diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/cadet | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/cadet')
34 files changed, 8414 insertions, 8296 deletions
diff --git a/src/cadet/cadet.h b/src/cadet/cadet.h index 9b2050e67..29400e39f 100644 --- a/src/cadet/cadet.h +++ b/src/cadet/cadet.h | |||
@@ -35,18 +35,18 @@ extern "C" { | |||
35 | 35 | ||
36 | #include <stdint.h> | 36 | #include <stdint.h> |
37 | 37 | ||
38 | #if !defined(GNUNET_CULL_LOGGING) | 38 | #if ! defined(GNUNET_CULL_LOGGING) |
39 | #define CADET_TIMING_START \ | 39 | #define CADET_TIMING_START \ |
40 | struct GNUNET_TIME_Absolute __timestamp; \ | 40 | struct GNUNET_TIME_Absolute __timestamp; \ |
41 | __timestamp = GNUNET_TIME_absolute_get() | 41 | __timestamp = GNUNET_TIME_absolute_get () |
42 | 42 | ||
43 | #define CADET_TIMING_END \ | 43 | #define CADET_TIMING_END \ |
44 | struct GNUNET_TIME_Relative __duration; \ | 44 | struct GNUNET_TIME_Relative __duration; \ |
45 | __duration = GNUNET_TIME_absolute_get_duration(__timestamp); \ | 45 | __duration = GNUNET_TIME_absolute_get_duration (__timestamp); \ |
46 | LOG(GNUNET_ERROR_TYPE_INFO, \ | 46 | LOG (GNUNET_ERROR_TYPE_INFO, \ |
47 | " %s duration %s\n", \ | 47 | " %s duration %s\n", \ |
48 | __FUNCTION__, \ | 48 | __FUNCTION__, \ |
49 | GNUNET_STRINGS_relative_time_to_string(__duration, GNUNET_YES)); | 49 | GNUNET_STRINGS_relative_time_to_string (__duration, GNUNET_YES)); |
50 | #else | 50 | #else |
51 | #define CADET_TIMING_START | 51 | #define CADET_TIMING_START |
52 | #define CADET_TIMING_END | 52 | #define CADET_TIMING_END |
@@ -99,7 +99,8 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
99 | /** | 99 | /** |
100 | * Number uniquely identifying a channel of a client. | 100 | * Number uniquely identifying a channel of a client. |
101 | */ | 101 | */ |
102 | struct GNUNET_CADET_ClientChannelNumber { | 102 | struct GNUNET_CADET_ClientChannelNumber |
103 | { | ||
103 | /** | 104 | /** |
104 | * Values for channel numbering. | 105 | * Values for channel numbering. |
105 | * Local channel numbers given by the service (incoming) are | 106 | * Local channel numbers given by the service (incoming) are |
@@ -114,7 +115,8 @@ struct GNUNET_CADET_ClientChannelNumber { | |||
114 | /** | 115 | /** |
115 | * Message for a client to create and destroy channels. | 116 | * Message for a client to create and destroy channels. |
116 | */ | 117 | */ |
117 | struct GNUNET_CADET_PortMessage { | 118 | struct GNUNET_CADET_PortMessage |
119 | { | ||
118 | /** | 120 | /** |
119 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN | 121 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN |
120 | * or #GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE | 122 | * or #GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE |
@@ -133,7 +135,8 @@ struct GNUNET_CADET_PortMessage { | |||
133 | /** | 135 | /** |
134 | * Message for a client to create channels. | 136 | * Message for a client to create channels. |
135 | */ | 137 | */ |
136 | struct GNUNET_CADET_LocalChannelCreateMessage { | 138 | struct GNUNET_CADET_LocalChannelCreateMessage |
139 | { | ||
137 | /** | 140 | /** |
138 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE | 141 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE |
139 | * | 142 | * |
@@ -166,7 +169,8 @@ struct GNUNET_CADET_LocalChannelCreateMessage { | |||
166 | /** | 169 | /** |
167 | * Message for or to a client to destroy tunnel. | 170 | * Message for or to a client to destroy tunnel. |
168 | */ | 171 | */ |
169 | struct GNUNET_CADET_LocalChannelDestroyMessage { | 172 | struct GNUNET_CADET_LocalChannelDestroyMessage |
173 | { | ||
170 | /** | 174 | /** |
171 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY | 175 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY |
172 | */ | 176 | */ |
@@ -182,7 +186,8 @@ struct GNUNET_CADET_LocalChannelDestroyMessage { | |||
182 | /** | 186 | /** |
183 | * Message for cadet data traffic. | 187 | * Message for cadet data traffic. |
184 | */ | 188 | */ |
185 | struct GNUNET_CADET_LocalData { | 189 | struct GNUNET_CADET_LocalData |
190 | { | ||
186 | /** | 191 | /** |
187 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA | 192 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA |
188 | */ | 193 | */ |
@@ -209,7 +214,8 @@ struct GNUNET_CADET_LocalData { | |||
209 | * Message to allow the client send more data to the service | 214 | * Message to allow the client send more data to the service |
210 | * (always service -> client). | 215 | * (always service -> client). |
211 | */ | 216 | */ |
212 | struct GNUNET_CADET_LocalAck { | 217 | struct GNUNET_CADET_LocalAck |
218 | { | ||
213 | /** | 219 | /** |
214 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK | 220 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK |
215 | */ | 221 | */ |
@@ -227,7 +233,8 @@ struct GNUNET_CADET_LocalAck { | |||
227 | * | 233 | * |
228 | * TODO: split into two messages! | 234 | * TODO: split into two messages! |
229 | */ | 235 | */ |
230 | struct GNUNET_CADET_LocalInfo { | 236 | struct GNUNET_CADET_LocalInfo |
237 | { | ||
231 | /** | 238 | /** |
232 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL or | 239 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL or |
233 | * #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER | 240 | * #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER |
@@ -249,7 +256,8 @@ struct GNUNET_CADET_LocalInfo { | |||
249 | /** | 256 | /** |
250 | * Message to inform the client about channels in the service. | 257 | * Message to inform the client about channels in the service. |
251 | */ | 258 | */ |
252 | struct GNUNET_CADET_RequestPathInfoMessage { | 259 | struct GNUNET_CADET_RequestPathInfoMessage |
260 | { | ||
253 | /** | 261 | /** |
254 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH | 262 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH |
255 | */ | 263 | */ |
@@ -270,7 +278,8 @@ struct GNUNET_CADET_RequestPathInfoMessage { | |||
270 | /** | 278 | /** |
271 | * Message to inform the client about channels in the service. | 279 | * Message to inform the client about channels in the service. |
272 | */ | 280 | */ |
273 | struct GNUNET_CADET_ChannelInfoMessage { | 281 | struct GNUNET_CADET_ChannelInfoMessage |
282 | { | ||
274 | /** | 283 | /** |
275 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL. | 284 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL. |
276 | */ | 285 | */ |
@@ -293,7 +302,8 @@ struct GNUNET_CADET_ChannelInfoMessage { | |||
293 | /** | 302 | /** |
294 | * Message to as the service about information on a channel. | 303 | * Message to as the service about information on a channel. |
295 | */ | 304 | */ |
296 | struct GNUNET_CADET_RequestChannelInfoMessage { | 305 | struct GNUNET_CADET_RequestChannelInfoMessage |
306 | { | ||
297 | /** | 307 | /** |
298 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_CHANNEL. | 308 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_CHANNEL. |
299 | */ | 309 | */ |
@@ -309,7 +319,8 @@ struct GNUNET_CADET_RequestChannelInfoMessage { | |||
309 | /** | 319 | /** |
310 | * Message to inform the client about one of the paths known to the service. | 320 | * Message to inform the client about one of the paths known to the service. |
311 | */ | 321 | */ |
312 | struct GNUNET_CADET_LocalInfoPath { | 322 | struct GNUNET_CADET_LocalInfoPath |
323 | { | ||
313 | /** | 324 | /** |
314 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH. | 325 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH. |
315 | */ | 326 | */ |
@@ -325,7 +336,8 @@ struct GNUNET_CADET_LocalInfoPath { | |||
325 | /** | 336 | /** |
326 | * Message to inform the client about one of the peers in the service. | 337 | * Message to inform the client about one of the peers in the service. |
327 | */ | 338 | */ |
328 | struct GNUNET_CADET_LocalInfoPeers { | 339 | struct GNUNET_CADET_LocalInfoPeers |
340 | { | ||
329 | /** | 341 | /** |
330 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS | 342 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS |
331 | */ | 343 | */ |
@@ -358,7 +370,8 @@ struct GNUNET_CADET_LocalInfoPeers { | |||
358 | * | 370 | * |
359 | * TODO: split into two messages! | 371 | * TODO: split into two messages! |
360 | */ | 372 | */ |
361 | struct GNUNET_CADET_LocalInfoTunnel { | 373 | struct GNUNET_CADET_LocalInfoTunnel |
374 | { | ||
362 | /** | 375 | /** |
363 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL | 376 | * Type: #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL |
364 | * or #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS | 377 | * or #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS |
@@ -406,7 +419,7 @@ GNUNET_NETWORK_STRUCT_END | |||
406 | * @return String representing FWD or BCK. | 419 | * @return String representing FWD or BCK. |
407 | */ | 420 | */ |
408 | char * | 421 | char * |
409 | GC_f2s(int fwd); | 422 | GC_f2s (int fwd); |
410 | 423 | ||
411 | 424 | ||
412 | /** | 425 | /** |
@@ -418,7 +431,7 @@ GC_f2s(int fwd); | |||
418 | * @return True if bigger (arg1) has a higher value than smaller (arg 2). | 431 | * @return True if bigger (arg1) has a higher value than smaller (arg 2). |
419 | */ | 432 | */ |
420 | int | 433 | int |
421 | GC_is_pid_bigger(uint32_t bigger, uint32_t smaller); | 434 | GC_is_pid_bigger (uint32_t bigger, uint32_t smaller); |
422 | 435 | ||
423 | 436 | ||
424 | /** | 437 | /** |
@@ -430,7 +443,7 @@ GC_is_pid_bigger(uint32_t bigger, uint32_t smaller); | |||
430 | * @return Highest ACK value from the two. | 443 | * @return Highest ACK value from the two. |
431 | */ | 444 | */ |
432 | uint32_t | 445 | uint32_t |
433 | GC_max_pid(uint32_t a, uint32_t b); | 446 | GC_max_pid (uint32_t a, uint32_t b); |
434 | 447 | ||
435 | 448 | ||
436 | /** | 449 | /** |
@@ -442,7 +455,7 @@ GC_max_pid(uint32_t a, uint32_t b); | |||
442 | * @return Lowest ACK value from the two. | 455 | * @return Lowest ACK value from the two. |
443 | */ | 456 | */ |
444 | uint32_t | 457 | uint32_t |
445 | GC_min_pid(uint32_t a, uint32_t b); | 458 | GC_min_pid (uint32_t a, uint32_t b); |
446 | 459 | ||
447 | 460 | ||
448 | /** | 461 | /** |
@@ -455,7 +468,7 @@ GC_min_pid(uint32_t a, uint32_t b); | |||
455 | * @return The size of the output. | 468 | * @return The size of the output. |
456 | */ | 469 | */ |
457 | size_t | 470 | size_t |
458 | GC_bin2s(void *bin, unsigned int len, char **output); | 471 | GC_bin2s (void *bin, unsigned int len, char **output); |
459 | 472 | ||
460 | 473 | ||
461 | /** | 474 | /** |
@@ -469,7 +482,7 @@ GC_bin2s(void *bin, unsigned int len, char **output); | |||
469 | * @return Human readable string description. | 482 | * @return Human readable string description. |
470 | */ | 483 | */ |
471 | const char * | 484 | const char * |
472 | GC_m2s(uint16_t m); | 485 | GC_m2s (uint16_t m); |
473 | 486 | ||
474 | #if 0 /* keep Emacsens' auto-indent happy */ | 487 | #if 0 /* keep Emacsens' auto-indent happy */ |
475 | { | 488 | { |
diff --git a/src/cadet/cadet_api.c b/src/cadet/cadet_api.c index 61ff71b31..9aeedb616 100644 --- a/src/cadet/cadet_api.c +++ b/src/cadet/cadet_api.c | |||
@@ -30,12 +30,13 @@ | |||
30 | #include "cadet.h" | 30 | #include "cadet.h" |
31 | #include "cadet_protocol.h" | 31 | #include "cadet_protocol.h" |
32 | 32 | ||
33 | #define LOG(kind, ...) GNUNET_log_from(kind, "cadet-api", __VA_ARGS__) | 33 | #define LOG(kind, ...) GNUNET_log_from (kind, "cadet-api", __VA_ARGS__) |
34 | 34 | ||
35 | /** | 35 | /** |
36 | * Opaque handle to the service. | 36 | * Opaque handle to the service. |
37 | */ | 37 | */ |
38 | struct GNUNET_CADET_Handle { | 38 | struct GNUNET_CADET_Handle |
39 | { | ||
39 | /** | 40 | /** |
40 | * Message queue. | 41 | * Message queue. |
41 | */ | 42 | */ |
@@ -76,7 +77,8 @@ struct GNUNET_CADET_Handle { | |||
76 | /** | 77 | /** |
77 | * Opaque handle to a channel. | 78 | * Opaque handle to a channel. |
78 | */ | 79 | */ |
79 | struct GNUNET_CADET_Channel { | 80 | struct GNUNET_CADET_Channel |
81 | { | ||
80 | /** | 82 | /** |
81 | * Other end of the channel. | 83 | * Other end of the channel. |
82 | */ | 84 | */ |
@@ -140,7 +142,8 @@ struct GNUNET_CADET_Channel { | |||
140 | /** | 142 | /** |
141 | * Opaque handle to a port. | 143 | * Opaque handle to a port. |
142 | */ | 144 | */ |
143 | struct GNUNET_CADET_Port { | 145 | struct GNUNET_CADET_Port |
146 | { | ||
144 | /** | 147 | /** |
145 | * Port "number" | 148 | * Port "number" |
146 | */ | 149 | */ |
@@ -191,10 +194,10 @@ struct GNUNET_CADET_Port { | |||
191 | * @return The port handle if known, NULL otherwise. | 194 | * @return The port handle if known, NULL otherwise. |
192 | */ | 195 | */ |
193 | static struct GNUNET_CADET_Port * | 196 | static struct GNUNET_CADET_Port * |
194 | find_port(const struct GNUNET_CADET_Handle *h, | 197 | find_port (const struct GNUNET_CADET_Handle *h, |
195 | const struct GNUNET_HashCode *hash) | 198 | const struct GNUNET_HashCode *hash) |
196 | { | 199 | { |
197 | return GNUNET_CONTAINER_multihashmap_get(h->ports, hash); | 200 | return GNUNET_CONTAINER_multihashmap_get (h->ports, hash); |
198 | } | 201 | } |
199 | 202 | ||
200 | 203 | ||
@@ -206,11 +209,11 @@ find_port(const struct GNUNET_CADET_Handle *h, | |||
206 | * @return handle to the required channel or NULL if not found | 209 | * @return handle to the required channel or NULL if not found |
207 | */ | 210 | */ |
208 | static struct GNUNET_CADET_Channel * | 211 | static struct GNUNET_CADET_Channel * |
209 | find_channel(struct GNUNET_CADET_Handle *h, | 212 | find_channel (struct GNUNET_CADET_Handle *h, |
210 | struct GNUNET_CADET_ClientChannelNumber ccn) | 213 | struct GNUNET_CADET_ClientChannelNumber ccn) |
211 | { | 214 | { |
212 | return GNUNET_CONTAINER_multihashmap32_get(h->channels, | 215 | return GNUNET_CONTAINER_multihashmap32_get (h->channels, |
213 | ntohl(ccn.channel_of_client)); | 216 | ntohl (ccn.channel_of_client)); |
214 | } | 217 | } |
215 | 218 | ||
216 | 219 | ||
@@ -222,33 +225,33 @@ find_channel(struct GNUNET_CADET_Handle *h, | |||
222 | * @return Handle to the created channel. | 225 | * @return Handle to the created channel. |
223 | */ | 226 | */ |
224 | static struct GNUNET_CADET_Channel * | 227 | static struct GNUNET_CADET_Channel * |
225 | create_channel(struct GNUNET_CADET_Handle *h, | 228 | create_channel (struct GNUNET_CADET_Handle *h, |
226 | const struct GNUNET_CADET_ClientChannelNumber *ccnp) | 229 | const struct GNUNET_CADET_ClientChannelNumber *ccnp) |
227 | { | 230 | { |
228 | struct GNUNET_CADET_Channel *ch; | 231 | struct GNUNET_CADET_Channel *ch; |
229 | struct GNUNET_CADET_ClientChannelNumber ccn; | 232 | struct GNUNET_CADET_ClientChannelNumber ccn; |
230 | 233 | ||
231 | ch = GNUNET_new(struct GNUNET_CADET_Channel); | 234 | ch = GNUNET_new (struct GNUNET_CADET_Channel); |
232 | ch->cadet = h; | 235 | ch->cadet = h; |
233 | if (NULL == ccnp) | 236 | if (NULL == ccnp) |
234 | { | 237 | { |
235 | while (NULL != find_channel(h, h->next_ccn)) | 238 | while (NULL != find_channel (h, h->next_ccn)) |
236 | h->next_ccn.channel_of_client = | 239 | h->next_ccn.channel_of_client = |
237 | htonl(GNUNET_CADET_LOCAL_CHANNEL_ID_CLI | | 240 | htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI |
238 | (1 + ntohl(h->next_ccn.channel_of_client))); | 241 | | (1 + ntohl (h->next_ccn.channel_of_client))); |
239 | ccn = h->next_ccn; | 242 | ccn = h->next_ccn; |
240 | } | 243 | } |
241 | else | 244 | else |
242 | { | 245 | { |
243 | ccn = *ccnp; | 246 | ccn = *ccnp; |
244 | } | 247 | } |
245 | ch->ccn = ccn; | 248 | ch->ccn = ccn; |
246 | GNUNET_assert(GNUNET_OK == | 249 | GNUNET_assert (GNUNET_OK == |
247 | GNUNET_CONTAINER_multihashmap32_put( | 250 | GNUNET_CONTAINER_multihashmap32_put ( |
248 | h->channels, | 251 | h->channels, |
249 | ntohl(ch->ccn.channel_of_client), | 252 | ntohl (ch->ccn.channel_of_client), |
250 | ch, | 253 | ch, |
251 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 254 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
252 | return ch; | 255 | return ch; |
253 | } | 256 | } |
254 | 257 | ||
@@ -264,31 +267,31 @@ create_channel(struct GNUNET_CADET_Handle *h, | |||
264 | * @param call_cleaner Whether to call the cleaner handler. | 267 | * @param call_cleaner Whether to call the cleaner handler. |
265 | */ | 268 | */ |
266 | static void | 269 | static void |
267 | destroy_channel(struct GNUNET_CADET_Channel *ch) | 270 | destroy_channel (struct GNUNET_CADET_Channel *ch) |
268 | { | 271 | { |
269 | struct GNUNET_CADET_Handle *h = ch->cadet; | 272 | struct GNUNET_CADET_Handle *h = ch->cadet; |
270 | 273 | ||
271 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 274 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
272 | "Destroying channel %X of %p\n", | 275 | "Destroying channel %X of %p\n", |
273 | htonl(ch->ccn.channel_of_client), | 276 | htonl (ch->ccn.channel_of_client), |
274 | h); | 277 | h); |
275 | GNUNET_assert( | 278 | GNUNET_assert ( |
276 | GNUNET_YES == | 279 | GNUNET_YES == |
277 | GNUNET_CONTAINER_multihashmap32_remove(h->channels, | 280 | GNUNET_CONTAINER_multihashmap32_remove (h->channels, |
278 | ntohl(ch->ccn.channel_of_client), | 281 | ntohl (ch->ccn.channel_of_client), |
279 | ch)); | 282 | ch)); |
280 | if (NULL != ch->mq_cont) | 283 | if (NULL != ch->mq_cont) |
281 | { | 284 | { |
282 | GNUNET_SCHEDULER_cancel(ch->mq_cont); | 285 | GNUNET_SCHEDULER_cancel (ch->mq_cont); |
283 | ch->mq_cont = NULL; | 286 | ch->mq_cont = NULL; |
284 | } | 287 | } |
285 | /* signal channel destruction */ | 288 | /* signal channel destruction */ |
286 | if (NULL != ch->disconnects) | 289 | if (NULL != ch->disconnects) |
287 | ch->disconnects(ch->ctx, ch); | 290 | ch->disconnects (ch->ctx, ch); |
288 | if (NULL != ch->pending_env) | 291 | if (NULL != ch->pending_env) |
289 | GNUNET_MQ_discard(ch->pending_env); | 292 | GNUNET_MQ_discard (ch->pending_env); |
290 | GNUNET_MQ_destroy(ch->mq); | 293 | GNUNET_MQ_destroy (ch->mq); |
291 | GNUNET_free(ch); | 294 | GNUNET_free (ch); |
292 | } | 295 | } |
293 | 296 | ||
294 | 297 | ||
@@ -299,7 +302,7 @@ destroy_channel(struct GNUNET_CADET_Channel *ch) | |||
299 | * @param h handle to the cadet | 302 | * @param h handle to the cadet |
300 | */ | 303 | */ |
301 | static void | 304 | static void |
302 | reconnect(struct GNUNET_CADET_Handle *h); | 305 | reconnect (struct GNUNET_CADET_Handle *h); |
303 | 306 | ||
304 | 307 | ||
305 | /** | 308 | /** |
@@ -312,17 +315,17 @@ reconnect(struct GNUNET_CADET_Handle *h); | |||
312 | * @return #GNUNET_OK (continue to iterate) | 315 | * @return #GNUNET_OK (continue to iterate) |
313 | */ | 316 | */ |
314 | static int | 317 | static int |
315 | open_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value) | 318 | open_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value) |
316 | { | 319 | { |
317 | struct GNUNET_CADET_Handle *h = cls; | 320 | struct GNUNET_CADET_Handle *h = cls; |
318 | struct GNUNET_CADET_Port *port = value; | 321 | struct GNUNET_CADET_Port *port = value; |
319 | struct GNUNET_CADET_PortMessage *msg; | 322 | struct GNUNET_CADET_PortMessage *msg; |
320 | struct GNUNET_MQ_Envelope *env; | 323 | struct GNUNET_MQ_Envelope *env; |
321 | 324 | ||
322 | (void)id; | 325 | (void) id; |
323 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN); | 326 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN); |
324 | msg->port = port->id; | 327 | msg->port = port->id; |
325 | GNUNET_MQ_send(h->mq, env); | 328 | GNUNET_MQ_send (h->mq, env); |
326 | return GNUNET_OK; | 329 | return GNUNET_OK; |
327 | } | 330 | } |
328 | 331 | ||
@@ -334,14 +337,14 @@ open_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value) | |||
334 | * @param cls closure (cadet handle) | 337 | * @param cls closure (cadet handle) |
335 | */ | 338 | */ |
336 | static void | 339 | static void |
337 | reconnect_cbk(void *cls) | 340 | reconnect_cbk (void *cls) |
338 | { | 341 | { |
339 | struct GNUNET_CADET_Handle *h = cls; | 342 | struct GNUNET_CADET_Handle *h = cls; |
340 | 343 | ||
341 | h->reconnect_task = NULL; | 344 | h->reconnect_task = NULL; |
342 | h->reconnect_time = GNUNET_TIME_STD_BACKOFF(h->reconnect_time); | 345 | h->reconnect_time = GNUNET_TIME_STD_BACKOFF (h->reconnect_time); |
343 | reconnect(h); | 346 | reconnect (h); |
344 | GNUNET_CONTAINER_multihashmap_iterate(h->ports, &open_port_cb, h); | 347 | GNUNET_CONTAINER_multihashmap_iterate (h->ports, &open_port_cb, h); |
345 | } | 348 | } |
346 | 349 | ||
347 | 350 | ||
@@ -351,12 +354,12 @@ reconnect_cbk(void *cls) | |||
351 | * @param ch Channel to notify about. | 354 | * @param ch Channel to notify about. |
352 | */ | 355 | */ |
353 | static void | 356 | static void |
354 | notify_window_size(struct GNUNET_CADET_Channel *ch) | 357 | notify_window_size (struct GNUNET_CADET_Channel *ch) |
355 | { | 358 | { |
356 | if (NULL != ch->window_changes) | 359 | if (NULL != ch->window_changes) |
357 | ch->window_changes(ch->ctx, | 360 | ch->window_changes (ch->ctx, |
358 | ch, /* FIXME: remove 'ch'? */ | 361 | ch, /* FIXME: remove 'ch'? */ |
359 | ch->allow_send); | 362 | ch->allow_send); |
360 | } | 363 | } |
361 | 364 | ||
362 | 365 | ||
@@ -366,32 +369,32 @@ notify_window_size(struct GNUNET_CADET_Channel *ch) | |||
366 | * @param cls Closure (channel whose mq to activate). | 369 | * @param cls Closure (channel whose mq to activate). |
367 | */ | 370 | */ |
368 | static void | 371 | static void |
369 | cadet_mq_send_now(void *cls) | 372 | cadet_mq_send_now (void *cls) |
370 | { | 373 | { |
371 | struct GNUNET_CADET_Channel *ch = cls; | 374 | struct GNUNET_CADET_Channel *ch = cls; |
372 | struct GNUNET_MQ_Envelope *env = ch->pending_env; | 375 | struct GNUNET_MQ_Envelope *env = ch->pending_env; |
373 | 376 | ||
374 | ch->mq_cont = NULL; | 377 | ch->mq_cont = NULL; |
375 | if (0 == ch->allow_send) | 378 | if (0 == ch->allow_send) |
376 | { | 379 | { |
377 | /* how did we get here? */ | 380 | /* how did we get here? */ |
378 | GNUNET_break(0); | 381 | GNUNET_break (0); |
379 | return; | 382 | return; |
380 | } | 383 | } |
381 | if (NULL == env) | 384 | if (NULL == env) |
382 | { | 385 | { |
383 | /* how did we get here? */ | 386 | /* how did we get here? */ |
384 | GNUNET_break(0); | 387 | GNUNET_break (0); |
385 | return; | 388 | return; |
386 | } | 389 | } |
387 | ch->allow_send--; | 390 | ch->allow_send--; |
388 | ch->pending_env = NULL; | 391 | ch->pending_env = NULL; |
389 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 392 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
390 | "Sending message on channel %s to CADET, new window size is %u\n", | 393 | "Sending message on channel %s to CADET, new window size is %u\n", |
391 | GNUNET_i2s(&ch->peer), | 394 | GNUNET_i2s (&ch->peer), |
392 | ch->allow_send); | 395 | ch->allow_send); |
393 | GNUNET_MQ_send(ch->cadet->mq, env); | 396 | GNUNET_MQ_send (ch->cadet->mq, env); |
394 | GNUNET_MQ_impl_send_continue(ch->mq); | 397 | GNUNET_MQ_impl_send_continue (ch->mq); |
395 | } | 398 | } |
396 | 399 | ||
397 | 400 | ||
@@ -408,9 +411,9 @@ cadet_mq_send_now(void *cls) | |||
408 | * @param impl_state state of the implementation | 411 | * @param impl_state state of the implementation |
409 | */ | 412 | */ |
410 | static void | 413 | static void |
411 | cadet_mq_send_impl(struct GNUNET_MQ_Handle *mq, | 414 | cadet_mq_send_impl (struct GNUNET_MQ_Handle *mq, |
412 | const struct GNUNET_MessageHeader *msg, | 415 | const struct GNUNET_MessageHeader *msg, |
413 | void *impl_state) | 416 | void *impl_state) |
414 | { | 417 | { |
415 | struct GNUNET_CADET_Channel *ch = impl_state; | 418 | struct GNUNET_CADET_Channel *ch = impl_state; |
416 | struct GNUNET_CADET_Handle *h = ch->cadet; | 419 | struct GNUNET_CADET_Handle *h = ch->cadet; |
@@ -421,31 +424,31 @@ cadet_mq_send_impl(struct GNUNET_MQ_Handle *mq, | |||
421 | enum GNUNET_MQ_PriorityPreferences pp; | 424 | enum GNUNET_MQ_PriorityPreferences pp; |
422 | 425 | ||
423 | if (NULL == h->mq) | 426 | if (NULL == h->mq) |
424 | { | 427 | { |
425 | /* We're currently reconnecting, pretend this worked */ | 428 | /* We're currently reconnecting, pretend this worked */ |
426 | GNUNET_MQ_impl_send_continue(mq); | 429 | GNUNET_MQ_impl_send_continue (mq); |
427 | return; | 430 | return; |
428 | } | 431 | } |
429 | orig_env = GNUNET_MQ_get_current_envelope(mq); | 432 | orig_env = GNUNET_MQ_get_current_envelope (mq); |
430 | pp = GNUNET_MQ_env_get_options(orig_env); | 433 | pp = GNUNET_MQ_env_get_options (orig_env); |
431 | 434 | ||
432 | /* check message size for sanity */ | 435 | /* check message size for sanity */ |
433 | msize = ntohs(msg->size); | 436 | msize = ntohs (msg->size); |
434 | if (msize > GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE) | 437 | if (msize > GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE) |
435 | { | 438 | { |
436 | GNUNET_break(0); | 439 | GNUNET_break (0); |
437 | GNUNET_MQ_impl_send_continue(mq); | 440 | GNUNET_MQ_impl_send_continue (mq); |
438 | return; | 441 | return; |
439 | } | 442 | } |
440 | env = GNUNET_MQ_msg_nested_mh(cadet_msg, | 443 | env = GNUNET_MQ_msg_nested_mh (cadet_msg, |
441 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, | 444 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, |
442 | msg); | 445 | msg); |
443 | cadet_msg->ccn = ch->ccn; | 446 | cadet_msg->ccn = ch->ccn; |
444 | cadet_msg->pp = htonl((uint32_t)pp); | 447 | cadet_msg->pp = htonl ((uint32_t) pp); |
445 | GNUNET_assert(NULL == ch->pending_env); | 448 | GNUNET_assert (NULL == ch->pending_env); |
446 | ch->pending_env = env; | 449 | ch->pending_env = env; |
447 | if (0 < ch->allow_send) | 450 | if (0 < ch->allow_send) |
448 | ch->mq_cont = GNUNET_SCHEDULER_add_now(&cadet_mq_send_now, ch); | 451 | ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch); |
449 | } | 452 | } |
450 | 453 | ||
451 | 454 | ||
@@ -457,11 +460,11 @@ cadet_mq_send_impl(struct GNUNET_MQ_Handle *mq, | |||
457 | * @param impl_state state of the implementation | 460 | * @param impl_state state of the implementation |
458 | */ | 461 | */ |
459 | static void | 462 | static void |
460 | cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state) | 463 | cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state) |
461 | { | 464 | { |
462 | struct GNUNET_CADET_Channel *ch = impl_state; | 465 | struct GNUNET_CADET_Channel *ch = impl_state; |
463 | 466 | ||
464 | GNUNET_assert(mq == ch->mq); | 467 | GNUNET_assert (mq == ch->mq); |
465 | ch->mq = NULL; | 468 | ch->mq = NULL; |
466 | } | 469 | } |
467 | 470 | ||
@@ -475,25 +478,25 @@ cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state) | |||
475 | * @param error error code | 478 | * @param error error code |
476 | */ | 479 | */ |
477 | static void | 480 | static void |
478 | cadet_mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | 481 | cadet_mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
479 | { | 482 | { |
480 | struct GNUNET_CADET_Channel *ch = cls; | 483 | struct GNUNET_CADET_Channel *ch = cls; |
481 | 484 | ||
482 | if (GNUNET_MQ_ERROR_NO_MATCH == error) | 485 | if (GNUNET_MQ_ERROR_NO_MATCH == error) |
483 | { | 486 | { |
484 | /* Got a message we did not understand, still try to continue! */ | 487 | /* Got a message we did not understand, still try to continue! */ |
485 | GNUNET_break_op(0); | 488 | GNUNET_break_op (0); |
486 | GNUNET_CADET_receive_done(ch); | 489 | GNUNET_CADET_receive_done (ch); |
487 | } | 490 | } |
488 | else | 491 | else |
489 | { | 492 | { |
490 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 493 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
491 | "MQ error in communication with CADET: %d\n", | 494 | "MQ error in communication with CADET: %d\n", |
492 | error); | 495 | error); |
493 | if (NULL != ch->disconnects) | 496 | if (NULL != ch->disconnects) |
494 | ch->disconnects(ch->ctx, ch); | 497 | ch->disconnects (ch->ctx, ch); |
495 | GNUNET_CADET_channel_destroy(ch); | 498 | GNUNET_CADET_channel_destroy (ch); |
496 | } | 499 | } |
497 | } | 500 | } |
498 | 501 | ||
499 | 502 | ||
@@ -505,19 +508,19 @@ cadet_mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
505 | * @param impl_state state specific to the implementation | 508 | * @param impl_state state specific to the implementation |
506 | */ | 509 | */ |
507 | static void | 510 | static void |
508 | cadet_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state) | 511 | cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state) |
509 | { | 512 | { |
510 | struct GNUNET_CADET_Channel *ch = impl_state; | 513 | struct GNUNET_CADET_Channel *ch = impl_state; |
511 | 514 | ||
512 | (void)mq; | 515 | (void) mq; |
513 | GNUNET_assert(NULL != ch->pending_env); | 516 | GNUNET_assert (NULL != ch->pending_env); |
514 | GNUNET_MQ_discard(ch->pending_env); | 517 | GNUNET_MQ_discard (ch->pending_env); |
515 | ch->pending_env = NULL; | 518 | ch->pending_env = NULL; |
516 | if (NULL != ch->mq_cont) | 519 | if (NULL != ch->mq_cont) |
517 | { | 520 | { |
518 | GNUNET_SCHEDULER_cancel(ch->mq_cont); | 521 | GNUNET_SCHEDULER_cancel (ch->mq_cont); |
519 | ch->mq_cont = NULL; | 522 | ch->mq_cont = NULL; |
520 | } | 523 | } |
521 | } | 524 | } |
522 | 525 | ||
523 | 526 | ||
@@ -528,7 +531,7 @@ cadet_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state) | |||
528 | * @param msg A message with the details of the new incoming channel | 531 | * @param msg A message with the details of the new incoming channel |
529 | */ | 532 | */ |
530 | static void | 533 | static void |
531 | handle_channel_created( | 534 | handle_channel_created ( |
532 | void *cls, | 535 | void *cls, |
533 | const struct GNUNET_CADET_LocalChannelCreateMessage *msg) | 536 | const struct GNUNET_CADET_LocalChannelCreateMessage *msg) |
534 | { | 537 | { |
@@ -540,52 +543,52 @@ handle_channel_created( | |||
540 | 543 | ||
541 | ccn = msg->ccn; | 544 | ccn = msg->ccn; |
542 | port_number = &msg->port; | 545 | port_number = &msg->port; |
543 | if (ntohl(ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI) | 546 | if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI) |
544 | { | 547 | { |
545 | GNUNET_break(0); | 548 | GNUNET_break (0); |
546 | return; | 549 | return; |
547 | } | 550 | } |
548 | port = find_port(h, port_number); | 551 | port = find_port (h, port_number); |
549 | if (NULL == port) | 552 | if (NULL == port) |
550 | { | 553 | { |
551 | /* We could have closed the port but the service didn't know about it yet | 554 | /* We could have closed the port but the service didn't know about it yet |
552 | * This is not an error. | 555 | * This is not an error. |
553 | */ | 556 | */ |
554 | struct GNUNET_CADET_LocalChannelDestroyMessage *d_msg; | 557 | struct GNUNET_CADET_LocalChannelDestroyMessage *d_msg; |
555 | struct GNUNET_MQ_Envelope *env; | 558 | struct GNUNET_MQ_Envelope *env; |
556 | 559 | ||
557 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 560 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
558 | "No handler for incoming channel %X (on port %s, recently closed?)\n", | 561 | "No handler for incoming channel %X (on port %s, recently closed?)\n", |
559 | ntohl(ccn.channel_of_client), | 562 | ntohl (ccn.channel_of_client), |
560 | GNUNET_h2s(port_number)); | 563 | GNUNET_h2s (port_number)); |
561 | env = | 564 | env = |
562 | GNUNET_MQ_msg(d_msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY); | 565 | GNUNET_MQ_msg (d_msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY); |
563 | d_msg->ccn = msg->ccn; | 566 | d_msg->ccn = msg->ccn; |
564 | GNUNET_MQ_send(h->mq, env); | 567 | GNUNET_MQ_send (h->mq, env); |
565 | return; | 568 | return; |
566 | } | 569 | } |
567 | 570 | ||
568 | ch = create_channel(h, &ccn); | 571 | ch = create_channel (h, &ccn); |
569 | ch->peer = msg->peer; | 572 | ch->peer = msg->peer; |
570 | ch->incoming_port = port; | 573 | ch->incoming_port = port; |
571 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 574 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
572 | "Creating incoming channel %X [%s] %p\n", | 575 | "Creating incoming channel %X [%s] %p\n", |
573 | ntohl(ccn.channel_of_client), | 576 | ntohl (ccn.channel_of_client), |
574 | GNUNET_h2s(port_number), | 577 | GNUNET_h2s (port_number), |
575 | ch); | 578 | ch); |
576 | 579 | ||
577 | GNUNET_assert(NULL != port->connects); | 580 | GNUNET_assert (NULL != port->connects); |
578 | ch->window_changes = port->window_changes; | 581 | ch->window_changes = port->window_changes; |
579 | ch->disconnects = port->disconnects; | 582 | ch->disconnects = port->disconnects; |
580 | ch->mq = GNUNET_MQ_queue_for_callbacks(&cadet_mq_send_impl, | 583 | ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl, |
581 | &cadet_mq_destroy_impl, | 584 | &cadet_mq_destroy_impl, |
582 | &cadet_mq_cancel_impl, | 585 | &cadet_mq_cancel_impl, |
583 | ch, | 586 | ch, |
584 | port->handlers, | 587 | port->handlers, |
585 | &cadet_mq_error_handler, | 588 | &cadet_mq_error_handler, |
586 | ch); | 589 | ch); |
587 | ch->ctx = port->connects(port->cls, ch, &msg->peer); | 590 | ch->ctx = port->connects (port->cls, ch, &msg->peer); |
588 | GNUNET_MQ_set_handlers_closure(ch->mq, ch->ctx); | 591 | GNUNET_MQ_set_handlers_closure (ch->mq, ch->ctx); |
589 | } | 592 | } |
590 | 593 | ||
591 | 594 | ||
@@ -596,25 +599,25 @@ handle_channel_created( | |||
596 | * @param msg A message with the details of the channel being destroyed | 599 | * @param msg A message with the details of the channel being destroyed |
597 | */ | 600 | */ |
598 | static void | 601 | static void |
599 | handle_channel_destroy( | 602 | handle_channel_destroy ( |
600 | void *cls, | 603 | void *cls, |
601 | const struct GNUNET_CADET_LocalChannelDestroyMessage *msg) | 604 | const struct GNUNET_CADET_LocalChannelDestroyMessage *msg) |
602 | { | 605 | { |
603 | struct GNUNET_CADET_Handle *h = cls; | 606 | struct GNUNET_CADET_Handle *h = cls; |
604 | struct GNUNET_CADET_Channel *ch; | 607 | struct GNUNET_CADET_Channel *ch; |
605 | 608 | ||
606 | ch = find_channel(h, msg->ccn); | 609 | ch = find_channel (h, msg->ccn); |
607 | if (NULL == ch) | 610 | if (NULL == ch) |
608 | { | 611 | { |
609 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 612 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
610 | "Received channel destroy for unknown channel %X from CADET service (recently close?)\n", | 613 | "Received channel destroy for unknown channel %X from CADET service (recently close?)\n", |
611 | ntohl(msg->ccn.channel_of_client)); | 614 | ntohl (msg->ccn.channel_of_client)); |
612 | return; | 615 | return; |
613 | } | 616 | } |
614 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 617 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
615 | "Received channel destroy for channel %X from CADET service\n", | 618 | "Received channel destroy for channel %X from CADET service\n", |
616 | ntohl(msg->ccn.channel_of_client)); | 619 | ntohl (msg->ccn.channel_of_client)); |
617 | destroy_channel(ch); | 620 | destroy_channel (ch); |
618 | } | 621 | } |
619 | 622 | ||
620 | 623 | ||
@@ -627,17 +630,17 @@ handle_channel_destroy( | |||
627 | * #GNUNET_SYSERR otherwise | 630 | * #GNUNET_SYSERR otherwise |
628 | */ | 631 | */ |
629 | static int | 632 | static int |
630 | check_local_data(void *cls, const struct GNUNET_CADET_LocalData *message) | 633 | check_local_data (void *cls, const struct GNUNET_CADET_LocalData *message) |
631 | { | 634 | { |
632 | uint16_t size; | 635 | uint16_t size; |
633 | 636 | ||
634 | (void)cls; | 637 | (void) cls; |
635 | size = ntohs(message->header.size); | 638 | size = ntohs (message->header.size); |
636 | if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size) | 639 | if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size) |
637 | { | 640 | { |
638 | GNUNET_break(0); | 641 | GNUNET_break (0); |
639 | return GNUNET_SYSERR; | 642 | return GNUNET_SYSERR; |
640 | } | 643 | } |
641 | return GNUNET_OK; | 644 | return GNUNET_OK; |
642 | } | 645 | } |
643 | 646 | ||
@@ -649,7 +652,7 @@ check_local_data(void *cls, const struct GNUNET_CADET_LocalData *message) | |||
649 | * @param message A message encapsulating the data | 652 | * @param message A message encapsulating the data |
650 | */ | 653 | */ |
651 | static void | 654 | static void |
652 | handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message) | 655 | handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *message) |
653 | { | 656 | { |
654 | struct GNUNET_CADET_Handle *h = cls; | 657 | struct GNUNET_CADET_Handle *h = cls; |
655 | const struct GNUNET_MessageHeader *payload; | 658 | const struct GNUNET_MessageHeader *payload; |
@@ -657,25 +660,25 @@ handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message) | |||
657 | uint16_t type; | 660 | uint16_t type; |
658 | int fwd; | 661 | int fwd; |
659 | 662 | ||
660 | ch = find_channel(h, message->ccn); | 663 | ch = find_channel (h, message->ccn); |
661 | if (NULL == ch) | 664 | if (NULL == ch) |
662 | { | 665 | { |
663 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 666 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
664 | "Unknown channel %X for incoming data (recently closed?)\n", | 667 | "Unknown channel %X for incoming data (recently closed?)\n", |
665 | ntohl(message->ccn.channel_of_client)); | 668 | ntohl (message->ccn.channel_of_client)); |
666 | return; | 669 | return; |
667 | } | 670 | } |
668 | 671 | ||
669 | payload = (const struct GNUNET_MessageHeader *)&message[1]; | 672 | payload = (const struct GNUNET_MessageHeader *) &message[1]; |
670 | type = ntohs(payload->type); | 673 | type = ntohs (payload->type); |
671 | fwd = ntohl(ch->ccn.channel_of_client) <= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI; | 674 | fwd = ntohl (ch->ccn.channel_of_client) <= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI; |
672 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 675 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
673 | "Got a %s data on channel %s [%X] of type %u\n", | 676 | "Got a %s data on channel %s [%X] of type %u\n", |
674 | fwd ? "FWD" : "BWD", | 677 | fwd ? "FWD" : "BWD", |
675 | GNUNET_i2s(&ch->peer), | 678 | GNUNET_i2s (&ch->peer), |
676 | ntohl(message->ccn.channel_of_client), | 679 | ntohl (message->ccn.channel_of_client), |
677 | type); | 680 | type); |
678 | GNUNET_MQ_inject_message(ch->mq, payload); | 681 | GNUNET_MQ_inject_message (ch->mq, payload); |
679 | } | 682 | } |
680 | 683 | ||
681 | 684 | ||
@@ -687,37 +690,37 @@ handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message) | |||
687 | * @param message Message itself. | 690 | * @param message Message itself. |
688 | */ | 691 | */ |
689 | static void | 692 | static void |
690 | handle_local_ack(void *cls, const struct GNUNET_CADET_LocalAck *message) | 693 | handle_local_ack (void *cls, const struct GNUNET_CADET_LocalAck *message) |
691 | { | 694 | { |
692 | struct GNUNET_CADET_Handle *h = cls; | 695 | struct GNUNET_CADET_Handle *h = cls; |
693 | struct GNUNET_CADET_Channel *ch; | 696 | struct GNUNET_CADET_Channel *ch; |
694 | 697 | ||
695 | ch = find_channel(h, message->ccn); | 698 | ch = find_channel (h, message->ccn); |
696 | if (NULL == ch) | 699 | if (NULL == ch) |
697 | { | 700 | { |
698 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 701 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
699 | "ACK on unknown channel %X\n", | 702 | "ACK on unknown channel %X\n", |
700 | ntohl(message->ccn.channel_of_client)); | 703 | ntohl (message->ccn.channel_of_client)); |
701 | return; | 704 | return; |
702 | } | 705 | } |
703 | ch->allow_send++; | 706 | ch->allow_send++; |
704 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 707 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
705 | "Got an ACK on mq channel %X (peer %s); new window size is %u!\n", | 708 | "Got an ACK on mq channel %X (peer %s); new window size is %u!\n", |
706 | ntohl(ch->ccn.channel_of_client), | 709 | ntohl (ch->ccn.channel_of_client), |
707 | GNUNET_i2s(&ch->peer), | 710 | GNUNET_i2s (&ch->peer), |
708 | ch->allow_send); | 711 | ch->allow_send); |
709 | if (NULL == ch->pending_env) | 712 | if (NULL == ch->pending_env) |
710 | { | 713 | { |
711 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 714 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
712 | "Got an ACK on mq channel %X, allow send now %u!\n", | 715 | "Got an ACK on mq channel %X, allow send now %u!\n", |
713 | ntohl(ch->ccn.channel_of_client), | 716 | ntohl (ch->ccn.channel_of_client), |
714 | ch->allow_send); | 717 | ch->allow_send); |
715 | notify_window_size(ch); | 718 | notify_window_size (ch); |
716 | return; | 719 | return; |
717 | } | 720 | } |
718 | if (NULL != ch->mq_cont) | 721 | if (NULL != ch->mq_cont) |
719 | return; /* already working on it! */ | 722 | return; /* already working on it! */ |
720 | ch->mq_cont = GNUNET_SCHEDULER_add_now(&cadet_mq_send_now, ch); | 723 | ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch); |
721 | } | 724 | } |
722 | 725 | ||
723 | 726 | ||
@@ -731,16 +734,16 @@ handle_local_ack(void *cls, const struct GNUNET_CADET_LocalAck *message) | |||
731 | * @return #GNUNET_OK (continue to iterate) | 734 | * @return #GNUNET_OK (continue to iterate) |
732 | */ | 735 | */ |
733 | static int | 736 | static int |
734 | destroy_channel_cb(void *cls, uint32_t cid, void *value) | 737 | destroy_channel_cb (void *cls, uint32_t cid, void *value) |
735 | { | 738 | { |
736 | /* struct GNUNET_CADET_Handle *handle = cls; */ | 739 | /* struct GNUNET_CADET_Handle *handle = cls; */ |
737 | struct GNUNET_CADET_Channel *ch = value; | 740 | struct GNUNET_CADET_Channel *ch = value; |
738 | 741 | ||
739 | (void)cls; | 742 | (void) cls; |
740 | (void)cid; | 743 | (void) cid; |
741 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 744 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
742 | "Destroying channel due to GNUNET_CADET_disconnect()\n"); | 745 | "Destroying channel due to GNUNET_CADET_disconnect()\n"); |
743 | destroy_channel(ch); | 746 | destroy_channel (ch); |
744 | return GNUNET_OK; | 747 | return GNUNET_OK; |
745 | } | 748 | } |
746 | 749 | ||
@@ -754,17 +757,17 @@ destroy_channel_cb(void *cls, uint32_t cid, void *value) | |||
754 | * @param error error code | 757 | * @param error error code |
755 | */ | 758 | */ |
756 | static void | 759 | static void |
757 | handle_mq_error(void *cls, enum GNUNET_MQ_Error error) | 760 | handle_mq_error (void *cls, enum GNUNET_MQ_Error error) |
758 | { | 761 | { |
759 | struct GNUNET_CADET_Handle *h = cls; | 762 | struct GNUNET_CADET_Handle *h = cls; |
760 | 763 | ||
761 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error); | 764 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error); |
762 | GNUNET_CONTAINER_multihashmap32_iterate(h->channels, &destroy_channel_cb, h); | 765 | GNUNET_CONTAINER_multihashmap32_iterate (h->channels, &destroy_channel_cb, h); |
763 | GNUNET_MQ_destroy(h->mq); | 766 | GNUNET_MQ_destroy (h->mq); |
764 | h->mq = NULL; | 767 | h->mq = NULL; |
765 | GNUNET_assert(NULL == h->reconnect_task); | 768 | GNUNET_assert (NULL == h->reconnect_task); |
766 | h->reconnect_task = | 769 | h->reconnect_task = |
767 | GNUNET_SCHEDULER_add_delayed(h->reconnect_time, &reconnect_cbk, h); | 770 | GNUNET_SCHEDULER_add_delayed (h->reconnect_time, &reconnect_cbk, h); |
768 | } | 771 | } |
769 | 772 | ||
770 | 773 | ||
@@ -775,30 +778,30 @@ handle_mq_error(void *cls, enum GNUNET_MQ_Error error) | |||
775 | * @param h handle to the cadet | 778 | * @param h handle to the cadet |
776 | */ | 779 | */ |
777 | static void | 780 | static void |
778 | reconnect(struct GNUNET_CADET_Handle *h) | 781 | reconnect (struct GNUNET_CADET_Handle *h) |
779 | { | 782 | { |
780 | struct GNUNET_MQ_MessageHandler handlers[] = | 783 | struct GNUNET_MQ_MessageHandler handlers[] = |
781 | { GNUNET_MQ_hd_fixed_size(channel_created, | 784 | { GNUNET_MQ_hd_fixed_size (channel_created, |
782 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, | 785 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, |
783 | struct GNUNET_CADET_LocalChannelCreateMessage, | 786 | struct GNUNET_CADET_LocalChannelCreateMessage, |
784 | h), | 787 | h), |
785 | GNUNET_MQ_hd_fixed_size(channel_destroy, | 788 | GNUNET_MQ_hd_fixed_size (channel_destroy, |
786 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, | 789 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, |
787 | struct GNUNET_CADET_LocalChannelDestroyMessage, | 790 | struct GNUNET_CADET_LocalChannelDestroyMessage, |
788 | h), | 791 | h), |
789 | GNUNET_MQ_hd_var_size(local_data, | 792 | GNUNET_MQ_hd_var_size (local_data, |
790 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, | 793 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, |
791 | struct GNUNET_CADET_LocalData, | 794 | struct GNUNET_CADET_LocalData, |
792 | h), | 795 | h), |
793 | GNUNET_MQ_hd_fixed_size(local_ack, | 796 | GNUNET_MQ_hd_fixed_size (local_ack, |
794 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, | 797 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, |
795 | struct GNUNET_CADET_LocalAck, | 798 | struct GNUNET_CADET_LocalAck, |
796 | h), | 799 | h), |
797 | GNUNET_MQ_handler_end() }; | 800 | GNUNET_MQ_handler_end () }; |
798 | 801 | ||
799 | GNUNET_assert(NULL == h->mq); | 802 | GNUNET_assert (NULL == h->mq); |
800 | h->mq = | 803 | h->mq = |
801 | GNUNET_CLIENT_connect(h->cfg, "cadet", handlers, &handle_mq_error, h); | 804 | GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h); |
802 | } | 805 | } |
803 | 806 | ||
804 | 807 | ||
@@ -812,16 +815,16 @@ reconnect(struct GNUNET_CADET_Handle *h) | |||
812 | * @return #GNUNET_OK (continue to iterate) | 815 | * @return #GNUNET_OK (continue to iterate) |
813 | */ | 816 | */ |
814 | static int | 817 | static int |
815 | destroy_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value) | 818 | destroy_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value) |
816 | { | 819 | { |
817 | /* struct GNUNET_CADET_Handle *handle = cls; */ | 820 | /* struct GNUNET_CADET_Handle *handle = cls; */ |
818 | struct GNUNET_CADET_Port *port = value; | 821 | struct GNUNET_CADET_Port *port = value; |
819 | 822 | ||
820 | (void)cls; | 823 | (void) cls; |
821 | (void)id; | 824 | (void) id; |
822 | /* This is a warning, the app should have cleanly closed all open ports */ | 825 | /* This is a warning, the app should have cleanly closed all open ports */ |
823 | GNUNET_break(0); | 826 | GNUNET_break (0); |
824 | GNUNET_CADET_close_port(port); | 827 | GNUNET_CADET_close_port (port); |
825 | return GNUNET_OK; | 828 | return GNUNET_OK; |
826 | } | 829 | } |
827 | 830 | ||
@@ -835,29 +838,29 @@ destroy_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value) | |||
835 | * @param handle connection to cadet to disconnect | 838 | * @param handle connection to cadet to disconnect |
836 | */ | 839 | */ |
837 | void | 840 | void |
838 | GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle) | 841 | GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle) |
839 | { | 842 | { |
840 | GNUNET_CONTAINER_multihashmap_iterate(handle->ports, | 843 | GNUNET_CONTAINER_multihashmap_iterate (handle->ports, |
841 | &destroy_port_cb, | 844 | &destroy_port_cb, |
842 | handle); | 845 | handle); |
843 | GNUNET_CONTAINER_multihashmap_destroy(handle->ports); | 846 | GNUNET_CONTAINER_multihashmap_destroy (handle->ports); |
844 | handle->ports = NULL; | 847 | handle->ports = NULL; |
845 | GNUNET_CONTAINER_multihashmap32_iterate(handle->channels, | 848 | GNUNET_CONTAINER_multihashmap32_iterate (handle->channels, |
846 | &destroy_channel_cb, | 849 | &destroy_channel_cb, |
847 | handle); | 850 | handle); |
848 | GNUNET_CONTAINER_multihashmap32_destroy(handle->channels); | 851 | GNUNET_CONTAINER_multihashmap32_destroy (handle->channels); |
849 | handle->channels = NULL; | 852 | handle->channels = NULL; |
850 | if (NULL != handle->mq) | 853 | if (NULL != handle->mq) |
851 | { | 854 | { |
852 | GNUNET_MQ_destroy(handle->mq); | 855 | GNUNET_MQ_destroy (handle->mq); |
853 | handle->mq = NULL; | 856 | handle->mq = NULL; |
854 | } | 857 | } |
855 | if (NULL != handle->reconnect_task) | 858 | if (NULL != handle->reconnect_task) |
856 | { | 859 | { |
857 | GNUNET_SCHEDULER_cancel(handle->reconnect_task); | 860 | GNUNET_SCHEDULER_cancel (handle->reconnect_task); |
858 | handle->reconnect_task = NULL; | 861 | handle->reconnect_task = NULL; |
859 | } | 862 | } |
860 | GNUNET_free(handle); | 863 | GNUNET_free (handle); |
861 | } | 864 | } |
862 | 865 | ||
863 | 866 | ||
@@ -868,22 +871,22 @@ GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle) | |||
868 | * @param p Port handle. | 871 | * @param p Port handle. |
869 | */ | 872 | */ |
870 | void | 873 | void |
871 | GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p) | 874 | GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p) |
872 | { | 875 | { |
873 | GNUNET_assert( | 876 | GNUNET_assert ( |
874 | GNUNET_YES == | 877 | GNUNET_YES == |
875 | GNUNET_CONTAINER_multihashmap_remove(p->cadet->ports, &p->id, p)); | 878 | GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports, &p->id, p)); |
876 | if (NULL != p->cadet->mq) | 879 | if (NULL != p->cadet->mq) |
877 | { | 880 | { |
878 | struct GNUNET_CADET_PortMessage *msg; | 881 | struct GNUNET_CADET_PortMessage *msg; |
879 | struct GNUNET_MQ_Envelope *env; | 882 | struct GNUNET_MQ_Envelope *env; |
880 | 883 | ||
881 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE); | 884 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE); |
882 | msg->port = p->id; | 885 | msg->port = p->id; |
883 | GNUNET_MQ_send(p->cadet->mq, env); | 886 | GNUNET_MQ_send (p->cadet->mq, env); |
884 | } | 887 | } |
885 | GNUNET_free_non_null(p->handlers); | 888 | GNUNET_free_non_null (p->handlers); |
886 | GNUNET_free(p); | 889 | GNUNET_free (p); |
887 | } | 890 | } |
888 | 891 | ||
889 | 892 | ||
@@ -897,22 +900,22 @@ GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p) | |||
897 | * @param channel Channel handle, becomes invalid after this call. | 900 | * @param channel Channel handle, becomes invalid after this call. |
898 | */ | 901 | */ |
899 | void | 902 | void |
900 | GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel) | 903 | GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel) |
901 | { | 904 | { |
902 | struct GNUNET_CADET_Handle *h = channel->cadet; | 905 | struct GNUNET_CADET_Handle *h = channel->cadet; |
903 | struct GNUNET_CADET_LocalChannelDestroyMessage *msg; | 906 | struct GNUNET_CADET_LocalChannelDestroyMessage *msg; |
904 | struct GNUNET_MQ_Envelope *env; | 907 | struct GNUNET_MQ_Envelope *env; |
905 | 908 | ||
906 | if (NULL != h->mq) | 909 | if (NULL != h->mq) |
907 | { | 910 | { |
908 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY); | 911 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY); |
909 | msg->ccn = channel->ccn; | 912 | msg->ccn = channel->ccn; |
910 | GNUNET_MQ_send(h->mq, env); | 913 | GNUNET_MQ_send (h->mq, env); |
911 | } | 914 | } |
912 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 915 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
913 | "Destroying channel due to GNUNET_CADET_channel_destroy()\n"); | 916 | "Destroying channel due to GNUNET_CADET_channel_destroy()\n"); |
914 | channel->disconnects = NULL; | 917 | channel->disconnects = NULL; |
915 | destroy_channel(channel); | 918 | destroy_channel (channel); |
916 | } | 919 | } |
917 | 920 | ||
918 | 921 | ||
@@ -926,19 +929,19 @@ GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel) | |||
926 | * @return Union with an answer to the query. | 929 | * @return Union with an answer to the query. |
927 | */ | 930 | */ |
928 | const union GNUNET_CADET_ChannelInfo * | 931 | const union GNUNET_CADET_ChannelInfo * |
929 | GNUNET_CADET_channel_get_info(struct GNUNET_CADET_Channel *channel, | 932 | GNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel, |
930 | enum GNUNET_CADET_ChannelInfoOption option, | 933 | enum GNUNET_CADET_ChannelInfoOption option, |
931 | ...) | 934 | ...) |
932 | { | 935 | { |
933 | switch (option) | 936 | switch (option) |
934 | { | 937 | { |
935 | case GNUNET_CADET_OPTION_PEER: | 938 | case GNUNET_CADET_OPTION_PEER: |
936 | return (const union GNUNET_CADET_ChannelInfo *)&channel->peer; | 939 | return (const union GNUNET_CADET_ChannelInfo *) &channel->peer; |
937 | 940 | ||
938 | default: | 941 | default: |
939 | GNUNET_break(0); | 942 | GNUNET_break (0); |
940 | return NULL; | 943 | return NULL; |
941 | } | 944 | } |
942 | } | 945 | } |
943 | 946 | ||
944 | 947 | ||
@@ -948,17 +951,17 @@ GNUNET_CADET_channel_get_info(struct GNUNET_CADET_Channel *channel, | |||
948 | * @param ch Channel on which to send the ACK. | 951 | * @param ch Channel on which to send the ACK. |
949 | */ | 952 | */ |
950 | void | 953 | void |
951 | GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel) | 954 | GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel) |
952 | { | 955 | { |
953 | struct GNUNET_CADET_LocalAck *msg; | 956 | struct GNUNET_CADET_LocalAck *msg; |
954 | struct GNUNET_MQ_Envelope *env; | 957 | struct GNUNET_MQ_Envelope *env; |
955 | 958 | ||
956 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK); | 959 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK); |
957 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 960 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
958 | "Sending ACK on channel %X\n", | 961 | "Sending ACK on channel %X\n", |
959 | ntohl(channel->ccn.channel_of_client)); | 962 | ntohl (channel->ccn.channel_of_client)); |
960 | msg->ccn = channel->ccn; | 963 | msg->ccn = channel->ccn; |
961 | GNUNET_MQ_send(channel->cadet->mq, env); | 964 | GNUNET_MQ_send (channel->cadet->mq, env); |
962 | } | 965 | } |
963 | 966 | ||
964 | 967 | ||
@@ -970,23 +973,23 @@ GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel) | |||
970 | * @return Handle to the cadet service NULL on error. | 973 | * @return Handle to the cadet service NULL on error. |
971 | */ | 974 | */ |
972 | struct GNUNET_CADET_Handle * | 975 | struct GNUNET_CADET_Handle * |
973 | GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg) | 976 | GNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg) |
974 | { | 977 | { |
975 | struct GNUNET_CADET_Handle *h; | 978 | struct GNUNET_CADET_Handle *h; |
976 | 979 | ||
977 | LOG(GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n"); | 980 | LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n"); |
978 | h = GNUNET_new(struct GNUNET_CADET_Handle); | 981 | h = GNUNET_new (struct GNUNET_CADET_Handle); |
979 | h->cfg = cfg; | 982 | h->cfg = cfg; |
980 | h->ports = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_YES); | 983 | h->ports = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_YES); |
981 | h->channels = GNUNET_CONTAINER_multihashmap32_create(4); | 984 | h->channels = GNUNET_CONTAINER_multihashmap32_create (4); |
982 | reconnect(h); | 985 | reconnect (h); |
983 | if (NULL == h->mq) | 986 | if (NULL == h->mq) |
984 | { | 987 | { |
985 | GNUNET_break(0); | 988 | GNUNET_break (0); |
986 | GNUNET_CADET_disconnect(h); | 989 | GNUNET_CADET_disconnect (h); |
987 | return NULL; | 990 | return NULL; |
988 | } | 991 | } |
989 | h->next_ccn.channel_of_client = htonl(GNUNET_CADET_LOCAL_CHANNEL_ID_CLI); | 992 | h->next_ccn.channel_of_client = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI); |
990 | return h; | 993 | return h; |
991 | } | 994 | } |
992 | 995 | ||
@@ -1004,41 +1007,41 @@ GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
1004 | * @return Port handle, NULL if port is in use | 1007 | * @return Port handle, NULL if port is in use |
1005 | */ | 1008 | */ |
1006 | struct GNUNET_CADET_Port * | 1009 | struct GNUNET_CADET_Port * |
1007 | GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, | 1010 | GNUNET_CADET_open_port (struct GNUNET_CADET_Handle *h, |
1008 | const struct GNUNET_HashCode *port, | 1011 | const struct GNUNET_HashCode *port, |
1009 | GNUNET_CADET_ConnectEventHandler connects, | 1012 | GNUNET_CADET_ConnectEventHandler connects, |
1010 | void *connects_cls, | 1013 | void *connects_cls, |
1011 | GNUNET_CADET_WindowSizeEventHandler window_changes, | 1014 | GNUNET_CADET_WindowSizeEventHandler window_changes, |
1012 | GNUNET_CADET_DisconnectEventHandler disconnects, | 1015 | GNUNET_CADET_DisconnectEventHandler disconnects, |
1013 | const struct GNUNET_MQ_MessageHandler *handlers) | 1016 | const struct GNUNET_MQ_MessageHandler *handlers) |
1014 | { | 1017 | { |
1015 | struct GNUNET_CADET_Port *p; | 1018 | struct GNUNET_CADET_Port *p; |
1016 | 1019 | ||
1017 | GNUNET_assert(NULL != connects); | 1020 | GNUNET_assert (NULL != connects); |
1018 | GNUNET_assert(NULL != disconnects); | 1021 | GNUNET_assert (NULL != disconnects); |
1019 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1022 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1020 | "Listening to CADET port %s\n", | 1023 | "Listening to CADET port %s\n", |
1021 | GNUNET_h2s(port)); | 1024 | GNUNET_h2s (port)); |
1022 | 1025 | ||
1023 | p = GNUNET_new(struct GNUNET_CADET_Port); | 1026 | p = GNUNET_new (struct GNUNET_CADET_Port); |
1024 | p->cadet = h; | 1027 | p->cadet = h; |
1025 | p->id = *port; | 1028 | p->id = *port; |
1026 | if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put( | 1029 | if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put ( |
1027 | h->ports, | 1030 | h->ports, |
1028 | &p->id, | 1031 | &p->id, |
1029 | p, | 1032 | p, |
1030 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) | 1033 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) |
1031 | { | 1034 | { |
1032 | GNUNET_free(p); | 1035 | GNUNET_free (p); |
1033 | return NULL; | 1036 | return NULL; |
1034 | } | 1037 | } |
1035 | p->connects = connects; | 1038 | p->connects = connects; |
1036 | p->cls = connects_cls; | 1039 | p->cls = connects_cls; |
1037 | p->window_changes = window_changes; | 1040 | p->window_changes = window_changes; |
1038 | p->disconnects = disconnects; | 1041 | p->disconnects = disconnects; |
1039 | p->handlers = GNUNET_MQ_copy_handlers(handlers); | 1042 | p->handlers = GNUNET_MQ_copy_handlers (handlers); |
1040 | 1043 | ||
1041 | GNUNET_assert(GNUNET_OK == open_port_cb(h, &p->id, p)); | 1044 | GNUNET_assert (GNUNET_OK == open_port_cb (h, &p->id, p)); |
1042 | return p; | 1045 | return p; |
1043 | } | 1046 | } |
1044 | 1047 | ||
@@ -1062,45 +1065,45 @@ GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, | |||
1062 | * @return Handle to the channel. | 1065 | * @return Handle to the channel. |
1063 | */ | 1066 | */ |
1064 | struct GNUNET_CADET_Channel * | 1067 | struct GNUNET_CADET_Channel * |
1065 | GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, | 1068 | GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h, |
1066 | void *channel_cls, | 1069 | void *channel_cls, |
1067 | const struct GNUNET_PeerIdentity *destination, | 1070 | const struct GNUNET_PeerIdentity *destination, |
1068 | const struct GNUNET_HashCode *port, | 1071 | const struct GNUNET_HashCode *port, |
1069 | GNUNET_CADET_WindowSizeEventHandler window_changes, | 1072 | GNUNET_CADET_WindowSizeEventHandler window_changes, |
1070 | GNUNET_CADET_DisconnectEventHandler disconnects, | 1073 | GNUNET_CADET_DisconnectEventHandler disconnects, |
1071 | const struct GNUNET_MQ_MessageHandler *handlers) | 1074 | const struct GNUNET_MQ_MessageHandler *handlers) |
1072 | { | 1075 | { |
1073 | struct GNUNET_CADET_Channel *ch; | 1076 | struct GNUNET_CADET_Channel *ch; |
1074 | struct GNUNET_CADET_LocalChannelCreateMessage *msg; | 1077 | struct GNUNET_CADET_LocalChannelCreateMessage *msg; |
1075 | struct GNUNET_MQ_Envelope *env; | 1078 | struct GNUNET_MQ_Envelope *env; |
1076 | 1079 | ||
1077 | GNUNET_assert(NULL != disconnects); | 1080 | GNUNET_assert (NULL != disconnects); |
1078 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1081 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1079 | "Creating channel to peer %s at port %s\n", | 1082 | "Creating channel to peer %s at port %s\n", |
1080 | GNUNET_i2s(destination), | 1083 | GNUNET_i2s (destination), |
1081 | GNUNET_h2s(port)); | 1084 | GNUNET_h2s (port)); |
1082 | ch = create_channel(h, NULL); | 1085 | ch = create_channel (h, NULL); |
1083 | ch->ctx = channel_cls; | 1086 | ch->ctx = channel_cls; |
1084 | ch->peer = *destination; | 1087 | ch->peer = *destination; |
1085 | ch->window_changes = window_changes; | 1088 | ch->window_changes = window_changes; |
1086 | ch->disconnects = disconnects; | 1089 | ch->disconnects = disconnects; |
1087 | 1090 | ||
1088 | /* Create MQ for channel */ | 1091 | /* Create MQ for channel */ |
1089 | ch->mq = GNUNET_MQ_queue_for_callbacks(&cadet_mq_send_impl, | 1092 | ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl, |
1090 | &cadet_mq_destroy_impl, | 1093 | &cadet_mq_destroy_impl, |
1091 | &cadet_mq_cancel_impl, | 1094 | &cadet_mq_cancel_impl, |
1092 | ch, | 1095 | ch, |
1093 | handlers, | 1096 | handlers, |
1094 | &cadet_mq_error_handler, | 1097 | &cadet_mq_error_handler, |
1095 | ch); | 1098 | ch); |
1096 | GNUNET_MQ_set_handlers_closure(ch->mq, channel_cls); | 1099 | GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls); |
1097 | 1100 | ||
1098 | /* Request channel creation to service */ | 1101 | /* Request channel creation to service */ |
1099 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE); | 1102 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE); |
1100 | msg->ccn = ch->ccn; | 1103 | msg->ccn = ch->ccn; |
1101 | msg->port = *port; | 1104 | msg->port = *port; |
1102 | msg->peer = *destination; | 1105 | msg->peer = *destination; |
1103 | GNUNET_MQ_send(h->mq, env); | 1106 | GNUNET_MQ_send (h->mq, env); |
1104 | return ch; | 1107 | return ch; |
1105 | } | 1108 | } |
1106 | 1109 | ||
@@ -1113,7 +1116,7 @@ GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, | |||
1113 | * @return NULL if @a channel is not yet connected. | 1116 | * @return NULL if @a channel is not yet connected. |
1114 | */ | 1117 | */ |
1115 | struct GNUNET_MQ_Handle * | 1118 | struct GNUNET_MQ_Handle * |
1116 | GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel) | 1119 | GNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel) |
1117 | { | 1120 | { |
1118 | return channel->mq; | 1121 | return channel->mq; |
1119 | } | 1122 | } |
diff --git a/src/cadet/cadet_api_get_channel.c b/src/cadet/cadet_api_get_channel.c index 5479f4238..6d86e8e81 100644 --- a/src/cadet/cadet_api_get_channel.c +++ b/src/cadet/cadet_api_get_channel.c | |||
@@ -34,7 +34,8 @@ | |||
34 | /** | 34 | /** |
35 | * Operation handle. | 35 | * Operation handle. |
36 | */ | 36 | */ |
37 | struct GNUNET_CADET_ChannelMonitor { | 37 | struct GNUNET_CADET_ChannelMonitor |
38 | { | ||
38 | /** | 39 | /** |
39 | * Channel callback. | 40 | * Channel callback. |
40 | */ | 41 | */ |
@@ -81,10 +82,10 @@ struct GNUNET_CADET_ChannelMonitor { | |||
81 | * #GNUNET_SYSERR otherwise | 82 | * #GNUNET_SYSERR otherwise |
82 | */ | 83 | */ |
83 | static int | 84 | static int |
84 | check_channel_info(void *cls, | 85 | check_channel_info (void *cls, |
85 | const struct GNUNET_CADET_ChannelInfoMessage *message) | 86 | const struct GNUNET_CADET_ChannelInfoMessage *message) |
86 | { | 87 | { |
87 | (void)cls; | 88 | (void) cls; |
88 | 89 | ||
89 | return GNUNET_OK; | 90 | return GNUNET_OK; |
90 | } | 91 | } |
@@ -97,17 +98,17 @@ check_channel_info(void *cls, | |||
97 | * @param message Message itself. | 98 | * @param message Message itself. |
98 | */ | 99 | */ |
99 | static void | 100 | static void |
100 | handle_channel_info(void *cls, | 101 | handle_channel_info (void *cls, |
101 | const struct GNUNET_CADET_ChannelInfoMessage *message) | 102 | const struct GNUNET_CADET_ChannelInfoMessage *message) |
102 | { | 103 | { |
103 | struct GNUNET_CADET_ChannelMonitor *cm = cls; | 104 | struct GNUNET_CADET_ChannelMonitor *cm = cls; |
104 | struct GNUNET_CADET_ChannelInternals ci; | 105 | struct GNUNET_CADET_ChannelInternals ci; |
105 | 106 | ||
106 | ci.root = message->root; | 107 | ci.root = message->root; |
107 | ci.dest = message->dest; | 108 | ci.dest = message->dest; |
108 | cm->channel_cb(cm->channel_cb_cls, | 109 | cm->channel_cb (cm->channel_cb_cls, |
109 | &ci); | 110 | &ci); |
110 | GNUNET_CADET_get_channel_cancel(cm); | 111 | GNUNET_CADET_get_channel_cancel (cm); |
111 | } | 112 | } |
112 | 113 | ||
113 | 114 | ||
@@ -118,14 +119,14 @@ handle_channel_info(void *cls, | |||
118 | * @param message Message itself. | 119 | * @param message Message itself. |
119 | */ | 120 | */ |
120 | static void | 121 | static void |
121 | handle_channel_info_end(void *cls, | 122 | handle_channel_info_end (void *cls, |
122 | const struct GNUNET_MessageHeader *message) | 123 | const struct GNUNET_MessageHeader *message) |
123 | { | 124 | { |
124 | struct GNUNET_CADET_ChannelMonitor *cm = cls; | 125 | struct GNUNET_CADET_ChannelMonitor *cm = cls; |
125 | 126 | ||
126 | cm->channel_cb(cm->channel_cb_cls, | 127 | cm->channel_cb (cm->channel_cb_cls, |
127 | NULL); | 128 | NULL); |
128 | GNUNET_CADET_get_channel_cancel(cm); | 129 | GNUNET_CADET_get_channel_cancel (cm); |
129 | } | 130 | } |
130 | 131 | ||
131 | 132 | ||
@@ -135,7 +136,7 @@ handle_channel_info_end(void *cls, | |||
135 | * @param cls a `struct GNUNET_CADET_ChannelMonitor` operation | 136 | * @param cls a `struct GNUNET_CADET_ChannelMonitor` operation |
136 | */ | 137 | */ |
137 | static void | 138 | static void |
138 | reconnect(void *cls); | 139 | reconnect (void *cls); |
139 | 140 | ||
140 | 141 | ||
141 | /** | 142 | /** |
@@ -145,18 +146,18 @@ reconnect(void *cls); | |||
145 | * @param error error code from MQ | 146 | * @param error error code from MQ |
146 | */ | 147 | */ |
147 | static void | 148 | static void |
148 | error_handler(void *cls, | 149 | error_handler (void *cls, |
149 | enum GNUNET_MQ_Error error) | 150 | enum GNUNET_MQ_Error error) |
150 | { | 151 | { |
151 | struct GNUNET_CADET_ChannelMonitor *cm = cls; | 152 | struct GNUNET_CADET_ChannelMonitor *cm = cls; |
152 | 153 | ||
153 | GNUNET_MQ_destroy(cm->mq); | 154 | GNUNET_MQ_destroy (cm->mq); |
154 | cm->mq = NULL; | 155 | cm->mq = NULL; |
155 | cm->backoff = GNUNET_TIME_randomized_backoff(cm->backoff, | 156 | cm->backoff = GNUNET_TIME_randomized_backoff (cm->backoff, |
156 | GNUNET_TIME_UNIT_MINUTES); | 157 | GNUNET_TIME_UNIT_MINUTES); |
157 | cm->reconnect_task = GNUNET_SCHEDULER_add_delayed(cm->backoff, | 158 | cm->reconnect_task = GNUNET_SCHEDULER_add_delayed (cm->backoff, |
158 | &reconnect, | 159 | &reconnect, |
159 | cm); | 160 | cm); |
160 | } | 161 | } |
161 | 162 | ||
162 | 163 | ||
@@ -166,36 +167,36 @@ error_handler(void *cls, | |||
166 | * @param cls a `struct GNUNET_CADET_ChannelMonitor` operation | 167 | * @param cls a `struct GNUNET_CADET_ChannelMonitor` operation |
167 | */ | 168 | */ |
168 | static void | 169 | static void |
169 | reconnect(void *cls) | 170 | reconnect (void *cls) |
170 | { | 171 | { |
171 | struct GNUNET_CADET_ChannelMonitor *cm = cls; | 172 | struct GNUNET_CADET_ChannelMonitor *cm = cls; |
172 | struct GNUNET_MQ_MessageHandler handlers[] = { | 173 | struct GNUNET_MQ_MessageHandler handlers[] = { |
173 | GNUNET_MQ_hd_fixed_size(channel_info_end, | 174 | GNUNET_MQ_hd_fixed_size (channel_info_end, |
174 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL_END, | 175 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL_END, |
175 | struct GNUNET_MessageHeader, | 176 | struct GNUNET_MessageHeader, |
176 | cm), | 177 | cm), |
177 | GNUNET_MQ_hd_var_size(channel_info, | 178 | GNUNET_MQ_hd_var_size (channel_info, |
178 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL, | 179 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL, |
179 | struct GNUNET_CADET_ChannelInfoMessage, | 180 | struct GNUNET_CADET_ChannelInfoMessage, |
180 | cm), | 181 | cm), |
181 | GNUNET_MQ_handler_end() | 182 | GNUNET_MQ_handler_end () |
182 | }; | 183 | }; |
183 | struct GNUNET_CADET_RequestChannelInfoMessage *msg; | 184 | struct GNUNET_CADET_RequestChannelInfoMessage *msg; |
184 | struct GNUNET_MQ_Envelope *env; | 185 | struct GNUNET_MQ_Envelope *env; |
185 | 186 | ||
186 | cm->reconnect_task = NULL; | 187 | cm->reconnect_task = NULL; |
187 | cm->mq = GNUNET_CLIENT_connect(cm->cfg, | 188 | cm->mq = GNUNET_CLIENT_connect (cm->cfg, |
188 | "cadet", | 189 | "cadet", |
189 | handlers, | 190 | handlers, |
190 | &error_handler, | 191 | &error_handler, |
191 | cm); | 192 | cm); |
192 | if (NULL == cm->mq) | 193 | if (NULL == cm->mq) |
193 | return; | 194 | return; |
194 | env = GNUNET_MQ_msg(msg, | 195 | env = GNUNET_MQ_msg (msg, |
195 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_CHANNEL); | 196 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_CHANNEL); |
196 | msg->target = cm->peer; | 197 | msg->target = cm->peer; |
197 | GNUNET_MQ_send(cm->mq, | 198 | GNUNET_MQ_send (cm->mq, |
198 | env); | 199 | env); |
199 | } | 200 | } |
200 | 201 | ||
201 | 202 | ||
@@ -209,29 +210,29 @@ reconnect(void *cls) | |||
209 | * @return NULL on error | 210 | * @return NULL on error |
210 | */ | 211 | */ |
211 | struct GNUNET_CADET_ChannelMonitor * | 212 | struct GNUNET_CADET_ChannelMonitor * |
212 | GNUNET_CADET_get_channel(const struct GNUNET_CONFIGURATION_Handle *cfg, | 213 | GNUNET_CADET_get_channel (const struct GNUNET_CONFIGURATION_Handle *cfg, |
213 | struct GNUNET_PeerIdentity *peer, | 214 | struct GNUNET_PeerIdentity *peer, |
214 | GNUNET_CADET_ChannelCB callback, | 215 | GNUNET_CADET_ChannelCB callback, |
215 | void *callback_cls) | 216 | void *callback_cls) |
216 | { | 217 | { |
217 | struct GNUNET_CADET_ChannelMonitor *cm; | 218 | struct GNUNET_CADET_ChannelMonitor *cm; |
218 | 219 | ||
219 | if (NULL == callback) | 220 | if (NULL == callback) |
220 | { | 221 | { |
221 | GNUNET_break(0); | 222 | GNUNET_break (0); |
222 | return NULL; | 223 | return NULL; |
223 | } | 224 | } |
224 | cm = GNUNET_new(struct GNUNET_CADET_ChannelMonitor); | 225 | cm = GNUNET_new (struct GNUNET_CADET_ChannelMonitor); |
225 | cm->channel_cb = callback; | 226 | cm->channel_cb = callback; |
226 | cm->channel_cb_cls = callback_cls; | 227 | cm->channel_cb_cls = callback_cls; |
227 | cm->cfg = cfg; | 228 | cm->cfg = cfg; |
228 | cm->peer = *peer; | 229 | cm->peer = *peer; |
229 | reconnect(cm); | 230 | reconnect (cm); |
230 | if (NULL == cm->mq) | 231 | if (NULL == cm->mq) |
231 | { | 232 | { |
232 | GNUNET_free(cm); | 233 | GNUNET_free (cm); |
233 | return NULL; | 234 | return NULL; |
234 | } | 235 | } |
235 | return cm; | 236 | return cm; |
236 | } | 237 | } |
237 | 238 | ||
@@ -243,15 +244,15 @@ GNUNET_CADET_get_channel(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
243 | * @return Closure that was given to #GNUNET_CADET_get_channel(). | 244 | * @return Closure that was given to #GNUNET_CADET_get_channel(). |
244 | */ | 245 | */ |
245 | void * | 246 | void * |
246 | GNUNET_CADET_get_channel_cancel(struct GNUNET_CADET_ChannelMonitor *cm) | 247 | GNUNET_CADET_get_channel_cancel (struct GNUNET_CADET_ChannelMonitor *cm) |
247 | { | 248 | { |
248 | void *ret = cm->channel_cb_cls; | 249 | void *ret = cm->channel_cb_cls; |
249 | 250 | ||
250 | if (NULL != cm->mq) | 251 | if (NULL != cm->mq) |
251 | GNUNET_MQ_destroy(cm->mq); | 252 | GNUNET_MQ_destroy (cm->mq); |
252 | if (NULL != cm->reconnect_task) | 253 | if (NULL != cm->reconnect_task) |
253 | GNUNET_SCHEDULER_cancel(cm->reconnect_task); | 254 | GNUNET_SCHEDULER_cancel (cm->reconnect_task); |
254 | GNUNET_free(cm); | 255 | GNUNET_free (cm); |
255 | return ret; | 256 | return ret; |
256 | } | 257 | } |
257 | 258 | ||
diff --git a/src/cadet/cadet_api_get_path.c b/src/cadet/cadet_api_get_path.c index 0f18014c3..68070eab2 100644 --- a/src/cadet/cadet_api_get_path.c +++ b/src/cadet/cadet_api_get_path.c | |||
@@ -34,7 +34,8 @@ | |||
34 | /** | 34 | /** |
35 | * Operation handle. | 35 | * Operation handle. |
36 | */ | 36 | */ |
37 | struct GNUNET_CADET_GetPath { | 37 | struct GNUNET_CADET_GetPath |
38 | { | ||
38 | /** | 39 | /** |
39 | * Monitor callback | 40 | * Monitor callback |
40 | */ | 41 | */ |
@@ -81,24 +82,24 @@ struct GNUNET_CADET_GetPath { | |||
81 | * #GNUNET_SYSERR otherwise | 82 | * #GNUNET_SYSERR otherwise |
82 | */ | 83 | */ |
83 | static int | 84 | static int |
84 | check_get_path(void *cls, | 85 | check_get_path (void *cls, |
85 | const struct GNUNET_CADET_LocalInfoPath *message) | 86 | const struct GNUNET_CADET_LocalInfoPath *message) |
86 | { | 87 | { |
87 | size_t msize = sizeof(struct GNUNET_CADET_LocalInfoPath); | 88 | size_t msize = sizeof(struct GNUNET_CADET_LocalInfoPath); |
88 | size_t esize; | 89 | size_t esize; |
89 | 90 | ||
90 | (void)cls; | 91 | (void) cls; |
91 | esize = ntohs(message->header.size); | 92 | esize = ntohs (message->header.size); |
92 | if (esize < msize) | 93 | if (esize < msize) |
93 | { | 94 | { |
94 | GNUNET_break(0); | 95 | GNUNET_break (0); |
95 | return GNUNET_SYSERR; | 96 | return GNUNET_SYSERR; |
96 | } | 97 | } |
97 | if (0 != ((esize - msize) % sizeof(struct GNUNET_PeerIdentity))) | 98 | if (0 != ((esize - msize) % sizeof(struct GNUNET_PeerIdentity))) |
98 | { | 99 | { |
99 | GNUNET_break(0); | 100 | GNUNET_break (0); |
100 | return GNUNET_SYSERR; | 101 | return GNUNET_SYSERR; |
101 | } | 102 | } |
102 | return GNUNET_OK; | 103 | return GNUNET_OK; |
103 | } | 104 | } |
104 | 105 | ||
@@ -110,19 +111,19 @@ check_get_path(void *cls, | |||
110 | * @param message Message itself. | 111 | * @param message Message itself. |
111 | */ | 112 | */ |
112 | static void | 113 | static void |
113 | handle_get_path(void *cls, | 114 | handle_get_path (void *cls, |
114 | const struct GNUNET_CADET_LocalInfoPath *message) | 115 | const struct GNUNET_CADET_LocalInfoPath *message) |
115 | { | 116 | { |
116 | struct GNUNET_CADET_GetPath *gp = cls; | 117 | struct GNUNET_CADET_GetPath *gp = cls; |
117 | struct GNUNET_CADET_PeerPathDetail ppd; | 118 | struct GNUNET_CADET_PeerPathDetail ppd; |
118 | 119 | ||
119 | ppd.peer = gp->id; | 120 | ppd.peer = gp->id; |
120 | ppd.path = (const struct GNUNET_PeerIdentity *)&message[1]; | 121 | ppd.path = (const struct GNUNET_PeerIdentity *) &message[1]; |
121 | ppd.target_offset = ntohl(message->off); | 122 | ppd.target_offset = ntohl (message->off); |
122 | ppd.path_length = (ntohs(message->header.size) - sizeof(*message)) | 123 | ppd.path_length = (ntohs (message->header.size) - sizeof(*message)) |
123 | / sizeof(struct GNUNET_PeerIdentity); | 124 | / sizeof(struct GNUNET_PeerIdentity); |
124 | gp->path_cb(gp->path_cb_cls, | 125 | gp->path_cb (gp->path_cb_cls, |
125 | &ppd); | 126 | &ppd); |
126 | } | 127 | } |
127 | 128 | ||
128 | 129 | ||
@@ -133,15 +134,15 @@ handle_get_path(void *cls, | |||
133 | * @param message Message itself. | 134 | * @param message Message itself. |
134 | */ | 135 | */ |
135 | static void | 136 | static void |
136 | handle_get_path_end(void *cls, | 137 | handle_get_path_end (void *cls, |
137 | const struct GNUNET_MessageHeader *message) | 138 | const struct GNUNET_MessageHeader *message) |
138 | { | 139 | { |
139 | struct GNUNET_CADET_GetPath *gp = cls; | 140 | struct GNUNET_CADET_GetPath *gp = cls; |
140 | 141 | ||
141 | (void)message; | 142 | (void) message; |
142 | gp->path_cb(gp->path_cb_cls, | 143 | gp->path_cb (gp->path_cb_cls, |
143 | NULL); | 144 | NULL); |
144 | GNUNET_CADET_get_path_cancel(gp); | 145 | GNUNET_CADET_get_path_cancel (gp); |
145 | } | 146 | } |
146 | 147 | ||
147 | 148 | ||
@@ -151,7 +152,7 @@ handle_get_path_end(void *cls, | |||
151 | * @param cls a `struct GNUNET_CADET_GetPath` operation | 152 | * @param cls a `struct GNUNET_CADET_GetPath` operation |
152 | */ | 153 | */ |
153 | static void | 154 | static void |
154 | reconnect(void *cls); | 155 | reconnect (void *cls); |
155 | 156 | ||
156 | 157 | ||
157 | /** | 158 | /** |
@@ -161,18 +162,18 @@ reconnect(void *cls); | |||
161 | * @param error error code from MQ | 162 | * @param error error code from MQ |
162 | */ | 163 | */ |
163 | static void | 164 | static void |
164 | error_handler(void *cls, | 165 | error_handler (void *cls, |
165 | enum GNUNET_MQ_Error error) | 166 | enum GNUNET_MQ_Error error) |
166 | { | 167 | { |
167 | struct GNUNET_CADET_GetPath *gp = cls; | 168 | struct GNUNET_CADET_GetPath *gp = cls; |
168 | 169 | ||
169 | GNUNET_MQ_destroy(gp->mq); | 170 | GNUNET_MQ_destroy (gp->mq); |
170 | gp->mq = NULL; | 171 | gp->mq = NULL; |
171 | gp->backoff = GNUNET_TIME_randomized_backoff(gp->backoff, | 172 | gp->backoff = GNUNET_TIME_randomized_backoff (gp->backoff, |
172 | GNUNET_TIME_UNIT_MINUTES); | 173 | GNUNET_TIME_UNIT_MINUTES); |
173 | gp->reconnect_task = GNUNET_SCHEDULER_add_delayed(gp->backoff, | 174 | gp->reconnect_task = GNUNET_SCHEDULER_add_delayed (gp->backoff, |
174 | &reconnect, | 175 | &reconnect, |
175 | gp); | 176 | gp); |
176 | } | 177 | } |
177 | 178 | ||
178 | 179 | ||
@@ -182,36 +183,36 @@ error_handler(void *cls, | |||
182 | * @param cls a `struct GNUNET_CADET_GetPath` operation | 183 | * @param cls a `struct GNUNET_CADET_GetPath` operation |
183 | */ | 184 | */ |
184 | static void | 185 | static void |
185 | reconnect(void *cls) | 186 | reconnect (void *cls) |
186 | { | 187 | { |
187 | struct GNUNET_CADET_GetPath *gp = cls; | 188 | struct GNUNET_CADET_GetPath *gp = cls; |
188 | struct GNUNET_MQ_MessageHandler handlers[] = { | 189 | struct GNUNET_MQ_MessageHandler handlers[] = { |
189 | GNUNET_MQ_hd_var_size(get_path, | 190 | GNUNET_MQ_hd_var_size (get_path, |
190 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH, | 191 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH, |
191 | struct GNUNET_CADET_LocalInfoPath, | 192 | struct GNUNET_CADET_LocalInfoPath, |
192 | gp), | 193 | gp), |
193 | GNUNET_MQ_hd_fixed_size(get_path_end, | 194 | GNUNET_MQ_hd_fixed_size (get_path_end, |
194 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END, | 195 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END, |
195 | struct GNUNET_MessageHeader, | 196 | struct GNUNET_MessageHeader, |
196 | gp), | 197 | gp), |
197 | GNUNET_MQ_handler_end() | 198 | GNUNET_MQ_handler_end () |
198 | }; | 199 | }; |
199 | struct GNUNET_CADET_RequestPathInfoMessage *msg; | 200 | struct GNUNET_CADET_RequestPathInfoMessage *msg; |
200 | struct GNUNET_MQ_Envelope *env; | 201 | struct GNUNET_MQ_Envelope *env; |
201 | 202 | ||
202 | gp->reconnect_task = NULL; | 203 | gp->reconnect_task = NULL; |
203 | gp->mq = GNUNET_CLIENT_connect(gp->cfg, | 204 | gp->mq = GNUNET_CLIENT_connect (gp->cfg, |
204 | "cadet", | 205 | "cadet", |
205 | handlers, | 206 | handlers, |
206 | &error_handler, | 207 | &error_handler, |
207 | gp); | 208 | gp); |
208 | if (NULL == gp->mq) | 209 | if (NULL == gp->mq) |
209 | return; | 210 | return; |
210 | env = GNUNET_MQ_msg(msg, | 211 | env = GNUNET_MQ_msg (msg, |
211 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH); | 212 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH); |
212 | msg->peer = gp->id; | 213 | msg->peer = gp->id; |
213 | GNUNET_MQ_send(gp->mq, | 214 | GNUNET_MQ_send (gp->mq, |
214 | env); | 215 | env); |
215 | } | 216 | } |
216 | 217 | ||
217 | 218 | ||
@@ -225,29 +226,29 @@ reconnect(void *cls) | |||
225 | * @return NULL on error | 226 | * @return NULL on error |
226 | */ | 227 | */ |
227 | struct GNUNET_CADET_GetPath * | 228 | struct GNUNET_CADET_GetPath * |
228 | GNUNET_CADET_get_path(const struct GNUNET_CONFIGURATION_Handle *cfg, | 229 | GNUNET_CADET_get_path (const struct GNUNET_CONFIGURATION_Handle *cfg, |
229 | const struct GNUNET_PeerIdentity *id, | 230 | const struct GNUNET_PeerIdentity *id, |
230 | GNUNET_CADET_PathCB callback, | 231 | GNUNET_CADET_PathCB callback, |
231 | void *callback_cls) | 232 | void *callback_cls) |
232 | { | 233 | { |
233 | struct GNUNET_CADET_GetPath *gp; | 234 | struct GNUNET_CADET_GetPath *gp; |
234 | 235 | ||
235 | if (NULL == callback) | 236 | if (NULL == callback) |
236 | { | 237 | { |
237 | GNUNET_break(0); | 238 | GNUNET_break (0); |
238 | return NULL; | 239 | return NULL; |
239 | } | 240 | } |
240 | gp = GNUNET_new(struct GNUNET_CADET_GetPath); | 241 | gp = GNUNET_new (struct GNUNET_CADET_GetPath); |
241 | gp->path_cb = callback; | 242 | gp->path_cb = callback; |
242 | gp->path_cb_cls = callback_cls; | 243 | gp->path_cb_cls = callback_cls; |
243 | gp->cfg = cfg; | 244 | gp->cfg = cfg; |
244 | gp->id = *id; | 245 | gp->id = *id; |
245 | reconnect(gp); | 246 | reconnect (gp); |
246 | if (NULL == gp->mq) | 247 | if (NULL == gp->mq) |
247 | { | 248 | { |
248 | GNUNET_free(gp); | 249 | GNUNET_free (gp); |
249 | return NULL; | 250 | return NULL; |
250 | } | 251 | } |
251 | return gp; | 252 | return gp; |
252 | } | 253 | } |
253 | 254 | ||
@@ -259,15 +260,15 @@ GNUNET_CADET_get_path(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
259 | * @return closure from #GNUNET_CADET_get_path(). | 260 | * @return closure from #GNUNET_CADET_get_path(). |
260 | */ | 261 | */ |
261 | void * | 262 | void * |
262 | GNUNET_CADET_get_path_cancel(struct GNUNET_CADET_GetPath *gp) | 263 | GNUNET_CADET_get_path_cancel (struct GNUNET_CADET_GetPath *gp) |
263 | { | 264 | { |
264 | void *ret = gp->path_cb_cls; | 265 | void *ret = gp->path_cb_cls; |
265 | 266 | ||
266 | if (NULL != gp->mq) | 267 | if (NULL != gp->mq) |
267 | GNUNET_MQ_destroy(gp->mq); | 268 | GNUNET_MQ_destroy (gp->mq); |
268 | if (NULL != gp->reconnect_task) | 269 | if (NULL != gp->reconnect_task) |
269 | GNUNET_SCHEDULER_cancel(gp->reconnect_task); | 270 | GNUNET_SCHEDULER_cancel (gp->reconnect_task); |
270 | GNUNET_free(gp); | 271 | GNUNET_free (gp); |
271 | return ret; | 272 | return ret; |
272 | } | 273 | } |
273 | 274 | ||
diff --git a/src/cadet/cadet_api_helper.c b/src/cadet/cadet_api_helper.c index 78e5eb45c..52aec6cc9 100644 --- a/src/cadet/cadet_api_helper.c +++ b/src/cadet/cadet_api_helper.c | |||
@@ -41,15 +41,14 @@ | |||
41 | * @return A GNUNET_HashCode usable for the new CADET API. | 41 | * @return A GNUNET_HashCode usable for the new CADET API. |
42 | */ | 42 | */ |
43 | const struct GNUNET_HashCode * | 43 | const struct GNUNET_HashCode * |
44 | GC_u2h(uint32_t port) | 44 | GC_u2h (uint32_t port) |
45 | { | 45 | { |
46 | static struct GNUNET_HashCode hash; | 46 | static struct GNUNET_HashCode hash; |
47 | 47 | ||
48 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 48 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
49 | "This is a transitional function, use proper crypto hashes as CADET ports\n"); | 49 | "This is a transitional function, use proper crypto hashes as CADET ports\n"); |
50 | GNUNET_CRYPTO_hash(&port, | 50 | GNUNET_CRYPTO_hash (&port, |
51 | sizeof(port), | 51 | sizeof(port), |
52 | &hash); | 52 | &hash); |
53 | return &hash; | 53 | return &hash; |
54 | } | 54 | } |
55 | |||
diff --git a/src/cadet/cadet_api_list_peers.c b/src/cadet/cadet_api_list_peers.c index 65e9ad4da..8865b6f57 100644 --- a/src/cadet/cadet_api_list_peers.c +++ b/src/cadet/cadet_api_list_peers.c | |||
@@ -34,7 +34,8 @@ | |||
34 | /** | 34 | /** |
35 | * Operation handle. | 35 | * Operation handle. |
36 | */ | 36 | */ |
37 | struct GNUNET_CADET_PeersLister { | 37 | struct GNUNET_CADET_PeersLister |
38 | { | ||
38 | /** | 39 | /** |
39 | * Monitor callback | 40 | * Monitor callback |
40 | */ | 41 | */ |
@@ -74,18 +75,18 @@ struct GNUNET_CADET_PeersLister { | |||
74 | * @param info Message itself. | 75 | * @param info Message itself. |
75 | */ | 76 | */ |
76 | static void | 77 | static void |
77 | handle_get_peers(void *cls, | 78 | handle_get_peers (void *cls, |
78 | const struct GNUNET_CADET_LocalInfoPeers *info) | 79 | const struct GNUNET_CADET_LocalInfoPeers *info) |
79 | { | 80 | { |
80 | struct GNUNET_CADET_PeersLister *pl = cls; | 81 | struct GNUNET_CADET_PeersLister *pl = cls; |
81 | struct GNUNET_CADET_PeerListEntry ple; | 82 | struct GNUNET_CADET_PeerListEntry ple; |
82 | 83 | ||
83 | ple.peer = info->destination; | 84 | ple.peer = info->destination; |
84 | ple.have_tunnel = (int)ntohs(info->tunnel); | 85 | ple.have_tunnel = (int) ntohs (info->tunnel); |
85 | ple.n_paths = (unsigned int)ntohs(info->paths); | 86 | ple.n_paths = (unsigned int) ntohs (info->paths); |
86 | ple.best_path_length = (unsigned int)ntohl(info->best_path_length); | 87 | ple.best_path_length = (unsigned int) ntohl (info->best_path_length); |
87 | pl->peers_cb(pl->peers_cb_cls, | 88 | pl->peers_cb (pl->peers_cb_cls, |
88 | &ple); | 89 | &ple); |
89 | } | 90 | } |
90 | 91 | ||
91 | 92 | ||
@@ -96,16 +97,16 @@ handle_get_peers(void *cls, | |||
96 | * @param msg Message itself. | 97 | * @param msg Message itself. |
97 | */ | 98 | */ |
98 | static void | 99 | static void |
99 | handle_get_peers_end(void *cls, | 100 | handle_get_peers_end (void *cls, |
100 | const struct GNUNET_MessageHeader *msg) | 101 | const struct GNUNET_MessageHeader *msg) |
101 | { | 102 | { |
102 | struct GNUNET_CADET_PeersLister *pl = cls; | 103 | struct GNUNET_CADET_PeersLister *pl = cls; |
103 | 104 | ||
104 | (void)msg; | 105 | (void) msg; |
105 | 106 | ||
106 | pl->peers_cb(pl->peers_cb_cls, | 107 | pl->peers_cb (pl->peers_cb_cls, |
107 | NULL); | 108 | NULL); |
108 | GNUNET_CADET_list_peers_cancel(pl); | 109 | GNUNET_CADET_list_peers_cancel (pl); |
109 | } | 110 | } |
110 | 111 | ||
111 | 112 | ||
@@ -115,7 +116,7 @@ handle_get_peers_end(void *cls, | |||
115 | * @param cls a `struct GNUNET_CADET_PeersLister` operation | 116 | * @param cls a `struct GNUNET_CADET_PeersLister` operation |
116 | */ | 117 | */ |
117 | static void | 118 | static void |
118 | reconnect(void *cls); | 119 | reconnect (void *cls); |
119 | 120 | ||
120 | 121 | ||
121 | /** | 122 | /** |
@@ -125,18 +126,18 @@ reconnect(void *cls); | |||
125 | * @param error error code from MQ | 126 | * @param error error code from MQ |
126 | */ | 127 | */ |
127 | static void | 128 | static void |
128 | error_handler(void *cls, | 129 | error_handler (void *cls, |
129 | enum GNUNET_MQ_Error error) | 130 | enum GNUNET_MQ_Error error) |
130 | { | 131 | { |
131 | struct GNUNET_CADET_PeersLister *pl = cls; | 132 | struct GNUNET_CADET_PeersLister *pl = cls; |
132 | 133 | ||
133 | GNUNET_MQ_destroy(pl->mq); | 134 | GNUNET_MQ_destroy (pl->mq); |
134 | pl->mq = NULL; | 135 | pl->mq = NULL; |
135 | pl->backoff = GNUNET_TIME_randomized_backoff(pl->backoff, | 136 | pl->backoff = GNUNET_TIME_randomized_backoff (pl->backoff, |
136 | GNUNET_TIME_UNIT_MINUTES); | 137 | GNUNET_TIME_UNIT_MINUTES); |
137 | pl->reconnect_task = GNUNET_SCHEDULER_add_delayed(pl->backoff, | 138 | pl->reconnect_task = GNUNET_SCHEDULER_add_delayed (pl->backoff, |
138 | &reconnect, | 139 | &reconnect, |
139 | pl); | 140 | pl); |
140 | } | 141 | } |
141 | 142 | ||
142 | 143 | ||
@@ -146,35 +147,35 @@ error_handler(void *cls, | |||
146 | * @param cls a `struct GNUNET_CADET_PeersLister` operation | 147 | * @param cls a `struct GNUNET_CADET_PeersLister` operation |
147 | */ | 148 | */ |
148 | static void | 149 | static void |
149 | reconnect(void *cls) | 150 | reconnect (void *cls) |
150 | { | 151 | { |
151 | struct GNUNET_CADET_PeersLister *pl = cls; | 152 | struct GNUNET_CADET_PeersLister *pl = cls; |
152 | struct GNUNET_MQ_MessageHandler handlers[] = { | 153 | struct GNUNET_MQ_MessageHandler handlers[] = { |
153 | GNUNET_MQ_hd_fixed_size(get_peers, | 154 | GNUNET_MQ_hd_fixed_size (get_peers, |
154 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS, | 155 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS, |
155 | struct GNUNET_CADET_LocalInfoPeers, | 156 | struct GNUNET_CADET_LocalInfoPeers, |
156 | pl), | 157 | pl), |
157 | GNUNET_MQ_hd_fixed_size(get_peers_end, | 158 | GNUNET_MQ_hd_fixed_size (get_peers_end, |
158 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END, | 159 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END, |
159 | struct GNUNET_MessageHeader, | 160 | struct GNUNET_MessageHeader, |
160 | pl), | 161 | pl), |
161 | GNUNET_MQ_handler_end() | 162 | GNUNET_MQ_handler_end () |
162 | }; | 163 | }; |
163 | struct GNUNET_MessageHeader *msg; | 164 | struct GNUNET_MessageHeader *msg; |
164 | struct GNUNET_MQ_Envelope *env; | 165 | struct GNUNET_MQ_Envelope *env; |
165 | 166 | ||
166 | pl->reconnect_task = NULL; | 167 | pl->reconnect_task = NULL; |
167 | pl->mq = GNUNET_CLIENT_connect(pl->cfg, | 168 | pl->mq = GNUNET_CLIENT_connect (pl->cfg, |
168 | "cadet", | 169 | "cadet", |
169 | handlers, | 170 | handlers, |
170 | &error_handler, | 171 | &error_handler, |
171 | pl); | 172 | pl); |
172 | if (NULL == pl->mq) | 173 | if (NULL == pl->mq) |
173 | return; | 174 | return; |
174 | env = GNUNET_MQ_msg(msg, | 175 | env = GNUNET_MQ_msg (msg, |
175 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS); | 176 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS); |
176 | GNUNET_MQ_send(pl->mq, | 177 | GNUNET_MQ_send (pl->mq, |
177 | env); | 178 | env); |
178 | } | 179 | } |
179 | 180 | ||
180 | 181 | ||
@@ -189,27 +190,27 @@ reconnect(void *cls) | |||
189 | * @return NULL on error | 190 | * @return NULL on error |
190 | */ | 191 | */ |
191 | struct GNUNET_CADET_PeersLister * | 192 | struct GNUNET_CADET_PeersLister * |
192 | GNUNET_CADET_list_peers(const struct GNUNET_CONFIGURATION_Handle *cfg, | 193 | GNUNET_CADET_list_peers (const struct GNUNET_CONFIGURATION_Handle *cfg, |
193 | GNUNET_CADET_PeersCB callback, | 194 | GNUNET_CADET_PeersCB callback, |
194 | void *callback_cls) | 195 | void *callback_cls) |
195 | { | 196 | { |
196 | struct GNUNET_CADET_PeersLister *pl; | 197 | struct GNUNET_CADET_PeersLister *pl; |
197 | 198 | ||
198 | if (NULL == callback) | 199 | if (NULL == callback) |
199 | { | 200 | { |
200 | GNUNET_break(0); | 201 | GNUNET_break (0); |
201 | return NULL; | 202 | return NULL; |
202 | } | 203 | } |
203 | pl = GNUNET_new(struct GNUNET_CADET_PeersLister); | 204 | pl = GNUNET_new (struct GNUNET_CADET_PeersLister); |
204 | pl->peers_cb = callback; | 205 | pl->peers_cb = callback; |
205 | pl->peers_cb_cls = callback_cls; | 206 | pl->peers_cb_cls = callback_cls; |
206 | pl->cfg = cfg; | 207 | pl->cfg = cfg; |
207 | reconnect(pl); | 208 | reconnect (pl); |
208 | if (NULL == pl->mq) | 209 | if (NULL == pl->mq) |
209 | { | 210 | { |
210 | GNUNET_free(pl); | 211 | GNUNET_free (pl); |
211 | return NULL; | 212 | return NULL; |
212 | } | 213 | } |
213 | return pl; | 214 | return pl; |
214 | } | 215 | } |
215 | 216 | ||
@@ -221,15 +222,15 @@ GNUNET_CADET_list_peers(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
221 | * @return Closure given to GNUNET_CADET_get_peers(). | 222 | * @return Closure given to GNUNET_CADET_get_peers(). |
222 | */ | 223 | */ |
223 | void * | 224 | void * |
224 | GNUNET_CADET_list_peers_cancel(struct GNUNET_CADET_PeersLister *pl) | 225 | GNUNET_CADET_list_peers_cancel (struct GNUNET_CADET_PeersLister *pl) |
225 | { | 226 | { |
226 | void *ret = pl->peers_cb_cls; | 227 | void *ret = pl->peers_cb_cls; |
227 | 228 | ||
228 | if (NULL != pl->mq) | 229 | if (NULL != pl->mq) |
229 | GNUNET_MQ_destroy(pl->mq); | 230 | GNUNET_MQ_destroy (pl->mq); |
230 | if (NULL != pl->reconnect_task) | 231 | if (NULL != pl->reconnect_task) |
231 | GNUNET_SCHEDULER_cancel(pl->reconnect_task); | 232 | GNUNET_SCHEDULER_cancel (pl->reconnect_task); |
232 | GNUNET_free(pl); | 233 | GNUNET_free (pl); |
233 | return ret; | 234 | return ret; |
234 | } | 235 | } |
235 | 236 | ||
diff --git a/src/cadet/cadet_api_list_tunnels.c b/src/cadet/cadet_api_list_tunnels.c index 2ea8cf26c..e9ae069bb 100644 --- a/src/cadet/cadet_api_list_tunnels.c +++ b/src/cadet/cadet_api_list_tunnels.c | |||
@@ -34,7 +34,8 @@ | |||
34 | /** | 34 | /** |
35 | * Operation handle. | 35 | * Operation handle. |
36 | */ | 36 | */ |
37 | struct GNUNET_CADET_ListTunnels { | 37 | struct GNUNET_CADET_ListTunnels |
38 | { | ||
38 | /** | 39 | /** |
39 | * Monitor callback | 40 | * Monitor callback |
40 | */ | 41 | */ |
@@ -74,19 +75,19 @@ struct GNUNET_CADET_ListTunnels { | |||
74 | * @param info Message itself. | 75 | * @param info Message itself. |
75 | */ | 76 | */ |
76 | static void | 77 | static void |
77 | handle_get_tunnels(void *cls, | 78 | handle_get_tunnels (void *cls, |
78 | const struct GNUNET_CADET_LocalInfoTunnel *info) | 79 | const struct GNUNET_CADET_LocalInfoTunnel *info) |
79 | { | 80 | { |
80 | struct GNUNET_CADET_ListTunnels *lt = cls; | 81 | struct GNUNET_CADET_ListTunnels *lt = cls; |
81 | struct GNUNET_CADET_TunnelDetails td; | 82 | struct GNUNET_CADET_TunnelDetails td; |
82 | 83 | ||
83 | td.peer = info->destination; | 84 | td.peer = info->destination; |
84 | td.channels = ntohl(info->channels); | 85 | td.channels = ntohl (info->channels); |
85 | td.connections = ntohl(info->connections); | 86 | td.connections = ntohl (info->connections); |
86 | td.estate = ntohs(info->estate); | 87 | td.estate = ntohs (info->estate); |
87 | td.cstate = ntohs(info->cstate); | 88 | td.cstate = ntohs (info->cstate); |
88 | lt->tunnels_cb(lt->tunnels_cb_cls, | 89 | lt->tunnels_cb (lt->tunnels_cb_cls, |
89 | &td); | 90 | &td); |
90 | } | 91 | } |
91 | 92 | ||
92 | 93 | ||
@@ -97,16 +98,16 @@ handle_get_tunnels(void *cls, | |||
97 | * @param message Message itself. | 98 | * @param message Message itself. |
98 | */ | 99 | */ |
99 | static void | 100 | static void |
100 | handle_get_tunnels_end(void *cls, | 101 | handle_get_tunnels_end (void *cls, |
101 | const struct GNUNET_MessageHeader *msg) | 102 | const struct GNUNET_MessageHeader *msg) |
102 | { | 103 | { |
103 | struct GNUNET_CADET_ListTunnels *lt = cls; | 104 | struct GNUNET_CADET_ListTunnels *lt = cls; |
104 | 105 | ||
105 | (void)msg; | 106 | (void) msg; |
106 | 107 | ||
107 | lt->tunnels_cb(lt->tunnels_cb_cls, | 108 | lt->tunnels_cb (lt->tunnels_cb_cls, |
108 | NULL); | 109 | NULL); |
109 | GNUNET_CADET_list_tunnels_cancel(lt); | 110 | GNUNET_CADET_list_tunnels_cancel (lt); |
110 | } | 111 | } |
111 | 112 | ||
112 | 113 | ||
@@ -116,7 +117,7 @@ handle_get_tunnels_end(void *cls, | |||
116 | * @param cls a `struct GNUNET_CADET_ListTunnels` operation | 117 | * @param cls a `struct GNUNET_CADET_ListTunnels` operation |
117 | */ | 118 | */ |
118 | static void | 119 | static void |
119 | reconnect(void *cls); | 120 | reconnect (void *cls); |
120 | 121 | ||
121 | 122 | ||
122 | /** | 123 | /** |
@@ -126,18 +127,18 @@ reconnect(void *cls); | |||
126 | * @param error error code from MQ | 127 | * @param error error code from MQ |
127 | */ | 128 | */ |
128 | static void | 129 | static void |
129 | error_handler(void *cls, | 130 | error_handler (void *cls, |
130 | enum GNUNET_MQ_Error error) | 131 | enum GNUNET_MQ_Error error) |
131 | { | 132 | { |
132 | struct GNUNET_CADET_ListTunnels *lt = cls; | 133 | struct GNUNET_CADET_ListTunnels *lt = cls; |
133 | 134 | ||
134 | GNUNET_MQ_destroy(lt->mq); | 135 | GNUNET_MQ_destroy (lt->mq); |
135 | lt->mq = NULL; | 136 | lt->mq = NULL; |
136 | lt->backoff = GNUNET_TIME_randomized_backoff(lt->backoff, | 137 | lt->backoff = GNUNET_TIME_randomized_backoff (lt->backoff, |
137 | GNUNET_TIME_UNIT_MINUTES); | 138 | GNUNET_TIME_UNIT_MINUTES); |
138 | lt->reconnect_task = GNUNET_SCHEDULER_add_delayed(lt->backoff, | 139 | lt->reconnect_task = GNUNET_SCHEDULER_add_delayed (lt->backoff, |
139 | &reconnect, | 140 | &reconnect, |
140 | lt); | 141 | lt); |
141 | } | 142 | } |
142 | 143 | ||
143 | 144 | ||
@@ -147,35 +148,35 @@ error_handler(void *cls, | |||
147 | * @param cls a `struct GNUNET_CADET_ListTunnels` operation | 148 | * @param cls a `struct GNUNET_CADET_ListTunnels` operation |
148 | */ | 149 | */ |
149 | static void | 150 | static void |
150 | reconnect(void *cls) | 151 | reconnect (void *cls) |
151 | { | 152 | { |
152 | struct GNUNET_CADET_ListTunnels *lt = cls; | 153 | struct GNUNET_CADET_ListTunnels *lt = cls; |
153 | struct GNUNET_MQ_MessageHandler handlers[] = { | 154 | struct GNUNET_MQ_MessageHandler handlers[] = { |
154 | GNUNET_MQ_hd_fixed_size(get_tunnels, | 155 | GNUNET_MQ_hd_fixed_size (get_tunnels, |
155 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS, | 156 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS, |
156 | struct GNUNET_CADET_LocalInfoTunnel, | 157 | struct GNUNET_CADET_LocalInfoTunnel, |
157 | lt), | 158 | lt), |
158 | GNUNET_MQ_hd_fixed_size(get_tunnels_end, | 159 | GNUNET_MQ_hd_fixed_size (get_tunnels_end, |
159 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END, | 160 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END, |
160 | struct GNUNET_MessageHeader, | 161 | struct GNUNET_MessageHeader, |
161 | lt), | 162 | lt), |
162 | GNUNET_MQ_handler_end() | 163 | GNUNET_MQ_handler_end () |
163 | }; | 164 | }; |
164 | struct GNUNET_MessageHeader *msg; | 165 | struct GNUNET_MessageHeader *msg; |
165 | struct GNUNET_MQ_Envelope *env; | 166 | struct GNUNET_MQ_Envelope *env; |
166 | 167 | ||
167 | lt->reconnect_task = NULL; | 168 | lt->reconnect_task = NULL; |
168 | lt->mq = GNUNET_CLIENT_connect(lt->cfg, | 169 | lt->mq = GNUNET_CLIENT_connect (lt->cfg, |
169 | "cadet", | 170 | "cadet", |
170 | handlers, | 171 | handlers, |
171 | &error_handler, | 172 | &error_handler, |
172 | lt); | 173 | lt); |
173 | if (NULL == lt->mq) | 174 | if (NULL == lt->mq) |
174 | return; | 175 | return; |
175 | env = GNUNET_MQ_msg(msg, | 176 | env = GNUNET_MQ_msg (msg, |
176 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS); | 177 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS); |
177 | GNUNET_MQ_send(lt->mq, | 178 | GNUNET_MQ_send (lt->mq, |
178 | env); | 179 | env); |
179 | } | 180 | } |
180 | 181 | ||
181 | 182 | ||
@@ -190,27 +191,27 @@ reconnect(void *cls) | |||
190 | * @return NULL on error | 191 | * @return NULL on error |
191 | */ | 192 | */ |
192 | struct GNUNET_CADET_ListTunnels * | 193 | struct GNUNET_CADET_ListTunnels * |
193 | GNUNET_CADET_list_tunnels(const struct GNUNET_CONFIGURATION_Handle *cfg, | 194 | GNUNET_CADET_list_tunnels (const struct GNUNET_CONFIGURATION_Handle *cfg, |
194 | GNUNET_CADET_TunnelsCB callback, | 195 | GNUNET_CADET_TunnelsCB callback, |
195 | void *callback_cls) | 196 | void *callback_cls) |
196 | { | 197 | { |
197 | struct GNUNET_CADET_ListTunnels *lt; | 198 | struct GNUNET_CADET_ListTunnels *lt; |
198 | 199 | ||
199 | if (NULL == callback) | 200 | if (NULL == callback) |
200 | { | 201 | { |
201 | GNUNET_break(0); | 202 | GNUNET_break (0); |
202 | return NULL; | 203 | return NULL; |
203 | } | 204 | } |
204 | lt = GNUNET_new(struct GNUNET_CADET_ListTunnels); | 205 | lt = GNUNET_new (struct GNUNET_CADET_ListTunnels); |
205 | lt->tunnels_cb = callback; | 206 | lt->tunnels_cb = callback; |
206 | lt->tunnels_cb_cls = callback_cls; | 207 | lt->tunnels_cb_cls = callback_cls; |
207 | lt->cfg = cfg; | 208 | lt->cfg = cfg; |
208 | reconnect(lt); | 209 | reconnect (lt); |
209 | if (NULL == lt->mq) | 210 | if (NULL == lt->mq) |
210 | { | 211 | { |
211 | GNUNET_free(lt); | 212 | GNUNET_free (lt); |
212 | return NULL; | 213 | return NULL; |
213 | } | 214 | } |
214 | return lt; | 215 | return lt; |
215 | } | 216 | } |
216 | 217 | ||
@@ -222,15 +223,15 @@ GNUNET_CADET_list_tunnels(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
222 | * @return Closure given to GNUNET_CADET_list_tunnels(). | 223 | * @return Closure given to GNUNET_CADET_list_tunnels(). |
223 | */ | 224 | */ |
224 | void * | 225 | void * |
225 | GNUNET_CADET_list_tunnels_cancel(struct GNUNET_CADET_ListTunnels *lt) | 226 | GNUNET_CADET_list_tunnels_cancel (struct GNUNET_CADET_ListTunnels *lt) |
226 | { | 227 | { |
227 | void *ret = lt->tunnels_cb_cls; | 228 | void *ret = lt->tunnels_cb_cls; |
228 | 229 | ||
229 | if (NULL != lt->mq) | 230 | if (NULL != lt->mq) |
230 | GNUNET_MQ_destroy(lt->mq); | 231 | GNUNET_MQ_destroy (lt->mq); |
231 | if (NULL != lt->reconnect_task) | 232 | if (NULL != lt->reconnect_task) |
232 | GNUNET_SCHEDULER_cancel(lt->reconnect_task); | 233 | GNUNET_SCHEDULER_cancel (lt->reconnect_task); |
233 | GNUNET_free(lt); | 234 | GNUNET_free (lt); |
234 | return ret; | 235 | return ret; |
235 | } | 236 | } |
236 | 237 | ||
diff --git a/src/cadet/cadet_protocol.h b/src/cadet/cadet_protocol.h index 6252a1da5..e3417f8c4 100644 --- a/src/cadet/cadet_protocol.h +++ b/src/cadet/cadet_protocol.h | |||
@@ -66,7 +66,8 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
66 | /** | 66 | /** |
67 | * Message for cadet connection creation. | 67 | * Message for cadet connection creation. |
68 | */ | 68 | */ |
69 | struct GNUNET_CADET_ConnectionCreateMessage { | 69 | struct GNUNET_CADET_ConnectionCreateMessage |
70 | { | ||
70 | /** | 71 | /** |
71 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE | 72 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE |
72 | * | 73 | * |
@@ -99,7 +100,8 @@ struct GNUNET_CADET_ConnectionCreateMessage { | |||
99 | /** | 100 | /** |
100 | * Message for ack'ing a connection | 101 | * Message for ack'ing a connection |
101 | */ | 102 | */ |
102 | struct GNUNET_CADET_ConnectionCreateAckMessage { | 103 | struct GNUNET_CADET_ConnectionCreateAckMessage |
104 | { | ||
103 | /** | 105 | /** |
104 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK | 106 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK |
105 | */ | 107 | */ |
@@ -120,7 +122,8 @@ struct GNUNET_CADET_ConnectionCreateAckMessage { | |||
120 | /** | 122 | /** |
121 | * Message for notifying a disconnection in a path | 123 | * Message for notifying a disconnection in a path |
122 | */ | 124 | */ |
123 | struct GNUNET_CADET_ConnectionBrokenMessage { | 125 | struct GNUNET_CADET_ConnectionBrokenMessage |
126 | { | ||
124 | /** | 127 | /** |
125 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN. | 128 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN. |
126 | */ | 129 | */ |
@@ -151,7 +154,8 @@ struct GNUNET_CADET_ConnectionBrokenMessage { | |||
151 | /** | 154 | /** |
152 | * Message to destroy a connection. | 155 | * Message to destroy a connection. |
153 | */ | 156 | */ |
154 | struct GNUNET_CADET_ConnectionDestroyMessage { | 157 | struct GNUNET_CADET_ConnectionDestroyMessage |
158 | { | ||
155 | /** | 159 | /** |
156 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY | 160 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY |
157 | */ | 161 | */ |
@@ -180,7 +184,8 @@ struct GNUNET_CADET_ConnectionDestroyMessage { | |||
180 | * against the respective #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED | 184 | * against the respective #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED |
181 | * messages. | 185 | * messages. |
182 | */ | 186 | */ |
183 | struct CadetEncryptedMessageIdentifier { | 187 | struct CadetEncryptedMessageIdentifier |
188 | { | ||
184 | /** | 189 | /** |
185 | * This number is incremented by one per message. It may wrap around. | 190 | * This number is incremented by one per message. It may wrap around. |
186 | * In network byte order. | 191 | * In network byte order. |
@@ -192,7 +197,8 @@ struct CadetEncryptedMessageIdentifier { | |||
192 | /** | 197 | /** |
193 | * Flags to be used in GNUNET_CADET_KX. | 198 | * Flags to be used in GNUNET_CADET_KX. |
194 | */ | 199 | */ |
195 | enum GNUNET_CADET_KX_Flags { | 200 | enum GNUNET_CADET_KX_Flags |
201 | { | ||
196 | /** | 202 | /** |
197 | * Should the peer reply with its KX details? | 203 | * Should the peer reply with its KX details? |
198 | */ | 204 | */ |
@@ -208,7 +214,8 @@ enum GNUNET_CADET_KX_Flags { | |||
208 | /** | 214 | /** |
209 | * Message for a Key eXchange for a tunnel. | 215 | * Message for a Key eXchange for a tunnel. |
210 | */ | 216 | */ |
211 | struct GNUNET_CADET_TunnelKeyExchangeMessage { | 217 | struct GNUNET_CADET_TunnelKeyExchangeMessage |
218 | { | ||
212 | /** | 219 | /** |
213 | * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX or | 220 | * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX or |
214 | * #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH as part | 221 | * #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH as part |
@@ -263,7 +270,8 @@ struct GNUNET_CADET_TunnelKeyExchangeMessage { | |||
263 | * Message for a Key eXchange for a tunnel, with authentication. | 270 | * Message for a Key eXchange for a tunnel, with authentication. |
264 | * Used as a response to the initial KX as well as for rekeying. | 271 | * Used as a response to the initial KX as well as for rekeying. |
265 | */ | 272 | */ |
266 | struct GNUNET_CADET_TunnelKeyExchangeAuthMessage { | 273 | struct GNUNET_CADET_TunnelKeyExchangeAuthMessage |
274 | { | ||
267 | /** | 275 | /** |
268 | * Message header with key material. | 276 | * Message header with key material. |
269 | */ | 277 | */ |
@@ -290,7 +298,8 @@ struct GNUNET_CADET_TunnelKeyExchangeAuthMessage { | |||
290 | * Encrypted axolotl header with numbers that identify which | 298 | * Encrypted axolotl header with numbers that identify which |
291 | * keys in which ratchet are to be used to decrypt the body. | 299 | * keys in which ratchet are to be used to decrypt the body. |
292 | */ | 300 | */ |
293 | struct GNUNET_CADET_AxHeader { | 301 | struct GNUNET_CADET_AxHeader |
302 | { | ||
294 | /** | 303 | /** |
295 | * Number of messages sent with the current ratchet key. | 304 | * Number of messages sent with the current ratchet key. |
296 | */ | 305 | */ |
@@ -311,7 +320,8 @@ struct GNUNET_CADET_AxHeader { | |||
311 | /** | 320 | /** |
312 | * Axolotl-encrypted tunnel message with application payload. | 321 | * Axolotl-encrypted tunnel message with application payload. |
313 | */ | 322 | */ |
314 | struct GNUNET_CADET_TunnelEncryptedMessage { | 323 | struct GNUNET_CADET_TunnelEncryptedMessage |
324 | { | ||
315 | /** | 325 | /** |
316 | * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED | 326 | * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED |
317 | */ | 327 | */ |
@@ -354,7 +364,8 @@ struct GNUNET_CADET_TunnelEncryptedMessage { | |||
354 | /** | 364 | /** |
355 | * Message to create a Channel. | 365 | * Message to create a Channel. |
356 | */ | 366 | */ |
357 | struct GNUNET_CADET_ChannelOpenMessage { | 367 | struct GNUNET_CADET_ChannelOpenMessage |
368 | { | ||
358 | /** | 369 | /** |
359 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN | 370 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN |
360 | */ | 371 | */ |
@@ -381,7 +392,8 @@ struct GNUNET_CADET_ChannelOpenMessage { | |||
381 | * Message to acknowledge opening a channel of type | 392 | * Message to acknowledge opening a channel of type |
382 | * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK. | 393 | * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK. |
383 | */ | 394 | */ |
384 | struct GNUNET_CADET_ChannelOpenAckMessage { | 395 | struct GNUNET_CADET_ChannelOpenAckMessage |
396 | { | ||
385 | /** | 397 | /** |
386 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK | 398 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK |
387 | */ | 399 | */ |
@@ -409,7 +421,8 @@ struct GNUNET_CADET_ChannelOpenAckMessage { | |||
409 | * Message to destroy a channel of type | 421 | * Message to destroy a channel of type |
410 | * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY. | 422 | * #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY. |
411 | */ | 423 | */ |
412 | struct GNUNET_CADET_ChannelDestroyMessage { | 424 | struct GNUNET_CADET_ChannelDestroyMessage |
425 | { | ||
413 | /** | 426 | /** |
414 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY | 427 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY |
415 | */ | 428 | */ |
@@ -430,7 +443,8 @@ struct GNUNET_CADET_ChannelDestroyMessage { | |||
430 | /** | 443 | /** |
431 | * Number used to uniquely identify messages in a CADET Channel. | 444 | * Number used to uniquely identify messages in a CADET Channel. |
432 | */ | 445 | */ |
433 | struct ChannelMessageIdentifier { | 446 | struct ChannelMessageIdentifier |
447 | { | ||
434 | /** | 448 | /** |
435 | * Unique ID of the message, cycles around, in NBO. | 449 | * Unique ID of the message, cycles around, in NBO. |
436 | */ | 450 | */ |
@@ -441,7 +455,8 @@ struct ChannelMessageIdentifier { | |||
441 | /** | 455 | /** |
442 | * Message for cadet data traffic. | 456 | * Message for cadet data traffic. |
443 | */ | 457 | */ |
444 | struct GNUNET_CADET_ChannelAppDataMessage { | 458 | struct GNUNET_CADET_ChannelAppDataMessage |
459 | { | ||
445 | /** | 460 | /** |
446 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA. | 461 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA. |
447 | */ | 462 | */ |
@@ -466,7 +481,8 @@ struct GNUNET_CADET_ChannelAppDataMessage { | |||
466 | /** | 481 | /** |
467 | * Message to acknowledge end-to-end data. | 482 | * Message to acknowledge end-to-end data. |
468 | */ | 483 | */ |
469 | struct GNUNET_CADET_ChannelDataAckMessage { | 484 | struct GNUNET_CADET_ChannelDataAckMessage |
485 | { | ||
470 | /** | 486 | /** |
471 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK | 487 | * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK |
472 | */ | 488 | */ |
diff --git a/src/cadet/cadet_test_lib.c b/src/cadet/cadet_test_lib.c index ae1eb6f00..490e6539b 100644 --- a/src/cadet/cadet_test_lib.c +++ b/src/cadet/cadet_test_lib.c | |||
@@ -31,7 +31,8 @@ | |||
31 | /** | 31 | /** |
32 | * Test context for a CADET Test. | 32 | * Test context for a CADET Test. |
33 | */ | 33 | */ |
34 | struct GNUNET_CADET_TEST_Context { | 34 | struct GNUNET_CADET_TEST_Context |
35 | { | ||
35 | /** | 36 | /** |
36 | * Array of running peers. | 37 | * Array of running peers. |
37 | */ | 38 | */ |
@@ -97,7 +98,8 @@ struct GNUNET_CADET_TEST_Context { | |||
97 | /** | 98 | /** |
98 | * Context for a cadet adapter callback. | 99 | * Context for a cadet adapter callback. |
99 | */ | 100 | */ |
100 | struct GNUNET_CADET_TEST_AdapterContext { | 101 | struct GNUNET_CADET_TEST_AdapterContext |
102 | { | ||
101 | /** | 103 | /** |
102 | * Peer number for the particular peer. | 104 | * Peer number for the particular peer. |
103 | */ | 105 | */ |
@@ -126,33 +128,33 @@ struct GNUNET_CADET_TEST_AdapterContext { | |||
126 | * @return service handle to return in 'op_result', NULL on error | 128 | * @return service handle to return in 'op_result', NULL on error |
127 | */ | 129 | */ |
128 | static void * | 130 | static void * |
129 | cadet_connect_adapter(void *cls, | 131 | cadet_connect_adapter (void *cls, |
130 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 132 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
131 | { | 133 | { |
132 | struct GNUNET_CADET_TEST_AdapterContext *actx = cls; | 134 | struct GNUNET_CADET_TEST_AdapterContext *actx = cls; |
133 | struct GNUNET_CADET_TEST_Context *ctx = actx->ctx; | 135 | struct GNUNET_CADET_TEST_Context *ctx = actx->ctx; |
134 | struct GNUNET_CADET_Handle *h; | 136 | struct GNUNET_CADET_Handle *h; |
135 | 137 | ||
136 | h = GNUNET_CADET_connect(cfg); | 138 | h = GNUNET_CADET_connect (cfg); |
137 | if (NULL == h) | 139 | if (NULL == h) |
138 | { | 140 | { |
139 | GNUNET_break(0); | 141 | GNUNET_break (0); |
140 | return NULL; | 142 | return NULL; |
141 | } | 143 | } |
142 | if (NULL == ctx->ports) | 144 | if (NULL == ctx->ports) |
143 | return h; | 145 | return h; |
144 | actx->ports = GNUNET_new_array(ctx->port_count, | 146 | actx->ports = GNUNET_new_array (ctx->port_count, |
145 | struct GNUNET_CADET_Port *); | 147 | struct GNUNET_CADET_Port *); |
146 | for (unsigned int i = 0; i < ctx->port_count; i++) | 148 | for (unsigned int i = 0; i < ctx->port_count; i++) |
147 | { | 149 | { |
148 | actx->ports[i] = GNUNET_CADET_open_port(h, | 150 | actx->ports[i] = GNUNET_CADET_open_port (h, |
149 | ctx->ports[i], | 151 | ctx->ports[i], |
150 | ctx->connects, | 152 | ctx->connects, |
151 | (void *)(long)actx->peer, | 153 | (void *) (long) actx->peer, |
152 | ctx->window_changes, | 154 | ctx->window_changes, |
153 | ctx->disconnects, | 155 | ctx->disconnects, |
154 | ctx->handlers); | 156 | ctx->handlers); |
155 | } | 157 | } |
156 | return h; | 158 | return h; |
157 | } | 159 | } |
158 | 160 | ||
@@ -165,23 +167,23 @@ cadet_connect_adapter(void *cls, | |||
165 | * @param op_result service handle returned from the connect adapter | 167 | * @param op_result service handle returned from the connect adapter |
166 | */ | 168 | */ |
167 | static void | 169 | static void |
168 | cadet_disconnect_adapter(void *cls, | 170 | cadet_disconnect_adapter (void *cls, |
169 | void *op_result) | 171 | void *op_result) |
170 | { | 172 | { |
171 | struct GNUNET_CADET_Handle *cadet = op_result; | 173 | struct GNUNET_CADET_Handle *cadet = op_result; |
172 | struct GNUNET_CADET_TEST_AdapterContext *actx = cls; | 174 | struct GNUNET_CADET_TEST_AdapterContext *actx = cls; |
173 | 175 | ||
174 | if (NULL != actx->ports) | 176 | if (NULL != actx->ports) |
177 | { | ||
178 | for (unsigned int i = 0; i < actx->ctx->port_count; i++) | ||
175 | { | 179 | { |
176 | for (unsigned int i = 0; i < actx->ctx->port_count; i++) | 180 | GNUNET_CADET_close_port (actx->ports[i]); |
177 | { | 181 | actx->ports[i] = NULL; |
178 | GNUNET_CADET_close_port(actx->ports[i]); | ||
179 | actx->ports[i] = NULL; | ||
180 | } | ||
181 | GNUNET_free(actx->ports); | ||
182 | } | 182 | } |
183 | GNUNET_free(actx); | 183 | GNUNET_free (actx->ports); |
184 | GNUNET_CADET_disconnect(cadet); | 184 | } |
185 | GNUNET_free (actx); | ||
186 | GNUNET_CADET_disconnect (cadet); | ||
185 | } | 187 | } |
186 | 188 | ||
187 | 189 | ||
@@ -196,56 +198,56 @@ cadet_disconnect_adapter(void *cls, | |||
196 | * NULL if operation has executed successfully. | 198 | * NULL if operation has executed successfully. |
197 | */ | 199 | */ |
198 | static void | 200 | static void |
199 | cadet_connect_cb(void *cls, | 201 | cadet_connect_cb (void *cls, |
200 | struct GNUNET_TESTBED_Operation *op, | 202 | struct GNUNET_TESTBED_Operation *op, |
201 | void *ca_result, | 203 | void *ca_result, |
202 | const char *emsg) | 204 | const char *emsg) |
203 | { | 205 | { |
204 | struct GNUNET_CADET_TEST_Context *ctx = cls; | 206 | struct GNUNET_CADET_TEST_Context *ctx = cls; |
205 | 207 | ||
206 | if (NULL != emsg) | 208 | if (NULL != emsg) |
207 | { | 209 | { |
208 | fprintf(stderr, | 210 | fprintf (stderr, |
209 | "Failed to connect to CADET service: %s\n", | 211 | "Failed to connect to CADET service: %s\n", |
210 | emsg); | 212 | emsg); |
211 | GNUNET_SCHEDULER_shutdown(); | 213 | GNUNET_SCHEDULER_shutdown (); |
212 | return; | 214 | return; |
213 | } | 215 | } |
214 | for (unsigned int i = 0; i < ctx->num_peers; i++) | 216 | for (unsigned int i = 0; i < ctx->num_peers; i++) |
215 | if (op == ctx->ops[i]) | 217 | if (op == ctx->ops[i]) |
216 | { | 218 | { |
217 | ctx->cadets[i] = ca_result; | 219 | ctx->cadets[i] = ca_result; |
218 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 220 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
219 | "...cadet %u connected\n", | 221 | "...cadet %u connected\n", |
220 | i); | 222 | i); |
221 | } | 223 | } |
222 | for (unsigned int i = 0; i < ctx->num_peers; i++) | 224 | for (unsigned int i = 0; i < ctx->num_peers; i++) |
223 | if (NULL == ctx->cadets[i]) | 225 | if (NULL == ctx->cadets[i]) |
224 | return; | 226 | return; |
225 | /* still some CADET connections missing */ | 227 | /* still some CADET connections missing */ |
226 | /* all CADET connections ready! */ | 228 | /* all CADET connections ready! */ |
227 | ctx->app_main(ctx->app_main_cls, | 229 | ctx->app_main (ctx->app_main_cls, |
228 | ctx, | 230 | ctx, |
229 | ctx->num_peers, | 231 | ctx->num_peers, |
230 | ctx->peers, | 232 | ctx->peers, |
231 | ctx->cadets); | 233 | ctx->cadets); |
232 | } | 234 | } |
233 | 235 | ||
234 | 236 | ||
235 | void | 237 | void |
236 | GNUNET_CADET_TEST_cleanup(struct GNUNET_CADET_TEST_Context *ctx) | 238 | GNUNET_CADET_TEST_cleanup (struct GNUNET_CADET_TEST_Context *ctx) |
237 | { | 239 | { |
238 | for (unsigned int i = 0; i < ctx->num_peers; i++) | 240 | for (unsigned int i = 0; i < ctx->num_peers; i++) |
239 | { | 241 | { |
240 | GNUNET_assert(NULL != ctx->ops[i]); | 242 | GNUNET_assert (NULL != ctx->ops[i]); |
241 | GNUNET_TESTBED_operation_done(ctx->ops[i]); | 243 | GNUNET_TESTBED_operation_done (ctx->ops[i]); |
242 | ctx->ops[i] = NULL; | 244 | ctx->ops[i] = NULL; |
243 | } | 245 | } |
244 | GNUNET_free(ctx->ops); | 246 | GNUNET_free (ctx->ops); |
245 | GNUNET_free(ctx->cadets); | 247 | GNUNET_free (ctx->cadets); |
246 | GNUNET_free(ctx->handlers); | 248 | GNUNET_free (ctx->handlers); |
247 | GNUNET_free(ctx); | 249 | GNUNET_free (ctx); |
248 | GNUNET_SCHEDULER_shutdown(); | 250 | GNUNET_SCHEDULER_shutdown (); |
249 | } | 251 | } |
250 | 252 | ||
251 | 253 | ||
@@ -263,57 +265,57 @@ GNUNET_CADET_TEST_cleanup(struct GNUNET_CADET_TEST_Context *ctx) | |||
263 | * failed | 265 | * failed |
264 | */ | 266 | */ |
265 | static void | 267 | static void |
266 | cadet_test_run(void *cls, | 268 | cadet_test_run (void *cls, |
267 | struct GNUNET_TESTBED_RunHandle *h, | 269 | struct GNUNET_TESTBED_RunHandle *h, |
268 | unsigned int num_peers, | 270 | unsigned int num_peers, |
269 | struct GNUNET_TESTBED_Peer **peers, | 271 | struct GNUNET_TESTBED_Peer **peers, |
270 | unsigned int links_succeeded, | 272 | unsigned int links_succeeded, |
271 | unsigned int links_failed) | 273 | unsigned int links_failed) |
272 | { | 274 | { |
273 | struct GNUNET_CADET_TEST_Context *ctx = cls; | 275 | struct GNUNET_CADET_TEST_Context *ctx = cls; |
274 | 276 | ||
275 | if (0 != links_failed) | 277 | if (0 != links_failed) |
276 | { | 278 | { |
277 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 279 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
278 | "Some links failed (%u), ending\n", | 280 | "Some links failed (%u), ending\n", |
279 | links_failed); | 281 | links_failed); |
280 | exit(77); | 282 | exit (77); |
281 | } | 283 | } |
282 | if (num_peers != ctx->num_peers) | 284 | if (num_peers != ctx->num_peers) |
283 | { | 285 | { |
284 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 286 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
285 | "Peers started %u/%u, ending\n", | 287 | "Peers started %u/%u, ending\n", |
286 | num_peers, | 288 | num_peers, |
287 | ctx->num_peers); | 289 | ctx->num_peers); |
288 | exit(1); | 290 | exit (1); |
289 | } | 291 | } |
290 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 292 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
291 | "Testbed up, %u peers and %u links\n", | 293 | "Testbed up, %u peers and %u links\n", |
292 | num_peers, | 294 | num_peers, |
293 | links_succeeded); | 295 | links_succeeded); |
294 | ctx->peers = peers; | 296 | ctx->peers = peers; |
295 | for (unsigned int i = 0; i < num_peers; i++) | 297 | for (unsigned int i = 0; i < num_peers; i++) |
296 | { | 298 | { |
297 | struct GNUNET_CADET_TEST_AdapterContext *newctx; | 299 | struct GNUNET_CADET_TEST_AdapterContext *newctx; |
298 | 300 | ||
299 | newctx = GNUNET_new(struct GNUNET_CADET_TEST_AdapterContext); | 301 | newctx = GNUNET_new (struct GNUNET_CADET_TEST_AdapterContext); |
300 | newctx->peer = i; | 302 | newctx->peer = i; |
301 | newctx->ctx = ctx; | 303 | newctx->ctx = ctx; |
302 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 304 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
303 | "Connecting to cadet %u\n", | 305 | "Connecting to cadet %u\n", |
304 | i); | 306 | i); |
305 | ctx->ops[i] = GNUNET_TESTBED_service_connect(ctx, | 307 | ctx->ops[i] = GNUNET_TESTBED_service_connect (ctx, |
306 | peers[i], | 308 | peers[i], |
307 | "cadet", | 309 | "cadet", |
308 | &cadet_connect_cb, | 310 | &cadet_connect_cb, |
309 | ctx, | 311 | ctx, |
310 | &cadet_connect_adapter, | 312 | &cadet_connect_adapter, |
311 | &cadet_disconnect_adapter, | 313 | &cadet_disconnect_adapter, |
312 | newctx); | 314 | newctx); |
313 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 315 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
314 | "op handle %p\n", | 316 | "op handle %p\n", |
315 | ctx->ops[i]); | 317 | ctx->ops[i]); |
316 | } | 318 | } |
317 | } | 319 | } |
318 | 320 | ||
319 | 321 | ||
@@ -333,41 +335,41 @@ cadet_test_run(void *cls, | |||
333 | * @param ports Ports the peers offer, NULL-terminated. | 335 | * @param ports Ports the peers offer, NULL-terminated. |
334 | */ | 336 | */ |
335 | void | 337 | void |
336 | GNUNET_CADET_TEST_ruN(const char *testname, | 338 | GNUNET_CADET_TEST_ruN (const char *testname, |
337 | const char *cfgfile, | 339 | const char *cfgfile, |
338 | unsigned int num_peers, | 340 | unsigned int num_peers, |
339 | GNUNET_CADET_TEST_AppMain tmain, | 341 | GNUNET_CADET_TEST_AppMain tmain, |
340 | void *tmain_cls, | 342 | void *tmain_cls, |
341 | GNUNET_CADET_ConnectEventHandler connects, | 343 | GNUNET_CADET_ConnectEventHandler connects, |
342 | GNUNET_CADET_WindowSizeEventHandler window_changes, | 344 | GNUNET_CADET_WindowSizeEventHandler window_changes, |
343 | GNUNET_CADET_DisconnectEventHandler disconnects, | 345 | GNUNET_CADET_DisconnectEventHandler disconnects, |
344 | struct GNUNET_MQ_MessageHandler *handlers, | 346 | struct GNUNET_MQ_MessageHandler *handlers, |
345 | const struct GNUNET_HashCode **ports) | 347 | const struct GNUNET_HashCode **ports) |
346 | { | 348 | { |
347 | struct GNUNET_CADET_TEST_Context *ctx; | 349 | struct GNUNET_CADET_TEST_Context *ctx; |
348 | 350 | ||
349 | ctx = GNUNET_new(struct GNUNET_CADET_TEST_Context); | 351 | ctx = GNUNET_new (struct GNUNET_CADET_TEST_Context); |
350 | ctx->num_peers = num_peers; | 352 | ctx->num_peers = num_peers; |
351 | ctx->ops = GNUNET_new_array(num_peers, | 353 | ctx->ops = GNUNET_new_array (num_peers, |
352 | struct GNUNET_TESTBED_Operation *); | 354 | struct GNUNET_TESTBED_Operation *); |
353 | ctx->cadets = GNUNET_new_array(num_peers, | 355 | ctx->cadets = GNUNET_new_array (num_peers, |
354 | struct GNUNET_CADET_Handle *); | 356 | struct GNUNET_CADET_Handle *); |
355 | ctx->app_main = tmain; | 357 | ctx->app_main = tmain; |
356 | ctx->app_main_cls = tmain_cls; | 358 | ctx->app_main_cls = tmain_cls; |
357 | ctx->connects = connects; | 359 | ctx->connects = connects; |
358 | ctx->window_changes = window_changes; | 360 | ctx->window_changes = window_changes; |
359 | ctx->disconnects = disconnects; | 361 | ctx->disconnects = disconnects; |
360 | ctx->handlers = GNUNET_MQ_copy_handlers(handlers); | 362 | ctx->handlers = GNUNET_MQ_copy_handlers (handlers); |
361 | ctx->ports = ports; | 363 | ctx->ports = ports; |
362 | ctx->port_count = 0; | 364 | ctx->port_count = 0; |
363 | while (NULL != ctx->ports[ctx->port_count]) | 365 | while (NULL != ctx->ports[ctx->port_count]) |
364 | ctx->port_count++; | 366 | ctx->port_count++; |
365 | GNUNET_TESTBED_test_run(testname, | 367 | GNUNET_TESTBED_test_run (testname, |
366 | cfgfile, | 368 | cfgfile, |
367 | num_peers, | 369 | num_peers, |
368 | 0LL, NULL, NULL, | 370 | 0LL, NULL, NULL, |
369 | &cadet_test_run, | 371 | &cadet_test_run, |
370 | ctx); | 372 | ctx); |
371 | } | 373 | } |
372 | 374 | ||
373 | /* end of cadet_test_lib.c */ | 375 | /* end of cadet_test_lib.c */ |
diff --git a/src/cadet/cadet_test_lib.h b/src/cadet/cadet_test_lib.h index f526831a6..7d446801a 100644 --- a/src/cadet/cadet_test_lib.h +++ b/src/cadet/cadet_test_lib.h | |||
@@ -74,16 +74,16 @@ typedef void (*GNUNET_CADET_TEST_AppMain) (void *cls, | |||
74 | * @param ports Ports the peers offer, NULL-terminated. | 74 | * @param ports Ports the peers offer, NULL-terminated. |
75 | */ | 75 | */ |
76 | void | 76 | void |
77 | GNUNET_CADET_TEST_ruN(const char *testname, | 77 | GNUNET_CADET_TEST_ruN (const char *testname, |
78 | const char *cfgfile, | 78 | const char *cfgfile, |
79 | unsigned int num_peers, | 79 | unsigned int num_peers, |
80 | GNUNET_CADET_TEST_AppMain tmain, | 80 | GNUNET_CADET_TEST_AppMain tmain, |
81 | void *tmain_cls, | 81 | void *tmain_cls, |
82 | GNUNET_CADET_ConnectEventHandler connects, | 82 | GNUNET_CADET_ConnectEventHandler connects, |
83 | GNUNET_CADET_WindowSizeEventHandler window_changes, | 83 | GNUNET_CADET_WindowSizeEventHandler window_changes, |
84 | GNUNET_CADET_DisconnectEventHandler disconnects, | 84 | GNUNET_CADET_DisconnectEventHandler disconnects, |
85 | struct GNUNET_MQ_MessageHandler *handlers, | 85 | struct GNUNET_MQ_MessageHandler *handlers, |
86 | const struct GNUNET_HashCode **ports); | 86 | const struct GNUNET_HashCode **ports); |
87 | 87 | ||
88 | /** | 88 | /** |
89 | * Clean up the testbed. | 89 | * Clean up the testbed. |
@@ -91,7 +91,7 @@ GNUNET_CADET_TEST_ruN(const char *testname, | |||
91 | * @param ctx handle for the testbed | 91 | * @param ctx handle for the testbed |
92 | */ | 92 | */ |
93 | void | 93 | void |
94 | GNUNET_CADET_TEST_cleanup(struct GNUNET_CADET_TEST_Context *ctx); | 94 | GNUNET_CADET_TEST_cleanup (struct GNUNET_CADET_TEST_Context *ctx); |
95 | 95 | ||
96 | 96 | ||
97 | #if 0 /* keep Emacsens' auto-indent happy */ | 97 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/cadet/desirability_table.c b/src/cadet/desirability_table.c index 5c23de76b..829c618af 100644 --- a/src/cadet/desirability_table.c +++ b/src/cadet/desirability_table.c | |||
@@ -8,26 +8,26 @@ | |||
8 | #include <stdio.h> | 8 | #include <stdio.h> |
9 | 9 | ||
10 | int | 10 | int |
11 | main() | 11 | main () |
12 | { | 12 | { |
13 | for (unsigned int num_alts = 1; num_alts < 10; num_alts++) | 13 | for (unsigned int num_alts = 1; num_alts < 10; num_alts++) |
14 | for (unsigned int off = 0; off < 10; off++) | 14 | for (unsigned int off = 0; off < 10; off++) |
15 | for (double delta = -(int)off; delta <= 5; delta += 0.25) | 15 | for (double delta = -(int) off; delta <= 5; delta += 0.25) |
16 | { | 16 | { |
17 | double weight_alts; | 17 | double weight_alts; |
18 | 18 | ||
19 | if (delta <= -1.0) | 19 | if (delta <= -1.0) |
20 | weight_alts = -1.0 * num_alts / delta; /* discount alternative paths */ | 20 | weight_alts = -1.0 * num_alts / delta; /* discount alternative paths */ |
21 | else if (delta >= 1.0) | 21 | else if (delta >= 1.0) |
22 | weight_alts = 1.0 * num_alts * delta; /* overcount alternative paths */ | 22 | weight_alts = 1.0 * num_alts * delta; /* overcount alternative paths */ |
23 | else | 23 | else |
24 | weight_alts = 1.0 * num_alts; /* count alternative paths normally */ | 24 | weight_alts = 1.0 * num_alts; /* count alternative paths normally */ |
25 | 25 | ||
26 | fprintf(stderr, | 26 | fprintf (stderr, |
27 | "Paths: %u Offset: %u Delta: %5.2f SCORE: %f\n", | 27 | "Paths: %u Offset: %u Delta: %5.2f SCORE: %f\n", |
28 | num_alts, | 28 | num_alts, |
29 | off, | 29 | off, |
30 | delta, | 30 | delta, |
31 | ((off + 1.0) / (weight_alts * weight_alts))); | 31 | ((off + 1.0) / (weight_alts * weight_alts))); |
32 | } | 32 | } |
33 | } | 33 | } |
diff --git a/src/cadet/gnunet-cadet-profiler.c b/src/cadet/gnunet-cadet-profiler.c index b3e7fa30d..e66761e1e 100644 --- a/src/cadet/gnunet-cadet-profiler.c +++ b/src/cadet/gnunet-cadet-profiler.c | |||
@@ -41,12 +41,12 @@ | |||
41 | /** | 41 | /** |
42 | * How long until we give up on connecting the peers? | 42 | * How long until we give up on connecting the peers? |
43 | */ | 43 | */ |
44 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120) | 44 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) |
45 | 45 | ||
46 | /** | 46 | /** |
47 | * Time to wait for stuff that should be rather fast | 47 | * Time to wait for stuff that should be rather fast |
48 | */ | 48 | */ |
49 | #define SHORT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300) | 49 | #define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300) |
50 | 50 | ||
51 | /** | 51 | /** |
52 | * Total number of rounds. | 52 | * Total number of rounds. |
@@ -61,7 +61,8 @@ static float rounds[] = { 0.8, 0.6, 0.8, 0.5, 0.3, 0.8, 0.0 }; | |||
61 | /** | 61 | /** |
62 | * Message type for pings. | 62 | * Message type for pings. |
63 | */ | 63 | */ |
64 | struct CadetPingMessage { | 64 | struct CadetPingMessage |
65 | { | ||
65 | /** | 66 | /** |
66 | * Header. Type PING/PONG. | 67 | * Header. Type PING/PONG. |
67 | */ | 68 | */ |
@@ -86,7 +87,8 @@ struct CadetPingMessage { | |||
86 | /** | 87 | /** |
87 | * Peer description. | 88 | * Peer description. |
88 | */ | 89 | */ |
89 | struct CadetPeer { | 90 | struct CadetPeer |
91 | { | ||
90 | /** | 92 | /** |
91 | * Testbed Operation (to get peer id, etc). | 93 | * Testbed Operation (to get peer id, etc). |
92 | */ | 94 | */ |
@@ -253,7 +255,7 @@ static struct GNUNET_SCHEDULER_Task *round_task; | |||
253 | * @param cls Closure (unsued). | 255 | * @param cls Closure (unsued). |
254 | */ | 256 | */ |
255 | static void | 257 | static void |
256 | start_test(void *cls); | 258 | start_test (void *cls); |
257 | 259 | ||
258 | 260 | ||
259 | /** | 261 | /** |
@@ -264,12 +266,12 @@ start_test(void *cls); | |||
264 | * @return A time between 0 a max-1 ms. | 266 | * @return A time between 0 a max-1 ms. |
265 | */ | 267 | */ |
266 | static struct GNUNET_TIME_Relative | 268 | static struct GNUNET_TIME_Relative |
267 | delay_ms_rnd(unsigned int max) | 269 | delay_ms_rnd (unsigned int max) |
268 | { | 270 | { |
269 | unsigned int rnd; | 271 | unsigned int rnd; |
270 | 272 | ||
271 | rnd = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, max); | 273 | rnd = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max); |
272 | return GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, rnd); | 274 | return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, rnd); |
273 | } | 275 | } |
274 | 276 | ||
275 | 277 | ||
@@ -281,7 +283,7 @@ delay_ms_rnd(unsigned int max) | |||
281 | * @return Index of peer in peers. | 283 | * @return Index of peer in peers. |
282 | */ | 284 | */ |
283 | static unsigned int | 285 | static unsigned int |
284 | get_index(struct CadetPeer *peer) | 286 | get_index (struct CadetPeer *peer) |
285 | { | 287 | { |
286 | return peer - peers; | 288 | return peer - peers; |
287 | } | 289 | } |
@@ -291,23 +293,23 @@ get_index(struct CadetPeer *peer) | |||
291 | * Show the results of the test (banwidth acheived) and log them to GAUGER | 293 | * Show the results of the test (banwidth acheived) and log them to GAUGER |
292 | */ | 294 | */ |
293 | static void | 295 | static void |
294 | show_end_data(void) | 296 | show_end_data (void) |
295 | { | 297 | { |
296 | struct CadetPeer *peer; | 298 | struct CadetPeer *peer; |
297 | unsigned int i; | 299 | unsigned int i; |
298 | unsigned int j; | 300 | unsigned int j; |
299 | 301 | ||
300 | for (i = 0; i < number_rounds; i++) | 302 | for (i = 0; i < number_rounds; i++) |
303 | { | ||
304 | for (j = 0; j < peers_pinging; j++) | ||
301 | { | 305 | { |
302 | for (j = 0; j < peers_pinging; j++) | 306 | peer = &peers[j]; |
303 | { | 307 | fprintf (stdout, |
304 | peer = &peers[j]; | 308 | "ROUND %3u PEER %3u: %10.2f / %10.2f, PINGS: %3u, PONGS: %3u\n", |
305 | fprintf(stdout, | 309 | i, j, peer->mean[i], sqrt (peer->var[i] / (peer->pongs[i] - 1)), |
306 | "ROUND %3u PEER %3u: %10.2f / %10.2f, PINGS: %3u, PONGS: %3u\n", | 310 | peer->pings[i], peer->pongs[i]); |
307 | i, j, peer->mean[i], sqrt(peer->var[i] / (peer->pongs[i] - 1)), | ||
308 | peer->pings[i], peer->pongs[i]); | ||
309 | } | ||
310 | } | 311 | } |
312 | } | ||
311 | } | 313 | } |
312 | 314 | ||
313 | 315 | ||
@@ -317,46 +319,46 @@ show_end_data(void) | |||
317 | * @param cls Closure (unused). | 319 | * @param cls Closure (unused). |
318 | */ | 320 | */ |
319 | static void | 321 | static void |
320 | disconnect_cadet_peers(void *cls) | 322 | disconnect_cadet_peers (void *cls) |
321 | { | 323 | { |
322 | long line = (long)cls; | 324 | long line = (long) cls; |
323 | unsigned int i; | 325 | unsigned int i; |
324 | 326 | ||
325 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 327 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
326 | "disconnecting cadet service, called from line %ld\n", | 328 | "disconnecting cadet service, called from line %ld\n", |
327 | line); | 329 | line); |
328 | disconnect_task = NULL; | 330 | disconnect_task = NULL; |
329 | for (i = 0; i < peers_total; i++) | 331 | for (i = 0; i < peers_total; i++) |
332 | { | ||
333 | if (NULL != peers[i].op) | ||
334 | GNUNET_TESTBED_operation_done (peers[i].op); | ||
335 | |||
336 | if (peers[i].up != GNUNET_YES) | ||
337 | continue; | ||
338 | |||
339 | if (NULL != peers[i].ch) | ||
340 | { | ||
341 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
342 | "%u: channel %p\n", i, peers[i].ch); | ||
343 | GNUNET_CADET_channel_destroy (peers[i].ch); | ||
344 | } | ||
345 | if (NULL != peers[i].warmup_ch) | ||
346 | { | ||
347 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
348 | "%u: warmup channel %p\n", | ||
349 | i, peers[i].warmup_ch); | ||
350 | GNUNET_CADET_channel_destroy (peers[i].warmup_ch); | ||
351 | } | ||
352 | if (NULL != peers[i].incoming_ch) | ||
330 | { | 353 | { |
331 | if (NULL != peers[i].op) | 354 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
332 | GNUNET_TESTBED_operation_done(peers[i].op); | 355 | "%u: incoming channel %p\n", |
333 | 356 | i, peers[i].incoming_ch); | |
334 | if (peers[i].up != GNUNET_YES) | 357 | GNUNET_CADET_channel_destroy (peers[i].incoming_ch); |
335 | continue; | ||
336 | |||
337 | if (NULL != peers[i].ch) | ||
338 | { | ||
339 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
340 | "%u: channel %p\n", i, peers[i].ch); | ||
341 | GNUNET_CADET_channel_destroy(peers[i].ch); | ||
342 | } | ||
343 | if (NULL != peers[i].warmup_ch) | ||
344 | { | ||
345 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
346 | "%u: warmup channel %p\n", | ||
347 | i, peers[i].warmup_ch); | ||
348 | GNUNET_CADET_channel_destroy(peers[i].warmup_ch); | ||
349 | } | ||
350 | if (NULL != peers[i].incoming_ch) | ||
351 | { | ||
352 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
353 | "%u: incoming channel %p\n", | ||
354 | i, peers[i].incoming_ch); | ||
355 | GNUNET_CADET_channel_destroy(peers[i].incoming_ch); | ||
356 | } | ||
357 | } | 358 | } |
358 | GNUNET_CADET_TEST_cleanup(test_ctx); | 359 | } |
359 | GNUNET_SCHEDULER_shutdown(); | 360 | GNUNET_CADET_TEST_cleanup (test_ctx); |
361 | GNUNET_SCHEDULER_shutdown (); | ||
360 | } | 362 | } |
361 | 363 | ||
362 | 364 | ||
@@ -366,26 +368,26 @@ disconnect_cadet_peers(void *cls) | |||
366 | * @param cls Closure (unused). | 368 | * @param cls Closure (unused). |
367 | */ | 369 | */ |
368 | static void | 370 | static void |
369 | shutdown_task(void *cls) | 371 | shutdown_task (void *cls) |
370 | { | 372 | { |
371 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 373 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
372 | "Ending test.\n"); | 374 | "Ending test.\n"); |
373 | if (NULL != disconnect_task) | 375 | if (NULL != disconnect_task) |
374 | { | 376 | { |
375 | GNUNET_SCHEDULER_cancel(disconnect_task); | 377 | GNUNET_SCHEDULER_cancel (disconnect_task); |
376 | disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 378 | disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
377 | (void *)__LINE__); | 379 | (void *) __LINE__); |
378 | } | 380 | } |
379 | if (NULL != round_task) | 381 | if (NULL != round_task) |
380 | { | 382 | { |
381 | GNUNET_SCHEDULER_cancel(round_task); | 383 | GNUNET_SCHEDULER_cancel (round_task); |
382 | round_task = NULL; | 384 | round_task = NULL; |
383 | } | 385 | } |
384 | if (NULL != test_task) | 386 | if (NULL != test_task) |
385 | { | 387 | { |
386 | GNUNET_SCHEDULER_cancel(test_task); | 388 | GNUNET_SCHEDULER_cancel (test_task); |
387 | test_task = NULL; | 389 | test_task = NULL; |
388 | } | 390 | } |
389 | } | 391 | } |
390 | 392 | ||
391 | 393 | ||
@@ -395,14 +397,14 @@ shutdown_task(void *cls) | |||
395 | * @param line Line in the code the abort is requested from (__LINE__). | 397 | * @param line Line in the code the abort is requested from (__LINE__). |
396 | */ | 398 | */ |
397 | static void | 399 | static void |
398 | abort_test(long line) | 400 | abort_test (long line) |
399 | { | 401 | { |
400 | if (disconnect_task != NULL) | 402 | if (disconnect_task != NULL) |
401 | { | 403 | { |
402 | GNUNET_SCHEDULER_cancel(disconnect_task); | 404 | GNUNET_SCHEDULER_cancel (disconnect_task); |
403 | disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 405 | disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
404 | (void *)line); | 406 | (void *) line); |
405 | } | 407 | } |
406 | } | 408 | } |
407 | 409 | ||
408 | /** | 410 | /** |
@@ -415,15 +417,15 @@ abort_test(long line) | |||
415 | * operation has executed successfully. | 417 | * operation has executed successfully. |
416 | */ | 418 | */ |
417 | static void | 419 | static void |
418 | stats_cont(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg) | 420 | stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg) |
419 | { | 421 | { |
420 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "... collecting statistics done.\n"); | 422 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "... collecting statistics done.\n"); |
421 | GNUNET_TESTBED_operation_done(stats_op); | 423 | GNUNET_TESTBED_operation_done (stats_op); |
422 | 424 | ||
423 | if (NULL != disconnect_task) | 425 | if (NULL != disconnect_task) |
424 | GNUNET_SCHEDULER_cancel(disconnect_task); | 426 | GNUNET_SCHEDULER_cancel (disconnect_task); |
425 | disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 427 | disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
426 | (void *)__LINE__); | 428 | (void *) __LINE__); |
427 | } | 429 | } |
428 | 430 | ||
429 | 431 | ||
@@ -439,20 +441,20 @@ stats_cont(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg) | |||
439 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration | 441 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration |
440 | */ | 442 | */ |
441 | static int | 443 | static int |
442 | stats_iterator(void *cls, | 444 | stats_iterator (void *cls, |
443 | const struct GNUNET_TESTBED_Peer *peer, | 445 | const struct GNUNET_TESTBED_Peer *peer, |
444 | const char *subsystem, | 446 | const char *subsystem, |
445 | const char *name, | 447 | const char *name, |
446 | uint64_t value, | 448 | uint64_t value, |
447 | int is_persistent) | 449 | int is_persistent) |
448 | { | 450 | { |
449 | uint32_t i; | 451 | uint32_t i; |
450 | 452 | ||
451 | i = GNUNET_TESTBED_get_index(peer); | 453 | i = GNUNET_TESTBED_get_index (peer); |
452 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 454 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
453 | " STATS %u - %s [%s]: %llu\n", | 455 | " STATS %u - %s [%s]: %llu\n", |
454 | i, subsystem, name, | 456 | i, subsystem, name, |
455 | (unsigned long long)value); | 457 | (unsigned long long) value); |
456 | 458 | ||
457 | return GNUNET_OK; | 459 | return GNUNET_OK; |
458 | } | 460 | } |
@@ -464,15 +466,15 @@ stats_iterator(void *cls, | |||
464 | * @param cls Closure (NULL). | 466 | * @param cls Closure (NULL). |
465 | */ | 467 | */ |
466 | static void | 468 | static void |
467 | collect_stats(void *cls) | 469 | collect_stats (void *cls) |
468 | { | 470 | { |
469 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 471 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
470 | "Start collecting statistics...\n"); | 472 | "Start collecting statistics...\n"); |
471 | stats_op = GNUNET_TESTBED_get_statistics(peers_total, | 473 | stats_op = GNUNET_TESTBED_get_statistics (peers_total, |
472 | testbed_handles, | 474 | testbed_handles, |
473 | NULL, NULL, | 475 | NULL, NULL, |
474 | &stats_iterator, | 476 | &stats_iterator, |
475 | &stats_cont, NULL); | 477 | &stats_cont, NULL); |
476 | } | 478 | } |
477 | 479 | ||
478 | 480 | ||
@@ -482,11 +484,11 @@ collect_stats(void *cls) | |||
482 | * @param cls Closure (unused). | 484 | * @param cls Closure (unused). |
483 | */ | 485 | */ |
484 | static void | 486 | static void |
485 | finish_profiler(void *cls) | 487 | finish_profiler (void *cls) |
486 | { | 488 | { |
487 | test_finished = GNUNET_YES; | 489 | test_finished = GNUNET_YES; |
488 | show_end_data(); | 490 | show_end_data (); |
489 | GNUNET_SCHEDULER_add_now(&collect_stats, NULL); | 491 | GNUNET_SCHEDULER_add_now (&collect_stats, NULL); |
490 | } | 492 | } |
491 | 493 | ||
492 | 494 | ||
@@ -496,7 +498,7 @@ finish_profiler(void *cls) | |||
496 | * @param target Desired number of running peers. | 498 | * @param target Desired number of running peers. |
497 | */ | 499 | */ |
498 | static void | 500 | static void |
499 | adjust_running_peers(unsigned int target) | 501 | adjust_running_peers (unsigned int target) |
500 | { | 502 | { |
501 | struct GNUNET_TESTBED_Operation *op; | 503 | struct GNUNET_TESTBED_Operation *op; |
502 | unsigned int delta; | 504 | unsigned int delta; |
@@ -504,60 +506,60 @@ adjust_running_peers(unsigned int target) | |||
504 | unsigned int i; | 506 | unsigned int i; |
505 | unsigned int r; | 507 | unsigned int r; |
506 | 508 | ||
507 | GNUNET_assert(target <= peers_total); | 509 | GNUNET_assert (target <= peers_total); |
508 | 510 | ||
509 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "adjust peers to %u\n", target); | 511 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "adjust peers to %u\n", target); |
510 | if (target > peers_running) | 512 | if (target > peers_running) |
513 | { | ||
514 | delta = target - peers_running; | ||
515 | run = GNUNET_YES; | ||
516 | } | ||
517 | else | ||
518 | { | ||
519 | delta = peers_running - target; | ||
520 | run = GNUNET_NO; | ||
521 | } | ||
522 | |||
523 | for (i = 0; i < delta; i++) | ||
524 | { | ||
525 | do | ||
511 | { | 526 | { |
512 | delta = target - peers_running; | 527 | r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
513 | run = GNUNET_YES; | 528 | peers_total - peers_pinging); |
529 | r += peers_pinging; | ||
514 | } | 530 | } |
515 | else | 531 | while (peers[r].up == run || NULL != peers[r].incoming); |
532 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "St%s peer %u: %s\n", | ||
533 | run ? "arting" : "opping", r, GNUNET_i2s (&peers[r].id)); | ||
534 | |||
535 | if (NULL != peers[r].ping_task) | ||
536 | { | ||
537 | GNUNET_SCHEDULER_cancel (peers[r].ping_task); | ||
538 | peers[r].ping_task = NULL; | ||
539 | } | ||
540 | if (NULL != peers[r].ping_ntr) | ||
516 | { | 541 | { |
517 | delta = peers_running - target; | 542 | GNUNET_CADET_notify_transmit_ready_cancel (peers[r].ping_ntr); |
518 | run = GNUNET_NO; | 543 | peers[r].ping_ntr = NULL; |
519 | } | 544 | } |
545 | peers[r].up = run; | ||
520 | 546 | ||
521 | for (i = 0; i < delta; i++) | 547 | if (NULL != peers[r].ch) |
548 | GNUNET_CADET_channel_destroy (peers[r].ch); | ||
549 | peers[r].ch = NULL; | ||
550 | if (NULL != peers[r].dest) | ||
522 | { | 551 | { |
523 | do | 552 | if (NULL != peers[r].dest->incoming_ch) |
524 | { | 553 | GNUNET_CADET_channel_destroy (peers[r].dest->incoming_ch); |
525 | r = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, | 554 | peers[r].dest->incoming_ch = NULL; |
526 | peers_total - peers_pinging); | ||
527 | r += peers_pinging; | ||
528 | } | ||
529 | while (peers[r].up == run || NULL != peers[r].incoming); | ||
530 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "St%s peer %u: %s\n", | ||
531 | run ? "arting" : "opping", r, GNUNET_i2s(&peers[r].id)); | ||
532 | |||
533 | if (NULL != peers[r].ping_task) | ||
534 | { | ||
535 | GNUNET_SCHEDULER_cancel(peers[r].ping_task); | ||
536 | peers[r].ping_task = NULL; | ||
537 | } | ||
538 | if (NULL != peers[r].ping_ntr) | ||
539 | { | ||
540 | GNUNET_CADET_notify_transmit_ready_cancel(peers[r].ping_ntr); | ||
541 | peers[r].ping_ntr = NULL; | ||
542 | } | ||
543 | peers[r].up = run; | ||
544 | |||
545 | if (NULL != peers[r].ch) | ||
546 | GNUNET_CADET_channel_destroy(peers[r].ch); | ||
547 | peers[r].ch = NULL; | ||
548 | if (NULL != peers[r].dest) | ||
549 | { | ||
550 | if (NULL != peers[r].dest->incoming_ch) | ||
551 | GNUNET_CADET_channel_destroy(peers[r].dest->incoming_ch); | ||
552 | peers[r].dest->incoming_ch = NULL; | ||
553 | } | ||
554 | |||
555 | op = GNUNET_TESTBED_peer_manage_service(&peers[r], testbed_handles[r], | ||
556 | "cadet", NULL, NULL, run); | ||
557 | GNUNET_break(NULL != op); | ||
558 | peers_running += run ? 1 : -1; | ||
559 | GNUNET_assert(peers_running > 0); | ||
560 | } | 555 | } |
556 | |||
557 | op = GNUNET_TESTBED_peer_manage_service (&peers[r], testbed_handles[r], | ||
558 | "cadet", NULL, NULL, run); | ||
559 | GNUNET_break (NULL != op); | ||
560 | peers_running += run ? 1 : -1; | ||
561 | GNUNET_assert (peers_running > 0); | ||
562 | } | ||
561 | } | 563 | } |
562 | 564 | ||
563 | 565 | ||
@@ -567,23 +569,23 @@ adjust_running_peers(unsigned int target) | |||
567 | * @param cls Closure (round #). | 569 | * @param cls Closure (round #). |
568 | */ | 570 | */ |
569 | static void | 571 | static void |
570 | next_rnd(void *cls) | 572 | next_rnd (void *cls) |
571 | { | 573 | { |
572 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 574 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
573 | "ROUND %u\n", | 575 | "ROUND %u\n", |
574 | current_round); | 576 | current_round); |
575 | if (0.0 == rounds[current_round]) | 577 | if (0.0 == rounds[current_round]) |
576 | { | 578 | { |
577 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Finishing\n"); | 579 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Finishing\n"); |
578 | GNUNET_SCHEDULER_add_now(&finish_profiler, NULL); | 580 | GNUNET_SCHEDULER_add_now (&finish_profiler, NULL); |
579 | return; | 581 | return; |
580 | } | 582 | } |
581 | adjust_running_peers(rounds[current_round] * peers_total); | 583 | adjust_running_peers (rounds[current_round] * peers_total); |
582 | current_round++; | 584 | current_round++; |
583 | 585 | ||
584 | round_task = GNUNET_SCHEDULER_add_delayed(round_time, | 586 | round_task = GNUNET_SCHEDULER_add_delayed (round_time, |
585 | &next_rnd, | 587 | &next_rnd, |
586 | NULL); | 588 | NULL); |
587 | } | 589 | } |
588 | 590 | ||
589 | 591 | ||
@@ -597,7 +599,7 @@ next_rnd(void *cls) | |||
597 | * @return Number of bytes written to buf. | 599 | * @return Number of bytes written to buf. |
598 | */ | 600 | */ |
599 | static size_t | 601 | static size_t |
600 | tmt_rdy_ping(void *cls, size_t size, void *buf); | 602 | tmt_rdy_ping (void *cls, size_t size, void *buf); |
601 | 603 | ||
602 | 604 | ||
603 | /** | 605 | /** |
@@ -608,21 +610,21 @@ tmt_rdy_ping(void *cls, size_t size, void *buf); | |||
608 | * @param buf Buffer to copy data to. | 610 | * @param buf Buffer to copy data to. |
609 | */ | 611 | */ |
610 | static size_t | 612 | static size_t |
611 | tmt_rdy_pong(void *cls, size_t size, void *buf) | 613 | tmt_rdy_pong (void *cls, size_t size, void *buf) |
612 | { | 614 | { |
613 | struct CadetPingMessage *ping = cls; | 615 | struct CadetPingMessage *ping = cls; |
614 | struct CadetPingMessage *pong; | 616 | struct CadetPingMessage *pong; |
615 | 617 | ||
616 | if (0 == size || NULL == buf) | 618 | if ((0 == size)||(NULL == buf)) |
617 | { | 619 | { |
618 | GNUNET_free(ping); | 620 | GNUNET_free (ping); |
619 | return 0; | 621 | return 0; |
620 | } | 622 | } |
621 | pong = (struct CadetPingMessage *)buf; | 623 | pong = (struct CadetPingMessage *) buf; |
622 | GNUNET_memcpy(pong, ping, sizeof(*ping)); | 624 | GNUNET_memcpy (pong, ping, sizeof(*ping)); |
623 | pong->header.type = htons(PONG); | 625 | pong->header.type = htons (PONG); |
624 | 626 | ||
625 | GNUNET_free(ping); | 627 | GNUNET_free (ping); |
626 | return sizeof(*ping); | 628 | return sizeof(*ping); |
627 | } | 629 | } |
628 | 630 | ||
@@ -633,22 +635,23 @@ tmt_rdy_pong(void *cls, size_t size, void *buf) | |||
633 | * @param cls Closure (peer). | 635 | * @param cls Closure (peer). |
634 | */ | 636 | */ |
635 | static void | 637 | static void |
636 | ping(void *cls) | 638 | ping (void *cls) |
637 | { | 639 | { |
638 | struct CadetPeer *peer = cls; | 640 | struct CadetPeer *peer = cls; |
639 | 641 | ||
640 | peer->ping_task = NULL; | 642 | peer->ping_task = NULL; |
641 | if (GNUNET_YES == test_finished) | 643 | if (GNUNET_YES == test_finished) |
642 | return; | 644 | return; |
643 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 645 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
644 | "%u -> %u (%u)\n", | 646 | "%u -> %u (%u)\n", |
645 | get_index(peer), | 647 | get_index (peer), |
646 | get_index(peer->dest), | 648 | get_index (peer->dest), |
647 | peer->data_sent); | 649 | peer->data_sent); |
648 | peer->ping_ntr = GNUNET_CADET_notify_transmit_ready(peer->ch, GNUNET_NO, | 650 | peer->ping_ntr = GNUNET_CADET_notify_transmit_ready (peer->ch, GNUNET_NO, |
649 | GNUNET_TIME_UNIT_FOREVER_REL, | 651 | GNUNET_TIME_UNIT_FOREVER_REL, |
650 | sizeof(struct CadetPingMessage), | 652 | sizeof(struct |
651 | &tmt_rdy_ping, peer); | 653 | CadetPingMessage), |
654 | &tmt_rdy_ping, peer); | ||
652 | } | 655 | } |
653 | 656 | ||
654 | /** | 657 | /** |
@@ -658,17 +661,17 @@ ping(void *cls) | |||
658 | * @param tc Task context. | 661 | * @param tc Task context. |
659 | */ | 662 | */ |
660 | static void | 663 | static void |
661 | pong(struct GNUNET_CADET_Channel *channel, | 664 | pong (struct GNUNET_CADET_Channel *channel, |
662 | const struct CadetPingMessage *ping) | 665 | const struct CadetPingMessage *ping) |
663 | { | 666 | { |
664 | struct CadetPingMessage *copy; | 667 | struct CadetPingMessage *copy; |
665 | 668 | ||
666 | copy = GNUNET_new(struct CadetPingMessage); | 669 | copy = GNUNET_new (struct CadetPingMessage); |
667 | *copy = *ping; | 670 | *copy = *ping; |
668 | GNUNET_CADET_notify_transmit_ready(channel, GNUNET_NO, | 671 | GNUNET_CADET_notify_transmit_ready (channel, GNUNET_NO, |
669 | GNUNET_TIME_UNIT_FOREVER_REL, | 672 | GNUNET_TIME_UNIT_FOREVER_REL, |
670 | sizeof(struct CadetPingMessage), | 673 | sizeof(struct CadetPingMessage), |
671 | &tmt_rdy_pong, copy); | 674 | &tmt_rdy_pong, copy); |
672 | } | 675 | } |
673 | 676 | ||
674 | 677 | ||
@@ -680,37 +683,37 @@ pong(struct GNUNET_CADET_Channel *channel, | |||
680 | * @param buf Buffer to copy data to. | 683 | * @param buf Buffer to copy data to. |
681 | */ | 684 | */ |
682 | static size_t | 685 | static size_t |
683 | tmt_rdy_ping(void *cls, size_t size, void *buf) | 686 | tmt_rdy_ping (void *cls, size_t size, void *buf) |
684 | { | 687 | { |
685 | struct CadetPeer *peer = cls; | 688 | struct CadetPeer *peer = cls; |
686 | struct CadetPingMessage *msg = buf; | 689 | struct CadetPingMessage *msg = buf; |
687 | 690 | ||
688 | peer->ping_ntr = NULL; | 691 | peer->ping_ntr = NULL; |
689 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 692 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
690 | "tmt_rdy called, filling buffer\n"); | 693 | "tmt_rdy called, filling buffer\n"); |
691 | if (size < sizeof(struct CadetPingMessage) || NULL == buf) | 694 | if ((size < sizeof(struct CadetPingMessage))||(NULL == buf)) |
692 | { | 695 | { |
693 | GNUNET_break(GNUNET_YES == test_finished); | 696 | GNUNET_break (GNUNET_YES == test_finished); |
694 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 697 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
695 | "size %u, buf %p, data_sent %u, data_received %u\n", | 698 | "size %u, buf %p, data_sent %u, data_received %u\n", |
696 | (unsigned int)size, | 699 | (unsigned int) size, |
697 | buf, | 700 | buf, |
698 | peer->data_sent, | 701 | peer->data_sent, |
699 | peer->data_received); | 702 | peer->data_received); |
700 | 703 | ||
701 | return 0; | 704 | return 0; |
702 | } | 705 | } |
703 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 706 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
704 | "Sending: msg %d\n", | 707 | "Sending: msg %d\n", |
705 | peer->data_sent); | 708 | peer->data_sent); |
706 | msg->header.size = htons(size); | 709 | msg->header.size = htons (size); |
707 | msg->header.type = htons(PING); | 710 | msg->header.type = htons (PING); |
708 | msg->counter = htonl(peer->data_sent++); | 711 | msg->counter = htonl (peer->data_sent++); |
709 | msg->round_number = htonl(current_round); | 712 | msg->round_number = htonl (current_round); |
710 | msg->timestamp = GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get()); | 713 | msg->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ()); |
711 | peer->pings[current_round]++; | 714 | peer->pings[current_round]++; |
712 | peer->ping_task = GNUNET_SCHEDULER_add_delayed(delay_ms_rnd(PING_PERIOD), | 715 | peer->ping_task = GNUNET_SCHEDULER_add_delayed (delay_ms_rnd (PING_PERIOD), |
713 | &ping, peer); | 716 | &ping, peer); |
714 | 717 | ||
715 | return sizeof(struct CadetPingMessage); | 718 | return sizeof(struct CadetPingMessage); |
716 | } | 719 | } |
@@ -727,18 +730,18 @@ tmt_rdy_ping(void *cls, size_t size, void *buf) | |||
727 | * GNUNET_SYSERR to close it (signal serious error) | 730 | * GNUNET_SYSERR to close it (signal serious error) |
728 | */ | 731 | */ |
729 | int | 732 | int |
730 | ping_handler(void *cls, struct GNUNET_CADET_Channel *channel, | 733 | ping_handler (void *cls, struct GNUNET_CADET_Channel *channel, |
731 | void **channel_ctx, | 734 | void **channel_ctx, |
732 | const struct GNUNET_MessageHeader *message) | 735 | const struct GNUNET_MessageHeader *message) |
733 | { | 736 | { |
734 | long n = (long)cls; | 737 | long n = (long) cls; |
735 | 738 | ||
736 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 739 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
737 | "%u got PING\n", | 740 | "%u got PING\n", |
738 | (unsigned int)n); | 741 | (unsigned int) n); |
739 | GNUNET_CADET_receive_done(channel); | 742 | GNUNET_CADET_receive_done (channel); |
740 | if (GNUNET_NO == test_finished) | 743 | if (GNUNET_NO == test_finished) |
741 | pong(channel, (struct CadetPingMessage *)message); | 744 | pong (channel, (struct CadetPingMessage *) message); |
742 | 745 | ||
743 | return GNUNET_OK; | 746 | return GNUNET_OK; |
744 | } | 747 | } |
@@ -755,11 +758,11 @@ ping_handler(void *cls, struct GNUNET_CADET_Channel *channel, | |||
755 | * GNUNET_SYSERR to close it (signal serious error) | 758 | * GNUNET_SYSERR to close it (signal serious error) |
756 | */ | 759 | */ |
757 | int | 760 | int |
758 | pong_handler(void *cls, struct GNUNET_CADET_Channel *channel, | 761 | pong_handler (void *cls, struct GNUNET_CADET_Channel *channel, |
759 | void **channel_ctx, | 762 | void **channel_ctx, |
760 | const struct GNUNET_MessageHeader *message) | 763 | const struct GNUNET_MessageHeader *message) |
761 | { | 764 | { |
762 | long n = (long)cls; | 765 | long n = (long) cls; |
763 | struct CadetPeer *peer; | 766 | struct CadetPeer *peer; |
764 | struct CadetPingMessage *msg; | 767 | struct CadetPingMessage *msg; |
765 | struct GNUNET_TIME_Absolute send_time; | 768 | struct GNUNET_TIME_Absolute send_time; |
@@ -767,19 +770,19 @@ pong_handler(void *cls, struct GNUNET_CADET_Channel *channel, | |||
767 | unsigned int r /* Ping round */; | 770 | unsigned int r /* Ping round */; |
768 | float delta; | 771 | float delta; |
769 | 772 | ||
770 | GNUNET_CADET_receive_done(channel); | 773 | GNUNET_CADET_receive_done (channel); |
771 | peer = &peers[n]; | 774 | peer = &peers[n]; |
772 | 775 | ||
773 | msg = (struct CadetPingMessage *)message; | 776 | msg = (struct CadetPingMessage *) message; |
774 | 777 | ||
775 | send_time = GNUNET_TIME_absolute_ntoh(msg->timestamp); | 778 | send_time = GNUNET_TIME_absolute_ntoh (msg->timestamp); |
776 | latency = GNUNET_TIME_absolute_get_duration(send_time); | 779 | latency = GNUNET_TIME_absolute_get_duration (send_time); |
777 | r = ntohl(msg->round_number); | 780 | r = ntohl (msg->round_number); |
778 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "%u <- %u (%u) latency: %s\n", | 781 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%u <- %u (%u) latency: %s\n", |
779 | get_index(peer), | 782 | get_index (peer), |
780 | get_index(peer->dest), | 783 | get_index (peer->dest), |
781 | (uint32_t)ntohl(msg->counter), | 784 | (uint32_t) ntohl (msg->counter), |
782 | GNUNET_STRINGS_relative_time_to_string(latency, GNUNET_NO)); | 785 | GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_NO)); |
783 | 786 | ||
784 | /* Online variance calculation */ | 787 | /* Online variance calculation */ |
785 | peer->pongs[r]++; | 788 | peer->pongs[r]++; |
@@ -814,41 +817,41 @@ static struct GNUNET_CADET_MessageHandler handlers[] = { | |||
814 | * (can be NULL -- that's not an error). | 817 | * (can be NULL -- that's not an error). |
815 | */ | 818 | */ |
816 | static void * | 819 | static void * |
817 | incoming_channel(void *cls, struct GNUNET_CADET_Channel *channel, | 820 | incoming_channel (void *cls, struct GNUNET_CADET_Channel *channel, |
818 | const struct GNUNET_PeerIdentity *initiator, | 821 | const struct GNUNET_PeerIdentity *initiator, |
819 | const struct GNUNET_HashCode *port, | 822 | const struct GNUNET_HashCode *port, |
820 | enum GNUNET_CADET_ChannelOption options) | 823 | enum GNUNET_CADET_ChannelOption options) |
821 | { | 824 | { |
822 | long n = (long)cls; | 825 | long n = (long) cls; |
823 | struct CadetPeer *peer; | 826 | struct CadetPeer *peer; |
824 | 827 | ||
825 | peer = GNUNET_CONTAINER_multipeermap_get(ids, initiator); | 828 | peer = GNUNET_CONTAINER_multipeermap_get (ids, initiator); |
826 | GNUNET_assert(NULL != peer); | 829 | GNUNET_assert (NULL != peer); |
827 | if (NULL == peers[n].incoming) | 830 | if (NULL == peers[n].incoming) |
828 | { | 831 | { |
829 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 832 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
830 | "WARMUP %3u: %u <= %u\n", | 833 | "WARMUP %3u: %u <= %u\n", |
831 | peers_warmup, | 834 | peers_warmup, |
832 | (unsigned int)n, | 835 | (unsigned int) n, |
833 | get_index(peer)); | 836 | get_index (peer)); |
834 | peers_warmup++; | 837 | peers_warmup++; |
835 | if (peers_warmup < peers_total) | 838 | if (peers_warmup < peers_total) |
836 | return NULL; | ||
837 | if (NULL != test_task) | ||
838 | { | ||
839 | GNUNET_SCHEDULER_cancel(test_task); | ||
840 | test_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, | ||
841 | &start_test, NULL); | ||
842 | } | ||
843 | return NULL; | 839 | return NULL; |
840 | if (NULL != test_task) | ||
841 | { | ||
842 | GNUNET_SCHEDULER_cancel (test_task); | ||
843 | test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | ||
844 | &start_test, NULL); | ||
844 | } | 845 | } |
845 | GNUNET_assert(peer == peers[n].incoming); | 846 | return NULL; |
846 | GNUNET_assert(peer->dest == &peers[n]); | 847 | } |
847 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 848 | GNUNET_assert (peer == peers[n].incoming); |
848 | "%u <= %u %p\n", | 849 | GNUNET_assert (peer->dest == &peers[n]); |
849 | (unsigned int)n, | 850 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
850 | get_index(peer), | 851 | "%u <= %u %p\n", |
851 | channel); | 852 | (unsigned int) n, |
853 | get_index (peer), | ||
854 | channel); | ||
852 | peers[n].incoming_ch = channel; | 855 | peers[n].incoming_ch = channel; |
853 | 856 | ||
854 | return NULL; | 857 | return NULL; |
@@ -864,15 +867,15 @@ incoming_channel(void *cls, struct GNUNET_CADET_Channel *channel, | |||
864 | * with the channel is stored | 867 | * with the channel is stored |
865 | */ | 868 | */ |
866 | static void | 869 | static void |
867 | channel_cleaner(void *cls, | 870 | channel_cleaner (void *cls, |
868 | const struct GNUNET_CADET_Channel *channel, | 871 | const struct GNUNET_CADET_Channel *channel, |
869 | void *channel_ctx) | 872 | void *channel_ctx) |
870 | { | 873 | { |
871 | long n = (long)cls; | 874 | long n = (long) cls; |
872 | struct CadetPeer *peer = &peers[n]; | 875 | struct CadetPeer *peer = &peers[n]; |
873 | 876 | ||
874 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 877 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
875 | "Channel %p disconnected at peer %ld\n", channel, n); | 878 | "Channel %p disconnected at peer %ld\n", channel, n); |
876 | if (peer->ch == channel) | 879 | if (peer->ch == channel) |
877 | peer->ch = NULL; | 880 | peer->ch = NULL; |
878 | } | 881 | } |
@@ -886,14 +889,14 @@ channel_cleaner(void *cls, | |||
886 | * @return Random peer not yet connected to. | 889 | * @return Random peer not yet connected to. |
887 | */ | 890 | */ |
888 | static struct CadetPeer * | 891 | static struct CadetPeer * |
889 | select_random_peer(struct CadetPeer *peer) | 892 | select_random_peer (struct CadetPeer *peer) |
890 | { | 893 | { |
891 | unsigned int r; | 894 | unsigned int r; |
892 | 895 | ||
893 | do | 896 | do |
894 | { | 897 | { |
895 | r = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, peers_total); | 898 | r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, peers_total); |
896 | } | 899 | } |
897 | while (NULL != peers[r].incoming); | 900 | while (NULL != peers[r].incoming); |
898 | peers[r].incoming = peer; | 901 | peers[r].incoming = peer; |
899 | 902 | ||
@@ -909,45 +912,46 @@ select_random_peer(struct CadetPeer *peer) | |||
909 | * @param cls Closure (unsued). | 912 | * @param cls Closure (unsued). |
910 | */ | 913 | */ |
911 | static void | 914 | static void |
912 | start_test(void *cls) | 915 | start_test (void *cls) |
913 | { | 916 | { |
914 | unsigned long i; | 917 | unsigned long i; |
915 | 918 | ||
916 | test_task = NULL; | 919 | test_task = NULL; |
917 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Start profiler\n"); | 920 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start profiler\n"); |
918 | 921 | ||
919 | 922 | ||
920 | for (i = 0; i < peers_pinging; i++) | 923 | for (i = 0; i < peers_pinging; i++) |
924 | { | ||
925 | peers[i].dest = select_random_peer (&peers[i]); | ||
926 | peers[i].ch = GNUNET_CADET_channel_create (peers[i].cadet, NULL, | ||
927 | &peers[i].dest->id, | ||
928 | GC_u2h (1)); | ||
929 | if (NULL == peers[i].ch) | ||
921 | { | 930 | { |
922 | peers[i].dest = select_random_peer(&peers[i]); | 931 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Channel %lu failed\n", i); |
923 | peers[i].ch = GNUNET_CADET_channel_create(peers[i].cadet, NULL, | 932 | GNUNET_CADET_TEST_cleanup (test_ctx); |
924 | &peers[i].dest->id, | 933 | return; |
925 | GC_u2h(1)); | ||
926 | if (NULL == peers[i].ch) | ||
927 | { | ||
928 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Channel %lu failed\n", i); | ||
929 | GNUNET_CADET_TEST_cleanup(test_ctx); | ||
930 | return; | ||
931 | } | ||
932 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
933 | "%lu => %u %p\n", | ||
934 | i, | ||
935 | get_index(peers[i].dest), | ||
936 | peers[i].ch); | ||
937 | peers[i].ping_task = GNUNET_SCHEDULER_add_delayed(delay_ms_rnd(2000), | ||
938 | &ping, &peers[i]); | ||
939 | } | 934 | } |
935 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
936 | "%lu => %u %p\n", | ||
937 | i, | ||
938 | get_index (peers[i].dest), | ||
939 | peers[i].ch); | ||
940 | peers[i].ping_task = GNUNET_SCHEDULER_add_delayed (delay_ms_rnd (2000), | ||
941 | &ping, &peers[i]); | ||
942 | } | ||
940 | peers_running = peers_total; | 943 | peers_running = peers_total; |
941 | if (NULL != disconnect_task) | 944 | if (NULL != disconnect_task) |
942 | GNUNET_SCHEDULER_cancel(disconnect_task); | 945 | GNUNET_SCHEDULER_cancel (disconnect_task); |
943 | disconnect_task = | 946 | disconnect_task = |
944 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(round_time, | 947 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (round_time, |
945 | number_rounds + 1), | 948 | number_rounds |
946 | &disconnect_cadet_peers, | 949 | + 1), |
947 | (void *)__LINE__); | 950 | &disconnect_cadet_peers, |
948 | round_task = GNUNET_SCHEDULER_add_delayed(round_time, | 951 | (void *) __LINE__); |
949 | &next_rnd, | 952 | round_task = GNUNET_SCHEDULER_add_delayed (round_time, |
950 | NULL); | 953 | &next_rnd, |
954 | NULL); | ||
951 | } | 955 | } |
952 | 956 | ||
953 | 957 | ||
@@ -955,26 +959,26 @@ start_test(void *cls) | |||
955 | * Do warmup: create some channels to spread information about the topology. | 959 | * Do warmup: create some channels to spread information about the topology. |
956 | */ | 960 | */ |
957 | static void | 961 | static void |
958 | warmup(void) | 962 | warmup (void) |
959 | { | 963 | { |
960 | struct CadetPeer *peer; | 964 | struct CadetPeer *peer; |
961 | unsigned int i; | 965 | unsigned int i; |
962 | 966 | ||
963 | for (i = 0; i < peers_total; i++) | 967 | for (i = 0; i < peers_total; i++) |
968 | { | ||
969 | peer = select_random_peer (NULL); | ||
970 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "WARMUP %u => %u\n", | ||
971 | i, get_index (peer)); | ||
972 | peers[i].warmup_ch = | ||
973 | GNUNET_CADET_channel_create (peers[i].cadet, NULL, &peer->id, | ||
974 | GC_u2h (1)); | ||
975 | if (NULL == peers[i].warmup_ch) | ||
964 | { | 976 | { |
965 | peer = select_random_peer(NULL); | 977 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Warmup %u failed\n", i); |
966 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "WARMUP %u => %u\n", | 978 | GNUNET_CADET_TEST_cleanup (test_ctx); |
967 | i, get_index(peer)); | 979 | return; |
968 | peers[i].warmup_ch = | ||
969 | GNUNET_CADET_channel_create(peers[i].cadet, NULL, &peer->id, | ||
970 | GC_u2h(1)); | ||
971 | if (NULL == peers[i].warmup_ch) | ||
972 | { | ||
973 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Warmup %u failed\n", i); | ||
974 | GNUNET_CADET_TEST_cleanup(test_ctx); | ||
975 | return; | ||
976 | } | ||
977 | } | 980 | } |
981 | } | ||
978 | } | 982 | } |
979 | 983 | ||
980 | 984 | ||
@@ -988,48 +992,48 @@ warmup(void) | |||
988 | * NULL if the operation is successfull | 992 | * NULL if the operation is successfull |
989 | */ | 993 | */ |
990 | static void | 994 | static void |
991 | peer_id_cb(void *cls, | 995 | peer_id_cb (void *cls, |
992 | struct GNUNET_TESTBED_Operation *op, | 996 | struct GNUNET_TESTBED_Operation *op, |
993 | const struct GNUNET_TESTBED_PeerInformation *pinfo, | 997 | const struct GNUNET_TESTBED_PeerInformation *pinfo, |
994 | const char *emsg) | 998 | const char *emsg) |
995 | { | 999 | { |
996 | long n = (long)cls; | 1000 | long n = (long) cls; |
997 | 1001 | ||
998 | if (NULL == pinfo || NULL != emsg) | 1002 | if ((NULL == pinfo)||(NULL != emsg)) |
999 | { | 1003 | { |
1000 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg); | 1004 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg); |
1001 | abort_test(__LINE__); | 1005 | abort_test (__LINE__); |
1002 | return; | 1006 | return; |
1003 | } | 1007 | } |
1004 | peers[n].id = *(pinfo->result.id); | 1008 | peers[n].id = *(pinfo->result.id); |
1005 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1009 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1006 | "%ld id: %s\n", | 1010 | "%ld id: %s\n", |
1007 | n, | 1011 | n, |
1008 | GNUNET_i2s(&peers[n].id)); | 1012 | GNUNET_i2s (&peers[n].id)); |
1009 | GNUNET_break(GNUNET_OK == | 1013 | GNUNET_break (GNUNET_OK == |
1010 | GNUNET_CONTAINER_multipeermap_put(ids, &peers[n].id, &peers[n], | 1014 | GNUNET_CONTAINER_multipeermap_put (ids, &peers[n].id, &peers[n], |
1011 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); | 1015 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); |
1012 | 1016 | ||
1013 | GNUNET_TESTBED_operation_done(peers[n].op); | 1017 | GNUNET_TESTBED_operation_done (peers[n].op); |
1014 | peers[n].op = NULL; | 1018 | peers[n].op = NULL; |
1015 | 1019 | ||
1016 | p_ids++; | 1020 | p_ids++; |
1017 | if (p_ids < peers_total) | 1021 | if (p_ids < peers_total) |
1018 | return; | 1022 | return; |
1019 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Got all IDs, starting profiler\n"); | 1023 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got all IDs, starting profiler\n"); |
1020 | if (do_warmup) | 1024 | if (do_warmup) |
1021 | { | 1025 | { |
1022 | struct GNUNET_TIME_Relative delay; | 1026 | struct GNUNET_TIME_Relative delay; |
1023 | 1027 | ||
1024 | warmup(); | 1028 | warmup (); |
1025 | delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, | 1029 | delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, |
1026 | 100 * peers_total); | 1030 | 100 * peers_total); |
1027 | test_task = GNUNET_SCHEDULER_add_delayed(delay, &start_test, NULL); | 1031 | test_task = GNUNET_SCHEDULER_add_delayed (delay, &start_test, NULL); |
1028 | return; /* start_test from incoming_channel */ | 1032 | return; /* start_test from incoming_channel */ |
1029 | } | 1033 | } |
1030 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Starting in a second...\n"); | 1034 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting in a second...\n"); |
1031 | test_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, | 1035 | test_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, |
1032 | &start_test, NULL); | 1036 | &start_test, NULL); |
1033 | } | 1037 | } |
1034 | 1038 | ||
1035 | 1039 | ||
@@ -1043,37 +1047,37 @@ peer_id_cb(void *cls, | |||
1043 | * @param cadetes Handle to each of the CADETs of the peers. | 1047 | * @param cadetes Handle to each of the CADETs of the peers. |
1044 | */ | 1048 | */ |
1045 | static void | 1049 | static void |
1046 | tmain(void *cls, | 1050 | tmain (void *cls, |
1047 | struct GNUNET_CADET_TEST_Context *ctx, | 1051 | struct GNUNET_CADET_TEST_Context *ctx, |
1048 | unsigned int num_peers, | 1052 | unsigned int num_peers, |
1049 | struct GNUNET_TESTBED_Peer **testbed_peers, | 1053 | struct GNUNET_TESTBED_Peer **testbed_peers, |
1050 | struct GNUNET_CADET_Handle **cadetes) | 1054 | struct GNUNET_CADET_Handle **cadetes) |
1051 | { | 1055 | { |
1052 | unsigned long i; | 1056 | unsigned long i; |
1053 | 1057 | ||
1054 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1058 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1055 | "test main\n"); | 1059 | "test main\n"); |
1056 | test_ctx = ctx; | 1060 | test_ctx = ctx; |
1057 | GNUNET_assert(peers_total == num_peers); | 1061 | GNUNET_assert (peers_total == num_peers); |
1058 | peers_running = num_peers; | 1062 | peers_running = num_peers; |
1059 | testbed_handles = testbed_peers; | 1063 | testbed_handles = testbed_peers; |
1060 | disconnect_task = GNUNET_SCHEDULER_add_delayed(SHORT_TIME, | 1064 | disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME, |
1061 | &disconnect_cadet_peers, | 1065 | &disconnect_cadet_peers, |
1062 | (void *)__LINE__); | 1066 | (void *) __LINE__); |
1063 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); | 1067 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); |
1064 | for (i = 0; i < peers_total; i++) | 1068 | for (i = 0; i < peers_total; i++) |
1065 | { | 1069 | { |
1066 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1070 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1067 | "requesting id %ld\n", | 1071 | "requesting id %ld\n", |
1068 | i); | 1072 | i); |
1069 | peers[i].up = GNUNET_YES; | 1073 | peers[i].up = GNUNET_YES; |
1070 | peers[i].cadet = cadetes[i]; | 1074 | peers[i].cadet = cadetes[i]; |
1071 | peers[i].op = | 1075 | peers[i].op = |
1072 | GNUNET_TESTBED_peer_get_information(testbed_handles[i], | 1076 | GNUNET_TESTBED_peer_get_information (testbed_handles[i], |
1073 | GNUNET_TESTBED_PIT_IDENTITY, | 1077 | GNUNET_TESTBED_PIT_IDENTITY, |
1074 | &peer_id_cb, (void *)i); | 1078 | &peer_id_cb, (void *) i); |
1075 | } | 1079 | } |
1076 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "requested peer ids\n"); | 1080 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "requested peer ids\n"); |
1077 | /* Continues from pi_cb -> do_test */ | 1081 | /* Continues from pi_cb -> do_test */ |
1078 | } | 1082 | } |
1079 | 1083 | ||
@@ -1082,7 +1086,7 @@ tmain(void *cls, | |||
1082 | * Main: start profiler. | 1086 | * Main: start profiler. |
1083 | */ | 1087 | */ |
1084 | int | 1088 | int |
1085 | main(int argc, char *argv[]) | 1089 | main (int argc, char *argv[]) |
1086 | { | 1090 | { |
1087 | static const struct GNUNET_HashCode *ports[2]; | 1091 | static const struct GNUNET_HashCode *ports[2]; |
1088 | const char *config_file; | 1092 | const char *config_file; |
@@ -1090,59 +1094,59 @@ main(int argc, char *argv[]) | |||
1090 | config_file = ".profiler.conf"; | 1094 | config_file = ".profiler.conf"; |
1091 | 1095 | ||
1092 | if (4 > argc) | 1096 | if (4 > argc) |
1093 | { | 1097 | { |
1094 | fprintf(stderr, | 1098 | fprintf (stderr, |
1095 | "usage: %s ROUND_TIME PEERS PINGS [DO_WARMUP]\n", | 1099 | "usage: %s ROUND_TIME PEERS PINGS [DO_WARMUP]\n", |
1096 | argv[0]); | 1100 | argv[0]); |
1097 | fprintf(stderr, | 1101 | fprintf (stderr, |
1098 | "example: %s 30s 16 1 Y\n", | 1102 | "example: %s 30s 16 1 Y\n", |
1099 | argv[0]); | 1103 | argv[0]); |
1100 | return 1; | 1104 | return 1; |
1101 | } | 1105 | } |
1102 | 1106 | ||
1103 | if (GNUNET_OK != | 1107 | if (GNUNET_OK != |
1104 | GNUNET_STRINGS_fancy_time_to_relative(argv[1], | 1108 | GNUNET_STRINGS_fancy_time_to_relative (argv[1], |
1105 | &round_time)) | 1109 | &round_time)) |
1106 | { | 1110 | { |
1107 | fprintf(stderr, | 1111 | fprintf (stderr, |
1108 | "%s is not a valid time\n", | 1112 | "%s is not a valid time\n", |
1109 | argv[1]); | 1113 | argv[1]); |
1110 | return 1; | 1114 | return 1; |
1111 | } | 1115 | } |
1112 | 1116 | ||
1113 | peers_total = atoll(argv[2]); | 1117 | peers_total = atoll (argv[2]); |
1114 | if (2 > peers_total) | 1118 | if (2 > peers_total) |
1115 | { | 1119 | { |
1116 | fprintf(stderr, | 1120 | fprintf (stderr, |
1117 | "%s peers is not valid (> 2)\n", | 1121 | "%s peers is not valid (> 2)\n", |
1118 | argv[1]); | 1122 | argv[1]); |
1119 | return 1; | 1123 | return 1; |
1120 | } | 1124 | } |
1121 | peers = GNUNET_new_array(peers_total, | 1125 | peers = GNUNET_new_array (peers_total, |
1122 | struct CadetPeer); | 1126 | struct CadetPeer); |
1123 | peers_pinging = atoll(argv[3]); | 1127 | peers_pinging = atoll (argv[3]); |
1124 | 1128 | ||
1125 | if (peers_total < 2 * peers_pinging) | 1129 | if (peers_total < 2 * peers_pinging) |
1126 | { | 1130 | { |
1127 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1131 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1128 | "not enough peers, total should be > 2 * peers_pinging\n"); | 1132 | "not enough peers, total should be > 2 * peers_pinging\n"); |
1129 | return 1; | 1133 | return 1; |
1130 | } | 1134 | } |
1131 | 1135 | ||
1132 | do_warmup = (5 > argc || argv[4][0] != 'N'); | 1136 | do_warmup = (5 > argc || argv[4][0] != 'N'); |
1133 | 1137 | ||
1134 | ids = GNUNET_CONTAINER_multipeermap_create(2 * peers_total, | 1138 | ids = GNUNET_CONTAINER_multipeermap_create (2 * peers_total, |
1135 | GNUNET_YES); | 1139 | GNUNET_YES); |
1136 | GNUNET_assert(NULL != ids); | 1140 | GNUNET_assert (NULL != ids); |
1137 | p_ids = 0; | 1141 | p_ids = 0; |
1138 | test_finished = GNUNET_NO; | 1142 | test_finished = GNUNET_NO; |
1139 | ports[0] = GC_u2h(1); | 1143 | ports[0] = GC_u2h (1); |
1140 | ports[1] = 0; | 1144 | ports[1] = 0; |
1141 | GNUNET_CADET_TEST_run("cadet-profiler", config_file, peers_total, | 1145 | GNUNET_CADET_TEST_run ("cadet-profiler", config_file, peers_total, |
1142 | &tmain, NULL, /* tmain cls */ | 1146 | &tmain, NULL, /* tmain cls */ |
1143 | &incoming_channel, &channel_cleaner, | 1147 | &incoming_channel, &channel_cleaner, |
1144 | handlers, ports); | 1148 | handlers, ports); |
1145 | GNUNET_free(peers); | 1149 | GNUNET_free (peers); |
1146 | 1150 | ||
1147 | return 0; | 1151 | return 0; |
1148 | } | 1152 | } |
diff --git a/src/cadet/gnunet-cadet.c b/src/cadet/gnunet-cadet.c index f5cf86211..d85a3c6ba 100644 --- a/src/cadet/gnunet-cadet.c +++ b/src/cadet/gnunet-cadet.c | |||
@@ -143,7 +143,7 @@ static unsigned int sent_pkt; | |||
143 | * Wait for input on STDIO and send it out over the #ch. | 143 | * Wait for input on STDIO and send it out over the #ch. |
144 | */ | 144 | */ |
145 | static void | 145 | static void |
146 | listen_stdio(void); | 146 | listen_stdio (void); |
147 | 147 | ||
148 | 148 | ||
149 | /** | 149 | /** |
@@ -154,25 +154,25 @@ listen_stdio(void); | |||
154 | * @return Human readable string. | 154 | * @return Human readable string. |
155 | */ | 155 | */ |
156 | static const char * | 156 | static const char * |
157 | enc_2s(uint16_t status) | 157 | enc_2s (uint16_t status) |
158 | { | 158 | { |
159 | switch (status) | 159 | switch (status) |
160 | { | 160 | { |
161 | case 0: | 161 | case 0: |
162 | return "NULL "; | 162 | return "NULL "; |
163 | 163 | ||
164 | case 1: | 164 | case 1: |
165 | return "KSENT"; | 165 | return "KSENT"; |
166 | 166 | ||
167 | case 2: | 167 | case 2: |
168 | return "KRECV"; | 168 | return "KRECV"; |
169 | 169 | ||
170 | case 3: | 170 | case 3: |
171 | return "READY"; | 171 | return "READY"; |
172 | 172 | ||
173 | default: | 173 | default: |
174 | return ""; | 174 | return ""; |
175 | } | 175 | } |
176 | } | 176 | } |
177 | 177 | ||
178 | 178 | ||
@@ -184,28 +184,28 @@ enc_2s(uint16_t status) | |||
184 | * @return Human readable string. | 184 | * @return Human readable string. |
185 | */ | 185 | */ |
186 | static const char * | 186 | static const char * |
187 | conn_2s(uint16_t status) | 187 | conn_2s (uint16_t status) |
188 | { | 188 | { |
189 | switch (status) | 189 | switch (status) |
190 | { | 190 | { |
191 | case 0: | 191 | case 0: |
192 | return "NEW "; | 192 | return "NEW "; |
193 | 193 | ||
194 | case 1: | 194 | case 1: |
195 | return "SRCH "; | 195 | return "SRCH "; |
196 | 196 | ||
197 | case 2: | 197 | case 2: |
198 | return "WAIT "; | 198 | return "WAIT "; |
199 | 199 | ||
200 | case 3: | 200 | case 3: |
201 | return "READY"; | 201 | return "READY"; |
202 | 202 | ||
203 | case 4: | 203 | case 4: |
204 | return "SHUTD"; | 204 | return "SHUTD"; |
205 | 205 | ||
206 | default: | 206 | default: |
207 | return ""; | 207 | return ""; |
208 | } | 208 | } |
209 | } | 209 | } |
210 | 210 | ||
211 | 211 | ||
@@ -215,60 +215,60 @@ conn_2s(uint16_t status) | |||
215 | * @param cls Closure (unused). | 215 | * @param cls Closure (unused). |
216 | */ | 216 | */ |
217 | static void | 217 | static void |
218 | shutdown_task(void *cls) | 218 | shutdown_task (void *cls) |
219 | { | 219 | { |
220 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n"); | 220 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n"); |
221 | if (NULL != lp) | 221 | if (NULL != lp) |
222 | { | 222 | { |
223 | GNUNET_CADET_close_port(lp); | 223 | GNUNET_CADET_close_port (lp); |
224 | lp = NULL; | 224 | lp = NULL; |
225 | } | 225 | } |
226 | if (NULL != ch) | 226 | if (NULL != ch) |
227 | { | 227 | { |
228 | GNUNET_CADET_channel_destroy(ch); | 228 | GNUNET_CADET_channel_destroy (ch); |
229 | ch = NULL; | 229 | ch = NULL; |
230 | } | 230 | } |
231 | if (NULL != gpo) | 231 | if (NULL != gpo) |
232 | { | 232 | { |
233 | GNUNET_CADET_get_path_cancel(gpo); | 233 | GNUNET_CADET_get_path_cancel (gpo); |
234 | gpo = NULL; | 234 | gpo = NULL; |
235 | } | 235 | } |
236 | if (NULL != plo) | 236 | if (NULL != plo) |
237 | { | 237 | { |
238 | GNUNET_CADET_list_peers_cancel(plo); | 238 | GNUNET_CADET_list_peers_cancel (plo); |
239 | plo = NULL; | 239 | plo = NULL; |
240 | } | 240 | } |
241 | if (NULL != tio) | 241 | if (NULL != tio) |
242 | { | 242 | { |
243 | GNUNET_CADET_list_tunnels_cancel(tio); | 243 | GNUNET_CADET_list_tunnels_cancel (tio); |
244 | tio = NULL; | 244 | tio = NULL; |
245 | } | 245 | } |
246 | if (NULL != mh) | 246 | if (NULL != mh) |
247 | { | 247 | { |
248 | GNUNET_CADET_disconnect(mh); | 248 | GNUNET_CADET_disconnect (mh); |
249 | mh = NULL; | 249 | mh = NULL; |
250 | } | 250 | } |
251 | if (NULL != rd_task) | 251 | if (NULL != rd_task) |
252 | { | 252 | { |
253 | GNUNET_SCHEDULER_cancel(rd_task); | 253 | GNUNET_SCHEDULER_cancel (rd_task); |
254 | rd_task = NULL; | 254 | rd_task = NULL; |
255 | } | 255 | } |
256 | if (NULL != echo_task) | 256 | if (NULL != echo_task) |
257 | { | 257 | { |
258 | GNUNET_SCHEDULER_cancel(echo_task); | 258 | GNUNET_SCHEDULER_cancel (echo_task); |
259 | echo_task = NULL; | 259 | echo_task = NULL; |
260 | } | 260 | } |
261 | if (NULL != job) | 261 | if (NULL != job) |
262 | { | 262 | { |
263 | GNUNET_SCHEDULER_cancel(job); | 263 | GNUNET_SCHEDULER_cancel (job); |
264 | job = NULL; | 264 | job = NULL; |
265 | } | 265 | } |
266 | } | 266 | } |
267 | 267 | ||
268 | void | 268 | void |
269 | mq_cb(void *cls) | 269 | mq_cb (void *cls) |
270 | { | 270 | { |
271 | listen_stdio(); | 271 | listen_stdio (); |
272 | } | 272 | } |
273 | 273 | ||
274 | 274 | ||
@@ -278,7 +278,7 @@ mq_cb(void *cls) | |||
278 | * @param cls Closure (unused). | 278 | * @param cls Closure (unused). |
279 | */ | 279 | */ |
280 | static void | 280 | static void |
281 | read_stdio(void *cls) | 281 | read_stdio (void *cls) |
282 | { | 282 | { |
283 | struct GNUNET_MQ_Envelope *env; | 283 | struct GNUNET_MQ_Envelope *env; |
284 | struct GNUNET_MessageHeader *msg; | 284 | struct GNUNET_MessageHeader *msg; |
@@ -286,41 +286,41 @@ read_stdio(void *cls) | |||
286 | ssize_t data_size; | 286 | ssize_t data_size; |
287 | 287 | ||
288 | rd_task = NULL; | 288 | rd_task = NULL; |
289 | data_size = read(0, buf, 60000); | 289 | data_size = read (0, buf, 60000); |
290 | if (data_size < 1) | 290 | if (data_size < 1) |
291 | { | 291 | { |
292 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 292 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
293 | "read() returned %s\n", | 293 | "read() returned %s\n", |
294 | strerror(errno)); | 294 | strerror (errno)); |
295 | GNUNET_SCHEDULER_shutdown(); | 295 | GNUNET_SCHEDULER_shutdown (); |
296 | return; | 296 | return; |
297 | } | 297 | } |
298 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 298 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
299 | "Read %u bytes from stdio\n", | 299 | "Read %u bytes from stdio\n", |
300 | (unsigned int)data_size); | 300 | (unsigned int) data_size); |
301 | env = GNUNET_MQ_msg_extra(msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI); | 301 | env = GNUNET_MQ_msg_extra (msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI); |
302 | GNUNET_memcpy(&msg[1], buf, data_size); | 302 | GNUNET_memcpy (&msg[1], buf, data_size); |
303 | GNUNET_MQ_send(GNUNET_CADET_get_mq(ch), env); | 303 | GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env); |
304 | 304 | ||
305 | sent_pkt++; | 305 | sent_pkt++; |
306 | 306 | ||
307 | if (GNUNET_NO == echo) | 307 | if (GNUNET_NO == echo) |
308 | { | ||
309 | // Use MQ's notification if too much data of stdin is pooring in too fast. | ||
310 | if (STREAM_BUFFER_SIZE < sent_pkt) | ||
308 | { | 311 | { |
309 | // Use MQ's notification if too much data of stdin is pooring in too fast. | 312 | GNUNET_MQ_notify_sent (env, mq_cb, cls); |
310 | if (STREAM_BUFFER_SIZE < sent_pkt) | 313 | sent_pkt = 0; |
311 | { | ||
312 | GNUNET_MQ_notify_sent(env, mq_cb, cls); | ||
313 | sent_pkt = 0; | ||
314 | } | ||
315 | else | ||
316 | { | ||
317 | listen_stdio(); | ||
318 | } | ||
319 | } | 314 | } |
320 | else | 315 | else |
321 | { | 316 | { |
322 | echo_time = GNUNET_TIME_absolute_get(); | 317 | listen_stdio (); |
323 | } | 318 | } |
319 | } | ||
320 | else | ||
321 | { | ||
322 | echo_time = GNUNET_TIME_absolute_get (); | ||
323 | } | ||
324 | } | 324 | } |
325 | 325 | ||
326 | 326 | ||
@@ -328,20 +328,20 @@ read_stdio(void *cls) | |||
328 | * Wait for input on STDIO and send it out over the #ch. | 328 | * Wait for input on STDIO and send it out over the #ch. |
329 | */ | 329 | */ |
330 | static void | 330 | static void |
331 | listen_stdio() | 331 | listen_stdio () |
332 | { | 332 | { |
333 | struct GNUNET_NETWORK_FDSet *rs; | 333 | struct GNUNET_NETWORK_FDSet *rs; |
334 | 334 | ||
335 | /* FIXME: why use 'rs' here, seems overly complicated... */ | 335 | /* FIXME: why use 'rs' here, seems overly complicated... */ |
336 | rs = GNUNET_NETWORK_fdset_create(); | 336 | rs = GNUNET_NETWORK_fdset_create (); |
337 | GNUNET_NETWORK_fdset_set_native(rs, 0); /* STDIN */ | 337 | GNUNET_NETWORK_fdset_set_native (rs, 0); /* STDIN */ |
338 | rd_task = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 338 | rd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
339 | GNUNET_TIME_UNIT_FOREVER_REL, | 339 | GNUNET_TIME_UNIT_FOREVER_REL, |
340 | rs, | 340 | rs, |
341 | NULL, | 341 | NULL, |
342 | &read_stdio, | 342 | &read_stdio, |
343 | NULL); | 343 | NULL); |
344 | GNUNET_NETWORK_fdset_destroy(rs); | 344 | GNUNET_NETWORK_fdset_destroy (rs); |
345 | } | 345 | } |
346 | 346 | ||
347 | 347 | ||
@@ -355,12 +355,12 @@ listen_stdio() | |||
355 | * @param channel connection to the other end (henceforth invalid) | 355 | * @param channel connection to the other end (henceforth invalid) |
356 | */ | 356 | */ |
357 | static void | 357 | static void |
358 | channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel) | 358 | channel_ended (void *cls, const struct GNUNET_CADET_Channel *channel) |
359 | { | 359 | { |
360 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n"); | 360 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n"); |
361 | GNUNET_assert(channel == ch); | 361 | GNUNET_assert (channel == ch); |
362 | ch = NULL; | 362 | ch = NULL; |
363 | GNUNET_SCHEDULER_shutdown(); | 363 | GNUNET_SCHEDULER_shutdown (); |
364 | } | 364 | } |
365 | 365 | ||
366 | 366 | ||
@@ -379,20 +379,20 @@ channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel) | |||
379 | * @return initial channel context for the channel, we use @a channel | 379 | * @return initial channel context for the channel, we use @a channel |
380 | */ | 380 | */ |
381 | static void * | 381 | static void * |
382 | channel_incoming(void *cls, | 382 | channel_incoming (void *cls, |
383 | struct GNUNET_CADET_Channel *channel, | 383 | struct GNUNET_CADET_Channel *channel, |
384 | const struct GNUNET_PeerIdentity *initiator) | 384 | const struct GNUNET_PeerIdentity *initiator) |
385 | { | 385 | { |
386 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 386 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
387 | "Incoming connection from %s\n", | 387 | "Incoming connection from %s\n", |
388 | GNUNET_i2s_full(initiator)); | 388 | GNUNET_i2s_full (initiator)); |
389 | GNUNET_assert(NULL == ch); | 389 | GNUNET_assert (NULL == ch); |
390 | GNUNET_assert(NULL != lp); | 390 | GNUNET_assert (NULL != lp); |
391 | GNUNET_CADET_close_port(lp); | 391 | GNUNET_CADET_close_port (lp); |
392 | lp = NULL; | 392 | lp = NULL; |
393 | ch = channel; | 393 | ch = channel; |
394 | if (GNUNET_NO == echo) | 394 | if (GNUNET_NO == echo) |
395 | listen_stdio(); | 395 | listen_stdio (); |
396 | return channel; | 396 | return channel; |
397 | } | 397 | } |
398 | 398 | ||
@@ -403,7 +403,7 @@ channel_incoming(void *cls, | |||
403 | * @param cls Closure (NULL). | 403 | * @param cls Closure (NULL). |
404 | */ | 404 | */ |
405 | static void | 405 | static void |
406 | send_echo(void *cls) | 406 | send_echo (void *cls) |
407 | { | 407 | { |
408 | struct GNUNET_MQ_Envelope *env; | 408 | struct GNUNET_MQ_Envelope *env; |
409 | struct GNUNET_MessageHeader *msg; | 409 | struct GNUNET_MessageHeader *msg; |
@@ -411,8 +411,8 @@ send_echo(void *cls) | |||
411 | echo_task = NULL; | 411 | echo_task = NULL; |
412 | if (NULL == ch) | 412 | if (NULL == ch) |
413 | return; | 413 | return; |
414 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_CLI); | 414 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_CLI); |
415 | GNUNET_MQ_send(GNUNET_CADET_get_mq(ch), env); | 415 | GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env); |
416 | } | 416 | } |
417 | 417 | ||
418 | 418 | ||
@@ -425,7 +425,7 @@ send_echo(void *cls) | |||
425 | * #GNUNET_SYSERR to close it (signal serious error). | 425 | * #GNUNET_SYSERR to close it (signal serious error). |
426 | */ | 426 | */ |
427 | static int | 427 | static int |
428 | check_data(void *cls, const struct GNUNET_MessageHeader *message) | 428 | check_data (void *cls, const struct GNUNET_MessageHeader *message) |
429 | { | 429 | { |
430 | return GNUNET_OK; /* all is well-formed */ | 430 | return GNUNET_OK; /* all is well-formed */ |
431 | } | 431 | } |
@@ -442,59 +442,59 @@ check_data(void *cls, const struct GNUNET_MessageHeader *message) | |||
442 | * @param message The actual message. | 442 | * @param message The actual message. |
443 | */ | 443 | */ |
444 | static void | 444 | static void |
445 | handle_data(void *cls, const struct GNUNET_MessageHeader *message) | 445 | handle_data (void *cls, const struct GNUNET_MessageHeader *message) |
446 | { | 446 | { |
447 | size_t payload_size = ntohs(message->size) - sizeof(*message); | 447 | size_t payload_size = ntohs (message->size) - sizeof(*message); |
448 | uint16_t len; | 448 | uint16_t len; |
449 | ssize_t done; | 449 | ssize_t done; |
450 | uint16_t off; | 450 | uint16_t off; |
451 | const char *buf; | 451 | const char *buf; |
452 | 452 | ||
453 | GNUNET_CADET_receive_done(ch); | 453 | GNUNET_CADET_receive_done (ch); |
454 | if (GNUNET_YES == echo) | 454 | if (GNUNET_YES == echo) |
455 | { | ||
456 | if (NULL != listen_port) | ||
455 | { | 457 | { |
456 | if (NULL != listen_port) | 458 | struct GNUNET_MQ_Envelope *env; |
457 | { | 459 | struct GNUNET_MessageHeader *msg; |
458 | struct GNUNET_MQ_Envelope *env; | 460 | |
459 | struct GNUNET_MessageHeader *msg; | 461 | env = |
460 | 462 | GNUNET_MQ_msg_extra (msg, payload_size, GNUNET_MESSAGE_TYPE_CADET_CLI); | |
461 | env = | 463 | GNUNET_memcpy (&msg[1], &message[1], payload_size); |
462 | GNUNET_MQ_msg_extra(msg, payload_size, GNUNET_MESSAGE_TYPE_CADET_CLI); | 464 | GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env); |
463 | GNUNET_memcpy(&msg[1], &message[1], payload_size); | 465 | return; |
464 | GNUNET_MQ_send(GNUNET_CADET_get_mq(ch), env); | ||
465 | return; | ||
466 | } | ||
467 | else | ||
468 | { | ||
469 | struct GNUNET_TIME_Relative latency; | ||
470 | |||
471 | latency = GNUNET_TIME_absolute_get_duration(echo_time); | ||
472 | echo_time = GNUNET_TIME_UNIT_FOREVER_ABS; | ||
473 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
474 | "time: %s\n", | ||
475 | GNUNET_STRINGS_relative_time_to_string(latency, GNUNET_NO)); | ||
476 | echo_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, | ||
477 | &send_echo, | ||
478 | NULL); | ||
479 | } | ||
480 | } | 466 | } |
467 | else | ||
468 | { | ||
469 | struct GNUNET_TIME_Relative latency; | ||
470 | |||
471 | latency = GNUNET_TIME_absolute_get_duration (echo_time); | ||
472 | echo_time = GNUNET_TIME_UNIT_FOREVER_ABS; | ||
473 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | ||
474 | "time: %s\n", | ||
475 | GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_NO)); | ||
476 | echo_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | ||
477 | &send_echo, | ||
478 | NULL); | ||
479 | } | ||
480 | } | ||
481 | 481 | ||
482 | len = ntohs(message->size) - sizeof(*message); | 482 | len = ntohs (message->size) - sizeof(*message); |
483 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len); | 483 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len); |
484 | buf = (const char *)&message[1]; | 484 | buf = (const char *) &message[1]; |
485 | off = 0; | 485 | off = 0; |
486 | while (off < len) | 486 | while (off < len) |
487 | { | ||
488 | done = write (1, &buf[off], len - off); | ||
489 | if (done <= 0) | ||
487 | { | 490 | { |
488 | done = write(1, &buf[off], len - off); | 491 | if (-1 == done) |
489 | if (done <= 0) | 492 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write"); |
490 | { | 493 | GNUNET_SCHEDULER_shutdown (); |
491 | if (-1 == done) | 494 | return; |
492 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "write"); | ||
493 | GNUNET_SCHEDULER_shutdown(); | ||
494 | return; | ||
495 | } | ||
496 | off += done; | ||
497 | } | 495 | } |
496 | off += done; | ||
497 | } | ||
498 | } | 498 | } |
499 | 499 | ||
500 | 500 | ||
@@ -508,19 +508,19 @@ handle_data(void *cls, const struct GNUNET_MessageHeader *message) | |||
508 | * @param ple information about peer, or NULL on "EOF". | 508 | * @param ple information about peer, or NULL on "EOF". |
509 | */ | 509 | */ |
510 | static void | 510 | static void |
511 | peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple) | 511 | peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple) |
512 | { | 512 | { |
513 | if (NULL == ple) | 513 | if (NULL == ple) |
514 | { | 514 | { |
515 | plo = NULL; | 515 | plo = NULL; |
516 | GNUNET_SCHEDULER_shutdown(); | 516 | GNUNET_SCHEDULER_shutdown (); |
517 | return; | 517 | return; |
518 | } | 518 | } |
519 | fprintf(stdout, | 519 | fprintf (stdout, |
520 | "%s tunnel: %c, paths: %u\n", | 520 | "%s tunnel: %c, paths: %u\n", |
521 | GNUNET_i2s_full(&ple->peer), | 521 | GNUNET_i2s_full (&ple->peer), |
522 | ple->have_tunnel ? 'Y' : 'N', | 522 | ple->have_tunnel ? 'Y' : 'N', |
523 | ple->n_paths); | 523 | ple->n_paths); |
524 | } | 524 | } |
525 | 525 | ||
526 | 526 | ||
@@ -532,20 +532,20 @@ peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple) | |||
532 | * @param ppd path detail | 532 | * @param ppd path detail |
533 | */ | 533 | */ |
534 | static void | 534 | static void |
535 | path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd) | 535 | path_callback (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd) |
536 | { | 536 | { |
537 | if (NULL == ppd) | 537 | if (NULL == ppd) |
538 | { | 538 | { |
539 | gpo = NULL; | 539 | gpo = NULL; |
540 | GNUNET_SCHEDULER_shutdown(); | 540 | GNUNET_SCHEDULER_shutdown (); |
541 | return; | 541 | return; |
542 | } | 542 | } |
543 | fprintf(stdout, "Path of length %u: ", ppd->path_length); | 543 | fprintf (stdout, "Path of length %u: ", ppd->path_length); |
544 | for (unsigned int i = 0; i < ppd->path_length; i++) | 544 | for (unsigned int i = 0; i < ppd->path_length; i++) |
545 | fprintf(stdout, | 545 | fprintf (stdout, |
546 | (i == ppd->target_offset) ? "*%s* " : "%s ", | 546 | (i == ppd->target_offset) ? "*%s* " : "%s ", |
547 | GNUNET_i2s(&ppd->path[i])); | 547 | GNUNET_i2s (&ppd->path[i])); |
548 | fprintf(stdout, "\n"); | 548 | fprintf (stdout, "\n"); |
549 | } | 549 | } |
550 | 550 | ||
551 | 551 | ||
@@ -556,21 +556,21 @@ path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd) | |||
556 | * @param td tunnel details | 556 | * @param td tunnel details |
557 | */ | 557 | */ |
558 | static void | 558 | static void |
559 | tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td) | 559 | tunnels_callback (void *cls, const struct GNUNET_CADET_TunnelDetails *td) |
560 | { | 560 | { |
561 | if (NULL == td) | 561 | if (NULL == td) |
562 | { | 562 | { |
563 | tio = NULL; | 563 | tio = NULL; |
564 | GNUNET_SCHEDULER_shutdown(); | 564 | GNUNET_SCHEDULER_shutdown (); |
565 | return; | 565 | return; |
566 | } | 566 | } |
567 | fprintf(stdout, | 567 | fprintf (stdout, |
568 | "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n", | 568 | "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n", |
569 | GNUNET_i2s_full(&td->peer), | 569 | GNUNET_i2s_full (&td->peer), |
570 | enc_2s(td->estate), | 570 | enc_2s (td->estate), |
571 | conn_2s(td->cstate), | 571 | conn_2s (td->cstate), |
572 | td->channels, | 572 | td->channels, |
573 | td->connections); | 573 | td->connections); |
574 | } | 574 | } |
575 | 575 | ||
576 | 576 | ||
@@ -580,10 +580,10 @@ tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td) | |||
580 | * @param cls Closure (unused). | 580 | * @param cls Closure (unused). |
581 | */ | 581 | */ |
582 | static void | 582 | static void |
583 | get_peers(void *cls) | 583 | get_peers (void *cls) |
584 | { | 584 | { |
585 | job = NULL; | 585 | job = NULL; |
586 | plo = GNUNET_CADET_list_peers(my_cfg, &peers_callback, NULL); | 586 | plo = GNUNET_CADET_list_peers (my_cfg, &peers_callback, NULL); |
587 | } | 587 | } |
588 | 588 | ||
589 | 589 | ||
@@ -593,20 +593,20 @@ get_peers(void *cls) | |||
593 | * @param cls Closure (unused). | 593 | * @param cls Closure (unused). |
594 | */ | 594 | */ |
595 | static void | 595 | static void |
596 | show_peer(void *cls) | 596 | show_peer (void *cls) |
597 | { | 597 | { |
598 | struct GNUNET_PeerIdentity pid; | 598 | struct GNUNET_PeerIdentity pid; |
599 | 599 | ||
600 | job = NULL; | 600 | job = NULL; |
601 | if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string(peer_id, | 601 | if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id, |
602 | strlen(peer_id), | 602 | strlen (peer_id), |
603 | &pid.public_key)) | 603 | &pid.public_key)) |
604 | { | 604 | { |
605 | fprintf(stderr, _("Invalid peer ID `%s'\n"), peer_id); | 605 | fprintf (stderr, _ ("Invalid peer ID `%s'\n"), peer_id); |
606 | GNUNET_SCHEDULER_shutdown(); | 606 | GNUNET_SCHEDULER_shutdown (); |
607 | return; | 607 | return; |
608 | } | 608 | } |
609 | gpo = GNUNET_CADET_get_path(my_cfg, &pid, &path_callback, NULL); | 609 | gpo = GNUNET_CADET_get_path (my_cfg, &pid, &path_callback, NULL); |
610 | } | 610 | } |
611 | 611 | ||
612 | 612 | ||
@@ -616,10 +616,10 @@ show_peer(void *cls) | |||
616 | * @param cls Closure (unused). | 616 | * @param cls Closure (unused). |
617 | */ | 617 | */ |
618 | static void | 618 | static void |
619 | get_tunnels(void *cls) | 619 | get_tunnels (void *cls) |
620 | { | 620 | { |
621 | job = NULL; | 621 | job = NULL; |
622 | tio = GNUNET_CADET_list_tunnels(my_cfg, &tunnels_callback, NULL); | 622 | tio = GNUNET_CADET_list_tunnels (my_cfg, &tunnels_callback, NULL); |
623 | } | 623 | } |
624 | 624 | ||
625 | 625 | ||
@@ -629,10 +629,10 @@ get_tunnels(void *cls) | |||
629 | * @param cls Closure (unused). | 629 | * @param cls Closure (unused). |
630 | */ | 630 | */ |
631 | static void | 631 | static void |
632 | show_channel(void *cls) | 632 | show_channel (void *cls) |
633 | { | 633 | { |
634 | job = NULL; | 634 | job = NULL; |
635 | GNUNET_break(0); | 635 | GNUNET_break (0); |
636 | } | 636 | } |
637 | 637 | ||
638 | 638 | ||
@@ -642,10 +642,10 @@ show_channel(void *cls) | |||
642 | * @param cls Closure (unused). | 642 | * @param cls Closure (unused). |
643 | */ | 643 | */ |
644 | static void | 644 | static void |
645 | show_connection(void *cls) | 645 | show_connection (void *cls) |
646 | { | 646 | { |
647 | job = NULL; | 647 | job = NULL; |
648 | GNUNET_break(0); | 648 | GNUNET_break (0); |
649 | } | 649 | } |
650 | 650 | ||
651 | 651 | ||
@@ -658,17 +658,17 @@ show_connection(void *cls) | |||
658 | * @param cfg configuration | 658 | * @param cfg configuration |
659 | */ | 659 | */ |
660 | static void | 660 | static void |
661 | run(void *cls, | 661 | run (void *cls, |
662 | char *const *args, | 662 | char *const *args, |
663 | const char *cfgfile, | 663 | const char *cfgfile, |
664 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 664 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
665 | { | 665 | { |
666 | struct GNUNET_MQ_MessageHandler handlers[] = | 666 | struct GNUNET_MQ_MessageHandler handlers[] = |
667 | { GNUNET_MQ_hd_var_size(data, | 667 | { GNUNET_MQ_hd_var_size (data, |
668 | GNUNET_MESSAGE_TYPE_CADET_CLI, | 668 | GNUNET_MESSAGE_TYPE_CADET_CLI, |
669 | struct GNUNET_MessageHeader, | 669 | struct GNUNET_MessageHeader, |
670 | NULL), | 670 | NULL), |
671 | GNUNET_MQ_handler_end() }; | 671 | GNUNET_MQ_handler_end () }; |
672 | 672 | ||
673 | /* FIXME add option to monitor apps */ | 673 | /* FIXME add option to monitor apps */ |
674 | my_cfg = cfg; | 674 | my_cfg = cfg; |
@@ -676,105 +676,105 @@ run(void *cls, | |||
676 | if (target_id && args[1]) | 676 | if (target_id && args[1]) |
677 | target_port = args[1]; | 677 | target_port = args[1]; |
678 | 678 | ||
679 | if ((0 != (request_peers | request_tunnels) || NULL != conn_id || | 679 | if (((0 != (request_peers | request_tunnels))||(NULL != conn_id)|| |
680 | NULL != channel_id) && | 680 | (NULL != channel_id) ) && |
681 | target_id != NULL) | 681 | (target_id != NULL) ) |
682 | { | 682 | { |
683 | fprintf(stderr, | 683 | fprintf (stderr, |
684 | _("Extra arguments are not applicable " | 684 | _ ("Extra arguments are not applicable " |
685 | "in combination with this option.\n")); | 685 | "in combination with this option.\n")); |
686 | return; | 686 | return; |
687 | } | 687 | } |
688 | 688 | ||
689 | if (NULL != peer_id) | 689 | if (NULL != peer_id) |
690 | { | 690 | { |
691 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show peer\n"); | 691 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show peer\n"); |
692 | job = GNUNET_SCHEDULER_add_now(&show_peer, NULL); | 692 | job = GNUNET_SCHEDULER_add_now (&show_peer, NULL); |
693 | } | 693 | } |
694 | else if (NULL != channel_id) | 694 | else if (NULL != channel_id) |
695 | { | 695 | { |
696 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show channel\n"); | 696 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show channel\n"); |
697 | job = GNUNET_SCHEDULER_add_now(&show_channel, NULL); | 697 | job = GNUNET_SCHEDULER_add_now (&show_channel, NULL); |
698 | } | 698 | } |
699 | else if (NULL != conn_id) | 699 | else if (NULL != conn_id) |
700 | { | 700 | { |
701 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show connection\n"); | 701 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show connection\n"); |
702 | job = GNUNET_SCHEDULER_add_now(&show_connection, NULL); | 702 | job = GNUNET_SCHEDULER_add_now (&show_connection, NULL); |
703 | } | 703 | } |
704 | else if (GNUNET_YES == request_peers) | 704 | else if (GNUNET_YES == request_peers) |
705 | { | 705 | { |
706 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n"); | 706 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n"); |
707 | job = GNUNET_SCHEDULER_add_now(&get_peers, NULL); | 707 | job = GNUNET_SCHEDULER_add_now (&get_peers, NULL); |
708 | } | 708 | } |
709 | else if (GNUNET_YES == request_tunnels) | 709 | else if (GNUNET_YES == request_tunnels) |
710 | { | 710 | { |
711 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n"); | 711 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n"); |
712 | job = GNUNET_SCHEDULER_add_now(&get_tunnels, NULL); | 712 | job = GNUNET_SCHEDULER_add_now (&get_tunnels, NULL); |
713 | } | 713 | } |
714 | 714 | ||
715 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n"); | 715 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n"); |
716 | mh = GNUNET_CADET_connect(cfg); | 716 | mh = GNUNET_CADET_connect (cfg); |
717 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); | 717 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); |
718 | if (NULL == mh) | 718 | if (NULL == mh) |
719 | { | ||
720 | GNUNET_SCHEDULER_shutdown (); | ||
721 | return; | ||
722 | } | ||
723 | if (NULL != listen_port) | ||
724 | { | ||
725 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n"); | ||
726 | GNUNET_CRYPTO_hash (listen_port, strlen (listen_port), &porthash); | ||
727 | lp = GNUNET_CADET_open_port (mh, | ||
728 | &porthash, | ||
729 | &channel_incoming, | ||
730 | NULL, | ||
731 | NULL /* window changes */, | ||
732 | &channel_ended, | ||
733 | handlers); | ||
734 | } | ||
735 | if (NULL != target_id) | ||
736 | { | ||
737 | struct GNUNET_PeerIdentity pid; | ||
738 | |||
739 | if (GNUNET_OK != | ||
740 | GNUNET_CRYPTO_eddsa_public_key_from_string (target_id, | ||
741 | strlen (target_id), | ||
742 | &pid.public_key)) | ||
719 | { | 743 | { |
720 | GNUNET_SCHEDULER_shutdown(); | 744 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
745 | _ ("Invalid target `%s'\n"), | ||
746 | target_id); | ||
747 | GNUNET_SCHEDULER_shutdown (); | ||
721 | return; | 748 | return; |
722 | } | 749 | } |
723 | if (NULL != listen_port) | 750 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
751 | "Connecting to `%s:%s'\n", | ||
752 | target_id, | ||
753 | target_port); | ||
754 | GNUNET_CRYPTO_hash (target_port, strlen (target_port), &porthash); | ||
755 | ch = GNUNET_CADET_channel_create (mh, | ||
756 | NULL, | ||
757 | &pid, | ||
758 | &porthash, | ||
759 | NULL /* window changes */, | ||
760 | &channel_ended, | ||
761 | handlers); | ||
762 | if (GNUNET_YES == echo) | ||
724 | { | 763 | { |
725 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n"); | 764 | echo_task = GNUNET_SCHEDULER_add_now (&send_echo, NULL); |
726 | GNUNET_CRYPTO_hash(listen_port, strlen(listen_port), &porthash); | ||
727 | lp = GNUNET_CADET_open_port(mh, | ||
728 | &porthash, | ||
729 | &channel_incoming, | ||
730 | NULL, | ||
731 | NULL /* window changes */, | ||
732 | &channel_ended, | ||
733 | handlers); | ||
734 | } | 765 | } |
735 | if (NULL != target_id) | 766 | else |
736 | { | 767 | { |
737 | struct GNUNET_PeerIdentity pid; | 768 | listen_stdio (); |
738 | |||
739 | if (GNUNET_OK != | ||
740 | GNUNET_CRYPTO_eddsa_public_key_from_string(target_id, | ||
741 | strlen(target_id), | ||
742 | &pid.public_key)) | ||
743 | { | ||
744 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
745 | _("Invalid target `%s'\n"), | ||
746 | target_id); | ||
747 | GNUNET_SCHEDULER_shutdown(); | ||
748 | return; | ||
749 | } | ||
750 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
751 | "Connecting to `%s:%s'\n", | ||
752 | target_id, | ||
753 | target_port); | ||
754 | GNUNET_CRYPTO_hash(target_port, strlen(target_port), &porthash); | ||
755 | ch = GNUNET_CADET_channel_create(mh, | ||
756 | NULL, | ||
757 | &pid, | ||
758 | &porthash, | ||
759 | NULL /* window changes */, | ||
760 | &channel_ended, | ||
761 | handlers); | ||
762 | if (GNUNET_YES == echo) | ||
763 | { | ||
764 | echo_task = GNUNET_SCHEDULER_add_now(&send_echo, NULL); | ||
765 | } | ||
766 | else | ||
767 | { | ||
768 | listen_stdio(); | ||
769 | } | ||
770 | } | 769 | } |
770 | } | ||
771 | 771 | ||
772 | if ((NULL == lp) && (NULL == job) && (NULL == ch)) | 772 | if ((NULL == lp) && (NULL == job) && (NULL == ch)) |
773 | { | 773 | { |
774 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, _("No action requested\n")); | 774 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _ ("No action requested\n")); |
775 | GNUNET_SCHEDULER_shutdown(); | 775 | GNUNET_SCHEDULER_shutdown (); |
776 | return; | 776 | return; |
777 | } | 777 | } |
778 | } | 778 | } |
779 | 779 | ||
780 | 780 | ||
@@ -786,61 +786,60 @@ run(void *cls, | |||
786 | * @return 0 ok, 1 on error | 786 | * @return 0 ok, 1 on error |
787 | */ | 787 | */ |
788 | int | 788 | int |
789 | main(int argc, char *const *argv) | 789 | main (int argc, char *const *argv) |
790 | { | 790 | { |
791 | int res; | 791 | int res; |
792 | const char helpstr[] = | 792 | const char helpstr[] = |
793 | "Create tunnels and retrieve info about CADET's status."; | 793 | "Create tunnels and retrieve info about CADET's status."; |
794 | struct GNUNET_GETOPT_CommandLineOption options[] = | 794 | struct GNUNET_GETOPT_CommandLineOption options[] = { /* I would use the terminology 'circuit' here... --lynX */ |
795 | { /* I would use the terminology 'circuit' here... --lynX */ | 795 | GNUNET_GETOPT_option_string ( |
796 | GNUNET_GETOPT_option_string( | ||
797 | 'C', | 796 | 'C', |
798 | "connection", | 797 | "connection", |
799 | "CONNECTION_ID", | 798 | "CONNECTION_ID", |
800 | gettext_noop("Provide information about a particular connection"), | 799 | gettext_noop ("Provide information about a particular connection"), |
801 | &conn_id), | 800 | &conn_id), |
802 | GNUNET_GETOPT_option_flag('e', | 801 | GNUNET_GETOPT_option_flag ('e', |
803 | "echo", | 802 | "echo", |
804 | gettext_noop("Activate echo mode"), | 803 | gettext_noop ("Activate echo mode"), |
805 | &echo), | 804 | &echo), |
806 | GNUNET_GETOPT_option_string( | 805 | GNUNET_GETOPT_option_string ( |
807 | 'o', | 806 | 'o', |
808 | "open-port", | 807 | "open-port", |
809 | "SHARED_SECRET", | 808 | "SHARED_SECRET", |
810 | gettext_noop( | 809 | gettext_noop ( |
811 | "Listen for connections using a shared secret among sender and recipient"), | 810 | "Listen for connections using a shared secret among sender and recipient"), |
812 | &listen_port), | 811 | &listen_port), |
813 | GNUNET_GETOPT_option_string('p', | 812 | GNUNET_GETOPT_option_string ('p', |
814 | "peer", | 813 | "peer", |
815 | "PEER_ID", | 814 | "PEER_ID", |
816 | gettext_noop( | 815 | gettext_noop ( |
817 | "Provide information about a patricular peer"), | 816 | "Provide information about a patricular peer"), |
818 | &peer_id), | 817 | &peer_id), |
819 | GNUNET_GETOPT_option_flag('P', | 818 | GNUNET_GETOPT_option_flag ('P', |
820 | "peers", | 819 | "peers", |
821 | gettext_noop( | 820 | gettext_noop ( |
822 | "Provide information about all peers"), | 821 | "Provide information about all peers"), |
823 | &request_peers), | 822 | &request_peers), |
824 | GNUNET_GETOPT_option_flag('T', | 823 | GNUNET_GETOPT_option_flag ('T', |
825 | "tunnels", | 824 | "tunnels", |
826 | gettext_noop( | 825 | gettext_noop ( |
827 | "Provide information about all tunnels"), | 826 | "Provide information about all tunnels"), |
828 | &request_tunnels), | 827 | &request_tunnels), |
829 | GNUNET_GETOPT_OPTION_END | 828 | GNUNET_GETOPT_OPTION_END |
830 | }; | 829 | }; |
831 | 830 | ||
832 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) | 831 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) |
833 | return 2; | 832 | return 2; |
834 | 833 | ||
835 | res = GNUNET_PROGRAM_run(argc, | 834 | res = GNUNET_PROGRAM_run (argc, |
836 | argv, | 835 | argv, |
837 | "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)", | 836 | "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)", |
838 | gettext_noop(helpstr), | 837 | gettext_noop (helpstr), |
839 | options, | 838 | options, |
840 | &run, | 839 | &run, |
841 | NULL); | 840 | NULL); |
842 | 841 | ||
843 | GNUNET_free((void *)argv); | 842 | GNUNET_free ((void *) argv); |
844 | 843 | ||
845 | if (GNUNET_OK == res) | 844 | if (GNUNET_OK == res) |
846 | return 0; | 845 | return 0; |
diff --git a/src/cadet/gnunet-service-cadet.c b/src/cadet/gnunet-service-cadet.c index a06cd184f..c64da33e2 100644 --- a/src/cadet/gnunet-service-cadet.c +++ b/src/cadet/gnunet-service-cadet.c | |||
@@ -46,13 +46,14 @@ | |||
46 | #include "gnunet-service-cadet_peer.h" | 46 | #include "gnunet-service-cadet_peer.h" |
47 | #include "gnunet-service-cadet_paths.h" | 47 | #include "gnunet-service-cadet_paths.h" |
48 | 48 | ||
49 | #define LOG(level, ...) GNUNET_log(level, __VA_ARGS__) | 49 | #define LOG(level, ...) GNUNET_log (level, __VA_ARGS__) |
50 | 50 | ||
51 | 51 | ||
52 | /** | 52 | /** |
53 | * Struct containing information about a client of the service | 53 | * Struct containing information about a client of the service |
54 | */ | 54 | */ |
55 | struct CadetClient { | 55 | struct CadetClient |
56 | { | ||
56 | /** | 57 | /** |
57 | * Linked list next | 58 | * Linked list next |
58 | */ | 59 | */ |
@@ -201,11 +202,11 @@ unsigned long long drop_percent; | |||
201 | * @param env envelope with the message | 202 | * @param env envelope with the message |
202 | */ | 203 | */ |
203 | void | 204 | void |
204 | GSC_send_to_client(struct CadetClient *c, | 205 | GSC_send_to_client (struct CadetClient *c, |
205 | struct GNUNET_MQ_Envelope *env) | 206 | struct GNUNET_MQ_Envelope *env) |
206 | { | 207 | { |
207 | GNUNET_MQ_send(c->mq, | 208 | GNUNET_MQ_send (c->mq, |
208 | env); | 209 | env); |
209 | } | 210 | } |
210 | 211 | ||
211 | 212 | ||
@@ -216,14 +217,14 @@ GSC_send_to_client(struct CadetClient *c, | |||
216 | * @return string for debugging | 217 | * @return string for debugging |
217 | */ | 218 | */ |
218 | const char * | 219 | const char * |
219 | GSC_2s(struct CadetClient *c) | 220 | GSC_2s (struct CadetClient *c) |
220 | { | 221 | { |
221 | static char buf[32]; | 222 | static char buf[32]; |
222 | 223 | ||
223 | GNUNET_snprintf(buf, | 224 | GNUNET_snprintf (buf, |
224 | sizeof(buf), | 225 | sizeof(buf), |
225 | "Client(%u)", | 226 | "Client(%u)", |
226 | c->id); | 227 | c->id); |
227 | return buf; | 228 | return buf; |
228 | } | 229 | } |
229 | 230 | ||
@@ -236,11 +237,11 @@ GSC_2s(struct CadetClient *c) | |||
236 | * @return NULL if no such channel exists | 237 | * @return NULL if no such channel exists |
237 | */ | 238 | */ |
238 | static struct CadetChannel * | 239 | static struct CadetChannel * |
239 | lookup_channel(struct CadetClient *c, | 240 | lookup_channel (struct CadetClient *c, |
240 | struct GNUNET_CADET_ClientChannelNumber ccn) | 241 | struct GNUNET_CADET_ClientChannelNumber ccn) |
241 | { | 242 | { |
242 | return GNUNET_CONTAINER_multihashmap32_get(c->channels, | 243 | return GNUNET_CONTAINER_multihashmap32_get (c->channels, |
243 | ntohl(ccn.channel_of_client)); | 244 | ntohl (ccn.channel_of_client)); |
244 | } | 245 | } |
245 | 246 | ||
246 | 247 | ||
@@ -251,23 +252,23 @@ lookup_channel(struct CadetClient *c, | |||
251 | * @param c client handle | 252 | * @param c client handle |
252 | */ | 253 | */ |
253 | static struct GNUNET_CADET_ClientChannelNumber | 254 | static struct GNUNET_CADET_ClientChannelNumber |
254 | client_get_next_ccn(struct CadetClient *c) | 255 | client_get_next_ccn (struct CadetClient *c) |
255 | { | 256 | { |
256 | struct GNUNET_CADET_ClientChannelNumber ccn = c->next_ccn; | 257 | struct GNUNET_CADET_ClientChannelNumber ccn = c->next_ccn; |
257 | 258 | ||
258 | /* increment until we have a free one... */ | 259 | /* increment until we have a free one... */ |
259 | while (NULL != | 260 | while (NULL != |
260 | lookup_channel(c, | 261 | lookup_channel (c, |
261 | ccn)) | 262 | ccn)) |
262 | { | 263 | { |
263 | ccn.channel_of_client | 264 | ccn.channel_of_client |
264 | = htonl(1 + (ntohl(ccn.channel_of_client))); | 265 | = htonl (1 + (ntohl (ccn.channel_of_client))); |
265 | if (ntohl(ccn.channel_of_client) >= | 266 | if (ntohl (ccn.channel_of_client) >= |
266 | GNUNET_CADET_LOCAL_CHANNEL_ID_CLI) | 267 | GNUNET_CADET_LOCAL_CHANNEL_ID_CLI) |
267 | ccn.channel_of_client = htonl(0); | 268 | ccn.channel_of_client = htonl (0); |
268 | } | 269 | } |
269 | c->next_ccn.channel_of_client | 270 | c->next_ccn.channel_of_client |
270 | = htonl(1 + (ntohl(ccn.channel_of_client))); | 271 | = htonl (1 + (ntohl (ccn.channel_of_client))); |
271 | return ccn; | 272 | return ccn; |
272 | } | 273 | } |
273 | 274 | ||
@@ -285,38 +286,39 @@ client_get_next_ccn(struct CadetClient *c) | |||
285 | * @return local channel number assigned to the new client | 286 | * @return local channel number assigned to the new client |
286 | */ | 287 | */ |
287 | struct GNUNET_CADET_ClientChannelNumber | 288 | struct GNUNET_CADET_ClientChannelNumber |
288 | GSC_bind(struct CadetClient *c, | 289 | GSC_bind (struct CadetClient *c, |
289 | struct CadetChannel *ch, | 290 | struct CadetChannel *ch, |
290 | struct CadetPeer *dest, | 291 | struct CadetPeer *dest, |
291 | const struct GNUNET_HashCode *port, | 292 | const struct GNUNET_HashCode *port, |
292 | uint32_t options) | 293 | uint32_t options) |
293 | { | 294 | { |
294 | struct GNUNET_MQ_Envelope *env; | 295 | struct GNUNET_MQ_Envelope *env; |
295 | struct GNUNET_CADET_LocalChannelCreateMessage *cm; | 296 | struct GNUNET_CADET_LocalChannelCreateMessage *cm; |
296 | struct GNUNET_CADET_ClientChannelNumber ccn; | 297 | struct GNUNET_CADET_ClientChannelNumber ccn; |
297 | 298 | ||
298 | ccn = client_get_next_ccn(c); | 299 | ccn = client_get_next_ccn (c); |
299 | GNUNET_assert(GNUNET_YES == | 300 | GNUNET_assert (GNUNET_YES == |
300 | GNUNET_CONTAINER_multihashmap32_put(c->channels, | 301 | GNUNET_CONTAINER_multihashmap32_put (c->channels, |
301 | ntohl(ccn.channel_of_client), | 302 | ntohl ( |
302 | ch, | 303 | ccn.channel_of_client), |
303 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 304 | ch, |
304 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 305 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
305 | "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n", | 306 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
306 | GCCH_2s(ch), | 307 | "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n", |
307 | GCP_2s(dest), | 308 | GCCH_2s (ch), |
308 | GNUNET_h2s(port), | 309 | GCP_2s (dest), |
309 | (uint32_t)ntohl(options), | 310 | GNUNET_h2s (port), |
310 | (uint32_t)ntohl(ccn.channel_of_client)); | 311 | (uint32_t) ntohl (options), |
312 | (uint32_t) ntohl (ccn.channel_of_client)); | ||
311 | /* notify local client about incoming connection! */ | 313 | /* notify local client about incoming connection! */ |
312 | env = GNUNET_MQ_msg(cm, | 314 | env = GNUNET_MQ_msg (cm, |
313 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE); | 315 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE); |
314 | cm->ccn = ccn; | 316 | cm->ccn = ccn; |
315 | cm->port = *port; | 317 | cm->port = *port; |
316 | cm->opt = htonl(options); | 318 | cm->opt = htonl (options); |
317 | cm->peer = *GCP_get_id(dest); | 319 | cm->peer = *GCP_get_id (dest); |
318 | GSC_send_to_client(c, | 320 | GSC_send_to_client (c, |
319 | env); | 321 | env); |
320 | return ccn; | 322 | return ccn; |
321 | } | 323 | } |
322 | 324 | ||
@@ -331,16 +333,16 @@ GSC_bind(struct CadetClient *c, | |||
331 | * @return #GNUNET_OK (iterate over all entries) | 333 | * @return #GNUNET_OK (iterate over all entries) |
332 | */ | 334 | */ |
333 | static int | 335 | static int |
334 | destroy_tunnels_now(void *cls, | 336 | destroy_tunnels_now (void *cls, |
335 | const struct GNUNET_PeerIdentity *pid, | 337 | const struct GNUNET_PeerIdentity *pid, |
336 | void *value) | 338 | void *value) |
337 | { | 339 | { |
338 | struct CadetPeer *cp = value; | 340 | struct CadetPeer *cp = value; |
339 | struct CadetTunnel *t = GCP_get_tunnel(cp, | 341 | struct CadetTunnel *t = GCP_get_tunnel (cp, |
340 | GNUNET_NO); | 342 | GNUNET_NO); |
341 | 343 | ||
342 | if (NULL != t) | 344 | if (NULL != t) |
343 | GCT_destroy_tunnel_now(t); | 345 | GCT_destroy_tunnel_now (t); |
344 | return GNUNET_OK; | 346 | return GNUNET_OK; |
345 | } | 347 | } |
346 | 348 | ||
@@ -355,13 +357,13 @@ destroy_tunnels_now(void *cls, | |||
355 | * @return #GNUNET_OK (iterate over all entries) | 357 | * @return #GNUNET_OK (iterate over all entries) |
356 | */ | 358 | */ |
357 | static int | 359 | static int |
358 | destroy_paths_now(void *cls, | 360 | destroy_paths_now (void *cls, |
359 | const struct GNUNET_PeerIdentity *pid, | 361 | const struct GNUNET_PeerIdentity *pid, |
360 | void *value) | 362 | void *value) |
361 | { | 363 | { |
362 | struct CadetPeer *cp = value; | 364 | struct CadetPeer *cp = value; |
363 | 365 | ||
364 | GCP_drop_owned_paths(cp); | 366 | GCP_drop_owned_paths (cp); |
365 | return GNUNET_OK; | 367 | return GNUNET_OK; |
366 | } | 368 | } |
367 | 369 | ||
@@ -370,50 +372,50 @@ destroy_paths_now(void *cls, | |||
370 | * Shutdown everything once the clients have disconnected. | 372 | * Shutdown everything once the clients have disconnected. |
371 | */ | 373 | */ |
372 | static void | 374 | static void |
373 | shutdown_rest() | 375 | shutdown_rest () |
374 | { | 376 | { |
375 | if (NULL != stats) | 377 | if (NULL != stats) |
376 | { | 378 | { |
377 | GNUNET_STATISTICS_destroy(stats, | 379 | GNUNET_STATISTICS_destroy (stats, |
378 | GNUNET_NO); | 380 | GNUNET_NO); |
379 | stats = NULL; | 381 | stats = NULL; |
380 | } | 382 | } |
381 | /* Destroy tunnels. Note that all channels must be destroyed first! */ | 383 | /* Destroy tunnels. Note that all channels must be destroyed first! */ |
382 | GCP_iterate_all(&destroy_tunnels_now, | 384 | GCP_iterate_all (&destroy_tunnels_now, |
383 | NULL); | 385 | NULL); |
384 | /* All tunnels, channels, connections and CORE must be down before this point. */ | 386 | /* All tunnels, channels, connections and CORE must be down before this point. */ |
385 | GCP_iterate_all(&destroy_paths_now, | 387 | GCP_iterate_all (&destroy_paths_now, |
386 | NULL); | 388 | NULL); |
387 | /* All paths, tunnels, channels, connections and CORE must be down before this point. */ | 389 | /* All paths, tunnels, channels, connections and CORE must be down before this point. */ |
388 | GCP_destroy_all_peers(); | 390 | GCP_destroy_all_peers (); |
389 | if (NULL != open_ports) | 391 | if (NULL != open_ports) |
390 | { | 392 | { |
391 | GNUNET_CONTAINER_multihashmap_destroy(open_ports); | 393 | GNUNET_CONTAINER_multihashmap_destroy (open_ports); |
392 | open_ports = NULL; | 394 | open_ports = NULL; |
393 | } | 395 | } |
394 | if (NULL != loose_channels) | 396 | if (NULL != loose_channels) |
395 | { | 397 | { |
396 | GNUNET_CONTAINER_multihashmap_destroy(loose_channels); | 398 | GNUNET_CONTAINER_multihashmap_destroy (loose_channels); |
397 | loose_channels = NULL; | 399 | loose_channels = NULL; |
398 | } | 400 | } |
399 | if (NULL != peers) | 401 | if (NULL != peers) |
400 | { | 402 | { |
401 | GNUNET_CONTAINER_multipeermap_destroy(peers); | 403 | GNUNET_CONTAINER_multipeermap_destroy (peers); |
402 | peers = NULL; | 404 | peers = NULL; |
403 | } | 405 | } |
404 | if (NULL != connections) | 406 | if (NULL != connections) |
405 | { | 407 | { |
406 | GNUNET_CONTAINER_multishortmap_destroy(connections); | 408 | GNUNET_CONTAINER_multishortmap_destroy (connections); |
407 | connections = NULL; | 409 | connections = NULL; |
408 | } | 410 | } |
409 | if (NULL != ats_ch) | 411 | if (NULL != ats_ch) |
410 | { | 412 | { |
411 | GNUNET_ATS_connectivity_done(ats_ch); | 413 | GNUNET_ATS_connectivity_done (ats_ch); |
412 | ats_ch = NULL; | 414 | ats_ch = NULL; |
413 | } | 415 | } |
414 | GCD_shutdown(); | 416 | GCD_shutdown (); |
415 | GCH_shutdown(); | 417 | GCH_shutdown (); |
416 | GNUNET_free_non_null(my_private_key); | 418 | GNUNET_free_non_null (my_private_key); |
417 | my_private_key = NULL; | 419 | my_private_key = NULL; |
418 | } | 420 | } |
419 | 421 | ||
@@ -424,14 +426,14 @@ shutdown_rest() | |||
424 | * @param cls unused | 426 | * @param cls unused |
425 | */ | 427 | */ |
426 | static void | 428 | static void |
427 | shutdown_task(void *cls) | 429 | shutdown_task (void *cls) |
428 | { | 430 | { |
429 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 431 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
430 | "Shutting down\n"); | 432 | "Shutting down\n"); |
431 | shutting_down = GNUNET_YES; | 433 | shutting_down = GNUNET_YES; |
432 | GCO_shutdown(); | 434 | GCO_shutdown (); |
433 | if (NULL == clients_head) | 435 | if (NULL == clients_head) |
434 | shutdown_rest(); | 436 | shutdown_rest (); |
435 | } | 437 | } |
436 | 438 | ||
437 | 439 | ||
@@ -445,20 +447,20 @@ shutdown_task(void *cls) | |||
445 | * @return #GNUNET_YES (iterate over all such channels) | 447 | * @return #GNUNET_YES (iterate over all such channels) |
446 | */ | 448 | */ |
447 | static int | 449 | static int |
448 | bind_loose_channel(void *cls, | 450 | bind_loose_channel (void *cls, |
449 | const struct GNUNET_HashCode *port, | 451 | const struct GNUNET_HashCode *port, |
450 | void *value) | 452 | void *value) |
451 | { | 453 | { |
452 | struct OpenPort *op = cls; | 454 | struct OpenPort *op = cls; |
453 | struct CadetChannel *ch = value; | 455 | struct CadetChannel *ch = value; |
454 | 456 | ||
455 | GCCH_bind(ch, | 457 | GCCH_bind (ch, |
456 | op->c, | 458 | op->c, |
457 | &op->port); | 459 | &op->port); |
458 | GNUNET_assert(GNUNET_YES == | 460 | GNUNET_assert (GNUNET_YES == |
459 | GNUNET_CONTAINER_multihashmap_remove(loose_channels, | 461 | GNUNET_CONTAINER_multihashmap_remove (loose_channels, |
460 | &op->h_port, | 462 | &op->h_port, |
461 | ch)); | 463 | ch)); |
462 | return GNUNET_YES; | 464 | return GNUNET_YES; |
463 | } | 465 | } |
464 | 466 | ||
@@ -473,44 +475,44 @@ bind_loose_channel(void *cls, | |||
473 | * @param pmsg The actual message. | 475 | * @param pmsg The actual message. |
474 | */ | 476 | */ |
475 | static void | 477 | static void |
476 | handle_port_open(void *cls, | 478 | handle_port_open (void *cls, |
477 | const struct GNUNET_CADET_PortMessage *pmsg) | 479 | const struct GNUNET_CADET_PortMessage *pmsg) |
478 | { | 480 | { |
479 | struct CadetClient *c = cls; | 481 | struct CadetClient *c = cls; |
480 | struct OpenPort *op; | 482 | struct OpenPort *op; |
481 | 483 | ||
482 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 484 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
483 | "Open port %s requested by %s\n", | 485 | "Open port %s requested by %s\n", |
484 | GNUNET_h2s(&pmsg->port), | 486 | GNUNET_h2s (&pmsg->port), |
485 | GSC_2s(c)); | 487 | GSC_2s (c)); |
486 | if (NULL == c->ports) | 488 | if (NULL == c->ports) |
487 | c->ports = GNUNET_CONTAINER_multihashmap_create(4, | 489 | c->ports = GNUNET_CONTAINER_multihashmap_create (4, |
488 | GNUNET_NO); | 490 | GNUNET_NO); |
489 | op = GNUNET_new(struct OpenPort); | 491 | op = GNUNET_new (struct OpenPort); |
490 | op->c = c; | 492 | op->c = c; |
491 | op->port = pmsg->port; | 493 | op->port = pmsg->port; |
492 | GCCH_hash_port(&op->h_port, | 494 | GCCH_hash_port (&op->h_port, |
493 | &pmsg->port, | 495 | &pmsg->port, |
494 | &my_full_id); | 496 | &my_full_id); |
495 | if (GNUNET_OK != | 497 | if (GNUNET_OK != |
496 | GNUNET_CONTAINER_multihashmap_put(c->ports, | 498 | GNUNET_CONTAINER_multihashmap_put (c->ports, |
497 | &op->port, | 499 | &op->port, |
498 | op, | 500 | op, |
499 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) | 501 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) |
500 | { | 502 | { |
501 | GNUNET_break(0); | 503 | GNUNET_break (0); |
502 | GNUNET_SERVICE_client_drop(c->client); | 504 | GNUNET_SERVICE_client_drop (c->client); |
503 | return; | 505 | return; |
504 | } | 506 | } |
505 | (void)GNUNET_CONTAINER_multihashmap_put(open_ports, | 507 | (void) GNUNET_CONTAINER_multihashmap_put (open_ports, |
506 | &op->h_port, | 508 | &op->h_port, |
507 | op, | 509 | op, |
508 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 510 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
509 | GNUNET_CONTAINER_multihashmap_get_multiple(loose_channels, | 511 | GNUNET_CONTAINER_multihashmap_get_multiple (loose_channels, |
510 | &op->h_port, | 512 | &op->h_port, |
511 | &bind_loose_channel, | 513 | &bind_loose_channel, |
512 | op); | 514 | op); |
513 | GNUNET_SERVICE_client_continue(c->client); | 515 | GNUNET_SERVICE_client_continue (c->client); |
514 | } | 516 | } |
515 | 517 | ||
516 | 518 | ||
@@ -524,41 +526,41 @@ handle_port_open(void *cls, | |||
524 | * @param pmsg The actual message. | 526 | * @param pmsg The actual message. |
525 | */ | 527 | */ |
526 | static void | 528 | static void |
527 | handle_port_close(void *cls, | 529 | handle_port_close (void *cls, |
528 | const struct GNUNET_CADET_PortMessage *pmsg) | 530 | const struct GNUNET_CADET_PortMessage *pmsg) |
529 | { | 531 | { |
530 | struct CadetClient *c = cls; | 532 | struct CadetClient *c = cls; |
531 | struct OpenPort *op; | 533 | struct OpenPort *op; |
532 | 534 | ||
533 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 535 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
534 | "Closing port %s as requested by %s\n", | 536 | "Closing port %s as requested by %s\n", |
535 | GNUNET_h2s(&pmsg->port), | 537 | GNUNET_h2s (&pmsg->port), |
536 | GSC_2s(c)); | 538 | GSC_2s (c)); |
537 | if (NULL == c->ports) | 539 | if (NULL == c->ports) |
538 | { | 540 | { |
539 | /* Client closed a port despite _never_ having opened one? */ | 541 | /* Client closed a port despite _never_ having opened one? */ |
540 | GNUNET_break(0); | 542 | GNUNET_break (0); |
541 | GNUNET_SERVICE_client_drop(c->client); | 543 | GNUNET_SERVICE_client_drop (c->client); |
542 | return; | 544 | return; |
543 | } | 545 | } |
544 | op = GNUNET_CONTAINER_multihashmap_get(c->ports, | 546 | op = GNUNET_CONTAINER_multihashmap_get (c->ports, |
545 | &pmsg->port); | 547 | &pmsg->port); |
546 | if (NULL == op) | 548 | if (NULL == op) |
547 | { | 549 | { |
548 | GNUNET_break(0); | 550 | GNUNET_break (0); |
549 | GNUNET_SERVICE_client_drop(c->client); | 551 | GNUNET_SERVICE_client_drop (c->client); |
550 | return; | 552 | return; |
551 | } | 553 | } |
552 | GNUNET_assert(GNUNET_YES == | 554 | GNUNET_assert (GNUNET_YES == |
553 | GNUNET_CONTAINER_multihashmap_remove(c->ports, | 555 | GNUNET_CONTAINER_multihashmap_remove (c->ports, |
554 | &op->port, | 556 | &op->port, |
555 | op)); | 557 | op)); |
556 | GNUNET_assert(GNUNET_YES == | 558 | GNUNET_assert (GNUNET_YES == |
557 | GNUNET_CONTAINER_multihashmap_remove(open_ports, | 559 | GNUNET_CONTAINER_multihashmap_remove (open_ports, |
558 | &op->h_port, | 560 | &op->h_port, |
559 | op)); | 561 | op)); |
560 | GNUNET_free(op); | 562 | GNUNET_free (op); |
561 | GNUNET_SERVICE_client_continue(c->client); | 563 | GNUNET_SERVICE_client_continue (c->client); |
562 | } | 564 | } |
563 | 565 | ||
564 | 566 | ||
@@ -569,54 +571,56 @@ handle_port_close(void *cls, | |||
569 | * @param tcm The actual message. | 571 | * @param tcm The actual message. |
570 | */ | 572 | */ |
571 | static void | 573 | static void |
572 | handle_channel_create(void *cls, | 574 | handle_channel_create (void *cls, |
573 | const struct GNUNET_CADET_LocalChannelCreateMessage *tcm) | 575 | const struct GNUNET_CADET_LocalChannelCreateMessage *tcm) |
574 | { | 576 | { |
575 | struct CadetClient *c = cls; | 577 | struct CadetClient *c = cls; |
576 | struct CadetChannel *ch; | 578 | struct CadetChannel *ch; |
577 | 579 | ||
578 | if (ntohl(tcm->ccn.channel_of_client) < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI) | 580 | if (ntohl (tcm->ccn.channel_of_client) < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI) |
579 | { | 581 | { |
580 | /* Channel ID not in allowed range. */ | 582 | /* Channel ID not in allowed range. */ |
581 | GNUNET_break(0); | 583 | GNUNET_break (0); |
582 | GNUNET_SERVICE_client_drop(c->client); | 584 | GNUNET_SERVICE_client_drop (c->client); |
583 | return; | 585 | return; |
584 | } | 586 | } |
585 | ch = lookup_channel(c, | 587 | ch = lookup_channel (c, |
586 | tcm->ccn); | 588 | tcm->ccn); |
587 | if (NULL != ch) | 589 | if (NULL != ch) |
588 | { | 590 | { |
589 | /* Channel ID already in use. Not allowed. */ | 591 | /* Channel ID already in use. Not allowed. */ |
590 | GNUNET_break(0); | 592 | GNUNET_break (0); |
591 | GNUNET_SERVICE_client_drop(c->client); | 593 | GNUNET_SERVICE_client_drop (c->client); |
592 | return; | 594 | return; |
593 | } | 595 | } |
594 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 596 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
595 | "New channel to %s at port %s requested by %s\n", | 597 | "New channel to %s at port %s requested by %s\n", |
596 | GNUNET_i2s(&tcm->peer), | 598 | GNUNET_i2s (&tcm->peer), |
597 | GNUNET_h2s(&tcm->port), | 599 | GNUNET_h2s (&tcm->port), |
598 | GSC_2s(c)); | 600 | GSC_2s (c)); |
599 | 601 | ||
600 | /* Create channel */ | 602 | /* Create channel */ |
601 | ch = GCCH_channel_local_new(c, | 603 | ch = GCCH_channel_local_new (c, |
602 | tcm->ccn, | 604 | tcm->ccn, |
603 | GCP_get(&tcm->peer, | 605 | GCP_get (&tcm->peer, |
604 | GNUNET_YES), | 606 | GNUNET_YES), |
605 | &tcm->port, | 607 | &tcm->port, |
606 | ntohl(tcm->opt)); | 608 | ntohl (tcm->opt)); |
607 | if (NULL == ch) | 609 | if (NULL == ch) |
608 | { | 610 | { |
609 | GNUNET_break(0); | 611 | GNUNET_break (0); |
610 | GNUNET_SERVICE_client_drop(c->client); | 612 | GNUNET_SERVICE_client_drop (c->client); |
611 | return; | 613 | return; |
612 | } | 614 | } |
613 | GNUNET_assert(GNUNET_YES == | 615 | GNUNET_assert (GNUNET_YES == |
614 | GNUNET_CONTAINER_multihashmap32_put(c->channels, | 616 | GNUNET_CONTAINER_multihashmap32_put (c->channels, |
615 | ntohl(tcm->ccn.channel_of_client), | 617 | ntohl ( |
616 | ch, | 618 | tcm->ccn. |
617 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 619 | channel_of_client), |
618 | 620 | ch, | |
619 | GNUNET_SERVICE_client_continue(c->client); | 621 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
622 | |||
623 | GNUNET_SERVICE_client_continue (c->client); | ||
620 | } | 624 | } |
621 | 625 | ||
622 | 626 | ||
@@ -627,37 +631,40 @@ handle_channel_create(void *cls, | |||
627 | * @param msg the actual message | 631 | * @param msg the actual message |
628 | */ | 632 | */ |
629 | static void | 633 | static void |
630 | handle_channel_destroy(void *cls, | 634 | handle_channel_destroy (void *cls, |
631 | const struct GNUNET_CADET_LocalChannelDestroyMessage *msg) | 635 | const struct |
636 | GNUNET_CADET_LocalChannelDestroyMessage *msg) | ||
632 | { | 637 | { |
633 | struct CadetClient *c = cls; | 638 | struct CadetClient *c = cls; |
634 | struct CadetChannel *ch; | 639 | struct CadetChannel *ch; |
635 | 640 | ||
636 | ch = lookup_channel(c, | 641 | ch = lookup_channel (c, |
637 | msg->ccn); | 642 | msg->ccn); |
638 | if (NULL == ch) | 643 | if (NULL == ch) |
639 | { | 644 | { |
640 | /* Client attempted to destroy unknown channel. | 645 | /* Client attempted to destroy unknown channel. |
641 | Can happen if the other side went down at the same time.*/ | 646 | Can happen if the other side went down at the same time.*/ |
642 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 647 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
643 | "%s tried to destroy unknown channel %X\n", | 648 | "%s tried to destroy unknown channel %X\n", |
644 | GSC_2s(c), | 649 | GSC_2s (c), |
645 | (uint32_t)ntohl(msg->ccn.channel_of_client)); | 650 | (uint32_t) ntohl (msg->ccn.channel_of_client)); |
646 | GNUNET_SERVICE_client_continue(c->client); | 651 | GNUNET_SERVICE_client_continue (c->client); |
647 | return; | 652 | return; |
648 | } | 653 | } |
649 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 654 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
650 | "%s is destroying %s\n", | 655 | "%s is destroying %s\n", |
651 | GSC_2s(c), | 656 | GSC_2s (c), |
652 | GCCH_2s(ch)); | 657 | GCCH_2s (ch)); |
653 | GNUNET_assert(GNUNET_YES == | 658 | GNUNET_assert (GNUNET_YES == |
654 | GNUNET_CONTAINER_multihashmap32_remove(c->channels, | 659 | GNUNET_CONTAINER_multihashmap32_remove (c->channels, |
655 | ntohl(msg->ccn.channel_of_client), | 660 | ntohl ( |
656 | ch)); | 661 | msg->ccn. |
657 | GCCH_channel_local_destroy(ch, | 662 | channel_of_client), |
658 | c, | 663 | ch)); |
659 | msg->ccn); | 664 | GCCH_channel_local_destroy (ch, |
660 | GNUNET_SERVICE_client_continue(c->client); | 665 | c, |
666 | msg->ccn); | ||
667 | GNUNET_SERVICE_client_continue (c->client); | ||
661 | } | 668 | } |
662 | 669 | ||
663 | 670 | ||
@@ -669,8 +676,8 @@ handle_channel_destroy(void *cls, | |||
669 | * @return #GNUNET_OK if @a msg is OK, #GNUNET_SYSERR if not | 676 | * @return #GNUNET_OK if @a msg is OK, #GNUNET_SYSERR if not |
670 | */ | 677 | */ |
671 | static int | 678 | static int |
672 | check_local_data(void *cls, | 679 | check_local_data (void *cls, |
673 | const struct GNUNET_CADET_LocalData *msg) | 680 | const struct GNUNET_CADET_LocalData *msg) |
674 | { | 681 | { |
675 | size_t payload_size; | 682 | size_t payload_size; |
676 | size_t payload_claimed_size; | 683 | size_t payload_claimed_size; |
@@ -683,36 +690,36 @@ check_local_data(void *cls, | |||
683 | cadet_api will likely no more, so we could then | 690 | cadet_api will likely no more, so we could then |
684 | simplify this mess again. */ | 691 | simplify this mess again. */ |
685 | /* Sanity check for message size */ | 692 | /* Sanity check for message size */ |
686 | payload_size = ntohs(msg->header.size) - sizeof(*msg); | 693 | payload_size = ntohs (msg->header.size) - sizeof(*msg); |
687 | buf = (const char *)&msg[1]; | 694 | buf = (const char *) &msg[1]; |
688 | while (payload_size >= sizeof(struct GNUNET_MessageHeader)) | 695 | while (payload_size >= sizeof(struct GNUNET_MessageHeader)) |
696 | { | ||
697 | /* need to memcpy() for alignment */ | ||
698 | GNUNET_memcpy (&pa, | ||
699 | buf, | ||
700 | sizeof(pa)); | ||
701 | payload_claimed_size = ntohs (pa.size); | ||
702 | if ((payload_size < payload_claimed_size) || | ||
703 | (payload_claimed_size < sizeof(struct GNUNET_MessageHeader)) || | ||
704 | (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size)) | ||
689 | { | 705 | { |
690 | /* need to memcpy() for alignment */ | 706 | GNUNET_break (0); |
691 | GNUNET_memcpy(&pa, | 707 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
692 | buf, | 708 | "Local data of %u total size had sub-message %u at %u with %u bytes\n", |
693 | sizeof(pa)); | 709 | ntohs (msg->header.size), |
694 | payload_claimed_size = ntohs(pa.size); | 710 | ntohs (pa.type), |
695 | if ((payload_size < payload_claimed_size) || | 711 | (unsigned int) (buf - (const char *) &msg[1]), |
696 | (payload_claimed_size < sizeof(struct GNUNET_MessageHeader)) || | 712 | (unsigned int) payload_claimed_size); |
697 | (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size)) | ||
698 | { | ||
699 | GNUNET_break(0); | ||
700 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
701 | "Local data of %u total size had sub-message %u at %u with %u bytes\n", | ||
702 | ntohs(msg->header.size), | ||
703 | ntohs(pa.type), | ||
704 | (unsigned int)(buf - (const char *)&msg[1]), | ||
705 | (unsigned int)payload_claimed_size); | ||
706 | return GNUNET_SYSERR; | ||
707 | } | ||
708 | payload_size -= payload_claimed_size; | ||
709 | buf += payload_claimed_size; | ||
710 | } | ||
711 | if (0 != payload_size) | ||
712 | { | ||
713 | GNUNET_break_op(0); | ||
714 | return GNUNET_SYSERR; | 713 | return GNUNET_SYSERR; |
715 | } | 714 | } |
715 | payload_size -= payload_claimed_size; | ||
716 | buf += payload_claimed_size; | ||
717 | } | ||
718 | if (0 != payload_size) | ||
719 | { | ||
720 | GNUNET_break_op (0); | ||
721 | return GNUNET_SYSERR; | ||
722 | } | ||
716 | return GNUNET_OK; | 723 | return GNUNET_OK; |
717 | } | 724 | } |
718 | 725 | ||
@@ -725,47 +732,47 @@ check_local_data(void *cls, | |||
725 | * @param msg the actual message | 732 | * @param msg the actual message |
726 | */ | 733 | */ |
727 | static void | 734 | static void |
728 | handle_local_data(void *cls, | 735 | handle_local_data (void *cls, |
729 | const struct GNUNET_CADET_LocalData *msg) | 736 | const struct GNUNET_CADET_LocalData *msg) |
730 | { | 737 | { |
731 | struct CadetClient *c = cls; | 738 | struct CadetClient *c = cls; |
732 | struct CadetChannel *ch; | 739 | struct CadetChannel *ch; |
733 | size_t payload_size; | 740 | size_t payload_size; |
734 | const char *buf; | 741 | const char *buf; |
735 | 742 | ||
736 | ch = lookup_channel(c, | 743 | ch = lookup_channel (c, |
737 | msg->ccn); | 744 | msg->ccn); |
738 | if (NULL == ch) | 745 | if (NULL == ch) |
739 | { | 746 | { |
740 | /* Channel does not exist (anymore) */ | 747 | /* Channel does not exist (anymore) */ |
741 | LOG(GNUNET_ERROR_TYPE_WARNING, | 748 | LOG (GNUNET_ERROR_TYPE_WARNING, |
742 | "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n", | 749 | "Dropping payload for channel %u from client (channel unknown, other endpoint may have disconnected)\n", |
743 | (unsigned int)ntohl(msg->ccn.channel_of_client)); | 750 | (unsigned int) ntohl (msg->ccn.channel_of_client)); |
744 | GNUNET_SERVICE_client_continue(c->client); | 751 | GNUNET_SERVICE_client_continue (c->client); |
745 | return; | 752 | return; |
746 | } | 753 | } |
747 | payload_size = ntohs(msg->header.size) - sizeof(*msg); | 754 | payload_size = ntohs (msg->header.size) - sizeof(*msg); |
748 | GNUNET_STATISTICS_update(stats, | 755 | GNUNET_STATISTICS_update (stats, |
749 | "# payload received from clients", | 756 | "# payload received from clients", |
750 | payload_size, | 757 | payload_size, |
751 | GNUNET_NO); | 758 | GNUNET_NO); |
752 | buf = (const char *)&msg[1]; | 759 | buf = (const char *) &msg[1]; |
753 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 760 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
754 | "Received %u bytes payload from %s for %s\n", | 761 | "Received %u bytes payload from %s for %s\n", |
755 | (unsigned int)payload_size, | 762 | (unsigned int) payload_size, |
756 | GSC_2s(c), | 763 | GSC_2s (c), |
757 | GCCH_2s(ch)); | 764 | GCCH_2s (ch)); |
758 | if (GNUNET_OK != | 765 | if (GNUNET_OK != |
759 | GCCH_handle_local_data(ch, | 766 | GCCH_handle_local_data (ch, |
760 | msg->ccn, | 767 | msg->ccn, |
761 | buf, | 768 | buf, |
762 | payload_size)) | 769 | payload_size)) |
763 | { | 770 | { |
764 | GNUNET_break(0); | 771 | GNUNET_break (0); |
765 | GNUNET_SERVICE_client_drop(c->client); | 772 | GNUNET_SERVICE_client_drop (c->client); |
766 | return; | 773 | return; |
767 | } | 774 | } |
768 | GNUNET_SERVICE_client_continue(c->client); | 775 | GNUNET_SERVICE_client_continue (c->client); |
769 | } | 776 | } |
770 | 777 | ||
771 | 778 | ||
@@ -776,30 +783,30 @@ handle_local_data(void *cls, | |||
776 | * @param msg The actual message. | 783 | * @param msg The actual message. |
777 | */ | 784 | */ |
778 | static void | 785 | static void |
779 | handle_local_ack(void *cls, | 786 | handle_local_ack (void *cls, |
780 | const struct GNUNET_CADET_LocalAck *msg) | 787 | const struct GNUNET_CADET_LocalAck *msg) |
781 | { | 788 | { |
782 | struct CadetClient *c = cls; | 789 | struct CadetClient *c = cls; |
783 | struct CadetChannel *ch; | 790 | struct CadetChannel *ch; |
784 | 791 | ||
785 | ch = lookup_channel(c, | 792 | ch = lookup_channel (c, |
786 | msg->ccn); | 793 | msg->ccn); |
787 | if (NULL == ch) | 794 | if (NULL == ch) |
788 | { | 795 | { |
789 | /* Channel does not exist (anymore) */ | 796 | /* Channel does not exist (anymore) */ |
790 | LOG(GNUNET_ERROR_TYPE_WARNING, | 797 | LOG (GNUNET_ERROR_TYPE_WARNING, |
791 | "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n", | 798 | "Ignoring local ACK for channel %u from client (channel unknown, other endpoint may have disconnected)\n", |
792 | (unsigned int)ntohl(msg->ccn.channel_of_client)); | 799 | (unsigned int) ntohl (msg->ccn.channel_of_client)); |
793 | GNUNET_SERVICE_client_continue(c->client); | 800 | GNUNET_SERVICE_client_continue (c->client); |
794 | return; | 801 | return; |
795 | } | 802 | } |
796 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 803 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
797 | "Got a local ACK from %s for %s\n", | 804 | "Got a local ACK from %s for %s\n", |
798 | GSC_2s(c), | 805 | GSC_2s (c), |
799 | GCCH_2s(ch)); | 806 | GCCH_2s (ch)); |
800 | GCCH_handle_local_ack(ch, | 807 | GCCH_handle_local_ack (ch, |
801 | msg->ccn); | 808 | msg->ccn); |
802 | GNUNET_SERVICE_client_continue(c->client); | 809 | GNUNET_SERVICE_client_continue (c->client); |
803 | } | 810 | } |
804 | 811 | ||
805 | 812 | ||
@@ -812,24 +819,24 @@ handle_local_ack(void *cls, | |||
812 | * @return #GNUNET_YES, to keep iterating. | 819 | * @return #GNUNET_YES, to keep iterating. |
813 | */ | 820 | */ |
814 | static int | 821 | static int |
815 | get_all_peers_iterator(void *cls, | 822 | get_all_peers_iterator (void *cls, |
816 | const struct GNUNET_PeerIdentity *peer, | 823 | const struct GNUNET_PeerIdentity *peer, |
817 | void *value) | 824 | void *value) |
818 | { | 825 | { |
819 | struct CadetClient *c = cls; | 826 | struct CadetClient *c = cls; |
820 | struct CadetPeer *p = value; | 827 | struct CadetPeer *p = value; |
821 | struct GNUNET_MQ_Envelope *env; | 828 | struct GNUNET_MQ_Envelope *env; |
822 | struct GNUNET_CADET_LocalInfoPeers *msg; | 829 | struct GNUNET_CADET_LocalInfoPeers *msg; |
823 | 830 | ||
824 | env = GNUNET_MQ_msg(msg, | 831 | env = GNUNET_MQ_msg (msg, |
825 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS); | 832 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS); |
826 | msg->destination = *peer; | 833 | msg->destination = *peer; |
827 | msg->paths = htons(GCP_count_paths(p)); | 834 | msg->paths = htons (GCP_count_paths (p)); |
828 | msg->tunnel = htons(NULL != GCP_get_tunnel(p, | 835 | msg->tunnel = htons (NULL != GCP_get_tunnel (p, |
829 | GNUNET_NO)); | 836 | GNUNET_NO)); |
830 | msg->best_path_length = htonl(0); // FIXME: get length of shortest known path! | 837 | msg->best_path_length = htonl (0); // FIXME: get length of shortest known path! |
831 | GNUNET_MQ_send(c->mq, | 838 | GNUNET_MQ_send (c->mq, |
832 | env); | 839 | env); |
833 | return GNUNET_YES; | 840 | return GNUNET_YES; |
834 | } | 841 | } |
835 | 842 | ||
@@ -841,20 +848,20 @@ get_all_peers_iterator(void *cls, | |||
841 | * @param message The actual message. | 848 | * @param message The actual message. |
842 | */ | 849 | */ |
843 | static void | 850 | static void |
844 | handle_get_peers(void *cls, | 851 | handle_get_peers (void *cls, |
845 | const struct GNUNET_MessageHeader *message) | 852 | const struct GNUNET_MessageHeader *message) |
846 | { | 853 | { |
847 | struct CadetClient *c = cls; | 854 | struct CadetClient *c = cls; |
848 | struct GNUNET_MQ_Envelope *env; | 855 | struct GNUNET_MQ_Envelope *env; |
849 | struct GNUNET_MessageHeader *reply; | 856 | struct GNUNET_MessageHeader *reply; |
850 | 857 | ||
851 | GCP_iterate_all(&get_all_peers_iterator, | 858 | GCP_iterate_all (&get_all_peers_iterator, |
852 | c); | 859 | c); |
853 | env = GNUNET_MQ_msg(reply, | 860 | env = GNUNET_MQ_msg (reply, |
854 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END); | 861 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END); |
855 | GNUNET_MQ_send(c->mq, | 862 | GNUNET_MQ_send (c->mq, |
856 | env); | 863 | env); |
857 | GNUNET_SERVICE_client_continue(c->client); | 864 | GNUNET_SERVICE_client_continue (c->client); |
858 | } | 865 | } |
859 | 866 | ||
860 | 867 | ||
@@ -869,9 +876,9 @@ handle_get_peers(void *cls, | |||
869 | * #GNUNET_NO otherwise. | 876 | * #GNUNET_NO otherwise. |
870 | */ | 877 | */ |
871 | static int | 878 | static int |
872 | path_info_iterator(void *cls, | 879 | path_info_iterator (void *cls, |
873 | struct CadetPeerPath *path, | 880 | struct CadetPeerPath *path, |
874 | unsigned int off) | 881 | unsigned int off) |
875 | { | 882 | { |
876 | struct GNUNET_MQ_Handle *mq = cls; | 883 | struct GNUNET_MQ_Handle *mq = cls; |
877 | struct GNUNET_MQ_Envelope *env; | 884 | struct GNUNET_MQ_Envelope *env; |
@@ -880,36 +887,37 @@ path_info_iterator(void *cls, | |||
880 | size_t path_size; | 887 | size_t path_size; |
881 | unsigned int path_length; | 888 | unsigned int path_length; |
882 | 889 | ||
883 | path_length = GCPP_get_length(path); | 890 | path_length = GCPP_get_length (path); |
884 | path_size = sizeof(struct GNUNET_PeerIdentity) * path_length; | 891 | path_size = sizeof(struct GNUNET_PeerIdentity) * path_length; |
885 | if (sizeof(*resp) + path_size > UINT16_MAX) | 892 | if (sizeof(*resp) + path_size > UINT16_MAX) |
886 | { | 893 | { |
887 | /* try just giving the relevant path */ | 894 | /* try just giving the relevant path */ |
888 | path_length = GNUNET_MIN((UINT16_MAX - sizeof(*resp)) / sizeof(struct GNUNET_PeerIdentity), | 895 | path_length = GNUNET_MIN ((UINT16_MAX - sizeof(*resp)) / sizeof(struct |
889 | off); | 896 | GNUNET_PeerIdentity), |
890 | path_size = sizeof(struct GNUNET_PeerIdentity) * path_length; | 897 | off); |
891 | } | 898 | path_size = sizeof(struct GNUNET_PeerIdentity) * path_length; |
899 | } | ||
892 | if (sizeof(*resp) + path_size > UINT16_MAX) | 900 | if (sizeof(*resp) + path_size > UINT16_MAX) |
893 | { | 901 | { |
894 | LOG(GNUNET_ERROR_TYPE_WARNING, | 902 | LOG (GNUNET_ERROR_TYPE_WARNING, |
895 | "Path of %u entries is too long for info message\n", | 903 | "Path of %u entries is too long for info message\n", |
896 | path_length); | 904 | path_length); |
897 | return GNUNET_YES; | 905 | return GNUNET_YES; |
898 | } | 906 | } |
899 | env = GNUNET_MQ_msg_extra(resp, | 907 | env = GNUNET_MQ_msg_extra (resp, |
900 | path_size, | 908 | path_size, |
901 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH); | 909 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH); |
902 | id = (struct GNUNET_PeerIdentity *)&resp[1]; | 910 | id = (struct GNUNET_PeerIdentity *) &resp[1]; |
903 | 911 | ||
904 | /* Don't copy first peer. First peer is always the local one. Last | 912 | /* Don't copy first peer. First peer is always the local one. Last |
905 | * peer is always the destination (leave as 0, EOL). | 913 | * peer is always the destination (leave as 0, EOL). |
906 | */ | 914 | */ |
907 | for (unsigned int i = 0; i < path_length; i++) | 915 | for (unsigned int i = 0; i < path_length; i++) |
908 | id[i] = *GCP_get_id(GCPP_get_peer_at_offset(path, | 916 | id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path, |
909 | i)); | 917 | i)); |
910 | resp->off = htonl(off); | 918 | resp->off = htonl (off); |
911 | GNUNET_MQ_send(mq, | 919 | GNUNET_MQ_send (mq, |
912 | env); | 920 | env); |
913 | return GNUNET_YES; | 921 | return GNUNET_YES; |
914 | } | 922 | } |
915 | 923 | ||
@@ -921,25 +929,25 @@ path_info_iterator(void *cls, | |||
921 | * @param msg The actual message. | 929 | * @param msg The actual message. |
922 | */ | 930 | */ |
923 | static void | 931 | static void |
924 | handle_show_path(void *cls, | 932 | handle_show_path (void *cls, |
925 | const struct GNUNET_CADET_RequestPathInfoMessage *msg) | 933 | const struct GNUNET_CADET_RequestPathInfoMessage *msg) |
926 | { | 934 | { |
927 | struct CadetClient *c = cls; | 935 | struct CadetClient *c = cls; |
928 | struct CadetPeer *p; | 936 | struct CadetPeer *p; |
929 | struct GNUNET_MQ_Envelope *env; | 937 | struct GNUNET_MQ_Envelope *env; |
930 | struct GNUNET_MessageHeader *resp; | 938 | struct GNUNET_MessageHeader *resp; |
931 | 939 | ||
932 | p = GCP_get(&msg->peer, | 940 | p = GCP_get (&msg->peer, |
933 | GNUNET_NO); | 941 | GNUNET_NO); |
934 | if (NULL != p) | 942 | if (NULL != p) |
935 | GCP_iterate_indirect_paths(p, | 943 | GCP_iterate_indirect_paths (p, |
936 | &path_info_iterator, | 944 | &path_info_iterator, |
937 | c->mq); | 945 | c->mq); |
938 | env = GNUNET_MQ_msg(resp, | 946 | env = GNUNET_MQ_msg (resp, |
939 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END); | 947 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END); |
940 | GNUNET_MQ_send(c->mq, | 948 | GNUNET_MQ_send (c->mq, |
941 | env); | 949 | env); |
942 | GNUNET_SERVICE_client_continue(c->client); | 950 | GNUNET_SERVICE_client_continue (c->client); |
943 | } | 951 | } |
944 | 952 | ||
945 | 953 | ||
@@ -952,9 +960,9 @@ handle_show_path(void *cls, | |||
952 | * @return #GNUNET_YES, to keep iterating. | 960 | * @return #GNUNET_YES, to keep iterating. |
953 | */ | 961 | */ |
954 | static int | 962 | static int |
955 | get_all_tunnels_iterator(void *cls, | 963 | get_all_tunnels_iterator (void *cls, |
956 | const struct GNUNET_PeerIdentity *peer, | 964 | const struct GNUNET_PeerIdentity *peer, |
957 | void *value) | 965 | void *value) |
958 | { | 966 | { |
959 | struct CadetClient *c = cls; | 967 | struct CadetClient *c = cls; |
960 | struct CadetPeer *p = value; | 968 | struct CadetPeer *p = value; |
@@ -962,19 +970,19 @@ get_all_tunnels_iterator(void *cls, | |||
962 | struct GNUNET_CADET_LocalInfoTunnel *msg; | 970 | struct GNUNET_CADET_LocalInfoTunnel *msg; |
963 | struct CadetTunnel *t; | 971 | struct CadetTunnel *t; |
964 | 972 | ||
965 | t = GCP_get_tunnel(p, | 973 | t = GCP_get_tunnel (p, |
966 | GNUNET_NO); | 974 | GNUNET_NO); |
967 | if (NULL == t) | 975 | if (NULL == t) |
968 | return GNUNET_YES; | 976 | return GNUNET_YES; |
969 | env = GNUNET_MQ_msg(msg, | 977 | env = GNUNET_MQ_msg (msg, |
970 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS); | 978 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS); |
971 | msg->destination = *peer; | 979 | msg->destination = *peer; |
972 | msg->channels = htonl(GCT_count_channels(t)); | 980 | msg->channels = htonl (GCT_count_channels (t)); |
973 | msg->connections = htonl(GCT_count_any_connections(t)); | 981 | msg->connections = htonl (GCT_count_any_connections (t)); |
974 | msg->cstate = htons(0); | 982 | msg->cstate = htons (0); |
975 | msg->estate = htons((uint16_t)GCT_get_estate(t)); | 983 | msg->estate = htons ((uint16_t) GCT_get_estate (t)); |
976 | GNUNET_MQ_send(c->mq, | 984 | GNUNET_MQ_send (c->mq, |
977 | env); | 985 | env); |
978 | return GNUNET_YES; | 986 | return GNUNET_YES; |
979 | } | 987 | } |
980 | 988 | ||
@@ -986,20 +994,20 @@ get_all_tunnels_iterator(void *cls, | |||
986 | * @param message The actual message. | 994 | * @param message The actual message. |
987 | */ | 995 | */ |
988 | static void | 996 | static void |
989 | handle_info_tunnels(void *cls, | 997 | handle_info_tunnels (void *cls, |
990 | const struct GNUNET_MessageHeader *message) | 998 | const struct GNUNET_MessageHeader *message) |
991 | { | 999 | { |
992 | struct CadetClient *c = cls; | 1000 | struct CadetClient *c = cls; |
993 | struct GNUNET_MQ_Envelope *env; | 1001 | struct GNUNET_MQ_Envelope *env; |
994 | struct GNUNET_MessageHeader *reply; | 1002 | struct GNUNET_MessageHeader *reply; |
995 | 1003 | ||
996 | GCP_iterate_all(&get_all_tunnels_iterator, | 1004 | GCP_iterate_all (&get_all_tunnels_iterator, |
997 | c); | 1005 | c); |
998 | env = GNUNET_MQ_msg(reply, | 1006 | env = GNUNET_MQ_msg (reply, |
999 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END); | 1007 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END); |
1000 | GNUNET_MQ_send(c->mq, | 1008 | GNUNET_MQ_send (c->mq, |
1001 | env); | 1009 | env); |
1002 | GNUNET_SERVICE_client_continue(c->client); | 1010 | GNUNET_SERVICE_client_continue (c->client); |
1003 | } | 1011 | } |
1004 | 1012 | ||
1005 | 1013 | ||
@@ -1012,28 +1020,28 @@ handle_info_tunnels(void *cls, | |||
1012 | * @return @a c | 1020 | * @return @a c |
1013 | */ | 1021 | */ |
1014 | static void * | 1022 | static void * |
1015 | client_connect_cb(void *cls, | 1023 | client_connect_cb (void *cls, |
1016 | struct GNUNET_SERVICE_Client *client, | 1024 | struct GNUNET_SERVICE_Client *client, |
1017 | struct GNUNET_MQ_Handle *mq) | 1025 | struct GNUNET_MQ_Handle *mq) |
1018 | { | 1026 | { |
1019 | struct CadetClient *c; | 1027 | struct CadetClient *c; |
1020 | 1028 | ||
1021 | c = GNUNET_new(struct CadetClient); | 1029 | c = GNUNET_new (struct CadetClient); |
1022 | c->client = client; | 1030 | c->client = client; |
1023 | c->mq = mq; | 1031 | c->mq = mq; |
1024 | c->id = next_client_id++; /* overflow not important: just for debug */ | 1032 | c->id = next_client_id++; /* overflow not important: just for debug */ |
1025 | c->channels | 1033 | c->channels |
1026 | = GNUNET_CONTAINER_multihashmap32_create(32); | 1034 | = GNUNET_CONTAINER_multihashmap32_create (32); |
1027 | GNUNET_CONTAINER_DLL_insert(clients_head, | 1035 | GNUNET_CONTAINER_DLL_insert (clients_head, |
1028 | clients_tail, | 1036 | clients_tail, |
1029 | c); | 1037 | c); |
1030 | GNUNET_STATISTICS_update(stats, | 1038 | GNUNET_STATISTICS_update (stats, |
1031 | "# clients", | 1039 | "# clients", |
1032 | +1, | 1040 | +1, |
1033 | GNUNET_NO); | 1041 | GNUNET_NO); |
1034 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1042 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1035 | "%s connected\n", | 1043 | "%s connected\n", |
1036 | GSC_2s(c)); | 1044 | GSC_2s (c)); |
1037 | return c; | 1045 | return c; |
1038 | } | 1046 | } |
1039 | 1047 | ||
@@ -1046,22 +1054,23 @@ client_connect_cb(void *cls, | |||
1046 | * @param ch the channel object | 1054 | * @param ch the channel object |
1047 | */ | 1055 | */ |
1048 | void | 1056 | void |
1049 | GSC_handle_remote_channel_destroy(struct CadetClient *c, | 1057 | GSC_handle_remote_channel_destroy (struct CadetClient *c, |
1050 | struct GNUNET_CADET_ClientChannelNumber ccn, | 1058 | struct GNUNET_CADET_ClientChannelNumber ccn, |
1051 | struct CadetChannel *ch) | 1059 | struct CadetChannel *ch) |
1052 | { | 1060 | { |
1053 | struct GNUNET_MQ_Envelope *env; | 1061 | struct GNUNET_MQ_Envelope *env; |
1054 | struct GNUNET_CADET_LocalChannelDestroyMessage *tdm; | 1062 | struct GNUNET_CADET_LocalChannelDestroyMessage *tdm; |
1055 | 1063 | ||
1056 | env = GNUNET_MQ_msg(tdm, | 1064 | env = GNUNET_MQ_msg (tdm, |
1057 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY); | 1065 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY); |
1058 | tdm->ccn = ccn; | 1066 | tdm->ccn = ccn; |
1059 | GSC_send_to_client(c, | 1067 | GSC_send_to_client (c, |
1060 | env); | 1068 | env); |
1061 | GNUNET_assert(GNUNET_YES == | 1069 | GNUNET_assert (GNUNET_YES == |
1062 | GNUNET_CONTAINER_multihashmap32_remove(c->channels, | 1070 | GNUNET_CONTAINER_multihashmap32_remove (c->channels, |
1063 | ntohl(ccn.channel_of_client), | 1071 | ntohl ( |
1064 | ch)); | 1072 | ccn.channel_of_client), |
1073 | ch)); | ||
1065 | } | 1074 | } |
1066 | 1075 | ||
1067 | 1076 | ||
@@ -1073,13 +1082,13 @@ GSC_handle_remote_channel_destroy(struct CadetClient *c, | |||
1073 | * @param ch the channel that was lost | 1082 | * @param ch the channel that was lost |
1074 | */ | 1083 | */ |
1075 | void | 1084 | void |
1076 | GSC_drop_loose_channel(const struct GNUNET_HashCode *h_port, | 1085 | GSC_drop_loose_channel (const struct GNUNET_HashCode *h_port, |
1077 | struct CadetChannel *ch) | 1086 | struct CadetChannel *ch) |
1078 | { | 1087 | { |
1079 | GNUNET_assert(GNUNET_YES == | 1088 | GNUNET_assert (GNUNET_YES == |
1080 | GNUNET_CONTAINER_multihashmap_remove(loose_channels, | 1089 | GNUNET_CONTAINER_multihashmap_remove (loose_channels, |
1081 | h_port, | 1090 | h_port, |
1082 | ch)); | 1091 | ch)); |
1083 | } | 1092 | } |
1084 | 1093 | ||
1085 | 1094 | ||
@@ -1092,26 +1101,26 @@ GSC_drop_loose_channel(const struct GNUNET_HashCode *h_port, | |||
1092 | * @return #GNUNET_OK, keep iterating. | 1101 | * @return #GNUNET_OK, keep iterating. |
1093 | */ | 1102 | */ |
1094 | static int | 1103 | static int |
1095 | channel_destroy_iterator(void *cls, | 1104 | channel_destroy_iterator (void *cls, |
1096 | uint32_t key, | 1105 | uint32_t key, |
1097 | void *value) | 1106 | void *value) |
1098 | { | 1107 | { |
1099 | struct CadetClient *c = cls; | 1108 | struct CadetClient *c = cls; |
1100 | struct GNUNET_CADET_ClientChannelNumber ccn; | 1109 | struct GNUNET_CADET_ClientChannelNumber ccn; |
1101 | struct CadetChannel *ch = value; | 1110 | struct CadetChannel *ch = value; |
1102 | 1111 | ||
1103 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1112 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1104 | "Destroying %s, due to %s disconnecting.\n", | 1113 | "Destroying %s, due to %s disconnecting.\n", |
1105 | GCCH_2s(ch), | 1114 | GCCH_2s (ch), |
1106 | GSC_2s(c)); | 1115 | GSC_2s (c)); |
1107 | ccn.channel_of_client = htonl(key); | 1116 | ccn.channel_of_client = htonl (key); |
1108 | GCCH_channel_local_destroy(ch, | 1117 | GCCH_channel_local_destroy (ch, |
1109 | c, | 1118 | c, |
1110 | ccn); | 1119 | ccn); |
1111 | GNUNET_assert(GNUNET_YES == | 1120 | GNUNET_assert (GNUNET_YES == |
1112 | GNUNET_CONTAINER_multihashmap32_remove(c->channels, | 1121 | GNUNET_CONTAINER_multihashmap32_remove (c->channels, |
1113 | key, | 1122 | key, |
1114 | ch)); | 1123 | ch)); |
1115 | return GNUNET_OK; | 1124 | return GNUNET_OK; |
1116 | } | 1125 | } |
1117 | 1126 | ||
@@ -1125,27 +1134,27 @@ channel_destroy_iterator(void *cls, | |||
1125 | * @return #GNUNET_OK, keep iterating. | 1134 | * @return #GNUNET_OK, keep iterating. |
1126 | */ | 1135 | */ |
1127 | static int | 1136 | static int |
1128 | client_release_ports(void *cls, | 1137 | client_release_ports (void *cls, |
1129 | const struct GNUNET_HashCode *port, | 1138 | const struct GNUNET_HashCode *port, |
1130 | void *value) | 1139 | void *value) |
1131 | { | 1140 | { |
1132 | struct CadetClient *c = cls; | 1141 | struct CadetClient *c = cls; |
1133 | struct OpenPort *op = value; | 1142 | struct OpenPort *op = value; |
1134 | 1143 | ||
1135 | GNUNET_assert(c == op->c); | 1144 | GNUNET_assert (c == op->c); |
1136 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1145 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1137 | "Closing port %s due to %s disconnect.\n", | 1146 | "Closing port %s due to %s disconnect.\n", |
1138 | GNUNET_h2s(port), | 1147 | GNUNET_h2s (port), |
1139 | GSC_2s(c)); | 1148 | GSC_2s (c)); |
1140 | GNUNET_assert(GNUNET_YES == | 1149 | GNUNET_assert (GNUNET_YES == |
1141 | GNUNET_CONTAINER_multihashmap_remove(open_ports, | 1150 | GNUNET_CONTAINER_multihashmap_remove (open_ports, |
1142 | &op->h_port, | 1151 | &op->h_port, |
1143 | op)); | 1152 | op)); |
1144 | GNUNET_assert(GNUNET_YES == | 1153 | GNUNET_assert (GNUNET_YES == |
1145 | GNUNET_CONTAINER_multihashmap_remove(c->ports, | 1154 | GNUNET_CONTAINER_multihashmap_remove (c->ports, |
1146 | port, | 1155 | port, |
1147 | op)); | 1156 | op)); |
1148 | GNUNET_free(op); | 1157 | GNUNET_free (op); |
1149 | return GNUNET_OK; | 1158 | return GNUNET_OK; |
1150 | } | 1159 | } |
1151 | 1160 | ||
@@ -1158,42 +1167,42 @@ client_release_ports(void *cls, | |||
1158 | * @param internal_cls should be equal to @a c | 1167 | * @param internal_cls should be equal to @a c |
1159 | */ | 1168 | */ |
1160 | static void | 1169 | static void |
1161 | client_disconnect_cb(void *cls, | 1170 | client_disconnect_cb (void *cls, |
1162 | struct GNUNET_SERVICE_Client *client, | 1171 | struct GNUNET_SERVICE_Client *client, |
1163 | void *internal_cls) | 1172 | void *internal_cls) |
1164 | { | 1173 | { |
1165 | struct CadetClient *c = internal_cls; | 1174 | struct CadetClient *c = internal_cls; |
1166 | 1175 | ||
1167 | GNUNET_assert(c->client == client); | 1176 | GNUNET_assert (c->client == client); |
1168 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1177 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1169 | "%s is disconnecting.\n", | 1178 | "%s is disconnecting.\n", |
1170 | GSC_2s(c)); | 1179 | GSC_2s (c)); |
1171 | if (NULL != c->channels) | 1180 | if (NULL != c->channels) |
1172 | { | 1181 | { |
1173 | GNUNET_CONTAINER_multihashmap32_iterate(c->channels, | 1182 | GNUNET_CONTAINER_multihashmap32_iterate (c->channels, |
1174 | &channel_destroy_iterator, | 1183 | &channel_destroy_iterator, |
1175 | c); | 1184 | c); |
1176 | GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap32_size(c->channels)); | 1185 | GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (c->channels)); |
1177 | GNUNET_CONTAINER_multihashmap32_destroy(c->channels); | 1186 | GNUNET_CONTAINER_multihashmap32_destroy (c->channels); |
1178 | } | 1187 | } |
1179 | if (NULL != c->ports) | 1188 | if (NULL != c->ports) |
1180 | { | 1189 | { |
1181 | GNUNET_CONTAINER_multihashmap_iterate(c->ports, | 1190 | GNUNET_CONTAINER_multihashmap_iterate (c->ports, |
1182 | &client_release_ports, | 1191 | &client_release_ports, |
1183 | c); | 1192 | c); |
1184 | GNUNET_CONTAINER_multihashmap_destroy(c->ports); | 1193 | GNUNET_CONTAINER_multihashmap_destroy (c->ports); |
1185 | } | 1194 | } |
1186 | GNUNET_CONTAINER_DLL_remove(clients_head, | 1195 | GNUNET_CONTAINER_DLL_remove (clients_head, |
1187 | clients_tail, | 1196 | clients_tail, |
1188 | c); | 1197 | c); |
1189 | GNUNET_STATISTICS_update(stats, | 1198 | GNUNET_STATISTICS_update (stats, |
1190 | "# clients", | 1199 | "# clients", |
1191 | -1, | 1200 | -1, |
1192 | GNUNET_NO); | 1201 | GNUNET_NO); |
1193 | GNUNET_free(c); | 1202 | GNUNET_free (c); |
1194 | if ((NULL == clients_head) && | 1203 | if ((NULL == clients_head) && |
1195 | (GNUNET_YES == shutting_down)) | 1204 | (GNUNET_YES == shutting_down)) |
1196 | shutdown_rest(); | 1205 | shutdown_rest (); |
1197 | } | 1206 | } |
1198 | 1207 | ||
1199 | 1208 | ||
@@ -1205,92 +1214,92 @@ client_disconnect_cb(void *cls, | |||
1205 | * @param c configuration to use | 1214 | * @param c configuration to use |
1206 | */ | 1215 | */ |
1207 | static void | 1216 | static void |
1208 | run(void *cls, | 1217 | run (void *cls, |
1209 | const struct GNUNET_CONFIGURATION_Handle *c, | 1218 | const struct GNUNET_CONFIGURATION_Handle *c, |
1210 | struct GNUNET_SERVICE_Handle *service) | 1219 | struct GNUNET_SERVICE_Handle *service) |
1211 | { | 1220 | { |
1212 | cfg = c; | 1221 | cfg = c; |
1213 | if (GNUNET_OK != | 1222 | if (GNUNET_OK != |
1214 | GNUNET_CONFIGURATION_get_value_number(c, | 1223 | GNUNET_CONFIGURATION_get_value_number (c, |
1215 | "CADET", | 1224 | "CADET", |
1216 | "RATCHET_MESSAGES", | 1225 | "RATCHET_MESSAGES", |
1217 | &ratchet_messages)) | 1226 | &ratchet_messages)) |
1218 | { | 1227 | { |
1219 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, | 1228 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, |
1220 | "CADET", | 1229 | "CADET", |
1221 | "RATCHET_MESSAGES", | 1230 | "RATCHET_MESSAGES", |
1222 | "needs to be a number"); | 1231 | "needs to be a number"); |
1223 | ratchet_messages = 64; | 1232 | ratchet_messages = 64; |
1224 | } | 1233 | } |
1225 | if (GNUNET_OK != | 1234 | if (GNUNET_OK != |
1226 | GNUNET_CONFIGURATION_get_value_time(c, | 1235 | GNUNET_CONFIGURATION_get_value_time (c, |
1227 | "CADET", | 1236 | "CADET", |
1228 | "RATCHET_TIME", | 1237 | "RATCHET_TIME", |
1229 | &ratchet_time)) | 1238 | &ratchet_time)) |
1230 | { | 1239 | { |
1231 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, | 1240 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, |
1232 | "CADET", | 1241 | "CADET", |
1233 | "RATCHET_TIME", | 1242 | "RATCHET_TIME", |
1234 | "need delay value"); | 1243 | "need delay value"); |
1235 | ratchet_time = GNUNET_TIME_UNIT_HOURS; | 1244 | ratchet_time = GNUNET_TIME_UNIT_HOURS; |
1236 | } | 1245 | } |
1237 | if (GNUNET_OK != | 1246 | if (GNUNET_OK != |
1238 | GNUNET_CONFIGURATION_get_value_time(c, | 1247 | GNUNET_CONFIGURATION_get_value_time (c, |
1239 | "CADET", | 1248 | "CADET", |
1240 | "REFRESH_CONNECTION_TIME", | 1249 | "REFRESH_CONNECTION_TIME", |
1241 | &keepalive_period)) | 1250 | &keepalive_period)) |
1242 | { | 1251 | { |
1243 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, | 1252 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, |
1244 | "CADET", | 1253 | "CADET", |
1245 | "REFRESH_CONNECTION_TIME", | 1254 | "REFRESH_CONNECTION_TIME", |
1246 | "need delay value"); | 1255 | "need delay value"); |
1247 | keepalive_period = GNUNET_TIME_UNIT_MINUTES; | 1256 | keepalive_period = GNUNET_TIME_UNIT_MINUTES; |
1248 | } | 1257 | } |
1249 | if (GNUNET_OK != | 1258 | if (GNUNET_OK != |
1250 | GNUNET_CONFIGURATION_get_value_number(c, | 1259 | GNUNET_CONFIGURATION_get_value_number (c, |
1251 | "CADET", | 1260 | "CADET", |
1252 | "DROP_PERCENT", | 1261 | "DROP_PERCENT", |
1253 | &drop_percent)) | 1262 | &drop_percent)) |
1254 | { | 1263 | { |
1255 | drop_percent = 0; | 1264 | drop_percent = 0; |
1256 | } | 1265 | } |
1257 | else | 1266 | else |
1258 | { | 1267 | { |
1259 | LOG(GNUNET_ERROR_TYPE_WARNING, "**************************************\n"); | 1268 | LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n"); |
1260 | LOG(GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n"); | 1269 | LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n"); |
1261 | LOG(GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n"); | 1270 | LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n"); |
1262 | LOG(GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n"); | 1271 | LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n"); |
1263 | LOG(GNUNET_ERROR_TYPE_WARNING, "**************************************\n"); | 1272 | LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n"); |
1264 | } | 1273 | } |
1265 | my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(c); | 1274 | my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c); |
1266 | if (NULL == my_private_key) | 1275 | if (NULL == my_private_key) |
1267 | { | 1276 | { |
1268 | GNUNET_break(0); | 1277 | GNUNET_break (0); |
1269 | GNUNET_SCHEDULER_shutdown(); | 1278 | GNUNET_SCHEDULER_shutdown (); |
1270 | return; | 1279 | return; |
1271 | } | 1280 | } |
1272 | GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, | 1281 | GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, |
1273 | &my_full_id.public_key); | 1282 | &my_full_id.public_key); |
1274 | stats = GNUNET_STATISTICS_create("cadet", | 1283 | stats = GNUNET_STATISTICS_create ("cadet", |
1275 | c); | 1284 | c); |
1276 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, | 1285 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, |
1277 | NULL); | 1286 | NULL); |
1278 | ats_ch = GNUNET_ATS_connectivity_init(c); | 1287 | ats_ch = GNUNET_ATS_connectivity_init (c); |
1279 | /* FIXME: optimize code to allow GNUNET_YES here! */ | 1288 | /* FIXME: optimize code to allow GNUNET_YES here! */ |
1280 | open_ports = GNUNET_CONTAINER_multihashmap_create(16, | 1289 | open_ports = GNUNET_CONTAINER_multihashmap_create (16, |
1281 | GNUNET_NO); | 1290 | GNUNET_NO); |
1282 | loose_channels = GNUNET_CONTAINER_multihashmap_create(16, | 1291 | loose_channels = GNUNET_CONTAINER_multihashmap_create (16, |
1283 | GNUNET_NO); | 1292 | GNUNET_NO); |
1284 | peers = GNUNET_CONTAINER_multipeermap_create(16, | 1293 | peers = GNUNET_CONTAINER_multipeermap_create (16, |
1285 | GNUNET_YES); | 1294 | GNUNET_YES); |
1286 | connections = GNUNET_CONTAINER_multishortmap_create(256, | 1295 | connections = GNUNET_CONTAINER_multishortmap_create (256, |
1287 | GNUNET_YES); | 1296 | GNUNET_YES); |
1288 | GCH_init(c); | 1297 | GCH_init (c); |
1289 | GCD_init(c); | 1298 | GCD_init (c); |
1290 | GCO_init(c); | 1299 | GCO_init (c); |
1291 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1300 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1292 | "CADET started for peer %s\n", | 1301 | "CADET started for peer %s\n", |
1293 | GNUNET_i2s(&my_full_id)); | 1302 | GNUNET_i2s (&my_full_id)); |
1294 | } | 1303 | } |
1295 | 1304 | ||
1296 | 1305 | ||
@@ -1304,42 +1313,42 @@ GNUNET_SERVICE_MAIN | |||
1304 | &client_connect_cb, | 1313 | &client_connect_cb, |
1305 | &client_disconnect_cb, | 1314 | &client_disconnect_cb, |
1306 | NULL, | 1315 | NULL, |
1307 | GNUNET_MQ_hd_fixed_size(port_open, | 1316 | GNUNET_MQ_hd_fixed_size (port_open, |
1308 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, | 1317 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, |
1309 | struct GNUNET_CADET_PortMessage, | 1318 | struct GNUNET_CADET_PortMessage, |
1310 | NULL), | 1319 | NULL), |
1311 | GNUNET_MQ_hd_fixed_size(port_close, | 1320 | GNUNET_MQ_hd_fixed_size (port_close, |
1312 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE, | 1321 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE, |
1313 | struct GNUNET_CADET_PortMessage, | 1322 | struct GNUNET_CADET_PortMessage, |
1314 | NULL), | 1323 | NULL), |
1315 | GNUNET_MQ_hd_fixed_size(channel_create, | 1324 | GNUNET_MQ_hd_fixed_size (channel_create, |
1316 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, | 1325 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, |
1317 | struct GNUNET_CADET_LocalChannelCreateMessage, | 1326 | struct GNUNET_CADET_LocalChannelCreateMessage, |
1318 | NULL), | 1327 | NULL), |
1319 | GNUNET_MQ_hd_fixed_size(channel_destroy, | 1328 | GNUNET_MQ_hd_fixed_size (channel_destroy, |
1320 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, | 1329 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, |
1321 | struct GNUNET_CADET_LocalChannelDestroyMessage, | 1330 | struct GNUNET_CADET_LocalChannelDestroyMessage, |
1322 | NULL), | 1331 | NULL), |
1323 | GNUNET_MQ_hd_var_size(local_data, | 1332 | GNUNET_MQ_hd_var_size (local_data, |
1324 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, | 1333 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, |
1325 | struct GNUNET_CADET_LocalData, | 1334 | struct GNUNET_CADET_LocalData, |
1326 | NULL), | 1335 | NULL), |
1327 | GNUNET_MQ_hd_fixed_size(local_ack, | 1336 | GNUNET_MQ_hd_fixed_size (local_ack, |
1328 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, | 1337 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, |
1329 | struct GNUNET_CADET_LocalAck, | 1338 | struct GNUNET_CADET_LocalAck, |
1330 | NULL), | 1339 | NULL), |
1331 | GNUNET_MQ_hd_fixed_size(get_peers, | 1340 | GNUNET_MQ_hd_fixed_size (get_peers, |
1332 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS, | 1341 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS, |
1333 | struct GNUNET_MessageHeader, | 1342 | struct GNUNET_MessageHeader, |
1334 | NULL), | 1343 | NULL), |
1335 | GNUNET_MQ_hd_fixed_size(show_path, | 1344 | GNUNET_MQ_hd_fixed_size (show_path, |
1336 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH, | 1345 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH, |
1337 | struct GNUNET_CADET_RequestPathInfoMessage, | 1346 | struct GNUNET_CADET_RequestPathInfoMessage, |
1338 | NULL), | 1347 | NULL), |
1339 | GNUNET_MQ_hd_fixed_size(info_tunnels, | 1348 | GNUNET_MQ_hd_fixed_size (info_tunnels, |
1340 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS, | 1349 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS, |
1341 | struct GNUNET_MessageHeader, | 1350 | struct GNUNET_MessageHeader, |
1342 | NULL), | 1351 | NULL), |
1343 | GNUNET_MQ_handler_end()); | 1352 | GNUNET_MQ_handler_end ()); |
1344 | 1353 | ||
1345 | /* end of gnunet-service-cadet-new.c */ | 1354 | /* end of gnunet-service-cadet-new.c */ |
diff --git a/src/cadet/gnunet-service-cadet.h b/src/cadet/gnunet-service-cadet.h index 8decdba0d..6da0950f1 100644 --- a/src/cadet/gnunet-service-cadet.h +++ b/src/cadet/gnunet-service-cadet.h | |||
@@ -1,4 +1,3 @@ | |||
1 | |||
2 | /* | 1 | /* |
3 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
4 | Copyright (C) 2001-2017 GNUnet e.V. | 3 | Copyright (C) 2001-2017 GNUnet e.V. |
@@ -64,7 +63,8 @@ struct CadetPeerPath; | |||
64 | /** | 63 | /** |
65 | * Entry in a peer path. | 64 | * Entry in a peer path. |
66 | */ | 65 | */ |
67 | struct CadetPeerPathEntry { | 66 | struct CadetPeerPathEntry |
67 | { | ||
68 | /** | 68 | /** |
69 | * DLL of paths where the same @e peer is at the same offset. | 69 | * DLL of paths where the same @e peer is at the same offset. |
70 | */ | 70 | */ |
@@ -103,7 +103,8 @@ struct CadetPeerPathEntry { | |||
103 | /** | 103 | /** |
104 | * Entry in list of connections used by tunnel, with metadata. | 104 | * Entry in list of connections used by tunnel, with metadata. |
105 | */ | 105 | */ |
106 | struct CadetTConnection { | 106 | struct CadetTConnection |
107 | { | ||
107 | /** | 108 | /** |
108 | * Next in DLL. | 109 | * Next in DLL. |
109 | */ | 110 | */ |
@@ -144,7 +145,8 @@ struct CadetTConnection { | |||
144 | /** | 145 | /** |
145 | * Port opened by a client. | 146 | * Port opened by a client. |
146 | */ | 147 | */ |
147 | struct OpenPort { | 148 | struct OpenPort |
149 | { | ||
148 | /** | 150 | /** |
149 | * Client that opened the port. | 151 | * Client that opened the port. |
150 | */ | 152 | */ |
@@ -266,8 +268,8 @@ extern unsigned long long drop_percent; | |||
266 | * @param env envelope with the message | 268 | * @param env envelope with the message |
267 | */ | 269 | */ |
268 | void | 270 | void |
269 | GSC_send_to_client(struct CadetClient *c, | 271 | GSC_send_to_client (struct CadetClient *c, |
270 | struct GNUNET_MQ_Envelope *env); | 272 | struct GNUNET_MQ_Envelope *env); |
271 | 273 | ||
272 | 274 | ||
273 | /** | 275 | /** |
@@ -278,9 +280,9 @@ GSC_send_to_client(struct CadetClient *c, | |||
278 | * @param ch the channel object | 280 | * @param ch the channel object |
279 | */ | 281 | */ |
280 | void | 282 | void |
281 | GSC_handle_remote_channel_destroy(struct CadetClient *c, | 283 | GSC_handle_remote_channel_destroy (struct CadetClient *c, |
282 | struct GNUNET_CADET_ClientChannelNumber ccn, | 284 | struct GNUNET_CADET_ClientChannelNumber ccn, |
283 | struct CadetChannel *ch); | 285 | struct CadetChannel *ch); |
284 | 286 | ||
285 | /** | 287 | /** |
286 | * A client that created a loose channel that was not bound to a port | 288 | * A client that created a loose channel that was not bound to a port |
@@ -290,8 +292,8 @@ GSC_handle_remote_channel_destroy(struct CadetClient *c, | |||
290 | * @param ch the channel that was lost | 292 | * @param ch the channel that was lost |
291 | */ | 293 | */ |
292 | void | 294 | void |
293 | GSC_drop_loose_channel(const struct GNUNET_HashCode *h_port, | 295 | GSC_drop_loose_channel (const struct GNUNET_HashCode *h_port, |
294 | struct CadetChannel *ch); | 296 | struct CadetChannel *ch); |
295 | 297 | ||
296 | 298 | ||
297 | /** | 299 | /** |
@@ -306,11 +308,11 @@ GSC_drop_loose_channel(const struct GNUNET_HashCode *h_port, | |||
306 | * @return local channel number assigned to the new client | 308 | * @return local channel number assigned to the new client |
307 | */ | 309 | */ |
308 | struct GNUNET_CADET_ClientChannelNumber | 310 | struct GNUNET_CADET_ClientChannelNumber |
309 | GSC_bind(struct CadetClient *c, | 311 | GSC_bind (struct CadetClient *c, |
310 | struct CadetChannel *ch, | 312 | struct CadetChannel *ch, |
311 | struct CadetPeer *dest, | 313 | struct CadetPeer *dest, |
312 | const struct GNUNET_HashCode *port, | 314 | const struct GNUNET_HashCode *port, |
313 | uint32_t options); | 315 | uint32_t options); |
314 | 316 | ||
315 | 317 | ||
316 | /** | 318 | /** |
@@ -320,7 +322,7 @@ GSC_bind(struct CadetClient *c, | |||
320 | * @return string for debugging | 322 | * @return string for debugging |
321 | */ | 323 | */ |
322 | const char * | 324 | const char * |
323 | GSC_2s(struct CadetClient *c); | 325 | GSC_2s (struct CadetClient *c); |
324 | 326 | ||
325 | 327 | ||
326 | #endif | 328 | #endif |
diff --git a/src/cadet/gnunet-service-cadet_channel.c b/src/cadet/gnunet-service-cadet_channel.c index dad5325fc..0a261039c 100644 --- a/src/cadet/gnunet-service-cadet_channel.c +++ b/src/cadet/gnunet-service-cadet_channel.c | |||
@@ -41,26 +41,26 @@ | |||
41 | #include "gnunet-service-cadet_tunnels.h" | 41 | #include "gnunet-service-cadet_tunnels.h" |
42 | #include "gnunet-service-cadet_paths.h" | 42 | #include "gnunet-service-cadet_paths.h" |
43 | 43 | ||
44 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-chn", __VA_ARGS__) | 44 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-chn", __VA_ARGS__) |
45 | 45 | ||
46 | /** | 46 | /** |
47 | * How long do we initially wait before retransmitting? | 47 | * How long do we initially wait before retransmitting? |
48 | */ | 48 | */ |
49 | #define CADET_INITIAL_RETRANSMIT_TIME \ | 49 | #define CADET_INITIAL_RETRANSMIT_TIME \ |
50 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250) | 50 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250) |
51 | 51 | ||
52 | /** | 52 | /** |
53 | * How long do we wait before dropping state about incoming | 53 | * How long do we wait before dropping state about incoming |
54 | * connection to closed port? | 54 | * connection to closed port? |
55 | */ | 55 | */ |
56 | #define TIMEOUT_CLOSED_PORT \ | 56 | #define TIMEOUT_CLOSED_PORT \ |
57 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30) | 57 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) |
58 | 58 | ||
59 | /** | 59 | /** |
60 | * How long do we wait at least before retransmitting ever? | 60 | * How long do we wait at least before retransmitting ever? |
61 | */ | 61 | */ |
62 | #define MIN_RTT_DELAY \ | 62 | #define MIN_RTT_DELAY \ |
63 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 75) | 63 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 75) |
64 | 64 | ||
65 | /** | 65 | /** |
66 | * Maximum message ID into the future we accept for out-of-order messages. | 66 | * Maximum message ID into the future we accept for out-of-order messages. |
@@ -78,7 +78,8 @@ | |||
78 | /** | 78 | /** |
79 | * All the states a channel can be in. | 79 | * All the states a channel can be in. |
80 | */ | 80 | */ |
81 | enum CadetChannelState { | 81 | enum CadetChannelState |
82 | { | ||
82 | /** | 83 | /** |
83 | * Uninitialized status, should never appear in operation. | 84 | * Uninitialized status, should never appear in operation. |
84 | */ | 85 | */ |
@@ -107,7 +108,8 @@ enum CadetChannelState { | |||
107 | * Note that we DO use this structure also for unreliable | 108 | * Note that we DO use this structure also for unreliable |
108 | * messages. | 109 | * messages. |
109 | */ | 110 | */ |
110 | struct CadetReliableMessage { | 111 | struct CadetReliableMessage |
112 | { | ||
111 | /** | 113 | /** |
112 | * Double linked list, FIFO style | 114 | * Double linked list, FIFO style |
113 | */ | 115 | */ |
@@ -171,7 +173,8 @@ struct CadetReliableMessage { | |||
171 | /** | 173 | /** |
172 | * List of received out-of-order data messages. | 174 | * List of received out-of-order data messages. |
173 | */ | 175 | */ |
174 | struct CadetOutOfOrderMessage { | 176 | struct CadetOutOfOrderMessage |
177 | { | ||
175 | /** | 178 | /** |
176 | * Double linked list, FIFO style | 179 | * Double linked list, FIFO style |
177 | */ | 180 | */ |
@@ -200,7 +203,8 @@ struct CadetOutOfOrderMessage { | |||
200 | * loopback channel, in which case it has two of these endpoints. | 203 | * loopback channel, in which case it has two of these endpoints. |
201 | * Note that flow control also is required in both directions. | 204 | * Note that flow control also is required in both directions. |
202 | */ | 205 | */ |
203 | struct CadetChannelClient { | 206 | struct CadetChannelClient |
207 | { | ||
204 | /** | 208 | /** |
205 | * Client handle. Not by itself sufficient to designate | 209 | * Client handle. Not by itself sufficient to designate |
206 | * the client endpoint, as the same client handle may | 210 | * the client endpoint, as the same client handle may |
@@ -241,7 +245,8 @@ struct CadetChannelClient { | |||
241 | /** | 245 | /** |
242 | * Struct containing all information regarding a channel to a remote client. | 246 | * Struct containing all information regarding a channel to a remote client. |
243 | */ | 247 | */ |
244 | struct CadetChannel { | 248 | struct CadetChannel |
249 | { | ||
245 | /** | 250 | /** |
246 | * Tunnel this channel is in. | 251 | * Tunnel this channel is in. |
247 | */ | 252 | */ |
@@ -386,24 +391,24 @@ struct CadetChannel { | |||
386 | * @return Static string with the channel IDs. | 391 | * @return Static string with the channel IDs. |
387 | */ | 392 | */ |
388 | const char * | 393 | const char * |
389 | GCCH_2s(const struct CadetChannel *ch) | 394 | GCCH_2s (const struct CadetChannel *ch) |
390 | { | 395 | { |
391 | static char buf[128]; | 396 | static char buf[128]; |
392 | 397 | ||
393 | GNUNET_snprintf(buf, | 398 | GNUNET_snprintf (buf, |
394 | sizeof(buf), | 399 | sizeof(buf), |
395 | "Channel %s:%s ctn:%X(%X/%X)", | 400 | "Channel %s:%s ctn:%X(%X/%X)", |
396 | (GNUNET_YES == ch->is_loopback) | 401 | (GNUNET_YES == ch->is_loopback) |
397 | ? "loopback" | 402 | ? "loopback" |
398 | : GNUNET_i2s(GCP_get_id(GCT_get_destination(ch->t))), | 403 | : GNUNET_i2s (GCP_get_id (GCT_get_destination (ch->t))), |
399 | GNUNET_h2s(&ch->port), | 404 | GNUNET_h2s (&ch->port), |
400 | ch->ctn, | 405 | ch->ctn, |
401 | (NULL == ch->owner) | 406 | (NULL == ch->owner) |
402 | ? 0 | 407 | ? 0 |
403 | : ntohl(ch->owner->ccn.channel_of_client), | 408 | : ntohl (ch->owner->ccn.channel_of_client), |
404 | (NULL == ch->dest) | 409 | (NULL == ch->dest) |
405 | ? 0 | 410 | ? 0 |
406 | : ntohl(ch->dest->ccn.channel_of_client)); | 411 | : ntohl (ch->dest->ccn.channel_of_client)); |
407 | return buf; | 412 | return buf; |
408 | } | 413 | } |
409 | 414 | ||
@@ -418,19 +423,19 @@ GCCH_2s(const struct CadetChannel *ch) | |||
418 | * @param listener peer that is listining on @a port | 423 | * @param listener peer that is listining on @a port |
419 | */ | 424 | */ |
420 | void | 425 | void |
421 | GCCH_hash_port(struct GNUNET_HashCode *h_port, | 426 | GCCH_hash_port (struct GNUNET_HashCode *h_port, |
422 | const struct GNUNET_HashCode *port, | 427 | const struct GNUNET_HashCode *port, |
423 | const struct GNUNET_PeerIdentity *listener) | 428 | const struct GNUNET_PeerIdentity *listener) |
424 | { | 429 | { |
425 | struct GNUNET_HashContext *hc; | 430 | struct GNUNET_HashContext *hc; |
426 | 431 | ||
427 | hc = GNUNET_CRYPTO_hash_context_start(); | 432 | hc = GNUNET_CRYPTO_hash_context_start (); |
428 | GNUNET_CRYPTO_hash_context_read(hc, port, sizeof(*port)); | 433 | GNUNET_CRYPTO_hash_context_read (hc, port, sizeof(*port)); |
429 | GNUNET_CRYPTO_hash_context_read(hc, listener, sizeof(*listener)); | 434 | GNUNET_CRYPTO_hash_context_read (hc, listener, sizeof(*listener)); |
430 | GNUNET_CRYPTO_hash_context_finish(hc, h_port); | 435 | GNUNET_CRYPTO_hash_context_finish (hc, h_port); |
431 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 436 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
432 | "Calculated port hash %s\n", | 437 | "Calculated port hash %s\n", |
433 | GNUNET_h2s(h_port)); | 438 | GNUNET_h2s (h_port)); |
434 | } | 439 | } |
435 | 440 | ||
436 | 441 | ||
@@ -442,7 +447,7 @@ GCCH_hash_port(struct GNUNET_HashCode *h_port, | |||
442 | * @return ID used to identify the channel with the remote peer. | 447 | * @return ID used to identify the channel with the remote peer. |
443 | */ | 448 | */ |
444 | struct GNUNET_CADET_ChannelTunnelNumber | 449 | struct GNUNET_CADET_ChannelTunnelNumber |
445 | GCCH_get_id(const struct CadetChannel *ch) | 450 | GCCH_get_id (const struct CadetChannel *ch) |
446 | { | 451 | { |
447 | return ch->ctn; | 452 | return ch->ctn; |
448 | } | 453 | } |
@@ -454,18 +459,18 @@ GCCH_get_id(const struct CadetChannel *ch) | |||
454 | * @param ccc data structure to clean up | 459 | * @param ccc data structure to clean up |
455 | */ | 460 | */ |
456 | static void | 461 | static void |
457 | free_channel_client(struct CadetChannelClient *ccc) | 462 | free_channel_client (struct CadetChannelClient *ccc) |
458 | { | 463 | { |
459 | struct CadetOutOfOrderMessage *com; | 464 | struct CadetOutOfOrderMessage *com; |
460 | 465 | ||
461 | while (NULL != (com = ccc->head_recv)) | 466 | while (NULL != (com = ccc->head_recv)) |
462 | { | 467 | { |
463 | GNUNET_CONTAINER_DLL_remove(ccc->head_recv, ccc->tail_recv, com); | 468 | GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com); |
464 | ccc->num_recv--; | 469 | ccc->num_recv--; |
465 | GNUNET_MQ_discard(com->env); | 470 | GNUNET_MQ_discard (com->env); |
466 | GNUNET_free(com); | 471 | GNUNET_free (com); |
467 | } | 472 | } |
468 | GNUNET_free(ccc); | 473 | GNUNET_free (ccc); |
469 | } | 474 | } |
470 | 475 | ||
471 | 476 | ||
@@ -475,57 +480,57 @@ free_channel_client(struct CadetChannelClient *ccc) | |||
475 | * @param ch channel to destroy | 480 | * @param ch channel to destroy |
476 | */ | 481 | */ |
477 | static void | 482 | static void |
478 | channel_destroy(struct CadetChannel *ch) | 483 | channel_destroy (struct CadetChannel *ch) |
479 | { | 484 | { |
480 | struct CadetReliableMessage *crm; | 485 | struct CadetReliableMessage *crm; |
481 | 486 | ||
482 | while (NULL != (crm = ch->head_sent)) | 487 | while (NULL != (crm = ch->head_sent)) |
488 | { | ||
489 | GNUNET_assert (ch == crm->ch); | ||
490 | if (NULL != crm->qe) | ||
483 | { | 491 | { |
484 | GNUNET_assert(ch == crm->ch); | 492 | GCT_send_cancel (crm->qe); |
485 | if (NULL != crm->qe) | 493 | crm->qe = NULL; |
486 | { | ||
487 | GCT_send_cancel(crm->qe); | ||
488 | crm->qe = NULL; | ||
489 | } | ||
490 | GNUNET_CONTAINER_DLL_remove(ch->head_sent, ch->tail_sent, crm); | ||
491 | GNUNET_free(crm->data_message); | ||
492 | GNUNET_free(crm); | ||
493 | } | 494 | } |
495 | GNUNET_CONTAINER_DLL_remove (ch->head_sent, ch->tail_sent, crm); | ||
496 | GNUNET_free (crm->data_message); | ||
497 | GNUNET_free (crm); | ||
498 | } | ||
494 | if (CADET_CHANNEL_LOOSE == ch->state) | 499 | if (CADET_CHANNEL_LOOSE == ch->state) |
495 | { | 500 | { |
496 | GSC_drop_loose_channel(&ch->h_port, ch); | 501 | GSC_drop_loose_channel (&ch->h_port, ch); |
497 | } | 502 | } |
498 | if (NULL != ch->owner) | 503 | if (NULL != ch->owner) |
499 | { | 504 | { |
500 | free_channel_client(ch->owner); | 505 | free_channel_client (ch->owner); |
501 | ch->owner = NULL; | 506 | ch->owner = NULL; |
502 | } | 507 | } |
503 | if (NULL != ch->dest) | 508 | if (NULL != ch->dest) |
504 | { | 509 | { |
505 | free_channel_client(ch->dest); | 510 | free_channel_client (ch->dest); |
506 | ch->dest = NULL; | 511 | ch->dest = NULL; |
507 | } | 512 | } |
508 | if (NULL != ch->last_control_qe) | 513 | if (NULL != ch->last_control_qe) |
509 | { | 514 | { |
510 | GCT_send_cancel(ch->last_control_qe); | 515 | GCT_send_cancel (ch->last_control_qe); |
511 | ch->last_control_qe = NULL; | 516 | ch->last_control_qe = NULL; |
512 | } | 517 | } |
513 | if (NULL != ch->retry_data_task) | 518 | if (NULL != ch->retry_data_task) |
514 | { | 519 | { |
515 | GNUNET_SCHEDULER_cancel(ch->retry_data_task); | 520 | GNUNET_SCHEDULER_cancel (ch->retry_data_task); |
516 | ch->retry_data_task = NULL; | 521 | ch->retry_data_task = NULL; |
517 | } | 522 | } |
518 | if (NULL != ch->retry_control_task) | 523 | if (NULL != ch->retry_control_task) |
519 | { | 524 | { |
520 | GNUNET_SCHEDULER_cancel(ch->retry_control_task); | 525 | GNUNET_SCHEDULER_cancel (ch->retry_control_task); |
521 | ch->retry_control_task = NULL; | 526 | ch->retry_control_task = NULL; |
522 | } | 527 | } |
523 | if (GNUNET_NO == ch->is_loopback) | 528 | if (GNUNET_NO == ch->is_loopback) |
524 | { | 529 | { |
525 | GCT_remove_channel(ch->t, ch, ch->ctn); | 530 | GCT_remove_channel (ch->t, ch, ch->ctn); |
526 | ch->t = NULL; | 531 | ch->t = NULL; |
527 | } | 532 | } |
528 | GNUNET_free(ch); | 533 | GNUNET_free (ch); |
529 | } | 534 | } |
530 | 535 | ||
531 | 536 | ||
@@ -535,7 +540,7 @@ channel_destroy(struct CadetChannel *ch) | |||
535 | * @param cls Channel for which to send. | 540 | * @param cls Channel for which to send. |
536 | */ | 541 | */ |
537 | static void | 542 | static void |
538 | send_channel_open(void *cls); | 543 | send_channel_open (void *cls); |
539 | 544 | ||
540 | 545 | ||
541 | /** | 546 | /** |
@@ -547,20 +552,20 @@ send_channel_open(void *cls); | |||
547 | * if transmission failed | 552 | * if transmission failed |
548 | */ | 553 | */ |
549 | static void | 554 | static void |
550 | channel_open_sent_cb(void *cls, | 555 | channel_open_sent_cb (void *cls, |
551 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 556 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
552 | { | 557 | { |
553 | struct CadetChannel *ch = cls; | 558 | struct CadetChannel *ch = cls; |
554 | 559 | ||
555 | GNUNET_assert(NULL != ch->last_control_qe); | 560 | GNUNET_assert (NULL != ch->last_control_qe); |
556 | ch->last_control_qe = NULL; | 561 | ch->last_control_qe = NULL; |
557 | ch->retry_time = GNUNET_TIME_STD_BACKOFF(ch->retry_time); | 562 | ch->retry_time = GNUNET_TIME_STD_BACKOFF (ch->retry_time); |
558 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 563 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
559 | "Sent CADET_CHANNEL_OPEN on %s, retrying in %s\n", | 564 | "Sent CADET_CHANNEL_OPEN on %s, retrying in %s\n", |
560 | GCCH_2s(ch), | 565 | GCCH_2s (ch), |
561 | GNUNET_STRINGS_relative_time_to_string(ch->retry_time, GNUNET_YES)); | 566 | GNUNET_STRINGS_relative_time_to_string (ch->retry_time, GNUNET_YES)); |
562 | ch->retry_control_task = | 567 | ch->retry_control_task = |
563 | GNUNET_SCHEDULER_add_delayed(ch->retry_time, &send_channel_open, ch); | 568 | GNUNET_SCHEDULER_add_delayed (ch->retry_time, &send_channel_open, ch); |
564 | } | 569 | } |
565 | 570 | ||
566 | 571 | ||
@@ -570,27 +575,27 @@ channel_open_sent_cb(void *cls, | |||
570 | * @param cls Channel for which to send. | 575 | * @param cls Channel for which to send. |
571 | */ | 576 | */ |
572 | static void | 577 | static void |
573 | send_channel_open(void *cls) | 578 | send_channel_open (void *cls) |
574 | { | 579 | { |
575 | struct CadetChannel *ch = cls; | 580 | struct CadetChannel *ch = cls; |
576 | struct GNUNET_CADET_ChannelOpenMessage msgcc; | 581 | struct GNUNET_CADET_ChannelOpenMessage msgcc; |
577 | 582 | ||
578 | ch->retry_control_task = NULL; | 583 | ch->retry_control_task = NULL; |
579 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 584 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
580 | "Sending CHANNEL_OPEN message for %s\n", | 585 | "Sending CHANNEL_OPEN message for %s\n", |
581 | GCCH_2s(ch)); | 586 | GCCH_2s (ch)); |
582 | msgcc.header.size = htons(sizeof(msgcc)); | 587 | msgcc.header.size = htons (sizeof(msgcc)); |
583 | msgcc.header.type = htons(GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN); | 588 | msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN); |
584 | //TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated "reliable" bit here that was removed. | 589 | // TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated "reliable" bit here that was removed. |
585 | msgcc.opt = 2; | 590 | msgcc.opt = 2; |
586 | msgcc.h_port = ch->h_port; | 591 | msgcc.h_port = ch->h_port; |
587 | msgcc.ctn = ch->ctn; | 592 | msgcc.ctn = ch->ctn; |
588 | ch->state = CADET_CHANNEL_OPEN_SENT; | 593 | ch->state = CADET_CHANNEL_OPEN_SENT; |
589 | if (NULL != ch->last_control_qe) | 594 | if (NULL != ch->last_control_qe) |
590 | GCT_send_cancel(ch->last_control_qe); | 595 | GCT_send_cancel (ch->last_control_qe); |
591 | ch->last_control_qe = | 596 | ch->last_control_qe = |
592 | GCT_send(ch->t, &msgcc.header, &channel_open_sent_cb, ch); | 597 | GCT_send (ch->t, &msgcc.header, &channel_open_sent_cb, ch); |
593 | GNUNET_assert(NULL == ch->retry_control_task); | 598 | GNUNET_assert (NULL == ch->retry_control_task); |
594 | } | 599 | } |
595 | 600 | ||
596 | 601 | ||
@@ -605,13 +610,13 @@ send_channel_open(void *cls) | |||
605 | * @param ch the channel for which the tunnel is now ready | 610 | * @param ch the channel for which the tunnel is now ready |
606 | */ | 611 | */ |
607 | void | 612 | void |
608 | GCCH_tunnel_up(struct CadetChannel *ch) | 613 | GCCH_tunnel_up (struct CadetChannel *ch) |
609 | { | 614 | { |
610 | GNUNET_assert(NULL == ch->retry_control_task); | 615 | GNUNET_assert (NULL == ch->retry_control_task); |
611 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 616 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
612 | "Tunnel up, sending CHANNEL_OPEN on %s now\n", | 617 | "Tunnel up, sending CHANNEL_OPEN on %s now\n", |
613 | GCCH_2s(ch)); | 618 | GCCH_2s (ch)); |
614 | ch->retry_control_task = GNUNET_SCHEDULER_add_now(&send_channel_open, ch); | 619 | ch->retry_control_task = GNUNET_SCHEDULER_add_now (&send_channel_open, ch); |
615 | } | 620 | } |
616 | 621 | ||
617 | 622 | ||
@@ -626,22 +631,22 @@ GCCH_tunnel_up(struct CadetChannel *ch) | |||
626 | * @return handle to the new channel | 631 | * @return handle to the new channel |
627 | */ | 632 | */ |
628 | struct CadetChannel * | 633 | struct CadetChannel * |
629 | GCCH_channel_local_new(struct CadetClient *owner, | 634 | GCCH_channel_local_new (struct CadetClient *owner, |
630 | struct GNUNET_CADET_ClientChannelNumber ccn, | 635 | struct GNUNET_CADET_ClientChannelNumber ccn, |
631 | struct CadetPeer *destination, | 636 | struct CadetPeer *destination, |
632 | const struct GNUNET_HashCode *port, | 637 | const struct GNUNET_HashCode *port, |
633 | uint32_t options) | 638 | uint32_t options) |
634 | { | 639 | { |
635 | struct CadetChannel *ch; | 640 | struct CadetChannel *ch; |
636 | struct CadetChannelClient *ccco; | 641 | struct CadetChannelClient *ccco; |
637 | 642 | ||
638 | ccco = GNUNET_new(struct CadetChannelClient); | 643 | ccco = GNUNET_new (struct CadetChannelClient); |
639 | ccco->c = owner; | 644 | ccco->c = owner; |
640 | ccco->ccn = ccn; | 645 | ccco->ccn = ccn; |
641 | ccco->client_ready = GNUNET_YES; | 646 | ccco->client_ready = GNUNET_YES; |
642 | 647 | ||
643 | ch = GNUNET_new(struct CadetChannel); | 648 | ch = GNUNET_new (struct CadetChannel); |
644 | ch->mid_recv.mid = htonl(1); /* The OPEN_ACK counts as message 0! */ | 649 | ch->mid_recv.mid = htonl (1); /* The OPEN_ACK counts as message 0! */ |
645 | ch->nobuffer = GNUNET_NO; | 650 | ch->nobuffer = GNUNET_NO; |
646 | ch->reliable = GNUNET_YES; | 651 | ch->reliable = GNUNET_YES; |
647 | ch->out_of_order = GNUNET_NO; | 652 | ch->out_of_order = GNUNET_NO; |
@@ -649,44 +654,44 @@ GCCH_channel_local_new(struct CadetClient *owner, | |||
649 | (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */ | 654 | (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */ |
650 | ch->owner = ccco; | 655 | ch->owner = ccco; |
651 | ch->port = *port; | 656 | ch->port = *port; |
652 | GCCH_hash_port(&ch->h_port, port, GCP_get_id(destination)); | 657 | GCCH_hash_port (&ch->h_port, port, GCP_get_id (destination)); |
653 | if (0 == GNUNET_memcmp(&my_full_id, GCP_get_id(destination))) | 658 | if (0 == GNUNET_memcmp (&my_full_id, GCP_get_id (destination))) |
659 | { | ||
660 | struct OpenPort *op; | ||
661 | |||
662 | ch->is_loopback = GNUNET_YES; | ||
663 | op = GNUNET_CONTAINER_multihashmap_get (open_ports, &ch->h_port); | ||
664 | if (NULL == op) | ||
654 | { | 665 | { |
655 | struct OpenPort *op; | 666 | /* port closed, wait for it to possibly open */ |
656 | 667 | ch->state = CADET_CHANNEL_LOOSE; | |
657 | ch->is_loopback = GNUNET_YES; | 668 | (void) GNUNET_CONTAINER_multihashmap_put ( |
658 | op = GNUNET_CONTAINER_multihashmap_get(open_ports, &ch->h_port); | 669 | loose_channels, |
659 | if (NULL == op) | 670 | &ch->h_port, |
660 | { | 671 | ch, |
661 | /* port closed, wait for it to possibly open */ | 672 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
662 | ch->state = CADET_CHANNEL_LOOSE; | 673 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
663 | (void)GNUNET_CONTAINER_multihashmap_put( | 674 | "Created loose incoming loopback channel to port %s\n", |
664 | loose_channels, | 675 | GNUNET_h2s (&ch->port)); |
665 | &ch->h_port, | ||
666 | ch, | ||
667 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | ||
668 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
669 | "Created loose incoming loopback channel to port %s\n", | ||
670 | GNUNET_h2s(&ch->port)); | ||
671 | } | ||
672 | else | ||
673 | { | ||
674 | GCCH_bind(ch, op->c, &op->port); | ||
675 | } | ||
676 | } | 676 | } |
677 | else | 677 | else |
678 | { | 678 | { |
679 | ch->t = GCP_get_tunnel(destination, GNUNET_YES); | 679 | GCCH_bind (ch, op->c, &op->port); |
680 | ch->retry_time = CADET_INITIAL_RETRANSMIT_TIME; | ||
681 | ch->ctn = GCT_add_channel(ch->t, ch); | ||
682 | } | 680 | } |
683 | GNUNET_STATISTICS_update(stats, "# channels", 1, GNUNET_NO); | 681 | } |
684 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 682 | else |
685 | "Created channel to port %s at peer %s for %s using %s\n", | 683 | { |
686 | GNUNET_h2s(port), | 684 | ch->t = GCP_get_tunnel (destination, GNUNET_YES); |
687 | GCP_2s(destination), | 685 | ch->retry_time = CADET_INITIAL_RETRANSMIT_TIME; |
688 | GSC_2s(owner), | 686 | ch->ctn = GCT_add_channel (ch->t, ch); |
689 | (GNUNET_YES == ch->is_loopback) ? "loopback" : GCT_2s(ch->t)); | 687 | } |
688 | GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO); | ||
689 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
690 | "Created channel to port %s at peer %s for %s using %s\n", | ||
691 | GNUNET_h2s (port), | ||
692 | GCP_2s (destination), | ||
693 | GSC_2s (owner), | ||
694 | (GNUNET_YES == ch->is_loopback) ? "loopback" : GCT_2s (ch->t)); | ||
690 | return ch; | 695 | return ch; |
691 | } | 696 | } |
692 | 697 | ||
@@ -698,16 +703,16 @@ GCCH_channel_local_new(struct CadetClient *owner, | |||
698 | * @param cls the channel to drop | 703 | * @param cls the channel to drop |
699 | */ | 704 | */ |
700 | static void | 705 | static void |
701 | timeout_closed_cb(void *cls) | 706 | timeout_closed_cb (void *cls) |
702 | { | 707 | { |
703 | struct CadetChannel *ch = cls; | 708 | struct CadetChannel *ch = cls; |
704 | 709 | ||
705 | ch->retry_control_task = NULL; | 710 | ch->retry_control_task = NULL; |
706 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 711 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
707 | "Closing incoming channel to port %s from peer %s due to timeout\n", | 712 | "Closing incoming channel to port %s from peer %s due to timeout\n", |
708 | GNUNET_h2s(&ch->port), | 713 | GNUNET_h2s (&ch->port), |
709 | GCP_2s(GCT_get_destination(ch->t))); | 714 | GCP_2s (GCT_get_destination (ch->t))); |
710 | channel_destroy(ch); | 715 | channel_destroy (ch); |
711 | } | 716 | } |
712 | 717 | ||
713 | 718 | ||
@@ -721,15 +726,15 @@ timeout_closed_cb(void *cls) | |||
721 | * @return handle to the new channel | 726 | * @return handle to the new channel |
722 | */ | 727 | */ |
723 | struct CadetChannel * | 728 | struct CadetChannel * |
724 | GCCH_channel_incoming_new(struct CadetTunnel *t, | 729 | GCCH_channel_incoming_new (struct CadetTunnel *t, |
725 | struct GNUNET_CADET_ChannelTunnelNumber ctn, | 730 | struct GNUNET_CADET_ChannelTunnelNumber ctn, |
726 | const struct GNUNET_HashCode *h_port, | 731 | const struct GNUNET_HashCode *h_port, |
727 | uint32_t options) | 732 | uint32_t options) |
728 | { | 733 | { |
729 | struct CadetChannel *ch; | 734 | struct CadetChannel *ch; |
730 | struct OpenPort *op; | 735 | struct OpenPort *op; |
731 | 736 | ||
732 | ch = GNUNET_new(struct CadetChannel); | 737 | ch = GNUNET_new (struct CadetChannel); |
733 | ch->h_port = *h_port; | 738 | ch->h_port = *h_port; |
734 | ch->t = t; | 739 | ch->t = t; |
735 | ch->ctn = ctn; | 740 | ch->ctn = ctn; |
@@ -739,32 +744,32 @@ GCCH_channel_incoming_new(struct CadetTunnel *t, | |||
739 | ch->out_of_order = GNUNET_NO; | 744 | ch->out_of_order = GNUNET_NO; |
740 | ch->max_pending_messages = | 745 | ch->max_pending_messages = |
741 | (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */ | 746 | (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */ |
742 | GNUNET_STATISTICS_update(stats, "# channels", 1, GNUNET_NO); | 747 | GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO); |
743 | 748 | ||
744 | op = GNUNET_CONTAINER_multihashmap_get(open_ports, h_port); | 749 | op = GNUNET_CONTAINER_multihashmap_get (open_ports, h_port); |
745 | if (NULL == op) | 750 | if (NULL == op) |
746 | { | 751 | { |
747 | /* port closed, wait for it to possibly open */ | 752 | /* port closed, wait for it to possibly open */ |
748 | ch->state = CADET_CHANNEL_LOOSE; | 753 | ch->state = CADET_CHANNEL_LOOSE; |
749 | (void)GNUNET_CONTAINER_multihashmap_put( | 754 | (void) GNUNET_CONTAINER_multihashmap_put ( |
750 | loose_channels, | 755 | loose_channels, |
751 | &ch->h_port, | 756 | &ch->h_port, |
752 | ch, | 757 | ch, |
753 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 758 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
754 | GNUNET_assert(NULL == ch->retry_control_task); | 759 | GNUNET_assert (NULL == ch->retry_control_task); |
755 | ch->retry_control_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT_CLOSED_PORT, | 760 | ch->retry_control_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_CLOSED_PORT, |
756 | &timeout_closed_cb, | 761 | &timeout_closed_cb, |
757 | ch); | 762 | ch); |
758 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 763 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
759 | "Created loose incoming channel to port %s from peer %s\n", | 764 | "Created loose incoming channel to port %s from peer %s\n", |
760 | GNUNET_h2s(&ch->port), | 765 | GNUNET_h2s (&ch->port), |
761 | GCP_2s(GCT_get_destination(ch->t))); | 766 | GCP_2s (GCT_get_destination (ch->t))); |
762 | } | 767 | } |
763 | else | 768 | else |
764 | { | 769 | { |
765 | GCCH_bind(ch, op->c, &op->port); | 770 | GCCH_bind (ch, op->c, &op->port); |
766 | } | 771 | } |
767 | GNUNET_STATISTICS_update(stats, "# channels", 1, GNUNET_NO); | 772 | GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO); |
768 | return ch; | 773 | return ch; |
769 | } | 774 | } |
770 | 775 | ||
@@ -779,12 +784,12 @@ GCCH_channel_incoming_new(struct CadetTunnel *t, | |||
779 | * if transmission failed | 784 | * if transmission failed |
780 | */ | 785 | */ |
781 | static void | 786 | static void |
782 | send_ack_cb(void *cls, | 787 | send_ack_cb (void *cls, |
783 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 788 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
784 | { | 789 | { |
785 | struct CadetChannel *ch = cls; | 790 | struct CadetChannel *ch = cls; |
786 | 791 | ||
787 | GNUNET_assert(NULL != ch->last_control_qe); | 792 | GNUNET_assert (NULL != ch->last_control_qe); |
788 | ch->last_control_qe = NULL; | 793 | ch->last_control_qe = NULL; |
789 | } | 794 | } |
790 | 795 | ||
@@ -795,25 +800,25 @@ send_ack_cb(void *cls, | |||
795 | * @param ch channel to send the #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK for | 800 | * @param ch channel to send the #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK for |
796 | */ | 801 | */ |
797 | static void | 802 | static void |
798 | send_channel_data_ack(struct CadetChannel *ch) | 803 | send_channel_data_ack (struct CadetChannel *ch) |
799 | { | 804 | { |
800 | struct GNUNET_CADET_ChannelDataAckMessage msg; | 805 | struct GNUNET_CADET_ChannelDataAckMessage msg; |
801 | 806 | ||
802 | if (GNUNET_NO == ch->reliable) | 807 | if (GNUNET_NO == ch->reliable) |
803 | return; /* no ACKs */ | 808 | return; /* no ACKs */ |
804 | msg.header.type = htons(GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK); | 809 | msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK); |
805 | msg.header.size = htons(sizeof(msg)); | 810 | msg.header.size = htons (sizeof(msg)); |
806 | msg.ctn = ch->ctn; | 811 | msg.ctn = ch->ctn; |
807 | msg.mid.mid = htonl(ntohl(ch->mid_recv.mid)); | 812 | msg.mid.mid = htonl (ntohl (ch->mid_recv.mid)); |
808 | msg.futures = GNUNET_htonll(ch->mid_futures); | 813 | msg.futures = GNUNET_htonll (ch->mid_futures); |
809 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 814 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
810 | "Sending DATA_ACK %u:%llX via %s\n", | 815 | "Sending DATA_ACK %u:%llX via %s\n", |
811 | (unsigned int)ntohl(msg.mid.mid), | 816 | (unsigned int) ntohl (msg.mid.mid), |
812 | (unsigned long long)ch->mid_futures, | 817 | (unsigned long long) ch->mid_futures, |
813 | GCCH_2s(ch)); | 818 | GCCH_2s (ch)); |
814 | if (NULL != ch->last_control_qe) | 819 | if (NULL != ch->last_control_qe) |
815 | GCT_send_cancel(ch->last_control_qe); | 820 | GCT_send_cancel (ch->last_control_qe); |
816 | ch->last_control_qe = GCT_send(ch->t, &msg.header, &send_ack_cb, ch); | 821 | ch->last_control_qe = GCT_send (ch->t, &msg.header, &send_ack_cb, ch); |
817 | } | 822 | } |
818 | 823 | ||
819 | 824 | ||
@@ -824,23 +829,23 @@ send_channel_data_ack(struct CadetChannel *ch) | |||
824 | * @param cls the `struct CadetChannel` | 829 | * @param cls the `struct CadetChannel` |
825 | */ | 830 | */ |
826 | static void | 831 | static void |
827 | send_open_ack(void *cls) | 832 | send_open_ack (void *cls) |
828 | { | 833 | { |
829 | struct CadetChannel *ch = cls; | 834 | struct CadetChannel *ch = cls; |
830 | struct GNUNET_CADET_ChannelOpenAckMessage msg; | 835 | struct GNUNET_CADET_ChannelOpenAckMessage msg; |
831 | 836 | ||
832 | ch->retry_control_task = NULL; | 837 | ch->retry_control_task = NULL; |
833 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 838 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
834 | "Sending CHANNEL_OPEN_ACK on %s\n", | 839 | "Sending CHANNEL_OPEN_ACK on %s\n", |
835 | GCCH_2s(ch)); | 840 | GCCH_2s (ch)); |
836 | msg.header.type = htons(GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK); | 841 | msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK); |
837 | msg.header.size = htons(sizeof(msg)); | 842 | msg.header.size = htons (sizeof(msg)); |
838 | msg.reserved = htonl(0); | 843 | msg.reserved = htonl (0); |
839 | msg.ctn = ch->ctn; | 844 | msg.ctn = ch->ctn; |
840 | msg.port = ch->port; | 845 | msg.port = ch->port; |
841 | if (NULL != ch->last_control_qe) | 846 | if (NULL != ch->last_control_qe) |
842 | GCT_send_cancel(ch->last_control_qe); | 847 | GCT_send_cancel (ch->last_control_qe); |
843 | ch->last_control_qe = GCT_send(ch->t, &msg.header, &send_ack_cb, ch); | 848 | ch->last_control_qe = GCT_send (ch->t, &msg.header, &send_ack_cb, ch); |
844 | } | 849 | } |
845 | 850 | ||
846 | 851 | ||
@@ -853,28 +858,28 @@ send_open_ack(void *cls) | |||
853 | * @param cti identifier of the connection that delivered the message | 858 | * @param cti identifier of the connection that delivered the message |
854 | */ | 859 | */ |
855 | void | 860 | void |
856 | GCCH_handle_duplicate_open( | 861 | GCCH_handle_duplicate_open ( |
857 | struct CadetChannel *ch, | 862 | struct CadetChannel *ch, |
858 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti) | 863 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti) |
859 | { | 864 | { |
860 | if (NULL == ch->dest) | 865 | if (NULL == ch->dest) |
861 | { | 866 | { |
862 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 867 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
863 | "Ignoring duplicate CHANNEL_OPEN on %s: port is closed\n", | 868 | "Ignoring duplicate CHANNEL_OPEN on %s: port is closed\n", |
864 | GCCH_2s(ch)); | 869 | GCCH_2s (ch)); |
865 | return; | 870 | return; |
866 | } | 871 | } |
867 | if (NULL != ch->retry_control_task) | 872 | if (NULL != ch->retry_control_task) |
868 | { | 873 | { |
869 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 874 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
870 | "Ignoring duplicate CHANNEL_OPEN on %s: control message is pending\n", | 875 | "Ignoring duplicate CHANNEL_OPEN on %s: control message is pending\n", |
871 | GCCH_2s(ch)); | 876 | GCCH_2s (ch)); |
872 | return; | 877 | return; |
873 | } | 878 | } |
874 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 879 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
875 | "Retransmitting CHANNEL_OPEN_ACK on %s\n", | 880 | "Retransmitting CHANNEL_OPEN_ACK on %s\n", |
876 | GCCH_2s(ch)); | 881 | GCCH_2s (ch)); |
877 | ch->retry_control_task = GNUNET_SCHEDULER_add_now(&send_open_ack, ch); | 882 | ch->retry_control_task = GNUNET_SCHEDULER_add_now (&send_open_ack, ch); |
878 | } | 883 | } |
879 | 884 | ||
880 | 885 | ||
@@ -886,7 +891,7 @@ GCCH_handle_duplicate_open( | |||
886 | * #GNUNET_NO to send to dest | 891 | * #GNUNET_NO to send to dest |
887 | */ | 892 | */ |
888 | static void | 893 | static void |
889 | send_ack_to_client(struct CadetChannel *ch, int to_owner) | 894 | send_ack_to_client (struct CadetChannel *ch, int to_owner) |
890 | { | 895 | { |
891 | struct GNUNET_MQ_Envelope *env; | 896 | struct GNUNET_MQ_Envelope *env; |
892 | struct GNUNET_CADET_LocalAck *ack; | 897 | struct GNUNET_CADET_LocalAck *ack; |
@@ -894,22 +899,22 @@ send_ack_to_client(struct CadetChannel *ch, int to_owner) | |||
894 | 899 | ||
895 | ccc = (GNUNET_YES == to_owner) ? ch->owner : ch->dest; | 900 | ccc = (GNUNET_YES == to_owner) ? ch->owner : ch->dest; |
896 | if (NULL == ccc) | 901 | if (NULL == ccc) |
897 | { | 902 | { |
898 | /* This can happen if we are just getting ACKs after | 903 | /* This can happen if we are just getting ACKs after |
899 | our local client already disconnected. */ | 904 | our local client already disconnected. */ |
900 | GNUNET_assert(GNUNET_YES == ch->destroy); | 905 | GNUNET_assert (GNUNET_YES == ch->destroy); |
901 | return; | 906 | return; |
902 | } | 907 | } |
903 | env = GNUNET_MQ_msg(ack, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK); | 908 | env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK); |
904 | ack->ccn = ccc->ccn; | 909 | ack->ccn = ccc->ccn; |
905 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 910 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
906 | "Sending CADET_LOCAL_ACK to %s (%s) at ccn %X (%u/%u pending)\n", | 911 | "Sending CADET_LOCAL_ACK to %s (%s) at ccn %X (%u/%u pending)\n", |
907 | GSC_2s(ccc->c), | 912 | GSC_2s (ccc->c), |
908 | (GNUNET_YES == to_owner) ? "owner" : "dest", | 913 | (GNUNET_YES == to_owner) ? "owner" : "dest", |
909 | ntohl(ack->ccn.channel_of_client), | 914 | ntohl (ack->ccn.channel_of_client), |
910 | ch->pending_messages, | 915 | ch->pending_messages, |
911 | ch->max_pending_messages); | 916 | ch->max_pending_messages); |
912 | GSC_send_to_client(ccc->c, env); | 917 | GSC_send_to_client (ccc->c, env); |
913 | } | 918 | } |
914 | 919 | ||
915 | 920 | ||
@@ -923,58 +928,58 @@ send_ack_to_client(struct CadetChannel *ch, int to_owner) | |||
923 | * @param port the port @a is listening on | 928 | * @param port the port @a is listening on |
924 | */ | 929 | */ |
925 | void | 930 | void |
926 | GCCH_bind(struct CadetChannel *ch, | 931 | GCCH_bind (struct CadetChannel *ch, |
927 | struct CadetClient *c, | 932 | struct CadetClient *c, |
928 | const struct GNUNET_HashCode *port) | 933 | const struct GNUNET_HashCode *port) |
929 | { | 934 | { |
930 | uint32_t options; | 935 | uint32_t options; |
931 | struct CadetChannelClient *cccd; | 936 | struct CadetChannelClient *cccd; |
932 | 937 | ||
933 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 938 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
934 | "Binding %s from %s to port %s of %s\n", | 939 | "Binding %s from %s to port %s of %s\n", |
935 | GCCH_2s(ch), | 940 | GCCH_2s (ch), |
936 | GCT_2s(ch->t), | 941 | GCT_2s (ch->t), |
937 | GNUNET_h2s(&ch->port), | 942 | GNUNET_h2s (&ch->port), |
938 | GSC_2s(c)); | 943 | GSC_2s (c)); |
939 | if (NULL != ch->retry_control_task) | 944 | if (NULL != ch->retry_control_task) |
940 | { | 945 | { |
941 | /* there might be a timeout task here */ | 946 | /* there might be a timeout task here */ |
942 | GNUNET_SCHEDULER_cancel(ch->retry_control_task); | 947 | GNUNET_SCHEDULER_cancel (ch->retry_control_task); |
943 | ch->retry_control_task = NULL; | 948 | ch->retry_control_task = NULL; |
944 | } | 949 | } |
945 | options = 0; | 950 | options = 0; |
946 | cccd = GNUNET_new(struct CadetChannelClient); | 951 | cccd = GNUNET_new (struct CadetChannelClient); |
947 | GNUNET_assert(NULL == ch->dest); | 952 | GNUNET_assert (NULL == ch->dest); |
948 | ch->dest = cccd; | 953 | ch->dest = cccd; |
949 | ch->port = *port; | 954 | ch->port = *port; |
950 | cccd->c = c; | 955 | cccd->c = c; |
951 | cccd->client_ready = GNUNET_YES; | 956 | cccd->client_ready = GNUNET_YES; |
952 | cccd->ccn = GSC_bind(c, | 957 | cccd->ccn = GSC_bind (c, |
953 | ch, | 958 | ch, |
954 | (GNUNET_YES == ch->is_loopback) | 959 | (GNUNET_YES == ch->is_loopback) |
955 | ? GCP_get(&my_full_id, GNUNET_YES) | 960 | ? GCP_get (&my_full_id, GNUNET_YES) |
956 | : GCT_get_destination(ch->t), | 961 | : GCT_get_destination (ch->t), |
957 | port, | 962 | port, |
958 | options); | 963 | options); |
959 | GNUNET_assert(ntohl(cccd->ccn.channel_of_client) < | 964 | GNUNET_assert (ntohl (cccd->ccn.channel_of_client) < |
960 | GNUNET_CADET_LOCAL_CHANNEL_ID_CLI); | 965 | GNUNET_CADET_LOCAL_CHANNEL_ID_CLI); |
961 | ch->mid_recv.mid = htonl(1); /* The OPEN counts as message 0! */ | 966 | ch->mid_recv.mid = htonl (1); /* The OPEN counts as message 0! */ |
962 | if (GNUNET_YES == ch->is_loopback) | 967 | if (GNUNET_YES == ch->is_loopback) |
963 | { | 968 | { |
964 | ch->state = CADET_CHANNEL_OPEN_SENT; | 969 | ch->state = CADET_CHANNEL_OPEN_SENT; |
965 | GCCH_handle_channel_open_ack(ch, NULL, port); | 970 | GCCH_handle_channel_open_ack (ch, NULL, port); |
966 | } | 971 | } |
967 | else | 972 | else |
968 | { | 973 | { |
969 | /* notify other peer that we accepted the connection */ | 974 | /* notify other peer that we accepted the connection */ |
970 | ch->state = CADET_CHANNEL_READY; | 975 | ch->state = CADET_CHANNEL_READY; |
971 | ch->retry_control_task = GNUNET_SCHEDULER_add_now(&send_open_ack, ch); | 976 | ch->retry_control_task = GNUNET_SCHEDULER_add_now (&send_open_ack, ch); |
972 | } | 977 | } |
973 | /* give client it's initial supply of ACKs */ | 978 | /* give client it's initial supply of ACKs */ |
974 | GNUNET_assert(ntohl(cccd->ccn.channel_of_client) < | 979 | GNUNET_assert (ntohl (cccd->ccn.channel_of_client) < |
975 | GNUNET_CADET_LOCAL_CHANNEL_ID_CLI); | 980 | GNUNET_CADET_LOCAL_CHANNEL_ID_CLI); |
976 | for (unsigned int i = 0; i < ch->max_pending_messages; i++) | 981 | for (unsigned int i = 0; i < ch->max_pending_messages; i++) |
977 | send_ack_to_client(ch, GNUNET_NO); | 982 | send_ack_to_client (ch, GNUNET_NO); |
978 | } | 983 | } |
979 | 984 | ||
980 | 985 | ||
@@ -986,7 +991,7 @@ GCCH_bind(struct CadetChannel *ch, | |||
986 | * @param cls the `struct CadetChannel` where one of the ends is now dead | 991 | * @param cls the `struct CadetChannel` where one of the ends is now dead |
987 | */ | 992 | */ |
988 | static void | 993 | static void |
989 | signal_remote_destroy_cb(void *cls) | 994 | signal_remote_destroy_cb (void *cls) |
990 | { | 995 | { |
991 | struct CadetChannel *ch = cls; | 996 | struct CadetChannel *ch = cls; |
992 | struct CadetChannelClient *ccc; | 997 | struct CadetChannelClient *ccc; |
@@ -994,8 +999,8 @@ signal_remote_destroy_cb(void *cls) | |||
994 | /* Find which end is left... */ | 999 | /* Find which end is left... */ |
995 | ch->retry_control_task = NULL; | 1000 | ch->retry_control_task = NULL; |
996 | ccc = (NULL != ch->owner) ? ch->owner : ch->dest; | 1001 | ccc = (NULL != ch->owner) ? ch->owner : ch->dest; |
997 | GSC_handle_remote_channel_destroy(ccc->c, ccc->ccn, ch); | 1002 | GSC_handle_remote_channel_destroy (ccc->c, ccc->ccn, ch); |
998 | channel_destroy(ch); | 1003 | channel_destroy (ch); |
999 | } | 1004 | } |
1000 | 1005 | ||
1001 | 1006 | ||
@@ -1008,74 +1013,74 @@ signal_remote_destroy_cb(void *cls) | |||
1008 | * @param ccn client number of the client @a c | 1013 | * @param ccn client number of the client @a c |
1009 | */ | 1014 | */ |
1010 | void | 1015 | void |
1011 | GCCH_channel_local_destroy(struct CadetChannel *ch, | 1016 | GCCH_channel_local_destroy (struct CadetChannel *ch, |
1012 | struct CadetClient *c, | 1017 | struct CadetClient *c, |
1013 | struct GNUNET_CADET_ClientChannelNumber ccn) | 1018 | struct GNUNET_CADET_ClientChannelNumber ccn) |
1014 | { | 1019 | { |
1015 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1020 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1016 | "%s asks for destruction of %s\n", | 1021 | "%s asks for destruction of %s\n", |
1017 | GSC_2s(c), | 1022 | GSC_2s (c), |
1018 | GCCH_2s(ch)); | 1023 | GCCH_2s (ch)); |
1019 | GNUNET_assert(NULL != c); | 1024 | GNUNET_assert (NULL != c); |
1020 | if ((NULL != ch->owner) && (c == ch->owner->c) && | 1025 | if ((NULL != ch->owner) && (c == ch->owner->c) && |
1021 | (ccn.channel_of_client == ch->owner->ccn.channel_of_client)) | 1026 | (ccn.channel_of_client == ch->owner->ccn.channel_of_client)) |
1022 | { | 1027 | { |
1023 | free_channel_client(ch->owner); | 1028 | free_channel_client (ch->owner); |
1024 | ch->owner = NULL; | 1029 | ch->owner = NULL; |
1025 | } | 1030 | } |
1026 | else if ((NULL != ch->dest) && (c == ch->dest->c) && | 1031 | else if ((NULL != ch->dest) && (c == ch->dest->c) && |
1027 | (ccn.channel_of_client == ch->dest->ccn.channel_of_client)) | 1032 | (ccn.channel_of_client == ch->dest->ccn.channel_of_client)) |
1028 | { | 1033 | { |
1029 | free_channel_client(ch->dest); | 1034 | free_channel_client (ch->dest); |
1030 | ch->dest = NULL; | 1035 | ch->dest = NULL; |
1031 | } | 1036 | } |
1032 | else | 1037 | else |
1033 | { | 1038 | { |
1034 | GNUNET_assert(0); | 1039 | GNUNET_assert (0); |
1035 | } | 1040 | } |
1036 | 1041 | ||
1037 | if (GNUNET_YES == ch->destroy) | 1042 | if (GNUNET_YES == ch->destroy) |
1038 | { | 1043 | { |
1039 | /* other end already destroyed, with the local client gone, no need | 1044 | /* other end already destroyed, with the local client gone, no need |
1040 | to finish transmissions, just destroy immediately. */ | 1045 | to finish transmissions, just destroy immediately. */ |
1041 | channel_destroy(ch); | 1046 | channel_destroy (ch); |
1042 | return; | 1047 | return; |
1043 | } | 1048 | } |
1044 | if ((NULL != ch->head_sent) && ((NULL != ch->owner) || (NULL != ch->dest))) | 1049 | if ((NULL != ch->head_sent) && ((NULL != ch->owner) || (NULL != ch->dest))) |
1045 | { | 1050 | { |
1046 | /* Wait for other end to destroy us as well, | 1051 | /* Wait for other end to destroy us as well, |
1047 | and otherwise allow send queue to be transmitted first */ | 1052 | and otherwise allow send queue to be transmitted first */ |
1048 | ch->destroy = GNUNET_YES; | 1053 | ch->destroy = GNUNET_YES; |
1049 | return; | 1054 | return; |
1050 | } | 1055 | } |
1051 | if ((GNUNET_YES == ch->is_loopback) && | 1056 | if ((GNUNET_YES == ch->is_loopback) && |
1052 | ((NULL != ch->owner) || (NULL != ch->dest))) | 1057 | ((NULL != ch->owner) || (NULL != ch->dest))) |
1053 | { | 1058 | { |
1054 | if (NULL != ch->retry_control_task) | 1059 | if (NULL != ch->retry_control_task) |
1055 | GNUNET_SCHEDULER_cancel(ch->retry_control_task); | 1060 | GNUNET_SCHEDULER_cancel (ch->retry_control_task); |
1056 | ch->retry_control_task = | 1061 | ch->retry_control_task = |
1057 | GNUNET_SCHEDULER_add_now(&signal_remote_destroy_cb, ch); | 1062 | GNUNET_SCHEDULER_add_now (&signal_remote_destroy_cb, ch); |
1058 | return; | 1063 | return; |
1059 | } | 1064 | } |
1060 | if (GNUNET_NO == ch->is_loopback) | 1065 | if (GNUNET_NO == ch->is_loopback) |
1066 | { | ||
1067 | /* If the we ever sent the CHANNEL_CREATE, we need to send a destroy message. */ | ||
1068 | switch (ch->state) | ||
1061 | { | 1069 | { |
1062 | /* If the we ever sent the CHANNEL_CREATE, we need to send a destroy message. */ | 1070 | case CADET_CHANNEL_NEW: |
1063 | switch (ch->state) | 1071 | /* We gave up on a channel that we created as a client to a remote |
1064 | { | 1072 | target, but that never went anywhere. Nothing to do here. */ |
1065 | case CADET_CHANNEL_NEW: | 1073 | break; |
1066 | /* We gave up on a channel that we created as a client to a remote | 1074 | |
1067 | target, but that never went anywhere. Nothing to do here. */ | 1075 | case CADET_CHANNEL_LOOSE: |
1068 | break; | 1076 | break; |
1069 | 1077 | ||
1070 | case CADET_CHANNEL_LOOSE: | 1078 | default: |
1071 | break; | 1079 | GCT_send_channel_destroy (ch->t, ch->ctn); |
1072 | |||
1073 | default: | ||
1074 | GCT_send_channel_destroy(ch->t, ch->ctn); | ||
1075 | } | ||
1076 | } | 1080 | } |
1081 | } | ||
1077 | /* Nothing left to do, just finish destruction */ | 1082 | /* Nothing left to do, just finish destruction */ |
1078 | channel_destroy(ch); | 1083 | channel_destroy (ch); |
1079 | } | 1084 | } |
1080 | 1085 | ||
1081 | 1086 | ||
@@ -1089,60 +1094,60 @@ GCCH_channel_local_destroy(struct CadetChannel *ch, | |||
1089 | * @param port port number (needed to verify receiver knows the port) | 1094 | * @param port port number (needed to verify receiver knows the port) |
1090 | */ | 1095 | */ |
1091 | void | 1096 | void |
1092 | GCCH_handle_channel_open_ack( | 1097 | GCCH_handle_channel_open_ack ( |
1093 | struct CadetChannel *ch, | 1098 | struct CadetChannel *ch, |
1094 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 1099 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
1095 | const struct GNUNET_HashCode *port) | 1100 | const struct GNUNET_HashCode *port) |
1096 | { | 1101 | { |
1097 | switch (ch->state) | 1102 | switch (ch->state) |
1103 | { | ||
1104 | case CADET_CHANNEL_NEW: | ||
1105 | /* this should be impossible */ | ||
1106 | GNUNET_break (0); | ||
1107 | break; | ||
1108 | |||
1109 | case CADET_CHANNEL_LOOSE: | ||
1110 | /* This makes no sense. */ | ||
1111 | GNUNET_break_op (0); | ||
1112 | break; | ||
1113 | |||
1114 | case CADET_CHANNEL_OPEN_SENT: | ||
1115 | if (NULL == ch->owner) | ||
1098 | { | 1116 | { |
1099 | case CADET_CHANNEL_NEW: | 1117 | /* We're not the owner, wrong direction! */ |
1100 | /* this should be impossible */ | 1118 | GNUNET_break_op (0); |
1101 | GNUNET_break(0); | 1119 | return; |
1102 | break; | 1120 | } |
1103 | 1121 | if (0 != GNUNET_memcmp (&ch->port, port)) | |
1104 | case CADET_CHANNEL_LOOSE: | 1122 | { |
1105 | /* This makes no sense. */ | 1123 | /* Other peer failed to provide the right port, |
1106 | GNUNET_break_op(0); | 1124 | refuse connection. */ |
1107 | break; | 1125 | GNUNET_break_op (0); |
1108 | 1126 | return; | |
1109 | case CADET_CHANNEL_OPEN_SENT: | ||
1110 | if (NULL == ch->owner) | ||
1111 | { | ||
1112 | /* We're not the owner, wrong direction! */ | ||
1113 | GNUNET_break_op(0); | ||
1114 | return; | ||
1115 | } | ||
1116 | if (0 != GNUNET_memcmp(&ch->port, port)) | ||
1117 | { | ||
1118 | /* Other peer failed to provide the right port, | ||
1119 | refuse connection. */ | ||
1120 | GNUNET_break_op(0); | ||
1121 | return; | ||
1122 | } | ||
1123 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1124 | "Received CHANNEL_OPEN_ACK for waiting %s, entering READY state\n", | ||
1125 | GCCH_2s(ch)); | ||
1126 | if (NULL != ch->retry_control_task) /* can be NULL if ch->is_loopback */ | ||
1127 | { | ||
1128 | GNUNET_SCHEDULER_cancel(ch->retry_control_task); | ||
1129 | ch->retry_control_task = NULL; | ||
1130 | } | ||
1131 | ch->state = CADET_CHANNEL_READY; | ||
1132 | /* On first connect, send client as many ACKs as we allow messages | ||
1133 | to be buffered! */ | ||
1134 | for (unsigned int i = 0; i < ch->max_pending_messages; i++) | ||
1135 | send_ack_to_client(ch, GNUNET_YES); | ||
1136 | break; | ||
1137 | |||
1138 | case CADET_CHANNEL_READY: | ||
1139 | /* duplicate ACK, maybe we retried the CREATE. Ignore. */ | ||
1140 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1141 | "Received duplicate channel OPEN_ACK for %s\n", | ||
1142 | GCCH_2s(ch)); | ||
1143 | GNUNET_STATISTICS_update(stats, "# duplicate CREATE_ACKs", 1, GNUNET_NO); | ||
1144 | break; | ||
1145 | } | 1127 | } |
1128 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1129 | "Received CHANNEL_OPEN_ACK for waiting %s, entering READY state\n", | ||
1130 | GCCH_2s (ch)); | ||
1131 | if (NULL != ch->retry_control_task) /* can be NULL if ch->is_loopback */ | ||
1132 | { | ||
1133 | GNUNET_SCHEDULER_cancel (ch->retry_control_task); | ||
1134 | ch->retry_control_task = NULL; | ||
1135 | } | ||
1136 | ch->state = CADET_CHANNEL_READY; | ||
1137 | /* On first connect, send client as many ACKs as we allow messages | ||
1138 | to be buffered! */ | ||
1139 | for (unsigned int i = 0; i < ch->max_pending_messages; i++) | ||
1140 | send_ack_to_client (ch, GNUNET_YES); | ||
1141 | break; | ||
1142 | |||
1143 | case CADET_CHANNEL_READY: | ||
1144 | /* duplicate ACK, maybe we retried the CREATE. Ignore. */ | ||
1145 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1146 | "Received duplicate channel OPEN_ACK for %s\n", | ||
1147 | GCCH_2s (ch)); | ||
1148 | GNUNET_STATISTICS_update (stats, "# duplicate CREATE_ACKs", 1, GNUNET_NO); | ||
1149 | break; | ||
1150 | } | ||
1146 | } | 1151 | } |
1147 | 1152 | ||
1148 | 1153 | ||
@@ -1155,28 +1160,28 @@ GCCH_handle_channel_open_ack( | |||
1155 | * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO | 1160 | * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO |
1156 | */ | 1161 | */ |
1157 | static int | 1162 | static int |
1158 | is_before(void *cls, | 1163 | is_before (void *cls, |
1159 | struct CadetOutOfOrderMessage *m1, | 1164 | struct CadetOutOfOrderMessage *m1, |
1160 | struct CadetOutOfOrderMessage *m2) | 1165 | struct CadetOutOfOrderMessage *m2) |
1161 | { | 1166 | { |
1162 | int *duplicate = cls; | 1167 | int *duplicate = cls; |
1163 | uint32_t v1 = ntohl(m1->mid.mid); | 1168 | uint32_t v1 = ntohl (m1->mid.mid); |
1164 | uint32_t v2 = ntohl(m2->mid.mid); | 1169 | uint32_t v2 = ntohl (m2->mid.mid); |
1165 | uint32_t delta; | 1170 | uint32_t delta; |
1166 | 1171 | ||
1167 | delta = v2 - v1; | 1172 | delta = v2 - v1; |
1168 | if (0 == delta) | 1173 | if (0 == delta) |
1169 | *duplicate = GNUNET_YES; | 1174 | *duplicate = GNUNET_YES; |
1170 | if (delta > (uint32_t)INT_MAX) | 1175 | if (delta > (uint32_t) INT_MAX) |
1171 | { | 1176 | { |
1172 | /* in overflow range, we can safely assume we wrapped around */ | 1177 | /* in overflow range, we can safely assume we wrapped around */ |
1173 | return GNUNET_NO; | 1178 | return GNUNET_NO; |
1174 | } | 1179 | } |
1175 | else | 1180 | else |
1176 | { | 1181 | { |
1177 | /* result is small, thus v2 > v1, thus m1 < m2 */ | 1182 | /* result is small, thus v2 > v1, thus m1 < m2 */ |
1178 | return GNUNET_YES; | 1183 | return GNUNET_YES; |
1179 | } | 1184 | } |
1180 | } | 1185 | } |
1181 | 1186 | ||
1182 | 1187 | ||
@@ -1189,7 +1194,7 @@ is_before(void *cls, | |||
1189 | * @param msg message that was received | 1194 | * @param msg message that was received |
1190 | */ | 1195 | */ |
1191 | void | 1196 | void |
1192 | GCCH_handle_channel_plaintext_data( | 1197 | GCCH_handle_channel_plaintext_data ( |
1193 | struct CadetChannel *ch, | 1198 | struct CadetChannel *ch, |
1194 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 1199 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
1195 | const struct GNUNET_CADET_ChannelAppDataMessage *msg) | 1200 | const struct GNUNET_CADET_ChannelAppDataMessage *msg) |
@@ -1205,239 +1210,239 @@ GCCH_handle_channel_plaintext_data( | |||
1205 | uint32_t mid_msg; | 1210 | uint32_t mid_msg; |
1206 | uint32_t delta; | 1211 | uint32_t delta; |
1207 | 1212 | ||
1208 | GNUNET_assert(GNUNET_NO == ch->is_loopback); | 1213 | GNUNET_assert (GNUNET_NO == ch->is_loopback); |
1209 | if ((NULL == ch->owner) && (NULL == ch->dest)) | 1214 | if ((NULL == ch->owner) && (NULL == ch->dest)) |
1210 | { | 1215 | { |
1211 | /* This client is gone, but we still have messages to send to | 1216 | /* This client is gone, but we still have messages to send to |
1212 | the other end (which is why @a ch is not yet dead). However, | 1217 | the other end (which is why @a ch is not yet dead). However, |
1213 | we cannot pass messages to our client anymore. */ | 1218 | we cannot pass messages to our client anymore. */ |
1214 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1219 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1215 | "Dropping incoming payload on %s as this end is already closed\n", | 1220 | "Dropping incoming payload on %s as this end is already closed\n", |
1216 | GCCH_2s(ch)); | 1221 | GCCH_2s (ch)); |
1217 | /* send back DESTROY notification to stop further retransmissions! */ | 1222 | /* send back DESTROY notification to stop further retransmissions! */ |
1218 | if (GNUNET_YES == ch->destroy) | 1223 | if (GNUNET_YES == ch->destroy) |
1219 | GCT_send_channel_destroy(ch->t, ch->ctn); | 1224 | GCT_send_channel_destroy (ch->t, ch->ctn); |
1220 | return; | 1225 | return; |
1221 | } | 1226 | } |
1222 | payload_size = ntohs(msg->header.size) - sizeof(*msg); | 1227 | payload_size = ntohs (msg->header.size) - sizeof(*msg); |
1223 | env = GNUNET_MQ_msg_extra(ld, | 1228 | env = GNUNET_MQ_msg_extra (ld, |
1224 | payload_size, | 1229 | payload_size, |
1225 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA); | 1230 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA); |
1226 | ld->ccn = (NULL == ch->dest) ? ch->owner->ccn : ch->dest->ccn; | 1231 | ld->ccn = (NULL == ch->dest) ? ch->owner->ccn : ch->dest->ccn; |
1227 | GNUNET_memcpy(&ld[1], &msg[1], payload_size); | 1232 | GNUNET_memcpy (&ld[1], &msg[1], payload_size); |
1228 | ccc = (NULL != ch->owner) ? ch->owner : ch->dest; | 1233 | ccc = (NULL != ch->owner) ? ch->owner : ch->dest; |
1229 | if (GNUNET_YES == ccc->client_ready) | 1234 | if (GNUNET_YES == ccc->client_ready) |
1235 | { | ||
1236 | /* | ||
1237 | * We ad-hoc send the message if | ||
1238 | * - The channel is out-of-order | ||
1239 | * - The channel is reliable and MID matches next expected MID | ||
1240 | * - The channel is unreliable and MID is before lowest seen MID | ||
1241 | */ | ||
1242 | if ((GNUNET_YES == ch->out_of_order) || | ||
1243 | ((msg->mid.mid == ch->mid_recv.mid) && (GNUNET_YES == ch->reliable)) || | ||
1244 | ((GNUNET_NO == ch->reliable) && | ||
1245 | (ntohl (msg->mid.mid) >= ntohl (ch->mid_recv.mid)) && | ||
1246 | ((NULL == ccc->head_recv) || | ||
1247 | (ntohl (msg->mid.mid) < ntohl (ccc->head_recv->mid.mid))))) | ||
1230 | { | 1248 | { |
1231 | /* | 1249 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1232 | * We ad-hoc send the message if | 1250 | "Giving %u bytes of payload with MID %u from %s to client %s\n", |
1233 | * - The channel is out-of-order | 1251 | (unsigned int) payload_size, |
1234 | * - The channel is reliable and MID matches next expected MID | 1252 | ntohl (msg->mid.mid), |
1235 | * - The channel is unreliable and MID is before lowest seen MID | 1253 | GCCH_2s (ch), |
1236 | */ | 1254 | GSC_2s (ccc->c)); |
1237 | if ((GNUNET_YES == ch->out_of_order) || | 1255 | ccc->client_ready = GNUNET_NO; |
1238 | ((msg->mid.mid == ch->mid_recv.mid) && (GNUNET_YES == ch->reliable)) || | 1256 | GSC_send_to_client (ccc->c, env); |
1239 | ((GNUNET_NO == ch->reliable) && | 1257 | if (GNUNET_NO == ch->out_of_order) |
1240 | (ntohl(msg->mid.mid) >= ntohl(ch->mid_recv.mid)) && | 1258 | ch->mid_recv.mid = htonl (1 + ntohl (msg->mid.mid)); |
1241 | ((NULL == ccc->head_recv) || | 1259 | else |
1242 | (ntohl(msg->mid.mid) < ntohl(ccc->head_recv->mid.mid))))) | 1260 | ch->mid_recv.mid = htonl (1 + ntohl (ch->mid_recv.mid)); |
1243 | { | 1261 | ch->mid_futures >>= 1; |
1244 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1262 | if ((GNUNET_YES == ch->out_of_order) && (GNUNET_NO == ch->reliable)) |
1245 | "Giving %u bytes of payload with MID %u from %s to client %s\n", | 1263 | { |
1246 | (unsigned int)payload_size, | 1264 | /* possibly shift by more if we skipped messages */ |
1247 | ntohl(msg->mid.mid), | 1265 | uint64_t delta = htonl (msg->mid.mid) - 1 - ntohl (ch->mid_recv.mid); |
1248 | GCCH_2s(ch), | 1266 | |
1249 | GSC_2s(ccc->c)); | 1267 | if (delta > 63) |
1250 | ccc->client_ready = GNUNET_NO; | 1268 | ch->mid_futures = 0; |
1251 | GSC_send_to_client(ccc->c, env); | 1269 | else |
1252 | if (GNUNET_NO == ch->out_of_order) | 1270 | ch->mid_futures >>= delta; |
1253 | ch->mid_recv.mid = htonl(1 + ntohl(msg->mid.mid)); | 1271 | ch->mid_recv.mid = htonl (1 + ntohl (msg->mid.mid)); |
1254 | else | 1272 | } |
1255 | ch->mid_recv.mid = htonl(1 + ntohl(ch->mid_recv.mid)); | 1273 | send_channel_data_ack (ch); |
1256 | ch->mid_futures >>= 1; | 1274 | return; |
1257 | if ((GNUNET_YES == ch->out_of_order) && (GNUNET_NO == ch->reliable)) | ||
1258 | { | ||
1259 | /* possibly shift by more if we skipped messages */ | ||
1260 | uint64_t delta = htonl(msg->mid.mid) - 1 - ntohl(ch->mid_recv.mid); | ||
1261 | |||
1262 | if (delta > 63) | ||
1263 | ch->mid_futures = 0; | ||
1264 | else | ||
1265 | ch->mid_futures >>= delta; | ||
1266 | ch->mid_recv.mid = htonl(1 + ntohl(msg->mid.mid)); | ||
1267 | } | ||
1268 | send_channel_data_ack(ch); | ||
1269 | return; | ||
1270 | } | ||
1271 | } | 1275 | } |
1276 | } | ||
1272 | 1277 | ||
1273 | if (GNUNET_YES == ch->reliable) | 1278 | if (GNUNET_YES == ch->reliable) |
1279 | { | ||
1280 | /* check if message ought to be dropped because it is ancient/too distant/duplicate */ | ||
1281 | mid_min = ntohl (ch->mid_recv.mid); | ||
1282 | mid_max = mid_min + ch->max_pending_messages; | ||
1283 | mid_msg = ntohl (msg->mid.mid); | ||
1284 | if (((uint32_t) (mid_msg - mid_min) > ch->max_pending_messages) || | ||
1285 | ((uint32_t) (mid_max - mid_msg) > ch->max_pending_messages)) | ||
1286 | { | ||
1287 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1288 | "%s at %u drops ancient or far-future message %u\n", | ||
1289 | GCCH_2s (ch), | ||
1290 | (unsigned int) mid_min, | ||
1291 | ntohl (msg->mid.mid)); | ||
1292 | |||
1293 | GNUNET_STATISTICS_update (stats, | ||
1294 | "# duplicate DATA (ancient or future)", | ||
1295 | 1, | ||
1296 | GNUNET_NO); | ||
1297 | GNUNET_MQ_discard (env); | ||
1298 | send_channel_data_ack (ch); | ||
1299 | return; | ||
1300 | } | ||
1301 | /* mark bit for future ACKs */ | ||
1302 | delta = mid_msg - mid_min - 1; /* overflow/underflow are OK here */ | ||
1303 | if (delta < 64) | ||
1274 | { | 1304 | { |
1275 | /* check if message ought to be dropped because it is ancient/too distant/duplicate */ | 1305 | if (0 != (ch->mid_futures & (1LLU << delta))) |
1276 | mid_min = ntohl(ch->mid_recv.mid); | 1306 | { |
1277 | mid_max = mid_min + ch->max_pending_messages; | 1307 | /* Duplicate within the queue, drop also */ |
1278 | mid_msg = ntohl(msg->mid.mid); | 1308 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1279 | if (((uint32_t)(mid_msg - mid_min) > ch->max_pending_messages) || | 1309 | "Duplicate payload of %u bytes on %s (mid %u) dropped\n", |
1280 | ((uint32_t)(mid_max - mid_msg) > ch->max_pending_messages)) | 1310 | (unsigned int) payload_size, |
1281 | { | 1311 | GCCH_2s (ch), |
1282 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1312 | ntohl (msg->mid.mid)); |
1283 | "%s at %u drops ancient or far-future message %u\n", | 1313 | GNUNET_STATISTICS_update (stats, "# duplicate DATA", 1, GNUNET_NO); |
1284 | GCCH_2s(ch), | 1314 | GNUNET_MQ_discard (env); |
1285 | (unsigned int)mid_min, | 1315 | send_channel_data_ack (ch); |
1286 | ntohl(msg->mid.mid)); | 1316 | return; |
1287 | 1317 | } | |
1288 | GNUNET_STATISTICS_update(stats, | 1318 | ch->mid_futures |= (1LLU << delta); |
1289 | "# duplicate DATA (ancient or future)", | 1319 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1290 | 1, | 1320 | "Marked bit %llX for mid %u (base: %u); now: %llX\n", |
1291 | GNUNET_NO); | 1321 | (1LLU << delta), |
1292 | GNUNET_MQ_discard(env); | 1322 | mid_msg, |
1293 | send_channel_data_ack(ch); | 1323 | mid_min, |
1294 | return; | 1324 | ch->mid_futures); |
1295 | } | ||
1296 | /* mark bit for future ACKs */ | ||
1297 | delta = mid_msg - mid_min - 1; /* overflow/underflow are OK here */ | ||
1298 | if (delta < 64) | ||
1299 | { | ||
1300 | if (0 != (ch->mid_futures & (1LLU << delta))) | ||
1301 | { | ||
1302 | /* Duplicate within the queue, drop also */ | ||
1303 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1304 | "Duplicate payload of %u bytes on %s (mid %u) dropped\n", | ||
1305 | (unsigned int)payload_size, | ||
1306 | GCCH_2s(ch), | ||
1307 | ntohl(msg->mid.mid)); | ||
1308 | GNUNET_STATISTICS_update(stats, "# duplicate DATA", 1, GNUNET_NO); | ||
1309 | GNUNET_MQ_discard(env); | ||
1310 | send_channel_data_ack(ch); | ||
1311 | return; | ||
1312 | } | ||
1313 | ch->mid_futures |= (1LLU << delta); | ||
1314 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1315 | "Marked bit %llX for mid %u (base: %u); now: %llX\n", | ||
1316 | (1LLU << delta), | ||
1317 | mid_msg, | ||
1318 | mid_min, | ||
1319 | ch->mid_futures); | ||
1320 | } | ||
1321 | } | 1325 | } |
1326 | } | ||
1322 | else /* ! ch->reliable */ | 1327 | else /* ! ch->reliable */ |
1328 | { | ||
1329 | struct CadetOutOfOrderMessage *next_msg; | ||
1330 | |||
1331 | /** | ||
1332 | * We always send if possible in this case. | ||
1333 | * It is guaranteed that the queued MID < received MID | ||
1334 | **/ | ||
1335 | if ((NULL != ccc->head_recv) && (GNUNET_YES == ccc->client_ready)) | ||
1336 | { | ||
1337 | next_msg = ccc->head_recv; | ||
1338 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1339 | "Giving queued MID %u from %s to client %s\n", | ||
1340 | ntohl (next_msg->mid.mid), | ||
1341 | GCCH_2s (ch), | ||
1342 | GSC_2s (ccc->c)); | ||
1343 | ccc->client_ready = GNUNET_NO; | ||
1344 | GSC_send_to_client (ccc->c, next_msg->env); | ||
1345 | ch->mid_recv.mid = htonl (1 + ntohl (next_msg->mid.mid)); | ||
1346 | ch->mid_futures >>= 1; | ||
1347 | send_channel_data_ack (ch); | ||
1348 | GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, next_msg); | ||
1349 | ccc->num_recv--; | ||
1350 | /* Do not process duplicate MID */ | ||
1351 | if (msg->mid.mid == next_msg->mid.mid) /* Duplicate */ | ||
1352 | { | ||
1353 | /* Duplicate within the queue, drop */ | ||
1354 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1355 | "Message on %s (mid %u) dropped, duplicate\n", | ||
1356 | GCCH_2s (ch), | ||
1357 | ntohl (msg->mid.mid)); | ||
1358 | GNUNET_free (next_msg); | ||
1359 | GNUNET_MQ_discard (env); | ||
1360 | return; | ||
1361 | } | ||
1362 | GNUNET_free (next_msg); | ||
1363 | } | ||
1364 | |||
1365 | if (ntohl (msg->mid.mid) < ntohl (ch->mid_recv.mid)) /* Old */ | ||
1366 | { | ||
1367 | /* Duplicate within the queue, drop */ | ||
1368 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1369 | "Message on %s (mid %u) dropped, old.\n", | ||
1370 | GCCH_2s (ch), | ||
1371 | ntohl (msg->mid.mid)); | ||
1372 | GNUNET_MQ_discard (env); | ||
1373 | return; | ||
1374 | } | ||
1375 | |||
1376 | /* Channel is unreliable, so we do not ACK. But we also cannot | ||
1377 | allow buffering everything, so check if we have space... */ | ||
1378 | if (ccc->num_recv >= ch->max_pending_messages) | ||
1323 | { | 1379 | { |
1324 | struct CadetOutOfOrderMessage *next_msg; | 1380 | struct CadetOutOfOrderMessage *drop; |
1325 | 1381 | ||
1326 | /** | 1382 | /* Yep, need to drop. Drop the oldest message in |
1327 | * We always send if possible in this case. | 1383 | the buffer. */ |
1328 | * It is guaranteed that the queued MID < received MID | 1384 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1329 | **/ | 1385 | "Queue full due slow client on %s, dropping oldest message\n", |
1330 | if ((NULL != ccc->head_recv) && (GNUNET_YES == ccc->client_ready)) | 1386 | GCCH_2s (ch)); |
1331 | { | 1387 | GNUNET_STATISTICS_update (stats, |
1332 | next_msg = ccc->head_recv; | 1388 | "# messages dropped due to slow client", |
1333 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1389 | 1, |
1334 | "Giving queued MID %u from %s to client %s\n", | 1390 | GNUNET_NO); |
1335 | ntohl(next_msg->mid.mid), | 1391 | drop = ccc->head_recv; |
1336 | GCCH_2s(ch), | 1392 | GNUNET_assert (NULL != drop); |
1337 | GSC_2s(ccc->c)); | 1393 | GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, drop); |
1338 | ccc->client_ready = GNUNET_NO; | 1394 | ccc->num_recv--; |
1339 | GSC_send_to_client(ccc->c, next_msg->env); | 1395 | GNUNET_MQ_discard (drop->env); |
1340 | ch->mid_recv.mid = htonl(1 + ntohl(next_msg->mid.mid)); | 1396 | GNUNET_free (drop); |
1341 | ch->mid_futures >>= 1; | ||
1342 | send_channel_data_ack(ch); | ||
1343 | GNUNET_CONTAINER_DLL_remove(ccc->head_recv, ccc->tail_recv, next_msg); | ||
1344 | ccc->num_recv--; | ||
1345 | /* Do not process duplicate MID */ | ||
1346 | if (msg->mid.mid == next_msg->mid.mid) /* Duplicate */ | ||
1347 | { | ||
1348 | /* Duplicate within the queue, drop */ | ||
1349 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1350 | "Message on %s (mid %u) dropped, duplicate\n", | ||
1351 | GCCH_2s(ch), | ||
1352 | ntohl(msg->mid.mid)); | ||
1353 | GNUNET_free(next_msg); | ||
1354 | GNUNET_MQ_discard(env); | ||
1355 | return; | ||
1356 | } | ||
1357 | GNUNET_free(next_msg); | ||
1358 | } | ||
1359 | |||
1360 | if (ntohl(msg->mid.mid) < ntohl(ch->mid_recv.mid)) /* Old */ | ||
1361 | { | ||
1362 | /* Duplicate within the queue, drop */ | ||
1363 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1364 | "Message on %s (mid %u) dropped, old.\n", | ||
1365 | GCCH_2s(ch), | ||
1366 | ntohl(msg->mid.mid)); | ||
1367 | GNUNET_MQ_discard(env); | ||
1368 | return; | ||
1369 | } | ||
1370 | |||
1371 | /* Channel is unreliable, so we do not ACK. But we also cannot | ||
1372 | allow buffering everything, so check if we have space... */ | ||
1373 | if (ccc->num_recv >= ch->max_pending_messages) | ||
1374 | { | ||
1375 | struct CadetOutOfOrderMessage *drop; | ||
1376 | |||
1377 | /* Yep, need to drop. Drop the oldest message in | ||
1378 | the buffer. */ | ||
1379 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1380 | "Queue full due slow client on %s, dropping oldest message\n", | ||
1381 | GCCH_2s(ch)); | ||
1382 | GNUNET_STATISTICS_update(stats, | ||
1383 | "# messages dropped due to slow client", | ||
1384 | 1, | ||
1385 | GNUNET_NO); | ||
1386 | drop = ccc->head_recv; | ||
1387 | GNUNET_assert(NULL != drop); | ||
1388 | GNUNET_CONTAINER_DLL_remove(ccc->head_recv, ccc->tail_recv, drop); | ||
1389 | ccc->num_recv--; | ||
1390 | GNUNET_MQ_discard(drop->env); | ||
1391 | GNUNET_free(drop); | ||
1392 | } | ||
1393 | } | 1397 | } |
1398 | } | ||
1394 | 1399 | ||
1395 | /* Insert message into sorted out-of-order queue */ | 1400 | /* Insert message into sorted out-of-order queue */ |
1396 | com = GNUNET_new(struct CadetOutOfOrderMessage); | 1401 | com = GNUNET_new (struct CadetOutOfOrderMessage); |
1397 | com->mid = msg->mid; | 1402 | com->mid = msg->mid; |
1398 | com->env = env; | 1403 | com->env = env; |
1399 | duplicate = GNUNET_NO; | 1404 | duplicate = GNUNET_NO; |
1400 | GNUNET_CONTAINER_DLL_insert_sorted(struct CadetOutOfOrderMessage, | 1405 | GNUNET_CONTAINER_DLL_insert_sorted (struct CadetOutOfOrderMessage, |
1401 | is_before, | 1406 | is_before, |
1402 | &duplicate, | 1407 | &duplicate, |
1403 | ccc->head_recv, | 1408 | ccc->head_recv, |
1404 | ccc->tail_recv, | 1409 | ccc->tail_recv, |
1405 | com); | 1410 | com); |
1406 | ccc->num_recv++; | 1411 | ccc->num_recv++; |
1407 | if (GNUNET_YES == duplicate) | 1412 | if (GNUNET_YES == duplicate) |
1408 | { | 1413 | { |
1409 | /* Duplicate within the queue, drop also (this is not covered by | 1414 | /* Duplicate within the queue, drop also (this is not covered by |
1410 | the case above if "delta" >= 64, which could be the case if | 1415 | the case above if "delta" >= 64, which could be the case if |
1411 | max_pending_messages is also >= 64 or if our client is unready | 1416 | max_pending_messages is also >= 64 or if our client is unready |
1412 | and we are seeing retransmissions of the message our client is | 1417 | and we are seeing retransmissions of the message our client is |
1413 | blocked on. */ | 1418 | blocked on. */ |
1414 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1419 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1415 | "Duplicate payload of %u bytes on %s (mid %u) dropped\n", | 1420 | "Duplicate payload of %u bytes on %s (mid %u) dropped\n", |
1416 | (unsigned int)payload_size, | 1421 | (unsigned int) payload_size, |
1417 | GCCH_2s(ch), | 1422 | GCCH_2s (ch), |
1418 | ntohl(msg->mid.mid)); | 1423 | ntohl (msg->mid.mid)); |
1419 | GNUNET_STATISTICS_update(stats, "# duplicate DATA", 1, GNUNET_NO); | 1424 | GNUNET_STATISTICS_update (stats, "# duplicate DATA", 1, GNUNET_NO); |
1420 | GNUNET_CONTAINER_DLL_remove(ccc->head_recv, ccc->tail_recv, com); | 1425 | GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com); |
1421 | ccc->num_recv--; | 1426 | ccc->num_recv--; |
1422 | GNUNET_MQ_discard(com->env); | 1427 | GNUNET_MQ_discard (com->env); |
1423 | GNUNET_free(com); | 1428 | GNUNET_free (com); |
1424 | send_channel_data_ack(ch); | 1429 | send_channel_data_ack (ch); |
1425 | return; | 1430 | return; |
1426 | } | 1431 | } |
1427 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1432 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1428 | "Queued %s payload of %u bytes on %s-%X(%p) (mid %u, need %u first)\n", | 1433 | "Queued %s payload of %u bytes on %s-%X(%p) (mid %u, need %u first)\n", |
1429 | (GNUNET_YES == ccc->client_ready) ? "out-of-order" : "client-not-ready", | 1434 | (GNUNET_YES == ccc->client_ready) ? "out-of-order" : "client-not-ready", |
1430 | (unsigned int)payload_size, | 1435 | (unsigned int) payload_size, |
1431 | GCCH_2s(ch), | 1436 | GCCH_2s (ch), |
1432 | ntohl(ccc->ccn.channel_of_client), | 1437 | ntohl (ccc->ccn.channel_of_client), |
1433 | ccc, | 1438 | ccc, |
1434 | ntohl(msg->mid.mid), | 1439 | ntohl (msg->mid.mid), |
1435 | ntohl(ch->mid_recv.mid)); | 1440 | ntohl (ch->mid_recv.mid)); |
1436 | /* NOTE: this ACK we _could_ skip, as the packet is out-of-order and | 1441 | /* NOTE: this ACK we _could_ skip, as the packet is out-of-order and |
1437 | the sender may already be transmitting the previous one. Needs | 1442 | the sender may already be transmitting the previous one. Needs |
1438 | experimental evaluation to see if/when this ACK helps or | 1443 | experimental evaluation to see if/when this ACK helps or |
1439 | hurts. (We might even want another option.) */ | 1444 | hurts. (We might even want another option.) */ |
1440 | send_channel_data_ack(ch); | 1445 | send_channel_data_ack (ch); |
1441 | } | 1446 | } |
1442 | 1447 | ||
1443 | 1448 | ||
@@ -1452,8 +1457,8 @@ GCCH_handle_channel_plaintext_data( | |||
1452 | * if transmission failed | 1457 | * if transmission failed |
1453 | */ | 1458 | */ |
1454 | static void | 1459 | static void |
1455 | data_sent_cb(void *cls, | 1460 | data_sent_cb (void *cls, |
1456 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | 1461 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); |
1457 | 1462 | ||
1458 | 1463 | ||
1459 | /** | 1464 | /** |
@@ -1463,19 +1468,19 @@ data_sent_cb(void *cls, | |||
1463 | * @param cls the `struct CadetChannel` where we need to retransmit | 1468 | * @param cls the `struct CadetChannel` where we need to retransmit |
1464 | */ | 1469 | */ |
1465 | static void | 1470 | static void |
1466 | retry_transmission(void *cls) | 1471 | retry_transmission (void *cls) |
1467 | { | 1472 | { |
1468 | struct CadetChannel *ch = cls; | 1473 | struct CadetChannel *ch = cls; |
1469 | struct CadetReliableMessage *crm = ch->head_sent; | 1474 | struct CadetReliableMessage *crm = ch->head_sent; |
1470 | 1475 | ||
1471 | ch->retry_data_task = NULL; | 1476 | ch->retry_data_task = NULL; |
1472 | GNUNET_assert(NULL == crm->qe); | 1477 | GNUNET_assert (NULL == crm->qe); |
1473 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1478 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1474 | "Retrying transmission on %s of message %u\n", | 1479 | "Retrying transmission on %s of message %u\n", |
1475 | GCCH_2s(ch), | 1480 | GCCH_2s (ch), |
1476 | (unsigned int)ntohl(crm->data_message->mid.mid)); | 1481 | (unsigned int) ntohl (crm->data_message->mid.mid)); |
1477 | crm->qe = GCT_send(ch->t, &crm->data_message->header, &data_sent_cb, crm); | 1482 | crm->qe = GCT_send (ch->t, &crm->data_message->header, &data_sent_cb, crm); |
1478 | GNUNET_assert(NULL == ch->retry_data_task); | 1483 | GNUNET_assert (NULL == ch->retry_data_task); |
1479 | } | 1484 | } |
1480 | 1485 | ||
1481 | 1486 | ||
@@ -1488,36 +1493,36 @@ retry_transmission(void *cls) | |||
1488 | * @param crm the message that got acknowledged | 1493 | * @param crm the message that got acknowledged |
1489 | */ | 1494 | */ |
1490 | static void | 1495 | static void |
1491 | handle_matching_ack(struct CadetChannel *ch, | 1496 | handle_matching_ack (struct CadetChannel *ch, |
1492 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 1497 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
1493 | struct CadetReliableMessage *crm) | 1498 | struct CadetReliableMessage *crm) |
1494 | { | 1499 | { |
1495 | GNUNET_CONTAINER_DLL_remove(ch->head_sent, ch->tail_sent, crm); | 1500 | GNUNET_CONTAINER_DLL_remove (ch->head_sent, ch->tail_sent, crm); |
1496 | ch->pending_messages--; | 1501 | ch->pending_messages--; |
1497 | GNUNET_assert(ch->pending_messages < ch->max_pending_messages); | 1502 | GNUNET_assert (ch->pending_messages < ch->max_pending_messages); |
1498 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1503 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1499 | "Received DATA_ACK on %s for message %u (%u ACKs pending)\n", | 1504 | "Received DATA_ACK on %s for message %u (%u ACKs pending)\n", |
1500 | GCCH_2s(ch), | 1505 | GCCH_2s (ch), |
1501 | (unsigned int)ntohl(crm->data_message->mid.mid), | 1506 | (unsigned int) ntohl (crm->data_message->mid.mid), |
1502 | ch->pending_messages); | 1507 | ch->pending_messages); |
1503 | if (NULL != crm->qe) | 1508 | if (NULL != crm->qe) |
1504 | { | 1509 | { |
1505 | GCT_send_cancel(crm->qe); | 1510 | GCT_send_cancel (crm->qe); |
1506 | crm->qe = NULL; | 1511 | crm->qe = NULL; |
1507 | } | 1512 | } |
1508 | if ((1 == crm->num_transmissions) && (NULL != cti)) | 1513 | if ((1 == crm->num_transmissions) && (NULL != cti)) |
1514 | { | ||
1515 | GCC_ack_observed (cti); | ||
1516 | if (0 == GNUNET_memcmp (cti, &crm->connection_taken)) | ||
1509 | { | 1517 | { |
1510 | GCC_ack_observed(cti); | 1518 | GCC_latency_observed (cti, |
1511 | if (0 == GNUNET_memcmp(cti, &crm->connection_taken)) | 1519 | GNUNET_TIME_absolute_get_duration ( |
1512 | { | 1520 | crm->first_transmission_time)); |
1513 | GCC_latency_observed(cti, | ||
1514 | GNUNET_TIME_absolute_get_duration( | ||
1515 | crm->first_transmission_time)); | ||
1516 | } | ||
1517 | } | 1521 | } |
1518 | GNUNET_free(crm->data_message); | 1522 | } |
1519 | GNUNET_free(crm); | 1523 | GNUNET_free (crm->data_message); |
1520 | send_ack_to_client(ch, (NULL == ch->owner) ? GNUNET_NO : GNUNET_YES); | 1524 | GNUNET_free (crm); |
1525 | send_ack_to_client (ch, (NULL == ch->owner) ? GNUNET_NO : GNUNET_YES); | ||
1521 | } | 1526 | } |
1522 | 1527 | ||
1523 | 1528 | ||
@@ -1530,7 +1535,7 @@ handle_matching_ack(struct CadetChannel *ch, | |||
1530 | * @param ack details about what was received | 1535 | * @param ack details about what was received |
1531 | */ | 1536 | */ |
1532 | void | 1537 | void |
1533 | GCCH_handle_channel_plaintext_data_ack( | 1538 | GCCH_handle_channel_plaintext_data_ack ( |
1534 | struct CadetChannel *ch, | 1539 | struct CadetChannel *ch, |
1535 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 1540 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
1536 | const struct GNUNET_CADET_ChannelDataAckMessage *ack) | 1541 | const struct GNUNET_CADET_ChannelDataAckMessage *ack) |
@@ -1542,72 +1547,72 @@ GCCH_handle_channel_plaintext_data_ack( | |||
1542 | uint64_t mid_mask; | 1547 | uint64_t mid_mask; |
1543 | unsigned int delta; | 1548 | unsigned int delta; |
1544 | 1549 | ||
1545 | GNUNET_break(GNUNET_NO == ch->is_loopback); | 1550 | GNUNET_break (GNUNET_NO == ch->is_loopback); |
1546 | if (GNUNET_NO == ch->reliable) | 1551 | if (GNUNET_NO == ch->reliable) |
1547 | { | 1552 | { |
1548 | /* not expecting ACKs on unreliable channel, odd */ | 1553 | /* not expecting ACKs on unreliable channel, odd */ |
1549 | GNUNET_break_op(0); | 1554 | GNUNET_break_op (0); |
1550 | return; | 1555 | return; |
1551 | } | 1556 | } |
1552 | /* mid_base is the MID of the next message that the | 1557 | /* mid_base is the MID of the next message that the |
1553 | other peer expects (i.e. that is missing!), everything | 1558 | other peer expects (i.e. that is missing!), everything |
1554 | LOWER (but excluding mid_base itself) was received. */ | 1559 | LOWER (but excluding mid_base itself) was received. */ |
1555 | mid_base = ntohl(ack->mid.mid); | 1560 | mid_base = ntohl (ack->mid.mid); |
1556 | mid_mask = GNUNET_htonll(ack->futures); | 1561 | mid_mask = GNUNET_htonll (ack->futures); |
1557 | found = GNUNET_NO; | 1562 | found = GNUNET_NO; |
1558 | for (crm = ch->head_sent; NULL != crm; crm = crmn) | 1563 | for (crm = ch->head_sent; NULL != crm; crm = crmn) |
1564 | { | ||
1565 | crmn = crm->next; | ||
1566 | delta = (unsigned int) (ntohl (crm->data_message->mid.mid) - mid_base); | ||
1567 | if (delta >= UINT_MAX - ch->max_pending_messages) | ||
1559 | { | 1568 | { |
1560 | crmn = crm->next; | 1569 | /* overflow, means crm was a bit in the past, so this ACK counts for it. */ |
1561 | delta = (unsigned int)(ntohl(crm->data_message->mid.mid) - mid_base); | 1570 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1562 | if (delta >= UINT_MAX - ch->max_pending_messages) | 1571 | "Got DATA_ACK with base %u satisfying past message %u on %s\n", |
1563 | { | 1572 | (unsigned int) mid_base, |
1564 | /* overflow, means crm was a bit in the past, so this ACK counts for it. */ | 1573 | ntohl (crm->data_message->mid.mid), |
1565 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1574 | GCCH_2s (ch)); |
1566 | "Got DATA_ACK with base %u satisfying past message %u on %s\n", | 1575 | handle_matching_ack (ch, cti, crm); |
1567 | (unsigned int)mid_base, | 1576 | found = GNUNET_YES; |
1568 | ntohl(crm->data_message->mid.mid), | 1577 | continue; |
1569 | GCCH_2s(ch)); | ||
1570 | handle_matching_ack(ch, cti, crm); | ||
1571 | found = GNUNET_YES; | ||
1572 | continue; | ||
1573 | } | ||
1574 | delta--; | ||
1575 | if (delta >= 64) | ||
1576 | continue; | ||
1577 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1578 | "Testing bit %llX for mid %u (base: %u)\n", | ||
1579 | (1LLU << delta), | ||
1580 | ntohl(crm->data_message->mid.mid), | ||
1581 | mid_base); | ||
1582 | if (0 != (mid_mask & (1LLU << delta))) | ||
1583 | { | ||
1584 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1585 | "Got DATA_ACK with mask for %u on %s\n", | ||
1586 | ntohl(crm->data_message->mid.mid), | ||
1587 | GCCH_2s(ch)); | ||
1588 | handle_matching_ack(ch, cti, crm); | ||
1589 | found = GNUNET_YES; | ||
1590 | } | ||
1591 | } | 1578 | } |
1592 | if (GNUNET_NO == found) | 1579 | delta--; |
1580 | if (delta >= 64) | ||
1581 | continue; | ||
1582 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1583 | "Testing bit %llX for mid %u (base: %u)\n", | ||
1584 | (1LLU << delta), | ||
1585 | ntohl (crm->data_message->mid.mid), | ||
1586 | mid_base); | ||
1587 | if (0 != (mid_mask & (1LLU << delta))) | ||
1593 | { | 1588 | { |
1594 | /* ACK for message we already dropped, might have been a | 1589 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1595 | duplicate ACK? Ignore. */ | 1590 | "Got DATA_ACK with mask for %u on %s\n", |
1596 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1591 | ntohl (crm->data_message->mid.mid), |
1597 | "Duplicate DATA_ACK on %s, ignoring\n", | 1592 | GCCH_2s (ch)); |
1598 | GCCH_2s(ch)); | 1593 | handle_matching_ack (ch, cti, crm); |
1599 | GNUNET_STATISTICS_update(stats, "# duplicate DATA_ACKs", 1, GNUNET_NO); | 1594 | found = GNUNET_YES; |
1600 | return; | ||
1601 | } | 1595 | } |
1596 | } | ||
1597 | if (GNUNET_NO == found) | ||
1598 | { | ||
1599 | /* ACK for message we already dropped, might have been a | ||
1600 | duplicate ACK? Ignore. */ | ||
1601 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1602 | "Duplicate DATA_ACK on %s, ignoring\n", | ||
1603 | GCCH_2s (ch)); | ||
1604 | GNUNET_STATISTICS_update (stats, "# duplicate DATA_ACKs", 1, GNUNET_NO); | ||
1605 | return; | ||
1606 | } | ||
1602 | if (NULL != ch->retry_data_task) | 1607 | if (NULL != ch->retry_data_task) |
1603 | { | 1608 | { |
1604 | GNUNET_SCHEDULER_cancel(ch->retry_data_task); | 1609 | GNUNET_SCHEDULER_cancel (ch->retry_data_task); |
1605 | ch->retry_data_task = NULL; | 1610 | ch->retry_data_task = NULL; |
1606 | } | 1611 | } |
1607 | if ((NULL != ch->head_sent) && (NULL == ch->head_sent->qe)) | 1612 | if ((NULL != ch->head_sent) && (NULL == ch->head_sent->qe)) |
1608 | ch->retry_data_task = GNUNET_SCHEDULER_add_at(ch->head_sent->next_retry, | 1613 | ch->retry_data_task = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry, |
1609 | &retry_transmission, | 1614 | &retry_transmission, |
1610 | ch); | 1615 | ch); |
1611 | } | 1616 | } |
1612 | 1617 | ||
1613 | 1618 | ||
@@ -1621,34 +1626,34 @@ GCCH_handle_channel_plaintext_data_ack( | |||
1621 | * NULL if we are simulating receiving a destroy due to shutdown | 1626 | * NULL if we are simulating receiving a destroy due to shutdown |
1622 | */ | 1627 | */ |
1623 | void | 1628 | void |
1624 | GCCH_handle_remote_destroy( | 1629 | GCCH_handle_remote_destroy ( |
1625 | struct CadetChannel *ch, | 1630 | struct CadetChannel *ch, |
1626 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti) | 1631 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti) |
1627 | { | 1632 | { |
1628 | struct CadetChannelClient *ccc; | 1633 | struct CadetChannelClient *ccc; |
1629 | 1634 | ||
1630 | GNUNET_assert(GNUNET_NO == ch->is_loopback); | 1635 | GNUNET_assert (GNUNET_NO == ch->is_loopback); |
1631 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1636 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1632 | "Received remote channel DESTROY for %s\n", | 1637 | "Received remote channel DESTROY for %s\n", |
1633 | GCCH_2s(ch)); | 1638 | GCCH_2s (ch)); |
1634 | if (GNUNET_YES == ch->destroy) | 1639 | if (GNUNET_YES == ch->destroy) |
1635 | { | 1640 | { |
1636 | /* Local client already gone, this is instant-death. */ | 1641 | /* Local client already gone, this is instant-death. */ |
1637 | channel_destroy(ch); | 1642 | channel_destroy (ch); |
1638 | return; | 1643 | return; |
1639 | } | 1644 | } |
1640 | ccc = (NULL != ch->owner) ? ch->owner : ch->dest; | 1645 | ccc = (NULL != ch->owner) ? ch->owner : ch->dest; |
1641 | if ((NULL != ccc) && (NULL != ccc->head_recv)) | 1646 | if ((NULL != ccc) && (NULL != ccc->head_recv)) |
1642 | { | 1647 | { |
1643 | LOG(GNUNET_ERROR_TYPE_WARNING, | 1648 | LOG (GNUNET_ERROR_TYPE_WARNING, |
1644 | "Lost end of transmission due to remote shutdown on %s\n", | 1649 | "Lost end of transmission due to remote shutdown on %s\n", |
1645 | GCCH_2s(ch)); | 1650 | GCCH_2s (ch)); |
1646 | /* FIXME: change API to notify client about truncated transmission! */ | 1651 | /* FIXME: change API to notify client about truncated transmission! */ |
1647 | } | 1652 | } |
1648 | ch->destroy = GNUNET_YES; | 1653 | ch->destroy = GNUNET_YES; |
1649 | if (NULL != ccc) | 1654 | if (NULL != ccc) |
1650 | GSC_handle_remote_channel_destroy(ccc->c, ccc->ccn, ch); | 1655 | GSC_handle_remote_channel_destroy (ccc->c, ccc->ccn, ch); |
1651 | channel_destroy(ch); | 1656 | channel_destroy (ch); |
1652 | } | 1657 | } |
1653 | 1658 | ||
1654 | 1659 | ||
@@ -1661,9 +1666,9 @@ GCCH_handle_remote_destroy( | |||
1661 | * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO | 1666 | * @return #GNUNET_YES if @e1 < @e2, otherwise #GNUNET_NO |
1662 | */ | 1667 | */ |
1663 | static int | 1668 | static int |
1664 | cmp_crm_by_next_retry(void *cls, | 1669 | cmp_crm_by_next_retry (void *cls, |
1665 | struct CadetReliableMessage *crm1, | 1670 | struct CadetReliableMessage *crm1, |
1666 | struct CadetReliableMessage *crm2) | 1671 | struct CadetReliableMessage *crm2) |
1667 | { | 1672 | { |
1668 | if (crm1->next_retry.abs_value_us < crm2->next_retry.abs_value_us) | 1673 | if (crm1->next_retry.abs_value_us < crm2->next_retry.abs_value_us) |
1669 | return GNUNET_YES; | 1674 | return GNUNET_YES; |
@@ -1682,75 +1687,76 @@ cmp_crm_by_next_retry(void *cls, | |||
1682 | * if transmission failed | 1687 | * if transmission failed |
1683 | */ | 1688 | */ |
1684 | static void | 1689 | static void |
1685 | data_sent_cb(void *cls, | 1690 | data_sent_cb (void *cls, |
1686 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 1691 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
1687 | { | 1692 | { |
1688 | struct CadetReliableMessage *crm = cls; | 1693 | struct CadetReliableMessage *crm = cls; |
1689 | struct CadetChannel *ch = crm->ch; | 1694 | struct CadetChannel *ch = crm->ch; |
1690 | 1695 | ||
1691 | GNUNET_assert(GNUNET_NO == ch->is_loopback); | 1696 | GNUNET_assert (GNUNET_NO == ch->is_loopback); |
1692 | GNUNET_assert(NULL != crm->qe); | 1697 | GNUNET_assert (NULL != crm->qe); |
1693 | crm->qe = NULL; | 1698 | crm->qe = NULL; |
1694 | GNUNET_CONTAINER_DLL_remove(ch->head_sent, ch->tail_sent, crm); | 1699 | GNUNET_CONTAINER_DLL_remove (ch->head_sent, ch->tail_sent, crm); |
1695 | if (GNUNET_NO == ch->reliable) | 1700 | if (GNUNET_NO == ch->reliable) |
1696 | { | 1701 | { |
1697 | GNUNET_free(crm->data_message); | 1702 | GNUNET_free (crm->data_message); |
1698 | GNUNET_free(crm); | 1703 | GNUNET_free (crm); |
1699 | ch->pending_messages--; | 1704 | ch->pending_messages--; |
1700 | send_ack_to_client(ch, (NULL == ch->owner) ? GNUNET_NO : GNUNET_YES); | 1705 | send_ack_to_client (ch, (NULL == ch->owner) ? GNUNET_NO : GNUNET_YES); |
1701 | return; | 1706 | return; |
1702 | } | 1707 | } |
1703 | if (NULL == cid) | 1708 | if (NULL == cid) |
1704 | { | 1709 | { |
1705 | /* There was an error sending. */ | 1710 | /* There was an error sending. */ |
1706 | crm->num_transmissions = GNUNET_SYSERR; | 1711 | crm->num_transmissions = GNUNET_SYSERR; |
1707 | } | 1712 | } |
1708 | else if (GNUNET_SYSERR != crm->num_transmissions) | 1713 | else if (GNUNET_SYSERR != crm->num_transmissions) |
1714 | { | ||
1715 | /* Increment transmission counter, and possibly store @a cid | ||
1716 | if this was the first transmission. */ | ||
1717 | crm->num_transmissions++; | ||
1718 | if (1 == crm->num_transmissions) | ||
1709 | { | 1719 | { |
1710 | /* Increment transmission counter, and possibly store @a cid | 1720 | crm->first_transmission_time = GNUNET_TIME_absolute_get (); |
1711 | if this was the first transmission. */ | 1721 | crm->connection_taken = *cid; |
1712 | crm->num_transmissions++; | 1722 | GCC_ack_expected (cid); |
1713 | if (1 == crm->num_transmissions) | ||
1714 | { | ||
1715 | crm->first_transmission_time = GNUNET_TIME_absolute_get(); | ||
1716 | crm->connection_taken = *cid; | ||
1717 | GCC_ack_expected(cid); | ||
1718 | } | ||
1719 | } | 1723 | } |
1724 | } | ||
1720 | if ((0 == crm->retry_delay.rel_value_us) && (NULL != cid)) | 1725 | if ((0 == crm->retry_delay.rel_value_us) && (NULL != cid)) |
1721 | { | 1726 | { |
1722 | struct CadetConnection *cc = GCC_lookup(cid); | 1727 | struct CadetConnection *cc = GCC_lookup (cid); |
1723 | 1728 | ||
1724 | if (NULL != cc) | 1729 | if (NULL != cc) |
1725 | crm->retry_delay = GCC_get_metrics(cc)->aged_latency; | 1730 | crm->retry_delay = GCC_get_metrics (cc)->aged_latency; |
1726 | else | 1731 | else |
1727 | crm->retry_delay = ch->retry_time; | 1732 | crm->retry_delay = ch->retry_time; |
1728 | } | 1733 | } |
1729 | crm->retry_delay = GNUNET_TIME_STD_BACKOFF(crm->retry_delay); | 1734 | crm->retry_delay = GNUNET_TIME_STD_BACKOFF (crm->retry_delay); |
1730 | crm->retry_delay = GNUNET_TIME_relative_max(crm->retry_delay, MIN_RTT_DELAY); | 1735 | crm->retry_delay = GNUNET_TIME_relative_max (crm->retry_delay, MIN_RTT_DELAY); |
1731 | crm->next_retry = GNUNET_TIME_relative_to_absolute(crm->retry_delay); | 1736 | crm->next_retry = GNUNET_TIME_relative_to_absolute (crm->retry_delay); |
1732 | 1737 | ||
1733 | GNUNET_CONTAINER_DLL_insert_sorted(struct CadetReliableMessage, | 1738 | GNUNET_CONTAINER_DLL_insert_sorted (struct CadetReliableMessage, |
1734 | cmp_crm_by_next_retry, | 1739 | cmp_crm_by_next_retry, |
1735 | NULL, | 1740 | NULL, |
1736 | ch->head_sent, | 1741 | ch->head_sent, |
1737 | ch->tail_sent, | 1742 | ch->tail_sent, |
1738 | crm); | 1743 | crm); |
1739 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1744 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1740 | "Message %u sent, next transmission on %s in %s\n", | 1745 | "Message %u sent, next transmission on %s in %s\n", |
1741 | (unsigned int)ntohl(crm->data_message->mid.mid), | 1746 | (unsigned int) ntohl (crm->data_message->mid.mid), |
1742 | GCCH_2s(ch), | 1747 | GCCH_2s (ch), |
1743 | GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_remaining( | 1748 | GNUNET_STRINGS_relative_time_to_string ( |
1744 | ch->head_sent->next_retry), | 1749 | GNUNET_TIME_absolute_get_remaining ( |
1745 | GNUNET_YES)); | 1750 | ch->head_sent->next_retry), |
1751 | GNUNET_YES)); | ||
1746 | if (NULL == ch->head_sent->qe) | 1752 | if (NULL == ch->head_sent->qe) |
1747 | { | 1753 | { |
1748 | if (NULL != ch->retry_data_task) | 1754 | if (NULL != ch->retry_data_task) |
1749 | GNUNET_SCHEDULER_cancel(ch->retry_data_task); | 1755 | GNUNET_SCHEDULER_cancel (ch->retry_data_task); |
1750 | ch->retry_data_task = GNUNET_SCHEDULER_add_at(ch->head_sent->next_retry, | 1756 | ch->retry_data_task = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry, |
1751 | &retry_transmission, | 1757 | &retry_transmission, |
1752 | ch); | 1758 | ch); |
1753 | } | 1759 | } |
1754 | } | 1760 | } |
1755 | 1761 | ||
1756 | 1762 | ||
@@ -1769,100 +1775,100 @@ data_sent_cb(void *cls, | |||
1769 | * #GNUNET_SYSERR in case of an error. | 1775 | * #GNUNET_SYSERR in case of an error. |
1770 | */ | 1776 | */ |
1771 | int | 1777 | int |
1772 | GCCH_handle_local_data(struct CadetChannel *ch, | 1778 | GCCH_handle_local_data (struct CadetChannel *ch, |
1773 | struct GNUNET_CADET_ClientChannelNumber sender_ccn, | 1779 | struct GNUNET_CADET_ClientChannelNumber sender_ccn, |
1774 | const char *buf, | 1780 | const char *buf, |
1775 | size_t buf_len) | 1781 | size_t buf_len) |
1776 | { | 1782 | { |
1777 | struct CadetReliableMessage *crm; | 1783 | struct CadetReliableMessage *crm; |
1778 | 1784 | ||
1779 | if (ch->pending_messages >= ch->max_pending_messages) | 1785 | if (ch->pending_messages >= ch->max_pending_messages) |
1786 | { | ||
1787 | GNUNET_break (0); /* Fails: #5370 */ | ||
1788 | return GNUNET_SYSERR; | ||
1789 | } | ||
1790 | if (GNUNET_YES == ch->destroy) | ||
1791 | { | ||
1792 | /* we are going down, drop messages */ | ||
1793 | return GNUNET_OK; | ||
1794 | } | ||
1795 | ch->pending_messages++; | ||
1796 | |||
1797 | if (GNUNET_YES == ch->is_loopback) | ||
1798 | { | ||
1799 | struct CadetChannelClient *receiver; | ||
1800 | struct GNUNET_MQ_Envelope *env; | ||
1801 | struct GNUNET_CADET_LocalData *ld; | ||
1802 | int ack_to_owner; | ||
1803 | |||
1804 | env = | ||
1805 | GNUNET_MQ_msg_extra (ld, buf_len, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA); | ||
1806 | if ((NULL != ch->owner) && | ||
1807 | (sender_ccn.channel_of_client == ch->owner->ccn.channel_of_client)) | ||
1808 | { | ||
1809 | receiver = ch->dest; | ||
1810 | ack_to_owner = GNUNET_YES; | ||
1811 | } | ||
1812 | else if ((NULL != ch->dest) && | ||
1813 | (sender_ccn.channel_of_client == ch->dest->ccn.channel_of_client)) | ||
1814 | { | ||
1815 | receiver = ch->owner; | ||
1816 | ack_to_owner = GNUNET_NO; | ||
1817 | } | ||
1818 | else | ||
1780 | { | 1819 | { |
1781 | GNUNET_break(0); /* Fails: #5370 */ | 1820 | GNUNET_break (0); |
1782 | return GNUNET_SYSERR; | 1821 | return GNUNET_SYSERR; |
1783 | } | 1822 | } |
1784 | if (GNUNET_YES == ch->destroy) | 1823 | GNUNET_assert (NULL != receiver); |
1824 | ld->ccn = receiver->ccn; | ||
1825 | GNUNET_memcpy (&ld[1], buf, buf_len); | ||
1826 | if (GNUNET_YES == receiver->client_ready) | ||
1785 | { | 1827 | { |
1786 | /* we are going down, drop messages */ | 1828 | ch->pending_messages--; |
1787 | return GNUNET_OK; | 1829 | GSC_send_to_client (receiver->c, env); |
1830 | send_ack_to_client (ch, ack_to_owner); | ||
1788 | } | 1831 | } |
1789 | ch->pending_messages++; | 1832 | else |
1790 | |||
1791 | if (GNUNET_YES == ch->is_loopback) | ||
1792 | { | 1833 | { |
1793 | struct CadetChannelClient *receiver; | 1834 | struct CadetOutOfOrderMessage *oom; |
1794 | struct GNUNET_MQ_Envelope *env; | 1835 | |
1795 | struct GNUNET_CADET_LocalData *ld; | 1836 | oom = GNUNET_new (struct CadetOutOfOrderMessage); |
1796 | int ack_to_owner; | 1837 | oom->env = env; |
1797 | 1838 | GNUNET_CONTAINER_DLL_insert_tail (receiver->head_recv, | |
1798 | env = | 1839 | receiver->tail_recv, |
1799 | GNUNET_MQ_msg_extra(ld, buf_len, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA); | 1840 | oom); |
1800 | if ((NULL != ch->owner) && | 1841 | receiver->num_recv++; |
1801 | (sender_ccn.channel_of_client == ch->owner->ccn.channel_of_client)) | ||
1802 | { | ||
1803 | receiver = ch->dest; | ||
1804 | ack_to_owner = GNUNET_YES; | ||
1805 | } | ||
1806 | else if ((NULL != ch->dest) && | ||
1807 | (sender_ccn.channel_of_client == ch->dest->ccn.channel_of_client)) | ||
1808 | { | ||
1809 | receiver = ch->owner; | ||
1810 | ack_to_owner = GNUNET_NO; | ||
1811 | } | ||
1812 | else | ||
1813 | { | ||
1814 | GNUNET_break(0); | ||
1815 | return GNUNET_SYSERR; | ||
1816 | } | ||
1817 | GNUNET_assert(NULL != receiver); | ||
1818 | ld->ccn = receiver->ccn; | ||
1819 | GNUNET_memcpy(&ld[1], buf, buf_len); | ||
1820 | if (GNUNET_YES == receiver->client_ready) | ||
1821 | { | ||
1822 | ch->pending_messages--; | ||
1823 | GSC_send_to_client(receiver->c, env); | ||
1824 | send_ack_to_client(ch, ack_to_owner); | ||
1825 | } | ||
1826 | else | ||
1827 | { | ||
1828 | struct CadetOutOfOrderMessage *oom; | ||
1829 | |||
1830 | oom = GNUNET_new(struct CadetOutOfOrderMessage); | ||
1831 | oom->env = env; | ||
1832 | GNUNET_CONTAINER_DLL_insert_tail(receiver->head_recv, | ||
1833 | receiver->tail_recv, | ||
1834 | oom); | ||
1835 | receiver->num_recv++; | ||
1836 | } | ||
1837 | return GNUNET_OK; | ||
1838 | } | 1842 | } |
1843 | return GNUNET_OK; | ||
1844 | } | ||
1839 | 1845 | ||
1840 | /* Everything is correct, send the message. */ | 1846 | /* Everything is correct, send the message. */ |
1841 | crm = GNUNET_malloc(sizeof(*crm)); | 1847 | crm = GNUNET_malloc (sizeof(*crm)); |
1842 | crm->ch = ch; | 1848 | crm->ch = ch; |
1843 | crm->data_message = GNUNET_malloc( | 1849 | crm->data_message = GNUNET_malloc ( |
1844 | sizeof(struct GNUNET_CADET_ChannelAppDataMessage) + buf_len); | 1850 | sizeof(struct GNUNET_CADET_ChannelAppDataMessage) + buf_len); |
1845 | crm->data_message->header.size = | 1851 | crm->data_message->header.size = |
1846 | htons(sizeof(struct GNUNET_CADET_ChannelAppDataMessage) + buf_len); | 1852 | htons (sizeof(struct GNUNET_CADET_ChannelAppDataMessage) + buf_len); |
1847 | crm->data_message->header.type = | 1853 | crm->data_message->header.type = |
1848 | htons(GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA); | 1854 | htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA); |
1849 | ch->mid_send.mid = htonl(ntohl(ch->mid_send.mid) + 1); | 1855 | ch->mid_send.mid = htonl (ntohl (ch->mid_send.mid) + 1); |
1850 | crm->data_message->mid = ch->mid_send; | 1856 | crm->data_message->mid = ch->mid_send; |
1851 | crm->data_message->ctn = ch->ctn; | 1857 | crm->data_message->ctn = ch->ctn; |
1852 | GNUNET_memcpy(&crm->data_message[1], buf, buf_len); | 1858 | GNUNET_memcpy (&crm->data_message[1], buf, buf_len); |
1853 | GNUNET_CONTAINER_DLL_insert_tail(ch->head_sent, ch->tail_sent, crm); | 1859 | GNUNET_CONTAINER_DLL_insert_tail (ch->head_sent, ch->tail_sent, crm); |
1854 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1860 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1855 | "Sending message %u from local client to %s with %u bytes\n", | 1861 | "Sending message %u from local client to %s with %u bytes\n", |
1856 | ntohl(crm->data_message->mid.mid), | 1862 | ntohl (crm->data_message->mid.mid), |
1857 | GCCH_2s(ch), | 1863 | GCCH_2s (ch), |
1858 | buf_len); | 1864 | buf_len); |
1859 | if (NULL != ch->retry_data_task) | 1865 | if (NULL != ch->retry_data_task) |
1860 | { | 1866 | { |
1861 | GNUNET_SCHEDULER_cancel(ch->retry_data_task); | 1867 | GNUNET_SCHEDULER_cancel (ch->retry_data_task); |
1862 | ch->retry_data_task = NULL; | 1868 | ch->retry_data_task = NULL; |
1863 | } | 1869 | } |
1864 | crm->qe = GCT_send(ch->t, &crm->data_message->header, &data_sent_cb, crm); | 1870 | crm->qe = GCT_send (ch->t, &crm->data_message->header, &data_sent_cb, crm); |
1865 | GNUNET_assert(NULL == ch->retry_data_task); | 1871 | GNUNET_assert (NULL == ch->retry_data_task); |
1866 | return GNUNET_OK; | 1872 | return GNUNET_OK; |
1867 | } | 1873 | } |
1868 | 1874 | ||
@@ -1875,8 +1881,8 @@ GCCH_handle_local_data(struct CadetChannel *ch, | |||
1875 | * @param client_ccn ccn of the client sending the ack | 1881 | * @param client_ccn ccn of the client sending the ack |
1876 | */ | 1882 | */ |
1877 | void | 1883 | void |
1878 | GCCH_handle_local_ack(struct CadetChannel *ch, | 1884 | GCCH_handle_local_ack (struct CadetChannel *ch, |
1879 | struct GNUNET_CADET_ClientChannelNumber client_ccn) | 1885 | struct GNUNET_CADET_ClientChannelNumber client_ccn) |
1880 | { | 1886 | { |
1881 | struct CadetChannelClient *ccc; | 1887 | struct CadetChannelClient *ccc; |
1882 | struct CadetOutOfOrderMessage *com; | 1888 | struct CadetOutOfOrderMessage *com; |
@@ -1888,87 +1894,87 @@ GCCH_handle_local_ack(struct CadetChannel *ch, | |||
1888 | (ch->dest->ccn.channel_of_client == client_ccn.channel_of_client)) | 1894 | (ch->dest->ccn.channel_of_client == client_ccn.channel_of_client)) |
1889 | ccc = ch->dest; | 1895 | ccc = ch->dest; |
1890 | else | 1896 | else |
1891 | GNUNET_assert(0); | 1897 | GNUNET_assert (0); |
1892 | ccc->client_ready = GNUNET_YES; | 1898 | ccc->client_ready = GNUNET_YES; |
1893 | com = ccc->head_recv; | 1899 | com = ccc->head_recv; |
1894 | if (NULL == com) | 1900 | if (NULL == com) |
1901 | { | ||
1902 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1903 | "Got LOCAL_ACK, %s-%X ready to receive more data, but none pending on %s-%X(%p)!\n", | ||
1904 | GSC_2s (ccc->c), | ||
1905 | ntohl (client_ccn.channel_of_client), | ||
1906 | GCCH_2s (ch), | ||
1907 | ntohl (ccc->ccn.channel_of_client), | ||
1908 | ccc); | ||
1909 | return; /* none pending */ | ||
1910 | } | ||
1911 | if (GNUNET_YES == ch->is_loopback) | ||
1912 | { | ||
1913 | int to_owner; | ||
1914 | |||
1915 | /* Messages are always in-order, just send */ | ||
1916 | GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com); | ||
1917 | ccc->num_recv--; | ||
1918 | GSC_send_to_client (ccc->c, com->env); | ||
1919 | /* Notify sender that we can receive more */ | ||
1920 | if ((NULL != ch->owner) && | ||
1921 | (ccc->ccn.channel_of_client == ch->owner->ccn.channel_of_client)) | ||
1895 | { | 1922 | { |
1896 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1923 | to_owner = GNUNET_NO; |
1897 | "Got LOCAL_ACK, %s-%X ready to receive more data, but none pending on %s-%X(%p)!\n", | ||
1898 | GSC_2s(ccc->c), | ||
1899 | ntohl(client_ccn.channel_of_client), | ||
1900 | GCCH_2s(ch), | ||
1901 | ntohl(ccc->ccn.channel_of_client), | ||
1902 | ccc); | ||
1903 | return; /* none pending */ | ||
1904 | } | 1924 | } |
1905 | if (GNUNET_YES == ch->is_loopback) | 1925 | else |
1906 | { | 1926 | { |
1907 | int to_owner; | 1927 | GNUNET_assert ((NULL != ch->dest) && (ccc->ccn.channel_of_client == |
1908 | 1928 | ch->dest->ccn.channel_of_client)); | |
1909 | /* Messages are always in-order, just send */ | 1929 | to_owner = GNUNET_YES; |
1910 | GNUNET_CONTAINER_DLL_remove(ccc->head_recv, ccc->tail_recv, com); | ||
1911 | ccc->num_recv--; | ||
1912 | GSC_send_to_client(ccc->c, com->env); | ||
1913 | /* Notify sender that we can receive more */ | ||
1914 | if ((NULL != ch->owner) && | ||
1915 | (ccc->ccn.channel_of_client == ch->owner->ccn.channel_of_client)) | ||
1916 | { | ||
1917 | to_owner = GNUNET_NO; | ||
1918 | } | ||
1919 | else | ||
1920 | { | ||
1921 | GNUNET_assert((NULL != ch->dest) && (ccc->ccn.channel_of_client == | ||
1922 | ch->dest->ccn.channel_of_client)); | ||
1923 | to_owner = GNUNET_YES; | ||
1924 | } | ||
1925 | send_ack_to_client(ch, to_owner); | ||
1926 | GNUNET_free(com); | ||
1927 | return; | ||
1928 | } | 1930 | } |
1931 | send_ack_to_client (ch, to_owner); | ||
1932 | GNUNET_free (com); | ||
1933 | return; | ||
1934 | } | ||
1929 | 1935 | ||
1930 | if ((com->mid.mid != ch->mid_recv.mid) && (GNUNET_NO == ch->out_of_order) && | 1936 | if ((com->mid.mid != ch->mid_recv.mid) && (GNUNET_NO == ch->out_of_order) && |
1931 | (GNUNET_YES == ch->reliable)) | 1937 | (GNUNET_YES == ch->reliable)) |
1932 | { | 1938 | { |
1933 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1939 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1934 | "Got LOCAL_ACK, %s-%X ready to receive more data (but next one is out-of-order %u vs. %u)!\n", | 1940 | "Got LOCAL_ACK, %s-%X ready to receive more data (but next one is out-of-order %u vs. %u)!\n", |
1935 | GSC_2s(ccc->c), | 1941 | GSC_2s (ccc->c), |
1936 | ntohl(ccc->ccn.channel_of_client), | 1942 | ntohl (ccc->ccn.channel_of_client), |
1937 | ntohl(com->mid.mid), | 1943 | ntohl (com->mid.mid), |
1938 | ntohl(ch->mid_recv.mid)); | 1944 | ntohl (ch->mid_recv.mid)); |
1939 | return; /* missing next one in-order */ | 1945 | return; /* missing next one in-order */ |
1940 | } | 1946 | } |
1941 | 1947 | ||
1942 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1948 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1943 | "Got LOCAL_ACK, giving payload message %u to %s-%X on %s\n", | 1949 | "Got LOCAL_ACK, giving payload message %u to %s-%X on %s\n", |
1944 | ntohl(com->mid.mid), | 1950 | ntohl (com->mid.mid), |
1945 | GSC_2s(ccc->c), | 1951 | GSC_2s (ccc->c), |
1946 | ntohl(ccc->ccn.channel_of_client), | 1952 | ntohl (ccc->ccn.channel_of_client), |
1947 | GCCH_2s(ch)); | 1953 | GCCH_2s (ch)); |
1948 | 1954 | ||
1949 | /* all good, pass next message to client */ | 1955 | /* all good, pass next message to client */ |
1950 | GNUNET_CONTAINER_DLL_remove(ccc->head_recv, ccc->tail_recv, com); | 1956 | GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com); |
1951 | ccc->num_recv--; | 1957 | ccc->num_recv--; |
1952 | /* FIXME: if unreliable, this is not aggressive | 1958 | /* FIXME: if unreliable, this is not aggressive |
1953 | enough, as it would be OK to have lost some! */ | 1959 | enough, as it would be OK to have lost some! */ |
1954 | 1960 | ||
1955 | ch->mid_recv.mid = htonl(1 + ntohl(com->mid.mid)); | 1961 | ch->mid_recv.mid = htonl (1 + ntohl (com->mid.mid)); |
1956 | ch->mid_futures >>= 1; /* equivalent to division by 2 */ | 1962 | ch->mid_futures >>= 1; /* equivalent to division by 2 */ |
1957 | ccc->client_ready = GNUNET_NO; | 1963 | ccc->client_ready = GNUNET_NO; |
1958 | GSC_send_to_client(ccc->c, com->env); | 1964 | GSC_send_to_client (ccc->c, com->env); |
1959 | GNUNET_free(com); | 1965 | GNUNET_free (com); |
1960 | send_channel_data_ack(ch); | 1966 | send_channel_data_ack (ch); |
1961 | if (NULL != ccc->head_recv) | 1967 | if (NULL != ccc->head_recv) |
1962 | return; | 1968 | return; |
1963 | if (GNUNET_NO == ch->destroy) | 1969 | if (GNUNET_NO == ch->destroy) |
1964 | return; | 1970 | return; |
1965 | GCT_send_channel_destroy(ch->t, ch->ctn); | 1971 | GCT_send_channel_destroy (ch->t, ch->ctn); |
1966 | channel_destroy(ch); | 1972 | channel_destroy (ch); |
1967 | } | 1973 | } |
1968 | 1974 | ||
1969 | 1975 | ||
1970 | #define LOG2(level, ...) \ | 1976 | #define LOG2(level, ...) \ |
1971 | GNUNET_log_from_nocheck(level, "cadet-chn", __VA_ARGS__) | 1977 | GNUNET_log_from_nocheck (level, "cadet-chn", __VA_ARGS__) |
1972 | 1978 | ||
1973 | 1979 | ||
1974 | /** | 1980 | /** |
@@ -1978,46 +1984,46 @@ GCCH_handle_local_ack(struct CadetChannel *ch, | |||
1978 | * @param level Debug level to use. | 1984 | * @param level Debug level to use. |
1979 | */ | 1985 | */ |
1980 | void | 1986 | void |
1981 | GCCH_debug(struct CadetChannel *ch, enum GNUNET_ErrorType level) | 1987 | GCCH_debug (struct CadetChannel *ch, enum GNUNET_ErrorType level) |
1982 | { | 1988 | { |
1983 | #if !defined(GNUNET_CULL_LOGGING) | 1989 | #if ! defined(GNUNET_CULL_LOGGING) |
1984 | int do_log; | 1990 | int do_log; |
1985 | 1991 | ||
1986 | do_log = GNUNET_get_log_call_status(level & (~GNUNET_ERROR_TYPE_BULK), | 1992 | do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK), |
1987 | "cadet-chn", | 1993 | "cadet-chn", |
1988 | __FILE__, | 1994 | __FILE__, |
1989 | __FUNCTION__, | 1995 | __FUNCTION__, |
1990 | __LINE__); | 1996 | __LINE__); |
1991 | if (0 == do_log) | 1997 | if (0 == do_log) |
1992 | return; | 1998 | return; |
1993 | 1999 | ||
1994 | if (NULL == ch) | 2000 | if (NULL == ch) |
1995 | { | 2001 | { |
1996 | LOG2(level, "CHN *** DEBUG NULL CHANNEL ***\n"); | 2002 | LOG2 (level, "CHN *** DEBUG NULL CHANNEL ***\n"); |
1997 | return; | 2003 | return; |
1998 | } | 2004 | } |
1999 | LOG2(level, "CHN %s:%X (%p)\n", GCT_2s(ch->t), ch->ctn, ch); | 2005 | LOG2 (level, "CHN %s:%X (%p)\n", GCT_2s (ch->t), ch->ctn, ch); |
2000 | if (NULL != ch->owner) | 2006 | if (NULL != ch->owner) |
2001 | { | 2007 | { |
2002 | LOG2(level, | 2008 | LOG2 (level, |
2003 | "CHN origin %s ready %s local-id: %u\n", | 2009 | "CHN origin %s ready %s local-id: %u\n", |
2004 | GSC_2s(ch->owner->c), | 2010 | GSC_2s (ch->owner->c), |
2005 | ch->owner->client_ready ? "YES" : "NO", | 2011 | ch->owner->client_ready ? "YES" : "NO", |
2006 | ntohl(ch->owner->ccn.channel_of_client)); | 2012 | ntohl (ch->owner->ccn.channel_of_client)); |
2007 | } | 2013 | } |
2008 | if (NULL != ch->dest) | 2014 | if (NULL != ch->dest) |
2009 | { | 2015 | { |
2010 | LOG2(level, | 2016 | LOG2 (level, |
2011 | "CHN destination %s ready %s local-id: %u\n", | 2017 | "CHN destination %s ready %s local-id: %u\n", |
2012 | GSC_2s(ch->dest->c), | 2018 | GSC_2s (ch->dest->c), |
2013 | ch->dest->client_ready ? "YES" : "NO", | 2019 | ch->dest->client_ready ? "YES" : "NO", |
2014 | ntohl(ch->dest->ccn.channel_of_client)); | 2020 | ntohl (ch->dest->ccn.channel_of_client)); |
2015 | } | 2021 | } |
2016 | LOG2(level, | 2022 | LOG2 (level, |
2017 | "CHN Message IDs recv: %d (%LLX), send: %d\n", | 2023 | "CHN Message IDs recv: %d (%LLX), send: %d\n", |
2018 | ntohl(ch->mid_recv.mid), | 2024 | ntohl (ch->mid_recv.mid), |
2019 | (unsigned long long)ch->mid_futures, | 2025 | (unsigned long long) ch->mid_futures, |
2020 | ntohl(ch->mid_send.mid)); | 2026 | ntohl (ch->mid_send.mid)); |
2021 | #endif | 2027 | #endif |
2022 | } | 2028 | } |
2023 | 2029 | ||
diff --git a/src/cadet/gnunet-service-cadet_channel.h b/src/cadet/gnunet-service-cadet_channel.h index a64d4058e..181c6e88b 100644 --- a/src/cadet/gnunet-service-cadet_channel.h +++ b/src/cadet/gnunet-service-cadet_channel.h | |||
@@ -53,9 +53,9 @@ struct CadetChannel; | |||
53 | * @param listener peer that is listining on @a port | 53 | * @param listener peer that is listining on @a port |
54 | */ | 54 | */ |
55 | void | 55 | void |
56 | GCCH_hash_port(struct GNUNET_HashCode *h_port, | 56 | GCCH_hash_port (struct GNUNET_HashCode *h_port, |
57 | const struct GNUNET_HashCode *port, | 57 | const struct GNUNET_HashCode *port, |
58 | const struct GNUNET_PeerIdentity *listener); | 58 | const struct GNUNET_PeerIdentity *listener); |
59 | 59 | ||
60 | 60 | ||
61 | /** | 61 | /** |
@@ -66,7 +66,7 @@ GCCH_hash_port(struct GNUNET_HashCode *h_port, | |||
66 | * @return Static string with the channel IDs. | 66 | * @return Static string with the channel IDs. |
67 | */ | 67 | */ |
68 | const char * | 68 | const char * |
69 | GCCH_2s(const struct CadetChannel *ch); | 69 | GCCH_2s (const struct CadetChannel *ch); |
70 | 70 | ||
71 | 71 | ||
72 | /** | 72 | /** |
@@ -76,8 +76,8 @@ GCCH_2s(const struct CadetChannel *ch); | |||
76 | * @param level Debug level to use. | 76 | * @param level Debug level to use. |
77 | */ | 77 | */ |
78 | void | 78 | void |
79 | GCCH_debug(struct CadetChannel *ch, | 79 | GCCH_debug (struct CadetChannel *ch, |
80 | enum GNUNET_ErrorType level); | 80 | enum GNUNET_ErrorType level); |
81 | 81 | ||
82 | 82 | ||
83 | /** | 83 | /** |
@@ -88,7 +88,7 @@ GCCH_debug(struct CadetChannel *ch, | |||
88 | * @return ID used to identify the channel with the remote peer. | 88 | * @return ID used to identify the channel with the remote peer. |
89 | */ | 89 | */ |
90 | struct GNUNET_CADET_ChannelTunnelNumber | 90 | struct GNUNET_CADET_ChannelTunnelNumber |
91 | GCCH_get_id(const struct CadetChannel *ch); | 91 | GCCH_get_id (const struct CadetChannel *ch); |
92 | 92 | ||
93 | 93 | ||
94 | /** | 94 | /** |
@@ -102,11 +102,11 @@ GCCH_get_id(const struct CadetChannel *ch); | |||
102 | * @return handle to the new channel | 102 | * @return handle to the new channel |
103 | */ | 103 | */ |
104 | struct CadetChannel * | 104 | struct CadetChannel * |
105 | GCCH_channel_local_new(struct CadetClient *owner, | 105 | GCCH_channel_local_new (struct CadetClient *owner, |
106 | struct GNUNET_CADET_ClientChannelNumber owner_id, | 106 | struct GNUNET_CADET_ClientChannelNumber owner_id, |
107 | struct CadetPeer *destination, | 107 | struct CadetPeer *destination, |
108 | const struct GNUNET_HashCode *port, | 108 | const struct GNUNET_HashCode *port, |
109 | uint32_t options); | 109 | uint32_t options); |
110 | 110 | ||
111 | 111 | ||
112 | /** | 112 | /** |
@@ -119,9 +119,9 @@ GCCH_channel_local_new(struct CadetClient *owner, | |||
119 | * @param port port number @a c is listening on | 119 | * @param port port number @a c is listening on |
120 | */ | 120 | */ |
121 | void | 121 | void |
122 | GCCH_bind(struct CadetChannel *ch, | 122 | GCCH_bind (struct CadetChannel *ch, |
123 | struct CadetClient *c, | 123 | struct CadetClient *c, |
124 | const struct GNUNET_HashCode *port); | 124 | const struct GNUNET_HashCode *port); |
125 | 125 | ||
126 | 126 | ||
127 | /** | 127 | /** |
@@ -133,9 +133,9 @@ GCCH_bind(struct CadetChannel *ch, | |||
133 | * @param ccn client number of the client @a c | 133 | * @param ccn client number of the client @a c |
134 | */ | 134 | */ |
135 | void | 135 | void |
136 | GCCH_channel_local_destroy(struct CadetChannel *ch, | 136 | GCCH_channel_local_destroy (struct CadetChannel *ch, |
137 | struct CadetClient *c, | 137 | struct CadetClient *c, |
138 | struct GNUNET_CADET_ClientChannelNumber ccn); | 138 | struct GNUNET_CADET_ClientChannelNumber ccn); |
139 | 139 | ||
140 | 140 | ||
141 | /** | 141 | /** |
@@ -149,7 +149,7 @@ GCCH_channel_local_destroy(struct CadetChannel *ch, | |||
149 | * @param ch the channel for which the tunnel is now ready | 149 | * @param ch the channel for which the tunnel is now ready |
150 | */ | 150 | */ |
151 | void | 151 | void |
152 | GCCH_tunnel_up(struct CadetChannel *ch); | 152 | GCCH_tunnel_up (struct CadetChannel *ch); |
153 | 153 | ||
154 | 154 | ||
155 | /** | 155 | /** |
@@ -163,10 +163,10 @@ GCCH_tunnel_up(struct CadetChannel *ch); | |||
163 | * @return handle to the new channel | 163 | * @return handle to the new channel |
164 | */ | 164 | */ |
165 | struct CadetChannel * | 165 | struct CadetChannel * |
166 | GCCH_channel_incoming_new(struct CadetTunnel *t, | 166 | GCCH_channel_incoming_new (struct CadetTunnel *t, |
167 | struct GNUNET_CADET_ChannelTunnelNumber chid, | 167 | struct GNUNET_CADET_ChannelTunnelNumber chid, |
168 | const struct GNUNET_HashCode *h_port, | 168 | const struct GNUNET_HashCode *h_port, |
169 | uint32_t options); | 169 | uint32_t options); |
170 | 170 | ||
171 | 171 | ||
172 | /** | 172 | /** |
@@ -178,8 +178,9 @@ GCCH_channel_incoming_new(struct CadetTunnel *t, | |||
178 | * @param cti identifier of the connection that delivered the message | 178 | * @param cti identifier of the connection that delivered the message |
179 | */ | 179 | */ |
180 | void | 180 | void |
181 | GCCH_handle_duplicate_open(struct CadetChannel *ch, | 181 | GCCH_handle_duplicate_open (struct CadetChannel *ch, |
182 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti); | 182 | const struct |
183 | GNUNET_CADET_ConnectionTunnelIdentifier *cti); | ||
183 | 184 | ||
184 | 185 | ||
185 | 186 | ||
@@ -191,9 +192,11 @@ GCCH_handle_duplicate_open(struct CadetChannel *ch, | |||
191 | * @param msg message that was received | 192 | * @param msg message that was received |
192 | */ | 193 | */ |
193 | void | 194 | void |
194 | GCCH_handle_channel_plaintext_data(struct CadetChannel *ch, | 195 | GCCH_handle_channel_plaintext_data (struct CadetChannel *ch, |
195 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 196 | const struct |
196 | const struct GNUNET_CADET_ChannelAppDataMessage *msg); | 197 | GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
198 | const struct | ||
199 | GNUNET_CADET_ChannelAppDataMessage *msg); | ||
197 | 200 | ||
198 | 201 | ||
199 | /** | 202 | /** |
@@ -205,9 +208,12 @@ GCCH_handle_channel_plaintext_data(struct CadetChannel *ch, | |||
205 | * @param ack details about what was received | 208 | * @param ack details about what was received |
206 | */ | 209 | */ |
207 | void | 210 | void |
208 | GCCH_handle_channel_plaintext_data_ack(struct CadetChannel *ch, | 211 | GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch, |
209 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 212 | const struct |
210 | const struct GNUNET_CADET_ChannelDataAckMessage *ack); | 213 | GNUNET_CADET_ConnectionTunnelIdentifier |
214 | *cti, | ||
215 | const struct | ||
216 | GNUNET_CADET_ChannelDataAckMessage *ack); | ||
211 | 217 | ||
212 | 218 | ||
213 | /** | 219 | /** |
@@ -220,9 +226,10 @@ GCCH_handle_channel_plaintext_data_ack(struct CadetChannel *ch, | |||
220 | * @param port port number (needed to verify receiver knows the port) | 226 | * @param port port number (needed to verify receiver knows the port) |
221 | */ | 227 | */ |
222 | void | 228 | void |
223 | GCCH_handle_channel_open_ack(struct CadetChannel *ch, | 229 | GCCH_handle_channel_open_ack (struct CadetChannel *ch, |
224 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 230 | const struct |
225 | const struct GNUNET_HashCode *port); | 231 | GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
232 | const struct GNUNET_HashCode *port); | ||
226 | 233 | ||
227 | 234 | ||
228 | /** | 235 | /** |
@@ -242,8 +249,9 @@ GCCH_handle_channel_open_ack(struct CadetChannel *ch, | |||
242 | * NULL during shutdown | 249 | * NULL during shutdown |
243 | */ | 250 | */ |
244 | void | 251 | void |
245 | GCCH_handle_remote_destroy(struct CadetChannel *ch, | 252 | GCCH_handle_remote_destroy (struct CadetChannel *ch, |
246 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti); | 253 | const struct |
254 | GNUNET_CADET_ConnectionTunnelIdentifier *cti); | ||
247 | 255 | ||
248 | 256 | ||
249 | /** | 257 | /** |
@@ -261,10 +269,10 @@ GCCH_handle_remote_destroy(struct CadetChannel *ch, | |||
261 | * #GNUNET_SYSERR in case of an error. | 269 | * #GNUNET_SYSERR in case of an error. |
262 | */ | 270 | */ |
263 | int | 271 | int |
264 | GCCH_handle_local_data(struct CadetChannel *ch, | 272 | GCCH_handle_local_data (struct CadetChannel *ch, |
265 | struct GNUNET_CADET_ClientChannelNumber sender_ccn, | 273 | struct GNUNET_CADET_ClientChannelNumber sender_ccn, |
266 | const char *buf, | 274 | const char *buf, |
267 | size_t buf_len); | 275 | size_t buf_len); |
268 | 276 | ||
269 | 277 | ||
270 | /** | 278 | /** |
@@ -274,7 +282,7 @@ GCCH_handle_local_data(struct CadetChannel *ch, | |||
274 | * @param client_ccn ccn of the client sending the ack | 282 | * @param client_ccn ccn of the client sending the ack |
275 | */ | 283 | */ |
276 | void | 284 | void |
277 | GCCH_handle_local_ack(struct CadetChannel *ch, | 285 | GCCH_handle_local_ack (struct CadetChannel *ch, |
278 | struct GNUNET_CADET_ClientChannelNumber client_ccn); | 286 | struct GNUNET_CADET_ClientChannelNumber client_ccn); |
279 | 287 | ||
280 | #endif | 288 | #endif |
diff --git a/src/cadet/gnunet-service-cadet_connection.c b/src/cadet/gnunet-service-cadet_connection.c index e3c1a4124..66dc20481 100644 --- a/src/cadet/gnunet-service-cadet_connection.c +++ b/src/cadet/gnunet-service-cadet_connection.c | |||
@@ -35,7 +35,7 @@ | |||
35 | #include "cadet_protocol.h" | 35 | #include "cadet_protocol.h" |
36 | 36 | ||
37 | 37 | ||
38 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-con", __VA_ARGS__) | 38 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-con", __VA_ARGS__) |
39 | 39 | ||
40 | 40 | ||
41 | /** | 41 | /** |
@@ -43,13 +43,14 @@ | |||
43 | * TODO: replace by 2 RTT if/once we have connection-level RTT data! | 43 | * TODO: replace by 2 RTT if/once we have connection-level RTT data! |
44 | */ | 44 | */ |
45 | #define INITIAL_CONNECTION_CREATE_RETRY_DELAY \ | 45 | #define INITIAL_CONNECTION_CREATE_RETRY_DELAY \ |
46 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200) | 46 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 200) |
47 | 47 | ||
48 | 48 | ||
49 | /** | 49 | /** |
50 | * All the states a connection can be in. | 50 | * All the states a connection can be in. |
51 | */ | 51 | */ |
52 | enum CadetConnectionState { | 52 | enum CadetConnectionState |
53 | { | ||
53 | /** | 54 | /** |
54 | * Uninitialized status, we have not yet even gotten the message queue. | 55 | * Uninitialized status, we have not yet even gotten the message queue. |
55 | */ | 56 | */ |
@@ -81,7 +82,8 @@ enum CadetConnectionState { | |||
81 | /** | 82 | /** |
82 | * Low-level connection to a destination. | 83 | * Low-level connection to a destination. |
83 | */ | 84 | */ |
84 | struct CadetConnection { | 85 | struct CadetConnection |
86 | { | ||
85 | /** | 87 | /** |
86 | * ID of the connection. | 88 | * ID of the connection. |
87 | */ | 89 | */ |
@@ -181,10 +183,10 @@ struct CadetConnection { | |||
181 | * @return NULL if connection was not found | 183 | * @return NULL if connection was not found |
182 | */ | 184 | */ |
183 | struct CadetConnection * | 185 | struct CadetConnection * |
184 | GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 186 | GCC_lookup (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
185 | { | 187 | { |
186 | return GNUNET_CONTAINER_multishortmap_get(connections, | 188 | return GNUNET_CONTAINER_multishortmap_get (connections, |
187 | &cid->connection_of_tunnel); | 189 | &cid->connection_of_tunnel); |
188 | } | 190 | } |
189 | 191 | ||
190 | 192 | ||
@@ -197,9 +199,9 @@ GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | |||
197 | * @param new_mqm_ready new `mqm_ready` state for @a cc | 199 | * @param new_mqm_ready new `mqm_ready` state for @a cc |
198 | */ | 200 | */ |
199 | static void | 201 | static void |
200 | update_state(struct CadetConnection *cc, | 202 | update_state (struct CadetConnection *cc, |
201 | enum CadetConnectionState new_state, | 203 | enum CadetConnectionState new_state, |
202 | int new_mqm_ready) | 204 | int new_mqm_ready) |
203 | { | 205 | { |
204 | int old_ready; | 206 | int old_ready; |
205 | int new_ready; | 207 | int new_ready; |
@@ -213,7 +215,7 @@ update_state(struct CadetConnection *cc, | |||
213 | cc->state = new_state; | 215 | cc->state = new_state; |
214 | cc->mqm_ready = new_mqm_ready; | 216 | cc->mqm_ready = new_mqm_ready; |
215 | if (old_ready != new_ready) | 217 | if (old_ready != new_ready) |
216 | cc->ready_cb(cc->ready_cb_cls, new_ready); | 218 | cc->ready_cb (cc->ready_cb_cls, new_ready); |
217 | } | 219 | } |
218 | 220 | ||
219 | 221 | ||
@@ -224,34 +226,34 @@ update_state(struct CadetConnection *cc, | |||
224 | * @param cc connection to destroy | 226 | * @param cc connection to destroy |
225 | */ | 227 | */ |
226 | static void | 228 | static void |
227 | GCC_destroy(struct CadetConnection *cc) | 229 | GCC_destroy (struct CadetConnection *cc) |
228 | { | 230 | { |
229 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Destroying %s\n", GCC_2s(cc)); | 231 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying %s\n", GCC_2s (cc)); |
230 | if (NULL != cc->mq_man) | 232 | if (NULL != cc->mq_man) |
231 | { | 233 | { |
232 | GCP_request_mq_cancel(cc->mq_man, NULL); | 234 | GCP_request_mq_cancel (cc->mq_man, NULL); |
233 | cc->mq_man = NULL; | 235 | cc->mq_man = NULL; |
234 | } | 236 | } |
235 | if (NULL != cc->task) | 237 | if (NULL != cc->task) |
236 | { | 238 | { |
237 | GNUNET_SCHEDULER_cancel(cc->task); | 239 | GNUNET_SCHEDULER_cancel (cc->task); |
238 | cc->task = NULL; | 240 | cc->task = NULL; |
239 | } | 241 | } |
240 | if (NULL != cc->keepalive_qe) | 242 | if (NULL != cc->keepalive_qe) |
241 | { | 243 | { |
242 | GCT_send_cancel(cc->keepalive_qe); | 244 | GCT_send_cancel (cc->keepalive_qe); |
243 | cc->keepalive_qe = NULL; | 245 | cc->keepalive_qe = NULL; |
244 | } | 246 | } |
245 | GCPP_del_connection(cc->path, cc->off, cc); | 247 | GCPP_del_connection (cc->path, cc->off, cc); |
246 | for (unsigned int i = 0; i < cc->off; i++) | 248 | for (unsigned int i = 0; i < cc->off; i++) |
247 | GCP_remove_connection(GCPP_get_peer_at_offset(cc->path, i), cc); | 249 | GCP_remove_connection (GCPP_get_peer_at_offset (cc->path, i), cc); |
248 | GNUNET_assert( | 250 | GNUNET_assert ( |
249 | GNUNET_YES == | 251 | GNUNET_YES == |
250 | GNUNET_CONTAINER_multishortmap_remove(connections, | 252 | GNUNET_CONTAINER_multishortmap_remove (connections, |
251 | &GCC_get_id(cc) | 253 | &GCC_get_id (cc) |
252 | ->connection_of_tunnel, | 254 | ->connection_of_tunnel, |
253 | cc)); | 255 | cc)); |
254 | GNUNET_free(cc); | 256 | GNUNET_free (cc); |
255 | } | 257 | } |
256 | 258 | ||
257 | 259 | ||
@@ -264,14 +266,14 @@ GCC_destroy(struct CadetConnection *cc) | |||
264 | * @param cc connection to destroy | 266 | * @param cc connection to destroy |
265 | */ | 267 | */ |
266 | void | 268 | void |
267 | GCC_destroy_without_core(struct CadetConnection *cc) | 269 | GCC_destroy_without_core (struct CadetConnection *cc) |
268 | { | 270 | { |
269 | if (NULL != cc->ct) | 271 | if (NULL != cc->ct) |
270 | { | 272 | { |
271 | GCT_connection_lost(cc->ct); | 273 | GCT_connection_lost (cc->ct); |
272 | cc->ct = NULL; | 274 | cc->ct = NULL; |
273 | } | 275 | } |
274 | GCC_destroy(cc); | 276 | GCC_destroy (cc); |
275 | } | 277 | } |
276 | 278 | ||
277 | 279 | ||
@@ -283,22 +285,22 @@ GCC_destroy_without_core(struct CadetConnection *cc) | |||
283 | * @param cc connection to destroy | 285 | * @param cc connection to destroy |
284 | */ | 286 | */ |
285 | void | 287 | void |
286 | GCC_destroy_without_tunnel(struct CadetConnection *cc) | 288 | GCC_destroy_without_tunnel (struct CadetConnection *cc) |
287 | { | 289 | { |
288 | cc->ct = NULL; | 290 | cc->ct = NULL; |
289 | if ((CADET_CONNECTION_SENDING_CREATE != cc->state) && (NULL != cc->mq_man)) | 291 | if ((CADET_CONNECTION_SENDING_CREATE != cc->state) && (NULL != cc->mq_man)) |
290 | { | 292 | { |
291 | struct GNUNET_MQ_Envelope *env; | 293 | struct GNUNET_MQ_Envelope *env; |
292 | struct GNUNET_CADET_ConnectionDestroyMessage *destroy_msg; | 294 | struct GNUNET_CADET_ConnectionDestroyMessage *destroy_msg; |
293 | 295 | ||
294 | /* Need to notify next hop that we are down. */ | 296 | /* Need to notify next hop that we are down. */ |
295 | env = | 297 | env = |
296 | GNUNET_MQ_msg(destroy_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY); | 298 | GNUNET_MQ_msg (destroy_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY); |
297 | destroy_msg->cid = cc->cid; | 299 | destroy_msg->cid = cc->cid; |
298 | GCP_request_mq_cancel(cc->mq_man, env); | 300 | GCP_request_mq_cancel (cc->mq_man, env); |
299 | cc->mq_man = NULL; | 301 | cc->mq_man = NULL; |
300 | } | 302 | } |
301 | GCC_destroy(cc); | 303 | GCC_destroy (cc); |
302 | } | 304 | } |
303 | 305 | ||
304 | 306 | ||
@@ -309,7 +311,7 @@ GCC_destroy_without_tunnel(struct CadetConnection *cc) | |||
309 | * @return corresponding entry in the tunnel's connection list | 311 | * @return corresponding entry in the tunnel's connection list |
310 | */ | 312 | */ |
311 | struct CadetTConnection * | 313 | struct CadetTConnection * |
312 | GCC_get_ct(struct CadetConnection *cc) | 314 | GCC_get_ct (struct CadetConnection *cc) |
313 | { | 315 | { |
314 | return cc->ct; | 316 | return cc->ct; |
315 | } | 317 | } |
@@ -322,7 +324,7 @@ GCC_get_ct(struct CadetConnection *cc) | |||
322 | * @return the metrics | 324 | * @return the metrics |
323 | */ | 325 | */ |
324 | const struct CadetConnectionMetrics * | 326 | const struct CadetConnectionMetrics * |
325 | GCC_get_metrics(struct CadetConnection *cc) | 327 | GCC_get_metrics (struct CadetConnection *cc) |
326 | { | 328 | { |
327 | return &cc->metrics; | 329 | return &cc->metrics; |
328 | } | 330 | } |
@@ -335,7 +337,7 @@ GCC_get_metrics(struct CadetConnection *cc) | |||
335 | * @param cls the `struct CadetConnection` to keep alive. | 337 | * @param cls the `struct CadetConnection` to keep alive. |
336 | */ | 338 | */ |
337 | static void | 339 | static void |
338 | send_keepalive(void *cls); | 340 | send_keepalive (void *cls); |
339 | 341 | ||
340 | 342 | ||
341 | /** | 343 | /** |
@@ -347,15 +349,15 @@ send_keepalive(void *cls); | |||
347 | * if transmission failed | 349 | * if transmission failed |
348 | */ | 350 | */ |
349 | static void | 351 | static void |
350 | keepalive_done(void *cls, | 352 | keepalive_done (void *cls, |
351 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 353 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
352 | { | 354 | { |
353 | struct CadetConnection *cc = cls; | 355 | struct CadetConnection *cc = cls; |
354 | 356 | ||
355 | cc->keepalive_qe = NULL; | 357 | cc->keepalive_qe = NULL; |
356 | if ((GNUNET_YES == cc->mqm_ready) && (NULL == cc->task)) | 358 | if ((GNUNET_YES == cc->mqm_ready) && (NULL == cc->task)) |
357 | cc->task = | 359 | cc->task = |
358 | GNUNET_SCHEDULER_add_delayed(keepalive_period, &send_keepalive, cc); | 360 | GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc); |
359 | } | 361 | } |
360 | 362 | ||
361 | 363 | ||
@@ -366,31 +368,31 @@ keepalive_done(void *cls, | |||
366 | * @param cls the `struct CadetConnection` to keep alive. | 368 | * @param cls the `struct CadetConnection` to keep alive. |
367 | */ | 369 | */ |
368 | static void | 370 | static void |
369 | send_keepalive(void *cls) | 371 | send_keepalive (void *cls) |
370 | { | 372 | { |
371 | struct CadetConnection *cc = cls; | 373 | struct CadetConnection *cc = cls; |
372 | struct GNUNET_MessageHeader msg; | 374 | struct GNUNET_MessageHeader msg; |
373 | 375 | ||
374 | cc->task = NULL; | 376 | cc->task = NULL; |
375 | if (CADET_TUNNEL_KEY_OK != GCT_get_estate(cc->ct->t)) | 377 | if (CADET_TUNNEL_KEY_OK != GCT_get_estate (cc->ct->t)) |
376 | { | 378 | { |
377 | /* Tunnel not yet ready, wait with keepalives... */ | 379 | /* Tunnel not yet ready, wait with keepalives... */ |
378 | cc->task = | 380 | cc->task = |
379 | GNUNET_SCHEDULER_add_delayed(keepalive_period, &send_keepalive, cc); | 381 | GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc); |
380 | return; | 382 | return; |
381 | } | 383 | } |
382 | GNUNET_assert(NULL != cc->ct); | 384 | GNUNET_assert (NULL != cc->ct); |
383 | GNUNET_assert(GNUNET_YES == cc->mqm_ready); | 385 | GNUNET_assert (GNUNET_YES == cc->mqm_ready); |
384 | GNUNET_assert(NULL == cc->keepalive_qe); | 386 | GNUNET_assert (NULL == cc->keepalive_qe); |
385 | LOG(GNUNET_ERROR_TYPE_INFO, | 387 | LOG (GNUNET_ERROR_TYPE_INFO, |
386 | "Sending KEEPALIVE on behalf of %s via %s\n", | 388 | "Sending KEEPALIVE on behalf of %s via %s\n", |
387 | GCC_2s(cc), | 389 | GCC_2s (cc), |
388 | GCT_2s(cc->ct->t)); | 390 | GCT_2s (cc->ct->t)); |
389 | GNUNET_STATISTICS_update(stats, "# keepalives sent", 1, GNUNET_NO); | 391 | GNUNET_STATISTICS_update (stats, "# keepalives sent", 1, GNUNET_NO); |
390 | msg.size = htons(sizeof(msg)); | 392 | msg.size = htons (sizeof(msg)); |
391 | msg.type = htons(GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE); | 393 | msg.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE); |
392 | 394 | ||
393 | cc->keepalive_qe = GCT_send(cc->ct->t, &msg, &keepalive_done, cc); | 395 | cc->keepalive_qe = GCT_send (cc->ct->t, &msg, &keepalive_done, cc); |
394 | } | 396 | } |
395 | 397 | ||
396 | 398 | ||
@@ -401,11 +403,11 @@ send_keepalive(void *cls) | |||
401 | * @param cid connection identifier where we expect an ACK | 403 | * @param cid connection identifier where we expect an ACK |
402 | */ | 404 | */ |
403 | void | 405 | void |
404 | GCC_ack_expected(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 406 | GCC_ack_expected (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
405 | { | 407 | { |
406 | struct CadetConnection *cc; | 408 | struct CadetConnection *cc; |
407 | 409 | ||
408 | cc = GCC_lookup(cid); | 410 | cc = GCC_lookup (cid); |
409 | if (NULL == cc) | 411 | if (NULL == cc) |
410 | return; /* whopise, connection alredy down? */ | 412 | return; /* whopise, connection alredy down? */ |
411 | cc->metrics.num_acked_transmissions++; | 413 | cc->metrics.num_acked_transmissions++; |
@@ -421,11 +423,11 @@ GCC_ack_expected(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | |||
421 | * may have gotten back to us via a different connection). | 423 | * may have gotten back to us via a different connection). |
422 | */ | 424 | */ |
423 | void | 425 | void |
424 | GCC_ack_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 426 | GCC_ack_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
425 | { | 427 | { |
426 | struct CadetConnection *cc; | 428 | struct CadetConnection *cc; |
427 | 429 | ||
428 | cc = GCC_lookup(cid); | 430 | cc = GCC_lookup (cid); |
429 | if (NULL == cc) | 431 | if (NULL == cc) |
430 | return; /* whopise, connection alredy down? */ | 432 | return; /* whopise, connection alredy down? */ |
431 | cc->metrics.num_successes++; | 433 | cc->metrics.num_successes++; |
@@ -441,17 +443,17 @@ GCC_ack_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | |||
441 | * @param latency the observed latency | 443 | * @param latency the observed latency |
442 | */ | 444 | */ |
443 | void | 445 | void |
444 | GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 446 | GCC_latency_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
445 | struct GNUNET_TIME_Relative latency) | 447 | struct GNUNET_TIME_Relative latency) |
446 | { | 448 | { |
447 | struct CadetConnection *cc; | 449 | struct CadetConnection *cc; |
448 | double weight; | 450 | double weight; |
449 | double result; | 451 | double result; |
450 | 452 | ||
451 | cc = GCC_lookup(cid); | 453 | cc = GCC_lookup (cid); |
452 | if (NULL == cc) | 454 | if (NULL == cc) |
453 | return; /* whopise, connection alredy down? */ | 455 | return; /* whopise, connection alredy down? */ |
454 | GNUNET_STATISTICS_update(stats, "# latencies observed", 1, GNUNET_NO); | 456 | GNUNET_STATISTICS_update (stats, "# latencies observed", 1, GNUNET_NO); |
455 | cc->latency_datapoints++; | 457 | cc->latency_datapoints++; |
456 | if (cc->latency_datapoints >= 7) | 458 | if (cc->latency_datapoints >= 7) |
457 | weight = 7.0; | 459 | weight = 7.0; |
@@ -460,10 +462,10 @@ GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | |||
460 | /* Compute weighted average, giving at MOST weight 7 to the | 462 | /* Compute weighted average, giving at MOST weight 7 to the |
461 | existing values, or less if that value is based on fewer than 7 | 463 | existing values, or less if that value is based on fewer than 7 |
462 | measurements. */ | 464 | measurements. */ |
463 | result = (weight * cc->metrics.aged_latency.rel_value_us) + | 465 | result = (weight * cc->metrics.aged_latency.rel_value_us) |
464 | 1.0 * latency.rel_value_us; | 466 | + 1.0 * latency.rel_value_us; |
465 | result /= (weight + 1.0); | 467 | result /= (weight + 1.0); |
466 | cc->metrics.aged_latency.rel_value_us = (uint64_t)result; | 468 | cc->metrics.aged_latency.rel_value_us = (uint64_t) result; |
467 | } | 469 | } |
468 | 470 | ||
469 | 471 | ||
@@ -475,26 +477,26 @@ GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | |||
475 | * @param cc the connection that got the ACK. | 477 | * @param cc the connection that got the ACK. |
476 | */ | 478 | */ |
477 | void | 479 | void |
478 | GCC_handle_connection_create_ack(struct CadetConnection *cc) | 480 | GCC_handle_connection_create_ack (struct CadetConnection *cc) |
479 | { | 481 | { |
480 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 482 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
481 | "Received CADET_CONNECTION_CREATE_ACK for %s in state %d (%s)\n", | 483 | "Received CADET_CONNECTION_CREATE_ACK for %s in state %d (%s)\n", |
482 | GCC_2s(cc), | 484 | GCC_2s (cc), |
483 | cc->state, | 485 | cc->state, |
484 | (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy"); | 486 | (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy"); |
485 | if (CADET_CONNECTION_READY == cc->state) | 487 | if (CADET_CONNECTION_READY == cc->state) |
486 | return; /* Duplicate ACK, ignore */ | 488 | return; /* Duplicate ACK, ignore */ |
487 | if (NULL != cc->task) | 489 | if (NULL != cc->task) |
488 | { | 490 | { |
489 | GNUNET_SCHEDULER_cancel(cc->task); | 491 | GNUNET_SCHEDULER_cancel (cc->task); |
490 | cc->task = NULL; | 492 | cc->task = NULL; |
491 | } | 493 | } |
492 | cc->metrics.age = GNUNET_TIME_absolute_get(); | 494 | cc->metrics.age = GNUNET_TIME_absolute_get (); |
493 | update_state(cc, CADET_CONNECTION_READY, cc->mqm_ready); | 495 | update_state (cc, CADET_CONNECTION_READY, cc->mqm_ready); |
494 | if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) && | 496 | if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) && |
495 | (NULL == cc->task)) | 497 | (NULL == cc->task)) |
496 | cc->task = | 498 | cc->task = |
497 | GNUNET_SCHEDULER_add_delayed(keepalive_period, &send_keepalive, cc); | 499 | GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc); |
498 | } | 500 | } |
499 | 501 | ||
500 | 502 | ||
@@ -505,24 +507,24 @@ GCC_handle_connection_create_ack(struct CadetConnection *cc) | |||
505 | * @param msg the key exchange message | 507 | * @param msg the key exchange message |
506 | */ | 508 | */ |
507 | void | 509 | void |
508 | GCC_handle_kx(struct CadetConnection *cc, | 510 | GCC_handle_kx (struct CadetConnection *cc, |
509 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg) | 511 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg) |
510 | { | 512 | { |
511 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 513 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
512 | "Received KX message with ephermal %s on CC %s in state %d\n", | 514 | "Received KX message with ephermal %s on CC %s in state %d\n", |
513 | GNUNET_e2s(&msg->ephemeral_key), | 515 | GNUNET_e2s (&msg->ephemeral_key), |
514 | GNUNET_sh2s(&cc->cid.connection_of_tunnel), | 516 | GNUNET_sh2s (&cc->cid.connection_of_tunnel), |
515 | cc->state); | 517 | cc->state); |
516 | if (CADET_CONNECTION_SENT == cc->state) | 518 | if (CADET_CONNECTION_SENT == cc->state) |
517 | { | 519 | { |
518 | /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine, | 520 | /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine, |
519 | clearly something is working, so pretend we got an ACK. */ | 521 | clearly something is working, so pretend we got an ACK. */ |
520 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 522 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
521 | "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n", | 523 | "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n", |
522 | GCC_2s(cc)); | 524 | GCC_2s (cc)); |
523 | GCC_handle_connection_create_ack(cc); | 525 | GCC_handle_connection_create_ack (cc); |
524 | } | 526 | } |
525 | GCT_handle_kx(cc->ct, msg); | 527 | GCT_handle_kx (cc->ct, msg); |
526 | } | 528 | } |
527 | 529 | ||
528 | 530 | ||
@@ -533,24 +535,24 @@ GCC_handle_kx(struct CadetConnection *cc, | |||
533 | * @param msg the key exchange message | 535 | * @param msg the key exchange message |
534 | */ | 536 | */ |
535 | void | 537 | void |
536 | GCC_handle_kx_auth(struct CadetConnection *cc, | 538 | GCC_handle_kx_auth (struct CadetConnection *cc, |
537 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg) | 539 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg) |
538 | { | 540 | { |
539 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 541 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
540 | "Received KX AUTH message with ephermal %s on CC %s in state %d\n", | 542 | "Received KX AUTH message with ephermal %s on CC %s in state %d\n", |
541 | GNUNET_e2s(&msg->kx.ephemeral_key), | 543 | GNUNET_e2s (&msg->kx.ephemeral_key), |
542 | GNUNET_sh2s(&cc->cid.connection_of_tunnel), | 544 | GNUNET_sh2s (&cc->cid.connection_of_tunnel), |
543 | cc->state); | 545 | cc->state); |
544 | if (CADET_CONNECTION_SENT == cc->state) | 546 | if (CADET_CONNECTION_SENT == cc->state) |
545 | { | 547 | { |
546 | /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine, | 548 | /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine, |
547 | clearly something is working, so pretend we got an ACK. */ | 549 | clearly something is working, so pretend we got an ACK. */ |
548 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 550 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
549 | "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n", | 551 | "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n", |
550 | GCC_2s(cc)); | 552 | GCC_2s (cc)); |
551 | GCC_handle_connection_create_ack(cc); | 553 | GCC_handle_connection_create_ack (cc); |
552 | } | 554 | } |
553 | GCT_handle_kx_auth(cc->ct, msg); | 555 | GCT_handle_kx_auth (cc->ct, msg); |
554 | } | 556 | } |
555 | 557 | ||
556 | 558 | ||
@@ -561,20 +563,20 @@ GCC_handle_kx_auth(struct CadetConnection *cc, | |||
561 | * @param msg the encrypted message to decrypt | 563 | * @param msg the encrypted message to decrypt |
562 | */ | 564 | */ |
563 | void | 565 | void |
564 | GCC_handle_encrypted(struct CadetConnection *cc, | 566 | GCC_handle_encrypted (struct CadetConnection *cc, |
565 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) | 567 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) |
566 | { | 568 | { |
567 | if (CADET_CONNECTION_SENT == cc->state) | 569 | if (CADET_CONNECTION_SENT == cc->state) |
568 | { | 570 | { |
569 | /* We didn't get the CREATE_ACK, but instead got payload. That's fine, | 571 | /* We didn't get the CREATE_ACK, but instead got payload. That's fine, |
570 | clearly something is working, so pretend we got an ACK. */ | 572 | clearly something is working, so pretend we got an ACK. */ |
571 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 573 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
572 | "Faking connection ACK for %s due to ENCRYPTED payload\n", | 574 | "Faking connection ACK for %s due to ENCRYPTED payload\n", |
573 | GCC_2s(cc)); | 575 | GCC_2s (cc)); |
574 | GCC_handle_connection_create_ack(cc); | 576 | GCC_handle_connection_create_ack (cc); |
575 | } | 577 | } |
576 | cc->metrics.last_use = GNUNET_TIME_absolute_get(); | 578 | cc->metrics.last_use = GNUNET_TIME_absolute_get (); |
577 | GCT_handle_encrypted(cc->ct, msg); | 579 | GCT_handle_encrypted (cc->ct, msg); |
578 | } | 580 | } |
579 | 581 | ||
580 | 582 | ||
@@ -585,7 +587,7 @@ GCC_handle_encrypted(struct CadetConnection *cc, | |||
585 | * @param cls the `struct CadetConnection` to initiate | 587 | * @param cls the `struct CadetConnection` to initiate |
586 | */ | 588 | */ |
587 | static void | 589 | static void |
588 | send_create(void *cls) | 590 | send_create (void *cls) |
589 | { | 591 | { |
590 | struct CadetConnection *cc = cls; | 592 | struct CadetConnection *cc = cls; |
591 | struct GNUNET_CADET_ConnectionCreateMessage *create_msg; | 593 | struct GNUNET_CADET_ConnectionCreateMessage *create_msg; |
@@ -593,27 +595,27 @@ send_create(void *cls) | |||
593 | struct GNUNET_MQ_Envelope *env; | 595 | struct GNUNET_MQ_Envelope *env; |
594 | 596 | ||
595 | cc->task = NULL; | 597 | cc->task = NULL; |
596 | GNUNET_assert(GNUNET_YES == cc->mqm_ready); | 598 | GNUNET_assert (GNUNET_YES == cc->mqm_ready); |
597 | env = | 599 | env = |
598 | GNUNET_MQ_msg_extra(create_msg, | 600 | GNUNET_MQ_msg_extra (create_msg, |
599 | (2 + cc->off) * sizeof(struct GNUNET_PeerIdentity), | 601 | (2 + cc->off) * sizeof(struct GNUNET_PeerIdentity), |
600 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE); | 602 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE); |
601 | //TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated 'reliable' bit here that was removed. | 603 | // TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated 'reliable' bit here that was removed. |
602 | create_msg->options = 2; | 604 | create_msg->options = 2; |
603 | create_msg->cid = cc->cid; | 605 | create_msg->cid = cc->cid; |
604 | pids = (struct GNUNET_PeerIdentity *)&create_msg[1]; | 606 | pids = (struct GNUNET_PeerIdentity *) &create_msg[1]; |
605 | pids[0] = my_full_id; | 607 | pids[0] = my_full_id; |
606 | for (unsigned int i = 0; i <= cc->off; i++) | 608 | for (unsigned int i = 0; i <= cc->off; i++) |
607 | pids[i + 1] = *GCP_get_id(GCPP_get_peer_at_offset(cc->path, i)); | 609 | pids[i + 1] = *GCP_get_id (GCPP_get_peer_at_offset (cc->path, i)); |
608 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 610 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
609 | "Sending CADET_CONNECTION_CREATE message for %s with %u hops\n", | 611 | "Sending CADET_CONNECTION_CREATE message for %s with %u hops\n", |
610 | GCC_2s(cc), | 612 | GCC_2s (cc), |
611 | cc->off + 2); | 613 | cc->off + 2); |
612 | cc->env = env; | 614 | cc->env = env; |
613 | cc->retry_delay = GNUNET_TIME_STD_BACKOFF(cc->retry_delay); | 615 | cc->retry_delay = GNUNET_TIME_STD_BACKOFF (cc->retry_delay); |
614 | cc->create_at = GNUNET_TIME_relative_to_absolute(cc->retry_delay); | 616 | cc->create_at = GNUNET_TIME_relative_to_absolute (cc->retry_delay); |
615 | update_state(cc, CADET_CONNECTION_SENT, GNUNET_NO); | 617 | update_state (cc, CADET_CONNECTION_SENT, GNUNET_NO); |
616 | GCP_send(cc->mq_man, env); | 618 | GCP_send (cc->mq_man, env); |
617 | } | 619 | } |
618 | 620 | ||
619 | 621 | ||
@@ -623,29 +625,29 @@ send_create(void *cls) | |||
623 | * @param cls the `struct CadetConnection` to initiate | 625 | * @param cls the `struct CadetConnection` to initiate |
624 | */ | 626 | */ |
625 | static void | 627 | static void |
626 | send_create_ack(void *cls) | 628 | send_create_ack (void *cls) |
627 | { | 629 | { |
628 | struct CadetConnection *cc = cls; | 630 | struct CadetConnection *cc = cls; |
629 | struct GNUNET_CADET_ConnectionCreateAckMessage *ack_msg; | 631 | struct GNUNET_CADET_ConnectionCreateAckMessage *ack_msg; |
630 | struct GNUNET_MQ_Envelope *env; | 632 | struct GNUNET_MQ_Envelope *env; |
631 | 633 | ||
632 | cc->task = NULL; | 634 | cc->task = NULL; |
633 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 635 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
634 | "Sending CONNECTION_CREATE_ACK message for %s\n", | 636 | "Sending CONNECTION_CREATE_ACK message for %s\n", |
635 | GCC_2s(cc)); | 637 | GCC_2s (cc)); |
636 | GNUNET_assert(GNUNET_YES == cc->mqm_ready); | 638 | GNUNET_assert (GNUNET_YES == cc->mqm_ready); |
637 | env = | 639 | env = |
638 | GNUNET_MQ_msg(ack_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK); | 640 | GNUNET_MQ_msg (ack_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK); |
639 | ack_msg->cid = cc->cid; | 641 | ack_msg->cid = cc->cid; |
640 | cc->env = env; | 642 | cc->env = env; |
641 | cc->retry_delay = GNUNET_TIME_STD_BACKOFF(cc->retry_delay); | 643 | cc->retry_delay = GNUNET_TIME_STD_BACKOFF (cc->retry_delay); |
642 | cc->create_ack_at = GNUNET_TIME_relative_to_absolute(cc->retry_delay); | 644 | cc->create_ack_at = GNUNET_TIME_relative_to_absolute (cc->retry_delay); |
643 | if (CADET_CONNECTION_CREATE_RECEIVED == cc->state) | 645 | if (CADET_CONNECTION_CREATE_RECEIVED == cc->state) |
644 | update_state(cc, CADET_CONNECTION_READY, GNUNET_NO); | 646 | update_state (cc, CADET_CONNECTION_READY, GNUNET_NO); |
645 | if (CADET_CONNECTION_READY == cc->state) | 647 | if (CADET_CONNECTION_READY == cc->state) |
646 | cc->task = | 648 | cc->task = |
647 | GNUNET_SCHEDULER_add_delayed(keepalive_period, &send_keepalive, cc); | 649 | GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc); |
648 | GCP_send(cc->mq_man, env); | 650 | GCP_send (cc->mq_man, env); |
649 | } | 651 | } |
650 | 652 | ||
651 | 653 | ||
@@ -657,31 +659,31 @@ send_create_ack(void *cls) | |||
657 | * @param cc connection that got the duplicate CREATE | 659 | * @param cc connection that got the duplicate CREATE |
658 | */ | 660 | */ |
659 | void | 661 | void |
660 | GCC_handle_duplicate_create(struct CadetConnection *cc) | 662 | GCC_handle_duplicate_create (struct CadetConnection *cc) |
661 | { | 663 | { |
662 | if (GNUNET_YES == cc->mqm_ready) | 664 | if (GNUNET_YES == cc->mqm_ready) |
663 | { | 665 | { |
664 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 666 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
665 | "Got duplicate CREATE for %s, scheduling another ACK (%s)\n", | 667 | "Got duplicate CREATE for %s, scheduling another ACK (%s)\n", |
666 | GCC_2s(cc), | 668 | GCC_2s (cc), |
667 | (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy"); | 669 | (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy"); |
668 | /* Revert back to the state of having only received the 'CREATE', | 670 | /* Revert back to the state of having only received the 'CREATE', |
669 | and immediately proceed to send the CREATE_ACK. */ | 671 | and immediately proceed to send the CREATE_ACK. */ |
670 | update_state(cc, CADET_CONNECTION_CREATE_RECEIVED, cc->mqm_ready); | 672 | update_state (cc, CADET_CONNECTION_CREATE_RECEIVED, cc->mqm_ready); |
671 | if (NULL != cc->task) | 673 | if (NULL != cc->task) |
672 | GNUNET_SCHEDULER_cancel(cc->task); | 674 | GNUNET_SCHEDULER_cancel (cc->task); |
673 | cc->task = | 675 | cc->task = |
674 | GNUNET_SCHEDULER_add_at(cc->create_ack_at, &send_create_ack, cc); | 676 | GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc); |
675 | } | 677 | } |
676 | else | 678 | else |
677 | { | 679 | { |
678 | /* We are currently sending something else back, which | 680 | /* We are currently sending something else back, which |
679 | can only be an ACK or payload, either of which would | 681 | can only be an ACK or payload, either of which would |
680 | do. So actually no need to do anything. */ | 682 | do. So actually no need to do anything. */ |
681 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 683 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
682 | "Got duplicate CREATE for %s. MQ is busy, not queueing another ACK\n", | 684 | "Got duplicate CREATE for %s. MQ is busy, not queueing another ACK\n", |
683 | GCC_2s(cc)); | 685 | GCC_2s (cc)); |
684 | } | 686 | } |
685 | } | 687 | } |
686 | 688 | ||
687 | 689 | ||
@@ -696,67 +698,67 @@ GCC_handle_duplicate_create(struct CadetConnection *cc) | |||
696 | * and the last envelope was discarded | 698 | * and the last envelope was discarded |
697 | */ | 699 | */ |
698 | static void | 700 | static void |
699 | manage_first_hop_mq(void *cls, int available) | 701 | manage_first_hop_mq (void *cls, int available) |
700 | { | 702 | { |
701 | struct CadetConnection *cc = cls; | 703 | struct CadetConnection *cc = cls; |
702 | 704 | ||
703 | if (GNUNET_YES != available) | 705 | if (GNUNET_YES != available) |
706 | { | ||
707 | /* Connection is down, for now... */ | ||
708 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Core MQ for %s went down\n", GCC_2s (cc)); | ||
709 | update_state (cc, CADET_CONNECTION_NEW, GNUNET_NO); | ||
710 | cc->retry_delay = INITIAL_CONNECTION_CREATE_RETRY_DELAY; | ||
711 | if (NULL != cc->task) | ||
704 | { | 712 | { |
705 | /* Connection is down, for now... */ | 713 | GNUNET_SCHEDULER_cancel (cc->task); |
706 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Core MQ for %s went down\n", GCC_2s(cc)); | 714 | cc->task = NULL; |
707 | update_state(cc, CADET_CONNECTION_NEW, GNUNET_NO); | ||
708 | cc->retry_delay = INITIAL_CONNECTION_CREATE_RETRY_DELAY; | ||
709 | if (NULL != cc->task) | ||
710 | { | ||
711 | GNUNET_SCHEDULER_cancel(cc->task); | ||
712 | cc->task = NULL; | ||
713 | } | ||
714 | return; | ||
715 | } | 715 | } |
716 | return; | ||
717 | } | ||
716 | 718 | ||
717 | update_state(cc, cc->state, GNUNET_YES); | 719 | update_state (cc, cc->state, GNUNET_YES); |
718 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 720 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
719 | "Core MQ for %s became available in state %d\n", | 721 | "Core MQ for %s became available in state %d\n", |
720 | GCC_2s(cc), | 722 | GCC_2s (cc), |
721 | cc->state); | 723 | cc->state); |
722 | switch (cc->state) | 724 | switch (cc->state) |
725 | { | ||
726 | case CADET_CONNECTION_NEW: | ||
727 | /* Transmit immediately */ | ||
728 | cc->task = GNUNET_SCHEDULER_add_at (cc->create_at, &send_create, cc); | ||
729 | break; | ||
730 | |||
731 | case CADET_CONNECTION_SENDING_CREATE: | ||
732 | /* Should not be possible to be called in this state. */ | ||
733 | GNUNET_assert (0); | ||
734 | break; | ||
735 | |||
736 | case CADET_CONNECTION_SENT: | ||
737 | /* Retry a bit later... */ | ||
738 | cc->task = GNUNET_SCHEDULER_add_at (cc->create_at, &send_create, cc); | ||
739 | break; | ||
740 | |||
741 | case CADET_CONNECTION_CREATE_RECEIVED: | ||
742 | /* We got the 'CREATE' (incoming connection), should send the CREATE_ACK */ | ||
743 | cc->metrics.age = GNUNET_TIME_absolute_get (); | ||
744 | cc->task = | ||
745 | GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc); | ||
746 | break; | ||
747 | |||
748 | case CADET_CONNECTION_READY: | ||
749 | if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) && | ||
750 | (NULL == cc->task)) | ||
723 | { | 751 | { |
724 | case CADET_CONNECTION_NEW: | 752 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
725 | /* Transmit immediately */ | 753 | "Scheduling keepalive for %s in %s\n", |
726 | cc->task = GNUNET_SCHEDULER_add_at(cc->create_at, &send_create, cc); | 754 | GCC_2s (cc), |
727 | break; | 755 | GNUNET_STRINGS_relative_time_to_string (keepalive_period, |
728 | 756 | GNUNET_YES)); | |
729 | case CADET_CONNECTION_SENDING_CREATE: | ||
730 | /* Should not be possible to be called in this state. */ | ||
731 | GNUNET_assert(0); | ||
732 | break; | ||
733 | |||
734 | case CADET_CONNECTION_SENT: | ||
735 | /* Retry a bit later... */ | ||
736 | cc->task = GNUNET_SCHEDULER_add_at(cc->create_at, &send_create, cc); | ||
737 | break; | ||
738 | |||
739 | case CADET_CONNECTION_CREATE_RECEIVED: | ||
740 | /* We got the 'CREATE' (incoming connection), should send the CREATE_ACK */ | ||
741 | cc->metrics.age = GNUNET_TIME_absolute_get(); | ||
742 | cc->task = | 757 | cc->task = |
743 | GNUNET_SCHEDULER_add_at(cc->create_ack_at, &send_create_ack, cc); | 758 | GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc); |
744 | break; | ||
745 | |||
746 | case CADET_CONNECTION_READY: | ||
747 | if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) && | ||
748 | (NULL == cc->task)) | ||
749 | { | ||
750 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
751 | "Scheduling keepalive for %s in %s\n", | ||
752 | GCC_2s(cc), | ||
753 | GNUNET_STRINGS_relative_time_to_string(keepalive_period, | ||
754 | GNUNET_YES)); | ||
755 | cc->task = | ||
756 | GNUNET_SCHEDULER_add_delayed(keepalive_period, &send_keepalive, cc); | ||
757 | } | ||
758 | break; | ||
759 | } | 759 | } |
760 | break; | ||
761 | } | ||
760 | } | 762 | } |
761 | 763 | ||
762 | 764 | ||
@@ -775,44 +777,44 @@ manage_first_hop_mq(void *cls, int available) | |||
775 | * @return handle to the connection | 777 | * @return handle to the connection |
776 | */ | 778 | */ |
777 | static struct CadetConnection * | 779 | static struct CadetConnection * |
778 | connection_create(struct CadetPeer *destination, | 780 | connection_create (struct CadetPeer *destination, |
779 | struct CadetPeerPath *path, | 781 | struct CadetPeerPath *path, |
780 | unsigned int off, | 782 | unsigned int off, |
781 | struct CadetTConnection *ct, | 783 | struct CadetTConnection *ct, |
782 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 784 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
783 | enum CadetConnectionState init_state, | 785 | enum CadetConnectionState init_state, |
784 | GCC_ReadyCallback ready_cb, | 786 | GCC_ReadyCallback ready_cb, |
785 | void *ready_cb_cls) | 787 | void *ready_cb_cls) |
786 | { | 788 | { |
787 | struct CadetConnection *cc; | 789 | struct CadetConnection *cc; |
788 | struct CadetPeer *first_hop; | 790 | struct CadetPeer *first_hop; |
789 | 791 | ||
790 | cc = GNUNET_new(struct CadetConnection); | 792 | cc = GNUNET_new (struct CadetConnection); |
791 | cc->state = init_state; | 793 | cc->state = init_state; |
792 | cc->ct = ct; | 794 | cc->ct = ct; |
793 | cc->cid = *cid; | 795 | cc->cid = *cid; |
794 | cc->retry_delay = | 796 | cc->retry_delay = |
795 | GNUNET_TIME_relative_multiply(INITIAL_CONNECTION_CREATE_RETRY_DELAY, off); | 797 | GNUNET_TIME_relative_multiply (INITIAL_CONNECTION_CREATE_RETRY_DELAY, off); |
796 | GNUNET_assert(GNUNET_OK == | 798 | GNUNET_assert (GNUNET_OK == |
797 | GNUNET_CONTAINER_multishortmap_put( | 799 | GNUNET_CONTAINER_multishortmap_put ( |
798 | connections, | 800 | connections, |
799 | &GCC_get_id(cc)->connection_of_tunnel, | 801 | &GCC_get_id (cc)->connection_of_tunnel, |
800 | cc, | 802 | cc, |
801 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 803 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
802 | cc->ready_cb = ready_cb; | 804 | cc->ready_cb = ready_cb; |
803 | cc->ready_cb_cls = ready_cb_cls; | 805 | cc->ready_cb_cls = ready_cb_cls; |
804 | cc->path = path; | 806 | cc->path = path; |
805 | cc->off = off; | 807 | cc->off = off; |
806 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 808 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
807 | "Creating %s using path %s (offset: %u)\n", | 809 | "Creating %s using path %s (offset: %u)\n", |
808 | GCC_2s(cc), | 810 | GCC_2s (cc), |
809 | GCPP_2s(path), | 811 | GCPP_2s (path), |
810 | off); | 812 | off); |
811 | GCPP_add_connection(path, off, cc); | 813 | GCPP_add_connection (path, off, cc); |
812 | for (unsigned int i = 0; i < off; i++) | 814 | for (unsigned int i = 0; i < off; i++) |
813 | GCP_add_connection(GCPP_get_peer_at_offset(path, i), cc); | 815 | GCP_add_connection (GCPP_get_peer_at_offset (path, i), cc); |
814 | first_hop = GCPP_get_peer_at_offset(path, 0); | 816 | first_hop = GCPP_get_peer_at_offset (path, 0); |
815 | cc->mq_man = GCP_request_mq(first_hop, &manage_first_hop_mq, cc); | 817 | cc->mq_man = GCP_request_mq (first_hop, &manage_first_hop_mq, cc); |
816 | return cc; | 818 | return cc; |
817 | } | 819 | } |
818 | 820 | ||
@@ -831,64 +833,64 @@ connection_create(struct CadetPeer *destination, | |||
831 | * a connection that takes precedence on @a path | 833 | * a connection that takes precedence on @a path |
832 | */ | 834 | */ |
833 | struct CadetConnection * | 835 | struct CadetConnection * |
834 | GCC_create_inbound(struct CadetPeer *destination, | 836 | GCC_create_inbound (struct CadetPeer *destination, |
835 | struct CadetPeerPath *path, | 837 | struct CadetPeerPath *path, |
836 | struct CadetTConnection *ct, | 838 | struct CadetTConnection *ct, |
837 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 839 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
838 | GCC_ReadyCallback ready_cb, | 840 | GCC_ReadyCallback ready_cb, |
839 | void *ready_cb_cls) | 841 | void *ready_cb_cls) |
840 | { | 842 | { |
841 | struct CadetConnection *cc; | 843 | struct CadetConnection *cc; |
842 | unsigned int off; | 844 | unsigned int off; |
843 | 845 | ||
844 | off = GCPP_find_peer(path, destination); | 846 | off = GCPP_find_peer (path, destination); |
845 | GNUNET_assert(UINT_MAX != off); | 847 | GNUNET_assert (UINT_MAX != off); |
846 | cc = GCPP_get_connection(path, destination, off); | 848 | cc = GCPP_get_connection (path, destination, off); |
847 | if (NULL != cc) | 849 | if (NULL != cc) |
850 | { | ||
851 | int cmp; | ||
852 | |||
853 | cmp = GNUNET_memcmp (cid, &cc->cid); | ||
854 | if (0 == cmp) | ||
848 | { | 855 | { |
849 | int cmp; | 856 | /* Two peers picked the SAME random connection identifier at the |
850 | 857 | same time for the same path? Must be malicious. Drop | |
851 | cmp = GNUNET_memcmp(cid, &cc->cid); | 858 | connection (existing and inbound), even if it is the only |
852 | if (0 == cmp) | 859 | one. */ |
853 | { | 860 | GNUNET_break_op (0); |
854 | /* Two peers picked the SAME random connection identifier at the | 861 | GCT_connection_lost (cc->ct); |
855 | same time for the same path? Must be malicious. Drop | 862 | GCC_destroy_without_tunnel (cc); |
856 | connection (existing and inbound), even if it is the only | 863 | return NULL; |
857 | one. */ | ||
858 | GNUNET_break_op(0); | ||
859 | GCT_connection_lost(cc->ct); | ||
860 | GCC_destroy_without_tunnel(cc); | ||
861 | return NULL; | ||
862 | } | ||
863 | if (0 < cmp) | ||
864 | { | ||
865 | /* drop existing */ | ||
866 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
867 | "Got two connections on %s, dropping my existing %s\n", | ||
868 | GCPP_2s(path), | ||
869 | GCC_2s(cc)); | ||
870 | GCT_connection_lost(cc->ct); | ||
871 | GCC_destroy_without_tunnel(cc); | ||
872 | } | ||
873 | else | ||
874 | { | ||
875 | /* keep existing */ | ||
876 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
877 | "Got two connections on %s, keeping my existing %s\n", | ||
878 | GCPP_2s(path), | ||
879 | GCC_2s(cc)); | ||
880 | return NULL; | ||
881 | } | ||
882 | } | 864 | } |
883 | 865 | if (0 < cmp) | |
884 | return connection_create(destination, | 866 | { |
885 | path, | 867 | /* drop existing */ |
886 | off, | 868 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
887 | ct, | 869 | "Got two connections on %s, dropping my existing %s\n", |
888 | cid, | 870 | GCPP_2s (path), |
889 | CADET_CONNECTION_CREATE_RECEIVED, | 871 | GCC_2s (cc)); |
890 | ready_cb, | 872 | GCT_connection_lost (cc->ct); |
891 | ready_cb_cls); | 873 | GCC_destroy_without_tunnel (cc); |
874 | } | ||
875 | else | ||
876 | { | ||
877 | /* keep existing */ | ||
878 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
879 | "Got two connections on %s, keeping my existing %s\n", | ||
880 | GCPP_2s (path), | ||
881 | GCC_2s (cc)); | ||
882 | return NULL; | ||
883 | } | ||
884 | } | ||
885 | |||
886 | return connection_create (destination, | ||
887 | path, | ||
888 | off, | ||
889 | ct, | ||
890 | cid, | ||
891 | CADET_CONNECTION_CREATE_RECEIVED, | ||
892 | ready_cb, | ||
893 | ready_cb_cls); | ||
892 | } | 894 | } |
893 | 895 | ||
894 | 896 | ||
@@ -905,24 +907,24 @@ GCC_create_inbound(struct CadetPeer *destination, | |||
905 | * @return handle to the connection | 907 | * @return handle to the connection |
906 | */ | 908 | */ |
907 | struct CadetConnection * | 909 | struct CadetConnection * |
908 | GCC_create(struct CadetPeer *destination, | 910 | GCC_create (struct CadetPeer *destination, |
909 | struct CadetPeerPath *path, | 911 | struct CadetPeerPath *path, |
910 | unsigned int off, | 912 | unsigned int off, |
911 | struct CadetTConnection *ct, | 913 | struct CadetTConnection *ct, |
912 | GCC_ReadyCallback ready_cb, | 914 | GCC_ReadyCallback ready_cb, |
913 | void *ready_cb_cls) | 915 | void *ready_cb_cls) |
914 | { | 916 | { |
915 | struct GNUNET_CADET_ConnectionTunnelIdentifier cid; | 917 | struct GNUNET_CADET_ConnectionTunnelIdentifier cid; |
916 | 918 | ||
917 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof(cid)); | 919 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof(cid)); |
918 | return connection_create(destination, | 920 | return connection_create (destination, |
919 | path, | 921 | path, |
920 | off, | 922 | off, |
921 | ct, | 923 | ct, |
922 | &cid, | 924 | &cid, |
923 | CADET_CONNECTION_NEW, | 925 | CADET_CONNECTION_NEW, |
924 | ready_cb, | 926 | ready_cb, |
925 | ready_cb_cls); | 927 | ready_cb_cls); |
926 | } | 928 | } |
927 | 929 | ||
928 | 930 | ||
@@ -937,21 +939,21 @@ GCC_create(struct CadetPeer *destination, | |||
937 | * yet have a #GNUNET_MQ_notify_sent() callback attached to it | 939 | * yet have a #GNUNET_MQ_notify_sent() callback attached to it |
938 | */ | 940 | */ |
939 | void | 941 | void |
940 | GCC_transmit(struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env) | 942 | GCC_transmit (struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env) |
941 | { | 943 | { |
942 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 944 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
943 | "Scheduling message for transmission on %s\n", | 945 | "Scheduling message for transmission on %s\n", |
944 | GCC_2s(cc)); | 946 | GCC_2s (cc)); |
945 | GNUNET_assert(GNUNET_YES == cc->mqm_ready); | 947 | GNUNET_assert (GNUNET_YES == cc->mqm_ready); |
946 | GNUNET_assert(CADET_CONNECTION_READY == cc->state); | 948 | GNUNET_assert (CADET_CONNECTION_READY == cc->state); |
947 | cc->metrics.last_use = GNUNET_TIME_absolute_get(); | 949 | cc->metrics.last_use = GNUNET_TIME_absolute_get (); |
948 | cc->mqm_ready = GNUNET_NO; | 950 | cc->mqm_ready = GNUNET_NO; |
949 | if (NULL != cc->task) | 951 | if (NULL != cc->task) |
950 | { | 952 | { |
951 | GNUNET_SCHEDULER_cancel(cc->task); | 953 | GNUNET_SCHEDULER_cancel (cc->task); |
952 | cc->task = NULL; | 954 | cc->task = NULL; |
953 | } | 955 | } |
954 | GCP_send(cc->mq_man, env); | 956 | GCP_send (cc->mq_man, env); |
955 | } | 957 | } |
956 | 958 | ||
957 | 959 | ||
@@ -963,7 +965,7 @@ GCC_transmit(struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env) | |||
963 | * @return path to @a cc | 965 | * @return path to @a cc |
964 | */ | 966 | */ |
965 | struct CadetPeerPath * | 967 | struct CadetPeerPath * |
966 | GCC_get_path(struct CadetConnection *cc, unsigned int *off) | 968 | GCC_get_path (struct CadetConnection *cc, unsigned int *off) |
967 | { | 969 | { |
968 | *off = cc->off; | 970 | *off = cc->off; |
969 | return cc->path; | 971 | return cc->path; |
@@ -977,7 +979,7 @@ GCC_get_path(struct CadetConnection *cc, unsigned int *off) | |||
977 | * @return unique number of the connection | 979 | * @return unique number of the connection |
978 | */ | 980 | */ |
979 | const struct GNUNET_CADET_ConnectionTunnelIdentifier * | 981 | const struct GNUNET_CADET_ConnectionTunnelIdentifier * |
980 | GCC_get_id(struct CadetConnection *cc) | 982 | GCC_get_id (struct CadetConnection *cc) |
981 | { | 983 | { |
982 | return &cc->cid; | 984 | return &cc->cid; |
983 | } | 985 | } |
@@ -989,7 +991,7 @@ GCC_get_id(struct CadetConnection *cc) | |||
989 | * @param cc Connection. | 991 | * @param cc Connection. |
990 | */ | 992 | */ |
991 | const char * | 993 | const char * |
992 | GCC_2s(const struct CadetConnection *cc) | 994 | GCC_2s (const struct CadetConnection *cc) |
993 | { | 995 | { |
994 | static char buf[128]; | 996 | static char buf[128]; |
995 | 997 | ||
@@ -997,24 +999,24 @@ GCC_2s(const struct CadetConnection *cc) | |||
997 | return "Connection(NULL)"; | 999 | return "Connection(NULL)"; |
998 | 1000 | ||
999 | if (NULL != cc->ct) | 1001 | if (NULL != cc->ct) |
1000 | { | 1002 | { |
1001 | GNUNET_snprintf(buf, | 1003 | GNUNET_snprintf (buf, |
1002 | sizeof(buf), | 1004 | sizeof(buf), |
1003 | "Connection %s (%s)", | 1005 | "Connection %s (%s)", |
1004 | GNUNET_sh2s(&cc->cid.connection_of_tunnel), | 1006 | GNUNET_sh2s (&cc->cid.connection_of_tunnel), |
1005 | GCT_2s(cc->ct->t)); | 1007 | GCT_2s (cc->ct->t)); |
1006 | return buf; | 1008 | return buf; |
1007 | } | 1009 | } |
1008 | GNUNET_snprintf(buf, | 1010 | GNUNET_snprintf (buf, |
1009 | sizeof(buf), | 1011 | sizeof(buf), |
1010 | "Connection %s", | 1012 | "Connection %s", |
1011 | GNUNET_sh2s(&cc->cid.connection_of_tunnel)); | 1013 | GNUNET_sh2s (&cc->cid.connection_of_tunnel)); |
1012 | return buf; | 1014 | return buf; |
1013 | } | 1015 | } |
1014 | 1016 | ||
1015 | 1017 | ||
1016 | #define LOG2(level, ...) \ | 1018 | #define LOG2(level, ...) \ |
1017 | GNUNET_log_from_nocheck(level, "cadet-con", __VA_ARGS__) | 1019 | GNUNET_log_from_nocheck (level, "cadet-con", __VA_ARGS__) |
1018 | 1020 | ||
1019 | 1021 | ||
1020 | /** | 1022 | /** |
@@ -1024,30 +1026,30 @@ GCC_2s(const struct CadetConnection *cc) | |||
1024 | * @param level Debug level to use. | 1026 | * @param level Debug level to use. |
1025 | */ | 1027 | */ |
1026 | void | 1028 | void |
1027 | GCC_debug(struct CadetConnection *cc, enum GNUNET_ErrorType level) | 1029 | GCC_debug (struct CadetConnection *cc, enum GNUNET_ErrorType level) |
1028 | { | 1030 | { |
1029 | #if !defined(GNUNET_CULL_LOGGING) | 1031 | #if ! defined(GNUNET_CULL_LOGGING) |
1030 | int do_log; | 1032 | int do_log; |
1031 | 1033 | ||
1032 | do_log = GNUNET_get_log_call_status(level & (~GNUNET_ERROR_TYPE_BULK), | 1034 | do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK), |
1033 | "cadet-con", | 1035 | "cadet-con", |
1034 | __FILE__, | 1036 | __FILE__, |
1035 | __FUNCTION__, | 1037 | __FUNCTION__, |
1036 | __LINE__); | 1038 | __LINE__); |
1037 | if (0 == do_log) | 1039 | if (0 == do_log) |
1038 | return; | 1040 | return; |
1039 | if (NULL == cc) | 1041 | if (NULL == cc) |
1040 | { | 1042 | { |
1041 | LOG2(level, "Connection (NULL)\n"); | 1043 | LOG2 (level, "Connection (NULL)\n"); |
1042 | return; | 1044 | return; |
1043 | } | 1045 | } |
1044 | LOG2(level, | 1046 | LOG2 (level, |
1045 | "%s to %s via path %s in state %d is %s\n", | 1047 | "%s to %s via path %s in state %d is %s\n", |
1046 | GCC_2s(cc), | 1048 | GCC_2s (cc), |
1047 | GCP_2s(cc->destination), | 1049 | GCP_2s (cc->destination), |
1048 | GCPP_2s(cc->path), | 1050 | GCPP_2s (cc->path), |
1049 | cc->state, | 1051 | cc->state, |
1050 | (GNUNET_YES == cc->mqm_ready) ? "ready" : "busy"); | 1052 | (GNUNET_YES == cc->mqm_ready) ? "ready" : "busy"); |
1051 | #endif | 1053 | #endif |
1052 | } | 1054 | } |
1053 | 1055 | ||
diff --git a/src/cadet/gnunet-service-cadet_connection.h b/src/cadet/gnunet-service-cadet_connection.h index 47b654cbb..b05c3b72c 100644 --- a/src/cadet/gnunet-service-cadet_connection.h +++ b/src/cadet/gnunet-service-cadet_connection.h | |||
@@ -57,7 +57,7 @@ typedef void | |||
57 | * @param cc connection to destroy | 57 | * @param cc connection to destroy |
58 | */ | 58 | */ |
59 | void | 59 | void |
60 | GCC_destroy_without_core(struct CadetConnection *cc); | 60 | GCC_destroy_without_core (struct CadetConnection *cc); |
61 | 61 | ||
62 | 62 | ||
63 | /** | 63 | /** |
@@ -68,7 +68,7 @@ GCC_destroy_without_core(struct CadetConnection *cc); | |||
68 | * @param cc connection to destroy | 68 | * @param cc connection to destroy |
69 | */ | 69 | */ |
70 | void | 70 | void |
71 | GCC_destroy_without_tunnel(struct CadetConnection *cc); | 71 | GCC_destroy_without_tunnel (struct CadetConnection *cc); |
72 | 72 | ||
73 | 73 | ||
74 | /** | 74 | /** |
@@ -78,7 +78,7 @@ GCC_destroy_without_tunnel(struct CadetConnection *cc); | |||
78 | * @return NULL if connection was not found | 78 | * @return NULL if connection was not found |
79 | */ | 79 | */ |
80 | struct CadetConnection * | 80 | struct CadetConnection * |
81 | GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | 81 | GCC_lookup (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); |
82 | 82 | ||
83 | 83 | ||
84 | /** | 84 | /** |
@@ -94,12 +94,12 @@ GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | |||
94 | * @return handle to the connection | 94 | * @return handle to the connection |
95 | */ | 95 | */ |
96 | struct CadetConnection * | 96 | struct CadetConnection * |
97 | GCC_create(struct CadetPeer *destination, | 97 | GCC_create (struct CadetPeer *destination, |
98 | struct CadetPeerPath *path, | 98 | struct CadetPeerPath *path, |
99 | unsigned int off, | 99 | unsigned int off, |
100 | struct CadetTConnection *ct, | 100 | struct CadetTConnection *ct, |
101 | GCC_ReadyCallback ready_cb, | 101 | GCC_ReadyCallback ready_cb, |
102 | void *ready_cb_cls); | 102 | void *ready_cb_cls); |
103 | 103 | ||
104 | 104 | ||
105 | /** | 105 | /** |
@@ -116,12 +116,12 @@ GCC_create(struct CadetPeer *destination, | |||
116 | * a connection that takes precedence on @a path | 116 | * a connection that takes precedence on @a path |
117 | */ | 117 | */ |
118 | struct CadetConnection * | 118 | struct CadetConnection * |
119 | GCC_create_inbound(struct CadetPeer *destination, | 119 | GCC_create_inbound (struct CadetPeer *destination, |
120 | struct CadetPeerPath *path, | 120 | struct CadetPeerPath *path, |
121 | struct CadetTConnection *ct, | 121 | struct CadetTConnection *ct, |
122 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 122 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
123 | GCC_ReadyCallback ready_cb, | 123 | GCC_ReadyCallback ready_cb, |
124 | void *ready_cb_cls); | 124 | void *ready_cb_cls); |
125 | 125 | ||
126 | 126 | ||
127 | /** | 127 | /** |
@@ -137,8 +137,8 @@ GCC_create_inbound(struct CadetPeer *destination, | |||
137 | * connection identifier of this connection... | 137 | * connection identifier of this connection... |
138 | */ | 138 | */ |
139 | void | 139 | void |
140 | GCC_transmit(struct CadetConnection *cc, | 140 | GCC_transmit (struct CadetConnection *cc, |
141 | struct GNUNET_MQ_Envelope *env); | 141 | struct GNUNET_MQ_Envelope *env); |
142 | 142 | ||
143 | 143 | ||
144 | /** | 144 | /** |
@@ -147,7 +147,7 @@ GCC_transmit(struct CadetConnection *cc, | |||
147 | * @param cc the connection that got the ACK. | 147 | * @param cc the connection that got the ACK. |
148 | */ | 148 | */ |
149 | void | 149 | void |
150 | GCC_handle_connection_create_ack(struct CadetConnection *cc); | 150 | GCC_handle_connection_create_ack (struct CadetConnection *cc); |
151 | 151 | ||
152 | 152 | ||
153 | /** | 153 | /** |
@@ -158,7 +158,7 @@ GCC_handle_connection_create_ack(struct CadetConnection *cc); | |||
158 | * @param cc connection that got the duplicate CREATE | 158 | * @param cc connection that got the duplicate CREATE |
159 | */ | 159 | */ |
160 | void | 160 | void |
161 | GCC_handle_duplicate_create(struct CadetConnection *cc); | 161 | GCC_handle_duplicate_create (struct CadetConnection *cc); |
162 | 162 | ||
163 | 163 | ||
164 | /** | 164 | /** |
@@ -168,8 +168,8 @@ GCC_handle_duplicate_create(struct CadetConnection *cc); | |||
168 | * @param msg the key exchange message | 168 | * @param msg the key exchange message |
169 | */ | 169 | */ |
170 | void | 170 | void |
171 | GCC_handle_kx(struct CadetConnection *cc, | 171 | GCC_handle_kx (struct CadetConnection *cc, |
172 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg); | 172 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg); |
173 | 173 | ||
174 | 174 | ||
175 | /** | 175 | /** |
@@ -179,14 +179,16 @@ GCC_handle_kx(struct CadetConnection *cc, | |||
179 | * @param msg the key exchange message | 179 | * @param msg the key exchange message |
180 | */ | 180 | */ |
181 | void | 181 | void |
182 | GCC_handle_kx_auth(struct CadetConnection *cc, | 182 | GCC_handle_kx_auth (struct CadetConnection *cc, |
183 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg); | 183 | const struct |
184 | GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg); | ||
184 | 185 | ||
185 | 186 | ||
186 | /** | 187 | /** |
187 | * Performance metrics for a connection. | 188 | * Performance metrics for a connection. |
188 | */ | 189 | */ |
189 | struct CadetConnectionMetrics { | 190 | struct CadetConnectionMetrics |
191 | { | ||
190 | /** | 192 | /** |
191 | * Our current best estimate of the latency, based on a weighted | 193 | * Our current best estimate of the latency, based on a weighted |
192 | * average of at least @a latency_datapoints values. | 194 | * average of at least @a latency_datapoints values. |
@@ -229,7 +231,7 @@ struct CadetConnectionMetrics { | |||
229 | * @return the metrics | 231 | * @return the metrics |
230 | */ | 232 | */ |
231 | const struct CadetConnectionMetrics * | 233 | const struct CadetConnectionMetrics * |
232 | GCC_get_metrics(struct CadetConnection *cc); | 234 | GCC_get_metrics (struct CadetConnection *cc); |
233 | 235 | ||
234 | 236 | ||
235 | /** | 237 | /** |
@@ -239,8 +241,8 @@ GCC_get_metrics(struct CadetConnection *cc); | |||
239 | * @param msg the encrypted message to decrypt | 241 | * @param msg the encrypted message to decrypt |
240 | */ | 242 | */ |
241 | void | 243 | void |
242 | GCC_handle_encrypted(struct CadetConnection *cc, | 244 | GCC_handle_encrypted (struct CadetConnection *cc, |
243 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg); | 245 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg); |
244 | 246 | ||
245 | 247 | ||
246 | /** | 248 | /** |
@@ -250,7 +252,7 @@ GCC_handle_encrypted(struct CadetConnection *cc, | |||
250 | * @param cid connection identifier where we expect an ACK | 252 | * @param cid connection identifier where we expect an ACK |
251 | */ | 253 | */ |
252 | void | 254 | void |
253 | GCC_ack_expected(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | 255 | GCC_ack_expected (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); |
254 | 256 | ||
255 | 257 | ||
256 | /** | 258 | /** |
@@ -262,7 +264,7 @@ GCC_ack_expected(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | |||
262 | * may have gotten back to us via a different connection). | 264 | * may have gotten back to us via a different connection). |
263 | */ | 265 | */ |
264 | void | 266 | void |
265 | GCC_ack_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | 267 | GCC_ack_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); |
266 | 268 | ||
267 | 269 | ||
268 | /** | 270 | /** |
@@ -274,8 +276,8 @@ GCC_ack_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | |||
274 | * @param latency the observed latency | 276 | * @param latency the observed latency |
275 | */ | 277 | */ |
276 | void | 278 | void |
277 | GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | 279 | GCC_latency_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, |
278 | struct GNUNET_TIME_Relative latency); | 280 | struct GNUNET_TIME_Relative latency); |
279 | 281 | ||
280 | 282 | ||
281 | /** | 283 | /** |
@@ -285,7 +287,7 @@ GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti, | |||
285 | * @return corresponding entry in the tunnel's connection list | 287 | * @return corresponding entry in the tunnel's connection list |
286 | */ | 288 | */ |
287 | struct CadetTConnection * | 289 | struct CadetTConnection * |
288 | GCC_get_ct(struct CadetConnection *cc); | 290 | GCC_get_ct (struct CadetConnection *cc); |
289 | 291 | ||
290 | 292 | ||
291 | /** | 293 | /** |
@@ -296,8 +298,8 @@ GCC_get_ct(struct CadetConnection *cc); | |||
296 | * @return path to @a cc | 298 | * @return path to @a cc |
297 | */ | 299 | */ |
298 | struct CadetPeerPath * | 300 | struct CadetPeerPath * |
299 | GCC_get_path(struct CadetConnection *cc, | 301 | GCC_get_path (struct CadetConnection *cc, |
300 | unsigned int *off); | 302 | unsigned int *off); |
301 | 303 | ||
302 | 304 | ||
303 | /** | 305 | /** |
@@ -307,7 +309,7 @@ GCC_get_path(struct CadetConnection *cc, | |||
307 | * @return unique number of the connection | 309 | * @return unique number of the connection |
308 | */ | 310 | */ |
309 | const struct GNUNET_CADET_ConnectionTunnelIdentifier * | 311 | const struct GNUNET_CADET_ConnectionTunnelIdentifier * |
310 | GCC_get_id(struct CadetConnection *cc); | 312 | GCC_get_id (struct CadetConnection *cc); |
311 | 313 | ||
312 | 314 | ||
313 | /** | 315 | /** |
@@ -316,7 +318,7 @@ GCC_get_id(struct CadetConnection *cc); | |||
316 | * @param cc Connection. | 318 | * @param cc Connection. |
317 | */ | 319 | */ |
318 | const char * | 320 | const char * |
319 | GCC_2s(const struct CadetConnection *cc); | 321 | GCC_2s (const struct CadetConnection *cc); |
320 | 322 | ||
321 | 323 | ||
322 | /** | 324 | /** |
@@ -326,8 +328,8 @@ GCC_2s(const struct CadetConnection *cc); | |||
326 | * @param level Debug level to use. | 328 | * @param level Debug level to use. |
327 | */ | 329 | */ |
328 | void | 330 | void |
329 | GCC_debug(struct CadetConnection *cc, | 331 | GCC_debug (struct CadetConnection *cc, |
330 | enum GNUNET_ErrorType level); | 332 | enum GNUNET_ErrorType level); |
331 | 333 | ||
332 | 334 | ||
333 | #endif | 335 | #endif |
diff --git a/src/cadet/gnunet-service-cadet_core.c b/src/cadet/gnunet-service-cadet_core.c index a08c80aae..7d1791f3c 100644 --- a/src/cadet/gnunet-service-cadet_core.c +++ b/src/cadet/gnunet-service-cadet_core.c | |||
@@ -39,7 +39,7 @@ | |||
39 | #include "gnunet_statistics_service.h" | 39 | #include "gnunet_statistics_service.h" |
40 | #include "cadet_protocol.h" | 40 | #include "cadet_protocol.h" |
41 | 41 | ||
42 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-cor", __VA_ARGS__) | 42 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-cor", __VA_ARGS__) |
43 | 43 | ||
44 | /** | 44 | /** |
45 | * Information we keep per direction for a route. | 45 | * Information we keep per direction for a route. |
@@ -52,7 +52,8 @@ struct RouteDirection; | |||
52 | * routes that have the current maximum of messages in the buffer (in | 52 | * routes that have the current maximum of messages in the buffer (in |
53 | * case we have to purge). | 53 | * case we have to purge). |
54 | */ | 54 | */ |
55 | struct Rung { | 55 | struct Rung |
56 | { | ||
56 | /** | 57 | /** |
57 | * Rung of RouteDirections with one more buffer entry each. | 58 | * Rung of RouteDirections with one more buffer entry each. |
58 | */ | 59 | */ |
@@ -89,7 +90,8 @@ struct Rung { | |||
89 | /** | 90 | /** |
90 | * Information we keep per direction for a route. | 91 | * Information we keep per direction for a route. |
91 | */ | 92 | */ |
92 | struct RouteDirection { | 93 | struct RouteDirection |
94 | { | ||
93 | /** | 95 | /** |
94 | * DLL of other route directions within the same `struct Rung`. | 96 | * DLL of other route directions within the same `struct Rung`. |
95 | */ | 97 | */ |
@@ -145,7 +147,8 @@ struct RouteDirection { | |||
145 | * the complete `struct CadetPath` that is formed by the individual | 147 | * the complete `struct CadetPath` that is formed by the individual |
146 | * routes. | 148 | * routes. |
147 | */ | 149 | */ |
148 | struct CadetRoute { | 150 | struct CadetRoute |
151 | { | ||
149 | /** | 152 | /** |
150 | * Information about the next hop on this route. | 153 | * Information about the next hop on this route. |
151 | */ | 154 | */ |
@@ -231,10 +234,10 @@ static struct GNUNET_SCHEDULER_Task *timeout_task; | |||
231 | * @param cid hash generated from the connection identifier | 234 | * @param cid hash generated from the connection identifier |
232 | */ | 235 | */ |
233 | static struct CadetRoute * | 236 | static struct CadetRoute * |
234 | get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | 237 | get_route (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) |
235 | { | 238 | { |
236 | return GNUNET_CONTAINER_multishortmap_get(routes, | 239 | return GNUNET_CONTAINER_multishortmap_get (routes, |
237 | &cid->connection_of_tunnel); | 240 | &cid->connection_of_tunnel); |
238 | } | 241 | } |
239 | 242 | ||
240 | 243 | ||
@@ -244,22 +247,22 @@ get_route(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid) | |||
244 | * @param dir direction to lower in rung. | 247 | * @param dir direction to lower in rung. |
245 | */ | 248 | */ |
246 | static void | 249 | static void |
247 | lower_rung(struct RouteDirection *dir) | 250 | lower_rung (struct RouteDirection *dir) |
248 | { | 251 | { |
249 | struct Rung *rung = dir->rung; | 252 | struct Rung *rung = dir->rung; |
250 | struct Rung *prev; | 253 | struct Rung *prev; |
251 | 254 | ||
252 | GNUNET_CONTAINER_DLL_remove(rung->rd_head, rung->rd_tail, dir); | 255 | GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir); |
253 | prev = rung->prev; | 256 | prev = rung->prev; |
254 | GNUNET_assert(NULL != prev); | 257 | GNUNET_assert (NULL != prev); |
255 | if (prev->rung_off != rung->rung_off - 1) | 258 | if (prev->rung_off != rung->rung_off - 1) |
256 | { | 259 | { |
257 | prev = GNUNET_new(struct Rung); | 260 | prev = GNUNET_new (struct Rung); |
258 | prev->rung_off = rung->rung_off - 1; | 261 | prev->rung_off = rung->rung_off - 1; |
259 | GNUNET_CONTAINER_DLL_insert_after(rung_head, rung_tail, rung->prev, prev); | 262 | GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung->prev, prev); |
260 | } | 263 | } |
261 | GNUNET_assert(NULL != prev); | 264 | GNUNET_assert (NULL != prev); |
262 | GNUNET_CONTAINER_DLL_insert(prev->rd_head, prev->rd_tail, dir); | 265 | GNUNET_CONTAINER_DLL_insert (prev->rd_head, prev->rd_tail, dir); |
263 | dir->rung = prev; | 266 | dir->rung = prev; |
264 | } | 267 | } |
265 | 268 | ||
@@ -272,13 +275,13 @@ lower_rung(struct RouteDirection *dir) | |||
272 | * @param env envelope to discard | 275 | * @param env envelope to discard |
273 | */ | 276 | */ |
274 | static void | 277 | static void |
275 | discard_buffer(struct RouteDirection *dir, struct GNUNET_MQ_Envelope *env) | 278 | discard_buffer (struct RouteDirection *dir, struct GNUNET_MQ_Envelope *env) |
276 | { | 279 | { |
277 | GNUNET_MQ_dll_remove(&dir->env_head, &dir->env_tail, env); | 280 | GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env); |
278 | cur_buffers--; | 281 | cur_buffers--; |
279 | GNUNET_MQ_discard(env); | 282 | GNUNET_MQ_discard (env); |
280 | lower_rung(dir); | 283 | lower_rung (dir); |
281 | GNUNET_STATISTICS_set(stats, "# buffer use", cur_buffers, GNUNET_NO); | 284 | GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO); |
282 | } | 285 | } |
283 | 286 | ||
284 | 287 | ||
@@ -286,24 +289,24 @@ discard_buffer(struct RouteDirection *dir, struct GNUNET_MQ_Envelope *env) | |||
286 | * Discard all messages from the highest rung, to make space. | 289 | * Discard all messages from the highest rung, to make space. |
287 | */ | 290 | */ |
288 | static void | 291 | static void |
289 | discard_all_from_rung_tail() | 292 | discard_all_from_rung_tail () |
290 | { | 293 | { |
291 | struct Rung *tail = rung_tail; | 294 | struct Rung *tail = rung_tail; |
292 | struct RouteDirection *dir; | 295 | struct RouteDirection *dir; |
293 | 296 | ||
294 | while (NULL != (dir = tail->rd_head)) | 297 | while (NULL != (dir = tail->rd_head)) |
295 | { | 298 | { |
296 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 299 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
297 | "Queue full due new message %s on connection %s, dropping old message\n", | 300 | "Queue full due new message %s on connection %s, dropping old message\n", |
298 | GNUNET_sh2s(&dir->my_route->cid.connection_of_tunnel)); | 301 | GNUNET_sh2s (&dir->my_route->cid.connection_of_tunnel)); |
299 | GNUNET_STATISTICS_update(stats, | 302 | GNUNET_STATISTICS_update (stats, |
300 | "# messages dropped due to full buffer", | 303 | "# messages dropped due to full buffer", |
301 | 1, | 304 | 1, |
302 | GNUNET_NO); | 305 | GNUNET_NO); |
303 | discard_buffer(dir, dir->env_head); | 306 | discard_buffer (dir, dir->env_head); |
304 | } | 307 | } |
305 | GNUNET_CONTAINER_DLL_remove(rung_head, rung_tail, tail); | 308 | GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, tail); |
306 | GNUNET_free(tail); | 309 | GNUNET_free (tail); |
307 | } | 310 | } |
308 | 311 | ||
309 | 312 | ||
@@ -317,10 +320,10 @@ discard_all_from_rung_tail() | |||
317 | * @param msg the message to forward | 320 | * @param msg the message to forward |
318 | */ | 321 | */ |
319 | static void | 322 | static void |
320 | route_message(struct CadetPeer *prev, | 323 | route_message (struct CadetPeer *prev, |
321 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 324 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
322 | const struct GNUNET_MessageHeader *msg, | 325 | const struct GNUNET_MessageHeader *msg, |
323 | const enum GNUNET_MQ_PriorityPreferences priority) | 326 | const enum GNUNET_MQ_PriorityPreferences priority) |
324 | { | 327 | { |
325 | struct CadetRoute *route; | 328 | struct CadetRoute *route; |
326 | struct RouteDirection *dir; | 329 | struct RouteDirection *dir; |
@@ -328,133 +331,133 @@ route_message(struct CadetPeer *prev, | |||
328 | struct Rung *nxt; | 331 | struct Rung *nxt; |
329 | struct GNUNET_MQ_Envelope *env; | 332 | struct GNUNET_MQ_Envelope *env; |
330 | 333 | ||
331 | route = get_route(cid); | 334 | route = get_route (cid); |
332 | if (NULL == route) | 335 | if (NULL == route) |
336 | { | ||
337 | struct GNUNET_MQ_Envelope *env; | ||
338 | struct GNUNET_CADET_ConnectionBrokenMessage *bm; | ||
339 | |||
340 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
341 | "Failed to route message of type %u from %s on connection %s: no route\n", | ||
342 | ntohs (msg->type), | ||
343 | GCP_2s (prev), | ||
344 | GNUNET_sh2s (&cid->connection_of_tunnel)); | ||
345 | switch (ntohs (msg->type)) | ||
333 | { | 346 | { |
334 | struct GNUNET_MQ_Envelope *env; | 347 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: |
335 | struct GNUNET_CADET_ConnectionBrokenMessage *bm; | 348 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: |
336 | 349 | /* No need to respond to these! */ | |
337 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
338 | "Failed to route message of type %u from %s on connection %s: no route\n", | ||
339 | ntohs(msg->type), | ||
340 | GCP_2s(prev), | ||
341 | GNUNET_sh2s(&cid->connection_of_tunnel)); | ||
342 | switch (ntohs(msg->type)) | ||
343 | { | ||
344 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: | ||
345 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: | ||
346 | /* No need to respond to these! */ | ||
347 | return; | ||
348 | } | ||
349 | env = GNUNET_MQ_msg(bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN); | ||
350 | bm->cid = *cid; | ||
351 | bm->peer1 = my_full_id; | ||
352 | GCP_send_ooo(prev, env); | ||
353 | return; | 350 | return; |
354 | } | 351 | } |
355 | route->last_use = GNUNET_TIME_absolute_get(); | 352 | env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN); |
356 | GNUNET_CONTAINER_heap_update_cost(route->hn, route->last_use.abs_value_us); | 353 | bm->cid = *cid; |
354 | bm->peer1 = my_full_id; | ||
355 | GCP_send_ooo (prev, env); | ||
356 | return; | ||
357 | } | ||
358 | route->last_use = GNUNET_TIME_absolute_get (); | ||
359 | GNUNET_CONTAINER_heap_update_cost (route->hn, route->last_use.abs_value_us); | ||
357 | dir = (prev == route->prev.hop) ? &route->next : &route->prev; | 360 | dir = (prev == route->prev.hop) ? &route->next : &route->prev; |
358 | if (GNUNET_YES == dir->is_ready) | 361 | if (GNUNET_YES == dir->is_ready) |
359 | { | 362 | { |
360 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 363 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
361 | "Routing message of type %u from %s to %s on connection %s\n", | 364 | "Routing message of type %u from %s to %s on connection %s\n", |
362 | ntohs(msg->type), | 365 | ntohs (msg->type), |
363 | GCP_2s(prev), | 366 | GCP_2s (prev), |
364 | GNUNET_i2s(GCP_get_id(dir->hop)), | 367 | GNUNET_i2s (GCP_get_id (dir->hop)), |
365 | GNUNET_sh2s(&cid->connection_of_tunnel)); | 368 | GNUNET_sh2s (&cid->connection_of_tunnel)); |
366 | dir->is_ready = GNUNET_NO; | 369 | dir->is_ready = GNUNET_NO; |
367 | GCP_send(dir->mqm, GNUNET_MQ_msg_copy(msg)); | 370 | GCP_send (dir->mqm, GNUNET_MQ_msg_copy (msg)); |
368 | return; | 371 | return; |
369 | } | 372 | } |
370 | /* Check if low latency is required and if the previous message was | 373 | /* Check if low latency is required and if the previous message was |
371 | unreliable; if so, make sure we only queue one message per | 374 | unreliable; if so, make sure we only queue one message per |
372 | direction (no buffering). */ | 375 | direction (no buffering). */ |
373 | if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) && | 376 | if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) && |
374 | (NULL != dir->env_head) && | 377 | (NULL != dir->env_head) && |
375 | (0 == | 378 | (0 == |
376 | (GNUNET_MQ_env_get_options(dir->env_head) & GNUNET_MQ_PREF_UNRELIABLE))) | 379 | (GNUNET_MQ_env_get_options (dir->env_head) & GNUNET_MQ_PREF_UNRELIABLE))) |
377 | discard_buffer(dir, dir->env_head); | 380 | discard_buffer (dir, dir->env_head); |
378 | /* Check for duplicates */ | 381 | /* Check for duplicates */ |
379 | for (const struct GNUNET_MQ_Envelope *env = dir->env_head; NULL != env; | 382 | for (const struct GNUNET_MQ_Envelope *env = dir->env_head; NULL != env; |
380 | env = GNUNET_MQ_env_next(env)) | 383 | env = GNUNET_MQ_env_next (env)) |
384 | { | ||
385 | const struct GNUNET_MessageHeader *hdr = GNUNET_MQ_env_get_msg (env); | ||
386 | |||
387 | if ((hdr->size == msg->size) && (0 == memcmp (hdr, msg, ntohs (msg->size)))) | ||
381 | { | 388 | { |
382 | const struct GNUNET_MessageHeader *hdr = GNUNET_MQ_env_get_msg(env); | 389 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
383 | 390 | "Received duplicate of message already in buffer, dropping\n"); | |
384 | if ((hdr->size == msg->size) && (0 == memcmp(hdr, msg, ntohs(msg->size)))) | 391 | GNUNET_STATISTICS_update (stats, |
385 | { | 392 | "# messages dropped due to duplicate in buffer", |
386 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 393 | 1, |
387 | "Received duplicate of message already in buffer, dropping\n"); | 394 | GNUNET_NO); |
388 | GNUNET_STATISTICS_update(stats, | 395 | return; |
389 | "# messages dropped due to duplicate in buffer", | ||
390 | 1, | ||
391 | GNUNET_NO); | ||
392 | return; | ||
393 | } | ||
394 | } | 396 | } |
397 | } | ||
395 | 398 | ||
396 | rung = dir->rung; | 399 | rung = dir->rung; |
397 | if (cur_buffers == max_buffers) | 400 | if (cur_buffers == max_buffers) |
401 | { | ||
402 | /* Need to make room. */ | ||
403 | if (NULL != rung->next) | ||
398 | { | 404 | { |
399 | /* Need to make room. */ | 405 | /* Easy case, drop messages from route directions in highest rung */ |
400 | if (NULL != rung->next) | 406 | discard_all_from_rung_tail (); |
401 | { | ||
402 | /* Easy case, drop messages from route directions in highest rung */ | ||
403 | discard_all_from_rung_tail(); | ||
404 | } | ||
405 | else | ||
406 | { | ||
407 | /* We are in the highest rung, drop our own! */ | ||
408 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
409 | "Queue full due new message %s on connection %s, dropping old message\n", | ||
410 | GNUNET_sh2s(&dir->my_route->cid.connection_of_tunnel)); | ||
411 | GNUNET_STATISTICS_update(stats, | ||
412 | "# messages dropped due to full buffer", | ||
413 | 1, | ||
414 | GNUNET_NO); | ||
415 | discard_buffer(dir, dir->env_head); | ||
416 | rung = dir->rung; | ||
417 | } | ||
418 | } | 407 | } |
408 | else | ||
409 | { | ||
410 | /* We are in the highest rung, drop our own! */ | ||
411 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
412 | "Queue full due new message %s on connection %s, dropping old message\n", | ||
413 | GNUNET_sh2s (&dir->my_route->cid.connection_of_tunnel)); | ||
414 | GNUNET_STATISTICS_update (stats, | ||
415 | "# messages dropped due to full buffer", | ||
416 | 1, | ||
417 | GNUNET_NO); | ||
418 | discard_buffer (dir, dir->env_head); | ||
419 | rung = dir->rung; | ||
420 | } | ||
421 | } | ||
419 | /* remove 'dir' from current rung */ | 422 | /* remove 'dir' from current rung */ |
420 | GNUNET_CONTAINER_DLL_remove(rung->rd_head, rung->rd_tail, dir); | 423 | GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir); |
421 | /* make 'nxt' point to the next higher rung, create if necessary */ | 424 | /* make 'nxt' point to the next higher rung, create if necessary */ |
422 | nxt = rung->next; | 425 | nxt = rung->next; |
423 | if ((NULL == nxt) || (rung->rung_off + 1 != nxt->rung_off)) | 426 | if ((NULL == nxt) || (rung->rung_off + 1 != nxt->rung_off)) |
424 | { | 427 | { |
425 | nxt = GNUNET_new(struct Rung); | 428 | nxt = GNUNET_new (struct Rung); |
426 | nxt->rung_off = rung->rung_off + 1; | 429 | nxt->rung_off = rung->rung_off + 1; |
427 | GNUNET_CONTAINER_DLL_insert_after(rung_head, rung_tail, rung, nxt); | 430 | GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung, nxt); |
428 | } | 431 | } |
429 | /* insert 'dir' into next higher rung */ | 432 | /* insert 'dir' into next higher rung */ |
430 | GNUNET_CONTAINER_DLL_insert(nxt->rd_head, nxt->rd_tail, dir); | 433 | GNUNET_CONTAINER_DLL_insert (nxt->rd_head, nxt->rd_tail, dir); |
431 | dir->rung = nxt; | 434 | dir->rung = nxt; |
432 | 435 | ||
433 | /* add message into 'dir' buffer */ | 436 | /* add message into 'dir' buffer */ |
434 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 437 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
435 | "Queueing new message of type %u from %s to %s on connection %s\n", | 438 | "Queueing new message of type %u from %s to %s on connection %s\n", |
436 | ntohs(msg->type), | 439 | ntohs (msg->type), |
437 | GCP_2s(prev), | 440 | GCP_2s (prev), |
438 | GNUNET_i2s(GCP_get_id(dir->hop)), | 441 | GNUNET_i2s (GCP_get_id (dir->hop)), |
439 | GNUNET_sh2s(&cid->connection_of_tunnel)); | 442 | GNUNET_sh2s (&cid->connection_of_tunnel)); |
440 | env = GNUNET_MQ_msg_copy(msg); | 443 | env = GNUNET_MQ_msg_copy (msg); |
441 | GNUNET_MQ_env_set_options(env, priority); | 444 | GNUNET_MQ_env_set_options (env, priority); |
442 | if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) && | 445 | if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) && |
443 | (0 != (priority & GNUNET_MQ_PREF_OUT_OF_ORDER)) && | 446 | (0 != (priority & GNUNET_MQ_PREF_OUT_OF_ORDER)) && |
444 | (NULL != dir->env_head) && | 447 | (NULL != dir->env_head) && |
445 | (0 == (GNUNET_MQ_env_get_options(dir->env_head) & | 448 | (0 == (GNUNET_MQ_env_get_options (dir->env_head) |
446 | GNUNET_MQ_PREF_LOW_LATENCY))) | 449 | & GNUNET_MQ_PREF_LOW_LATENCY))) |
447 | GNUNET_MQ_dll_insert_head(&dir->env_head, &dir->env_tail, env); | 450 | GNUNET_MQ_dll_insert_head (&dir->env_head, &dir->env_tail, env); |
448 | else | 451 | else |
449 | GNUNET_MQ_dll_insert_tail(&dir->env_head, &dir->env_tail, env); | 452 | GNUNET_MQ_dll_insert_tail (&dir->env_head, &dir->env_tail, env); |
450 | cur_buffers++; | 453 | cur_buffers++; |
451 | GNUNET_STATISTICS_set(stats, "# buffer use", cur_buffers, GNUNET_NO); | 454 | GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO); |
452 | /* Clean up 'rung' if now empty (and not head) */ | 455 | /* Clean up 'rung' if now empty (and not head) */ |
453 | if ((NULL == rung->rd_head) && (rung != rung_head)) | 456 | if ((NULL == rung->rd_head) && (rung != rung_head)) |
454 | { | 457 | { |
455 | GNUNET_CONTAINER_DLL_remove(rung_head, rung_tail, rung); | 458 | GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, rung); |
456 | GNUNET_free(rung); | 459 | GNUNET_free (rung); |
457 | } | 460 | } |
458 | } | 461 | } |
459 | 462 | ||
460 | 463 | ||
@@ -467,16 +470,16 @@ route_message(struct CadetPeer *prev, | |||
467 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. | 470 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. |
468 | */ | 471 | */ |
469 | static int | 472 | static int |
470 | check_connection_create(void *cls, | 473 | check_connection_create (void *cls, |
471 | const struct GNUNET_CADET_ConnectionCreateMessage *msg) | 474 | const struct GNUNET_CADET_ConnectionCreateMessage *msg) |
472 | { | 475 | { |
473 | uint16_t size = ntohs(msg->header.size) - sizeof(*msg); | 476 | uint16_t size = ntohs (msg->header.size) - sizeof(*msg); |
474 | 477 | ||
475 | if (0 != (size % sizeof(struct GNUNET_PeerIdentity))) | 478 | if (0 != (size % sizeof(struct GNUNET_PeerIdentity))) |
476 | { | 479 | { |
477 | GNUNET_break_op(0); | 480 | GNUNET_break_op (0); |
478 | return GNUNET_NO; | 481 | return GNUNET_NO; |
479 | } | 482 | } |
480 | return GNUNET_YES; | 483 | return GNUNET_YES; |
481 | } | 484 | } |
482 | 485 | ||
@@ -487,24 +490,24 @@ check_connection_create(void *cls, | |||
487 | * @param dir direction to destroy (do NOT free memory of 'dir' itself) | 490 | * @param dir direction to destroy (do NOT free memory of 'dir' itself) |
488 | */ | 491 | */ |
489 | static void | 492 | static void |
490 | destroy_direction(struct RouteDirection *dir) | 493 | destroy_direction (struct RouteDirection *dir) |
491 | { | 494 | { |
492 | struct GNUNET_MQ_Envelope *env; | 495 | struct GNUNET_MQ_Envelope *env; |
493 | 496 | ||
494 | while (NULL != (env = dir->env_head)) | 497 | while (NULL != (env = dir->env_head)) |
495 | { | 498 | { |
496 | GNUNET_STATISTICS_update(stats, | 499 | GNUNET_STATISTICS_update (stats, |
497 | "# messages dropped due to route destruction", | 500 | "# messages dropped due to route destruction", |
498 | 1, | 501 | 1, |
499 | GNUNET_NO); | 502 | GNUNET_NO); |
500 | discard_buffer(dir, env); | 503 | discard_buffer (dir, env); |
501 | } | 504 | } |
502 | if (NULL != dir->mqm) | 505 | if (NULL != dir->mqm) |
503 | { | 506 | { |
504 | GCP_request_mq_cancel(dir->mqm, NULL); | 507 | GCP_request_mq_cancel (dir->mqm, NULL); |
505 | dir->mqm = NULL; | 508 | dir->mqm = NULL; |
506 | } | 509 | } |
507 | GNUNET_CONTAINER_DLL_remove(rung_head->rd_head, rung_head->rd_tail, dir); | 510 | GNUNET_CONTAINER_DLL_remove (rung_head->rd_head, rung_head->rd_tail, dir); |
508 | } | 511 | } |
509 | 512 | ||
510 | 513 | ||
@@ -514,26 +517,26 @@ destroy_direction(struct RouteDirection *dir) | |||
514 | * @param route route to destroy | 517 | * @param route route to destroy |
515 | */ | 518 | */ |
516 | static void | 519 | static void |
517 | destroy_route(struct CadetRoute *route) | 520 | destroy_route (struct CadetRoute *route) |
518 | { | 521 | { |
519 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 522 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
520 | "Destroying route from %s to %s of connection %s\n", | 523 | "Destroying route from %s to %s of connection %s\n", |
521 | GNUNET_i2s(GCP_get_id(route->prev.hop)), | 524 | GNUNET_i2s (GCP_get_id (route->prev.hop)), |
522 | GNUNET_i2s2(GCP_get_id(route->next.hop)), | 525 | GNUNET_i2s2 (GCP_get_id (route->next.hop)), |
523 | GNUNET_sh2s(&route->cid.connection_of_tunnel)); | 526 | GNUNET_sh2s (&route->cid.connection_of_tunnel)); |
524 | GNUNET_assert(route == GNUNET_CONTAINER_heap_remove_node(route->hn)); | 527 | GNUNET_assert (route == GNUNET_CONTAINER_heap_remove_node (route->hn)); |
525 | GNUNET_assert( | 528 | GNUNET_assert ( |
526 | GNUNET_YES == | 529 | GNUNET_YES == |
527 | GNUNET_CONTAINER_multishortmap_remove(routes, | 530 | GNUNET_CONTAINER_multishortmap_remove (routes, |
528 | &route->cid.connection_of_tunnel, | 531 | &route->cid.connection_of_tunnel, |
529 | route)); | 532 | route)); |
530 | GNUNET_STATISTICS_set(stats, | 533 | GNUNET_STATISTICS_set (stats, |
531 | "# routes", | 534 | "# routes", |
532 | GNUNET_CONTAINER_multishortmap_size(routes), | 535 | GNUNET_CONTAINER_multishortmap_size (routes), |
533 | GNUNET_NO); | 536 | GNUNET_NO); |
534 | destroy_direction(&route->prev); | 537 | destroy_direction (&route->prev); |
535 | destroy_direction(&route->next); | 538 | destroy_direction (&route->next); |
536 | GNUNET_free(route); | 539 | GNUNET_free (route); |
537 | } | 540 | } |
538 | 541 | ||
539 | 542 | ||
@@ -546,30 +549,30 @@ destroy_route(struct CadetRoute *route) | |||
546 | * @param peer2 another one of the peers where a link is broken | 549 | * @param peer2 another one of the peers where a link is broken |
547 | */ | 550 | */ |
548 | static void | 551 | static void |
549 | send_broken(struct RouteDirection *target, | 552 | send_broken (struct RouteDirection *target, |
550 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 553 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
551 | const struct GNUNET_PeerIdentity *peer1, | 554 | const struct GNUNET_PeerIdentity *peer1, |
552 | const struct GNUNET_PeerIdentity *peer2) | 555 | const struct GNUNET_PeerIdentity *peer2) |
553 | { | 556 | { |
554 | struct GNUNET_MQ_Envelope *env; | 557 | struct GNUNET_MQ_Envelope *env; |
555 | struct GNUNET_CADET_ConnectionBrokenMessage *bm; | 558 | struct GNUNET_CADET_ConnectionBrokenMessage *bm; |
556 | 559 | ||
557 | if (NULL == target->mqm) | 560 | if (NULL == target->mqm) |
558 | return; /* Can't send notification, connection is down! */ | 561 | return; /* Can't send notification, connection is down! */ |
559 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 562 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
560 | "Notifying %s about BROKEN route at %s-%s of connection %s\n", | 563 | "Notifying %s about BROKEN route at %s-%s of connection %s\n", |
561 | GCP_2s(target->hop), | 564 | GCP_2s (target->hop), |
562 | GNUNET_i2s(peer1), | 565 | GNUNET_i2s (peer1), |
563 | GNUNET_i2s2(peer2), | 566 | GNUNET_i2s2 (peer2), |
564 | GNUNET_sh2s(&cid->connection_of_tunnel)); | 567 | GNUNET_sh2s (&cid->connection_of_tunnel)); |
565 | 568 | ||
566 | env = GNUNET_MQ_msg(bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN); | 569 | env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN); |
567 | bm->cid = *cid; | 570 | bm->cid = *cid; |
568 | if (NULL != peer1) | 571 | if (NULL != peer1) |
569 | bm->peer1 = *peer1; | 572 | bm->peer1 = *peer1; |
570 | if (NULL != peer2) | 573 | if (NULL != peer2) |
571 | bm->peer2 = *peer2; | 574 | bm->peer2 = *peer2; |
572 | GCP_request_mq_cancel(target->mqm, env); | 575 | GCP_request_mq_cancel (target->mqm, env); |
573 | target->mqm = NULL; | 576 | target->mqm = NULL; |
574 | } | 577 | } |
575 | 578 | ||
@@ -582,31 +585,31 @@ send_broken(struct RouteDirection *target, | |||
582 | * @param cls NULL | 585 | * @param cls NULL |
583 | */ | 586 | */ |
584 | static void | 587 | static void |
585 | timeout_cb(void *cls) | 588 | timeout_cb (void *cls) |
586 | { | 589 | { |
587 | struct CadetRoute *r; | 590 | struct CadetRoute *r; |
588 | struct GNUNET_TIME_Relative linger; | 591 | struct GNUNET_TIME_Relative linger; |
589 | struct GNUNET_TIME_Absolute exp; | 592 | struct GNUNET_TIME_Absolute exp; |
590 | 593 | ||
591 | timeout_task = NULL; | 594 | timeout_task = NULL; |
592 | linger = GNUNET_TIME_relative_multiply(keepalive_period, 3); | 595 | linger = GNUNET_TIME_relative_multiply (keepalive_period, 3); |
593 | while (NULL != (r = GNUNET_CONTAINER_heap_peek(route_heap))) | 596 | while (NULL != (r = GNUNET_CONTAINER_heap_peek (route_heap))) |
597 | { | ||
598 | exp = GNUNET_TIME_absolute_add (r->last_use, linger); | ||
599 | if (0 != GNUNET_TIME_absolute_get_remaining (exp).rel_value_us) | ||
594 | { | 600 | { |
595 | exp = GNUNET_TIME_absolute_add(r->last_use, linger); | 601 | /* Route not yet timed out, wait until it does. */ |
596 | if (0 != GNUNET_TIME_absolute_get_remaining(exp).rel_value_us) | 602 | timeout_task = GNUNET_SCHEDULER_add_at (exp, &timeout_cb, NULL); |
597 | { | 603 | return; |
598 | /* Route not yet timed out, wait until it does. */ | ||
599 | timeout_task = GNUNET_SCHEDULER_add_at(exp, &timeout_cb, NULL); | ||
600 | return; | ||
601 | } | ||
602 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
603 | "Sending BROKEN due to timeout (%s was last use, %s linger)\n", | ||
604 | GNUNET_STRINGS_absolute_time_to_string(r->last_use), | ||
605 | GNUNET_STRINGS_relative_time_to_string(linger, GNUNET_YES)); | ||
606 | send_broken(&r->prev, &r->cid, NULL, NULL); | ||
607 | send_broken(&r->next, &r->cid, NULL, NULL); | ||
608 | destroy_route(r); | ||
609 | } | 604 | } |
605 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
606 | "Sending BROKEN due to timeout (%s was last use, %s linger)\n", | ||
607 | GNUNET_STRINGS_absolute_time_to_string (r->last_use), | ||
608 | GNUNET_STRINGS_relative_time_to_string (linger, GNUNET_YES)); | ||
609 | send_broken (&r->prev, &r->cid, NULL, NULL); | ||
610 | send_broken (&r->next, &r->cid, NULL, NULL); | ||
611 | destroy_route (r); | ||
612 | } | ||
610 | /* No more routes left, so no need for a #timeout_task */ | 613 | /* No more routes left, so no need for a #timeout_task */ |
611 | } | 614 | } |
612 | 615 | ||
@@ -624,32 +627,32 @@ timeout_cb(void *cls) | |||
624 | * and the last envelope was discarded | 627 | * and the last envelope was discarded |
625 | */ | 628 | */ |
626 | static void | 629 | static void |
627 | dir_ready_cb(void *cls, int ready) | 630 | dir_ready_cb (void *cls, int ready) |
628 | { | 631 | { |
629 | struct RouteDirection *dir = cls; | 632 | struct RouteDirection *dir = cls; |
630 | struct CadetRoute *route = dir->my_route; | 633 | struct CadetRoute *route = dir->my_route; |
631 | struct RouteDirection *odir; | 634 | struct RouteDirection *odir; |
632 | 635 | ||
633 | if (GNUNET_YES == ready) | 636 | if (GNUNET_YES == ready) |
637 | { | ||
638 | struct GNUNET_MQ_Envelope *env; | ||
639 | |||
640 | dir->is_ready = GNUNET_YES; | ||
641 | if (NULL != (env = dir->env_head)) | ||
634 | { | 642 | { |
635 | struct GNUNET_MQ_Envelope *env; | 643 | GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env); |
636 | 644 | cur_buffers--; | |
637 | dir->is_ready = GNUNET_YES; | 645 | GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO); |
638 | if (NULL != (env = dir->env_head)) | 646 | lower_rung (dir); |
639 | { | 647 | dir->is_ready = GNUNET_NO; |
640 | GNUNET_MQ_dll_remove(&dir->env_head, &dir->env_tail, env); | 648 | GCP_send (dir->mqm, env); |
641 | cur_buffers--; | ||
642 | GNUNET_STATISTICS_set(stats, "# buffer use", cur_buffers, GNUNET_NO); | ||
643 | lower_rung(dir); | ||
644 | dir->is_ready = GNUNET_NO; | ||
645 | GCP_send(dir->mqm, env); | ||
646 | } | ||
647 | return; | ||
648 | } | 649 | } |
650 | return; | ||
651 | } | ||
649 | odir = (dir == &route->next) ? &route->prev : &route->next; | 652 | odir = (dir == &route->next) ? &route->prev : &route->next; |
650 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending BROKEN due to MQ going down\n"); | 653 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending BROKEN due to MQ going down\n"); |
651 | send_broken(&route->next, &route->cid, GCP_get_id(odir->hop), &my_full_id); | 654 | send_broken (&route->next, &route->cid, GCP_get_id (odir->hop), &my_full_id); |
652 | destroy_route(route); | 655 | destroy_route (route); |
653 | } | 656 | } |
654 | 657 | ||
655 | 658 | ||
@@ -661,16 +664,16 @@ dir_ready_cb(void *cls, int ready) | |||
661 | * @param hop next hop on in the @a dir | 664 | * @param hop next hop on in the @a dir |
662 | */ | 665 | */ |
663 | static void | 666 | static void |
664 | dir_init(struct RouteDirection *dir, | 667 | dir_init (struct RouteDirection *dir, |
665 | struct CadetRoute *route, | 668 | struct CadetRoute *route, |
666 | struct CadetPeer *hop) | 669 | struct CadetPeer *hop) |
667 | { | 670 | { |
668 | dir->hop = hop; | 671 | dir->hop = hop; |
669 | dir->my_route = route; | 672 | dir->my_route = route; |
670 | dir->mqm = GCP_request_mq(hop, &dir_ready_cb, dir); | 673 | dir->mqm = GCP_request_mq (hop, &dir_ready_cb, dir); |
671 | GNUNET_CONTAINER_DLL_insert(rung_head->rd_head, rung_head->rd_tail, dir); | 674 | GNUNET_CONTAINER_DLL_insert (rung_head->rd_head, rung_head->rd_tail, dir); |
672 | dir->rung = rung_head; | 675 | dir->rung = rung_head; |
673 | GNUNET_assert(GNUNET_YES == dir->is_ready); | 676 | GNUNET_assert (GNUNET_YES == dir->is_ready); |
674 | } | 677 | } |
675 | 678 | ||
676 | 679 | ||
@@ -685,7 +688,7 @@ dir_init(struct RouteDirection *dir, | |||
685 | * or NULL. | 688 | * or NULL. |
686 | */ | 689 | */ |
687 | static void | 690 | static void |
688 | send_broken_without_mqm( | 691 | send_broken_without_mqm ( |
689 | struct CadetPeer *target, | 692 | struct CadetPeer *target, |
690 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 693 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
691 | const struct GNUNET_PeerIdentity *failure_at) | 694 | const struct GNUNET_PeerIdentity *failure_at) |
@@ -693,12 +696,12 @@ send_broken_without_mqm( | |||
693 | struct GNUNET_MQ_Envelope *env; | 696 | struct GNUNET_MQ_Envelope *env; |
694 | struct GNUNET_CADET_ConnectionBrokenMessage *bm; | 697 | struct GNUNET_CADET_ConnectionBrokenMessage *bm; |
695 | 698 | ||
696 | env = GNUNET_MQ_msg(bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN); | 699 | env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN); |
697 | bm->cid = *cid; | 700 | bm->cid = *cid; |
698 | bm->peer1 = my_full_id; | 701 | bm->peer1 = my_full_id; |
699 | if (NULL != failure_at) | 702 | if (NULL != failure_at) |
700 | bm->peer2 = *failure_at; | 703 | bm->peer2 = *failure_at; |
701 | GCP_send_ooo(target, env); | 704 | GCP_send_ooo (target, env); |
702 | } | 705 | } |
703 | 706 | ||
704 | 707 | ||
@@ -709,193 +712,194 @@ send_broken_without_mqm( | |||
709 | * @param msg Message itself. | 712 | * @param msg Message itself. |
710 | */ | 713 | */ |
711 | static void | 714 | static void |
712 | handle_connection_create( | 715 | handle_connection_create ( |
713 | void *cls, | 716 | void *cls, |
714 | const struct GNUNET_CADET_ConnectionCreateMessage *msg) | 717 | const struct GNUNET_CADET_ConnectionCreateMessage *msg) |
715 | { | 718 | { |
716 | struct CadetPeer *sender = cls; | 719 | struct CadetPeer *sender = cls; |
717 | struct CadetPeer *next; | 720 | struct CadetPeer *next; |
718 | const struct GNUNET_PeerIdentity *pids = | 721 | const struct GNUNET_PeerIdentity *pids = |
719 | (const struct GNUNET_PeerIdentity *)&msg[1]; | 722 | (const struct GNUNET_PeerIdentity *) &msg[1]; |
720 | struct CadetRoute *route; | 723 | struct CadetRoute *route; |
721 | uint16_t size = ntohs(msg->header.size) - sizeof(*msg); | 724 | uint16_t size = ntohs (msg->header.size) - sizeof(*msg); |
722 | unsigned int path_length; | 725 | unsigned int path_length; |
723 | unsigned int off; | 726 | unsigned int off; |
724 | 727 | ||
725 | path_length = size / sizeof(struct GNUNET_PeerIdentity); | 728 | path_length = size / sizeof(struct GNUNET_PeerIdentity); |
726 | if (0 == path_length) | 729 | if (0 == path_length) |
727 | { | 730 | { |
728 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 731 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
729 | "Dropping CADET_CONNECTION_CREATE with empty path\n"); | 732 | "Dropping CADET_CONNECTION_CREATE with empty path\n"); |
730 | GNUNET_break_op(0); | 733 | GNUNET_break_op (0); |
731 | return; | 734 | return; |
732 | } | 735 | } |
733 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 736 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
734 | "Handling CADET_CONNECTION_CREATE from %s for CID %s with %u hops\n", | 737 | "Handling CADET_CONNECTION_CREATE from %s for CID %s with %u hops\n", |
735 | GCP_2s(sender), | 738 | GCP_2s (sender), |
736 | GNUNET_sh2s(&msg->cid.connection_of_tunnel), | 739 | GNUNET_sh2s (&msg->cid.connection_of_tunnel), |
737 | path_length); | 740 | path_length); |
738 | /* Check for loops */ | 741 | /* Check for loops */ |
739 | { | 742 | { |
740 | struct GNUNET_CONTAINER_MultiPeerMap *map; | 743 | struct GNUNET_CONTAINER_MultiPeerMap *map; |
741 | 744 | ||
742 | map = GNUNET_CONTAINER_multipeermap_create(path_length * 2, GNUNET_YES); | 745 | map = GNUNET_CONTAINER_multipeermap_create (path_length * 2, GNUNET_YES); |
743 | GNUNET_assert(NULL != map); | 746 | GNUNET_assert (NULL != map); |
744 | for (unsigned int i = 0; i < path_length; i++) | 747 | for (unsigned int i = 0; i < path_length; i++) |
748 | { | ||
749 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
750 | "CADET_CONNECTION_CREATE has peer %s at offset %u\n", | ||
751 | GNUNET_i2s (&pids[i]), | ||
752 | i); | ||
753 | if (GNUNET_SYSERR == GNUNET_CONTAINER_multipeermap_put ( | ||
754 | map, | ||
755 | &pids[i], | ||
756 | NULL, | ||
757 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) | ||
745 | { | 758 | { |
746 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 759 | /* bogus request */ |
747 | "CADET_CONNECTION_CREATE has peer %s at offset %u\n", | 760 | GNUNET_CONTAINER_multipeermap_destroy (map); |
748 | GNUNET_i2s(&pids[i]), | 761 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
749 | i); | 762 | "Dropping CADET_CONNECTION_CREATE with cyclic path\n"); |
750 | if (GNUNET_SYSERR == GNUNET_CONTAINER_multipeermap_put( | 763 | GNUNET_break_op (0); |
751 | map, | 764 | return; |
752 | &pids[i], | ||
753 | NULL, | ||
754 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) | ||
755 | { | ||
756 | /* bogus request */ | ||
757 | GNUNET_CONTAINER_multipeermap_destroy(map); | ||
758 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
759 | "Dropping CADET_CONNECTION_CREATE with cyclic path\n"); | ||
760 | GNUNET_break_op(0); | ||
761 | return; | ||
762 | } | ||
763 | } | 765 | } |
764 | GNUNET_CONTAINER_multipeermap_destroy(map); | 766 | } |
767 | GNUNET_CONTAINER_multipeermap_destroy (map); | ||
765 | } | 768 | } |
766 | /* Initiator is at offset 0, find us */ | 769 | /* Initiator is at offset 0, find us */ |
767 | for (off = 1; off < path_length; off++) | 770 | for (off = 1; off < path_length; off++) |
768 | if (0 == GNUNET_memcmp(&my_full_id, &pids[off])) | 771 | if (0 == GNUNET_memcmp (&my_full_id, &pids[off])) |
769 | break; | 772 | break; |
770 | if (off == path_length) | 773 | if (off == path_length) |
771 | { | 774 | { |
772 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 775 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
773 | "Dropping CADET_CONNECTION_CREATE without us in the path\n"); | 776 | "Dropping CADET_CONNECTION_CREATE without us in the path\n"); |
774 | GNUNET_break_op(0); | 777 | GNUNET_break_op (0); |
775 | return; | 778 | return; |
776 | } | 779 | } |
777 | /* Check previous hop */ | 780 | /* Check previous hop */ |
778 | if (sender != GCP_get(&pids[off - 1], GNUNET_NO)) | 781 | if (sender != GCP_get (&pids[off - 1], GNUNET_NO)) |
779 | { | 782 | { |
780 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 783 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
781 | "Dropping CADET_CONNECTION_CREATE without sender at previous hop in the path\n"); | 784 | "Dropping CADET_CONNECTION_CREATE without sender at previous hop in the path\n"); |
782 | GNUNET_break_op(0); | 785 | GNUNET_break_op (0); |
783 | return; | 786 | return; |
784 | } | 787 | } |
785 | if (NULL != (route = get_route(&msg->cid))) | 788 | if (NULL != (route = get_route (&msg->cid))) |
786 | { | 789 | { |
787 | /* Duplicate CREATE, pass it on, previous one might have been lost! */ | 790 | /* Duplicate CREATE, pass it on, previous one might have been lost! */ |
788 | 791 | ||
789 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 792 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
790 | "Passing on duplicate CADET_CONNECTION_CREATE message on connection %s\n", | 793 | "Passing on duplicate CADET_CONNECTION_CREATE message on connection %s\n", |
791 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | 794 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); |
792 | route_message(sender, | 795 | route_message (sender, |
793 | &msg->cid, | 796 | &msg->cid, |
794 | &msg->header, | 797 | &msg->header, |
795 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | | 798 | GNUNET_MQ_PRIO_CRITICAL_CONTROL |
796 | GNUNET_MQ_PREF_LOW_LATENCY); | 799 | | GNUNET_MQ_PREF_LOW_LATENCY); |
797 | return; | 800 | return; |
798 | } | 801 | } |
799 | if (off == path_length - 1) | 802 | if (off == path_length - 1) |
803 | { | ||
804 | /* We are the destination, create connection */ | ||
805 | struct CadetConnection *cc; | ||
806 | struct CadetPeerPath *path; | ||
807 | struct CadetPeer *origin; | ||
808 | |||
809 | cc = GCC_lookup (&msg->cid); | ||
810 | if (NULL != cc) | ||
800 | { | 811 | { |
801 | /* We are the destination, create connection */ | 812 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
802 | struct CadetConnection *cc; | 813 | "Received duplicate CADET_CONNECTION_CREATE message on connection %s\n", |
803 | struct CadetPeerPath *path; | 814 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); |
804 | struct CadetPeer *origin; | 815 | GCC_handle_duplicate_create (cc); |
805 | |||
806 | cc = GCC_lookup(&msg->cid); | ||
807 | if (NULL != cc) | ||
808 | { | ||
809 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
810 | "Received duplicate CADET_CONNECTION_CREATE message on connection %s\n", | ||
811 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | ||
812 | GCC_handle_duplicate_create(cc); | ||
813 | return; | ||
814 | } | ||
815 | |||
816 | origin = GCP_get(&pids[0], GNUNET_YES); | ||
817 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
818 | "I am destination for CADET_CONNECTION_CREATE message from %s for connection %s, building inverse path\n", | ||
819 | GCP_2s(origin), | ||
820 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | ||
821 | path = GCPP_get_path_from_route(path_length - 1, pids); | ||
822 | if (GNUNET_OK != | ||
823 | GCT_add_inbound_connection(GCP_get_tunnel(origin, GNUNET_YES), | ||
824 | &msg->cid, | ||
825 | path)) | ||
826 | { | ||
827 | /* Send back BROKEN: duplicate connection on the same path, | ||
828 | we will use the other one. */ | ||
829 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
830 | "Received CADET_CONNECTION_CREATE from %s for %s, but %s already has a connection. Sending BROKEN\n", | ||
831 | GCP_2s(sender), | ||
832 | GNUNET_sh2s(&msg->cid.connection_of_tunnel), | ||
833 | GCPP_2s(path)); | ||
834 | send_broken_without_mqm(sender, &msg->cid, NULL); | ||
835 | return; | ||
836 | } | ||
837 | return; | ||
838 | } | ||
839 | /* We are merely a hop on the way, check if we can support the route */ | ||
840 | next = GCP_get(&pids[off + 1], GNUNET_NO); | ||
841 | if ((NULL == next) || (GNUNET_NO == GCP_has_core_connection(next))) | ||
842 | { | ||
843 | /* unworkable, send back BROKEN notification */ | ||
844 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
845 | "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is down. Sending BROKEN\n", | ||
846 | GCP_2s(sender), | ||
847 | GNUNET_sh2s(&msg->cid.connection_of_tunnel), | ||
848 | GNUNET_i2s(&pids[off + 1]), | ||
849 | off + 1); | ||
850 | send_broken_without_mqm(sender, &msg->cid, &pids[off + 1]); | ||
851 | return; | 816 | return; |
852 | } | 817 | } |
853 | if (max_routes <= GNUNET_CONTAINER_multishortmap_size(routes)) | 818 | |
819 | origin = GCP_get (&pids[0], GNUNET_YES); | ||
820 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
821 | "I am destination for CADET_CONNECTION_CREATE message from %s for connection %s, building inverse path\n", | ||
822 | GCP_2s (origin), | ||
823 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); | ||
824 | path = GCPP_get_path_from_route (path_length - 1, pids); | ||
825 | if (GNUNET_OK != | ||
826 | GCT_add_inbound_connection (GCP_get_tunnel (origin, GNUNET_YES), | ||
827 | &msg->cid, | ||
828 | path)) | ||
854 | { | 829 | { |
855 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 830 | /* Send back BROKEN: duplicate connection on the same path, |
856 | "Received CADET_CONNECTION_CREATE from %s for %s. We have reached our route limit. Sending BROKEN\n", | 831 | we will use the other one. */ |
857 | GCP_2s(sender), | 832 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
858 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | 833 | "Received CADET_CONNECTION_CREATE from %s for %s, but %s already has a connection. Sending BROKEN\n", |
859 | send_broken_without_mqm(sender, &msg->cid, &pids[off - 1]); | 834 | GCP_2s (sender), |
835 | GNUNET_sh2s (&msg->cid.connection_of_tunnel), | ||
836 | GCPP_2s (path)); | ||
837 | send_broken_without_mqm (sender, &msg->cid, NULL); | ||
860 | return; | 838 | return; |
861 | } | 839 | } |
840 | return; | ||
841 | } | ||
842 | /* We are merely a hop on the way, check if we can support the route */ | ||
843 | next = GCP_get (&pids[off + 1], GNUNET_NO); | ||
844 | if ((NULL == next) || (GNUNET_NO == GCP_has_core_connection (next))) | ||
845 | { | ||
846 | /* unworkable, send back BROKEN notification */ | ||
847 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
848 | "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is down. Sending BROKEN\n", | ||
849 | GCP_2s (sender), | ||
850 | GNUNET_sh2s (&msg->cid.connection_of_tunnel), | ||
851 | GNUNET_i2s (&pids[off + 1]), | ||
852 | off + 1); | ||
853 | send_broken_without_mqm (sender, &msg->cid, &pids[off + 1]); | ||
854 | return; | ||
855 | } | ||
856 | if (max_routes <= GNUNET_CONTAINER_multishortmap_size (routes)) | ||
857 | { | ||
858 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
859 | "Received CADET_CONNECTION_CREATE from %s for %s. We have reached our route limit. Sending BROKEN\n", | ||
860 | GCP_2s (sender), | ||
861 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); | ||
862 | send_broken_without_mqm (sender, &msg->cid, &pids[off - 1]); | ||
863 | return; | ||
864 | } | ||
862 | 865 | ||
863 | /* Workable route, create routing entry */ | 866 | /* Workable route, create routing entry */ |
864 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 867 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
865 | "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is up. Creating route\n", | 868 | "Received CADET_CONNECTION_CREATE from %s for %s. Next hop %s:%u is up. Creating route\n", |
866 | GCP_2s(sender), | 869 | GCP_2s (sender), |
867 | GNUNET_sh2s(&msg->cid.connection_of_tunnel), | 870 | GNUNET_sh2s (&msg->cid.connection_of_tunnel), |
868 | GNUNET_i2s(&pids[off + 1]), | 871 | GNUNET_i2s (&pids[off + 1]), |
869 | off + 1); | 872 | off + 1); |
870 | route = GNUNET_new(struct CadetRoute); | 873 | route = GNUNET_new (struct CadetRoute); |
871 | route->cid = msg->cid; | 874 | route->cid = msg->cid; |
872 | route->last_use = GNUNET_TIME_absolute_get(); | 875 | route->last_use = GNUNET_TIME_absolute_get (); |
873 | dir_init(&route->prev, route, sender); | 876 | dir_init (&route->prev, route, sender); |
874 | dir_init(&route->next, route, next); | 877 | dir_init (&route->next, route, next); |
875 | GNUNET_assert(GNUNET_OK == | 878 | GNUNET_assert (GNUNET_OK == |
876 | GNUNET_CONTAINER_multishortmap_put( | 879 | GNUNET_CONTAINER_multishortmap_put ( |
877 | routes, | 880 | routes, |
878 | &route->cid.connection_of_tunnel, | 881 | &route->cid.connection_of_tunnel, |
879 | route, | 882 | route, |
880 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 883 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
881 | GNUNET_STATISTICS_set(stats, | 884 | GNUNET_STATISTICS_set (stats, |
882 | "# routes", | 885 | "# routes", |
883 | GNUNET_CONTAINER_multishortmap_size(routes), | 886 | GNUNET_CONTAINER_multishortmap_size (routes), |
884 | GNUNET_NO); | 887 | GNUNET_NO); |
885 | route->hn = GNUNET_CONTAINER_heap_insert(route_heap, | 888 | route->hn = GNUNET_CONTAINER_heap_insert (route_heap, |
886 | route, | 889 | route, |
887 | route->last_use.abs_value_us); | 890 | route->last_use.abs_value_us); |
888 | if (NULL == timeout_task) | 891 | if (NULL == timeout_task) |
889 | timeout_task = | 892 | timeout_task = |
890 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(keepalive_period, | 893 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply ( |
891 | 3), | 894 | keepalive_period, |
892 | &timeout_cb, | 895 | 3), |
893 | NULL); | 896 | &timeout_cb, |
897 | NULL); | ||
894 | /* also pass CREATE message along to next hop */ | 898 | /* also pass CREATE message along to next hop */ |
895 | route_message(sender, | 899 | route_message (sender, |
896 | &msg->cid, | 900 | &msg->cid, |
897 | &msg->header, | 901 | &msg->header, |
898 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); | 902 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); |
899 | } | 903 | } |
900 | 904 | ||
901 | 905 | ||
@@ -906,7 +910,7 @@ handle_connection_create( | |||
906 | * @param msg Message itself. | 910 | * @param msg Message itself. |
907 | */ | 911 | */ |
908 | static void | 912 | static void |
909 | handle_connection_create_ack( | 913 | handle_connection_create_ack ( |
910 | void *cls, | 914 | void *cls, |
911 | const struct GNUNET_CADET_ConnectionCreateAckMessage *msg) | 915 | const struct GNUNET_CADET_ConnectionCreateAckMessage *msg) |
912 | { | 916 | { |
@@ -914,31 +918,31 @@ handle_connection_create_ack( | |||
914 | struct CadetConnection *cc; | 918 | struct CadetConnection *cc; |
915 | 919 | ||
916 | /* First, check if ACK belongs to a connection that ends here. */ | 920 | /* First, check if ACK belongs to a connection that ends here. */ |
917 | cc = GCC_lookup(&msg->cid); | 921 | cc = GCC_lookup (&msg->cid); |
918 | if (NULL != cc) | 922 | if (NULL != cc) |
923 | { | ||
924 | /* verify ACK came from the right direction */ | ||
925 | unsigned int len; | ||
926 | struct CadetPeerPath *path = GCC_get_path (cc, &len); | ||
927 | |||
928 | if (peer != GCPP_get_peer_at_offset (path, 0)) | ||
919 | { | 929 | { |
920 | /* verify ACK came from the right direction */ | 930 | /* received ACK from unexpected direction, ignore! */ |
921 | unsigned int len; | 931 | GNUNET_break_op (0); |
922 | struct CadetPeerPath *path = GCC_get_path(cc, &len); | ||
923 | |||
924 | if (peer != GCPP_get_peer_at_offset(path, 0)) | ||
925 | { | ||
926 | /* received ACK from unexpected direction, ignore! */ | ||
927 | GNUNET_break_op(0); | ||
928 | return; | ||
929 | } | ||
930 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
931 | "Received CONNECTION_CREATE_ACK for connection %s.\n", | ||
932 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | ||
933 | GCC_handle_connection_create_ack(cc); | ||
934 | return; | 932 | return; |
935 | } | 933 | } |
934 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
935 | "Received CONNECTION_CREATE_ACK for connection %s.\n", | ||
936 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); | ||
937 | GCC_handle_connection_create_ack (cc); | ||
938 | return; | ||
939 | } | ||
936 | 940 | ||
937 | /* We're just an intermediary peer, route the message along its path */ | 941 | /* We're just an intermediary peer, route the message along its path */ |
938 | route_message(peer, | 942 | route_message (peer, |
939 | &msg->cid, | 943 | &msg->cid, |
940 | &msg->header, | 944 | &msg->header, |
941 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); | 945 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); |
942 | } | 946 | } |
943 | 947 | ||
944 | 948 | ||
@@ -950,7 +954,7 @@ handle_connection_create_ack( | |||
950 | * @deprecated duplicate logic with #handle_destroy(); dedup! | 954 | * @deprecated duplicate logic with #handle_destroy(); dedup! |
951 | */ | 955 | */ |
952 | static void | 956 | static void |
953 | handle_connection_broken( | 957 | handle_connection_broken ( |
954 | void *cls, | 958 | void *cls, |
955 | const struct GNUNET_CADET_ConnectionBrokenMessage *msg) | 959 | const struct GNUNET_CADET_ConnectionBrokenMessage *msg) |
956 | { | 960 | { |
@@ -959,36 +963,36 @@ handle_connection_broken( | |||
959 | struct CadetRoute *route; | 963 | struct CadetRoute *route; |
960 | 964 | ||
961 | /* First, check if message belongs to a connection that ends here. */ | 965 | /* First, check if message belongs to a connection that ends here. */ |
962 | cc = GCC_lookup(&msg->cid); | 966 | cc = GCC_lookup (&msg->cid); |
963 | if (NULL != cc) | 967 | if (NULL != cc) |
968 | { | ||
969 | /* verify message came from the right direction */ | ||
970 | unsigned int len; | ||
971 | struct CadetPeerPath *path = GCC_get_path (cc, &len); | ||
972 | |||
973 | if (peer != GCPP_get_peer_at_offset (path, 0)) | ||
964 | { | 974 | { |
965 | /* verify message came from the right direction */ | 975 | /* received message from unexpected direction, ignore! */ |
966 | unsigned int len; | 976 | GNUNET_break_op (0); |
967 | struct CadetPeerPath *path = GCC_get_path(cc, &len); | ||
968 | |||
969 | if (peer != GCPP_get_peer_at_offset(path, 0)) | ||
970 | { | ||
971 | /* received message from unexpected direction, ignore! */ | ||
972 | GNUNET_break_op(0); | ||
973 | return; | ||
974 | } | ||
975 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
976 | "Received CONNECTION_BROKEN for connection %s. Destroying it.\n", | ||
977 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | ||
978 | GCC_destroy_without_core(cc); | ||
979 | |||
980 | /* FIXME: also destroy the path up to the specified link! */ | ||
981 | return; | 977 | return; |
982 | } | 978 | } |
979 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
980 | "Received CONNECTION_BROKEN for connection %s. Destroying it.\n", | ||
981 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); | ||
982 | GCC_destroy_without_core (cc); | ||
983 | |||
984 | /* FIXME: also destroy the path up to the specified link! */ | ||
985 | return; | ||
986 | } | ||
983 | 987 | ||
984 | /* We're just an intermediary peer, route the message along its path */ | 988 | /* We're just an intermediary peer, route the message along its path */ |
985 | route_message(peer, | 989 | route_message (peer, |
986 | &msg->cid, | 990 | &msg->cid, |
987 | &msg->header, | 991 | &msg->header, |
988 | GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL); | 992 | GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL); |
989 | route = get_route(&msg->cid); | 993 | route = get_route (&msg->cid); |
990 | if (NULL != route) | 994 | if (NULL != route) |
991 | destroy_route(route); | 995 | destroy_route (route); |
992 | /* FIXME: also destroy paths we MAY have up to the specified link! */ | 996 | /* FIXME: also destroy paths we MAY have up to the specified link! */ |
993 | } | 997 | } |
994 | 998 | ||
@@ -1000,7 +1004,7 @@ handle_connection_broken( | |||
1000 | * @param msg Message itself. | 1004 | * @param msg Message itself. |
1001 | */ | 1005 | */ |
1002 | static void | 1006 | static void |
1003 | handle_connection_destroy( | 1007 | handle_connection_destroy ( |
1004 | void *cls, | 1008 | void *cls, |
1005 | const struct GNUNET_CADET_ConnectionDestroyMessage *msg) | 1009 | const struct GNUNET_CADET_ConnectionDestroyMessage *msg) |
1006 | { | 1010 | { |
@@ -1009,38 +1013,38 @@ handle_connection_destroy( | |||
1009 | struct CadetRoute *route; | 1013 | struct CadetRoute *route; |
1010 | 1014 | ||
1011 | /* First, check if message belongs to a connection that ends here. */ | 1015 | /* First, check if message belongs to a connection that ends here. */ |
1012 | cc = GCC_lookup(&msg->cid); | 1016 | cc = GCC_lookup (&msg->cid); |
1013 | if (NULL != cc) | 1017 | if (NULL != cc) |
1018 | { | ||
1019 | /* verify message came from the right direction */ | ||
1020 | unsigned int len; | ||
1021 | struct CadetPeerPath *path = GCC_get_path (cc, &len); | ||
1022 | |||
1023 | if (peer != GCPP_get_peer_at_offset (path, 0)) | ||
1014 | { | 1024 | { |
1015 | /* verify message came from the right direction */ | 1025 | /* received message from unexpected direction, ignore! */ |
1016 | unsigned int len; | 1026 | GNUNET_break_op (0); |
1017 | struct CadetPeerPath *path = GCC_get_path(cc, &len); | ||
1018 | |||
1019 | if (peer != GCPP_get_peer_at_offset(path, 0)) | ||
1020 | { | ||
1021 | /* received message from unexpected direction, ignore! */ | ||
1022 | GNUNET_break_op(0); | ||
1023 | return; | ||
1024 | } | ||
1025 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1026 | "Received CONNECTION_DESTROY for connection %s. Destroying connection.\n", | ||
1027 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | ||
1028 | |||
1029 | GCC_destroy_without_core(cc); | ||
1030 | return; | 1027 | return; |
1031 | } | 1028 | } |
1029 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1030 | "Received CONNECTION_DESTROY for connection %s. Destroying connection.\n", | ||
1031 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); | ||
1032 | |||
1033 | GCC_destroy_without_core (cc); | ||
1034 | return; | ||
1035 | } | ||
1032 | 1036 | ||
1033 | /* We're just an intermediary peer, route the message along its path */ | 1037 | /* We're just an intermediary peer, route the message along its path */ |
1034 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1038 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1035 | "Received CONNECTION_DESTROY for connection %s. Destroying route.\n", | 1039 | "Received CONNECTION_DESTROY for connection %s. Destroying route.\n", |
1036 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | 1040 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); |
1037 | route_message(peer, | 1041 | route_message (peer, |
1038 | &msg->cid, | 1042 | &msg->cid, |
1039 | &msg->header, | 1043 | &msg->header, |
1040 | GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL); | 1044 | GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL); |
1041 | route = get_route(&msg->cid); | 1045 | route = get_route (&msg->cid); |
1042 | if (NULL != route) | 1046 | if (NULL != route) |
1043 | destroy_route(route); | 1047 | destroy_route (route); |
1044 | } | 1048 | } |
1045 | 1049 | ||
1046 | 1050 | ||
@@ -1051,41 +1055,41 @@ handle_connection_destroy( | |||
1051 | * @param msg Message itself. | 1055 | * @param msg Message itself. |
1052 | */ | 1056 | */ |
1053 | static void | 1057 | static void |
1054 | handle_tunnel_kx(void *cls, | 1058 | handle_tunnel_kx (void *cls, |
1055 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg) | 1059 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg) |
1056 | { | 1060 | { |
1057 | struct CadetPeer *peer = cls; | 1061 | struct CadetPeer *peer = cls; |
1058 | struct CadetConnection *cc; | 1062 | struct CadetConnection *cc; |
1059 | 1063 | ||
1060 | /* First, check if message belongs to a connection that ends here. */ | 1064 | /* First, check if message belongs to a connection that ends here. */ |
1061 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1065 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1062 | "Routing KX with ephemeral %s on CID %s\n", | 1066 | "Routing KX with ephemeral %s on CID %s\n", |
1063 | GNUNET_e2s(&msg->ephemeral_key), | 1067 | GNUNET_e2s (&msg->ephemeral_key), |
1064 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | 1068 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); |
1065 | 1069 | ||
1066 | 1070 | ||
1067 | cc = GCC_lookup(&msg->cid); | 1071 | cc = GCC_lookup (&msg->cid); |
1068 | if (NULL != cc) | 1072 | if (NULL != cc) |
1073 | { | ||
1074 | /* verify message came from the right direction */ | ||
1075 | unsigned int len; | ||
1076 | struct CadetPeerPath *path = GCC_get_path (cc, &len); | ||
1077 | |||
1078 | if (peer != GCPP_get_peer_at_offset (path, 0)) | ||
1069 | { | 1079 | { |
1070 | /* verify message came from the right direction */ | 1080 | /* received message from unexpected direction, ignore! */ |
1071 | unsigned int len; | 1081 | GNUNET_break_op (0); |
1072 | struct CadetPeerPath *path = GCC_get_path(cc, &len); | ||
1073 | |||
1074 | if (peer != GCPP_get_peer_at_offset(path, 0)) | ||
1075 | { | ||
1076 | /* received message from unexpected direction, ignore! */ | ||
1077 | GNUNET_break_op(0); | ||
1078 | return; | ||
1079 | } | ||
1080 | GCC_handle_kx(cc, msg); | ||
1081 | return; | 1082 | return; |
1082 | } | 1083 | } |
1084 | GCC_handle_kx (cc, msg); | ||
1085 | return; | ||
1086 | } | ||
1083 | 1087 | ||
1084 | /* We're just an intermediary peer, route the message along its path */ | 1088 | /* We're just an intermediary peer, route the message along its path */ |
1085 | route_message(peer, | 1089 | route_message (peer, |
1086 | &msg->cid, | 1090 | &msg->cid, |
1087 | &msg->header, | 1091 | &msg->header, |
1088 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); | 1092 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); |
1089 | } | 1093 | } |
1090 | 1094 | ||
1091 | 1095 | ||
@@ -1096,7 +1100,7 @@ handle_tunnel_kx(void *cls, | |||
1096 | * @param msg Message itself. | 1100 | * @param msg Message itself. |
1097 | */ | 1101 | */ |
1098 | static void | 1102 | static void |
1099 | handle_tunnel_kx_auth( | 1103 | handle_tunnel_kx_auth ( |
1100 | void *cls, | 1104 | void *cls, |
1101 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg) | 1105 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg) |
1102 | { | 1106 | { |
@@ -1104,28 +1108,28 @@ handle_tunnel_kx_auth( | |||
1104 | struct CadetConnection *cc; | 1108 | struct CadetConnection *cc; |
1105 | 1109 | ||
1106 | /* First, check if message belongs to a connection that ends here. */ | 1110 | /* First, check if message belongs to a connection that ends here. */ |
1107 | cc = GCC_lookup(&msg->kx.cid); | 1111 | cc = GCC_lookup (&msg->kx.cid); |
1108 | if (NULL != cc) | 1112 | if (NULL != cc) |
1113 | { | ||
1114 | /* verify message came from the right direction */ | ||
1115 | unsigned int len; | ||
1116 | struct CadetPeerPath *path = GCC_get_path (cc, &len); | ||
1117 | |||
1118 | if (peer != GCPP_get_peer_at_offset (path, 0)) | ||
1109 | { | 1119 | { |
1110 | /* verify message came from the right direction */ | 1120 | /* received message from unexpected direction, ignore! */ |
1111 | unsigned int len; | 1121 | GNUNET_break_op (0); |
1112 | struct CadetPeerPath *path = GCC_get_path(cc, &len); | ||
1113 | |||
1114 | if (peer != GCPP_get_peer_at_offset(path, 0)) | ||
1115 | { | ||
1116 | /* received message from unexpected direction, ignore! */ | ||
1117 | GNUNET_break_op(0); | ||
1118 | return; | ||
1119 | } | ||
1120 | GCC_handle_kx_auth(cc, msg); | ||
1121 | return; | 1122 | return; |
1122 | } | 1123 | } |
1124 | GCC_handle_kx_auth (cc, msg); | ||
1125 | return; | ||
1126 | } | ||
1123 | 1127 | ||
1124 | /* We're just an intermediary peer, route the message along its path */ | 1128 | /* We're just an intermediary peer, route the message along its path */ |
1125 | route_message(peer, | 1129 | route_message (peer, |
1126 | &msg->kx.cid, | 1130 | &msg->kx.cid, |
1127 | &msg->kx.header, | 1131 | &msg->kx.header, |
1128 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); | 1132 | GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY); |
1129 | } | 1133 | } |
1130 | 1134 | ||
1131 | 1135 | ||
@@ -1138,8 +1142,8 @@ handle_tunnel_kx_auth( | |||
1138 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. | 1142 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. |
1139 | */ | 1143 | */ |
1140 | static int | 1144 | static int |
1141 | check_tunnel_encrypted(void *cls, | 1145 | check_tunnel_encrypted (void *cls, |
1142 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) | 1146 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) |
1143 | { | 1147 | { |
1144 | return GNUNET_YES; | 1148 | return GNUNET_YES; |
1145 | } | 1149 | } |
@@ -1152,31 +1156,31 @@ check_tunnel_encrypted(void *cls, | |||
1152 | * @param msg Message itself. | 1156 | * @param msg Message itself. |
1153 | */ | 1157 | */ |
1154 | static void | 1158 | static void |
1155 | handle_tunnel_encrypted(void *cls, | 1159 | handle_tunnel_encrypted (void *cls, |
1156 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) | 1160 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) |
1157 | { | 1161 | { |
1158 | struct CadetPeer *peer = cls; | 1162 | struct CadetPeer *peer = cls; |
1159 | struct CadetConnection *cc; | 1163 | struct CadetConnection *cc; |
1160 | 1164 | ||
1161 | /* First, check if message belongs to a connection that ends here. */ | 1165 | /* First, check if message belongs to a connection that ends here. */ |
1162 | cc = GCC_lookup(&msg->cid); | 1166 | cc = GCC_lookup (&msg->cid); |
1163 | if (NULL != cc) | 1167 | if (NULL != cc) |
1168 | { | ||
1169 | /* verify message came from the right direction */ | ||
1170 | unsigned int len; | ||
1171 | struct CadetPeerPath *path = GCC_get_path (cc, &len); | ||
1172 | |||
1173 | if (peer != GCPP_get_peer_at_offset (path, 0)) | ||
1164 | { | 1174 | { |
1165 | /* verify message came from the right direction */ | 1175 | /* received message from unexpected direction, ignore! */ |
1166 | unsigned int len; | 1176 | GNUNET_break_op (0); |
1167 | struct CadetPeerPath *path = GCC_get_path(cc, &len); | ||
1168 | |||
1169 | if (peer != GCPP_get_peer_at_offset(path, 0)) | ||
1170 | { | ||
1171 | /* received message from unexpected direction, ignore! */ | ||
1172 | GNUNET_break_op(0); | ||
1173 | return; | ||
1174 | } | ||
1175 | GCC_handle_encrypted(cc, msg); | ||
1176 | return; | 1177 | return; |
1177 | } | 1178 | } |
1179 | GCC_handle_encrypted (cc, msg); | ||
1180 | return; | ||
1181 | } | ||
1178 | /* We're just an intermediary peer, route the message along its path */ | 1182 | /* We're just an intermediary peer, route the message along its path */ |
1179 | route_message(peer, &msg->cid, &msg->header, GNUNET_MQ_PRIO_BEST_EFFORT); | 1183 | route_message (peer, &msg->cid, &msg->header, GNUNET_MQ_PRIO_BEST_EFFORT); |
1180 | } | 1184 | } |
1181 | 1185 | ||
1182 | 1186 | ||
@@ -1193,14 +1197,14 @@ handle_tunnel_encrypted(void *cls, | |||
1193 | * @param my_identity ID of this peer, NULL if we failed | 1197 | * @param my_identity ID of this peer, NULL if we failed |
1194 | */ | 1198 | */ |
1195 | static void | 1199 | static void |
1196 | core_init_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity) | 1200 | core_init_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity) |
1197 | { | 1201 | { |
1198 | if (NULL == my_identity) | 1202 | if (NULL == my_identity) |
1199 | { | 1203 | { |
1200 | GNUNET_break(0); | 1204 | GNUNET_break (0); |
1201 | return; | 1205 | return; |
1202 | } | 1206 | } |
1203 | GNUNET_break(0 == GNUNET_memcmp(my_identity, &my_full_id)); | 1207 | GNUNET_break (0 == GNUNET_memcmp (my_identity, &my_full_id)); |
1204 | } | 1208 | } |
1205 | 1209 | ||
1206 | 1210 | ||
@@ -1211,17 +1215,17 @@ core_init_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity) | |||
1211 | * @param peer peer identity this notification is about | 1215 | * @param peer peer identity this notification is about |
1212 | */ | 1216 | */ |
1213 | static void * | 1217 | static void * |
1214 | core_connect_cb(void *cls, | 1218 | core_connect_cb (void *cls, |
1215 | const struct GNUNET_PeerIdentity *peer, | 1219 | const struct GNUNET_PeerIdentity *peer, |
1216 | struct GNUNET_MQ_Handle *mq) | 1220 | struct GNUNET_MQ_Handle *mq) |
1217 | { | 1221 | { |
1218 | struct CadetPeer *cp; | 1222 | struct CadetPeer *cp; |
1219 | 1223 | ||
1220 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1224 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1221 | "CORE connection to peer %s was established.\n", | 1225 | "CORE connection to peer %s was established.\n", |
1222 | GNUNET_i2s(peer)); | 1226 | GNUNET_i2s (peer)); |
1223 | cp = GCP_get(peer, GNUNET_YES); | 1227 | cp = GCP_get (peer, GNUNET_YES); |
1224 | GCP_set_mq(cp, mq); | 1228 | GCP_set_mq (cp, mq); |
1225 | return cp; | 1229 | return cp; |
1226 | } | 1230 | } |
1227 | 1231 | ||
@@ -1233,16 +1237,16 @@ core_connect_cb(void *cls, | |||
1233 | * @param peer peer identity this notification is about | 1237 | * @param peer peer identity this notification is about |
1234 | */ | 1238 | */ |
1235 | static void | 1239 | static void |
1236 | core_disconnect_cb(void *cls, | 1240 | core_disconnect_cb (void *cls, |
1237 | const struct GNUNET_PeerIdentity *peer, | 1241 | const struct GNUNET_PeerIdentity *peer, |
1238 | void *peer_cls) | 1242 | void *peer_cls) |
1239 | { | 1243 | { |
1240 | struct CadetPeer *cp = peer_cls; | 1244 | struct CadetPeer *cp = peer_cls; |
1241 | 1245 | ||
1242 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1246 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1243 | "CORE connection to peer %s went down.\n", | 1247 | "CORE connection to peer %s went down.\n", |
1244 | GNUNET_i2s(peer)); | 1248 | GNUNET_i2s (peer)); |
1245 | GCP_set_mq(cp, NULL); | 1249 | GCP_set_mq (cp, NULL); |
1246 | } | 1250 | } |
1247 | 1251 | ||
1248 | 1252 | ||
@@ -1252,57 +1256,57 @@ core_disconnect_cb(void *cls, | |||
1252 | * @param c Configuration. | 1256 | * @param c Configuration. |
1253 | */ | 1257 | */ |
1254 | void | 1258 | void |
1255 | GCO_init(const struct GNUNET_CONFIGURATION_Handle *c) | 1259 | GCO_init (const struct GNUNET_CONFIGURATION_Handle *c) |
1256 | { | 1260 | { |
1257 | struct GNUNET_MQ_MessageHandler handlers[] = | 1261 | struct GNUNET_MQ_MessageHandler handlers[] = |
1258 | { GNUNET_MQ_hd_var_size(connection_create, | 1262 | { GNUNET_MQ_hd_var_size (connection_create, |
1259 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, | 1263 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, |
1260 | struct GNUNET_CADET_ConnectionCreateMessage, | 1264 | struct GNUNET_CADET_ConnectionCreateMessage, |
1261 | NULL), | 1265 | NULL), |
1262 | GNUNET_MQ_hd_fixed_size(connection_create_ack, | 1266 | GNUNET_MQ_hd_fixed_size (connection_create_ack, |
1263 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK, | 1267 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK, |
1264 | struct GNUNET_CADET_ConnectionCreateAckMessage, | 1268 | struct GNUNET_CADET_ConnectionCreateAckMessage, |
1265 | NULL), | 1269 | NULL), |
1266 | GNUNET_MQ_hd_fixed_size(connection_broken, | 1270 | GNUNET_MQ_hd_fixed_size (connection_broken, |
1267 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, | 1271 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, |
1268 | struct GNUNET_CADET_ConnectionBrokenMessage, | 1272 | struct GNUNET_CADET_ConnectionBrokenMessage, |
1269 | NULL), | 1273 | NULL), |
1270 | GNUNET_MQ_hd_fixed_size(connection_destroy, | 1274 | GNUNET_MQ_hd_fixed_size (connection_destroy, |
1271 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, | 1275 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, |
1272 | struct GNUNET_CADET_ConnectionDestroyMessage, | 1276 | struct GNUNET_CADET_ConnectionDestroyMessage, |
1273 | NULL), | 1277 | NULL), |
1274 | GNUNET_MQ_hd_fixed_size(tunnel_kx, | 1278 | GNUNET_MQ_hd_fixed_size (tunnel_kx, |
1275 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX, | 1279 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX, |
1276 | struct GNUNET_CADET_TunnelKeyExchangeMessage, | 1280 | struct GNUNET_CADET_TunnelKeyExchangeMessage, |
1277 | NULL), | 1281 | NULL), |
1278 | GNUNET_MQ_hd_fixed_size(tunnel_kx_auth, | 1282 | GNUNET_MQ_hd_fixed_size (tunnel_kx_auth, |
1279 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH, | 1283 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH, |
1280 | struct GNUNET_CADET_TunnelKeyExchangeAuthMessage, | 1284 | struct GNUNET_CADET_TunnelKeyExchangeAuthMessage, |
1281 | NULL), | 1285 | NULL), |
1282 | GNUNET_MQ_hd_var_size(tunnel_encrypted, | 1286 | GNUNET_MQ_hd_var_size (tunnel_encrypted, |
1283 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED, | 1287 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED, |
1284 | struct GNUNET_CADET_TunnelEncryptedMessage, | 1288 | struct GNUNET_CADET_TunnelEncryptedMessage, |
1285 | NULL), | 1289 | NULL), |
1286 | GNUNET_MQ_handler_end() }; | 1290 | GNUNET_MQ_handler_end () }; |
1287 | 1291 | ||
1288 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(c, | 1292 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c, |
1289 | "CADET", | 1293 | "CADET", |
1290 | "MAX_ROUTES", | 1294 | "MAX_ROUTES", |
1291 | &max_routes)) | 1295 | &max_routes)) |
1292 | max_routes = 5000; | 1296 | max_routes = 5000; |
1293 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(c, | 1297 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c, |
1294 | "CADET", | 1298 | "CADET", |
1295 | "MAX_MSGS_QUEUE", | 1299 | "MAX_MSGS_QUEUE", |
1296 | &max_buffers)) | 1300 | &max_buffers)) |
1297 | max_buffers = 10000; | 1301 | max_buffers = 10000; |
1298 | routes = GNUNET_CONTAINER_multishortmap_create(1024, GNUNET_NO); | 1302 | routes = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_NO); |
1299 | route_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); | 1303 | route_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); |
1300 | core = GNUNET_CORE_connect(c, | 1304 | core = GNUNET_CORE_connect (c, |
1301 | NULL, | 1305 | NULL, |
1302 | &core_init_cb, | 1306 | &core_init_cb, |
1303 | &core_connect_cb, | 1307 | &core_connect_cb, |
1304 | &core_disconnect_cb, | 1308 | &core_disconnect_cb, |
1305 | handlers); | 1309 | handlers); |
1306 | } | 1310 | } |
1307 | 1311 | ||
1308 | 1312 | ||
@@ -1310,23 +1314,23 @@ GCO_init(const struct GNUNET_CONFIGURATION_Handle *c) | |||
1310 | * Shut down the CORE subsystem. | 1314 | * Shut down the CORE subsystem. |
1311 | */ | 1315 | */ |
1312 | void | 1316 | void |
1313 | GCO_shutdown() | 1317 | GCO_shutdown () |
1314 | { | 1318 | { |
1315 | if (NULL != core) | 1319 | if (NULL != core) |
1316 | { | 1320 | { |
1317 | GNUNET_CORE_disconnect(core); | 1321 | GNUNET_CORE_disconnect (core); |
1318 | core = NULL; | 1322 | core = NULL; |
1319 | } | 1323 | } |
1320 | GNUNET_assert(0 == GNUNET_CONTAINER_multishortmap_size(routes)); | 1324 | GNUNET_assert (0 == GNUNET_CONTAINER_multishortmap_size (routes)); |
1321 | GNUNET_CONTAINER_multishortmap_destroy(routes); | 1325 | GNUNET_CONTAINER_multishortmap_destroy (routes); |
1322 | routes = NULL; | 1326 | routes = NULL; |
1323 | GNUNET_CONTAINER_heap_destroy(route_heap); | 1327 | GNUNET_CONTAINER_heap_destroy (route_heap); |
1324 | route_heap = NULL; | 1328 | route_heap = NULL; |
1325 | if (NULL != timeout_task) | 1329 | if (NULL != timeout_task) |
1326 | { | 1330 | { |
1327 | GNUNET_SCHEDULER_cancel(timeout_task); | 1331 | GNUNET_SCHEDULER_cancel (timeout_task); |
1328 | timeout_task = NULL; | 1332 | timeout_task = NULL; |
1329 | } | 1333 | } |
1330 | } | 1334 | } |
1331 | 1335 | ||
1332 | /* end of gnunet-cadet-service_core.c */ | 1336 | /* end of gnunet-cadet-service_core.c */ |
diff --git a/src/cadet/gnunet-service-cadet_core.h b/src/cadet/gnunet-service-cadet_core.h index b049dc2af..3438dcb31 100644 --- a/src/cadet/gnunet-service-cadet_core.h +++ b/src/cadet/gnunet-service-cadet_core.h | |||
@@ -47,14 +47,14 @@ extern "C" | |||
47 | * @param c Configuration. | 47 | * @param c Configuration. |
48 | */ | 48 | */ |
49 | void | 49 | void |
50 | GCO_init(const struct GNUNET_CONFIGURATION_Handle *c); | 50 | GCO_init (const struct GNUNET_CONFIGURATION_Handle *c); |
51 | 51 | ||
52 | 52 | ||
53 | /** | 53 | /** |
54 | * Shut down the CORE subsystem. | 54 | * Shut down the CORE subsystem. |
55 | */ | 55 | */ |
56 | void | 56 | void |
57 | GCO_shutdown(void); | 57 | GCO_shutdown (void); |
58 | 58 | ||
59 | 59 | ||
60 | #if 0 /* keep Emacsens' auto-indent happy */ | 60 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/cadet/gnunet-service-cadet_dht.c b/src/cadet/gnunet-service-cadet_dht.c index c208c7f29..3bb86cae4 100644 --- a/src/cadet/gnunet-service-cadet_dht.c +++ b/src/cadet/gnunet-service-cadet_dht.c | |||
@@ -40,23 +40,26 @@ | |||
40 | * notifications when our HELLO is ready, so this is just the maximum | 40 | * notifications when our HELLO is ready, so this is just the maximum |
41 | * we wait for the first notification. | 41 | * we wait for the first notification. |
42 | */ | 42 | */ |
43 | #define STARTUP_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500) | 43 | #define STARTUP_DELAY GNUNET_TIME_relative_multiply ( \ |
44 | GNUNET_TIME_UNIT_MILLISECONDS, 500) | ||
44 | 45 | ||
45 | /** | 46 | /** |
46 | * How long do we wait after we get an updated HELLO before publishing? | 47 | * How long do we wait after we get an updated HELLO before publishing? |
47 | * Allows for the HELLO to be updated again quickly, for example in | 48 | * Allows for the HELLO to be updated again quickly, for example in |
48 | * case multiple addresses changed and we got a partial update. | 49 | * case multiple addresses changed and we got a partial update. |
49 | */ | 50 | */ |
50 | #define CHANGE_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100) | 51 | #define CHANGE_DELAY GNUNET_TIME_relative_multiply ( \ |
52 | GNUNET_TIME_UNIT_MILLISECONDS, 100) | ||
51 | 53 | ||
52 | 54 | ||
53 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-dht", __VA_ARGS__) | 55 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-dht", __VA_ARGS__) |
54 | 56 | ||
55 | 57 | ||
56 | /** | 58 | /** |
57 | * Handle for DHT searches. | 59 | * Handle for DHT searches. |
58 | */ | 60 | */ |
59 | struct GCD_search_handle { | 61 | struct GCD_search_handle |
62 | { | ||
60 | /** | 63 | /** |
61 | * DHT_GET handle. | 64 | * DHT_GET handle. |
62 | */ | 65 | */ |
@@ -107,35 +110,35 @@ static struct GNUNET_TIME_Relative announce_delay; | |||
107 | * @param data pointer to the result data | 110 | * @param data pointer to the result data |
108 | */ | 111 | */ |
109 | static void | 112 | static void |
110 | dht_get_id_handler(void *cls, struct GNUNET_TIME_Absolute exp, | 113 | dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp, |
111 | const struct GNUNET_HashCode *key, | 114 | const struct GNUNET_HashCode *key, |
112 | const struct GNUNET_PeerIdentity *get_path, | 115 | const struct GNUNET_PeerIdentity *get_path, |
113 | unsigned int get_path_length, | 116 | unsigned int get_path_length, |
114 | const struct GNUNET_PeerIdentity *put_path, | 117 | const struct GNUNET_PeerIdentity *put_path, |
115 | unsigned int put_path_length, | 118 | unsigned int put_path_length, |
116 | enum GNUNET_BLOCK_Type type, | 119 | enum GNUNET_BLOCK_Type type, |
117 | size_t size, | 120 | size_t size, |
118 | const void *data) | 121 | const void *data) |
119 | { | 122 | { |
120 | const struct GNUNET_HELLO_Message *hello = data; | 123 | const struct GNUNET_HELLO_Message *hello = data; |
121 | struct CadetPeer *peer; | 124 | struct CadetPeer *peer; |
122 | 125 | ||
123 | GCPP_try_path_from_dht(get_path, | 126 | GCPP_try_path_from_dht (get_path, |
124 | get_path_length, | 127 | get_path_length, |
125 | put_path, | 128 | put_path, |
126 | put_path_length); | 129 | put_path_length); |
127 | if ((size >= sizeof(struct GNUNET_HELLO_Message)) && | 130 | if ((size >= sizeof(struct GNUNET_HELLO_Message)) && |
128 | (ntohs(hello->header.size) == size) && | 131 | (ntohs (hello->header.size) == size) && |
129 | (size == GNUNET_HELLO_size(hello))) | 132 | (size == GNUNET_HELLO_size (hello))) |
130 | { | 133 | { |
131 | peer = GCP_get(&put_path[0], | 134 | peer = GCP_get (&put_path[0], |
132 | GNUNET_YES); | 135 | GNUNET_YES); |
133 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 136 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
134 | "Got HELLO for %s\n", | 137 | "Got HELLO for %s\n", |
135 | GCP_2s(peer)); | 138 | GCP_2s (peer)); |
136 | GCP_set_hello(peer, | 139 | GCP_set_hello (peer, |
137 | hello); | 140 | hello); |
138 | } | 141 | } |
139 | } | 142 | } |
140 | 143 | ||
141 | 144 | ||
@@ -145,7 +148,7 @@ dht_get_id_handler(void *cls, struct GNUNET_TIME_Absolute exp, | |||
145 | * @param cls closure | 148 | * @param cls closure |
146 | */ | 149 | */ |
147 | static void | 150 | static void |
148 | announce_id(void *cls) | 151 | announce_id (void *cls) |
149 | { | 152 | { |
150 | struct GNUNET_HashCode phash; | 153 | struct GNUNET_HashCode phash; |
151 | const struct GNUNET_HELLO_Message *hello; | 154 | const struct GNUNET_HELLO_Message *hello; |
@@ -153,58 +156,58 @@ announce_id(void *cls) | |||
153 | struct GNUNET_TIME_Absolute expiration; | 156 | struct GNUNET_TIME_Absolute expiration; |
154 | struct GNUNET_TIME_Relative next_put; | 157 | struct GNUNET_TIME_Relative next_put; |
155 | 158 | ||
156 | hello = GCH_get_mine(); | 159 | hello = GCH_get_mine (); |
157 | size = (NULL != hello) ? GNUNET_HELLO_size(hello) : 0; | 160 | size = (NULL != hello) ? GNUNET_HELLO_size (hello) : 0; |
158 | if (0 == size) | 161 | if (0 == size) |
159 | { | 162 | { |
160 | expiration = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), | 163 | expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), |
161 | announce_delay); | 164 | announce_delay); |
162 | announce_delay = GNUNET_TIME_STD_BACKOFF(announce_delay); | 165 | announce_delay = GNUNET_TIME_STD_BACKOFF (announce_delay); |
163 | } | 166 | } |
164 | else | 167 | else |
165 | { | 168 | { |
166 | expiration = GNUNET_HELLO_get_last_expiration(hello); | 169 | expiration = GNUNET_HELLO_get_last_expiration (hello); |
167 | announce_delay = GNUNET_TIME_UNIT_SECONDS; | 170 | announce_delay = GNUNET_TIME_UNIT_SECONDS; |
168 | } | 171 | } |
169 | 172 | ||
170 | /* Call again in id_announce_time, unless HELLO expires first, | 173 | /* Call again in id_announce_time, unless HELLO expires first, |
171 | * but wait at least 1s. */ | 174 | * but wait at least 1s. */ |
172 | next_put | 175 | next_put |
173 | = GNUNET_TIME_absolute_get_remaining(expiration); | 176 | = GNUNET_TIME_absolute_get_remaining (expiration); |
174 | next_put | 177 | next_put |
175 | = GNUNET_TIME_relative_min(next_put, | 178 | = GNUNET_TIME_relative_min (next_put, |
176 | id_announce_time); | 179 | id_announce_time); |
177 | next_put | 180 | next_put |
178 | = GNUNET_TIME_relative_max(next_put, | 181 | = GNUNET_TIME_relative_max (next_put, |
179 | GNUNET_TIME_UNIT_SECONDS); | 182 | GNUNET_TIME_UNIT_SECONDS); |
180 | announce_id_task | 183 | announce_id_task |
181 | = GNUNET_SCHEDULER_add_delayed(next_put, | 184 | = GNUNET_SCHEDULER_add_delayed (next_put, |
182 | &announce_id, | 185 | &announce_id, |
183 | cls); | 186 | cls); |
184 | GNUNET_STATISTICS_update(stats, | 187 | GNUNET_STATISTICS_update (stats, |
185 | "# DHT announce", | 188 | "# DHT announce", |
186 | 1, | 189 | 1, |
187 | GNUNET_NO); | 190 | GNUNET_NO); |
188 | memset(&phash, | 191 | memset (&phash, |
189 | 0, | 192 | 0, |
190 | sizeof(phash)); | 193 | sizeof(phash)); |
191 | GNUNET_memcpy(&phash, | 194 | GNUNET_memcpy (&phash, |
192 | &my_full_id, | 195 | &my_full_id, |
193 | sizeof(my_full_id)); | 196 | sizeof(my_full_id)); |
194 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 197 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
195 | "Announcing my HELLO (%u bytes) in the DHT\n", | 198 | "Announcing my HELLO (%u bytes) in the DHT\n", |
196 | size); | 199 | size); |
197 | GNUNET_DHT_put(dht_handle, /* DHT handle */ | 200 | GNUNET_DHT_put (dht_handle, /* DHT handle */ |
198 | &phash, /* Key to use */ | 201 | &phash, /* Key to use */ |
199 | dht_replication_level, /* Replication level */ | 202 | dht_replication_level, /* Replication level */ |
200 | GNUNET_DHT_RO_RECORD_ROUTE | 203 | GNUNET_DHT_RO_RECORD_ROUTE |
201 | | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, /* DHT options */ | 204 | | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, /* DHT options */ |
202 | GNUNET_BLOCK_TYPE_DHT_HELLO, /* Block type */ | 205 | GNUNET_BLOCK_TYPE_DHT_HELLO, /* Block type */ |
203 | size, /* Size of the data */ | 206 | size, /* Size of the data */ |
204 | (const char *)hello, /* Data itself */ | 207 | (const char *) hello, /* Data itself */ |
205 | expiration, /* Data expiration */ | 208 | expiration, /* Data expiration */ |
206 | NULL, /* Continuation */ | 209 | NULL, /* Continuation */ |
207 | NULL); /* Continuation closure */ | 210 | NULL); /* Continuation closure */ |
208 | } | 211 | } |
209 | 212 | ||
210 | 213 | ||
@@ -213,15 +216,15 @@ announce_id(void *cls) | |||
213 | * changes. Re-triggers the DHT PUT immediately. | 216 | * changes. Re-triggers the DHT PUT immediately. |
214 | */ | 217 | */ |
215 | void | 218 | void |
216 | GCD_hello_update() | 219 | GCD_hello_update () |
217 | { | 220 | { |
218 | if (NULL == announce_id_task) | 221 | if (NULL == announce_id_task) |
219 | return; /* too early */ | 222 | return; /* too early */ |
220 | GNUNET_SCHEDULER_cancel(announce_id_task); | 223 | GNUNET_SCHEDULER_cancel (announce_id_task); |
221 | announce_id_task | 224 | announce_id_task |
222 | = GNUNET_SCHEDULER_add_delayed(CHANGE_DELAY, | 225 | = GNUNET_SCHEDULER_add_delayed (CHANGE_DELAY, |
223 | &announce_id, | 226 | &announce_id, |
224 | NULL); | 227 | NULL); |
225 | } | 228 | } |
226 | 229 | ||
227 | 230 | ||
@@ -231,42 +234,42 @@ GCD_hello_update() | |||
231 | * @param c Configuration. | 234 | * @param c Configuration. |
232 | */ | 235 | */ |
233 | void | 236 | void |
234 | GCD_init(const struct GNUNET_CONFIGURATION_Handle *c) | 237 | GCD_init (const struct GNUNET_CONFIGURATION_Handle *c) |
235 | { | 238 | { |
236 | if (GNUNET_OK != | 239 | if (GNUNET_OK != |
237 | GNUNET_CONFIGURATION_get_value_number(c, | 240 | GNUNET_CONFIGURATION_get_value_number (c, |
238 | "CADET", | 241 | "CADET", |
239 | "DHT_REPLICATION_LEVEL", | 242 | "DHT_REPLICATION_LEVEL", |
240 | &dht_replication_level)) | 243 | &dht_replication_level)) |
241 | { | 244 | { |
242 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, | 245 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, |
243 | "CADET", | 246 | "CADET", |
244 | "DHT_REPLICATION_LEVEL", | 247 | "DHT_REPLICATION_LEVEL", |
245 | "USING DEFAULT"); | 248 | "USING DEFAULT"); |
246 | dht_replication_level = 3; | 249 | dht_replication_level = 3; |
247 | } | 250 | } |
248 | 251 | ||
249 | if (GNUNET_OK != | 252 | if (GNUNET_OK != |
250 | GNUNET_CONFIGURATION_get_value_time(c, | 253 | GNUNET_CONFIGURATION_get_value_time (c, |
251 | "CADET", | 254 | "CADET", |
252 | "ID_ANNOUNCE_TIME", | 255 | "ID_ANNOUNCE_TIME", |
253 | &id_announce_time)) | 256 | &id_announce_time)) |
254 | { | 257 | { |
255 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, | 258 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, |
256 | "CADET", | 259 | "CADET", |
257 | "ID_ANNOUNCE_TIME", | 260 | "ID_ANNOUNCE_TIME", |
258 | "MISSING"); | 261 | "MISSING"); |
259 | GNUNET_SCHEDULER_shutdown(); | 262 | GNUNET_SCHEDULER_shutdown (); |
260 | return; | 263 | return; |
261 | } | 264 | } |
262 | 265 | ||
263 | dht_handle = GNUNET_DHT_connect(c, | 266 | dht_handle = GNUNET_DHT_connect (c, |
264 | 64); | 267 | 64); |
265 | GNUNET_break(NULL != dht_handle); | 268 | GNUNET_break (NULL != dht_handle); |
266 | announce_delay = GNUNET_TIME_UNIT_SECONDS; | 269 | announce_delay = GNUNET_TIME_UNIT_SECONDS; |
267 | announce_id_task = GNUNET_SCHEDULER_add_delayed(STARTUP_DELAY, | 270 | announce_id_task = GNUNET_SCHEDULER_add_delayed (STARTUP_DELAY, |
268 | &announce_id, | 271 | &announce_id, |
269 | NULL); | 272 | NULL); |
270 | } | 273 | } |
271 | 274 | ||
272 | 275 | ||
@@ -274,18 +277,18 @@ GCD_init(const struct GNUNET_CONFIGURATION_Handle *c) | |||
274 | * Shut down the DHT subsystem. | 277 | * Shut down the DHT subsystem. |
275 | */ | 278 | */ |
276 | void | 279 | void |
277 | GCD_shutdown(void) | 280 | GCD_shutdown (void) |
278 | { | 281 | { |
279 | if (NULL != dht_handle) | 282 | if (NULL != dht_handle) |
280 | { | 283 | { |
281 | GNUNET_DHT_disconnect(dht_handle); | 284 | GNUNET_DHT_disconnect (dht_handle); |
282 | dht_handle = NULL; | 285 | dht_handle = NULL; |
283 | } | 286 | } |
284 | if (NULL != announce_id_task) | 287 | if (NULL != announce_id_task) |
285 | { | 288 | { |
286 | GNUNET_SCHEDULER_cancel(announce_id_task); | 289 | GNUNET_SCHEDULER_cancel (announce_id_task); |
287 | announce_id_task = NULL; | 290 | announce_id_task = NULL; |
288 | } | 291 | } |
289 | } | 292 | } |
290 | 293 | ||
291 | 294 | ||
@@ -296,37 +299,37 @@ GCD_shutdown(void) | |||
296 | * @return handle to abort search | 299 | * @return handle to abort search |
297 | */ | 300 | */ |
298 | struct GCD_search_handle * | 301 | struct GCD_search_handle * |
299 | GCD_search(const struct GNUNET_PeerIdentity *peer_id) | 302 | GCD_search (const struct GNUNET_PeerIdentity *peer_id) |
300 | { | 303 | { |
301 | struct GNUNET_HashCode phash; | 304 | struct GNUNET_HashCode phash; |
302 | struct GCD_search_handle *h; | 305 | struct GCD_search_handle *h; |
303 | 306 | ||
304 | GNUNET_STATISTICS_update(stats, | 307 | GNUNET_STATISTICS_update (stats, |
305 | "# DHT search", | 308 | "# DHT search", |
306 | 1, | 309 | 1, |
307 | GNUNET_NO); | 310 | GNUNET_NO); |
308 | memset(&phash, | 311 | memset (&phash, |
309 | 0, | 312 | 0, |
310 | sizeof(phash)); | 313 | sizeof(phash)); |
311 | GNUNET_memcpy(&phash, | 314 | GNUNET_memcpy (&phash, |
312 | peer_id, | 315 | peer_id, |
313 | sizeof(*peer_id)); | 316 | sizeof(*peer_id)); |
314 | 317 | ||
315 | h = GNUNET_new(struct GCD_search_handle); | 318 | h = GNUNET_new (struct GCD_search_handle); |
316 | h->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */ | 319 | h->dhtget = GNUNET_DHT_get_start (dht_handle, /* handle */ |
317 | GNUNET_BLOCK_TYPE_DHT_HELLO, /* type */ | 320 | GNUNET_BLOCK_TYPE_DHT_HELLO, /* type */ |
318 | &phash, /* key to search */ | 321 | &phash, /* key to search */ |
319 | dht_replication_level, /* replication level */ | 322 | dht_replication_level, /* replication level */ |
320 | GNUNET_DHT_RO_RECORD_ROUTE | | 323 | GNUNET_DHT_RO_RECORD_ROUTE |
321 | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, | 324 | | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, |
322 | NULL, /* xquery */ | 325 | NULL, /* xquery */ |
323 | 0, /* xquery bits */ | 326 | 0, /* xquery bits */ |
324 | &dht_get_id_handler, | 327 | &dht_get_id_handler, |
325 | h); | 328 | h); |
326 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 329 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
327 | "Starting DHT GET for peer %s (%p)\n", | 330 | "Starting DHT GET for peer %s (%p)\n", |
328 | GNUNET_i2s(peer_id), | 331 | GNUNET_i2s (peer_id), |
329 | h); | 332 | h); |
330 | return h; | 333 | return h; |
331 | } | 334 | } |
332 | 335 | ||
@@ -337,13 +340,13 @@ GCD_search(const struct GNUNET_PeerIdentity *peer_id) | |||
337 | * @param h handle to search to stop | 340 | * @param h handle to search to stop |
338 | */ | 341 | */ |
339 | void | 342 | void |
340 | GCD_search_stop(struct GCD_search_handle *h) | 343 | GCD_search_stop (struct GCD_search_handle *h) |
341 | { | 344 | { |
342 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 345 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
343 | "Stopping DHT GET %p\n", | 346 | "Stopping DHT GET %p\n", |
344 | h); | 347 | h); |
345 | GNUNET_DHT_get_stop(h->dhtget); | 348 | GNUNET_DHT_get_stop (h->dhtget); |
346 | GNUNET_free(h); | 349 | GNUNET_free (h); |
347 | } | 350 | } |
348 | 351 | ||
349 | /* end of gnunet-service-cadet_dht.c */ | 352 | /* end of gnunet-service-cadet_dht.c */ |
diff --git a/src/cadet/gnunet-service-cadet_dht.h b/src/cadet/gnunet-service-cadet_dht.h index 4cb6e9fff..bcc27f5d2 100644 --- a/src/cadet/gnunet-service-cadet_dht.h +++ b/src/cadet/gnunet-service-cadet_dht.h | |||
@@ -52,14 +52,14 @@ struct GCD_search_handle; | |||
52 | * @param c Configuration. | 52 | * @param c Configuration. |
53 | */ | 53 | */ |
54 | void | 54 | void |
55 | GCD_init(const struct GNUNET_CONFIGURATION_Handle *c); | 55 | GCD_init (const struct GNUNET_CONFIGURATION_Handle *c); |
56 | 56 | ||
57 | 57 | ||
58 | /** | 58 | /** |
59 | * Shut down the DHT subsystem. | 59 | * Shut down the DHT subsystem. |
60 | */ | 60 | */ |
61 | void | 61 | void |
62 | GCD_shutdown(void); | 62 | GCD_shutdown (void); |
63 | 63 | ||
64 | 64 | ||
65 | /** | 65 | /** |
@@ -67,7 +67,7 @@ GCD_shutdown(void); | |||
67 | * changes. Re-triggers the DHT PUT immediately. | 67 | * changes. Re-triggers the DHT PUT immediately. |
68 | */ | 68 | */ |
69 | void | 69 | void |
70 | GCD_hello_update(void); | 70 | GCD_hello_update (void); |
71 | 71 | ||
72 | /** | 72 | /** |
73 | * Search DHT for paths to @a peeR_id | 73 | * Search DHT for paths to @a peeR_id |
@@ -76,7 +76,7 @@ GCD_hello_update(void); | |||
76 | * @return handle to abort search | 76 | * @return handle to abort search |
77 | */ | 77 | */ |
78 | struct GCD_search_handle * | 78 | struct GCD_search_handle * |
79 | GCD_search(const struct GNUNET_PeerIdentity *peer_id); | 79 | GCD_search (const struct GNUNET_PeerIdentity *peer_id); |
80 | 80 | ||
81 | 81 | ||
82 | /** | 82 | /** |
@@ -85,7 +85,7 @@ GCD_search(const struct GNUNET_PeerIdentity *peer_id); | |||
85 | * @param h handle to search to stop | 85 | * @param h handle to search to stop |
86 | */ | 86 | */ |
87 | void | 87 | void |
88 | GCD_search_stop(struct GCD_search_handle *h); | 88 | GCD_search_stop (struct GCD_search_handle *h); |
89 | 89 | ||
90 | 90 | ||
91 | #if 0 /* keep Emacsens' auto-indent happy */ | 91 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/cadet/gnunet-service-cadet_hello.c b/src/cadet/gnunet-service-cadet_hello.c index 7d6d2b0ce..bbe947ad1 100644 --- a/src/cadet/gnunet-service-cadet_hello.c +++ b/src/cadet/gnunet-service-cadet_hello.c | |||
@@ -35,7 +35,7 @@ | |||
35 | #include "gnunet-service-cadet_hello.h" | 35 | #include "gnunet-service-cadet_hello.h" |
36 | #include "gnunet-service-cadet_peer.h" | 36 | #include "gnunet-service-cadet_peer.h" |
37 | 37 | ||
38 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-hll", __VA_ARGS__) | 38 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-hll", __VA_ARGS__) |
39 | 39 | ||
40 | /** | 40 | /** |
41 | * Hello message of local peer. | 41 | * Hello message of local peer. |
@@ -62,34 +62,35 @@ static struct GNUNET_PEERINFO_NotifyContext *nc; | |||
62 | * @param err_msg Error message. | 62 | * @param err_msg Error message. |
63 | */ | 63 | */ |
64 | static void | 64 | static void |
65 | got_hello(void *cls, | 65 | got_hello (void *cls, |
66 | const struct GNUNET_PeerIdentity *id, | 66 | const struct GNUNET_PeerIdentity *id, |
67 | const struct GNUNET_HELLO_Message *hello, | 67 | const struct GNUNET_HELLO_Message *hello, |
68 | const char *err_msg) | 68 | const char *err_msg) |
69 | { | 69 | { |
70 | struct CadetPeer *peer; | 70 | struct CadetPeer *peer; |
71 | 71 | ||
72 | if ((NULL == id) || | 72 | if ((NULL == id) || |
73 | (NULL == hello)) | 73 | (NULL == hello)) |
74 | return; | 74 | return; |
75 | if (0 == GNUNET_memcmp(id, | 75 | if (0 == GNUNET_memcmp (id, |
76 | &my_full_id)) | 76 | &my_full_id)) |
77 | { | 77 | { |
78 | GNUNET_free_non_null(mine); | 78 | GNUNET_free_non_null (mine); |
79 | mine = (struct GNUNET_HELLO_Message *)GNUNET_copy_message(&hello->header); | 79 | mine = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (&hello->header); |
80 | GCD_hello_update(); | 80 | GCD_hello_update (); |
81 | return; | 81 | return; |
82 | } | 82 | } |
83 | 83 | ||
84 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 84 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
85 | "Hello for %s (%d bytes), expires on %s\n", | 85 | "Hello for %s (%d bytes), expires on %s\n", |
86 | GNUNET_i2s(id), | 86 | GNUNET_i2s (id), |
87 | GNUNET_HELLO_size(hello), | 87 | GNUNET_HELLO_size (hello), |
88 | GNUNET_STRINGS_absolute_time_to_string(GNUNET_HELLO_get_last_expiration(hello))); | 88 | GNUNET_STRINGS_absolute_time_to_string ( |
89 | peer = GCP_get(id, | 89 | GNUNET_HELLO_get_last_expiration (hello))); |
90 | GNUNET_YES); | 90 | peer = GCP_get (id, |
91 | GCP_set_hello(peer, | 91 | GNUNET_YES); |
92 | hello); | 92 | GCP_set_hello (peer, |
93 | hello); | ||
93 | } | 94 | } |
94 | 95 | ||
95 | 96 | ||
@@ -99,14 +100,14 @@ got_hello(void *cls, | |||
99 | * @param c Configuration. | 100 | * @param c Configuration. |
100 | */ | 101 | */ |
101 | void | 102 | void |
102 | GCH_init(const struct GNUNET_CONFIGURATION_Handle *c) | 103 | GCH_init (const struct GNUNET_CONFIGURATION_Handle *c) |
103 | { | 104 | { |
104 | GNUNET_assert(NULL == nc); | 105 | GNUNET_assert (NULL == nc); |
105 | peerinfo = GNUNET_PEERINFO_connect(c); | 106 | peerinfo = GNUNET_PEERINFO_connect (c); |
106 | nc = GNUNET_PEERINFO_notify(c, | 107 | nc = GNUNET_PEERINFO_notify (c, |
107 | GNUNET_NO, | 108 | GNUNET_NO, |
108 | &got_hello, | 109 | &got_hello, |
109 | NULL); | 110 | NULL); |
110 | } | 111 | } |
111 | 112 | ||
112 | 113 | ||
@@ -114,23 +115,23 @@ GCH_init(const struct GNUNET_CONFIGURATION_Handle *c) | |||
114 | * Shut down the hello subsystem. | 115 | * Shut down the hello subsystem. |
115 | */ | 116 | */ |
116 | void | 117 | void |
117 | GCH_shutdown() | 118 | GCH_shutdown () |
118 | { | 119 | { |
119 | if (NULL != nc) | 120 | if (NULL != nc) |
120 | { | 121 | { |
121 | GNUNET_PEERINFO_notify_cancel(nc); | 122 | GNUNET_PEERINFO_notify_cancel (nc); |
122 | nc = NULL; | 123 | nc = NULL; |
123 | } | 124 | } |
124 | if (NULL != peerinfo) | 125 | if (NULL != peerinfo) |
125 | { | 126 | { |
126 | GNUNET_PEERINFO_disconnect(peerinfo); | 127 | GNUNET_PEERINFO_disconnect (peerinfo); |
127 | peerinfo = NULL; | 128 | peerinfo = NULL; |
128 | } | 129 | } |
129 | if (NULL != mine) | 130 | if (NULL != mine) |
130 | { | 131 | { |
131 | GNUNET_free(mine); | 132 | GNUNET_free (mine); |
132 | mine = NULL; | 133 | mine = NULL; |
133 | } | 134 | } |
134 | } | 135 | } |
135 | 136 | ||
136 | 137 | ||
@@ -140,7 +141,7 @@ GCH_shutdown() | |||
140 | * @return Own hello message. | 141 | * @return Own hello message. |
141 | */ | 142 | */ |
142 | const struct GNUNET_HELLO_Message * | 143 | const struct GNUNET_HELLO_Message * |
143 | GCH_get_mine(void) | 144 | GCH_get_mine (void) |
144 | { | 145 | { |
145 | return mine; | 146 | return mine; |
146 | } | 147 | } |
diff --git a/src/cadet/gnunet-service-cadet_hello.h b/src/cadet/gnunet-service-cadet_hello.h index 99b6c807d..2cb444b4a 100644 --- a/src/cadet/gnunet-service-cadet_hello.h +++ b/src/cadet/gnunet-service-cadet_hello.h | |||
@@ -49,14 +49,14 @@ extern "C" | |||
49 | * @param c Configuration. | 49 | * @param c Configuration. |
50 | */ | 50 | */ |
51 | void | 51 | void |
52 | GCH_init(const struct GNUNET_CONFIGURATION_Handle *c); | 52 | GCH_init (const struct GNUNET_CONFIGURATION_Handle *c); |
53 | 53 | ||
54 | 54 | ||
55 | /** | 55 | /** |
56 | * Shut down the hello subsystem. | 56 | * Shut down the hello subsystem. |
57 | */ | 57 | */ |
58 | void | 58 | void |
59 | GCH_shutdown(void); | 59 | GCH_shutdown (void); |
60 | 60 | ||
61 | 61 | ||
62 | /** | 62 | /** |
@@ -65,7 +65,7 @@ GCH_shutdown(void); | |||
65 | * @return Own hello message. | 65 | * @return Own hello message. |
66 | */ | 66 | */ |
67 | const struct GNUNET_HELLO_Message * | 67 | const struct GNUNET_HELLO_Message * |
68 | GCH_get_mine(void); | 68 | GCH_get_mine (void); |
69 | 69 | ||
70 | 70 | ||
71 | #if 0 /* keep Emacsens' auto-indent happy */ | 71 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/cadet/gnunet-service-cadet_paths.c b/src/cadet/gnunet-service-cadet_paths.c index 149ac659a..e4a8dc789 100644 --- a/src/cadet/gnunet-service-cadet_paths.c +++ b/src/cadet/gnunet-service-cadet_paths.c | |||
@@ -30,13 +30,14 @@ | |||
30 | #include "gnunet-service-cadet_paths.h" | 30 | #include "gnunet-service-cadet_paths.h" |
31 | 31 | ||
32 | 32 | ||
33 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-pat", __VA_ARGS__) | 33 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-pat", __VA_ARGS__) |
34 | 34 | ||
35 | 35 | ||
36 | /** | 36 | /** |
37 | * Information regarding a possible path to reach a peer. | 37 | * Information regarding a possible path to reach a peer. |
38 | */ | 38 | */ |
39 | struct CadetPeerPath { | 39 | struct CadetPeerPath |
40 | { | ||
40 | /** | 41 | /** |
41 | * Array of all the peers on the path. If @e hn is non-NULL, the | 42 | * Array of all the peers on the path. If @e hn is non-NULL, the |
42 | * last one is our owner. | 43 | * last one is our owner. |
@@ -68,18 +69,18 @@ struct CadetPeerPath { | |||
68 | * @param path path to calculate the score for | 69 | * @param path path to calculate the score for |
69 | */ | 70 | */ |
70 | static void | 71 | static void |
71 | recalculate_path_desirability(struct CadetPeerPath *path) | 72 | recalculate_path_desirability (struct CadetPeerPath *path) |
72 | { | 73 | { |
73 | double result = 0.0; | 74 | double result = 0.0; |
74 | 75 | ||
75 | for (unsigned int i = 0; i < path->entries_length; i++) | 76 | for (unsigned int i = 0; i < path->entries_length; i++) |
76 | { | 77 | { |
77 | struct CadetPeer *cp = path->entries[i]->peer; | 78 | struct CadetPeer *cp = path->entries[i]->peer; |
78 | 79 | ||
79 | result += GCP_get_desirability_of_path(cp, | 80 | result += GCP_get_desirability_of_path (cp, |
80 | i); | 81 | i); |
81 | } | 82 | } |
82 | path->desirability = (GNUNET_CONTAINER_HeapCostType)result; | 83 | path->desirability = (GNUNET_CONTAINER_HeapCostType) result; |
83 | } | 84 | } |
84 | 85 | ||
85 | 86 | ||
@@ -97,7 +98,7 @@ recalculate_path_desirability(struct CadetPeerPath *path) | |||
97 | * @return desirability of the path, larger is more desirable | 98 | * @return desirability of the path, larger is more desirable |
98 | */ | 99 | */ |
99 | GNUNET_CONTAINER_HeapCostType | 100 | GNUNET_CONTAINER_HeapCostType |
100 | GCPP_get_desirability(const struct CadetPeerPath *path) | 101 | GCPP_get_desirability (const struct CadetPeerPath *path) |
101 | { | 102 | { |
102 | return path->desirability; | 103 | return path->desirability; |
103 | } | 104 | } |
@@ -114,15 +115,15 @@ GCPP_get_desirability(const struct CadetPeerPath *path) | |||
114 | * otherwise connection from us to @a destination via @a path | 115 | * otherwise connection from us to @a destination via @a path |
115 | */ | 116 | */ |
116 | struct CadetConnection * | 117 | struct CadetConnection * |
117 | GCPP_get_connection(struct CadetPeerPath *path, | 118 | GCPP_get_connection (struct CadetPeerPath *path, |
118 | struct CadetPeer *destination, | 119 | struct CadetPeer *destination, |
119 | unsigned int off) | 120 | unsigned int off) |
120 | { | 121 | { |
121 | struct CadetPeerPathEntry *entry; | 122 | struct CadetPeerPathEntry *entry; |
122 | 123 | ||
123 | GNUNET_assert(off < path->entries_length); | 124 | GNUNET_assert (off < path->entries_length); |
124 | entry = path->entries[off]; | 125 | entry = path->entries[off]; |
125 | GNUNET_assert(entry->peer == destination); | 126 | GNUNET_assert (entry->peer == destination); |
126 | return entry->cc; | 127 | return entry->cc; |
127 | } | 128 | } |
128 | 129 | ||
@@ -136,21 +137,21 @@ GCPP_get_connection(struct CadetPeerPath *path, | |||
136 | * @param cc the connection to remember | 137 | * @param cc the connection to remember |
137 | */ | 138 | */ |
138 | void | 139 | void |
139 | GCPP_add_connection(struct CadetPeerPath *path, | 140 | GCPP_add_connection (struct CadetPeerPath *path, |
140 | unsigned int off, | 141 | unsigned int off, |
141 | struct CadetConnection *cc) | 142 | struct CadetConnection *cc) |
142 | { | 143 | { |
143 | struct CadetPeerPathEntry *entry; | 144 | struct CadetPeerPathEntry *entry; |
144 | 145 | ||
145 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 146 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
146 | "Adding %s to path %s at offset %u\n", | 147 | "Adding %s to path %s at offset %u\n", |
147 | GCC_2s(cc), | 148 | GCC_2s (cc), |
148 | GCPP_2s(path), | 149 | GCPP_2s (path), |
149 | off); | 150 | off); |
150 | GNUNET_assert(off < path->entries_length); | 151 | GNUNET_assert (off < path->entries_length); |
151 | entry = path->entries[off]; | 152 | entry = path->entries[off]; |
152 | GNUNET_assert(NULL == entry->cc); | 153 | GNUNET_assert (NULL == entry->cc); |
153 | GNUNET_assert(NULL != cc); | 154 | GNUNET_assert (NULL != cc); |
154 | entry->cc = cc; | 155 | entry->cc = cc; |
155 | } | 156 | } |
156 | 157 | ||
@@ -165,20 +166,20 @@ GCPP_add_connection(struct CadetPeerPath *path, | |||
165 | * @param cc the connection to forget | 166 | * @param cc the connection to forget |
166 | */ | 167 | */ |
167 | void | 168 | void |
168 | GCPP_del_connection(struct CadetPeerPath *path, | 169 | GCPP_del_connection (struct CadetPeerPath *path, |
169 | unsigned int off, | 170 | unsigned int off, |
170 | struct CadetConnection *cc) | 171 | struct CadetConnection *cc) |
171 | { | 172 | { |
172 | struct CadetPeerPathEntry *entry; | 173 | struct CadetPeerPathEntry *entry; |
173 | 174 | ||
174 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 175 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
175 | "Removing connection %s to path %s at offset %u\n", | 176 | "Removing connection %s to path %s at offset %u\n", |
176 | GCC_2s(cc), | 177 | GCC_2s (cc), |
177 | GCPP_2s(path), | 178 | GCPP_2s (path), |
178 | off); | 179 | off); |
179 | GNUNET_assert(off < path->entries_length); | 180 | GNUNET_assert (off < path->entries_length); |
180 | entry = path->entries[off]; | 181 | entry = path->entries[off]; |
181 | GNUNET_assert(cc == entry->cc); | 182 | GNUNET_assert (cc == entry->cc); |
182 | entry->cc = NULL; | 183 | entry->cc = NULL; |
183 | } | 184 | } |
184 | 185 | ||
@@ -193,42 +194,42 @@ GCPP_del_connection(struct CadetPeerPath *path, | |||
193 | * @param stop_at the path length at which to stop trying | 194 | * @param stop_at the path length at which to stop trying |
194 | */ | 195 | */ |
195 | static void | 196 | static void |
196 | attach_path(struct CadetPeerPath *path, unsigned int stop_at) | 197 | attach_path (struct CadetPeerPath *path, unsigned int stop_at) |
197 | { | 198 | { |
198 | GNUNET_assert(NULL == path->hn); | 199 | GNUNET_assert (NULL == path->hn); |
199 | 200 | ||
200 | /* Try to attach this path to a peer, working backwards from the end. */ | 201 | /* Try to attach this path to a peer, working backwards from the end. */ |
201 | while (path->entries_length > stop_at) | 202 | while (path->entries_length > stop_at) |
202 | { | 203 | { |
203 | unsigned int end = path->entries_length - 1; | 204 | unsigned int end = path->entries_length - 1; |
204 | struct CadetPeerPathEntry *entry = path->entries[end]; | 205 | struct CadetPeerPathEntry *entry = path->entries[end]; |
205 | int force = GNUNET_NO; | 206 | int force = GNUNET_NO; |
206 | 207 | ||
207 | recalculate_path_desirability(path); | 208 | recalculate_path_desirability (path); |
208 | /* If the entry already has a connection using it, force attach. */ | 209 | /* If the entry already has a connection using it, force attach. */ |
209 | if (NULL != entry->cc) | 210 | if (NULL != entry->cc) |
210 | force = GNUNET_YES; | 211 | force = GNUNET_YES; |
211 | path->hn = GCP_attach_path(entry->peer, | 212 | path->hn = GCP_attach_path (entry->peer, |
212 | path, | 213 | path, |
213 | end, | 214 | end, |
214 | force); | 215 | force); |
215 | if (NULL != path->hn) | 216 | if (NULL != path->hn) |
216 | break; | 217 | break; |
217 | 218 | ||
218 | /* Attach failed, trim this entry from the path. */ | 219 | /* Attach failed, trim this entry from the path. */ |
219 | GNUNET_assert(NULL == entry->cc); | 220 | GNUNET_assert (NULL == entry->cc); |
220 | GCP_path_entry_remove(entry->peer, | 221 | GCP_path_entry_remove (entry->peer, |
221 | entry, | 222 | entry, |
222 | end); | 223 | end); |
223 | GNUNET_free(entry); | 224 | GNUNET_free (entry); |
224 | path->entries[end] = NULL; | 225 | path->entries[end] = NULL; |
225 | path->entries_length--; | 226 | path->entries_length--; |
226 | } | 227 | } |
227 | 228 | ||
228 | /* Shrink array to actual path length. */ | 229 | /* Shrink array to actual path length. */ |
229 | GNUNET_array_grow(path->entries, | 230 | GNUNET_array_grow (path->entries, |
230 | path->entries_length, | 231 | path->entries_length, |
231 | path->entries_length); | 232 | path->entries_length); |
232 | } | 233 | } |
233 | 234 | ||
234 | 235 | ||
@@ -240,33 +241,33 @@ attach_path(struct CadetPeerPath *path, unsigned int stop_at) | |||
240 | * @param path the path that is being released | 241 | * @param path the path that is being released |
241 | */ | 242 | */ |
242 | void | 243 | void |
243 | GCPP_release(struct CadetPeerPath *path) | 244 | GCPP_release (struct CadetPeerPath *path) |
244 | { | 245 | { |
245 | struct CadetPeerPathEntry *entry; | 246 | struct CadetPeerPathEntry *entry; |
246 | 247 | ||
247 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 248 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
248 | "Owner releases path %s\n", | 249 | "Owner releases path %s\n", |
249 | GCPP_2s(path)); | 250 | GCPP_2s (path)); |
250 | path->hn = NULL; | 251 | path->hn = NULL; |
251 | entry = path->entries[path->entries_length - 1]; | 252 | entry = path->entries[path->entries_length - 1]; |
252 | GNUNET_assert(path == entry->path); | 253 | GNUNET_assert (path == entry->path); |
253 | GNUNET_assert(NULL == entry->cc); | 254 | GNUNET_assert (NULL == entry->cc); |
254 | /* cut 'off' end of path */ | 255 | /* cut 'off' end of path */ |
255 | GCP_path_entry_remove(entry->peer, | 256 | GCP_path_entry_remove (entry->peer, |
256 | entry, | 257 | entry, |
257 | path->entries_length - 1); | 258 | path->entries_length - 1); |
258 | GNUNET_free(entry); | 259 | GNUNET_free (entry); |
259 | path->entries[path->entries_length - 1] = NULL; | 260 | path->entries[path->entries_length - 1] = NULL; |
260 | path->entries_length--; | 261 | path->entries_length--; |
261 | /* see if new peer at the end likes this path any better */ | 262 | /* see if new peer at the end likes this path any better */ |
262 | attach_path(path, 0); | 263 | attach_path (path, 0); |
263 | if (NULL == path->hn) | 264 | if (NULL == path->hn) |
264 | { | 265 | { |
265 | /* nobody wants us, discard the path */ | 266 | /* nobody wants us, discard the path */ |
266 | GNUNET_assert(0 == path->entries_length); | 267 | GNUNET_assert (0 == path->entries_length); |
267 | GNUNET_assert(NULL == path->entries); | 268 | GNUNET_assert (NULL == path->entries); |
268 | GNUNET_free(path); | 269 | GNUNET_free (path); |
269 | } | 270 | } |
270 | } | 271 | } |
271 | 272 | ||
272 | 273 | ||
@@ -279,38 +280,39 @@ GCPP_release(struct CadetPeerPath *path) | |||
279 | * @param delta change in the score to apply | 280 | * @param delta change in the score to apply |
280 | */ | 281 | */ |
281 | void | 282 | void |
282 | GCPP_update_score(struct CadetPeerPath *path, | 283 | GCPP_update_score (struct CadetPeerPath *path, |
283 | unsigned int off, | 284 | unsigned int off, |
284 | int delta) | 285 | int delta) |
285 | { | 286 | { |
286 | struct CadetPeerPathEntry *entry; | 287 | struct CadetPeerPathEntry *entry; |
287 | 288 | ||
288 | GNUNET_assert(off < path->entries_length); | 289 | GNUNET_assert (off < path->entries_length); |
289 | entry = path->entries[off]; | 290 | entry = path->entries[off]; |
290 | 291 | ||
291 | /* Add delta, with checks for overflows */ | 292 | /* Add delta, with checks for overflows */ |
292 | if (delta >= 0) | 293 | if (delta >= 0) |
293 | { | 294 | { |
294 | if (delta + entry->score < entry->score) | 295 | if (delta + entry->score < entry->score) |
295 | entry->score = INT_MAX; | 296 | entry->score = INT_MAX; |
296 | else | 297 | else |
297 | entry->score += delta; | 298 | entry->score += delta; |
298 | } | 299 | } |
299 | else | 300 | else |
300 | { | 301 | { |
301 | if (delta + entry->score > entry->score) | 302 | if (delta + entry->score > entry->score) |
302 | entry->score = INT_MIN; | 303 | entry->score = INT_MIN; |
303 | else | 304 | else |
304 | entry->score += delta; | 305 | entry->score += delta; |
305 | } | 306 | } |
306 | recalculate_path_desirability(path); | 307 | recalculate_path_desirability (path); |
307 | } | 308 | } |
308 | 309 | ||
309 | 310 | ||
310 | /** | 311 | /** |
311 | * Closure for #find_peer_at() and #check_match(). | 312 | * Closure for #find_peer_at() and #check_match(). |
312 | */ | 313 | */ |
313 | struct CheckMatchContext { | 314 | struct CheckMatchContext |
315 | { | ||
314 | /** | 316 | /** |
315 | * Set to a matching path, if any. | 317 | * Set to a matching path, if any. |
316 | */ | 318 | */ |
@@ -339,38 +341,38 @@ struct CheckMatchContext { | |||
339 | * @return #GNUNET_YES (continue to iterate), or if found #GNUNET_NO | 341 | * @return #GNUNET_YES (continue to iterate), or if found #GNUNET_NO |
340 | */ | 342 | */ |
341 | static int | 343 | static int |
342 | check_match(void *cls, | 344 | check_match (void *cls, |
343 | struct CadetPeerPath *path, | 345 | struct CadetPeerPath *path, |
344 | unsigned int off) | 346 | unsigned int off) |
345 | { | 347 | { |
346 | struct CheckMatchContext *cm_ctx = cls; | 348 | struct CheckMatchContext *cm_ctx = cls; |
347 | 349 | ||
348 | GNUNET_assert(path->entries_length > off); | 350 | GNUNET_assert (path->entries_length > off); |
349 | if ((path->entries_length != off + 1) && | 351 | if ((path->entries_length != off + 1) && |
350 | (off + 1 != cm_ctx->cpath_length)) | 352 | (off + 1 != cm_ctx->cpath_length)) |
351 | { | 353 | { |
352 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 354 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
353 | "check_match mismatch because path %s is too long (%u vs. %u vs. %u)\n", | 355 | "check_match mismatch because path %s is too long (%u vs. %u vs. %u)\n", |
354 | GCPP_2s(path), | 356 | GCPP_2s (path), |
355 | path->entries_length, | 357 | path->entries_length, |
356 | off + 1, | 358 | off + 1, |
357 | cm_ctx->cpath_length); | 359 | cm_ctx->cpath_length); |
358 | return GNUNET_YES; /* too long, goes somewhere else already, thus cannot be useful */ | 360 | return GNUNET_YES; /* too long, goes somewhere else already, thus cannot be useful */ |
359 | } | 361 | } |
360 | for (unsigned int i = 0; i < off; i++) | 362 | for (unsigned int i = 0; i < off; i++) |
361 | if (cm_ctx->cpath[i] != | 363 | if (cm_ctx->cpath[i] != |
362 | GCPP_get_peer_at_offset(path, | 364 | GCPP_get_peer_at_offset (path, |
363 | i)) | 365 | i)) |
364 | { | 366 | { |
365 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 367 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
366 | "check_match path %s mismatches at offset %u\n", | 368 | "check_match path %s mismatches at offset %u\n", |
367 | GCPP_2s(path), | 369 | GCPP_2s (path), |
368 | i); | 370 | i); |
369 | return GNUNET_YES; /* mismatch, ignore */ | 371 | return GNUNET_YES; /* mismatch, ignore */ |
370 | } | 372 | } |
371 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 373 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
372 | "check_match found match with path %s\n", | 374 | "check_match found match with path %s\n", |
373 | GCPP_2s(path)); | 375 | GCPP_2s (path)); |
374 | cm_ctx->match = path; | 376 | cm_ctx->match = path; |
375 | return GNUNET_NO; /* match, we are done! */ | 377 | return GNUNET_NO; /* match, we are done! */ |
376 | } | 378 | } |
@@ -387,70 +389,70 @@ check_match(void *cls, | |||
387 | * paths already | 389 | * paths already |
388 | */ | 390 | */ |
389 | static void | 391 | static void |
390 | extend_path(struct CadetPeerPath *path, | 392 | extend_path (struct CadetPeerPath *path, |
391 | struct CadetPeer **peers, | 393 | struct CadetPeer **peers, |
392 | unsigned int num_peers, | 394 | unsigned int num_peers, |
393 | int force) | 395 | int force) |
394 | { | 396 | { |
395 | unsigned int old_len = path->entries_length; | 397 | unsigned int old_len = path->entries_length; |
396 | int i; | 398 | int i; |
397 | 399 | ||
398 | /* Expand path */ | 400 | /* Expand path */ |
399 | GNUNET_array_grow(path->entries, | 401 | GNUNET_array_grow (path->entries, |
400 | path->entries_length, | 402 | path->entries_length, |
401 | old_len + num_peers); | 403 | old_len + num_peers); |
402 | for (i = num_peers - 1; i >= 0; i--) | 404 | for (i = num_peers - 1; i >= 0; i--) |
403 | { | 405 | { |
404 | struct CadetPeerPathEntry *entry = GNUNET_new(struct CadetPeerPathEntry); | 406 | struct CadetPeerPathEntry *entry = GNUNET_new (struct CadetPeerPathEntry); |
405 | 407 | ||
406 | path->entries[old_len + i] = entry; | 408 | path->entries[old_len + i] = entry; |
407 | entry->peer = peers[i]; | 409 | entry->peer = peers[i]; |
408 | entry->path = path; | 410 | entry->path = path; |
409 | } | 411 | } |
410 | for (i = num_peers - 1; i >= 0; i--) | 412 | for (i = num_peers - 1; i >= 0; i--) |
411 | { | 413 | { |
412 | struct CadetPeerPathEntry *entry = path->entries[old_len + i]; | 414 | struct CadetPeerPathEntry *entry = path->entries[old_len + i]; |
413 | 415 | ||
414 | GCP_path_entry_add(entry->peer, | 416 | GCP_path_entry_add (entry->peer, |
415 | entry, | 417 | entry, |
416 | old_len + i); | 418 | old_len + i); |
417 | } | 419 | } |
418 | 420 | ||
419 | /* If we extend an existing path, detach it from the | 421 | /* If we extend an existing path, detach it from the |
420 | old owner and re-attach to the new one */ | 422 | old owner and re-attach to the new one */ |
421 | GCP_detach_path(path->entries[old_len - 1]->peer, | 423 | GCP_detach_path (path->entries[old_len - 1]->peer, |
422 | path, | 424 | path, |
423 | path->hn); | 425 | path->hn); |
424 | path->hn = NULL; | 426 | path->hn = NULL; |
425 | path->entries_length = old_len + num_peers; | 427 | path->entries_length = old_len + num_peers; |
426 | if (GNUNET_YES == force) | 428 | if (GNUNET_YES == force) |
427 | { | 429 | { |
428 | int end = path->entries_length - 1; | 430 | int end = path->entries_length - 1; |
429 | 431 | ||
430 | path->hn = GCP_attach_path(path->entries[end]->peer, | 432 | path->hn = GCP_attach_path (path->entries[end]->peer, |
431 | path, | 433 | path, |
432 | end, | 434 | end, |
433 | GNUNET_YES); | 435 | GNUNET_YES); |
434 | } | 436 | } |
435 | else | 437 | else |
436 | { | 438 | { |
437 | attach_path(path, old_len); | 439 | attach_path (path, old_len); |
438 | } | 440 | } |
439 | if (NULL == path->hn) | 441 | if (NULL == path->hn) |
440 | { | 442 | { |
441 | /* none of the peers is interested in this path; | 443 | /* none of the peers is interested in this path; |
442 | re-attach. */ | 444 | re-attach. */ |
443 | GNUNET_assert(old_len == path->entries_length); | 445 | GNUNET_assert (old_len == path->entries_length); |
444 | path->hn = GCP_attach_path(path->entries[old_len - 1]->peer, | 446 | path->hn = GCP_attach_path (path->entries[old_len - 1]->peer, |
445 | path, | 447 | path, |
446 | old_len - 1, | 448 | old_len - 1, |
447 | GNUNET_YES); | 449 | GNUNET_YES); |
448 | GNUNET_assert(NULL != path->hn); | 450 | GNUNET_assert (NULL != path->hn); |
449 | return; | 451 | return; |
450 | } | 452 | } |
451 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 453 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
452 | "Extended path %s\n", | 454 | "Extended path %s\n", |
453 | GCPP_2s(path)); | 455 | GCPP_2s (path)); |
454 | } | 456 | } |
455 | 457 | ||
456 | 458 | ||
@@ -467,10 +469,10 @@ extend_path(struct CadetPeerPath *path, | |||
467 | * @return a path through the network | 469 | * @return a path through the network |
468 | */ | 470 | */ |
469 | void | 471 | void |
470 | GCPP_try_path_from_dht(const struct GNUNET_PeerIdentity *get_path, | 472 | GCPP_try_path_from_dht (const struct GNUNET_PeerIdentity *get_path, |
471 | unsigned int get_path_length, | 473 | unsigned int get_path_length, |
472 | const struct GNUNET_PeerIdentity *put_path, | 474 | const struct GNUNET_PeerIdentity *put_path, |
473 | unsigned int put_path_length) | 475 | unsigned int put_path_length) |
474 | { | 476 | { |
475 | struct CadetPeer *cpath[get_path_length + put_path_length]; | 477 | struct CadetPeer *cpath[get_path_length + put_path_length]; |
476 | struct CheckMatchContext cm_ctx; | 478 | struct CheckMatchContext cm_ctx; |
@@ -480,42 +482,42 @@ GCPP_try_path_from_dht(const struct GNUNET_PeerIdentity *get_path, | |||
480 | 482 | ||
481 | /* precompute 'cpath' so we can avoid doing the lookups lots of times */ | 483 | /* precompute 'cpath' so we can avoid doing the lookups lots of times */ |
482 | skip = 0; | 484 | skip = 0; |
483 | memset(cpath, | 485 | memset (cpath, |
484 | 0, | 486 | 0, |
485 | sizeof(cpath)); /* Just to trigger harder errors later. */ | 487 | sizeof(cpath)); /* Just to trigger harder errors later. */ |
486 | total_len = get_path_length + put_path_length; | 488 | total_len = get_path_length + put_path_length; |
487 | for (unsigned int off = 0; off < total_len; off++) | 489 | for (unsigned int off = 0; off < total_len; off++) |
490 | { | ||
491 | const struct GNUNET_PeerIdentity *pid; | ||
492 | |||
493 | pid = (off < get_path_length) | ||
494 | ? &get_path[get_path_length - off - 1] | ||
495 | : &put_path[get_path_length + put_path_length - off - 1]; | ||
496 | /* Check that I am not in the path */ | ||
497 | if (0 == GNUNET_memcmp (&my_full_id, | ||
498 | pid)) | ||
488 | { | 499 | { |
489 | const struct GNUNET_PeerIdentity *pid; | 500 | skip = off + 1; |
490 | 501 | continue; | |
491 | pid = (off < get_path_length) | ||
492 | ? &get_path[get_path_length - off - 1] | ||
493 | : &put_path[get_path_length + put_path_length - off - 1]; | ||
494 | /* Check that I am not in the path */ | ||
495 | if (0 == GNUNET_memcmp(&my_full_id, | ||
496 | pid)) | ||
497 | { | ||
498 | skip = off + 1; | ||
499 | continue; | ||
500 | } | ||
501 | cpath[off - skip] = GCP_get(pid, | ||
502 | GNUNET_YES); | ||
503 | /* Check that no peer is twice on the path */ | ||
504 | for (unsigned int i = 0; i < off - skip; i++) | ||
505 | { | ||
506 | if (cpath[i] == cpath[off - skip]) | ||
507 | { | ||
508 | skip = off - i; | ||
509 | break; | ||
510 | } | ||
511 | } | ||
512 | } | 502 | } |
513 | if (skip >= total_len) | 503 | cpath[off - skip] = GCP_get (pid, |
504 | GNUNET_YES); | ||
505 | /* Check that no peer is twice on the path */ | ||
506 | for (unsigned int i = 0; i < off - skip; i++) | ||
514 | { | 507 | { |
515 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 508 | if (cpath[i] == cpath[off - skip]) |
516 | "Path discovered from DHT is one big cycle?\n"); | 509 | { |
517 | return; | 510 | skip = off - i; |
511 | break; | ||
512 | } | ||
518 | } | 513 | } |
514 | } | ||
515 | if (skip >= total_len) | ||
516 | { | ||
517 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
518 | "Path discovered from DHT is one big cycle?\n"); | ||
519 | return; | ||
520 | } | ||
519 | total_len -= skip; | 521 | total_len -= skip; |
520 | 522 | ||
521 | /* First figure out if this path is a subset of an existing path, an | 523 | /* First figure out if this path is a subset of an existing path, an |
@@ -524,72 +526,72 @@ GCPP_try_path_from_dht(const struct GNUNET_PeerIdentity *get_path, | |||
524 | cm_ctx.cpath = cpath; | 526 | cm_ctx.cpath = cpath; |
525 | cm_ctx.match = NULL; | 527 | cm_ctx.match = NULL; |
526 | for (int i = total_len - 1; i >= 0; i--) | 528 | for (int i = total_len - 1; i >= 0; i--) |
529 | { | ||
530 | GCP_iterate_paths_at (cpath[i], | ||
531 | (unsigned int) i, | ||
532 | &check_match, | ||
533 | &cm_ctx); | ||
534 | if (NULL != cm_ctx.match) | ||
527 | { | 535 | { |
528 | GCP_iterate_paths_at(cpath[i], | 536 | if (i == total_len - 1) |
529 | (unsigned int)i, | 537 | { |
530 | &check_match, | 538 | /* Existing path includes this one, nothing to do! */ |
531 | &cm_ctx); | 539 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
532 | if (NULL != cm_ctx.match) | 540 | "Path discovered from DHT is already known\n"); |
533 | { | 541 | return; |
534 | if (i == total_len - 1) | 542 | } |
535 | { | 543 | if (cm_ctx.match->entries_length == i + 1) |
536 | /* Existing path includes this one, nothing to do! */ | 544 | { |
537 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 545 | /* Existing path ends in the middle of new path, extend it! */ |
538 | "Path discovered from DHT is already known\n"); | 546 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
539 | return; | 547 | "Trying to extend existing path %s by additional links discovered from DHT\n", |
540 | } | 548 | GCPP_2s (cm_ctx.match)); |
541 | if (cm_ctx.match->entries_length == i + 1) | 549 | extend_path (cm_ctx.match, |
542 | { | 550 | &cpath[i + 1], |
543 | /* Existing path ends in the middle of new path, extend it! */ | 551 | total_len - i - 1, |
544 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 552 | GNUNET_NO); |
545 | "Trying to extend existing path %s by additional links discovered from DHT\n", | 553 | return; |
546 | GCPP_2s(cm_ctx.match)); | 554 | } |
547 | extend_path(cm_ctx.match, | ||
548 | &cpath[i + 1], | ||
549 | total_len - i - 1, | ||
550 | GNUNET_NO); | ||
551 | return; | ||
552 | } | ||
553 | } | ||
554 | } | 555 | } |
556 | } | ||
555 | 557 | ||
556 | /* No match at all, create completely new path */ | 558 | /* No match at all, create completely new path */ |
557 | path = GNUNET_new(struct CadetPeerPath); | 559 | path = GNUNET_new (struct CadetPeerPath); |
558 | path->entries_length = total_len; | 560 | path->entries_length = total_len; |
559 | path->entries = GNUNET_new_array(path->entries_length, | 561 | path->entries = GNUNET_new_array (path->entries_length, |
560 | struct CadetPeerPathEntry *); | 562 | struct CadetPeerPathEntry *); |
561 | for (int i = path->entries_length - 1; i >= 0; i--) | 563 | for (int i = path->entries_length - 1; i >= 0; i--) |
562 | { | 564 | { |
563 | struct CadetPeerPathEntry *entry = GNUNET_new(struct CadetPeerPathEntry); | 565 | struct CadetPeerPathEntry *entry = GNUNET_new (struct CadetPeerPathEntry); |
564 | 566 | ||
565 | path->entries[i] = entry; | 567 | path->entries[i] = entry; |
566 | entry->peer = cpath[i]; | 568 | entry->peer = cpath[i]; |
567 | entry->path = path; | 569 | entry->path = path; |
568 | } | 570 | } |
569 | for (int i = path->entries_length - 1; i >= 0; i--) | 571 | for (int i = path->entries_length - 1; i >= 0; i--) |
570 | { | 572 | { |
571 | struct CadetPeerPathEntry *entry = path->entries[i]; | 573 | struct CadetPeerPathEntry *entry = path->entries[i]; |
572 | 574 | ||
573 | GCP_path_entry_add(entry->peer, | 575 | GCP_path_entry_add (entry->peer, |
574 | entry, | 576 | entry, |
575 | i); | 577 | i); |
576 | } | 578 | } |
577 | 579 | ||
578 | /* Finally, try to attach it */ | 580 | /* Finally, try to attach it */ |
579 | attach_path(path, 0); | 581 | attach_path (path, 0); |
580 | if (NULL == path->hn) | 582 | if (NULL == path->hn) |
581 | { | 583 | { |
582 | /* None of the peers on the path care about it. */ | 584 | /* None of the peers on the path care about it. */ |
583 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 585 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
584 | "Path discovered from DHT is not interesting to us\n"); | 586 | "Path discovered from DHT is not interesting to us\n"); |
585 | GNUNET_assert(0 == path->entries_length); | 587 | GNUNET_assert (0 == path->entries_length); |
586 | GNUNET_assert(NULL == path->entries); | 588 | GNUNET_assert (NULL == path->entries); |
587 | GNUNET_free(path); | 589 | GNUNET_free (path); |
588 | return; | 590 | return; |
589 | } | 591 | } |
590 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 592 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
591 | "Created new path %s based on information from DHT\n", | 593 | "Created new path %s based on information from DHT\n", |
592 | GCPP_2s(path)); | 594 | GCPP_2s (path)); |
593 | } | 595 | } |
594 | 596 | ||
595 | 597 | ||
@@ -601,8 +603,8 @@ GCPP_try_path_from_dht(const struct GNUNET_PeerIdentity *get_path, | |||
601 | * @return corresponding path object | 603 | * @return corresponding path object |
602 | */ | 604 | */ |
603 | struct CadetPeerPath * | 605 | struct CadetPeerPath * |
604 | GCPP_get_path_from_route(unsigned int path_length, | 606 | GCPP_get_path_from_route (unsigned int path_length, |
605 | const struct GNUNET_PeerIdentity *pids) | 607 | const struct GNUNET_PeerIdentity *pids) |
606 | { | 608 | { |
607 | struct CheckMatchContext cm_ctx; | 609 | struct CheckMatchContext cm_ctx; |
608 | struct CadetPeer *cpath[path_length]; | 610 | struct CadetPeer *cpath[path_length]; |
@@ -611,8 +613,8 @@ GCPP_get_path_from_route(unsigned int path_length, | |||
611 | /* precompute inverted 'cpath' so we can avoid doing the lookups and | 613 | /* precompute inverted 'cpath' so we can avoid doing the lookups and |
612 | have the correct order */ | 614 | have the correct order */ |
613 | for (unsigned int off = 0; off < path_length; off++) | 615 | for (unsigned int off = 0; off < path_length; off++) |
614 | cpath[off] = GCP_get(&pids[path_length - 1 - off], | 616 | cpath[off] = GCP_get (&pids[path_length - 1 - off], |
615 | GNUNET_YES); | 617 | GNUNET_YES); |
616 | 618 | ||
617 | /* First figure out if this path is a subset of an existing path, an | 619 | /* First figure out if this path is a subset of an existing path, an |
618 | extension of an existing path, or a new path. */ | 620 | extension of an existing path, or a new path. */ |
@@ -620,69 +622,69 @@ GCPP_get_path_from_route(unsigned int path_length, | |||
620 | cm_ctx.cpath_length = path_length; | 622 | cm_ctx.cpath_length = path_length; |
621 | cm_ctx.match = NULL; | 623 | cm_ctx.match = NULL; |
622 | for (int i = path_length - 1; i >= 0; i--) | 624 | for (int i = path_length - 1; i >= 0; i--) |
625 | { | ||
626 | GCP_iterate_paths_at (cpath[i], | ||
627 | (unsigned int) i, | ||
628 | &check_match, | ||
629 | &cm_ctx); | ||
630 | if (NULL != cm_ctx.match) | ||
623 | { | 631 | { |
624 | GCP_iterate_paths_at(cpath[i], | 632 | if (i == path_length - 1) |
625 | (unsigned int)i, | 633 | { |
626 | &check_match, | 634 | /* Existing path includes this one, return the match! */ |
627 | &cm_ctx); | 635 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
628 | if (NULL != cm_ctx.match) | 636 | "Returning existing path %s as inverse for incoming connection\n", |
629 | { | 637 | GCPP_2s (cm_ctx.match)); |
630 | if (i == path_length - 1) | 638 | return cm_ctx.match; |
631 | { | 639 | } |
632 | /* Existing path includes this one, return the match! */ | 640 | if (cm_ctx.match->entries_length == i + 1) |
633 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 641 | { |
634 | "Returning existing path %s as inverse for incoming connection\n", | 642 | /* Existing path ends in the middle of new path, extend it! */ |
635 | GCPP_2s(cm_ctx.match)); | 643 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
636 | return cm_ctx.match; | 644 | "Extending existing path %s to create inverse for incoming connection\n", |
637 | } | 645 | GCPP_2s (cm_ctx.match)); |
638 | if (cm_ctx.match->entries_length == i + 1) | 646 | extend_path (cm_ctx.match, |
639 | { | 647 | &cpath[i + 1], |
640 | /* Existing path ends in the middle of new path, extend it! */ | 648 | path_length - i - 1, |
641 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 649 | GNUNET_YES); |
642 | "Extending existing path %s to create inverse for incoming connection\n", | 650 | /* Check that extension was successful */ |
643 | GCPP_2s(cm_ctx.match)); | 651 | GNUNET_assert (cm_ctx.match->entries_length == path_length); |
644 | extend_path(cm_ctx.match, | 652 | return cm_ctx.match; |
645 | &cpath[i + 1], | 653 | } |
646 | path_length - i - 1, | 654 | /* Eh, we found a match but couldn't use it? Something is wrong. */ |
647 | GNUNET_YES); | 655 | GNUNET_break (0); |
648 | /* Check that extension was successful */ | ||
649 | GNUNET_assert(cm_ctx.match->entries_length == path_length); | ||
650 | return cm_ctx.match; | ||
651 | } | ||
652 | /* Eh, we found a match but couldn't use it? Something is wrong. */ | ||
653 | GNUNET_break(0); | ||
654 | } | ||
655 | } | 656 | } |
657 | } | ||
656 | 658 | ||
657 | /* No match at all, create completely new path */ | 659 | /* No match at all, create completely new path */ |
658 | path = GNUNET_new(struct CadetPeerPath); | 660 | path = GNUNET_new (struct CadetPeerPath); |
659 | path->entries_length = path_length; | 661 | path->entries_length = path_length; |
660 | path->entries = GNUNET_new_array(path->entries_length, | 662 | path->entries = GNUNET_new_array (path->entries_length, |
661 | struct CadetPeerPathEntry *); | 663 | struct CadetPeerPathEntry *); |
662 | for (int i = path_length - 1; i >= 0; i--) | 664 | for (int i = path_length - 1; i >= 0; i--) |
663 | { | 665 | { |
664 | struct CadetPeerPathEntry *entry = GNUNET_new(struct CadetPeerPathEntry); | 666 | struct CadetPeerPathEntry *entry = GNUNET_new (struct CadetPeerPathEntry); |
665 | 667 | ||
666 | path->entries[i] = entry; | 668 | path->entries[i] = entry; |
667 | entry->peer = cpath[i]; | 669 | entry->peer = cpath[i]; |
668 | entry->path = path; | 670 | entry->path = path; |
669 | } | 671 | } |
670 | for (int i = path_length - 1; i >= 0; i--) | 672 | for (int i = path_length - 1; i >= 0; i--) |
671 | { | 673 | { |
672 | struct CadetPeerPathEntry *entry = path->entries[i]; | 674 | struct CadetPeerPathEntry *entry = path->entries[i]; |
673 | 675 | ||
674 | GCP_path_entry_add(entry->peer, | 676 | GCP_path_entry_add (entry->peer, |
675 | entry, | 677 | entry, |
676 | i); | 678 | i); |
677 | } | 679 | } |
678 | recalculate_path_desirability(path); | 680 | recalculate_path_desirability (path); |
679 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 681 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
680 | "Created new path %s to create inverse for incoming connection\n", | 682 | "Created new path %s to create inverse for incoming connection\n", |
681 | GCPP_2s(path)); | 683 | GCPP_2s (path)); |
682 | path->hn = GCP_attach_path(cpath[path_length - 1], | 684 | path->hn = GCP_attach_path (cpath[path_length - 1], |
683 | path, | 685 | path, |
684 | path_length - 1, | 686 | path_length - 1, |
685 | GNUNET_YES); | 687 | GNUNET_YES); |
686 | return path; | 688 | return path; |
687 | } | 689 | } |
688 | 690 | ||
@@ -695,7 +697,7 @@ GCPP_get_path_from_route(unsigned int path_length, | |||
695 | * @return number of peers on the path | 697 | * @return number of peers on the path |
696 | */ | 698 | */ |
697 | unsigned int | 699 | unsigned int |
698 | GCPP_get_length(struct CadetPeerPath *path) | 700 | GCPP_get_length (struct CadetPeerPath *path) |
699 | { | 701 | { |
700 | return path->entries_length; | 702 | return path->entries_length; |
701 | } | 703 | } |
@@ -709,14 +711,14 @@ GCPP_get_length(struct CadetPeerPath *path) | |||
709 | * @return offset of @a cp on @a path, or UINT_MAX if not found | 711 | * @return offset of @a cp on @a path, or UINT_MAX if not found |
710 | */ | 712 | */ |
711 | unsigned int | 713 | unsigned int |
712 | GCPP_find_peer(struct CadetPeerPath *path, | 714 | GCPP_find_peer (struct CadetPeerPath *path, |
713 | struct CadetPeer *cp) | 715 | struct CadetPeer *cp) |
714 | { | 716 | { |
715 | for (unsigned int off = 0; | 717 | for (unsigned int off = 0; |
716 | off < path->entries_length; | 718 | off < path->entries_length; |
717 | off++) | 719 | off++) |
718 | if (cp == GCPP_get_peer_at_offset(path, | 720 | if (cp == GCPP_get_peer_at_offset (path, |
719 | off)) | 721 | off)) |
720 | return off; | 722 | return off; |
721 | return UINT_MAX; | 723 | return UINT_MAX; |
722 | } | 724 | } |
@@ -730,10 +732,10 @@ GCPP_find_peer(struct CadetPeerPath *path, | |||
730 | * @return the peer at offset @a off | 732 | * @return the peer at offset @a off |
731 | */ | 733 | */ |
732 | struct CadetPeer * | 734 | struct CadetPeer * |
733 | GCPP_get_peer_at_offset(struct CadetPeerPath *path, | 735 | GCPP_get_peer_at_offset (struct CadetPeerPath *path, |
734 | unsigned int off) | 736 | unsigned int off) |
735 | { | 737 | { |
736 | GNUNET_assert(off < path->entries_length); | 738 | GNUNET_assert (off < path->entries_length); |
737 | return path->entries[off]->peer; | 739 | return path->entries[off]->peer; |
738 | } | 740 | } |
739 | 741 | ||
@@ -745,7 +747,7 @@ GCPP_get_peer_at_offset(struct CadetPeerPath *path, | |||
745 | * @return string, to be freed by caller (unlike other *_2s APIs!) | 747 | * @return string, to be freed by caller (unlike other *_2s APIs!) |
746 | */ | 748 | */ |
747 | const char * | 749 | const char * |
748 | GCPP_2s(struct CadetPeerPath *path) | 750 | GCPP_2s (struct CadetPeerPath *path) |
749 | { | 751 | { |
750 | static char buf[2048]; | 752 | static char buf[2048]; |
751 | size_t off; | 753 | size_t off; |
@@ -755,27 +757,28 @@ GCPP_2s(struct CadetPeerPath *path) | |||
755 | for (unsigned int i = 0; | 757 | for (unsigned int i = 0; |
756 | i < path->entries_length; | 758 | i < path->entries_length; |
757 | i++) | 759 | i++) |
758 | { | 760 | { |
759 | if ((path->entries_length > max_plen) && | 761 | if ((path->entries_length > max_plen) && |
760 | (i == max_plen / 2)) | 762 | (i == max_plen / 2)) |
761 | off += GNUNET_snprintf(&buf[off], | 763 | off += GNUNET_snprintf (&buf[off], |
762 | sizeof(buf) - off, | 764 | sizeof(buf) - off, |
763 | "...-"); | 765 | "...-"); |
764 | if ((path->entries_length > max_plen) && | 766 | if ((path->entries_length > max_plen) && |
765 | (i > max_plen / 2) && | 767 | (i > max_plen / 2) && |
766 | (i < path->entries_length - max_plen / 2)) | 768 | (i < path->entries_length - max_plen / 2)) |
767 | continue; | 769 | continue; |
768 | off += GNUNET_snprintf(&buf[off], | 770 | off += GNUNET_snprintf (&buf[off], |
769 | sizeof(buf) - off, | 771 | sizeof(buf) - off, |
770 | "%s%s", | 772 | "%s%s", |
771 | GNUNET_i2s(GCP_get_id(GCPP_get_peer_at_offset(path, | 773 | GNUNET_i2s (GCP_get_id (GCPP_get_peer_at_offset ( |
772 | i))), | 774 | path, |
773 | (i == path->entries_length - 1) ? "" : "-"); | 775 | i))), |
774 | } | 776 | (i == path->entries_length - 1) ? "" : "-"); |
775 | GNUNET_snprintf(&buf[off], | 777 | } |
776 | sizeof(buf) - off, | 778 | GNUNET_snprintf (&buf[off], |
777 | "(%p)", | 779 | sizeof(buf) - off, |
778 | path); | 780 | "(%p)", |
781 | path); | ||
779 | return buf; | 782 | return buf; |
780 | } | 783 | } |
781 | 784 | ||
diff --git a/src/cadet/gnunet-service-cadet_paths.h b/src/cadet/gnunet-service-cadet_paths.h index 399f91516..125ea669a 100644 --- a/src/cadet/gnunet-service-cadet_paths.h +++ b/src/cadet/gnunet-service-cadet_paths.h | |||
@@ -1,4 +1,3 @@ | |||
1 | |||
2 | /* | 1 | /* |
3 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
4 | Copyright (C) 2001-2017 GNUnet e.V. | 3 | Copyright (C) 2001-2017 GNUnet e.V. |
@@ -43,10 +42,10 @@ | |||
43 | * @param put_path_length length of the @a put_path | 42 | * @param put_path_length length of the @a put_path |
44 | */ | 43 | */ |
45 | void | 44 | void |
46 | GCPP_try_path_from_dht(const struct GNUNET_PeerIdentity *get_path, | 45 | GCPP_try_path_from_dht (const struct GNUNET_PeerIdentity *get_path, |
47 | unsigned int get_path_length, | 46 | unsigned int get_path_length, |
48 | const struct GNUNET_PeerIdentity *put_path, | 47 | const struct GNUNET_PeerIdentity *put_path, |
49 | unsigned int put_path_length); | 48 | unsigned int put_path_length); |
50 | 49 | ||
51 | 50 | ||
52 | /** | 51 | /** |
@@ -57,8 +56,8 @@ GCPP_try_path_from_dht(const struct GNUNET_PeerIdentity *get_path, | |||
57 | * @return corresponding path object | 56 | * @return corresponding path object |
58 | */ | 57 | */ |
59 | struct CadetPeerPath * | 58 | struct CadetPeerPath * |
60 | GCPP_get_path_from_route(unsigned int path_length, | 59 | GCPP_get_path_from_route (unsigned int path_length, |
61 | const struct GNUNET_PeerIdentity *pids); | 60 | const struct GNUNET_PeerIdentity *pids); |
62 | 61 | ||
63 | 62 | ||
64 | /** | 63 | /** |
@@ -69,7 +68,7 @@ GCPP_get_path_from_route(unsigned int path_length, | |||
69 | * @return number of peers on the path | 68 | * @return number of peers on the path |
70 | */ | 69 | */ |
71 | unsigned int | 70 | unsigned int |
72 | GCPP_get_length(struct CadetPeerPath *path); | 71 | GCPP_get_length (struct CadetPeerPath *path); |
73 | 72 | ||
74 | 73 | ||
75 | /** | 74 | /** |
@@ -83,9 +82,9 @@ GCPP_get_length(struct CadetPeerPath *path); | |||
83 | * otherwise connection from us to @a destination via @a path | 82 | * otherwise connection from us to @a destination via @a path |
84 | */ | 83 | */ |
85 | struct CadetConnection * | 84 | struct CadetConnection * |
86 | GCPP_get_connection(struct CadetPeerPath *path, | 85 | GCPP_get_connection (struct CadetPeerPath *path, |
87 | struct CadetPeer *destination, | 86 | struct CadetPeer *destination, |
88 | unsigned int off); | 87 | unsigned int off); |
89 | 88 | ||
90 | 89 | ||
91 | /** | 90 | /** |
@@ -97,9 +96,9 @@ GCPP_get_connection(struct CadetPeerPath *path, | |||
97 | * @param cc the connection to remember | 96 | * @param cc the connection to remember |
98 | */ | 97 | */ |
99 | void | 98 | void |
100 | GCPP_add_connection(struct CadetPeerPath *path, | 99 | GCPP_add_connection (struct CadetPeerPath *path, |
101 | unsigned int off, | 100 | unsigned int off, |
102 | struct CadetConnection *cc); | 101 | struct CadetConnection *cc); |
103 | 102 | ||
104 | 103 | ||
105 | /** | 104 | /** |
@@ -111,9 +110,9 @@ GCPP_add_connection(struct CadetPeerPath *path, | |||
111 | * @param cc the connection to forget | 110 | * @param cc the connection to forget |
112 | */ | 111 | */ |
113 | void | 112 | void |
114 | GCPP_del_connection(struct CadetPeerPath *path, | 113 | GCPP_del_connection (struct CadetPeerPath *path, |
115 | unsigned int off, | 114 | unsigned int off, |
116 | struct CadetConnection *cc); | 115 | struct CadetConnection *cc); |
117 | 116 | ||
118 | 117 | ||
119 | /** | 118 | /** |
@@ -124,8 +123,8 @@ GCPP_del_connection(struct CadetPeerPath *path, | |||
124 | * @return offset of @a cp on @a path, or UINT_MAX if not found | 123 | * @return offset of @a cp on @a path, or UINT_MAX if not found |
125 | */ | 124 | */ |
126 | unsigned int | 125 | unsigned int |
127 | GCPP_find_peer(struct CadetPeerPath *path, | 126 | GCPP_find_peer (struct CadetPeerPath *path, |
128 | struct CadetPeer *cp); | 127 | struct CadetPeer *cp); |
129 | 128 | ||
130 | 129 | ||
131 | /** | 130 | /** |
@@ -142,7 +141,7 @@ GCPP_find_peer(struct CadetPeerPath *path, | |||
142 | * @return desirability of the path, larger is more desirable | 141 | * @return desirability of the path, larger is more desirable |
143 | */ | 142 | */ |
144 | GNUNET_CONTAINER_HeapCostType | 143 | GNUNET_CONTAINER_HeapCostType |
145 | GCPP_get_desirability(const struct CadetPeerPath *path); | 144 | GCPP_get_desirability (const struct CadetPeerPath *path); |
146 | 145 | ||
147 | 146 | ||
148 | /** | 147 | /** |
@@ -154,7 +153,7 @@ GCPP_get_desirability(const struct CadetPeerPath *path); | |||
154 | * @param path the path that is being released | 153 | * @param path the path that is being released |
155 | */ | 154 | */ |
156 | void | 155 | void |
157 | GCPP_release(struct CadetPeerPath *path); | 156 | GCPP_release (struct CadetPeerPath *path); |
158 | 157 | ||
159 | 158 | ||
160 | /** | 159 | /** |
@@ -165,8 +164,8 @@ GCPP_release(struct CadetPeerPath *path); | |||
165 | * @return peer at offset @a off | 164 | * @return peer at offset @a off |
166 | */ | 165 | */ |
167 | struct CadetPeer * | 166 | struct CadetPeer * |
168 | GCPP_get_peer_at_offset(struct CadetPeerPath *path, | 167 | GCPP_get_peer_at_offset (struct CadetPeerPath *path, |
169 | unsigned int off); | 168 | unsigned int off); |
170 | 169 | ||
171 | 170 | ||
172 | /** | 171 | /** |
@@ -176,7 +175,7 @@ GCPP_get_peer_at_offset(struct CadetPeerPath *path, | |||
176 | * @return string, statically allocated | 175 | * @return string, statically allocated |
177 | */ | 176 | */ |
178 | const char * | 177 | const char * |
179 | GCPP_2s(struct CadetPeerPath *p); | 178 | GCPP_2s (struct CadetPeerPath *p); |
180 | 179 | ||
181 | 180 | ||
182 | #endif | 181 | #endif |
diff --git a/src/cadet/gnunet-service-cadet_peer.c b/src/cadet/gnunet-service-cadet_peer.c index 23eb6b225..52a0c2bd3 100644 --- a/src/cadet/gnunet-service-cadet_peer.c +++ b/src/cadet/gnunet-service-cadet_peer.c | |||
@@ -46,18 +46,20 @@ | |||
46 | #include "gnunet-service-cadet_tunnels.h" | 46 | #include "gnunet-service-cadet_tunnels.h" |
47 | 47 | ||
48 | 48 | ||
49 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-per", __VA_ARGS__) | 49 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-per", __VA_ARGS__) |
50 | 50 | ||
51 | 51 | ||
52 | /** | 52 | /** |
53 | * How long do we wait until tearing down an idle peer? | 53 | * How long do we wait until tearing down an idle peer? |
54 | */ | 54 | */ |
55 | #define IDLE_PEER_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) | 55 | #define IDLE_PEER_TIMEOUT GNUNET_TIME_relative_multiply ( \ |
56 | GNUNET_TIME_UNIT_MINUTES, 5) | ||
56 | 57 | ||
57 | /** | 58 | /** |
58 | * How long do we keep paths around if we no longer care about the peer? | 59 | * How long do we keep paths around if we no longer care about the peer? |
59 | */ | 60 | */ |
60 | #define IDLE_PATH_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2) | 61 | #define IDLE_PATH_TIMEOUT GNUNET_TIME_relative_multiply ( \ |
62 | GNUNET_TIME_UNIT_MINUTES, 2) | ||
61 | 63 | ||
62 | /** | 64 | /** |
63 | * Queue size when we start dropping OOO messages. | 65 | * Queue size when we start dropping OOO messages. |
@@ -69,7 +71,8 @@ | |||
69 | * Data structure used to track whom we have to notify about changes | 71 | * Data structure used to track whom we have to notify about changes |
70 | * to our message queue. | 72 | * to our message queue. |
71 | */ | 73 | */ |
72 | struct GCP_MessageQueueManager { | 74 | struct GCP_MessageQueueManager |
75 | { | ||
73 | /** | 76 | /** |
74 | * Kept in a DLL. | 77 | * Kept in a DLL. |
75 | */ | 78 | */ |
@@ -105,7 +108,8 @@ struct GCP_MessageQueueManager { | |||
105 | /** | 108 | /** |
106 | * Struct containing all information regarding a given peer | 109 | * Struct containing all information regarding a given peer |
107 | */ | 110 | */ |
108 | struct CadetPeer { | 111 | struct CadetPeer |
112 | { | ||
109 | /** | 113 | /** |
110 | * ID of the peer | 114 | * ID of the peer |
111 | */ | 115 | */ |
@@ -235,23 +239,23 @@ struct CadetPeer { | |||
235 | * @return Static string for it's ID. | 239 | * @return Static string for it's ID. |
236 | */ | 240 | */ |
237 | const char * | 241 | const char * |
238 | GCP_2s(const struct CadetPeer *cp) | 242 | GCP_2s (const struct CadetPeer *cp) |
239 | { | 243 | { |
240 | static char buf[5]; | 244 | static char buf[5]; |
241 | char *ret; | 245 | char *ret; |
242 | 246 | ||
243 | if ((NULL == cp) || | 247 | if ((NULL == cp) || |
244 | (0 == GNUNET_is_zero(&cp->pid.public_key))) | 248 | (0 == GNUNET_is_zero (&cp->pid.public_key))) |
245 | return "NULL"; | 249 | return "NULL"; |
246 | 250 | ||
247 | ret = GNUNET_CRYPTO_eddsa_public_key_to_string(&cp->pid.public_key); | 251 | ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&cp->pid.public_key); |
248 | if (NULL == ret) | 252 | if (NULL == ret) |
249 | return "NULL"; | 253 | return "NULL"; |
250 | 254 | ||
251 | GNUNET_strlcpy(buf, | 255 | GNUNET_strlcpy (buf, |
252 | ret, | 256 | ret, |
253 | sizeof(buf)); | 257 | sizeof(buf)); |
254 | GNUNET_free(ret); | 258 | GNUNET_free (ret); |
255 | return buf; | 259 | return buf; |
256 | } | 260 | } |
257 | 261 | ||
@@ -272,8 +276,8 @@ GCP_2s(const struct CadetPeer *cp) | |||
272 | * positive scores mean path is more desirable | 276 | * positive scores mean path is more desirable |
273 | */ | 277 | */ |
274 | double | 278 | double |
275 | GCP_get_desirability_of_path(struct CadetPeer *cp, | 279 | GCP_get_desirability_of_path (struct CadetPeer *cp, |
276 | unsigned int off) | 280 | unsigned int off) |
277 | { | 281 | { |
278 | unsigned int num_alts = cp->num_paths; | 282 | unsigned int num_alts = cp->num_paths; |
279 | unsigned int off_sum; | 283 | unsigned int off_sum; |
@@ -281,8 +285,8 @@ GCP_get_desirability_of_path(struct CadetPeer *cp, | |||
281 | double path_delta; | 285 | double path_delta; |
282 | double weight_alts; | 286 | double weight_alts; |
283 | 287 | ||
284 | GNUNET_assert(num_alts >= 1); /* 'path' should be in there! */ | 288 | GNUNET_assert (num_alts >= 1); /* 'path' should be in there! */ |
285 | GNUNET_assert(0 != cp->path_dll_length); | 289 | GNUNET_assert (0 != cp->path_dll_length); |
286 | 290 | ||
287 | /* We maintain 'off_sum' in 'peer' and thereby | 291 | /* We maintain 'off_sum' in 'peer' and thereby |
288 | avoid the SLOW recalculation each time. Kept here | 292 | avoid the SLOW recalculation each time. Kept here |
@@ -294,7 +298,7 @@ GCP_get_desirability_of_path(struct CadetPeer *cp, | |||
294 | NULL != pe; | 298 | NULL != pe; |
295 | pe = pe->next) | 299 | pe = pe->next) |
296 | off_sum += j; | 300 | off_sum += j; |
297 | GNUNET_assert(off_sum == cp->off_sum); | 301 | GNUNET_assert (off_sum == cp->off_sum); |
298 | #else | 302 | #else |
299 | off_sum = cp->off_sum; | 303 | off_sum = cp->off_sum; |
300 | #endif | 304 | #endif |
@@ -323,63 +327,63 @@ GCP_get_desirability_of_path(struct CadetPeer *cp, | |||
323 | * @param cls peer to clean up | 327 | * @param cls peer to clean up |
324 | */ | 328 | */ |
325 | static void | 329 | static void |
326 | destroy_peer(void *cls) | 330 | destroy_peer (void *cls) |
327 | { | 331 | { |
328 | struct CadetPeer *cp = cls; | 332 | struct CadetPeer *cp = cls; |
329 | 333 | ||
330 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 334 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
331 | "Destroying state about peer %s\n", | 335 | "Destroying state about peer %s\n", |
332 | GCP_2s(cp)); | 336 | GCP_2s (cp)); |
333 | cp->destroy_task = NULL; | 337 | cp->destroy_task = NULL; |
334 | GNUNET_assert(NULL == cp->t); | 338 | GNUNET_assert (NULL == cp->t); |
335 | GNUNET_assert(NULL == cp->core_mq); | 339 | GNUNET_assert (NULL == cp->core_mq); |
336 | GNUNET_assert(0 == cp->num_paths); | 340 | GNUNET_assert (0 == cp->num_paths); |
337 | for (unsigned int i = 0; i < cp->path_dll_length; i++) | 341 | for (unsigned int i = 0; i < cp->path_dll_length; i++) |
338 | GNUNET_assert(NULL == cp->path_heads[i]); | 342 | GNUNET_assert (NULL == cp->path_heads[i]); |
339 | GNUNET_assert(0 == GNUNET_CONTAINER_multishortmap_size(cp->connections)); | 343 | GNUNET_assert (0 == GNUNET_CONTAINER_multishortmap_size (cp->connections)); |
340 | GNUNET_assert(GNUNET_YES == | 344 | GNUNET_assert (GNUNET_YES == |
341 | GNUNET_CONTAINER_multipeermap_remove(peers, | 345 | GNUNET_CONTAINER_multipeermap_remove (peers, |
342 | &cp->pid, | 346 | &cp->pid, |
343 | cp)); | 347 | cp)); |
344 | GNUNET_free_non_null(cp->path_heads); | 348 | GNUNET_free_non_null (cp->path_heads); |
345 | GNUNET_free_non_null(cp->path_tails); | 349 | GNUNET_free_non_null (cp->path_tails); |
346 | cp->path_dll_length = 0; | 350 | cp->path_dll_length = 0; |
347 | if (NULL != cp->search_h) | 351 | if (NULL != cp->search_h) |
348 | { | 352 | { |
349 | GCD_search_stop(cp->search_h); | 353 | GCD_search_stop (cp->search_h); |
350 | cp->search_h = NULL; | 354 | cp->search_h = NULL; |
351 | } | 355 | } |
352 | /* FIXME: clean up search_delayedXXX! */ | 356 | /* FIXME: clean up search_delayedXXX! */ |
353 | 357 | ||
354 | if (NULL != cp->hello_offer) | 358 | if (NULL != cp->hello_offer) |
355 | { | 359 | { |
356 | GNUNET_TRANSPORT_offer_hello_cancel(cp->hello_offer); | 360 | GNUNET_TRANSPORT_offer_hello_cancel (cp->hello_offer); |
357 | cp->hello_offer = NULL; | 361 | cp->hello_offer = NULL; |
358 | } | 362 | } |
359 | if (NULL != cp->connectivity_suggestion) | 363 | if (NULL != cp->connectivity_suggestion) |
360 | { | 364 | { |
361 | GNUNET_ATS_connectivity_suggest_cancel(cp->connectivity_suggestion); | 365 | GNUNET_ATS_connectivity_suggest_cancel (cp->connectivity_suggestion); |
362 | cp->connectivity_suggestion = NULL; | 366 | cp->connectivity_suggestion = NULL; |
363 | } | 367 | } |
364 | GNUNET_CONTAINER_multishortmap_destroy(cp->connections); | 368 | GNUNET_CONTAINER_multishortmap_destroy (cp->connections); |
365 | if (NULL != cp->path_heap) | 369 | if (NULL != cp->path_heap) |
366 | { | 370 | { |
367 | GNUNET_CONTAINER_heap_destroy(cp->path_heap); | 371 | GNUNET_CONTAINER_heap_destroy (cp->path_heap); |
368 | cp->path_heap = NULL; | 372 | cp->path_heap = NULL; |
369 | } | 373 | } |
370 | if (NULL != cp->heap_cleanup_task) | 374 | if (NULL != cp->heap_cleanup_task) |
371 | { | 375 | { |
372 | GNUNET_SCHEDULER_cancel(cp->heap_cleanup_task); | 376 | GNUNET_SCHEDULER_cancel (cp->heap_cleanup_task); |
373 | cp->heap_cleanup_task = NULL; | 377 | cp->heap_cleanup_task = NULL; |
374 | } | 378 | } |
375 | GNUNET_free_non_null(cp->hello); | 379 | GNUNET_free_non_null (cp->hello); |
376 | /* Peer should not be freed if paths exist; if there are no paths, | 380 | /* Peer should not be freed if paths exist; if there are no paths, |
377 | there ought to be no connections, and without connections, no | 381 | there ought to be no connections, and without connections, no |
378 | notifications. Thus we can assert that mqm_head is empty at this | 382 | notifications. Thus we can assert that mqm_head is empty at this |
379 | point. */ | 383 | point. */ |
380 | GNUNET_assert(NULL == cp->mqm_head); | 384 | GNUNET_assert (NULL == cp->mqm_head); |
381 | GNUNET_assert(NULL == cp->mqm_ready_ptr); | 385 | GNUNET_assert (NULL == cp->mqm_ready_ptr); |
382 | GNUNET_free(cp); | 386 | GNUNET_free (cp); |
383 | } | 387 | } |
384 | 388 | ||
385 | 389 | ||
@@ -389,64 +393,64 @@ destroy_peer(void *cls) | |||
389 | * @param cp the more-active peer | 393 | * @param cp the more-active peer |
390 | */ | 394 | */ |
391 | static void | 395 | static void |
392 | consider_peer_activate(struct CadetPeer *cp) | 396 | consider_peer_activate (struct CadetPeer *cp) |
393 | { | 397 | { |
394 | uint32_t strength; | 398 | uint32_t strength; |
395 | 399 | ||
396 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 400 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
397 | "Updating peer %s activation state (%u connections)%s%s\n", | 401 | "Updating peer %s activation state (%u connections)%s%s\n", |
398 | GCP_2s(cp), | 402 | GCP_2s (cp), |
399 | GNUNET_CONTAINER_multishortmap_size(cp->connections), | 403 | GNUNET_CONTAINER_multishortmap_size (cp->connections), |
400 | (NULL == cp->t) ? "" : " with tunnel", | 404 | (NULL == cp->t) ? "" : " with tunnel", |
401 | (NULL == cp->core_mq) ? "" : " with CORE link"); | 405 | (NULL == cp->core_mq) ? "" : " with CORE link"); |
402 | if (NULL != cp->destroy_task) | 406 | if (NULL != cp->destroy_task) |
403 | { | 407 | { |
404 | /* It's active, do not destory! */ | 408 | /* It's active, do not destory! */ |
405 | GNUNET_SCHEDULER_cancel(cp->destroy_task); | 409 | GNUNET_SCHEDULER_cancel (cp->destroy_task); |
406 | cp->destroy_task = NULL; | 410 | cp->destroy_task = NULL; |
407 | } | 411 | } |
408 | if ((0 == GNUNET_CONTAINER_multishortmap_size(cp->connections)) && | 412 | if ((0 == GNUNET_CONTAINER_multishortmap_size (cp->connections)) && |
409 | (NULL == cp->t)) | 413 | (NULL == cp->t)) |
414 | { | ||
415 | /* We're just on a path or directly connected; don't bother too much */ | ||
416 | if (NULL != cp->connectivity_suggestion) | ||
410 | { | 417 | { |
411 | /* We're just on a path or directly connected; don't bother too much */ | 418 | GNUNET_ATS_connectivity_suggest_cancel (cp->connectivity_suggestion); |
412 | if (NULL != cp->connectivity_suggestion) | 419 | cp->connectivity_suggestion = NULL; |
413 | { | ||
414 | GNUNET_ATS_connectivity_suggest_cancel(cp->connectivity_suggestion); | ||
415 | cp->connectivity_suggestion = NULL; | ||
416 | } | ||
417 | if (NULL != cp->search_h) | ||
418 | { | ||
419 | GCD_search_stop(cp->search_h); | ||
420 | cp->search_h = NULL; | ||
421 | } | ||
422 | return; | ||
423 | } | 420 | } |
424 | if (NULL == cp->core_mq) | 421 | if (NULL != cp->search_h) |
425 | { | 422 | { |
426 | /* Lacks direct connection, try to create one by querying the DHT */ | 423 | GCD_search_stop (cp->search_h); |
427 | if ((NULL == cp->search_h) && | 424 | cp->search_h = NULL; |
428 | (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths)) | ||
429 | cp->search_h | ||
430 | = GCD_search(&cp->pid); | ||
431 | } | 425 | } |
426 | return; | ||
427 | } | ||
428 | if (NULL == cp->core_mq) | ||
429 | { | ||
430 | /* Lacks direct connection, try to create one by querying the DHT */ | ||
431 | if ((NULL == cp->search_h) && | ||
432 | (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths)) | ||
433 | cp->search_h | ||
434 | = GCD_search (&cp->pid); | ||
435 | } | ||
432 | else | 436 | else |
437 | { | ||
438 | /* Have direct connection, stop DHT search if active */ | ||
439 | if (NULL != cp->search_h) | ||
433 | { | 440 | { |
434 | /* Have direct connection, stop DHT search if active */ | 441 | GCD_search_stop (cp->search_h); |
435 | if (NULL != cp->search_h) | 442 | cp->search_h = NULL; |
436 | { | ||
437 | GCD_search_stop(cp->search_h); | ||
438 | cp->search_h = NULL; | ||
439 | } | ||
440 | } | 443 | } |
444 | } | ||
441 | 445 | ||
442 | /* If we have a tunnel, our urge for connections is much bigger */ | 446 | /* If we have a tunnel, our urge for connections is much bigger */ |
443 | strength = (NULL != cp->t) ? 32 : 1; | 447 | strength = (NULL != cp->t) ? 32 : 1; |
444 | if (NULL != cp->connectivity_suggestion) | 448 | if (NULL != cp->connectivity_suggestion) |
445 | GNUNET_ATS_connectivity_suggest_cancel(cp->connectivity_suggestion); | 449 | GNUNET_ATS_connectivity_suggest_cancel (cp->connectivity_suggestion); |
446 | cp->connectivity_suggestion | 450 | cp->connectivity_suggestion |
447 | = GNUNET_ATS_connectivity_suggest(ats_ch, | 451 | = GNUNET_ATS_connectivity_suggest (ats_ch, |
448 | &cp->pid, | 452 | &cp->pid, |
449 | strength); | 453 | strength); |
450 | } | 454 | } |
451 | 455 | ||
452 | 456 | ||
@@ -456,7 +460,7 @@ consider_peer_activate(struct CadetPeer *cp) | |||
456 | * @param cp peer to clean up | 460 | * @param cp peer to clean up |
457 | */ | 461 | */ |
458 | static void | 462 | static void |
459 | consider_peer_destroy(struct CadetPeer *cp); | 463 | consider_peer_destroy (struct CadetPeer *cp); |
460 | 464 | ||
461 | 465 | ||
462 | /** | 466 | /** |
@@ -466,15 +470,15 @@ consider_peer_destroy(struct CadetPeer *cp); | |||
466 | * @param cls a `struct CadetPeer`. | 470 | * @param cls a `struct CadetPeer`. |
467 | */ | 471 | */ |
468 | static void | 472 | static void |
469 | drop_paths(void *cls) | 473 | drop_paths (void *cls) |
470 | { | 474 | { |
471 | struct CadetPeer *cp = cls; | 475 | struct CadetPeer *cp = cls; |
472 | struct CadetPeerPath *path; | 476 | struct CadetPeerPath *path; |
473 | 477 | ||
474 | cp->destroy_task = NULL; | 478 | cp->destroy_task = NULL; |
475 | while (NULL != (path = GNUNET_CONTAINER_heap_remove_root(cp->path_heap))) | 479 | while (NULL != (path = GNUNET_CONTAINER_heap_remove_root (cp->path_heap))) |
476 | GCPP_release(path); | 480 | GCPP_release (path); |
477 | consider_peer_destroy(cp); | 481 | consider_peer_destroy (cp); |
478 | } | 482 | } |
479 | 483 | ||
480 | 484 | ||
@@ -484,43 +488,44 @@ drop_paths(void *cls) | |||
484 | * @param cp peer to clean up | 488 | * @param cp peer to clean up |
485 | */ | 489 | */ |
486 | static void | 490 | static void |
487 | consider_peer_destroy(struct CadetPeer *cp) | 491 | consider_peer_destroy (struct CadetPeer *cp) |
488 | { | 492 | { |
489 | struct GNUNET_TIME_Relative exp; | 493 | struct GNUNET_TIME_Relative exp; |
490 | 494 | ||
491 | if (NULL != cp->destroy_task) | 495 | if (NULL != cp->destroy_task) |
492 | { | 496 | { |
493 | GNUNET_SCHEDULER_cancel(cp->destroy_task); | 497 | GNUNET_SCHEDULER_cancel (cp->destroy_task); |
494 | cp->destroy_task = NULL; | 498 | cp->destroy_task = NULL; |
495 | } | 499 | } |
496 | if (NULL != cp->t) | 500 | if (NULL != cp->t) |
497 | return; /* still relevant! */ | 501 | return; /* still relevant! */ |
498 | if (NULL != cp->core_mq) | 502 | if (NULL != cp->core_mq) |
499 | return; /* still relevant! */ | 503 | return; /* still relevant! */ |
500 | if (0 != GNUNET_CONTAINER_multishortmap_size(cp->connections)) | 504 | if (0 != GNUNET_CONTAINER_multishortmap_size (cp->connections)) |
501 | return; /* still relevant! */ | 505 | return; /* still relevant! */ |
502 | if ((NULL != cp->path_heap) && | 506 | if ((NULL != cp->path_heap) && |
503 | (0 < GNUNET_CONTAINER_heap_get_size(cp->path_heap))) | 507 | (0 < GNUNET_CONTAINER_heap_get_size (cp->path_heap))) |
504 | { | 508 | { |
505 | cp->destroy_task = GNUNET_SCHEDULER_add_delayed(IDLE_PATH_TIMEOUT, | 509 | cp->destroy_task = GNUNET_SCHEDULER_add_delayed (IDLE_PATH_TIMEOUT, |
506 | &drop_paths, | 510 | &drop_paths, |
507 | cp); | 511 | cp); |
508 | return; | 512 | return; |
509 | } | 513 | } |
510 | if (0 != cp->num_paths) | 514 | if (0 != cp->num_paths) |
511 | return; /* still relevant! */ | 515 | return; /* still relevant! */ |
512 | if (NULL != cp->hello) | 516 | if (NULL != cp->hello) |
513 | { | 517 | { |
514 | /* relevant only until HELLO expires */ | 518 | /* relevant only until HELLO expires */ |
515 | exp = GNUNET_TIME_absolute_get_remaining(GNUNET_HELLO_get_last_expiration(cp->hello)); | 519 | exp = GNUNET_TIME_absolute_get_remaining (GNUNET_HELLO_get_last_expiration ( |
516 | cp->destroy_task = GNUNET_SCHEDULER_add_delayed(exp, | 520 | cp->hello)); |
517 | &destroy_peer, | 521 | cp->destroy_task = GNUNET_SCHEDULER_add_delayed (exp, |
518 | cp); | 522 | &destroy_peer, |
519 | return; | 523 | cp); |
520 | } | 524 | return; |
521 | cp->destroy_task = GNUNET_SCHEDULER_add_delayed(IDLE_PEER_TIMEOUT, | 525 | } |
522 | &destroy_peer, | 526 | cp->destroy_task = GNUNET_SCHEDULER_add_delayed (IDLE_PEER_TIMEOUT, |
523 | cp); | 527 | &destroy_peer, |
528 | cp); | ||
524 | } | 529 | } |
525 | 530 | ||
526 | 531 | ||
@@ -531,60 +536,60 @@ consider_peer_destroy(struct CadetPeer *cp) | |||
531 | * @param mq message queue to set (can be NULL) | 536 | * @param mq message queue to set (can be NULL) |
532 | */ | 537 | */ |
533 | void | 538 | void |
534 | GCP_set_mq(struct CadetPeer *cp, | 539 | GCP_set_mq (struct CadetPeer *cp, |
535 | struct GNUNET_MQ_Handle *mq) | 540 | struct GNUNET_MQ_Handle *mq) |
536 | { | 541 | { |
537 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 542 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
538 | "Message queue for peer %s is now %p\n", | 543 | "Message queue for peer %s is now %p\n", |
539 | GCP_2s(cp), | 544 | GCP_2s (cp), |
540 | mq); | 545 | mq); |
541 | cp->core_mq = mq; | 546 | cp->core_mq = mq; |
542 | for (struct GCP_MessageQueueManager *mqm = cp->mqm_head, *next; | 547 | for (struct GCP_MessageQueueManager *mqm = cp->mqm_head, *next; |
543 | NULL != mqm; | 548 | NULL != mqm; |
544 | mqm = next) | 549 | mqm = next) |
550 | { | ||
551 | /* Save next pointer in case mqm gets freed by the callback */ | ||
552 | next = mqm->next; | ||
553 | if (NULL == mq) | ||
545 | { | 554 | { |
546 | /* Save next pointer in case mqm gets freed by the callback */ | 555 | if (NULL != mqm->env) |
547 | next = mqm->next; | 556 | { |
548 | if (NULL == mq) | 557 | GNUNET_MQ_discard (mqm->env); |
549 | { | 558 | mqm->env = NULL; |
550 | if (NULL != mqm->env) | 559 | mqm->cb (mqm->cb_cls, |
551 | { | 560 | GNUNET_SYSERR); |
552 | GNUNET_MQ_discard(mqm->env); | 561 | } |
553 | mqm->env = NULL; | ||
554 | mqm->cb(mqm->cb_cls, | ||
555 | GNUNET_SYSERR); | ||
556 | } | ||
557 | else | ||
558 | { | ||
559 | mqm->cb(mqm->cb_cls, | ||
560 | GNUNET_NO); | ||
561 | } | ||
562 | } | ||
563 | else | 562 | else |
564 | { | 563 | { |
565 | GNUNET_assert(NULL == mqm->env); | 564 | mqm->cb (mqm->cb_cls, |
566 | mqm->cb(mqm->cb_cls, | 565 | GNUNET_NO); |
567 | GNUNET_YES); | 566 | } |
568 | } | 567 | } |
568 | else | ||
569 | { | ||
570 | GNUNET_assert (NULL == mqm->env); | ||
571 | mqm->cb (mqm->cb_cls, | ||
572 | GNUNET_YES); | ||
569 | } | 573 | } |
574 | } | ||
570 | if ((NULL != mq) || | 575 | if ((NULL != mq) || |
571 | (NULL != cp->t)) | 576 | (NULL != cp->t)) |
572 | consider_peer_activate(cp); | 577 | consider_peer_activate (cp); |
573 | else | 578 | else |
574 | consider_peer_destroy(cp); | 579 | consider_peer_destroy (cp); |
575 | 580 | ||
576 | if ((NULL != mq) && | 581 | if ((NULL != mq) && |
577 | (NULL != cp->t)) | 582 | (NULL != cp->t)) |
578 | { | 583 | { |
579 | /* have a new, direct path to the target, notify tunnel */ | 584 | /* have a new, direct path to the target, notify tunnel */ |
580 | struct CadetPeerPath *path; | 585 | struct CadetPeerPath *path; |
581 | 586 | ||
582 | path = GCPP_get_path_from_route(1, | 587 | path = GCPP_get_path_from_route (1, |
583 | &cp->pid); | 588 | &cp->pid); |
584 | GCT_consider_path(cp->t, | 589 | GCT_consider_path (cp->t, |
585 | path, | 590 | path, |
586 | 0); | 591 | 0); |
587 | } | 592 | } |
588 | } | 593 | } |
589 | 594 | ||
590 | 595 | ||
@@ -595,12 +600,12 @@ GCP_set_mq(struct CadetPeer *cp, | |||
595 | * @return #GNUNET_YES or #GNUNET_NO with the decision to drop. | 600 | * @return #GNUNET_YES or #GNUNET_NO with the decision to drop. |
596 | */ | 601 | */ |
597 | static int | 602 | static int |
598 | should_I_drop(void) | 603 | should_I_drop (void) |
599 | { | 604 | { |
600 | if (0 == drop_percent) | 605 | if (0 == drop_percent) |
601 | return GNUNET_NO; | 606 | return GNUNET_NO; |
602 | if (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, | 607 | if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
603 | 101) < drop_percent) | 608 | 101) < drop_percent) |
604 | return GNUNET_YES; | 609 | return GNUNET_YES; |
605 | return GNUNET_NO; | 610 | return GNUNET_NO; |
606 | } | 611 | } |
@@ -613,7 +618,7 @@ should_I_drop(void) | |||
613 | * @param cls the `struct CadetPeeer` where we made progress | 618 | * @param cls the `struct CadetPeeer` where we made progress |
614 | */ | 619 | */ |
615 | static void | 620 | static void |
616 | mqm_send_done(void *cls); | 621 | mqm_send_done (void *cls); |
617 | 622 | ||
618 | 623 | ||
619 | /** | 624 | /** |
@@ -622,7 +627,7 @@ mqm_send_done(void *cls); | |||
622 | * @param mqm mqm to transmit message for now | 627 | * @param mqm mqm to transmit message for now |
623 | */ | 628 | */ |
624 | static void | 629 | static void |
625 | mqm_execute(struct GCP_MessageQueueManager *mqm) | 630 | mqm_execute (struct GCP_MessageQueueManager *mqm) |
626 | { | 631 | { |
627 | struct CadetPeer *cp = mqm->cp; | 632 | struct CadetPeer *cp = mqm->cp; |
628 | 633 | ||
@@ -632,59 +637,59 @@ mqm_execute(struct GCP_MessageQueueManager *mqm) | |||
632 | cp->mqm_ready_ptr = mqm->next; | 637 | cp->mqm_ready_ptr = mqm->next; |
633 | /* Move entry to the end of the DLL, to be fair. */ | 638 | /* Move entry to the end of the DLL, to be fair. */ |
634 | if (mqm != cp->mqm_tail) | 639 | if (mqm != cp->mqm_tail) |
635 | { | 640 | { |
636 | GNUNET_CONTAINER_DLL_remove(cp->mqm_head, | 641 | GNUNET_CONTAINER_DLL_remove (cp->mqm_head, |
637 | cp->mqm_tail, | 642 | cp->mqm_tail, |
638 | mqm); | 643 | mqm); |
639 | GNUNET_CONTAINER_DLL_insert_tail(cp->mqm_head, | 644 | GNUNET_CONTAINER_DLL_insert_tail (cp->mqm_head, |
640 | cp->mqm_tail, | 645 | cp->mqm_tail, |
641 | mqm); | 646 | mqm); |
642 | } | 647 | } |
643 | cp->mqm_ready_counter--; | 648 | cp->mqm_ready_counter--; |
644 | if (GNUNET_YES == should_I_drop()) | 649 | if (GNUNET_YES == should_I_drop ()) |
645 | { | 650 | { |
646 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 651 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
647 | "DROPPING message to peer %s from MQM %p\n", | 652 | "DROPPING message to peer %s from MQM %p\n", |
648 | GCP_2s(cp), | 653 | GCP_2s (cp), |
649 | mqm); | 654 | mqm); |
650 | GNUNET_MQ_discard(mqm->env); | 655 | GNUNET_MQ_discard (mqm->env); |
651 | mqm->env = NULL; | 656 | mqm->env = NULL; |
652 | mqm_send_done(cp); | 657 | mqm_send_done (cp); |
653 | } | 658 | } |
654 | else | 659 | else |
660 | { | ||
655 | { | 661 | { |
662 | const struct GNUNET_MessageHeader *mh; | ||
663 | |||
664 | mh = GNUNET_MQ_env_get_msg (mqm->env); | ||
665 | switch (ntohs (mh->type)) | ||
656 | { | 666 | { |
657 | const struct GNUNET_MessageHeader *mh; | 667 | case GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX: |
658 | 668 | { | |
659 | mh = GNUNET_MQ_env_get_msg(mqm->env); | 669 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg |
660 | switch (ntohs(mh->type)) | 670 | = (const struct GNUNET_CADET_TunnelKeyExchangeMessage *) mh; |
661 | { | 671 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
662 | case GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX: | 672 | "P2P forwarding KX with ephemeral %s to %s on CID %s\n", |
663 | { | 673 | GNUNET_e2s (&msg->ephemeral_key), |
664 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg | 674 | GCP_2s (cp), |
665 | = (const struct GNUNET_CADET_TunnelKeyExchangeMessage *)mh; | 675 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); |
666 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 676 | } |
667 | "P2P forwarding KX with ephemeral %s to %s on CID %s\n", | 677 | break; |
668 | GNUNET_e2s(&msg->ephemeral_key), | 678 | |
669 | GCP_2s(cp), | 679 | default: |
670 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | 680 | break; |
671 | } | ||
672 | break; | ||
673 | |||
674 | default: | ||
675 | break; | ||
676 | } | ||
677 | } | 681 | } |
678 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
679 | "Sending to peer %s from MQM %p\n", | ||
680 | GCP_2s(cp), | ||
681 | mqm); | ||
682 | GNUNET_MQ_send(cp->core_mq, | ||
683 | mqm->env); | ||
684 | mqm->env = NULL; | ||
685 | } | 682 | } |
686 | mqm->cb(mqm->cb_cls, | 683 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
687 | GNUNET_YES); | 684 | "Sending to peer %s from MQM %p\n", |
685 | GCP_2s (cp), | ||
686 | mqm); | ||
687 | GNUNET_MQ_send (cp->core_mq, | ||
688 | mqm->env); | ||
689 | mqm->env = NULL; | ||
690 | } | ||
691 | mqm->cb (mqm->cb_cls, | ||
692 | GNUNET_YES); | ||
688 | } | 693 | } |
689 | 694 | ||
690 | 695 | ||
@@ -696,7 +701,7 @@ mqm_execute(struct GCP_MessageQueueManager *mqm) | |||
696 | * @param cp peer to try to send the next ready message to | 701 | * @param cp peer to try to send the next ready message to |
697 | */ | 702 | */ |
698 | static void | 703 | static void |
699 | send_next_ready(struct CadetPeer *cp) | 704 | send_next_ready (struct CadetPeer *cp) |
700 | { | 705 | { |
701 | struct GCP_MessageQueueManager *mqm; | 706 | struct GCP_MessageQueueManager *mqm; |
702 | 707 | ||
@@ -707,7 +712,7 @@ send_next_ready(struct CadetPeer *cp) | |||
707 | cp->mqm_ready_ptr = mqm->next; | 712 | cp->mqm_ready_ptr = mqm->next; |
708 | if (NULL == mqm) | 713 | if (NULL == mqm) |
709 | return; /* nothing to do */ | 714 | return; /* nothing to do */ |
710 | mqm_execute(mqm); | 715 | mqm_execute (mqm); |
711 | } | 716 | } |
712 | 717 | ||
713 | 718 | ||
@@ -718,14 +723,14 @@ send_next_ready(struct CadetPeer *cp) | |||
718 | * @param cls the `struct CadetPeeer` where we made progress | 723 | * @param cls the `struct CadetPeeer` where we made progress |
719 | */ | 724 | */ |
720 | static void | 725 | static void |
721 | mqm_send_done(void *cls) | 726 | mqm_send_done (void *cls) |
722 | { | 727 | { |
723 | struct CadetPeer *cp = cls; | 728 | struct CadetPeer *cp = cls; |
724 | 729 | ||
725 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 730 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
726 | "Sending to peer %s completed\n", | 731 | "Sending to peer %s completed\n", |
727 | GCP_2s(cp)); | 732 | GCP_2s (cp)); |
728 | send_next_ready(cp); | 733 | send_next_ready (cp); |
729 | } | 734 | } |
730 | 735 | ||
731 | 736 | ||
@@ -737,30 +742,30 @@ mqm_send_done(void *cls) | |||
737 | * yet have a #GNUNET_MQ_notify_sent() callback attached to it | 742 | * yet have a #GNUNET_MQ_notify_sent() callback attached to it |
738 | */ | 743 | */ |
739 | void | 744 | void |
740 | GCP_send(struct GCP_MessageQueueManager *mqm, | 745 | GCP_send (struct GCP_MessageQueueManager *mqm, |
741 | struct GNUNET_MQ_Envelope *env) | 746 | struct GNUNET_MQ_Envelope *env) |
742 | { | 747 | { |
743 | struct CadetPeer *cp = mqm->cp; | 748 | struct CadetPeer *cp = mqm->cp; |
744 | 749 | ||
745 | GNUNET_assert(NULL != env); | 750 | GNUNET_assert (NULL != env); |
746 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 751 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
747 | "Queueing message to peer %s in MQM %p\n", | 752 | "Queueing message to peer %s in MQM %p\n", |
748 | GCP_2s(cp), | 753 | GCP_2s (cp), |
749 | mqm); | 754 | mqm); |
750 | GNUNET_assert(NULL != cp->core_mq); | 755 | GNUNET_assert (NULL != cp->core_mq); |
751 | GNUNET_assert(NULL == mqm->env); | 756 | GNUNET_assert (NULL == mqm->env); |
752 | GNUNET_MQ_notify_sent(env, | 757 | GNUNET_MQ_notify_sent (env, |
753 | &mqm_send_done, | 758 | &mqm_send_done, |
754 | cp); | 759 | cp); |
755 | mqm->env = env; | 760 | mqm->env = env; |
756 | cp->mqm_ready_counter++; | 761 | cp->mqm_ready_counter++; |
757 | if (mqm != cp->mqm_ready_ptr) | 762 | if (mqm != cp->mqm_ready_ptr) |
758 | cp->mqm_ready_ptr = cp->mqm_head; | 763 | cp->mqm_ready_ptr = cp->mqm_head; |
759 | if (1 == cp->mqm_ready_counter) | 764 | if (1 == cp->mqm_ready_counter) |
760 | cp->mqm_ready_ptr = mqm; | 765 | cp->mqm_ready_ptr = mqm; |
761 | if (0 != GNUNET_MQ_get_length(cp->core_mq)) | 766 | if (0 != GNUNET_MQ_get_length (cp->core_mq)) |
762 | return; | 767 | return; |
763 | send_next_ready(cp); | 768 | send_next_ready (cp); |
764 | } | 769 | } |
765 | 770 | ||
766 | 771 | ||
@@ -773,18 +778,18 @@ GCP_send(struct GCP_MessageQueueManager *mqm, | |||
773 | * @return #GNUNET_OK (continue to iterate) | 778 | * @return #GNUNET_OK (continue to iterate) |
774 | */ | 779 | */ |
775 | static int | 780 | static int |
776 | destroy_iterator_cb(void *cls, | 781 | destroy_iterator_cb (void *cls, |
777 | const struct GNUNET_PeerIdentity *pid, | 782 | const struct GNUNET_PeerIdentity *pid, |
778 | void *value) | 783 | void *value) |
779 | { | 784 | { |
780 | struct CadetPeer *cp = value; | 785 | struct CadetPeer *cp = value; |
781 | 786 | ||
782 | if (NULL != cp->destroy_task) | 787 | if (NULL != cp->destroy_task) |
783 | { | 788 | { |
784 | GNUNET_SCHEDULER_cancel(cp->destroy_task); | 789 | GNUNET_SCHEDULER_cancel (cp->destroy_task); |
785 | cp->destroy_task = NULL; | 790 | cp->destroy_task = NULL; |
786 | } | 791 | } |
787 | destroy_peer(cp); | 792 | destroy_peer (cp); |
788 | return GNUNET_OK; | 793 | return GNUNET_OK; |
789 | } | 794 | } |
790 | 795 | ||
@@ -795,13 +800,13 @@ destroy_iterator_cb(void *cls, | |||
795 | * connections are down. | 800 | * connections are down. |
796 | */ | 801 | */ |
797 | void | 802 | void |
798 | GCP_destroy_all_peers() | 803 | GCP_destroy_all_peers () |
799 | { | 804 | { |
800 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 805 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
801 | "Destroying all peers now\n"); | 806 | "Destroying all peers now\n"); |
802 | GNUNET_CONTAINER_multipeermap_iterate(peers, | 807 | GNUNET_CONTAINER_multipeermap_iterate (peers, |
803 | &destroy_iterator_cb, | 808 | &destroy_iterator_cb, |
804 | NULL); | 809 | NULL); |
805 | } | 810 | } |
806 | 811 | ||
807 | 812 | ||
@@ -812,17 +817,17 @@ GCP_destroy_all_peers() | |||
812 | * @param cp peer to drop paths to | 817 | * @param cp peer to drop paths to |
813 | */ | 818 | */ |
814 | void | 819 | void |
815 | GCP_drop_owned_paths(struct CadetPeer *cp) | 820 | GCP_drop_owned_paths (struct CadetPeer *cp) |
816 | { | 821 | { |
817 | struct CadetPeerPath *path; | 822 | struct CadetPeerPath *path; |
818 | 823 | ||
819 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 824 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
820 | "Destroying all paths to %s\n", | 825 | "Destroying all paths to %s\n", |
821 | GCP_2s(cp)); | 826 | GCP_2s (cp)); |
822 | while (NULL != (path = | 827 | while (NULL != (path = |
823 | GNUNET_CONTAINER_heap_remove_root(cp->path_heap))) | 828 | GNUNET_CONTAINER_heap_remove_root (cp->path_heap))) |
824 | GCPP_release(path); | 829 | GCPP_release (path); |
825 | GNUNET_CONTAINER_heap_destroy(cp->path_heap); | 830 | GNUNET_CONTAINER_heap_destroy (cp->path_heap); |
826 | cp->path_heap = NULL; | 831 | cp->path_heap = NULL; |
827 | } | 832 | } |
828 | 833 | ||
@@ -835,55 +840,55 @@ GCP_drop_owned_paths(struct CadetPeer *cp) | |||
835 | * @param off offset of this peer on the path | 840 | * @param off offset of this peer on the path |
836 | */ | 841 | */ |
837 | void | 842 | void |
838 | GCP_path_entry_add(struct CadetPeer *cp, | 843 | GCP_path_entry_add (struct CadetPeer *cp, |
839 | struct CadetPeerPathEntry *entry, | 844 | struct CadetPeerPathEntry *entry, |
840 | unsigned int off) | 845 | unsigned int off) |
841 | { | 846 | { |
842 | GNUNET_assert(cp == GCPP_get_peer_at_offset(entry->path, | 847 | GNUNET_assert (cp == GCPP_get_peer_at_offset (entry->path, |
843 | off)); | 848 | off)); |
844 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 849 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
845 | "Discovered that peer %s is on path %s at offset %u\n", | 850 | "Discovered that peer %s is on path %s at offset %u\n", |
846 | GCP_2s(cp), | 851 | GCP_2s (cp), |
847 | GCPP_2s(entry->path), | 852 | GCPP_2s (entry->path), |
848 | off); | 853 | off); |
849 | if (off >= cp->path_dll_length) | 854 | if (off >= cp->path_dll_length) |
850 | { | 855 | { |
851 | unsigned int len = cp->path_dll_length; | 856 | unsigned int len = cp->path_dll_length; |
852 | 857 | ||
853 | GNUNET_array_grow(cp->path_heads, | 858 | GNUNET_array_grow (cp->path_heads, |
854 | len, | 859 | len, |
855 | off + 4); | 860 | off + 4); |
856 | GNUNET_array_grow(cp->path_tails, | 861 | GNUNET_array_grow (cp->path_tails, |
857 | cp->path_dll_length, | 862 | cp->path_dll_length, |
858 | off + 4); | 863 | off + 4); |
859 | } | 864 | } |
860 | GNUNET_CONTAINER_DLL_insert(cp->path_heads[off], | 865 | GNUNET_CONTAINER_DLL_insert (cp->path_heads[off], |
861 | cp->path_tails[off], | 866 | cp->path_tails[off], |
862 | entry); | 867 | entry); |
863 | cp->off_sum += off; | 868 | cp->off_sum += off; |
864 | cp->num_paths++; | 869 | cp->num_paths++; |
865 | 870 | ||
866 | /* If we have a tunnel to this peer, tell the tunnel that there is a | 871 | /* If we have a tunnel to this peer, tell the tunnel that there is a |
867 | new path available. */ | 872 | new path available. */ |
868 | if (NULL != cp->t) | 873 | if (NULL != cp->t) |
869 | GCT_consider_path(cp->t, | 874 | GCT_consider_path (cp->t, |
870 | entry->path, | 875 | entry->path, |
871 | off); | 876 | off); |
872 | 877 | ||
873 | if ((NULL != cp->search_h) && | 878 | if ((NULL != cp->search_h) && |
874 | (DESIRED_CONNECTIONS_PER_TUNNEL <= cp->num_paths)) | 879 | (DESIRED_CONNECTIONS_PER_TUNNEL <= cp->num_paths)) |
875 | { | 880 | { |
876 | /* Now I have enough paths, stop search */ | 881 | /* Now I have enough paths, stop search */ |
877 | GCD_search_stop(cp->search_h); | 882 | GCD_search_stop (cp->search_h); |
878 | cp->search_h = NULL; | 883 | cp->search_h = NULL; |
879 | } | 884 | } |
880 | if (NULL != cp->destroy_task) | 885 | if (NULL != cp->destroy_task) |
881 | { | 886 | { |
882 | /* paths changed, this resets the destroy timeout counter | 887 | /* paths changed, this resets the destroy timeout counter |
883 | and aborts a destroy task that may no longer be valid | 888 | and aborts a destroy task that may no longer be valid |
884 | to have (as we now have more paths via this peer). */ | 889 | to have (as we now have more paths via this peer). */ |
885 | consider_peer_destroy(cp); | 890 | consider_peer_destroy (cp); |
886 | } | 891 | } |
887 | } | 892 | } |
888 | 893 | ||
889 | 894 | ||
@@ -895,19 +900,19 @@ GCP_path_entry_add(struct CadetPeer *cp, | |||
895 | * @param off offset of this peer on the path | 900 | * @param off offset of this peer on the path |
896 | */ | 901 | */ |
897 | void | 902 | void |
898 | GCP_path_entry_remove(struct CadetPeer *cp, | 903 | GCP_path_entry_remove (struct CadetPeer *cp, |
899 | struct CadetPeerPathEntry *entry, | 904 | struct CadetPeerPathEntry *entry, |
900 | unsigned int off) | 905 | unsigned int off) |
901 | { | 906 | { |
902 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 907 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
903 | "Removing knowledge about peer %s beging on path %s at offset %u\n", | 908 | "Removing knowledge about peer %s beging on path %s at offset %u\n", |
904 | GCP_2s(cp), | 909 | GCP_2s (cp), |
905 | GCPP_2s(entry->path), | 910 | GCPP_2s (entry->path), |
906 | off); | 911 | off); |
907 | GNUNET_CONTAINER_DLL_remove(cp->path_heads[off], | 912 | GNUNET_CONTAINER_DLL_remove (cp->path_heads[off], |
908 | cp->path_tails[off], | 913 | cp->path_tails[off], |
909 | entry); | 914 | entry); |
910 | GNUNET_assert(0 < cp->num_paths); | 915 | GNUNET_assert (0 < cp->num_paths); |
911 | cp->off_sum -= off; | 916 | cp->off_sum -= off; |
912 | cp->num_paths--; | 917 | cp->num_paths--; |
913 | if ((NULL == cp->core_mq) && | 918 | if ((NULL == cp->core_mq) && |
@@ -915,12 +920,12 @@ GCP_path_entry_remove(struct CadetPeer *cp, | |||
915 | (NULL == cp->search_h) && | 920 | (NULL == cp->search_h) && |
916 | (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths)) | 921 | (DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths)) |
917 | cp->search_h | 922 | cp->search_h |
918 | = GCD_search(&cp->pid); | 923 | = GCD_search (&cp->pid); |
919 | if (NULL == cp->destroy_task) | 924 | if (NULL == cp->destroy_task) |
920 | { | 925 | { |
921 | /* paths changed, we might now be ready for destruction, check again */ | 926 | /* paths changed, we might now be ready for destruction, check again */ |
922 | consider_peer_destroy(cp); | 927 | consider_peer_destroy (cp); |
923 | } | 928 | } |
924 | } | 929 | } |
925 | 930 | ||
926 | 931 | ||
@@ -931,32 +936,32 @@ GCP_path_entry_remove(struct CadetPeer *cp, | |||
931 | * @param cls the `struct CadetPeer` to maintain the path heap for | 936 | * @param cls the `struct CadetPeer` to maintain the path heap for |
932 | */ | 937 | */ |
933 | static void | 938 | static void |
934 | path_heap_cleanup(void *cls) | 939 | path_heap_cleanup (void *cls) |
935 | { | 940 | { |
936 | struct CadetPeer *cp = cls; | 941 | struct CadetPeer *cp = cls; |
937 | struct CadetPeerPath *root; | 942 | struct CadetPeerPath *root; |
938 | 943 | ||
939 | cp->heap_cleanup_task = NULL; | 944 | cp->heap_cleanup_task = NULL; |
940 | while (GNUNET_CONTAINER_heap_get_size(cp->path_heap) >= | 945 | while (GNUNET_CONTAINER_heap_get_size (cp->path_heap) >= |
941 | 2 * DESIRED_CONNECTIONS_PER_TUNNEL) | 946 | 2 * DESIRED_CONNECTIONS_PER_TUNNEL) |
942 | { | 947 | { |
943 | /* Now we have way too many, drop least desirable UNLESS it is in use! | 948 | /* Now we have way too many, drop least desirable UNLESS it is in use! |
944 | (Note that this intentionally keeps highly desireable, but currently | 949 | (Note that this intentionally keeps highly desireable, but currently |
945 | unused paths around in the hope that we might be able to switch, even | 950 | unused paths around in the hope that we might be able to switch, even |
946 | if the number of paths exceeds the threshold.) */ | 951 | if the number of paths exceeds the threshold.) */ |
947 | root = GNUNET_CONTAINER_heap_peek(cp->path_heap); | 952 | root = GNUNET_CONTAINER_heap_peek (cp->path_heap); |
948 | GNUNET_assert(NULL != root); | 953 | GNUNET_assert (NULL != root); |
949 | if (NULL != | 954 | if (NULL != |
950 | GCPP_get_connection(root, | 955 | GCPP_get_connection (root, |
951 | cp, | 956 | cp, |
952 | GCPP_get_length(root) - 1)) | 957 | GCPP_get_length (root) - 1)) |
953 | break; /* can't fix */ | 958 | break; /* can't fix */ |
954 | /* Got plenty of paths to this destination, and this is a low-quality | 959 | /* Got plenty of paths to this destination, and this is a low-quality |
955 | one that we don't care about. Allow it to die. */ | 960 | one that we don't care about. Allow it to die. */ |
956 | GNUNET_assert(root == | 961 | GNUNET_assert (root == |
957 | GNUNET_CONTAINER_heap_remove_root(cp->path_heap)); | 962 | GNUNET_CONTAINER_heap_remove_root (cp->path_heap)); |
958 | GCPP_release(root); | 963 | GCPP_release (root); |
959 | } | 964 | } |
960 | } | 965 | } |
961 | 966 | ||
962 | 967 | ||
@@ -972,66 +977,66 @@ path_heap_cleanup(void *cls) | |||
972 | * otherwise the node in the peer's path heap for the @a path. | 977 | * otherwise the node in the peer's path heap for the @a path. |
973 | */ | 978 | */ |
974 | struct GNUNET_CONTAINER_HeapNode * | 979 | struct GNUNET_CONTAINER_HeapNode * |
975 | GCP_attach_path(struct CadetPeer *cp, | 980 | GCP_attach_path (struct CadetPeer *cp, |
976 | struct CadetPeerPath *path, | 981 | struct CadetPeerPath *path, |
977 | unsigned int off, | 982 | unsigned int off, |
978 | int force) | 983 | int force) |
979 | { | 984 | { |
980 | GNUNET_CONTAINER_HeapCostType desirability; | 985 | GNUNET_CONTAINER_HeapCostType desirability; |
981 | struct CadetPeerPath *root; | 986 | struct CadetPeerPath *root; |
982 | GNUNET_CONTAINER_HeapCostType root_desirability; | 987 | GNUNET_CONTAINER_HeapCostType root_desirability; |
983 | struct GNUNET_CONTAINER_HeapNode *hn; | 988 | struct GNUNET_CONTAINER_HeapNode *hn; |
984 | 989 | ||
985 | GNUNET_assert(off == GCPP_get_length(path) - 1); | 990 | GNUNET_assert (off == GCPP_get_length (path) - 1); |
986 | GNUNET_assert(cp == GCPP_get_peer_at_offset(path, | 991 | GNUNET_assert (cp == GCPP_get_peer_at_offset (path, |
987 | off)); | 992 | off)); |
988 | if (NULL == cp->path_heap) | 993 | if (NULL == cp->path_heap) |
989 | { | 994 | { |
990 | /* #GCP_drop_owned_paths() was already called, we cannot take new ones! */ | 995 | /* #GCP_drop_owned_paths() was already called, we cannot take new ones! */ |
991 | GNUNET_assert(GNUNET_NO == force); | 996 | GNUNET_assert (GNUNET_NO == force); |
992 | return NULL; | 997 | return NULL; |
993 | } | 998 | } |
994 | desirability = GCPP_get_desirability(path); | 999 | desirability = GCPP_get_desirability (path); |
995 | if (GNUNET_NO == force) | 1000 | if (GNUNET_NO == force) |
1001 | { | ||
1002 | /* FIXME: desirability is not yet initialized; tricky! */ | ||
1003 | if (GNUNET_NO == | ||
1004 | GNUNET_CONTAINER_heap_peek2 (cp->path_heap, | ||
1005 | (void **) &root, | ||
1006 | &root_desirability)) | ||
996 | { | 1007 | { |
997 | /* FIXME: desirability is not yet initialized; tricky! */ | 1008 | root = NULL; |
998 | if (GNUNET_NO == | 1009 | root_desirability = 0; |
999 | GNUNET_CONTAINER_heap_peek2(cp->path_heap, | 1010 | } |
1000 | (void **)&root, | ||
1001 | &root_desirability)) | ||
1002 | { | ||
1003 | root = NULL; | ||
1004 | root_desirability = 0; | ||
1005 | } | ||
1006 | 1011 | ||
1007 | if ((DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths) && | 1012 | if ((DESIRED_CONNECTIONS_PER_TUNNEL > cp->num_paths) && |
1008 | (desirability < root_desirability)) | 1013 | (desirability < root_desirability)) |
1009 | { | 1014 | { |
1010 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1015 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1011 | "Decided to not attach path %s to peer %s due to undesirability\n", | 1016 | "Decided to not attach path %s to peer %s due to undesirability\n", |
1012 | GCPP_2s(path), | 1017 | GCPP_2s (path), |
1013 | GCP_2s(cp)); | 1018 | GCP_2s (cp)); |
1014 | return NULL; | 1019 | return NULL; |
1015 | } | ||
1016 | } | 1020 | } |
1021 | } | ||
1017 | 1022 | ||
1018 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1023 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1019 | "Attaching path %s to peer %s (%s)\n", | 1024 | "Attaching path %s to peer %s (%s)\n", |
1020 | GCPP_2s(path), | 1025 | GCPP_2s (path), |
1021 | GCP_2s(cp), | 1026 | GCP_2s (cp), |
1022 | (GNUNET_NO == force) ? "desirable" : "forced"); | 1027 | (GNUNET_NO == force) ? "desirable" : "forced"); |
1023 | 1028 | ||
1024 | /* Yes, we'd like to add this path, add to our heap */ | 1029 | /* Yes, we'd like to add this path, add to our heap */ |
1025 | hn = GNUNET_CONTAINER_heap_insert(cp->path_heap, | 1030 | hn = GNUNET_CONTAINER_heap_insert (cp->path_heap, |
1026 | path, | 1031 | path, |
1027 | desirability); | 1032 | desirability); |
1028 | 1033 | ||
1029 | /* Consider maybe dropping other paths because of the new one */ | 1034 | /* Consider maybe dropping other paths because of the new one */ |
1030 | if ((GNUNET_CONTAINER_heap_get_size(cp->path_heap) >= | 1035 | if ((GNUNET_CONTAINER_heap_get_size (cp->path_heap) >= |
1031 | 2 * DESIRED_CONNECTIONS_PER_TUNNEL) && | 1036 | 2 * DESIRED_CONNECTIONS_PER_TUNNEL) && |
1032 | (NULL != cp->heap_cleanup_task)) | 1037 | (NULL != cp->heap_cleanup_task)) |
1033 | cp->heap_cleanup_task = GNUNET_SCHEDULER_add_now(&path_heap_cleanup, | 1038 | cp->heap_cleanup_task = GNUNET_SCHEDULER_add_now (&path_heap_cleanup, |
1034 | cp); | 1039 | cp); |
1035 | return hn; | 1040 | return hn; |
1036 | } | 1041 | } |
1037 | 1042 | ||
@@ -1046,16 +1051,16 @@ GCP_attach_path(struct CadetPeer *cp, | |||
1046 | * @param hn note in @a cp's path heap that must be deleted | 1051 | * @param hn note in @a cp's path heap that must be deleted |
1047 | */ | 1052 | */ |
1048 | void | 1053 | void |
1049 | GCP_detach_path(struct CadetPeer *cp, | 1054 | GCP_detach_path (struct CadetPeer *cp, |
1050 | struct CadetPeerPath *path, | 1055 | struct CadetPeerPath *path, |
1051 | struct GNUNET_CONTAINER_HeapNode *hn) | 1056 | struct GNUNET_CONTAINER_HeapNode *hn) |
1052 | { | 1057 | { |
1053 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1058 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1054 | "Detatching path %s from peer %s\n", | 1059 | "Detatching path %s from peer %s\n", |
1055 | GCPP_2s(path), | 1060 | GCPP_2s (path), |
1056 | GCP_2s(cp)); | 1061 | GCP_2s (cp)); |
1057 | GNUNET_assert(path == | 1062 | GNUNET_assert (path == |
1058 | GNUNET_CONTAINER_heap_remove_node(hn)); | 1063 | GNUNET_CONTAINER_heap_remove_node (hn)); |
1059 | } | 1064 | } |
1060 | 1065 | ||
1061 | 1066 | ||
@@ -1066,23 +1071,24 @@ GCP_detach_path(struct CadetPeer *cp, | |||
1066 | * @param cc the connection to add | 1071 | * @param cc the connection to add |
1067 | */ | 1072 | */ |
1068 | void | 1073 | void |
1069 | GCP_add_connection(struct CadetPeer *cp, | 1074 | GCP_add_connection (struct CadetPeer *cp, |
1070 | struct CadetConnection *cc) | 1075 | struct CadetConnection *cc) |
1071 | { | 1076 | { |
1072 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1077 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1073 | "Adding %s to peer %s\n", | 1078 | "Adding %s to peer %s\n", |
1074 | GCC_2s(cc), | 1079 | GCC_2s (cc), |
1075 | GCP_2s(cp)); | 1080 | GCP_2s (cp)); |
1076 | GNUNET_assert(GNUNET_OK == | 1081 | GNUNET_assert (GNUNET_OK == |
1077 | GNUNET_CONTAINER_multishortmap_put(cp->connections, | 1082 | GNUNET_CONTAINER_multishortmap_put (cp->connections, |
1078 | &GCC_get_id(cc)->connection_of_tunnel, | 1083 | &GCC_get_id ( |
1079 | cc, | 1084 | cc)->connection_of_tunnel, |
1080 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 1085 | cc, |
1086 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
1081 | if (NULL != cp->destroy_task) | 1087 | if (NULL != cp->destroy_task) |
1082 | { | 1088 | { |
1083 | GNUNET_SCHEDULER_cancel(cp->destroy_task); | 1089 | GNUNET_SCHEDULER_cancel (cp->destroy_task); |
1084 | cp->destroy_task = NULL; | 1090 | cp->destroy_task = NULL; |
1085 | } | 1091 | } |
1086 | } | 1092 | } |
1087 | 1093 | ||
1088 | 1094 | ||
@@ -1093,18 +1099,20 @@ GCP_add_connection(struct CadetPeer *cp, | |||
1093 | * @param cc the connection to remove | 1099 | * @param cc the connection to remove |
1094 | */ | 1100 | */ |
1095 | void | 1101 | void |
1096 | GCP_remove_connection(struct CadetPeer *cp, | 1102 | GCP_remove_connection (struct CadetPeer *cp, |
1097 | struct CadetConnection *cc) | 1103 | struct CadetConnection *cc) |
1098 | { | 1104 | { |
1099 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1105 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1100 | "Removing connection %s from peer %s\n", | 1106 | "Removing connection %s from peer %s\n", |
1101 | GCC_2s(cc), | 1107 | GCC_2s (cc), |
1102 | GCP_2s(cp)); | 1108 | GCP_2s (cp)); |
1103 | GNUNET_assert(GNUNET_YES == | 1109 | GNUNET_assert (GNUNET_YES == |
1104 | GNUNET_CONTAINER_multishortmap_remove(cp->connections, | 1110 | GNUNET_CONTAINER_multishortmap_remove (cp->connections, |
1105 | &GCC_get_id(cc)->connection_of_tunnel, | 1111 | &GCC_get_id ( |
1106 | cc)); | 1112 | cc)-> |
1107 | consider_peer_destroy(cp); | 1113 | connection_of_tunnel, |
1114 | cc)); | ||
1115 | consider_peer_destroy (cp); | ||
1108 | } | 1116 | } |
1109 | 1117 | ||
1110 | 1118 | ||
@@ -1120,30 +1128,31 @@ GCP_remove_connection(struct CadetPeer *cp, | |||
1120 | * NULL if unknown and not requested @a create | 1128 | * NULL if unknown and not requested @a create |
1121 | */ | 1129 | */ |
1122 | struct CadetPeer * | 1130 | struct CadetPeer * |
1123 | GCP_get(const struct GNUNET_PeerIdentity *peer_id, | 1131 | GCP_get (const struct GNUNET_PeerIdentity *peer_id, |
1124 | int create) | 1132 | int create) |
1125 | { | 1133 | { |
1126 | struct CadetPeer *cp; | 1134 | struct CadetPeer *cp; |
1127 | 1135 | ||
1128 | cp = GNUNET_CONTAINER_multipeermap_get(peers, | 1136 | cp = GNUNET_CONTAINER_multipeermap_get (peers, |
1129 | peer_id); | 1137 | peer_id); |
1130 | if (NULL != cp) | 1138 | if (NULL != cp) |
1131 | return cp; | 1139 | return cp; |
1132 | if (GNUNET_NO == create) | 1140 | if (GNUNET_NO == create) |
1133 | return NULL; | 1141 | return NULL; |
1134 | cp = GNUNET_new(struct CadetPeer); | 1142 | cp = GNUNET_new (struct CadetPeer); |
1135 | cp->pid = *peer_id; | 1143 | cp->pid = *peer_id; |
1136 | cp->connections = GNUNET_CONTAINER_multishortmap_create(32, | 1144 | cp->connections = GNUNET_CONTAINER_multishortmap_create (32, |
1137 | GNUNET_YES); | 1145 | GNUNET_YES); |
1138 | cp->path_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); | 1146 | cp->path_heap = GNUNET_CONTAINER_heap_create ( |
1139 | GNUNET_assert(GNUNET_YES == | 1147 | GNUNET_CONTAINER_HEAP_ORDER_MIN); |
1140 | GNUNET_CONTAINER_multipeermap_put(peers, | 1148 | GNUNET_assert (GNUNET_YES == |
1141 | &cp->pid, | 1149 | GNUNET_CONTAINER_multipeermap_put (peers, |
1142 | cp, | 1150 | &cp->pid, |
1143 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 1151 | cp, |
1144 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1152 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
1145 | "Creating peer %s\n", | 1153 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1146 | GCP_2s(cp)); | 1154 | "Creating peer %s\n", |
1155 | GCP_2s (cp)); | ||
1147 | return cp; | 1156 | return cp; |
1148 | } | 1157 | } |
1149 | 1158 | ||
@@ -1155,7 +1164,7 @@ GCP_get(const struct GNUNET_PeerIdentity *peer_id, | |||
1155 | * @return the peer identity | 1164 | * @return the peer identity |
1156 | */ | 1165 | */ |
1157 | const struct GNUNET_PeerIdentity * | 1166 | const struct GNUNET_PeerIdentity * |
1158 | GCP_get_id(struct CadetPeer *cp) | 1167 | GCP_get_id (struct CadetPeer *cp) |
1159 | { | 1168 | { |
1160 | return &cp->pid; | 1169 | return &cp->pid; |
1161 | } | 1170 | } |
@@ -1168,12 +1177,12 @@ GCP_get_id(struct CadetPeer *cp) | |||
1168 | * @param cls Closure for @c iter. | 1177 | * @param cls Closure for @c iter. |
1169 | */ | 1178 | */ |
1170 | void | 1179 | void |
1171 | GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, | 1180 | GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, |
1172 | void *cls) | 1181 | void *cls) |
1173 | { | 1182 | { |
1174 | GNUNET_CONTAINER_multipeermap_iterate(peers, | 1183 | GNUNET_CONTAINER_multipeermap_iterate (peers, |
1175 | iter, | 1184 | iter, |
1176 | cls); | 1185 | cls); |
1177 | } | 1186 | } |
1178 | 1187 | ||
1179 | 1188 | ||
@@ -1184,7 +1193,7 @@ GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, | |||
1184 | * @return Number of known paths. | 1193 | * @return Number of known paths. |
1185 | */ | 1194 | */ |
1186 | unsigned int | 1195 | unsigned int |
1187 | GCP_count_paths(const struct CadetPeer *cp) | 1196 | GCP_count_paths (const struct CadetPeer *cp) |
1188 | { | 1197 | { |
1189 | return cp->num_paths; | 1198 | return cp->num_paths; |
1190 | } | 1199 | } |
@@ -1199,45 +1208,45 @@ GCP_count_paths(const struct CadetPeer *cp) | |||
1199 | * @return Number of iterated paths. | 1208 | * @return Number of iterated paths. |
1200 | */ | 1209 | */ |
1201 | unsigned int | 1210 | unsigned int |
1202 | GCP_iterate_paths(struct CadetPeer *cp, | 1211 | GCP_iterate_paths (struct CadetPeer *cp, |
1203 | GCP_PathIterator callback, | 1212 | GCP_PathIterator callback, |
1204 | void *callback_cls) | 1213 | void *callback_cls) |
1205 | { | 1214 | { |
1206 | unsigned int ret = 0; | 1215 | unsigned int ret = 0; |
1207 | 1216 | ||
1208 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1217 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1209 | "Iterating over paths to peer %s%s\n", | 1218 | "Iterating over paths to peer %s%s\n", |
1210 | GCP_2s(cp), | 1219 | GCP_2s (cp), |
1211 | (NULL == cp->core_mq) ? "" : " including direct link"); | 1220 | (NULL == cp->core_mq) ? "" : " including direct link"); |
1212 | if (NULL != cp->core_mq) | 1221 | if (NULL != cp->core_mq) |
1222 | { | ||
1223 | /* FIXME: this branch seems to duplicate the | ||
1224 | i=0 case below (direct link). Leave out!??? -CG */ | ||
1225 | struct CadetPeerPath *path; | ||
1226 | |||
1227 | path = GCPP_get_path_from_route (1, | ||
1228 | &cp->pid); | ||
1229 | ret++; | ||
1230 | if (GNUNET_NO == | ||
1231 | callback (callback_cls, | ||
1232 | path, | ||
1233 | 0)) | ||
1234 | return ret; | ||
1235 | } | ||
1236 | for (unsigned int i = 0; i < cp->path_dll_length; i++) | ||
1237 | { | ||
1238 | for (struct CadetPeerPathEntry *pe = cp->path_heads[i]; | ||
1239 | NULL != pe; | ||
1240 | pe = pe->next) | ||
1213 | { | 1241 | { |
1214 | /* FIXME: this branch seems to duplicate the | ||
1215 | i=0 case below (direct link). Leave out!??? -CG */ | ||
1216 | struct CadetPeerPath *path; | ||
1217 | |||
1218 | path = GCPP_get_path_from_route(1, | ||
1219 | &cp->pid); | ||
1220 | ret++; | 1242 | ret++; |
1221 | if (GNUNET_NO == | 1243 | if (GNUNET_NO == |
1222 | callback(callback_cls, | 1244 | callback (callback_cls, |
1223 | path, | 1245 | pe->path, |
1224 | 0)) | 1246 | i)) |
1225 | return ret; | 1247 | return ret; |
1226 | } | 1248 | } |
1227 | for (unsigned int i = 0; i < cp->path_dll_length; i++) | 1249 | } |
1228 | { | ||
1229 | for (struct CadetPeerPathEntry *pe = cp->path_heads[i]; | ||
1230 | NULL != pe; | ||
1231 | pe = pe->next) | ||
1232 | { | ||
1233 | ret++; | ||
1234 | if (GNUNET_NO == | ||
1235 | callback(callback_cls, | ||
1236 | pe->path, | ||
1237 | i)) | ||
1238 | return ret; | ||
1239 | } | ||
1240 | } | ||
1241 | return ret; | 1250 | return ret; |
1242 | } | 1251 | } |
1243 | 1252 | ||
@@ -1250,29 +1259,29 @@ GCP_iterate_paths(struct CadetPeer *cp, | |||
1250 | * @return Number of iterated paths. | 1259 | * @return Number of iterated paths. |
1251 | */ | 1260 | */ |
1252 | unsigned int | 1261 | unsigned int |
1253 | GCP_iterate_indirect_paths(struct CadetPeer *cp, | 1262 | GCP_iterate_indirect_paths (struct CadetPeer *cp, |
1254 | GCP_PathIterator callback, | 1263 | GCP_PathIterator callback, |
1255 | void *callback_cls) | 1264 | void *callback_cls) |
1256 | { | 1265 | { |
1257 | unsigned int ret = 0; | 1266 | unsigned int ret = 0; |
1258 | 1267 | ||
1259 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1268 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1260 | "Iterating over paths to peer %s without direct link\n", | 1269 | "Iterating over paths to peer %s without direct link\n", |
1261 | GCP_2s(cp)); | 1270 | GCP_2s (cp)); |
1262 | for (unsigned int i = 1; i < cp->path_dll_length; i++) | 1271 | for (unsigned int i = 1; i < cp->path_dll_length; i++) |
1272 | { | ||
1273 | for (struct CadetPeerPathEntry *pe = cp->path_heads[i]; | ||
1274 | NULL != pe; | ||
1275 | pe = pe->next) | ||
1263 | { | 1276 | { |
1264 | for (struct CadetPeerPathEntry *pe = cp->path_heads[i]; | 1277 | ret++; |
1265 | NULL != pe; | 1278 | if (GNUNET_NO == |
1266 | pe = pe->next) | 1279 | callback (callback_cls, |
1267 | { | 1280 | pe->path, |
1268 | ret++; | 1281 | i)) |
1269 | if (GNUNET_NO == | 1282 | return ret; |
1270 | callback(callback_cls, | ||
1271 | pe->path, | ||
1272 | i)) | ||
1273 | return ret; | ||
1274 | } | ||
1275 | } | 1283 | } |
1284 | } | ||
1276 | return ret; | 1285 | return ret; |
1277 | } | 1286 | } |
1278 | 1287 | ||
@@ -1288,32 +1297,32 @@ GCP_iterate_indirect_paths(struct CadetPeer *cp, | |||
1288 | * @return Number of iterated paths. | 1297 | * @return Number of iterated paths. |
1289 | */ | 1298 | */ |
1290 | unsigned int | 1299 | unsigned int |
1291 | GCP_iterate_paths_at(struct CadetPeer *cp, | 1300 | GCP_iterate_paths_at (struct CadetPeer *cp, |
1292 | unsigned int dist, | 1301 | unsigned int dist, |
1293 | GCP_PathIterator callback, | 1302 | GCP_PathIterator callback, |
1294 | void *callback_cls) | 1303 | void *callback_cls) |
1295 | { | 1304 | { |
1296 | unsigned int ret = 0; | 1305 | unsigned int ret = 0; |
1297 | 1306 | ||
1298 | if (dist >= cp->path_dll_length) | 1307 | if (dist >= cp->path_dll_length) |
1299 | { | 1308 | { |
1300 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1309 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1301 | "Asked to look for paths at distance %u, but maximum for me is < %u\n", | 1310 | "Asked to look for paths at distance %u, but maximum for me is < %u\n", |
1302 | dist, | 1311 | dist, |
1303 | cp->path_dll_length); | 1312 | cp->path_dll_length); |
1304 | return 0; | 1313 | return 0; |
1305 | } | 1314 | } |
1306 | for (struct CadetPeerPathEntry *pe = cp->path_heads[dist]; | 1315 | for (struct CadetPeerPathEntry *pe = cp->path_heads[dist]; |
1307 | NULL != pe; | 1316 | NULL != pe; |
1308 | pe = pe->next) | 1317 | pe = pe->next) |
1309 | { | 1318 | { |
1310 | if (GNUNET_NO == | 1319 | if (GNUNET_NO == |
1311 | callback(callback_cls, | 1320 | callback (callback_cls, |
1312 | pe->path, | 1321 | pe->path, |
1313 | dist)) | 1322 | dist)) |
1314 | return ret; | 1323 | return ret; |
1315 | ret++; | 1324 | ret++; |
1316 | } | 1325 | } |
1317 | return ret; | 1326 | return ret; |
1318 | } | 1327 | } |
1319 | 1328 | ||
@@ -1326,16 +1335,16 @@ GCP_iterate_paths_at(struct CadetPeer *cp, | |||
1326 | * @return Tunnel towards peer. | 1335 | * @return Tunnel towards peer. |
1327 | */ | 1336 | */ |
1328 | struct CadetTunnel * | 1337 | struct CadetTunnel * |
1329 | GCP_get_tunnel(struct CadetPeer *cp, | 1338 | GCP_get_tunnel (struct CadetPeer *cp, |
1330 | int create) | 1339 | int create) |
1331 | { | 1340 | { |
1332 | if (NULL == cp) | 1341 | if (NULL == cp) |
1333 | return NULL; | 1342 | return NULL; |
1334 | if ((NULL != cp->t) || | 1343 | if ((NULL != cp->t) || |
1335 | (GNUNET_NO == create)) | 1344 | (GNUNET_NO == create)) |
1336 | return cp->t; | 1345 | return cp->t; |
1337 | cp->t = GCT_create_tunnel(cp); | 1346 | cp->t = GCT_create_tunnel (cp); |
1338 | consider_peer_activate(cp); | 1347 | consider_peer_activate (cp); |
1339 | return cp->t; | 1348 | return cp->t; |
1340 | } | 1349 | } |
1341 | 1350 | ||
@@ -1347,7 +1356,7 @@ GCP_get_tunnel(struct CadetPeer *cp, | |||
1347 | * @param cls the `struct CadetPeer` where the offer completed | 1356 | * @param cls the `struct CadetPeer` where the offer completed |
1348 | */ | 1357 | */ |
1349 | static void | 1358 | static void |
1350 | hello_offer_done(void *cls) | 1359 | hello_offer_done (void *cls) |
1351 | { | 1360 | { |
1352 | struct CadetPeer *cp = cls; | 1361 | struct CadetPeer *cp = cls; |
1353 | 1362 | ||
@@ -1363,39 +1372,39 @@ hello_offer_done(void *cls) | |||
1363 | * @param hello the HELLO to remember | 1372 | * @param hello the HELLO to remember |
1364 | */ | 1373 | */ |
1365 | void | 1374 | void |
1366 | GCP_set_hello(struct CadetPeer *cp, | 1375 | GCP_set_hello (struct CadetPeer *cp, |
1367 | const struct GNUNET_HELLO_Message *hello) | 1376 | const struct GNUNET_HELLO_Message *hello) |
1368 | { | 1377 | { |
1369 | struct GNUNET_HELLO_Message *mrg; | 1378 | struct GNUNET_HELLO_Message *mrg; |
1370 | 1379 | ||
1371 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1380 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1372 | "Got %u byte HELLO for peer %s\n", | 1381 | "Got %u byte HELLO for peer %s\n", |
1373 | (unsigned int)GNUNET_HELLO_size(hello), | 1382 | (unsigned int) GNUNET_HELLO_size (hello), |
1374 | GCP_2s(cp)); | 1383 | GCP_2s (cp)); |
1375 | if (NULL != cp->hello_offer) | 1384 | if (NULL != cp->hello_offer) |
1376 | { | 1385 | { |
1377 | GNUNET_TRANSPORT_offer_hello_cancel(cp->hello_offer); | 1386 | GNUNET_TRANSPORT_offer_hello_cancel (cp->hello_offer); |
1378 | cp->hello_offer = NULL; | 1387 | cp->hello_offer = NULL; |
1379 | } | 1388 | } |
1380 | if (NULL != cp->hello) | 1389 | if (NULL != cp->hello) |
1381 | { | 1390 | { |
1382 | mrg = GNUNET_HELLO_merge(hello, | 1391 | mrg = GNUNET_HELLO_merge (hello, |
1383 | cp->hello); | 1392 | cp->hello); |
1384 | GNUNET_free(cp->hello); | 1393 | GNUNET_free (cp->hello); |
1385 | cp->hello = mrg; | 1394 | cp->hello = mrg; |
1386 | } | 1395 | } |
1387 | else | 1396 | else |
1388 | { | 1397 | { |
1389 | cp->hello = GNUNET_memdup(hello, | 1398 | cp->hello = GNUNET_memdup (hello, |
1390 | GNUNET_HELLO_size(hello)); | 1399 | GNUNET_HELLO_size (hello)); |
1391 | } | 1400 | } |
1392 | cp->hello_offer | 1401 | cp->hello_offer |
1393 | = GNUNET_TRANSPORT_offer_hello(cfg, | 1402 | = GNUNET_TRANSPORT_offer_hello (cfg, |
1394 | GNUNET_HELLO_get_header(cp->hello), | 1403 | GNUNET_HELLO_get_header (cp->hello), |
1395 | &hello_offer_done, | 1404 | &hello_offer_done, |
1396 | cp); | 1405 | cp); |
1397 | /* New HELLO means cp's destruction time may change... */ | 1406 | /* New HELLO means cp's destruction time may change... */ |
1398 | consider_peer_destroy(cp); | 1407 | consider_peer_destroy (cp); |
1399 | } | 1408 | } |
1400 | 1409 | ||
1401 | 1410 | ||
@@ -1407,16 +1416,16 @@ GCP_set_hello(struct CadetPeer *cp, | |||
1407 | * @param t the dead tunnel | 1416 | * @param t the dead tunnel |
1408 | */ | 1417 | */ |
1409 | void | 1418 | void |
1410 | GCP_drop_tunnel(struct CadetPeer *cp, | 1419 | GCP_drop_tunnel (struct CadetPeer *cp, |
1411 | struct CadetTunnel *t) | 1420 | struct CadetTunnel *t) |
1412 | { | 1421 | { |
1413 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1422 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1414 | "Dropping tunnel %s to peer %s\n", | 1423 | "Dropping tunnel %s to peer %s\n", |
1415 | GCT_2s(t), | 1424 | GCT_2s (t), |
1416 | GCP_2s(cp)); | 1425 | GCP_2s (cp)); |
1417 | GNUNET_assert(cp->t == t); | 1426 | GNUNET_assert (cp->t == t); |
1418 | cp->t = NULL; | 1427 | cp->t = NULL; |
1419 | consider_peer_destroy(cp); | 1428 | consider_peer_destroy (cp); |
1420 | } | 1429 | } |
1421 | 1430 | ||
1422 | 1431 | ||
@@ -1427,7 +1436,7 @@ GCP_drop_tunnel(struct CadetPeer *cp, | |||
1427 | * @return #GNUNET_YES if @a cp has a core-level connection | 1436 | * @return #GNUNET_YES if @a cp has a core-level connection |
1428 | */ | 1437 | */ |
1429 | int | 1438 | int |
1430 | GCP_has_core_connection(struct CadetPeer *cp) | 1439 | GCP_has_core_connection (struct CadetPeer *cp) |
1431 | { | 1440 | { |
1432 | return (NULL != cp->core_mq) ? GNUNET_YES : GNUNET_NO; | 1441 | return (NULL != cp->core_mq) ? GNUNET_YES : GNUNET_NO; |
1433 | } | 1442 | } |
@@ -1442,26 +1451,26 @@ GCP_has_core_connection(struct CadetPeer *cp) | |||
1442 | * @return handle to cancel request | 1451 | * @return handle to cancel request |
1443 | */ | 1452 | */ |
1444 | struct GCP_MessageQueueManager * | 1453 | struct GCP_MessageQueueManager * |
1445 | GCP_request_mq(struct CadetPeer *cp, | 1454 | GCP_request_mq (struct CadetPeer *cp, |
1446 | GCP_MessageQueueNotificationCallback cb, | 1455 | GCP_MessageQueueNotificationCallback cb, |
1447 | void *cb_cls) | 1456 | void *cb_cls) |
1448 | { | 1457 | { |
1449 | struct GCP_MessageQueueManager *mqm; | 1458 | struct GCP_MessageQueueManager *mqm; |
1450 | 1459 | ||
1451 | mqm = GNUNET_new(struct GCP_MessageQueueManager); | 1460 | mqm = GNUNET_new (struct GCP_MessageQueueManager); |
1452 | mqm->cb = cb; | 1461 | mqm->cb = cb; |
1453 | mqm->cb_cls = cb_cls; | 1462 | mqm->cb_cls = cb_cls; |
1454 | mqm->cp = cp; | 1463 | mqm->cp = cp; |
1455 | GNUNET_CONTAINER_DLL_insert(cp->mqm_head, | 1464 | GNUNET_CONTAINER_DLL_insert (cp->mqm_head, |
1456 | cp->mqm_tail, | 1465 | cp->mqm_tail, |
1457 | mqm); | 1466 | mqm); |
1458 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1467 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1459 | "Creating MQM %p for peer %s\n", | 1468 | "Creating MQM %p for peer %s\n", |
1460 | mqm, | 1469 | mqm, |
1461 | GCP_2s(cp)); | 1470 | GCP_2s (cp)); |
1462 | if (NULL != cp->core_mq) | 1471 | if (NULL != cp->core_mq) |
1463 | cb(cb_cls, | 1472 | cb (cb_cls, |
1464 | GNUNET_YES); | 1473 | GNUNET_YES); |
1465 | return mqm; | 1474 | return mqm; |
1466 | } | 1475 | } |
1467 | 1476 | ||
@@ -1473,39 +1482,39 @@ GCP_request_mq(struct CadetPeer *cp, | |||
1473 | * @param last_env final message to transmit, or NULL | 1482 | * @param last_env final message to transmit, or NULL |
1474 | */ | 1483 | */ |
1475 | void | 1484 | void |
1476 | GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, | 1485 | GCP_request_mq_cancel (struct GCP_MessageQueueManager *mqm, |
1477 | struct GNUNET_MQ_Envelope *last_env) | 1486 | struct GNUNET_MQ_Envelope *last_env) |
1478 | { | 1487 | { |
1479 | struct CadetPeer *cp = mqm->cp; | 1488 | struct CadetPeer *cp = mqm->cp; |
1480 | 1489 | ||
1481 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1490 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1482 | "Destroying MQM %p for peer %s%s\n", | 1491 | "Destroying MQM %p for peer %s%s\n", |
1483 | mqm, | 1492 | mqm, |
1484 | GCP_2s(cp), | 1493 | GCP_2s (cp), |
1485 | (NULL == last_env) ? "" : " with last ditch transmission"); | 1494 | (NULL == last_env) ? "" : " with last ditch transmission"); |
1486 | if (NULL != mqm->env) | 1495 | if (NULL != mqm->env) |
1487 | GNUNET_MQ_discard(mqm->env); | 1496 | GNUNET_MQ_discard (mqm->env); |
1488 | if (NULL != last_env) | 1497 | if (NULL != last_env) |
1498 | { | ||
1499 | if (NULL != cp->core_mq) | ||
1489 | { | 1500 | { |
1490 | if (NULL != cp->core_mq) | 1501 | GNUNET_MQ_notify_sent (last_env, |
1491 | { | 1502 | &mqm_send_done, |
1492 | GNUNET_MQ_notify_sent(last_env, | 1503 | cp); |
1493 | &mqm_send_done, | 1504 | GNUNET_MQ_send (cp->core_mq, |
1494 | cp); | 1505 | last_env); |
1495 | GNUNET_MQ_send(cp->core_mq, | ||
1496 | last_env); | ||
1497 | } | ||
1498 | else | ||
1499 | { | ||
1500 | GNUNET_MQ_discard(last_env); | ||
1501 | } | ||
1502 | } | 1506 | } |
1507 | else | ||
1508 | { | ||
1509 | GNUNET_MQ_discard (last_env); | ||
1510 | } | ||
1511 | } | ||
1503 | if (cp->mqm_ready_ptr == mqm) | 1512 | if (cp->mqm_ready_ptr == mqm) |
1504 | cp->mqm_ready_ptr = mqm->next; | 1513 | cp->mqm_ready_ptr = mqm->next; |
1505 | GNUNET_CONTAINER_DLL_remove(cp->mqm_head, | 1514 | GNUNET_CONTAINER_DLL_remove (cp->mqm_head, |
1506 | cp->mqm_tail, | 1515 | cp->mqm_tail, |
1507 | mqm); | 1516 | mqm); |
1508 | GNUNET_free(mqm); | 1517 | GNUNET_free (mqm); |
1509 | } | 1518 | } |
1510 | 1519 | ||
1511 | 1520 | ||
@@ -1519,27 +1528,27 @@ GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, | |||
1519 | * @param env envelope with the message to send | 1528 | * @param env envelope with the message to send |
1520 | */ | 1529 | */ |
1521 | void | 1530 | void |
1522 | GCP_send_ooo(struct CadetPeer *cp, | 1531 | GCP_send_ooo (struct CadetPeer *cp, |
1523 | struct GNUNET_MQ_Envelope *env) | 1532 | struct GNUNET_MQ_Envelope *env) |
1524 | { | 1533 | { |
1525 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1534 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1526 | "Sending message to %s out of management\n", | 1535 | "Sending message to %s out of management\n", |
1527 | GCP_2s(cp)); | 1536 | GCP_2s (cp)); |
1528 | if (NULL == cp->core_mq) | 1537 | if (NULL == cp->core_mq) |
1529 | { | 1538 | { |
1530 | GNUNET_MQ_discard(env); | 1539 | GNUNET_MQ_discard (env); |
1531 | return; | 1540 | return; |
1532 | } | 1541 | } |
1533 | if (GNUNET_MQ_get_length(cp->core_mq) > MAX_OOO_QUEUE_SIZE) | 1542 | if (GNUNET_MQ_get_length (cp->core_mq) > MAX_OOO_QUEUE_SIZE) |
1534 | { | 1543 | { |
1535 | GNUNET_MQ_discard(env); | 1544 | GNUNET_MQ_discard (env); |
1536 | return; | 1545 | return; |
1537 | } | 1546 | } |
1538 | GNUNET_MQ_notify_sent(env, | 1547 | GNUNET_MQ_notify_sent (env, |
1539 | &mqm_send_done, | 1548 | &mqm_send_done, |
1540 | cp); | 1549 | cp); |
1541 | GNUNET_MQ_send(cp->core_mq, | 1550 | GNUNET_MQ_send (cp->core_mq, |
1542 | env); | 1551 | env); |
1543 | } | 1552 | } |
1544 | 1553 | ||
1545 | 1554 | ||
diff --git a/src/cadet/gnunet-service-cadet_peer.h b/src/cadet/gnunet-service-cadet_peer.h index 09c6f64c9..bec0606a0 100644 --- a/src/cadet/gnunet-service-cadet_peer.h +++ b/src/cadet/gnunet-service-cadet_peer.h | |||
@@ -39,7 +39,7 @@ | |||
39 | * @return Static string for it's ID. | 39 | * @return Static string for it's ID. |
40 | */ | 40 | */ |
41 | const char * | 41 | const char * |
42 | GCP_2s(const struct CadetPeer *peer); | 42 | GCP_2s (const struct CadetPeer *peer); |
43 | 43 | ||
44 | 44 | ||
45 | /** | 45 | /** |
@@ -54,8 +54,8 @@ GCP_2s(const struct CadetPeer *peer); | |||
54 | * NULL if unknown and not requested @a create | 54 | * NULL if unknown and not requested @a create |
55 | */ | 55 | */ |
56 | struct CadetPeer * | 56 | struct CadetPeer * |
57 | GCP_get(const struct GNUNET_PeerIdentity *peer_id, | 57 | GCP_get (const struct GNUNET_PeerIdentity *peer_id, |
58 | int create); | 58 | int create); |
59 | 59 | ||
60 | 60 | ||
61 | /** | 61 | /** |
@@ -68,8 +68,8 @@ GCP_get(const struct GNUNET_PeerIdentity *peer_id, | |||
68 | * positive scores mean path is more desirable | 68 | * positive scores mean path is more desirable |
69 | */ | 69 | */ |
70 | double | 70 | double |
71 | GCP_get_desirability_of_path(struct CadetPeer *cp, | 71 | GCP_get_desirability_of_path (struct CadetPeer *cp, |
72 | unsigned int off); | 72 | unsigned int off); |
73 | 73 | ||
74 | 74 | ||
75 | /** | 75 | /** |
@@ -79,7 +79,7 @@ GCP_get_desirability_of_path(struct CadetPeer *cp, | |||
79 | * @return the peer identity | 79 | * @return the peer identity |
80 | */ | 80 | */ |
81 | const struct GNUNET_PeerIdentity * | 81 | const struct GNUNET_PeerIdentity * |
82 | GCP_get_id(struct CadetPeer *cp); | 82 | GCP_get_id (struct CadetPeer *cp); |
83 | 83 | ||
84 | 84 | ||
85 | /** | 85 | /** |
@@ -89,8 +89,8 @@ GCP_get_id(struct CadetPeer *cp); | |||
89 | * @param cls Closure for @c iter. | 89 | * @param cls Closure for @c iter. |
90 | */ | 90 | */ |
91 | void | 91 | void |
92 | GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, | 92 | GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, |
93 | void *cls); | 93 | void *cls); |
94 | 94 | ||
95 | 95 | ||
96 | /** | 96 | /** |
@@ -100,7 +100,7 @@ GCP_iterate_all(GNUNET_CONTAINER_PeerMapIterator iter, | |||
100 | * @return Number of known paths. | 100 | * @return Number of known paths. |
101 | */ | 101 | */ |
102 | unsigned int | 102 | unsigned int |
103 | GCP_count_paths(const struct CadetPeer *cp); | 103 | GCP_count_paths (const struct CadetPeer *cp); |
104 | 104 | ||
105 | 105 | ||
106 | /** | 106 | /** |
@@ -110,7 +110,7 @@ GCP_count_paths(const struct CadetPeer *cp); | |||
110 | * @param cp peer to drop paths to | 110 | * @param cp peer to drop paths to |
111 | */ | 111 | */ |
112 | void | 112 | void |
113 | GCP_drop_owned_paths(struct CadetPeer *cp); | 113 | GCP_drop_owned_paths (struct CadetPeer *cp); |
114 | 114 | ||
115 | 115 | ||
116 | /** | 116 | /** |
@@ -137,9 +137,9 @@ typedef int | |||
137 | * @return Number of iterated paths. | 137 | * @return Number of iterated paths. |
138 | */ | 138 | */ |
139 | unsigned int | 139 | unsigned int |
140 | GCP_iterate_paths(struct CadetPeer *cp, | 140 | GCP_iterate_paths (struct CadetPeer *cp, |
141 | GCP_PathIterator callback, | 141 | GCP_PathIterator callback, |
142 | void *callback_cls); | 142 | void *callback_cls); |
143 | 143 | ||
144 | /** | 144 | /** |
145 | * Iterate over the paths to a peer without direct link. | 145 | * Iterate over the paths to a peer without direct link. |
@@ -150,9 +150,9 @@ GCP_iterate_paths(struct CadetPeer *cp, | |||
150 | * @return Number of iterated paths. | 150 | * @return Number of iterated paths. |
151 | */ | 151 | */ |
152 | unsigned int | 152 | unsigned int |
153 | GCP_iterate_indirect_paths(struct CadetPeer *cp, | 153 | GCP_iterate_indirect_paths (struct CadetPeer *cp, |
154 | GCP_PathIterator callback, | 154 | GCP_PathIterator callback, |
155 | void *callback_cls); | 155 | void *callback_cls); |
156 | 156 | ||
157 | 157 | ||
158 | /** | 158 | /** |
@@ -166,10 +166,10 @@ GCP_iterate_indirect_paths(struct CadetPeer *cp, | |||
166 | * @return Number of iterated paths. | 166 | * @return Number of iterated paths. |
167 | */ | 167 | */ |
168 | unsigned int | 168 | unsigned int |
169 | GCP_iterate_paths_at(struct CadetPeer *cp, | 169 | GCP_iterate_paths_at (struct CadetPeer *cp, |
170 | unsigned int dist, | 170 | unsigned int dist, |
171 | GCP_PathIterator callback, | 171 | GCP_PathIterator callback, |
172 | void *callback_cls); | 172 | void *callback_cls); |
173 | 173 | ||
174 | 174 | ||
175 | /** | 175 | /** |
@@ -180,9 +180,9 @@ GCP_iterate_paths_at(struct CadetPeer *cp, | |||
180 | * @param off offset of this peer on the path | 180 | * @param off offset of this peer on the path |
181 | */ | 181 | */ |
182 | void | 182 | void |
183 | GCP_path_entry_remove(struct CadetPeer *cp, | 183 | GCP_path_entry_remove (struct CadetPeer *cp, |
184 | struct CadetPeerPathEntry *entry, | 184 | struct CadetPeerPathEntry *entry, |
185 | unsigned int off); | 185 | unsigned int off); |
186 | 186 | ||
187 | 187 | ||
188 | /** | 188 | /** |
@@ -193,9 +193,9 @@ GCP_path_entry_remove(struct CadetPeer *cp, | |||
193 | * @param off offset of this peer on the path | 193 | * @param off offset of this peer on the path |
194 | */ | 194 | */ |
195 | void | 195 | void |
196 | GCP_path_entry_add(struct CadetPeer *cp, | 196 | GCP_path_entry_add (struct CadetPeer *cp, |
197 | struct CadetPeerPathEntry *entry, | 197 | struct CadetPeerPathEntry *entry, |
198 | unsigned int off); | 198 | unsigned int off); |
199 | 199 | ||
200 | 200 | ||
201 | /** | 201 | /** |
@@ -206,8 +206,8 @@ GCP_path_entry_add(struct CadetPeer *cp, | |||
206 | * @return Tunnel towards peer. | 206 | * @return Tunnel towards peer. |
207 | */ | 207 | */ |
208 | struct CadetTunnel * | 208 | struct CadetTunnel * |
209 | GCP_get_tunnel(struct CadetPeer *cp, | 209 | GCP_get_tunnel (struct CadetPeer *cp, |
210 | int create); | 210 | int create); |
211 | 211 | ||
212 | 212 | ||
213 | /** | 213 | /** |
@@ -218,8 +218,8 @@ GCP_get_tunnel(struct CadetPeer *cp, | |||
218 | * @param t the dead tunnel | 218 | * @param t the dead tunnel |
219 | */ | 219 | */ |
220 | void | 220 | void |
221 | GCP_drop_tunnel(struct CadetPeer *cp, | 221 | GCP_drop_tunnel (struct CadetPeer *cp, |
222 | struct CadetTunnel *t); | 222 | struct CadetTunnel *t); |
223 | 223 | ||
224 | 224 | ||
225 | /** | 225 | /** |
@@ -234,10 +234,10 @@ GCP_drop_tunnel(struct CadetPeer *cp, | |||
234 | * otherwise the node in the peer's path heap for the @a path. | 234 | * otherwise the node in the peer's path heap for the @a path. |
235 | */ | 235 | */ |
236 | struct GNUNET_CONTAINER_HeapNode * | 236 | struct GNUNET_CONTAINER_HeapNode * |
237 | GCP_attach_path(struct CadetPeer *cp, | 237 | GCP_attach_path (struct CadetPeer *cp, |
238 | struct CadetPeerPath *path, | 238 | struct CadetPeerPath *path, |
239 | unsigned int off, | 239 | unsigned int off, |
240 | int force); | 240 | int force); |
241 | 241 | ||
242 | 242 | ||
243 | /** | 243 | /** |
@@ -250,9 +250,9 @@ GCP_attach_path(struct CadetPeer *cp, | |||
250 | * @param hn note in @a cp's path heap that must be deleted | 250 | * @param hn note in @a cp's path heap that must be deleted |
251 | */ | 251 | */ |
252 | void | 252 | void |
253 | GCP_detach_path(struct CadetPeer *cp, | 253 | GCP_detach_path (struct CadetPeer *cp, |
254 | struct CadetPeerPath *path, | 254 | struct CadetPeerPath *path, |
255 | struct GNUNET_CONTAINER_HeapNode *hn); | 255 | struct GNUNET_CONTAINER_HeapNode *hn); |
256 | 256 | ||
257 | 257 | ||
258 | /** | 258 | /** |
@@ -262,8 +262,8 @@ GCP_detach_path(struct CadetPeer *cp, | |||
262 | * @param cc the connection to add | 262 | * @param cc the connection to add |
263 | */ | 263 | */ |
264 | void | 264 | void |
265 | GCP_add_connection(struct CadetPeer *cp, | 265 | GCP_add_connection (struct CadetPeer *cp, |
266 | struct CadetConnection *cc); | 266 | struct CadetConnection *cc); |
267 | 267 | ||
268 | 268 | ||
269 | /** | 269 | /** |
@@ -273,8 +273,8 @@ GCP_add_connection(struct CadetPeer *cp, | |||
273 | * @param cc the connection to remove | 273 | * @param cc the connection to remove |
274 | */ | 274 | */ |
275 | void | 275 | void |
276 | GCP_remove_connection(struct CadetPeer *cp, | 276 | GCP_remove_connection (struct CadetPeer *cp, |
277 | struct CadetConnection *cc); | 277 | struct CadetConnection *cc); |
278 | 278 | ||
279 | 279 | ||
280 | /** | 280 | /** |
@@ -285,8 +285,8 @@ GCP_remove_connection(struct CadetPeer *cp, | |||
285 | * @param hello the HELLO to remember | 285 | * @param hello the HELLO to remember |
286 | */ | 286 | */ |
287 | void | 287 | void |
288 | GCP_set_hello(struct CadetPeer *cp, | 288 | GCP_set_hello (struct CadetPeer *cp, |
289 | const struct GNUNET_HELLO_Message *hello); | 289 | const struct GNUNET_HELLO_Message *hello); |
290 | 290 | ||
291 | 291 | ||
292 | /** | 292 | /** |
@@ -295,7 +295,7 @@ GCP_set_hello(struct CadetPeer *cp, | |||
295 | * connections are down. | 295 | * connections are down. |
296 | */ | 296 | */ |
297 | void | 297 | void |
298 | GCP_destroy_all_peers(void); | 298 | GCP_destroy_all_peers (void); |
299 | 299 | ||
300 | 300 | ||
301 | /** | 301 | /** |
@@ -334,9 +334,9 @@ typedef void | |||
334 | * @return handle to cancel request | 334 | * @return handle to cancel request |
335 | */ | 335 | */ |
336 | struct GCP_MessageQueueManager * | 336 | struct GCP_MessageQueueManager * |
337 | GCP_request_mq(struct CadetPeer *cp, | 337 | GCP_request_mq (struct CadetPeer *cp, |
338 | GCP_MessageQueueNotificationCallback cb, | 338 | GCP_MessageQueueNotificationCallback cb, |
339 | void *cb_cls); | 339 | void *cb_cls); |
340 | 340 | ||
341 | 341 | ||
342 | /** | 342 | /** |
@@ -346,7 +346,7 @@ GCP_request_mq(struct CadetPeer *cp, | |||
346 | * @return #GNUNET_YES if @a cp has a core-level connection | 346 | * @return #GNUNET_YES if @a cp has a core-level connection |
347 | */ | 347 | */ |
348 | int | 348 | int |
349 | GCP_has_core_connection(struct CadetPeer *cp); | 349 | GCP_has_core_connection (struct CadetPeer *cp); |
350 | 350 | ||
351 | 351 | ||
352 | /** | 352 | /** |
@@ -361,8 +361,8 @@ GCP_has_core_connection(struct CadetPeer *cp); | |||
361 | * yet have a #GNUNET_MQ_notify_sent() callback attached to it | 361 | * yet have a #GNUNET_MQ_notify_sent() callback attached to it |
362 | */ | 362 | */ |
363 | void | 363 | void |
364 | GCP_send(struct GCP_MessageQueueManager *mqm, | 364 | GCP_send (struct GCP_MessageQueueManager *mqm, |
365 | struct GNUNET_MQ_Envelope *env); | 365 | struct GNUNET_MQ_Envelope *env); |
366 | 366 | ||
367 | 367 | ||
368 | /** | 368 | /** |
@@ -375,8 +375,8 @@ GCP_send(struct GCP_MessageQueueManager *mqm, | |||
375 | * @param env envelope with the message to send | 375 | * @param env envelope with the message to send |
376 | */ | 376 | */ |
377 | void | 377 | void |
378 | GCP_send_ooo(struct CadetPeer *cp, | 378 | GCP_send_ooo (struct CadetPeer *cp, |
379 | struct GNUNET_MQ_Envelope *env); | 379 | struct GNUNET_MQ_Envelope *env); |
380 | 380 | ||
381 | 381 | ||
382 | /** | 382 | /** |
@@ -388,8 +388,8 @@ GCP_send_ooo(struct CadetPeer *cp, | |||
388 | * @param last_env final message to transmit, or NULL | 388 | * @param last_env final message to transmit, or NULL |
389 | */ | 389 | */ |
390 | void | 390 | void |
391 | GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, | 391 | GCP_request_mq_cancel (struct GCP_MessageQueueManager *mqm, |
392 | struct GNUNET_MQ_Envelope *last_env); | 392 | struct GNUNET_MQ_Envelope *last_env); |
393 | 393 | ||
394 | 394 | ||
395 | /** | 395 | /** |
@@ -399,8 +399,8 @@ GCP_request_mq_cancel(struct GCP_MessageQueueManager *mqm, | |||
399 | * @param mq message queue to set (can be NULL) | 399 | * @param mq message queue to set (can be NULL) |
400 | */ | 400 | */ |
401 | void | 401 | void |
402 | GCP_set_mq(struct CadetPeer *cp, | 402 | GCP_set_mq (struct CadetPeer *cp, |
403 | struct GNUNET_MQ_Handle *mq); | 403 | struct GNUNET_MQ_Handle *mq); |
404 | 404 | ||
405 | 405 | ||
406 | #endif | 406 | #endif |
diff --git a/src/cadet/gnunet-service-cadet_tunnels.c b/src/cadet/gnunet-service-cadet_tunnels.c index c73f8cdbe..6f2dd1d8d 100644 --- a/src/cadet/gnunet-service-cadet_tunnels.c +++ b/src/cadet/gnunet-service-cadet_tunnels.c | |||
@@ -42,7 +42,7 @@ | |||
42 | #include "gnunet-service-cadet_paths.h" | 42 | #include "gnunet-service-cadet_paths.h" |
43 | 43 | ||
44 | 44 | ||
45 | #define LOG(level, ...) GNUNET_log_from(level, "cadet-tun", __VA_ARGS__) | 45 | #define LOG(level, ...) GNUNET_log_from (level, "cadet-tun", __VA_ARGS__) |
46 | 46 | ||
47 | /** | 47 | /** |
48 | * How often do we try to decrypt payload with unverified key | 48 | * How often do we try to decrypt payload with unverified key |
@@ -54,13 +54,15 @@ | |||
54 | /** | 54 | /** |
55 | * How long do we wait until tearing down an idle tunnel? | 55 | * How long do we wait until tearing down an idle tunnel? |
56 | */ | 56 | */ |
57 | #define IDLE_DESTROY_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90) | 57 | #define IDLE_DESTROY_DELAY GNUNET_TIME_relative_multiply ( \ |
58 | GNUNET_TIME_UNIT_SECONDS, 90) | ||
58 | 59 | ||
59 | /** | 60 | /** |
60 | * How long do we wait initially before retransmitting the KX? | 61 | * How long do we wait initially before retransmitting the KX? |
61 | * TODO: replace by 2 RTT if/once we have connection-level RTT data! | 62 | * TODO: replace by 2 RTT if/once we have connection-level RTT data! |
62 | */ | 63 | */ |
63 | #define INITIAL_KX_RETRY_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250) | 64 | #define INITIAL_KX_RETRY_DELAY GNUNET_TIME_relative_multiply ( \ |
65 | GNUNET_TIME_UNIT_MILLISECONDS, 250) | ||
64 | 66 | ||
65 | /** | 67 | /** |
66 | * Maximum number of skipped keys we keep in memory per tunnel. | 68 | * Maximum number of skipped keys we keep in memory per tunnel. |
@@ -77,7 +79,8 @@ | |||
77 | /** | 79 | /** |
78 | * Struct to old keys for skipped messages while advancing the Axolotl ratchet. | 80 | * Struct to old keys for skipped messages while advancing the Axolotl ratchet. |
79 | */ | 81 | */ |
80 | struct CadetTunnelSkippedKey { | 82 | struct CadetTunnelSkippedKey |
83 | { | ||
81 | /** | 84 | /** |
82 | * DLL next. | 85 | * DLL next. |
83 | */ | 86 | */ |
@@ -113,7 +116,8 @@ struct CadetTunnelSkippedKey { | |||
113 | /** | 116 | /** |
114 | * Axolotl data, according to https://github.com/trevp/axolotl/wiki . | 117 | * Axolotl data, according to https://github.com/trevp/axolotl/wiki . |
115 | */ | 118 | */ |
116 | struct CadetTunnelAxolotl { | 119 | struct CadetTunnelAxolotl |
120 | { | ||
117 | /** | 121 | /** |
118 | * A (double linked) list of stored message keys and associated header keys | 122 | * A (double linked) list of stored message keys and associated header keys |
119 | * for "skipped" messages, i.e. messages that have not been | 123 | * for "skipped" messages, i.e. messages that have not been |
@@ -252,7 +256,8 @@ struct CadetTunnelAxolotl { | |||
252 | /** | 256 | /** |
253 | * Struct used to save messages in a non-ready tunnel to send once connected. | 257 | * Struct used to save messages in a non-ready tunnel to send once connected. |
254 | */ | 258 | */ |
255 | struct CadetTunnelQueueEntry { | 259 | struct CadetTunnelQueueEntry |
260 | { | ||
256 | /** | 261 | /** |
257 | * We are entries in a DLL | 262 | * We are entries in a DLL |
258 | */ | 263 | */ |
@@ -294,7 +299,8 @@ struct CadetTunnelQueueEntry { | |||
294 | /** | 299 | /** |
295 | * Struct containing all information regarding a tunnel to a peer. | 300 | * Struct containing all information regarding a tunnel to a peer. |
296 | */ | 301 | */ |
297 | struct CadetTunnel { | 302 | struct CadetTunnel |
303 | { | ||
298 | /** | 304 | /** |
299 | * Destination of the tunnel. | 305 | * Destination of the tunnel. |
300 | */ | 306 | */ |
@@ -459,19 +465,19 @@ struct CadetTunnel { | |||
459 | * @return #GNUNET_YES for Alice, #GNUNET_NO for Betty, #GNUNET_SYSERR if talking to myself | 465 | * @return #GNUNET_YES for Alice, #GNUNET_NO for Betty, #GNUNET_SYSERR if talking to myself |
460 | */ | 466 | */ |
461 | static int | 467 | static int |
462 | alice_or_betty(const struct GNUNET_PeerIdentity *other) | 468 | alice_or_betty (const struct GNUNET_PeerIdentity *other) |
463 | { | 469 | { |
464 | if (0 > GNUNET_memcmp(&my_full_id, | 470 | if (0 > GNUNET_memcmp (&my_full_id, |
465 | other)) | 471 | other)) |
466 | return GNUNET_YES; | 472 | return GNUNET_YES; |
467 | else if (0 < GNUNET_memcmp(&my_full_id, | 473 | else if (0 < GNUNET_memcmp (&my_full_id, |
468 | other)) | 474 | other)) |
469 | return GNUNET_NO; | 475 | return GNUNET_NO; |
470 | else | 476 | else |
471 | { | 477 | { |
472 | GNUNET_break_op(0); | 478 | GNUNET_break_op (0); |
473 | return GNUNET_SYSERR; | 479 | return GNUNET_SYSERR; |
474 | } | 480 | } |
475 | } | 481 | } |
476 | 482 | ||
477 | 483 | ||
@@ -482,20 +488,20 @@ alice_or_betty(const struct GNUNET_PeerIdentity *other) | |||
482 | * @param ct connection to move to unready status | 488 | * @param ct connection to move to unready status |
483 | */ | 489 | */ |
484 | static void | 490 | static void |
485 | mark_connection_unready(struct CadetTConnection *ct) | 491 | mark_connection_unready (struct CadetTConnection *ct) |
486 | { | 492 | { |
487 | struct CadetTunnel *t = ct->t; | 493 | struct CadetTunnel *t = ct->t; |
488 | 494 | ||
489 | GNUNET_assert(GNUNET_YES == ct->is_ready); | 495 | GNUNET_assert (GNUNET_YES == ct->is_ready); |
490 | GNUNET_CONTAINER_DLL_remove(t->connection_ready_head, | 496 | GNUNET_CONTAINER_DLL_remove (t->connection_ready_head, |
491 | t->connection_ready_tail, | 497 | t->connection_ready_tail, |
492 | ct); | 498 | ct); |
493 | GNUNET_assert(0 < t->num_ready_connections); | 499 | GNUNET_assert (0 < t->num_ready_connections); |
494 | t->num_ready_connections--; | 500 | t->num_ready_connections--; |
495 | ct->is_ready = GNUNET_NO; | 501 | ct->is_ready = GNUNET_NO; |
496 | GNUNET_CONTAINER_DLL_insert(t->connection_busy_head, | 502 | GNUNET_CONTAINER_DLL_insert (t->connection_busy_head, |
497 | t->connection_busy_tail, | 503 | t->connection_busy_tail, |
498 | ct); | 504 | ct); |
499 | t->num_busy_connections++; | 505 | t->num_busy_connections++; |
500 | } | 506 | } |
501 | 507 | ||
@@ -508,16 +514,16 @@ mark_connection_unready(struct CadetTConnection *ct) | |||
508 | * @return Static string the destination peer's ID. | 514 | * @return Static string the destination peer's ID. |
509 | */ | 515 | */ |
510 | const char * | 516 | const char * |
511 | GCT_2s(const struct CadetTunnel *t) | 517 | GCT_2s (const struct CadetTunnel *t) |
512 | { | 518 | { |
513 | static char buf[64]; | 519 | static char buf[64]; |
514 | 520 | ||
515 | if (NULL == t) | 521 | if (NULL == t) |
516 | return "Tunnel(NULL)"; | 522 | return "Tunnel(NULL)"; |
517 | GNUNET_snprintf(buf, | 523 | GNUNET_snprintf (buf, |
518 | sizeof(buf), | 524 | sizeof(buf), |
519 | "Tunnel %s", | 525 | "Tunnel %s", |
520 | GNUNET_i2s(GCP_get_id(t->destination))); | 526 | GNUNET_i2s (GCP_get_id (t->destination))); |
521 | return buf; | 527 | return buf; |
522 | } | 528 | } |
523 | 529 | ||
@@ -530,37 +536,37 @@ GCT_2s(const struct CadetTunnel *t) | |||
530 | * @return String representation. | 536 | * @return String representation. |
531 | */ | 537 | */ |
532 | static const char * | 538 | static const char * |
533 | estate2s(enum CadetTunnelEState es) | 539 | estate2s (enum CadetTunnelEState es) |
534 | { | 540 | { |
535 | static char buf[32]; | 541 | static char buf[32]; |
536 | 542 | ||
537 | switch (es) | 543 | switch (es) |
538 | { | 544 | { |
539 | case CADET_TUNNEL_KEY_UNINITIALIZED: | 545 | case CADET_TUNNEL_KEY_UNINITIALIZED: |
540 | return "CADET_TUNNEL_KEY_UNINITIALIZED"; | 546 | return "CADET_TUNNEL_KEY_UNINITIALIZED"; |
541 | 547 | ||
542 | case CADET_TUNNEL_KEY_AX_RECV: | 548 | case CADET_TUNNEL_KEY_AX_RECV: |
543 | return "CADET_TUNNEL_KEY_AX_RECV"; | 549 | return "CADET_TUNNEL_KEY_AX_RECV"; |
544 | 550 | ||
545 | case CADET_TUNNEL_KEY_AX_SENT: | 551 | case CADET_TUNNEL_KEY_AX_SENT: |
546 | return "CADET_TUNNEL_KEY_AX_SENT"; | 552 | return "CADET_TUNNEL_KEY_AX_SENT"; |
547 | 553 | ||
548 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: | 554 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: |
549 | return "CADET_TUNNEL_KEY_AX_SENT_AND_RECV"; | 555 | return "CADET_TUNNEL_KEY_AX_SENT_AND_RECV"; |
550 | 556 | ||
551 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: | 557 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: |
552 | return "CADET_TUNNEL_KEY_AX_AUTH_SENT"; | 558 | return "CADET_TUNNEL_KEY_AX_AUTH_SENT"; |
553 | 559 | ||
554 | case CADET_TUNNEL_KEY_OK: | 560 | case CADET_TUNNEL_KEY_OK: |
555 | return "CADET_TUNNEL_KEY_OK"; | 561 | return "CADET_TUNNEL_KEY_OK"; |
556 | 562 | ||
557 | default: | 563 | default: |
558 | GNUNET_snprintf(buf, | 564 | GNUNET_snprintf (buf, |
559 | sizeof(buf), | 565 | sizeof(buf), |
560 | "%u (UNKNOWN STATE)", | 566 | "%u (UNKNOWN STATE)", |
561 | es); | 567 | es); |
562 | return buf; | 568 | return buf; |
563 | } | 569 | } |
564 | } | 570 | } |
565 | 571 | ||
566 | 572 | ||
@@ -571,7 +577,7 @@ estate2s(enum CadetTunnelEState es) | |||
571 | * @return the destination of the tunnel | 577 | * @return the destination of the tunnel |
572 | */ | 578 | */ |
573 | struct CadetPeer * | 579 | struct CadetPeer * |
574 | GCT_get_destination(struct CadetTunnel *t) | 580 | GCT_get_destination (struct CadetTunnel *t) |
575 | { | 581 | { |
576 | return t->destination; | 582 | return t->destination; |
577 | } | 583 | } |
@@ -585,9 +591,9 @@ GCT_get_destination(struct CadetTunnel *t) | |||
585 | * @return Number of channels. | 591 | * @return Number of channels. |
586 | */ | 592 | */ |
587 | unsigned int | 593 | unsigned int |
588 | GCT_count_channels(struct CadetTunnel *t) | 594 | GCT_count_channels (struct CadetTunnel *t) |
589 | { | 595 | { |
590 | return GNUNET_CONTAINER_multihashmap32_size(t->channels); | 596 | return GNUNET_CONTAINER_multihashmap32_size (t->channels); |
591 | } | 597 | } |
592 | 598 | ||
593 | 599 | ||
@@ -599,11 +605,11 @@ GCT_count_channels(struct CadetTunnel *t) | |||
599 | * @return NULL if channel does not exist | 605 | * @return NULL if channel does not exist |
600 | */ | 606 | */ |
601 | struct CadetChannel * | 607 | struct CadetChannel * |
602 | lookup_channel(struct CadetTunnel *t, | 608 | lookup_channel (struct CadetTunnel *t, |
603 | struct GNUNET_CADET_ChannelTunnelNumber ctn) | 609 | struct GNUNET_CADET_ChannelTunnelNumber ctn) |
604 | { | 610 | { |
605 | return GNUNET_CONTAINER_multihashmap32_get(t->channels, | 611 | return GNUNET_CONTAINER_multihashmap32_get (t->channels, |
606 | ntohl(ctn.cn)); | 612 | ntohl (ctn.cn)); |
607 | } | 613 | } |
608 | 614 | ||
609 | 615 | ||
@@ -615,7 +621,7 @@ lookup_channel(struct CadetTunnel *t, | |||
615 | * @return Number of connections created, either being established or ready. | 621 | * @return Number of connections created, either being established or ready. |
616 | */ | 622 | */ |
617 | unsigned int | 623 | unsigned int |
618 | GCT_count_any_connections(const struct CadetTunnel *t) | 624 | GCT_count_any_connections (const struct CadetTunnel *t) |
619 | { | 625 | { |
620 | return t->num_ready_connections + t->num_busy_connections; | 626 | return t->num_ready_connections + t->num_busy_connections; |
621 | } | 627 | } |
@@ -629,12 +635,12 @@ GCT_count_any_connections(const struct CadetTunnel *t) | |||
629 | * @return NULL if we have no connection that is ready | 635 | * @return NULL if we have no connection that is ready |
630 | */ | 636 | */ |
631 | static struct CadetTConnection * | 637 | static struct CadetTConnection * |
632 | get_ready_connection(struct CadetTunnel *t) | 638 | get_ready_connection (struct CadetTunnel *t) |
633 | { | 639 | { |
634 | struct CadetTConnection *hd = t->connection_ready_head; | 640 | struct CadetTConnection *hd = t->connection_ready_head; |
635 | 641 | ||
636 | GNUNET_assert((NULL == hd) || | 642 | GNUNET_assert ((NULL == hd) || |
637 | (GNUNET_YES == hd->is_ready)); | 643 | (GNUNET_YES == hd->is_ready)); |
638 | return hd; | 644 | return hd; |
639 | } | 645 | } |
640 | 646 | ||
@@ -647,7 +653,7 @@ get_ready_connection(struct CadetTunnel *t) | |||
647 | * @return Tunnel's encryption state. | 653 | * @return Tunnel's encryption state. |
648 | */ | 654 | */ |
649 | enum CadetTunnelEState | 655 | enum CadetTunnelEState |
650 | GCT_get_estate(struct CadetTunnel *t) | 656 | GCT_get_estate (struct CadetTunnel *t) |
651 | { | 657 | { |
652 | return t->estate; | 658 | return t->estate; |
653 | } | 659 | } |
@@ -662,7 +668,7 @@ GCT_get_estate(struct CadetTunnel *t) | |||
662 | * @param cls the `struct CadetTunnel` to process messages on | 668 | * @param cls the `struct CadetTunnel` to process messages on |
663 | */ | 669 | */ |
664 | static void | 670 | static void |
665 | trigger_transmissions(void *cls); | 671 | trigger_transmissions (void *cls); |
666 | 672 | ||
667 | 673 | ||
668 | /* ************************************** start core crypto ***************************** */ | 674 | /* ************************************** start core crypto ***************************** */ |
@@ -674,12 +680,12 @@ trigger_transmissions(void *cls); | |||
674 | * @param ax key material to update | 680 | * @param ax key material to update |
675 | */ | 681 | */ |
676 | static void | 682 | static void |
677 | new_ephemeral(struct CadetTunnelAxolotl *ax) | 683 | new_ephemeral (struct CadetTunnelAxolotl *ax) |
678 | { | 684 | { |
679 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 685 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
680 | "Creating new ephemeral ratchet key (DHRs)\n"); | 686 | "Creating new ephemeral ratchet key (DHRs)\n"); |
681 | GNUNET_assert(GNUNET_OK == | 687 | GNUNET_assert (GNUNET_OK == |
682 | GNUNET_CRYPTO_ecdhe_key_create2(&ax->DHRs)); | 688 | GNUNET_CRYPTO_ecdhe_key_create2 (&ax->DHRs)); |
683 | } | 689 | } |
684 | 690 | ||
685 | 691 | ||
@@ -693,31 +699,31 @@ new_ephemeral(struct CadetTunnelAxolotl *ax) | |||
693 | * @param hmac[out] Destination to store the HMAC. | 699 | * @param hmac[out] Destination to store the HMAC. |
694 | */ | 700 | */ |
695 | static void | 701 | static void |
696 | t_hmac(const void *plaintext, | 702 | t_hmac (const void *plaintext, |
697 | size_t size, | 703 | size_t size, |
698 | uint32_t iv, | 704 | uint32_t iv, |
699 | const struct GNUNET_CRYPTO_SymmetricSessionKey *key, | 705 | const struct GNUNET_CRYPTO_SymmetricSessionKey *key, |
700 | struct GNUNET_ShortHashCode *hmac) | 706 | struct GNUNET_ShortHashCode *hmac) |
701 | { | 707 | { |
702 | static const char ctx[] = "cadet authentication key"; | 708 | static const char ctx[] = "cadet authentication key"; |
703 | struct GNUNET_CRYPTO_AuthKey auth_key; | 709 | struct GNUNET_CRYPTO_AuthKey auth_key; |
704 | struct GNUNET_HashCode hash; | 710 | struct GNUNET_HashCode hash; |
705 | 711 | ||
706 | GNUNET_CRYPTO_hmac_derive_key(&auth_key, | 712 | GNUNET_CRYPTO_hmac_derive_key (&auth_key, |
707 | key, | 713 | key, |
708 | &iv, sizeof(iv), | 714 | &iv, sizeof(iv), |
709 | key, sizeof(*key), | 715 | key, sizeof(*key), |
710 | ctx, sizeof(ctx), | 716 | ctx, sizeof(ctx), |
711 | NULL); | 717 | NULL); |
712 | /* Two step: GNUNET_ShortHash is only 256 bits, | 718 | /* Two step: GNUNET_ShortHash is only 256 bits, |
713 | GNUNET_HashCode is 512, so we truncate. */ | 719 | GNUNET_HashCode is 512, so we truncate. */ |
714 | GNUNET_CRYPTO_hmac(&auth_key, | 720 | GNUNET_CRYPTO_hmac (&auth_key, |
715 | plaintext, | 721 | plaintext, |
716 | size, | 722 | size, |
717 | &hash); | 723 | &hash); |
718 | GNUNET_memcpy(hmac, | 724 | GNUNET_memcpy (hmac, |
719 | &hash, | 725 | &hash, |
720 | sizeof(*hmac)); | 726 | sizeof(*hmac)); |
721 | } | 727 | } |
722 | 728 | ||
723 | 729 | ||
@@ -730,22 +736,22 @@ t_hmac(const void *plaintext, | |||
730 | * @param len Length of @a source. | 736 | * @param len Length of @a source. |
731 | */ | 737 | */ |
732 | static void | 738 | static void |
733 | t_ax_hmac_hash(const struct GNUNET_CRYPTO_SymmetricSessionKey *key, | 739 | t_ax_hmac_hash (const struct GNUNET_CRYPTO_SymmetricSessionKey *key, |
734 | struct GNUNET_HashCode *hash, | 740 | struct GNUNET_HashCode *hash, |
735 | const void *source, | 741 | const void *source, |
736 | unsigned int len) | 742 | unsigned int len) |
737 | { | 743 | { |
738 | static const char ctx[] = "axolotl HMAC-HASH"; | 744 | static const char ctx[] = "axolotl HMAC-HASH"; |
739 | struct GNUNET_CRYPTO_AuthKey auth_key; | 745 | struct GNUNET_CRYPTO_AuthKey auth_key; |
740 | 746 | ||
741 | GNUNET_CRYPTO_hmac_derive_key(&auth_key, | 747 | GNUNET_CRYPTO_hmac_derive_key (&auth_key, |
742 | key, | 748 | key, |
743 | ctx, sizeof(ctx), | 749 | ctx, sizeof(ctx), |
744 | NULL); | 750 | NULL); |
745 | GNUNET_CRYPTO_hmac(&auth_key, | 751 | GNUNET_CRYPTO_hmac (&auth_key, |
746 | source, | 752 | source, |
747 | len, | 753 | len, |
748 | hash); | 754 | hash); |
749 | } | 755 | } |
750 | 756 | ||
751 | 757 | ||
@@ -758,22 +764,22 @@ t_ax_hmac_hash(const struct GNUNET_CRYPTO_SymmetricSessionKey *key, | |||
758 | * @param len Length of @a source. | 764 | * @param len Length of @a source. |
759 | */ | 765 | */ |
760 | static void | 766 | static void |
761 | t_hmac_derive_key(const struct GNUNET_CRYPTO_SymmetricSessionKey *key, | 767 | t_hmac_derive_key (const struct GNUNET_CRYPTO_SymmetricSessionKey *key, |
762 | struct GNUNET_CRYPTO_SymmetricSessionKey *out, | 768 | struct GNUNET_CRYPTO_SymmetricSessionKey *out, |
763 | const void *source, | 769 | const void *source, |
764 | unsigned int len) | 770 | unsigned int len) |
765 | { | 771 | { |
766 | static const char ctx[] = "axolotl derive key"; | 772 | static const char ctx[] = "axolotl derive key"; |
767 | struct GNUNET_HashCode h; | 773 | struct GNUNET_HashCode h; |
768 | 774 | ||
769 | t_ax_hmac_hash(key, | 775 | t_ax_hmac_hash (key, |
770 | &h, | 776 | &h, |
771 | source, | 777 | source, |
772 | len); | 778 | len); |
773 | GNUNET_CRYPTO_kdf(out, sizeof(*out), | 779 | GNUNET_CRYPTO_kdf (out, sizeof(*out), |
774 | ctx, sizeof(ctx), | 780 | ctx, sizeof(ctx), |
775 | &h, sizeof(h), | 781 | &h, sizeof(h), |
776 | NULL); | 782 | NULL); |
777 | } | 783 | } |
778 | 784 | ||
779 | 785 | ||
@@ -786,10 +792,10 @@ t_hmac_derive_key(const struct GNUNET_CRYPTO_SymmetricSessionKey *key, | |||
786 | * @param size Size of the buffers at @a src and @a dst | 792 | * @param size Size of the buffers at @a src and @a dst |
787 | */ | 793 | */ |
788 | static void | 794 | static void |
789 | t_ax_encrypt(struct CadetTunnelAxolotl *ax, | 795 | t_ax_encrypt (struct CadetTunnelAxolotl *ax, |
790 | void *dst, | 796 | void *dst, |
791 | const void *src, | 797 | const void *src, |
792 | size_t size) | 798 | size_t size) |
793 | { | 799 | { |
794 | struct GNUNET_CRYPTO_SymmetricSessionKey MK; | 800 | struct GNUNET_CRYPTO_SymmetricSessionKey MK; |
795 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; | 801 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; |
@@ -798,66 +804,67 @@ t_ax_encrypt(struct CadetTunnelAxolotl *ax, | |||
798 | ax->ratchet_counter++; | 804 | ax->ratchet_counter++; |
799 | if ((GNUNET_YES == ax->ratchet_allowed) && | 805 | if ((GNUNET_YES == ax->ratchet_allowed) && |
800 | ((ratchet_messages <= ax->ratchet_counter) || | 806 | ((ratchet_messages <= ax->ratchet_counter) || |
801 | (0 == GNUNET_TIME_absolute_get_remaining(ax->ratchet_expiration).rel_value_us))) | 807 | (0 == GNUNET_TIME_absolute_get_remaining ( |
802 | { | 808 | ax->ratchet_expiration).rel_value_us))) |
803 | ax->ratchet_flag = GNUNET_YES; | 809 | { |
804 | } | 810 | ax->ratchet_flag = GNUNET_YES; |
811 | } | ||
805 | if (GNUNET_YES == ax->ratchet_flag) | 812 | if (GNUNET_YES == ax->ratchet_flag) |
806 | { | 813 | { |
807 | /* Advance ratchet */ | 814 | /* Advance ratchet */ |
808 | struct GNUNET_CRYPTO_SymmetricSessionKey keys[3]; | 815 | struct GNUNET_CRYPTO_SymmetricSessionKey keys[3]; |
809 | struct GNUNET_HashCode dh; | 816 | struct GNUNET_HashCode dh; |
810 | struct GNUNET_HashCode hmac; | 817 | struct GNUNET_HashCode hmac; |
811 | static const char ctx[] = "axolotl ratchet"; | 818 | static const char ctx[] = "axolotl ratchet"; |
812 | 819 | ||
813 | new_ephemeral(ax); | 820 | new_ephemeral (ax); |
814 | ax->HKs = ax->NHKs; | 821 | ax->HKs = ax->NHKs; |
815 | 822 | ||
816 | /* RK, NHKs, CKs = KDF( HMAC-HASH(RK, DH(DHRs, DHRr)) ) */ | 823 | /* RK, NHKs, CKs = KDF( HMAC-HASH(RK, DH(DHRs, DHRr)) ) */ |
817 | GNUNET_CRYPTO_ecc_ecdh(&ax->DHRs, | 824 | GNUNET_CRYPTO_ecc_ecdh (&ax->DHRs, |
818 | &ax->DHRr, | 825 | &ax->DHRr, |
819 | &dh); | 826 | &dh); |
820 | t_ax_hmac_hash(&ax->RK, | 827 | t_ax_hmac_hash (&ax->RK, |
821 | &hmac, | 828 | &hmac, |
822 | &dh, | 829 | &dh, |
823 | sizeof(dh)); | 830 | sizeof(dh)); |
824 | GNUNET_CRYPTO_kdf(keys, sizeof(keys), | 831 | GNUNET_CRYPTO_kdf (keys, sizeof(keys), |
825 | ctx, sizeof(ctx), | 832 | ctx, sizeof(ctx), |
826 | &hmac, sizeof(hmac), | 833 | &hmac, sizeof(hmac), |
827 | NULL); | 834 | NULL); |
828 | ax->RK = keys[0]; | 835 | ax->RK = keys[0]; |
829 | ax->NHKs = keys[1]; | 836 | ax->NHKs = keys[1]; |
830 | ax->CKs = keys[2]; | 837 | ax->CKs = keys[2]; |
831 | 838 | ||
832 | ax->PNs = ax->Ns; | 839 | ax->PNs = ax->Ns; |
833 | ax->Ns = 0; | 840 | ax->Ns = 0; |
834 | ax->ratchet_flag = GNUNET_NO; | 841 | ax->ratchet_flag = GNUNET_NO; |
835 | ax->ratchet_allowed = GNUNET_NO; | 842 | ax->ratchet_allowed = GNUNET_NO; |
836 | ax->ratchet_counter = 0; | 843 | ax->ratchet_counter = 0; |
837 | ax->ratchet_expiration | 844 | ax->ratchet_expiration |
838 | = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), | 845 | = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), |
839 | ratchet_time); | 846 | ratchet_time); |
840 | } | 847 | } |
841 | 848 | ||
842 | t_hmac_derive_key(&ax->CKs, | 849 | t_hmac_derive_key (&ax->CKs, |
843 | &MK, | 850 | &MK, |
844 | "0", | 851 | "0", |
845 | 1); | 852 | 1); |
846 | GNUNET_CRYPTO_symmetric_derive_iv(&iv, | 853 | GNUNET_CRYPTO_symmetric_derive_iv (&iv, |
847 | &MK, | 854 | &MK, |
848 | NULL, 0, | 855 | NULL, 0, |
849 | NULL); | 856 | NULL); |
850 | 857 | ||
851 | out_size = GNUNET_CRYPTO_symmetric_encrypt(src, | 858 | out_size = GNUNET_CRYPTO_symmetric_encrypt (src, |
852 | size, | 859 | size, |
853 | &MK, | 860 | &MK, |
854 | &iv, | 861 | &iv, |
855 | dst); | 862 | dst); |
856 | GNUNET_assert(size == out_size); | 863 | GNUNET_assert (size == out_size); |
857 | t_hmac_derive_key(&ax->CKs, | 864 | t_hmac_derive_key (&ax->CKs, |
858 | &ax->CKs, | 865 | &ax->CKs, |
859 | "1", | 866 | "1", |
860 | 1); | 867 | 1); |
861 | } | 868 | } |
862 | 869 | ||
863 | 870 | ||
@@ -870,34 +877,34 @@ t_ax_encrypt(struct CadetTunnelAxolotl *ax, | |||
870 | * @param size Size of the @a src and @a dst buffers | 877 | * @param size Size of the @a src and @a dst buffers |
871 | */ | 878 | */ |
872 | static void | 879 | static void |
873 | t_ax_decrypt(struct CadetTunnelAxolotl *ax, | 880 | t_ax_decrypt (struct CadetTunnelAxolotl *ax, |
874 | void *dst, | 881 | void *dst, |
875 | const void *src, | 882 | const void *src, |
876 | size_t size) | 883 | size_t size) |
877 | { | 884 | { |
878 | struct GNUNET_CRYPTO_SymmetricSessionKey MK; | 885 | struct GNUNET_CRYPTO_SymmetricSessionKey MK; |
879 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; | 886 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; |
880 | size_t out_size; | 887 | size_t out_size; |
881 | 888 | ||
882 | t_hmac_derive_key(&ax->CKr, | 889 | t_hmac_derive_key (&ax->CKr, |
883 | &MK, | 890 | &MK, |
884 | "0", | 891 | "0", |
885 | 1); | 892 | 1); |
886 | GNUNET_CRYPTO_symmetric_derive_iv(&iv, | 893 | GNUNET_CRYPTO_symmetric_derive_iv (&iv, |
887 | &MK, | 894 | &MK, |
888 | NULL, 0, | 895 | NULL, 0, |
889 | NULL); | 896 | NULL); |
890 | GNUNET_assert(size >= sizeof(struct GNUNET_MessageHeader)); | 897 | GNUNET_assert (size >= sizeof(struct GNUNET_MessageHeader)); |
891 | out_size = GNUNET_CRYPTO_symmetric_decrypt(src, | 898 | out_size = GNUNET_CRYPTO_symmetric_decrypt (src, |
892 | size, | 899 | size, |
893 | &MK, | 900 | &MK, |
894 | &iv, | 901 | &iv, |
895 | dst); | 902 | dst); |
896 | GNUNET_assert(out_size == size); | 903 | GNUNET_assert (out_size == size); |
897 | t_hmac_derive_key(&ax->CKr, | 904 | t_hmac_derive_key (&ax->CKr, |
898 | &ax->CKr, | 905 | &ax->CKr, |
899 | "1", | 906 | "1", |
900 | 1); | 907 | 1); |
901 | } | 908 | } |
902 | 909 | ||
903 | 910 | ||
@@ -908,22 +915,23 @@ t_ax_decrypt(struct CadetTunnelAxolotl *ax, | |||
908 | * @param[in|out] msg Message whose header to encrypt. | 915 | * @param[in|out] msg Message whose header to encrypt. |
909 | */ | 916 | */ |
910 | static void | 917 | static void |
911 | t_h_encrypt(struct CadetTunnelAxolotl *ax, | 918 | t_h_encrypt (struct CadetTunnelAxolotl *ax, |
912 | struct GNUNET_CADET_TunnelEncryptedMessage *msg) | 919 | struct GNUNET_CADET_TunnelEncryptedMessage *msg) |
913 | { | 920 | { |
914 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; | 921 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; |
915 | size_t out_size; | 922 | size_t out_size; |
916 | 923 | ||
917 | GNUNET_CRYPTO_symmetric_derive_iv(&iv, | 924 | GNUNET_CRYPTO_symmetric_derive_iv (&iv, |
918 | &ax->HKs, | 925 | &ax->HKs, |
919 | NULL, 0, | 926 | NULL, 0, |
920 | NULL); | 927 | NULL); |
921 | out_size = GNUNET_CRYPTO_symmetric_encrypt(&msg->ax_header, | 928 | out_size = GNUNET_CRYPTO_symmetric_encrypt (&msg->ax_header, |
922 | sizeof(struct GNUNET_CADET_AxHeader), | 929 | sizeof(struct |
923 | &ax->HKs, | 930 | GNUNET_CADET_AxHeader), |
924 | &iv, | 931 | &ax->HKs, |
925 | &msg->ax_header); | 932 | &iv, |
926 | GNUNET_assert(sizeof(struct GNUNET_CADET_AxHeader) == out_size); | 933 | &msg->ax_header); |
934 | GNUNET_assert (sizeof(struct GNUNET_CADET_AxHeader) == out_size); | ||
927 | } | 935 | } |
928 | 936 | ||
929 | 937 | ||
@@ -935,23 +943,24 @@ t_h_encrypt(struct CadetTunnelAxolotl *ax, | |||
935 | * @param dst Where to decrypt header to. | 943 | * @param dst Where to decrypt header to. |
936 | */ | 944 | */ |
937 | static void | 945 | static void |
938 | t_h_decrypt(struct CadetTunnelAxolotl *ax, | 946 | t_h_decrypt (struct CadetTunnelAxolotl *ax, |
939 | const struct GNUNET_CADET_TunnelEncryptedMessage *src, | 947 | const struct GNUNET_CADET_TunnelEncryptedMessage *src, |
940 | struct GNUNET_CADET_TunnelEncryptedMessage *dst) | 948 | struct GNUNET_CADET_TunnelEncryptedMessage *dst) |
941 | { | 949 | { |
942 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; | 950 | struct GNUNET_CRYPTO_SymmetricInitializationVector iv; |
943 | size_t out_size; | 951 | size_t out_size; |
944 | 952 | ||
945 | GNUNET_CRYPTO_symmetric_derive_iv(&iv, | 953 | GNUNET_CRYPTO_symmetric_derive_iv (&iv, |
946 | &ax->HKr, | 954 | &ax->HKr, |
947 | NULL, 0, | 955 | NULL, 0, |
948 | NULL); | 956 | NULL); |
949 | out_size = GNUNET_CRYPTO_symmetric_decrypt(&src->ax_header.Ns, | 957 | out_size = GNUNET_CRYPTO_symmetric_decrypt (&src->ax_header.Ns, |
950 | sizeof(struct GNUNET_CADET_AxHeader), | 958 | sizeof(struct |
951 | &ax->HKr, | 959 | GNUNET_CADET_AxHeader), |
952 | &iv, | 960 | &ax->HKr, |
953 | &dst->ax_header.Ns); | 961 | &iv, |
954 | GNUNET_assert(sizeof(struct GNUNET_CADET_AxHeader) == out_size); | 962 | &dst->ax_header.Ns); |
963 | GNUNET_assert (sizeof(struct GNUNET_CADET_AxHeader) == out_size); | ||
955 | } | 964 | } |
956 | 965 | ||
957 | 966 | ||
@@ -962,13 +971,13 @@ t_h_decrypt(struct CadetTunnelAxolotl *ax, | |||
962 | * @param key Key to delete. | 971 | * @param key Key to delete. |
963 | */ | 972 | */ |
964 | static void | 973 | static void |
965 | delete_skipped_key(struct CadetTunnelAxolotl *ax, | 974 | delete_skipped_key (struct CadetTunnelAxolotl *ax, |
966 | struct CadetTunnelSkippedKey *key) | 975 | struct CadetTunnelSkippedKey *key) |
967 | { | 976 | { |
968 | GNUNET_CONTAINER_DLL_remove(ax->skipped_head, | 977 | GNUNET_CONTAINER_DLL_remove (ax->skipped_head, |
969 | ax->skipped_tail, | 978 | ax->skipped_tail, |
970 | key); | 979 | key); |
971 | GNUNET_free(key); | 980 | GNUNET_free (key); |
972 | ax->skipped--; | 981 | ax->skipped--; |
973 | } | 982 | } |
974 | 983 | ||
@@ -984,10 +993,10 @@ delete_skipped_key(struct CadetTunnelAxolotl *ax, | |||
984 | * @return Size of the decrypted data, -1 if an error was encountered. | 993 | * @return Size of the decrypted data, -1 if an error was encountered. |
985 | */ | 994 | */ |
986 | static ssize_t | 995 | static ssize_t |
987 | try_old_ax_keys(struct CadetTunnelAxolotl *ax, | 996 | try_old_ax_keys (struct CadetTunnelAxolotl *ax, |
988 | void *dst, | 997 | void *dst, |
989 | const struct GNUNET_CADET_TunnelEncryptedMessage *src, | 998 | const struct GNUNET_CADET_TunnelEncryptedMessage *src, |
990 | size_t size) | 999 | size_t size) |
991 | { | 1000 | { |
992 | struct CadetTunnelSkippedKey *key; | 1001 | struct CadetTunnelSkippedKey *key; |
993 | struct GNUNET_ShortHashCode *hmac; | 1002 | struct GNUNET_ShortHashCode *hmac; |
@@ -999,70 +1008,70 @@ try_old_ax_keys(struct CadetTunnelAxolotl *ax, | |||
999 | size_t len; | 1008 | size_t len; |
1000 | unsigned int N; | 1009 | unsigned int N; |
1001 | 1010 | ||
1002 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1011 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1003 | "Trying skipped keys\n"); | 1012 | "Trying skipped keys\n"); |
1004 | hmac = &plaintext_header.hmac; | 1013 | hmac = &plaintext_header.hmac; |
1005 | esize = size - sizeof(struct GNUNET_CADET_TunnelEncryptedMessage); | 1014 | esize = size - sizeof(struct GNUNET_CADET_TunnelEncryptedMessage); |
1006 | 1015 | ||
1007 | /* Find a correct Header Key */ | 1016 | /* Find a correct Header Key */ |
1008 | valid_HK = NULL; | 1017 | valid_HK = NULL; |
1009 | for (key = ax->skipped_head; NULL != key; key = key->next) | 1018 | for (key = ax->skipped_head; NULL != key; key = key->next) |
1010 | { | 1019 | { |
1011 | t_hmac(&src->ax_header, | 1020 | t_hmac (&src->ax_header, |
1012 | sizeof(struct GNUNET_CADET_AxHeader) + esize, | 1021 | sizeof(struct GNUNET_CADET_AxHeader) + esize, |
1013 | 0, | 1022 | 0, |
1014 | &key->HK, | 1023 | &key->HK, |
1015 | hmac); | 1024 | hmac); |
1016 | if (0 == GNUNET_memcmp(hmac, | 1025 | if (0 == GNUNET_memcmp (hmac, |
1017 | &src->hmac)) | 1026 | &src->hmac)) |
1018 | { | 1027 | { |
1019 | valid_HK = &key->HK; | 1028 | valid_HK = &key->HK; |
1020 | break; | 1029 | break; |
1021 | } | ||
1022 | } | 1030 | } |
1031 | } | ||
1023 | if (NULL == key) | 1032 | if (NULL == key) |
1024 | return -1; | 1033 | return -1; |
1025 | 1034 | ||
1026 | /* Should've been checked in -cadet_connection.c handle_cadet_encrypted. */ | 1035 | /* Should've been checked in -cadet_connection.c handle_cadet_encrypted. */ |
1027 | GNUNET_assert(size > sizeof(struct GNUNET_CADET_TunnelEncryptedMessage)); | 1036 | GNUNET_assert (size > sizeof(struct GNUNET_CADET_TunnelEncryptedMessage)); |
1028 | len = size - sizeof(struct GNUNET_CADET_TunnelEncryptedMessage); | 1037 | len = size - sizeof(struct GNUNET_CADET_TunnelEncryptedMessage); |
1029 | GNUNET_assert(len >= sizeof(struct GNUNET_MessageHeader)); | 1038 | GNUNET_assert (len >= sizeof(struct GNUNET_MessageHeader)); |
1030 | 1039 | ||
1031 | /* Decrypt header */ | 1040 | /* Decrypt header */ |
1032 | GNUNET_CRYPTO_symmetric_derive_iv(&iv, | 1041 | GNUNET_CRYPTO_symmetric_derive_iv (&iv, |
1033 | &key->HK, | 1042 | &key->HK, |
1034 | NULL, 0, | 1043 | NULL, 0, |
1035 | NULL); | 1044 | NULL); |
1036 | res = GNUNET_CRYPTO_symmetric_decrypt(&src->ax_header.Ns, | 1045 | res = GNUNET_CRYPTO_symmetric_decrypt (&src->ax_header.Ns, |
1037 | sizeof(struct GNUNET_CADET_AxHeader), | 1046 | sizeof(struct GNUNET_CADET_AxHeader), |
1038 | &key->HK, | 1047 | &key->HK, |
1039 | &iv, | 1048 | &iv, |
1040 | &plaintext_header.ax_header.Ns); | 1049 | &plaintext_header.ax_header.Ns); |
1041 | GNUNET_assert(sizeof(struct GNUNET_CADET_AxHeader) == res); | 1050 | GNUNET_assert (sizeof(struct GNUNET_CADET_AxHeader) == res); |
1042 | 1051 | ||
1043 | /* Find the correct message key */ | 1052 | /* Find the correct message key */ |
1044 | N = ntohl(plaintext_header.ax_header.Ns); | 1053 | N = ntohl (plaintext_header.ax_header.Ns); |
1045 | while ((NULL != key) && | 1054 | while ((NULL != key) && |
1046 | (N != key->Kn)) | 1055 | (N != key->Kn)) |
1047 | key = key->next; | 1056 | key = key->next; |
1048 | if ((NULL == key) || | 1057 | if ((NULL == key) || |
1049 | (0 != GNUNET_memcmp(&key->HK, | 1058 | (0 != GNUNET_memcmp (&key->HK, |
1050 | valid_HK))) | 1059 | valid_HK))) |
1051 | return -1; | 1060 | return -1; |
1052 | 1061 | ||
1053 | /* Decrypt payload */ | 1062 | /* Decrypt payload */ |
1054 | GNUNET_CRYPTO_symmetric_derive_iv(&iv, | 1063 | GNUNET_CRYPTO_symmetric_derive_iv (&iv, |
1055 | &key->MK, | 1064 | &key->MK, |
1056 | NULL, | 1065 | NULL, |
1057 | 0, | 1066 | 0, |
1058 | NULL); | 1067 | NULL); |
1059 | res = GNUNET_CRYPTO_symmetric_decrypt(&src[1], | 1068 | res = GNUNET_CRYPTO_symmetric_decrypt (&src[1], |
1060 | len, | 1069 | len, |
1061 | &key->MK, | 1070 | &key->MK, |
1062 | &iv, | 1071 | &iv, |
1063 | dst); | 1072 | dst); |
1064 | delete_skipped_key(ax, | 1073 | delete_skipped_key (ax, |
1065 | key); | 1074 | key); |
1066 | return res; | 1075 | return res; |
1067 | } | 1076 | } |
1068 | 1077 | ||
@@ -1074,26 +1083,26 @@ try_old_ax_keys(struct CadetTunnelAxolotl *ax, | |||
1074 | * @param HKr Header Key to use. | 1083 | * @param HKr Header Key to use. |
1075 | */ | 1084 | */ |
1076 | static void | 1085 | static void |
1077 | store_skipped_key(struct CadetTunnelAxolotl *ax, | 1086 | store_skipped_key (struct CadetTunnelAxolotl *ax, |
1078 | const struct GNUNET_CRYPTO_SymmetricSessionKey *HKr) | 1087 | const struct GNUNET_CRYPTO_SymmetricSessionKey *HKr) |
1079 | { | 1088 | { |
1080 | struct CadetTunnelSkippedKey *key; | 1089 | struct CadetTunnelSkippedKey *key; |
1081 | 1090 | ||
1082 | key = GNUNET_new(struct CadetTunnelSkippedKey); | 1091 | key = GNUNET_new (struct CadetTunnelSkippedKey); |
1083 | key->timestamp = GNUNET_TIME_absolute_get(); | 1092 | key->timestamp = GNUNET_TIME_absolute_get (); |
1084 | key->Kn = ax->Nr; | 1093 | key->Kn = ax->Nr; |
1085 | key->HK = ax->HKr; | 1094 | key->HK = ax->HKr; |
1086 | t_hmac_derive_key(&ax->CKr, | 1095 | t_hmac_derive_key (&ax->CKr, |
1087 | &key->MK, | 1096 | &key->MK, |
1088 | "0", | 1097 | "0", |
1089 | 1); | 1098 | 1); |
1090 | t_hmac_derive_key(&ax->CKr, | 1099 | t_hmac_derive_key (&ax->CKr, |
1091 | &ax->CKr, | 1100 | &ax->CKr, |
1092 | "1", | 1101 | "1", |
1093 | 1); | 1102 | 1); |
1094 | GNUNET_CONTAINER_DLL_insert(ax->skipped_head, | 1103 | GNUNET_CONTAINER_DLL_insert (ax->skipped_head, |
1095 | ax->skipped_tail, | 1104 | ax->skipped_tail, |
1096 | key); | 1105 | key); |
1097 | ax->skipped++; | 1106 | ax->skipped++; |
1098 | ax->Nr++; | 1107 | ax->Nr++; |
1099 | } | 1108 | } |
@@ -1110,41 +1119,41 @@ store_skipped_key(struct CadetTunnelAxolotl *ax, | |||
1110 | * #GNUNET_SYSERR if an error ocurred (@a Np not expected). | 1119 | * #GNUNET_SYSERR if an error ocurred (@a Np not expected). |
1111 | */ | 1120 | */ |
1112 | static int | 1121 | static int |
1113 | store_ax_keys(struct CadetTunnelAxolotl *ax, | 1122 | store_ax_keys (struct CadetTunnelAxolotl *ax, |
1114 | const struct GNUNET_CRYPTO_SymmetricSessionKey *HKr, | 1123 | const struct GNUNET_CRYPTO_SymmetricSessionKey *HKr, |
1115 | uint32_t Np) | 1124 | uint32_t Np) |
1116 | { | 1125 | { |
1117 | int gap; | 1126 | int gap; |
1118 | 1127 | ||
1119 | gap = Np - ax->Nr; | 1128 | gap = Np - ax->Nr; |
1120 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1129 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1121 | "Storing skipped keys [%u, %u)\n", | 1130 | "Storing skipped keys [%u, %u)\n", |
1122 | ax->Nr, | 1131 | ax->Nr, |
1123 | Np); | 1132 | Np); |
1124 | if (MAX_KEY_GAP < gap) | 1133 | if (MAX_KEY_GAP < gap) |
1125 | { | 1134 | { |
1126 | /* Avoid DoS (forcing peer to do more than #MAX_KEY_GAP HMAC operations) */ | 1135 | /* Avoid DoS (forcing peer to do more than #MAX_KEY_GAP HMAC operations) */ |
1127 | /* TODO: start new key exchange on return */ | 1136 | /* TODO: start new key exchange on return */ |
1128 | GNUNET_break_op(0); | 1137 | GNUNET_break_op (0); |
1129 | LOG(GNUNET_ERROR_TYPE_WARNING, | 1138 | LOG (GNUNET_ERROR_TYPE_WARNING, |
1130 | "Got message %u, expected %u+\n", | 1139 | "Got message %u, expected %u+\n", |
1131 | Np, | 1140 | Np, |
1132 | ax->Nr); | 1141 | ax->Nr); |
1133 | return GNUNET_SYSERR; | 1142 | return GNUNET_SYSERR; |
1134 | } | 1143 | } |
1135 | if (0 > gap) | 1144 | if (0 > gap) |
1136 | { | 1145 | { |
1137 | /* Delayed message: don't store keys, flag to try old keys. */ | 1146 | /* Delayed message: don't store keys, flag to try old keys. */ |
1138 | return GNUNET_SYSERR; | 1147 | return GNUNET_SYSERR; |
1139 | } | 1148 | } |
1140 | 1149 | ||
1141 | while (ax->Nr < Np) | 1150 | while (ax->Nr < Np) |
1142 | store_skipped_key(ax, | 1151 | store_skipped_key (ax, |
1143 | HKr); | 1152 | HKr); |
1144 | 1153 | ||
1145 | while (ax->skipped > MAX_SKIPPED_KEYS) | 1154 | while (ax->skipped > MAX_SKIPPED_KEYS) |
1146 | delete_skipped_key(ax, | 1155 | delete_skipped_key (ax, |
1147 | ax->skipped_tail); | 1156 | ax->skipped_tail); |
1148 | return GNUNET_OK; | 1157 | return GNUNET_OK; |
1149 | } | 1158 | } |
1150 | 1159 | ||
@@ -1160,10 +1169,11 @@ store_ax_keys(struct CadetTunnelAxolotl *ax, | |||
1160 | * @return Size of the decrypted data, -1 if an error was encountered. | 1169 | * @return Size of the decrypted data, -1 if an error was encountered. |
1161 | */ | 1170 | */ |
1162 | static ssize_t | 1171 | static ssize_t |
1163 | t_ax_decrypt_and_validate(struct CadetTunnelAxolotl *ax, | 1172 | t_ax_decrypt_and_validate (struct CadetTunnelAxolotl *ax, |
1164 | void *dst, | 1173 | void *dst, |
1165 | const struct GNUNET_CADET_TunnelEncryptedMessage *src, | 1174 | const struct |
1166 | size_t size) | 1175 | GNUNET_CADET_TunnelEncryptedMessage *src, |
1176 | size_t size) | ||
1167 | { | 1177 | { |
1168 | struct GNUNET_ShortHashCode msg_hmac; | 1178 | struct GNUNET_ShortHashCode msg_hmac; |
1169 | struct GNUNET_HashCode hmac; | 1179 | struct GNUNET_HashCode hmac; |
@@ -1175,90 +1185,90 @@ t_ax_decrypt_and_validate(struct CadetTunnelAxolotl *ax, | |||
1175 | esize = size - sizeof(struct GNUNET_CADET_TunnelEncryptedMessage); | 1185 | esize = size - sizeof(struct GNUNET_CADET_TunnelEncryptedMessage); |
1176 | 1186 | ||
1177 | /* Try current HK */ | 1187 | /* Try current HK */ |
1178 | t_hmac(&src->ax_header, | 1188 | t_hmac (&src->ax_header, |
1179 | sizeof(struct GNUNET_CADET_AxHeader) + esize, | 1189 | sizeof(struct GNUNET_CADET_AxHeader) + esize, |
1180 | 0, &ax->HKr, | 1190 | 0, &ax->HKr, |
1181 | &msg_hmac); | 1191 | &msg_hmac); |
1182 | if (0 != GNUNET_memcmp(&msg_hmac, | 1192 | if (0 != GNUNET_memcmp (&msg_hmac, |
1183 | &src->hmac)) | 1193 | &src->hmac)) |
1194 | { | ||
1195 | static const char ctx[] = "axolotl ratchet"; | ||
1196 | struct GNUNET_CRYPTO_SymmetricSessionKey keys[3]; /* RKp, NHKp, CKp */ | ||
1197 | struct GNUNET_CRYPTO_SymmetricSessionKey HK; | ||
1198 | struct GNUNET_HashCode dh; | ||
1199 | struct GNUNET_CRYPTO_EcdhePublicKey *DHRp; | ||
1200 | |||
1201 | /* Try Next HK */ | ||
1202 | t_hmac (&src->ax_header, | ||
1203 | sizeof(struct GNUNET_CADET_AxHeader) + esize, | ||
1204 | 0, | ||
1205 | &ax->NHKr, | ||
1206 | &msg_hmac); | ||
1207 | if (0 != GNUNET_memcmp (&msg_hmac, | ||
1208 | &src->hmac)) | ||
1184 | { | 1209 | { |
1185 | static const char ctx[] = "axolotl ratchet"; | 1210 | /* Try the skipped keys, if that fails, we're out of luck. */ |
1186 | struct GNUNET_CRYPTO_SymmetricSessionKey keys[3]; /* RKp, NHKp, CKp */ | 1211 | return try_old_ax_keys (ax, |
1187 | struct GNUNET_CRYPTO_SymmetricSessionKey HK; | 1212 | dst, |
1188 | struct GNUNET_HashCode dh; | 1213 | src, |
1189 | struct GNUNET_CRYPTO_EcdhePublicKey *DHRp; | 1214 | size); |
1190 | 1215 | } | |
1191 | /* Try Next HK */ | 1216 | HK = ax->HKr; |
1192 | t_hmac(&src->ax_header, | 1217 | ax->HKr = ax->NHKr; |
1193 | sizeof(struct GNUNET_CADET_AxHeader) + esize, | 1218 | t_h_decrypt (ax, |
1194 | 0, | 1219 | src, |
1195 | &ax->NHKr, | 1220 | &plaintext_header); |
1196 | &msg_hmac); | 1221 | Np = ntohl (plaintext_header.ax_header.Ns); |
1197 | if (0 != GNUNET_memcmp(&msg_hmac, | 1222 | PNp = ntohl (plaintext_header.ax_header.PNs); |
1198 | &src->hmac)) | 1223 | DHRp = &plaintext_header.ax_header.DHRs; |
1199 | { | 1224 | store_ax_keys (ax, |
1200 | /* Try the skipped keys, if that fails, we're out of luck. */ | 1225 | &HK, |
1201 | return try_old_ax_keys(ax, | 1226 | PNp); |
1202 | dst, | 1227 | |
1203 | src, | 1228 | /* RKp, NHKp, CKp = KDF (HMAC-HASH (RK, DH (DHRp, DHRs))) */ |
1204 | size); | 1229 | GNUNET_CRYPTO_ecc_ecdh (&ax->DHRs, |
1205 | } | 1230 | DHRp, |
1206 | HK = ax->HKr; | 1231 | &dh); |
1207 | ax->HKr = ax->NHKr; | 1232 | t_ax_hmac_hash (&ax->RK, |
1208 | t_h_decrypt(ax, | 1233 | &hmac, |
1209 | src, | 1234 | &dh, sizeof(dh)); |
1210 | &plaintext_header); | 1235 | GNUNET_CRYPTO_kdf (keys, sizeof(keys), |
1211 | Np = ntohl(plaintext_header.ax_header.Ns); | 1236 | ctx, sizeof(ctx), |
1212 | PNp = ntohl(plaintext_header.ax_header.PNs); | 1237 | &hmac, sizeof(hmac), |
1213 | DHRp = &plaintext_header.ax_header.DHRs; | 1238 | NULL); |
1214 | store_ax_keys(ax, | 1239 | |
1215 | &HK, | 1240 | /* Commit "purported" keys */ |
1216 | PNp); | 1241 | ax->RK = keys[0]; |
1217 | 1242 | ax->NHKr = keys[1]; | |
1218 | /* RKp, NHKp, CKp = KDF (HMAC-HASH (RK, DH (DHRp, DHRs))) */ | 1243 | ax->CKr = keys[2]; |
1219 | GNUNET_CRYPTO_ecc_ecdh(&ax->DHRs, | 1244 | ax->DHRr = *DHRp; |
1220 | DHRp, | 1245 | ax->Nr = 0; |
1221 | &dh); | 1246 | ax->ratchet_allowed = GNUNET_YES; |
1222 | t_ax_hmac_hash(&ax->RK, | 1247 | } |
1223 | &hmac, | ||
1224 | &dh, sizeof(dh)); | ||
1225 | GNUNET_CRYPTO_kdf(keys, sizeof(keys), | ||
1226 | ctx, sizeof(ctx), | ||
1227 | &hmac, sizeof(hmac), | ||
1228 | NULL); | ||
1229 | |||
1230 | /* Commit "purported" keys */ | ||
1231 | ax->RK = keys[0]; | ||
1232 | ax->NHKr = keys[1]; | ||
1233 | ax->CKr = keys[2]; | ||
1234 | ax->DHRr = *DHRp; | ||
1235 | ax->Nr = 0; | ||
1236 | ax->ratchet_allowed = GNUNET_YES; | ||
1237 | } | ||
1238 | else | 1248 | else |
1239 | { | 1249 | { |
1240 | t_h_decrypt(ax, | 1250 | t_h_decrypt (ax, |
1241 | src, | 1251 | src, |
1242 | &plaintext_header); | 1252 | &plaintext_header); |
1243 | Np = ntohl(plaintext_header.ax_header.Ns); | 1253 | Np = ntohl (plaintext_header.ax_header.Ns); |
1244 | PNp = ntohl(plaintext_header.ax_header.PNs); | 1254 | PNp = ntohl (plaintext_header.ax_header.PNs); |
1245 | } | 1255 | } |
1246 | if ((Np != ax->Nr) && | 1256 | if ((Np != ax->Nr) && |
1247 | (GNUNET_OK != store_ax_keys(ax, | 1257 | (GNUNET_OK != store_ax_keys (ax, |
1248 | &ax->HKr, | 1258 | &ax->HKr, |
1249 | Np))) | 1259 | Np))) |
1250 | { | 1260 | { |
1251 | /* Try the skipped keys, if that fails, we're out of luck. */ | 1261 | /* Try the skipped keys, if that fails, we're out of luck. */ |
1252 | return try_old_ax_keys(ax, | 1262 | return try_old_ax_keys (ax, |
1253 | dst, | 1263 | dst, |
1254 | src, | 1264 | src, |
1255 | size); | 1265 | size); |
1256 | } | 1266 | } |
1257 | 1267 | ||
1258 | t_ax_decrypt(ax, | 1268 | t_ax_decrypt (ax, |
1259 | dst, | 1269 | dst, |
1260 | &src[1], | 1270 | &src[1], |
1261 | esize); | 1271 | esize); |
1262 | ax->Nr = Np + 1; | 1272 | ax->Nr = Np + 1; |
1263 | return esize; | 1273 | return esize; |
1264 | } | 1274 | } |
@@ -1274,13 +1284,13 @@ t_ax_decrypt_and_validate(struct CadetTunnelAxolotl *ax, | |||
1274 | * @return #GNUNET_OK (continue to iterate) | 1284 | * @return #GNUNET_OK (continue to iterate) |
1275 | */ | 1285 | */ |
1276 | static int | 1286 | static int |
1277 | notify_tunnel_up_cb(void *cls, | 1287 | notify_tunnel_up_cb (void *cls, |
1278 | uint32_t key, | 1288 | uint32_t key, |
1279 | void *value) | 1289 | void *value) |
1280 | { | 1290 | { |
1281 | struct CadetChannel *ch = value; | 1291 | struct CadetChannel *ch = value; |
1282 | 1292 | ||
1283 | GCCH_tunnel_up(ch); | 1293 | GCCH_tunnel_up (ch); |
1284 | return GNUNET_OK; | 1294 | return GNUNET_OK; |
1285 | } | 1295 | } |
1286 | 1296 | ||
@@ -1293,35 +1303,35 @@ notify_tunnel_up_cb(void *cls, | |||
1293 | * @param state New encryption state. | 1303 | * @param state New encryption state. |
1294 | */ | 1304 | */ |
1295 | void | 1305 | void |
1296 | GCT_change_estate(struct CadetTunnel *t, | 1306 | GCT_change_estate (struct CadetTunnel *t, |
1297 | enum CadetTunnelEState state) | 1307 | enum CadetTunnelEState state) |
1298 | { | 1308 | { |
1299 | enum CadetTunnelEState old = t->estate; | 1309 | enum CadetTunnelEState old = t->estate; |
1300 | 1310 | ||
1301 | t->estate = state; | 1311 | t->estate = state; |
1302 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1312 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1303 | "%s estate changed from %s to %s\n", | 1313 | "%s estate changed from %s to %s\n", |
1304 | GCT_2s(t), | 1314 | GCT_2s (t), |
1305 | estate2s(old), | 1315 | estate2s (old), |
1306 | estate2s(state)); | 1316 | estate2s (state)); |
1307 | 1317 | ||
1308 | if ((CADET_TUNNEL_KEY_OK != old) && | 1318 | if ((CADET_TUNNEL_KEY_OK != old) && |
1309 | (CADET_TUNNEL_KEY_OK == t->estate)) | 1319 | (CADET_TUNNEL_KEY_OK == t->estate)) |
1320 | { | ||
1321 | if (NULL != t->kx_task) | ||
1310 | { | 1322 | { |
1311 | if (NULL != t->kx_task) | 1323 | GNUNET_SCHEDULER_cancel (t->kx_task); |
1312 | { | 1324 | t->kx_task = NULL; |
1313 | GNUNET_SCHEDULER_cancel(t->kx_task); | ||
1314 | t->kx_task = NULL; | ||
1315 | } | ||
1316 | /* notify all channels that have been waiting */ | ||
1317 | GNUNET_CONTAINER_multihashmap32_iterate(t->channels, | ||
1318 | ¬ify_tunnel_up_cb, | ||
1319 | t); | ||
1320 | if (NULL != t->send_task) | ||
1321 | GNUNET_SCHEDULER_cancel(t->send_task); | ||
1322 | t->send_task = GNUNET_SCHEDULER_add_now(&trigger_transmissions, | ||
1323 | t); | ||
1324 | } | 1325 | } |
1326 | /* notify all channels that have been waiting */ | ||
1327 | GNUNET_CONTAINER_multihashmap32_iterate (t->channels, | ||
1328 | ¬ify_tunnel_up_cb, | ||
1329 | t); | ||
1330 | if (NULL != t->send_task) | ||
1331 | GNUNET_SCHEDULER_cancel (t->send_task); | ||
1332 | t->send_task = GNUNET_SCHEDULER_add_now (&trigger_transmissions, | ||
1333 | t); | ||
1334 | } | ||
1325 | } | 1335 | } |
1326 | 1336 | ||
1327 | 1337 | ||
@@ -1334,63 +1344,63 @@ GCT_change_estate(struct CadetTunnel *t, | |||
1334 | * @param ax axolotl key context to use | 1344 | * @param ax axolotl key context to use |
1335 | */ | 1345 | */ |
1336 | static void | 1346 | static void |
1337 | send_kx(struct CadetTunnel *t, | 1347 | send_kx (struct CadetTunnel *t, |
1338 | struct CadetTConnection *ct, | 1348 | struct CadetTConnection *ct, |
1339 | struct CadetTunnelAxolotl *ax) | 1349 | struct CadetTunnelAxolotl *ax) |
1340 | { | 1350 | { |
1341 | struct CadetConnection *cc; | 1351 | struct CadetConnection *cc; |
1342 | struct GNUNET_MQ_Envelope *env; | 1352 | struct GNUNET_MQ_Envelope *env; |
1343 | struct GNUNET_CADET_TunnelKeyExchangeMessage *msg; | 1353 | struct GNUNET_CADET_TunnelKeyExchangeMessage *msg; |
1344 | enum GNUNET_CADET_KX_Flags flags; | 1354 | enum GNUNET_CADET_KX_Flags flags; |
1345 | 1355 | ||
1346 | if (GNUNET_YES != alice_or_betty(GCP_get_id(t->destination))) | 1356 | if (GNUNET_YES != alice_or_betty (GCP_get_id (t->destination))) |
1347 | return; /* only Alice may send KX */ | 1357 | return; /* only Alice may send KX */ |
1348 | if ((NULL == ct) || | 1358 | if ((NULL == ct) || |
1349 | (GNUNET_NO == ct->is_ready)) | 1359 | (GNUNET_NO == ct->is_ready)) |
1350 | ct = get_ready_connection(t); | 1360 | ct = get_ready_connection (t); |
1351 | if (NULL == ct) | 1361 | if (NULL == ct) |
1352 | { | 1362 | { |
1353 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1363 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1354 | "Wanted to send %s in state %s, but no connection is ready, deferring\n", | 1364 | "Wanted to send %s in state %s, but no connection is ready, deferring\n", |
1355 | GCT_2s(t), | 1365 | GCT_2s (t), |
1356 | estate2s(t->estate)); | 1366 | estate2s (t->estate)); |
1357 | t->next_kx_attempt = GNUNET_TIME_absolute_get(); | 1367 | t->next_kx_attempt = GNUNET_TIME_absolute_get (); |
1358 | return; | 1368 | return; |
1359 | } | 1369 | } |
1360 | cc = ct->cc; | 1370 | cc = ct->cc; |
1361 | env = GNUNET_MQ_msg(msg, | 1371 | env = GNUNET_MQ_msg (msg, |
1362 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX); | 1372 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX); |
1363 | flags = GNUNET_CADET_KX_FLAG_FORCE_REPLY; /* always for KX */ | 1373 | flags = GNUNET_CADET_KX_FLAG_FORCE_REPLY; /* always for KX */ |
1364 | msg->flags = htonl(flags); | 1374 | msg->flags = htonl (flags); |
1365 | msg->cid = *GCC_get_id(cc); | 1375 | msg->cid = *GCC_get_id (cc); |
1366 | GNUNET_CRYPTO_ecdhe_key_get_public(&ax->kx_0, | 1376 | GNUNET_CRYPTO_ecdhe_key_get_public (&ax->kx_0, |
1367 | &msg->ephemeral_key); | 1377 | &msg->ephemeral_key); |
1368 | #if DEBUG_KX | 1378 | #if DEBUG_KX |
1369 | msg->ephemeral_key_XXX = ax->kx_0; | 1379 | msg->ephemeral_key_XXX = ax->kx_0; |
1370 | msg->private_key_XXX = *my_private_key; | 1380 | msg->private_key_XXX = *my_private_key; |
1371 | #endif | 1381 | #endif |
1372 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1382 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1373 | "Sending KX message to %s with ephemeral %s on CID %s\n", | 1383 | "Sending KX message to %s with ephemeral %s on CID %s\n", |
1374 | GCT_2s(t), | 1384 | GCT_2s (t), |
1375 | GNUNET_e2s(&msg->ephemeral_key), | 1385 | GNUNET_e2s (&msg->ephemeral_key), |
1376 | GNUNET_sh2s(&msg->cid.connection_of_tunnel)); | 1386 | GNUNET_sh2s (&msg->cid.connection_of_tunnel)); |
1377 | GNUNET_CRYPTO_ecdhe_key_get_public(&ax->DHRs, | 1387 | GNUNET_CRYPTO_ecdhe_key_get_public (&ax->DHRs, |
1378 | &msg->ratchet_key); | 1388 | &msg->ratchet_key); |
1379 | mark_connection_unready(ct); | 1389 | mark_connection_unready (ct); |
1380 | t->kx_retry_delay = GNUNET_TIME_STD_BACKOFF(t->kx_retry_delay); | 1390 | t->kx_retry_delay = GNUNET_TIME_STD_BACKOFF (t->kx_retry_delay); |
1381 | t->next_kx_attempt = GNUNET_TIME_relative_to_absolute(t->kx_retry_delay); | 1391 | t->next_kx_attempt = GNUNET_TIME_relative_to_absolute (t->kx_retry_delay); |
1382 | if (CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) | 1392 | if (CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) |
1383 | GCT_change_estate(t, | 1393 | GCT_change_estate (t, |
1384 | CADET_TUNNEL_KEY_AX_SENT); | 1394 | CADET_TUNNEL_KEY_AX_SENT); |
1385 | else if (CADET_TUNNEL_KEY_AX_RECV == t->estate) | 1395 | else if (CADET_TUNNEL_KEY_AX_RECV == t->estate) |
1386 | GCT_change_estate(t, | 1396 | GCT_change_estate (t, |
1387 | CADET_TUNNEL_KEY_AX_SENT_AND_RECV); | 1397 | CADET_TUNNEL_KEY_AX_SENT_AND_RECV); |
1388 | GCC_transmit(cc, | 1398 | GCC_transmit (cc, |
1389 | env); | 1399 | env); |
1390 | GNUNET_STATISTICS_update(stats, | 1400 | GNUNET_STATISTICS_update (stats, |
1391 | "# KX transmitted", | 1401 | "# KX transmitted", |
1392 | 1, | 1402 | 1, |
1393 | GNUNET_NO); | 1403 | GNUNET_NO); |
1394 | } | 1404 | } |
1395 | 1405 | ||
1396 | 1406 | ||
@@ -1405,10 +1415,10 @@ send_kx(struct CadetTunnel *t, | |||
1405 | * (set if we would like to transmit right now, but cannot) | 1415 | * (set if we would like to transmit right now, but cannot) |
1406 | */ | 1416 | */ |
1407 | static void | 1417 | static void |
1408 | send_kx_auth(struct CadetTunnel *t, | 1418 | send_kx_auth (struct CadetTunnel *t, |
1409 | struct CadetTConnection *ct, | 1419 | struct CadetTConnection *ct, |
1410 | struct CadetTunnelAxolotl *ax, | 1420 | struct CadetTunnelAxolotl *ax, |
1411 | int force_reply) | 1421 | int force_reply) |
1412 | { | 1422 | { |
1413 | struct CadetConnection *cc; | 1423 | struct CadetConnection *cc; |
1414 | struct GNUNET_MQ_Envelope *env; | 1424 | struct GNUNET_MQ_Envelope *env; |
@@ -1417,64 +1427,64 @@ send_kx_auth(struct CadetTunnel *t, | |||
1417 | 1427 | ||
1418 | if ((NULL == ct) || | 1428 | if ((NULL == ct) || |
1419 | (GNUNET_NO == ct->is_ready)) | 1429 | (GNUNET_NO == ct->is_ready)) |
1420 | ct = get_ready_connection(t); | 1430 | ct = get_ready_connection (t); |
1421 | if (NULL == ct) | 1431 | if (NULL == ct) |
1422 | { | 1432 | { |
1423 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1433 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1424 | "Wanted to send KX_AUTH on %s, but no connection is ready, deferring\n", | 1434 | "Wanted to send KX_AUTH on %s, but no connection is ready, deferring\n", |
1425 | GCT_2s(t)); | 1435 | GCT_2s (t)); |
1426 | t->next_kx_attempt = GNUNET_TIME_absolute_get(); | 1436 | t->next_kx_attempt = GNUNET_TIME_absolute_get (); |
1427 | t->kx_auth_requested = GNUNET_YES; /* queue KX_AUTH independent of estate */ | 1437 | t->kx_auth_requested = GNUNET_YES; /* queue KX_AUTH independent of estate */ |
1428 | return; | 1438 | return; |
1429 | } | 1439 | } |
1430 | t->kx_auth_requested = GNUNET_NO; /* clear flag */ | 1440 | t->kx_auth_requested = GNUNET_NO; /* clear flag */ |
1431 | cc = ct->cc; | 1441 | cc = ct->cc; |
1432 | env = GNUNET_MQ_msg(msg, | 1442 | env = GNUNET_MQ_msg (msg, |
1433 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH); | 1443 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH); |
1434 | flags = GNUNET_CADET_KX_FLAG_NONE; | 1444 | flags = GNUNET_CADET_KX_FLAG_NONE; |
1435 | if (GNUNET_YES == force_reply) | 1445 | if (GNUNET_YES == force_reply) |
1436 | flags |= GNUNET_CADET_KX_FLAG_FORCE_REPLY; | 1446 | flags |= GNUNET_CADET_KX_FLAG_FORCE_REPLY; |
1437 | msg->kx.flags = htonl(flags); | 1447 | msg->kx.flags = htonl (flags); |
1438 | msg->kx.cid = *GCC_get_id(cc); | 1448 | msg->kx.cid = *GCC_get_id (cc); |
1439 | GNUNET_CRYPTO_ecdhe_key_get_public(&ax->kx_0, | 1449 | GNUNET_CRYPTO_ecdhe_key_get_public (&ax->kx_0, |
1440 | &msg->kx.ephemeral_key); | 1450 | &msg->kx.ephemeral_key); |
1441 | GNUNET_CRYPTO_ecdhe_key_get_public(&ax->DHRs, | 1451 | GNUNET_CRYPTO_ecdhe_key_get_public (&ax->DHRs, |
1442 | &msg->kx.ratchet_key); | 1452 | &msg->kx.ratchet_key); |
1443 | #if DEBUG_KX | 1453 | #if DEBUG_KX |
1444 | msg->kx.ephemeral_key_XXX = ax->kx_0; | 1454 | msg->kx.ephemeral_key_XXX = ax->kx_0; |
1445 | msg->kx.private_key_XXX = *my_private_key; | 1455 | msg->kx.private_key_XXX = *my_private_key; |
1446 | msg->r_ephemeral_key_XXX = ax->last_ephemeral; | 1456 | msg->r_ephemeral_key_XXX = ax->last_ephemeral; |
1447 | #endif | 1457 | #endif |
1448 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1458 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1449 | "Sending KX_AUTH message to %s with ephemeral %s on CID %s\n", | 1459 | "Sending KX_AUTH message to %s with ephemeral %s on CID %s\n", |
1450 | GCT_2s(t), | 1460 | GCT_2s (t), |
1451 | GNUNET_e2s(&msg->kx.ephemeral_key), | 1461 | GNUNET_e2s (&msg->kx.ephemeral_key), |
1452 | GNUNET_sh2s(&msg->kx.cid.connection_of_tunnel)); | 1462 | GNUNET_sh2s (&msg->kx.cid.connection_of_tunnel)); |
1453 | 1463 | ||
1454 | /* Compute authenticator (this is the main difference to #send_kx()) */ | 1464 | /* Compute authenticator (this is the main difference to #send_kx()) */ |
1455 | GNUNET_CRYPTO_hash(&ax->RK, | 1465 | GNUNET_CRYPTO_hash (&ax->RK, |
1456 | sizeof(ax->RK), | 1466 | sizeof(ax->RK), |
1457 | &msg->auth); | 1467 | &msg->auth); |
1458 | /* Compute when to be triggered again; actual job will | 1468 | /* Compute when to be triggered again; actual job will |
1459 | be scheduled via #connection_ready_cb() */ | 1469 | be scheduled via #connection_ready_cb() */ |
1460 | t->kx_retry_delay | 1470 | t->kx_retry_delay |
1461 | = GNUNET_TIME_STD_BACKOFF(t->kx_retry_delay); | 1471 | = GNUNET_TIME_STD_BACKOFF (t->kx_retry_delay); |
1462 | t->next_kx_attempt | 1472 | t->next_kx_attempt |
1463 | = GNUNET_TIME_relative_to_absolute(t->kx_retry_delay); | 1473 | = GNUNET_TIME_relative_to_absolute (t->kx_retry_delay); |
1464 | 1474 | ||
1465 | /* Send via cc, mark it as unready */ | 1475 | /* Send via cc, mark it as unready */ |
1466 | mark_connection_unready(ct); | 1476 | mark_connection_unready (ct); |
1467 | 1477 | ||
1468 | /* Update state machine, unless we are already OK */ | 1478 | /* Update state machine, unless we are already OK */ |
1469 | if (CADET_TUNNEL_KEY_OK != t->estate) | 1479 | if (CADET_TUNNEL_KEY_OK != t->estate) |
1470 | GCT_change_estate(t, | 1480 | GCT_change_estate (t, |
1471 | CADET_TUNNEL_KEY_AX_AUTH_SENT); | 1481 | CADET_TUNNEL_KEY_AX_AUTH_SENT); |
1472 | GCC_transmit(cc, | 1482 | GCC_transmit (cc, |
1473 | env); | 1483 | env); |
1474 | GNUNET_STATISTICS_update(stats, | 1484 | GNUNET_STATISTICS_update (stats, |
1475 | "# KX_AUTH transmitted", | 1485 | "# KX_AUTH transmitted", |
1476 | 1, | 1486 | 1, |
1477 | GNUNET_NO); | 1487 | GNUNET_NO); |
1478 | } | 1488 | } |
1479 | 1489 | ||
1480 | 1490 | ||
@@ -1484,14 +1494,14 @@ send_kx_auth(struct CadetTunnel *t, | |||
1484 | * @param ax state to free, but not memory of @a ax itself | 1494 | * @param ax state to free, but not memory of @a ax itself |
1485 | */ | 1495 | */ |
1486 | static void | 1496 | static void |
1487 | cleanup_ax(struct CadetTunnelAxolotl *ax) | 1497 | cleanup_ax (struct CadetTunnelAxolotl *ax) |
1488 | { | 1498 | { |
1489 | while (NULL != ax->skipped_head) | 1499 | while (NULL != ax->skipped_head) |
1490 | delete_skipped_key(ax, | 1500 | delete_skipped_key (ax, |
1491 | ax->skipped_head); | 1501 | ax->skipped_head); |
1492 | GNUNET_assert(0 == ax->skipped); | 1502 | GNUNET_assert (0 == ax->skipped); |
1493 | GNUNET_CRYPTO_ecdhe_key_clear(&ax->kx_0); | 1503 | GNUNET_CRYPTO_ecdhe_key_clear (&ax->kx_0); |
1494 | GNUNET_CRYPTO_ecdhe_key_clear(&ax->DHRs); | 1504 | GNUNET_CRYPTO_ecdhe_key_clear (&ax->DHRs); |
1495 | } | 1505 | } |
1496 | 1506 | ||
1497 | 1507 | ||
@@ -1509,105 +1519,105 @@ cleanup_ax(struct CadetTunnelAxolotl *ax) | |||
1509 | * #GNUNET_SYSERR on hard errors (i.e. @a pid is #my_full_id) | 1519 | * #GNUNET_SYSERR on hard errors (i.e. @a pid is #my_full_id) |
1510 | */ | 1520 | */ |
1511 | static int | 1521 | static int |
1512 | update_ax_by_kx(struct CadetTunnelAxolotl *ax, | 1522 | update_ax_by_kx (struct CadetTunnelAxolotl *ax, |
1513 | const struct GNUNET_PeerIdentity *pid, | 1523 | const struct GNUNET_PeerIdentity *pid, |
1514 | const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral_key, | 1524 | const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral_key, |
1515 | const struct GNUNET_CRYPTO_EcdhePublicKey *ratchet_key) | 1525 | const struct GNUNET_CRYPTO_EcdhePublicKey *ratchet_key) |
1516 | { | 1526 | { |
1517 | struct GNUNET_HashCode key_material[3]; | 1527 | struct GNUNET_HashCode key_material[3]; |
1518 | struct GNUNET_CRYPTO_SymmetricSessionKey keys[5]; | 1528 | struct GNUNET_CRYPTO_SymmetricSessionKey keys[5]; |
1519 | const char salt[] = "CADET Axolotl salt"; | 1529 | const char salt[] = "CADET Axolotl salt"; |
1520 | int am_I_alice; | 1530 | int am_I_alice; |
1521 | 1531 | ||
1522 | if (GNUNET_SYSERR == (am_I_alice = alice_or_betty(pid))) | 1532 | if (GNUNET_SYSERR == (am_I_alice = alice_or_betty (pid))) |
1523 | { | 1533 | { |
1524 | GNUNET_break_op(0); | 1534 | GNUNET_break_op (0); |
1525 | return GNUNET_SYSERR; | 1535 | return GNUNET_SYSERR; |
1526 | } | 1536 | } |
1527 | if (0 == GNUNET_memcmp(&ax->DHRr, | 1537 | if (0 == GNUNET_memcmp (&ax->DHRr, |
1528 | ratchet_key)) | 1538 | ratchet_key)) |
1529 | { | 1539 | { |
1530 | GNUNET_STATISTICS_update(stats, | 1540 | GNUNET_STATISTICS_update (stats, |
1531 | "# Ratchet key already known", | 1541 | "# Ratchet key already known", |
1532 | 1, | 1542 | 1, |
1533 | GNUNET_NO); | 1543 | GNUNET_NO); |
1534 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1544 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1535 | "Ratchet key already known. Ignoring KX.\n"); | 1545 | "Ratchet key already known. Ignoring KX.\n"); |
1536 | return GNUNET_NO; | 1546 | return GNUNET_NO; |
1537 | } | 1547 | } |
1538 | 1548 | ||
1539 | ax->DHRr = *ratchet_key; | 1549 | ax->DHRr = *ratchet_key; |
1540 | ax->last_ephemeral = *ephemeral_key; | 1550 | ax->last_ephemeral = *ephemeral_key; |
1541 | /* ECDH A B0 */ | 1551 | /* ECDH A B0 */ |
1542 | if (GNUNET_YES == am_I_alice) | 1552 | if (GNUNET_YES == am_I_alice) |
1543 | { | 1553 | { |
1544 | GNUNET_CRYPTO_eddsa_ecdh(my_private_key, /* a */ | 1554 | GNUNET_CRYPTO_eddsa_ecdh (my_private_key, /* a */ |
1545 | ephemeral_key, /* B0 */ | 1555 | ephemeral_key, /* B0 */ |
1546 | &key_material[0]); | 1556 | &key_material[0]); |
1547 | } | 1557 | } |
1548 | else | 1558 | else |
1549 | { | 1559 | { |
1550 | GNUNET_CRYPTO_ecdh_eddsa(&ax->kx_0, /* b0 */ | 1560 | GNUNET_CRYPTO_ecdh_eddsa (&ax->kx_0, /* b0 */ |
1551 | &pid->public_key, /* A */ | 1561 | &pid->public_key, /* A */ |
1552 | &key_material[0]); | 1562 | &key_material[0]); |
1553 | } | 1563 | } |
1554 | /* ECDH A0 B */ | 1564 | /* ECDH A0 B */ |
1555 | if (GNUNET_YES == am_I_alice) | 1565 | if (GNUNET_YES == am_I_alice) |
1556 | { | 1566 | { |
1557 | GNUNET_CRYPTO_ecdh_eddsa(&ax->kx_0, /* a0 */ | 1567 | GNUNET_CRYPTO_ecdh_eddsa (&ax->kx_0, /* a0 */ |
1558 | &pid->public_key, /* B */ | 1568 | &pid->public_key, /* B */ |
1559 | &key_material[1]); | 1569 | &key_material[1]); |
1560 | } | 1570 | } |
1561 | else | 1571 | else |
1562 | { | 1572 | { |
1563 | GNUNET_CRYPTO_eddsa_ecdh(my_private_key, /* b */ | 1573 | GNUNET_CRYPTO_eddsa_ecdh (my_private_key, /* b */ |
1564 | ephemeral_key, /* A0 */ | 1574 | ephemeral_key, /* A0 */ |
1565 | &key_material[1]); | 1575 | &key_material[1]); |
1566 | } | 1576 | } |
1567 | 1577 | ||
1568 | /* ECDH A0 B0 */ | 1578 | /* ECDH A0 B0 */ |
1569 | GNUNET_CRYPTO_ecc_ecdh(&ax->kx_0, /* a0 or b0 */ | 1579 | GNUNET_CRYPTO_ecc_ecdh (&ax->kx_0, /* a0 or b0 */ |
1570 | ephemeral_key, /* B0 or A0 */ | 1580 | ephemeral_key, /* B0 or A0 */ |
1571 | &key_material[2]); | 1581 | &key_material[2]); |
1572 | /* KDF */ | 1582 | /* KDF */ |
1573 | GNUNET_CRYPTO_kdf(keys, sizeof(keys), | 1583 | GNUNET_CRYPTO_kdf (keys, sizeof(keys), |
1574 | salt, sizeof(salt), | 1584 | salt, sizeof(salt), |
1575 | &key_material, sizeof(key_material), | 1585 | &key_material, sizeof(key_material), |
1576 | NULL); | 1586 | NULL); |
1577 | 1587 | ||
1578 | if (0 == memcmp(&ax->RK, | 1588 | if (0 == memcmp (&ax->RK, |
1579 | &keys[0], | 1589 | &keys[0], |
1580 | sizeof(ax->RK))) | 1590 | sizeof(ax->RK))) |
1581 | { | 1591 | { |
1582 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1592 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1583 | "Root key already known. Ignoring KX.\n"); | 1593 | "Root key already known. Ignoring KX.\n"); |
1584 | GNUNET_STATISTICS_update(stats, | 1594 | GNUNET_STATISTICS_update (stats, |
1585 | "# Root key already known", | 1595 | "# Root key already known", |
1586 | 1, | 1596 | 1, |
1587 | GNUNET_NO); | 1597 | GNUNET_NO); |
1588 | return GNUNET_NO; | 1598 | return GNUNET_NO; |
1589 | } | 1599 | } |
1590 | 1600 | ||
1591 | ax->RK = keys[0]; | 1601 | ax->RK = keys[0]; |
1592 | if (GNUNET_YES == am_I_alice) | 1602 | if (GNUNET_YES == am_I_alice) |
1593 | { | 1603 | { |
1594 | ax->HKr = keys[1]; | 1604 | ax->HKr = keys[1]; |
1595 | ax->NHKs = keys[2]; | 1605 | ax->NHKs = keys[2]; |
1596 | ax->NHKr = keys[3]; | 1606 | ax->NHKr = keys[3]; |
1597 | ax->CKr = keys[4]; | 1607 | ax->CKr = keys[4]; |
1598 | ax->ratchet_flag = GNUNET_YES; | 1608 | ax->ratchet_flag = GNUNET_YES; |
1599 | } | 1609 | } |
1600 | else | 1610 | else |
1601 | { | 1611 | { |
1602 | ax->HKs = keys[1]; | 1612 | ax->HKs = keys[1]; |
1603 | ax->NHKr = keys[2]; | 1613 | ax->NHKr = keys[2]; |
1604 | ax->NHKs = keys[3]; | 1614 | ax->NHKs = keys[3]; |
1605 | ax->CKs = keys[4]; | 1615 | ax->CKs = keys[4]; |
1606 | ax->ratchet_flag = GNUNET_NO; | 1616 | ax->ratchet_flag = GNUNET_NO; |
1607 | ax->ratchet_expiration | 1617 | ax->ratchet_expiration |
1608 | = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), | 1618 | = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), |
1609 | ratchet_time); | 1619 | ratchet_time); |
1610 | } | 1620 | } |
1611 | return GNUNET_OK; | 1621 | return GNUNET_OK; |
1612 | } | 1622 | } |
1613 | 1623 | ||
@@ -1618,89 +1628,89 @@ update_ax_by_kx(struct CadetTunnelAxolotl *ax, | |||
1618 | * @param cls the `struct CadetTunnel` to do KX for. | 1628 | * @param cls the `struct CadetTunnel` to do KX for. |
1619 | */ | 1629 | */ |
1620 | static void | 1630 | static void |
1621 | retry_kx(void *cls) | 1631 | retry_kx (void *cls) |
1622 | { | 1632 | { |
1623 | struct CadetTunnel *t = cls; | 1633 | struct CadetTunnel *t = cls; |
1624 | struct CadetTunnelAxolotl *ax; | 1634 | struct CadetTunnelAxolotl *ax; |
1625 | 1635 | ||
1626 | t->kx_task = NULL; | 1636 | t->kx_task = NULL; |
1627 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1637 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1628 | "Trying to make KX progress on %s in state %s\n", | 1638 | "Trying to make KX progress on %s in state %s\n", |
1629 | GCT_2s(t), | 1639 | GCT_2s (t), |
1630 | estate2s(t->estate)); | 1640 | estate2s (t->estate)); |
1631 | switch (t->estate) | 1641 | switch (t->estate) |
1632 | { | 1642 | { |
1633 | case CADET_TUNNEL_KEY_UNINITIALIZED: /* first attempt */ | 1643 | case CADET_TUNNEL_KEY_UNINITIALIZED: /* first attempt */ |
1634 | case CADET_TUNNEL_KEY_AX_SENT: /* trying again */ | 1644 | case CADET_TUNNEL_KEY_AX_SENT: /* trying again */ |
1635 | send_kx(t, | 1645 | send_kx (t, |
1636 | NULL, | 1646 | NULL, |
1637 | &t->ax); | 1647 | &t->ax); |
1638 | break; | 1648 | break; |
1639 | 1649 | ||
1640 | case CADET_TUNNEL_KEY_AX_RECV: | 1650 | case CADET_TUNNEL_KEY_AX_RECV: |
1641 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: | 1651 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: |
1642 | /* We are responding, so only require reply | 1652 | /* We are responding, so only require reply |
1643 | if WE have a channel waiting. */ | 1653 | if WE have a channel waiting. */ |
1644 | if (NULL != t->unverified_ax) | 1654 | if (NULL != t->unverified_ax) |
1645 | { | 1655 | { |
1646 | /* Send AX_AUTH so we might get this one verified */ | 1656 | /* Send AX_AUTH so we might get this one verified */ |
1647 | ax = t->unverified_ax; | 1657 | ax = t->unverified_ax; |
1648 | } | 1658 | } |
1649 | else | 1659 | else |
1650 | { | 1660 | { |
1651 | /* How can this be? */ | 1661 | /* How can this be? */ |
1652 | GNUNET_break(0); | 1662 | GNUNET_break (0); |
1653 | ax = &t->ax; | 1663 | ax = &t->ax; |
1654 | } | 1664 | } |
1655 | send_kx_auth(t, | 1665 | send_kx_auth (t, |
1656 | NULL, | 1666 | NULL, |
1657 | ax, | 1667 | ax, |
1658 | (0 == GCT_count_channels(t)) | 1668 | (0 == GCT_count_channels (t)) |
1659 | ? GNUNET_NO | 1669 | ? GNUNET_NO |
1660 | : GNUNET_YES); | 1670 | : GNUNET_YES); |
1661 | break; | 1671 | break; |
1662 | 1672 | ||
1663 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: | 1673 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: |
1664 | /* We are responding, so only require reply | 1674 | /* We are responding, so only require reply |
1665 | if WE have a channel waiting. */ | 1675 | if WE have a channel waiting. */ |
1666 | if (NULL != t->unverified_ax) | 1676 | if (NULL != t->unverified_ax) |
1667 | { | 1677 | { |
1668 | /* Send AX_AUTH so we might get this one verified */ | 1678 | /* Send AX_AUTH so we might get this one verified */ |
1669 | ax = t->unverified_ax; | 1679 | ax = t->unverified_ax; |
1670 | } | 1680 | } |
1671 | else | 1681 | else |
1672 | { | 1682 | { |
1673 | /* How can this be? */ | 1683 | /* How can this be? */ |
1674 | GNUNET_break(0); | 1684 | GNUNET_break (0); |
1675 | ax = &t->ax; | 1685 | ax = &t->ax; |
1676 | } | 1686 | } |
1677 | send_kx_auth(t, | 1687 | send_kx_auth (t, |
1678 | NULL, | 1688 | NULL, |
1679 | ax, | 1689 | ax, |
1680 | (0 == GCT_count_channels(t)) | 1690 | (0 == GCT_count_channels (t)) |
1681 | ? GNUNET_NO | 1691 | ? GNUNET_NO |
1682 | : GNUNET_YES); | 1692 | : GNUNET_YES); |
1683 | break; | 1693 | break; |
1684 | 1694 | ||
1685 | case CADET_TUNNEL_KEY_OK: | 1695 | case CADET_TUNNEL_KEY_OK: |
1686 | /* Must have been the *other* peer asking us to | 1696 | /* Must have been the *other* peer asking us to |
1687 | respond with a KX_AUTH. */ | 1697 | respond with a KX_AUTH. */ |
1688 | if (NULL != t->unverified_ax) | 1698 | if (NULL != t->unverified_ax) |
1689 | { | 1699 | { |
1690 | /* Sending AX_AUTH in response to AX so we might get this one verified */ | 1700 | /* Sending AX_AUTH in response to AX so we might get this one verified */ |
1691 | ax = t->unverified_ax; | 1701 | ax = t->unverified_ax; |
1692 | } | ||
1693 | else | ||
1694 | { | ||
1695 | /* Sending AX_AUTH in response to AX_AUTH */ | ||
1696 | ax = &t->ax; | ||
1697 | } | ||
1698 | send_kx_auth(t, | ||
1699 | NULL, | ||
1700 | ax, | ||
1701 | GNUNET_NO); | ||
1702 | break; | ||
1703 | } | 1702 | } |
1703 | else | ||
1704 | { | ||
1705 | /* Sending AX_AUTH in response to AX_AUTH */ | ||
1706 | ax = &t->ax; | ||
1707 | } | ||
1708 | send_kx_auth (t, | ||
1709 | NULL, | ||
1710 | ax, | ||
1711 | GNUNET_NO); | ||
1712 | break; | ||
1713 | } | ||
1704 | } | 1714 | } |
1705 | 1715 | ||
1706 | 1716 | ||
@@ -1713,98 +1723,98 @@ retry_kx(void *cls) | |||
1713 | * @param msg the key exchange message | 1723 | * @param msg the key exchange message |
1714 | */ | 1724 | */ |
1715 | void | 1725 | void |
1716 | GCT_handle_kx(struct CadetTConnection *ct, | 1726 | GCT_handle_kx (struct CadetTConnection *ct, |
1717 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg) | 1727 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg) |
1718 | { | 1728 | { |
1719 | struct CadetTunnel *t = ct->t; | 1729 | struct CadetTunnel *t = ct->t; |
1720 | int ret; | 1730 | int ret; |
1721 | 1731 | ||
1722 | GNUNET_STATISTICS_update(stats, | 1732 | GNUNET_STATISTICS_update (stats, |
1723 | "# KX received", | 1733 | "# KX received", |
1724 | 1, | 1734 | 1, |
1725 | GNUNET_NO); | 1735 | GNUNET_NO); |
1726 | if (GNUNET_YES == | 1736 | if (GNUNET_YES == |
1727 | alice_or_betty(GCP_get_id(t->destination))) | 1737 | alice_or_betty (GCP_get_id (t->destination))) |
1728 | { | 1738 | { |
1729 | /* Betty/Bob is not allowed to send KX! */ | 1739 | /* Betty/Bob is not allowed to send KX! */ |
1730 | GNUNET_break_op(0); | 1740 | GNUNET_break_op (0); |
1731 | return; | 1741 | return; |
1732 | } | 1742 | } |
1733 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1743 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1734 | "Received KX message from %s with ephemeral %s from %s on connection %s\n", | 1744 | "Received KX message from %s with ephemeral %s from %s on connection %s\n", |
1735 | GCT_2s(t), | 1745 | GCT_2s (t), |
1736 | GNUNET_e2s(&msg->ephemeral_key), | 1746 | GNUNET_e2s (&msg->ephemeral_key), |
1737 | GNUNET_i2s(GCP_get_id(t->destination)), | 1747 | GNUNET_i2s (GCP_get_id (t->destination)), |
1738 | GCC_2s(ct->cc)); | 1748 | GCC_2s (ct->cc)); |
1739 | #if 1 | 1749 | #if 1 |
1740 | if ((0 == | 1750 | if ((0 == |
1741 | memcmp(&t->ax.DHRr, | 1751 | memcmp (&t->ax.DHRr, |
1742 | &msg->ratchet_key, | 1752 | &msg->ratchet_key, |
1743 | sizeof(msg->ratchet_key))) && | 1753 | sizeof(msg->ratchet_key))) && |
1744 | (0 == | 1754 | (0 == |
1745 | memcmp(&t->ax.last_ephemeral, | 1755 | memcmp (&t->ax.last_ephemeral, |
1746 | &msg->ephemeral_key, | 1756 | &msg->ephemeral_key, |
1747 | sizeof(msg->ephemeral_key)))) | 1757 | sizeof(msg->ephemeral_key)))) |
1748 | 1758 | ||
1749 | { | 1759 | { |
1750 | GNUNET_STATISTICS_update(stats, | 1760 | GNUNET_STATISTICS_update (stats, |
1751 | "# Duplicate KX received", | 1761 | "# Duplicate KX received", |
1752 | 1, | 1762 | 1, |
1753 | GNUNET_NO); | 1763 | GNUNET_NO); |
1754 | send_kx_auth(t, | 1764 | send_kx_auth (t, |
1755 | ct, | 1765 | ct, |
1756 | &t->ax, | 1766 | &t->ax, |
1757 | GNUNET_NO); | 1767 | GNUNET_NO); |
1758 | return; | 1768 | return; |
1759 | } | 1769 | } |
1760 | #endif | 1770 | #endif |
1761 | /* We only keep ONE unverified KX around, so if there is an existing one, | 1771 | /* We only keep ONE unverified KX around, so if there is an existing one, |
1762 | clean it up. */ | 1772 | clean it up. */ |
1763 | if (NULL != t->unverified_ax) | 1773 | if (NULL != t->unverified_ax) |
1764 | { | 1774 | { |
1765 | if ((0 == | 1775 | if ((0 == |
1766 | memcmp(&t->unverified_ax->DHRr, | 1776 | memcmp (&t->unverified_ax->DHRr, |
1767 | &msg->ratchet_key, | 1777 | &msg->ratchet_key, |
1768 | sizeof(msg->ratchet_key))) && | 1778 | sizeof(msg->ratchet_key))) && |
1769 | (0 == | 1779 | (0 == |
1770 | memcmp(&t->unverified_ax->last_ephemeral, | 1780 | memcmp (&t->unverified_ax->last_ephemeral, |
1771 | &msg->ephemeral_key, | 1781 | &msg->ephemeral_key, |
1772 | sizeof(msg->ephemeral_key)))) | 1782 | sizeof(msg->ephemeral_key)))) |
1773 | { | 1783 | { |
1774 | GNUNET_STATISTICS_update(stats, | 1784 | GNUNET_STATISTICS_update (stats, |
1775 | "# Duplicate unverified KX received", | 1785 | "# Duplicate unverified KX received", |
1776 | 1, | 1786 | 1, |
1777 | GNUNET_NO); | 1787 | GNUNET_NO); |
1778 | #if 1 | 1788 | #if 1 |
1779 | send_kx_auth(t, | 1789 | send_kx_auth (t, |
1780 | ct, | 1790 | ct, |
1781 | t->unverified_ax, | 1791 | t->unverified_ax, |
1782 | GNUNET_NO); | 1792 | GNUNET_NO); |
1783 | return; | 1793 | return; |
1784 | #endif | 1794 | #endif |
1785 | } | ||
1786 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1787 | "Dropping old unverified KX state.\n"); | ||
1788 | GNUNET_STATISTICS_update(stats, | ||
1789 | "# Unverified KX dropped for fresh KX", | ||
1790 | 1, | ||
1791 | GNUNET_NO); | ||
1792 | GNUNET_break(NULL == t->unverified_ax->skipped_head); | ||
1793 | memset(t->unverified_ax, | ||
1794 | 0, | ||
1795 | sizeof(struct CadetTunnelAxolotl)); | ||
1796 | } | 1795 | } |
1796 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1797 | "Dropping old unverified KX state.\n"); | ||
1798 | GNUNET_STATISTICS_update (stats, | ||
1799 | "# Unverified KX dropped for fresh KX", | ||
1800 | 1, | ||
1801 | GNUNET_NO); | ||
1802 | GNUNET_break (NULL == t->unverified_ax->skipped_head); | ||
1803 | memset (t->unverified_ax, | ||
1804 | 0, | ||
1805 | sizeof(struct CadetTunnelAxolotl)); | ||
1806 | } | ||
1797 | else | 1807 | else |
1798 | { | 1808 | { |
1799 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1809 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1800 | "Creating fresh unverified KX for %s\n", | 1810 | "Creating fresh unverified KX for %s\n", |
1801 | GCT_2s(t)); | 1811 | GCT_2s (t)); |
1802 | GNUNET_STATISTICS_update(stats, | 1812 | GNUNET_STATISTICS_update (stats, |
1803 | "# Fresh KX setup", | 1813 | "# Fresh KX setup", |
1804 | 1, | 1814 | 1, |
1805 | GNUNET_NO); | 1815 | GNUNET_NO); |
1806 | t->unverified_ax = GNUNET_new(struct CadetTunnelAxolotl); | 1816 | t->unverified_ax = GNUNET_new (struct CadetTunnelAxolotl); |
1807 | } | 1817 | } |
1808 | /* Set as the 'current' RK/DHRr the one we are currently using, | 1818 | /* Set as the 'current' RK/DHRr the one we are currently using, |
1809 | so that the duplicate-detection logic of | 1819 | so that the duplicate-detection logic of |
1810 | #update_ax_by_kx can work. */ | 1820 | #update_ax_by_kx can work. */ |
@@ -1815,101 +1825,101 @@ GCT_handle_kx(struct CadetTConnection *ct, | |||
1815 | t->unverified_attempts = 0; | 1825 | t->unverified_attempts = 0; |
1816 | 1826 | ||
1817 | /* Update 'ax' by the new key material */ | 1827 | /* Update 'ax' by the new key material */ |
1818 | ret = update_ax_by_kx(t->unverified_ax, | 1828 | ret = update_ax_by_kx (t->unverified_ax, |
1819 | GCP_get_id(t->destination), | 1829 | GCP_get_id (t->destination), |
1820 | &msg->ephemeral_key, | 1830 | &msg->ephemeral_key, |
1821 | &msg->ratchet_key); | 1831 | &msg->ratchet_key); |
1822 | GNUNET_break(GNUNET_SYSERR != ret); | 1832 | GNUNET_break (GNUNET_SYSERR != ret); |
1823 | if (GNUNET_OK != ret) | 1833 | if (GNUNET_OK != ret) |
1824 | { | 1834 | { |
1825 | GNUNET_STATISTICS_update(stats, | 1835 | GNUNET_STATISTICS_update (stats, |
1826 | "# Useless KX", | 1836 | "# Useless KX", |
1827 | 1, | 1837 | 1, |
1828 | GNUNET_NO); | 1838 | GNUNET_NO); |
1829 | return; /* duplicate KX, nothing to do */ | 1839 | return; /* duplicate KX, nothing to do */ |
1830 | } | 1840 | } |
1831 | /* move ahead in our state machine */ | 1841 | /* move ahead in our state machine */ |
1832 | if (CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) | 1842 | if (CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) |
1833 | GCT_change_estate(t, | 1843 | GCT_change_estate (t, |
1834 | CADET_TUNNEL_KEY_AX_RECV); | 1844 | CADET_TUNNEL_KEY_AX_RECV); |
1835 | else if (CADET_TUNNEL_KEY_AX_SENT == t->estate) | 1845 | else if (CADET_TUNNEL_KEY_AX_SENT == t->estate) |
1836 | GCT_change_estate(t, | 1846 | GCT_change_estate (t, |
1837 | CADET_TUNNEL_KEY_AX_SENT_AND_RECV); | 1847 | CADET_TUNNEL_KEY_AX_SENT_AND_RECV); |
1838 | 1848 | ||
1839 | /* KX is still not done, try again our end. */ | 1849 | /* KX is still not done, try again our end. */ |
1840 | if (CADET_TUNNEL_KEY_OK != t->estate) | 1850 | if (CADET_TUNNEL_KEY_OK != t->estate) |
1841 | { | 1851 | { |
1842 | if (NULL != t->kx_task) | 1852 | if (NULL != t->kx_task) |
1843 | GNUNET_SCHEDULER_cancel(t->kx_task); | 1853 | GNUNET_SCHEDULER_cancel (t->kx_task); |
1844 | t->kx_task | 1854 | t->kx_task |
1845 | = GNUNET_SCHEDULER_add_now(&retry_kx, | 1855 | = GNUNET_SCHEDULER_add_now (&retry_kx, |
1846 | t); | 1856 | t); |
1847 | } | 1857 | } |
1848 | } | 1858 | } |
1849 | 1859 | ||
1850 | 1860 | ||
1851 | #if DEBUG_KX | 1861 | #if DEBUG_KX |
1852 | static void | 1862 | static void |
1853 | check_ee(const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, | 1863 | check_ee (const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, |
1854 | const struct GNUNET_CRYPTO_EcdhePrivateKey *e2) | 1864 | const struct GNUNET_CRYPTO_EcdhePrivateKey *e2) |
1855 | { | 1865 | { |
1856 | struct GNUNET_CRYPTO_EcdhePublicKey p1; | 1866 | struct GNUNET_CRYPTO_EcdhePublicKey p1; |
1857 | struct GNUNET_CRYPTO_EcdhePublicKey p2; | 1867 | struct GNUNET_CRYPTO_EcdhePublicKey p2; |
1858 | struct GNUNET_HashCode hc1; | 1868 | struct GNUNET_HashCode hc1; |
1859 | struct GNUNET_HashCode hc2; | 1869 | struct GNUNET_HashCode hc2; |
1860 | 1870 | ||
1861 | GNUNET_CRYPTO_ecdhe_key_get_public(e1, | 1871 | GNUNET_CRYPTO_ecdhe_key_get_public (e1, |
1862 | &p1); | 1872 | &p1); |
1863 | GNUNET_CRYPTO_ecdhe_key_get_public(e2, | 1873 | GNUNET_CRYPTO_ecdhe_key_get_public (e2, |
1864 | &p2); | 1874 | &p2); |
1865 | GNUNET_assert(GNUNET_OK == | 1875 | GNUNET_assert (GNUNET_OK == |
1866 | GNUNET_CRYPTO_ecc_ecdh(e1, | 1876 | GNUNET_CRYPTO_ecc_ecdh (e1, |
1867 | &p2, | 1877 | &p2, |
1868 | &hc1)); | 1878 | &hc1)); |
1869 | GNUNET_assert(GNUNET_OK == | 1879 | GNUNET_assert (GNUNET_OK == |
1870 | GNUNET_CRYPTO_ecc_ecdh(e2, | 1880 | GNUNET_CRYPTO_ecc_ecdh (e2, |
1871 | &p1, | 1881 | &p1, |
1872 | &hc2)); | 1882 | &hc2)); |
1873 | GNUNET_break(0 == GNUNET_memcmp(&hc1, | 1883 | GNUNET_break (0 == GNUNET_memcmp (&hc1, |
1874 | &hc2)); | 1884 | &hc2)); |
1875 | } | 1885 | } |
1876 | 1886 | ||
1877 | 1887 | ||
1878 | static void | 1888 | static void |
1879 | check_ed(const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, | 1889 | check_ed (const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, |
1880 | const struct GNUNET_CRYPTO_EddsaPrivateKey *e2) | 1890 | const struct GNUNET_CRYPTO_EddsaPrivateKey *e2) |
1881 | { | 1891 | { |
1882 | struct GNUNET_CRYPTO_EcdhePublicKey p1; | 1892 | struct GNUNET_CRYPTO_EcdhePublicKey p1; |
1883 | struct GNUNET_CRYPTO_EddsaPublicKey p2; | 1893 | struct GNUNET_CRYPTO_EddsaPublicKey p2; |
1884 | struct GNUNET_HashCode hc1; | 1894 | struct GNUNET_HashCode hc1; |
1885 | struct GNUNET_HashCode hc2; | 1895 | struct GNUNET_HashCode hc2; |
1886 | 1896 | ||
1887 | GNUNET_CRYPTO_ecdhe_key_get_public(e1, | 1897 | GNUNET_CRYPTO_ecdhe_key_get_public (e1, |
1888 | &p1); | 1898 | &p1); |
1889 | GNUNET_CRYPTO_eddsa_key_get_public(e2, | 1899 | GNUNET_CRYPTO_eddsa_key_get_public (e2, |
1890 | &p2); | 1900 | &p2); |
1891 | GNUNET_assert(GNUNET_OK == | 1901 | GNUNET_assert (GNUNET_OK == |
1892 | GNUNET_CRYPTO_ecdh_eddsa(e1, | 1902 | GNUNET_CRYPTO_ecdh_eddsa (e1, |
1893 | &p2, | 1903 | &p2, |
1894 | &hc1)); | 1904 | &hc1)); |
1895 | GNUNET_assert(GNUNET_OK == | 1905 | GNUNET_assert (GNUNET_OK == |
1896 | GNUNET_CRYPTO_eddsa_ecdh(e2, | 1906 | GNUNET_CRYPTO_eddsa_ecdh (e2, |
1897 | &p1, | 1907 | &p1, |
1898 | &hc2)); | 1908 | &hc2)); |
1899 | GNUNET_break(0 == GNUNET_memcmp(&hc1, | 1909 | GNUNET_break (0 == GNUNET_memcmp (&hc1, |
1900 | &hc2)); | 1910 | &hc2)); |
1901 | } | 1911 | } |
1902 | 1912 | ||
1903 | 1913 | ||
1904 | static void | 1914 | static void |
1905 | test_crypto_bug(const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, | 1915 | test_crypto_bug (const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, |
1906 | const struct GNUNET_CRYPTO_EcdhePrivateKey *e2, | 1916 | const struct GNUNET_CRYPTO_EcdhePrivateKey *e2, |
1907 | const struct GNUNET_CRYPTO_EddsaPrivateKey *d1, | 1917 | const struct GNUNET_CRYPTO_EddsaPrivateKey *d1, |
1908 | const struct GNUNET_CRYPTO_EddsaPrivateKey *d2) | 1918 | const struct GNUNET_CRYPTO_EddsaPrivateKey *d2) |
1909 | { | 1919 | { |
1910 | check_ee(e1, e2); | 1920 | check_ee (e1, e2); |
1911 | check_ed(e1, d2); | 1921 | check_ed (e1, d2); |
1912 | check_ed(e2, d1); | 1922 | check_ed (e2, d1); |
1913 | } | 1923 | } |
1914 | 1924 | ||
1915 | #endif | 1925 | #endif |
@@ -1922,135 +1932,135 @@ test_crypto_bug(const struct GNUNET_CRYPTO_EcdhePrivateKey *e1, | |||
1922 | * @param msg the key exchange message | 1932 | * @param msg the key exchange message |
1923 | */ | 1933 | */ |
1924 | void | 1934 | void |
1925 | GCT_handle_kx_auth(struct CadetTConnection *ct, | 1935 | GCT_handle_kx_auth (struct CadetTConnection *ct, |
1926 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg) | 1936 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg) |
1927 | { | 1937 | { |
1928 | struct CadetTunnel *t = ct->t; | 1938 | struct CadetTunnel *t = ct->t; |
1929 | struct CadetTunnelAxolotl ax_tmp; | 1939 | struct CadetTunnelAxolotl ax_tmp; |
1930 | struct GNUNET_HashCode kx_auth; | 1940 | struct GNUNET_HashCode kx_auth; |
1931 | int ret; | 1941 | int ret; |
1932 | 1942 | ||
1933 | GNUNET_STATISTICS_update(stats, | 1943 | GNUNET_STATISTICS_update (stats, |
1934 | "# KX_AUTH received", | 1944 | "# KX_AUTH received", |
1935 | 1, | 1945 | 1, |
1936 | GNUNET_NO); | 1946 | GNUNET_NO); |
1937 | if ((CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) || | 1947 | if ((CADET_TUNNEL_KEY_UNINITIALIZED == t->estate) || |
1938 | (CADET_TUNNEL_KEY_AX_RECV == t->estate)) | 1948 | (CADET_TUNNEL_KEY_AX_RECV == t->estate)) |
1939 | { | 1949 | { |
1940 | /* Confusing, we got a KX_AUTH before we even send our own | 1950 | /* Confusing, we got a KX_AUTH before we even send our own |
1941 | KX. This should not happen. We'll send our own KX ASAP anyway, | 1951 | KX. This should not happen. We'll send our own KX ASAP anyway, |
1942 | so let's ignore this here. */ | 1952 | so let's ignore this here. */ |
1943 | GNUNET_break_op(0); | 1953 | GNUNET_break_op (0); |
1944 | return; | 1954 | return; |
1945 | } | 1955 | } |
1946 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1956 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1947 | "Handling KX_AUTH message from %s with ephemeral %s\n", | 1957 | "Handling KX_AUTH message from %s with ephemeral %s\n", |
1948 | GCT_2s(t), | 1958 | GCT_2s (t), |
1949 | GNUNET_e2s(&msg->kx.ephemeral_key)); | 1959 | GNUNET_e2s (&msg->kx.ephemeral_key)); |
1950 | /* We do everything in ax_tmp until we've checked the authentication | 1960 | /* We do everything in ax_tmp until we've checked the authentication |
1951 | so we don't clobber anything we care about by accident. */ | 1961 | so we don't clobber anything we care about by accident. */ |
1952 | ax_tmp = t->ax; | 1962 | ax_tmp = t->ax; |
1953 | 1963 | ||
1954 | /* Update 'ax' by the new key material */ | 1964 | /* Update 'ax' by the new key material */ |
1955 | ret = update_ax_by_kx(&ax_tmp, | 1965 | ret = update_ax_by_kx (&ax_tmp, |
1956 | GCP_get_id(t->destination), | 1966 | GCP_get_id (t->destination), |
1957 | &msg->kx.ephemeral_key, | 1967 | &msg->kx.ephemeral_key, |
1958 | &msg->kx.ratchet_key); | 1968 | &msg->kx.ratchet_key); |
1959 | if (GNUNET_OK != ret) | 1969 | if (GNUNET_OK != ret) |
1970 | { | ||
1971 | if (GNUNET_NO == ret) | ||
1972 | GNUNET_STATISTICS_update (stats, | ||
1973 | "# redundant KX_AUTH received", | ||
1974 | 1, | ||
1975 | GNUNET_NO); | ||
1976 | else | ||
1977 | GNUNET_break (0); /* connect to self!? */ | ||
1978 | return; | ||
1979 | } | ||
1980 | GNUNET_CRYPTO_hash (&ax_tmp.RK, | ||
1981 | sizeof(ax_tmp.RK), | ||
1982 | &kx_auth); | ||
1983 | if (0 != GNUNET_memcmp (&kx_auth, | ||
1984 | &msg->auth)) | ||
1985 | { | ||
1986 | /* This KX_AUTH is not using the latest KX/KX_AUTH data | ||
1987 | we transmitted to the sender, refuse it, try KX again. */ | ||
1988 | GNUNET_STATISTICS_update (stats, | ||
1989 | "# KX_AUTH not using our last KX received (auth failure)", | ||
1990 | 1, | ||
1991 | GNUNET_NO); | ||
1992 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
1993 | "KX AUTH mismatch!\n"); | ||
1994 | #if DEBUG_KX | ||
1960 | { | 1995 | { |
1961 | if (GNUNET_NO == ret) | 1996 | struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key; |
1962 | GNUNET_STATISTICS_update(stats, | 1997 | |
1963 | "# redundant KX_AUTH received", | 1998 | GNUNET_CRYPTO_ecdhe_key_get_public (&ax_tmp.kx_0, |
1964 | 1, | 1999 | &ephemeral_key); |
1965 | GNUNET_NO); | 2000 | if (0 != GNUNET_memcmp (&ephemeral_key, |
2001 | &msg->r_ephemeral_key_XXX)) | ||
2002 | { | ||
2003 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
2004 | "My ephemeral is %s!\n", | ||
2005 | GNUNET_e2s (&ephemeral_key)); | ||
2006 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
2007 | "Response is for ephemeral %s!\n", | ||
2008 | GNUNET_e2s (&msg->r_ephemeral_key_XXX)); | ||
2009 | } | ||
1966 | else | 2010 | else |
1967 | GNUNET_break(0); /* connect to self!? */ | ||
1968 | return; | ||
1969 | } | ||
1970 | GNUNET_CRYPTO_hash(&ax_tmp.RK, | ||
1971 | sizeof(ax_tmp.RK), | ||
1972 | &kx_auth); | ||
1973 | if (0 != GNUNET_memcmp(&kx_auth, | ||
1974 | &msg->auth)) | ||
1975 | { | ||
1976 | /* This KX_AUTH is not using the latest KX/KX_AUTH data | ||
1977 | we transmitted to the sender, refuse it, try KX again. */ | ||
1978 | GNUNET_STATISTICS_update(stats, | ||
1979 | "# KX_AUTH not using our last KX received (auth failure)", | ||
1980 | 1, | ||
1981 | GNUNET_NO); | ||
1982 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
1983 | "KX AUTH mismatch!\n"); | ||
1984 | #if DEBUG_KX | ||
1985 | { | 2011 | { |
1986 | struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key; | 2012 | test_crypto_bug (&ax_tmp.kx_0, |
1987 | 2013 | &msg->kx.ephemeral_key_XXX, | |
1988 | GNUNET_CRYPTO_ecdhe_key_get_public(&ax_tmp.kx_0, | 2014 | my_private_key, |
1989 | &ephemeral_key); | 2015 | &msg->kx.private_key_XXX); |
1990 | if (0 != GNUNET_memcmp(&ephemeral_key, | ||
1991 | &msg->r_ephemeral_key_XXX)) | ||
1992 | { | ||
1993 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
1994 | "My ephemeral is %s!\n", | ||
1995 | GNUNET_e2s(&ephemeral_key)); | ||
1996 | LOG(GNUNET_ERROR_TYPE_WARNING, | ||
1997 | "Response is for ephemeral %s!\n", | ||
1998 | GNUNET_e2s(&msg->r_ephemeral_key_XXX)); | ||
1999 | } | ||
2000 | else | ||
2001 | { | ||
2002 | test_crypto_bug(&ax_tmp.kx_0, | ||
2003 | &msg->kx.ephemeral_key_XXX, | ||
2004 | my_private_key, | ||
2005 | &msg->kx.private_key_XXX); | ||
2006 | } | ||
2007 | } | 2016 | } |
2008 | #endif | ||
2009 | if (NULL == t->kx_task) | ||
2010 | t->kx_task | ||
2011 | = GNUNET_SCHEDULER_add_at(t->next_kx_attempt, | ||
2012 | &retry_kx, | ||
2013 | t); | ||
2014 | return; | ||
2015 | } | 2017 | } |
2018 | #endif | ||
2019 | if (NULL == t->kx_task) | ||
2020 | t->kx_task | ||
2021 | = GNUNET_SCHEDULER_add_at (t->next_kx_attempt, | ||
2022 | &retry_kx, | ||
2023 | t); | ||
2024 | return; | ||
2025 | } | ||
2016 | /* Yep, we're good. */ | 2026 | /* Yep, we're good. */ |
2017 | t->ax = ax_tmp; | 2027 | t->ax = ax_tmp; |
2018 | if (NULL != t->unverified_ax) | 2028 | if (NULL != t->unverified_ax) |
2019 | { | 2029 | { |
2020 | /* We got some "stale" KX before, drop that. */ | 2030 | /* We got some "stale" KX before, drop that. */ |
2021 | cleanup_ax(t->unverified_ax); | 2031 | cleanup_ax (t->unverified_ax); |
2022 | GNUNET_free(t->unverified_ax); | 2032 | GNUNET_free (t->unverified_ax); |
2023 | t->unverified_ax = NULL; | 2033 | t->unverified_ax = NULL; |
2024 | } | 2034 | } |
2025 | 2035 | ||
2026 | /* move ahead in our state machine */ | 2036 | /* move ahead in our state machine */ |
2027 | switch (t->estate) | 2037 | switch (t->estate) |
2028 | { | 2038 | { |
2029 | case CADET_TUNNEL_KEY_UNINITIALIZED: | 2039 | case CADET_TUNNEL_KEY_UNINITIALIZED: |
2030 | case CADET_TUNNEL_KEY_AX_RECV: | 2040 | case CADET_TUNNEL_KEY_AX_RECV: |
2031 | /* Checked above, this is impossible. */ | 2041 | /* Checked above, this is impossible. */ |
2032 | GNUNET_assert(0); | 2042 | GNUNET_assert (0); |
2033 | break; | 2043 | break; |
2034 | 2044 | ||
2035 | case CADET_TUNNEL_KEY_AX_SENT: /* This is the normal case */ | 2045 | case CADET_TUNNEL_KEY_AX_SENT: /* This is the normal case */ |
2036 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: /* both peers started KX */ | 2046 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: /* both peers started KX */ |
2037 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: /* both peers now did KX_AUTH */ | 2047 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: /* both peers now did KX_AUTH */ |
2038 | GCT_change_estate(t, | 2048 | GCT_change_estate (t, |
2039 | CADET_TUNNEL_KEY_OK); | 2049 | CADET_TUNNEL_KEY_OK); |
2040 | break; | 2050 | break; |
2041 | 2051 | ||
2042 | case CADET_TUNNEL_KEY_OK: | 2052 | case CADET_TUNNEL_KEY_OK: |
2043 | /* Did not expect another KX_AUTH, but so what, still acceptable. | 2053 | /* Did not expect another KX_AUTH, but so what, still acceptable. |
2044 | Nothing to do here. */ | 2054 | Nothing to do here. */ |
2045 | break; | 2055 | break; |
2046 | } | 2056 | } |
2047 | if (0 != (GNUNET_CADET_KX_FLAG_FORCE_REPLY & ntohl(msg->kx.flags))) | 2057 | if (0 != (GNUNET_CADET_KX_FLAG_FORCE_REPLY & ntohl (msg->kx.flags))) |
2048 | { | 2058 | { |
2049 | send_kx_auth(t, | 2059 | send_kx_auth (t, |
2050 | NULL, | 2060 | NULL, |
2051 | &t->ax, | 2061 | &t->ax, |
2052 | GNUNET_NO); | 2062 | GNUNET_NO); |
2053 | } | 2063 | } |
2054 | } | 2064 | } |
2055 | 2065 | ||
2056 | 2066 | ||
@@ -2065,7 +2075,7 @@ GCT_handle_kx_auth(struct CadetTConnection *ct, | |||
2065 | * @return unused number that can uniquely identify a channel in the tunnel | 2075 | * @return unused number that can uniquely identify a channel in the tunnel |
2066 | */ | 2076 | */ |
2067 | static struct GNUNET_CADET_ChannelTunnelNumber | 2077 | static struct GNUNET_CADET_ChannelTunnelNumber |
2068 | get_next_free_ctn(struct CadetTunnel *t) | 2078 | get_next_free_ctn (struct CadetTunnel *t) |
2069 | { | 2079 | { |
2070 | #define HIGH_BIT 0x8000000 | 2080 | #define HIGH_BIT 0x8000000 |
2071 | struct GNUNET_CADET_ChannelTunnelNumber ret; | 2081 | struct GNUNET_CADET_ChannelTunnelNumber ret; |
@@ -2073,23 +2083,23 @@ get_next_free_ctn(struct CadetTunnel *t) | |||
2073 | int cmp; | 2083 | int cmp; |
2074 | uint32_t highbit; | 2084 | uint32_t highbit; |
2075 | 2085 | ||
2076 | cmp = GNUNET_memcmp(&my_full_id, | 2086 | cmp = GNUNET_memcmp (&my_full_id, |
2077 | GCP_get_id(GCT_get_destination(t))); | 2087 | GCP_get_id (GCT_get_destination (t))); |
2078 | if (0 < cmp) | 2088 | if (0 < cmp) |
2079 | highbit = HIGH_BIT; | 2089 | highbit = HIGH_BIT; |
2080 | else if (0 > cmp) | 2090 | else if (0 > cmp) |
2081 | highbit = 0; | 2091 | highbit = 0; |
2082 | else | 2092 | else |
2083 | GNUNET_assert(0); // loopback must never go here! | 2093 | GNUNET_assert (0); // loopback must never go here! |
2084 | ctn = ntohl(t->next_ctn.cn); | 2094 | ctn = ntohl (t->next_ctn.cn); |
2085 | while (NULL != | 2095 | while (NULL != |
2086 | GNUNET_CONTAINER_multihashmap32_get(t->channels, | 2096 | GNUNET_CONTAINER_multihashmap32_get (t->channels, |
2087 | ctn | highbit)) | 2097 | ctn | highbit)) |
2088 | { | 2098 | { |
2089 | ctn = ((ctn + 1) & (~HIGH_BIT)); | 2099 | ctn = ((ctn + 1) & (~HIGH_BIT)); |
2090 | } | 2100 | } |
2091 | t->next_ctn.cn = htonl((ctn + 1) & (~HIGH_BIT)); | 2101 | t->next_ctn.cn = htonl ((ctn + 1) & (~HIGH_BIT)); |
2092 | ret.cn = htonl(ctn | highbit); | 2102 | ret.cn = htonl (ctn | highbit); |
2093 | return ret; | 2103 | return ret; |
2094 | } | 2104 | } |
2095 | 2105 | ||
@@ -2104,53 +2114,53 @@ get_next_free_ctn(struct CadetTunnel *t) | |||
2104 | * @return unique number identifying @a ch within @a t | 2114 | * @return unique number identifying @a ch within @a t |
2105 | */ | 2115 | */ |
2106 | struct GNUNET_CADET_ChannelTunnelNumber | 2116 | struct GNUNET_CADET_ChannelTunnelNumber |
2107 | GCT_add_channel(struct CadetTunnel *t, | 2117 | GCT_add_channel (struct CadetTunnel *t, |
2108 | struct CadetChannel *ch) | 2118 | struct CadetChannel *ch) |
2109 | { | 2119 | { |
2110 | struct GNUNET_CADET_ChannelTunnelNumber ctn; | 2120 | struct GNUNET_CADET_ChannelTunnelNumber ctn; |
2111 | 2121 | ||
2112 | ctn = get_next_free_ctn(t); | 2122 | ctn = get_next_free_ctn (t); |
2113 | if (NULL != t->destroy_task) | 2123 | if (NULL != t->destroy_task) |
2114 | { | 2124 | { |
2115 | GNUNET_SCHEDULER_cancel(t->destroy_task); | 2125 | GNUNET_SCHEDULER_cancel (t->destroy_task); |
2116 | t->destroy_task = NULL; | 2126 | t->destroy_task = NULL; |
2117 | } | 2127 | } |
2118 | GNUNET_assert(GNUNET_YES == | 2128 | GNUNET_assert (GNUNET_YES == |
2119 | GNUNET_CONTAINER_multihashmap32_put(t->channels, | 2129 | GNUNET_CONTAINER_multihashmap32_put (t->channels, |
2120 | ntohl(ctn.cn), | 2130 | ntohl (ctn.cn), |
2121 | ch, | 2131 | ch, |
2122 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 2132 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
2123 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2133 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2124 | "Adding %s to %s\n", | 2134 | "Adding %s to %s\n", |
2125 | GCCH_2s(ch), | 2135 | GCCH_2s (ch), |
2126 | GCT_2s(t)); | 2136 | GCT_2s (t)); |
2127 | switch (t->estate) | 2137 | switch (t->estate) |
2128 | { | 2138 | { |
2129 | case CADET_TUNNEL_KEY_UNINITIALIZED: | 2139 | case CADET_TUNNEL_KEY_UNINITIALIZED: |
2130 | /* waiting for connection to start KX */ | 2140 | /* waiting for connection to start KX */ |
2131 | break; | 2141 | break; |
2132 | 2142 | ||
2133 | case CADET_TUNNEL_KEY_AX_RECV: | 2143 | case CADET_TUNNEL_KEY_AX_RECV: |
2134 | case CADET_TUNNEL_KEY_AX_SENT: | 2144 | case CADET_TUNNEL_KEY_AX_SENT: |
2135 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: | 2145 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: |
2136 | /* we're currently waiting for KX to complete */ | 2146 | /* we're currently waiting for KX to complete */ |
2137 | break; | 2147 | break; |
2138 | 2148 | ||
2139 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: | 2149 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: |
2140 | /* waiting for OTHER peer to send us data, | 2150 | /* waiting for OTHER peer to send us data, |
2141 | we might need to prompt more aggressively! */ | 2151 | we might need to prompt more aggressively! */ |
2142 | if (NULL == t->kx_task) | 2152 | if (NULL == t->kx_task) |
2143 | t->kx_task | 2153 | t->kx_task |
2144 | = GNUNET_SCHEDULER_add_at(t->next_kx_attempt, | 2154 | = GNUNET_SCHEDULER_add_at (t->next_kx_attempt, |
2145 | &retry_kx, | 2155 | &retry_kx, |
2146 | t); | 2156 | t); |
2147 | break; | 2157 | break; |
2148 | 2158 | ||
2149 | case CADET_TUNNEL_KEY_OK: | 2159 | case CADET_TUNNEL_KEY_OK: |
2150 | /* We are ready. Tell the new channel that we are up. */ | 2160 | /* We are ready. Tell the new channel that we are up. */ |
2151 | GCCH_tunnel_up(ch); | 2161 | GCCH_tunnel_up (ch); |
2152 | break; | 2162 | break; |
2153 | } | 2163 | } |
2154 | return ctn; | 2164 | return ctn; |
2155 | } | 2165 | } |
2156 | 2166 | ||
@@ -2162,25 +2172,25 @@ GCT_add_channel(struct CadetTunnel *t, | |||
2162 | * @param ct binding of connection to tunnel of the connection that was lost. | 2172 | * @param ct binding of connection to tunnel of the connection that was lost. |
2163 | */ | 2173 | */ |
2164 | void | 2174 | void |
2165 | GCT_connection_lost(struct CadetTConnection *ct) | 2175 | GCT_connection_lost (struct CadetTConnection *ct) |
2166 | { | 2176 | { |
2167 | struct CadetTunnel *t = ct->t; | 2177 | struct CadetTunnel *t = ct->t; |
2168 | 2178 | ||
2169 | if (GNUNET_YES == ct->is_ready) | 2179 | if (GNUNET_YES == ct->is_ready) |
2170 | { | 2180 | { |
2171 | GNUNET_CONTAINER_DLL_remove(t->connection_ready_head, | 2181 | GNUNET_CONTAINER_DLL_remove (t->connection_ready_head, |
2172 | t->connection_ready_tail, | 2182 | t->connection_ready_tail, |
2173 | ct); | 2183 | ct); |
2174 | t->num_ready_connections--; | 2184 | t->num_ready_connections--; |
2175 | } | 2185 | } |
2176 | else | 2186 | else |
2177 | { | 2187 | { |
2178 | GNUNET_CONTAINER_DLL_remove(t->connection_busy_head, | 2188 | GNUNET_CONTAINER_DLL_remove (t->connection_busy_head, |
2179 | t->connection_busy_tail, | 2189 | t->connection_busy_tail, |
2180 | ct); | 2190 | ct); |
2181 | t->num_busy_connections--; | 2191 | t->num_busy_connections--; |
2182 | } | 2192 | } |
2183 | GNUNET_free(ct); | 2193 | GNUNET_free (ct); |
2184 | } | 2194 | } |
2185 | 2195 | ||
2186 | 2196 | ||
@@ -2191,15 +2201,15 @@ GCT_connection_lost(struct CadetTConnection *ct) | |||
2191 | * @param ct connection to clean up | 2201 | * @param ct connection to clean up |
2192 | */ | 2202 | */ |
2193 | static void | 2203 | static void |
2194 | destroy_t_connection(void *cls, | 2204 | destroy_t_connection (void *cls, |
2195 | struct CadetTConnection *ct) | 2205 | struct CadetTConnection *ct) |
2196 | { | 2206 | { |
2197 | struct CadetTunnel *t = cls; | 2207 | struct CadetTunnel *t = cls; |
2198 | struct CadetConnection *cc = ct->cc; | 2208 | struct CadetConnection *cc = ct->cc; |
2199 | 2209 | ||
2200 | GNUNET_assert(ct->t == t); | 2210 | GNUNET_assert (ct->t == t); |
2201 | GCT_connection_lost(ct); | 2211 | GCT_connection_lost (ct); |
2202 | GCC_destroy_without_tunnel(cc); | 2212 | GCC_destroy_without_tunnel (cc); |
2203 | } | 2213 | } |
2204 | 2214 | ||
2205 | 2215 | ||
@@ -2209,56 +2219,56 @@ destroy_t_connection(void *cls, | |||
2209 | * @param cls the idle tunnel | 2219 | * @param cls the idle tunnel |
2210 | */ | 2220 | */ |
2211 | static void | 2221 | static void |
2212 | destroy_tunnel(void *cls) | 2222 | destroy_tunnel (void *cls) |
2213 | { | 2223 | { |
2214 | struct CadetTunnel *t = cls; | 2224 | struct CadetTunnel *t = cls; |
2215 | struct CadetTunnelQueueEntry *tq; | 2225 | struct CadetTunnelQueueEntry *tq; |
2216 | 2226 | ||
2217 | t->destroy_task = NULL; | 2227 | t->destroy_task = NULL; |
2218 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2228 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2219 | "Destroying idle %s\n", | 2229 | "Destroying idle %s\n", |
2220 | GCT_2s(t)); | 2230 | GCT_2s (t)); |
2221 | GNUNET_assert(0 == GCT_count_channels(t)); | 2231 | GNUNET_assert (0 == GCT_count_channels (t)); |
2222 | GCT_iterate_connections(t, | 2232 | GCT_iterate_connections (t, |
2223 | &destroy_t_connection, | 2233 | &destroy_t_connection, |
2224 | t); | 2234 | t); |
2225 | GNUNET_assert(NULL == t->connection_ready_head); | 2235 | GNUNET_assert (NULL == t->connection_ready_head); |
2226 | GNUNET_assert(NULL == t->connection_busy_head); | 2236 | GNUNET_assert (NULL == t->connection_busy_head); |
2227 | while (NULL != (tq = t->tq_head)) | 2237 | while (NULL != (tq = t->tq_head)) |
2228 | { | 2238 | { |
2229 | if (NULL != tq->cont) | 2239 | if (NULL != tq->cont) |
2230 | tq->cont(tq->cont_cls, | 2240 | tq->cont (tq->cont_cls, |
2231 | NULL); | 2241 | NULL); |
2232 | GCT_send_cancel(tq); | 2242 | GCT_send_cancel (tq); |
2233 | } | 2243 | } |
2234 | GCP_drop_tunnel(t->destination, | 2244 | GCP_drop_tunnel (t->destination, |
2235 | t); | 2245 | t); |
2236 | GNUNET_CONTAINER_multihashmap32_destroy(t->channels); | 2246 | GNUNET_CONTAINER_multihashmap32_destroy (t->channels); |
2237 | if (NULL != t->maintain_connections_task) | 2247 | if (NULL != t->maintain_connections_task) |
2238 | { | 2248 | { |
2239 | GNUNET_SCHEDULER_cancel(t->maintain_connections_task); | 2249 | GNUNET_SCHEDULER_cancel (t->maintain_connections_task); |
2240 | t->maintain_connections_task = NULL; | 2250 | t->maintain_connections_task = NULL; |
2241 | } | 2251 | } |
2242 | if (NULL != t->send_task) | 2252 | if (NULL != t->send_task) |
2243 | { | 2253 | { |
2244 | GNUNET_SCHEDULER_cancel(t->send_task); | 2254 | GNUNET_SCHEDULER_cancel (t->send_task); |
2245 | t->send_task = NULL; | 2255 | t->send_task = NULL; |
2246 | } | 2256 | } |
2247 | if (NULL != t->kx_task) | 2257 | if (NULL != t->kx_task) |
2248 | { | 2258 | { |
2249 | GNUNET_SCHEDULER_cancel(t->kx_task); | 2259 | GNUNET_SCHEDULER_cancel (t->kx_task); |
2250 | t->kx_task = NULL; | 2260 | t->kx_task = NULL; |
2251 | } | 2261 | } |
2252 | GNUNET_MST_destroy(t->mst); | 2262 | GNUNET_MST_destroy (t->mst); |
2253 | GNUNET_MQ_destroy(t->mq); | 2263 | GNUNET_MQ_destroy (t->mq); |
2254 | if (NULL != t->unverified_ax) | 2264 | if (NULL != t->unverified_ax) |
2255 | { | 2265 | { |
2256 | cleanup_ax(t->unverified_ax); | 2266 | cleanup_ax (t->unverified_ax); |
2257 | GNUNET_free(t->unverified_ax); | 2267 | GNUNET_free (t->unverified_ax); |
2258 | } | 2268 | } |
2259 | cleanup_ax(&t->ax); | 2269 | cleanup_ax (&t->ax); |
2260 | GNUNET_assert(NULL == t->destroy_task); | 2270 | GNUNET_assert (NULL == t->destroy_task); |
2261 | GNUNET_free(t); | 2271 | GNUNET_free (t); |
2262 | } | 2272 | } |
2263 | 2273 | ||
2264 | 2274 | ||
@@ -2270,27 +2280,27 @@ destroy_tunnel(void *cls) | |||
2270 | * @param ctn unique number identifying @a ch within @a t | 2280 | * @param ctn unique number identifying @a ch within @a t |
2271 | */ | 2281 | */ |
2272 | void | 2282 | void |
2273 | GCT_remove_channel(struct CadetTunnel *t, | 2283 | GCT_remove_channel (struct CadetTunnel *t, |
2274 | struct CadetChannel *ch, | 2284 | struct CadetChannel *ch, |
2275 | struct GNUNET_CADET_ChannelTunnelNumber ctn) | 2285 | struct GNUNET_CADET_ChannelTunnelNumber ctn) |
2276 | { | 2286 | { |
2277 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2287 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2278 | "Removing %s from %s\n", | 2288 | "Removing %s from %s\n", |
2279 | GCCH_2s(ch), | 2289 | GCCH_2s (ch), |
2280 | GCT_2s(t)); | 2290 | GCT_2s (t)); |
2281 | GNUNET_assert(GNUNET_YES == | 2291 | GNUNET_assert (GNUNET_YES == |
2282 | GNUNET_CONTAINER_multihashmap32_remove(t->channels, | 2292 | GNUNET_CONTAINER_multihashmap32_remove (t->channels, |
2283 | ntohl(ctn.cn), | 2293 | ntohl (ctn.cn), |
2284 | ch)); | 2294 | ch)); |
2285 | if ((0 == | 2295 | if ((0 == |
2286 | GCT_count_channels(t)) && | 2296 | GCT_count_channels (t)) && |
2287 | (NULL == t->destroy_task)) | 2297 | (NULL == t->destroy_task)) |
2288 | { | 2298 | { |
2289 | t->destroy_task | 2299 | t->destroy_task |
2290 | = GNUNET_SCHEDULER_add_delayed(IDLE_DESTROY_DELAY, | 2300 | = GNUNET_SCHEDULER_add_delayed (IDLE_DESTROY_DELAY, |
2291 | &destroy_tunnel, | 2301 | &destroy_tunnel, |
2292 | t); | 2302 | t); |
2293 | } | 2303 | } |
2294 | } | 2304 | } |
2295 | 2305 | ||
2296 | 2306 | ||
@@ -2303,14 +2313,14 @@ GCT_remove_channel(struct CadetTunnel *t, | |||
2303 | * @return #GNUNET_OK (continue to iterate) | 2313 | * @return #GNUNET_OK (continue to iterate) |
2304 | */ | 2314 | */ |
2305 | static int | 2315 | static int |
2306 | destroy_remaining_channels(void *cls, | 2316 | destroy_remaining_channels (void *cls, |
2307 | uint32_t key, | 2317 | uint32_t key, |
2308 | void *value) | 2318 | void *value) |
2309 | { | 2319 | { |
2310 | struct CadetChannel *ch = value; | 2320 | struct CadetChannel *ch = value; |
2311 | 2321 | ||
2312 | GCCH_handle_remote_destroy(ch, | 2322 | GCCH_handle_remote_destroy (ch, |
2313 | NULL); | 2323 | NULL); |
2314 | return GNUNET_OK; | 2324 | return GNUNET_OK; |
2315 | } | 2325 | } |
2316 | 2326 | ||
@@ -2321,20 +2331,20 @@ destroy_remaining_channels(void *cls, | |||
2321 | * @param t tunnel to destroy | 2331 | * @param t tunnel to destroy |
2322 | */ | 2332 | */ |
2323 | void | 2333 | void |
2324 | GCT_destroy_tunnel_now(struct CadetTunnel *t) | 2334 | GCT_destroy_tunnel_now (struct CadetTunnel *t) |
2325 | { | 2335 | { |
2326 | GNUNET_assert(GNUNET_YES == shutting_down); | 2336 | GNUNET_assert (GNUNET_YES == shutting_down); |
2327 | GNUNET_CONTAINER_multihashmap32_iterate(t->channels, | 2337 | GNUNET_CONTAINER_multihashmap32_iterate (t->channels, |
2328 | &destroy_remaining_channels, | 2338 | &destroy_remaining_channels, |
2329 | t); | 2339 | t); |
2330 | GNUNET_assert(0 == | 2340 | GNUNET_assert (0 == |
2331 | GCT_count_channels(t)); | 2341 | GCT_count_channels (t)); |
2332 | if (NULL != t->destroy_task) | 2342 | if (NULL != t->destroy_task) |
2333 | { | 2343 | { |
2334 | GNUNET_SCHEDULER_cancel(t->destroy_task); | 2344 | GNUNET_SCHEDULER_cancel (t->destroy_task); |
2335 | t->destroy_task = NULL; | 2345 | t->destroy_task = NULL; |
2336 | } | 2346 | } |
2337 | destroy_tunnel(t); | 2347 | destroy_tunnel (t); |
2338 | } | 2348 | } |
2339 | 2349 | ||
2340 | 2350 | ||
@@ -2346,40 +2356,40 @@ GCT_destroy_tunnel_now(struct CadetTunnel *t) | |||
2346 | * @param ct connection to use for transmission (is ready) | 2356 | * @param ct connection to use for transmission (is ready) |
2347 | */ | 2357 | */ |
2348 | static void | 2358 | static void |
2349 | try_send_normal_payload(struct CadetTunnel *t, | 2359 | try_send_normal_payload (struct CadetTunnel *t, |
2350 | struct CadetTConnection *ct) | 2360 | struct CadetTConnection *ct) |
2351 | { | 2361 | { |
2352 | struct CadetTunnelQueueEntry *tq; | 2362 | struct CadetTunnelQueueEntry *tq; |
2353 | 2363 | ||
2354 | GNUNET_assert(GNUNET_YES == ct->is_ready); | 2364 | GNUNET_assert (GNUNET_YES == ct->is_ready); |
2355 | tq = t->tq_head; | 2365 | tq = t->tq_head; |
2356 | if (NULL == tq) | 2366 | if (NULL == tq) |
2357 | { | 2367 | { |
2358 | /* no messages pending right now */ | 2368 | /* no messages pending right now */ |
2359 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2369 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2360 | "Not sending payload of %s on ready %s (nothing pending)\n", | 2370 | "Not sending payload of %s on ready %s (nothing pending)\n", |
2361 | GCT_2s(t), | 2371 | GCT_2s (t), |
2362 | GCC_2s(ct->cc)); | 2372 | GCC_2s (ct->cc)); |
2363 | return; | 2373 | return; |
2364 | } | 2374 | } |
2365 | /* ready to send message 'tq' on tunnel 'ct' */ | 2375 | /* ready to send message 'tq' on tunnel 'ct' */ |
2366 | GNUNET_assert(t == tq->t); | 2376 | GNUNET_assert (t == tq->t); |
2367 | GNUNET_CONTAINER_DLL_remove(t->tq_head, | 2377 | GNUNET_CONTAINER_DLL_remove (t->tq_head, |
2368 | t->tq_tail, | 2378 | t->tq_tail, |
2369 | tq); | 2379 | tq); |
2370 | if (NULL != tq->cid) | 2380 | if (NULL != tq->cid) |
2371 | *tq->cid = *GCC_get_id(ct->cc); | 2381 | *tq->cid = *GCC_get_id (ct->cc); |
2372 | mark_connection_unready(ct); | 2382 | mark_connection_unready (ct); |
2373 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2383 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2374 | "Sending payload of %s on %s\n", | 2384 | "Sending payload of %s on %s\n", |
2375 | GCT_2s(t), | 2385 | GCT_2s (t), |
2376 | GCC_2s(ct->cc)); | 2386 | GCC_2s (ct->cc)); |
2377 | GCC_transmit(ct->cc, | 2387 | GCC_transmit (ct->cc, |
2378 | tq->env); | 2388 | tq->env); |
2379 | if (NULL != tq->cont) | 2389 | if (NULL != tq->cont) |
2380 | tq->cont(tq->cont_cls, | 2390 | tq->cont (tq->cont_cls, |
2381 | GCC_get_id(ct->cc)); | 2391 | GCC_get_id (ct->cc)); |
2382 | GNUNET_free(tq); | 2392 | GNUNET_free (tq); |
2383 | } | 2393 | } |
2384 | 2394 | ||
2385 | 2395 | ||
@@ -2392,97 +2402,99 @@ try_send_normal_payload(struct CadetTunnel *t, | |||
2392 | * #GNUNET_NO if connection are no longer ready | 2402 | * #GNUNET_NO if connection are no longer ready |
2393 | */ | 2403 | */ |
2394 | static void | 2404 | static void |
2395 | connection_ready_cb(void *cls, | 2405 | connection_ready_cb (void *cls, |
2396 | int is_ready) | 2406 | int is_ready) |
2397 | { | 2407 | { |
2398 | struct CadetTConnection *ct = cls; | 2408 | struct CadetTConnection *ct = cls; |
2399 | struct CadetTunnel *t = ct->t; | 2409 | struct CadetTunnel *t = ct->t; |
2400 | 2410 | ||
2401 | if (GNUNET_NO == is_ready) | 2411 | if (GNUNET_NO == is_ready) |
2402 | { | 2412 | { |
2403 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2413 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2404 | "%s no longer ready for %s\n", | 2414 | "%s no longer ready for %s\n", |
2405 | GCC_2s(ct->cc), | 2415 | GCC_2s (ct->cc), |
2406 | GCT_2s(t)); | 2416 | GCT_2s (t)); |
2407 | mark_connection_unready(ct); | 2417 | mark_connection_unready (ct); |
2408 | return; | 2418 | return; |
2409 | } | 2419 | } |
2410 | GNUNET_assert(GNUNET_NO == ct->is_ready); | 2420 | GNUNET_assert (GNUNET_NO == ct->is_ready); |
2411 | GNUNET_CONTAINER_DLL_remove(t->connection_busy_head, | 2421 | GNUNET_CONTAINER_DLL_remove (t->connection_busy_head, |
2412 | t->connection_busy_tail, | 2422 | t->connection_busy_tail, |
2413 | ct); | 2423 | ct); |
2414 | GNUNET_assert(0 < t->num_busy_connections); | 2424 | GNUNET_assert (0 < t->num_busy_connections); |
2415 | t->num_busy_connections--; | 2425 | t->num_busy_connections--; |
2416 | ct->is_ready = GNUNET_YES; | 2426 | ct->is_ready = GNUNET_YES; |
2417 | GNUNET_CONTAINER_DLL_insert_tail(t->connection_ready_head, | 2427 | GNUNET_CONTAINER_DLL_insert_tail (t->connection_ready_head, |
2418 | t->connection_ready_tail, | 2428 | t->connection_ready_tail, |
2419 | ct); | 2429 | ct); |
2420 | t->num_ready_connections++; | 2430 | t->num_ready_connections++; |
2421 | 2431 | ||
2422 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2432 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2423 | "%s now ready for %s in state %s\n", | 2433 | "%s now ready for %s in state %s\n", |
2424 | GCC_2s(ct->cc), | 2434 | GCC_2s (ct->cc), |
2425 | GCT_2s(t), | 2435 | GCT_2s (t), |
2426 | estate2s(t->estate)); | 2436 | estate2s (t->estate)); |
2427 | switch (t->estate) | 2437 | switch (t->estate) |
2438 | { | ||
2439 | case CADET_TUNNEL_KEY_UNINITIALIZED: | ||
2440 | /* Do not begin KX if WE have no channels waiting! */ | ||
2441 | if (0 != GNUNET_TIME_absolute_get_remaining ( | ||
2442 | t->next_kx_attempt).rel_value_us) | ||
2443 | return; /* wait for timeout before retrying */ | ||
2444 | /* We are uninitialized, just transmit immediately, | ||
2445 | without undue delay. */ | ||
2446 | if (NULL != t->kx_task) | ||
2447 | { | ||
2448 | GNUNET_SCHEDULER_cancel (t->kx_task); | ||
2449 | t->kx_task = NULL; | ||
2450 | } | ||
2451 | send_kx (t, | ||
2452 | ct, | ||
2453 | &t->ax); | ||
2454 | if ((0 == | ||
2455 | GCT_count_channels (t)) && | ||
2456 | (NULL == t->destroy_task)) | ||
2428 | { | 2457 | { |
2429 | case CADET_TUNNEL_KEY_UNINITIALIZED: | 2458 | t->destroy_task |
2430 | /* Do not begin KX if WE have no channels waiting! */ | 2459 | = GNUNET_SCHEDULER_add_delayed (IDLE_DESTROY_DELAY, |
2431 | if (0 != GNUNET_TIME_absolute_get_remaining(t->next_kx_attempt).rel_value_us) | 2460 | &destroy_tunnel, |
2432 | return; /* wait for timeout before retrying */ | 2461 | t); |
2433 | /* We are uninitialized, just transmit immediately, | 2462 | } |
2434 | without undue delay. */ | 2463 | break; |
2435 | if (NULL != t->kx_task) | ||
2436 | { | ||
2437 | GNUNET_SCHEDULER_cancel(t->kx_task); | ||
2438 | t->kx_task = NULL; | ||
2439 | } | ||
2440 | send_kx(t, | ||
2441 | ct, | ||
2442 | &t->ax); | ||
2443 | if ((0 == | ||
2444 | GCT_count_channels(t)) && | ||
2445 | (NULL == t->destroy_task)) | ||
2446 | { | ||
2447 | t->destroy_task | ||
2448 | = GNUNET_SCHEDULER_add_delayed(IDLE_DESTROY_DELAY, | ||
2449 | &destroy_tunnel, | ||
2450 | t); | ||
2451 | } | ||
2452 | break; | ||
2453 | 2464 | ||
2454 | case CADET_TUNNEL_KEY_AX_RECV: | 2465 | case CADET_TUNNEL_KEY_AX_RECV: |
2455 | case CADET_TUNNEL_KEY_AX_SENT: | 2466 | case CADET_TUNNEL_KEY_AX_SENT: |
2456 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: | 2467 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: |
2457 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: | 2468 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: |
2458 | /* we're currently waiting for KX to complete, schedule job */ | 2469 | /* we're currently waiting for KX to complete, schedule job */ |
2459 | if (NULL == t->kx_task) | 2470 | if (NULL == t->kx_task) |
2460 | t->kx_task | 2471 | t->kx_task |
2461 | = GNUNET_SCHEDULER_add_at(t->next_kx_attempt, | 2472 | = GNUNET_SCHEDULER_add_at (t->next_kx_attempt, |
2462 | &retry_kx, | 2473 | &retry_kx, |
2463 | t); | 2474 | t); |
2464 | break; | 2475 | break; |
2465 | 2476 | ||
2466 | case CADET_TUNNEL_KEY_OK: | 2477 | case CADET_TUNNEL_KEY_OK: |
2467 | if (GNUNET_YES == t->kx_auth_requested) | 2478 | if (GNUNET_YES == t->kx_auth_requested) |
2468 | { | 2479 | { |
2469 | if (0 != GNUNET_TIME_absolute_get_remaining(t->next_kx_attempt).rel_value_us) | 2480 | if (0 != GNUNET_TIME_absolute_get_remaining ( |
2470 | return; /* wait for timeout */ | 2481 | t->next_kx_attempt).rel_value_us) |
2471 | if (NULL != t->kx_task) | 2482 | return; /* wait for timeout */ |
2472 | { | 2483 | if (NULL != t->kx_task) |
2473 | GNUNET_SCHEDULER_cancel(t->kx_task); | 2484 | { |
2474 | t->kx_task = NULL; | 2485 | GNUNET_SCHEDULER_cancel (t->kx_task); |
2475 | } | 2486 | t->kx_task = NULL; |
2476 | send_kx_auth(t, | 2487 | } |
2477 | ct, | 2488 | send_kx_auth (t, |
2478 | &t->ax, | 2489 | ct, |
2479 | GNUNET_NO); | 2490 | &t->ax, |
2480 | return; | 2491 | GNUNET_NO); |
2481 | } | 2492 | return; |
2482 | try_send_normal_payload(t, | ||
2483 | ct); | ||
2484 | break; | ||
2485 | } | 2493 | } |
2494 | try_send_normal_payload (t, | ||
2495 | ct); | ||
2496 | break; | ||
2497 | } | ||
2486 | } | 2498 | } |
2487 | 2499 | ||
2488 | 2500 | ||
@@ -2495,7 +2507,7 @@ connection_ready_cb(void *cls, | |||
2495 | * @param cls the `struct CadetTunnel` to process messages on | 2507 | * @param cls the `struct CadetTunnel` to process messages on |
2496 | */ | 2508 | */ |
2497 | static void | 2509 | static void |
2498 | trigger_transmissions(void *cls) | 2510 | trigger_transmissions (void *cls) |
2499 | { | 2511 | { |
2500 | struct CadetTunnel *t = cls; | 2512 | struct CadetTunnel *t = cls; |
2501 | struct CadetTConnection *ct; | 2513 | struct CadetTConnection *ct; |
@@ -2503,11 +2515,11 @@ trigger_transmissions(void *cls) | |||
2503 | t->send_task = NULL; | 2515 | t->send_task = NULL; |
2504 | if (NULL == t->tq_head) | 2516 | if (NULL == t->tq_head) |
2505 | return; /* no messages pending right now */ | 2517 | return; /* no messages pending right now */ |
2506 | ct = get_ready_connection(t); | 2518 | ct = get_ready_connection (t); |
2507 | if (NULL == ct) | 2519 | if (NULL == ct) |
2508 | return; /* no connections ready */ | 2520 | return; /* no connections ready */ |
2509 | try_send_normal_payload(t, | 2521 | try_send_normal_payload (t, |
2510 | ct); | 2522 | ct); |
2511 | } | 2523 | } |
2512 | 2524 | ||
2513 | 2525 | ||
@@ -2515,7 +2527,8 @@ trigger_transmissions(void *cls) | |||
2515 | * Closure for #evaluate_connection. Used to assemble summary information | 2527 | * Closure for #evaluate_connection. Used to assemble summary information |
2516 | * about the existing connections so we can evaluate a new path. | 2528 | * about the existing connections so we can evaluate a new path. |
2517 | */ | 2529 | */ |
2518 | struct EvaluationSummary { | 2530 | struct EvaluationSummary |
2531 | { | ||
2519 | /** | 2532 | /** |
2520 | * Minimum length of any of our connections, `UINT_MAX` if we have none. | 2533 | * Minimum length of any of our connections, `UINT_MAX` if we have none. |
2521 | */ | 2534 | */ |
@@ -2567,8 +2580,8 @@ struct EvaluationSummary { | |||
2567 | * @param ct a connection to include in the summary | 2580 | * @param ct a connection to include in the summary |
2568 | */ | 2581 | */ |
2569 | static void | 2582 | static void |
2570 | evaluate_connection(void *cls, | 2583 | evaluate_connection (void *cls, |
2571 | struct CadetTConnection *ct) | 2584 | struct CadetTConnection *ct) |
2572 | { | 2585 | { |
2573 | struct EvaluationSummary *es = cls; | 2586 | struct EvaluationSummary *es = cls; |
2574 | struct CadetConnection *cc = ct->cc; | 2587 | struct CadetConnection *cc = ct->cc; |
@@ -2581,79 +2594,80 @@ evaluate_connection(void *cls, | |||
2581 | double score; | 2594 | double score; |
2582 | double success_rate; | 2595 | double success_rate; |
2583 | 2596 | ||
2584 | ps = GCC_get_path(cc, | 2597 | ps = GCC_get_path (cc, |
2585 | &ct_length); | 2598 | &ct_length); |
2586 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2599 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2587 | "Evaluating path %s of existing %s\n", | 2600 | "Evaluating path %s of existing %s\n", |
2588 | GCPP_2s(ps), | 2601 | GCPP_2s (ps), |
2589 | GCC_2s(cc)); | 2602 | GCC_2s (cc)); |
2590 | if (ps == es->path) | 2603 | if (ps == es->path) |
2604 | { | ||
2605 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2606 | "Ignoring duplicate path %s.\n", | ||
2607 | GCPP_2s (es->path)); | ||
2608 | es->duplicate = GNUNET_YES; | ||
2609 | return; | ||
2610 | } | ||
2611 | if (NULL != es->path) | ||
2612 | { | ||
2613 | int duplicate = GNUNET_YES; | ||
2614 | |||
2615 | for (unsigned int i = 0; i < ct_length; i++) | ||
2616 | { | ||
2617 | GNUNET_assert (GCPP_get_length (es->path) > i); | ||
2618 | if (GCPP_get_peer_at_offset (es->path, | ||
2619 | i) != | ||
2620 | GCPP_get_peer_at_offset (ps, | ||
2621 | i)) | ||
2622 | { | ||
2623 | duplicate = GNUNET_NO; | ||
2624 | break; | ||
2625 | } | ||
2626 | } | ||
2627 | if (GNUNET_YES == duplicate) | ||
2591 | { | 2628 | { |
2592 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2629 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2593 | "Ignoring duplicate path %s.\n", | 2630 | "Ignoring overlapping path %s.\n", |
2594 | GCPP_2s(es->path)); | 2631 | GCPP_2s (es->path)); |
2595 | es->duplicate = GNUNET_YES; | 2632 | es->duplicate = GNUNET_YES; |
2596 | return; | 2633 | return; |
2597 | } | 2634 | } |
2598 | if (NULL != es->path) | 2635 | else |
2599 | { | 2636 | { |
2600 | int duplicate = GNUNET_YES; | 2637 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2601 | 2638 | "Known path %s differs from proposed path\n", | |
2602 | for (unsigned int i = 0; i < ct_length; i++) | 2639 | GCPP_2s (ps)); |
2603 | { | ||
2604 | GNUNET_assert(GCPP_get_length(es->path) > i); | ||
2605 | if (GCPP_get_peer_at_offset(es->path, | ||
2606 | i) != | ||
2607 | GCPP_get_peer_at_offset(ps, | ||
2608 | i)) | ||
2609 | { | ||
2610 | duplicate = GNUNET_NO; | ||
2611 | break; | ||
2612 | } | ||
2613 | } | ||
2614 | if (GNUNET_YES == duplicate) | ||
2615 | { | ||
2616 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
2617 | "Ignoring overlapping path %s.\n", | ||
2618 | GCPP_2s(es->path)); | ||
2619 | es->duplicate = GNUNET_YES; | ||
2620 | return; | ||
2621 | } | ||
2622 | else | ||
2623 | { | ||
2624 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
2625 | "Known path %s differs from proposed path\n", | ||
2626 | GCPP_2s(ps)); | ||
2627 | } | ||
2628 | } | 2640 | } |
2641 | } | ||
2629 | 2642 | ||
2630 | ct_desirability = GCPP_get_desirability(ps); | 2643 | ct_desirability = GCPP_get_desirability (ps); |
2631 | metrics = GCC_get_metrics(cc); | 2644 | metrics = GCC_get_metrics (cc); |
2632 | uptime = GNUNET_TIME_absolute_get_duration(metrics->age); | 2645 | uptime = GNUNET_TIME_absolute_get_duration (metrics->age); |
2633 | last_use = GNUNET_TIME_absolute_get_duration(metrics->last_use); | 2646 | last_use = GNUNET_TIME_absolute_get_duration (metrics->last_use); |
2634 | /* We add 1.0 here to avoid division by zero. */ | 2647 | /* We add 1.0 here to avoid division by zero. */ |
2635 | success_rate = (metrics->num_acked_transmissions + 1.0) / (metrics->num_successes + 1.0); | 2648 | success_rate = (metrics->num_acked_transmissions + 1.0) |
2649 | / (metrics->num_successes + 1.0); | ||
2636 | score | 2650 | score |
2637 | = ct_desirability | 2651 | = ct_desirability |
2638 | + 100.0 / (1.0 + ct_length) /* longer paths = better */ | 2652 | + 100.0 / (1.0 + ct_length) /* longer paths = better */ |
2639 | + sqrt(uptime.rel_value_us / 60000000LL) /* larger uptime = better */ | 2653 | + sqrt (uptime.rel_value_us / 60000000LL) /* larger uptime = better */ |
2640 | - last_use.rel_value_us / 1000L; /* longer idle = worse */ | 2654 | - last_use.rel_value_us / 1000L; /* longer idle = worse */ |
2641 | score *= success_rate; /* weigh overall by success rate */ | 2655 | score *= success_rate; /* weigh overall by success rate */ |
2642 | 2656 | ||
2643 | if ((NULL == es->worst) || | 2657 | if ((NULL == es->worst) || |
2644 | (score < es->worst_score)) | 2658 | (score < es->worst_score)) |
2645 | { | 2659 | { |
2646 | es->worst = ct; | 2660 | es->worst = ct; |
2647 | es->worst_score = score; | 2661 | es->worst_score = score; |
2648 | } | 2662 | } |
2649 | es->min_length = GNUNET_MIN(es->min_length, | 2663 | es->min_length = GNUNET_MIN (es->min_length, |
2650 | ct_length); | 2664 | ct_length); |
2651 | es->max_length = GNUNET_MAX(es->max_length, | 2665 | es->max_length = GNUNET_MAX (es->max_length, |
2652 | ct_length); | 2666 | ct_length); |
2653 | es->min_desire = GNUNET_MIN(es->min_desire, | 2667 | es->min_desire = GNUNET_MIN (es->min_desire, |
2654 | ct_desirability); | 2668 | ct_desirability); |
2655 | es->max_desire = GNUNET_MAX(es->max_desire, | 2669 | es->max_desire = GNUNET_MAX (es->max_desire, |
2656 | ct_desirability); | 2670 | ct_desirability); |
2657 | } | 2671 | } |
2658 | 2672 | ||
2659 | 2673 | ||
@@ -2667,17 +2681,17 @@ evaluate_connection(void *cls, | |||
2667 | * @return #GNUNET_YES (should keep iterating) | 2681 | * @return #GNUNET_YES (should keep iterating) |
2668 | */ | 2682 | */ |
2669 | static int | 2683 | static int |
2670 | consider_path_cb(void *cls, | 2684 | consider_path_cb (void *cls, |
2671 | struct CadetPeerPath *path, | 2685 | struct CadetPeerPath *path, |
2672 | unsigned int off) | 2686 | unsigned int off) |
2673 | { | 2687 | { |
2674 | struct CadetTunnel *t = cls; | 2688 | struct CadetTunnel *t = cls; |
2675 | struct EvaluationSummary es; | 2689 | struct EvaluationSummary es; |
2676 | struct CadetTConnection *ct; | 2690 | struct CadetTConnection *ct; |
2677 | 2691 | ||
2678 | GNUNET_assert(off < GCPP_get_length(path)); | 2692 | GNUNET_assert (off < GCPP_get_length (path)); |
2679 | GNUNET_assert(GCPP_get_peer_at_offset(path, | 2693 | GNUNET_assert (GCPP_get_peer_at_offset (path, |
2680 | off) == t->destination); | 2694 | off) == t->destination); |
2681 | es.min_length = UINT_MAX; | 2695 | es.min_length = UINT_MAX; |
2682 | es.max_length = 0; | 2696 | es.max_length = 0; |
2683 | es.max_desire = 0; | 2697 | es.max_desire = 0; |
@@ -2687,16 +2701,16 @@ consider_path_cb(void *cls, | |||
2687 | es.worst = NULL; | 2701 | es.worst = NULL; |
2688 | 2702 | ||
2689 | /* Compute evaluation summary over existing connections. */ | 2703 | /* Compute evaluation summary over existing connections. */ |
2690 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2704 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2691 | "Evaluating proposed path %s for target %s\n", | 2705 | "Evaluating proposed path %s for target %s\n", |
2692 | GCPP_2s(path), | 2706 | GCPP_2s (path), |
2693 | GCT_2s(t)); | 2707 | GCT_2s (t)); |
2694 | /* FIXME: suspect this does not ACTUALLY iterate | 2708 | /* FIXME: suspect this does not ACTUALLY iterate |
2695 | over all existing paths, otherwise dup detection | 2709 | over all existing paths, otherwise dup detection |
2696 | should work!!! */ | 2710 | should work!!! */ |
2697 | GCT_iterate_connections(t, | 2711 | GCT_iterate_connections (t, |
2698 | &evaluate_connection, | 2712 | &evaluate_connection, |
2699 | &es); | 2713 | &es); |
2700 | if (GNUNET_YES == es.duplicate) | 2714 | if (GNUNET_YES == es.duplicate) |
2701 | return GNUNET_YES; | 2715 | return GNUNET_YES; |
2702 | 2716 | ||
@@ -2707,54 +2721,54 @@ consider_path_cb(void *cls, | |||
2707 | /* We iterate by increasing path length; if we have enough paths and | 2721 | /* We iterate by increasing path length; if we have enough paths and |
2708 | this one is more than twice as long than what we are currently | 2722 | this one is more than twice as long than what we are currently |
2709 | using, then ignore all of these super-long ones! */ | 2723 | using, then ignore all of these super-long ones! */ |
2710 | if ((GCT_count_any_connections(t) > DESIRED_CONNECTIONS_PER_TUNNEL) && | 2724 | if ((GCT_count_any_connections (t) > DESIRED_CONNECTIONS_PER_TUNNEL) && |
2711 | (es.min_length * 2 < off) && | 2725 | (es.min_length * 2 < off) && |
2712 | (es.max_length < off)) | 2726 | (es.max_length < off)) |
2713 | { | 2727 | { |
2714 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2728 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2715 | "Ignoring paths of length %u, they are way too long.\n", | 2729 | "Ignoring paths of length %u, they are way too long.\n", |
2716 | es.min_length * 2); | 2730 | es.min_length * 2); |
2717 | return GNUNET_NO; | 2731 | return GNUNET_NO; |
2718 | } | 2732 | } |
2719 | /* If we have enough paths and this one looks no better, ignore it. */ | 2733 | /* If we have enough paths and this one looks no better, ignore it. */ |
2720 | if ((GCT_count_any_connections(t) >= DESIRED_CONNECTIONS_PER_TUNNEL) && | 2734 | if ((GCT_count_any_connections (t) >= DESIRED_CONNECTIONS_PER_TUNNEL) && |
2721 | (es.min_length < GCPP_get_length(path)) && | 2735 | (es.min_length < GCPP_get_length (path)) && |
2722 | (es.min_desire > GCPP_get_desirability(path)) && | 2736 | (es.min_desire > GCPP_get_desirability (path)) && |
2723 | (es.max_length < off)) | 2737 | (es.max_length < off)) |
2724 | { | 2738 | { |
2725 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2739 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2726 | "Ignoring path (%u/%llu) to %s, got something better already.\n", | 2740 | "Ignoring path (%u/%llu) to %s, got something better already.\n", |
2727 | GCPP_get_length(path), | 2741 | GCPP_get_length (path), |
2728 | (unsigned long long)GCPP_get_desirability(path), | 2742 | (unsigned long long) GCPP_get_desirability (path), |
2729 | GCP_2s(t->destination)); | 2743 | GCP_2s (t->destination)); |
2730 | return GNUNET_YES; | 2744 | return GNUNET_YES; |
2731 | } | 2745 | } |
2732 | 2746 | ||
2733 | /* Path is interesting (better by some metric, or we don't have | 2747 | /* Path is interesting (better by some metric, or we don't have |
2734 | enough paths yet). */ | 2748 | enough paths yet). */ |
2735 | ct = GNUNET_new(struct CadetTConnection); | 2749 | ct = GNUNET_new (struct CadetTConnection); |
2736 | ct->created = GNUNET_TIME_absolute_get(); | 2750 | ct->created = GNUNET_TIME_absolute_get (); |
2737 | ct->t = t; | 2751 | ct->t = t; |
2738 | ct->cc = GCC_create(t->destination, | 2752 | ct->cc = GCC_create (t->destination, |
2739 | path, | 2753 | path, |
2740 | off, | 2754 | off, |
2741 | ct, | 2755 | ct, |
2742 | &connection_ready_cb, | 2756 | &connection_ready_cb, |
2743 | ct); | 2757 | ct); |
2744 | 2758 | ||
2745 | /* FIXME: schedule job to kill connection (and path?) if it takes | 2759 | /* FIXME: schedule job to kill connection (and path?) if it takes |
2746 | too long to get ready! (And track performance data on how long | 2760 | too long to get ready! (And track performance data on how long |
2747 | other connections took with the tunnel!) | 2761 | other connections took with the tunnel!) |
2748 | => Note: to be done within 'connection'-logic! */ | 2762 | => Note: to be done within 'connection'-logic! */ |
2749 | GNUNET_CONTAINER_DLL_insert(t->connection_busy_head, | 2763 | GNUNET_CONTAINER_DLL_insert (t->connection_busy_head, |
2750 | t->connection_busy_tail, | 2764 | t->connection_busy_tail, |
2751 | ct); | 2765 | ct); |
2752 | t->num_busy_connections++; | 2766 | t->num_busy_connections++; |
2753 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2767 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2754 | "Found interesting path %s for %s, created %s\n", | 2768 | "Found interesting path %s for %s, created %s\n", |
2755 | GCPP_2s(path), | 2769 | GCPP_2s (path), |
2756 | GCT_2s(t), | 2770 | GCT_2s (t), |
2757 | GCC_2s(ct->cc)); | 2771 | GCC_2s (ct->cc)); |
2758 | return GNUNET_YES; | 2772 | return GNUNET_YES; |
2759 | } | 2773 | } |
2760 | 2774 | ||
@@ -2773,16 +2787,16 @@ consider_path_cb(void *cls, | |||
2773 | * @param cls the `struct CadetTunnel` | 2787 | * @param cls the `struct CadetTunnel` |
2774 | */ | 2788 | */ |
2775 | static void | 2789 | static void |
2776 | maintain_connections_cb(void *cls) | 2790 | maintain_connections_cb (void *cls) |
2777 | { | 2791 | { |
2778 | struct CadetTunnel *t = cls; | 2792 | struct CadetTunnel *t = cls; |
2779 | struct GNUNET_TIME_Relative delay; | 2793 | struct GNUNET_TIME_Relative delay; |
2780 | struct EvaluationSummary es; | 2794 | struct EvaluationSummary es; |
2781 | 2795 | ||
2782 | t->maintain_connections_task = NULL; | 2796 | t->maintain_connections_task = NULL; |
2783 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2797 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2784 | "Performing connection maintenance for %s.\n", | 2798 | "Performing connection maintenance for %s.\n", |
2785 | GCT_2s(t)); | 2799 | GCT_2s (t)); |
2786 | 2800 | ||
2787 | es.min_length = UINT_MAX; | 2801 | es.min_length = UINT_MAX; |
2788 | es.max_length = 0; | 2802 | es.max_length = 0; |
@@ -2791,21 +2805,21 @@ maintain_connections_cb(void *cls) | |||
2791 | es.path = NULL; | 2805 | es.path = NULL; |
2792 | es.worst = NULL; | 2806 | es.worst = NULL; |
2793 | es.duplicate = GNUNET_NO; | 2807 | es.duplicate = GNUNET_NO; |
2794 | GCT_iterate_connections(t, | 2808 | GCT_iterate_connections (t, |
2795 | &evaluate_connection, | 2809 | &evaluate_connection, |
2796 | &es); | 2810 | &es); |
2797 | if ((NULL != es.worst) && | 2811 | if ((NULL != es.worst) && |
2798 | (GCT_count_any_connections(t) > DESIRED_CONNECTIONS_PER_TUNNEL)) | 2812 | (GCT_count_any_connections (t) > DESIRED_CONNECTIONS_PER_TUNNEL)) |
2799 | { | 2813 | { |
2800 | /* Clear out worst-performing connection 'es.worst'. */ | 2814 | /* Clear out worst-performing connection 'es.worst'. */ |
2801 | destroy_t_connection(t, | 2815 | destroy_t_connection (t, |
2802 | es.worst); | 2816 | es.worst); |
2803 | } | 2817 | } |
2804 | 2818 | ||
2805 | /* Consider additional paths */ | 2819 | /* Consider additional paths */ |
2806 | (void)GCP_iterate_paths(t->destination, | 2820 | (void) GCP_iterate_paths (t->destination, |
2807 | &consider_path_cb, | 2821 | &consider_path_cb, |
2808 | t); | 2822 | t); |
2809 | 2823 | ||
2810 | /* FIXME: calculate when to try again based on how well we are doing; | 2824 | /* FIXME: calculate when to try again based on how well we are doing; |
2811 | in particular, if we have to few connections, we might be able | 2825 | in particular, if we have to few connections, we might be able |
@@ -2817,9 +2831,9 @@ maintain_connections_cb(void *cls) | |||
2817 | and then reduce the frequency accordingly. */ | 2831 | and then reduce the frequency accordingly. */ |
2818 | delay = GNUNET_TIME_UNIT_MINUTES; | 2832 | delay = GNUNET_TIME_UNIT_MINUTES; |
2819 | t->maintain_connections_task | 2833 | t->maintain_connections_task |
2820 | = GNUNET_SCHEDULER_add_delayed(delay, | 2834 | = GNUNET_SCHEDULER_add_delayed (delay, |
2821 | &maintain_connections_cb, | 2835 | &maintain_connections_cb, |
2822 | t); | 2836 | t); |
2823 | } | 2837 | } |
2824 | 2838 | ||
2825 | 2839 | ||
@@ -2832,18 +2846,18 @@ maintain_connections_cb(void *cls) | |||
2832 | * @param off offset of the destination on path @a path | 2846 | * @param off offset of the destination on path @a path |
2833 | */ | 2847 | */ |
2834 | void | 2848 | void |
2835 | GCT_consider_path(struct CadetTunnel *t, | 2849 | GCT_consider_path (struct CadetTunnel *t, |
2836 | struct CadetPeerPath *p, | 2850 | struct CadetPeerPath *p, |
2837 | unsigned int off) | 2851 | unsigned int off) |
2838 | { | 2852 | { |
2839 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2853 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2840 | "Considering %s for %s (offset %u)\n", | 2854 | "Considering %s for %s (offset %u)\n", |
2841 | GCPP_2s(p), | 2855 | GCPP_2s (p), |
2842 | GCT_2s(t), | 2856 | GCT_2s (t), |
2843 | off); | 2857 | off); |
2844 | (void)consider_path_cb(t, | 2858 | (void) consider_path_cb (t, |
2845 | p, | 2859 | p, |
2846 | off); | 2860 | off); |
2847 | } | 2861 | } |
2848 | 2862 | ||
2849 | 2863 | ||
@@ -2854,18 +2868,18 @@ GCT_consider_path(struct CadetTunnel *t, | |||
2854 | * @param msg the message we received on the tunnel | 2868 | * @param msg the message we received on the tunnel |
2855 | */ | 2869 | */ |
2856 | static void | 2870 | static void |
2857 | handle_plaintext_keepalive(void *cls, | 2871 | handle_plaintext_keepalive (void *cls, |
2858 | const struct GNUNET_MessageHeader *msg) | 2872 | const struct GNUNET_MessageHeader *msg) |
2859 | { | 2873 | { |
2860 | struct CadetTunnel *t = cls; | 2874 | struct CadetTunnel *t = cls; |
2861 | 2875 | ||
2862 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2876 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2863 | "Received KEEPALIVE on %s\n", | 2877 | "Received KEEPALIVE on %s\n", |
2864 | GCT_2s(t)); | 2878 | GCT_2s (t)); |
2865 | GNUNET_STATISTICS_update(stats, | 2879 | GNUNET_STATISTICS_update (stats, |
2866 | "# keepalives received", | 2880 | "# keepalives received", |
2867 | 1, | 2881 | 1, |
2868 | GNUNET_NO); | 2882 | GNUNET_NO); |
2869 | } | 2883 | } |
2870 | 2884 | ||
2871 | 2885 | ||
@@ -2877,8 +2891,8 @@ handle_plaintext_keepalive(void *cls, | |||
2877 | * @return #GNUNET_OK (any variable-size payload goes) | 2891 | * @return #GNUNET_OK (any variable-size payload goes) |
2878 | */ | 2892 | */ |
2879 | static int | 2893 | static int |
2880 | check_plaintext_data(void *cls, | 2894 | check_plaintext_data (void *cls, |
2881 | const struct GNUNET_CADET_ChannelAppDataMessage *msg) | 2895 | const struct GNUNET_CADET_ChannelAppDataMessage *msg) |
2882 | { | 2896 | { |
2883 | return GNUNET_OK; | 2897 | return GNUNET_OK; |
2884 | } | 2898 | } |
@@ -2892,29 +2906,29 @@ check_plaintext_data(void *cls, | |||
2892 | * @param msg the message we received on the tunnel | 2906 | * @param msg the message we received on the tunnel |
2893 | */ | 2907 | */ |
2894 | static void | 2908 | static void |
2895 | handle_plaintext_data(void *cls, | 2909 | handle_plaintext_data (void *cls, |
2896 | const struct GNUNET_CADET_ChannelAppDataMessage *msg) | 2910 | const struct GNUNET_CADET_ChannelAppDataMessage *msg) |
2897 | { | 2911 | { |
2898 | struct CadetTunnel *t = cls; | 2912 | struct CadetTunnel *t = cls; |
2899 | struct CadetChannel *ch; | 2913 | struct CadetChannel *ch; |
2900 | 2914 | ||
2901 | ch = lookup_channel(t, | 2915 | ch = lookup_channel (t, |
2902 | msg->ctn); | 2916 | msg->ctn); |
2903 | if (NULL == ch) | 2917 | if (NULL == ch) |
2904 | { | 2918 | { |
2905 | /* We don't know about such a channel, might have been destroyed on our | 2919 | /* We don't know about such a channel, might have been destroyed on our |
2906 | end in the meantime, or never existed. Send back a DESTROY. */ | 2920 | end in the meantime, or never existed. Send back a DESTROY. */ |
2907 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2921 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2908 | "Received %u bytes of application data for unknown channel %u, sending DESTROY\n", | 2922 | "Received %u bytes of application data for unknown channel %u, sending DESTROY\n", |
2909 | (unsigned int)(ntohs(msg->header.size) - sizeof(*msg)), | 2923 | (unsigned int) (ntohs (msg->header.size) - sizeof(*msg)), |
2910 | ntohl(msg->ctn.cn)); | 2924 | ntohl (msg->ctn.cn)); |
2911 | GCT_send_channel_destroy(t, | 2925 | GCT_send_channel_destroy (t, |
2912 | msg->ctn); | 2926 | msg->ctn); |
2913 | return; | 2927 | return; |
2914 | } | 2928 | } |
2915 | GCCH_handle_channel_plaintext_data(ch, | 2929 | GCCH_handle_channel_plaintext_data (ch, |
2916 | GCC_get_id(t->current_ct->cc), | 2930 | GCC_get_id (t->current_ct->cc), |
2917 | msg); | 2931 | msg); |
2918 | } | 2932 | } |
2919 | 2933 | ||
2920 | 2934 | ||
@@ -2927,28 +2941,28 @@ handle_plaintext_data(void *cls, | |||
2927 | * @param ack the message we received on the tunnel | 2941 | * @param ack the message we received on the tunnel |
2928 | */ | 2942 | */ |
2929 | static void | 2943 | static void |
2930 | handle_plaintext_data_ack(void *cls, | 2944 | handle_plaintext_data_ack (void *cls, |
2931 | const struct GNUNET_CADET_ChannelDataAckMessage *ack) | 2945 | const struct GNUNET_CADET_ChannelDataAckMessage *ack) |
2932 | { | 2946 | { |
2933 | struct CadetTunnel *t = cls; | 2947 | struct CadetTunnel *t = cls; |
2934 | struct CadetChannel *ch; | 2948 | struct CadetChannel *ch; |
2935 | 2949 | ||
2936 | ch = lookup_channel(t, | 2950 | ch = lookup_channel (t, |
2937 | ack->ctn); | 2951 | ack->ctn); |
2938 | if (NULL == ch) | 2952 | if (NULL == ch) |
2939 | { | 2953 | { |
2940 | /* We don't know about such a channel, might have been destroyed on our | 2954 | /* We don't know about such a channel, might have been destroyed on our |
2941 | end in the meantime, or never existed. Send back a DESTROY. */ | 2955 | end in the meantime, or never existed. Send back a DESTROY. */ |
2942 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2956 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2943 | "Received DATA_ACK for unknown channel %u, sending DESTROY\n", | 2957 | "Received DATA_ACK for unknown channel %u, sending DESTROY\n", |
2944 | ntohl(ack->ctn.cn)); | 2958 | ntohl (ack->ctn.cn)); |
2945 | GCT_send_channel_destroy(t, | 2959 | GCT_send_channel_destroy (t, |
2946 | ack->ctn); | 2960 | ack->ctn); |
2947 | return; | 2961 | return; |
2948 | } | 2962 | } |
2949 | GCCH_handle_channel_plaintext_data_ack(ch, | 2963 | GCCH_handle_channel_plaintext_data_ack (ch, |
2950 | GCC_get_id(t->current_ct->cc), | 2964 | GCC_get_id (t->current_ct->cc), |
2951 | ack); | 2965 | ack); |
2952 | } | 2966 | } |
2953 | 2967 | ||
2954 | 2968 | ||
@@ -2960,43 +2974,44 @@ handle_plaintext_data_ack(void *cls, | |||
2960 | * @param copen the message we received on the tunnel | 2974 | * @param copen the message we received on the tunnel |
2961 | */ | 2975 | */ |
2962 | static void | 2976 | static void |
2963 | handle_plaintext_channel_open(void *cls, | 2977 | handle_plaintext_channel_open (void *cls, |
2964 | const struct GNUNET_CADET_ChannelOpenMessage *copen) | 2978 | const struct |
2979 | GNUNET_CADET_ChannelOpenMessage *copen) | ||
2965 | { | 2980 | { |
2966 | struct CadetTunnel *t = cls; | 2981 | struct CadetTunnel *t = cls; |
2967 | struct CadetChannel *ch; | 2982 | struct CadetChannel *ch; |
2968 | 2983 | ||
2969 | ch = GNUNET_CONTAINER_multihashmap32_get(t->channels, | 2984 | ch = GNUNET_CONTAINER_multihashmap32_get (t->channels, |
2970 | ntohl(copen->ctn.cn)); | 2985 | ntohl (copen->ctn.cn)); |
2971 | if (NULL != ch) | 2986 | if (NULL != ch) |
2972 | { | 2987 | { |
2973 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2988 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2974 | "Received duplicate channel CHANNEL_OPEN on h_port %s from %s (%s), resending ACK\n", | 2989 | "Received duplicate channel CHANNEL_OPEN on h_port %s from %s (%s), resending ACK\n", |
2975 | GNUNET_h2s(&copen->h_port), | 2990 | GNUNET_h2s (&copen->h_port), |
2976 | GCT_2s(t), | 2991 | GCT_2s (t), |
2977 | GCCH_2s(ch)); | 2992 | GCCH_2s (ch)); |
2978 | GCCH_handle_duplicate_open(ch, | 2993 | GCCH_handle_duplicate_open (ch, |
2979 | GCC_get_id(t->current_ct->cc)); | 2994 | GCC_get_id (t->current_ct->cc)); |
2980 | return; | 2995 | return; |
2981 | } | 2996 | } |
2982 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2997 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2983 | "Received CHANNEL_OPEN on h_port %s from %s\n", | 2998 | "Received CHANNEL_OPEN on h_port %s from %s\n", |
2984 | GNUNET_h2s(&copen->h_port), | 2999 | GNUNET_h2s (&copen->h_port), |
2985 | GCT_2s(t)); | 3000 | GCT_2s (t)); |
2986 | ch = GCCH_channel_incoming_new(t, | 3001 | ch = GCCH_channel_incoming_new (t, |
2987 | copen->ctn, | 3002 | copen->ctn, |
2988 | &copen->h_port, | 3003 | &copen->h_port, |
2989 | ntohl(copen->opt)); | 3004 | ntohl (copen->opt)); |
2990 | if (NULL != t->destroy_task) | 3005 | if (NULL != t->destroy_task) |
2991 | { | 3006 | { |
2992 | GNUNET_SCHEDULER_cancel(t->destroy_task); | 3007 | GNUNET_SCHEDULER_cancel (t->destroy_task); |
2993 | t->destroy_task = NULL; | 3008 | t->destroy_task = NULL; |
2994 | } | 3009 | } |
2995 | GNUNET_assert(GNUNET_OK == | 3010 | GNUNET_assert (GNUNET_OK == |
2996 | GNUNET_CONTAINER_multihashmap32_put(t->channels, | 3011 | GNUNET_CONTAINER_multihashmap32_put (t->channels, |
2997 | ntohl(copen->ctn.cn), | 3012 | ntohl (copen->ctn.cn), |
2998 | ch, | 3013 | ch, |
2999 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 3014 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
3000 | } | 3015 | } |
3001 | 3016 | ||
3002 | 3017 | ||
@@ -3007,22 +3022,22 @@ handle_plaintext_channel_open(void *cls, | |||
3007 | * @param ctn ID of the channel to destroy | 3022 | * @param ctn ID of the channel to destroy |
3008 | */ | 3023 | */ |
3009 | void | 3024 | void |
3010 | GCT_send_channel_destroy(struct CadetTunnel *t, | 3025 | GCT_send_channel_destroy (struct CadetTunnel *t, |
3011 | struct GNUNET_CADET_ChannelTunnelNumber ctn) | 3026 | struct GNUNET_CADET_ChannelTunnelNumber ctn) |
3012 | { | 3027 | { |
3013 | struct GNUNET_CADET_ChannelDestroyMessage msg; | 3028 | struct GNUNET_CADET_ChannelDestroyMessage msg; |
3014 | 3029 | ||
3015 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3030 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3016 | "Sending DESTORY message for channel ID %u\n", | 3031 | "Sending DESTORY message for channel ID %u\n", |
3017 | ntohl(ctn.cn)); | 3032 | ntohl (ctn.cn)); |
3018 | msg.header.size = htons(sizeof(msg)); | 3033 | msg.header.size = htons (sizeof(msg)); |
3019 | msg.header.type = htons(GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY); | 3034 | msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY); |
3020 | msg.reserved = htonl(0); | 3035 | msg.reserved = htonl (0); |
3021 | msg.ctn = ctn; | 3036 | msg.ctn = ctn; |
3022 | GCT_send(t, | 3037 | GCT_send (t, |
3023 | &msg.header, | 3038 | &msg.header, |
3024 | NULL, | 3039 | NULL, |
3025 | NULL); | 3040 | NULL); |
3026 | } | 3041 | } |
3027 | 3042 | ||
3028 | 3043 | ||
@@ -3035,32 +3050,33 @@ GCT_send_channel_destroy(struct CadetTunnel *t, | |||
3035 | * @param cm the message we received on the tunnel | 3050 | * @param cm the message we received on the tunnel |
3036 | */ | 3051 | */ |
3037 | static void | 3052 | static void |
3038 | handle_plaintext_channel_open_ack(void *cls, | 3053 | handle_plaintext_channel_open_ack (void *cls, |
3039 | const struct GNUNET_CADET_ChannelOpenAckMessage *cm) | 3054 | const struct |
3055 | GNUNET_CADET_ChannelOpenAckMessage *cm) | ||
3040 | { | 3056 | { |
3041 | struct CadetTunnel *t = cls; | 3057 | struct CadetTunnel *t = cls; |
3042 | struct CadetChannel *ch; | 3058 | struct CadetChannel *ch; |
3043 | 3059 | ||
3044 | ch = lookup_channel(t, | 3060 | ch = lookup_channel (t, |
3045 | cm->ctn); | 3061 | cm->ctn); |
3046 | if (NULL == ch) | 3062 | if (NULL == ch) |
3047 | { | 3063 | { |
3048 | /* We don't know about such a channel, might have been destroyed on our | 3064 | /* We don't know about such a channel, might have been destroyed on our |
3049 | end in the meantime, or never existed. Send back a DESTROY. */ | 3065 | end in the meantime, or never existed. Send back a DESTROY. */ |
3050 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3066 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3051 | "Received channel OPEN_ACK for unknown channel %u, sending DESTROY\n", | 3067 | "Received channel OPEN_ACK for unknown channel %u, sending DESTROY\n", |
3052 | ntohl(cm->ctn.cn)); | 3068 | ntohl (cm->ctn.cn)); |
3053 | GCT_send_channel_destroy(t, | 3069 | GCT_send_channel_destroy (t, |
3054 | cm->ctn); | 3070 | cm->ctn); |
3055 | return; | 3071 | return; |
3056 | } | 3072 | } |
3057 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3073 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3058 | "Received channel OPEN_ACK on channel %s from %s\n", | 3074 | "Received channel OPEN_ACK on channel %s from %s\n", |
3059 | GCCH_2s(ch), | 3075 | GCCH_2s (ch), |
3060 | GCT_2s(t)); | 3076 | GCT_2s (t)); |
3061 | GCCH_handle_channel_open_ack(ch, | 3077 | GCCH_handle_channel_open_ack (ch, |
3062 | GCC_get_id(t->current_ct->cc), | 3078 | GCC_get_id (t->current_ct->cc), |
3063 | &cm->port); | 3079 | &cm->port); |
3064 | } | 3080 | } |
3065 | 3081 | ||
3066 | 3082 | ||
@@ -3072,29 +3088,30 @@ handle_plaintext_channel_open_ack(void *cls, | |||
3072 | * @param cm the message we received on the tunnel | 3088 | * @param cm the message we received on the tunnel |
3073 | */ | 3089 | */ |
3074 | static void | 3090 | static void |
3075 | handle_plaintext_channel_destroy(void *cls, | 3091 | handle_plaintext_channel_destroy (void *cls, |
3076 | const struct GNUNET_CADET_ChannelDestroyMessage *cm) | 3092 | const struct |
3093 | GNUNET_CADET_ChannelDestroyMessage *cm) | ||
3077 | { | 3094 | { |
3078 | struct CadetTunnel *t = cls; | 3095 | struct CadetTunnel *t = cls; |
3079 | struct CadetChannel *ch; | 3096 | struct CadetChannel *ch; |
3080 | 3097 | ||
3081 | ch = lookup_channel(t, | 3098 | ch = lookup_channel (t, |
3082 | cm->ctn); | 3099 | cm->ctn); |
3083 | if (NULL == ch) | 3100 | if (NULL == ch) |
3084 | { | 3101 | { |
3085 | /* We don't know about such a channel, might have been destroyed on our | 3102 | /* We don't know about such a channel, might have been destroyed on our |
3086 | end in the meantime, or never existed. */ | 3103 | end in the meantime, or never existed. */ |
3087 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3104 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3088 | "Received channel DESTORY for unknown channel %u. Ignoring.\n", | 3105 | "Received channel DESTORY for unknown channel %u. Ignoring.\n", |
3089 | ntohl(cm->ctn.cn)); | 3106 | ntohl (cm->ctn.cn)); |
3090 | return; | 3107 | return; |
3091 | } | 3108 | } |
3092 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3109 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3093 | "Received channel DESTROY on %s from %s\n", | 3110 | "Received channel DESTROY on %s from %s\n", |
3094 | GCCH_2s(ch), | 3111 | GCCH_2s (ch), |
3095 | GCT_2s(t)); | 3112 | GCT_2s (t)); |
3096 | GCCH_handle_remote_destroy(ch, | 3113 | GCCH_handle_remote_destroy (ch, |
3097 | GCC_get_id(t->current_ct->cc)); | 3114 | GCC_get_id (t->current_ct->cc)); |
3098 | } | 3115 | } |
3099 | 3116 | ||
3100 | 3117 | ||
@@ -3109,14 +3126,14 @@ handle_plaintext_channel_destroy(void *cls, | |||
3109 | * #GNUNET_SYSERR to stop further processing with error | 3126 | * #GNUNET_SYSERR to stop further processing with error |
3110 | */ | 3127 | */ |
3111 | static int | 3128 | static int |
3112 | handle_decrypted(void *cls, | 3129 | handle_decrypted (void *cls, |
3113 | const struct GNUNET_MessageHeader *msg) | 3130 | const struct GNUNET_MessageHeader *msg) |
3114 | { | 3131 | { |
3115 | struct CadetTunnel *t = cls; | 3132 | struct CadetTunnel *t = cls; |
3116 | 3133 | ||
3117 | GNUNET_assert(NULL != t->current_ct); | 3134 | GNUNET_assert (NULL != t->current_ct); |
3118 | GNUNET_MQ_inject_message(t->mq, | 3135 | GNUNET_MQ_inject_message (t->mq, |
3119 | msg); | 3136 | msg); |
3120 | return GNUNET_OK; | 3137 | return GNUNET_OK; |
3121 | } | 3138 | } |
3122 | 3139 | ||
@@ -3129,10 +3146,10 @@ handle_decrypted(void *cls, | |||
3129 | * @param error error code | 3146 | * @param error error code |
3130 | */ | 3147 | */ |
3131 | static void | 3148 | static void |
3132 | decrypted_error_cb(void *cls, | 3149 | decrypted_error_cb (void *cls, |
3133 | enum GNUNET_MQ_Error error) | 3150 | enum GNUNET_MQ_Error error) |
3134 | { | 3151 | { |
3135 | GNUNET_break_op(0); | 3152 | GNUNET_break_op (0); |
3136 | } | 3153 | } |
3137 | 3154 | ||
3138 | 3155 | ||
@@ -3144,55 +3161,55 @@ decrypted_error_cb(void *cls, | |||
3144 | * @return new tunnel to @a destination | 3161 | * @return new tunnel to @a destination |
3145 | */ | 3162 | */ |
3146 | struct CadetTunnel * | 3163 | struct CadetTunnel * |
3147 | GCT_create_tunnel(struct CadetPeer *destination) | 3164 | GCT_create_tunnel (struct CadetPeer *destination) |
3148 | { | 3165 | { |
3149 | struct CadetTunnel *t = GNUNET_new(struct CadetTunnel); | 3166 | struct CadetTunnel *t = GNUNET_new (struct CadetTunnel); |
3150 | struct GNUNET_MQ_MessageHandler handlers[] = { | 3167 | struct GNUNET_MQ_MessageHandler handlers[] = { |
3151 | GNUNET_MQ_hd_fixed_size(plaintext_keepalive, | 3168 | GNUNET_MQ_hd_fixed_size (plaintext_keepalive, |
3152 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE, | 3169 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE, |
3153 | struct GNUNET_MessageHeader, | 3170 | struct GNUNET_MessageHeader, |
3154 | t), | 3171 | t), |
3155 | GNUNET_MQ_hd_var_size(plaintext_data, | 3172 | GNUNET_MQ_hd_var_size (plaintext_data, |
3156 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA, | 3173 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA, |
3157 | struct GNUNET_CADET_ChannelAppDataMessage, | 3174 | struct GNUNET_CADET_ChannelAppDataMessage, |
3158 | t), | 3175 | t), |
3159 | GNUNET_MQ_hd_fixed_size(plaintext_data_ack, | 3176 | GNUNET_MQ_hd_fixed_size (plaintext_data_ack, |
3160 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK, | 3177 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK, |
3161 | struct GNUNET_CADET_ChannelDataAckMessage, | 3178 | struct GNUNET_CADET_ChannelDataAckMessage, |
3162 | t), | 3179 | t), |
3163 | GNUNET_MQ_hd_fixed_size(plaintext_channel_open, | 3180 | GNUNET_MQ_hd_fixed_size (plaintext_channel_open, |
3164 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN, | 3181 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN, |
3165 | struct GNUNET_CADET_ChannelOpenMessage, | 3182 | struct GNUNET_CADET_ChannelOpenMessage, |
3166 | t), | 3183 | t), |
3167 | GNUNET_MQ_hd_fixed_size(plaintext_channel_open_ack, | 3184 | GNUNET_MQ_hd_fixed_size (plaintext_channel_open_ack, |
3168 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK, | 3185 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK, |
3169 | struct GNUNET_CADET_ChannelOpenAckMessage, | 3186 | struct GNUNET_CADET_ChannelOpenAckMessage, |
3170 | t), | 3187 | t), |
3171 | GNUNET_MQ_hd_fixed_size(plaintext_channel_destroy, | 3188 | GNUNET_MQ_hd_fixed_size (plaintext_channel_destroy, |
3172 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY, | 3189 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY, |
3173 | struct GNUNET_CADET_ChannelDestroyMessage, | 3190 | struct GNUNET_CADET_ChannelDestroyMessage, |
3174 | t), | 3191 | t), |
3175 | GNUNET_MQ_handler_end() | 3192 | GNUNET_MQ_handler_end () |
3176 | }; | 3193 | }; |
3177 | 3194 | ||
3178 | t->kx_retry_delay = INITIAL_KX_RETRY_DELAY; | 3195 | t->kx_retry_delay = INITIAL_KX_RETRY_DELAY; |
3179 | new_ephemeral(&t->ax); | 3196 | new_ephemeral (&t->ax); |
3180 | GNUNET_assert(GNUNET_OK == | 3197 | GNUNET_assert (GNUNET_OK == |
3181 | GNUNET_CRYPTO_ecdhe_key_create2(&t->ax.kx_0)); | 3198 | GNUNET_CRYPTO_ecdhe_key_create2 (&t->ax.kx_0)); |
3182 | t->destination = destination; | 3199 | t->destination = destination; |
3183 | t->channels = GNUNET_CONTAINER_multihashmap32_create(8); | 3200 | t->channels = GNUNET_CONTAINER_multihashmap32_create (8); |
3184 | t->maintain_connections_task | 3201 | t->maintain_connections_task |
3185 | = GNUNET_SCHEDULER_add_now(&maintain_connections_cb, | 3202 | = GNUNET_SCHEDULER_add_now (&maintain_connections_cb, |
3186 | t); | 3203 | t); |
3187 | t->mq = GNUNET_MQ_queue_for_callbacks(NULL, | 3204 | t->mq = GNUNET_MQ_queue_for_callbacks (NULL, |
3188 | NULL, | 3205 | NULL, |
3189 | NULL, | 3206 | NULL, |
3190 | NULL, | 3207 | NULL, |
3191 | handlers, | 3208 | handlers, |
3192 | &decrypted_error_cb, | 3209 | &decrypted_error_cb, |
3193 | t); | 3210 | t); |
3194 | t->mst = GNUNET_MST_create(&handle_decrypted, | 3211 | t->mst = GNUNET_MST_create (&handle_decrypted, |
3195 | t); | 3212 | t); |
3196 | return t; | 3213 | return t; |
3197 | } | 3214 | } |
3198 | 3215 | ||
@@ -3208,42 +3225,43 @@ GCT_create_tunnel(struct CadetPeer *destination) | |||
3208 | * #GNUNET_SYSERR on failure (duplicate connection) | 3225 | * #GNUNET_SYSERR on failure (duplicate connection) |
3209 | */ | 3226 | */ |
3210 | int | 3227 | int |
3211 | GCT_add_inbound_connection(struct CadetTunnel *t, | 3228 | GCT_add_inbound_connection (struct CadetTunnel *t, |
3212 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 3229 | const struct |
3213 | struct CadetPeerPath *path) | 3230 | GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
3231 | struct CadetPeerPath *path) | ||
3214 | { | 3232 | { |
3215 | struct CadetTConnection *ct; | 3233 | struct CadetTConnection *ct; |
3216 | 3234 | ||
3217 | ct = GNUNET_new(struct CadetTConnection); | 3235 | ct = GNUNET_new (struct CadetTConnection); |
3218 | ct->created = GNUNET_TIME_absolute_get(); | 3236 | ct->created = GNUNET_TIME_absolute_get (); |
3219 | ct->t = t; | 3237 | ct->t = t; |
3220 | ct->cc = GCC_create_inbound(t->destination, | 3238 | ct->cc = GCC_create_inbound (t->destination, |
3221 | path, | 3239 | path, |
3222 | ct, | 3240 | ct, |
3223 | cid, | 3241 | cid, |
3224 | &connection_ready_cb, | 3242 | &connection_ready_cb, |
3225 | ct); | 3243 | ct); |
3226 | if (NULL == ct->cc) | 3244 | if (NULL == ct->cc) |
3227 | { | 3245 | { |
3228 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3246 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3229 | "%s refused inbound %s (duplicate)\n", | 3247 | "%s refused inbound %s (duplicate)\n", |
3230 | GCT_2s(t), | 3248 | GCT_2s (t), |
3231 | GCC_2s(ct->cc)); | 3249 | GCC_2s (ct->cc)); |
3232 | GNUNET_free(ct); | 3250 | GNUNET_free (ct); |
3233 | return GNUNET_SYSERR; | 3251 | return GNUNET_SYSERR; |
3234 | } | 3252 | } |
3235 | /* FIXME: schedule job to kill connection (and path?) if it takes | 3253 | /* FIXME: schedule job to kill connection (and path?) if it takes |
3236 | too long to get ready! (And track performance data on how long | 3254 | too long to get ready! (And track performance data on how long |
3237 | other connections took with the tunnel!) | 3255 | other connections took with the tunnel!) |
3238 | => Note: to be done within 'connection'-logic! */ | 3256 | => Note: to be done within 'connection'-logic! */ |
3239 | GNUNET_CONTAINER_DLL_insert(t->connection_busy_head, | 3257 | GNUNET_CONTAINER_DLL_insert (t->connection_busy_head, |
3240 | t->connection_busy_tail, | 3258 | t->connection_busy_tail, |
3241 | ct); | 3259 | ct); |
3242 | t->num_busy_connections++; | 3260 | t->num_busy_connections++; |
3243 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3261 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3244 | "%s has new %s\n", | 3262 | "%s has new %s\n", |
3245 | GCT_2s(t), | 3263 | GCT_2s (t), |
3246 | GCC_2s(ct->cc)); | 3264 | GCC_2s (ct->cc)); |
3247 | return GNUNET_OK; | 3265 | return GNUNET_OK; |
3248 | } | 3266 | } |
3249 | 3267 | ||
@@ -3255,177 +3273,177 @@ GCT_add_inbound_connection(struct CadetTunnel *t, | |||
3255 | * @param msg the encrypted message to decrypt | 3273 | * @param msg the encrypted message to decrypt |
3256 | */ | 3274 | */ |
3257 | void | 3275 | void |
3258 | GCT_handle_encrypted(struct CadetTConnection *ct, | 3276 | GCT_handle_encrypted (struct CadetTConnection *ct, |
3259 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) | 3277 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg) |
3260 | { | 3278 | { |
3261 | struct CadetTunnel *t = ct->t; | 3279 | struct CadetTunnel *t = ct->t; |
3262 | uint16_t size = ntohs(msg->header.size); | 3280 | uint16_t size = ntohs (msg->header.size); |
3263 | char cbuf [size] GNUNET_ALIGN; | 3281 | char cbuf [size] GNUNET_ALIGN; |
3264 | ssize_t decrypted_size; | 3282 | ssize_t decrypted_size; |
3265 | 3283 | ||
3266 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3284 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3267 | "%s received %u bytes of encrypted data in state %d\n", | 3285 | "%s received %u bytes of encrypted data in state %d\n", |
3268 | GCT_2s(t), | 3286 | GCT_2s (t), |
3269 | (unsigned int)size, | 3287 | (unsigned int) size, |
3270 | t->estate); | 3288 | t->estate); |
3271 | 3289 | ||
3272 | switch (t->estate) | 3290 | switch (t->estate) |
3273 | { | 3291 | { |
3274 | case CADET_TUNNEL_KEY_UNINITIALIZED: | 3292 | case CADET_TUNNEL_KEY_UNINITIALIZED: |
3275 | case CADET_TUNNEL_KEY_AX_RECV: | 3293 | case CADET_TUNNEL_KEY_AX_RECV: |
3276 | /* We did not even SEND our KX, how can the other peer | 3294 | /* We did not even SEND our KX, how can the other peer |
3277 | send us encrypted data? Must have been that we went | 3295 | send us encrypted data? Must have been that we went |
3278 | down and the other peer still things we are up. | 3296 | down and the other peer still things we are up. |
3279 | Let's send it KX back. */ | 3297 | Let's send it KX back. */ |
3280 | GNUNET_STATISTICS_update(stats, | 3298 | GNUNET_STATISTICS_update (stats, |
3281 | "# received encrypted without any KX", | 3299 | "# received encrypted without any KX", |
3282 | 1, | 3300 | 1, |
3283 | GNUNET_NO); | 3301 | GNUNET_NO); |
3284 | if (NULL != t->kx_task) | 3302 | if (NULL != t->kx_task) |
3285 | { | 3303 | { |
3286 | GNUNET_SCHEDULER_cancel(t->kx_task); | 3304 | GNUNET_SCHEDULER_cancel (t->kx_task); |
3287 | t->kx_task = NULL; | 3305 | t->kx_task = NULL; |
3288 | } | 3306 | } |
3289 | send_kx(t, | 3307 | send_kx (t, |
3290 | ct, | 3308 | ct, |
3291 | &t->ax); | 3309 | &t->ax); |
3292 | return; | 3310 | return; |
3293 | |||
3294 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: | ||
3295 | /* We send KX, and other peer send KX to us at the same time. | ||
3296 | Neither KX is AUTH'ed, so let's try KX_AUTH this time. */ | ||
3297 | GNUNET_STATISTICS_update(stats, | ||
3298 | "# received encrypted without KX_AUTH", | ||
3299 | 1, | ||
3300 | GNUNET_NO); | ||
3301 | if (NULL != t->kx_task) | ||
3302 | { | ||
3303 | GNUNET_SCHEDULER_cancel(t->kx_task); | ||
3304 | t->kx_task = NULL; | ||
3305 | } | ||
3306 | send_kx_auth(t, | ||
3307 | ct, | ||
3308 | &t->ax, | ||
3309 | GNUNET_YES); | ||
3310 | return; | ||
3311 | 3311 | ||
3312 | case CADET_TUNNEL_KEY_AX_SENT: | 3312 | case CADET_TUNNEL_KEY_AX_SENT_AND_RECV: |
3313 | /* We did not get the KX of the other peer, but that | 3313 | /* We send KX, and other peer send KX to us at the same time. |
3314 | might have been lost. Send our KX again immediately. */ | 3314 | Neither KX is AUTH'ed, so let's try KX_AUTH this time. */ |
3315 | GNUNET_STATISTICS_update(stats, | 3315 | GNUNET_STATISTICS_update (stats, |
3316 | "# received encrypted without KX", | 3316 | "# received encrypted without KX_AUTH", |
3317 | 1, | 3317 | 1, |
3318 | GNUNET_NO); | 3318 | GNUNET_NO); |
3319 | if (NULL != t->kx_task) | 3319 | if (NULL != t->kx_task) |
3320 | { | 3320 | { |
3321 | GNUNET_SCHEDULER_cancel(t->kx_task); | 3321 | GNUNET_SCHEDULER_cancel (t->kx_task); |
3322 | t->kx_task = NULL; | 3322 | t->kx_task = NULL; |
3323 | } | 3323 | } |
3324 | send_kx(t, | 3324 | send_kx_auth (t, |
3325 | ct, | 3325 | ct, |
3326 | &t->ax); | 3326 | &t->ax, |
3327 | return; | 3327 | GNUNET_YES); |
3328 | return; | ||
3328 | 3329 | ||
3329 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: | 3330 | case CADET_TUNNEL_KEY_AX_SENT: |
3330 | /* Great, first payload, we might graduate to OK! */ | 3331 | /* We did not get the KX of the other peer, but that |
3331 | case CADET_TUNNEL_KEY_OK: | 3332 | might have been lost. Send our KX again immediately. */ |
3332 | /* We are up and running, all good. */ | 3333 | GNUNET_STATISTICS_update (stats, |
3333 | break; | 3334 | "# received encrypted without KX", |
3335 | 1, | ||
3336 | GNUNET_NO); | ||
3337 | if (NULL != t->kx_task) | ||
3338 | { | ||
3339 | GNUNET_SCHEDULER_cancel (t->kx_task); | ||
3340 | t->kx_task = NULL; | ||
3334 | } | 3341 | } |
3342 | send_kx (t, | ||
3343 | ct, | ||
3344 | &t->ax); | ||
3345 | return; | ||
3346 | |||
3347 | case CADET_TUNNEL_KEY_AX_AUTH_SENT: | ||
3348 | /* Great, first payload, we might graduate to OK! */ | ||
3349 | case CADET_TUNNEL_KEY_OK: | ||
3350 | /* We are up and running, all good. */ | ||
3351 | break; | ||
3352 | } | ||
3335 | 3353 | ||
3336 | decrypted_size = -1; | 3354 | decrypted_size = -1; |
3337 | if (CADET_TUNNEL_KEY_OK == t->estate) | 3355 | if (CADET_TUNNEL_KEY_OK == t->estate) |
3338 | { | 3356 | { |
3339 | /* We have well-established key material available, | 3357 | /* We have well-established key material available, |
3340 | try that. (This is the common case.) */ | 3358 | try that. (This is the common case.) */ |
3341 | decrypted_size = t_ax_decrypt_and_validate(&t->ax, | 3359 | decrypted_size = t_ax_decrypt_and_validate (&t->ax, |
3342 | cbuf, | 3360 | cbuf, |
3343 | msg, | 3361 | msg, |
3344 | size); | 3362 | size); |
3345 | } | 3363 | } |
3346 | 3364 | ||
3347 | if ((-1 == decrypted_size) && | 3365 | if ((-1 == decrypted_size) && |
3348 | (NULL != t->unverified_ax)) | 3366 | (NULL != t->unverified_ax)) |
3367 | { | ||
3368 | /* We have un-authenticated KX material available. We should try | ||
3369 | this as a back-up option, in case the sender crashed and | ||
3370 | switched keys. */ | ||
3371 | decrypted_size = t_ax_decrypt_and_validate (t->unverified_ax, | ||
3372 | cbuf, | ||
3373 | msg, | ||
3374 | size); | ||
3375 | if (-1 != decrypted_size) | ||
3376 | { | ||
3377 | /* It worked! Treat this as authentication of the AX data! */ | ||
3378 | cleanup_ax (&t->ax); | ||
3379 | t->ax = *t->unverified_ax; | ||
3380 | GNUNET_free (t->unverified_ax); | ||
3381 | t->unverified_ax = NULL; | ||
3382 | } | ||
3383 | if (CADET_TUNNEL_KEY_AX_AUTH_SENT == t->estate) | ||
3349 | { | 3384 | { |
3350 | /* We have un-authenticated KX material available. We should try | 3385 | /* First time it worked, move tunnel into production! */ |
3351 | this as a back-up option, in case the sender crashed and | 3386 | GCT_change_estate (t, |
3352 | switched keys. */ | 3387 | CADET_TUNNEL_KEY_OK); |
3353 | decrypted_size = t_ax_decrypt_and_validate(t->unverified_ax, | 3388 | if (NULL != t->send_task) |
3354 | cbuf, | 3389 | GNUNET_SCHEDULER_cancel (t->send_task); |
3355 | msg, | 3390 | t->send_task = GNUNET_SCHEDULER_add_now (&trigger_transmissions, |
3356 | size); | 3391 | t); |
3357 | if (-1 != decrypted_size) | ||
3358 | { | ||
3359 | /* It worked! Treat this as authentication of the AX data! */ | ||
3360 | cleanup_ax(&t->ax); | ||
3361 | t->ax = *t->unverified_ax; | ||
3362 | GNUNET_free(t->unverified_ax); | ||
3363 | t->unverified_ax = NULL; | ||
3364 | } | ||
3365 | if (CADET_TUNNEL_KEY_AX_AUTH_SENT == t->estate) | ||
3366 | { | ||
3367 | /* First time it worked, move tunnel into production! */ | ||
3368 | GCT_change_estate(t, | ||
3369 | CADET_TUNNEL_KEY_OK); | ||
3370 | if (NULL != t->send_task) | ||
3371 | GNUNET_SCHEDULER_cancel(t->send_task); | ||
3372 | t->send_task = GNUNET_SCHEDULER_add_now(&trigger_transmissions, | ||
3373 | t); | ||
3374 | } | ||
3375 | } | 3392 | } |
3393 | } | ||
3376 | if (NULL != t->unverified_ax) | 3394 | if (NULL != t->unverified_ax) |
3377 | { | 3395 | { |
3378 | /* We had unverified KX material that was useless; so increment | 3396 | /* We had unverified KX material that was useless; so increment |
3379 | counter and eventually move to ignore it. Note that we even do | 3397 | counter and eventually move to ignore it. Note that we even do |
3380 | this increment if we successfully decrypted with the old KX | 3398 | this increment if we successfully decrypted with the old KX |
3381 | material and thus didn't even both with the new one. This is | 3399 | material and thus didn't even both with the new one. This is |
3382 | the ideal case, as a malicious injection of bogus KX data | 3400 | the ideal case, as a malicious injection of bogus KX data |
3383 | basically only causes us to increment a counter a few times. */ | 3401 | basically only causes us to increment a counter a few times. */ |
3384 | t->unverified_attempts++; | 3402 | t->unverified_attempts++; |
3385 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3403 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3386 | "Failed to decrypt message with unverified KX data %u times\n", | 3404 | "Failed to decrypt message with unverified KX data %u times\n", |
3387 | t->unverified_attempts); | 3405 | t->unverified_attempts); |
3388 | if (t->unverified_attempts > MAX_UNVERIFIED_ATTEMPTS) | 3406 | if (t->unverified_attempts > MAX_UNVERIFIED_ATTEMPTS) |
3389 | { | 3407 | { |
3390 | cleanup_ax(t->unverified_ax); | 3408 | cleanup_ax (t->unverified_ax); |
3391 | GNUNET_free(t->unverified_ax); | 3409 | GNUNET_free (t->unverified_ax); |
3392 | t->unverified_ax = NULL; | 3410 | t->unverified_ax = NULL; |
3393 | } | ||
3394 | } | 3411 | } |
3412 | } | ||
3395 | 3413 | ||
3396 | if (-1 == decrypted_size) | 3414 | if (-1 == decrypted_size) |
3397 | { | 3415 | { |
3398 | /* Decryption failed for good, complain. */ | 3416 | /* Decryption failed for good, complain. */ |
3399 | LOG(GNUNET_ERROR_TYPE_WARNING, | 3417 | LOG (GNUNET_ERROR_TYPE_WARNING, |
3400 | "%s failed to decrypt and validate encrypted data, retrying KX\n", | 3418 | "%s failed to decrypt and validate encrypted data, retrying KX\n", |
3401 | GCT_2s(t)); | 3419 | GCT_2s (t)); |
3402 | GNUNET_STATISTICS_update(stats, | 3420 | GNUNET_STATISTICS_update (stats, |
3403 | "# unable to decrypt", | 3421 | "# unable to decrypt", |
3404 | 1, | 3422 | 1, |
3405 | GNUNET_NO); | 3423 | GNUNET_NO); |
3406 | if (NULL != t->kx_task) | 3424 | if (NULL != t->kx_task) |
3407 | { | 3425 | { |
3408 | GNUNET_SCHEDULER_cancel(t->kx_task); | 3426 | GNUNET_SCHEDULER_cancel (t->kx_task); |
3409 | t->kx_task = NULL; | 3427 | t->kx_task = NULL; |
3410 | } | ||
3411 | send_kx(t, | ||
3412 | ct, | ||
3413 | &t->ax); | ||
3414 | return; | ||
3415 | } | 3428 | } |
3416 | GNUNET_STATISTICS_update(stats, | 3429 | send_kx (t, |
3417 | "# decrypted bytes", | 3430 | ct, |
3418 | decrypted_size, | 3431 | &t->ax); |
3419 | GNUNET_NO); | 3432 | return; |
3433 | } | ||
3434 | GNUNET_STATISTICS_update (stats, | ||
3435 | "# decrypted bytes", | ||
3436 | decrypted_size, | ||
3437 | GNUNET_NO); | ||
3420 | 3438 | ||
3421 | /* The MST will ultimately call #handle_decrypted() on each message. */ | 3439 | /* The MST will ultimately call #handle_decrypted() on each message. */ |
3422 | t->current_ct = ct; | 3440 | t->current_ct = ct; |
3423 | GNUNET_break_op(GNUNET_OK == | 3441 | GNUNET_break_op (GNUNET_OK == |
3424 | GNUNET_MST_from_buffer(t->mst, | 3442 | GNUNET_MST_from_buffer (t->mst, |
3425 | cbuf, | 3443 | cbuf, |
3426 | decrypted_size, | 3444 | decrypted_size, |
3427 | GNUNET_YES, | 3445 | GNUNET_YES, |
3428 | GNUNET_NO)); | 3446 | GNUNET_NO)); |
3429 | t->current_ct = NULL; | 3447 | t->current_ct = NULL; |
3430 | } | 3448 | } |
3431 | 3449 | ||
@@ -3441,10 +3459,10 @@ GCT_handle_encrypted(struct CadetTConnection *ct, | |||
3441 | * @return Handle to cancel message | 3459 | * @return Handle to cancel message |
3442 | */ | 3460 | */ |
3443 | struct CadetTunnelQueueEntry * | 3461 | struct CadetTunnelQueueEntry * |
3444 | GCT_send(struct CadetTunnel *t, | 3462 | GCT_send (struct CadetTunnel *t, |
3445 | const struct GNUNET_MessageHeader *message, | 3463 | const struct GNUNET_MessageHeader *message, |
3446 | GCT_SendContinuation cont, | 3464 | GCT_SendContinuation cont, |
3447 | void *cont_cls) | 3465 | void *cont_cls) |
3448 | { | 3466 | { |
3449 | struct CadetTunnelQueueEntry *tq; | 3467 | struct CadetTunnelQueueEntry *tq; |
3450 | uint16_t payload_size; | 3468 | uint16_t payload_size; |
@@ -3452,55 +3470,55 @@ GCT_send(struct CadetTunnel *t, | |||
3452 | struct GNUNET_CADET_TunnelEncryptedMessage *ax_msg; | 3470 | struct GNUNET_CADET_TunnelEncryptedMessage *ax_msg; |
3453 | 3471 | ||
3454 | if (CADET_TUNNEL_KEY_OK != t->estate) | 3472 | if (CADET_TUNNEL_KEY_OK != t->estate) |
3455 | { | 3473 | { |
3456 | GNUNET_break(0); | 3474 | GNUNET_break (0); |
3457 | return NULL; | 3475 | return NULL; |
3458 | } | 3476 | } |
3459 | payload_size = ntohs(message->size); | 3477 | payload_size = ntohs (message->size); |
3460 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 3478 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
3461 | "Encrypting %u bytes for %s\n", | 3479 | "Encrypting %u bytes for %s\n", |
3462 | (unsigned int)payload_size, | 3480 | (unsigned int) payload_size, |
3463 | GCT_2s(t)); | 3481 | GCT_2s (t)); |
3464 | env = GNUNET_MQ_msg_extra(ax_msg, | 3482 | env = GNUNET_MQ_msg_extra (ax_msg, |
3483 | payload_size, | ||
3484 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED); | ||
3485 | t_ax_encrypt (&t->ax, | ||
3486 | &ax_msg[1], | ||
3487 | message, | ||
3488 | payload_size); | ||
3489 | GNUNET_STATISTICS_update (stats, | ||
3490 | "# encrypted bytes", | ||
3465 | payload_size, | 3491 | payload_size, |
3466 | GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED); | 3492 | GNUNET_NO); |
3467 | t_ax_encrypt(&t->ax, | 3493 | ax_msg->ax_header.Ns = htonl (t->ax.Ns++); |
3468 | &ax_msg[1], | 3494 | ax_msg->ax_header.PNs = htonl (t->ax.PNs); |
3469 | message, | ||
3470 | payload_size); | ||
3471 | GNUNET_STATISTICS_update(stats, | ||
3472 | "# encrypted bytes", | ||
3473 | payload_size, | ||
3474 | GNUNET_NO); | ||
3475 | ax_msg->ax_header.Ns = htonl(t->ax.Ns++); | ||
3476 | ax_msg->ax_header.PNs = htonl(t->ax.PNs); | ||
3477 | /* FIXME: we should do this once, not once per message; | 3495 | /* FIXME: we should do this once, not once per message; |
3478 | this is a point multiplication, and DHRs does not | 3496 | this is a point multiplication, and DHRs does not |
3479 | change all the time. */ | 3497 | change all the time. */ |
3480 | GNUNET_CRYPTO_ecdhe_key_get_public(&t->ax.DHRs, | 3498 | GNUNET_CRYPTO_ecdhe_key_get_public (&t->ax.DHRs, |
3481 | &ax_msg->ax_header.DHRs); | 3499 | &ax_msg->ax_header.DHRs); |
3482 | t_h_encrypt(&t->ax, | 3500 | t_h_encrypt (&t->ax, |
3483 | ax_msg); | 3501 | ax_msg); |
3484 | t_hmac(&ax_msg->ax_header, | 3502 | t_hmac (&ax_msg->ax_header, |
3485 | sizeof(struct GNUNET_CADET_AxHeader) + payload_size, | 3503 | sizeof(struct GNUNET_CADET_AxHeader) + payload_size, |
3486 | 0, | 3504 | 0, |
3487 | &t->ax.HKs, | 3505 | &t->ax.HKs, |
3488 | &ax_msg->hmac); | 3506 | &ax_msg->hmac); |
3489 | 3507 | ||
3490 | tq = GNUNET_malloc(sizeof(*tq)); | 3508 | tq = GNUNET_malloc (sizeof(*tq)); |
3491 | tq->t = t; | 3509 | tq->t = t; |
3492 | tq->env = env; | 3510 | tq->env = env; |
3493 | tq->cid = &ax_msg->cid; /* will initialize 'ax_msg->cid' once we know the connection */ | 3511 | tq->cid = &ax_msg->cid; /* will initialize 'ax_msg->cid' once we know the connection */ |
3494 | tq->cont = cont; | 3512 | tq->cont = cont; |
3495 | tq->cont_cls = cont_cls; | 3513 | tq->cont_cls = cont_cls; |
3496 | GNUNET_CONTAINER_DLL_insert_tail(t->tq_head, | 3514 | GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, |
3497 | t->tq_tail, | 3515 | t->tq_tail, |
3498 | tq); | 3516 | tq); |
3499 | if (NULL != t->send_task) | 3517 | if (NULL != t->send_task) |
3500 | GNUNET_SCHEDULER_cancel(t->send_task); | 3518 | GNUNET_SCHEDULER_cancel (t->send_task); |
3501 | t->send_task | 3519 | t->send_task |
3502 | = GNUNET_SCHEDULER_add_now(&trigger_transmissions, | 3520 | = GNUNET_SCHEDULER_add_now (&trigger_transmissions, |
3503 | t); | 3521 | t); |
3504 | return tq; | 3522 | return tq; |
3505 | } | 3523 | } |
3506 | 3524 | ||
@@ -3515,15 +3533,15 @@ GCT_send(struct CadetTunnel *t, | |||
3515 | * @param tq Handle to the queue entry to cancel. | 3533 | * @param tq Handle to the queue entry to cancel. |
3516 | */ | 3534 | */ |
3517 | void | 3535 | void |
3518 | GCT_send_cancel(struct CadetTunnelQueueEntry *tq) | 3536 | GCT_send_cancel (struct CadetTunnelQueueEntry *tq) |
3519 | { | 3537 | { |
3520 | struct CadetTunnel *t = tq->t; | 3538 | struct CadetTunnel *t = tq->t; |
3521 | 3539 | ||
3522 | GNUNET_CONTAINER_DLL_remove(t->tq_head, | 3540 | GNUNET_CONTAINER_DLL_remove (t->tq_head, |
3523 | t->tq_tail, | 3541 | t->tq_tail, |
3524 | tq); | 3542 | tq); |
3525 | GNUNET_MQ_discard(tq->env); | 3543 | GNUNET_MQ_discard (tq->env); |
3526 | GNUNET_free(tq); | 3544 | GNUNET_free (tq); |
3527 | } | 3545 | } |
3528 | 3546 | ||
3529 | 3547 | ||
@@ -3535,35 +3553,36 @@ GCT_send_cancel(struct CadetTunnelQueueEntry *tq) | |||
3535 | * @param iter_cls Closure for @c iter. | 3553 | * @param iter_cls Closure for @c iter. |
3536 | */ | 3554 | */ |
3537 | void | 3555 | void |
3538 | GCT_iterate_connections(struct CadetTunnel *t, | 3556 | GCT_iterate_connections (struct CadetTunnel *t, |
3539 | GCT_ConnectionIterator iter, | 3557 | GCT_ConnectionIterator iter, |
3540 | void *iter_cls) | 3558 | void *iter_cls) |
3541 | { | 3559 | { |
3542 | struct CadetTConnection *n; | 3560 | struct CadetTConnection *n; |
3543 | 3561 | ||
3544 | for (struct CadetTConnection *ct = t->connection_ready_head; | 3562 | for (struct CadetTConnection *ct = t->connection_ready_head; |
3545 | NULL != ct; | 3563 | NULL != ct; |
3546 | ct = n) | 3564 | ct = n) |
3547 | { | 3565 | { |
3548 | n = ct->next; | 3566 | n = ct->next; |
3549 | iter(iter_cls, | 3567 | iter (iter_cls, |
3550 | ct); | 3568 | ct); |
3551 | } | 3569 | } |
3552 | for (struct CadetTConnection *ct = t->connection_busy_head; | 3570 | for (struct CadetTConnection *ct = t->connection_busy_head; |
3553 | NULL != ct; | 3571 | NULL != ct; |
3554 | ct = n) | 3572 | ct = n) |
3555 | { | 3573 | { |
3556 | n = ct->next; | 3574 | n = ct->next; |
3557 | iter(iter_cls, | 3575 | iter (iter_cls, |
3558 | ct); | 3576 | ct); |
3559 | } | 3577 | } |
3560 | } | 3578 | } |
3561 | 3579 | ||
3562 | 3580 | ||
3563 | /** | 3581 | /** |
3564 | * Closure for #iterate_channels_cb. | 3582 | * Closure for #iterate_channels_cb. |
3565 | */ | 3583 | */ |
3566 | struct ChanIterCls { | 3584 | struct ChanIterCls |
3585 | { | ||
3567 | /** | 3586 | /** |
3568 | * Function to call. | 3587 | * Function to call. |
3569 | */ | 3588 | */ |
@@ -3585,15 +3604,15 @@ struct ChanIterCls { | |||
3585 | * @return #GNUNET_OK | 3604 | * @return #GNUNET_OK |
3586 | */ | 3605 | */ |
3587 | static int | 3606 | static int |
3588 | iterate_channels_cb(void *cls, | 3607 | iterate_channels_cb (void *cls, |
3589 | uint32_t key, | 3608 | uint32_t key, |
3590 | void *value) | 3609 | void *value) |
3591 | { | 3610 | { |
3592 | struct ChanIterCls *ctx = cls; | 3611 | struct ChanIterCls *ctx = cls; |
3593 | struct CadetChannel *ch = value; | 3612 | struct CadetChannel *ch = value; |
3594 | 3613 | ||
3595 | ctx->iter(ctx->iter_cls, | 3614 | ctx->iter (ctx->iter_cls, |
3596 | ch); | 3615 | ch); |
3597 | return GNUNET_OK; | 3616 | return GNUNET_OK; |
3598 | } | 3617 | } |
3599 | 3618 | ||
@@ -3606,17 +3625,17 @@ iterate_channels_cb(void *cls, | |||
3606 | * @param iter_cls Closure for @c iter. | 3625 | * @param iter_cls Closure for @c iter. |
3607 | */ | 3626 | */ |
3608 | void | 3627 | void |
3609 | GCT_iterate_channels(struct CadetTunnel *t, | 3628 | GCT_iterate_channels (struct CadetTunnel *t, |
3610 | GCT_ChannelIterator iter, | 3629 | GCT_ChannelIterator iter, |
3611 | void *iter_cls) | 3630 | void *iter_cls) |
3612 | { | 3631 | { |
3613 | struct ChanIterCls ctx; | 3632 | struct ChanIterCls ctx; |
3614 | 3633 | ||
3615 | ctx.iter = iter; | 3634 | ctx.iter = iter; |
3616 | ctx.iter_cls = iter_cls; | 3635 | ctx.iter_cls = iter_cls; |
3617 | GNUNET_CONTAINER_multihashmap32_iterate(t->channels, | 3636 | GNUNET_CONTAINER_multihashmap32_iterate (t->channels, |
3618 | &iterate_channels_cb, | 3637 | &iterate_channels_cb, |
3619 | &ctx); | 3638 | &ctx); |
3620 | } | 3639 | } |
3621 | 3640 | ||
3622 | 3641 | ||
@@ -3629,19 +3648,20 @@ GCT_iterate_channels(struct CadetTunnel *t, | |||
3629 | * @return #GNUNET_OK (continue iteration) | 3648 | * @return #GNUNET_OK (continue iteration) |
3630 | */ | 3649 | */ |
3631 | static int | 3650 | static int |
3632 | debug_channel(void *cls, | 3651 | debug_channel (void *cls, |
3633 | uint32_t key, | 3652 | uint32_t key, |
3634 | void *value) | 3653 | void *value) |
3635 | { | 3654 | { |
3636 | const enum GNUNET_ErrorType *level = cls; | 3655 | const enum GNUNET_ErrorType *level = cls; |
3637 | struct CadetChannel *ch = value; | 3656 | struct CadetChannel *ch = value; |
3638 | 3657 | ||
3639 | GCCH_debug(ch, *level); | 3658 | GCCH_debug (ch, *level); |
3640 | return GNUNET_OK; | 3659 | return GNUNET_OK; |
3641 | } | 3660 | } |
3642 | 3661 | ||
3643 | 3662 | ||
3644 | #define LOG2(level, ...) GNUNET_log_from_nocheck(level, "cadet-tun", __VA_ARGS__) | 3663 | #define LOG2(level, ...) GNUNET_log_from_nocheck (level, "cadet-tun", \ |
3664 | __VA_ARGS__) | ||
3645 | 3665 | ||
3646 | 3666 | ||
3647 | /** | 3667 | /** |
@@ -3651,41 +3671,41 @@ debug_channel(void *cls, | |||
3651 | * @param level Debug level to use. | 3671 | * @param level Debug level to use. |
3652 | */ | 3672 | */ |
3653 | void | 3673 | void |
3654 | GCT_debug(const struct CadetTunnel *t, | 3674 | GCT_debug (const struct CadetTunnel *t, |
3655 | enum GNUNET_ErrorType level) | 3675 | enum GNUNET_ErrorType level) |
3656 | { | 3676 | { |
3657 | #if !defined(GNUNET_CULL_LOGGING) | 3677 | #if ! defined(GNUNET_CULL_LOGGING) |
3658 | struct CadetTConnection *iter_c; | 3678 | struct CadetTConnection *iter_c; |
3659 | int do_log; | 3679 | int do_log; |
3660 | 3680 | ||
3661 | do_log = GNUNET_get_log_call_status(level & (~GNUNET_ERROR_TYPE_BULK), | 3681 | do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK), |
3662 | "cadet-tun", | 3682 | "cadet-tun", |
3663 | __FILE__, __FUNCTION__, __LINE__); | 3683 | __FILE__, __FUNCTION__, __LINE__); |
3664 | if (0 == do_log) | 3684 | if (0 == do_log) |
3665 | return; | 3685 | return; |
3666 | 3686 | ||
3667 | LOG2(level, | 3687 | LOG2 (level, |
3668 | "TTT TUNNEL TOWARDS %s in estate %s tq_len: %u #cons: %u\n", | 3688 | "TTT TUNNEL TOWARDS %s in estate %s tq_len: %u #cons: %u\n", |
3669 | GCT_2s(t), | 3689 | GCT_2s (t), |
3670 | estate2s(t->estate), | 3690 | estate2s (t->estate), |
3671 | t->tq_len, | 3691 | t->tq_len, |
3672 | GCT_count_any_connections(t)); | 3692 | GCT_count_any_connections (t)); |
3673 | LOG2(level, | 3693 | LOG2 (level, |
3674 | "TTT channels:\n"); | 3694 | "TTT channels:\n"); |
3675 | GNUNET_CONTAINER_multihashmap32_iterate(t->channels, | 3695 | GNUNET_CONTAINER_multihashmap32_iterate (t->channels, |
3676 | &debug_channel, | 3696 | &debug_channel, |
3677 | &level); | 3697 | &level); |
3678 | LOG2(level, | 3698 | LOG2 (level, |
3679 | "TTT connections:\n"); | 3699 | "TTT connections:\n"); |
3680 | for (iter_c = t->connection_ready_head; NULL != iter_c; iter_c = iter_c->next) | 3700 | for (iter_c = t->connection_ready_head; NULL != iter_c; iter_c = iter_c->next) |
3681 | GCC_debug(iter_c->cc, | 3701 | GCC_debug (iter_c->cc, |
3682 | level); | 3702 | level); |
3683 | for (iter_c = t->connection_busy_head; NULL != iter_c; iter_c = iter_c->next) | 3703 | for (iter_c = t->connection_busy_head; NULL != iter_c; iter_c = iter_c->next) |
3684 | GCC_debug(iter_c->cc, | 3704 | GCC_debug (iter_c->cc, |
3685 | level); | 3705 | level); |
3686 | 3706 | ||
3687 | LOG2(level, | 3707 | LOG2 (level, |
3688 | "TTT TUNNEL END\n"); | 3708 | "TTT TUNNEL END\n"); |
3689 | #endif | 3709 | #endif |
3690 | } | 3710 | } |
3691 | 3711 | ||
diff --git a/src/cadet/gnunet-service-cadet_tunnels.h b/src/cadet/gnunet-service-cadet_tunnels.h index 0df35cd23..ef07badea 100644 --- a/src/cadet/gnunet-service-cadet_tunnels.h +++ b/src/cadet/gnunet-service-cadet_tunnels.h | |||
@@ -1,4 +1,3 @@ | |||
1 | |||
2 | /* | 1 | /* |
3 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
4 | Copyright (C) 2001-2017 GNUnet e.V. | 3 | Copyright (C) 2001-2017 GNUnet e.V. |
@@ -41,7 +40,8 @@ | |||
41 | /** | 40 | /** |
42 | * All the encryption states a tunnel can be in. | 41 | * All the encryption states a tunnel can be in. |
43 | */ | 42 | */ |
44 | enum CadetTunnelEState { | 43 | enum CadetTunnelEState |
44 | { | ||
45 | /** | 45 | /** |
46 | * Uninitialized status, we need to send KX. We will stay | 46 | * Uninitialized status, we need to send KX. We will stay |
47 | * in this state until the first connection is up. | 47 | * in this state until the first connection is up. |
@@ -89,7 +89,7 @@ enum CadetTunnelEState { | |||
89 | * @return Static string the destination peer's ID. | 89 | * @return Static string the destination peer's ID. |
90 | */ | 90 | */ |
91 | const char * | 91 | const char * |
92 | GCT_2s(const struct CadetTunnel *t); | 92 | GCT_2s (const struct CadetTunnel *t); |
93 | 93 | ||
94 | 94 | ||
95 | /** | 95 | /** |
@@ -100,7 +100,7 @@ GCT_2s(const struct CadetTunnel *t); | |||
100 | * @return new tunnel to @a destination | 100 | * @return new tunnel to @a destination |
101 | */ | 101 | */ |
102 | struct CadetTunnel * | 102 | struct CadetTunnel * |
103 | GCT_create_tunnel(struct CadetPeer *destination); | 103 | GCT_create_tunnel (struct CadetPeer *destination); |
104 | 104 | ||
105 | 105 | ||
106 | /** | 106 | /** |
@@ -109,7 +109,7 @@ GCT_create_tunnel(struct CadetPeer *destination); | |||
109 | * @param t tunnel to destroy | 109 | * @param t tunnel to destroy |
110 | */ | 110 | */ |
111 | void | 111 | void |
112 | GCT_destroy_tunnel_now(struct CadetTunnel *t); | 112 | GCT_destroy_tunnel_now (struct CadetTunnel *t); |
113 | 113 | ||
114 | 114 | ||
115 | /** | 115 | /** |
@@ -122,9 +122,10 @@ GCT_destroy_tunnel_now(struct CadetTunnel *t); | |||
122 | * #GNUNET_SYSERR on failure (duplicate connection) | 122 | * #GNUNET_SYSERR on failure (duplicate connection) |
123 | */ | 123 | */ |
124 | int | 124 | int |
125 | GCT_add_inbound_connection(struct CadetTunnel *t, | 125 | GCT_add_inbound_connection (struct CadetTunnel *t, |
126 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid, | 126 | const struct |
127 | struct CadetPeerPath *path); | 127 | GNUNET_CADET_ConnectionTunnelIdentifier *cid, |
128 | struct CadetPeerPath *path); | ||
128 | 129 | ||
129 | 130 | ||
130 | /** | 131 | /** |
@@ -134,7 +135,7 @@ GCT_add_inbound_connection(struct CadetTunnel *t, | |||
134 | * @param ct binding of connection to tunnel of the connection that was lost. | 135 | * @param ct binding of connection to tunnel of the connection that was lost. |
135 | */ | 136 | */ |
136 | void | 137 | void |
137 | GCT_connection_lost(struct CadetTConnection *ct); | 138 | GCT_connection_lost (struct CadetTConnection *ct); |
138 | 139 | ||
139 | 140 | ||
140 | /** | 141 | /** |
@@ -144,7 +145,7 @@ GCT_connection_lost(struct CadetTConnection *ct); | |||
144 | * @return the destination of the tunnel | 145 | * @return the destination of the tunnel |
145 | */ | 146 | */ |
146 | struct CadetPeer * | 147 | struct CadetPeer * |
147 | GCT_get_destination(struct CadetTunnel *t); | 148 | GCT_get_destination (struct CadetTunnel *t); |
148 | 149 | ||
149 | 150 | ||
150 | /** | 151 | /** |
@@ -156,9 +157,9 @@ GCT_get_destination(struct CadetTunnel *t); | |||
156 | * @param off offset of the destination on path @a path | 157 | * @param off offset of the destination on path @a path |
157 | */ | 158 | */ |
158 | void | 159 | void |
159 | GCT_consider_path(struct CadetTunnel *t, | 160 | GCT_consider_path (struct CadetTunnel *t, |
160 | struct CadetPeerPath *p, | 161 | struct CadetPeerPath *p, |
161 | unsigned int off); | 162 | unsigned int off); |
162 | 163 | ||
163 | 164 | ||
164 | /** | 165 | /** |
@@ -169,8 +170,8 @@ GCT_consider_path(struct CadetTunnel *t, | |||
169 | * @return unique number identifying @a ch within @a t | 170 | * @return unique number identifying @a ch within @a t |
170 | */ | 171 | */ |
171 | struct GNUNET_CADET_ChannelTunnelNumber | 172 | struct GNUNET_CADET_ChannelTunnelNumber |
172 | GCT_add_channel(struct CadetTunnel *t, | 173 | GCT_add_channel (struct CadetTunnel *t, |
173 | struct CadetChannel *ch); | 174 | struct CadetChannel *ch); |
174 | 175 | ||
175 | 176 | ||
176 | /** | 177 | /** |
@@ -181,9 +182,9 @@ GCT_add_channel(struct CadetTunnel *t, | |||
181 | * @param ctn unique number identifying @a ch within @a t | 182 | * @param ctn unique number identifying @a ch within @a t |
182 | */ | 183 | */ |
183 | void | 184 | void |
184 | GCT_remove_channel(struct CadetTunnel *t, | 185 | GCT_remove_channel (struct CadetTunnel *t, |
185 | struct CadetChannel *ch, | 186 | struct CadetChannel *ch, |
186 | struct GNUNET_CADET_ChannelTunnelNumber ctn); | 187 | struct GNUNET_CADET_ChannelTunnelNumber ctn); |
187 | 188 | ||
188 | 189 | ||
189 | /** | 190 | /** |
@@ -193,8 +194,8 @@ GCT_remove_channel(struct CadetTunnel *t, | |||
193 | * @param ctn ID of the channel to destroy | 194 | * @param ctn ID of the channel to destroy |
194 | */ | 195 | */ |
195 | void | 196 | void |
196 | GCT_send_channel_destroy(struct CadetTunnel *t, | 197 | GCT_send_channel_destroy (struct CadetTunnel *t, |
197 | struct GNUNET_CADET_ChannelTunnelNumber ctn); | 198 | struct GNUNET_CADET_ChannelTunnelNumber ctn); |
198 | 199 | ||
199 | 200 | ||
200 | /** | 201 | /** |
@@ -207,7 +208,8 @@ GCT_send_channel_destroy(struct CadetTunnel *t, | |||
207 | */ | 208 | */ |
208 | typedef void | 209 | typedef void |
209 | (*GCT_SendContinuation)(void *cls, | 210 | (*GCT_SendContinuation)(void *cls, |
210 | const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid); | 211 | const struct |
212 | GNUNET_CADET_ConnectionTunnelIdentifier *cid); | ||
211 | 213 | ||
212 | 214 | ||
213 | /** | 215 | /** |
@@ -221,10 +223,10 @@ typedef void | |||
221 | * @return Handle to cancel message. | 223 | * @return Handle to cancel message. |
222 | */ | 224 | */ |
223 | struct CadetTunnelQueueEntry * | 225 | struct CadetTunnelQueueEntry * |
224 | GCT_send(struct CadetTunnel *t, | 226 | GCT_send (struct CadetTunnel *t, |
225 | const struct GNUNET_MessageHeader *message, | 227 | const struct GNUNET_MessageHeader *message, |
226 | GCT_SendContinuation cont, | 228 | GCT_SendContinuation cont, |
227 | void *cont_cls); | 229 | void *cont_cls); |
228 | 230 | ||
229 | 231 | ||
230 | /** | 232 | /** |
@@ -237,7 +239,7 @@ GCT_send(struct CadetTunnel *t, | |||
237 | * @param q Handle to the queue entry to cancel. | 239 | * @param q Handle to the queue entry to cancel. |
238 | */ | 240 | */ |
239 | void | 241 | void |
240 | GCT_send_cancel(struct CadetTunnelQueueEntry *q); | 242 | GCT_send_cancel (struct CadetTunnelQueueEntry *q); |
241 | 243 | ||
242 | 244 | ||
243 | /** | 245 | /** |
@@ -247,7 +249,7 @@ GCT_send_cancel(struct CadetTunnelQueueEntry *q); | |||
247 | * @return number of channels using the tunnel | 249 | * @return number of channels using the tunnel |
248 | */ | 250 | */ |
249 | unsigned int | 251 | unsigned int |
250 | GCT_count_channels(struct CadetTunnel *t); | 252 | GCT_count_channels (struct CadetTunnel *t); |
251 | 253 | ||
252 | 254 | ||
253 | /** | 255 | /** |
@@ -257,7 +259,7 @@ GCT_count_channels(struct CadetTunnel *t); | |||
257 | * @return number of connections available for the tunnel | 259 | * @return number of connections available for the tunnel |
258 | */ | 260 | */ |
259 | unsigned int | 261 | unsigned int |
260 | GCT_count_any_connections(const struct CadetTunnel *t); | 262 | GCT_count_any_connections (const struct CadetTunnel *t); |
261 | 263 | ||
262 | 264 | ||
263 | /** | 265 | /** |
@@ -279,9 +281,9 @@ typedef void | |||
279 | * @param iter_cls Closure for @c iter. | 281 | * @param iter_cls Closure for @c iter. |
280 | */ | 282 | */ |
281 | void | 283 | void |
282 | GCT_iterate_connections(struct CadetTunnel *t, | 284 | GCT_iterate_connections (struct CadetTunnel *t, |
283 | GCT_ConnectionIterator iter, | 285 | GCT_ConnectionIterator iter, |
284 | void *iter_cls); | 286 | void *iter_cls); |
285 | 287 | ||
286 | 288 | ||
287 | /** | 289 | /** |
@@ -303,9 +305,9 @@ typedef void | |||
303 | * @param iter_cls Closure for @c iter. | 305 | * @param iter_cls Closure for @c iter. |
304 | */ | 306 | */ |
305 | void | 307 | void |
306 | GCT_iterate_channels(struct CadetTunnel *t, | 308 | GCT_iterate_channels (struct CadetTunnel *t, |
307 | GCT_ChannelIterator iter, | 309 | GCT_ChannelIterator iter, |
308 | void *iter_cls); | 310 | void *iter_cls); |
309 | 311 | ||
310 | 312 | ||
311 | /** | 313 | /** |
@@ -316,7 +318,7 @@ GCT_iterate_channels(struct CadetTunnel *t, | |||
316 | * @return Tunnel's encryption state. | 318 | * @return Tunnel's encryption state. |
317 | */ | 319 | */ |
318 | enum CadetTunnelEState | 320 | enum CadetTunnelEState |
319 | GCT_get_estate(struct CadetTunnel *t); | 321 | GCT_get_estate (struct CadetTunnel *t); |
320 | 322 | ||
321 | 323 | ||
322 | /** | 324 | /** |
@@ -326,8 +328,8 @@ GCT_get_estate(struct CadetTunnel *t); | |||
326 | * @param msg the key exchange message | 328 | * @param msg the key exchange message |
327 | */ | 329 | */ |
328 | void | 330 | void |
329 | GCT_handle_kx(struct CadetTConnection *ct, | 331 | GCT_handle_kx (struct CadetTConnection *ct, |
330 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg); | 332 | const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg); |
331 | 333 | ||
332 | 334 | ||
333 | /** | 335 | /** |
@@ -337,8 +339,9 @@ GCT_handle_kx(struct CadetTConnection *ct, | |||
337 | * @param msg the key exchange message | 339 | * @param msg the key exchange message |
338 | */ | 340 | */ |
339 | void | 341 | void |
340 | GCT_handle_kx_auth(struct CadetTConnection *ct, | 342 | GCT_handle_kx_auth (struct CadetTConnection *ct, |
341 | const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg); | 343 | const struct |
344 | GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg); | ||
342 | 345 | ||
343 | 346 | ||
344 | /** | 347 | /** |
@@ -348,8 +351,8 @@ GCT_handle_kx_auth(struct CadetTConnection *ct, | |||
348 | * @param msg the encrypted message to decrypt | 351 | * @param msg the encrypted message to decrypt |
349 | */ | 352 | */ |
350 | void | 353 | void |
351 | GCT_handle_encrypted(struct CadetTConnection *ct, | 354 | GCT_handle_encrypted (struct CadetTConnection *ct, |
352 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg); | 355 | const struct GNUNET_CADET_TunnelEncryptedMessage *msg); |
353 | 356 | ||
354 | 357 | ||
355 | /** | 358 | /** |
@@ -359,8 +362,8 @@ GCT_handle_encrypted(struct CadetTConnection *ct, | |||
359 | * @param level Debug level to use. | 362 | * @param level Debug level to use. |
360 | */ | 363 | */ |
361 | void | 364 | void |
362 | GCT_debug(const struct CadetTunnel *t, | 365 | GCT_debug (const struct CadetTunnel *t, |
363 | enum GNUNET_ErrorType level); | 366 | enum GNUNET_ErrorType level); |
364 | 367 | ||
365 | 368 | ||
366 | #endif | 369 | #endif |
diff --git a/src/cadet/test_cadet.c b/src/cadet/test_cadet.c index de5e4eef0..354593c4b 100644 --- a/src/cadet/test_cadet.c +++ b/src/cadet/test_cadet.c | |||
@@ -34,7 +34,8 @@ | |||
34 | /** | 34 | /** |
35 | * Ugly workaround to unify data handlers on incoming and outgoing channels. | 35 | * Ugly workaround to unify data handlers on incoming and outgoing channels. |
36 | */ | 36 | */ |
37 | struct CadetTestChannelWrapper { | 37 | struct CadetTestChannelWrapper |
38 | { | ||
38 | /** | 39 | /** |
39 | * Channel pointer. | 40 | * Channel pointer. |
40 | */ | 41 | */ |
@@ -49,17 +50,18 @@ struct CadetTestChannelWrapper { | |||
49 | /** | 50 | /** |
50 | * How long until we give up on connecting the peers? | 51 | * How long until we give up on connecting the peers? |
51 | */ | 52 | */ |
52 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120) | 53 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) |
53 | 54 | ||
54 | /** | 55 | /** |
55 | * Time to wait by default for stuff that should be rather fast. | 56 | * Time to wait by default for stuff that should be rather fast. |
56 | */ | 57 | */ |
57 | #define SHORT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20) | 58 | #define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20) |
58 | 59 | ||
59 | /** | 60 | /** |
60 | * How fast do we send messages? | 61 | * How fast do we send messages? |
61 | */ | 62 | */ |
62 | #define SEND_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10) | 63 | #define SEND_INTERVAL GNUNET_TIME_relative_multiply ( \ |
64 | GNUNET_TIME_UNIT_MILLISECONDS, 10) | ||
63 | 65 | ||
64 | /** | 66 | /** |
65 | * DIFFERENT TESTS TO RUN | 67 | * DIFFERENT TESTS TO RUN |
@@ -259,9 +261,9 @@ static unsigned int msg_dropped; | |||
259 | * or the last peer in the line (for other tests). | 261 | * or the last peer in the line (for other tests). |
260 | */ | 262 | */ |
261 | static struct GNUNET_CADET_Channel * | 263 | static struct GNUNET_CADET_Channel * |
262 | get_target_channel() | 264 | get_target_channel () |
263 | { | 265 | { |
264 | if (SPEED == test && GNUNET_YES == test_backwards) | 266 | if ((SPEED == test)&&(GNUNET_YES == test_backwards)) |
265 | return outgoing_ch; | 267 | return outgoing_ch; |
266 | else | 268 | else |
267 | return incoming_ch; | 269 | return incoming_ch; |
@@ -272,29 +274,29 @@ get_target_channel() | |||
272 | * Show the results of the test (banwidth acheived) and log them to GAUGER | 274 | * Show the results of the test (banwidth acheived) and log them to GAUGER |
273 | */ | 275 | */ |
274 | static void | 276 | static void |
275 | show_end_data(void) | 277 | show_end_data (void) |
276 | { | 278 | { |
277 | static struct GNUNET_TIME_Absolute end_time; | 279 | static struct GNUNET_TIME_Absolute end_time; |
278 | static struct GNUNET_TIME_Relative total_time; | 280 | static struct GNUNET_TIME_Relative total_time; |
279 | 281 | ||
280 | end_time = GNUNET_TIME_absolute_get(); | 282 | end_time = GNUNET_TIME_absolute_get (); |
281 | total_time = GNUNET_TIME_absolute_get_difference(start_time, end_time); | 283 | total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time); |
282 | fprintf(stderr, | 284 | fprintf (stderr, |
283 | "\nResults of test \"%s\"\n", | 285 | "\nResults of test \"%s\"\n", |
284 | test_name); | 286 | test_name); |
285 | fprintf(stderr, | 287 | fprintf (stderr, |
286 | "Test time %s\n", | 288 | "Test time %s\n", |
287 | GNUNET_STRINGS_relative_time_to_string(total_time, GNUNET_YES)); | 289 | GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES)); |
288 | fprintf(stderr, | 290 | fprintf (stderr, |
289 | "Test bandwidth: %f kb/s\n", | 291 | "Test bandwidth: %f kb/s\n", |
290 | 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); // 4bytes * ms | 292 | 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); // 4bytes * ms |
291 | fprintf(stderr, | 293 | fprintf (stderr, |
292 | "Test throughput: %f packets/s\n\n", | 294 | "Test throughput: %f packets/s\n\n", |
293 | total_packets * 1000.0 / (total_time.rel_value_us / 1000)); // packets * ms | 295 | total_packets * 1000.0 / (total_time.rel_value_us / 1000)); // packets * ms |
294 | GAUGER("CADET", | 296 | GAUGER ("CADET", |
295 | test_name, | 297 | test_name, |
296 | total_packets * 1000.0 / (total_time.rel_value_us / 1000), | 298 | total_packets * 1000.0 / (total_time.rel_value_us / 1000), |
297 | "packets/s"); | 299 | "packets/s"); |
298 | } | 300 | } |
299 | 301 | ||
300 | 302 | ||
@@ -305,30 +307,30 @@ show_end_data(void) | |||
305 | * @param tc Task Context. | 307 | * @param tc Task Context. |
306 | */ | 308 | */ |
307 | static void | 309 | static void |
308 | disconnect_cadet_peers(void *cls) | 310 | disconnect_cadet_peers (void *cls) |
309 | { | 311 | { |
310 | long line = (long)cls; | 312 | long line = (long) cls; |
311 | 313 | ||
312 | disconnect_task = NULL; | 314 | disconnect_task = NULL; |
313 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 315 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
314 | "disconnecting cadet service of peers, called from line %ld\n", | 316 | "disconnecting cadet service of peers, called from line %ld\n", |
315 | line); | 317 | line); |
316 | for (unsigned int i = 0; i < 2; i++) | 318 | for (unsigned int i = 0; i < 2; i++) |
317 | { | 319 | { |
318 | GNUNET_TESTBED_operation_done(t_op[i]); | 320 | GNUNET_TESTBED_operation_done (t_op[i]); |
319 | } | 321 | } |
320 | if (NULL != outgoing_ch) | 322 | if (NULL != outgoing_ch) |
321 | { | 323 | { |
322 | GNUNET_CADET_channel_destroy(outgoing_ch); | 324 | GNUNET_CADET_channel_destroy (outgoing_ch); |
323 | outgoing_ch = NULL; | 325 | outgoing_ch = NULL; |
324 | } | 326 | } |
325 | if (NULL != incoming_ch) | 327 | if (NULL != incoming_ch) |
326 | { | 328 | { |
327 | GNUNET_CADET_channel_destroy(incoming_ch); | 329 | GNUNET_CADET_channel_destroy (incoming_ch); |
328 | incoming_ch = NULL; | 330 | incoming_ch = NULL; |
329 | } | 331 | } |
330 | GNUNET_CADET_TEST_cleanup(test_ctx); | 332 | GNUNET_CADET_TEST_cleanup (test_ctx); |
331 | GNUNET_SCHEDULER_shutdown(); | 333 | GNUNET_SCHEDULER_shutdown (); |
332 | } | 334 | } |
333 | 335 | ||
334 | 336 | ||
@@ -339,27 +341,27 @@ disconnect_cadet_peers(void *cls) | |||
339 | * @param tc Task Context. | 341 | * @param tc Task Context. |
340 | */ | 342 | */ |
341 | static void | 343 | static void |
342 | shutdown_task(void *cls) | 344 | shutdown_task (void *cls) |
343 | { | 345 | { |
344 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 346 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
345 | "Ending test.\n"); | 347 | "Ending test.\n"); |
346 | if (NULL != send_next_msg_task) | 348 | if (NULL != send_next_msg_task) |
347 | { | 349 | { |
348 | GNUNET_SCHEDULER_cancel(send_next_msg_task); | 350 | GNUNET_SCHEDULER_cancel (send_next_msg_task); |
349 | send_next_msg_task = NULL; | 351 | send_next_msg_task = NULL; |
350 | } | 352 | } |
351 | if (NULL != test_task) | 353 | if (NULL != test_task) |
352 | { | 354 | { |
353 | GNUNET_SCHEDULER_cancel(test_task); | 355 | GNUNET_SCHEDULER_cancel (test_task); |
354 | test_task = NULL; | 356 | test_task = NULL; |
355 | } | 357 | } |
356 | if (NULL != disconnect_task) | 358 | if (NULL != disconnect_task) |
357 | { | 359 | { |
358 | GNUNET_SCHEDULER_cancel(disconnect_task); | 360 | GNUNET_SCHEDULER_cancel (disconnect_task); |
359 | disconnect_task = | 361 | disconnect_task = |
360 | GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 362 | GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
361 | (void *)__LINE__); | 363 | (void *) __LINE__); |
362 | } | 364 | } |
363 | } | 365 | } |
364 | 366 | ||
365 | 367 | ||
@@ -373,26 +375,26 @@ shutdown_task(void *cls) | |||
373 | * operation has executed successfully. | 375 | * operation has executed successfully. |
374 | */ | 376 | */ |
375 | static void | 377 | static void |
376 | stats_cont(void *cls, | 378 | stats_cont (void *cls, |
377 | struct GNUNET_TESTBED_Operation *op, | 379 | struct GNUNET_TESTBED_Operation *op, |
378 | const char *emsg) | 380 | const char *emsg) |
379 | { | 381 | { |
380 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 382 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
381 | "KA sent: %u, KA received: %u\n", | 383 | "KA sent: %u, KA received: %u\n", |
382 | ka_sent, | 384 | ka_sent, |
383 | ka_received); | 385 | ka_received); |
384 | if ((KEEPALIVE == test || REOPEN == test) && | 386 | if (((KEEPALIVE == test)||(REOPEN == test)) && |
385 | ((ka_sent < 2) || (ka_sent > ka_received + 1))) | 387 | ((ka_sent < 2) || (ka_sent > ka_received + 1))) |
386 | { | 388 | { |
387 | GNUNET_break(0); | 389 | GNUNET_break (0); |
388 | ok--; | 390 | ok--; |
389 | } | 391 | } |
390 | GNUNET_TESTBED_operation_done(stats_op); | 392 | GNUNET_TESTBED_operation_done (stats_op); |
391 | 393 | ||
392 | if (NULL != disconnect_task) | 394 | if (NULL != disconnect_task) |
393 | GNUNET_SCHEDULER_cancel(disconnect_task); | 395 | GNUNET_SCHEDULER_cancel (disconnect_task); |
394 | disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 396 | disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
395 | cls); | 397 | cls); |
396 | } | 398 | } |
397 | 399 | ||
398 | 400 | ||
@@ -408,12 +410,12 @@ stats_cont(void *cls, | |||
408 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration | 410 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration |
409 | */ | 411 | */ |
410 | static int | 412 | static int |
411 | stats_iterator(void *cls, | 413 | stats_iterator (void *cls, |
412 | const struct GNUNET_TESTBED_Peer *peer, | 414 | const struct GNUNET_TESTBED_Peer *peer, |
413 | const char *subsystem, | 415 | const char *subsystem, |
414 | const char *name, | 416 | const char *name, |
415 | uint64_t value, | 417 | uint64_t value, |
416 | int is_persistent) | 418 | int is_persistent) |
417 | { | 419 | { |
418 | static const char *s_sent = "# keepalives sent"; | 420 | static const char *s_sent = "# keepalives sent"; |
419 | static const char *s_recv = "# keepalives received"; | 421 | static const char *s_recv = "# keepalives received"; |
@@ -421,16 +423,17 @@ stats_iterator(void *cls, | |||
421 | static const char *cdrops = "# messages dropped due to slow client"; | 423 | static const char *cdrops = "# messages dropped due to slow client"; |
422 | uint32_t i; | 424 | uint32_t i; |
423 | 425 | ||
424 | i = GNUNET_TESTBED_get_index(peer); | 426 | i = GNUNET_TESTBED_get_index (peer); |
425 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i, | 427 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i, |
426 | subsystem, name, (unsigned long long)value); | 428 | subsystem, name, (unsigned long long) value); |
427 | if (0 == strncmp(s_sent, name, strlen(s_sent)) && 0 == i) | 429 | if ((0 == strncmp (s_sent, name, strlen (s_sent)))&&(0 == i)) |
428 | ka_sent = value; | 430 | ka_sent = value; |
429 | if (0 == strncmp(s_recv, name, strlen(s_recv)) && peers_requested - 1 == i) | 431 | if ((0 == strncmp (s_recv, name, strlen (s_recv)))&&(peers_requested - 1 == |
432 | i) ) | ||
430 | ka_received = value; | 433 | ka_received = value; |
431 | if (0 == strncmp(rdrops, name, strlen(rdrops))) | 434 | if (0 == strncmp (rdrops, name, strlen (rdrops))) |
432 | msg_dropped += value; | 435 | msg_dropped += value; |
433 | if (0 == strncmp(cdrops, name, strlen(cdrops))) | 436 | if (0 == strncmp (cdrops, name, strlen (cdrops))) |
434 | msg_dropped += value; | 437 | msg_dropped += value; |
435 | 438 | ||
436 | return GNUNET_OK; | 439 | return GNUNET_OK; |
@@ -443,26 +446,26 @@ stats_iterator(void *cls, | |||
443 | * @param cls Closure (line from which the task was scheduled). | 446 | * @param cls Closure (line from which the task was scheduled). |
444 | */ | 447 | */ |
445 | static void | 448 | static void |
446 | gather_stats_and_exit(void *cls) | 449 | gather_stats_and_exit (void *cls) |
447 | { | 450 | { |
448 | long l = (long)cls; | 451 | long l = (long) cls; |
449 | 452 | ||
450 | disconnect_task = NULL; | 453 | disconnect_task = NULL; |
451 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 454 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
452 | "gathering statistics from line %ld\n", | 455 | "gathering statistics from line %ld\n", |
453 | l); | 456 | l); |
454 | if (NULL != outgoing_ch) | 457 | if (NULL != outgoing_ch) |
455 | { | 458 | { |
456 | GNUNET_CADET_channel_destroy(outgoing_ch); | 459 | GNUNET_CADET_channel_destroy (outgoing_ch); |
457 | outgoing_ch = NULL; | 460 | outgoing_ch = NULL; |
458 | } | 461 | } |
459 | stats_op = GNUNET_TESTBED_get_statistics(peers_running, | 462 | stats_op = GNUNET_TESTBED_get_statistics (peers_running, |
460 | testbed_peers, | 463 | testbed_peers, |
461 | "cadet", | 464 | "cadet", |
462 | NULL, | 465 | NULL, |
463 | &stats_iterator, | 466 | &stats_iterator, |
464 | stats_cont, | 467 | stats_cont, |
465 | cls); | 468 | cls); |
466 | } | 469 | } |
467 | 470 | ||
468 | 471 | ||
@@ -474,7 +477,7 @@ gather_stats_and_exit(void *cls) | |||
474 | * @param channel Channel to send the message on. | 477 | * @param channel Channel to send the message on. |
475 | */ | 478 | */ |
476 | static void | 479 | static void |
477 | send_test_message(struct GNUNET_CADET_Channel *channel); | 480 | send_test_message (struct GNUNET_CADET_Channel *channel); |
478 | 481 | ||
479 | /** | 482 | /** |
480 | * Check if payload is sane (size contains payload). | 483 | * Check if payload is sane (size contains payload). |
@@ -485,8 +488,8 @@ send_test_message(struct GNUNET_CADET_Channel *channel); | |||
485 | * #GNUNET_SYSERR to close it (signal serious error). | 488 | * #GNUNET_SYSERR to close it (signal serious error). |
486 | */ | 489 | */ |
487 | static int | 490 | static int |
488 | check_data(void *cls, | 491 | check_data (void *cls, |
489 | const struct GNUNET_MessageHeader *message); | 492 | const struct GNUNET_MessageHeader *message); |
490 | 493 | ||
491 | /** | 494 | /** |
492 | * Function is called whenever a message is received. | 495 | * Function is called whenever a message is received. |
@@ -495,8 +498,8 @@ check_data(void *cls, | |||
495 | * @param message the actual message | 498 | * @param message the actual message |
496 | */ | 499 | */ |
497 | static void | 500 | static void |
498 | handle_data(void *cls, | 501 | handle_data (void *cls, |
499 | const struct GNUNET_MessageHeader *message); | 502 | const struct GNUNET_MessageHeader *message); |
500 | 503 | ||
501 | /** | 504 | /** |
502 | * Function called whenever an MQ-channel is destroyed, unless the destruction | 505 | * Function called whenever an MQ-channel is destroyed, unless the destruction |
@@ -510,8 +513,8 @@ handle_data(void *cls, | |||
510 | * @param channel Connection to the other end (henceforth invalid). | 513 | * @param channel Connection to the other end (henceforth invalid). |
511 | */ | 514 | */ |
512 | static void | 515 | static void |
513 | disconnect_handler(void *cls, | 516 | disconnect_handler (void *cls, |
514 | const struct GNUNET_CADET_Channel *channel); | 517 | const struct GNUNET_CADET_Channel *channel); |
515 | 518 | ||
516 | 519 | ||
517 | /** | 520 | /** |
@@ -520,37 +523,37 @@ disconnect_handler(void *cls, | |||
520 | * @param cls Closure (line from which the task was scheduled). | 523 | * @param cls Closure (line from which the task was scheduled). |
521 | */ | 524 | */ |
522 | static void | 525 | static void |
523 | reconnect_op(void *cls) | 526 | reconnect_op (void *cls) |
524 | { | 527 | { |
525 | struct GNUNET_MQ_MessageHandler handlers[] = { | 528 | struct GNUNET_MQ_MessageHandler handlers[] = { |
526 | GNUNET_MQ_hd_var_size(data, | 529 | GNUNET_MQ_hd_var_size (data, |
527 | GNUNET_MESSAGE_TYPE_DUMMY, | 530 | GNUNET_MESSAGE_TYPE_DUMMY, |
528 | struct GNUNET_MessageHeader, | 531 | struct GNUNET_MessageHeader, |
529 | NULL), | 532 | NULL), |
530 | GNUNET_MQ_handler_end() | 533 | GNUNET_MQ_handler_end () |
531 | }; | 534 | }; |
532 | long l = (long)cls; | 535 | long l = (long) cls; |
533 | struct CadetTestChannelWrapper *ch; | 536 | struct CadetTestChannelWrapper *ch; |
534 | 537 | ||
535 | reconnect_task = NULL; | 538 | reconnect_task = NULL; |
536 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 539 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
537 | "reconnecting from line %ld\n", | 540 | "reconnecting from line %ld\n", |
538 | l); | 541 | l); |
539 | if (NULL != outgoing_ch) | 542 | if (NULL != outgoing_ch) |
540 | { | 543 | { |
541 | GNUNET_CADET_channel_destroy(outgoing_ch); | 544 | GNUNET_CADET_channel_destroy (outgoing_ch); |
542 | outgoing_ch = NULL; | 545 | outgoing_ch = NULL; |
543 | } | 546 | } |
544 | ch = GNUNET_new(struct CadetTestChannelWrapper); | 547 | ch = GNUNET_new (struct CadetTestChannelWrapper); |
545 | outgoing_ch = GNUNET_CADET_channel_create(h1, | 548 | outgoing_ch = GNUNET_CADET_channel_create (h1, |
546 | ch, | 549 | ch, |
547 | p_id[1], | 550 | p_id[1], |
548 | &port, | 551 | &port, |
549 | NULL, | 552 | NULL, |
550 | &disconnect_handler, | 553 | &disconnect_handler, |
551 | handlers); | 554 | handlers); |
552 | ch->ch = outgoing_ch; | 555 | ch->ch = outgoing_ch; |
553 | send_test_message(outgoing_ch); | 556 | send_test_message (outgoing_ch); |
554 | } | 557 | } |
555 | 558 | ||
556 | /** | 559 | /** |
@@ -565,47 +568,47 @@ reconnect_op(void *cls) | |||
565 | * @param channel Connection to the other end (henceforth invalid). | 568 | * @param channel Connection to the other end (henceforth invalid). |
566 | */ | 569 | */ |
567 | static void | 570 | static void |
568 | disconnect_handler(void *cls, | 571 | disconnect_handler (void *cls, |
569 | const struct GNUNET_CADET_Channel *channel) | 572 | const struct GNUNET_CADET_Channel *channel) |
570 | { | 573 | { |
571 | struct CadetTestChannelWrapper *ch_w = cls; | 574 | struct CadetTestChannelWrapper *ch_w = cls; |
572 | 575 | ||
573 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 576 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
574 | "Channel disconnected at %d\n", | 577 | "Channel disconnected at %d\n", |
575 | ok); | 578 | ok); |
576 | GNUNET_assert(ch_w->ch == channel); | 579 | GNUNET_assert (ch_w->ch == channel); |
577 | if (channel == incoming_ch) | 580 | if (channel == incoming_ch) |
578 | { | 581 | { |
579 | ok++; | 582 | ok++; |
580 | incoming_ch = NULL; | 583 | incoming_ch = NULL; |
581 | } | 584 | } |
582 | else if (outgoing_ch == channel) | 585 | else if (outgoing_ch == channel) |
586 | { | ||
587 | if (P2P_SIGNAL == test) | ||
583 | { | 588 | { |
584 | if (P2P_SIGNAL == test) | 589 | ok++; |
585 | { | ||
586 | ok++; | ||
587 | } | ||
588 | outgoing_ch = NULL; | ||
589 | } | 590 | } |
591 | outgoing_ch = NULL; | ||
592 | } | ||
590 | else | 593 | else |
591 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 594 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
592 | "Unknown channel! %p\n", | 595 | "Unknown channel! %p\n", |
593 | channel); | 596 | channel); |
594 | if (NULL != disconnect_task && REOPEN != test) | 597 | if ((NULL != disconnect_task)&&(REOPEN != test)) |
595 | { | 598 | { |
596 | GNUNET_SCHEDULER_cancel(disconnect_task); | 599 | GNUNET_SCHEDULER_cancel (disconnect_task); |
597 | disconnect_task = | 600 | disconnect_task = |
598 | GNUNET_SCHEDULER_add_now(&gather_stats_and_exit, | 601 | GNUNET_SCHEDULER_add_now (&gather_stats_and_exit, |
599 | (void *)__LINE__); | 602 | (void *) __LINE__); |
600 | } | 603 | } |
601 | else if (NULL != reconnect_task && REOPEN == test) | 604 | else if ((NULL != reconnect_task)&&(REOPEN == test)) |
602 | { | 605 | { |
603 | GNUNET_SCHEDULER_cancel(reconnect_task); | 606 | GNUNET_SCHEDULER_cancel (reconnect_task); |
604 | reconnect_task = | 607 | reconnect_task = |
605 | GNUNET_SCHEDULER_add_now(&reconnect_op, | 608 | GNUNET_SCHEDULER_add_now (&reconnect_op, |
606 | (void *)__LINE__); | 609 | (void *) __LINE__); |
607 | } | 610 | } |
608 | GNUNET_free(ch_w); | 611 | GNUNET_free (ch_w); |
609 | } | 612 | } |
610 | 613 | ||
611 | 614 | ||
@@ -615,18 +618,18 @@ disconnect_handler(void *cls, | |||
615 | * @param line Line in the code the abort is requested from (__LINE__). | 618 | * @param line Line in the code the abort is requested from (__LINE__). |
616 | */ | 619 | */ |
617 | static void | 620 | static void |
618 | abort_test(long line) | 621 | abort_test (long line) |
619 | { | 622 | { |
620 | if (NULL != disconnect_task) | 623 | if (NULL != disconnect_task) |
621 | { | 624 | { |
622 | GNUNET_SCHEDULER_cancel(disconnect_task); | 625 | GNUNET_SCHEDULER_cancel (disconnect_task); |
623 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 626 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
624 | "Aborting test from %ld\n", | 627 | "Aborting test from %ld\n", |
625 | line); | 628 | line); |
626 | disconnect_task = | 629 | disconnect_task = |
627 | GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 630 | GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
628 | (void *)line); | 631 | (void *) line); |
629 | } | 632 | } |
630 | } | 633 | } |
631 | 634 | ||
632 | 635 | ||
@@ -638,7 +641,7 @@ abort_test(long line) | |||
638 | * @param channel Channel to send the message on. | 641 | * @param channel Channel to send the message on. |
639 | */ | 642 | */ |
640 | static void | 643 | static void |
641 | send_test_message(struct GNUNET_CADET_Channel *channel) | 644 | send_test_message (struct GNUNET_CADET_Channel *channel) |
642 | { | 645 | { |
643 | struct GNUNET_MQ_Envelope *env; | 646 | struct GNUNET_MQ_Envelope *env; |
644 | struct GNUNET_MessageHeader *msg; | 647 | struct GNUNET_MessageHeader *msg; |
@@ -646,64 +649,64 @@ send_test_message(struct GNUNET_CADET_Channel *channel) | |||
646 | int payload; | 649 | int payload; |
647 | int size; | 650 | int size; |
648 | 651 | ||
649 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 652 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
650 | "Sending test message on channel %p\n", | 653 | "Sending test message on channel %p\n", |
651 | channel); | 654 | channel); |
652 | size = size_payload; | 655 | size = size_payload; |
653 | if (GNUNET_NO == initialized) | 656 | if (GNUNET_NO == initialized) |
654 | { | 657 | { |
655 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n"); | 658 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n"); |
656 | size += 1000; | 659 | size += 1000; |
657 | payload = data_sent; | 660 | payload = data_sent; |
658 | if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer | 661 | if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer |
659 | data_sent++; | 662 | data_sent++; |
660 | } | 663 | } |
661 | else if (SPEED == test || SPEED_ACK == test) | 664 | else if ((SPEED == test)||(SPEED_ACK == test)) |
662 | { | 665 | { |
663 | if (get_target_channel() == channel) | 666 | if (get_target_channel () == channel) |
664 | { | ||
665 | payload = ack_sent; | ||
666 | size += ack_sent; | ||
667 | ack_sent++; | ||
668 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
669 | "Sending ACK %u [%d bytes]\n", | ||
670 | payload, size); | ||
671 | } | ||
672 | else | ||
673 | { | ||
674 | payload = data_sent; | ||
675 | size += data_sent; | ||
676 | data_sent++; | ||
677 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
678 | "Sending DATA %u [%d bytes]\n", | ||
679 | data_sent, size); | ||
680 | } | ||
681 | } | ||
682 | else if (FORWARD == test) | ||
683 | { | 667 | { |
684 | payload = ack_sent; | 668 | payload = ack_sent; |
669 | size += ack_sent; | ||
670 | ack_sent++; | ||
671 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
672 | "Sending ACK %u [%d bytes]\n", | ||
673 | payload, size); | ||
685 | } | 674 | } |
686 | else if (P2P_SIGNAL == test) | 675 | else |
687 | { | ||
688 | payload = data_sent; | ||
689 | } | ||
690 | else if (REOPEN == test) | ||
691 | { | 676 | { |
692 | payload = data_sent; | 677 | payload = data_sent; |
678 | size += data_sent; | ||
693 | data_sent++; | 679 | data_sent++; |
694 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 680 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
695 | "Sending DATA %u [%d bytes]\n", | 681 | "Sending DATA %u [%d bytes]\n", |
696 | data_sent, size); | 682 | data_sent, size); |
697 | } | 683 | } |
684 | } | ||
685 | else if (FORWARD == test) | ||
686 | { | ||
687 | payload = ack_sent; | ||
688 | } | ||
689 | else if (P2P_SIGNAL == test) | ||
690 | { | ||
691 | payload = data_sent; | ||
692 | } | ||
693 | else if (REOPEN == test) | ||
694 | { | ||
695 | payload = data_sent; | ||
696 | data_sent++; | ||
697 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
698 | "Sending DATA %u [%d bytes]\n", | ||
699 | data_sent, size); | ||
700 | } | ||
698 | else | 701 | else |
699 | { | 702 | { |
700 | GNUNET_assert(0); | 703 | GNUNET_assert (0); |
701 | } | 704 | } |
702 | env = GNUNET_MQ_msg_extra(msg, size, GNUNET_MESSAGE_TYPE_DUMMY); | 705 | env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY); |
703 | 706 | ||
704 | data = (uint32_t *)&msg[1]; | 707 | data = (uint32_t *) &msg[1]; |
705 | *data = htonl(payload); | 708 | *data = htonl (payload); |
706 | GNUNET_MQ_send(GNUNET_CADET_get_mq(channel), env); | 709 | GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env); |
707 | } | 710 | } |
708 | 711 | ||
709 | 712 | ||
@@ -714,30 +717,30 @@ send_test_message(struct GNUNET_CADET_Channel *channel) | |||
714 | * @param cls Closure (unused). | 717 | * @param cls Closure (unused). |
715 | */ | 718 | */ |
716 | static void | 719 | static void |
717 | send_next_msg(void *cls) | 720 | send_next_msg (void *cls) |
718 | { | 721 | { |
719 | struct GNUNET_CADET_Channel *channel; | 722 | struct GNUNET_CADET_Channel *channel; |
720 | 723 | ||
721 | send_next_msg_task = NULL; | 724 | send_next_msg_task = NULL; |
722 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 725 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
723 | "Sending next message: %d\n", | 726 | "Sending next message: %d\n", |
724 | data_sent); | 727 | data_sent); |
725 | 728 | ||
726 | channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch; | 729 | channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch; |
727 | GNUNET_assert(NULL != channel); | 730 | GNUNET_assert (NULL != channel); |
728 | GNUNET_assert(SPEED == test); | 731 | GNUNET_assert (SPEED == test); |
729 | send_test_message(channel); | 732 | send_test_message (channel); |
730 | if (data_sent < total_packets) | 733 | if (data_sent < total_packets) |
731 | { | 734 | { |
732 | /* SPEED test: Send all messages as soon as possible */ | 735 | /* SPEED test: Send all messages as soon as possible */ |
733 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 736 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
734 | "Scheduling message %d\n", | 737 | "Scheduling message %d\n", |
735 | data_sent + 1); | 738 | data_sent + 1); |
736 | send_next_msg_task = | 739 | send_next_msg_task = |
737 | GNUNET_SCHEDULER_add_delayed(SEND_INTERVAL, | 740 | GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL, |
738 | &send_next_msg, | 741 | &send_next_msg, |
739 | NULL); | 742 | NULL); |
740 | } | 743 | } |
741 | } | 744 | } |
742 | 745 | ||
743 | 746 | ||
@@ -748,20 +751,20 @@ send_next_msg(void *cls) | |||
748 | * @param line Code line number to log if a timeout occurs. | 751 | * @param line Code line number to log if a timeout occurs. |
749 | */ | 752 | */ |
750 | static void | 753 | static void |
751 | reschedule_timeout_task(long line) | 754 | reschedule_timeout_task (long line) |
752 | { | 755 | { |
753 | if ((ok % 10) == 0) | 756 | if ((ok % 10) == 0) |
757 | { | ||
758 | if (NULL != disconnect_task) | ||
754 | { | 759 | { |
755 | if (NULL != disconnect_task) | 760 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
756 | { | 761 | "reschedule timeout every 10 messages\n"); |
757 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 762 | GNUNET_SCHEDULER_cancel (disconnect_task); |
758 | "reschedule timeout every 10 messages\n"); | 763 | disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time, |
759 | GNUNET_SCHEDULER_cancel(disconnect_task); | 764 | &gather_stats_and_exit, |
760 | disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time, | 765 | (void *) line); |
761 | &gather_stats_and_exit, | ||
762 | (void *)line); | ||
763 | } | ||
764 | } | 766 | } |
767 | } | ||
765 | } | 768 | } |
766 | 769 | ||
767 | 770 | ||
@@ -774,8 +777,8 @@ reschedule_timeout_task(long line) | |||
774 | * #GNUNET_SYSERR to close it (signal serious error). | 777 | * #GNUNET_SYSERR to close it (signal serious error). |
775 | */ | 778 | */ |
776 | static int | 779 | static int |
777 | check_data(void *cls, | 780 | check_data (void *cls, |
778 | const struct GNUNET_MessageHeader *message) | 781 | const struct GNUNET_MessageHeader *message) |
779 | { | 782 | { |
780 | return GNUNET_OK; /* all is well-formed */ | 783 | return GNUNET_OK; /* all is well-formed */ |
781 | } | 784 | } |
@@ -788,8 +791,8 @@ check_data(void *cls, | |||
788 | * @param message the actual message | 791 | * @param message the actual message |
789 | */ | 792 | */ |
790 | static void | 793 | static void |
791 | handle_data(void *cls, | 794 | handle_data (void *cls, |
792 | const struct GNUNET_MessageHeader *message) | 795 | const struct GNUNET_MessageHeader *message) |
793 | { | 796 | { |
794 | struct CadetTestChannelWrapper *ch = cls; | 797 | struct CadetTestChannelWrapper *ch = cls; |
795 | struct GNUNET_CADET_Channel *channel = ch->ch; | 798 | struct GNUNET_CADET_Channel *channel = ch->ch; |
@@ -798,101 +801,101 @@ handle_data(void *cls, | |||
798 | int *counter; | 801 | int *counter; |
799 | 802 | ||
800 | ok++; | 803 | ok++; |
801 | GNUNET_CADET_receive_done(channel); | 804 | GNUNET_CADET_receive_done (channel); |
802 | counter = get_target_channel() == channel ? &data_received : &ack_received; | 805 | counter = get_target_channel () == channel ? &data_received : &ack_received; |
803 | 806 | ||
804 | reschedule_timeout_task((long)__LINE__); | 807 | reschedule_timeout_task ((long) __LINE__); |
805 | 808 | ||
806 | if (channel == outgoing_ch) | 809 | if (channel == outgoing_ch) |
807 | { | 810 | { |
808 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 811 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
809 | "Root client got a message.\n"); | 812 | "Root client got a message.\n"); |
810 | } | 813 | } |
811 | else if (channel == incoming_ch) | 814 | else if (channel == incoming_ch) |
812 | { | 815 | { |
813 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 816 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
814 | "Leaf client got a message.\n"); | 817 | "Leaf client got a message.\n"); |
815 | } | 818 | } |
816 | else | 819 | else |
817 | { | 820 | { |
818 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 821 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
819 | "Unknown channel %p.\n", | 822 | "Unknown channel %p.\n", |
820 | channel); | 823 | channel); |
821 | GNUNET_assert(0); | 824 | GNUNET_assert (0); |
822 | } | 825 | } |
823 | 826 | ||
824 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 827 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
825 | " ok: (%d/%d)\n", | 828 | " ok: (%d/%d)\n", |
826 | ok, | 829 | ok, |
827 | ok_goal); | 830 | ok_goal); |
828 | data = (uint32_t *)&message[1]; | 831 | data = (uint32_t *) &message[1]; |
829 | payload = ntohl(*data); | 832 | payload = ntohl (*data); |
830 | if (payload == *counter) | 833 | if (payload == *counter) |
831 | { | 834 | { |
832 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 835 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
833 | " payload as expected: %u\n", | 836 | " payload as expected: %u\n", |
834 | payload); | 837 | payload); |
835 | } | 838 | } |
836 | else | 839 | else |
837 | { | 840 | { |
838 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 841 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
839 | " payload %u, expected: %u\n", | 842 | " payload %u, expected: %u\n", |
840 | payload, *counter); | 843 | payload, *counter); |
841 | } | 844 | } |
842 | 845 | ||
843 | if (GNUNET_NO == initialized) | 846 | if (GNUNET_NO == initialized) |
847 | { | ||
848 | initialized = GNUNET_YES; | ||
849 | start_time = GNUNET_TIME_absolute_get (); | ||
850 | if (SPEED == test) | ||
844 | { | 851 | { |
845 | initialized = GNUNET_YES; | 852 | GNUNET_assert (incoming_ch == channel); |
846 | start_time = GNUNET_TIME_absolute_get(); | 853 | send_next_msg_task = GNUNET_SCHEDULER_add_now (&send_next_msg, |
847 | if (SPEED == test) | 854 | NULL); |
848 | { | 855 | return; |
849 | GNUNET_assert(incoming_ch == channel); | ||
850 | send_next_msg_task = GNUNET_SCHEDULER_add_now(&send_next_msg, | ||
851 | NULL); | ||
852 | return; | ||
853 | } | ||
854 | } | 856 | } |
857 | } | ||
855 | 858 | ||
856 | (*counter)++; | 859 | (*counter)++; |
857 | if (get_target_channel() == channel) /* Got "data" */ | 860 | if (get_target_channel () == channel) /* Got "data" */ |
861 | { | ||
862 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received); | ||
863 | if ((SPEED != test) ||( (ok_goal - 2) == ok) ) | ||
858 | { | 864 | { |
859 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received); | 865 | /* Send ACK */ |
860 | if (SPEED != test || (ok_goal - 2) == ok) | 866 | send_test_message (channel); |
861 | { | 867 | return; |
862 | /* Send ACK */ | 868 | } |
863 | send_test_message(channel); | 869 | else |
864 | return; | 870 | { |
865 | } | 871 | if (data_received < total_packets) |
866 | else | 872 | return; |
867 | { | ||
868 | if (data_received < total_packets) | ||
869 | return; | ||
870 | } | ||
871 | } | 873 | } |
874 | } | ||
872 | else /* Got "ack" */ | 875 | else /* Got "ack" */ |
876 | { | ||
877 | if ((SPEED_ACK == test) ||(SPEED == test) ) | ||
878 | { | ||
879 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received); | ||
880 | /* Send more data */ | ||
881 | send_test_message (channel); | ||
882 | if ((ack_received < total_packets) &&(SPEED != test) ) | ||
883 | return; | ||
884 | if ((ok == 2) &&(SPEED == test) ) | ||
885 | return; | ||
886 | show_end_data (); | ||
887 | } | ||
888 | if (test == P2P_SIGNAL) | ||
889 | { | ||
890 | GNUNET_CADET_channel_destroy (incoming_ch); | ||
891 | incoming_ch = NULL; | ||
892 | } | ||
893 | else | ||
873 | { | 894 | { |
874 | if (SPEED_ACK == test || SPEED == test) | 895 | GNUNET_CADET_channel_destroy (outgoing_ch); |
875 | { | 896 | outgoing_ch = NULL; |
876 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received); | ||
877 | /* Send more data */ | ||
878 | send_test_message(channel); | ||
879 | if (ack_received < total_packets && SPEED != test) | ||
880 | return; | ||
881 | if (ok == 2 && SPEED == test) | ||
882 | return; | ||
883 | show_end_data(); | ||
884 | } | ||
885 | if (test == P2P_SIGNAL) | ||
886 | { | ||
887 | GNUNET_CADET_channel_destroy(incoming_ch); | ||
888 | incoming_ch = NULL; | ||
889 | } | ||
890 | else | ||
891 | { | ||
892 | GNUNET_CADET_channel_destroy(outgoing_ch); | ||
893 | outgoing_ch = NULL; | ||
894 | } | ||
895 | } | 897 | } |
898 | } | ||
896 | } | 899 | } |
897 | 900 | ||
898 | 901 | ||
@@ -909,66 +912,66 @@ handle_data(void *cls, | |||
909 | * received on the @a channel. | 912 | * received on the @a channel. |
910 | */ | 913 | */ |
911 | static void * | 914 | static void * |
912 | connect_handler(void *cls, | 915 | connect_handler (void *cls, |
913 | struct GNUNET_CADET_Channel *channel, | 916 | struct GNUNET_CADET_Channel *channel, |
914 | const struct GNUNET_PeerIdentity *source) | 917 | const struct GNUNET_PeerIdentity *source) |
915 | { | 918 | { |
916 | struct CadetTestChannelWrapper *ch; | 919 | struct CadetTestChannelWrapper *ch; |
917 | long peer = (long)cls; | 920 | long peer = (long) cls; |
918 | 921 | ||
919 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 922 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
920 | "Incoming channel from %s to %ld: %p\n", | 923 | "Incoming channel from %s to %ld: %p\n", |
921 | GNUNET_i2s(source), | 924 | GNUNET_i2s (source), |
922 | peer, | 925 | peer, |
923 | channel); | 926 | channel); |
924 | ok++; | 927 | ok++; |
925 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 928 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
926 | " ok: %d\n", | 929 | " ok: %d\n", |
927 | ok); | 930 | ok); |
928 | if (peer == peers_requested - 1) | 931 | if (peer == peers_requested - 1) |
932 | { | ||
933 | if (NULL != incoming_ch) | ||
929 | { | 934 | { |
930 | if (NULL != incoming_ch) | 935 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
931 | { | 936 | "Duplicate incoming channel for client %lu\n", |
932 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 937 | (long) cls); |
933 | "Duplicate incoming channel for client %lu\n", | 938 | GNUNET_assert (0); |
934 | (long)cls); | ||
935 | GNUNET_assert(0); | ||
936 | } | ||
937 | incoming_ch = channel; | ||
938 | } | 939 | } |
940 | incoming_ch = channel; | ||
941 | } | ||
939 | else | 942 | else |
940 | { | 943 | { |
941 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 944 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
942 | "Incoming channel for unexpected peer #%lu\n", | 945 | "Incoming channel for unexpected peer #%lu\n", |
943 | (long)cls); | 946 | (long) cls); |
944 | GNUNET_assert(0); | 947 | GNUNET_assert (0); |
945 | } | 948 | } |
946 | if (NULL != disconnect_task && REOPEN != test) | 949 | if ((NULL != disconnect_task)&&(REOPEN != test)) |
947 | { | 950 | { |
948 | GNUNET_SCHEDULER_cancel(disconnect_task); | 951 | GNUNET_SCHEDULER_cancel (disconnect_task); |
949 | disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time, | 952 | disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time, |
950 | &gather_stats_and_exit, | 953 | &gather_stats_and_exit, |
951 | (void *)__LINE__); | 954 | (void *) __LINE__); |
952 | } | 955 | } |
953 | else if ((NULL != disconnect_task) && (REOPEN == test)) | 956 | else if ((NULL != disconnect_task) && (REOPEN == test)) |
954 | { | 957 | { |
955 | GNUNET_SCHEDULER_cancel(disconnect_task); | 958 | GNUNET_SCHEDULER_cancel (disconnect_task); |
956 | disconnect_task = GNUNET_SCHEDULER_add_delayed( | 959 | disconnect_task = GNUNET_SCHEDULER_add_delayed ( |
957 | GNUNET_TIME_relative_multiply(short_time, 2), | 960 | GNUNET_TIME_relative_multiply (short_time, 2), |
958 | &gather_stats_and_exit, | 961 | &gather_stats_and_exit, |
959 | (void *)__LINE__); | 962 | (void *) __LINE__); |
960 | } | 963 | } |
961 | 964 | ||
962 | if ((NULL != reconnect_task) && (REOPEN == test)) | 965 | if ((NULL != reconnect_task) && (REOPEN == test)) |
963 | { | 966 | { |
964 | GNUNET_SCHEDULER_cancel(reconnect_task); | 967 | GNUNET_SCHEDULER_cancel (reconnect_task); |
965 | reconnect_task = GNUNET_SCHEDULER_add_delayed(short_time, | 968 | reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time, |
966 | &reconnect_op, | 969 | &reconnect_op, |
967 | (void *)__LINE__); | 970 | (void *) __LINE__); |
968 | } | 971 | } |
969 | 972 | ||
970 | /* TODO: cannot return channel as-is, in order to unify the data handlers */ | 973 | /* TODO: cannot return channel as-is, in order to unify the data handlers */ |
971 | ch = GNUNET_new(struct CadetTestChannelWrapper); | 974 | ch = GNUNET_new (struct CadetTestChannelWrapper); |
972 | ch->ch = channel; | 975 | ch->ch = channel; |
973 | 976 | ||
974 | return ch; | 977 | return ch; |
@@ -984,44 +987,44 @@ connect_handler(void *cls, | |||
984 | * @param cls Closure (unused). | 987 | * @param cls Closure (unused). |
985 | */ | 988 | */ |
986 | static void | 989 | static void |
987 | start_test(void *cls) | 990 | start_test (void *cls) |
988 | { | 991 | { |
989 | struct GNUNET_MQ_MessageHandler handlers[] = { | 992 | struct GNUNET_MQ_MessageHandler handlers[] = { |
990 | GNUNET_MQ_hd_var_size(data, | 993 | GNUNET_MQ_hd_var_size (data, |
991 | GNUNET_MESSAGE_TYPE_DUMMY, | 994 | GNUNET_MESSAGE_TYPE_DUMMY, |
992 | struct GNUNET_MessageHeader, | 995 | struct GNUNET_MessageHeader, |
993 | NULL), | 996 | NULL), |
994 | GNUNET_MQ_handler_end() | 997 | GNUNET_MQ_handler_end () |
995 | }; | 998 | }; |
996 | struct CadetTestChannelWrapper *ch; | 999 | struct CadetTestChannelWrapper *ch; |
997 | 1000 | ||
998 | test_task = NULL; | 1001 | test_task = NULL; |
999 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name); | 1002 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name); |
1000 | if (NULL != disconnect_task) | 1003 | if (NULL != disconnect_task) |
1001 | { | 1004 | { |
1002 | GNUNET_SCHEDULER_cancel(disconnect_task); | 1005 | GNUNET_SCHEDULER_cancel (disconnect_task); |
1003 | disconnect_task = NULL; | 1006 | disconnect_task = NULL; |
1004 | } | 1007 | } |
1005 | 1008 | ||
1006 | if (SPEED_REL == test) | 1009 | if (SPEED_REL == test) |
1007 | { | 1010 | { |
1008 | test = SPEED; | 1011 | test = SPEED; |
1009 | } | 1012 | } |
1010 | 1013 | ||
1011 | ch = GNUNET_new(struct CadetTestChannelWrapper); | 1014 | ch = GNUNET_new (struct CadetTestChannelWrapper); |
1012 | outgoing_ch = GNUNET_CADET_channel_create(h1, | 1015 | outgoing_ch = GNUNET_CADET_channel_create (h1, |
1013 | ch, | 1016 | ch, |
1014 | p_id[1], | 1017 | p_id[1], |
1015 | &port, | 1018 | &port, |
1016 | NULL, | 1019 | NULL, |
1017 | &disconnect_handler, | 1020 | &disconnect_handler, |
1018 | handlers); | 1021 | handlers); |
1019 | 1022 | ||
1020 | ch->ch = outgoing_ch; | 1023 | ch->ch = outgoing_ch; |
1021 | 1024 | ||
1022 | disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time, | 1025 | disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time, |
1023 | &gather_stats_and_exit, | 1026 | &gather_stats_and_exit, |
1024 | (void *)__LINE__); | 1027 | (void *) __LINE__); |
1025 | if (KEEPALIVE == test) | 1028 | if (KEEPALIVE == test) |
1026 | return; /* Don't send any data. */ | 1029 | return; /* Don't send any data. */ |
1027 | 1030 | ||
@@ -1029,21 +1032,21 @@ start_test(void *cls) | |||
1029 | data_sent = 0; | 1032 | data_sent = 0; |
1030 | ack_received = 0; | 1033 | ack_received = 0; |
1031 | ack_sent = 0; | 1034 | ack_sent = 0; |
1032 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1035 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1033 | "Sending data initializer on channel %p...\n", | 1036 | "Sending data initializer on channel %p...\n", |
1034 | outgoing_ch); | 1037 | outgoing_ch); |
1035 | send_test_message(outgoing_ch); | 1038 | send_test_message (outgoing_ch); |
1036 | if (REOPEN == test) | 1039 | if (REOPEN == test) |
1037 | { | 1040 | { |
1038 | reconnect_task = GNUNET_SCHEDULER_add_delayed(short_time, | 1041 | reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time, |
1039 | &reconnect_op, | 1042 | &reconnect_op, |
1040 | (void *)__LINE__); | 1043 | (void *) __LINE__); |
1041 | GNUNET_SCHEDULER_cancel(disconnect_task); | 1044 | GNUNET_SCHEDULER_cancel (disconnect_task); |
1042 | disconnect_task = GNUNET_SCHEDULER_add_delayed( | 1045 | disconnect_task = GNUNET_SCHEDULER_add_delayed ( |
1043 | GNUNET_TIME_relative_multiply(short_time, 2), | 1046 | GNUNET_TIME_relative_multiply (short_time, 2), |
1044 | &gather_stats_and_exit, | 1047 | &gather_stats_and_exit, |
1045 | (void *)__LINE__); | 1048 | (void *) __LINE__); |
1046 | } | 1049 | } |
1047 | } | 1050 | } |
1048 | 1051 | ||
1049 | 1052 | ||
@@ -1057,35 +1060,35 @@ start_test(void *cls) | |||
1057 | * NULL if the operation is successfull | 1060 | * NULL if the operation is successfull |
1058 | */ | 1061 | */ |
1059 | static void | 1062 | static void |
1060 | pi_cb(void *cls, | 1063 | pi_cb (void *cls, |
1061 | struct GNUNET_TESTBED_Operation *op, | 1064 | struct GNUNET_TESTBED_Operation *op, |
1062 | const struct GNUNET_TESTBED_PeerInformation *pinfo, | 1065 | const struct GNUNET_TESTBED_PeerInformation *pinfo, |
1063 | const char *emsg) | 1066 | const char *emsg) |
1064 | { | 1067 | { |
1065 | long i = (long)cls; | 1068 | long i = (long) cls; |
1066 | 1069 | ||
1067 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1070 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1068 | "ID callback for %ld\n", | 1071 | "ID callback for %ld\n", |
1069 | i); | 1072 | i); |
1070 | if ((NULL == pinfo) || | 1073 | if ((NULL == pinfo) || |
1071 | (NULL != emsg)) | 1074 | (NULL != emsg)) |
1072 | { | 1075 | { |
1073 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1076 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1074 | "pi_cb: %s\n", | 1077 | "pi_cb: %s\n", |
1075 | emsg); | 1078 | emsg); |
1076 | abort_test(__LINE__); | 1079 | abort_test (__LINE__); |
1077 | return; | 1080 | return; |
1078 | } | 1081 | } |
1079 | p_id[i] = pinfo->result.id; | 1082 | p_id[i] = pinfo->result.id; |
1080 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1083 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1081 | "id: %s\n", | 1084 | "id: %s\n", |
1082 | GNUNET_i2s(p_id[i])); | 1085 | GNUNET_i2s (p_id[i])); |
1083 | p_ids++; | 1086 | p_ids++; |
1084 | if (p_ids < 2) | 1087 | if (p_ids < 2) |
1085 | return; | 1088 | return; |
1086 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1089 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1087 | "Got all IDs, starting test\n"); | 1090 | "Got all IDs, starting test\n"); |
1088 | test_task = GNUNET_SCHEDULER_add_now(&start_test, NULL); | 1091 | test_task = GNUNET_SCHEDULER_add_now (&start_test, NULL); |
1089 | } | 1092 | } |
1090 | 1093 | ||
1091 | 1094 | ||
@@ -1099,34 +1102,34 @@ pi_cb(void *cls, | |||
1099 | * @param cadets Handle to each of the CADETs of the peers. | 1102 | * @param cadets Handle to each of the CADETs of the peers. |
1100 | */ | 1103 | */ |
1101 | static void | 1104 | static void |
1102 | tmain(void *cls, | 1105 | tmain (void *cls, |
1103 | struct GNUNET_CADET_TEST_Context *ctx, | 1106 | struct GNUNET_CADET_TEST_Context *ctx, |
1104 | unsigned int num_peers, | 1107 | unsigned int num_peers, |
1105 | struct GNUNET_TESTBED_Peer **peers, | 1108 | struct GNUNET_TESTBED_Peer **peers, |
1106 | struct GNUNET_CADET_Handle **cadets) | 1109 | struct GNUNET_CADET_Handle **cadets) |
1107 | { | 1110 | { |
1108 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "test main\n"); | 1111 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test main\n"); |
1109 | ok = 0; | 1112 | ok = 0; |
1110 | test_ctx = ctx; | 1113 | test_ctx = ctx; |
1111 | peers_running = num_peers; | 1114 | peers_running = num_peers; |
1112 | GNUNET_assert(peers_running == peers_requested); | 1115 | GNUNET_assert (peers_running == peers_requested); |
1113 | testbed_peers = peers; | 1116 | testbed_peers = peers; |
1114 | h1 = cadets[0]; | 1117 | h1 = cadets[0]; |
1115 | h2 = cadets[num_peers - 1]; | 1118 | h2 = cadets[num_peers - 1]; |
1116 | disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time, | 1119 | disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time, |
1117 | &disconnect_cadet_peers, | 1120 | &disconnect_cadet_peers, |
1118 | (void *)__LINE__); | 1121 | (void *) __LINE__); |
1119 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, | 1122 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, |
1120 | NULL); | 1123 | NULL); |
1121 | t_op[0] = GNUNET_TESTBED_peer_get_information(peers[0], | 1124 | t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0], |
1122 | GNUNET_TESTBED_PIT_IDENTITY, | 1125 | GNUNET_TESTBED_PIT_IDENTITY, |
1123 | &pi_cb, | 1126 | &pi_cb, |
1124 | (void *)0L); | 1127 | (void *) 0L); |
1125 | t_op[1] = GNUNET_TESTBED_peer_get_information(peers[num_peers - 1], | 1128 | t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1], |
1126 | GNUNET_TESTBED_PIT_IDENTITY, | 1129 | GNUNET_TESTBED_PIT_IDENTITY, |
1127 | &pi_cb, | 1130 | &pi_cb, |
1128 | (void *)1L); | 1131 | (void *) 1L); |
1129 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n"); | 1132 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n"); |
1130 | } | 1133 | } |
1131 | 1134 | ||
1132 | 1135 | ||
@@ -1134,179 +1137,179 @@ tmain(void *cls, | |||
1134 | * Main: start test | 1137 | * Main: start test |
1135 | */ | 1138 | */ |
1136 | int | 1139 | int |
1137 | main(int argc, char *argv[]) | 1140 | main (int argc, char *argv[]) |
1138 | { | 1141 | { |
1139 | static const struct GNUNET_HashCode *ports[2]; | 1142 | static const struct GNUNET_HashCode *ports[2]; |
1140 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1143 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1141 | GNUNET_MQ_hd_var_size(data, | 1144 | GNUNET_MQ_hd_var_size (data, |
1142 | GNUNET_MESSAGE_TYPE_DUMMY, | 1145 | GNUNET_MESSAGE_TYPE_DUMMY, |
1143 | struct GNUNET_MessageHeader, | 1146 | struct GNUNET_MessageHeader, |
1144 | NULL), | 1147 | NULL), |
1145 | GNUNET_MQ_handler_end() | 1148 | GNUNET_MQ_handler_end () |
1146 | }; | 1149 | }; |
1147 | const char *config_file; | 1150 | const char *config_file; |
1148 | char port_id[] = "test port"; | 1151 | char port_id[] = "test port"; |
1149 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 1152 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
1150 | GNUNET_GETOPT_option_relative_time('t', | 1153 | GNUNET_GETOPT_option_relative_time ('t', |
1151 | "time", | 1154 | "time", |
1152 | "short_time", | 1155 | "short_time", |
1153 | gettext_noop("set short timeout"), | 1156 | gettext_noop ("set short timeout"), |
1154 | &short_time), | 1157 | &short_time), |
1155 | GNUNET_GETOPT_option_uint('m', | 1158 | GNUNET_GETOPT_option_uint ('m', |
1156 | "messages", | 1159 | "messages", |
1157 | "NUM_MESSAGES", | 1160 | "NUM_MESSAGES", |
1158 | gettext_noop("set number of messages to send"), | 1161 | gettext_noop ("set number of messages to send"), |
1159 | &total_packets), | 1162 | &total_packets), |
1160 | 1163 | ||
1161 | GNUNET_GETOPT_OPTION_END | 1164 | GNUNET_GETOPT_OPTION_END |
1162 | }; | 1165 | }; |
1163 | 1166 | ||
1164 | 1167 | ||
1165 | initialized = GNUNET_NO; | 1168 | initialized = GNUNET_NO; |
1166 | GNUNET_log_setup("test", "DEBUG", NULL); | 1169 | GNUNET_log_setup ("test", "DEBUG", NULL); |
1167 | 1170 | ||
1168 | total_packets = TOTAL_PACKETS; | 1171 | total_packets = TOTAL_PACKETS; |
1169 | short_time = SHORT_TIME; | 1172 | short_time = SHORT_TIME; |
1170 | if (-1 == GNUNET_GETOPT_run(argv[0], options, argc, argv)) | 1173 | if (-1 == GNUNET_GETOPT_run (argv[0], options, argc, argv)) |
1171 | { | 1174 | { |
1172 | fprintf(stderr, "test failed: problem with CLI parameters\n"); | 1175 | fprintf (stderr, "test failed: problem with CLI parameters\n"); |
1173 | exit(1); | 1176 | exit (1); |
1174 | } | 1177 | } |
1175 | 1178 | ||
1176 | config_file = "test_cadet.conf"; | 1179 | config_file = "test_cadet.conf"; |
1177 | GNUNET_CRYPTO_hash(port_id, sizeof(port_id), &port); | 1180 | GNUNET_CRYPTO_hash (port_id, sizeof(port_id), &port); |
1178 | 1181 | ||
1179 | /* Find out requested size */ | 1182 | /* Find out requested size */ |
1180 | if (strstr(argv[0], "_2_") != NULL) | 1183 | if (strstr (argv[0], "_2_") != NULL) |
1181 | { | 1184 | { |
1182 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n"); | 1185 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n"); |
1183 | peers_requested = 2; | 1186 | peers_requested = 2; |
1184 | } | 1187 | } |
1185 | else if (strstr(argv[0], "_5_") != NULL) | 1188 | else if (strstr (argv[0], "_5_") != NULL) |
1186 | { | 1189 | { |
1187 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n"); | 1190 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n"); |
1188 | peers_requested = 5; | 1191 | peers_requested = 5; |
1189 | } | 1192 | } |
1190 | else if (strstr(argv[0], "_6_") != NULL) | 1193 | else if (strstr (argv[0], "_6_") != NULL) |
1191 | { | 1194 | { |
1192 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n"); | 1195 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n"); |
1193 | peers_requested = 6; | 1196 | peers_requested = 6; |
1194 | } | 1197 | } |
1195 | else | 1198 | else |
1196 | { | 1199 | { |
1197 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n"); | 1200 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n"); |
1198 | peers_requested = 2; | 1201 | peers_requested = 2; |
1199 | } | 1202 | } |
1200 | 1203 | ||
1201 | /* Find out requested test */ | 1204 | /* Find out requested test */ |
1202 | if (strstr(argv[0], "_forward") != NULL) | 1205 | if (strstr (argv[0], "_forward") != NULL) |
1206 | { | ||
1207 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n"); | ||
1208 | test = FORWARD; | ||
1209 | test_name = "unicast"; | ||
1210 | ok_goal = 4; | ||
1211 | } | ||
1212 | else if (strstr (argv[0], "_signal") != NULL) | ||
1213 | { | ||
1214 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n"); | ||
1215 | test = P2P_SIGNAL; | ||
1216 | test_name = "signal"; | ||
1217 | ok_goal = 4; | ||
1218 | } | ||
1219 | else if (strstr (argv[0], "_speed_ack") != NULL) | ||
1220 | { | ||
1221 | /* Test is supposed to generate the following callbacks: | ||
1222 | * 1 incoming channel (@dest) | ||
1223 | * total_packets received data packet (@dest) | ||
1224 | * total_packets received data packet (@orig) | ||
1225 | * 1 received channel destroy (@dest) FIXME #5818 | ||
1226 | */ | ||
1227 | ok_goal = total_packets * 2 + 2; | ||
1228 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n"); | ||
1229 | test = SPEED_ACK; | ||
1230 | test_name = "speed ack"; | ||
1231 | } | ||
1232 | else if (strstr (argv[0], "_speed") != NULL) | ||
1233 | { | ||
1234 | /* Test is supposed to generate the following callbacks: | ||
1235 | * 1 incoming channel (@dest) | ||
1236 | * 1 initial packet (@dest) | ||
1237 | * total_packets received data packet (@dest) | ||
1238 | * 1 received data packet (@orig) | ||
1239 | * 1 received channel destroy (@dest) FIXME #5818 | ||
1240 | */ | ||
1241 | ok_goal = total_packets + 4; | ||
1242 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED\n"); | ||
1243 | if (strstr (argv[0], "_reliable") != NULL) | ||
1203 | { | 1244 | { |
1204 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n"); | 1245 | test = SPEED_REL; |
1205 | test = FORWARD; | 1246 | test_name = "speed reliable"; |
1206 | test_name = "unicast"; | 1247 | config_file = "test_cadet_drop.conf"; |
1207 | ok_goal = 4; | ||
1208 | } | 1248 | } |
1209 | else if (strstr(argv[0], "_signal") != NULL) | 1249 | else |
1210 | { | 1250 | { |
1211 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n"); | 1251 | test = SPEED; |
1212 | test = P2P_SIGNAL; | 1252 | test_name = "speed"; |
1213 | test_name = "signal"; | ||
1214 | ok_goal = 4; | ||
1215 | } | ||
1216 | else if (strstr(argv[0], "_speed_ack") != NULL) | ||
1217 | { | ||
1218 | /* Test is supposed to generate the following callbacks: | ||
1219 | * 1 incoming channel (@dest) | ||
1220 | * total_packets received data packet (@dest) | ||
1221 | * total_packets received data packet (@orig) | ||
1222 | * 1 received channel destroy (@dest) FIXME #5818 | ||
1223 | */ | ||
1224 | ok_goal = total_packets * 2 + 2; | ||
1225 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n"); | ||
1226 | test = SPEED_ACK; | ||
1227 | test_name = "speed ack"; | ||
1228 | } | ||
1229 | else if (strstr(argv[0], "_speed") != NULL) | ||
1230 | { | ||
1231 | /* Test is supposed to generate the following callbacks: | ||
1232 | * 1 incoming channel (@dest) | ||
1233 | * 1 initial packet (@dest) | ||
1234 | * total_packets received data packet (@dest) | ||
1235 | * 1 received data packet (@orig) | ||
1236 | * 1 received channel destroy (@dest) FIXME #5818 | ||
1237 | */ | ||
1238 | ok_goal = total_packets + 4; | ||
1239 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SPEED\n"); | ||
1240 | if (strstr(argv[0], "_reliable") != NULL) | ||
1241 | { | ||
1242 | test = SPEED_REL; | ||
1243 | test_name = "speed reliable"; | ||
1244 | config_file = "test_cadet_drop.conf"; | ||
1245 | } | ||
1246 | else | ||
1247 | { | ||
1248 | test = SPEED; | ||
1249 | test_name = "speed"; | ||
1250 | } | ||
1251 | } | ||
1252 | else if (strstr(argv[0], "_keepalive") != NULL) | ||
1253 | { | ||
1254 | test = KEEPALIVE; | ||
1255 | test_name = "keepalive"; | ||
1256 | /* Test is supposed to generate the following callbacks: | ||
1257 | * 1 incoming channel (@dest) | ||
1258 | * [wait] | ||
1259 | * 1 received channel destroy (@dest) FIXME #5818 | ||
1260 | */ | ||
1261 | ok_goal = 1; | ||
1262 | } | ||
1263 | else if (strstr(argv[0], "_reopen") != NULL) | ||
1264 | { | ||
1265 | test = REOPEN; | ||
1266 | test_name = "reopen"; | ||
1267 | ///* Test is supposed to generate the following callbacks: | ||
1268 | // * 1 incoming channel (@dest) | ||
1269 | // * [wait] | ||
1270 | // * 1 received channel destroy (@dest) FIXME #5818 | ||
1271 | // */ | ||
1272 | ok_goal = 6; | ||
1273 | } | 1253 | } |
1254 | } | ||
1255 | else if (strstr (argv[0], "_keepalive") != NULL) | ||
1256 | { | ||
1257 | test = KEEPALIVE; | ||
1258 | test_name = "keepalive"; | ||
1259 | /* Test is supposed to generate the following callbacks: | ||
1260 | * 1 incoming channel (@dest) | ||
1261 | * [wait] | ||
1262 | * 1 received channel destroy (@dest) FIXME #5818 | ||
1263 | */ | ||
1264 | ok_goal = 1; | ||
1265 | } | ||
1266 | else if (strstr (argv[0], "_reopen") != NULL) | ||
1267 | { | ||
1268 | test = REOPEN; | ||
1269 | test_name = "reopen"; | ||
1270 | ///* Test is supposed to generate the following callbacks: | ||
1271 | // * 1 incoming channel (@dest) | ||
1272 | // * [wait] | ||
1273 | // * 1 received channel destroy (@dest) FIXME #5818 | ||
1274 | // */ | ||
1275 | ok_goal = 6; | ||
1276 | } | ||
1274 | else | 1277 | else |
1275 | { | 1278 | { |
1276 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n"); | 1279 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n"); |
1277 | test = SETUP; | 1280 | test = SETUP; |
1278 | ok_goal = 0; | 1281 | ok_goal = 0; |
1279 | } | 1282 | } |
1280 | 1283 | ||
1281 | if (strstr(argv[0], "backwards") != NULL) | 1284 | if (strstr (argv[0], "backwards") != NULL) |
1282 | { | 1285 | { |
1283 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n"); | 1286 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n"); |
1284 | test_backwards = GNUNET_YES; | 1287 | test_backwards = GNUNET_YES; |
1285 | GNUNET_asprintf(&test_name, "backwards %s", test_name); | 1288 | GNUNET_asprintf (&test_name, "backwards %s", test_name); |
1286 | } | 1289 | } |
1287 | 1290 | ||
1288 | p_ids = 0; | 1291 | p_ids = 0; |
1289 | ports[0] = &port; | 1292 | ports[0] = &port; |
1290 | ports[1] = NULL; | 1293 | ports[1] = NULL; |
1291 | GNUNET_CADET_TEST_ruN("test_cadet_small", | 1294 | GNUNET_CADET_TEST_ruN ("test_cadet_small", |
1292 | config_file, | 1295 | config_file, |
1293 | peers_requested, | 1296 | peers_requested, |
1294 | &tmain, | 1297 | &tmain, |
1295 | NULL, /* tmain cls */ | 1298 | NULL, /* tmain cls */ |
1296 | &connect_handler, | 1299 | &connect_handler, |
1297 | NULL, | 1300 | NULL, |
1298 | &disconnect_handler, | 1301 | &disconnect_handler, |
1299 | handlers, | 1302 | handlers, |
1300 | ports); | 1303 | ports); |
1301 | if (NULL != strstr(argv[0], "_reliable")) | 1304 | if (NULL != strstr (argv[0], "_reliable")) |
1302 | msg_dropped = 0; /* dropped should be retransmitted */ | 1305 | msg_dropped = 0; /* dropped should be retransmitted */ |
1303 | 1306 | ||
1304 | if (ok_goal > ok - msg_dropped) | 1307 | if (ok_goal > ok - msg_dropped) |
1305 | { | 1308 | { |
1306 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal); | 1309 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal); |
1307 | return 1; | 1310 | return 1; |
1308 | } | 1311 | } |
1309 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "success\n"); | 1312 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "success\n"); |
1310 | return 0; | 1313 | return 0; |
1311 | } | 1314 | } |
1312 | 1315 | ||
diff --git a/src/cadet/test_cadet_flow.c b/src/cadet/test_cadet_flow.c index 5278dc00f..94e1f1c85 100644 --- a/src/cadet/test_cadet_flow.c +++ b/src/cadet/test_cadet_flow.c | |||
@@ -34,7 +34,8 @@ | |||
34 | /** | 34 | /** |
35 | * Ugly workaround to unify data handlers on incoming and outgoing channels. | 35 | * Ugly workaround to unify data handlers on incoming and outgoing channels. |
36 | */ | 36 | */ |
37 | struct CadetTestChannelWrapper { | 37 | struct CadetTestChannelWrapper |
38 | { | ||
38 | /** | 39 | /** |
39 | * Channel pointer. | 40 | * Channel pointer. |
40 | */ | 41 | */ |
@@ -49,17 +50,18 @@ struct CadetTestChannelWrapper { | |||
49 | /** | 50 | /** |
50 | * How long until we give up on connecting the peers? | 51 | * How long until we give up on connecting the peers? |
51 | */ | 52 | */ |
52 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120) | 53 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) |
53 | 54 | ||
54 | /** | 55 | /** |
55 | * Time to wait by default for stuff that should be rather fast. | 56 | * Time to wait by default for stuff that should be rather fast. |
56 | */ | 57 | */ |
57 | #define SHORT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20) | 58 | #define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20) |
58 | 59 | ||
59 | /** | 60 | /** |
60 | * How fast do we send messages? | 61 | * How fast do we send messages? |
61 | */ | 62 | */ |
62 | #define SEND_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10) | 63 | #define SEND_INTERVAL GNUNET_TIME_relative_multiply ( \ |
64 | GNUNET_TIME_UNIT_MILLISECONDS, 10) | ||
63 | 65 | ||
64 | 66 | ||
65 | /** | 67 | /** |
@@ -208,29 +210,29 @@ static unsigned int msg_dropped; | |||
208 | * Show the results of the test (banwidth acheived) and log them to GAUGER | 210 | * Show the results of the test (banwidth acheived) and log them to GAUGER |
209 | */ | 211 | */ |
210 | static void | 212 | static void |
211 | show_end_data(void) | 213 | show_end_data (void) |
212 | { | 214 | { |
213 | static struct GNUNET_TIME_Absolute end_time; | 215 | static struct GNUNET_TIME_Absolute end_time; |
214 | static struct GNUNET_TIME_Relative total_time; | 216 | static struct GNUNET_TIME_Relative total_time; |
215 | 217 | ||
216 | end_time = GNUNET_TIME_absolute_get(); | 218 | end_time = GNUNET_TIME_absolute_get (); |
217 | total_time = GNUNET_TIME_absolute_get_difference(start_time, end_time); | 219 | total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time); |
218 | fprintf(stderr, | 220 | fprintf (stderr, |
219 | "\nResults of test \"%s\"\n", | 221 | "\nResults of test \"%s\"\n", |
220 | test_name); | 222 | test_name); |
221 | fprintf(stderr, | 223 | fprintf (stderr, |
222 | "Test time %s\n", | 224 | "Test time %s\n", |
223 | GNUNET_STRINGS_relative_time_to_string(total_time, GNUNET_YES)); | 225 | GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES)); |
224 | fprintf(stderr, | 226 | fprintf (stderr, |
225 | "Test bandwidth: %f kb/s\n", | 227 | "Test bandwidth: %f kb/s\n", |
226 | 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); // 4bytes * ms | 228 | 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); // 4bytes * ms |
227 | fprintf(stderr, | 229 | fprintf (stderr, |
228 | "Test throughput: %f packets/s\n\n", | 230 | "Test throughput: %f packets/s\n\n", |
229 | total_packets * 1000.0 / (total_time.rel_value_us / 1000)); // packets * ms | 231 | total_packets * 1000.0 / (total_time.rel_value_us / 1000)); // packets * ms |
230 | GAUGER("CADET", | 232 | GAUGER ("CADET", |
231 | test_name, | 233 | test_name, |
232 | total_packets * 1000.0 / (total_time.rel_value_us / 1000), | 234 | total_packets * 1000.0 / (total_time.rel_value_us / 1000), |
233 | "packets/s"); | 235 | "packets/s"); |
234 | } | 236 | } |
235 | 237 | ||
236 | 238 | ||
@@ -241,33 +243,33 @@ show_end_data(void) | |||
241 | * @param tc Task Context. | 243 | * @param tc Task Context. |
242 | */ | 244 | */ |
243 | static void | 245 | static void |
244 | shutdown_task(void *cls) | 246 | shutdown_task (void *cls) |
245 | { | 247 | { |
246 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 248 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
247 | "Ending test.\n"); | 249 | "Ending test.\n"); |
248 | if (NULL != send_next_msg_task) | 250 | if (NULL != send_next_msg_task) |
249 | { | 251 | { |
250 | GNUNET_SCHEDULER_cancel(send_next_msg_task); | 252 | GNUNET_SCHEDULER_cancel (send_next_msg_task); |
251 | send_next_msg_task = NULL; | 253 | send_next_msg_task = NULL; |
252 | } | 254 | } |
253 | if (NULL != test_task) | 255 | if (NULL != test_task) |
254 | { | 256 | { |
255 | GNUNET_SCHEDULER_cancel(test_task); | 257 | GNUNET_SCHEDULER_cancel (test_task); |
256 | test_task = NULL; | 258 | test_task = NULL; |
257 | } | 259 | } |
258 | for (unsigned int i = 0; i < 2; i++) | 260 | for (unsigned int i = 0; i < 2; i++) |
259 | GNUNET_TESTBED_operation_done(t_op[i]); | 261 | GNUNET_TESTBED_operation_done (t_op[i]); |
260 | if (NULL != outgoing_ch) | 262 | if (NULL != outgoing_ch) |
261 | { | 263 | { |
262 | GNUNET_CADET_channel_destroy(outgoing_ch); | 264 | GNUNET_CADET_channel_destroy (outgoing_ch); |
263 | outgoing_ch = NULL; | 265 | outgoing_ch = NULL; |
264 | } | 266 | } |
265 | if (NULL != incoming_ch) | 267 | if (NULL != incoming_ch) |
266 | { | 268 | { |
267 | GNUNET_CADET_channel_destroy(incoming_ch); | 269 | GNUNET_CADET_channel_destroy (incoming_ch); |
268 | incoming_ch = NULL; | 270 | incoming_ch = NULL; |
269 | } | 271 | } |
270 | GNUNET_CADET_TEST_cleanup(test_ctx); | 272 | GNUNET_CADET_TEST_cleanup (test_ctx); |
271 | } | 273 | } |
272 | 274 | ||
273 | 275 | ||
@@ -281,25 +283,25 @@ shutdown_task(void *cls) | |||
281 | * operation has executed successfully. | 283 | * operation has executed successfully. |
282 | */ | 284 | */ |
283 | static void | 285 | static void |
284 | stats_cont(void *cls, | 286 | stats_cont (void *cls, |
285 | struct GNUNET_TESTBED_Operation *op, | 287 | struct GNUNET_TESTBED_Operation *op, |
286 | const char *emsg) | 288 | const char *emsg) |
287 | { | 289 | { |
288 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 290 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
289 | "KA sent: %u, KA received: %u\n", | 291 | "KA sent: %u, KA received: %u\n", |
290 | ka_sent, | 292 | ka_sent, |
291 | ka_received); | 293 | ka_received); |
292 | if ((KEEPALIVE == test) && ((ka_sent < 2) || (ka_sent > ka_received + 1))) | 294 | if ((KEEPALIVE == test) && ((ka_sent < 2) || (ka_sent > ka_received + 1))) |
293 | { | 295 | { |
294 | GNUNET_break(0); | 296 | GNUNET_break (0); |
295 | ok--; | 297 | ok--; |
296 | } | 298 | } |
297 | GNUNET_TESTBED_operation_done(stats_op); | 299 | GNUNET_TESTBED_operation_done (stats_op); |
298 | 300 | ||
299 | if (NULL != disconnect_task) | 301 | if (NULL != disconnect_task) |
300 | GNUNET_SCHEDULER_cancel(disconnect_task); | 302 | GNUNET_SCHEDULER_cancel (disconnect_task); |
301 | disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 303 | disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
302 | cls); | 304 | cls); |
303 | } | 305 | } |
304 | 306 | ||
305 | 307 | ||
@@ -315,12 +317,12 @@ stats_cont(void *cls, | |||
315 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration | 317 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration |
316 | */ | 318 | */ |
317 | static int | 319 | static int |
318 | stats_iterator(void *cls, | 320 | stats_iterator (void *cls, |
319 | const struct GNUNET_TESTBED_Peer *peer, | 321 | const struct GNUNET_TESTBED_Peer *peer, |
320 | const char *subsystem, | 322 | const char *subsystem, |
321 | const char *name, | 323 | const char *name, |
322 | uint64_t value, | 324 | uint64_t value, |
323 | int is_persistent) | 325 | int is_persistent) |
324 | { | 326 | { |
325 | static const char *s_sent = "# keepalives sent"; | 327 | static const char *s_sent = "# keepalives sent"; |
326 | static const char *s_recv = "# keepalives received"; | 328 | static const char *s_recv = "# keepalives received"; |
@@ -328,16 +330,17 @@ stats_iterator(void *cls, | |||
328 | static const char *cdrops = "# messages dropped due to slow client"; | 330 | static const char *cdrops = "# messages dropped due to slow client"; |
329 | uint32_t i; | 331 | uint32_t i; |
330 | 332 | ||
331 | i = GNUNET_TESTBED_get_index(peer); | 333 | i = GNUNET_TESTBED_get_index (peer); |
332 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i, | 334 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i, |
333 | subsystem, name, (unsigned long long)value); | 335 | subsystem, name, (unsigned long long) value); |
334 | if (0 == strncmp(s_sent, name, strlen(s_sent)) && 0 == i) | 336 | if ((0 == strncmp (s_sent, name, strlen (s_sent)))&&(0 == i)) |
335 | ka_sent = value; | 337 | ka_sent = value; |
336 | if (0 == strncmp(s_recv, name, strlen(s_recv)) && peers_requested - 1 == i) | 338 | if ((0 == strncmp (s_recv, name, strlen (s_recv)))&&(peers_requested - 1 == |
339 | i) ) | ||
337 | ka_received = value; | 340 | ka_received = value; |
338 | if (0 == strncmp(rdrops, name, strlen(rdrops))) | 341 | if (0 == strncmp (rdrops, name, strlen (rdrops))) |
339 | msg_dropped += value; | 342 | msg_dropped += value; |
340 | if (0 == strncmp(cdrops, name, strlen(cdrops))) | 343 | if (0 == strncmp (cdrops, name, strlen (cdrops))) |
341 | msg_dropped += value; | 344 | msg_dropped += value; |
342 | 345 | ||
343 | return GNUNET_OK; | 346 | return GNUNET_OK; |
@@ -350,26 +353,26 @@ stats_iterator(void *cls, | |||
350 | * @param cls Closure (line from which the task was scheduled). | 353 | * @param cls Closure (line from which the task was scheduled). |
351 | */ | 354 | */ |
352 | static void | 355 | static void |
353 | gather_stats_and_exit(void *cls) | 356 | gather_stats_and_exit (void *cls) |
354 | { | 357 | { |
355 | long l = (long)cls; | 358 | long l = (long) cls; |
356 | 359 | ||
357 | disconnect_task = NULL; | 360 | disconnect_task = NULL; |
358 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 361 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
359 | "gathering statistics from line %ld\n", | 362 | "gathering statistics from line %ld\n", |
360 | l); | 363 | l); |
361 | if (NULL != outgoing_ch) | 364 | if (NULL != outgoing_ch) |
362 | { | 365 | { |
363 | GNUNET_CADET_channel_destroy(outgoing_ch); | 366 | GNUNET_CADET_channel_destroy (outgoing_ch); |
364 | outgoing_ch = NULL; | 367 | outgoing_ch = NULL; |
365 | } | 368 | } |
366 | stats_op = GNUNET_TESTBED_get_statistics(peers_running, | 369 | stats_op = GNUNET_TESTBED_get_statistics (peers_running, |
367 | testbed_peers, | 370 | testbed_peers, |
368 | "cadet", | 371 | "cadet", |
369 | NULL, | 372 | NULL, |
370 | &stats_iterator, | 373 | &stats_iterator, |
371 | stats_cont, | 374 | stats_cont, |
372 | cls); | 375 | cls); |
373 | } | 376 | } |
374 | 377 | ||
375 | 378 | ||
@@ -379,18 +382,18 @@ gather_stats_and_exit(void *cls) | |||
379 | * @param line Line in the code the abort is requested from (__LINE__). | 382 | * @param line Line in the code the abort is requested from (__LINE__). |
380 | */ | 383 | */ |
381 | static void | 384 | static void |
382 | abort_test(long line) | 385 | abort_test (long line) |
383 | { | 386 | { |
384 | if (NULL != disconnect_task) | 387 | if (NULL != disconnect_task) |
385 | { | 388 | { |
386 | GNUNET_SCHEDULER_cancel(disconnect_task); | 389 | GNUNET_SCHEDULER_cancel (disconnect_task); |
387 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 390 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
388 | "Aborting test from %ld\n", | 391 | "Aborting test from %ld\n", |
389 | line); | 392 | line); |
390 | disconnect_task = | 393 | disconnect_task = |
391 | GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers, | 394 | GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, |
392 | (void *)line); | 395 | (void *) line); |
393 | } | 396 | } |
394 | } | 397 | } |
395 | 398 | ||
396 | 399 | ||
@@ -402,7 +405,7 @@ abort_test(long line) | |||
402 | * @param channel Channel to send the message on. | 405 | * @param channel Channel to send the message on. |
403 | */ | 406 | */ |
404 | static void | 407 | static void |
405 | send_test_message(struct GNUNET_CADET_Channel *channel) | 408 | send_test_message (struct GNUNET_CADET_Channel *channel) |
406 | { | 409 | { |
407 | struct GNUNET_MQ_Envelope *env; | 410 | struct GNUNET_MQ_Envelope *env; |
408 | struct GNUNET_MessageHeader *msg; | 411 | struct GNUNET_MessageHeader *msg; |
@@ -410,56 +413,56 @@ send_test_message(struct GNUNET_CADET_Channel *channel) | |||
410 | int payload; | 413 | int payload; |
411 | int size; | 414 | int size; |
412 | 415 | ||
413 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 416 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
414 | "Sending test message on channel %p\n", | 417 | "Sending test message on channel %p\n", |
415 | channel); | 418 | channel); |
416 | size = size_payload; | 419 | size = size_payload; |
417 | if (GNUNET_NO == initialized) | 420 | if (GNUNET_NO == initialized) |
418 | { | 421 | { |
419 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n"); | 422 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n"); |
420 | size += 1000; | 423 | size += 1000; |
421 | payload = data_sent; | 424 | payload = data_sent; |
422 | if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer | 425 | if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer |
423 | data_sent++; | 426 | data_sent++; |
424 | } | 427 | } |
425 | else if (SPEED == test || SPEED_ACK == test) | 428 | else if ((SPEED == test)||(SPEED_ACK == test)) |
426 | { | 429 | { |
427 | if (get_target_channel() == channel) | 430 | if (get_target_channel () == channel) |
428 | { | ||
429 | payload = ack_sent; | ||
430 | size += ack_sent; | ||
431 | ack_sent++; | ||
432 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
433 | "Sending ACK %u [%d bytes]\n", | ||
434 | payload, size); | ||
435 | } | ||
436 | else | ||
437 | { | ||
438 | payload = data_sent; | ||
439 | size += data_sent; | ||
440 | data_sent++; | ||
441 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
442 | "Sending DATA %u [%d bytes]\n", | ||
443 | data_sent, size); | ||
444 | } | ||
445 | } | ||
446 | else if (FORWARD == test) | ||
447 | { | 431 | { |
448 | payload = ack_sent; | 432 | payload = ack_sent; |
433 | size += ack_sent; | ||
434 | ack_sent++; | ||
435 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
436 | "Sending ACK %u [%d bytes]\n", | ||
437 | payload, size); | ||
449 | } | 438 | } |
450 | else if (P2P_SIGNAL == test) | 439 | else |
451 | { | 440 | { |
452 | payload = data_sent; | 441 | payload = data_sent; |
442 | size += data_sent; | ||
443 | data_sent++; | ||
444 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
445 | "Sending DATA %u [%d bytes]\n", | ||
446 | data_sent, size); | ||
453 | } | 447 | } |
448 | } | ||
449 | else if (FORWARD == test) | ||
450 | { | ||
451 | payload = ack_sent; | ||
452 | } | ||
453 | else if (P2P_SIGNAL == test) | ||
454 | { | ||
455 | payload = data_sent; | ||
456 | } | ||
454 | else | 457 | else |
455 | { | 458 | { |
456 | GNUNET_assert(0); | 459 | GNUNET_assert (0); |
457 | } | 460 | } |
458 | env = GNUNET_MQ_msg_extra(msg, size, GNUNET_MESSAGE_TYPE_DUMMY); | 461 | env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY); |
459 | 462 | ||
460 | data = (uint32_t *)&msg[1]; | 463 | data = (uint32_t *) &msg[1]; |
461 | *data = htonl(payload); | 464 | *data = htonl (payload); |
462 | GNUNET_MQ_send(GNUNET_CADET_get_mq(channel), env); | 465 | GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env); |
463 | } | 466 | } |
464 | 467 | ||
465 | 468 | ||
@@ -470,30 +473,30 @@ send_test_message(struct GNUNET_CADET_Channel *channel) | |||
470 | * @param cls Closure (unused). | 473 | * @param cls Closure (unused). |
471 | */ | 474 | */ |
472 | static void | 475 | static void |
473 | send_next_msg(void *cls) | 476 | send_next_msg (void *cls) |
474 | { | 477 | { |
475 | struct GNUNET_CADET_Channel *channel; | 478 | struct GNUNET_CADET_Channel *channel; |
476 | 479 | ||
477 | send_next_msg_task = NULL; | 480 | send_next_msg_task = NULL; |
478 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 481 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
479 | "Sending next message: %d\n", | 482 | "Sending next message: %d\n", |
480 | data_sent); | 483 | data_sent); |
481 | 484 | ||
482 | channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch; | 485 | channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch; |
483 | GNUNET_assert(NULL != channel); | 486 | GNUNET_assert (NULL != channel); |
484 | GNUNET_assert(SPEED == test); | 487 | GNUNET_assert (SPEED == test); |
485 | send_test_message(channel); | 488 | send_test_message (channel); |
486 | if (data_sent < total_packets) | 489 | if (data_sent < total_packets) |
487 | { | 490 | { |
488 | /* SPEED test: Send all messages as soon as possible */ | 491 | /* SPEED test: Send all messages as soon as possible */ |
489 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 492 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
490 | "Scheduling message %d\n", | 493 | "Scheduling message %d\n", |
491 | data_sent + 1); | 494 | data_sent + 1); |
492 | send_next_msg_task = | 495 | send_next_msg_task = |
493 | GNUNET_SCHEDULER_add_delayed(SEND_INTERVAL, | 496 | GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL, |
494 | &send_next_msg, | 497 | &send_next_msg, |
495 | NULL); | 498 | NULL); |
496 | } | 499 | } |
497 | } | 500 | } |
498 | 501 | ||
499 | 502 | ||
@@ -506,8 +509,8 @@ send_next_msg(void *cls) | |||
506 | * #GNUNET_SYSERR to close it (signal serious error). | 509 | * #GNUNET_SYSERR to close it (signal serious error). |
507 | */ | 510 | */ |
508 | static int | 511 | static int |
509 | check_data(void *cls, | 512 | check_data (void *cls, |
510 | const struct GNUNET_MessageHeader *message) | 513 | const struct GNUNET_MessageHeader *message) |
511 | { | 514 | { |
512 | return GNUNET_OK; /* all is well-formed */ | 515 | return GNUNET_OK; /* all is well-formed */ |
513 | } | 516 | } |
@@ -520,8 +523,8 @@ check_data(void *cls, | |||
520 | * @param message the actual message | 523 | * @param message the actual message |
521 | */ | 524 | */ |
522 | static void | 525 | static void |
523 | handle_data(void *cls, | 526 | handle_data (void *cls, |
524 | const struct GNUNET_MessageHeader *message) | 527 | const struct GNUNET_MessageHeader *message) |
525 | { | 528 | { |
526 | struct CadetTestChannelWrapper *ch = cls; | 529 | struct CadetTestChannelWrapper *ch = cls; |
527 | struct GNUNET_CADET_Channel *channel = ch->ch; | 530 | struct GNUNET_CADET_Channel *channel = ch->ch; |
@@ -529,73 +532,73 @@ handle_data(void *cls, | |||
529 | uint32_t payload; | 532 | uint32_t payload; |
530 | int *counter; | 533 | int *counter; |
531 | 534 | ||
532 | GNUNET_CADET_receive_done(channel); | 535 | GNUNET_CADET_receive_done (channel); |
533 | counter = get_target_channel() == channel ? &data_received : &ack_received; | 536 | counter = get_target_channel () == channel ? &data_received : &ack_received; |
534 | if (channel == outgoing_ch) | 537 | if (channel == outgoing_ch) |
535 | { | 538 | { |
536 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 539 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
537 | "Root client got a message.\n"); | 540 | "Root client got a message.\n"); |
538 | } | 541 | } |
539 | else if (channel == incoming_ch) | 542 | else if (channel == incoming_ch) |
540 | { | 543 | { |
541 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 544 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
542 | "Leaf client got a message.\n"); | 545 | "Leaf client got a message.\n"); |
543 | } | 546 | } |
544 | else | 547 | else |
545 | { | 548 | { |
546 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 549 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
547 | "Unknown channel %p.\n", | 550 | "Unknown channel %p.\n", |
548 | channel); | 551 | channel); |
549 | GNUNET_assert(0); | 552 | GNUNET_assert (0); |
550 | } | 553 | } |
551 | 554 | ||
552 | data = (uint32_t *)&message[1]; | 555 | data = (uint32_t *) &message[1]; |
553 | payload = ntohl(*data); | 556 | payload = ntohl (*data); |
554 | if (payload == *counter) | 557 | if (payload == *counter) |
555 | { | 558 | { |
556 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 559 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
557 | "Payload as expected: %u\n", | 560 | "Payload as expected: %u\n", |
558 | payload); | 561 | payload); |
559 | } | 562 | } |
560 | else | 563 | else |
561 | { | 564 | { |
562 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 565 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
563 | "Received payload %u, expected: %u\n", | 566 | "Received payload %u, expected: %u\n", |
564 | payload, *counter); | 567 | payload, *counter); |
565 | } | 568 | } |
566 | (*counter)++; | 569 | (*counter)++; |
567 | if (get_target_channel() == channel) /* Got "data" */ | 570 | if (get_target_channel () == channel) /* Got "data" */ |
571 | { | ||
572 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
573 | " received data %u\n", | ||
574 | data_received); | ||
575 | if (data_received < total_packets) | ||
576 | return; | ||
577 | } | ||
578 | else /* Got "ack" */ | ||
579 | { | ||
580 | if ((SPEED_ACK == test) ||(SPEED == test) ) | ||
568 | { | 581 | { |
569 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 582 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received); |
570 | " received data %u\n", | 583 | /* Send more data */ |
571 | data_received); | 584 | send_test_message (channel); |
572 | if (data_received < total_packets) | 585 | if ((ack_received < total_packets) &&(SPEED != test) ) |
586 | return; | ||
587 | if ((ok == 2) &&(SPEED == test) ) | ||
573 | return; | 588 | return; |
589 | show_end_data (); | ||
574 | } | 590 | } |
575 | else /* Got "ack" */ | 591 | if (test == P2P_SIGNAL) |
592 | { | ||
593 | GNUNET_CADET_channel_destroy (incoming_ch); | ||
594 | incoming_ch = NULL; | ||
595 | } | ||
596 | else | ||
576 | { | 597 | { |
577 | if (SPEED_ACK == test || SPEED == test) | 598 | GNUNET_CADET_channel_destroy (outgoing_ch); |
578 | { | 599 | outgoing_ch = NULL; |
579 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received); | ||
580 | /* Send more data */ | ||
581 | send_test_message(channel); | ||
582 | if (ack_received < total_packets && SPEED != test) | ||
583 | return; | ||
584 | if (ok == 2 && SPEED == test) | ||
585 | return; | ||
586 | show_end_data(); | ||
587 | } | ||
588 | if (test == P2P_SIGNAL) | ||
589 | { | ||
590 | GNUNET_CADET_channel_destroy(incoming_ch); | ||
591 | incoming_ch = NULL; | ||
592 | } | ||
593 | else | ||
594 | { | ||
595 | GNUNET_CADET_channel_destroy(outgoing_ch); | ||
596 | outgoing_ch = NULL; | ||
597 | } | ||
598 | } | 600 | } |
601 | } | ||
599 | } | 602 | } |
600 | 603 | ||
601 | 604 | ||
@@ -612,37 +615,37 @@ handle_data(void *cls, | |||
612 | * received on the @a channel. | 615 | * received on the @a channel. |
613 | */ | 616 | */ |
614 | static void * | 617 | static void * |
615 | connect_handler(void *cls, | 618 | connect_handler (void *cls, |
616 | struct GNUNET_CADET_Channel *channel, | 619 | struct GNUNET_CADET_Channel *channel, |
617 | const struct GNUNET_PeerIdentity *source) | 620 | const struct GNUNET_PeerIdentity *source) |
618 | { | 621 | { |
619 | struct CadetTestChannelWrapper *ch; | 622 | struct CadetTestChannelWrapper *ch; |
620 | long peer = (long)cls; | 623 | long peer = (long) cls; |
621 | 624 | ||
622 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 625 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
623 | "Incoming channel from %s to %ld: %p\n", | 626 | "Incoming channel from %s to %ld: %p\n", |
624 | GNUNET_i2s(source), | 627 | GNUNET_i2s (source), |
625 | peer, | 628 | peer, |
626 | channel); | 629 | channel); |
627 | if (peer == peers_requested - 1) | 630 | if (peer == peers_requested - 1) |
631 | { | ||
632 | if (NULL != incoming_ch) | ||
628 | { | 633 | { |
629 | if (NULL != incoming_ch) | 634 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
630 | { | 635 | "Duplicate incoming channel for client %lu\n", |
631 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 636 | (long) cls); |
632 | "Duplicate incoming channel for client %lu\n", | 637 | GNUNET_assert (0); |
633 | (long)cls); | ||
634 | GNUNET_assert(0); | ||
635 | } | ||
636 | incoming_ch = channel; | ||
637 | } | 638 | } |
639 | incoming_ch = channel; | ||
640 | } | ||
638 | else | 641 | else |
639 | { | 642 | { |
640 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 643 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
641 | "Incoming channel for unexpected peer #%lu\n", | 644 | "Incoming channel for unexpected peer #%lu\n", |
642 | (long)cls); | 645 | (long) cls); |
643 | GNUNET_assert(0); | 646 | GNUNET_assert (0); |
644 | } | 647 | } |
645 | ch = GNUNET_new(struct CadetTestChannelWrapper); | 648 | ch = GNUNET_new (struct CadetTestChannelWrapper); |
646 | ch->ch = channel; | 649 | ch->ch = channel; |
647 | 650 | ||
648 | return ch; | 651 | return ch; |
@@ -661,28 +664,28 @@ connect_handler(void *cls, | |||
661 | * @param channel Connection to the other end (henceforth invalid). | 664 | * @param channel Connection to the other end (henceforth invalid). |
662 | */ | 665 | */ |
663 | static void | 666 | static void |
664 | disconnect_handler(void *cls, | 667 | disconnect_handler (void *cls, |
665 | const struct GNUNET_CADET_Channel *channel) | 668 | const struct GNUNET_CADET_Channel *channel) |
666 | { | 669 | { |
667 | struct CadetTestChannelWrapper *ch_w = cls; | 670 | struct CadetTestChannelWrapper *ch_w = cls; |
668 | 671 | ||
669 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 672 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
670 | "Channel disconnected at %d\n", | 673 | "Channel disconnected at %d\n", |
671 | ok); | 674 | ok); |
672 | GNUNET_assert(ch_w->ch == channel); | 675 | GNUNET_assert (ch_w->ch == channel); |
673 | if (channel == incoming_ch) | 676 | if (channel == incoming_ch) |
674 | incoming_ch = NULL; | 677 | incoming_ch = NULL; |
675 | else if (outgoing_ch == channel) | 678 | else if (outgoing_ch == channel) |
676 | outgoing_ch = NULL; | 679 | outgoing_ch = NULL; |
677 | else | 680 | else |
678 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 681 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
679 | "Disconnect on unknown channel %p\n", | 682 | "Disconnect on unknown channel %p\n", |
680 | channel); | 683 | channel); |
681 | if (NULL != disconnect_task) | 684 | if (NULL != disconnect_task) |
682 | GNUNET_SCHEDULER_cancel(disconnect_task); | 685 | GNUNET_SCHEDULER_cancel (disconnect_task); |
683 | disconnect_task = GNUNET_SCHEDULER_add_now(&gather_stats_and_exit, | 686 | disconnect_task = GNUNET_SCHEDULER_add_now (&gather_stats_and_exit, |
684 | (void *)__LINE__); | 687 | (void *) __LINE__); |
685 | GNUNET_free(ch_w); | 688 | GNUNET_free (ch_w); |
686 | } | 689 | } |
687 | 690 | ||
688 | 691 | ||
@@ -695,41 +698,41 @@ disconnect_handler(void *cls, | |||
695 | * @param cls Closure (unused). | 698 | * @param cls Closure (unused). |
696 | */ | 699 | */ |
697 | static void | 700 | static void |
698 | start_test(void *cls) | 701 | start_test (void *cls) |
699 | { | 702 | { |
700 | struct GNUNET_MQ_MessageHandler handlers[] = { | 703 | struct GNUNET_MQ_MessageHandler handlers[] = { |
701 | GNUNET_MQ_hd_var_size(data, | 704 | GNUNET_MQ_hd_var_size (data, |
702 | GNUNET_MESSAGE_TYPE_DUMMY, | 705 | GNUNET_MESSAGE_TYPE_DUMMY, |
703 | struct GNUNET_MessageHeader, | 706 | struct GNUNET_MessageHeader, |
704 | NULL), | 707 | NULL), |
705 | GNUNET_MQ_handler_end() | 708 | GNUNET_MQ_handler_end () |
706 | }; | 709 | }; |
707 | struct CadetTestChannelWrapper *ch; | 710 | struct CadetTestChannelWrapper *ch; |
708 | enum GNUNET_CADET_ChannelOption flags; | 711 | enum GNUNET_CADET_ChannelOption flags; |
709 | 712 | ||
710 | test_task = NULL; | 713 | test_task = NULL; |
711 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 714 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
712 | "In start_test\n"); | 715 | "In start_test\n"); |
713 | start_time = GNUNET_TIME_absolute_get(); | 716 | start_time = GNUNET_TIME_absolute_get (); |
714 | ch = GNUNET_new(struct CadetTestChannelWrapper); | 717 | ch = GNUNET_new (struct CadetTestChannelWrapper); |
715 | outgoing_ch = GNUNET_CADET_channel_create(h1, | 718 | outgoing_ch = GNUNET_CADET_channel_create (h1, |
716 | ch, | 719 | ch, |
717 | p_id[1], | 720 | p_id[1], |
718 | &port, | 721 | &port, |
719 | flags, | 722 | flags, |
720 | NULL, | 723 | NULL, |
721 | &disconnect_handler, | 724 | &disconnect_handler, |
722 | handlers); | 725 | handlers); |
723 | ch->ch = outgoing_ch; | 726 | ch->ch = outgoing_ch; |
724 | GNUNET_assert(NULL == disconnect_task); | 727 | GNUNET_assert (NULL == disconnect_task); |
725 | disconnect_task | 728 | disconnect_task |
726 | = GNUNET_SCHEDULER_add_delayed(short_time, | 729 | = GNUNET_SCHEDULER_add_delayed (short_time, |
727 | &gather_stats_and_exit, | 730 | &gather_stats_and_exit, |
728 | (void *)__LINE__); | 731 | (void *) __LINE__); |
729 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 732 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
730 | "Sending data initializer on channel %p...\n", | 733 | "Sending data initializer on channel %p...\n", |
731 | outgoing_ch); | 734 | outgoing_ch); |
732 | send_test_message(outgoing_ch); | 735 | send_test_message (outgoing_ch); |
733 | } | 736 | } |
734 | 737 | ||
735 | 738 | ||
@@ -743,36 +746,36 @@ start_test(void *cls) | |||
743 | * NULL if the operation is successfull | 746 | * NULL if the operation is successfull |
744 | */ | 747 | */ |
745 | static void | 748 | static void |
746 | pi_cb(void *cls, | 749 | pi_cb (void *cls, |
747 | struct GNUNET_TESTBED_Operation *op, | 750 | struct GNUNET_TESTBED_Operation *op, |
748 | const struct GNUNET_TESTBED_PeerInformation *pinfo, | 751 | const struct GNUNET_TESTBED_PeerInformation *pinfo, |
749 | const char *emsg) | 752 | const char *emsg) |
750 | { | 753 | { |
751 | long i = (long)cls; | 754 | long i = (long) cls; |
752 | 755 | ||
753 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 756 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
754 | "ID callback for %ld\n", | 757 | "ID callback for %ld\n", |
755 | i); | 758 | i); |
756 | if ((NULL == pinfo) || | 759 | if ((NULL == pinfo) || |
757 | (NULL != emsg)) | 760 | (NULL != emsg)) |
758 | { | 761 | { |
759 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 762 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
760 | "pi_cb: %s\n", | 763 | "pi_cb: %s\n", |
761 | emsg); | 764 | emsg); |
762 | abort_test(__LINE__); | 765 | abort_test (__LINE__); |
763 | return; | 766 | return; |
764 | } | 767 | } |
765 | p_id[i] = pinfo->result.id; | 768 | p_id[i] = pinfo->result.id; |
766 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 769 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
767 | "id: %s\n", | 770 | "id: %s\n", |
768 | GNUNET_i2s(p_id[i])); | 771 | GNUNET_i2s (p_id[i])); |
769 | p_ids++; | 772 | p_ids++; |
770 | if (p_ids < 2) | 773 | if (p_ids < 2) |
771 | return; | 774 | return; |
772 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 775 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
773 | "Got all IDs, starting test\n"); | 776 | "Got all IDs, starting test\n"); |
774 | test_task = GNUNET_SCHEDULER_add_now(&start_test, | 777 | test_task = GNUNET_SCHEDULER_add_now (&start_test, |
775 | NULL); | 778 | NULL); |
776 | } | 779 | } |
777 | 780 | ||
778 | 781 | ||
@@ -786,33 +789,33 @@ pi_cb(void *cls, | |||
786 | * @param cadets Handle to each of the CADETs of the peers. | 789 | * @param cadets Handle to each of the CADETs of the peers. |
787 | */ | 790 | */ |
788 | static void | 791 | static void |
789 | tmain(void *cls, | 792 | tmain (void *cls, |
790 | struct GNUNET_CADET_TEST_Context *ctx, | 793 | struct GNUNET_CADET_TEST_Context *ctx, |
791 | unsigned int num_peers, | 794 | unsigned int num_peers, |
792 | struct GNUNET_TESTBED_Peer **peers, | 795 | struct GNUNET_TESTBED_Peer **peers, |
793 | struct GNUNET_CADET_Handle **cadets) | 796 | struct GNUNET_CADET_Handle **cadets) |
794 | { | 797 | { |
795 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 798 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
796 | "test main\n"); | 799 | "test main\n"); |
797 | test_ctx = ctx; | 800 | test_ctx = ctx; |
798 | peers_running = num_peers; | 801 | peers_running = num_peers; |
799 | GNUNET_assert(peers_running == peers_requested); | 802 | GNUNET_assert (peers_running == peers_requested); |
800 | testbed_peers = peers; | 803 | testbed_peers = peers; |
801 | h1 = cadets[0]; | 804 | h1 = cadets[0]; |
802 | h2 = cadets[num_peers - 1]; | 805 | h2 = cadets[num_peers - 1]; |
803 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, | 806 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, |
804 | NULL); | 807 | NULL); |
805 | p_ids = 0; | 808 | p_ids = 0; |
806 | t_op[0] = GNUNET_TESTBED_peer_get_information(peers[0], | 809 | t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0], |
807 | GNUNET_TESTBED_PIT_IDENTITY, | 810 | GNUNET_TESTBED_PIT_IDENTITY, |
808 | &pi_cb, | 811 | &pi_cb, |
809 | (void *)0L); | 812 | (void *) 0L); |
810 | t_op[1] = GNUNET_TESTBED_peer_get_information(peers[num_peers - 1], | 813 | t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1], |
811 | GNUNET_TESTBED_PIT_IDENTITY, | 814 | GNUNET_TESTBED_PIT_IDENTITY, |
812 | &pi_cb, | 815 | &pi_cb, |
813 | (void *)1L); | 816 | (void *) 1L); |
814 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 817 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
815 | "requested peer ids\n"); | 818 | "requested peer ids\n"); |
816 | } | 819 | } |
817 | 820 | ||
818 | 821 | ||
@@ -820,67 +823,67 @@ tmain(void *cls, | |||
820 | * Main: start test | 823 | * Main: start test |
821 | */ | 824 | */ |
822 | int | 825 | int |
823 | main(int argc, | 826 | main (int argc, |
824 | char *argv[]) | 827 | char *argv[]) |
825 | { | 828 | { |
826 | static const struct GNUNET_HashCode *ports[2]; | 829 | static const struct GNUNET_HashCode *ports[2]; |
827 | struct GNUNET_MQ_MessageHandler handlers[] = { | 830 | struct GNUNET_MQ_MessageHandler handlers[] = { |
828 | GNUNET_MQ_hd_var_size(data, | 831 | GNUNET_MQ_hd_var_size (data, |
829 | GNUNET_MESSAGE_TYPE_DUMMY, | 832 | GNUNET_MESSAGE_TYPE_DUMMY, |
830 | struct GNUNET_MessageHeader, | 833 | struct GNUNET_MessageHeader, |
831 | NULL), | 834 | NULL), |
832 | GNUNET_MQ_handler_end() | 835 | GNUNET_MQ_handler_end () |
833 | }; | 836 | }; |
834 | const char *config_file = "test_cadet.conf"; | 837 | const char *config_file = "test_cadet.conf"; |
835 | char port_id[] = "test port"; | 838 | char port_id[] = "test port"; |
836 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 839 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
837 | GNUNET_GETOPT_option_relative_time('t', | 840 | GNUNET_GETOPT_option_relative_time ('t', |
838 | "time", | 841 | "time", |
839 | "short_time", | 842 | "short_time", |
840 | gettext_noop("set short timeout"), | 843 | gettext_noop ("set short timeout"), |
841 | &short_time), | 844 | &short_time), |
842 | GNUNET_GETOPT_option_uint('m', | 845 | GNUNET_GETOPT_option_uint ('m', |
843 | "messages", | 846 | "messages", |
844 | "NUM_MESSAGES", | 847 | "NUM_MESSAGES", |
845 | gettext_noop("set number of messages to send"), | 848 | gettext_noop ("set number of messages to send"), |
846 | &total_packets), | 849 | &total_packets), |
847 | GNUNET_GETOPT_option_uint('p', | 850 | GNUNET_GETOPT_option_uint ('p', |
848 | "peers", | 851 | "peers", |
849 | "NUM_PEERS", | 852 | "NUM_PEERS", |
850 | gettext_noop("number of peers to launch"), | 853 | gettext_noop ("number of peers to launch"), |
851 | &peers_requested), | 854 | &peers_requested), |
852 | GNUNET_GETOPT_OPTION_END | 855 | GNUNET_GETOPT_OPTION_END |
853 | }; | 856 | }; |
854 | 857 | ||
855 | GNUNET_log_setup("test-cadet-flow", | 858 | GNUNET_log_setup ("test-cadet-flow", |
856 | "DEBUG", | 859 | "DEBUG", |
857 | NULL); | 860 | NULL); |
858 | total_packets = TOTAL_PACKETS; | 861 | total_packets = TOTAL_PACKETS; |
859 | short_time = SHORT_TIME; | 862 | short_time = SHORT_TIME; |
860 | if (-1 == GNUNET_GETOPT_run(argv[0], | 863 | if (-1 == GNUNET_GETOPT_run (argv[0], |
861 | options, | 864 | options, |
862 | argc, | 865 | argc, |
863 | argv)) | 866 | argv)) |
864 | { | 867 | { |
865 | fprintf(stderr, | 868 | fprintf (stderr, |
866 | "test failed: problem with CLI parameters\n"); | 869 | "test failed: problem with CLI parameters\n"); |
867 | return 1; | 870 | return 1; |
868 | } | 871 | } |
869 | GNUNET_CRYPTO_hash(port_id, | 872 | GNUNET_CRYPTO_hash (port_id, |
870 | sizeof(port_id), | 873 | sizeof(port_id), |
871 | &port); | 874 | &port); |
872 | ports[0] = &port; | 875 | ports[0] = &port; |
873 | ports[1] = NULL; | 876 | ports[1] = NULL; |
874 | GNUNET_CADET_TEST_ruN("test_cadet_flow", | 877 | GNUNET_CADET_TEST_ruN ("test_cadet_flow", |
875 | config_file, | 878 | config_file, |
876 | peers_requested, | 879 | peers_requested, |
877 | &tmain, | 880 | &tmain, |
878 | NULL, /* tmain cls */ | 881 | NULL, /* tmain cls */ |
879 | &connect_handler, | 882 | &connect_handler, |
880 | NULL, | 883 | NULL, |
881 | &disconnect_handler, | 884 | &disconnect_handler, |
882 | handlers, | 885 | handlers, |
883 | ports); | 886 | ports); |
884 | return 0; | 887 | return 0; |
885 | } | 888 | } |
886 | 889 | ||
diff --git a/src/cadet/test_cadet_local_mq.c b/src/cadet/test_cadet_local_mq.c index 7ae0a90c4..c56b510ae 100644 --- a/src/cadet/test_cadet_local_mq.c +++ b/src/cadet/test_cadet_local_mq.c | |||
@@ -36,7 +36,8 @@ | |||
36 | /** | 36 | /** |
37 | * Test message structure. | 37 | * Test message structure. |
38 | */ | 38 | */ |
39 | struct GNUNET_CADET_TestMsg { | 39 | struct GNUNET_CADET_TestMsg |
40 | { | ||
40 | /** | 41 | /** |
41 | * Type: #TEST_MESSAGE_TYPE | 42 | * Type: #TEST_MESSAGE_TYPE |
42 | * | 43 | * |
@@ -73,46 +74,46 @@ static struct GNUNET_SCHEDULER_Task *connect_task; | |||
73 | * @param cls Closue (unused). | 74 | * @param cls Closue (unused). |
74 | */ | 75 | */ |
75 | static void | 76 | static void |
76 | do_connect(void *cls); | 77 | do_connect (void *cls); |
77 | 78 | ||
78 | 79 | ||
79 | /** | 80 | /** |
80 | * Shutdown nicely | 81 | * Shutdown nicely |
81 | */ | 82 | */ |
82 | static void | 83 | static void |
83 | do_shutdown(void *cls) | 84 | do_shutdown (void *cls) |
84 | { | 85 | { |
85 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 86 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
86 | "shutdown\n"); | 87 | "shutdown\n"); |
87 | if (NULL != abort_task) | 88 | if (NULL != abort_task) |
88 | { | 89 | { |
89 | GNUNET_SCHEDULER_cancel(abort_task); | 90 | GNUNET_SCHEDULER_cancel (abort_task); |
90 | abort_task = NULL; | 91 | abort_task = NULL; |
91 | } | 92 | } |
92 | if (NULL != ch) | 93 | if (NULL != ch) |
93 | { | 94 | { |
94 | GNUNET_CADET_channel_destroy(ch); | 95 | GNUNET_CADET_channel_destroy (ch); |
95 | ch = NULL; | 96 | ch = NULL; |
96 | } | 97 | } |
97 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 98 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
98 | "Disconnect client 1\n"); | 99 | "Disconnect client 1\n"); |
99 | if (NULL != cadet_peer_1) | 100 | if (NULL != cadet_peer_1) |
100 | { | 101 | { |
101 | GNUNET_CADET_disconnect(cadet_peer_1); | 102 | GNUNET_CADET_disconnect (cadet_peer_1); |
102 | cadet_peer_1 = NULL; | 103 | cadet_peer_1 = NULL; |
103 | } | 104 | } |
104 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 105 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
105 | "Disconnect client 2\n"); | 106 | "Disconnect client 2\n"); |
106 | if (NULL != cadet_peer_2) | 107 | if (NULL != cadet_peer_2) |
107 | { | 108 | { |
108 | GNUNET_CADET_disconnect(cadet_peer_2); | 109 | GNUNET_CADET_disconnect (cadet_peer_2); |
109 | cadet_peer_2 = NULL; | 110 | cadet_peer_2 = NULL; |
110 | } | 111 | } |
111 | if (NULL != connect_task) | 112 | if (NULL != connect_task) |
112 | { | 113 | { |
113 | GNUNET_SCHEDULER_cancel(connect_task); | 114 | GNUNET_SCHEDULER_cancel (connect_task); |
114 | connect_task = NULL; | 115 | connect_task = NULL; |
115 | } | 116 | } |
116 | } | 117 | } |
117 | 118 | ||
118 | 119 | ||
@@ -120,14 +121,14 @@ do_shutdown(void *cls) | |||
120 | * Something went wrong and timed out. Kill everything and set error flag | 121 | * Something went wrong and timed out. Kill everything and set error flag |
121 | */ | 122 | */ |
122 | static void | 123 | static void |
123 | do_abort(void *cls) | 124 | do_abort (void *cls) |
124 | { | 125 | { |
125 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 126 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
126 | "ABORT from line %ld\n", | 127 | "ABORT from line %ld\n", |
127 | (long)cls); | 128 | (long) cls); |
128 | result = GNUNET_SYSERR; | 129 | result = GNUNET_SYSERR; |
129 | abort_task = NULL; | 130 | abort_task = NULL; |
130 | GNUNET_SCHEDULER_shutdown(); | 131 | GNUNET_SCHEDULER_shutdown (); |
131 | } | 132 | } |
132 | 133 | ||
133 | /** | 134 | /** |
@@ -143,14 +144,14 @@ do_abort(void *cls) | |||
143 | * received on the @a channel. | 144 | * received on the @a channel. |
144 | */ | 145 | */ |
145 | static void * | 146 | static void * |
146 | connected(void *cls, | 147 | connected (void *cls, |
147 | struct GNUNET_CADET_Channel *channel, | 148 | struct GNUNET_CADET_Channel *channel, |
148 | const struct GNUNET_PeerIdentity *source) | 149 | const struct GNUNET_PeerIdentity *source) |
149 | { | 150 | { |
150 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 151 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
151 | "connected %s, cls: %p\n", | 152 | "connected %s, cls: %p\n", |
152 | GNUNET_i2s(source), | 153 | GNUNET_i2s (source), |
153 | cls); | 154 | cls); |
154 | return channel; | 155 | return channel; |
155 | } | 156 | } |
156 | 157 | ||
@@ -166,12 +167,12 @@ connected(void *cls, | |||
166 | * @param channel Connection to the other end (henceforth invalid). | 167 | * @param channel Connection to the other end (henceforth invalid). |
167 | */ | 168 | */ |
168 | static void | 169 | static void |
169 | disconnected(void *cls, | 170 | disconnected (void *cls, |
170 | const struct GNUNET_CADET_Channel *channel) | 171 | const struct GNUNET_CADET_Channel *channel) |
171 | { | 172 | { |
172 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 173 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
173 | "disconnected channel %p, cls: %p\n", | 174 | "disconnected channel %p, cls: %p\n", |
174 | channel, cls); | 175 | channel, cls); |
175 | if (channel == ch) | 176 | if (channel == ch) |
176 | ch = NULL; | 177 | ch = NULL; |
177 | } | 178 | } |
@@ -184,19 +185,19 @@ disconnected(void *cls, | |||
184 | * @param msg A message with the details of the new incoming channel | 185 | * @param msg A message with the details of the new incoming channel |
185 | */ | 186 | */ |
186 | static void | 187 | static void |
187 | handle_data_received(void *cls, | 188 | handle_data_received (void *cls, |
188 | const struct GNUNET_CADET_TestMsg *msg) | 189 | const struct GNUNET_CADET_TestMsg *msg) |
189 | { | 190 | { |
190 | uint64_t payload; | 191 | uint64_t payload; |
191 | 192 | ||
192 | payload = GNUNET_ntohll(msg->payload); | 193 | payload = GNUNET_ntohll (msg->payload); |
193 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 194 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
194 | "Data callback payload %llu with cls: %p! Shutting down.\n", | 195 | "Data callback payload %llu with cls: %p! Shutting down.\n", |
195 | (unsigned long long)payload, | 196 | (unsigned long long) payload, |
196 | cls); | 197 | cls); |
197 | GNUNET_assert(42 == payload); | 198 | GNUNET_assert (42 == payload); |
198 | got_data = GNUNET_YES; | 199 | got_data = GNUNET_YES; |
199 | GNUNET_SCHEDULER_shutdown(); | 200 | GNUNET_SCHEDULER_shutdown (); |
200 | } | 201 | } |
201 | 202 | ||
202 | 203 | ||
@@ -206,10 +207,10 @@ handle_data_received(void *cls, | |||
206 | * @param cls Closure (unused). | 207 | * @param cls Closure (unused). |
207 | */ | 208 | */ |
208 | static void | 209 | static void |
209 | message_sent(void *cls) | 210 | message_sent (void *cls) |
210 | { | 211 | { |
211 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 212 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
212 | "message sent\n"); | 213 | "message sent\n"); |
213 | } | 214 | } |
214 | 215 | ||
215 | 216 | ||
@@ -219,7 +220,7 @@ message_sent(void *cls) | |||
219 | * @param cls Closure (unused). | 220 | * @param cls Closure (unused). |
220 | */ | 221 | */ |
221 | static void | 222 | static void |
222 | do_connect(void *cls) | 223 | do_connect (void *cls) |
223 | { | 224 | { |
224 | struct GNUNET_PeerIdentity id; | 225 | struct GNUNET_PeerIdentity id; |
225 | struct GNUNET_MQ_Handle *mq; | 226 | struct GNUNET_MQ_Handle *mq; |
@@ -227,32 +228,32 @@ do_connect(void *cls) | |||
227 | struct GNUNET_CADET_TestMsg *msg; | 228 | struct GNUNET_CADET_TestMsg *msg; |
228 | 229 | ||
229 | struct GNUNET_MQ_MessageHandler handlers[] = { | 230 | struct GNUNET_MQ_MessageHandler handlers[] = { |
230 | GNUNET_MQ_hd_fixed_size(data_received, | 231 | GNUNET_MQ_hd_fixed_size (data_received, |
231 | TEST_MESSAGE_TYPE, | 232 | TEST_MESSAGE_TYPE, |
232 | struct GNUNET_CADET_TestMsg, | 233 | struct GNUNET_CADET_TestMsg, |
233 | cadet_peer_1), | 234 | cadet_peer_1), |
234 | GNUNET_MQ_handler_end() | 235 | GNUNET_MQ_handler_end () |
235 | }; | 236 | }; |
236 | 237 | ||
237 | connect_task = NULL; | 238 | connect_task = NULL; |
238 | GNUNET_TESTING_peer_get_identity(me, &id); | 239 | GNUNET_TESTING_peer_get_identity (me, &id); |
239 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 240 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
240 | "creating channel\n"); | 241 | "creating channel\n"); |
241 | ch = GNUNET_CADET_channel_create(cadet_peer_1, /* cadet handle */ | 242 | ch = GNUNET_CADET_channel_create (cadet_peer_1, /* cadet handle */ |
242 | NULL, /* channel cls */ | 243 | NULL, /* channel cls */ |
243 | &id, /* destination */ | 244 | &id, /* destination */ |
244 | GC_u2h(TEST_MESSAGE_TYPE), /* port */ | 245 | GC_u2h (TEST_MESSAGE_TYPE), /* port */ |
245 | NULL, /* window change */ | 246 | NULL, /* window change */ |
246 | &disconnected, /* disconnect handler */ | 247 | &disconnected, /* disconnect handler */ |
247 | handlers /* traffic handlers */ | 248 | handlers /* traffic handlers */ |
248 | ); | 249 | ); |
249 | env = GNUNET_MQ_msg(msg, TEST_MESSAGE_TYPE); | 250 | env = GNUNET_MQ_msg (msg, TEST_MESSAGE_TYPE); |
250 | msg->payload = GNUNET_htonll(42); | 251 | msg->payload = GNUNET_htonll (42); |
251 | mq = GNUNET_CADET_get_mq(ch); | 252 | mq = GNUNET_CADET_get_mq (ch); |
252 | GNUNET_MQ_notify_sent(env, &message_sent, NULL); | 253 | GNUNET_MQ_notify_sent (env, &message_sent, NULL); |
253 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 254 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
254 | "sending message\n"); | 255 | "sending message\n"); |
255 | GNUNET_MQ_send(mq, env); | 256 | GNUNET_MQ_send (mq, env); |
256 | } | 257 | } |
257 | 258 | ||
258 | 259 | ||
@@ -264,53 +265,53 @@ do_connect(void *cls) | |||
264 | * @param peer Testing peer handle. | 265 | * @param peer Testing peer handle. |
265 | */ | 266 | */ |
266 | static void | 267 | static void |
267 | run(void *cls, | 268 | run (void *cls, |
268 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 269 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
269 | struct GNUNET_TESTING_Peer *peer) | 270 | struct GNUNET_TESTING_Peer *peer) |
270 | { | 271 | { |
271 | struct GNUNET_MQ_MessageHandler handlers[] = { | 272 | struct GNUNET_MQ_MessageHandler handlers[] = { |
272 | GNUNET_MQ_hd_fixed_size(data_received, | 273 | GNUNET_MQ_hd_fixed_size (data_received, |
273 | TEST_MESSAGE_TYPE, | 274 | TEST_MESSAGE_TYPE, |
274 | struct GNUNET_CADET_TestMsg, | 275 | struct GNUNET_CADET_TestMsg, |
275 | cadet_peer_2), | 276 | cadet_peer_2), |
276 | GNUNET_MQ_handler_end() | 277 | GNUNET_MQ_handler_end () |
277 | }; | 278 | }; |
278 | struct GNUNET_TIME_Relative delay; | 279 | struct GNUNET_TIME_Relative delay; |
279 | 280 | ||
280 | me = peer; | 281 | me = peer; |
281 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, | 282 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, |
282 | NULL); | 283 | NULL); |
283 | delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15); | 284 | delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15); |
284 | abort_task = GNUNET_SCHEDULER_add_delayed(delay, | 285 | abort_task = GNUNET_SCHEDULER_add_delayed (delay, |
285 | &do_abort, | 286 | &do_abort, |
286 | (void *)(long)__LINE__); | 287 | (void *) (long) __LINE__); |
287 | cadet_peer_1 = GNUNET_CADET_connect(cfg); | 288 | cadet_peer_1 = GNUNET_CADET_connect (cfg); |
288 | cadet_peer_2 = GNUNET_CADET_connect(cfg); | 289 | cadet_peer_2 = GNUNET_CADET_connect (cfg); |
289 | 290 | ||
290 | if ((NULL == cadet_peer_1) || | 291 | if ((NULL == cadet_peer_1) || |
291 | (NULL == cadet_peer_2)) | 292 | (NULL == cadet_peer_2)) |
292 | { | 293 | { |
293 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 294 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
294 | "Couldn't connect to cadet\n"); | 295 | "Couldn't connect to cadet\n"); |
295 | result = GNUNET_SYSERR; | 296 | result = GNUNET_SYSERR; |
296 | GNUNET_SCHEDULER_shutdown(); | 297 | GNUNET_SCHEDULER_shutdown (); |
297 | return; | 298 | return; |
298 | } | 299 | } |
299 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "CADET 1: %p\n", cadet_peer_1); | 300 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CADET 1: %p\n", cadet_peer_1); |
300 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "CADET 2: %p\n", cadet_peer_2); | 301 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CADET 2: %p\n", cadet_peer_2); |
301 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "handlers 2: %p\n", handlers); | 302 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "handlers 2: %p\n", handlers); |
302 | GNUNET_CADET_open_port(cadet_peer_2, /* cadet handle */ | 303 | GNUNET_CADET_open_port (cadet_peer_2, /* cadet handle */ |
303 | GC_u2h(TEST_PORT_ID), /* port id */ | 304 | GC_u2h (TEST_PORT_ID), /* port id */ |
304 | &connected, /* connect handler */ | 305 | &connected, /* connect handler */ |
305 | (void *)2L, /* handle for #connected */ | 306 | (void *) 2L, /* handle for #connected */ |
306 | NULL, /* window size handler */ | 307 | NULL, /* window size handler */ |
307 | &disconnected, /* disconnect handler */ | 308 | &disconnected, /* disconnect handler */ |
308 | handlers); /* traffic handlers */ | 309 | handlers); /* traffic handlers */ |
309 | delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2); | 310 | delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2); |
310 | if (NULL == connect_task) | 311 | if (NULL == connect_task) |
311 | connect_task = GNUNET_SCHEDULER_add_delayed(delay, | 312 | connect_task = GNUNET_SCHEDULER_add_delayed (delay, |
312 | &do_connect, | 313 | &do_connect, |
313 | NULL); | 314 | NULL); |
314 | } | 315 | } |
315 | 316 | ||
316 | 317 | ||
@@ -318,16 +319,16 @@ run(void *cls, | |||
318 | * Main | 319 | * Main |
319 | */ | 320 | */ |
320 | int | 321 | int |
321 | main(int argc, char *argv[]) | 322 | main (int argc, char *argv[]) |
322 | { | 323 | { |
323 | if (0 != GNUNET_TESTING_peer_run("test-cadet-local", | 324 | if (0 != GNUNET_TESTING_peer_run ("test-cadet-local", |
324 | "test_cadet.conf", | 325 | "test_cadet.conf", |
325 | &run, NULL)) | 326 | &run, NULL)) |
326 | { | 327 | { |
327 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "run failed\n"); | 328 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "run failed\n"); |
328 | return 2; | 329 | return 2; |
329 | } | 330 | } |
330 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Final result: %d\n", result); | 331 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Final result: %d\n", result); |
331 | return (result == GNUNET_OK) ? 0 : 1; | 332 | return (result == GNUNET_OK) ? 0 : 1; |
332 | } | 333 | } |
333 | 334 | ||