diff options
Diffstat (limited to 'src/transport/gnunet-service-transport_manipulation.c')
-rw-r--r-- | src/transport/gnunet-service-transport_manipulation.c | 478 |
1 files changed, 240 insertions, 238 deletions
diff --git a/src/transport/gnunet-service-transport_manipulation.c b/src/transport/gnunet-service-transport_manipulation.c index 07f7eb618..47ae5b981 100644 --- a/src/transport/gnunet-service-transport_manipulation.c +++ b/src/transport/gnunet-service-transport_manipulation.c | |||
@@ -36,7 +36,8 @@ | |||
36 | /** | 36 | /** |
37 | * Struct containing information about manipulations to a specific peer | 37 | * Struct containing information about manipulations to a specific peer |
38 | */ | 38 | */ |
39 | struct TM_Peer { | 39 | struct TM_Peer |
40 | { | ||
40 | /** | 41 | /** |
41 | * Peer ID | 42 | * Peer ID |
42 | */ | 43 | */ |
@@ -77,7 +78,8 @@ struct TM_Peer { | |||
77 | /** | 78 | /** |
78 | * Entry in the delay queue for an outbound delayed message | 79 | * Entry in the delay queue for an outbound delayed message |
79 | */ | 80 | */ |
80 | struct DelayQueueEntry { | 81 | struct DelayQueueEntry |
82 | { | ||
81 | /** | 83 | /** |
82 | * Next in DLL | 84 | * Next in DLL |
83 | */ | 85 | */ |
@@ -169,39 +171,39 @@ static struct GNUNET_SCHEDULER_Task *generic_send_delay_task; | |||
169 | * @param message containing information | 171 | * @param message containing information |
170 | */ | 172 | */ |
171 | void | 173 | void |
172 | GST_manipulation_set_metric(const struct TrafficMetricMessage *tm) | 174 | GST_manipulation_set_metric (const struct TrafficMetricMessage *tm) |
173 | { | 175 | { |
174 | static struct GNUNET_PeerIdentity zero; | 176 | static struct GNUNET_PeerIdentity zero; |
175 | struct TM_Peer *tmp; | 177 | struct TM_Peer *tmp; |
176 | 178 | ||
177 | if (0 == memcmp(&tm->peer, | 179 | if (0 == memcmp (&tm->peer, |
178 | &zero, | 180 | &zero, |
179 | sizeof(struct GNUNET_PeerIdentity))) | 181 | sizeof(struct GNUNET_PeerIdentity))) |
180 | { | 182 | { |
181 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 183 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
182 | "Received traffic metrics for all peers\n"); | 184 | "Received traffic metrics for all peers\n"); |
183 | delay_in = GNUNET_TIME_relative_ntoh(tm->delay_in); | 185 | delay_in = GNUNET_TIME_relative_ntoh (tm->delay_in); |
184 | delay_out = GNUNET_TIME_relative_ntoh(tm->delay_out); | 186 | delay_out = GNUNET_TIME_relative_ntoh (tm->delay_out); |
185 | return; | 187 | return; |
186 | } | 188 | } |
187 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 189 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
188 | "Received traffic metrics for peer `%s'\n", | 190 | "Received traffic metrics for peer `%s'\n", |
189 | GNUNET_i2s(&tm->peer)); | 191 | GNUNET_i2s (&tm->peer)); |
190 | if (NULL == | 192 | if (NULL == |
191 | (tmp = GNUNET_CONTAINER_multipeermap_get(peers, | 193 | (tmp = GNUNET_CONTAINER_multipeermap_get (peers, |
192 | &tm->peer))) | 194 | &tm->peer))) |
193 | { | 195 | { |
194 | tmp = GNUNET_new(struct TM_Peer); | 196 | tmp = GNUNET_new (struct TM_Peer); |
195 | tmp->peer = tm->peer; | 197 | tmp->peer = tm->peer; |
196 | GNUNET_CONTAINER_multipeermap_put(peers, | 198 | GNUNET_CONTAINER_multipeermap_put (peers, |
197 | &tm->peer, | 199 | &tm->peer, |
198 | tmp, | 200 | tmp, |
199 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); | 201 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); |
200 | } | 202 | } |
201 | GNUNET_ATS_properties_ntoh(&tmp->properties, | 203 | GNUNET_ATS_properties_ntoh (&tmp->properties, |
202 | &tm->properties); | 204 | &tm->properties); |
203 | tmp->delay_in = GNUNET_TIME_relative_ntoh(tm->delay_in); | 205 | tmp->delay_in = GNUNET_TIME_relative_ntoh (tm->delay_in); |
204 | tmp->delay_out = GNUNET_TIME_relative_ntoh(tm->delay_out); | 206 | tmp->delay_out = GNUNET_TIME_relative_ntoh (tm->delay_out); |
205 | } | 207 | } |
206 | 208 | ||
207 | 209 | ||
@@ -212,52 +214,52 @@ GST_manipulation_set_metric(const struct TrafficMetricMessage *tm) | |||
212 | * @param cls the `struct DelayQueueEntry` to transmit | 214 | * @param cls the `struct DelayQueueEntry` to transmit |
213 | */ | 215 | */ |
214 | static void | 216 | static void |
215 | send_delayed(void *cls) | 217 | send_delayed (void *cls) |
216 | { | 218 | { |
217 | struct DelayQueueEntry *dqe = cls; | 219 | struct DelayQueueEntry *dqe = cls; |
218 | struct DelayQueueEntry *next; | 220 | struct DelayQueueEntry *next; |
219 | struct TM_Peer *tmp = dqe->tmp; | 221 | struct TM_Peer *tmp = dqe->tmp; |
220 | 222 | ||
221 | GNUNET_break(GNUNET_YES == | 223 | GNUNET_break (GNUNET_YES == |
222 | GST_neighbours_test_connected(&dqe->id)); | 224 | GST_neighbours_test_connected (&dqe->id)); |
223 | if (NULL != tmp) | 225 | if (NULL != tmp) |
226 | { | ||
227 | tmp->send_delay_task = NULL; | ||
228 | GNUNET_CONTAINER_DLL_remove (tmp->send_head, | ||
229 | tmp->send_tail, | ||
230 | dqe); | ||
231 | next = tmp->send_head; | ||
232 | if (NULL != next) | ||
224 | { | 233 | { |
225 | tmp->send_delay_task = NULL; | 234 | /* More delayed messages */ |
226 | GNUNET_CONTAINER_DLL_remove(tmp->send_head, | 235 | tmp->send_delay_task = GNUNET_SCHEDULER_add_at (next->sent_at, |
227 | tmp->send_tail, | 236 | &send_delayed, |
228 | dqe); | 237 | next); |
229 | next = tmp->send_head; | ||
230 | if (NULL != next) | ||
231 | { | ||
232 | /* More delayed messages */ | ||
233 | tmp->send_delay_task = GNUNET_SCHEDULER_add_at(next->sent_at, | ||
234 | &send_delayed, | ||
235 | next); | ||
236 | } | ||
237 | } | 238 | } |
239 | } | ||
238 | else | 240 | else |
241 | { | ||
242 | /* Remove from generic queue */ | ||
243 | generic_send_delay_task = NULL; | ||
244 | GNUNET_CONTAINER_DLL_remove (generic_dqe_head, | ||
245 | generic_dqe_tail, | ||
246 | dqe); | ||
247 | next = generic_dqe_head; | ||
248 | if (NULL != next) | ||
239 | { | 249 | { |
240 | /* Remove from generic queue */ | 250 | /* More delayed messages */ |
241 | generic_send_delay_task = NULL; | 251 | generic_send_delay_task = GNUNET_SCHEDULER_add_at (next->sent_at, |
242 | GNUNET_CONTAINER_DLL_remove(generic_dqe_head, | 252 | &send_delayed, |
243 | generic_dqe_tail, | 253 | next); |
244 | dqe); | ||
245 | next = generic_dqe_head; | ||
246 | if (NULL != next) | ||
247 | { | ||
248 | /* More delayed messages */ | ||
249 | generic_send_delay_task = GNUNET_SCHEDULER_add_at(next->sent_at, | ||
250 | &send_delayed, | ||
251 | next); | ||
252 | } | ||
253 | } | 254 | } |
254 | GST_neighbours_send(&dqe->id, | 255 | } |
255 | dqe->msg, | 256 | GST_neighbours_send (&dqe->id, |
256 | dqe->msg_size, | 257 | dqe->msg, |
257 | dqe->timeout, | 258 | dqe->msg_size, |
258 | dqe->cont, | 259 | dqe->timeout, |
259 | dqe->cont_cls); | 260 | dqe->cont, |
260 | GNUNET_free(dqe); | 261 | dqe->cont_cls); |
262 | GNUNET_free (dqe); | ||
261 | } | 263 | } |
262 | 264 | ||
263 | 265 | ||
@@ -273,71 +275,71 @@ send_delayed(void *cls) | |||
273 | * @param cont_cls cls for @a cont | 275 | * @param cont_cls cls for @a cont |
274 | */ | 276 | */ |
275 | void | 277 | void |
276 | GST_manipulation_send(const struct GNUNET_PeerIdentity *target, | 278 | GST_manipulation_send (const struct GNUNET_PeerIdentity *target, |
277 | const void *msg, | 279 | const void *msg, |
278 | size_t msg_size, | 280 | size_t msg_size, |
279 | struct GNUNET_TIME_Relative timeout, | 281 | struct GNUNET_TIME_Relative timeout, |
280 | GST_NeighbourSendContinuation cont, | 282 | GST_NeighbourSendContinuation cont, |
281 | void *cont_cls) | 283 | void *cont_cls) |
282 | { | 284 | { |
283 | struct TM_Peer *tmp; | 285 | struct TM_Peer *tmp; |
284 | struct DelayQueueEntry *dqe; | 286 | struct DelayQueueEntry *dqe; |
285 | struct GNUNET_TIME_Relative delay; | 287 | struct GNUNET_TIME_Relative delay; |
286 | 288 | ||
287 | if (NULL != (tmp = | 289 | if (NULL != (tmp = |
288 | GNUNET_CONTAINER_multipeermap_get(peers, | 290 | GNUNET_CONTAINER_multipeermap_get (peers, |
289 | target))) | 291 | target))) |
290 | delay = tmp->delay_out; | 292 | delay = tmp->delay_out; |
291 | else | 293 | else |
292 | delay = delay_out; | 294 | delay = delay_out; |
293 | if (0 == delay.rel_value_us) | 295 | if (0 == delay.rel_value_us) |
294 | { | 296 | { |
295 | /* Normal sending */ | 297 | /* Normal sending */ |
296 | GST_neighbours_send(target, | 298 | GST_neighbours_send (target, |
297 | msg, | 299 | msg, |
298 | msg_size, | 300 | msg_size, |
299 | timeout, | 301 | timeout, |
300 | cont, cont_cls); | 302 | cont, cont_cls); |
301 | return; | 303 | return; |
302 | } | 304 | } |
303 | dqe = GNUNET_malloc(sizeof(struct DelayQueueEntry) + msg_size); | 305 | dqe = GNUNET_malloc (sizeof(struct DelayQueueEntry) + msg_size); |
304 | dqe->id = *target; | 306 | dqe->id = *target; |
305 | dqe->tmp = tmp; | 307 | dqe->tmp = tmp; |
306 | dqe->sent_at = GNUNET_TIME_relative_to_absolute(delay); | 308 | dqe->sent_at = GNUNET_TIME_relative_to_absolute (delay); |
307 | dqe->cont = cont; | 309 | dqe->cont = cont; |
308 | dqe->cont_cls = cont_cls; | 310 | dqe->cont_cls = cont_cls; |
309 | dqe->msg = &dqe[1]; | 311 | dqe->msg = &dqe[1]; |
310 | dqe->msg_size = msg_size; | 312 | dqe->msg_size = msg_size; |
311 | dqe->timeout = timeout; | 313 | dqe->timeout = timeout; |
312 | GNUNET_memcpy(dqe->msg, | 314 | GNUNET_memcpy (dqe->msg, |
313 | msg, | 315 | msg, |
314 | msg_size); | 316 | msg_size); |
315 | if (NULL == tmp) | 317 | if (NULL == tmp) |
316 | { | 318 | { |
317 | GNUNET_CONTAINER_DLL_insert_tail(generic_dqe_head, | 319 | GNUNET_CONTAINER_DLL_insert_tail (generic_dqe_head, |
318 | generic_dqe_tail, | 320 | generic_dqe_tail, |
319 | dqe); | 321 | dqe); |
320 | if (NULL == generic_send_delay_task) | 322 | if (NULL == generic_send_delay_task) |
321 | generic_send_delay_task = GNUNET_SCHEDULER_add_delayed(delay, | 323 | generic_send_delay_task = GNUNET_SCHEDULER_add_delayed (delay, |
322 | &send_delayed, | 324 | &send_delayed, |
323 | dqe); | 325 | dqe); |
324 | } | 326 | } |
325 | else | 327 | else |
326 | { | 328 | { |
327 | GNUNET_CONTAINER_DLL_insert_tail(tmp->send_head, | 329 | GNUNET_CONTAINER_DLL_insert_tail (tmp->send_head, |
328 | tmp->send_tail, | 330 | tmp->send_tail, |
329 | dqe); | 331 | dqe); |
330 | if (NULL == tmp->send_delay_task) | 332 | if (NULL == tmp->send_delay_task) |
331 | tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed(delay, | 333 | tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed (delay, |
332 | &send_delayed, | 334 | &send_delayed, |
333 | dqe); | 335 | dqe); |
334 | } | 336 | } |
335 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 337 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
336 | "Delaying %u byte message to peer `%s' with peer specific delay for %s\n", | 338 | "Delaying %u byte message to peer `%s' with peer specific delay for %s\n", |
337 | (unsigned int)msg_size, | 339 | (unsigned int) msg_size, |
338 | GNUNET_i2s(target), | 340 | GNUNET_i2s (target), |
339 | GNUNET_STRINGS_relative_time_to_string(delay, | 341 | GNUNET_STRINGS_relative_time_to_string (delay, |
340 | GNUNET_YES)); | 342 | GNUNET_YES)); |
341 | } | 343 | } |
342 | 344 | ||
343 | 345 | ||
@@ -350,15 +352,15 @@ GST_manipulation_send(const struct GNUNET_PeerIdentity *target, | |||
350 | * @param prop[IN|OUT] metrics to modify | 352 | * @param prop[IN|OUT] metrics to modify |
351 | */ | 353 | */ |
352 | void | 354 | void |
353 | GST_manipulation_manipulate_metrics(const struct GNUNET_HELLO_Address *address, | 355 | GST_manipulation_manipulate_metrics (const struct GNUNET_HELLO_Address *address, |
354 | struct GNUNET_ATS_Session *session, | 356 | struct GNUNET_ATS_Session *session, |
355 | struct GNUNET_ATS_Properties *prop) | 357 | struct GNUNET_ATS_Properties *prop) |
356 | { | 358 | { |
357 | const struct GNUNET_PeerIdentity *peer = &address->peer; | 359 | const struct GNUNET_PeerIdentity *peer = &address->peer; |
358 | struct TM_Peer *tmp; | 360 | struct TM_Peer *tmp; |
359 | 361 | ||
360 | tmp = GNUNET_CONTAINER_multipeermap_get(peers, | 362 | tmp = GNUNET_CONTAINER_multipeermap_get (peers, |
361 | peer); | 363 | peer); |
362 | if (NULL != tmp) | 364 | if (NULL != tmp) |
363 | *prop = tmp->properties; | 365 | *prop = tmp->properties; |
364 | } | 366 | } |
@@ -375,33 +377,33 @@ GST_manipulation_manipulate_metrics(const struct GNUNET_HELLO_Address *address, | |||
375 | * @return manipulated delay for next receive | 377 | * @return manipulated delay for next receive |
376 | */ | 378 | */ |
377 | struct GNUNET_TIME_Relative | 379 | struct GNUNET_TIME_Relative |
378 | GST_manipulation_recv(void *cls, | 380 | GST_manipulation_recv (void *cls, |
379 | const struct GNUNET_HELLO_Address *address, | 381 | const struct GNUNET_HELLO_Address *address, |
380 | struct GNUNET_ATS_Session *session, | 382 | struct GNUNET_ATS_Session *session, |
381 | const struct GNUNET_MessageHeader *message) | 383 | const struct GNUNET_MessageHeader *message) |
382 | { | 384 | { |
383 | struct TM_Peer *tmp; | 385 | struct TM_Peer *tmp; |
384 | struct GNUNET_TIME_Relative quota_delay; | 386 | struct GNUNET_TIME_Relative quota_delay; |
385 | struct GNUNET_TIME_Relative m_delay; | 387 | struct GNUNET_TIME_Relative m_delay; |
386 | 388 | ||
387 | if (NULL != | 389 | if (NULL != |
388 | (tmp = GNUNET_CONTAINER_multipeermap_get(peers, | 390 | (tmp = GNUNET_CONTAINER_multipeermap_get (peers, |
389 | &address->peer))) | 391 | &address->peer))) |
390 | m_delay = tmp->delay_in; | 392 | m_delay = tmp->delay_in; |
391 | else | 393 | else |
392 | m_delay = delay_in; | 394 | m_delay = delay_in; |
393 | 395 | ||
394 | quota_delay = GST_receive_callback(cls, | 396 | quota_delay = GST_receive_callback (cls, |
395 | address, | 397 | address, |
396 | session, | 398 | session, |
397 | message); | 399 | message); |
398 | m_delay = GNUNET_TIME_relative_max(m_delay, | 400 | m_delay = GNUNET_TIME_relative_max (m_delay, |
399 | quota_delay); | 401 | quota_delay); |
400 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 402 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
401 | "Delaying next receive for peer `%s' for %s\n", | 403 | "Delaying next receive for peer `%s' for %s\n", |
402 | GNUNET_i2s(&address->peer), | 404 | GNUNET_i2s (&address->peer), |
403 | GNUNET_STRINGS_relative_time_to_string(m_delay, | 405 | GNUNET_STRINGS_relative_time_to_string (m_delay, |
404 | GNUNET_YES)); | 406 | GNUNET_YES)); |
405 | return m_delay; | 407 | return m_delay; |
406 | } | 408 | } |
407 | 409 | ||
@@ -410,38 +412,38 @@ GST_manipulation_recv(void *cls, | |||
410 | * Initialize traffic manipulation | 412 | * Initialize traffic manipulation |
411 | */ | 413 | */ |
412 | void | 414 | void |
413 | GST_manipulation_init() | 415 | GST_manipulation_init () |
414 | { | 416 | { |
415 | struct GNUNET_TIME_Relative delay; | 417 | struct GNUNET_TIME_Relative delay; |
416 | 418 | ||
417 | if ((GNUNET_OK == | 419 | if ((GNUNET_OK == |
418 | GNUNET_CONFIGURATION_get_value_time(GST_cfg, | 420 | GNUNET_CONFIGURATION_get_value_time (GST_cfg, |
419 | "transport", | 421 | "transport", |
420 | "MANIPULATE_DELAY_IN", | 422 | "MANIPULATE_DELAY_IN", |
421 | &delay)) && | 423 | &delay)) && |
422 | (delay.rel_value_us > 0)) | 424 | (delay.rel_value_us > 0)) |
423 | { | 425 | { |
424 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 426 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
425 | "Delaying inbound traffic for %s\n", | 427 | "Delaying inbound traffic for %s\n", |
426 | GNUNET_STRINGS_relative_time_to_string(delay, | 428 | GNUNET_STRINGS_relative_time_to_string (delay, |
427 | GNUNET_YES)); | 429 | GNUNET_YES)); |
428 | delay_in = delay; | 430 | delay_in = delay; |
429 | } | 431 | } |
430 | if ((GNUNET_OK == | 432 | if ((GNUNET_OK == |
431 | GNUNET_CONFIGURATION_get_value_time(GST_cfg, | 433 | GNUNET_CONFIGURATION_get_value_time (GST_cfg, |
432 | "transport", | 434 | "transport", |
433 | "MANIPULATE_DELAY_OUT", | 435 | "MANIPULATE_DELAY_OUT", |
434 | &delay)) && | 436 | &delay)) && |
435 | (delay.rel_value_us > 0)) | 437 | (delay.rel_value_us > 0)) |
436 | { | 438 | { |
437 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 439 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
438 | "Delaying outbound traffic for %s\n", | 440 | "Delaying outbound traffic for %s\n", |
439 | GNUNET_STRINGS_relative_time_to_string(delay, | 441 | GNUNET_STRINGS_relative_time_to_string (delay, |
440 | GNUNET_YES)); | 442 | GNUNET_YES)); |
441 | delay_out = delay; | 443 | delay_out = delay; |
442 | } | 444 | } |
443 | peers = GNUNET_CONTAINER_multipeermap_create(4, | 445 | peers = GNUNET_CONTAINER_multipeermap_create (4, |
444 | GNUNET_NO); | 446 | GNUNET_NO); |
445 | } | 447 | } |
446 | 448 | ||
447 | 449 | ||
@@ -451,58 +453,58 @@ GST_manipulation_init() | |||
451 | * @param peer the disconnecting peer | 453 | * @param peer the disconnecting peer |
452 | */ | 454 | */ |
453 | void | 455 | void |
454 | GST_manipulation_peer_disconnect(const struct GNUNET_PeerIdentity *peer) | 456 | GST_manipulation_peer_disconnect (const struct GNUNET_PeerIdentity *peer) |
455 | { | 457 | { |
456 | struct TM_Peer *tmp; | 458 | struct TM_Peer *tmp; |
457 | struct DelayQueueEntry *dqe; | 459 | struct DelayQueueEntry *dqe; |
458 | struct DelayQueueEntry *next; | 460 | struct DelayQueueEntry *next; |
459 | 461 | ||
460 | tmp = GNUNET_CONTAINER_multipeermap_get(peers, | 462 | tmp = GNUNET_CONTAINER_multipeermap_get (peers, |
461 | peer); | 463 | peer); |
462 | if (NULL != tmp) | 464 | if (NULL != tmp) |
465 | { | ||
466 | while (NULL != (dqe = tmp->send_head)) | ||
463 | { | 467 | { |
464 | while (NULL != (dqe = tmp->send_head)) | 468 | GNUNET_CONTAINER_DLL_remove (tmp->send_head, |
465 | { | 469 | tmp->send_tail, |
466 | GNUNET_CONTAINER_DLL_remove(tmp->send_head, | 470 | dqe); |
467 | tmp->send_tail, | 471 | if (NULL != dqe->cont) |
468 | dqe); | 472 | dqe->cont (dqe->cont_cls, |
469 | if (NULL != dqe->cont) | 473 | GNUNET_SYSERR, |
470 | dqe->cont(dqe->cont_cls, | 474 | dqe->msg_size, |
471 | GNUNET_SYSERR, | 475 | 0); |
472 | dqe->msg_size, | 476 | GNUNET_free (dqe); |
473 | 0); | ||
474 | GNUNET_free(dqe); | ||
475 | } | ||
476 | } | 477 | } |
478 | } | ||
477 | next = generic_dqe_head; | 479 | next = generic_dqe_head; |
478 | while (NULL != (dqe = next)) | 480 | while (NULL != (dqe = next)) |
481 | { | ||
482 | next = dqe->next; | ||
483 | if (0 == memcmp (peer, | ||
484 | &dqe->id, | ||
485 | sizeof(dqe->id))) | ||
479 | { | 486 | { |
480 | next = dqe->next; | 487 | GNUNET_CONTAINER_DLL_remove (generic_dqe_head, |
481 | if (0 == memcmp(peer, | 488 | generic_dqe_tail, |
482 | &dqe->id, | 489 | dqe); |
483 | sizeof(dqe->id))) | 490 | if (NULL != dqe->cont) |
484 | { | 491 | dqe->cont (dqe->cont_cls, |
485 | GNUNET_CONTAINER_DLL_remove(generic_dqe_head, | 492 | GNUNET_SYSERR, |
486 | generic_dqe_tail, | 493 | dqe->msg_size, |
487 | dqe); | 494 | 0); |
488 | if (NULL != dqe->cont) | 495 | GNUNET_free (dqe); |
489 | dqe->cont(dqe->cont_cls, | ||
490 | GNUNET_SYSERR, | ||
491 | dqe->msg_size, | ||
492 | 0); | ||
493 | GNUNET_free(dqe); | ||
494 | } | ||
495 | } | 496 | } |
497 | } | ||
496 | if (NULL != generic_send_delay_task) | 498 | if (NULL != generic_send_delay_task) |
497 | { | 499 | { |
498 | GNUNET_SCHEDULER_cancel(generic_send_delay_task); | 500 | GNUNET_SCHEDULER_cancel (generic_send_delay_task); |
499 | generic_send_delay_task = NULL; | 501 | generic_send_delay_task = NULL; |
500 | if (NULL != generic_dqe_head) | 502 | if (NULL != generic_dqe_head) |
501 | generic_send_delay_task | 503 | generic_send_delay_task |
502 | = GNUNET_SCHEDULER_add_at(generic_dqe_head->sent_at, | 504 | = GNUNET_SCHEDULER_add_at (generic_dqe_head->sent_at, |
503 | &send_delayed, | 505 | &send_delayed, |
504 | generic_dqe_head); | 506 | generic_dqe_head); |
505 | } | 507 | } |
506 | } | 508 | } |
507 | 509 | ||
508 | 510 | ||
@@ -515,35 +517,35 @@ GST_manipulation_peer_disconnect(const struct GNUNET_PeerIdentity *peer) | |||
515 | * @return #GNUNET_OK (continue to iterate) | 517 | * @return #GNUNET_OK (continue to iterate) |
516 | */ | 518 | */ |
517 | static int | 519 | static int |
518 | free_tmps(void *cls, | 520 | free_tmps (void *cls, |
519 | const struct GNUNET_PeerIdentity *key, | 521 | const struct GNUNET_PeerIdentity *key, |
520 | void *value) | 522 | void *value) |
521 | { | 523 | { |
522 | struct TM_Peer *tmp = value; | 524 | struct TM_Peer *tmp = value; |
523 | struct DelayQueueEntry *dqe; | 525 | struct DelayQueueEntry *dqe; |
524 | 526 | ||
525 | GNUNET_break(GNUNET_YES == | 527 | GNUNET_break (GNUNET_YES == |
526 | GNUNET_CONTAINER_multipeermap_remove(peers, | 528 | GNUNET_CONTAINER_multipeermap_remove (peers, |
527 | key, | 529 | key, |
528 | value)); | 530 | value)); |
529 | while (NULL != (dqe = tmp->send_head)) | 531 | while (NULL != (dqe = tmp->send_head)) |
530 | { | 532 | { |
531 | GNUNET_CONTAINER_DLL_remove(tmp->send_head, | 533 | GNUNET_CONTAINER_DLL_remove (tmp->send_head, |
532 | tmp->send_tail, | 534 | tmp->send_tail, |
533 | dqe); | 535 | dqe); |
534 | if (NULL != dqe->cont) | 536 | if (NULL != dqe->cont) |
535 | dqe->cont(dqe->cont_cls, | 537 | dqe->cont (dqe->cont_cls, |
536 | GNUNET_SYSERR, | 538 | GNUNET_SYSERR, |
537 | dqe->msg_size, | 539 | dqe->msg_size, |
538 | 0); | 540 | 0); |
539 | GNUNET_free(dqe); | 541 | GNUNET_free (dqe); |
540 | } | 542 | } |
541 | if (NULL != tmp->send_delay_task) | 543 | if (NULL != tmp->send_delay_task) |
542 | { | 544 | { |
543 | GNUNET_SCHEDULER_cancel(tmp->send_delay_task); | 545 | GNUNET_SCHEDULER_cancel (tmp->send_delay_task); |
544 | tmp->send_delay_task = NULL; | 546 | tmp->send_delay_task = NULL; |
545 | } | 547 | } |
546 | GNUNET_free(tmp); | 548 | GNUNET_free (tmp); |
547 | return GNUNET_OK; | 549 | return GNUNET_OK; |
548 | } | 550 | } |
549 | 551 | ||
@@ -552,32 +554,32 @@ free_tmps(void *cls, | |||
552 | * Stop traffic manipulation | 554 | * Stop traffic manipulation |
553 | */ | 555 | */ |
554 | void | 556 | void |
555 | GST_manipulation_stop() | 557 | GST_manipulation_stop () |
556 | { | 558 | { |
557 | struct DelayQueueEntry *cur; | 559 | struct DelayQueueEntry *cur; |
558 | 560 | ||
559 | GNUNET_CONTAINER_multipeermap_iterate(peers, | 561 | GNUNET_CONTAINER_multipeermap_iterate (peers, |
560 | &free_tmps, | 562 | &free_tmps, |
561 | NULL); | 563 | NULL); |
562 | GNUNET_CONTAINER_multipeermap_destroy(peers); | 564 | GNUNET_CONTAINER_multipeermap_destroy (peers); |
563 | peers = NULL; | 565 | peers = NULL; |
564 | while (NULL != (cur = generic_dqe_head)) | 566 | while (NULL != (cur = generic_dqe_head)) |
565 | { | 567 | { |
566 | GNUNET_CONTAINER_DLL_remove(generic_dqe_head, | 568 | GNUNET_CONTAINER_DLL_remove (generic_dqe_head, |
567 | generic_dqe_tail, | 569 | generic_dqe_tail, |
568 | cur); | 570 | cur); |
569 | if (NULL != cur->cont) | 571 | if (NULL != cur->cont) |
570 | cur->cont(cur->cont_cls, | 572 | cur->cont (cur->cont_cls, |
571 | GNUNET_SYSERR, | 573 | GNUNET_SYSERR, |
572 | cur->msg_size, | 574 | cur->msg_size, |
573 | 0); | 575 | 0); |
574 | GNUNET_free(cur); | 576 | GNUNET_free (cur); |
575 | } | 577 | } |
576 | if (NULL != generic_send_delay_task) | 578 | if (NULL != generic_send_delay_task) |
577 | { | 579 | { |
578 | GNUNET_SCHEDULER_cancel(generic_send_delay_task); | 580 | GNUNET_SCHEDULER_cancel (generic_send_delay_task); |
579 | generic_send_delay_task = NULL; | 581 | generic_send_delay_task = NULL; |
580 | } | 582 | } |
581 | } | 583 | } |
582 | 584 | ||
583 | /* end of file gnunet-service-transport_manipulation.c */ | 585 | /* end of file gnunet-service-transport_manipulation.c */ |