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

285 lines
9.3 KiB
Go

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()
}