package server
import (
"bytes"
"context"
"encoding/xml"
"errors"
"io"
"net/http"
"net/url"
"pageswiki/internal/calendar"
"path"
"strings"
"time"
)
type calendarAuthTransport struct {
base http.RoundTripper
origin, user, password string
}
func (t calendarAuthTransport) RoundTrip(r *http.Request) (*http.Response, error) {
origin, e := url.Parse(t.origin)
if e != nil || !strings.EqualFold(origin.Host, r.URL.Host) || origin.Scheme != r.URL.Scheme {
return nil, errors.New("calendar credential origin mismatch")
}
clone := r.Clone(r.Context())
clone.SetBasicAuth(t.user, t.password)
return t.base.RoundTrip(clone)
}
type remoteCalendarObject struct{ href, etag, data string }
func remoteCalendarReport(ctx context.Context, client *http.Client, address, body string) ([]remoteCalendarObject, error) {
req, e := http.NewRequestWithContext(ctx, "REPORT", address, strings.NewReader(body))
if e != nil {
return nil, errors.New("invalid CalDAV URL")
}
req.Header.Set("Content-Type", "application/xml; charset=utf-8")
req.Header.Set("Depth", "1")
response, e := client.Do(req)
if e != nil {
return nil, calendarSourceRequestError(e)
}
defer response.Body.Close()
if response.StatusCode != 207 {
return nil, errors.New("external CalDAV REPORT returned " + http.StatusText(response.StatusCode))
}
b, e := io.ReadAll(io.LimitReader(response.Body, calendar.MaxFeed+1))
if e != nil || len(b) > calendar.MaxFeed {
return nil, calendar.ErrLimit
}
dec := xml.NewDecoder(bytes.NewReader(b))
depth, count := 0, 0
for {
token, e := dec.Token()
if e == io.EOF {
break
}
if e != nil {
return nil, errors.New("invalid CalDAV XML")
}
switch token.(type) {
case xml.Directive:
return nil, errors.New("CalDAV DTD rejected")
case xml.StartElement:
depth++
count++
if depth > 16 || count > 100000 {
return nil, calendar.ErrLimit
}
case xml.EndElement:
depth--
}
}
var root davNode
if xml.Unmarshal(b, &root) != nil || root.XMLName.Space != davNS || root.XMLName.Local != "multistatus" {
return nil, errors.New("invalid CalDAV multistatus")
}
origin, _ := url.Parse(address)
prefix := strings.TrimSuffix(path.Clean(origin.Path), "/") + "/"
seen := map[string]bool{}
out := []remoteCalendarObject{}
for _, row := range root.Children {
if row.XMLName.Space != davNS || row.XMLName.Local != "response" {
return nil, errors.New("unsupported CalDAV report response")
}
href := row.child(davNS, "href")
if href == nil {
return nil, errors.New("CalDAV href missing")
}
u, e := url.Parse(strings.TrimSpace(href.Text))
if e != nil {
return nil, errors.New("invalid CalDAV href")
}
u = origin.ResolveReference(u)
if !strings.EqualFold(u.Host, origin.Host) || u.Scheme != origin.Scheme || u.User != nil || u.RawQuery != "" || u.Fragment != "" || !strings.HasPrefix(path.Clean(u.Path), prefix) {
return nil, errors.New("CalDAV href outside collection")
}
key := u.EscapedPath()
if seen[key] {
return nil, errors.New("duplicate CalDAV href")
}
seen[key] = true
item := remoteCalendarObject{href: key}
for _, ps := range row.Children {
if ps.XMLName.Space == davNS && ps.XMLName.Local == "status" {
return nil, errors.New("incomplete CalDAV report")
}
if ps.XMLName.Space != davNS || ps.XMLName.Local != "propstat" {
continue
}
status := ps.child(davNS, "status")
props := ps.child(davNS, "prop")
if status == nil || props == nil || !strings.Contains(status.Text, " 200 ") {
return nil, errors.New("CalDAV property unavailable")
}
if tag := props.child(davNS, "getetag"); tag != nil {
item.etag = tag.Text
}
if data := props.child(calNS, "calendar-data"); data != nil {
item.data = data.Text
}
}
if item.etag == "" {
return nil, errors.New("CalDAV ETag missing")
}
out = append(out, item)
if len(out) > 5000 {
return nil, calendar.ErrLimit
}
}
return out, nil
}
// Materialize a bounded read-only window: 90 days back, 275 days forward.
// REPORT fetches validators; calendar-multiget retrieves only changed resources.
func fetchCalDAVSource(ctx context.Context, client *http.Client, repo *calendar.Repository, domain string, c calendar.Calendar) ([]calendar.Event, map[string]calendar.RemoteResource, error) {
start := time.Now().UTC().Truncate(24*time.Hour).AddDate(0, 0, -90)
end := start.AddDate(0, 0, 365)
query := ``
rows, e := remoteCalendarReport(ctx, client, c.Source.URL, query)
if e != nil {
return nil, nil, e
}
result := []calendar.Event{}
resources := map[string]calendar.RemoteResource{}
missing := []remoteCalendarObject{}
uids := map[string]bool{}
totalBytes := 0
add := func(row remoteCalendarObject, event calendar.Event) error {
totalBytes += len(event.Data)
if totalBytes > calendar.MaxFeed {
return calendar.ErrLimit
}
if uids[event.UID] {
return errors.New("CalDAV contains duplicate UID or recurrence exceptions")
}
uids[event.UID] = true
result = append(result, event)
resources[row.href] = calendar.RemoteResource{UID: event.UID, ETag: row.etag}
return nil
}
for _, row := range rows {
old, ok := c.Source.Resources[row.href]
if ok && old.ETag == row.etag {
event, e := repo.Event(ctx, domain, c.ID, c.Owner, old.UID)
if e == nil {
if e = add(row, event); e != nil {
return nil, nil, e
}
continue
}
if !errors.Is(e, calendar.ErrMissing) {
return nil, nil, e
}
}
missing = append(missing, row)
}
for offset := 0; offset < len(missing); offset += 100 {
limit := offset + 100
if limit > len(missing) {
limit = len(missing)
}
wanted := map[string]string{}
var body strings.Builder
body.WriteString(``)
for _, row := range missing[offset:limit] {
wanted[row.href] = row.etag
body.WriteString("" + xmlText(row.href) + "")
}
body.WriteString("")
batch, e := remoteCalendarReport(ctx, client, c.Source.URL, body.String())
if e != nil {
return nil, nil, e
}
if len(batch) != len(wanted) {
return nil, nil, errors.New("incomplete CalDAV multiget")
}
for _, row := range batch {
tag, ok := wanted[row.href]
if !ok || tag != row.etag {
return nil, nil, errors.New("CalDAV changed during synchronization; retry required")
}
event, e := calendar.Parse(row.data)
if e != nil {
return nil, nil, e
}
if e = add(row, event); e != nil {
return nil, nil, e
}
}
}
return result, resources, nil
}