435 lines
13 KiB
Go
435 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"log/slog"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"path/filepath"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/yourusername/caldav-server/internal/auth"
|
|
"github.com/yourusername/caldav-server/internal/caldav"
|
|
"github.com/yourusername/caldav-server/internal/carddav"
|
|
"github.com/yourusername/caldav-server/internal/config"
|
|
"github.com/yourusername/caldav-server/internal/db"
|
|
"github.com/yourusername/caldav-server/internal/store"
|
|
"github.com/yourusername/caldav-server/internal/web"
|
|
filewebdav "github.com/yourusername/caldav-server/internal/webdav"
|
|
webstatic "github.com/yourusername/caldav-server/web"
|
|
)
|
|
|
|
func main() {
|
|
var cfgPath string
|
|
flag.StringVar(&cfgPath, "config", "config.yaml", "path to configuration file")
|
|
flag.Parse()
|
|
|
|
// ---- Configuration ----
|
|
cfg, err := config.Load(cfgPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error loading config: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// ---- Logging ----
|
|
logger := buildLogger(cfg)
|
|
logger.Info("starting DAV server",
|
|
"host", cfg.Server.Host,
|
|
"port", cfg.Server.Port,
|
|
"base_url", cfg.Server.BaseURL,
|
|
"tls", cfg.TLS.Enabled)
|
|
|
|
// ---- Storage ----
|
|
st, err := store.NewStore(cfg.Storage.DataDir)
|
|
if err != nil {
|
|
logger.Error("initialising store", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// ---- Database (users, calendars, address books, sharing) ----
|
|
dbPath := filepath.Join(cfg.Storage.DataDir, "nidus.db")
|
|
dbase, err := db.Open(dbPath)
|
|
if err != nil {
|
|
logger.Error("initialising database", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
defer dbase.Close()
|
|
|
|
if n, err := dbase.UserCount(); err != nil {
|
|
logger.Error("counting users", "error", err)
|
|
os.Exit(1)
|
|
} else if n == 0 {
|
|
logger.Warn("no users exist yet — create one with: nidusctl user create <username>")
|
|
}
|
|
|
|
// Pre-create on-disk collections for every registered calendar/address
|
|
// book, in case they were added via nidusctl/web UI while the server
|
|
// wasn't running.
|
|
users, err := dbase.ListUsers()
|
|
if err != nil {
|
|
logger.Error("listing users", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
for _, user := range users {
|
|
cals, err := dbase.ListCalendars(user.Username)
|
|
if err != nil {
|
|
logger.Warn("listing calendars", "user", user.Username, "error", err)
|
|
continue
|
|
}
|
|
for _, cal := range cals {
|
|
// Check if we're using the old format and auto-migrate it
|
|
if err := st.EnsureCollection(user.Username, "calendars/"+cal.Name); err != nil {
|
|
logger.Warn("creating calendar collection", "user", user.Username, "cal", cal.Name, "error", err)
|
|
}
|
|
}
|
|
books, err := dbase.ListAddressBooks(user.Username)
|
|
if err != nil {
|
|
logger.Warn("listing address books", "user", user.Username, "error", err)
|
|
continue
|
|
}
|
|
for _, book := range books {
|
|
// Check if we're using the old format and auto-migrate it
|
|
if err := st.EnsureCollection(user.Username, "addressbooks/"+book); err != nil {
|
|
logger.Warn("creating address book collection", "user", user.Username, "book", book, "error", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Auto-migrate old data structures if they exist
|
|
migrateOldPaths(st, cfg.Storage.DataDir, logger)
|
|
|
|
// ---- Middleware ----
|
|
authMw := auth.NewMiddleware(cfg, dbase, logger)
|
|
|
|
// ---- Handlers ----
|
|
calHandler := caldav.NewHandler(cfg, st, dbase, logger)
|
|
cardHandler := carddav.NewHandler(cfg, st, dbase, logger)
|
|
fileHandler := filewebdav.NewHandler(cfg, cfg.Storage.DataDir, logger)
|
|
webUI := web.NewServer(cfg, st, dbase, logger)
|
|
|
|
mux := buildMux(cfg, authMw, calHandler, cardHandler, fileHandler, webUI, logger)
|
|
|
|
// ---- HTTP Server ----
|
|
addr := net.JoinHostPort(cfg.Server.Host, fmt.Sprintf("%d", cfg.Server.Port))
|
|
srv := &http.Server{
|
|
Addr: addr,
|
|
Handler: withRequestLogging(mux, logger),
|
|
ReadTimeout: 30 * time.Second,
|
|
WriteTimeout: 30 * time.Second,
|
|
IdleTimeout: 120 * time.Second,
|
|
}
|
|
|
|
// ---- Graceful shutdown ----
|
|
idleConnsClosed := make(chan struct{})
|
|
go func() {
|
|
quit := make(chan os.Signal, 1)
|
|
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
|
|
<-quit
|
|
|
|
logger.Info("shutting down...")
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(ctx); err != nil {
|
|
logger.Error("graceful shutdown failed", "error", err)
|
|
}
|
|
close(idleConnsClosed)
|
|
}()
|
|
|
|
logger.Info("server ready", "addr", addr)
|
|
if cfg.TLS.Enabled {
|
|
err = srv.ListenAndServeTLS(cfg.TLS.CertFile, cfg.TLS.KeyFile)
|
|
} else {
|
|
err = srv.ListenAndServe()
|
|
}
|
|
if err != nil && err != http.ErrServerClosed {
|
|
logger.Error("server error", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
<-idleConnsClosed
|
|
logger.Info("server stopped")
|
|
}
|
|
|
|
// buildMux creates the top-level HTTP multiplexer.
|
|
func buildMux(
|
|
cfg *config.Config,
|
|
authMw *auth.Middleware,
|
|
calHandler, cardHandler, fileHandler http.Handler,
|
|
webUI *web.Server,
|
|
logger *slog.Logger,
|
|
) *http.ServeMux {
|
|
mux := http.NewServeMux()
|
|
|
|
// Web UI (own cookie-based auth, not Basic Auth) — dashboard, login,
|
|
// share management. Mounted at "/web/"; /cal/, /card/, /files/ keep
|
|
// their own dedicated prefixes.
|
|
mux.Handle("/web/", http.StripPrefix("/web", webUI.Handler(webstatic.FS())))
|
|
|
|
// /.well-known/ redirects for auto-discovery
|
|
mux.HandleFunc("/.well-known/caldav", func(w http.ResponseWriter, r *http.Request) {
|
|
http.Redirect(w, r, cfg.Server.BaseURL+"/cal/", http.StatusMovedPermanently)
|
|
})
|
|
mux.HandleFunc("/.well-known/carddav", func(w http.ResponseWriter, r *http.Request) {
|
|
http.Redirect(w, r, cfg.Server.BaseURL+"/card/", http.StatusMovedPermanently)
|
|
})
|
|
|
|
// Health check (unauthenticated)
|
|
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte(`{"status":"ok"}`))
|
|
})
|
|
|
|
// CalDAV, CardDAV, and file WebDAV — all behind Basic Auth
|
|
mux.Handle("/cal/", authMw.Wrap(calHandler))
|
|
mux.Handle("/card/", authMw.Wrap(cardHandler))
|
|
mux.Handle("/files/", authMw.Wrap(fileHandler))
|
|
|
|
// Root — simple HTML welcome page (unauthenticated)
|
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/" {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
// Only plain GET/HEAD get the welcome page. Any other method
|
|
// (PROPFIND, LOCK, PUT, ...) hitting "/" means a client is pointed
|
|
// at the wrong URL — reject it explicitly instead of returning a
|
|
// misleading 200 OK, which breaks WebDAV clients expecting 207.
|
|
if r.Method != http.MethodGet && r.Method != http.MethodHead {
|
|
w.Header().Set("Allow", "GET, HEAD")
|
|
http.Error(w, "not a WebDAV collection; use /cal/, /card/ or /files/", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
fmt.Fprintf(w, welcomePage, cfg.Server.BaseURL, cfg.Server.BaseURL, cfg.Server.BaseURL, cfg.Server.BaseURL, cfg.Server.BaseURL)
|
|
})
|
|
|
|
return mux
|
|
}
|
|
|
|
// withRequestLogging wraps a handler with access-log middleware.
|
|
func withRequestLogging(next http.Handler, logger *slog.Logger) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
rw := &responseWriter{ResponseWriter: w, code: http.StatusOK}
|
|
next.ServeHTTP(rw, r)
|
|
logger.Info("request",
|
|
"method", r.Method,
|
|
"path", r.URL.Path,
|
|
"status", rw.code,
|
|
"duration_ms", time.Since(start).Milliseconds(),
|
|
"remote_addr", r.RemoteAddr,
|
|
)
|
|
})
|
|
}
|
|
|
|
// responseWriter captures the status code for logging.
|
|
type responseWriter struct {
|
|
http.ResponseWriter
|
|
code int
|
|
}
|
|
|
|
func (rw *responseWriter) WriteHeader(code int) {
|
|
rw.code = code
|
|
rw.ResponseWriter.WriteHeader(code)
|
|
}
|
|
|
|
// buildLogger creates a slog.Logger based on config.
|
|
func buildLogger(cfg *config.Config) *slog.Logger {
|
|
level := slog.LevelInfo
|
|
switch cfg.Logging.Level {
|
|
case "debug":
|
|
level = slog.LevelDebug
|
|
case "warn":
|
|
level = slog.LevelWarn
|
|
case "error":
|
|
level = slog.LevelError
|
|
}
|
|
|
|
var handler slog.Handler
|
|
opts := &slog.HandlerOptions{Level: level}
|
|
if cfg.Logging.Format == "json" {
|
|
handler = slog.NewJSONHandler(os.Stdout, opts)
|
|
} else {
|
|
handler = slog.NewTextHandler(os.Stdout, opts)
|
|
}
|
|
return slog.New(handler)
|
|
}
|
|
|
|
const welcomePage = `<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head><meta charset="UTF-8"><title>DAV Server</title>
|
|
<style>
|
|
body { font-family: system-ui, sans-serif; max-width: 640px; margin: 4rem auto; padding: 0 1rem; }
|
|
h1 { color: #333; }
|
|
code { background: #f4f4f4; padding: 2px 6px; border-radius: 3px; }
|
|
ul { line-height: 2; }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<h1>🗓 DAV Server</h1>
|
|
<p>This server provides CalDAV, CardDAV, and WebDAV access.</p>
|
|
<h2>Endpoints</h2>
|
|
<ul>
|
|
<li><strong>CalDAV</strong> — <code>%s/cal/</code></li>
|
|
<li><strong>CardDAV</strong> — <code>%s/card/</code></li>
|
|
<li><strong>WebDAV files</strong> — <code>%s/files/</code></li>
|
|
</ul>
|
|
<h2>Auto-discovery</h2>
|
|
<ul>
|
|
<li><code>%s/.well-known/caldav</code></li>
|
|
<li><code>%s/.well-known/carddav</code></li>
|
|
</ul>
|
|
<p><em>Authentication: HTTP Basic Auth</em></p>
|
|
<p><a href="/web/">Open the web dashboard →</a></p>
|
|
</body>
|
|
</html>`
|
|
|
|
// migrateOldPaths automatically migrates data from old to new directory structures
|
|
func migrateOldPaths(st *store.Store, dataDir string, logger *slog.Logger) {
|
|
logger.Info("Checking for legacy data structure...")
|
|
|
|
// List all user directories in the data dir (excluding files/)
|
|
users, err := os.ReadDir(dataDir)
|
|
if err != nil {
|
|
logger.Warn("Failed to read data directory", "error", err)
|
|
return
|
|
}
|
|
|
|
for _, user := range users {
|
|
if user.Name() == "files" || !user.IsDir() {
|
|
continue
|
|
}
|
|
|
|
userDir := filepath.Join(dataDir, user.Name())
|
|
|
|
// Check for old calendar collections (cal-*)
|
|
cals, err := os.ReadDir(userDir)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
for _, cal := range cals {
|
|
if strings.HasPrefix(cal.Name(), "cal-") {
|
|
oldPath := filepath.Join(userDir, cal.Name())
|
|
|
|
// Create new directory structure
|
|
newPath := filepath.Join(userDir, "calendars", cal.Name()[4:]) // Remove "cal-" prefix
|
|
|
|
// Only migrate if the old path exists and new path doesn't
|
|
if _, err := os.Stat(oldPath); err == nil {
|
|
if _, err := os.Stat(newPath); os.IsNotExist(err) {
|
|
logger.Info("Migrating calendar", "user", user.Name(), "from", oldPath, "to", newPath)
|
|
if err := os.MkdirAll(filepath.Dir(newPath), 0755); err != nil {
|
|
logger.Warn("Failed to create directory for migration", "path", newPath, "error", err)
|
|
continue
|
|
}
|
|
|
|
// Move files
|
|
if err := moveDirContent(oldPath, newPath); err != nil {
|
|
logger.Warn("Failed to migrate calendar", "user", user.Name(), "error", err)
|
|
} else {
|
|
logger.Info("Migration complete", "user", user.Name(), "calendar", cal.Name())
|
|
}
|
|
}
|
|
}
|
|
} else if strings.HasPrefix(cal.Name(), "card-") {
|
|
oldPath := filepath.Join(userDir, cal.Name())
|
|
|
|
// Create new directory structure
|
|
newPath := filepath.Join(userDir, "addressbooks", cal.Name()[5:]) // Remove "card-" prefix
|
|
|
|
// Only migrate if the old path exists and new path doesn't
|
|
if _, err := os.Stat(oldPath); err == nil {
|
|
if _, err := os.Stat(newPath); os.IsNotExist(err) {
|
|
logger.Info("Migrating address book", "user", user.Name(), "from", oldPath, "to", newPath)
|
|
if err := os.MkdirAll(filepath.Dir(newPath), 0755); err != nil {
|
|
logger.Warn("Failed to create directory for migration", "path", newPath, "error", err)
|
|
continue
|
|
}
|
|
|
|
// Move files
|
|
if err := moveDirContent(oldPath, newPath); err != nil {
|
|
logger.Warn("Failed to migrate address book", "user", user.Name(), "error", err)
|
|
} else {
|
|
logger.Info("Migration complete", "user", user.Name(), "addressbook", cal.Name())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Migrate WebDAV files from old flat structure (dataDir/files/<username>/)
|
|
// to new nested structure (dataDir/<username>/files/)
|
|
filesRoot := filepath.Join(dataDir, "files")
|
|
if _, err := os.Stat(filesRoot); err == nil {
|
|
if entries, er := os.ReadDir(filesRoot); er == nil {
|
|
for _, entry := range entries {
|
|
if !entry.IsDir() {
|
|
continue
|
|
}
|
|
username := entry.Name()
|
|
oldWebdavPath := filepath.Join(filesRoot, username)
|
|
newUserDir := filepath.Join(dataDir, username)
|
|
newWebdavPath := filepath.Join(newUserDir, "files")
|
|
|
|
if _, e := os.Stat(oldWebdavPath); e != nil {
|
|
continue
|
|
}
|
|
if _, e := os.Stat(newWebdavPath); !os.IsNotExist(e) {
|
|
continue
|
|
}
|
|
|
|
logger.Info("Migrating webdav files", "user", username, "from", oldWebdavPath, "to", newWebdavPath)
|
|
if mkErr := os.MkdirAll(filepath.Dir(newWebdavPath), 0755); mkErr != nil {
|
|
logger.Warn("Failed to create directory for webdav migration", "path", newWebdavPath, "error", mkErr)
|
|
continue
|
|
}
|
|
if mvErr := moveDirContent(oldWebdavPath, newWebdavPath); mvErr != nil {
|
|
logger.Warn("Failed to migrate webdav files", "user", username, "error", mvErr)
|
|
} else {
|
|
logger.Info("webdav files migration complete", "user", username)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
logger.Info("Legacy structure check complete")
|
|
}
|
|
|
|
// moveDirContent moves all files from src to dst directory
|
|
func moveDirContent(src, dst string) error {
|
|
srcEntries, err := os.ReadDir(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, entry := range srcEntries {
|
|
srcPath := filepath.Join(src, entry.Name())
|
|
dstPath := filepath.Join(dst, entry.Name())
|
|
|
|
if entry.IsDir() {
|
|
if err := os.MkdirAll(dstPath, 0755); err != nil {
|
|
return err
|
|
}
|
|
if err := moveDirContent(srcPath, dstPath); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if err := os.Rename(srcPath, dstPath); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove the old dir
|
|
return os.Remove(src)
|
|
}
|