/builds/wireshark/wireshark/epan/dissectors/dcerpc/idl2wrs.c

Bug Summary

File:	epan/dissectors/dcerpc/idl2wrs.c
Warning:	line 968, column 6 File position of the stream might be 'indeterminate' after a failed operation. Can cause undefined behavior
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name idl2wrs.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_DEBUG -D WS_DEBUG_UTF_8 -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-truncation -Wno-format-nonliteral -Wno-pointer-sign -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2025-10-21-100328-3623-1 -x c /builds/wireshark/wireshark/epan/dissectors/dcerpc/idl2wrs.c
1/* idl2wrs.c
* DCE RPC IDL to Wireshark dissector compiler
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

11/*
12TODO
 check that every cnf defined type,hffield,rename,... has been referenced
 at least once and if not,   abort with an error

 need to distinguish between NTTIME (absolute time) and relative time

 prune_xxx should only act inside of '[' ']'

 add support for bool8,16,32,64 with tfs strings

 add the remaining array type  (uvarray)

 add code to verify that union tag length is correct
25*/
26/* List of built in types :
 WERROR	A 32 bit integer holding a DCE/NT status code.

 uint8	A 8 bit integer
 int8

 uint16	A 16 bit integer
 int16

 uint32	A 32 bit integer
 int32

 uint64	A 64 bit integer

 udlong	A 64 bit integer aligned on 4 byte boundary
 dlong

 time_t	A 32 bit integer holding a unix style time_t

 NTTIME_hyper A 64 bit integer representing a NTTIME
 NTTIME_1sec

 unistr		A conformant and varying unicode string

 ascstr		A conformant and varying ascii string


 SID			A SID structure.

 uuid_t	A 16 byte FT_GUID blob.
 GUID


 policy_handle
 bool8
 uuid_t
 policy_handle
 NTTIME
64*/

66/* All field dissectors that call a normal type
 (i.e. not a pointer, not an array)
 has a local variable  unsigned param declared which is passed on to the
 type dissector.
 The default value is 0 but the PARAM_VALUE conformance tag can be used to
 change it.
 This is only meaningful if the called type dissector actually does anything
 with this parameter.
74*/

76#define _GNU_SOURCE

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>

85#undef IDL2WRS_DEBUG

87#define DISSECTORNAME_MAXLEN256 256

89#define BASE_BUFFER_SIZE256 256

91static FILE *tfh, *eth_code, *eth_hdr, *eth_hf, *eth_hfarr, *eth_ett, *eth_ettarr, *eth_ft, *eth_handoff;
92static char *uuid=NULL((void*)0);
93static char *version=NULL((void*)0);
94static const char *pointer_default=NULL((void*)0);
95static char *ifname=NULL((void*)0);
96static char hf_status[BASE_BUFFER_SIZE256];
97static int lineno,linepos;
98static char line[4 * BASE_BUFFER_SIZE256];

100static void FPRINTF(FILE *fh, const char *format, ...)
101{
va_list args;

104#ifdef IDL2WRS_DEBUG
va_start(args, format)__builtin_va_start(args, format);
vfprintf (stderrstderr, format, args);
va_end(args)__builtin_va_end(args);
108#endif
if (fh) {
va_start(args, format)__builtin_va_start(args, format);
vfprintf (fh, format, args);
va_end(args)__builtin_va_end(args);
}
114}

116typedef struct _pointer_item_t {
struct _pointer_item_t *next;
const char *type;
119} pointer_item_t;

121#define BI_CASE0x00000001			0x00000001
122#define BI_CASE_DEFAULT0x00000002		0x00000002
123#define BI_IN0x00000004			0x00000004
124#define BI_OUT0x00000008			0x00000008
125#define BI_SIZE_IS0x00000010		0x00000010
126#define BI_LENGTH_IS0x00000020		0x00000020
127#define BI_POINTER0x00000040		0x00000040
128#define BI_BITMAP80x00000100		0x00000100
129#define BI_BITMAP320x00000200		0x00000200
130#define BI_SWITCH_TYPE0x00000400		0x00000400
131typedef struct _bracket_item_t {
unsigned int flags;
const char *case_name;
pointer_item_t *pointer_list;
int union_tag_size;
136} bracket_item_t;

138typedef struct _no_emit_item_t {
struct _no_emit_item_t *next;
char *name;
141} no_emit_item_t;
142static no_emit_item_t *no_emit_list=NULL((void*)0);

144typedef struct _hf_rename_item_t {
struct _hf_rename_item_t *next;
int refcount;	/* number of times this rename has been referenced */
char *old_name;
char *new_name;
149} hf_rename_item_t;
150static hf_rename_item_t *hf_rename_list=NULL((void*)0);

152typedef struct _enum_list_t {
struct _enum_list_t *next;
char *name;
int val;
156} enum_list_t;

158typedef struct _token_item_t {
struct _token_item_t *next;
char *str;
161} token_item_t;
162static token_item_t *token_list=NULL((void*)0);
163static token_item_t *last_token_item=NULL((void*)0);

165typedef struct _type_item_t {
struct _type_item_t *next;
char *name;
char *dissector;
char *ft_type;
char *base_type;
char *mask;
char *vals;
int alignment;
174} type_item_t;
175static type_item_t *type_list=NULL((void*)0);

177typedef struct _union_tag_size_item_t {
struct _union_tag_size_item_t *next;
char *name;
int size;
181} union_tag_size_item_t;
182static union_tag_size_item_t *union_tag_size_list=NULL((void*)0);

184typedef struct _hf_field_item_t {
struct _hf_field_item_t *next;
char *name;
char *ft_type;
188} hf_field_item_t;
189static hf_field_item_t *hf_field_list=NULL((void*)0);

191typedef struct _dissector_param_value_t {
struct _dissector_param_value_t *next;
char *name;
char *value;
195} dissector_param_value_t;
196static dissector_param_value_t *dissector_param_list=NULL((void*)0);

198static type_item_t *find_type(char *name);
199static int Exit(int code);

201static void
202register_dissector_param_value(const char *name, const char *value)
203{
dissector_param_value_t *dpv;
dpv=g_new0(dissector_param_value_t, 1)((dissector_param_value_t *) g_malloc0_n ((1), sizeof (dissector_param_value_t
)));
if (!dpv) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
dpv->next=dissector_param_list;
dissector_param_list=dpv;
dpv->name=g_strdup(name)g_strdup_inline (name);
dpv->value=g_strdup(value)g_strdup_inline (value);
214}

216static const char *
217find_dissector_param_value(char *name)
218{
dissector_param_value_t *dpv;
for(dpv=dissector_param_list;dpv;dpv=dpv->next){
if(!g_strcmp0(name,dpv->name)){
	return dpv->value;
}
}
return "0";
226}

228static pointer_item_t *
229prepend_pointer_list(pointer_item_t *ptrs, int num_pointers)
230{
pointer_item_t *pi;

pi=ptrs;
while(pi){
if(num_pointers)num_pointers--;
pi=pi->next;
}
pi=ptrs;
while(num_pointers--){
pi=g_new0(pointer_item_t, 1)((pointer_item_t *) g_malloc0_n ((1), sizeof (pointer_item_t)
));
if (!pi) {
	FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
	exit(10);
}
pi->next=ptrs;
pi->type=pointer_default;
ptrs=pi;
}
ptrs=pi;

return ptrs;
252}

254static const char *
255ptr_to_define(const char *pointer_type)
256{
if(!g_strcmp0(pointer_type, "unique")){
return "NDR_POINTER_UNIQUE";
} else if(!g_strcmp0(pointer_type, "ref")){
return "NDR_POINTER_REF";
} else if(!g_strcmp0(pointer_type, "ptr")){
return "NDR_POINTER_PTR";
}

FPRINTF(stderrstderr, "prt_to_define, 	weirdo pointer :%s\n", pointer_type);
exit(10);
267}

269static int
270get_union_tag_size(char *name)
271{
union_tag_size_item_t *utsi;
for(utsi=union_tag_size_list;utsi;utsi=utsi->next){
if(!g_strcmp0(name, utsi->name)){
	return utsi->size;
}
}
FPRINTF(stderrstderr, "ERROR: size of tag for union:%s is not known\n", name);
FPRINTF(stderrstderr, "  use the UNION_TAG_SIZE directive to specify it in the conformance file\n");
exit(10);
281}


284/* this function will add an entry to the hf_rename list */
285static void
286register_hf_rename(const char *old_name, const char *new_name)
287{
hf_rename_item_t *new_item;
new_item=g_new0(hf_rename_item_t, 1)((hf_rename_item_t *) g_malloc0_n ((1), sizeof (hf_rename_item_t
)));
if (!new_item) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
new_item->next=hf_rename_list;
hf_rename_list=new_item;
new_item->refcount=0;
new_item->old_name=g_strdup(old_name)g_strdup_inline (old_name);
new_item->new_name=g_strdup(new_name)g_strdup_inline (new_name);
299}

301/* this function checks that all hf_rename fields have actually been referenced
 if not	out conformance file is stale
303*/
304static void
305check_hf_rename_refcount(void)
306{
hf_rename_item_t *hri;

/* don't generate code for renamed hf fields  just return the new name*/
for(hri=hf_rename_list;hri;hri=hri->next){
if(!hri->refcount){
	FPRINTF(stderrstderr, "ERROR: the hf_rename field:%s was never referenced. it is likely the conformance file is stale\n", hri->old_name);
	exit(10);
}
}
316}

318static hf_field_item_t *
319find_hf_field(char *name)
320{
hf_field_item_t *hfi;

for(hfi=hf_field_list;hfi;hfi=hfi->next){
if(!g_strcmp0(hfi->name, name)){
	break;
}
}
if (!hfi) {
FPRINTF(stderrstderr, "find_hf_field:  unknown hf_field:%s\n",name);
Exit(10);
}

return hfi;
334}


337/* this function will create the code required for a hf field.
 it MIGHT rename the field so a user MUST use the name returned
 from this function.
 for fields that are to be renamed  no code is generated
341*/
342static const char *
343register_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{
hf_field_item_t *hfi;
hf_rename_item_t *hri;

/* don't generate code for renamed hf fields  just return the new name*/
for(hri=hf_rename_list;hri;hri=hri->next){
if(!strncmp(hf_name, hri->old_name, strlen(hf_name))){
	hfi=find_hf_field(hri->new_name);
	if(g_strcmp0(ft_type, hfi->ft_type)){
		FPRINTF(stderrstderr, "register_hf_field:  hf_fields %s and %s have different types %s %s\n",hf_name,hfi->name,ft_type,hfi->ft_type);
		Exit(10);
	}
	hri->refcount++;
	return hri->new_name;
}
}

hfi=g_new0(hf_field_item_t, 1)((hf_field_item_t *) g_malloc0_n ((1), sizeof (hf_field_item_t
)));
if (!hfi) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
hfi->next=hf_field_list;
hf_field_list=hfi;
hfi->name=g_strdup(hf_name)g_strdup_inline (hf_name);
hfi->ft_type=g_strdup(ft_type)g_strdup_inline (ft_type);

FPRINTF(eth_hf, "static int %s;\n", hf_name);
FPRINTF(eth_hfarr, "		{ &%s,\n", hf_name);
FPRINTF(eth_hfarr, "		  { \"%s\", \"%s\", %s, %s,\n", title, filter_name, ft_type, base_type);
FPRINTF(eth_hfarr, "		  %s, %s,\n", valsstring, mask);
if (strlen(blurb) > 0)
FPRINTF(eth_hfarr, "		 \"%s\", HFILL }},\n", blurb);
else
FPRINTF(eth_hfarr, "		 NULL, HFILL }},\n");
FPRINTF(eth_hfarr, "\n");

return hf_name;
382}

384/* this function will parse the no emit list and decide whether code should
 be generated for this dissector or if we should only register the type.
386*/
387static int
388check_if_to_emit(char *name)
389{
no_emit_item_t *nel;

for(nel=no_emit_list;nel;nel=nel->next){
if(!g_strcmp0(name, nel->name)){
	FPRINTF(NULL((void*)0), "SKIPPED emitting of %s\n",name);
	return 0;
}
}
return 1;
399}

401#if 0
402static void
403prune_keywords(char *name)
404{
token_item_t *ti;

for(ti=token_list;ti;ti=ti->next){
if(!ti->next){
	break;
}
if(!g_strcmp0(ti->next->str, name)){
	if(!g_strcmp0(ti->next->next->str, ",")){
		ti->next=ti->next->next->next;
	} else {
		ti->next=ti->next->next;
	}
}
}
419}
420#endif

422static void
423rename_tokens(const char *old_name, const char *new_name)
424{
token_item_t *ti;

for(ti=token_list;ti;ti=ti->next){
if(!g_strcmp0(ti->str, old_name)){
	ti->str=g_strdup(new_name)g_strdup_inline (new_name);
}
}
432}

434static void
435prune_keyword_parameters(const char *name)
436{
token_item_t *ti, *tmpti;

for(ti=token_list;ti;ti=ti->next){
if(!g_strcmp0(ti->str, name)){
	if(!g_strcmp0(ti->next->str, "(")){
		tmpti=ti;
		while(1){
			if(!g_strcmp0(tmpti->str, ")")){
				ti->next=tmpti->next;
				break;
			}
			tmpti=tmpti->next;
		}
	}
}
}
453}

