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
@@ -21,7 +21,7 @@ type Manifest struct {
|
||||
|
||||
func Catalog() []Manifest {
|
||||
return []Manifest{
|
||||
{ID: "organizer.contacts", APIVersion: 1, Version: "0.1.0", Kind: "contacts", Scope: "domain", NameKey: "contacts.title", DescriptionKey: "contacts.help", Capabilities: []string{"contacts.own.read", "contacts.own.write"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
|
||||
{ID: "organizer.contacts", APIVersion: 1, Version: "0.2.0", Kind: "contacts", Scope: "domain", NameKey: "contacts.title", DescriptionKey: "contacts.help", Capabilities: []string{"contacts.own.read", "contacts.own.write"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
|
||||
{ID: "organizer.tasks", APIVersion: 1, Version: "0.12.0", Kind: "tasks", Scope: "domain", NameKey: "tasks.title", DescriptionKey: "tasks.help", Capabilities: []string{"tasks.own.read", "tasks.own.write"}, Events: []string{"organizer.task.changed", "organizer.project.changed", "task.digest.deliver"}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+background+index"},
|
||||
{ID: "organizer.calendar", APIVersion: 1, Version: "0.2.0", Kind: "calendar", Scope: "domain", NameKey: "calendar.title", DescriptionKey: "calendar.help", Capabilities: []string{"calendar.read", "calendar.write"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
|
||||
{ID: "content.diary", APIVersion: 1, Version: "0.1.0", Kind: "diary", Scope: "domain", NameKey: "periodical.diary", DescriptionKey: "periodical.diary_help", Capabilities: []string{"path.read", "path.write", "domain.extensions.manage"}, Events: []string{"periodical.registered", "periodical.removed"}, SettingsPanel: "diary", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
|
||||
|
||||
@@ -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')){
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
var ErrContactUIDConflict = errors.New("contact UID conflict")
|
||||
var ErrContactSyncToken = errors.New("invalid contact sync token")
|
||||
|
||||
func ContactPropertyValues(c Contact, key string) []string {
|
||||
lines, err := cardLines(c.VCard)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
values := []string{}
|
||||
for _, line := range lines[1 : len(lines)-1] {
|
||||
k, v, e := cardKey(line)
|
||||
if e == nil && k == strings.ToUpper(key) {
|
||||
values = append(values, cardText(v))
|
||||
}
|
||||
}
|
||||
return values
|
||||
}
|
||||
|
||||
func ValidContactDAVName(name string) bool {
|
||||
if len(name) < 5 || len(name) > 128 || !strings.HasSuffix(name, ".vcf") || strings.HasPrefix(name, ".") {
|
||||
return false
|
||||
}
|
||||
for _, c := range name {
|
||||
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || strings.ContainsRune("-_.", c)) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
func ContactETag(c Contact) string { return fmt.Sprintf(`"%d"`, c.Version) }
|
||||
|
||||
type ContactDAVItem struct {
|
||||
Contact
|
||||
Name string
|
||||
Sequence int64
|
||||
Size int
|
||||
}
|
||||
type ContactDAVSnapshot struct {
|
||||
Items []ContactDAVItem
|
||||
Token string
|
||||
More bool
|
||||
}
|
||||
|
||||
// Scope and epoch bind opaque tokens to this database, domain and owner. Each
|
||||
// resource retains only its latest sequence; soft-deleted rows are tombstones.
|
||||
func (s *Store) ContactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int) (ContactDAVSnapshot, error) {
|
||||
if limit < 0 || limit > 200 {
|
||||
return ContactDAVSnapshot{}, ErrTaskInvalid
|
||||
}
|
||||
return s.contactDAVSnapshot(ctx, domain, actor, token, limit, false)
|
||||
}
|
||||
|
||||
// PROPFIND inventories contain metadata only, never thousands of vCard bodies.
|
||||
// The same read transaction supplies both the inventory and its change token.
|
||||
func (s *Store) ContactDAVInventory(ctx context.Context, domain, actor string) (ContactDAVSnapshot, error) {
|
||||
return s.contactDAVSnapshot(ctx, domain, actor, "", 5000, true)
|
||||
}
|
||||
|
||||
func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int, metadata bool) (ContactDAVSnapshot, error) {
|
||||
out := ContactDAVSnapshot{Items: []ContactDAVItem{}}
|
||||
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
if err = taskActor(ctx, tx, domain, actor, false); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if err = contactEnabled(ctx, tx, domain); err != nil {
|
||||
return out, err
|
||||
}
|
||||
var epoch string
|
||||
if err = tx.QueryRowContext(ctx, `SELECT value FROM organizer_contact_epoch WHERE id=1`).Scan(&epoch); err != nil {
|
||||
return out, err
|
||||
}
|
||||
hash := sha256.Sum256([]byte(epoch + "\x00" + domain + "\x00" + actor))
|
||||
prefix := "urn:pageswiki:contacts:" + hex.EncodeToString(hash[:]) + ":"
|
||||
var high int64
|
||||
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(sequence),0) FROM organizer_contact_changes WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&high); err != nil {
|
||||
return out, err
|
||||
}
|
||||
since := int64(0)
|
||||
if token != "" {
|
||||
if !strings.HasPrefix(token, prefix) {
|
||||
return out, ErrContactSyncToken
|
||||
}
|
||||
since, err = strconv.ParseInt(strings.TrimPrefix(token, prefix), 10, 64)
|
||||
if err != nil || since < 0 || since > high || prefix+strconv.FormatInt(since, 10) != token {
|
||||
return out, ErrContactSyncToken
|
||||
}
|
||||
}
|
||||
out.Token = prefix + strconv.FormatInt(high, 10)
|
||||
if limit == 0 {
|
||||
return out, nil
|
||||
}
|
||||
fields := `c.data,n.name,x.sequence,0`
|
||||
if metadata {
|
||||
fields = `json_object('uuid',c.uuid,'version',c.version),n.name,x.sequence,length(CAST(json_extract(c.data,'$.vcard') AS BLOB))`
|
||||
}
|
||||
rows, err := tx.QueryContext(ctx, `SELECT `+fields+` FROM organizer_contact_changes x JOIN organizer_contacts c USING(domain_uuid,owner_uuid,uuid) JOIN organizer_contact_names n USING(domain_uuid,owner_uuid,uuid) WHERE x.domain_uuid=? AND x.owner_uuid=? AND x.sequence>? AND (?<>'' OR c.deleted=0) ORDER BY x.sequence LIMIT ?`, domain, actor, since, token, limit+1)
|
||||
if err != nil {
|
||||
return out, err
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
if len(out.Items) == limit {
|
||||
out.More = true
|
||||
out.Token = prefix + strconv.FormatInt(out.Items[len(out.Items)-1].Sequence, 10)
|
||||
break
|
||||
}
|
||||
var item ContactDAVItem
|
||||
var raw string
|
||||
if err = rows.Scan(&raw, &item.Name, &item.Sequence, &item.Size); err != nil {
|
||||
return out, err
|
||||
}
|
||||
if err = json.Unmarshal([]byte(raw), &item.Contact); err != nil {
|
||||
return out, err
|
||||
}
|
||||
out.Items = append(out.Items, item)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func (s *Store) ContactDAVResource(ctx context.Context, domain, actor, name string) (Contact, error) {
|
||||
if !ValidContactDAVName(name) {
|
||||
return Contact{}, ErrTaskInvalid
|
||||
}
|
||||
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
||||
return Contact{}, err
|
||||
}
|
||||
if err := contactEnabled(ctx, s.DB, domain); err != nil {
|
||||
return Contact{}, err
|
||||
}
|
||||
var id string
|
||||
err := s.DB.QueryRowContext(ctx, `SELECT uuid FROM organizer_contact_names WHERE domain_uuid=? AND owner_uuid=? AND name=?`, domain, actor, name).Scan(&id)
|
||||
if err != nil {
|
||||
return Contact{}, err
|
||||
}
|
||||
return s.Contact(ctx, domain, actor, id)
|
||||
}
|
||||
|
||||
// The version is compared under the same write lock as credential revocation,
|
||||
// membership and extension state. No read-modify-write bypass for DAV clients.
|
||||
func (s *Store) SaveContactDAV(ctx context.Context, domain, actor, credential, name, raw string, version int64, remove bool) (Contact, error) {
|
||||
if !ValidContactDAVName(name) {
|
||||
return Contact{}, ErrTaskInvalid
|
||||
}
|
||||
old, err := s.ContactDAVResource(ctx, domain, actor, name)
|
||||
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
||||
return old, err
|
||||
}
|
||||
if old.Version != version {
|
||||
return old, ErrTaskConflict
|
||||
}
|
||||
if remove {
|
||||
if old.Version == 0 || old.Deleted {
|
||||
return old, sql.ErrNoRows
|
||||
}
|
||||
old.Deleted = true
|
||||
return s.saveContact(ctx, domain, actor, old, "fields", credential, name)
|
||||
}
|
||||
id := old.UUID
|
||||
if id == "" {
|
||||
id = strings.TrimSuffix(name, ".vcf")
|
||||
if u, e := uuid.Parse(id); e != nil || u.String() != id {
|
||||
id = uuid.NewSHA1(uuid.NameSpaceURL, []byte(domain+"\x00"+actor+"\x00"+name)).String()
|
||||
}
|
||||
}
|
||||
return s.saveContact(ctx, domain, actor, Contact{UUID: id, Version: version, VCard: raw}, "dav", credential, name)
|
||||
}
|
||||
|
||||
type ContactRevision struct {
|
||||
Version int64 `json:"version"`
|
||||
Deleted bool `json:"deleted"`
|
||||
CreatedMS int64 `json:"created_ms"`
|
||||
}
|
||||
|
||||
func (s *Store) ContactHistory(ctx context.Context, domain, actor, id string, before int64) ([]ContactRevision, error) {
|
||||
if _, err := s.Contact(ctx, domain, actor, id); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rows, err := s.DB.QueryContext(ctx, `SELECT version,deleted,created_ms FROM organizer_contact_revisions WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND (?=0 OR version<?) ORDER BY version DESC LIMIT 100`, domain, actor, id, before, before)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
out := []ContactRevision{}
|
||||
for rows.Next() {
|
||||
var r ContactRevision
|
||||
if err = rows.Scan(&r.Version, &r.Deleted, &r.CreatedMS); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, r)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
func (s *Store) RestoreContactRevision(ctx context.Context, domain, actor, id string, revision, version int64) (Contact, error) {
|
||||
old, err := s.Contact(ctx, domain, actor, id)
|
||||
if err != nil {
|
||||
return old, err
|
||||
}
|
||||
if old.Version != version {
|
||||
return old, ErrTaskConflict
|
||||
}
|
||||
var hash string
|
||||
if err = s.DB.QueryRowContext(ctx, `SELECT hash FROM organizer_contact_revisions WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND version=?`, domain, actor, id, revision).Scan(&hash); err != nil {
|
||||
return old, err
|
||||
}
|
||||
raw, err := s.readDocument(hash)
|
||||
if err != nil {
|
||||
return old, err
|
||||
}
|
||||
return s.saveContact(ctx, domain, actor, Contact{UUID: id, Version: version, VCard: raw}, "dav", "", "")
|
||||
}
|
||||
|
||||
func (s *Store) ContactAtRevision(ctx context.Context, domain, actor, id string, version int64) (Contact, error) {
|
||||
if _, err := s.Contact(ctx, domain, actor, id); err != nil {
|
||||
return Contact{}, err
|
||||
}
|
||||
var hash string
|
||||
var deleted bool
|
||||
if err := s.DB.QueryRowContext(ctx, `SELECT hash,deleted FROM organizer_contact_revisions WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND version=?`, domain, actor, id, version).Scan(&hash, &deleted); err != nil {
|
||||
return Contact{}, err
|
||||
}
|
||||
raw, err := s.readDocument(hash)
|
||||
if err != nil {
|
||||
return Contact{}, err
|
||||
}
|
||||
c, err := ParseContact(raw)
|
||||
c.UUID = id
|
||||
c.Version = version
|
||||
c.Deleted = deleted
|
||||
return c, err
|
||||
}
|
||||
|
||||
// One SQLite read snapshot, bounded before headers are sent. An export must
|
||||
// never look successful when contacts have been silently truncated.
|
||||
func (s *Store) ExportContacts(ctx context.Context, domain, actor string) (string, error) {
|
||||
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := contactEnabled(ctx, s.DB, domain); err != nil {
|
||||
return "", err
|
||||
}
|
||||
rows, err := s.DB.QueryContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND deleted=0 ORDER BY uuid LIMIT 5001`, domain, actor)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out strings.Builder
|
||||
count := 0
|
||||
for rows.Next() {
|
||||
var raw string
|
||||
var c Contact
|
||||
if err = rows.Scan(&raw); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err = json.Unmarshal([]byte(raw), &c); err != nil {
|
||||
return "", err
|
||||
}
|
||||
count++
|
||||
if count > 5000 || out.Len()+len(c.VCard) > 16<<20 {
|
||||
return "", ErrTaskDAVLimit
|
||||
}
|
||||
out.WriteString(c.VCard)
|
||||
}
|
||||
return out.String(), rows.Err()
|
||||
}
|
||||
@@ -21,7 +21,29 @@ var contactMigrations = []db.SQLMigration{{Version: 1, Name: "private_address_bo
|
||||
`CREATE TABLE organizer_contacts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,uid TEXT NOT NULL,version INTEGER NOT NULL,name TEXT NOT NULL,search TEXT NOT NULL,data TEXT NOT NULL,hash TEXT NOT NULL,deleted INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,owner_uuid,uuid),UNIQUE(domain_uuid,owner_uuid,uid))`,
|
||||
`CREATE INDEX organizer_contacts_owner ON organizer_contacts(domain_uuid,owner_uuid,deleted,uuid)`,
|
||||
`CREATE TABLE organizer_contact_revisions(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,version INTEGER NOT NULL,hash TEXT NOT NULL,deleted INTEGER NOT NULL,created_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,uuid,version))`,
|
||||
}, Assertions: []string{schemaColumns("organizer_contacts", "domain_uuid,owner_uuid,uuid,uid,version,name,search,data,hash,deleted"), schemaUnique("organizer_contacts", "domain_uuid,owner_uuid,uid")}}}
|
||||
}, Assertions: []string{schemaColumns("organizer_contacts", "domain_uuid,owner_uuid,uuid,uid,version,name,search,data,hash,deleted"), schemaUnique("organizer_contacts", "domain_uuid,owner_uuid,uid")}}, {Version: 2, Name: "contact_dav_sync", Statements: []string{
|
||||
`CREATE TABLE organizer_contact_credentials(credential_id TEXT PRIMARY KEY)`,
|
||||
`CREATE TRIGGER organizer_contact_credential_delete AFTER DELETE ON organizer_dav_credentials BEGIN DELETE FROM organizer_contact_credentials WHERE credential_id=old.id; END`,
|
||||
`CREATE TABLE organizer_contact_names(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,name TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,uuid),UNIQUE(domain_uuid,owner_uuid,name))`,
|
||||
`INSERT INTO organizer_contact_names SELECT domain_uuid,owner_uuid,uuid,uuid||'.vcf' FROM organizer_contacts`,
|
||||
`CREATE TABLE organizer_contact_epoch(id INTEGER PRIMARY KEY CHECK(id=1),value TEXT NOT NULL)`,
|
||||
`INSERT INTO organizer_contact_epoch VALUES(1,lower(hex(randomblob(32))))`,
|
||||
`CREATE TABLE organizer_contact_changes(sequence INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,UNIQUE(domain_uuid,owner_uuid,uuid))`,
|
||||
`CREATE INDEX organizer_contact_changes_owner ON organizer_contact_changes(domain_uuid,owner_uuid,sequence,uuid)`,
|
||||
`INSERT INTO organizer_contact_changes(domain_uuid,owner_uuid,uuid) SELECT domain_uuid,owner_uuid,uuid FROM organizer_contacts ORDER BY domain_uuid,owner_uuid,uuid`,
|
||||
`CREATE TRIGGER organizer_contact_insert AFTER INSERT ON organizer_contacts BEGIN INSERT INTO organizer_contact_names SELECT new.domain_uuid,new.owner_uuid,new.uuid,new.uuid||'.vcf' WHERE NOT EXISTS(SELECT 1 FROM organizer_contact_names WHERE domain_uuid=new.domain_uuid AND owner_uuid=new.owner_uuid AND uuid=new.uuid); INSERT INTO organizer_contact_changes(domain_uuid,owner_uuid,uuid) VALUES(new.domain_uuid,new.owner_uuid,new.uuid); END`,
|
||||
`CREATE TRIGGER organizer_contact_update AFTER UPDATE ON organizer_contacts BEGIN DELETE FROM organizer_contact_changes WHERE domain_uuid=new.domain_uuid AND owner_uuid=new.owner_uuid AND uuid=new.uuid; INSERT INTO organizer_contact_changes(domain_uuid,owner_uuid,uuid) VALUES(new.domain_uuid,new.owner_uuid,new.uuid); END`,
|
||||
}, Assertions: []string{
|
||||
schemaColumns("organizer_contact_changes", "sequence,domain_uuid,owner_uuid,uuid"),
|
||||
schemaColumns("organizer_contact_credentials", "credential_id"),
|
||||
schemaColumns("organizer_contact_epoch", "id,value"),
|
||||
schemaColumns("organizer_contact_names", "domain_uuid,owner_uuid,uuid,name"),
|
||||
schemaUnique("organizer_contact_names", "domain_uuid,owner_uuid,name"),
|
||||
schemaUnique("organizer_contact_changes", "domain_uuid,owner_uuid,uuid"),
|
||||
schemaIndex("organizer_contact_changes", "organizer_contact_changes_owner", "domain_uuid,owner_uuid,sequence,uuid"),
|
||||
`SELECT 1 WHERE (SELECT count(*) FROM organizer_contact_epoch WHERE id=1 AND length(value)=64)<>1`,
|
||||
`SELECT 1 WHERE (SELECT count(*) FROM sqlite_master WHERE type='trigger' AND name IN ('organizer_contact_insert','organizer_contact_update','organizer_contact_credential_delete'))<>3`,
|
||||
}}}
|
||||
|
||||
type Contact struct {
|
||||
UUID string `json:"uuid"`
|
||||
@@ -344,6 +366,13 @@ func (s *Store) Contact(ctx context.Context, domain, actor, id string) (Contact,
|
||||
return c, err
|
||||
}
|
||||
func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact, rawImport bool) (Contact, error) {
|
||||
mode := "fields"
|
||||
if rawImport {
|
||||
mode = "import"
|
||||
}
|
||||
return s.saveContact(ctx, domain, actor, c, mode, "", "")
|
||||
}
|
||||
func (s *Store) saveContact(ctx context.Context, domain, actor string, c Contact, mode, credential, name string) (Contact, error) {
|
||||
if s.ReadOnly {
|
||||
return c, ErrReadOnly
|
||||
}
|
||||
@@ -364,6 +393,11 @@ func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact
|
||||
if err = contactEnabled(ctx, tx, domain); err != nil {
|
||||
return c, err
|
||||
}
|
||||
if credential != "" {
|
||||
if err = davCredentialAllowed(ctx, tx, domain, actor, credential, true, "contacts"); err != nil {
|
||||
return c, err
|
||||
}
|
||||
}
|
||||
var old Contact
|
||||
var data string
|
||||
err = tx.QueryRowContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, c.UUID).Scan(&data)
|
||||
@@ -377,8 +411,8 @@ func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact
|
||||
if c.Version != old.Version {
|
||||
return c, ErrTaskConflict
|
||||
}
|
||||
if rawImport {
|
||||
if c.Version != 0 {
|
||||
if mode == "import" || mode == "dav" {
|
||||
if mode == "import" && c.Version != 0 {
|
||||
return c, ErrTaskInvalid
|
||||
}
|
||||
parsed, e := ParseContact(c.VCard)
|
||||
@@ -386,7 +420,11 @@ func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact
|
||||
return c, e
|
||||
}
|
||||
parsed.UUID = c.UUID
|
||||
parsed.Version = c.Version
|
||||
c = parsed
|
||||
if old.Version != 0 && old.UID != c.UID {
|
||||
return c, ErrContactUIDConflict
|
||||
}
|
||||
var existing string
|
||||
err = tx.QueryRowContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND uid=?`, domain, actor, c.UID).Scan(&existing)
|
||||
if err == nil {
|
||||
@@ -394,12 +432,17 @@ func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact
|
||||
if json.Unmarshal([]byte(existing), &previous) != nil {
|
||||
return c, ErrTaskInvalid
|
||||
}
|
||||
if previous.VCard != c.VCard || previous.Deleted {
|
||||
return c, ErrTaskConflict
|
||||
if mode == "import" {
|
||||
if previous.VCard != c.VCard || previous.Deleted {
|
||||
return c, ErrTaskConflict
|
||||
}
|
||||
return previous, nil
|
||||
}
|
||||
if previous.UUID != c.UUID {
|
||||
return c, ErrContactUIDConflict
|
||||
}
|
||||
return previous, nil
|
||||
}
|
||||
if !errors.Is(err, sql.ErrNoRows) {
|
||||
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
||||
return c, err
|
||||
}
|
||||
} else {
|
||||
@@ -408,6 +451,29 @@ func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact
|
||||
return c, err
|
||||
}
|
||||
}
|
||||
if name != "" {
|
||||
if !ValidContactDAVName(name) {
|
||||
return c, ErrTaskInvalid
|
||||
}
|
||||
var existing string
|
||||
err = tx.QueryRowContext(ctx, `SELECT name FROM organizer_contact_names WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, c.UUID).Scan(&existing)
|
||||
if err == nil && existing != name {
|
||||
return c, ErrTaskConflict
|
||||
}
|
||||
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
||||
return c, err
|
||||
}
|
||||
if _, err = tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_contact_names VALUES(?,?,?,?)`, domain, actor, c.UUID, name); err != nil {
|
||||
return c, err
|
||||
}
|
||||
var mapped string
|
||||
if err = tx.QueryRowContext(ctx, `SELECT uuid FROM organizer_contact_names WHERE domain_uuid=? AND owner_uuid=? AND name=?`, domain, actor, name).Scan(&mapped); err != nil {
|
||||
return c, err
|
||||
}
|
||||
if mapped != c.UUID {
|
||||
return c, ErrTaskConflict
|
||||
}
|
||||
}
|
||||
c.Version++
|
||||
b, err := json.Marshal(c)
|
||||
if err != nil {
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
@@ -8,6 +9,48 @@ import (
|
||||
"pageswiki/internal/db"
|
||||
)
|
||||
|
||||
func TestContactDAVUpgradePreservesRowsAndTracksChanges(t *testing.T) {
|
||||
st := newSchemaTestStore(t)
|
||||
ctx := context.Background()
|
||||
if e := db.ApplySQLiteMigrations(ctx, st.DB, "contacts", contactMigrations[:1]); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if _, e := st.DB.Exec(`INSERT INTO organizer_contacts VALUES('d','u','c','uid',1,'Name','name','{"name":"Name"}','hash',0)`); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
for range 2 {
|
||||
if e := st.ensureSchemaComponent("contacts"); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
var name, data string
|
||||
var before, after int64
|
||||
var count int
|
||||
if e := st.DB.QueryRow(`SELECT name FROM organizer_contact_names WHERE uuid='c'`).Scan(&name); e != nil || name != "c.vcf" {
|
||||
t.Fatal(name, e)
|
||||
}
|
||||
if e := st.DB.QueryRow(`SELECT data FROM organizer_contacts WHERE uuid='c'`).Scan(&data); e != nil || data != `{"name":"Name"}` {
|
||||
t.Fatal(data, e)
|
||||
}
|
||||
if e := st.DB.QueryRow(`SELECT sequence FROM organizer_contact_changes WHERE uuid='c'`).Scan(&before); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
for range 3 {
|
||||
if _, e := st.DB.Exec(`UPDATE organizer_contacts SET deleted=1 WHERE uuid='c'`); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
if e := st.DB.QueryRow(`SELECT count(*),max(sequence) FROM organizer_contact_changes WHERE uuid='c'`).Scan(&count, &after); e != nil || count != 1 || after <= before {
|
||||
t.Fatal(count, before, after, e)
|
||||
}
|
||||
if _, e := st.DB.Exec(`INSERT INTO organizer_dav_credentials VALUES('credential'); INSERT INTO organizer_contact_credentials VALUES('credential'); DELETE FROM organizer_dav_credentials WHERE id='credential'`); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if e := st.DB.QueryRow(`SELECT count(*) FROM organizer_contact_credentials`).Scan(&count); e != nil || count != 0 {
|
||||
t.Fatal(count, e)
|
||||
}
|
||||
}
|
||||
|
||||
func newSchemaTestStore(t *testing.T) *Store {
|
||||
t.Helper()
|
||||
database, err := db.Open(filepath.Join(t.TempDir(), "schema.db"))
|
||||
@@ -20,6 +63,9 @@ func newSchemaTestStore(t *testing.T) *Store {
|
||||
if _, err = database.Exec(`CREATE TABLE organizer_items(domain_uuid TEXT,owner_uuid TEXT,uuid TEXT,kind TEXT,data TEXT)`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = database.Exec(`CREATE TABLE organizer_dav_credentials(id TEXT PRIMARY KEY)`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &Store{DB: database}
|
||||
}
|
||||
|
||||
|
||||
@@ -33,7 +33,10 @@ func (s *Store) CreateTaskDAVCredential(ctx context.Context, domain, actor, labe
|
||||
|
||||
func (s *Store) CreateDAVCredential(ctx context.Context, domain, actor, label string, write bool, days int, scope string, compatibility ...bool) (TaskDAVCredential, string, error) {
|
||||
compat := len(compatibility) == 1 && compatibility[0]
|
||||
if scope != "tasks" && scope != "calendar" && scope != "all" {
|
||||
if scope == "contacts" && compat {
|
||||
return TaskDAVCredential{}, "", ErrTaskInvalid
|
||||
}
|
||||
if scope != "tasks" && scope != "calendar" && scope != "all" && scope != "contacts" {
|
||||
return TaskDAVCredential{}, "", ErrTaskInvalid
|
||||
}
|
||||
label = strings.TrimSpace(label)
|
||||
@@ -71,12 +74,19 @@ func (s *Store) CreateDAVCredential(ctx context.Context, domain, actor, label st
|
||||
// of accidentally interpreting them as task-only authority.
|
||||
secret = "pw_dav_" + base64.RawURLEncoding.EncodeToString(raw)
|
||||
}
|
||||
if scope == "contacts" {
|
||||
secret = "pw_contactdav_" + base64.RawURLEncoding.EncodeToString(raw)
|
||||
}
|
||||
now := time.Now()
|
||||
c := TaskDAVCredential{ID: uuid.NewString(), Label: label, Write: write, CreatedMS: now.UnixMilli(), ExpiresMS: now.Add(time.Duration(days) * 24 * time.Hour).UnixMilli(), Scope: scope}
|
||||
c.CalendarAccessCompat = compat
|
||||
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_credentials(id,domain_uuid,owner_uuid,label,secret_hash,write_access,created_ms,expires_ms) VALUES(?,?,?,?,?,?,?,?)`, c.ID, domain, actor, c.Label, taskDAVSecretHash(secret), write, c.CreatedMS, c.ExpiresMS)
|
||||
if err == nil {
|
||||
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_scopes(credential_id,scope) VALUES(?,?)`, c.ID, scope)
|
||||
if scope == "contacts" {
|
||||
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_contact_credentials VALUES(?)`, c.ID)
|
||||
} else {
|
||||
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_scopes(credential_id,scope) VALUES(?,?)`, c.ID, scope)
|
||||
}
|
||||
}
|
||||
if err == nil && compat {
|
||||
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_compat(credential_id) VALUES(?)`, c.ID)
|
||||
@@ -90,7 +100,7 @@ func (s *Store) ListTaskDAVCredentials(ctx context.Context, domain, actor string
|
||||
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rows, err := s.DB.QueryContext(ctx, `SELECT id,label,write_access,created_ms,expires_ms,COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks'),EXISTS(SELECT 1 FROM organizer_dav_compat WHERE credential_id=id) FROM organizer_dav_credentials WHERE domain_uuid=? AND owner_uuid=? ORDER BY created_ms DESC LIMIT 100`, domain, actor)
|
||||
rows, err := s.DB.QueryContext(ctx, `SELECT id,label,write_access,created_ms,expires_ms,CASE WHEN EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=id) THEN 'contacts' ELSE COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks') END,EXISTS(SELECT 1 FROM organizer_dav_compat WHERE credential_id=id) FROM organizer_dav_credentials WHERE domain_uuid=? AND owner_uuid=? ORDER BY created_ms DESC LIMIT 100`, domain, actor)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -130,7 +140,7 @@ func davCredentialAllowed(ctx context.Context, q interface {
|
||||
QueryRowContext(context.Context, string, ...any) *sql.Row
|
||||
}, domain, actor, id string, write bool, scope string) error {
|
||||
var yes bool
|
||||
if err := q.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_credentials WHERE id=? AND domain_uuid=? AND owner_uuid=? AND expires_ms>? AND (?=0 OR write_access=1) AND COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks') IN (?, 'all'))`, id, domain, actor, time.Now().UnixMilli(), write, scope).Scan(&yes); err != nil {
|
||||
if err := q.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_credentials WHERE id=? AND domain_uuid=? AND owner_uuid=? AND expires_ms>? AND (?=0 OR write_access=1) AND ((?='contacts' AND EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=id)) OR (? IN ('tasks','calendar') AND NOT EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=id) AND COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks') IN (?, 'all'))))`, id, domain, actor, time.Now().UnixMilli(), write, scope, scope, scope).Scan(&yes); err != nil {
|
||||
return err
|
||||
}
|
||||
if !yes {
|
||||
@@ -151,16 +161,19 @@ func (s *Store) CheckDAVCredential(ctx context.Context, domain, actor, id string
|
||||
|
||||
// An empty requested scope is discovery only; callers must filter collections.
|
||||
func (s *Store) AuthenticateDAV(ctx context.Context, domain, id, secret, requested string) (string, bool, string, error) {
|
||||
if len(secret) > 128 || !(strings.HasPrefix(secret, "pw_taskdav_") || strings.HasPrefix(secret, "pw_dav_")) {
|
||||
if len(secret) > 128 || !(strings.HasPrefix(secret, "pw_taskdav_") || strings.HasPrefix(secret, "pw_dav_") || strings.HasPrefix(secret, "pw_contactdav_")) {
|
||||
return "", false, "", ErrAccessDenied
|
||||
}
|
||||
var actor, hash, state, scope string
|
||||
var write bool
|
||||
err := s.DB.QueryRowContext(ctx, `SELECT c.owner_uuid,c.secret_hash,c.write_access,p.state,COALESCE(s.scope,'tasks') FROM organizer_dav_credentials c JOIN principals p ON p.uuid=c.owner_uuid LEFT JOIN organizer_dav_scopes s ON s.credential_id=c.id WHERE c.id=? AND c.domain_uuid=? AND c.expires_ms>?`, id, domain, time.Now().UnixMilli()).Scan(&actor, &hash, &write, &state, &scope)
|
||||
err := s.DB.QueryRowContext(ctx, `SELECT c.owner_uuid,c.secret_hash,c.write_access,p.state,CASE WHEN EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=c.id) THEN 'contacts' ELSE COALESCE(s.scope,'tasks') END FROM organizer_dav_credentials c JOIN principals p ON p.uuid=c.owner_uuid LEFT JOIN organizer_dav_scopes s ON s.credential_id=c.id WHERE c.id=? AND c.domain_uuid=? AND c.expires_ms>?`, id, domain, time.Now().UnixMilli()).Scan(&actor, &hash, &write, &state, &scope)
|
||||
if err != nil || subtle.ConstantTimeCompare([]byte(hash), []byte(taskDAVSecretHash(secret))) != 1 {
|
||||
return "", false, "", ErrAccessDenied
|
||||
}
|
||||
if requested != "" && scope != "all" && scope != requested {
|
||||
if strings.HasPrefix(secret, "pw_contactdav_") && scope != "contacts" {
|
||||
return "", false, "", ErrAccessDenied
|
||||
}
|
||||
if requested != "" && scope != requested && !(scope == "all" && (requested == "tasks" || requested == "calendar")) {
|
||||
return "", false, "", ErrAccessDenied
|
||||
}
|
||||
if err = taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
||||
|
||||
Reference in new issue
Block a user