jeka
/
utun2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
910 Commits
15 Branches
2 Tags
165 MiB
 
 
 
 
 
 
Tree: de7841f33a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'de7841f33a'
${ noResults }
utun2/tools/chatgui/db/db_manager.cpp

674 lines
27 KiB
Raw Blame History

#include "db_manager.h"
#include "../src/debug_ui.h"
#include <openssl/sha.h>
#include <openssl/evp.h>
#include <cstring>
#include <QSet>
/* ── helpers ── */
static const char kZero64[64] = {};
QString DbManager::sanitizeTableName(const QString& chId) {
QString s;
s.reserve(chId.size());
for (int i = 0; i < chId.size(); i++) {
QChar c = chId[i];
if (c.isLetterOrNumber() || c == '_') s += c;
else s += '_';
}
return s;
}
QString DbManager::msgTableName(const QString& chId) const {
return QStringLiteral("msg_") + sanitizeTableName(chId);
}
QString DbManager::peersTableName(const QString& chId) const {
return QStringLiteral("peers_") + sanitizeTableName(chId);
}
uint64_t DbManager::computeDatahash(const QByteArray& data) {
uint8_t hash[32];
SHA256((const unsigned char*)data.constData(), data.size(), hash);
uint64_t dh; memcpy(&dh, hash, 8); return dh;
}
QByteArray DbManager::computeChainHash(const QByteArray& prevChain,
qint64 timestamp, uint64_t datahash) {
uint8_t buf[32 + 8 + 8];
memcpy(buf, prevChain.constData(), 32);
memcpy(buf + 32, &timestamp, 8);
memcpy(buf + 40, &datahash, 8);
uint8_t hash[32];
SHA256(buf, 48, hash);
return QByteArray((const char*)hash, 32);
}
QByteArray DbManager::getLastChainHash(const QString& chId) const {
QString tbl = msgTableName(chId);
QByteArray sql = QStringLiteral(
"SELECT chain_hash FROM \"%1\" ORDER BY timestamp, datahash DESC LIMIT 1")
.arg(tbl).toUtf8();
sqlite3_stmt* stmt = prepareOrNull(sql.constData());
if (!stmt) return QByteArray(32, '\0');
QByteArray r = (sqlite3_step(stmt) == SQLITE_ROW) ? colBlob(stmt, 0)
: QByteArray(32, '\0');
sqlite3_finalize(stmt);
return r.size() == 32 ? r : QByteArray(32, '\0');
}
/* ── lifecycle ── */
DbManager::DbManager(const QString& path, QObject* parent)
: QObject(parent)
{
int rc = sqlite3_open(path.toUtf8().constData(), &m_db);
if (rc != SQLITE_OK) {
GUI_ERROR("Cannot open database: %s", sqlite3_errmsg(m_db));
sqlite3_close(m_db); m_db = nullptr; return;
}
sqlite3_exec(m_db, "PRAGMA journal_mode=WAL", nullptr, nullptr, nullptr);
sqlite3_exec(m_db, "PRAGMA foreign_keys=ON", nullptr, nullptr, nullptr);
m_myNodeId = 100;
initTables();
if (getChannels().isEmpty()) seedStubData();
GUI_INFO("Database opened: %s (my_node_id=%llu)", path.toUtf8().constData(),
(unsigned long long)m_myNodeId);
}
DbManager::~DbManager() {
for (auto it = m_cursors.begin(); it != m_cursors.end(); ++it)
sqlite3_finalize(it.value());
m_cursors.clear();
if (m_db) { sqlite3_close(m_db); m_db = nullptr; }
}
sqlite3_stmt* DbManager::prepareOrNull(const char* sql) const {
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
GUI_ERROR("prepare failed: %s — %s", sql, sqlite3_errmsg(m_db));
return nullptr;
}
return stmt;
}
QString DbManager::colText(sqlite3_stmt* stmt, int col) {
return QString::fromUtf8(
reinterpret_cast<const char*>(sqlite3_column_text(stmt, col)));
}
QByteArray DbManager::colBlob(sqlite3_stmt* stmt, int col) {
int len = sqlite3_column_bytes(stmt, col);
if (len <= 0) return {};
return QByteArray(static_cast<const char*>(sqlite3_column_blob(stmt, col)), len);
}
/* ── init ── */
void DbManager::initTables() {
const char* sql =
"CREATE TABLE IF NOT EXISTS local_identity ("
" id INTEGER PRIMARY KEY CHECK (id = 1),"
" node_id INTEGER NOT NULL UNIQUE,"
" name TEXT NOT NULL,"
" x25519_pubkey BLOB NOT NULL,"
" x25519_privkey BLOB,"
" ed25519_pubkey BLOB,"
" created_at INTEGER DEFAULT (unixepoch()),"
" updated_at INTEGER DEFAULT (unixepoch())"
");"
"CREATE TABLE IF NOT EXISTS accounts ("
" node_id INTEGER PRIMARY KEY REFERENCES nodes(node_id),"
" display_name TEXT NOT NULL,"
" avatar_color TEXT DEFAULT '#4A90E2',"
" avatar_letter TEXT NOT NULL,"
" is_contact INTEGER DEFAULT 1,"
" created_at INTEGER DEFAULT (unixepoch())"
");"
"CREATE TABLE IF NOT EXISTS ui_state ("
" key TEXT PRIMARY KEY,"
" value TEXT"
");";
char* err = nullptr;
if (sqlite3_exec(m_db, sql, nullptr, nullptr, &err) != SQLITE_OK) {
GUI_ERROR("initTables: %s", err);
sqlite3_free(err);
} else {
GUI_INFO("Database tables initialized");
}
}
/* ── channels ── */
QList<ChannelRow> DbManager::getChannels() const {
QList<ChannelRow> list;
sqlite3_stmt* stmt = prepareOrNull(
"SELECT channel_id, name, owner_node_id, is_dm,"
" x25519_pubkey, x25519_privkey, ed25519_pubkey, ed25519_privkey, signature,"
" last_read_msg_id, last_pos_msg_id, created_at"
" FROM channels ORDER BY created_at ASC");
if (!stmt) return list;
while (sqlite3_step(stmt) == SQLITE_ROW) {
ChannelRow r;
r.channelId = colText(stmt, 0);
r.name = colText(stmt, 1);
r.ownerNodeId = (quint64)sqlite3_column_int64(stmt, 2);
r.isDm = sqlite3_column_int(stmt, 3) != 0;
r.x25519_pubkey = colBlob(stmt, 4);
r.x25519_privkey = colBlob(stmt, 5);
r.ed25519_pubkey = colBlob(stmt, 6);
r.ed25519_privkey = colBlob(stmt, 7);
r.signature = colBlob(stmt, 8);
r.lastReadMsgId = sqlite3_column_int64(stmt, 9);
r.lastPosMsgId = sqlite3_column_int64(stmt, 10);
r.createdAt = sqlite3_column_int64(stmt, 11);
list.append(r);
}
sqlite3_finalize(stmt);
return list;
}
bool DbManager::createChannel(const QString& chId, const QString& name,
quint64 ownerNodeId,
const QByteArray& x25519pub, const QByteArray& x25519priv,
const QByteArray& ed25519pub, const QByteArray& ed25519priv) {
GUI_INFO("createChannel (msg table only): chId='%s' name='%s'", chId.toUtf8().constData(), name.toUtf8().constData());
(void)ownerNodeId; (void)x25519pub; (void)x25519priv; (void)ed25519pub; (void)ed25519priv;
QString msgt = msgTableName(chId);
QString csql = QStringLiteral(
"CREATE TABLE IF NOT EXISTS \"%1\" ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" node_id INTEGER NOT NULL,"
" content_type TEXT NOT NULL,"
" data BLOB NOT NULL,"
" timestamp INTEGER NOT NULL,"
" datahash INTEGER NOT NULL,"
" chain_hash BLOB NOT NULL,"
" signature BLOB,"
" is_outgoing INTEGER DEFAULT 0,"
" is_read INTEGER DEFAULT 0,"
" sync_flags INTEGER DEFAULT 0,"
" UNIQUE(timestamp, datahash))").arg(msgt);
sqlite3_exec(m_db, csql.toUtf8().constData(), nullptr, nullptr, nullptr);
csql = QStringLiteral("CREATE INDEX IF NOT EXISTS idx_%1_ts ON \"%1\"(timestamp, datahash)").arg(msgt);
sqlite3_exec(m_db, csql.toUtf8().constData(), nullptr, nullptr, nullptr);
GUI_INFO("Message table ensured: %s", msgt.toUtf8().constData());
return true;
}
bool DbManager::deleteChannel(const QString& chId) {
QString msgt = msgTableName(chId), pt = peersTableName(chId);
sqlite3_exec(m_db, QStringLiteral("DROP TABLE IF EXISTS \"%1\"").arg(msgt).toUtf8().constData(), nullptr, nullptr, nullptr);
sqlite3_exec(m_db, QStringLiteral("DROP TABLE IF EXISTS \"%1\"").arg(pt).toUtf8().constData(), nullptr, nullptr, nullptr);
sqlite3_stmt* stmt = prepareOrNull("DELETE FROM channels WHERE channel_id=?");
if (!stmt) return false;
sqlite3_bind_text(stmt, 1, chId.toUtf8().constData(), -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
GUI_INFO("Channel deleted: %s", chId.toUtf8().constData());
return true;
}
/* ── messages (UI) ── */
QList<MessageRow> DbManager::getMessages(const QString& chId, int limit) const {
QList<MessageRow> list;
QString sql = QStringLiteral(
"SELECT id, node_id, content_type, data, timestamp, datahash, chain_hash,"
" signature, is_outgoing, is_read"
" FROM \"%1\" ORDER BY timestamp, datahash ASC LIMIT ?").arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return list;
sqlite3_bind_int(stmt, 1, limit);
while (sqlite3_step(stmt) == SQLITE_ROW) {
MessageRow m;
m.id = sqlite3_column_int64(stmt, 0);
m.authorNodeId = (quint64)sqlite3_column_int64(stmt, 1);
m.contentType = colText(stmt, 2);
m.data = colBlob(stmt, 3);
m.timestamp = sqlite3_column_int64(stmt, 4);
m.datahash = (uint64_t)sqlite3_column_int64(stmt, 5);
m.chainHash = colBlob(stmt, 6);
m.signature = colBlob(stmt, 7);
m.isOutgoing = sqlite3_column_int(stmt, 8) != 0;
m.isRead = sqlite3_column_int(stmt, 9) != 0;
list.append(m);
}
sqlite3_finalize(stmt);
return list;
}
bool DbManager::insertMessage(const QString& chId, quint64 nodeId,
const QString& contentType, const QByteArray& data,
qint64 timestamp, bool isOutgoing,
uint64_t* outDatahash, QByteArray* outChainHash) {
uint64_t dh = computeDatahash(data);
QByteArray prevCh = getLastChainHash(chId);
QByteArray ch = computeChainHash(prevCh, timestamp, dh);
QString sql = QStringLiteral(
"INSERT OR IGNORE INTO \"%1\""
" (node_id, content_type, data, timestamp, datahash, chain_hash,"
" signature, is_outgoing, is_read)"
" VALUES(?,?,?,?,?,?,?,?,1)").arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return false;
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)nodeId);
sqlite3_bind_text(stmt, 2, contentType.toUtf8().constData(), -1, SQLITE_TRANSIENT);
sqlite3_bind_blob(stmt, 3, data.constData(), data.size(), SQLITE_TRANSIENT);
sqlite3_bind_int64(stmt, 4, timestamp);
sqlite3_bind_int64(stmt, 5, (sqlite3_int64)dh);
sqlite3_bind_blob(stmt, 6, ch.constData(), 32, SQLITE_TRANSIENT);
sqlite3_bind_blob(stmt, 7, kZero64, 64, SQLITE_TRANSIENT);
sqlite3_bind_int(stmt, 8, isOutgoing ? 1 : 0);
bool ok = sqlite3_step(stmt) == SQLITE_DONE;
sqlite3_finalize(stmt);
if (ok) {
if (outDatahash) *outDatahash = dh;
if (outChainHash) *outChainHash = ch;
}
return ok;
}
/* ── peers (запись теперь через topo_node_sqlite) ── */
bool DbManager::addPeer(const QString& chId, quint64 nodeId,
const QByteArray& joinSig, const QByteArray& creatorSig,
const QString& comment) {
(void)chId; (void)nodeId; (void)joinSig; (void)creatorSig; (void)comment;
return true;
}
bool DbManager::removePeer(const QString& chId, quint64 nodeId) {
(void)chId; (void)nodeId;
return true;
}
/* ── nodes (запись теперь через topo_node_sqlite) ── */
bool DbManager::upsertNode(quint64 nodeId, const QString& name,
const QByteArray& x25519pub, const QByteArray& ed25519pub) {
(void)nodeId; (void)name; (void)x25519pub; (void)ed25519pub;
return true;
}
bool DbManager::addNodeAddress(quint64 nodeId, int family, int protocol,
const QByteArray& addr, quint16 port, bool isNat) {
(void)nodeId; (void)family; (void)protocol; (void)addr; (void)port; (void)isNat;
return true;
}
QByteArray DbManager::loadNodeInfo(quint64 nodeId) const {
/* binary format: [x25519:32][ed25519:32][addr_count:1]([family:1][proto:1][addr_len:1][addr:4|16][port:2][rtt:2])... */
sqlite3_stmt* stmt = prepareOrNull(
"SELECT x25519_pubkey, ed25519_pubkey FROM nodes WHERE node_id=?");
if (!stmt) return {};
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)nodeId);
if (sqlite3_step(stmt) != SQLITE_ROW) { sqlite3_finalize(stmt); return {}; }
QByteArray x25519 = colBlob(stmt, 0);
QByteArray ed25519 = colBlob(stmt, 1);
sqlite3_finalize(stmt);
QByteArray result;
result.append(x25519.isEmpty() ? QByteArray(32, '\0') : x25519);
result.append(ed25519.isEmpty() ? QByteArray(32, '\0') : ed25519);
/* запросить адреса */
stmt = prepareOrNull(
"SELECT family, protocol, address, port, rtt FROM node_addresses WHERE node_id=?");
if (!stmt) { result.append('\0'); return result; }
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)nodeId);
QByteArray addrsPart;
uint8_t cnt = 0;
while (sqlite3_step(stmt) == SQLITE_ROW && cnt < 255) {
int family = sqlite3_column_int(stmt, 0);
int proto = sqlite3_column_int(stmt, 1);
QByteArray addr = colBlob(stmt, 2);
uint16_t port = (uint16_t)sqlite3_column_int(stmt, 3);
int16_t rtt = (int16_t)(sqlite3_column_int(stmt, 4));
addrsPart.append((char)family);
addrsPart.append((char)proto);
addrsPart.append((char)addr.size());
addrsPart.append(addr);
addrsPart.append((const char*)&port, 2);
addrsPart.append((const char*)&rtt, 2);
cnt++;
}
sqlite3_finalize(stmt);
result.append((char)cnt);
result.append(addrsPart);
return result;
}
QList<quint64> DbManager::getOnlinePeers() const {
QList<quint64> peers;
/* без is_online: получаем всех кроме себя */
sqlite3_stmt* stmt = prepareOrNull("SELECT node_id FROM nodes WHERE node_id != ?");
if (!stmt) return peers;
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)m_myNodeId);
while (sqlite3_step(stmt) == SQLITE_ROW)
peers.append((quint64)sqlite3_column_int64(stmt, 0));
sqlite3_finalize(stmt);
return peers;
}
QByteArray DbManager::getNodeEdPub(quint64 nodeId) const {
sqlite3_stmt* stmt = prepareOrNull("SELECT ed25519_pubkey FROM nodes WHERE node_id=?");
if (!stmt) return {};
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)nodeId);
QByteArray r;
if (sqlite3_step(stmt) == SQLITE_ROW) r = colBlob(stmt, 0);
sqlite3_finalize(stmt);
return r;
}
QList<NodeAddr> DbManager::getOnlinePeerAddresses(quint64 excludeNodeId) const {
QList<NodeAddr> list;
sqlite3_stmt* stmt = prepareOrNull(
"SELECT na.node_id, na.family, na.protocol, na.address, na.port, na.rtt, na.is_nat"
" FROM node_addresses na JOIN nodes n ON na.node_id = n.node_id"
" WHERE na.is_nat=0 AND na.node_id != ?"
" ORDER BY RANDOM()");
if (!stmt) return list;
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)excludeNodeId);
while (sqlite3_step(stmt) == SQLITE_ROW) {
NodeAddr a;
a.nodeId = (quint64)sqlite3_column_int64(stmt, 0);
a.family = sqlite3_column_int(stmt, 1);
a.protocol = sqlite3_column_int(stmt, 2);
a.address = colBlob(stmt, 3);
a.port = (quint16)sqlite3_column_int(stmt, 4);
a.rtt = sqlite3_column_int(stmt, 5);
a.isNat = sqlite3_column_int(stmt, 6) != 0;
list.append(a);
}
sqlite3_finalize(stmt);
return list;
}
/* ── accounts ── */
QList<AccountRow> DbManager::getAccounts(bool contactsOnly) const {
QList<AccountRow> list;
const char* sql = contactsOnly
? "SELECT node_id, display_name, avatar_color, avatar_letter, is_contact"
" FROM accounts WHERE is_contact=1 ORDER BY display_name"
: "SELECT node_id, display_name, avatar_color, avatar_letter, is_contact"
" FROM accounts ORDER BY display_name";
sqlite3_stmt* stmt = prepareOrNull(sql);
if (!stmt) return list;
while (sqlite3_step(stmt) == SQLITE_ROW) {
AccountRow a;
a.nodeId = (quint64)sqlite3_column_int64(stmt, 0);
a.displayName = colText(stmt, 1);
a.avatarColor = colText(stmt, 2);
a.avatarLetter = colText(stmt, 3);
a.isContact = sqlite3_column_int(stmt, 4) != 0;
list.append(a);
}
sqlite3_finalize(stmt);
return list;
}
AccountRow DbManager::getAccount(quint64 nodeId) const {
AccountRow a;
sqlite3_stmt* stmt = prepareOrNull(
"SELECT node_id, display_name, avatar_color, avatar_letter, is_contact"
" FROM accounts WHERE node_id=?");
if (!stmt) return a;
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)nodeId);
if (sqlite3_step(stmt) == SQLITE_ROW) {
a.nodeId = (quint64)sqlite3_column_int64(stmt, 0);
a.displayName = colText(stmt, 1);
a.avatarColor = colText(stmt, 2);
a.avatarLetter = colText(stmt, 3);
a.isContact = sqlite3_column_int(stmt, 4) != 0;
}
sqlite3_finalize(stmt);
return a;
}
/* ── ui_state ── */
QString DbManager::getUiState(const QString& key) const {
sqlite3_stmt* stmt = prepareOrNull("SELECT value FROM ui_state WHERE key=?");
if (!stmt) return {};
sqlite3_bind_text(stmt, 1, key.toUtf8().constData(), -1, SQLITE_TRANSIENT);
QString val;
if (sqlite3_step(stmt) == SQLITE_ROW) val = colText(stmt, 0);
sqlite3_finalize(stmt);
return val;
}
void DbManager::setUiState(const QString& key, const QString& value) {
sqlite3_stmt* stmt = prepareOrNull(
"INSERT OR REPLACE INTO ui_state(key,value) VALUES(?,?)");
if (!stmt) return;
sqlite3_bind_text(stmt, 1, key.toUtf8().constData(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, value.toUtf8().constData(), -1, SQLITE_TRANSIENT);
sqlite3_step(stmt); sqlite3_finalize(stmt);
}
/* ── sync operations (called from gui_bridge, in GUI thread) ── */
QByteArray DbManager::syncListChannels() const {
/* binary: [count:2]([chId_len:1][chId:var])... */
QList<ChannelRow> chs = getChannels();
QByteArray out;
uint16_t cnt = (uint16_t)chs.size();
out.append((const char*)&cnt, 2);
for (auto& ch : chs) {
QByteArray id = ch.channelId.toUtf8();
out.append((char)(uint8_t)id.size());
out.append(id);
}
return out;
}
QByteArray DbManager::syncCount(const QString& chId) const {
QString sql = QStringLiteral("SELECT COUNT(*) FROM \"%1\"").arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return {};
uint32_t cnt = 0;
if (sqlite3_step(stmt) == SQLITE_ROW) cnt = (uint32_t)sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
QByteArray out; out.append((const char*)&cnt, 4); return out;
}
QByteArray DbManager::syncChainHashAt(const QString& chId, uint32_t pos) const {
QString sql = QStringLiteral(
"SELECT chain_hash FROM \"%1\" ORDER BY timestamp, datahash ASC LIMIT 1 OFFSET ?")
.arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return QByteArray(32, '\0');
sqlite3_bind_int64(stmt, 1, pos);
QByteArray r;
if (sqlite3_step(stmt) == SQLITE_ROW) r = colBlob(stmt, 0);
sqlite3_finalize(stmt);
return r.size() == 32 ? r : QByteArray(32, '\0');
}
QByteArray DbManager::syncInsert(const QString& chId, const QByteArray& recData) {
/* recData: [timestamp:8][datahash:8][node_id:8][ct_len:1][ct:var][data_len:4][data:var][chain_hash:32] */
if (recData.size() < 29) return QByteArray(1, (char)-1);
const uint8_t* p = (const uint8_t*)recData.constData();
int rem = recData.size();
qint64 ts; uint64_t dh, nid;
memcpy(&ts, p, 8); p += 8; rem -= 8;
memcpy(&dh, p, 8); p += 8; rem -= 8;
memcpy(&nid, p, 8); p += 8; rem -= 8;
if (rem < 1) return QByteArray(1, (char)-1);
uint8_t ctLen = *p; p++; rem--;
if (rem < ctLen) return QByteArray(1, (char)-1);
QString ct = QString::fromUtf8((const char*)p, ctLen); p += ctLen; rem -= ctLen;
if (rem < 4) return QByteArray(1, (char)-1);
uint32_t dLen; memcpy(&dLen, p, 4); p += 4; rem -= 4;
if (rem < (int)dLen) return QByteArray(1, (char)-1);
QByteArray data((const char*)p, dLen); p += dLen; rem -= dLen;
if (rem < 32) return QByteArray(1, (char)-1);
QByteArray peerCH((const char*)p, 32);
/* verify chain_hash */
QByteArray prev = getLastChainHash(chId);
QByteArray expected = computeChainHash(prev, ts, dh);
if (expected != peerCH) {
GUI_ERROR("syncInsert: chain_hash mismatch for %s ts=%lld dh=%llx", chId.toUtf8().constData(), (long long)ts, (unsigned long long)dh);
return QByteArray(1, (char)-1);
}
QString sql = QStringLiteral(
"INSERT OR IGNORE INTO \"%1\""
" (node_id, content_type, data, timestamp, datahash, chain_hash, signature, is_outgoing, is_read)"
" VALUES(?,?,?,?,?,?,?,0,1)").arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return QByteArray(1, (char)-1);
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)nid);
sqlite3_bind_text(stmt, 2, ct.toUtf8().constData(), -1, SQLITE_TRANSIENT);
sqlite3_bind_blob(stmt, 3, data.constData(), data.size(), SQLITE_TRANSIENT);
sqlite3_bind_int64(stmt, 4, ts);
sqlite3_bind_int64(stmt, 5, (sqlite3_int64)dh);
sqlite3_bind_blob(stmt, 6, peerCH.constData(), 32, SQLITE_TRANSIENT);
sqlite3_bind_blob(stmt, 7, kZero64, 64, SQLITE_TRANSIENT);
int rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
if (rc == SQLITE_DONE) return QByteArray(1, '\0');
if (rc == SQLITE_CONSTRAINT) return QByteArray(1, (char)1); /* duplicate */
return QByteArray(1, (char)-1);
}
QByteArray DbManager::syncCursorOpen(const QString& chId) {
QString sql = QStringLiteral(
"SELECT timestamp, datahash, node_id, content_type, data"
" FROM \"%1\" ORDER BY timestamp, datahash ASC").arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) { QByteArray r(4, '\0'); return r; }
uint32_t id = m_nextCursorId++;
m_cursors[id] = stmt;
QByteArray r; r.append((const char*)&id, 4); return r;
}
QByteArray DbManager::syncCursorNext(uint32_t cursorId) {
auto it = m_cursors.find(cursorId);
if (it == m_cursors.end()) return {};
if (sqlite3_step(it.value()) != SQLITE_ROW) return {};
/* return: [ts:8][dh:8][nid:8][ct_len:1][ct:var][data_len:4][data:var] */
qint64 ts = sqlite3_column_int64(it.value(), 0);
uint64_t dh = (uint64_t)sqlite3_column_int64(it.value(), 1);
uint64_t nid = (uint64_t)sqlite3_column_int64(it.value(), 2);
QString ct = colText(it.value(), 3);
QByteArray data = colBlob(it.value(), 4);
QByteArray out;
out.append((const char*)&ts, 8);
out.append((const char*)&dh, 8);
out.append((const char*)&nid, 8);
QByteArray ctb = ct.toUtf8();
out.append((char)(uint8_t)ctb.size());
out.append(ctb);
uint32_t dLen = (uint32_t)data.size();
out.append((const char*)&dLen, 4);
out.append(data);
return out;
}
void DbManager::syncCursorClose(uint32_t cursorId) {
auto it = m_cursors.find(cursorId);
if (it != m_cursors.end()) { sqlite3_finalize(it.value()); m_cursors.erase(it); }
}
QByteArray DbManager::syncMarkSent(const QString& chId, quint64 ts, quint64 dh, quint64 myNodeId) {
QString sql = QStringLiteral(
"UPDATE \"%1\" SET sync_flags=sync_flags|1"
" WHERE timestamp=? AND datahash=? AND node_id=? AND is_outgoing=1")
.arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return {};
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)ts);
sqlite3_bind_int64(stmt, 2, (sqlite3_int64)dh);
sqlite3_bind_int64(stmt, 3, (sqlite3_int64)myNodeId);
sqlite3_step(stmt); sqlite3_finalize(stmt);
return {};
}
QByteArray DbManager::syncTtlDelete(const QString& chId, quint64 myNodeId, quint64 cutoffUs) {
QString sql = QStringLiteral(
"DELETE FROM \"%1\" WHERE node_id=? AND is_outgoing=1 AND (sync_flags&1)=0 AND timestamp<?")
.arg(msgTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) return {};
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)myNodeId);
sqlite3_bind_int64(stmt, 2, (sqlite3_int64)cutoffUs);
sqlite3_step(stmt); sqlite3_finalize(stmt);
return {};
}
QByteArray DbManager::syncListPeers(const QString& chId) const {
/* binary: [count:2]([node_id:8])... */
QString sql = QStringLiteral("SELECT node_id FROM \"%1\"").arg(peersTableName(chId));
sqlite3_stmt* stmt = prepareOrNull(sql.toUtf8().constData());
if (!stmt) { QByteArray r(2, '\0'); return r; }
QList<uint64_t> ids;
while (sqlite3_step(stmt) == SQLITE_ROW)
ids.append((uint64_t)sqlite3_column_int64(stmt, 0));
sqlite3_finalize(stmt);
QByteArray out;
uint16_t cnt = (uint16_t)ids.size();
out.append((const char*)&cnt, 2);
for (auto id : ids) out.append((const char*)&id, 8);
return out;
}
/* ── gui notifications ── */
void DbManager::onSyncMessageReceived(const QString& chId) {
Q_UNUSED(chId)
/* Обновление last_message в channels не нужно (убран). Вызывается emitter'ом из gui_bridge_impl */
}
void DbManager::setNodeOnline(quint64 nodeId, bool online) {
Q_UNUSED(nodeId); Q_UNUSED(online)
/* is_online убран из nodes. Обновление статуса через conn_mgr — позже */
}
/* ── seed stub data ── */
void DbManager::seedStubData() {
GUI_INFO("Seeding stub data (accounts only)...");
sqlite3_exec(m_db, "BEGIN", nullptr, nullptr, nullptr);
unsigned char pub_dummy[32] = {};
sqlite3_stmt* ins = prepareOrNull(
"INSERT OR IGNORE INTO local_identity(id,node_id,name,x25519_pubkey,ed25519_pubkey)"
" VALUES(1,?,'MyDevice',?,?)");
sqlite3_bind_int64(ins, 1, m_myNodeId);
sqlite3_bind_blob(ins, 2, pub_dummy, 32, SQLITE_TRANSIENT);
sqlite3_bind_blob(ins, 3, pub_dummy, 32, SQLITE_TRANSIENT);
sqlite3_step(ins); sqlite3_finalize(ins);
struct { quint64 id; const char* name; const char* letter; const char* color; } accs[] = {
{1, "Alice", "A", "#4A90E2"}, {2, "Bob", "B", "#7ED321"},
{3, "Carol", "C", "#F5A623"}, {4, "Dave", "D", "#9013FE"},
{5, "Eve", "E", "#00B894"},
};
for (auto& a : accs) {
ins = prepareOrNull("INSERT OR IGNORE INTO accounts(node_id,display_name,avatar_color,avatar_letter)"
" VALUES(?,?,?,?)");
sqlite3_bind_int64(ins, 1, (sqlite3_int64)a.id);
sqlite3_bind_text(ins, 2, a.name, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(ins, 3, a.color, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(ins, 4, a.letter, -1, SQLITE_TRANSIENT);
sqlite3_step(ins); sqlite3_finalize(ins);
}
sqlite3_exec(m_db, "COMMIT", nullptr, nullptr, nullptr);
GUI_INFO("Seed data inserted (5 accounts)");
}