* Gilbert Ramirez <gram@alumni.rice.edu>
* Modified to decode NDS packets by Greg Morris <gmorris@novell.com>
*
- * $Id: packet-ncp2222.inc,v 1.19 2002/09/22 15:46:42 gerald Exp $
+ * Portions Copyright (c) Gilbert Ramirez 2000-2002
+ * Portions Copyright (c) Novell, Inc. 2000-2003
+ *
+ * $Id: packet-ncp2222.inc,v 1.70 2004/02/29 08:01:22 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
#define NCP_PACKET_INIT_COUNT 200
#define PROTO_LENGTH_UNTIL_END -1
+gboolean nds_defragment = TRUE;
+
+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];
+
+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"
+};
+
static const value_string nds_tags[] = {
{ 0x00000000, "No Such Entry" },
{ 0x00000001, "Local Entry" },
{ 0x00000001, "Attribute Name & Value / " },
{ 0x00000002, "Effective Privileges / " },
{ 0x00000003, "Value Information / " },
- { 0x00000004, "Abreviated Value / " },
+ { 0x00000004, "Abbreviated Value / " },
{ 0, NULL }
};
{ 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" },
{ 0xfffffd0d, "(-755) Invalid Synchronization Data" },
{ 0xfffffd0c, "(-756) Stream Exists" },
{ 0xfffffd0b, "(-757) Auxiliary Has Containment" },
- { 0xfffffd0a, "(-758) Auxiliary Not Containere" },
+ { 0xfffffd0a, "(-758) Auxiliary Not Container" },
{ 0xfffffd09, "(-759) Auxiliary Not Effective" },
{ 0xfffffd08, "(-760) Auxiliary On Alias" },
{ 0xfffffd07, "(-761) Have Seen State" },
{ 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 }
guint32 nw_eid;
} ncp_req_eid_hash_key;
-typedef struct {
- const ncp_record *ncp_rec;
- gboolean *req_cond_results;
- guint32 req_frame_num;
- guint32 req_nds_flags;
- guint8 nds_request_verb;
- guint8 nds_version;
- char * object_name;
-} ncp_req_hash_value;
-
typedef struct {
char object_name[256];
char *object_class;
gint
ncp_equal(gconstpointer v, gconstpointer v2)
{
- ncp_req_hash_key *val1 = (ncp_req_hash_key*)v;
- ncp_req_hash_key *val2 = (ncp_req_hash_key*)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 ) {
gint
ncp_eid_equal(gconstpointer v, gconstpointer v2)
{
- ncp_req_eid_hash_key *val1 = (ncp_req_eid_hash_key*)v;
- ncp_req_eid_hash_key *val2 = (ncp_req_eid_hash_key*)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;
guint
ncp_hash(gconstpointer v)
{
- ncp_req_hash_key *ncp_key = (ncp_req_hash_key*)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;
}
guint
ncp_eid_hash(gconstpointer v)
{
- ncp_req_eid_hash_key *ncp_eid_key = (ncp_req_eid_hash_key*)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);
}
static void
ncp_init_protocol(void)
{
+ /* fragment */
+ fragment_table_init(&nds_fragment_table);
+ reassembled_table_init(&nds_reassembled_table);
+
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_hash) {
/* Destroy the hash, but don't clean up request_condition data. */
- g_hash_table_destroy(ncp_req_hash);
- ncp_req_hash = NULL;
+ /*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;
+ /*g_mem_chunk_destroy(ncp_req_hash_keys);
+ ncp_req_hash_keys = NULL;*/
}
- /* Don't free the ncp_req_hash_values, as they're
+ /* Don't free the ncp_req_hash_values or EID_hash_table, as they're
* needed during random-access processing of the proto_tree.*/
- if (ncp_req_eid_hash) {
- /* Destroy the hash, but don't clean up request_condition data. */
- g_hash_table_destroy(ncp_req_eid_hash);
- ncp_req_eid_hash = NULL;
- }
- if (ncp_req_eid_hash_keys) {
- g_mem_chunk_destroy(ncp_req_eid_hash_keys);
- ncp_req_eid_hash_keys = NULL;
- }
}
ncp_req_hash_value*
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 = 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);
}
ncp_req_eid_hash_value*
-ncp_eid_hash_insert(conversation_t *conversation, guint32 nw_eid,
- const ncp_record *ncp_rec)
+ncp_eid_hash_insert(guint32 nw_eid)
{
ncp_req_eid_hash_key *request_eid_key;
ncp_req_eid_hash_value *request_eid_value;
/* Returns the value_rec* for needed EID, or NULL if not found. */
ncp_req_eid_hash_value*
-ncp_eid_hash_lookup(conversation_t *conversation, guint32 nw_eid)
+ncp_eid_hash_lookup(conversation_t *conversation _U_, guint32 nw_eid)
{
ncp_req_eid_hash_key request_eid_key;
guint
get_item_value(proto_item *item)
{
- return fvalue_get_integer(PITEM_FINFO(item)->value);
+ return fvalue_get_integer(&PITEM_FINFO(item)->value);
}
char *
get_item_string(proto_item *item)
{
- return fvalue_get(PITEM_FINFO(item)->value);
+ return fvalue_get(&PITEM_FINFO(item)->value);
}
char *
} nw_time_t;
typedef struct {
- char * buffer;
+ 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 /* XXX - how does this differ from 1? */
+#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;
guint32 bit16hfname;
guint8 mvtype;
guint32 vflags;
+ guint32 nds_version;
} nds_val;
{
/* 2-second resolution */
nwtime->second = (data & 0x001f) * 2;
- nwtime->minute = ((data & 0x07e0) >> 5) + 1;
- nwtime->hour = ((data & 0xf800) >> 11) + 1;
+ nwtime->minute = ((data & 0x07e0) >> 5);
+ nwtime->hour = ((data & 0xf800) >> 11);
}
char *
unicode_to_string(char * data, guint32 length)
{
- int i;
+ guint32 i;
guint16 character;
int offset = 0;
char * buffer = "";
nw_uni_t nw_uni;
guint offset;
- nw_uni.buffer = "\0";
+ strcpy(nw_uni.buffer, "");
offset = ptvcursor_current_offset(ptvc);
item = ptvcursor_add(ptvc, *rec->hf_ptr,
}
}
-
static guint32
align_4(tvbuff_t *tvb, guint32 aoffset)
{
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)
+ if(str_length > length_remaining || str_length > 1024)
{
strcpy(dest_buf, "String too long to process");
return;
- }
+ }
+ 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 != 0x00)
{
- c_char = 0x2e;
- dest_buf[i] = c_char & 0xff;
+ c_char = '.';
+ dest_buf[i] = c_char & 0xff;
}
else
{
return;
}
}
-dest_buf[i] = '\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;
}
/*************************************
* %s = string = 2
**************************************/
int
-get_info_type(gchar* check_string)
+get_info_type(const gchar* check_string)
{
guint length;
guint i;
for (i = 0 ; i < length-1 ; i++ ) {
char_val = check_string[i+1];
- if (check_string[i] == 0x25 && check_string[i+1] == 0x64) {
+ if (check_string[i] == 0x25 && check_string[i+1] == 0x64) { /* %d Digits*/
return 0;
}
- if ( check_string[i] == 0x25 && check_string[i+1] == 0x78) {
+ if ( check_string[i] == 0x78 && check_string[i+1] == 0x25 && check_string[i+2] == 0x73) { /* x%s Bytes*/
return 1;
}
}
- return 2;
+ return 2; /* Normal String */
}
static void
process_bitfield(proto_tree *ncp_tree, tvbuff_t *tvb, nds_val *values)
{
- char flags_str[512];
- char * sep = NULL;
+ gchar flags_str[512];
+ gchar *sep;
proto_item *tinew;
proto_tree *flags_tree;
- int i;
+ guint32 i;
guint32 bvalue = 0;
bvalue = 0x00000001;
- strcpy(flags_str, " (");
- sep = " ";
+ flags_str[0]='\0';
+ sep="";
for (i = 0 ; i < (values->vlength*8); i++ ) {
if (values->vvalue & bvalue)
{
}
bvalue = bvalue*2;
}
- if (flags_str[0] != '\0')
+ if(values->vlength==4)
{
- strcat(flags_str, " )\0");
- if(values->vlength==4)
- {
- tinew = proto_tree_add_uint_format(ncp_tree, values->hfname,
- tvb, values->voffset, values->vlength, values->vvalue, "%s 0x%08x -%s",
- values->vdesc, values->vvalue, flags_str);
- }
- else
- {
- tinew = proto_tree_add_uint_format(ncp_tree, values->hfname,
- tvb, values->voffset, values->vlength, values->vvalue, "%s 0x%04x -%s",
- values->vdesc, values->vvalue, flags_str);
- }
-
+ 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);
+ flags_tree = proto_item_add_subtree(tinew, ett_nds);
- bvalue = 0x00000001;
+ bvalue = 0x00000001;
- for (i = 0 ; i < (values->vlength*8); i++ ) {
-
- if (values->vvalue & bvalue)
+ for (i = 0 ; i < (values->vlength*8); i++ ) {
+ if (values->vvalue & bvalue)
+ {
+ switch(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 0x0000008:
- 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;
- }
+ 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;
}
- }
+ bvalue = bvalue*2;
+ }
}
guint32 value5 = 0;
guint32 value6 = 0;
guint32 voffset = 0;
- guint8 icounter;
+ guint32 icounter;
guint32 number_of_values = 0;
guint32 number_of_items = 0;
- guint8 r;
+ guint32 r;
proto_item *vitem;
proto_tree *nvtree;
proto_item *aditem;
guint16 rstate = 0;
guint16 rnum = 0;
guint16 revent = 0;
+ gint length_remaining;
voffset = vvalues->voffset;
if(tvb_get_guint8(tvb, voffset) == 0x00)
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: %d", number_of_values);
+ 4, number_of_values, "Number of Values: %u", number_of_values);
nvtree = proto_item_add_subtree(vitem, ett_nds);
proto_tree_add_string(nvtree, hf_value_string, tvb, voffset,
value1, vvalues->vstring);
voffset = voffset + value1;
+ voffset += align_4(tvb, voffset);
}
- voffset += align_4(tvb, voffset);
break;
case 0x00000007: /* Boolean */
value1 = tvb_get_letohl(tvb, voffset); /* length of field */
if (value1==0)
{
- vvalues->vstring = "False";
+ vvalues->vstring = "False";
}
else
{
- vvalues->vstring = "True";
+ vvalues->vstring = "True";
}
proto_tree_add_string(nvtree, hf_value_string, tvb, voffset,
value1, vvalues->vstring);
case 0x00000009: /* Binary String */
case 0x00000015: /* Stream */
value1 = tvb_get_letohl(tvb, voffset); /* length of field */
- if(value1 > tvb_length_remaining(tvb, voffset))
+ length_remaining = tvb_length_remaining(tvb, voffset);
+ if(length_remaining == -1 || value1 > (guint32) length_remaining)
{
break;
}
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 0x00000001:
- proto_tree_add_item(nvtree, hf_nds_port, tvb, voffset, 2, FALSE);
- value4 = tvb_get_letohl(tvb, voffset+2);
- proto_tree_add_ipv4(nvtree, hf_add_ref_ip, tvb, voffset+2, 4, value4);
- break;
case 0x00000008:
proto_tree_add_item(nvtree, hf_nds_port, tvb, voffset, 2, FALSE);
value4 = tvb_get_letohl(tvb, voffset+2);
value4 = tvb_get_letohl(tvb, voffset+2);
proto_tree_add_ipv4(nvtree, hf_add_ref_tcp, tvb, voffset+2, 4, value4);
break;
+ case 0x00000001:
+ proto_tree_add_item(nvtree, hf_nds_port, tvb, voffset, 2, FALSE);
+ value4 = tvb_get_letohl(tvb, voffset+2);
+ proto_tree_add_ipv4(nvtree, hf_add_ref_ip, tvb, voffset+2, 4, value4);
+ break;
case 0x0000000d:
get_string(tvb, voffset, value3, vvalues->vstring);
proto_tree_add_string(nvtree, hf_value_string, tvb, voffset,
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(vtree, hf_nds_uint32value, tvb, voffset,
- 4, number_of_items, "Number of Addresses: %d", number_of_items);
+ 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;
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+14;
+ 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, "Lenght of Record", value1);
+ 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,
voffset = voffset+4;
get_string(tvb, voffset, value3, vvalues->vstring);
proto_tree_add_string_format(nvtree, hf_value_string, tvb, voffset,
- value3, "Server Distinguished Name - %s", vvalues->vstring);
+ 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, "Lenght of Record", value1);
+ 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,
voffset = voffset+4;
get_string(tvb, voffset, value4, vvalues->vstring);
proto_tree_add_string_format(nvtree, hf_value_string, tvb, voffset,
- value4, "Distinguished Name - %s", vvalues->vstring);
+ 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, "Lenght of Record", value1);
+ 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,
voffset = voffset+4;
get_string(tvb, voffset, value3, vvalues->vstring);
proto_tree_add_string_format(nvtree, hf_value_string, tvb, voffset,
- value3, "Subject - %s", vvalues->vstring);
+ value3, vvalues->vstring,
+ "Subject - %s", vvalues->vstring);
voffset = voffset+value3;
voffset += align_4(tvb, voffset);
break;
guint32 value3;
guint32 value4;
guint32 value5;
- guint32 number_of_referals;
- guint8 r;
- guint8 i;
+ guint32 number_of_referrals;
+ guint32 r;
+ guint32 i;
guint16 replica_num;
guint16 event_num;
nw_uni_t mval_buf;
proto_item *aitem;
char * vstring="";
- mval_buf.buffer = "";
+ strcpy(mval_buf.buffer, "");
+
switch (vtype)
{
case 0: /* No Specifier Type */
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 */
value3, values->vstring);
values->voffset=ioffset + value3;
ioffset = values->voffset;
+ ioffset += align_4(tvb, ioffset);
break;
case 2: /* Based */
break;
value3, values->vstring);
values->voffset=ioffset + value3;
ioffset = values->voffset;
+ ioffset += align_4(tvb, ioffset);
break;
case 2: /* Based */
break;
}
break;
case 3: /* Hinted */
- number_of_referals = tvb_get_letohl(tvb, ioffset);
+ number_of_referrals = tvb_get_letohl(tvb, ioffset);
- for (r = 1 ; r <= number_of_referals; r++ )
+ for (r = 1 ; r <= number_of_referrals; r++ )
{
- aitem = proto_tree_add_uint_format(estree, hf_referal_record, tvb, 6, 0,
- r, "NDS Referal Record #%d", 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_referal_addcount, tvb, ioffset, 4,
- value1, "Number of Addresses in Referal - %d", value1);
+ 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++ )
value3, values->vstring);
values->voffset=ioffset + value3;
ioffset = values->voffset;
+ ioffset += align_4(tvb, ioffset);
break;
case 2: /* Based */
break;
static void
process_multivalues(proto_tree *ncp_tree, tvbuff_t *tvb, nds_val *values)
{
- guint8 i;
- guint8 r;
- guint8 n;
+ guint32 i;
+ guint32 r;
guint32 ioffset = 0;
guint32 value1 = 0;
guint32 value2 = 0;
guint8 value3 = 0;
guint32 value4 = 0;
- guint32 value5 = 0;
+ gint value5 = 0;
guint32 value6 = 0;
guint32 value7 = 0;
- guint32 value8 = 0;
char * valuestr = "";
proto_tree *ntree;
proto_tree *atree;
proto_item *nitem;
proto_item *aitem;
- guint32 number_of_referals = 0;
+ guint32 number_of_referrals = 0;
nw_uni_t mval_buf;
proto_tree *estree;
proto_item *esitem;
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;
- mval_buf.buffer = "";
- if(values->mvtype != 12)
+ strcpy(mval_buf.buffer, "");
+
+ 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);
switch (values->mvtype)
{
- case 1: /* Attribute Request */
+ case MVTYPE_ATTR_REQUEST: /* Attribute Request */
for (i = 1 ; i <= values->vvalue; i++ )
{
ioffset += align_4(tvb, ioffset);
ioffset = ioffset + value1;
}
break;
- case 2: /* Attribute Reply */
+
+ case MVTYPE_ATTR_REPLY: /* Attribute Reply */
switch(values->vflags)
{
case 0:
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;
+ value2, values->vstring);
+ ioffset += value2;
+ ioffset += align_4(tvb, ioffset);
+ values->voffset = ioffset;
+
print_nds_values(ntree, tvb, value1, values);
ioffset = values->voffset;
}
break;
}
break;
- case 3: /* Attribute Request */
+
+ case MVTYPE_ATTR_REQUEST2: /* Attribute Request */
for (i = 1 ; i <= values->vvalue; i++ )
{
ioffset += align_4(tvb, ioffset);
ioffset = ioffset + value1;
}
break;
- case 4: /* Read Class Request */
+
+ 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);
ioffset = ioffset + value1;
}
break;
- case 5: /* Read Replicas */
+
+ case MVTYPE_READ_REPLICAS: /* Read Replicas */
for (i = 1 ; i <= values->vvalue; i++ )
{
}
}
break;
- case 6: /* Modify Attribute Request */
+
+ case MVTYPE_MODIFY_ATTR_REQUEST: /* Modify Attribute Request */
for (i = 0 ; i < values->vvalue; i++ )
{
ioffset += align_4(tvb, ioffset);
}
}
break;
- case 7: /* Address Referal Request */
+
+ case MVTYPE_ADDR_REFERRAL_REQUEST: /* Address Referral Request */
for (i = 0 ; i < values->vvalue; i++ )
{
ioffset = ioffset+4;
}
break;
- case 8: /* Address Referal Reply */
- number_of_referals = values->vvalue;
+
+ case MVTYPE_ADDR_REFERRAL_REPLY: /* Address Referral Reply */
+ number_of_referrals = values->vvalue;
- for (r = 1 ; r <= number_of_referals; r++ )
+ for (r = 1 ; r <= number_of_referrals; r++ )
{
- aitem = proto_tree_add_uint_format(ntree, hf_referal_record, tvb, 6, 0,
- r, "NDS Referal Record #%d", 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_referal_addcount, tvb, ioffset, 4,
- value1, "Number of Addresses in Referal - %d", value1);
+ 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++ )
}
}
-
break;
- case 9: /* Local Address Referal Reply */
- number_of_referals = values->vvalue;
- for (r = 1 ; r <= number_of_referals; r++ )
+ 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_referal_record, tvb, 6, 0,
- r, "NDS Referal Record #%d", 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);
ioffset += align_4(tvb, ioffset);
}
break;
- case 10: /* Process Entry Specifiers */
+
+ case MVTYPE_PROC_ENTRY_SPECIFIERS: /* Process Entry Specifiers */
value2 = tvb_get_letohl(tvb, ioffset); /* ES Type */
values->vstring = match_strval(value2, es_type);
if (values->vstring == NULL)
ioffset = ioffset + 4;
ioffset = print_es_type(estree, tvb, values, value3, ioffset);
value4 = tvb_get_letohl(tvb, ioffset);
- aitem = proto_tree_add_uint_format(ntree, hf_referal_record, tvb, ioffset, 4,
- value4, "Referal Protocols - %d", value4);
+ 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++ )
ioffset = ioffset+4;
}
value6 = tvb_get_letohl(tvb, ioffset);
- aitem = proto_tree_add_uint_format(ntree, hf_referal_record, tvb, ioffset, 4,
+ 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;
ioffset = ioffset+4;
}
break;
- case 11: /* 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;
- case 12: /* List Partitions */
- number_of_referals = values->vvalue;
- for (i = 0; i < number_of_referals; i++)
+
+ 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;
+ for (i = 0; i < number_of_referrals; i++)
{
bvalue = 0x00000001;
{
case 0x00000001: /* Information Flags */
temp_values.vvalue = tvb_get_letohs(tvb, ioffset);
- temp_values.vtype = 5; /* Bitfield */
- temp_values.vstring = "";
+ 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;
process_bitfield(ntree, tvb, &temp_values);
ioffset = ioffset+2;
temp_values.vvalue = tvb_get_letohs(tvb, ioffset);
- temp_values.vtype = 5; /* Bitfield */
- temp_values.vstring = "";
+ 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;
break;
case 0x00000004: /* Entry Flags */
temp_values.vvalue = tvb_get_letohl(tvb, ioffset);
- temp_values.vtype = 5; /* Bitfield */
- temp_values.vstring = "";
+ 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;
}
}
break;
- case 13: /* Class Names */
- number_of_referals = values->vvalue;
- for (i = 0; i < number_of_referals; i++)
+
+ 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;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 = 5; /* Bitfield */
- temp_values.vstring = "";
+ 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.bit15hfname = hf_bit15cflags;
temp_values.bit16 = "Not Defined";
temp_values.bit16hfname = hf_bit16cflags;
- process_bitfield(ntree, tvb, &temp_values);
+ process_bitfield(sub1tree, tvb, &temp_values);
ioffset = ioffset+4;
if(values->vflags != 5)
{
value1 = tvb_get_letohl(tvb, ioffset); /* length of field */
- if(value1 > tvb_length_remaining(tvb, ioffset))
+ length_remaining = tvb_length_remaining(tvb, ioffset);
+ if(length_remaining == -1 || value1 > (guint32) length_remaining)
{
break;
}
ioffset += 4;
- proto_tree_add_bytes(ntree, hf_nds_asn1, tvb, ioffset, value1, tvb_get_ptr(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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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 = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ proto_tree_add_string(sub2tree, hf_mv_string, tvb, ioffset,
value2, temp_values.vstring);
ioffset = ioffset + value2;
if(tvb_length_remaining(tvb, ioffset) < 4 )
}
}
}
- if(values->vflags == 2 || values->vflags == 4) /* Class Definitions of Super Classes */
+ /*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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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 = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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(ntree, hf_nds_eid, tvb, ioffset,
+ 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 )
if(values->vflags == 5) /* Base Class Definitions */
{
value1 = tvb_get_letohl(tvb, ioffset); /* Creation Timestamp */
- proto_tree_add_uint_format(ntree, hf_es_seconds, tvb, ioffset,
+ 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(ntree, hf_nds_replica_num, tvb, ioffset,
+ 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(ntree, hf_nds_event_num, tvb, ioffset,
+ 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(ntree, hf_es_seconds, tvb, ioffset,
+ 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(ntree, hf_nds_replica_num, tvb, ioffset,
+ 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(ntree, hf_nds_event_num, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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++)
{
ioffset = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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 */
- proto_tree_add_uint_format(ntree, hf_nds_purge, tvb, ioffset,
+ 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 = ioffset + 4;
get_string(tvb, ioffset, value2, mval_buf.buffer);
temp_values.vstring = mval_buf.buffer;
- proto_tree_add_string(ntree, hf_nds_base_class, tvb, ioffset,
+ 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(ntree, hf_nds_eid, tvb, ioffset,
+ 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;
- case 14: /* Modify Class */
+
+ case MVTYPE_MODIFY_CLASS: /* Modify Class */
for (i = 1 ; i <= values->vvalue; i++ ) /* Attribute Names to add*/
{
ioffset += align_4(tvb, ioffset);
}
}
+/*
+ * 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.
+ *
+ * XXX - this has several problems:
+ *
+ * 1) it uses global variables ("frags");
+ *
+ * 2) the sequence numbers don't start at a fixed value, they're
+ * per-connection sequence numbers;
+ *
+ * 3) the fragment size and handle aren't put into the protocol
+ * tree for fragments other than the last fragment.
+ *
+ * 2) needs to be fixed by having a way of doing defragmentation using
+ * connection sequence numbers; that's needed for fragmentation in
+ * connection-oriented protocols, e.g. COTP, as well.
+ * That might let us fix 1) as well.
+ *
+ * 3) should be fixed by putting that into the protocol tree ourselves
+ * if this isn't the first fragment.
+*/
+void
+nds_defrag(tvbuff_t *tvb, packet_info *pinfo, guint16 nw_connection, guint8 sequence, guint16 type, proto_tree *tree)
+{
+ 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 < 9; i++) {
+ if (!frags[i].nds_fragmented)
+ {
+ frags[i].nds_frag = 0;
+ }
+ }
+ /* Check to see if defragmentation is enabeled in the dissector */
+ if (!nds_defragment) {
+ dissect_ncp_reply(tvb, pinfo, nw_connection, sequence, type, tree);
+ return;
+ }
+ /* Has this already been dissected? */
+ if (!pinfo->fd->flags.visited) {
+ /* Find the conversation whence the request would have come. */
+ conversation = find_conversation(&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);
+ 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);
+ 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);
+ 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);
+ 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 == 0)
+ {
+ if (frags[i].nds_frag == 0)
+ {
+ frags[i].nds_length = 0;
+ frags[i].nds_frag = nds_frag;
+ frags[i].nds_fragmented = TRUE;
+ }
+ break;
+ }
+ }
+ frag_count = i;
+
+ /* 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)
+ {
+ show_fragment_seq_tree(fd_head,
+ &nds_frag_items,
+ tree, pinfo,
+ frag_tvb);
+ 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 (frags[i].nds_frag == 0)
+ {
+ /* Error can't find fragment */
+ /*g_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);
+ }
+ }
+ }
+ 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);
+ }
+}
+
void
dissect_ncp_request(tvbuff_t *tvb, packet_info *pinfo,
guint16 nw_connection, guint8 sequence,
guint16 type, proto_tree *ncp_tree)
{
guint8 func, subfunc = 0;
- gboolean requires_subfunc;
- gboolean has_length = TRUE;
+ gboolean requires_subfunc = FALSE;
+ gboolean has_length = FALSE;
ncp_req_hash_value *request_value = NULL;
const ncp_record *ncp_rec = NULL;
conversation_t *conversation;
func = tvb_get_guint8(tvb, 6);
- 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);
- }
- }
-
/* Determine which ncp_record to use. */
switch (type) {
case NCP_ALLOCATE_SLOT:
}
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:
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 %d %d (0x%02X/0x%02x)",
+ "C Unknown Function %u %u (0x%02X/0x%02x)",
func, subfunc, func, subfunc);
}
else {
col_add_fstr(pinfo->cinfo, COL_INFO,
- "C Unknown Function %d (0x%02x)",
+ "C Unknown Function %u (0x%02x)",
func, func);
}
}
}
request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
request_value->req_frame_num = pinfo->fd->num;
+ request_value->req_frame_time.secs=pinfo->fd->abs_secs;
+ request_value->req_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
/* 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. */
+ * display filters can't possibly work. */
if (ncp_rec) {
if (ncp_rec->req_cond_indexes) {
run_req_cond = TRUE;
}
- /* Only create info string if COL_INFO is available. */
- if (ncp_rec->req_info_str && check_col(pinfo->cinfo, COL_INFO)) {
- run_info_str = TRUE;
- }
- /* We also have to use a tree if we have to construct an info_str */
- 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 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
proto_tree_prime_hfid(ncp_tree, *ncp_rec->req_info_str->hf_ptr);
}
- conversation = find_conversation(&pinfo->src, &pinfo->dst,
- PT_NCP, nw_connection, nw_connection, 0);
-
switch (type) {
case NCP_BROADCAST_SLOT:
; /* nothing */
case NCP_SERVICE_REQUEST:
proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 1,
- func, "Function: %d (0x%02X), %s",
+ func, "Function: %u (0x%02X), %s",
func, func, ncp_rec ? ncp_rec->name : "Unknown");
break;
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: %d (0x%02x)",
+ 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: %d (0x%02x)",
+ subfunc, "SubFunction: %u (0x%02x)",
subfunc, subfunc);
ptvc = ptvcursor_new(ncp_tree, tvb, 8);
}
/* The group is not part of the packet, but it's useful
* information to display anyway. */
if (ncp_rec) {
- proto_tree_add_text(ncp_tree, tvb, 6, 1, "Group: %s",
+ proto_tree_add_text(ncp_tree, tvb, 0, 0, "Group: %s",
ncp_groups[ncp_rec->group]);
}
process_ptvc_record(ptvc, ncp_rec->request_ptvc, NULL, TRUE, ncp_rec);
}
ptvcursor_free(ptvc);
+ /* 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
* 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->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);
finfo = g_ptr_array_index(parray, 0);
- info_type = get_info_type((gchar*) ncp_rec->req_info_str->first_string);
+ info_type = get_info_type((const gchar*) ncp_rec->req_info_str->first_string);
- if (info_type == 2) { // Is this a string or not?
-
- col_append_fstr(pinfo->cinfo, COL_INFO,
- (gchar*) ncp_rec->req_info_str->first_string,
- fvalue_get(finfo->value));
+ if (info_type != 0) { /* Is this a string or not? */
+
+ if (info_type == 1) { /* Is this bytes? */
+ byte_string = bytes_to_str(fvalue_get(&finfo->value), fvalue_length(&finfo->value));
+ 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(fvalue_get(&finfo->value), fvalue_length(&finfo->value), 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,
+ fvalue_get(&finfo->value));
+ }
+ }
}
else
{
-
col_append_fstr(pinfo->cinfo, COL_INFO,
- (gchar*) ncp_rec->req_info_str->first_string,
- fvalue_get_integer(finfo->value));
+ (const gchar*) ncp_rec->req_info_str->first_string,
+ fvalue_get_integer(&finfo->value));
}
}
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((gchar*) ncp_rec->req_info_str->repeat_string);
+ info_type = get_info_type((const gchar*) ncp_rec->req_info_str->repeat_string);
- if (info_type == 2) { // Is this a string or not?
-
+ if (info_type != 0) { /* Is this a string or not? */
+ if (info_type == 1)
+ { /* Is this bytes? */
+ byte_string = bytes_to_str(fvalue_get(&finfo->value), fvalue_length(&finfo->value));
col_append_fstr(pinfo->cinfo, COL_INFO,
- (gchar*) ncp_rec->req_info_str->repeat_string,
- fvalue_get(finfo->value));
+ (const gchar*) ncp_rec->req_info_str->repeat_string,
+ byte_string);
+ }
+ else
+ {
+ if (info_type == 2) { /* Is this a String? */
+ uni_to_string(fvalue_get(&finfo->value), fvalue_length(&finfo->value), 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,
+ fvalue_get(&finfo->value));
+ }
+ }
}
else
{
-
col_append_fstr(pinfo->cinfo, COL_INFO,
- (gchar*) ncp_rec->req_info_str->repeat_string,
- fvalue_get_integer(finfo->value));
+ (const gchar*) ncp_rec->req_info_str->repeat_string,
+ fvalue_get_integer(&finfo->value));
}
}
}
}
-
/* Free the temporary proto_tree */
CLEANUP_CALL_AND_POP;
}
guint16 nw_connection, guint8 sequence, guint16 type,
proto_tree *ncp_tree)
{
- conversation_t *conversation;
- conversation_t *eid_conversation;
+ conversation_t *conversation = NULL;
ncp_req_hash_value *request_value = NULL;
ncp_req_eid_hash_value *request_eid_value = NULL;
const ncp_record *ncp_rec = NULL;
- const ncp_record *ncp_eid_rec = NULL;
int *req_cond_results;
guint8 completion_code=0;
guint length;
ptvcursor_t *ptvc = NULL;
const char *error_string;
- char *n_string="";
guint32 nds_string_len = 0;
guint8 ping_version = 0;
guint32 nds_flags = 0;
nw_uni_t reply_buffer;
char * verb_string="";
guint32 nds_error_code = 0;
- guint32 nds_error_offset = 0;
guint32 nds_reply_buffer = 0;
char * nds_error_string = NULL;
guint32 nds_frag=0;
- nds_val p1values;
- nds_val p2values;
- nds_val p3values;
- nds_val p4values;
- nds_val p5values;
- nds_val p6values;
- nds_val p7values;
- nds_val p8values;
- nds_val p9values;
+ 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='\0';
+ char global_object_name[256];
+ int i;
+ guint32 bvalue=0;
-
- reply_buffer.buffer = "\0";
+ strcpy(reply_buffer.buffer, "");
+ strcpy(global_object_name, "");
+
if (!pinfo->fd->flags.visited) {
/* Find the conversation whence the request would have come. */
conversation = find_conversation(&pinfo->src, &pinfo->dst,
}
}
+ 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 (ncp_rec && ncp_rec->errors) {
- error_string = ncp_error_string(ncp_rec->errors, completion_code);
- }
- else if (completion_code == 0) {
- error_string = "OK";
- }
- else {
- error_string = "Not OK";
+ 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 = "Not OK";
+ }
}
- if (ncp_rec && ncp_rec->func==0x68 && ncp_rec->subfunc==0x02)
+ if (type == NCP_SERVICE_REPLY && ncp_rec && ncp_rec->func==0x68 &&
+ ncp_rec->subfunc==0x02)
{
nds_offset = 8;
- nds_reply_buffer = tvb_get_letohl(tvb, nds_offset);
- nds_frag = tvb_get_letohl(tvb, 12);
+ nds_reply_buffer = tvb_get_letohl(tvb, nds_offset);
+ nds_offset += 4;
+ nds_frag = tvb_get_letohl(tvb, nds_offset);
if (nds_reply_buffer > 7)
{
- nds_offset = 16;
+ nds_offset += 4;
nds_error_code = tvb_get_letohl(tvb, nds_offset);
- error_string = match_strval(nds_error_code, nds_reply_errors);
- if (error_string == NULL)
+ nds_error_string = match_strval(nds_error_code, nds_reply_errors);
+ if (nds_error_string == NULL)
{
- nds_offset = 19;
- nds_error_code = tvb_get_letohl(tvb, nds_offset);
- error_string = match_strval(nds_error_code, nds_reply_errors);
+ nds_error_string = "NDS Error - No Definition Found";
}
- if (error_string == NULL || nds_error_code == 0x00000000)
+ if (nds_error_string == NULL || nds_error_code == 0x00000000)
{
- if (nds_frag != 0xffffffff)
- {
- error_string = "NDS Fragment";
- }
- else
- {
- error_string = "Ok";
- }
+ nds_error_string = "Ok";
}
}
}
if (check_col(pinfo->cinfo, COL_INFO)) {
- if (ncp_rec && ncp_rec->func==0x68 && ncp_rec->subfunc==0x02) {
- col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDS");
- }
- if (ncp_rec && ncp_rec->func==0x68 && ncp_rec->subfunc==0x01) {
- col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDS");
- }
col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s",
type == NCP_SERVICE_REPLY ? "R" : "ACK",
- error_string);
+ 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);
- }
+ ns.secs=pinfo->fd->abs_secs-request_value->req_frame_time.secs;
+ ns.nsecs=pinfo->fd->abs_usecs*1000-request_value->req_frame_time.nsecs;
+ if(ns.nsecs<0){
+ ns.nsecs+=1000000000;
+ ns.secs--;
+ }
+ 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
*/
if (ncp_rec) {
proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 0,
- ncp_rec->func, "Function: %d (0x%02X), %s",
+ 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: %d (0x%02x)",
+ ncp_rec->subfunc, "SubFunction: %u (0x%02x)",
ncp_rec->subfunc, ncp_rec->subfunc);
}
}
completion_code, completion_code, error_string);
proto_tree_add_item(ncp_tree, hf_ncp_connection_status, tvb, 7, 1, FALSE);
+
+ /*
+ * Unless this is a reply, that's all there is to parse.
+ */
+ if (type != NCP_SERVICE_REPLY)
+ return;
+
/* Decode NDS Reply packets */
if (ncp_rec) {
- if (ncp_rec->func == 0x68 && ncp_rec->subfunc == 0x01) {
+ /* 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);
+ }
+ if ((ncp_rec->func == 0x68 && ncp_rec->subfunc == 0x01) && completion_code == 0) {
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;
- proto_tree_add_item(ncp_tree, hf_nds_string, tvb, 16, nds_string_len, FALSE);
+ 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;
- if (nds_flags & 0x00200000) {
- nds_offset = nds_offset+4;
- }
- if (nds_flags & 0x00000002) {
- proto_tree_add_item(ncp_tree, hf_nds_reply_depth, tvb, nds_offset, 4, TRUE);
- nds_offset = nds_offset+4;
- }
- if (nds_flags & 0x00000004) {
- proto_tree_add_item(ncp_tree, hf_nds_reply_rev, tvb, nds_offset, 4, TRUE);
- nds_offset = nds_offset+4;
- }
- if (nds_flags & 0x00000008) {
- proto_tree_add_item(ncp_tree, hf_nds_reply_flags, tvb, nds_offset, 4, TRUE);
- nds_offset = nds_offset+4;
- }
- if (nds_flags & 0x00020000) {
- nds_string_len = tvb_get_letohl(tvb, nds_offset);
- get_string(tvb, nds_offset+4, nds_string_len, reply_buffer.buffer);
- /*nds_string_len = strlen(reply_buffer.buffer);*/
- proto_tree_add_text(ncp_tree, tvb, nds_offset+4, nds_string_len, "NDS Tree Name: %s", reply_buffer.buffer);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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;
}
}
}
nds_offset = 8;
nds_reply_buffer = tvb_get_letohl(tvb, nds_offset);
- proto_tree_add_uint_format(ncp_tree, hf_ncp_fragment_size, tvb, 8,
- 4, nds_reply_buffer, "NDS Fragment Size %d",
- nds_reply_buffer);
- nds_frag = tvb_get_letohl(tvb, 12);
- proto_tree_add_uint_format(ncp_tree, hf_ncp_fragment_handle, tvb, 12,
- 4, nds_frag, "NDS Fragment Handle 0x%08x",
- nds_frag);
+ 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;
if (nds_reply_buffer > 7)
{
- nds_offset = 16;
- 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_offset = 19;
- nds_error_code = tvb_get_letohl(tvb, nds_offset);
- error_string = match_strval(nds_error_code, nds_reply_errors);
- }
- if (nds_error_string == NULL || nds_error_code == 0x00000000)
- {
- if (nds_frag != 0xffffffff)
- {
- nds_error_string = "NDS Fragment";
- }
- else
- {
- nds_error_string = "Ok";
- }
- nds_error_code = 0x00000000;
- }
+ /*
+ * XXX - is this present in
+ * replies to continuation
+ * messages? It doesn't appear to
+ * be.
+ */
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 (request_value && nds_error_code == 0x00000000 && nds_frag == 0xffffffff)
+ if (request_value && nds_error_code == 0x00000000)
{
nds_offset = 20;
- p1values.vtype = 0;
- p2values.vtype = 0;
- p3values.vtype = 0;
- p4values.vtype = 0;
- p5values.vtype = 0;
- p6values.vtype = 0;
- p7values.vtype = 0;
- p8values.vtype = 0;
- p9values.vtype = 0;
- p1values.vvalue = 0;
- p2values.vvalue = 0;
- p3values.vvalue = 0;
- p4values.vvalue = 0;
- p5values.vvalue = 0;
- p6values.vvalue = 0;
- p7values.vvalue = 0;
- p8values.vvalue = 0;
- p9values.vvalue = 0;
- p1values.vlength = 0;
- p2values.vlength = 0;
- p3values.vlength = 0;
- p4values.vlength = 0;
- p5values.vlength = 0;
- p6values.vlength = 0;
- p7values.vlength = 0;
- p8values.vlength = 0;
- p9values.vlength = 0;
- p1values.voffset = 0;
- p2values.voffset = 0;
- p3values.voffset = 0;
- p4values.voffset = 0;
- p5values.voffset = 0;
- p6values.voffset = 0;
- p7values.voffset = 0;
- p8values.voffset = 0;
- p9values.voffset = 0;
- p1values.hfname = 0;
- p2values.hfname = 0;
- p3values.hfname = 0;
- p4values.hfname = 0;
- p5values.hfname = 0;
- p6values.hfname = 0;
- p7values.hfname = 0;
- p8values.hfname = 0;
- p9values.hfname = 0;
- p1values.vdesc = "";
- p2values.vdesc = "";
- p3values.vdesc = "";
- p4values.vdesc = "";
- p5values.vdesc = "";
- p6values.vdesc = "";
- p7values.vdesc = "";
- p8values.vdesc = "";
- p9values.vdesc = "";
- p1values.vstring = "";
- p2values.vstring = "";
- p3values.vstring = "";
- p4values.vstring = "";
- p5values.vstring = "";
- p6values.vstring = "";
- p7values.vstring = "";
- p8values.vstring = "";
- p9values.vstring = "";
+ 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:
- verb_string = "Resolve Name";
if(request_value->nds_version == 0)
{
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = match_strval(p1values.vvalue, nds_tags);
- if(p1values.vstring == NULL)
+ pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
+ pvalues[0].vstring = match_strval(pvalues[0].vvalue, nds_tags);
+ if(pvalues[0].vstring == NULL)
{
- p1values.vstring = "No Tags Set";
+ pvalues[0].vstring = "No Tags Set";
}
- p1values.vtype = 4; /* String */
- p1values.vdesc = "Tag: %s";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_tag_string;
- nds_offset = nds_offset+p1values.vlength;
- switch(p1values.vvalue)
+ 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 0: /* No Such Entry */
break;
case 1: /* Local Entry */
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
+ pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
+ pvalues[1].vtype = VTYPE_UINT32;
+ pvalues[1].vdesc = "Entry ID: 0x%08x";
add_eid = TRUE;
- global_object_name = request_value->object_name;
- global_eid = p2values.vvalue;
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Referal Records: %d";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_referals;
- p3values.mvtype = 9;
+ 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 2: /* Remote Entry */
nds_offset += 4; /* GUINT32 reserved field */
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
+ pvalues[1].vvalue = tvb_get_letohl(tvb, nds_offset);
+ pvalues[1].vtype = VTYPE_UINT32;
+ pvalues[1].vdesc = "Entry ID: 0x%08x";
add_eid = TRUE;
- global_eid = p2values.vvalue;
- global_object_name = request_value->object_name;
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Referal Records: %d";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_referals;
- p3values.mvtype = 9;
+ 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 3: /* Alias Entry */
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Alias Name: %s";
- p2values.vstring = "";
- p2values.mvtype = 1;
- p2values.vvalue = 0;
- p2values.vlength = 256;
- p2values.vlength = tvb_get_letohl(tvb, nds_offset);
- if (p2values.vlength == 0x00)
+ 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)
{
- p2values.vtype = 0;
+ pvalues[1].vtype = VTYPE_NONE;
break;
}
- p2values.voffset = nds_offset+4;
+ pvalues[1].voffset = nds_offset+4;
nds_offset += 4;
- get_string(tvb, p2values.voffset, p2values.vlength, p2values.vstring);
- nds_offset += p2values.vlength;
+ get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, pvalues[1].vstring);
+ nds_offset += pvalues[1].vlength;
nds_offset += align_4(tvb, nds_offset);
- p2values.hfname= hf_nds_name;
+ pvalues[1].hfname= hf_nds_name;
break;
case 4: /* Referral Information */
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Distance Object is From Root: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Referal Records: %d";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_depth;
- p3values.mvtype = 9;
+ 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_LOC_ADDR_REFERRAL_REPLY;
break;
case 6: /* Entry and Referrals */
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Result Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_result_flags;
- nds_offset = nds_offset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
+ 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;
- global_eid = p3values.vvalue;
- global_object_name = request_value->object_name;
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p4values.vtype = 6; /* Multivalue Uint32 */
- p4values.vstring = "";
- p4values.vdesc = "Referal Records: %d";
- p4values.vlength = 4;
- p4values.voffset = nds_offset;
- p4values.mvtype = 8;
- p4values.hfname = hf_nds_referals;
+ 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
{
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "CRC: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_crc;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = match_strval(p2values.vvalue, nds_tags);
- if(p2values.vstring == NULL)
+ 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 = match_strval(pvalues[1].vvalue, nds_tags);
+ if(pvalues[1].vstring == NULL)
{
- p2values.vstring = "No Tags Set";
+ pvalues[1].vstring = "No Tags Set";
}
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Tag: %s";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- nds_offset = nds_offset+p2values.vlength;
- p2values.hfname = hf_nds_tag_string;
- switch(p2values.vvalue)
+ 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 0: /* No Such Entry */
break;
case 1: /* Local Entry */
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
+ pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
+ pvalues[2].vtype = VTYPE_UINT32;
+ pvalues[2].vdesc = "Entry ID: 0x%08x";
add_eid = TRUE;
- global_eid = p3values.vvalue;
- global_object_name = request_value->object_name;
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p4values.vtype = 6; /* Multivalue Uint32 */
- p4values.vstring = "";
- p4values.vdesc = "Referal Records: %d";
- p4values.vlength = 4;
- p4values.voffset = nds_offset;
- p4values.hfname = hf_nds_referals;
- p4values.mvtype = 9;
+ 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 2: /* Remote Entry */
nds_offset += 4; /* GUINT32 reserved field */
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vstring = "";
+ pvalues[2].vvalue = tvb_get_letohl(tvb, nds_offset);
add_eid = TRUE;
- global_eid = p3values.vvalue;
- global_object_name = request_value->object_name;
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p4values.vtype = 6; /* Multivalue Uint32 */
- p4values.vstring = "";
- p4values.vdesc = "Referal Records: %d";
- p4values.vlength = 4;
- p4values.voffset = nds_offset;
- p4values.hfname = hf_nds_referals;
- p4values.mvtype = 9;
+ 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 3: /* Alias Entry */
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Alias Name: %s";
- p3values.vstring = "";
- p3values.mvtype = 1;
- p3values.vvalue = 0;
- p3values.vlength = 256;
- p3values.vlength = tvb_get_letohl(tvb, nds_offset);
- if (p3values.vlength == 0x00)
+ 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)
{
- p3values.vtype = 0;
+ pvalues[2].vtype = VTYPE_NONE;
break;
}
- p3values.voffset = nds_offset+4;
+ pvalues[2].voffset = nds_offset+4;
nds_offset += 4;
- get_string(tvb, p3values.voffset, p3values.vlength, p3values.vstring);
- nds_offset += p3values.vlength;
+ get_string(tvb, pvalues[2].voffset, pvalues[2].vlength, pvalues[2].vstring);
+ nds_offset += pvalues[2].vlength;
nds_offset += align_4(tvb, nds_offset);
- p3values.hfname= hf_nds_name;
+ pvalues[2].hfname= hf_nds_name;
break;
case 4: /* Referral Information */
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Distance Object is From Root: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p4values.vtype = 6; /* Multivalue Uint32 */
- p4values.vstring = "";
- p4values.vdesc = "Referal Records: %d";
- p4values.vlength = 4;
- p4values.voffset = nds_offset;
- p4values.hfname = hf_nds_depth;
- p4values.mvtype = 8;
+ 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 6: /* Entry and Referrals */
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Result Flags: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_result_flags;
- nds_offset = nds_offset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p4values.vstring = "";
- p4values.vtype = 3; /* Uint32 */
- p4values.vdesc = "Entry ID: 0x%08x";
+ 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;
- global_object_name = request_value->object_name;
- global_eid = p4values.vvalue;
- p4values.vlength = 4;
- p4values.voffset = nds_offset;
- p4values.hfname = hf_nds_eid;
- nds_offset = nds_offset+p4values.vlength;
- p5values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p5values.vtype = 6; /* Multivalue Uint32 */
- p5values.vstring = "";
- p5values.vdesc = "Referal Records: %d";
- p5values.vlength = 4;
- p5values.voffset = nds_offset;
- p5values.mvtype = 8;
- p5values.hfname = hf_nds_referals;
+ 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:
- verb_string = "Read Entry Information";
if(request_value->nds_version != 0x000000fe)
{
- p1values.vvalue = 1;
- p1values.vtype = 6; /* Multivalue Uint32 */
- p1values.vstring = "";
- p1values.vdesc = "Entry Information";
- p1values.vlength = 0;
- p1values.voffset = nds_offset-4;
- p1values.hfname = hf_nds_name;
- p1values.mvtype = 12;
- p1values.vflags = request_value->req_nds_flags;
+ 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
{
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "CRC: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_crc;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = 1;
- p2values.vtype = 6; /* Multivalue Uint32 */
- p2values.vstring = "";
- p2values.vdesc = "Entry Information";
- p2values.vlength = 0;
- p2values.voffset = nds_offset-4;
- p2values.hfname = hf_nds_name;
- p2values.mvtype = 12;
- p2values.vflags = request_value->req_nds_flags;
+ 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:
- verb_string = "Read";
if(request_value->nds_version != 0x000000fe)
{
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Iteration Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = match_strval(p2values.vvalue, nds_info_type);
- if(p2values.vstring == NULL)
+ 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 = match_strval(pvalues[1].vvalue, nds_info_type);
+ if(pvalues[1].vstring == NULL)
{
- p2values.vstring = "No Info Type Set";
+ pvalues[1].vstring = "No Info Type Set";
}
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Info Type: %s";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_info_type;
- nds_offset = nds_offset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Number of Attributes: %d";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_attr;
- p3values.mvtype = 2;
- p3values.vflags = request_value->req_nds_flags;
+ 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
{
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "CRC: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_crc;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Iteration Handle: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vstring = match_strval(p3values.vvalue, nds_info_type);
- if(p3values.vstring == NULL)
+ 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 = match_strval(pvalues[2].vvalue, nds_info_type);
+ if(pvalues[2].vstring == NULL)
{
- p3values.vstring = "No Info Type Set";
+ pvalues[2].vstring = "No Info Type Set";
}
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Info Type: %s";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_info_type;
- nds_offset = nds_offset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p4values.vtype = 6; /* Multivalue Uint32 */
- p4values.vstring = "";
- p4values.vdesc = "Number of Attributes: %d";
- p4values.vlength = 4;
- p4values.voffset = nds_offset;
- p4values.hfname = hf_nds_attr;
- p4values.mvtype = 2;
- p4values.vflags = request_value->req_nds_flags;
+ 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:
- verb_string = "Compare";
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- if (p1values.vvalue == 0x00000000)
+ pvalues[0].vvalue = tvb_get_letohl(tvb, nds_offset);
+ if (pvalues[0].vvalue == 0x00000000)
{
- p1values.vstring = "Did Not Match";
+ pvalues[0].vstring = "Did Not Match";
}
else
{
- p1values.vstring = "Matched";
+ pvalues[0].vstring = "Matched";
}
- p1values.vtype = 4; /* String */
- p1values.vdesc = "Compare Values Returned - %s";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.mvtype = 0;
- p1values.hfname= hf_nds_compare_results;
- nds_offset += p1values.vlength;
+ 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:
- verb_string = "List";
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Iteration Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);;
- p2values.vtype = 6; /* Multivalue Uint32 */
- p2values.vstring = "";
- p2values.vdesc = "Entry Information";
- p2values.vlength = 0;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_name;
- p2values.mvtype = 12;
- p2values.vflags = request_value->req_nds_flags;
+ 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:
- verb_string = "Search Entries";
break;
case 0x07:
- verb_string = "Add Entry";
break;
case 0x08:
- verb_string = "Remove Entry";
break;
case 0x09:
- verb_string = "Modify Entry";
break;
case 0x0a:
- verb_string = "Modify RDN";
break;
case 0x0b:
- verb_string = "Define Attribute";
break;
case 0x0c:
- verb_string = "Read Attribute Definition";
break;
case 0x0d:
- verb_string = "Remove Attribute Definition";
break;
case 0x0e:
- verb_string = "Define Class";
break;
case 0x0f:
- verb_string = "Read Class Definition";
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Iteration Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = match_strval(p2values.vvalue, class_def_type);
- if(p2values.vstring == NULL)
+ 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 = match_strval(pvalues[1].vvalue, class_def_type);
+ if(pvalues[1].vstring == NULL)
{
- p2values.vstring = "No Class Definition Type Set";
+ pvalues[1].vstring = "No Class Definition Type Set";
}
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Class Definition Type: %s";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.mvtype = 0;
- p2values.hfname= hf_nds_class_def_type;
- nds_offset = nds_offset + p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);;
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Class Definitions %d";
- p3values.vlength = 0;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_classes;
- p3values.mvtype = 13;
- p3values.vflags = request_value->req_nds_flags;
+ 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:
- verb_string = "Modify Class Definition";
break;
case 0x11:
- verb_string = "Remove Class Definition";
break;
case 0x12:
- verb_string = "List Containable Classes";
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Iteration Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vtype = 6; /* Multivalue Uint32 */
- p2values.vstring = "";
- p2values.vdesc = "Classes: %d";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.mvtype = 4;
- p2values.hfname= hf_nds_classes;
+ 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:
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Privileges: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_privileges;
- nds_offset = nds_offset+p1values.vlength;
+ 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:
- verb_string = "Add Partition";
break;
case 0x15:
- verb_string = "Remove Partition";
break;
case 0x16:
- verb_string = "List Partitions";
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Iteration Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Server Distinguished Name: %s";
- p2values.vstring = "";
- p2values.mvtype = 1;
- p2values.vvalue = 0;
- p2values.vlength = 256;
- p2values.vlength = tvb_get_letohl(tvb, nds_offset);
- if (p2values.vlength == 0x00)
+ 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)
{
- p2values.vtype = 0;
+ pvalues[1].vtype = VTYPE_NONE;
break;
}
- p2values.voffset = nds_offset+4;
+ pvalues[1].voffset = nds_offset+4;
nds_offset += 4;
- get_string(tvb, p2values.voffset, p2values.vlength, p2values.vstring);
- nds_offset += p2values.vlength;
+ get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, pvalues[1].vstring);
+ nds_offset += pvalues[1].vlength;
nds_offset += align_4(tvb, nds_offset);
- p2values.hfname= hf_nds_name;
+ pvalues[1].hfname= hf_nds_name;
nds_offset += align_4(tvb, nds_offset);
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Replicas: %d";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_replicas;
- p3values.mvtype = 5;
- p3values.bit1 = "Output Flags";
- p3values.bit2 = "Entry ID";
- p3values.bit3 = "Replica State";
- p3values.bit4 = "Modification Timestamp";
- p3values.bit5 = "Purge Time";
- p3values.bit6 = "Local Partition ID";
- p3values.bit7 = "Distinguished Name";
- p3values.bit8 = "Replica Type";
- p3values.bit9 = "Partition Busy";
- p3values.vflags = request_value->req_nds_flags;
+ 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:
- verb_string = "Split Partition";
break;
case 0x18:
- verb_string = "Join Partitions";
break;
case 0x19:
- verb_string = "Add Replica";
break;
case 0x1a:
- verb_string = "Remove Replica";
break;
case 0x1b:
- verb_string = "Open Stream";
- p1values.vvalue = tvb_get_ntohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "File Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_file_handle;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "File Size: %d";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_file_size;
- nds_offset = nds_offset+p2values.vlength;
+ 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:
- verb_string = "Search Filter";
break;
case 0x1d:
- verb_string = "Create Subordinate Reference";
break;
case 0x1e:
- verb_string = "Link Replica";
break;
case 0x1f:
- verb_string = "Change Replica Type";
break;
case 0x20:
- verb_string = "Start Update Schema";
break;
case 0x21:
- verb_string = "End Update Schema";
break;
case 0x22:
- verb_string = "Update Schema";
break;
case 0x23:
- verb_string = "Start Update Replica";
break;
case 0x24:
- verb_string = "End Update Replica";
break;
case 0x25:
- verb_string = "Update Replica";
break;
case 0x26:
- verb_string = "Synchronize Partition";
break;
case 0x27:
- verb_string = "Synchronize Schema";
break;
case 0x28:
- verb_string = "Read Syntaxes";
break;
case 0x29:
- verb_string = "Get Replica Root ID";
break;
case 0x2a:
- verb_string = "Begin Move Entry";
break;
case 0x2b:
- verb_string = "Finish Move Entry";
break;
case 0x2c:
- verb_string = "Release Moved Entry";
break;
case 0x2d:
- verb_string = "Backup Entry";
break;
case 0x2e:
- verb_string = "Restore Entry";
break;
case 0x2f:
- verb_string = "Save DIB";
break;
case 0x30:
- verb_string = "Control";
break;
case 0x31:
- verb_string = "Remove Backlink";
break;
case 0x32:
- verb_string = "Close Iteration";
break;
case 0x33:
- verb_string = "Mutate Entry";
break;
case 0x34:
- verb_string = "Audit Skulking";
break;
case 0x35:
- verb_string = "Get Server Address";
if(request_value->nds_version != 0x000000fe)
{
- p1values.vtype = 4; /* String */
- p1values.vdesc = "Distinguished Name: %s";
- p1values.vstring = "";
- p1values.mvtype = 1;
- p1values.vvalue = 0;
- p1values.vlength = 256;
- p1values.vlength = tvb_get_letohl(tvb, nds_offset);
- if (p1values.vlength == 0x00)
+ 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)
{
- p1values.vtype = 0;
+ pvalues[0].vtype = VTYPE_NONE;
break;
}
- p1values.voffset = nds_offset+4;
+ pvalues[0].voffset = nds_offset+4;
nds_offset += 4;
- get_string(tvb, p1values.voffset, p1values.vlength, p1values.vstring);
- nds_offset += p1values.vlength;
+ get_string(tvb, pvalues[0].voffset, pvalues[0].vlength, pvalues[0].vstring);
+ nds_offset += pvalues[0].vlength;
nds_offset += align_4(tvb, nds_offset);
- p1values.hfname= hf_nds_name;
- p2values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p2values.vtype = 6; /* Multivalue Uint32 */
- p2values.vstring = "";
- p2values.vdesc = "Referal Records: %d";
- p2values.vlength = 4;
- p2values.voffset = nds_offset;
- p2values.hfname = hf_nds_referals;
- p2values.mvtype = 9;
+ 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
{
- p1values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Iteration Handle: 0x%08x";
- p1values.vlength = 4;
- p1values.voffset = nds_offset;
- p1values.hfname = hf_nds_iteration;
- nds_offset = nds_offset+p1values.vlength;
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Distinguished Name: %s";
- p2values.vstring = "";
- p2values.mvtype = 1;
- p2values.vvalue = 0;
- p2values.vlength = 256;
- p2values.vlength = tvb_get_letohl(tvb, nds_offset);
- if (p2values.vlength == 0x00)
+ 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)
{
- p2values.vtype = 0;
+ pvalues[1].vtype = VTYPE_NONE;
break;
}
- p2values.voffset = nds_offset+4;
+ pvalues[1].voffset = nds_offset+4;
nds_offset += 4;
- get_string(tvb, p2values.voffset, p2values.vlength, p2values.vstring);
- nds_offset += p2values.vlength;
+ get_string(tvb, pvalues[1].voffset, pvalues[1].vlength, pvalues[1].vstring);
+ nds_offset += pvalues[1].vlength;
nds_offset += align_4(tvb, nds_offset);
- p2values.hfname= hf_nds_name;
- p3values.vvalue = tvb_get_letohl(tvb, nds_offset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Referal Records: %d";
- p3values.vlength = 4;
- p3values.voffset = nds_offset;
- p3values.hfname = hf_nds_referals;
- p3values.mvtype = 9;
+ 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:
- verb_string = "Set Keys";
break;
case 0x37:
- verb_string = "Change Password";
break;
case 0x38:
- verb_string = "Verify Password";
break;
case 0x39:
- verb_string = "Begin Login";
break;
case 0x3a:
- verb_string = "Finish Login";
break;
case 0x3b:
- verb_string = "Begin Authentication";
break;
case 0x3c:
- verb_string = "Finish Authentication";
break;
case 0x3d:
- verb_string = "Logout";
break;
case 0x3e:
- verb_string = "Repair Ring";
break;
case 0x3f:
- verb_string = "Repair Timestamps";
break;
case 0x40:
- verb_string = "Create Back Link";
break;
case 0x41:
- verb_string = "Delete External Reference";
break;
case 0x42:
- verb_string = "Rename External Reference";
break;
case 0x43:
- verb_string = "Create Directory Entry";
break;
case 0x44:
- verb_string = "Remove Directory Entry";
break;
case 0x45:
- verb_string = "Designate New Master";
break;
case 0x46:
- verb_string = "Change Tree Name";
break;
case 0x47:
- verb_string = "Partition Entry Count";
break;
case 0x48:
- verb_string = "Check Login Restrictions";
break;
case 0x49:
- verb_string = "Start Join";
break;
case 0x4a:
- verb_string = "Low Level Split";
break;
case 0x4b:
- verb_string = "Low Level Join";
break;
case 0x4c:
- verb_string = "Abort Low Level Join";
break;
case 0x4d:
- verb_string = "Get All Servers";
break;
default:
- verb_string = "NDS Continuation Fragment";
break;
}
- if(request_value->nds_request_verb != NULL)
+ 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_eid_value = ncp_eid_hash_lookup(conversation, global_eid);
if (!request_eid_value) {
- request_eid_value = ncp_eid_hash_insert(conversation, global_eid, ncp_rec);
+ request_eid_value = ncp_eid_hash_insert(global_eid);
strcpy(request_eid_value->object_name, 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) {
- global_object_name = request_eid_value->object_name;
+ 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);
- }
- }
- if (p1values.vtype != 0) {
- switch (p1values.vtype) {
- case 1: /* uint8 */
- proto_tree_add_uint_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vtype, "NDS Parameter not defined %d",
- p1values.vtype);
- break;
- case 2: /* uint16 */
- proto_tree_add_uint_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vtype, "NDS Parameter not defined %d",
- p1values.vtype);
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vvalue, p1values.vdesc,
- p1values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vdesc, p1values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p1values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p1values);
- break;
- default:
- proto_tree_add_uint_format(ncp_tree, hf_nds_p1type, tvb, p1values.voffset,
- p1values.vlength, p1values.vtype, "NDS Parameter not defined %d",
- p1values.vtype);
- break;
- }
- switch (p2values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p2values.hfname, tvb, p2values.voffset,
- p2values.vlength, p2values.vvalue, p2values.vdesc,
- p2values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p2values.hfname, tvb, p2values.voffset,
- p2values.vlength, p2values.vdesc, p2values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p2values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p2values);
- break;
- default:
- break;
- }
- switch (p3values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p3values.hfname, tvb, p3values.voffset,
- p3values.vlength, p3values.vvalue, p3values.vdesc,
- p3values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p3values.hfname, tvb, p3values.voffset,
- p3values.vlength, p3values.vdesc, p3values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p3values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p3values);
- break;
- default:
- break;
- }
- switch (p4values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p4values.hfname, tvb, p4values.voffset,
- p4values.vlength, p4values.vvalue, p4values.vdesc,
- p4values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p4values.hfname, tvb, p4values.voffset,
- p4values.vlength, p4values.vdesc, p4values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p4values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p4values);
- break;
- default:
- break;
- }
- switch (p5values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p5values.hfname, tvb, p5values.voffset,
- p5values.vlength, p5values.vvalue, p5values.vdesc,
- p5values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p5values.hfname, tvb, p5values.voffset,
- p5values.vlength, p5values.vdesc, p5values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p5values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p5values);
- break;
- default:
- break;
- }
- switch (p6values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p6values.hfname, tvb, p6values.voffset,
- p6values.vlength, p6values.vvalue, p6values.vdesc,
- p6values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p6values.hfname, tvb, p6values.voffset,
- p6values.vlength, p6values.vdesc, p6values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p6values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p6values);
- break;
- default:
- break;
- }
- switch (p7values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p7values.hfname, tvb, p7values.voffset,
- p7values.vlength, p7values.vvalue, p7values.vdesc,
- p7values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p7values.hfname, tvb, p7values.voffset,
- p7values.vlength, p7values.vdesc, p7values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p7values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p7values);
- break;
- default:
- break;
- }
- switch (p8values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p8values.hfname, tvb, p8values.voffset,
- p8values.vlength, p8values.vvalue, p8values.vdesc,
- p8values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p8values.hfname, tvb, p8values.voffset,
- p8values.vlength, p8values.vdesc, p8values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p8values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p8values);
- break;
- default:
- break;
- }
- switch (p9values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p9values.hfname, tvb, p9values.voffset,
- p9values.vlength, p9values.vvalue, p9values.vdesc,
- p9values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p9values.hfname, tvb, p9values.voffset,
- p9values.vlength, p9values.vdesc, p9values.vstring);
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p9values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p9values);
- break;
- default:
- break;
- }
- }
+ 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;
+ }
+ }
}
}
- }
- /*
- * Unless this is a reply, that's all there is to parse.
- */
- if (type != NCP_SERVICE_REPLY)
- return;
+ }
length = tvb_length(tvb);
if (!ncp_rec && length > 8) {
ncp_req_hash_value *request_value = NULL;
ncp_req_eid_hash_value *request_eid_value = NULL;
const ncp_record *ncp_rec = NULL;
- ncp_req_hash_value *nds_rec = NULL;
conversation_t *conversation;
- conversation_t *eid_conversation;
ptvcursor_t *ptvc = NULL;
proto_tree *temp_tree = NULL;
+ gboolean run_req_cond = FALSE;
+ gboolean run_info_str = FALSE;
guint8 nds_verb = 0;
char * verb_string = "";
guint32 nds_frag = 0;
- nds_val p1values;
- nds_val p2values;
- nds_val p3values;
- nds_val p4values;
- nds_val p5values;
- nds_val p6values;
- nds_val p7values;
- nds_val p8values;
- nds_val p9values;
- guint32 value1= 0;
- guint32 value2= 0;
- char * nds_string = "";
+ gboolean added_arrow;
+ nds_val pvalues[9];
+ char string_buffer[9][1024];
guint8 nds_version = 0;
guint32 foffset = 0;
- guint32 nlength = 0;
- guint32 nds_reply_buffer;
nw_uni_t req_buffer;
- char * global_object_name="\0";
+ char global_object_name[256];
guint32 global_eid=0;
- boolean resolve_eid=FALSE;
+ 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;
+ }
+
+ strcpy(req_buffer.buffer, "");
+ strcpy(global_object_name, "");
- p1values.vtype = 0;
- p2values.vtype = 0;
- p3values.vtype = 0;
- p4values.vtype = 0;
- p5values.vtype = 0;
- p6values.vtype = 0;
- p7values.vtype = 0;
- p8values.vtype = 0;
- p9values.vtype = 0;
- p1values.mvtype = 0;
- p2values.mvtype = 0;
- p3values.mvtype = 0;
- p4values.mvtype = 0;
- p5values.mvtype = 0;
- p6values.mvtype = 0;
- p7values.mvtype = 0;
- p8values.mvtype = 0;
- p9values.mvtype = 0;
- req_buffer.buffer = "\0";
func = tvb_get_guint8(tvb, 6);
subfunc = tvb_get_guint8(tvb, 7);
/* Check to see if this is a fragment packet */
nds_frag = tvb_get_letohl(tvb, 8);
-
/* Get NDS Verb */
if (nds_frag == 0xffffffff) {
nds_verb = tvb_get_guint8(tvb, 24);
nds_version = 0;
foffset = 28;
}
- nds_reply_buffer = tvb_get_letohl(tvb, foffset);
- proto_tree_add_uint_format(ncp_tree, hf_nds_buffer_size, tvb, foffset,
- 4, nds_reply_buffer, "NDS Reply Buffer Size %d",
- nds_reply_buffer);
+ 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:
- verb_string = "Resolve Name -> ";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p1values.vvalue;
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.hfname = hf_nds_ver;
- p1values.voffset = foffset;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vtype = 5; /* Bitfield */
- p2values.vstring = "";
- p2values.vdesc = "Flags:";
- p2values.vlength = 2;
- p2values.hfname= hf_nds_nflags;
- p2values.voffset = foffset;
- p2values.bit1 = "Entry ID";
- p2values.bit1hfname = hf_bit1nflags;
- p2values.bit2 = "Readable";
- p2values.bit2hfname = hf_bit2nflags;
- p2values.bit3 = "Writeable";
- p2values.bit3hfname = hf_bit3nflags;
- p2values.bit4 = "Master";
- p2values.bit4hfname = hf_bit4nflags;
- p2values.bit5 = "Create ID";
- p2values.bit5hfname = hf_bit5nflags;
- p2values.bit6 = "Walk Tree";
- p2values.bit6hfname = hf_bit6nflags;
- p2values.bit7 = "Dereference Alias";
- p2values.bit7hfname = hf_bit7nflags;
- p2values.bit8 = "Not Defined";
- p2values.bit8hfname = hf_bit8nflags;
- p2values.bit9 = "Not Defined";
- p2values.bit9hfname = hf_bit9nflags;
- p2values.bit10 = "Not Defined";
- p2values.bit10hfname = hf_bit10nflags;
- p2values.bit11= "Not Defined";
- p2values.bit11hfname = hf_bit11nflags;
- p2values.bit12 = "Not Defined";
- p2values.bit12hfname = hf_bit12nflags;
- p2values.bit13 = "Not Defined";
- p2values.bit13hfname = hf_bit13nflags;
- p2values.bit14 = "Prefer Referalls";
- p2values.bit14hfname = hf_bit14nflags;
- p2values.bit15 = "Prefer Only Referalls";
- p2values.bit15hfname = hf_bit15nflags;
- p2values.bit16 = "Not Defined";
- p2values.bit16hfname = hf_bit16nflags;
+ 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 (p1values.vvalue == 0 || p1values.vvalue == 1)
+ if (pvalues[0].vvalue == 0 || pvalues[0].vvalue == 1)
{
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Scope: %d";
- p3values.vstring = "";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.hfname= hf_nds_scope;
- foffset = foffset+p3values.vlength;
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Name: %s";
- p4values.vstring = "";
- p4values.mvtype = 1;
- p4values.vvalue = 0;
- p4values.vlength = 256;
- p4values.vlength = tvb_get_letohl(tvb, foffset);
- if (p4values.vlength == 0x00)
+ 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)
{
- p4values.vtype = 0;
+ pvalues[3].vtype = VTYPE_NONE;
break;
}
- p4values.voffset = foffset+4;
+ pvalues[3].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p4values.voffset, p4values.vlength, req_buffer.buffer);
- p4values.vstring = req_buffer.buffer;
- global_object_name = req_buffer.buffer;
- p4values.hfname= hf_nds_name;
- foffset = foffset+p4values.vlength;
+ 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);
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vtype = 6; /* Mulitvalue Uint32 */
- p5values.vstring = "";
- p5values.vdesc = "Communications Transports: %d";
- p5values.vlength = 4;
- p5values.hfname= hf_nds_comm_trans;
- p5values.voffset = foffset;
- p5values.mvtype = 7;
- foffset = foffset + (p5values.vvalue * 4) + 4;
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.vtype = 6; /* Multivalue Uint32 */
- p6values.vstring = "";
- p6values.vdesc = "Tree Walker Transport Type: %d";
- p6values.vlength = 4;
- p6values.mvtype = 7;
- p6values.hfname= hf_nds_tree_trans;
- p6values.voffset = 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
{
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Minimum DS Version: %d";
- p3values.vstring = "";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.hfname= hf_min_nds_ver;
- foffset = foffset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vtype = 6; /* Multivalue Uint32 */
- p4values.vstring = "";
- p4values.vdesc = "Number of Versions to Include: %d";
- p4values.vlength = 4;
- p4values.mvtype = 3;
- p4values.voffset = foffset;
- p4values.hfname= hf_nds_ver_include;
- foffset += (p4values.vvalue * 4) + 4;
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vtype = 6; /* Multivalue Uint32 */
- p5values.vstring = "";
- p5values.vdesc = "Number of Versions to Exclude: %d";
- p5values.vlength = 4;
- p5values.mvtype = 3;
- p5values.hfname= hf_nds_ver_exclude;
- p5values.voffset = foffset;
+ 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;
- p6values.vtype = 3; /* Uint32 */
- p6values.vdesc = "DN Output Type: %d";
- p6values.vstring = "";
- p6values.vlength = 4;
- p6values.voffset = foffset;
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.hfname= hf_nds_dn_output_type;
- foffset = foffset+p6values.vlength;
- p7values.vtype = 3; /* Uint32 */
- p7values.vdesc = "Nested Output Type: %d";
- p7values.vstring = "";
- p7values.vlength = 4;
- p7values.voffset = foffset;
- p7values.vvalue = tvb_get_letohl(tvb, foffset);
- p7values.hfname= hf_nds_nested_output_type;
- foffset = foffset+p7values.vlength;
- p8values.vtype = 4; /* String */
- p8values.vdesc = "Output Delimiter: %s";
- p8values.vstring = "";
- p8values.mvtype = 1;
- p8values.vvalue = 0;
- p8values.vlength = 256;
- p8values.vlength = tvb_get_letohl(tvb, foffset);
- p8values.voffset = 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, p8values.voffset, p8values.vlength, req_buffer.buffer);
- p8values.vstring = req_buffer.buffer;
- p8values.hfname= hf_nds_output_delimiter;
- foffset = foffset+p8values.vlength;
+ 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);
- p9values.vvalue = tvb_get_letohl(tvb, foffset);
- p9values.vtype = 6; /* Multivalue Uint32 */
- p9values.vstring = "";
- p9values.vdesc = "Size of Entry Specifier: %d";
- p9values.vlength = 4;
- p9values.mvtype = 10;
- p9values.hfname= hf_nds_output_entry_specifier;
- p9values.voffset = 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:
- verb_string = "Read Entry Information";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- switch(p1values.vvalue)
+ 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:
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname = hf_nds_eid;
- foffset = foffset+p2values.vlength;
+ global_eid = pvalues[1].vvalue;
+ pvalues[1].voffset = foffset;
+ pvalues[1].hfname = hf_nds_eid;
+ foffset = foffset+pvalues[1].vlength;
break;
case 1:
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vtype = 5; /* Bitfield */
- p2values.vstring = "";
- p2values.vdesc = "Request Flags:";
- p2values.vlength = 2;
- p2values.hfname= hf_nds_rflags;
- p2values.voffset = foffset;
- p2values.bit1 = "Typeless";
- p2values.bit1hfname = hf_bit1rflags;
- p2values.bit2 = "Slashed";
- p2values.bit2hfname = hf_bit2rflags;
- p2values.bit3 = "Dotted";
- p2values.bit3hfname = hf_bit3rflags;
- p2values.bit4 = "Tuned";
- p2values.bit4hfname = hf_bit4rflags;
- p2values.bit5 = "Not Defined";
- p2values.bit5hfname = hf_bit5rflags;
- p2values.bit6 = "Not Defined";
- p2values.bit6hfname = hf_bit6rflags;
- p2values.bit7 = "Not Defined";
- p2values.bit7hfname = hf_bit7rflags;
- p2values.bit8 = "Not Defined";
- p2values.bit8hfname = hf_bit8rflags;
- p2values.bit9 = "Not Defined";
- p2values.bit9hfname = hf_bit9rflags;
- p2values.bit10 = "Not Defined";
- p2values.bit10hfname = hf_bit10rflags;
- p2values.bit11 = "Not Defined";
- p2values.bit11hfname = hf_bit11rflags;
- p2values.bit12 = "Not Defined";
- p2values.bit12hfname = hf_bit12rflags;
- p2values.bit13 = "Not Defined";
- p2values.bit13hfname = hf_bit13rflags;
- p2values.bit14 = "Not Defined";
- p2values.bit14hfname = hf_bit14rflags;
- p2values.bit15 = "Not Defined";
- p2values.bit15hfname = hf_bit15rflags;
- p2values.bit16 = "Not Defined";
- p2values.bit16hfname = hf_bit16rflags;
- if((p2values.vvalue&&0xf000) == 0xc000)
+ 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)
{
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Name Type: %s";
- p3values.vstring = "Partial";
- p3values.mvtype = 0;
- p3values.vvalue = 0;
- p3values.vlength = 0;
- p3values.voffset = 0;
- p3values.hfname= hf_nds_name_type;
+ 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
{
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Name Type: %s";
- p3values.vstring = "Full";
- p3values.vvalue = 0;
- p3values.mvtype = 0;
- p3values.vlength = 0;
- p3values.voffset = 0;
- p3values.hfname= hf_nds_name_type;
+ 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;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = "";
- p4values.vtype = 3; /* Uint32 */
- p4values.vdesc = "Entry ID: 0x%08x";
- p4values.vlength = 4;
- p4values.voffset = foffset;
+ 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 = p4values.vvalue;
- p4values.hfname = hf_nds_eid;
- foffset = foffset+p4values.vlength;
+ global_eid = pvalues[3].vvalue;
+ pvalues[3].hfname = hf_nds_eid;
+ foffset = foffset+pvalues[3].vlength;
break;
case 2:
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vtype = 5; /* Bitfield */
- p2values.vstring = "";
- p2values.vdesc = "Request Flags:";
- p2values.vlength = 2;
- p2values.hfname= hf_nds_rflags;
- p2values.voffset = foffset;
- p2values.bit1 = "Typeless";
- p2values.bit1hfname = hf_bit1rflags;
- p2values.bit2 = "Slashed";
- p2values.bit2hfname = hf_bit2rflags;
- p2values.bit3 = "Dotted";
- p2values.bit3hfname = hf_bit3rflags;
- p2values.bit4 = "Tuned";
- p2values.bit4hfname = hf_bit4rflags;
- p2values.bit5 = "Not Defined";
- p2values.bit5hfname = hf_bit5rflags;
- p2values.bit6 = "Not Defined";
- p2values.bit6hfname = hf_bit6rflags;
- p2values.bit7 = "Not Defined";
- p2values.bit7hfname = hf_bit7rflags;
- p2values.bit8 = "Not Defined";
- p2values.bit8hfname = hf_bit8rflags;
- p2values.bit9 = "Not Defined";
- p2values.bit9hfname = hf_bit9rflags;
- p2values.bit10 = "Not Defined";
- p2values.bit10hfname = hf_bit10rflags;
- p2values.bit11 = "Not Defined";
- p2values.bit11hfname = hf_bit11rflags;
- p2values.bit12 = "Not Defined";
- p2values.bit12hfname = hf_bit12rflags;
- p2values.bit13 = "Not Defined";
- p2values.bit13hfname = hf_bit13rflags;
- p2values.bit14 = "Not Defined";
- p2values.bit14hfname = hf_bit14rflags;
- p2values.bit15 = "Not Defined";
- p2values.bit15hfname = hf_bit15rflags;
- p2values.bit16 = "Not Defined";
- p2values.bit16hfname = hf_bit16rflags;
- if((p2values.vvalue&&0xf000) == 0xc000)
+ 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)
{
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Name Type: %s";
- p3values.vstring = "Return Partion Name";
- p3values.vvalue = 0;
- p3values.vlength = 4;
- p3values.voffset = p2values.voffset;
- p3values.mvtype = 0;
- p3values.hfname= hf_nds_name_type;
+ 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
{
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Name Type: %s";
- p3values.vstring = "Return Full Name";
- p3values.vvalue = 0;
- p3values.vlength = 4;
- p3values.mvtype = 0;
- p3values.voffset = p2values.voffset;
- p3values.hfname= hf_nds_name_type;
+ 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;
- p4values.vvalue = tvb_get_letohs(tvb, foffset);
+ pvalues[3].vvalue = tvb_get_letohs(tvb, foffset);
global_flags = tvb_get_letohl(tvb, foffset);
- p4values.vtype = 5; /* Bitfield */
- p4values.vstring = "";
- p4values.vdesc = "Information Flags (low) Byte:";
- p4values.vlength = 2;
- p4values.hfname= hf_nds_rflags;
- p4values.voffset = foffset;
- p4values.bit1 = "Output Flags";
- p4values.bit1hfname = hf_bit1infoflagsl;
- p4values.bit2 = "Entry ID";
- p4values.bit2hfname = hf_bit2infoflagsl;
- p4values.bit3 = "Entry Flags";
- p4values.bit3hfname = hf_bit3infoflagsl;
- p4values.bit4 = "Subordinate Count";
- p4values.bit4hfname = hf_bit4infoflagsl;
- p4values.bit5 = "Modification Time";
- p4values.bit5hfname = hf_bit5infoflagsl;
- p4values.bit6 = "Modification Timestamp";
- p4values.bit6hfname = hf_bit6infoflagsl;
- p4values.bit7 = "Creation Timestamp";
- p4values.bit7hfname = hf_bit7infoflagsl;
- p4values.bit8 = "Partition Root ID";
- p4values.bit8hfname = hf_bit8infoflagsl;
- p4values.bit9 = "Parent ID";
- p4values.bit9hfname = hf_bit9infoflagsl;
- p4values.bit10 = "Revision Count";
- p4values.bit10hfname = hf_bit10infoflagsl;
- p4values.bit11 = "Replica Type";
- p4values.bit11hfname = hf_bit11infoflagsl;
- p4values.bit12 = "Base Class";
- p4values.bit12hfname = hf_bit12infoflagsl;
- p4values.bit13 = "Relative Distinguished Name";
- p4values.bit13hfname = hf_bit13infoflagsl;
- p4values.bit14 = "Distinguished Name";
- p4values.bit14hfname = hf_bit14infoflagsl;
- p4values.bit15 = "Root Distinguished Name";
- p4values.bit15hfname = hf_bit15infoflagsl;
- p4values.bit16 = "Parent Distinguished Name";
- p4values.bit16hfname = hf_bit16infoflagsl;
+ 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;
- p5values.vvalue = tvb_get_letohs(tvb, foffset);
- p5values.vtype = 5; /* Bitfield */
- p5values.vstring = "";
- p5values.vdesc = "Information Flags (high) Byte:";
- p5values.vlength = 2;
- p5values.hfname= hf_nds_rflags;
- p5values.voffset = foffset;
- p5values.bit1 = "Purge Time";
- p5values.bit1hfname = hf_bit1infoflagsh;
- p5values.bit2 = "Dereference Base Class";
- p5values.bit2hfname = hf_bit2infoflagsh;
- p5values.bit3 = "Not Defined";
- p5values.bit3hfname = hf_bit3infoflagsh;
- p5values.bit4 = "Not Defined";
- p5values.bit4hfname = hf_bit4infoflagsh;
- p5values.bit5 = "Not Defined";
- p5values.bit5hfname = hf_bit5infoflagsh;
- p5values.bit6 = "Not Defined";
- p5values.bit6hfname = hf_bit6infoflagsh;
- p5values.bit7 = "Not Defined";
- p5values.bit7hfname = hf_bit7infoflagsh;
- p5values.bit8 = "Not Defined";
- p5values.bit8hfname = hf_bit8infoflagsh;
- p5values.bit9 = "Not Defined";
- p5values.bit9hfname = hf_bit9infoflagsh;
- p5values.bit10 = "Not Defined";
- p5values.bit10hfname = hf_bit10infoflagsh;
- p5values.bit11 = "Not Defined";
- p5values.bit11hfname = hf_bit11infoflagsh;
- p5values.bit12 = "Not Defined";
- p5values.bit12hfname = hf_bit12infoflagsh;
- p5values.bit13 = "Not Defined";
- p5values.bit13hfname = hf_bit13infoflagsh;
- p5values.bit14 = "Not Defined";
- p5values.bit14hfname = hf_bit14infoflagsh;
- p5values.bit15 = "Not Defined";
- p5values.bit15hfname = hf_bit15infoflagsh;
- p5values.bit16 = "Not Defined";
- p5values.bit16hfname = hf_bit16infoflagsh;
+ 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;
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.vstring = "";
- p6values.vtype = 3; /* Uint32 */
- p6values.vdesc = "Entry ID: 0x%08x";
- p6values.vlength = 4;
- p6values.voffset = foffset;
+ 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 = p6values.vvalue;
- p6values.hfname = hf_nds_eid;
- foffset = foffset+p6values.vlength;
+ global_eid = pvalues[5].vvalue;
+ pvalues[5].hfname = hf_nds_eid;
+ foffset = foffset+pvalues[5].vlength;
break;
default:
break;
break;
case 0x03:
- verb_string = "Read -> ";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- if(p1values.vvalue == 0)
+ 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)
{
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Iteration Handle: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_iteration;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
- p3values.vlength = 4;
+ 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 = p3values.vvalue;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_eid;
- foffset = foffset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = match_strval(p4values.vvalue, nds_info_type);
- global_flags = p4values.vvalue;
- if(p4values.vstring == NULL)
+ 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 = match_strval(pvalues[3].vvalue, nds_info_type);
+ global_flags = pvalues[3].vvalue;
+ if(pvalues[3].vstring == NULL)
{
- p4values.vstring = "No Info Type Set";
+ pvalues[3].vstring = "No Info Type Set";
}
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Info Type: %s";
- p4values.vlength = 4;
- p4values.voffset = foffset;
- p4values.mvtype = 1;
- p4values.hfname= hf_nds_info_type;
- foffset = foffset + p4values.vlength;
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vstring = "";
- p5values.vtype = 3; /* Uint32 */
- p5values.vdesc = "All Attributes: %d";
- p5values.vlength = 4;
- p5values.voffset = foffset;
- p5values.hfname= hf_nds_all_attr;
- foffset = foffset+p5values.vlength;
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.vtype = 6; /* Multivalue Uint32 */
- p6values.vstring = "";
- p6values.vdesc = "Attributes: %d";
- p6values.vlength = 4;
- p6values.voffset = foffset;
- p6values.mvtype = 1;
- p6values.hfname= hf_nds_attr;
+ 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
{
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Request Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_req_flags;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Iteration Handle: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_iteration;
- foffset = foffset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = "";
- p4values.vtype = 3; /* Uint32 */
- p4values.vdesc = "Entry ID: 0x%08x";
- p4values.vlength = 4;
+ 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 = p4values.vvalue;
- p4values.voffset = foffset;
- p4values.hfname= hf_nds_eid;
- foffset = foffset+p4values.vlength;
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vstring = match_strval(p5values.vvalue, nds_info_type);
- global_flags = p5values.vvalue;
- if(p5values.vstring == NULL)
+ 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 = match_strval(pvalues[4].vvalue, nds_info_type);
+ global_flags = pvalues[4].vvalue;
+ if(pvalues[4].vstring == NULL)
{
- p5values.vstring = "No Info Type Set";
+ pvalues[4].vstring = "No Info Type Set";
}
- p5values.vtype = 4; /* String */
- p5values.vdesc = "Info Type: %s";
- p5values.vlength = 4;
- p5values.voffset = foffset;
- p5values.hfname= hf_nds_info_type;
- p5values.mvtype = 1;
- foffset = foffset+p5values.vlength;
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.vstring = "";
- p6values.vtype = 3; /* Uint32 */
- p6values.vdesc = "All Attributes: %d";
- p6values.vlength = 4;
- p6values.voffset = foffset;
- p6values.hfname= hf_nds_all_attr;
- foffset = foffset+p6values.vlength;
- p7values.vvalue = tvb_get_letohl(tvb, foffset);
- p7values.vtype = 6; /* Multivalue Uint32 */
- p7values.vstring = "";
- p7values.vdesc = "Attributes: %d";
- p7values.vlength = 4;
- p7values.voffset = foffset;
- p7values.mvtype = 1;
- p7values.hfname= hf_nds_attr;
+ 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:
- verb_string = "Compare";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname = hf_nds_eid;
- foffset = foffset+p2values.vlength;
+ 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 */
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Attribute Name Being Compared: %s";
- p3values.vstring = "";
- p3values.mvtype = 1;
- p3values.vvalue = 0;
- p3values.vlength = 256;
- p3values.vlength = tvb_get_letohl(tvb, foffset);
- if (p3values.vlength == 0x00)
+ 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)
{
- p3values.vtype = 0;
+ pvalues[2].vtype = VTYPE_NONE;
break;
}
- p3values.voffset = foffset+4;
+ pvalues[2].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p3values.voffset, p3values.vlength, req_buffer.buffer);
- p3values.vstring = req_buffer.buffer;
- global_object_name = req_buffer.buffer;
- p3values.hfname= hf_nds_name;
- foffset = foffset+p3values.vlength;
+ 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 */
/***************
***************/
break;
case 0x05:
- verb_string = "List -> ";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vtype = 5; /* Bitfield */
- p2values.vstring = "";
- p2values.vdesc = "Request Flags:";
- p2values.vlength = 2;
- p2values.hfname= hf_nds_rflags;
- p2values.voffset = foffset;
- p2values.bit1 = "List Typeless";
- p2values.bit1hfname = hf_bit1lflags;
- p2values.bit2 = "List Containers";
- p2values.bit2hfname = hf_bit2lflags;
- p2values.bit3 = "List Slashed";
- p2values.bit3hfname = hf_bit3lflags;
- p2values.bit4 = "List Dotted";
- p2values.bit4hfname = hf_bit4lflags;
- p2values.bit5 = "Dereference Alias";
- p2values.bit5hfname = hf_bit5lflags;
- p2values.bit6 = "List All Containers";
- p2values.bit6hfname = hf_bit6lflags;
- p2values.bit7 = "List Obsolete";
- p2values.bit7hfname = hf_bit7lflags;
- p2values.bit8 = "List Tuned Output";
- p2values.bit8hfname = hf_bit8lflags;
- p2values.bit9 = "List External Reference";
- p2values.bit9hfname = hf_bit9lflags;
- p2values.bit10 = "Not Defined";
- p2values.bit10hfname = hf_bit10lflags;
- p2values.bit11 = "Not Defined";
- p2values.bit11hfname = hf_bit11lflags;
- p2values.bit12 = "Not Defined";
- p2values.bit12hfname = hf_bit12lflags;
- p2values.bit13 = "Not Defined";
- p2values.bit13hfname = hf_bit13lflags;
- p2values.bit14 = "Not Defined";
- p2values.bit14hfname = hf_bit14lflags;
- p2values.bit15 = "Not Defined";
- p2values.bit15hfname = hf_bit15lflags;
- p2values.bit16 = "Not Defined";
- p2values.bit16hfname = hf_bit16lflags;
- foffset = foffset+p2values.vlength;
+ 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;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Iteration Handle: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_iteration;
- foffset = foffset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = "";
- p4values.vtype = 3; /* Uint32 */
- p4values.vdesc = "Parent ID: 0x%08x";
- p4values.vlength = 4;
- p4values.voffset = foffset;
- p4values.hfname= hf_nds_parent;
- foffset = foffset+p4values.vlength;
- p5values.vvalue = tvb_get_letohs(tvb, foffset);
+ 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);
- p5values.vtype = 5; /* Bitfield */
- p5values.vstring = "";
- p5values.vdesc = "Information Flags (low) Byte:";
- p5values.vlength = 2;
- p5values.hfname= hf_nds_rflags;
- p5values.voffset = foffset;
- p5values.bit1 = "Output Flags";
- p5values.bit1hfname = hf_bit1infoflagsl;
- p5values.bit2 = "Entry ID";
- p5values.bit2hfname = hf_bit2infoflagsl;
- p5values.bit3 = "Entry Flags";
- p5values.bit3hfname = hf_bit3infoflagsl;
- p5values.bit4 = "Subordinate Count";
- p5values.bit4hfname = hf_bit4infoflagsl;
- p5values.bit5 = "Modification Time";
- p5values.bit5hfname = hf_bit5infoflagsl;
- p5values.bit6 = "Modification Timestamp";
- p5values.bit6hfname = hf_bit6infoflagsl;
- p5values.bit7 = "Creation Timestamp";
- p5values.bit7hfname = hf_bit7infoflagsl;
- p5values.bit8 = "Partition Root ID";
- p5values.bit8hfname = hf_bit8infoflagsl;
- p5values.bit9 = "Parent ID";
- p5values.bit9hfname = hf_bit9infoflagsl;
- p5values.bit10 = "Revision Count";
- p5values.bit10hfname = hf_bit10infoflagsl;
- p5values.bit11 = "Replica Type";
- p5values.bit11hfname = hf_bit11infoflagsl;
- p5values.bit12 = "Base Class";
- p5values.bit12hfname = hf_bit12infoflagsl;
- p5values.bit13 = "Relative Distinguished Name";
- p5values.bit13hfname = hf_bit13infoflagsl;
- p5values.bit14 = "Distinguished Name";
- p5values.bit14hfname = hf_bit14infoflagsl;
- p5values.bit15 = "Root Distinguished Name";
- p5values.bit15hfname = hf_bit15infoflagsl;
- p5values.bit16 = "Parent Distinguished Name";
- p5values.bit16hfname = hf_bit16infoflagsl;
+ 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;
- p6values.vvalue = tvb_get_letohs(tvb, foffset);
- p6values.vtype = 5; /* Bitfield */
- p6values.vstring = "";
- p6values.vdesc = "Information Flags (high) Byte:";
- p6values.vlength = 2;
- p6values.hfname= hf_nds_rflags;
- p6values.voffset = foffset;
- p6values.bit1 = "Purge Time";
- p6values.bit1hfname = hf_bit1infoflagsh;
- p6values.bit2 = "Dereference Base Class";
- p6values.bit2hfname = hf_bit2infoflagsh;
- p6values.bit3 = "Not Defined";
- p6values.bit3hfname = hf_bit3infoflagsh;
- p6values.bit4 = "Not Defined";
- p6values.bit4hfname = hf_bit4infoflagsh;
- p6values.bit5 = "Not Defined";
- p6values.bit5hfname = hf_bit5infoflagsh;
- p6values.bit6 = "Not Defined";
- p6values.bit6hfname = hf_bit6infoflagsh;
- p6values.bit7 = "Not Defined";
- p6values.bit7hfname = hf_bit7infoflagsh;
- p6values.bit8 = "Not Defined";
- p6values.bit8hfname = hf_bit8infoflagsh;
- p6values.bit9 = "Not Defined";
- p6values.bit9hfname = hf_bit9infoflagsh;
- p6values.bit10 = "Not Defined";
- p6values.bit10hfname = hf_bit10infoflagsh;
- p6values.bit11 = "Not Defined";
- p6values.bit11hfname = hf_bit11infoflagsh;
- p6values.bit12 = "Not Defined";
- p6values.bit12hfname = hf_bit12infoflagsh;
- p6values.bit13 = "Not Defined";
- p6values.bit13hfname = hf_bit13infoflagsh;
- p6values.bit14 = "Not Defined";
- p6values.bit14hfname = hf_bit14infoflagsh;
- p6values.bit15 = "Not Defined";
- p6values.bit15hfname = hf_bit15infoflagsh;
- p6values.bit16 = "Not Defined";
- p6values.bit16hfname = hf_bit16infoflagsh;
+ 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;
- p7values.vtype = 4; /* String */
- p7values.vdesc = "Name Filter: %s";
- p7values.vstring = "";
- p7values.mvtype = 1;
- p7values.vvalue = 0;
- p7values.vlength = 256;
- p7values.vlength = tvb_get_letohl(tvb, foffset);
- p7values.voffset = foffset+4;
+ 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, p7values.voffset, p7values.vlength, p7values.vstring);
- p7values.hfname= hf_nds_name_filter;
- foffset = foffset+p7values.vlength;
- if(p1values.vvalue == 0)
+ 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);
- p8values.vtype = 4; /* String */
- p8values.vdesc = "Class Filter: %s";
- p8values.vstring = "";
- p8values.mvtype = 1;
- p8values.vvalue = 0;
- p8values.vlength = 256;
- p8values.vlength = tvb_get_letohl(tvb, foffset);
- p8values.voffset = foffset+4;
+ 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, p8values.voffset, p8values.vlength, p8values.vstring);
- p8values.hfname= hf_nds_class_filter;
- foffset = foffset+p8values.vlength;
- if(p1values.vvalue == 1)
+ 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);
- p9values.vvalue = tvb_get_letohl(tvb, foffset);
- p9values.vtype = 6; /* Multivalue Uint32 */
- p9values.vstring = "";
- p9values.vdesc = "Seconds %d";
- p9values.vlength = 4;
- p9values.mvtype = 11;
- p9values.hfname= hf_nds_time_filter;
- p9values.voffset = 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:
- verb_string = "Search Entries";
- p1values.vtype = 0; /* Not Defined */
+ 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 = 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:
- verb_string = "Add Entry";
- p1values.vtype = 0; /* Not Defined */
+ 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:
- verb_string = "Remove Entry";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_eid;
- foffset = foffset+p2values.vlength;
+ global_eid = pvalues[1].vvalue;
+ pvalues[1].voffset = foffset;
+ pvalues[1].hfname= hf_nds_eid;
+ foffset = foffset+pvalues[1].vlength;
break;
case 0x09:
- verb_string = "Modify Entry";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vtype = 3; /* Uint32 */
- p2values.vstring = "";
- p2values.vdesc = "Request Flags: 0x%08x"; /* always 0 */
- p2values.vlength = 4;
- p2values.hfname= hf_nds_rflags;
- p2values.voffset = foffset;
- foffset = foffset+4;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vtype = 3; /* Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Iteration Handle: 0x%08x"; /* always 0 */
- p3values.vlength = 4;
- p3values.hfname= hf_nds_iteration;
- p3values.voffset = foffset;
- foffset = foffset+4;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = "";
- p4values.vtype = 3; /* Uint32 */
- p4values.vdesc = "Entry ID: 0x%08x";
- p4values.vlength = 4;
- p4values.voffset = foffset;
- resolve_eid = TRUE;
- global_eid = p4values.vvalue;
- p4values.hfname = hf_nds_eid;
- foffset = foffset+p4values.vlength;
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vtype = 6; /* Multivalue Uint32 */
- p5values.vstring = "";
- p5values.vdesc = "Number of Attributes to Change %d";
- p5values.vlength = 4;
- p5values.mvtype = 6;
- p5values.hfname= hf_nds_number_of_changes;
- p5values.voffset = foffset;
+ 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:
- verb_string = "Modify RDN";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname = hf_nds_eid;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vtype = 8; /* Boolean */
- p3values.vdesc = "Keep Original RDN: %s";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.mvtype = 0;
- p3values.hfname= hf_nds_keep;
+ 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);
- p4values.vtype = 4; /* String */
- p4values.vdesc = "New RDN: %s";
- p4values.vstring = "";
- p4values.mvtype = 0;
- p4values.vvalue = 0;
- p4values.vlength = 256;
- p4values.vlength = tvb_get_letohl(tvb, foffset);
- p4values.voffset = foffset+4;
+ 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, p4values.voffset, p4values.vlength, p4values.vstring);
- p4values.hfname= hf_nds_new_rdn;
- foffset = foffset+p4values.vlength;
+ 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:
- verb_string = "Define Attribute ->";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohs(tvb, foffset);
+ 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);
- p2values.vtype = 5; /* Bitfield */
- p2values.vstring = "";
- p2values.vdesc = "Attribute Constraints:";
- p2values.vlength = 2;
- p2values.hfname= hf_nds_acflags;
- p2values.voffset = foffset;
- p2values.bit1 = "Single Valued";
- p2values.bit1hfname = hf_bit1acflags;
- p2values.bit2 = "Sized";
- p2values.bit2hfname = hf_bit2acflags;
- p2values.bit3 = "Non-Removable";
- p2values.bit3hfname = hf_bit3acflags;
- p2values.bit4 = "Read Only";
- p2values.bit4hfname = hf_bit4acflags;
- p2values.bit5 = "Hidden";
- p2values.bit5hfname = hf_bit5acflags;
- p2values.bit6 = "String";
- p2values.bit6hfname = hf_bit6acflags;
- p2values.bit7 = "Synchronize Immediate";
- p2values.bit7hfname = hf_bit7acflags;
- p2values.bit8 = "Public Read";
- p2values.bit8hfname = hf_bit8acflags;
- p2values.bit9 = "Server Read";
- p2values.bit9hfname = hf_bit9acflags;
- p2values.bit10 = "Write Managed";
- p2values.bit10hfname = hf_bit10acflags;
- p2values.bit11 = "Per Replica";
- p2values.bit11hfname = hf_bit11acflags;
- p2values.bit12 = "Never Schedule Synchronization";
- p2values.bit12hfname = hf_bit12acflags;
- p2values.bit13 = "Operational";
- p2values.bit13hfname = hf_bit13acflags;
- p2values.bit14 = "Not Defined";
- p2values.bit14hfname = hf_bit14acflags;
- p2values.bit15 = "Not Defined";
- p2values.bit15hfname = hf_bit15acflags;
- p2values.bit16 = "Not Defined";
- p2values.bit16hfname = hf_bit16acflags;
+ 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;
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Attribute Name: %s";
- p3values.vstring = "";
- p3values.mvtype = 1;
- p3values.vvalue = 0;
- p3values.vlength = 256;
- p3values.vlength = tvb_get_letohl(tvb, foffset);
- if (p3values.vlength == 0x00)
+ 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)
{
- p3values.vtype = 0;
+ pvalues[2].vtype = VTYPE_NONE;
break;
}
- p3values.voffset = foffset+4;
+ pvalues[2].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p3values.voffset, p3values.vlength, req_buffer.buffer);
- p3values.vstring = req_buffer.buffer;
- global_object_name = req_buffer.buffer;
- p3values.hfname= hf_nds_name;
- foffset = foffset+p3values.vlength;
+ 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);
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = match_strval(p4values.vvalue, nds_syntax);
- if(p4values.vstring == NULL)
+ pvalues[3].vvalue = tvb_get_letohl(tvb, foffset);
+ pvalues[3].vstring = match_strval(pvalues[3].vvalue, nds_syntax);
+ if(pvalues[3].vstring == NULL)
{
- p4values.vstring = "No Syntax Found";
+ pvalues[3].vstring = "No Syntax Found";
}
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Syntax: %s";
- p4values.vlength = 4;
- p4values.voffset = foffset;
- p4values.hfname= hf_nds_syntax;
- p4values.mvtype = 0;
- foffset = foffset+p4values.vlength;
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vstring = "";
- p5values.vtype = 3; /* Uint32 */
- p5values.vdesc = "Lower Limit Value %d";
- p5values.vlength = 4;
- p5values.voffset = foffset;
- p5values.hfname = hf_nds_lower;
+ 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;
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.vstring = "";
- p6values.vtype = 3; /* Uint32 */
- p6values.vdesc = "Upper Limit Value %d";
- p6values.vlength = 4;
- p6values.voffset = foffset;
- p6values.hfname = hf_nds_upper;
- p7values.vvalue = tvb_get_letohl(tvb, foffset); /* Length of bytes field */
+ 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;
- p7values.vstring = "";
- p7values.vtype = 7; /* Bytes */
- p7values.vdesc = "ASN.1 ID";
- p7values.vlength = p7values.vvalue;
- p7values.voffset = foffset;
- p7values.hfname = hf_nds_asn1;
+ 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:
- verb_string = "Read Attribute Definition";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x0d:
- verb_string = "Remove Attribute Definition";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Attribute Name: %s";
- p2values.vstring = "";
- p2values.mvtype = 1;
- p2values.vvalue = 0;
- p2values.vlength = 256;
- p2values.vlength = tvb_get_letohl(tvb, foffset);
- if (p2values.vlength == 0x00)
+ 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)
{
- p2values.vtype = 0;
+ pvalues[1].vtype = VTYPE_NONE;
break;
}
- p2values.voffset = foffset+4;
+ pvalues[1].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p2values.voffset, p2values.vlength, req_buffer.buffer);
- p2values.vstring = req_buffer.buffer;
- global_object_name = req_buffer.buffer;
- p2values.hfname= hf_nds_attribute_dn;
+ 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:
- verb_string = "Define Class";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x0f:
- verb_string = "Read Class Definition ->";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Iteration Handle: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_iteration;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- global_flags = p3values.vvalue;
- p3values.vstring = match_strval(p3values.vvalue, class_def_type);
- if(p3values.vstring == NULL)
+ 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 = match_strval(pvalues[2].vvalue, class_def_type);
+ if(pvalues[2].vstring == NULL)
{
- p3values.vstring = "No Class Definition Type Set";
+ pvalues[2].vstring = "No Class Definition Type Set";
}
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Class Definition Type: %s";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.mvtype = 0;
- p3values.hfname= hf_nds_class_def_type;
- foffset = foffset + p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- if (p4values.vvalue == 0x00000000)
+ 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)
{
- p4values.vstring = "Return All Classes = False";
+ pvalues[3].vstring = "Do Not Return All Classes";
+ pvalues[3].mvtype = 0;
}
else
{
- p4values.vstring = "Return All Classes = True";
+ pvalues[3].vstring = "Return All Classes";
+ pvalues[3].mvtype = MVTYPE_ATTR_REQUEST;
}
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Return all Classes %s";
- p4values.vlength = 4;
- p4values.voffset = foffset;
- p4values.mvtype = 0;
- p4values.hfname= hf_nds_return_all_classes;
- foffset = foffset + p4values.vlength;
+ 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);
- p5values.vvalue = tvb_get_letohl(tvb, foffset);
- p5values.vtype = 6; /* Multivalue Uint32 */
- p5values.vstring = "";
- p5values.vdesc = "Classes: %d";
- p5values.vlength = 4;
- p5values.voffset = foffset;
- p5values.mvtype = 4;
- p5values.hfname= hf_nds_classes;
+ 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:
- verb_string = "Modify Class Definition -> ";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Class Name: %s";
- p2values.vstring = "";
- p2values.mvtype = 1;
- p2values.vvalue = 0;
- p2values.vlength = 256;
- p2values.vlength = tvb_get_letohl(tvb, foffset);
- if (p2values.vlength == 0x00)
+ 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)
{
- p2values.vtype = 0;
+ pvalues[1].vtype = VTYPE_NONE;
break;
}
- p2values.voffset = foffset+4;
+ pvalues[1].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p2values.voffset, p2values.vlength, req_buffer.buffer);
- p2values.vstring = req_buffer.buffer;
- global_object_name = req_buffer.buffer;
- p2values.hfname= hf_nds_base_class;
- foffset = foffset+p2values.vlength;
+ 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);
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vtype = 6; /* Multivalue Uint32 */
- p3values.vstring = "";
- p3values.vdesc = "Number of Attributes to Add: %d";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.mvtype = 14;
- p3values.hfname= hf_nds_att_add;
+ 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:
- verb_string = "Remove Class Definition";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vtype = 4; /* String */
- p2values.vdesc = "Class Name: %s";
- p2values.vstring = "";
- p2values.mvtype = 1;
- p2values.vvalue = 0;
- p2values.vlength = 256;
- p2values.vlength = tvb_get_letohl(tvb, foffset);
- if (p2values.vlength == 0x00)
+ 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)
{
- p2values.vtype = 0;
+ pvalues[1].vtype = VTYPE_NONE;
break;
}
- p2values.voffset = foffset+4;
+ pvalues[1].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p2values.voffset, p2values.vlength, req_buffer.buffer);
- p2values.vstring = req_buffer.buffer;
- global_object_name = req_buffer.buffer;
- p2values.hfname= hf_nds_base;
+ 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:
- verb_string = "List Containable Classes";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Iteration Handle: 0x%08x";
- p2values.vlength = 4;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_iteration;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
- p3values.vlength = 4;
+ 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 = p3values.vvalue;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_eid;
- foffset = foffset+p3values.vlength;
+ global_eid = pvalues[2].vvalue;
+ pvalues[2].voffset = foffset;
+ pvalues[2].hfname= hf_nds_eid;
+ foffset = foffset+pvalues[2].vlength;
break;
case 0x13:
- verb_string = "Get Effective Rights -> ";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_eid;
- foffset = foffset+p2values.vlength;
- p3values.vtype = 4; /* String */
- p3values.vdesc = "Trustee Name: %s";
- p3values.vstring = "";
- p3values.mvtype = 1;
- p3values.vvalue = 0;
- p3values.vlength = 256;
- p3values.vlength = tvb_get_letohl(tvb, foffset);
- if (p3values.vlength == 0x00)
+ 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)
{
- p3values.vtype = 0;
+ pvalues[2].vtype = VTYPE_NONE;
break;
}
- p3values.voffset = foffset+4;
+ pvalues[2].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p3values.voffset, p3values.vlength, req_buffer.buffer);
- p3values.vstring = req_buffer.buffer;
- p3values.hfname= hf_nds_name;
- foffset = foffset+p3values.vlength;
+ 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);
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Attribute to be Checked: %s";
- p4values.vstring = "";
- p4values.mvtype = 0;
- p4values.vvalue = 0;
- p4values.vlength = 256;
- p4values.vlength = tvb_get_letohl(tvb, foffset);
- if (p4values.vlength == 0x00)
+ 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)
{
- p4values.vtype = 0;
+ pvalues[3].vtype = VTYPE_NONE;
break;
}
- p4values.voffset = foffset+4;
+ pvalues[3].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p4values.voffset, p4values.vlength, p4values.vstring);
- p4values.hfname= hf_nds_name;
- foffset = foffset+p4values.vlength;
+ 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(p1values.vvalue != 0)
+ if(pvalues[0].vvalue != 0)
{
- p5values.vtype = 4; /* String */
- p5values.vdesc = "Security Equivalence: %s";
- p5values.vstring = "";
- p5values.mvtype = 1;
- p5values.vvalue = 0;
- p5values.vlength = 256;
- p5values.vlength = tvb_get_letohl(tvb, foffset);
- if (p5values.vlength == 0x00)
+ 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)
{
- p5values.vtype = 0;
+ pvalues[4].vtype = VTYPE_NONE;
break;
}
- p5values.voffset = foffset+4;
+ pvalues[4].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p5values.voffset, p5values.vlength, p5values.vstring);
- p5values.hfname= hf_nds_name;
- foffset = foffset+p5values.vlength;
+ 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:
- verb_string = "Add Partition";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x15:
- verb_string = "Remove Partition";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x16:
- verb_string = "List Partitions";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vtype = 5; /* Bitfield */
- p2values.vstring = "";
- p2values.vdesc = "Request Flags:";
- p2values.vlength = 2;
- p2values.hfname= hf_nds_rflags;
- p2values.voffset = foffset;
- p2values.bit1 = "Typeless";
- p2values.bit1hfname = hf_nds_bit1;
- p2values.bit2 = "All Containers";
- p2values.bit2hfname = hf_nds_bit2;
- p2values.bit3 = "Slashed";
- p2values.bit3hfname = hf_nds_bit3;
- p2values.bit4 = "Dotted";
- p2values.bit4hfname = hf_nds_bit4;
- p2values.bit5 = "Tuned";
- p2values.bit5hfname = hf_nds_bit5;
- p2values.bit6 = "Not Defined";
- p2values.bit6hfname = hf_nds_bit6;
- p2values.bit7 = "Not Defined";
- p2values.bit7hfname = hf_nds_bit7;
- p2values.bit8 = "Not Defined";
- p2values.bit8hfname = hf_nds_bit8;
- p2values.bit9 = "Not Defined";
- p2values.bit9hfname = hf_nds_bit9;
- p2values.bit10 = "Not Defined";
- p2values.bit10hfname = hf_nds_bit10;
- p2values.bit11 = "Not Defined";
- p2values.bit11hfname = hf_nds_bit11;
- p2values.bit12 = "Not Defined";
- p2values.bit12hfname = hf_nds_bit12;
- p2values.bit13 = "Not Defined";
- p2values.bit13hfname = hf_nds_bit13;
- p2values.bit14 = "Not Defined";
- p2values.bit14hfname = hf_nds_bit14;
- p2values.bit15 = "Not Defined";
- p2values.bit15hfname = hf_nds_bit15;
- p2values.bit16 = "Not Defined";
- p2values.bit16hfname = hf_nds_bit16;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Iteration Handle: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_iteration;
- foffset = foffset+p3values.vlength;
- if(p1values.vvalue == 0)
+ 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;
}
- p4values.vvalue = tvb_get_letohs(tvb, foffset);
- p4values.vtype = 5; /* Bitfield */
- p4values.vstring = "";
- p4values.vdesc = "Information Flags (low) Byte:";
- p4values.vlength = 2;
- p4values.hfname= hf_nds_rflags;
- p4values.voffset = foffset;
- p4values.bit1 = "Output Flags";
- p4values.bit1hfname = hf_bit1l1flagsl;
- p4values.bit2 = "Entry ID";
- p4values.bit2hfname = hf_bit2l1flagsl;
- p4values.bit3 = "Replica State";
- p4values.bit3hfname = hf_bit3l1flagsl;
- p4values.bit4 = "Modification Timestamp";
- p4values.bit4hfname = hf_bit4l1flagsl;
- p4values.bit5 = "Purge Time";
- p4values.bit5hfname = hf_bit5l1flagsl;
- p4values.bit6 = "Local Partition ID";
- p4values.bit6hfname = hf_bit6l1flagsl;
- p4values.bit7 = "Distinguished Name";
- p4values.bit7hfname = hf_bit7l1flagsl;
- p4values.bit8 = "Replica Type";
- p4values.bit8hfname = hf_bit8l1flagsl;
- p4values.bit9 = "Partition Busy";
- p4values.bit9hfname = hf_bit9l1flagsl;
- p4values.bit10 = "Not Defined";
- p4values.bit10hfname = hf_bit10l1flagsl;
- p4values.bit11 = "Not Defined";
- p4values.bit11hfname = hf_bit11l1flagsl;
- p4values.bit12 = "Not Defined";
- p4values.bit12hfname = hf_bit12l1flagsl;
- p4values.bit13 = "Not Defined";
- p4values.bit13hfname = hf_bit13l1flagsl;
- p4values.bit14 = "Not Defined";
- p4values.bit14hfname = hf_bit14l1flagsl;
- p4values.bit15 = "Not Defined";
- p4values.bit15hfname = hf_bit15l1flagsl;
- p4values.bit16 = "Not Defined";
- p4values.bit16hfname = hf_bit16l1flagsl;
- global_flags = p4values.vvalue;
+ 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;
- p5values.vvalue = tvb_get_letohs(tvb, foffset);
- p5values.vtype = 5; /* Bitfield */
- p5values.vstring = "";
- p5values.vdesc = "Information Flags (high) Byte:";
- p5values.vlength = 2;
- p5values.hfname= hf_nds_rflags;
- p5values.voffset = foffset;
- p5values.bit1 = "Not Defined";
- p5values.bit1hfname = hf_bit1l1flagsl;
- p5values.bit2 = "Not Defined";
- p5values.bit2hfname = hf_bit2l1flagsl;
- p5values.bit3 = "Not Defined";
- p5values.bit3hfname = hf_bit3l1flagsl;
- p5values.bit4 = "Not Defined";
- p5values.bit4hfname = hf_bit4l1flagsl;
- p5values.bit5 = "Not Defined";
- p5values.bit5hfname = hf_bit5l1flagsl;
- p5values.bit6 = "Not Defined";
- p5values.bit6hfname = hf_bit6l1flagsl;
- p5values.bit7 = "Not Defined";
- p5values.bit7hfname = hf_bit7l1flagsl;
- p5values.bit8 = "Not Defined";
- p5values.bit8hfname = hf_bit8l1flagsl;
- p5values.bit9 = "Not Defined";
- p5values.bit9hfname = hf_bit9l1flagsl;
- p5values.bit10 = "Not Defined";
- p5values.bit10hfname = hf_bit10l1flagsl;
- p5values.bit11 = "Not Defined";
- p5values.bit11hfname = hf_bit11l1flagsl;
- p5values.bit12 = "Not Defined";
- p5values.bit12hfname = hf_bit12l1flagsl;
- p5values.bit13 = "Not Defined";
- p5values.bit13hfname = hf_bit13l1flagsl;
- p5values.bit14 = "Not Defined";
- p5values.bit14hfname = hf_bit14l1flagsl;
- p5values.bit15 = "Not Defined";
- p5values.bit15hfname = hf_bit15l1flagsl;
- p5values.bit16 = "Not Defined";
- p5values.bit16hfname = hf_bit16l1flagsl;
+ 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(p1values.vvalue == 1)
+ if(pvalues[0].vvalue == 1)
{
break;
}
- p6values.vvalue = tvb_get_letohl(tvb, foffset);
- p6values.vstring = "";
- p6values.vtype = 3; /* Uint32 */
- p6values.vdesc = "Partition Root ID: 0x%08x";
- p6values.vlength = 4;
- p6values.voffset = foffset;
- p6values.hfname= hf_nds_partition_root_id;
- foffset = foffset+p6values.vlength;
+ 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:
- verb_string = "Split Partition";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p1values.vvalue;
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.hfname = hf_nds_ver;
- p1values.voffset = foffset;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p2values.vvalue;
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.hfname = hf_nds_req_flags;
- p2values.voffset = foffset;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "New Partition Root ID: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_new_part_id;
- foffset = foffset+p3values.vlength;
+ 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:
- verb_string = "Join Partitions";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p1values.vvalue;
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.hfname = hf_nds_ver;
- p1values.voffset = foffset;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p2values.vvalue;
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.hfname = hf_nds_req_flags;
- p2values.voffset = foffset;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Child Partition Root ID: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_child_part_id;
- foffset = foffset+p3values.vlength;
+ 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:
- verb_string = "Add Replica";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p1values.vvalue;
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.hfname = hf_nds_ver;
- p1values.voffset = foffset;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p2values.vvalue;
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.hfname = hf_nds_req_flags;
- p2values.voffset = foffset;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Master Partition Root ID: 0x%08x";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_master_part_id;
- foffset = foffset+p3values.vlength;
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = match_strval(p4values.vvalue, nds_replica_type);
- if(p4values.vstring == NULL)
+ 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 = match_strval(pvalues[3].vvalue, nds_replica_type);
+ if(pvalues[3].vstring == NULL)
{
- p4values.vstring = "No Replica Type Found";
+ pvalues[3].vstring = "No Replica Type Found";
}
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Replica Type: %s";
- p4values.vlength = 4;
- p4values.voffset = foffset;
- p4values.mvtype = 0;
- p4values.hfname= hf_replica_type;
- foffset = foffset + p4values.vlength;
- p5values.vtype = 4; /* String */
- p5values.vdesc = "Target Server Name: %s";
- p5values.vstring = "";
- p5values.mvtype = 0;
- p5values.vvalue = 0;
- p5values.vlength = 256;
- p5values.vlength = tvb_get_letohl(tvb, foffset);
- if (p5values.vlength == 0x00)
+ 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)
{
- p5values.vtype = 0;
+ pvalues[4].vtype = VTYPE_NONE;
break;
}
- p5values.voffset = foffset+4;
+ pvalues[4].voffset = foffset+4;
foffset = foffset + 4;
- get_string(tvb, p5values.voffset, p5values.vlength, p5values.vstring);
- p5values.hfname= hf_nds_target_name;
+ get_string(tvb, pvalues[4].voffset, pvalues[4].vlength, pvalues[4].vstring);
+ pvalues[4].hfname= hf_nds_target_name;
break;
case 0x1a:
- verb_string = "Remove Replica";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x1b:
- verb_string = "Open Stream -> ";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p1values.vvalue;
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.hfname = hf_nds_ver;
- p1values.voffset = foffset;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p2values.vvalue;
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Streams Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.hfname = hf_nds_stream_flags;
- p2values.voffset = foffset;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
- p3values.vlength = 4;
+ 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 = p3values.vvalue;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_eid;
- foffset = foffset+p3values.vlength;
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Stream Name: %s";
- p4values.vstring = "";
- p4values.mvtype = 1;
- p4values.vvalue = 0;
- p4values.vlength = 256;
- p4values.vlength = tvb_get_letohl(tvb, foffset);
- if (p4values.vlength == 0x00)
+ 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)
{
- p4values.vtype = 0;
+ pvalues[3].vtype = VTYPE_NONE;
break;
}
- p4values.voffset = foffset+4;
+ pvalues[3].voffset = foffset+4;
foffset += 4;
- get_string(tvb, p4values.voffset, p4values.vlength, p4values.vstring);
- foffset += p4values.vlength;
+ get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
+ foffset += pvalues[3].vlength;
foffset += align_4(tvb, foffset);
- p4values.hfname= hf_nds_stream_name;
+ pvalues[3].hfname= hf_nds_stream_name;
break;
case 0x1c:
- verb_string = "Search Filter";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x1d:
- verb_string = "Create Subordinate Reference";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x1e:
- verb_string = "Link Replica";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x1f:
- verb_string = "Change Replica Type";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x20:
- verb_string = "Start Update Schema";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x21:
- verb_string = "End Update Schema";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x22:
- verb_string = "Update Schema";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x23:
- verb_string = "Start Update Replica";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x24:
- verb_string = "End Update Replica";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x25:
- verb_string = "Update Replica";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x26:
- verb_string = "Synchronize Partition";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p1values.vvalue;
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.hfname = hf_nds_ver;
- p1values.voffset = foffset;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- nds_version = p2values.vvalue;
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Flags: 0x%08x";
- p2values.vlength = 4;
- p2values.hfname = hf_nds_req_flags;
- p2values.voffset = foffset;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Time Delay in Seconds: %d";
- p3values.vlength = 4;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_time_delay;
- foffset = foffset+p3values.vlength;
- if(p1values.vvalue == 0)
+ 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)
{
- p4values.vtype = 4; /* String */
- p4values.vdesc = "Root Most Object Name: %s";
- p4values.vstring = "";
- p4values.mvtype = 1;
- p4values.vvalue = 0;
- p4values.vlength = 256;
- p4values.vlength = tvb_get_letohl(tvb, foffset);
- if (p4values.vlength == 0x00)
+ 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)
{
- p4values.vtype = 0;
+ pvalues[3].vtype = VTYPE_NONE;
break;
}
- p4values.voffset = foffset+4;
+ pvalues[3].voffset = foffset+4;
foffset += 4;
- get_string(tvb, p4values.voffset, p4values.vlength, p4values.vstring);
- foffset += p4values.vlength;
+ get_string(tvb, pvalues[3].voffset, pvalues[3].vlength, pvalues[3].vstring);
+ foffset += pvalues[3].vlength;
foffset += align_4(tvb, foffset);
- p4values.hfname= hf_nds_root_name;
+ pvalues[3].hfname= hf_nds_root_name;
}
else
{
- p4values.vvalue = tvb_get_letohl(tvb, foffset);
- p4values.vstring = "";
- p4values.vtype = 3; /* Uint32 */
- p4values.vdesc = "Entry ID: 0x%08x";
- p4values.vlength = 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;
resolve_eid = TRUE;
- global_eid = p4values.vvalue;
- p4values.voffset = foffset;
- p4values.hfname= hf_nds_eid;
- foffset = foffset+p4values.vlength;
+ 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 = p4values.vvalue;
+ global_eid = pvalues[3].vvalue;
}
break;
case 0x27:
- verb_string = "Synchronize Schema";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x28:
- verb_string = "Read Syntaxes";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x29:
- verb_string = "Get Replica Root ID";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x2a:
- verb_string = "Begin Move Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x2b:
- verb_string = "Finish Move Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x2c:
- verb_string = "Release Moved Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x2d:
- verb_string = "Backup Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x2e:
- verb_string = "Restore Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x2f:
- verb_string = "Save DIB";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x30:
- verb_string = "Control";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x31:
- verb_string = "Remove Backlink";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x32:
- verb_string = "Close Iteration";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x33:
- verb_string = "Mutate Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x34:
- verb_string = "Audit Skulking";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x35:
- verb_string = "Get Server Address";
- p1values.vvalue = 0;
+ pvalues[0].vvalue = 0;
break;
case 0x36:
- verb_string = "Set Keys";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x37:
- verb_string = "Change Password";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x38:
- verb_string = "Verify Password";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x39:
- verb_string = "Begin Login";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_eid;
- foffset = foffset+p2values.vlength;
+ global_eid = pvalues[1].vvalue;
+ pvalues[1].voffset = foffset;
+ pvalues[1].hfname= hf_nds_eid;
+ foffset = foffset+pvalues[1].vlength;
break;
case 0x3a:
- verb_string = "Finish Login";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Reply Buffer Size: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_buffer_size;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Version: %d";
- p2values.vlength = 4;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_ver;
- foffset = foffset+p2values.vlength;
- p3values.vvalue = tvb_get_letohl(tvb, foffset);
- p3values.vstring = "";
- p3values.vtype = 3; /* Uint32 */
- p3values.vdesc = "Entry ID: 0x%08x";
- p3values.vlength = 4;
+ 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 = p3values.vvalue;
- p3values.voffset = foffset;
- p3values.hfname= hf_nds_eid;
- foffset = foffset+p3values.vlength;
+ global_eid = pvalues[2].vvalue;
+ pvalues[2].voffset = foffset;
+ pvalues[2].hfname= hf_nds_eid;
+ foffset = foffset+pvalues[2].vlength;
break;
case 0x3b:
- verb_string = "Begin Authentication";
- p1values.vvalue = tvb_get_letohl(tvb, foffset);
- p1values.vstring = "";
- p1values.vtype = 3; /* Uint32 */
- p1values.vdesc = "Version: %d";
- p1values.vlength = 4;
- p1values.voffset = foffset;
- p1values.hfname= hf_nds_ver;
- foffset = foffset+p1values.vlength;
- p2values.vvalue = tvb_get_letohl(tvb, foffset);
- p2values.vstring = "";
- p2values.vtype = 3; /* Uint32 */
- p2values.vdesc = "Entry ID: 0x%08x";
- p2values.vlength = 4;
+ 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 = p2values.vvalue;
- p2values.voffset = foffset;
- p2values.hfname= hf_nds_eid;
- foffset = foffset+p2values.vlength;
+ global_eid = pvalues[1].vvalue;
+ pvalues[1].voffset = foffset;
+ pvalues[1].hfname= hf_nds_eid;
+ foffset = foffset+pvalues[1].vlength;
break;
case 0x3c:
- verb_string = "Finish Authentication";
break;
case 0x3d:
- verb_string = "Logout";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x3e:
- verb_string = "Repair Ring";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x3f:
- verb_string = "Repair Timestamps";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x40:
- verb_string = "Create Back Link";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x41:
- verb_string = "Delete External Reference";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x42:
- verb_string = "Rename External Reference";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x43:
- verb_string = "Create Directory Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x44:
- verb_string = "Remove Directory Entry";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x45:
- verb_string = "Designate New Master";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x46:
- verb_string = "Change Tree Name";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x47:
- verb_string = "Partition Entry Count";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x48:
- verb_string = "Check Login Restrictions";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x49:
- verb_string = "Start Join";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x4a:
- verb_string = "Low Level Split";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x4b:
- verb_string = "Low Level Join";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x4c:
- verb_string = "Abort Low Level Join";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
case 0x4d:
- verb_string = "Get All Servers";
- p1values.vtype = 0; /* Not Defined */
+ pvalues[0].vtype = VTYPE_NONE; /* Not Defined */
break;
default:
- verb_string = "NDS Continuation Fragment";
- p1values.vtype = 0; /* Not Defined */
+ 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,
}
}
- 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->src, &pinfo->dst,
+
+ /* 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->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->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->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.secs=pinfo->fd->abs_secs;
+ request_value->req_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
+
/* 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
* 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) {
- 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_rec && !ncp_tree) {
+ 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
CLEANUP_PUSH(free_proto_tree, temp_tree);
- conversation = find_conversation(&pinfo->src, &pinfo->dst,
- PT_NCP, nw_connection, nw_connection, 0);
-
-
+ request_value = ncp_hash_lookup(conversation, sequence);
switch (type) {
case NCP_BROADCAST_SLOT:
subfunc, "SubFunction: %d (0x%02x)",
subfunc, subfunc);
- proto_tree_add_uint_format(ncp_tree, hf_ncp_fragment_handle, tvb, 8, 4,
- nds_frag, "Fragment Handle: (0x%08x)",
+ proto_tree_add_uint(ncp_tree, hf_ncp_fragment_handle, tvb, 8, 4,
nds_frag);
if (nds_frag == 0xffffffff) {
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);
- if (p1values.vtype != 0) {
- switch (p1values.vtype) {
- case 1: /* uint8 */
- proto_tree_add_uint_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vtype, "NDS Parameter not defined %d",
- p1values.vtype);
- break;
- case 2: /* uint16 */
- proto_tree_add_uint_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vtype, "NDS Parameter not defined %d",
- p1values.vtype);
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vvalue, p1values.vdesc,
- p1values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, p1values.vstring, p1values.vdesc, p1values.vstring);
- if (p1values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p1values.vstring);
- }
- }
- break;
- case 5: /* bitfield */
- process_bitfield(ncp_tree, tvb, &p1values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p1values);
- if (p1values.mvtype == 1 || p1values.mvtype == 10)
- {
- if (p1values.mvtype == 10)
- {
- global_object_name = p1values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p1values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p1values.hfname, tvb, p1values.voffset,
- p1values.vlength, tvb_get_ptr(tvb, p1values.voffset, p1values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p1values.hfname, tvb, p1values.voffset, p1values.vlength, TRUE);
- break;
- default:
- proto_tree_add_uint_format(ncp_tree, hf_nds_p1type, tvb, p1values.voffset,
- p1values.vlength, p1values.vtype, "NDS Parameter not defined %d",
- p1values.vtype);
- break;
- }
- switch (p2values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p2values.hfname, tvb, p2values.voffset,
- p2values.vlength, p2values.vvalue, p2values.vdesc,
- p2values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p2values.hfname, tvb, p2values.voffset,
- p2values.vlength, p2values.vstring, p2values.vdesc, p2values.vstring);
- if (p2values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p2values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p2values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p2values);
- if (p2values.mvtype == 1 || p2values.mvtype == 10)
- {
- if (p2values.mvtype == 10)
- {
- global_object_name = p1values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p2values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p2values.hfname, tvb, p2values.voffset,
- p2values.vlength, tvb_get_ptr(tvb, p2values.voffset, p2values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p2values.hfname, tvb, p2values.voffset, p2values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p3values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p3values.hfname, tvb, p3values.voffset,
- p3values.vlength, p3values.vvalue, p3values.vdesc,
- p3values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p3values.hfname, tvb, p3values.voffset,
- p3values.vlength, p3values.vstring, p3values.vdesc, p3values.vstring);
- if (p3values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p3values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p3values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p3values);
- if (p3values.mvtype == 1 || p3values.mvtype == 10)
- {
- if (p3values.mvtype == 10)
- {
- global_object_name = p3values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p3values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p3values.hfname, tvb, p3values.voffset,
- p3values.vlength, tvb_get_ptr(tvb, p3values.voffset, p3values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p3values.hfname, tvb, p3values.voffset, p3values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p4values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p4values.hfname, tvb, p4values.voffset,
- p4values.vlength, p4values.vvalue, p4values.vdesc,
- p4values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p4values.hfname, tvb, p4values.voffset,
- p4values.vlength, p4values.vstring, p4values.vdesc, p4values.vstring);
- if (p4values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p4values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p4values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p4values);
- if (p4values.mvtype == 1 || p4values.mvtype == 10)
- {
- if (p4values.mvtype == 10)
- {
- global_object_name = p4values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p4values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p4values.hfname, tvb, p4values.voffset,
- p4values.vlength, tvb_get_ptr(tvb, p4values.voffset, p4values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p4values.hfname, tvb, p4values.voffset, p4values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p5values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p5values.hfname, tvb, p5values.voffset,
- p5values.vlength, p5values.vvalue, p5values.vdesc,
- p5values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p5values.hfname, tvb, p5values.voffset,
- p5values.vlength, p5values.vstring, p5values.vdesc, p5values.vstring);
- if (p5values.mvtype == 1 || p5values.mvtype == 10)
- {
- if (p5values.mvtype == 10)
- {
- global_object_name = p5values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p5values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p5values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p5values);
- if (p5values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p5values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p5values.hfname, tvb, p5values.voffset,
- p5values.vlength, tvb_get_ptr(tvb, p5values.voffset, p5values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p5values.hfname, tvb, p5values.voffset, p5values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p6values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p6values.hfname, tvb, p6values.voffset,
- p6values.vlength, p6values.vvalue, p6values.vdesc,
- p6values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p6values.hfname, tvb, p6values.voffset,
- p6values.vlength, p6values.vstring, p6values.vdesc, p6values.vstring);
- if (p6values.mvtype == 1 || p6values.mvtype == 10)
- {
- if (p6values.mvtype == 10)
- {
- global_object_name = p6values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p6values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p6values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p6values);
- if (p6values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p6values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p6values.hfname, tvb, p6values.voffset,
- p6values.vlength, tvb_get_ptr(tvb, p6values.voffset, p6values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p6values.hfname, tvb, p6values.voffset, p6values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p7values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p7values.hfname, tvb, p7values.voffset,
- p7values.vlength, p7values.vvalue, p7values.vdesc,
- p7values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p7values.hfname, tvb, p7values.voffset,
- p7values.vlength, p7values.vstring, p7values.vdesc, p7values.vstring);
- if (p7values.mvtype == 1 || p7values.mvtype == 10)
- {
- if (p7values.mvtype == 10)
- {
- global_object_name = p7values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p7values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p7values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p7values);
- if (p7values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p7values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p7values.hfname, tvb, p7values.voffset,
- p7values.vlength, tvb_get_ptr(tvb, p7values.voffset, p7values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p7values.hfname, tvb, p7values.voffset, p7values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p8values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p8values.hfname, tvb, p8values.voffset,
- p8values.vlength, p8values.vvalue, p8values.vdesc,
- p8values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p8values.hfname, tvb, p8values.voffset,
- p8values.vlength, p8values.vstring, p8values.vdesc, p8values.vstring);
- if (p8values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p8values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p8values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p8values);
- if (p8values.mvtype == 1 || p8values.mvtype == 10)
- {
- if (p8values.mvtype == 10)
- {
- global_object_name = p8values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p8values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p8values.hfname, tvb, p8values.voffset,
- p8values.vlength, tvb_get_ptr(tvb, p8values.voffset, p8values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p8values.hfname, tvb, p8values.voffset, p8values.vlength, TRUE);
- break;
- default:
- break;
- }
- switch (p9values.vtype) {
- case 1: /* uint8 */
- break;
- case 2: /* uint16 */
- break;
- case 3: /* uint32 */
- proto_tree_add_uint_format(ncp_tree, p9values.hfname, tvb, p9values.voffset,
- p9values.vlength, p9values.vvalue, p9values.vdesc,
- p9values.vvalue);
- break;
- case 4: /* string */
- proto_tree_add_string_format(ncp_tree, p9values.hfname, tvb, p9values.voffset,
- p9values.vlength, p9values.vstring, p9values.vdesc, p9values.vstring);
- if (p9values.mvtype == 1)
- {
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p9values.vstring);
- }
- }
- break;
- case 5: /* boolean */
- process_bitfield(ncp_tree, tvb, &p9values);
- break;
- case 6: /*multivalue uint32 */
- process_multivalues(ncp_tree, tvb, &p9values);
- if (p9values.mvtype == 1 || p9values.mvtype == 10)
- {
- if (p9values.mvtype == 10)
- {
- global_object_name = p9values.vstring;
- }
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_str(pinfo->cinfo, COL_INFO, p9values.vstring);
- }
- }
- break;
- case 7: /* Bytes */
- proto_tree_add_bytes(ncp_tree, p9values.hfname, tvb, p9values.voffset,
- p9values.vlength, tvb_get_ptr(tvb, p9values.voffset, p9values.vvalue));
- break;
- case 8:
- proto_tree_add_item(ncp_tree, p9values.hfname, tvb, p9values.voffset, p9values.vlength, TRUE);
- break;
- default:
- break;
- }
- if(resolve_eid) {
-
- /* For NDS requests with just an EID, resolve name from hash table. */
- request_eid_value = ncp_eid_hash_lookup(conversation, global_eid);
- if (request_eid_value) {
- 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);
- }
+ 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, pvalues[i].vstring);
+ }
+ 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)) {
+ 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_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);
}
}
}
{
request_value->nds_request_verb = nds_verb;
request_value->nds_version = nds_version;
- request_value->object_name = global_object_name;
+ strcpy(request_value->object_name, global_object_name);
request_value->req_nds_flags = global_flags;
- }
+ }
}
break;
}
}
-
+/*
+ * 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,
+dissect_ping_req(tvbuff_t *tvb, packet_info *pinfo,
guint16 nw_connection, guint8 sequence,
guint16 type, proto_tree *ncp_tree)
{
conversation_t *conversation;
ptvcursor_t *ptvc = NULL;
proto_tree *temp_tree = NULL;
- guint32 nds_version = 0;
gint length_remaining = 0;
- char flags_str[1+3+1+3+1+3+1+3+1+1];
- char * sep = NULL;
- proto_tree *flags_tree;
guint32 nds_flags;
- proto_item *tinew;
- guint32 nds_flag_tree = 0x00020000;
- guint32 nds_flag_depth = 0x00000002;
- guint32 nds_flag_rev = 0x00000004;
- guint32 nds_flag_flags = 0x00000008;
- int ett_nds_flags;
+ guint32 ping_version;
+ nds_val pvalue;
+ char string_buffer[1024];
+
+ 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);
request_value = ncp_hash_insert(conversation, sequence, ncp_rec);
request_value->req_frame_num = pinfo->fd->num;
+ request_value->req_frame_time.secs=pinfo->fd->abs_secs;
+ request_value->req_frame_time.nsecs=pinfo->fd->abs_usecs*1000;
/* If this is the first time we're examining the packet,
* check to see if this NCP type uses a "request condition".
* 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)
- {
+ if (ncp_rec && !ncp_tree) {
proto_item *ti;
temp_tree = proto_tree_create_root();
}
}
- 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);
-
- conversation = find_conversation(&pinfo->src, &pinfo->dst,
- PT_NCP, nw_connection, nw_connection, 0);
+ 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;
+ 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: %d (0x%02X), %s",
- func, func, ncp_rec ? ncp_rec->name : "Unknown");
+ 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: %d (0x%02x)",
- subfunc, subfunc);
+ proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 7, 1,
+ subfunc, "SubFunction: %u (0x%02x)",
+ subfunc, subfunc);
- proto_tree_add_uint_format(ncp_tree, hf_nds_version, tvb, 8, 4,
- nds_version, "NDS Version: (0x%x)",
- nds_version);
-
- length_remaining = tvb_length_remaining(tvb, 8);
- if (length_remaining > 6)
- {
- nds_flags = tvb_get_letohl(tvb, 12);
- strcpy(flags_str, " ");
- sep = "(";
- if (nds_flags & nds_flag_tree)
- {
- strcat(flags_str, sep);
- strcat(flags_str, "Tree");
- sep = ",";
- }
- if (nds_flags & nds_flag_depth)
- {
- strcat(flags_str, sep);
- strcat(flags_str, "Depth");
- sep = ",";
- }
- if (nds_flags & nds_flag_rev)
- {
- strcat(flags_str, sep);
- strcat(flags_str, "Revision");
- }
- if (nds_flags & nds_flag_flags)
- {
- strcat(flags_str, sep);
- strcat(flags_str, "Flags");
- }
- if (flags_str[0] != '\0')
- {
- strcat(flags_str, ")");
- tinew = proto_tree_add_uint_format(ncp_tree, hf_nds_flags,
- tvb, 12, 4, nds_flags, "Flags: 0x%08x -%s", nds_flags,
- flags_str);
-
- flags_tree = proto_item_add_subtree(tinew, ett_nds);
-
- if(request_value)
- {
- request_value->req_nds_flags = nds_flags;
- }
-
- proto_tree_add_item(flags_tree, hf_nds_flags_tree,
- tvb, 12, 4, TRUE);
- proto_tree_add_item(flags_tree, hf_nds_flags_flags,
- tvb, 12, 4, TRUE);
- proto_tree_add_item(flags_tree, hf_nds_flags_rev,
- tvb, 12, 4, TRUE);
- proto_tree_add_item(flags_tree, hf_nds_flags_depth,
- tvb, 12, 4, TRUE);
- }
- }
- break;
-
- default:
- ; /* nothing */
- break;
+ 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->req_nds_flags = nds_flags;
+
+
+ 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;
- }
- 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);
+ 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;
- /* Free the temporary proto_tree */
- CLEANUP_CALL_AND_POP;
- }
-
+ 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;
+ }
}
git.samba.org / obnox / wireshark / wip.git / blobdiff