summaryrefslogtreecommitdiff
path: root/src/transport/gnunet-service-transport_manipulation.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/transport/gnunet-service-transport_manipulation.c')
-rw-r--r--src/transport/gnunet-service-transport_manipulation.c478
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 */
39struct TM_Peer { 39struct 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 */
80struct DelayQueueEntry { 81struct 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 */
171void 173void
172GST_manipulation_set_metric(const struct TrafficMetricMessage *tm) 174GST_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 */
214static void 216static void
215send_delayed(void *cls) 217send_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 */
275void 277void
276GST_manipulation_send(const struct GNUNET_PeerIdentity *target, 278GST_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 */
352void 354void
353GST_manipulation_manipulate_metrics(const struct GNUNET_HELLO_Address *address, 355GST_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 */
377struct GNUNET_TIME_Relative 379struct GNUNET_TIME_Relative
378GST_manipulation_recv(void *cls, 380GST_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 */
412void 414void
413GST_manipulation_init() 415GST_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 */
453void 455void
454GST_manipulation_peer_disconnect(const struct GNUNET_PeerIdentity *peer) 456GST_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 */
517static int 519static int
518free_tmps(void *cls, 520free_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 */
554void 556void
555GST_manipulation_stop() 557GST_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 */