about summary refs log tree commit diff stats
path: root/src/omemo/store.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/omemo/store.c')
-rw-r--r--src/omemo/store.c187
1 files changed, 92 insertions, 95 deletions
diff --git a/src/omemo/store.c b/src/omemo/store.c
index ec39ed1b..434483ed 100644
--- a/src/omemo/store.c
+++ b/src/omemo/store.c
@@ -39,28 +39,28 @@
 #include "omemo/omemo.h"
 #include "omemo/store.h"
 
-static void _g_hash_table_free(GHashTable *hash_table);
+static void _g_hash_table_free(GHashTable* hash_table);
 
-GHashTable *
+GHashTable*
 session_store_new(void)
 {
     return g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_g_hash_table_free);
 }
 
-GHashTable *
+GHashTable*
 pre_key_store_new(void)
 {
     return g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free);
 }
 
-GHashTable *
+GHashTable*
 signed_pre_key_store_new(void)
 {
     return g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free);
 }
 
 void
-identity_key_store_new(identity_key_store_t *identity_key_store)
+identity_key_store_new(identity_key_store_t* identity_key_store)
 {
     identity_key_store->trusted = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)signal_buffer_free);
     identity_key_store->private = NULL;
@@ -69,16 +69,16 @@ identity_key_store_new(identity_key_store_t *identity_key_store)
 
 #ifdef HAVE_LIBSIGNAL_LT_2_3_2
 int
-load_session(signal_buffer **record, const signal_protocol_address *address,
-    void *user_data)
+load_session(signal_buffer** record, const signal_protocol_address* address,
+             void* user_data)
 #else
 int
