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 5000 || out.Len()+len(c.VCard) > 16<<20 { return "", ErrTaskDAVLimit } out.WriteString(c.VCard) } return out.String(), rows.Err() }