442 lines
11 KiB
Go
442 lines
11 KiB
Go
package client
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
|
|
"forge.redroom.link/yves/meowlib"
|
|
"github.com/google/uuid"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
// One RWMutex per SQLite file path. Entries are never deleted (bounded by
|
|
// peer count, which is small). RLock for reads, Lock for writes.
|
|
var dbFileMu sync.Map
|
|
|
|
func getDbFileMutex(path string) *sync.RWMutex {
|
|
v, _ := dbFileMu.LoadOrStore(path, &sync.RWMutex{})
|
|
return v.(*sync.RWMutex)
|
|
}
|
|
|
|
func withDbWrite(path string, fn func(*sql.DB) error) error {
|
|
mu := getDbFileMutex(path)
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
db, err := sql.Open("sqlite3", path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer db.Close()
|
|
return fn(db)
|
|
}
|
|
|
|
func withDbRead(path string, fn func(*sql.DB) error) error {
|
|
mu := getDbFileMutex(path)
|
|
mu.RLock()
|
|
defer mu.RUnlock()
|
|
db, err := sql.Open("sqlite3", path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer db.Close()
|
|
return fn(db)
|
|
}
|
|
|
|
func dbPath(cfg *Config, identity *Identity, dbid string) string {
|
|
return filepath.Join(cfg.StoragePath, identity.Uuid, dbid+cfg.DbSuffix)
|
|
}
|
|
|
|
func storeMessage(peer *Peer, usermessage *meowlib.UserMessage, filenames []string, password string) error {
|
|
cfg := GetConfig()
|
|
identity := cfg.GetIdentity()
|
|
|
|
isNew := len(peer.DbIds) == 0
|
|
var dbid string
|
|
if isNew {
|
|
dbid = uuid.NewString()
|
|
peer.DbIds = []string{dbid}
|
|
identity.Peers.StorePeer(peer)
|
|
identity.CreateFolder()
|
|
} else {
|
|
dbid = peer.DbIds[len(peer.DbIds)-1]
|
|
}
|
|
|
|
// Detach file attachments — no DB lock needed for file I/O.
|
|
hiddenFilenames := []string{}
|
|
if len(usermessage.Files) > 0 {
|
|
secureDir := filepath.Join(cfg.StoragePath, identity.Uuid, "securefiles")
|
|
if _, err := os.Stat(secureDir); os.IsNotExist(err) {
|
|
if err = os.MkdirAll(secureDir, 0755); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, f := range usermessage.Files {
|
|
hiddenFilename := uuid.NewString()
|
|
encData, err := meowlib.SymEncrypt(password, f.Data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
hidden := filepath.Join(secureDir, hiddenFilename)
|
|
os.WriteFile(hidden, encData, 0600)
|
|
hiddenFilenames = append(hiddenFilenames, hidden)
|
|
f.Data = []byte(hidden)
|
|
}
|
|
}
|
|
|
|
outbound := usermessage.From != peer.ContactPublicKey
|
|
dbm := UserMessageToDbMessage(outbound, usermessage, hiddenFilenames)
|
|
out, err := proto.Marshal(dbm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
encData, err := meowlib.SymEncrypt(password, out)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var id int64
|
|
path := dbPath(cfg, identity, dbid)
|
|
err = withDbWrite(path, func(db *sql.DB) error {
|
|
// SQLite creates the file on first Open; create the table if new DB.
|
|
if isNew {
|
|
if err := createMessageTable(db); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
stmt, err := db.Prepare(`INSERT INTO message(m) VALUES (?) RETURNING ID`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
result, err := stmt.Exec(encData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
id, err = result.LastInsertId()
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
peer.LastMessage = DbMessageToInternalUserMessage(id, dbid, dbm)
|
|
identity.Peers.StorePeer(peer)
|
|
return nil
|
|
}
|
|
|
|
func loadNewMessages(peer *Peer, lastDbId int, password string) ([]*InternalUserMessage, error) {
|
|
var messages []*InternalUserMessage
|
|
cfg := GetConfig()
|
|
identity := cfg.GetIdentity()
|
|
if len(peer.DbIds) == 0 {
|
|
return messages, nil
|
|
}
|
|
fileidx := len(peer.DbIds) - 1
|
|
if lastDbId == 0 {
|
|
lastDbId = math.MaxInt64
|
|
}
|
|
err := withDbRead(dbPath(cfg, identity, peer.DbIds[fileidx]), func(db *sql.DB) error {
|
|
stm, err := db.Prepare("SELECT id, m FROM message WHERE id > ? ORDER BY id DESC")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer stm.Close()
|
|
rows, err := stm.Query(lastDbId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var id int64
|
|
var m []byte
|
|
if err = rows.Scan(&id, &m); err != nil {
|
|
return err
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var dbm meowlib.DbMessage
|
|
if err = proto.Unmarshal(decdata, &dbm); err != nil {
|
|
return err
|
|
}
|
|
ium := DbMessageToInternalUserMessage(id, peer.DbIds[fileidx], &dbm)
|
|
ium.Dbid = id
|
|
ium.Dbfile = peer.DbIds[fileidx]
|
|
messages = append(messages, ium)
|
|
}
|
|
return nil
|
|
})
|
|
// TODO DB overlap
|
|
return messages, err
|
|
}
|
|
|
|
func loadMessagesHistory(peer *Peer, inAppMsgCount int, lastDbId int, wantMore int, password string) ([]InternalUserMessage, error) {
|
|
var messages []InternalUserMessage
|
|
cfg := GetConfig()
|
|
if len(peer.DbIds) == 0 {
|
|
return messages, nil
|
|
}
|
|
fileidx := len(peer.DbIds) - 1
|
|
countStack, err := getMessageCount(peer.DbIds[fileidx])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for inAppMsgCount > countStack {
|
|
fileidx--
|
|
if fileidx < 0 {
|
|
return nil, nil
|
|
}
|
|
newCount, err := getMessageCount(peer.DbIds[fileidx])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
countStack += newCount
|
|
}
|
|
if lastDbId == 0 {
|
|
lastDbId = math.MaxInt64
|
|
}
|
|
err = withDbRead(filepath.Join(cfg.StoragePath, cfg.GetIdentity().Uuid, peer.DbIds[fileidx]+cfg.DbSuffix), func(db *sql.DB) error {
|
|
stm, err := db.Prepare("SELECT id, m FROM message WHERE id < ? ORDER BY id DESC LIMIT ?")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer stm.Close()
|
|
rows, err := stm.Query(lastDbId, wantMore)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var id int64
|
|
var m []byte
|
|
if err = rows.Scan(&id, &m); err != nil {
|
|
return err
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var dbm meowlib.DbMessage
|
|
if err = proto.Unmarshal(decdata, &dbm); err != nil {
|
|
return err
|
|
}
|
|
ium := DbMessageToInternalUserMessage(id, peer.DbIds[fileidx], &dbm)
|
|
ium.Dbid = id
|
|
ium.Dbfile = peer.DbIds[fileidx]
|
|
messages = append(messages, *ium)
|
|
}
|
|
return nil
|
|
})
|
|
// TODO DB overlap
|
|
return messages, err
|
|
}
|
|
|
|
func GetDbMessage(dbFile string, dbId int64, password string) (*meowlib.DbMessage, error) {
|
|
cfg := GetConfig()
|
|
path := filepath.Join(cfg.StoragePath, cfg.GetIdentity().Uuid, dbFile+cfg.DbSuffix)
|
|
var dbm meowlib.DbMessage
|
|
found := false
|
|
err := withDbRead(path, func(db *sql.DB) error {
|
|
stm, err := db.Prepare("SELECT id, m FROM message WHERE id=?")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer stm.Close()
|
|
rows, err := stm.Query(dbId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
found = true
|
|
var id int64
|
|
var m []byte
|
|
if err = rows.Scan(&id, &m); err != nil {
|
|
return err
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = proto.Unmarshal(decdata, &dbm); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !found {
|
|
return nil, fmt.Errorf("message row %d not found in %s", dbId, dbFile)
|
|
}
|
|
return &dbm, nil
|
|
}
|
|
|
|
func UpdateDbMessage(dbm *meowlib.DbMessage, dbFile string, dbId int64, password string) error {
|
|
cfg := GetConfig()
|
|
path := filepath.Join(cfg.StoragePath, cfg.GetIdentity().Uuid, dbFile+cfg.DbSuffix)
|
|
out, err := proto.Marshal(dbm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
encData, err := meowlib.SymEncrypt(password, out)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return withDbWrite(path, func(db *sql.DB) error {
|
|
stmt, err := db.Prepare(`UPDATE message SET m=? WHERE id=?`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = stmt.Exec(encData, dbId)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func GetMessagePreview(dbFile string, dbId int64, password string) ([]byte, error) {
|
|
dbm, err := GetDbMessage(dbFile, dbId, password)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return FilePreview(dbm.FilePaths[0], password)
|
|
}
|
|
|
|
func FilePreview(filename string, password string) ([]byte, error) {
|
|
encData, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return meowlib.SymDecrypt(password, encData)
|
|
}
|
|
|
|
func InternalUserMessagePreview(msg *InternalUserMessage, password string) ([]byte, error) {
|
|
if len(msg.FilePaths) == 0 {
|
|
return nil, nil
|
|
}
|
|
return FilePreview(msg.FilePaths[0], password)
|
|
}
|
|
|
|
func getMessageCount(dbid string) (int, error) {
|
|
cfg := GetConfig()
|
|
path := filepath.Join(cfg.StoragePath, cfg.GetIdentity().Uuid, dbid+cfg.DbSuffix)
|
|
var count int
|
|
err := withDbRead(path, func(db *sql.DB) error {
|
|
return db.QueryRow("SELECT COUNT(*) FROM message").Scan(&count)
|
|
})
|
|
return count, err
|
|
}
|
|
|
|
// SetMessageServerDelivery updates the server delivery UUID and timestamp for a stored message.
|
|
func SetMessageServerDelivery(dbFile string, dbId int64, serverUid string, receiveTime uint64, password string) error {
|
|
dbm, err := GetDbMessage(dbFile, dbId, password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
dbm.ServerDeliveryUuid = serverUid
|
|
dbm.ServerDeliveryTimestamp = receiveTime
|
|
return UpdateDbMessage(dbm, dbFile, dbId, password)
|
|
}
|
|
|
|
// FindMessageByUuid scans all DB files for a peer (newest first) and returns
|
|
// the dbFile, row ID, and DbMessage for the message whose Status.Uuid matches.
|
|
func FindMessageByUuid(peer *Peer, messageUuid string, password string) (string, int64, *meowlib.DbMessage, error) {
|
|
cfg := GetConfig()
|
|
identity := cfg.GetIdentity()
|
|
for i := len(peer.DbIds) - 1; i >= 0; i-- {
|
|
dbid := peer.DbIds[i]
|
|
path := filepath.Join(cfg.StoragePath, identity.Uuid, dbid+cfg.DbSuffix)
|
|
var foundFile string
|
|
var foundId int64
|
|
var foundMsg meowlib.DbMessage
|
|
err := withDbRead(path, func(db *sql.DB) error {
|
|
rows, err := db.Query("SELECT id, m FROM message ORDER BY id DESC")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var id int64
|
|
var m []byte
|
|
if err := rows.Scan(&id, &m); err != nil {
|
|
continue
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
var dbm meowlib.DbMessage
|
|
if err := proto.Unmarshal(decdata, &dbm); err != nil {
|
|
continue
|
|
}
|
|
if dbm.Status != nil && dbm.Status.Uuid == messageUuid {
|
|
foundFile = dbid
|
|
foundId = id
|
|
foundMsg = dbm
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err == nil && foundFile != "" {
|
|
return foundFile, foundId, &foundMsg, nil
|
|
}
|
|
}
|
|
return "", 0, nil, fmt.Errorf("message with UUID %s not found", messageUuid)
|
|
}
|
|
|
|
// UpdateMessageAck finds a stored outbound message by UUID and stamps it with
|
|
// the received and/or processed timestamps from an inbound ACK message.
|
|
func UpdateMessageAck(peer *Peer, messageUuid string, receivedAt uint64, processedAt uint64, password string) error {
|
|
dbFile, dbId, dbm, err := FindMessageByUuid(peer, messageUuid, password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if dbm.Status == nil {
|
|
dbm.Status = &meowlib.ConversationStatus{}
|
|
}
|
|
if receivedAt != 0 {
|
|
dbm.Status.Received = receivedAt
|
|
}
|
|
if processedAt != 0 {
|
|
dbm.Status.Processed = processedAt
|
|
}
|
|
return UpdateDbMessage(dbm, dbFile, dbId, password)
|
|
}
|
|
|
|
func createMessageTable(db *sql.DB) error {
|
|
stmt, err := db.Prepare(`CREATE TABLE message (
|
|
"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
|
|
"m" BLOB)`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
stmt.Exec()
|
|
return nil
|
|
}
|
|
|
|
func createServerTable(db *sql.DB) error {
|
|
stmt, err := db.Prepare(`CREATE TABLE servers (
|
|
"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
|
|
"country" varchar(2),
|
|
"public" bool,
|
|
"uptime" int,
|
|
"bandwith" float,
|
|
"load" float,
|
|
"url" varchar(2000)
|
|
"name" varchar(255);
|
|
"description" varchar(5000)
|
|
"publickey" varchar(10000)
|
|
)`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
stmt.Exec()
|
|
return nil
|
|
}
|