1 /* $NetBSD: regress.gen.c,v 1.1.1.3 2017/01/31 21:14:53 christos Exp $ */ 2 /* 3 * Automatically generated from ./test/regress.rpc 4 * by event_rpcgen.py/0.1. DO NOT EDIT THIS FILE. 5 */ 6 7 #include <stdlib.h> 8 #include <string.h> 9 #include <assert.h> 10 #include <event2/event-config.h> 11 #include <event2/event.h> 12 #include <event2/buffer.h> 13 #include <event2/tag.h> 14 15 #if defined(EVENT____func__) && !defined(__func__) 16 #define __func__ EVENT____func__ 17 #endif 18 19 20 #include "regress.gen.h" 21 22 void event_warn(const char *fmt, ...); 23 void event_warnx(const char *fmt, ...); 24 25 26 /* 27 * Implementation of msg 28 */ 29 30 static struct msg_access_ msg_base__ = { 31 msg_from_name_assign, 32 msg_from_name_get, 33 msg_to_name_assign, 34 msg_to_name_get, 35 msg_attack_assign, 36 msg_attack_get, 37 msg_run_assign, 38 msg_run_get, 39 msg_run_add, 40 }; 41 42 struct msg * 43 msg_new(void) 44 { 45 return msg_new_with_arg(NULL); 46 } 47 48 struct msg * 49 msg_new_with_arg(void *unused) 50 { 51 struct msg *tmp; 52 if ((tmp = malloc(sizeof(struct msg))) == NULL) { 53 event_warn("%s: malloc", __func__); 54 return (NULL); 55 } 56 tmp->base = &msg_base__; 57 58 tmp->from_name_data = NULL; 59 tmp->from_name_set = 0; 60 61 tmp->to_name_data = NULL; 62 tmp->to_name_set = 0; 63 64 tmp->attack_data = NULL; 65 tmp->attack_set = 0; 66 67 tmp->run_data = NULL; 68 tmp->run_length = 0; 69 tmp->run_num_allocated = 0; 70 tmp->run_set = 0; 71 72 return (tmp); 73 } 74 75 76 77 78 static int 79 msg_run_expand_to_hold_more(struct msg *msg) 80 { 81 int tobe_allocated = msg->run_num_allocated; 82 struct run** new_data = NULL; 83 tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1; 84 new_data = (struct run**) realloc(msg->run_data, 85 tobe_allocated * sizeof(struct run*)); 86 if (new_data == NULL) 87 return -1; 88 msg->run_data = new_data; 89 msg->run_num_allocated = tobe_allocated; 90 return 0;} 91 92 struct run* 93 msg_run_add(struct msg *msg) 94 { 95 if (++msg->run_length >= msg->run_num_allocated) { 96 if (msg_run_expand_to_hold_more(msg)<0) 97 goto error; 98 } 99 msg->run_data[msg->run_length - 1] = run_new(); 100 if (msg->run_data[msg->run_length - 1] == NULL) 101 goto error; 102 msg->run_set = 1; 103 return (msg->run_data[msg->run_length - 1]); 104 error: 105 --msg->run_length; 106 return (NULL); 107 } 108 109 int 110 msg_from_name_assign(struct msg *msg, 111 const char * value) 112 { 113 if (msg->from_name_data != NULL) 114 free(msg->from_name_data); 115 if ((msg->from_name_data = strdup(value)) == NULL) 116 return (-1); 117 msg->from_name_set = 1; 118 return (0); 119 } 120 121 int 122 msg_to_name_assign(struct msg *msg, 123 const char * value) 124 { 125 if (msg->to_name_data != NULL) 126 free(msg->to_name_data); 127 if ((msg->to_name_data = strdup(value)) == NULL) 128 return (-1); 129 msg->to_name_set = 1; 130 return (0); 131 } 132 133 int 134 msg_attack_assign(struct msg *msg, 135 const struct kill* value) 136 { 137 struct evbuffer *tmp = NULL; 138 if (msg->attack_set) { 139 kill_clear(msg->attack_data); 140 msg->attack_set = 0; 141 } else { 142 msg->attack_data = kill_new(); 143 if (msg->attack_data == NULL) { 144 event_warn("%s: kill_new()", __func__); 145 goto error; 146 } 147 } 148 if ((tmp = evbuffer_new()) == NULL) { 149 event_warn("%s: evbuffer_new()", __func__); 150 goto error; 151 } 152 kill_marshal(tmp, value); 153 if (kill_unmarshal(msg->attack_data, tmp) == -1) { 154 event_warnx("%s: kill_unmarshal", __func__); 155 goto error; 156 } 157 msg->attack_set = 1; 158 evbuffer_free(tmp); 159 return (0); 160 error: 161 if (tmp != NULL) 162 evbuffer_free(tmp); 163 if (msg->attack_data != NULL) { 164 kill_free(msg->attack_data); 165 msg->attack_data = NULL; 166 } 167 return (-1); 168 } 169 170 int 171 msg_run_assign(struct msg *msg, int off, 172 const struct run* value) 173 { 174 if (!msg->run_set || off < 0 || off >= msg->run_length) 175 return (-1); 176 177 { 178 int had_error = 0; 179 struct evbuffer *tmp = NULL; 180 run_clear(msg->run_data[off]); 181 if ((tmp = evbuffer_new()) == NULL) { 182 event_warn("%s: evbuffer_new()", __func__); 183 had_error = 1; 184 goto done; 185 } 186 run_marshal(tmp, value); 187 if (run_unmarshal(msg->run_data[off], tmp) == -1) { 188 event_warnx("%s: run_unmarshal", __func__); 189 had_error = 1; 190 goto done; 191 } 192 done:if (tmp != NULL) 193 evbuffer_free(tmp); 194 if (had_error) { 195 run_clear(msg->run_data[off]); 196 return (-1); 197 } 198 } 199 return (0); 200 } 201 202 int 203 msg_from_name_get(struct msg *msg, char * *value) 204 { 205 if (msg->from_name_set != 1) 206 return (-1); 207 *value = msg->from_name_data; 208 return (0); 209 } 210 211 int 212 msg_to_name_get(struct msg *msg, char * *value) 213 { 214 if (msg->to_name_set != 1) 215 return (-1); 216 *value = msg->to_name_data; 217 return (0); 218 } 219 220 int 221 msg_attack_get(struct msg *msg, struct kill* *value) 222 { 223 if (msg->attack_set != 1) { 224 msg->attack_data = kill_new(); 225 if (msg->attack_data == NULL) 226 return (-1); 227 msg->attack_set = 1; 228 } 229 *value = msg->attack_data; 230 return (0); 231 } 232 233 int 234 msg_run_get(struct msg *msg, int offset, 235 struct run* *value) 236 { 237 if (!msg->run_set || offset < 0 || offset >= msg->run_length) 238 return (-1); 239 *value = msg->run_data[offset]; 240 return (0); 241 } 242 243 void 244 msg_clear(struct msg *tmp) 245 { 246 if (tmp->from_name_set == 1) { 247 free(tmp->from_name_data); 248 tmp->from_name_data = NULL; 249 tmp->from_name_set = 0; 250 } 251 if (tmp->to_name_set == 1) { 252 free(tmp->to_name_data); 253 tmp->to_name_data = NULL; 254 tmp->to_name_set = 0; 255 } 256 if (tmp->attack_set == 1) { 257 kill_free(tmp->attack_data); 258 tmp->attack_data = NULL; 259 tmp->attack_set = 0; 260 } 261 if (tmp->run_set == 1) { 262 int i; 263 for (i = 0; i < tmp->run_length; ++i) { 264 run_free(tmp->run_data[i]); 265 } 266 free(tmp->run_data); 267 tmp->run_data = NULL; 268 tmp->run_set = 0; 269 tmp->run_length = 0; 270 tmp->run_num_allocated = 0; 271 } 272 } 273 274 void 275 msg_free(struct msg *tmp) 276 { 277 if (tmp->from_name_data != NULL) 278 free (tmp->from_name_data); 279 if (tmp->to_name_data != NULL) 280 free (tmp->to_name_data); 281 if (tmp->attack_data != NULL) 282 kill_free(tmp->attack_data); 283 if (tmp->run_set == 1) { 284 int i; 285 for (i = 0; i < tmp->run_length; ++i) { 286 run_free(tmp->run_data[i]); 287 } 288 free(tmp->run_data); 289 tmp->run_data = NULL; 290 tmp->run_set = 0; 291 tmp->run_length = 0; 292 tmp->run_num_allocated = 0; 293 } 294 free(tmp->run_data); 295 free(tmp); 296 } 297 298 void 299 msg_marshal(struct evbuffer *evbuf, const struct msg *tmp){ 300 evtag_marshal_string(evbuf, MSG_FROM_NAME, tmp->from_name_data); 301 evtag_marshal_string(evbuf, MSG_TO_NAME, tmp->to_name_data); 302 if (tmp->attack_set) { 303 evtag_marshal_kill(evbuf, MSG_ATTACK, tmp->attack_data); 304 } 305 if (tmp->run_set) { 306 { 307 int i; 308 for (i = 0; i < tmp->run_length; ++i) { 309 evtag_marshal_run(evbuf, MSG_RUN, tmp->run_data[i]); 310 } 311 } 312 } 313 } 314 315 int 316 msg_unmarshal(struct msg *tmp, struct evbuffer *evbuf) 317 { 318 ev_uint32_t tag; 319 while (evbuffer_get_length(evbuf) > 0) { 320 if (evtag_peek(evbuf, &tag) == -1) 321 return (-1); 322 switch (tag) { 323 324 case MSG_FROM_NAME: 325 326 if (tmp->from_name_set) 327 return (-1); 328 if (evtag_unmarshal_string(evbuf, MSG_FROM_NAME, &tmp->from_name_data) == -1) { 329 event_warnx("%s: failed to unmarshal from_name", __func__); 330 return (-1); 331 } 332 tmp->from_name_set = 1; 333 break; 334 335 case MSG_TO_NAME: 336 337 if (tmp->to_name_set) 338 return (-1); 339 if (evtag_unmarshal_string(evbuf, MSG_TO_NAME, &tmp->to_name_data) == -1) { 340 event_warnx("%s: failed to unmarshal to_name", __func__); 341 return (-1); 342 } 343 tmp->to_name_set = 1; 344 break; 345 346 case MSG_ATTACK: 347 348 if (tmp->attack_set) 349 return (-1); 350 tmp->attack_data = kill_new(); 351 if (tmp->attack_data == NULL) 352 return (-1); 353 if (evtag_unmarshal_kill(evbuf, MSG_ATTACK, tmp->attack_data) == -1) { 354 event_warnx("%s: failed to unmarshal attack", __func__); 355 return (-1); 356 } 357 tmp->attack_set = 1; 358 break; 359 360 case MSG_RUN: 361 362 if (tmp->run_length >= tmp->run_num_allocated && 363 msg_run_expand_to_hold_more(tmp) < 0) { 364 puts("HEY NOW"); 365 return (-1); 366 } 367 tmp->run_data[tmp->run_length] = run_new(); 368 if (tmp->run_data[tmp->run_length] == NULL) 369 return (-1); 370 if (evtag_unmarshal_run(evbuf, MSG_RUN, tmp->run_data[tmp->run_length]) == -1) { 371 event_warnx("%s: failed to unmarshal run", __func__); 372 return (-1); 373 } 374 ++tmp->run_length; 375 tmp->run_set = 1; 376 break; 377 378 default: 379 return -1; 380 } 381 } 382 383 if (msg_complete(tmp) == -1) 384 return (-1); 385 return (0); 386 } 387 388 int 389 msg_complete(struct msg *msg) 390 { 391 if (!msg->from_name_set) 392 return (-1); 393 if (!msg->to_name_set) 394 return (-1); 395 if (msg->attack_set && kill_complete(msg->attack_data) == -1) 396 return (-1); 397 { 398 int i; 399 for (i = 0; i < msg->run_length; ++i) { 400 if (msg->run_set && run_complete(msg->run_data[i]) == -1) 401 return (-1); 402 } 403 } 404 return (0); 405 } 406 407 int 408 evtag_unmarshal_msg(struct evbuffer *evbuf, ev_uint32_t need_tag, struct msg *msg) 409 { 410 ev_uint32_t tag; 411 int res = -1; 412 413 struct evbuffer *tmp = evbuffer_new(); 414 415 if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag) 416 goto error; 417 418 if (msg_unmarshal(msg, tmp) == -1) 419 goto error; 420 421 res = 0; 422 423 error: 424 evbuffer_free(tmp); 425 return (res); 426 } 427 428 void 429 evtag_marshal_msg(struct evbuffer *evbuf, ev_uint32_t tag, const struct msg *msg) 430 { 431 struct evbuffer *buf_ = evbuffer_new(); 432 assert(buf_ != NULL); 433 msg_marshal(buf_, msg); 434 evtag_marshal_buffer(evbuf, tag, buf_); 435 evbuffer_free(buf_); 436 } 437 438 /* 439 * Implementation of kill 440 */ 441 442 static struct kill_access_ kill_base__ = { 443 kill_weapon_assign, 444 kill_weapon_get, 445 kill_action_assign, 446 kill_action_get, 447 kill_how_often_assign, 448 kill_how_often_get, 449 kill_how_often_add, 450 }; 451 452 struct kill * 453 kill_new(void) 454 { 455 return kill_new_with_arg(NULL); 456 } 457 458 struct kill * 459 kill_new_with_arg(void *unused) 460 { 461 struct kill *tmp; 462 if ((tmp = malloc(sizeof(struct kill))) == NULL) { 463 event_warn("%s: malloc", __func__); 464 return (NULL); 465 } 466 tmp->base = &kill_base__; 467 468 tmp->weapon_data = NULL; 469 tmp->weapon_set = 0; 470 471 tmp->action_data = NULL; 472 tmp->action_set = 0; 473 474 tmp->how_often_data = NULL; 475 tmp->how_often_length = 0; 476 tmp->how_often_num_allocated = 0; 477 tmp->how_often_set = 0; 478 479 return (tmp); 480 } 481 482 483 484 static int 485 kill_how_often_expand_to_hold_more(struct kill *msg) 486 { 487 int tobe_allocated = msg->how_often_num_allocated; 488 ev_uint32_t* new_data = NULL; 489 tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1; 490 new_data = (ev_uint32_t*) realloc(msg->how_often_data, 491 tobe_allocated * sizeof(ev_uint32_t)); 492 if (new_data == NULL) 493 return -1; 494 msg->how_often_data = new_data; 495 msg->how_often_num_allocated = tobe_allocated; 496 return 0;} 497 498 ev_uint32_t * 499 kill_how_often_add(struct kill *msg, const ev_uint32_t value) 500 { 501 if (++msg->how_often_length >= msg->how_often_num_allocated) { 502 if (kill_how_often_expand_to_hold_more(msg)<0) 503 goto error; 504 } 505 msg->how_often_data[msg->how_often_length - 1] = value; 506 msg->how_often_set = 1; 507 return &(msg->how_often_data[msg->how_often_length - 1]); 508 error: 509 --msg->how_often_length; 510 return (NULL); 511 } 512 513 int 514 kill_weapon_assign(struct kill *msg, 515 const char * value) 516 { 517 if (msg->weapon_data != NULL) 518 free(msg->weapon_data); 519 if ((msg->weapon_data = strdup(value)) == NULL) 520 return (-1); 521 msg->weapon_set = 1; 522 return (0); 523 } 524 525 int 526 kill_action_assign(struct kill *msg, 527 const char * value) 528 { 529 if (msg->action_data != NULL) 530 free(msg->action_data); 531 if ((msg->action_data = strdup(value)) == NULL) 532 return (-1); 533 msg->action_set = 1; 534 return (0); 535 } 536 537 int 538 kill_how_often_assign(struct kill *msg, int off, 539 const ev_uint32_t value) 540 { 541 if (!msg->how_often_set || off < 0 || off >= msg->how_often_length) 542 return (-1); 543 544 { 545 msg->how_often_data[off] = value; 546 } 547 return (0); 548 } 549 550 int 551 kill_weapon_get(struct kill *msg, char * *value) 552 { 553 if (msg->weapon_set != 1) 554 return (-1); 555 *value = msg->weapon_data; 556 return (0); 557 } 558 559 int 560 kill_action_get(struct kill *msg, char * *value) 561 { 562 if (msg->action_set != 1) 563 return (-1); 564 *value = msg->action_data; 565 return (0); 566 } 567 568 int 569 kill_how_often_get(struct kill *msg, int offset, 570 ev_uint32_t *value) 571 { 572 if (!msg->how_often_set || offset < 0 || offset >= msg->how_often_length) 573 return (-1); 574 *value = msg->how_often_data[offset]; 575 return (0); 576 } 577 578 void 579 kill_clear(struct kill *tmp) 580 { 581 if (tmp->weapon_set == 1) { 582 free(tmp->weapon_data); 583 tmp->weapon_data = NULL; 584 tmp->weapon_set = 0; 585 } 586 if (tmp->action_set == 1) { 587 free(tmp->action_data); 588 tmp->action_data = NULL; 589 tmp->action_set = 0; 590 } 591 if (tmp->how_often_set == 1) { 592 free(tmp->how_often_data); 593 tmp->how_often_data = NULL; 594 tmp->how_often_set = 0; 595 tmp->how_often_length = 0; 596 tmp->how_often_num_allocated = 0; 597 } 598 } 599 600 void 601 kill_free(struct kill *tmp) 602 { 603 if (tmp->weapon_data != NULL) 604 free (tmp->weapon_data); 605 if (tmp->action_data != NULL) 606 free (tmp->action_data); 607 if (tmp->how_often_set == 1) { 608 free(tmp->how_often_data); 609 tmp->how_often_data = NULL; 610 tmp->how_often_set = 0; 611 tmp->how_often_length = 0; 612 tmp->how_often_num_allocated = 0; 613 } 614 free(tmp->how_often_data); 615 free(tmp); 616 } 617 618 void 619 kill_marshal(struct evbuffer *evbuf, const struct kill *tmp){ 620 evtag_marshal_string(evbuf, KILL_WEAPON, tmp->weapon_data); 621 evtag_marshal_string(evbuf, KILL_ACTION, tmp->action_data); 622 if (tmp->how_often_set) { 623 { 624 int i; 625 for (i = 0; i < tmp->how_often_length; ++i) { 626 evtag_marshal_int(evbuf, KILL_HOW_OFTEN, tmp->how_often_data[i]); 627 } 628 } 629 } 630 } 631 632 int 633 kill_unmarshal(struct kill *tmp, struct evbuffer *evbuf) 634 { 635 ev_uint32_t tag; 636 while (evbuffer_get_length(evbuf) > 0) { 637 if (evtag_peek(evbuf, &tag) == -1) 638 return (-1); 639 switch (tag) { 640 641 case KILL_WEAPON: 642 643 if (tmp->weapon_set) 644 return (-1); 645 if (evtag_unmarshal_string(evbuf, KILL_WEAPON, &tmp->weapon_data) == -1) { 646 event_warnx("%s: failed to unmarshal weapon", __func__); 647 return (-1); 648 } 649 tmp->weapon_set = 1; 650 break; 651 652 case KILL_ACTION: 653 654 if (tmp->action_set) 655 return (-1); 656 if (evtag_unmarshal_string(evbuf, KILL_ACTION, &tmp->action_data) == -1) { 657 event_warnx("%s: failed to unmarshal action", __func__); 658 return (-1); 659 } 660 tmp->action_set = 1; 661 break; 662 663 case KILL_HOW_OFTEN: 664 665 if (tmp->how_often_length >= tmp->how_often_num_allocated && 666 kill_how_often_expand_to_hold_more(tmp) < 0) { 667 puts("HEY NOW"); 668 return (-1); 669 } 670 if (evtag_unmarshal_int(evbuf, KILL_HOW_OFTEN, &tmp->how_often_data[tmp->how_often_length]) == -1) { 671 event_warnx("%s: failed to unmarshal how_often", __func__); 672 return (-1); 673 } 674 ++tmp->how_often_length; 675 tmp->how_often_set = 1; 676 break; 677 678 default: 679 return -1; 680 } 681 } 682 683 if (kill_complete(tmp) == -1) 684 return (-1); 685 return (0); 686 } 687 688 int 689 kill_complete(struct kill *msg) 690 { 691 if (!msg->weapon_set) 692 return (-1); 693 if (!msg->action_set) 694 return (-1); 695 return (0); 696 } 697 698 int 699 evtag_unmarshal_kill(struct evbuffer *evbuf, ev_uint32_t need_tag, struct kill *msg) 700 { 701 ev_uint32_t tag; 702 int res = -1; 703 704 struct evbuffer *tmp = evbuffer_new(); 705 706 if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag) 707 goto error; 708 709 if (kill_unmarshal(msg, tmp) == -1) 710 goto error; 711 712 res = 0; 713 714 error: 715 evbuffer_free(tmp); 716 return (res); 717 } 718 719 void 720 evtag_marshal_kill(struct evbuffer *evbuf, ev_uint32_t tag, const struct kill *msg) 721 { 722 struct evbuffer *buf_ = evbuffer_new(); 723 assert(buf_ != NULL); 724 kill_marshal(buf_, msg); 725 evtag_marshal_buffer(evbuf, tag, buf_); 726 evbuffer_free(buf_); 727 } 728 729 /* 730 * Implementation of run 731 */ 732 733 static struct run_access_ run_base__ = { 734 run_how_assign, 735 run_how_get, 736 run_some_bytes_assign, 737 run_some_bytes_get, 738 run_fixed_bytes_assign, 739 run_fixed_bytes_get, 740 run_notes_assign, 741 run_notes_get, 742 run_notes_add, 743 run_large_number_assign, 744 run_large_number_get, 745 run_other_numbers_assign, 746 run_other_numbers_get, 747 run_other_numbers_add, 748 }; 749 750 struct run * 751 run_new(void) 752 { 753 return run_new_with_arg(NULL); 754 } 755 756 struct run * 757 run_new_with_arg(void *unused) 758 { 759 struct run *tmp; 760 if ((tmp = malloc(sizeof(struct run))) == NULL) { 761 event_warn("%s: malloc", __func__); 762 return (NULL); 763 } 764 tmp->base = &run_base__; 765 766 tmp->how_data = NULL; 767 tmp->how_set = 0; 768 769 tmp->some_bytes_data = NULL; 770 tmp->some_bytes_length = 0; 771 tmp->some_bytes_set = 0; 772 773 memset(tmp->fixed_bytes_data, 0, sizeof(tmp->fixed_bytes_data)); 774 tmp->fixed_bytes_set = 0; 775 776 tmp->notes_data = NULL; 777 tmp->notes_length = 0; 778 tmp->notes_num_allocated = 0; 779 tmp->notes_set = 0; 780 781 tmp->large_number_data = 0; 782 tmp->large_number_set = 0; 783 784 tmp->other_numbers_data = NULL; 785 tmp->other_numbers_length = 0; 786 tmp->other_numbers_num_allocated = 0; 787 tmp->other_numbers_set = 0; 788 789 return (tmp); 790 } 791 792 793 794 795 static int 796 run_notes_expand_to_hold_more(struct run *msg) 797 { 798 int tobe_allocated = msg->notes_num_allocated; 799 char ** new_data = NULL; 800 tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1; 801 new_data = (char **) realloc(msg->notes_data, 802 tobe_allocated * sizeof(char *)); 803 if (new_data == NULL) 804 return -1; 805 msg->notes_data = new_data; 806 msg->notes_num_allocated = tobe_allocated; 807 return 0;} 808 809 char * * 810 run_notes_add(struct run *msg, const char * value) 811 { 812 if (++msg->notes_length >= msg->notes_num_allocated) { 813 if (run_notes_expand_to_hold_more(msg)<0) 814 goto error; 815 } 816 if (value != NULL) { 817 msg->notes_data[msg->notes_length - 1] = strdup(value); 818 if (msg->notes_data[msg->notes_length - 1] == NULL) { 819 goto error; 820 } 821 } else { 822 msg->notes_data[msg->notes_length - 1] = NULL; 823 } 824 msg->notes_set = 1; 825 return &(msg->notes_data[msg->notes_length - 1]); 826 error: 827 --msg->notes_length; 828 return (NULL); 829 } 830 831 832 static int 833 run_other_numbers_expand_to_hold_more(struct run *msg) 834 { 835 int tobe_allocated = msg->other_numbers_num_allocated; 836 ev_uint32_t* new_data = NULL; 837 tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1; 838 new_data = (ev_uint32_t*) realloc(msg->other_numbers_data, 839 tobe_allocated * sizeof(ev_uint32_t)); 840 if (new_data == NULL) 841 return -1; 842 msg->other_numbers_data = new_data; 843 msg->other_numbers_num_allocated = tobe_allocated; 844 return 0;} 845 846 ev_uint32_t * 847 run_other_numbers_add(struct run *msg, const ev_uint32_t value) 848 { 849 if (++msg->other_numbers_length >= msg->other_numbers_num_allocated) { 850 if (run_other_numbers_expand_to_hold_more(msg)<0) 851 goto error; 852 } 853 msg->other_numbers_data[msg->other_numbers_length - 1] = value; 854 msg->other_numbers_set = 1; 855 return &(msg->other_numbers_data[msg->other_numbers_length - 1]); 856 error: 857 --msg->other_numbers_length; 858 return (NULL); 859 } 860 861 int 862 run_how_assign(struct run *msg, 863 const char * value) 864 { 865 if (msg->how_data != NULL) 866 free(msg->how_data); 867 if ((msg->how_data = strdup(value)) == NULL) 868 return (-1); 869 msg->how_set = 1; 870 return (0); 871 } 872 873 int 874 run_some_bytes_assign(struct run *msg, const ev_uint8_t * value, ev_uint32_t len) 875 { 876 if (msg->some_bytes_data != NULL) 877 free (msg->some_bytes_data); 878 msg->some_bytes_data = malloc(len); 879 if (msg->some_bytes_data == NULL) 880 return (-1); 881 msg->some_bytes_set = 1; 882 msg->some_bytes_length = len; 883 memcpy(msg->some_bytes_data, value, len); 884 return (0); 885 } 886 887 int 888 run_fixed_bytes_assign(struct run *msg, const ev_uint8_t *value) 889 { 890 msg->fixed_bytes_set = 1; 891 memcpy(msg->fixed_bytes_data, value, 24); 892 return (0); 893 } 894 895 int 896 run_notes_assign(struct run *msg, int off, 897 const char * value) 898 { 899 if (!msg->notes_set || off < 0 || off >= msg->notes_length) 900 return (-1); 901 902 { 903 if (msg->notes_data[off] != NULL) 904 free(msg->notes_data[off]); 905 msg->notes_data[off] = strdup(value); 906 if (msg->notes_data[off] == NULL) { 907 event_warnx("%s: strdup", __func__); 908 return (-1); 909 } 910 } 911 return (0); 912 } 913 914 int 915 run_large_number_assign(struct run *msg, const ev_uint64_t value) 916 { 917 msg->large_number_set = 1; 918 msg->large_number_data = value; 919 return (0); 920 } 921 922 int 923 run_other_numbers_assign(struct run *msg, int off, 924 const ev_uint32_t value) 925 { 926 if (!msg->other_numbers_set || off < 0 || off >= msg->other_numbers_length) 927 return (-1); 928 929 { 930 msg->other_numbers_data[off] = value; 931 } 932 return (0); 933 } 934 935 int 936 run_how_get(struct run *msg, char * *value) 937 { 938 if (msg->how_set != 1) 939 return (-1); 940 *value = msg->how_data; 941 return (0); 942 } 943 944 int 945 run_some_bytes_get(struct run *msg, ev_uint8_t * *value, ev_uint32_t *plen) 946 { 947 if (msg->some_bytes_set != 1) 948 return (-1); 949 *value = msg->some_bytes_data; 950 *plen = msg->some_bytes_length; 951 return (0); 952 } 953 954 int 955 run_fixed_bytes_get(struct run *msg, ev_uint8_t **value) 956 { 957 if (msg->fixed_bytes_set != 1) 958 return (-1); 959 *value = msg->fixed_bytes_data; 960 return (0); 961 } 962 963 int 964 run_notes_get(struct run *msg, int offset, 965 char * *value) 966 { 967 if (!msg->notes_set || offset < 0 || offset >= msg->notes_length) 968 return (-1); 969 *value = msg->notes_data[offset]; 970 return (0); 971 } 972 973 int 974 run_large_number_get(struct run *msg, ev_uint64_t *value) 975 { 976 if (msg->large_number_set != 1) 977 return (-1); 978 *value = msg->large_number_data; 979 return (0); 980 } 981 982 int 983 run_other_numbers_get(struct run *msg, int offset, 984 ev_uint32_t *value) 985 { 986 if (!msg->other_numbers_set || offset < 0 || offset >= msg->other_numbers_length) 987 return (-1); 988 *value = msg->other_numbers_data[offset]; 989 return (0); 990 } 991 992 void 993 run_clear(struct run *tmp) 994 { 995 if (tmp->how_set == 1) { 996 free(tmp->how_data); 997 tmp->how_data = NULL; 998 tmp->how_set = 0; 999 } 1000 if (tmp->some_bytes_set == 1) { 1001 free (tmp->some_bytes_data); 1002 tmp->some_bytes_data = NULL; 1003 tmp->some_bytes_length = 0; 1004 tmp->some_bytes_set = 0; 1005 } 1006 tmp->fixed_bytes_set = 0; 1007 memset(tmp->fixed_bytes_data, 0, sizeof(tmp->fixed_bytes_data)); 1008 if (tmp->notes_set == 1) { 1009 int i; 1010 for (i = 0; i < tmp->notes_length; ++i) { 1011 if (tmp->notes_data[i] != NULL) free(tmp->notes_data[i]); 1012 } 1013 free(tmp->notes_data); 1014 tmp->notes_data = NULL; 1015 tmp->notes_set = 0; 1016 tmp->notes_length = 0; 1017 tmp->notes_num_allocated = 0; 1018 } 1019 tmp->large_number_set = 0; 1020 if (tmp->other_numbers_set == 1) { 1021 free(tmp->other_numbers_data); 1022 tmp->other_numbers_data = NULL; 1023 tmp->other_numbers_set = 0; 1024 tmp->other_numbers_length = 0; 1025 tmp->other_numbers_num_allocated = 0; 1026 } 1027 } 1028 1029 void 1030 run_free(struct run *tmp) 1031 { 1032 if (tmp->how_data != NULL) 1033 free (tmp->how_data); 1034 if (tmp->some_bytes_data != NULL) 1035 free(tmp->some_bytes_data); 1036 if (tmp->notes_set == 1) { 1037 int i; 1038 for (i = 0; i < tmp->notes_length; ++i) { 1039 if (tmp->notes_data[i] != NULL) free(tmp->notes_data[i]); 1040 } 1041 free(tmp->notes_data); 1042 tmp->notes_data = NULL; 1043 tmp->notes_set = 0; 1044 tmp->notes_length = 0; 1045 tmp->notes_num_allocated = 0; 1046 } 1047 free(tmp->notes_data); 1048 if (tmp->other_numbers_set == 1) { 1049 free(tmp->other_numbers_data); 1050 tmp->other_numbers_data = NULL; 1051 tmp->other_numbers_set = 0; 1052 tmp->other_numbers_length = 0; 1053 tmp->other_numbers_num_allocated = 0; 1054 } 1055 free(tmp->other_numbers_data); 1056 free(tmp); 1057 } 1058 1059 void 1060 run_marshal(struct evbuffer *evbuf, const struct run *tmp){ 1061 evtag_marshal_string(evbuf, RUN_HOW, tmp->how_data); 1062 if (tmp->some_bytes_set) { 1063 evtag_marshal(evbuf, RUN_SOME_BYTES, tmp->some_bytes_data, tmp->some_bytes_length); 1064 } 1065 evtag_marshal(evbuf, RUN_FIXED_BYTES, tmp->fixed_bytes_data, (24)); 1066 if (tmp->notes_set) { 1067 { 1068 int i; 1069 for (i = 0; i < tmp->notes_length; ++i) { 1070 evtag_marshal_string(evbuf, RUN_NOTES, tmp->notes_data[i]); 1071 } 1072 } 1073 } 1074 if (tmp->large_number_set) { 1075 evtag_marshal_int64(evbuf, RUN_LARGE_NUMBER, tmp->large_number_data); 1076 } 1077 if (tmp->other_numbers_set) { 1078 { 1079 int i; 1080 for (i = 0; i < tmp->other_numbers_length; ++i) { 1081 evtag_marshal_int(evbuf, RUN_OTHER_NUMBERS, tmp->other_numbers_data[i]); 1082 } 1083 } 1084 } 1085 } 1086 1087 int 1088 run_unmarshal(struct run *tmp, struct evbuffer *evbuf) 1089 { 1090 ev_uint32_t tag; 1091 while (evbuffer_get_length(evbuf) > 0) { 1092 if (evtag_peek(evbuf, &tag) == -1) 1093 return (-1); 1094 switch (tag) { 1095 1096 case RUN_HOW: 1097 1098 if (tmp->how_set) 1099 return (-1); 1100 if (evtag_unmarshal_string(evbuf, RUN_HOW, &tmp->how_data) == -1) { 1101 event_warnx("%s: failed to unmarshal how", __func__); 1102 return (-1); 1103 } 1104 tmp->how_set = 1; 1105 break; 1106 1107 case RUN_SOME_BYTES: 1108 1109 if (tmp->some_bytes_set) 1110 return (-1); 1111 if (evtag_payload_length(evbuf, &tmp->some_bytes_length) == -1) 1112 return (-1); 1113 if (tmp->some_bytes_length > evbuffer_get_length(evbuf)) 1114 return (-1); 1115 if ((tmp->some_bytes_data = malloc(tmp->some_bytes_length)) == NULL) 1116 return (-1); 1117 if (evtag_unmarshal_fixed(evbuf, RUN_SOME_BYTES, tmp->some_bytes_data, tmp->some_bytes_length) == -1) { 1118 event_warnx("%s: failed to unmarshal some_bytes", __func__); 1119 return (-1); 1120 } 1121 tmp->some_bytes_set = 1; 1122 break; 1123 1124 case RUN_FIXED_BYTES: 1125 1126 if (tmp->fixed_bytes_set) 1127 return (-1); 1128 if (evtag_unmarshal_fixed(evbuf, RUN_FIXED_BYTES, tmp->fixed_bytes_data, (24)) == -1) { 1129 event_warnx("%s: failed to unmarshal fixed_bytes", __func__); 1130 return (-1); 1131 } 1132 tmp->fixed_bytes_set = 1; 1133 break; 1134 1135 case RUN_NOTES: 1136 1137 if (tmp->notes_length >= tmp->notes_num_allocated && 1138 run_notes_expand_to_hold_more(tmp) < 0) { 1139 puts("HEY NOW"); 1140 return (-1); 1141 } 1142 if (evtag_unmarshal_string(evbuf, RUN_NOTES, &tmp->notes_data[tmp->notes_length]) == -1) { 1143 event_warnx("%s: failed to unmarshal notes", __func__); 1144 return (-1); 1145 } 1146 ++tmp->notes_length; 1147 tmp->notes_set = 1; 1148 break; 1149 1150 case RUN_LARGE_NUMBER: 1151 1152 if (tmp->large_number_set) 1153 return (-1); 1154 if (evtag_unmarshal_int64(evbuf, RUN_LARGE_NUMBER, &tmp->large_number_data) == -1) { 1155 event_warnx("%s: failed to unmarshal large_number", __func__); 1156 return (-1); 1157 } 1158 tmp->large_number_set = 1; 1159 break; 1160 1161 case RUN_OTHER_NUMBERS: 1162 1163 if (tmp->other_numbers_length >= tmp->other_numbers_num_allocated && 1164 run_other_numbers_expand_to_hold_more(tmp) < 0) { 1165 puts("HEY NOW"); 1166 return (-1); 1167 } 1168 if (evtag_unmarshal_int(evbuf, RUN_OTHER_NUMBERS, &tmp->other_numbers_data[tmp->other_numbers_length]) == -1) { 1169 event_warnx("%s: failed to unmarshal other_numbers", __func__); 1170 return (-1); 1171 } 1172 ++tmp->other_numbers_length; 1173 tmp->other_numbers_set = 1; 1174 break; 1175 1176 default: 1177 return -1; 1178 } 1179 } 1180 1181 if (run_complete(tmp) == -1) 1182 return (-1); 1183 return (0); 1184 } 1185 1186 int 1187 run_complete(struct run *msg) 1188 { 1189 if (!msg->how_set) 1190 return (-1); 1191 if (!msg->fixed_bytes_set) 1192 return (-1); 1193 return (0); 1194 } 1195 1196 int 1197 evtag_unmarshal_run(struct evbuffer *evbuf, ev_uint32_t need_tag, struct run *msg) 1198 { 1199 ev_uint32_t tag; 1200 int res = -1; 1201 1202 struct evbuffer *tmp = evbuffer_new(); 1203 1204 if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag) 1205 goto error; 1206 1207 if (run_unmarshal(msg, tmp) == -1) 1208 goto error; 1209 1210 res = 0; 1211 1212 error: 1213 evbuffer_free(tmp); 1214 return (res); 1215 } 1216 1217 void 1218 evtag_marshal_run(struct evbuffer *evbuf, ev_uint32_t tag, const struct run *msg) 1219 { 1220 struct evbuffer *buf_ = evbuffer_new(); 1221 assert(buf_ != NULL); 1222 run_marshal(buf_, msg); 1223 evtag_marshal_buffer(evbuf, tag, buf_); 1224 evbuffer_free(buf_); 1225 } 1226 1227