libevent/test/regress.gen.c

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