-load_session(signal_buffer **record, signal_buffer **user_record,
-    const signal_protocol_address *address, void *user_data)
+load_session(signal_buffer** record, signal_buffer** user_record,
+             const signal_protocol_address* address, void* user_data)
 #endif
 {
-    GHashTable *session_store = (GHashTable *)user_data;
-    GHashTable *device_store = NULL;
+    GHashTable* session_store = (GHashTable*)user_data;
+    GHashTable* device_store = NULL;
 
     device_store = g_hash_table_lookup(session_store, address->name);
     if (!device_store) {
@@ -86,7 +86,7 @@ load_session(signal_buffer **record, signal_buffer **user_record,
         return 0;
     }
 
-    signal_buffer *original = g_hash_table_lookup(device_store, GINT_TO_POINTER(address->device_id));
+    signal_buffer* original = g_hash_table_lookup(device_store, GINT_TO_POINTER(address->device_id));
     if (!original) {
         *record = NULL;
         return 0;
@@ -96,11 +96,11 @@ load_session(signal_buffer **record, signal_buffer **user_record,
 }
 
 int
-get_sub_device_sessions(signal_int_list **sessions, const char *name,
-    size_t name_len, void *user_data)
+get_sub_device_sessions(signal_int_list** sessions, const char* name,
+                        size_t name_len, void* user_data)
 {
-    GHashTable *session_store = (GHashTable *)user_data;
-    GHashTable *device_store = NULL;
+    GHashTable* session_store = (GHashTable*)user_data;
+    GHashTable* device_store = NULL;
     GHashTableIter iter;
     gpointer key, value;
 
@@ -115,37 +115,35 @@ get_sub_device_sessions(signal_int_list **sessions, const char *name,
         signal_int_list_push_back(*sessions, GPOINTER_TO_INT(key));
     }
 
-
     return SG_SUCCESS;
 }
 
 #ifdef HAVE_LIBSIGNAL_LT_2_3_2
 int
-store_session(const signal_protocol_address *address, uint8_t *record,
-    size_t record_len, void *user_data)
+store_session(const signal_protocol_address* address, uint8_t* record,
+              size_t record_len, void* user_data)
 #else
 int
-store_session(const signal_protocol_address *address,
-    uint8_t *record, size_t record_len,
-    uint8_t *user_record, size_t user_record_len,
-    void *user_data)
+store_session(const signal_protocol_address* address,
+              uint8_t* record, size_t record_len,
+              uint8_t* user_record, size_t user_record_len,
+              void* user_data)
 #endif
 {
-    GHashTable *session_store = (GHashTable *)user_data;
-    GHashTable *device_store = NULL;
+    GHashTable* session_store = (GHashTable*)user_data;
+    GHashTable* device_store = NULL;
 
-    device_store = g_hash_table_lookup(session_store, (void *)address->name);
+    device_store = g_hash_table_lookup(session_store, (void*)address->name);
     if (!device_store) {
         device_store = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free);
         g_hash_table_insert(session_store, strdup(address->name), device_store);
     }
 
-    signal_buffer *buffer = signal_buffer_create(record, record_len);
+    signal_buffer* buffer = signal_buffer_create(record, record_len);
     g_hash_table_insert(device_store, GINT_TO_POINTER(address->device_id), buffer);
 
-
-    char *record_b64 = g_base64_encode(record, record_len);
-    char *device_id = g_strdup_printf("%d", address->device_id);
+    char* record_b64 = g_base64_encode(record, record_len);
+    char* device_id = g_strdup_printf("%d", address->device_id);
     g_key_file_set_string(omemo_sessions_keyfile(), address->name, device_id, record_b64);
     free(device_id);
     g_free(record_b64);
@@ -156,10 +154,10 @@ store_session(const signal_protocol_address *address,
 }
 
 int
-contains_session(const signal_protocol_address *address, void *user_data)
+contains_session(const signal_protocol_address* address, void* user_data)
 {
-    GHashTable *session_store = (GHashTable *)user_data;
-    GHashTable *device_store = NULL;
+    GHashTable* session_store = (GHashTable*)user_data;
+    GHashTable* device_store = NULL;
 
     device_store = g_hash_table_lookup(session_store, address->name);
     if (!device_store) {
@@ -174,10 +172,10 @@ contains_session(const signal_protocol_address *address, void *user_data)
 }
 
 int
-delete_session(const signal_protocol_address *address, void *user_data)
+delete_session(const signal_protocol_address* address, void* user_data)
 {
-    GHashTable *session_store = (GHashTable *)user_data;
-    GHashTable *device_store = NULL;
+    GHashTable* session_store = (GHashTable*)user_data;
+    GHashTable* device_store = NULL;
 
     device_store = g_hash_table_lookup(session_store, address->name);
     if (!device_store) {
@@ -186,7 +184,7 @@ delete_session(const signal_protocol_address *address, void *user_data)
 
     g_hash_table_remove(device_store, GINT_TO_POINTER(address->device_id));
 
-    char *device_id_str = g_strdup_printf("%d", address->device_id);
+    char* device_id_str = g_strdup_printf("%d", address->device_id);
     g_key_file_remove_key(omemo_sessions_keyfile(), address->name, device_id_str, NULL);
     g_free(device_id_str);
     omemo_sessions_keyfile_save();
@@ -195,10 +193,10 @@ delete_session(const signal_protocol_address *address, void *user_data)
 }
 
 int
-delete_all_sessions(const char *name, size_t name_len, void *user_data)
+delete_all_sessions(const char* name, size_t name_len, void* user_data)
 {
-    GHashTable *session_store = (GHashTable *)user_data;
-    GHashTable *device_store = NULL;
+    GHashTable* session_store = (GHashTable*)user_data;
+    GHashTable* device_store = NULL;
 
     device_store = g_hash_table_lookup(session_store, name);
     if (!device_store) {
@@ -211,10 +209,10 @@ delete_all_sessions(const char *name, size_t name_len, void *user_data)
 }
 
 int
-load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data)
+load_pre_key(signal_buffer** record, uint32_t pre_key_id, void* user_data)
 {
-    signal_buffer *original;
-    GHashTable *pre_key_store = (GHashTable *)user_data;
+    signal_buffer* original;
+    GHashTable* pre_key_store = (GHashTable*)user_data;
 
     original = g_hash_table_lookup(pre_key_store, GINT_TO_POINTER(pre_key_id));
     if (original == NULL) {
@@ -226,17 +224,17 @@ load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data)
 }
 
 int
-store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len,
-    void *user_data)
+store_pre_key(uint32_t pre_key_id, uint8_t* record, size_t record_len,
+              void* user_data)
 {
-    GHashTable *pre_key_store = (GHashTable *)user_data;
+    GHashTable* pre_key_store = (GHashTable*)user_data;
 
-    signal_buffer *buffer = signal_buffer_create(record, record_len);
+    signal_buffer* buffer = signal_buffer_create(record, record_len);
     g_hash_table_insert(pre_key_store, GINT_TO_POINTER(pre_key_id), buffer);
 
     /* Long term storage */
-    char *pre_key_id_str = g_strdup_printf("%d", pre_key_id);
-    char *record_b64 = g_base64_encode(record, record_len);
+    char* pre_key_id_str = g_strdup_printf("%d", pre_key_id);
+    char* record_b64 = g_base64_encode(record, record_len);
     g_key_file_set_string(omemo_identity_keyfile(), OMEMO_STORE_GROUP_PREKEYS, pre_key_id_str, record_b64);
     g_free(pre_key_id_str);
     g_free(record_b64);
@@ -247,22 +245,22 @@ store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len,
 }
 
 int
-contains_pre_key(uint32_t pre_key_id, void *user_data)
+contains_pre_key(uint32_t pre_key_id, void* user_data)
 {
-    GHashTable *pre_key_store = (GHashTable *)user_data;
+    GHashTable* pre_key_store = (GHashTable*)user_data;
 
     return g_hash_table_lookup(pre_key_store, GINT_TO_POINTER(pre_key_id)) != NULL;
 }
 
 int
-remove_pre_key(uint32_t pre_key_id, void *user_data)
+remove_pre_key(uint32_t pre_key_id, void* user_data)
 {
-    GHashTable *pre_key_store = (GHashTable *)user_data;
+    GHashTable* pre_key_store = (GHashTable*)user_data;
 
     int ret = g_hash_table_remove(pre_key_store, GINT_TO_POINTER(pre_key_id));
 
     /* Long term storage */
-    char *pre_key_id_str = g_strdup_printf("%d", pre_key_id);
+    char* pre_key_id_str = g_strdup_printf("%d", pre_key_id);
     g_key_file_remove_key(omemo_identity_keyfile(), OMEMO_STORE_GROUP_PREKEYS, pre_key_id_str, NULL);
     g_free(pre_key_id_str);
 
@@ -276,11 +274,11 @@ remove_pre_key(uint32_t pre_key_id, void *user_data)
 }
 
 int
-load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id,
-    void *user_data)
+load_signed_pre_key(signal_buffer** record, uint32_t signed_pre_key_id,
+                    void* user_data)
 {
-    signal_buffer *original;
-    GHashTable *signed_pre_key_store = (GHashTable *)user_data;
+    signal_buffer* original;
+    GHashTable* signed_pre_key_store = (GHashTable*)user_data;
 
     original = g_hash_table_lookup(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id));
     if (!original) {
@@ -292,17 +290,17 @@ load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id,
 }
 
 int
-store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record,
-    size_t record_len, void *user_data)
+store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t* record,
+                     size_t record_len, void* user_data)
 {
-    GHashTable *signed_pre_key_store = (GHashTable *)user_data;
+    GHashTable* signed_pre_key_store = (GHashTable*)user_data;
 
-    signal_buffer *buffer = signal_buffer_create(record, record_len);
+    signal_buffer* buffer = signal_buffer_create(record, record_len);
     g_hash_table_insert(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id), buffer);
 
     /* Long term storage */
-    char *signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id);
-    char *record_b64 = g_base64_encode(record, record_len);
+    char* signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id);
+    char* record_b64 = g_base64_encode(record, record_len);
     g_key_file_set_string(omemo_identity_keyfile(), OMEMO_STORE_GROUP_SIGNED_PREKEYS, signed_pre_key_id_str, record_b64);
     g_free(signed_pre_key_id_str);
     g_free(record_b64);