455/* this function will parse a bracket item
  [ ... ]
 it will return the token of the next item following the ']'
458*/
459static token_item_t *
460parsebrackets(token_item_t *ti, bracket_item_t **bracket){
bracket_item_t *br;
const type_item_t *type_item;

if(g_strcmp0(ti->str, "[")){
FPRINTF(stderrstderr, "ERROR: parsebrackets first token is not '['\n");
Exit(10);
}
ti=ti->next;

br=g_new0(bracket_item_t, 1)((bracket_item_t *) g_malloc0_n ((1), sizeof (bracket_item_t)
));
if (!br) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
*bracket=br;
br->flags=0;
br->case_name=NULL((void*)0);
br->pointer_list=NULL((void*)0);

while(ti){
if( !g_strcmp0(ti->str, "{")
  ||!g_strcmp0(ti->str, "}")){
	FPRINTF(stderrstderr, "ERROR: parsebrackets '{' '}' inside bracket item\n");
	Exit(10);
}

if(!g_strcmp0(ti->str, "[")){
	FPRINTF(stderrstderr, "ERROR: parsebrackets '[' inside bracket item\n");
	Exit(10);
}

/* finished */
if(!g_strcmp0(ti->str, "]")){
	/* check for [ ... ] [ ...] */
	ti=ti->next;

	if(!g_strcmp0(ti->str, "[")){
		ti=ti->next;
		continue;
	}
	return ti;
}

/* just ignore all ',' */
if(!g_strcmp0(ti->str, ",")){
	ti=ti->next;
	continue;
}

/* case '(' tag ')' */
if(!g_strcmp0(ti->str, "case")){
	br->flags|=BI_CASE0x00000001;
	ti=ti->next;

	if(g_strcmp0(ti->str, "(")){
		FPRINTF(stderrstderr, "ERROR: parsebrackets case not followed by '('\n");
		Exit(10);
	}
	ti=ti->next;

	/* name */
	br->case_name=ti->str;
	ti=ti->next;

	if(g_strcmp0(ti->str, ")")){
		FPRINTF(stderrstderr, "ERROR: parsebrackets case does not end with ')'\n");
		Exit(10);
	}
	ti=ti->next;
	continue;
}

/* default */
if(!g_strcmp0(ti->str, "default")){
	br->flags|=BI_CASE0x00000001;
	br->flags|=BI_CASE_DEFAULT0x00000002;
	br->case_name="default";
	ti=ti->next;
	continue;
}


/* in */
if(!g_strcmp0(ti->str, "in")){
	br->flags|=BI_IN0x00000004;
	ti=ti->next;
	continue;
}

/* out */
if(!g_strcmp0(ti->str, "out")){
	br->flags|=BI_OUT0x00000008;
	ti=ti->next;
	continue;
}

/* public : we don't care about this one */
if(!g_strcmp0(ti->str, "public")){
	ti=ti->next;
	continue;
}

/* gensize : we don't care about this one */
if(!g_strcmp0(ti->str, "gensize")){
	ti=ti->next;
	continue;
}

/* switch_is */
if(!g_strcmp0(ti->str, "switch_is")){
	FPRINTF(stderrstderr, "WARNING: parsebrackets can not handle switch_is properly yet  so we can not verify the tag size\n");
	while(ti){
		if(!g_strcmp0(ti->str, ")")){
			ti=ti->next;
			break;
		}
		ti=ti->next;
	}
	continue;
}

/* switch_is */
if(!g_strcmp0(ti->str, "subcontext")){
	while(ti){
		if(!g_strcmp0(ti->str, ")")){
			ti=ti->next;
			break;
		}
		ti=ti->next;
	}
	continue;
}

/* value   we don't care about this one so just skip it */
if(!g_strcmp0(ti->str, "value")){
	int level;
	ti=ti->next;
	if( g_strcmp0(ti->str, "(") ){
		FPRINTF(stderrstderr, "WARNING: parsebrackets value was not followed by '('\n");
		Exit(10);
	}
	level=0;
	while(ti){
		if(!g_strcmp0(ti->str, "(")){
			ti=ti->next;
			level++;
			continue;
		}
		if(!g_strcmp0(ti->str, ")")){
			ti=ti->next;
			level--;
			if(level){
				continue;
			}
			break;
		}
		ti=ti->next;
	}
	continue;
}

/* range   we don't care about this one so just skip it */
if(!g_strcmp0(ti->str, "range")){
	int level;
	ti=ti->next;
	if( g_strcmp0(ti->str, "(") ){
		FPRINTF(stderrstderr, "WARNING: parsebrackets range was not followed by '('\n");
		Exit(10);
	}
	level=0;
	while(ti){
		if(!g_strcmp0(ti->str, "(")){
			ti=ti->next;
			level++;
			continue;
		}
		if(!g_strcmp0(ti->str, ")")){
			ti=ti->next;
			level--;
			if(level){
				continue;
			}
			break;
		}
		ti=ti->next;
	}
	continue;
}

/* flag   we don't care about this one so just skip it */
if(!g_strcmp0(ti->str, "flag")){
	int level;
	ti=ti->next;
	if( g_strcmp0(ti->str, "(") ){
		FPRINTF(stderrstderr, "WARNING: parsebrackets flag was not followed by '('\n");
		Exit(10);
	}
	level=0;
	while(ti){
		if(!g_strcmp0(ti->str, "(")){
			ti=ti->next;
			level++;
			continue;
		}
		if(!g_strcmp0(ti->str, ")")){
			ti=ti->next;
			level--;
			if(level){
				continue;
			}
			break;
		}
		ti=ti->next;
	}
	continue;
}

/* switch_type */
if(!g_strcmp0(ti->str, "switch_type")){
	br->flags|=BI_SWITCH_TYPE0x00000400;
	ti=ti->next;

	if(g_strcmp0(ti->str, "(")){
		FPRINTF(stderrstderr, "WARNING: parsebrackets switch_type was not followed by '('\n");
		Exit(10);
	}
	ti=ti->next;

	type_item=find_type(ti->str);
	if(!type_item){
		FPRINTF(stderrstderr, "ERROR : parsebrackets switch_type unknown type %s\n",ti->str);
		Exit(10);
	}
	br->union_tag_size=type_item->alignment;
	ti=ti->next;

	if(g_strcmp0(ti->str, ")")){
		FPRINTF(stderrstderr, "WARNING: parsebrackets switch_type did not end with ')'\n");
		Exit(10);
	}
	ti=ti->next;

	continue;
}

/* size_is */
if(!g_strcmp0(ti->str, "size_is")){
	br->flags|=BI_SIZE_IS0x00000010;
	ti=ti->next;
	continue;
}

/* length_is */
if(!g_strcmp0(ti->str, "length_is")){
	br->flags|=BI_LENGTH_IS0x00000020;
	ti=ti->next;
	continue;
}

/* bitmap8bit */
if(!g_strcmp0(ti->str, "bitmap8bit")){
	br->flags|=BI_BITMAP80x00000100;
	ti=ti->next;
	continue;
}

/* bitmap32bit */
if(!g_strcmp0(ti->str, "bitmap32bit")){
	br->flags|=BI_BITMAP320x00000200;
	ti=ti->next;
	continue;
}

/* ref, unique or ptr */
if(!g_strcmp0(ti->str, "ref")
|| !g_strcmp0(ti->str, "unique")
|| !g_strcmp0(ti->str, "ptr")){
	pointer_item_t *newpi;

	br->flags|=BI_POINTER0x00000040;
	newpi=g_new0(pointer_item_t, 1)((pointer_item_t *) g_malloc0_n ((1), sizeof (pointer_item_t)
));
	if (!newpi) {
		FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
		exit(10);
	}
	newpi->next=NULL((void*)0);
	newpi->type=ti->str;
	newpi->next=br->pointer_list;
	br->pointer_list=newpi;
	ti=ti->next;
	continue;
}
if(ti){
	FPRINTF(stderrstderr, "ERROR: parsebrackets should not be reached  unknown tag:%s\n", ti->str);
}
Exit(10);
}

return NULL((void*)0);
760}

762/* this function will register a new type learnt from the IDL file
763*/
764static type_item_t *
765register_new_type(const char *name, const char *dissectorname, const char *ft_type, const char *base_type, const char *mask, const char *valsstring, int alignment){
type_item_t *new_type;

FPRINTF(NULL((void*)0),"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);

new_type=g_new0(type_item_t, 1)((type_item_t *) g_malloc0_n ((1), sizeof (type_item_t)));
if (!new_type) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
new_type->next=type_list;
new_type->name=g_strdup(name)g_strdup_inline (name);
new_type->dissector=g_strdup(dissectorname)g_strdup_inline (dissectorname);
new_type->ft_type=g_strdup(ft_type)g_strdup_inline (ft_type);
new_type->base_type=g_strdup(base_type)g_strdup_inline (base_type);
new_type->mask=g_strdup(mask)g_strdup_inline (mask);
new_type->vals=g_strdup(valsstring)g_strdup_inline (valsstring);
new_type->alignment=alignment;
type_list=new_type;

return new_type;
786}


789/* this function will print the remaining content of the token list
790*/
791static void printtokenlist(int count)
792{
token_item_t *ti;
FPRINTF(stderrstderr, "TOKENLIST:\n");
for(ti=token_list;ti&&count;count--,ti=ti->next){
FPRINTF(stderrstderr, "Token \"%s\"\n",ti->str);
}
if(!count){
FPRINTF(stderrstderr, "	 ...\n");
}
801}


804/* this function will parse the header and pick up the fields
* we are interested in.
* the header is supposed to start at the very first token and look like
* [ <fields> ] interface <ifname> {
*
* we are interested in the fields:
*	   uuid
*	   version
*	   pointer_default
*
* this function will also g_remove the header from the token list
*/
816static void parseheader(void)
817{
char filter_name[BASE_BUFFER_SIZE256];
token_item_t *ti;
int level=0;
int major, minor;

ti=token_list;
if(!ti){
FPRINTF(stderrstderr, "ERROR: no tokens\n");
Exit(10);
}

/* first token must be '[' */
if( g_strcmp0(ti->str, "[") ){
FPRINTF(stderrstderr, "ERROR: first token is not '['\n");
Exit(10);
}

for(ti=token_list;ti;ti=ti->next){
if( !g_strcmp0(ti->str, "[")){
	level++;
	continue;
}
if( !g_strcmp0(ti->str, "]")){
	level--;
	if(!level){
		token_list=ti->next;
		break;
	}
}
if(level==1){
	if( !g_strcmp0(ti->str, "uuid")){
		uuid=ti->next->next->str;
		FPRINTF(NULL((void*)0),"UUID:%s\n",uuid);
	}
	if( !g_strcmp0(ti->str, "version")){
		version=ti->next->next->str;
		FPRINTF(NULL((void*)0),"VERSION:%s\n",version);
	}
	if( !g_strcmp0(ti->str, "pointer_default")){
		if(!g_strcmp0(ti->next->next->str, "unique")){
			pointer_default="unique";
		} else if(!g_strcmp0(ti->next->next->str, "ptr")){
			pointer_default="ptr";
		} else {
			FPRINTF(stderrstderr, "ERROR: unknown pointer type\n");
			Exit(10);
		}
		FPRINTF(NULL((void*)0),"POINTER_DEFAULT:%s\n",pointer_default);
	}
}
}
if(!token_list){
FPRINTF(stderrstderr, "ERROR: ran out of tokens inside header\n");
Exit(10);
}
/* interface */
if(g_strcmp0(token_list->str, "interface")){
FPRINTF(stderrstderr, "ERROR: interface not found\n");
Exit(10);
}
token_list=token_list->next;
if (!token_list){
FPRINTF(stderrstderr, "ERROR: ran out of tokens\n");
Exit(10);
}
/* interface name */
ifname=token_list->str;
token_list=token_list->next;
FPRINTF(NULL((void*)0),"Interface:%s\n",ifname);

/* opnum */
snprintf(hf_status, BASE_BUFFER_SIZE256, "hf_%s_opnum", ifname);
snprintf(filter_name, BASE_BUFFER_SIZE256, "%s.opnum", ifname);
register_hf_field(hf_status, "Operation", filter_name, "FT_UINT16", "BASE_DEC", "NULL", "0", "");

/* status */
snprintf(hf_status, BASE_BUFFER_SIZE256, "hf_%s_rc", ifname);
snprintf(filter_name, BASE_BUFFER_SIZE256, "%s.rc", ifname);
register_hf_field(hf_status, "Return code", filter_name, "FT_UINT32", "BASE_HEX|BASE_EXT_STRING", "&NT_errors_ext", "0", "");

FPRINTF(eth_ett, "static int ett_%s;\n", ifname);
FPRINTF(eth_ettarr, "		 &ett_%s,\n", ifname);

/* the body must start with { */
if(g_strcmp0(token_list->str, "{")){
FPRINTF(stderrstderr, "ERROR: body does not start with '{'\n");
Exit(10);
}

/* skip the initial '{' */
token_list=token_list->next;

if(!uuid){
FPRINTF(stderrstderr, "ERROR: no uuid found\n");
Exit(10);
}
FPRINTF(eth_code,"static e_guid_t uuid_dcerpc_%s = {\n", ifname);
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]);
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]);
FPRINTF(eth_code,"};\n");
FPRINTF(eth_code,"\n");

