forked from cory/tildefriends
311 lines
9.1 KiB
C
311 lines
9.1 KiB
C
#include "ssb.ebt.h"
|
|
|
|
#include "mem.h"
|
|
#include "ssb.db.h"
|
|
#include "ssb.h"
|
|
#include "util.js.h"
|
|
|
|
#include "uv.h"
|
|
|
|
#include <string.h>
|
|
|
|
typedef struct _ebt_entry_t
|
|
{
|
|
char id[k_id_base64_len];
|
|
int64_t out;
|
|
int64_t in;
|
|
bool out_replicate;
|
|
bool out_receive;
|
|
bool in_replicate;
|
|
bool in_receive;
|
|
} ebt_entry_t;
|
|
|
|
typedef struct _tf_ssb_ebt_t
|
|
{
|
|
tf_ssb_connection_t* connection;
|
|
uv_mutex_t mutex;
|
|
|
|
ebt_entry_t* entries;
|
|
int entries_count;
|
|
} tf_ssb_ebt_t;
|
|
|
|
tf_ssb_ebt_t* tf_ssb_ebt_create(tf_ssb_connection_t* connection)
|
|
{
|
|
tf_ssb_ebt_t* ebt = tf_malloc(sizeof(tf_ssb_ebt_t));
|
|
*ebt = (tf_ssb_ebt_t) {
|
|
.connection = connection,
|
|
};
|
|
uv_mutex_init(&ebt->mutex);
|
|
return ebt;
|
|
}
|
|
|
|
void tf_ssb_ebt_destroy(tf_ssb_ebt_t* ebt)
|
|
{
|
|
uv_mutex_destroy(&ebt->mutex);
|
|
tf_free(ebt->entries);
|
|
tf_free(ebt);
|
|
}
|
|
|
|
static int _ebt_entry_compare(const void* a, const void* b)
|
|
{
|
|
const char* id = a;
|
|
const ebt_entry_t* entry = b;
|
|
return strcmp(id, entry->id);
|
|
}
|
|
|
|
static ebt_entry_t* _ebt_get_entry(tf_ssb_ebt_t* ebt, const char* id)
|
|
{
|
|
int index = tf_util_insert_index(id, ebt->entries, ebt->entries_count, sizeof(ebt_entry_t), _ebt_entry_compare);
|
|
if (index < ebt->entries_count && strcmp(id, ebt->entries[index].id) == 0)
|
|
{
|
|
return &ebt->entries[index];
|
|
}
|
|
else
|
|
{
|
|
ebt->entries = tf_resize_vec(ebt->entries, (ebt->entries_count + 1) * sizeof(ebt_entry_t));
|
|
if (index < ebt->entries_count)
|
|
{
|
|
memmove(ebt->entries + index + 1, ebt->entries + index, (ebt->entries_count - index) * sizeof(ebt_entry_t));
|
|
}
|
|
ebt->entries[index] = (ebt_entry_t) {
|
|
.in = -1,
|
|
.out = -1,
|
|
};
|
|
snprintf(ebt->entries[index].id, sizeof(ebt->entries[index].id), "%s", id);
|
|
ebt->entries_count++;
|
|
return &ebt->entries[index];
|
|
}
|
|
}
|
|
|
|
void tf_ssb_ebt_receive_clock(tf_ssb_ebt_t* ebt, JSContext* context, JSValue clock)
|
|
{
|
|
JSPropertyEnum* ptab = NULL;
|
|
uint32_t plen = 0;
|
|
if (JS_GetOwnPropertyNames(context, &ptab, &plen, clock, JS_GPN_STRING_MASK) == 0)
|
|
{
|
|
uv_mutex_lock(&ebt->mutex);
|
|
for (uint32_t i = 0; i < plen; ++i)
|
|
{
|
|
JSValue in_clock = JS_UNDEFINED;
|
|
JSPropertyDescriptor desc = { 0 };
|
|
if (JS_GetOwnProperty(context, &desc, clock, ptab[i].atom) == 1)
|
|
{
|
|
in_clock = desc.value;
|
|
JS_FreeValue(context, desc.setter);
|
|
JS_FreeValue(context, desc.getter);
|
|
}
|
|
if (!JS_IsUndefined(in_clock))
|
|
{
|
|
JSValue key = JS_AtomToString(context, ptab[i].atom);
|
|
const char* author = JS_ToCString(context, key);
|
|
int64_t sequence = -1;
|
|
JS_ToInt64(context, &sequence, in_clock);
|
|
|
|
ebt_entry_t* entry = _ebt_get_entry(ebt, author);
|
|
if (sequence < 0)
|
|
{
|
|
entry->in = -1;
|
|
entry->in_replicate = false;
|
|
entry->in_receive = false;
|
|
}
|
|
else
|
|
{
|
|
entry->in = sequence >> 1;
|
|
entry->in_replicate = true;
|
|
entry->in_receive = (sequence & 1) == 0;
|
|
}
|
|
if (!entry->in_receive)
|
|
{
|
|
tf_ssb_connection_remove_new_message_request(ebt->connection, author);
|
|
}
|
|
JS_FreeCString(context, author);
|
|
JS_FreeValue(context, key);
|
|
}
|
|
JS_FreeValue(context, in_clock);
|
|
}
|
|
uv_mutex_unlock(&ebt->mutex);
|
|
for (uint32_t i = 0; i < plen; ++i)
|
|
{
|
|
JS_FreeAtom(context, ptab[i].atom);
|
|
}
|
|
js_free(context, ptab);
|
|
}
|
|
}
|
|
|
|
typedef struct _ebt_get_clock_t
|
|
{
|
|
tf_ssb_ebt_t* ebt;
|
|
int32_t request_number;
|
|
tf_ssb_ebt_clock_callback_t* callback;
|
|
tf_ssb_ebt_clock_t* clock;
|
|
void* user_data;
|
|
} ebt_get_clock_t;
|
|
|
|
static int _ebt_compare_entry(const void* a, const void* b)
|
|
{
|
|
const char* id = a;
|
|
const tf_ssb_ebt_clock_entry_t* entry = b;
|
|
return strcmp(id, entry->id);
|
|
}
|
|
|
|
static void _ebt_add_to_clock(ebt_get_clock_t* work, const char* id, int64_t value, bool replicate, bool receive)
|
|
{
|
|
int count = work->clock ? work->clock->count : 0;
|
|
ebt_entry_t* entry = _ebt_get_entry(work->ebt, id);
|
|
if ((replicate && !entry->out_replicate) || (receive && !entry->out_receive) || ((replicate || receive || entry->out_replicate || entry->out_receive) && entry->out != value))
|
|
{
|
|
entry->out = value;
|
|
entry->out_replicate = entry->out_replicate || replicate;
|
|
entry->out_receive = entry->out_receive || receive;
|
|
|
|
int index = tf_util_insert_index(id, count ? work->clock->entries : NULL, count, sizeof(tf_ssb_ebt_clock_entry_t), _ebt_compare_entry);
|
|
int64_t out_value = entry->out_replicate ? ((value << 1) | (entry->out_receive ? 0 : 1)) : -1;
|
|
if (index < count && strcmp(id, work->clock->entries[index].id) == 0)
|
|
{
|
|
work->clock->entries[index].value = out_value;
|
|
}
|
|
else
|
|
{
|
|
work->clock = tf_resize_vec(work->clock, sizeof(tf_ssb_ebt_clock_t) + (count + 1) * sizeof(tf_ssb_ebt_clock_entry_t));
|
|
if (index < count)
|
|
{
|
|
memmove(work->clock->entries + index + 1, work->clock->entries + index, (count - index) * sizeof(tf_ssb_ebt_clock_entry_t));
|
|
}
|
|
work->clock->entries[index] = (tf_ssb_ebt_clock_entry_t) { .value = out_value };
|
|
snprintf(work->clock->entries[index].id, sizeof(work->clock->entries[index].id), "%s", id);
|
|
work->clock->count = count + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void _tf_ssb_ebt_get_send_clock_work(tf_ssb_connection_t* connection, void* user_data)
|
|
{
|
|
ebt_get_clock_t* work = user_data;
|
|
tf_ssb_t* ssb = tf_ssb_connection_get_ssb(work->ebt->connection);
|
|
|
|
int64_t depth = 2;
|
|
sqlite3* db = tf_ssb_acquire_db_reader(ssb);
|
|
tf_ssb_db_get_global_setting_int64(db, "replication_hops", &depth);
|
|
tf_ssb_release_db_reader(ssb, db);
|
|
|
|
/* Ask for every identity we know is being followed from local accounts. */
|
|
const char** visible = tf_ssb_db_get_all_visible_identities(ssb, depth);
|
|
if (visible)
|
|
{
|
|
int64_t* sequences = NULL;
|
|
for (int i = 0; visible[i]; i++)
|
|
{
|
|
int64_t sequence = 0;
|
|
tf_ssb_db_get_latest_message_by_author(ssb, visible[i], &sequence, NULL, 0);
|
|
sequences = tf_resize_vec(sequences, (i + 1) * sizeof(int64_t));
|
|
sequences[i] = sequence;
|
|
}
|
|
|
|
uv_mutex_lock(&work->ebt->mutex);
|
|
for (int i = 0; visible[i]; i++)
|
|
{
|
|
_ebt_add_to_clock(work, visible[i], sequences[i], true, true);
|
|
}
|
|
uv_mutex_unlock(&work->ebt->mutex);
|
|
|
|
tf_free(visible);
|
|
tf_free(sequences);
|
|
}
|
|
|
|
/* Ask about the incoming connection, too. */
|
|
char id[k_id_base64_len] = "";
|
|
if (tf_ssb_connection_get_id(connection, id, sizeof(id)))
|
|
{
|
|
int64_t sequence = 0;
|
|
tf_ssb_db_get_latest_message_by_author(ssb, id, &sequence, NULL, 0);
|
|
uv_mutex_lock(&work->ebt->mutex);
|
|
_ebt_add_to_clock(work, id, sequence, true, true);
|
|
uv_mutex_unlock(&work->ebt->mutex);
|
|
}
|
|
|
|
/* Also respond with what we know about all requested identities. */
|
|
tf_ssb_ebt_clock_entry_t* requested = NULL;
|
|
int requested_count = 0;
|
|
uv_mutex_lock(&work->ebt->mutex);
|
|
for (int i = 0; i < work->ebt->entries_count; i++)
|
|
{
|
|
ebt_entry_t* entry = &work->ebt->entries[i];
|
|
if (entry->in_replicate && !entry->out_replicate)
|
|
{
|
|
requested = tf_resize_vec(requested, (requested_count + 1) * sizeof(tf_ssb_ebt_clock_entry_t));
|
|
requested[requested_count] = (tf_ssb_ebt_clock_entry_t) { .value = -1 };
|
|
snprintf(requested[requested_count].id, sizeof(requested[requested_count].id), "%s", entry->id);
|
|
requested_count++;
|
|
}
|
|
}
|
|
uv_mutex_unlock(&work->ebt->mutex);
|
|
|
|
if (requested_count)
|
|
{
|
|
for (int i = 0; i < requested_count; i++)
|
|
{
|
|
tf_ssb_db_get_latest_message_by_author(ssb, requested[i].id, &requested[i].value, NULL, 0);
|
|
}
|
|
|
|
uv_mutex_lock(&work->ebt->mutex);
|
|
for (int i = 0; i < requested_count; i++)
|
|
{
|
|
_ebt_add_to_clock(work, requested[i].id, requested[i].value, requested[i].value >= 0, false);
|
|
}
|
|
uv_mutex_unlock(&work->ebt->mutex);
|
|
tf_free(requested);
|
|
}
|
|
}
|
|
|
|
static void _tf_ssb_ebt_get_send_clock_after_work(tf_ssb_connection_t* connection, int status, void* user_data)
|
|
{
|
|
ebt_get_clock_t* work = user_data;
|
|
work->callback(work->clock, work->request_number, work->user_data);
|
|
tf_free(work->clock);
|
|
tf_free(work);
|
|
}
|
|
|
|
void tf_ssb_ebt_get_send_clock(tf_ssb_ebt_t* ebt, int32_t request_number, tf_ssb_ebt_clock_callback_t* callback, void* user_data)
|
|
{
|
|
ebt_get_clock_t* work = tf_malloc(sizeof(ebt_get_clock_t));
|
|
*work = (ebt_get_clock_t) {
|
|
.ebt = ebt,
|
|
.request_number = request_number,
|
|
.callback = callback,
|
|
.user_data = user_data,
|
|
};
|
|
tf_ssb_connection_run_work(ebt->connection, _tf_ssb_ebt_get_send_clock_work, _tf_ssb_ebt_get_send_clock_after_work, work);
|
|
}
|
|
|
|
tf_ssb_ebt_clock_t* tf_ssb_ebt_get_messages_to_send(tf_ssb_ebt_t* ebt)
|
|
{
|
|
int count = 0;
|
|
tf_ssb_ebt_clock_t* clock = NULL;
|
|
uv_mutex_lock(&ebt->mutex);
|
|
for (int i = 0; i < ebt->entries_count; i++)
|
|
{
|
|
ebt_entry_t* entry = &ebt->entries[i];
|
|
if (entry->in_replicate && entry->in_receive && entry->out > entry->in)
|
|
{
|
|
clock = tf_resize_vec(clock, sizeof(tf_ssb_ebt_clock_t) + (count + 1) * sizeof(tf_ssb_ebt_clock_entry_t));
|
|
clock->entries[count] = (tf_ssb_ebt_clock_entry_t) { .value = entry->in };
|
|
snprintf(clock->entries[count].id, sizeof(clock->entries[count].id), "%s", entry->id);
|
|
clock->count = ++count;
|
|
}
|
|
}
|
|
uv_mutex_unlock(&ebt->mutex);
|
|
return clock;
|
|
}
|
|
|
|
void tf_ssb_ebt_set_messages_sent(tf_ssb_ebt_t* ebt, const char* id, int64_t sequence)
|
|
{
|
|
uv_mutex_lock(&ebt->mutex);
|
|
ebt_entry_t* entry = _ebt_get_entry(ebt, id);
|
|
entry->in = tf_max(entry->in, sequence);
|
|
if (entry->in == entry->out && (tf_ssb_connection_get_flags(ebt->connection) & k_tf_ssb_connect_flag_one_shot) == 0)
|
|
{
|
|
tf_ssb_connection_add_new_message_request(ebt->connection, id, tf_ssb_connection_get_ebt_request_number(ebt->connection), false);
|
|
}
|
|
uv_mutex_unlock(&ebt->mutex);
|
|
}
|