432 lines
13 KiB
Go
432 lines
13 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")}}}
|
|
|
|
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) {
|
|
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
|
|
}
|
|
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 rawImport {
|
|
if c.Version != 0 {
|
|
return c, ErrTaskInvalid
|
|
}
|
|
parsed, e := ParseContact(c.VCard)
|
|
if e != nil {
|
|
return c, e
|
|
}
|
|
parsed.UUID = c.UUID
|
|
c = parsed
|
|
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 previous.VCard != c.VCard || previous.Deleted {
|
|
return c, ErrTaskConflict
|
|
}
|
|
return previous, nil
|
|
}
|
|
if !errors.Is(err, sql.ErrNoRows) {
|
|
return c, err
|
|
}
|
|
} else {
|
|
c, err = buildContact(old, c)
|
|
if err != nil {
|
|
return c, err
|
|
}
|
|
}
|
|
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()
|
|
}
|