interfect/tildefriends
1
0
Fork 0
forked from cory/tildefriends
Code Pull Requests Activity

Use a custom allocator for everything.

Browse Source 
git-svn-id: https://www.unprompted.com/svn/projects/tildefriends/trunk@3892 ed5197a5-7fde-0310-b194-c3ffbd925b24
This commit is contained in:
Cory McWilliams
2022-06-04 17:04:51 +00:00
parent cf61e68713
commit 9c90b2bc1d
24 changed files with 404 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
src/ssb.c
View File

@ -1,14 +1,12 @@
#include "ssb.h"
#include "mem.h"
#include "ssb.connections.h"
#include "ssb.db.h"
#include "trace.h"
#include <assert.h>
#include <malloc.h>
#include <base64c.h>
//#include <openssl/evp.h>
//#include <openssl/rand.h>
#include <quickjs.h>
#include <sodium/crypto_auth.h>
#include <sodium/crypto_box.h>
@ -264,7 +262,7 @@ static void _tf_ssb_connection_on_tcp_alloc(uv_handle_t* handle, size_t suggeste
{
tf_ssb_connection_t* connection = handle->data;
size_t malloc_size = sizeof(connection->recv_buffer) - connection->recv_size;
buf->base = malloc_size ? malloc(malloc_size) : NULL;
buf->base = malloc_size ? tf_malloc(malloc_size) : NULL;
buf->len = malloc_size;
}
@ -275,19 +273,19 @@ static void _tf_ssb_connection_on_write(uv_write_t* req, int status)
tf_ssb_connection_t* connection = req->data;
_tf_ssb_connection_close(connection, "write failed asynchronously");
}
free(req);
tf_free(req);
}
static void _tf_ssb_write(tf_ssb_connection_t* connection, void* data, size_t size)
{
uv_write_t* write = malloc(sizeof(uv_write_t) + size);
uv_write_t* write = tf_malloc(sizeof(uv_write_t) + size);
*write = (uv_write_t) { .data = connection };
memcpy(write + 1, data, size);
int result = uv_write(write, (uv_stream_t*)&connection->tcp, &(uv_buf_t) { .base = (char*)(write + 1), .len = size }, 1, _tf_ssb_connection_on_write);
if (result)
{
_tf_ssb_connection_close(connection, "write failed");
free(write);
tf_free(write);
}
}
@ -372,7 +370,7 @@ static void _tf_ssb_nonce_inc(uint8_t* nonce)
static void _tf_ssb_connection_box_stream_send(tf_ssb_connection_t* connection, const uint8_t* message, size_t size)
{
uint8_t* message_enc = malloc(size + 34);
uint8_t* message_enc = tf_malloc(size + 34);
uint8_t nonce1[crypto_secretbox_NONCEBYTES];
memcpy(nonce1, connection->send_nonce, sizeof(nonce1));
@ -384,7 +382,7 @@ static void _tf_ssb_connection_box_stream_send(tf_ssb_connection_t* connection,
if (crypto_secretbox_easy(message_enc + 34 - 16, message, size, nonce2, connection->c_to_s_box_key) != 0)
{
_tf_ssb_connection_close(connection, "unable to secretbox message");
free(message_enc);
tf_free(message_enc);
return;
}
@ -394,12 +392,12 @@ static void _tf_ssb_connection_box_stream_send(tf_ssb_connection_t* connection,
if (crypto_secretbox_easy(message_enc, header, sizeof(header), nonce1, connection->c_to_s_box_key) != 0)
{
_tf_ssb_connection_close(connection, "unable to secretbox header");
free(message_enc);
tf_free(message_enc);
return;
}
_tf_ssb_write(connection, message_enc, size + 34);
free(message_enc);
tf_free(message_enc);
}
static bool _tf_ssb_connection_get_request_callback(tf_ssb_connection_t* connection, int32_t request_number, tf_ssb_rpc_callback_t** out_callback, void** out_user_data)
@ -431,7 +429,7 @@ void tf_ssb_connection_add_request(tf_ssb_connection_t* connection, int32_t requ
/* TODO: This leaks the callback. */
return;
}
tf_ssb_request_t* request = malloc(sizeof(tf_ssb_request_t));
tf_ssb_request_t* request = tf_malloc(sizeof(tf_ssb_request_t));
*request = (tf_ssb_request_t)
{
.next = connection->requests,
@ -454,7 +452,7 @@ static void _tf_ssb_connection_remove_request(tf_ssb_connection_t* connection, i
JS_FreeValue(tf_ssb_connection_get_context(connection), JS_MKPTR(JS_TAG_OBJECT, found->user_data));
}
*it = found->next;
free(found);
tf_free(found);
break;
}
}
@ -470,7 +468,7 @@ void tf_ssb_connection_rpc_send(tf_ssb_connection_t* connection, uint8_t flags,
{
tf_ssb_connection_add_request(connection, request_number, callback, user_data);
}
uint8_t* combined = malloc(9 + size);
uint8_t* combined = tf_malloc(9 + size);
*combined = flags;
uint32_t u32size = htonl((uint32_t)size);
memcpy(combined + 1, &u32size, sizeof(u32size));
@ -478,7 +476,7 @@ void tf_ssb_connection_rpc_send(tf_ssb_connection_t* connection, uint8_t flags,
memcpy(combined + 1 + sizeof(uint32_t), &rn, sizeof(rn));
memcpy(combined + 1 + 2 * sizeof(uint32_t), message, size);
_tf_ssb_connection_box_stream_send(connection, combined, 1 + 2 * sizeof(uint32_t) + size);
free(combined);
tf_free(combined);
printf("RPC SEND flags=%x RN=%d: %.*s\n", flags, request_number, (int)size, message);
connection->ssb->rpc_out++;
}
@ -543,7 +541,7 @@ void tf_ssb_calculate_message_id(JSContext* context, JSValue message, char* out_
size_t len = 0;
const char* messagestr = JS_ToCStringLen(context, &len, idval);
char* latin1 = strdup(messagestr);
char* latin1 = tf_strdup(messagestr);
uint8_t* write_pos = (uint8_t*)latin1;
const uint8_t* p = (const uint8_t*)messagestr;
while (p && *p)
@ -573,7 +571,7 @@ void tf_ssb_calculate_message_id(JSContext* context, JSValue message, char* out_
snprintf(out_id, out_id_size, "%%%s.sha256", id_base64);
free(latin1);
tf_free(latin1);
JS_FreeCString(context, messagestr);
JS_FreeValue(context, idval);
}
@ -1372,7 +1370,7 @@ void _tf_ssb_connection_destroy(tf_ssb_connection_t* connection, const char* rea
!connection->tcp.data &&
!connection->connect.data)
{
free(connection);
tf_free(connection);
}
}
@ -1394,7 +1392,7 @@ static void _tf_ssb_connection_on_tcp_recv(uv_stream_t* stream, ssize_t nread, c
if (connection->recv_size + nread > sizeof(connection->recv_buffer))
{
_tf_ssb_connection_close(connection, "recv buffer overflow");
free(buf->base);
tf_free(buf->base);
return;
}
memcpy(connection->recv_buffer + connection->recv_size, buf->base, nread);
@ -1474,7 +1472,7 @@ static void _tf_ssb_connection_on_tcp_recv(uv_stream_t* stream, ssize_t nread, c
{
_tf_ssb_connection_close(connection, "read zero");
}
free(buf->base);
tf_free(buf->base);
}
static void _tf_ssb_connection_client_send_hello(uv_stream_t* stream)
@ -1539,7 +1537,7 @@ static bool _tf_ssb_load_keys(tf_ssb_t* ssb)
bool result = false;
char* json = NULL;
size_t path_size = strlen(home) + strlen(ssb->secrets_path) + 1;
char* path = malloc(path_size);
char* path = tf_malloc(path_size);
snprintf(path, path_size, "%s%s", home, ssb->secrets_path);
FILE* file = fopen(path, "rb");
@ -1562,7 +1560,7 @@ static bool _tf_ssb_load_keys(tf_ssb_t* ssb)
goto failed;
}
json = malloc(len + 1);
json = tf_malloc(len + 1);
if (fread(json, 1, len, file) != (size_t)len)
{
printf("Failed to read %s: %s\n.", path, strerror(errno));
@ -1599,7 +1597,7 @@ static bool _tf_ssb_load_keys(tf_ssb_t* ssb)
failed:
if (json)
{
free(json);
tf_free(json);
}
if (file)
{
@ -1607,7 +1605,7 @@ failed:
}
if (path)
{
free(path);
tf_free(path);
}
return result;
}
@ -1634,7 +1632,7 @@ static bool _tf_ssb_save_keys(tf_ssb_t* ssb)
}
size_t path_size = strlen(home) + strlen(ssb->secrets_path) + 1;
char* path = malloc(path_size);
char* path = tf_malloc(path_size);
snprintf(path, path_size, "%s%s", home, ssb->secrets_path);
JSContext* context = ssb->context;
@ -1659,7 +1657,7 @@ static bool _tf_ssb_save_keys(tf_ssb_t* ssb)
JS_FreeValue(context, jsonval);
JS_FreeValue(context, root);
free(path);
tf_free(path);
return result;
}
@ -1716,7 +1714,7 @@ void tf_ssb_get_stats(tf_ssb_t* ssb, tf_ssb_stats_t* out_stats)
tf_ssb_t* tf_ssb_create(uv_loop_t* loop, JSContext* context, sqlite3* db, const char* secrets_path)
{
tf_ssb_t* ssb = malloc(sizeof(tf_ssb_t));
tf_ssb_t* ssb = tf_malloc(sizeof(tf_ssb_t));
memset(ssb, 0, sizeof(*ssb));
ssb->secrets_path = secrets_path ? secrets_path : k_secrets_path;
if (context)
@ -1886,7 +1884,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb)
node->cleanup(ssb, node->user_data);
node->cleanup = NULL;
}
free(node);
tf_free(node);
}
while (ssb->connections_changed)
{
@ -1897,7 +1895,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb)
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
while (ssb->message_added)
{
@ -1908,7 +1906,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb)
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
while (ssb->blob_want_added)
{
@ -1919,7 +1917,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb)
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
while (ssb->broadcasts_changed)
{
@ -1930,7 +1928,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb)
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
if (ssb->own_context)
{
@ -1946,9 +1944,9 @@ void tf_ssb_destroy(tf_ssb_t* ssb)
tf_ssb_broadcast_t* broadcast = ssb->broadcasts;
ssb->broadcasts = broadcast->next;
ssb->broadcasts_count--;
free(broadcast);
tf_free(broadcast);
}
free(ssb);
tf_free(ssb);
}
void tf_ssb_run(tf_ssb_t* ssb)
@ -2034,7 +2032,7 @@ tf_ssb_connection_t* tf_ssb_connection_create(tf_ssb_t* ssb, const char* host, c
}
JSContext* context = ssb->context;
tf_ssb_connection_t* connection = malloc(sizeof(tf_ssb_connection_t));
tf_ssb_connection_t* connection = tf_malloc(sizeof(tf_ssb_connection_t));
memset(connection, 0, sizeof(*connection));
connection->ssb = ssb;
connection->tcp.data = connection;
@ -2097,13 +2095,13 @@ static void _tf_on_connect_getaddrinfo(uv_getaddrinfo_t* addrinfo, int result, s
{
printf("getaddrinfo => %s\n", uv_strerror(result));
}
free(connect);
tf_free(connect);
uv_freeaddrinfo(info);
}
void tf_ssb_connect(tf_ssb_t* ssb, const char* host, int port, const uint8_t* key)
{
connect_t* connect = malloc(sizeof(connect_t));
connect_t* connect = tf_malloc(sizeof(connect_t));
*connect = (connect_t)
{
.ssb = ssb,
@ -2116,7 +2114,7 @@ void tf_ssb_connect(tf_ssb_t* ssb, const char* host, int port, const uint8_t* ke
if (r < 0)
{
printf("uv_getaddrinfo: %s\n", uv_strerror(r));
free(connect);
tf_free(connect);
}
}
@ -2129,7 +2127,7 @@ static void _tf_ssb_on_connection(uv_stream_t* stream, int status)
return;
}
tf_ssb_connection_t* connection = malloc(sizeof(tf_ssb_connection_t));
tf_ssb_connection_t* connection = tf_malloc(sizeof(tf_ssb_connection_t));
memset(connection, 0, sizeof(*connection));
connection->ssb = ssb;
connection->tcp.data = connection;
@ -2310,7 +2308,7 @@ void tf_ssb_connect_str(tf_ssb_t* ssb, const char* address)
static void _tf_ssb_on_broadcast_listener_alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
{
buf->base = malloc(suggested_size);
buf->base = tf_malloc(suggested_size);
buf->len = suggested_size;
}
@ -2353,7 +2351,7 @@ static void _tf_ssb_add_broadcast(tf_ssb_t* ssb, const tf_ssb_broadcast_t* broad
}
printf("Received new broadcast: host=%s, pub=%s.\n", broadcast->host, key);
tf_ssb_broadcast_t* node = malloc(sizeof(tf_ssb_broadcast_t));
tf_ssb_broadcast_t* node = tf_malloc(sizeof(tf_ssb_broadcast_t));
*node = *broadcast;
node->next = ssb->broadcasts;
node->ctime = time(NULL);
@ -2368,7 +2366,7 @@ static void _tf_ssb_on_broadcast_listener_recv(uv_udp_t* handle, ssize_t nread,
{
if (nread <= 0)
{
free(buf->base);
tf_free(buf->base);
return;
}
@ -2387,7 +2385,7 @@ static void _tf_ssb_on_broadcast_listener_recv(uv_udp_t* handle, ssize_t nread,
}
entry = strtok_r(NULL, k_delim, &state);
}
free(buf->base);
tf_free(buf->base);
}
void tf_ssb_visit_broadcasts(tf_ssb_t* ssb, void (*callback)(const struct sockaddr_in* addr, const uint8_t* pub, void* user_data), void* user_data)
@ -2415,7 +2413,7 @@ static void _tf_ssb_broadcast_cleanup_timer(uv_timer_t* timer)
{
tf_ssb_broadcast_t* node = *it;
*it = node->next;
free(node);
tf_free(node);
ssb->broadcasts_count--;
modified++;
}
@ -2487,7 +2485,7 @@ const char** tf_ssb_get_connection_ids(tf_ssb_t* ssb)
}
}
char* buffer = malloc(sizeof(char*) * (count + 1) + k_id_base64_len * count);
char* buffer = tf_malloc(sizeof(char*) * (count + 1) + k_id_base64_len * count);
char** array = (char**)buffer;
char* strings = buffer + sizeof(char*) * (count + 1);
int i = 0;
@ -2518,7 +2516,7 @@ int tf_ssb_get_connections(tf_ssb_t* ssb, tf_ssb_connection_t** out_connections,
void tf_ssb_add_broadcasts_changed_callback(tf_ssb_t* ssb, tf_ssb_broadcasts_changed_callback_t* callback, tf_ssb_callback_cleanup_t* cleanup, void* user_data)
{
tf_ssb_broadcasts_changed_callback_node_t* node = malloc(sizeof(tf_ssb_broadcasts_changed_callback_node_t));
tf_ssb_broadcasts_changed_callback_node_t* node = tf_malloc(sizeof(tf_ssb_broadcasts_changed_callback_node_t));
*node = (tf_ssb_broadcasts_changed_callback_node_t)
{
.callback = callback,
@ -2545,7 +2543,7 @@ void tf_ssb_remove_broadcasts_changed_callback(tf_ssb_t* ssb, tf_ssb_broadcasts_
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
else
{
@ -2556,7 +2554,7 @@ void tf_ssb_remove_broadcasts_changed_callback(tf_ssb_t* ssb, tf_ssb_broadcasts_
void tf_ssb_add_connections_changed_callback(tf_ssb_t* ssb, tf_ssb_connections_changed_callback_t* callback, tf_ssb_callback_cleanup_t* cleanup, void* user_data)
{
tf_ssb_connections_changed_callback_node_t* node = malloc(sizeof(tf_ssb_connections_changed_callback_node_t));
tf_ssb_connections_changed_callback_node_t* node = tf_malloc(sizeof(tf_ssb_connections_changed_callback_node_t));
*node = (tf_ssb_connections_changed_callback_node_t)
{
.callback = callback,
@ -2583,7 +2581,7 @@ void tf_ssb_remove_connections_changed_callback(tf_ssb_t* ssb, tf_ssb_connection
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
else
{
@ -2601,7 +2599,7 @@ void tf_ssb_add_rpc_callback(tf_ssb_t* ssb, const char** name, tf_ssb_rpc_callba
name_count++;
name_len += strlen(name[i]) + 1;
}
tf_ssb_rpc_callback_node_t* node = malloc(sizeof(tf_ssb_rpc_callback_node_t) + (name_count + 1) * sizeof(const char*) + name_len);
tf_ssb_rpc_callback_node_t* node = tf_malloc(sizeof(tf_ssb_rpc_callback_node_t) + (name_count + 1) * sizeof(const char*) + name_len);
*node = (tf_ssb_rpc_callback_node_t)
{
.name = (const char**)(node + 1),
@ -2650,7 +2648,7 @@ JSValue tf_ssb_connection_get_object(tf_ssb_connection_t* connection)
void tf_ssb_add_message_added_callback(tf_ssb_t* ssb, void (*callback)(tf_ssb_t* ssb, const char* id, void* user_data), void (*cleanup)(tf_ssb_t* ssb, void* user_data), void* user_data)
{
tf_ssb_message_added_callback_node_t* node = malloc(sizeof(tf_ssb_message_added_callback_node_t));
tf_ssb_message_added_callback_node_t* node = tf_malloc(sizeof(tf_ssb_message_added_callback_node_t));
*node = (tf_ssb_message_added_callback_node_t)
{
.callback = callback,
@ -2677,7 +2675,7 @@ void tf_ssb_remove_message_added_callback(tf_ssb_t* ssb, tf_ssb_message_added_ca
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
else
{
@ -2699,7 +2697,7 @@ void tf_ssb_notify_message_added(tf_ssb_t* ssb, const char* id)
void tf_ssb_add_blob_want_added_callback(tf_ssb_t* ssb, void (*callback)(tf_ssb_t* ssb, const char* id, void* user_data), void (*cleanup)(tf_ssb_t* ssb, void* user_data), void* user_data)
{
tf_ssb_blob_want_added_callback_node_t* node = malloc(sizeof(tf_ssb_blob_want_added_callback_node_t));
tf_ssb_blob_want_added_callback_node_t* node = tf_malloc(sizeof(tf_ssb_blob_want_added_callback_node_t));
*node = (tf_ssb_blob_want_added_callback_node_t)
{
.callback = callback,
@ -2726,7 +2724,7 @@ void tf_ssb_remove_blob_want_added_callback(tf_ssb_t* ssb, tf_ssb_blob_want_adde
{
node->cleanup(ssb, node->user_data);
}
free(node);
tf_free(node);
}
else
{