sscanf(version, "%d.%d", &major, &minor);
FPRINTF(eth_code,"static uint16_t ver_%s = %d;\n", ifname, major);
FPRINTF(eth_code,"\n");

FPRINTF(eth_handoff, "	  dcerpc_init_uuid(proto_%s, ett_%s,\n", ifname, ifname);
FPRINTF(eth_handoff, "		  &uuid_dcerpc_%s, ver_%s,\n", ifname, ifname);
FPRINTF(eth_handoff, "		  function_dissectors, hf_%s_opnum);\n", ifname);
927}



931/* this helper function is called by the tokenizer and will just append the
 current token to the linked list
933*/
934static void pushtoken(char *token)
935{
token_item_t *new_token_item;
new_token_item=g_new0(token_item_t, 1)((token_item_t *) g_malloc0_n ((1), sizeof (token_item_t)));
if (!new_token_item) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
new_token_item->next=NULL((void*)0);
new_token_item->str=token;
if(!token_list){
token_list=new_token_item;
} else {
last_token_item->next=new_token_item;
}
last_token_item=new_token_item;
950}

952/* this function reads the idl file and translates it into tokens.
 the tokens are stored in a linked list  token_list of type token_item_t
954*/
955static void tokenize(FILE *fh)
956{
int ch;
int fullinecomment=0;
int normalcomment=0;
int insidequote=0;
char qs[4 * BASE_BUFFER_SIZE256];
int qspos=0;
int insidetoken=0;
char token[4 * BASE_BUFFER_SIZE256];
int tokenpos=0;

while(!feof(fh)){
6
←
Loop condition is true.  Entering loop body→
9
←
 Execution continues on line 967→
10
←
Loop condition is true.  Entering loop body→
13
←
 Execution continues on line 967→
14
←
Loop condition is true.  Entering loop body→
ch=fgetc(fh);
11
←
Assuming this stream operation fails→
15
←
File position of the stream might be 'indeterminate' after a failed operation. Can cause undefined behavior

/* full line comment */
if(fullinecomment6.1
'fullinecomment' is 0
1
'fullinecomment' is 1
){
	if( (ch=='\n')||(ch=='\r') ){
12
←
Taking false branch→
		fullinecomment=0;
		linepos=0;
	}
	continue;
}
if( (ch=='#')&&(linepos7.1
'linepos' is equal to 0
==0) ){
7
←
Assuming the condition is true→
8
←
Taking true branch→
	fullinecomment=1;
	continue;
}

/* normal comment */
if(normalcomment==0){
	if(ch=='/'){
		int nextch;
		nextch=fgetc(fh);
		if(nextch=='*'){
			normalcomment=1;
			continue;
		}
		ungetc(nextch, fh);
	}
} else {
	if(ch=='*'){
		int nextch;
		nextch=fgetc(fh);
		if(nextch=='/'){
			normalcomment=0;
			continue;
		}
		ungetc(nextch, fh);
	}
	continue;
}

/* quoted string */
if(insidequote){
	if(ch=='"'){
		insidequote=0;
		qs[qspos++]='"';
		qs[qspos]=0;
		pushtoken(g_strdup(qs)g_strdup_inline (qs));
		continue;
	} else {
		qs[qspos++]=(char)ch;
		continue;
	}
} else {
	if(ch=='"'){
		insidequote=1;
		qs[0]='"';
		qspos=1;
		continue;
	}
}


switch(ch){
case '\n':
case '\r':
	if(insidetoken){
		insidetoken=0;
		token[tokenpos]=0;
		pushtoken(g_strdup(token)g_strdup_inline (token));
	}
	line[linepos]=0;

	linepos=0;
	lineno++;
	break;
case '\t':
case ' ':
	if(insidetoken){
		insidetoken=0;
		token[tokenpos]=0;
		pushtoken(g_strdup(token)g_strdup_inline (token));
	}
	break;
case '[':
case ']':
case '(':
case ')':
case ',':
case ';':
case '*':
case '=':
	if(insidetoken){
		insidetoken=0;
		token[tokenpos]=0;
		pushtoken(g_strdup(token)g_strdup_inline (token));
	}
	token[0]=(char)ch;
	token[1]=0;
	pushtoken(g_strdup(token)g_strdup_inline (token));
	break;
default:
	if(!insidetoken){
		tokenpos=0;
	}
	insidetoken=1;
	token[tokenpos++]=(char)ch;
	line[linepos++]=(char)ch;
	break;
}

}
1078}


1081static type_item_t *
1082find_type(char *name)
1083{
type_item_t *tmptype;
for(tmptype=type_list;tmptype;tmptype=tmptype->next){
if(!g_strcmp0(tmptype->name, name)){
	break;
}
}
/* autogenerate built in types */
if(!tmptype){
char dissectorname[DISSECTORNAME_MAXLEN256];
if(!g_strcmp0(name,"uint16")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("uint16", dissectorname, "FT_UINT16", "BASE_DEC", "0", "NULL", 2);
} else if(!g_strcmp0(name,"int16")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("int16", dissectorname, "FT_INT16", "BASE_DEC", "0", "NULL", 2);
} else if(!g_strcmp0(name,"uint32")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("uint32", dissectorname, "FT_UINT32", "BASE_DEC", "0", "NULL", 4);
} else if( (!g_strcmp0(name,"int32"))
	|| (!g_strcmp0(name,"long")) ){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	if (!g_strcmp0(name,"int32"))
		tmptype=register_new_type("int32", dissectorname, "FT_INT32", "BASE_DEC", "0", "NULL", 4);
	else
		tmptype=register_new_type("long", dissectorname, "FT_INT32", "BASE_DEC", "0", "NULL", 4);
} else if( (!g_strcmp0(name,"uint8")) ){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("uint8", dissectorname, "FT_UINT8", "BASE_DEC", "0", "NULL", 1);
} else if( (!g_strcmp0(name,"int8"))
	|| (!g_strcmp0(name, "char")) ){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	if (!g_strcmp0(name,"int8"))
		tmptype=register_new_type("int8", dissectorname, "FT_INT8", "BASE_DEC", "0", "NULL", 1);
	else
		tmptype=register_new_type("char", dissectorname, "FT_INT8", "BASE_DEC", "0", "NULL", 1);
} else if(!g_strcmp0(name,"bool8")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("bool8", dissectorname, "FT_INT8", "BASE_DEC", "0", "NULL", 1);
} else if(!g_strcmp0(name,"unistr")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_cvstring(tvb, offset, pinfo, tree, di, drep, 2, hf_index, false, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("unistr", dissectorname, "FT_STRING", "BASE_NONE", "0", "NULL", 4);
} else if(!g_strcmp0(name,"ascstr")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_cvstring(tvb, offset, pinfo, tree, di, drep, 1, hf_index, false, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("ascstr", dissectorname, "FT_STRING", "BASE_NONE", "0", "NULL", 4);
} else if(!g_strcmp0(name,"GUID")
	||!g_strcmp0(name,"uuid_t")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uuid_t(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type(name, dissectorname, "FT_GUID", "BASE_NONE", "0", "NULL", 4);
} else if(!g_strcmp0(name,"policy_handle")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static e_ctx_hnd policy_hnd;\n");
	FPRINTF(eth_code, "static proto_item *hnd_item;\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset = dissect_nt_policy_hnd(tvb, offset, pinfo, tree, di, drep,\n");
	FPRINTF(eth_code, " 				  hf_index, &policy_hnd, &hnd_item,\n");
	FPRINTF(eth_code, " 				  param);\n");

	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("policy_handle", dissectorname, "FT_BYTES", "BASE_NONE", "0", "NULL", 4);
} else if(!g_strcmp0(name,"NTTIME")){
	/* 8 bytes, aligned to 4 bytes */
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, di, drep, hf_index);\n");

	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("NTTIME", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
} else if(!g_strcmp0(name,"NTTIME_hyper")){
	/* 8 bytes, aligned to 8 bytes */
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    ALIGN_TO_8_BYTES;\n");
	FPRINTF(eth_code, "    offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, di, drep, hf_index);\n");

	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("NTTIME_hyper", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
} else if(!g_strcmp0(name,"NTTIME_1sec")){
	/* 8 bytes, aligned to 8 bytes */
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    ALIGN_TO_8_BYTES;\n");
	FPRINTF(eth_code, "    offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, di, drep, hf_index);\n");

	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("NTTIME_1sec", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
} else if(!g_strcmp0(name,"udlong")){
	/* 8 bytes, aligned to 4 bytes */
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_duint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("udlong", dissectorname, "FT_UINT64", "BASE_DEC", "0", "NULL", 4);
} else if(!g_strcmp0(name,"dlong")){
	/* 8 bytes, aligned to 4 bytes */
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_duint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("dlong", dissectorname, "FT_INT64", "BASE_DEC", "0", "NULL", 4);
} else if(!g_strcmp0(name,"uint64")){
	/* 8 bytes, aligned to 8 bytes */
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    \n");
	FPRINTF(eth_code, "    ALIGN_TO_8_BYTES;\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint64(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("uint64", dissectorname, "FT_UINT64", "BASE_DEC", "0", "NULL", 8);
} else if(!g_strcmp0(name,"time_t")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_time_t(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("time_t", dissectorname, "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", "0", "NULL", 4);
} else if(!g_strcmp0(name,"SID")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    offset=dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, di, drep, param, hf_index);\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("SID", dissectorname, "FT_STRING", "BASE_NONE", "0", "NULL", 4);
} else if(!g_strcmp0(name,"WERROR")){
	snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, name);
	FPRINTF(NULL((void*)0),"\nAutogenerating built-in type:%s\n------------\n",name);
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "static int\n");
	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);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    \n");
	FPRINTF(eth_code, "    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");
	tmptype=register_new_type("WERROR", dissectorname, "FT_UINT32", "BASE_DEC|BASE_EXT_STRING", "0", "&WERR_errors_ext", 4);
}
}

return tmptype;
1377}


1380/* this function will skip past an entire declare ... ; statement */
1381static void skipdeclare(void)
1382{
token_item_t *ti;

/* first must be the keyword const */
ti=token_list;
if(strncmp(ti->str, "declare", 7)){
FPRINTF(stderrstderr, "ERROR: skipdeclare  first token is not 'declare'\n");
Exit(10);
}
while(ti->str[0] != ';'){
ti=ti->next;
}
ti=ti->next;

token_list=ti;
1397}

1399/* this function will parse a
  const
 and generate the appropriate code
 const must be followed by a suitable keyword [uint16|uint32|...]
 the const will later be g_removed from the token list
 the function assumes that the const is the first object in the token_list
1405*/
1406static void parseconst(void)
1407{
token_item_t *ti;
char *name, *value;

/* first must be the keyword const */
ti=token_list;
if(strncmp(ti->str, "const", 5)){
FPRINTF(stderrstderr, "ERROR: const  first token is not 'const'\n");
Exit(10);
}
ti=ti->next;

/* just skip second token */
ti=ti->next;

/* third is a variable and not a type */
if(find_type(ti->str)){
FPRINTF(stderrstderr, "ERROR: const, not a variable name:%s\n", ti->str);
Exit(10);
}
name=ti->str;
ti=ti->next;

/* fourth is '=' */
if(ti->str[0] != '='){
FPRINTF(stderrstderr, "ERROR: const  fourth token is not '='\n");
Exit(10);
}
ti=ti->next;

/* fifth is the value */
value=ti->str;
ti=ti->next;

/* sixth is ';' */
if(ti->str[0] != ';'){
FPRINTF(stderrstderr, "ERROR: const  sixth token is not ';'\n");
Exit(10);
}
ti=ti->next;

FPRINTF(NULL((void*)0),"\nCONST:%s\n-------\n",name);

FPRINTF(eth_hdr, "#define %s		%s\n", name, value);

FPRINTF(NULL((void*)0),"\n----------\nEND CONST:%s\n",name);

token_list=ti;
1455}

1457/* this function will parse a
  typedef struct {
 construct and generate the appropriate code.
 the typedef will be g_removed from the token_list once it has been processed
 the function assumes that the typedef is the first object in the token_list
 the function will be called twice, once with pass=0 and once with pass=1
 which controls whether subdissectors are to be generated or whether the
 struct dissector itself is to be generated
1465*/
1466static void parsetypedefstruct(int pass)
1467{
token_item_t *ti, *tmpti;
char *struct_name;
char dissectorname[DISSECTORNAME_MAXLEN256];
char tmpstr[BASE_BUFFER_SIZE256], *ptmpstr;
int level, num_pointers;
static int alignment;
type_item_t *type_item;
char hf_index[BASE_BUFFER_SIZE256];
bracket_item_t *bi=NULL((void*)0);
pointer_item_t *pi;
const char *pointer_type;
char *field_name;
uint32_t fixed_array_size;
int is_array_of_pointers;
int empty_struct = 0;

ti=token_list;
if(g_strcmp0(ti->str, "typedef")){
FPRINTF(stderrstderr, "ERROR: typedefstruct  first token is not 'typedef'\n");
Exit(10);
}
ti=ti->next;

if(!g_strcmp0(ti->str, "[")){
ti=parsebrackets(ti, &bi);
}
/* check that we know how to handle the bracket thing */
if(bi){
if(bi->flags){
	FPRINTF(stderrstderr, "ERROR: typedefstruct unknown bracket flags encountered : 0x%08x\n",bi->flags);
	Exit(10);
}
}

if(g_strcmp0(ti->str, "struct")){
FPRINTF(stderrstderr, "ERROR: typedefstruct  second token is not 'struct'\n");
Exit(10);
}
ti=ti->next;

if(g_strcmp0(ti->str, "{")){
FPRINTF(stderrstderr, "ERROR: typedefstruct  third token is not '{'\n");
Exit(10);
}
ti=ti->next;

/* Check if the struct is empty (search if there is no end bracket) */
if(g_strcmp0(ti->str, "}") == 0){
empty_struct = 1;
}

/* search forward until the '}' so we can find the name of the struct */
for(tmpti=ti,level=0;tmpti;tmpti=tmpti->next){
if(!g_strcmp0(tmpti->str, "{")){
	level++;
	continue;
}
if(!g_strcmp0(tmpti->str, "}")){
	if(!level){
		break;
	}
	level--;
	continue;
}
}
if(!tmpti || !tmpti->next){
FPRINTF(stderrstderr, "ERROR: typedefstruct  missing matching '}'\n");
Exit(10);
}

struct_name=tmpti->next->str;
snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, struct_name);

FPRINTF(NULL((void*)0),"\nSTRUCT:%s pass:%d\n-------\n",struct_name,pass);

if(!check_if_to_emit(dissectorname)){
FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct dissector.\n");
ti=tmpti;
goto typedef_struct_finished;
}

/* this is pass 0  so reset alignment to zero and update as items are
  processed. we need alignment when pass 1 is run.
  set alignment initially to 1 so we don't fail for empty structs
*/
if(pass==0){
alignment=1;
}
/* pass 1  generate header for the struct dissector */
if(pass==1){
FPRINTF(eth_ett, "static int ett_%s_%s;\n", ifname, struct_name);
FPRINTF(eth_ettarr, "		 &ett_%s_%s,\n", ifname, struct_name);
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);
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "int\n");
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);
FPRINTF(eth_code, "{\n");
FPRINTF(eth_code, "    proto_item *item=NULL;\n");
if(!empty_struct){
	FPRINTF(eth_code, "    proto_tree *tree=NULL;\n");
}
FPRINTF(eth_code, "    int old_offset;\n");
FPRINTF(eth_code, "\n");
switch(alignment){
case 1:
	break;
case 2:
	FPRINTF(eth_code, "    ALIGN_TO_2_BYTES;\n");
	FPRINTF(eth_code, "\n");
	break;
case 4:
	FPRINTF(eth_code, "    ALIGN_TO_4_BYTES;\n");
	FPRINTF(eth_code, "\n");
	break;
case 8:
	FPRINTF(eth_code, "    ALIGN_TO_8_BYTES;\n");
	FPRINTF(eth_code, "\n");
	break;
default:
	FPRINTF(stderrstderr, "ERROR: can not handle alignment:%d\n",alignment);
	Exit(10);
}
FPRINTF(eth_code, "    old_offset=offset;\n");
FPRINTF(eth_code, "    if(parent_tree){\n");
FPRINTF(eth_code, " 	   item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, ENC_NA);\n");
if(!empty_struct){
	FPRINTF(eth_code, " 	   tree=proto_item_add_subtree(item, ett_%s_%s);\n", ifname, struct_name);
}
FPRINTF(eth_code, "    }\n");
FPRINTF(eth_code, "\n");
}

