Logo Search packages:      
Sourcecode: wireshark version File versions  Download package

packet-ncp2222.inc

#define FAKE_TREE_IS_VISIBLE  1
/* fake that the tree is visible so that proto.c will not try to
 "fake" generation of finfo values/nodes.
  Thus this means netware dissector is slower than it has to, but it wont crash.
  once the dissector is refactored to avoid calling fvalue_ functions directly this faking of whether the tree is visible or not can be removed.
*/


/* packet-ncp2222.inc
 *
 * Routines for NetWare Core Protocol. This C code gets #include'd
 * into packet-ncp2222.c, which is generated from ncp2222.py. It's
 * #include'd instead of being in a separate compilation unit so
 * that all the data tables in packet-ncp2222.c can remain static.
 *
 * Gilbert Ramirez <gram@alumni.rice.edu>
 * Modified to decode NDS packets by Greg Morris <gmorris@novell.com>
 *
 * Portions Copyright (c) Gilbert Ramirez 2000-2002
 * Portions Copyright (c) Novell, Inc. 2000-2003
 *
 * $Id: packet-ncp2222.inc 19073 2006-08-29 08:45:53Z gmorris $
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 2000 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.
 */

#define NCP_PACKET_INIT_COUNT 200
#define PROTO_LENGTH_UNTIL_END -1

gboolean        nds_defragment = TRUE;
gboolean        nds_echo_eid = TRUE;
gboolean        ncp_echo_err = TRUE;
gboolean        ncp_echo_conn = FALSE;
gboolean        ncp_echo_server = TRUE;
gboolean        ncp_echo_file = FALSE;
gboolean        ncp_newstyle = TRUE;

extern dissector_handle_t nds_data_handle;
typedef struct {
        guint32         nds_frag_verb;
        guint32         nds_frag_version;
        guint32         nds_frag_flags;
        guint32         nds_length;
        guint32         nds_frag;
        gboolean        nds_fragmented;
} frag_info;        

frag_info           frags[100];
char    mv_resolve_name_string[128];

const fragment_items nds_frag_items = {
      &ett_nds_segment,
      &ett_nds_segments,
      &hf_nds_segments,
      &hf_nds_segment,
      &hf_nds_segment_overlap,
      &hf_nds_segment_overlap_conflict,
      &hf_nds_segment_multiple_tails,
      &hf_nds_segment_too_long_segment,
      &hf_nds_segment_error,
      NULL,
      "segments"
};

#define NDS_TAG_NO_SUCH_ENTRY       0x00000000
#define NDS_TAG_LOCAL_ENTRY         0x00000001
#define NDS_TAG_REMOTE_ENTRY        0x00000002
#define NDS_TAG_ALIAS_ENTRY         0x00000003
#define NDS_TAG_REFERRAL_INFORMATION      0x00000004
#define NDS_TAG_ENTRY_AND_REFERRALS 0x00000006

static const value_string zensearchenum[] = {
    { 0, "[Root]" },
    { 1, "Object Container" },
    { 2, "Associated Container" },
    { 3, "Selected Container" },
    {0, NULL }
};

static const value_string nds_tags[] = {
        { NDS_TAG_NO_SUCH_ENTRY,        "No Such Entry" },
        { NDS_TAG_LOCAL_ENTRY,          "Local Entry" },
        { NDS_TAG_REMOTE_ENTRY,         "Remote Entry" },
        { NDS_TAG_ALIAS_ENTRY,          "Alias Entry" },
        { NDS_TAG_REFERRAL_INFORMATION, "Referral Information" },
        { NDS_TAG_ENTRY_AND_REFERRALS,  "Entry and Referrals" },
      { 0,  NULL }
};

static const value_string nds_info_type[] = {
        { 0x00000000, "Attribute Names Only / " },
        { 0x00000001, "Attribute Name & Value / " },
        { 0x00000002, "Effective Privileges / " },
        { 0x00000003, "Value Information / " },
        { 0x00000004, "Abbreviated Value / " },
      { 0,  NULL }
};

static const value_string nds_kind_of_changes[] = {
        { 0x00000000, "Add Attribute" },
        { 0x00000001, "Remove Attribute" },
        { 0x00000002, "Add Value" },
        { 0x00000003, "Remove Value" },
        { 0x00000004, "Add Additional Value" },
        { 0x00000005, "Overwrite Value" },
        { 0x00000006, "Clear Attribute" },
        { 0x00000007, "Clear Value" },
      { 0,  NULL }
};

static const value_string es_type[] = {
        { 0x00000000, "No type is specified" },
        { 0x00000001, "Unicode string" },
        { 0x00000002, "Partial name" },
        { 0x00000003, "Referrals" },
        { 0x00000004, "Tuned name" },
        { 0x00000005, "GUID attribute" },
        { 0x00000006, "Local entry ID" },
        { 0x00000007, "Number of defined entry specifiers" },
      { 0,  NULL }
};

static const value_string ncp_rights_vals[] = {
  { 0x00, "No Rights"},
  { 0x01, "Read"},
  { 0x02, "Write"},
  { 0x03, "Read, Write"},
  { 0x04, "Deny Read"},
  { 0x05, "Read, Deny Read"},
  { 0x06, "Write, Deny Read"},
  { 0x07, "Read, Write, Deny Read"},
  { 0x08, "Deny Write"},
  { 0x09, "Read, Deny Write"},
  { 0x0a, "Write, Deny Write"},
  { 0x0b, "Read, Write, Deny Write"},
  { 0x0c, "Deny Read, Deny Write"},
  { 0x0d, "Read, Deny Read, Deny Write"},
  { 0x0e, "Write, Deny Read, Deny Write"},
  { 0x0f, "Read, Write, Deny Read, Deny Write"},
  { 0x10, "Compatibility"},
  { 0x11, "Read, Compatibility"},
  { 0x12, "Write, Compatibility"},
  { 0x13, "Read, Write, Compatibility"},
  { 0x14, "Deny Read, Compatibility"},
  { 0x15, "Read, Deny Read, Compatibility"},
  { 0x16, "Write, Deny Read, Compatibility"},
  { 0x17, "Read, Write, Deny Read, Compatibility"},
  { 0x18, "Deny Write, Compatibility"},
  { 0x19, "Read, Deny Write, Compatibility"},
  { 0x1a, "Write, Deny Write, Compatibility"},
  { 0x1b, "Read, Write, Deny Write, Compatibility"},
  { 0x1c, "Deny Read, Deny Write, Compatibility"},
  { 0x1d, "Read, Deny Read, Deny Write, Compatibility"},
  { 0x1e, "Write, Deny Read, Deny Write, Compatibility"},
  { 0x1f, "Read, Write, Deny Read, Deny Write, Compatibility"},
  { 0x40, "File Write Through"},
  { 0x41, "Read, File Write Through"},
  { 0x42, "Write, File Write Through"},
  { 0x43, "Read, Write, File Write Through"},
  { 0x44, "Deny Read, File Write Through"},
  { 0x45, "Read, Deny Read, File Write Through"},
  { 0x46, "Write, Deny Read, File Write Through"},
  { 0x47, "Read, Write, Deny Read, File Write Through"},
  { 0x48, "Deny Write, File Write Through"},
  { 0x49, "Read, Deny Write, File Write Through"},
  { 0x4a, "Write, Deny Write, File Write Through"},
  { 0x4b, "Read, Write, Deny Write, File Write Through"},
  { 0x4c, "Deny Read, Deny Write, File Write Through"},
  { 0x4d, "Read, Deny Read, Deny Write, File Write Through"},
  { 0x4e, "Write, Deny Read, Deny Write, File Write Through"},
  { 0x4f, "Read, Write, Deny Read, Deny Write, File Write Through"},
  { 0x50, "Compatibility, File Write Through"},
  { 0x51, "Read, Compatibility, File Write Through"},
  { 0x52, "Write, Compatibility, File Write Through"},
  { 0x53, "Read, Write, Compatibility, File Write Through"},
  { 0x54, "Deny Read, Compatibility, File Write Through"},
  { 0x55, "Read, Deny Read, Compatibility, File Write Through"},
  { 0x56, "Write, Deny Read, Compatibility, File Write Through"},
  { 0x57, "Read, Write, Deny Read, Compatibility, File Write Through"},
  { 0x58, "Deny Write, Compatibility, File Write Through"},
  { 0x59, "Read, Deny Write, Compatibility, File Write Through"},
  { 0x5a, "Write, Deny Write, Compatibility, File Write Through"},
  { 0x5b, "Read, Write, Deny Write, Compatibility, File Write Through"},
  { 0x5c, "Deny Read, Deny Write, Compatibility, File Write Through"},
  { 0x5d, "Read, Deny Read, Deny Write, Compatibility, File Write Through"},
  { 0x5e, "Write, Deny Read, Deny Write, Compatibility, File Write Through"},
  { 0x5f, "Read, Write, Deny Read, Deny Write, Compatibility, File Write Through"},
  { 0,    NULL }
};

static const value_string open_create_mode_vals[] = {
    { 0x01, "Open"},
    { 0x02, "Replace"},
    { 0x03, "Open, Replace"},
    { 0x08, "Create"},
    { 0x09, "Open, Create"},
    { 0x0a, "Replace, Create"},
    { 0x0b, "Open, Replace, Create"},
    { 0x20, "64-bit"},
    { 0x21, "Open, 64-bit"},
    { 0x22, "Replace, 64-bit"},
    { 0x23, "Open, Replace, 64-bit"},
    { 0x28, "Create, 64-bit"},
    { 0x29, "Open, Create, 64-bit"},
    { 0x2a, "Replace, Create, 64-bit"},
    { 0x2b, "Open, Replace, Create, 64-bit"},
    { 0x40, "Read Only"},
    { 0x41, "Open, Read Only"},
    { 0x42, "Replace, Read Only"},
    { 0x43, "Open, Replace, Read Only"},
    { 0x48, "Create, Read Only"},
    { 0x49, "Open, Create, Read Only"},
    { 0x4a, "Replace, Create, Read Only"},
    { 0x4b, "Open, Replace, Create, Read Only"},
    { 0x60, "64-bit, Read Only"},
    { 0x61, "Open, 64-bit, Read Only"},
    { 0x62, "Replace, 64-bit, Read Only"},
    { 0x63, "Open, Replace, 64-bit, Read Only"},
    { 0x68, "Create, 64-bit, Read Only"},
    { 0x69, "Open, Create, 64-bit, Read Only"},
    { 0x6a, "Replace, Create, 64-bit, Read Only"},
    { 0x6b, "Open, Replace, Create, 64-bit, Read Only"},
    { 0x80, "Op-Lock"},
    { 0x81, "Open, Op-Lock"},
    { 0x82, "Replace, Op-Lock"},
    { 0x83, "Open, Replace, Op-Lock"},
    { 0x88, "Create, Op-Lock"},
    { 0x89, "Open, Create, Op-Lock"},
    { 0x8a, "Replace, Create, Op-Lock"},
    { 0x8b, "Open, Replace, Create, Op-Lock"},
    { 0xa0, "64-bit, Op-Lock"},
    { 0xa1, "Open, 64-bit, Op-Lock"},
    { 0xa2, "Replace, 64-bit, Op-Lock"},
    { 0xa3, "Open, Replace, 64-bit, Op-Lock"},
    { 0xa8, "Create, 64-bit, Op-Lock"},
    { 0xa9, "Open, Create, 64-bit, Op-Lock"},
    { 0xaa, "Replace, Create, 64-bit, Op-Lock"},
    { 0xab, "Open, Replace, Create, 64-bit, Op-Lock"},
    { 0xc0, "Read Only, Op-Lock"},
    { 0xc1, "Open, Read Only, Op-Lock"},
    { 0xc2, "Replace, Read Only, Op-Lock"},
    { 0xc3, "Open, Replace, Read Only, Op-Lock"},
    { 0xc8, "Create, Read Only, Op-Lock"},
    { 0xc9, "Open, Create, Read Only, Op-Lock"},
    { 0xca, "Replace, Create, Read Only, Op-Lock"},
    { 0xcb, "Open, Replace, Create, Read Only, Op-Lock"},
    { 0xe0, "64-bit, Read Only, Op-Lock"},
    { 0xe1, "Open, 64-bit, Read Only, Op-Lock"},
    { 0xe2, "Replace, 64-bit, Read Only, Op-Lock"},
    { 0xe3, "Open, Replace, 64-bit, Read Only, Op-Lock"},
    { 0xe8, "Create, 64-bit, Read Only, Op-Lock"},
    { 0xe9, "Open, Create, 64-bit, Read Only, Op-Lock"},
    { 0xea, "Replace, Create, 64-bit, Read Only, Op-Lock"},
    { 0xeb, "Open, Replace, Create, 64-bit, Read Only, Op-Lock"},
    { 0,    NULL }
};

static const value_string open_create_action_vals[] = {
    { 0x01, "Opened"},
    { 0x02, "Created"},
    { 0x03, "Opened, Created"},
    { 0x04, "Replaced"},
    { 0x05, "Opened, Replaced"},
    { 0x06, "Created, Replaced"},
    { 0x07, "Opened, Created, Replaced"},
    { 0x08, "Compressed"},
    { 0x09, "Opened, Compressed"},
    { 0x0a, "Created, Compressed"},
    { 0x0b, "Opened, Created, Compressed"},
    { 0x0c, "Replaced, Compressed"},
    { 0x0d, "Opened, Replaced, Compressed"},
    { 0x0e, "Created, Replaced, Compressed"},
    { 0x0f, "Opened, Created, Replaced, Compressed"},
    { 0x80, "Read Only"},
    { 0x81, "Opened, Read Only"},
    { 0x82, "Created, Read Only"},
    { 0x83, "Opened, Created, Read Only"},
    { 0x84, "Replaced, Read Only"},
    { 0x85, "Opened, Replaced, Read Only"},
    { 0x86, "Created, Replaced, Read Only"},
    { 0x87, "Opened, Created, Replaced, Read Only"},
    { 0x88, "Compressed, Read Only"},
    { 0x89, "Opened, Compressed, Read Only"},
    { 0x8a, "Created, Compressed, Read Only"},
    { 0x8b, "Opened, Created, Compressed, Read Only"},
    { 0x8c, "Replaced, Compressed, Read Only"},
    { 0x8d, "Opened, Replaced, Compressed, Read Only"},
    { 0x8e, "Created, Replaced, Compressed, Read Only"},
    { 0x8f, "Opened, Created, Replaced, Compressed, Read Only"},
    { 0,    NULL }
};

static const value_string access_rights_vals[] = {
    { 0x0000, "No Rights"},
      { 0x0001, "Read"},
    { 0x0002, "Write"},
    { 0x0003, "Read, Write"},
    { 0x0004, "Open"},
      { 0x0005, "Read, Open"},
    { 0x0006, "Write, Open"},
    { 0x0007, "Read, Write, Open"},
    { 0x0008, "Create"},
      { 0x0009, "Read, Create"},
    { 0x000a, "Write, Create"},
    { 0x000b, "Read, Write, Create"},
    { 0x000c, "Open, Create"},
      { 0x000d, "Read, Open, Create"},
    { 0x000e, "Write, Open, Create"},
    { 0x000f, "Read, Write, Open, Create"},
    { 0x0010, "Delete"},
      { 0x0011, "Read, Delete"},
    { 0x0012, "Write, Delete"},
    { 0x0013, "Read, Write, Delete"},
    { 0x0014, "Open, Delete"},
      { 0x0015, "Read, Open, Delete"},
    { 0x0016, "Write, Open, Delete"},
    { 0x0017, "Read, Write, Open, Delete"},
    { 0x0018, "Create, Delete"},
      { 0x0019, "Read, Create, Delete"},
    { 0x001a, "Write, Create, Delete"},
    { 0x001b, "Read, Write, Create, Delete"},
    { 0x001c, "Open, Create, Delete"},
      { 0x001d, "Read, Open, Create, Delete"},
    { 0x001e, "Write, Open, Create, Delete"},
    { 0x001f, "Read, Write, Open, Create, Delete"},
    { 0x0020, "Parental"},
      { 0x0021, "Read, Parental"},
    { 0x0022, "Write, Parental"},
    { 0x0023, "Read, Write, Parental"},
    { 0x0024, "Open, Parental"},
      { 0x0025, "Read, Open, Parental"},
    { 0x0026, "Write, Open, Parental"},
    { 0x0027, "Read, Write, Open, Parental"},
    { 0x0028, "Create, Parental"},
      { 0x0029, "Read, Create, Parental"},
    { 0x002a, "Write, Create, Parental"},
    { 0x002b, "Read, Write, Create, Parental"},
    { 0x002c, "Open, Create, Parental"},
      { 0x002d, "Read, Open, Create, Parental"},
    { 0x002e, "Write, Open, Create, Parental"},
    { 0x002f, "Read, Write, Open, Create, Parental"},
    { 0x0030, "Delete, Parental"},
      { 0x0031, "Read, Delete, Parental"},
    { 0x0032, "Write, Delete, Parental"},
    { 0x0033, "Read, Write, Delete, Parental"},
    { 0x0034, "Open, Delete, Parental"},
      { 0x0035, "Read, Open, Delete, Parental"},
    { 0x0036, "Write, Open, Delete, Parental"},
    { 0x0037, "Read, Write, Open, Delete, Parental"},
    { 0x0038, "Create, Delete, Parental"},
      { 0x0039, "Read, Create, Delete, Parental"},
    { 0x003a, "Write, Create, Delete, Parental"},
    { 0x003b, "Read, Write, Create, Delete, Parental"},
    { 0x003c, "Open, Create, Delete, Parental"},
      { 0x003d, "Read, Open, Create, Delete, Parental"},
    { 0x003e, "Write, Open, Create, Delete, Parental"},
    { 0x003f, "Read, Write, Open, Create, Delete, Parental"},
    { 0x0040, "Search"},
      { 0x0041, "Read, Search"},
    { 0x0042, "Write, Search"},
    { 0x0043, "Read, Write, Search"},
    { 0x0044, "Open, Search"},
      { 0x0045, "Read, Open, Search"},
    { 0x0046, "Write, Open, Search"},
    { 0x0047, "Read, Write, Open, Search"},
    { 0x0048, "Create, Search"},
      { 0x0049, "Read, Create, Search"},
    { 0x004a, "Write, Create, Search"},
    { 0x004b, "Read, Write, Create, Search"},
    { 0x004c, "Open, Create, Search"},
      { 0x004d, "Read, Open, Create, Search"},
    { 0x004e, "Write, Open, Create, Search"},
    { 0x004f, "Read, Write, Open, Create, Search"},
    { 0x0050, "Delete, Search"},
      { 0x0051, "Read, Delete, Search"},
    { 0x0052, "Write, Delete, Search"},
    { 0x0053, "Read, Write, Delete, Search"},
    { 0x0054, "Open, Delete, Search"},
      { 0x0055, "Read, Open, Delete, Search"},
    { 0x0056, "Write, Open, Delete, Search"},
    { 0x0057, "Read, Write, Open, Delete, Search"},
    { 0x0058, "Create, Delete, Search"},
      { 0x0059, "Read, Create, Delete, Search"},
    { 0x005a, "Write, Create, Delete, Search"},
    { 0x005b, "Read, Write, Create, Delete, Search"},
    { 0x005c, "Open, Create, Delete, Search"},
      { 0x005d, "Read, Open, Create, Delete, Search"},
    { 0x005e, "Write, Open, Create, Delete, Search"},
    { 0x005f, "Read, Write, Open, Create, Delete, Search"},
    { 0x0060, "Parental, Search"},
      { 0x0061, "Read, Parental, Search"},
    { 0x0062, "Write, Parental, Search"},
    { 0x0063, "Read, Write, Parental, Search"},
    { 0x0064, "Open, Parental, Search"},
      { 0x0065, "Read, Open, Parental, Search"},
    { 0x0066, "Write, Open, Parental, Search"},
    { 0x0067, "Read, Write, Open, Parental, Search"},
    { 0x0068, "Create, Parental, Search"},
      { 0x0069, "Read, Create, Parental, Search"},
    { 0x006a, "Write, Create, Parental, Search"},
    { 0x006b, "Read, Write, Create, Parental, Search"},
    { 0x006c, "Open, Create, Parental, Search"},
      { 0x006d, "Read, Open, Create, Parental, Search"},
    { 0x006e, "Write, Open, Create, Parental, Search"},
    { 0x006f, "Read, Write, Open, Create, Parental, Search"},
    { 0x0070, "Delete, Parental, Search"},
      { 0x0071, "Read, Delete, Parental, Search"},
    { 0x0072, "Write, Delete, Parental, Search"},
    { 0x0073, "Read, Write, Delete, Parental, Search"},
    { 0x0074, "Open, Delete, Parental, Search"},
      { 0x0075, "Read, Open, Delete, Parental, Search"},
    { 0x0076, "Write, Open, Delete, Parental, Search"},
    { 0x0077, "Read, Write, Open, Delete, Parental, Search"},
    { 0x0078, "Create, Delete, Parental, Search"},
      { 0x0079, "Read, Create, Delete, Parental, Search"},
    { 0x007a, "Write, Create, Delete, Parental, Search"},
    { 0x007b, "Read, Write, Create, Delete, Parental, Search"},
    { 0x007c, "Open, Create, Delete, Parental, Search"},
      { 0x007d, "Read, Open, Create, Delete, Parental, Search"},
    { 0x007e, "Write, Open, Create, Delete, Parental, Search"},
    { 0x007f, "Read, Write, Open, Create, Delete, Parental, Search"},
    { 0x0080, "Modify"},
      { 0x0081, "Read, Modify"},
    { 0x0082, "Write, Modify"},
    { 0x0083, "Read, Write, Modify"},
    { 0x0084, "Open, Modify"},
      { 0x0085, "Read, Open, Modify"},
    { 0x0086, "Write, Open, Modify"},
    { 0x0087, "Read, Write, Open, Modify"},
    { 0x0088, "Create, Modify"},
      { 0x0089, "Read, Create, Modify"},
    { 0x008a, "Write, Create, Modify"},
    { 0x008b, "Read, Write, Create, Modify"},
    { 0x008c, "Open, Create, Modify"},
      { 0x008d, "Read, Open, Create, Modify"},
    { 0x008e, "Write, Open, Create, Modify"},
    { 0x008f, "Read, Write, Open, Create, Modify"},
    { 0x0090, "Delete, Modify"},
      { 0x0091, "Read, Delete, Modify"},
    { 0x0092, "Write, Delete, Modify"},
    { 0x0093, "Read, Write, Delete, Modify"},
    { 0x0094, "Open, Delete, Modify"},
      { 0x0095, "Read, Open, Delete, Modify"},
    { 0x0096, "Write, Open, Delete, Modify"},
    { 0x0097, "Read, Write, Open, Delete, Modify"},
    { 0x0098, "Create, Delete, Modify"},
      { 0x0099, "Read, Create, Delete, Modify"},
    { 0x009a, "Write, Create, Delete, Modify"},
    { 0x009b, "Read, Write, Create, Delete, Modify"},
    { 0x009c, "Open, Create, Delete, Modify"},
      { 0x009d, "Read, Open, Create, Delete, Modify"},
    { 0x009e, "Write, Open, Create, Delete, Modify"},
    { 0x009f, "Read, Write, Open, Create, Delete, Modify"},
    { 0x00a0, "Parental, Modify"},
      { 0x00a1, "Read, Parental, Modify"},
    { 0x00a2, "Write, Parental, Modify"},
    { 0x00a3, "Read, Write, Parental, Modify"},
    { 0x00a4, "Open, Parental, Modify"},
      { 0x00a5, "Read, Open, Parental, Modify"},
    { 0x00a6, "Write, Open, Parental, Modify"},
    { 0x00a7, "Read, Write, Open, Parental, Modify"},
    { 0x00a8, "Create, Parental, Modify"},
      { 0x00a9, "Read, Create, Parental, Modify"},
    { 0x00aa, "Write, Create, Parental, Modify"},
    { 0x00ab, "Read, Write, Create, Parental, Modify"},
    { 0x00ac, "Open, Create, Parental, Modify"},
      { 0x00ad, "Read, Open, Create, Parental, Modify"},
    { 0x00ae, "Write, Open, Create, Parental, Modify"},
    { 0x00af, "Read, Write, Open, Create, Parental, Modify"},
    { 0x00b0, "Delete, Parental, Modify"},
      { 0x00b1, "Read, Delete, Parental, Modify"},
    { 0x00b2, "Write, Delete, Parental, Modify"},
    { 0x00b3, "Read, Write, Delete, Parental, Modify"},
    { 0x00b4, "Open, Delete, Parental, Modify"},
      { 0x00b5, "Read, Open, Delete, Parental, Modify"},
    { 0x00b6, "Write, Open, Delete, Parental, Modify"},
    { 0x00b7, "Read, Write, Open, Delete, Parental, Modify"},
    { 0x00b8, "Create, Delete, Parental, Modify"},
      { 0x00b9, "Read, Create, Delete, Parental, Modify"},
    { 0x00ba, "Write, Create, Delete, Parental, Modify"},
    { 0x00bb, "Read, Write, Create, Delete, Parental, Modify"},
    { 0x00bc, "Open, Create, Delete, Parental, Modify"},
      { 0x00bd, "Read, Open, Create, Delete, Parental, Modify"},
    { 0x00be, "Write, Open, Create, Delete, Parental, Modify"},
    { 0x00bf, "Read, Write, Open, Create, Delete, Parental, Modify"},
    { 0x00c0, "Search, Modify"},
      { 0x00c1, "Read, Search, Modify"},
    { 0x00c2, "Write, Search, Modify"},
    { 0x00c3, "Read, Write, Search, Modify"},
    { 0x00c4, "Open, Search, Modify"},
      { 0x00c5, "Read, Open, Search, Modify"},
    { 0x00c6, "Write, Open, Search, Modify"},
    { 0x00c7, "Read, Write, Open, Search, Modify"},
    { 0x00c8, "Create, Search, Modify"},
      { 0x00c9, "Read, Create, Search, Modify"},
    { 0x00ca, "Write, Create, Search, Modify"},
    { 0x00cb, "Read, Write, Create, Search, Modify"},
    { 0x00cc, "Open, Create, Search, Modify"},
      { 0x00cd, "Read, Open, Create, Search, Modify"},
    { 0x00ce, "Write, Open, Create, Search, Modify"},
    { 0x00cf, "Read, Write, Open, Create, Search, Modify"},
    { 0x00d0, "Delete, Search, Modify"},
      { 0x00d1, "Read, Delete, Search, Modify"},
    { 0x00d2, "Write, Delete, Search, Modify"},
    { 0x00d3, "Read, Write, Delete, Search, Modify"},
    { 0x00d4, "Open, Delete, Search, Modify"},
      { 0x00d5, "Read, Open, Delete, Search, Modify"},
    { 0x00d6, "Write, Open, Delete, Search, Modify"},
    { 0x00d7, "Read, Write, Open, Delete, Search, Modify"},
    { 0x00d8, "Create, Delete, Search, Modify"},
      { 0x00d9, "Read, Create, Delete, Search, Modify"},
    { 0x00da, "Write, Create, Delete, Search, Modify"},
    { 0x00db, "Read, Write, Create, Delete, Search, Modify"},
    { 0x00dc, "Open, Create, Delete, Search, Modify"},
      { 0x00dd, "Read, Open, Create, Delete, Search, Modify"},
    { 0x00de, "Write, Open, Create, Delete, Search, Modify"},
    { 0x00df, "Read, Write, Open, Create, Delete, Search, Modify"},
    { 0x00e0, "Parental, Search, Modify"},
      { 0x00e1, "Read, Parental, Search, Modify"},
    { 0x00e2, "Write, Parental, Search, Modify"},
    { 0x00e3, "Read, Write, Parental, Search, Modify"},
    { 0x00e4, "Open, Parental, Search, Modify"},
      { 0x00e5, "Read, Open, Parental, Search, Modify"},
    { 0x00e6, "Write, Open, Parental, Search, Modify"},
    { 0x00e7, "Read, Write, Open, Parental, Search, Modify"},
    { 0x00e8, "Create, Parental, Search, Modify"},
      { 0x00e9, "Read, Create, Parental, Search, Modify"},
    { 0x00ea, "Write, Create, Parental, Search, Modify"},
    { 0x00eb, "Read, Write, Create, Parental, Search, Modify"},
    { 0x00ec, "Open, Create, Parental, Search, Modify"},
      { 0x00ed, "Read, Open, Create, Parental, Search, Modify"},
    { 0x00ee, "Write, Open, Create, Parental, Search, Modify"},
    { 0x00ef, "Read, Write, Open, Create, Parental, Search, Modify"},
    { 0x00f0, "Delete, Parental, Search, Modify"},
      { 0x00f1, "Read, Delete, Parental, Search, Modify"},
    { 0x00f2, "Write, Delete, Parental, Search, Modify"},
    { 0x00f3, "Read, Write, Delete, Parental, Search, Modify"},
    { 0x00f4, "Open, Delete, Parental, Search, Modify"},
      { 0x00f5, "Read, Open, Delete, Parental, Search, Modify"},
    { 0x00f6, "Write, Open, Delete, Parental, Search, Modify"},
    { 0x00f7, "Read, Write, Open, Delete, Parental, Search, Modify"},
    { 0x00f8, "Create, Delete, Parental, Search, Modify"},
      { 0x00f9, "Read, Create, Delete, Parental, Search, Modify"},
    { 0x00fa, "Write, Create, Delete, Parental, Search, Modify"},
    { 0x00fb, "Read, Write, Create, Delete, Parental, Search, Modify"},
    { 0x00fc, "Open, Create, Delete, Parental, Search, Modify"},
      { 0x00fd, "Read, Open, Create, Delete, Parental, Search, Modify"},
    { 0x00fe, "Write, Open, Create, Delete, Parental, Search, Modify"},
    { 0x00ff, "Read, Write, Open, Create, Delete, Parental, Search, Modify"},
    { 0x0100, "Supervisor"},
      { 0x0101, "Read, Supervisor"},
    { 0x0102, "Write, Supervisor"},
    { 0x0103, "Read, Write, Supervisor"},
    { 0x0104, "Open, Supervisor"},
      { 0x0105, "Read, Open, Supervisor"},
    { 0x0106, "Write, Open, Supervisor"},
    { 0x0107, "Read, Write, Open, Supervisor"},
    { 0x0108, "Create, Supervisor"},
      { 0x0109, "Read, Create, Supervisor"},
    { 0x010a, "Write, Create, Supervisor"},
    { 0x010b, "Read, Write, Create, Supervisor"},
    { 0x010c, "Open, Create, Supervisor"},
      { 0x010d, "Read, Open, Create, Supervisor"},
    { 0x010e, "Write, Open, Create, Supervisor"},
    { 0x010f, "Read, Write, Open, Create, Supervisor"},
    { 0x0110, "Delete, Supervisor"},
      { 0x0111, "Read, Delete, Supervisor"},
    { 0x0112, "Write, Delete, Supervisor"},
    { 0x0113, "Read, Write, Delete, Supervisor"},
    { 0x0114, "Open, Delete, Supervisor"},
      { 0x0115, "Read, Open, Delete, Supervisor"},
    { 0x0116, "Write, Open, Delete, Supervisor"},
    { 0x0117, "Read, Write, Open, Delete, Supervisor"},
    { 0x0118, "Create, Delete, Supervisor"},
      { 0x0119, "Read, Create, Delete, Supervisor"},
    { 0x011a, "Write, Create, Delete, Supervisor"},
    { 0x011b, "Read, Write, Create, Delete, Supervisor"},
    { 0x011c, "Open, Create, Delete, Supervisor"},
      { 0x011d, "Read, Open, Create, Delete, Supervisor"},
    { 0x011e, "Write, Open, Create, Delete, Supervisor"},
    { 0x011f, "Read, Write, Open, Create, Delete, Supervisor"},
    { 0x0120, "Parental, Supervisor"},
      { 0x0121, "Read, Parental, Supervisor"},
    { 0x0122, "Write, Parental, Supervisor"},
    { 0x0123, "Read, Write, Parental, Supervisor"},
    { 0x0124, "Open, Parental, Supervisor"},
      { 0x0125, "Read, Open, Parental, Supervisor"},
    { 0x0126, "Write, Open, Parental, Supervisor"},
    { 0x0127, "Read, Write, Open, Parental, Supervisor"},
    { 0x0128, "Create, Parental, Supervisor"},
      { 0x0129, "Read, Create, Parental, Supervisor"},
    { 0x012a, "Write, Create, Parental, Supervisor"},
    { 0x012b, "Read, Write, Create, Parental, Supervisor"},
    { 0x012c, "Open, Create, Parental, Supervisor"},
      { 0x012d, "Read, Open, Create, Parental, Supervisor"},
    { 0x012e, "Write, Open, Create, Parental, Supervisor"},
    { 0x012f, "Read, Write, Open, Create, Parental, Supervisor"},
    { 0x0130, "Delete, Parental, Supervisor"},
      { 0x0131, "Read, Delete, Parental, Supervisor"},
    { 0x0132, "Write, Delete, Parental, Supervisor"},
    { 0x0133, "Read, Write, Delete, Parental, Supervisor"},
    { 0x0134, "Open, Delete, Parental, Supervisor"},
      { 0x0135, "Read, Open, Delete, Parental, Supervisor"},
    { 0x0136, "Write, Open, Delete, Parental, Supervisor"},
    { 0x0137, "Read, Write, Open, Delete, Parental, Supervisor"},
    { 0x0138, "Create, Delete, Parental, Supervisor"},
      { 0x0139, "Read, Create, Delete, Parental, Supervisor"},
    { 0x013a, "Write, Create, Delete, Parental, Supervisor"},
    { 0x013b, "Read, Write, Create, Delete, Parental, Supervisor"},
    { 0x013c, "Open, Create, Delete, Parental, Supervisor"},
      { 0x013d, "Read, Open, Create, Delete, Parental, Supervisor"},
    { 0x013e, "Write, Open, Create, Delete, Parental, Supervisor"},
    { 0x013f, "Read, Write, Open, Create, Delete, Parental, Supervisor"},
    { 0x0140, "Search, Supervisor"},
      { 0x0141, "Read, Search, Supervisor"},
    { 0x0142, "Write, Search, Supervisor"},
    { 0x0143, "Read, Write, Search, Supervisor"},
    { 0x0144, "Open, Search, Supervisor"},
      { 0x0145, "Read, Open, Search, Supervisor"},
    { 0x0146, "Write, Open, Search, Supervisor"},
    { 0x0147, "Read, Write, Open, Search, Supervisor"},
    { 0x0148, "Create, Search, Supervisor"},
      { 0x0149, "Read, Create, Search, Supervisor"},
    { 0x014a, "Write, Create, Search, Supervisor"},
    { 0x014b, "Read, Write, Create, Search, Supervisor"},
    { 0x014c, "Open, Create, Search, Supervisor"},
      { 0x014d, "Read, Open, Create, Search, Supervisor"},
    { 0x014e, "Write, Open, Create, Search, Supervisor"},
    { 0x014f, "Read, Write, Open, Create, Search, Supervisor"},
    { 0x0150, "Delete, Search, Supervisor"},
      { 0x0151, "Read, Delete, Search, Supervisor"},
    { 0x0152, "Write, Delete, Search, Supervisor"},
    { 0x0153, "Read, Write, Delete, Search, Supervisor"},
    { 0x0154, "Open, Delete, Search, Supervisor"},
      { 0x0155, "Read, Open, Delete, Search, Supervisor"},
    { 0x0156, "Write, Open, Delete, Search, Supervisor"},
    { 0x0157, "Read, Write, Open, Delete, Search, Supervisor"},
    { 0x0158, "Create, Delete, Search, Supervisor"},
      { 0x0159, "Read, Create, Delete, Search, Supervisor"},
    { 0x015a, "Write, Create, Delete, Search, Supervisor"},
    { 0x015b, "Read, Write, Create, Delete, Search, Supervisor"},
    { 0x015c, "Open, Create, Delete, Search, Supervisor"},
      { 0x015d, "Read, Open, Create, Delete, Search, Supervisor"},
    { 0x015e, "Write, Open, Create, Delete, Search, Supervisor"},
    { 0x015f, "Read, Write, Open, Create, Delete, Search, Supervisor"},
    { 0x0160, "Parental, Search, Supervisor"},
      { 0x0161, "Read, Parental, Search, Supervisor"},
    { 0x0162, "Write, Parental, Search, Supervisor"},
    { 0x0163, "Read, Write, Parental, Search, Supervisor"},
    { 0x0164, "Open, Parental, Search, Supervisor"},
      { 0x0165, "Read, Open, Parental, Search, Supervisor"},
    { 0x0166, "Write, Open, Parental, Search, Supervisor"},
    { 0x0167, "Read, Write, Open, Parental, Search, Supervisor"},
    { 0x0168, "Create, Parental, Search, Supervisor"},
      { 0x0169, "Read, Create, Parental, Search, Supervisor"},
    { 0x016a, "Write, Create, Parental, Search, Supervisor"},
    { 0x016b, "Read, Write, Create, Parental, Search, Supervisor"},
    { 0x016c, "Open, Create, Parental, Search, Supervisor"},
      { 0x016d, "Read, Open, Create, Parental, Search, Supervisor"},
    { 0x016e, "Write, Open, Create, Parental, Search, Supervisor"},
    { 0x016f, "Read, Write, Open, Create, Parental, Search, Supervisor"},
    { 0x0170, "Delete, Parental, Search, Supervisor"},
      { 0x0171, "Read, Delete, Parental, Search, Supervisor"},
    { 0x0172, "Write, Delete, Parental, Search, Supervisor"},
    { 0x0173, "Read, Write, Delete, Parental, Search, Supervisor"},
    { 0x0174, "Open, Delete, Parental, Search, Supervisor"},
      { 0x0175, "Read, Open, Delete, Parental, Search, Supervisor"},
    { 0x0176, "Write, Open, Delete, Parental, Search, Supervisor"},
    { 0x0177, "Read, Write, Open, Delete, Parental, Search, Supervisor"},
    { 0x0178, "Create, Delete, Parental, Search, Supervisor"},
      { 0x0179, "Read, Create, Delete, Parental, Search, Supervisor"},
    { 0x017a, "Write, Create, Delete, Parental, Search, Supervisor"},
    { 0x017b, "Read, Write, Create, Delete, Parental, Search, Supervisor"},
    { 0x017c, "Open, Create, Delete, Parental, Search, Supervisor"},
      { 0x017d, "Read, Open, Create, Delete, Parental, Search, Supervisor"},
    { 0x017e, "Write, Open, Create, Delete, Parental, Search, Supervisor"},
    { 0x017f, "Read, Write, Open, Create, Delete, Parental, Search, Supervisor"},
    { 0x0180, "Modify, Supervisor"},
      { 0x0181, "Read, Modify, Supervisor"},
    { 0x0182, "Write, Modify, Supervisor"},
    { 0x0183, "Read, Write, Modify, Supervisor"},
    { 0x0184, "Open, Modify, Supervisor"},
      { 0x0185, "Read, Open, Modify, Supervisor"},
    { 0x0186, "Write, Open, Modify, Supervisor"},
    { 0x0187, "Read, Write, Open, Modify, Supervisor"},
    { 0x0188, "Create, Modify, Supervisor"},
      { 0x0189, "Read, Create, Modify, Supervisor"},
    { 0x018a, "Write, Create, Modify, Supervisor"},
    { 0x018b, "Read, Write, Create, Modify, Supervisor"},
    { 0x018c, "Open, Create, Modify, Supervisor"},
      { 0x018d, "Read, Open, Create, Modify, Supervisor"},
    { 0x018e, "Write, Open, Create, Modify, Supervisor"},
    { 0x018f, "Read, Write, Open, Create, Modify, Supervisor"},
    { 0x0190, "Delete, Modify, Supervisor"},
      { 0x0191, "Read, Delete, Modify, Supervisor"},
    { 0x0192, "Write, Delete, Modify, Supervisor"},
    { 0x0193, "Read, Write, Delete, Modify, Supervisor"},
    { 0x0194, "Open, Delete, Modify, Supervisor"},
      { 0x0195, "Read, Open, Delete, Modify, Supervisor"},
    { 0x0196, "Write, Open, Delete, Modify, Supervisor"},
    { 0x0197, "Read, Write, Open, Delete, Modify, Supervisor"},
    { 0x0198, "Create, Delete, Modify, Supervisor"},
      { 0x0199, "Read, Create, Delete, Modify, Supervisor"},
    { 0x019a, "Write, Create, Delete, Modify, Supervisor"},
    { 0x019b, "Read, Write, Create, Delete, Modify, Supervisor"},
    { 0x019c, "Open, Create, Delete, Modify, Supervisor"},
      { 0x019d, "Read, Open, Create, Delete, Modify, Supervisor"},
    { 0x019e, "Write, Open, Create, Delete, Modify, Supervisor"},
    { 0x019f, "Read, Write, Open, Create, Delete, Modify, Supervisor"},
    { 0x01a0, "Parental, Modify, Supervisor"},
      { 0x01a1, "Read, Parental, Modify, Supervisor"},
    { 0x01a2, "Write, Parental, Modify, Supervisor"},
    { 0x01a3, "Read, Write, Parental, Modify, Supervisor"},
    { 0x01a4, "Open, Parental, Modify, Supervisor"},
      { 0x01a5, "Read, Open, Parental, Modify, Supervisor"},
    { 0x01a6, "Write, Open, Parental, Modify, Supervisor"},
    { 0x01a7, "Read, Write, Open, Parental, Modify, Supervisor"},
    { 0x01a8, "Create, Parental, Modify, Supervisor"},
      { 0x01a9, "Read, Create, Parental, Modify, Supervisor"},
    { 0x01aa, "Write, Create, Parental, Modify, Supervisor"},
    { 0x01ab, "Read, Write, Create, Parental, Modify, Supervisor"},
    { 0x01ac, "Open, Create, Parental, Modify, Supervisor"},
      { 0x01ad, "Read, Open, Create, Parental, Modify, Supervisor"},
    { 0x01ae, "Write, Open, Create, Parental, Modify, Supervisor"},
    { 0x01af, "Read, Write, Open, Create, Parental, Modify, Supervisor"},
    { 0x01b0, "Delete, Parental, Modify, Supervisor"},
      { 0x01b1, "Read, Delete, Parental, Modify, Supervisor"},
    { 0x01b2, "Write, Delete, Parental, Modify, Supervisor"},
    { 0x01b3, "Read, Write, Delete, Parental, Modify, Supervisor"},
    { 0x01b4, "Open, Delete, Parental, Modify, Supervisor"},
      { 0x01b5, "Read, Open, Delete, Parental, Modify, Supervisor"},
    { 0x01b6, "Write, Open, Delete, Parental, Modify, Supervisor"},
    { 0x01b7, "Read, Write, Open, Delete, Parental, Modify, Supervisor"},
    { 0x01b8, "Create, Delete, Parental, Modify, Supervisor"},
      { 0x01b9, "Read, Create, Delete, Parental, Modify, Supervisor"},
    { 0x01ba, "Write, Create, Delete, Parental, Modify, Supervisor"},
    { 0x01bb, "Read, Write, Create, Delete, Parental, Modify, Supervisor"},
    { 0x01bc, "Open, Create, Delete, Parental, Modify, Supervisor"},
      { 0x01bd, "Read, Open, Create, Delete, Parental, Modify, Supervisor"},
    { 0x01be, "Write, Open, Create, Delete, Parental, Modify, Supervisor"},
    { 0x01bf, "Read, Write, Open, Create, Delete, Parental, Modify, Supervisor"},
    { 0x01c0, "Search, Modify, Supervisor"},
      { 0x01c1, "Read, Search, Modify, Supervisor"},
    { 0x01c2, "Write, Search, Modify, Supervisor"},
    { 0x01c3, "Read, Write, Search, Modify, Supervisor"},
    { 0x01c4, "Open, Search, Modify, Supervisor"},
      { 0x01c5, "Read, Open, Search, Modify, Supervisor"},
    { 0x01c6, "Write, Open, Search, Modify, Supervisor"},
    { 0x01c7, "Read, Write, Open, Search, Modify, Supervisor"},
    { 0x01c8, "Create, Search, Modify, Supervisor"},
      { 0x01c9, "Read, Create, Search, Modify, Supervisor"},
    { 0x01ca, "Write, Create, Search, Modify, Supervisor"},
    { 0x01cb, "Read, Write, Create, Search, Modify, Supervisor"},
    { 0x01cc, "Open, Create, Search, Modify, Supervisor"},
      { 0x01cd, "Read, Open, Create, Search, Modify, Supervisor"},
    { 0x01ce, "Write, Open, Create, Search, Modify, Supervisor"},
    { 0x01cf, "Read, Write, Open, Create, Search, Modify, Supervisor"},
    { 0x01d0, "Delete, Search, Modify, Supervisor"},
      { 0x01d1, "Read, Delete, Search, Modify, Supervisor"},
    { 0x01d2, "Write, Delete, Search, Modify, Supervisor"},
    { 0x01d3, "Read, Write, Delete, Search, Modify, Supervisor"},
    { 0x01d4, "Open, Delete, Search, Modify, Supervisor"},
      { 0x01d5, "Read, Open, Delete, Search, Modify, Supervisor"},
    { 0x01d6, "Write, Open, Delete, Search, Modify, Supervisor"},
    { 0x01d7, "Read, Write, Open, Delete, Search, Modify, Supervisor"},
    { 0x01d8, "Create, Delete, Search, Modify, Supervisor"},
      { 0x01d9, "Read, Create, Delete, Search, Modify, Supervisor"},
    { 0x01da, "Write, Create, Delete, Search, Modify, Supervisor"},
    { 0x01db, "Read, Write, Create, Delete, Search, Modify, Supervisor"},
    { 0x01dc, "Open, Create, Delete, Search, Modify, Supervisor"},
      { 0x01dd, "Read, Open, Create, Delete, Search, Modify, Supervisor"},
    { 0x01de, "Write, Open, Create, Delete, Search, Modify, Supervisor"},
    { 0x01df, "Read, Write, Open, Create, Delete, Search, Modify, Supervisor"},
    { 0x01e0, "Parental, Search, Modify, Supervisor"},
      { 0x01e1, "Read, Parental, Search, Modify, Supervisor"},
    { 0x01e2, "Write, Parental, Search, Modify, Supervisor"},
    { 0x01e3, "Read, Write, Parental, Search, Modify, Supervisor"},
    { 0x01e4, "Open, Parental, Search, Modify, Supervisor"},
      { 0x01e5, "Read, Open, Parental, Search, Modify, Supervisor"},
    { 0x01e6, "Write, Open, Parental, Search, Modify, Supervisor"},
    { 0x01e7, "Read, Write, Open, Parental, Search, Modify, Supervisor"},
    { 0x01e8, "Create, Parental, Search, Modify, Supervisor"},
      { 0x01e9, "Read, Create, Parental, Search, Modify, Supervisor"},
    { 0x01ea, "Write, Create, Parental, Search, Modify, Supervisor"},
    { 0x01eb, "Read, Write, Create, Parental, Search, Modify, Supervisor"},
    { 0x01ec, "Open, Create, Parental, Search, Modify, Supervisor"},
      { 0x01ed, "Read, Open, Create, Parental, Search, Modify, Supervisor"},
    { 0x01ee, "Write, Open, Create, Parental, Search, Modify, Supervisor"},
    { 0x01ef, "Read, Write, Open, Create, Parental, Search, Modify, Supervisor"},
    { 0x01f0, "Delete, Parental, Search, Modify, Supervisor"},
      { 0x01f1, "Read, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01f2, "Write, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01f3, "Read, Write, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01f4, "Open, Delete, Parental, Search, Modify, Supervisor"},
      { 0x01f5, "Read, Open, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01f6, "Write, Open, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01f7, "Read, Write, Open, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01f8, "Create, Delete, Parental, Search, Modify, Supervisor"},
      { 0x01f9, "Read, Create, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01fa, "Write, Create, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01fb, "Read, Write, Create, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01fc, "Open, Create, Delete, Parental, Search, Modify, Supervisor"},
      { 0x01fd, "Read, Open, Create, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01fe, "Write, Open, Create, Delete, Parental, Search, Modify, Supervisor"},
    { 0x01ff, "Read, Write, Open, Create, Delete, Parental, Search, Modify, Supervisor"},
    { 0,    NULL }
};

#define NDS_PTYPE_IPX         0x00000000
#define NDS_PTYPE_IP          0x00000001
#define NDS_PTYPE_SDLC        0x00000002
#define NDS_PTYPE_TR_ON_ETH   0x00000003
#define NDS_PTYPE_OSI         0x00000004
#define NDS_PTYPE_APPLETALK   0x00000005
#define NDS_PTYPE_NETBEUI     0x00000006
#define NDS_PTYPE_SOCKETADDRESS     0x00000007
#define NDS_PTYPE_UDP         0x00000008
#define NDS_PTYPE_TCP         0x00000009
#define NDS_PTYPE_UDPv6       0x0000000a
#define NDS_PTYPE_TCPv6       0x0000000b
#define NDS_PTYPE_INTERNAL    0x0000000c
#define NDS_PTYPE_URL         0x0000000d

static const value_string nds_protocol_type[] = {
        { NDS_PTYPE_IPX,           "(IPX Protocol)" },
        { NDS_PTYPE_IP,            "(IP Protocol)" },
        { NDS_PTYPE_SDLC,          "(SDLC Protocol)" },
        { NDS_PTYPE_TR_ON_ETH,     "(TokenRing on Ethernet Protocol)" },
        { NDS_PTYPE_OSI,           "(OSI Protocol)" },
        { NDS_PTYPE_APPLETALK,     "(AppleTalk Protocol)" },
        { NDS_PTYPE_NETBEUI,       "(NetBEUI Protocol)" },
        { NDS_PTYPE_SOCKETADDRESS, "(Socket Address Protocol)" },
        { NDS_PTYPE_UDP,           "(UDP Protocol)" },
        { NDS_PTYPE_TCP,           "(TCP Protocol)" },
        { NDS_PTYPE_UDPv6,         "(UDP v6 Protocol)" },
        { NDS_PTYPE_TCPv6,         "(TCP v6 Protocol)" },
        { NDS_PTYPE_INTERNAL,      "(Internal Protocol)" },
        { NDS_PTYPE_URL,           "(URL Protocol)" },
      { 0,  NULL }
};


static const value_string nds_syntax[] = {
        { 0x00000000, "Unknown Syntax" },
        { 0x00000001, "Distinguished Name" },
        { 0x00000002, "Case Sensitive Unicode String" },
        { 0x00000003, "Non Case Sensitive Unicode String" },
        { 0x00000004, "Printable String" },
        { 0x00000005, "Numeric String" },
        { 0x00000006, "Case Insensitive List" },
        { 0x00000007, "Boolean" },
        { 0x00000008, "Signed Integer" },
        { 0x00000009, "Binary String" },
        { 0x0000000a, "Telephone Number" },
        { 0x0000000b, "Fax Number" },
        { 0x0000000c, "Network Address" },
        { 0x0000000d, "Binary String List" },
        { 0x0000000e, "Email Address" },
        { 0x0000000f, "File System Path" },
        { 0x00000010, "Replica Pointer" },
        { 0x00000011, "Object ACL" },
        { 0x00000012, "Postal Address" },
        { 0x00000013, "Time Stamp" },
        { 0x00000014, "Class Name" },
        { 0x00000015, "Stream" },
        { 0x00000016, "Counter" },
        { 0x00000017, "Back Link" },
        { 0x00000018, "Time" },
        { 0x00000019, "Typed Name" },
        { 0x0000001a, "Hold" },
        { 0x0000001b, "Interval" },
        { 0,      NULL }
};

static const value_string name_space_type[] = {
        { 0x00000000, "DOS Name Space" },
        { 0x00000001, "MAC Name Space" },
        { 0x00000002, "NFS Name Space" },
        { 0x00000003, "FTAM Name Space" },
        { 0x00000004, "OS/2, Long Name Space" },
        { 0,      NULL }
};

                              
static const value_string nds_replica_state[] = {
        { 0x0000, "On" },
        { 0x0001, "New" },
        { 0x0002, "Dying" },
        { 0x0003, "Locked" },
        { 0x0004, "Create Master State 0" },
        { 0x0005, "Create Master State 1" },
        { 0x0006, "Transition On" },
        { 0x0007, "Dead Replica" },
        { 0x0008, "Begin Add" },
        { 0x000b, "Master Start" },
        { 0x000c, "Master Done" },
        { 0x0017, "Federated" },
        { 0x0030, "Split State 0" },
        { 0x0031, "Split State 1" },
        { 0x0040, "Join State 0" },
        { 0x0041, "Join State 1" },
        { 0x0042, "Join State 2" },
        { 0x0050, "Move Subtree State 0" },
        { 0x0051, "Move Subtree State 1" },
        { 0,      NULL }
};

static const value_string nds_replica_type[] = {
        { 0x0000, "Master" },
        { 0x0001, "Secondary" },
        { 0x0002, "Read Only" },
        { 0x0003, "Sub Ref" },
        { 0,      NULL }
};

static const value_string class_def_type[] = {
        { 0x0000, "Return Class Name" },
        { 0x0001, "Return Class Name, Flag, and Definition" },
        { 0x0002, "Return Class Name, Flag, Definition, and Super Class" },
        { 0x0003, "Return Class Name, Flag, and ASN.1 identifier" },
        { 0x0004, "Return Class Name, Flag, Definition, Super Class, and ACL" },
        { 0x0005, "Return Class Name, Flag, Creation Timestamp, Modification Timestamp, Definition, and ACL" },
        { 0,      NULL }
};

static const value_string nds_search_scope[] = {
        { 0x0000, "Examine the base object only" },
        { 0x0001, "Search the immediate subordinates of the base object" },
        { 0x0002, "Search the base object and all its subordinates" },
        { 0x0003, "Search the base objects and all objects in its partition (Implemented in NDS 8)" },
        { 0,      NULL }
};

static const value_string nds_reply_errors[] = {
        { 0xffffffff, "(-1) Insufficient Space" },
        { 0xffffff89, "(-119) Buffer too Small" },
        { 0xffffff88, "(-120) RR Volume Flag Not Set" },
        { 0xffffff87, "(-121) No Items Found" },
        { 0xffffff86, "(-122) Connection Already Temporary" },
        { 0xffffff85, "(-123) Connection Already Logged In" },
        { 0xffffff84, "(-124) Connection Not Authenticated" },
        { 0xffffff83, "(-125) Connection Not Logged In" },
        { 0xffffff82, "(-126) NCP Boundary Check Failed" },
        { 0xffffff81, "(-127) Lock Waiting" },
        { 0xffffff80, "(-128) Lock Fail" },
        { 0xffffff7f, "(-129) Out of Handles" },
        { 0xffffff7e, "(-130) No Open Privilege" },
        { 0xffffff7d, "(-131) Hard IO Error" },
        { 0xffffff7c, "(-132) No Create Privilege" },
        { 0xffffff7b, "(-133) No Create Delete Privilege" },
        { 0xffffff7a, "(-134) Create Duplicate When Read Only" },
        { 0xffffff79, "(-135) Create File with Invalid Name" },
        { 0xffffff78, "(-136) Invalid File Handle" },
        { 0xffffff77, "(-137) No Search Privilege"   },
        { 0xffffff76, "(-138) No Delete Privilege" },
        { 0xffffff75, "(-139) No Rename Privilege" },
        { 0xffffff74, "(-140) No Set Privilege" },
        { 0xffffff73, "(-141) Some File in Use" },
        { 0xffffff72, "(-142) All File in Use" },
        { 0xffffff71, "(-143) Some Read Only" },
        { 0xffffff70, "(-144) All Read Only" },
        { 0xffffff6f, "(-145) Some names Exist" },
        { 0xffffff6e, "(-146) All Names Exist" },
        { 0xffffff6d, "(-147) No Read Privilege" },
        { 0xffffff6c, "(-148) No Write Privilege" },
        { 0xffffff6b, "(-149) File Detached" },
        { 0xffffff6a, "(-150) No Alloc Space/Target Not a Subdirectory/Insuffficient Memory" },
        { 0xffffff69, "(-151) No Spool Space" },
        { 0xffffff68, "(-152) Invalid Volume" },
        { 0xffffff67, "(-153) Directory Full" },
        { 0xffffff66, "(-154) Rename Across Volume" },
        { 0xffffff65, "(-155) Bad Directory Handle" },
        { 0xffffff64, "(-156) Invalid Path/No Such Extension" },
        { 0xffffff63, "(-157) No Directory Handles" },
        { 0xffffff62, "(-158) Bad File Name" },
        { 0xffffff61, "(-159) Directory Active" },
        { 0xffffff60, "(-160) Directory Not Empty" },
        { 0xffffff5f, "(-161) Directory IO Error" },
        { 0xffffff5e, "(-162) IO Locked" },
        { 0xffffff5d, "(-163) Transaction Restarted" },
        { 0xffffff5c, "(-164) Rename Directory Invalid" },
        { 0xffffff5b, "(-165) Invalid Open/Create Mode" },
        { 0xffffff5a, "(-166) Already in Use" },
        { 0xffffff59, "(-167) Invalid Resource Tag" },
        { 0xffffff58, "(-168) Access Denied" },
        { 0xffffff44, "(-188) Login Signing Required" },
        { 0xffffff43, "(-189) Login Encryption Required" },
        { 0xffffff42, "(-190) Invalid Data Stream" },
        { 0xffffff41, "(-191) Invalid Name Space" },
        { 0xffffff40, "(-192) No Accounting Privileges" },
        { 0xffffff3f, "(-193) No Account Balance" },
        { 0xffffff3e, "(-194) Credit Limit Exceeded" },
        { 0xffffff3d, "(-195) Too Many Holds" },
        { 0xffffff3c, "(-196) Accounting Disabled" },
        { 0xffffff3b, "(-197) Intruder Login Lockout" },
        { 0xffffff3a, "(-198) No Console Rights" },
        { 0xffffff30, "(-208) Queue IO Failure" },
        { 0xffffff2f, "(-209) No Queue" },
        { 0xffffff2e, "(-210) No Queue Server" },
        { 0xffffff2d, "(-211) No Queue Rights" },
        { 0xffffff2c, "(-212) Queue Full" },
        { 0xffffff2b, "(-213) No Queue Job" },
        { 0xffffff2a, "(-214) No Queue Job Rights/Unencrypted Not Allowed" },
        { 0xffffff29, "(-215) Queue In Service/Duplicate Password" },
        { 0xffffff28, "(-216) Queue Not Active/Password Too Short" },
        { 0xffffff27, "(-217) Queue Station Not Server/Maximum Logins Exceeded" },
        { 0xffffff26, "(-218) Queue Halted/Bad Login Time" },
        { 0xffffff25, "(-219) Queue Maximum Servers/Node Address Violation" },
        { 0xffffff24, "(-220) Login Account Expired" },
        { 0xffffff22, "(-222) Bad Password" },
        { 0xffffff21, "(-223) Password Expired" },
        { 0xffffff20, "(-224) No Login Connection Available" },
        { 0xffffff18, "(-232) Write to Group Property" },
        { 0xffffff17, "(-233) Member Already Exists" },
        { 0xffffff16, "(-234) No Such Member" },
        { 0xffffff15, "(-235) Property Not Group" },
        { 0xffffff14, "(-236) No Such Value Set" },
        { 0xffffff13, "(-237) Property Already Exists" },
        { 0xffffff12, "(-238) Object Already Exists" },
        { 0xffffff11, "(-239) Illegal Name" },
        { 0xffffff10, "(-240) Illegal Wildcard" },
        { 0xffffff0f, "(-241) Bindery Security" },
        { 0xffffff0e, "(-242) No Object Read Rights" },
        { 0xffffff0d, "(-243) No Object Rename Rights" },
        { 0xffffff0c, "(-244) No Object Delete Rights" },
        { 0xffffff0b, "(-245) No Object Create Rights" },
        { 0xffffff0a, "(-246) No Property Delete Rights" },
        { 0xffffff09, "(-247) No Property Create Rigths" },
        { 0xffffff08, "(-248) No Property Write Rights" },
        { 0xffffff07, "(-249) No Propery Read Rights" },
        { 0xffffff06, "(-250) Temp Remap" },
        { 0xffffff05, "(-251) Unknown Request/No Such Property" },
        { 0xffffff04, "(-252) Message Queue Full/Target Already Has Message/No Such Object" },
        { 0xffffff03, "(-253) Bad Station Number" },
        { 0xffffff02, "(-254) Bindery Locked/Directory Locked/Spool Delete/Trustee not Found/Timeout" },
        { 0xffffff01, "(-255) Hard Failure" },
        { 0xfffffed3, "(-301) Not Enough Memory" },
        { 0xfffffed2, "(-302) Bad Key" },
        { 0xfffffed1, "(-303) Bad Context" },
        { 0xfffffed0, "(-304) Buffer Full" },
        { 0xfffffecf, "(-305) List Empty" },
        { 0xfffffece, "(-306) Bad Syntax"   },
        { 0xfffffecd, "(-307) Buffer Empty" },
        { 0xfffffecc, "(-308) Bad Verb" },
        { 0xfffffecb, "(-309) Expected Identifier" },
        { 0xfffffeca, "(-310) Expected Equals" },
        { 0xfffffec9, "(-311) Attribute Type Expected" },
        { 0xfffffec8, "(-312) Attribute Type Not Expected" },
        { 0xfffffec7, "(-313) Filter Tree Empty" },
        { 0xfffffec6, "(-314) Invalid Object Name" },
        { 0xfffffec5, "(-315) Expected RDN Delimiter" },
        { 0xfffffec4, "(-316) Too Many Tokens" },
        { 0xfffffec3, "(-317) Inconsistent MultiAVA" },
        { 0xfffffec2, "(-318) Country Name Too Long" },
        { 0xfffffec1, "(-319) Internal Error" },
        { 0xfffffec0, "(-320) Can't Add Root" },
        { 0xfffffebf, "(-321) Unable to Attach" },
        { 0xfffffebe, "(-322) Invalid Iteration Handle" },
        { 0xfffffebd, "(-323) Buffer Zero Length" },
        { 0xfffffebc, "(-324) Invalid Replica Type" },
        { 0xfffffebb, "(-325) Invalid Attribute Syntax" },
        { 0xfffffeba, "(-326) Invalid Filter Syntax" },
        { 0xfffffeb8, "(-328) Unicode Error during Context Creation" },
        { 0xfffffeb7, "(-329) Invalid Union Tag" },
        { 0xfffffeb6, "(-330) Invalid Server Response" },
        { 0xfffffeb5, "(-331) Null Pointer" },
        { 0xfffffeb4, "(-332) No Server Found" },
        { 0xfffffeb3, "(-333) No Connection" },
        { 0xfffffeb2, "(-334) RDN Too Long" },
        { 0xfffffeb1, "(-335) Duplicate Type" },
        { 0xfffffeb0, "(-336) Data Store Failure" },
        { 0xfffffeaf, "(-337) Not Logged In" },
        { 0xfffffeae, "(-338) Invalid Password Characters" },
        { 0xfffffead, "(-339) Failed Server Authentication" },
        { 0xfffffeac, "(-340) Transport Failed" },
        { 0xfffffeab, "(-341) No Such Syntax" },
        { 0xfffffeaa, "(-342) Invalid DS Name" },
        { 0xfffffea9, "(-343) Attribute Name Too Long" },
        { 0xfffffea8, "(-344) Invalid TDS" },
        { 0xfffffea7, "(-345) Invalid DS Version" },
        { 0xfffffea6, "(-346) Unicode Translation" },
        { 0xfffffea5, "(-347) Schema Name Too Long" },
        { 0xfffffea4, "(-348) Unicode File Not Found" },
        { 0xfffffea3, "(-349) Unicode Already Loaded" },
        { 0xfffffea2, "(-350) Not Context Owner" },
        { 0xfffffea1, "(-351) Attempt to Authenticate" },
        { 0xfffffea0, "(-352) No Writable Replicas" },
        { 0xfffffe9f, "(-353) DN Too Long" },
        { 0xfffffe9e, "(-354) Rename Not Allowed" },
        { 0xfffffe9d, "(-355) Not NDS for NT" },
        { 0xfffffe9c, "(-356) NDS for NT - No Domain" },
        { 0xfffffe9b, "(-357) NDS for NT - Sync Disabled" },
        { 0xfffffe9a, "(-358) Iterator Invalid Handle" },
        { 0xfffffe99, "(-359) Iterator Invalid Position" },
        { 0xfffffe98, "(-360) Iterator Invalid Search Data" },
        { 0xfffffe97, "(-361) Iterator Invalid Scope" },
        { 0xfffffda7, "(-601) No Such Entry" },
        { 0xfffffda6, "(-602) No Such Value" },
        { 0xfffffda5, "(-603) No Such Attribute" },
        { 0xfffffda4, "(-604) No Such Class" },
        { 0xfffffda3, "(-605) No Such Partition" },
        { 0xfffffda2, "(-606) Entry Already Exists" },
        { 0xfffffda1, "(-607) Not Effective Class" },
        { 0xfffffda0, "(-608) Illegal Attribute" },
        { 0xfffffd9f, "(-609) Missing Mandatory" },
        { 0xfffffd9e, "(-610) Illegal DS Name" },
        { 0xfffffd9d, "(-611) Illegal Containment" },
        { 0xfffffd9c, "(-612) Can't Have Multiple Values" },
        { 0xfffffd9b, "(-613) Syntax Violation" },
        { 0xfffffd9a, "(-614) Duplicate Value" },
        { 0xfffffd99, "(-615) Attribute Already Exists" },
        { 0xfffffd98, "(-616) Maximum Entries Exist" },
        { 0xfffffd97, "(-617) Database Format" },
        { 0xfffffd96, "(-618) Inconsistent Database" },
        { 0xfffffd95, "(-619) Invalid Comparison" },
        { 0xfffffd94, "(-620) Comparison Failed" },
        { 0xfffffd93, "(-621) Transaction Tracking Disabled" },
        { 0xfffffd92, "(-622) Invalid Transport" },
        { 0xfffffd91, "(-623) Syntax Invalid in Name" },
        { 0xfffffd90, "(-624) Replica Already Exists" },
        { 0xfffffd8f, "(-625) Transport Failure" },
        { 0xfffffd8e, "(-626) All Referrals Failed" },
        { 0xfffffd8d, "(-627) Can't Remove Naming Value" },
        { 0xfffffd8c, "(-628) Object Class Violation" },
        { 0xfffffd8b, "(-629) Entry is Not Leaf" },
        { 0xfffffd8a, "(-630) Different Tree" },
        { 0xfffffd89, "(-631) Illegal Replica Type" },
        { 0xfffffd88, "(-632) System Failure" },
        { 0xfffffd87, "(-633) Invalid Entry for Root" },
        { 0xfffffd86, "(-634) No Referrals" },
        { 0xfffffd85, "(-635) Remote Failure" },
        { 0xfffffd84, "(-636) Unreachable Server" },
        { 0xfffffd83, "(-637) Previous Move in Progress" },
        { 0xfffffd82, "(-638) No Character Mapping" },
        { 0xfffffd81, "(-639) Incomplete Authentication" },
        { 0xfffffd80, "(-640) Invalid Certificate" },
        { 0xfffffd7f, "(-641) Invalid Request" },
        { 0xfffffd7e, "(-642) Invalid Iteration" },
        { 0xfffffd7d, "(-643) Schema is Non-removable" },
        { 0xfffffd7c, "(-644) Schema is in Use" },
        { 0xfffffd7b, "(-645) Class Already Exists" },
        { 0xfffffd7a, "(-646) Bad Naming Attributes" },
        { 0xfffffd79, "(-647) Not Root Partition" },
        { 0xfffffd78, "(-648) Insufficient Stack" },
        { 0xfffffd77, "(-649) Insufficient Buffer" },
        { 0xfffffd76, "(-650) Ambiguous Containment" },
        { 0xfffffd75, "(-651) Ambiguous Naming" },
        { 0xfffffd74, "(-652) Duplicate Mandatory" },
        { 0xfffffd73, "(-653) Duplicate Optional" },
        { 0xfffffd72, "(-654) Partition Busy" },
        { 0xfffffd71, "(-655) Multiple Replicas" },
        { 0xfffffd70, "(-656) Crucial Replica" },
        { 0xfffffd6f, "(-657) Schema Sync in Progress" },
        { 0xfffffd6e, "(-658) Skulk in Progress" },
        { 0xfffffd6d, "(-659) Time Not Synchronized" },
        { 0xfffffd6c, "(-660) Record in Use" },
        { 0xfffffd6b, "(-661) DS Volume Not Mounted" },
        { 0xfffffd6a, "(-662) DS Volume IO Failure" },
        { 0xfffffd69, "(-663) DS Locked" },
        { 0xfffffd68, "(-664) Old Epoch" },
        { 0xfffffd67, "(-665) New Epoch" },
        { 0xfffffd66, "(-666) Incompatible DS Version" },
        { 0xfffffd65, "(-667) Partition Root" },
        { 0xfffffd64, "(-668) Entry Not Container" },
        { 0xfffffd63, "(-669) Failed Authentication" },
        { 0xfffffd62, "(-670) Invalid Context" },
        { 0xfffffd61, "(-671) No Such Parent" },
        { 0xfffffd60, "(-672) No Access" },
        { 0xfffffd5f, "(-673) Replica Not On" },
        { 0xfffffd5e, "(-674) Invalid Name Service" },
        { 0xfffffd5d, "(-675) Invalid Task" },
        { 0xfffffd5c, "(-676) Invalide Connection Handle" },
        { 0xfffffd5b, "(-677) Invalid Identity" },
        { 0xfffffd5a, "(-678) Duplicate ACL" },
        { 0xfffffd59, "(-679) Partition Already Exists" },
        { 0xfffffd58, "(-680) Transport Modified" },
        { 0xfffffd57, "(-681) Alias of an Alias" },
        { 0xfffffd56, "(-682) Auditing Failed" },
        { 0xfffffd55, "(-683) Invalid API Version" },
        { 0xfffffd54, "(-684) Secure NCP Violation" },
        { 0xfffffd53, "(-685) Move in Progress" },
        { 0xfffffd52, "(-686) Not a Leaf Partition" },
        { 0xfffffd51, "(-687) Cannot Abort" },
        { 0xfffffd50, "(-688) Cache Overflow" },
        { 0xfffffd4f, "(-689) Invalid Subordinate Count" },
        { 0xfffffd4e, "(-690) Invalid RDN" },
        { 0xfffffd4d, "(-691) Modification Time Not Current" },
        { 0xfffffd4c, "(-692) Incorrect Base Class" },
        { 0xfffffd4b, "(-693) Missing Reference" },
        { 0xfffffd4a, "(-694) Lost Entry" },
        { 0xfffffd49, "(-695) Agent Already Registered" },
        { 0xfffffd48, "(-696) DS Loader Busy" },
        { 0xfffffd47, "(-697) DS Cannot Reload" },
        { 0xfffffd46, "(-698) Replica in Skulk" },
        { 0xfffffd45, "(-699) Fatal" },
        { 0xfffffd44, "(-700) Obsolete API" },
        { 0xfffffd43, "(-701) Synchronization Disabled" },
        { 0xfffffd42, "(-702) Invalid Parameter" },
        { 0xfffffd41, "(-703) Duplicate Template" },
        { 0xfffffd40, "(-704) No Master Replica" },
        { 0xfffffd3f, "(-705) Duplicate Containment" },
        { 0xfffffd3e, "(-706) Not a Sibling" },
        { 0xfffffd3d, "(-707) Invalid Signature" },
        { 0xfffffd3c, "(-708) Invalid Response" },
        { 0xfffffd3b, "(-709) Insufficient Sockets" },
        { 0xfffffd3a, "(-710) Database Read Fail" },
        { 0xfffffd39, "(-711) Invalid Code Page" },
        { 0xfffffd38, "(-712) Invalid Escape Character" },
        { 0xfffffd37, "(-713) Invalide Delimiters" },
        { 0xfffffd36, "(-714) Not Implemented" },
        { 0xfffffd35, "(-715) Checksum Failure" },
        { 0xfffffd34, "(-716) Checksumming Not Supported" },
        { 0xfffffd33, "(-717) CRC Failure" },
        { 0xfffffd32, "(-718) Invalid Entry Handle" },
        { 0xfffffd31, "(-719) Invalid Value Handle" },
        { 0xfffffd30, "(-720) Connection Denied" },
        { 0xfffffd2f, "(-721) No Such Federation Link" },
        { 0xfffffd2e, "(-722) Operetational Schema Mismatch" },
        { 0xfffffd2d, "(-723) Stream Not Found" },
        { 0xfffffd2c, "(-724) DClient Unavailable" },
        { 0xfffffd2b, "(-725) MASV No Access" },
        { 0xfffffd2a, "(-726) MASV Invalid Request" },
        { 0xfffffd29, "(-727) MASV Failure" },
        { 0xfffffd28, "(-728) MASV Already Exists" },
        { 0xfffffd27, "(-729) MASV Not Found" },
        { 0xfffffd26, "(-730) MASV Bad Range" },
        { 0xfffffd25, "(-731) Value Data" },
        { 0xfffffd24, "(-732) Database Locked" },
        { 0xfffffd21, "(-735) Nothing to Abort" },
        { 0xfffffd20, "(-736) End of Stream" },
        { 0xfffffd1f, "(-737) No Such Template" },
        { 0xfffffd1e, "(-738) SAS Locked" },
        { 0xfffffd1d, "(-739) Invalid SAS Version" },
        { 0xfffffd1c, "(-740) SAS Already Registered" },
        { 0xfffffd1b, "(-741) Name Type Not Supported" },
        { 0xfffffd1a, "(-742) Wrong DS Version" },
        { 0xfffffd19, "(-743) Invalid Control Function" },
        { 0xfffffd18, "(-744) Invalid Control State" },
        { 0xfffffd17, "(-745) Cache in Use" },
        { 0xfffffd16, "(-746) Zero Creation Time" },
        { 0xfffffd15, "(-747) Would Block" },
        { 0xfffffd14, "(-748) Connection Timeout" },
        { 0xfffffd13, "(-749) Too Many Referrals" },
        { 0xfffffd12, "(-750) Operation Cancelled" },
        { 0xfffffd11, "(-751) Unknown Target" },
        { 0xfffffd10, "(-752) GUID Failure" },
        { 0xfffffd0f, "(-753) Incompatible OS" },
        { 0xfffffd0e, "(-754) Callback Cancel" },
        { 0xfffffd0d, "(-755) Invalid Synchronization Data" },
        { 0xfffffd0c, "(-756) Stream Exists" },
        { 0xfffffd0b, "(-757) Auxiliary Has Containment" },
        { 0xfffffd0a, "(-758) Auxiliary Not Container" },
        { 0xfffffd09, "(-759) Auxiliary Not Effective" },
        { 0xfffffd08, "(-760) Auxiliary On Alias" },
        { 0xfffffd07, "(-761) Have Seen State" },
        { 0xfffffd06, "(-762) Verb Locked" },
        { 0xfffffd05, "(-763) Verb Exceeds Table Length" },
        { 0xfffffd04, "(-764) BOF Hit" },
        { 0xfffffd03, "(-765) EOF Hit" },
        { 0xfffffd02, "(-766) Incompatible Replica Version" },
        { 0xfffffd01, "(-767) Query Timeout" },
        { 0xfffffd00, "(-768) Query Maximum Count" },
        { 0xfffffcff, "(-769) Duplicate Naming" },
        { 0xfffffcfe, "(-770) No Transaction Active" },
        { 0xfffffcfd, "(-771) Transaction Active" },
        { 0xfffffcfc, "(-772) Illegal Transaction Operation" },
        { 0xfffffcfb, "(-773) Iterator Syntax" },
        { 0xfffffcfa, "(-774) Repairing DIB" },
        { 0xfffffcf9, "(-775) Invalid OID Format" },
        { 0xfffffcf8, "(-776) Attempted to perform an NDS operation, and the DS agent on this server is closing" },
        { 0xfffffcf7, "(-777) Attempted to modify an object's attribute that is not stored on the sparse replica" },
        { 0xfffffcf6, "(-778) VpVector and VpvUser which must be correlated, are out of sync" },
        { 0xfffffcf5, "(-779) Error Cannot Go Remote" },
        { 0xfffffcf4, "(-780) Request not Supported" },
        { 0xfffffcf3, "(-781) Entry Not Local" },
        { 0xfffffcf2, "(-782) Root Unreachable" },
        { 0xfffffcf1, "(-783) VRDIM Not Initialized" },
        { 0xfffffcf0, "(-784) Wait Timeout" },
        { 0xfffffcef, "(-785) DIB Error" },
        { 0xfffffcee, "(-786) DIB IO Failure" },
        { 0xfffffced, "(-787) Illegal Schema Attribute" },
        { 0xfffffcec, "(-788) Error Schema Partition" },
        { 0xfffffceb, "(-789) Invalid Template" },
        { 0xfffffcea, "(-790) Error Opening File" },
        { 0xfffffce9, "(-791) Error Direct Opening File" },
        { 0xfffffce8, "(-792) Error Creating File" },
        { 0xfffffce7, "(-793) Error Direct Creating File" },
        { 0xfffffce6, "(-794) Error Reading File" },
        { 0xfffffce5, "(-795) Error Direct Reading File" },
        { 0xfffffce4, "(-796) Error Writing File" },
        { 0xfffffce3, "(-797) Error Direct Writing File" },
        { 0xfffffce2, "(-798) Error Positioning in File" },
        { 0xfffffce1, "(-799) Error Getting File Size" },
        { 0xffffe88f, "(-6001) Error Truncating File" },
        { 0xffffe88e, "(-6002) Error Parsing File Name" },
        { 0xffffe88d, "(-6003) Error Closing File" },
        { 0xffffe88c, "(-6004) Error Getting File Info" },
        { 0xffffe88b, "(-6005) Error Expanding File" },
        { 0xffffe88a, "(-6006) Error Getting Free Blocks" },
        { 0xffffe889, "(-6007) Error Checking File Existence" },
        { 0xffffe888, "(-6008) Error Deleting File" },
        { 0xffffe887, "(-6009) Error Renaming File" },
        { 0xffffe886, "(-6010) Error Initializing IO System" },
        { 0xffffe885, "(-6011) Error Flushing File" },
        { 0xffffe884, "(-6012) Error Setting Up for Read" },
        { 0xffffe883, "(-6013) Error Setting up for Write" },
        { 0xffffe882, "(-6014) Error Old View" },
        { 0xffffe881, "(-6015) Server in Skulk" },
        { 0xffffe880, "(-6016) Error Returning Partial Results" },
        { 0xffffe87f, "(-6017) No Such Schema" },
        { 0xffffe87e, "(-6018) Serial Number Mismatch" },
        { 0xffffe87d, "(-6019) Bad Referal Database Serial Number" },
        { 0xffffe87c, "(-6020) Bad Referal Serial Number" },
        { 0xffffe87b, "(-6021) Invalid File Sequence" },
        { 0xffffe87a, "(-6022) Error Referal Trans Gap" },
        { 0xffffe879, "(-6023) Bad Referal File Number" },
        { 0xffffe878, "(-6024) Referal File Not Found" },
        { 0xffffe877, "(-6025) Error Backup Active" },
        { 0xffffe876, "(-6026) Referal Device Full" },
        { 0xffffe875, "(-6027) Unsupported Version" },
        { 0xffffe874, "(-6028) Error Must Wait Checkpoint" },
        { 0xffffe873, "(-6029) Attribute Maintenance in Progress" },
        { 0xffffe872, "(-6030) Error Abort Transaction" },
        { 0xffff0000, "Ok" },
        { 0x0000, "Ok" },
      { 0,  NULL }
};

static const value_string nds_verb2b_flag_vals[] = {
      { 0, "Request Flags (0x0000) - Retain old object name" },
      { 1, "Request Flags (0x0001) - Delete old object name" },
      { 0,  NULL }
};

static void
process_ptvc_record(ptvcursor_t *ptvc, const ptvc_record *rec,
            int *req_cond_results, gboolean really_decode,
            const ncp_record *ncp_rec);

/* NCP packets come in request/reply pairs. The request packets tell the type
 * of NCP request and give a sequence ID. The response, unfortunately, only
 * identifies itself via the sequence ID; you have to know what type of NCP
 * request the request packet contained in order to successfully parse the NCP
 * response. A global method for doing this does not exist in wireshark yet
 * (NFS also requires it), so for now the NCP section will keep its own hash
 * table keeping track of NCP packet types.
 *
 * We construct a conversation specified by the client and server
 * addresses and the connection number; the key representing the unique
 * NCP request then is composed of the pointer to the conversation
 * structure, cast to a "guint" (which may throw away the upper 32
 * bits of the pointer on a P64 platform, but the low-order 32 bits
 * are more likely to differ between conversations than the upper 32 bits),
 * and the sequence number.
 *
 * The value stored in the hash table is the ncp_req_hash_value pointer. This
 * struct tells us the NCP type and gives the ncp2222_record pointer, if
 * ncp_type == 0x2222.
 */
typedef struct {
      conversation_t    *conversation;
      guint8            nw_sequence;
} ncp_req_hash_key;


typedef struct {
      guint32           nw_eid;
} ncp_req_eid_hash_key;

typedef struct {
        ncp_req_eid_hash_key    *nds_eid;
        char                        object_name[256];
        char                    *object_class;
} ncp_req_eid_hash_value;

static GHashTable *ncp_req_hash = NULL;
static GHashTable *ncp_req_eid_hash = NULL;
static GMemChunk *ncp_req_eid_hash_keys = NULL;
static GMemChunk *ncp_req_eid_hash_values = NULL;
static GMemChunk *ncp_req_hash_keys = NULL;
static GMemChunk *ncp_req_hash_values = NULL;

/* Hash Functions */
static gint
ncp_equal(gconstpointer v, gconstpointer v2)
{
      const ncp_req_hash_key  *val1 = (const ncp_req_hash_key*)v;
      const ncp_req_hash_key  *val2 = (const ncp_req_hash_key*)v2;

      if (val1->conversation == val2->conversation &&
          val1->nw_sequence  == val2->nw_sequence ) {
            return 1;
      }
      return 0;
}

static gint
ncp_eid_equal(gconstpointer v, gconstpointer v2)
{
      const ncp_req_eid_hash_key    *val1 = (const ncp_req_eid_hash_key*)v;
      const ncp_req_eid_hash_key    *val2 = (const ncp_req_eid_hash_key*)v2;

        if (val1->nw_eid == val2->nw_eid ) {
            return 1;
      }
      return 0;
}

static guint
ncp_hash(gconstpointer v)
{
      const ncp_req_hash_key  *ncp_key = (const ncp_req_hash_key*)v;
      return GPOINTER_TO_UINT(ncp_key->conversation) + ncp_key->nw_sequence;
}

static guint
ncp_eid_hash(gconstpointer v)
{
      const ncp_req_eid_hash_key    *ncp_eid_key = (const ncp_req_eid_hash_key*)v;
      return GPOINTER_TO_UINT(ncp_eid_key->nw_eid);
}

/* Frees memory used by the ncp_req_hash_value's */
static void
ncp_req_hash_cleanup(gpointer key _U_, gpointer value, gpointer user_data _U_)
{
      ncp_req_hash_value      *request_value = (ncp_req_hash_value*) value;

      if (request_value->req_cond_results) {
            g_free(request_value->req_cond_results);
      }
}

/* Frees memory used by the ncp_req_hash_value's */
static void
ncp_req_eid_hash_cleanup(gpointer key _U_, gpointer value, gpointer user_data _U_)
{
      ncp_req_eid_hash_value  *request_eid_value = (ncp_req_eid_hash_value*) value;

      if (request_eid_value->object_class) {
            g_free(request_eid_value->object_name);
      }
}

/* Initializes the hash table and the mem_chunk area each time a new
 * file is loaded or re-loaded in wireshark */
static void
ncp_init_protocol(void)
{
    int i;

      /* fragment */
      fragment_table_init(&nds_fragment_table);
      reassembled_table_init(&nds_reassembled_table);

    for (i = 0; i < 99; i++) {
        frags[i].nds_frag = 0xfffffff0;
    }
        
      if (ncp_req_hash) {
            g_hash_table_foreach(ncp_req_hash, ncp_req_hash_cleanup, NULL);
            g_hash_table_destroy(ncp_req_hash);
      }
      if (ncp_req_eid_hash) {
            g_hash_table_foreach(ncp_req_eid_hash, ncp_req_eid_hash_cleanup, NULL);
            g_hash_table_destroy(ncp_req_eid_hash);
      }
      if (ncp_req_hash_keys)
            g_mem_chunk_destroy(ncp_req_hash_keys);
      if (ncp_req_hash_values)
            g_mem_chunk_destroy(ncp_req_hash_values);
      if (ncp_req_eid_hash_keys)
            g_mem_chunk_destroy(ncp_req_eid_hash_keys);
      if (ncp_req_eid_hash_values)
            g_mem_chunk_destroy(ncp_req_eid_hash_values);

      ncp_req_hash = g_hash_table_new(ncp_hash, ncp_equal);
      ncp_req_eid_hash = g_hash_table_new(ncp_eid_hash, ncp_eid_equal);
      ncp_req_hash_keys = g_mem_chunk_new("ncp_req_hash_keys",
                  sizeof(ncp_req_hash_key),
                  NCP_PACKET_INIT_COUNT * sizeof(ncp_req_hash_key),
                  G_ALLOC_ONLY);
      ncp_req_hash_values = g_mem_chunk_new("ncp_req_hash_values",
                  sizeof(ncp_req_hash_value),
                  NCP_PACKET_INIT_COUNT * sizeof(ncp_req_hash_value),
                  G_ALLOC_ONLY);
      ncp_req_eid_hash_keys = g_mem_chunk_new("ncp_req_eid_hash_keys",
                  sizeof(ncp_req_eid_hash_key),
                  NCP_PACKET_INIT_COUNT * sizeof(ncp_req_eid_hash_key),
                  G_ALLOC_ONLY);
      ncp_req_eid_hash_values = g_mem_chunk_new("ncp_req_eid_hash_values",
                  sizeof(ncp_req_eid_hash_value),
                  NCP_PACKET_INIT_COUNT * sizeof(ncp_req_eid_hash_value),
                  G_ALLOC_ONLY);
}

/* After the sequential run, we don't need the ncp_request hash and keys
 * anymore; the lookups have already been done and the vital info
 * saved in the reply-packets' private_data in the frame_data struct. */
static void
ncp_postseq_cleanup(void)
{
      if (ncp_req_hash) {
            /* Destroy the hash, but don't clean up request_condition data. */
            /*g_hash_table_destroy(ncp_req_hash);
            ncp_req_hash = NULL;*/
      }
      if (ncp_req_hash_keys) {
            /*g_mem_chunk_destroy(ncp_req_hash_keys);
            ncp_req_hash_keys = NULL;*/
      }
      /* Don't free the ncp_req_hash_values or EID_hash_table, as they're
       * needed during random-access processing of the proto_tree.*/
}

static ncp_req_hash_value*
ncp_hash_insert(conversation_t *conversation, guint8 nw_sequence,
            const ncp_record *ncp_rec)
{
      ncp_req_hash_key        *request_key;
      ncp_req_hash_value            *request_value;

      /* Now remember the request, so we can find it if we later
         a reply to it. */
      request_key = g_mem_chunk_alloc(ncp_req_hash_keys);
      request_key->conversation = conversation;
      request_key->nw_sequence = nw_sequence;

      request_value = g_mem_chunk_alloc(ncp_req_hash_values);
      request_value->ncp_rec = ncp_rec;
      request_value->req_cond_results = NULL;
        request_value->req_nds_flags = 0;
      request_value->nds_request_verb = 0;
      request_value->nds_version = 0;
      strcpy(request_value->object_name, " ");
        request_value->nds_frag = TRUE;
        
        g_hash_table_insert(ncp_req_hash, request_key, request_value);

      return request_value;
}

static ncp_req_eid_hash_value*
ncp_eid_hash_insert(guint32 nw_eid)
{
      ncp_req_eid_hash_key          *request_eid_key;
      ncp_req_eid_hash_value        *request_eid_value;

      /* Now remember the request, so we can find it if we later
         a reply to it. */
      request_eid_key = g_mem_chunk_alloc(ncp_req_eid_hash_keys);
        request_eid_key->nw_eid = nw_eid;

      request_eid_value = g_mem_chunk_alloc(ncp_req_eid_hash_values);
      strcpy(request_eid_value->object_name, " ");
        request_eid_value->object_class = NULL;
        
        g_hash_table_insert(ncp_req_eid_hash, request_eid_key, request_eid_value);

      return request_eid_value;
}

/* Returns the ncp_rec*, or NULL if not found. */
static ncp_req_hash_value*
ncp_hash_lookup(conversation_t *conversation, guint8 nw_sequence)
{
      ncp_req_hash_key        request_key;

      request_key.conversation = conversation;
      request_key.nw_sequence = nw_sequence;

      return g_hash_table_lookup(ncp_req_hash, &request_key);
}

/* Returns the value_rec* for needed EID, or NULL if not found. */
static ncp_req_eid_hash_value*
ncp_eid_hash_lookup(conversation_t *conversation _U_, guint32 nw_eid)
{
      ncp_req_eid_hash_key          request_eid_key;

      request_eid_key.nw_eid = nw_eid;

      return g_hash_table_lookup(ncp_req_eid_hash, &request_eid_key);
}

/* Does NCP func require a subfunction code? */
static gboolean
ncp_requires_subfunc(guint8 func)
{
      const guint8 *ncp_func_requirement = ncp_func_requires_subfunc;

      while (*ncp_func_requirement != 0) {
            if (*ncp_func_requirement == func) {
                  return TRUE;
            }
            ncp_func_requirement++;
      }
      return FALSE;
}

/* Does the NCP func have a length parameter? */
static gboolean
ncp_has_length_parameter(guint8 func)
{
      const guint8 *ncp_func_requirement = ncp_func_has_no_length_parameter;

      while (*ncp_func_requirement != 0) {
            if (*ncp_func_requirement == func) {
                  return FALSE;
            }
            ncp_func_requirement++;
      }
      return TRUE;
}
            

/* Return a ncp_record* based on func and possibly subfunc */
static const ncp_record *
ncp_record_find(guint8 func, guint8 subfunc)
{
      const ncp_record *ncp_rec = ncp_packets;

      while(ncp_rec->func != 0 || ncp_rec->subfunc != 0 ||
            ncp_rec->name != NULL ) {
            if (ncp_rec->func == func) {
                  if (ncp_rec->has_subfunc) {
                        if (ncp_rec->subfunc == subfunc) {
                              return ncp_rec;
                        }
                  }
                  else {
                        return ncp_rec;
                  }
            }
            ncp_rec++;
      }
      return NULL;
}


/* Given a proto_item*, assume it contains an integer value
 * and return a guint from it. */
static guint
get_finfo_value_integer(field_info *finfo)
{
      /* XXX the fvalue functions are no longer safe to call directly
         since we sometimes fake the entries to speed things up.
         this dissector should not call fvalue_ functions directly.
      */
      if(!finfo->value.ftype->get_value_integer){
            return 0;
      }
      return fvalue_get_integer(&finfo->value);
}
static guint
get_item_value(proto_item *item)
{
      return get_finfo_value_integer(PITEM_FINFO(item));
}


static guint
get_finfo_length(field_info *finfo)
{
      return fvalue_length(&finfo->value);
}


static char *
get_finfo_value_string(field_info *finfo)
{
      return fvalue_get(&finfo->value);
}
#if 0
static char *
get_item_string(proto_item *item)
{
      return get_finfo_value_string(PITEM_FINFO(item));
}
#endif

static const char *
get_item_name(proto_item *item)
{
      return PITEM_FINFO(item)->hfinfo->name;
}


typedef proto_item* (*padd_func_t)(ptvcursor_t*, const ptvc_record*);

/*
 * XXX - are these just DOS-format dates and times?
 *
 * Should we put code to understand various date and time formats (UNIX,
 * DOS, SMB weird mutant UNIX, NT, Mac, etc. into libwireshark, and have
 * the "display" member of an HF_ABSOLUTE_TIME field specify whether
 * it's DOS date/DOS time, DOS time/DOS date, NT time, UNIX time_t,
 * UNIX "struct timeval", NFSv3/NFSv4 seconds/nanoseconds, Mac, etc.?
 *
 * What about hijacking the "bitmask" field to specify the precision of
 * the time stamp, or putting a combination of precision and format
 * into the "display" member?
 *
 * What about relative times?  Should they have units (seconds, milliseconds,
 * microseconds, nanoseconds, etc.), precision, and format in there?
 */
typedef struct {
      guint year;
      guint month;
      guint day;
} nw_date_t;

typedef struct {
      guint hour;
      guint minute;
      guint second;
} nw_time_t;

typedef struct {
      char   buffer[1024];
} nw_uni_t;

#define VTYPE_NONE            0     /* no value */
#define VTYPE_UINT8           1
#define VTYPE_UINT16          2
#define VTYPE_UINT32          3
#define VTYPE_STRING          4
#define VTYPE_BITFIELD        5
#define VTYPE_MULTIVALUE_UINT32     6
#define VTYPE_BYTES           7
#define VTYPE_BOOLEAN         8

#define MVTYPE_ATTR_REQUEST         1
#define MVTYPE_ATTR_REPLY           2
#define MVTYPE_ATTR_REQUEST2        3     
#define MVTYPE_READ_CLASS_REQ       4
#define MVTYPE_READ_REPLICAS        5
#define MVTYPE_MODIFY_ATTR_REQUEST  6
#define MVTYPE_ADDR_REFERRAL_REQUEST      7
#define MVTYPE_ADDR_REFERRAL_REPLY  8
#define MVTYPE_LOC_ADDR_REFERRAL_REPLY    9
#define MVTYPE_PROC_ENTRY_SPECIFIERS      10
#define MVTYPE_PRINT_TIMESTAMP            11
#define MVTYPE_LIST_PARTITIONS            12
#define MVTYPE_CLASS_NAMES          13
#define MVTYPE_MODIFY_CLASS         14
#define MVTYPE_ADD_ATTR_REQUEST         15

typedef struct {
        guint8          vtype;
        guint32         vvalue;
        char*           vstring;
        const char*     vdesc;
        guint32         vlength;
        guint32         voffset;
        guint32         hfname;
        const char*     bit1;
        guint32         bit1hfname;
        const char*     bit2;
        guint32         bit2hfname;
        const char*     bit3;
        guint32         bit3hfname;
        const char*     bit4;
        guint32         bit4hfname;
        const char*     bit5;
        guint32         bit5hfname;
        const char*     bit6;
        guint32         bit6hfname;
        const char*     bit7;
        guint32         bit7hfname;
        const char*     bit8;
        guint32         bit8hfname;
        const char*     bit9;
        guint32         bit9hfname;
        const char*     bit10;
        guint32         bit10hfname;
        const char*     bit11;
        guint32         bit11hfname;
        const char*     bit12;
        guint32         bit12hfname;
        const char*     bit13;
        guint32         bit13hfname;
        const char*     bit14;
        guint32         bit14hfname;
        const char*     bit15;
        guint32         bit15hfname;
        const char*     bit16;
        guint32         bit16hfname;
        guint8          mvtype;
        guint32         vflags;
        guint32         nds_version;
} nds_val;        
        

/* Given an integer, fill in a nw_date_t struct. */
static void
uint_to_nwdate(guint data, nw_date_t *nwdate)
{
      nwdate->day   =  data & 0x001f;
      nwdate->month = (data & 0x01e0) >> 5;
      nwdate->year  = ((data & 0xfe00) >> 9) + 1980;
}

/* Given an integer, fill in a nw_time_t struct. */
static void
uint_to_nwtime(guint data, nw_time_t *nwtime)
{
      /* 2-second resolution */
      nwtime->second = (data & 0x001f) * 2;
      nwtime->minute = ((data & 0x07e0) >> 5);
      nwtime->hour   = ((data & 0xf800) >> 11);
}

static proto_item*
padd_normal(ptvcursor_t *ptvc, const ptvc_record *rec)
{
      return 
        ptvcursor_add(ptvc, *rec->hf_ptr,
            rec->length, rec->endianness);
}

static proto_item*
padd_date(ptvcursor_t *ptvc, const ptvc_record *rec)
{
      proto_item  *item;
      nw_date_t   nw_date;
      gint        offset;

      offset = ptvcursor_current_offset(ptvc);

      item = ptvcursor_add(ptvc, *rec->hf_ptr,
            rec->length, rec->endianness);

      uint_to_nwdate(get_item_value(item), &nw_date);
      
      proto_item_set_text(item, "%s", get_item_name(item)); 
      proto_item_append_text(item, ": %04u/%02u/%02u",
                  nw_date.year, nw_date.month, nw_date.day);
      return item;
}

static proto_item*
padd_time(ptvcursor_t *ptvc, const ptvc_record *rec)
{
      proto_item  *item;
      nw_time_t   nw_time;
      gint        offset;

      offset = ptvcursor_current_offset(ptvc);

      item = ptvcursor_add(ptvc, *rec->hf_ptr,
            rec->length, rec->endianness);

      uint_to_nwtime(get_item_value(item), &nw_time);
      
      proto_item_set_text(item, "%s", get_item_name(item)); 
      proto_item_append_text(item, ": %02u:%02u:%02u",
                  nw_time.hour, nw_time.minute, nw_time.second);
      return item;
}


/* Convert a string from little-endian unicode to ascii.  At the moment we
   fake it by taking every odd byte.  )-:  The caller must free the
   result returned. */
static proto_item*
padd_uni(ptvcursor_t *ptvc, const ptvc_record *rec)
{
      proto_item      *item;
        nw_uni_t        nw_uni;
        guint            offset;
        
      strcpy(nw_uni.buffer, "");
        offset = ptvcursor_current_offset(ptvc);

      item = ptvcursor_add(ptvc, *rec->hf_ptr,
            rec->length, rec->endianness);

        proto_item_set_text(item, "%s", get_item_name(item)); 
      proto_item_append_text(item, " %s",
                  nw_uni.buffer);
                                
      return item;
} 

/* Add a value for a ptvc_record, and process the sub-ptvc_record
 * that it points to. */
static void
process_bitfield_sub_ptvc_record(ptvcursor_t *ptvc, const ptvc_record *rec,
            gboolean really_decode)
{
      proto_item        *item;
      proto_tree        *sub_tree;
      const ptvc_record *sub_rec;
      int               current_offset;
      gint              ett;
      ptvcursor_t       *sub_ptvc;

      if (really_decode) {
            /* Save the current offset */
            current_offset = ptvcursor_current_offset(ptvc);

            /* Add the item */
            item = ptvcursor_add(ptvc, *rec->hf_ptr, rec->length,
                        rec->endianness);

            ett = *rec->sub_ptvc_rec->ett;

            /* Make a new protocol sub-tree */
            sub_tree = proto_item_add_subtree(item, ett);

            /* Make a new ptvcursor */
            sub_ptvc = ptvcursor_new(sub_tree, ptvcursor_tvbuff(ptvc),
                        current_offset);

            /* Use it */
            sub_rec = rec->sub_ptvc_rec->ptvc_rec;
            while(sub_rec->hf_ptr != NULL) {
                  DISSECTOR_ASSERT(!sub_rec->sub_ptvc_rec);
                  ptvcursor_add_no_advance(sub_ptvc, *sub_rec->hf_ptr,
                              sub_rec->length, sub_rec->endianness);
                  sub_rec++;
            }

            /* Free it. */
            ptvcursor_free(sub_ptvc);
      }
      else {
            DISSECTOR_ASSERT(rec->length > 0 &&
               proto_registrar_get_nth(*rec->hf_ptr)->type != FT_UINT_STRING);
            ptvcursor_advance(ptvc, rec->length);
      }
}

/* Process a sub-ptvc_record that points to a "struct" ptvc_record. */
static void
process_struct_sub_ptvc_record(ptvcursor_t *ptvc, const ptvc_record *rec,
            int *req_cond_results, gboolean really_decode,
            const ncp_record *ncp_rec)
{
      const ptvc_record *sub_rec;
      gint              ett;
      proto_tree        *old_tree=NULL, *new_tree;
      proto_item        *item=NULL;
      gint              offset=0;

      /* Create a sub-proto_tree? */
      if (rec->sub_ptvc_rec->descr) {
            ett = *rec->sub_ptvc_rec->ett;
            old_tree = ptvcursor_tree(ptvc);
            offset = ptvcursor_current_offset(ptvc);
            item = proto_tree_add_text(old_tree, ptvcursor_tvbuff(ptvc),
                        offset, PROTO_LENGTH_UNTIL_END,
                        rec->sub_ptvc_rec->descr);
            new_tree = proto_item_add_subtree(item, ett);
            ptvcursor_set_tree(ptvc, new_tree);
      }

      /* Get the ptvc_record for the struct and call our caller
       * to process it. */
      sub_rec = rec->sub_ptvc_rec->ptvc_rec;
      process_ptvc_record(ptvc, sub_rec, req_cond_results, really_decode, ncp_rec);

      /* Re-set the tree */
      if (rec->sub_ptvc_rec->descr) {
            if (ptvcursor_current_offset(ptvc) <= offset)
                  THROW(ReportedBoundsError);

            proto_item_set_len(item, ptvcursor_current_offset(ptvc) - offset);
            ptvcursor_set_tree(ptvc, old_tree);
      }
}

/* Run through the table of ptvc_record's and add info to the tree. This
 * is the work-horse of process_ptvc_record(). */
static void
_process_ptvc_record(ptvcursor_t *ptvc, const ptvc_record *rec,
            int *req_cond_results, gboolean really_decode,
            const ncp_record *ncp_rec)
{
      proto_item  *item;
      guint       i, repeat_count;
      padd_func_t func = NULL;

      if (rec->sub_ptvc_rec) {
            /* Repeat this? */
            if (rec->repeat_index == NO_REPEAT) {
                  if (rec->hf_ptr == PTVC_STRUCT) {
                        process_struct_sub_ptvc_record(ptvc, rec,
                                    req_cond_results, really_decode,
                                    ncp_rec);
                  }
                  else {
                        process_bitfield_sub_ptvc_record(ptvc, rec,
                                    really_decode);
                  }
            }
            else {
                  repeat_count = repeat_vars[rec->repeat_index];
                  for (i = 0; i < repeat_count; i++ ) {
                        if (rec->hf_ptr == PTVC_STRUCT) {
                              process_struct_sub_ptvc_record(ptvc, rec,
                                    req_cond_results, really_decode,
                                    ncp_rec);
                        }
                        else {
                              process_bitfield_sub_ptvc_record(ptvc, rec,
                                          really_decode);
                        }
                  }
            }
      }
      else {
            /* If we can't repeat this field, we might use it
             * to set a 'var'. */
            if (rec->repeat_index == NO_REPEAT) {
                  if (really_decode) {
                        /* Handle any special formatting. */
                        switch(rec->special_fmt) {
                              case NCP_FMT_NONE:
                                    func = padd_normal;
                                    break;
                              case NCP_FMT_NW_DATE:
                                    func = padd_date;
                                    break;
                              case NCP_FMT_NW_TIME:
                                    func = padd_time;
                                    break;
                                        case NCP_FMT_UNICODE:
                                                func = padd_uni;
                                                break;        
                              default:
                                    DISSECTOR_ASSERT_NOT_REACHED();
                        }
                        item = func(ptvc, rec);

                        /* Set the value as a 'var' ? */
                        if (rec->var_index != NO_VAR) {
                              repeat_vars[rec->var_index] = get_item_value(item);
                        }
                  }
                  else {
                        /* If we don't decode the field, we
                         * better not use the value to set a var.
                         * Actually, we could, as long as we don't
                         * *use* that var; for now keep this assert in
                         * place. */
                        DISSECTOR_ASSERT(rec->var_index == NO_VAR);

                        /* This had better not be variable-length,
                         * either. */
                        DISSECTOR_ASSERT(rec->length > 0 &&
                           proto_registrar_get_nth(*rec->hf_ptr)->type != FT_UINT_STRING);
                        ptvcursor_advance(ptvc, rec->length);
                  }
            }
            else {
                  /* We do repeat this field. */
                  repeat_count = repeat_vars[rec->repeat_index];
                  if (really_decode) {
                        /* Handle any special formatting. */
                        switch(rec->special_fmt) {
                              case NCP_FMT_NONE:
                                    func = padd_normal;
                                    break;
                              case NCP_FMT_NW_DATE:
                                    func = padd_date;
                                    break;
                              case NCP_FMT_NW_TIME:
                                    func = padd_time;
                                    break;
                                        case NCP_FMT_UNICODE:
                                                func = padd_uni;
                                                break;        
                              default:
                                    DISSECTOR_ASSERT_NOT_REACHED();
                        }
                        for (i = 0; i < repeat_count; i++ ) {
                              func(ptvc, rec);
                        }
                  }
                  else {
                        for (i = 0; i < repeat_count; i++ ) {
                              DISSECTOR_ASSERT(rec->length > 0 &&
                                 proto_registrar_get_nth(*rec->hf_ptr)->type != FT_UINT_STRING);
                              ptvcursor_advance(ptvc, rec->length);
                        }
                  }
            }
      }
}

/* Run through the table of ptvc_record's and add info to the tree.
 * Honor a request condition result. */
static void
process_ptvc_record(ptvcursor_t *ptvc, const ptvc_record *rec,
            int *req_cond_results, gboolean really_decode,
            const ncp_record *ncp_rec)
{
      gboolean decode;

      while(rec->hf_ptr != NULL) {
            decode = really_decode;
            /* If we're supposed to decode, check the request condition
             * results to see if we should override this and *not* decode. */
            if (decode && req_cond_results) {
                  if (rec->req_cond_index != NO_REQ_COND) {
                        if (req_cond_results[rec->req_cond_index] == FALSE) {
                              decode = FALSE;
                        }
                  }
            }
            if (decode || ncp_rec->req_cond_size_type == REQ_COND_SIZE_CONSTANT) {
                  _process_ptvc_record(ptvc, rec, req_cond_results, decode, ncp_rec);
            }
            rec++;
      }
}



/* Clear the repeat_vars array. */
static void
clear_repeat_vars(void)
{
      guint i;

      for (i = 0 ; i < NUM_REPEAT_VARS; i++ ) {
            repeat_vars[i] = 0;
      }
}


/* Given an error_equivalency table and a completion code, return
 * the string representing the error. */
static const char*
ncp_error_string(const error_equivalency *errors, guint8 completion_code)
{

      while (errors->ncp_error_index != -1) {
            if (errors->error_in_packet == completion_code) {
                  return ncp_errors[errors->ncp_error_index];
            }
            errors++;
      }

      return "Unknown Error Code";
}

static const ncp_record ncp1111_request =
      { 0x1, 0x00, NO_SUBFUNC, "Create Connection Service", NCP_GROUP_CONNECTION,
            NULL, NULL, ncp_0x2_errors, NULL, NO_REQ_COND_SIZE, NULL };

static const ncp_record ncp5555_request =
      { 0x5, 0x00, NO_SUBFUNC, "Destroy Connection Service", NCP_GROUP_CONNECTION,
            NULL, NULL, ncp_0x2_errors, NULL, NO_REQ_COND_SIZE, NULL };

static const ncp_record ncpbbbb_request =
      { 0xb, 0x00, NO_SUBFUNC, "Server Broadcast Message", NCP_GROUP_CONNECTION,
            NULL, NULL, ncp_0x2_errors, NULL, NO_REQ_COND_SIZE, NULL };                

static const ncp_record ncplip_echo =
      { 0x1f, 0x00, NO_SUBFUNC, "LIP Echo Packet", NCP_GROUP_CONNECTION,
            NULL, NULL, ncp_0x2_errors, NULL, NO_REQ_COND_SIZE, NULL };

/* Wrapper around proto_tree_free() */
static void free_proto_tree(void *tree)
{
      if (tree) {
            proto_tree_free((proto_tree*) tree);
      }
}

static guint32
align_4(tvbuff_t *tvb, guint32 aoffset)
{
       if(tvb_length_remaining(tvb, aoffset) > 4 )
       {
                return (aoffset%4);
       }
       return 0;
}
       
static void
get_string(tvbuff_t* tvb, guint offset, guint str_length, char *dest_buf)
{
        guint32 i;
        guint16 c_char;
        guint32 length_remaining = 0;

        length_remaining = tvb_length_remaining(tvb, offset);
        if(str_length > length_remaining || str_length > 1024)  
        {
                THROW(ReportedBoundsError);
        }
        dest_buf[0] = '\0';        
        if(str_length == 0)
        {
                return;
        }
        for ( i = 0; i < str_length; i++ )
        {
                c_char = tvb_get_guint8(tvb, offset );
                if (c_char<0x20 || c_char>0x7e)
                {
                        if (c_char != 0x00)
                        { 
                                c_char = '.';
                                dest_buf[i] = c_char & 0xff;
                        }
                        else
                        {
                                i--;
                                str_length--;
                        }
                }
                else
                {
                        dest_buf[i] = c_char & 0xff;
                }
                offset++;
                length_remaining--;
                
                if(length_remaining==1)
                {
                        dest_buf[i+1] = '\0';
                        return;
                }        
        }
        dest_buf[i] = '\0';
        return;
}

static void
uni_to_string(char * data, guint32 str_length, char *dest_buf)
{
        guint32 i;
        guint16 c_char;
        guint32 length_remaining = 0;

        length_remaining = str_length;
        dest_buf[0] = '\0';        
        if(str_length == 0)
        {
                return;
        }
        for ( i = 0; i < str_length; i++ )
        {
                c_char = data[i];
                if (c_char<0x20 || c_char>0x7e)
                {
                        if (c_char != 0x00)
                        { 
                                c_char = '.';
                                dest_buf[i] = c_char & 0xff;
                        }
                        else
                        {
                                i--;
                                str_length--;
                        }
                }
                else
                {
                        dest_buf[i] = c_char & 0xff;
                }
                length_remaining--;
                
                if(length_remaining==0)
                {
                        dest_buf[i+1] = '\0';
                        return;
                }        
        }
        dest_buf[i] = '\0';
        return;
}

/*************************************
* Return based on % format in request
* %d = integer in decimal format = 0
* %x = integer in hex format = 1
* %s = string = 2
**************************************/  
static int
get_info_type(const gchar* check_string)
{
        guint length;
        guint i;
        char char_val;
        
        length =  strlen(check_string);
        
        for (i = 0 ; i < length-1 ; i++ ) {
                char_val = check_string[i+1];
                if (check_string[i] == 0x25 && check_string[i+1] == 0x64) {   /* %d Digits*/
                        return 0;
                } 
                if ( check_string[i] == 0x78 && check_string[i+1] == 0x25 && check_string[i+2] == 0x73) {  /* x%s Bytes*/
                        return 1;
                }
        }
        return 2; /* Normal String */
}                

static void
process_bitfield(proto_tree *ncp_tree, tvbuff_t *tvb, nds_val *values)
{
        gchar                   flags_str[512];
        const gchar             *sep;
      proto_item        *tinew;
      proto_tree        *flags_tree;
        guint32                 i;
        guint32                 bvalue = 0;

        bvalue = 0x00000001;
        flags_str[0]='\0';
        sep="";
        for (i = 0 ; i < (values->vlength*8); i++ ) {
                if (values->vvalue & bvalue) 
                {
                        strcat(flags_str, sep);
                        switch(bvalue){
                                case 0x00000001:
                                        strcat(flags_str, values->bit1);
                                        break;
                                case 0x00000002:        
                                        strcat(flags_str, values->bit2);
                                        break;
                                case 0x00000004:        
                                        strcat(flags_str, values->bit3);
                                        break;
                                case 0x00000008:        
                                        strcat(flags_str, values->bit4);
                                        break;
                                case 0x00000010:        
                                        strcat(flags_str, values->bit5);
                                        break;
                                case 0x00000020:        
                                        strcat(flags_str, values->bit6);
                                        break;
                                case 0x00000040:        
                                        strcat(flags_str, values->bit7);
                                        break;
                                case 0x00000080:        
                                        strcat(flags_str, values->bit8);
                                        break;
                                case 0x00000100:        
                                        strcat(flags_str, values->bit9);
                                        break;
                                case 0x00000200:        
                                        strcat(flags_str, values->bit10);
                                        break;
                                case 0x00000400:        
                                        strcat(flags_str, values->bit11);
                                        break;
                                case 0x00000800:        
                                        strcat(flags_str, values->bit12);
                                        break;
                                case 0x00001000:        
                                        strcat(flags_str, values->bit13);
                                        break;
                                case 0x00002000:        
                                        strcat(flags_str, values->bit14);
                                        break;
                                case 0x00004000:        
                                        strcat(flags_str, values->bit15);
                                        break;
                                case 0x00008000:        
                                        strcat(flags_str, values->bit16);
                                        break;
                                default:
                                        break;
                        }                
                        sep = ", ";
              }
                bvalue = bvalue*2;
        }
        if(values->vlength==4)
        {
            tinew = proto_tree_add_uint_format(ncp_tree, values->hfname,
                      tvb, values->voffset, values->vlength, values->vvalue, "%s 0x%08x",
                        values->vdesc, values->vvalue);
      }
        else
        {                
              tinew = proto_tree_add_uint_format(ncp_tree, values->hfname,
                      tvb, values->voffset, values->vlength, values->vvalue, "%s 0x%04x",
                        values->vdesc, values->vvalue);
        }
      if (flags_str[0] != '\0')
              proto_item_append_text(tinew, " - (%s)", flags_str);
                                                        
      flags_tree = proto_item_add_subtree(tinew, ett_nds);
                                                
        bvalue = 0x00000001;
            
        for (i = 0 ; i < (values->vlength*8); i++ ) {
                if (values->vvalue & bvalue) 
                {
                        switch(bvalue)
                        {
                                case 0x00000001:
                                        proto_tree_add_item(flags_tree, values->bit1hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000002:
                                      proto_tree_add_item(flags_tree, values->bit2hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000004:
                                      proto_tree_add_item(flags_tree, values->bit3hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000008:
                                        proto_tree_add_item(flags_tree, values->bit4hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000010:
                                        proto_tree_add_item(flags_tree, values->bit5hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000020:
                                        proto_tree_add_item(flags_tree, values->bit6hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000040:
                                        proto_tree_add_item(flags_tree, values->bit7hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000080:
                                        proto_tree_add_item(flags_tree, values->bit8hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000100:
                                        proto_tree_add_item(flags_tree, values->bit9hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000200:
                                        proto_tree_add_item(flags_tree, values->bit10hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000400:
                                        proto_tree_add_item(flags_tree, values->bit11hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00000800:
                                        proto_tree_add_item(flags_tree, values->bit12hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00001000:
                                        proto_tree_add_item(flags_tree, values->bit13hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00002000:
                                        proto_tree_add_item(flags_tree, values->bit14hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00004000:
                                        proto_tree_add_item(flags_tree, values->bit15hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                case 0x00008000:
                                        proto_tree_add_item(flags_tree, values->bit16hfname, tvb, values->voffset, values->vlength, TRUE);
                                        break;
                                default:
                                        break;
                        }
                }
                bvalue = bvalue*2;
        }
}

/* NCP data from python code can't be accessed directly. Parse the ncp tree and find the items
 * and their associated values. Store results in passed buffer.
 */
static void
build_expert_data(proto_tree *ncp_tree, char *hf_name, char *buffer, int repeat_lookup, gboolean search_structs)
{
      proto_tree        *tree_pointer;
      proto_tree        *tree_loc;
      proto_tree        *struct_tree_pointer;
    char            temp_buffer[256]="\0";
    gboolean        in_struct=FALSE;
       
    tree_loc = ncp_tree->first_child;
      for (tree_pointer=tree_loc; tree_pointer!=NULL; tree_pointer=tree_pointer->next)
      {
        /* We currently only go one structure deap in our search for values */
        if (tree_pointer->first_child && !in_struct && search_structs) {
            struct_tree_pointer = tree_pointer;
            tree_pointer = tree_pointer->first_child;
            in_struct=TRUE;
        }
            if (strcmp(tree_pointer->finfo->hfinfo->abbrev, hf_name)==0)
            {
                  switch (tree_pointer->finfo->hfinfo->type)
                  {
            case 3:                       /* uint8 */
            case 4:                       /* uint16 */
                g_snprintf(buffer, get_finfo_length(tree_pointer->finfo)*4, "%d", get_finfo_value_integer(tree_pointer->finfo));
                        break;

            case 6:             /* uint32 */
                g_snprintf(buffer, get_finfo_length(tree_pointer->finfo)*4, "%08x", get_finfo_value_integer(tree_pointer->finfo));
                        break;
            case 17:
                  case 19:                /* string */
                    uni_to_string(get_finfo_value_string(tree_pointer->finfo), get_finfo_length(tree_pointer->finfo), buffer);
                if (repeat_lookup > 0) {
                    if (strlen(temp_buffer) + strlen(buffer) < 250) {
                        strcat(temp_buffer, buffer);
                        repeat_lookup--;
                        if (repeat_lookup == 0) {
                            strcpy(buffer, temp_buffer);
                            break;
                        }
                        else
                        {
                            strcat(temp_buffer, "/");
                            break;
                        }
                    }
                    else
                    {
                        return;
                    }
                }
                else
                {
                    break;
                }
            case 21:             /* Bytes */
                g_snprintf(buffer, (get_finfo_length(tree_pointer->finfo))*4, "%s", bytes_to_str(get_finfo_value_string(tree_pointer->finfo), get_finfo_length(tree_pointer->finfo)));
                break;
                  default:                /* Dont currently handle. Only need string, integers, and bytes */
                        buffer = "Unsupported Expert Type\0";
                        return;
                  }                       
            if (repeat_lookup ==0) {
                break;
            }
            }
        if (tree_pointer->next==NULL && in_struct && search_structs) {
                tree_pointer = struct_tree_pointer;
                in_struct=FALSE;
        }
      }
    if (strlen(buffer)==0) {
        buffer = "No Value\0";
    }
    return;
}

/* Some NCP data may be desirable to echo to the expert table.
 * But to extract we must have visability to the tree
 * This means that to extract the data we can only perform
 * this code path on the first dissection or a redissect.
 *
 * Should the dissector store this info in memory so that 
 * the data can be reported wihout a complete redissection?
 */
static void
trap_for_expert_event(proto_tree *ncp_tree, packet_info *pinfo, const ncp_record *ncp_rec, int request_reply)
{   
    if (ncp_rec == NULL)
        return;
    /* Request == 0, Reply == 1 */
    if (request_reply==0) {
        if (ncp_echo_file) {
            /* The following allows for Update file handle rights echoed to expert tap. */
            if (ncp_rec->func == 66) { 
                char p_filehandle[15]="\0";

                build_expert_data(ncp_tree, "ncp.file_handle", p_filehandle, 0, FALSE);

                expert_add_info_format(pinfo, NULL, PI_REQUEST_CODE, PI_CHAT, "Close file handle %s", p_filehandle);
            }
            /* The following allows for oplock level 1 file opens echoed to expert tap. */
            if ((ncp_rec->func == 89 || ncp_rec->func == 87) && (ncp_rec->subfunc == 1 || ncp_rec->subfunc == 30 || ncp_rec->subfunc == 32 || ncp_rec->subfunc == 33)) { 
                char oaction[2]="\0";
                char p_filename[256]="\0";
                char p_rights[2]="\0";
                char p_path_count[2]="\0";

                build_expert_data(ncp_tree, "ncp.open_create_mode", oaction, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.desired_access_rights", p_rights, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.path_count", p_path_count, 0, FALSE);

                if (ncp_rec->func == 87) {
                    build_expert_data(ncp_tree, "ncp.path", p_filename, atoi(p_path_count), FALSE);
                }
                else
                {
                    build_expert_data(ncp_tree, "ncp.path16", p_filename, atoi(p_path_count), FALSE);
                }

                expert_add_info_format(pinfo, NULL, PI_REQUEST_CODE, PI_CHAT, "%s: %s, Rights:(%s)", match_strval((atoi(oaction) & 0xeb), open_create_mode_vals), p_filename, match_strval((atoi(p_rights) & 0x5f), ncp_rights_vals));
            }
            /* The following allows for oplock ack's and level 2 request echoed to expert tap. */
            if (ncp_rec->func == 87 && ncp_rec->subfunc == 34) {
                char cc_function[2]="\0";
                char p_filehandle[15]="\0";

                build_expert_data(ncp_tree, "ncp.cc_file_handle", p_filehandle, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.cc_function", cc_function, 0, FALSE);

                expert_add_info_format(pinfo, NULL, PI_REQUEST_CODE, PI_CHAT, "Op-lock on handle %s - %s", p_filehandle, match_strval(atoi(cc_function), ncp_cc_function_vals));
            }
            /* The following allows for Update file handle rights echoed to expert tap. */
            if (ncp_rec->func == 87 && ncp_rec->subfunc == 44) { 
                char p_rights[20]="\0";
                char n_rights[20]="\0";
                char p_filehandle[15]="\0";

                build_expert_data(ncp_tree, "ncp.file_handle", p_filehandle, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.access_rights_mask_word", p_rights, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.new_access_rights_mask", n_rights, 0, FALSE);
                expert_add_info_format(pinfo, NULL, PI_REQUEST_CODE, PI_CHAT, "Change handle %s rights from:(%s) to:(%s)", p_filehandle, match_strval((atoi(p_rights) & 0x1ff), access_rights_vals), match_strval((atoi(n_rights) & 0x1ff), access_rights_vals));
            }
        }
    }
    else
    {

        if (ncp_echo_file) { /* Echo File System Data */
            /* The following allows for oplock level 1 file opens echoed to expert tap. */
            if ((ncp_rec->func == 89 || ncp_rec->func == 87) && (ncp_rec->subfunc == 32 || ncp_rec->subfunc == 1)) { 
                char oaction[2]="\0";
                char oplockflg[2]="\0";
                char p_filehandle[15]="\0";

                build_expert_data(ncp_tree, "ncp.open_create_action", oaction, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.file_handle", p_filehandle, 0, FALSE);

                if (ncp_rec->subfunc == 1) {
                    expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "%s - File handle %s", match_strval((atoi(oaction) & 0x8f), open_create_action_vals), p_filehandle);
                }
                else
                {
                    build_expert_data(ncp_tree, "ncp.o_c_ret_flags", oplockflg, 0, FALSE);
                    expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "%s - File handle %s, %s", match_strval((atoi(oaction) & 0x8f), open_create_action_vals), p_filehandle, match_strval(atoi(oplockflg), ncp_o_c_ret_flags_vals));
                }
            }
            /* The following allows for Update file handle rights echoed to expert tap. */
            if (ncp_rec->func == 87 && ncp_rec->subfunc == 44) { 
                char p_rights[20]="\0";
                char p_filehandle[15]="\0";

                build_expert_data(ncp_tree, "ncp.file_handle", p_filehandle, 0, FALSE);
                build_expert_data(ncp_tree, "ncp.effective_rights", p_rights, 0, FALSE);
                expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "Handle %s effective rights:(%s)", p_filehandle, match_strval((atoi(p_rights) & 0x1ff), access_rights_vals));
            }
        }
        /* The following allows for specific NCP server info to be echoed to the expert tap. */
        if (ncp_rec->func == 23 && ncp_rec->subfunc == 17 && ncp_echo_server) {
            char fsname[50]="\0";
            char p_maj_ver[3]="\0";
            char p_min_ver[3]="\0";
            char p_rev[3]="\0";
            char p_lang[3]="\0";

            /* Get Server name and version info */
            build_expert_data(ncp_tree, "ncp.server_name", fsname, 0, FALSE);
            build_expert_data(ncp_tree, "ncp.product_major_version", p_maj_ver, 0, FALSE);
            build_expert_data(ncp_tree, "ncp.product_minor_version", p_min_ver, 0, FALSE);
            build_expert_data(ncp_tree, "ncp.product_revision_version", p_rev, 0, FALSE);
            build_expert_data(ncp_tree, "ncp.os_language_id", p_lang, 0, FALSE);
            expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "Server %s, version %s.%s, support pack %s, language %s", fsname, 
                                   p_maj_ver, p_min_ver, p_rev, p_lang);
        }
    }
}


static void
print_nds_values(proto_tree *vtree, tvbuff_t *tvb, guint32 syntax_type, nds_val *vvalues)
{
        guint32         value1 = 0;
        guint32         value2 = 0;
        guint32         value3 = 0;
        guint32         value4 = 0;
        guint32         value5 = 0;
        guint32         voffset = 0, oldvoffset;
        guint32         icounter;
        guint32         number_of_values = 0;
        guint32         number_of_items = 0;
        guint32         r;
        proto_item      *vitem;
        proto_tree      *nvtree;
        proto_item      *aditem;
        proto_tree      *adtree;
        const char      *valuestr = NULL;
        guint16         rtype = 0;
        guint16         rstate = 0;
        guint16         rnum = 0;
        guint16         revent = 0;
      gint        length_remaining;

        voffset = vvalues->voffset;
        if(tvb_get_guint8(tvb, voffset) == 0x00)
        {
                voffset = voffset+2;
        }                
        
        number_of_values = tvb_get_letohl(tvb, voffset);
        
        vitem = proto_tree_add_uint_format(vtree, hf_nds_uint32value, tvb, voffset,
                4, number_of_values, "Number of Values: %u", number_of_values);
        
        nvtree = proto_item_add_subtree(vitem, ett_nds);
        
        oldvoffset = voffset;
        voffset = voffset + 4; 
        
        for (icounter = 1 ; icounter <= number_of_values; icounter++ )
        {                      
                if (oldvoffset >= voffset) {
                        proto_tree_add_text(nvtree, tvb, 0, 0, "[ Invalid offset: %u ]", voffset);
                        THROW(ReportedBoundsError);
                }
                oldvoffset = voffset;
                switch(syntax_type)
                {       
                       case 0x00000006:        /* Case Insensitive List */
                       case 0x0000000d:        /* Binary String List */
                       case 0x00000012:        /* Postal Address */
                               voffset += align_4(tvb, voffset);
                               voffset = voffset+4;         
                               number_of_items = tvb_get_letohl(tvb, voffset);
                               voffset = voffset+4;
                               for (r=1; r<=number_of_items; r++)
                               {
                                       value1 = tvb_get_letohl(tvb, voffset);
                                       voffset = voffset + 4;
                                       get_string(tvb, voffset, value1, vvalues->vstring);
                                       proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                           value1, vvalues->vstring);
                                       voffset = voffset + value1;    
                                       voffset += align_4(tvb, voffset);
                               }            
                               break;
                        case 0x00000007:        /* Boolean */
                               voffset+=4;                            /* this is always just a parameter count of 1, so ignore */
                               value1 = tvb_get_guint8(tvb, voffset); /* Boolean value */
                               if (value1==0)
                               {
                                       vvalues->vstring = "False";
                               }
                               else
                               {
                                       vvalues->vstring = "True";
                               }
                               tvb_ensure_bytes_exist(tvb, voffset, 1);
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                           1, vvalues->vstring);
                               voffset=voffset+1;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000009:        /* Binary String */
                               value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                               length_remaining = tvb_length_remaining(tvb, voffset);
                               if(length_remaining == -1 || value1 > (guint32) length_remaining)
                               {
                                        break;
                               }
                               voffset += 4;
                               tvb_ensure_bytes_exist(tvb, voffset, value1);
                               proto_tree_add_bytes(nvtree, hf_value_bytes, tvb, voffset, value1, tvb_get_ptr(tvb, voffset, value1));
                               voffset += value1;
                               voffset += (value1%2);
                               break;
                       case 0x00000015:        /* Stream */
                           value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                           length_remaining = tvb_length_remaining(tvb, voffset);
                           if(length_remaining == -1 || value1 > (guint32) length_remaining)
                           {
                                    break;
                           }
                           proto_tree_add_text(nvtree, tvb, voffset, 4, "No value, Open stream file for data.");
                           voffset += 4;
                           voffset += value1;
                           voffset += (value1%2);
                           break;
                       case 0x00000008:        /* Signed Integer */
                       case 0x00000016:        /* Counter */
                       case 0x00000018:        /* Time */
                       case 0x0000001b:        /* Interval */
                               value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                               voffset = voffset+4;
                               value2 = tvb_get_letohl(tvb, voffset); /* Value */
                               tvb_ensure_bytes_exist(tvb, voffset, value1);
                               if (strcmp(vvalues->vstring, "zendmSearchType")==0) {
                                   proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                            value1, value2, "Value (%d) = %s", value2, match_strval(value2, zensearchenum));
                               }
                               else
                               {
                                   proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                            value1, value2, "Value %d", value2);
                               }
                               voffset = voffset+4;
                               break;
                       case 0x0000000b:        /* Fax Number */
                               value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value1, vvalues->vstring);
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                        value1, vvalues->vstring);
                               voffset = voffset + value1;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x0000000c:        /* Network Address */
                               value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                               voffset = voffset + 4;
                               value2 = tvb_get_letohl(tvb, voffset); /* type of Protocol */
                               valuestr = match_strval(value2, nds_protocol_type);
                               if (valuestr == NULL)
                               { 
                                               valuestr="(Undefined Protocol)";
                               }
                               tvb_ensure_bytes_exist(tvb, voffset, value1);
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                   value1, value2, valuestr, value2);
                               voffset = voffset+4;
                               value3 = tvb_get_letohl(tvb, voffset); /* length of address */
                               voffset = voffset+4;
                               switch (value2)
                               { 
                                        case NDS_PTYPE_IPX:
                                                proto_tree_add_item(nvtree, hf_nds_net, tvb, voffset, 4, FALSE);
                                            proto_tree_add_item(nvtree, hf_nds_node, tvb, voffset+4, 6, FALSE);
                                            proto_tree_add_item(nvtree, hf_nds_socket, tvb, voffset+10, 2, FALSE);
                                                break;
                                        case NDS_PTYPE_IP:
                                          proto_tree_add_item(nvtree, hf_nds_port, tvb, voffset, 2, FALSE);
                                              proto_tree_add_item(nvtree, hf_add_ref_ip, tvb, voffset+2, 4, FALSE);
                                                break;
                                        case NDS_PTYPE_UDP:
                                          proto_tree_add_item(nvtree, hf_nds_port, tvb, voffset, 2, FALSE);
                                              proto_tree_add_item(nvtree, hf_add_ref_udp, tvb, voffset+2, 4, FALSE);
                                                break;
                                        case NDS_PTYPE_TCP:
                                            proto_tree_add_item(nvtree, hf_nds_port, tvb, voffset, 2, FALSE);
                                                proto_tree_add_item(nvtree, hf_add_ref_tcp, tvb, voffset+2, 4, FALSE);
                                                break;
                                        case NDS_PTYPE_URL:
                                                get_string(tvb, voffset, value3, vvalues->vstring);
                                                proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                                        value3, vvalues->vstring);
                                                break;
                                        default:
                                                break;
                               }
                               voffset = voffset + value3;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x0000000f:        /* File System Path */
                               value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                               voffset = voffset + 4;
                               value2 = tvb_get_letohl(tvb, voffset); /* Name Space */
                               valuestr = match_strval(value2, name_space_type);
                               if (valuestr == NULL)
                               {
                                        valuestr = "Unknown Name Space";
                               }
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                        4, valuestr);
                               voffset = voffset+4;
                               value3 = tvb_get_letohl(tvb, voffset); /* Length of Volume name */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value3, vvalues->vstring);
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                        value3, vvalues->vstring);
                               voffset = voffset+value3;
                               voffset += align_4(tvb, voffset);
                               value4 = tvb_get_letohl(tvb, voffset); /* Length of Path name */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value4, vvalues->vstring);
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                        value4, vvalues->vstring);
                               voffset = voffset+value4;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000010:        /* Replica Pointer */
                               value1 = tvb_get_letohl(tvb, voffset); /* length of field */
                               voffset = voffset + 4;
                               value2 = tvb_get_letohl(tvb, voffset); /* Length of Server name */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value2, vvalues->vstring);
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                        value2, vvalues->vstring);
                               voffset = voffset+value2;
                               voffset += align_4(tvb, voffset);
                               rtype = tvb_get_letohs(tvb, voffset); /* replica type */
                               valuestr = match_strval(rtype, nds_replica_type);
                               if (valuestr == NULL)
                               { 
                                        valuestr="(Unknown Replica Type)";
                               }
                               proto_tree_add_string(nvtree, hf_replica_type, tvb, voffset,
                                        2, valuestr);
                               voffset = voffset+2; 
                               rstate = tvb_get_letohs(tvb, voffset); /* replica state */
                               valuestr = match_strval(rstate, nds_replica_state);
                               if (valuestr == NULL)
                               { 
                                        valuestr="(Unknown Replica State)";
                               }
                               proto_tree_add_string(nvtree, hf_replica_state, tvb, voffset,
                                        2, valuestr);
                               voffset = voffset+2;
                               value3 = tvb_get_letohl(tvb, voffset); /* Replica number */
                               proto_tree_add_uint_format(nvtree, hf_replica_number, tvb, voffset, 
                                        4, value3, "Replica Number %d", value3);
                               voffset = voffset+4;
                               if(vvalues->nds_version == 0xfe)
                               {
                                        voffset += 4;
                               }
                               number_of_items = tvb_get_letohl(tvb, voffset);  /* Number of Addresses */
                               aditem = proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, number_of_items, "Number of Addresses: %u", number_of_items);
        
                               adtree = proto_item_add_subtree(aditem, ett_nds);
                               voffset = voffset+4;
                               for (r=1; r <= number_of_items; r++)
                               {
                                        voffset += align_4(tvb, voffset);
                                        value4 = tvb_get_letohl(tvb, voffset); /* type of Protocol */
                                        valuestr = match_strval(value4, nds_protocol_type);
                                        if (valuestr == NULL)
                                        { 
                                               valuestr="(Undefined Protocol)";
                                        }
                                        proto_tree_add_uint_format(adtree, hf_nds_uint32value, tvb, voffset,
                                                4, value4, valuestr, value4);
                                        voffset = voffset+4;
                                        value5 = tvb_get_letohl(tvb, voffset); /* length of address */
                                        voffset = voffset+4;
                                        switch (value4)
                                        { 
                                                case NDS_PTYPE_IPX:
                                                        proto_tree_add_item(adtree, hf_nds_net, tvb, voffset, 4, FALSE);
                                                    proto_tree_add_item(adtree, hf_nds_node, tvb, voffset+4, 6, FALSE);
                                                    proto_tree_add_item(adtree, hf_nds_socket, tvb, voffset+10, 2, FALSE);
                                                        break;
                                                case NDS_PTYPE_IP:
                                                  proto_tree_add_item(adtree, hf_nds_port, tvb, voffset, 2, FALSE);
                                                      proto_tree_add_item(adtree, hf_add_ref_ip, tvb, voffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_UDP:
                                                  proto_tree_add_item(adtree, hf_nds_port, tvb, voffset, 2, FALSE);
                                                      proto_tree_add_item(adtree, hf_add_ref_udp, tvb, voffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_TCP:
                                                    proto_tree_add_item(adtree, hf_nds_port, tvb, voffset, 2, FALSE);
                                                        proto_tree_add_item(adtree, hf_add_ref_tcp, tvb, voffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_URL:
                                                        get_string(tvb, voffset, value5, vvalues->vstring);
                                                        proto_tree_add_string(adtree, hf_value_string, tvb, voffset, 
                                                                value5, vvalues->vstring);
                                                        break;
                                                default:
                                                        break;
                                        }
                                        voffset = voffset + value5;
                               }            
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000011:        /* Object ACL */
                               value1 = tvb_get_letohl(tvb, voffset); /* Length of Field */
                               voffset = voffset + 4;
                               value2 = tvb_get_letohl(tvb, voffset);
                               voffset = voffset + 4;
                               get_string(tvb, voffset, value2, vvalues->vstring); /* Unicode String */
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                   value2, vvalues->vstring);
                               voffset = voffset + value2;    
                               voffset += align_4(tvb, voffset);
                               value3 = tvb_get_letohl(tvb, voffset);
                               voffset = voffset + 4;
                               get_string(tvb, voffset, value3, vvalues->vstring); /* Unicode Subject Name */
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                   value3, vvalues->vstring);
                               voffset = voffset + value3;    
                               voffset += align_4(tvb, voffset);
                               value4 = tvb_get_letohl(tvb, voffset);         /* Privileges */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value4, "Privileges %8x", value4);
                               voffset = voffset+4;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000013:        /* Time Stamp */
                               value1 = tvb_get_letohl(tvb, voffset);         /* Seconds */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value1, "Lenght of Record: %d", value1);
                               voffset = voffset+4;
                               value2 = tvb_get_letohl(tvb, voffset);
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value2, "Seconds: %d", value2);
                               voffset = voffset + 4;
                               rnum = tvb_get_letohs(tvb, voffset); /* replica number */
                               proto_tree_add_uint_format(nvtree, hf_nds_rnum, tvb, voffset,
                                        2, rnum, "Replica Number: %d", rnum);
                               voffset = voffset+2;
                               revent = tvb_get_letohs(tvb, voffset); /* Event */
                               proto_tree_add_uint_format(nvtree, hf_nds_revent, tvb, voffset,
                                        2, revent, "Event: %d", revent);
                               voffset = voffset+2;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000017:        /* Back Link */
                               value1 = tvb_get_letohl(tvb, voffset);         /* Length */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value1, "Length of Record %08x", value1);
                               voffset = voffset+4;
                               value2 = tvb_get_letohl(tvb, voffset);         /* Remote ID */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value2, "Remote ID %08x", value2);
                               voffset = voffset+4;
                               value3 = tvb_get_letohl(tvb, voffset);         /* Length of string */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value3, vvalues->vstring);
                               proto_tree_add_string_format(nvtree, hf_value_string, tvb, voffset, 
                                        value3, vvalues->vstring,
                                        "Server Distinguished Name - %s", vvalues->vstring);
                               voffset = voffset+value3;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000019:        /* Typed Name */
                               value1 = tvb_get_letohl(tvb, voffset);         /* Length */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value1, "Length of Record %08x", value1);
                               voffset = voffset+4;
                               value2 = tvb_get_letohl(tvb, voffset);         /* Level */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value2, "Level %d", value2);
                               voffset = voffset+4;
                               value3 = tvb_get_letohl(tvb, voffset);         /* Interval */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value3, "Interval %d", value3);
                               voffset = voffset+4;
                               value4 = tvb_get_letohl(tvb, voffset);         /* Distinguished Name */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value4, vvalues->vstring);
                               proto_tree_add_string_format(nvtree, hf_value_string, tvb, voffset, 
                                        value4, vvalues->vstring,
                                        "Distinguished Name - %s", vvalues->vstring);
                               voffset = voffset+value4;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x0000001a:        /* Hold */
                               value1 = tvb_get_letohl(tvb, voffset);         /* Length */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value1, "Length of Record %08x", value1);
                               voffset = voffset+4;
                               value2 = tvb_get_letohl(tvb, voffset);         /* Amount */
                               proto_tree_add_uint_format(nvtree, hf_nds_uint32value, tvb, voffset,
                                        4, value2, "Amount %d", value2);
                               voffset = voffset+4;
                               value3 = tvb_get_letohl(tvb, voffset);         /* Subject */
                               voffset = voffset+4;
                               get_string(tvb, voffset, value3, vvalues->vstring);
                               proto_tree_add_string_format(nvtree, hf_value_string, tvb, voffset, 
                                        value3, vvalues->vstring,
                                        "Subject - %s", vvalues->vstring);
                               voffset = voffset+value3;
                               voffset += align_4(tvb, voffset);
                               break;
                       case 0x00000001:        /* Distinguished Name */
                       case 0x00000002:        /* Case Sensitive Unicode String */
                       case 0x00000003:        /* Non Case Sensitive Unicode String */
                       case 0x00000004:        /* Printable String */
                       case 0x00000005:        /* Numeric String */
                       case 0x0000000a:        /* Telephone Number */
                       case 0x0000000e:        /* Email Address */
                       case 0x00000014:        /* Class Name */
                       default:
                               value1 = tvb_get_letohl(tvb, voffset);
                               voffset = voffset + 4;
                               if (strcmp(vvalues->vstring, "zendmSearchOrder")==0) {
                                   get_string(tvb, voffset, value1, vvalues->vstring);
                                   if (strcmp(vvalues->vstring, "0")==0) {
                                       vvalues->vstring = "Value (0) = Object";
                                   }
                                   if (strcmp(vvalues->vstring, "1")==0) {
                                       vvalues->vstring = "Value (1) = Group";
                                   }
                                   if (strcmp(vvalues->vstring, "2")==0) {
                                       vvalues->vstring = "Value (2) = Container";
                                   }
                                   if (strcmp(vvalues->vstring, "01")==0) {
                                       vvalues->vstring = "Value (01) = Object, Group";
                                   }
                                   if (strcmp(vvalues->vstring, "02")==0) {
                                       vvalues->vstring = "Value (02) = Object, Container";
                                   }
                                   if (strcmp(vvalues->vstring, "10")==0) {
                                       vvalues->vstring = "Value (10) = Group, Object";
                                   }
                                   if (strcmp(vvalues->vstring, "12")==0) {
                                       vvalues->vstring = "Value (12) = Group, Container";
                                   }
                                   if (strcmp(vvalues->vstring, "20")==0) {
                                       vvalues->vstring = "Value (20) = Container, Object";
                                   }
                                   if (strcmp(vvalues->vstring, "21")==0) {
                                       vvalues->vstring = "Value (21) = Container, Group";
                                   }
                                   if (strcmp(vvalues->vstring, "012")==0) {
                                       vvalues->vstring = "Value (012) = Object, Group, Container";
                                   }
                                   if (strcmp(vvalues->vstring, "021")==0) {
                                       vvalues->vstring = "Value (021) = Object, Container, Group";
                                   }
                                   if (strcmp(vvalues->vstring, "102")==0) {
                                       vvalues->vstring = "Value (102) = Group, Object, Container";
                                   }
                                   if (strcmp(vvalues->vstring, "120")==0) {
                                       vvalues->vstring = "Value (120) = Group, Container, Object";
                                   }
                                   if (strcmp(vvalues->vstring, "201")==0) {
                                       vvalues->vstring = "Value (201) = Container, Object, Group";
                                   }
                                   if (strcmp(vvalues->vstring, "210")==0) {
                                       vvalues->vstring = "Value (210) = Container, Group, Object";
                                   }
                               }
                               else
                               {
                                   get_string(tvb, voffset, value1, vvalues->vstring);
                               }
                               proto_tree_add_string(nvtree, hf_value_string, tvb, voffset, 
                                   value1, vvalues->vstring);
                               voffset = voffset + value1;    
                               voffset += align_4(tvb, voffset);
                               break;
                }
                voffset += align_4(tvb, voffset);
        }
        vvalues->voffset=voffset;                           
return;
}      

static guint32
print_es_type(proto_tree *estree, tvbuff_t *tvb, nds_val *values, guint32 vtype, guint32 ioffset)
{ 
        guint32         value1;
        guint32         value2;
        guint32         value3;
        guint32         value4;
        guint32         value5;
        guint32         number_of_referrals;
        guint32         r;
        guint32         i;
        guint16         replica_num;
        guint16         event_num;
        nw_uni_t        mval_buf;
        proto_tree      *nestree;
      proto_item      *nesitem;
        proto_tree      *atree;
      proto_item      *aitem;
        const char      *vstring="";
              
            strcpy(mval_buf.buffer, "");

        switch (vtype)
        {
                case 0: /* No Specifier Type */
                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                4, value1);
                        ioffset = ioffset + 4;
                        break;
                case 1: /* Unicode String */
                        value1 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                        ioffset = ioffset + 4;        
                        get_string(tvb, ioffset, value1, mval_buf.buffer);
                        values->vstring = mval_buf.buffer;
                        proto_tree_add_string_format(estree, hf_mv_string, tvb, ioffset, 
                                value1, values->vstring, "Delimeter ->%s", values->vstring);
                        ioffset=ioffset + value1;
                        ioffset += align_4(tvb, ioffset);
                        value2 = tvb_get_letohl(tvb, ioffset);
                        ioffset = ioffset + 4;        
                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                        values->vstring = mval_buf.buffer;
                        proto_tree_add_string(estree, hf_mv_string, tvb, ioffset, 
                                value2, values->vstring);
                        values->voffset=ioffset + value2;
                        ioffset = values->voffset;
                        ioffset += align_4(tvb, ioffset);
                        break;
                case 2: /* Based */
                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        vstring = match_strval(value1, es_type);
                        if (vstring == NULL)
                        {
                                vstring = "No ES Type Found";
                        }        
                        nesitem = proto_tree_add_string_format(estree, hf_es_type, tvb, ioffset, 
                                4, vstring, "Base Context Type - %s", vstring);
                        nestree = proto_item_add_subtree(nesitem, ett_nds);
                        ioffset = ioffset + 4;
                        switch (value1)
                        {
                                case 0: /* No Specifier Type */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                                        proto_tree_add_item(nestree, hf_es_value, tvb, ioffset, 
                                                4, value2);
                                        ioffset = ioffset + 4;
                                        break;
                                case 1: /* Unicode String */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string_format(nestree, hf_mv_string, tvb, ioffset, 
                                                value2, values->vstring, "Delimeter ->%s", values->vstring);
                                        ioffset=ioffset + value2;
                                        ioffset += align_4(tvb, ioffset);
                                        value3 = tvb_get_letohl(tvb, ioffset);
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value3, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(nestree, hf_mv_string, tvb, ioffset, 
                                                value3, values->vstring);
                                        values->voffset=ioffset + value3;
                                        ioffset = values->voffset;
                                        ioffset += align_4(tvb, ioffset);
                                        break;
                                case 2: /* Based */
                                        break;
                                case 3: /* Hinted */
                                        break;
                                case 4: /* Tuned */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* Count */
                                        proto_tree_add_item(nestree, hf_es_rdn_count, tvb, ioffset, 
                                                4, value2);
                                        ioffset = ioffset + 4;
                                        for (r = 1 ; r <= value2; r++ )
                                        {
                                                value3 = tvb_get_letohl(tvb, ioffset);   /* Seconds */
                                                proto_tree_add_item(nestree, hf_es_seconds, tvb, ioffset, 
                                                        4, value3);
                                                ioffset = ioffset + 4;
                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                proto_tree_add_item(nestree, hf_nds_replica_num, tvb, ioffset, 
                                                        2, replica_num);
                                                ioffset = ioffset + 2;
                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                proto_tree_add_item(nestree, hf_nds_event_num, tvb, ioffset, 
                                                        2, event_num);
                                                ioffset = ioffset + 2;
                                        }        
                                        value4 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value4, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(nestree, hf_mv_string, tvb, ioffset, 
                                                value4, values->vstring);
                                        ioffset=ioffset + value4;
                                        ioffset += align_4(tvb, ioffset);
                                        value5 = tvb_get_letohl(tvb, ioffset);   /* RDN */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value5, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(nestree, hf_rdn_string, tvb, ioffset, 
                                                value5, values->vstring);
                                        ioffset=ioffset + value5;
                                        ioffset += align_4(tvb, ioffset);
                                        break;
                                case 5: /* GUID */
                                case 6: /* ID32 */
                                case 7: /* Count */
                                default:
                                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                                4, value1);
                                        ioffset = ioffset + 4;
                                        break;
                         }
                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        vstring = match_strval(value1, es_type);
                        if (vstring == NULL)
                        {
                                vstring = "No ES Type Found";
                        }        
                        nesitem = proto_tree_add_string_format(estree, hf_es_type, tvb, ioffset, 
                                4, vstring, "Object Name Type - %s", vstring);
                        nestree = proto_item_add_subtree(nesitem, ett_nds);
                        ioffset = ioffset + 4;
                        switch (value1)
                        {
                                case 0: /* No Specifier Type */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                                4, value2);
                                        ioffset = ioffset + 4;
                                        break;
                                case 1: /* Unicode String */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string_format(estree, hf_mv_string, tvb, ioffset, 
                                                value2, values->vstring, "Delimeter ->%s", values->vstring);
                                        ioffset=ioffset + value2;
                                        ioffset += align_4(tvb, ioffset);
                                        value3 = tvb_get_letohl(tvb, ioffset);
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value3, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(estree, hf_mv_string, tvb, ioffset, 
                                                value3, values->vstring);
                                        values->voffset=ioffset + value3;
                                        ioffset = values->voffset;
                                        ioffset += align_4(tvb, ioffset);
                                        break;
                                case 2: /* Based */
                                        break;
                                case 3: /* Hinted */
                                        break;
                                case 4: /* Tuned */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* Count */
                                        proto_tree_add_item(estree, hf_es_rdn_count, tvb, ioffset, 
                                                4, value2);
                                        ioffset = ioffset + 4;
                                        for (r = 1 ; r <= value2; r++ )
                                        {
                                                value3 = tvb_get_letohl(tvb, ioffset);   /* Seconds */
                                                proto_tree_add_item(estree, hf_es_seconds, tvb, ioffset, 
                                                        4, value3);
                                                ioffset = ioffset + 4;
                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                proto_tree_add_item(estree, hf_nds_replica_num, tvb, ioffset, 
                                                        2, replica_num);
                                                ioffset = ioffset + 2;
                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                proto_tree_add_item(estree, hf_nds_event_num, tvb, ioffset, 
                                                        2, event_num);
                                                ioffset = ioffset + 2;
                                        }        
                                        value4 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value4, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(estree, hf_mv_string, tvb, ioffset, 
                                                value4, values->vstring);
                                        ioffset=ioffset + value4;
                                        ioffset += align_4(tvb, ioffset);
                                        value5 = tvb_get_letohl(tvb, ioffset);   /* RDN */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value5, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(estree, hf_rdn_string, tvb, ioffset, 
                                                value5, values->vstring);
                                        ioffset=ioffset + value5;
                                        ioffset += align_4(tvb, ioffset);
                                        break;
                                case 5: /* GUID */
                                case 6: /* ID32 */
                                case 7: /* Count */
                                default:
                                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                                4, value1);
                                        ioffset = ioffset + 4;
                                        break;
                         }
                        break;
                case 3: /* Hinted */
                        number_of_referrals = tvb_get_letohl(tvb, ioffset);
                        
                        for (r = 1 ; r <= number_of_referrals; r++ )
                        {
                            aitem = proto_tree_add_uint_format(estree, hf_referral_record, tvb, 6, 0,
                            r, "NDS Referral Record #%u", r);
                                atree = proto_item_add_subtree(aitem, ett_nds);
                                
                                value1 = tvb_get_letohl(tvb, ioffset);
                                
                              proto_tree_add_uint_format(atree, hf_referral_addcount, tvb, ioffset, 4,
                                    value1, "Number of Addresses in Referral - %d", value1);
                                     
                                ioffset = ioffset + 4;
                                for (i = 1 ; i <= value1; i++ ) 
                                {
                                        value2 = tvb_get_letohl(tvb, ioffset);
                                        values->vstring =(char *)match_strval(value2, nds_protocol_type);
                                        if (values->vstring == NULL)
                                        { 
                                               values->vstring="(Undefined Protocol)";
                                        }
                                        proto_tree_add_uint_format(atree, hf_nds_uint32value, tvb, ioffset,
                                        4, value2, vstring, value2);
                                        ioffset = ioffset+4;
                                        value3 = tvb_get_letohl(tvb, ioffset);
                                        ioffset = ioffset+4;
                                        switch (value2)
                                        { 
                                                case NDS_PTYPE_IPX:
                                                        proto_tree_add_item(atree, hf_nds_net, tvb, ioffset, 4, FALSE);
                                                    proto_tree_add_item(atree, hf_nds_node, tvb, ioffset+4, 6, FALSE);
                                                    proto_tree_add_item(atree, hf_nds_socket, tvb, ioffset+10, 2, FALSE);
                                                        break;
                                                case NDS_PTYPE_IP:
                                                proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                      proto_tree_add_item(atree, hf_add_ref_ip, tvb, ioffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_UDP:
                                                    proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                      proto_tree_add_item(atree, hf_add_ref_udp, tvb, ioffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_TCP:
                                                    proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                  proto_tree_add_item(atree, hf_add_ref_tcp, tvb, ioffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_URL:
                                                        get_string(tvb, ioffset, value3, values->vstring);
                                                        proto_tree_add_string(atree, hf_value_string, tvb, ioffset, 
                                                                value3, values->vstring);
                                                        break;
                                                default:
                                                        break;
                                        }
                                        ioffset = ioffset + value3;    
                                        ioffset += align_4(tvb, ioffset);
                                }
                
                        }
                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        vstring = match_strval(value1, es_type);
                        if (vstring == NULL)
                        {
                                vstring = "No ES Type Found";
                        }        
                        nesitem = proto_tree_add_string_format(estree, hf_es_type, tvb, ioffset, 
                                4, vstring, "Object Name Type - %s", vstring);
                        nestree = proto_item_add_subtree(nesitem, ett_nds);
                        ioffset = ioffset + 4;
                        switch (value1)
                        {
                                case 0: /* No Specifier Type */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                                4, value2);
                                        ioffset = ioffset + 4;
                                        break;
                                case 1: /* Unicode String */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string_format(estree, hf_mv_string, tvb, ioffset, 
                                                value2, values->vstring, "Delimeter ->%s", values->vstring);
                                        ioffset=ioffset + value2;
                                        ioffset += align_4(tvb, ioffset);
                                        value3 = tvb_get_letohl(tvb, ioffset);
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value3, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(estree, hf_mv_string, tvb, ioffset, 
                                                value3, values->vstring);
                                        values->voffset=ioffset + value3;
                                        ioffset = values->voffset;
                                        ioffset += align_4(tvb, ioffset);
                                        break;
                                case 2: /* Based */
                                        break;
                                case 3: /* Hinted */
                                        break;
                                case 4: /* Tuned */
                                        value2 = tvb_get_letohl(tvb, ioffset);   /* Count */
                                        proto_tree_add_item(estree, hf_es_rdn_count, tvb, ioffset, 
                                                4, value2);
                                        ioffset = ioffset + 4;
                                        for (r = 1 ; r <= value2; r++ )
                                        {
                                                value3 = tvb_get_letohl(tvb, ioffset);   /* Seconds */
                                                proto_tree_add_item(estree, hf_es_seconds, tvb, ioffset, 
                                                        4, value3);
                                                ioffset = ioffset + 4;
                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                proto_tree_add_item(estree, hf_nds_replica_num, tvb, ioffset, 
                                                        2, replica_num);
                                                ioffset = ioffset + 2;
                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                proto_tree_add_item(estree, hf_nds_event_num, tvb, ioffset, 
                                                        2, event_num);
                                                ioffset = ioffset + 2;
                                        }        
                                        value4 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value4, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(estree, hf_mv_string, tvb, ioffset, 
                                                value4, values->vstring);
                                        ioffset=ioffset + value4;
                                        ioffset += align_4(tvb, ioffset);
                                        value5 = tvb_get_letohl(tvb, ioffset);   /* RDN */
                                        ioffset = ioffset + 4;        
                                        get_string(tvb, ioffset, value5, mval_buf.buffer);
                                        values->vstring = mval_buf.buffer;
                                        proto_tree_add_string(estree, hf_rdn_string, tvb, ioffset, 
                                                value5, values->vstring);
                                        ioffset=ioffset + value5;
                                        ioffset += align_4(tvb, ioffset);
                                        break;
                                case 5: /* GUID */
                                case 6: /* ID32 */
                                case 7: /* Count */
                                default:
                                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                                4, value1);
                                        ioffset = ioffset + 4;
                                        break;
                         }
                        break;
                case 4: /* Tuned */
                        value1 = tvb_get_letohl(tvb, ioffset);   /* Count */
                        proto_tree_add_item(estree, hf_es_rdn_count, tvb, ioffset, 
                                4, value1);
                        ioffset = ioffset + 4;
                        for (r = 1 ; r <= value1; r++ )
                        {
                                value2 = tvb_get_letohl(tvb, ioffset);   /* Seconds */
                                proto_tree_add_item(estree, hf_es_seconds, tvb, ioffset, 
                                        4, value2);
                                ioffset = ioffset + 4;
                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                proto_tree_add_item(estree, hf_nds_replica_num, tvb, ioffset, 
                                        2, replica_num);
                                ioffset = ioffset + 2;
                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                proto_tree_add_item(estree, hf_nds_event_num, tvb, ioffset, 
                                        2, event_num);
                                ioffset = ioffset + 2;
                        }        
                        value3 = tvb_get_letohl(tvb, ioffset);   /* Delimeter Set */
                        ioffset = ioffset + 4;        
                        get_string(tvb, ioffset, value3, mval_buf.buffer);
                        values->vstring = mval_buf.buffer;
                        proto_tree_add_string(estree, hf_mv_string, tvb, ioffset, 
                                value3, values->vstring);
                        ioffset=ioffset + value3;
                        ioffset += align_4(tvb, ioffset);
                        value4 = tvb_get_letohl(tvb, ioffset);   /* RDN */
                        ioffset = ioffset + 4;        
                        get_string(tvb, ioffset, value4, mval_buf.buffer);
                        values->vstring = mval_buf.buffer;
                        proto_tree_add_string(estree, hf_rdn_string, tvb, ioffset, 
                                value4, values->vstring);
                        ioffset=ioffset + value4;
                        ioffset += align_4(tvb, ioffset);
                        break;
                case 5: /* GUID */
                case 6: /* ID32 */
                case 7: /* Count */
                default:
                        value1 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        proto_tree_add_item(estree, hf_es_value, tvb, ioffset, 
                                4, value1);
                        ioffset = ioffset + 4;
                        break;
         }
        return ioffset;
}   

static void
process_multivalues(proto_tree *ncp_tree, tvbuff_t *tvb, nds_val *values)
{
        guint32         i;
        guint32         r;
        guint32         ioffset = 0, oldioffset;
        guint32         value1 = 0;
        guint32         value2 = 0;
        guint8          value3 = 0;
        guint32         value4 = 0;
        gint            value5 = 0;
        guint32         value6 = 0;
        guint32         value7 = 0;
        const char      *valuestr = "";
        proto_tree      *ntree;
        proto_tree      *atree;
      proto_item      *nitem;
        proto_item      *aitem;
        guint32         number_of_referrals = 0;
        nw_uni_t        mval_buf;
        proto_tree      *estree;
      proto_item      *esitem;
        guint16         replica_num = 0;
        guint16         event_num = 0;
        guint32         bvalue=0;
        nds_val         temp_values;
        proto_tree      *sub1tree;
      proto_item      *sub1item;
        proto_tree      *sub2tree;
      proto_item      *sub2item;
      gint        length_remaining;
               
            strcpy(mval_buf.buffer, "");
        strcpy(mv_resolve_name_string, "");
        
        if(values->mvtype != MVTYPE_LIST_PARTITIONS)
        {
                nitem = proto_tree_add_uint_format(ncp_tree, values->hfname, tvb, values->voffset+ioffset,
                        values->vlength, values->vvalue, values->vdesc, values->vvalue);
        }
        else
        {
                nitem = proto_tree_add_string_format(ncp_tree, values->hfname, tvb, values->voffset+ioffset,
                        values->vlength, values->vdesc, "%s", values->vdesc);
        }                
        ioffset = (values->voffset+4);
        
        ntree = proto_item_add_subtree(nitem, ett_nds);

        switch (values->mvtype)
        {
                case MVTYPE_ATTR_REQUEST: /* Attribute Request */
                        for (i = 1 ; i <= values->vvalue; i++ )
                        {
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                        value1, values->vstring);
                                ioffset = ioffset + value1;        
                        }
                        break;

                case MVTYPE_ATTR_REPLY:         /* Attribute Reply */
                        switch(values->vflags)
                        {
                                case 0:
                                        for (i = 1 ; i <= values->vvalue; i++ )
                                        {
                                                ioffset += align_4(tvb, ioffset);
                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                ioffset = ioffset + 4;
                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                values->vstring = mval_buf.buffer;                                
                                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                                        value1, values->vstring);
                                                ioffset = ioffset + value1;        
                                        }
                                        break;
                                case 1:
                                        for (i = 1 ; i <= values->vvalue; i++ )
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                values->vstring = (char *)match_strval(value1, nds_syntax);
                                                if (values->vstring == NULL)
                                                {
                                                        values->vstring = "No Syntax Found";
                                                }        
                                                proto_tree_add_string(ntree, hf_nds_syntax, tvb, ioffset, 
                                                4, values->vstring);
                                                ioffset = ioffset + 4;
                                                value2 = tvb_get_letohl(tvb, ioffset);
                                                ioffset = ioffset + 4;        
                                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                values->vstring = mval_buf.buffer;
                                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                                        value2, values->vstring);        
                                                ioffset += value2;
                                                ioffset += align_4(tvb, ioffset);
                                                values->voffset = ioffset; 
        
                                                print_nds_values(ntree, tvb, value1, values);        
                                                ioffset = values->voffset;
                                        }
                                        break;                
                                case 2:
                                        for (i = 1 ; i <= values->vvalue; i++ )
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                values->vstring = (char *)match_strval(value1, nds_syntax);
                                                if (values->vstring == NULL)
                                                {
                                                        values->vstring = "No Syntax Found";
                                                }        
                                                proto_tree_add_string(ntree, hf_nds_syntax, tvb, ioffset, 
                                                4, values->vstring);
                                                ioffset = ioffset + 4;
                                                value2 = tvb_get_letohl(tvb, ioffset);
                                                ioffset = ioffset + 4;        
                                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                values->vstring = mval_buf.buffer;
                                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                                        value2, values->vstring);
                                                values->voffset=ioffset + value2;
                                                ioffset += value2;
                                                ioffset += align_4(tvb, ioffset);
                                                value3 = tvb_get_letohl(tvb, ioffset);
                                                
                                          proto_tree_add_uint_format(ntree, hf_nds_uint32value, tvb, ioffset, 4,
                                                      value1, "Number of Values - %d", value1);
                                                     
                                                ioffset = ioffset + 4;
                                                for (r = 1 ; r <= value3; r++ ) 
                                                {
                                                        ioffset += 4;   /* Length = 4 */
                                                        value4 = tvb_get_letohl(tvb, ioffset);
                                                        tvb_ensure_bytes_exist(tvb, ioffset, values->vlength);
                                                        proto_tree_add_uint(ntree, hf_nds_privileges, tvb, ioffset,
                                                        values->vlength, value4);
                                                        ioffset = ioffset+4;
                                                }
                                        }
                                        break;        
                                case 3:
                                        for (i = 1 ; i <= values->vvalue; i++ )
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                values->vstring = (char *)match_strval(value1, nds_syntax);
                                                if (values->vstring == NULL)
                                                {
                                                        values->vstring = "No Syntax Found";
                                                }        
                                                proto_tree_add_string(ntree, hf_nds_syntax, tvb, ioffset, 
                                                4, values->vstring);
                                                ioffset = ioffset + 4;
                                                value2 = tvb_get_letohl(tvb, ioffset);
                                                ioffset = ioffset + 4;        
                                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                values->vstring = mval_buf.buffer;
                                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                                        value2, values->vstring);
                                                ioffset = ioffset + value2;
                                                ioffset += align_4(tvb, ioffset);
                                                value3 = tvb_get_letohl(tvb, ioffset);
                                                
                                          aitem = proto_tree_add_uint_format(ntree, hf_nds_uint32value, tvb, ioffset, 4,
                                                      value3, "Number of Values - %d", value3);
        
                                                atree = proto_item_add_subtree(aitem, ett_nds);
                                                     
                                                ioffset = ioffset + 4;
                                                for (r = 1 ; r <= value3; r++ ) 
                                                {
                                                        ioffset += align_4(tvb, ioffset);
                                                        temp_values.vvalue = tvb_get_letohl(tvb, ioffset);
                                                        temp_values.vlength = 2;
                                                        temp_values.hfname = hf_nds_vflags;
                                                        temp_values.voffset = ioffset;
                                                        temp_values.vdesc = "Value Flags";
                                                        temp_values.bit1 = "Naming";
                                                        temp_values.bit1hfname = hf_bit1vflags;
                                                        temp_values.bit2 = "Base Class";
                                                        temp_values.bit2hfname = hf_bit2vflags;
                                                        temp_values.bit3 = "Present";
                                                        temp_values.bit3hfname = hf_bit3vflags;
                                                        temp_values.bit4 = "Value Damaged";
                                                        temp_values.bit4hfname = hf_bit4vflags;
                                                        temp_values.bit5 = "Not Defined";
                                                        temp_values.bit5hfname = hf_bit5vflags;
                                                        temp_values.bit6 = "Not Defined";
                                                        temp_values.bit6hfname = hf_bit6vflags;
                                                        temp_values.bit7 = "Not Defined";
                                                        temp_values.bit7hfname = hf_bit7vflags;
                                                        temp_values.bit8 = "Not Defined";
                                                        temp_values.bit8hfname = hf_bit8vflags;
                                                        temp_values.bit9 = "Not Defined";
                                                        temp_values.bit9hfname = hf_bit9vflags;
                                                        temp_values.bit10 = "Not Defined";
                                                        temp_values.bit10hfname = hf_bit10vflags;
                                                        temp_values.bit11 = "Not Defined";
                                                        temp_values.bit11hfname = hf_bit11vflags;
                                                        temp_values.bit12 = "Not Defined";
                                                        temp_values.bit12hfname = hf_bit12vflags;
                                                        temp_values.bit13 = "Not Defined";
                                                        temp_values.bit13hfname = hf_bit13vflags;
                                                        temp_values.bit14 = "Not Defined";
                                                        temp_values.bit14hfname = hf_bit14vflags;
                                                        temp_values.bit15 = "Not Defined";
                                                        temp_values.bit15hfname = hf_bit15vflags;
                                                        temp_values.bit16 = "Not Defined";
                                                        temp_values.bit16hfname = hf_bit16vflags;
                                                        process_bitfield(atree, tvb, &temp_values);
                                                        ioffset = ioffset + 4;        
                                                        value4 = tvb_get_letohl(tvb, ioffset);
                                                        proto_tree_add_uint_format(atree, hf_es_seconds, tvb, ioffset,
                                                                4, value4, "Seconds %d", value4);
                                                        ioffset = ioffset + 4;        
                                                        replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                        proto_tree_add_item(atree, hf_nds_replica_num, tvb, ioffset, 
                                                                2, replica_num);
                                                        ioffset = ioffset + 2;
                                                        event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                        proto_tree_add_item(atree, hf_nds_event_num, tvb, ioffset, 
                                                                2, event_num);
                                                        ioffset = ioffset + 2;
                                                        value5 = tvb_get_letohl(tvb, ioffset); /* length of field */
                                                        if(value5 > tvb_length_remaining(tvb, ioffset))
                                                        {
                                                                 break;
                                                        }
                                                        ioffset += 4;
                                                        tvb_ensure_bytes_exist(tvb, ioffset, value5);
                                                        proto_tree_add_bytes(atree, hf_value_bytes, tvb, ioffset, value5, tvb_get_ptr(tvb, ioffset, value5));
                                                        ioffset += value5;
                                                        ioffset += (value5%2);
                                                }
                                        }
                                        break;
                                case 4:
                                        for (i = 1 ; i <= values->vvalue; i++ )
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                values->vstring = (char *)match_strval(value1, nds_syntax);
                                                if (values->vstring == NULL)
                                                {
                                                        values->vstring = "No Syntax Found";
                                                }        
                                                proto_tree_add_string(ntree, hf_nds_syntax, tvb, ioffset, 
                                                4, values->vstring);
                                                ioffset = ioffset + 4;
                                                value2 = tvb_get_letohl(tvb, ioffset);
                                                ioffset = ioffset + 4;        
                                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                values->vstring = mval_buf.buffer;
                                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                                        value2, values->vstring);
                                                ioffset = ioffset + value2;
                                                value3 = tvb_get_letohl(tvb, ioffset);
                                                
                                          proto_tree_add_uint_format(ntree, hf_nds_uint32value, tvb, ioffset, 4,
                                                      value3, "Number of Values - %d", value3);
                                                     
                                                ioffset = ioffset + 4;
                                                for (r = 1 ; r <= value3; r++ ) 
                                                {
                                                        ioffset += align_4(tvb, ioffset);
                                                        temp_values.vvalue = tvb_get_letohl(tvb, ioffset);
                                                        temp_values.vlength = 2;
                                                        temp_values.hfname = hf_nds_vflags;
                                                        temp_values.voffset = ioffset;
                                                        temp_values.vdesc = "Value Flags";
                                                        temp_values.bit1 = "Naming";
                                                        temp_values.bit1hfname = hf_bit1vflags;
                                                        temp_values.bit2 = "Base Class";
                                                        temp_values.bit2hfname = hf_bit2vflags;
                                                        temp_values.bit3 = "Present";
                                                        temp_values.bit3hfname = hf_bit3vflags;
                                                        temp_values.bit4 = "Value Damaged";
                                                        temp_values.bit4hfname = hf_bit4vflags;
                                                        temp_values.bit5 = "Not Defined";
                                                        temp_values.bit5hfname = hf_bit5vflags;
                                                        temp_values.bit6 = "Not Defined";
                                                        temp_values.bit6hfname = hf_bit6vflags;
                                                        temp_values.bit7 = "Not Defined";
                                                        temp_values.bit7hfname = hf_bit7vflags;
                                                        temp_values.bit8 = "Not Defined";
                                                        temp_values.bit8hfname = hf_bit8vflags;
                                                        temp_values.bit9 = "Not Defined";
                                                        temp_values.bit9hfname = hf_bit9vflags;
                                                        temp_values.bit10 = "Not Defined";
                                                        temp_values.bit10hfname = hf_bit10vflags;
                                                        temp_values.bit11 = "Not Defined";
                                                        temp_values.bit11hfname = hf_bit11vflags;
                                                        temp_values.bit12 = "Not Defined";
                                                        temp_values.bit12hfname = hf_bit12vflags;
                                                        temp_values.bit13 = "Not Defined";
                                                        temp_values.bit13hfname = hf_bit13vflags;
                                                        temp_values.bit14 = "Not Defined";
                                                        temp_values.bit14hfname = hf_bit14vflags;
                                                        temp_values.bit15 = "Not Defined";
                                                        temp_values.bit15hfname = hf_bit15vflags;
                                                        temp_values.bit16 = "Not Defined";
                                                        temp_values.bit16hfname = hf_bit16vflags;
                                                        process_bitfield(ntree, tvb, &temp_values);
                                                        ioffset = ioffset + 4;        
                                                        value1 = tvb_get_letohl(tvb, ioffset);
                                                        proto_tree_add_uint_format(ntree, hf_es_seconds, tvb, ioffset,
                                                                4, value1, "Seconds %d", value1);
                                                        ioffset = ioffset + 4;        
                                                        replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                        proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset, 
                                                                2, replica_num);
                                                        ioffset = ioffset + 2;
                                                        event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                        proto_tree_add_item(ntree, hf_nds_event_num, tvb, ioffset, 
                                                                2, event_num);
                                                        ioffset = ioffset + 2;
                                                        value1 = tvb_get_letohl(tvb, ioffset);   
                                                        proto_tree_add_uint(ntree, hf_nds_value_len, tvb, ioffset,
                                                                4, value1);
                                                        ioffset = ioffset + 4;        
                                                }
                                        }
                                        break;
                                default:
                                        break;
                        }
                        break;

                case MVTYPE_ATTR_REQUEST2:      /* Attribute Request */
                        oldioffset = 0;
                        for (i = 1 ; i <= values->vvalue; i++ )
                        {
                                if (oldioffset >= ioffset) {
                                        proto_tree_add_text(ntree, tvb, 0, 0, "[ Invalid offset: %u ]", ioffset);
                                        THROW(ReportedBoundsError);
                                }
                                oldioffset = ioffset;
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);
                                proto_tree_add_uint_format(ntree, hf_nds_uint32value, tvb, ioffset,
                                        4, value1, "Value %d", value1);
                                ioffset = ioffset + value1;        
                        }
                        break;

                case MVTYPE_ADD_ATTR_REQUEST:   /* Add Attribute Request */
                        for (i = 1 ; i <= values->vvalue; i++ )
                        {
                                value1 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                        value1, values->vstring);
                                ioffset = ioffset + value1;        
                                ioffset += align_4(tvb, ioffset);
                                values->voffset = ioffset;
                                print_nds_values(ntree, tvb, 9, values);        
                                ioffset = values->voffset;
                        }
                        break;
                        
                case MVTYPE_READ_CLASS_REQ:     /* Read Class Request */
                        for (i = 1 ; i <= values->vvalue; i++ )
                        {
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_nds_base, tvb, ioffset, 
                                        value1, values->vstring);
                                values->mvtype = MVTYPE_ATTR_REQUEST;        
                                ioffset = ioffset + value1;        
                        }
                        break;

                case MVTYPE_READ_REPLICAS:      /* Read Replicas */
                        for (i = 1 ; i <= values->vvalue; i++ )
                        {
                                                
                                bvalue = 0x00000001;
            
                                for (r = 0 ; r < 9; r++ ) 
                                {
                
                                        if (values->vflags & bvalue) 
                                        {
                                                switch(bvalue)
                                                {
                                                        case 0x00000001:                /*p3values.bit1 = "Output Flags"*/
                                                                temp_values.vvalue = tvb_get_letohl(tvb, ioffset);
                                                                temp_values.vlength = 2;
                                                                temp_values.hfname = hf_nds_rflags;
                                                                temp_values.voffset = ioffset;
                                                                temp_values.vdesc = "Output Flags";
                                                                temp_values.bit1 = values->bit1;
                                                                temp_values.bit1hfname = hf_bit1outflags;
                                                                temp_values.bit2 = values->bit2;
                                                                temp_values.bit2hfname = hf_bit2outflags;
                                                                temp_values.bit3 = values->bit3;
                                                                temp_values.bit3hfname = hf_bit3outflags;
                                                                temp_values.bit4 = values->bit4;
                                                                temp_values.bit4hfname = hf_bit4outflags;
                                                                temp_values.bit5 = values->bit5;
                                                                temp_values.bit5hfname = hf_bit5outflags;
                                                                temp_values.bit6 = values->bit6;
                                                                temp_values.bit6hfname = hf_bit6outflags;
                                                                temp_values.bit7 = values->bit7;
                                                                temp_values.bit7hfname = hf_bit7outflags;
                                                                temp_values.bit8 = values->bit8;
                                                                temp_values.bit8hfname = hf_bit8outflags;
                                                                temp_values.bit9 = values->bit9;
                                                                temp_values.bit9hfname = hf_bit9outflags;
                                                                temp_values.bit10 = "Not Defined";
                                                                temp_values.bit10hfname = hf_bit10outflags;
                                                                temp_values.bit11 = "Not Defined";
                                                                temp_values.bit11hfname = hf_bit11outflags;
                                                                temp_values.bit12 = "Not Defined";
                                                                temp_values.bit12hfname = hf_bit12outflags;
                                                                temp_values.bit13 = "Not Defined";
                                                                temp_values.bit13hfname = hf_bit13outflags;
                                                                temp_values.bit14 = "Not Defined";
                                                                temp_values.bit14hfname = hf_bit14outflags;
                                                                temp_values.bit15 = "Not Defined";
                                                                temp_values.bit15hfname = hf_bit15outflags;
                                                                temp_values.bit16 = "Not Defined";
                                                                temp_values.bit16hfname = hf_bit16outflags;
                                                                process_bitfield(ntree, tvb, &temp_values);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000002:                /*p3values.bit2 = "Entry ID"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_eid, tvb, ioffset,
                                                                        4, value1, "Entry ID %08x", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000004:                /*p3values.bit3 = "Replica State"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                temp_values.vstring = (char *)match_strval(value1, nds_replica_state);
                                                                if (temp_values.vstring == NULL)
                                                                {
                                                                        temp_values.vstring = "No Replica State Found";
                                                                }        
                                                                proto_tree_add_string(ntree, hf_replica_state, tvb, ioffset, 
                                                                4, temp_values.vstring);
                                                                ioffset = ioffset + 4;
                                                                break;
                                                        case 0x0000008:                 /*p3values.bit4 = "Modification Timestamp"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_es_seconds, tvb, ioffset,
                                                                        4, value1, "Seconds %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                                proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset, 
                                                                        2, replica_num);
                                                                ioffset = ioffset + 2;
                                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                                proto_tree_add_item(ntree, hf_nds_event_num, tvb, ioffset, 
                                                                        2, event_num);
                                                                ioffset = ioffset + 2;
                                                                break;
                                                        case 0x00000010:                /*p3values.bit5 = "Purge Time"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
                                                                        4, value1, "Purge Time %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000020:                /*p3values.bit6 = "Local Partition ID"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_local_partition, tvb, ioffset,
                                                                        4, value1, "Local Partition ID %08x", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000040:                /*p3values.bit7 = "Distinguished Name"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;                                
                                                                proto_tree_add_string(ntree, hf_nds_name, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        case 0x00000080:                /*p3values.bit8 = "Replica Type & State"*/
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                value2 = value1 & 0x00ff;
                                                                temp_values.vstring = (char *)match_strval(value2, nds_replica_type);
                                                                if (temp_values.vstring == NULL)
                                                                {
                                                                        temp_values.vstring = "No Replica Type Found";
                                                                }        
                                                                proto_tree_add_string(ntree, hf_replica_type, tvb, ioffset, 
                                                                4, temp_values.vstring);
                                                                value3 = value1 & 0xff00;
                                                                temp_values.vstring = (char *)match_strval(value3, nds_replica_state);
                                                                if (temp_values.vstring == NULL)
                                                                {
                                                                        temp_values.vstring = "No Replica State Found";
                                                                }        
                                                                proto_tree_add_string(ntree, hf_replica_state, tvb, ioffset, 
                                                                4, temp_values.vstring);
                                                                ioffset = ioffset + 4;
                                                                break;
                                                        case 0x00000100:                /*p3values.bit9 = "Partition Busy"*/
                                                                value1 = tvb_get_letohs(tvb, ioffset);
                                                                proto_tree_add_boolean(ntree, hf_partition_busy, tvb, ioffset, 4, value1);
                                                                ioffset += 4;
                                                                break;
                                                        default:
                                                                break;
                                                        
                                                }
                                        }
                                        bvalue = bvalue*2;
                                        ioffset += align_4(tvb, ioffset);
                                        if(tvb_length_remaining(tvb, ioffset) < 4 )
                                        {
                                                break;
                                        }
                                }                
                                if(tvb_length_remaining(tvb, ioffset) < 4 )
                                {
                                        break;
                                }
                        }
                        break;

                case MVTYPE_MODIFY_ATTR_REQUEST: /* Modify Attribute Request */
                        for (i = 0 ; i < values->vvalue; i++ ) 
                        {
                               ioffset += align_4(tvb, ioffset);
                               value1 = tvb_get_letohl(tvb, ioffset);
                               valuestr = match_strval(value1, nds_kind_of_changes);
                               if (valuestr == NULL)
                               { 
                                               valuestr="(Kind Change Not Found)";
                               }
                               tvb_ensure_bytes_exist(tvb, ioffset, values->vlength);
                               proto_tree_add_uint_format(ntree, hf_nds_uint32value, tvb, ioffset,
                               values->vlength, value1, valuestr, value1);
                               ioffset = ioffset+4;
                               value2 = tvb_get_letohl(tvb, ioffset);
                               ioffset = ioffset + 4;
                               get_string(tvb, ioffset, value2, mval_buf.buffer);   /* Name of Attribute */
                               temp_values.vstring = mval_buf.buffer;                                
                               proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                       value2, temp_values.vstring);
                               ioffset = ioffset + value2;
                               ioffset += align_4(tvb, ioffset);
                               if(value1 != 1 && value1 != 6)
                               {
                                       values->voffset = ioffset;
                                       print_nds_values(ntree, tvb, 9, values);        
                                       ioffset = values->voffset;
                               }
                        }
                        break;

                case MVTYPE_ADDR_REFERRAL_REQUEST: /* Address Referral Request */
                        for (i = 0 ; i < values->vvalue; i++ ) 
                        {
        
                               value1 = tvb_get_letohl(tvb, ioffset);
                               valuestr = match_strval(value1, nds_protocol_type);
                               if (valuestr == NULL)
                               { 
                                               valuestr="(Undefined Protocol)";
                               }
                               tvb_ensure_bytes_exist(tvb, ioffset, values->vlength);
                               proto_tree_add_uint_format(ntree, hf_nds_uint32value, tvb, ioffset,
                               values->vlength, value1, valuestr, value1);
                               ioffset = ioffset+4;
                        }
                        break;

                case MVTYPE_ADDR_REFERRAL_REPLY: /* Address Referral Reply */
                        number_of_referrals = values->vvalue;
                        
                        for (r = 1 ; r <= number_of_referrals; r++ )
                        {
                            aitem = proto_tree_add_uint_format(ntree, hf_referral_record, tvb, 6, 0,
                            r, "NDS Referral Record #%u", r);
                                atree = proto_item_add_subtree(aitem, ett_nds);
                                
                                value1 = tvb_get_letohl(tvb, ioffset);
                                
                              proto_tree_add_uint_format(atree, hf_referral_addcount, tvb, ioffset, 4,
                                    value1, "Number of Addresses in Referral - %d", value1);
                                     
                                ioffset = ioffset + 4;
                                for (i = 1 ; i <= value1; i++ ) 
                                {
                                        value2 = tvb_get_letohl(tvb, ioffset);
                                        valuestr = match_strval(value2, nds_protocol_type);
                                        if (valuestr == NULL)
                                        { 
                                               valuestr="(Undefined Protocol)";
                                        }
                                        tvb_ensure_bytes_exist(tvb, ioffset, values->vlength);
                                        proto_tree_add_uint_format(atree, hf_nds_uint32value, tvb, ioffset,
                                        values->vlength, value2, valuestr, value2);
                                        ioffset = ioffset+4;
                                        value3 = tvb_get_letohl(tvb, ioffset);
                                        ioffset = ioffset+4;
                                        switch (value2)
                                        { 
                                                case NDS_PTYPE_IPX:
                                                        proto_tree_add_item(atree, hf_nds_net, tvb, ioffset, 4, FALSE);
                                                    proto_tree_add_item(atree, hf_nds_node, tvb, ioffset+4, 6, FALSE);
                                                    proto_tree_add_item(atree, hf_nds_socket, tvb, ioffset+10, 2, FALSE);
                                                        break;
                                                case NDS_PTYPE_IP:
                                                proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                      proto_tree_add_item(atree, hf_add_ref_ip, tvb, ioffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_UDP:
                                                    proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                      proto_tree_add_item(atree, hf_add_ref_udp, tvb, ioffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_TCP:
                                                    proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                  proto_tree_add_item(atree, hf_add_ref_tcp, tvb, ioffset+2, 4, FALSE);
                                                        break;
                                                case NDS_PTYPE_URL:
                                                        get_string(tvb, ioffset, value3, values->vstring);
                                                        proto_tree_add_string(atree, hf_value_string, tvb, ioffset, 
                                                                value3, values->vstring);
                                                        break;
                                                default:
                                                        break;
                                        }
                                        ioffset = ioffset + value3;    
                                        ioffset += align_4(tvb, ioffset);
                                }
                
                        }
                        break;

                case MVTYPE_LOC_ADDR_REFERRAL_REPLY: /* Local Address Referral Reply */
                        number_of_referrals = values->vvalue;

                        for (r = 1 ; r <= number_of_referrals; r++ )
                        {
                            aitem = proto_tree_add_uint_format(ntree, hf_referral_record, tvb, 6, 0,
                            r, "NDS Referral Record #%u", r);
                                atree = proto_item_add_subtree(aitem, ett_nds);
                                
                                value2 = tvb_get_letohl(tvb, ioffset);
                                valuestr = match_strval(value2, nds_protocol_type);
                                if (valuestr == NULL)
                                { 
                                        valuestr="(Undefined Protocol)";
                                }
                                tvb_ensure_bytes_exist(tvb, ioffset, values->vlength);
                                proto_tree_add_uint_format(atree, hf_nds_uint32value, tvb, ioffset,
                                values->vlength, value2, valuestr, value2);
                                ioffset = ioffset+4;
                                value3 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset+4;
                                
                                switch (value2)
                                { 
                                        case NDS_PTYPE_IPX:
                                                proto_tree_add_item(atree, hf_nds_net, tvb, ioffset, 4, FALSE);
                                            proto_tree_add_item(atree, hf_nds_node, tvb, ioffset+4, 6, FALSE);
                                            proto_tree_add_item(atree, hf_nds_socket, tvb, ioffset+10, 2, FALSE);
                                                break;
                                        case NDS_PTYPE_IP:
                                                proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                proto_tree_add_item(atree, hf_add_ref_ip, tvb, ioffset+2, 4, FALSE);
                                                break;
                                        case NDS_PTYPE_UDP:
                                            proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                              proto_tree_add_item(atree, hf_add_ref_udp, tvb, ioffset+2, 4, FALSE);
                                                break;
                                        case NDS_PTYPE_TCP:
                                            proto_tree_add_item(atree, hf_nds_port, tvb, ioffset, 2, FALSE);
                                                proto_tree_add_item(atree, hf_add_ref_tcp, tvb, ioffset+2, 4, FALSE);
                                                break;
                                        case NDS_PTYPE_URL:
                                                get_string(tvb, ioffset, value3, values->vstring);
                                                proto_tree_add_string(atree, hf_value_string, tvb, ioffset, 
                                                      value3, values->vstring);
                                                break;
                                        default:
                                                break;
                                }
                                ioffset = ioffset + value3;    
                                ioffset += align_4(tvb, ioffset);
                        }
                        break;

                case MVTYPE_PROC_ENTRY_SPECIFIERS: /* Process Entry Specifiers */
                        value2 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        values->vstring = (char *)match_strval(value2, es_type);
                        if (values->vstring == NULL)
                        {
                                values->vstring = "No ES Type Found";
                        }        
                        esitem = proto_tree_add_string_format(ntree, hf_es_type, tvb, ioffset, 
                                4, values->vstring, "Output Entry Specifier - %s", values->vstring);
                        estree = proto_item_add_subtree(esitem, ett_nds);
                        ioffset = ioffset + 4;
                        ioffset = print_es_type(estree, tvb, values, value2, ioffset);
                        value3 = tvb_get_letohl(tvb, ioffset);   /* ES Type */
                        values->vstring = (char *)match_strval(value3, es_type);
                        if (values->vstring == NULL)
                        {
                                values->vstring = "No ES Type Found";
                        }        
                        esitem = proto_tree_add_string_format(ntree, hf_es_type, tvb, ioffset, 
                                4, values->vstring, "Input Entry Specifier - %s", values->vstring);
                        estree = proto_item_add_subtree(esitem, ett_nds);
                        ioffset = ioffset + 4;
                        ioffset = print_es_type(estree, tvb, values, value3, ioffset);
                        /* values.vstring is being overwritten. So store the resolve name to a global value */
                        strcpy(mv_resolve_name_string, values->vstring);
                        value4 = tvb_get_letohl(tvb, ioffset);
                    aitem = proto_tree_add_uint_format(ntree, hf_referral_record, tvb, ioffset, 4,
                            value4, "Referral Protocols - %d", value4);
                        atree = proto_item_add_subtree(aitem, ett_nds);
                        ioffset += 4;               
                        for (i = 0 ; i < value4; i++ ) 
                        {
                               value5 = tvb_get_letohl(tvb, ioffset);
                               valuestr = match_strval(value5, nds_protocol_type);
                               if (valuestr == NULL)
                               { 
                                               valuestr="(Undefined Protocol)";
                               }
                               proto_tree_add_string_format(atree, hf_value_string, tvb, ioffset,
                               4, valuestr, "Protocol -> %s", valuestr);
                               ioffset = ioffset+4;
                        }
                        value6 = tvb_get_letohl(tvb, ioffset);
                    aitem = proto_tree_add_uint_format(ntree, hf_referral_record, tvb, ioffset, 4,
                            value6, "Tree Walking Protocols - %d", value6);
                        atree = proto_item_add_subtree(aitem, ett_nds);
                        ioffset += 4;               
                        for (i = 0 ; i < value6; i++ ) 
                        {
                               value7 = tvb_get_letohl(tvb, ioffset);
                               valuestr = match_strval(value7, nds_protocol_type);
                               if (valuestr == NULL)
                               { 
                                               valuestr="(Undefined Protocol)";
                               }
                               proto_tree_add_string_format(atree, hf_value_string, tvb, ioffset,
                               4, valuestr, "Protocol -> %s", valuestr);
                               ioffset = ioffset+4;
                        }
                        break;

                case MVTYPE_PRINT_TIMESTAMP:    /* Print Timestamp */
                        replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                        proto_tree_add_item(ncp_tree, hf_nds_replica_num, tvb, ioffset, 
                                2, replica_num);
                        ioffset = ioffset + 2;
                        event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                        proto_tree_add_item(ncp_tree, hf_nds_event_num, tvb, ioffset, 
                                2, event_num);
                        ioffset = ioffset + 2;
                  /* fall through */

                case MVTYPE_LIST_PARTITIONS:    /* List Partitions */
                        number_of_referrals = values->vvalue;
                        /* A bad packet could put us in a tight loop so trap for anything
                         * over 256 referals. 
                         */
                        if (number_of_referrals > 256) {
                            proto_tree_add_text(ntree, tvb, 0, 0, "[ Bad referal at offset: %u ]", ioffset);
                            THROW(ReportedBoundsError);
                            break;
                        }
                        for (i = 0; i < number_of_referrals; i++)
                        {        
                                bvalue = 0x00000001;
            
                                for (r = 0 ; r < 32; r++ ) 
                                {
                                        oldioffset = ioffset;
                                        if (values->vflags & bvalue) 
                                        {
                                                switch(bvalue)
                                                {
                                                        case 0x00000001:                /* Information Flags */
                                                                temp_values.vvalue = tvb_get_letohs(tvb, ioffset);
                                                                temp_values.vtype = VTYPE_BITFIELD;
                                                                temp_values.vstring = mval_buf.buffer;
                                                                temp_values.vdesc = "Information Flags (low) Byte:";
                                                                temp_values.vlength = 2;
                                                                temp_values.hfname= hf_nds_rflags;
                                                                temp_values.voffset = ioffset;
                                                                temp_values.bit1 = "Output Flags";
                                                                temp_values.bit1hfname = hf_bit1infoflagsl;
                                                                temp_values.bit2 = "Entry ID";
                                                                temp_values.bit2hfname = hf_bit2infoflagsl;
                                                                temp_values.bit3 = "Entry Flags";
                                                                temp_values.bit3hfname = hf_bit3infoflagsl;
                                                                temp_values.bit4 = "Subordinate Count";
                                                                temp_values.bit4hfname = hf_bit4infoflagsl;
                                                                temp_values.bit5 = "Modification Time";
                                                                temp_values.bit5hfname = hf_bit5infoflagsl;
                                                                temp_values.bit6 = "Modification Timestamp";
                                                                temp_values.bit6hfname = hf_bit6infoflagsl;
                                                                temp_values.bit7 = "Creation Timestamp";
                                                                temp_values.bit7hfname = hf_bit7infoflagsl;
                                                                temp_values.bit8 = "Partition Root ID";
                                                                temp_values.bit8hfname = hf_bit8infoflagsl;
                                                                temp_values.bit9 = "Parent ID";
                                                                temp_values.bit9hfname = hf_bit9infoflagsl;
                                                                temp_values.bit10 = "Revision Count";
                                                                temp_values.bit10hfname = hf_bit10infoflagsl;
                                                                temp_values.bit11 = "Replica Type";
                                                                temp_values.bit11hfname = hf_bit11infoflagsl;
                                                                temp_values.bit12 = "Base Class";
                                                                temp_values.bit12hfname = hf_bit12infoflagsl;
                                                                temp_values.bit13 = "Relative Distinguished Name";
                                                                temp_values.bit13hfname = hf_bit13infoflagsl;
                                                                temp_values.bit14 = "Distinguished Name";
                                                                temp_values.bit14hfname = hf_bit14infoflagsl;
                                                                temp_values.bit15 = "Root Distinguished Name";
                                                                temp_values.bit15hfname = hf_bit15infoflagsl;
                                                                temp_values.bit16 = "Parent Distinguished Name";
                                                                temp_values.bit16hfname = hf_bit16infoflagsl;
                                                                process_bitfield(ntree, tvb, &temp_values);
                                                                ioffset = ioffset+2;
                                                                temp_values.vvalue = tvb_get_letohs(tvb, ioffset);
                                                                temp_values.vtype = VTYPE_BITFIELD;
                                                                temp_values.vstring = mval_buf.buffer;
                                                                temp_values.vdesc = "Information Flags (high) Byte:";
                                                                temp_values.vlength = 2;
                                                                temp_values.hfname= hf_nds_rflags;
                                                                temp_values.voffset = ioffset;
                                                                temp_values.bit1 = "Purge Time";
                                                                temp_values.bit1hfname = hf_bit1infoflagsh;
                                                                temp_values.bit2 = "Dereference Base Class";
                                                                temp_values.bit2hfname = hf_bit2infoflagsh;
                                                                temp_values.bit3 = "Not Defined";
                                                                temp_values.bit3hfname = hf_bit3infoflagsh;
                                                                temp_values.bit4 = "Not Defined";
                                                                temp_values.bit4hfname = hf_bit4infoflagsh;
                                                                temp_values.bit5 = "Not Defined";
                                                                temp_values.bit5hfname = hf_bit5infoflagsh;
                                                                temp_values.bit6 = "Not Defined";
                                                                temp_values.bit6hfname = hf_bit6infoflagsh;
                                                                temp_values.bit7 = "Not Defined";
                                                                temp_values.bit7hfname = hf_bit7infoflagsh;
                                                                temp_values.bit8 = "Not Defined";
                                                                temp_values.bit8hfname = hf_bit8infoflagsh;
                                                                temp_values.bit9 = "Not Defined";
                                                                temp_values.bit9hfname = hf_bit9infoflagsh;
                                                                temp_values.bit10 = "Not Defined";
                                                                temp_values.bit10hfname = hf_bit10infoflagsh;
                                                                temp_values.bit11 = "Not Defined";
                                                                temp_values.bit11hfname = hf_bit11infoflagsh;
                                                                temp_values.bit12 = "Not Defined";
                                                                temp_values.bit12hfname = hf_bit12infoflagsh;
                                                                temp_values.bit13 = "Not Defined";
                                                                temp_values.bit13hfname = hf_bit13infoflagsh;
                                                                temp_values.bit14 = "Not Defined";
                                                                temp_values.bit14hfname = hf_bit14infoflagsh;
                                                                temp_values.bit15 = "Not Defined";
                                                                temp_values.bit15hfname = hf_bit15infoflagsh;
                                                                temp_values.bit16 = "Not Defined";
                                                                temp_values.bit16hfname = hf_bit16infoflagsh;
                                                                process_bitfield(ntree, tvb, &temp_values);
                                                                ioffset = ioffset+2;
                                                                break;
                                                        case 0x00000002:                /* Entry ID */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_eid, tvb, ioffset,
                                                                        4, value1, "Entry ID %08x", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000004:                /* Entry Flags */
                                                                temp_values.vvalue = tvb_get_letohl(tvb, ioffset);
                                                                temp_values.vtype = VTYPE_BITFIELD;
                                                                temp_values.vstring = mval_buf.buffer;
                                                                temp_values.vdesc = "Entry Flags:";
                                                                temp_values.vlength = 2;
                                                                temp_values.hfname= hf_nds_eflags;
                                                                temp_values.voffset = ioffset;
                                                                temp_values.bit1 = "Alias Entry";
                                                                temp_values.bit1hfname = hf_bit1eflags;
                                                                temp_values.bit2 = "Partition Root";
                                                                temp_values.bit2hfname = hf_bit2eflags;
                                                                temp_values.bit3 = "Container Entry";
                                                                temp_values.bit3hfname = hf_bit3eflags;
                                                                temp_values.bit4 = "Container Alias";
                                                                temp_values.bit4hfname = hf_bit4eflags;
                                                                temp_values.bit5 = "Matches List Filter";
                                                                temp_values.bit5hfname = hf_bit5eflags;
                                                                temp_values.bit6 = "Reference Entry";
                                                                temp_values.bit6hfname = hf_bit6eflags;
                                                                temp_values.bit7 = "40x Reference Entry";
                                                                temp_values.bit7hfname = hf_bit7eflags;
                                                                temp_values.bit8 = "Back Linked";
                                                                temp_values.bit8hfname = hf_bit8eflags;
                                                                temp_values.bit9 = "New Entry";
                                                                temp_values.bit9hfname = hf_bit9eflags;
                                                                temp_values.bit10 = "Temporary Reference";
                                                                temp_values.bit10hfname = hf_bit10eflags;
                                                                temp_values.bit11 = "Audited";
                                                                temp_values.bit11hfname = hf_bit11eflags;
                                                                temp_values.bit12 = "Entry Not Present";
                                                                temp_values.bit12hfname = hf_bit12eflags;
                                                                temp_values.bit13 = "Entry Verify CTS";
                                                                temp_values.bit13hfname = hf_bit13eflags;
                                                                temp_values.bit14 = "Entry Damaged";
                                                                temp_values.bit14hfname = hf_bit14eflags;
                                                                temp_values.bit15 = "Not Defined";
                                                                temp_values.bit15hfname = hf_bit15eflags;
                                                                temp_values.bit16 = "Not Defined";
                                                                temp_values.bit16hfname = hf_bit16eflags;
                                                                process_bitfield(ntree, tvb, &temp_values);
                                                                ioffset = ioffset+4;
                                                                break;
                                                        case 0x0000008:                 /* Subordinate Count */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_sub_count, tvb, ioffset,
                                                                        4, value1, "Subordinate Count %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x0000010:                 /* Modification Time */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_es_seconds, tvb, ioffset,
                                                                        4, value1, "Modification Time in Seconds %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x0000020:                 /* Modification Timestamp */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_es_seconds, tvb, ioffset,
                                                                        4, value1, "Modification Timestamp Seconds %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                                proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset, 
                                                                        2, replica_num);
                                                                ioffset = ioffset + 2;
                                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                                proto_tree_add_item(ntree, hf_nds_event_num, tvb, ioffset, 
                                                                        2, event_num);
                                                                ioffset = ioffset + 2;
                                                                break;
                                                        case 0x0000040:                 /* Creation Timestamp */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_es_seconds, tvb, ioffset,
                                                                        4, value1, "Creation Timestamp Seconds %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                                proto_tree_add_item(ntree, hf_nds_replica_num, tvb, ioffset, 
                                                                        2, replica_num);
                                                                ioffset = ioffset + 2;
                                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                                proto_tree_add_item(ntree, hf_nds_event_num, tvb, ioffset, 
                                                                        2, event_num);
                                                                ioffset = ioffset + 2;
                                                                break;
                                                        case 0x00000080:                /* Partition Root ID */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_partition_root_id, tvb, ioffset,
                                                                        4, value1, "Partition Root ID %08x", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000100:                /* Parent ID */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_parent, tvb, ioffset,
                                                                        4, value1, "Parent ID %08x", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000200:                /* Revision Count */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_revision, tvb, ioffset,
                                                                        4, value1, "Revision Count %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00000400:                /* Replica Type & State */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                value2 = value1 & 0x00ff;
                                                                temp_values.vstring = (char *)match_strval(value2, nds_replica_type);
                                                                if (temp_values.vstring == NULL)
                                                                {
                                                                        temp_values.vstring = "No Replica Type Found";
                                                                }        
                                                                proto_tree_add_string(ntree, hf_replica_type, tvb, ioffset, 
                                                                4, temp_values.vstring);
                                                                value3 = value1 & 0xff00;
                                                                temp_values.vstring = (char *)match_strval(value3, nds_replica_state);
                                                                if (temp_values.vstring == NULL)
                                                                {
                                                                        temp_values.vstring = "No Replica State Found";
                                                                }        
                                                                proto_tree_add_string(ntree, hf_replica_state, tvb, ioffset, 
                                                                4, temp_values.vstring);
                                                                ioffset = ioffset + 4;
                                                                break;
                                                        case 0x00000800:                /* Base Class */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;                                
                                                                proto_tree_add_string(ntree, hf_nds_base, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        case 0x00001000:                /* Relative Distinguished Name */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;
                                                                proto_tree_add_string(ntree, hf_nds_relative_dn, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        case 0x00002000:                /* Distinguished Name */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;                                
                                                                proto_tree_add_string(ntree, hf_nds_name, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        case 0x00004000:                /* Root Distinguished Name */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;                                
                                                                proto_tree_add_string(ntree, hf_nds_name, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        case 0x00008000:                /* Parent Distinguished Name */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;                                
                                                                proto_tree_add_string(ntree, hf_nds_name, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        case 0x00010000:                /* Purge Time */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
                                                                        4, value1, "Purge Time %d", value1);
                                                                ioffset = ioffset + 4;        
                                                                break;
                                                        case 0x00020000:                /* Dereference Base Class */
                                                                value1 = tvb_get_letohl(tvb, ioffset);
                                                                ioffset = ioffset + 4;
                                                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                                                temp_values.vstring = mval_buf.buffer;                                
                                                                proto_tree_add_string(ntree, hf_deref_base, tvb, ioffset, 
                                                                        value1, temp_values.vstring);
                                                                ioffset = ioffset + value1;        
                                                                break;
                                                        default:
                                                                break;
                                                        
                                                }
                                                ioffset += align_4(tvb, ioffset);
                                        }
                                        bvalue = bvalue*2;
                                        /* We could loop forever so check to see if bvalue has wrapped to 0.
                                         * if so then just abort loop.
                                         */
                                        if (bvalue==0) {
                                               break;
                                        }
                                        if(tvb_length_remaining(tvb, ioffset) < 4 )
                                        {
                                                break;
                                        }
                                }        
                                if(tvb_length_remaining(tvb, ioffset) < 4 )
                                {
                                        break;
                                }
                        }
                        break;                

                case MVTYPE_CLASS_NAMES:  /* Class Names */
                        number_of_referrals = values->vvalue;
                        for (i = 0; i < number_of_referrals; i++)
                        {        
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                temp_values.vstring = mval_buf.buffer;                                
                                sub1item = proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset, 
                                        value1, temp_values.vstring);
                                sub1tree = proto_item_add_subtree(sub1item, ett_nds);
                                ioffset = ioffset + value1;        
                                ioffset += align_4(tvb, ioffset);
                                if(values->vflags != 0)
                                {
                                        temp_values.vvalue = tvb_get_letohl(tvb, ioffset);
                                        temp_values.vtype = VTYPE_BITFIELD;
                                        temp_values.vstring = mval_buf.buffer;
                                        temp_values.vdesc = "Class Flags:";
                                        temp_values.vlength = 2;
                                        temp_values.hfname= hf_nds_cflags;
                                        temp_values.voffset = ioffset;
                                        temp_values.bit1 = "Ambiguous Containment";
                                        temp_values.bit1hfname = hf_bit1cflags;
                                        temp_values.bit2 = "Ambiguous Naming";
                                        temp_values.bit2hfname = hf_bit2cflags;
                                        temp_values.bit3 = "Class Definition Cannot be Removed";
                                        temp_values.bit3hfname = hf_bit3cflags;
                                        temp_values.bit4 = "Effective Class";
                                        temp_values.bit4hfname = hf_bit4cflags;
                                        temp_values.bit5 = "Container Class";
                                        temp_values.bit5hfname = hf_bit5cflags;
                                        temp_values.bit6 = "Not Defined";
                                        temp_values.bit6hfname = hf_bit6cflags;
                                        temp_values.bit7 = "Not Defined";
                                        temp_values.bit7hfname = hf_bit7cflags;
                                        temp_values.bit8 = "Not Defined";
                                        temp_values.bit8hfname = hf_bit8cflags;
                                        temp_values.bit9 = "Not Defined";
                                        temp_values.bit9hfname = hf_bit9cflags;
                                        temp_values.bit10 = "Not Defined";
                                        temp_values.bit10hfname = hf_bit10cflags;
                                        temp_values.bit11 = "Not Defined";
                                        temp_values.bit11hfname = hf_bit11cflags;
                                        temp_values.bit12 = "Not Defined";
                                        temp_values.bit12hfname = hf_bit12cflags;
                                        temp_values.bit13 = "Not Defined";
                                        temp_values.bit13hfname = hf_bit13cflags;
                                        temp_values.bit14 = "Not Defined";
                                        temp_values.bit14hfname = hf_bit14cflags;
                                        temp_values.bit15 = "Not Defined";
                                        temp_values.bit15hfname = hf_bit15cflags;
                                        temp_values.bit16 = "Not Defined";
                                        temp_values.bit16hfname = hf_bit16cflags;
                                        process_bitfield(sub1tree, tvb, &temp_values);
                                        ioffset = ioffset+4;
                                        if(values->vflags != 5)
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset); /* length of field */
                                                length_remaining = tvb_length_remaining(tvb, ioffset);
                                                if(length_remaining == -1 || value1 > (guint32) length_remaining)
                                                {
                                                         break;
                                                }
                                                ioffset += 4;
                                                tvb_ensure_bytes_exist(tvb, ioffset, value1);
                                                proto_tree_add_bytes(sub1tree, hf_nds_asn1, tvb, ioffset, value1, tvb_get_ptr(tvb, ioffset, value1));
                                                ioffset += value1;
                                                ioffset += (value1%2);
                                        }
                                        if(values->vflags == 1 || values->vflags == 2 || values->vflags == 4)
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Super Classes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Super Classes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_nds_super, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Containment Classes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Containment Classes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_nds_base_class, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Naming Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Naming Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Mandatory Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Mandatory Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Optional Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Optional Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        ioffset += align_4(tvb, ioffset);
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        if(tvb_length_remaining(tvb, ioffset) < 4 )
                                                        {
                                                                break;
                                                        }
                                                }        
                                        }
                                        /*if(values->vflags == 2 || values->vflags == 4)*/   /* Class Definitions of Super Classes */
                                        if(values->vflags == 4)   /* Class Definitions of Super Classes */
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Containment Classes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Containment Classes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_nds_base_class, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Naming Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Naming Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Mandatory Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Mandatory Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Optional Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Optional Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);    /* Default ACL */
                                                proto_tree_add_uint_format(sub1tree, hf_nds_eid, tvb, ioffset,
                                                        4, value1, "Default ACL %08x", value1);
                                                ioffset = ioffset + 4;        
                                                if(tvb_length_remaining(tvb, ioffset) < 4 )
                                                {
                                                        break;
                                                }
                                        }
                                        if(values->vflags == 5)   /* Base Class Definitions */
                                        {
                                                value1 = tvb_get_letohl(tvb, ioffset);         /* Creation Timestamp */
                                                proto_tree_add_uint_format(sub1tree, hf_es_seconds, tvb, ioffset,
                                                        4, value1, "Creation Timestamp Seconds %d", value1);
                                                ioffset = ioffset + 4;        
                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                proto_tree_add_item(sub1tree, hf_nds_replica_num, tvb, ioffset, 
                                                        2, replica_num);
                                                ioffset = ioffset + 2;
                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                proto_tree_add_item(sub1tree, hf_nds_event_num, tvb, ioffset, 
                                                        2, event_num);
                                                ioffset = ioffset + 2;
                                                value1 = tvb_get_letohl(tvb, ioffset);          /* Modification Timestamp */
                                                proto_tree_add_uint_format(sub1tree, hf_es_seconds, tvb, ioffset,
                                                        4, value1, "Modification Timestamp Seconds %d", value1);
                                                ioffset = ioffset + 4;        
                                                replica_num = tvb_get_letohs(tvb, ioffset);   /* Replica */
                                                proto_tree_add_item(sub1tree, hf_nds_replica_num, tvb, ioffset, 
                                                        2, replica_num);
                                                ioffset = ioffset + 2;
                                                event_num = tvb_get_letohs(tvb, ioffset);   /* Event */
                                                proto_tree_add_item(sub1tree, hf_nds_event_num, tvb, ioffset, 
                                                        2, event_num);
                                                ioffset = ioffset + 2;
                                                /* Class Definition */
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Super Classes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Super Classes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_nds_super, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Containment Classes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Containment Classes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_nds_base_class, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Naming Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Naming Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Mandatory Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Mandatory Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);  /* Optional Attributes */
                                                sub2item = proto_tree_add_uint_format(sub1tree, hf_nds_purge, tvb, ioffset,
                                                        4, value1, "Optional Attributes %d", value1);
                                                sub2tree = proto_item_add_subtree(sub2item, ett_nds);
                                                ioffset = ioffset + 4;        
                                                for (r = 0; r < value1; r++)
                                                {
                                                        value2 = tvb_get_letohl(tvb, ioffset);
                                                        ioffset = ioffset + 4;
                                                        get_string(tvb, ioffset, value2, mval_buf.buffer);
                                                        temp_values.vstring = mval_buf.buffer;                                
                                                        proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset, 
                                                                value2, temp_values.vstring);
                                                        ioffset = ioffset + value2;        
                                                        ioffset += align_4(tvb, ioffset);
                                                }        
                                                value1 = tvb_get_letohl(tvb, ioffset);    /* Default ACL */
                                                proto_tree_add_uint_format(sub1tree, hf_nds_eid, tvb, ioffset,
                                                        4, value1, "Default ACL %08x", value1);
                                                ioffset = ioffset + 4;        
                                                if(tvb_length_remaining(tvb, ioffset) < 4 )
                                                {
                                                        break;
                                                }
                                        }
                                }                                        
                        }
                        break;                

                case MVTYPE_MODIFY_CLASS: /* Modify Class */
                        for (i = 1 ; i <= values->vvalue; i++ )   /* Attribute Names to add*/
                        {
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value1, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                        value1, values->vstring);
                                ioffset = ioffset + value1;        
                        }
                        if(tvb_length_remaining(tvb, ioffset) < 4 )
                        {
                                break;
                        }
                        ioffset += align_4(tvb, ioffset);
                        value1 = tvb_get_letohl(tvb, ioffset);    
                        proto_tree_add_uint_format(ntree, hf_nds_att_del, tvb, ioffset,
                                4, value1, "Attribute Names to Delete %d", value1);
                        ioffset = ioffset + 4;        
                        for (i = 1 ; i <= value1; i++ )   /* Attribute Names to delete*/
                        {
                                ioffset += align_4(tvb, ioffset);
                                value2 = tvb_get_letohl(tvb, ioffset);
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_mv_string, tvb, ioffset, 
                                        value2, values->vstring);
                                ioffset = ioffset + value2;        
                        }
                        if(tvb_length_remaining(tvb, ioffset) < 4 )
                        {
                                break;
                        }
                        ioffset += align_4(tvb, ioffset);
                        value1 = tvb_get_letohl(tvb, ioffset);    
                        proto_tree_add_uint_format(ntree, hf_nds_acl_add, tvb, ioffset,
                                4, value1, "ACL Templates to Add %d", value1);
                        ioffset = ioffset + 4;        
                        for (i = 1 ; i <= value1; i++ )   /* ACL templates to add*/
                        {
                                ioffset += align_4(tvb, ioffset);
                                value2 = tvb_get_letohl(tvb, ioffset);  /* Attribute Name */
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_nds_attribute_dn, tvb, ioffset, 
                                        value2, values->vstring);
                                ioffset = ioffset + value2;        
                                ioffset += align_4(tvb, ioffset);
                                value2 = tvb_get_letohl(tvb, ioffset);  /* DN of Trustee */
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_nds_trustee_dn, tvb, ioffset, 
                                        value2, values->vstring);
                                ioffset = ioffset + value2;        
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);    
                                proto_tree_add_uint_format(ntree, hf_nds_privileges, tvb, ioffset,
                                        4, value1, "Priviledges 0x%08x", value1);
                                ioffset = ioffset + 4;        
                        }
                        if(tvb_length_remaining(tvb, ioffset) < 4 )
                        {
                                break;
                        }
                        ioffset += align_4(tvb, ioffset);
                        value1 = tvb_get_letohl(tvb, ioffset);    
                        proto_tree_add_uint_format(ntree, hf_nds_acl_del, tvb, ioffset,
                                4, value1, "ACL Templates to Delete %d", value1);
                        ioffset = ioffset + 4;        
                        for (i = 1 ; i <= value1; i++ )   /* ACL templates to delete*/
                        {
                                ioffset += align_4(tvb, ioffset);
                                value2 = tvb_get_letohl(tvb, ioffset);  /* Attribute Name */
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_nds_attribute_dn, tvb, ioffset, 
                                        value2, values->vstring);
                                ioffset = ioffset + value2;        
                                ioffset += align_4(tvb, ioffset);
                                value2 = tvb_get_letohl(tvb, ioffset);  /* DN of Trustee */
                                ioffset = ioffset + 4;
                                get_string(tvb, ioffset, value2, mval_buf.buffer);
                                values->vstring = mval_buf.buffer;                                
                                proto_tree_add_string(ntree, hf_nds_trustee_dn, tvb, ioffset, 
                                        value2, values->vstring);
                                ioffset = ioffset + value2;        
                                ioffset += align_4(tvb, ioffset);
                                value1 = tvb_get_letohl(tvb, ioffset);  /* Priviledges */  
                                proto_tree_add_uint_format(ntree, hf_nds_privileges, tvb, ioffset,
                                        4, value1, "Priviledges 0x%08x", value1);
                                ioffset = ioffset + 4;        
                        }
                        break;
                default:        
                        break;
        }
}

void
dissect_ncp_123_11_reply(tvbuff_t *tvb, proto_tree *volatile ncp_tree, ncp_req_hash_value *request_value)
{
    int string_len, loffset;

    loffset = 76;
    if (request_value->length == 7) {
        /* Undocumented, if request value length is 7 then the reply is offset by 8 bytes.
         * Unknown what these 8 bytes represent */
        loffset += 8;
    }
    string_len = tvb_get_guint8(tvb, loffset);
    proto_tree_add_item(ncp_tree, hf_ncp_file_name_12, tvb, loffset+1, string_len, TRUE);
    loffset += string_len+1;
    string_len = tvb_get_guint8(tvb, loffset);
    proto_tree_add_item(ncp_tree, hf_ncp_name12, tvb, loffset+1, string_len, TRUE);
    loffset += string_len+1;
    string_len = tvb_get_guint8(tvb, loffset);
    proto_tree_add_item(ncp_tree, hf_ncp_copyright, tvb, loffset+1, string_len, TRUE);
}

void
dissect_ncp_123_17_reply(tvbuff_t *tvb, proto_tree *volatile ncp_tree)
{
    proto_tree              *atree;
    proto_item              *aitem;
    guint32 loffset, number_of_items, addr_type;
    guint16 x;

    number_of_items = tvb_get_letohl(tvb, 36);
    proto_tree_add_item(ncp_tree, hf_ncp_items_in_packet, tvb, 36, 4, TRUE);
    loffset = 40;
    for (x = 1; x <= number_of_items; x++) 
    {
        aitem = proto_tree_add_text(ncp_tree, tvb, loffset, -1, "Network Address - %d", x);
        atree = proto_item_add_subtree(aitem, ett_ncp);

        addr_type = tvb_get_guint8(tvb, loffset);
        proto_tree_add_item(atree, hf_ncp_transport_type, tvb, loffset, 1, TRUE);
        /* The address type is one byte of a 4 byte value. The next 4 bytes are
         * the length of the address. Since we already know the length based upon
         * the type of address, we can skip this value. So set the offset accourdingly */
        loffset += 8;

        switch (addr_type)
        { 
                case 1:
                    proto_tree_add_item(atree, hf_nds_net, tvb, loffset, 4, FALSE);
                    proto_tree_add_item(atree, hf_nds_node, tvb, loffset+4, 6, FALSE);
                    proto_tree_add_item(atree, hf_nds_socket, tvb, loffset+10, 2, FALSE);
                    loffset += 12;
                    break;
                case 5:
                    proto_tree_add_item(atree, hf_nds_port, tvb, loffset, 2, FALSE);
                    proto_tree_add_item(atree, hf_add_ref_udp, tvb, loffset+2, 4, FALSE);
                    loffset += 6;
                    break;
                case 6:
                    proto_tree_add_item(atree, hf_nds_port, tvb, loffset, 2, FALSE);
                    proto_tree_add_item(atree, hf_add_ref_tcp, tvb, loffset+2, 4, FALSE);
                    loffset += 6;
                    break;
                default:
                    proto_tree_add_text(atree, tvb, loffset, -1, "Unknown Address Type");
                    /* unknown type so read the length field and then 
                    * just skip the record and move on to the next */
                    loffset += tvb_get_letohl(tvb, loffset - 4);
                    break;
        }
        proto_item_set_end(aitem, tvb, loffset);
        if(tvb_length_remaining(tvb, loffset) < 4 )
        {
                break;
        }
    }
}
                                
void
dissect_ncp_23_26_reply(tvbuff_t *tvb, proto_tree *volatile ncp_tree)
{
    /* For an IP-only server, the 4-byte IP address is placed into the 4-byte NetworkAddress
     * field of the NetworkAddressStruct, while the NetworkNodeAddress and NetworkSocket 
     * fields are left blank. */
    if (tvb_get_letohl(tvb, 12)==0) {
        /* IP Address */
        proto_tree_add_item(ncp_tree, hf_ncp_ip_address, tvb, 8, 4, FALSE);
    }
    else
    {
        /* IPX Address */
        proto_tree_add_item(ncp_tree, hf_nds_net, tvb, 8, 4, FALSE);
        proto_tree_add_item(ncp_tree, hf_nds_node, tvb, 12, 6, FALSE);
        proto_tree_add_item(ncp_tree, hf_nds_socket, tvb, 18, 2, FALSE);
    }
    proto_tree_add_item(ncp_tree, hf_ncp_connection_type, tvb, 20, 1, TRUE);
}

void
dissect_ncp_8x20reply(tvbuff_t *tvb, proto_tree *volatile ncp_tree, 
                      const ncp_record    *ncp_rec, ncp_req_hash_value *request_value)
{
    guint16 x;
    guint32 loffset, number_of_items, str_length;
      ptvcursor_t             *ptvc = NULL;
    proto_tree              *atree, *btree;
    proto_item              *aitem, *bitem;

    proto_tree_add_item(ncp_tree, hf_ncp_search_sequence, tvb, 8, 9, TRUE);
    proto_tree_add_item(ncp_tree, hf_ncp_more_flag, tvb, 17, 1, TRUE);
    number_of_items = tvb_get_letohs(tvb, 18);
    proto_tree_add_item(ncp_tree, hf_ncp_info_count, tvb, 18, 2, TRUE);
    loffset = 20;
    for (x = 1; x <= number_of_items; x++ )
    {
        aitem = proto_tree_add_text(ncp_tree, tvb, loffset, -1, "Information Item %d", x);
        atree = proto_item_add_subtree(aitem, ett_ncp);
        /* Data Stream Space Allocated */
        if (request_value->req_mask & 0x0002) {
            proto_tree_add_item(atree, hf_ncp_data_stream_space_alloc, tvb, loffset, 4, TRUE);
            loffset += 4;
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 4;
            }
        }
        /* Attributes */
        if (request_value->req_mask & 0x0004) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Attributes");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_attributes_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 6;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 6;
            }
        }
        /* Data Stream Size */
        if (request_value->req_mask & 0x0008) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Data Stream Size");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            proto_tree_add_item(btree, hf_ncp_data_stream_size, tvb, loffset, 4, TRUE);
            loffset += 4;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 4;
            }
        }
        /* Total Stream Size */
        if (request_value->req_mask & 0x0010) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Total Stream Size");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            proto_tree_add_item(btree, hf_ncp_ttl_ds_disk_space_alloc, tvb, loffset, 4, TRUE);
            proto_tree_add_item(btree, hf_ncp_number_of_data_streams, tvb, loffset+4, 2, TRUE);
            loffset += 6;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 6;
            }
        }
        /* Extended Attributes new style location*/
        if (request_value->req_mask & 0x0020 && ncp_newstyle) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Extended Attributes");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_ea_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 12;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE && ncp_newstyle) {
                loffset += 12;
            }
        }
        /* Creation Information old style location */
        if (request_value->req_mask & 0x0100 && !ncp_newstyle) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Creation");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_creation_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 8;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE && !ncp_newstyle) {
                loffset += 8;
            }
        }
        /* Modification Information */
        if (request_value->req_mask & 0x0080) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Modification");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_modify_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 10;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 10;
            }
        }
        /* Creation Information new style location */
        if (request_value->req_mask & 0x0100 && ncp_newstyle) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Creation");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_creation_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 8;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE && ncp_newstyle) {
                loffset += 8;
            }
        }
        /* Archive Information */
        if (request_value->req_mask & 0x0040) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Archive");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_archive_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 8;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 8;
            }
        }
        /* Rights Information */
        if (request_value->req_mask & 0x0800) {
            ptvc = ptvcursor_new(atree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_rights_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 2;
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 2;
            }
        }
        /* Directory Entry */
        if (request_value->req_mask & 0x0400) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Directory Entry");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_dir_entry_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 12;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 12;
            }
        }
        /* Extended Attributes oldstyle location*/
        if (request_value->req_mask & 0x0020 && !ncp_newstyle) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Extended Attributes");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_ea_info_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 12;
            proto_item_set_end(bitem, tvb, loffset);
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE && !ncp_newstyle) {
                loffset += 12;
            }
        }
        /* Name Space Information */
        if (request_value->req_mask & 0x0200) {
            proto_tree_add_item(atree, hf_ncp_creator_name_space_number, tvb, loffset, 1, TRUE);
            loffset += 4;
        }
        else
        {
            if ((request_value->req_mask_ext & 0x8000)==FALSE) {
                loffset += 4;
            }
        }
        if (request_value->req_mask & 0x1000) {
            proto_tree_add_item(atree, hf_ncp_curr_ref_id, tvb, loffset, 2, TRUE);
            loffset += 2;
        }
        if (request_value->req_mask & 0x2000) {
            proto_tree_add_item(atree, hf_ncp_attr_def_32, tvb, loffset, 1, TRUE);
            loffset += 4;
        }
        if (request_value->req_mask & 0x4000) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Actual");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            proto_tree_add_item(btree, hf_ncp_data_stream_num_long, tvb, loffset, 4, TRUE);
            proto_tree_add_item(btree, hf_ncp_data_stream_fat_blks, tvb, loffset+4, 4, TRUE);
            loffset += 8;
            proto_item_set_end(bitem, tvb, loffset);
        }
        if (request_value->req_mask & 0x8000) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Logical");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            proto_tree_add_item(btree, hf_ncp_data_stream_num_long, tvb, loffset, 4, TRUE);
            proto_tree_add_item(btree, hf_ncp_data_stream_size, tvb, loffset+4, 4, TRUE);
            loffset += 8;
            proto_item_set_end(bitem, tvb, loffset);
        }
        if (request_value->req_mask_ext & 0x0001 && ncp_newstyle) {
            proto_tree_add_item(atree, hf_ncp_sec_rel_to_y2k, tvb, loffset, 4, TRUE);
            loffset += 4;
        }
        if (request_value->req_mask_ext & 0x0002 && ncp_newstyle) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "DOS Name");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            if (ncp_rec->func == 0x57) {
                str_length = tvb_get_guint8(tvb, loffset);
                loffset += 1;
            }
            else
            {
                str_length = tvb_get_letohs(tvb, loffset);
                loffset += 2;
            }
            proto_tree_add_item(btree, hf_ncp_file_name_12, tvb, loffset, str_length, FALSE);
            loffset += str_length;
            proto_item_set_end(bitem, tvb, loffset);
        }
        if (request_value->req_mask_ext & 0x0004 && ncp_newstyle) {
            ptvc = ptvcursor_new(atree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_flush_time_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 4;
        }
        if (request_value->req_mask_ext & 0x0008 && ncp_newstyle) {
            proto_tree_add_item(atree, hf_ncp_parent_base_id, tvb, loffset, 4, TRUE);
            loffset += 4;
        }
        if (request_value->req_mask_ext & 0x0010 && ncp_newstyle) {
            proto_tree_add_item(atree, hf_ncp_mac_finder_info, tvb, loffset, 32, TRUE);
            loffset += 32;
        }
        if (request_value->req_mask_ext & 0x0020 && ncp_newstyle) {
            proto_tree_add_item(atree, hf_ncp_sibling_count, tvb, loffset, 4, TRUE);
            loffset += 4;
        }
        if (request_value->req_mask_ext & 0x0040 && ncp_newstyle) {
            proto_tree_add_item(atree, hf_ncp_effective_rights, tvb, loffset, 1, TRUE);
            loffset += 4;
        }
        if (request_value->req_mask_ext & 0x0080 && ncp_newstyle) {
            bitem = proto_tree_add_text(atree, tvb, loffset, -1, "Mac Date");
            btree = proto_item_add_subtree(bitem, ett_ncp);
            ptvc = ptvcursor_new(btree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_mac_time_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 8;
            proto_item_set_end(bitem, tvb, loffset);
        }
        if (request_value->req_mask_ext & 0x0100 && ncp_newstyle) {
            ptvc = ptvcursor_new(atree, tvb, loffset);
            process_ptvc_record(ptvc, ptvc_struct_last_access_time_struct,
                    NULL, TRUE, ncp_rec);
            ptvcursor_free(ptvc);
            loffset += 2;
        }
        if (request_value->req_mask_ext & 0x0400 && ncp_newstyle) {
            proto_tree_add_item(atree, hf_ncp_f_size_64bit, tvb, loffset, 8, TRUE);
            loffset += 8;
        }
        /* We always return the file name */
        if (ncp_rec->func == 0x57) {
            str_length = tvb_get_guint8(tvb, loffset);
            loffset += 1;
        }
        else
        {
            str_length = tvb_get_letohs(tvb, loffset);
            loffset += 2;
        }
        proto_tree_add_item(atree, hf_ncp_file_name_12, tvb, loffset, str_length, FALSE);
        loffset += str_length;

        proto_item_set_end(aitem, tvb, loffset);

        if(tvb_length_remaining(tvb, loffset) < 4 )
        {
                break;
        }
    }
}

/*
 * Defrag logic 
 *
 * NDS fragment not being set to 0xffffffff indicates we are inside or at the 
 * beginning of a fragment. But when the end of the fragment 
 * is encounterd the flag is set to 0xffffffff. So we must mark what the
 * frame number is of the end fragment so that we will be
 * able to redissect if the user clicks on the packet
 * or resorts/filters the trace. 
 *
 * Once we are certain that we are in a fragment sequence
 * then we can just process each fragment in this conversation
 * until we reach the fragment == 0xffffffff packet. 
 *
 * We will be able to easily determine if a conversation is a fragment
 * with the exception of the last packet in the fragment. So remember
 * the last fragment packet number.
 *
 * Also the NDS dissection requires the values of NDS Verb, Version, and Flags.
 * Without this values being remembered from the first request packet then 
 * we will be unable to dissect the reply packet. For this reason we remember
 * these values on the first fragment and then populate the values in the final
 * fragment. We only do this on the first dissection.
 */         
void
nds_defrag(tvbuff_t *tvb, packet_info *pinfo, guint32 nw_connection, guint8 sequence, guint16 type, proto_tree *tree, struct novell_tap *ncp_tap)
{
    int                 i, frag_count=0;
    guint                 len=0;
    guint32             tid = 1;
    tvbuff_t            *frag_tvb = NULL;
    fragment_data       *fd_head;
    ncp_req_hash_value  *request_value = NULL;
    conversation_t      *conversation;
    guint32             nds_frag;
    
    for (i = 0; i < 99; i++) {
        if (!frags[i].nds_fragmented)
      {
                frags[i].nds_frag = 0xfffffff0;
        }
    }
    /* Check to see if defragmentation is enabeled in the dissector */
    if (!nds_defragment) {
        dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
        return;
    }
    /* Has this already been dissected? */
    if (!pinfo->fd->flags.visited) {
            /* Find the conversation whence the request would have come. */
            conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                      PT_NCP, nw_connection, nw_connection, 0);
            if (conversation != NULL) {
                  /* find the record telling us the request made that caused
                     this reply */
                  request_value = ncp_hash_lookup(conversation, sequence);
                  if (!request_value) {
                        dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
                        return;
                }
                  p_add_proto_data(pinfo->fd, proto_ncp, (void*) request_value);
            }
            /* else... we haven't seen an NCP Request for that conversation and sequence. */
        else
        {
                dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
                return;
        }
    }
    else {
            request_value = p_get_proto_data(pinfo->fd, proto_ncp);
            if (!request_value) {
                dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
                return;
        }
    }
    /* Validate that this is an NDS packet */
    /* If this isn't an NDS packet then just return */
    if (!request_value->ncp_rec ||
         request_value->ncp_rec->func!=104 || request_value->ncp_rec->subfunc!=2) {
        dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
        return;
    }
    /* Check to see if there is at least enough packet info to get the fragment flag */
    if (tvb_reported_length_remaining(tvb, 12) < 4) {
        dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
        return;
    }
    /* Get the fragment flag */
    nds_frag = tvb_get_letohl(tvb, 12);
    
    /* Now we need to find if this is a new fragment or already one defined. */
    /* We currently limit the maximum number of simultaneous fragments to 100. */
    for (i=0; i<100; i++)
    {
        if (frags[i].nds_frag == nds_frag || frags[i].nds_frag == 0xfffffff0)
        {
                if (frags[i].nds_frag == 0xfffffff0)
                {
                        frags[i].nds_length = 0;
                        frags[i].nds_frag = nds_frag;
                        frags[i].nds_fragmented = TRUE;
                }
                break;
        }
    }
    if (i > 99)
        return;

    frag_count = i;
    
    /* is this the end of an existing fragment or just another reply */
    if (nds_frag == 0xffffffff && request_value->nds_frag_num == 0xffffffff)
    {
                dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
                return;
    } 
    
    /* Now we process the fragments */
    if (request_value->nds_frag || (request_value->nds_end_frag == pinfo->fd->num)) 
    {
        /* Check to see of this is a fragment. If so then mark as a fragment. */
        if (frags[frag_count].nds_frag==0xffffffff) {
                request_value->nds_frag = FALSE;
                /* nds_length of 0 means start of fragment */
                frags[frag_count].nds_length = 0;
        }
        else
        {
                if (frags[frag_count].nds_length == 0)
                {
                        frags[frag_count].nds_length = tvb_get_letohl(tvb, 0);
                }
        }
        /*   
         * Fragment
         *
         */
        tid = (pinfo->srcport+pinfo->destport);
        len = tvb_reported_length(tvb);
        if (len > 0 && tvb_bytes_exist(tvb, 0, len))
        {
            if (frags[frag_count].nds_length > len)
            {
                /* This is the first fragment so remember the verb, version, and flags. */
                frags[frag_count].nds_frag_verb = request_value->nds_request_verb;
                frags[frag_count].nds_frag_version = request_value->nds_version;
                frags[frag_count].nds_frag_flags = request_value->req_nds_flags;
                fd_head = fragment_add_seq_next(tvb, 0, pinfo, tid, nds_fragment_table, nds_reassembled_table, len, request_value->nds_frag);
                frags[frag_count].nds_length = 1;
            }
            else
            {
                /* Subsequent fragments should be offset by 16 since we do not need */
                /* the additional fragment handle and size fields in our composite data */
                fd_head = fragment_add_seq_next(tvb, 16, pinfo, tid, nds_fragment_table, nds_reassembled_table, len-16, request_value->nds_frag);
            } 
            if (fd_head != NULL) 
            {
                /* Is this the last fragment? nds_frag will indicate */
                if (fd_head->next != NULL && !request_value->nds_frag) 
                {
                    frag_tvb = tvb_new_real_data(fd_head->data,
                        fd_head->len, fd_head->len);
                    tvb_set_child_real_data_tvbuff(tvb,
                        frag_tvb);
                    add_new_data_source(pinfo,
                        frag_tvb,
                        "Reassembled NDS");
                    /* Show all fragments. */
                    if (tree) 
                    {
                        proto_item *frag_tree_item;
                        show_fragment_seq_tree(fd_head,
                            &nds_frag_items,
                            tree, pinfo,
                            frag_tvb, &frag_tree_item);
                        tid++;
                    }
                    
                    if (!pinfo->fd->flags.visited) 
                    {
                         /* Now we need to find the original fragment number. */
                         /* Get the fragment flag */
                         nds_frag = tvb_get_letohl(frag_tvb, 12);
                         for (i=0; i<100; i++)
                         {
                             if (frags[i].nds_frag == nds_frag)
                             {
                                     break;
                             }
                         }
                         if (i > 99)
                             return;
                         if (frags[i].nds_frag == 0xffffffff)
                         {
                                 /* Error can't find fragment */
                                 /*DISSECTOR_ASSERT(0);*/
                         }
                         frag_count = i;
                        /* Remember this fragment information so we can dissect.
                         * Only do this on the first dissection. After the first 
                         * dissection we will just read the memory values. 
                         */
                        request_value->nds_end_frag = pinfo->fd->num;
                        request_value->nds_request_verb = frags[frag_count].nds_frag_verb;
                        request_value->nds_version = frags[frag_count].nds_frag_version;
                        request_value->req_nds_flags = frags[frag_count].nds_frag_flags;
                    }

                } 
                else 
                {
                    /* This is either a beggining or middle fragment on second dissection */
                    frag_tvb = tvb_new_subset(tvb, 0, -1, -1);
                    if (check_col(pinfo->cinfo, COL_INFO))
                    {
                      if (request_value->nds_frag)
                      {
                        col_add_fstr(pinfo->cinfo, COL_INFO, "[NDS Fragment %08x]", frags[frag_count].nds_frag);
                      }
                    }
                }
            }
            else 
            {
                /* Fragment from first pass of dissection */
                if (check_col(pinfo->cinfo, COL_INFO))
                {
                  if (request_value->nds_frag)
                  {
                     col_add_fstr(pinfo->cinfo, COL_INFO, "[NDS Fragment %08x]", frags[frag_count].nds_frag);
                  }
                }
                frag_tvb = NULL;
            }
        }
        else 
        {
            /*
             * There are no bytes so Dissect this
             */
            frag_tvb = tvb_new_subset(tvb, 0, -1, -1);
        }
        if (frag_tvb == NULL)
        {
            /* This is a fragment packet */
                frag_tvb = tvb_new_subset (tvb, 0, -1, -1);
              nds_data_handle = find_dissector("data");
                call_dissector(nds_data_handle, frag_tvb, pinfo, tree);
        }
        else
        {
            /* This is the end fragment so dissect */
            if (!request_value->nds_frag) {
                frags[frag_count].nds_length = 0;
                dissect_ncp_reply(frag_tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
            }
        }
    }
    else
    {
        /* This is not any fragment packet */
        frags[frag_count].nds_length = 0;
        request_value->nds_frag = FALSE;
        dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree, ncp_tap);
    }
}

void
dissect_ncp_request(tvbuff_t *tvb, packet_info *pinfo,
            guint32 nw_connection, guint8 sequence,
            guint16 type, proto_tree *volatile ncp_tree)
{
      guint8                  func, subfunc = 0;
      gboolean          requires_subfunc = FALSE;
      gboolean          has_length = FALSE;
      ncp_req_hash_value      *volatile request_value = NULL;
      const ncp_record  *volatile ncp_rec = NULL;
      conversation_t          *conversation;
      ptvcursor_t       *volatile ptvc = NULL;
      proto_tree        *temp_tree = NULL;
      volatile gboolean run_req_cond = FALSE;
      volatile gboolean run_info_str = FALSE;
    guint32                 length_remaining;
    guint32                 testvar;
    unsigned long           except_code;
    const char              *message;

      func = tvb_get_guint8(tvb, 6);

      /* Determine which ncp_record to use. */
      switch (type) {
            case NCP_ALLOCATE_SLOT:
                        length_remaining = tvb_length_remaining(tvb, 4);
                        if (length_remaining > 4)
                        { 
                                testvar = tvb_get_ntohl(tvb, 4);
                                if( testvar == 0x4c495020)
                                {
                                        ncp_rec = &ncplip_echo;
                                }
                                else
                                {
                                        ncp_rec = &ncp1111_request;
                                    if (ncp_echo_conn) {
                                        expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "Connection Request");
                                    }
                                }        
                        }        
                        else
                        {
                                ncp_rec = &ncp1111_request;
                            if (ncp_echo_conn) {
                                expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "Connection Request");
                            }
                        }        
                  break;
            case NCP_SERVICE_REQUEST:
                  requires_subfunc = ncp_requires_subfunc(func);
                  has_length = ncp_has_length_parameter(func);
                  if (requires_subfunc) {
                        if (has_length) {
                              subfunc = tvb_get_guint8(tvb, 9);
                        }
                        else {
                              subfunc = tvb_get_guint8(tvb, 7);
                        }
                  }
                  ncp_rec = ncp_record_find(func, subfunc);
                  break;
            case NCP_DEALLOCATE_SLOT:
                  ncp_rec = &ncp5555_request;
            if (ncp_echo_conn) {
                expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "Destroy Connection %d Request", nw_connection);
            }
                  break;
            case NCP_BROADCAST_SLOT:
                  ncp_rec = &ncpbbbb_request;
                  break;
                case NCP_LIP_ECHO:
                        ncp_rec = &ncplip_echo;
                        break;        
            default:
                  ncp_rec = NULL;
                  break;
      }

      /* Fill in the INFO column. */
      if (check_col(pinfo->cinfo, COL_INFO)) {
                  if (ncp_rec) {
                  col_add_fstr(pinfo->cinfo, COL_INFO, "C %s", ncp_rec->name);
                  if (ncp_rec->req_info_str) {
                        /* We want to add more stuff to the Info
                           column. */
                        run_info_str = TRUE;
                  }
            }
            else {
                  if (requires_subfunc) {
                        col_add_fstr(pinfo->cinfo, COL_INFO,
                              "C Unknown Function %u %u (0x%02X/0x%02x)",
                              func, subfunc, func, subfunc);
                    return;
                  }
                  else {
                        col_add_fstr(pinfo->cinfo, COL_INFO,
                              "C Unknown Function %u (0x%02x)",
                              func, func);
                    return;
                  }
            }
        }
      if (!pinfo->fd->flags.visited) {
            /* This is the first time we've looked at this packet.
               Keep track of the address and connection whence the request
               came, and the address and connection to which the request
               is being sent, so that we can match up calls with replies.
               (We don't include the sequence number, as we may want
               to have all packets over the same connection treated
               as being part of a single conversation so that we can
               let the user select that conversation to be displayed.) */
            conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                PT_NCP, nw_connection, nw_connection, 0);

            if (conversation == NULL) {
                  /* It's not part of any conversation - create a new one. */
                  conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                      PT_NCP, nw_connection, nw_connection, 0);
            }
            request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
            request_value->req_frame_num = pinfo->fd->num;
            request_value->req_frame_time = pinfo->fd->abs_ts;

            /* If this is the first time we're examining the packet,
             * check to see if this NCP type uses a "request condition".
             * If so, we have to build a proto_tree because request conditions
             * use display filters to work, and without a proto_tree,
             * display filters can't possibly work. */
            if (ncp_rec) {
                        if (ncp_rec->req_cond_indexes) {
                        run_req_cond = TRUE;
                        }
            }
      }

      /* If we have to handle a request condition, or have to
         add to the Info column, we need to construct a protocol
         tree.  If we already have a proto_tree, then wonderful.
         If we don't, we need to build one. */
      if ((run_info_str || run_req_cond) && !ncp_tree) {
            proto_item *ti;

            temp_tree = proto_tree_create_root();
            proto_tree_set_visible(temp_tree, FALSE);
            ti = proto_tree_add_item(temp_tree, proto_ncp, tvb, 0, -1, FALSE);
            ncp_tree = proto_item_add_subtree(ti, ett_ncp);
      }

      if (ncp_tree) {
            /* If the dissection throws an exception, be sure to free
             * the temporary proto_tree that was created. Because of the
             * way the CLEANUP_PUSH macro works, we can't put it in an 'if'
             * block; it has to be in the same scope as the terminating
             * CLEANUP_POP or CLEANUP_POP_AND_ALLOC. So, we always
             * call CLEANUP_POP and friends, but the value of temp_tree is
             * NULL if no cleanup is needed, and non-null if cleanup is needed. */
            CLEANUP_PUSH(free_proto_tree, temp_tree);

#ifdef FAKE_TREE_IS_VISIBLE
            PTREE_DATA(ncp_tree)->visible=1;
#endif

            /* Before the dissection, if we're saving data for a request
             * condition, we have to prime the proto tree using the
             * dfilter information */
            if (run_req_cond) {
                  const int   *needed;
                  dfilter_t   *dfilter;

                  needed = ncp_rec->req_cond_indexes;

                  while (*needed != -1) {
                        dfilter = req_conds[*needed].dfilter;
                        /* Prime the proto_tree with "interesting fields". */
                        dfilter_prime_proto_tree(dfilter, ncp_tree);
                        needed++;
                  }
            }

            /* Before the dissection, if we need a field for the info_str,
             * prime the tree. */
            if (run_info_str) {
                  proto_tree_prime_hfid(ncp_tree, *ncp_rec->req_info_str->hf_ptr);
            }

            switch (type) {
                        case NCP_BROADCAST_SLOT:
                        ; /* nothing */
                        break;

                  case NCP_SERVICE_REQUEST:
                        proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 1,
                              func, "Function: %u (0x%02X), %s",
                              func, func, ncp_rec ? ncp_rec->name : "Unknown");
                        break;

                  default:
                        ; /* nothing */
                        break;
            }
        if (request_value) {
            request_value->length = 0;
        }
            if (requires_subfunc) {
                  if (has_length) {
                if (request_value && func==123) {
                    request_value->length = tvb_get_ntohs(tvb, 7);
                }
                        proto_tree_add_item(ncp_tree, hf_ncp_length, tvb, 7,
                              2, FALSE);
                proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 9, 1,
                              subfunc, "SubFunction: %u (0x%02x)",
                              subfunc, subfunc);
                        ptvc = ptvcursor_new(ncp_tree, tvb, 10);
                  }
                  else {
                        proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 7, 1,
                              subfunc, "SubFunction: %u (0x%02x)",
                              subfunc, subfunc);
                        ptvc = ptvcursor_new(ncp_tree, tvb, 8);
                  }
            }
            else {
                  ptvc = ptvcursor_new(ncp_tree, tvb, 7);
            }

        /* The group is not part of the packet, but it's useful
             * information to display anyway. Put it in the tree for filtering and tap use*/
            if (ncp_rec) {
              proto_tree_add_uint_format(ncp_tree, hf_ncp_group, tvb, 0, 0, ncp_rec->group, "Group: %s", ncp_groups[ncp_rec->group]);
            }

                except_code = 0;
                message = NULL;
            if (ncp_rec && ncp_rec->request_ptvc) {
                  clear_repeat_vars();
                  /*
                   * We need to remember the results even if we
                   * throw an exception dissecting this request,
                   * so that we can properly dissect the reply.
                   * We catch any exceptions thrown when
                   * dissecting the request, and re-throw them
                   * after saving the results of any conditional
                   * tests.
                   */
                  TRY {
                        process_ptvc_record(ptvc, ncp_rec->request_ptvc, NULL, TRUE, ncp_rec);
                  } CATCH_ALL {
                        except_code = EXCEPT_CODE;
                        message = GET_MESSAGE;
                  }
                  ENDTRY;
            }
            ptvcursor_free(ptvc);
                /* SecretStore packets are dessected in packet-ncp-sss.c */
                if (func == 0x5c && ncp_tree) {
                        dissect_sss_request(tvb, pinfo, ncp_tree, request_value);
                }
                /* NMAS packets are dessected in packet-ncp-nmas.c */
                if (func == 0x5e && ncp_tree) {
                        dissect_nmas_request(tvb, pinfo, ncp_tree, request_value);
                }

            /* Now that the dissection is done, do we need to run
             * some display filters on the resulting tree in order
             * to save results for "request conditions" ? */
            if (run_req_cond) {
                  const int   *needed;
                  gboolean    *results;
                  dfilter_t   *dfilter;

                  results = g_new0(gboolean, NUM_REQ_CONDS);
                  needed = ncp_rec->req_cond_indexes;

                  while (*needed != -1) {
                        /* ncp_tree is not a root proto_tree, but
                         * dfilters will still work on it. */
                        dfilter = req_conds[*needed].dfilter;
                        results[*needed] = dfilter_apply(dfilter, ncp_tree);
                        needed++;
                  }

                  /* Save the results so the reply packet dissection
                   * get to them. */
                  request_value->req_cond_results = results;
            }
            /* Construct the info string if necessary */
            if (run_info_str) {
                  GPtrArray *parray;
                        char*   byte_string;
                        char    non_uni_string[1024];
                  int i, len;
                  field_info *finfo;
                        int info_type;
                        
                        if (!request_value)
                        {
                          conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                            PT_NCP, nw_connection, nw_connection, 0);
                          if (conversation != NULL) {
                                /* find the record telling us the request made that caused
                                this reply */
                                request_value = ncp_hash_lookup(conversation, sequence);
                                }
                                if (!conversation || !request_value)
                                {
                                        return;
                                }
                        }
                        
                  parray = proto_get_finfo_ptr_array(ncp_tree,
                        *ncp_rec->req_info_str->hf_ptr);
                  len = g_ptr_array_len(parray);
                        
                  if (len > 0) {
                        
                        col_set_str(pinfo->cinfo, COL_INFO, "C ");

                        finfo = g_ptr_array_index(parray, 0);

                                info_type = get_info_type((const gchar*) ncp_rec->req_info_str->first_string);
                                                            
                                if (info_type != 0) {    /* Is this  a string or not? */
                                       
                                        if (info_type == 1) {   /* Is this bytes? */
                                                byte_string = bytes_to_str(get_finfo_value_string(finfo), get_finfo_length(finfo));
                                                col_append_fstr(pinfo->cinfo, COL_INFO,
                                                          (const gchar*) ncp_rec->req_info_str->first_string,
                                                          byte_string);
                                        }
                                        else
                                        {
                                                if (info_type == 2) {   /* Is this a String? */
                                                        uni_to_string(get_finfo_value_string(finfo), get_finfo_length(finfo), non_uni_string);
                                                        col_append_fstr(pinfo->cinfo, COL_INFO,
                                                                (const gchar*) ncp_rec->req_info_str->first_string,
                                                                non_uni_string);
                                                }
                                                else
                                                {
                                                        col_append_fstr(pinfo->cinfo, COL_INFO,
                                                                (const gchar*) ncp_rec->req_info_str->first_string,
                                                                get_finfo_value_string(finfo));
                                                }
                                        }
                                }
                                else
                                {
                                      col_append_fstr(pinfo->cinfo, COL_INFO,
                                      (const gchar*) ncp_rec->req_info_str->first_string,
                                      get_finfo_value_integer(finfo));
                                }
                        }
                  if (len > 1) {
                        for (i = 1; i < len; i++) {
                                        non_uni_string[0]='\0';
                              finfo = g_ptr_array_index(parray, i);
                                        info_type = get_info_type((const gchar*) ncp_rec->req_info_str->repeat_string);
                                                                    
                                        if (info_type != 0) {    /* Is this  a string or not? */
                                              if (info_type == 1) 
                                              {   /* Is this bytes? */
                                                byte_string = bytes_to_str(get_finfo_value_string(finfo), get_finfo_length(finfo));
                                                col_append_fstr(pinfo->cinfo, COL_INFO,
                                                          (const gchar*) ncp_rec->req_info_str->repeat_string,
                                                          byte_string);
                                              }
                                              else
                                              {
                                                        if (info_type == 2) {   /* Is this a String? */
                                                                uni_to_string(get_finfo_value_string(finfo), get_finfo_length(finfo), non_uni_string);
                                                                col_append_fstr(pinfo->cinfo, COL_INFO,
                                                                            (const gchar*) ncp_rec->req_info_str->repeat_string,
                                                                            non_uni_string);
                                                        }
                                                        else
                                                        {
                                                                col_append_fstr(pinfo->cinfo, COL_INFO,
                                                                            (const gchar*) ncp_rec->req_info_str->repeat_string,
                                                                            get_finfo_value_string(finfo));
                                                        }
                                              }
                                        }
                                        else
                                        {
                                            col_append_fstr(pinfo->cinfo, COL_INFO,
                                                  (const gchar*) ncp_rec->req_info_str->repeat_string,
                                            get_finfo_value_integer(finfo));
                                        }
                                }
                  }
            }
        /* Store NCP request specific flags for manual dissection */
        if ((func == 0x57 || func == 0x59) && subfunc == 0x14 && ncp_tree && request_value) {
            char ret_info_string[16];
            char ret_info_string_ext[16];
            
            build_expert_data(ncp_tree, "ncp.ret_info_mask", ret_info_string, 0, FALSE);
            request_value->req_mask = atoi(ret_info_string);
            build_expert_data(ncp_tree, "ncp.ext_info", ret_info_string_ext, 0, FALSE);
            request_value->req_mask_ext = atoi(ret_info_string_ext);
        }
        /* Check to see if we need to report to the expert table */
        trap_for_expert_event(ncp_tree, pinfo, ncp_rec, 0);
            /* Free the temporary proto_tree */
            CLEANUP_CALL_AND_POP;

            /* Re-throw any exception. */
            if (except_code != 0)
                  THROW_MESSAGE(except_code, message);
      }
}

static void
dissect_nds_ping_reply(tvbuff_t *tvb, packet_info *pinfo _U_,
      proto_tree *ncp_tree, ncp_req_hash_value *request_value)
{
        nw_uni_t                        reply_buffer;
        guint8                          ping_version;
        guint32                         nds_string_len;
        guint32                         nds_offset;
        guint32                         bvalue;
        guint32                         nds_flags;
      nds_val                       pvalues[9];
      int                     i;

      strcpy(reply_buffer.buffer, "");

        ping_version = tvb_get_guint8(tvb, 8);
        proto_tree_add_item(ncp_tree, hf_ping_version, tvb, 8, 1, TRUE);
        if (ping_version == 9) {
                nds_string_len = tvb_get_ntohl(tvb, 9);
                nds_offset = nds_string_len+16;
                tvb_ensure_bytes_exist(tvb, 16, nds_string_len);
                proto_tree_add_item(ncp_tree, hf_nds_tree_name, tvb, 16, nds_string_len, FALSE);
                proto_tree_add_item(ncp_tree, hf_nds_reply_depth, tvb, nds_offset, 4, FALSE);
                proto_tree_add_item(ncp_tree, hf_nds_reply_rev, tvb, (nds_offset+4), 4, FALSE);
                proto_tree_add_item(ncp_tree, hf_nds_reply_flags, tvb, (nds_offset+8), 4, TRUE);
        }
        else {
                nds_offset = 12;
                nds_flags = request_value->req_nds_flags;
                bvalue = 0x00000001;
                                          
                for (i = 0 ; i < 32; i++ ) {
                        if (nds_flags & bvalue) 
                        {
                                switch(bvalue)
                                {
                                        case 0x00000001:   /* Supported Fields */
                                                pvalues[0].vvalue = tvb_get_letohs(tvb, nds_offset);
                                                pvalues[0].vtype = VTYPE_BITFIELD;
                                                pvalues[0].vstring = "";
                                                pvalues[0].vdesc = "Ping (low) Supported Fields:";
                                                pvalues[0].vlength = 2;
                                                pvalues[0].hfname= hf_nds_rflags;
                                                pvalues[0].voffset = nds_offset;
                                                pvalues[0].bit1 = "Supported Fields";
                                                pvalues[0].bit1hfname = hf_bit1pingflags1;
                                                pvalues[0].bit2 = "Depth";
                                                pvalues[0].bit2hfname = hf_bit2pingflags1;
                                                pvalues[0].bit3 = "Revision";
                                                pvalues[0].bit3hfname = hf_bit3pingflags1;
                                                pvalues[0].bit4 = "Flags";
                                                pvalues[0].bit4hfname = hf_bit4pingflags1;
                                                pvalues[0].bit5 = "Verification Flags";
                                                pvalues[0].bit5hfname = hf_bit5pingflags1;
                                                pvalues[0].bit6 = "Letter Version";
                                                pvalues[0].bit6hfname = hf_bit6pingflags1;
                                                pvalues[0].bit7 = "OS Version";
                                                pvalues[0].bit7hfname = hf_bit7pingflags1;
                                                pvalues[0].bit8 = "License Flags";
                                                pvalues[0].bit8hfname = hf_bit8pingflags1;
                                                pvalues[0].bit9 = "DS Time";
                                                pvalues[0].bit9hfname = hf_bit9pingflags1;
                                                pvalues[0].bit10 = "Not Defined";
                                                pvalues[0].bit10hfname = hf_bit10pingflags1;
                                                pvalues[0].bit11 = "Not Defined";
                                                pvalues[0].bit11hfname = hf_bit11pingflags1;
                                                pvalues[0].bit12 = "Not Defined";
                                                pvalues[0].bit12hfname = hf_bit12pingflags1;
                                                pvalues[0].bit13 = "Not Defined";
                                                pvalues[0].bit13hfname = hf_bit13pingflags1;
                                                pvalues[0].bit14 = "Not Defined";
                                                pvalues[0].bit14hfname = hf_bit14pingflags1;
                                                pvalues[0].bit15 = "Not Defined";
                                                pvalues[0].bit15hfname = hf_bit15pingflags1;
                                                pvalues[0].bit16 = "Not Defined";
                                                pvalues[0].bit16hfname = hf_bit16pingflags1;
                                                                        
                                                process_bitfield(ncp_tree, tvb, &pvalues[0]);
                                                nds_offset += 2;
                                                                        
                                                pvalues[0].vvalue = tvb_get_letohs(tvb, nds_offset);
                                                pvalues[0].vtype = VTYPE_BITFIELD;
                                                pvalues[0].vstring = "";
                                                pvalues[0].vdesc = "Ping (high) Supported Fields:";
                                                pvalues[0].vlength = 2;
                                                pvalues[0].hfname= hf_nds_rflags;
                                                pvalues[0].voffset = nds_offset;
                                                pvalues[0].bit1 = "Sap Name";
                                                pvalues[0].bit1hfname = hf_bit1pingflags2;
                                                pvalues[0].bit2 = "Tree Name";
                                                pvalues[0].bit2hfname = hf_bit2pingflags2;
                                                pvalues[0].bit3 = "OS Name";
                                                pvalues[0].bit3hfname = hf_bit3pingflags2;
                                                pvalues[0].bit4 = "Hardware Name";
                                                pvalues[0].bit4hfname = hf_bit4pingflags2;
                                                pvalues[0].bit5 = "Vendor Name";
                                                pvalues[0].bit5hfname = hf_bit5pingflags2;
                                                pvalues[0].bit6 = "Not Defined";
                                                pvalues[0].bit6hfname = hf_bit6pingflags2;
                                                pvalues[0].bit7 = "Not Defined";
                                                pvalues[0].bit7hfname = hf_bit7pingflags2;
                                                pvalues[0].bit8 = "Not Defined";
                                                pvalues[0].bit8hfname = hf_bit8pingflags2;
                                                pvalues[0].bit9 = "Not Defined";
                                                pvalues[0].bit9hfname = hf_bit9pingflags2;
                                                pvalues[0].bit10 = "Not Defined";
                                                pvalues[0].bit10hfname = hf_bit10pingflags2;
                                                pvalues[0].bit11 = "Not Defined";
                                                pvalues[0].bit11hfname = hf_bit11pingflags2;
                                                pvalues[0].bit12 = "Not Defined";
                                                pvalues[0].bit12hfname = hf_bit12pingflags2;
                                                pvalues[0].bit13 = "Not Defined";
                                                pvalues[0].bit13hfname = hf_bit13pingflags2;
                                                pvalues[0].bit14 = "Not Defined";
                                                pvalues[0].bit14hfname = hf_bit14pingflags2;
                                                pvalues[0].bit15 = "Not Defined";
                                                pvalues[0].bit15hfname = hf_bit15pingflags2;
                                                pvalues[0].bit16 = "Not Defined";
                                                pvalues[0].bit16hfname = hf_bit16pingflags2;
                                                                        
                                                process_bitfield(ncp_tree, tvb, &pvalues[0]);
                                                nds_offset += 2;
                                                break;
                                        case 0x00000002:
                                                proto_tree_add_item(ncp_tree, hf_nds_reply_depth, tvb, nds_offset, 4, TRUE);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000004:
                                                proto_tree_add_item(ncp_tree, hf_nds_reply_rev, tvb, nds_offset, 4, TRUE);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000008:
                                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                pvalues[0].vtype = VTYPE_BITFIELD;
                                                pvalues[0].vstring = "";
                                                pvalues[0].vdesc = "Ping Flags:";
                                                pvalues[0].vlength = 4;
                                                pvalues[0].hfname= hf_nds_rflags;
                                                pvalues[0].voffset = nds_offset;
                                                pvalues[0].bit1 = "Root Most Master Replica";
                                                pvalues[0].bit1hfname = hf_bit1pingpflags1;
                                                pvalues[0].bit2 = "Time Synchronized";
                                                pvalues[0].bit2hfname = hf_bit2pingpflags1;
                                                pvalues[0].bit3 = "Not Defined";
                                                pvalues[0].bit3hfname = hf_bit3pingpflags1;
                                                pvalues[0].bit4 = "Not Defined";
                                                pvalues[0].bit4hfname = hf_bit4pingpflags1;
                                                pvalues[0].bit5 = "Not Defined";
                                                pvalues[0].bit5hfname = hf_bit5pingpflags1;
                                                pvalues[0].bit6 = "Not Defined";
                                                pvalues[0].bit6hfname = hf_bit6pingpflags1;
                                                pvalues[0].bit7 = "Not Defined";
                                                pvalues[0].bit7hfname = hf_bit7pingpflags1;
                                                pvalues[0].bit8 = "Not Defined";
                                                pvalues[0].bit8hfname = hf_bit8pingpflags1;
                                                pvalues[0].bit9 = "Not Defined";
                                                pvalues[0].bit9hfname = hf_bit9pingpflags1;
                                                pvalues[0].bit10 = "Not Defined";
                                                pvalues[0].bit10hfname = hf_bit10pingpflags1;
                                                pvalues[0].bit11 = "Not Defined";
                                                pvalues[0].bit11hfname = hf_bit11pingpflags1;
                                                pvalues[0].bit12 = "Not Defined";
                                                pvalues[0].bit12hfname = hf_bit12pingpflags1;
                                                pvalues[0].bit13 = "Not Defined";
                                                pvalues[0].bit13hfname = hf_bit13pingpflags1;
                                                pvalues[0].bit14 = "Not Defined";
                                                pvalues[0].bit14hfname = hf_bit14pingpflags1;
                                                pvalues[0].bit15 = "Not Defined";
                                                pvalues[0].bit15hfname = hf_bit15pingpflags1;
                                                pvalues[0].bit16 = "Not Defined";
                                                pvalues[0].bit16hfname = hf_bit16pingpflags1;
                                                                        
                                                process_bitfield(ncp_tree, tvb, &pvalues[0]);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000010:
                                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                pvalues[0].vtype = VTYPE_BITFIELD;
                                                pvalues[0].vstring = "";
                                                pvalues[0].vdesc = "Verification Flags:";
                                                pvalues[0].vlength = 4;
                                                pvalues[0].hfname= hf_nds_rflags;
                                                pvalues[0].voffset = nds_offset;
                                                pvalues[0].bit1 = "Checksum";
                                                pvalues[0].bit1hfname = hf_bit1pingvflags1;
                                                pvalues[0].bit2 = "CRC32";
                                                pvalues[0].bit2hfname = hf_bit2pingvflags1;
                                                pvalues[0].bit3 = "Not Defined";
                                                pvalues[0].bit3hfname = hf_bit3pingvflags1;
                                                pvalues[0].bit4 = "Not Defined";
                                                pvalues[0].bit4hfname = hf_bit4pingvflags1;
                                                pvalues[0].bit5 = "Not Defined";
                                                pvalues[0].bit5hfname = hf_bit5pingvflags1;
                                                pvalues[0].bit6 = "Not Defined";
                                                pvalues[0].bit6hfname = hf_bit6pingvflags1;
                                                pvalues[0].bit7 = "Not Defined";
                                                pvalues[0].bit7hfname = hf_bit7pingvflags1;
                                                pvalues[0].bit8 = "Not Defined";
                                                pvalues[0].bit8hfname = hf_bit8pingvflags1;
                                                pvalues[0].bit9 = "Not Defined";
                                                pvalues[0].bit9hfname = hf_bit9pingvflags1;
                                                pvalues[0].bit10 = "Not Defined";
                                                pvalues[0].bit10hfname = hf_bit10pingvflags1;
                                                pvalues[0].bit11 = "Not Defined";
                                                pvalues[0].bit11hfname = hf_bit11pingvflags1;
                                                pvalues[0].bit12 = "Not Defined";
                                                pvalues[0].bit12hfname = hf_bit12pingvflags1;
                                                pvalues[0].bit13 = "Not Defined";
                                                pvalues[0].bit13hfname = hf_bit13pingvflags1;
                                                pvalues[0].bit14 = "Not Defined";
                                                pvalues[0].bit14hfname = hf_bit14pingvflags1;
                                                pvalues[0].bit15 = "Not Defined";
                                                pvalues[0].bit15hfname = hf_bit15pingvflags1;
                                                pvalues[0].bit16 = "Not Defined";
                                                pvalues[0].bit16hfname = hf_bit16pingvflags1;
                                                                        
                                                process_bitfield(ncp_tree, tvb, &pvalues[0]);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000020:
                                                proto_tree_add_item(ncp_tree, hf_nds_letter_ver, tvb, nds_offset, 4, TRUE);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000040:
                                                proto_tree_add_item(ncp_tree, hf_nds_os_ver, tvb, nds_offset, 4, TRUE);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000080:
                                                proto_tree_add_item(ncp_tree, hf_nds_lic_flags, tvb, nds_offset, 4, TRUE);
                                                nds_offset += 4;
                                                break;
                                        case 0x00000100:
                                                proto_tree_add_item(ncp_tree, hf_nds_ds_time, tvb, nds_offset, 4, TRUE);
                                                nds_offset += 4;
                                                break;
                                        case 0x00010000:
                                                nds_string_len = tvb_get_letohl(tvb, nds_offset);
                                                nds_offset += 4;
                                                get_string(tvb, nds_offset, nds_string_len, reply_buffer.buffer);
                                                tvb_ensure_bytes_exist(tvb, nds_offset, nds_string_len);
                                                proto_tree_add_text(ncp_tree, tvb, nds_offset, nds_string_len, "SAP Name: %s", reply_buffer.buffer);
                                                nds_offset += nds_string_len;
                                                nds_offset += align_4(tvb, nds_offset);
                                                nds_offset += 2;
                                                break;
                                        case 0x00020000:
                                                nds_string_len = tvb_get_letohl(tvb, nds_offset);
                                                nds_offset += 4;
                                                get_string(tvb, nds_offset, nds_string_len, reply_buffer.buffer);
                                                tvb_ensure_bytes_exist(tvb, nds_offset, nds_string_len);
                                                proto_tree_add_text(ncp_tree, tvb, nds_offset, nds_string_len, "NDS Tree Name: %s", reply_buffer.buffer);
                                                nds_offset += nds_string_len;
                                                nds_offset += align_4(tvb, nds_offset);
                                                break;
                                        case 0x00040000:
                                                nds_string_len = tvb_get_letohl(tvb, nds_offset);
                                                nds_offset += 4;
                                                get_string(tvb, nds_offset, nds_string_len, reply_buffer.buffer);
                                                tvb_ensure_bytes_exist(tvb, nds_offset, nds_string_len);
                                                proto_tree_add_text(ncp_tree, tvb, nds_offset, nds_string_len, "OS Name: %s", reply_buffer.buffer);
                                                nds_offset += nds_string_len;
                                                nds_offset += align_4(tvb, nds_offset);
                                                break;
                                        case 0x00080000:
                                                nds_string_len = tvb_get_letohl(tvb, nds_offset);
                                                nds_offset += 4;
                                                get_string(tvb, nds_offset, nds_string_len, reply_buffer.buffer);
                                                tvb_ensure_bytes_exist(tvb, nds_offset, nds_string_len);
                                                proto_tree_add_text(ncp_tree, tvb, nds_offset, nds_string_len, "Hardware Name: %s", reply_buffer.buffer);
                                                nds_offset += nds_string_len;
                                                nds_offset += align_4(tvb, nds_offset);
                                                break;
                                        case 0x00100000:
                                                nds_string_len = tvb_get_letohl(tvb, nds_offset);
                                                nds_offset += 4;
                                                get_string(tvb, nds_offset, nds_string_len, reply_buffer.buffer);
                                                tvb_ensure_bytes_exist(tvb, nds_offset, nds_string_len);
                                                proto_tree_add_text(ncp_tree, tvb, nds_offset, nds_string_len, "Vendor Name: %s", reply_buffer.buffer);
                                                nds_offset += nds_string_len;
                                                nds_offset += align_4(tvb, nds_offset);
                                                break;
                                        case 0x00000200:
                                                /* Not Defined */
                                        case 0x00000400:
                                                /* Not Defined */
                                        case 0x00000800:
                                                /* Not Defined */
                                        case 0x00001000:
                                                /* Not Defined */
                                        case 0x00002000:
                                                /* Not Defined */
                                        case 0x00004000:
                                                /* Not Defined */
                                        case 0x00008000:
                                                /* Not Defined */
                                        case 0x00200000:
                                                /* Not Defined */
                                        case 0x00400000:
                                                /* Not Defined */
                                        case 0x00800000:
                                                /* Not Defined */
                                        case 0x01000000:
                                                /* Not Defined */
                                        case 0x02000000:
                                                /* Not Defined */
                                        case 0x04000000:
                                                /* Not Defined */
                                        case 0x08000000:
                                                /* Not Defined */
                                        case 0x10000000:
                                                /* Not Defined */
                                        case 0x20000000:
                                                /* Not Defined */
                                        case 0x40000000:
                                                /* Not Defined */
                                        case 0x80000000:
                                                /* Not Defined */
                                        default:
                                                break;
                                }
                        }
                        bvalue = bvalue*2;
                }
        }
}

static void
dissect_nds_reply(tvbuff_t *tvb, packet_info *pinfo,
      proto_tree *ncp_tree, guint32 nds_error_code,
        const char *nds_error_string, ncp_req_hash_value *request_value,
        conversation_t *conversation)
{
        guint32                         nds_offset;
        guint32                         nds_reply_buffer;
        guint32                         nds_frag;
        const char                      *verb_string;
      nds_val                       pvalues[9];
      char                    string_buffer[9][1024];
        gboolean                        resolve_eid=FALSE;
        guint32                         global_eid=0;
        gboolean                        add_eid = FALSE;
        char                            global_object_name[256];
      ncp_req_eid_hash_value        *request_eid_value = NULL;
      int                     i;

      strcpy(global_object_name, "");

        nds_offset = 8;
                                        
        nds_reply_buffer = tvb_get_letohl(tvb, nds_offset);
        proto_tree_add_uint(ncp_tree, hf_ncp_fragment_size, tvb, nds_offset,
                4, nds_reply_buffer);
        nds_offset += 4;
        nds_frag = tvb_get_letohl(tvb, nds_offset);        
        proto_tree_add_uint(ncp_tree, hf_ncp_fragment_handle, tvb, nds_offset,
                4, nds_frag);
        nds_offset += 4;        
        /*
         * Is the possibly-reassembled reply large enough to have a completion
         * code?  (We can't check the fragment size as this might just be the
         * last fragment.)
         */
        if (tvb_reported_length_remaining(tvb, nds_offset) >= 4)
        {                        
                /* Yes - process the completion code. */
                expert_item = proto_tree_add_uint_format(ncp_tree, hf_nds_reply_error, tvb, nds_offset,
                        4, nds_error_code, "NDS Completion Code: 0x%08x, %s",
                        nds_error_code, nds_error_string);

                if (nds_error_code != 0 && ncp_echo_err) {
                        expert_add_info_format(pinfo, expert_item, PI_RESPONSE_CODE, PI_ERROR, "NDS Error: 0x%08x %s", nds_error_code, nds_error_string);
                }
        }
        if (request_value && nds_error_code == 0x00000000)
        {
                nds_offset = 20;
                for (i = 0; i < 9; i++) {
                  pvalues[i].vtype = 0;
                  pvalues[i].vvalue = 0;
                  pvalues[i].vlength = 0;
                  pvalues[i].voffset = 0;
                  pvalues[i].hfname = 0;
                  pvalues[i].vdesc = "";
                  string_buffer[i][0] = '\0';
                  pvalues[i].vstring = string_buffer[i];
                  pvalues[i].mvtype = 0;
            }
                verb_string = val_to_str(request_value->nds_request_verb,
                    ncp_nds_verb_vals, "Continuation Fragment");
                switch (request_value->nds_request_verb)
                {
                        case 0x01:
                                if(request_value->nds_version < 2)
                                { 
                                        pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[0].vstring = (char *)match_strval(pvalues[0].vvalue, nds_tags);
                                        if(pvalues[0].vstring == NULL)
                                        {
                                                pvalues[0].vstring = "No Tags Set";
                                        }
                                        pvalues[0].vtype = VTYPE_STRING;
                                        pvalues[0].vdesc = "Tag: %s";
                                        pvalues[0].vlength = 4;
                                        pvalues[0].voffset = nds_offset;
                                        pvalues[0].hfname = hf_nds_tag_string;
                                        nds_offset = nds_offset+pvalues[0].vlength;
                                        switch(pvalues[0].vvalue)
                                        {
                                                case NDS_TAG_NO_SUCH_ENTRY:
                                                        break;
                                                case NDS_TAG_LOCAL_ENTRY:
                                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[1].vtype = VTYPE_UINT32;
                                                        pvalues[1].vdesc = "Entry ID: 0x%08x";
                                                        add_eid = TRUE;
                                                        resolve_eid = TRUE;
                                                        strcpy(global_object_name, request_value->object_name);
                                                        global_eid = pvalues[1].vvalue;
                                                        pvalues[1].vlength = 4;
                                                        pvalues[1].voffset = nds_offset;
                                                        pvalues[1].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[1].vlength;
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[2].vdesc = "Referral Records: %u";
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_referrals;
                                                        pvalues[2].mvtype = MVTYPE_LOC_ADDR_REFERRAL_REPLY;
                                                        break;
                                                case NDS_TAG_REMOTE_ENTRY:
                                                        nds_offset += 4;   /* GUINT32 reserved field */
                                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[1].vtype = VTYPE_UINT32;
                                                        pvalues[1].vdesc = "Entry ID: 0x%08x";
                                                        /*add_eid = TRUE;
                                                        resolve_eid = TRUE;
                                                        global_eid = pvalues[1].vvalue;
                                                        strcpy(global_object_name, request_value->object_name);*/
                                                        pvalues[1].vlength = 4;
                                                        pvalues[1].voffset = nds_offset;
                                                        pvalues[1].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[1].vlength;
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[2].vdesc = "Referral Records: %u";
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_referrals;
                                                        pvalues[2].mvtype = MVTYPE_LOC_ADDR_REFERRAL_REPLY;
                                                        break;
                                                case NDS_TAG_ALIAS_ENTRY:
                                                        pvalues[1].vtype = VTYPE_STRING;
                                                        pvalues[1].vdesc = "Alias Name: %s";
                                                        pvalues[1].mvtype = MVTYPE_ATTR_REQUEST;
                                                        pvalues[1].vvalue = 0;
                                                        pvalues[1].vlength = 256;
                                                        pvalues[1].vlength = tvb_get_letohl(tvb, nds_offset);
                                                        if (pvalues[1].vlength == 0x00)
                                                        {
                                                                pvalues[1].vtype = VTYPE_NONE;
                                                                break;
                                                        }
                                                        pvalues[1].voffset = nds_offset+4;
                                                        nds_offset += 4;
                                                        get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, pvalues[1].vstring);
                                                        nds_offset += pvalues[1].vlength;
                                                        nds_offset += align_4(tvb, nds_offset);
                                                        pvalues[1].hfname= hf_nds_name;
                                                        break;
                                                case NDS_TAG_REFERRAL_INFORMATION:
                                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[1].vtype = VTYPE_UINT32;
                                                        pvalues[1].vdesc = "Distance Object is From Root: 0x%08x";
                                                        pvalues[1].vlength = 4;
                                                        pvalues[1].voffset = nds_offset;
                                                        pvalues[1].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[1].vlength;
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[2].vdesc = "Referral Records: %u";
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_depth;
                                                        pvalues[2].mvtype = MVTYPE_ADDR_REFERRAL_REPLY;
                                                        break;
                                                case NDS_TAG_ENTRY_AND_REFERRALS:
                                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[1].vtype = VTYPE_UINT32;
                                                        pvalues[1].vdesc = "Result Flags: 0x%08x";
                                                        pvalues[1].vlength = 4;
                                                        pvalues[1].voffset = nds_offset;
                                                        pvalues[1].hfname = hf_nds_result_flags;
                                                        nds_offset = nds_offset+pvalues[1].vlength;
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_UINT32;
                                                        pvalues[2].vdesc = "Entry ID: 0x%08x";
                                                        add_eid = TRUE;
                                                        resolve_eid = TRUE;
                                                        global_eid = pvalues[2].vvalue;
                                                        strcpy(global_object_name, request_value->object_name);
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[2].vlength;
                                                        pvalues[3].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[3].vdesc = "Referral Records: %u";
                                                        pvalues[3].vlength = 4;
                                                        pvalues[3].voffset = nds_offset;
                                                        pvalues[3].mvtype = MVTYPE_ADDR_REFERRAL_REPLY;
                                                        pvalues[3].hfname = hf_nds_referrals;
                                                        break;
                                                default:
                                                        break;
                                        }
                                }
                                else
                                {
                                        pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[0].vtype = VTYPE_UINT32;
                                        pvalues[0].vdesc = "CRC: 0x%08x";
                                        pvalues[0].vlength = 4;
                                        pvalues[0].voffset = nds_offset;
                                        pvalues[0].hfname = hf_nds_crc;
                                        nds_offset = nds_offset+pvalues[0].vlength;
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[1].vstring = (char *)match_strval(pvalues[1].vvalue, nds_tags);
                                        if(pvalues[1].vstring == NULL)
                                        {
                                                pvalues[1].vstring = "No Tags Set";
                                        }
                                        pvalues[1].vtype = VTYPE_STRING;
                                        pvalues[1].vdesc = "Tag: %s";
                                        pvalues[1].vlength = 4;
                                        pvalues[1].voffset = nds_offset;
                                        nds_offset = nds_offset+pvalues[1].vlength;
                                        pvalues[1].hfname = hf_nds_tag_string;
                                        switch(pvalues[1].vvalue)
                                        {
                                                case NDS_TAG_NO_SUCH_ENTRY:
                                                        break;
                                                case NDS_TAG_LOCAL_ENTRY:
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_UINT32;
                                                        pvalues[2].vdesc = "Entry ID: 0x%08x";
                                                        add_eid = TRUE;
                                                        resolve_eid = TRUE;
                                                        global_eid = pvalues[2].vvalue;
                                                        strcpy(global_object_name, request_value->object_name);
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[2].vlength;
                                                        pvalues[3].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[3].vdesc = "Referral Records: %u";
                                                        pvalues[3].vlength = 4;
                                                        pvalues[3].voffset = nds_offset;
                                                        pvalues[3].hfname = hf_nds_referrals;
                                                        pvalues[3].mvtype = MVTYPE_LOC_ADDR_REFERRAL_REPLY;
                                                        break;
                                                case NDS_TAG_REMOTE_ENTRY:
                                                        nds_offset += 4;   /* GUINT32 reserved field */
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        add_eid = TRUE;
                                                        resolve_eid = TRUE;
                                                        global_eid = pvalues[2].vvalue;
                                                        strcpy(global_object_name, request_value->object_name);
                                                        pvalues[2].vtype = VTYPE_UINT32;
                                                        pvalues[2].vdesc = "Entry ID: 0x%08x";
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[2].vlength;
                                                        pvalues[3].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[3].vdesc = "Referral Records: %u";
                                                        pvalues[3].vlength = 4;
                                                        pvalues[3].voffset = nds_offset;
                                                        pvalues[3].hfname = hf_nds_referrals;
                                                        pvalues[3].mvtype = MVTYPE_LOC_ADDR_REFERRAL_REPLY;
                                                        break;
                                                case NDS_TAG_ALIAS_ENTRY:
                                                        pvalues[2].vtype = VTYPE_STRING;
                                                        pvalues[2].vdesc = "Alias Name: %s";
                                                        pvalues[2].mvtype = MVTYPE_ATTR_REQUEST;
                                                        pvalues[2].vvalue = 0;
                                                        pvalues[2].vlength = 256;
                                                        pvalues[2].vlength = tvb_get_letohl(tvb, nds_offset);
                                                        if (pvalues[2].vlength == 0x00)
                                                        {
                                                                pvalues[2].vtype = VTYPE_NONE;
                                                                break;
                                                        }
                                                        pvalues[2].voffset = nds_offset+4;
                                                        nds_offset += 4;
                                                        get_string(tvb, pvalues[2].voffset, pvalues[2].vlength, pvalues[2].vstring);
                                                        nds_offset += pvalues[2].vlength;
                                                        nds_offset += align_4(tvb, nds_offset);
                                                        pvalues[2].hfname= hf_nds_name;
                                                        break;
                                                case NDS_TAG_REFERRAL_INFORMATION:
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_UINT32;
                                                        pvalues[2].vdesc = "Distance Object is From Root: 0x%08x";
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[2].vlength;
                                                        pvalues[3].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[3].vdesc = "Referral Records: %u";
                                                        pvalues[3].vlength = 4;
                                                        pvalues[3].voffset = nds_offset;
                                                        pvalues[3].hfname = hf_nds_depth;
                                                        pvalues[3].mvtype = MVTYPE_ADDR_REFERRAL_REPLY;
                                                        break;
                                                case NDS_TAG_ENTRY_AND_REFERRALS:
                                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[2].vtype = VTYPE_UINT32;
                                                        pvalues[2].vdesc = "Result Flags: 0x%08x";
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = nds_offset;
                                                        pvalues[2].hfname = hf_nds_result_flags;
                                                        nds_offset = nds_offset+pvalues[2].vlength;
                                                        pvalues[3].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[3].vtype = VTYPE_UINT32;
                                                        pvalues[3].vdesc = "Entry ID: 0x%08x";
                                                        add_eid = TRUE;
                                                        resolve_eid = TRUE;
                                                        strcpy(global_object_name, request_value->object_name);
                                                        global_eid = pvalues[3].vvalue;
                                                        pvalues[3].vlength = 4;
                                                        pvalues[3].voffset = nds_offset;
                                                        pvalues[3].hfname = hf_nds_eid;
                                                        nds_offset = nds_offset+pvalues[3].vlength;
                                                        pvalues[4].vvalue = tvb_get_letohl(tvb, nds_offset);
                                                        pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32;
                                                        pvalues[4].vdesc = "Referral Records: %u";
                                                        pvalues[4].vlength = 4;
                                                        pvalues[4].voffset = nds_offset;
                                                        pvalues[4].mvtype = MVTYPE_ADDR_REFERRAL_REPLY;
                                                        pvalues[4].hfname = hf_nds_referrals;
                                                        break;
                                                default:
                                                        break;
                                        }
                                                                
                                }
                                break;
                        case 0x02:    
                                if(request_value->nds_version != 0x000000fe)
                                { 
                                        pvalues[0].vvalue = 1;
                                        pvalues[0].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[0].vdesc = "Entry Information";
                                        pvalues[0].vlength = 0;
                                        pvalues[0].voffset = nds_offset-4;
                                        pvalues[0].hfname = hf_nds_name;
                                        pvalues[0].mvtype = MVTYPE_LIST_PARTITIONS;
                                        pvalues[0].vflags = request_value->req_nds_flags;
                                }
                                else
                                {
                                        pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[0].vtype = VTYPE_UINT32;
                                        pvalues[0].vdesc = "CRC: 0x%08x";
                                        pvalues[0].vlength = 4;
                                        pvalues[0].voffset = nds_offset;
                                        pvalues[0].hfname = hf_nds_crc;
                                        nds_offset = nds_offset+pvalues[0].vlength;
                                        pvalues[1].vvalue = 1;
                                        pvalues[1].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[1].vdesc = "Entry Information";
                                        pvalues[1].vlength = 0;
                                        pvalues[1].voffset = nds_offset-4;
                                        pvalues[1].hfname = hf_nds_name;
                                        pvalues[1].mvtype = MVTYPE_LIST_PARTITIONS;
                                        pvalues[1].vflags = request_value->req_nds_flags;
                                }
                                break;
                        case 0x03:    
                                if(request_value->nds_version != 0x000000fe)
                                { 
                                        pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[0].vtype = VTYPE_UINT32;
                                        pvalues[0].vdesc = "Iteration Handle: 0x%08x";
                                        pvalues[0].vlength = 4;
                                        pvalues[0].voffset = nds_offset;
                                        pvalues[0].hfname = hf_nds_iteration;
                                        nds_offset = nds_offset+pvalues[0].vlength;
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[1].vstring = (char *)match_strval(pvalues[1].vvalue, nds_info_type);
                                        if(pvalues[1].vstring == NULL)
                                        {
                                                pvalues[1].vstring = "No Info Type Set";
                                        }
                                        pvalues[1].vtype = VTYPE_STRING;
                                        pvalues[1].vdesc = "Info Type: %s";
                                        pvalues[1].vlength = 4;
                                        pvalues[1].voffset = nds_offset;
                                        pvalues[1].hfname = hf_nds_info_type;
                                        nds_offset = nds_offset+pvalues[1].vlength;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[2].vdesc = "Number of Attributes: %u";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = nds_offset;
                                        pvalues[2].hfname = hf_nds_attr;
                                        pvalues[2].mvtype = MVTYPE_ATTR_REPLY;
                                        pvalues[2].vflags = request_value->req_nds_flags;
                                        pvalues[2].nds_version = request_value->nds_version;
                                }
                                else
                                {
                                        pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[0].vtype = VTYPE_UINT32;
                                        pvalues[0].vdesc = "CRC: 0x%08x";
                                        pvalues[0].vlength = 4;
                                        pvalues[0].voffset = nds_offset;
                                        pvalues[0].hfname = hf_nds_crc;
                                        nds_offset = nds_offset+pvalues[0].vlength;
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[1].vtype = VTYPE_UINT32;
                                        pvalues[1].vdesc = "Iteration Handle: 0x%08x";
                                        pvalues[1].vlength = 4;
                                        pvalues[1].voffset = nds_offset;
                                        pvalues[1].hfname = hf_nds_iteration;
                                        nds_offset = nds_offset+pvalues[1].vlength;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[2].vstring = (char *)match_strval(pvalues[2].vvalue, nds_info_type);
                                        if(pvalues[2].vstring == NULL)
                                        {
                                                pvalues[2].vstring = "No Info Type Set";
                                        }
                                        pvalues[2].vtype = VTYPE_STRING;
                                        pvalues[2].vdesc = "Info Type: %s";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = nds_offset;
                                        pvalues[2].hfname = hf_nds_info_type;
                                        nds_offset = nds_offset+pvalues[2].vlength;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[3].vdesc = "Number of Attributes: %u";
                                        pvalues[3].vlength = 4;
                                        pvalues[3].voffset = nds_offset;
                                        pvalues[3].hfname = hf_nds_attr;
                                        pvalues[3].mvtype = MVTYPE_ATTR_REPLY;
                                        pvalues[3].vflags = request_value->req_nds_flags;
                                        pvalues[3].nds_version = request_value->nds_version;
                                }
                                break;
                        case 0x04:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                if (pvalues[0].vvalue == 0x00000000)
                                {
                                        pvalues[0].vstring = "Did Not Match";
                                }        
                                else
                                {
                                        pvalues[0].vstring = "Matched";
                                }
                                pvalues[0].vtype = VTYPE_STRING;
                                pvalues[0].vdesc = "Compare Values Returned - %s";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].mvtype = 0;
                                pvalues[0].hfname= hf_nds_compare_results;
                                nds_offset += pvalues[0].vlength;
                                break;
                        case 0x05:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].hfname = hf_nds_iteration;
                                nds_offset = nds_offset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[1].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[1].vdesc = "Entry Information";
                                pvalues[1].vlength = 0;
                                pvalues[1].voffset = nds_offset;
                                pvalues[1].hfname = hf_nds_name;
                                pvalues[1].mvtype = MVTYPE_LIST_PARTITIONS;
                                pvalues[1].vflags = request_value->req_nds_flags;
                                break;
                        case 0x06:    
                                break;
                        case 0x07:    
                                break;
                        case 0x08:    
                                break;
                        case 0x09:    
                                break;
                        case 0x0a:    
                                break;
                        case 0x0b:    
                                break;
                        case 0x0c:    
                                break;
                        case 0x0d:    
                                break;
                        case 0x0e:    
                                break;
                        case 0x0f:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].hfname = hf_nds_iteration;
                                nds_offset = nds_offset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[1].vstring = (char *)match_strval(pvalues[1].vvalue, class_def_type);
                                if(pvalues[1].vstring == NULL)
                                {
                                        pvalues[1].vstring = "No Class Definition Type Set";
                                }
                                pvalues[1].vtype = VTYPE_STRING;
                                pvalues[1].vdesc = "Class Definition Type: %s";
                                pvalues[1].vlength = 4;
                                pvalues[1].voffset = nds_offset;
                                pvalues[1].mvtype = 0;
                                pvalues[1].hfname= hf_nds_class_def_type;
                                nds_offset = nds_offset + pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);;
                                pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[2].vdesc = "Class Definitions %u";
                                pvalues[2].vlength = 0;
                                pvalues[2].voffset = nds_offset;
                                pvalues[2].hfname = hf_nds_classes;
                                pvalues[2].mvtype = MVTYPE_CLASS_NAMES;
                                pvalues[2].vflags = request_value->req_nds_flags;
                                break;
                        case 0x10:    
                                break;
                        case 0x11:    
                                break;
                        case 0x12:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].hfname = hf_nds_iteration;
                                nds_offset = nds_offset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[1].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[1].vdesc = "Classes: %u";
                                pvalues[1].vlength = 4;
                                pvalues[1].voffset = nds_offset;
                                pvalues[1].mvtype = MVTYPE_READ_CLASS_REQ;
                                pvalues[1].hfname= hf_nds_classes;
                                break;
                        case 0x13:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Privileges: 0x%08x";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].hfname = hf_nds_privileges;
                                nds_offset = nds_offset+pvalues[0].vlength;
                                break;
                        case 0x14:    
                                break;
                        case 0x15:    
                                break;
                        case 0x16:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].hfname = hf_nds_iteration;
                                nds_offset = nds_offset+pvalues[0].vlength;
                                pvalues[1].vtype = VTYPE_STRING;
                                pvalues[1].vdesc = "Server Distinguished Name: %s";
                                pvalues[1].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[1].vvalue = 0;
                                pvalues[1].vlength = 256;
                                pvalues[1].vlength = tvb_get_letohl(tvb, nds_offset);
                                if (pvalues[1].vlength == 0x00)
                                {
                                        pvalues[1].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[1].voffset = nds_offset+4;
                                nds_offset += 4;
                                get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, pvalues[1].vstring);
                                nds_offset += pvalues[1].vlength;
                                nds_offset += align_4(tvb, nds_offset);
                                pvalues[1].hfname= hf_nds_name;
                                nds_offset += align_4(tvb, nds_offset);
                                pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[2].vdesc = "Replicas: %u";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = nds_offset;
                                pvalues[2].hfname = hf_nds_replicas;
                                pvalues[2].mvtype = MVTYPE_READ_REPLICAS;
                                pvalues[2].bit1 = "Output Flags";
                                pvalues[2].bit2 = "Entry ID";
                                pvalues[2].bit3 = "Replica State";
                                pvalues[2].bit4 = "Modification Timestamp";
                                pvalues[2].bit5 = "Purge Time";
                                pvalues[2].bit6 = "Local Partition ID";
                                pvalues[2].bit7 = "Distinguished Name";
                                pvalues[2].bit8 = "Replica Type";
                                pvalues[2].bit9 = "Partition Busy";
                                pvalues[2].vflags = request_value->req_nds_flags;
                                break;
                        case 0x17:    
                                break;
                        case 0x18:    
                                break;
                        case 0x19:    
                                break;
                        case 0x1a:    
                                break;
                        case 0x1b:    
                                pvalues[0].vvalue = tvb_get_ntohl(tvb, nds_offset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "File Handle: 0x%08x";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = nds_offset;
                                pvalues[0].hfname = hf_nds_file_handle;
                                nds_offset = nds_offset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "File Size: %u";
                                pvalues[1].vlength = 4;
                                pvalues[1].voffset = nds_offset;
                                pvalues[1].hfname = hf_nds_file_size;
                                nds_offset = nds_offset+pvalues[1].vlength;
                                break;
                        case 0x1c:    
                                break;
                        case 0x1d:    
                                break;
                        case 0x1e:    
                                break;
                        case 0x1f:    
                                break;
                        case 0x20:    
                                break;
                        case 0x21:    
                                break;
                        case 0x22:    
                                break;
                        case 0x23:    
                                break;
                        case 0x24:    
                                break;
                        case 0x25:    
                                break;
                        case 0x26:    
                                break;
                        case 0x27:    
                                break;
                        case 0x28:    
                                break;
                        case 0x29:    
                                break;                  
                        case 0x2a:    
                                break;
                        case 0x2b:    
                                break;
                        case 0x2c:    
                                break;
                        case 0x2d:    
                                break;
                        case 0x2e:    
                                break;
                        case 0x2f:    
                                break;
                        case 0x30:
                                break;
                        case 0x31:
                                break;
                        case 0x32:    
                                break;
                        case 0x33:    
                                break;
                        case 0x34:    
                                break;
                        case 0x35:    
                                if(request_value->nds_version != 0x000000fe)
                                { 
                                        pvalues[0].vtype = VTYPE_STRING;
                                        pvalues[0].vdesc = "Distinguished Name: %s";
                                        pvalues[0].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[0].vvalue = 0;
                                        pvalues[0].vlength = 256;
                                        pvalues[0].vlength = tvb_get_letohl(tvb, nds_offset);
                                        if (pvalues[0].vlength == 0x00)
                                        {
                                                pvalues[0].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[0].voffset = nds_offset+4;
                                        nds_offset += 4;
                                        get_string(tvb, pvalues[0].voffset, pvalues[0].vlength, pvalues[0].vstring);
                                        nds_offset += pvalues[0].vlength;
                                        nds_offset += align_4(tvb, nds_offset);
                                        pvalues[0].hfname= hf_nds_name;
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[1].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[1].vdesc = "Referral Records: %u";
                                        pvalues[1].vlength = 4;
                                        pvalues[1].voffset = nds_offset;
                                        pvalues[1].hfname = hf_nds_referrals;
                                        pvalues[1].mvtype = MVTYPE_LOC_ADDR_REFERRAL_REPLY;
                                }
                                else
                                {
                                        pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[0].vtype = VTYPE_UINT32;
                                        pvalues[0].vdesc = "Iteration Handle: 0x%08x";
                                        pvalues[0].vlength = 4;
                                        pvalues[0].voffset = nds_offset;
                                        pvalues[0].hfname = hf_nds_iteration;
                                        nds_offset = nds_offset+pvalues[0].vlength;
                                        pvalues[1].vtype = VTYPE_STRING;
                                        pvalues[1].vdesc = "Distinguished Name: %s";
                                        pvalues[1].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[1].vvalue = 0;
                                        pvalues[1].vlength = 256;
                                        pvalues[1].vlength = tvb_get_letohl(tvb, nds_offset);
                                        if (pvalues[1].vlength == 0x00)
                                        {
                                                pvalues[1].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[1].voffset = nds_offset+4;
                                        nds_offset += 4;
                                        get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, pvalues[1].vstring);
                                        nds_offset += pvalues[1].vlength;
                                        nds_offset += align_4(tvb, nds_offset);
                                        pvalues[1].hfname= hf_nds_name;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
                                        pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[2].vdesc = "Referral Records: %u";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = nds_offset;
                                        pvalues[2].hfname = hf_nds_referrals;
                                        pvalues[2].mvtype = MVTYPE_LOC_ADDR_REFERRAL_REPLY;
                                }        
                                break;
                        case 0x36:    
                                break;
                        case 0x37:    
                                break;
                        case 0x38:    
                                break;
                        case 0x39:    
                                break;
                        case 0x3a:    
                                break;
                        case 0x3b:    
                                break;
                        case 0x3c:    
                                break;
                        case 0x3d:    
                                break;
                        case 0x3e:    
                                break;
                        case 0x3f:    
                                break;
                        case 0x40:    
                                break;
                        case 0x41:              
                                break;
                        case 0x42:    
                                break;
                        case 0x43:    
                                break;
                        case 0x44:    
                                break;
                        case 0x45:    
                                break;
                        case 0x46:    
                                break;
                        case 0x47:    
                                break;
                        case 0x48:    
                                break;
                        case 0x49:    
                                break;
                        case 0x4a:    
                                break;
                        case 0x4b:    
                                break;
                        case 0x4c:    
                                break;
                        case 0x4d:    
                                break;
                        default:
                                break;
                        }
                        if(request_value->nds_request_verb != 0)
                        {
                                proto_tree_add_uint_format(ncp_tree,
                                    hf_ncp_nds_verb, tvb, 6, 0,
                                    request_value->nds_request_verb,
                                    "NDS Verb: %d, %s",
                            request_value->nds_request_verb, verb_string);
                        }
                        /* NDS Entry ID's (EID) is identified in the reply
                         * packet of an NDS resolve name. We need to store
                         * this EID and its associated name into our hash
                         * so that we can resolve the name for other NDS
                         * requests. */
                        if (!pinfo->fd->flags.visited) {
                                if(add_eid)
                                {
                                        request_eid_value = ncp_eid_hash_lookup(conversation, global_eid);
                                        if (!request_eid_value) {
                                                request_eid_value = ncp_eid_hash_insert(global_eid);
                                                strcpy(request_eid_value->object_name, global_object_name);
                                        }
                                }
                        }
                        /* Echo EID data to expert Chat window */
                        if (add_eid && nds_echo_eid) {
                            expert_add_info_format(pinfo, NULL,
                                PI_RESPONSE_CODE, PI_CHAT,
                                "EID (%08x) = %s", global_eid, global_object_name);
                        }
                        /* For NDS requests with just an EID, resolve name
                         * from hash table. */
                        if(resolve_eid)
                        {
                                request_eid_value = ncp_eid_hash_lookup(conversation, global_eid);
                                if (request_eid_value) {
                                        strcpy(global_object_name, request_eid_value->object_name);
                                        proto_tree_add_string_format(ncp_tree,
                                            hf_nds_name, tvb, 6, 0,
                                            global_object_name,
                                            "NDS Name for EID - %s",
                                            global_object_name);
                                }
                        }        
                  for (i = 0; i < 9; i++) {
                        switch (pvalues[i].vtype) {

                        case VTYPE_NONE: /* no value */
                              break;

                        case VTYPE_UINT8:
                              proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                  pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u",
                                  pvalues[i].vtype);
                              break;

                        case VTYPE_UINT16:
                              proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                  pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u",
                                  pvalues[i].vtype);
                              break;

                        case VTYPE_UINT32:
                              proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                  pvalues[i].vlength, pvalues[i].vvalue, pvalues[i].vdesc,
                                  pvalues[i].vvalue);
                              break;

                        case VTYPE_STRING:
                              proto_tree_add_string_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, 
                                  pvalues[i].vlength, pvalues[i].vstring, pvalues[i].vdesc,
                                  pvalues[i].vstring);
                              break;

                        case VTYPE_BITFIELD:
                              process_bitfield(ncp_tree, tvb, &pvalues[i]);
                              break;

                        case VTYPE_MULTIVALUE_UINT32:
                              process_multivalues(ncp_tree, tvb, &pvalues[i]);
                              break;

                        default:
                              proto_tree_add_uint_format(ncp_tree, hf_nds_p1type, tvb, pvalues[i].voffset,
                                  pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u",
                                  pvalues[i].vtype);
                              break;
                        }
            }
      }
}

void
dissect_ncp_reply(tvbuff_t *tvb, packet_info *pinfo,
      guint32 nw_connection, guint8 sequence, guint16 type,
      proto_tree *ncp_tree, struct novell_tap *ncp_tap)
{
      conversation_t                *conversation = NULL;
      ncp_req_hash_value            *request_value = NULL;
      const ncp_record        *ncp_rec = NULL;
      int                     *req_cond_results;
      guint8                        completion_code=0;
      ptvcursor_t             *ptvc = NULL;
      const char              *error_string;
        guint32                         nds_offset = 0;
        guint32                         nds_error_code = 0;
        guint32                         nds_reply_buffer = 0;
        const char                      *nds_error_string = NULL;
        guint32                         nds_frag=0;
        
#ifdef FAKE_TREE_IS_VISIBLE
        if (ncp_tree) {
                PTREE_DATA(ncp_tree)->visible=1;
        }
#endif

      if (!pinfo->fd->flags.visited) {
            /* Find the conversation whence the request would have come. */
            conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                      PT_NCP, nw_connection, nw_connection, 0);
            if (conversation != NULL) {
                  /* find the record telling us the request made that caused
                     this reply */
                  request_value = ncp_hash_lookup(conversation, sequence);
                  if (request_value) {
                        ncp_rec = request_value->ncp_rec;
                  }
                  p_add_proto_data(pinfo->fd, proto_ncp, (void*) request_value);
            }
            /* else... we haven't seen an NCP Request for that conversation
               and sequence.
               Create Service request packets do not contain nw_connection.
               The initial value is set to 65535 or 0. The reply packet has the
               valid connection. So, we can't find the request packet in
               our conversation list. To trap for this we can just perform
               the search again with 65535 to see if we can locate the
               proper request packet. */
            else {
                  conversation = find_conversation(pinfo->fd->num,
                      &pinfo->src, &pinfo->dst, PT_NCP, 65535, 65535, 0);
                  if (conversation != NULL) {
                        /* find the record telling us the request made
                           that caused this reply */
                        request_value = ncp_hash_lookup(conversation,
                            sequence);
                        if (request_value) {
                              ncp_rec = request_value->ncp_rec;
                        }
                        p_add_proto_data(pinfo->fd, proto_ncp,
                            (void*) request_value);
                  }
            else {
                conversation = find_conversation(pinfo->fd->num,
                    &pinfo->src, &pinfo->dst, PT_NCP, 0, 0, 0);
                if (conversation != NULL) {
                    /* find the record telling us the request made
                       that caused this reply */
                    request_value = ncp_hash_lookup(conversation,
                        sequence);
                    if (request_value) {
                        ncp_rec = request_value->ncp_rec;
                    }
                    p_add_proto_data(pinfo->fd, proto_ncp,
                        (void*) request_value);
                }
                /* else... we haven't seen an NCP Request for that
                   conversation and sequence. */
            }
            }
      }
      else {
            request_value = p_get_proto_data(pinfo->fd, proto_ncp);
            if (request_value) {
                  ncp_rec = request_value->ncp_rec;
            }
      }

      /*
         * Tap the packet before the dissectors are called so we
         * still get the tap listener called even if there is an
         * exception.
         */
        tap_queue_packet(ncp_tap->stat, pinfo, request_value);

      if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
                if (ncp_rec && ncp_rec->func==0x68 &&
                (ncp_rec->subfunc==0x02 || ncp_rec->subfunc==0x01)) {
                  col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDS");
                }
      }

      /* A completion code of 0 always means OK. Non-zero means failure,
       * but each non-zero value has a different meaning. And the same value
       * can have different meanings, depending on the ncp.func (and ncp.subfunc)
       * value. */
      completion_code = tvb_get_guint8(tvb, 6);
      if (completion_code == 0) {
                if(type == NCP_POSITIVE_ACK)
                {
                        error_string = "Server Busy, Request Being Processed";
                }
                else
                {                
                        error_string = "OK";
                }        
      } else {
            if (ncp_rec && ncp_rec->errors) {
                  error_string = ncp_error_string(ncp_rec->errors, completion_code);
            }
            else {
                  error_string = "Original Request Packet not Found";
            }
      }
        if (type == NCP_SERVICE_REPLY && ncp_rec && ncp_rec->func==0x68 &&
            ncp_rec->subfunc==0x02 && (tvb_reported_length_remaining(tvb, 8) >= 8))
        {
                nds_offset = 8;
                nds_reply_buffer = tvb_get_letohl(tvb, nds_offset);
                nds_offset += 4;        
                nds_frag = tvb_get_letohl(tvb, nds_offset);        
                nds_offset += 4;
            /*
             * Is the possibly-reassembled reply large enough to have
             * a completion code?  (We can't check the fragment size
             * as this might just be the last fragment.)
             */
                if (tvb_reported_length_remaining(tvb, nds_offset) >= 4)
                {
                  /* Yes - process the completion code. */
                        nds_error_code = tvb_get_letohl(tvb, nds_offset);
                        nds_error_string = match_strval(nds_error_code, nds_reply_errors);
                        if (nds_error_string == NULL)
                        {
                                nds_error_string = "NDS Error - No Definition Found";
                        }
                }
        }
      if (check_col(pinfo->cinfo, COL_INFO)) {
            col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s",
                type == NCP_SERVICE_REPLY ? "R" : "ACK",
                nds_error_string ? nds_error_string : error_string);
      }

      if (ncp_tree) {

            if (request_value) {
                  nstime_t ns;

                  proto_tree_add_uint(ncp_tree, hf_ncp_req_frame_num, tvb, 0, 0,
                        request_value->req_frame_num);
                  nstime_delta(&ns, &pinfo->fd->abs_ts, &request_value->req_frame_time);
                  proto_tree_add_time(ncp_tree, hf_ncp_req_frame_time, tvb, 0, 0, &ns);
            }
        
            /* Put the func (and maybe subfunc) from the request packet
             * in the proto tree, but hidden. That way filters on ncp.func
             * or ncp.subfunc will find both the requests and the replies.
             */
            if (ncp_rec) {
                  proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 0,
                        ncp_rec->func, "Function: %u (0x%02X), %s",
                        ncp_rec->func, ncp_rec->func, ncp_rec->name);
                  if (ncp_requires_subfunc(ncp_rec->func)) {
                        proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 6, 0,
                              ncp_rec->subfunc, "SubFunction: %u (0x%02x)",
                              ncp_rec->subfunc, ncp_rec->subfunc);
                  }
            }
      }

      expert_item = proto_tree_add_uint_format(ncp_tree, hf_ncp_completion_code, tvb, 6, 1,
            completion_code, "Completion Code: %d (0x89%02x), %s",
            completion_code, completion_code, error_string);
      if ((completion_code != 0 || type == NCP_POSITIVE_ACK) && ncp_echo_err) {
            expert_add_info_format(pinfo, expert_item,
                PI_RESPONSE_CODE, PI_ERROR,
                "Error: %d (0x89%02x) %s", completion_code,
                completion_code, error_string);
      }

      if (ncp_tree) {
        guint8    conn_stat;

        conn_stat = tvb_get_guint8(tvb, 7);
            expert_item = proto_tree_add_item(ncp_tree, hf_ncp_connection_status, tvb,
                7, 1, FALSE);
        if (conn_stat != 0 && conn_stat != 0x40 ) {
            if (check_col(pinfo->cinfo, COL_INFO)) {
                col_set_str(pinfo->cinfo, COL_INFO,
                    "Error: Bad Connection Status");
            }
            if (ncp_echo_err) {
                expert_add_info_format(pinfo, expert_item,
                    PI_RESPONSE_CODE, PI_ERROR,
                    "Error: Bad Connection Status");
            }
            return;
        }
      }
      /*
       * Unless this is a successful reply, that's all there
       * is to parse.
       */
      if (type != NCP_SERVICE_REPLY || completion_code != 0)
            return;

        if (ncp_rec) {
                /* Dissect SSS Reply packets */
                if (ncp_rec->func == 0x5c && request_value)
                {
                        dissect_sss_reply(tvb, pinfo, ncp_tree, ncp_rec->subfunc, request_value);
                } 
                /* Dissect NMAS Reply packets */
                if (ncp_rec->func == 0x5e && request_value)
                {
                        dissect_nmas_reply(tvb, pinfo, ncp_tree, ncp_rec->func, ncp_rec->subfunc, request_value);
                }
                /* Dissect NDS Ping packets */
                if (ncp_rec->func == 0x68 && ncp_rec->subfunc == 0x01)
                {
                        dissect_nds_ping_reply(tvb, pinfo, ncp_tree,
                            request_value);
                }
                /* Dissect NDS Reply packets */
                if (ncp_rec->func == 0x68 && ncp_rec->subfunc == 0x02) 
                {
                        dissect_nds_reply(tvb, pinfo, ncp_tree, nds_error_code,
                            nds_error_string, request_value, conversation);
                }
                /* Due to lack of group repeat fields in reply structure, decode this ncp 87/20 reply manually here. */
                if ((ncp_rec->func == 0x57 || ncp_rec->func == 0x59) && ncp_rec->subfunc == 0x14) {
                        dissect_ncp_8x20reply(tvb, ncp_tree, ncp_rec, request_value);
                }
                /* Process ncp 23/26 address records manually to format correctly. */
                if (ncp_rec->func == 0x17 && ncp_rec->subfunc == 0x1a) {
                        dissect_ncp_23_26_reply(tvb, ncp_tree);
                }
                if (ncp_rec->func == 5 && ncp_echo_conn) {
                    expert_add_info_format(pinfo, NULL, PI_RESPONSE_CODE, PI_CHAT, "Connection Destroyed");
                }
                if (ncp_rec->reply_ptvc) {
                        /* If we're not building a protocol tree, quit;
                         * "process_ptvc_record()" assumes we're building
                         * a protocol tree, and we don't support putting
                         * stuff in the Info column in replies, and no
                         * state information is currently updated for
                         * replies by "process_ptvc_record()", so we
                         * can't, and don't have a reason to, dissect
                         * any further if we're not building a protocol
                         * tree. */
                        if (!ncp_tree)
                                return;

                        /* If a non-zero completion code was found, it is
                         * legal to not have any fields, even if the packet
                         * type is defined as having fields.
                         *
                         * XXX - we already know that the completion code
                         * is 0, as we checked it above.  Is there any
                         * reason why we'd want to do a full dissection
                         * if the completion code isn't 0? */
                        if (completion_code != 0 && tvb_length(tvb) == 8) {
                                return;
                        }

                        /* Any request condition results? */
                        if (request_value) {
                                req_cond_results = request_value->req_cond_results;
                        }
                        else {
                                req_cond_results = NULL;
                        }
                        clear_repeat_vars();
                        ptvc = ptvcursor_new(ncp_tree, tvb, 8);
                        process_ptvc_record(ptvc, ncp_rec->reply_ptvc,
                                req_cond_results, TRUE, ncp_rec);
                        ptvcursor_free(ptvc);

                        /* Echo the NDS EID and name for NCP 22,51 replies to expert tap */
                        if (!pinfo->fd->flags.visited && ncp_rec->func == 0x16 && ncp_rec->subfunc == 0x33) {

                            char    eid_string[10];
                            char    global_object_name[256];
                            
                            build_expert_data(ncp_tree, "ncp.directory_services_object_id", eid_string, 0, TRUE);
                            build_expert_data(ncp_tree, "ncp.volume_name_len", global_object_name, 0, FALSE);
                            
                            /* Echo EID data to expert Chat window */
                            if (nds_echo_eid) {
                                expert_add_info_format(pinfo, NULL,
                                    PI_RESPONSE_CODE, PI_CHAT,
                                    "EID (%s) = %s", eid_string, global_object_name);
                            }
                        }
                        /* Process ncp 123/17 address records manually to format correctly. */
                        if (ncp_rec->func == 0x7b && ncp_rec->subfunc == 0x11) {
                                dissect_ncp_123_17_reply(tvb, ncp_tree);
                        }
                        /* Process ncp 123/11 NLM names manually to format correctly. */
                        if (ncp_rec->func == 0x7b && ncp_rec->subfunc == 0x0b && request_value) {
                                dissect_ncp_123_11_reply(tvb, ncp_tree, request_value);
                        }
                }
                /* Check to see if we need to report to the expert table */
                trap_for_expert_event(ncp_tree, pinfo, ncp_rec, 1);
        } else {
                if (tvb_length(tvb) > 8) {
                        expert_item = proto_tree_add_text(ncp_tree, tvb, 8, -1,
                            "No request record found. Parsing is impossible.");
                        if (ncp_echo_err) {
                            expert_add_info_format(pinfo, expert_item, PI_SEQUENCE, PI_NOTE, "No request record found.");
                        }
                }
        }
}

void
dissect_nds_request(tvbuff_t *tvb, packet_info *pinfo,
            guint32 nw_connection, guint8 sequence,
            guint16 type, proto_tree *ncp_tree)
{
      guint8                  func, subfunc = 0;
      ncp_req_hash_value      *request_value = NULL;
      ncp_req_eid_hash_value  *request_eid_value = NULL;
      const ncp_record  *ncp_rec = NULL;          
      conversation_t          *conversation;
      ptvcursor_t       *ptvc = NULL;
      proto_tree        *temp_tree = NULL;
      gboolean          run_req_cond = FALSE;
      gboolean          run_info_str = FALSE;
        guint8                  nds_verb = 0;
        const char              *verb_string = "";
        guint32                 nds_frag = 0;
        gboolean                added_arrow;
        nds_val               pvalues[9];
      char              string_buffer[9][1024];
        guint8                  nds_version = 0;
        guint32                 foffset = 0;
        nw_uni_t                req_buffer;
        char                    global_object_name[256];
        guint32                 global_eid=0;
        gboolean                resolve_eid=FALSE;
        guint32                 global_flags=0;
      int               i;

      for (i = 0; i < 9; i++) {
            pvalues[i].vtype = 0;
            pvalues[i].vvalue = 0;
            pvalues[i].vlength = 0;
            pvalues[i].voffset = 0;
            pvalues[i].hfname = 0;
            pvalues[i].vdesc = "";
            string_buffer[i][0] = '\0';
            pvalues[i].vstring = string_buffer[i];
            pvalues[i].mvtype = 0;
            pvalues[i].vflags = 0;
      }
        
        strcpy(req_buffer.buffer, "");
        strcpy(global_object_name, "");
        
        func = tvb_get_guint8(tvb, 6);
        subfunc = tvb_get_guint8(tvb, 7);
        
            ncp_rec = ncp_record_find(func, subfunc);

        /* Check to see if this is a fragment packet */
        nds_frag = tvb_get_letohl(tvb, 8);
        
        /* Get NDS Verb */
        if (nds_frag == 0xffffffff) {
                /* First fragment or only fragment. */
                nds_verb = tvb_get_guint8(tvb, 24);
                if (nds_verb == 0xfe) 
                {
                        nds_version = nds_verb;
                        nds_verb = tvb_get_guint8(tvb, 32);
                        foffset = 36;
                }
                else
                {
                        nds_version = 0;
                        foffset = 28;
                }
                if (type == NCP_SERVICE_REQUEST) {
                        proto_tree_add_item(ncp_tree, hf_nds_buffer_size, tvb, foffset,
                                            4, TRUE);
                }
                foffset = foffset+4;        
                verb_string = val_to_str(nds_verb, ncp_nds_verb_vals,
                    "Continuation Fragment");
                switch(nds_verb) {
                
                        case 0x01:
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_BITFIELD;
                                pvalues[1].vdesc = "Flags:";
                                pvalues[1].vlength = 2;
                                pvalues[1].hfname= hf_nds_nflags;
                                pvalues[1].voffset = foffset;
                                pvalues[1].bit1 = "Entry ID";
                                pvalues[1].bit1hfname = hf_bit1nflags;
                                pvalues[1].bit2 = "Readable";
                                pvalues[1].bit2hfname = hf_bit2nflags;
                                pvalues[1].bit3 = "Writeable";
                                pvalues[1].bit3hfname = hf_bit3nflags;
                                pvalues[1].bit4 = "Master";
                                pvalues[1].bit4hfname = hf_bit4nflags;
                                pvalues[1].bit5 = "Create ID";
                                pvalues[1].bit5hfname = hf_bit5nflags;
                                pvalues[1].bit6 = "Walk Tree";
                                pvalues[1].bit6hfname = hf_bit6nflags;
                                pvalues[1].bit7 = "Dereference Alias";
                                pvalues[1].bit7hfname = hf_bit7nflags;
                                pvalues[1].bit8 = "Not Defined";
                                pvalues[1].bit8hfname = hf_bit8nflags;
                                pvalues[1].bit9 = "Not Defined";
                                pvalues[1].bit9hfname = hf_bit9nflags;
                                pvalues[1].bit10 = "Not Defined";
                                pvalues[1].bit10hfname = hf_bit10nflags;
                                pvalues[1].bit11= "Not Defined";
                                pvalues[1].bit11hfname = hf_bit11nflags;
                                pvalues[1].bit12 = "Not Defined";
                                pvalues[1].bit12hfname = hf_bit12nflags;
                                pvalues[1].bit13 = "Not Defined";
                                pvalues[1].bit13hfname = hf_bit13nflags;
                                pvalues[1].bit14 = "Prefer Referrals";
                                pvalues[1].bit14hfname = hf_bit14nflags;
                                pvalues[1].bit15 = "Prefer Only Referrals";
                                pvalues[1].bit15hfname = hf_bit15nflags;
                                pvalues[1].bit16 = "Not Defined";
                                pvalues[1].bit16hfname = hf_bit16nflags;
                                foffset = foffset+4;
                                if (pvalues[0].vvalue == 0 || pvalues[0].vvalue == 1)
                                {
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Scope: %u";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = foffset;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].hfname= hf_nds_scope;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vtype = VTYPE_STRING;
                                        pvalues[3].vdesc = "Name: %s";
                                        pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[3].vvalue = 0;
                                        pvalues[3].vlength = 256;
                                        pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                        if (pvalues[3].vlength == 0x00)
                                        {
                                                pvalues[3].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[3].voffset = foffset+4;
                                        foffset = foffset + 4;
                                        get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, req_buffer.buffer);
                                        pvalues[3].vstring = req_buffer.buffer;
                                        strcpy(global_object_name, req_buffer.buffer);
                                        pvalues[3].hfname= hf_nds_name;
                                        foffset = foffset+pvalues[3].vlength;
                                        foffset += align_4(tvb, foffset);
                                        pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[4].vdesc = "Communications Transports: %u";
                                        pvalues[4].vlength = 4;
                                        pvalues[4].hfname= hf_nds_comm_trans;
                                        pvalues[4].voffset = foffset;
                                        pvalues[4].mvtype = MVTYPE_ADDR_REFERRAL_REQUEST;
                                        foffset = foffset + (pvalues[4].vvalue * 4) + 4;
                                        pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[5].vdesc = "Tree Walker Transport Type: %u";
                                        pvalues[5].vlength = 4;
                                        pvalues[5].mvtype = MVTYPE_ADDR_REFERRAL_REQUEST;
                                        pvalues[5].hfname= hf_nds_tree_trans;
                                        pvalues[5].voffset = foffset;
                                }
                                else
                                {
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Minimum DS Version: %u";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = foffset;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].hfname= hf_min_nds_ver;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[3].vdesc = "Number of Versions to Include: %u";
                                        pvalues[3].vlength = 4;
                                        pvalues[3].mvtype = MVTYPE_ATTR_REQUEST2;
                                        pvalues[3].voffset = foffset;
                                        pvalues[3].hfname= hf_nds_ver_include;
                                        foffset += (pvalues[3].vvalue * 4) + 4;
                                        pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[4].vdesc = "Number of Versions to Exclude: %u";
                                        pvalues[4].vlength = 4;
                                        pvalues[4].mvtype = MVTYPE_ATTR_REQUEST2;
                                        pvalues[4].hfname= hf_nds_ver_exclude;
                                        pvalues[4].voffset = foffset;
                                        foffset += 4;
                                        pvalues[5].vtype = VTYPE_UINT32;
                                        pvalues[5].vdesc = "DN Output Type: %u";
                                        pvalues[5].vlength = 4;
                                        pvalues[5].voffset = foffset;
                                        pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[5].hfname= hf_nds_dn_output_type;
                                        foffset = foffset+pvalues[5].vlength;
                                        pvalues[6].vtype = VTYPE_UINT32;
                                        pvalues[6].vdesc = "Nested Output Type: %u";
                                        pvalues[6].vlength = 4;
                                        pvalues[6].voffset = foffset;
                                        pvalues[6].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[6].hfname= hf_nds_nested_output_type;
                                        foffset = foffset+pvalues[6].vlength;
                                        pvalues[7].vtype = VTYPE_STRING;
                                        pvalues[7].vdesc = "Output Delimiter: %s";
                                        pvalues[7].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[7].vvalue = 0;
                                        pvalues[7].vlength = 256;
                                        pvalues[7].vlength = tvb_get_letohl(tvb, foffset);
                                        pvalues[7].voffset = foffset+4;
                                        foffset = foffset + 4;
                                        get_string(tvb, pvalues[7].voffset, pvalues[7].vlength, req_buffer.buffer);
                                        pvalues[7].vstring = req_buffer.buffer;
                                        pvalues[7].hfname= hf_nds_output_delimiter;
                                        foffset = foffset+pvalues[7].vlength;
                                        foffset += align_4(tvb, foffset);
                                        pvalues[8].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[8].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[8].vdesc = "Size of Entry Specifier: %u";
                                        pvalues[8].vlength = 4;
                                        pvalues[8].mvtype = MVTYPE_PROC_ENTRY_SPECIFIERS;
                                        pvalues[8].hfname= hf_nds_output_entry_specifier;
                                        pvalues[8].voffset = foffset;
                                }
                                break;
                        case 0x02:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                switch(pvalues[0].vvalue)
                                {
                                        case 0:
                                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                                pvalues[1].vtype = VTYPE_UINT32;
                                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                                pvalues[1].vlength = 4;
                                                resolve_eid = TRUE;
                                                global_eid = pvalues[1].vvalue;
                                                pvalues[1].voffset = foffset;
                                                pvalues[1].hfname = hf_nds_eid;
                                                foffset = foffset+pvalues[1].vlength;
                                                break;
                                        case 1:
                                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                                pvalues[1].vtype = VTYPE_BITFIELD;
                                                pvalues[1].vdesc = "Request Flags:";
                                                pvalues[1].vlength = 2;
                                                pvalues[1].hfname= hf_nds_rflags;
                                                pvalues[1].voffset = foffset;
                                                pvalues[1].bit1 = "Typeless";
                                                pvalues[1].bit1hfname = hf_bit1rflags;
                                                pvalues[1].bit2 = "Slashed";
                                                pvalues[1].bit2hfname = hf_bit2rflags;
                                                pvalues[1].bit3 = "Dotted";
                                                pvalues[1].bit3hfname = hf_bit3rflags;
                                                pvalues[1].bit4 = "Tuned";
                                                pvalues[1].bit4hfname = hf_bit4rflags;
                                                pvalues[1].bit5 = "Not Defined";
                                                pvalues[1].bit5hfname = hf_bit5rflags;
                                                pvalues[1].bit6 = "Not Defined";
                                                pvalues[1].bit6hfname = hf_bit6rflags;
                                                pvalues[1].bit7 = "Not Defined";
                                                pvalues[1].bit7hfname = hf_bit7rflags;
                                                pvalues[1].bit8 = "Not Defined";
                                                pvalues[1].bit8hfname = hf_bit8rflags;
                                                pvalues[1].bit9 = "Not Defined";
                                                pvalues[1].bit9hfname = hf_bit9rflags;
                                                pvalues[1].bit10 = "Not Defined";
                                                pvalues[1].bit10hfname = hf_bit10rflags;
                                                pvalues[1].bit11 = "Not Defined";
                                                pvalues[1].bit11hfname = hf_bit11rflags;
                                                pvalues[1].bit12 = "Not Defined";
                                                pvalues[1].bit12hfname = hf_bit12rflags;
                                                pvalues[1].bit13 = "Not Defined";
                                                pvalues[1].bit13hfname = hf_bit13rflags;
                                                pvalues[1].bit14 = "Not Defined";
                                                pvalues[1].bit14hfname = hf_bit14rflags;
                                                pvalues[1].bit15 = "Not Defined";
                                                pvalues[1].bit15hfname = hf_bit15rflags;
                                                pvalues[1].bit16 = "Not Defined";
                                                pvalues[1].bit16hfname = hf_bit16rflags;
                                                if((pvalues[1].vvalue&&0xf000) == 0xc000)
                                                {
                                                        pvalues[2].vtype = VTYPE_STRING;
                                                        pvalues[2].vdesc = "Name Type: %s";
                                                        pvalues[2].vstring = "Partial";
                                                        pvalues[2].mvtype = 0;
                                                        pvalues[2].vvalue = 0;
                                                        pvalues[2].vlength = 0;
                                                        pvalues[2].voffset = 0;
                                                        pvalues[2].hfname= hf_nds_name_type;
                                                }
                                                else
                                                {
                                                        pvalues[2].vtype = VTYPE_STRING;
                                                        pvalues[2].vdesc = "Name Type: %s";
                                                        pvalues[2].vstring = "Full";
                                                        pvalues[2].vvalue = 0;
                                                        pvalues[2].mvtype = 0;
                                                        pvalues[2].vlength = 0;
                                                        pvalues[2].voffset = 0;
                                                        pvalues[2].hfname= hf_nds_name_type;
                                                }
                                                foffset = foffset+4;
                                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                                pvalues[3].vtype = VTYPE_UINT32;
                                                pvalues[3].vdesc = "Entry ID: 0x%08x";
                                                pvalues[3].vlength = 4;
                                                pvalues[3].voffset = foffset;
                                                resolve_eid = TRUE;
                                                global_eid = pvalues[3].vvalue;
                                                pvalues[3].hfname = hf_nds_eid;
                                                foffset = foffset+pvalues[3].vlength;
                                                break;
                                        case 2:
                                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                                pvalues[1].vtype = VTYPE_BITFIELD;
                                                pvalues[1].vdesc = "Request Flags:";
                                                pvalues[1].vlength = 2;
                                                pvalues[1].hfname= hf_nds_rflags;
                                                pvalues[1].voffset = foffset;
                                                pvalues[1].bit1 = "Typeless";
                                                pvalues[1].bit1hfname = hf_bit1rflags;
                                                pvalues[1].bit2 = "Slashed";
                                                pvalues[1].bit2hfname = hf_bit2rflags;
                                                pvalues[1].bit3 = "Dotted";
                                                pvalues[1].bit3hfname = hf_bit3rflags;
                                                pvalues[1].bit4 = "Tuned";
                                                pvalues[1].bit4hfname = hf_bit4rflags;
                                                pvalues[1].bit5 = "Not Defined";
                                                pvalues[1].bit5hfname = hf_bit5rflags;
                                                pvalues[1].bit6 = "Not Defined";
                                                pvalues[1].bit6hfname = hf_bit6rflags;
                                                pvalues[1].bit7 = "Not Defined";
                                                pvalues[1].bit7hfname = hf_bit7rflags;
                                                pvalues[1].bit8 = "Not Defined";
                                                pvalues[1].bit8hfname = hf_bit8rflags;
                                                pvalues[1].bit9 = "Not Defined";
                                                pvalues[1].bit9hfname = hf_bit9rflags;
                                                pvalues[1].bit10 = "Not Defined";
                                                pvalues[1].bit10hfname = hf_bit10rflags;
                                                pvalues[1].bit11 = "Not Defined";
                                                pvalues[1].bit11hfname = hf_bit11rflags;
                                                pvalues[1].bit12 = "Not Defined";
                                                pvalues[1].bit12hfname = hf_bit12rflags;
                                                pvalues[1].bit13 = "Not Defined";
                                                pvalues[1].bit13hfname = hf_bit13rflags;
                                                pvalues[1].bit14 = "Not Defined";
                                                pvalues[1].bit14hfname = hf_bit14rflags;
                                                pvalues[1].bit15 = "Not Defined";
                                                pvalues[1].bit15hfname = hf_bit15rflags;
                                                pvalues[1].bit16 = "Not Defined";
                                                pvalues[1].bit16hfname = hf_bit16rflags;
                                                if((pvalues[1].vvalue&&0xf000) == 0xc000)
                                                {
                                                        pvalues[2].vtype = VTYPE_STRING;
                                                        pvalues[2].vdesc = "Name Type: %s";
                                                        pvalues[2].vstring = "Return Partion Name";
                                                        pvalues[2].vvalue = 0;
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].voffset = pvalues[1].voffset;
                                                        pvalues[2].mvtype = 0;
                                                        pvalues[2].hfname= hf_nds_name_type;
                                                }
                                                else
                                                {
                                                        pvalues[2].vtype = VTYPE_STRING;
                                                        pvalues[2].vdesc = "Name Type: %s";
                                                        pvalues[2].vstring = "Return Full Name";
                                                        pvalues[2].vvalue = 0;
                                                        pvalues[2].vlength = 4;
                                                        pvalues[2].mvtype = 0;
                                                        pvalues[2].voffset = pvalues[1].voffset;
                                                        pvalues[2].hfname= hf_nds_name_type;
                                                }
                                                foffset = foffset+4;
                                                pvalues[3].vvalue = tvb_get_letohs(tvb, foffset);
                                                global_flags = tvb_get_letohl(tvb, foffset);
                                                pvalues[3].vtype = VTYPE_BITFIELD;
                                                pvalues[3].vdesc = "Information Flags (low) Byte:";
                                                pvalues[3].vlength = 2;
                                                pvalues[3].hfname= hf_nds_rflags;
                                                pvalues[3].voffset = foffset;
                                                pvalues[3].bit1 = "Output Flags";
                                                pvalues[3].bit1hfname = hf_bit1infoflagsl;
                                                pvalues[3].bit2 = "Entry ID";
                                                pvalues[3].bit2hfname = hf_bit2infoflagsl;
                                                pvalues[3].bit3 = "Entry Flags";
                                                pvalues[3].bit3hfname = hf_bit3infoflagsl;
                                                pvalues[3].bit4 = "Subordinate Count";
                                                pvalues[3].bit4hfname = hf_bit4infoflagsl;
                                                pvalues[3].bit5 = "Modification Time";
                                                pvalues[3].bit5hfname = hf_bit5infoflagsl;
                                                pvalues[3].bit6 = "Modification Timestamp";
                                                pvalues[3].bit6hfname = hf_bit6infoflagsl;
                                                pvalues[3].bit7 = "Creation Timestamp";
                                                pvalues[3].bit7hfname = hf_bit7infoflagsl;
                                                pvalues[3].bit8 = "Partition Root ID";
                                                pvalues[3].bit8hfname = hf_bit8infoflagsl;
                                                pvalues[3].bit9 = "Parent ID";
                                                pvalues[3].bit9hfname = hf_bit9infoflagsl;
                                                pvalues[3].bit10 = "Revision Count";
                                                pvalues[3].bit10hfname = hf_bit10infoflagsl;
                                                pvalues[3].bit11 = "Replica Type";
                                                pvalues[3].bit11hfname = hf_bit11infoflagsl;
                                                pvalues[3].bit12 = "Base Class";
                                                pvalues[3].bit12hfname = hf_bit12infoflagsl;
                                                pvalues[3].bit13 = "Relative Distinguished Name";
                                                pvalues[3].bit13hfname = hf_bit13infoflagsl;
                                                pvalues[3].bit14 = "Distinguished Name";
                                                pvalues[3].bit14hfname = hf_bit14infoflagsl;
                                                pvalues[3].bit15 = "Root Distinguished Name";
                                                pvalues[3].bit15hfname = hf_bit15infoflagsl;
                                                pvalues[3].bit16 = "Parent Distinguished Name";
                                                pvalues[3].bit16hfname = hf_bit16infoflagsl;
                                                foffset = foffset+2;
                                                pvalues[4].vvalue = tvb_get_letohs(tvb, foffset);
                                                pvalues[4].vtype = VTYPE_BITFIELD;
                                                pvalues[4].vdesc = "Information Flags (high) Byte:";
                                                pvalues[4].vlength = 2;
                                                pvalues[4].hfname= hf_nds_rflags;
                                                pvalues[4].voffset = foffset;
                                                pvalues[4].bit1 = "Purge Time";
                                                pvalues[4].bit1hfname = hf_bit1infoflagsh;
                                                pvalues[4].bit2 = "Dereference Base Class";
                                                pvalues[4].bit2hfname = hf_bit2infoflagsh;
                                                pvalues[4].bit3 = "Not Defined";
                                                pvalues[4].bit3hfname = hf_bit3infoflagsh;
                                                pvalues[4].bit4 = "Not Defined";
                                                pvalues[4].bit4hfname = hf_bit4infoflagsh;
                                                pvalues[4].bit5 = "Not Defined";
                                                pvalues[4].bit5hfname = hf_bit5infoflagsh;
                                                pvalues[4].bit6 = "Not Defined";
                                                pvalues[4].bit6hfname = hf_bit6infoflagsh;
                                                pvalues[4].bit7 = "Not Defined";
                                                pvalues[4].bit7hfname = hf_bit7infoflagsh;
                                                pvalues[4].bit8 = "Not Defined";
                                                pvalues[4].bit8hfname = hf_bit8infoflagsh;
                                                pvalues[4].bit9 = "Not Defined";
                                                pvalues[4].bit9hfname = hf_bit9infoflagsh;
                                                pvalues[4].bit10 = "Not Defined";
                                                pvalues[4].bit10hfname = hf_bit10infoflagsh;
                                                pvalues[4].bit11 = "Not Defined";
                                                pvalues[4].bit11hfname = hf_bit11infoflagsh;
                                                pvalues[4].bit12 = "Not Defined";
                                                pvalues[4].bit12hfname = hf_bit12infoflagsh;
                                                pvalues[4].bit13 = "Not Defined";
                                                pvalues[4].bit13hfname = hf_bit13infoflagsh;
                                                pvalues[4].bit14 = "Not Defined";
                                                pvalues[4].bit14hfname = hf_bit14infoflagsh;
                                                pvalues[4].bit15 = "Not Defined";
                                                pvalues[4].bit15hfname = hf_bit15infoflagsh;
                                                pvalues[4].bit16 = "Not Defined";
                                                pvalues[4].bit16hfname = hf_bit16infoflagsh;
                                                foffset = foffset+2;
                                                pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                                pvalues[5].vtype = VTYPE_UINT32;
                                                pvalues[5].vdesc = "Entry ID: 0x%08x";
                                                pvalues[5].vlength = 4;
                                                pvalues[5].voffset = foffset;
                                                resolve_eid = TRUE;
                                                global_eid = pvalues[5].vvalue;
                                                pvalues[5].hfname = hf_nds_eid;
                                                foffset = foffset+pvalues[5].vlength;
                                                break;
                                        default:
                                                break;
                                }
                                
                                break;
                        case 0x03:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                if(pvalues[0].vvalue == 0)
                                {
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[1].vtype = VTYPE_UINT32;
                                        pvalues[1].vdesc = "Iteration Handle: 0x%08x";
                                        pvalues[1].vlength = 4;
                                        pvalues[1].voffset = foffset;
                                        pvalues[1].hfname= hf_nds_iteration;
                                        foffset = foffset+pvalues[1].vlength;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Entry ID: 0x%08x";
                                        pvalues[2].vlength = 4;
                                        resolve_eid = TRUE;
                                        global_eid = pvalues[2].vvalue;
                                        pvalues[2].voffset = foffset;
                                        pvalues[2].hfname= hf_nds_eid;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, nds_info_type);
                                        global_flags = pvalues[3].vvalue;
                                        if(pvalues[3].vstring == NULL)
                                        {
                                                pvalues[3].vstring = "No Info Type Set";
                                        }
                                        pvalues[3].vtype = VTYPE_STRING;
                                        pvalues[3].vdesc = "Info Type: %s";
                                        pvalues[3].vlength = 4;
                                        pvalues[3].voffset = foffset;
                                        pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[3].hfname= hf_nds_info_type;
                                        foffset = foffset + pvalues[3].vlength;
                                        pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[4].vtype = VTYPE_UINT32;
                                        pvalues[4].vdesc = "All Attributes: %u";
                                        pvalues[4].vlength = 4;
                                        pvalues[4].voffset = foffset;
                                        pvalues[4].hfname= hf_nds_all_attr;
                                        foffset = foffset+pvalues[4].vlength;
                                        pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[5].vdesc = "Attributes: %u";
                                        pvalues[5].vlength = 4;
                                        pvalues[5].voffset = foffset;
                                        pvalues[5].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[5].hfname= hf_nds_attr;
                                }
                                else
                                {
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[1].vtype = VTYPE_UINT32;
                                        pvalues[1].vdesc = "Request Flags: 0x%08x";
                                        pvalues[1].vlength = 4;
                                        pvalues[1].voffset = foffset;
                                        pvalues[1].hfname= hf_nds_req_flags;
                                        foffset = foffset+pvalues[1].vlength;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Iteration Handle: 0x%08x";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = foffset;
                                        pvalues[2].hfname= hf_nds_iteration;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vtype = VTYPE_UINT32;
                                        pvalues[3].vdesc = "Entry ID: 0x%08x";
                                        pvalues[3].vlength = 4;
                                        resolve_eid = TRUE;
                                        global_eid = pvalues[3].vvalue;
                                        pvalues[3].voffset = foffset;
                                        pvalues[3].hfname= hf_nds_eid;
                                        foffset = foffset+pvalues[3].vlength;
                                        pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[4].vstring = (char *)match_strval(pvalues[4].vvalue, nds_info_type);
                                        global_flags = pvalues[4].vvalue;
                                        if(pvalues[4].vstring == NULL)
                                        {
                                                pvalues[4].vstring = "No Info Type Set";
                                        }
                                        pvalues[4].vtype = VTYPE_STRING;
                                        pvalues[4].vdesc = "Info Type: %s";
                                        pvalues[4].vlength = 4;
                                        pvalues[4].voffset = foffset;
                                        pvalues[4].hfname= hf_nds_info_type;
                                        pvalues[4].mvtype = MVTYPE_ATTR_REQUEST;
                                        foffset = foffset+pvalues[4].vlength;
                                        pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[5].vtype = VTYPE_UINT32;
                                        pvalues[5].vdesc = "All Attributes: %u";
                                        pvalues[5].vlength = 4;
                                        pvalues[5].voffset = foffset;
                                        pvalues[5].hfname= hf_nds_all_attr;
                                        foffset = foffset+pvalues[5].vlength;
                                        pvalues[6].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[6].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[6].vdesc = "Attributes: %u";
                                        pvalues[6].vlength = 4;
                                        pvalues[6].voffset = foffset;
                                        pvalues[6].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[6].hfname= hf_nds_attr;
                                }
                                break;
                        case 0x04:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                pvalues[1].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[1].vvalue;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname = hf_nds_eid;
                                foffset = foffset+pvalues[1].vlength;
                                foffset += 4;       /* Attribute Count = 1 */
                                pvalues[2].vtype = VTYPE_STRING;
                                pvalues[2].vdesc = "Attribute Name Being Compared: %s";
                                pvalues[2].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[2].vvalue = 0;
                                pvalues[2].vlength = 256;
                                pvalues[2].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[2].vlength == 0x00)
                                {
                                        pvalues[2].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[2].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[2].voffset, pvalues[2].vlength, req_buffer.buffer);
                                pvalues[2].vstring = req_buffer.buffer;
                                strcpy(global_object_name, req_buffer.buffer);
                                pvalues[2].hfname= hf_nds_name;
                                foffset = foffset+pvalues[2].vlength;
                                foffset += align_4(tvb, foffset);
                                foffset += 4;       /* Attribute Value Count = 1 */
                                /***************
                                 * Need Trace file to test. Will have to create a 
                                 * new mvtype to call print_nds_values.
                                 ***************/
                                break;
                        case 0x05:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_BITFIELD;
                                pvalues[1].vdesc = "Request Flags:";
                                pvalues[1].vlength = 2;
                                pvalues[1].hfname= hf_nds_rflags;
                                pvalues[1].voffset = foffset;
                                pvalues[1].bit1 = "List Typeless";
                                pvalues[1].bit1hfname = hf_bit1lflags;
                                pvalues[1].bit2 = "List Containers";
                                pvalues[1].bit2hfname = hf_bit2lflags;
                                pvalues[1].bit3 = "List Slashed";
                                pvalues[1].bit3hfname = hf_bit3lflags;
                                pvalues[1].bit4 = "List Dotted";
                                pvalues[1].bit4hfname = hf_bit4lflags;
                                pvalues[1].bit5 = "Dereference Alias";
                                pvalues[1].bit5hfname = hf_bit5lflags;
                                pvalues[1].bit6 = "List All Containers";
                                pvalues[1].bit6hfname = hf_bit6lflags;
                                pvalues[1].bit7 = "List Obsolete";
                                pvalues[1].bit7hfname = hf_bit7lflags;
                                pvalues[1].bit8 = "List Tuned Output";
                                pvalues[1].bit8hfname = hf_bit8lflags;
                                pvalues[1].bit9 = "List External Reference";
                                pvalues[1].bit9hfname = hf_bit9lflags;
                                pvalues[1].bit10 = "Not Defined";
                                pvalues[1].bit10hfname = hf_bit10lflags;
                                pvalues[1].bit11 = "Not Defined";
                                pvalues[1].bit11hfname = hf_bit11lflags;
                                pvalues[1].bit12 = "Not Defined";
                                pvalues[1].bit12hfname = hf_bit12lflags;
                                pvalues[1].bit13 = "Not Defined";
                                pvalues[1].bit13hfname = hf_bit13lflags;
                                pvalues[1].bit14 = "Not Defined";
                                pvalues[1].bit14hfname = hf_bit14lflags;
                                pvalues[1].bit15 = "Not Defined";
                                pvalues[1].bit15hfname = hf_bit15lflags;
                                pvalues[1].bit16 = "Not Defined";
                                pvalues[1].bit16hfname = hf_bit16lflags;
                                foffset = foffset+pvalues[1].vlength;
                                foffset += 2;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_iteration;
                                foffset = foffset+pvalues[2].vlength;
                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[3].vtype = VTYPE_UINT32;
                                pvalues[3].vdesc = "Parent ID: 0x%08x";
                                pvalues[3].vlength = 4;
                                pvalues[3].voffset = foffset;
                                pvalues[3].hfname= hf_nds_parent;
                                foffset = foffset+pvalues[3].vlength;
                                pvalues[4].vvalue = tvb_get_letohs(tvb, foffset);
                                global_flags = tvb_get_letohl(tvb, foffset);
                                pvalues[4].vtype = VTYPE_BITFIELD;
                                pvalues[4].vdesc = "Information Flags (low) Byte:";
                                pvalues[4].vlength = 2;
                                pvalues[4].hfname= hf_nds_rflags;
                                pvalues[4].voffset = foffset;
                                pvalues[4].bit1 = "Output Flags";
                                pvalues[4].bit1hfname = hf_bit1infoflagsl;
                                pvalues[4].bit2 = "Entry ID";
                                pvalues[4].bit2hfname = hf_bit2infoflagsl;
                                pvalues[4].bit3 = "Entry Flags";
                                pvalues[4].bit3hfname = hf_bit3infoflagsl;
                                pvalues[4].bit4 = "Subordinate Count";
                                pvalues[4].bit4hfname = hf_bit4infoflagsl;
                                pvalues[4].bit5 = "Modification Time";
                                pvalues[4].bit5hfname = hf_bit5infoflagsl;
                                pvalues[4].bit6 = "Modification Timestamp";
                                pvalues[4].bit6hfname = hf_bit6infoflagsl;
                                pvalues[4].bit7 = "Creation Timestamp";
                                pvalues[4].bit7hfname = hf_bit7infoflagsl;
                                pvalues[4].bit8 = "Partition Root ID";
                                pvalues[4].bit8hfname = hf_bit8infoflagsl;
                                pvalues[4].bit9 = "Parent ID";
                                pvalues[4].bit9hfname = hf_bit9infoflagsl;
                                pvalues[4].bit10 = "Revision Count";
                                pvalues[4].bit10hfname = hf_bit10infoflagsl;
                                pvalues[4].bit11 = "Replica Type";
                                pvalues[4].bit11hfname = hf_bit11infoflagsl;
                                pvalues[4].bit12 = "Base Class";
                                pvalues[4].bit12hfname = hf_bit12infoflagsl;
                                pvalues[4].bit13 = "Relative Distinguished Name";
                                pvalues[4].bit13hfname = hf_bit13infoflagsl;
                                pvalues[4].bit14 = "Distinguished Name";
                                pvalues[4].bit14hfname = hf_bit14infoflagsl;
                                pvalues[4].bit15 = "Root Distinguished Name";
                                pvalues[4].bit15hfname = hf_bit15infoflagsl;
                                pvalues[4].bit16 = "Parent Distinguished Name";
                                pvalues[4].bit16hfname = hf_bit16infoflagsl;
                                foffset = foffset+2;
                                pvalues[5].vvalue = tvb_get_letohs(tvb, foffset);
                                pvalues[5].vtype = VTYPE_BITFIELD;
                                pvalues[5].vdesc = "Information Flags (high) Byte:";
                                pvalues[5].vlength = 2;
                                pvalues[5].hfname= hf_nds_rflags;
                                pvalues[5].voffset = foffset;
                                pvalues[5].bit1 = "Purge Time";
                                pvalues[5].bit1hfname = hf_bit1infoflagsh;
                                pvalues[5].bit2 = "Dereference Base Class";
                                pvalues[5].bit2hfname = hf_bit2infoflagsh;
                                pvalues[5].bit3 = "Not Defined";
                                pvalues[5].bit3hfname = hf_bit3infoflagsh;
                                pvalues[5].bit4 = "Not Defined";
                                pvalues[5].bit4hfname = hf_bit4infoflagsh;
                                pvalues[5].bit5 = "Not Defined";
                                pvalues[5].bit5hfname = hf_bit5infoflagsh;
                                pvalues[5].bit6 = "Not Defined";
                                pvalues[5].bit6hfname = hf_bit6infoflagsh;
                                pvalues[5].bit7 = "Not Defined";
                                pvalues[5].bit7hfname = hf_bit7infoflagsh;
                                pvalues[5].bit8 = "Not Defined";
                                pvalues[5].bit8hfname = hf_bit8infoflagsh;
                                pvalues[5].bit9 = "Not Defined";
                                pvalues[5].bit9hfname = hf_bit9infoflagsh;
                                pvalues[5].bit10 = "Not Defined";
                                pvalues[5].bit10hfname = hf_bit10infoflagsh;
                                pvalues[5].bit11 = "Not Defined";
                                pvalues[5].bit11hfname = hf_bit11infoflagsh;
                                pvalues[5].bit12 = "Not Defined";
                                pvalues[5].bit12hfname = hf_bit12infoflagsh;
                                pvalues[5].bit13 = "Not Defined";
                                pvalues[5].bit13hfname = hf_bit13infoflagsh;
                                pvalues[5].bit14 = "Not Defined";
                                pvalues[5].bit14hfname = hf_bit14infoflagsh;
                                pvalues[5].bit15 = "Not Defined";
                                pvalues[5].bit15hfname = hf_bit15infoflagsh;
                                pvalues[5].bit16 = "Not Defined";
                                pvalues[5].bit16hfname = hf_bit16infoflagsh;
                                foffset = foffset+2;
                                pvalues[6].vtype = VTYPE_STRING;
                                pvalues[6].vdesc = "Name Filter: %s";
                                pvalues[6].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[6].vvalue = 0;
                                pvalues[6].vlength = 256;
                                pvalues[6].vlength = tvb_get_letohl(tvb, foffset);
                                pvalues[6].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[6].voffset, pvalues[6].vlength, pvalues[6].vstring);
                                pvalues[6].hfname= hf_nds_name_filter;
                                foffset = foffset+pvalues[6].vlength;
                                if(pvalues[0].vvalue == 0)
                                {
                                        break;
                                }        
                                foffset += align_4(tvb, foffset);
                                pvalues[7].vtype = VTYPE_STRING;
                                pvalues[7].vdesc = "Class Filter: %s";
                                pvalues[7].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[7].vvalue = 0;
                                pvalues[7].vlength = 256;
                                pvalues[7].vlength = tvb_get_letohl(tvb, foffset);
                                pvalues[7].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[7].voffset, pvalues[7].vlength, pvalues[7].vstring);
                                pvalues[7].hfname= hf_nds_class_filter;
                                foffset = foffset+pvalues[7].vlength;
                                if(pvalues[0].vvalue == 1)
                                {
                                        break;
                                }        
                                foffset += align_4(tvb, foffset);
                                pvalues[8].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[8].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[8].vdesc = "Seconds: %u";
                                pvalues[8].vlength = 4;
                                pvalues[8].mvtype = MVTYPE_PRINT_TIMESTAMP;
                                pvalues[8].hfname= hf_nds_time_filter;
                                pvalues[8].voffset = foffset;
                                break;
                        case 0x06:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vstring = "";
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vstring = "";
                                pvalues[1].vdesc = "Request Flags: 0x%08x"; 
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname= hf_nds_rflags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+4;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_iteration;
                                foffset = foffset+pvalues[2].vlength;
                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[3].vstring = "";
                                pvalues[3].vtype = VTYPE_UINT32;
                                pvalues[3].vdesc = "Base Entry ID: 0x%08x";
                                pvalues[3].vlength = 4;
                                resolve_eid = FALSE;
                                global_eid = pvalues[3].vvalue;
                                pvalues[3].voffset = foffset;
                                pvalues[3].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[3].vlength;
                                pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[4].vstring = (char *)match_strval(pvalues[4].vvalue, nds_search_scope);
                                if(pvalues[4].vstring == NULL)
                                {
                                        pvalues[4].vstring = "No Search Scope Defined";
                                }
                                pvalues[4].vtype = VTYPE_STRING;
                                pvalues[4].vdesc = "Replica Type: %s";
                                pvalues[4].vlength = 4;
                                pvalues[4].voffset = foffset;
                                pvalues[4].mvtype = 0;
                                pvalues[4].hfname= hf_nds_search_scope;
                                foffset = foffset + pvalues[4].vlength;
                                pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[5].vtype = VTYPE_UINT32;
                                pvalues[5].vdesc = "Number of Objects to Search: 0x%08x";
                                pvalues[5].vlength = 4;
                                pvalues[5].voffset = foffset;
                                pvalues[5].hfname= hf_nds_num_objects;
                                foffset = foffset+pvalues[5].vlength;
                                pvalues[6].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[6].vtype = VTYPE_BITFIELD;
                                pvalues[6].vdesc = "Information Types:";
                                pvalues[6].vlength = 2;
                                pvalues[6].hfname= hf_nds_nflags;
                                pvalues[6].voffset = foffset;
                                pvalues[6].bit1 = "Names";
                                pvalues[6].bit1hfname = hf_bit1siflags;
                                pvalues[6].bit2 = "Names and Values";
                                pvalues[6].bit2hfname = hf_bit2siflags;
                                pvalues[6].bit3 = "Effective Privileges";
                                pvalues[6].bit3hfname = hf_bit3siflags;
                                pvalues[6].bit4 = "Value Info";
                                pvalues[6].bit4hfname = hf_bit4siflags;
                                pvalues[6].bit5 = "Abbreviated Value";
                                pvalues[6].bit5hfname = hf_bit5siflags;
                                pvalues[6].bit6 = "Not Defined";
                                pvalues[6].bit6hfname = hf_bit6siflags;
                                pvalues[6].bit7 = "Not Defined";
                                pvalues[6].bit7hfname = hf_bit7siflags;
                                pvalues[6].bit8 = "Not Defined";
                                pvalues[6].bit8hfname = hf_bit8siflags;
                                pvalues[6].bit9 = "Expanded Class";
                                pvalues[6].bit9hfname = hf_bit9siflags;
                                pvalues[6].bit10 = "Not Defined";
                                pvalues[6].bit10hfname = hf_bit10siflags;
                                pvalues[6].bit11= "Not Defined";
                                pvalues[6].bit11hfname = hf_bit11siflags;
                                pvalues[6].bit12 = "Not Defined";
                                pvalues[6].bit12hfname = hf_bit12siflags;
                                pvalues[6].bit13 = "Not Defined";
                                pvalues[6].bit13hfname = hf_bit13siflags;
                                pvalues[6].bit14 = "Not Defined";
                                pvalues[6].bit14hfname = hf_bit14siflags;
                                pvalues[6].bit15 = "Not Defined";
                                pvalues[6].bit15hfname = hf_bit15siflags;
                                pvalues[6].bit16 = "Not Defined";
                                pvalues[6].bit16hfname = hf_bit16siflags;
                                foffset = foffset+4;
                                if(pvalues[0].vvalue != 2)
                                {
                                        pvalues[7].vvalue = tvb_get_letohs(tvb, foffset);
                                        global_flags = tvb_get_letohl(tvb, foffset);
                                        pvalues[7].vtype = VTYPE_BITFIELD;
                                        pvalues[7].vdesc = "Information Flags (low) Byte:";
                                        pvalues[7].vlength = 2;
                                        pvalues[7].hfname= hf_nds_rflags;
                                        pvalues[7].voffset = foffset;
                                        pvalues[7].bit1 = "Output Flags";
                                        pvalues[7].bit1hfname = hf_bit1infoflagsl;
                                        pvalues[7].bit2 = "Entry ID";
                                        pvalues[7].bit2hfname = hf_bit2infoflagsl;
                                        pvalues[7].bit3 = "Entry Flags";
                                        pvalues[7].bit3hfname = hf_bit3infoflagsl;
                                        pvalues[7].bit4 = "Subordinate Count";
                                        pvalues[7].bit4hfname = hf_bit4infoflagsl;
                                        pvalues[7].bit5 = "Modification Time";
                                        pvalues[7].bit5hfname = hf_bit5infoflagsl;
                                        pvalues[7].bit6 = "Modification Timestamp";
                                        pvalues[7].bit6hfname = hf_bit6infoflagsl;
                                        pvalues[7].bit7 = "Creation Timestamp";
                                        pvalues[7].bit7hfname = hf_bit7infoflagsl;
                                        pvalues[7].bit8 = "Partition Root ID";
                                        pvalues[7].bit8hfname = hf_bit8infoflagsl;
                                        pvalues[7].bit9 = "Parent ID";
                                        pvalues[7].bit9hfname = hf_bit9infoflagsl;
                                        pvalues[7].bit10 = "Revision Count";
                                        pvalues[7].bit10hfname = hf_bit10infoflagsl;
                                        pvalues[7].bit11 = "Replica Type";
                                        pvalues[7].bit11hfname = hf_bit11infoflagsl;
                                        pvalues[7].bit12 = "Base Class";
                                        pvalues[7].bit12hfname = hf_bit12infoflagsl;
                                        pvalues[7].bit13 = "Relative Distinguished Name";
                                        pvalues[7].bit13hfname = hf_bit13infoflagsl;
                                        pvalues[7].bit14 = "Distinguished Name";
                                        pvalues[7].bit14hfname = hf_bit14infoflagsl;
                                        pvalues[7].bit15 = "Root Distinguished Name";
                                        pvalues[7].bit15hfname = hf_bit15infoflagsl;
                                        pvalues[7].bit16 = "Parent Distinguished Name";
                                        pvalues[7].bit16hfname = hf_bit16infoflagsl;
                                        foffset = foffset+2;
                                        pvalues[8].vvalue = tvb_get_letohs(tvb, foffset);
                                        pvalues[8].vtype = VTYPE_BITFIELD;
                                        pvalues[8].vdesc = "Information Flags (high) Byte:";
                                        pvalues[8].vlength = 2;
                                        pvalues[8].hfname= hf_nds_rflags;
                                        pvalues[8].voffset = foffset;
                                        pvalues[8].bit1 = "Purge Time";
                                        pvalues[8].bit1hfname = hf_bit1infoflagsh;
                                        pvalues[8].bit2 = "Dereference Base Class";
                                        pvalues[8].bit2hfname = hf_bit2infoflagsh;
                                        pvalues[8].bit3 = "Not Defined";
                                        pvalues[8].bit3hfname = hf_bit3infoflagsh;
                                        pvalues[8].bit4 = "Not Defined";
                                        pvalues[8].bit4hfname = hf_bit4infoflagsh;
                                        pvalues[8].bit5 = "Not Defined";
                                        pvalues[8].bit5hfname = hf_bit5infoflagsh;
                                        pvalues[8].bit6 = "Not Defined";
                                        pvalues[8].bit6hfname = hf_bit6infoflagsh;
                                        pvalues[8].bit7 = "Not Defined";
                                        pvalues[8].bit7hfname = hf_bit7infoflagsh;
                                        pvalues[8].bit8 = "Not Defined";
                                        pvalues[8].bit8hfname = hf_bit8infoflagsh;
                                        pvalues[8].bit9 = "Not Defined";
                                        pvalues[8].bit9hfname = hf_bit9infoflagsh;
                                        pvalues[8].bit10 = "Not Defined";
                                        pvalues[8].bit10hfname = hf_bit10infoflagsh;
                                        pvalues[8].bit11 = "Not Defined";
                                        pvalues[8].bit11hfname = hf_bit11infoflagsh;
                                        pvalues[8].bit12 = "Not Defined";
                                        pvalues[8].bit12hfname = hf_bit12infoflagsh;
                                        pvalues[8].bit13 = "Not Defined";
                                        pvalues[8].bit13hfname = hf_bit13infoflagsh;
                                        pvalues[8].bit14 = "Not Defined";
                                        pvalues[8].bit14hfname = hf_bit14infoflagsh;
                                        pvalues[8].bit15 = "Not Defined";
                                        pvalues[8].bit15hfname = hf_bit15infoflagsh;
                                        pvalues[8].bit16 = "Not Defined";
                                        pvalues[8].bit16hfname = hf_bit16infoflagsh;
                                        foffset = foffset+2;
                                }
                                break;
                        case 0x07:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vstring = "";
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vstring = "";
                                pvalues[1].vdesc = "Request Flags: 0x%08x"; 
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname= hf_nds_rflags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+4;
                                if(pvalues[0].vvalue == 0)
                                {
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].vstring = "";
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Parent Entry ID: 0x%08x";
                                        pvalues[2].vlength = 4;
                                        resolve_eid = FALSE;
                                        global_eid = pvalues[2].vvalue;
                                        pvalues[2].voffset = foffset;
                                        pvalues[2].hfname= hf_nds_eid;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vtype = VTYPE_STRING;
                                        pvalues[3].vdesc = "Relative Distinguished Name: %s";
                                        pvalues[3].vstring = "";
                                        pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[3].vvalue = 0;
                                        pvalues[3].vlength = 256;
                                        pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                        if (pvalues[3].vlength == 0x00)
                                        {
                                                pvalues[3].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[3].voffset = foffset+4;
                                        foffset = foffset + 4;
                                        get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, req_buffer.buffer);
                                        pvalues[3].vstring = req_buffer.buffer;
                                        strcpy(global_object_name, req_buffer.buffer);
                                        pvalues[3].hfname= hf_nds_relative_dn;
                                        foffset = foffset+pvalues[3].vlength;
                                        foffset += align_4(tvb, foffset);
                                        pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[4].vstring = "";
                                        pvalues[4].vdesc = "Attributes: %u";
                                        pvalues[4].vlength = 4;
                                        pvalues[4].voffset = foffset;
                                        pvalues[4].mvtype = MVTYPE_ADD_ATTR_REQUEST;
                                        pvalues[4].hfname= hf_nds_attr;
                                }
                                else
                                {
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].vstring = "";
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Iteration Handle: 0x%08x";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = foffset;
                                        pvalues[2].hfname= hf_nds_iteration;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vstring = "";
                                        pvalues[3].vtype = VTYPE_UINT32;
                                        pvalues[3].vdesc = "Parent Entry ID: 0x%08x";
                                        pvalues[3].vlength = 4;
                                        resolve_eid = FALSE;
                                        global_eid = pvalues[3].vvalue;
                                        pvalues[3].voffset = foffset;
                                        pvalues[3].hfname= hf_nds_eid;
                                        foffset = foffset+pvalues[3].vlength;
                                        pvalues[4].vtype = VTYPE_STRING;
                                        pvalues[4].vdesc = "Relative Distinguished Name: %s";
                                        pvalues[4].vstring = "";
                                        pvalues[4].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[4].vvalue = 0;
                                        pvalues[4].vlength = 256;
                                        pvalues[4].vlength = tvb_get_letohl(tvb, foffset);
                                        if (pvalues[4].vlength == 0x00)
                                        {
                                                pvalues[4].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[4].voffset = foffset+4;
                                        foffset = foffset + 4;
                                        get_string(tvb, pvalues[4].voffset, pvalues[4].vlength, req_buffer.buffer);
                                        pvalues[4].vstring = req_buffer.buffer;
                                        strcpy(global_object_name, req_buffer.buffer);
                                        pvalues[4].hfname= hf_nds_relative_dn;
                                        foffset = foffset+pvalues[4].vlength;
                                        foffset += align_4(tvb, foffset);
                                        pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[5].vstring = "";
                                        pvalues[5].vdesc = "Attributes: %u";
                                        pvalues[5].vlength = 4;
                                        pvalues[5].voffset = foffset;
                                        pvalues[5].mvtype = MVTYPE_ADD_ATTR_REQUEST;
                                        pvalues[5].hfname= hf_nds_attr;
                                }
                                break;
                        case 0x08:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                pvalues[1].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[1].vvalue;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[1].vlength;
                                break;
                        case 0x09:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                if(pvalues[0].vvalue == 0)
                                {
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[1].vtype = VTYPE_UINT32;
                                        pvalues[1].vstring = "";
                                        pvalues[1].vdesc = "Iteration Handle: 0x%08x";  /* always 0 */
                                        pvalues[1].vlength = 4;
                                        pvalues[1].hfname= hf_nds_iteration;
                                        pvalues[1].voffset = foffset;
                                        foffset = foffset+4;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].vstring = "";
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vdesc = "Entry ID: 0x%08x";
                                        pvalues[2].vlength = 4;
                                        pvalues[2].voffset = foffset;
                                        resolve_eid = TRUE;
                                        global_eid = pvalues[2].vvalue;
                                        pvalues[2].hfname = hf_nds_eid;
                                        foffset = foffset+pvalues[2].vlength;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[3].vstring = "";
                                        pvalues[3].vdesc = "Number of Attributes to Change %u";
                                        pvalues[3].vlength = 4;
                                        pvalues[3].mvtype = MVTYPE_MODIFY_ATTR_REQUEST;
                                        pvalues[3].hfname= hf_nds_number_of_changes;
                                        pvalues[3].voffset = foffset;
                                }
                                else
                                {
                                        pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[1].vtype = VTYPE_UINT32;
                                        pvalues[1].vstring = "";
                                        pvalues[1].vdesc = "Request Flags: 0x%08x";  /* always 0 */
                                        pvalues[1].vlength = 4;
                                        pvalues[1].hfname= hf_nds_rflags;
                                        pvalues[1].voffset = foffset;
                                        foffset = foffset+4;
                                        pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[2].vtype = VTYPE_UINT32;
                                        pvalues[2].vstring = "";
                                        pvalues[2].vdesc = "Iteration Handle: 0x%08x";  /* always 0 */
                                        pvalues[2].vlength = 4;
                                        pvalues[2].hfname= hf_nds_iteration;
                                        pvalues[2].voffset = foffset;
                                        foffset = foffset+4;
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vstring = "";
                                        pvalues[3].vtype = VTYPE_UINT32;
                                        pvalues[3].vdesc = "Entry ID: 0x%08x";
                                        pvalues[3].vlength = 4;
                                        pvalues[3].voffset = foffset;
                                        resolve_eid = TRUE;
                                        global_eid = pvalues[3].vvalue;
                                        pvalues[3].hfname = hf_nds_eid;
                                        foffset = foffset+pvalues[3].vlength;
                                        pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32;
                                        pvalues[4].vstring = "";
                                        pvalues[4].vdesc = "Number of Attributes to Change %u";
                                        pvalues[4].vlength = 4;
                                        pvalues[4].mvtype = MVTYPE_MODIFY_ATTR_REQUEST;
                                        pvalues[4].hfname= hf_nds_number_of_changes;
                                        pvalues[4].voffset = foffset;
                                }
                                break;
                        case 0x0a:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                pvalues[1].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[1].vvalue;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname = hf_nds_eid;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_BOOLEAN;
                                pvalues[2].vdesc = "Keep Original RDN: %s";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].mvtype = 0;
                                pvalues[2].hfname= hf_nds_keep;
                                foffset = foffset+4;
                                foffset += align_4(tvb, foffset);
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "New RDN: %s";
                                pvalues[3].mvtype = 0;
                                pvalues[3].vvalue = 0;
                                pvalues[3].vlength = 256;
                                pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                pvalues[3].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
                                pvalues[3].hfname= hf_nds_new_rdn;
                                foffset = foffset+pvalues[3].vlength;
                                break;
                        case 0x0b:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohs(tvb, foffset);
                                global_flags = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_BITFIELD;
                                pvalues[1].vdesc = "Attribute Constraints:";
                                pvalues[1].vlength = 2;
                                pvalues[1].hfname= hf_nds_acflags;
                                pvalues[1].voffset = foffset;
                                pvalues[1].bit1 = "Single Valued";
                                pvalues[1].bit1hfname = hf_bit1acflags;
                                pvalues[1].bit2 = "Sized";
                                pvalues[1].bit2hfname = hf_bit2acflags;
                                pvalues[1].bit3 = "Non-Removable";
                                pvalues[1].bit3hfname = hf_bit3acflags;
                                pvalues[1].bit4 = "Read Only";
                                pvalues[1].bit4hfname = hf_bit4acflags;
                                pvalues[1].bit5 = "Hidden";
                                pvalues[1].bit5hfname = hf_bit5acflags;
                                pvalues[1].bit6 = "String";
                                pvalues[1].bit6hfname = hf_bit6acflags;
                                pvalues[1].bit7 = "Synchronize Immediate";
                                pvalues[1].bit7hfname = hf_bit7acflags;
                                pvalues[1].bit8 = "Public Read";
                                pvalues[1].bit8hfname = hf_bit8acflags;
                                pvalues[1].bit9 = "Server Read";
                                pvalues[1].bit9hfname = hf_bit9acflags;
                                pvalues[1].bit10 = "Write Managed";
                                pvalues[1].bit10hfname = hf_bit10acflags;
                                pvalues[1].bit11 = "Per Replica";
                                pvalues[1].bit11hfname = hf_bit11acflags;
                                pvalues[1].bit12 = "Never Schedule Synchronization";
                                pvalues[1].bit12hfname = hf_bit12acflags;
                                pvalues[1].bit13 = "Operational";
                                pvalues[1].bit13hfname = hf_bit13acflags;
                                pvalues[1].bit14 = "Not Defined";
                                pvalues[1].bit14hfname = hf_bit14acflags;
                                pvalues[1].bit15 = "Not Defined";
                                pvalues[1].bit15hfname = hf_bit15acflags;
                                pvalues[1].bit16 = "Not Defined";
                                pvalues[1].bit16hfname = hf_bit16acflags;
                                foffset = foffset+4;
                                pvalues[2].vtype = VTYPE_STRING;
                                pvalues[2].vdesc = "Attribute Name: %s";
                                pvalues[2].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[2].vvalue = 0;
                                pvalues[2].vlength = 256;
                                pvalues[2].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[2].vlength == 0x00)
                                {
                                        pvalues[2].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[2].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[2].voffset, pvalues[2].vlength, req_buffer.buffer);
                                pvalues[2].vstring = req_buffer.buffer;
                                strcpy(global_object_name, req_buffer.buffer);
                                pvalues[2].hfname= hf_nds_name;
                                foffset = foffset+pvalues[2].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, nds_syntax);
                                if(pvalues[3].vstring == NULL)
                                {
                                        pvalues[3].vstring = "No Syntax Found";
                                }
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "Syntax: %s";
                                pvalues[3].vlength = 4;
                                pvalues[3].voffset = foffset;
                                pvalues[3].hfname= hf_nds_syntax;
                                pvalues[3].mvtype = 0;
                                foffset = foffset+pvalues[3].vlength;
                                pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[4].vtype = VTYPE_UINT32;
                                pvalues[4].vdesc = "Lower Limit Value %u";
                                pvalues[4].vlength = 4;
                                pvalues[4].voffset = foffset;
                                pvalues[4].hfname = hf_nds_lower;
                                foffset += 4;
                                pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[5].vtype = VTYPE_UINT32;
                                pvalues[5].vdesc = "Upper Limit Value %u";
                                pvalues[5].vlength = 4;
                                pvalues[5].voffset = foffset;
                                pvalues[5].hfname = hf_nds_upper;
                                foffset += 4;
                                pvalues[6].vvalue = tvb_get_letohl(tvb, foffset); /* Length of bytes field */
                                foffset += 4;
                                pvalues[6].vtype = VTYPE_BYTES;
                                pvalues[6].vdesc = "ASN.1 ID";
                                pvalues[6].vlength = pvalues[6].vvalue;
                                pvalues[6].voffset = foffset;
                                pvalues[6].hfname = hf_nds_asn1;
                                break;
                        case 0x0c:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x0d:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vtype = VTYPE_STRING;
                                pvalues[1].vdesc = "Attribute Name: %s";
                                pvalues[1].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[1].vvalue = 0;
                                pvalues[1].vlength = 256;
                                pvalues[1].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[1].vlength == 0x00)
                                {
                                        pvalues[1].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[1].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, req_buffer.buffer);
                                pvalues[1].vstring = req_buffer.buffer;
                                strcpy(global_object_name, req_buffer.buffer);
                                pvalues[1].hfname= hf_nds_attribute_dn;
                                break;
                        case 0x0e:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x0f:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_iteration;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                global_flags = pvalues[2].vvalue;
                                pvalues[2].vstring = (char *)match_strval(pvalues[2].vvalue, class_def_type);
                                if(pvalues[2].vstring == NULL)
                                {
                                        pvalues[2].vstring = "No Class Definition Type Set";
                                }
                                pvalues[2].vtype = VTYPE_STRING;
                                pvalues[2].vdesc = "Class Definition Type: %s";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].mvtype = 0;
                                pvalues[2].hfname= hf_nds_class_def_type;
                                foffset = foffset + pvalues[2].vlength;
                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                if (pvalues[3].vvalue == 0x00000000)
                                {
                                        pvalues[3].vstring = "Do Not Return All Classes";
                                        pvalues[3].mvtype = 0;
                                }        
                                else
                                {
                                        pvalues[3].vstring = "Return All Classes";
                                        pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
                                }
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "%s";
                                pvalues[3].vlength = 4;
                                pvalues[3].voffset = foffset;
                                pvalues[3].hfname= hf_nds_return_all_classes;
                                foffset = foffset + pvalues[3].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[4].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[4].vdesc = "Classes: %d";
                                pvalues[4].vlength = 4;
                                pvalues[4].voffset = foffset;
                                pvalues[4].mvtype = MVTYPE_READ_CLASS_REQ;
                                pvalues[4].hfname= hf_nds_classes;
                                break;
                        case 0x10:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vtype = VTYPE_STRING;
                                pvalues[1].vdesc = "Class Name: %s";
                                pvalues[1].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[1].vvalue = 0;
                                pvalues[1].vlength = 256;
                                pvalues[1].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[1].vlength == 0x00)
                                {
                                        pvalues[1].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[1].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, req_buffer.buffer);
                                pvalues[1].vstring = req_buffer.buffer;
                                strcpy(global_object_name, req_buffer.buffer);
                                pvalues[1].hfname= hf_nds_base_class;
                                foffset = foffset+pvalues[1].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32;
                                pvalues[2].vdesc = "Number of Attributes to Add: %u";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].mvtype = MVTYPE_MODIFY_CLASS;
                                pvalues[2].hfname= hf_nds_att_add;
                                break;
                        case 0x11:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vtype = VTYPE_STRING;
                                pvalues[1].vdesc = "Class Name: %s";
                                pvalues[1].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[1].vvalue = 0;
                                pvalues[1].vlength = 256;
                                pvalues[1].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[1].vlength == 0x00)
                                {
                                        pvalues[1].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[1].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, req_buffer.buffer);
                                pvalues[1].vstring = req_buffer.buffer;
                                strcpy(global_object_name, req_buffer.buffer);
                                pvalues[1].hfname= hf_nds_base;
                                break;
                        case 0x12:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_iteration;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Entry ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[2].vvalue;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[2].vlength;
                                break;
                        case 0x13:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                pvalues[1].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[1].vvalue;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vtype = VTYPE_STRING;
                                pvalues[2].vdesc = "Trustee Name: %s";
                                pvalues[2].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[2].vvalue = 0;
                                pvalues[2].vlength = 256;
                                pvalues[2].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[2].vlength == 0x00)
                                {
                                        pvalues[2].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[2].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[2].voffset, pvalues[2].vlength, req_buffer.buffer);
                                pvalues[2].vstring = req_buffer.buffer;
                                pvalues[2].hfname= hf_nds_name;
                                foffset = foffset+pvalues[2].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "Attribute to be Checked: %s";
                                pvalues[3].mvtype = 0;
                                pvalues[3].vvalue = 0;
                                pvalues[3].vlength = 256;
                                pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[3].vlength == 0x00)
                                {
                                        pvalues[3].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[3].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
                                pvalues[3].hfname= hf_nds_name;
                                foffset = foffset+pvalues[3].vlength;
                                foffset += align_4(tvb, foffset);
                                if(pvalues[0].vvalue != 0)
                                {
                                        pvalues[4].vtype = VTYPE_STRING;
                                        pvalues[4].vdesc = "Security Equivalence: %s";
                                        pvalues[4].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[4].vvalue = 0;
                                        pvalues[4].vlength = 256;
                                        pvalues[4].vlength = tvb_get_letohl(tvb, foffset);
                                        if (pvalues[4].vlength == 0x00)
                                        {
                                                pvalues[4].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[4].voffset = foffset+4;
                                        foffset = foffset + 4;
                                        get_string(tvb, pvalues[4].voffset, pvalues[4].vlength, pvalues[4].vstring);
                                        pvalues[4].hfname= hf_nds_name;
                                        foffset = foffset+pvalues[4].vlength;
                                        foffset += align_4(tvb, foffset);
                                }
                                break;
                        case 0x14:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x15:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x16:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_BITFIELD;
                                pvalues[1].vdesc = "Request Flags:";
                                pvalues[1].vlength = 2;
                                pvalues[1].hfname= hf_nds_rflags;
                                pvalues[1].voffset = foffset;
                                pvalues[1].bit1 = "Typeless";
                                pvalues[1].bit1hfname = hf_nds_bit1;
                                pvalues[1].bit2 = "All Containers";
                                pvalues[1].bit2hfname = hf_nds_bit2;
                                pvalues[1].bit3 = "Slashed";
                                pvalues[1].bit3hfname = hf_nds_bit3;
                                pvalues[1].bit4 = "Dotted";
                                pvalues[1].bit4hfname = hf_nds_bit4;
                                pvalues[1].bit5 = "Tuned";
                                pvalues[1].bit5hfname = hf_nds_bit5;
                                pvalues[1].bit6 = "Not Defined";
                                pvalues[1].bit6hfname = hf_nds_bit6;
                                pvalues[1].bit7 = "Not Defined";
                                pvalues[1].bit7hfname = hf_nds_bit7;
                                pvalues[1].bit8 = "Not Defined";
                                pvalues[1].bit8hfname = hf_nds_bit8;
                                pvalues[1].bit9 = "Not Defined";
                                pvalues[1].bit9hfname = hf_nds_bit9;
                                pvalues[1].bit10 = "Not Defined";
                                pvalues[1].bit10hfname = hf_nds_bit10;
                                pvalues[1].bit11 = "Not Defined";
                                pvalues[1].bit11hfname = hf_nds_bit11;
                                pvalues[1].bit12 = "Not Defined";
                                pvalues[1].bit12hfname = hf_nds_bit12;
                                pvalues[1].bit13 = "Not Defined";
                                pvalues[1].bit13hfname = hf_nds_bit13;
                                pvalues[1].bit14 = "Not Defined";
                                pvalues[1].bit14hfname = hf_nds_bit14;
                                pvalues[1].bit15 = "Not Defined";
                                pvalues[1].bit15hfname = hf_nds_bit15;
                                pvalues[1].bit16 = "Not Defined";
                                pvalues[1].bit16hfname = hf_nds_bit16;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Iteration Handle: 0x%08x";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_iteration;
                                foffset = foffset+pvalues[2].vlength;
                                if(pvalues[0].vvalue == 0)
                                {
                                        global_flags = 0x000000c0;
                                        break;
                                }
                                pvalues[3].vvalue = tvb_get_letohs(tvb, foffset);
                                pvalues[3].vtype = VTYPE_BITFIELD;
                                pvalues[3].vdesc = "Information Flags (low) Byte:";
                                pvalues[3].vlength = 2;
                                pvalues[3].hfname= hf_nds_rflags;
                                pvalues[3].voffset = foffset;
                                pvalues[3].bit1 = "Output Flags";
                                pvalues[3].bit1hfname = hf_bit1l1flagsl;
                                pvalues[3].bit2 = "Entry ID";
                                pvalues[3].bit2hfname = hf_bit2l1flagsl;
                                pvalues[3].bit3 = "Replica State";
                                pvalues[3].bit3hfname = hf_bit3l1flagsl;
                                pvalues[3].bit4 = "Modification Timestamp";
                                pvalues[3].bit4hfname = hf_bit4l1flagsl;
                                pvalues[3].bit5 = "Purge Time";
                                pvalues[3].bit5hfname = hf_bit5l1flagsl;
                                pvalues[3].bit6 = "Local Partition ID";
                                pvalues[3].bit6hfname = hf_bit6l1flagsl;
                                pvalues[3].bit7 = "Distinguished Name";
                                pvalues[3].bit7hfname = hf_bit7l1flagsl;
                                pvalues[3].bit8 = "Replica Type";
                                pvalues[3].bit8hfname = hf_bit8l1flagsl;
                                pvalues[3].bit9 = "Partition Busy";
                                pvalues[3].bit9hfname = hf_bit9l1flagsl;
                                pvalues[3].bit10 = "Not Defined";
                                pvalues[3].bit10hfname = hf_bit10l1flagsl;
                                pvalues[3].bit11 = "Not Defined";
                                pvalues[3].bit11hfname = hf_bit11l1flagsl;
                                pvalues[3].bit12 = "Not Defined";
                                pvalues[3].bit12hfname = hf_bit12l1flagsl;
                                pvalues[3].bit13 = "Not Defined";
                                pvalues[3].bit13hfname = hf_bit13l1flagsl;
                                pvalues[3].bit14 = "Not Defined";
                                pvalues[3].bit14hfname = hf_bit14l1flagsl;
                                pvalues[3].bit15 = "Not Defined";
                                pvalues[3].bit15hfname = hf_bit15l1flagsl;
                                pvalues[3].bit16 = "Not Defined";
                                pvalues[3].bit16hfname = hf_bit16l1flagsl;
                                global_flags = pvalues[3].vvalue;
                                foffset = foffset+2;
                                pvalues[4].vvalue = tvb_get_letohs(tvb, foffset);
                                pvalues[4].vtype = VTYPE_BITFIELD;
                                pvalues[4].vdesc = "Information Flags (high) Byte:";
                                pvalues[4].vlength = 2;
                                pvalues[4].hfname= hf_nds_rflags;
                                pvalues[4].voffset = foffset;
                                pvalues[4].bit1 = "Not Defined";
                                pvalues[4].bit1hfname = hf_bit1l1flagsl;
                                pvalues[4].bit2 = "Not Defined";
                                pvalues[4].bit2hfname = hf_bit2l1flagsl;
                                pvalues[4].bit3 = "Not Defined";
                                pvalues[4].bit3hfname = hf_bit3l1flagsl;
                                pvalues[4].bit4 = "Not Defined";
                                pvalues[4].bit4hfname = hf_bit4l1flagsl;
                                pvalues[4].bit5 = "Not Defined";
                                pvalues[4].bit5hfname = hf_bit5l1flagsl;
                                pvalues[4].bit6 = "Not Defined";
                                pvalues[4].bit6hfname = hf_bit6l1flagsl;
                                pvalues[4].bit7 = "Not Defined";
                                pvalues[4].bit7hfname = hf_bit7l1flagsl;
                                pvalues[4].bit8 = "Not Defined";
                                pvalues[4].bit8hfname = hf_bit8l1flagsl;
                                pvalues[4].bit9 = "Not Defined";
                                pvalues[4].bit9hfname = hf_bit9l1flagsl;
                                pvalues[4].bit10 = "Not Defined";
                                pvalues[4].bit10hfname = hf_bit10l1flagsl;
                                pvalues[4].bit11 = "Not Defined";
                                pvalues[4].bit11hfname = hf_bit11l1flagsl;
                                pvalues[4].bit12 = "Not Defined";
                                pvalues[4].bit12hfname = hf_bit12l1flagsl;
                                pvalues[4].bit13 = "Not Defined";
                                pvalues[4].bit13hfname = hf_bit13l1flagsl;
                                pvalues[4].bit14 = "Not Defined";
                                pvalues[4].bit14hfname = hf_bit14l1flagsl;
                                pvalues[4].bit15 = "Not Defined";
                                pvalues[4].bit15hfname = hf_bit15l1flagsl;
                                pvalues[4].bit16 = "Not Defined";
                                pvalues[4].bit16hfname = hf_bit16l1flagsl;
                                foffset = foffset+2;
                                if(pvalues[0].vvalue == 1)
                                {
                                        break;
                                }
                                pvalues[5].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[5].vtype = VTYPE_UINT32;
                                pvalues[5].vdesc = "Partition Root ID: 0x%08x";
                                pvalues[5].vlength = 4;
                                pvalues[5].voffset = foffset;
                                pvalues[5].hfname= hf_nds_partition_root_id;
                                foffset = foffset+pvalues[5].vlength;
                                break;
                        case 0x17:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Flags: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_req_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "New Partition Root ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_new_part_id;
                                foffset = foffset+pvalues[2].vlength;
                                break;
                        case 0x18:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Flags: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_req_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Child Partition Root ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_child_part_id;
                                foffset = foffset+pvalues[2].vlength;
                                break;
                        case 0x19:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Flags: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_req_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Master Partition Root ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_master_part_id;
                                foffset = foffset+pvalues[2].vlength;
                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, nds_replica_type);
                                if(pvalues[3].vstring == NULL)
                                {
                                        pvalues[3].vstring = "No Replica Type Found";
                                }
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "Replica Type: %s";
                                pvalues[3].vlength = 4;
                                pvalues[3].voffset = foffset;
                                pvalues[3].mvtype = 0;
                                pvalues[3].hfname= hf_replica_type;
                                foffset = foffset + pvalues[3].vlength;
                                pvalues[4].vtype = VTYPE_STRING;
                                pvalues[4].vdesc = "Target Server Name: %s";
                                pvalues[4].mvtype = 0;
                                pvalues[4].vvalue = 0;
                                pvalues[4].vlength = 256;
                                pvalues[4].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[4].vlength == 0x00)
                                {
                                        pvalues[4].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[4].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[4].voffset, pvalues[4].vlength, pvalues[4].vstring);
                                pvalues[4].hfname= hf_nds_target_name;
                                break;
                        case 0x1a:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x1b:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Streams Flags: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_stream_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Entry ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[2].vvalue;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[2].vlength;
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "Stream Name: %s";
                                pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
                                pvalues[3].vvalue = 0;
                                pvalues[3].vlength = 256;
                                pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[3].vlength == 0x00)
                                {
                                        pvalues[3].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[3].voffset = foffset+4;
                                foffset += 4;
                                get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
                                foffset += pvalues[3].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[3].hfname= hf_nds_stream_name;
                                break;
                        case 0x1c:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x1d:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x1e:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x1f:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x20:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x21:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x22:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x23:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x24:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x25:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x26:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Flags: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_req_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Time Delay in Seconds: %u";
                                pvalues[2].vlength = 4;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_time_delay;
                                foffset = foffset+pvalues[2].vlength;
                                if(pvalues[0].vvalue == 0)
                                {
                                        pvalues[3].vtype = VTYPE_STRING;
                                        pvalues[3].vdesc = "Root Most Object Name: %s";
                                        pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
                                        pvalues[3].vvalue = 0;
                                        pvalues[3].vlength = 256;
                                        pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                        if (pvalues[3].vlength == 0x00)
                                        {
                                                pvalues[3].vtype = VTYPE_NONE;
                                                break;
                                        }
                                        pvalues[3].voffset = foffset+4;
                                        foffset += 4;
                                        get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
                                        foffset += pvalues[3].vlength;
                                        foffset += align_4(tvb, foffset);
                                        pvalues[3].hfname= hf_nds_root_name;
                                }
                                else
                                {
                                        pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                        pvalues[3].vtype = VTYPE_UINT32;
                                        pvalues[3].vdesc = "Entry ID: 0x%08x";
                                        pvalues[3].vlength = 4;
                                        resolve_eid = TRUE;
                                        global_eid = pvalues[3].vvalue;
                                        pvalues[3].voffset = foffset;
                                        pvalues[3].hfname= hf_nds_eid;
                                        foffset = foffset+pvalues[3].vlength;
                                        resolve_eid = TRUE;
                                        global_eid = pvalues[3].vvalue;
                                }
                                break;
                        case 0x27:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x28:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x29:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x2a:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Flags: 0x%08x";
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_req_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Destination Parent Entry ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[2].vvalue;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[2].vlength;
                                resolve_eid = TRUE;
                                global_eid = pvalues[2].vvalue;
                                pvalues[3].vtype = VTYPE_STRING;
                                pvalues[3].vdesc = "New RDN: %s";
                                pvalues[3].mvtype = 0;
                                pvalues[3].vvalue = 0;
                                pvalues[3].vlength = 256;
                                pvalues[3].vlength = tvb_get_letohl(tvb, foffset);
                                pvalues[3].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
                                pvalues[3].hfname= hf_nds_new_rdn;
                                foffset = foffset+pvalues[3].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[4].vtype = VTYPE_STRING;
                                pvalues[4].vdesc = "Source Server Name: %s";
                                pvalues[4].mvtype = 0;
                                pvalues[4].vvalue = 0;
                                pvalues[4].vlength = 256;
                                pvalues[4].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[4].vlength == 0x00)
                                {
                                        pvalues[4].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[4].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[4].voffset, pvalues[4].vlength, pvalues[4].vstring);
                                pvalues[4].hfname= hf_nds_target_name;
                                break;
                        case 0x2b:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[0].vvalue;
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].hfname = hf_nds_ver;
                                pvalues[0].voffset = foffset;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                nds_version = pvalues[1].vvalue;
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = (char *)match_strval(pvalues[1].vvalue, nds_verb2b_flag_vals);
                                if(pvalues[1].vdesc == NULL)
                                {
                                        pvalues[1].vdesc = "No Flag Definition Found";
                                }
                                pvalues[1].vlength = 4;
                                pvalues[1].hfname = hf_nds_verb2b_req_flags;
                                pvalues[1].voffset = foffset;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Source Entry ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[2].vvalue;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[2].vlength;
                                pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[3].vtype = VTYPE_UINT32;
                                pvalues[3].vdesc = "Destination Parent Entry ID: 0x%08x";
                                pvalues[3].vlength = 4;
                                pvalues[3].voffset = foffset;
                                pvalues[3].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[3].vlength;
                                pvalues[4].vtype = VTYPE_STRING;
                                pvalues[4].vdesc = "New RDN: %s";
                                pvalues[4].mvtype = 0;
                                pvalues[4].vvalue = 0;
                                pvalues[4].vlength = 256;
                                pvalues[4].vlength = tvb_get_letohl(tvb, foffset);
                                pvalues[4].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[4].voffset, pvalues[4].vlength, pvalues[4].vstring);
                                pvalues[4].hfname= hf_nds_new_rdn;
                                foffset = foffset+pvalues[4].vlength;
                                foffset += align_4(tvb, foffset);
                                pvalues[5].vtype = VTYPE_STRING;
                                pvalues[5].vdesc = "Source Server Name: %s";
                                pvalues[5].mvtype = 0;
                                pvalues[5].vvalue = 0;
                                pvalues[5].vlength = 256;
                                pvalues[5].vlength = tvb_get_letohl(tvb, foffset);
                                if (pvalues[5].vlength == 0x00)
                                {
                                        pvalues[5].vtype = VTYPE_NONE;
                                        break;
                                }
                                pvalues[5].voffset = foffset+4;
                                foffset = foffset + 4;
                                get_string(tvb, pvalues[5].voffset, pvalues[5].vlength, pvalues[5].vstring);
                                pvalues[5].hfname= hf_nds_target_name;
                                break;
                        case 0x2c:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x2d:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x2e:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x2f:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x30:
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x31:
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x32:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x33:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x34:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x35:    
                                pvalues[0].vvalue = 0;
                                break;
                        case 0x36:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x37:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x38:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x39:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                pvalues[1].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[1].vvalue;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[1].vlength;
                                break;
                        case 0x3a:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Reply Buffer Size: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_buffer_size;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Version: %u";
                                pvalues[1].vlength = 4;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[1].vlength;
                                pvalues[2].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[2].vtype = VTYPE_UINT32;
                                pvalues[2].vdesc = "Entry ID: 0x%08x";
                                pvalues[2].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[2].vvalue;
                                pvalues[2].voffset = foffset;
                                pvalues[2].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[2].vlength;
                                break;
                        case 0x3b:    
                                pvalues[0].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[0].vtype = VTYPE_UINT32;
                                pvalues[0].vdesc = "Version: %u";
                                pvalues[0].vlength = 4;
                                pvalues[0].voffset = foffset;
                                pvalues[0].hfname= hf_nds_ver;
                                foffset = foffset+pvalues[0].vlength;
                                pvalues[1].vvalue = tvb_get_letohl(tvb, foffset);
                                pvalues[1].vtype = VTYPE_UINT32;
                                pvalues[1].vdesc = "Entry ID: 0x%08x";
                                pvalues[1].vlength = 4;
                                resolve_eid = TRUE;
                                global_eid = pvalues[1].vvalue;
                                pvalues[1].voffset = foffset;
                                pvalues[1].hfname= hf_nds_eid;
                                foffset = foffset+pvalues[1].vlength;
                                break;
                        case 0x3c:    
                                break;
                        case 0x3d:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x3e:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x3f:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x40:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x41:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x42:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x43:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x44:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x45:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x46:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x47:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x48:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x49:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x4a:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x4b:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x4c:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        case 0x4d:    
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                                break;
                        default:
                                pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
                  }
        }
        /* Fill in the INFO column. */
        if (check_col(pinfo->cinfo, COL_INFO)) {
            if (ncp_rec) {
                        col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDS");
                        if (nds_frag != 0xffffffff) {
                                col_add_fstr(pinfo->cinfo, COL_INFO, "C Continue NDS Fragment %08x", nds_frag);
                        }
                        else {
                              col_add_fstr(pinfo->cinfo, COL_INFO, "C NDS %s", verb_string);
                          }
                          run_info_str = TRUE;
                }
                  else {
                  col_add_fstr(pinfo->cinfo, COL_INFO,
                        "C Unknown Function %d (0x%02x)",
                        func, func);
                  }
                        
        }
        /* Keep track of the address and connection whence the request
           came, and the address and connection to which the request
           is being sent, so that we can match up calls with replies.
           (We don't include the sequence number, as we may want
           to have all packets over the same connection treated
           as being part of a single conversation so that we can
           let the user select that conversation to be displayed.) */

        conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                PT_NCP, nw_connection, nw_connection, 0);
            if (conversation == NULL) {
                  /* It's not part of any conversation - create a new one. */
                  conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                      PT_NCP, nw_connection, nw_connection, 0);
      }
                
      if (!pinfo->fd->flags.visited) {
            request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
            request_value->req_frame_num = pinfo->fd->num;
            request_value->req_frame_time=pinfo->fd->abs_ts;

            /* If this is the first time we're examining the packet,
             * check to see if this NCP type uses a "request condition".
             * If so, we have to build a proto_tree because request conditions
             * use display filters to work, and without a proto_tree,
             * display filters can't possibly work. If we already have
             * a proto_tree, then wonderful. If we don't, we need to build
             * one. */
            if (ncp_rec && !ncp_tree) {
                        run_req_cond = TRUE;
            }
                /* Keep track of the Fragment number in the request for defrag logic */
                request_value->nds_frag_num = nds_frag;
        }
                
      /* If we have to handle a request condition, or have to
         add to the Info column, we need to construct a protocol
         tree.  If we already have a proto_tree, then wonderful.
         If we don't, we need to build one. */
      if ((run_info_str || run_req_cond) && !ncp_tree) {
            proto_item *ti;
                                       
            temp_tree = proto_tree_create_root();
            proto_tree_set_visible(temp_tree, FALSE);
            ti = proto_tree_add_item(temp_tree, proto_ncp, tvb, 0, -1, FALSE);
            ncp_tree = proto_item_add_subtree(ti, ett_ncp);
      }

        if (ncp_tree) {
            /* If the dissection throws an exception, be sure to free
             * the temporary proto_tree that was created. Because of the
             * way the CLEANUP_PUSH macro works, we can't put it in an 'if'
             * block; it has to be in the same scope as the terminating
             * CLEANUP_POP or CLEANUP_POP_AND_ALLOC. So, we always
             * call CLEANUP_POP and friends, but the value of temp_tree is
             * NULL if no cleanup is needed, and non-null if cleanup is needed. 
                 */
            CLEANUP_PUSH(free_proto_tree, temp_tree);
               
#ifdef FAKE_TREE_IS_VISIBLE
            PTREE_DATA(ncp_tree)->visible=1;
#endif

            request_value = ncp_hash_lookup(conversation, sequence);
            switch (type) {
                        case NCP_BROADCAST_SLOT:
                              ; /* nothing */
                              break;
                
                        case NCP_SERVICE_REQUEST:
                        
                        ptvc = ptvcursor_new(ncp_tree, tvb, 7);
                              if (ncp_rec && ncp_rec->request_ptvc)
                                {
                                      clear_repeat_vars();
                                      process_ptvc_record(ptvc, ncp_rec->request_ptvc, NULL, TRUE, ncp_rec);
                                }
                              proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 1,
                                    func, "Function: %d (0x%02X), %s",
                                    func, func, ncp_rec ? ncp_rec->name : "Unknown");
                                                
                        proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 7, 1,
                              subfunc, "SubFunction: %d (0x%02x)",
                              subfunc, subfunc);
                                                
                        proto_tree_add_uint(ncp_tree, hf_ncp_fragment_handle, tvb, 8, 4,
                              nds_frag);
                                                
                                if (nds_frag == 0xffffffff) {
                                        
                              proto_tree_add_item(ncp_tree, hf_ncp_fragment_size, tvb, 12, 4, TRUE);
                                                
                              proto_tree_add_item(ncp_tree, hf_ncp_message_size, tvb, 16, 4, TRUE);
                                        
                              proto_tree_add_item(ncp_tree, hf_ncp_nds_flag, tvb, 20, 4, FALSE);
                                        
                                      proto_tree_add_uint_format(ncp_tree, hf_ncp_nds_verb, tvb, 24, 4,
                                            nds_verb, "NDS Verb: %d, (0x%02x), %s",
                                            nds_verb, nds_verb, verb_string);
                                        added_arrow = FALSE;
                              for (i = 0; i < 9; i++) {
                                    switch (pvalues[i].vtype) {

                                    case VTYPE_NONE: /* no value */
                                          break;

                                    case VTYPE_UINT8:
                                          proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                              pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %d",
                                              pvalues[i].vtype);
                                          break;

                                    case VTYPE_UINT16:
                                          proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                              pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %d",
                                              pvalues[i].vtype);
                                          break;

                                    case VTYPE_UINT32:
                                          proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                              pvalues[i].vlength, pvalues[i].vvalue, pvalues[i].vdesc,
                                              pvalues[i].vvalue);
                                          break;

                                    case VTYPE_STRING:
                                          proto_tree_add_string_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, 
                                              pvalues[i].vlength, pvalues[i].vstring, pvalues[i].vdesc, pvalues[i].vstring);
                                          if (pvalues[i].mvtype == MVTYPE_ATTR_REQUEST) {
                                                /*
                                                 * The "vstring" value is set to the input ES type
                                                 * for MVTYPE_PROC_ENTRY_SPECIFIERS,
                                                 * to add string to columninfo
                                                 */
                                                if (check_col(pinfo->cinfo, COL_INFO)) {
                                                      if (!added_arrow) {
                                                            col_append_str(pinfo->cinfo, COL_INFO, " -> ");
                                                            added_arrow = TRUE;
                                                      }
                                                      col_append_str(pinfo->cinfo, COL_INFO, pvalues[i].vstring);
                                                }
                                          }
                                          break;

                                    case VTYPE_BITFIELD:
                                          process_bitfield(ncp_tree, tvb, &pvalues[i]);
                                          break;

                                    case VTYPE_MULTIVALUE_UINT32:
                                          process_multivalues(ncp_tree, tvb, &pvalues[i]);
                                          if (pvalues[i].mvtype == MVTYPE_PROC_ENTRY_SPECIFIERS) {
                                                /*
                                                 * The "vstring" value is set to the input ES type
                                                 * by "process_multivalues()".
                                                 */
                                                strcpy(global_object_name, mv_resolve_name_string);
                                          }
                                          if (pvalues[i].mvtype == MVTYPE_ATTR_REQUEST || pvalues[i].mvtype == MVTYPE_PROC_ENTRY_SPECIFIERS) {
                                                /*
                                                 * The "vstring" value is set to the input ES type
                                                 * for MVTYPE_PROC_ENTRY_SPECIFIERS,
                                                 * and the last string for MVTYPE_ATTR_REQUEST,
                                                 * by "process_multivalues()".
                                                 */
                                                if (check_col(pinfo->cinfo, COL_INFO)) {
                                                      col_append_str(pinfo->cinfo, COL_INFO, pvalues[i].vstring);
                                                      if (!added_arrow) {
                                                            col_append_str(pinfo->cinfo, COL_INFO, " -> ");
                                                            added_arrow = TRUE;
                                                      }
                                                      col_append_str(pinfo->cinfo, COL_INFO, mv_resolve_name_string);
                                                }
                                          }
                                          break;

                                    case VTYPE_BYTES:
                                          proto_tree_add_bytes(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset,
                                              pvalues[i].vlength, tvb_get_ptr(tvb, pvalues[i].voffset, pvalues[i].vvalue));
                                          break;

                                    case VTYPE_BOOLEAN:
                                          proto_tree_add_item(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, pvalues[i].vlength, TRUE);
                                          break;

                                    default:
                                          proto_tree_add_uint_format(ncp_tree, hf_nds_p1type, tvb, pvalues[i].voffset,
                                              pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u",
                                              pvalues[i].vtype);
                                          break;
                                    }
                                                /* For NDS requests with just an EID, resolve name from hash table. */
                                        }
                                        request_eid_value = ncp_eid_hash_lookup(conversation, global_eid);
                                        if(resolve_eid) {
                                                if (request_eid_value) {
                                                        strcpy(global_object_name, request_eid_value->object_name);
                                                        if (check_col(pinfo->cinfo, COL_INFO)) 
                                                        {
                                                                col_append_str(pinfo->cinfo, COL_INFO, ", Object Name - ");
                                                                col_append_str(pinfo->cinfo, COL_INFO, global_object_name);
                                                        }
                                                }        
                                        }
                                        if (request_value)
                                        {
                                                request_value->nds_request_verb = nds_verb;
                                                request_value->nds_version = nds_version;
                                                strcpy(request_value->object_name, global_object_name);
                                                request_value->req_nds_flags = global_flags;
                                        }
                                }
                              break;
               
                  default:
                              ; /* nothing */
                              break;
                  }
                  ptvcursor_free(ptvc);
               
                  /* Free the temporary proto_tree */
                  CLEANUP_CALL_AND_POP;
        }        
}

/*
 * XXX - this duplicates stuff in "dissect_ncp_request()"; could
 * "dissect_ncp_request()" not just call "dissect_ping_req()" if
 * the operation is an NCP ping, and "dissect_ping_req()" just dissect
 * ping portion?
 */
void
dissect_ping_req(tvbuff_t *tvb, packet_info *pinfo,
            guint32 nw_connection, guint8 sequence,
            guint16 type, proto_tree *ncp_tree)
{
      guint8                  func, subfunc = 0;
      ncp_req_hash_value      *request_value = NULL;
      const ncp_record  *ncp_rec = NULL;          
      conversation_t          *conversation;
      ptvcursor_t       *ptvc = NULL;
      proto_tree        *temp_tree = NULL;
        gint                    length_remaining = 0;
        guint32                 nds_flags;
        guint32                 ping_version;
      nds_val                 pvalue;
      char              string_buffer[1024];
        
#ifdef FAKE_TREE_IS_VISIBLE
    if (ncp_tree) {
        PTREE_DATA(ncp_tree)->visible=1;
    }
#endif

      pvalue.vvalue = 0;
      pvalue.vlength = 0;
      pvalue.voffset = 0;
      pvalue.hfname = 0;
      pvalue.vdesc = "";
      string_buffer[0] = '\0';
      pvalue.vstring = string_buffer;
      pvalue.mvtype = 0;
        
      func = tvb_get_guint8(tvb, 6);
        subfunc = tvb_get_guint8(tvb, 7);
        
        ncp_rec = ncp_record_find(func, subfunc);

            /* Fill in the INFO column. */
            if (check_col(pinfo->cinfo, COL_INFO)) 
        {
                  if (ncp_rec) 
                {
                        
                  col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDS");
                        col_add_fstr(pinfo->cinfo, COL_INFO, "C Ping for NDS");
                  }
                
        }
            if (!pinfo->fd->flags.visited) 
        {
        
            /* This is the first time we've looked at this packet.
            Keep track of the address and connection whence the request
            came, and the address and connection to which the request
            is being sent, so that we can match up calls with replies.
            (We don't include the sequence number, as we may want
            to have all packets over the same connection treated
            as being part of a single conversation so that we can
              let the user select that conversation to be displayed.) */
                
                  conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                      PT_NCP, nw_connection, nw_connection, 0);
        
                  if (conversation == NULL) 
                {
                        /* It's not part of any conversation - create a new one. */
                        conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
                            PT_NCP, nw_connection, nw_connection, 0);
                  }
                
                  request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
                  request_value->req_frame_num = pinfo->fd->num;
                request_value->req_frame_time=pinfo->fd->abs_ts;
        
                  /* If this is the first time we're examining the packet,
                   * check to see if this NCP type uses a "request condition".
                   * If so, we have to build a proto_tree because request conditions
                   * use display filters to work, and without a proto_tree,
                   * display filters can't possibly work. If we already have
                   * a proto_tree, then wonderful. If we don't, we need to build
                   * one. */
                  if (ncp_rec && !ncp_tree) {
                  proto_item *ti;
                               
                  temp_tree = proto_tree_create_root();
                  proto_tree_set_visible(temp_tree, FALSE);
                  ti = proto_tree_add_item(temp_tree, proto_ncp, tvb, 0, -1, FALSE);
                  ncp_tree = proto_item_add_subtree(ti, ett_ncp);
                  }
            }
        
      if (ncp_tree) {
            /* If the dissection throws an exception, be sure to free
             * the temporary proto_tree that was created. Because of the
             * way the CLEANUP_PUSH macro works, we can't put it in an 'if'
             * block; it has to be in the same scope as the terminating
             * CLEANUP_POP or CLEANUP_POP_AND_ALLOC. So, we always
             * call CLEANUP_POP and friends, but the value of temp_tree is
             * NULL if no cleanup is needed, and non-null if cleanup is needed. 
             */
            CLEANUP_PUSH(free_proto_tree, temp_tree);

        switch (type) {

            case NCP_BROADCAST_SLOT:
                  ; /* nothing */
                  break;
        
            case NCP_SERVICE_REQUEST:
                  proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 1,
                        func, "Function: %u (0x%02X), %s",
                        func, func, ncp_rec ? ncp_rec->name : "Unknown");
                                        
                  proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 7, 1,
                        subfunc, "SubFunction: %u (0x%02x)",
                        subfunc, subfunc);

                  length_remaining = tvb_reported_length_remaining(tvb, 8);

                  if (length_remaining >= 8) {
                                ping_version = tvb_get_letohl(tvb, 8);
                        proto_tree_add_uint(ncp_tree, hf_nds_ping_version, tvb, 8,
                            4, ping_version);
                        nds_flags = tvb_get_letohl(tvb, 12);
                        if (request_value){
                    request_value->nds_request_verb = 0xf0;
                    request_value->req_nds_flags = nds_flags;
                }
                    proto_tree_add_uint_hidden(ncp_tree, hf_ncp_nds_verb, tvb, 0, 0,
                        240);

                        
                                pvalue.vvalue = tvb_get_letohs(tvb, 12);
                                pvalue.vtype = VTYPE_BITFIELD;
                                pvalue.vstring = "";
                                pvalue.vdesc = "Ping (low) Request Flags:";
                                pvalue.vlength = 2;
                                pvalue.hfname= hf_nds_rflags;
                                pvalue.voffset = 12;
                                pvalue.bit1 = "Supported Fields";
                                pvalue.bit1hfname = hf_bit1pingflags1;
                                pvalue.bit2 = "Depth";
                                pvalue.bit2hfname = hf_bit2pingflags1;
                                pvalue.bit3 = "Revision";
                                pvalue.bit3hfname = hf_bit3pingflags1;
                                pvalue.bit4 = "Flags";
                                pvalue.bit4hfname = hf_bit4pingflags1;
                                pvalue.bit5 = "Verification Flags";
                                pvalue.bit5hfname = hf_bit5pingflags1;
                                pvalue.bit6 = "Letter Version";
                                pvalue.bit6hfname = hf_bit6pingflags1;
                                pvalue.bit7 = "OS Version";
                                pvalue.bit7hfname = hf_bit7pingflags1;
                                pvalue.bit8 = "License Flags";
                                pvalue.bit8hfname = hf_bit8pingflags1;
                                pvalue.bit9 = "DS Time";
                                pvalue.bit9hfname = hf_bit9pingflags1;
                                pvalue.bit10 = "Not Defined";
                                pvalue.bit10hfname = hf_bit10pingflags1;
                                pvalue.bit11 = "Not Defined";
                                pvalue.bit11hfname = hf_bit11pingflags1;
                                pvalue.bit12 = "Not Defined";
                                pvalue.bit12hfname = hf_bit12pingflags1;
                                pvalue.bit13 = "Not Defined";
                                pvalue.bit13hfname = hf_bit13pingflags1;
                                pvalue.bit14 = "Not Defined";
                                pvalue.bit14hfname = hf_bit14pingflags1;
                                pvalue.bit15 = "Not Defined";
                                pvalue.bit15hfname = hf_bit15pingflags1;
                                pvalue.bit16 = "Not Defined";
                                pvalue.bit16hfname = hf_bit16pingflags1;
                                
                                process_bitfield(ncp_tree, tvb, &pvalue);
                                
                                pvalue.vvalue = tvb_get_letohs(tvb, 14);
                                pvalue.vtype = VTYPE_BITFIELD;
                                pvalue.vstring = "";
                                pvalue.vdesc = "Ping (high) Request Flags:";
                                pvalue.vlength = 2;
                                pvalue.hfname= hf_nds_rflags;
                                pvalue.voffset = 14;
                                pvalue.bit1 = "Sap Name";
                                pvalue.bit1hfname = hf_bit1pingflags2;
                                pvalue.bit2 = "Tree Name";
                                pvalue.bit2hfname = hf_bit2pingflags2;
                                pvalue.bit3 = "OS Name";
                                pvalue.bit3hfname = hf_bit3pingflags2;
                                pvalue.bit4 = "Hardware Name";
                                pvalue.bit4hfname = hf_bit4pingflags2;
                                pvalue.bit5 = "Vendor Name";
                                pvalue.bit5hfname = hf_bit5pingflags2;
                                pvalue.bit6 = "Not Defined";
                                pvalue.bit6hfname = hf_bit6pingflags2;
                                pvalue.bit7 = "Not Defined";
                                pvalue.bit7hfname = hf_bit7pingflags2;
                                pvalue.bit8 = "Not Defined";
                                pvalue.bit8hfname = hf_bit8pingflags2;
                                pvalue.bit9 = "Not Defined";
                                pvalue.bit9hfname = hf_bit9pingflags2;
                                pvalue.bit10 = "Not Defined";
                                pvalue.bit10hfname = hf_bit10pingflags2;
                                pvalue.bit11 = "Not Defined";
                                pvalue.bit11hfname = hf_bit11pingflags2;
                                pvalue.bit12 = "Not Defined";
                                pvalue.bit12hfname = hf_bit12pingflags2;
                                pvalue.bit13 = "Not Defined";
                                pvalue.bit13hfname = hf_bit13pingflags2;
                                pvalue.bit14 = "Not Defined";
                                pvalue.bit14hfname = hf_bit14pingflags2;
                                pvalue.bit15 = "Not Defined";
                                pvalue.bit15hfname = hf_bit15pingflags2;
                                pvalue.bit16 = "Not Defined";
                                pvalue.bit16hfname = hf_bit16pingflags2;
                                
                                process_bitfield(ncp_tree, tvb, &pvalue);
                  }
                  break;
       
            default:
                  ; /* nothing */
                  break;
            }
            ptvc = ptvcursor_new(ncp_tree, tvb, 7);
            if (ncp_rec && ncp_rec->request_ptvc) {
                  clear_repeat_vars();
                  process_ptvc_record(ptvc, ncp_rec->request_ptvc, NULL, TRUE, ncp_rec);
            }
            ptvcursor_free(ptvc);

            /* Free the temporary proto_tree */
            CLEANUP_CALL_AND_POP;
      }
}

Generated by  Doxygen 1.6.0   Back to index