diff options
author | Ronnie Sahlberg <ronnie_sahlberg@ozemail.com.au> | 2005-02-14 19:56:11 +0000 |
---|---|---|
committer | Ronnie Sahlberg <ronnie_sahlberg@ozemail.com.au> | 2005-02-14 19:56:11 +0000 |
commit | b4b5a4776fb35f7a4431055a1295f5f162e7b355 (patch) | |
tree | 8726b1ba5d1b1dcb3e9baeb7e154d16a5ff06542 /epan | |
parent | 48ffe7c8940fa98e2673e13d176a8c4c33fc8b3a (diff) |
add machinegenerated full dissector for dcedfs BUDB protocol
svn path=/trunk/; revision=13401
Diffstat (limited to 'epan')
-rw-r--r-- | epan/dissectors/dcerpc/budb/Makefile | 16 | ||||
-rwxr-xr-x | epan/dissectors/dcerpc/budb/budb.cnf | 4 | ||||
-rwxr-xr-x | epan/dissectors/dcerpc/budb/budb.idl | 695 | ||||
-rwxr-xr-x | epan/dissectors/dcerpc/budb/template.c | 85 | ||||
-rwxr-xr-x | epan/dissectors/dcerpc/budb/template.h | 34 | ||||
-rw-r--r-- | epan/dissectors/packet-dcerpc-budb.c | 4893 | ||||
-rw-r--r-- | epan/dissectors/packet-dcerpc-budb.h | 115 |
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 */ |