diff options
-rw-r--r-- | core/DHT.c | 559 | ||||
-rw-r--r-- | core/DHT.h | 11 | ||||
-rw-r--r-- | core/Lossless_UDP.c | 17 | ||||
-rw-r--r-- | core/Lossless_UDP.h | 9 | ||||
-rw-r--r-- | core/Messenger.c | 14 | ||||
-rw-r--r-- | core/Messenger.h | 8 | ||||
-rw-r--r-- | core/friend_requests.c | 3 | ||||
-rw-r--r-- | core/friend_requests.h | 5 | ||||
-rw-r--r-- | core/net_crypto.c | 12 | ||||
-rw-r--r-- | core/net_crypto.h | 6 | ||||
-rw-r--r-- | core/network.c | 3 | ||||
-rw-r--r-- | core/network.h | 4 | ||||
-rw-r--r-- | testing/DHT_cryptosendfiletest.c | 119 | ||||
-rw-r--r-- | testing/DHT_sendfiletest.c | 60 | ||||
-rw-r--r-- | testing/DHT_test.c | 53 | ||||
-rw-r--r-- | testing/Lossless_UDP_testclient.c | 72 | ||||
-rw-r--r-- | testing/Lossless_UDP_testserver.c | 48 | ||||
-rw-r--r-- | testing/Messenger_test.c | 19 | ||||
-rw-r--r-- | testing/nTox.c | 13 | ||||
-rw-r--r-- | testing/nTox.h | 1 |
20 files changed, 335 insertions, 701 deletions
@@ -23,7 +23,6 @@ | |||
23 | 23 | ||
24 | #include "DHT.h" | 24 | #include "DHT.h" |
25 | 25 | ||
26 | |||
27 | typedef struct | 26 | typedef struct |
28 | { | 27 | { |
29 | uint8_t client_id[CLIENT_ID_SIZE]; | 28 | uint8_t client_id[CLIENT_ID_SIZE]; |
@@ -34,8 +33,10 @@ typedef struct | |||
34 | (for nodes in friends_list) or us (for nodes in close_clientlist) */ | 33 | (for nodes in friends_list) or us (for nodes in close_clientlist) */ |
35 | uint32_t ret_timestamp; | 34 | uint32_t ret_timestamp; |
36 | }Client_data; | 35 | }Client_data; |
36 | |||
37 | /* maximum number of clients stored per friend. */ | 37 | /* maximum number of clients stored per friend. */ |
38 | #define MAX_FRIEND_CLIENTS 8 | 38 | #define MAX_FRIEND_CLIENTS 8 |
39 | |||
39 | typedef struct | 40 | typedef struct |
40 | { | 41 | { |
41 | uint8_t client_id[CLIENT_ID_SIZE]; | 42 | uint8_t client_id[CLIENT_ID_SIZE]; |
@@ -50,7 +51,6 @@ typedef struct | |||
50 | uint32_t NATping_timestamp; | 51 | uint32_t NATping_timestamp; |
51 | }Friend; | 52 | }Friend; |
52 | 53 | ||
53 | |||
54 | typedef struct | 54 | typedef struct |
55 | { | 55 | { |
56 | uint8_t client_id[CLIENT_ID_SIZE]; | 56 | uint8_t client_id[CLIENT_ID_SIZE]; |
@@ -74,8 +74,6 @@ uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; | |||
74 | #define LCLIENT_LIST 32 | 74 | #define LCLIENT_LIST 32 |
75 | static Client_data close_clientlist[LCLIENT_LIST]; | 75 | static Client_data close_clientlist[LCLIENT_LIST]; |
76 | 76 | ||
77 | |||
78 | |||
79 | static Friend * friends_list; | 77 | static Friend * friends_list; |
80 | static uint16_t num_friends; | 78 | static uint16_t num_friends; |
81 | 79 | ||
@@ -88,7 +86,6 @@ static Pinged pings[LPING_ARRAY]; | |||
88 | 86 | ||
89 | static Pinged send_nodes[LSEND_NODES_ARRAY]; | 87 | static Pinged send_nodes[LSEND_NODES_ARRAY]; |
90 | 88 | ||
91 | |||
92 | /* Compares client_id1 and client_id2 with client_id | 89 | /* Compares client_id1 and client_id2 with client_id |
93 | return 0 if both are same distance | 90 | return 0 if both are same distance |
94 | return 1 if client_id1 is closer | 91 | return 1 if client_id1 is closer |
@@ -96,17 +93,12 @@ static Pinged send_nodes[LSEND_NODES_ARRAY]; | |||
96 | int id_closest(uint8_t * client_id, uint8_t * client_id1, uint8_t * client_id2) /* tested */ | 93 | int id_closest(uint8_t * client_id, uint8_t * client_id1, uint8_t * client_id2) /* tested */ |
97 | { | 94 | { |
98 | uint32_t i; | 95 | uint32_t i; |
99 | for(i = 0; i < CLIENT_ID_SIZE; ++i) | 96 | for(i = 0; i < CLIENT_ID_SIZE; ++i) { |
100 | { | 97 | if(abs(client_id[i] ^ client_id1[i]) < abs(client_id[i] ^ client_id2[i])) { |
101 | if(abs(client_id[i] ^ client_id1[i]) < abs(client_id[i] ^ client_id2[i])) | ||
102 | { | ||
103 | return 1; | 98 | return 1; |
104 | } | 99 | } else if(abs(client_id[i] ^ client_id1[i]) > abs(client_id[i] ^ client_id2[i])) { |
105 | else if(abs(client_id[i] ^ client_id1[i]) > abs(client_id[i] ^ client_id2[i])) | ||
106 | { | ||
107 | return 2; | 100 | return 2; |
108 | } | 101 | } |
109 | |||
110 | } | 102 | } |
111 | 103 | ||
112 | return 0; | 104 | return 0; |
@@ -123,17 +115,14 @@ int client_in_list(Client_data * list, uint32_t length, uint8_t * client_id, IP_ | |||
123 | uint32_t i; | 115 | uint32_t i; |
124 | uint32_t temp_time = unix_time(); | 116 | uint32_t temp_time = unix_time(); |
125 | 117 | ||
126 | for(i = 0; i < length; ++i) | 118 | for(i = 0; i < length; ++i) { |
127 | { | ||
128 | /*If ip_port is assigned to a different client_id replace it*/ | 119 | /*If ip_port is assigned to a different client_id replace it*/ |
129 | if(list[i].ip_port.ip.i == ip_port.ip.i && | 120 | if(list[i].ip_port.ip.i == ip_port.ip.i && |
130 | list[i].ip_port.port == ip_port.port) | 121 | list[i].ip_port.port == ip_port.port) { |
131 | { | ||
132 | memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); | 122 | memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); |
133 | } | 123 | } |
134 | 124 | ||
135 | if(memcmp(list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) | 125 | if(memcmp(list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) { |
136 | { | ||
137 | /* Refresh the client timestamp. */ | 126 | /* Refresh the client timestamp. */ |
138 | list[i].timestamp = temp_time; | 127 | list[i].timestamp = temp_time; |
139 | list[i].ip_port.ip.i = ip_port.ip.i; | 128 | list[i].ip_port.ip.i = ip_port.ip.i; |
@@ -150,10 +139,8 @@ int client_in_list(Client_data * list, uint32_t length, uint8_t * client_id, IP_ | |||
150 | int client_in_nodelist(Node_format * list, uint32_t length, uint8_t * client_id) | 139 | int client_in_nodelist(Node_format * list, uint32_t length, uint8_t * client_id) |
151 | { | 140 | { |
152 | uint32_t i; | 141 | uint32_t i; |
153 | for(i = 0; i < length; ++i) | 142 | for(i = 0; i < length; ++i) { |
154 | { | 143 | if(memcmp(list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) { |
155 | if(memcmp(list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) | ||
156 | { | ||
157 | 144 | ||
158 | return 1; | 145 | return 1; |
159 | } | 146 | } |
@@ -167,8 +154,7 @@ int client_in_nodelist(Node_format * list, uint32_t length, uint8_t * client_id) | |||
167 | static int friend_number(uint8_t * client_id) | 154 | static int friend_number(uint8_t * client_id) |
168 | { | 155 | { |
169 | uint32_t i; | 156 | uint32_t i; |
170 | for(i = 0; i < num_friends; ++i) | 157 | for(i = 0; i < num_friends; ++i) { |
171 | { | ||
172 | if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) /* Equal */ | 158 | if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) /* Equal */ |
173 | { | 159 | { |
174 | return i; | 160 | return i; |
@@ -177,13 +163,11 @@ static int friend_number(uint8_t * client_id) | |||
177 | return -1; | 163 | return -1; |
178 | } | 164 | } |
179 | 165 | ||
180 | |||
181 | /* the number of seconds for a non responsive node to become bad. */ | 166 | /* the number of seconds for a non responsive node to become bad. */ |
182 | #define BAD_NODE_TIMEOUT 70 | 167 | #define BAD_NODE_TIMEOUT 70 |
183 | /* the max number of nodes to send with send nodes. */ | 168 | /* the max number of nodes to send with send nodes. */ |
184 | #define MAX_SENT_NODES 8 | 169 | #define MAX_SENT_NODES 8 |
185 | 170 | ||
186 | |||
187 | /* Find MAX_SENT_NODES nodes closest to the client_id for the send nodes request: | 171 | /* Find MAX_SENT_NODES nodes closest to the client_id for the send nodes request: |
188 | put them in the nodes_list and return how many were found. | 172 | put them in the nodes_list and return how many were found. |
189 | TODO: Make this function much more efficient. */ | 173 | TODO: Make this function much more efficient. */ |
@@ -192,48 +176,35 @@ int get_close_nodes(uint8_t * client_id, Node_format * nodes_list) | |||
192 | uint32_t i, j, k; | 176 | uint32_t i, j, k; |
193 | int num_nodes=0; | 177 | int num_nodes=0; |
194 | uint32_t temp_time = unix_time(); | 178 | uint32_t temp_time = unix_time(); |
195 | for(i = 0; i < LCLIENT_LIST; ++i) | 179 | for(i = 0; i < LCLIENT_LIST; ++i) { |
196 | { | ||
197 | if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time && | 180 | if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time && |
198 | !client_in_nodelist(nodes_list, MAX_SENT_NODES,close_clientlist[i].client_id)) | 181 | !client_in_nodelist(nodes_list, MAX_SENT_NODES,close_clientlist[i].client_id)) { |
199 | /* if node is good and not already in list. */ | 182 | /* if node is good and not already in list. */ |
200 | { | 183 | if(num_nodes < MAX_SENT_NODES) { |
201 | if(num_nodes < MAX_SENT_NODES) | ||
202 | { | ||
203 | memcpy(nodes_list[num_nodes].client_id, close_clientlist[i].client_id, CLIENT_ID_SIZE); | 184 | memcpy(nodes_list[num_nodes].client_id, close_clientlist[i].client_id, CLIENT_ID_SIZE); |
204 | nodes_list[num_nodes].ip_port = close_clientlist[i].ip_port; | 185 | nodes_list[num_nodes].ip_port = close_clientlist[i].ip_port; |
205 | num_nodes++; | 186 | num_nodes++; |
206 | } | 187 | } |
207 | else for(j = 0; j < MAX_SENT_NODES; ++j) | 188 | else for(j = 0; j < MAX_SENT_NODES; ++j) { |
208 | { | 189 | if(id_closest(client_id, nodes_list[j].client_id, close_clientlist[i].client_id) == 2) { |
209 | if(id_closest(client_id, nodes_list[j].client_id, close_clientlist[i].client_id) == 2) | ||
210 | { | ||
211 | memcpy(nodes_list[j].client_id, close_clientlist[i].client_id, CLIENT_ID_SIZE); | 190 | memcpy(nodes_list[j].client_id, close_clientlist[i].client_id, CLIENT_ID_SIZE); |
212 | nodes_list[j].ip_port = close_clientlist[i].ip_port; | 191 | nodes_list[j].ip_port = close_clientlist[i].ip_port; |
213 | break; | 192 | break; |
214 | } | 193 | } |
215 | } | 194 | } |
216 | } | 195 | } |
217 | |||
218 | } | 196 | } |
219 | for(i = 0; i < num_friends; ++i) | 197 | for(i = 0; i < num_friends; ++i) { |
220 | { | 198 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) { |
221 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) | ||
222 | { | ||
223 | if(friends_list[i].client_list[j].timestamp + BAD_NODE_TIMEOUT > temp_time && | 199 | if(friends_list[i].client_list[j].timestamp + BAD_NODE_TIMEOUT > temp_time && |
224 | !client_in_nodelist(nodes_list, MAX_SENT_NODES,friends_list[i].client_list[j].client_id)) | 200 | !client_in_nodelist(nodes_list, MAX_SENT_NODES,friends_list[i].client_list[j].client_id)) { |
225 | /* if node is good and not already in list. */ | 201 | /* if node is good and not already in list. */ |
226 | { | 202 | if(num_nodes < MAX_SENT_NODES) { |
227 | if(num_nodes < MAX_SENT_NODES) | ||
228 | { | ||
229 | memcpy(nodes_list[num_nodes].client_id, friends_list[i].client_list[j].client_id, CLIENT_ID_SIZE); | 203 | memcpy(nodes_list[num_nodes].client_id, friends_list[i].client_list[j].client_id, CLIENT_ID_SIZE); |
230 | nodes_list[num_nodes].ip_port = friends_list[i].client_list[j].ip_port; | 204 | nodes_list[num_nodes].ip_port = friends_list[i].client_list[j].ip_port; |
231 | num_nodes++; | 205 | num_nodes++; |
232 | } | 206 | } else for(k = 0; k < MAX_SENT_NODES; ++k) { |
233 | else for(k = 0; k < MAX_SENT_NODES; ++k) | 207 | if(id_closest(client_id, nodes_list[k].client_id, friends_list[i].client_list[j].client_id) == 2) { |
234 | { | ||
235 | if(id_closest(client_id, nodes_list[k].client_id, friends_list[i].client_list[j].client_id) == 2) | ||
236 | { | ||
237 | memcpy(nodes_list[k].client_id, friends_list[i].client_list[j].client_id, CLIENT_ID_SIZE); | 208 | memcpy(nodes_list[k].client_id, friends_list[i].client_list[j].client_id, CLIENT_ID_SIZE); |
238 | nodes_list[k].ip_port = friends_list[i].client_list[j].ip_port; | 209 | nodes_list[k].ip_port = friends_list[i].client_list[j].ip_port; |
239 | break; | 210 | break; |
@@ -243,12 +214,9 @@ int get_close_nodes(uint8_t * client_id, Node_format * nodes_list) | |||
243 | } | 214 | } |
244 | } | 215 | } |
245 | 216 | ||
246 | return num_nodes; | 217 | return num_nodes; |
247 | |||
248 | } | 218 | } |
249 | 219 | ||
250 | |||
251 | |||
252 | /* replace first bad (or empty) node with this one | 220 | /* replace first bad (or empty) node with this one |
253 | return 0 if successful | 221 | return 0 if successful |
254 | return 1 if not (list contains no bad nodes) */ | 222 | return 1 if not (list contains no bad nodes) */ |
@@ -256,10 +224,8 @@ int replace_bad(Client_data * list, uint32_t length, uint8_t * client_id, IP_Por | |||
256 | { | 224 | { |
257 | uint32_t i; | 225 | uint32_t i; |
258 | uint32_t temp_time = unix_time(); | 226 | uint32_t temp_time = unix_time(); |
259 | for(i = 0; i < length; ++i) | 227 | for(i = 0; i < length; ++i) { |
260 | { | 228 | if(list[i].timestamp + BAD_NODE_TIMEOUT < temp_time) /* if node is bad. */ { |
261 | if(list[i].timestamp + BAD_NODE_TIMEOUT < temp_time) /* if node is bad. */ | ||
262 | { | ||
263 | memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); | 229 | memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); |
264 | list[i].ip_port = ip_port; | 230 | list[i].ip_port = ip_port; |
265 | list[i].timestamp = temp_time; | 231 | list[i].timestamp = temp_time; |
@@ -279,10 +245,8 @@ int replace_good(Client_data * list, uint32_t length, uint8_t * client_id, IP_Po | |||
279 | uint32_t i; | 245 | uint32_t i; |
280 | uint32_t temp_time = unix_time(); | 246 | uint32_t temp_time = unix_time(); |
281 | 247 | ||
282 | for(i = 0; i < length; ++i) | 248 | for(i = 0; i < length; ++i) { |
283 | { | 249 | if(id_closest(comp_client_id, list[i].client_id, client_id) == 2) { |
284 | if(id_closest(comp_client_id, list[i].client_id, client_id) == 2) | ||
285 | { | ||
286 | memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); | 250 | memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); |
287 | list[i].ip_port = ip_port; | 251 | list[i].ip_port = ip_port; |
288 | list[i].timestamp = temp_time; | 252 | list[i].timestamp = temp_time; |
@@ -302,23 +266,16 @@ void addto_lists(IP_Port ip_port, uint8_t * client_id) | |||
302 | uint32_t i; | 266 | uint32_t i; |
303 | 267 | ||
304 | /* NOTE: current behavior if there are two clients with the same id is to replace the first ip by the second. */ | 268 | /* NOTE: current behavior if there are two clients with the same id is to replace the first ip by the second. */ |
305 | if(!client_in_list(close_clientlist, LCLIENT_LIST, client_id, ip_port)) | 269 | if(!client_in_list(close_clientlist, LCLIENT_LIST, client_id, ip_port)) { |
306 | { | ||
307 | 270 | ||
308 | if(replace_bad(close_clientlist, LCLIENT_LIST, client_id, ip_port)) | 271 | if(replace_bad(close_clientlist, LCLIENT_LIST, client_id, ip_port)) { |
309 | { | ||
310 | /* if we can't replace bad nodes we try replacing good ones */ | 272 | /* if we can't replace bad nodes we try replacing good ones */ |
311 | replace_good(close_clientlist, LCLIENT_LIST, client_id, ip_port, self_public_key); | 273 | replace_good(close_clientlist, LCLIENT_LIST, client_id, ip_port, self_public_key); |
312 | } | 274 | } |
313 | |||
314 | } | 275 | } |
315 | for(i = 0; i < num_friends; ++i) | 276 | for(i = 0; i < num_friends; ++i) { |
316 | { | 277 | if(!client_in_list(friends_list[i].client_list, MAX_FRIEND_CLIENTS, client_id, ip_port)) { |
317 | if(!client_in_list(friends_list[i].client_list, MAX_FRIEND_CLIENTS, client_id, ip_port)) | 278 | if(replace_bad(friends_list[i].client_list, MAX_FRIEND_CLIENTS, client_id, ip_port)) { |
318 | { | ||
319 | |||
320 | if(replace_bad(friends_list[i].client_list, MAX_FRIEND_CLIENTS, client_id, ip_port)) | ||
321 | { | ||
322 | /* if we can't replace bad nodes we try replacing good ones. */ | 279 | /* if we can't replace bad nodes we try replacing good ones. */ |
323 | replace_good(friends_list[i].client_list, MAX_FRIEND_CLIENTS, client_id, ip_port, friends_list[i].client_id); | 280 | replace_good(friends_list[i].client_list, MAX_FRIEND_CLIENTS, client_id, ip_port, friends_list[i].client_id); |
324 | } | 281 | } |
@@ -332,12 +289,9 @@ void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient | |||
332 | { | 289 | { |
333 | uint32_t i, j; | 290 | uint32_t i, j; |
334 | uint32_t temp_time = unix_time(); | 291 | uint32_t temp_time = unix_time(); |
335 | if(memcmp(client_id, self_public_key, CLIENT_ID_SIZE) == 0) | 292 | if(memcmp(client_id, self_public_key, CLIENT_ID_SIZE) == 0) { |
336 | { | 293 | for(i = 0; i < LCLIENT_LIST; ++i) { |
337 | for(i = 0; i < LCLIENT_LIST; ++i) | 294 | if(memcmp(nodeclient_id, close_clientlist[i].client_id, CLIENT_ID_SIZE) == 0) { |
338 | { | ||
339 | if(memcmp(nodeclient_id, close_clientlist[i].client_id, CLIENT_ID_SIZE) == 0) | ||
340 | { | ||
341 | close_clientlist[i].ret_ip_port = ip_port; | 295 | close_clientlist[i].ret_ip_port = ip_port; |
342 | close_clientlist[i].ret_timestamp = temp_time; | 296 | close_clientlist[i].ret_timestamp = temp_time; |
343 | return; | 297 | return; |
@@ -345,14 +299,10 @@ void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient | |||
345 | } | 299 | } |
346 | } | 300 | } |
347 | else | 301 | else |
348 | for(i = 0; i < num_friends; ++i) | 302 | for(i = 0; i < num_friends; ++i) { |
349 | { | 303 | if(memcmp(client_id, friends_list[i].client_id, CLIENT_ID_SIZE) == 0) { |
350 | if(memcmp(client_id, friends_list[i].client_id, CLIENT_ID_SIZE) == 0) | 304 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) { |
351 | { | 305 | if(memcmp(nodeclient_id, friends_list[i].client_list[j].client_id, CLIENT_ID_SIZE) == 0) { |
352 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) | ||
353 | { | ||
354 | if(memcmp(nodeclient_id, friends_list[i].client_list[j].client_id, CLIENT_ID_SIZE) == 0) | ||
355 | { | ||
356 | friends_list[i].client_list[j].ret_ip_port = ip_port; | 306 | friends_list[i].client_list[j].ret_ip_port = ip_port; |
357 | friends_list[i].client_list[j].ret_timestamp = temp_time; | 307 | friends_list[i].client_list[j].ret_timestamp = temp_time; |
358 | return; | 308 | return; |
@@ -364,6 +314,7 @@ void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient | |||
364 | 314 | ||
365 | /* ping timeout in seconds */ | 315 | /* ping timeout in seconds */ |
366 | #define PING_TIMEOUT 5 | 316 | #define PING_TIMEOUT 5 |
317 | |||
367 | /* check if we are currently pinging an ip_port and/or a ping_id | 318 | /* check if we are currently pinging an ip_port and/or a ping_id |
368 | variables with values of zero will not be checked. | 319 | variables with values of zero will not be checked. |
369 | if we are already, return 1 | 320 | if we are already, return 1 |
@@ -375,28 +326,22 @@ int is_pinging(IP_Port ip_port, uint64_t ping_id) | |||
375 | uint8_t pinging; | 326 | uint8_t pinging; |
376 | uint32_t temp_time = unix_time(); | 327 | uint32_t temp_time = unix_time(); |
377 | 328 | ||
378 | for(i = 0; i < LPING_ARRAY; ++i ) | 329 | for(i = 0; i < LPING_ARRAY; ++i ) { |
379 | { | 330 | if((pings[i].timestamp + PING_TIMEOUT) > temp_time) { |
380 | if((pings[i].timestamp + PING_TIMEOUT) > temp_time) | ||
381 | { | ||
382 | pinging = 0; | 331 | pinging = 0; |
383 | if(ip_port.ip.i != 0) | 332 | if(ip_port.ip.i != 0) { |
384 | { | ||
385 | if(pings[i].ip_port.ip.i == ip_port.ip.i && | 333 | if(pings[i].ip_port.ip.i == ip_port.ip.i && |
386 | pings[i].ip_port.port == ip_port.port) | 334 | pings[i].ip_port.port == ip_port.port) { |
387 | { | ||
388 | ++pinging; | 335 | ++pinging; |
389 | } | 336 | } |
390 | } | 337 | } |
391 | if(ping_id != 0) | 338 | if(ping_id != 0) { |
392 | { | ||
393 | if(pings[i].ping_id == ping_id) | 339 | if(pings[i].ping_id == ping_id) |
394 | { | 340 | { |
395 | ++pinging; | 341 | ++pinging; |
396 | } | 342 | } |
397 | } | 343 | } |
398 | if(pinging == (ping_id != 0) + (ip_port.ip.i != 0)) | 344 | if(pinging == (ping_id != 0) + (ip_port.ip.i != 0)) { |
399 | { | ||
400 | return 1; | 345 | return 1; |
401 | } | 346 | } |
402 | 347 | ||
@@ -407,7 +352,6 @@ int is_pinging(IP_Port ip_port, uint64_t ping_id) | |||
407 | 352 | ||
408 | } | 353 | } |
409 | 354 | ||
410 | |||
411 | /* Same as last function but for get_node requests. */ | 355 | /* Same as last function but for get_node requests. */ |
412 | int is_gettingnodes(IP_Port ip_port, uint64_t ping_id) | 356 | int is_gettingnodes(IP_Port ip_port, uint64_t ping_id) |
413 | { | 357 | { |
@@ -415,28 +359,21 @@ int is_gettingnodes(IP_Port ip_port, uint64_t ping_id) | |||
415 | uint8_t pinging; | 359 | uint8_t pinging; |
416 | uint32_t temp_time = unix_time(); | 360 | uint32_t temp_time = unix_time(); |
417 | 361 | ||
418 | for(i = 0; i < LSEND_NODES_ARRAY; ++i ) | 362 | for(i = 0; i < LSEND_NODES_ARRAY; ++i ) { |
419 | { | 363 | if((send_nodes[i].timestamp + PING_TIMEOUT) > temp_time) { |
420 | if((send_nodes[i].timestamp + PING_TIMEOUT) > temp_time) | ||
421 | { | ||
422 | pinging = 0; | 364 | pinging = 0; |
423 | if(ip_port.ip.i != 0) | 365 | if(ip_port.ip.i != 0) { |
424 | { | ||
425 | if(send_nodes[i].ip_port.ip.i == ip_port.ip.i && | 366 | if(send_nodes[i].ip_port.ip.i == ip_port.ip.i && |
426 | send_nodes[i].ip_port.port == ip_port.port) | 367 | send_nodes[i].ip_port.port == ip_port.port) { |
427 | { | ||
428 | ++pinging; | 368 | ++pinging; |
429 | } | 369 | } |
430 | } | 370 | } |
431 | if(ping_id != 0) | 371 | if(ping_id != 0) { |
432 | { | 372 | if(send_nodes[i].ping_id == ping_id) { |
433 | if(send_nodes[i].ping_id == ping_id) | ||
434 | { | ||
435 | ++pinging; | 373 | ++pinging; |
436 | } | 374 | } |
437 | } | 375 | } |
438 | if(pinging == (ping_id != 0) + (ip_port.ip.i != 0)) | 376 | if(pinging == (ping_id != 0) + (ip_port.ip.i != 0)) { |
439 | { | ||
440 | return 1; | 377 | return 1; |
441 | } | 378 | } |
442 | 379 | ||
@@ -447,7 +384,6 @@ int is_gettingnodes(IP_Port ip_port, uint64_t ping_id) | |||
447 | 384 | ||
448 | } | 385 | } |
449 | 386 | ||
450 | |||
451 | /* Add a new ping request to the list of ping requests | 387 | /* Add a new ping request to the list of ping requests |
452 | returns the ping_id to put in the ping request | 388 | returns the ping_id to put in the ping request |
453 | returns 0 if problem. | 389 | returns 0 if problem. |
@@ -458,12 +394,9 @@ uint64_t add_pinging(IP_Port ip_port) | |||
458 | uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int(); | 394 | uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int(); |
459 | uint32_t temp_time = unix_time(); | 395 | uint32_t temp_time = unix_time(); |
460 | 396 | ||
461 | for(i = 0; i < PING_TIMEOUT; ++i ) | 397 | for(i = 0; i < PING_TIMEOUT; ++i ) { |
462 | { | 398 | for(j = 0; j < LPING_ARRAY; ++j ) { |
463 | for(j = 0; j < LPING_ARRAY; ++j ) | 399 | if((pings[j].timestamp + PING_TIMEOUT - i) < temp_time) { |
464 | { | ||
465 | if((pings[j].timestamp + PING_TIMEOUT - i) < temp_time) | ||
466 | { | ||
467 | pings[j].timestamp = temp_time; | 400 | pings[j].timestamp = temp_time; |
468 | pings[j].ip_port = ip_port; | 401 | pings[j].ip_port = ip_port; |
469 | pings[j].ping_id = ping_id; | 402 | pings[j].ping_id = ping_id; |
@@ -482,12 +415,9 @@ uint64_t add_gettingnodes(IP_Port ip_port) | |||
482 | uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int(); | 415 | uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int(); |
483 | uint32_t temp_time = unix_time(); | 416 | uint32_t temp_time = unix_time(); |
484 | 417 | ||
485 | for(i = 0; i < PING_TIMEOUT; ++i ) | 418 | for(i = 0; i < PING_TIMEOUT; ++i ) { |
486 | { | 419 | for(j = 0; j < LSEND_NODES_ARRAY; ++j ) { |
487 | for(j = 0; j < LSEND_NODES_ARRAY; ++j ) | 420 | if((send_nodes[j].timestamp + PING_TIMEOUT - i) < temp_time) { |
488 | { | ||
489 | if((send_nodes[j].timestamp + PING_TIMEOUT - i) < temp_time) | ||
490 | { | ||
491 | send_nodes[j].timestamp = temp_time; | 421 | send_nodes[j].timestamp = temp_time; |
492 | send_nodes[j].ip_port = ip_port; | 422 | send_nodes[j].ip_port = ip_port; |
493 | send_nodes[j].ping_id = ping_id; | 423 | send_nodes[j].ping_id = ping_id; |
@@ -499,25 +429,20 @@ uint64_t add_gettingnodes(IP_Port ip_port) | |||
499 | 429 | ||
500 | } | 430 | } |
501 | 431 | ||
502 | |||
503 | |||
504 | /* send a ping request | 432 | /* send a ping request |
505 | Ping request only works if none has been sent to that ip/port in the last 5 seconds. */ | 433 | Ping request only works if none has been sent to that ip/port in the last 5 seconds. */ |
506 | static int pingreq(IP_Port ip_port, uint8_t * public_key) | 434 | static int pingreq(IP_Port ip_port, uint8_t * public_key) |
507 | { | 435 | { |
508 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is gonna be sent to ourself */ | 436 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is gonna be sent to ourself */ { |
509 | { | ||
510 | return 1; | 437 | return 1; |
511 | } | 438 | } |
512 | 439 | ||
513 | if(is_pinging(ip_port, 0)) | 440 | if(is_pinging(ip_port, 0)) { |
514 | { | ||
515 | return 1; | 441 | return 1; |
516 | } | 442 | } |
517 | 443 | ||
518 | uint64_t ping_id = add_pinging(ip_port); | 444 | uint64_t ping_id = add_pinging(ip_port); |
519 | if(ping_id == 0) | 445 | if(ping_id == 0) { |
520 | { | ||
521 | return 1; | 446 | return 1; |
522 | } | 447 | } |
523 | 448 | ||
@@ -527,8 +452,7 @@ static int pingreq(IP_Port ip_port, uint8_t * public_key) | |||
527 | random_nonce(nonce); | 452 | random_nonce(nonce); |
528 | 453 | ||
529 | int len = encrypt_data(public_key, self_secret_key, nonce, (uint8_t *)&ping_id, sizeof(ping_id), encrypt); | 454 | int len = encrypt_data(public_key, self_secret_key, nonce, (uint8_t *)&ping_id, sizeof(ping_id), encrypt); |
530 | if(len != sizeof(ping_id) + ENCRYPTION_PADDING) | 455 | if(len != sizeof(ping_id) + ENCRYPTION_PADDING) { |
531 | { | ||
532 | return -1; | 456 | return -1; |
533 | } | 457 | } |
534 | data[0] = 0; | 458 | data[0] = 0; |
@@ -540,12 +464,11 @@ static int pingreq(IP_Port ip_port, uint8_t * public_key) | |||
540 | 464 | ||
541 | } | 465 | } |
542 | 466 | ||
543 | |||
544 | /* send a ping response */ | 467 | /* send a ping response */ |
545 | static int pingres(IP_Port ip_port, uint8_t * public_key, uint64_t ping_id) | 468 | static int pingres(IP_Port ip_port, uint8_t * public_key, uint64_t ping_id) |
546 | { | 469 | { |
547 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is gonna be sent to ourself */ | 470 | /* check if packet is gonna be sent to ourself */ |
548 | { | 471 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) { |
549 | return 1; | 472 | return 1; |
550 | } | 473 | } |
551 | 474 | ||
@@ -555,8 +478,7 @@ static int pingres(IP_Port ip_port, uint8_t * public_key, uint64_t ping_id) | |||
555 | random_nonce(nonce); | 478 | random_nonce(nonce); |
556 | 479 | ||
557 | int len = encrypt_data(public_key, self_secret_key, nonce, (uint8_t *)&ping_id, sizeof(ping_id), encrypt); | 480 | int len = encrypt_data(public_key, self_secret_key, nonce, (uint8_t *)&ping_id, sizeof(ping_id), encrypt); |
558 | if(len != sizeof(ping_id) + ENCRYPTION_PADDING) | 481 | if(len != sizeof(ping_id) + ENCRYPTION_PADDING) { |
559 | { | ||
560 | return -1; | 482 | return -1; |
561 | } | 483 | } |
562 | data[0] = 1; | 484 | data[0] = 1; |
@@ -571,20 +493,18 @@ static int pingres(IP_Port ip_port, uint8_t * public_key, uint64_t ping_id) | |||
571 | /* send a getnodes request */ | 493 | /* send a getnodes request */ |
572 | static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id) | 494 | static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id) |
573 | { | 495 | { |
574 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is gonna be sent to ourself */ | 496 | /* check if packet is gonna be sent to ourself */ |
575 | { | 497 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) { |
576 | return 1; | 498 | return 1; |
577 | } | 499 | } |
578 | 500 | ||
579 | if(is_gettingnodes(ip_port, 0)) | 501 | if(is_gettingnodes(ip_port, 0)) { |
580 | { | ||
581 | return 1; | 502 | return 1; |
582 | } | 503 | } |
583 | 504 | ||
584 | uint64_t ping_id = add_gettingnodes(ip_port); | 505 | uint64_t ping_id = add_gettingnodes(ip_port); |
585 | 506 | ||
586 | if(ping_id == 0) | 507 | if(ping_id == 0) { |
587 | { | ||
588 | return 1; | 508 | return 1; |
589 | } | 509 | } |
590 | 510 | ||
@@ -599,8 +519,7 @@ static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id) | |||
599 | 519 | ||
600 | int len = encrypt_data(public_key, self_secret_key, nonce, plain, sizeof(ping_id) + CLIENT_ID_SIZE, encrypt); | 520 | int len = encrypt_data(public_key, self_secret_key, nonce, plain, sizeof(ping_id) + CLIENT_ID_SIZE, encrypt); |
601 | 521 | ||
602 | if(len != sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING) | 522 | if(len != sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING) { |
603 | { | ||
604 | return -1; | 523 | return -1; |
605 | } | 524 | } |
606 | data[0] = 2; | 525 | data[0] = 2; |
@@ -611,12 +530,10 @@ static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id) | |||
611 | 530 | ||
612 | } | 531 | } |
613 | 532 | ||
614 | |||
615 | /* send a send nodes response */ | 533 | /* send a send nodes response */ |
616 | static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id, uint64_t ping_id) | 534 | static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id, uint64_t ping_id) |
617 | { | 535 | { |
618 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is gonna be sent to ourself */ | 536 | if(memcmp(public_key, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is gonna be sent to ourself */ { |
619 | { | ||
620 | return 1; | 537 | return 1; |
621 | } | 538 | } |
622 | 539 | ||
@@ -626,8 +543,7 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id, | |||
626 | Node_format nodes_list[MAX_SENT_NODES]; | 543 | Node_format nodes_list[MAX_SENT_NODES]; |
627 | int num_nodes = get_close_nodes(client_id, nodes_list); | 544 | int num_nodes = get_close_nodes(client_id, nodes_list); |
628 | 545 | ||
629 | if(num_nodes == 0) | 546 | if(num_nodes == 0) { |
630 | { | ||
631 | return 0; | 547 | return 0; |
632 | } | 548 | } |
633 | 549 | ||
@@ -642,8 +558,7 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id, | |||
642 | int len = encrypt_data(public_key, self_secret_key, nonce, plain, | 558 | int len = encrypt_data(public_key, self_secret_key, nonce, plain, |
643 | sizeof(ping_id) + num_nodes * sizeof(Node_format), encrypt); | 559 | sizeof(ping_id) + num_nodes * sizeof(Node_format), encrypt); |
644 | 560 | ||
645 | if(len != sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING) | 561 | if(len != sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING) { |
646 | { | ||
647 | return -1; | 562 | return -1; |
648 | } | 563 | } |
649 | 564 | ||
@@ -656,20 +571,17 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id, | |||
656 | 571 | ||
657 | } | 572 | } |
658 | 573 | ||
659 | |||
660 | |||
661 | /* Packet handling functions | 574 | /* Packet handling functions |
662 | One to handle each types of packets we receive | 575 | One to handle each types of packets we receive |
663 | return 0 if handled correctly, 1 if packet is bad. */ | 576 | return 0 if handled correctly, 1 if packet is bad. */ |
664 | int handle_pingreq(uint8_t * packet, uint32_t length, IP_Port source) | 577 | int handle_pingreq(uint8_t * packet, uint32_t length, IP_Port source) |
665 | { | 578 | { |
666 | uint64_t ping_id; | 579 | uint64_t ping_id; |
667 | if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING) | 580 | if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING) { |
668 | { | ||
669 | return 1; | 581 | return 1; |
670 | } | 582 | } |
671 | if(memcmp(packet + 1, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is from ourself. */ | 583 | /* check if packet is from ourself. */ |
672 | { | 584 | if(memcmp(packet + 1, self_public_key, CLIENT_ID_SIZE) == 0) { |
673 | return 1; | 585 | return 1; |
674 | } | 586 | } |
675 | 587 | ||
@@ -678,8 +590,7 @@ int handle_pingreq(uint8_t * packet, uint32_t length, IP_Port source) | |||
678 | int len = decrypt_data(packet + 1, self_secret_key, packet + 1 + CLIENT_ID_SIZE, | 590 | int len = decrypt_data(packet + 1, self_secret_key, packet + 1 + CLIENT_ID_SIZE, |
679 | packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, | 591 | packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, |
680 | sizeof(ping_id) + ENCRYPTION_PADDING, (uint8_t *)&ping_id); | 592 | sizeof(ping_id) + ENCRYPTION_PADDING, (uint8_t *)&ping_id); |
681 | if(len != sizeof(ping_id)) | 593 | if(len != sizeof(ping_id)) { |
682 | { | ||
683 | return 1; | 594 | return 1; |
684 | } | 595 | } |
685 | 596 | ||
@@ -695,12 +606,10 @@ int handle_pingreq(uint8_t * packet, uint32_t length, IP_Port source) | |||
695 | int handle_pingres(uint8_t * packet, uint32_t length, IP_Port source) | 606 | int handle_pingres(uint8_t * packet, uint32_t length, IP_Port source) |
696 | { | 607 | { |
697 | uint64_t ping_id; | 608 | uint64_t ping_id; |
698 | if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING) | 609 | if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING) { |
699 | { | ||
700 | return 1; | 610 | return 1; |
701 | } | 611 | } |
702 | if(memcmp(packet + 1, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is from ourself. */ | 612 | if(memcmp(packet + 1, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is from ourself. */ { |
703 | { | ||
704 | return 1; | 613 | return 1; |
705 | } | 614 | } |
706 | 615 | ||
@@ -709,13 +618,11 @@ int handle_pingres(uint8_t * packet, uint32_t length, IP_Port source) | |||
709 | int len = decrypt_data(packet + 1, self_secret_key, packet + 1 + CLIENT_ID_SIZE, | 618 | int len = decrypt_data(packet + 1, self_secret_key, packet + 1 + CLIENT_ID_SIZE, |
710 | packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, | 619 | packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, |
711 | sizeof(ping_id) + ENCRYPTION_PADDING, (uint8_t *)&ping_id); | 620 | sizeof(ping_id) + ENCRYPTION_PADDING, (uint8_t *)&ping_id); |
712 | if(len != sizeof(ping_id)) | 621 | if(len != sizeof(ping_id)) { |
713 | { | ||
714 | return 1; | 622 | return 1; |
715 | } | 623 | } |
716 | 624 | ||
717 | if(is_pinging(source, ping_id)) | 625 | if(is_pinging(source, ping_id)) { |
718 | { | ||
719 | addto_lists(source, packet + 1); | 626 | addto_lists(source, packet + 1); |
720 | return 0; | 627 | return 0; |
721 | } | 628 | } |
@@ -726,12 +633,11 @@ int handle_pingres(uint8_t * packet, uint32_t length, IP_Port source) | |||
726 | int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source) | 633 | int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source) |
727 | { | 634 | { |
728 | uint64_t ping_id; | 635 | uint64_t ping_id; |
729 | if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING) | 636 | if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING) { |
730 | { | ||
731 | return 1; | 637 | return 1; |
732 | } | 638 | } |
733 | if(memcmp(packet + 1, self_public_key, CLIENT_ID_SIZE) == 0) /* check if packet is from ourself. */ | 639 | /* check if packet is from ourself. */ |
734 | { | 640 | if(memcmp(packet + 1, self_public_key, CLIENT_ID_SIZE) == 0) { |
735 | return 1; | 641 | return 1; |
736 | } | 642 | } |
737 | 643 | ||
@@ -741,8 +647,7 @@ int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source) | |||
741 | packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, | 647 | packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, |
742 | sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING, plain); | 648 | sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING, plain); |
743 | 649 | ||
744 | if(len != sizeof(ping_id) + CLIENT_ID_SIZE) | 650 | if(len != sizeof(ping_id) + CLIENT_ID_SIZE) { |
745 | { | ||
746 | return 1; | 651 | return 1; |
747 | } | 652 | } |
748 | 653 | ||
@@ -764,8 +669,7 @@ int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source) | |||
764 | (length - (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) | 669 | (length - (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) |
765 | + ENCRYPTION_PADDING)) % (sizeof(Node_format)) != 0 || | 670 | + ENCRYPTION_PADDING)) % (sizeof(Node_format)) != 0 || |
766 | length < 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) | 671 | length < 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) |
767 | + sizeof(Node_format) + ENCRYPTION_PADDING) | 672 | + sizeof(Node_format) + ENCRYPTION_PADDING) { |
768 | { | ||
769 | return 1; | 673 | return 1; |
770 | } | 674 | } |
771 | uint32_t num_nodes = (length - (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES | 675 | uint32_t num_nodes = (length - (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES |
@@ -778,14 +682,12 @@ int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source) | |||
778 | sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING, plain); | 682 | sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING, plain); |
779 | 683 | ||
780 | 684 | ||
781 | if(len != sizeof(ping_id) + num_nodes * sizeof(Node_format)) | 685 | if(len != sizeof(ping_id) + num_nodes * sizeof(Node_format)) { |
782 | { | ||
783 | return 1; | 686 | return 1; |
784 | } | 687 | } |
785 | 688 | ||
786 | memcpy(&ping_id, plain, sizeof(ping_id)); | 689 | memcpy(&ping_id, plain, sizeof(ping_id)); |
787 | if(!is_gettingnodes(source, ping_id)) | 690 | if(!is_gettingnodes(source, ping_id)) { |
788 | { | ||
789 | return 1; | 691 | return 1; |
790 | } | 692 | } |
791 | 693 | ||
@@ -795,8 +697,7 @@ int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source) | |||
795 | addto_lists(source, packet + 1); | 697 | addto_lists(source, packet + 1); |
796 | 698 | ||
797 | uint32_t i; | 699 | uint32_t i; |
798 | for(i = 0; i < num_nodes; ++i) | 700 | for(i = 0; i < num_nodes; ++i) { |
799 | { | ||
800 | pingreq(nodes_list[i].ip_port, nodes_list[i].client_id); | 701 | pingreq(nodes_list[i].ip_port, nodes_list[i].client_id); |
801 | returnedip_ports(nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1); | 702 | returnedip_ports(nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1); |
802 | } | 703 | } |
@@ -809,16 +710,12 @@ int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source) | |||
809 | int DHT_addfriend(uint8_t * client_id) | 710 | int DHT_addfriend(uint8_t * client_id) |
810 | { | 711 | { |
811 | Friend * temp; | 712 | Friend * temp; |
812 | if(num_friends == 0) | 713 | if(num_friends == 0) { |
813 | { | ||
814 | temp = malloc(sizeof(Friend)); | 714 | temp = malloc(sizeof(Friend)); |
815 | } | 715 | } else { |
816 | else | ||
817 | { | ||
818 | temp = realloc(friends_list, sizeof(Friend) * (num_friends + 1)); | 716 | temp = realloc(friends_list, sizeof(Friend) * (num_friends + 1)); |
819 | } | 717 | } |
820 | if(temp == NULL) | 718 | if(temp == NULL) { |
821 | { | ||
822 | return 1; | 719 | return 1; |
823 | } | 720 | } |
824 | 721 | ||
@@ -830,24 +727,19 @@ int DHT_addfriend(uint8_t * client_id) | |||
830 | return 0; | 727 | return 0; |
831 | } | 728 | } |
832 | 729 | ||
833 | |||
834 | |||
835 | int DHT_delfriend(uint8_t * client_id) | 730 | int DHT_delfriend(uint8_t * client_id) |
836 | { | 731 | { |
837 | uint32_t i; | 732 | uint32_t i; |
838 | Friend * temp; | 733 | Friend * temp; |
839 | for(i = 0; i < num_friends; ++i) | 734 | for(i = 0; i < num_friends; ++i) { |
840 | { | 735 | /* Equal */ |
841 | if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) /* Equal */ | 736 | if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0){ |
842 | { | ||
843 | --num_friends; | 737 | --num_friends; |
844 | if(num_friends != i) | 738 | if(num_friends != i) { |
845 | { | ||
846 | memcpy(friends_list[i].client_id, friends_list[num_friends].client_id, CLIENT_ID_SIZE); | 739 | memcpy(friends_list[i].client_id, friends_list[num_friends].client_id, CLIENT_ID_SIZE); |
847 | } | 740 | } |
848 | temp = realloc(friends_list, sizeof(Friend) * (num_friends)); | 741 | temp = realloc(friends_list, sizeof(Friend) * (num_friends)); |
849 | if(temp != NULL) | 742 | if(temp != NULL) { |
850 | { | ||
851 | friends_list = temp; | 743 | friends_list = temp; |
852 | } | 744 | } |
853 | return 0; | 745 | return 0; |
@@ -856,38 +748,28 @@ int DHT_delfriend(uint8_t * client_id) | |||
856 | return 1; | 748 | return 1; |
857 | } | 749 | } |
858 | 750 | ||
859 | |||
860 | |||
861 | |||
862 | /* TODO: Optimize this. */ | 751 | /* TODO: Optimize this. */ |
863 | IP_Port DHT_getfriendip(uint8_t * client_id) | 752 | IP_Port DHT_getfriendip(uint8_t * client_id) |
864 | { | 753 | { |
865 | uint32_t i, j; | 754 | uint32_t i, j; |
866 | IP_Port empty = {{{0}}, 0}; | 755 | IP_Port empty = {{{0}}, 0}; |
867 | uint32_t temp_time = unix_time(); | 756 | uint32_t temp_time = unix_time(); |
868 | for(i = 0; i < num_friends; ++i) | 757 | for(i = 0; i < num_friends; ++i) { |
869 | { | 758 | /* Equal */ |
870 | if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) /* Equal */ | 759 | if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0)1 { |
871 | { | 760 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) { |
872 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) | ||
873 | { | ||
874 | if(memcmp(friends_list[i].client_list[j].client_id, client_id, CLIENT_ID_SIZE) == 0 && | 761 | if(memcmp(friends_list[i].client_list[j].client_id, client_id, CLIENT_ID_SIZE) == 0 && |
875 | friends_list[i].client_list[j].timestamp + BAD_NODE_TIMEOUT > temp_time) | 762 | friends_list[i].client_list[j].timestamp + BAD_NODE_TIMEOUT > temp_time) { |
876 | { | ||
877 | return friends_list[i].client_list[j].ip_port; | 763 | return friends_list[i].client_list[j].ip_port; |
878 | } | 764 | } |
879 | 765 | } | |
880 | } | ||
881 | |||
882 | return empty; | 766 | return empty; |
883 | } | 767 | } |
884 | } | 768 | } |
885 | empty.ip.i = 1; | 769 | empty.ip.i = 1; |
886 | return empty; | 770 | return empty; |
887 | 771 | ||
888 | } | 772 | } |
889 | |||
890 | |||
891 | 773 | ||
892 | /* The timeout after which a node is discarded completely. */ | 774 | /* The timeout after which a node is discarded completely. */ |
893 | #define Kill_NODE_TIMEOUT 300 | 775 | #define Kill_NODE_TIMEOUT 300 |
@@ -900,8 +782,6 @@ IP_Port DHT_getfriendip(uint8_t * client_id) | |||
900 | 782 | ||
901 | /* Ping each client in the "friends" list every 60 seconds. | 783 | /* Ping each client in the "friends" list every 60 seconds. |
902 | Send a get nodes request every 20 seconds to a random good node for each "friend" in our "friends" list. */ | 784 | Send a get nodes request every 20 seconds to a random good node for each "friend" in our "friends" list. */ |
903 | |||
904 | |||
905 | void doDHTFriends() | 785 | void doDHTFriends() |
906 | { | 786 | { |
907 | uint32_t i, j; | 787 | uint32_t i, j; |
@@ -909,27 +789,21 @@ void doDHTFriends() | |||
909 | uint32_t rand_node; | 789 | uint32_t rand_node; |
910 | uint32_t index[MAX_FRIEND_CLIENTS]; | 790 | uint32_t index[MAX_FRIEND_CLIENTS]; |
911 | 791 | ||
912 | for(i = 0; i < num_friends; ++i) | 792 | for(i = 0; i < num_friends; ++i) { |
913 | { | ||
914 | uint32_t num_nodes = 0; | 793 | uint32_t num_nodes = 0; |
915 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) | 794 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) { |
916 | { | 795 | if(friends_list[i].client_list[j].timestamp + Kill_NODE_TIMEOUT > temp_time) /* if node is not dead. */ { |
917 | if(friends_list[i].client_list[j].timestamp + Kill_NODE_TIMEOUT > temp_time) /* if node is not dead. */ | 796 | if((friends_list[i].client_list[j].last_pinged + PING_INTERVAL) <= temp_time) { |
918 | { | ||
919 | if((friends_list[i].client_list[j].last_pinged + PING_INTERVAL) <= temp_time) | ||
920 | { | ||
921 | pingreq(friends_list[i].client_list[j].ip_port, friends_list[i].client_list[j].client_id); | 797 | pingreq(friends_list[i].client_list[j].ip_port, friends_list[i].client_list[j].client_id); |
922 | friends_list[i].client_list[j].last_pinged = temp_time; | 798 | friends_list[i].client_list[j].last_pinged = temp_time; |
923 | } | 799 | } |
924 | if(friends_list[i].client_list[j].timestamp + BAD_NODE_TIMEOUT > temp_time) /* if node is good. */ | 800 | if(friends_list[i].client_list[j].timestamp + BAD_NODE_TIMEOUT > temp_time) /* if node is good. */ { |
925 | { | ||
926 | index[num_nodes] = j; | 801 | index[num_nodes] = j; |
927 | ++num_nodes; | 802 | ++num_nodes; |
928 | } | 803 | } |
929 | } | 804 | } |
930 | } | 805 | } |
931 | if(friends_list[i].lastgetnode + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) | 806 | if(friends_list[i].lastgetnode + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) { |
932 | { | ||
933 | rand_node = rand() % num_nodes; | 807 | rand_node = rand() % num_nodes; |
934 | getnodes(friends_list[i].client_list[index[rand_node]].ip_port, | 808 | getnodes(friends_list[i].client_list[index[rand_node]].ip_port, |
935 | friends_list[i].client_list[index[rand_node]].client_id, | 809 | friends_list[i].client_list[index[rand_node]].client_id, |
@@ -951,62 +825,49 @@ void doClose() /* tested */ | |||
951 | uint32_t rand_node; | 825 | uint32_t rand_node; |
952 | uint32_t index[LCLIENT_LIST]; | 826 | uint32_t index[LCLIENT_LIST]; |
953 | 827 | ||
954 | for(i = 0; i < LCLIENT_LIST; ++i) | 828 | for(i = 0; i < LCLIENT_LIST; ++i) { |
955 | { | 829 | /* if node is not dead. */ |
956 | if(close_clientlist[i].timestamp + Kill_NODE_TIMEOUT > temp_time) /* if node is not dead. */ | 830 | if(close_clientlist[i].timestamp + Kill_NODE_TIMEOUT > temp_time) { |
957 | { | ||
958 | if((close_clientlist[i].last_pinged + PING_INTERVAL) <= temp_time) | 831 | if((close_clientlist[i].last_pinged + PING_INTERVAL) <= temp_time) |
959 | { | 832 | { |
960 | pingreq(close_clientlist[i].ip_port, close_clientlist[i].client_id); | 833 | pingreq(close_clientlist[i].ip_port, close_clientlist[i].client_id); |
961 | close_clientlist[i].last_pinged = temp_time; | 834 | close_clientlist[i].last_pinged = temp_time; |
962 | } | 835 | } |
963 | if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time) /* if node is good. */ | 836 | /* if node is good. */ |
964 | { | 837 | if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time) { |
965 | index[num_nodes] = i; | 838 | index[num_nodes] = i; |
966 | ++num_nodes; | 839 | ++num_nodes; |
967 | } | 840 | } |
968 | } | 841 | } |
969 | } | 842 | } |
970 | 843 | ||
971 | if(close_lastgetnodes + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) | 844 | if(close_lastgetnodes + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) { |
972 | { | ||
973 | rand_node = rand() % num_nodes; | 845 | rand_node = rand() % num_nodes; |
974 | getnodes(close_clientlist[index[rand_node]].ip_port, | 846 | getnodes(close_clientlist[index[rand_node]].ip_port, |
975 | close_clientlist[index[rand_node]].client_id, | 847 | close_clientlist[index[rand_node]].client_id, |
976 | self_public_key); | 848 | self_public_key); |
977 | close_lastgetnodes = temp_time; | 849 | close_lastgetnodes = temp_time; |
978 | } | 850 | } |
979 | |||
980 | } | 851 | } |
981 | 852 | ||
982 | |||
983 | |||
984 | |||
985 | |||
986 | |||
987 | void DHT_bootstrap(IP_Port ip_port, uint8_t * public_key) | 853 | void DHT_bootstrap(IP_Port ip_port, uint8_t * public_key) |
988 | { | 854 | { |
989 | getnodes(ip_port, public_key, self_public_key); | 855 | getnodes(ip_port, public_key, self_public_key); |
990 | } | 856 | } |
991 | 857 | ||
992 | |||
993 | |||
994 | /* send the given packet to node with client_id | 858 | /* send the given packet to node with client_id |
995 | returns -1 if failure */ | 859 | returns -1 if failure */ |
996 | int route_packet(uint8_t * client_id, uint8_t * packet, uint32_t length) | 860 | int route_packet(uint8_t * client_id, uint8_t * packet, uint32_t length) |
997 | { | 861 | { |
998 | uint32_t i; | 862 | uint32_t i; |
999 | for(i = 0; i < LCLIENT_LIST; ++i) | 863 | for(i = 0; i < LCLIENT_LIST; ++i) { |
1000 | { | 864 | if(memcmp(client_id, close_clientlist[i].client_id, CLIENT_ID_SIZE) == 0) { |
1001 | if(memcmp(client_id, close_clientlist[i].client_id, CLIENT_ID_SIZE) == 0) | ||
1002 | { | ||
1003 | return sendpacket(close_clientlist[i].ip_port, packet, length); | 865 | return sendpacket(close_clientlist[i].ip_port, packet, length); |
1004 | } | 866 | } |
1005 | } | 867 | } |
1006 | return -1; | 868 | return -1; |
1007 | } | 869 | } |
1008 | 870 | ||
1009 | |||
1010 | /* Puts all the different ips returned by the nodes for a friend_num into array ip_portlist | 871 | /* Puts all the different ips returned by the nodes for a friend_num into array ip_portlist |
1011 | ip_portlist must be at least MAX_FRIEND_CLIENTS big | 872 | ip_portlist must be at least MAX_FRIEND_CLIENTS big |
1012 | returns the number of ips returned | 873 | returns the number of ips returned |
@@ -1017,18 +878,15 @@ static int friend_iplist(IP_Port * ip_portlist, uint16_t friend_num) | |||
1017 | int num_ips = 0; | 878 | int num_ips = 0; |
1018 | uint32_t i; | 879 | uint32_t i; |
1019 | uint32_t temp_time = unix_time(); | 880 | uint32_t temp_time = unix_time(); |
1020 | if(friend_num >= num_friends) | 881 | if(friend_num >= num_friends) { |
1021 | { | ||
1022 | return -1; | 882 | return -1; |
1023 | } | 883 | } |
1024 | for(i = 0; i < MAX_FRIEND_CLIENTS; ++i) | 884 | for(i = 0; i < MAX_FRIEND_CLIENTS; ++i) |
1025 | { | 885 | { |
886 | /*If ip is not zero and node is good */ | ||
1026 | if(friends_list[friend_num].client_list[i].ret_ip_port.ip.i != 0 && | 887 | if(friends_list[friend_num].client_list[i].ret_ip_port.ip.i != 0 && |
1027 | friends_list[friend_num].client_list[i].ret_timestamp + BAD_NODE_TIMEOUT > temp_time) | 888 | friends_list[friend_num].client_list[i].ret_timestamp + BAD_NODE_TIMEOUT > temp_time) { |
1028 | /*If ip is not zero and node is good */ | 889 | if(memcmp(friends_list[friend_num].client_list[i].client_id, friends_list[friend_num].client_id, CLIENT_ID_SIZE) == 0 ) { |
1029 | { | ||
1030 | if(memcmp(friends_list[friend_num].client_list[i].client_id, friends_list[friend_num].client_id, CLIENT_ID_SIZE) == 0 ) | ||
1031 | { | ||
1032 | return 0; | 890 | return 0; |
1033 | } | 891 | } |
1034 | ip_portlist[num_ips] = friends_list[friend_num].client_list[i].ret_ip_port; | 892 | ip_portlist[num_ips] = friends_list[friend_num].client_list[i].ret_ip_port; |
@@ -1038,7 +896,6 @@ static int friend_iplist(IP_Port * ip_portlist, uint16_t friend_num) | |||
1038 | return num_ips; | 896 | return num_ips; |
1039 | } | 897 | } |
1040 | 898 | ||
1041 | |||
1042 | /* Send the following packet to everyone who tells us they are connected to friend_id | 899 | /* Send the following packet to everyone who tells us they are connected to friend_id |
1043 | returns the number of nodes it sent the packet to */ | 900 | returns the number of nodes it sent the packet to */ |
1044 | int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) | 901 | int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) |
@@ -1046,18 +903,14 @@ int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) | |||
1046 | uint32_t i, j; | 903 | uint32_t i, j; |
1047 | uint32_t sent = 0; | 904 | uint32_t sent = 0; |
1048 | uint32_t temp_time = unix_time(); | 905 | uint32_t temp_time = unix_time(); |
1049 | for(i = 0; i < num_friends; ++i) | 906 | for(i = 0; i < num_friends; ++i) { |
1050 | { | 907 | /* Equal */ |
1051 | if(memcmp(friends_list[i].client_id, friend_id, CLIENT_ID_SIZE) == 0) /* Equal */ | 908 | if(memcmp(friends_list[i].client_id, friend_id, CLIENT_ID_SIZE) == 0) { |
1052 | { | 909 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) { |
1053 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) | 910 | /*If ip is not zero and node is good */ |
1054 | { | ||
1055 | if(friends_list[i].client_list[j].ret_ip_port.ip.i != 0 && | 911 | if(friends_list[i].client_list[j].ret_ip_port.ip.i != 0 && |
1056 | friends_list[i].client_list[j].ret_timestamp + BAD_NODE_TIMEOUT > temp_time) | 912 | friends_list[i].client_list[j].ret_timestamp + BAD_NODE_TIMEOUT > temp_time) { |
1057 | /*If ip is not zero and node is good */ | 913 | if(sendpacket(friends_list[i].client_list[j].ip_port, packet, length) == length) { |
1058 | { | ||
1059 | if(sendpacket(friends_list[i].client_list[j].ip_port, packet, length) == length) | ||
1060 | { | ||
1061 | ++sent; | 914 | ++sent; |
1062 | } | 915 | } |
1063 | } | 916 | } |
@@ -1073,8 +926,7 @@ int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) | |||
1073 | int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) | 926 | int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) |
1074 | { | 927 | { |
1075 | int num = friend_number(friend_id); | 928 | int num = friend_number(friend_id); |
1076 | if(num == -1) | 929 | if(num == -1) { |
1077 | { | ||
1078 | return 0; | 930 | return 0; |
1079 | } | 931 | } |
1080 | 932 | ||
@@ -1082,22 +934,18 @@ int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length) | |||
1082 | int n = 0; | 934 | int n = 0; |
1083 | uint32_t i; | 935 | uint32_t i; |
1084 | uint32_t temp_time = unix_time(); | 936 | uint32_t temp_time = unix_time(); |
1085 | for(i = 0; i < MAX_FRIEND_CLIENTS; ++i) | 937 | for(i = 0; i < MAX_FRIEND_CLIENTS; ++i) { |
1086 | { | 938 | /*If ip is not zero and node is good */ |
1087 | if(friends_list[num].client_list[i].ret_ip_port.ip.i != 0 && | 939 | if(friends_list[num].client_list[i].ret_ip_port.ip.i != 0 && |
1088 | friends_list[num].client_list[i].ret_timestamp + BAD_NODE_TIMEOUT > temp_time) | 940 | friends_list[num].client_list[i].ret_timestamp + BAD_NODE_TIMEOUT > temp_time) { |
1089 | /*If ip is not zero and node is good */ | ||
1090 | { | ||
1091 | ip_list[n] = friends_list[num].client_list[i].ip_port; | 941 | ip_list[n] = friends_list[num].client_list[i].ip_port; |
1092 | ++n; | 942 | ++n; |
1093 | } | 943 | } |
1094 | } | 944 | } |
1095 | if(n < 1) | 945 | if(n < 1) { |
1096 | { | ||
1097 | return 0; | 946 | return 0; |
1098 | } | 947 | } |
1099 | if(sendpacket(ip_list[rand() % n], packet, length) == length) | 948 | if(sendpacket(ip_list[rand() % n], packet, length) == length) { |
1100 | { | ||
1101 | return 1; | 949 | return 1; |
1102 | } | 950 | } |
1103 | return 0; | 951 | return 0; |
@@ -1112,10 +960,9 @@ int friend_ips(IP_Port * ip_portlist, uint8_t * friend_id) | |||
1112 | { | 960 | { |
1113 | 961 | ||
1114 | uint32_t i; | 962 | uint32_t i; |
1115 | for(i = 0; i < num_friends; ++i) | 963 | for(i = 0; i < num_friends; ++i) { |
1116 | { | 964 | /* Equal */ |
1117 | if(memcmp(friends_list[i].client_id, friend_id, CLIENT_ID_SIZE) == 0) /* Equal */ | 965 | if(memcmp(friends_list[i].client_id, friend_id, CLIENT_ID_SIZE) == 0) { |
1118 | { | ||
1119 | return friend_iplist(ip_portlist, i); | 966 | return friend_iplist(ip_portlist, i); |
1120 | } | 967 | } |
1121 | } | 968 | } |
@@ -1132,60 +979,49 @@ int send_NATping(uint8_t * public_key, uint64_t ping_id, uint8_t type) | |||
1132 | 979 | ||
1133 | uint8_t packet[MAX_DATA_SIZE]; | 980 | uint8_t packet[MAX_DATA_SIZE]; |
1134 | int len = create_request(packet, public_key, data, sizeof(uint64_t) + 1, 254); /* 254 is NAT ping request packet id */ | 981 | int len = create_request(packet, public_key, data, sizeof(uint64_t) + 1, 254); /* 254 is NAT ping request packet id */ |
1135 | if(len == -1) | 982 | if(len == -1) { |
1136 | { | ||
1137 | return -1; | 983 | return -1; |
1138 | } | 984 | } |
1139 | int num = 0; | 985 | int num = 0; |
1140 | if(type == 0) | 986 | if(type == 0) { |
1141 | { | ||
1142 | num = route_tofriend(public_key, packet, len);/*If packet is request use many people to route it*/ | 987 | num = route_tofriend(public_key, packet, len);/*If packet is request use many people to route it*/ |
1143 | } | 988 | } |
1144 | else if(type == 1) | 989 | else if(type == 1) { |
1145 | { | ||
1146 | num = routeone_tofriend(public_key, packet, len);/*If packet is response use only one person to route it*/ | 990 | num = routeone_tofriend(public_key, packet, len);/*If packet is response use only one person to route it*/ |
1147 | } | 991 | } |
1148 | if(num == 0) | 992 | if(num == 0) { |
1149 | { | ||
1150 | return -1; | 993 | return -1; |
1151 | } | 994 | } |
1152 | return num; | 995 | return num; |
1153 | } | 996 | } |
1154 | 997 | ||
1155 | |||
1156 | /* Handle a recieved ping request for */ | 998 | /* Handle a recieved ping request for */ |
1157 | int handle_NATping(uint8_t * packet, uint32_t length, IP_Port source) | 999 | int handle_NATping(uint8_t * packet, uint32_t length, IP_Port source) |
1158 | { | 1000 | { |
1159 | if(length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING && | 1001 | if(length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING && |
1160 | length > MAX_DATA_SIZE + ENCRYPTION_PADDING) | 1002 | length > MAX_DATA_SIZE + ENCRYPTION_PADDING) { |
1161 | { | ||
1162 | return 1; | 1003 | return 1; |
1163 | } | 1004 | } |
1164 | if(memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)//check if request is for us. | 1005 | /* check if request is for us. */ |
1165 | { | 1006 | if(memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) == 0) { |
1166 | uint8_t public_key[crypto_box_PUBLICKEYBYTES]; | 1007 | uint8_t public_key[crypto_box_PUBLICKEYBYTES]; |
1167 | uint8_t data[MAX_DATA_SIZE]; | 1008 | uint8_t data[MAX_DATA_SIZE]; |
1168 | int len = handle_request(public_key, data, packet, length); | 1009 | int len = handle_request(public_key, data, packet, length); |
1169 | if(len != sizeof(uint64_t) + 1) | 1010 | if(len != sizeof(uint64_t) + 1) { |
1170 | { | ||
1171 | return 1; | 1011 | return 1; |
1172 | } | 1012 | } |
1173 | uint64_t ping_id; | 1013 | uint64_t ping_id; |
1174 | memcpy(&ping_id, data + 1, sizeof(uint64_t)); | 1014 | memcpy(&ping_id, data + 1, sizeof(uint64_t)); |
1175 | 1015 | ||
1176 | int friendnumber = friend_number(public_key); | 1016 | int friendnumber = friend_number(public_key); |
1177 | if(friendnumber == -1) | 1017 | if(friendnumber == -1) { |
1178 | { | ||
1179 | return 1; | 1018 | return 1; |
1180 | } | 1019 | } |
1181 | 1020 | ||
1182 | if(data[0] == 0) | 1021 | if(data[0] == 0) { |
1183 | { | ||
1184 | send_NATping(public_key, ping_id, 1);/*1 is reply*/ | 1022 | send_NATping(public_key, ping_id, 1);/*1 is reply*/ |
1185 | return 0; | 1023 | return 0; |
1186 | } | 1024 | } else if (data[0] == 1) { |
1187 | else if (data[0] == 1) | ||
1188 | { | ||
1189 | if(friends_list[friendnumber].NATping_id == ping_id) | 1025 | if(friends_list[friendnumber].NATping_id == ping_id) |
1190 | { | 1026 | { |
1191 | friends_list[friendnumber].NATping_id = ((uint64_t)random_int() << 32) + random_int(); | 1027 | friends_list[friendnumber].NATping_id = ((uint64_t)random_int() << 32) + random_int(); |
@@ -1195,10 +1031,9 @@ int handle_NATping(uint8_t * packet, uint32_t length, IP_Port source) | |||
1195 | } | 1031 | } |
1196 | return 1; | 1032 | return 1; |
1197 | } | 1033 | } |
1198 | else//if request is not for us, try routing it. | 1034 | /* if request is not for us, try routing it. */ |
1199 | { | 1035 | else { |
1200 | if(route_packet(packet + 1, packet, length) == length) | 1036 | if(route_packet(packet + 1, packet, length) == length) { |
1201 | { | ||
1202 | return 0; | 1037 | return 0; |
1203 | } | 1038 | } |
1204 | } | 1039 | } |
@@ -1212,24 +1047,19 @@ int handle_NATping(uint8_t * packet, uint32_t length, IP_Port source) | |||
1212 | static IP NAT_commonip(IP_Port * ip_portlist, uint16_t len, uint16_t min_num) | 1047 | static IP NAT_commonip(IP_Port * ip_portlist, uint16_t len, uint16_t min_num) |
1213 | { | 1048 | { |
1214 | IP zero = {{0}}; | 1049 | IP zero = {{0}}; |
1215 | if(len > MAX_FRIEND_CLIENTS) | 1050 | if(len > MAX_FRIEND_CLIENTS) { |
1216 | { | ||
1217 | return zero; | 1051 | return zero; |
1218 | } | 1052 | } |
1219 | 1053 | ||
1220 | uint32_t i, j; | 1054 | uint32_t i, j; |
1221 | uint16_t numbers[MAX_FRIEND_CLIENTS] = {0}; | 1055 | uint16_t numbers[MAX_FRIEND_CLIENTS] = {0}; |
1222 | for(i = 0; i < len; ++i) | 1056 | for(i = 0; i < len; ++i) { |
1223 | { | 1057 | for(j = 0; j < len; ++j) { |
1224 | for(j = 0; j < len; ++j) | 1058 | if(ip_portlist[i].ip.i == ip_portlist[j].ip.i) { |
1225 | { | ||
1226 | if(ip_portlist[i].ip.i == ip_portlist[j].ip.i) | ||
1227 | { | ||
1228 | ++numbers[i]; | 1059 | ++numbers[i]; |
1229 | } | 1060 | } |
1230 | } | 1061 | } |
1231 | if(numbers[i] >= min_num) | 1062 | if(numbers[i] >= min_num) { |
1232 | { | ||
1233 | return ip_portlist[i].ip; | 1063 | return ip_portlist[i].ip; |
1234 | } | 1064 | } |
1235 | } | 1065 | } |
@@ -1244,10 +1074,8 @@ static uint16_t NAT_getports(uint16_t * portlist, IP_Port * ip_portlist, uint16_ | |||
1244 | { | 1074 | { |
1245 | uint32_t i; | 1075 | uint32_t i; |
1246 | uint16_t num = 0; | 1076 | uint16_t num = 0; |
1247 | for(i = 0; i < len; ++i) | 1077 | for(i = 0; i < len; ++i) { |
1248 | { | 1078 | if(ip_portlist[i].ip.i == ip.i) { |
1249 | if(ip_portlist[i].ip.i == ip.i) | ||
1250 | { | ||
1251 | portlist[num] = ntohs(ip_portlist[i].port); | 1079 | portlist[num] = ntohs(ip_portlist[i].port); |
1252 | ++num; | 1080 | ++num; |
1253 | } | 1081 | } |
@@ -1259,14 +1087,12 @@ static uint16_t NAT_getports(uint16_t * portlist, IP_Port * ip_portlist, uint16_ | |||
1259 | 1087 | ||
1260 | static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t friend_num) | 1088 | static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t friend_num) |
1261 | { | 1089 | { |
1262 | if(numports > MAX_FRIEND_CLIENTS || numports == 0) | 1090 | if(numports > MAX_FRIEND_CLIENTS || numports == 0) { |
1263 | { | ||
1264 | return; | 1091 | return; |
1265 | } | 1092 | } |
1266 | uint32_t i; | 1093 | uint32_t i; |
1267 | uint32_t top = friends_list[friend_num].punching_index + MAX_PUNCHING_PORTS; | 1094 | uint32_t top = friends_list[friend_num].punching_index + MAX_PUNCHING_PORTS; |
1268 | for(i = friends_list[friend_num].punching_index; i != top; i++) | 1095 | for(i = friends_list[friend_num].punching_index; i != top; i++) { |
1269 | { | ||
1270 | /*TODO: improve port guessing algorithm*/ | 1096 | /*TODO: improve port guessing algorithm*/ |
1271 | uint16_t port = port_list[(i/2) % numports] + (i/(2*numports))*((i % 2) ? -1 : 1); | 1097 | uint16_t port = port_list[(i/2) % numports] + (i/(2*numports))*((i % 2) ? -1 : 1); |
1272 | IP_Port pinging = {ip, htons(port)}; | 1098 | IP_Port pinging = {ip, htons(port)}; |
@@ -1282,28 +1108,22 @@ static void doNAT() | |||
1282 | { | 1108 | { |
1283 | uint32_t i; | 1109 | uint32_t i; |
1284 | uint32_t temp_time = unix_time(); | 1110 | uint32_t temp_time = unix_time(); |
1285 | for(i = 0; i < num_friends; ++i) | 1111 | for(i = 0; i < num_friends; ++i) { |
1286 | { | ||
1287 | IP_Port ip_list[MAX_FRIEND_CLIENTS]; | 1112 | IP_Port ip_list[MAX_FRIEND_CLIENTS]; |
1288 | int num = friend_iplist(ip_list, i); | 1113 | int num = friend_iplist(ip_list, i); |
1289 | /*If we are connected to friend or if friend is not online don't try to hole punch with him*/ | 1114 | /*If we are connected to friend or if friend is not online don't try to hole punch with him*/ |
1290 | if(num < MAX_FRIEND_CLIENTS/2) | 1115 | if(num < MAX_FRIEND_CLIENTS/2) { |
1291 | { | ||
1292 | continue; | 1116 | continue; |
1293 | } | 1117 | } |
1294 | if(friends_list[i].hole_punching != 1) | 1118 | if(friends_list[i].hole_punching != 1) { |
1295 | { | 1119 | if(friends_list[i].NATping_timestamp + PUNCH_INTERVAL < temp_time) { |
1296 | if(friends_list[i].NATping_timestamp + PUNCH_INTERVAL < temp_time) | ||
1297 | { | ||
1298 | send_NATping(friends_list[i].client_id, friends_list[i].NATping_id, 0); /*0 is request*/ | 1120 | send_NATping(friends_list[i].client_id, friends_list[i].NATping_id, 0); /*0 is request*/ |
1299 | friends_list[i].NATping_timestamp = temp_time; | 1121 | friends_list[i].NATping_timestamp = temp_time; |
1300 | } | 1122 | } |
1301 | } | 1123 | } |
1302 | else if(friends_list[i].punching_timestamp + PUNCH_INTERVAL < temp_time) | 1124 | else if(friends_list[i].punching_timestamp + PUNCH_INTERVAL < temp_time) { |
1303 | { | ||
1304 | IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS/2); | 1125 | IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS/2); |
1305 | if(ip.i == 0) | 1126 | if(ip.i == 0) { |
1306 | { | ||
1307 | continue; | 1127 | continue; |
1308 | } | 1128 | } |
1309 | uint16_t port_list[MAX_FRIEND_CLIENTS]; | 1129 | uint16_t port_list[MAX_FRIEND_CLIENTS]; |
@@ -1318,7 +1138,6 @@ static void doNAT() | |||
1318 | 1138 | ||
1319 | /*END OF NAT PUNCHING FUNCTIONS*/ | 1139 | /*END OF NAT PUNCHING FUNCTIONS*/ |
1320 | 1140 | ||
1321 | |||
1322 | int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) | 1141 | int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) |
1323 | { | 1142 | { |
1324 | switch (packet[0]) { | 1143 | switch (packet[0]) { |
@@ -1346,7 +1165,6 @@ int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) | |||
1346 | 1165 | ||
1347 | } | 1166 | } |
1348 | 1167 | ||
1349 | |||
1350 | void doDHT() | 1168 | void doDHT() |
1351 | { | 1169 | { |
1352 | doClose(); | 1170 | doClose(); |
@@ -1354,8 +1172,6 @@ void doDHT() | |||
1354 | doNAT(); | 1172 | doNAT(); |
1355 | } | 1173 | } |
1356 | 1174 | ||
1357 | |||
1358 | |||
1359 | /* get the size of the DHT (for saving) */ | 1175 | /* get the size of the DHT (for saving) */ |
1360 | uint32_t DHT_size() | 1176 | uint32_t DHT_size() |
1361 | { | 1177 | { |
@@ -1374,12 +1190,10 @@ void DHT_save(uint8_t * data) | |||
1374 | return 0 if success */ | 1190 | return 0 if success */ |
1375 | int DHT_load(uint8_t * data, uint32_t size) | 1191 | int DHT_load(uint8_t * data, uint32_t size) |
1376 | { | 1192 | { |
1377 | if(size < sizeof(close_clientlist)) | 1193 | if(size < sizeof(close_clientlist)) { |
1378 | { | ||
1379 | return -1; | 1194 | return -1; |
1380 | } | 1195 | } |
1381 | if((size - sizeof(close_clientlist)) % sizeof(Friend) != 0) | 1196 | if((size - sizeof(close_clientlist)) % sizeof(Friend) != 0) { |
1382 | { | ||
1383 | return -1; | 1197 | return -1; |
1384 | } | 1198 | } |
1385 | uint32_t i, j; | 1199 | uint32_t i, j; |
@@ -1388,17 +1202,13 @@ int DHT_load(uint8_t * data, uint32_t size) | |||
1388 | 1202 | ||
1389 | temp = (size - sizeof(close_clientlist))/sizeof(Friend); | 1203 | temp = (size - sizeof(close_clientlist))/sizeof(Friend); |
1390 | 1204 | ||
1391 | if(temp != 0) | 1205 | if(temp != 0) { |
1392 | { | ||
1393 | Friend * tempfriends_list = (Friend *)(data + sizeof(close_clientlist)); | 1206 | Friend * tempfriends_list = (Friend *)(data + sizeof(close_clientlist)); |
1394 | 1207 | ||
1395 | for(i = 0; i < temp; ++i) | 1208 | for(i = 0; i < temp; ++i) { |
1396 | { | ||
1397 | DHT_addfriend(tempfriends_list[i].client_id); | 1209 | DHT_addfriend(tempfriends_list[i].client_id); |
1398 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) | 1210 | for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) { |
1399 | { | 1211 | if(tempfriends_list[i].client_list[j].timestamp != 0) { |
1400 | if(tempfriends_list[i].client_list[j].timestamp != 0) | ||
1401 | { | ||
1402 | getnodes(tempfriends_list[i].client_list[j].ip_port, | 1212 | getnodes(tempfriends_list[i].client_list[j].ip_port, |
1403 | tempfriends_list[i].client_list[j].client_id, tempfriends_list[i].client_id); | 1213 | tempfriends_list[i].client_list[j].client_id, tempfriends_list[i].client_id); |
1404 | } | 1214 | } |
@@ -1407,10 +1217,8 @@ int DHT_load(uint8_t * data, uint32_t size) | |||
1407 | } | 1217 | } |
1408 | Client_data * tempclose_clientlist = (Client_data *)data; | 1218 | Client_data * tempclose_clientlist = (Client_data *)data; |
1409 | 1219 | ||
1410 | for(i = 0; i < LCLIENT_LIST; ++i) | 1220 | for(i = 0; i < LCLIENT_LIST; ++i) { |
1411 | { | 1221 | if(tempclose_clientlist[i].timestamp != 0) { |
1412 | if(tempclose_clientlist[i].timestamp != 0) | ||
1413 | { | ||
1414 | DHT_bootstrap(tempclose_clientlist[i].ip_port, tempclose_clientlist[i].client_id); | 1222 | DHT_bootstrap(tempclose_clientlist[i].ip_port, tempclose_clientlist[i].client_id); |
1415 | } | 1223 | } |
1416 | } | 1224 | } |
@@ -1423,13 +1231,10 @@ int DHT_isconnected() | |||
1423 | { | 1231 | { |
1424 | uint32_t i; | 1232 | uint32_t i; |
1425 | uint32_t temp_time = unix_time(); | 1233 | uint32_t temp_time = unix_time(); |
1426 | for(i = 0; i < LCLIENT_LIST; ++i) | 1234 | for(i = 0; i < LCLIENT_LIST; ++i) { |
1427 | { | 1235 | if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time) { |
1428 | if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time) | ||
1429 | { | ||
1430 | return 1; | 1236 | return 1; |
1431 | } | 1237 | } |
1432 | } | 1238 | } |
1433 | return 0; | 1239 | return 0; |
1434 | } | 1240 | } \ No newline at end of file |
1435 | |||
@@ -21,7 +21,6 @@ | |||
21 | * | 21 | * |
22 | */ | 22 | */ |
23 | 23 | ||
24 | |||
25 | #ifndef DHT_H | 24 | #ifndef DHT_H |
26 | #define DHT_H | 25 | #define DHT_H |
27 | 26 | ||
@@ -37,8 +36,6 @@ extern "C" { | |||
37 | /* size of the client_id in bytes */ | 36 | /* size of the client_id in bytes */ |
38 | #define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES | 37 | #define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES |
39 | 38 | ||
40 | |||
41 | |||
42 | /* Add a new friend to the friends list | 39 | /* Add a new friend to the friends list |
43 | client_id must be CLIENT_ID_SIZE bytes long. | 40 | client_id must be CLIENT_ID_SIZE bytes long. |
44 | returns 0 if success | 41 | returns 0 if success |
@@ -51,7 +48,6 @@ int DHT_addfriend(uint8_t * client_id); | |||
51 | returns 1 if failure (client_id not in friends list) */ | 48 | returns 1 if failure (client_id not in friends list) */ |
52 | int DHT_delfriend(uint8_t * client_id); | 49 | int DHT_delfriend(uint8_t * client_id); |
53 | 50 | ||
54 | |||
55 | /* Get ip of friend | 51 | /* Get ip of friend |
56 | client_id must be CLIENT_ID_SIZE bytes long. | 52 | client_id must be CLIENT_ID_SIZE bytes long. |
57 | ip must be 4 bytes long. | 53 | ip must be 4 bytes long. |
@@ -61,7 +57,6 @@ int DHT_delfriend(uint8_t * client_id); | |||
61 | returns ip of 1 if friend is not in list. */ | 57 | returns ip of 1 if friend is not in list. */ |
62 | IP_Port DHT_getfriendip(uint8_t * client_id); | 58 | IP_Port DHT_getfriendip(uint8_t * client_id); |
63 | 59 | ||
64 | |||
65 | /* Run this function at least a couple times per second (It's the main loop) */ | 60 | /* Run this function at least a couple times per second (It's the main loop) */ |
66 | void doDHT(); | 61 | void doDHT(); |
67 | 62 | ||
@@ -74,8 +69,6 @@ int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source); | |||
74 | Sends a get nodes request to the given node with ip port and public_key */ | 69 | Sends a get nodes request to the given node with ip port and public_key */ |
75 | void DHT_bootstrap(IP_Port ip_port, uint8_t * public_key); | 70 | void DHT_bootstrap(IP_Port ip_port, uint8_t * public_key); |
76 | 71 | ||
77 | |||
78 | |||
79 | /* ROUTING FUNCTIONS */ | 72 | /* ROUTING FUNCTIONS */ |
80 | 73 | ||
81 | /* send the given packet to node with client_id | 74 | /* send the given packet to node with client_id |
@@ -86,8 +79,6 @@ int route_packet(uint8_t * client_id, uint8_t * packet, uint32_t length); | |||
86 | returns the number of nodes it sent the packet to */ | 79 | returns the number of nodes it sent the packet to */ |
87 | int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length); | 80 | int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length); |
88 | 81 | ||
89 | |||
90 | |||
91 | /* NAT PUNCHING FUNCTIONS */ | 82 | /* NAT PUNCHING FUNCTIONS */ |
92 | 83 | ||
93 | /* Puts all the different ips returned by the nodes for a friend_id into array ip_portlist | 84 | /* Puts all the different ips returned by the nodes for a friend_id into array ip_portlist |
@@ -96,8 +87,6 @@ int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length); | |||
96 | returns -1 if no such friend*/ | 87 | returns -1 if no such friend*/ |
97 | int friend_ips(IP_Port * ip_portlist, uint8_t * friend_id); | 88 | int friend_ips(IP_Port * ip_portlist, uint8_t * friend_id); |
98 | 89 | ||
99 | |||
100 | |||
101 | /* SAVE/LOAD functions */ | 90 | /* SAVE/LOAD functions */ |
102 | 91 | ||
103 | /* get the size of the DHT (for saving) */ | 92 | /* get the size of the DHT (for saving) */ |
diff --git a/core/Lossless_UDP.c b/core/Lossless_UDP.c index 47d63a71..83bb1785 100644 --- a/core/Lossless_UDP.c +++ b/core/Lossless_UDP.c | |||
@@ -25,8 +25,6 @@ | |||
25 | There are a couple of useless variables to get rid of. */ | 25 | There are a couple of useless variables to get rid of. */ |
26 | #include "Lossless_UDP.h" | 26 | #include "Lossless_UDP.h" |
27 | 27 | ||
28 | |||
29 | |||
30 | /* maximum data packets in sent and receive queues. */ | 28 | /* maximum data packets in sent and receive queues. */ |
31 | #define MAX_QUEUE_NUM 16 | 29 | #define MAX_QUEUE_NUM 16 |
32 | 30 | ||
@@ -88,7 +86,6 @@ typedef struct | |||
88 | uint8_t timeout; /* connection timeout in seconds. */ | 86 | uint8_t timeout; /* connection timeout in seconds. */ |
89 | }Connection; | 87 | }Connection; |
90 | 88 | ||
91 | |||
92 | #define MAX_CONNECTIONS 256 | 89 | #define MAX_CONNECTIONS 256 |
93 | 90 | ||
94 | static Connection connections[MAX_CONNECTIONS]; | 91 | static Connection connections[MAX_CONNECTIONS]; |
@@ -117,7 +114,6 @@ int getconnection_id(IP_Port ip_port) | |||
117 | /* table of random numbers used below. */ | 114 | /* table of random numbers used below. */ |
118 | static uint32_t randtable[6][256]; | 115 | static uint32_t randtable[6][256]; |
119 | 116 | ||
120 | |||
121 | /* generate a handshake_id which depends on the ip_port. | 117 | /* generate a handshake_id which depends on the ip_port. |
122 | this function will always give one unique handshake_id per ip_port. | 118 | this function will always give one unique handshake_id per ip_port. |
123 | TODO: make this better */ | 119 | TODO: make this better */ |
@@ -138,6 +134,7 @@ uint32_t handshake_id(IP_Port source) | |||
138 | } | 134 | } |
139 | return id; | 135 | return id; |
140 | } | 136 | } |
137 | |||
141 | /* change the hnshake id associated with that ip_port | 138 | /* change the hnshake id associated with that ip_port |
142 | TODO: make this better */ | 139 | TODO: make this better */ |
143 | void change_handshake(IP_Port source) | 140 | void change_handshake(IP_Port source) |
@@ -146,7 +143,6 @@ void change_handshake(IP_Port source) | |||
146 | randtable[rand][((uint8_t *)&source)[rand]] = random_int(); | 143 | randtable[rand][((uint8_t *)&source)[rand]] = random_int(); |
147 | } | 144 | } |
148 | 145 | ||
149 | |||
150 | /* initialize a new connection to ip_port | 146 | /* initialize a new connection to ip_port |
151 | returns an integer corresponding to the connection id. | 147 | returns an integer corresponding to the connection id. |
152 | return -1 if it could not initialize the connection. | 148 | return -1 if it could not initialize the connection. |
@@ -314,6 +310,7 @@ char id_packet(int connection_id) | |||
314 | } | 310 | } |
315 | return -1; | 311 | return -1; |
316 | } | 312 | } |
313 | |||
317 | /* return 0 if there is no received data in the buffer. | 314 | /* return 0 if there is no received data in the buffer. |
318 | return length of received packet if successful */ | 315 | return length of received packet if successful */ |
319 | int read_packet(int connection_id, uint8_t * data) | 316 | int read_packet(int connection_id, uint8_t * data) |
@@ -353,9 +350,6 @@ int write_packet(int connection_id, uint8_t * data, uint32_t length) | |||
353 | return 0; | 350 | return 0; |
354 | } | 351 | } |
355 | 352 | ||
356 | |||
357 | |||
358 | |||
359 | /* put the packet numbers the we are missing in requested and return the number */ | 353 | /* put the packet numbers the we are missing in requested and return the number */ |
360 | uint32_t missing_packets(int connection_id, uint32_t * requested) | 354 | uint32_t missing_packets(int connection_id, uint32_t * requested) |
361 | { | 355 | { |
@@ -386,8 +380,6 @@ uint32_t missing_packets(int connection_id, uint32_t * requested) | |||
386 | /* Packet sending functions | 380 | /* Packet sending functions |
387 | One per packet type. | 381 | One per packet type. |
388 | see docs/Lossless_UDP.txt for more information. */ | 382 | see docs/Lossless_UDP.txt for more information. */ |
389 | |||
390 | |||
391 | int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t handshake_id2) | 383 | int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t handshake_id2) |
392 | { | 384 | { |
393 | uint8_t packet[1 + 4 + 4]; | 385 | uint8_t packet[1 + 4 + 4]; |
@@ -402,7 +394,6 @@ int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t handshake_i | |||
402 | 394 | ||
403 | } | 395 | } |
404 | 396 | ||
405 | |||
406 | int send_SYNC(uint32_t connection_id) | 397 | int send_SYNC(uint32_t connection_id) |
407 | { | 398 | { |
408 | 399 | ||
@@ -468,8 +459,6 @@ int send_DATA(uint32_t connection_id) | |||
468 | 459 | ||
469 | /* END of packet sending functions */ | 460 | /* END of packet sending functions */ |
470 | 461 | ||
471 | |||
472 | |||
473 | /* Packet handling functions | 462 | /* Packet handling functions |
474 | One to handle each type of packets we receive | 463 | One to handle each type of packets we receive |
475 | return 0 if handled correctly, 1 if packet is bad. */ | 464 | return 0 if handled correctly, 1 if packet is bad. */ |
@@ -700,7 +689,6 @@ int handle_data(uint8_t * packet, uint32_t length, IP_Port source) | |||
700 | 689 | ||
701 | /* END of packet handling functions */ | 690 | /* END of packet handling functions */ |
702 | 691 | ||
703 | |||
704 | int LosslessUDP_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) | 692 | int LosslessUDP_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) |
705 | { | 693 | { |
706 | 694 | ||
@@ -828,6 +816,7 @@ void adjustRates() | |||
828 | } | 816 | } |
829 | } | 817 | } |
830 | } | 818 | } |
819 | |||
831 | /* Call this function a couple times per second | 820 | /* Call this function a couple times per second |
832 | It's the main loop. */ | 821 | It's the main loop. */ |
833 | void doLossless_UDP() | 822 | void doLossless_UDP() |
diff --git a/core/Lossless_UDP.h b/core/Lossless_UDP.h index 4b156301..a9f1bb15 100644 --- a/core/Lossless_UDP.h +++ b/core/Lossless_UDP.h | |||
@@ -33,8 +33,6 @@ extern "C" { | |||
33 | /* maximum length of the data in the data packets */ | 33 | /* maximum length of the data in the data packets */ |
34 | #define MAX_DATA_SIZE 1024 | 34 | #define MAX_DATA_SIZE 1024 |
35 | 35 | ||
36 | |||
37 | |||
38 | /* Functions */ | 36 | /* Functions */ |
39 | 37 | ||
40 | /* initialize a new connection to ip_port | 38 | /* initialize a new connection to ip_port |
@@ -52,7 +50,6 @@ int getconnection_id(IP_Port ip_port); | |||
52 | return -1 if there are no new incoming connections in the list. */ | 50 | return -1 if there are no new incoming connections in the list. */ |
53 | int incoming_connection(); | 51 | int incoming_connection(); |
54 | 52 | ||
55 | |||
56 | /* return -1 if it could not kill the connection. | 53 | /* return -1 if it could not kill the connection. |
57 | return 0 if killed successfully */ | 54 | return 0 if killed successfully */ |
58 | int kill_connection(int connection_id); | 55 | int kill_connection(int connection_id); |
@@ -74,21 +71,16 @@ char id_packet(int connection_id); | |||
74 | return length of received packet if successful */ | 71 | return length of received packet if successful */ |
75 | int read_packet(int connection_id, uint8_t * data); | 72 | int read_packet(int connection_id, uint8_t * data); |
76 | 73 | ||
77 | |||
78 | /* return 0 if data could not be put in packet queue | 74 | /* return 0 if data could not be put in packet queue |
79 | return 1 if data was put into the queue */ | 75 | return 1 if data was put into the queue */ |
80 | int write_packet(int connection_id, uint8_t * data, uint32_t length); | 76 | int write_packet(int connection_id, uint8_t * data, uint32_t length); |
81 | 77 | ||
82 | |||
83 | |||
84 | /* returns the number of packets in the queue waiting to be successfully sent. */ | 78 | /* returns the number of packets in the queue waiting to be successfully sent. */ |
85 | uint32_t sendqueue(int connection_id); | 79 | uint32_t sendqueue(int connection_id); |
86 | 80 | ||
87 | |||
88 | /* returns the number of packets in the queue waiting to be successfully read with read_packet(...) */ | 81 | /* returns the number of packets in the queue waiting to be successfully read with read_packet(...) */ |
89 | uint32_t recvqueue(int connection_id); | 82 | uint32_t recvqueue(int connection_id); |
90 | 83 | ||
91 | |||
92 | /* check if connection is connected | 84 | /* check if connection is connected |
93 | return 0 no. | 85 | return 0 no. |
94 | return 1 if attempting handshake | 86 | return 1 if attempting handshake |
@@ -97,7 +89,6 @@ uint32_t recvqueue(int connection_id); | |||
97 | return 4 if timed out and wating to be killed */ | 89 | return 4 if timed out and wating to be killed */ |
98 | int is_connected(int connection_id); | 90 | int is_connected(int connection_id); |
99 | 91 | ||
100 | |||
101 | /* Call this function a couple times per second | 92 | /* Call this function a couple times per second |
102 | It's the main loop. */ | 93 | It's the main loop. */ |
103 | void doLossless_UDP(); | 94 | void doLossless_UDP(); |
diff --git a/core/Messenger.c b/core/Messenger.c index 11613cbb..d58e895c 100644 --- a/core/Messenger.c +++ b/core/Messenger.c | |||
@@ -38,8 +38,6 @@ typedef struct | |||
38 | uint8_t userstatus_sent; | 38 | uint8_t userstatus_sent; |
39 | uint16_t info_size; /* length of the info */ | 39 | uint16_t info_size; /* length of the info */ |
40 | }Friend; | 40 | }Friend; |
41 | |||
42 | |||
43 | 41 | ||
44 | uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; | 42 | uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; |
45 | 43 | ||
@@ -57,7 +55,6 @@ static uint32_t numfriends; | |||
57 | 0 if we are offline | 55 | 0 if we are offline |
58 | static uint8_t online; */ | 56 | static uint8_t online; */ |
59 | 57 | ||
60 | |||
61 | /* return the friend id associated to that public key. | 58 | /* return the friend id associated to that public key. |
62 | return -1 if no such friend */ | 59 | return -1 if no such friend */ |
63 | int getfriend_id(uint8_t * client_id) | 60 | int getfriend_id(uint8_t * client_id) |
@@ -76,7 +73,6 @@ int getfriend_id(uint8_t * client_id) | |||
76 | return -1; | 73 | return -1; |
77 | } | 74 | } |
78 | 75 | ||
79 | |||
80 | /* copies the public key associated to that friend id into client_id buffer. | 76 | /* copies the public key associated to that friend id into client_id buffer. |
81 | make sure that client_id is of size CLIENT_ID_SIZE. | 77 | make sure that client_id is of size CLIENT_ID_SIZE. |
82 | return 0 if success | 78 | return 0 if success |
@@ -96,7 +92,6 @@ int getclient_id(int friend_id, uint8_t * client_id) | |||
96 | return -1; | 92 | return -1; |
97 | } | 93 | } |
98 | 94 | ||
99 | |||
100 | /* add a friend | 95 | /* add a friend |
101 | set the data that will be sent along with friend request | 96 | set the data that will be sent along with friend request |
102 | client_id is the client id of the friend | 97 | client_id is the client id of the friend |
@@ -191,7 +186,6 @@ int m_delfriend(int friendnumber) | |||
191 | return 0; | 186 | return 0; |
192 | } | 187 | } |
193 | 188 | ||
194 | |||
195 | /* return 4 if friend is online | 189 | /* return 4 if friend is online |
196 | return 3 if friend is confirmed | 190 | return 3 if friend is confirmed |
197 | return 2 if the friend request was sent | 191 | return 2 if the friend request was sent |
@@ -206,7 +200,6 @@ int m_friendstatus(int friendnumber) | |||
206 | return friendlist[friendnumber].status; | 200 | return friendlist[friendnumber].status; |
207 | } | 201 | } |
208 | 202 | ||
209 | |||
210 | /* send a text chat message to an online friend | 203 | /* send a text chat message to an online friend |
211 | return 1 if packet was successfully put into the send queue | 204 | return 1 if packet was successfully put into the send queue |
212 | return 0 if it was not */ | 205 | return 0 if it was not */ |
@@ -239,7 +232,6 @@ static int m_sendname(int friendnumber, uint8_t * name) | |||
239 | /* set the name of a friend | 232 | /* set the name of a friend |
240 | return 0 if success | 233 | return 0 if success |
241 | return -1 if failure */ | 234 | return -1 if failure */ |
242 | |||
243 | static int setfriendname(int friendnumber, uint8_t * name) | 235 | static int setfriendname(int friendnumber, uint8_t * name) |
244 | { | 236 | { |
245 | if(friendnumber >= numfriends || friendnumber < 0) | 237 | if(friendnumber >= numfriends || friendnumber < 0) |
@@ -250,7 +242,6 @@ static int setfriendname(int friendnumber, uint8_t * name) | |||
250 | return 0; | 242 | return 0; |
251 | } | 243 | } |
252 | 244 | ||
253 | |||
254 | /* Set our nickname | 245 | /* Set our nickname |
255 | name must be a string of maximum MAX_NAME_LENGTH length. | 246 | name must be a string of maximum MAX_NAME_LENGTH length. |
256 | return 0 if success | 247 | return 0 if success |
@@ -352,6 +343,7 @@ static int set_friend_userstatus(int friendnumber, uint8_t * status, uint16_t le | |||
352 | friendlist[friendnumber].userstatus_length = length; | 343 | friendlist[friendnumber].userstatus_length = length; |
353 | return 0; | 344 | return 0; |
354 | } | 345 | } |
346 | |||
355 | /* | 347 | /* |
356 | static void (*friend_request)(uint8_t *, uint8_t *, uint16_t); | 348 | static void (*friend_request)(uint8_t *, uint8_t *, uint16_t); |
357 | static uint8_t friend_request_isset = 0; | 349 | static uint8_t friend_request_isset = 0; |
@@ -362,7 +354,6 @@ void m_callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)) | |||
362 | callback_friendrequest(function); | 354 | callback_friendrequest(function); |
363 | } | 355 | } |
364 | 356 | ||
365 | |||
366 | static void (*friend_message)(int, uint8_t *, uint16_t); | 357 | static void (*friend_message)(int, uint8_t *, uint16_t); |
367 | static uint8_t friend_message_isset = 0; | 358 | static uint8_t friend_message_isset = 0; |
368 | 359 | ||
@@ -373,7 +364,6 @@ void m_callback_friendmessage(void (*function)(int, uint8_t *, uint16_t)) | |||
373 | friend_message_isset = 1; | 364 | friend_message_isset = 1; |
374 | } | 365 | } |
375 | 366 | ||
376 | |||
377 | static void (*friend_namechange)(int, uint8_t *, uint16_t); | 367 | static void (*friend_namechange)(int, uint8_t *, uint16_t); |
378 | static uint8_t friend_namechange_isset = 0; | 368 | static uint8_t friend_namechange_isset = 0; |
379 | void m_callback_namechange(void (*function)(int, uint8_t *, uint16_t)) | 369 | void m_callback_namechange(void (*function)(int, uint8_t *, uint16_t)) |
@@ -520,8 +510,6 @@ static void doFriends() | |||
520 | } | 510 | } |
521 | } | 511 | } |
522 | 512 | ||
523 | |||
524 | |||
525 | static void doInbound() | 513 | static void doInbound() |
526 | { | 514 | { |
527 | uint8_t secret_nonce[crypto_box_NONCEBYTES]; | 515 | uint8_t secret_nonce[crypto_box_NONCEBYTES]; |
diff --git a/core/Messenger.h b/core/Messenger.h index f699c022..c0432e68 100644 --- a/core/Messenger.h +++ b/core/Messenger.h | |||
@@ -22,8 +22,7 @@ | |||
22 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | 22 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. |
23 | * | 23 | * |
24 | */ | 24 | */ |
25 | 25 | ||
26 | |||
27 | #ifndef MESSENGER_H | 26 | #ifndef MESSENGER_H |
28 | #define MESSENGER_H | 27 | #define MESSENGER_H |
29 | 28 | ||
@@ -79,7 +78,6 @@ int m_delfriend(int friendnumber); | |||
79 | return 0 if there is no friend with that number */ | 78 | return 0 if there is no friend with that number */ |
80 | int m_friendstatus(int friendnumber); | 79 | int m_friendstatus(int friendnumber); |
81 | 80 | ||
82 | |||
83 | /* send a text chat message to an online friend | 81 | /* send a text chat message to an online friend |
84 | returns 1 if packet was successfully put into the send queue | 82 | returns 1 if packet was successfully put into the send queue |
85 | return 0 if it was not */ | 83 | return 0 if it was not */ |
@@ -91,7 +89,6 @@ int m_sendmessage(int friendnumber, uint8_t * message, uint32_t length); | |||
91 | return -1 if failure */ | 89 | return -1 if failure */ |
92 | int setname(uint8_t * name, uint16_t length); | 90 | int setname(uint8_t * name, uint16_t length); |
93 | 91 | ||
94 | |||
95 | /* get name of friendnumber | 92 | /* get name of friendnumber |
96 | put it in name | 93 | put it in name |
97 | name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes. | 94 | name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes. |
@@ -117,7 +114,6 @@ int m_copy_userstatus(int friendnumber, uint8_t * buf, uint32_t maxlen); | |||
117 | function format is function(uint8_t * public_key, uint8_t * data, uint16_t length) */ | 114 | function format is function(uint8_t * public_key, uint8_t * data, uint16_t length) */ |
118 | void m_callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)); | 115 | void m_callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)); |
119 | 116 | ||
120 | |||
121 | /* set the function that will be executed when a message from a friend is received. | 117 | /* set the function that will be executed when a message from a friend is received. |
122 | function format is: function(int friendnumber, uint8_t * message, uint32_t length) */ | 118 | function format is: function(int friendnumber, uint8_t * message, uint32_t length) */ |
123 | void m_callback_friendmessage(void (*function)(int, uint8_t *, uint16_t)); | 119 | void m_callback_friendmessage(void (*function)(int, uint8_t *, uint16_t)); |
@@ -137,11 +133,9 @@ void m_callback_userstatus(void (*function)(int, uint8_t *, uint16_t)); | |||
137 | returns -1 if there are problems */ | 133 | returns -1 if there are problems */ |
138 | int initMessenger(); | 134 | int initMessenger(); |
139 | 135 | ||
140 | |||
141 | /* the main loop that needs to be run at least 200 times per second */ | 136 | /* the main loop that needs to be run at least 200 times per second */ |
142 | void doMessenger(); | 137 | void doMessenger(); |
143 | 138 | ||
144 | |||
145 | /* SAVING AND LOADING FUNCTIONS: */ | 139 | /* SAVING AND LOADING FUNCTIONS: */ |
146 | 140 | ||
147 | /* returns the size of the messenger data (for saving) */ | 141 | /* returns the size of the messenger data (for saving) */ |
diff --git a/core/friend_requests.c b/core/friend_requests.c index ba3f7535..d24dd4b4 100644 --- a/core/friend_requests.c +++ b/core/friend_requests.c | |||
@@ -25,7 +25,6 @@ | |||
25 | 25 | ||
26 | uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; | 26 | uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; |
27 | 27 | ||
28 | |||
29 | /* Try to send a friendrequest to peer with public_key | 28 | /* Try to send a friendrequest to peer with public_key |
30 | data is the data in the request and length is the length. | 29 | data is the data in the request and length is the length. |
31 | return -1 if failure. | 30 | return -1 if failure. |
@@ -61,7 +60,6 @@ int send_friendrequest(uint8_t * public_key, uint8_t * data, uint32_t length) | |||
61 | return num; | 60 | return num; |
62 | } | 61 | } |
63 | 62 | ||
64 | |||
65 | static void (*handle_friendrequest)(uint8_t *, uint8_t *, uint16_t); | 63 | static void (*handle_friendrequest)(uint8_t *, uint8_t *, uint16_t); |
66 | static uint8_t handle_friendrequest_isset = 0; | 64 | static uint8_t handle_friendrequest_isset = 0; |
67 | 65 | ||
@@ -72,7 +70,6 @@ void callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)) | |||
72 | handle_friendrequest_isset = 1; | 70 | handle_friendrequest_isset = 1; |
73 | } | 71 | } |
74 | 72 | ||
75 | |||
76 | int friendreq_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) | 73 | int friendreq_handlepacket(uint8_t * packet, uint32_t length, IP_Port source) |
77 | { | 74 | { |
78 | 75 | ||
diff --git a/core/friend_requests.h b/core/friend_requests.h index fb19a709..29bc2b88 100644 --- a/core/friend_requests.h +++ b/core/friend_requests.h | |||
@@ -21,11 +21,9 @@ | |||
21 | * | 21 | * |
22 | */ | 22 | */ |
23 | 23 | ||
24 | |||
25 | #ifndef FRIEND_REQUESTS_H | 24 | #ifndef FRIEND_REQUESTS_H |
26 | #define FRIEND_REQUESTS_H | 25 | #define FRIEND_REQUESTS_H |
27 | 26 | ||
28 | |||
29 | #include "DHT.h" | 27 | #include "DHT.h" |
30 | #include "net_crypto.h" | 28 | #include "net_crypto.h" |
31 | 29 | ||
@@ -37,7 +35,6 @@ extern "C" { | |||
37 | data is the data in the request and length is the length. */ | 35 | data is the data in the request and length is the length. */ |
38 | int send_friendrequest(uint8_t * public_key, uint8_t * data, uint32_t length); | 36 | int send_friendrequest(uint8_t * public_key, uint8_t * data, uint32_t length); |
39 | 37 | ||
40 | |||
41 | /* set the function that will be executed when a friend request for us is received. | 38 | /* set the function that will be executed when a friend request for us is received. |
42 | function format is function(uint8_t * public_key, uint8_t * data, uint16_t length) */ | 39 | function format is function(uint8_t * public_key, uint8_t * data, uint16_t length) */ |
43 | void callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)); | 40 | void callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)); |
@@ -47,8 +44,6 @@ void callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t)); | |||
47 | return 1 if it didn't handle the packet or if the packet was shit. */ | 44 | return 1 if it didn't handle the packet or if the packet was shit. */ |
48 | int friendreq_handlepacket(uint8_t * packet, uint32_t length, IP_Port source); | 45 | int friendreq_handlepacket(uint8_t * packet, uint32_t length, IP_Port source); |
49 | 46 | ||
50 | |||
51 | |||
52 | #ifdef __cplusplus | 47 | #ifdef __cplusplus |
53 | } | 48 | } |
54 | #endif | 49 | #endif |
diff --git a/core/net_crypto.c b/core/net_crypto.c index a16537e8..044845f0 100644 --- a/core/net_crypto.c +++ b/core/net_crypto.c | |||
@@ -26,12 +26,10 @@ | |||
26 | 26 | ||
27 | #include "net_crypto.h" | 27 | #include "net_crypto.h" |
28 | 28 | ||
29 | |||
30 | /* Our public and secret keys. */ | 29 | /* Our public and secret keys. */ |
31 | uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; | 30 | uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; |
32 | uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; | 31 | uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; |
33 | 32 | ||
34 | |||
35 | typedef struct | 33 | typedef struct |
36 | { | 34 | { |
37 | uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* the real public key of the peer. */ | 35 | uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* the real public key of the peer. */ |
@@ -177,7 +175,6 @@ int read_cryptpacket(int crypt_connection_id, uint8_t * data) | |||
177 | return -1; | 175 | return -1; |
178 | } | 176 | } |
179 | 177 | ||
180 | |||
181 | /* return 0 if data could not be put in packet queue | 178 | /* return 0 if data could not be put in packet queue |
182 | return 1 if data was put into the queue */ | 179 | return 1 if data was put into the queue */ |
183 | int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length) | 180 | int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length) |
@@ -267,7 +264,6 @@ int handle_request(uint8_t * public_key, uint8_t * data, uint8_t * packet, uint1 | |||
267 | } | 264 | } |
268 | } | 265 | } |
269 | 266 | ||
270 | |||
271 | /* Send a crypto handshake packet containing an encrypted secret nonce and session public key | 267 | /* Send a crypto handshake packet containing an encrypted secret nonce and session public key |
272 | to peer with connection_id and public_key | 268 | to peer with connection_id and public_key |
273 | the packet is encrypted with a random nonce which is sent in plain text with the packet */ | 269 | the packet is encrypted with a random nonce which is sent in plain text with the packet */ |
@@ -327,9 +323,6 @@ int handle_cryptohandshake(uint8_t * public_key, uint8_t * secret_nonce, | |||
327 | return 1; | 323 | return 1; |
328 | } | 324 | } |
329 | 325 | ||
330 | |||
331 | |||
332 | |||
333 | /* get crypto connection id from public key of peer | 326 | /* get crypto connection id from public key of peer |
334 | return -1 if there are no connections like we are looking for | 327 | return -1 if there are no connections like we are looking for |
335 | return id if it found it */ | 328 | return id if it found it */ |
@@ -349,7 +342,6 @@ int getcryptconnection_id(uint8_t * public_key) | |||
349 | return -1; | 342 | return -1; |
350 | } | 343 | } |
351 | 344 | ||
352 | |||
353 | /* Start a secure connection with other peer who has public_key and ip_port | 345 | /* Start a secure connection with other peer who has public_key and ip_port |
354 | returns -1 if failure | 346 | returns -1 if failure |
355 | returns crypt_connection_id of the initialized connection if everything went well. */ | 347 | returns crypt_connection_id of the initialized connection if everything went well. */ |
@@ -447,7 +439,6 @@ int crypto_kill(int crypt_connection_id) | |||
447 | return 1; | 439 | return 1; |
448 | } | 440 | } |
449 | 441 | ||
450 | |||
451 | /* accept an incoming connection using the parameters provided by crypto_inbound | 442 | /* accept an incoming connection using the parameters provided by crypto_inbound |
452 | return -1 if not successful | 443 | return -1 if not successful |
453 | returns the crypt_connection_id if successful */ | 444 | returns the crypt_connection_id if successful */ |
@@ -505,7 +496,6 @@ int is_cryptoconnected(int crypt_connection_id) | |||
505 | return 0; | 496 | return 0; |
506 | } | 497 | } |
507 | 498 | ||
508 | |||
509 | /* Generate our public and private keys | 499 | /* Generate our public and private keys |
510 | Only call this function the first time the program starts. */ | 500 | Only call this function the first time the program starts. */ |
511 | void new_keys() | 501 | void new_keys() |
@@ -681,4 +671,4 @@ void doNetCrypto() | |||
681 | handle_incomings(); | 671 | handle_incomings(); |
682 | receive_crypto(); | 672 | receive_crypto(); |
683 | killTimedout(); | 673 | killTimedout(); |
684 | } | 674 | } \ No newline at end of file |
diff --git a/core/net_crypto.h b/core/net_crypto.h index 0dba0552..b5bab17a 100644 --- a/core/net_crypto.h +++ b/core/net_crypto.h | |||
@@ -55,13 +55,11 @@ int decrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, | |||
55 | /* fill the given nonce with random bytes. */ | 55 | /* fill the given nonce with random bytes. */ |
56 | void random_nonce(uint8_t * nonce); | 56 | void random_nonce(uint8_t * nonce); |
57 | 57 | ||
58 | |||
59 | /* return 0 if there is no received data in the buffer | 58 | /* return 0 if there is no received data in the buffer |
60 | return -1 if the packet was discarded. | 59 | return -1 if the packet was discarded. |
61 | return length of received data if successful */ | 60 | return length of received data if successful */ |
62 | int read_cryptpacket(int crypt_connection_id, uint8_t * data); | 61 | int read_cryptpacket(int crypt_connection_id, uint8_t * data); |
63 | 62 | ||
64 | |||
65 | /* return 0 if data could not be put in packet queue | 63 | /* return 0 if data could not be put in packet queue |
66 | return 1 if data was put into the queue */ | 64 | return 1 if data was put into the queue */ |
67 | int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length); | 65 | int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length); |
@@ -74,20 +72,17 @@ int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length); | |||
74 | returns the length of the created packet on success */ | 72 | returns the length of the created packet on success */ |
75 | int create_request(uint8_t * packet, uint8_t * public_key, uint8_t * data, uint32_t length, uint8_t request_id); | 73 | int create_request(uint8_t * packet, uint8_t * public_key, uint8_t * data, uint32_t length, uint8_t request_id); |
76 | 74 | ||
77 | |||
78 | /* puts the senders public key in the request in public_key, the data from the request | 75 | /* puts the senders public key in the request in public_key, the data from the request |
79 | in data if a friend or ping request was sent to us and returns the length of the data. | 76 | in data if a friend or ping request was sent to us and returns the length of the data. |
80 | packet is the request packet and length is its length | 77 | packet is the request packet and length is its length |
81 | return -1 if not valid request. */ | 78 | return -1 if not valid request. */ |
82 | int handle_request(uint8_t * public_key, uint8_t * data, uint8_t * packet, uint16_t length); | 79 | int handle_request(uint8_t * public_key, uint8_t * data, uint8_t * packet, uint16_t length); |
83 | 80 | ||
84 | |||
85 | /* Start a secure connection with other peer who has public_key and ip_port | 81 | /* Start a secure connection with other peer who has public_key and ip_port |
86 | returns -1 if failure | 82 | returns -1 if failure |
87 | returns crypt_connection_id of the initialized connection if everything went well. */ | 83 | returns crypt_connection_id of the initialized connection if everything went well. */ |
88 | int crypto_connect(uint8_t * public_key, IP_Port ip_port); | 84 | int crypto_connect(uint8_t * public_key, IP_Port ip_port); |
89 | 85 | ||
90 | |||
91 | /* kill a crypto connection | 86 | /* kill a crypto connection |
92 | return 0 if killed successfully | 87 | return 0 if killed successfully |
93 | return 1 if there was a problem. */ | 88 | return 1 if there was a problem. */ |
@@ -102,7 +97,6 @@ int crypto_kill(int crypt_connection_id); | |||
102 | to refuse it just call kill_connection(...) on the connection id */ | 97 | to refuse it just call kill_connection(...) on the connection id */ |
103 | int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key); | 98 | int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key); |
104 | 99 | ||
105 | |||
106 | /* accept an incoming connection using the parameters provided by crypto_inbound | 100 | /* accept an incoming connection using the parameters provided by crypto_inbound |
107 | return -1 if not successful | 101 | return -1 if not successful |
108 | returns the crypt_connection_id if successful */ | 102 | returns the crypt_connection_id if successful */ |
diff --git a/core/network.c b/core/network.c index 8c9cd0bd..5aa0d304 100644 --- a/core/network.c +++ b/core/network.c | |||
@@ -23,7 +23,6 @@ | |||
23 | 23 | ||
24 | #include "network.h" | 24 | #include "network.h" |
25 | 25 | ||
26 | |||
27 | /* returns current UNIX time in microseconds (us). */ | 26 | /* returns current UNIX time in microseconds (us). */ |
28 | uint64_t current_time() | 27 | uint64_t current_time() |
29 | { | 28 | { |
@@ -128,7 +127,6 @@ int init_networking(IP ip, uint16_t port) | |||
128 | return -1; | 127 | return -1; |
129 | #endif | 128 | #endif |
130 | 129 | ||
131 | |||
132 | /* Functions to increase the size of the send and receive UDP buffers | 130 | /* Functions to increase the size of the send and receive UDP buffers |
133 | NOTE: uncomment if necessary */ | 131 | NOTE: uncomment if necessary */ |
134 | /* | 132 | /* |
@@ -146,7 +144,6 @@ int init_networking(IP ip, uint16_t port) | |||
146 | /*Enable broadcast on socket*/ | 144 | /*Enable broadcast on socket*/ |
147 | int broadcast = 1; | 145 | int broadcast = 1; |
148 | setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char*)&broadcast, sizeof(broadcast)); | 146 | setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char*)&broadcast, sizeof(broadcast)); |
149 | |||
150 | 147 | ||
151 | /* Set socket nonblocking */ | 148 | /* Set socket nonblocking */ |
152 | #ifdef WIN32 | 149 | #ifdef WIN32 |
diff --git a/core/network.h b/core/network.h index e6bf1a7a..dcbd4160 100644 --- a/core/network.h +++ b/core/network.h | |||
@@ -20,7 +20,6 @@ | |||
20 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | 20 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. |
21 | * | 21 | * |
22 | */ | 22 | */ |
23 | |||
24 | 23 | ||
25 | #ifndef NETWORK_H | 24 | #ifndef NETWORK_H |
26 | #define NETWORK_H | 25 | #define NETWORK_H |
@@ -31,8 +30,6 @@ | |||
31 | #include <string.h> | 30 | #include <string.h> |
32 | #include <time.h> | 31 | #include <time.h> |
33 | 32 | ||
34 | |||
35 | |||
36 | #ifdef WIN32 /* Put win32 includes here */ | 33 | #ifdef WIN32 /* Put win32 includes here */ |
37 | //Windows XP | 34 | //Windows XP |
38 | #define WINVER 0x0501 | 35 | #define WINVER 0x0501 |
@@ -97,7 +94,6 @@ typedef struct | |||
97 | #endif | 94 | #endif |
98 | }ADDR; | 95 | }ADDR; |
99 | 96 | ||
100 | |||
101 | /* returns current time in milleseconds since the epoch. */ | 97 | /* returns current time in milleseconds since the epoch. */ |
102 | uint64_t current_time(); | 98 | uint64_t current_time(); |
103 | 99 | ||
diff --git a/testing/DHT_cryptosendfiletest.c b/testing/DHT_cryptosendfiletest.c index 6aaac677..b06ddea5 100644 --- a/testing/DHT_cryptosendfiletest.c +++ b/testing/DHT_cryptosendfiletest.c | |||
@@ -41,7 +41,7 @@ | |||
41 | 41 | ||
42 | #include <string.h> | 42 | #include <string.h> |
43 | 43 | ||
44 | //Sleep function (x = milliseconds) | 44 | /* Sleep function (x = milliseconds) */ |
45 | #ifdef WIN32 | 45 | #ifdef WIN32 |
46 | 46 | ||
47 | #define c_sleep(x) Sleep(1*x) | 47 | #define c_sleep(x) Sleep(1*x) |
@@ -60,16 +60,14 @@ void printip(IP_Port ip_port) | |||
60 | printf("\nIP: %u.%u.%u.%u Port: %u\n",ip_port.ip.c[0],ip_port.ip.c[1],ip_port.ip.c[2],ip_port.ip.c[3],ntohs(ip_port.port)); | 60 | printf("\nIP: %u.%u.%u.%u Port: %u\n",ip_port.ip.c[0],ip_port.ip.c[1],ip_port.ip.c[2],ip_port.ip.c[3],ntohs(ip_port.port)); |
61 | } | 61 | } |
62 | 62 | ||
63 | 63 | /* horrible function from one of my first C programs. | |
64 | //horrible function from one of my first C programs. | 64 | *only here because I was too lazy to write a proper one. */ |
65 | //only here because I was too lazy to write a proper one. | ||
66 | unsigned char * hex_string_to_bin(char hex_string[]) | 65 | unsigned char * hex_string_to_bin(char hex_string[]) |
67 | { | 66 | { |
68 | unsigned char * val = malloc(strlen(hex_string)); | 67 | unsigned char * val = malloc(strlen(hex_string)); |
69 | char * pos = hex_string; | 68 | char * pos = hex_string; |
70 | int i=0; | 69 | int i=0; |
71 | while(i < strlen(hex_string)) | 70 | while(i < strlen(hex_string)) { |
72 | { | ||
73 | sscanf(pos,"%2hhx",&val[i]); | 71 | sscanf(pos,"%2hhx",&val[i]); |
74 | pos+=2; | 72 | pos+=2; |
75 | i++; | 73 | i++; |
@@ -88,8 +86,7 @@ int main(int argc, char *argv[]) | |||
88 | new_keys(); | 86 | new_keys(); |
89 | printf("OUR ID: "); | 87 | printf("OUR ID: "); |
90 | uint32_t i; | 88 | uint32_t i; |
91 | for(i = 0; i < 32; i++) | 89 | for(i = 0; i < 32; i++) { |
92 | { | ||
93 | if(self_public_key[i] < 16) | 90 | if(self_public_key[i] < 16) |
94 | printf("0"); | 91 | printf("0"); |
95 | printf("%hhX",self_public_key[i]); | 92 | printf("%hhX",self_public_key[i]); |
@@ -105,8 +102,7 @@ int main(int argc, char *argv[]) | |||
105 | uint8_t friend_id[32]; | 102 | uint8_t friend_id[32]; |
106 | memcpy(friend_id, hex_string_to_bin(temp_id), 32); | 103 | memcpy(friend_id, hex_string_to_bin(temp_id), 32); |
107 | 104 | ||
108 | 105 | /* memcpy(self_client_id, "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq", 32); */ | |
109 | //memcpy(self_client_id, "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq", 32); | ||
110 | 106 | ||
111 | 107 | ||
112 | DHT_addfriend(friend_id); | 108 | DHT_addfriend(friend_id); |
@@ -118,15 +114,13 @@ int main(int argc, char *argv[]) | |||
118 | int friendrequest = -1; | 114 | int friendrequest = -1; |
119 | uint8_t request_data[512]; | 115 | uint8_t request_data[512]; |
120 | 116 | ||
121 | //initialize networking | 117 | /* initialize networking |
122 | //bind to ip 0.0.0.0:PORT | 118 | * bind to ip 0.0.0.0:PORT */ |
123 | IP ip; | 119 | IP ip; |
124 | ip.i = 0; | 120 | ip.i = 0; |
125 | init_networking(ip, PORT); | 121 | init_networking(ip, PORT); |
126 | initNetCrypto(); | 122 | initNetCrypto(); |
127 | 123 | ||
128 | |||
129 | |||
130 | perror("Initialization"); | 124 | perror("Initialization"); |
131 | IP_Port bootstrap_ip_port; | 125 | IP_Port bootstrap_ip_port; |
132 | bootstrap_ip_port.port = htons(atoi(argv[2])); | 126 | bootstrap_ip_port.port = htons(atoi(argv[2])); |
@@ -147,122 +141,99 @@ int main(int argc, char *argv[]) | |||
147 | if ( file2==NULL ){return 1;} | 141 | if ( file2==NULL ){return 1;} |
148 | read1 = fread(buffer1, 1, 128, file1); | 142 | read1 = fread(buffer1, 1, 128, file1); |
149 | 143 | ||
150 | while(1) | 144 | while(1) { |
151 | { | 145 | while(receivepacket(&ip_port, data, &length) != -1) { |
152 | 146 | if(rand() % 3 != 1) { /* simulate packet loss */ | |
153 | while(receivepacket(&ip_port, data, &length) != -1) | 147 | if(DHT_handlepacket(data, length, ip_port) && LosslessUDP_handlepacket(data, length, ip_port)) { |
154 | { | 148 | /* if packet is not recognized */ |
155 | if(rand() % 3 != 1)//simulate packet loss | ||
156 | { | ||
157 | if(DHT_handlepacket(data, length, ip_port) && LosslessUDP_handlepacket(data, length, ip_port)) | ||
158 | { | ||
159 | //if packet is not recognized | ||
160 | printf("Received unhandled packet with length: %u\n", length); | 149 | printf("Received unhandled packet with length: %u\n", length); |
161 | } | 150 | } else { |
162 | else | ||
163 | { | ||
164 | printf("Received handled packet with length: %u\n", length); | 151 | printf("Received handled packet with length: %u\n", length); |
165 | } | 152 | } |
166 | } | 153 | } |
167 | } | 154 | } |
168 | friend_ip = DHT_getfriendip(friend_id); | 155 | friend_ip = DHT_getfriendip(friend_id); |
169 | if(friend_ip.ip.i != 0) | 156 | if(friend_ip.ip.i != 0) { |
170 | { | 157 | if(connection == -1 && friendrequest == -1) { |
171 | if(connection == -1 && friendrequest == -1) | ||
172 | { | ||
173 | printf("Sending friend request to peer:"); | 158 | printf("Sending friend request to peer:"); |
174 | printip(friend_ip); | 159 | printip(friend_ip); |
175 | friendrequest = send_friendrequest(friend_id, friend_ip,(uint8_t *) "Hello World", 12); | 160 | friendrequest = send_friendrequest(friend_id, friend_ip,(uint8_t *) "Hello World", 12); |
176 | //connection = crypto_connect((uint8_t *)friend_id, friend_ip); | 161 | /* connection = crypto_connect((uint8_t *)friend_id, friend_ip); */ |
177 | //connection = new_connection(friend_ip); | 162 | /* connection = new_connection(friend_ip); */ |
178 | } | 163 | } |
179 | if(check_friendrequest(friendrequest) == 1) | 164 | if(check_friendrequest(friendrequest) == 1) { |
180 | { | ||
181 | printf("Started connecting to friend:"); | 165 | printf("Started connecting to friend:"); |
182 | connection = crypto_connect(friend_id, friend_ip); | 166 | connection = crypto_connect(friend_id, friend_ip); |
183 | } | 167 | } |
184 | } | 168 | } |
185 | if(inconnection == -1) | 169 | if(inconnection == -1) { |
186 | { | ||
187 | uint8_t secret_nonce[crypto_box_NONCEBYTES]; | 170 | uint8_t secret_nonce[crypto_box_NONCEBYTES]; |
188 | uint8_t public_key[crypto_box_PUBLICKEYBYTES]; | 171 | uint8_t public_key[crypto_box_PUBLICKEYBYTES]; |
189 | uint8_t session_key[crypto_box_PUBLICKEYBYTES]; | 172 | uint8_t session_key[crypto_box_PUBLICKEYBYTES]; |
190 | inconnection = crypto_inbound(public_key, secret_nonce, session_key); | 173 | inconnection = crypto_inbound(public_key, secret_nonce, session_key); |
191 | inconnection = accept_crypto_inbound(inconnection, acceptedfriend_public_key, secret_nonce, session_key); | 174 | inconnection = accept_crypto_inbound(inconnection, acceptedfriend_public_key, secret_nonce, session_key); |
192 | //inconnection = incoming_connection(); | 175 | /* inconnection = incoming_connection(); */ |
193 | if(inconnection != -1) | 176 | if(inconnection != -1) { |
194 | { | ||
195 | printf("Someone connected to us:\n"); | 177 | printf("Someone connected to us:\n"); |
196 | // printip(connection_ip(inconnection)); | 178 | /* printip(connection_ip(inconnection)); */ |
197 | } | 179 | } |
198 | } | 180 | } |
199 | if(handle_friendrequest(acceptedfriend_public_key, request_data) > 1) | 181 | if(handle_friendrequest(acceptedfriend_public_key, request_data) > 1) { |
200 | { | ||
201 | printf("RECIEVED FRIEND REQUEST: %s\n", request_data); | 182 | printf("RECIEVED FRIEND REQUEST: %s\n", request_data); |
202 | } | 183 | } |
203 | 184 | ||
204 | //if someone connected to us write what he sends to a file | 185 | /* if someone connected to us write what he sends to a file |
205 | //also send him our file. | 186 | * also send him our file. */ |
206 | if(inconnection != -1) | 187 | if(inconnection != -1) { |
207 | { | 188 | if(write_cryptpacket(inconnection, buffer1, read1)) { |
208 | if(write_cryptpacket(inconnection, buffer1, read1)) | ||
209 | { | ||
210 | printf("Wrote data1.\n"); | 189 | printf("Wrote data1.\n"); |
211 | read1 = fread(buffer1, 1, 128, file1); | 190 | read1 = fread(buffer1, 1, 128, file1); |
212 | } | 191 | } |
213 | read2 = read_cryptpacket(inconnection, buffer2); | 192 | read2 = read_cryptpacket(inconnection, buffer2); |
214 | if(read2 != 0) | 193 | if(read2 != 0) { |
215 | { | ||
216 | printf("Received data1.\n"); | 194 | printf("Received data1.\n"); |
217 | if(!fwrite(buffer2, read2, 1, file2)) | 195 | if(!fwrite(buffer2, read2, 1, file2)) { |
218 | { | ||
219 | printf("file write error1\n"); | 196 | printf("file write error1\n"); |
220 | } | 197 | } |
221 | if(read2 < 128) | 198 | if(read2 < 128) { |
222 | { | ||
223 | printf("Closed file1 %u\n", read2); | 199 | printf("Closed file1 %u\n", read2); |
224 | fclose(file2); | 200 | fclose(file2); |
225 | } | 201 | } |
226 | } | 202 | } |
227 | else if(is_cryptoconnected(inconnection) == 4)//if buffer is empty and the connection timed out. | 203 | /* if buffer is empty and the connection timed out. */ |
228 | { | 204 | else if(is_cryptoconnected(inconnection) == 4) { |
229 | crypto_kill(inconnection); | 205 | crypto_kill(inconnection); |
230 | } | 206 | } |
231 | } | 207 | } |
232 | //if we are connected to a friend send him data from the file. | 208 | /* if we are connected to a friend send him data from the file. |
233 | //also put what he sends us in a file. | 209 | * also put what he sends us in a file. */ |
234 | if(is_cryptoconnected(connection) >= 3) | 210 | if(is_cryptoconnected(connection) >= 3) { |
235 | { | 211 | if(write_cryptpacket(0, buffer1, read1)) { |
236 | if(write_cryptpacket(0, buffer1, read1)) | ||
237 | { | ||
238 | printf("Wrote data2.\n"); | 212 | printf("Wrote data2.\n"); |
239 | read1 = fread(buffer1, 1, 128, file1); | 213 | read1 = fread(buffer1, 1, 128, file1); |
240 | } | 214 | } |
241 | read2 = read_cryptpacket(0, buffer2); | 215 | read2 = read_cryptpacket(0, buffer2); |
242 | if(read2 != 0) | 216 | if(read2 != 0) { |
243 | { | ||
244 | printf("Received data2.\n"); | 217 | printf("Received data2.\n"); |
245 | if(!fwrite(buffer2, read2, 1, file2)) | 218 | if(!fwrite(buffer2, read2, 1, file2)) { |
246 | { | ||
247 | printf("file write error2\n"); | 219 | printf("file write error2\n"); |
248 | } | 220 | } |
249 | if(read2 < 128) | 221 | if(read2 < 128) { |
250 | { | ||
251 | printf("Closed file2 %u\n", read2); | 222 | printf("Closed file2 %u\n", read2); |
252 | fclose(file2); | 223 | fclose(file2); |
253 | } | 224 | } |
254 | } | 225 | } |
255 | else if(is_cryptoconnected(connection) == 4)//if buffer is empty and the connection timed out. | 226 | /* if buffer is empty and the connection timed out. */ |
256 | { | 227 | else if(is_cryptoconnected(connection) == 4) { |
257 | crypto_kill(connection); | 228 | crypto_kill(connection); |
258 | } | 229 | } |
259 | } | 230 | } |
260 | doDHT(); | 231 | doDHT(); |
261 | doLossless_UDP(); | 232 | doLossless_UDP(); |
262 | doNetCrypto(); | 233 | doNetCrypto(); |
263 | //print_clientlist(); | 234 | /*print_clientlist(); |
264 | //print_friendlist(); | 235 | *print_friendlist(); |
265 | //c_sleep(300); | 236 | *c_sleep(300); */ |
266 | c_sleep(1); | 237 | c_sleep(1); |
267 | } | 238 | } |
268 | 239 | ||
diff --git a/testing/DHT_sendfiletest.c b/testing/DHT_sendfiletest.c index c9865843..5b5d6c9f 100644 --- a/testing/DHT_sendfiletest.c +++ b/testing/DHT_sendfiletest.c | |||
@@ -33,6 +33,7 @@ | |||
33 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | 33 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. |
34 | * | 34 | * |
35 | */ | 35 | */ |
36 | |||
36 | #include "../core/network.h" | 37 | #include "../core/network.h" |
37 | #include "../core/DHT.h" | 38 | #include "../core/DHT.h" |
38 | #include "../core/Lossless_UDP.h" | 39 | #include "../core/Lossless_UDP.h" |
@@ -100,68 +101,53 @@ int main(int argc, char *argv[]) | |||
100 | if ( file2==NULL ){return 1;} | 101 | if ( file2==NULL ){return 1;} |
101 | read1 = fread(buffer1, 1, 128, file1); | 102 | read1 = fread(buffer1, 1, 128, file1); |
102 | 103 | ||
103 | while(1) | 104 | while(1) { |
104 | { | ||
105 | 105 | ||
106 | while(receivepacket(&ip_port, data, &length) != -1) | 106 | while(receivepacket(&ip_port, data, &length) != -1) { |
107 | { | 107 | if(rand() % 3 != 1) { /* simulate packet loss */ |
108 | if(rand() % 3 != 1)//simulate packet loss | 108 | if(DHT_handlepacket(data, length, ip_port) && LosslessUDP_handlepacket(data, length, ip_port)) { |
109 | { | 109 | /* if packet is not recognized */ |
110 | if(DHT_handlepacket(data, length, ip_port) && LosslessUDP_handlepacket(data, length, ip_port)) | ||
111 | { | ||
112 | //if packet is not recognized | ||
113 | printf("Received unhandled packet with length: %u\n", length); | 110 | printf("Received unhandled packet with length: %u\n", length); |
114 | } | 111 | } else { |
115 | else | ||
116 | { | ||
117 | printf("Received handled packet with length: %u\n", length); | 112 | printf("Received handled packet with length: %u\n", length); |
118 | } | 113 | } |
119 | } | 114 | } |
120 | } | 115 | } |
121 | friend_ip = DHT_getfriendip((uint8_t *)argv[3]); | 116 | friend_ip = DHT_getfriendip((uint8_t *)argv[3]); |
122 | if(friend_ip.ip.i != 0) | 117 | if(friend_ip.ip.i != 0) { |
123 | { | 118 | if(connection == -1) { |
124 | if(connection == -1) | ||
125 | { | ||
126 | printf("Started connecting to friend:"); | 119 | printf("Started connecting to friend:"); |
127 | printip(friend_ip); | 120 | printip(friend_ip); |
128 | connection = new_connection(friend_ip); | 121 | connection = new_connection(friend_ip); |
129 | } | 122 | } |
130 | } | 123 | } |
131 | if(inconnection == -1) | 124 | if(inconnection == -1) { |
132 | { | ||
133 | inconnection = incoming_connection(); | 125 | inconnection = incoming_connection(); |
134 | if(inconnection != -1) | 126 | if(inconnection != -1) { |
135 | { | ||
136 | printf("Someone connected to us:"); | 127 | printf("Someone connected to us:"); |
137 | printip(connection_ip(inconnection)); | 128 | printip(connection_ip(inconnection)); |
138 | } | 129 | } |
139 | } | 130 | } |
140 | //if someone connected to us write what he sends to a file | 131 | /* if someone connected to us write what he sends to a file */ |
141 | //also send him our file. | 132 | /* also send him our file. */ |
142 | if(inconnection != -1) | 133 | if(inconnection != -1) { |
143 | { | 134 | if(write_packet(inconnection, buffer1, read1)) { |
144 | if(write_packet(inconnection, buffer1, read1)) | ||
145 | { | ||
146 | printf("Wrote data.\n"); | 135 | printf("Wrote data.\n"); |
147 | read1 = fread(buffer1, 1, 128, file1); | 136 | read1 = fread(buffer1, 1, 128, file1); |
148 | } | 137 | } |
149 | read2 = read_packet(inconnection, buffer2); | 138 | read2 = read_packet(inconnection, buffer2); |
150 | if(read2 != 0) | 139 | if(read2 != 0) { |
151 | { | ||
152 | printf("Received data.\n"); | 140 | printf("Received data.\n"); |
153 | if(!fwrite(buffer2, read2, 1, file2)) | 141 | if(!fwrite(buffer2, read2, 1, file2)) { |
154 | { | ||
155 | printf("file write error\n"); | 142 | printf("file write error\n"); |
156 | } | 143 | } |
157 | if(read2 < 128) | 144 | if(read2 < 128) { |
158 | { | ||
159 | fclose(file2); | 145 | fclose(file2); |
160 | } | 146 | } |
161 | } | 147 | } |
162 | } | 148 | } |
163 | //if we are connected to a friend send him data from the file. | 149 | /* if we are connected to a friend send him data from the file. |
164 | //also put what he sends us in a file. | 150 | * also put what he sends us in a file. */ |
165 | if(is_connected(connection) == 3) | 151 | if(is_connected(connection) == 3) |
166 | { | 152 | { |
167 | if(write_packet(0, buffer1, read1)) | 153 | if(write_packet(0, buffer1, read1)) |
@@ -185,9 +171,9 @@ int main(int argc, char *argv[]) | |||
185 | } | 171 | } |
186 | doDHT(); | 172 | doDHT(); |
187 | doLossless_UDP(); | 173 | doLossless_UDP(); |
188 | //print_clientlist(); | 174 | /* print_clientlist(); |
189 | //print_friendlist(); | 175 | * print_friendlist(); |
190 | //c_sleep(300); | 176 | * c_sleep(300); */ |
191 | c_sleep(1); | 177 | c_sleep(1); |
192 | } | 178 | } |
193 | 179 | ||
diff --git a/testing/DHT_test.c b/testing/DHT_test.c index 80019029..bb482595 100644 --- a/testing/DHT_test.c +++ b/testing/DHT_test.c | |||
@@ -47,17 +47,14 @@ | |||
47 | 47 | ||
48 | #define PORT 33445 | 48 | #define PORT 33445 |
49 | 49 | ||
50 | |||
51 | void print_clientlist() | 50 | void print_clientlist() |
52 | { | 51 | { |
53 | uint32_t i, j; | 52 | uint32_t i, j; |
54 | IP_Port p_ip; | 53 | IP_Port p_ip; |
55 | printf("___________________CLOSE________________________________\n"); | 54 | printf("___________________CLOSE________________________________\n"); |
56 | for(i = 0; i < 4; i++) | 55 | for(i = 0; i < 4; i++) { |
57 | { | ||
58 | printf("ClientID: "); | 56 | printf("ClientID: "); |
59 | for(j = 0; j < 32; j++) | 57 | for(j = 0; j < 32; j++) { |
60 | { | ||
61 | printf("%c", close_clientlist[i].client_id[j]); | 58 | printf("%c", close_clientlist[i].client_id[j]); |
62 | } | 59 | } |
63 | p_ip = close_clientlist[i].ip_port; | 60 | p_ip = close_clientlist[i].ip_port; |
@@ -75,12 +72,10 @@ void print_friendlist() | |||
75 | uint32_t i, j, k; | 72 | uint32_t i, j, k; |
76 | IP_Port p_ip; | 73 | IP_Port p_ip; |
77 | printf("_________________FRIENDS__________________________________\n"); | 74 | printf("_________________FRIENDS__________________________________\n"); |
78 | for(k = 0; k < num_friends; k++) | 75 | for(k = 0; k < num_friends; k++) { |
79 | { | ||
80 | printf("FRIEND %u\n", k); | 76 | printf("FRIEND %u\n", k); |
81 | printf("ID: "); | 77 | printf("ID: "); |
82 | for(j = 0; j < 32; j++) | 78 | for(j = 0; j < 32; j++) { |
83 | { | ||
84 | printf("%c", friends_list[k].client_id[j]); | 79 | printf("%c", friends_list[k].client_id[j]); |
85 | } | 80 | } |
86 | p_ip = DHT_getfriendip(friends_list[k].client_id); | 81 | p_ip = DHT_getfriendip(friends_list[k].client_id); |
@@ -88,11 +83,9 @@ void print_friendlist() | |||
88 | 83 | ||
89 | printf("\nCLIENTS IN LIST:\n\n"); | 84 | printf("\nCLIENTS IN LIST:\n\n"); |
90 | 85 | ||
91 | for(i = 0; i < 4; i++) | 86 | for(i = 0; i < 4; i++) { |
92 | { | ||
93 | printf("ClientID: "); | 87 | printf("ClientID: "); |
94 | for(j = 0; j < 32; j++) | 88 | for(j = 0; j < 32; j++) { |
95 | { | ||
96 | if(0 <= friends_list[k].client_list[i].client_id[j] && friends_list[k].client_list[i].client_id[j] < 16) | 89 | if(0 <= friends_list[k].client_list[i].client_id[j] && friends_list[k].client_list[i].client_id[j] < 16) |
97 | printf("0"); | 90 | printf("0"); |
98 | printf("%hhX", friends_list[k].client_list[i].client_id[j]); | 91 | printf("%hhX", friends_list[k].client_list[i].client_id[j]); |
@@ -113,8 +106,7 @@ void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) | |||
113 | uint32_t i; | 106 | uint32_t i; |
114 | printf("UNHANDLED PACKET RECEIVED\nLENGTH:%u\nCONTENTS:\n", length); | 107 | printf("UNHANDLED PACKET RECEIVED\nLENGTH:%u\nCONTENTS:\n", length); |
115 | printf("--------------------BEGIN-----------------------------\n"); | 108 | printf("--------------------BEGIN-----------------------------\n"); |
116 | for(i = 0; i < length; i++) | 109 | for(i = 0; i < length; i++) { |
117 | { | ||
118 | if(data[i] < 16) | 110 | if(data[i] < 16) |
119 | printf("0"); | 111 | printf("0"); |
120 | printf("%hhX",data[i]); | 112 | printf("%hhX",data[i]); |
@@ -129,8 +121,7 @@ unsigned char * hex_string_to_bin(char hex_string[]) | |||
129 | unsigned char * val = malloc(strlen(hex_string)); | 121 | unsigned char * val = malloc(strlen(hex_string)); |
130 | char * pos = hex_string; | 122 | char * pos = hex_string; |
131 | int i=0; | 123 | int i=0; |
132 | while(i < strlen(hex_string)) | 124 | while(i < strlen(hex_string)) { |
133 | { | ||
134 | sscanf(pos,"%2hhx",&val[i]); | 125 | sscanf(pos,"%2hhx",&val[i]); |
135 | pos+=2; | 126 | pos+=2; |
136 | i++; | 127 | i++; |
@@ -149,8 +140,7 @@ int main(int argc, char *argv[]) | |||
149 | new_keys(); | 140 | new_keys(); |
150 | printf("OUR ID: "); | 141 | printf("OUR ID: "); |
151 | uint32_t i; | 142 | uint32_t i; |
152 | for(i = 0; i < 32; i++) | 143 | for(i = 0; i < 32; i++) { |
153 | { | ||
154 | if(self_public_key[i] < 16) | 144 | if(self_public_key[i] < 16) |
155 | printf("0"); | 145 | printf("0"); |
156 | printf("%hhX",self_public_key[i]); | 146 | printf("%hhX",self_public_key[i]); |
@@ -161,8 +151,8 @@ int main(int argc, char *argv[]) | |||
161 | scanf("%s", temp_id); | 151 | scanf("%s", temp_id); |
162 | DHT_addfriend(hex_string_to_bin(temp_id)); | 152 | DHT_addfriend(hex_string_to_bin(temp_id)); |
163 | 153 | ||
164 | //initialize networking | 154 | /* initialize networking */ |
165 | //bind to ip 0.0.0.0:PORT | 155 | /* bind to ip 0.0.0.0:PORT */ |
166 | IP ip; | 156 | IP ip; |
167 | ip.i = 0; | 157 | ip.i = 0; |
168 | init_networking(ip, PORT); | 158 | init_networking(ip, PORT); |
@@ -171,10 +161,10 @@ int main(int argc, char *argv[]) | |||
171 | perror("Initialization"); | 161 | perror("Initialization"); |
172 | IP_Port bootstrap_ip_port; | 162 | IP_Port bootstrap_ip_port; |
173 | bootstrap_ip_port.port = htons(atoi(argv[2])); | 163 | bootstrap_ip_port.port = htons(atoi(argv[2])); |
174 | //bootstrap_ip_port.ip.c[0] = 127; | 164 | /* bootstrap_ip_port.ip.c[0] = 127; |
175 | //bootstrap_ip_port.ip.c[1] = 0; | 165 | * bootstrap_ip_port.ip.c[1] = 0; |
176 | //bootstrap_ip_port.ip.c[2] = 0; | 166 | * bootstrap_ip_port.ip.c[2] = 0; |
177 | //bootstrap_ip_port.ip.c[3] = 1; | 167 | * bootstrap_ip_port.ip.c[3] = 1; */ |
178 | bootstrap_ip_port.ip.i = inet_addr(argv[1]); | 168 | bootstrap_ip_port.ip.i = inet_addr(argv[1]); |
179 | DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3])); | 169 | DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3])); |
180 | 170 | ||
@@ -182,20 +172,15 @@ int main(int argc, char *argv[]) | |||
182 | uint8_t data[MAX_UDP_PACKET_SIZE]; | 172 | uint8_t data[MAX_UDP_PACKET_SIZE]; |
183 | uint32_t length; | 173 | uint32_t length; |
184 | 174 | ||
185 | while(1) | 175 | while(1) { |
186 | { | ||
187 | 176 | ||
188 | doDHT(); | 177 | doDHT(); |
189 | 178 | ||
190 | while(receivepacket(&ip_port, data, &length) != -1) | 179 | while(receivepacket(&ip_port, data, &length) != -1) { |
191 | { | 180 | if(DHT_handlepacket(data, length, ip_port) && friendreq_handlepacket(data, length, ip_port)) { |
192 | if(DHT_handlepacket(data, length, ip_port) && friendreq_handlepacket(data, length, ip_port)) | ||
193 | { | ||
194 | //unhandled packet | 181 | //unhandled packet |
195 | printpacket(data, length, ip_port); | 182 | printpacket(data, length, ip_port); |
196 | } | 183 | } else { |
197 | else | ||
198 | { | ||
199 | printf("Received handled packet with length: %u\n", length); | 184 | printf("Received handled packet with length: %u\n", length); |
200 | } | 185 | } |
201 | } | 186 | } |
diff --git a/testing/Lossless_UDP_testclient.c b/testing/Lossless_UDP_testclient.c index 07ab319b..8f23528c 100644 --- a/testing/Lossless_UDP_testclient.c +++ b/testing/Lossless_UDP_testclient.c | |||
@@ -42,7 +42,6 @@ | |||
42 | 42 | ||
43 | #endif | 43 | #endif |
44 | 44 | ||
45 | |||
46 | #define PORT 33446 | 45 | #define PORT 33446 |
47 | 46 | ||
48 | void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) | 47 | void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) |
@@ -50,8 +49,7 @@ void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) | |||
50 | uint32_t i; | 49 | uint32_t i; |
51 | printf("UNHANDLED PACKET RECEIVED\nLENGTH:%u\nCONTENTS:\n", length); | 50 | printf("UNHANDLED PACKET RECEIVED\nLENGTH:%u\nCONTENTS:\n", length); |
52 | printf("--------------------BEGIN-----------------------------\n"); | 51 | printf("--------------------BEGIN-----------------------------\n"); |
53 | for(i = 0; i < length; i++) | 52 | for(i = 0; i < length; i++) { |
54 | { | ||
55 | if(data[i] < 16) | 53 | if(data[i] < 16) |
56 | printf("0"); | 54 | printf("0"); |
57 | printf("%hhX",data[i]); | 55 | printf("%hhX",data[i]); |
@@ -117,39 +115,34 @@ void printconnection(int connection_id) | |||
117 | 115 | ||
118 | } | 116 | } |
119 | */ | 117 | */ |
120 | //recieve packets and send them to the packethandler | 118 | |
121 | //run doLossless_UDP(); | 119 | /*( recieve packets and send them to the packethandler */ |
120 | /*run doLossless_UDP(); */ | ||
122 | void Lossless_UDP() | 121 | void Lossless_UDP() |
123 | { | 122 | { |
124 | IP_Port ip_port; | 123 | IP_Port ip_port; |
125 | uint8_t data[MAX_UDP_PACKET_SIZE]; | 124 | uint8_t data[MAX_UDP_PACKET_SIZE]; |
126 | uint32_t length; | 125 | uint32_t length; |
127 | while(receivepacket(&ip_port, data, &length) != -1) | 126 | while(receivepacket(&ip_port, data, &length) != -1) { |
128 | { | ||
129 | printf("packet with length: %u\n", length); | 127 | printf("packet with length: %u\n", length); |
130 | //if(rand() % 3 != 1)//add packet loss | 128 | /* if(rand() % 3 != 1)//add packet loss |
131 | // { | 129 | { */ |
132 | if(LosslessUDP_handlepacket(data, length, ip_port)) | 130 | if(LosslessUDP_handlepacket(data, length, ip_port)) { |
133 | { | ||
134 | printpacket(data, length, ip_port); | 131 | printpacket(data, length, ip_port); |
135 | } | 132 | } else { |
136 | else | ||
137 | { | ||
138 | //printconnection(0); | 133 | //printconnection(0); |
139 | printf("Received handled packet with length: %u\n", length); | 134 | printf("Received handled packet with length: %u\n", length); |
140 | } | 135 | } |
141 | // } | 136 | /* } */ |
142 | } | 137 | } |
143 | 138 | ||
144 | doLossless_UDP(); | 139 | doLossless_UDP(); |
145 | 140 | ||
146 | } | 141 | } |
147 | 142 | ||
148 | |||
149 | int main(int argc, char *argv[]) | 143 | int main(int argc, char *argv[]) |
150 | { | 144 | { |
151 | if (argc < 4) | 145 | if (argc < 4) { |
152 | { | ||
153 | printf("usage: %s ip port filename\n", argv[0]); | 146 | printf("usage: %s ip port filename\n", argv[0]); |
154 | exit(0); | 147 | exit(0); |
155 | } | 148 | } |
@@ -161,8 +154,8 @@ int main(int argc, char *argv[]) | |||
161 | if ( file==NULL ){return 1;} | 154 | if ( file==NULL ){return 1;} |
162 | 155 | ||
163 | 156 | ||
164 | //initialize networking | 157 | /* initialize networking */ |
165 | //bind to ip 0.0.0.0:PORT | 158 | /* bind to ip 0.0.0.0:PORT */ |
166 | IP ip; | 159 | IP ip; |
167 | ip.i = 0; | 160 | ip.i = 0; |
168 | init_networking(ip, PORT); | 161 | init_networking(ip, PORT); |
@@ -173,17 +166,14 @@ int main(int argc, char *argv[]) | |||
173 | printip(serverip); | 166 | printip(serverip); |
174 | int connection = new_connection(serverip); | 167 | int connection = new_connection(serverip); |
175 | uint64_t timer = current_time(); | 168 | uint64_t timer = current_time(); |
176 | while(1) | 169 | while(1) { |
177 | { | 170 | /* printconnection(connection); */ |
178 | // printconnection(connection); | ||
179 | Lossless_UDP(); | 171 | Lossless_UDP(); |
180 | if(is_connected(connection) == 3) | 172 | if(is_connected(connection) == 3) { |
181 | { | ||
182 | printf("Connecting took: %llu us\n", (unsigned long long)(current_time() - timer)); | 173 | printf("Connecting took: %llu us\n", (unsigned long long)(current_time() - timer)); |
183 | break; | 174 | break; |
184 | } | 175 | } |
185 | if(is_connected(connection) == 0) | 176 | if(is_connected(connection) == 0) { |
186 | { | ||
187 | printf("Connection timeout after: %llu us\n", (unsigned long long)(current_time() - timer)); | 177 | printf("Connection timeout after: %llu us\n", (unsigned long long)(current_time() - timer)); |
188 | return 1; | 178 | return 1; |
189 | } | 179 | } |
@@ -192,38 +182,32 @@ int main(int argc, char *argv[]) | |||
192 | timer = current_time(); | 182 | timer = current_time(); |
193 | 183 | ||
194 | 184 | ||
195 | //read first part of file | 185 | /*read first part of file */ |
196 | read = fread(buffer, 1, 512, file); | 186 | read = fread(buffer, 1, 512, file); |
197 | 187 | ||
198 | while(1) | 188 | while(1) { |
199 | { | 189 | /* printconnection(connection); */ |
200 | //printconnection(connection); | ||
201 | Lossless_UDP(); | 190 | Lossless_UDP(); |
202 | if(is_connected(connection) == 3) | 191 | if(is_connected(connection) == 3) { |
203 | { | ||
204 | 192 | ||
205 | if(write_packet(connection, buffer, read)) | 193 | if(write_packet(connection, buffer, read)) { |
206 | { | 194 | /* printf("Wrote data.\n"); */ |
207 | //printf("Wrote data.\n"); | ||
208 | read = fread(buffer, 1, 512, file); | 195 | read = fread(buffer, 1, 512, file); |
209 | 196 | ||
210 | } | 197 | } |
211 | //printf("%u\n", sendqueue(connection)); | 198 | /* printf("%u\n", sendqueue(connection)); */ |
212 | if(sendqueue(connection) == 0) | 199 | if(sendqueue(connection) == 0) { |
213 | { | 200 | if(read == 0) { |
214 | if(read == 0) | ||
215 | { | ||
216 | printf("Sent file successfully in: %llu us\n", (unsigned long long)(current_time() - timer)); | 201 | printf("Sent file successfully in: %llu us\n", (unsigned long long)(current_time() - timer)); |
217 | break; | 202 | break; |
218 | } | 203 | } |
219 | } | 204 | } |
220 | } | 205 | } |
221 | else | 206 | else { |
222 | { | ||
223 | printf("Connecting Lost after: %llu us\n", (unsigned long long)(current_time() - timer)); | 207 | printf("Connecting Lost after: %llu us\n", (unsigned long long)(current_time() - timer)); |
224 | return 0; | 208 | return 0; |
225 | } | 209 | } |
226 | //c_sleep(1); | 210 | /* c_sleep(1); */ |
227 | } | 211 | } |
228 | 212 | ||
229 | return 0; | 213 | return 0; |
diff --git a/testing/Lossless_UDP_testserver.c b/testing/Lossless_UDP_testserver.c index 0ed214e9..a8097048 100644 --- a/testing/Lossless_UDP_testserver.c +++ b/testing/Lossless_UDP_testserver.c | |||
@@ -43,7 +43,6 @@ | |||
43 | 43 | ||
44 | #endif | 44 | #endif |
45 | 45 | ||
46 | |||
47 | #define PORT 33445 | 46 | #define PORT 33445 |
48 | 47 | ||
49 | void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) | 48 | void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) |
@@ -51,14 +50,14 @@ void printpacket(uint8_t * data, uint32_t length, IP_Port ip_port) | |||
51 | uint32_t i; | 50 | uint32_t i; |
52 | printf("UNHANDLED PACKET RECEIVED\nLENGTH:%u\nCONTENTS:\n", length); | 51 | printf("UNHANDLED PACKET RECEIVED\nLENGTH:%u\nCONTENTS:\n", length); |
53 | printf("--------------------BEGIN-----------------------------\n"); | 52 | printf("--------------------BEGIN-----------------------------\n"); |
54 | for(i = 0; i < length; i++) | 53 | for(i = 0; i < length; i++) { |
55 | { | ||
56 | if(data[i] < 16) | 54 | if(data[i] < 16) |
57 | printf("0"); | 55 | printf("0"); |
58 | printf("%hhX",data[i]); | 56 | printf("%hhX",data[i]); |
59 | } | 57 | } |
60 | printf("\n--------------------END-----------------------------\n\n\n"); | 58 | printf("\n--------------------END-----------------------------\n\n\n"); |
61 | } | 59 | } |
60 | |||
62 | /* | 61 | /* |
63 | void printpackets(Data test) | 62 | void printpackets(Data test) |
64 | { | 63 | { |
@@ -113,23 +112,20 @@ void printconnection(int connection_id) | |||
113 | 112 | ||
114 | } | 113 | } |
115 | */ | 114 | */ |
116 | //recieve packets and send them to the packethandler | 115 | |
117 | //run doLossless_UDP(); | 116 | /* recieve packets and send them to the packethandler |
117 | * run doLossless_UDP(); */ | ||
118 | void Lossless_UDP() | 118 | void Lossless_UDP() |
119 | { | 119 | { |
120 | IP_Port ip_port; | 120 | IP_Port ip_port; |
121 | uint8_t data[MAX_UDP_PACKET_SIZE]; | 121 | uint8_t data[MAX_UDP_PACKET_SIZE]; |
122 | uint32_t length; | 122 | uint32_t length; |
123 | while(receivepacket(&ip_port, data, &length) != -1) | 123 | while(receivepacket(&ip_port, data, &length) != -1) { |
124 | { | ||
125 | //if(rand() % 3 != 1)//add packet loss | 124 | //if(rand() % 3 != 1)//add packet loss |
126 | //{ | 125 | //{ |
127 | if(LosslessUDP_handlepacket(data, length, ip_port)) | 126 | if(LosslessUDP_handlepacket(data, length, ip_port)) { |
128 | { | ||
129 | printpacket(data, length, ip_port); | 127 | printpacket(data, length, ip_port); |
130 | } | 128 | } else { |
131 | else | ||
132 | { | ||
133 | //printconnection(0); | 129 | //printconnection(0); |
134 | printf("Received handled packet with length: %u\n", length); | 130 | printf("Received handled packet with length: %u\n", length); |
135 | } | 131 | } |
@@ -137,14 +133,12 @@ void Lossless_UDP() | |||
137 | } | 133 | } |
138 | 134 | ||
139 | doLossless_UDP(); | 135 | doLossless_UDP(); |
140 | |||
141 | } | 136 | } |
142 | 137 | ||
143 | 138 | ||
144 | int main(int argc, char *argv[]) | 139 | int main(int argc, char *argv[]) |
145 | { | 140 | { |
146 | if (argc < 2) | 141 | if (argc < 2) { |
147 | { | ||
148 | printf("usage: %s filename\n", argv[0]); | 142 | printf("usage: %s filename\n", argv[0]); |
149 | exit(0); | 143 | exit(0); |
150 | } | 144 | } |
@@ -167,14 +161,11 @@ int main(int argc, char *argv[]) | |||
167 | uint64_t timer = current_time(); | 161 | uint64_t timer = current_time(); |
168 | 162 | ||
169 | 163 | ||
170 | while(1) | 164 | while(1) { |
171 | { | ||
172 | Lossless_UDP(); | 165 | Lossless_UDP(); |
173 | connection = incoming_connection(); | 166 | connection = incoming_connection(); |
174 | if(connection != -1) | 167 | if(connection != -1) { |
175 | { | 168 | if(is_connected(connection) == 2) { |
176 | if(is_connected(connection) == 2) | ||
177 | { | ||
178 | printf("Recieved the connection.\n"); | 169 | printf("Recieved the connection.\n"); |
179 | 170 | ||
180 | } | 171 | } |
@@ -185,25 +176,20 @@ int main(int argc, char *argv[]) | |||
185 | 176 | ||
186 | timer = current_time(); | 177 | timer = current_time(); |
187 | 178 | ||
188 | while(1) | 179 | while(1) { |
189 | { | ||
190 | //printconnection(0); | 180 | //printconnection(0); |
191 | Lossless_UDP(); | 181 | Lossless_UDP(); |
192 | if(is_connected(connection) >= 2) | 182 | if(is_connected(connection) >= 2) { |
193 | { | ||
194 | kill_connection_in(connection, 3000000); | 183 | kill_connection_in(connection, 3000000); |
195 | read = read_packet(connection, buffer); | 184 | read = read_packet(connection, buffer); |
196 | if(read != 0) | 185 | if(read != 0) { |
197 | { | ||
198 | // printf("Recieved data.\n"); | 186 | // printf("Recieved data.\n"); |
199 | if(!fwrite(buffer, read, 1, file)) | 187 | if(!fwrite(buffer, read, 1, file)) { |
200 | { | ||
201 | printf("file write error\n"); | 188 | printf("file write error\n"); |
202 | } | 189 | } |
203 | } | 190 | } |
204 | } | 191 | } |
205 | if(is_connected(connection) == 4) | 192 | if(is_connected(connection) == 4) { |
206 | { | ||
207 | printf("Connecting Lost after: %llu us\n", (unsigned long long)(current_time() - timer)); | 193 | printf("Connecting Lost after: %llu us\n", (unsigned long long)(current_time() - timer)); |
208 | fclose(file); | 194 | fclose(file); |
209 | return 1; | 195 | return 1; |
diff --git a/testing/Messenger_test.c b/testing/Messenger_test.c index e5da16e9..19ab4cc3 100644 --- a/testing/Messenger_test.c +++ b/testing/Messenger_test.c | |||
@@ -104,15 +104,12 @@ int main(int argc, char *argv[]) | |||
104 | exit(0); | 104 | exit(0); |
105 | } | 105 | } |
106 | initMessenger(); | 106 | initMessenger(); |
107 | if(argc > 3) | 107 | if(argc > 3) { |
108 | { | ||
109 | IP_Port bootstrap_ip_port; | 108 | IP_Port bootstrap_ip_port; |
110 | bootstrap_ip_port.port = htons(atoi(argv[2])); | 109 | bootstrap_ip_port.port = htons(atoi(argv[2])); |
111 | bootstrap_ip_port.ip.i = inet_addr(argv[1]); | 110 | bootstrap_ip_port.ip.i = inet_addr(argv[1]); |
112 | DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3])); | 111 | DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3])); |
113 | } | 112 | } else { |
114 | else | ||
115 | { | ||
116 | FILE *file = fopen(argv[1], "rb"); | 113 | FILE *file = fopen(argv[1], "rb"); |
117 | if ( file==NULL ){return 1;} | 114 | if ( file==NULL ){return 1;} |
118 | int read; | 115 | int read; |
@@ -127,8 +124,7 @@ int main(int argc, char *argv[]) | |||
127 | 124 | ||
128 | printf("OUR ID: "); | 125 | printf("OUR ID: "); |
129 | uint32_t i; | 126 | uint32_t i; |
130 | for(i = 0; i < 32; i++) | 127 | for(i = 0; i < 32; i++) { |
131 | { | ||
132 | if(self_public_key[i] < 16) | 128 | if(self_public_key[i] < 16) |
133 | printf("0"); | 129 | printf("0"); |
134 | printf("%hhX",self_public_key[i]); | 130 | printf("%hhX",self_public_key[i]); |
@@ -138,16 +134,14 @@ int main(int argc, char *argv[]) | |||
138 | 134 | ||
139 | char temp_id[128]; | 135 | char temp_id[128]; |
140 | printf("\nEnter the client_id of the friend you wish to add (32 bytes HEX format):\n"); | 136 | printf("\nEnter the client_id of the friend you wish to add (32 bytes HEX format):\n"); |
141 | if(scanf("%s", temp_id) != 1) | 137 | if(scanf("%s", temp_id) != 1) { |
142 | { | ||
143 | return 1; | 138 | return 1; |
144 | } | 139 | } |
145 | int num = m_addfriend(hex_string_to_bin(temp_id), (uint8_t*)"Install Gentoo", sizeof("Install Gentoo")); | 140 | int num = m_addfriend(hex_string_to_bin(temp_id), (uint8_t*)"Install Gentoo", sizeof("Install Gentoo")); |
146 | 141 | ||
147 | perror("Initialization"); | 142 | perror("Initialization"); |
148 | 143 | ||
149 | while(1) | 144 | while(1) { |
150 | { | ||
151 | uint8_t name[128]; | 145 | uint8_t name[128]; |
152 | getname(num, name); | 146 | getname(num, name); |
153 | printf("%s\n", name); | 147 | printf("%s\n", name); |
@@ -162,6 +156,5 @@ int main(int argc, char *argv[]) | |||
162 | fwrite(buffer, 1, Messenger_size(), file); | 156 | fwrite(buffer, 1, Messenger_size(), file); |
163 | free(buffer); | 157 | free(buffer); |
164 | fclose(file); | 158 | fclose(file); |
165 | } | 159 | } |
166 | |||
167 | } | 160 | } |
diff --git a/testing/nTox.c b/testing/nTox.c index 87a87007..caa7d45c 100644 --- a/testing/nTox.c +++ b/testing/nTox.c | |||
@@ -51,8 +51,7 @@ unsigned char * hex_string_to_bin(char hex_string[]) | |||
51 | unsigned char * val = malloc(strlen(hex_string)); | 51 | unsigned char * val = malloc(strlen(hex_string)); |
52 | char * pos = hex_string; | 52 | char * pos = hex_string; |
53 | int i=0; | 53 | int i=0; |
54 | while(i < strlen(hex_string)) | 54 | while(i < strlen(hex_string)) { |
55 | { | ||
56 | sscanf(pos,"%2hhx",&val[i]); | 55 | sscanf(pos,"%2hhx",&val[i]); |
57 | pos+=2; | 56 | pos+=2; |
58 | i++; | 57 | i++; |
@@ -190,6 +189,7 @@ void do_refresh() | |||
190 | clrtoeol(); | 189 | clrtoeol(); |
191 | refresh(); | 190 | refresh(); |
192 | } | 191 | } |
192 | |||
193 | void print_request(uint8_t * public_key, uint8_t * data, uint16_t length) | 193 | void print_request(uint8_t * public_key, uint8_t * data, uint16_t length) |
194 | { | 194 | { |
195 | new_lines("[i] received friend request"); | 195 | new_lines("[i] received friend request"); |
@@ -205,6 +205,7 @@ void print_request(uint8_t * public_key, uint8_t * data, uint16_t length) | |||
205 | new_lines(numchar); | 205 | new_lines(numchar); |
206 | } | 206 | } |
207 | } | 207 | } |
208 | |||
208 | void print_message(int friendnumber, uint8_t * string, uint16_t length) | 209 | void print_message(int friendnumber, uint8_t * string, uint16_t length) |
209 | { | 210 | { |
210 | char name[MAX_NAME_LENGTH]; | 211 | char name[MAX_NAME_LENGTH]; |
@@ -220,6 +221,7 @@ void print_message(int friendnumber, uint8_t * string, uint16_t length) | |||
220 | sprintf(msg, "[%d] %s <%s> %s", friendnumber, temp, name, string); // someone please fix this | 221 | sprintf(msg, "[%d] %s <%s> %s", friendnumber, temp, name, string); // someone please fix this |
221 | new_lines(msg); | 222 | new_lines(msg); |
222 | } | 223 | } |
224 | |||
223 | void print_nickchange(int friendnumber, uint8_t *string, uint16_t length) { | 225 | void print_nickchange(int friendnumber, uint8_t *string, uint16_t length) { |
224 | char name[MAX_NAME_LENGTH]; | 226 | char name[MAX_NAME_LENGTH]; |
225 | getname(friendnumber, (uint8_t*)name); | 227 | getname(friendnumber, (uint8_t*)name); |
@@ -227,6 +229,7 @@ void print_nickchange(int friendnumber, uint8_t *string, uint16_t length) { | |||
227 | sprintf(msg, "[i] [%d] %s is now known as %s.", friendnumber, name, string); | 229 | sprintf(msg, "[i] [%d] %s is now known as %s.", friendnumber, name, string); |
228 | new_lines(msg); | 230 | new_lines(msg); |
229 | } | 231 | } |
232 | |||
230 | void print_statuschange(int friendnumber, uint8_t *string, uint16_t length) { | 233 | void print_statuschange(int friendnumber, uint8_t *string, uint16_t length) { |
231 | char name[MAX_NAME_LENGTH]; | 234 | char name[MAX_NAME_LENGTH]; |
232 | getname(friendnumber, (uint8_t*)name); | 235 | getname(friendnumber, (uint8_t*)name); |
@@ -234,6 +237,7 @@ void print_statuschange(int friendnumber, uint8_t *string, uint16_t length) { | |||
234 | sprintf(msg, "[i] [%d] %s's status changed to %s.", friendnumber, name, string); | 237 | sprintf(msg, "[i] [%d] %s's status changed to %s.", friendnumber, name, string); |
235 | new_lines(msg); | 238 | new_lines(msg); |
236 | } | 239 | } |
240 | |||
237 | void load_key(){ | 241 | void load_key(){ |
238 | FILE *data_file = NULL; | 242 | FILE *data_file = NULL; |
239 | if ((data_file = fopen("data","r"))) { | 243 | if ((data_file = fopen("data","r"))) { |
@@ -260,6 +264,7 @@ void load_key(){ | |||
260 | } | 264 | } |
261 | fclose(data_file); | 265 | fclose(data_file); |
262 | } | 266 | } |
267 | |||
263 | int main(int argc, char *argv[]) | 268 | int main(int argc, char *argv[]) |
264 | { | 269 | { |
265 | if (argc < 4) { | 270 | if (argc < 4) { |
@@ -317,9 +322,7 @@ int main(int argc, char *argv[]) | |||
317 | DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3])); | 322 | DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3])); |
318 | nodelay(stdscr, TRUE); | 323 | nodelay(stdscr, TRUE); |
319 | while(true) { | 324 | while(true) { |
320 | 325 | if (on == 0 && DHT_isconnected()) { | |
321 | if (on == 0 && DHT_isconnected()) | ||
322 | { | ||
323 | new_lines("[i] connected to DHT\n[i] define username with /n"); | 326 | new_lines("[i] connected to DHT\n[i] define username with /n"); |
324 | on = 1; | 327 | on = 1; |
325 | } | 328 | } |
diff --git a/testing/nTox.h b/testing/nTox.h index 5a86830f..9b69d959 100644 --- a/testing/nTox.h +++ b/testing/nTox.h | |||
@@ -20,6 +20,7 @@ | |||
20 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | 20 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. |
21 | * | 21 | * |
22 | */ | 22 | */ |
23 | |||
23 | #ifndef NTOX_H | 24 | #ifndef NTOX_H |
24 | #define NTOX_H | 25 | #define NTOX_H |
25 | 26 | ||