/* scan the struct and create all subdissectors */
level=0;
while(ti){
if(!g_strcmp0(ti->str, "{")){
	level++;
	ti=ti->next;
	continue;
}
if(!g_strcmp0(ti->str, "}")){
	if(!level){
		break;
	}
	level--;
	ti=ti->next;
	continue;
}
if(!g_strcmp0(ti->str, "[")){
	ti=parsebrackets(ti, &bi);
	continue;
}

/* check that we know how to handle the bracket thing */
if(bi){
	if(bi->flags&(~(BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020|BI_POINTER0x00000040))){
		FPRINTF(stderrstderr, "ERROR: typedefstruct unknown bracket flags encountered : 0x%08x\n",bi->flags);
		Exit(10);
	}
}

/* handle the type, verify that we KNOW this type */
type_item=find_type(ti->str);
if(!type_item){
	FPRINTF(stderrstderr, "ERROR : typedefstruct unknown type %s\n",ti->str);
	Exit(10);
}
ti=ti->next;
/* count the levels of pointers */
for(num_pointers=0;!g_strcmp0(ti->str, "*");ti=ti->next){
	num_pointers++;
	/* pointers are aligned at 4 byte boundaries */
	if(alignment<4){
		alignment=4;
	}
}
/* now that we know how many real pointers there were we must
   prepend default pointers to the list so it has the right
   length.
*/
pi=prepend_pointer_list(bi?bi->pointer_list:NULL((void*)0), num_pointers);
/* keep track of alignment */
if(alignment<type_item->alignment){
	alignment=type_item->alignment;
}

field_name=ti->str;
ti=ti->next;

/* see if it is a fixed array */
fixed_array_size=0;
is_array_of_pointers=0;
if(!g_strcmp0(ti->str, "[")){
	/* this might be a fixed array */
	ti=ti->next;

	if(!g_strcmp0("]", ti->str)){
		/* this is just a normal [] array */
		fixed_array_size=0;
	} else if(!g_strcmp0("*", ti->str)){
		pi=prepend_pointer_list(pi, num_pointers+1);
		fixed_array_size=0;
		is_array_of_pointers=1;
		ti=ti->next;
	} else if (!ws_strtou32(ti->str, NULL((void*)0), &fixed_array_size)) {
		FPRINTF(stderrstderr, "ERROR: invalid integer: %s\n", ti->str);
		Exit(10);
	} else {
		ti=ti->next;
	}

	if(g_strcmp0(ti->str, "]")){
		FPRINTF(stderrstderr, "ERROR: typedefstruct  fixed array does not end with ']' it ended with %s\n",ti->str);
		Exit(10);
	}
	ti=ti->next;
}

snprintf(hf_index, BASE_BUFFER_SIZE256, "hf_%s_%s_%s", ifname, struct_name, field_name);
/* pass 0  generate subdissectors */
if(pass==0){
	char filter_name[BASE_BUFFER_SIZE256];
	const char *hf;

	snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_dissect_%s_%s", ifname, struct_name, field_name);
	ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	if(check_if_to_emit(tmpstr)){
	  snprintf(filter_name, BASE_BUFFER_SIZE256, "%s.%s.%s", ifname, struct_name, field_name);
	  hf=register_hf_field(hf_index, field_name, filter_name, type_item->ft_type, type_item->base_type, type_item->vals, type_item->mask, "");
	  FPRINTF(eth_code, "static int\n");
	  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", ptmpstr);
	  FPRINTF(eth_code, "{\n");
	  FPRINTF(eth_code, "	 uint32_t param=%s;\n",find_dissector_param_value(ptmpstr));
	  FPRINTF(eth_code, "	 offset=%s(tvb, offset, pinfo, tree, di, drep, %s, param);\n", type_item->dissector, hf);
	  FPRINTF(eth_code, "	 return offset;\n");
	  FPRINTF(eth_code, "}\n");
	  FPRINTF(eth_code, "\n");
	} else {
	  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
	}

	if(is_array_of_pointers){
		pointer_type=pi->type;
		pi=pi->next;
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", pointer_type, ptmpstr);
		if(check_if_to_emit(tmpstr)){
		  FPRINTF(eth_code, "static int\n");
		  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		  FPRINTF(eth_code, "{\n");
		  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);
		  FPRINTF(eth_code, "	 return offset;\n");
		  FPRINTF(eth_code, "}\n");
		  FPRINTF(eth_code, "\n");
		} else {
		  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
		}

		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	} else if(fixed_array_size){
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "fixedarray_%s", ptmpstr);
		if(check_if_to_emit(tmpstr)){
		  FPRINTF(eth_code, "static int\n");
		  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		  FPRINTF(eth_code, "{\n");
		  FPRINTF(eth_code, "	 int count=%d;\n",fixed_array_size);
		  FPRINTF(eth_code, "	 while(count--){\n");
		  FPRINTF(eth_code, "		 offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
		  FPRINTF(eth_code, "	 }\n");
		  FPRINTF(eth_code, "\n");
		  FPRINTF(eth_code, "	 return offset;\n");
		  FPRINTF(eth_code, "}\n");
		  FPRINTF(eth_code, "\n");
		} else {
		  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
		}
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	}

	/* handle switch_is */
	if(bi){
	  switch(bi->flags&(BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020)){
	  case 0:
		break;
	  case BI_SIZE_IS0x00000010:
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucarray_%s", ptmpstr);
		if(check_if_to_emit(tmpstr)){
		  FPRINTF(eth_code, "static int\n");
		  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		  FPRINTF(eth_code, "{\n");
		  FPRINTF(eth_code, "	 offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
		  FPRINTF(eth_code, "	 return offset;\n");
		  FPRINTF(eth_code, "}\n");
		  FPRINTF(eth_code, "\n");
		} else {
		  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
		}
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
		break;
	  case BI_LENGTH_IS0x00000020:
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "uvarray_%s", ptmpstr);
		if(check_if_to_emit(tmpstr)){
		  FPRINTF(eth_code, "static int\n");
		  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		  FPRINTF(eth_code, "{\n");
		  FPRINTF(eth_code, "	 offset=dissect_ndr_uvarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
		  FPRINTF(eth_code, "	 return offset;\n");
		  FPRINTF(eth_code, "}\n");
		  FPRINTF(eth_code, "\n");
		} else {
		  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
		}
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
		break;
	  case BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020:
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucvarray_%s", ptmpstr);
		if(check_if_to_emit(tmpstr)){
		  FPRINTF(eth_code, "static int\n");
		  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		  FPRINTF(eth_code, "{\n");
		  FPRINTF(eth_code, "	 offset=dissect_ndr_ucvarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
		  FPRINTF(eth_code, "	 return offset;\n");
		  FPRINTF(eth_code, "}\n");
		  FPRINTF(eth_code, "\n");
		} else {
		  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
		}
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
		break;
	  default:
		FPRINTF(stderrstderr, "ERROR: typedefstruct can not handle this combination of sizeis/lengthis\n");
		Exit(10);
	  }
	}

	/* handle pointers */
	while(num_pointers--){
		pointer_type=pi->type;
		pi=pi->next;
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", pointer_type, ptmpstr);
		if(check_if_to_emit(tmpstr)){
		  FPRINTF(eth_code, "static int\n");
		  FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		  FPRINTF(eth_code, "{\n");
		  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);
		  FPRINTF(eth_code, "	 return offset;\n");
		  FPRINTF(eth_code, "}\n");
		  FPRINTF(eth_code, "\n");
		} else {
		  FPRINTF(NULL((void*)0),"NOEMIT Skipping this struct item :%s\n",tmpstr);
		}

		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	}
}

if(pass==1){
	snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_dissect_%s_%s", ifname, struct_name, field_name);
	ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	/* handle fixedsizearrays */
	if(is_array_of_pointers){
		pointer_type=pi->type;
		pi=pi->next;
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", pointer_type, ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	} else if(fixed_array_size){
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "fixedarray_%s", ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	}

	/* handle switch_is */
	if(bi){
	  switch(bi->flags&(BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020)){
	  case 0:
		break;
	  case BI_SIZE_IS0x00000010:
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucarray_%s", ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
		break;
	  case BI_LENGTH_IS0x00000020:
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "uvarray_%s", ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
		break;
	  case BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020:
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucvarray_%s", ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
		break;
	  default:
		FPRINTF(stderrstderr, "ERROR: typedefstruct can not handle this combination of sizeis/lengthis\n");
		Exit(10);
	  }
	}

	/* handle pointers */
	while(num_pointers--){
		pointer_type=pi->type;
		pi=pi->next;
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", pointer_type, ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	}

	FPRINTF(eth_code, "    offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
	FPRINTF(eth_code, "\n");
}

if(g_strcmp0(ti->str,";")){
	FPRINTF(stderrstderr, "ERROR: field does not en with ';'\n");
	Exit(10);
}
ti=ti->next;
bi=NULL((void*)0); /* clear bi before we start on the next field */
}

if(pass==1){
FPRINTF(eth_code, "    proto_item_set_len(item, offset-old_offset);\n");
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "    return offset;\n");
FPRINTF(eth_code, "}\n");
register_new_type(struct_name, dissectorname, "FT_NONE", "BASE_NONE", "0", "NULL", alignment);
}


1891typedef_struct_finished:
FPRINTF(NULL((void*)0),"\nEND STRUCT:%s pass:%d\n-------\n",struct_name,pass);

/* only advance token_list for pass==1
  ti now points to the '}' token
*/
if(pass==1){
if(!ti || g_strcmp0(ti->str,"}")){
	FPRINTF(stderrstderr, "ERROR: struct does not end with '}'\n");
	Exit(10);
}
ti=ti->next;

/* just skip the name */
ti=ti->next;

if(!ti || g_strcmp0(ti->str,";")){
	FPRINTF(stderrstderr, "ERROR: struct does not end with ';'\n");
	Exit(10);
}
ti=ti->next;

token_list=ti;
}
1915}

