1 /* 2 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu> 3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 /* The old tests here need assertions to work. */ 29 #undef NDEBUG 30 31 #ifdef _WIN32 32 #include <winsock2.h> 33 #include <windows.h> 34 #endif 35 36 #include "event2/event-config.h" 37 38 #include <sys/types.h> 39 #include <sys/stat.h> 40 #ifdef EVENT__HAVE_SYS_TIME_H 41 #include <sys/time.h> 42 #endif 43 #include <sys/queue.h> 44 #ifndef _WIN32 45 #include <sys/socket.h> 46 #include <signal.h> 47 #include <unistd.h> 48 #include <netdb.h> 49 #endif 50 #include <fcntl.h> 51 #include <stdlib.h> 52 #include <stdio.h> 53 #include <string.h> 54 #include <errno.h> 55 #include <assert.h> 56 57 #include "event2/buffer.h" 58 #include "event2/event.h" 59 #include "event2/event_compat.h" 60 #include "event2/http.h" 61 #include "event2/http_compat.h" 62 #include "event2/http_struct.h" 63 #include "event2/rpc.h" 64 #include "event2/rpc.h" 65 #include "event2/rpc_struct.h" 66 #include "event2/tag.h" 67 #include "log-internal.h" 68 69 #include "regress.gen.h" 70 71 #include "regress.h" 72 #include "regress_testutils.h" 73 74 #ifndef NO_PYTHON_EXISTS 75 76 static struct evhttp * http_setup(ev_uint16_t * pport)77 http_setup(ev_uint16_t *pport) 78 { 79 struct evhttp *myhttp; 80 ev_uint16_t port; 81 struct evhttp_bound_socket *sock; 82 83 myhttp = evhttp_new(NULL); 84 if (!myhttp) 85 event_errx(1, "Could not start web server"); 86 87 /* Try a few different ports */ 88 sock = evhttp_bind_socket_with_handle(myhttp, "127.0.0.1", 0); 89 if (!sock) 90 event_errx(1, "Couldn't open web port"); 91 92 port = regress_get_socket_port(evhttp_bound_socket_get_fd(sock)); 93 94 *pport = port; 95 return (myhttp); 96 } 97 98 EVRPC_HEADER(Message, msg, kill) 99 EVRPC_HEADER(NeverReply, msg, kill) 100 101 EVRPC_GENERATE(Message, msg, kill) 102 EVRPC_GENERATE(NeverReply, msg, kill) 103 104 static int need_input_hook = 0; 105 static int need_output_hook = 0; 106 107 static void MessageCb(EVRPC_STRUCT (Message)* rpc,void * arg)108 MessageCb(EVRPC_STRUCT(Message)* rpc, void *arg) 109 { 110 struct kill* kill_reply = rpc->reply; 111 112 if (need_input_hook) { 113 struct evhttp_request* req = EVRPC_REQUEST_HTTP(rpc); 114 const char *header = evhttp_find_header( 115 req->input_headers, "X-Hook"); 116 assert(header); 117 assert(strcmp(header, "input") == 0); 118 } 119 120 /* we just want to fill in some non-sense */ 121 EVTAG_ASSIGN(kill_reply, weapon, "dagger"); 122 EVTAG_ASSIGN(kill_reply, action, "wave around like an idiot"); 123 124 /* no reply to the RPC */ 125 EVRPC_REQUEST_DONE(rpc); 126 } 127 EVRPC_STRUCT(NeverReply)128 static EVRPC_STRUCT(NeverReply) *saved_rpc; 129 130 static void 131 NeverReplyCb(EVRPC_STRUCT(NeverReply)* rpc, void *arg) 132 { 133 test_ok += 1; 134 saved_rpc = rpc; 135 } 136 137 static void rpc_setup(struct evhttp ** phttp,ev_uint16_t * pport,struct evrpc_base ** pbase)138 rpc_setup(struct evhttp **phttp, ev_uint16_t *pport, struct evrpc_base **pbase) 139 { 140 ev_uint16_t port; 141 struct evhttp *http = NULL; 142 struct evrpc_base *base = NULL; 143 144 http = http_setup(&port); 145 base = evrpc_init(http); 146 147 EVRPC_REGISTER(base, Message, msg, kill, MessageCb, NULL); 148 EVRPC_REGISTER(base, NeverReply, msg, kill, NeverReplyCb, NULL); 149 150 *phttp = http; 151 *pport = port; 152 *pbase = base; 153 154 need_input_hook = 0; 155 need_output_hook = 0; 156 } 157 158 static void rpc_teardown(struct evrpc_base * base)159 rpc_teardown(struct evrpc_base *base) 160 { 161 assert(EVRPC_UNREGISTER(base, Message) == 0); 162 assert(EVRPC_UNREGISTER(base, NeverReply) == 0); 163 164 evrpc_free(base); 165 } 166 167 static void rpc_postrequest_failure(struct evhttp_request * req,void * arg)168 rpc_postrequest_failure(struct evhttp_request *req, void *arg) 169 { 170 if (req->response_code != HTTP_SERVUNAVAIL) { 171 172 fprintf(stderr, "FAILED (response code)\n"); 173 exit(1); 174 } 175 176 test_ok = 1; 177 event_loopexit(NULL); 178 } 179 180 /* 181 * Test a malformed payload submitted as an RPC 182 */ 183 184 static void rpc_basic_test(void)185 rpc_basic_test(void) 186 { 187 ev_uint16_t port; 188 struct evhttp *http = NULL; 189 struct evrpc_base *base = NULL; 190 struct evhttp_connection *evcon = NULL; 191 struct evhttp_request *req = NULL; 192 193 rpc_setup(&http, &port, &base); 194 195 evcon = evhttp_connection_new("127.0.0.1", port); 196 tt_assert(evcon); 197 198 /* 199 * At this point, we want to schedule an HTTP POST request 200 * server using our make request method. 201 */ 202 203 req = evhttp_request_new(rpc_postrequest_failure, NULL); 204 tt_assert(req); 205 206 /* Add the information that we care about */ 207 evhttp_add_header(req->output_headers, "Host", "somehost"); 208 evbuffer_add_printf(req->output_buffer, "Some Nonsense"); 209 210 if (evhttp_make_request(evcon, req, 211 EVHTTP_REQ_POST, 212 "/.rpc.Message") == -1) { 213 tt_abort(); 214 } 215 216 test_ok = 0; 217 218 event_dispatch(); 219 220 evhttp_connection_free(evcon); 221 222 rpc_teardown(base); 223 224 tt_assert(test_ok == 1); 225 226 end: 227 evhttp_free(http); 228 } 229 230 static void rpc_postrequest_done(struct evhttp_request * req,void * arg)231 rpc_postrequest_done(struct evhttp_request *req, void *arg) 232 { 233 struct kill* kill_reply = NULL; 234 235 if (req->response_code != HTTP_OK) { 236 fprintf(stderr, "FAILED (response code)\n"); 237 exit(1); 238 } 239 240 kill_reply = kill_new(); 241 242 if ((kill_unmarshal(kill_reply, req->input_buffer)) == -1) { 243 fprintf(stderr, "FAILED (unmarshal)\n"); 244 exit(1); 245 } 246 247 kill_free(kill_reply); 248 249 test_ok = 1; 250 event_loopexit(NULL); 251 } 252 253 static void rpc_basic_message(void)254 rpc_basic_message(void) 255 { 256 ev_uint16_t port; 257 struct evhttp *http = NULL; 258 struct evrpc_base *base = NULL; 259 struct evhttp_connection *evcon = NULL; 260 struct evhttp_request *req = NULL; 261 struct msg *msg; 262 263 rpc_setup(&http, &port, &base); 264 265 evcon = evhttp_connection_new("127.0.0.1", port); 266 tt_assert(evcon); 267 268 /* 269 * At this point, we want to schedule an HTTP POST request 270 * server using our make request method. 271 */ 272 273 req = evhttp_request_new(rpc_postrequest_done, NULL); 274 if (req == NULL) { 275 fprintf(stdout, "FAILED\n"); 276 exit(1); 277 } 278 279 /* Add the information that we care about */ 280 evhttp_add_header(req->output_headers, "Host", "somehost"); 281 282 /* set up the basic message */ 283 msg = msg_new(); 284 EVTAG_ASSIGN(msg, from_name, "niels"); 285 EVTAG_ASSIGN(msg, to_name, "tester"); 286 msg_marshal(req->output_buffer, msg); 287 msg_free(msg); 288 289 if (evhttp_make_request(evcon, req, 290 EVHTTP_REQ_POST, 291 "/.rpc.Message") == -1) { 292 fprintf(stdout, "FAILED\n"); 293 exit(1); 294 } 295 296 test_ok = 0; 297 298 event_dispatch(); 299 300 evhttp_connection_free(evcon); 301 302 rpc_teardown(base); 303 304 end: 305 evhttp_free(http); 306 } 307 308 static struct evrpc_pool * rpc_pool_with_connection(ev_uint16_t port)309 rpc_pool_with_connection(ev_uint16_t port) 310 { 311 struct evhttp_connection *evcon; 312 struct evrpc_pool *pool; 313 314 pool = evrpc_pool_new(NULL); 315 assert(pool != NULL); 316 317 evcon = evhttp_connection_new("127.0.0.1", port); 318 assert(evcon != NULL); 319 320 evrpc_pool_add_connection(pool, evcon); 321 322 return (pool); 323 } 324 325 static void GotKillCb(struct evrpc_status * status,struct msg * msg,struct kill * kill,void * arg)326 GotKillCb(struct evrpc_status *status, 327 struct msg *msg, struct kill *kill, void *arg) 328 { 329 char *weapon; 330 char *action; 331 332 if (need_output_hook) { 333 struct evhttp_request *req = status->http_req; 334 const char *header = evhttp_find_header( 335 req->input_headers, "X-Pool-Hook"); 336 assert(header); 337 assert(strcmp(header, "ran") == 0); 338 } 339 340 if (status->error != EVRPC_STATUS_ERR_NONE) 341 goto done; 342 343 if (EVTAG_GET(kill, weapon, &weapon) == -1) { 344 fprintf(stderr, "get weapon\n"); 345 goto done; 346 } 347 if (EVTAG_GET(kill, action, &action) == -1) { 348 fprintf(stderr, "get action\n"); 349 goto done; 350 } 351 352 if (strcmp(weapon, "dagger")) 353 goto done; 354 355 if (strcmp(action, "wave around like an idiot")) 356 goto done; 357 358 test_ok += 1; 359 360 done: 361 event_loopexit(NULL); 362 } 363 364 static void GotKillCbTwo(struct evrpc_status * status,struct msg * msg,struct kill * kill,void * arg)365 GotKillCbTwo(struct evrpc_status *status, 366 struct msg *msg, struct kill *kill, void *arg) 367 { 368 char *weapon; 369 char *action; 370 371 if (status->error != EVRPC_STATUS_ERR_NONE) 372 goto done; 373 374 if (EVTAG_GET(kill, weapon, &weapon) == -1) { 375 fprintf(stderr, "get weapon\n"); 376 goto done; 377 } 378 if (EVTAG_GET(kill, action, &action) == -1) { 379 fprintf(stderr, "get action\n"); 380 goto done; 381 } 382 383 if (strcmp(weapon, "dagger")) 384 goto done; 385 386 if (strcmp(action, "wave around like an idiot")) 387 goto done; 388 389 test_ok += 1; 390 391 done: 392 if (test_ok == 2) 393 event_loopexit(NULL); 394 } 395 396 static int rpc_hook_add_header(void * ctx,struct evhttp_request * req,struct evbuffer * evbuf,void * arg)397 rpc_hook_add_header(void *ctx, struct evhttp_request *req, 398 struct evbuffer *evbuf, void *arg) 399 { 400 const char *hook_type = arg; 401 if (strcmp("input", hook_type) == 0) 402 evhttp_add_header(req->input_headers, "X-Hook", hook_type); 403 else 404 evhttp_add_header(req->output_headers, "X-Hook", hook_type); 405 406 assert(evrpc_hook_get_connection(ctx) != NULL); 407 408 return (EVRPC_CONTINUE); 409 } 410 411 static int rpc_hook_add_meta(void * ctx,struct evhttp_request * req,struct evbuffer * evbuf,void * arg)412 rpc_hook_add_meta(void *ctx, struct evhttp_request *req, 413 struct evbuffer *evbuf, void *arg) 414 { 415 evrpc_hook_add_meta(ctx, "meta", "test", 5); 416 417 assert(evrpc_hook_get_connection(ctx) != NULL); 418 419 return (EVRPC_CONTINUE); 420 } 421 422 static int rpc_hook_remove_header(void * ctx,struct evhttp_request * req,struct evbuffer * evbuf,void * arg)423 rpc_hook_remove_header(void *ctx, struct evhttp_request *req, 424 struct evbuffer *evbuf, void *arg) 425 { 426 const char *header = evhttp_find_header(req->input_headers, "X-Hook"); 427 void *data = NULL; 428 size_t data_len = 0; 429 430 assert(header != NULL); 431 assert(strcmp(header, arg) == 0); 432 433 evhttp_remove_header(req->input_headers, "X-Hook"); 434 evhttp_add_header(req->input_headers, "X-Pool-Hook", "ran"); 435 436 assert(evrpc_hook_find_meta(ctx, "meta", &data, &data_len) == 0); 437 assert(data != NULL); 438 assert(data_len == 5); 439 440 assert(evrpc_hook_get_connection(ctx) != NULL); 441 442 return (EVRPC_CONTINUE); 443 } 444 445 static void rpc_basic_client(void)446 rpc_basic_client(void) 447 { 448 ev_uint16_t port; 449 struct evhttp *http = NULL; 450 struct evrpc_base *base = NULL; 451 struct evrpc_pool *pool = NULL; 452 struct msg *msg = NULL; 453 struct kill *kill = NULL; 454 455 rpc_setup(&http, &port, &base); 456 457 need_input_hook = 1; 458 need_output_hook = 1; 459 460 assert(evrpc_add_hook(base, EVRPC_INPUT, rpc_hook_add_header, (void*)"input") 461 != NULL); 462 assert(evrpc_add_hook(base, EVRPC_OUTPUT, rpc_hook_add_header, (void*)"output") 463 != NULL); 464 465 pool = rpc_pool_with_connection(port); 466 tt_assert(pool); 467 468 assert(evrpc_add_hook(pool, EVRPC_OUTPUT, rpc_hook_add_meta, NULL)); 469 assert(evrpc_add_hook(pool, EVRPC_INPUT, rpc_hook_remove_header, (void*)"output")); 470 471 /* set up the basic message */ 472 msg = msg_new(); 473 tt_assert(msg); 474 EVTAG_ASSIGN(msg, from_name, "niels"); 475 EVTAG_ASSIGN(msg, to_name, "tester"); 476 477 kill = kill_new(); 478 479 EVRPC_MAKE_REQUEST(Message, pool, msg, kill, GotKillCb, NULL); 480 481 test_ok = 0; 482 483 event_dispatch(); 484 485 tt_assert(test_ok == 1); 486 487 /* we do it twice to make sure that reuse works correctly */ 488 kill_clear(kill); 489 490 EVRPC_MAKE_REQUEST(Message, pool, msg, kill, GotKillCb, NULL); 491 492 event_dispatch(); 493 494 tt_assert(test_ok == 2); 495 496 /* we do it trice to make sure other stuff works, too */ 497 kill_clear(kill); 498 499 { 500 struct evrpc_request_wrapper *ctx = 501 EVRPC_MAKE_CTX(Message, msg, kill, 502 pool, msg, kill, GotKillCb, NULL); 503 evrpc_make_request(ctx); 504 } 505 506 event_dispatch(); 507 508 rpc_teardown(base); 509 510 tt_assert(test_ok == 3); 511 512 end: 513 if (msg) 514 msg_free(msg); 515 if (kill) 516 kill_free(kill); 517 518 if (pool) 519 evrpc_pool_free(pool); 520 if (http) 521 evhttp_free(http); 522 523 need_input_hook = 0; 524 need_output_hook = 0; 525 } 526 527 /* 528 * We are testing that the second requests gets send over the same 529 * connection after the first RPCs completes. 530 */ 531 static void rpc_basic_queued_client(void)532 rpc_basic_queued_client(void) 533 { 534 ev_uint16_t port; 535 struct evhttp *http = NULL; 536 struct evrpc_base *base = NULL; 537 struct evrpc_pool *pool = NULL; 538 struct msg *msg=NULL; 539 struct kill *kill_one=NULL, *kill_two=NULL; 540 541 rpc_setup(&http, &port, &base); 542 543 pool = rpc_pool_with_connection(port); 544 tt_assert(pool); 545 546 /* set up the basic message */ 547 msg = msg_new(); 548 tt_assert(msg); 549 EVTAG_ASSIGN(msg, from_name, "niels"); 550 EVTAG_ASSIGN(msg, to_name, "tester"); 551 552 kill_one = kill_new(); 553 kill_two = kill_new(); 554 555 EVRPC_MAKE_REQUEST(Message, pool, msg, kill_one, GotKillCbTwo, NULL); 556 EVRPC_MAKE_REQUEST(Message, pool, msg, kill_two, GotKillCb, NULL); 557 558 test_ok = 0; 559 560 event_dispatch(); 561 562 rpc_teardown(base); 563 564 tt_assert(test_ok == 2); 565 566 end: 567 if (msg) 568 msg_free(msg); 569 if (kill_one) 570 kill_free(kill_one); 571 if (kill_two) 572 kill_free(kill_two); 573 574 if (pool) 575 evrpc_pool_free(pool); 576 if (http) 577 evhttp_free(http); 578 } 579 580 static void GotErrorCb(struct evrpc_status * status,struct msg * msg,struct kill * kill,void * arg)581 GotErrorCb(struct evrpc_status *status, 582 struct msg *msg, struct kill *kill, void *arg) 583 { 584 if (status->error != EVRPC_STATUS_ERR_TIMEOUT) 585 goto done; 586 587 /* should never be complete but just to check */ 588 if (kill_complete(kill) == 0) 589 goto done; 590 591 test_ok += 1; 592 593 done: 594 event_loopexit(NULL); 595 } 596 597 /* we just pause the rpc and continue it in the next callback */ 598 599 struct rpc_hook_ctx_ { 600 void *vbase; 601 void *ctx; 602 }; 603 604 static int hook_pause_cb_called=0; 605 606 static void rpc_hook_pause_cb(evutil_socket_t fd,short what,void * arg)607 rpc_hook_pause_cb(evutil_socket_t fd, short what, void *arg) 608 { 609 struct rpc_hook_ctx_ *ctx = arg; 610 ++hook_pause_cb_called; 611 evrpc_resume_request(ctx->vbase, ctx->ctx, EVRPC_CONTINUE); 612 free(arg); 613 } 614 615 static int rpc_hook_pause(void * ctx,struct evhttp_request * req,struct evbuffer * evbuf,void * arg)616 rpc_hook_pause(void *ctx, struct evhttp_request *req, struct evbuffer *evbuf, 617 void *arg) 618 { 619 struct rpc_hook_ctx_ *tmp = malloc(sizeof(*tmp)); 620 struct timeval tv; 621 622 assert(tmp != NULL); 623 tmp->vbase = arg; 624 tmp->ctx = ctx; 625 626 memset(&tv, 0, sizeof(tv)); 627 event_once(-1, EV_TIMEOUT, rpc_hook_pause_cb, tmp, &tv); 628 return EVRPC_PAUSE; 629 } 630 631 static void rpc_basic_client_with_pause(void)632 rpc_basic_client_with_pause(void) 633 { 634 ev_uint16_t port; 635 struct evhttp *http = NULL; 636 struct evrpc_base *base = NULL; 637 struct evrpc_pool *pool = NULL; 638 struct msg *msg = NULL; 639 struct kill *kill= NULL; 640 641 rpc_setup(&http, &port, &base); 642 643 assert(evrpc_add_hook(base, EVRPC_INPUT, rpc_hook_pause, base)); 644 assert(evrpc_add_hook(base, EVRPC_OUTPUT, rpc_hook_pause, base)); 645 646 pool = rpc_pool_with_connection(port); 647 tt_assert(pool); 648 assert(evrpc_add_hook(pool, EVRPC_INPUT, rpc_hook_pause, pool)); 649 assert(evrpc_add_hook(pool, EVRPC_OUTPUT, rpc_hook_pause, pool)); 650 651 /* set up the basic message */ 652 msg = msg_new(); 653 tt_assert(msg); 654 EVTAG_ASSIGN(msg, from_name, "niels"); 655 EVTAG_ASSIGN(msg, to_name, "tester"); 656 657 kill = kill_new(); 658 659 EVRPC_MAKE_REQUEST(Message, pool, msg, kill, GotKillCb, NULL); 660 661 test_ok = 0; 662 663 event_dispatch(); 664 665 tt_int_op(test_ok, ==, 1); 666 tt_int_op(hook_pause_cb_called, ==, 4); 667 668 end: 669 if (base) 670 rpc_teardown(base); 671 672 if (msg) 673 msg_free(msg); 674 if (kill) 675 kill_free(kill); 676 677 if (pool) 678 evrpc_pool_free(pool); 679 if (http) 680 evhttp_free(http); 681 } 682 683 static void rpc_client_timeout(void)684 rpc_client_timeout(void) 685 { 686 ev_uint16_t port; 687 struct evhttp *http = NULL; 688 struct evrpc_base *base = NULL; 689 struct evrpc_pool *pool = NULL; 690 struct msg *msg = NULL; 691 struct kill *kill = NULL; 692 693 rpc_setup(&http, &port, &base); 694 695 pool = rpc_pool_with_connection(port); 696 tt_assert(pool); 697 698 /* set the timeout to 1 second. */ 699 evrpc_pool_set_timeout(pool, 1); 700 701 /* set up the basic message */ 702 msg = msg_new(); 703 tt_assert(msg); 704 EVTAG_ASSIGN(msg, from_name, "niels"); 705 EVTAG_ASSIGN(msg, to_name, "tester"); 706 707 kill = kill_new(); 708 709 EVRPC_MAKE_REQUEST(NeverReply, pool, msg, kill, GotErrorCb, NULL); 710 711 test_ok = 0; 712 713 event_dispatch(); 714 715 /* free the saved RPC structure up */ 716 EVRPC_REQUEST_DONE(saved_rpc); 717 718 rpc_teardown(base); 719 720 tt_assert(test_ok == 2); 721 722 end: 723 if (msg) 724 msg_free(msg); 725 if (kill) 726 kill_free(kill); 727 728 if (pool) 729 evrpc_pool_free(pool); 730 if (http) 731 evhttp_free(http); 732 } 733 734 static void rpc_test(void)735 rpc_test(void) 736 { 737 struct msg *msg = NULL, *msg2 = NULL; 738 struct kill *attack = NULL; 739 struct run *run = NULL; 740 struct evbuffer *tmp = evbuffer_new(); 741 struct timeval tv_start, tv_end; 742 ev_uint32_t tag; 743 int i; 744 745 msg = msg_new(); 746 747 tt_assert(msg); 748 749 EVTAG_ASSIGN(msg, from_name, "niels"); 750 EVTAG_ASSIGN(msg, to_name, "phoenix"); 751 752 if (EVTAG_GET(msg, attack, &attack) == -1) { 753 tt_abort_msg("Failed to set kill message."); 754 } 755 756 EVTAG_ASSIGN(attack, weapon, "feather"); 757 EVTAG_ASSIGN(attack, action, "tickle"); 758 for (i = 0; i < 3; ++i) { 759 if (EVTAG_ARRAY_ADD_VALUE(attack, how_often, i) == NULL) { 760 tt_abort_msg("Failed to add how_often."); 761 } 762 } 763 764 evutil_gettimeofday(&tv_start, NULL); 765 for (i = 0; i < 1000; ++i) { 766 run = EVTAG_ARRAY_ADD(msg, run); 767 if (run == NULL) { 768 tt_abort_msg("Failed to add run message."); 769 } 770 EVTAG_ASSIGN(run, how, "very fast but with some data in it"); 771 EVTAG_ASSIGN(run, fixed_bytes, 772 (ev_uint8_t*)"012345678901234567890123"); 773 774 if (EVTAG_ARRAY_ADD_VALUE( 775 run, notes, "this is my note") == NULL) { 776 tt_abort_msg("Failed to add note."); 777 } 778 if (EVTAG_ARRAY_ADD_VALUE(run, notes, "pps") == NULL) { 779 tt_abort_msg("Failed to add note"); 780 } 781 782 EVTAG_ASSIGN(run, large_number, 0xdead0a0bcafebeefLL); 783 EVTAG_ARRAY_ADD_VALUE(run, other_numbers, 0xdead0a0b); 784 EVTAG_ARRAY_ADD_VALUE(run, other_numbers, 0xbeefcafe); 785 } 786 787 if (msg_complete(msg) == -1) 788 tt_abort_msg("Failed to make complete message."); 789 790 evtag_marshal_msg(tmp, 0xdeaf, msg); 791 792 if (evtag_peek(tmp, &tag) == -1) 793 tt_abort_msg("Failed to peak tag."); 794 795 if (tag != 0xdeaf) 796 TT_DIE(("Got incorrect tag: %0x.", (unsigned)tag)); 797 798 msg2 = msg_new(); 799 if (evtag_unmarshal_msg(tmp, 0xdeaf, msg2) == -1) 800 tt_abort_msg("Failed to unmarshal message."); 801 802 evutil_gettimeofday(&tv_end, NULL); 803 evutil_timersub(&tv_end, &tv_start, &tv_end); 804 TT_BLATHER(("(%.1f us/add) ", 805 (float)tv_end.tv_sec/(float)i * 1000000.0 + 806 tv_end.tv_usec / (float)i)); 807 808 if (!EVTAG_HAS(msg2, from_name) || 809 !EVTAG_HAS(msg2, to_name) || 810 !EVTAG_HAS(msg2, attack)) { 811 tt_abort_msg("Missing data structures."); 812 } 813 814 if (EVTAG_GET(msg2, attack, &attack) == -1) { 815 tt_abort_msg("Could not get attack."); 816 } 817 818 if (EVTAG_ARRAY_LEN(msg2, run) != i) { 819 tt_abort_msg("Wrong number of run messages."); 820 } 821 822 /* get the very first run message */ 823 if (EVTAG_ARRAY_GET(msg2, run, 0, &run) == -1) { 824 tt_abort_msg("Failed to get run msg."); 825 } else { 826 /* verify the notes */ 827 char *note_one, *note_two; 828 ev_uint64_t large_number; 829 ev_uint32_t short_number; 830 831 if (EVTAG_ARRAY_LEN(run, notes) != 2) { 832 tt_abort_msg("Wrong number of note strings."); 833 } 834 835 if (EVTAG_ARRAY_GET(run, notes, 0, ¬e_one) == -1 || 836 EVTAG_ARRAY_GET(run, notes, 1, ¬e_two) == -1) { 837 tt_abort_msg("Could not get note strings."); 838 } 839 840 if (strcmp(note_one, "this is my note") || 841 strcmp(note_two, "pps")) { 842 tt_abort_msg("Incorrect note strings encoded."); 843 } 844 845 if (EVTAG_GET(run, large_number, &large_number) == -1 || 846 large_number != 0xdead0a0bcafebeefLL) { 847 tt_abort_msg("Incorrrect large_number."); 848 } 849 850 if (EVTAG_ARRAY_LEN(run, other_numbers) != 2) { 851 tt_abort_msg("Wrong number of other_numbers."); 852 } 853 854 if (EVTAG_ARRAY_GET( 855 run, other_numbers, 0, &short_number) == -1) { 856 tt_abort_msg("Could not get short number."); 857 } 858 tt_uint_op(short_number, ==, 0xdead0a0b); 859 860 } 861 tt_int_op(EVTAG_ARRAY_LEN(attack, how_often), ==, 3); 862 863 for (i = 0; i < 3; ++i) { 864 ev_uint32_t res; 865 if (EVTAG_ARRAY_GET(attack, how_often, i, &res) == -1) { 866 TT_DIE(("Cannot get %dth how_often msg.", i)); 867 } 868 if ((int)res != i) { 869 TT_DIE(("Wrong message encoded %d != %d", i, res)); 870 } 871 } 872 873 test_ok = 1; 874 end: 875 if (msg) 876 msg_free(msg); 877 if (msg2) 878 msg_free(msg2); 879 if (tmp) 880 evbuffer_free(tmp); 881 } 882 883 #define RPC_LEGACY(name) \ 884 { #name, run_legacy_test_fn, TT_FORK|TT_NEED_BASE|TT_LEGACY, \ 885 &legacy_setup, \ 886 rpc_##name } 887 #else 888 /* NO_PYTHON_EXISTS */ 889 890 #define RPC_LEGACY(name) \ 891 { #name, NULL, TT_SKIP, NULL, NULL } 892 893 #endif 894 895 struct testcase_t rpc_testcases[] = { 896 RPC_LEGACY(basic_test), 897 RPC_LEGACY(basic_message), 898 RPC_LEGACY(basic_client), 899 RPC_LEGACY(basic_queued_client), 900 RPC_LEGACY(basic_client_with_pause), 901 RPC_LEGACY(client_timeout), 902 RPC_LEGACY(test), 903 904 END_OF_TESTCASES, 905 }; 906