external/bsd/libevent/dist/test/regress.gen.c

   1 /*      $NetBSD: regress.gen.c,v 1.1.1.2 2013/04/11 16:43:32 christos Exp $     */
   2 /*
   3  * Automatically generated from ./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 #ifdef _EVENT___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