Files
pages/internal/server/dav_credentials.go
T
Anya Tokugawa 19e12f96a8
Build and publish container images / images (push) Successful in 13m39s
Release container images / release (push) Successful in 18s
Add private CardDAV synchronization and contact revision recovery
2026-11-02 08:41:15 +09:00

158 lines
5.1 KiB
Go

package server
import (
"encoding/xml"
"net/http"
"strings"
mw "pageswiki/internal/server/middleware"
)
func (s *Server) davActor(w http.ResponseWriter, r *http.Request, requested string, anonymous bool) (actor string, write bool, scope, credential string, ok bool) {
scope = "all"
if len(r.Header.Values("Authorization")) > 1 {
mw.SetDAVAuthOutcome(r, "multiple_authorization")
w.WriteHeader(401)
return
}
if id, secret, basic := r.BasicAuth(); basic {
var err error
actor, write, scope, err = s.store.AuthenticateDAV(r.Context(), s.domainUUIDForRequest(r), id, secret, requested)
if err == nil {
mw.SetDAVAuthOutcome(r, "basic_accepted")
return actor, write, scope, id, true
}
mw.SetDAVAuthOutcome(r, "basic_rejected")
} else {
actor, write = s.calendarActor(r)
if actor != "" || anonymous && r.Header.Get("Authorization") == "" {
if actor != "" {
mw.SetDAVAuthOutcome(r, "session_accepted")
} else {
mw.SetDAVAuthOutcome(r, "anonymous")
}
return actor, write, scope, "", true
}
if r.Header.Get("Authorization") == "" {
mw.SetDAVAuthOutcome(r, "missing")
} else {
mw.SetDAVAuthOutcome(r, "invalid_authorization")
}
}
w.Header().Set("WWW-Authenticate", `Basic realm="PagesWiki CalDAV", charset="UTF-8"`)
if requested == "contacts" {
w.Header().Set("WWW-Authenticate", `Basic realm="PagesWiki CardDAV", charset="UTF-8"`)
}
w.WriteHeader(401)
return
}
func (s *Server) handleDAVHome(w http.ResponseWriter, r *http.Request) {
domain := s.domainUUIDForRequest(r)
tasks := s.systemExtensionEnabled(domain, "organizer.tasks")
calendars := s.systemExtensionEnabled(domain, "organizer.calendar")
if !tasks && !calendars {
http.NotFound(w, r)
return
}
actor, writable, scope, credential, ok := s.davActor(w, r, "", false)
if !ok {
return
}
s.setDAVCapabilities(w, r, actor, credential)
w.Header().Set("Allow", "OPTIONS, PROPFIND")
if r.Method == "OPTIONS" {
w.WriteHeader(204)
return
}
if r.Method != "PROPFIND" {
w.WriteHeader(405)
return
}
if depth := r.Header.Get("Depth"); depth != "0" && depth != "1" {
http.Error(w, "Depth 0 or 1 required", 403)
return
}
n, err := readDAV(w, r)
if err != nil || n.XMLName.Local != "" && n.XMLName != (xml.Name{Space: davNS, Local: "propfind"}) {
http.Error(w, "invalid PROPFIND", 400)
return
}
var req []davNode
if p := n.child(davNS, "prop"); p != nil {
req = p.Children
}
rows := []davResponse{{href: calendarDAV, props: map[xml.Name]string{
{Space: davNS, Local: "resourcetype"}: "<d:collection/><d:principal/>",
{Space: davNS, Local: "displayname"}: "PagesWiki CalDAV",
{Space: davNS, Local: "current-user-principal"}: "<d:href>" + calendarDAV + "</d:href>",
{Space: davNS, Local: "principal-URL"}: "<d:href>" + calendarDAV + "</d:href>",
{Space: calNS, Local: "calendar-home-set"}: "<d:href>" + calendarDAV + "</d:href>",
}}}
rows[0].props[xml.Name{Space: davNS, Local: "current-user-privilege-set"}] = davPrivileges(false)
if writable && tasks && (scope == "tasks" || scope == "all") {
rows[0].props[xml.Name{Space: davNS, Local: "current-user-privilege-set"}] += "<d:privilege><d:bind/></d:privilege>"
}
if r.Header.Get("Depth") == "1" {
if calendars && (scope == "calendar" || scope == "all") {
repo, err := s.calendars()
if err != nil {
calendarError(w, err)
return
}
items, err := repo.List(domain, actor)
if err != nil {
calendarError(w, err)
return
}
for _, c := range items {
row := calendarDAVRow(c)
row.props[xml.Name{Space: davNS, Local: "current-user-privilege-set"}] = davPrivileges(writable && c.CanWrite(actor))
rows = append(rows, row)
}
}
if tasks && (scope == "tasks" || scope == "all") {
row := taskDAVCollectionRow()
title, err := s.store.TaskDAVDefaultTitle(r.Context(), domain, actor)
if err != nil {
taskError(w, err)
return
}
row.props[xml.Name{Space: davNS, Local: "displayname"}] = xmlText(title)
row.props[xml.Name{Space: davNS, Local: "current-user-privilege-set"}] = davPrivileges(writable)
rows = append(rows, row)
if !s.appendTaskDAVCollections(w, r, domain, actor, writable, &rows) {
return
}
}
}
writeDAV(w, rows, req)
}
func davPrivileges(write bool) string {
value := "<d:privilege><d:read/></d:privilege>"
if write {
value += "<d:privilege><d:write/></d:privilege>"
}
return value
}
func (s *Server) handleDAVCredentials(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Cache-Control", "private, no-store")
domain := s.domainUUIDForRequest(r)
if !s.systemExtensionEnabled(domain, "organizer.tasks") && !s.systemExtensionEnabled(domain, "organizer.calendar") && !s.systemExtensionEnabled(domain, "organizer.contacts") {
http.NotFound(w, r)
return
}
actor, _ := s.calendarActor(r) // Basic DAV secrets cannot issue/revoke credentials.
if actor == "" {
s.authRequired(w, r)
return
}
parts := []string{"dav-credentials"}
if r.URL.Path != davCredentialsAPI {
parts = append(parts, strings.Split(strings.TrimPrefix(r.URL.Path, davCredentialsAPI+"/"), "/")...)
}
s.handleTaskDAVCredentials(w, r, actor, parts)
}