158 lines
5.1 KiB
Go
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)
|
|
}
|