This source file includes following definitions.
- msg_new
- msg_new_with_arg
- msg_run_expand_to_hold_more
- msg_run_add
- msg_from_name_assign
- msg_to_name_assign
- msg_attack_assign
- msg_run_assign
- msg_from_name_get
- msg_to_name_get
- msg_attack_get
- msg_run_get
- msg_clear
- msg_free
- msg_marshal
- msg_unmarshal
- msg_complete
- evtag_unmarshal_msg
- evtag_marshal_msg
- kill_new
- kill_new_with_arg
- kill_how_often_expand_to_hold_more
- kill_how_often_add
- kill_weapon_assign
- kill_action_assign
- kill_how_often_assign
- kill_weapon_get
- kill_action_get
- kill_how_often_get
- kill_clear
- kill_free
- kill_marshal
- kill_unmarshal
- kill_complete
- evtag_unmarshal_kill
- evtag_marshal_kill
- run_new
- run_new_with_arg
- run_notes_expand_to_hold_more
- run_notes_add
- run_other_numbers_expand_to_hold_more
- run_other_numbers_add
- run_how_assign
- run_some_bytes_assign
- run_fixed_bytes_assign
- run_notes_assign
- run_large_number_assign
- run_other_numbers_assign
- run_how_get
- run_some_bytes_get
- run_fixed_bytes_get
- run_notes_get
- run_large_number_get
- run_other_numbers_get
- run_clear
- run_free
- run_marshal
- run_unmarshal
- run_complete
- evtag_unmarshal_run
- evtag_marshal_run
1
2
3
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
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
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
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