xref: /freebsd/contrib/ntp/sntp/libevent/test/regress.gen.c (revision 19261079b74319502c6ffa1249920079f0f69a72) 
1 /*
2  * Automatically generated from /ntpbuild/data/snaps/ntp-stable/sntp/libevent/test/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 
1226