Files
pages/internal/store/contacts.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

498 lines
17 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net/mail"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"pageswiki/internal/db"
)
var contactMigrations = []db.SQLMigration{{Version: 1, Name: "private_address_book", Statements: []string{
`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")}}, {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"`
UID string `json:"uid"`
Version int64 `json:"version"`
Name string `json:"name"`
Emails []string `json:"emails"`
Phones []string `json:"phones"`
Organization string `json:"organization"`
Notes string `json:"notes"`
VCard string `json:"vcard,omitempty"`
Deleted bool `json:"deleted"`
}
// Preserve every unfolded property, including unsupported fields/parameters.
// Encoded legacy v2.1/QP and malformed data are rejected, never silently lost.
func cardLines(raw string) ([]string, error) {
if len(raw) > 65536 || !utf8.ValidString(raw) || strings.ContainsRune(raw, 0) {
return nil, ErrTaskInvalid
}
for _, c := range raw {
if c < 32 && c != '\r' && c != '\n' && c != '\t' || c == 127 {
return nil, ErrTaskInvalid
}
}
raw = strings.ReplaceAll(raw, "\r\n", "\n")
if strings.ContainsRune(raw, '\r') {
return nil, ErrTaskInvalid
}
var lines []string
for _, line := range strings.Split(strings.TrimSuffix(raw, "\n"), "\n") {
if strings.HasPrefix(line, " ") || strings.HasPrefix(line, "\t") {
if len(lines) == 0 {
return nil, ErrTaskInvalid
}
lines[len(lines)-1] += line[1:]
} else {
lines = append(lines, line)
}
}
if len(lines) < 4 || lines[0] != "BEGIN:VCARD" || lines[len(lines)-1] != "END:VCARD" {
return nil, ErrTaskInvalid
}
return lines, nil
}
func cardKey(line string) (string, string, error) {
quoted := false
colon := -1
for i, c := range line {
if c == '"' {
quoted = !quoted
}
if c == ':' && !quoted {
colon = i
break
}
}
if colon < 1 {
return "", "", ErrTaskInvalid
}
head := line[:colon]
key := strings.SplitN(head, ";", 2)[0]
if i := strings.LastIndex(key, "."); i >= 0 {
key = key[i+1:]
}
for _, c := range key {
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '-') {
return "", "", ErrTaskInvalid
}
}
upper := strings.ToUpper(head)
if strings.Contains(upper, "ENCODING=") || strings.Contains(upper, "CHARSET=") {
return "", "", ErrTaskInvalid
}
return strings.ToUpper(key), line[colon+1:], nil
}
func cardText(s string) string {
var b strings.Builder
for i := 0; i < len(s); i++ {
if s[i] == '\\' && i+1 < len(s) {
i++
if s[i] == 'n' || s[i] == 'N' {
b.WriteByte('\n')
continue
}
}
b.WriteByte(s[i])
}
return b.String()
}
func escapeCard(s string) string {
return strings.NewReplacer("\\", "\\\\", "\r\n", "\\n", "\n", "\\n", ";", "\\;", ",", "\\,").Replace(s)
}
func foldCard(lines []string) string {
var b strings.Builder
for _, line := range lines {
first := true
for len(line) > 0 {
n := 75
if !first {
b.WriteByte(' ')
n = 74
}
if len(line) < n {
n = len(line)
}
for n > 0 && n < len(line) && !utf8.RuneStart(line[n]) {
n--
}
b.WriteString(line[:n])
b.WriteString("\r\n")
line = line[n:]
first = false
}
}
return b.String()
}
func ParseContact(raw string) (Contact, error) {
c := Contact{Emails: []string{}, Phones: []string{}}
lines, err := cardLines(raw)
if err != nil {
return c, err
}
versions, names, uids := 0, 0, 0
for _, line := range lines[1 : len(lines)-1] {
key, value, e := cardKey(line)
if e != nil {
return c, e
}
value = cardText(value)
switch key {
case "VERSION":
versions++
if value != "4.0" && value != "3.0" {
return c, ErrTaskInvalid
}
case "BEGIN", "END":
return c, ErrTaskInvalid
case "UID":
uids++
c.UID = value
case "FN":
names++
if c.Name == "" {
c.Name = value
}
case "EMAIL":
c.Emails = append(c.Emails, value)
case "TEL":
c.Phones = append(c.Phones, strings.TrimPrefix(value, "tel:"))
case "ORG":
if c.Organization == "" {
c.Organization = value
}
case "NOTE":
if c.Notes == "" {
c.Notes = value
}
}
}
if versions != 1 || names < 1 || uids > 1 || len(c.Name) > 300 || len(c.UID) > 1024 || strings.TrimSpace(c.Name) == "" || len(c.Emails) > 30 || len(c.Phones) > 30 {
return c, ErrTaskInvalid
}
if lines[1] != "VERSION:4.0" && lines[1] != "VERSION:3.0" {
return c, ErrTaskInvalid
}
for _, value := range append([]string{c.Name, c.UID}, c.Emails...) {
if strings.ContainsAny(value, "\r\n\x00") {
return c, ErrTaskInvalid
}
}
for _, value := range c.Emails {
a, e := mail.ParseAddress(value)
if e != nil || a.Address != value {
return c, ErrTaskInvalid
}
}
if c.UID == "" {
sum := sha256.Sum256([]byte(raw))
c.UID = "urn:pageswiki:import:" + hex.EncodeToString(sum[:])
lines = append(lines[:len(lines)-1], "UID:"+c.UID, "END:VCARD")
}
c.VCard = foldCard(lines)
return c, nil
}
// Editing the visible fields retains other fields verbatim. Even repeated FN,
// ORG/NOTE and typed email/phone fields survive when that field is unchanged.
func buildContact(old Contact, c Contact) (Contact, error) {
if len(c.Name) > 300 || strings.TrimSpace(c.Name) == "" || len(c.Notes) > 16384 || len(c.Organization) > 1000 || len(c.Emails) > 30 || len(c.Phones) > 30 {
return c, ErrTaskInvalid
}
for _, value := range append(append([]string{c.Name, c.Organization}, c.Emails...), c.Phones...) {
if strings.ContainsAny(value, "\r\n\x00") {
return c, ErrTaskInvalid
}
}
for _, value := range c.Emails {
a, e := mail.ParseAddress(value)
if e != nil || a.Address != value {
return c, ErrTaskInvalid
}
}
lines := []string{"BEGIN:VCARD", "VERSION:4.0", "UID:urn:uuid:" + c.UUID, "END:VCARD"}
if old.VCard != "" {
var e error
lines, e = cardLines(old.VCard)
if e != nil {
return c, e
}
}
changes := map[string][]string{}
if old.VCard == "" || c.Name != old.Name {
changes["FN"] = []string{c.Name}
}
if c.Organization != old.Organization {
changes["ORG"] = []string{c.Organization}
}
if c.Notes != old.Notes {
changes["NOTE"] = []string{c.Notes}
}
if strings.Join(c.Emails, "\x00") != strings.Join(old.Emails, "\x00") {
changes["EMAIL"] = c.Emails
}
if strings.Join(c.Phones, "\x00") != strings.Join(old.Phones, "\x00") {
changes["TEL"] = c.Phones
}
out := []string{}
for _, line := range lines[:len(lines)-1] {
k, _, _ := cardKey(line)
if _, replace := changes[k]; !replace {
out = append(out, line)
}
}
for _, key := range []string{"FN", "ORG", "NOTE", "EMAIL", "TEL"} {
for _, value := range changes[key] {
if value != "" {
out = append(out, key+":"+escapeCard(value))
}
}
}
out = append(out, "END:VCARD")
parsed, e := ParseContact(foldCard(out))
parsed.UUID = c.UUID
parsed.Version = c.Version
parsed.Deleted = c.Deleted
return parsed, e
}
func contactEnabled(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, domain string) error {
var raw string
err := q.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=? AND key='system_extension_states'`, domain).Scan(&raw)
if errors.Is(err, sql.ErrNoRows) || err == nil && raw == "" {
return nil
}
if err != nil {
return err
}
states := map[string]bool{}
if json.Unmarshal([]byte(raw), &states) != nil {
return ErrAccessDenied
}
if on, ok := states["organizer.contacts"]; ok && !on {
return ErrAccessDenied
}
return nil
}
func (s *Store) Contacts(ctx context.Context, domain, actor, query, after string) ([]Contact, string, error) {
return s.ListContacts(ctx, domain, actor, query, after, false)
}
func (s *Store) ListContacts(ctx context.Context, domain, actor, query, after string, deleted bool) ([]Contact, string, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, "", err
}
if err := contactEnabled(ctx, s.DB, domain); err != nil {
return nil, "", err
}
if len(query) > 200 {
return nil, "", ErrTaskInvalid
}
rows, err := s.DB.QueryContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND deleted=? AND uuid>? AND instr(search,?)>0 ORDER BY uuid LIMIT 101`, domain, actor, deleted, after, strings.ToLower(query))
if err != nil {
return nil, "", err
}
defer rows.Close()
out := []Contact{}
next := ""
for rows.Next() {
var raw string
if err = rows.Scan(&raw); err != nil {
return nil, "", err
}
var c Contact
if err = json.Unmarshal([]byte(raw), &c); err != nil {
return nil, "", err
}
if len(out) == 100 {
next = out[99].UUID
break
}
c.VCard = ""
out = append(out, c)
}
return out, next, rows.Err()
}
func (s *Store) Contact(ctx context.Context, domain, actor, id string) (Contact, error) {
var c Contact
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return c, err
}
if err := contactEnabled(ctx, s.DB, domain); err != nil {
return c, err
}
var raw string
err := s.DB.QueryRowContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, id).Scan(&raw)
if err == nil {
err = json.Unmarshal([]byte(raw), &c)
}
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
}
if id, e := uuid.Parse(c.UUID); e != nil || id.String() != c.UUID || c.Version < 0 {
return c, ErrTaskInvalid
}
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return c, err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
return c, err
}
if err = taskActor(ctx, tx, domain, actor, true); err != nil {
return c, err
}
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)
if err == nil {
if err = json.Unmarshal([]byte(data), &old); err != nil {
return c, err
}
} else if !errors.Is(err, sql.ErrNoRows) {
return c, err
}
if c.Version != old.Version {
return c, ErrTaskConflict
}
if mode == "import" || mode == "dav" {
if mode == "import" && c.Version != 0 {
return c, ErrTaskInvalid
}
parsed, e := ParseContact(c.VCard)
if e != nil {
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 {
var previous Contact
if json.Unmarshal([]byte(existing), &previous) != nil {
return c, ErrTaskInvalid
}
if mode == "import" {
if previous.VCard != c.VCard || previous.Deleted {
return c, ErrTaskConflict
}
return previous, nil
}
if previous.UUID != c.UUID {
return c, ErrContactUIDConflict
}
}
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return c, err
}
} else {
c, err = buildContact(old, c)
if err != nil {
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 {
return c, err
}
hash := sha256.Sum256([]byte(c.VCard))
digest := hex.EncodeToString(hash[:])
if err = s.persistDocument(digest, c.VCard); err != nil {
return c, err
}
search := strings.ToLower(c.Name + "\n" + c.Organization + "\n" + strings.Join(c.Emails, "\n") + "\n" + strings.Join(c.Phones, "\n"))
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_contacts(domain_uuid,owner_uuid,uuid,uid,version,name,search,data,hash,deleted) VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(domain_uuid,owner_uuid,uuid) DO UPDATE SET version=excluded.version,name=excluded.name,search=excluded.search,data=excluded.data,hash=excluded.hash,deleted=excluded.deleted`, domain, actor, c.UUID, c.UID, c.Version, c.Name, search, string(b), digest, c.Deleted)
if err != nil {
return c, fmt.Errorf("save contact: %w", err)
}
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_contact_revisions VALUES(?,?,?,?,?,?,?)`, domain, actor, c.UUID, c.Version, digest, c.Deleted, time.Now().UnixMilli())
if err != nil {
return c, err
}
return c, tx.Commit()
}