335 lines
9.1 KiB
Go
335 lines
9.1 KiB
Go
package client
|
|
|
|
import (
|
|
"database/sql"
|
|
"math"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"forge.redroom.link/yves/meowlib"
|
|
"github.com/google/uuid"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
func StoreMessage(peer *Peer, usermessage *meowlib.UserMessage, filenames []string, password string) error {
|
|
var dbid string
|
|
cfg := GetConfig()
|
|
identity := cfg.GetIdentity()
|
|
// If no db/no ID create DB + Tablz
|
|
// TODO : if file size > X new db
|
|
if len(peer.DbIds) == 0 {
|
|
dbid = uuid.NewString()
|
|
peer.DbIds = []string{dbid}
|
|
|
|
identity.Save()
|
|
identity.CreateFolder()
|
|
file, err := os.Create(filepath.Join(cfg.StoragePath, identity.Uuid, dbid+GetConfig().DbSuffix))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
file.Close()
|
|
peer.DbIds = append(peer.DbIds, dbid)
|
|
sqliteDatabase, _ := sql.Open("sqlite3", filepath.Join(cfg.StoragePath, identity.Uuid, dbid+GetConfig().DbSuffix)) // Open the created SQLite File
|
|
err = createMessageTable(sqliteDatabase)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sqliteDatabase.Close()
|
|
} else {
|
|
dbid = peer.DbIds[len(peer.DbIds)-1]
|
|
}
|
|
// Open Db
|
|
db, _ := sql.Open("sqlite3", filepath.Join(cfg.StoragePath, identity.Uuid, dbid+GetConfig().DbSuffix)) // Open the created SQLite File
|
|
defer db.Close()
|
|
// Detach Files
|
|
hiddenFilenames := []string{}
|
|
if len(usermessage.Files) > 0 {
|
|
for _, f := range usermessage.Files {
|
|
hiddenFilename := uuid.NewString()
|
|
// Cypher file
|
|
encData, err := meowlib.SymEncrypt(password, f.Data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := os.Stat(filepath.Join(cfg.StoragePath, identity.Uuid, "securefiles")); os.IsNotExist(err) {
|
|
err = os.MkdirAll(filepath.Join(cfg.StoragePath, identity.Uuid, "securefiles"), 0755)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
os.WriteFile(filepath.Join(cfg.StoragePath, identity.Uuid, "securefiles", hiddenFilename), encData, 0600)
|
|
hiddenFilenames = append(hiddenFilenames, filepath.Join(cfg.StoragePath, identity.Uuid, "securefiles", hiddenFilename))
|
|
// replace f.Data by uuid filename
|
|
f.Data = []byte(filepath.Join(cfg.StoragePath, identity.Uuid, "securefiles", hiddenFilename))
|
|
}
|
|
}
|
|
outbound := true
|
|
if usermessage.From == peer.ContactPublicKey {
|
|
outbound = false
|
|
}
|
|
// Convert UserMessage to DbMessage
|
|
dbm := UserMessageToDbMessage(outbound, usermessage, hiddenFilenames)
|
|
// Encrypt message
|
|
out, err := proto.Marshal(dbm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
encData, err := meowlib.SymEncrypt(password, out)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Insert message
|
|
insertMessageSQL := `INSERT INTO message(m) VALUES (?) RETURNING ID`
|
|
statement, err := db.Prepare(insertMessageSQL) // Prepare statement.
|
|
if err != nil {
|
|
return err
|
|
}
|
|
result, err := statement.Exec(encData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
id, err := result.LastInsertId()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ium := DbMessageToInternalUserMessage(id, dbid, dbm)
|
|
peer.LastMessage = ium
|
|
identity.Save()
|
|
return nil
|
|
}
|
|
|
|
// Get new messages from a peer
|
|
func GetNewMessages(peer *Peer, lastDbId int, password string) ([]*InternalUserMessage, error) {
|
|
var messages []*InternalUserMessage
|
|
cfg := GetConfig()
|
|
identity := cfg.GetIdentity()
|
|
// handle no db yet
|
|
if len(peer.DbIds) == 0 {
|
|
return messages, nil
|
|
}
|
|
fileidx := len(peer.DbIds) - 1
|
|
// There fileidx should provide the db that we need (unless wantMore overlaps the next DB)
|
|
db, _ := sql.Open("sqlite3", filepath.Join(cfg.StoragePath, identity.Uuid, peer.DbIds[fileidx]+GetConfig().DbSuffix)) // Open the created SQLite File
|
|
defer db.Close()
|
|
// if it's first app query, it won't hold a lastIndex, so let's start from end
|
|
if lastDbId == 0 {
|
|
lastDbId = math.MaxInt64
|
|
}
|
|
stm, err := db.Prepare("SELECT id, m FROM message WHERE id > ? ORDER BY id DESC")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer stm.Close()
|
|
rows, err := stm.Query(lastDbId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var ium *InternalUserMessage
|
|
var dbm meowlib.DbMessage
|
|
var id int64
|
|
var m []byte
|
|
err = rows.Scan(&id, &m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = proto.Unmarshal(decdata, &dbm)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ium = DbMessageToInternalUserMessage(id, peer.DbIds[fileidx], &dbm)
|
|
ium.Dbid = id
|
|
ium.Dbfile = peer.DbIds[fileidx]
|
|
messages = append(messages, ium)
|
|
}
|
|
// TODO DB overlap
|
|
return messages, nil
|
|
}
|
|
|
|
// Get old messages from a peer
|
|
func GetMessagesHistory(peer *Peer, inAppMsgCount int, lastDbId int, wantMore int, password string) ([]InternalUserMessage, error) {
|
|
var messages []InternalUserMessage
|
|
// handle no db yet
|
|
if len(peer.DbIds) == 0 {
|
|
return messages, nil
|
|
}
|
|
fileidx := len(peer.DbIds) - 1
|
|
// initialize count with last db message count
|
|
countStack, err := getMessageCount(peer.DbIds[fileidx])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// while the db message count < what we already have in app, step to next db file
|
|
for inAppMsgCount > countStack {
|
|
fileidx--
|
|
if fileidx < 0 {
|
|
return nil, nil
|
|
}
|
|
newCount, err := getMessageCount(peer.DbIds[fileidx])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
countStack += newCount
|
|
}
|
|
// There fileidx should provide the db that we need (unless wantMore overlaps the next DB)
|
|
db, _ := sql.Open("sqlite3", filepath.Join(GetConfig().StoragePath, GetConfig().GetIdentity().Uuid, peer.DbIds[fileidx]+GetConfig().DbSuffix)) // Open the created SQLite File
|
|
defer db.Close()
|
|
// if it's first app query, it won't hold a lastIndex, so let's start from end
|
|
if lastDbId == 0 {
|
|
lastDbId = math.MaxInt64
|
|
}
|
|
stm, err := db.Prepare("SELECT id, m FROM message WHERE id < ? ORDER BY id DESC LIMIT ?")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer stm.Close()
|
|
rows, err := stm.Query(lastDbId, wantMore)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var ium *InternalUserMessage
|
|
var dbm meowlib.DbMessage
|
|
var id int64
|
|
var m []byte
|
|
err = rows.Scan(&id, &m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = proto.Unmarshal(decdata, &dbm)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ium = DbMessageToInternalUserMessage(id, peer.DbIds[fileidx], &dbm)
|
|
ium.Dbid = id
|
|
ium.Dbfile = peer.DbIds[fileidx]
|
|
|
|
messages = append(messages, *ium)
|
|
}
|
|
// TODO DB overlap
|
|
return messages, nil
|
|
}
|
|
|
|
// Get old messages from a peer
|
|
func GetMessagePreview(peer *Peer, dbFile string, dbId int64, password string) ([]byte, error) {
|
|
|
|
// There fileidx should provide the db that we need (unless wantMore overlaps the next DB)
|
|
db, _ := sql.Open("sqlite3", filepath.Join(GetConfig().StoragePath, GetConfig().GetIdentity().Uuid, dbFile+GetConfig().DbSuffix)) // Open the created SQLite File
|
|
defer db.Close()
|
|
|
|
stm, err := db.Prepare("SELECT id, m FROM message WHERE id=?")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer stm.Close()
|
|
rows, err := stm.Query(dbId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var dbm meowlib.DbMessage
|
|
for rows.Next() {
|
|
|
|
var id int64
|
|
var m []byte
|
|
err = rows.Scan(&id, &m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
decdata, err := meowlib.SymDecrypt(password, m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = proto.Unmarshal(decdata, &dbm)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
}
|
|
return FilePreview(dbm.FilePaths[0], password)
|
|
}
|
|
|
|
func FilePreview(filename string, password string) ([]byte, error) {
|
|
// get the hidden file
|
|
encData, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// decrypt the file
|
|
data, err := meowlib.SymDecrypt(password, encData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
// make an image from the files content (loads the first image, or build a more complex view)
|
|
func InternalUserMessagePreview(msg *InternalUserMessage, password string) ([]byte, error) {
|
|
// get the hidden file name
|
|
if len(msg.FilePaths) == 0 {
|
|
return nil, nil
|
|
}
|
|
return FilePreview(msg.FilePaths[0], password)
|
|
}
|
|
|
|
func getMessageCount(dbid string) (int, error) {
|
|
db, _ := sql.Open("sqlite3", filepath.Join(GetConfig().StoragePath, GetConfig().GetIdentity().Uuid, dbid+GetConfig().DbSuffix)) // Open the created SQLite File
|
|
defer db.Close()
|
|
var count int
|
|
query := "SELECT COUNT(*) FROM message"
|
|
err := db.QueryRow(query).Scan(&count)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return count, nil
|
|
}
|
|
|
|
func createMessageTable(db *sql.DB) error {
|
|
createMessageTableSQL := `CREATE TABLE message (
|
|
"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
|
|
"m" BLOB);` // SQL Statement for Create Table
|
|
statement, err := db.Prepare(createMessageTableSQL) // Prepare SQL Statement
|
|
if err != nil {
|
|
return err
|
|
}
|
|
statement.Exec() // Execute SQL Statements
|
|
return nil
|
|
}
|
|
|
|
func createServerTable(db *sql.DB) error {
|
|
createServerTableSQL := `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)
|
|
)` // SQL Statement for Create Table
|
|
statement, err := db.Prepare(createServerTableSQL) // Prepare SQL Statement
|
|
if err != nil {
|
|
return err
|
|
}
|
|
statement.Exec() // Execute SQL Statements
|
|
return nil
|
|
}
|