diff options
author | irungentoo <irungentoo@gmail.com> | 2015-02-24 20:29:01 -0500 |
---|---|---|
committer | irungentoo <irungentoo@gmail.com> | 2015-02-24 20:29:01 -0500 |
commit | d83efd35dd342da7f5b0f4b6e11ffd943d7f3c63 (patch) | |
tree | 4fa5e862c65c9bb9a007dab78424c161ddd61341 /testing | |
parent | 8fa8e9dcd798540bf539d502d0dbba71184f7489 (diff) |
Ported some of the code in testing/ to the new api.
Diffstat (limited to 'testing')
-rw-r--r-- | testing/Makefile.inc | 15 | ||||
-rw-r--r-- | testing/Messenger_test.c | 12 | ||||
-rw-r--r-- | testing/dns3_test.c | 4 | ||||
-rw-r--r-- | testing/irc_syncbot.c | 16 | ||||
-rw-r--r-- | testing/nTox.c | 133 | ||||
-rw-r--r-- | testing/test_avatars.c | 755 | ||||
-rw-r--r-- | testing/tox_shell.c | 32 | ||||
-rw-r--r-- | testing/tox_sync.c | 28 |
8 files changed, 116 insertions, 879 deletions
diff --git a/testing/Makefile.inc b/testing/Makefile.inc index 8b93c8ac..fda99a89 100644 --- a/testing/Makefile.inc +++ b/testing/Makefile.inc | |||
@@ -106,21 +106,6 @@ tox_shell_LDADD = $(LIBSODIUM_LDFLAGS) \ | |||
106 | -lutil | 106 | -lutil |
107 | 107 | ||
108 | 108 | ||
109 | noinst_PROGRAMS += test_avatars | ||
110 | |||
111 | test_avatars_SOURCES = ../testing/test_avatars.c | ||
112 | |||
113 | test_avatars_CFLAGS = $(LIBSODIUM_CFLAGS) \ | ||
114 | $(NACL_CFLAGS) | ||
115 | |||
116 | test_avatars_LDADD = $(LIBSODIUM_LDFLAGS) \ | ||
117 | $(NACL_LDFLAGS) \ | ||
118 | libtoxcore.la \ | ||
119 | $(LIBSODIUM_LIBS) \ | ||
120 | $(NACL_OBJECTS) \ | ||
121 | $(NACL_LIBS) | ||
122 | |||
123 | |||
124 | noinst_PROGRAMS += irc_syncbot | 109 | noinst_PROGRAMS += irc_syncbot |
125 | 110 | ||
126 | irc_syncbot_SOURCES = ../testing/irc_syncbot.c | 111 | irc_syncbot_SOURCES = ../testing/irc_syncbot.c |
diff --git a/testing/Messenger_test.c b/testing/Messenger_test.c index 42cadf73..27216107 100644 --- a/testing/Messenger_test.c +++ b/testing/Messenger_test.c | |||
@@ -56,17 +56,17 @@ | |||
56 | 56 | ||
57 | #endif | 57 | #endif |
58 | 58 | ||
59 | void print_message(Messenger *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata) | 59 | void print_message(Messenger *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata) |
60 | { | 60 | { |
61 | printf("Message with length %u received from %u: %s \n", length, friendnumber, string); | 61 | printf("Message with length %lu received from %u: %s \n", length, friendnumber, string); |
62 | m_sendmessage(m, friendnumber, (uint8_t *)"Test1", 6); | 62 | m_sendmessage(m, friendnumber, (uint8_t *)"Test1", 6, 0); |
63 | } | 63 | } |
64 | 64 | ||
65 | /* FIXME needed as print_request has to match the interface expected by | 65 | /* FIXME needed as print_request has to match the interface expected by |
66 | * networking_requesthandler and so cannot take a Messenger * */ | 66 | * networking_requesthandler and so cannot take a Messenger * */ |
67 | static Messenger *m; | 67 | static Messenger *m; |
68 | 68 | ||
69 | void print_request(Messenger *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata) | 69 | void print_request(Messenger *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) |
70 | { | 70 | { |
71 | printf("Friend request received from: \n"); | 71 | printf("Friend request received from: \n"); |
72 | printf("ClientID: "); | 72 | printf("ClientID: "); |
@@ -79,7 +79,7 @@ void print_request(Messenger *m, const uint8_t *public_key, const uint8_t *data, | |||
79 | printf("%hhX", public_key[j]); | 79 | printf("%hhX", public_key[j]); |
80 | } | 80 | } |
81 | 81 | ||
82 | printf("\nOf length: %u with data: %s \n", length, data); | 82 | printf("\nOf length: %lu with data: %s \n", length, data); |
83 | 83 | ||
84 | if (length != sizeof("Install Gentoo")) { | 84 | if (length != sizeof("Install Gentoo")) { |
85 | return; | 85 | return; |
@@ -184,7 +184,7 @@ int main(int argc, char *argv[]) | |||
184 | getname(m, num, name); | 184 | getname(m, num, name); |
185 | printf("%s\n", name); | 185 | printf("%s\n", name); |
186 | 186 | ||
187 | m_sendmessage(m, num, (uint8_t *)"Test", 5); | 187 | m_sendmessage(m, num, (uint8_t *)"Test", 5, 0); |
188 | do_messenger(m); | 188 | do_messenger(m); |
189 | c_sleep(30); | 189 | c_sleep(30); |
190 | FILE *file = fopen("Save.bak", "wb"); | 190 | FILE *file = fopen("Save.bak", "wb"); |
diff --git a/testing/dns3_test.c b/testing/dns3_test.c index 7052aae7..1f6c6a12 100644 --- a/testing/dns3_test.c +++ b/testing/dns3_test.c | |||
@@ -98,7 +98,7 @@ int main(int argc, char *argv[]) | |||
98 | 98 | ||
99 | for (i = r_len - 1; i != 0 && buffer[i] != '='; --i); | 99 | for (i = r_len - 1; i != 0 && buffer[i] != '='; --i); |
100 | 100 | ||
101 | uint8_t tox_id[TOX_FRIEND_ADDRESS_SIZE]; | 101 | uint8_t tox_id[TOX_ADDRESS_SIZE]; |
102 | 102 | ||
103 | if (tox_decrypt_dns3_TXT(d, tox_id, buffer + i + 1, r_len - (i + 1), request_id) != 0) | 103 | if (tox_decrypt_dns3_TXT(d, tox_id, buffer + i + 1, r_len - (i + 1), request_id) != 0) |
104 | return -1; | 104 | return -1; |
@@ -106,7 +106,7 @@ int main(int argc, char *argv[]) | |||
106 | printf("The Tox id for username %s is:\n", argv[3]); | 106 | printf("The Tox id for username %s is:\n", argv[3]); |
107 | 107 | ||
108 | //unsigned int i; | 108 | //unsigned int i; |
109 | for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; ++i) { | 109 | for (i = 0; i < TOX_ADDRESS_SIZE; ++i) { |
110 | printf("%02hhX", tox_id[i]); | 110 | printf("%02hhX", tox_id[i]); |
111 | } | 111 | } |
112 | 112 | ||
diff --git a/testing/irc_syncbot.c b/testing/irc_syncbot.c index f7486115..df9e964c 100644 --- a/testing/irc_syncbot.c +++ b/testing/irc_syncbot.c | |||
@@ -89,7 +89,7 @@ static void callback_group_invite(Tox *tox, int fid, uint8_t type, const uint8_t | |||
89 | current_group = tox_join_groupchat(tox, fid, data, length); | 89 | current_group = tox_join_groupchat(tox, fid, data, length); |
90 | } | 90 | } |
91 | 91 | ||
92 | void callback_friend_message(Tox *tox, int fid, const uint8_t *message, uint16_t length, void *userdata) | 92 | void callback_friend_message(Tox *tox, uint32_t fid, const uint8_t *message, size_t length, void *userdata) |
93 | { | 93 | { |
94 | if (length == 1 && *message == 'c') { | 94 | if (length == 1 && *message == 'c') { |
95 | if (tox_del_groupchat(tox, current_group) == 0) | 95 | if (tox_del_groupchat(tox, current_group) == 0) |
@@ -203,7 +203,7 @@ void send_irc_group(Tox *tox, uint8_t *msg, uint16_t len) | |||
203 | 203 | ||
204 | Tox *init_tox(int argc, char *argv[]) | 204 | Tox *init_tox(int argc, char *argv[]) |
205 | { | 205 | { |
206 | uint8_t ipv6enabled = TOX_ENABLE_IPV6_DEFAULT; /* x */ | 206 | uint8_t ipv6enabled = 1; /* x */ |
207 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); | 207 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); |
208 | 208 | ||
209 | if (argvoffset < 0) | 209 | if (argvoffset < 0) |
@@ -215,12 +215,12 @@ Tox *init_tox(int argc, char *argv[]) | |||
215 | exit(0); | 215 | exit(0); |
216 | } | 216 | } |
217 | 217 | ||
218 | Tox *tox = tox_new(0); | 218 | Tox *tox = tox_new(0, 0, 0, 0); |
219 | 219 | ||
220 | if (!tox) | 220 | if (!tox) |
221 | exit(1); | 221 | exit(1); |
222 | 222 | ||
223 | tox_set_name(tox, (uint8_t *)IRC_NAME, sizeof(IRC_NAME) - 1); | 223 | tox_self_set_name(tox, (uint8_t *)IRC_NAME, sizeof(IRC_NAME) - 1, 0); |
224 | tox_callback_friend_message(tox, &callback_friend_message, 0); | 224 | tox_callback_friend_message(tox, &callback_friend_message, 0); |
225 | tox_callback_group_invite(tox, &callback_group_invite, 0); | 225 | tox_callback_group_invite(tox, &callback_group_invite, 0); |
226 | tox_callback_group_message(tox, ©_groupmessage, 0); | 226 | tox_callback_group_message(tox, ©_groupmessage, 0); |
@@ -228,7 +228,7 @@ Tox *init_tox(int argc, char *argv[]) | |||
228 | 228 | ||
229 | uint16_t port = atoi(argv[argvoffset + 2]); | 229 | uint16_t port = atoi(argv[argvoffset + 2]); |
230 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); | 230 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); |
231 | int res = tox_bootstrap_from_address(tox, argv[argvoffset + 1], port, binary_string); | 231 | tox_bootstrap(tox, argv[argvoffset + 1], port, binary_string, 0); |
232 | free(binary_string); | 232 | free(binary_string); |
233 | 233 | ||
234 | char temp_id[128]; | 234 | char temp_id[128]; |
@@ -239,10 +239,10 @@ Tox *init_tox(int argc, char *argv[]) | |||
239 | } | 239 | } |
240 | 240 | ||
241 | uint8_t *bin_id = hex_string_to_bin(temp_id); | 241 | uint8_t *bin_id = hex_string_to_bin(temp_id); |
242 | int num = tox_add_friend(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo") - 1); | 242 | uint32_t num = tox_friend_add(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo") - 1, 0); |
243 | free(bin_id); | 243 | free(bin_id); |
244 | 244 | ||
245 | if (num < 0) { | 245 | if (num == UINT32_MAX) { |
246 | printf("\nSomething went wrong when adding friend.\n"); | 246 | printf("\nSomething went wrong when adding friend.\n"); |
247 | exit(1); | 247 | exit(1); |
248 | } | 248 | } |
@@ -342,7 +342,7 @@ int main(int argc, char *argv[]) | |||
342 | } | 342 | } |
343 | } | 343 | } |
344 | 344 | ||
345 | tox_do(tox); | 345 | tox_iteration(tox); |
346 | usleep(1000 * 50); | 346 | usleep(1000 * 50); |
347 | } | 347 | } |
348 | 348 | ||
diff --git a/testing/nTox.c b/testing/nTox.c index 329191d7..ff419c9a 100644 --- a/testing/nTox.c +++ b/testing/nTox.c | |||
@@ -105,7 +105,7 @@ int x, y; | |||
105 | int conversation_default = 0; | 105 | int conversation_default = 0; |
106 | 106 | ||
107 | typedef struct { | 107 | typedef struct { |
108 | uint8_t id[TOX_CLIENT_ID_SIZE]; | 108 | uint8_t id[TOX_PUBLIC_KEY_SIZE]; |
109 | uint8_t accepted; | 109 | uint8_t accepted; |
110 | } Friend_request; | 110 | } Friend_request; |
111 | 111 | ||
@@ -179,19 +179,19 @@ int add_filesender(Tox *m, uint16_t friendnum, char *filename) | |||
179 | 179 | ||
180 | 180 | ||
181 | #define FRADDR_TOSTR_CHUNK_LEN 8 | 181 | #define FRADDR_TOSTR_CHUNK_LEN 8 |
182 | #define FRADDR_TOSTR_BUFSIZE (TOX_FRIEND_ADDRESS_SIZE * 2 + TOX_FRIEND_ADDRESS_SIZE / FRADDR_TOSTR_CHUNK_LEN + 1) | 182 | #define FRADDR_TOSTR_BUFSIZE (TOX_ADDRESS_SIZE * 2 + TOX_ADDRESS_SIZE / FRADDR_TOSTR_CHUNK_LEN + 1) |
183 | 183 | ||
184 | static void fraddr_to_str(uint8_t *id_bin, char *id_str) | 184 | static void fraddr_to_str(uint8_t *id_bin, char *id_str) |
185 | { | 185 | { |
186 | uint32_t i, delta = 0, pos_extra, sum_extra = 0; | 186 | uint32_t i, delta = 0, pos_extra, sum_extra = 0; |
187 | 187 | ||
188 | for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) { | 188 | for (i = 0; i < TOX_ADDRESS_SIZE; i++) { |
189 | sprintf(&id_str[2 * i + delta], "%02hhX", id_bin[i]); | 189 | sprintf(&id_str[2 * i + delta], "%02hhX", id_bin[i]); |
190 | 190 | ||
191 | if ((i + 1) == TOX_CLIENT_ID_SIZE) | 191 | if ((i + 1) == TOX_PUBLIC_KEY_SIZE) |
192 | pos_extra = 2 * (i + 1) + delta; | 192 | pos_extra = 2 * (i + 1) + delta; |
193 | 193 | ||
194 | if (i >= TOX_CLIENT_ID_SIZE) | 194 | if (i >= TOX_PUBLIC_KEY_SIZE) |
195 | sum_extra |= id_bin[i]; | 195 | sum_extra |= id_bin[i]; |
196 | 196 | ||
197 | if (!((i + 1) % FRADDR_TOSTR_CHUNK_LEN)) { | 197 | if (!((i + 1) % FRADDR_TOSTR_CHUNK_LEN)) { |
@@ -210,14 +210,15 @@ void get_id(Tox *m, char *data) | |||
210 | { | 210 | { |
211 | sprintf(data, "[i] ID: "); | 211 | sprintf(data, "[i] ID: "); |
212 | int offset = strlen(data); | 212 | int offset = strlen(data); |
213 | uint8_t address[TOX_FRIEND_ADDRESS_SIZE]; | 213 | uint8_t address[TOX_ADDRESS_SIZE]; |
214 | tox_get_address(m, address); | 214 | tox_self_get_address(m, address); |
215 | fraddr_to_str(address, data + offset); | 215 | fraddr_to_str(address, data + offset); |
216 | } | 216 | } |
217 | 217 | ||
218 | int getfriendname_terminated(Tox *m, int friendnum, char *namebuf) | 218 | int getfriendname_terminated(Tox *m, int friendnum, char *namebuf) |
219 | { | 219 | { |
220 | int res = tox_get_name(m, friendnum, (uint8_t *)namebuf); | 220 | tox_friend_get_name(m, friendnum, (uint8_t *)namebuf, NULL); |
221 | int res = tox_friend_get_name_size(m, friendnum, NULL); | ||
221 | 222 | ||
222 | if (res >= 0) | 223 | if (res >= 0) |
223 | namebuf[res] = 0; | 224 | namebuf[res] = 0; |
@@ -249,13 +250,13 @@ void new_lines(char *line) | |||
249 | 250 | ||
250 | 251 | ||
251 | const char ptrn_friend[] = "[i] Friend %i: %s\n+ id: %s"; | 252 | const char ptrn_friend[] = "[i] Friend %i: %s\n+ id: %s"; |
252 | const int id_str_len = TOX_FRIEND_ADDRESS_SIZE * 2 + 3; | 253 | const int id_str_len = TOX_ADDRESS_SIZE * 2 + 3; |
253 | void print_friendlist(Tox *m) | 254 | void print_friendlist(Tox *m) |
254 | { | 255 | { |
255 | new_lines("[i] Friend List:"); | 256 | new_lines("[i] Friend List:"); |
256 | 257 | ||
257 | char name[TOX_MAX_NAME_LENGTH + 1]; | 258 | char name[TOX_MAX_NAME_LENGTH + 1]; |
258 | uint8_t fraddr_bin[TOX_FRIEND_ADDRESS_SIZE]; | 259 | uint8_t fraddr_bin[TOX_ADDRESS_SIZE]; |
259 | char fraddr_str[FRADDR_TOSTR_BUFSIZE]; | 260 | char fraddr_str[FRADDR_TOSTR_BUFSIZE]; |
260 | 261 | ||
261 | /* account for the longest name and the longest "base" string and number (int) and id_str */ | 262 | /* account for the longest name and the longest "base" string and number (int) and id_str */ |
@@ -264,7 +265,7 @@ void print_friendlist(Tox *m) | |||
264 | uint32_t i = 0; | 265 | uint32_t i = 0; |
265 | 266 | ||
266 | while (getfriendname_terminated(m, i, name) != -1) { | 267 | while (getfriendname_terminated(m, i, name) != -1) { |
267 | if (!tox_get_client_id(m, i, fraddr_bin)) | 268 | if (tox_friend_get_public_key(m, i, fraddr_bin, NULL)) |
268 | fraddr_to_str(fraddr_bin, fraddr_str); | 269 | fraddr_to_str(fraddr_bin, fraddr_str); |
269 | else | 270 | else |
270 | sprintf(fraddr_str, "???"); | 271 | sprintf(fraddr_str, "???"); |
@@ -347,50 +348,59 @@ void line_eval(Tox *m, char *line) | |||
347 | } | 348 | } |
348 | 349 | ||
349 | unsigned char *bin_string = hex_string_to_bin(temp_id); | 350 | unsigned char *bin_string = hex_string_to_bin(temp_id); |
350 | int num = tox_add_friend(m, bin_string, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo")); | 351 | TOX_ERR_FRIEND_ADD error; |
352 | uint32_t num = tox_friend_add(m, bin_string, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo"), &error); | ||
351 | free(bin_string); | 353 | free(bin_string); |
352 | char numstring[100]; | 354 | char numstring[100]; |
353 | 355 | ||
354 | switch (num) { | 356 | switch (error) { |
355 | case TOX_FAERR_TOOLONG: | 357 | case TOX_ERR_FRIEND_ADD_TOO_LONG: |
356 | sprintf(numstring, "[i] Message is too long."); | 358 | sprintf(numstring, "[i] Message is too long."); |
357 | break; | 359 | break; |
358 | 360 | ||
359 | case TOX_FAERR_NOMESSAGE: | 361 | case TOX_ERR_FRIEND_ADD_NO_MESSAGE: |
360 | sprintf(numstring, "[i] Please add a message to your request."); | 362 | sprintf(numstring, "[i] Please add a message to your request."); |
361 | break; | 363 | break; |
362 | 364 | ||
363 | case TOX_FAERR_OWNKEY: | 365 | case TOX_ERR_FRIEND_ADD_OWN_KEY: |
364 | sprintf(numstring, "[i] That appears to be your own ID."); | 366 | sprintf(numstring, "[i] That appears to be your own ID."); |
365 | break; | 367 | break; |
366 | 368 | ||
367 | case TOX_FAERR_ALREADYSENT: | 369 | case TOX_ERR_FRIEND_ADD_ALREADY_SENT: |
368 | sprintf(numstring, "[i] Friend request already sent."); | 370 | sprintf(numstring, "[i] Friend request already sent."); |
369 | break; | 371 | break; |
370 | 372 | ||
371 | case TOX_FAERR_UNKNOWN: | 373 | case TOX_ERR_FRIEND_ADD_BAD_CHECKSUM: |
372 | sprintf(numstring, "[i] Undefined error when adding friend."); | 374 | sprintf(numstring, "[i] Address has a bad checksum."); |
373 | break; | 375 | break; |
374 | 376 | ||
375 | default: | 377 | case TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM: |
376 | if (num >= 0) { | 378 | sprintf(numstring, "[i] New nospam set."); |
377 | sprintf(numstring, "[i] Added friend as %d.", num); | 379 | break; |
378 | save_data(m); | 380 | |
379 | } else | 381 | case TOX_ERR_FRIEND_ADD_MALLOC: |
380 | sprintf(numstring, "[i] Unknown error %i.", num); | 382 | sprintf(numstring, "[i] malloc error."); |
383 | break; | ||
381 | 384 | ||
385 | case TOX_ERR_FRIEND_ADD_NULL: | ||
386 | sprintf(numstring, "[i] message was NULL."); | ||
387 | break; | ||
388 | |||
389 | case TOX_ERR_FRIEND_ADD_OK: | ||
390 | sprintf(numstring, "[i] Added friend as %d.", num); | ||
391 | save_data(m); | ||
382 | break; | 392 | break; |
383 | } | 393 | } |
384 | 394 | ||
385 | new_lines(numstring); | 395 | new_lines(numstring); |
386 | } else if (inpt_command == 'd') { | 396 | } else if (inpt_command == 'd') { |
387 | tox_do(m); | 397 | tox_iteration(m); |
388 | } else if (inpt_command == 'm') { //message command: /m friendnumber messsage | 398 | } else if (inpt_command == 'm') { //message command: /m friendnumber messsage |
389 | char *posi[1]; | 399 | char *posi[1]; |
390 | int num = strtoul(line + prompt_offset, posi, 0); | 400 | int num = strtoul(line + prompt_offset, posi, 0); |
391 | 401 | ||
392 | if (**posi != 0) { | 402 | if (**posi != 0) { |
393 | if (tox_send_message(m, num, (uint8_t *) *posi + 1, strlen(*posi + 1)) < 1) { | 403 | if (tox_send_message(m, num, (uint8_t *) *posi + 1, strlen(*posi + 1), NULL) < 1) { |
394 | char sss[256]; | 404 | char sss[256]; |
395 | sprintf(sss, "[i] could not send message to friend num %u", num); | 405 | sprintf(sss, "[i] could not send message to friend num %u", num); |
396 | new_lines(sss); | 406 | new_lines(sss); |
@@ -410,14 +420,14 @@ void line_eval(Tox *m, char *line) | |||
410 | } | 420 | } |
411 | 421 | ||
412 | name[i - 3] = 0; | 422 | name[i - 3] = 0; |
413 | tox_set_name(m, name, i - 2); | 423 | tox_self_set_name(m, name, i - 2, NULL); |
414 | char numstring[100]; | 424 | char numstring[100]; |
415 | sprintf(numstring, "[i] changed nick to %s", (char *)name); | 425 | sprintf(numstring, "[i] changed nick to %s", (char *)name); |
416 | new_lines(numstring); | 426 | new_lines(numstring); |
417 | } else if (inpt_command == 'l') { | 427 | } else if (inpt_command == 'l') { |
418 | print_friendlist(m); | 428 | print_friendlist(m); |
419 | } else if (inpt_command == 's') { | 429 | } else if (inpt_command == 's') { |
420 | uint8_t status[TOX_MAX_STATUSMESSAGE_LENGTH]; | 430 | uint8_t status[TOX_MAX_STATUS_MESSAGE_LENGTH]; |
421 | size_t i, len = strlen(line); | 431 | size_t i, len = strlen(line); |
422 | 432 | ||
423 | for (i = 3; i < len; i++) { | 433 | for (i = 3; i < len; i++) { |
@@ -427,7 +437,7 @@ void line_eval(Tox *m, char *line) | |||
427 | } | 437 | } |
428 | 438 | ||
429 | status[i - 3] = 0; | 439 | status[i - 3] = 0; |
430 | tox_set_status_message(m, status, strlen((char *)status)); | 440 | tox_self_set_status_message(m, status, strlen((char *)status), NULL); |
431 | char numstring[100]; | 441 | char numstring[100]; |
432 | sprintf(numstring, "[i] changed status to %s", (char *)status); | 442 | sprintf(numstring, "[i] changed status to %s", (char *)status); |
433 | new_lines(numstring); | 443 | new_lines(numstring); |
@@ -439,9 +449,9 @@ void line_eval(Tox *m, char *line) | |||
439 | sprintf(numchar, "[i] you either didn't receive that request or you already accepted it"); | 449 | sprintf(numchar, "[i] you either didn't receive that request or you already accepted it"); |
440 | new_lines(numchar); | 450 | new_lines(numchar); |
441 | } else { | 451 | } else { |
442 | int num = tox_add_friend_norequest(m, pending_requests[numf].id); | 452 | uint32_t num = tox_friend_add_norequest(m, pending_requests[numf].id, NULL); |
443 | 453 | ||
444 | if (num != -1) { | 454 | if (num != UINT32_MAX) { |
445 | pending_requests[numf].accepted = 1; | 455 | pending_requests[numf].accepted = 1; |
446 | sprintf(numchar, "[i] friend request %u accepted as friend no. %d", numf, num); | 456 | sprintf(numchar, "[i] friend request %u accepted as friend no. %d", numf, num); |
447 | new_lines(numchar); | 457 | new_lines(numchar); |
@@ -475,9 +485,9 @@ void line_eval(Tox *m, char *line) | |||
475 | } while ((c != 'y') && (c != 'n') && (c != EOF)); | 485 | } while ((c != 'y') && (c != 'n') && (c != EOF)); |
476 | 486 | ||
477 | if (c == 'y') { | 487 | if (c == 'y') { |
478 | int res = tox_del_friend(m, numf); | 488 | int res = tox_friend_delete(m, numf, NULL); |
479 | 489 | ||
480 | if (res == 0) | 490 | if (res) |
481 | sprintf(msg, "[i] [%i: %s] is no longer your friend", numf, fname); | 491 | sprintf(msg, "[i] [%i: %s] is no longer your friend", numf, fname); |
482 | else | 492 | else |
483 | sprintf(msg, "[i] failed to remove friend"); | 493 | sprintf(msg, "[i] failed to remove friend"); |
@@ -602,7 +612,7 @@ void line_eval(Tox *m, char *line) | |||
602 | if (conversation_default != 0) { | 612 | if (conversation_default != 0) { |
603 | if (conversation_default > 0) { | 613 | if (conversation_default > 0) { |
604 | int friendnumber = conversation_default - 1; | 614 | int friendnumber = conversation_default - 1; |
605 | uint32_t res = tox_send_message(m, friendnumber, (uint8_t *)line, strlen(line)); | 615 | uint32_t res = tox_send_message(m, friendnumber, (uint8_t *)line, strlen(line), NULL); |
606 | 616 | ||
607 | if (res == 0) { | 617 | if (res == 0) { |
608 | char sss[128]; | 618 | char sss[128]; |
@@ -863,20 +873,20 @@ void do_refresh() | |||
863 | refresh(); | 873 | refresh(); |
864 | } | 874 | } |
865 | 875 | ||
866 | void print_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata) | 876 | void print_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) |
867 | { | 877 | { |
868 | new_lines("[i] received friend request with message:"); | 878 | new_lines("[i] received friend request with message:"); |
869 | new_lines((char *)data); | 879 | new_lines((char *)data); |
870 | char numchar[100]; | 880 | char numchar[100]; |
871 | sprintf(numchar, "[i] accept request with /a %u", num_requests); | 881 | sprintf(numchar, "[i] accept request with /a %u", num_requests); |
872 | new_lines(numchar); | 882 | new_lines(numchar); |
873 | memcpy(pending_requests[num_requests].id, public_key, TOX_CLIENT_ID_SIZE); | 883 | memcpy(pending_requests[num_requests].id, public_key, TOX_PUBLIC_KEY_SIZE); |
874 | pending_requests[num_requests].accepted = 0; | 884 | pending_requests[num_requests].accepted = 0; |
875 | ++num_requests; | 885 | ++num_requests; |
876 | do_refresh(); | 886 | do_refresh(); |
877 | } | 887 | } |
878 | 888 | ||
879 | void print_message(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata) | 889 | void print_message(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata) |
880 | { | 890 | { |
881 | /* ensure null termination */ | 891 | /* ensure null termination */ |
882 | uint8_t null_string[length + 1]; | 892 | uint8_t null_string[length + 1]; |
@@ -885,7 +895,7 @@ void print_message(Tox *m, int friendnumber, const uint8_t *string, uint16_t len | |||
885 | print_formatted_message(m, (char *)null_string, friendnumber, 0); | 895 | print_formatted_message(m, (char *)null_string, friendnumber, 0); |
886 | } | 896 | } |
887 | 897 | ||
888 | void print_nickchange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata) | 898 | void print_nickchange(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata) |
889 | { | 899 | { |
890 | char name[TOX_MAX_NAME_LENGTH + 1]; | 900 | char name[TOX_MAX_NAME_LENGTH + 1]; |
891 | 901 | ||
@@ -901,7 +911,7 @@ void print_nickchange(Tox *m, int friendnumber, const uint8_t *string, uint16_t | |||
901 | } | 911 | } |
902 | } | 912 | } |
903 | 913 | ||
904 | void print_statuschange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata) | 914 | void print_statuschange(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata) |
905 | { | 915 | { |
906 | char name[TOX_MAX_NAME_LENGTH + 1]; | 916 | char name[TOX_MAX_NAME_LENGTH + 1]; |
907 | 917 | ||
@@ -919,7 +929,7 @@ void print_statuschange(Tox *m, int friendnumber, const uint8_t *string, uint16_ | |||
919 | 929 | ||
920 | static char *data_file_name = NULL; | 930 | static char *data_file_name = NULL; |
921 | 931 | ||
922 | static int load_data(Tox *m) | 932 | static Tox *load_data() |
923 | { | 933 | { |
924 | FILE *data_file = fopen(data_file_name, "r"); | 934 | FILE *data_file = fopen(data_file_name, "r"); |
925 | 935 | ||
@@ -936,7 +946,7 @@ static int load_data(Tox *m) | |||
936 | return 0; | 946 | return 0; |
937 | } | 947 | } |
938 | 948 | ||
939 | tox_load(m, data, size); | 949 | Tox *m = tox_new(0, data, size, NULL); |
940 | 950 | ||
941 | if (fclose(data_file) < 0) { | 951 | if (fclose(data_file) < 0) { |
942 | perror("[!] fclose failed"); | 952 | perror("[!] fclose failed"); |
@@ -944,10 +954,10 @@ static int load_data(Tox *m) | |||
944 | /* return 0; */ | 954 | /* return 0; */ |
945 | } | 955 | } |
946 | 956 | ||
947 | return 1; | 957 | return m; |
948 | } | 958 | } |
949 | 959 | ||
950 | return 0; | 960 | return tox_new(0, 0, 0, NULL); |
951 | } | 961 | } |
952 | 962 | ||
953 | static int save_data(Tox *m) | 963 | static int save_data(Tox *m) |
@@ -960,7 +970,7 @@ static int save_data(Tox *m) | |||
960 | } | 970 | } |
961 | 971 | ||
962 | int res = 1; | 972 | int res = 1; |
963 | size_t size = tox_size(m); | 973 | size_t size = tox_save_size(m); |
964 | uint8_t data[size]; | 974 | uint8_t data[size]; |
965 | tox_save(m, data); | 975 | tox_save(m, data); |
966 | 976 | ||
@@ -977,13 +987,10 @@ static int save_data(Tox *m) | |||
977 | return res; | 987 | return res; |
978 | } | 988 | } |
979 | 989 | ||
980 | static int load_data_or_init(Tox *m, char *path) | 990 | static int save_data_file(Tox *m, char *path) |
981 | { | 991 | { |
982 | data_file_name = path; | 992 | data_file_name = path; |
983 | 993 | ||
984 | if (load_data(m)) | ||
985 | return 1; | ||
986 | |||
987 | if (save_data(m)) | 994 | if (save_data(m)) |
988 | return 1; | 995 | return 1; |
989 | 996 | ||
@@ -1176,7 +1183,7 @@ void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *dat | |||
1176 | char timeout_getch(Tox *m) | 1183 | char timeout_getch(Tox *m) |
1177 | { | 1184 | { |
1178 | char c; | 1185 | char c; |
1179 | int slpval = tox_do_interval(m); | 1186 | int slpval = tox_iteration_interval(m); |
1180 | 1187 | ||
1181 | fd_set fds; | 1188 | fd_set fds; |
1182 | FD_ZERO(&fds); | 1189 | FD_ZERO(&fds); |
@@ -1214,7 +1221,7 @@ int main(int argc, char *argv[]) | |||
1214 | } | 1221 | } |
1215 | 1222 | ||
1216 | /* let user override default by cmdline */ | 1223 | /* let user override default by cmdline */ |
1217 | uint8_t ipv6enabled = TOX_ENABLE_IPV6_DEFAULT; /* x */ | 1224 | uint8_t ipv6enabled = 1; /* x */ |
1218 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); | 1225 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); |
1219 | 1226 | ||
1220 | if (argvoffset < 0) | 1227 | if (argvoffset < 0) |
@@ -1231,19 +1238,20 @@ int main(int argc, char *argv[]) | |||
1231 | if (!strcmp(argv[argc - 2], "-f")) | 1238 | if (!strcmp(argv[argc - 2], "-f")) |
1232 | filename = argv[argc - 1]; | 1239 | filename = argv[argc - 1]; |
1233 | 1240 | ||
1234 | m = tox_new(0); | 1241 | data_file_name = filename; |
1242 | m = load_data(); | ||
1235 | 1243 | ||
1236 | if ( !m ) { | 1244 | if ( !m ) { |
1237 | fputs("Failed to allocate Messenger datastructure", stderr); | 1245 | fputs("Failed to allocate Messenger datastructure", stderr); |
1238 | exit(0); | 1246 | exit(0); |
1239 | } | 1247 | } |
1240 | 1248 | ||
1241 | load_data_or_init(m, filename); | 1249 | save_data_file(m, filename); |
1242 | 1250 | ||
1243 | tox_callback_friend_request(m, print_request, NULL); | 1251 | tox_callback_friend_request(m, print_request, NULL); |
1244 | tox_callback_friend_message(m, print_message, NULL); | 1252 | tox_callback_friend_message(m, print_message, NULL); |
1245 | tox_callback_name_change(m, print_nickchange, NULL); | 1253 | tox_callback_friend_name(m, print_nickchange, NULL); |
1246 | tox_callback_status_message(m, print_statuschange, NULL); | 1254 | tox_callback_friend_status_message(m, print_statuschange, NULL); |
1247 | tox_callback_group_invite(m, print_invite, NULL); | 1255 | tox_callback_group_invite(m, print_invite, NULL); |
1248 | tox_callback_group_message(m, print_groupmessage, NULL); | 1256 | tox_callback_group_message(m, print_groupmessage, NULL); |
1249 | tox_callback_file_data(m, write_file, NULL); | 1257 | tox_callback_file_data(m, write_file, NULL); |
@@ -1263,7 +1271,7 @@ int main(int argc, char *argv[]) | |||
1263 | 1271 | ||
1264 | uint16_t port = atoi(argv[argvoffset + 2]); | 1272 | uint16_t port = atoi(argv[argvoffset + 2]); |
1265 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); | 1273 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); |
1266 | int res = tox_bootstrap_from_address(m, argv[argvoffset + 1], port, binary_string); | 1274 | int res = tox_bootstrap(m, argv[argvoffset + 1], port, binary_string, NULL); |
1267 | 1275 | ||
1268 | if (!res) { | 1276 | if (!res) { |
1269 | printf("Failed to convert \"%s\" into an IP address. Exiting...\n", argv[argvoffset + 1]); | 1277 | printf("Failed to convert \"%s\" into an IP address. Exiting...\n", argv[argvoffset + 1]); |
@@ -1275,7 +1283,8 @@ int main(int argc, char *argv[]) | |||
1275 | 1283 | ||
1276 | new_lines("[i] change username with /n"); | 1284 | new_lines("[i] change username with /n"); |
1277 | uint8_t name[TOX_MAX_NAME_LENGTH + 1]; | 1285 | uint8_t name[TOX_MAX_NAME_LENGTH + 1]; |
1278 | uint16_t namelen = tox_get_self_name(m, name); | 1286 | tox_self_get_name(m, name); |
1287 | uint16_t namelen = tox_self_get_name_size(m); | ||
1279 | name[namelen] = 0; | 1288 | name[namelen] = 0; |
1280 | 1289 | ||
1281 | if (namelen > 0) { | 1290 | if (namelen > 0) { |
@@ -1288,7 +1297,7 @@ int main(int argc, char *argv[]) | |||
1288 | 1297 | ||
1289 | while (1) { | 1298 | while (1) { |
1290 | if (on == 0) { | 1299 | if (on == 0) { |
1291 | if (tox_isconnected(m)) { | 1300 | if (tox_get_connection_status(m)) { |
1292 | new_lines("[i] connected to DHT"); | 1301 | new_lines("[i] connected to DHT"); |
1293 | on = 1; | 1302 | on = 1; |
1294 | } else { | 1303 | } else { |
@@ -1296,15 +1305,13 @@ int main(int argc, char *argv[]) | |||
1296 | 1305 | ||
1297 | if (timestamp0 + 10 < timestamp1) { | 1306 | if (timestamp0 + 10 < timestamp1) { |
1298 | timestamp0 = timestamp1; | 1307 | timestamp0 = timestamp1; |
1299 | tox_bootstrap_from_address(m, argv[argvoffset + 1], port, binary_string); | 1308 | tox_bootstrap(m, argv[argvoffset + 1], port, binary_string, NULL); |
1300 | } | 1309 | } |
1301 | } | 1310 | } |
1302 | } | 1311 | } |
1303 | 1312 | ||
1304 | |||
1305 | |||
1306 | send_filesenders(m); | 1313 | send_filesenders(m); |
1307 | tox_do(m); | 1314 | tox_iteration(m); |
1308 | do_refresh(); | 1315 | do_refresh(); |
1309 | 1316 | ||
1310 | int c = timeout_getch(m); | 1317 | int c = timeout_getch(m); |
@@ -1320,7 +1327,7 @@ int main(int argc, char *argv[]) | |||
1320 | } else if (c == 8 || c == 127) { | 1327 | } else if (c == 8 || c == 127) { |
1321 | input_line[strlen(input_line) - 1] = '\0'; | 1328 | input_line[strlen(input_line) - 1] = '\0'; |
1322 | } else if (isalnum(c) || ispunct(c) || c == ' ') { | 1329 | } else if (isalnum(c) || ispunct(c) || c == ' ') { |
1323 | strcpy(input_line, appender(input_line, (char) c)); | 1330 | appender(input_line, (char) c); |
1324 | } | 1331 | } |
1325 | } | 1332 | } |
1326 | 1333 | ||
diff --git a/testing/test_avatars.c b/testing/test_avatars.c deleted file mode 100644 index b4adc48f..00000000 --- a/testing/test_avatars.c +++ /dev/null | |||
@@ -1,755 +0,0 @@ | |||
1 | /* | ||
2 | * A bot to test Tox avatars | ||
3 | * | ||
4 | * Usage: ./test_avatars <data dir> | ||
5 | * | ||
6 | * Connects to the Tox network, publishes our avatar, requests our friends | ||
7 | * avatars and, if available, saves them to a local cache. | ||
8 | * This bot automatically accepts any friend request. | ||
9 | * | ||
10 | * | ||
11 | * Data dir MUST have: | ||
12 | * | ||
13 | * - A file named "data" (named accordingly to STS Draft v0.1.0) with | ||
14 | * user id, friends, bootstrap data, etc. from a previously configured | ||
15 | * Tox session; use a client (eg. toxic) to configure it, add friends, | ||
16 | * etc. | ||
17 | * | ||
18 | * Data dir MAY have: | ||
19 | * | ||
20 | * - A directory named "avatars" with the user's avatar and cached avatars. | ||
21 | * The user avatar must be named in the format: "<uppercase pub key>.png" | ||
22 | * | ||
23 | * | ||
24 | * The bot will answer to these commands: | ||
25 | * | ||
26 | * !debug-on - Enable extended debug messages | ||
27 | * !debug-off - Disenable extended debug messages | ||
28 | * !set-avatar - Set our avatar from "avatars/<USERID>.png" | ||
29 | * !remove-avatar - Remove our avatar | ||
30 | * | ||
31 | */ | ||
32 | |||
33 | #define DATA_FILE_NAME "data" | ||
34 | #define AVATAR_DIR_NAME "avatars" | ||
35 | |||
36 | #ifdef HAVE_CONFIG_H | ||
37 | #include "config.h" | ||
38 | #endif | ||
39 | |||
40 | #include "../toxcore/tox.h" | ||
41 | |||
42 | #include <stdlib.h> | ||
43 | #include <stdio.h> | ||
44 | #include <string.h> | ||
45 | #include <unistd.h> | ||
46 | #include <time.h> | ||
47 | #include <stdbool.h> | ||
48 | #include <limits.h> | ||
49 | #include <sys/stat.h> | ||
50 | #include <unistd.h> | ||
51 | #include <errno.h> | ||
52 | #include <stdarg.h> | ||
53 | |||
54 | |||
55 | |||
56 | /* Basic debug utils */ | ||
57 | |||
58 | #define DEBUG(format, ...) debug_printf("DEBUG: %s:%d %s: " format "\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__) | ||
59 | |||
60 | static bool print_debug_msgs = true; | ||
61 | |||
62 | static void debug_printf(const char *fmt, ...) | ||
63 | { | ||
64 | if (print_debug_msgs == true) { | ||
65 | va_list ap; | ||
66 | va_start(ap, fmt); | ||
67 | vprintf(fmt, ap); | ||
68 | va_end(ap); | ||
69 | } | ||
70 | } | ||
71 | |||
72 | |||
73 | |||
74 | |||
75 | |||
76 | |||
77 | /* ------------ Avatar cache managenment functions ------------ */ | ||
78 | |||
79 | typedef struct { | ||
80 | uint8_t format; | ||
81 | char *suffix; | ||
82 | } avatar_format_data_t; | ||
83 | |||
84 | static const avatar_format_data_t avatar_formats[] = { | ||
85 | /* In order of preference */ | ||
86 | { TOX_AVATAR_FORMAT_PNG, "png" }, | ||
87 | { TOX_AVATAR_FORMAT_NONE, NULL }, /* Must be the last one */ | ||
88 | }; | ||
89 | |||
90 | |||
91 | |||
92 | static void set_avatar(Tox *tox, const char *base_dir); | ||
93 | |||
94 | |||
95 | static char *get_avatar_suffix_from_format(uint8_t format) | ||
96 | { | ||
97 | int i; | ||
98 | |||
99 | for (i = 0; avatar_formats[i].format != TOX_AVATAR_FORMAT_NONE; i++) | ||
100 | if (avatar_formats[i].format == format) | ||
101 | return avatar_formats[i].suffix; | ||
102 | |||
103 | return NULL; | ||
104 | } | ||
105 | |||
106 | |||
107 | /* Load avatar data from a file into a memory buffer 'buf'. | ||
108 | * buf must have at least TOX_MAX_AVATAR_DATA_LENGTH bytes | ||
109 | * Returns the length of the data sucess or < 0 on error | ||
110 | */ | ||
111 | static int load_avatar_data(char *fname, uint8_t *buf) | ||
112 | { | ||
113 | FILE *fp = fopen(fname, "rb"); | ||
114 | |||
115 | if (fp == NULL) | ||
116 | return -1; /* Error */ | ||
117 | |||
118 | size_t n = fread(buf, 1, TOX_AVATAR_MAX_DATA_LENGTH, fp); | ||
119 | int ret; | ||
120 | |||
121 | if (ferror(fp) != 0 || n == 0) | ||
122 | ret = -1; /* Error */ | ||
123 | else | ||
124 | ret = n; | ||
125 | |||
126 | fclose(fp); | ||
127 | return ret; | ||
128 | } | ||
129 | |||
130 | |||
131 | /* Save avatar data to a file */ | ||
132 | static int save_avatar_data(char *fname, uint8_t *data, uint32_t len) | ||
133 | { | ||
134 | FILE *fp = fopen(fname, "wb"); | ||
135 | |||
136 | if (fp == NULL) | ||
137 | return -1; /* Error */ | ||
138 | |||
139 | int ret = 0; /* Ok */ | ||
140 | |||
141 | if (fwrite(data, 1, len, fp) != len) | ||
142 | ret = -1; /* Error */ | ||
143 | |||
144 | if (fclose(fp) != 0) | ||
145 | ret = -1; /* Error */ | ||
146 | |||
147 | return ret; | ||
148 | } | ||
149 | |||
150 | |||
151 | static void byte_to_hex_str(const uint8_t *buf, const size_t buflen, char *dst) | ||
152 | { | ||
153 | const char *hex_chars = "0123456789ABCDEF"; | ||
154 | size_t i = 0; | ||
155 | size_t j = 0; | ||
156 | |||
157 | while (i < buflen) { | ||
158 | dst[j++] = hex_chars[(buf[i] >> 4) & 0xf]; | ||
159 | dst[j++] = hex_chars[buf[i] & 0xf]; | ||
160 | i++; | ||
161 | } | ||
162 | |||
163 | dst[j++] = '\0'; | ||
164 | } | ||
165 | |||
166 | /* Make the cache file name for an avatar of the given format for the given | ||
167 | * public key. | ||
168 | */ | ||
169 | static int make_avatar_file_name(char *dst, size_t dst_len, const char *base_dir, | ||
170 | const uint8_t format, uint8_t *public_key) | ||
171 | { | ||
172 | char public_key_str[2 * TOX_PUBLIC_KEY_SIZE + 1]; | ||
173 | byte_to_hex_str(public_key, TOX_PUBLIC_KEY_SIZE, public_key_str); | ||
174 | |||
175 | const char *suffix = get_avatar_suffix_from_format(format); | ||
176 | |||
177 | if (suffix == NULL) | ||
178 | return -1; /* Error */ | ||
179 | |||
180 | int n = snprintf(dst, dst_len, "%s/%s/%s.%s", base_dir, AVATAR_DIR_NAME, | ||
181 | public_key_str, suffix); | ||
182 | dst[dst_len - 1] = '\0'; | ||
183 | |||
184 | if (n >= dst_len) | ||
185 | return -1; /* Error: Output truncated */ | ||
186 | |||
187 | return 0; /* Ok */ | ||
188 | } | ||
189 | |||
190 | |||
191 | /* Load a cached avatar into the buffer 'data' (which must be at least | ||
192 | * TOX_MAX_AVATAR_DATA_LENGTH bytes long). Gets the file name from client | ||
193 | * id and the given data format. | ||
194 | * Returns 0 on success, or -1 on error. | ||
195 | */ | ||
196 | static int load_user_avatar(Tox *tox, char *base_dir, int friendnum, | ||
197 | uint8_t format, uint8_t *hash, uint8_t *data, uint32_t *datalen) | ||
198 | { | ||
199 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
200 | |||
201 | if (tox_get_client_id(tox, friendnum, addr) != 0) { | ||
202 | DEBUG("Bad client id, friendnumber=%d", friendnum); | ||
203 | return -1; | ||
204 | } | ||
205 | |||
206 | char path[PATH_MAX]; | ||
207 | int ret = make_avatar_file_name(path, sizeof(path), base_dir, format, addr); | ||
208 | |||
209 | if (ret != 0) { | ||
210 | DEBUG("Can't create an file name for this user/avatar."); | ||
211 | return -1; | ||
212 | } | ||
213 | |||
214 | ret = load_avatar_data(path, data); | ||
215 | |||
216 | if (ret < 0) { | ||
217 | DEBUG("Failed to load avatar data."); | ||
218 | return -1; | ||
219 | } | ||
220 | |||
221 | *datalen = ret; | ||
222 | tox_hash(hash, data, *datalen); | ||
223 | |||
224 | return 0; | ||
225 | } | ||
226 | |||
227 | /* Save a user avatar into the cache. Gets the file name from the public key | ||
228 | * and the given data format. | ||
229 | * Returns 0 on success, or -1 on error. | ||
230 | */ | ||
231 | static int save_user_avatar(Tox *tox, char *base_dir, int friendnum, | ||
232 | uint8_t format, uint8_t *data, uint32_t datalen) | ||
233 | { | ||
234 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
235 | |||
236 | if (tox_get_client_id(tox, friendnum, addr) != 0) { | ||
237 | DEBUG("Bad client id, friendnumber=%d", friendnum); | ||
238 | return -1; | ||
239 | } | ||
240 | |||
241 | char path[PATH_MAX]; | ||
242 | int ret = make_avatar_file_name(path, sizeof(path), base_dir, format, addr); | ||
243 | |||
244 | if (ret != 0) { | ||
245 | DEBUG("Can't create a file name for this user/avatar"); | ||
246 | return -1; | ||
247 | } | ||
248 | |||
249 | return save_avatar_data(path, data, datalen); | ||
250 | } | ||
251 | |||
252 | /* Delete all cached avatars for a given user */ | ||
253 | static int delete_user_avatar(Tox *tox, char *base_dir, int friendnum) | ||
254 | { | ||
255 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
256 | |||
257 | if (tox_get_client_id(tox, friendnum, addr) != 0) { | ||
258 | DEBUG("Bad client id, friendnumber=%d", friendnum); | ||
259 | return -1; | ||
260 | } | ||
261 | |||
262 | char path[PATH_MAX]; | ||
263 | |||
264 | /* This iteration is dumb and inefficient */ | ||
265 | int i; | ||
266 | |||
267 | for (i = 0; avatar_formats[i].format != TOX_AVATAR_FORMAT_NONE; i++) { | ||
268 | int ret = make_avatar_file_name(path, sizeof(path), base_dir, | ||
269 | avatar_formats[i].format, addr); | ||
270 | |||
271 | if (ret != 0) { | ||
272 | DEBUG("Failed to create avatar path for friend #%d, format %d\n", | ||
273 | friendnum, avatar_formats[i].format); | ||
274 | continue; | ||
275 | } | ||
276 | |||
277 | if (unlink(path) == 0) | ||
278 | printf("Avatar file %s deleted.\n", path); | ||
279 | } | ||
280 | |||
281 | return 0; | ||
282 | } | ||
283 | |||
284 | |||
285 | |||
286 | |||
287 | /* ------------ Protocol callbacks ------------ */ | ||
288 | |||
289 | static void friend_status_cb(Tox *tox, int n, uint8_t status, void *ud) | ||
290 | { | ||
291 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
292 | char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1]; | ||
293 | |||
294 | if (tox_get_client_id(tox, n, addr) == 0) { | ||
295 | byte_to_hex_str(addr, TOX_PUBLIC_KEY_SIZE, addr_str); | ||
296 | printf("Receiving status from %s: %u\n", addr_str, status); | ||
297 | } | ||
298 | } | ||
299 | |||
300 | static void friend_avatar_info_cb(Tox *tox, int32_t n, uint8_t format, uint8_t *hash, void *ud) | ||
301 | { | ||
302 | char *base_dir = (char *) ud; | ||
303 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
304 | char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1]; | ||
305 | char hash_str[2 * TOX_HASH_LENGTH + 1]; | ||
306 | |||
307 | if (tox_get_client_id(tox, n, addr) == 0) { | ||
308 | byte_to_hex_str(addr, TOX_PUBLIC_KEY_SIZE, addr_str); | ||
309 | printf("Receiving avatar information from %s.\n", addr_str); | ||
310 | } else { | ||
311 | DEBUG("tox_get_client_id failed"); | ||
312 | printf("Receiving avatar information from friend number %u.\n", n); | ||
313 | } | ||
314 | |||
315 | byte_to_hex_str(hash, TOX_HASH_LENGTH, hash_str); | ||
316 | DEBUG("format=%u, hash=%s", format, hash_str); | ||
317 | |||
318 | if (format == TOX_AVATAR_FORMAT_NONE) { | ||
319 | printf(" -> User do not have an avatar.\n"); | ||
320 | /* User have no avatar anymore, delete it from our cache */ | ||
321 | delete_user_avatar(tox, base_dir, n); | ||
322 | } else { | ||
323 | /* Check the hash of the currently cached user avatar | ||
324 | * WARNING: THIS IS ONLY AN EXAMPLE! | ||
325 | * | ||
326 | * Real clients should keep the hashes in memory (eg. in the object | ||
327 | * used to represent a friend in the friend list) and do not access | ||
328 | * the file system or do anything resource intensive in reply of | ||
329 | * these events. | ||
330 | */ | ||
331 | uint32_t cur_av_len; | ||
332 | uint8_t cur_av_data[TOX_AVATAR_MAX_DATA_LENGTH]; | ||
333 | uint8_t cur_av_hash[TOX_HASH_LENGTH]; | ||
334 | int ret; | ||
335 | |||
336 | ret = load_user_avatar(tox, base_dir, n, format, cur_av_hash, cur_av_data, &cur_av_len); | ||
337 | |||
338 | if (ret != 0 | ||
339 | && memcpy(cur_av_hash, hash, TOX_HASH_LENGTH) != 0) { | ||
340 | printf(" -> Cached avatar is outdated. Requesting avatar data.\n"); | ||
341 | tox_request_avatar_data(tox, n); | ||
342 | } else { | ||
343 | printf(" -> Cached avatar is still updated.\n"); | ||
344 | } | ||
345 | } | ||
346 | |||
347 | } | ||
348 | |||
349 | static void friend_avatar_data_cb(Tox *tox, int32_t n, uint8_t format, | ||
350 | uint8_t *hash, uint8_t *data, uint32_t datalen, void *ud) | ||
351 | { | ||
352 | char *base_dir = (char *) ud; | ||
353 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
354 | char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1]; | ||
355 | char hash_str[2 * TOX_HASH_LENGTH + 1]; | ||
356 | |||
357 | if (tox_get_client_id(tox, n, addr) == 0) { | ||
358 | byte_to_hex_str(addr, TOX_PUBLIC_KEY_SIZE, addr_str); | ||
359 | printf("Receiving avatar data from %s.\n", addr_str); | ||
360 | } else { | ||
361 | DEBUG("tox_get_client_id failed"); | ||
362 | printf("Receiving avatar data from friend number %u.\n", n); | ||
363 | } | ||
364 | |||
365 | byte_to_hex_str(hash, TOX_HASH_LENGTH, hash_str); | ||
366 | DEBUG("format=%u, datalen=%d, hash=%s\n", format, datalen, hash_str); | ||
367 | |||
368 | delete_user_avatar(tox, base_dir, n); | ||
369 | |||
370 | if (format != TOX_AVATAR_FORMAT_NONE) { | ||
371 | int ret = save_user_avatar(tox, base_dir, n, format, data, datalen); | ||
372 | |||
373 | if (ret == 0) | ||
374 | printf(" -> Avatar updated in the cache.\n"); | ||
375 | else | ||
376 | printf(" -> Failed to save user avatar.\n"); | ||
377 | } | ||
378 | } | ||
379 | |||
380 | |||
381 | static void friend_msg_cb(Tox *tox, int n, const uint8_t *msg, uint16_t len, void *ud) | ||
382 | { | ||
383 | const char *base_dir = (char *) ud; | ||
384 | const char *msg_str = (char *) msg; | ||
385 | uint8_t addr[TOX_PUBLIC_KEY_SIZE]; | ||
386 | char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1]; | ||
387 | |||
388 | if (tox_get_client_id(tox, n, addr) == 0) { | ||
389 | byte_to_hex_str(addr, TOX_FRIEND_ADDRESS_SIZE, addr_str); | ||
390 | printf("Receiving message from %s:\n %s\n", addr_str, msg); | ||
391 | } | ||
392 | |||
393 | /* Handle bot commands for the tests */ | ||
394 | char *reply_ptr = NULL; | ||
395 | |||
396 | if (strstr(msg_str, "!debug-on") != NULL) { | ||
397 | print_debug_msgs = true; | ||
398 | reply_ptr = "Debug enabled."; | ||
399 | } else if (strstr(msg_str, "!debug-off") != NULL) { | ||
400 | print_debug_msgs = false; | ||
401 | reply_ptr = "Debug disabled."; | ||
402 | } else if (strstr(msg_str, "!set-avatar") != NULL) { | ||
403 | set_avatar(tox, base_dir); | ||
404 | reply_ptr = "Setting image avatar"; | ||
405 | } else if (strstr(msg_str, "!remove-avatar") != NULL) { | ||
406 | int r = tox_set_avatar(tox, TOX_AVATAR_FORMAT_NONE, NULL, 0); | ||
407 | DEBUG("tox_set_avatar returned %d", r); | ||
408 | reply_ptr = "Removing avatar"; | ||
409 | } | ||
410 | |||
411 | /* Add more useful commands here: add friend, etc. */ | ||
412 | |||
413 | char reply[TOX_MAX_MESSAGE_LENGTH]; | ||
414 | int reply_len; | ||
415 | |||
416 | if (reply_ptr) | ||
417 | reply_len = snprintf(reply, sizeof(reply), "%s", reply_ptr); | ||
418 | else | ||
419 | reply_len = snprintf(reply, sizeof(reply), | ||
420 | "No command found in message: %s", msg); | ||
421 | |||
422 | reply[sizeof(reply) - 1] = '\0'; | ||
423 | printf(" -> Reply: %s\n", reply); | ||
424 | tox_send_message(tox, n, (uint8_t *) reply, reply_len); | ||
425 | } | ||
426 | |||
427 | |||
428 | static void friend_request_cb(Tox *tox, const uint8_t *public_key, | ||
429 | const uint8_t *data, uint16_t length, void *ud) | ||
430 | { | ||
431 | char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1]; | ||
432 | byte_to_hex_str(public_key, TOX_PUBLIC_KEY_SIZE, addr_str); | ||
433 | printf("Accepting friend request from %s.\n %s\n", addr_str, data); | ||
434 | tox_add_friend_norequest(tox, public_key); | ||
435 | } | ||
436 | |||
437 | |||
438 | static void set_avatar(Tox *tox, const char *base_dir) | ||
439 | { | ||
440 | uint8_t addr[TOX_FRIEND_ADDRESS_SIZE]; | ||
441 | char path[PATH_MAX]; | ||
442 | uint8_t buf[2 * TOX_AVATAR_MAX_DATA_LENGTH]; | ||
443 | |||
444 | tox_get_address(tox, addr); | ||
445 | |||
446 | int i; | ||
447 | |||
448 | for (i = 0; ; i++) { | ||
449 | if (avatar_formats[i].format == TOX_AVATAR_FORMAT_NONE) { | ||
450 | tox_set_avatar(tox, TOX_AVATAR_FORMAT_NONE, NULL, 0); | ||
451 | printf("No avatar file found, setting to NONE.\n"); | ||
452 | break; | ||
453 | } else { | ||
454 | int ret = make_avatar_file_name(path, sizeof(path), base_dir, | ||
455 | avatar_formats[i].format, addr); | ||
456 | |||
457 | if (ret < 0) { | ||
458 | printf("Failed to generate avatar file name.\n"); | ||
459 | return; | ||
460 | } | ||
461 | |||
462 | int len = load_avatar_data(path, buf); | ||
463 | |||
464 | if (len < 0) { | ||
465 | printf("Failed to load avatar data from file: %s\n", path); | ||
466 | continue; | ||
467 | } | ||
468 | |||
469 | if (len > TOX_AVATAR_MAX_DATA_LENGTH) { | ||
470 | printf("Avatar file %s is too big (more than %d bytes)", | ||
471 | path, TOX_AVATAR_MAX_DATA_LENGTH); | ||
472 | return; | ||
473 | } | ||
474 | |||
475 | ret = tox_set_avatar(tox, avatar_formats[i].format, buf, len); | ||
476 | DEBUG("tox_set_avatar returned=%d", ret); | ||
477 | |||
478 | if (ret == 0) | ||
479 | printf("Setting avatar from %s (%d bytes).\n", path, len); | ||
480 | else | ||
481 | printf("Error setting avatar from %s.\n", path); | ||
482 | |||
483 | return; | ||
484 | } | ||
485 | } | ||
486 | } | ||
487 | |||
488 | |||
489 | static void print_avatar_info(Tox *tox) | ||
490 | { | ||
491 | uint8_t format; | ||
492 | uint8_t data[TOX_AVATAR_MAX_DATA_LENGTH]; | ||
493 | uint8_t hash[TOX_HASH_LENGTH]; | ||
494 | uint32_t data_length; | ||
495 | char hash_str[2 * TOX_HASH_LENGTH + 1]; | ||
496 | |||
497 | int ret = tox_get_self_avatar(tox, &format, data, &data_length, sizeof(data), hash); | ||
498 | DEBUG("tox_get_self_avatar returned %d", ret); | ||
499 | DEBUG("format: %d, data_length: %d", format, data_length); | ||
500 | byte_to_hex_str(hash, TOX_HASH_LENGTH, hash_str); | ||
501 | DEBUG("hash: %s", hash_str); | ||
502 | } | ||
503 | |||
504 | |||
505 | /* ------------ Initialization functions ------------ */ | ||
506 | |||
507 | /* Create directory to store tha avatars. Returns 0 if it was sucessfuly | ||
508 | * created or already existed. Returns -1 on error. | ||
509 | */ | ||
510 | static int create_avatar_diretory(const char *base_dir) | ||
511 | { | ||
512 | char path[PATH_MAX]; | ||
513 | int n = snprintf(path, sizeof(path), "%s/%s", base_dir, AVATAR_DIR_NAME); | ||
514 | path[sizeof(path) - 1] = '\0'; | ||
515 | |||
516 | if (n >= sizeof(path)) | ||
517 | return -1; | ||
518 | |||
519 | if (mkdir(path, 0755) == 0) { | ||
520 | return 0; /* Done */ | ||
521 | } else if (errno == EEXIST) { | ||
522 | /* Check if the existing path is a directory */ | ||
523 | struct stat st; | ||
524 | |||
525 | if (stat(path, &st) != 0) { | ||
526 | perror("stat()ing avatar directory"); | ||
527 | return -1; | ||
528 | } | ||
529 | |||
530 | if (S_ISDIR(st.st_mode)) | ||
531 | return 0; | ||
532 | } | ||
533 | |||
534 | return -1; /* Error */ | ||
535 | } | ||
536 | |||
537 | |||
538 | static void *load_bootstrap_data(const char *base_dir, uint32_t *len) | ||
539 | { | ||
540 | char path[PATH_MAX]; | ||
541 | int n = snprintf(path, sizeof(path), "%s/%s", base_dir, DATA_FILE_NAME); | ||
542 | path[sizeof(path) - 1] = '\0'; | ||
543 | |||
544 | if (n >= sizeof(path)) { | ||
545 | printf("Load error: path %s too long\n", path); | ||
546 | return NULL; | ||
547 | } | ||
548 | |||
549 | /* We should be using POSIX functions here, but let's try to be | ||
550 | * compatible with Windows. | ||
551 | */ | ||
552 | |||
553 | FILE *fp = fopen(path, "rb"); | ||
554 | |||
555 | if (fp == NULL) { | ||
556 | printf("fatal error: file %s not found.\n", path); | ||
557 | return NULL; | ||
558 | } | ||
559 | |||
560 | if (fseek(fp, 0, SEEK_END) != 0) { | ||
561 | printf("seek fail\n"); | ||
562 | fclose(fp); | ||
563 | return NULL; | ||
564 | } | ||
565 | |||
566 | int32_t flen = ftell(fp); | ||
567 | |||
568 | if (flen < 8 || flen > 2e6) { | ||
569 | printf("Fatal error: file %s have %u bytes. Out of acceptable range.\n", path, flen); | ||
570 | fclose(fp); | ||
571 | return NULL; | ||
572 | } | ||
573 | |||
574 | if (fseek(fp, 0, SEEK_SET) != 0) { | ||
575 | printf("seek fail\n"); | ||
576 | fclose(fp); | ||
577 | return NULL; | ||
578 | } | ||
579 | |||
580 | void *buf = malloc(flen); | ||
581 | |||
582 | if (buf == NULL) { | ||
583 | printf("malloc failed, %u bytes", flen); | ||
584 | fclose(fp); | ||
585 | return NULL; | ||
586 | } | ||
587 | |||
588 | *len = fread(buf, 1, flen, fp); | ||
589 | fclose(fp); | ||
590 | |||
591 | if (*len != flen) { | ||
592 | printf("fatal: %s have %u bytes, read only %u\n", path, flen, *len); | ||
593 | free(buf); | ||
594 | return NULL; | ||
595 | } | ||
596 | |||
597 | printf("bootstrap data loaded from %s (%u bytes)\n", path, flen); | ||
598 | return buf; | ||
599 | } | ||
600 | |||
601 | static int save_bootstrap_data(Tox *tox, const char *base_dir) | ||
602 | { | ||
603 | char path[PATH_MAX]; | ||
604 | int n = snprintf(path, sizeof(path), "%s/%s", base_dir, DATA_FILE_NAME); | ||
605 | path[sizeof(path) - 1] = '\0'; | ||
606 | |||
607 | if (n >= sizeof(path)) { | ||
608 | printf("Save error: path %s too long\n", path); | ||
609 | return -1; | ||
610 | } | ||
611 | |||
612 | char path_tmp[PATH_MAX]; | ||
613 | n = snprintf(path_tmp, sizeof(path_tmp), "%s.tmp", path); | ||
614 | path_tmp[sizeof(path_tmp) - 1] = '\0'; | ||
615 | |||
616 | if (n >= sizeof(path_tmp)) { | ||
617 | printf("error: path %s too long\n", path); | ||
618 | return -1; | ||
619 | } | ||
620 | |||
621 | uint32_t len = tox_size(tox); | ||
622 | |||
623 | if (len < 8 || len > 2e6) { | ||
624 | printf("save data length == %u, out of acceptable range\n", len); | ||
625 | return -1; | ||
626 | } | ||
627 | |||
628 | void *buf = malloc(len); | ||
629 | |||
630 | if (buf == NULL) { | ||
631 | printf("save data: malloc failed\n"); | ||
632 | return -1; | ||
633 | } | ||
634 | |||
635 | tox_save(tox, buf); | ||
636 | |||
637 | FILE *fp = fopen(path_tmp, "wb"); | ||
638 | |||
639 | if (fp == NULL) { | ||
640 | printf("Error saving data: can't open %s\n", path_tmp); | ||
641 | free(buf); | ||
642 | return -1; | ||
643 | } | ||
644 | |||
645 | if (fwrite(buf, 1, len, fp) != len) { | ||
646 | printf("Error writing data to %s\n", path_tmp); | ||
647 | free(buf); | ||
648 | fclose(fp); | ||
649 | return -1; | ||
650 | } | ||
651 | |||
652 | free(buf); | ||
653 | |||
654 | if (fclose(fp) != 0) { | ||
655 | printf("Error writing data to %s\n", path_tmp); | ||
656 | return -1; | ||
657 | } | ||
658 | |||
659 | if (rename(path_tmp, path) != 0) { | ||
660 | printf("Error renaming %s to %s\n", path_tmp, path); | ||
661 | return -1; | ||
662 | } | ||
663 | |||
664 | printf("Bootstrap data saved to %s\n", path); | ||
665 | return 0; /* Done */ | ||
666 | } | ||
667 | |||
668 | |||
669 | |||
670 | |||
671 | int main(int argc, char *argv[]) | ||
672 | { | ||
673 | int ret; | ||
674 | |||
675 | if (argc != 2) { | ||
676 | printf("usage: %s <data dir>\n", argv[0]); | ||
677 | return 1; | ||
678 | } | ||
679 | |||
680 | char *base_dir = argv[1]; | ||
681 | |||
682 | if (create_avatar_diretory(base_dir) != 0) | ||
683 | printf("Error creating avatar directory.\n"); | ||
684 | |||
685 | Tox *tox = tox_new(NULL); | ||
686 | |||
687 | uint32_t len; | ||
688 | void *data = load_bootstrap_data(base_dir, &len); | ||
689 | |||
690 | if (data == NULL) | ||
691 | return 1; | ||
692 | |||
693 | ret = tox_load(tox, data, len); | ||
694 | free(data); | ||
695 | |||
696 | if (ret == 0) { | ||
697 | printf("Tox initialized\n"); | ||
698 | } else { | ||
699 | printf("Fatal: tox_load returned %d\n", ret); | ||
700 | return 1; | ||
701 | } | ||
702 | |||
703 | tox_callback_connection_status(tox, friend_status_cb, NULL); | ||
704 | tox_callback_friend_message(tox, friend_msg_cb, base_dir); | ||
705 | tox_callback_friend_request(tox, friend_request_cb, NULL); | ||
706 | tox_callback_avatar_info(tox, friend_avatar_info_cb, base_dir); | ||
707 | tox_callback_avatar_data(tox, friend_avatar_data_cb, base_dir); | ||
708 | |||
709 | uint8_t addr[TOX_FRIEND_ADDRESS_SIZE]; | ||
710 | char addr_str[2 * TOX_FRIEND_ADDRESS_SIZE + 1]; | ||
711 | tox_get_address(tox, addr); | ||
712 | byte_to_hex_str(addr, TOX_FRIEND_ADDRESS_SIZE, addr_str); | ||
713 | printf("Using local tox address: %s\n", addr_str); | ||
714 | |||
715 | #ifdef TEST_SET_RESET_AVATAR | ||
716 | printf("Printing default avatar information:\n"); | ||
717 | print_avatar_info(tox); | ||
718 | |||
719 | printf("Setting a new avatar:\n"); | ||
720 | set_avatar(tox, base_dir); | ||
721 | print_avatar_info(tox); | ||
722 | |||
723 | printf("Removing the avatar we just set:\n"); | ||
724 | tox_avatar(tox, TOX_AVATARFORMAT_NONE, NULL, 0); | ||
725 | print_avatar_info(tox); | ||
726 | |||
727 | printf("Setting that avatar again:\n"); | ||
728 | #endif /* TEST_SET_RESET_AVATAR */ | ||
729 | |||
730 | set_avatar(tox, base_dir); | ||
731 | print_avatar_info(tox); | ||
732 | |||
733 | bool waiting = true; | ||
734 | time_t last_save = time(0); | ||
735 | |||
736 | while (1) { | ||
737 | if (tox_isconnected(tox) && waiting) { | ||
738 | printf("DHT connected.\n"); | ||
739 | waiting = false; | ||
740 | } | ||
741 | |||
742 | tox_do(tox); | ||
743 | |||
744 | time_t now = time(0); | ||
745 | |||
746 | if (now - last_save > 120) { | ||
747 | save_bootstrap_data(tox, base_dir); | ||
748 | last_save = now; | ||
749 | } | ||
750 | |||
751 | usleep(500000); | ||
752 | } | ||
753 | |||
754 | return 0; | ||
755 | } | ||
diff --git a/testing/tox_shell.c b/testing/tox_shell.c index 738d8616..5198d224 100644 --- a/testing/tox_shell.c +++ b/testing/tox_shell.c | |||
@@ -45,15 +45,15 @@ | |||
45 | 45 | ||
46 | #define c_sleep(x) usleep(1000*x) | 46 | #define c_sleep(x) usleep(1000*x) |
47 | 47 | ||
48 | void print_online(Tox *tox, int friendnumber, uint8_t status, void *userdata) | 48 | void print_online(Tox *tox, uint32_t friendnumber, uint8_t status, void *userdata) |
49 | { | 49 | { |
50 | if (status == 1) | 50 | if (status) |
51 | printf("\nOther went online.\n"); | 51 | printf("\nOther went online.\n"); |
52 | else | 52 | else |
53 | printf("\nOther went offline.\n"); | 53 | printf("\nOther went offline.\n"); |
54 | } | 54 | } |
55 | 55 | ||
56 | void print_message(Tox *tox, int friendnumber, const uint8_t *string, uint16_t length, void *userdata) | 56 | void print_message(Tox *tox, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata) |
57 | { | 57 | { |
58 | int master = *((int *)userdata); | 58 | int master = *((int *)userdata); |
59 | write(master, string, length); | 59 | write(master, string, length); |
@@ -62,7 +62,7 @@ void print_message(Tox *tox, int friendnumber, const uint8_t *string, uint16_t l | |||
62 | 62 | ||
63 | int main(int argc, char *argv[]) | 63 | int main(int argc, char *argv[]) |
64 | { | 64 | { |
65 | uint8_t ipv6enabled = TOX_ENABLE_IPV6_DEFAULT; /* x */ | 65 | uint8_t ipv6enabled = 1; /* x */ |
66 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); | 66 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); |
67 | 67 | ||
68 | if (argvoffset < 0) | 68 | if (argvoffset < 0) |
@@ -94,14 +94,14 @@ int main(int argc, char *argv[]) | |||
94 | printf("error setting flags\n"); | 94 | printf("error setting flags\n"); |
95 | } | 95 | } |
96 | 96 | ||
97 | Tox *tox = tox_new(0); | 97 | Tox *tox = tox_new(0, 0, 0, 0); |
98 | tox_callback_connection_status(tox, print_online, NULL); | 98 | tox_callback_friend_connection_status(tox, print_online, NULL); |
99 | tox_callback_friend_message(tox, print_message, master); | 99 | tox_callback_friend_message(tox, print_message, master); |
100 | 100 | ||
101 | 101 | ||
102 | uint16_t port = atoi(argv[argvoffset + 2]); | 102 | uint16_t port = atoi(argv[argvoffset + 2]); |
103 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); | 103 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); |
104 | int res = tox_bootstrap_from_address(tox, argv[argvoffset + 1], port, binary_string); | 104 | int res = tox_bootstrap(tox, argv[argvoffset + 1], port, binary_string, 0); |
105 | free(binary_string); | 105 | free(binary_string); |
106 | 106 | ||
107 | if (!res) { | 107 | if (!res) { |
@@ -109,11 +109,11 @@ int main(int argc, char *argv[]) | |||
109 | exit(1); | 109 | exit(1); |
110 | } | 110 | } |
111 | 111 | ||
112 | uint8_t address[TOX_FRIEND_ADDRESS_SIZE]; | 112 | uint8_t address[TOX_ADDRESS_SIZE]; |
113 | tox_get_address(tox, address); | 113 | tox_self_get_address(tox, address); |
114 | uint32_t i; | 114 | uint32_t i; |
115 | 115 | ||
116 | for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) { | 116 | for (i = 0; i < TOX_ADDRESS_SIZE; i++) { |
117 | printf("%02X", address[i]); | 117 | printf("%02X", address[i]); |
118 | } | 118 | } |
119 | 119 | ||
@@ -125,10 +125,10 @@ int main(int argc, char *argv[]) | |||
125 | } | 125 | } |
126 | 126 | ||
127 | uint8_t *bin_id = hex_string_to_bin(temp_id); | 127 | uint8_t *bin_id = hex_string_to_bin(temp_id); |
128 | int num = tox_add_friend(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo")); | 128 | uint32_t num = tox_friend_add(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo"), 0); |
129 | free(bin_id); | 129 | free(bin_id); |
130 | 130 | ||
131 | if (num < 0) { | 131 | if (num == UINT32_MAX) { |
132 | printf("\nSomething went wrong when adding friend.\n"); | 132 | printf("\nSomething went wrong when adding friend.\n"); |
133 | return 1; | 133 | return 1; |
134 | } | 134 | } |
@@ -136,22 +136,22 @@ int main(int argc, char *argv[]) | |||
136 | uint8_t notconnected = 1; | 136 | uint8_t notconnected = 1; |
137 | 137 | ||
138 | while (1) { | 138 | while (1) { |
139 | if (tox_isconnected(tox) && notconnected) { | 139 | if (tox_get_connection_status(tox) && notconnected) { |
140 | printf("\nDHT connected.\n"); | 140 | printf("\nDHT connected.\n"); |
141 | notconnected = 0; | 141 | notconnected = 0; |
142 | } | 142 | } |
143 | 143 | ||
144 | while (tox_get_friend_connection_status(tox, num) == 1) { | 144 | while (tox_friend_get_connection_status(tox, num, 0)) { |
145 | uint8_t buf[TOX_MAX_MESSAGE_LENGTH]; | 145 | uint8_t buf[TOX_MAX_MESSAGE_LENGTH]; |
146 | ret = read(*master, buf, sizeof(buf)); | 146 | ret = read(*master, buf, sizeof(buf)); |
147 | 147 | ||
148 | if (ret <= 0) | 148 | if (ret <= 0) |
149 | break; | 149 | break; |
150 | 150 | ||
151 | tox_send_message(tox, num, buf, ret); | 151 | tox_send_message(tox, num, buf, ret, 0); |
152 | } | 152 | } |
153 | 153 | ||
154 | tox_do(tox); | 154 | tox_iteration(tox); |
155 | c_sleep(1); | 155 | c_sleep(1); |
156 | } | 156 | } |
157 | 157 | ||
diff --git a/testing/tox_sync.c b/testing/tox_sync.c index 8b64b6ca..77f75c36 100644 --- a/testing/tox_sync.c +++ b/testing/tox_sync.c | |||
@@ -192,9 +192,9 @@ void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *dat | |||
192 | printf("Error writing data\n"); | 192 | printf("Error writing data\n"); |
193 | } | 193 | } |
194 | 194 | ||
195 | void print_online(Tox *tox, int friendnumber, uint8_t status, void *userdata) | 195 | void print_online(Tox *tox, uint32_t friendnumber, uint8_t status, void *userdata) |
196 | { | 196 | { |
197 | if (status == 1) | 197 | if (status) |
198 | printf("\nOther went online.\n"); | 198 | printf("\nOther went online.\n"); |
199 | else | 199 | else |
200 | printf("\nOther went offline.\n"); | 200 | printf("\nOther went offline.\n"); |
@@ -202,7 +202,7 @@ void print_online(Tox *tox, int friendnumber, uint8_t status, void *userdata) | |||
202 | 202 | ||
203 | int main(int argc, char *argv[]) | 203 | int main(int argc, char *argv[]) |
204 | { | 204 | { |
205 | uint8_t ipv6enabled = TOX_ENABLE_IPV6_DEFAULT; /* x */ | 205 | uint8_t ipv6enabled = 1; /* x */ |
206 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); | 206 | int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled); |
207 | 207 | ||
208 | if (argvoffset < 0) | 208 | if (argvoffset < 0) |
@@ -214,15 +214,15 @@ int main(int argc, char *argv[]) | |||
214 | exit(0); | 214 | exit(0); |
215 | } | 215 | } |
216 | 216 | ||
217 | Tox *tox = tox_new(0); | 217 | Tox *tox = tox_new(0, 0, 0, 0); |
218 | tox_callback_file_data(tox, write_file, NULL); | 218 | tox_callback_file_data(tox, write_file, NULL); |
219 | tox_callback_file_control(tox, file_print_control, NULL); | 219 | tox_callback_file_control(tox, file_print_control, NULL); |
220 | tox_callback_file_send_request(tox, file_request_accept, NULL); | 220 | tox_callback_file_send_request(tox, file_request_accept, NULL); |
221 | tox_callback_connection_status(tox, print_online, NULL); | 221 | tox_callback_friend_connection_status(tox, print_online, NULL); |
222 | 222 | ||
223 | uint16_t port = atoi(argv[argvoffset + 2]); | 223 | uint16_t port = atoi(argv[argvoffset + 2]); |
224 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); | 224 | unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]); |
225 | int res = tox_bootstrap_from_address(tox, argv[argvoffset + 1], port, binary_string); | 225 | int res = tox_bootstrap(tox, argv[argvoffset + 1], port, binary_string, 0); |
226 | free(binary_string); | 226 | free(binary_string); |
227 | 227 | ||
228 | if (!res) { | 228 | if (!res) { |
@@ -230,11 +230,11 @@ int main(int argc, char *argv[]) | |||
230 | exit(1); | 230 | exit(1); |
231 | } | 231 | } |
232 | 232 | ||
233 | uint8_t address[TOX_FRIEND_ADDRESS_SIZE]; | 233 | uint8_t address[TOX_ADDRESS_SIZE]; |
234 | tox_get_address(tox, address); | 234 | tox_self_get_address(tox, address); |
235 | uint32_t i; | 235 | uint32_t i; |
236 | 236 | ||
237 | for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) { | 237 | for (i = 0; i < TOX_ADDRESS_SIZE; i++) { |
238 | printf("%02X", address[i]); | 238 | printf("%02X", address[i]); |
239 | } | 239 | } |
240 | 240 | ||
@@ -246,10 +246,10 @@ int main(int argc, char *argv[]) | |||
246 | } | 246 | } |
247 | 247 | ||
248 | uint8_t *bin_id = hex_string_to_bin(temp_id); | 248 | uint8_t *bin_id = hex_string_to_bin(temp_id); |
249 | int num = tox_add_friend(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo")); | 249 | uint32_t num = tox_friend_add(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo"), 0); |
250 | free(bin_id); | 250 | free(bin_id); |
251 | 251 | ||
252 | if (num < 0) { | 252 | if (num == UINT32_MAX) { |
253 | printf("\nSomething went wrong when adding friend.\n"); | 253 | printf("\nSomething went wrong when adding friend.\n"); |
254 | return 1; | 254 | return 1; |
255 | } | 255 | } |
@@ -260,12 +260,12 @@ int main(int argc, char *argv[]) | |||
260 | uint8_t notconnected = 1; | 260 | uint8_t notconnected = 1; |
261 | 261 | ||
262 | while (1) { | 262 | while (1) { |
263 | if (tox_isconnected(tox) && notconnected) { | 263 | if (tox_get_connection_status(tox) && notconnected) { |
264 | printf("\nDHT connected.\n"); | 264 | printf("\nDHT connected.\n"); |
265 | notconnected = 0; | 265 | notconnected = 0; |
266 | } | 266 | } |
267 | 267 | ||
268 | if (not_sending() && tox_get_friend_connection_status(tox, num)) { | 268 | if (not_sending() && tox_friend_get_connection_status(tox, num, 0)) { |
269 | d = opendir(path); | 269 | d = opendir(path); |
270 | 270 | ||
271 | if (d) { | 271 | if (d) { |
@@ -291,7 +291,7 @@ int main(int argc, char *argv[]) | |||
291 | } | 291 | } |
292 | 292 | ||
293 | send_filesenders(tox); | 293 | send_filesenders(tox); |
294 | tox_do(tox); | 294 | tox_iteration(tox); |
295 | c_sleep(1); | 295 | c_sleep(1); |
296 | } | 296 | } |
297 | 297 | ||