?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "TODO epan/dissectors/asn1/kerberos/packet-kerberos-template.c new GSS flags"
[wireshark-sm.git] / epan / dissectors / dcerpc / idl2wrs.c
blobbb59ff000fee98b414256c54d8d77004b9998306
1 /* idl2wrs.c
2 * DCE RPC IDL to Wireshark dissector compiler
3 *
4 * Wireshark - Network traffic analyzer
5 * By Gerald Combs <gerald@wireshark.org>
6 * Copyright 1998 Gerald Combs
7 *
8 * SPDX-License-Identifier: GPL-2.0-or-later
9 */
10
11 /*
12 TODO
13 check that every cnf defined type,hffield,rename,... has been referenced
14 at least once and if not, abort with an error
15
16 need to distinguish between NTTIME (absolute time) and relative time
17
18 prune_xxx should only act inside of '[' ']'
19
20 add support for bool8,16,32,64 with tfs strings
21
22 add the remaining array type (uvarray)
23
24 add code to verify that union tag length is correct
25 */
26 /* List of built in types :
27 WERROR A 32 bit integer holding a DCE/NT status code.
28
29 uint8 A 8 bit integer
30 int8
31
32 uint16 A 16 bit integer
33 int16
34
35 uint32 A 32 bit integer
36 int32
37
38 uint64 A 64 bit integer
39
40 udlong A 64 bit integer aligned on 4 byte boundary
41 dlong
42
43 time_t A 32 bit integer holding a unix style time_t
44
45 NTTIME_hyper A 64 bit integer representing a NTTIME
46 NTTIME_1sec
47
48 unistr A conformant and varying unicode string
49
50 ascstr A conformant and varying ascii string
51
52
53 SID A SID structure.
54
55 uuid_t A 16 byte FT_GUID blob.
56 GUID
57
58
59 policy_handle
60 bool8
61 uuid_t
62 policy_handle
63 NTTIME
64 */
65
66 /* All field dissectors that call a normal type
67 (i.e. not a pointer, not an array)
68 has a local variable unsigned param declared which is passed on to the
69 type dissector.
70 The default value is 0 but the PARAM_VALUE conformance tag can be used to
71 change it.
72 This is only meaningful if the called type dissector actually does anything
73 with this parameter.
74 */
75
76 #define _GNU_SOURCE
77
78 #include <glib.h>
79 #include <glib/gstdio.h>
80 #include <string.h>
81 #include <stdlib.h>
82 #include <stdarg.h>
83 #include <wsutil/strtoi.h>
84
85 #undef IDL2WRS_DEBUG
86
87 #define DISSECTORNAME_MAXLEN 256
88
89 #define BASE_BUFFER_SIZE 256
90
91 static FILE *tfh, *eth_code, *eth_hdr, *eth_hf, *eth_hfarr, *eth_ett, *eth_ettarr, *eth_ft, *eth_handoff;
92 static char *uuid=NULL;
93 static char *version=NULL;
94 static const char *pointer_default=NULL;
95 static char *ifname=NULL;
96 static char hf_status[BASE_BUFFER_SIZE];
97 static int lineno,linepos;
98 static char line[4 * BASE_BUFFER_SIZE];
99
100 static void FPRINTF(FILE *fh, const char *format, ...)
101 {
102 va_list args;
103
104 #ifdef IDL2WRS_DEBUG
105 va_start(args, format);
106 vfprintf (stderr, format, args);
107 va_end(args);
108 #endif
109 if (fh) {
110 va_start(args, format);
111 vfprintf (fh, format, args);
112 va_end(args);
113 }
114 }
115
116 typedef struct _pointer_item_t {
117 struct _pointer_item_t *next;
118 const char *type;
119 } pointer_item_t;
120
121 #define BI_CASE 0x00000001
122 #define BI_CASE_DEFAULT 0x00000002
123 #define BI_IN 0x00000004
124 #define BI_OUT 0x00000008
125 #define BI_SIZE_IS 0x00000010
126 #define BI_LENGTH_IS 0x00000020
127 #define BI_POINTER 0x00000040
128 #define BI_BITMAP8 0x00000100
129 #define BI_BITMAP32 0x00000200
130 #define BI_SWITCH_TYPE 0x00000400
131 typedef struct _bracket_item_t {
132 unsigned int flags;
133 const char *case_name;
134 pointer_item_t *pointer_list;
135 int union_tag_size;
136 } bracket_item_t;
137
138 typedef struct _no_emit_item_t {
139 struct _no_emit_item_t *next;
140 char *name;
141 } no_emit_item_t;
142 static no_emit_item_t *no_emit_list=NULL;
143
144 typedef struct _hf_rename_item_t {
145 struct _hf_rename_item_t *next;
146 int refcount; /* number of times this rename has been referenced */
147 char *old_name;
148 char *new_name;
149 } hf_rename_item_t;
150 static hf_rename_item_t *hf_rename_list=NULL;
151
152 typedef struct _enum_list_t {
153 struct _enum_list_t *next;
154 char *name;
155 int val;
156 } enum_list_t;
157
158 typedef struct _token_item_t {
159 struct _token_item_t *next;
160 char *str;
161 } token_item_t;
162 static token_item_t *token_list=NULL;
163 static token_item_t *last_token_item=NULL;
164
165 typedef struct _type_item_t {
166 struct _type_item_t *next;
167 char *name;
168 char *dissector;
169 char *ft_type;
170 char *base_type;
171 char *mask;
172 char *vals;
173 int alignment;
174 } type_item_t;
175 static type_item_t *type_list=NULL;
176
177 typedef struct _union_tag_size_item_t {
178 struct _union_tag_size_item_t *next;
179 char *name;
180 int size;
181 } union_tag_size_item_t;
182 static union_tag_size_item_t *union_tag_size_list=NULL;
183
184 typedef struct _hf_field_item_t {
185 struct _hf_field_item_t *next;
186 char *name;
187 char *ft_type;
188 } hf_field_item_t;
189 static hf_field_item_t *hf_field_list=NULL;
190
191 typedef struct _dissector_param_value_t {
192 struct _dissector_param_value_t *next;
193 char *name;
194 char *value;
195 } dissector_param_value_t;
196 static dissector_param_value_t *dissector_param_list=NULL;
197
198 static type_item_t *find_type(char *name);
199 static int Exit(int code);
200
201 static void
202 register_dissector_param_value(const char *name, const char *value)
203 {
204 dissector_param_value_t *dpv;
205 dpv=g_new0(dissector_param_value_t, 1);
206 if (!dpv) {
207 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
208 exit(10);
209 }
210 dpv->next=dissector_param_list;
211 dissector_param_list=dpv;
212 dpv->name=g_strdup(name);
213 dpv->value=g_strdup(value);
214 }
215
216 static const char *
217 find_dissector_param_value(char *name)
218 {
219 dissector_param_value_t *dpv;
220 for(dpv=dissector_param_list;dpv;dpv=dpv->next){
221 if(!g_strcmp0(name,dpv->name)){
222 return dpv->value;
223 }
224 }
225 return "0";
226 }
227
228 static pointer_item_t *
229 prepend_pointer_list(pointer_item_t *ptrs, int num_pointers)
230 {
231 pointer_item_t *pi;
232
233 pi=ptrs;
234 while(pi){
235 if(num_pointers)num_pointers--;
236 pi=pi->next;
237 }
238 pi=ptrs;
239 while(num_pointers--){
240 pi=g_new0(pointer_item_t, 1);
241 if (!pi) {
242 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
243 exit(10);
244 }
245 pi->next=ptrs;
246 pi->type=pointer_default;
247 ptrs=pi;
248 }
249 ptrs=pi;
250
251 return ptrs;
252 }
253
254 static const char *
255 ptr_to_define(const char *pointer_type)
256 {
257 if(!g_strcmp0(pointer_type, "unique")){
258 return "NDR_POINTER_UNIQUE";
259 } else if(!g_strcmp0(pointer_type, "ref")){
260 return "NDR_POINTER_REF";
261 } else if(!g_strcmp0(pointer_type, "ptr")){
262 return "NDR_POINTER_PTR";
263 }
264
265 FPRINTF(stderr, "prt_to_define, weirdo pointer :%s\n", pointer_type);
266 exit(10);
267 }
268
269 static int
270 get_union_tag_size(char *name)
271 {
272 union_tag_size_item_t *utsi;
273 for(utsi=union_tag_size_list;utsi;utsi=utsi->next){
274 if(!g_strcmp0(name, utsi->name)){
275 return utsi->size;
276 }
277 }
278 FPRINTF(stderr, "ERROR: size of tag for union:%s is not known\n", name);
279 FPRINTF(stderr, " use the UNION_TAG_SIZE directive to specify it in the conformance file\n");
280 exit(10);
281 }
282
283
284 /* this function will add an entry to the hf_rename list */
285 static void
286 register_hf_rename(const char *old_name, const char *new_name)
287 {
288 hf_rename_item_t *new_item;
289 new_item=g_new0(hf_rename_item_t, 1);
290 if (!new_item) {
291 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
292 exit(10);
293 }
294 new_item->next=hf_rename_list;
295 hf_rename_list=new_item;
296 new_item->refcount=0;
297 new_item->old_name=g_strdup(old_name);
298 new_item->new_name=g_strdup(new_name);
299 }
300
301 /* this function checks that all hf_rename fields have actually been referenced
302 if not out conformance file is stale
303 */
304 static void
305 check_hf_rename_refcount(void)
306 {
307 hf_rename_item_t *hri;
308
309 /* don't generate code for renamed hf fields just return the new name*/
310 for(hri=hf_rename_list;hri;hri=hri->next){
311 if(!hri->refcount){
312 FPRINTF(stderr, "ERROR: the hf_rename field:%s was never referenced. it is likely the conformance file is stale\n", hri->old_name);
313 exit(10);
314 }
315 }
316 }
317
318 static hf_field_item_t *
319 find_hf_field(char *name)
320 {
321 hf_field_item_t *hfi;
322
323 for(hfi=hf_field_list;hfi;hfi=hfi->next){
324 if(!g_strcmp0(hfi->name, name)){
325 break;
326 }
327 }
328 if (!hfi) {
329 FPRINTF(stderr, "find_hf_field: unknown hf_field:%s\n",name);
330 Exit(10);
331 }
332
333 return hfi;
334 }
335
336
337 /* this function will create the code required for a hf field.
338 it MIGHT rename the field so a user MUST use the name returned
339 from this function.
340 for fields that are to be renamed no code is generated
341 */
342 static const char *
343 register_hf_field(const char *hf_name, const char *title, const char *filter_name, const char *ft_type, const char *base_type, const char *valsstring, const char *mask, const char *blurb)
344 {
345 hf_field_item_t *hfi;
346 hf_rename_item_t *hri;
347
348 /* don't generate code for renamed hf fields just return the new name*/
349 for(hri=hf_rename_list;hri;hri=hri->next){
350 if(!strncmp(hf_name, hri->old_name, strlen(hf_name))){
351 hfi=find_hf_field(hri->new_name);
352 if(g_strcmp0(ft_type, hfi->ft_type)){
353 FPRINTF(stderr, "register_hf_field: hf_fields %s and %s have different types %s %s\n",hf_name,hfi->name,ft_type,hfi->ft_type);
354 Exit(10);
355 }
356 hri->refcount++;
357 return hri->new_name;
358 }
359 }
360
361 hfi=g_new0(hf_field_item_t, 1);
362 if (!hfi) {
363 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
364 exit(10);
365 }
366 hfi->next=hf_field_list;
367 hf_field_list=hfi;
368 hfi->name=g_strdup(hf_name);
369 hfi->ft_type=g_strdup(ft_type);
370
371 FPRINTF(eth_hf, "static int %s;\n", hf_name);
372 FPRINTF(eth_hfarr, " { &%s,\n", hf_name);
373 FPRINTF(eth_hfarr, " { \"%s\", \"%s\", %s, %s,\n", title, filter_name, ft_type, base_type);
374 FPRINTF(eth_hfarr, " %s, %s,\n", valsstring, mask);
375 if (strlen(blurb) > 0)
376 FPRINTF(eth_hfarr, " \"%s\", HFILL }},\n", blurb);
377 else
378 FPRINTF(eth_hfarr, " NULL, HFILL }},\n");
379 FPRINTF(eth_hfarr, "\n");
380
381 return hf_name;
382 }
383
384 /* this function will parse the no emit list and decide whether code should
385 be generated for this dissector or if we should only register the type.
386 */
387 static int
388 check_if_to_emit(char *name)
389 {
390 no_emit_item_t *nel;
391
392 for(nel=no_emit_list;nel;nel=nel->next){
393 if(!g_strcmp0(name, nel->name)){
394 FPRINTF(NULL, "SKIPPED emitting of %s\n",name);
395 return 0;
396 }
397 }
398 return 1;
399 }
400
401 #if 0
402 static void
403 prune_keywords(char *name)
404 {
405 token_item_t *ti;
406
407 for(ti=token_list;ti;ti=ti->next){
408 if(!ti->next){
409 break;
410 }
411 if(!g_strcmp0(ti->next->str, name)){
412 if(!g_strcmp0(ti->next->next->str, ",")){
413 ti->next=ti->next->next->next;
414 } else {
415 ti->next=ti->next->next;
416 }
417 }
418 }
419 }
420 #endif
421
422 static void
423 rename_tokens(const char *old_name, const char *new_name)
424 {
425 token_item_t *ti;
426
427 for(ti=token_list;ti;ti=ti->next){
428 if(!g_strcmp0(ti->str, old_name)){
429 ti->str=g_strdup(new_name);
430 }
431 }
432 }
433
434 static void
435 prune_keyword_parameters(const char *name)
436 {
437 token_item_t *ti, *tmpti;
438
439 for(ti=token_list;ti;ti=ti->next){
440 if(!g_strcmp0(ti->str, name)){
441 if(!g_strcmp0(ti->next->str, "(")){
442 tmpti=ti;
443 while(1){
444 if(!g_strcmp0(tmpti->str, ")")){
445 ti->next=tmpti->next;
446 break;
447 }
448 tmpti=tmpti->next;
449 }
450 }
451 }
452 }
453 }
454
455 /* this function will parse a bracket item
456 [ ... ]
457 it will return the token of the next item following the ']'
458 */
459 static token_item_t *
460 parsebrackets(token_item_t *ti, bracket_item_t **bracket){
461 bracket_item_t *br;
462 const type_item_t *type_item;
463
464 if(g_strcmp0(ti->str, "[")){
465 FPRINTF(stderr, "ERROR: parsebrackets first token is not '['\n");
466 Exit(10);
467 }
468 ti=ti->next;
469
470 br=g_new0(bracket_item_t, 1);
471 if (!br) {
472 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
473 exit(10);
474 }
475 *bracket=br;
476 br->flags=0;
477 br->case_name=NULL;
478 br->pointer_list=NULL;
479
480 while(ti){
481 if( !g_strcmp0(ti->str, "{")
482 ||!g_strcmp0(ti->str, "}")){
483 FPRINTF(stderr, "ERROR: parsebrackets '{' '}' inside bracket item\n");
484 Exit(10);
485 }
486
487 if(!g_strcmp0(ti->str, "[")){
488 FPRINTF(stderr, "ERROR: parsebrackets '[' inside bracket item\n");
489 Exit(10);
490 }
491
492 /* finished */
493 if(!g_strcmp0(ti->str, "]")){
494 /* check for [ ... ] [ ...] */
495 ti=ti->next;
496
497 if(!g_strcmp0(ti->str, "[")){
498 ti=ti->next;
499 continue;
500 }
501 return ti;
502 }
503
504 /* just ignore all ',' */
505 if(!g_strcmp0(ti->str, ",")){
506 ti=ti->next;
507 continue;
508 }
509
510 /* case '(' tag ')' */
511 if(!g_strcmp0(ti->str, "case")){
512 br->flags|=BI_CASE;
513 ti=ti->next;
514
515 if(g_strcmp0(ti->str, "(")){
516 FPRINTF(stderr, "ERROR: parsebrackets case not followed by '('\n");
517 Exit(10);
518 }
519 ti=ti->next;
520
521 /* name */
522 br->case_name=ti->str;
523 ti=ti->next;
524
525 if(g_strcmp0(ti->str, ")")){
526 FPRINTF(stderr, "ERROR: parsebrackets case does not end with ')'\n");
527 Exit(10);
528 }
529 ti=ti->next;
530 continue;
531 }
532
533 /* default */
534 if(!g_strcmp0(ti->str, "default")){
535 br->flags|=BI_CASE;
536 br->flags|=BI_CASE_DEFAULT;
537 br->case_name="default";
538 ti=ti->next;
539 continue;
540 }
541
542
543 /* in */
544 if(!g_strcmp0(ti->str, "in")){
545 br->flags|=BI_IN;
546 ti=ti->next;
547 continue;
548 }
549
550 /* out */
551 if(!g_strcmp0(ti->str, "out")){
552 br->flags|=BI_OUT;
553 ti=ti->next;
554 continue;
555 }
556
557 /* public : we don't care about this one */
558 if(!g_strcmp0(ti->str, "public")){
559 ti=ti->next;
560 continue;
561 }
562
563 /* gensize : we don't care about this one */
564 if(!g_strcmp0(ti->str, "gensize")){
565 ti=ti->next;
566 continue;
567 }
568
569 /* switch_is */
570 if(!g_strcmp0(ti->str, "switch_is")){
571 FPRINTF(stderr, "WARNING: parsebrackets can not handle switch_is properly yet so we can not verify the tag size\n");
572 while(ti){
573 if(!g_strcmp0(ti->str, ")")){
574 ti=ti->next;
575 break;
576 }
577 ti=ti->next;
578 }
579 continue;
580 }
581
582 /* switch_is */
583 if(!g_strcmp0(ti->str, "subcontext")){
584 while(ti){
585 if(!g_strcmp0(ti->str, ")")){
586 ti=ti->next;
587 break;
588 }
589 ti=ti->next;
590 }
591 continue;
592 }
593
594 /* value we don't care about this one so just skip it */
595 if(!g_strcmp0(ti->str, "value")){
596 int level;
597 ti=ti->next;
598 if( g_strcmp0(ti->str, "(") ){
599 FPRINTF(stderr, "WARNING: parsebrackets value was not followed by '('\n");
600 Exit(10);
601 }
602 level=0;
603 while(ti){
604 if(!g_strcmp0(ti->str, "(")){
605 ti=ti->next;
606 level++;
607 continue;
608 }
609 if(!g_strcmp0(ti->str, ")")){
610 ti=ti->next;
611 level--;
612 if(level){
613 continue;
614 }
615 break;
616 }
617 ti=ti->next;
618 }
619 continue;
620 }
621
622 /* range we don't care about this one so just skip it */
623 if(!g_strcmp0(ti->str, "range")){
624 int level;
625 ti=ti->next;
626 if( g_strcmp0(ti->str, "(") ){
627 FPRINTF(stderr, "WARNING: parsebrackets range was not followed by '('\n");
628 Exit(10);
629 }
630 level=0;
631 while(ti){
632 if(!g_strcmp0(ti->str, "(")){
633 ti=ti->next;
634 level++;
635 continue;
636 }
637 if(!g_strcmp0(ti->str, ")")){
638 ti=ti->next;
639 level--;
640 if(level){
641 continue;
642 }
643 break;
644 }
645 ti=ti->next;
646 }
647 continue;
648 }
649
650 /* flag we don't care about this one so just skip it */
651 if(!g_strcmp0(ti->str, "flag")){
652 int level;
653 ti=ti->next;
654 if( g_strcmp0(ti->str, "(") ){
655 FPRINTF(stderr, "WARNING: parsebrackets flag was not followed by '('\n");
656 Exit(10);
657 }
658 level=0;
659 while(ti){
660 if(!g_strcmp0(ti->str, "(")){
661 ti=ti->next;
662 level++;
663 continue;
664 }
665 if(!g_strcmp0(ti->str, ")")){
666 ti=ti->next;
667 level--;
668 if(level){
669 continue;
670 }
671 break;
672 }
673 ti=ti->next;
674 }
675 continue;
676 }
677
678 /* switch_type */
679 if(!g_strcmp0(ti->str, "switch_type")){
680 br->flags|=BI_SWITCH_TYPE;
681 ti=ti->next;
682
683 if(g_strcmp0(ti->str, "(")){
684 FPRINTF(stderr, "WARNING: parsebrackets switch_type was not followed by '('\n");
685 Exit(10);
686 }
687 ti=ti->next;
688
689 type_item=find_type(ti->str);
690 if(!type_item){
691 FPRINTF(stderr, "ERROR : parsebrackets switch_type unknown type %s\n",ti->str);
692 Exit(10);
693 }
694 br->union_tag_size=type_item->alignment;
695 ti=ti->next;
696
697 if(g_strcmp0(ti->str, ")")){
698 FPRINTF(stderr, "WARNING: parsebrackets switch_type did not end with ')'\n");
699 Exit(10);
700 }
701 ti=ti->next;
702
703 continue;
704 }
705
706 /* size_is */
707 if(!g_strcmp0(ti->str, "size_is")){
708 br->flags|=BI_SIZE_IS;
709 ti=ti->next;
710 continue;
711 }
712
713 /* length_is */
714 if(!g_strcmp0(ti->str, "length_is")){
715 br->flags|=BI_LENGTH_IS;
716 ti=ti->next;
717 continue;
718 }
719
720 /* bitmap8bit */
721 if(!g_strcmp0(ti->str, "bitmap8bit")){
722 br->flags|=BI_BITMAP8;
723 ti=ti->next;
724 continue;
725 }
726
727 /* bitmap32bit */
728 if(!g_strcmp0(ti->str, "bitmap32bit")){
729 br->flags|=BI_BITMAP32;
730 ti=ti->next;
731 continue;
732 }
733
734 /* ref, unique or ptr */
735 if(!g_strcmp0(ti->str, "ref")
736 || !g_strcmp0(ti->str, "unique")
737 || !g_strcmp0(ti->str, "ptr")){
738 pointer_item_t *newpi;
739
740 br->flags|=BI_POINTER;
741 newpi=g_new0(pointer_item_t, 1);
742 if (!newpi) {
743 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
744 exit(10);
745 }
746 newpi->next=NULL;
747 newpi->type=ti->str;
748 newpi->next=br->pointer_list;
749 br->pointer_list=newpi;
750 ti=ti->next;
751 continue;
752 }
753 if(ti){
754 FPRINTF(stderr, "ERROR: parsebrackets should not be reached unknown tag:%s\n", ti->str);
755 }
756 Exit(10);
757 }
758
759 return NULL;
760 }
761
762 /* this function will register a new type learnt from the IDL file
763 */
764 static type_item_t *
765 register_new_type(const char *name, const char *dissectorname, const char *ft_type, const char *base_type, const char *mask, const char *valsstring, int alignment){
766 type_item_t *new_type;
767
768 FPRINTF(NULL,"XXX new type:%s dissector:%s Type:%s Base:%s Mask:%s Vals:%s alignment:%d\n", name, dissectorname, ft_type, base_type, mask, valsstring, alignment);
769
770 new_type=g_new0(type_item_t, 1);
771 if (!new_type) {
772 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
773 exit(10);
774 }
775 new_type->next=type_list;
776 new_type->name=g_strdup(name);
777 new_type->dissector=g_strdup(dissectorname);
778 new_type->ft_type=g_strdup(ft_type);
779 new_type->base_type=g_strdup(base_type);
780 new_type->mask=g_strdup(mask);
781 new_type->vals=g_strdup(valsstring);
782 new_type->alignment=alignment;
783 type_list=new_type;
784
785 return new_type;
786 }
787
788
789 /* this function will print the remaining content of the token list
790 */
791 static void printtokenlist(int count)
792 {
793 token_item_t *ti;
794 FPRINTF(stderr, "TOKENLIST:\n");
795 for(ti=token_list;ti&&count;count--,ti=ti->next){
796 FPRINTF(stderr, "Token \"%s\"\n",ti->str);
797 }
798 if(!count){
799 FPRINTF(stderr, " ...\n");
800 }
801 }
802
803
804 /* this function will parse the header and pick up the fields
805 * we are interested in.
806 * the header is supposed to start at the very first token and look like
807 * [ <fields> ] inteface <ifname> {
808 *
809 * we are interested in the fields:
810 * uuid
811 * version
812 * pointer_default
813 *
814 * this function will also g_remove the header from the token list
815 */
816 static void parseheader(void)
817 {
818 char filter_name[BASE_BUFFER_SIZE];
819 token_item_t *ti;
820 int level=0;
821 int major, minor;
822
823 ti=token_list;
824 if(!ti){
825 FPRINTF(stderr, "ERROR: no tokens\n");
826 Exit(10);
827 }
828
829 /* first token must be '[' */
830 if( g_strcmp0(ti->str, "[") ){
831 FPRINTF(stderr, "ERROR: first token is not '['\n");
832 Exit(10);
833 }
834
835 for(ti=token_list;ti;ti=ti->next){
836 if( !g_strcmp0(ti->str, "[")){
837 level++;
838 continue;
839 }
840 if( !g_strcmp0(ti->str, "]")){
841 level--;
842 if(!level){
843 token_list=ti->next;
844 break;
845 }
846 }
847 if(level==1){
848 if( !g_strcmp0(ti->str, "uuid")){
849 uuid=ti->next->next->str;
850 FPRINTF(NULL,"UUID:%s\n",uuid);
851 }
852 if( !g_strcmp0(ti->str, "version")){
853 version=ti->next->next->str;
854 FPRINTF(NULL,"VERSION:%s\n",version);
855 }
856 if( !g_strcmp0(ti->str, "pointer_default")){
857 if(!g_strcmp0(ti->next->next->str, "unique")){
858 pointer_default="unique";
859 } else if(!g_strcmp0(ti->next->next->str, "ptr")){
860 pointer_default="ptr";
861 } else {
862 FPRINTF(stderr, "ERROR: unknown pointer type\n");
863 Exit(10);
864 }
865 FPRINTF(NULL,"POINTER_DEFAULT:%s\n",pointer_default);
866 }
867 }
868 }
869 if(!token_list){
870 FPRINTF(stderr, "ERROR: ran out of tokens inside header\n");
871 Exit(10);
872 }
873 /* interface */
874 if(g_strcmp0(token_list->str, "interface")){
875 FPRINTF(stderr, "ERROR: interface not found\n");
876 Exit(10);
877 }
878 token_list=token_list->next;
879 if (!token_list){
880 FPRINTF(stderr, "ERROR: ran out of tokens\n");
881 Exit(10);
882 }
883 /* interface name */
884 ifname=token_list->str;
885 token_list=token_list->next;
886 FPRINTF(NULL,"Interface:%s\n",ifname);
887
888 /* opnum */
889 snprintf(hf_status, BASE_BUFFER_SIZE, "hf_%s_opnum", ifname);
890 snprintf(filter_name, BASE_BUFFER_SIZE, "%s.opnum", ifname);
891 register_hf_field(hf_status, "Operation", filter_name, "FT_UINT16", "BASE_DEC", "NULL", "0", "");
892
893 /* status */
894 snprintf(hf_status, BASE_BUFFER_SIZE, "hf_%s_rc", ifname);
895 snprintf(filter_name, BASE_BUFFER_SIZE, "%s.rc", ifname);
896 register_hf_field(hf_status, "Return code", filter_name, "FT_UINT32", "BASE_HEX|BASE_EXT_STRING", "&NT_errors_ext", "0", "");
897
898 FPRINTF(eth_ett, "static int ett_%s;\n", ifname);
899 FPRINTF(eth_ettarr, " &ett_%s,\n", ifname);
900
901 /* the body must start with { */
902 if(g_strcmp0(token_list->str, "{")){
903 FPRINTF(stderr, "ERROR: body does not start with '{'\n");
904 Exit(10);
905 }
906
907 /* skip the initial '{' */
908 token_list=token_list->next;
909
910 if(!uuid){
911 FPRINTF(stderr, "ERROR: no uuid found\n");
912 Exit(10);
913 }
914 FPRINTF(eth_code,"static e_guid_t uuid_dcerpc_%s = {\n", ifname);
915 FPRINTF(eth_code," 0x%c%c%c%c%c%c%c%c, 0x%c%c%c%c, 0x%c%c%c%c,\n",uuid[1],uuid[2],uuid[3],uuid[4],uuid[5],uuid[6],uuid[7],uuid[8],uuid[10],uuid[11],uuid[12],uuid[13],uuid[15],uuid[16],uuid[17],uuid[18]);
916 FPRINTF(eth_code," { 0x%c%c, 0x%c%c, 0x%c%c, 0x%c%c, 0x%c%c, 0x%c%c, 0x%c%c, 0x%c%c}\n",uuid[20],uuid[21],uuid[22],uuid[23],uuid[25],uuid[26],uuid[27],uuid[28],uuid[29],uuid[30],uuid[31],uuid[32],uuid[33],uuid[34],uuid[35],uuid[36]);
917 FPRINTF(eth_code,"};\n");
918 FPRINTF(eth_code,"\n");
919
920 sscanf(version, "%d.%d", &major, &minor);
921 FPRINTF(eth_code,"static uint16_t ver_%s = %d;\n", ifname, major);
922 FPRINTF(eth_code,"\n");
923
924 FPRINTF(eth_handoff, " dcerpc_init_uuid(proto_%s, ett_%s,\n", ifname, ifname);
925 FPRINTF(eth_handoff, " &uuid_dcerpc_%s, ver_%s,\n", ifname, ifname);
926 FPRINTF(eth_handoff, " function_dissectors, hf_%s_opnum);\n", ifname);
927 }
928
929
930
931 /* this helper function is called by the tokenizer and will just append the
932 current token to the linked list
933 */
934 static void pushtoken(char *token)
935 {
936 token_item_t *new_token_item;
937 new_token_item=g_new0(token_item_t, 1);
938 if (!new_token_item) {
939 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
940 exit(10);
941 }
942 new_token_item->next=NULL;
943 new_token_item->str=token;
944 if(!token_list){
945 token_list=new_token_item;
946 } else {
947 last_token_item->next=new_token_item;
948 }
949 last_token_item=new_token_item;
950 }
951
952 /* this function reads the idl file and translates it into tokens.
953 the tokens are stored in a linked list token_list of type token_item_t
954 */
955 static void tokenize(FILE *fh)
956 {
957 int ch;
958 int fullinecomment=0;
959 int normalcomment=0;
960 int insidequote=0;
961 char qs[4 * BASE_BUFFER_SIZE];
962 int qspos=0;
963 int insidetoken=0;
964 char token[4 * BASE_BUFFER_SIZE];
965 int tokenpos=0;
966
967 while(!feof(fh)){
968 ch=fgetc(fh);
969
970 /* full line comment */
971 if(fullinecomment){
972 if( (ch=='\n')||(ch=='\r') ){
973 fullinecomment=0;
974 linepos=0;
975 }
976 continue;
977 }
978 if( (ch=='#')&&(linepos==0) ){
979 fullinecomment=1;
980 continue;
981 }
982
983 /* normal comment */
984 if(normalcomment==0){
985 if(ch=='/'){
986 int nextch;
987 nextch=fgetc(fh);
988 if(nextch=='*'){
989 normalcomment=1;
990 continue;
991 }
992 ungetc(nextch, fh);
993 }
994 } else {
995 if(ch=='*'){
996 int nextch;
997 nextch=fgetc(fh);
998 if(nextch=='/'){
999 normalcomment=0;
1000 continue;
1001 }
1002 ungetc(nextch, fh);
1003 }
1004 continue;
1005 }
1006
1007 /* quoted string */
1008 if(insidequote){
1009 if(ch=='"'){
1010 insidequote=0;
1011 qs[qspos++]='"';
1012 qs[qspos]=0;
1013 pushtoken(g_strdup(qs));
1014 continue;
1015 } else {
1016 qs[qspos++]=(char)ch;
1017 continue;
1018 }
1019 } else {
1020 if(ch=='"'){
1021 insidequote=1;
1022 qs[0]='"';
1023 qspos=1;
1024 continue;
1025 }
1026 }
1027
1028
1029 switch(ch){
1030 case '\n':
1031 case '\r':
1032 if(insidetoken){
1033 insidetoken=0;
1034 token[tokenpos]=0;
1035 pushtoken(g_strdup(token));
1036 }
1037 line[linepos]=0;
1038
1039 linepos=0;
1040 lineno++;
1041 break;
1042 case '\t':
1043 case ' ':
1044 if(insidetoken){
1045 insidetoken=0;
1046 token[tokenpos]=0;
1047 pushtoken(g_strdup(token));
1048 }
1049 break;
1050 case '[':
1051 case ']':
1052 case '(':
1053 case ')':
1054 case ',':
1055 case ';':
1056 case '*':
1057 case '=':
1058 if(insidetoken){
1059 insidetoken=0;
1060 token[tokenpos]=0;
1061 pushtoken(g_strdup(token));
1062 }
1063 token[0]=(char)ch;
1064 token[1]=0;
1065 pushtoken(g_strdup(token));
1066 break;
1067 default:
1068 if(!insidetoken){
1069 tokenpos=0;
1070 }
1071 insidetoken=1;
1072 token[tokenpos++]=(char)ch;
1073 line[linepos++]=(char)ch;
1074 break;
1075 }
1076
1077 }
1078 }
1079
1080
1081 static type_item_t *
1082 find_type(char *name)
1083 {
1084 type_item_t *tmptype;
1085 for(tmptype=type_list;tmptype;tmptype=tmptype->next){
1086 if(!g_strcmp0(tmptype->name, name)){
1087 break;
1088 }
1089 }
1090 /* autogenerate built in types */
1091 if(!tmptype){
1092 char dissectorname[DISSECTORNAME_MAXLEN];
1093 if(!g_strcmp0(name,"uint16")){
1094 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1095 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1096 FPRINTF(eth_code, "\n");
1097 FPRINTF(eth_code, "static int\n");
1098 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1099 FPRINTF(eth_code, "{\n");
1100 FPRINTF(eth_code, " offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1101 FPRINTF(eth_code, " return offset;\n");
1102 FPRINTF(eth_code, "}\n");
1103 FPRINTF(eth_code, "\n");
1104 tmptype=register_new_type("uint16", dissectorname, "FT_UINT16", "BASE_DEC", "0", "NULL", 2);
1105 } else if(!g_strcmp0(name,"int16")){
1106 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1107 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1108 FPRINTF(eth_code, "\n");
1109 FPRINTF(eth_code, "static int\n");
1110 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1111 FPRINTF(eth_code, "{\n");
1112 FPRINTF(eth_code, " offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1113 FPRINTF(eth_code, " return offset;\n");
1114 FPRINTF(eth_code, "}\n");
1115 FPRINTF(eth_code, "\n");
1116 tmptype=register_new_type("int16", dissectorname, "FT_INT16", "BASE_DEC", "0", "NULL", 2);
1117 } else if(!g_strcmp0(name,"uint32")){
1118 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1119 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1120 FPRINTF(eth_code, "\n");
1121 FPRINTF(eth_code, "static int\n");
1122 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1123 FPRINTF(eth_code, "{\n");
1124 FPRINTF(eth_code, " offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1125 FPRINTF(eth_code, " return offset;\n");
1126 FPRINTF(eth_code, "}\n");
1127 FPRINTF(eth_code, "\n");
1128 tmptype=register_new_type("uint32", dissectorname, "FT_UINT32", "BASE_DEC", "0", "NULL", 4);
1129 } else if( (!g_strcmp0(name,"int32"))
1130 || (!g_strcmp0(name,"long")) ){
1131 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1132 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1133 FPRINTF(eth_code, "\n");
1134 FPRINTF(eth_code, "static int\n");
1135 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1136 FPRINTF(eth_code, "{\n");
1137 FPRINTF(eth_code, " offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1138 FPRINTF(eth_code, " return offset;\n");
1139 FPRINTF(eth_code, "}\n");
1140 FPRINTF(eth_code, "\n");
1141 if (!g_strcmp0(name,"int32"))
1142 tmptype=register_new_type("int32", dissectorname, "FT_INT32", "BASE_DEC", "0", "NULL", 4);
1143 else
1144 tmptype=register_new_type("long", dissectorname, "FT_INT32", "BASE_DEC", "0", "NULL", 4);
1145 } else if( (!g_strcmp0(name,"uint8")) ){
1146 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1147 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1148 FPRINTF(eth_code, "\n");
1149 FPRINTF(eth_code, "static int\n");
1150 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1151 FPRINTF(eth_code, "{\n");
1152 FPRINTF(eth_code, " offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1153 FPRINTF(eth_code, " return offset;\n");
1154 FPRINTF(eth_code, "}\n");
1155 FPRINTF(eth_code, "\n");
1156 tmptype=register_new_type("uint8", dissectorname, "FT_UINT8", "BASE_DEC", "0", "NULL", 1);
1157 } else if( (!g_strcmp0(name,"int8"))
1158 || (!g_strcmp0(name, "char")) ){
1159 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1160 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1161 FPRINTF(eth_code, "\n");
1162 FPRINTF(eth_code, "static int\n");
1163 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1164 FPRINTF(eth_code, "{\n");
1165 FPRINTF(eth_code, " offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1166 FPRINTF(eth_code, " return offset;\n");
1167 FPRINTF(eth_code, "}\n");
1168 FPRINTF(eth_code, "\n");
1169 if (!g_strcmp0(name,"int8"))
1170 tmptype=register_new_type("int8", dissectorname, "FT_INT8", "BASE_DEC", "0", "NULL", 1);
1171 else
1172 tmptype=register_new_type("char", dissectorname, "FT_INT8", "BASE_DEC", "0", "NULL", 1);
1173 } else if(!g_strcmp0(name,"bool8")){
1174 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1175 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1176 FPRINTF(eth_code, "\n");
1177 FPRINTF(eth_code, "static int\n");
1178 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1179 FPRINTF(eth_code, "{\n");
1180 FPRINTF(eth_code, " offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1181 FPRINTF(eth_code, " return offset;\n");
1182 FPRINTF(eth_code, "}\n");
1183 FPRINTF(eth_code, "\n");
1184 tmptype=register_new_type("bool8", dissectorname, "FT_INT8", "BASE_DEC", "0", "NULL", 1);
1185 } else if(!g_strcmp0(name,"unistr")){
1186 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1187 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1188 FPRINTF(eth_code, "\n");
1189 FPRINTF(eth_code, "static int\n");
1190 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1191 FPRINTF(eth_code, "{\n");
1192 FPRINTF(eth_code, " offset=dissect_ndr_cvstring(tvb, offset, pinfo, tree, di, drep, 2, hf_index, false, NULL);\n");
1193 FPRINTF(eth_code, " return offset;\n");
1194 FPRINTF(eth_code, "}\n");
1195 FPRINTF(eth_code, "\n");
1196 tmptype=register_new_type("unistr", dissectorname, "FT_STRING", "BASE_NONE", "0", "NULL", 4);
1197 } else if(!g_strcmp0(name,"ascstr")){
1198 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1199 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1200 FPRINTF(eth_code, "\n");
1201 FPRINTF(eth_code, "static int\n");
1202 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1203 FPRINTF(eth_code, "{\n");
1204 FPRINTF(eth_code, " offset=dissect_ndr_cvstring(tvb, offset, pinfo, tree, di, drep, 1, hf_index, false, NULL);\n");
1205 FPRINTF(eth_code, " return offset;\n");
1206 FPRINTF(eth_code, "}\n");
1207 FPRINTF(eth_code, "\n");
1208 tmptype=register_new_type("ascstr", dissectorname, "FT_STRING", "BASE_NONE", "0", "NULL", 4);
1209 } else if(!g_strcmp0(name,"GUID")
1210 ||!g_strcmp0(name,"uuid_t")){
1211 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1212 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1213 FPRINTF(eth_code, "\n");
1214 FPRINTF(eth_code, "static int\n");
1215 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1216 FPRINTF(eth_code, "{\n");
1217 FPRINTF(eth_code, " offset=dissect_ndr_uuid_t(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1218 FPRINTF(eth_code, " return offset;\n");
1219 FPRINTF(eth_code, "}\n");
1220 FPRINTF(eth_code, "\n");
1221 tmptype=register_new_type(name, dissectorname, "FT_GUID", "BASE_NONE", "0", "NULL", 4);
1222 } else if(!g_strcmp0(name,"policy_handle")){
1223 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1224 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1225 FPRINTF(eth_code, "\n");
1226 FPRINTF(eth_code, "static e_ctx_hnd policy_hnd;\n");
1227 FPRINTF(eth_code, "static proto_item *hnd_item;\n");
1228 FPRINTF(eth_code, "\n");
1229 FPRINTF(eth_code, "static int\n");
1230 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param)\n", dissectorname);
1231 FPRINTF(eth_code, "{\n");
1232 FPRINTF(eth_code, " offset = dissect_nt_policy_hnd(tvb, offset, pinfo, tree, di, drep,\n");
1233 FPRINTF(eth_code, " hf_index, &policy_hnd, &hnd_item,\n");
1234 FPRINTF(eth_code, " param);\n");
1235
1236 FPRINTF(eth_code, " return offset;\n");
1237 FPRINTF(eth_code, "}\n");
1238 FPRINTF(eth_code, "\n");
1239 tmptype=register_new_type("policy_handle", dissectorname, "FT_BYTES", "BASE_NONE", "0", "NULL", 4);
1240 } else if(!g_strcmp0(name,"NTTIME")){
1241 /* 8 bytes, aligned to 4 bytes */
1242 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1243 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1244 FPRINTF(eth_code, "\n");
1245 FPRINTF(eth_code, "static int\n");
1246 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1247 FPRINTF(eth_code, "{\n");
1248 FPRINTF(eth_code, " offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, di, drep, hf_index);\n");
1249
1250 FPRINTF(eth_code, "\n");
1251 FPRINTF(eth_code, " return offset;\n");
1252 FPRINTF(eth_code, "}\n");
1253 FPRINTF(eth_code, "\n");
1254 tmptype=register_new_type("NTTIME", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
1255 } else if(!g_strcmp0(name,"NTTIME_hyper")){
1256 /* 8 bytes, aligned to 8 bytes */
1257 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1258 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1259 FPRINTF(eth_code, "\n");
1260 FPRINTF(eth_code, "static int\n");
1261 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1262 FPRINTF(eth_code, "{\n");
1263 FPRINTF(eth_code, " ALIGN_TO_8_BYTES;\n");
1264 FPRINTF(eth_code, " offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, di, drep, hf_index);\n");
1265
1266 FPRINTF(eth_code, "\n");
1267 FPRINTF(eth_code, " return offset;\n");
1268 FPRINTF(eth_code, "}\n");
1269 FPRINTF(eth_code, "\n");
1270 tmptype=register_new_type("NTTIME_hyper", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
1271 } else if(!g_strcmp0(name,"NTTIME_1sec")){
1272 /* 8 bytes, aligned to 8 bytes */
1273 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1274 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1275 FPRINTF(eth_code, "\n");
1276 FPRINTF(eth_code, "static int\n");
1277 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1278 FPRINTF(eth_code, "{\n");
1279 FPRINTF(eth_code, " ALIGN_TO_8_BYTES;\n");
1280 FPRINTF(eth_code, " offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, di, drep, hf_index);\n");
1281
1282 FPRINTF(eth_code, "\n");
1283 FPRINTF(eth_code, " return offset;\n");
1284 FPRINTF(eth_code, "}\n");
1285 FPRINTF(eth_code, "\n");
1286 tmptype=register_new_type("NTTIME_1sec", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
1287 } else if(!g_strcmp0(name,"udlong")){
1288 /* 8 bytes, aligned to 4 bytes */
1289 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1290 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1291 FPRINTF(eth_code, "\n");
1292 FPRINTF(eth_code, "static int\n");
1293 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1294 FPRINTF(eth_code, "{\n");
1295 FPRINTF(eth_code, "\n");
1296 FPRINTF(eth_code, " offset=dissect_ndr_duint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1297 FPRINTF(eth_code, "\n");
1298 FPRINTF(eth_code, " return offset;\n");
1299 FPRINTF(eth_code, "}\n");
1300 FPRINTF(eth_code, "\n");
1301 tmptype=register_new_type("udlong", dissectorname, "FT_UINT64", "BASE_DEC", "0", "NULL", 4);
1302 } else if(!g_strcmp0(name,"dlong")){
1303 /* 8 bytes, aligned to 4 bytes */
1304 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1305 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1306 FPRINTF(eth_code, "\n");
1307 FPRINTF(eth_code, "static int\n");
1308 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1309 FPRINTF(eth_code, "{\n");
1310 FPRINTF(eth_code, "\n");
1311 FPRINTF(eth_code, " offset=dissect_ndr_duint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1312 FPRINTF(eth_code, "\n");
1313 FPRINTF(eth_code, " return offset;\n");
1314 FPRINTF(eth_code, "}\n");
1315 FPRINTF(eth_code, "\n");
1316 tmptype=register_new_type("dlong", dissectorname, "FT_INT64", "BASE_DEC", "0", "NULL", 4);
1317 } else if(!g_strcmp0(name,"uint64")){
1318 /* 8 bytes, aligned to 8 bytes */
1319 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1320 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1321 FPRINTF(eth_code, "\n");
1322 FPRINTF(eth_code, "static int\n");
1323 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1324 FPRINTF(eth_code, "{\n");
1325 FPRINTF(eth_code, " \n");
1326 FPRINTF(eth_code, " ALIGN_TO_8_BYTES;\n");
1327 FPRINTF(eth_code, " offset=dissect_ndr_uint64(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1328 FPRINTF(eth_code, "\n");
1329 FPRINTF(eth_code, " return offset;\n");
1330 FPRINTF(eth_code, "}\n");
1331 FPRINTF(eth_code, "\n");
1332 tmptype=register_new_type("uint64", dissectorname, "FT_UINT64", "BASE_DEC", "0", "NULL", 8);
1333 } else if(!g_strcmp0(name,"time_t")){
1334 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1335 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1336 FPRINTF(eth_code, "\n");
1337 FPRINTF(eth_code, "static int\n");
1338 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1339 FPRINTF(eth_code, "{\n");
1340 FPRINTF(eth_code, "\n");
1341 FPRINTF(eth_code, " offset=dissect_ndr_time_t(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1342 FPRINTF(eth_code, "\n");
1343 FPRINTF(eth_code, " return offset;\n");
1344 FPRINTF(eth_code, "}\n");
1345 FPRINTF(eth_code, "\n");
1346 tmptype=register_new_type("time_t", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
1347 } else if(!g_strcmp0(name,"SID")){
1348 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1349 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1350 FPRINTF(eth_code, "\n");
1351 FPRINTF(eth_code, "static int\n");
1352 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param)\n", dissectorname);
1353 FPRINTF(eth_code, "{\n");
1354 FPRINTF(eth_code, " offset=dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, di, drep, param, hf_index);\n");
1355 FPRINTF(eth_code, " return offset;\n");
1356 FPRINTF(eth_code, "}\n");
1357 FPRINTF(eth_code, "\n");
1358 tmptype=register_new_type("SID", dissectorname, "FT_STRING", "BASE_NONE", "0", "NULL", 4);
1359 } else if(!g_strcmp0(name,"WERROR")){
1360 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, name);
1361 FPRINTF(NULL,"\nAutogenerating built-in type:%s\n------------\n",name);
1362 FPRINTF(eth_code, "\n");
1363 FPRINTF(eth_code, "static int\n");
1364 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
1365 FPRINTF(eth_code, "{\n");
1366 FPRINTF(eth_code, " \n");
1367 FPRINTF(eth_code, " offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
1368 FPRINTF(eth_code, "\n");
1369 FPRINTF(eth_code, " return offset;\n");
1370 FPRINTF(eth_code, "}\n");
1371 FPRINTF(eth_code, "\n");
1372 tmptype=register_new_type("WERROR", dissectorname, "FT_UINT32", "BASE_DEC|BASE_EXT_STRING", "0", "&WERR_errors_ext", 4);
1373 }
1374 }
1375
1376 return tmptype;
1377 }
1378
1379
1380 /* this function will skip past an entire declare ... ; statement */
1381 static void skipdeclare(void)
1382 {
1383 token_item_t *ti;
1384
1385 /* first must be the keyword const */
1386 ti=token_list;
1387 if(strncmp(ti->str, "declare", 7)){
1388 FPRINTF(stderr, "ERROR: skipdeclare first token is not 'declare'\n");
1389 Exit(10);
1390 }
1391 while(ti->str[0] != ';'){
1392 ti=ti->next;
1393 }
1394 ti=ti->next;
1395
1396 token_list=ti;
1397 }
1398
1399 /* this function will parse a
1400 const
1401 and generate the appropriate code
1402 const must be followed by a suitable keyword [uint16|uint32|...]
1403 the const will later be g_removed from the token list
1404 the function assumes that the const is the first object in the token_list
1405 */
1406 static void parseconst(void)
1407 {
1408 token_item_t *ti;
1409 char *name, *value;
1410
1411 /* first must be the keyword const */
1412 ti=token_list;
1413 if(strncmp(ti->str, "const", 5)){
1414 FPRINTF(stderr, "ERROR: const first token is not 'const'\n");
1415 Exit(10);
1416 }
1417 ti=ti->next;
1418
1419 /* just skip second token */
1420 ti=ti->next;
1421
1422 /* third is a variable and not a type */
1423 if(find_type(ti->str)){
1424 FPRINTF(stderr, "ERROR: const, not a variable name:%s\n", ti->str);
1425 Exit(10);
1426 }
1427 name=ti->str;
1428 ti=ti->next;
1429
1430 /* fourth is '=' */
1431 if(ti->str[0] != '='){
1432 FPRINTF(stderr, "ERROR: const fourth token is not '='\n");
1433 Exit(10);
1434 }
1435 ti=ti->next;
1436
1437 /* fifth is the value */
1438 value=ti->str;
1439 ti=ti->next;
1440
1441 /* sixth is ';' */
1442 if(ti->str[0] != ';'){
1443 FPRINTF(stderr, "ERROR: const sixth token is not ';'\n");
1444 Exit(10);
1445 }
1446 ti=ti->next;
1447
1448 FPRINTF(NULL,"\nCONST:%s\n-------\n",name);
1449
1450 FPRINTF(eth_hdr, "#define %s %s\n", name, value);
1451
1452 FPRINTF(NULL,"\n----------\nEND CONST:%s\n",name);
1453
1454 token_list=ti;
1455 }
1456
1457 /* this function will parse a
1458 typedef struct {
1459 construct and generate the appropriate code.
1460 the typedef will be g_removed from the token_list once it has been processed
1461 the function assumes that the typedef is the first object in the token_list
1462 the function will be called twice, once with pass=0 and once with pass=1
1463 which controls whether subdissectors are to be generated or whether the
1464 struct dissector itself is to be generated
1465 */
1466 static void parsetypedefstruct(int pass)
1467 {
1468 token_item_t *ti, *tmpti;
1469 char *struct_name;
1470 char dissectorname[DISSECTORNAME_MAXLEN];
1471 char tmpstr[BASE_BUFFER_SIZE], *ptmpstr;
1472 int level, num_pointers;
1473 static int alignment;
1474 type_item_t *type_item;
1475 char hf_index[BASE_BUFFER_SIZE];
1476 bracket_item_t *bi=NULL;
1477 pointer_item_t *pi;
1478 const char *pointer_type;
1479 char *field_name;
1480 uint32_t fixed_array_size;
1481 int is_array_of_pointers;
1482 int empty_struct = 0;
1483
1484 ti=token_list;
1485 if(g_strcmp0(ti->str, "typedef")){
1486 FPRINTF(stderr, "ERROR: typedefstruct first token is not 'typedef'\n");
1487 Exit(10);
1488 }
1489 ti=ti->next;
1490
1491 if(!g_strcmp0(ti->str, "[")){
1492 ti=parsebrackets(ti, &bi);
1493 }
1494 /* check that we know how to handle the bracket thing */
1495 if(bi){
1496 if(bi->flags){
1497 FPRINTF(stderr, "ERROR: typedefstruct unknown bracket flags encountered : 0x%08x\n",bi->flags);
1498 Exit(10);
1499 }
1500 }
1501
1502 if(g_strcmp0(ti->str, "struct")){
1503 FPRINTF(stderr, "ERROR: typedefstruct second token is not 'struct'\n");
1504 Exit(10);
1505 }
1506 ti=ti->next;
1507
1508 if(g_strcmp0(ti->str, "{")){
1509 FPRINTF(stderr, "ERROR: typedefstruct third token is not '{'\n");
1510 Exit(10);
1511 }
1512 ti=ti->next;
1513
1514 /* Check if the struct is empty (search if there is no end bracket) */
1515 if(g_strcmp0(ti->str, "}") == 0){
1516 empty_struct = 1;
1517 }
1518
1519 /* search forward until the '}' so we can find the name of the struct */
1520 for(tmpti=ti,level=0;tmpti;tmpti=tmpti->next){
1521 if(!g_strcmp0(tmpti->str, "{")){
1522 level++;
1523 continue;
1524 }
1525 if(!g_strcmp0(tmpti->str, "}")){
1526 if(!level){
1527 break;
1528 }
1529 level--;
1530 continue;
1531 }
1532 }
1533 if(!tmpti || !tmpti->next){
1534 FPRINTF(stderr, "ERROR: typedefstruct missing matching '}'\n");
1535 Exit(10);
1536 }
1537
1538 struct_name=tmpti->next->str;
1539 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, struct_name);
1540
1541 FPRINTF(NULL,"\nSTRUCT:%s pass:%d\n-------\n",struct_name,pass);
1542
1543 if(!check_if_to_emit(dissectorname)){
1544 FPRINTF(NULL,"NOEMIT Skipping this struct dissector.\n");
1545 ti=tmpti;
1546 goto typedef_struct_finished;
1547 }
1548
1549 /* this is pass 0 so reset alignment to zero and update as items are
1550 processed. we need alignment when pass 1 is run.
1551 set alignment initially to 1 so we don't fail for empty structs
1552 */
1553 if(pass==0){
1554 alignment=1;
1555 }
1556 /* pass 1 generate header for the struct dissector */
1557 if(pass==1){
1558 FPRINTF(eth_ett, "static int ett_%s_%s;\n", ifname, struct_name);
1559 FPRINTF(eth_ettarr, " &ett_%s_%s,\n", ifname, struct_name);
1560 FPRINTF(eth_hdr, "int %s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param);\n", dissectorname);
1561 FPRINTF(eth_code, "\n");
1562 FPRINTF(eth_code, "int\n");
1563 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *parent_tree, dcerpc_info *di _U_, uint8_t *drep _U_, int hf_index, uint32_t param _U_)\n", dissectorname);
1564 FPRINTF(eth_code, "{\n");
1565 FPRINTF(eth_code, " proto_item *item=NULL;\n");
1566 if(!empty_struct){
1567 FPRINTF(eth_code, " proto_tree *tree=NULL;\n");
1568 }
1569 FPRINTF(eth_code, " int old_offset;\n");
1570 FPRINTF(eth_code, "\n");
1571 switch(alignment){
1572 case 1:
1573 break;
1574 case 2:
1575 FPRINTF(eth_code, " ALIGN_TO_2_BYTES;\n");
1576 FPRINTF(eth_code, "\n");
1577 break;
1578 case 4:
1579 FPRINTF(eth_code, " ALIGN_TO_4_BYTES;\n");
1580 FPRINTF(eth_code, "\n");
1581 break;
1582 case 8:
1583 FPRINTF(eth_code, " ALIGN_TO_8_BYTES;\n");
1584 FPRINTF(eth_code, "\n");
1585 break;
1586 default:
1587 FPRINTF(stderr, "ERROR: can not handle alignment:%d\n",alignment);
1588 Exit(10);
1589 }
1590 FPRINTF(eth_code, " old_offset=offset;\n");
1591 FPRINTF(eth_code, " if(parent_tree){\n");
1592 FPRINTF(eth_code, " item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, ENC_NA);\n");
1593 if(!empty_struct){
1594 FPRINTF(eth_code, " tree=proto_item_add_subtree(item, ett_%s_%s);\n", ifname, struct_name);
1595 }
1596 FPRINTF(eth_code, " }\n");
1597 FPRINTF(eth_code, "\n");
1598 }
1599
1600 /* scan the struct and create all subdissectors */
1601 level=0;
1602 while(ti){
1603 if(!g_strcmp0(ti->str, "{")){
1604 level++;
1605 ti=ti->next;
1606 continue;
1607 }
1608 if(!g_strcmp0(ti->str, "}")){
1609 if(!level){
1610 break;
1611 }
1612 level--;
1613 ti=ti->next;
1614 continue;
1615 }
1616 if(!g_strcmp0(ti->str, "[")){
1617 ti=parsebrackets(ti, &bi);
1618 continue;
1619 }
1620
1621 /* check that we know how to handle the bracket thing */
1622 if(bi){
1623 if(bi->flags&(~(BI_SIZE_IS|BI_LENGTH_IS|BI_POINTER))){
1624 FPRINTF(stderr, "ERROR: typedefstruct unknown bracket flags encountered : 0x%08x\n",bi->flags);
1625 Exit(10);
1626 }
1627 }
1628
1629 /* handle the type, verify that we KNOW this type */
1630 type_item=find_type(ti->str);
1631 if(!type_item){
1632 FPRINTF(stderr, "ERROR : typedefstruct unknown type %s\n",ti->str);
1633 Exit(10);
1634 }
1635 ti=ti->next;
1636 /* count the levels of pointers */
1637 for(num_pointers=0;!g_strcmp0(ti->str, "*");ti=ti->next){
1638 num_pointers++;
1639 /* pointers are aligned at 4 byte boundaries */
1640 if(alignment<4){
1641 alignment=4;
1642 }
1643 }
1644 /* now that we know how many real pointers there were we must
1645 prepend default pointers to the list so it has the right
1646 length.
1647 */
1648 pi=prepend_pointer_list(bi?bi->pointer_list:NULL, num_pointers);
1649 /* keep track of alignment */
1650 if(alignment<type_item->alignment){
1651 alignment=type_item->alignment;
1652 }
1653
1654 field_name=ti->str;
1655 ti=ti->next;
1656
1657 /* see if it is a fixed array */
1658 fixed_array_size=0;
1659 is_array_of_pointers=0;
1660 if(!g_strcmp0(ti->str, "[")){
1661 /* this might be a fixed array */
1662 ti=ti->next;
1663
1664 if(!g_strcmp0("]", ti->str)){
1665 /* this is just a normal [] array */
1666 fixed_array_size=0;
1667 } else if(!g_strcmp0("*", ti->str)){
1668 pi=prepend_pointer_list(pi, num_pointers+1);
1669 fixed_array_size=0;
1670 is_array_of_pointers=1;
1671 ti=ti->next;
1672 } else if (!ws_strtou32(ti->str, NULL, &fixed_array_size)) {
1673 FPRINTF(stderr, "ERROR: invalid integer: %s\n", ti->str);
1674 Exit(10);
1675 } else {
1676 ti=ti->next;
1677 }
1678
1679 if(g_strcmp0(ti->str, "]")){
1680 FPRINTF(stderr, "ERROR: typedefstruct fixed array does not end with ']' it ended with %s\n",ti->str);
1681 Exit(10);
1682 }
1683 ti=ti->next;
1684 }
1685
1686 snprintf(hf_index, BASE_BUFFER_SIZE, "hf_%s_%s_%s", ifname, struct_name, field_name);
1687 /* pass 0 generate subdissectors */
1688 if(pass==0){
1689 char filter_name[BASE_BUFFER_SIZE];
1690 const char *hf;
1691
1692 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_dissect_%s_%s", ifname, struct_name, field_name);
1693 ptmpstr=g_strdup(tmpstr);
1694
1695 if(check_if_to_emit(tmpstr)){
1696 snprintf(filter_name, BASE_BUFFER_SIZE, "%s.%s.%s", ifname, struct_name, field_name);
1697 hf=register_hf_field(hf_index, field_name, filter_name, type_item->ft_type, type_item->base_type, type_item->vals, type_item->mask, "");
1698 FPRINTF(eth_code, "static int\n");
1699 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", ptmpstr);
1700 FPRINTF(eth_code, "{\n");
1701 FPRINTF(eth_code, " uint32_t param=%s;\n",find_dissector_param_value(ptmpstr));
1702 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep, %s, param);\n", type_item->dissector, hf);
1703 FPRINTF(eth_code, " return offset;\n");
1704 FPRINTF(eth_code, "}\n");
1705 FPRINTF(eth_code, "\n");
1706 } else {
1707 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1708 }
1709
1710 if(is_array_of_pointers){
1711 pointer_type=pi->type;
1712 pi=pi->next;
1713 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", pointer_type, ptmpstr);
1714 if(check_if_to_emit(tmpstr)){
1715 FPRINTF(eth_code, "static int\n");
1716 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
1717 FPRINTF(eth_code, "{\n");
1718 FPRINTF(eth_code, " offset=dissect_ndr_embedded_pointer(tvb, offset, pinfo, tree, di, drep, %s, %s, \"%s\", -1);\n", ptmpstr, ptr_to_define(pointer_type), field_name);
1719 FPRINTF(eth_code, " return offset;\n");
1720 FPRINTF(eth_code, "}\n");
1721 FPRINTF(eth_code, "\n");
1722 } else {
1723 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1724 }
1725
1726 ptmpstr=g_strdup(tmpstr);
1727 } else if(fixed_array_size){
1728 snprintf(tmpstr, BASE_BUFFER_SIZE, "fixedarray_%s", ptmpstr);
1729 if(check_if_to_emit(tmpstr)){
1730 FPRINTF(eth_code, "static int\n");
1731 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
1732 FPRINTF(eth_code, "{\n");
1733 FPRINTF(eth_code, " int count=%d;\n",fixed_array_size);
1734 FPRINTF(eth_code, " while(count--){\n");
1735 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
1736 FPRINTF(eth_code, " }\n");
1737 FPRINTF(eth_code, "\n");
1738 FPRINTF(eth_code, " return offset;\n");
1739 FPRINTF(eth_code, "}\n");
1740 FPRINTF(eth_code, "\n");
1741 } else {
1742 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1743 }
1744 ptmpstr=g_strdup(tmpstr);
1745 }
1746
1747 /* handle switch_is */
1748 if(bi){
1749 switch(bi->flags&(BI_SIZE_IS|BI_LENGTH_IS)){
1750 case 0:
1751 break;
1752 case BI_SIZE_IS:
1753 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucarray_%s", ptmpstr);
1754 if(check_if_to_emit(tmpstr)){
1755 FPRINTF(eth_code, "static int\n");
1756 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
1757 FPRINTF(eth_code, "{\n");
1758 FPRINTF(eth_code, " offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
1759 FPRINTF(eth_code, " return offset;\n");
1760 FPRINTF(eth_code, "}\n");
1761 FPRINTF(eth_code, "\n");
1762 } else {
1763 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1764 }
1765 ptmpstr=g_strdup(tmpstr);
1766 break;
1767 case BI_LENGTH_IS:
1768 snprintf(tmpstr, BASE_BUFFER_SIZE, "uvarray_%s", ptmpstr);
1769 if(check_if_to_emit(tmpstr)){
1770 FPRINTF(eth_code, "static int\n");
1771 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
1772 FPRINTF(eth_code, "{\n");
1773 FPRINTF(eth_code, " offset=dissect_ndr_uvarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
1774 FPRINTF(eth_code, " return offset;\n");
1775 FPRINTF(eth_code, "}\n");
1776 FPRINTF(eth_code, "\n");
1777 } else {
1778 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1779 }
1780 ptmpstr=g_strdup(tmpstr);
1781 break;
1782 case BI_SIZE_IS|BI_LENGTH_IS:
1783 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucvarray_%s", ptmpstr);
1784 if(check_if_to_emit(tmpstr)){
1785 FPRINTF(eth_code, "static int\n");
1786 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
1787 FPRINTF(eth_code, "{\n");
1788 FPRINTF(eth_code, " offset=dissect_ndr_ucvarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
1789 FPRINTF(eth_code, " return offset;\n");
1790 FPRINTF(eth_code, "}\n");
1791 FPRINTF(eth_code, "\n");
1792 } else {
1793 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1794 }
1795 ptmpstr=g_strdup(tmpstr);
1796 break;
1797 default:
1798 FPRINTF(stderr, "ERROR: typedefstruct can not handle this combination of sizeis/lengthis\n");
1799 Exit(10);
1800 }
1801 }
1802
1803 /* handle pointers */
1804 while(num_pointers--){
1805 pointer_type=pi->type;
1806 pi=pi->next;
1807 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", pointer_type, ptmpstr);
1808 if(check_if_to_emit(tmpstr)){
1809 FPRINTF(eth_code, "static int\n");
1810 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
1811 FPRINTF(eth_code, "{\n");
1812 FPRINTF(eth_code, " offset=dissect_ndr_embedded_pointer(tvb, offset, pinfo, tree, di, drep, %s, %s, \"%s\", -1);\n", ptmpstr, ptr_to_define(pointer_type), field_name);
1813 FPRINTF(eth_code, " return offset;\n");
1814 FPRINTF(eth_code, "}\n");
1815 FPRINTF(eth_code, "\n");
1816 } else {
1817 FPRINTF(NULL,"NOEMIT Skipping this struct item :%s\n",tmpstr);
1818 }
1819
1820 ptmpstr=g_strdup(tmpstr);
1821 }
1822 }
1823
1824 if(pass==1){
1825 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_dissect_%s_%s", ifname, struct_name, field_name);
1826 ptmpstr=g_strdup(tmpstr);
1827
1828 /* handle fixedsizearrays */
1829 if(is_array_of_pointers){
1830 pointer_type=pi->type;
1831 pi=pi->next;
1832 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", pointer_type, ptmpstr);
1833 ptmpstr=g_strdup(tmpstr);
1834 } else if(fixed_array_size){
1835 snprintf(tmpstr, BASE_BUFFER_SIZE, "fixedarray_%s", ptmpstr);
1836 ptmpstr=g_strdup(tmpstr);
1837 }
1838
1839 /* handle switch_is */
1840 if(bi){
1841 switch(bi->flags&(BI_SIZE_IS|BI_LENGTH_IS)){
1842 case 0:
1843 break;
1844 case BI_SIZE_IS:
1845 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucarray_%s", ptmpstr);
1846 ptmpstr=g_strdup(tmpstr);
1847 break;
1848 case BI_LENGTH_IS:
1849 snprintf(tmpstr, BASE_BUFFER_SIZE, "uvarray_%s", ptmpstr);
1850 ptmpstr=g_strdup(tmpstr);
1851 break;
1852 case BI_SIZE_IS|BI_LENGTH_IS:
1853 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucvarray_%s", ptmpstr);
1854 ptmpstr=g_strdup(tmpstr);
1855 break;
1856 default:
1857 FPRINTF(stderr, "ERROR: typedefstruct can not handle this combination of sizeis/lengthis\n");
1858 Exit(10);
1859 }
1860 }
1861
1862 /* handle pointers */
1863 while(num_pointers--){
1864 pointer_type=pi->type;
1865 pi=pi->next;
1866 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", pointer_type, ptmpstr);
1867 ptmpstr=g_strdup(tmpstr);
1868 }
1869
1870 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
1871 FPRINTF(eth_code, "\n");
1872 }
1873
1874 if(g_strcmp0(ti->str,";")){
1875 FPRINTF(stderr, "ERROR: field does not en with ';'\n");
1876 Exit(10);
1877 }
1878 ti=ti->next;
1879 bi=NULL; /* clear bi before we start on the next field */
1880 }
1881
1882 if(pass==1){
1883 FPRINTF(eth_code, " proto_item_set_len(item, offset-old_offset);\n");
1884 FPRINTF(eth_code, "\n");
1885 FPRINTF(eth_code, " return offset;\n");
1886 FPRINTF(eth_code, "}\n");
1887 register_new_type(struct_name, dissectorname, "FT_NONE", "BASE_NONE", "0", "NULL", alignment);
1888 }
1889
1890
1891 typedef_struct_finished:
1892 FPRINTF(NULL,"\nEND STRUCT:%s pass:%d\n-------\n",struct_name,pass);
1893
1894 /* only advance token_list for pass==1
1895 ti now points to the '}' token
1896 */
1897 if(pass==1){
1898 if(!ti || g_strcmp0(ti->str,"}")){
1899 FPRINTF(stderr, "ERROR: struct does not end with '}'\n");
1900 Exit(10);
1901 }
1902 ti=ti->next;
1903
1904 /* just skip the name */
1905 ti=ti->next;
1906
1907 if(!ti || g_strcmp0(ti->str,";")){
1908 FPRINTF(stderr, "ERROR: struct does not end with ';'\n");
1909 Exit(10);
1910 }
1911 ti=ti->next;
1912
1913 token_list=ti;
1914 }
1915 }
1916
1917 /* this function will parse a
1918 typedef bitmap {
1919 construct and generate the appropriate code.
1920 the typedef will be g_removed from the token_list once it has been processed
1921 the function assumes that the typedef is the first object in the token_list
1922 the function will be called twice, once with pass=0 and once with pass=1
1923 which controls whether subdissectors are to be generated or whether the
1924 bitmap dissector itself is to be generated
1925
1926 bitmaps are by default 32 bits
1927 */
1928 static void parsetypedefbitmap(int pass)
1929 {
1930 token_item_t *ti, *tmpti;
1931 char *bitmap_name;
1932 char dissectorname[BASE_BUFFER_SIZE], hf_bitname[BASE_BUFFER_SIZE];
1933 int alignment;
1934 unsigned int val;
1935 char *name, *value;
1936 bracket_item_t *bi=NULL;
1937
1938 ti=token_list;
1939 if(g_strcmp0(ti->str, "typedef")){
1940 FPRINTF(stderr, "ERROR: typedefbitmap first token is not 'typedef'\n");
1941 Exit(10);
1942 }
1943 ti=ti->next;
1944
1945 alignment=4; /* default size is 32 bits */
1946
1947 if(!g_strcmp0(ti->str, "[")){
1948 ti=parsebrackets(ti, &bi);
1949 }
1950 /* check that we know how to handle the bracket thing */
1951 if(bi){
1952 if(bi->flags&(~(BI_BITMAP32|BI_BITMAP8))){
1953 FPRINTF(stderr, "ERROR: typedefbitmap unknown bracket flags encountered : 0x%08x\n",bi->flags);
1954 Exit(10);
1955 }
1956 if(bi->flags&BI_BITMAP32){
1957 alignment=4;
1958 }
1959 if(bi->flags&BI_BITMAP8){
1960 alignment=1;
1961 }
1962 }
1963
1964
1965 if(g_strcmp0(ti->str, "bitmap")){
1966 FPRINTF(stderr, "ERROR: typedefbitmap second token is not 'bitmap'\n");
1967 Exit(10);
1968 }
1969 ti=ti->next;
1970
1971 if(g_strcmp0(ti->str, "{")){
1972 FPRINTF(stderr, "ERROR: typedefbitmap third token is not '{'\n");
1973 Exit(10);
1974 }
1975 ti=ti->next;
1976
1977 /* search forward until the '}' so we can find the name of the bitmap */
1978 for(tmpti=ti;tmpti;tmpti=tmpti->next){
1979 if(!g_strcmp0(tmpti->str, "{")){
1980 FPRINTF(stderr, "ERROR: typedefbitmap '{' encountered inside bitmap\n");
1981 Exit(10);
1982 }
1983 if(!g_strcmp0(tmpti->str, "}")){
1984 break;
1985 }
1986 }
1987 if (!tmpti || !tmpti->next){
1988 FPRINTF(stderr, "ERROR: typedefbitmap missing matching '}'\n");
1989 Exit(10);
1990 }
1991 bitmap_name=tmpti->next->str;
1992 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, bitmap_name);
1993
1994 FPRINTF(NULL,"\nBITMAP:%s pass:%d\n-------\n",bitmap_name,pass);
1995
1996 /* pass 1 generate header for the struct dissector */
1997 if(pass==1){
1998 FPRINTF(eth_ett, "static int ett_%s_%s;\n", ifname, bitmap_name);
1999 FPRINTF(eth_ettarr, " &ett_%s_%s,\n", ifname, bitmap_name);
2000 FPRINTF(eth_hdr, "int %s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param);\n", dissectorname);
2001 FPRINTF(eth_code, "\n");
2002 FPRINTF(eth_code, "int\n");
2003 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
2004 FPRINTF(eth_code, "{\n");
2005 FPRINTF(eth_code, " proto_item *item=NULL;\n");
2006 FPRINTF(eth_code, " proto_tree *tree=NULL;\n");
2007 switch(alignment){
2008 case 1:
2009 FPRINTF(eth_code, " uint8_t flags;\n");
2010 FPRINTF(eth_code, "\n");
2011 break;
2012 case 4:
2013 FPRINTF(eth_code, " uint32_t flags;\n");
2014 FPRINTF(eth_code, "\n");
2015 FPRINTF(eth_code, " ALIGN_TO_4_BYTES;\n");
2016 break;
2017 default:
2018 FPRINTF(stderr, "ERROR: typedefbitmap can not handle alignment:%d\n",alignment);
2019 Exit(10);
2020 }
2021 FPRINTF(eth_code, "\n");
2022 FPRINTF(eth_code, " if(parent_tree){\n");
2023 FPRINTF(eth_code, " item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, %d, ENC_LITTLE_ENDIAN);\n", alignment);
2024 FPRINTF(eth_code, " tree=proto_item_add_subtree(item, ett_%s_%s);\n", ifname, bitmap_name);
2025 FPRINTF(eth_code, " }\n");
2026 FPRINTF(eth_code, "\n");
2027 switch(alignment){
2028 case 1:
2029 FPRINTF(eth_code, " offset=dissect_ndr_uint8(tvb, offset, pinfo, NULL, di, drep, -1, &flags);\n");
2030 FPRINTF(eth_code, "\n");
2031 break;
2032 case 4:
2033 FPRINTF(eth_code, " offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &flags);\n");
2034 FPRINTF(eth_code, "\n");
2035 break;
2036 default:
2037 FPRINTF(stderr, "ERROR: typedefbitmap can not handle alignment:%d\n",alignment);
2038 Exit(10);
2039 }
2040 FPRINTF(eth_code, "\n");
2041 }
2042
2043 /* scan the struct and create call for all bits */
2044 while(ti){
2045 if(!g_strcmp0(ti->str, "}")){
2046 break;
2047 }
2048 if(!g_strcmp0(ti->str, "[")){
2049 FPRINTF(stderr, "ERROR: typedefbitmap can not handle '[' yet\n");
2050 Exit(10);
2051 }
2052
2053 name=ti->str;
2054 ti=ti->next;
2055 snprintf(hf_bitname, BASE_BUFFER_SIZE, "hf_%s_%s_%s", ifname, bitmap_name, name);
2056
2057 if(g_strcmp0(ti->str, "=")){
2058 FPRINTF(stderr, "ERROR: typedefbitmap i expected a '=' here\n");
2059 Exit(10);
2060 }
2061 ti=ti->next;
2062
2063 value=ti->str;
2064 ti=ti->next;
2065 val=0;
2066 if(!strncmp(value, "0x", 2)){
2067 sscanf(value, "0x%x", &val);
2068 } else {
2069 FPRINTF(stderr, "ERROR: typedefbitmap can only handle hexadecimal constants\n");
2070 Exit(10);
2071 }
2072
2073 if( val&(val-1) ){
2074 FPRINTF(stderr, "ERROR: typedefbitmap can only handle single bit fields\n");
2075 Exit(10);
2076 }
2077
2078 if(pass==0){
2079 char filter_name[BASE_BUFFER_SIZE], base_name[BASE_BUFFER_SIZE], tfs_name[BASE_BUFFER_SIZE];
2080
2081 snprintf(filter_name, BASE_BUFFER_SIZE, "%s.%s.%s", ifname, bitmap_name, name);
2082 snprintf(base_name, BASE_BUFFER_SIZE, "%d", alignment*8);
2083 snprintf(tfs_name, BASE_BUFFER_SIZE, "TFS(&%s_tfs)", name);
2084 register_hf_field(hf_bitname, name, filter_name, "FT_BOOLEAN", base_name, tfs_name, value, "");
2085
2086 FPRINTF(eth_code, "static const true_false_string %s_tfs = {\n",name);
2087 FPRINTF(eth_code, " \"%s is SET\",\n", name);
2088 FPRINTF(eth_code, " \"%s is NOT set\"\n", name);
2089 FPRINTF(eth_code, "};\n");
2090 FPRINTF(eth_code, "\n");
2091 }
2092
2093 if(pass==1){
2094 FPRINTF(eth_code, " proto_tree_add_boolean(tree, %s, tvb, offset-%d, %d, flags);\n", hf_bitname, alignment, alignment);
2095 FPRINTF(eth_code, " if(flags&%s){\n", value);
2096 FPRINTF(eth_code, " proto_item_append_text(item, \" %s\");\n", name);
2097 FPRINTF(eth_code, " }\n");
2098 FPRINTF(eth_code, " flags&=(~%s);\n", value);
2099 FPRINTF(eth_code, "\n");
2100 }
2101
2102 if(!g_strcmp0(ti->str, ",")){
2103 ti=ti->next;
2104 continue;
2105 }
2106 }
2107
2108 if(pass==1){
2109 FPRINTF(eth_code, " if(flags){\n");
2110 FPRINTF(eth_code, " proto_item_append_text(item, \"UNKNOWN-FLAGS\");\n");
2111 FPRINTF(eth_code, " }\n");
2112 FPRINTF(eth_code, "\n");
2113 FPRINTF(eth_code, " return offset;\n");
2114 FPRINTF(eth_code, "}\n");
2115 switch(alignment){
2116 case 1:
2117 register_new_type(bitmap_name, dissectorname, "FT_UINT8", "BASE_HEX", "0", "NULL", alignment);
2118 break;
2119 case 4:
2120 register_new_type(bitmap_name, dissectorname, "FT_UINT32", "BASE_HEX", "0", "NULL", alignment);
2121 break;
2122 default:
2123 FPRINTF(stderr, "ERROR: typedefbitmap can not handle alignment:%d\n",alignment);
2124 Exit(10);
2125 }
2126 }
2127
2128 FPRINTF(NULL,"\nEND BITMAP:%s pass:%d\n-------\n",bitmap_name,pass);
2129
2130 /* only advance token_list for pass==1
2131 ti now points to the '}' token
2132 */
2133 if(pass==1){
2134 if(!ti || g_strcmp0(ti->str,"}")){
2135 FPRINTF(stderr, "ERROR: bitmap does not end with '}'\n");
2136 Exit(10);
2137 }
2138 ti=ti->next;
2139
2140 /* just skip the name */
2141 ti=ti->next;
2142
2143 if(!ti || g_strcmp0(ti->str,";")){
2144 FPRINTF(stderr, "ERROR: bitmap does not end with ';'\n");
2145 Exit(10);
2146 }
2147 ti=ti->next;
2148
2149 token_list=ti;
2150 }
2151 }
2152
2153 /* a case tag might be a negative number, i.e. contain a '-' sign which
2154 is not valid inside a symbol name in c.
2155 */
2156 static const char *
2157 case2str(const char *str)
2158 {
2159 char *newstr;
2160 if(str[0]!='-'){
2161 return str;
2162 }
2163 newstr=g_strdup(str);
2164 newstr[0]='m';
2165 return newstr;
2166 }
2167
2168 /* this function will parse a
2169 typedef union {
2170 construct and generate the appropriate code.
2171 the typedef will be g_removed from the token_list once it has been processed
2172 the function assumes that the typedef is the first object in the token_list
2173 the function will be called twice, once with pass=0 and once with pass=1
2174 which controls whether subdissectors are to be generated or whether the
2175 union dissector itself is to be generated
2176 */
2177 static void parsetypedefunion(int pass)
2178 {
2179 char *union_name;
2180 token_item_t *ti, *tmpti;
2181 char dissectorname[BASE_BUFFER_SIZE];
2182 bracket_item_t *bi=NULL;
2183 char tmpstr[BASE_BUFFER_SIZE], *ptmpstr;
2184 int level, num_pointers;
2185 static int alignment;
2186 type_item_t *type_item;
2187 char hf_index[BASE_BUFFER_SIZE];
2188 int tag_alignment, item_alignment;
2189
2190 ti=token_list;
2191 if(g_strcmp0(ti->str, "typedef")){
2192 FPRINTF(stderr, "ERROR: typedefunion first token is not 'typedef'\n");
2193 Exit(10);
2194 }
2195 ti=ti->next;
2196
2197 if(!g_strcmp0(ti->str, "[")){
2198 ti=parsebrackets(ti, &bi);
2199 }
2200 /* check that we know how to handle the bracket thing */
2201 if(bi){
2202 if(bi->flags&(~(BI_SWITCH_TYPE))){
2203 FPRINTF(stderr, "ERROR: typedefunion unknown bracket flags encountered : 0x%08x\n",bi->flags);
2204 Exit(10);
2205 }
2206 }
2207
2208 if(g_strcmp0(ti->str, "union")){
2209 FPRINTF(stderr, "ERROR: typedefunion second token is not 'union'\n");
2210 Exit(10);
2211 }
2212 ti=ti->next;
2213
2214 if(g_strcmp0(ti->str, "{")){
2215 FPRINTF(stderr, "ERROR: typedefunion third token is not '{'\n");
2216 Exit(10);
2217 }
2218 ti=ti->next;
2219
2220 /* search forward until the '}' so we can find the name of the union */
2221 for(tmpti=ti,level=0;tmpti;tmpti=tmpti->next){
2222 if(!g_strcmp0(tmpti->str, "{")){
2223 level++;
2224 continue;
2225 }
2226 if(!g_strcmp0(tmpti->str, "}")){
2227 if(!level){
2228 break;
2229 }
2230 level--;
2231 continue;
2232 }
2233 }
2234
2235 if (!tmpti || !tmpti->next){
2236 FPRINTF(stderr, "ERROR: typedefunion missing matching '}'\n");
2237 Exit(10);
2238 }
2239 union_name=tmpti->next->str;
2240 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_union_%s", ifname, union_name);
2241
2242 FPRINTF(NULL,"\nUNION:%s pass:%d\n-------\n",union_name,pass);
2243
2244 if(bi && bi->flags&BI_SWITCH_TYPE){
2245 tag_alignment=bi->union_tag_size;
2246 } else {
2247 tag_alignment=get_union_tag_size(union_name);
2248 }
2249
2250 /* this is pass 0 so reset alignment to the minimum possible value
2251 and update as items are processed.
2252 we need alignment when pass 1 is run
2253 */
2254 if(pass==0){
2255 alignment=tag_alignment;
2256 }
2257
2258 /* pass 1 generate header for the struct dissector */
2259 if(pass==1){
2260 FPRINTF(eth_ett, "static int ett_%s_%s;\n", ifname, union_name);
2261 FPRINTF(eth_ettarr, " &ett_%s_%s,\n", ifname, union_name);
2262 FPRINTF(eth_code, "\n");
2263 FPRINTF(eth_code, "static int\n");
2264 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
2265 FPRINTF(eth_code, "{\n");
2266 FPRINTF(eth_code, " proto_item *item=NULL;\n");
2267 FPRINTF(eth_code, " proto_tree *tree=NULL;\n");
2268 FPRINTF(eth_code, " int old_offset;\n");
2269 /* we do alignment on the tag itself here so that
2270 we skip any alignment padding prior to where the tag
2271 itself starts, this makes the byterange in the hexpane
2272 for the union expansion start with the first byte of the tag
2273 */
2274 switch(tag_alignment){
2275 case 1:
2276 break;
2277 case 2:
2278 FPRINTF(eth_code, " uint16_t level;\n");
2279 FPRINTF(eth_code, "\n");
2280 FPRINTF(eth_code, " ALIGN_TO_2_BYTES;\n");
2281 FPRINTF(eth_code, "\n");
2282 break;
2283 case 4:
2284 FPRINTF(eth_code, " uint32_t level = 0;\n");
2285 FPRINTF(eth_code, "\n");
2286 FPRINTF(eth_code, " ALIGN_TO_4_BYTES;\n");
2287 FPRINTF(eth_code, "\n");
2288 break;
2289 default:
2290 FPRINTF(stderr, "ERROR: typedefunion 1 can not handle alignment:%d\n",alignment);
2291 Exit(10);
2292 }
2293 FPRINTF(eth_code, " old_offset=offset;\n");
2294 FPRINTF(eth_code, " if(parent_tree){\n");
2295 FPRINTF(eth_code, " tree=proto_tree_add_subtree(parent_tree, tvb, offset, -1, ett_%s_%s, &item, \"%s\");\n", ifname, union_name, union_name);
2296 FPRINTF(eth_code, " }\n");
2297 FPRINTF(eth_code, "\n");
2298 switch(tag_alignment){
2299 case 1:
2300 break;
2301 case 2:
2302 FPRINTF(eth_code, " offset=dissect_ndr_uint16(tvb, offset, pinfo, tree,\n");
2303 FPRINTF(eth_code, " di, drep, hf_index, &level);\n");
2304 break;
2305 case 4:
2306 FPRINTF(eth_code, " offset=dissect_ndr_uint32(tvb, offset, pinfo, tree,\n");
2307 FPRINTF(eth_code, " di, drep, hf_index, &level);\n");
2308 break;
2309 default:
2310 FPRINTF(stderr, "ERROR: typedefunion 2 can not handle alignment:%d\n",alignment);
2311 Exit(10);
2312 }
2313 FPRINTF(eth_code, "\n");
2314 FPRINTF(eth_code, " switch(level){\n");
2315 }
2316
2317 /* scan the struct and create all subdissectors */
2318 level=0;
2319 while(ti){
2320 if(!g_strcmp0(ti->str, "{")){
2321 ti=ti->next;
2322 level++;
2323 continue;
2324 }
2325 if(!g_strcmp0(ti->str, "}")){
2326 if(!level){
2327 break;
2328 }
2329 ti=ti->next;
2330 level--;
2331 continue;
2332 }
2333 if(!g_strcmp0(ti->str, "[")){
2334 ti=parsebrackets(ti, &bi);
2335 continue;
2336 }
2337
2338 if(!bi){
2339 FPRINTF(stderr, "ERROR : typedefunion no brackets found for case\n");
2340 Exit(10);
2341 }
2342 /* make sure we catch when we havent implemented everything
2343 yet.
2344 we currently only know about CASE and CASE_DEFAULT flags
2345 */
2346 if(bi->flags&(~(BI_CASE|BI_CASE_DEFAULT|BI_POINTER))){
2347 FPRINTF(stderr, "ERROR: typedefunion unknown bracket flags encountered : 0x%08x\n",bi->flags);
2348 Exit(10);
2349 }
2350 if(!(bi->flags&BI_CASE)){
2351 FPRINTF(stderr, "ERROR : typedefunion no case found in brackets\n");
2352 Exit(10);
2353 }
2354 #ifdef g_removeD
2355 /* only empty default cases for now */
2356 if(bi->flags&BI_CASE_DEFAULT){
2357 if(g_strcmp0(ti->str,";")){
2358 FPRINTF(stderr, "ERROR: default tag is not empty\n");
2359 Exit(10);
2360 }
2361 ti=ti->next;
2362 continue;
2363 }
2364 #endif
2365
2366 /* just skip all and any 'empty' arms */
2367 if(!g_strcmp0(ti->str, ";")){
2368 ti=ti->next;
2369 continue;
2370 }
2371
2372 /* handle the type, verify that we KNOW this type */
2373 type_item=find_type(ti->str);
2374 if(!type_item){
2375 FPRINTF(stderr, "ERROR : typedefunion unknown type %s\n",ti->str);
2376 Exit(10);
2377 }
2378 ti=ti->next;
2379 /* count the levels of pointers */
2380 for(num_pointers=0;!g_strcmp0(ti->str, "*");ti=ti->next){
2381 num_pointers++;
2382 }
2383
2384 /* keep track of alignment */
2385 if(num_pointers){
2386 item_alignment=4;
2387 } else {
2388 item_alignment=type_item->alignment;
2389 }
2390 if(alignment<item_alignment){
2391 alignment=item_alignment;
2392 }
2393
2394 snprintf(hf_index, BASE_BUFFER_SIZE, "hf_%s_%s_%s_%s", ifname, union_name, case2str(bi->case_name), ti->str);
2395 /* pass 0 generate subdissectors */
2396 if(pass==0){
2397 char filter_name[BASE_BUFFER_SIZE];
2398 const char *hf;
2399
2400 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_dissect_union_%s_%s_%s", ifname, union_name, case2str(bi->case_name), ti->str);
2401 ptmpstr=g_strdup(tmpstr);
2402
2403 snprintf(filter_name, BASE_BUFFER_SIZE, "%s.%s.%s", ifname, union_name, ti->str);
2404 hf=register_hf_field(hf_index, ti->str, filter_name, type_item->ft_type, type_item->base_type, type_item->vals, type_item->mask, "");
2405
2406 FPRINTF(eth_code, "static int\n");
2407 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", ptmpstr);
2408 FPRINTF(eth_code, "{\n");
2409 FPRINTF(eth_code, " uint32_t param=%s;\n",find_dissector_param_value(ptmpstr));
2410 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep, %s, param);\n", type_item->dissector, hf);
2411 FPRINTF(eth_code, " return offset;\n");
2412 FPRINTF(eth_code, "}\n");
2413 FPRINTF(eth_code, "\n");
2414
2415 /* handle pointers */
2416 while(num_pointers--){
2417 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", ptmpstr, "unique");
2418 FPRINTF(eth_code, "static int\n");
2419 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
2420 FPRINTF(eth_code, "{\n");
2421 FPRINTF(eth_code, " offset=dissect_ndr_embedded_pointer(tvb, offset, pinfo, tree, di, drep, %s, NDR_POINTER_UNIQUE, \"%s\", -1);\n", ptmpstr, ti->str);
2422 FPRINTF(eth_code, " return offset;\n");
2423 FPRINTF(eth_code, "}\n");
2424 FPRINTF(eth_code, "\n");
2425
2426 ptmpstr=g_strdup(tmpstr);
2427
2428 }
2429 }
2430
2431 if(pass==1){
2432 /* handle pointers */
2433 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_dissect_union_%s_%s_%s", ifname, union_name, case2str(bi->case_name), ti->str);
2434 ptmpstr=g_strdup(tmpstr);
2435 while(num_pointers--){
2436 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", ptmpstr, "unique");
2437 ptmpstr=g_strdup(tmpstr);
2438 }
2439
2440 if(bi->flags&BI_CASE_DEFAULT){
2441 FPRINTF(eth_code, " default:\n");
2442 } else {
2443 FPRINTF(eth_code, " case %s:\n",bi->case_name);
2444 }
2445 /* each arm itself is aligned independently */
2446 switch(item_alignment){
2447 case 1:
2448 break;
2449 case 2:
2450 FPRINTF(eth_code, " ALIGN_TO_2_BYTES;\n");
2451 break;
2452 case 4:
2453 FPRINTF(eth_code, " ALIGN_TO_4_BYTES;\n");
2454 break;
2455 case 8:
2456 FPRINTF(eth_code, " ALIGN_TO_8_BYTES;\n");
2457 break;
2458 default:
2459 FPRINTF(stderr, "ERROR: typedefunion 3 can not handle alignment:%d\n",item_alignment);
2460 Exit(10);
2461 }
2462 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
2463 FPRINTF(eth_code, " break;\n");
2464 FPRINTF(eth_code, "\n");
2465 }
2466 ti=ti->next;
2467
2468 if(g_strcmp0(ti->str,";")){
2469 FPRINTF(stderr, "ERROR: field does not end with ';'\n");
2470 Exit(10);
2471 }
2472 ti=ti->next;
2473 }
2474
2475 if(pass==1){
2476 FPRINTF(eth_code, " }\n");
2477 FPRINTF(eth_code, "\n");
2478 FPRINTF(eth_code, " proto_item_set_len(item, offset-old_offset);\n");
2479 FPRINTF(eth_code, "\n");
2480 FPRINTF(eth_code, " return offset;\n");
2481 FPRINTF(eth_code, "}\n");
2482 switch(tag_alignment){
2483 case 2:
2484 register_new_type(union_name, dissectorname, "FT_UINT16", "BASE_DEC", "0", "NULL", alignment);
2485 break;
2486 case 4:
2487 register_new_type(union_name, dissectorname, "FT_UINT32", "BASE_DEC", "0", "NULL", alignment);
2488 break;
2489 default:
2490 FPRINTF(stderr, "ERROR: typedefunion 4 can not handle alignment:%d\n",alignment);
2491 Exit(10);
2492 }
2493 }
2494
2495 FPRINTF(NULL,"\nEND UNION:%s pass:%d\n-------\n",union_name,pass);
2496
2497 /* only advance token_list for pass==1
2498 ti now points to the '}' token
2499 */
2500 if(pass==1){
2501 if(!ti || g_strcmp0(ti->str,"}")){
2502 FPRINTF(stderr, "ERROR: union does not end with '}'\n");
2503 Exit(10);
2504 }
2505 ti=ti->next;
2506
2507 /* just skip the name */
2508 ti=ti->next;
2509
2510 if(!ti || g_strcmp0(ti->str,";")){
2511 FPRINTF(stderr, "ERROR: union does not end with ';'\n");
2512 Exit(10);
2513 }
2514 ti=ti->next;
2515
2516 token_list=ti;
2517 }
2518 }
2519
2520
2521 /* this function will parse a
2522 WERROR function (
2523 construct and generate the appropriate code.
2524 the function will be g_removed from the token_list once it has been processed
2525 the function assumes that the function is the first object in the token_list
2526 the function will be called three times with
2527 pass=0 generate subdissectors and entries for the function table
2528 pass=1 generate code for the REQUEST
2529 pass=2 generate code for the REPLY
2530 */
2531 static void parsefunction(int pass)
2532 {
2533 char *function_name;
2534 static int funcno=0;
2535 token_item_t *ti;
2536 bracket_item_t *bi=NULL;
2537 pointer_item_t *pi;
2538 const char *pointer_type;
2539
2540 char tmpstr[BASE_BUFFER_SIZE], *ptmpstr;
2541 int level, num_pointers;
2542 type_item_t *type_item;
2543 char hf_index[BASE_BUFFER_SIZE];
2544
2545 ti=token_list;
2546 if(g_strcmp0(ti->str, "WERROR")){
2547 FPRINTF(stderr, "ERROR: function first token is not 'WERROR'\n");
2548 Exit(10);
2549 }
2550 ti=ti->next;
2551
2552 function_name=ti->str;
2553 ti=ti->next;
2554
2555 if(g_strcmp0(ti->str, "(")){
2556 FPRINTF(stderr, "ERROR: function third token is not '('\n");
2557 Exit(10);
2558 }
2559 ti=ti->next;
2560
2561 FPRINTF(NULL,"\nFUNCTION:%s pass:%d\n-------\n",function_name,pass);
2562
2563 if(pass==0){
2564 FPRINTF(eth_ft, " { %d, \"%s\",\n",funcno,function_name);
2565 FPRINTF(eth_ft, " %s_dissect_%s_request,\n", ifname, function_name);
2566 FPRINTF(eth_ft, " %s_dissect_%s_response },\n", ifname, function_name);
2567 funcno++;
2568 }
2569
2570 /* pass 1,2 generate header for the function dissector */
2571 if((pass==1)||(pass==2)){
2572 FPRINTF(eth_code, "\n");
2573 FPRINTF(eth_code, "static int\n");
2574 FPRINTF(eth_code, "%s_dissect_%s_%s(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, dcerpc_info* di _U_, uint8_t *drep _U_)\n", ifname, function_name, (pass==1)?"request":"response");
2575 FPRINTF(eth_code, "{\n");
2576 }
2577
2578 /* scan the struct and create all subdissectors */
2579 level=0;
2580 while(ti){
2581 if(!g_strcmp0(ti->str, "(")){
2582 ti=ti->next;
2583 level++;
2584 continue;
2585 }
2586 if(!g_strcmp0(ti->str, ")")){
2587 if(!level){
2588 break;
2589 }
2590 ti=ti->next;
2591 level--;
2592 continue;
2593 }
2594 if(!g_strcmp0(ti->str, "[")){
2595 ti=parsebrackets(ti, &bi);
2596 continue;
2597 }
2598
2599 if(!bi){
2600 FPRINTF(stderr, "ERROR : function no brackets found for case\n");
2601 Exit(10);
2602 }
2603
2604 /* make sure we catch when we havent implemented everything
2605 yet.
2606 we currently only know about IN and OUT flags
2607 */
2608 if(bi->flags&(~(BI_IN|BI_OUT|BI_POINTER|BI_SIZE_IS|BI_LENGTH_IS))){
2609 FPRINTF(stderr, "ERROR: function unknown bracket flags encountered : 0x%08x\n",bi->flags);
2610 Exit(10);
2611 }
2612 if(!(bi->flags&(BI_IN|BI_OUT))){
2613 FPRINTF(stderr, "ERROR : function parameter is neither in nor out\n");
2614 Exit(10);
2615 }
2616
2617 /* handle the type, verify that we KNOW this type */
2618 type_item=find_type(ti->str);
2619 if(!type_item){
2620 FPRINTF(stderr, "ERROR : function unknown type %s\n",ti->str);
2621 Exit(10);
2622 }
2623 ti=ti->next;
2624 /* count the levels of pointers */
2625 for(num_pointers=0;!g_strcmp0(ti->str, "*");ti=ti->next){
2626 num_pointers++;
2627 }
2628
2629 /* now that we know how many real pointer there were we must
2630 prepend default pointers to the list so it has the right
2631 length.
2632 */
2633 pi=prepend_pointer_list(bi->pointer_list, num_pointers);
2634
2635 snprintf(hf_index, BASE_BUFFER_SIZE, "hf_%s_%s_%s", ifname, function_name, ti->str);
2636 /* pass 0 generate subdissectors */
2637 if(pass==0){
2638 char filter_name[BASE_BUFFER_SIZE];
2639 const char *hf;
2640
2641 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_dissect_%s_%s", ifname, function_name, ti->str);
2642 ptmpstr=g_strdup(tmpstr);
2643
2644 snprintf(filter_name, BASE_BUFFER_SIZE, "%s.%s.%s", ifname, function_name, ti->str);
2645 hf=register_hf_field(hf_index, ti->str, filter_name, type_item->ft_type, type_item->base_type, type_item->vals, type_item->mask, "");
2646
2647 FPRINTF(eth_code, "static int\n");
2648 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", ptmpstr);
2649 FPRINTF(eth_code, "{\n");
2650 FPRINTF(eth_code, " uint32_t param=%s;\n",find_dissector_param_value(ptmpstr));
2651 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep, %s, param);\n", type_item->dissector, hf);
2652 FPRINTF(eth_code, " return offset;\n");
2653 FPRINTF(eth_code, "}\n");
2654 FPRINTF(eth_code, "\n");
2655
2656
2657 /* handle switch_is */
2658 switch(bi->flags&(BI_SIZE_IS|BI_LENGTH_IS)){
2659 case 0:
2660 break;
2661 case BI_SIZE_IS|BI_LENGTH_IS:
2662 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucvarray_%s", ptmpstr);
2663 FPRINTF(eth_code, "static int\n");
2664 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
2665 FPRINTF(eth_code, "{\n");
2666 FPRINTF(eth_code, " offset=dissect_ndr_ucvarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
2667 FPRINTF(eth_code, " return offset;\n");
2668 FPRINTF(eth_code, "}\n");
2669 FPRINTF(eth_code, "\n");
2670 ptmpstr=g_strdup(tmpstr);
2671 break;
2672 case BI_SIZE_IS:
2673 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucarray_%s", ptmpstr);
2674 FPRINTF(eth_code, "static int\n");
2675 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
2676 FPRINTF(eth_code, "{\n");
2677 FPRINTF(eth_code, " offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
2678 FPRINTF(eth_code, " return offset;\n");
2679 FPRINTF(eth_code, "}\n");
2680 FPRINTF(eth_code, "\n");
2681 ptmpstr=g_strdup(tmpstr);
2682 break;
2683 default:
2684 FPRINTF(stderr, "ERROR: typedeffunction can not handle this combination of sizeis/lengthis\n");
2685 Exit(10);
2686 }
2687
2688 /* handle pointers */
2689 while(num_pointers--){
2690 pointer_type=pi->type;
2691 pi=pi->next;
2692 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", pointer_type, ptmpstr);
2693 FPRINTF(eth_code, "static int\n");
2694 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
2695 FPRINTF(eth_code, "{\n");
2696 FPRINTF(eth_code, " offset=dissect_ndr_toplevel_pointer(tvb, offset, pinfo, tree, di, drep, %s, %s, \"%s\", -1);\n", ptmpstr, ptr_to_define(pointer_type), ti->str);
2697 FPRINTF(eth_code, " return offset;\n");
2698 FPRINTF(eth_code, "}\n");
2699 FPRINTF(eth_code, "\n");
2700
2701 ptmpstr=g_strdup(tmpstr);
2702
2703 }
2704 }
2705
2706 if((pass==1)||(pass==2)){
2707 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_dissect_%s_%s", ifname, function_name, ti->str);
2708 ptmpstr=g_strdup(tmpstr);
2709
2710 switch(bi->flags&(BI_SIZE_IS|BI_LENGTH_IS)){
2711 case 0:
2712 break;
2713 case BI_SIZE_IS|BI_LENGTH_IS:
2714 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucvarray_%s", ptmpstr);
2715 ptmpstr=g_strdup(tmpstr);
2716 break;
2717 case BI_SIZE_IS:
2718 snprintf(tmpstr, BASE_BUFFER_SIZE, "ucarray_%s", ptmpstr);
2719 ptmpstr=g_strdup(tmpstr);
2720 break;
2721 default:
2722 FPRINTF(stderr, "ERROR: typedeffunction can not handle this combination of sizeis/lengthis\n");
2723 Exit(10);
2724 }
2725
2726 /* handle pointers */
2727 while(num_pointers--){
2728 pointer_type=pi->type;
2729 pi=pi->next;
2730 snprintf(tmpstr, BASE_BUFFER_SIZE, "%s_%s", pointer_type, ptmpstr);
2731 ptmpstr=g_strdup(tmpstr);
2732 }
2733
2734 if((pass==1)&&(bi->flags&BI_IN)){
2735 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
2736 FPRINTF(eth_code, " offset=dissect_deferred_pointers(pinfo, tvb, offset, di, drep);\n");
2737 FPRINTF(eth_code, "\n");
2738 }
2739 if((pass==2)&&(bi->flags&BI_OUT)){
2740 FPRINTF(eth_code, " offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
2741 FPRINTF(eth_code, " offset=dissect_deferred_pointers(pinfo, tvb, offset, di, drep);\n");
2742 FPRINTF(eth_code, "\n");
2743 }
2744 }
2745 ti=ti->next;
2746
2747
2748 if(!g_strcmp0(ti->str,",")){
2749 ti=ti->next;
2750 continue;
2751 }
2752 }
2753
2754 if((pass==1)||(pass==2)){
2755 if(pass==2){
2756 FPRINTF(eth_code, " offset=dissect_ntstatus(tvb, offset, pinfo, tree, di, drep, %s, NULL);\n", hf_status);
2757 FPRINTF(eth_code, "\n");
2758 }
2759 FPRINTF(eth_code, "\n");
2760 FPRINTF(eth_code, " return offset;\n");
2761 FPRINTF(eth_code, "}\n");
2762 }
2763
2764 FPRINTF(NULL,"\nEND FUNCTION:%s pass:%d\n-------\n",function_name,pass);
2765
2766 /* only advance token_list for pass==2
2767 ti now points to the ')' token
2768 */
2769 if(pass==2){
2770 if(!ti || g_strcmp0(ti->str,")")){
2771 FPRINTF(stderr, "ERROR: function does not end with ')'\n");
2772 Exit(10);
2773 }
2774 ti=ti->next;
2775
2776 if(!ti || g_strcmp0(ti->str,";")){
2777 FPRINTF(stderr, "ERROR: function does not end with ';'\n");
2778 Exit(10);
2779 }
2780 ti=ti->next;
2781
2782 token_list=ti;
2783 }
2784 }
2785
2786
2787 /* this function will parse a
2788 typedef enum {
2789 or a
2790 typedef [ v1_enum ] enum {
2791 construct and generate the appropriate code.
2792 the typedef will be g_removed from the token_list once it has been processed
2793 the function assumes that the typedef is the first object in the token_list
2794 */
2795 static void parsetypedefenum(void)
2796 {
2797 token_item_t *ti;
2798 enum_list_t *enum_list, *el, *lastel;
2799 char *p;
2800 long val;
2801 int eval, enumsize;
2802 char dissectorname[BASE_BUFFER_SIZE], valsstring[BASE_BUFFER_SIZE];
2803 char *hfvalsstring;
2804
2805 enumsize=16;
2806
2807 ti=token_list;
2808 if(g_strcmp0(ti->str, "typedef")){
2809 FPRINTF(stderr, "ERROR: typedefenum first token is not 'typedef'\n");
2810 Exit(10);
2811 }
2812 ti=ti->next;
2813
2814 /* this could be a [ v1_enum ] */
2815 if(!g_strcmp0(ti->str, "[")){
2816 ti=ti->next;
2817
2818 if(g_strcmp0(ti->str, "v1_enum")){
2819 FPRINTF(stderr, "ERROR: typedefenum not 'v1_enum' inside brackets\n");
2820 Exit(10);
2821 }
2822 ti=ti->next;
2823
2824 if(g_strcmp0(ti->str, "]")){
2825 FPRINTF(stderr, "ERROR: typedefenum 'v1_enum' is not followed by ']'\n");
2826 Exit(10);
2827 }
2828 ti=ti->next;
2829
2830 enumsize=32;
2831 }
2832
2833
2834 if(g_strcmp0(ti->str, "enum")){
2835 FPRINTF(stderr, "ERROR: typedefenum second token is not 'enum'\n");
2836 Exit(10);
2837 }
2838 ti=ti->next;
2839
2840 if(g_strcmp0(ti->str, "{")){
2841 FPRINTF(stderr, "ERROR: typedefenum third token is not '{'\n");
2842 Exit(10);
2843 }
2844 ti=ti->next;
2845
2846 /* now parse all values until we find the "}" */
2847 eval=0;
2848 enum_list=NULL;
2849 lastel=NULL;
2850 while(1){
2851 /* check for '}' */
2852 if(!g_strcmp0(ti->str,"}")){
2853 ti=ti->next;
2854 break;
2855 }
2856
2857 /* handle 4 types of entries:
2858 * 1, CONST = value,
2859 * 2, CONST,
2860 * 3, CONST = value}
2861 * 4, CONST}
2862 */
2863 el=g_new0(enum_list_t, 1);
2864 if (!el) {
2865 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
2866 exit(10);
2867 }
2868 el->next=NULL;
2869 if(!enum_list){
2870 enum_list=el;
2871 } else {
2872 lastel->next=el;
2873 }
2874 lastel=el;
2875
2876 /* grab CONST */
2877 el->name=ti->str;
2878 ti=ti->next;
2879
2880 /* grab separator */
2881 if(!g_strcmp0(ti->str,"=")){
2882 ti=ti->next;
2883 /* grab value */
2884 val=strtol(ti->str,&p,0);
2885 if (p==ti->str||*p) {
2886 FPRINTF(stderr, "ERROR: typedefenum value is not a number\n");
2887 Exit(10);
2888 }
2889 el->val=(int)val;
2890 ti=ti->next;
2891 } else {
2892 el->val=eval;
2893 }
2894 eval=el->val+1;
2895
2896 /* check for ',' */
2897 if(!g_strcmp0(ti->str,",")){
2898 ti=ti->next;
2899 continue;
2900 }
2901
2902 /* check for '}' */
2903 if(!g_strcmp0(ti->str,"}")){
2904 ti=ti->next;
2905 break;
2906 }
2907
2908 FPRINTF(stderr,"ERROR: typedefenum should not be reached\n");
2909 Exit(10);
2910 }
2911
2912 /* verify that it ends with a ';' */
2913 if(g_strcmp0(ti->next->str,";")){
2914 FPRINTF(stderr,"ERROR enum terminator is not ';'\n");
2915 Exit(10);
2916 }
2917
2918 snprintf(valsstring, BASE_BUFFER_SIZE, "%s_%s_vals", ifname, ti->str);
2919 snprintf(dissectorname, DISSECTORNAME_MAXLEN, "%s_dissect_%s", ifname, ti->str);
2920
2921 FPRINTF(NULL,"\nENUM:%s\n-------\n",ti->str);
2922
2923 FPRINTF(eth_hdr, "\n");
2924 for(el=enum_list;el;el=el->next){
2925 FPRINTF(eth_hdr, "#define %s %d\n", el->name, el->val);
2926 }
2927
2928 FPRINTF(eth_hdr, "\n");
2929 FPRINTF(eth_hdr, "extern const value_string %s[];\n", valsstring);
2930 FPRINTF(eth_hdr, "int %s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param);\n", dissectorname);
2931
2932 FPRINTF(eth_code, "\n");
2933 FPRINTF(eth_code, "const value_string %s[] = {\n", valsstring);
2934
2935 for(el=enum_list;el;el=el->next){
2936 FPRINTF(eth_code, " { %d , \"%s\" },\n", el->val, el->name);
2937 }
2938 FPRINTF(eth_code, " { 0 , NULL }\n");
2939 FPRINTF(eth_code, "};\n");
2940
2941 FPRINTF(eth_code, "\n");
2942 FPRINTF(eth_code, "int\n");
2943 FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep, int hf_index, uint32_t param _U_)\n", dissectorname);
2944 FPRINTF(eth_code, "{\n");
2945 switch(enumsize){
2946 case 16:
2947 FPRINTF(eth_code, " offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
2948 break;
2949 case 32:
2950 FPRINTF(eth_code, " offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
2951 break;
2952 default:
2953 FPRINTF(stderr,"ERROR enum unknown size\n");
2954 Exit(10);
2955 }
2956
2957 FPRINTF(eth_code, " return offset;\n");
2958 FPRINTF(eth_code, "}\n");
2959 FPRINTF(eth_code, "\n");
2960
2961 hfvalsstring = g_strdup_printf("VALS(%s)", valsstring);
2962 switch(enumsize){
2963 case 16:
2964 register_new_type(ti->str, dissectorname, "FT_INT16", "BASE_DEC", "0", hfvalsstring, 2);
2965 break;
2966 case 32:
2967 register_new_type(ti->str, dissectorname, "FT_INT32", "BASE_DEC", "0", hfvalsstring, 4);
2968 break;
2969 default:
2970 FPRINTF(stderr,"ERROR enum unknown size\n");
2971 g_free(hfvalsstring);
2972 Exit(10);
2973 }
2974 g_free(hfvalsstring);
2975
2976 FPRINTF(NULL,"\n----------\nEND ENUM:%s\n",ti->str);
2977
2978 /* skip past the name and the ';' */
2979 token_list=ti->next->next;
2980 }
2981
2982 typedef struct _trimmed_prefixes_t {
2983 struct _trimmed_prefixes_t *next;
2984 char *name;
2985 } trimmed_prefixes_t;
2986 static trimmed_prefixes_t *prefixes_to_trim=NULL;
2987
2988 static void preparetrimprefix(char *prefix_name)
2989 {
2990 trimmed_prefixes_t *new_prefix;
2991 new_prefix=g_new0(trimmed_prefixes_t, 1);
2992 if (!new_prefix) {
2993 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
2994 exit(10);
2995 }
2996 new_prefix->next=prefixes_to_trim;
2997 prefixes_to_trim=new_prefix;
2998 new_prefix->name=g_strdup(prefix_name);
2999 }
3000
3001 static void
3002 trimprefix(void)
3003 {
3004 token_item_t *ti;
3005 trimmed_prefixes_t *pfx;
3006 size_t len;
3007
3008 for(pfx=prefixes_to_trim;pfx;pfx=pfx->next){
3009 len=strlen(pfx->name);
3010 for(ti=token_list;ti;ti=ti->next){
3011 if(!strncmp(ti->str, pfx->name, len)){
3012 ti->str+=len;
3013 }
3014 }
3015 }
3016 }
3017
3018 static int Exit(int code)
3019 {
3020 FPRINTF(stderr, "The tokens remaining when aborting:\n");
3021 printtokenlist(10);
3022
3023 exit(code);
3024 }
3025
3026 static void usage(void)
3027 {
3028 FPRINTF(stderr, "Usage: idl2wrs <interface>\n");
3029 }
3030
3031 static void
3032 mergefile(const char *name, FILE *outfile)
3033 {
3034 FILE *infile;
3035
3036 FPRINTF(outfile, "\n\n/* INCLUDED FILE : %s */\n", name);
3037 infile=g_fopen(name, "r");
3038 while(!feof(infile)){
3039 int ch;
3040 ch=fgetc(infile);
3041 if(ch!=-1){
3042 fputc(ch, outfile);
3043 }
3044 }
3045 fclose(infile);
3046 FPRINTF(outfile, "/* END OF INCLUDED FILE : %s */\n\n\n", name);
3047 }
3048
3049
3050
3051 static char *
3052 str_read_string(char *str, char **name)
3053 {
3054 char tmpstr[BASE_BUFFER_SIZE], *strptr;
3055 int skip_blanks;
3056 int quoted_string;
3057
3058 strptr=tmpstr;
3059 skip_blanks=1;
3060 quoted_string=0;
3061 while(1){
3062 if(!*str){
3063 *strptr=0;
3064 *name=g_strdup(tmpstr);
3065 return str;
3066 }
3067 if(skip_blanks){
3068 if( (*str==' ') || (*str=='\t') ){
3069 str++;
3070 continue;
3071 }
3072 if( *str=='"' ){
3073 str++;
3074 quoted_string=1;
3075 }
3076 skip_blanks=0;
3077 continue;
3078 }
3079 if( (*str==' ') || (*str=='\t') ){
3080 if(quoted_string){
3081 *strptr++ = *str++;
3082 continue;
3083 }
3084 *strptr=0;
3085 *name=g_strdup(tmpstr);
3086 return str;
3087 }
3088 if( (*str=='"') || (*str=='\n') ){
3089 *strptr=0;
3090 *name=g_strdup(tmpstr);
3091 return ++str;
3092 }
3093 *strptr++ = *str++;
3094 }
3095 return NULL;
3096 }
3097
3098 static void
3099 readcnffile(FILE *fh)
3100 {
3101 char cnfline[4 * BASE_BUFFER_SIZE];
3102
3103 FPRINTF(NULL, "Reading conformance file\n=======================\n");
3104 while(!feof(fh)){
3105 cnfline[0]=0;
3106 if(!fgets(cnfline, 4 * BASE_BUFFER_SIZE, fh) || !cnfline[0]){
3107 continue;
3108 }
3109 if(cnfline[0]=='#'){
3110 /* ignore all comments */
3111 } else if(!strncmp(cnfline, "NOEMIT", 6)){
3112 no_emit_item_t *nei;
3113 char *str, *name;
3114
3115 str=cnfline+6;
3116 str_read_string(str, &name);
3117 nei=g_new0(no_emit_item_t, 1);
3118 if (!nei) {
3119 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
3120 exit(10);
3121 }
3122 nei->next=no_emit_list;
3123 no_emit_list=nei;
3124 nei->name=name;
3125 FPRINTF(NULL, "NOEMIT : %s\n", nei->name);
3126 } else if(!strncmp(cnfline, "TYPE", 4)){
3127 char *name, *dissectorname, *ft_type, *base_type;
3128 char *mask, *valsstring, *al;
3129 char *str;
3130 int alignment;
3131
3132 str=cnfline+4;
3133 str=str_read_string(str, &name);
3134 str=str_read_string(str, &dissectorname);
3135 str=str_read_string(str, &ft_type);
3136 str=str_read_string(str, &base_type);
3137 str=str_read_string(str, &mask);
3138 str=str_read_string(str, &valsstring);
3139 str_read_string(str, &al);
3140 if (ws_strtoi32(al, NULL, &alignment)) {
3141 FPRINTF(NULL, "TYPE : X%s,%sX\n", name, dissectorname);
3142 register_new_type(name, dissectorname, ft_type, base_type, mask, valsstring, alignment);
3143 }
3144 } else if(!strncmp(cnfline, "PARAM_VALUE", 11)){
3145 char *dissectorname, *value;
3146 char *str;
3147
3148 str=cnfline+11;
3149 str=str_read_string(str, &dissectorname);
3150 str_read_string(str, &value);
3151
3152 FPRINTF(NULL, "PARAM_VALUE : %s=%s\n", dissectorname,value);
3153 register_dissector_param_value(dissectorname, value);
3154 } else if(!strncmp(cnfline, "HF_FIELD", 8)){
3155 char *hf_index, *title, *filter_name, *ft_type;
3156 char *base_type, *valsstring, *mask, *blurb;
3157 char *str;
3158
3159 str=cnfline+8;
3160 str=str_read_string(str, &hf_index);
3161 str=str_read_string(str, &title);
3162 str=str_read_string(str, &filter_name);
3163 str=str_read_string(str, &ft_type);
3164 str=str_read_string(str, &base_type);
3165 str=str_read_string(str, &valsstring);
3166 str=str_read_string(str, &mask);
3167 str_read_string(str, &blurb);
3168 FPRINTF(NULL, "HF_FIELD: %s \"%s\"\n", hf_index, title);
3169 register_hf_field(hf_index, title, filter_name, ft_type, base_type, valsstring, mask, blurb);
3170 } else if(!strncmp(cnfline, "HF_RENAME", 9)){
3171 char *old_name, *new_name;
3172 char *str;
3173
3174 str=cnfline+9;
3175 str=str_read_string(str, &old_name);
3176 str_read_string(str, &new_name);
3177 FPRINTF(NULL, "HF_RENAME: %s -> %s\n", old_name, new_name);
3178 register_hf_rename(old_name, new_name);
3179 } else if(!strncmp(cnfline, "UNION_TAG_SIZE", 14)){
3180 char *union_name, *union_tag;
3181 int32_t union_tag_size;
3182 union_tag_size_item_t *utsi;
3183 char *str;
3184
3185 str=cnfline+14;
3186 str=str_read_string(str, &union_name);
3187 str_read_string(str, &union_tag);
3188 if (!ws_strtoi32(union_tag, NULL, &union_tag_size)) {
3189 FPRINTF(NULL, "UNION_TAG_SIZE: invalid string: %s\n", union_tag);
3190 exit(10);
3191 }
3192 FPRINTF(NULL, "UNION_TAG_SIZE: %s == %d\n", union_name, union_tag_size);
3193 utsi=g_new0(union_tag_size_item_t, 1);
3194 if (!utsi) {
3195 FPRINTF(stderr, "Can't allocate memory. Exit.\n");
3196 exit(10);
3197 }
3198 utsi->next=union_tag_size_list;
3199 union_tag_size_list=utsi;
3200 utsi->name=g_strdup(union_name);
3201 utsi->size=union_tag_size;
3202 } else if(!strncmp(cnfline, "STRIP_PREFIX", 12)){
3203 char *prefix_name;
3204 char *str;
3205
3206 str=cnfline+12;
3207 str_read_string(str, &prefix_name);
3208 FPRINTF(NULL, "STRIP_PREFIX: %s\n", prefix_name);
3209 preparetrimprefix(prefix_name);
3210 } else {
3211 FPRINTF(stderr, "ERROR: could not parse cnf directive:%s\n",cnfline);
3212 exit(10);
3213 }
3214 }
3215 }
3216
3217 int main(int argc, const char *argv[])
3218 {
3219 char idlfile[BASE_BUFFER_SIZE];
3220 char tmplfile[BASE_BUFFER_SIZE];
3221 char prefix_str[BASE_BUFFER_SIZE];
3222 bracket_item_t *bi;
3223 FILE *fh;
3224
3225 if(argc!=2){
3226 usage();
3227 exit(0);
3228 }
3229
3230 eth_code=g_fopen("ETH_CODE", "w");
3231 eth_hdr=g_fopen("ETH_HDR", "w");
3232 eth_hfarr=g_fopen("ETH_HFARR", "w");
3233 eth_hf=g_fopen("ETH_HF", "w");
3234 eth_ettarr=g_fopen("ETH_ETTARR", "w");
3235 eth_ett=g_fopen("ETH_ETT", "w");
3236 eth_ft=g_fopen("ETH_FT", "w");
3237 eth_handoff=g_fopen("ETH_HANDOFF", "w");
3238
3239 snprintf(idlfile, BASE_BUFFER_SIZE, "%s.cnf", argv[1]);
3240 fh=g_fopen(idlfile,"r");
3241 if(fh){
3242 readcnffile(fh);
3243 fclose(fh);
3244 }
3245
3246 snprintf(idlfile, BASE_BUFFER_SIZE, "%s.idl", argv[1]);
3247 fh=g_fopen(idlfile,"r");
3248 if(!fh){
3249 FPRINTF(stderr, "ERROR: could not open idl-file:%s\n", idlfile);
3250 Exit(0);
3251 }
3252
3253 lineno=0;
3254 linepos=0;
3255 tokenize(fh);
3256 prune_keyword_parameters("size_is");
3257 prune_keyword_parameters("length_is");
3258 rename_tokens("NTSTATUS", "WERROR");
3259 rename_tokens("unistr_noterm", "unistr");
3260 rename_tokens("ascstr_noterm", "ascstr");
3261 rename_tokens("hyper", "uint64");
3262 FPRINTF(NULL,"\n\nParsing header:\n================\n");
3263 parseheader();
3264
3265 /* some idl files prepend a lot of symbols with <ifname>_
3266 search through the tokenlist and g_remove all such
3267 prefixes
3268 */
3269 snprintf(prefix_str, BASE_BUFFER_SIZE, "%s_", ifname);
3270 preparetrimprefix(prefix_str);
3271 trimprefix();
3272
3273 /* this is the main loop, each iteration it tries to identify what
3274 kind of construct is the first entry in the token_list and call
3275 the appropriate handler
3276 */
3277 while(1) {
3278 /* just skip any [ ] that starts a new construct */
3279 if( !g_strcmp0(token_list->str, "[") ){
3280 token_list=parsebrackets(token_list, &bi);
3281 continue;
3282 }
3283
3284 /* typedef enum { */
3285 if( !g_strcmp0(token_list->str,"typedef")
3286 &&!g_strcmp0(token_list->next->str,"enum") ){
3287 parsetypedefenum();
3288 continue;
3289 }
3290
3291 /* typedef [ v1_enum ] enum { */
3292 if( !g_strcmp0(token_list->str,"typedef")
3293 &&!g_strcmp0(token_list->next->str,"[")
3294 &&!g_strcmp0(token_list->next->next->str,"v1_enum")
3295 &&!g_strcmp0(token_list->next->next->next->str,"]")
3296 &&!g_strcmp0(token_list->next->next->next->next->str,"enum") ){
3297 parsetypedefenum();
3298 continue;
3299 }
3300
3301 /* const */
3302 if( !g_strcmp0(token_list->str,"const") ){
3303 parseconst();
3304 continue;
3305 }
3306
3307 /* typedef struct { */
3308 if( !g_strcmp0(token_list->str,"typedef") ){
3309 token_item_t *tmpti;
3310
3311 tmpti=token_list->next;
3312 if( !g_strcmp0(tmpti->str, "[") ){
3313 tmpti=parsebrackets(tmpti, &bi);
3314 /* do some sanity checks here of bi->flags */
3315 }
3316 if( !g_strcmp0(tmpti->str, "struct") ){
3317 parsetypedefstruct(0);
3318 parsetypedefstruct(1);
3319 continue;
3320 }
3321 }
3322
3323 /* typedef union { */
3324 if( !g_strcmp0(token_list->str,"typedef") ){
3325 token_item_t *tmpti;
3326
3327 tmpti=token_list->next;
3328 if( !g_strcmp0(tmpti->str, "[") ){
3329 tmpti=parsebrackets(tmpti, &bi);
3330 /* do some sanity checks here of bi->flags */
3331 }
3332 if( !g_strcmp0(tmpti->str, "union") ){
3333 parsetypedefunion(0);
3334 parsetypedefunion(1);
3335 continue;
3336 }
3337 }
3338
3339 /* typedef bitmap { */
3340 if( !g_strcmp0(token_list->str,"typedef") ){
3341 token_item_t *tmpti;
3342
3343 tmpti=token_list->next;
3344 if( !g_strcmp0(tmpti->str, "[") ){
3345 tmpti=parsebrackets(tmpti, &bi);
3346 /* do some sanity checks here of bi->flags */
3347 }
3348 if( !g_strcmp0(tmpti->str, "bitmap") ){
3349 parsetypedefbitmap(0);
3350 parsetypedefbitmap(1);
3351 continue;
3352 }
3353 }
3354
3355 /* functions: WERROR function '(' */
3356 if( !g_strcmp0(token_list->str,"WERROR")
3357 &&!g_strcmp0(token_list->next->next->str,"(") ){
3358 parsefunction(0);
3359 parsefunction(1);
3360 parsefunction(2);
3361 continue;
3362 }
3363
3364 /* declare ... ; */
3365 if( !g_strcmp0(token_list->str,"declare") ){
3366 skipdeclare();
3367 continue;
3368 }
3369
3370
3371 break;
3372 };
3373
3374
3375 fclose(eth_code);
3376 fclose(eth_hdr);
3377 fclose(eth_hf);
3378 fclose(eth_hfarr);
3379 fclose(eth_ett);
3380 fclose(eth_ettarr);
3381 fclose(eth_ft);
3382 fclose(eth_handoff);
3383
3384 /* unless the token_list now only contains a single token : '}'
3385 we have failed to compile the idl file properly
3386 */
3387 if( g_strcmp0(token_list->str, "}") || token_list->next){
3388 FPRINTF(stderr, "ERROR: we did not process all tokens. Compiler is incomplete.\n===========================================\n");
3389 printtokenlist(10);
3390 exit(10);
3391 }
3392
3393 check_hf_rename_refcount();
3394
3395 /* merge code and template into dissector */
3396 snprintf(line, 4 * BASE_BUFFER_SIZE, "packet-dcerpc-%s.c", ifname);
3397 fh=g_fopen(line, "w");
3398 snprintf(tmplfile, BASE_BUFFER_SIZE, "packet-dcerpc-%s-template.c", argv[1]);
3399 tfh=g_fopen(tmplfile, "r");
3400 if(!tfh){
3401 FPRINTF(stderr, "ERROR: could not find %s\n", tmplfile);
3402 exit(10);
3403 }
3404 while(!feof(tfh)){
3405 line[0]=0;
3406 if(!fgets(line, 4 * BASE_BUFFER_SIZE, tfh) || !line[0]){
3407 continue;
3408 }
3409 if(!strncmp(line, "ETH_CODE", 8)){
3410 mergefile("ETH_CODE",fh);
3411 } else if(!strncmp(line, "ETH_HDR", 7)){
3412 mergefile("ETH_HDR",fh);
3413 } else if(!strncmp(line, "ETH_HFARR", 9)){
3414 mergefile("ETH_HFARR",fh);
3415 } else if(!strncmp(line, "ETH_HF", 6)){
3416 mergefile("ETH_HF",fh);
3417 } else if(!strncmp(line, "ETH_ETTARR", 10)){
3418 mergefile("ETH_ETTARR",fh);
3419 } else if(!strncmp(line, "ETH_ETT", 7)){
3420 mergefile("ETH_ETT",fh);
3421 } else if(!strncmp(line, "ETH_FT", 6)){
3422 mergefile("ETH_FT",fh);
3423 } else if(!strncmp(line, "ETH_HANDOFF", 11)){
3424 mergefile("ETH_HANDOFF",fh);
3425 } else {
3426 fputs(line, fh);
3427 }
3428 }
3429 fclose(fh);
3430 fclose(tfh);
3431
3432 snprintf(line, 4 * BASE_BUFFER_SIZE, "packet-dcerpc-%s.h", ifname);
3433 fh=g_fopen(line, "w");
3434 snprintf(tmplfile, BASE_BUFFER_SIZE, "packet-dcerpc-%s-template.h", argv[1]);
3435 tfh=g_fopen(tmplfile, "r");
3436 if(!tfh){
3437 FPRINTF(stderr, "ERROR: could not find %s\n", tmplfile);
3438 exit(10);
3439 }
3440 while(!feof(tfh)){
3441 line[0]=0;
3442 if(!fgets(line, 4 * BASE_BUFFER_SIZE, tfh) || !line[0]){
3443 continue;
3444 }
3445 if(!strncmp(line, "ETH_CODE", 8)){
3446 mergefile("ETH_CODE",fh);
3447 } else if(!strncmp(line, "ETH_HDR", 7)){
3448 mergefile("ETH_HDR",fh);
3449 } else if(!strncmp(line, "ETH_HFARR", 9)){
3450 mergefile("ETH_HFARR",fh);
3451 } else if(!strncmp(line, "ETH_HF", 6)){
3452 mergefile("ETH_HF",fh);
3453 } else if(!strncmp(line, "ETH_ETTARR", 10)){
3454 mergefile("ETH_ETTARR",fh);
3455 } else if(!strncmp(line, "ETH_ETT", 7)){
3456 mergefile("ETH_ETT",fh);
3457 } else if(!strncmp(line, "ETH_FT", 6)){
3458 mergefile("ETH_FT",fh);
3459 } else if(!strncmp(line, "ETH_HANDOFF", 11)){
3460 mergefile("ETH_HANDOFF",fh);
3461 } else {
3462 fputs(line, fh);
3463 }
3464 }
3465
3466 g_print("%s was successfully compiled\n", ifname);
3467
3468 fclose(fh);
3469 fclose(tfh);
3470
3471 if (g_remove("ETH_CODE") == -1) {
3472 FPRINTF(stderr, "Can't remove ETH_CODE");
3473 }
3474 if (g_remove("ETH_HDR") == -1) {
3475 FPRINTF(stderr, "Can't remove ETH_CODE");
3476 }
3477 if (g_remove("ETH_HFARR") == -1) {
3478 FPRINTF(stderr, "Can't remove ETH_CODE");
3479 }
3480 if (g_remove("ETH_HF") == -1) {
3481 FPRINTF(stderr, "Can't remove ETH_CODE");
3482 }
3483 if (g_remove("ETH_ETTARR") == -1) {
3484 FPRINTF(stderr, "Can't remove ETH_CODE");
3485 }
3486 if (g_remove("ETH_ETT") == -1) {
3487 FPRINTF(stderr, "Can't remove ETH_CODE");
3488 }
3489 if (g_remove("ETH_FT") == -1) {
3490 FPRINTF(stderr, "Can't remove ETH_CODE");
3491 }
3492 if (g_remove("ETH_HANDOFF") == -1) {
3493 FPRINTF(stderr, "Can't remove ETH_CODE");
3494 }
3495
3496
3497 return 0;
3498 }
3499
3500 /*
3501 * Editor modelines - https://www.wireshark.org/tools/modelines.html
3502 *
3503 * Local variables:
3504 * c-basic-offset: 8
3505 * tab-width: 8
3506 * indent-tabs-mode: t
3507 * End:
3508 *
3509 * vi: set shiftwidth=8 tabstop=8 noexpandtab:
3510 * :indentSize=8:tabSize=8:noTabs=false:
3511 */
Metzes wireshark repo