diff options
Diffstat (limited to 'src/omemo/omemo.c')
| -rw-r--r-- | src/omemo/omemo.c | 537 |
1 files changed, 268 insertions, 269 deletions
diff --git a/src/omemo/omemo.c b/src/omemo/omemo.c index 09782d66..997eddae 100644 --- a/src/omemo/omemo.c +++ b/src/omemo/omemo.c @@ -70,44 +70,45 @@ static gboolean _load_identity(void); static void _load_trust(void); static void _load_sessions(void); static void _load_known_devices(void); -static void _lock(void *user_data); -static void _unlock(void *user_data); -static void _omemo_log(int level, const char *message, size_t len, void *user_data); -static gboolean _handle_own_device_list(const char *const jid, GList *device_list); -static gboolean _handle_device_list_start_session(const char *const jid, GList *device_list); -static char * _omemo_fingerprint(ec_public_key *identity, gboolean formatted); -static unsigned char *_omemo_fingerprint_decode(const char *const fingerprint, size_t *len); -static char * _omemo_unformat_fingerprint(const char *const fingerprint_formatted); -static void _cache_device_identity(const char *const jid, uint32_t device_id, ec_public_key *identity); -static void _g_hash_table_free(GHashTable *hash_table); - -typedef gboolean (*OmemoDeviceListHandler)(const char *const jid, GList *device_list); - -struct omemo_context_t { +static void _lock(void* user_data); +static void _unlock(void* user_data); +static void _omemo_log(int level, const char* message, size_t len, void* user_data); +static gboolean _handle_own_device_list(const char* const jid, GList* device_list); +static gboolean _handle_device_list_start_session(const char* const jid, GList* device_list); +static char* _omemo_fingerprint(ec_public_key* identity, gboolean formatted); +static unsigned char* _omemo_fingerprint_decode(const char* const fingerprint, size_t* len); +static char* _omemo_unformat_fingerprint(const char* const fingerprint_formatted); +static void _cache_device_identity(const char* const jid, uint32_t device_id, ec_public_key* identity); +static void _g_hash_table_free(GHashTable* hash_table); + +typedef gboolean (*OmemoDeviceListHandler)(const char* const jid, GList* device_list); + +struct omemo_context_t +{ pthread_mutexattr_t attr; pthread_mutex_t lock; - signal_context *signal; + signal_context* signal; uint32_t device_id; - GHashTable *device_list; - GHashTable *device_list_handler; - ratchet_identity_key_pair *identity_key_pair; + GHashTable* device_list; + GHashTable* device_list_handler; + ratchet_identity_key_pair* identity_key_pair; uint32_t registration_id; uint32_t signed_pre_key_id; - signal_protocol_store_context *store; - GHashTable *session_store; - GHashTable *pre_key_store; - GHashTable *signed_pre_key_store; + signal_protocol_store_context* store; + GHashTable* session_store; + GHashTable* pre_key_store; + GHashTable* signed_pre_key_store; identity_key_store_t identity_key_store; - GString *identity_filename; - GKeyFile *identity_keyfile; - GString *trust_filename; - GKeyFile *trust_keyfile; - GString *sessions_filename; - GKeyFile *sessions_keyfile; - GHashTable *known_devices; - GString *known_devices_filename; - GKeyFile *known_devices_keyfile; - GHashTable *fingerprint_ac; + GString* identity_filename; + GKeyFile* identity_keyfile; + GString* trust_filename; + GKeyFile* trust_keyfile; + GString* sessions_filename; + GKeyFile* sessions_keyfile; + GHashTable* known_devices; + GString* known_devices_filename; + GKeyFile* known_devices_keyfile; + GHashTable* fingerprint_ac; }; static omemo_context omemo_ctx; @@ -137,9 +138,9 @@ omemo_close(void) } void -omemo_on_connect(ProfAccount *account) +omemo_on_connect(ProfAccount* account) { - GError *error = NULL; + GError* error = NULL; if (signal_context_create(&omemo_ctx.signal, &omemo_ctx) != 0) { cons_show("Error initializing OMEMO context"); @@ -220,13 +221,12 @@ omemo_on_connect(ProfAccount *account) }; signal_protocol_store_context_set_identity_key_store(omemo_ctx.store, &identity_key_store); - loaded = FALSE; omemo_ctx.device_list = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)g_list_free); omemo_ctx.device_list_handler = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL); omemo_ctx.known_devices = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_g_hash_table_free); - gchar *omemo_dir = files_get_account_data_path(DIR_OMEMO, account->jid); + gchar* omemo_dir = files_get_account_data_path(DIR_OMEMO, account->jid); omemo_ctx.identity_filename = g_string_new(omemo_dir); g_string_append(omemo_ctx.identity_filename, "/identity.txt"); @@ -237,11 +237,10 @@ omemo_on_connect(ProfAccount *account) omemo_ctx.known_devices_filename = g_string_new(omemo_dir); g_string_append(omemo_ctx.known_devices_filename, "/known_devices.txt"); - errno = 0; int res = g_mkdir_with_parents(omemo_dir, S_IRWXU); if (res == -1) { - char *errmsg = strerror(errno); + char* errmsg = strerror(errno); if (errmsg) { log_error("OMEMO: error creating directory: %s, %s", omemo_dir, errmsg); } else { @@ -312,7 +311,7 @@ omemo_on_disconnect(void) } void -omemo_generate_crypto_materials(ProfAccount *account) +omemo_generate_crypto_materials(ProfAccount* account) { if (loaded) { return; @@ -330,12 +329,12 @@ omemo_generate_crypto_materials(ProfAccount *account) signal_protocol_key_helper_generate_identity_key_pair(&omemo_ctx.identity_key_pair, omemo_ctx.signal); ec_public_key_serialize(&omemo_ctx.identity_key_store.public, ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair)); - char *identity_key_public = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.public), signal_buffer_len(omemo_ctx.identity_key_store.public)); + char* identity_key_public = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.public), signal_buffer_len(omemo_ctx.identity_key_store.public)); g_key_file_set_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC, identity_key_public); g_free(identity_key_public); ec_private_key_serialize(&omemo_ctx.identity_key_store.private, ratchet_identity_key_pair_get_private(omemo_ctx.identity_key_pair)); - char *identity_key_private = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.private), signal_buffer_len(omemo_ctx.identity_key_store.private)); + char* identity_key_private = g_base64_encode(signal_buffer_data(omemo_ctx.identity_key_store.private), signal_buffer_len(omemo_ctx.identity_key_store.private)); g_key_file_set_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE, identity_key_private); g_free(identity_key_private); @@ -365,7 +364,7 @@ omemo_publish_crypto_materials(void) return; } - char *barejid = connection_get_barejid(); + char* barejid = connection_get_barejid(); /* Ensure we get our current device list, and it gets updated with our * device_id */ @@ -380,12 +379,12 @@ omemo_publish_crypto_materials(void) void omemo_start_sessions(void) { - GSList *contacts = roster_get_contacts(ROSTER_ORD_NAME); + GSList* contacts = roster_get_contacts(ROSTER_ORD_NAME); if (contacts) { - GSList *curr; - for (curr = contacts; curr != NULL; curr = g_slist_next(curr)){ + GSList* curr; + for (curr = contacts; curr != NULL; curr = g_slist_next(curr)) { PContact contact = curr->data; - const char *jid = p_contact_barejid(contact); + const char* jid = p_contact_barejid(contact); omemo_start_session(jid); } g_slist_free(contacts); @@ -393,11 +392,11 @@ omemo_start_sessions(void) } void -omemo_start_session(const char *const barejid) +omemo_start_session(const char* const barejid) { - if( omemo_loaded() ) { + if (omemo_loaded()) { log_info("OMEMO: start session with %s", barejid); - GList *device_list = g_hash_table_lookup(omemo_ctx.device_list, barejid); + GList* device_list = g_hash_table_lookup(omemo_ctx.device_list, barejid); if (!device_list) { log_info("OMEMO: missing device list for %s", barejid); omemo_devicelist_request(barejid); @@ -405,7 +404,7 @@ omemo_start_session(const char *const barejid) return; } - GList *device_id; + GList* device_id; for (device_id = device_list; device_id != NULL; device_id = device_id->next) { omemo_bundle_request(barejid, GPOINTER_TO_INT(device_id->data), omemo_start_device_session_handle_bundle, free, strdup(barejid)); } @@ -413,12 +412,12 @@ omemo_start_session(const char *const barejid) } void -omemo_start_muc_sessions(const char *const roomjid) +omemo_start_muc_sessions(const char* const roomjid) { - GList *members = muc_members(roomjid); - GList *iter; + GList* members = muc_members(roomjid); + GList* iter; for (iter = members; iter != NULL; iter = iter->next) { - Jid *jid = jid_create(iter->data); + Jid* jid = jid_create(iter->data); omemo_start_session(jid->barejid); jid_destroy(jid); } @@ -438,9 +437,9 @@ omemo_device_id(void) } void -omemo_identity_key(unsigned char **output, size_t *length) +omemo_identity_key(unsigned char** output, size_t* length) { - signal_buffer *buffer = NULL; + signal_buffer* buffer = NULL; ec_public_key_serialize(&buffer, ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair)); *length = signal_buffer_len(buffer); *output = malloc(*length); @@ -449,10 +448,10 @@ omemo_identity_key(unsigned char **output, size_t *length) } void -omemo_signed_prekey(unsigned char **output, size_t *length) +omemo_signed_prekey(unsigned char** output, size_t* length) { - session_signed_pre_key *signed_pre_key; - signal_buffer *buffer = NULL; + session_signed_pre_key* signed_pre_key; + signal_buffer* buffer = NULL; if (signal_protocol_signed_pre_key_load_key(omemo_ctx.store, &signed_pre_key, omemo_ctx.signed_pre_key_id) != SG_SUCCESS) { *output = NULL; @@ -469,9 +468,9 @@ omemo_signed_prekey(unsigned char **output, size_t *length) } void -omemo_signed_prekey_signature(unsigned char **output, size_t *length) +omemo_signed_prekey_signature(unsigned char** output, size_t* length) { - session_signed_pre_key *signed_pre_key; + session_signed_pre_key* signed_pre_key; if (signal_protocol_signed_pre_key_load_key(omemo_ctx.store, &signed_pre_key, omemo_ctx.signed_pre_key_id) != SG_SUCCESS) { *output = NULL; @@ -486,25 +485,25 @@ omemo_signed_prekey_signature(unsigned char **output, size_t *length) } void -omemo_prekeys(GList **prekeys, GList **ids, GList **lengths) +omemo_prekeys(GList** prekeys, GList** ids, GList** lengths) { GHashTableIter iter; gpointer id; g_hash_table_iter_init(&iter, omemo_ctx.pre_key_store); while (g_hash_table_iter_next(&iter, &id, NULL)) { - session_pre_key *pre_key; + session_pre_key* pre_key; int ret; ret = signal_protocol_pre_key_load_key(omemo_ctx.store, &pre_key, GPOINTER_TO_INT(id)); if (ret != SG_SUCCESS) { continue; } - signal_buffer *public_key; + signal_buffer* public_key; ec_public_key_serialize(&public_key, ec_key_pair_get_public(session_pre_key_get_key_pair(pre_key))); SIGNAL_UNREF(pre_key); size_t length = signal_buffer_len(public_key); - unsigned char *prekey_value = malloc(length); + unsigned char* prekey_value = malloc(length); memcpy(prekey_value, signal_buffer_data(public_key), length); signal_buffer_free(public_key); @@ -515,9 +514,9 @@ omemo_prekeys(GList **prekeys, GList **ids, GList **lengths) } void -omemo_set_device_list(const char *const from, GList * device_list) +omemo_set_device_list(const char* const from, GList* device_list) { - Jid *jid; + Jid* jid; if (from) { jid = jid_create(from); } else { @@ -537,7 +536,7 @@ omemo_set_device_list(const char *const from, GList * device_list) jid_destroy(jid); } -GKeyFile * +GKeyFile* omemo_identity_keyfile(void) { return omemo_ctx.identity_keyfile; @@ -546,14 +545,14 @@ omemo_identity_keyfile(void) void omemo_identity_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.identity_keyfile, omemo_ctx.identity_filename->str, &error)) { log_error("OMEMO: error saving identity to: %s, %s", omemo_ctx.identity_filename->str, error->message); } } -GKeyFile * +GKeyFile* omemo_trust_keyfile(void) { return omemo_ctx.trust_keyfile; @@ -562,14 +561,14 @@ omemo_trust_keyfile(void) void omemo_trust_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.trust_keyfile, omemo_ctx.trust_filename->str, &error)) { log_error("OMEMO: error saving trust to: %s, %s", omemo_ctx.trust_filename->str, error->message); } } -GKeyFile * +GKeyFile* omemo_sessions_keyfile(void) { return omemo_ctx.sessions_keyfile; @@ -578,7 +577,7 @@ omemo_sessions_keyfile(void) void omemo_sessions_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.sessions_keyfile, omemo_ctx.sessions_filename->str, &error)) { log_error("OMEMO: error saving sessions to: %s, %s", omemo_ctx.sessions_filename->str, error->message); @@ -588,7 +587,7 @@ omemo_sessions_keyfile_save(void) void omemo_known_devices_keyfile_save(void) { - GError *error = NULL; + GError* error = NULL; if (!g_key_file_save_to_file(omemo_ctx.known_devices_keyfile, omemo_ctx.known_devices_filename->str, &error)) { log_error("OMEMO: error saving known devices to: %s, %s", omemo_ctx.known_devices_filename->str, error->message); @@ -596,11 +595,11 @@ omemo_known_devices_keyfile_save(void) } void -omemo_start_device_session(const char *const jid, uint32_t device_id, - GList *prekeys, uint32_t signed_prekey_id, - const unsigned char *const signed_prekey_raw, size_t signed_prekey_len, - const unsigned char *const signature, size_t signature_len, - const unsigned char *const identity_key_raw, size_t identity_key_len) +omemo_start_device_session(const char* const jid, uint32_t device_id, + GList* prekeys, uint32_t signed_prekey_id, + const unsigned char* const signed_prekey_raw, size_t signed_prekey_len, + const unsigned char* const signature, size_t signature_len, + const unsigned char* const identity_key_raw, size_t identity_key_len) { signal_protocol_address address = { .name = jid, @@ -608,11 +607,11 @@ omemo_start_device_session(const char *const jid, uint32_t device_id, .device_id = device_id, }; - ec_public_key *identity_key; + ec_public_key* identity_key; curve_decode_point(&identity_key, identity_key_raw, identity_key_len, omemo_ctx.signal); _cache_device_identity(jid, device_id, identity_key); - gboolean trusted = is_trusted_identity(&address, (uint8_t *)identity_key_raw, identity_key_len, &omemo_ctx.identity_key_store); + gboolean trusted = is_trusted_identity(&address, (uint8_t*)identity_key_raw, identity_key_len, &omemo_ctx.identity_key_store); if (!trusted) { goto out; @@ -620,15 +619,15 @@ omemo_start_device_session(const char *const jid, uint32_t device_id, if (!contains_session(&address, omemo_ctx.session_store)) { int res; - session_pre_key_bundle *bundle; - signal_protocol_address *address; + session_pre_key_bundle* bundle; + signal_protocol_address* address; address = malloc(sizeof(signal_protocol_address)); address->name = strdup(jid); address->name_len = strlen(jid); address->device_id = device_id; - session_builder *builder; + session_builder* builder; res = session_builder_create(&builder, omemo_ctx.store, address, omemo_ctx.signal); if (res != 0) { log_error("OMEMO: cannot create session builder for %s device %d", jid, device_id); @@ -638,11 +637,11 @@ omemo_start_device_session(const char *const jid, uint32_t device_id, int prekey_index; gcry_randomize(&prekey_index, sizeof(int), GCRY_STRONG_RANDOM); prekey_index %= g_list_length(prekeys); - omemo_key_t *prekey = g_list_nth_data(prekeys, prekey_index); + omemo_key_t* prekey = g_list_nth_data(prekeys, prekey_index); - ec_public_key *prekey_public; + ec_public_key* prekey_public; curve_decode_point(&prekey_public, prekey->data, prekey->length, omemo_ctx.signal); - ec_public_key *signed_prekey; + ec_public_key* signed_prekey; curve_decode_point(&signed_prekey, signed_prekey_raw, signed_prekey_len, omemo_ctx.signal); res = session_pre_key_bundle_create(&bundle, 0, device_id, prekey->id, prekey_public, signed_prekey_id, signed_prekey, signature, signature_len, identity_key); @@ -664,19 +663,19 @@ out: SIGNAL_UNREF(identity_key); } -char * -omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_receipt, gboolean muc, const char *const replace_id) +char* +omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_receipt, gboolean muc, const char* const replace_id) { - char *id = NULL; + char* id = NULL; int res; - Jid *jid = jid_create(connection_get_fulljid()); - GList *keys = NULL; - - unsigned char *key; - unsigned char *iv; - unsigned char *ciphertext; - unsigned char *tag; - unsigned char *key_tag; + Jid* jid = jid_create(connection_get_fulljid()); + GList* keys = NULL; + + unsigned char* key; + unsigned char* iv; + unsigned char* ciphertext; + unsigned char* tag; + unsigned char* key_tag; size_t ciphertext_len, tag_len; ciphertext_len = strlen(message); @@ -688,7 +687,7 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ key = gcry_random_bytes_secure(AES128_GCM_KEY_LENGTH, GCRY_VERY_STRONG_RANDOM); iv = gcry_random_bytes_secure(AES128_GCM_IV_LENGTH, GCRY_VERY_STRONG_RANDOM); - res = aes128gcm_encrypt(ciphertext, &ciphertext_len, tag, &tag_len, (const unsigned char * const)message, strlen(message), iv, key); + res = aes128gcm_encrypt(ciphertext, &ciphertext_len, tag, &tag_len, (const unsigned char* const)message, strlen(message), iv, key); if (res != 0) { log_error("OMEMO: cannot encrypt message"); goto out; @@ -697,31 +696,31 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ memcpy(key_tag, key, AES128_GCM_KEY_LENGTH); memcpy(key_tag + AES128_GCM_KEY_LENGTH, tag, AES128_GCM_TAG_LENGTH); - GList *recipients = NULL; + GList* recipients = NULL; if (muc) { - ProfMucWin *mucwin = (ProfMucWin *)win; + ProfMucWin* mucwin = (ProfMucWin*)win; assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK); - GList *members = muc_members(mucwin->roomjid); - GList *iter; + GList* members = muc_members(mucwin->roomjid); + GList* iter; for (iter = members; iter != NULL; iter = iter->next) { - Jid *jid = jid_create(iter->data); + Jid* jid = jid_create(iter->data); recipients = g_list_append(recipients, strdup(jid->barejid)); jid_destroy(jid); } g_list_free(members); } else { - ProfChatWin *chatwin = (ProfChatWin *)win; + ProfChatWin* chatwin = (ProfChatWin*)win; assert(chatwin->memcheck == PROFCHATWIN_MEMCHECK); recipients = g_list_append(recipients, strdup(chatwin->barejid)); } - GList *device_ids_iter; + GList* device_ids_iter; omemo_ctx.identity_key_store.recv = false; - GList *recipients_iter; + GList* recipients_iter; for (recipients_iter = recipients; recipients_iter != NULL; recipients_iter = recipients_iter->next) { - GList *recipient_device_id = NULL; + GList* recipient_device_id = NULL; recipient_device_id = g_hash_table_lookup(omemo_ctx.device_list, recipients_iter->data); if (!recipient_device_id) { log_warning("OMEMO: cannot find device ids for %s", recipients_iter->data); @@ -730,8 +729,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ for (device_ids_iter = recipient_device_id; device_ids_iter != NULL; device_ids_iter = device_ids_iter->next) { int res; - ciphertext_message *ciphertext; - session_cipher *cipher; + ciphertext_message* ciphertext; + session_cipher* cipher; signal_protocol_address address = { .name = recipients_iter->data, .name_len = strlen(recipients_iter->data), @@ -750,8 +749,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ log_error("OMEMO: cannot encrypt key for %s device id %d", address.name, address.device_id); continue; } - signal_buffer *buffer = ciphertext_message_get_serialized(ciphertext); - omemo_key_t *key = malloc(sizeof(omemo_key_t)); + signal_buffer* buffer = ciphertext_message_get_serialized(ciphertext); + omemo_key_t* key = malloc(sizeof(omemo_key_t)); key->length = signal_buffer_len(buffer); key->data = malloc(key->length); memcpy(key->data, signal_buffer_data(buffer), key->length); @@ -765,11 +764,11 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ g_list_free_full(recipients, free); if (!muc) { - GList *sender_device_id = g_hash_table_lookup(omemo_ctx.device_list, jid->barejid); + GList* sender_device_id = g_hash_table_lookup(omemo_ctx.device_list, jid->barejid); for (device_ids_iter = sender_device_id; device_ids_iter != NULL; device_ids_iter = device_ids_iter->next) { int res; - ciphertext_message *ciphertext; - session_cipher *cipher; + ciphertext_message* ciphertext; + session_cipher* cipher; signal_protocol_address address = { .name = jid->barejid, .name_len = strlen(jid->barejid), @@ -788,8 +787,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ log_error("OMEMO: cannot encrypt key for %s device id %d", address.name, address.device_id); continue; } - signal_buffer *buffer = ciphertext_message_get_serialized(ciphertext); - omemo_key_t *key = malloc(sizeof(omemo_key_t)); + signal_buffer* buffer = ciphertext_message_get_serialized(ciphertext); + omemo_key_t* key = malloc(sizeof(omemo_key_t)); key->length = signal_buffer_len(buffer); key->data = malloc(key->length); memcpy(key->data, signal_buffer_data(buffer), key->length); @@ -801,11 +800,11 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_ } if (muc) { - ProfMucWin *mucwin = (ProfMucWin *)win; + ProfMucWin* mucwin = (ProfMucWin*)win; assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK); id = message_send_chat_omemo(mucwin->roomjid, omemo_ctx.device_id, keys, iv, AES128_GCM_IV_LENGTH, ciphertext, ciphertext_len, request_receipt, TRUE, replace_id); } else { - ProfChatWin *chatwin = (ProfChatWin *)win; + ProfChatWin* chatwin = (ProfChatWin*)win; assert(chatwin->memcheck == PROFCHATWIN_MEMCHECK); id = message_send_chat_omemo(chatwin->barejid, omemo_ctx.device_id, keys, iv, AES128_GCM_IV_LENGTH, ciphertext, ciphertext_len, request_receipt, FALSE, replace_id); } @@ -822,24 +821,24 @@ out: return id; } -char * -omemo_on_message_recv(const char *const from_jid, uint32_t sid, - const unsigned char *const iv, size_t iv_len, GList *keys, - const unsigned char *const payload, size_t payload_len, gboolean muc, gboolean *trusted) +char* +omemo_on_message_recv(const char* const from_jid, uint32_t sid, + const unsigned char* const iv, size_t iv_len, GList* keys, + const unsigned char* const payload, size_t payload_len, gboolean muc, gboolean* trusted) { - unsigned char *plaintext = NULL; - Jid *sender = NULL; - Jid *from = jid_create(from_jid); + unsigned char* plaintext = NULL; + Jid* sender = NULL; + Jid* from = jid_create(from_jid); if (!from) { log_error("Invalid jid %s", from_jid); goto out; } int res; - GList *key_iter; - omemo_key_t *key = NULL; + GList* key_iter; + omemo_key_t* key = NULL; for (key_iter = keys; key_iter != NULL; key_iter = key_iter->next) { - if (((omemo_key_t *)key_iter->data)->device_id == omemo_ctx.device_id) { + if (((omemo_key_t*)key_iter->data)->device_id == omemo_ctx.device_id) { key = key_iter->data; break; } @@ -851,10 +850,10 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, } if (muc) { - GList *roster = muc_roster(from->barejid); - GList *iter; + GList* roster = muc_roster(from->barejid); + GList* iter; for (iter = roster; iter != NULL; iter = iter->next) { - Occupant *occupant = (Occupant *)iter->data; + Occupant* occupant = (Occupant*)iter->data; if (g_strcmp0(occupant->nick, from->resourcepart) == 0) { sender = jid_create(occupant->jid); break; @@ -869,8 +868,8 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, sender = jid_create(from->barejid); } - session_cipher *cipher; - signal_buffer *plaintext_key; + session_cipher* cipher; + signal_buffer* plaintext_key; signal_protocol_address address = { .name = sender->barejid, .name_len = strlen(sender->barejid), @@ -885,9 +884,9 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, if (key->prekey) { log_debug("OMEMO: decrypting message with prekey"); - pre_key_signal_message *message; - ec_public_key *their_identity_key; - signal_buffer *identity_buffer = NULL; + pre_key_signal_message* message; + ec_public_key* their_identity_key; + signal_buffer* identity_buffer = NULL; omemo_ctx.identity_key_store.recv = true; @@ -901,12 +900,12 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, /* Perform a real check of the identity */ ec_public_key_serialize(&identity_buffer, their_identity_key); *trusted = is_trusted_identity(&address, signal_buffer_data(identity_buffer), - signal_buffer_len(identity_buffer), &omemo_ctx.identity_key_store); + signal_buffer_len(identity_buffer), &omemo_ctx.identity_key_store); /* Replace used pre_key in bundle */ uint32_t pre_key_id = pre_key_signal_message_get_pre_key_id(message); - ec_key_pair *ec_pair; - session_pre_key *new_pre_key; + ec_key_pair* ec_pair; + session_pre_key* new_pre_key; curve_generate_key_pair(omemo_ctx.signal, &ec_pair); session_pre_key_create(&new_pre_key, pre_key_id, ec_pair); signal_protocol_pre_key_store_key(omemo_ctx.store, new_pre_key); @@ -921,7 +920,7 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, } } else { log_debug("OMEMO: decrypting message with existing session"); - signal_message *message = NULL; + signal_message* message = NULL; res = signal_message_deserialize(&message, key->data, key->length, omemo_ctx.signal); @@ -949,8 +948,8 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, size_t plaintext_len = payload_len; plaintext = malloc(plaintext_len + 1); res = aes128gcm_decrypt(plaintext, &plaintext_len, payload, payload_len, iv, - iv_len, signal_buffer_data(plaintext_key), - signal_buffer_data(plaintext_key) + AES128_GCM_KEY_LENGTH); + iv_len, signal_buffer_data(plaintext_key), + signal_buffer_data(plaintext_key) + AES128_GCM_KEY_LENGTH); signal_buffer_free(plaintext_key); if (res != 0) { log_error("OMEMO: cannot decrypt message: %s", gcry_strerror(res)); @@ -964,13 +963,13 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid, out: jid_destroy(from); jid_destroy(sender); - return (char *)plaintext; + return (char*)plaintext; } -char * -omemo_format_fingerprint(const char *const fingerprint) +char* +omemo_format_fingerprint(const char* const fingerprint) { - char *output = malloc(strlen(fingerprint) + strlen(fingerprint) / 8); + char* output = malloc(strlen(fingerprint) + strlen(fingerprint) / 8); int i, j; for (i = 0, j = 0; i < strlen(fingerprint); i++) { @@ -985,11 +984,11 @@ omemo_format_fingerprint(const char *const fingerprint) return output; } -static char * -_omemo_unformat_fingerprint(const char *const fingerprint_formatted) +static char* +_omemo_unformat_fingerprint(const char* const fingerprint_formatted) { /* Unformat fingerprint */ - char *fingerprint = malloc(strlen(fingerprint_formatted)); + char* fingerprint = malloc(strlen(fingerprint_formatted)); int i; int j; for (i = 0, j = 0; fingerprint_formatted[i] != '\0'; i++) { @@ -1004,17 +1003,17 @@ _omemo_unformat_fingerprint(const char *const fingerprint_formatted) return fingerprint; } -char * +char* omemo_own_fingerprint(gboolean formatted) { - ec_public_key *identity = ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair); + ec_public_key* identity = ratchet_identity_key_pair_get_public(omemo_ctx.identity_key_pair); return _omemo_fingerprint(identity, formatted); } -GList * -omemo_known_device_identities(const char *const jid) +GList* +omemo_known_device_identities(const char* const jid) { - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { return NULL; } @@ -1023,14 +1022,14 @@ omemo_known_device_identities(const char *const jid) } gboolean -omemo_is_trusted_identity(const char *const jid, const char *const fingerprint) +omemo_is_trusted_identity(const char* const jid, const char* const fingerprint) { - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { return FALSE; } - void *device_id = g_hash_table_lookup(known_identities, fingerprint); + void* device_id = g_hash_table_lookup(known_identities, fingerprint); if (!device_id) { return FALSE; } @@ -1042,9 +1041,9 @@ omemo_is_trusted_identity(const char *const jid, const char *const fingerprint) }; size_t fingerprint_len; - unsigned char *fingerprint_raw = _omemo_fingerprint_decode(fingerprint, &fingerprint_len); - unsigned char djb_type[] = {'\x05'}; - signal_buffer *buffer = signal_buffer_create(djb_type, 1); + unsigned char* fingerprint_raw = _omemo_fingerprint_decode(fingerprint, &fingerprint_len); + unsigned char djb_type[] = { '\x05' }; + signal_buffer* buffer = signal_buffer_create(djb_type, 1); buffer = signal_buffer_append(buffer, fingerprint_raw, fingerprint_len); gboolean trusted = is_trusted_identity(&address, signal_buffer_data(buffer), signal_buffer_len(buffer), &omemo_ctx.identity_key_store); @@ -1055,21 +1054,21 @@ omemo_is_trusted_identity(const char *const jid, const char *const fingerprint) return trusted; } -static char * -_omemo_fingerprint(ec_public_key *identity, gboolean formatted) +static char* +_omemo_fingerprint(ec_public_key* identity, gboolean formatted) { int i; - signal_buffer *identity_public_key; + signal_buffer* identity_public_key; ec_public_key_serialize(&identity_public_key, identity); size_t identity_public_key_len = signal_buffer_len(identity_public_key); - unsigned char *identity_public_key_data = signal_buffer_data(identity_public_key); + unsigned char* identity_public_key_data = signal_buffer_data(identity_public_key); /* Skip first byte corresponding to signal DJB_TYPE */ identity_public_key_len--; identity_public_key_data = &identity_public_key_data[1]; - char *fingerprint = malloc(identity_public_key_len * 2 + 1); + char* fingerprint = malloc(identity_public_key_len * 2 + 1); for (i = 0; i < identity_public_key_len; i++) { fingerprint[i * 2] = (identity_public_key_data[i] & 0xf0) >> 4; @@ -1091,16 +1090,16 @@ _omemo_fingerprint(ec_public_key *identity, gboolean formatted) if (!formatted) { return fingerprint; } else { - char *formatted_fingerprint = omemo_format_fingerprint(fingerprint); + char* formatted_fingerprint = omemo_format_fingerprint(fingerprint); free(fingerprint); return formatted_fingerprint; } } -static unsigned char * -_omemo_fingerprint_decode(const char *const fingerprint, size_t *len) +static unsigned char* +_omemo_fingerprint_decode(const char* const fingerprint, size_t* len) { - unsigned char *output = malloc(strlen(fingerprint) / 2 + 1); + unsigned char* output = malloc(strlen(fingerprint) / 2 + 1); int i; int j; @@ -1121,18 +1120,18 @@ _omemo_fingerprint_decode(const char *const fingerprint, size_t *len) } void -omemo_trust(const char *const jid, const char *const fingerprint_formatted) +omemo_trust(const char* const jid, const char* const fingerprint_formatted) { size_t len; - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { log_warning("OMEMO: cannot trust unknown device: %s", fingerprint_formatted); cons_show("Cannot trust unknown device: %s", fingerprint_formatted); return; } - char *fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); + char* fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); uint32_t device_id = GPOINTER_TO_INT(g_hash_table_lookup(known_identities, fingerprint)); free(fingerprint); @@ -1152,9 +1151,9 @@ omemo_trust(const char *const jid, const char *const fingerprint_formatted) .device_id = device_id, }; - unsigned char *fingerprint_raw = _omemo_fingerprint_decode(fingerprint_formatted, &len); - unsigned char djb_type[] = {'\x05'}; - signal_buffer *buffer = signal_buffer_create(djb_type, 1); + unsigned char* fingerprint_raw = _omemo_fingerprint_decode(fingerprint_formatted, &len); + unsigned char djb_type[] = { '\x05' }; + signal_buffer* buffer = signal_buffer_create(djb_type, 1); buffer = signal_buffer_append(buffer, fingerprint_raw, len); save_identity(&address, signal_buffer_data(buffer), signal_buffer_len(buffer), &omemo_ctx.identity_key_store); free(fingerprint_raw); @@ -1164,15 +1163,15 @@ omemo_trust(const char *const jid, const char *const fingerprint_formatted) } void -omemo_untrust(const char *const jid, const char *const fingerprint_formatted) +omemo_untrust(const char* const jid, const char* const fingerprint_formatted) { size_t len; - unsigned char *identity = _omemo_fingerprint_decode(fingerprint_formatted, &len); + unsigned char* identity = _omemo_fingerprint_decode(fingerprint_formatted, &len); GHashTableIter iter; gpointer key, value; - GHashTable *trusted = g_hash_table_lookup(omemo_ctx.identity_key_store.trusted, jid); + GHashTable* trusted = g_hash_table_lookup(omemo_ctx.identity_key_store.trusted, jid); if (!trusted) { free(identity); return; @@ -1180,8 +1179,8 @@ omemo_untrust(const char *const jid, const char *const fingerprint_formatted) g_hash_table_iter_init(&iter, trusted); while (g_hash_table_iter_next(&iter, &key, &value)) { - signal_buffer *buffer = value; - unsigned char *original = signal_buffer_data(buffer); + signal_buffer* buffer = value; + unsigned char* original = signal_buffer_data(buffer); /* Skip DJB_TYPE byte */ original++; if ((signal_buffer_len(buffer) - 1) == len && memcmp(original, identity, len) == 0) { @@ -1190,10 +1189,10 @@ omemo_untrust(const char *const jid, const char *const fingerprint_formatted) } free(identity); - char *fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); + char* fingerprint = _omemo_unformat_fingerprint(fingerprint_formatted); /* Remove existing session */ - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { log_error("OMEMO: cannot find known device while untrusting a fingerprint"); goto out; @@ -1213,7 +1212,7 @@ omemo_untrust(const char *const jid, const char *const fingerprint_formatted) delete_session(&address, omemo_ctx.session_store); /* Remove from keyfile */ - char *device_id_str = g_strdup_printf("%d", device_id); + char* device_id_str = g_strdup_printf("%d", device_id); g_key_file_remove_key(omemo_ctx.trust_keyfile, jid, device_id_str, NULL); g_free(device_id_str); omemo_trust_keyfile_save(); @@ -1223,41 +1222,41 @@ out: } static void -_lock(void *user_data) +_lock(void* user_data) { - omemo_context *ctx = (omemo_context *)user_data; + omemo_context* ctx = (omemo_context*)user_data; pthread_mutex_lock(&ctx->lock); } static void -_unlock(void *user_data) +_unlock(void* user_data) { - omemo_context *ctx = (omemo_context *)user_data; + omemo_context* ctx = (omemo_context*)user_data; pthread_mutex_unlock(&ctx->lock); } static void -_omemo_log(int level, const char *message, size_t len, void *user_data) +_omemo_log(int level, const char* message, size_t len, void* user_data) { switch (level) { - case SG_LOG_ERROR: - log_error("OMEMO: %s", message); - break; - case SG_LOG_WARNING: - log_warning("OMEMO: %s", message); - break; - case SG_LOG_NOTICE: - case SG_LOG_INFO: - log_info("OMEMO: %s", message); - break; - case SG_LOG_DEBUG: - log_debug("OMEMO: %s", message); - break; + case SG_LOG_ERROR: + log_error("OMEMO: %s", message); + break; + case SG_LOG_WARNING: + log_warning("OMEMO: %s", message); + break; + case SG_LOG_NOTICE: + case SG_LOG_INFO: + log_info("OMEMO: %s", message); + break; + case SG_LOG_DEBUG: + log_debug("OMEMO: %s", message); + break; } } static gboolean -_handle_own_device_list(const char *const jid, GList *device_list) +_handle_own_device_list(const char* const jid, GList* device_list) { if (!g_list_find(device_list, GINT_TO_POINTER(omemo_ctx.device_id))) { device_list = g_list_copy(device_list); @@ -1266,7 +1265,7 @@ _handle_own_device_list(const char *const jid, GList *device_list) omemo_devicelist_publish(device_list); } - GList *device_id; + GList* device_id; for (device_id = device_list; device_id != NULL; device_id = device_id->next) { omemo_bundle_request(jid, GPOINTER_TO_INT(device_id->data), omemo_start_device_session_handle_bundle, free, strdup(jid)); } @@ -1275,7 +1274,7 @@ _handle_own_device_list(const char *const jid, GList *device_list) } static gboolean -_handle_device_list_start_session(const char *const jid, GList *device_list) +_handle_device_list_start_session(const char* const jid, GList* device_list) { omemo_start_session(jid); @@ -1283,7 +1282,7 @@ _handle_device_list_start_session(const char *const jid, GList *device_list) } void -omemo_key_free(omemo_key_t *key) +omemo_key_free(omemo_key_t* key) { if (key == NULL) { return; @@ -1294,7 +1293,7 @@ omemo_key_free(omemo_key_t *key) } char* -omemo_fingerprint_autocomplete(const char *const search_str, gboolean previous, void *context) +omemo_fingerprint_autocomplete(const char* const search_str, gboolean previous, void* context) { Autocomplete ac = g_hash_table_lookup(omemo_ctx.fingerprint_ac, context); if (ac != NULL) { @@ -1318,11 +1317,11 @@ omemo_fingerprint_autocomplete_reset(void) } gboolean -omemo_automatic_start(const char *const recipient) +omemo_automatic_start(const char* const recipient) { gboolean result = FALSE; - char *account_name = session_get_account_name(); - ProfAccount *account = accounts_get_account(account_name); + char* account_name = session_get_account_name(); + ProfAccount* account = accounts_get_account(account_name); prof_omemopolicy_t policy; if (account->omemo_policy) { @@ -1338,7 +1337,7 @@ omemo_automatic_start(const char *const recipient) } } else { // check global setting - char *pref_omemo_policy = prefs_get_string(PREF_OMEMO_POLICY); + char* pref_omemo_policy = prefs_get_string(PREF_OMEMO_POLICY); // pref defaults to manual policy = PROF_OMEMOPOLICY_AUTOMATIC; @@ -1353,25 +1352,25 @@ omemo_automatic_start(const char *const recipient) } switch (policy) { - case PROF_OMEMOPOLICY_MANUAL: + case PROF_OMEMOPOLICY_MANUAL: + result = FALSE; + break; + case PROF_OMEMOPOLICY_AUTOMATIC: + if (g_list_find_custom(account->omemo_enabled, recipient, (GCompareFunc)g_strcmp0)) { + result = TRUE; + } else if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { result = FALSE; - break; - case PROF_OMEMOPOLICY_AUTOMATIC: - if (g_list_find_custom(account->omemo_enabled, recipient, (GCompareFunc)g_strcmp0)) { - result = TRUE; - } else if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { - result = FALSE; - } else { - result = FALSE; - } - break; - case PROF_OMEMOPOLICY_ALWAYS: - if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { - result = FALSE; - } else { - result = TRUE; - } - break; + } else { + result = FALSE; + } + break; + case PROF_OMEMOPOLICY_ALWAYS: + if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) { + result = FALSE; + } else { + result = TRUE; + } + break; } account_free(account); @@ -1381,7 +1380,7 @@ omemo_automatic_start(const char *const recipient) static gboolean _load_identity(void) { - GError *error = NULL; + GError* error = NULL; log_info("Loading OMEMO identity"); /* Device ID */ @@ -1403,50 +1402,50 @@ _load_identity(void) /* Identity key */ error = NULL; - char *identity_key_public_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC, &error); + char* identity_key_public_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PUBLIC, &error); if (!identity_key_public_b64) { log_error("OMEMO: cannot load identity public key: %s", error->message); return FALSE; } size_t identity_key_public_len; - unsigned char *identity_key_public = g_base64_decode(identity_key_public_b64, &identity_key_public_len); + unsigned char* identity_key_public = g_base64_decode(identity_key_public_b64, &identity_key_public_len); g_free(identity_key_public_b64); omemo_ctx.identity_key_store.public = signal_buffer_create(identity_key_public, identity_key_public_len); error = NULL; - char *identity_key_private_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE, &error); + char* identity_key_private_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_IDENTITY, OMEMO_STORE_KEY_IDENTITY_KEY_PRIVATE, &error); if (!identity_key_private_b64) { log_error("OMEMO: cannot load identity private key: %s", error->message); return FALSE; } size_t identity_key_private_len; - unsigned char *identity_key_private = g_base64_decode(identity_key_private_b64, &identity_key_private_len); + unsigned char* identity_key_private = g_base64_decode(identity_key_private_b64, &identity_key_private_len); g_free(identity_key_private_b64); omemo_ctx.identity_key_store.private = signal_buffer_create(identity_key_private, identity_key_private_len); - ec_public_key *public_key; + ec_public_key* public_key; curve_decode_point(&public_key, identity_key_public, identity_key_public_len, omemo_ctx.signal); - ec_private_key *private_key; + ec_private_key* private_key; curve_decode_private_point(&private_key, identity_key_private, identity_key_private_len, omemo_ctx.signal); ratchet_identity_key_pair_create(&omemo_ctx.identity_key_pair, public_key, private_key); g_free(identity_key_public); g_free(identity_key_private); - char **keys = NULL; + char** keys = NULL; int i; /* Pre keys */ i = 0; keys = g_key_file_get_keys(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_PREKEYS, NULL, NULL); if (keys) { for (i = 0; keys[i] != NULL; i++) { - char *pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_PREKEYS, keys[i], NULL); + char* pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_PREKEYS, keys[i], NULL); size_t pre_key_len; - unsigned char *pre_key = g_base64_decode(pre_key_b64, &pre_key_len); + unsigned char* pre_key = g_base64_decode(pre_key_b64, &pre_key_len); g_free(pre_key_b64); - signal_buffer *buffer = signal_buffer_create(pre_key, pre_key_len); + signal_buffer* buffer = signal_buffer_create(pre_key, pre_key_len); g_free(pre_key); g_hash_table_insert(omemo_ctx.pre_key_store, GINT_TO_POINTER(strtoul(keys[i], NULL, 10)), buffer); } @@ -1464,11 +1463,11 @@ _load_identity(void) keys = g_key_file_get_keys(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_SIGNED_PREKEYS, NULL, NULL); if (keys) { for (i = 0; keys[i] != NULL; i++) { - char *signed_pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_SIGNED_PREKEYS, keys[i], NULL); + char* signed_pre_key_b64 = g_key_file_get_string(omemo_ctx.identity_keyfile, OMEMO_STORE_GROUP_SIGNED_PREKEYS, keys[i], NULL); size_t signed_pre_key_len; - unsigned char *signed_pre_key = g_base64_decode(signed_pre_key_b64, &signed_pre_key_len); + unsigned char* signed_pre_key = g_base64_decode(signed_pre_key_b64, &signed_pre_key_len); g_free(signed_pre_key_b64); - signal_buffer *buffer = signal_buffer_create(signed_pre_key, signed_pre_key_len); + signal_buffer* buffer = signal_buffer_create(signed_pre_key, signed_pre_key_len); g_free(signed_pre_key); g_hash_table_insert(omemo_ctx.signed_pre_key_store, GINT_TO_POINTER(strtoul(keys[i], NULL, 10)), buffer); omemo_ctx.signed_pre_key_id = strtoul(keys[i], NULL, 10); @@ -1491,12 +1490,12 @@ _load_identity(void) static void _load_trust(void) { - char **keys = NULL; - char **groups = g_key_file_get_groups(omemo_ctx.trust_keyfile, NULL); + char** keys = NULL; + char** groups = g_key_file_get_groups(omemo_ctx.trust_keyfile, NULL); if (groups) { int i; for (i = 0; groups[i] != NULL; i++) { - GHashTable *trusted; + GHashTable* trusted; trusted = g_hash_table_lookup(omemo_ctx.identity_key_store.trusted, groups[i]); if (!trusted) { @@ -1507,11 +1506,11 @@ _load_trust(void) keys = g_key_file_get_keys(omemo_ctx.trust_keyfile, groups[i], NULL, NULL); int j; for (j = 0; keys[j] != NULL; j++) { - char *key_b64 = g_key_file_get_string(omemo_ctx.trust_keyfile, groups[i], keys[j], NULL); + char* key_b64 = g_key_file_get_string(omemo_ctx.trust_keyfile, groups[i], keys[j], NULL); size_t key_len; - unsigned char *key = g_base64_decode(key_b64, &key_len); + unsigned char* key = g_base64_decode(key_b64, &key_len); g_free(key_b64); - signal_buffer *buffer = signal_buffer_create(key, key_len); + signal_buffer* buffer = signal_buffer_create(key, key_len); g_free(key); uint32_t device_id = strtoul(keys[j], NULL, 10); g_hash_table_insert(trusted, GINT_TO_POINTER(device_id), buffer); @@ -1526,11 +1525,11 @@ static void _load_sessions(void) { int i; - char **groups = g_key_file_get_groups(omemo_ctx.sessions_keyfile, NULL); + char** groups = g_key_file_get_groups(omemo_ctx.sessions_keyfile, NULL); if (groups) { for (i = 0; groups[i] != NULL; i++) { int j; - GHashTable *device_store = NULL; + GHashTable* device_store = NULL; device_store = g_hash_table_lookup(omemo_ctx.session_store, groups[i]); if (!device_store) { @@ -1538,14 +1537,14 @@ _load_sessions(void) g_hash_table_insert(omemo_ctx.session_store, strdup(groups[i]), device_store); } - char **keys = g_key_file_get_keys(omemo_ctx.sessions_keyfile, groups[i], NULL, NULL); + char** keys = g_key_file_get_keys(omemo_ctx.sessions_keyfile, groups[i], NULL, NULL); for (j = 0; keys[j] != NULL; j++) { uint32_t id = strtoul(keys[j], NULL, 10); - char *record_b64 = g_key_file_get_string(omemo_ctx.sessions_keyfile, groups[i], keys[j], NULL); + char* record_b64 = g_key_file_get_string(omemo_ctx.sessions_keyfile, groups[i], keys[j], NULL); size_t record_len; - unsigned char *record = g_base64_decode(record_b64, &record_len); + unsigned char* record = g_base64_decode(record_b64, &record_len); g_free(record_b64); - signal_buffer *buffer = signal_buffer_create(record, record_len); + signal_buffer* buffer = signal_buffer_create(record, record_len); g_free(record); g_hash_table_insert(device_store, GINT_TO_POINTER(id), buffer); } @@ -1559,11 +1558,11 @@ static void _load_known_devices(void) { int i; - char **groups = g_key_file_get_groups(omemo_ctx.known_devices_keyfile, NULL); + char** groups = g_key_file_get_groups(omemo_ctx.known_devices_keyfile, NULL); if (groups) { for (i = 0; groups[i] != NULL; i++) { int j; - GHashTable *known_identities = NULL; + GHashTable* known_identities = NULL; known_identities = g_hash_table_lookup(omemo_ctx.known_devices, groups[i]); if (!known_identities) { @@ -1571,10 +1570,10 @@ _load_known_devices(void) g_hash_table_insert(omemo_ctx.known_devices, strdup(groups[i]), known_identities); } - char **keys = g_key_file_get_keys(omemo_ctx.known_devices_keyfile, groups[i], NULL, NULL); + char** keys = g_key_file_get_keys(omemo_ctx.known_devices_keyfile, groups[i], NULL, NULL); for (j = 0; keys[j] != NULL; j++) { uint32_t device_id = strtoul(keys[j], NULL, 10); - char *fingerprint = g_key_file_get_string(omemo_ctx.known_devices_keyfile, groups[i], keys[j], NULL); + char* fingerprint = g_key_file_get_string(omemo_ctx.known_devices_keyfile, groups[i], keys[j], NULL); g_hash_table_insert(known_identities, strdup(fingerprint), GINT_TO_POINTER(device_id)); g_free(fingerprint); } @@ -1585,19 +1584,19 @@ _load_known_devices(void) } static void -_cache_device_identity(const char *const jid, uint32_t device_id, ec_public_key *identity) +_cache_device_identity(const char* const jid, uint32_t device_id, ec_public_key* identity) { - GHashTable *known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); + GHashTable* known_identities = g_hash_table_lookup(omemo_ctx.known_devices, jid); if (!known_identities) { known_identities = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL); g_hash_table_insert(omemo_ctx.known_devices, strdup(jid), known_identities); } - char *fingerprint = _omemo_fingerprint(identity, FALSE); + char* fingerprint = _omemo_fingerprint(identity, FALSE); log_info("OMEMO: cache identity for %s:%d: %s", jid, device_id, fingerprint); g_hash_table_insert(known_identities, strdup(fingerprint), GINT_TO_POINTER(device_id)); - char *device_id_str = g_strdup_printf("%d", device_id); + char* device_id_str = g_strdup_printf("%d", device_id); g_key_file_set_string(omemo_ctx.known_devices_keyfile, jid, device_id_str, fingerprint); g_free(device_id_str); omemo_known_devices_keyfile_save(); @@ -1608,14 +1607,14 @@ _cache_device_identity(const char *const jid, uint32_t device_id, ec_public_key g_hash_table_insert(omemo_ctx.fingerprint_ac, strdup(jid), ac); } - char *formatted_fingerprint = omemo_format_fingerprint(fingerprint); + char* formatted_fingerprint = omemo_format_fingerprint(fingerprint); autocomplete_add(ac, formatted_fingerprint); free(formatted_fingerprint); free(fingerprint); } 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); @@ -1626,12 +1625,12 @@ _generate_pre_keys(int count) { unsigned int start; gcry_randomize(&start, sizeof(unsigned int), GCRY_VERY_STRONG_RANDOM); - signal_protocol_key_helper_pre_key_list_node *pre_keys_head; + signal_protocol_key_helper_pre_key_list_node* pre_keys_head; signal_protocol_key_helper_generate_pre_keys(&pre_keys_head, start, count, omemo_ctx.signal); - signal_protocol_key_helper_pre_key_list_node *p; + signal_protocol_key_helper_pre_key_list_node* p; for (p = pre_keys_head; p != NULL; p = signal_protocol_key_helper_key_list_next(p)) { - session_pre_key *prekey = signal_protocol_key_helper_key_list_element(p); + session_pre_key* prekey = signal_protocol_key_helper_key_list_element(p); signal_protocol_pre_key_store_key(omemo_ctx.store, prekey); } signal_protocol_key_helper_key_list_free(pre_keys_head); @@ -1640,7 +1639,7 @@ _generate_pre_keys(int count) static void _generate_signed_pre_key(void) { - session_signed_pre_key *signed_pre_key; + session_signed_pre_key* signed_pre_key; struct timeval tv; gettimeofday(&tv, NULL); unsigned long long timestamp = (unsigned long long)(tv.tv_sec) * 1000 + (unsigned long long)(tv.tv_usec) / 1000; |