@@ -313,22 +311,22 @@ store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record,
 }
 
 int
-contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data)
+contains_signed_pre_key(uint32_t signed_pre_key_id, void* user_data)
 {
-    GHashTable *signed_pre_key_store = (GHashTable *)user_data;
+    GHashTable* signed_pre_key_store = (GHashTable*)user_data;
 
     return g_hash_table_lookup(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id)) != NULL;
 }
 
 int
-remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data)
+remove_signed_pre_key(uint32_t signed_pre_key_id, void* user_data)
 {
-    GHashTable *signed_pre_key_store = (GHashTable *)user_data;
+    GHashTable* signed_pre_key_store = (GHashTable*)user_data;
 
     int ret = g_hash_table_remove(signed_pre_key_store, GINT_TO_POINTER(signed_pre_key_id));
 
     /* Long term storage */
-    char *signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id);
+    char* signed_pre_key_id_str = g_strdup_printf("%d", signed_pre_key_id);
     g_key_file_remove_key(omemo_identity_keyfile(), OMEMO_STORE_GROUP_PREKEYS, signed_pre_key_id_str, NULL);
     g_free(signed_pre_key_id_str);
 
@@ -338,10 +336,10 @@ remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data)
 }
 
 int
-get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data,
-    void *user_data)
+get_identity_key_pair(signal_buffer** public_data, signal_buffer** private_data,
+                      void* user_data)
 {
-    identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data;
+    identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data;
 
     *public_data = signal_buffer_copy(identity_key_store->public);
     *private_data = signal_buffer_copy(identity_key_store->private);
@@ -350,9 +348,9 @@ get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data,
 }
 
 int
