Add private CardDAV synchronization and contact revision recovery
This commit is contained in:
1 parent
433169c7e7
commit
19e12f96a8
32 files changed
+1855
-47
No files matched your search
@@ -79,21 +79,25 @@ func readDAV(w http.ResponseWriter, r *http.Request) (davNode, error) {
|
||||
func xmlText(s string) string { var b bytes.Buffer; xml.EscapeText(&b, []byte(s)); return b.String() }
|
||||
|
||||
type davResponse struct {
|
||||
href string
|
||||
props map[xml.Name]string
|
||||
status int
|
||||
href string
|
||||
props map[xml.Name]string
|
||||
status int
|
||||
errorXML string
|
||||
}
|
||||
|
||||
func davProperty(ns, key, value string) (xml.Name, string) {
|
||||
return xml.Name{Space: ns, Local: key}, value
|
||||
}
|
||||
func writeDAV(w http.ResponseWriter, rows []davResponse, requested []davNode) {
|
||||
func writeDAV(w http.ResponseWriter, rows []davResponse, requested []davNode, syncToken ...string) {
|
||||
var b strings.Builder
|
||||
b.WriteString(`<?xml version="1.0" encoding="UTF-8"?><d:multistatus xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">`)
|
||||
b.WriteString(`<?xml version="1.0" encoding="UTF-8"?><d:multistatus xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:a="urn:ietf:params:xml:ns:carddav">`)
|
||||
for _, row := range rows {
|
||||
b.WriteString("<d:response><d:href>" + xmlText(row.href) + "</d:href>")
|
||||
if row.status != 0 {
|
||||
fmt.Fprintf(&b, "<d:status>HTTP/1.1 %d %s</d:status>", row.status, http.StatusText(row.status))
|
||||
if row.errorXML != "" {
|
||||
b.WriteString("<d:error>" + row.errorXML + "</d:error>")
|
||||
}
|
||||
} else {
|
||||
present, missing := strings.Builder{}, strings.Builder{}
|
||||
props := requested
|
||||
@@ -122,6 +126,9 @@ func writeDAV(w http.ResponseWriter, rows []davResponse, requested []davNode) {
|
||||
}
|
||||
b.WriteString("</d:response>")
|
||||
}
|
||||
if len(syncToken) == 1 {
|
||||
b.WriteString("<d:sync-token>" + xmlText(syncToken[0]) + "</d:sync-token>")
|
||||
}
|
||||
b.WriteString("</d:multistatus>")
|
||||
w.Header().Set("Content-Type", "application/xml; charset=utf-8")
|
||||
w.WriteHeader(207)
|
||||
|
||||
@@ -0,0 +1,586 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"io"
|
||||
"mime"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode"
|
||||
|
||||
"golang.org/x/text/unicode/norm"
|
||||
|
||||
"pageswiki/internal/store"
|
||||
)
|
||||
|
||||
const contactDAV = "/_/api/v1/carddav/"
|
||||
const cardNS = "urn:ietf:params:xml:ns:carddav"
|
||||
|
||||
func contactDAVRoute(p string) bool {
|
||||
return p == strings.TrimSuffix(contactDAV, "/") || strings.HasPrefix(p, contactDAV) || p == "/.well-known/carddav"
|
||||
}
|
||||
func contactDAVError(w http.ResponseWriter, status int, ns, condition string) {
|
||||
w.Header().Set("Content-Type", "application/xml; charset=utf-8")
|
||||
w.WriteHeader(status)
|
||||
io.WriteString(w, `<?xml version="1.0"?><d:error xmlns:d="DAV:"><p:`+condition+` xmlns:p="`+xmlText(ns)+`"/></d:error>`)
|
||||
}
|
||||
func contactDAVStoreError(w http.ResponseWriter, err error) {
|
||||
switch {
|
||||
case errors.Is(err, sql.ErrNoRows):
|
||||
w.WriteHeader(404)
|
||||
case errors.Is(err, store.ErrTaskConflict):
|
||||
w.WriteHeader(412)
|
||||
case errors.Is(err, store.ErrContactUIDConflict):
|
||||
contactDAVError(w, 403, cardNS, "no-uid-conflict")
|
||||
case errors.Is(err, store.ErrContactSyncToken):
|
||||
contactDAVError(w, 403, davNS, "valid-sync-token")
|
||||
case errors.Is(err, store.ErrAccessDenied):
|
||||
w.WriteHeader(403)
|
||||
case errors.Is(err, store.ErrTaskInvalid):
|
||||
contactDAVError(w, 403, cardNS, "valid-address-data")
|
||||
default:
|
||||
http.Error(w, "address book operation failed", 500)
|
||||
}
|
||||
}
|
||||
func contactDAVRow(base string, item store.ContactDAVItem) davResponse {
|
||||
row := davResponse{href: base + item.Name}
|
||||
if item.Deleted {
|
||||
row.status = 404
|
||||
return row
|
||||
}
|
||||
size := len(item.VCard)
|
||||
if item.Size > 0 {
|
||||
size = item.Size
|
||||
}
|
||||
row.props = map[xml.Name]string{
|
||||
{Space: davNS, Local: "getetag"}: xmlText(store.ContactETag(item.Contact)),
|
||||
{Space: davNS, Local: "resourcetype"}: "",
|
||||
{Space: davNS, Local: "getcontenttype"}: "text/vcard; charset=utf-8",
|
||||
{Space: davNS, Local: "getcontentlength"}: strconv.Itoa(size),
|
||||
{Space: cardNS, Local: "address-data"}: xmlText(item.VCard),
|
||||
}
|
||||
return row
|
||||
}
|
||||
func contactBookRow(base, token string, writable bool) davResponse {
|
||||
return davResponse{href: base, props: map[xml.Name]string{
|
||||
{Space: davNS, Local: "displayname"}: "PagesWiki Contacts",
|
||||
{Space: davNS, Local: "resourcetype"}: "<d:collection/><a:addressbook/>",
|
||||
{Space: davNS, Local: "current-user-privilege-set"}: davPrivileges(writable),
|
||||
{Space: davNS, Local: "sync-token"}: xmlText(token),
|
||||
{Space: "http://calendarserver.org/ns/", Local: "getctag"}: xmlText(token),
|
||||
{Space: cardNS, Local: "addressbook-description"}: "Private contacts",
|
||||
{Space: cardNS, Local: "max-resource-size"}: "65536",
|
||||
{Space: cardNS, Local: "supported-address-data"}: `<a:address-data-type content-type="text/vcard" version="3.0"/><a:address-data-type content-type="text/vcard" version="4.0"/>`,
|
||||
{Space: cardNS, Local: "supported-collation-set"}: `<a:supported-collation>i;unicode-casemap</a:supported-collation><a:supported-collation>i;octet</a:supported-collation>`,
|
||||
{Space: davNS, Local: "supported-report-set"}: `<d:supported-report><d:report><a:addressbook-query/></d:report></d:supported-report><d:supported-report><d:report><a:addressbook-multiget/></d:report></d:supported-report><d:supported-report><d:report><d:sync-collection/></d:report></d:supported-report>`,
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *Server) handleContactDAV(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
|
||||
defer cancel()
|
||||
r = r.WithContext(ctx)
|
||||
w.Header().Set("Cache-Control", "private, no-store")
|
||||
domain := s.domainUUIDForRequest(r)
|
||||
if !s.systemExtensionEnabled(domain, "organizer.contacts") {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
if r.URL.Path == "/.well-known/carddav" {
|
||||
w.Header().Set("Location", contactDAV)
|
||||
w.WriteHeader(307)
|
||||
return
|
||||
}
|
||||
actor, writable, _, credential, ok := s.davActor(w, r, "contacts", false)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
// davActor authenticates the principal; storage rechecks active membership,
|
||||
// ownership and the extension switch even on reads.
|
||||
snapshot, err := s.store.ContactDAVSnapshot(ctx, domain, actor, "", 0)
|
||||
if err != nil {
|
||||
contactDAVStoreError(w, err)
|
||||
return
|
||||
}
|
||||
principal := contactDAV + actor + "/"
|
||||
book := principal + "contacts/"
|
||||
p := r.URL.Path
|
||||
root := p == contactDAV || p == strings.TrimSuffix(contactDAV, "/")
|
||||
home := p == principal || p == strings.TrimSuffix(principal, "/")
|
||||
collection := p == book || p == strings.TrimSuffix(book, "/")
|
||||
name := ""
|
||||
if !root && !home && !collection {
|
||||
if !strings.HasPrefix(p, book) {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
name = strings.TrimPrefix(p, book)
|
||||
if !store.ValidContactDAVName(name) {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
}
|
||||
w.Header().Set("DAV", "1, addressbook-access")
|
||||
w.Header().Set("X-PagesWiki-CardDAV-Profile", "private-addressbook")
|
||||
allow := "OPTIONS, PROPFIND"
|
||||
if collection {
|
||||
allow += ", REPORT"
|
||||
}
|
||||
if name != "" {
|
||||
allow += ", GET, HEAD"
|
||||
if writable {
|
||||
allow += ", PUT, DELETE"
|
||||
}
|
||||
}
|
||||
w.Header().Set("Allow", allow)
|
||||
if r.Method == "OPTIONS" {
|
||||
w.WriteHeader(204)
|
||||
return
|
||||
}
|
||||
if r.Method == "PROPFIND" {
|
||||
depth := r.Header.Get("Depth")
|
||||
if depth != "0" && depth != "1" {
|
||||
contactDAVError(w, 403, davNS, "propfind-finite-depth")
|
||||
return
|
||||
}
|
||||
n, e := readDAV(w, r)
|
||||
if e != nil || n.XMLName.Local != "" && n.XMLName != (xml.Name{Space: davNS, Local: "propfind"}) {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
var requested []davNode
|
||||
if prop := n.child(davNS, "prop"); prop != nil {
|
||||
requested = prop.Children
|
||||
}
|
||||
if name != "" {
|
||||
c, e := s.store.ContactDAVResource(ctx, domain, actor, name)
|
||||
if e != nil {
|
||||
contactDAVStoreError(w, e)
|
||||
return
|
||||
}
|
||||
if c.Deleted {
|
||||
w.WriteHeader(404)
|
||||
return
|
||||
}
|
||||
row := contactDAVRow(book, store.ContactDAVItem{Contact: c, Name: name})
|
||||
delete(row.props, xml.Name{Space: cardNS, Local: "address-data"})
|
||||
writeDAV(w, []davResponse{row}, requested)
|
||||
return
|
||||
}
|
||||
var rows []davResponse
|
||||
if collection {
|
||||
rows = append(rows, contactBookRow(book, snapshot.Token, writable))
|
||||
if depth == "1" {
|
||||
data, e := s.store.ContactDAVInventory(ctx, domain, actor)
|
||||
if e != nil {
|
||||
contactDAVStoreError(w, e)
|
||||
return
|
||||
}
|
||||
if data.More {
|
||||
contactDAVError(w, 507, davNS, "number-of-matches-within-limits")
|
||||
return
|
||||
}
|
||||
for _, c := range data.Items {
|
||||
row := contactDAVRow(book, c)
|
||||
delete(row.props, xml.Name{Space: cardNS, Local: "address-data"})
|
||||
rows = append(rows, row)
|
||||
}
|
||||
rows[0] = contactBookRow(book, data.Token, writable)
|
||||
}
|
||||
} else {
|
||||
href := principal
|
||||
if root {
|
||||
href = contactDAV
|
||||
}
|
||||
rows = append(rows, davResponse{href: href, props: map[xml.Name]string{
|
||||
{Space: davNS, Local: "resourcetype"}: "<d:collection/><d:principal/>",
|
||||
{Space: davNS, Local: "displayname"}: "PagesWiki Contacts",
|
||||
{Space: davNS, Local: "current-user-principal"}: "<d:href>" + principal + "</d:href>",
|
||||
{Space: davNS, Local: "principal-URL"}: "<d:href>" + principal + "</d:href>",
|
||||
{Space: cardNS, Local: "addressbook-home-set"}: "<d:href>" + principal + "</d:href>",
|
||||
{Space: davNS, Local: "current-user-privilege-set"}: davPrivileges(false),
|
||||
}})
|
||||
if depth == "1" {
|
||||
rows = append(rows, contactBookRow(book, snapshot.Token, writable))
|
||||
}
|
||||
}
|
||||
writeDAV(w, rows, requested)
|
||||
return
|
||||
}
|
||||
if r.Method == "REPORT" && collection {
|
||||
s.contactDAVReport(w, r, domain, actor, book)
|
||||
return
|
||||
}
|
||||
if name == "" {
|
||||
w.WriteHeader(405)
|
||||
return
|
||||
}
|
||||
c, err := s.store.ContactDAVResource(ctx, domain, actor, name)
|
||||
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
||||
contactDAVStoreError(w, err)
|
||||
return
|
||||
}
|
||||
exists := err == nil && !c.Deleted
|
||||
if r.Method == "GET" || r.Method == "HEAD" {
|
||||
if !exists {
|
||||
w.WriteHeader(404)
|
||||
return
|
||||
}
|
||||
tag := store.ContactETag(c)
|
||||
w.Header().Set("ETag", tag)
|
||||
if contactETagMatch(r.Header.Get("If-None-Match"), tag, true) {
|
||||
w.WriteHeader(304)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "text/vcard; charset=utf-8")
|
||||
w.Header().Set("Content-Length", strconv.Itoa(len(c.VCard)))
|
||||
if r.Method == "GET" {
|
||||
io.WriteString(w, c.VCard)
|
||||
}
|
||||
return
|
||||
}
|
||||
if r.Method != "PUT" && r.Method != "DELETE" {
|
||||
w.WriteHeader(405)
|
||||
return
|
||||
}
|
||||
if !writable {
|
||||
w.WriteHeader(403)
|
||||
return
|
||||
}
|
||||
if r.Method == "DELETE" && !exists {
|
||||
w.WriteHeader(404)
|
||||
return
|
||||
}
|
||||
match, none := r.Header.Get("If-Match"), r.Header.Get("If-None-Match")
|
||||
if match != "" && none != "" {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
if match != "" && (!exists || !contactETagMatch(match, store.ContactETag(c), false)) || none != "" && exists && contactETagMatch(none, store.ContactETag(c), true) {
|
||||
w.WriteHeader(412)
|
||||
return
|
||||
}
|
||||
if exists && match == "" {
|
||||
w.WriteHeader(428)
|
||||
return
|
||||
}
|
||||
if !exists && match == "" && none != "*" {
|
||||
w.WriteHeader(428)
|
||||
return
|
||||
}
|
||||
raw := ""
|
||||
if r.Method == "PUT" {
|
||||
media, params, e := mime.ParseMediaType(r.Header.Get("Content-Type"))
|
||||
if e != nil || media != "text/vcard" && media != "text/x-vcard" || params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8") {
|
||||
contactDAVError(w, 415, cardNS, "supported-address-data")
|
||||
return
|
||||
}
|
||||
data, e := io.ReadAll(http.MaxBytesReader(w, r.Body, 65536))
|
||||
if e != nil {
|
||||
w.WriteHeader(413)
|
||||
return
|
||||
}
|
||||
raw = string(data)
|
||||
if values := store.ContactPropertyValues(store.Contact{VCard: raw}, "UID"); len(values) != 1 || values[0] == "" {
|
||||
contactDAVError(w, 403, cardNS, "valid-address-data")
|
||||
return
|
||||
}
|
||||
if v := params["version"]; v != "" {
|
||||
values := store.ContactPropertyValues(store.Contact{VCard: raw}, "VERSION")
|
||||
if len(values) != 1 || values[0] != v {
|
||||
contactDAVError(w, 415, cardNS, "supported-address-data")
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
saved, e := s.store.SaveContactDAV(ctx, domain, actor, credential, name, raw, c.Version, r.Method == "DELETE")
|
||||
if e != nil {
|
||||
contactDAVStoreError(w, e)
|
||||
return
|
||||
}
|
||||
if r.Method == "DELETE" {
|
||||
w.WriteHeader(204)
|
||||
return
|
||||
}
|
||||
// RFC 6352: a transformed PUT representation must be fetched again by client.
|
||||
if saved.VCard == raw {
|
||||
w.Header().Set("ETag", store.ContactETag(saved))
|
||||
}
|
||||
if exists {
|
||||
w.WriteHeader(204)
|
||||
} else {
|
||||
w.Header().Set("Location", book+name)
|
||||
w.WriteHeader(201)
|
||||
}
|
||||
}
|
||||
|
||||
func contactETagMatch(value, tag string, weak bool) bool {
|
||||
for _, v := range strings.Split(value, ",") {
|
||||
v = strings.TrimSpace(v)
|
||||
if weak {
|
||||
v = strings.TrimPrefix(v, "W/")
|
||||
}
|
||||
if v == "*" || v == tag {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (s *Server) contactDAVReport(w http.ResponseWriter, r *http.Request, domain, actor, book string) {
|
||||
if depth := r.Header.Get("Depth"); depth != "" && depth != "0" && depth != "1" {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
n, err := readDAV(w, r)
|
||||
if err != nil {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
prop := n.child(davNS, "prop")
|
||||
if prop == nil || len(prop.Children) == 0 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
for _, p := range prop.Children {
|
||||
if p.XMLName == (xml.Name{Space: cardNS, Local: "address-data"}) && (len(p.Children) > 0 || p.attr("content-type") != "" && p.attr("content-type") != "text/vcard" || p.attr("version") != "" && p.attr("version") != "3.0" && p.attr("version") != "4.0") {
|
||||
contactDAVError(w, 403, cardNS, "supported-address-data")
|
||||
return
|
||||
}
|
||||
}
|
||||
requested := prop.Children
|
||||
rows := []davResponse{}
|
||||
if n.XMLName == (xml.Name{Space: davNS, Local: "sync-collection"}) {
|
||||
level := n.child(davNS, "sync-level")
|
||||
token := n.child(davNS, "sync-token")
|
||||
if level == nil || level.Text != "1" || token == nil {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
limit := 200
|
||||
if l := n.child(davNS, "limit"); l != nil {
|
||||
num := l.child(davNS, "nresults")
|
||||
if num == nil {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
v, e := strconv.Atoi(num.Text)
|
||||
if e != nil || v < 1 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
if v < limit {
|
||||
limit = v
|
||||
}
|
||||
}
|
||||
data, e := s.store.ContactDAVSnapshot(r.Context(), domain, actor, token.Text, limit)
|
||||
if e != nil {
|
||||
contactDAVStoreError(w, e)
|
||||
return
|
||||
}
|
||||
for _, c := range data.Items {
|
||||
rows = append(rows, contactDAVRow(book, c))
|
||||
}
|
||||
if data.More {
|
||||
rows = append(rows, davResponse{href: book, status: 507, errorXML: "<d:number-of-matches-within-limits/>"})
|
||||
}
|
||||
writeContactDAV(w, rows, requested, data.Token)
|
||||
return
|
||||
}
|
||||
if n.XMLName == (xml.Name{Space: cardNS, Local: "addressbook-multiget"}) {
|
||||
count := 0
|
||||
for _, h := range n.Children {
|
||||
if h.XMLName != (xml.Name{Space: davNS, Local: "href"}) {
|
||||
continue
|
||||
}
|
||||
count++
|
||||
if count > 100 {
|
||||
contactDAVError(w, 507, davNS, "number-of-matches-within-limits")
|
||||
return
|
||||
}
|
||||
u, e := url.Parse(h.Text)
|
||||
if e != nil || u.User != nil || u.RawQuery != "" || u.Fragment != "" || u.Host != "" && (!strings.EqualFold(u.Host, r.Host) || u.Scheme != "https" && u.Scheme != "http") || !strings.HasPrefix(u.Path, book) || !store.ValidContactDAVName(strings.TrimPrefix(u.Path, book)) {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
name := strings.TrimPrefix(u.Path, book)
|
||||
c, e := s.store.ContactDAVResource(r.Context(), domain, actor, name)
|
||||
if errors.Is(e, sql.ErrNoRows) {
|
||||
rows = append(rows, davResponse{href: book + name, status: 404})
|
||||
continue
|
||||
}
|
||||
if e != nil {
|
||||
contactDAVStoreError(w, e)
|
||||
return
|
||||
}
|
||||
rows = append(rows, contactDAVRow(book, store.ContactDAVItem{Contact: c, Name: name}))
|
||||
}
|
||||
if count == 0 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
writeContactDAV(w, rows, requested)
|
||||
return
|
||||
}
|
||||
if n.XMLName != (xml.Name{Space: cardNS, Local: "addressbook-query"}) {
|
||||
contactDAVError(w, 403, davNS, "supported-report")
|
||||
return
|
||||
}
|
||||
filter := n.child(cardNS, "filter")
|
||||
if filter != nil && !validContactFilter(*filter) {
|
||||
contactDAVError(w, 403, cardNS, "supported-filter")
|
||||
return
|
||||
}
|
||||
// A bounded full scan is explicit; never return a truncated 207 as a complete
|
||||
// address book, which would make clients infer deletions. Sync is paginated.
|
||||
data, e := s.store.ContactDAVSnapshot(r.Context(), domain, actor, "", 200)
|
||||
if e != nil {
|
||||
contactDAVStoreError(w, e)
|
||||
return
|
||||
}
|
||||
if data.More {
|
||||
contactDAVError(w, 507, davNS, "number-of-matches-within-limits")
|
||||
return
|
||||
}
|
||||
limit := 200
|
||||
if l := n.child(cardNS, "limit"); l != nil {
|
||||
num := l.child(cardNS, "nresults")
|
||||
if num == nil {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
v, e := strconv.Atoi(num.Text)
|
||||
if e != nil || v < 1 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
if v < limit {
|
||||
limit = v
|
||||
}
|
||||
}
|
||||
for _, c := range data.Items {
|
||||
if filter == nil || matchContactFilter(c.Contact, *filter) {
|
||||
rows = append(rows, contactDAVRow(book, c))
|
||||
}
|
||||
}
|
||||
if len(rows) > limit {
|
||||
contactDAVError(w, 507, davNS, "number-of-matches-within-limits")
|
||||
return
|
||||
}
|
||||
writeContactDAV(w, rows, requested)
|
||||
}
|
||||
|
||||
func writeContactDAV(w http.ResponseWriter, rows []davResponse, requested []davNode, token ...string) {
|
||||
for _, p := range requested {
|
||||
if p.XMLName == (xml.Name{Space: cardNS, Local: "address-data"}) && p.attr("version") != "" {
|
||||
for _, row := range rows {
|
||||
if v, ok := row.props[xml.Name{Space: cardNS, Local: "address-data"}]; ok && !strings.HasPrefix(v, xmlText("BEGIN:VCARD\r\nVERSION:"+p.attr("version")+"\r\n")) {
|
||||
contactDAVError(w, 403, cardNS, "supported-address-data")
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
writeDAV(w, rows, requested, token...)
|
||||
}
|
||||
|
||||
func validContactFilter(n davNode) bool {
|
||||
if n.attr("test") != "" && n.attr("test") != "anyof" && n.attr("test") != "allof" {
|
||||
return false
|
||||
}
|
||||
for _, p := range n.Children {
|
||||
if p.XMLName != (xml.Name{Space: cardNS, Local: "prop-filter"}) || p.attr("name") == "" || p.attr("test") != "" && p.attr("test") != "anyof" && p.attr("test") != "allof" {
|
||||
return false
|
||||
}
|
||||
for _, c := range p.attr("name") {
|
||||
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '-') {
|
||||
return false
|
||||
}
|
||||
}
|
||||
for _, m := range p.Children {
|
||||
switch m.XMLName {
|
||||
case xml.Name{Space: cardNS, Local: "is-not-defined"}:
|
||||
if len(p.Children) != 1 {
|
||||
return false
|
||||
}
|
||||
case xml.Name{Space: cardNS, Local: "text-match"}:
|
||||
if m.attr("collation") != "" && m.attr("collation") != "i;unicode-casemap" && m.attr("collation") != "i;octet" {
|
||||
return false
|
||||
}
|
||||
if m.attr("match-type") != "" && m.attr("match-type") != "contains" && m.attr("match-type") != "equals" && m.attr("match-type") != "starts-with" && m.attr("match-type") != "ends-with" {
|
||||
return false
|
||||
}
|
||||
if m.attr("negate-condition") != "" && m.attr("negate-condition") != "yes" && m.attr("negate-condition") != "no" {
|
||||
return false
|
||||
}
|
||||
default:
|
||||
return false
|
||||
}
|
||||
if len(m.Children) > 0 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func matchContactFilter(c store.Contact, n davNode) bool {
|
||||
if len(n.Children) == 0 {
|
||||
return true
|
||||
}
|
||||
all := n.attr("test") == "allof"
|
||||
result := all
|
||||
for _, p := range n.Children {
|
||||
values := store.ContactPropertyValues(c, p.attr("name"))
|
||||
match := len(values) > 0
|
||||
if len(p.Children) > 0 {
|
||||
and := p.attr("test") == "allof"
|
||||
match = and
|
||||
for _, m := range p.Children {
|
||||
hit := false
|
||||
if m.XMLName.Local == "is-not-defined" {
|
||||
hit = len(values) == 0
|
||||
} else {
|
||||
for _, v := range values {
|
||||
query := m.Text
|
||||
if m.attr("collation") != "i;octet" {
|
||||
v = norm.NFKD.String(strings.Map(unicode.ToTitle, v))
|
||||
query = norm.NFKD.String(strings.Map(unicode.ToTitle, query))
|
||||
}
|
||||
switch m.attr("match-type") {
|
||||
case "equals":
|
||||
hit = v == query
|
||||
case "starts-with":
|
||||
hit = strings.HasPrefix(v, query)
|
||||
case "ends-with":
|
||||
hit = strings.HasSuffix(v, query)
|
||||
default:
|
||||
hit = strings.Contains(v, query)
|
||||
}
|
||||
if hit {
|
||||
break
|
||||
}
|
||||
}
|
||||
if m.attr("negate-condition") == "yes" {
|
||||
hit = !hit && len(values) > 0
|
||||
}
|
||||
}
|
||||
if and {
|
||||
match = match && hit
|
||||
} else {
|
||||
match = match || hit
|
||||
}
|
||||
}
|
||||
}
|
||||
if all {
|
||||
result = result && match
|
||||
} else {
|
||||
result = result || match
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"pageswiki/internal/store"
|
||||
)
|
||||
|
||||
// Real client interoperability uses only disposable, synthetic contacts.
|
||||
func TestContactDAVVdirsyncer(t *testing.T) {
|
||||
bin := os.Getenv("PAGESWIKI_VDIRSYNCER")
|
||||
if bin == "" {
|
||||
t.Skip("opt-in vdirsyncer executable")
|
||||
}
|
||||
s, _, domain, actor := taskFixture(t)
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
|
||||
defer cancel()
|
||||
credential, password, err := s.store.CreateDAVCredential(ctx, domain, actor, "Fixture", true, 1, "contacts")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
native, err := s.store.SaveContact(ctx, domain, actor, store.Contact{UUID: uuid.NewString(), VCard: testCard}, true)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
server := httptest.NewServer(s.handler())
|
||||
defer server.Close()
|
||||
dir := t.TempDir()
|
||||
local := filepath.Join(dir, "cards")
|
||||
if err = os.MkdirAll(filepath.Join(local, "contacts"), 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
config := fmt.Sprintf(`[general]
|
||||
status_path = %q
|
||||
[pair contacts]
|
||||
a = "local"
|
||||
b = "remote"
|
||||
collections = ["contacts"]
|
||||
[storage local]
|
||||
type = "filesystem"
|
||||
path = %q
|
||||
fileext = ".vcf"
|
||||
[storage remote]
|
||||
type = "carddav"
|
||||
url = %q
|
||||
username = %q
|
||||
password = %q
|
||||
`, filepath.Join(dir, "status"), local, strings.Replace(server.URL, "127.0.0.1", "localhost", 1)+contactDAV, credential.ID, password)
|
||||
configPath := filepath.Join(dir, "vdirsyncer.conf")
|
||||
if err = os.WriteFile(configPath, []byte(config), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
run := func(action string, extra ...string) {
|
||||
t.Helper()
|
||||
cmd := exec.CommandContext(ctx, bin, append([]string{"-c", configPath, action}, extra...)...)
|
||||
cmd.Stdin = strings.NewReader("y\ny\ny\n")
|
||||
out, e := cmd.CombinedOutput()
|
||||
if e != nil {
|
||||
t.Fatalf("%s: %v\n%s", action, e, strings.ReplaceAll(string(out), password, "[REDACTED]"))
|
||||
}
|
||||
}
|
||||
run("discover")
|
||||
run("sync")
|
||||
files, err := filepath.Glob(filepath.Join(local, "contacts", "*.vcf"))
|
||||
if err != nil || len(files) != 1 {
|
||||
t.Fatal(files, err)
|
||||
}
|
||||
raw, err := os.ReadFile(files[0])
|
||||
if err != nil || !strings.Contains(string(raw), "FN:田中") {
|
||||
t.Fatal("download", err)
|
||||
}
|
||||
if err = os.WriteFile(files[0], []byte(strings.Replace(string(raw), "FN:田中", "FN:Client edited", 1)), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
run("sync")
|
||||
got, err := s.store.Contact(ctx, domain, actor, native.UUID)
|
||||
if err != nil || got.Name != "Client edited" || !strings.Contains(got.VCard, "X-PRIVATE:keep") {
|
||||
t.Fatal("client edit", got.Name, err)
|
||||
}
|
||||
got.Name = "Web edited"
|
||||
got, err = s.store.SaveContact(ctx, domain, actor, got, false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
run("sync")
|
||||
raw, err = os.ReadFile(files[0])
|
||||
if err != nil || !strings.Contains(string(raw), "FN:Web edited") {
|
||||
t.Fatal("web edit", err)
|
||||
}
|
||||
newPath := filepath.Join(local, "contacts", "client-new.vcf")
|
||||
newCard := strings.ReplaceAll(testCard, "urn:test:dav-contact", "urn:test:client-new")
|
||||
if err = os.WriteFile(newPath, []byte(newCard), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
run("sync")
|
||||
items, _, err := s.store.Contacts(ctx, domain, actor, "", "")
|
||||
if err != nil || len(items) != 2 {
|
||||
t.Fatal("client create", len(items), err)
|
||||
}
|
||||
if err = os.Remove(newPath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
run("sync")
|
||||
items, _, err = s.store.Contacts(ctx, domain, actor, "", "")
|
||||
if err != nil || len(items) != 1 {
|
||||
t.Fatal("client delete", len(items), err)
|
||||
}
|
||||
got.Deleted = true
|
||||
if _, err = s.store.SaveContact(ctx, domain, actor, got, false); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Emptying a whole book requires vdirsyncer's explicit safety override.
|
||||
run("sync", "--force-delete", "contacts/contacts")
|
||||
files, err = filepath.Glob(filepath.Join(local, "contacts", "*.vcf"))
|
||||
if err != nil || len(files) != 0 {
|
||||
t.Fatal("web delete", files, err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,358 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"pageswiki/internal/store"
|
||||
)
|
||||
|
||||
const testCard = "BEGIN:VCARD\r\nVERSION:4.0\r\nUID:urn:test:dav-contact\r\nFN:田中\r\nEMAIL;TYPE=work:tanaka@example.invalid\r\nX-PRIVATE:keep\r\nEND:VCARD\r\n"
|
||||
|
||||
func TestContactDAVConcurrentWritesAndStandaloneExtension(t *testing.T) {
|
||||
s, token, domain, actor := taskFixture(t)
|
||||
ctx := context.Background()
|
||||
for _, id := range []string{"organizer.tasks", "organizer.calendar"} {
|
||||
if e := s.setSystemExtensionEnabled(domain, id, false); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
cred, pass, err := s.store.CreateDAVCredential(ctx, domain, actor, "phone", true, 1, "contacts")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(cred.ID+":"+pass))
|
||||
path := contactDAV + actor + "/contacts/one.vcf"
|
||||
if w := cardRequest(s, auth, "PUT", path, testCard, map[string]string{"If-None-Match": "*"}); w.Code != 201 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
if w := cardRequest(s, "Bearer "+token, "GET", "/_/api/v1/caldav-credentials", "", nil); w.Code != 200 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
start := make(chan struct{})
|
||||
results := make(chan int, 2)
|
||||
for _, name := range []string{"First", "Second"} {
|
||||
go func(name string) {
|
||||
<-start
|
||||
w := cardRequest(s, auth, "PUT", path, strings.Replace(testCard, "FN:田中", "FN:"+name, 1), map[string]string{"If-Match": `"1"`})
|
||||
results <- w.Code
|
||||
}(name)
|
||||
}
|
||||
close(start)
|
||||
a, b := <-results, <-results
|
||||
if !(a == 204 && b == 412 || a == 412 && b == 204) {
|
||||
t.Fatal("concurrent overwrite", a, b)
|
||||
}
|
||||
// Removing the contacts marker must never reinterpret this secret as tasks.
|
||||
if _, err = s.store.DB.Exec(`DELETE FROM organizer_contact_credentials WHERE credential_id=?`, cred.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, _, _, err = s.store.AuthenticateDAV(ctx, domain, cred.ID, pass, ""); err != store.ErrAccessDenied {
|
||||
t.Fatal("scope downgrade", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestContactDAVInventoryAndLimits(t *testing.T) {
|
||||
s, token, domain, actor := taskFixture(t)
|
||||
ctx := context.Background()
|
||||
for i := 0; i < 201; i++ {
|
||||
_, e := s.store.SaveContact(ctx, domain, actor, store.Contact{UUID: uuid.NewString(), Name: fmt.Sprintf("Person %03d", i)}, false)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
data, err := s.store.ContactDAVInventory(ctx, domain, actor)
|
||||
if err != nil || data.More || len(data.Items) != 201 {
|
||||
t.Fatal(len(data.Items), err)
|
||||
}
|
||||
for _, c := range data.Items {
|
||||
if c.VCard != "" || c.Size < 1 || c.Version != 1 {
|
||||
t.Fatal("inventory must contain metadata only", c)
|
||||
}
|
||||
}
|
||||
book := contactDAV + actor + "/contacts/"
|
||||
auth := "Bearer " + token
|
||||
w := cardRequest(s, auth, "PROPFIND", book, "", nil)
|
||||
if w.Code != 207 || strings.Count(w.Body.String(), "<d:response>") != 202 || strings.Contains(w.Body.String(), "BEGIN:VCARD") {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
w = cardRequest(s, auth, "REPORT", book, cardSync("", ""), nil)
|
||||
if w.Code != 207 || !strings.Contains(w.Body.String(), "507") {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
next := cardRequest(s, auth, "REPORT", book, cardSync(responseSync(t, w), ""), nil)
|
||||
if next.Code != 207 || strings.Count(next.Body.String(), "<d:response>") != 1 {
|
||||
t.Fatal(next.Code, next.Body)
|
||||
}
|
||||
query := `<a:addressbook-query xmlns:a="urn:ietf:params:xml:ns:carddav" xmlns:d="DAV:"><d:prop><d:getetag/></d:prop></a:addressbook-query>`
|
||||
w = cardRequest(s, auth, "REPORT", book, query, nil)
|
||||
if w.Code != 507 {
|
||||
t.Fatal("must not silently truncate a full query", w.Code)
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
raw, media string
|
||||
want int
|
||||
}{
|
||||
{strings.Replace(testCard, "UID:urn:test:dav-contact\r\n", "", 1), "text/vcard", 403},
|
||||
{testCard, "text/vcard; version=3.0", 415},
|
||||
{testCard, "text/vcard; charset=shift_jis", 415},
|
||||
} {
|
||||
w = cardRequest(s, auth, "PUT", book+"invalid.vcf", tc.raw, map[string]string{"If-None-Match": "*", "Content-Type": tc.media})
|
||||
if w.Code != tc.want {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestContactDAVUnicodeAndUnknownProperties(t *testing.T) {
|
||||
card := store.Contact{VCard: strings.Replace(testCard, "X-PRIVATE:keep", "X-PRIVATE:CAFÉ", 1)}
|
||||
for _, tc := range []struct {
|
||||
collation, query string
|
||||
want bool
|
||||
}{
|
||||
{"i;unicode-casemap", "cafe\u0301", true},
|
||||
{"i;unicode-casemap", "CAFÉ", true},
|
||||
{"i;octet", "café", false},
|
||||
{"i;octet", "CAFÉ", true},
|
||||
} {
|
||||
var filter davNode
|
||||
raw := `<a:filter xmlns:a="urn:ietf:params:xml:ns:carddav"><a:prop-filter name="X-PRIVATE"><a:text-match collation="` + tc.collation + `" match-type="equals">` + tc.query + `</a:text-match></a:prop-filter></a:filter>`
|
||||
if e := xml.Unmarshal([]byte(raw), &filter); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if !validContactFilter(filter) || matchContactFilter(card, filter) != tc.want {
|
||||
t.Fatal(tc)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func cardRequest(s *Server, auth, method, path, body string, headers map[string]string) *httptest.ResponseRecorder {
|
||||
if headers == nil {
|
||||
headers = map[string]string{}
|
||||
}
|
||||
if _, ok := headers["Content-Type"]; !ok {
|
||||
headers["Content-Type"] = "text/vcard"
|
||||
}
|
||||
return davTaskRequest(s, auth, method, path, body, headers)
|
||||
}
|
||||
func cardSync(token string, limit string) string {
|
||||
return `<d:sync-collection xmlns:d="DAV:"><d:sync-token>` + xmlText(token) + `</d:sync-token><d:sync-level>1</d:sync-level><d:prop><d:getetag/></d:prop>` + limit + `</d:sync-collection>`
|
||||
}
|
||||
func responseSync(t *testing.T, w *httptest.ResponseRecorder) string {
|
||||
t.Helper()
|
||||
var value struct {
|
||||
Token string `xml:"sync-token"`
|
||||
}
|
||||
if e := xml.Unmarshal(w.Body.Bytes(), &value); e != nil || value.Token == "" {
|
||||
t.Fatal(e, w.Body)
|
||||
}
|
||||
return value.Token
|
||||
}
|
||||
func TestContactDAVRoundTripAndScopes(t *testing.T) {
|
||||
s, token, domain, actor := taskFixture(t)
|
||||
ctx := context.Background()
|
||||
book := contactDAV + actor + "/contacts/"
|
||||
cred, password, err := s.store.CreateDAVCredential(ctx, domain, actor, "phone", true, 90, "contacts")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(cred.ID+":"+password))
|
||||
request := func(method, path, body string, h map[string]string, want int) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
w := cardRequest(s, auth, method, path, body, h)
|
||||
if w.Code != want {
|
||||
t.Fatalf("%s %s: %d want %d %s", method, path, w.Code, want, w.Body)
|
||||
}
|
||||
return w
|
||||
}
|
||||
options := request("OPTIONS", contactDAV, "", nil, 204)
|
||||
if options.Header().Get("DAV") != "1, addressbook-access" {
|
||||
t.Fatal(options.Header())
|
||||
}
|
||||
home := request("PROPFIND", contactDAV, `<d:propfind xmlns:d="DAV:" xmlns:a="urn:ietf:params:xml:ns:carddav"><d:prop><d:current-user-principal/><a:addressbook-home-set/></d:prop></d:propfind>`, nil, 207)
|
||||
if !strings.Contains(home.Body.String(), contactDAV+actor+"/") {
|
||||
t.Fatal(home.Body)
|
||||
}
|
||||
discovery := request("PROPFIND", contactDAV+actor+"/", "", nil, 207)
|
||||
if !strings.Contains(discovery.Body.String(), book) {
|
||||
t.Fatal(discovery.Body)
|
||||
}
|
||||
empty := request("REPORT", book, cardSync("", ""), nil, 207)
|
||||
emptyToken := responseSync(t, empty)
|
||||
path := book + "client-contact.vcf"
|
||||
request("PUT", path, testCard, map[string]string{"If-None-Match": "*"}, 201)
|
||||
get := request("GET", path, "", nil, 200)
|
||||
tag := get.Header().Get("ETag")
|
||||
request("GET", path, "", map[string]string{"If-None-Match": tag}, 304)
|
||||
request("PUT", path, testCard, map[string]string{"If-None-Match": "*"}, 412)
|
||||
request("PUT", path, testCard, nil, 428)
|
||||
request("PUT", path, testCard, map[string]string{"If-Match": `"999"`}, 412)
|
||||
request("PUT", book+"duplicate.vcf", testCard, map[string]string{"If-None-Match": "*"}, 403)
|
||||
c, err := s.store.ContactDAVResource(ctx, domain, actor, "client-contact.vcf")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c.Name = "Webで変更"
|
||||
c, err = s.store.SaveContact(ctx, domain, actor, c, false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
delta := request("REPORT", book, cardSync(emptyToken, ""), nil, 207)
|
||||
if !strings.Contains(delta.Body.String(), path) || strings.Contains(delta.Body.String(), "Webで変更") {
|
||||
t.Fatal(delta.Body)
|
||||
}
|
||||
synced := responseSync(t, delta)
|
||||
multi := `<a:addressbook-multiget xmlns:a="urn:ietf:params:xml:ns:carddav" xmlns:d="DAV:"><d:prop><d:getetag/><a:address-data/></d:prop><d:href>` + path + `</d:href><d:href>` + book + `missing.vcf</d:href></a:addressbook-multiget>`
|
||||
got := request("REPORT", book, multi, nil, 207)
|
||||
if !strings.Contains(got.Body.String(), "Webで変更") || !strings.Contains(got.Body.String(), "X-PRIVATE:keep") || !strings.Contains(got.Body.String(), "404 Not Found") {
|
||||
t.Fatal(got.Body)
|
||||
}
|
||||
request("DELETE", path, "", map[string]string{"If-Match": store.ContactETag(c)}, 204)
|
||||
request("GET", path, "", nil, 404)
|
||||
delta = request("REPORT", book, cardSync(synced, ""), nil, 207)
|
||||
if !strings.Contains(delta.Body.String(), path) || !strings.Contains(delta.Body.String(), "404 Not Found") {
|
||||
t.Fatal(delta.Body)
|
||||
}
|
||||
request("REPORT", book, cardSync("urn:foreign:123", ""), nil, 403)
|
||||
request("PUT", path, testCard, map[string]string{"If-None-Match": "*"}, 201)
|
||||
c, err = s.store.ContactDAVResource(ctx, domain, actor, "client-contact.vcf")
|
||||
if err != nil || c.Deleted {
|
||||
t.Fatal(c, err)
|
||||
}
|
||||
if w := cardRequest(s, auth, "GET", contactsAPI+"items", "", nil); w.Code != 401 {
|
||||
t.Fatal("DAV credential leaked to API", w.Code)
|
||||
}
|
||||
if w := cardRequest(s, auth, "PROPFIND", taskDAVRoot, "", nil); w.Code != 401 {
|
||||
t.Fatal("contact credential grants tasks", w.Code)
|
||||
}
|
||||
// The legacy 'all' scope remains calendar+tasks, not newly added contacts.
|
||||
all, pass, e := s.store.CreateDAVCredential(ctx, domain, actor, "old", true, 1, "all")
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
otherAuth := "Basic " + base64.StdEncoding.EncodeToString([]byte(all.ID+":"+pass))
|
||||
if w := cardRequest(s, otherAuth, "PROPFIND", contactDAV, "", nil); w.Code != 401 {
|
||||
t.Fatal("old authority expanded", w.Code)
|
||||
}
|
||||
request("PROPFIND", contactDAV+uuid.NewString()+"/contacts/", "", nil, 404)
|
||||
if e = s.store.RevokeTaskDAVCredential(ctx, domain, actor, cred.ID); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
request("GET", path, "", nil, 401)
|
||||
if _, e = s.store.SaveContactDAV(ctx, domain, actor, cred.ID, "client-contact.vcf", testCard, c.Version, false); e != store.ErrAccessDenied {
|
||||
t.Fatal("revoked writer", e)
|
||||
}
|
||||
// A normal session can still edit its own address book.
|
||||
if w := cardRequest(s, "Bearer "+token, "GET", path, "", nil); w.Code != 200 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestContactDAVPaginationHistoryAndBoundaries(t *testing.T) {
|
||||
s, token, domain, actor := taskFixture(t)
|
||||
ctx := context.Background()
|
||||
auth := "Bearer " + token
|
||||
book := contactDAV + actor + "/contacts/"
|
||||
var ids []string
|
||||
for i := 0; i < 3; i++ {
|
||||
id := uuid.NewString()
|
||||
ids = append(ids, id)
|
||||
_, e := s.store.SaveContact(ctx, domain, actor, store.Contact{UUID: id, Name: "Person"}, false)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
first := cardRequest(s, auth, "REPORT", book, cardSync("", `<d:limit><d:nresults>1</d:nresults></d:limit>`), nil)
|
||||
if first.Code != 207 || !strings.Contains(first.Body.String(), "507 Insufficient Storage") {
|
||||
t.Fatal(first.Code, first.Body)
|
||||
}
|
||||
second := cardRequest(s, auth, "REPORT", book, cardSync(responseSync(t, first), ""), nil)
|
||||
if second.Code != 207 || strings.Contains(second.Body.String(), "507 Insufficient Storage") {
|
||||
t.Fatal(second.Code, second.Body)
|
||||
}
|
||||
var r struct {
|
||||
Responses []struct {
|
||||
Href string `xml:"href"`
|
||||
} `xml:"response"`
|
||||
}
|
||||
if e := xml.Unmarshal(second.Body.Bytes(), &r); e != nil || len(r.Responses) != 2 {
|
||||
t.Fatal(e, second.Body)
|
||||
}
|
||||
c, e := s.store.Contact(ctx, domain, actor, ids[0])
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
c.Name = "Changed"
|
||||
c, e = s.store.SaveContact(ctx, domain, actor, c, false)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
h, e := s.store.ContactHistory(ctx, domain, actor, c.UUID, 0)
|
||||
if e != nil || len(h) != 2 {
|
||||
t.Fatal(h, e)
|
||||
}
|
||||
restored, e := s.store.RestoreContactRevision(ctx, domain, actor, c.UUID, 1, c.Version)
|
||||
if e != nil || restored.Name != "Person" || restored.Version != 3 {
|
||||
t.Fatal(restored, e)
|
||||
}
|
||||
if _, e = s.store.RestoreContactRevision(ctx, domain, actor, c.UUID, 1, c.Version); e != store.ErrTaskConflict {
|
||||
t.Fatal("stale restore", e)
|
||||
}
|
||||
raw, e := s.store.ExportContacts(ctx, domain, actor)
|
||||
if e != nil || strings.Count(raw, "BEGIN:VCARD") != 3 {
|
||||
t.Fatal(e, raw)
|
||||
}
|
||||
history := cardRequest(s, auth, "GET", contactsAPI+"items/"+c.UUID+"/history", "", nil)
|
||||
if history.Code != 200 {
|
||||
t.Fatal(history.Code, history.Body)
|
||||
}
|
||||
preview := cardRequest(s, auth, "GET", contactsAPI+"items/"+c.UUID+"/history/1", "", nil)
|
||||
if preview.Code != 200 || !strings.Contains(preview.Body.String(), "Person") {
|
||||
t.Fatal(preview.Code, preview.Body)
|
||||
}
|
||||
restoreBody, _ := json.Marshal(map[string]int64{"version": restored.Version, "revision": 1})
|
||||
restore := cardRequest(s, auth, "POST", contactsAPI+"items/"+c.UUID+"/restore", string(restoreBody), map[string]string{"If-Match": store.ContactETag(restored)})
|
||||
if restore.Code != 200 {
|
||||
t.Fatal(restore.Code, restore.Body)
|
||||
}
|
||||
query := `<a:addressbook-query xmlns:a="urn:ietf:params:xml:ns:carddav" xmlns:d="DAV:"><d:prop><d:getetag/></d:prop><a:filter><a:prop-filter name="FN"><a:text-match match-type="equals">Person</a:text-match></a:prop-filter></a:filter></a:addressbook-query>`
|
||||
found := cardRequest(s, auth, "REPORT", book, query, nil)
|
||||
if found.Code != 207 {
|
||||
t.Fatal(found.Code, found.Body)
|
||||
}
|
||||
for _, body := range []string{strings.Replace(query, `name="FN"`, `name="BAD NAME"`, 1), strings.Replace(query, `match-type="equals"`, `collation="unsupported"`, 1)} {
|
||||
w := cardRequest(s, auth, "REPORT", book, body, nil)
|
||||
if w.Code != 403 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
}
|
||||
xmlBomb := `<!DOCTYPE x [<!ENTITY x "bomb">]><d:propfind xmlns:d="DAV:"/>`
|
||||
if w := cardRequest(s, auth, "PROPFIND", book, xmlBomb, nil); w.Code != 400 {
|
||||
t.Fatal(w.Code)
|
||||
}
|
||||
foreign := `<a:addressbook-multiget xmlns:a="urn:ietf:params:xml:ns:carddav" xmlns:d="DAV:"><d:prop><d:getetag/></d:prop><d:href>https://evil.invalid` + book + `a.vcf</d:href></a:addressbook-multiget>`
|
||||
if w := cardRequest(s, auth, "REPORT", book, foreign, nil); w.Code != 400 {
|
||||
t.Fatal(w.Code)
|
||||
}
|
||||
read, pass, e := s.store.CreateDAVCredential(ctx, domain, actor, "readonly", false, 1, "contacts")
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
readonly := "Basic " + base64.StdEncoding.EncodeToString([]byte(read.ID+":"+pass))
|
||||
if w := cardRequest(s, readonly, "PUT", book+"new.vcf", testCard, map[string]string{"If-None-Match": "*"}); w.Code != 403 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
if e = s.setSystemExtensionEnabled(domain, "organizer.contacts", false); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if w := cardRequest(s, auth, "PROPFIND", book, "", nil); w.Code != 404 {
|
||||
t.Fatal(w.Code)
|
||||
}
|
||||
}
|
||||
@@ -12,7 +12,9 @@ import (
|
||||
|
||||
const contactsAPI = "/_/api/v1/extension/organizer.contacts/"
|
||||
|
||||
func contactRoute(p string) bool { return p == "/v/plan/contacts" || strings.HasPrefix(p, contactsAPI) }
|
||||
func contactRoute(p string) bool {
|
||||
return contactDAVRoute(p) || p == "/v/plan/contacts" || strings.HasPrefix(p, contactsAPI)
|
||||
}
|
||||
func (s *Server) handleContacts(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Cache-Control", "private, no-store")
|
||||
domain := s.domainUUIDForRequest(r)
|
||||
@@ -42,6 +44,98 @@ func (s *Server) handleContacts(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
key := strings.TrimPrefix(r.URL.Path, contactsAPI)
|
||||
if key == "export.vcf" && (r.Method == "GET" || r.Method == "HEAD") {
|
||||
raw, e := s.store.ExportContacts(r.Context(), domain, actor)
|
||||
if e != nil {
|
||||
taskError(w, e)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "text/vcard; charset=utf-8")
|
||||
w.Header().Set("Content-Disposition", `attachment; filename="contacts.vcf"`)
|
||||
w.Header().Set("Content-Length", strconv.Itoa(len(raw)))
|
||||
if r.Method == "GET" {
|
||||
io.WriteString(w, raw)
|
||||
}
|
||||
return
|
||||
}
|
||||
parts := strings.Split(key, "/")
|
||||
if len(parts) >= 3 && parts[0] == "items" && (parts[2] == "history" || parts[2] == "restore") {
|
||||
id, e := uuid.Parse(parts[1])
|
||||
if e != nil || id.String() != parts[1] {
|
||||
w.WriteHeader(404)
|
||||
return
|
||||
}
|
||||
if parts[2] == "history" && r.Method == "GET" {
|
||||
if len(parts) == 4 {
|
||||
revision, e := strconv.ParseInt(parts[3], 10, 64)
|
||||
if e != nil || revision < 1 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
c, e := s.store.ContactAtRevision(r.Context(), domain, actor, parts[1], revision)
|
||||
if e != nil {
|
||||
taskError(w, e)
|
||||
return
|
||||
}
|
||||
writeEventJSON(w, 200, map[string]any{"item": c})
|
||||
return
|
||||
}
|
||||
if len(parts) != 3 {
|
||||
w.WriteHeader(404)
|
||||
return
|
||||
}
|
||||
before := int64(0)
|
||||
if v := r.URL.Query().Get("before"); v != "" {
|
||||
before, e = strconv.ParseInt(v, 10, 64)
|
||||
if e != nil || before < 1 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
}
|
||||
items, e := s.store.ContactHistory(r.Context(), domain, actor, parts[1], before)
|
||||
if e != nil {
|
||||
taskError(w, e)
|
||||
return
|
||||
}
|
||||
next := int64(0)
|
||||
if len(items) == 100 {
|
||||
next = items[99].Version
|
||||
}
|
||||
writeEventJSON(w, 200, map[string]any{"items": items, "next": next})
|
||||
return
|
||||
}
|
||||
if parts[2] == "restore" && len(parts) == 3 && r.Method == "POST" {
|
||||
var input struct {
|
||||
Version int64 `json:"version"`
|
||||
Revision int64 `json:"revision"`
|
||||
}
|
||||
if !taskJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
if input.Version < 1 || input.Revision < 1 {
|
||||
w.WriteHeader(400)
|
||||
return
|
||||
}
|
||||
if r.Header.Get("If-Match") == "" {
|
||||
w.WriteHeader(428)
|
||||
return
|
||||
}
|
||||
if r.Header.Get("If-Match") != `"`+strconv.FormatInt(input.Version, 10)+`"` {
|
||||
w.WriteHeader(412)
|
||||
return
|
||||
}
|
||||
c, e := s.store.RestoreContactRevision(r.Context(), domain, actor, parts[1], input.Revision, input.Version)
|
||||
if e != nil {
|
||||
taskError(w, e)
|
||||
return
|
||||
}
|
||||
w.Header().Set("ETag", store.ContactETag(c))
|
||||
writeEventJSON(w, 200, map[string]any{"item": c})
|
||||
return
|
||||
}
|
||||
w.WriteHeader(405)
|
||||
return
|
||||
}
|
||||
if key == "items" && r.Method == "GET" {
|
||||
items, next, e := s.store.ListContacts(r.Context(), domain, actor, r.URL.Query().Get("q"), r.URL.Query().Get("after"), r.URL.Query().Get("deleted") == "1")
|
||||
if e != nil {
|
||||
|
||||
@@ -40,6 +40,9 @@ func (s *Server) davActor(w http.ResponseWriter, r *http.Request, requested stri
|
||||
}
|
||||
}
|
||||
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
|
||||
}
|
||||
@@ -87,11 +90,11 @@ func (s *Server) handleDAVHome(w http.ResponseWriter, r *http.Request) {
|
||||
{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 != "calendar" {
|
||||
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 != "tasks" {
|
||||
if calendars && (scope == "calendar" || scope == "all") {
|
||||
repo, err := s.calendars()
|
||||
if err != nil {
|
||||
calendarError(w, err)
|
||||
@@ -108,7 +111,7 @@ func (s *Server) handleDAVHome(w http.ResponseWriter, r *http.Request) {
|
||||
rows = append(rows, row)
|
||||
}
|
||||
}
|
||||
if tasks && scope != "calendar" {
|
||||
if tasks && (scope == "tasks" || scope == "all") {
|
||||
row := taskDAVCollectionRow()
|
||||
title, err := s.store.TaskDAVDefaultTitle(r.Context(), domain, actor)
|
||||
if err != nil {
|
||||
@@ -137,7 +140,7 @@ func davPrivileges(write bool) string {
|
||||
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") {
|
||||
if !s.systemExtensionEnabled(domain, "organizer.tasks") && !s.systemExtensionEnabled(domain, "organizer.calendar") && !s.systemExtensionEnabled(domain, "organizer.contacts") {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -63,7 +63,7 @@ func (s *Server) withStandbyReadOnly(next http.Handler) http.Handler {
|
||||
// V1 standby does not serve organizer or DAV endpoints: their current
|
||||
// read paths repair file-backed indexes and update credential metadata.
|
||||
// They become available after promotion; no false successful sync responses.
|
||||
for _, prefix := range []string{"/v/plan", "/v/calendar", "/v/event", "/v/tasks", "/_/api/v1/calendar", "/_/api/v1/caldav", "/_/api/v1/task", "/_/api/v1/extension/", "/.well-known/caldav"} {
|
||||
for _, prefix := range []string{"/v/plan", "/v/calendar", "/v/event", "/v/tasks", "/_/api/v1/calendar", "/_/api/v1/caldav", "/_/api/v1/carddav", "/_/api/v1/task", "/_/api/v1/extension/", "/.well-known/caldav", "/.well-known/carddav"} {
|
||||
if strings.HasPrefix(r.URL.Path, prefix) {
|
||||
fail("organizer/DAV read service requires DR promotion in this version")
|
||||
return
|
||||
|
||||
@@ -35,6 +35,12 @@ func SetDAVAuthOutcome(r *http.Request, outcome string) {
|
||||
}
|
||||
|
||||
func davLogTarget(path string) string {
|
||||
if path == "/.well-known/carddav" {
|
||||
return "carddav_discovery"
|
||||
}
|
||||
if path == "/_/api/v1/carddav" || strings.HasPrefix(path, "/_/api/v1/carddav/") {
|
||||
return "carddav"
|
||||
}
|
||||
const root = "/_/api/v1/caldav"
|
||||
p := strings.TrimSuffix(path, "/")
|
||||
switch p {
|
||||
|
||||
@@ -77,10 +77,12 @@ func TestDAVLogTarget(t *testing.T) {
|
||||
for path, want := range map[string]string{
|
||||
"/_/api/v1/caldav": "home", "/_/api/v1/caldav/": "home",
|
||||
"/_/api/v1/caldav/tasks/": "task_home", "/_/api/v1/caldav/tasks/default": "task_collection",
|
||||
"/_/api/v1/caldav/tasks/default/private.ics": "task_resource",
|
||||
"/_/api/v1/caldav/private/": "calendar_collection",
|
||||
"/.well-known/caldav": "well_known",
|
||||
"/_/api/v1/caldav-credentials": "", "/health": "",
|
||||
"/_/api/v1/caldav/tasks/default/private.ics": "task_resource",
|
||||
"/_/api/v1/caldav/private/": "calendar_collection",
|
||||
"/.well-known/caldav": "well_known",
|
||||
"/.well-known/carddav": "carddav_discovery",
|
||||
"/_/api/v1/carddav/private-owner/private.vcf": "carddav",
|
||||
"/_/api/v1/caldav-credentials": "", "/health": "",
|
||||
} {
|
||||
if got := davLogTarget(path); got != want {
|
||||
t.Errorf("%s: %q != %q", path, got, want)
|
||||
|
||||
@@ -19,7 +19,7 @@ func NormalizePath(
|
||||
// Hosted adapter assets use directory-relative module and worker URLs.
|
||||
// DAV collections also require the slash: removing it conflicts with
|
||||
// ServeMux's collection redirect and causes an infinite redirect loop.
|
||||
if strings.HasPrefix(p, "/_/adaptor/") || strings.HasPrefix(p, "/_/api/v1/caldav/") {
|
||||
if strings.HasPrefix(p, "/_/adaptor/") || strings.HasPrefix(p, "/_/api/v1/caldav/") || strings.HasPrefix(p, "/_/api/v1/carddav/") {
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@ import (
|
||||
)
|
||||
|
||||
func TestNormalizePathDAVCollections(t *testing.T) {
|
||||
for _, path := range []string{"/_/api/v1/caldav/", "/_/api/v1/caldav/tasks/", "/_/api/v1/caldav/tasks/default/", "/_/api/v1/caldav/calendar-id/"} {
|
||||
for _, path := range []string{"/_/api/v1/caldav/", "/_/api/v1/caldav/tasks/", "/_/api/v1/caldav/tasks/default/", "/_/api/v1/caldav/calendar-id/", "/_/api/v1/carddav/", "/_/api/v1/carddav/actor/contacts/"} {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(401) })
|
||||
for _, method := range []string{"GET", "OPTIONS", "PROPFIND", "REPORT"} {
|
||||
|
||||
@@ -64,6 +64,9 @@ func (s *Server) handleTaskDAVCredentials(w http.ResponseWriter, r *http.Request
|
||||
if body.Scope != "tasks" {
|
||||
endpoint = calendarDAV
|
||||
}
|
||||
if body.Scope == "contacts" {
|
||||
endpoint = contactDAV
|
||||
}
|
||||
response := map[string]any{"credential": credential, "username": credential.ID, "password": password, "url": endpoint}
|
||||
if body.Scope == "tasks" {
|
||||
response["collection"] = taskDAVCollection
|
||||
|
||||
@@ -27,6 +27,9 @@ func taskRoute(p string) bool {
|
||||
}
|
||||
|
||||
func (s *Server) registerTaskRoutes() {
|
||||
s.mux.HandleFunc(contactDAV, s.handleContactDAV)
|
||||
s.mux.HandleFunc(strings.TrimSuffix(contactDAV, "/"), s.handleContactDAV)
|
||||
s.mux.HandleFunc("/.well-known/carddav", s.handleContactDAV)
|
||||
s.mux.HandleFunc(contactsAPI, s.handleContacts)
|
||||
s.mux.HandleFunc("/v/plan/contacts", s.handleContacts)
|
||||
for _, p := range []string{"/v/plan/today", "/v/plan/tasks", "/v/plan/tasks/", "/v/plan/projects", "/v/plan/project/", "/v/plan/task/"} {
|
||||
|
||||
@@ -2,6 +2,11 @@ window.addEventListener('load',async()=>{const wait=async(fn)=>{for(let i=0;i<12
|
||||
const path=location.pathname;
|
||||
if(path==='/v/plan/contacts'){
|
||||
await wait(()=>document.querySelector('#contacts-controls button'));document.querySelector('#contacts-controls button').click();fill(document.querySelector('[name=name]'),'ブラウザ連絡先');fill(document.querySelector('[name=emails]'),'browser@example.invalid');fill(document.querySelector('[name=notes]'),'Non-public notes');document.querySelector('#contact-editor form').requestSubmit();await wait(()=>document.querySelector('#contacts-list button')?.textContent.includes('ブラウザ'));const r=await fetch('/_/api/v1/extension/organizer.contacts/items?q=browser').then(r=>r.json());if(r.items.length!==1)throw Error('Contact save missing');
|
||||
fill(document.querySelector('[name=name]'),'変更後');document.querySelector('#contact-editor form').requestSubmit();await wait(()=>document.querySelector('#contacts-list button')?.textContent.includes('変更後'));
|
||||
await wait(()=>document.querySelector('.contact-history'));document.querySelector('.contact-history').open=true;await wait(()=>document.querySelectorAll('.contact-history-row').length===2);document.querySelectorAll('.contact-history-row')[1].querySelector('button').click();await wait(()=>document.querySelector('.contact-history pre').textContent.includes('ブラウザ連絡先'));
|
||||
window.confirm=()=>true;document.querySelectorAll('.contact-history-row')[1].querySelectorAll('button')[1].click();await wait(()=>document.querySelector('#contacts-list button')?.textContent.includes('ブラウザ'));
|
||||
const exported=await fetch('/_/api/v1/extension/organizer.contacts/export.vcf').then(r=>r.text());if(!exported.includes('ブラウザ連絡先'))throw Error('Export missing');
|
||||
document.querySelector('#tasks-dav-open').click();await wait(()=>document.querySelector('#tasks-dav-dialog').open);const dav=document.querySelector('#tasks-dav-dialog');if(getComputedStyle(dav.querySelector('.dav-compat-toggle')).display!=='none')throw Error('CalDAV-only compatibility visible');fill(dav.querySelector('form>input'),'Browser contact client');dav.querySelector('form').requestSubmit();await wait(()=>!dav.querySelector('section').hidden);const credentials=await fetch('/_/api/v1/caldav-credentials').then(r=>r.json());if(credentials.items.length!==1||credentials.items[0].scope!=='contacts')throw Error('Wrong credential scope');dav.querySelector('tbody button').click();await wait(()=>!dav.querySelector('tbody button'));dav.querySelector('header button').click();
|
||||
}else if(path.endsWith('/settings')){
|
||||
await wait(()=>document.querySelector('[name=due_days]'));fill(document.querySelector('[name=due_days]'),'2');document.querySelector('.productivity-settings').requestSubmit();await wait(()=>document.querySelector('#productivity-status').textContent.includes('保存'));const d=await fetch('/_/api/v1/extension/organizer.tasks/preferences').then(r=>r.json());if(d.preferences.due_days!==2)throw Error('Preferences missing');
|
||||
}else if(path.endsWith('/report')){
|
||||
|
||||
Reference in new issue
Block a user