diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/ats/test_ats_lib.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/ats/test_ats_lib.c')
-rw-r--r-- | src/ats/test_ats_lib.c | 1123 |
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 | */ |
34 | struct AddressSuggestData | 34 | struct 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 | */ |
66 | struct AddressInformationData | 65 | struct 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 | */ |
158 | static int | 156 | static int |
159 | free_asd (void *cls, | 157 | free_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 | */ |
183 | static int | 181 | static int |
184 | free_aid (void *cls, | 182 | free_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 | */ |
206 | static struct AddressSuggestData * | 204 | static struct AddressSuggestData * |
207 | find_address_suggestion (const struct GNUNET_PeerIdentity *pid) | 205 | find_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 | */ |
217 | struct MatchAddressContext | 215 | struct 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 | */ |
239 | static int | 236 | static int |
240 | match_address (void *cls, | 237 | match_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 | */ |
263 | static struct AddressInformationData * | 260 | static struct AddressInformationData * |
264 | find_address_information (const struct GNUNET_HELLO_Address *addr) | 261 | find_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 | */ |
283 | static void | 280 | static void |
284 | end (void *cls) | 281 | end(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 | */ |
337 | static void | 334 | static void |
338 | interpreter (void *cls); | 335 | interpreter(void *cls); |
339 | 336 | ||
340 | 337 | ||
341 | /** | 338 | /** |
342 | * Run the interpreter next. | 339 | * Run the interpreter next. |
343 | */ | 340 | */ |
344 | static void | 341 | static void |
345 | run_interpreter () | 342 | run_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 | */ |
360 | static void | 357 | static void |
361 | make_peer (uint32_t pid, | 358 | make_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 | */ |
381 | static struct GNUNET_HELLO_Address * | 378 | static struct GNUNET_HELLO_Address * |
382 | make_address (uint32_t pid, | 379 | make_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 | */ |
403 | struct GNUNET_ATS_Session | 400 | struct 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 | */ |
418 | static struct GNUNET_ATS_Session * | 414 | static struct GNUNET_ATS_Session * |
419 | make_session (unsigned int i) | 415 | make_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 | */ |
440 | static struct Command * | 436 | static struct Command * |
441 | find_command (enum CommandCode code, | 437 | find_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 | */ |
472 | static void | 468 | static void |
473 | info_cb (void *cls, | 469 | info_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 | */ |
531 | static void | 529 | static void |
532 | reservation_cb (void *cls, | 530 | reservation_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 | */ |
590 | static void | 590 | static void |
591 | interpreter (void *cls) | 591 | interpreter(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 | */ |
884 | static void | 899 | static void |
885 | address_suggest_cb (void *cls, | 900 | address_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 | */ |
954 | static void | 969 | static void |
955 | address_information_cb (void *cls, | 970 | address_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 | */ |
1003 | static void | 1018 | static void |
1004 | run (void *cls, | 1019 | run(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 | */ |
1054 | int | 1069 | int |
1055 | TEST_ATS_run (int argc, | 1070 | TEST_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 | ||