1917/* this function will parse a
  typedef bitmap {
 construct and generate the appropriate code.
 the typedef will be g_removed from the token_list once it has been processed
 the function assumes that the typedef is the first object in the token_list
 the function will be called twice, once with pass=0 and once with pass=1
 which controls whether subdissectors are to be generated or whether the
 bitmap dissector itself is to be generated

 bitmaps are by default 32 bits
1927*/
1928static void parsetypedefbitmap(int pass)
1929{
token_item_t *ti, *tmpti;
char *bitmap_name;
char dissectorname[BASE_BUFFER_SIZE256], hf_bitname[BASE_BUFFER_SIZE256];
int alignment;
unsigned int val;
char *name, *value;
bracket_item_t *bi=NULL((void*)0);

ti=token_list;
if(g_strcmp0(ti->str, "typedef")){
FPRINTF(stderrstderr, "ERROR: typedefbitmap  first token is not 'typedef'\n");
Exit(10);
}
ti=ti->next;

alignment=4;  /* default size is 32 bits */

if(!g_strcmp0(ti->str, "[")){
ti=parsebrackets(ti, &bi);
}
/* check that we know how to handle the bracket thing */
if(bi){
if(bi->flags&(~(BI_BITMAP320x00000200|BI_BITMAP80x00000100))){
	FPRINTF(stderrstderr, "ERROR: typedefbitmap unknown bracket flags encountered : 0x%08x\n",bi->flags);
	Exit(10);
}
if(bi->flags&BI_BITMAP320x00000200){
	alignment=4;
}
if(bi->flags&BI_BITMAP80x00000100){
	alignment=1;
}
}


if(g_strcmp0(ti->str, "bitmap")){
FPRINTF(stderrstderr, "ERROR: typedefbitmap  second token is not 'bitmap'\n");
Exit(10);
}
ti=ti->next;

if(g_strcmp0(ti->str, "{")){
FPRINTF(stderrstderr, "ERROR: typedefbitmap  third token is not '{'\n");
Exit(10);
}
ti=ti->next;

/* search forward until the '}' so we can find the name of the bitmap */
for(tmpti=ti;tmpti;tmpti=tmpti->next){
if(!g_strcmp0(tmpti->str, "{")){
	FPRINTF(stderrstderr, "ERROR: typedefbitmap '{' encountered inside bitmap\n");
	Exit(10);
}
if(!g_strcmp0(tmpti->str, "}")){
	break;
}
}
if (!tmpti || !tmpti->next){
FPRINTF(stderrstderr, "ERROR: typedefbitmap missing matching '}'\n");
Exit(10);
}
bitmap_name=tmpti->next->str;
snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, bitmap_name);

FPRINTF(NULL((void*)0),"\nBITMAP:%s pass:%d\n-------\n",bitmap_name,pass);

/* pass 1  generate header for the struct dissector */
if(pass==1){
FPRINTF(eth_ett, "static int ett_%s_%s;\n", ifname, bitmap_name);
FPRINTF(eth_ettarr, "		 &ett_%s_%s,\n", ifname, bitmap_name);
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);
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "int\n");
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);
FPRINTF(eth_code, "{\n");
FPRINTF(eth_code, "    proto_item *item=NULL;\n");
FPRINTF(eth_code, "    proto_tree *tree=NULL;\n");
switch(alignment){
case 1:
	FPRINTF(eth_code, "    uint8_t flags;\n");
	FPRINTF(eth_code, "\n");
	break;
case 4:
	FPRINTF(eth_code, "    uint32_t flags;\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    ALIGN_TO_4_BYTES;\n");
	break;
default:
	FPRINTF(stderrstderr, "ERROR: typedefbitmap can not handle alignment:%d\n",alignment);
	Exit(10);
}
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "    if(parent_tree){\n");
FPRINTF(eth_code, " 	   item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, %d, ENC_LITTLE_ENDIAN);\n", alignment);
FPRINTF(eth_code, " 	   tree=proto_item_add_subtree(item, ett_%s_%s);\n", ifname, bitmap_name);
FPRINTF(eth_code, "    }\n");
FPRINTF(eth_code, "\n");
switch(alignment){
case 1:
	FPRINTF(eth_code, "    offset=dissect_ndr_uint8(tvb, offset, pinfo, NULL, di, drep, -1, &flags);\n");
	FPRINTF(eth_code, "\n");
	break;
case 4:
	FPRINTF(eth_code, "    offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &flags);\n");
	FPRINTF(eth_code, "\n");
	break;
default:
	FPRINTF(stderrstderr, "ERROR: typedefbitmap can not handle alignment:%d\n",alignment);
	Exit(10);
}
FPRINTF(eth_code, "\n");
}

/* scan the struct and create call for all bits */
while(ti){
if(!g_strcmp0(ti->str, "}")){
	break;
}
if(!g_strcmp0(ti->str, "[")){
	FPRINTF(stderrstderr, "ERROR: typedefbitmap can not handle '[' yet\n");
	Exit(10);
}

name=ti->str;
ti=ti->next;
snprintf(hf_bitname, BASE_BUFFER_SIZE256, "hf_%s_%s_%s", ifname, bitmap_name, name);

if(g_strcmp0(ti->str, "=")){
	FPRINTF(stderrstderr, "ERROR: typedefbitmap i expected a '=' here\n");
	Exit(10);
}
ti=ti->next;

value=ti->str;
ti=ti->next;
val=0;
if(!strncmp(value, "0x", 2)){
	sscanf(value, "0x%x", &val);
} else {
	FPRINTF(stderrstderr, "ERROR: typedefbitmap can only handle hexadecimal constants\n");
	Exit(10);
}

if( val&(val-1) ){
	FPRINTF(stderrstderr, "ERROR: typedefbitmap can only handle single bit fields\n");
	Exit(10);
}

if(pass==0){
	char filter_name[BASE_BUFFER_SIZE256], base_name[BASE_BUFFER_SIZE256], tfs_name[BASE_BUFFER_SIZE256];

	snprintf(filter_name, BASE_BUFFER_SIZE256, "%s.%s.%s", ifname, bitmap_name, name);
	snprintf(base_name, BASE_BUFFER_SIZE256, "%d", alignment*8);
	snprintf(tfs_name, BASE_BUFFER_SIZE256, "TFS(&%s_tfs)", name);
	register_hf_field(hf_bitname, name, filter_name, "FT_BOOLEAN", base_name, tfs_name, value, "");

	FPRINTF(eth_code, "static const true_false_string %s_tfs = {\n",name);
	FPRINTF(eth_code, "    \"%s is SET\",\n", name);
	FPRINTF(eth_code, "    \"%s is NOT set\"\n", name);
	FPRINTF(eth_code, "};\n");
	FPRINTF(eth_code, "\n");
}

if(pass==1){
	FPRINTF(eth_code, "    proto_tree_add_boolean(tree, %s, tvb, offset-%d, %d, flags);\n", hf_bitname, alignment, alignment);
	FPRINTF(eth_code, "    if(flags&%s){\n", value);
	FPRINTF(eth_code, " 	   proto_item_append_text(item, \" %s\");\n", name);
	FPRINTF(eth_code, "    }\n");
	FPRINTF(eth_code, "    flags&=(~%s);\n", value);
	FPRINTF(eth_code, "\n");
}

if(!g_strcmp0(ti->str, ",")){
	ti=ti->next;
	continue;
}
}

if(pass==1){
FPRINTF(eth_code, "    if(flags){\n");
FPRINTF(eth_code, " 	   proto_item_append_text(item, \"UNKNOWN-FLAGS\");\n");
FPRINTF(eth_code, "    }\n");
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "    return offset;\n");
FPRINTF(eth_code, "}\n");
switch(alignment){
case 1:
	register_new_type(bitmap_name, dissectorname, "FT_UINT8", "BASE_HEX", "0", "NULL", alignment);
	break;
case 4:
	register_new_type(bitmap_name, dissectorname, "FT_UINT32", "BASE_HEX", "0", "NULL", alignment);
	break;
default:
	FPRINTF(stderrstderr, "ERROR: typedefbitmap can not handle alignment:%d\n",alignment);
	Exit(10);
}
}

FPRINTF(NULL((void*)0),"\nEND BITMAP:%s pass:%d\n-------\n",bitmap_name,pass);

/* only advance token_list for pass==1
  ti now points to the '}' token
*/
if(pass==1){
if(!ti || g_strcmp0(ti->str,"}")){
	FPRINTF(stderrstderr, "ERROR: bitmap does not end with '}'\n");
	Exit(10);
}
ti=ti->next;

/* just skip the name */
ti=ti->next;

if(!ti || g_strcmp0(ti->str,";")){
	FPRINTF(stderrstderr, "ERROR: bitmap does not end with ';'\n");
	Exit(10);
}
ti=ti->next;

token_list=ti;
}
2151}

2153/* a case tag might be a negative number, i.e. contain a '-' sign which
 is not valid inside a symbol name in c.
2155*/
2156static const char *
2157case2str(const char *str)
2158{
char *newstr;
if(str[0]!='-'){
return str;
}
newstr=g_strdup(str)g_strdup_inline (str);
newstr[0]='m';
return newstr;
2166}

2168/* this function will parse a
typedef union {
construct and generate the appropriate code.
the typedef will be g_removed from the token_list once it has been processed
the function assumes that the typedef is the first object in the token_list
the function will be called twice, once with pass=0 and once with pass=1
which controls whether subdissectors are to be generated or whether the
union dissector itself is to be generated
2176*/
2177static void parsetypedefunion(int pass)
2178{
char *union_name;
token_item_t *ti, *tmpti;
char dissectorname[BASE_BUFFER_SIZE256];
bracket_item_t *bi=NULL((void*)0);
char tmpstr[BASE_BUFFER_SIZE256], *ptmpstr;
int level, num_pointers;
static int alignment;
type_item_t *type_item;
char hf_index[BASE_BUFFER_SIZE256];
int tag_alignment, item_alignment;

ti=token_list;
if(g_strcmp0(ti->str, "typedef")){
FPRINTF(stderrstderr, "ERROR: typedefunion  first token is not 'typedef'\n");
Exit(10);
}
ti=ti->next;

if(!g_strcmp0(ti->str, "[")){
ti=parsebrackets(ti, &bi);
}
/* check that we know how to handle the bracket thing */
if(bi){
if(bi->flags&(~(BI_SWITCH_TYPE0x00000400))){
	FPRINTF(stderrstderr, "ERROR: typedefunion unknown bracket flags encountered : 0x%08x\n",bi->flags);
	Exit(10);
}
}

if(g_strcmp0(ti->str, "union")){
FPRINTF(stderrstderr, "ERROR: typedefunion  second token is not 'union'\n");
Exit(10);
}
ti=ti->next;

if(g_strcmp0(ti->str, "{")){
FPRINTF(stderrstderr, "ERROR: typedefunion  third token is not '{'\n");
Exit(10);
}
ti=ti->next;

/* search forward until the '}' so we can find the name of the union */
for(tmpti=ti,level=0;tmpti;tmpti=tmpti->next){
if(!g_strcmp0(tmpti->str, "{")){
	level++;
	continue;
}
if(!g_strcmp0(tmpti->str, "}")){
	if(!level){
		break;
	}
	level--;
	continue;
}
}

if (!tmpti || !tmpti->next){
FPRINTF(stderrstderr, "ERROR: typedefunion  missing matching '}'\n");
Exit(10);
}
union_name=tmpti->next->str;
snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_union_%s", ifname, union_name);

FPRINTF(NULL((void*)0),"\nUNION:%s pass:%d\n-------\n",union_name,pass);

if(bi && bi->flags&BI_SWITCH_TYPE0x00000400){
tag_alignment=bi->union_tag_size;
} else {
tag_alignment=get_union_tag_size(union_name);
}

/* this is pass 0  so reset alignment to the minimum possible value
  and update as items are processed.
  we need alignment when pass 1 is run
*/
if(pass==0){
alignment=tag_alignment;
}

/* pass 1  generate header for the struct dissector */
if(pass==1){
FPRINTF(eth_ett, "static int ett_%s_%s;\n", ifname, union_name);
FPRINTF(eth_ettarr, "		 &ett_%s_%s,\n", ifname, union_name);
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "static int\n");
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);
FPRINTF(eth_code, "{\n");
FPRINTF(eth_code, "    proto_item *item=NULL;\n");
FPRINTF(eth_code, "    proto_tree *tree=NULL;\n");
FPRINTF(eth_code, "    int old_offset;\n");
/* we do alignment on the tag itself here so that
   we skip any alignment padding prior to where the tag
   itself starts, this makes the byterange in the hexpane
   for the union expansion start with the first byte of the tag
*/
switch(tag_alignment){
case 1:
	break;
case 2:
	FPRINTF(eth_code, "    uint16_t level;\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    ALIGN_TO_2_BYTES;\n");
	FPRINTF(eth_code, "\n");
	break;
case 4:
	FPRINTF(eth_code, "    uint32_t level = 0;\n");
	FPRINTF(eth_code, "\n");
	FPRINTF(eth_code, "    ALIGN_TO_4_BYTES;\n");
	FPRINTF(eth_code, "\n");
	break;
default:
	FPRINTF(stderrstderr, "ERROR: typedefunion 1 can not handle alignment:%d\n",alignment);
	Exit(10);
}
FPRINTF(eth_code, "    old_offset=offset;\n");
FPRINTF(eth_code, "    if(parent_tree){\n");
FPRINTF(eth_code, " 	   tree=proto_tree_add_subtree(parent_tree, tvb, offset, -1, ett_%s_%s, &item, \"%s\");\n", ifname, union_name, union_name);
FPRINTF(eth_code, "    }\n");
FPRINTF(eth_code, "\n");
switch(tag_alignment){
case 1:
	break;
case 2:
	FPRINTF(eth_code, "    offset=dissect_ndr_uint16(tvb, offset, pinfo, tree,\n");
	FPRINTF(eth_code, " 							 di, drep, hf_index, &level);\n");
break;
case 4:
	FPRINTF(eth_code, "    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree,\n");
	FPRINTF(eth_code, " 							 di, drep, hf_index, &level);\n");
	break;
default:
	FPRINTF(stderrstderr, "ERROR: typedefunion 2 can not handle alignment:%d\n",alignment);
	Exit(10);
}
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "    switch(level){\n");
}

