package store import ( "context" "crypto/sha256" "database/sql" "encoding/hex" "encoding/json" "errors" "fmt" "strconv" "strings" "time" "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) (result ContactDAVSnapshot, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() 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) (result ContactDAVSnapshot, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() return s.contactDAVSnapshot(ctx, domain, actor, "", 5000, true) } func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int, metadata bool) (result ContactDAVSnapshot, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() ctx, cancel := context.WithTimeout(ctx, 5*time.Second) defer cancel() out := ContactDAVSnapshot{Items: []ContactDAVItem{}} options := &sql.TxOptions{ReadOnly: true} if s.sqlBackend == storePostgreSQL { // High-water mark and resource rows must be the same snapshot; // READ COMMITTED can skip a concurrent change permanently. options.Isolation = sql.LevelRepeatableRead } tx, err := s.DB.BeginTx(ctx, options) if err != nil { return out, err } defer tx.Rollback() if err = s.taskActor(ctx, tx, domain, actor, false); err != nil { return out, err } if err = s.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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2), 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))` if s.sqlBackend == storePostgreSQL { fields = `json_build_object('uuid',c.uuid,'version',c.version)::text,n.name,x.sequence,octet_length(c.data::jsonb->>'vcard')` } } 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=`+s.sqlParam(1)+` AND x.owner_uuid=`+s.sqlParam(2)+` AND x.sequence>`+s.sqlParam(3)+` AND (`+s.sqlParam(4)+`<>'' OR c.deleted=0) ORDER BY x.sequence LIMIT `+s.sqlParam(5), 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) (result Contact, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() if !ValidContactDAVName(name) { return Contact{}, ErrTaskInvalid } if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil { return Contact{}, err } if err := s.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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND name=`+s.sqlParam(3), 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) (result Contact, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() 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) (result []ContactRevision, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() 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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+` AND (CAST(`+s.sqlParam(4)+` AS BIGINT)=0 OR version<`+s.sqlParam(5)+`) 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) (result Contact, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() 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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+` AND version=`+s.sqlParam(4), 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) (result Contact, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() 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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+` AND version=`+s.sqlParam(4), 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 SQL statement 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) (result string, resultErr error) { defer func() { resultErr = s.sqlError("contacts repository", resultErr) }() if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil { return "", err } if err := s.contactEnabled(ctx, s.DB, domain); err != nil { return "", err } rows, err := s.DB.QueryContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` 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() }