add machinegenerated full dissector for dcedfs BUDB protocol

svn path=/trunk/; revision=13401

7 files changed, 5783 insertions, 59 deletions

diff --git a/epan/dissectors/dcerpc/budb/Makefile b/epan/dissectors/dcerpc/budb/Makefile
new file mode 100644
index 0000000000..1b9b555846
--- /dev/null
+++ b/epan/dissectors/dcerpc/budb/Makefile
@@ -0,0 +1,16 @@
+# $Id: Makefile 13071 2005-01-16 10:19:21Z guy $
+
+DISSECTOR_FILES=packet-dcerpc-budb.c packet-dcerpc-budb.h
+
+all: generate_dissector
+
+generate_dissector: $(DISSECTOR_FILES)
+
+$(DISSECTOR_FILES): ../idl2eth budb.idl budb.cnf template.c template.h 
+	../idl2eth budb
+
+clean:
+	rm -f ETH_* $(DISSECTOR_FILES)
+
+copy_files: generate_dissector
+	cp $(DISSECTOR_FILES) ../..
diff --git a/epan/dissectors/dcerpc/budb/budb.cnf b/epan/dissectors/dcerpc/budb/budb.cnf
new file mode 100755
index 0000000000..c99e8f47cb
--- /dev/null
+++ b/epan/dissectors/dcerpc/budb/budb.cnf
@@ -0,0 +1,4 @@
+#
+#
+TYPE	budbNameString_t budb_dissect_NameString_t FT_STRING BASE_NONE 0 NULL 4
+#
\ No newline at end of file
diff --git a/epan/dissectors/dcerpc/budb/budb.idl b/epan/dissectors/dcerpc/budb/budb.idl
new file mode 100755
index 0000000000..0af9d5e6f3
--- /dev/null
+++ b/epan/dissectors/dcerpc/budb/budb.idl
@@ -0,0 +1,695 @@
+/* this idl is from the LGPL irelease of dce/dfs from the open group.
+   it has been significantly modified to pass through idl2eth
+   original copyright follows:
+ */
+/*
+ * @OSF_COPYRIGHT@
+ * COPYRIGHT NOTICE
+ * Copyright (c) 1990, 1996 Open Software Foundation, Inc.
+ * ALL RIGHTS RESERVED (DCE).  See the file named COPYRIGHT.DCE for
+ * the full copyright text.
+ */
+/*
+ * HISTORY
+ * $Log: budb.idl,v $
+ * Revision 1.1.13.1  1996/10/02  16:59:37  damon
+ * 	Newest DFS from Transarc
+ * 	[1996/10/01  18:04:09  damon]
+ *
+ * $EndLog$
+ */
+/* Copyright (C) 1996, 1990 Transarc Corporation - All rights reserved */
+
+/* $Header: /u0/rcs_trees/dce/rcs/file/bakserver/budb.idl,v 1.1.13.1 1996/10/02 16:59:37 damon Exp $ */
+
+[
+uuid("eb814e2a-0099-11ca-8678-02608c2ea96e"),
+version(4.0),
+/*provider_version(2)*/
+pointer_default(ptr)
+] interface budb 	/* The backup database interface */
+{
+
+/*import "dcedfs/common_data.idl";*/
+
+
+/* 
+ * Constants for bakserver data structures
+ */
+const long BU_MAXNAMELEN    = 128;      /* names of objects: volumes */
+const long BU_MAXTAPELEN    = 256;     	/* names of objects: tapes */
+const long BU_MAXHOSTLEN    = 128;     	/* names of server machines */
+const long BU_MAXTOKENLEN   = 16;     	/* identifiers */
+const long BU_MAXUNAMELEN   = 256;      /* length of user name */
+const long BU_MAXCELLLEN    = 256;      /* length of a cell name */
+const long BU_MAXINAMELEN   = 128;	/* length of user name */
+const long BU_MAXPATHLEN    = 256;	/* length of schedule path name */
+const long BU_MAXGENNAMELEN = 512;	/* length of generic name */
+const long BU_MAXVOLCOUNT   = 64;	/* max volumes in volume array */
+
+/* first some constants */
+const long BUDB_MAJORVERSION = 1;    	/* version number of this interface */
+const long BUDB_PROVIDER_VERSION = 2;	/* provider version of this interface */
+
+/* types of text blocks */
+const	long TB_DUMPSCHEDULE	= 0;
+const	long TB_VOLUMESET	= 1;
+const	long TB_TAPEHOSTS	= 2;
+
+/* TB_NUM must be <= TB_MAX */
+const	long TB_NUM	= 3;		/* no. of block types */
+const	long TB_MAX	= 6;		/* unused items are spares */
+
+/* dump flag bit definitions */
+const long BUDB_DUMP_INCOMPLETE = 1<<0;	/* some vols omitted due to errors */
+const long BUDB_DUMP_TAPEERROR  = 1<<1;	/* tape error during dump */
+const long BUDB_DUMP_INPROGRESS = 1<<2;
+const long BUDB_DUMP_ABORTED    = 1<<3;	/* aborted: prob. dump unavailable */
+
+/* tape flag bit definitions */
+const long BUDB_TAPE_TAPEERROR    = 1<<0;
+const long BUDB_TAPE_DELETED      = 1<<1;
+const long BUDB_TAPE_BEINGWRITTEN = 1<<2;/* writing in progress */
+const long BUDB_TAPE_ABORTED      = 1<<3;/* aborted: tape probably garbaged */
+const long BUDB_TAPE_STAGED       = 1<<4;/* not yet on permanent media */
+const long BUDB_TAPE_WRITTEN      = 1<<5;/* tape writing finished: all OK */
+
+/* volume flag bit definitions */
+const long BUDB_VOL_TAPEERROR    = 1<<0;/* tape problem during dump */
+const long BUDB_VOL_FILEERROR    = 1<<1;/* voldump aborted during dump */
+const long BUDB_VOL_BEINGWRITTEN = 1<<2;
+const long BUDB_VOL_FIRSTFRAG    = 1<<3;/* same as low bits of tape position */
+const long BUDB_VOL_LASTFRAG     = 1<<4;
+const long BUDB_VOL_ABORTED      = 1<<5;/* aborted: vol probably undumped */
+
+const long BUDB_OP_NAMES    = 0x7;
+const long BUDB_OP_STARTS   = 0x7<<3;
+const long BUDB_OP_ENDS	    = 0x7<<6;
+const long BUDB_OP_TIMES    = 0x3<<9;
+const long BUDB_OP_MISC	    = 0xff<<16;
+
+/* The flag bits specify which entries are being requested.  They are search
+   operations that use name, start, and end to select a subset of entries to be
+   returned.  Not all combinations are meaning full or supported. */
+/* defining the meaning of "name" */
+const long BUDB_OP_DUMPNAME   = 1<<0;
+const long BUDB_OP_VOLUMENAME = 2<<0;
+const long BUDB_OP_TAPENAME   = 3<<0;
+
+/* "start" is a time value */
+const long BUDB_OP_STARTTIME  = 1<<3;
+/* "end" delimits a range of times */
+const long BUDB_OP_RANGE      = 1<<6;
+/* "end" specifies number of earlier entries */
+const long BUDB_OP_NPREVIOUS  = 2<<6;
+/* "end" specifies number of later entries */
+const long BUDB_OP_NFOLLOWING = 3<<6;
+/* start is dump id (name may be null), return all entries */
+const long BUDB_OP_DUMPID     = 2<<3;
+/* defining the which type of time values */
+const long BUDB_OP_CLONETIME  = 1<<9;	/* use clone time */
+const long BUDB_OP_DUMPTIME   = 2<<9;	/* use dump time (create?) */
+const long BUDB_OP_INCTIME    = 3<<9;	/* use inc time */
+
+/* Miscellaneous bits: */
+/* for volumes: return only first fragment */
+const long BUDB_OP_FIRSTFRAG  = 1<<16;
+/* maximum number of elements returnable by these functions */
+const long BUDB_MAX_RETURN_LIST = 1000;
+const long BUDB_MAX_CHAR_LIST = 1024;
+
+/* maximum number of volumes accepted by these functions */
+const long BUDB_MAX_VOL_COUNT = 64;
+
+const long BUDB_TEXT_COMPLETE	= 1;
+/* structure type values for database dump and restore operations */
+/* XXX -- these names need a better prefix */
+const long	SD_DBHEADER		= 1;
+const long	SD_DUMP			= 2;
+const long	SD_TAPE			= 3;
+const long	SD_VOLUME		= 4;
+const long	SD_TEXT_DUMPSCHEDULE	= 5;
+const long	SD_TEXT_VOLUMESET	= 6;
+const long	SD_TEXT_TAPEHOSTS	= 7;
+const long	SD_END			= 8;
+
+/* 
+ * Now, the bakserver data structure type definitions
+ */
+
+/*
+ * A generic string type for backup
+ */
+
+typedef struct { 	/* identifies a principal identity */
+    budbNameString_t name;
+    budbNameString_t instance;
+    budbNameString_t cell;
+    budbNameString_t spare;
+    uint32 spare1;			/* nominal spares */
+    uint32 spare2;			/* nominal spares */
+    uint32 spare3;			/* nominal spares */
+    uint32 spare4;			/* nominal spares */
+} budb_principal;
+
+typedef struct { 		/* describes a tape sequence */
+    int32  id;			/* id of tapeSet, assigned by budb */
+    budbNameString_t  tapeServer;
+    budbNameString_t  format;
+    /* Sequence numbers are assumed to be relatively small and relatively
+     * densely packed in 0<=seq<maxTapes. */
+    int32  maxTapes;			/* maximum number of tapes in seq. */
+    int32  a; int32 b;		/* linear transforms for tape */
+    uint32 spare1;			/* nominal spares */
+    uint32 spare2;			/* nominal spares */
+    uint32 spare3;			/* nominal spares */
+    uint32 spare4;			/* nominal spares */
+} budb_tapeSet;
+
+typedef struct { 	/* describes a dump */
+    uint32 id;				/* identifier of this dump */
+    uint32 parent;			/* parent dump */
+    int32   level;			/* level in multi-level incremental */
+    int32  flags;			/* various bits described below */
+    budbNameString_t  volumeSetName;
+    budbNameString_t  dumpPath;
+    budbNameString_t  name;
+    time_t  created;			/* creation date of dump */
+    time_t  incTime;			/* time for incrementals, 0 => full */
+    int32   nVolumes;		/* number of vol fragments in dump */
+    budb_tapeSet tapes;		        /* tapes containing dump */
+    budb_principal dumper;	        /* name of person running doing dump */
+    uint32 spare1;			/* nominal spares */
+    uint32 spare2;			/* nominal spares */
+    uint32 spare3;			/* nominal spares */
+    uint32 spare4;			/* nominal spares */
+} budb_dumpEntry;
+
+typedef struct { /* describes a tape */
+    budbNameString_t  name;
+    uint32  flags;			/* various bits described below */
+    time_t  written;			/* date tape was last written */
+    time_t  expires;                      /* expiration date */
+    uint32  nMBytes;		/* number of Mbytes on tape */
+    uint32  nBytes;			/* Megabyte remainder */
+    int32  nFiles;			/* number of files on tape */
+    int32   nVolumes;		/* number of vol fragments on tape */
+    int32   seq;			/* sequence in tape set */
+    int32  tapeid;			/* unique tape id */
+    int32  useCount;			/* # of times used */
+    int32  mediaType;                /* what kind of tape */
+    uint32 dump;			/* dump on tape (set) */
+    uint32 spare1;			/* nominal spares */
+    uint32 spare2;			/* nominal spares */
+    uint32 spare3;			/* nominal spares */
+    uint32 spare4;			/* nominal spares */
+} budb_tapeEntry;
+
+typedef struct { /* describes a fragment of a volume */
+
+    /* volume information */
+    budbNameString_t  name;
+    uint32  flags;			/* various bits described below */
+    udlong id;			/* volume uid */
+    budbNameString_t  server;
+    int32  partition;		/* partition on server */
+    int32  nFrags;			/* number fragments in whole volume */
+    /* per fragment */
+    int32  position;			/* position on tape */
+    time_t  clone;			/* time volume was cloned for dump */
+    time_t  incTime;			/* NOT USED */
+    int32  startByte;		/* first byte of volume in this frag */
+    int32  nBytes;			/* number of bytes in this frag */
+    int32   seq;			/* sequence of frag in volume */
+    /* additional location info */
+    uint32 dump;			/* dump volume is part of */
+    budbNameString_t tape;
+    uint32 spare1;			/* nominal spares */
+    uint32 spare2;			/* nominal spares */
+    uint32 spare3;			/* nominal spares */
+    uint32 spare4;			/* nominal spares */
+} budb_volumeEntry;
+
+/* To facilitate returning large large amounts of data some of these procedures
+   expect to receive a pointer to an array of structures.  The majorVersion
+   number implicitly specifies the size of each array element.  The progress
+   parameter is set to the number of elements actually returned.  Since the
+   caller may have limited buffer space, provisions are made to get the data in
+   a series of calls.  The index parameter specifies starting point of a
+   continued operation: for the first call it will be zero, a negative number
+   will produce an error.  If more elements are available on a subsequent call
+   nextIndex is set to the index of the next element.  Otherwise nextIndex is
+   set to a negative number. */
+
+typedef struct {
+    uint32 budb_volumeList_len; 
+    [size_is(budb_volumeList_len),ptr] budb_volumeEntry budb_volumeList_val[*];
+} budb_volumeList;
+
+typedef struct {
+    uint32 budb_dumpList_len;  
+    [size_is(budb_dumpList_len),ptr] budb_dumpEntry budb_dumpList_val[*];
+} budb_dumpList;
+
+typedef struct {
+    uint32 budb_tapeList_len;  
+    [size_is(budb_tapeList_len),ptr] budb_tapeEntry budb_tapeList_val[*];
+} budb_tapeList;
+
+typedef struct {
+    uint32 charListT_len;
+    [length_is(charListT_len)] uint8 charListT_val[1024];
+} charListT;
+
+/* database header - minimal version that is dumped. Allows values of important
+ *	state variables to be saved/restored.
+ */
+/* XXX -- this name needs a budb_ prefix */
+typedef struct {
+    int32 dbversion;			/* database version */
+    int32 created;			/* creation time */
+    budbNameString_t cell;
+    uint32 lastDumpId;			/* last dump id generated */
+    uint32 lastInstanceId;		/* last lock instance */
+    uint32 lastTapeId;		/* last tape id */
+    uint32 spare1;
+    uint32 spare2;
+    uint32 spare3;
+    uint32 spare4;
+} DbHeader;
+
+/* The structure is a version of budb_volumeEntry with the layout of the volume
+ * id hyper explicitly specified. */
+
+typedef struct { /* describes a volume in a database dump */
+    /* volume information */
+    budbNameString_t  name;
+    uint32  flags;			/* various bits described below */
+    udlong id;
+    budbNameString_t  server;
+    int32  partition;		/* partition on server */
+    int32  nFrags;			/* number fragments in whole volume */
+    /* per fragment */
+    int32  position;			/* position on tape */
+    time_t  clone;			/* time volume was cloned for dump */
+    time_t  incTime;			/* NOT USED */
+    int32  startByte;		/* first byte of volume in this frag */
+    int32  nBytes;			/* number of bytes in this frag */
+    int32   seq;			/* sequence of frag in volume */
+    /* additional location info */
+    uint32 dump;			/* dump volume is part of */
+    budbNameString_t tape;
+    uint32 spare1;			/* nominal spares */
+    uint32 spare2;			/* nominal spares */
+    uint32 spare3;			/* nominal spares */
+    uint32 spare4;			/* nominal spares */
+} budb_dbVolume;
+
+/* Header prefix for each structure in the byte stream returned by BUDB_DumpDB.
+ * The type field identifies the structure that follows --
+ *     SD_DBHEADER -- DbHeader
+ *     SD_DUMP -- budb_dumpEntry
+ *     SD_TAPE -- budb_tapeEntry
+ *     SD_VOLUME -- budb_dbVolume_t
+ *     SD_TEXT_DUMPSCHEDULE -- ???
+ *     SD_TEXT_VOLUMESET -- ???
+ *     SD_TEXT_TAPEHOSTS -- ???
+ *     SD_END -- end of database */
+
+/* XXX -- this name needs a budb_ prefix */
+typedef struct {
+  int32 type;			/* structure type */
+  int32 structversion;		/* version of following structure */
+  int32 size;    			/* bytes in following structure */
+  uint32 spare1;
+  uint32 spare2;
+  uint32 spare3;
+  uint32 spare4;
+} structDumpHeader;
+
+/*
+ * Bakserver interface procedure declarations 
+ */
+/* This adds a volume to particular dump and tape.  It is called after the
+   volume has been written to tape and allows the database to attach the volume
+   information to the structures for its containing dump and tape.  The
+   description of the volume must be specified on input, including the vldb
+   information, incTime, and a description of the volume's fragmention. */
+/*
+ * provider_version(1)
+ */
+WERROR AddVolume
+(
+ [ref, in] budb_volumeEntry *vol
+);
+
+/* This creates a new dump.  On input the dumpEntry specifies the containing
+   tape set, the dump name, the incTime, and the identity of the dumper.  On
+   output the dump's id is set. */
+
+/*
+ * provider_version(1)
+ */
+WERROR CreateDump
+(
+ [ref, in, out] budb_dumpEntry *dump
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR DeleteDump 
+(
+ [in] uint32 id 
+);
+
+/* This is called, probably infrequently, to remove a tape from the database.
+   The assumption is that sometimes tapes are retired or lost and this routine
+   facilitates cleaning up the database. */
+
+/*
+ * provider_version(1)
+ */
+WERROR DeleteTape
+(
+ [ref, in] budb_tapeEntry *tape
+);	/* tape info */
+
+/*
+ * provider_version(1)
+ */
+WERROR DeleteVDP
+(  
+   [in] budbNameString_t *dsname,	/* dump name */
+   [in] budbNameString_t *dumpPath,	/* dump node path name */
+   [in] int32 curDumpId		/* current dump Id for exclusion */
+);			
+
+/*
+ * provider_version(1)
+ */
+WERROR FindClone
+(  
+   [in] int32 dumpID,		/* id of dump to start with */
+   [in] budbNameString_t *volName,	/* clone time required for volName */
+   [ref, out] uint32  *clonetime,  	/* returned clone time */
+   [ref, out] uint32  *cloneSpare
+);		
+
+/*
+ * provider_version(1)
+ */
+WERROR FindDump
+(  
+   [in] budbNameString_t *volName,	/* name of volume to look for */
+   [in] uint32 beforeDate,		/* must be before this date */
+   [in] uint32 dateSpare,
+   [ref, out] budb_dumpEntry *deptr	/* returned dump information */
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR FindLatestDump
+(
+  [in] budbNameString_t *vsname,		/* name of volumeset to look for */
+  [in] budbNameString_t *dname, 		/* name of dump to look for */
+  [ref, out] budb_dumpEntry *dumpentry
+);
+
+/* This notifies the database that the dump is finished.  Some status bits can
+   be specified on input. */
+
+/*
+ * provider_version(1)
+ */
+WERROR FinishDump
+(
+   [ref, in, out] budb_dumpEntry *dump
+);
+
+/* This is called when writing to the tape has been completed.  The tapeEntry
+   includes some status bits on input, such as whether any tape errors were
+   encountered.  Volumes and dumps on the tape are marked as safe if the status
+   was good. */
+
+/*
+ * provider_version(1)
+ */
+WERROR FinishTape
+(
+  [ref, in] budb_tapeEntry *tape
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR GetDumps
+(
+  [in]  int32  majorVersion,		/* version of interface structures */
+  [in]  int32  flags,		/* search & select controls */
+  [in]  budbNameString_t *name,		/* s&s parameters */
+  [in]  int32  start,
+  [in]  int32  end,
+  [in]  int32  index,		/* start index of returned entries */
+  [ref, out] int32 *nextIndex,	/* output index for next call */
+  [ref, out] int32 *dbUpdate,	/* time of last db change */
+  [out] budb_dumpList **dumps      	/* structure list */
+);	
+
+/*
+ * provider_version(1)
+ */
+WERROR GetTapes
+(
+  [in]  int32   majorVersion,	/* version of interface structures */
+  [in]  int32  flags,		/* search & select controls */
+  [in]  budbNameString_t *name,	        /* s&s parameters */
+  [in]  int32  start,
+  [in]  int32  end,			/* reserved: MBZ */
+  [in]  int32  index,		/* start index of returned entries */
+  [ref, out] int32 *nextIndex,	/* output index for next call */
+  [ref, out] int32 *dbUpdate,	/* time of last db change */
+  [out] budb_tapeList **tapes		/* structure list */
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR GetVolumes
+(
+  [in]  int32   majorVersion,	/* version of interface structures */
+  [in]  int32  flags,		/* search & select controls */
+  [in]  budbNameString_t *name,	        /*  - parameters for search */
+  [in]  int32  start,		/*  - usage depends which BUDP_OP_* */
+  [in]  int32  end,			/*  - bits are set */
+  [in]  int32  index,		/* start index of returned entries */
+  [ref, out] int32 *nextIndex,	/* output index for next call */
+  [ref, out] int32 *dbUpdate,	/* time of last db change */
+  [out] budb_volumeList **volumes	/* structure list */
+);
+
+/* Called when a tape is about to be used.  It deletes from the database the
+   previous contents of the tape, if any, and marks it as "being written".  The
+   tapeEntry identifies the tape name and dump on input.  The updated entry is
+   returned on output. */
+
+/*
+ * provider_version(1)
+ */
+WERROR UseTape
+(
+  [ref, in] budb_tapeEntry *tape,	/* tape info */
+  [ref, out] int32  *new		/* set if tape is new */
+);
+
+/* text file management calls - alphabetic */
+
+/*
+ * provider_version(1)
+ */
+WERROR GetText
+(
+  [in]  int32 lockHandle,
+  [in]  int32 textType,			/* which type of text */
+  [in]  int32 maxLength,
+  [in] 	int32 offset,
+  [ref, out] int32 *nextOffset,
+  [ref, out] charListT *charListPtr 
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR GetTextVersion
+(
+  [in]  int32 textType,
+  [ref, out] int32 *tversion
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR SaveText
+(
+  [in]  int32 lockHandle,			/* which type of text */
+  [in]  int32 textType,			/* which type of text */
+  [in]	int32 offset,			/* offset into text block */
+  [in]  int32 flags,
+  [ref, in]  charListT *charListPtr	
+);
+
+/* Lock management interface routines */
+
+/*
+ * provider_version(1)
+ */
+WERROR FreeAllLocks
+(
+   [in] uint32 instanceId 			/* identifies user */ 
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR FreeLock
+(
+   [in] uint32 lockHandle			/* identifies lock */
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR GetInstanceId
+(
+   [ref, out] uint32 *instanceId     	/* instance of a user */
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR GetLock
+(
+   [in]	 uint32 instanceId,			/* instance of user */
+   [in]	 int32 lockName,			/* which lock */
+   [in]	 int32 expiration,			/* # secs after which lock 
+						   released */
+   [ref, out] uint32 *lockHandle		/* returned lock handle */
+);
+
+/* database dump and reconstruction */
+
+/*
+ * provider_version(1)
+ */
+WERROR DbVerify
+(
+   [ref, out] int32 *status,			/* 0=ok, 1=inconsistent */
+   [ref, out] int32 *orphans,		/* orphan block count */
+   [ref, out] int32 *host		       	/* host where checks done */
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR DumpDB
+(
+   [in]	 int32 maxLength,			/* max transfer size */
+   [ref, out] int32	*flags, 		/* status flags */
+   [ref, out] charListT *charListPtr		/* byte stream out */ 
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR RestoreDbHeader
+(
+   [ref, in] DbHeader *header 			/* restore database header */
+);
+
+/* Debug and test interface routines
+ *
+ * These routines provide a low level interface that can be used to test out
+ * the backup database.
+ */
+
+/*
+ * provider_version(1)
+ */
+WERROR T_GetVersion
+(
+   [ref, out] int32 *majorVersion
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR T_DumpHashTable 
+(
+   [in] int32 type, 
+   [in] budbNameString_t *filename
+);
+
+/*
+ * provider_version(1)
+ */
+WERROR T_DumpDatabase 
+(
+  [in] budbNameString_t *filename
+);
+
+/*
+ * provider_version(1)
+ */
+
+
+typedef struct {
+
+	uuid_t      interface_uuid;  /* i/f UUID of the supported i/f */
+	uint16  vers_major;      /* i/f major version number */
+	uint16  vers_minor;      /* i/f minor version number */
+	uint32  vers_provider;   /* provider_version number */
+
+	uint32 spare0;	/* some long spares */
+	uint32 spare1;
+	uint32 spare2;
+	uint32 spare3;
+	uint32 spare4;
+	uint32 spare5;
+	uint32 spare6;
+	uint32 spare7;
+	uint32 spare8;
+	uint32 spare9;
+
+	uint8 spareText[50]; /* spare text */
+
+} dfs_interfaceDescription;
+
+typedef struct {
+
+	uint32 dfs_interfaceList_len;
+	[length_is(dfs_interfaceList_len)] dfs_interfaceDescription dfs_interfaceList_val;
+
+} dfs_interfaceList;
+
+
+WERROR GetServerInterfaces
+(
+  [ref, in, out] dfs_interfaceList *serverInterfacesP
+);
+
+/*
+ * Same as AddVolume, except takes array of volumes instead of
+ * single volume
+ */
+
+/*
+ * provider_version(2)
+ */
+
+WERROR AddVolumes
+(
+ [in] uint32 cnt,
+ [in, size_is(cnt)] budb_volumeEntry vol[]
+);
+}
diff --git a/epan/dissectors/dcerpc/budb/template.c b/epan/dissectors/dcerpc/budb/template.c
new file mode 100755
index 0000000000..0386893a8e
--- /dev/null
+++ b/epan/dissectors/dcerpc/budb/template.c
@@ -0,0 +1,85 @@
+/* DO NOT EDIT
+ * This dissector is autogenerated
+ */
+
+/* packet-dcerpc-budb.c
+ * Routines for BUDB packet disassembly
+ *   ronnie sahlberg 2005
+ *
+ * $Id: packet-dcerpc-budb.c 11592 2004-08-03 02:28:49Z guy $
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@ethereal.com>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib.h>
+#include <string.h>
+
+#include <epan/packet.h>
+#include "packet-dcerpc.h"
+#include "packet-dcerpc-nt.h"
+#include "packet-windows-common.h"
+#include "packet-dcerpc-budb.h"
+
+static int proto_budb = -1;
+ETH_HF
+
+ETH_ETT
+
+static int
+budb_dissect_NameString_t(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, 1, hf_index, FALSE, NULL);
+    return offset;
+}
+
+ETH_CODE
+
+void
+proto_register_budb(void)
+{
+        static hf_register_info hf[] = {
+
+ETH_HFARR
+	};
+
+        static gint *ett[] = {
+ETH_ETTARR
+        };
+
+        proto_budb = proto_register_protocol(
+                "DCE/DFS BUDB", 
+		"BUDB", "budb");
+	proto_register_field_array(proto_budb, hf, array_length(hf));
+        proto_register_subtree_array(ett, array_length(ett));
+}
+
+static dcerpc_sub_dissector function_dissectors[] = {
+ETH_FT
+	{ 0, NULL, NULL, NULL },
+};
+
+void
+proto_reg_handoff_budb(void)
+{
+ETH_HANDOFF
+}
diff --git a/epan/dissectors/dcerpc/budb/template.h b/epan/dissectors/dcerpc/budb/template.h
new file mode 100755
index 0000000000..99eb800220
--- /dev/null
+++ b/epan/dissectors/dcerpc/budb/template.h
@@ -0,0 +1,34 @@
+/* DO NOT EDIT
+ * This dissector is autogenerated
+ *   ronnie sahlberg 2005
+ */
+/* packet-dcerpc-budb.h
+ * Routines for BUDB packet disassembly
+ *
+ * $Id: packet-dcerpc-budb.h 11410 2004-07-18 18:06:47Z gram $
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@ethereal.com>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef __PACKET_DCERPC_BUDB_H
+#define __PACKET_DCERPC_BUDB_H
+
+ETH_HDR
+
+#endif /* packet-dcerpc-budb.h */
diff --git a/epan/dissectors/packet-dcerpc-budb.c b/epan/dissectors/packet-dcerpc-budb.c
index 002e06cf0c..a91d452851 100644
--- a/epan/dissectors/packet-dcerpc-budb.c
+++ b/epan/dissectors/packet-dcerpc-budb.c
@@ -1,11 +1,13 @@
+/* DO NOT EDIT
+ * This dissector is autogenerated
+ */
+
 /* packet-dcerpc-budb.c
- * Routines for budb dissection
- * Copyright 2002, Jaime Fournier <Jaime.Fournier@hush.com>
- * This information is based off the released idl files from opengroup.
- * ftp://ftp.opengroup.org/pub/dce122/dce/src/file.tar.gz bubasics/budb.idl
+ * Routines for BUDB packet disassembly
+ *   ronnie sahlberg 2005
  *
  * $Id$
- *      
+ *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
@@ -29,79 +31,4852 @@
 #include "config.h"
 #endif
 
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
+#include <glib.h>
 #include <string.h>
 
-#include <glib.h>
 #include <epan/packet.h>
 #include "packet-dcerpc.h"
+#include "packet-dcerpc-nt.h"
+#include "packet-windows-common.h"
+#include "packet-dcerpc-budb.h"
 
 static int proto_budb = -1;
+
+
+/* INCLUDED FILE : ETH_HF */
 static int hf_budb_opnum = -1;
+static int hf_budb_rc = -1;
+static int hf_budb_principal_name = -1;
+static int hf_budb_principal_instance = -1;
+static int hf_budb_principal_cell = -1;
+static int hf_budb_principal_spare = -1;
+static int hf_budb_principal_spare1 = -1;
+static int hf_budb_principal_spare2 = -1;
+static int hf_budb_principal_spare3 = -1;
+static int hf_budb_principal_spare4 = -1;
+static int hf_budb_tapeSet_id = -1;
+static int hf_budb_tapeSet_tapeServer = -1;
+static int hf_budb_tapeSet_format = -1;
+static int hf_budb_tapeSet_maxTapes = -1;
+static int hf_budb_tapeSet_a = -1;
+static int hf_budb_tapeSet_b = -1;
+static int hf_budb_tapeSet_spare1 = -1;
+static int hf_budb_tapeSet_spare2 = -1;
+static int hf_budb_tapeSet_spare3 = -1;
+static int hf_budb_tapeSet_spare4 = -1;
+static int hf_budb_dumpEntry_id = -1;
+static int hf_budb_dumpEntry_parent = -1;
+static int hf_budb_dumpEntry_level = -1;
+static int hf_budb_dumpEntry_flags = -1;
+static int hf_budb_dumpEntry_volumeSetName = -1;
+static int hf_budb_dumpEntry_dumpPath = -1;
+static int hf_budb_dumpEntry_name = -1;
+static int hf_budb_dumpEntry_created = -1;
+static int hf_budb_dumpEntry_incTime = -1;
+static int hf_budb_dumpEntry_nVolumes = -1;
+static int hf_budb_dumpEntry_tapes = -1;
+static int hf_budb_dumpEntry_dumper = -1;
+static int hf_budb_dumpEntry_spare1 = -1;
+static int hf_budb_dumpEntry_spare2 = -1;
+static int hf_budb_dumpEntry_spare3 = -1;
+static int hf_budb_dumpEntry_spare4 = -1;
+static int hf_budb_tapeEntry_name = -1;
+static int hf_budb_tapeEntry_flags = -1;
+static int hf_budb_tapeEntry_written = -1;
+static int hf_budb_tapeEntry_expires = -1;
+static int hf_budb_tapeEntry_nMBytes = -1;
+static int hf_budb_tapeEntry_nBytes = -1;
+static int hf_budb_tapeEntry_nFiles = -1;
+static int hf_budb_tapeEntry_nVolumes = -1;
+static int hf_budb_tapeEntry_seq = -1;
+static int hf_budb_tapeEntry_tapeid = -1;
+static int hf_budb_tapeEntry_useCount = -1;
+static int hf_budb_tapeEntry_mediaType = -1;
+static int hf_budb_tapeEntry_dump = -1;
+static int hf_budb_tapeEntry_spare1 = -1;
+static int hf_budb_tapeEntry_spare2 = -1;
+static int hf_budb_tapeEntry_spare3 = -1;
+static int hf_budb_tapeEntry_spare4 = -1;
+static int hf_budb_volumeEntry_name = -1;
+static int hf_budb_volumeEntry_flags = -1;
+static int hf_budb_volumeEntry_id = -1;
+static int hf_budb_volumeEntry_server = -1;
+static int hf_budb_volumeEntry_partition = -1;
+static int hf_budb_volumeEntry_nFrags = -1;
+static int hf_budb_volumeEntry_position = -1;
+static int hf_budb_volumeEntry_clone = -1;
+static int hf_budb_volumeEntry_incTime = -1;
+static int hf_budb_volumeEntry_startByte = -1;
+static int hf_budb_volumeEntry_nBytes = -1;
+static int hf_budb_volumeEntry_seq = -1;
+static int hf_budb_volumeEntry_dump = -1;
+static int hf_budb_volumeEntry_tape = -1;
+static int hf_budb_volumeEntry_spare1 = -1;
+static int hf_budb_volumeEntry_spare2 = -1;
+static int hf_budb_volumeEntry_spare3 = -1;
+static int hf_budb_volumeEntry_spare4 = -1;
+static int hf_budb_volumeList_volumeList_len = -1;
+static int hf_budb_volumeList_volumeList_val = -1;
+static int hf_budb_dumpList_dumpList_len = -1;
+static int hf_budb_dumpList_dumpList_val = -1;
+static int hf_budb_tapeList_tapeList_len = -1;
+static int hf_budb_tapeList_tapeList_val = -1;
+static int hf_budb_charListT_charListT_len = -1;
+static int hf_budb_charListT_charListT_val = -1;
+static int hf_budb_DbHeader_dbversion = -1;
+static int hf_budb_DbHeader_created = -1;
+static int hf_budb_DbHeader_cell = -1;
+static int hf_budb_DbHeader_lastDumpId = -1;
+static int hf_budb_DbHeader_lastInstanceId = -1;
+static int hf_budb_DbHeader_lastTapeId = -1;
+static int hf_budb_DbHeader_spare1 = -1;
+static int hf_budb_DbHeader_spare2 = -1;
+static int hf_budb_DbHeader_spare3 = -1;
+static int hf_budb_DbHeader_spare4 = -1;
+static int hf_budb_dbVolume_name = -1;
+static int hf_budb_dbVolume_flags = -1;
+static int hf_budb_dbVolume_id = -1;
+static int hf_budb_dbVolume_server = -1;
+static int hf_budb_dbVolume_partition = -1;
+static int hf_budb_dbVolume_nFrags = -1;
+static int hf_budb_dbVolume_position = -1;
+static int hf_budb_dbVolume_clone = -1;
+static int hf_budb_dbVolume_incTime = -1;
+static int hf_budb_dbVolume_startByte = -1;
+static int hf_budb_dbVolume_nBytes = -1;
+static int hf_budb_dbVolume_seq = -1;
+static int hf_budb_dbVolume_dump = -1;
+static int hf_budb_dbVolume_tape = -1;
+static int hf_budb_dbVolume_spare1 = -1;
+static int hf_budb_dbVolume_spare2 = -1;
+static int hf_budb_dbVolume_spare3 = -1;
+static int hf_budb_dbVolume_spare4 = -1;
+static int hf_budb_structDumpHeader_type = -1;
+static int hf_budb_structDumpHeader_structversion = -1;
+static int hf_budb_structDumpHeader_size = -1;
+static int hf_budb_structDumpHeader_spare1 = -1;
+static int hf_budb_structDumpHeader_spare2 = -1;
+static int hf_budb_structDumpHeader_spare3 = -1;
+static int hf_budb_structDumpHeader_spare4 = -1;
+static int hf_budb_AddVolume_vol = -1;
+static int hf_budb_CreateDump_dump = -1;
+static int hf_budb_DeleteDump_id = -1;
+static int hf_budb_DeleteTape_tape = -1;
+static int hf_budb_DeleteVDP_dsname = -1;
+static int hf_budb_DeleteVDP_dumpPath = -1;
+static int hf_budb_DeleteVDP_curDumpId = -1;
+static int hf_budb_FindClone_dumpID = -1;
+static int hf_budb_FindClone_volName = -1;
+static int hf_budb_FindClone_clonetime = -1;
+static int hf_budb_FindClone_cloneSpare = -1;
+static int hf_budb_FindDump_volName = -1;
+static int hf_budb_FindDump_beforeDate = -1;
+static int hf_budb_FindDump_dateSpare = -1;
+static int hf_budb_FindDump_deptr = -1;
+static int hf_budb_FindLatestDump_vsname = -1;
+static int hf_budb_FindLatestDump_dname = -1;
+static int hf_budb_FindLatestDump_dumpentry = -1;
+static int hf_budb_FinishDump_dump = -1;
+static int hf_budb_FinishTape_tape = -1;
+static int hf_budb_GetDumps_majorVersion = -1;
+static int hf_budb_GetDumps_flags = -1;
+static int hf_budb_GetDumps_name = -1;
+static int hf_budb_GetDumps_start = -1;
+static int hf_budb_GetDumps_end = -1;
+static int hf_budb_GetDumps_index = -1;
+static int hf_budb_GetDumps_nextIndex = -1;
+static int hf_budb_GetDumps_dbUpdate = -1;
+static int hf_budb_GetDumps_dumps = -1;
+static int hf_budb_GetTapes_majorVersion = -1;
+static int hf_budb_GetTapes_flags = -1;
+static int hf_budb_GetTapes_name = -1;
+static int hf_budb_GetTapes_start = -1;
+static int hf_budb_GetTapes_end = -1;
+static int hf_budb_GetTapes_index = -1;
+static int hf_budb_GetTapes_nextIndex = -1;
+static int hf_budb_GetTapes_dbUpdate = -1;
+static int hf_budb_GetTapes_tapes = -1;
+static int hf_budb_GetVolumes_majorVersion = -1;
+static int hf_budb_GetVolumes_flags = -1;
+static int hf_budb_GetVolumes_name = -1;
+static int hf_budb_GetVolumes_start = -1;
+static int hf_budb_GetVolumes_end = -1;
+static int hf_budb_GetVolumes_index = -1;
+static int hf_budb_GetVolumes_nextIndex = -1;
+static int hf_budb_GetVolumes_dbUpdate = -1;
+static int hf_budb_GetVolumes_volumes = -1;
+static int hf_budb_UseTape_tape = -1;
+static int hf_budb_UseTape_new = -1;
+static int hf_budb_GetText_lockHandle = -1;
+static int hf_budb_GetText_textType = -1;
+static int hf_budb_GetText_maxLength = -1;
+static int hf_budb_GetText_offset = -1;
+static int hf_budb_GetText_nextOffset = -1;
+static int hf_budb_GetText_charListPtr = -1;
+static int hf_budb_GetTextVersion_textType = -1;
+static int hf_budb_GetTextVersion_tversion = -1;
+static int hf_budb_SaveText_lockHandle = -1;
+static int hf_budb_SaveText_textType = -1;
+static int hf_budb_SaveText_offset = -1;
+static int hf_budb_SaveText_flags = -1;
+static int hf_budb_SaveText_charListPtr = -1;
+static int hf_budb_FreeAllLocks_instanceId = -1;
+static int hf_budb_FreeLock_lockHandle = -1;
+static int hf_budb_GetInstanceId_instanceId = -1;
+static int hf_budb_GetLock_instanceId = -1;
+static int hf_budb_GetLock_lockName = -1;
+static int hf_budb_GetLock_expiration = -1;
+static int hf_budb_GetLock_lockHandle = -1;
+static int hf_budb_DbVerify_status = -1;
+static int hf_budb_DbVerify_orphans = -1;
+static int hf_budb_DbVerify_host = -1;
+static int hf_budb_DumpDB_maxLength = -1;
+static int hf_budb_DumpDB_flags = -1;
+static int hf_budb_DumpDB_charListPtr = -1;
+static int hf_budb_RestoreDbHeader_header = -1;
+static int hf_budb_T_GetVersion_majorVersion = -1;
+static int hf_budb_T_DumpHashTable_type = -1;
+static int hf_budb_T_DumpHashTable_filename = -1;
+static int hf_budb_T_DumpDatabase_filename = -1;
+static int hf_budb_dfs_interfaceDescription_interface_uuid = -1;
+static int hf_budb_dfs_interfaceDescription_vers_major = -1;
+static int hf_budb_dfs_interfaceDescription_vers_minor = -1;
+static int hf_budb_dfs_interfaceDescription_vers_provider = -1;
+static int hf_budb_dfs_interfaceDescription_spare0 = -1;
+static int hf_budb_dfs_interfaceDescription_spare1 = -1;
+static int hf_budb_dfs_interfaceDescription_spare2 = -1;
+static int hf_budb_dfs_interfaceDescription_spare3 = -1;
+static int hf_budb_dfs_interfaceDescription_spare4 = -1;
+static int hf_budb_dfs_interfaceDescription_spare5 = -1;
+static int hf_budb_dfs_interfaceDescription_spare6 = -1;
+static int hf_budb_dfs_interfaceDescription_spare7 = -1;
+static int hf_budb_dfs_interfaceDescription_spare8 = -1;
+static int hf_budb_dfs_interfaceDescription_spare9 = -1;
+static int hf_budb_dfs_interfaceDescription_spareText = -1;
+static int hf_budb_dfs_interfaceList_dfs_interfaceList_len = -1;
+static int hf_budb_dfs_interfaceList_dfs_interfaceList_val = -1;
+static int hf_budb_GetServerInterfaces_serverInterfacesP = -1;
+static int hf_budb_AddVolumes_cnt = -1;
+static int hf_budb_AddVolumes_vol = -1;
+/* END OF INCLUDED FILE : ETH_HF */
+
 
 
+
+
+/* INCLUDED FILE : ETH_ETT */
 static gint ett_budb = -1;
+static gint ett_budb_principal = -1;
+static gint ett_budb_tapeSet = -1;
+static gint ett_budb_dumpEntry = -1;
+static gint ett_budb_tapeEntry = -1;
+static gint ett_budb_volumeEntry = -1;
+static gint ett_budb_volumeList = -1;
+static gint ett_budb_dumpList = -1;
+static gint ett_budb_tapeList = -1;
+static gint ett_budb_charListT = -1;
+static gint ett_budb_DbHeader = -1;
+static gint ett_budb_dbVolume = -1;
+static gint ett_budb_structDumpHeader = -1;
+static gint ett_budb_dfs_interfaceDescription = -1;
+static gint ett_budb_dfs_interfaceList = -1;
+/* END OF INCLUDED FILE : ETH_ETT */
+
 
-static e_uuid_t uuid_budb = { 0xeb814e2a, 0x0099, 0x11ca, { 0x86, 0x78, 0x02, 0x60, 0x8c, 0x2e, 0xa9, 0x6e } };
-static guint16  ver_budb = 4;
-
-
-static dcerpc_sub_dissector budb_dissectors[] = {
-{ 0, "AddVolume", NULL, NULL },
-{ 1, "CreateDump", NULL, NULL },
-{ 2, "DeleteDump", NULL, NULL },
-{ 3, "DeleteTape", NULL, NULL },
-{ 4, "DeleteVDP", NULL, NULL },
-{ 5, "FindClone", NULL, NULL },
-{ 6, "FindDump", NULL, NULL },
-{ 7, "FindLatestDump", NULL, NULL },
-{ 8, "FinishDump", NULL, NULL },
-{ 9, "FinishTape", NULL, NULL },
-{ 10, "GetDumps", NULL, NULL },
-{ 11, "GetTapes", NULL, NULL },
-{ 12, "GetVolumes", NULL, NULL },
-{ 13, "UseTape", NULL, NULL },
-{ 14, "GetText", NULL, NULL },
-{ 15, "GetTextVersion", NULL, NULL },
-{ 16, "SaveText", NULL, NULL },
-{ 17, "FreeAllLocks", NULL, NULL },
-{ 18, "FreeLock", NULL, NULL },
-{ 19, "GetInstanceId", NULL, NULL },
-{ 20, "GetLock", NULL, NULL },
-{ 21, "DbVerify", NULL, NULL },
-{ 22, "DumpDB", NULL, NULL },
-{ 23, "RestoreDbHeader", NULL, NULL },
-{ 24, "T_GetVersion", NULL, NULL },
-{ 25, "T_DumpHashTable", NULL, NULL },
-{ 26, "T_DumpDatabase", NULL, NULL },
-{ 27, "GetServerInterfaces", NULL, NULL },
-{ 28, "AddVolumes", NULL, NULL },
-	{ 0, NULL, NULL, NULL }
+
+static int
+budb_dissect_NameString_t(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, 1, hf_index, FALSE, NULL);
+    return offset;
+}
+
+
+
+/* INCLUDED FILE : ETH_CODE */
+static e_uuid_t uuid_dcerpc_budb = {
+    0xeb814e2a, 0x0099, 0x11ca,
+    { 0x86, 0x78, 0x02, 0x60, 0x8c, 0x2e, 0xa9, 0x6e}
 };
 
+static guint16 ver_budb = 4;
+
+static int
+budb_dissect_principal_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_principal_name, param);
+    return offset;
+}
+
+static int
+budb_dissect_principal_instance(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_principal_instance, param);
+    return offset;
+}
+
+static int
+budb_dissect_principal_cell(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_principal_cell, param);
+    return offset;
+}
+
+static int
+budb_dissect_principal_spare(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_principal_spare, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_uint32(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+    return offset;
+}
+
+static int
+budb_dissect_principal_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_principal_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_principal_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_principal_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_principal_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_principal_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_principal_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_principal_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_principal(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_principal);
+    }
+
+    offset=budb_dissect_principal_name(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_instance(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_cell(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_spare(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_principal_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+
+static int
+budb_dissect_int32(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_id, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_tapeServer(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_tapeServer, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_format(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_format, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_maxTapes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_maxTapes, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_a(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_a, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_b(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_b, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeSet_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeSet_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_tapeSet(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_tapeSet);
+    }
+
+    offset=budb_dissect_tapeSet_id(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_tapeServer(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_format(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_maxTapes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_a(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_b(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeSet_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_dumpEntry_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_id, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_parent(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_parent, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_level(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_level, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_volumeSetName(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_volumeSetName, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_dumpPath(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_dumpPath, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_name, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_time_t(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    
+    offset=dissect_ndr_time_t(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_created(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_created, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_incTime(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_incTime, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_nVolumes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_nVolumes, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_tapes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_tapeSet(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_tapes, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_dumper(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_principal(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_dumper, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpEntry_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpEntry_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_dumpEntry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_dumpEntry);
+    }
+
+    offset=budb_dissect_dumpEntry_id(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_parent(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_level(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_flags(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_volumeSetName(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_dumpPath(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_name(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_created(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_incTime(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_nVolumes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_tapes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_dumper(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dumpEntry_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_tapeEntry_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_name, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_written(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_written, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_expires(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_expires, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_nMBytes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_nMBytes, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_nBytes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_nBytes, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_nFiles(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_nFiles, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_nVolumes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_nVolumes, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_seq(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_seq, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_tapeid(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_tapeid, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_useCount(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_useCount, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_mediaType(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_mediaType, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_dump, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeEntry_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeEntry_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_tapeEntry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_tapeEntry);
+    }
+
+    offset=budb_dissect_tapeEntry_name(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_flags(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_written(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_expires(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_nMBytes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_nBytes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_nFiles(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_nVolumes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_seq(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_tapeid(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_useCount(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_mediaType(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_dump(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_tapeEntry_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_volumeEntry_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_name, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_flags, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_udlong(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+
+    offset=dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_udlong(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_id, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_server(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_server, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_partition(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_partition, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_nFrags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_nFrags, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_position(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_position, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_clone(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_clone, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_incTime(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_incTime, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_startByte(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_startByte, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_nBytes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_nBytes, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_seq(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_seq, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_dump, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_tape, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeEntry_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeEntry_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_volumeEntry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_volumeEntry);
+    }
+
+    offset=budb_dissect_volumeEntry_name(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_flags(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_id(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_server(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_partition(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_nFrags(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_position(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_clone(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_incTime(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_startByte(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_nBytes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_seq(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_dump(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_tape(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_volumeEntry_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_volumeList_volumeList_len(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_volumeList_volumeList_len, param);
+    return offset;
+}
+
+static int
+budb_dissect_volumeList_volumeList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_volumeEntry(tvb, offset, pinfo, tree, drep, hf_budb_volumeList_volumeList_val, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_volumeList_volumeList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_volumeList_volumeList_val, NDR_POINTER_PTR, "volumeList_val", -1);
+    return offset;
+}
+
+static int
+ucarray_ptr_budb_dissect_volumeList_volumeList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, drep, ptr_budb_dissect_volumeList_volumeList_val);
+    return offset;
+}
+
+
+int
+budb_dissect_volumeList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_volumeList);
+    }
+
+    offset=budb_dissect_volumeList_volumeList_len(tvb, offset, pinfo, tree, drep);
+
+    offset=ucarray_ptr_budb_dissect_volumeList_volumeList_val(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_dumpList_dumpList_len(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dumpList_dumpList_len, param);
+    return offset;
+}
+
+static int
+budb_dissect_dumpList_dumpList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dumpEntry(tvb, offset, pinfo, tree, drep, hf_budb_dumpList_dumpList_val, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_dumpList_dumpList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_dumpList_dumpList_val, NDR_POINTER_PTR, "dumpList_val", -1);
+    return offset;
+}
+
+static int
+ucarray_ptr_budb_dissect_dumpList_dumpList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, drep, ptr_budb_dissect_dumpList_dumpList_val);
+    return offset;
+}
+
+
+int
+budb_dissect_dumpList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_dumpList);
+    }
+
+    offset=budb_dissect_dumpList_dumpList_len(tvb, offset, pinfo, tree, drep);
+
+    offset=ucarray_ptr_budb_dissect_dumpList_dumpList_val(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_tapeList_tapeList_len(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_tapeList_tapeList_len, param);
+    return offset;
+}
+
+static int
+budb_dissect_tapeList_tapeList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_tapeEntry(tvb, offset, pinfo, tree, drep, hf_budb_tapeList_tapeList_val, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_tapeList_tapeList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_tapeList_tapeList_val, NDR_POINTER_PTR, "tapeList_val", -1);
+    return offset;
+}
+
+static int
+ucarray_ptr_budb_dissect_tapeList_tapeList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, drep, ptr_budb_dissect_tapeList_tapeList_val);
+    return offset;
+}
+
+
+int
+budb_dissect_tapeList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_tapeList);
+    }
+
+    offset=budb_dissect_tapeList_tapeList_len(tvb, offset, pinfo, tree, drep);
+
+    offset=ucarray_ptr_budb_dissect_tapeList_tapeList_val(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_charListT_charListT_len(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_charListT_charListT_len, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_uint8(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+    return offset;
+}
+
+static int
+budb_dissect_charListT_charListT_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint8(tvb, offset, pinfo, tree, drep, hf_budb_charListT_charListT_val, param);
+    return offset;
+}
+
+static int
+fixedarray_budb_dissect_charListT_charListT_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    int count=1024;
+    while(count--){
+        offset=budb_dissect_charListT_charListT_val(tvb, offset, pinfo, tree, drep);
+    }
+
+    return offset;
+}
+
+static int
+uvarray_fixedarray_budb_dissect_charListT_charListT_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_uvarray(tvb, offset, pinfo, tree, drep, fixedarray_budb_dissect_charListT_charListT_val);
+    return offset;
+}
+
+
+int
+budb_dissect_charListT(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_charListT);
+    }
+
+    offset=budb_dissect_charListT_charListT_len(tvb, offset, pinfo, tree, drep);
+
+    offset=uvarray_fixedarray_budb_dissect_charListT_charListT_val(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_DbHeader_dbversion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_dbversion, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_created(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_created, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_cell(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_cell, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_lastDumpId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_lastDumpId, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_lastInstanceId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_lastInstanceId, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_lastTapeId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_lastTapeId, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_DbHeader_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DbHeader_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_DbHeader(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_DbHeader);
+    }
+
+    offset=budb_dissect_DbHeader_dbversion(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_created(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_cell(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_lastDumpId(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_lastInstanceId(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_lastTapeId(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_DbHeader_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_dbVolume_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_name, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_udlong(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_id, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_server(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_server, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_partition(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_partition, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_nFrags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_nFrags, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_position(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_position, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_clone(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_clone, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_incTime(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_time_t(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_incTime, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_startByte(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_startByte, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_nBytes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_nBytes, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_seq(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_seq, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_dump, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_tape, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_dbVolume_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dbVolume_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_dbVolume(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_dbVolume);
+    }
+
+    offset=budb_dissect_dbVolume_name(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_flags(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_id(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_server(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_partition(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_nFrags(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_position(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_clone(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_incTime(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_startByte(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_nBytes(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_seq(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_dump(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_tape(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dbVolume_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_structDumpHeader_type(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_type, param);
+    return offset;
+}
+
+static int
+budb_dissect_structDumpHeader_structversion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_structversion, param);
+    return offset;
+}
+
+static int
+budb_dissect_structDumpHeader_size(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_size, param);
+    return offset;
+}
+
+static int
+budb_dissect_structDumpHeader_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_structDumpHeader_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_structDumpHeader_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_structDumpHeader_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_structDumpHeader_spare4, param);
+    return offset;
+}
+
+
+int
+budb_dissect_structDumpHeader(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_structDumpHeader);
+    }
+
+    offset=budb_dissect_structDumpHeader_type(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_structDumpHeader_structversion(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_structDumpHeader_size(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_structDumpHeader_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_structDumpHeader_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_structDumpHeader_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_structDumpHeader_spare4(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_AddVolume_vol(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_volumeEntry(tvb, offset, pinfo, tree, drep, hf_budb_AddVolume_vol, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_AddVolume_vol(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_AddVolume_vol, NDR_POINTER_REF, "vol", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_AddVolume_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_AddVolume_vol(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_AddVolume_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_CreateDump_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dumpEntry(tvb, offset, pinfo, tree, drep, hf_budb_CreateDump_dump, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_CreateDump_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_CreateDump_dump, NDR_POINTER_REF, "dump", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_CreateDump_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_CreateDump_dump(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_CreateDump_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_CreateDump_dump(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_DeleteDump_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_DeleteDump_id, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_DeleteDump_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_DeleteDump_id(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_DeleteDump_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_DeleteTape_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_tapeEntry(tvb, offset, pinfo, tree, drep, hf_budb_DeleteTape_tape, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_DeleteTape_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DeleteTape_tape, NDR_POINTER_REF, "tape", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_DeleteTape_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_DeleteTape_tape(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_DeleteTape_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_DeleteVDP_dsname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_DeleteVDP_dsname, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_DeleteVDP_dsname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DeleteVDP_dsname, NDR_POINTER_PTR, "dsname", -1);
+    return offset;
+}
+
+static int
+budb_dissect_DeleteVDP_dumpPath(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_DeleteVDP_dumpPath, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_DeleteVDP_dumpPath(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DeleteVDP_dumpPath, NDR_POINTER_PTR, "dumpPath", -1);
+    return offset;
+}
+
+static int
+budb_dissect_DeleteVDP_curDumpId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DeleteVDP_curDumpId, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_DeleteVDP_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ptr_budb_dissect_DeleteVDP_dsname(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_DeleteVDP_dumpPath(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_DeleteVDP_curDumpId(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_DeleteVDP_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FindClone_dumpID(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_FindClone_dumpID, param);
+    return offset;
+}
+
+static int
+budb_dissect_FindClone_volName(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_FindClone_volName, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_FindClone_volName(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindClone_volName, NDR_POINTER_PTR, "volName", -1);
+    return offset;
+}
+
+static int
+budb_dissect_FindClone_clonetime(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_FindClone_clonetime, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_FindClone_clonetime(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindClone_clonetime, NDR_POINTER_REF, "clonetime", -1);
+    return offset;
+}
+
+static int
+budb_dissect_FindClone_cloneSpare(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_FindClone_cloneSpare, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_FindClone_cloneSpare(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindClone_cloneSpare, NDR_POINTER_REF, "cloneSpare", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_FindClone_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_FindClone_dumpID(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_FindClone_volName(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FindClone_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_FindClone_clonetime(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_FindClone_cloneSpare(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FindDump_volName(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_FindDump_volName, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_FindDump_volName(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindDump_volName, NDR_POINTER_PTR, "volName", -1);
+    return offset;
+}
+
+static int
+budb_dissect_FindDump_beforeDate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_FindDump_beforeDate, param);
+    return offset;
+}
+
+static int
+budb_dissect_FindDump_dateSpare(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_FindDump_dateSpare, param);
+    return offset;
+}
+
+static int
+budb_dissect_FindDump_deptr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dumpEntry(tvb, offset, pinfo, tree, drep, hf_budb_FindDump_deptr, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_FindDump_deptr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindDump_deptr, NDR_POINTER_REF, "deptr", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_FindDump_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ptr_budb_dissect_FindDump_volName(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_FindDump_beforeDate(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_FindDump_dateSpare(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FindDump_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_FindDump_deptr(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FindLatestDump_vsname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_FindLatestDump_vsname, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_FindLatestDump_vsname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindLatestDump_vsname, NDR_POINTER_PTR, "vsname", -1);
+    return offset;
+}
+
+static int
+budb_dissect_FindLatestDump_dname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_FindLatestDump_dname, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_FindLatestDump_dname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindLatestDump_dname, NDR_POINTER_PTR, "dname", -1);
+    return offset;
+}
+
+static int
+budb_dissect_FindLatestDump_dumpentry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dumpEntry(tvb, offset, pinfo, tree, drep, hf_budb_FindLatestDump_dumpentry, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_FindLatestDump_dumpentry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FindLatestDump_dumpentry, NDR_POINTER_REF, "dumpentry", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_FindLatestDump_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ptr_budb_dissect_FindLatestDump_vsname(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_FindLatestDump_dname(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FindLatestDump_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_FindLatestDump_dumpentry(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FinishDump_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dumpEntry(tvb, offset, pinfo, tree, drep, hf_budb_FinishDump_dump, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_FinishDump_dump(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FinishDump_dump, NDR_POINTER_REF, "dump", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_FinishDump_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_FinishDump_dump(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FinishDump_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_FinishDump_dump(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FinishTape_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_tapeEntry(tvb, offset, pinfo, tree, drep, hf_budb_FinishTape_tape, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_FinishTape_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_FinishTape_tape, NDR_POINTER_REF, "tape", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_FinishTape_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_FinishTape_tape(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FinishTape_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetDumps_majorVersion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_majorVersion, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_name, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_GetDumps_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetDumps_name, NDR_POINTER_PTR, "name", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_start(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_start, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_end(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_end, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_index(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_index, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_nextIndex(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_nextIndex, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetDumps_nextIndex(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetDumps_nextIndex, NDR_POINTER_REF, "nextIndex", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_dbUpdate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_dbUpdate, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetDumps_dbUpdate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetDumps_dbUpdate, NDR_POINTER_REF, "dbUpdate", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetDumps_dumps(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dumpList(tvb, offset, pinfo, tree, drep, hf_budb_GetDumps_dumps, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_GetDumps_dumps(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetDumps_dumps, NDR_POINTER_PTR, "dumps", -1);
+    return offset;
+}
+
+static int
+ptr_ptr_budb_dissect_GetDumps_dumps(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, ptr_budb_dissect_GetDumps_dumps, NDR_POINTER_PTR, "dumps", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetDumps_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_GetDumps_majorVersion(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetDumps_flags(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_GetDumps_name(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetDumps_start(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetDumps_end(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetDumps_index(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetDumps_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetDumps_nextIndex(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_GetDumps_dbUpdate(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_ptr_budb_dissect_GetDumps_dumps(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetTapes_majorVersion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_majorVersion, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_name, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_GetTapes_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetTapes_name, NDR_POINTER_PTR, "name", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_start(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_start, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_end(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_end, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_index(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_index, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_nextIndex(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_nextIndex, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetTapes_nextIndex(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetTapes_nextIndex, NDR_POINTER_REF, "nextIndex", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_dbUpdate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_dbUpdate, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetTapes_dbUpdate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetTapes_dbUpdate, NDR_POINTER_REF, "dbUpdate", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetTapes_tapes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_tapeList(tvb, offset, pinfo, tree, drep, hf_budb_GetTapes_tapes, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_GetTapes_tapes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetTapes_tapes, NDR_POINTER_PTR, "tapes", -1);
+    return offset;
+}
+
+static int
+ptr_ptr_budb_dissect_GetTapes_tapes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, ptr_budb_dissect_GetTapes_tapes, NDR_POINTER_PTR, "tapes", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetTapes_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_GetTapes_majorVersion(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetTapes_flags(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_GetTapes_name(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetTapes_start(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetTapes_end(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetTapes_index(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetTapes_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetTapes_nextIndex(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_GetTapes_dbUpdate(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_ptr_budb_dissect_GetTapes_tapes(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetVolumes_majorVersion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_majorVersion, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_name, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_GetVolumes_name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetVolumes_name, NDR_POINTER_PTR, "name", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_start(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_start, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_end(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_end, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_index(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_index, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_nextIndex(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_nextIndex, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetVolumes_nextIndex(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetVolumes_nextIndex, NDR_POINTER_REF, "nextIndex", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_dbUpdate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_dbUpdate, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetVolumes_dbUpdate(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetVolumes_dbUpdate, NDR_POINTER_REF, "dbUpdate", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetVolumes_volumes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_volumeList(tvb, offset, pinfo, tree, drep, hf_budb_GetVolumes_volumes, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_GetVolumes_volumes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetVolumes_volumes, NDR_POINTER_PTR, "volumes", -1);
+    return offset;
+}
+
+static int
+ptr_ptr_budb_dissect_GetVolumes_volumes(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, ptr_budb_dissect_GetVolumes_volumes, NDR_POINTER_PTR, "volumes", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetVolumes_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_GetVolumes_majorVersion(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetVolumes_flags(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_GetVolumes_name(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetVolumes_start(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetVolumes_end(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetVolumes_index(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetVolumes_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetVolumes_nextIndex(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_GetVolumes_dbUpdate(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_ptr_budb_dissect_GetVolumes_volumes(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_UseTape_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_tapeEntry(tvb, offset, pinfo, tree, drep, hf_budb_UseTape_tape, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_UseTape_tape(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_UseTape_tape, NDR_POINTER_REF, "tape", -1);
+    return offset;
+}
+
+static int
+budb_dissect_UseTape_new(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_UseTape_new, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_UseTape_new(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_UseTape_new, NDR_POINTER_REF, "new", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_UseTape_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_UseTape_tape(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_UseTape_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_UseTape_new(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetText_lockHandle(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetText_lockHandle, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetText_textType(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetText_textType, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetText_maxLength(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetText_maxLength, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetText_offset(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetText_offset, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetText_nextOffset(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetText_nextOffset, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetText_nextOffset(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetText_nextOffset, NDR_POINTER_REF, "nextOffset", -1);
+    return offset;
+}
+
+static int
+budb_dissect_GetText_charListPtr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_charListT(tvb, offset, pinfo, tree, drep, hf_budb_GetText_charListPtr, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetText_charListPtr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetText_charListPtr, NDR_POINTER_REF, "charListPtr", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetText_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_GetText_lockHandle(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetText_textType(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetText_maxLength(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetText_offset(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetText_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetText_nextOffset(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_GetText_charListPtr(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetTextVersion_textType(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTextVersion_textType, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetTextVersion_tversion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetTextVersion_tversion, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetTextVersion_tversion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetTextVersion_tversion, NDR_POINTER_REF, "tversion", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetTextVersion_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_GetTextVersion_textType(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetTextVersion_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetTextVersion_tversion(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_SaveText_lockHandle(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_SaveText_lockHandle, param);
+    return offset;
+}
+
+static int
+budb_dissect_SaveText_textType(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_SaveText_textType, param);
+    return offset;
+}
+
+static int
+budb_dissect_SaveText_offset(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_SaveText_offset, param);
+    return offset;
+}
+
+static int
+budb_dissect_SaveText_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_SaveText_flags, param);
+    return offset;
+}
+
+static int
+budb_dissect_SaveText_charListPtr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_charListT(tvb, offset, pinfo, tree, drep, hf_budb_SaveText_charListPtr, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_SaveText_charListPtr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_SaveText_charListPtr, NDR_POINTER_REF, "charListPtr", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_SaveText_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_SaveText_lockHandle(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_SaveText_textType(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_SaveText_offset(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_SaveText_flags(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_SaveText_charListPtr(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_SaveText_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FreeAllLocks_instanceId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_FreeAllLocks_instanceId, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_FreeAllLocks_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_FreeAllLocks_instanceId(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FreeAllLocks_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_FreeLock_lockHandle(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_FreeLock_lockHandle, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_FreeLock_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_FreeLock_lockHandle(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_FreeLock_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetInstanceId_instanceId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_GetInstanceId_instanceId, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetInstanceId_instanceId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetInstanceId_instanceId, NDR_POINTER_REF, "instanceId", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetInstanceId_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+
+   return offset;
+}
+
+static int
+budb_dissect_GetInstanceId_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetInstanceId_instanceId(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_GetLock_instanceId(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_GetLock_instanceId, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetLock_lockName(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetLock_lockName, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetLock_expiration(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_GetLock_expiration, param);
+    return offset;
+}
+
+static int
+budb_dissect_GetLock_lockHandle(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_GetLock_lockHandle, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetLock_lockHandle(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetLock_lockHandle, NDR_POINTER_REF, "lockHandle", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetLock_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_GetLock_instanceId(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetLock_lockName(tvb, offset, pinfo, tree, drep);
+
+        offset=budb_dissect_GetLock_expiration(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetLock_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetLock_lockHandle(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_DbVerify_status(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DbVerify_status, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_DbVerify_status(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DbVerify_status, NDR_POINTER_REF, "status", -1);
+    return offset;
+}
+
+static int
+budb_dissect_DbVerify_orphans(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DbVerify_orphans, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_DbVerify_orphans(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DbVerify_orphans, NDR_POINTER_REF, "orphans", -1);
+    return offset;
+}
+
+static int
+budb_dissect_DbVerify_host(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DbVerify_host, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_DbVerify_host(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DbVerify_host, NDR_POINTER_REF, "host", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_DbVerify_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+
+   return offset;
+}
+
+static int
+budb_dissect_DbVerify_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_DbVerify_status(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_DbVerify_orphans(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_DbVerify_host(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_DumpDB_maxLength(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DumpDB_maxLength, param);
+    return offset;
+}
+
+static int
+budb_dissect_DumpDB_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_DumpDB_flags, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_DumpDB_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DumpDB_flags, NDR_POINTER_REF, "flags", -1);
+    return offset;
+}
+
+static int
+budb_dissect_DumpDB_charListPtr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_charListT(tvb, offset, pinfo, tree, drep, hf_budb_DumpDB_charListPtr, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_DumpDB_charListPtr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_DumpDB_charListPtr, NDR_POINTER_REF, "charListPtr", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_DumpDB_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_DumpDB_maxLength(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_DumpDB_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_DumpDB_flags(tvb, offset, pinfo, tree, drep);
+
+        offset=ref_budb_dissect_DumpDB_charListPtr(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_RestoreDbHeader_header(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_DbHeader(tvb, offset, pinfo, tree, drep, hf_budb_RestoreDbHeader_header, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_RestoreDbHeader_header(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_RestoreDbHeader_header, NDR_POINTER_REF, "header", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_RestoreDbHeader_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_RestoreDbHeader_header(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_RestoreDbHeader_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_T_GetVersion_majorVersion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_T_GetVersion_majorVersion, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_T_GetVersion_majorVersion(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_T_GetVersion_majorVersion, NDR_POINTER_REF, "majorVersion", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_T_GetVersion_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+
+   return offset;
+}
+
+static int
+budb_dissect_T_GetVersion_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_T_GetVersion_majorVersion(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_T_DumpHashTable_type(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_int32(tvb, offset, pinfo, tree, drep, hf_budb_T_DumpHashTable_type, param);
+    return offset;
+}
+
+static int
+budb_dissect_T_DumpHashTable_filename(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_T_DumpHashTable_filename, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_T_DumpHashTable_filename(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_T_DumpHashTable_filename, NDR_POINTER_PTR, "filename", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_T_DumpHashTable_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_T_DumpHashTable_type(tvb, offset, pinfo, tree, drep);
+
+        offset=ptr_budb_dissect_T_DumpHashTable_filename(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_T_DumpHashTable_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_T_DumpDatabase_filename(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_NameString_t(tvb, offset, pinfo, tree, drep, hf_budb_T_DumpDatabase_filename, param);
+    return offset;
+}
+
+static int
+ptr_budb_dissect_T_DumpDatabase_filename(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_T_DumpDatabase_filename, NDR_POINTER_PTR, "filename", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_T_DumpDatabase_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ptr_budb_dissect_T_DumpDatabase_filename(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_T_DumpDatabase_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_uuid_t(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_interface_uuid(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uuid_t(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_interface_uuid, param);
+    return offset;
+}
+
+
+static int
+budb_dissect_uint16(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    offset=dissect_ndr_uint16(tvb, offset, pinfo, tree, drep, hf_index, NULL);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_vers_major(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint16(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_vers_major, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_vers_minor(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint16(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_vers_minor, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_vers_provider(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_vers_provider, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare0(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare0, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare1(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare1, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare2(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare2, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare3, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare4(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare4, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare5(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare5, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare6(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare6, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare7(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare7, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare8(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare8, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spare9(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spare9, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceDescription_spareText(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint8(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceDescription_spareText, param);
+    return offset;
+}
+
+static int
+fixedarray_budb_dissect_dfs_interfaceDescription_spareText(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    int count=50;
+    while(count--){
+        offset=budb_dissect_dfs_interfaceDescription_spareText(tvb, offset, pinfo, tree, drep);
+    }
+
+    return offset;
+}
+
+
+int
+budb_dissect_dfs_interfaceDescription(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_dfs_interfaceDescription);
+    }
+
+    offset=budb_dissect_dfs_interfaceDescription_interface_uuid(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_vers_major(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_vers_minor(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_vers_provider(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare0(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare1(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare2(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare3(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare4(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare5(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare6(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare7(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare8(tvb, offset, pinfo, tree, drep);
+
+    offset=budb_dissect_dfs_interfaceDescription_spare9(tvb, offset, pinfo, tree, drep);
+
+    offset=fixedarray_budb_dissect_dfs_interfaceDescription_spareText(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_dfs_interfaceList_dfs_interfaceList_len(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceList_dfs_interfaceList_len, param);
+    return offset;
+}
+
+static int
+budb_dissect_dfs_interfaceList_dfs_interfaceList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dfs_interfaceDescription(tvb, offset, pinfo, tree, drep, hf_budb_dfs_interfaceList_dfs_interfaceList_val, param);
+    return offset;
+}
+
+static int
+uvarray_budb_dissect_dfs_interfaceList_dfs_interfaceList_val(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_uvarray(tvb, offset, pinfo, tree, drep, budb_dissect_dfs_interfaceList_dfs_interfaceList_val);
+    return offset;
+}
+
+
+int
+budb_dissect_dfs_interfaceList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)
+{
+    proto_item *item=NULL;
+    proto_tree *tree=NULL;
+    int old_offset;
+
+    ALIGN_TO_4_BYTES;
+
+    old_offset=offset;
+    if(parent_tree){
+        item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);
+        tree=proto_item_add_subtree(item, ett_budb_dfs_interfaceList);
+    }
+
+    offset=budb_dissect_dfs_interfaceList_dfs_interfaceList_len(tvb, offset, pinfo, tree, drep);
+
+    offset=uvarray_budb_dissect_dfs_interfaceList_dfs_interfaceList_val(tvb, offset, pinfo, tree, drep);
+
+    proto_item_set_len(item, offset-old_offset);
+
+    return offset;
+}
+static int
+budb_dissect_GetServerInterfaces_serverInterfacesP(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_dfs_interfaceList(tvb, offset, pinfo, tree, drep, hf_budb_GetServerInterfaces_serverInterfacesP, param);
+    return offset;
+}
+
+static int
+ref_budb_dissect_GetServerInterfaces_serverInterfacesP(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_pointer(tvb, offset, pinfo, tree, drep, budb_dissect_GetServerInterfaces_serverInterfacesP, NDR_POINTER_REF, "serverInterfacesP", -1);
+    return offset;
+}
+
+
+static int
+budb_dissect_GetServerInterfaces_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetServerInterfaces_serverInterfacesP(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_GetServerInterfaces_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=ref_budb_dissect_GetServerInterfaces_serverInterfacesP(tvb, offset, pinfo, tree, drep);
+
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+static int
+budb_dissect_AddVolumes_cnt(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_uint32(tvb, offset, pinfo, tree, drep, hf_budb_AddVolumes_cnt, param);
+    return offset;
+}
+
+static int
+budb_dissect_AddVolumes_vol(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    guint32 param=0;
+    offset=budb_dissect_volumeEntry(tvb, offset, pinfo, tree, drep, hf_budb_AddVolumes_vol, param);
+    return offset;
+}
+
+static int
+ucarray_budb_dissect_AddVolumes_vol(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)
+{
+    offset=dissect_ndr_ucarray(tvb, offset, pinfo, tree, drep, budb_dissect_AddVolumes_vol);
+    return offset;
+}
+
+
+static int
+budb_dissect_AddVolumes_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+        offset=budb_dissect_AddVolumes_cnt(tvb, offset, pinfo, tree, drep);
+
+        offset=ucarray_budb_dissect_AddVolumes_vol(tvb, offset, pinfo, tree, drep);
+
+
+   return offset;
+}
+
+static int
+budb_dissect_AddVolumes_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)
+{
+   offset=dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf_budb_rc, NULL);
+
+
+   return offset;
+}
+/* END OF INCLUDED FILE : ETH_CODE */
+
+
+
 void
-proto_register_budb (void)
+proto_register_budb(void)
 {
-	static hf_register_info hf[] = {
-	{ &hf_budb_opnum,
-		{ "Operation", "budb.opnum", FT_UINT16, BASE_DEC, NULL, 0x0, "Operation", HFILL }},
-	};
+        static hf_register_info hf[] = {
+
+
+
+/* INCLUDED FILE : ETH_HFARR */
+        { &hf_budb_opnum,
+          { "Operation", "budb.opnum", FT_UINT16, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_rc,
+          { "Return code", "budb.rc", FT_UINT32, BASE_HEX,
+          VALS(NT_errors), 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_name,
+          { "name", "budb.principal.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_instance,
+          { "instance", "budb.principal.instance", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_cell,
+          { "cell", "budb.principal.cell", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_spare,
+          { "spare", "budb.principal.spare", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_spare1,
+          { "spare1", "budb.principal.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_spare2,
+          { "spare2", "budb.principal.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_spare3,
+          { "spare3", "budb.principal.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_principal_spare4,
+          { "spare4", "budb.principal.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_id,
+          { "id", "budb.tapeSet.id", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_tapeServer,
+          { "tapeServer", "budb.tapeSet.tapeServer", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_format,
+          { "format", "budb.tapeSet.format", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_maxTapes,
+          { "maxTapes", "budb.tapeSet.maxTapes", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_a,
+          { "a", "budb.tapeSet.a", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_b,
+          { "b", "budb.tapeSet.b", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_spare1,
+          { "spare1", "budb.tapeSet.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_spare2,
+          { "spare2", "budb.tapeSet.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_spare3,
+          { "spare3", "budb.tapeSet.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeSet_spare4,
+          { "spare4", "budb.tapeSet.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_id,
+          { "id", "budb.dumpEntry.id", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_parent,
+          { "parent", "budb.dumpEntry.parent", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_level,
+          { "level", "budb.dumpEntry.level", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_flags,
+          { "flags", "budb.dumpEntry.flags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_volumeSetName,
+          { "volumeSetName", "budb.dumpEntry.volumeSetName", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_dumpPath,
+          { "dumpPath", "budb.dumpEntry.dumpPath", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_name,
+          { "name", "budb.dumpEntry.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_created,
+          { "created", "budb.dumpEntry.created", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_incTime,
+          { "incTime", "budb.dumpEntry.incTime", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_nVolumes,
+          { "nVolumes", "budb.dumpEntry.nVolumes", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_tapes,
+          { "tapes", "budb.dumpEntry.tapes", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_dumper,
+          { "dumper", "budb.dumpEntry.dumper", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_spare1,
+          { "spare1", "budb.dumpEntry.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_spare2,
+          { "spare2", "budb.dumpEntry.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_spare3,
+          { "spare3", "budb.dumpEntry.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpEntry_spare4,
+          { "spare4", "budb.dumpEntry.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_name,
+          { "name", "budb.tapeEntry.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_flags,
+          { "flags", "budb.tapeEntry.flags", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_written,
+          { "written", "budb.tapeEntry.written", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_expires,
+          { "expires", "budb.tapeEntry.expires", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_nMBytes,
+          { "nMBytes", "budb.tapeEntry.nMBytes", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_nBytes,
+          { "nBytes", "budb.tapeEntry.nBytes", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_nFiles,
+          { "nFiles", "budb.tapeEntry.nFiles", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_nVolumes,
+          { "nVolumes", "budb.tapeEntry.nVolumes", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_seq,
+          { "seq", "budb.tapeEntry.seq", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_tapeid,
+          { "tapeid", "budb.tapeEntry.tapeid", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_useCount,
+          { "useCount", "budb.tapeEntry.useCount", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_mediaType,
+          { "mediaType", "budb.tapeEntry.mediaType", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_dump,
+          { "dump", "budb.tapeEntry.dump", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_spare1,
+          { "spare1", "budb.tapeEntry.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_spare2,
+          { "spare2", "budb.tapeEntry.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_spare3,
+          { "spare3", "budb.tapeEntry.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeEntry_spare4,
+          { "spare4", "budb.tapeEntry.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_name,
+          { "name", "budb.volumeEntry.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_flags,
+          { "flags", "budb.volumeEntry.flags", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_id,
+          { "id", "budb.volumeEntry.id", FT_UINT64, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_server,
+          { "server", "budb.volumeEntry.server", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_partition,
+          { "partition", "budb.volumeEntry.partition", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_nFrags,
+          { "nFrags", "budb.volumeEntry.nFrags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_position,
+          { "position", "budb.volumeEntry.position", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_clone,
+          { "clone", "budb.volumeEntry.clone", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_incTime,
+          { "incTime", "budb.volumeEntry.incTime", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_startByte,
+          { "startByte", "budb.volumeEntry.startByte", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_nBytes,
+          { "nBytes", "budb.volumeEntry.nBytes", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_seq,
+          { "seq", "budb.volumeEntry.seq", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_dump,
+          { "dump", "budb.volumeEntry.dump", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_tape,
+          { "tape", "budb.volumeEntry.tape", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_spare1,
+          { "spare1", "budb.volumeEntry.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_spare2,
+          { "spare2", "budb.volumeEntry.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_spare3,
+          { "spare3", "budb.volumeEntry.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeEntry_spare4,
+          { "spare4", "budb.volumeEntry.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeList_volumeList_len,
+          { "volumeList_len", "budb.volumeList.volumeList_len", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_volumeList_volumeList_val,
+          { "volumeList_val", "budb.volumeList.volumeList_val", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpList_dumpList_len,
+          { "dumpList_len", "budb.dumpList.dumpList_len", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dumpList_dumpList_val,
+          { "dumpList_val", "budb.dumpList.dumpList_val", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeList_tapeList_len,
+          { "tapeList_len", "budb.tapeList.tapeList_len", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_tapeList_tapeList_val,
+          { "tapeList_val", "budb.tapeList.tapeList_val", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_charListT_charListT_len,
+          { "charListT_len", "budb.charListT.charListT_len", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_charListT_charListT_val,
+          { "charListT_val", "budb.charListT.charListT_val", FT_UINT8, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_dbversion,
+          { "dbversion", "budb.DbHeader.dbversion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_created,
+          { "created", "budb.DbHeader.created", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_cell,
+          { "cell", "budb.DbHeader.cell", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_lastDumpId,
+          { "lastDumpId", "budb.DbHeader.lastDumpId", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_lastInstanceId,
+          { "lastInstanceId", "budb.DbHeader.lastInstanceId", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_lastTapeId,
+          { "lastTapeId", "budb.DbHeader.lastTapeId", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_spare1,
+          { "spare1", "budb.DbHeader.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_spare2,
+          { "spare2", "budb.DbHeader.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_spare3,
+          { "spare3", "budb.DbHeader.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbHeader_spare4,
+          { "spare4", "budb.DbHeader.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_name,
+          { "name", "budb.dbVolume.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_flags,
+          { "flags", "budb.dbVolume.flags", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_id,
+          { "id", "budb.dbVolume.id", FT_UINT64, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_server,
+          { "server", "budb.dbVolume.server", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_partition,
+          { "partition", "budb.dbVolume.partition", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_nFrags,
+          { "nFrags", "budb.dbVolume.nFrags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_position,
+          { "position", "budb.dbVolume.position", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_clone,
+          { "clone", "budb.dbVolume.clone", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_incTime,
+          { "incTime", "budb.dbVolume.incTime", FT_ABSOLUTE_TIME, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_startByte,
+          { "startByte", "budb.dbVolume.startByte", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_nBytes,
+          { "nBytes", "budb.dbVolume.nBytes", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_seq,
+          { "seq", "budb.dbVolume.seq", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_dump,
+          { "dump", "budb.dbVolume.dump", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_tape,
+          { "tape", "budb.dbVolume.tape", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_spare1,
+          { "spare1", "budb.dbVolume.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_spare2,
+          { "spare2", "budb.dbVolume.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_spare3,
+          { "spare3", "budb.dbVolume.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dbVolume_spare4,
+          { "spare4", "budb.dbVolume.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_type,
+          { "type", "budb.structDumpHeader.type", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_structversion,
+          { "structversion", "budb.structDumpHeader.structversion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_size,
+          { "size", "budb.structDumpHeader.size", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_spare1,
+          { "spare1", "budb.structDumpHeader.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_spare2,
+          { "spare2", "budb.structDumpHeader.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_spare3,
+          { "spare3", "budb.structDumpHeader.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_structDumpHeader_spare4,
+          { "spare4", "budb.structDumpHeader.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_AddVolume_vol,
+          { "vol", "budb.AddVolume.vol", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_CreateDump_dump,
+          { "dump", "budb.CreateDump.dump", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DeleteDump_id,
+          { "id", "budb.DeleteDump.id", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DeleteTape_tape,
+          { "tape", "budb.DeleteTape.tape", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DeleteVDP_dsname,
+          { "dsname", "budb.DeleteVDP.dsname", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DeleteVDP_dumpPath,
+          { "dumpPath", "budb.DeleteVDP.dumpPath", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DeleteVDP_curDumpId,
+          { "curDumpId", "budb.DeleteVDP.curDumpId", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindClone_dumpID,
+          { "dumpID", "budb.FindClone.dumpID", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindClone_volName,
+          { "volName", "budb.FindClone.volName", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindClone_clonetime,
+          { "clonetime", "budb.FindClone.clonetime", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindClone_cloneSpare,
+          { "cloneSpare", "budb.FindClone.cloneSpare", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindDump_volName,
+          { "volName", "budb.FindDump.volName", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindDump_beforeDate,
+          { "beforeDate", "budb.FindDump.beforeDate", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindDump_dateSpare,
+          { "dateSpare", "budb.FindDump.dateSpare", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindDump_deptr,
+          { "deptr", "budb.FindDump.deptr", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindLatestDump_vsname,
+          { "vsname", "budb.FindLatestDump.vsname", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindLatestDump_dname,
+          { "dname", "budb.FindLatestDump.dname", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FindLatestDump_dumpentry,
+          { "dumpentry", "budb.FindLatestDump.dumpentry", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FinishDump_dump,
+          { "dump", "budb.FinishDump.dump", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FinishTape_tape,
+          { "tape", "budb.FinishTape.tape", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_majorVersion,
+          { "majorVersion", "budb.GetDumps.majorVersion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_flags,
+          { "flags", "budb.GetDumps.flags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_name,
+          { "name", "budb.GetDumps.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_start,
+          { "start", "budb.GetDumps.start", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_end,
+          { "end", "budb.GetDumps.end", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_index,
+          { "index", "budb.GetDumps.index", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_nextIndex,
+          { "nextIndex", "budb.GetDumps.nextIndex", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_dbUpdate,
+          { "dbUpdate", "budb.GetDumps.dbUpdate", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetDumps_dumps,
+          { "dumps", "budb.GetDumps.dumps", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_majorVersion,
+          { "majorVersion", "budb.GetTapes.majorVersion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_flags,
+          { "flags", "budb.GetTapes.flags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_name,
+          { "name", "budb.GetTapes.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_start,
+          { "start", "budb.GetTapes.start", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_end,
+          { "end", "budb.GetTapes.end", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_index,
+          { "index", "budb.GetTapes.index", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_nextIndex,
+          { "nextIndex", "budb.GetTapes.nextIndex", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_dbUpdate,
+          { "dbUpdate", "budb.GetTapes.dbUpdate", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTapes_tapes,
+          { "tapes", "budb.GetTapes.tapes", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_majorVersion,
+          { "majorVersion", "budb.GetVolumes.majorVersion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_flags,
+          { "flags", "budb.GetVolumes.flags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_name,
+          { "name", "budb.GetVolumes.name", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_start,
+          { "start", "budb.GetVolumes.start", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_end,
+          { "end", "budb.GetVolumes.end", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_index,
+          { "index", "budb.GetVolumes.index", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_nextIndex,
+          { "nextIndex", "budb.GetVolumes.nextIndex", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_dbUpdate,
+          { "dbUpdate", "budb.GetVolumes.dbUpdate", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetVolumes_volumes,
+          { "volumes", "budb.GetVolumes.volumes", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_UseTape_tape,
+          { "tape", "budb.UseTape.tape", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_UseTape_new,
+          { "new", "budb.UseTape.new", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetText_lockHandle,
+          { "lockHandle", "budb.GetText.lockHandle", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetText_textType,
+          { "textType", "budb.GetText.textType", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetText_maxLength,
+          { "maxLength", "budb.GetText.maxLength", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetText_offset,
+          { "offset", "budb.GetText.offset", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetText_nextOffset,
+          { "nextOffset", "budb.GetText.nextOffset", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetText_charListPtr,
+          { "charListPtr", "budb.GetText.charListPtr", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTextVersion_textType,
+          { "textType", "budb.GetTextVersion.textType", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetTextVersion_tversion,
+          { "tversion", "budb.GetTextVersion.tversion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_SaveText_lockHandle,
+          { "lockHandle", "budb.SaveText.lockHandle", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_SaveText_textType,
+          { "textType", "budb.SaveText.textType", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_SaveText_offset,
+          { "offset", "budb.SaveText.offset", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_SaveText_flags,
+          { "flags", "budb.SaveText.flags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_SaveText_charListPtr,
+          { "charListPtr", "budb.SaveText.charListPtr", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FreeAllLocks_instanceId,
+          { "instanceId", "budb.FreeAllLocks.instanceId", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_FreeLock_lockHandle,
+          { "lockHandle", "budb.FreeLock.lockHandle", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetInstanceId_instanceId,
+          { "instanceId", "budb.GetInstanceId.instanceId", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetLock_instanceId,
+          { "instanceId", "budb.GetLock.instanceId", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetLock_lockName,
+          { "lockName", "budb.GetLock.lockName", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetLock_expiration,
+          { "expiration", "budb.GetLock.expiration", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetLock_lockHandle,
+          { "lockHandle", "budb.GetLock.lockHandle", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbVerify_status,
+          { "status", "budb.DbVerify.status", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbVerify_orphans,
+          { "orphans", "budb.DbVerify.orphans", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DbVerify_host,
+          { "host", "budb.DbVerify.host", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DumpDB_maxLength,
+          { "maxLength", "budb.DumpDB.maxLength", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DumpDB_flags,
+          { "flags", "budb.DumpDB.flags", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_DumpDB_charListPtr,
+          { "charListPtr", "budb.DumpDB.charListPtr", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_RestoreDbHeader_header,
+          { "header", "budb.RestoreDbHeader.header", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_T_GetVersion_majorVersion,
+          { "majorVersion", "budb.T_GetVersion.majorVersion", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_T_DumpHashTable_type,
+          { "type", "budb.T_DumpHashTable.type", FT_INT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_T_DumpHashTable_filename,
+          { "filename", "budb.T_DumpHashTable.filename", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_T_DumpDatabase_filename,
+          { "filename", "budb.T_DumpDatabase.filename", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_interface_uuid,
+          { "interface_uuid", "budb.dfs_interfaceDescription.interface_uuid", FT_STRING, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_vers_major,
+          { "vers_major", "budb.dfs_interfaceDescription.vers_major", FT_UINT16, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_vers_minor,
+          { "vers_minor", "budb.dfs_interfaceDescription.vers_minor", FT_UINT16, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_vers_provider,
+          { "vers_provider", "budb.dfs_interfaceDescription.vers_provider", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare0,
+          { "spare0", "budb.dfs_interfaceDescription.spare0", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare1,
+          { "spare1", "budb.dfs_interfaceDescription.spare1", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare2,
+          { "spare2", "budb.dfs_interfaceDescription.spare2", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare3,
+          { "spare3", "budb.dfs_interfaceDescription.spare3", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare4,
+          { "spare4", "budb.dfs_interfaceDescription.spare4", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare5,
+          { "spare5", "budb.dfs_interfaceDescription.spare5", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare6,
+          { "spare6", "budb.dfs_interfaceDescription.spare6", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare7,
+          { "spare7", "budb.dfs_interfaceDescription.spare7", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare8,
+          { "spare8", "budb.dfs_interfaceDescription.spare8", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spare9,
+          { "spare9", "budb.dfs_interfaceDescription.spare9", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceDescription_spareText,
+          { "spareText", "budb.dfs_interfaceDescription.spareText", FT_UINT8, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceList_dfs_interfaceList_len,
+          { "dfs_interfaceList_len", "budb.dfs_interfaceList.dfs_interfaceList_len", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_dfs_interfaceList_dfs_interfaceList_val,
+          { "dfs_interfaceList_val", "budb.dfs_interfaceList.dfs_interfaceList_val", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_GetServerInterfaces_serverInterfacesP,
+          { "serverInterfacesP", "budb.GetServerInterfaces.serverInterfacesP", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_AddVolumes_cnt,
+          { "cnt", "budb.AddVolumes.cnt", FT_UINT32, BASE_DEC,
+          NULL, 0,
+         "", HFILL }},
+
+        { &hf_budb_AddVolumes_vol,
+          { "vol", "budb.AddVolumes.vol", FT_NONE, BASE_NONE,
+          NULL, 0,
+         "", HFILL }},
+
+/* END OF INCLUDED FILE : ETH_HFARR */
+
 
-	static gint *ett[] = {
-		&ett_budb,
 	};
-	proto_budb = proto_register_protocol ("DCE/RPC BUDB", "BUDB", "budb");
-	proto_register_field_array (proto_budb, hf, array_length (hf));
-	proto_register_subtree_array (ett, array_length (ett));
+
+        static gint *ett[] = {
+
+
+/* INCLUDED FILE : ETH_ETTARR */
+        &ett_budb,
+        &ett_budb_principal,
+        &ett_budb_tapeSet,
+        &ett_budb_dumpEntry,
+        &ett_budb_tapeEntry,
+        &ett_budb_volumeEntry,
+        &ett_budb_volumeList,
+        &ett_budb_dumpList,
+        &ett_budb_tapeList,
+        &ett_budb_charListT,
+        &ett_budb_DbHeader,
+        &ett_budb_dbVolume,
+        &ett_budb_structDumpHeader,
+        &ett_budb_dfs_interfaceDescription,
+        &ett_budb_dfs_interfaceList,
+/* END OF INCLUDED FILE : ETH_ETTARR */
+
+
+        };
+
+        proto_budb = proto_register_protocol(
+                "DCE/DFS BUDB", 
+		"BUDB", "budb");
+	proto_register_field_array(proto_budb, hf, array_length(hf));
+        proto_register_subtree_array(ett, array_length(ett));
 }
 
+static dcerpc_sub_dissector function_dissectors[] = {
+
+
+/* INCLUDED FILE : ETH_FT */
+    { 0, "AddVolume",
+        budb_dissect_AddVolume_request,
+        budb_dissect_AddVolume_response },
+    { 1, "CreateDump",
+        budb_dissect_CreateDump_request,
+        budb_dissect_CreateDump_response },
+    { 2, "DeleteDump",
+        budb_dissect_DeleteDump_request,
+        budb_dissect_DeleteDump_response },
+    { 3, "DeleteTape",
+        budb_dissect_DeleteTape_request,
+        budb_dissect_DeleteTape_response },
+    { 4, "DeleteVDP",
+        budb_dissect_DeleteVDP_request,
+        budb_dissect_DeleteVDP_response },
+    { 5, "FindClone",
+        budb_dissect_FindClone_request,
+        budb_dissect_FindClone_response },
+    { 6, "FindDump",
+        budb_dissect_FindDump_request,
+        budb_dissect_FindDump_response },
+    { 7, "FindLatestDump",
+        budb_dissect_FindLatestDump_request,
+        budb_dissect_FindLatestDump_response },
+    { 8, "FinishDump",
+        budb_dissect_FinishDump_request,
+        budb_dissect_FinishDump_response },
+    { 9, "FinishTape",
+        budb_dissect_FinishTape_request,
+        budb_dissect_FinishTape_response },
+    { 10, "GetDumps",
+        budb_dissect_GetDumps_request,
+        budb_dissect_GetDumps_response },
+    { 11, "GetTapes",
+        budb_dissect_GetTapes_request,
+        budb_dissect_GetTapes_response },
+    { 12, "GetVolumes",
+        budb_dissect_GetVolumes_request,
+        budb_dissect_GetVolumes_response },
+    { 13, "UseTape",
+        budb_dissect_UseTape_request,
+        budb_dissect_UseTape_response },
+    { 14, "GetText",
+        budb_dissect_GetText_request,
+        budb_dissect_GetText_response },
+    { 15, "GetTextVersion",
+        budb_dissect_GetTextVersion_request,
+        budb_dissect_GetTextVersion_response },
+    { 16, "SaveText",
+        budb_dissect_SaveText_request,
+        budb_dissect_SaveText_response },
+    { 17, "FreeAllLocks",
+        budb_dissect_FreeAllLocks_request,
+        budb_dissect_FreeAllLocks_response },
+    { 18, "FreeLock",
+        budb_dissect_FreeLock_request,
+        budb_dissect_FreeLock_response },
+    { 19, "GetInstanceId",
+        budb_dissect_GetInstanceId_request,
+        budb_dissect_GetInstanceId_response },
+    { 20, "GetLock",
+        budb_dissect_GetLock_request,
+        budb_dissect_GetLock_response },
+    { 21, "DbVerify",
+        budb_dissect_DbVerify_request,
+        budb_dissect_DbVerify_response },
+    { 22, "DumpDB",
+        budb_dissect_DumpDB_request,
+        budb_dissect_DumpDB_response },
+    { 23, "RestoreDbHeader",
+        budb_dissect_RestoreDbHeader_request,
+        budb_dissect_RestoreDbHeader_response },
+    { 24, "T_GetVersion",
+        budb_dissect_T_GetVersion_request,
+        budb_dissect_T_GetVersion_response },
+    { 25, "T_DumpHashTable",
+        budb_dissect_T_DumpHashTable_request,
+        budb_dissect_T_DumpHashTable_response },
+    { 26, "T_DumpDatabase",
+        budb_dissect_T_DumpDatabase_request,
+        budb_dissect_T_DumpDatabase_response },
+    { 27, "GetServerInterfaces",
+        budb_dissect_GetServerInterfaces_request,
+        budb_dissect_GetServerInterfaces_response },
+    { 28, "AddVolumes",
+        budb_dissect_AddVolumes_request,
+        budb_dissect_AddVolumes_response },
+/* END OF INCLUDED FILE : ETH_FT */
+
+
+	{ 0, NULL, NULL, NULL },
+};
+
 void
-proto_reg_handoff_budb (void)
+proto_reg_handoff_budb(void)
 {
-	/* Register the protocol as dcerpc */
-	dcerpc_init_uuid (proto_budb, ett_budb, &uuid_budb, ver_budb, budb_dissectors, hf_budb_opnum);
+
+
+/* INCLUDED FILE : ETH_HANDOFF */
+    dcerpc_init_uuid(proto_budb, ett_budb,
+        &uuid_dcerpc_budb, ver_budb,
+        function_dissectors, hf_budb_opnum);
+/* END OF INCLUDED FILE : ETH_HANDOFF */
+
+
 }
diff --git a/epan/dissectors/packet-dcerpc-budb.h b/epan/dissectors/packet-dcerpc-budb.h
new file mode 100644
index 0000000000..6673653b40
--- /dev/null
+++ b/epan/dissectors/packet-dcerpc-budb.h
@@ -0,0 +1,115 @@
+/* DO NOT EDIT
+ * This dissector is autogenerated
+ *   ronnie sahlberg 2005
+ */
+/* packet-dcerpc-budb.h
+ * Routines for BUDB packet disassembly
+ *
+ * $Id: packet-dcerpc-budb.h 11410 2004-07-18 18:06:47Z gram $
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@ethereal.com>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef __PACKET_DCERPC_BUDB_H
+#define __PACKET_DCERPC_BUDB_H
+
+
+
+/* INCLUDED FILE : ETH_HDR */
+#define BU_MAXNAMELEN		128
+#define BU_MAXTAPELEN		256
+#define BU_MAXHOSTLEN		128
+#define BU_MAXTOKENLEN		16
+#define BU_MAXUNAMELEN		256
+#define BU_MAXCELLLEN		256
+#define BU_MAXINAMELEN		128
+#define BU_MAXPATHLEN		256
+#define BU_MAXGENNAMELEN		512
+#define BU_MAXVOLCOUNT		64
+#define BUDB_MAJORVERSION		1
+#define BUDB_PROVIDER_VERSION		2
+#define TB_DUMPSCHEDULE		0
+#define TB_VOLUMESET		1
+#define TB_TAPEHOSTS		2
+#define TB_NUM		3
+#define TB_MAX		6
+#define BUDB_DUMP_INCOMPLETE		1<<0
+#define BUDB_DUMP_TAPEERROR		1<<1
+#define BUDB_DUMP_INPROGRESS		1<<2
+#define BUDB_DUMP_ABORTED		1<<3
+#define BUDB_TAPE_TAPEERROR		1<<0
+#define BUDB_TAPE_DELETED		1<<1
+#define BUDB_TAPE_BEINGWRITTEN		1<<2
+#define BUDB_TAPE_ABORTED		1<<3
+#define BUDB_TAPE_STAGED		1<<4
+#define BUDB_TAPE_WRITTEN		1<<5
+#define BUDB_VOL_TAPEERROR		1<<0
+#define BUDB_VOL_FILEERROR		1<<1
+#define BUDB_VOL_BEINGWRITTEN		1<<2
+#define BUDB_VOL_FIRSTFRAG		1<<3
+#define BUDB_VOL_LASTFRAG		1<<4
+#define BUDB_VOL_ABORTED		1<<5
+#define BUDB_OP_NAMES		0x7
+#define BUDB_OP_STARTS		0x7<<3
+#define BUDB_OP_ENDS		0x7<<6
+#define BUDB_OP_TIMES		0x3<<9
+#define BUDB_OP_MISC		0xff<<16
+#define BUDB_OP_DUMPNAME		1<<0
+#define BUDB_OP_VOLUMENAME		2<<0
+#define BUDB_OP_TAPENAME		3<<0
+#define BUDB_OP_STARTTIME		1<<3
+#define BUDB_OP_RANGE		1<<6
+#define BUDB_OP_NPREVIOUS		2<<6
+#define BUDB_OP_NFOLLOWING		3<<6
+#define BUDB_OP_DUMPID		2<<3
+#define BUDB_OP_CLONETIME		1<<9
+#define BUDB_OP_DUMPTIME		2<<9
+#define BUDB_OP_INCTIME		3<<9
+#define BUDB_OP_FIRSTFRAG		1<<16
+#define BUDB_MAX_RETURN_LIST		1000
+#define BUDB_MAX_CHAR_LIST		1024
+#define BUDB_MAX_VOL_COUNT		64
+#define BUDB_TEXT_COMPLETE		1
+#define SD_DBHEADER		1
+#define SD_DUMP		2
+#define SD_TAPE		3
+#define SD_VOLUME		4
+#define SD_TEXT_DUMPSCHEDULE		5
+#define SD_TEXT_VOLUMESET		6
+#define SD_TEXT_TAPEHOSTS		7
+#define SD_END		8
+int budb_dissect_principal(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_tapeSet(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_dumpEntry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_tapeEntry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_volumeEntry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_volumeList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_dumpList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_tapeList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_charListT(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_DbHeader(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_dbVolume(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_structDumpHeader(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_dfs_interfaceDescription(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+int budb_dissect_dfs_interfaceList(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);
+/* END OF INCLUDED FILE : ETH_HDR */
+
+
+
+#endif /* packet-dcerpc-budb.h */