/* scan the struct and create all subdissectors */
level=0;
while(ti){
if(!g_strcmp0(ti->str, "{")){
	ti=ti->next;
	level++;
	continue;
}
if(!g_strcmp0(ti->str, "}")){
	if(!level){
		break;
	}
	ti=ti->next;
	level--;
	continue;
}
if(!g_strcmp0(ti->str, "[")){
	ti=parsebrackets(ti, &bi);
	continue;
}

if(!bi){
	FPRINTF(stderrstderr, "ERROR : typedefunion no brackets found for case\n");
	Exit(10);
}
/* make sure we catch when we havent implemented everything
   yet.
   we currently only know about CASE and CASE_DEFAULT flags
*/
if(bi->flags&(~(BI_CASE0x00000001|BI_CASE_DEFAULT0x00000002|BI_POINTER0x00000040))){
	FPRINTF(stderrstderr, "ERROR: typedefunion unknown bracket flags encountered : 0x%08x\n",bi->flags);
	Exit(10);
}
if(!(bi->flags&BI_CASE0x00000001)){
	FPRINTF(stderrstderr, "ERROR : typedefunion no case found in brackets\n");
	Exit(10);
}
2354#ifdef g_removeD
/* only empty default cases for now */
if(bi->flags&BI_CASE_DEFAULT0x00000002){
	if(g_strcmp0(ti->str,";")){
		FPRINTF(stderrstderr, "ERROR: default tag is not empty\n");
		Exit(10);
	}
	ti=ti->next;
	continue;
}
2364#endif

/* just skip all and any 'empty' arms */
if(!g_strcmp0(ti->str, ";")){
	ti=ti->next;
	continue;
}

/* handle the type, verify that we KNOW this type */
type_item=find_type(ti->str);
if(!type_item){
	FPRINTF(stderrstderr, "ERROR : typedefunion unknown type %s\n",ti->str);
	Exit(10);
}
ti=ti->next;
/* count the levels of pointers */
for(num_pointers=0;!g_strcmp0(ti->str, "*");ti=ti->next){
	num_pointers++;
}

/* keep track of alignment */
if(num_pointers){
	item_alignment=4;
} else {
	item_alignment=type_item->alignment;
}
if(alignment<item_alignment){
	alignment=item_alignment;
}

snprintf(hf_index, BASE_BUFFER_SIZE256, "hf_%s_%s_%s_%s", ifname, union_name, case2str(bi->case_name), ti->str);
/* pass 0  generate subdissectors */
if(pass==0){
	char filter_name[BASE_BUFFER_SIZE256];
	const char *hf;

	snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_dissect_union_%s_%s_%s", ifname, union_name, case2str(bi->case_name), ti->str);
	ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	snprintf(filter_name, BASE_BUFFER_SIZE256, "%s.%s.%s", ifname, union_name, ti->str);
	hf=register_hf_field(hf_index, ti->str, filter_name, type_item->ft_type, type_item->base_type, type_item->vals, type_item->mask, "");

	FPRINTF(eth_code, "static int\n");
	FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", ptmpstr);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    uint32_t param=%s;\n",find_dissector_param_value(ptmpstr));
	FPRINTF(eth_code, "    offset=%s(tvb, offset, pinfo, tree, di, drep, %s, param);\n", type_item->dissector, hf);
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");

	/* handle pointers */
	while(num_pointers--){
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", ptmpstr, "unique");
		FPRINTF(eth_code, "static int\n");
		FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		FPRINTF(eth_code, "{\n");
		FPRINTF(eth_code, "    offset=dissect_ndr_embedded_pointer(tvb, offset, pinfo, tree, di, drep, %s, NDR_POINTER_UNIQUE, \"%s\", -1);\n", ptmpstr, ti->str);
		FPRINTF(eth_code, "    return offset;\n");
		FPRINTF(eth_code, "}\n");
		FPRINTF(eth_code, "\n");

		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	}
}

if(pass==1){
	/* handle pointers */
	snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_dissect_union_%s_%s_%s", ifname, union_name, case2str(bi->case_name), ti->str);
	ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	while(num_pointers--){
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", ptmpstr, "unique");
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	}

	if(bi->flags&BI_CASE_DEFAULT0x00000002){
		FPRINTF(eth_code, "    default:\n");
	} else {
		FPRINTF(eth_code, "    case %s:\n",bi->case_name);
	}
	/* each arm itself is aligned independently */
	switch(item_alignment){
	case 1:
		break;
	case 2:
		FPRINTF(eth_code, " 	   ALIGN_TO_2_BYTES;\n");
		break;
	case 4:
		FPRINTF(eth_code, " 	   ALIGN_TO_4_BYTES;\n");
		break;
	case 8:
		FPRINTF(eth_code, " 	   ALIGN_TO_8_BYTES;\n");
		break;
	default:
		FPRINTF(stderrstderr, "ERROR: typedefunion 3 can not handle alignment:%d\n",item_alignment);
		Exit(10);
	}
	FPRINTF(eth_code, " 	   offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
	FPRINTF(eth_code, " 	   break;\n");
	FPRINTF(eth_code, "\n");
}
ti=ti->next;

if(g_strcmp0(ti->str,";")){
	FPRINTF(stderrstderr, "ERROR: field does not end with ';'\n");
	Exit(10);
}
ti=ti->next;
}

if(pass==1){
FPRINTF(eth_code, "    }\n");
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "    proto_item_set_len(item, offset-old_offset);\n");
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "   return offset;\n");
FPRINTF(eth_code, "}\n");
switch(tag_alignment){
case 2:
	register_new_type(union_name, dissectorname, "FT_UINT16", "BASE_DEC", "0", "NULL", alignment);
	break;
case 4:
	register_new_type(union_name, dissectorname, "FT_UINT32", "BASE_DEC", "0", "NULL", alignment);
	break;
default:
	FPRINTF(stderrstderr, "ERROR: typedefunion 4 can not handle alignment:%d\n",alignment);
	Exit(10);
}
}

FPRINTF(NULL((void*)0),"\nEND UNION:%s pass:%d\n-------\n",union_name,pass);

/* only advance token_list for pass==1
  ti now points to the '}' token
*/
if(pass==1){
if(!ti || g_strcmp0(ti->str,"}")){
	FPRINTF(stderrstderr, "ERROR: union does not end with '}'\n");
	Exit(10);
}
ti=ti->next;

/* just skip the name */
ti=ti->next;

if(!ti || g_strcmp0(ti->str,";")){
	FPRINTF(stderrstderr, "ERROR: union does not end with ';'\n");
	Exit(10);
}
ti=ti->next;

token_list=ti;
}
2518}


2521/* this function will parse a
  WERROR function (
 construct and generate the appropriate code.
 the function will be g_removed from the token_list once it has been processed
 the function assumes that the function is the first object in the token_list
 the function will be called three times with
pass=0   generate subdissectors and entries for the function table
pass=1   generate code for the REQUEST
pass=2   generate code for the REPLY
2530*/
2531static void parsefunction(int pass)
2532{
char *function_name;
static int funcno=0;
token_item_t *ti;
bracket_item_t *bi=NULL((void*)0);
pointer_item_t *pi;
const char *pointer_type;

char tmpstr[BASE_BUFFER_SIZE256], *ptmpstr;
int level, num_pointers;
type_item_t *type_item;
char hf_index[BASE_BUFFER_SIZE256];

ti=token_list;
if(g_strcmp0(ti->str, "WERROR")){
FPRINTF(stderrstderr, "ERROR: function  first token is not 'WERROR'\n");
Exit(10);
}
ti=ti->next;

function_name=ti->str;
ti=ti->next;

if(g_strcmp0(ti->str, "(")){
FPRINTF(stderrstderr, "ERROR: function  third token is not '('\n");
Exit(10);
}
ti=ti->next;

FPRINTF(NULL((void*)0),"\nFUNCTION:%s pass:%d\n-------\n",function_name,pass);

if(pass==0){
FPRINTF(eth_ft, "	 { %d, \"%s\",\n",funcno,function_name);
FPRINTF(eth_ft, "		 %s_dissect_%s_request,\n", ifname, function_name);
FPRINTF(eth_ft, "		 %s_dissect_%s_response },\n", ifname, function_name);
funcno++;
}

/* pass 1,2  generate header for the function dissector */
if((pass==1)||(pass==2)){
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "static int\n");
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");
FPRINTF(eth_code, "{\n");
}

/* scan the struct and create all subdissectors */
level=0;
while(ti){
if(!g_strcmp0(ti->str, "(")){
	ti=ti->next;
	level++;
	continue;
}
if(!g_strcmp0(ti->str, ")")){
	if(!level){
		break;
	}
	ti=ti->next;
	level--;
	continue;
}
if(!g_strcmp0(ti->str, "[")){
	ti=parsebrackets(ti, &bi);
	continue;
}

if(!bi){
	FPRINTF(stderrstderr, "ERROR : function no brackets found for case\n");
	Exit(10);
}

/* make sure we catch when we havent implemented everything
   yet.
   we currently only know about IN and OUT flags
*/
if(bi->flags&(~(BI_IN0x00000004|BI_OUT0x00000008|BI_POINTER0x00000040|BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020))){
	FPRINTF(stderrstderr, "ERROR: function unknown bracket flags encountered : 0x%08x\n",bi->flags);
	Exit(10);
}
if(!(bi->flags&(BI_IN0x00000004|BI_OUT0x00000008))){
	FPRINTF(stderrstderr, "ERROR : function  parameter is neither in nor out\n");
	Exit(10);
}

/* handle the type, verify that we KNOW this type */
type_item=find_type(ti->str);
if(!type_item){
	FPRINTF(stderrstderr, "ERROR : function unknown type %s\n",ti->str);
	Exit(10);
}
ti=ti->next;
/* count the levels of pointers */
for(num_pointers=0;!g_strcmp0(ti->str, "*");ti=ti->next){
	num_pointers++;
}

/* now that we know how many real pointer there were we must
   prepend default pointers to the list so it has the right
   length.
*/
pi=prepend_pointer_list(bi->pointer_list, num_pointers);

snprintf(hf_index, BASE_BUFFER_SIZE256, "hf_%s_%s_%s", ifname, function_name, ti->str);
/* pass 0  generate subdissectors */
if(pass==0){
	char filter_name[BASE_BUFFER_SIZE256];
	const char *hf;

	snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_dissect_%s_%s", ifname, function_name, ti->str);
	ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	snprintf(filter_name, BASE_BUFFER_SIZE256, "%s.%s.%s", ifname, function_name, ti->str);
	hf=register_hf_field(hf_index, ti->str, filter_name, type_item->ft_type, type_item->base_type, type_item->vals, type_item->mask, "");

	FPRINTF(eth_code, "static int\n");
	FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", ptmpstr);
	FPRINTF(eth_code, "{\n");
	FPRINTF(eth_code, "    uint32_t param=%s;\n",find_dissector_param_value(ptmpstr));
	FPRINTF(eth_code, "    offset=%s(tvb, offset, pinfo, tree, di, drep, %s, param);\n", type_item->dissector, hf);
	FPRINTF(eth_code, "    return offset;\n");
	FPRINTF(eth_code, "}\n");
	FPRINTF(eth_code, "\n");


	/* handle switch_is */
	switch(bi->flags&(BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020)){
	case 0:
	    break;
	case BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020:
	    snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucvarray_%s", ptmpstr);
	    FPRINTF(eth_code, "static int\n");
	    FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
	    FPRINTF(eth_code, "{\n");
	    FPRINTF(eth_code, "    offset=dissect_ndr_ucvarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
	    FPRINTF(eth_code, "    return offset;\n");
	    FPRINTF(eth_code, "}\n");
	    FPRINTF(eth_code, "\n");
	    ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	    break;
	case BI_SIZE_IS0x00000010:
	    snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucarray_%s", ptmpstr);
	    FPRINTF(eth_code, "static int\n");
	    FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
	    FPRINTF(eth_code, "{\n");
	    FPRINTF(eth_code, "    offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, di, drep, %s);\n", ptmpstr);
	    FPRINTF(eth_code, "    return offset;\n");
	    FPRINTF(eth_code, "}\n");
	    FPRINTF(eth_code, "\n");
	    ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	    break;
	default:
	    FPRINTF(stderrstderr, "ERROR: typedeffunction can not handle this combination of sizeis/lengthis\n");
	    Exit(10);
	}

	/* handle pointers */
	while(num_pointers--){
		pointer_type=pi->type;
		pi=pi->next;
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", pointer_type, ptmpstr);
		FPRINTF(eth_code, "static int\n");
		FPRINTF(eth_code, "%s(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, dcerpc_info *di, uint8_t *drep)\n", tmpstr);
		FPRINTF(eth_code, "{\n");
		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);
		FPRINTF(eth_code, "    return offset;\n");
		FPRINTF(eth_code, "}\n");
		FPRINTF(eth_code, "\n");

		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	}
}

if((pass==1)||(pass==2)){
	snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_dissect_%s_%s", ifname, function_name, ti->str);
	ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);

	switch(bi->flags&(BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020)){
	case 0:
	    break;
	case BI_SIZE_IS0x00000010|BI_LENGTH_IS0x00000020:
	    snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucvarray_%s", ptmpstr);
	    ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	    break;
	case BI_SIZE_IS0x00000010:
	    snprintf(tmpstr, BASE_BUFFER_SIZE256, "ucarray_%s", ptmpstr);
	    ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	    break;
	default:
	    FPRINTF(stderrstderr, "ERROR: typedeffunction can not handle this combination of sizeis/lengthis\n");
	    Exit(10);
	}

	/* handle pointers */
	while(num_pointers--){
		pointer_type=pi->type;
		pi=pi->next;
		snprintf(tmpstr, BASE_BUFFER_SIZE256, "%s_%s", pointer_type, ptmpstr);
		ptmpstr=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	}

	if((pass==1)&&(bi->flags&BI_IN0x00000004)){
		FPRINTF(eth_code, " 	   offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
		FPRINTF(eth_code, " 	   offset=dissect_deferred_pointers(pinfo, tvb, offset, di, drep);\n");
		FPRINTF(eth_code, "\n");
	}
	if((pass==2)&&(bi->flags&BI_OUT0x00000008)){
		FPRINTF(eth_code, " 	   offset=%s(tvb, offset, pinfo, tree, di, drep);\n", ptmpstr);
		FPRINTF(eth_code, " 	   offset=dissect_deferred_pointers(pinfo, tvb, offset, di, drep);\n");
		FPRINTF(eth_code, "\n");
	}
}
ti=ti->next;


if(!g_strcmp0(ti->str,",")){
	ti=ti->next;
	continue;
}
}

