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