From 744dc2f5da2c54ad1e4d7d6ce229bc1756d81263 Mon Sep 17 00:00:00 2001 From: "zugz (tox)" Date: Sun, 9 Sep 2018 23:21:20 +0200 Subject: [PATCH] Make saving and loading the responsibility of Tox rather than Messenger --- auto_tests/messenger_test.c | 43 ----------- testing/Messenger_test.c | 17 +---- toxcore/DHT.c | 4 +- toxcore/Messenger.c | 139 ++++++++++-------------------------- toxcore/Messenger.h | 29 +++----- toxcore/group.c | 16 +++++ toxcore/group.h | 15 ++++ toxcore/state.c | 32 +++++++-- toxcore/state.h | 25 ++++++- toxcore/tox.c | 82 +++++++++++++++++++-- 10 files changed, 208 insertions(+), 194 deletions(-) diff --git a/auto_tests/messenger_test.c b/auto_tests/messenger_test.c index dd644e50..e885e652 100644 --- a/auto_tests/messenger_test.c +++ b/auto_tests/messenger_test.c @@ -265,54 +265,11 @@ START_TEST(test_dht_state_saveloadsave) } END_TEST -START_TEST(test_messenger_state_saveloadsave) -{ - /* validate that: - * a) saving stays within the confined space - * b) a save()d state can be load()ed back successfully - * c) a second save() is of equal size - * d) the second save() is of equal content */ - const size_t extra = 64; - const size_t size = messenger_size(m); - VLA(uint8_t, buffer, size + 2 * extra); - memset(buffer, 0xCD, extra); - memset(buffer + extra + size, 0xCD, extra); - messenger_save(m, buffer + extra); - - for (size_t i = 0; i < extra; i++) { - ck_assert_msg(buffer[i] == 0xCD, "Buffer underwritten from messenger_save() @%u", (unsigned)i); - ck_assert_msg(buffer[extra + size + i] == 0xCD, "Buffer overwritten from messenger_save() @%u", (unsigned)i); - } - - const int res = messenger_load(m, buffer + extra, size); - - if (res == -1) { - ck_assert_msg(res == 0, "Failed to load back stored buffer: res == -1"); - } else { - const size_t offset = res >> 4; - const uint8_t *ptr = buffer + extra + offset; - ck_assert_msg(res == 0, "Failed to load back stored buffer: 0x%02x%02x%02x%02x%02x%02x%02x%02x @%u/%u, code %d", - ptr[-2], ptr[-1], ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], - (unsigned)offset, (unsigned)size, res & 0x0F); - } - - const size_t size2 = messenger_size(m); - ck_assert_msg(size == size2, "Messenger \"grew\" in size from a store/load cycle: %u -> %u", - (unsigned)size, (unsigned)size2); - - VLA(uint8_t, buffer2, size2); - messenger_save(m, buffer2); - - ck_assert_msg(!memcmp(buffer + extra, buffer2, size), "Messenger state changed by store/load/store cycle"); -} -END_TEST - static Suite *messenger_suite(void) { Suite *s = suite_create("Messenger"); DEFTESTCASE(dht_state_saveloadsave); - DEFTESTCASE(messenger_state_saveloadsave); DEFTESTCASE(getself_name); DEFTESTCASE(m_get_userstatus_size); diff --git a/testing/Messenger_test.c b/testing/Messenger_test.c index 5abb3998..a61d0dcf 100644 --- a/testing/Messenger_test.c +++ b/testing/Messenger_test.c @@ -100,10 +100,8 @@ int main(int argc, char *argv[]) } /* with optional --ipvx, now it can be 1-4 arguments... */ - if ((argc != argvoffset + 2) && (argc != argvoffset + 4)) { + if (argc != argvoffset + 4) { printf("Usage: %s [--ipv4|--ipv6] ip port public_key (of the DHT bootstrap node)\n", argv[0]); - printf("or\n"); - printf(" %s [--ipv4|--ipv6] Save.bak (to read Save.bak as state file)\n", argv[0]); exit(0); } @@ -134,19 +132,6 @@ int main(int argc, char *argv[]) printf("Failed to convert \"%s\" into an IP address. Exiting...\n", argv[argvoffset + 1]); exit(1); } - } else { - FILE *file = fopen(argv[argvoffset + 1], "rb"); - - if (file == nullptr) { - printf("Failed to open \"%s\" - does it exist?\n", argv[argvoffset + 1]); - return 1; - } - - int read; - uint8_t buffer[128000]; - read = fread(buffer, 1, 128000, file); - printf("Messenger loaded: %i\n", messenger_load(m, buffer, read)); - fclose(file); } m_callback_friendrequest(m, print_request); diff --git a/toxcore/DHT.c b/toxcore/DHT.c index 8208052d..4908de32 100644 --- a/toxcore/DHT.c +++ b/toxcore/DHT.c @@ -2831,7 +2831,7 @@ uint32_t dht_size(const DHT *dht) /* Save the DHT in data where data is an array of size dht_size(). */ void dht_save(const DHT *dht, uint8_t *data) { - host_to_lendian32(data, DHT_STATE_COOKIE_GLOBAL); + host_to_lendian_bytes32(data, DHT_STATE_COOKIE_GLOBAL); data += sizeof(uint32_t); uint8_t *const old_data = data; @@ -2960,7 +2960,7 @@ int dht_load(DHT *dht, const uint8_t *data, uint32_t length) if (length > cookie_len) { uint32_t data32; - lendian_to_host32(&data32, data); + lendian_bytes_to_host32(&data32, data); if (data32 == DHT_STATE_COOKIE_GLOBAL) { return state_load(dht->log, dht_load_state_callback, dht, data + cookie_len, diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c index e092a9f2..ae2d1d3b 100644 --- a/toxcore/Messenger.c +++ b/toxcore/Messenger.c @@ -2739,10 +2739,6 @@ void do_messenger(Messenger *m, void *userdata) /* new messenger format for load/save, more robust and forward compatible */ -#define MESSENGER_STATE_COOKIE_GLOBAL 0x15ed1b1f - -#define MESSENGER_STATE_COOKIE_TYPE 0x01ce - #define SAVED_FRIEND_REQUEST_SIZE 1024 #define NUM_SAVED_PATH_NODES 8 @@ -2881,7 +2877,7 @@ static uint32_t m_state_plugins_size(const Messenger *m) * returns true on success * returns false on failure */ -bool m_register_state_plugin(Messenger *m, Messenger_State_Type type, m_state_size_cb size_callback, +bool m_register_state_plugin(Messenger *m, State_Type type, m_state_size_cb size_callback, m_state_load_cb load_callback, m_state_save_cb save_callback) { @@ -2904,7 +2900,7 @@ bool m_register_state_plugin(Messenger *m, Messenger_State_Type type, m_state_si return true; } -static uint32_t m_plugin_size(const Messenger *m, Messenger_State_Type type) +static uint32_t m_plugin_size(const Messenger *m, State_Type type) { for (uint8_t i = 0; i < m->options.state_plugins_length; ++i) { const Messenger_State_Plugin plugin = m->options.state_plugins[i]; @@ -2922,30 +2918,18 @@ static uint32_t m_plugin_size(const Messenger *m, Messenger_State_Type type) /* return size of the messenger data (for saving) */ uint32_t messenger_size(const Messenger *m) { - const uint32_t size32 = sizeof(uint32_t); - const uint32_t sizesubhead = size32 * 2; - return size32 * 2 // global cookie - + m_state_plugins_size(m) - + sizesubhead; + return m_state_plugins_size(m); } -/* Save the messenger in data of size Messenger_size(). */ -void messenger_save(const Messenger *m, uint8_t *data) +/* Save the messenger in data of size messenger_size(). */ +uint8_t *messenger_save(const Messenger *m, uint8_t *data) { - memset(data, 0, messenger_size(m)); - - const uint32_t size32 = sizeof(uint32_t); - - // write cookie - memset(data, 0, size32); - data += size32; - host_to_lendian32(data, MESSENGER_STATE_COOKIE_GLOBAL); - data += size32; - for (uint8_t i = 0; i < m->options.state_plugins_length; ++i) { const Messenger_State_Plugin plugin = m->options.state_plugins[i]; data = plugin.save(m, data); } + + return data; } // nospam state plugin @@ -2956,12 +2940,12 @@ static uint32_t nospam_keys_size(const Messenger *m) static State_Load_Status load_nospam_keys(Messenger *m, const uint8_t *data, uint32_t length) { - if (length != m_plugin_size(m, MESSENGER_STATE_TYPE_NOSPAMKEYS)) { + if (length != m_plugin_size(m, STATE_TYPE_NOSPAMKEYS)) { return STATE_LOAD_STATUS_ERROR; } uint32_t nospam; - lendian_to_host32(&nospam, data); + lendian_bytes_to_host32(&nospam, data); set_nospam(m->fr, nospam); load_secret_key(m->net_crypto, data + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE); @@ -2974,11 +2958,11 @@ static State_Load_Status load_nospam_keys(Messenger *m, const uint8_t *data, uin static uint8_t *save_nospam_keys(const Messenger *m, uint8_t *data) { - const uint32_t len = m_plugin_size(m, MESSENGER_STATE_TYPE_NOSPAMKEYS); + const uint32_t len = m_plugin_size(m, STATE_TYPE_NOSPAMKEYS); assert(sizeof(get_nospam(m->fr)) == sizeof(uint32_t)); - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_NOSPAMKEYS); + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_NOSPAMKEYS); uint32_t nospam = get_nospam(m->fr); - host_to_lendian32(data, nospam); + host_to_lendian_bytes32(data, nospam); save_keys(m->net_crypto, data + sizeof(uint32_t)); data += len; return data; @@ -2992,8 +2976,8 @@ static uint32_t m_dht_size(const Messenger *m) static uint8_t *save_dht(const Messenger *m, uint8_t *data) { - const uint32_t len = m_plugin_size(m, MESSENGER_STATE_TYPE_DHT); - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_DHT); + const uint32_t len = m_plugin_size(m, STATE_TYPE_DHT); + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_DHT); dht_save(m->dht, data); data += len; return data; @@ -3013,8 +2997,8 @@ static uint32_t saved_friendslist_size(const Messenger *m) static uint8_t *friends_list_save(const Messenger *m, uint8_t *data) { - const uint32_t len = m_plugin_size(m, MESSENGER_STATE_TYPE_FRIENDS); - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_FRIENDS); + const uint32_t len = m_plugin_size(m, STATE_TYPE_FRIENDS); + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_FRIENDS); uint32_t num = 0; uint8_t *cur_data = data; @@ -3119,8 +3103,8 @@ static uint32_t name_size(const Messenger *m) static uint8_t *save_name(const Messenger *m, uint8_t *data) { - const uint32_t len = m_plugin_size(m, MESSENGER_STATE_TYPE_NAME); - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_NAME); + const uint32_t len = m_plugin_size(m, STATE_TYPE_NAME); + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_NAME); memcpy(data, m->name, len); data += len; return data; @@ -3143,8 +3127,8 @@ static uint32_t status_message_size(const Messenger *m) static uint8_t *save_status_message(const Messenger *m, uint8_t *data) { - const uint32_t len = m_plugin_size(m, MESSENGER_STATE_TYPE_STATUSMESSAGE); - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_STATUSMESSAGE); + const uint32_t len = m_plugin_size(m, STATE_TYPE_STATUSMESSAGE); + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_STATUSMESSAGE); memcpy(data, m->statusmessage, len); data += len; return data; @@ -3167,8 +3151,8 @@ static uint32_t status_size(const Messenger *m) static uint8_t *save_status(const Messenger *m, uint8_t *data) { - const uint32_t len = m_plugin_size(m, MESSENGER_STATE_TYPE_STATUS); - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_STATUS); + const uint32_t len = m_plugin_size(m, STATE_TYPE_STATUS); + data = state_write_section_header(data, STATE_COOKIE_TYPE, len, STATE_TYPE_STATUS); *data = m->userstatus; data += len; return data; @@ -3193,7 +3177,7 @@ static uint8_t *save_tcp_relays(const Messenger *m, uint8_t *data) { Node_format relays[NUM_SAVED_TCP_RELAYS]; uint8_t *temp_data = data; - data = state_write_section_header(temp_data, MESSENGER_STATE_COOKIE_TYPE, 0, MESSENGER_STATE_TYPE_TCP_RELAY); + data = state_write_section_header(temp_data, STATE_COOKIE_TYPE, 0, STATE_TYPE_TCP_RELAY); uint32_t num = copy_connected_tcp_relays(m->net_crypto, relays, NUM_SAVED_TCP_RELAYS); if (m->num_loaded_relays > 0) { @@ -3205,7 +3189,7 @@ static uint8_t *save_tcp_relays(const Messenger *m, uint8_t *data) if (l > 0) { const uint32_t len = l; - data = state_write_section_header(temp_data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_TCP_RELAY); + data = state_write_section_header(temp_data, STATE_COOKIE_TYPE, len, STATE_TYPE_TCP_RELAY); data += len; } @@ -3232,14 +3216,14 @@ static uint8_t *save_path_nodes(const Messenger *m, uint8_t *data) { Node_format nodes[NUM_SAVED_PATH_NODES]; uint8_t *temp_data = data; - data = state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, 0, MESSENGER_STATE_TYPE_PATH_NODE); + data = state_write_section_header(data, STATE_COOKIE_TYPE, 0, STATE_TYPE_PATH_NODE); memset(nodes, 0, sizeof(nodes)); const unsigned int num = onion_backup_nodes(m->onion_c, nodes, NUM_SAVED_PATH_NODES); const int l = pack_nodes(data, NUM_SAVED_PATH_NODES * packed_node_size(net_family_tcp_ipv6), nodes, num); if (l > 0) { const uint32_t len = l; - data = state_write_section_header(temp_data, MESSENGER_STATE_COOKIE_TYPE, len, MESSENGER_STATE_TYPE_PATH_NODE); + data = state_write_section_header(temp_data, STATE_COOKIE_TYPE, len, STATE_TYPE_PATH_NODE); data += len; } @@ -3261,77 +3245,32 @@ static State_Load_Status load_path_nodes(Messenger *m, const uint8_t *data, uint return STATE_LOAD_STATUS_CONTINUE; } -// end state plugin -static uint32_t end_size(const Messenger *m) -{ - return 0; -} - -static uint8_t *save_end(const Messenger *m, uint8_t *data) -{ - return state_write_section_header(data, MESSENGER_STATE_COOKIE_TYPE, 0, MESSENGER_STATE_TYPE_END); -} - -static State_Load_Status load_end(Messenger *m, const uint8_t *data, uint32_t length) -{ - if (length != 0) { - return STATE_LOAD_STATUS_ERROR; - } - - return STATE_LOAD_STATUS_END; -} - static void m_register_default_plugins(Messenger *m) { - m_register_state_plugin(m, MESSENGER_STATE_TYPE_NOSPAMKEYS, nospam_keys_size, load_nospam_keys, save_nospam_keys); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_DHT, m_dht_size, m_dht_load, save_dht); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_FRIENDS, saved_friendslist_size, friends_list_load, friends_list_save); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_NAME, name_size, load_name, save_name); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_STATUSMESSAGE, status_message_size, load_status_message, + m_register_state_plugin(m, STATE_TYPE_NOSPAMKEYS, nospam_keys_size, load_nospam_keys, save_nospam_keys); + m_register_state_plugin(m, STATE_TYPE_DHT, m_dht_size, m_dht_load, save_dht); + m_register_state_plugin(m, STATE_TYPE_FRIENDS, saved_friendslist_size, friends_list_load, friends_list_save); + m_register_state_plugin(m, STATE_TYPE_NAME, name_size, load_name, save_name); + m_register_state_plugin(m, STATE_TYPE_STATUSMESSAGE, status_message_size, load_status_message, save_status_message); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_STATUS, status_size, load_status, save_status); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_TCP_RELAY, tcp_relay_size, load_tcp_relays, save_tcp_relays); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_PATH_NODE, path_node_size, load_path_nodes, save_path_nodes); - m_register_state_plugin(m, MESSENGER_STATE_TYPE_END, end_size, load_end, save_end); + m_register_state_plugin(m, STATE_TYPE_STATUS, status_size, load_status, save_status); + m_register_state_plugin(m, STATE_TYPE_TCP_RELAY, tcp_relay_size, load_tcp_relays, save_tcp_relays); + m_register_state_plugin(m, STATE_TYPE_PATH_NODE, path_node_size, load_path_nodes, save_path_nodes); } -static State_Load_Status messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type) +bool messenger_load_state_section(Messenger *m, const uint8_t *data, uint32_t length, uint16_t type, + State_Load_Status *status) { - Messenger *m = (Messenger *)outer; - for (uint8_t i = 0; i < m->options.state_plugins_length; ++i) { const Messenger_State_Plugin *const plugin = &m->options.state_plugins[i]; if (plugin->type == type) { - return plugin->load(m, data, length); + *status = plugin->load(m, data, length); + return true; } } - LOGGER_ERROR(m->log, "Load state: contains unrecognized part (len %u, type %u)\n", - length, type); - - return STATE_LOAD_STATUS_CONTINUE; -} - -/* Load the messenger from data of size length. */ -int messenger_load(Messenger *m, const uint8_t *data, uint32_t length) -{ - uint32_t data32[2]; - uint32_t cookie_len = sizeof(data32); - - if (length < cookie_len) { - return -1; - } - - memcpy(data32, data, sizeof(uint32_t)); - lendian_to_host32(data32 + 1, data + sizeof(uint32_t)); - - if (!data32[0] && (data32[1] == MESSENGER_STATE_COOKIE_GLOBAL)) { - return state_load(m->log, messenger_load_state_callback, m, data + cookie_len, - length - cookie_len, MESSENGER_STATE_COOKIE_TYPE); - } - - return -1; + return false; } /* Return the number of friends in the instance m. diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h index 0d80bd0d..1651315e 100644 --- a/toxcore/Messenger.h +++ b/toxcore/Messenger.h @@ -62,20 +62,8 @@ typedef uint8_t *m_state_save_cb(const Messenger *m, uint8_t *data); // Returns if there were any erros during loading typedef State_Load_Status m_state_load_cb(Messenger *m, const uint8_t *data, uint32_t length); -typedef enum Messenger_State_Type { - MESSENGER_STATE_TYPE_NOSPAMKEYS = 1, - MESSENGER_STATE_TYPE_DHT = 2, - MESSENGER_STATE_TYPE_FRIENDS = 3, - MESSENGER_STATE_TYPE_NAME = 4, - MESSENGER_STATE_TYPE_STATUSMESSAGE = 5, - MESSENGER_STATE_TYPE_STATUS = 6, - MESSENGER_STATE_TYPE_TCP_RELAY = 10, - MESSENGER_STATE_TYPE_PATH_NODE = 11, - MESSENGER_STATE_TYPE_END = 255, -} Messenger_State_Type; - typedef struct Messenger_State_Plugin { - Messenger_State_Type type; + State_Type type; m_state_size_cb *size; m_state_save_cb *save; m_state_load_cb *load; @@ -797,17 +785,22 @@ uint32_t messenger_run_interval(const Messenger *m); * returns true on success * returns false on error */ -bool m_register_state_plugin(Messenger *m, Messenger_State_Type type, m_state_size_cb size_callback, +bool m_register_state_plugin(Messenger *m, State_Type type, m_state_size_cb size_callback, m_state_load_cb load_callback, m_state_save_cb save_callback); /* return size of the messenger data (for saving). */ uint32_t messenger_size(const Messenger *m); -/* Save the messenger in data (must be allocated memory of size Messenger_size()) */ -void messenger_save(const Messenger *m, uint8_t *data); +/* Save the messenger in data (must be allocated memory of size at least Messenger_size()) */ +uint8_t *messenger_save(const Messenger *m, uint8_t *data); -/* Load the messenger from data of size length. */ -int messenger_load(Messenger *m, const uint8_t *data, uint32_t length); +/* Load a state section. + * + * @param status Result of loading section is stored here if the section is handled. + * @return true iff section handled. + */ +bool messenger_load_state_section(Messenger *m, const uint8_t *data, uint32_t length, uint16_t type, + State_Load_Status *status); /* Return the number of friends in the instance m. * You should use this to determine how much memory to allocate diff --git a/toxcore/group.c b/toxcore/group.c index 5feb483b..ee9548a1 100644 --- a/toxcore/group.c +++ b/toxcore/group.c @@ -2875,6 +2875,22 @@ void send_name_all_groups(Group_Chats *g_c) } } +uint32_t conferences_size(const Group_Chats *g_c) +{ + return 0; +} + +uint8_t *conferences_save(const Group_Chats *g_c, uint8_t *data) +{ + return data; +} + +bool conferences_load_state_section(Group_Chats *g_c, const uint8_t *data, uint32_t length, uint16_t type, + State_Load_Status *status) +{ + return false; +} + /* Create new groupchat instance. */ Group_Chats *new_groupchats(Mono_Time *mono_time, Messenger *m) { diff --git a/toxcore/group.h b/toxcore/group.h index 7acd4637..8673abdb 100644 --- a/toxcore/group.h +++ b/toxcore/group.h @@ -448,6 +448,21 @@ int callback_groupchat_peer_delete(Group_Chats *g_c, uint32_t groupnumber, peer_ */ int callback_groupchat_delete(Group_Chats *g_c, uint32_t groupnumber, group_on_delete_cb *function); +/* Return size of the conferences data (for saving). */ +uint32_t conferences_size(const Group_Chats *g_c); + +/* Save the conferences in data (must be allocated memory of size at least conferences_size()) */ +uint8_t *conferences_save(const Group_Chats *g_c, uint8_t *data); + +/** + * Load a section. + * + * @param status Result of loading section is stored here if the section is handled. + * @return true iff section handled. + */ +bool conferences_load_state_section(Group_Chats *g_c, const uint8_t *data, uint32_t length, uint16_t type, + State_Load_Status *status); + /* Create new groupchat instance. */ Group_Chats *new_groupchats(Mono_Time *mono_time, Messenger *m); diff --git a/toxcore/state.c b/toxcore/state.c index 29b4af88..919c2e8c 100644 --- a/toxcore/state.c +++ b/toxcore/state.c @@ -16,10 +16,10 @@ int state_load(const Logger *log, state_load_cb *state_load_callback, void *oute while (length >= size_head) { uint32_t length_sub; - lendian_to_host32(&length_sub, data); + lendian_bytes_to_host32(&length_sub, data); uint32_t cookie_type; - lendian_to_host32(&cookie_type, data + sizeof(uint32_t)); + lendian_bytes_to_host32(&cookie_type, data + sizeof(uint32_t)); data += size_head; length -= size_head; @@ -63,9 +63,9 @@ int state_load(const Logger *log, state_load_cb *state_load_callback, void *oute uint8_t *state_write_section_header(uint8_t *data, uint16_t cookie_type, uint32_t len, uint32_t section_type) { - host_to_lendian32(data, len); + host_to_lendian_bytes32(data, len); data += sizeof(uint32_t); - host_to_lendian32(data, (host_tolendian16(cookie_type) << 16) | host_tolendian16(section_type)); + host_to_lendian_bytes32(data, (host_to_lendian16(cookie_type) << 16) | host_to_lendian16(section_type)); data += sizeof(uint32_t); return data; } @@ -79,12 +79,12 @@ uint16_t lendian_to_host16(uint16_t lendian) #endif } -uint16_t host_tolendian16(uint16_t host) +uint16_t host_to_lendian16(uint16_t host) { return lendian_to_host16(host); } -void host_to_lendian32(uint8_t *dest, uint32_t num) +void host_to_lendian_bytes32(uint8_t *dest, uint32_t num) { #ifdef WORDS_BIGENDIAN num = ((num << 8) & 0xFF00FF00) | ((num >> 8) & 0xFF00FF); @@ -93,7 +93,7 @@ void host_to_lendian32(uint8_t *dest, uint32_t num) memcpy(dest, &num, sizeof(uint32_t)); } -void lendian_to_host32(uint32_t *dest, const uint8_t *lendian) +void lendian_bytes_to_host32(uint32_t *dest, const uint8_t *lendian) { uint32_t d; memcpy(&d, lendian, sizeof(uint32_t)); @@ -103,3 +103,21 @@ void lendian_to_host32(uint32_t *dest, const uint8_t *lendian) #endif *dest = d; } + +void host_to_lendian_bytes16(uint8_t *dest, uint16_t num) +{ +#ifdef WORDS_BIGENDIAN + num = (num << 8) | (num >> 8); +#endif + memcpy(dest, &num, sizeof(uint16_t)); +} + +void lendian_bytes_to_host16(uint16_t *dest, const uint8_t *lendian) +{ + uint16_t d; + memcpy(&d, lendian, sizeof(uint16_t)); +#ifdef WORDS_BIGENDIAN + d = (d << 8) | (d >> 8); +#endif + *dest = d; +} diff --git a/toxcore/state.h b/toxcore/state.h index 2d1f62c3..872b1e9d 100644 --- a/toxcore/state.h +++ b/toxcore/state.h @@ -18,6 +18,22 @@ extern "C" { #endif +#define STATE_COOKIE_GLOBAL 0x15ed1b1f + +#define STATE_COOKIE_TYPE 0x01ce + +typedef enum State_Type { + STATE_TYPE_NOSPAMKEYS = 1, + STATE_TYPE_DHT = 2, + STATE_TYPE_FRIENDS = 3, + STATE_TYPE_NAME = 4, + STATE_TYPE_STATUSMESSAGE = 5, + STATE_TYPE_STATUS = 6, + STATE_TYPE_TCP_RELAY = 10, + STATE_TYPE_PATH_NODE = 11, + STATE_TYPE_END = 255, +} State_Type; + // Returned by the state_load_cb to instruct the loader on what to do next. typedef enum State_Load_Status { // Continue loading state data sections. @@ -39,10 +55,13 @@ uint8_t *state_write_section_header(uint8_t *data, uint16_t cookie_type, uint32_ // Utilities for state data serialisation. uint16_t lendian_to_host16(uint16_t lendian); -uint16_t host_tolendian16(uint16_t host); +uint16_t host_to_lendian16(uint16_t host); -void host_to_lendian32(uint8_t *dest, uint32_t num); -void lendian_to_host32(uint32_t *dest, const uint8_t *lendian); +void host_to_lendian_bytes32(uint8_t *dest, uint32_t num); +void lendian_bytes_to_host32(uint32_t *dest, const uint8_t *lendian); + +void host_to_lendian_bytes16(uint8_t *dest, uint16_t num); +void lendian_bytes_to_host16(uint16_t *dest, const uint8_t *lendian); #ifdef __cplusplus } // extern "C" diff --git a/toxcore/tox.c b/toxcore/tox.c index e679a168..629cc1c5 100644 --- a/toxcore/tox.c +++ b/toxcore/tox.c @@ -328,6 +328,51 @@ bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch) return TOX_VERSION_IS_API_COMPATIBLE(major, minor, patch); } +static State_Load_Status state_load_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type) +{ + Tox *tox = (Tox *)outer; + State_Load_Status status = STATE_LOAD_STATUS_CONTINUE; + + if (messenger_load_state_section(tox->m, data, length, type, &status) + || conferences_load_state_section(tox->m->conferences_object, data, length, type, &status)) { + return status; + } + + if (type == STATE_TYPE_END) { + if (length != 0) { + return STATE_LOAD_STATUS_ERROR; + } + + return STATE_LOAD_STATUS_END; + } + + LOGGER_ERROR(tox->m->log, "Load state: contains unrecognized part (len %u, type %u)\n", + length, type); + + return STATE_LOAD_STATUS_CONTINUE; +} + +/* Load tox from data of size length. */ +static int tox_load(Tox *tox, const uint8_t *data, uint32_t length) +{ + uint32_t data32[2]; + uint32_t cookie_len = sizeof(data32); + + if (length < cookie_len) { + return -1; + } + + memcpy(data32, data, sizeof(uint32_t)); + lendian_bytes_to_host32(data32 + 1, data + sizeof(uint32_t)); + + if (data32[0] != 0 || data32[1] != STATE_COOKIE_GLOBAL) { + return -1; + } + + return state_load(tox->m->log, state_load_callback, tox, data + cookie_len, + length - cookie_len, STATE_COOKIE_TYPE); +} + Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error) { @@ -488,7 +533,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error) } if (load_savedata_tox - && messenger_load(m, tox_options_get_savedata_data(opts), tox_options_get_savedata_length(opts)) == -1) { + && tox_load(tox, tox_options_get_savedata_data(opts), tox_options_get_savedata_length(opts)) == -1) { SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT); } else if (load_savedata_sk) { load_secret_key(m->net_crypto, tox_options_get_savedata_data(opts)); @@ -537,18 +582,45 @@ void tox_kill(Tox *tox) free(tox); } +static uint32_t end_size(void) +{ + return 2 * sizeof(uint32_t); +} + +static void end_save(uint8_t *data) +{ + state_write_section_header(data, STATE_COOKIE_TYPE, 0, STATE_TYPE_END); +} + size_t tox_get_savedata_size(const Tox *tox) { const Messenger *m = tox->m; - return messenger_size(m); + return 2 * sizeof(uint32_t) + + messenger_size(m) + + conferences_size(m->conferences_object) + + end_size(); } void tox_get_savedata(const Tox *tox, uint8_t *savedata) { - if (savedata) { - const Messenger *m = tox->m; - messenger_save(m, savedata); + if (savedata == nullptr) { + return; } + + memset(savedata, 0, tox_get_savedata_size(tox)); + + const uint32_t size32 = sizeof(uint32_t); + + // write cookie + memset(savedata, 0, size32); + savedata += size32; + host_to_lendian_bytes32(savedata, STATE_COOKIE_GLOBAL); + savedata += size32; + + const Messenger *m = tox->m; + savedata = messenger_save(m, savedata); + savedata = conferences_save(m->conferences_object, savedata); + end_save(savedata); } bool tox_bootstrap(Tox *tox, const char *host, uint16_t port, const uint8_t *public_key, Tox_Err_Bootstrap *error)