285 lines
9.3 KiB
Go
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()
|
|
}
|