if((pass==1)||(pass==2)){
if(pass==2){
	FPRINTF(eth_code, "   offset=dissect_ntstatus(tvb, offset, pinfo, tree, di, drep, %s, NULL);\n", hf_status);
	FPRINTF(eth_code, "\n");
}
FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "   return offset;\n");
FPRINTF(eth_code, "}\n");
}

FPRINTF(NULL((void*)0),"\nEND FUNCTION:%s pass:%d\n-------\n",function_name,pass);

/* only advance token_list for pass==2
  ti now points to the ')' token
*/
if(pass==2){
if(!ti || g_strcmp0(ti->str,")")){
	FPRINTF(stderrstderr, "ERROR: function does not end with ')'\n");
	Exit(10);
}
ti=ti->next;

if(!ti || g_strcmp0(ti->str,";")){
	FPRINTF(stderrstderr, "ERROR: function does not end with ';'\n");
	Exit(10);
}
ti=ti->next;

token_list=ti;
}
2784}


2787/* this function will parse a
  typedef enum {
 or a
  typedef [ v1_enum ] enum {
 construct and generate the appropriate code.
 the typedef will be g_removed from the token_list once it has been processed
 the function assumes that the typedef is the first object in the token_list
2794*/
2795static void parsetypedefenum(void)
2796{
token_item_t *ti;
enum_list_t *enum_list, *el, *lastel;
char *p;
long val;
int eval, enumsize;
char dissectorname[BASE_BUFFER_SIZE256], valsstring[BASE_BUFFER_SIZE256];
char *hfvalsstring;

enumsize=16;

ti=token_list;
if(g_strcmp0(ti->str, "typedef")){
FPRINTF(stderrstderr, "ERROR: typedefenum  first token is not 'typedef'\n");
Exit(10);
}
ti=ti->next;

/* this could be a [ v1_enum ] */
if(!g_strcmp0(ti->str, "[")){
ti=ti->next;

if(g_strcmp0(ti->str, "v1_enum")){
	FPRINTF(stderrstderr, "ERROR: typedefenum  not 'v1_enum' inside brackets\n");
	Exit(10);
}
ti=ti->next;

if(g_strcmp0(ti->str, "]")){
	FPRINTF(stderrstderr, "ERROR: typedefenum  'v1_enum' is not followed by ']'\n");
	Exit(10);
}
ti=ti->next;

enumsize=32;
}


if(g_strcmp0(ti->str, "enum")){
FPRINTF(stderrstderr, "ERROR: typedefenum  second token is not 'enum'\n");
Exit(10);
}
ti=ti->next;

if(g_strcmp0(ti->str, "{")){
FPRINTF(stderrstderr, "ERROR: typedefenum  third token is not '{'\n");
Exit(10);
}
ti=ti->next;

/* now parse all values until we find the "}" */
eval=0;
enum_list=NULL((void*)0);
lastel=NULL((void*)0);
while(1){
/* check for '}' */
if(!g_strcmp0(ti->str,"}")){
	ti=ti->next;
	break;
}

/* handle 4 types of entries:
 * 1, CONST = value,
 * 2, CONST,
 * 3, CONST = value}
 * 4, CONST}
 */
el=g_new0(enum_list_t, 1)((enum_list_t *) g_malloc0_n ((1), sizeof (enum_list_t)));
if (!el) {
	FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
	exit(10);
}
el->next=NULL((void*)0);
if(!enum_list){
	enum_list=el;
} else {
	lastel->next=el;
}
lastel=el;

/* grab CONST */
el->name=ti->str;
ti=ti->next;

/* grab separator */
if(!g_strcmp0(ti->str,"=")){
	ti=ti->next;
	/* grab value */
	val=strtol(ti->str,&p,0);
	if (p==ti->str||*p) {
		FPRINTF(stderrstderr, "ERROR: typedefenum value is not a number\n");
		Exit(10);
	}
	el->val=(int)val;
	ti=ti->next;
} else {
	el->val=eval;
}
eval=el->val+1;

/* check for ',' */
if(!g_strcmp0(ti->str,",")){
	ti=ti->next;
	continue;
}

/* check for '}' */
if(!g_strcmp0(ti->str,"}")){
	ti=ti->next;
	break;
}

FPRINTF(stderrstderr,"ERROR: typedefenum should not be reached\n");
Exit(10);
}

/* verify that it ends with a ';' */
if(g_strcmp0(ti->next->str,";")){
FPRINTF(stderrstderr,"ERROR enum terminator is not ';'\n");
Exit(10);
}

snprintf(valsstring, BASE_BUFFER_SIZE256, "%s_%s_vals", ifname, ti->str);
snprintf(dissectorname, DISSECTORNAME_MAXLEN256, "%s_dissect_%s", ifname, ti->str);

FPRINTF(NULL((void*)0),"\nENUM:%s\n-------\n",ti->str);

FPRINTF(eth_hdr, "\n");
for(el=enum_list;el;el=el->next){
FPRINTF(eth_hdr, "#define %s		%d\n", el->name, el->val);
}

FPRINTF(eth_hdr, "\n");
FPRINTF(eth_hdr, "extern const value_string %s[];\n", valsstring);
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);

FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "const value_string %s[] = {\n", valsstring);

for(el=enum_list;el;el=el->next){
FPRINTF(eth_code, "    { %d	, \"%s\" },\n", el->val, el->name);
}
FPRINTF(eth_code, "    { 0	, NULL }\n");
FPRINTF(eth_code, "};\n");

FPRINTF(eth_code, "\n");
FPRINTF(eth_code, "int\n");
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);
FPRINTF(eth_code, "{\n");
switch(enumsize){
case 16:
FPRINTF(eth_code, "    offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
break;
case 32:
FPRINTF(eth_code, "    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, hf_index, NULL);\n");
break;
default:
FPRINTF(stderrstderr,"ERROR enum unknown size\n");
Exit(10);
}

FPRINTF(eth_code, "    return offset;\n");
FPRINTF(eth_code, "}\n");
FPRINTF(eth_code, "\n");

hfvalsstring = g_strdup_printf("VALS(%s)", valsstring);
switch(enumsize){
case 16:
register_new_type(ti->str, dissectorname, "FT_INT16", "BASE_DEC", "0", hfvalsstring, 2);
break;
case 32:
register_new_type(ti->str, dissectorname, "FT_INT32", "BASE_DEC", "0", hfvalsstring, 4);
break;
default:
FPRINTF(stderrstderr,"ERROR enum unknown size\n");
g_free(hfvalsstring);
Exit(10);
}
g_free(hfvalsstring);

FPRINTF(NULL((void*)0),"\n----------\nEND ENUM:%s\n",ti->str);

/* skip past the name and the ';' */
token_list=ti->next->next;
2980}

2982typedef struct _trimmed_prefixes_t {
struct _trimmed_prefixes_t *next;
char *name;
2985} trimmed_prefixes_t;
2986static trimmed_prefixes_t *prefixes_to_trim=NULL((void*)0);

2988static void preparetrimprefix(char *prefix_name)
2989{
trimmed_prefixes_t *new_prefix;
new_prefix=g_new0(trimmed_prefixes_t, 1)((trimmed_prefixes_t *) g_malloc0_n ((1), sizeof (trimmed_prefixes_t
)));
if (!new_prefix) {
FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
exit(10);
}
new_prefix->next=prefixes_to_trim;
prefixes_to_trim=new_prefix;
new_prefix->name=g_strdup(prefix_name)g_strdup_inline (prefix_name);
2999}

3001static void
3002trimprefix(void)
3003{
token_item_t *ti;
trimmed_prefixes_t *pfx;
size_t len;

for(pfx=prefixes_to_trim;pfx;pfx=pfx->next){
len=strlen(pfx->name);
for(ti=token_list;ti;ti=ti->next){
	if(!strncmp(ti->str, pfx->name, len)){
		ti->str+=len;
	}
}
}
3016}

3018static int Exit(int code)
3019{
FPRINTF(stderrstderr, "The tokens remaining when aborting:\n");
printtokenlist(10);

exit(code);
3024}

3026static void usage(void)
3027{
FPRINTF(stderrstderr, "Usage: idl2wrs <interface>\n");
3029}

3031static void
3032mergefile(const char *name, FILE *outfile)
3033{
FILE *infile;

FPRINTF(outfile, "\n\n/* INCLUDED FILE : %s */\n", name);
infile=g_fopenfopen(name, "r");
while(!feof(infile)){
int ch;
ch=fgetc(infile);
if(ch!=-1){
	fputc(ch, outfile);
}
}
fclose(infile);
FPRINTF(outfile, "/* END OF INCLUDED FILE : %s */\n\n\n", name);
3047}



3051static char *
3052str_read_string(char *str, char **name)
3053{
char tmpstr[BASE_BUFFER_SIZE256], *strptr;
int skip_blanks;
int quoted_string;

strptr=tmpstr;
skip_blanks=1;
quoted_string=0;
while(1){
if(!*str){
	*strptr=0;
	*name=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	return str;
}
if(skip_blanks){
	if( (*str==' ') || (*str=='\t') ){
		str++;
		continue;
	}
	if( *str=='"' ){
		str++;
		quoted_string=1;
	}
	skip_blanks=0;
	continue;
}
if( (*str==' ') || (*str=='\t') ){
	if(quoted_string){
		*strptr++ = *str++;
		continue;
	}
	*strptr=0;
	*name=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	return str;
}
if( (*str=='"') || (*str=='\n') ){
	*strptr=0;
	*name=g_strdup(tmpstr)g_strdup_inline (tmpstr);
	return ++str;
}
*strptr++ = *str++;
}
return NULL((void*)0);
3096}