-get_local_registration_id(void *user_data, uint32_t *registration_id)
+get_local_registration_id(void* user_data, uint32_t* registration_id)
 {
-    identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data;
+    identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data;
 
     *registration_id = identity_key_store->registration_id;
 
@@ -360,10 +358,10 @@ get_local_registration_id(void *user_data, uint32_t *registration_id)
 }
 
 int
-save_identity(const signal_protocol_address *address, uint8_t *key_data,
-    size_t key_len, void *user_data)
+save_identity(const signal_protocol_address* address, uint8_t* key_data,
+              size_t key_len, void* user_data)
 {
-    identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data;
+    identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data;
 
     if (identity_key_store->recv) {
         /* Do not trust identity automatically */
@@ -377,9 +375,9 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data,
         }
     }
 
-    signal_buffer *buffer = signal_buffer_create(key_data, key_len);
+    signal_buffer* buffer = signal_buffer_create(key_data, key_len);
 
-    GHashTable *trusted = g_hash_table_lookup(identity_key_store->trusted, address->name);
+    GHashTable* trusted = g_hash_table_lookup(identity_key_store->trusted, address->name);
     if (!trusted) {
         trusted = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)signal_buffer_free);
         g_hash_table_insert(identity_key_store->trusted, strdup(address->name), trusted);
@@ -387,8 +385,8 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data,
     g_hash_table_insert(trusted, GINT_TO_POINTER(address->device_id), buffer);
 
     /* Long term storage */
-    char *key_b64 = g_base64_encode(key_data, key_len);
-    char *device_id = g_strdup_printf("%d", address->device_id);
+    char* key_b64 = g_base64_encode(key_data, key_len);
+    char* device_id = g_strdup_printf("%d", address->device_id);
     g_key_file_set_string(omemo_trust_keyfile(), address->name, device_id, key_b64);
     g_free(device_id);
     g_free(key_b64);
@@ -399,13 +397,13 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data,
 }
 
 int
-is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data,
-    size_t key_len, void *user_data)
+is_trusted_identity(const signal_protocol_address* address, uint8_t* key_data,
+                    size_t key_len, void* user_data)
 {
     int ret;
-    identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data;
+    identity_key_store_t* identity_key_store = (identity_key_store_t*)user_data;
 
-    GHashTable *trusted = g_hash_table_lookup(identity_key_store->trusted, address->name);
+    GHashTable* trusted = g_hash_table_lookup(identity_key_store->trusted, address->name);
     if (!trusted) {
         if (identity_key_store->recv) {
             return 1;
@@ -414,14 +412,13 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data,
         }
     }
 
-    signal_buffer *buffer = signal_buffer_create(key_data, key_len);
-    signal_buffer *original = g_hash_table_lookup(trusted, GINT_TO_POINTER(address->device_id));
+    signal_buffer* buffer = signal_buffer_create(key_data, key_len);
+    signal_buffer* original = g_hash_table_lookup(trusted, GINT_TO_POINTER(address->device_id));
 
     ret = original != NULL && signal_buffer_compare(buffer, original) == 0;
 
     signal_buffer_free(buffer);
 
-
     if (identity_key_store->recv) {
         return 1;
     } else {
@@ -430,23 +427,23 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data,
 }
 
 int
-store_sender_key(const signal_protocol_sender_key_name *sender_key_name,
-    uint8_t *record, size_t record_len, uint8_t *user_record,
-    size_t user_record_len, void *user_data)
+store_sender_key(const signal_protocol_sender_key_name* sender_key_name,
+                 uint8_t* record, size_t record_len, uint8_t* user_record,
+                 size_t user_record_len, void* user_data)
 {
     return SG_SUCCESS;
 }
 
 int
-load_sender_key(signal_buffer **record, signal_buffer **user_record,
-                const signal_protocol_sender_key_name *sender_key_name,
-                void *user_data)
+load_sender_key(signal_buffer** record, signal_buffer** user_record,
+                const signal_protocol_sender_key_name* sender_key_name,
+                void* user_data)
 {
     return SG_SUCCESS;
 }
 
 static void
-_g_hash_table_free(GHashTable *hash_table)
+_g_hash_table_free(GHashTable* hash_table)
 {
     g_hash_table_remove_all(hash_table);
     g_hash_table_unref(hash_table);
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-06-30 12:23:49 +0000