summaryrefslogtreecommitdiff
path: root/src/ats/test_ats_lib.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/ats/test_ats_lib.c')
-rw-r--r--src/ats/test_ats_lib.c1123
1 files changed, 569 insertions, 554 deletions
diff --git a/src/ats/test_ats_lib.c b/src/ats/test_ats_lib.c
index 33597e678..979dbde3e 100644
--- a/src/ats/test_ats_lib.c
+++ b/src/ats/test_ats_lib.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file ats/test_ats_lib.c 21 * @file ats/test_ats_lib.c
22 * @brief test ATS library with a generic interpreter for running ATS tests 22 * @brief test ATS library with a generic interpreter for running ATS tests
@@ -31,8 +31,7 @@
31/** 31/**
32 * Information about the last address suggestion we got for a peer. 32 * Information about the last address suggestion we got for a peer.
33 */ 33 */
34struct AddressSuggestData 34struct AddressSuggestData {
35{
36 /** 35 /**
37 * Which session were we given? 36 * Which session were we given?
38 */ 37 */
@@ -63,8 +62,7 @@ struct AddressSuggestData
63/** 62/**
64 * Information about the last address information we got for an address. 63 * Information about the last address information we got for an address.
65 */ 64 */
66struct AddressInformationData 65struct AddressInformationData {
67{
68 /** 66 /**
69 * What address is this data about? 67 * What address is this data about?
70 */ 68 */
@@ -156,18 +154,18 @@ static struct Command *test_commands;
156 * @return #GNUNET_OK (continue to iterate) 154 * @return #GNUNET_OK (continue to iterate)
157 */ 155 */
158static int 156static int
159free_asd (void *cls, 157free_asd(void *cls,
160 const struct GNUNET_PeerIdentity *key, 158 const struct GNUNET_PeerIdentity *key,
161 void *value) 159 void *value)
162{ 160{
163 struct AddressSuggestData *asd = value; 161 struct AddressSuggestData *asd = value;
164 162
165 GNUNET_assert (GNUNET_YES == 163 GNUNET_assert(GNUNET_YES ==
166 GNUNET_CONTAINER_multipeermap_remove (p2asd, 164 GNUNET_CONTAINER_multipeermap_remove(p2asd,
167 key, 165 key,
168 asd)); 166 asd));
169 GNUNET_free_non_null (asd->address); 167 GNUNET_free_non_null(asd->address);
170 GNUNET_free (asd); 168 GNUNET_free(asd);
171 return GNUNET_OK; 169 return GNUNET_OK;
172} 170}
173 171
@@ -181,18 +179,18 @@ free_asd (void *cls,
181 * @return #GNUNET_OK (continue to iterate) 179 * @return #GNUNET_OK (continue to iterate)
182 */ 180 */
183static int 181static int
184free_aid (void *cls, 182free_aid(void *cls,
185 const struct GNUNET_PeerIdentity *key, 183 const struct GNUNET_PeerIdentity *key,
186 void *value) 184 void *value)
187{ 185{
188 struct AddressInformationData *aid = value; 186 struct AddressInformationData *aid = value;
189 187
190 GNUNET_assert (GNUNET_YES == 188 GNUNET_assert(GNUNET_YES ==
191 GNUNET_CONTAINER_multipeermap_remove (p2aid, 189 GNUNET_CONTAINER_multipeermap_remove(p2aid,
192 key, 190 key,
193 aid)); 191 aid));
194 GNUNET_free (aid->address); 192 GNUNET_free(aid->address);
195 GNUNET_free (aid); 193 GNUNET_free(aid);
196 return GNUNET_OK; 194 return GNUNET_OK;
197} 195}
198 196
@@ -204,18 +202,17 @@ free_aid (void *cls,
204 * @return NULL if peer was never involved 202 * @return NULL if peer was never involved
205 */ 203 */
206static struct AddressSuggestData * 204static struct AddressSuggestData *
207find_address_suggestion (const struct GNUNET_PeerIdentity *pid) 205find_address_suggestion(const struct GNUNET_PeerIdentity *pid)
208{ 206{
209 return GNUNET_CONTAINER_multipeermap_get (p2asd, 207 return GNUNET_CONTAINER_multipeermap_get(p2asd,
210 pid); 208 pid);
211} 209}
212 210
213 211
214/** 212/**
215 * Closure for #match_address() 213 * Closure for #match_address()
216 */ 214 */
217struct MatchAddressContext 215struct MatchAddressContext {
218{
219 /** 216 /**
220 * Address to find. 217 * Address to find.
221 */ 218 */
@@ -237,19 +234,19 @@ struct MatchAddressContext
237 * @return #GNUNET_OK if not found 234 * @return #GNUNET_OK if not found
238 */ 235 */
239static int 236static int
240match_address (void *cls, 237match_address(void *cls,
241 const struct GNUNET_PeerIdentity *key, 238 const struct GNUNET_PeerIdentity *key,
242 void *value) 239 void *value)
243{ 240{
244 struct MatchAddressContext *mac = cls; 241 struct MatchAddressContext *mac = cls;
245 struct AddressInformationData *aid = value; 242 struct AddressInformationData *aid = value;
246 243
247 if (0 == GNUNET_HELLO_address_cmp (mac->addr, 244 if (0 == GNUNET_HELLO_address_cmp(mac->addr,
248 aid->address)) 245 aid->address))
249 { 246 {
250 mac->ret = aid; 247 mac->ret = aid;
251 return GNUNET_NO; 248 return GNUNET_NO;
252 } 249 }
253 return GNUNET_OK; 250 return GNUNET_OK;
254} 251}
255 252
@@ -261,16 +258,16 @@ match_address (void *cls,
261 * @return NULL if peer was never involved 258 * @return NULL if peer was never involved
262 */ 259 */
263static struct AddressInformationData * 260static struct AddressInformationData *
264find_address_information (const struct GNUNET_HELLO_Address *addr) 261find_address_information(const struct GNUNET_HELLO_Address *addr)
265{ 262{
266 struct MatchAddressContext mac; 263 struct MatchAddressContext mac;
267 264
268 mac.ret = NULL; 265 mac.ret = NULL;
269 mac.addr = addr; 266 mac.addr = addr;
270 GNUNET_CONTAINER_multipeermap_get_multiple (p2aid, 267 GNUNET_CONTAINER_multipeermap_get_multiple(p2aid,
271 &addr->peer, 268 &addr->peer,
272 &match_address, 269 &match_address,
273 &mac); 270 &mac);
274 return mac.ret; 271 return mac.ret;
275} 272}
276 273
@@ -281,51 +278,51 @@ find_address_information (const struct GNUNET_HELLO_Address *addr)
281 * @param cls NULL 278 * @param cls NULL
282 */ 279 */
283static void 280static void
284end (void *cls) 281end(void *cls)
285{ 282{
286 if (0 != ret) 283 if (0 != ret)
287 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 284 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
288 "Test failed at stage %u %s\n", 285 "Test failed at stage %u %s\n",
289 off, 286 off,
290 (NULL != test_commands[off].label) 287 (NULL != test_commands[off].label)
291 ? test_commands[off].label 288 ? test_commands[off].label
292 : ""); 289 : "");
293 if (NULL != interpreter_task) 290 if (NULL != interpreter_task)
294 { 291 {
295 GNUNET_SCHEDULER_cancel (interpreter_task); 292 GNUNET_SCHEDULER_cancel(interpreter_task);
296 interpreter_task = NULL; 293 interpreter_task = NULL;
297 } 294 }
298 if (NULL != sched_ats) 295 if (NULL != sched_ats)
299 { 296 {
300 GNUNET_ATS_scheduling_done (sched_ats); 297 GNUNET_ATS_scheduling_done(sched_ats);
301 sched_ats = NULL; 298 sched_ats = NULL;
302 } 299 }
303 if (NULL != con_ats) 300 if (NULL != con_ats)
304 { 301 {
305 GNUNET_ATS_connectivity_done (con_ats); 302 GNUNET_ATS_connectivity_done(con_ats);
306 con_ats = NULL; 303 con_ats = NULL;
307 } 304 }
308 if (NULL != perf_ats) 305 if (NULL != perf_ats)
309 { 306 {
310 GNUNET_ATS_performance_done (perf_ats); 307 GNUNET_ATS_performance_done(perf_ats);
311 perf_ats = NULL; 308 perf_ats = NULL;
312 } 309 }
313 if (NULL != p2asd) 310 if (NULL != p2asd)
314 { 311 {
315 GNUNET_CONTAINER_multipeermap_iterate (p2asd, 312 GNUNET_CONTAINER_multipeermap_iterate(p2asd,
316 &free_asd, 313 &free_asd,
317 NULL); 314 NULL);
318 GNUNET_CONTAINER_multipeermap_destroy (p2asd); 315 GNUNET_CONTAINER_multipeermap_destroy(p2asd);
319 p2asd = NULL; 316 p2asd = NULL;
320 } 317 }
321 if (NULL != p2aid) 318 if (NULL != p2aid)
322 { 319 {
323 GNUNET_CONTAINER_multipeermap_iterate (p2aid, 320 GNUNET_CONTAINER_multipeermap_iterate(p2aid,
324 &free_aid, 321 &free_aid,
325 NULL); 322 NULL);
326 GNUNET_CONTAINER_multipeermap_destroy (p2aid); 323 GNUNET_CONTAINER_multipeermap_destroy(p2aid);
327 p2aid = NULL; 324 p2aid = NULL;
328 } 325 }
329} 326}
330 327
331 328
@@ -335,19 +332,19 @@ end (void *cls)
335 * @param cls NULL 332 * @param cls NULL
336 */ 333 */
337static void 334static void
338interpreter (void *cls); 335interpreter(void *cls);
339 336
340 337
341/** 338/**
342 * Run the interpreter next. 339 * Run the interpreter next.
343 */ 340 */
344static void 341static void
345run_interpreter () 342run_interpreter()
346{ 343{
347 if (NULL != interpreter_task) 344 if (NULL != interpreter_task)
348 GNUNET_SCHEDULER_cancel (interpreter_task); 345 GNUNET_SCHEDULER_cancel(interpreter_task);
349 interpreter_task = GNUNET_SCHEDULER_add_now (&interpreter, 346 interpreter_task = GNUNET_SCHEDULER_add_now(&interpreter,
350 NULL); 347 NULL);
351} 348}
352 349
353 350
@@ -358,15 +355,15 @@ run_interpreter ()
358 * @param pk resulting fake public key 355 * @param pk resulting fake public key
359 */ 356 */
360static void 357static void
361make_peer (uint32_t pid, 358make_peer(uint32_t pid,
362 struct GNUNET_PeerIdentity *pk) 359 struct GNUNET_PeerIdentity *pk)
363{ 360{
364 memset (pk, 361 memset(pk,
365 (int) pid, 362 (int)pid,
366 sizeof (struct GNUNET_PeerIdentity)); 363 sizeof(struct GNUNET_PeerIdentity));
367 GNUNET_memcpy (pk, 364 GNUNET_memcpy(pk,
368 &pid, 365 &pid,
369 sizeof (uint32_t)); 366 sizeof(uint32_t));
370} 367}
371 368
372 369
@@ -379,29 +376,28 @@ make_peer (uint32_t pid,
379 * @return the address 376 * @return the address
380 */ 377 */
381static struct GNUNET_HELLO_Address * 378static struct GNUNET_HELLO_Address *
382make_address (uint32_t pid, 379make_address(uint32_t pid,
383 uint32_t num, 380 uint32_t num,
384 enum GNUNET_HELLO_AddressInfo addr_flags) 381 enum GNUNET_HELLO_AddressInfo addr_flags)
385{ 382{
386 struct GNUNET_PeerIdentity pk; 383 struct GNUNET_PeerIdentity pk;
387 uint32_t nbo; 384 uint32_t nbo;
388 385
389 nbo = htonl (num); 386 nbo = htonl(num);
390 make_peer (pid, 387 make_peer(pid,
391 &pk); 388 &pk);
392 return GNUNET_HELLO_address_allocate (&pk, 389 return GNUNET_HELLO_address_allocate(&pk,
393 "test", 390 "test",
394 &nbo, 391 &nbo,
395 sizeof (nbo), 392 sizeof(nbo),
396 addr_flags); 393 addr_flags);
397} 394}
398 395
399 396
400/** 397/**
401 * Our dummy sessions. 398 * Our dummy sessions.
402 */ 399 */
403struct GNUNET_ATS_Session 400struct GNUNET_ATS_Session {
404{
405 /** 401 /**
406 * Field to avoid `0 == sizeof(struct GNUNET_ATS_Session)`. 402 * Field to avoid `0 == sizeof(struct GNUNET_ATS_Session)`.
407 */ 403 */
@@ -416,7 +412,7 @@ struct GNUNET_ATS_Session
416 * @return NULL if @a i is 0, otherwise a pointer unique to @a i 412 * @return NULL if @a i is 0, otherwise a pointer unique to @a i
417 */ 413 */
418static struct GNUNET_ATS_Session * 414static struct GNUNET_ATS_Session *
419make_session (unsigned int i) 415make_session(unsigned int i)
420{ 416{
421 struct GNUNET_ATS_Session *baseptr = NULL; 417 struct GNUNET_ATS_Session *baseptr = NULL;
422 418
@@ -438,19 +434,19 @@ make_session (unsigned int i)
438 * @return previous command with the matching label 434 * @return previous command with the matching label
439 */ 435 */
440static struct Command * 436static struct Command *
441find_command (enum CommandCode code, 437find_command(enum CommandCode code,
442 const char *label) 438 const char *label)
443{ 439{
444 int i; 440 int i;
445 441
446 if (NULL == label) 442 if (NULL == label)
447 return NULL; 443 return NULL;
448 for (i=off-1;i>=0;i--) 444 for (i = off - 1; i >= 0; i--)
449 if ( (code == test_commands[i].code) && 445 if ((code == test_commands[i].code) &&
450 (0 == strcmp (test_commands[i].label, 446 (0 == strcmp(test_commands[i].label,
451 label)) ) 447 label)))
452 return &test_commands[i]; 448 return &test_commands[i];
453 GNUNET_break (0); 449 GNUNET_break(0);
454 return NULL; 450 return NULL;
455} 451}
456 452
@@ -470,51 +466,53 @@ find_command (enum CommandCode code,
470 * @param prop performance data for the address 466 * @param prop performance data for the address
471 */ 467 */
472static void 468static void
473info_cb (void *cls, 469info_cb(void *cls,
474 const struct GNUNET_HELLO_Address *address, 470 const struct GNUNET_HELLO_Address *address,
475 int address_active, 471 int address_active,
476 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, 472 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
477 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, 473 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
478 const struct GNUNET_ATS_Properties *prop) 474 const struct GNUNET_ATS_Properties *prop)
479{ 475{
480 struct Command *c = cls; 476 struct Command *c = cls;
481 struct CommandListAddresses *cmd = &c->details.list_addresses; 477 struct CommandListAddresses *cmd = &c->details.list_addresses;
482 478
483 if (NULL == address) 479 if (NULL == address)
484 {
485 cmd->alh = NULL;
486 /* we are done with the iteration, continue to execute */
487 if ( (cmd->calls < cmd->min_calls) &&
488 (cmd->active_calls < cmd->min_active_calls) )
489 { 480 {
490 GNUNET_SCHEDULER_shutdown (); 481 cmd->alh = NULL;
482 /* we are done with the iteration, continue to execute */
483 if ((cmd->calls < cmd->min_calls) &&
484 (cmd->active_calls < cmd->min_active_calls))
485 {
486 GNUNET_SCHEDULER_shutdown();
487 return;
488 }
489 off++;
490 run_interpreter();
491 return; 491 return;
492 } 492 }
493 off++;
494 run_interpreter ();
495 return;
496 }
497 switch (address_active) 493 switch (address_active)
498 { 494 {
499 case GNUNET_YES: 495 case GNUNET_YES:
500 cmd->active_calls++; 496 cmd->active_calls++;
501 cmd->calls++; 497 cmd->calls++;
502 break; 498 break;
503 case GNUNET_NO: 499
504 cmd->calls++; 500 case GNUNET_NO:
505 break; 501 cmd->calls++;
506 case GNUNET_SYSERR: 502 break;
507 return; 503
508 } 504 case GNUNET_SYSERR:
509 if ( (cmd->calls > cmd->max_calls) && 505 return;
510 (cmd->active_calls < cmd->max_active_calls) ) 506 }
511 { 507 if ((cmd->calls > cmd->max_calls) &&
512 GNUNET_break (0); 508 (cmd->active_calls < cmd->max_active_calls))
513 GNUNET_ATS_performance_list_addresses_cancel (cmd->alh); 509 {
514 cmd->alh = NULL; 510 GNUNET_break(0);
515 GNUNET_SCHEDULER_shutdown (); 511 GNUNET_ATS_performance_list_addresses_cancel(cmd->alh);
516 return; 512 cmd->alh = NULL;
517 } 513 GNUNET_SCHEDULER_shutdown();
514 return;
515 }
518} 516}
519 517
520 518
@@ -529,56 +527,58 @@ info_cb (void *cls,
529 * long should the client wait until re-trying? 527 * long should the client wait until re-trying?
530 */ 528 */
531static void 529static void
532reservation_cb (void *cls, 530reservation_cb(void *cls,
533 const struct GNUNET_PeerIdentity *peer, 531 const struct GNUNET_PeerIdentity *peer,
534 int32_t amount, 532 int32_t amount,
535 struct GNUNET_TIME_Relative res_delay) 533 struct GNUNET_TIME_Relative res_delay)
536{ 534{
537 struct Command *cmd = cls; 535 struct Command *cmd = cls;
538 struct GNUNET_PeerIdentity pid; 536 struct GNUNET_PeerIdentity pid;
539 537
540 cmd->details.reserve_bandwidth.rc = NULL; 538 cmd->details.reserve_bandwidth.rc = NULL;
541 make_peer (cmd->details.reserve_bandwidth.pid, 539 make_peer(cmd->details.reserve_bandwidth.pid,
542 &pid); 540 &pid);
543 GNUNET_assert (0 == GNUNET_memcmp (peer, 541 GNUNET_assert(0 == GNUNET_memcmp(peer,
544 &pid)); 542 &pid));
545 switch (cmd->details.reserve_bandwidth.expected_result) 543 switch (cmd->details.reserve_bandwidth.expected_result)
546 {
547 case GNUNET_OK:
548 if (amount != cmd->details.reserve_bandwidth.amount)
549 {
550 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
551 "Unexpectedly failed to reserve %d/%d bytes with delay %s!\n",
552 (int) amount,
553 (int) cmd->details.reserve_bandwidth.amount,
554 GNUNET_STRINGS_relative_time_to_string (res_delay,
555 GNUNET_YES));
556 GNUNET_break (0);
557 GNUNET_SCHEDULER_shutdown ();
558 return;
559 }
560 break;
561 case GNUNET_NO:
562 GNUNET_break ( (0 != amount) ||
563 (0 != res_delay.rel_value_us) );
564 break;
565 case GNUNET_SYSERR:
566 if ( (amount != 0) ||
567 (0 == res_delay.rel_value_us) )
568 { 544 {
569 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 545 case GNUNET_OK:
570 "Unexpectedly reserved %d bytes with delay %s!\n", 546 if (amount != cmd->details.reserve_bandwidth.amount)
571 (int) amount, 547 {
572 GNUNET_STRINGS_relative_time_to_string (res_delay, 548 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
573 GNUNET_YES)); 549 "Unexpectedly failed to reserve %d/%d bytes with delay %s!\n",
574 GNUNET_break (0); 550 (int)amount,
575 GNUNET_SCHEDULER_shutdown (); 551 (int)cmd->details.reserve_bandwidth.amount,
576 return; 552 GNUNET_STRINGS_relative_time_to_string(res_delay,
553 GNUNET_YES));
554 GNUNET_break(0);
555 GNUNET_SCHEDULER_shutdown();
556 return;
557 }
558 break;
559
560 case GNUNET_NO:
561 GNUNET_break((0 != amount) ||
562 (0 != res_delay.rel_value_us));
563 break;
564
565 case GNUNET_SYSERR:
566 if ((amount != 0) ||
567 (0 == res_delay.rel_value_us))
568 {
569 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
570 "Unexpectedly reserved %d bytes with delay %s!\n",
571 (int)amount,
572 GNUNET_STRINGS_relative_time_to_string(res_delay,
573 GNUNET_YES));
574 GNUNET_break(0);
575 GNUNET_SCHEDULER_shutdown();
576 return;
577 }
578 break;
577 } 579 }
578 break;
579 }
580 off++; 580 off++;
581 run_interpreter (); 581 run_interpreter();
582} 582}
583 583
584 584
@@ -588,282 +588,297 @@ reservation_cb (void *cls,
588 * @param cls NULL 588 * @param cls NULL
589 */ 589 */
590static void 590static void
591interpreter (void *cls) 591interpreter(void *cls)
592 592
593{ 593{
594 struct Command *cmd; 594 struct Command *cmd;
595 595
596 interpreter_task = NULL; 596 interpreter_task = NULL;
597 while (1) 597 while (1)
598 {
599 cmd = &test_commands[off];
600 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
601 "#%u: %d %s\n",
602 off,
603 (int) cmd->code,
604 (NULL != cmd->label) ? cmd->label : "");
605 switch (cmd->code)
606 { 598 {
607 case CMD_END_PASS: 599 cmd = &test_commands[off];
608 ret = 0; 600 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
609 GNUNET_SCHEDULER_shutdown (); 601 "#%u: %d %s\n",
610 return; 602 off,
611 case CMD_ADD_ADDRESS: 603 (int)cmd->code,
612 { 604 (NULL != cmd->label) ? cmd->label : "");
613 struct GNUNET_HELLO_Address *addr; 605 switch (cmd->code)
614 struct GNUNET_ATS_Session *session; 606 {
615 607 case CMD_END_PASS:
616 addr = make_address (cmd->details.add_address.pid, 608 ret = 0;
617 cmd->details.add_address.addr_num, 609 GNUNET_SCHEDULER_shutdown();
618 cmd->details.add_address.addr_flags); 610 return;
619 session = make_session (cmd->details.add_address.session); 611
620 if (cmd->details.add_address.expect_fail) 612 case CMD_ADD_ADDRESS:
621 GNUNET_log_skip (1, GNUNET_NO);
622 cmd->details.add_address.ar
623 = GNUNET_ATS_address_add (sched_ats,
624 addr,
625 session,
626 &cmd->details.add_address.properties);
627 GNUNET_free (addr);
628 if (cmd->details.add_address.expect_fail)
629 { 613 {
630 GNUNET_log_skip (0, GNUNET_YES); 614 struct GNUNET_HELLO_Address *addr;
615 struct GNUNET_ATS_Session *session;
616
617 addr = make_address(cmd->details.add_address.pid,
618 cmd->details.add_address.addr_num,
619 cmd->details.add_address.addr_flags);
620 session = make_session(cmd->details.add_address.session);
621 if (cmd->details.add_address.expect_fail)
622 GNUNET_log_skip(1, GNUNET_NO);
623 cmd->details.add_address.ar
624 = GNUNET_ATS_address_add(sched_ats,
625 addr,
626 session,
627 &cmd->details.add_address.properties);
628 GNUNET_free(addr);
629 if (cmd->details.add_address.expect_fail)
630 {
631 GNUNET_log_skip(0, GNUNET_YES);
632 }
633 else if (NULL == cmd->details.add_address.ar)
634 {
635 GNUNET_break(0);
636 GNUNET_SCHEDULER_shutdown();
637 return;
638 }
639 off++;
640 break;
631 } 641 }
632 else if (NULL == cmd->details.add_address.ar) 642
643 case CMD_DEL_ADDRESS:
633 { 644 {
634 GNUNET_break (0); 645 struct Command *add;
635 GNUNET_SCHEDULER_shutdown (); 646
636 return; 647 add = find_command(CMD_ADD_ADDRESS,
648 cmd->details.del_address.add_label);
649 GNUNET_assert(NULL != add->details.add_address.ar);
650 GNUNET_ATS_address_destroy(add->details.add_address.ar);
651 add->details.add_address.ar = NULL;
652 off++;
653 break;
637 } 654 }
638 off++; 655
639 break; 656 case CMD_AWAIT_ADDRESS_SUGGESTION:
640 }
641 case CMD_DEL_ADDRESS:
642 {
643 struct Command *add;
644
645 add = find_command (CMD_ADD_ADDRESS,
646 cmd->details.del_address.add_label);
647 GNUNET_assert (NULL != add->details.add_address.ar);
648 GNUNET_ATS_address_destroy (add->details.add_address.ar);
649 add->details.add_address.ar = NULL;
650 off++;
651 break;
652 }
653 case CMD_AWAIT_ADDRESS_SUGGESTION:
654 {
655 struct GNUNET_PeerIdentity pid;
656 struct GNUNET_HELLO_Address *addr;
657 struct Command *add;
658 struct AddressSuggestData *asd;
659 int done;
660
661 make_peer (cmd->details.await_address_suggestion.pid,
662 &pid);
663 asd = find_address_suggestion (&pid);
664 if (NULL == asd)
665 return;
666 if (GNUNET_NO == asd->active)
667 return; /* last suggestion was to disconnect, wait longer */
668 done = GNUNET_YES;
669 if (NULL != cmd->details.await_address_suggestion.add_label)
670 { 657 {
671 done = GNUNET_NO; 658 struct GNUNET_PeerIdentity pid;
672 add = find_command (CMD_ADD_ADDRESS, 659 struct GNUNET_HELLO_Address *addr;
673 cmd->details.await_address_suggestion.add_label); 660 struct Command *add;
674 addr = make_address (add->details.add_address.pid, 661 struct AddressSuggestData *asd;
675 add->details.add_address.addr_num, 662 int done;
676 add->details.add_address.addr_flags); 663
677 if ( (asd->session == 664 make_peer(cmd->details.await_address_suggestion.pid,
678 make_session (add->details.add_address.session)) && 665 &pid);
679 (0 == 666 asd = find_address_suggestion(&pid);
680 GNUNET_HELLO_address_cmp (addr, 667 if (NULL == asd)
681 asd->address)) ) 668 return;
682 done = GNUNET_YES; 669 if (GNUNET_NO == asd->active)
683 GNUNET_free (addr); 670 return; /* last suggestion was to disconnect, wait longer */
671 done = GNUNET_YES;
672 if (NULL != cmd->details.await_address_suggestion.add_label)
673 {
674 done = GNUNET_NO;
675 add = find_command(CMD_ADD_ADDRESS,
676 cmd->details.await_address_suggestion.add_label);
677 addr = make_address(add->details.add_address.pid,
678 add->details.add_address.addr_num,
679 add->details.add_address.addr_flags);
680 if ((asd->session ==
681 make_session(add->details.add_address.session)) &&
682 (0 ==
683 GNUNET_HELLO_address_cmp(addr,
684 asd->address)))
685 done = GNUNET_YES;
686 GNUNET_free(addr);
687 }
688 if (GNUNET_NO == done)
689 return;
690 off++;
691 break;
684 } 692 }
685 if (GNUNET_NO == done) 693
686 return; 694 case CMD_AWAIT_DISCONNECT_SUGGESTION:
687 off++;
688 break;
689 }
690 case CMD_AWAIT_DISCONNECT_SUGGESTION:
691 {
692 struct GNUNET_PeerIdentity pid;
693 struct AddressSuggestData *asd;
694
695 make_peer (cmd->details.await_disconnect_suggestion.pid,
696 &pid);
697 asd = find_address_suggestion (&pid);
698 if (NULL == asd)
699 return; /* odd, no suggestion at all yet!? */
700 if (GNUNET_YES == asd->active)
701 return; /* last suggestion was to activate, wait longer */
702 /* last suggestion was to deactivate, condition satisfied! */
703 off++;
704 break;
705 }
706 case CMD_REQUEST_CONNECTION_START:
707 {
708 struct GNUNET_PeerIdentity pid;
709
710 make_peer (cmd->details.request_connection_start.pid,
711 &pid);
712 cmd->details.request_connection_start.csh
713 = GNUNET_ATS_connectivity_suggest (con_ats,
714 &pid,
715 1);
716 off++;
717 break;
718 }
719 case CMD_REQUEST_CONNECTION_STOP:
720 {
721 struct Command *start;
722
723 start = find_command (CMD_REQUEST_CONNECTION_START,
724 cmd->details.request_connection_stop.connect_label);
725 GNUNET_ATS_connectivity_suggest_cancel (start->details.request_connection_start.csh);
726 start->details.request_connection_start.csh = NULL;
727 off++;
728 break;
729 }
730 case CMD_AWAIT_ADDRESS_INFORMATION:
731 {
732 struct AddressInformationData *aid;
733 struct Command *add;
734 struct Command *update;
735 struct GNUNET_HELLO_Address *addr;
736 const struct GNUNET_ATS_Properties *cmp;
737
738 add = find_command (CMD_ADD_ADDRESS,
739 cmd->details.await_address_information.add_label);
740 update = find_command (CMD_UPDATE_ADDRESS,
741 cmd->details.await_address_information.update_label);
742 addr = make_address (add->details.add_address.pid,
743 add->details.add_address.addr_num,
744 add->details.add_address.addr_flags);
745 aid = find_address_information (addr);
746 GNUNET_free (addr);
747 if (NULL == update)
748 cmp = &add->details.add_address.properties;
749 else
750 cmp = &update->details.update_address.properties;
751 if ( (NULL != aid) &&
752 (cmp->delay.rel_value_us == aid->properties.delay.rel_value_us) &&
753 (cmp->utilization_out == aid->properties.utilization_out) &&
754 (cmp->utilization_in == aid->properties.utilization_in) &&
755 (cmp->distance == aid->properties.distance) &&
756 (cmp->scope == aid->properties.scope) )
757 { 695 {
696 struct GNUNET_PeerIdentity pid;
697 struct AddressSuggestData *asd;
698
699 make_peer(cmd->details.await_disconnect_suggestion.pid,
700 &pid);
701 asd = find_address_suggestion(&pid);
702 if (NULL == asd)
703 return; /* odd, no suggestion at all yet!? */
704 if (GNUNET_YES == asd->active)
705 return; /* last suggestion was to activate, wait longer */
706 /* last suggestion was to deactivate, condition satisfied! */
758 off++; 707 off++;
759 break; 708 break;
760 } 709 }
761 return; 710
762 } 711 case CMD_REQUEST_CONNECTION_START:
763 case CMD_UPDATE_ADDRESS: 712 {
764 { 713 struct GNUNET_PeerIdentity pid;
765 struct Command *add; 714
766 715 make_peer(cmd->details.request_connection_start.pid,
767 add = find_command (CMD_ADD_ADDRESS, 716 &pid);
768 cmd->details.update_address.add_label); 717 cmd->details.request_connection_start.csh
769 GNUNET_assert (NULL != add->details.add_address.ar); 718 = GNUNET_ATS_connectivity_suggest(con_ats,
770 GNUNET_ATS_address_update (add->details.add_address.ar,
771 &cmd->details.update_address.properties);
772 off++;
773 break;
774 }
775 case CMD_ADD_SESSION:
776 {
777 struct Command *add;
778 struct GNUNET_ATS_Session *session;
779
780 add = find_command (CMD_ADD_ADDRESS,
781 cmd->details.add_session.add_label);
782 session = make_session (cmd->details.add_session.session);
783 GNUNET_assert (NULL != add->details.add_address.ar);
784 GNUNET_ATS_address_add_session (add->details.add_address.ar,
785 session);
786 off++;
787 break;
788 }
789 case CMD_DEL_SESSION:
790 {
791 struct Command *add_address;
792 struct Command *add_session;
793 struct GNUNET_ATS_Session *session;
794
795 add_session = find_command (CMD_ADD_SESSION,
796 cmd->details.del_session.add_session_label);
797 add_address = find_command (CMD_ADD_ADDRESS,
798 add_session->details.add_session.add_label);
799 GNUNET_assert (NULL != add_address->details.add_address.ar);
800 session = make_session (add_session->details.add_session.session);
801 GNUNET_ATS_address_del_session (add_address->details.add_address.ar,
802 session);
803 off++;
804 break;
805 }
806 case CMD_CHANGE_PREFERENCE:
807 {
808 struct GNUNET_PeerIdentity pid;
809
810 make_peer (cmd->details.change_preference.pid,
811 &pid);
812 GNUNET_ATS_performance_change_preference (perf_ats,
813 &pid,
814 GNUNET_ATS_PREFERENCE_END);
815 off++;
816 break;
817 }
818 case CMD_PROVIDE_FEEDBACK:
819 {
820 struct GNUNET_PeerIdentity pid;
821
822 make_peer (cmd->details.provide_feedback.pid,
823 &pid);
824 GNUNET_ATS_performance_give_feedback (perf_ats,
825 &pid, 719 &pid,
826 cmd->details.provide_feedback.scope, 720 1);
827 GNUNET_ATS_PREFERENCE_END); 721 off++;
828 off++; 722 break;
829 break; 723 }
830 } 724
831 case CMD_LIST_ADDRESSES: 725 case CMD_REQUEST_CONNECTION_STOP:
832 { 726 {
833 struct GNUNET_PeerIdentity pid; 727 struct Command *start;
834 728
835 make_peer (cmd->details.list_addresses.pid, 729 start = find_command(CMD_REQUEST_CONNECTION_START,
836 &pid); 730 cmd->details.request_connection_stop.connect_label);
837 cmd->details.list_addresses.alh 731 GNUNET_ATS_connectivity_suggest_cancel(start->details.request_connection_start.csh);
838 = GNUNET_ATS_performance_list_addresses (perf_ats, 732 start->details.request_connection_start.csh = NULL;
733 off++;
734 break;
735 }
736
737 case CMD_AWAIT_ADDRESS_INFORMATION:
738 {
739 struct AddressInformationData *aid;
740 struct Command *add;
741 struct Command *update;
742 struct GNUNET_HELLO_Address *addr;
743 const struct GNUNET_ATS_Properties *cmp;
744
745 add = find_command(CMD_ADD_ADDRESS,
746 cmd->details.await_address_information.add_label);
747 update = find_command(CMD_UPDATE_ADDRESS,
748 cmd->details.await_address_information.update_label);
749 addr = make_address(add->details.add_address.pid,
750 add->details.add_address.addr_num,
751 add->details.add_address.addr_flags);
752 aid = find_address_information(addr);
753 GNUNET_free(addr);
754 if (NULL == update)
755 cmp = &add->details.add_address.properties;
756 else
757 cmp = &update->details.update_address.properties;
758 if ((NULL != aid) &&
759 (cmp->delay.rel_value_us == aid->properties.delay.rel_value_us) &&
760 (cmp->utilization_out == aid->properties.utilization_out) &&
761 (cmp->utilization_in == aid->properties.utilization_in) &&
762 (cmp->distance == aid->properties.distance) &&
763 (cmp->scope == aid->properties.scope))
764 {
765 off++;
766 break;
767 }
768 return;
769 }
770
771 case CMD_UPDATE_ADDRESS:
772 {
773 struct Command *add;
774
775 add = find_command(CMD_ADD_ADDRESS,
776 cmd->details.update_address.add_label);
777 GNUNET_assert(NULL != add->details.add_address.ar);
778 GNUNET_ATS_address_update(add->details.add_address.ar,
779 &cmd->details.update_address.properties);
780 off++;
781 break;
782 }
783
784 case CMD_ADD_SESSION:
785 {
786 struct Command *add;
787 struct GNUNET_ATS_Session *session;
788
789 add = find_command(CMD_ADD_ADDRESS,
790 cmd->details.add_session.add_label);
791 session = make_session(cmd->details.add_session.session);
792 GNUNET_assert(NULL != add->details.add_address.ar);
793 GNUNET_ATS_address_add_session(add->details.add_address.ar,
794 session);
795 off++;
796 break;
797 }
798
799 case CMD_DEL_SESSION:
800 {
801 struct Command *add_address;
802 struct Command *add_session;
803 struct GNUNET_ATS_Session *session;
804
805 add_session = find_command(CMD_ADD_SESSION,
806 cmd->details.del_session.add_session_label);
807 add_address = find_command(CMD_ADD_ADDRESS,
808 add_session->details.add_session.add_label);
809 GNUNET_assert(NULL != add_address->details.add_address.ar);
810 session = make_session(add_session->details.add_session.session);
811 GNUNET_ATS_address_del_session(add_address->details.add_address.ar,
812 session);
813 off++;
814 break;
815 }
816
817 case CMD_CHANGE_PREFERENCE:
818 {
819 struct GNUNET_PeerIdentity pid;
820
821 make_peer(cmd->details.change_preference.pid,
822 &pid);
823 GNUNET_ATS_performance_change_preference(perf_ats,
839 &pid, 824 &pid,
840 cmd->details.list_addresses.all, 825 GNUNET_ATS_PREFERENCE_END);
841 &info_cb, 826 off++;
842 cmd); 827 break;
843 return; 828 }
844 } 829
845 case CMD_RESERVE_BANDWIDTH: 830 case CMD_PROVIDE_FEEDBACK:
846 { 831 {
847 struct GNUNET_PeerIdentity pid; 832 struct GNUNET_PeerIdentity pid;
848 833
849 make_peer (cmd->details.reserve_bandwidth.pid, 834 make_peer(cmd->details.provide_feedback.pid,
850 &pid); 835 &pid);
851 cmd->details.reserve_bandwidth.rc 836 GNUNET_ATS_performance_give_feedback(perf_ats,
852 = GNUNET_ATS_reserve_bandwidth (perf_ats, 837 &pid,
853 &pid, 838 cmd->details.provide_feedback.scope,
854 cmd->details.reserve_bandwidth.amount, 839 GNUNET_ATS_PREFERENCE_END);
855 &reservation_cb, 840 off++;
856 cmd); 841 break;
857 return; 842 }
858 } 843
859 case CMD_SLEEP: 844 case CMD_LIST_ADDRESSES:
860 off++; 845 {
861 interpreter_task = GNUNET_SCHEDULER_add_delayed (cmd->details.sleep.delay, 846 struct GNUNET_PeerIdentity pid;
862 &interpreter, 847
863 NULL); 848 make_peer(cmd->details.list_addresses.pid,
864 return; 849 &pid);
865 } /* end switch */ 850 cmd->details.list_addresses.alh
866 } /* end while(1) */ 851 = GNUNET_ATS_performance_list_addresses(perf_ats,
852 &pid,
853 cmd->details.list_addresses.all,
854 &info_cb,
855 cmd);
856 return;
857 }
858
859 case CMD_RESERVE_BANDWIDTH:
860 {
861 struct GNUNET_PeerIdentity pid;
862
863 make_peer(cmd->details.reserve_bandwidth.pid,
864 &pid);
865 cmd->details.reserve_bandwidth.rc
866 = GNUNET_ATS_reserve_bandwidth(perf_ats,
867 &pid,
868 cmd->details.reserve_bandwidth.amount,
869 &reservation_cb,
870 cmd);
871 return;
872 }
873
874 case CMD_SLEEP:
875 off++;
876 interpreter_task = GNUNET_SCHEDULER_add_delayed(cmd->details.sleep.delay,
877 &interpreter,
878 NULL);
879 return;
880 } /* end switch */
881 } /* end while(1) */
867} 882}
868 883
869 884
@@ -882,59 +897,59 @@ interpreter (void *cls)
882 * 0 to signal disconnect 897 * 0 to signal disconnect
883 */ 898 */
884static void 899static void
885address_suggest_cb (void *cls, 900address_suggest_cb(void *cls,
886 const struct GNUNET_PeerIdentity *peer, 901 const struct GNUNET_PeerIdentity *peer,
887 const struct GNUNET_HELLO_Address *address, 902 const struct GNUNET_HELLO_Address *address,
888 struct GNUNET_ATS_Session *session, 903 struct GNUNET_ATS_Session *session,
889 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, 904 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
890 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in) 905 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
891{ 906{
892 const char *asc_cls = cls; 907 const char *asc_cls = cls;
893 struct AddressSuggestData *asd; 908 struct AddressSuggestData *asd;
894 909
895 GNUNET_break (0 == strcmp (asc_cls, "asc-closure")); 910 GNUNET_break(0 == strcmp(asc_cls, "asc-closure"));
896 if (NULL == peer) 911 if (NULL == peer)
897 { 912 {
898 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 913 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
899 "Connection to ATS died, likely a crash!\n"); 914 "Connection to ATS died, likely a crash!\n");
900 GNUNET_SCHEDULER_shutdown (); 915 GNUNET_SCHEDULER_shutdown();
901#if 0 916#if 0
902 /* This is what we should do if we wanted to continue past 917 /* This is what we should do if we wanted to continue past
903 the ATS crash. */ 918 the ATS crash. */
904 GNUNET_CONTAINER_multipeermap_iterate (p2asd, 919 GNUNET_CONTAINER_multipeermap_iterate(p2asd,
905 &free_asd, 920 &free_asd,
906 NULL); 921 NULL);
907 GNUNET_CONTAINER_multipeermap_iterate (p2aid, 922 GNUNET_CONTAINER_multipeermap_iterate(p2aid,
908 &free_aid, 923 &free_aid,
909 NULL); 924 NULL);
910#endif 925#endif
911 return; 926 return;
912 } 927 }
913 928
914 asd = find_address_suggestion (peer); 929 asd = find_address_suggestion(peer);
915 if (NULL == asd) 930 if (NULL == asd)
916 { 931 {
917 asd = GNUNET_new (struct AddressSuggestData); 932 asd = GNUNET_new(struct AddressSuggestData);
918 GNUNET_assert (GNUNET_YES == 933 GNUNET_assert(GNUNET_YES ==
919 GNUNET_CONTAINER_multipeermap_put (p2asd, 934 GNUNET_CONTAINER_multipeermap_put(p2asd,
920 peer, 935 peer,
921 asd, 936 asd,
922 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); 937 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
923 } 938 }
924 if ( (0 == ntohl (bandwidth_out.value__)) && 939 if ((0 == ntohl(bandwidth_out.value__)) &&
925 (0 == ntohl (bandwidth_in.value__)) ) 940 (0 == ntohl(bandwidth_in.value__)))
926 asd->active = GNUNET_NO; 941 asd->active = GNUNET_NO;
927 else 942 else
928 asd->active = GNUNET_YES; 943 asd->active = GNUNET_YES;
929 asd->bandwidth_out = bandwidth_out; 944 asd->bandwidth_out = bandwidth_out;
930 asd->bandwidth_in = bandwidth_in; 945 asd->bandwidth_in = bandwidth_in;
931 asd->session = session; 946 asd->session = session;
932 GNUNET_free_non_null (asd->address); 947 GNUNET_free_non_null(asd->address);
933 asd->address = NULL; 948 asd->address = NULL;
934 if (NULL != address) 949 if (NULL != address)
935 asd->address = GNUNET_HELLO_address_copy (address); 950 asd->address = GNUNET_HELLO_address_copy(address);
936 if (NULL == interpreter_task) 951 if (NULL == interpreter_task)
937 run_interpreter (); 952 run_interpreter();
938} 953}
939 954
940 955
@@ -952,44 +967,44 @@ address_suggest_cb (void *cls,
952 * @param prop performance data for the address 967 * @param prop performance data for the address
953 */ 968 */
954static void 969static void
955address_information_cb (void *cls, 970address_information_cb(void *cls,
956 const struct GNUNET_HELLO_Address *address, 971 const struct GNUNET_HELLO_Address *address,
957 int address_active, 972 int address_active,
958 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, 973 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
959 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, 974 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
960 const struct GNUNET_ATS_Properties *prop) 975 const struct GNUNET_ATS_Properties *prop)
961{ 976{
962 const char *aic_cls = cls; 977 const char *aic_cls = cls;
963 struct AddressInformationData *aid; 978 struct AddressInformationData *aid;
964 979
965 GNUNET_break (0 == strcmp (aic_cls, "aic-closure")); 980 GNUNET_break(0 == strcmp(aic_cls, "aic-closure"));
966 if (NULL == address) 981 if (NULL == address)
967 { 982 {
968 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 983 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
969 "Connection to ATS died, likely a crash!\n"); 984 "Connection to ATS died, likely a crash!\n");
970 GNUNET_CONTAINER_multipeermap_iterate (p2aid, 985 GNUNET_CONTAINER_multipeermap_iterate(p2aid,
971 &free_aid, 986 &free_aid,
972 NULL); 987 NULL);
973 return; 988 return;
974 } 989 }
975 990
976 aid = find_address_information (address); 991 aid = find_address_information(address);
977 if (NULL == aid) 992 if (NULL == aid)
978 { 993 {
979 aid = GNUNET_new (struct AddressInformationData); 994 aid = GNUNET_new(struct AddressInformationData);
980 aid->address = GNUNET_HELLO_address_copy (address); 995 aid->address = GNUNET_HELLO_address_copy(address);
981 GNUNET_assert (GNUNET_YES == 996 GNUNET_assert(GNUNET_YES ==
982 GNUNET_CONTAINER_multipeermap_put (p2aid, 997 GNUNET_CONTAINER_multipeermap_put(p2aid,
983 &address->peer, 998 &address->peer,
984 aid, 999 aid,
985 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); 1000 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
986 } 1001 }
987 aid->active = address_active; 1002 aid->active = address_active;
988 aid->bandwidth_out = bandwidth_out; 1003 aid->bandwidth_out = bandwidth_out;
989 aid->bandwidth_in = bandwidth_in; 1004 aid->bandwidth_in = bandwidth_in;
990 aid->properties = *prop; 1005 aid->properties = *prop;
991 if (NULL == interpreter_task) 1006 if (NULL == interpreter_task)
992 run_interpreter (); 1007 run_interpreter();
993} 1008}
994 1009
995 1010
@@ -1001,44 +1016,44 @@ address_information_cb (void *cls,
1001 * @param peer handle to the peer 1016 * @param peer handle to the peer
1002 */ 1017 */
1003static void 1018static void
1004run (void *cls, 1019run(void *cls,
1005 const struct GNUNET_CONFIGURATION_Handle *cfg, 1020 const struct GNUNET_CONFIGURATION_Handle *cfg,
1006 struct GNUNET_TESTING_Peer *peer) 1021 struct GNUNET_TESTING_Peer *peer)
1007{ 1022{
1008 p2asd = GNUNET_CONTAINER_multipeermap_create (128, 1023 p2asd = GNUNET_CONTAINER_multipeermap_create(128,
1009 GNUNET_NO); 1024 GNUNET_NO);
1010 p2aid = GNUNET_CONTAINER_multipeermap_create (128, 1025 p2aid = GNUNET_CONTAINER_multipeermap_create(128,
1011 GNUNET_NO); 1026 GNUNET_NO);
1012 GNUNET_SCHEDULER_add_delayed (TIMEOUT, 1027 GNUNET_SCHEDULER_add_delayed(TIMEOUT,
1013 &end, 1028 &end,
1014 NULL); 1029 NULL);
1015 1030
1016 sched_ats = GNUNET_ATS_scheduling_init (cfg, 1031 sched_ats = GNUNET_ATS_scheduling_init(cfg,
1017 &address_suggest_cb, 1032 &address_suggest_cb,
1018 "asc-closure"); 1033 "asc-closure");
1019 if (NULL == sched_ats) 1034 if (NULL == sched_ats)
1020 { 1035 {
1021 GNUNET_break (0); 1036 GNUNET_break(0);
1022 GNUNET_SCHEDULER_shutdown (); 1037 GNUNET_SCHEDULER_shutdown();
1023 return; 1038 return;
1024 } 1039 }
1025 con_ats = GNUNET_ATS_connectivity_init (cfg); 1040 con_ats = GNUNET_ATS_connectivity_init(cfg);
1026 if (NULL == con_ats) 1041 if (NULL == con_ats)
1027 { 1042 {
1028 GNUNET_break (0); 1043 GNUNET_break(0);
1029 GNUNET_SCHEDULER_shutdown (); 1044 GNUNET_SCHEDULER_shutdown();
1030 return; 1045 return;
1031 } 1046 }
1032 perf_ats = GNUNET_ATS_performance_init (cfg, 1047 perf_ats = GNUNET_ATS_performance_init(cfg,
1033 &address_information_cb, 1048 &address_information_cb,
1034 "aic-closure"); 1049 "aic-closure");
1035 if (NULL == perf_ats) 1050 if (NULL == perf_ats)
1036 { 1051 {
1037 GNUNET_break (0); 1052 GNUNET_break(0);
1038 GNUNET_SCHEDULER_shutdown (); 1053 GNUNET_SCHEDULER_shutdown();
1039 return; 1054 return;
1040 } 1055 }
1041 run_interpreter (); 1056 run_interpreter();
1042} 1057}
1043 1058
1044 1059
@@ -1052,32 +1067,32 @@ run (void *cls,
1052 * @return 0 on success 1067 * @return 0 on success
1053 */ 1068 */
1054int 1069int
1055TEST_ATS_run (int argc, 1070TEST_ATS_run(int argc,
1056 char *argv[], 1071 char *argv[],
1057 struct Command *cmds, 1072 struct Command *cmds,
1058 struct GNUNET_TIME_Relative timeout) 1073 struct GNUNET_TIME_Relative timeout)
1059{ 1074{
1060 char *test_filename = GNUNET_strdup (argv[0]); 1075 char *test_filename = GNUNET_strdup(argv[0]);
1061 char *sep; 1076 char *sep;
1062 char *config_file; 1077 char *config_file;
1063 char *underscore; 1078 char *underscore;
1064 1079
1065 test_commands = cmds; 1080 test_commands = cmds;
1066 TIMEOUT = timeout; 1081 TIMEOUT = timeout;
1067 if (NULL != (sep = strstr (test_filename, ".exe"))) 1082 if (NULL != (sep = strstr(test_filename, ".exe")))
1068 sep[0] = '\0'; 1083 sep[0] = '\0';
1069 underscore = strrchr (test_filename, (int) '_'); 1084 underscore = strrchr(test_filename, (int)'_');
1070 GNUNET_assert (NULL != underscore); 1085 GNUNET_assert(NULL != underscore);
1071 GNUNET_asprintf (&config_file, 1086 GNUNET_asprintf(&config_file,
1072 "test_ats_api_%s.conf", 1087 "test_ats_api_%s.conf",
1073 underscore + 1); 1088 underscore + 1);
1074 ret = 2; 1089 ret = 2;
1075 if (0 != GNUNET_TESTING_peer_run ("test-ats-api", 1090 if (0 != GNUNET_TESTING_peer_run("test-ats-api",
1076 config_file, 1091 config_file,
1077 &run, NULL)) 1092 &run, NULL))
1078 ret = 1; 1093 ret = 1;
1079 GNUNET_free (test_filename); 1094 GNUNET_free(test_filename);
1080 GNUNET_free (config_file); 1095 GNUNET_free(config_file);
1081 return ret; 1096 return ret;
1082} 1097}
1083 1098