3098static void
3099readcnffile(FILE *fh)
3100{
char cnfline[4 * BASE_BUFFER_SIZE256];

FPRINTF(NULL((void*)0), "Reading conformance file\n=======================\n");
while(!feof(fh)){
cnfline[0]=0;
if(!fgets(cnfline, 4 * BASE_BUFFER_SIZE256, fh) || !cnfline[0]){
	continue;
}
if(cnfline[0]=='#'){
	/* ignore all comments */
} else if(!strncmp(cnfline, "NOEMIT", 6)){
	no_emit_item_t *nei;
	char *str, *name;

	str=cnfline+6;
	str_read_string(str, &name);
	nei=g_new0(no_emit_item_t, 1)((no_emit_item_t *) g_malloc0_n ((1), sizeof (no_emit_item_t)
));
	if (!nei) {
		FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
		exit(10);
	}
	nei->next=no_emit_list;
	no_emit_list=nei;
	nei->name=name;
	FPRINTF(NULL((void*)0), "NOEMIT : %s\n", nei->name);
} else if(!strncmp(cnfline, "TYPE", 4)){
	char *name, *dissectorname, *ft_type, *base_type;
	char *mask, *valsstring, *al;
	char *str;
	int alignment;

	str=cnfline+4;
	str=str_read_string(str, &name);
	str=str_read_string(str, &dissectorname);
	str=str_read_string(str, &ft_type);
	str=str_read_string(str, &base_type);
	str=str_read_string(str, &mask);
	str=str_read_string(str, &valsstring);
	str_read_string(str, &al);
	if (ws_strtoi32(al, NULL((void*)0), &alignment)) {
		FPRINTF(NULL((void*)0), "TYPE : X%s,%sX\n", name, dissectorname);
		register_new_type(name, dissectorname, ft_type, base_type, mask, valsstring, alignment);
	}
} else if(!strncmp(cnfline, "PARAM_VALUE", 11)){
	char *dissectorname, *value;
	char *str;

	str=cnfline+11;
	str=str_read_string(str, &dissectorname);
	str_read_string(str, &value);

	FPRINTF(NULL((void*)0), "PARAM_VALUE : %s=%s\n", dissectorname,value);
	register_dissector_param_value(dissectorname, value);
} else if(!strncmp(cnfline, "HF_FIELD", 8)){
	char *hf_index, *title, *filter_name, *ft_type;
	char *base_type, *valsstring, *mask, *blurb;
	char *str;

	str=cnfline+8;
	str=str_read_string(str, &hf_index);
	str=str_read_string(str, &title);
	str=str_read_string(str, &filter_name);
	str=str_read_string(str, &ft_type);
	str=str_read_string(str, &base_type);
	str=str_read_string(str, &valsstring);
	str=str_read_string(str, &mask);
	str_read_string(str, &blurb);
	FPRINTF(NULL((void*)0), "HF_FIELD: %s \"%s\"\n", hf_index, title);
	register_hf_field(hf_index, title, filter_name, ft_type, base_type, valsstring, mask, blurb);
} else if(!strncmp(cnfline, "HF_RENAME", 9)){
	char *old_name, *new_name;
	char *str;

	str=cnfline+9;
	str=str_read_string(str, &old_name);
	str_read_string(str, &new_name);
	FPRINTF(NULL((void*)0), "HF_RENAME: %s -> %s\n", old_name, new_name);
	register_hf_rename(old_name, new_name);
} else if(!strncmp(cnfline, "UNION_TAG_SIZE", 14)){
	char *union_name, *union_tag;
	int32_t union_tag_size;
	union_tag_size_item_t *utsi;
	char *str;

	str=cnfline+14;
	str=str_read_string(str, &union_name);
	str_read_string(str, &union_tag);
	if (!ws_strtoi32(union_tag, NULL((void*)0), &union_tag_size)) {
		FPRINTF(NULL((void*)0), "UNION_TAG_SIZE: invalid string: %s\n", union_tag);
		exit(10);
	}
	FPRINTF(NULL((void*)0), "UNION_TAG_SIZE: %s == %d\n", union_name, union_tag_size);
	utsi=g_new0(union_tag_size_item_t, 1)((union_tag_size_item_t *) g_malloc0_n ((1), sizeof (union_tag_size_item_t
)));
	if (!utsi) {
		FPRINTF(stderrstderr, "Can't allocate memory. Exit.\n");
		exit(10);
	}
	utsi->next=union_tag_size_list;
	union_tag_size_list=utsi;
	utsi->name=g_strdup(union_name)g_strdup_inline (union_name);
	utsi->size=union_tag_size;
} else if(!strncmp(cnfline, "STRIP_PREFIX", 12)){
	char *prefix_name;
	char *str;

	str=cnfline+12;
	str_read_string(str, &prefix_name);
	FPRINTF(NULL((void*)0), "STRIP_PREFIX: %s\n", prefix_name);
	preparetrimprefix(prefix_name);
} else {
	FPRINTF(stderrstderr, "ERROR: could not parse cnf directive:%s\n",cnfline);
	exit(10);
}
}
3215}

3217int main(int argc, const char *argv[])
3218{
char idlfile[BASE_BUFFER_SIZE256];
char tmplfile[BASE_BUFFER_SIZE256];
char prefix_str[BASE_BUFFER_SIZE256];
bracket_item_t *bi;
FILE *fh;

if(argc!=2){
1
Assuming 'argc' is equal to 2→
2
←
Taking false branch→
usage();
exit(0);
}

eth_code=g_fopenfopen("ETH_CODE", "w");
eth_hdr=g_fopenfopen("ETH_HDR", "w");
eth_hfarr=g_fopenfopen("ETH_HFARR", "w");
eth_hf=g_fopenfopen("ETH_HF", "w");
eth_ettarr=g_fopenfopen("ETH_ETTARR", "w");
eth_ett=g_fopenfopen("ETH_ETT", "w");
eth_ft=g_fopenfopen("ETH_FT", "w");
eth_handoff=g_fopenfopen("ETH_HANDOFF", "w");

snprintf(idlfile, BASE_BUFFER_SIZE256, "%s.cnf", argv[1]);
fh=g_fopenfopen(idlfile,"r");
if(fh2.1
'fh' is null
){
3
←
Taking false branch→
readcnffile(fh);
fclose(fh);
}

snprintf(idlfile, BASE_BUFFER_SIZE256, "%s.idl", argv[1]);
fh=g_fopenfopen(idlfile,"r");
if(!fh3.1
'fh' is non-null
){
4
←
Taking false branch→
FPRINTF(stderrstderr, "ERROR: could not open idl-file:%s\n", idlfile);
Exit(0);
}

lineno=0;
linepos=0;
tokenize(fh);
5
←
Calling 'tokenize'→
prune_keyword_parameters("size_is");
prune_keyword_parameters("length_is");
rename_tokens("NTSTATUS", "WERROR");
rename_tokens("unistr_noterm", "unistr");
rename_tokens("ascstr_noterm", "ascstr");
rename_tokens("hyper", "uint64");
FPRINTF(NULL((void*)0),"\n\nParsing header:\n================\n");
parseheader();

/* some idl files prepend a lot of symbols with <ifname>_
  search through the tokenlist and g_remove all such
  prefixes
*/
snprintf(prefix_str, BASE_BUFFER_SIZE256, "%s_", ifname);
preparetrimprefix(prefix_str);
trimprefix();

/* this is the main loop, each iteration it tries to identify what
  kind of construct is the first entry in the token_list and call
  the appropriate handler
*/
while(1) {
/* just skip any [ ] that starts a new construct */
if( !g_strcmp0(token_list->str, "[") ){
	token_list=parsebrackets(token_list, &bi);
	continue;
}

/* typedef enum { */
if( !g_strcmp0(token_list->str,"typedef")
  &&!g_strcmp0(token_list->next->str,"enum") ){
	parsetypedefenum();
	continue;
}

/* typedef [ v1_enum ] enum { */
if( !g_strcmp0(token_list->str,"typedef")
  &&!g_strcmp0(token_list->next->str,"[")
  &&!g_strcmp0(token_list->next->next->str,"v1_enum")
  &&!g_strcmp0(token_list->next->next->next->str,"]")
  &&!g_strcmp0(token_list->next->next->next->next->str,"enum") ){
	parsetypedefenum();
	continue;
}

/* const */
if( !g_strcmp0(token_list->str,"const") ){
	parseconst();
	continue;
}

/* typedef struct { */
if( !g_strcmp0(token_list->str,"typedef") ){
	token_item_t *tmpti;

	tmpti=token_list->next;
	if( !g_strcmp0(tmpti->str, "[") ){
		tmpti=parsebrackets(tmpti, &bi);
		/* do some sanity checks here of bi->flags */
	}
	if( !g_strcmp0(tmpti->str, "struct") ){
		parsetypedefstruct(0);
		parsetypedefstruct(1);
		continue;
	}
}

/* typedef union { */
if( !g_strcmp0(token_list->str,"typedef") ){
	token_item_t *tmpti;

	tmpti=token_list->next;
	if( !g_strcmp0(tmpti->str, "[") ){
		tmpti=parsebrackets(tmpti, &bi);
		/* do some sanity checks here of bi->flags */
	}
	if( !g_strcmp0(tmpti->str, "union") ){
		parsetypedefunion(0);
		parsetypedefunion(1);
		continue;
	}
}

/* typedef bitmap { */
if( !g_strcmp0(token_list->str,"typedef") ){
	token_item_t *tmpti;

	tmpti=token_list->next;
	if( !g_strcmp0(tmpti->str, "[") ){
		tmpti=parsebrackets(tmpti, &bi);
		/* do some sanity checks here of bi->flags */
	}
	if( !g_strcmp0(tmpti->str, "bitmap") ){
		parsetypedefbitmap(0);
		parsetypedefbitmap(1);
		continue;
	}
}

/* functions:  WERROR function '(' */
if( !g_strcmp0(token_list->str,"WERROR")
  &&!g_strcmp0(token_list->next->next->str,"(") ){
	parsefunction(0);
	parsefunction(1);
	parsefunction(2);
	continue;
}

/* declare ... ; */
if( !g_strcmp0(token_list->str,"declare") ){
	skipdeclare();
	continue;
}


break;
};


fclose(eth_code);
fclose(eth_hdr);
fclose(eth_hf);
fclose(eth_hfarr);
fclose(eth_ett);
fclose(eth_ettarr);
fclose(eth_ft);
fclose(eth_handoff);

/* unless the token_list now only contains a single token : '}'
  we have failed to compile the idl file properly
*/
if( g_strcmp0(token_list->str, "}") || token_list->next){
FPRINTF(stderrstderr, "ERROR: we did not process all tokens. Compiler is incomplete.\n===========================================\n");
printtokenlist(10);
exit(10);
}

check_hf_rename_refcount();

/* merge code and template into dissector */
snprintf(line, 4 * BASE_BUFFER_SIZE256, "packet-dcerpc-%s.c", ifname);
fh=g_fopenfopen(line, "w");
snprintf(tmplfile, BASE_BUFFER_SIZE256, "packet-dcerpc-%s-template.c", argv[1]);
tfh=g_fopenfopen(tmplfile, "r");
if(!tfh){
FPRINTF(stderrstderr, "ERROR: could not find %s\n", tmplfile);
exit(10);
}
while(!feof(tfh)){
line[0]=0;
if(!fgets(line, 4 * BASE_BUFFER_SIZE256, tfh) || !line[0]){
	continue;
}
if(!strncmp(line, "ETH_CODE", 8)){
	mergefile("ETH_CODE",fh);
} else if(!strncmp(line, "ETH_HDR", 7)){
	mergefile("ETH_HDR",fh);
} else if(!strncmp(line, "ETH_HFARR", 9)){
	mergefile("ETH_HFARR",fh);
} else if(!strncmp(line, "ETH_HF", 6)){
	mergefile("ETH_HF",fh);
} else if(!strncmp(line, "ETH_ETTARR", 10)){
	mergefile("ETH_ETTARR",fh);
} else if(!strncmp(line, "ETH_ETT", 7)){
	mergefile("ETH_ETT",fh);
} else if(!strncmp(line, "ETH_FT", 6)){
	mergefile("ETH_FT",fh);
} else if(!strncmp(line, "ETH_HANDOFF", 11)){
	mergefile("ETH_HANDOFF",fh);
} else {
	fputs(line, fh);
}
}
fclose(fh);
fclose(tfh);

snprintf(line, 4 * BASE_BUFFER_SIZE256, "packet-dcerpc-%s.h", ifname);
fh=g_fopenfopen(line, "w");
snprintf(tmplfile, BASE_BUFFER_SIZE256, "packet-dcerpc-%s-template.h", argv[1]);
tfh=g_fopenfopen(tmplfile, "r");
if(!tfh){
FPRINTF(stderrstderr, "ERROR: could not find %s\n", tmplfile);
exit(10);
}
while(!feof(tfh)){
line[0]=0;
if(!fgets(line, 4 * BASE_BUFFER_SIZE256, tfh) || !line[0]){
	continue;
}
if(!strncmp(line, "ETH_CODE", 8)){
	mergefile("ETH_CODE",fh);
} else if(!strncmp(line, "ETH_HDR", 7)){
	mergefile("ETH_HDR",fh);
} else if(!strncmp(line, "ETH_HFARR", 9)){
	mergefile("ETH_HFARR",fh);
} else if(!strncmp(line, "ETH_HF", 6)){
	mergefile("ETH_HF",fh);
} else if(!strncmp(line, "ETH_ETTARR", 10)){
	mergefile("ETH_ETTARR",fh);
} else if(!strncmp(line, "ETH_ETT", 7)){
	mergefile("ETH_ETT",fh);
} else if(!strncmp(line, "ETH_FT", 6)){
	mergefile("ETH_FT",fh);
} else if(!strncmp(line, "ETH_HANDOFF", 11)){
	mergefile("ETH_HANDOFF",fh);
} else {
	fputs(line, fh);
}
}

g_print("%s was successfully compiled\n", ifname);

fclose(fh);
fclose(tfh);

if (g_removeremove("ETH_CODE") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_HDR") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_HFARR") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_HF") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_ETTARR") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_ETT") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_FT") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}
if (g_removeremove("ETH_HANDOFF") == -1) {
FPRINTF(stderrstderr, "Can't remove ETH_CODE");
}


return 0;
3498}

3500/*
* Editor modelines  -  https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 8
* tab-width: 8
* indent-tabs-mode: t
* End:
*
* vi: set shiftwidth=8 tabstop=8 noexpandtab:
* :indentSize=8:tabSize=8:noTabs=false:
*/