# include "config.h"
#endif
-#include <string.h>
#include <glib.h>
#include <epan/packet.h>
#include <epan/prefs.h>
+#include <epan/reassemble.h>
+#include <epan/conversation.h>
+#include <epan/expert.h>
#include <epan/emem.h>
+#include <epan/strutil.h>
+
#include "packet-ipx.h"
#include "packet-tcp.h"
-#include <epan/conversation.h>
#include "packet-ndps.h"
-#include <epan/reassemble.h>
-#include <epan/expert.h>
/* Limit the number of items we can add to the tree. */
-#define NDPS_MAX_ITEMS 50
+#define NDPS_MAX_ITEMS 100
/* Tables for reassembly of fragments. */
static GHashTable *ndps_fragment_table = NULL;
/* Global Attribute for evaluation of Values */
static const char *global_attribute_name=NULL;
-static void dissect_ndps_request(tvbuff_t*, packet_info*, proto_tree*, guint32, guint32, int);
+static int dissect_ndps_request(tvbuff_t*, packet_info*, proto_tree*, guint32, guint32, int);
-static void dissect_ndps_reply(tvbuff_t *, packet_info*, proto_tree*, int);
+static int dissect_ndps_reply(tvbuff_t *, packet_info*, proto_tree*, int);
static int hf_ndps_segments = -1;
static int hf_ndps_segment = -1;
static int hf_ndps_segment_multiple_tails = -1;
static int hf_ndps_segment_too_long_segment = -1;
static int hf_ndps_segment_error = -1;
+static int hf_ndps_segment_count = -1;
+static int hf_ndps_reassembled_length = -1;
static gint ett_ndps_segments = -1;
static gint ett_ndps_segment = -1;
static int hf_object_name = -1;
static int hf_ndps_document_number = -1;
static int hf_ndps_nameorid = -1;
-static int hf_local_object_name = -1;
-static int hf_printer_name = -1;
+static int hf_ndps_local_object_name = -1;
+static int hf_ndps_printer_name = -1;
static int hf_ndps_qualified_name = -1;
static int hf_ndps_item_count = -1;
static int hf_ndps_num_passwords = -1;
static int hf_ndps_other_error_2 = -1;
static int hf_ndps_session = -1;
static int hf_ndps_abort_flag = -1;
-static int hf_obj_attribute_type = -1;
+static int hf_ndps_obj_attribute_type = -1;
static int hf_ndps_attribute_value = -1;
static int hf_ndps_lower_range = -1;
static int hf_ndps_upper_range = -1;
static int hf_oid_asn1_type = -1;
static int hf_ndps_item_ptr = -1;
static int hf_ndps_len = -1;
-static int hf_limit_enc = -1;
+static int hf_ndps_limit_enc = -1;
static int hf_ndps_delivery_add_count = -1;
static int hf_ndps_qualified_name2 = -1;
static int hf_ndps_delivery_add_type = -1;
/* desegmentation of NDPS over TCP */
static gboolean ndps_desegment = TRUE;
-/* global item and value for passing expert data */
-static proto_item *expert_item;
-static guint32 expert_status;
-
static const value_string true_false[] = {
{ 0x00000000, "Accept" },
{ 0x00000001, "Deny" },
{ 0xffffff0c, "(-244) No Object Delete Rights" },
{ 0xffffff0b, "(-245) No Object Create Rights" },
{ 0xffffff0a, "(-246) No Property Delete Rights" },
- { 0xffffff09, "(-247) No Property Create Rigths" },
+ { 0xffffff09, "(-247) No Property Create Rights" },
{ 0xffffff08, "(-248) No Property Write Rights" },
- { 0xffffff07, "(-249) No Propery Read Rights" },
+ { 0xffffff07, "(-249) No Property Read Rights" },
{ 0xffffff06, "(-250) Temp Remap" },
{ 0xffffff05, "(-251) Unknown Request/No Such Property" },
{ 0xffffff04, "(-252) Message Queue Full/Target Already Has Message/No Such Object" },
{ 0xfffffd5f, "(-673) Replica Not On" },
{ 0xfffffd5e, "(-674) Invalid Name Service" },
{ 0xfffffd5d, "(-675) Invalid Task" },
- { 0xfffffd5c, "(-676) Invalide Connection Handle" },
+ { 0xfffffd5c, "(-676) Invalid Connection Handle" },
{ 0xfffffd5b, "(-677) Invalid Identity" },
{ 0xfffffd5a, "(-678) Duplicate ACL" },
{ 0xfffffd59, "(-679) Partition Already Exists" },
{ 0xfffffd3a, "(-710) Database Read Fail" },
{ 0xfffffd39, "(-711) Invalid Code Page" },
{ 0xfffffd38, "(-712) Invalid Escape Character" },
- { 0xfffffd37, "(-713) Invalide Delimiters" },
+ { 0xfffffd37, "(-713) Invalid Delimiters" },
{ 0xfffffd36, "(-714) Not Implemented" },
{ 0xfffffd35, "(-715) Checksum Failure" },
{ 0xfffffd34, "(-716) Checksumming Not Supported" },
{ 0xfffffd31, "(-719) Invalid Value Handle" },
{ 0xfffffd30, "(-720) Connection Denied" },
{ 0xfffffd2f, "(-721) No Such Federation Link" },
- { 0xfffffd2e, "(-722) Operetational Schema Mismatch" },
+ { 0xfffffd2e, "(-722) Operational Schema Mismatch" },
{ 0xfffffd2d, "(-723) Stream Not Found" },
{ 0xfffffd2c, "(-724) DClient Unavailable" },
{ 0xfffffd2b, "(-725) MASV No Access" },
{ 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" },
+ { 0xffffe87d, "(-6019) Bad Referral Database Serial Number" },
+ { 0xffffe87c, "(-6020) Bad Referral 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" },
+ { 0xffffe87a, "(-6022) Error Referral Trans Gap" },
+ { 0xffffe879, "(-6023) Bad Referral File Number" },
+ { 0xffffe878, "(-6024) Referral File Not Found" },
{ 0xffffe877, "(-6025) Error Backup Active" },
- { 0xffffe876, "(-6026) Referal Device Full" },
+ { 0xffffe876, "(-6026) Referral Device Full" },
{ 0xffffe875, "(-6027) Unsupported Version" },
{ 0xffffe874, "(-6028) Error Must Wait Checkpoint" },
{ 0xffffe873, "(-6029) Attribute Maintenance in Progress" },
static int
align_4(tvbuff_t *tvb, int aoffset)
{
- if(tvb_length_remaining(tvb, aoffset) > 4 )
- {
- return (aoffset%4);
- }
- return 0;
+ if(tvb_length_remaining(tvb, aoffset) > 4 )
+ {
+ return (aoffset%4);
+ }
+ return 0;
}
+/*
+ * XXX - is there something in the packet to indicate whether a string
+ * is ASCII or Unicode, or is it a characteristic of the attribute?
+ * Currently, we use a heuristic - if the length is odd, we assume
+ * it's ASCII (as it's a length in bytes, not characters), otherwise if
+ * if the length is 2, we assume it's ASCII (as strings are null-
+ * terminated, so a Unicode string would have to be at least 4 bytes),
+ * otherwise if the second byte of the string is 0, we assume it's
+ * Unicode (as an ASCII string would, in that case, have at least two
+ * characters before the terminating NUL).
+ */
static int
-ndps_string(tvbuff_t* tvb, int hfinfo, proto_tree *ndps_tree, int offset, char *stringval, size_t buflen)
+ndps_string(tvbuff_t* tvb, int hfinfo, proto_tree *ndps_tree, int offset, char **stringval)
{
- int foffset = offset;
- guint32 str_length;
- char buffer[ITEM_LABEL_LENGTH];
- guint32 i;
- guint16 c_char;
- guint32 length_remaining = 0;
-
- if (stringval == NULL) {
- stringval = buffer;
- buflen = sizeof buffer;
- }
- str_length = tvb_get_ntohl(tvb, foffset);
- foffset += 4;
- length_remaining = tvb_length_remaining(tvb, foffset);
- if(str_length > (guint)length_remaining || str_length >= ITEM_LABEL_LENGTH)
- {
- proto_tree_add_string(ndps_tree, hfinfo, tvb, foffset,
- length_remaining + 4, "<String too long to process>");
- foffset += length_remaining;
- return foffset;
- }
- if(str_length == 0)
- {
- proto_tree_add_string(ndps_tree, hfinfo, tvb, offset,
- 4, "<Not Specified>");
- return foffset;
- }
- for ( i = 0; i < str_length; i++ )
- {
- c_char = tvb_get_guint8(tvb, foffset );
- if (c_char<0x20 || c_char>0x7e)
- {
- if (c_char != 0x00)
- {
- c_char = 0x2e;
- if (i < buflen - 1)
- stringval[i] = c_char & 0xff;
- }
- else
- {
- i--;
- str_length--;
- }
- }
- else
- {
- if (i < buflen - 1)
- stringval[i] = c_char & 0xff;
- }
- foffset++;
- length_remaining--;
+ int foffset = offset;
+ guint32 str_length;
+ char *string;
- if(length_remaining==1)
- {
- i++;
- break;
- }
- }
- stringval[i] = '\0';
-
- str_length = tvb_get_ntohl(tvb, offset);
- proto_tree_add_string(ndps_tree, hfinfo, tvb, offset+4,
- str_length, stringval);
- foffset += align_4(tvb, foffset);
+ str_length = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ if(str_length == 0)
+ {
+ proto_tree_add_string(ndps_tree, hfinfo, tvb, offset, 4, "<Not Specified>");
+ if (stringval != NULL)
+ *stringval = ep_strdup("");
return foffset;
+ }
+ if (str_length <= 2 || (str_length & 0x01) || tvb_get_guint8(tvb, foffset + 1) != 0) {
+ /*
+ * ASCII.
+ */
+ string = tvb_get_ephemeral_string(tvb, foffset, str_length);
+ } else {
+ /*
+ * Unicode.
+ */
+ string = tvb_get_ephemeral_faked_unicode(tvb, foffset, str_length/2, TRUE);
+ }
+ foffset += str_length;
+ proto_tree_add_string(ndps_tree, hfinfo, tvb, offset, str_length + 4, string);
+ foffset += align_4(tvb, foffset);
+ if (stringval != NULL)
+ *stringval = string;
+ return foffset;
}
static int
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_7, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_7, tvb, foffset, length, "%s", label);
break;
case 10:
label_value = tvb_get_ntohl(tvb, foffset+6);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_8, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_8, tvb, foffset, length, "%s", label);
break;
case 11:
label_value = tvb_get_ntohl(tvb, foffset+7);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_9, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_9, tvb, foffset, length, "%s", label);
break;
case 12:
label_value = tvb_get_ntohl(tvb, foffset+8);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_10, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_10, tvb, foffset, length, "%s", label);
break;
case 13:
label_value = tvb_get_ntohl(tvb, foffset+9);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_11, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_11, tvb, foffset, length, "%s", label);
break;
case 14:
label_value = tvb_get_ntohl(tvb, foffset+10);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_12, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_12, tvb, foffset, length, "%s", label);
break;
case 15:
label_value = tvb_get_ntohl(tvb, foffset+11);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_13, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_13, tvb, foffset, length, "%s", label);
break;
case 16:
label_value = tvb_get_ntohl(tvb, foffset+12);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_14, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_14, tvb, foffset, length, "%s", label);
break;
case 17:
label_value = tvb_get_ntohl(tvb, foffset+13);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_15, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_15, tvb, foffset, length, "%s", label);
break;
case 18:
label_value = tvb_get_ntohl(tvb, foffset+14);
found=FALSE;
break;
}
- aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_16, tvb, foffset, length, label);
+ aitem = proto_tree_add_none_format(ndps_tree, hf_ndps_object_ids_16, tvb, foffset, length, "%s", label);
break;
default:
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, length, "Unknown ID");
length = tvb_get_guint8(tvb, foffset);
foffset += 1;
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(atree, hf_ndps_oid, tvb, foffset, length, FALSE);
+ proto_tree_add_item(atree, hf_ndps_oid, tvb, foffset, length, ENC_NA);
foffset += length;
}
else
break;
case 2: /* Local */
- foffset = ndps_string(tvb, hf_local_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_local_object_name, ndps_tree, foffset, NULL);
break;
}
foffset += align_4(tvb, foffset);
foffset += 4;
if (qualified_name_type != 0) {
if (qualified_name_type == 1) {
- foffset = ndps_string(tvb, hf_printer_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_name, ndps_tree, foffset, NULL);
}
else
{
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
}
}
return foffset;
switch(object_type)
{
case 0: /* Printer Contained Object ID */
- foffset = ndps_string(tvb, hf_printer_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_ndps_object, tvb, foffset,
4, FALSE);
foffset += 4;
break;
case 1: /* Document Identifier */
- foffset = ndps_string(tvb, hf_printer_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_ndps_document_number, tvb, foffset,
4, FALSE);
foffset += 4;
foffset = objectidentifier(tvb, atree, foffset);
break;
case 3: /* Object Name */
- foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL);
if (foffset > tvb_length_remaining(tvb, foffset)) {
return foffset;
}
foffset = name_or_id(tvb, atree, foffset);
break;
case 5: /* Simple Name */
- foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL);
break;
case 6: /* Printer Configuration Object ID */
- foffset = ndps_string(tvb, hf_printer_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_name, atree, foffset, NULL);
break;
case 7: /* Qualified Name */
foffset = qualifiedname(tvb, ndps_tree, foffset);
break;
case 8: /* Event Object ID */
- foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL);
foffset = objectidentifier(tvb, atree, foffset);
proto_tree_add_item(atree, hf_ndps_event_type, tvb, foffset,
4, FALSE);
static int
print_address(tvbuff_t* tvb, proto_tree *ndps_tree, int foffset)
{
- guint32 address_type=0;
- guint32 address_len=0;
+ guint32 addr_type=0;
+ guint32 addr_len=0;
- address_type = tvb_get_ntohl(tvb, foffset);
- proto_tree_add_uint(ndps_tree, hf_ndps_address, tvb, foffset, 4, address_type);
+ addr_type = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_uint(ndps_tree, hf_ndps_address, tvb, foffset, 4, addr_type);
foffset += 4;
- address_len = tvb_get_ntohl(tvb, foffset);
+ addr_len = tvb_get_ntohl(tvb, foffset);
proto_tree_add_item(ndps_tree, hf_address_len, tvb, foffset, 4, FALSE);
foffset += 4;
/*
* XXX - should this code - and the code in packet-ncp2222.inc to
* dissect addresses - check the length for the types it supports?
*/
- switch(address_type)
+ switch(addr_type)
{
case 0x00000000:
- proto_tree_add_item(ndps_tree, hf_ndps_net, tvb, foffset, 4, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_net, tvb, foffset, 4, ENC_NA);
proto_tree_add_item(ndps_tree, hf_ndps_node, tvb, foffset+4, 6, FALSE);
proto_tree_add_item(ndps_tree, hf_ndps_socket, tvb, foffset+10, 2, FALSE);
break;
default:
break;
}
- tvb_ensure_bytes_exist(tvb, foffset, address_len);
- foffset += address_len;
- return foffset+(address_len%4);
+ tvb_ensure_bytes_exist(tvb, foffset, addr_len);
+ foffset += addr_len;
+ return foffset+(addr_len%4);
}
static int
address_item(tvbuff_t* tvb, proto_tree *ndps_tree, int foffset)
{
- guint32 address_type=0;
+ guint32 addr_type=0;
- address_type = tvb_get_ntohl(tvb, foffset);
- proto_tree_add_uint(ndps_tree, hf_address_type, tvb, foffset, 4, address_type);
+ addr_type = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_uint(ndps_tree, hf_address_type, tvb, foffset, 4, addr_type);
foffset += 4;
- switch(address_type)
+ switch(addr_type)
{
case 0:
case 1:
case 10:
case 11:
case 12:
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
break;
case 13:
proto_tree_add_item(ndps_tree, hf_ndps_attrib_boolean, tvb, foffset, 4, FALSE);
case 16:
case 17:
default:
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
break;
}
return foffset;
switch (cred_type)
{
case 0:
- foffset = ndps_string(tvb, hf_ndps_user_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_user_name, ndps_tree, foffset, NULL);
number_of_items=tvb_get_ntohl(tvb, foffset);
proto_tree_add_uint(ndps_tree, hf_ndps_num_passwords, tvb, foffset, 4, number_of_items);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Password %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(atree, hf_ndps_password, tvb, foffset, length, FALSE);
+ proto_tree_add_item(atree, hf_ndps_password, tvb, foffset, length, ENC_NA);
}
proto_item_set_end(aitem, tvb, foffset);
foffset += length;
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_certified, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_certified, tvb, foffset, length, ENC_NA);
}
foffset += length;
break;
case 2:
- foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, NULL);
foffset += 2;
proto_tree_add_item(ndps_tree, hf_ndps_connection, tvb, foffset, 2, FALSE);
foffset += 2;
break;
case 3:
length=tvb_get_ntohl(tvb, foffset);
- foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, NULL);
if (length == 0)
{
foffset += 2;
}
proto_tree_add_item(ndps_tree, hf_ndps_connection, tvb, foffset, 2, FALSE);
foffset += 2;
- foffset = ndps_string(tvb, hf_ndps_user_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_user_name, ndps_tree, foffset, NULL);
break;
case 4:
- foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, NULL);
foffset += 2;
proto_tree_add_item(ndps_tree, hf_ndps_connection, tvb, foffset, 2, FALSE);
foffset += 2;
- foffset = ndps_string(tvb, hf_ndps_user_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_user_name, ndps_tree, foffset, NULL);
foffset += 8; /* Don't know what these 8 bytes signify */
proto_tree_add_item(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
- foffset += 4; /* XXX - what does this count? */
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset += 4; /* XXX - what does this count? */
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
break;
default:
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Event %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
proto_tree_add_item(btree, hf_ndps_event_type, tvb, foffset, 4, FALSE);
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Item %u", j);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = objectidentifier(tvb, ctree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Cardinal %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
static int
server_entry(tvbuff_t* tvb, proto_tree *ndps_tree, int foffset)
{
- char server_name[1024];
+ char *server_name;
guint32 number_of_items;
guint32 i;
guint32 data_type;
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Server Info");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, server_name, sizeof server_name);
- proto_item_append_text(aitem, ": %s", server_name);
+ foffset = ndps_string(tvb, hf_ndps_server_name, ndps_tree, foffset, &server_name);
+ proto_item_append_text(aitem, ": %s", format_text(server_name, strlen(server_name)));
proto_tree_add_item(atree, hf_ndps_server_type, tvb, foffset, 4, FALSE);
foffset += 4;
foffset = print_address(tvb, atree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Info %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
data_type = tvb_get_ntohl(tvb, foffset);
break;
case 4: /* String */
case 5: /* Bytes */
- foffset = ndps_string(tvb, hf_info_string, btree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_info_string, btree, foffset, NULL);
break;
default:
break;
attribute_type = tvb_get_ntohl(tvb, foffset);
if (ndps_show_oids)
{
- proto_tree_add_item(ndps_tree, hf_obj_attribute_type, tvb, foffset, 4, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_obj_attribute_type, tvb, foffset, 4, FALSE);
}
foffset += 4;
switch(attribute_type)
case 102: /* File Path */
case 103: /* Uniform Resource Identifier */
case 108: /* Extended Resource Identifier */
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
break;
case 4: /* Message */
case 5: /* Error Message */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = name_or_id(tvb, atree, foffset);
break;
case 7: /* Distinguished Name String*/
case 79: /* File Reference */
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
foffset = name_or_id(tvb, ndps_tree, foffset);
break;
case 8: /* Distinguished Name String Seq */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Name %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL);
foffset = name_or_id(tvb, atree, foffset);
proto_item_set_end(aitem, tvb, foffset);
}
case 24: /* Positive Integer 64 */
case 31: /* Non-Negative Real */
case 29: /* Real */
- proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 21: /* Integer 64 Seq */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
proto_item_set_end(aitem, tvb, foffset);
}
case 26: /* Cardinal 64 Range */
case 32: /* Real Range */
case 33: /* Non-Negative Real Range */
- proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 27: /* Maximum Integer 64 */
- proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 28: /* Minimum Integer 64 */
- proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 34: /* Boolean */
foffset += 4;
break;
case 36: /* Object Identifier */
- foffset = objectidentifier(tvb, ndps_tree, foffset);
+ foffset = objectidentifier(tvb, ndps_tree, foffset);
break;
case 37: /* Object Identifier Seq */
number_of_items = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Object %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = objectidentifier(tvb, atree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Name %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
break;
foffset += 4;
break;
case 43: /* Medium Dimensions */
- proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 44: /* Dimension */
proto_tree_add_uint(ndps_tree, hf_ndps_dim_value, tvb, foffset, 4, dimension);
foffset += 4;
if (dimension == 0) {
- proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
else
}
proto_tree_add_item(ndps_tree, hf_ndps_dim_flag, tvb, foffset, 4, FALSE);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 45: /* XY Dimensions */
}
else
{
- proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
proto_tree_add_item(ndps_tree, hf_ndps_dim_flag, tvb, foffset, 4, FALSE);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 46: /* Locations */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Location %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
proto_item_set_end(aitem, tvb, foffset);
}
}
proto_tree_add_item(ndps_tree, hf_ndps_dim_flag, tvb, foffset, 4, FALSE);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 47: /* Area */
- proto_tree_add_item(ndps_tree, hf_ndps_xmin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xmin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_xmax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xmax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ymin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ymin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ymax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ymax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
case 48: /* Area Seq */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Area %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- proto_tree_add_item(atree, hf_ndps_xmin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(atree, hf_ndps_xmin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(atree, hf_ndps_xmax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(atree, hf_ndps_xmax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(atree, hf_ndps_ymin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(atree, hf_ndps_ymin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(atree, hf_ndps_ymax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(atree, hf_ndps_ymax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
proto_item_set_end(aitem, tvb, foffset);
}
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Address Item %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = address_item(tvb, atree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Event %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_event_type, tvb, foffset, 4, FALSE);
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
foffset = objectidentifier(tvb, atree, foffset);
}
foffset += 4;
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Object %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
case 56: /* Octet String */
case 63: /* Job Password */
case 66: /* Print Checkpoint */
- foffset = ndps_string(tvb, hf_info_string, ndps_tree, foffset, NULL, 0);
+ length = tvb_get_ntohl(tvb, foffset);
+ ndps_string(tvb, hf_info_string, ndps_tree, foffset, NULL);
+ foffset += length+2;
+ foffset += align_4(tvb, foffset);
break;
case 59: /* Method Delivery Address */
proto_tree_add_item(ndps_tree, hf_ndps_delivery_add_type, tvb, foffset, 4, FALSE);
case 1: /*DISTINGUISHED_NAME*/
case 2: /*TEXT*/
case 3: /*OCTET_STRING*/
- foffset = ndps_string(tvb, hf_info_string, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_info_string, ndps_tree, foffset, NULL);
break;
case 4: /*DIST_NAME_STRING*/
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
foffset = name_or_id(tvb, ndps_tree, foffset);
break;
case 5: /*RPC_ADDRESS*/
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Ignored Attribute %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
ignored_type = tvb_get_ntohl(tvb, foffset);
}
else
{
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
}
break;
case 69: /* Medium Substitution */
foffset = name_or_id(tvb, ndps_tree, foffset);
break;
case 70: /* Font Substitution */
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
break;
case 71: /* Resource Context Seq */
number_of_items = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Resource %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
resource_type = tvb_get_ntohl(tvb, foffset);
}
else
{
- foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL);
}
proto_item_set_end(aitem, tvb, foffset);
}
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Page Select %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_page_flag, tvb, foffset, 4, FALSE);
}
if (identifier_type == 1)
{
- foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL);
}
if (identifier_type == 2)
{
}
if (identifier_type == 1)
{
- foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL);
}
if (identifier_type == 2)
{
}
else
{
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
number_of_items = tvb_get_ntohl(tvb, foffset);
proto_tree_add_uint(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, number_of_items);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_page_flag, tvb, foffset, 4, FALSE);
}
if (identifier_type == 1)
{
- foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, atree, foffset, NULL);
}
if (identifier_type == 2)
{
foffset += 4;
if (length!=0)
{
- proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
}
else
{
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
foffset = name_or_id(tvb, ndps_tree, foffset);
}
break;
}
else
{
- proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
break;
}
else
{
- proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
proto_tree_add_item(ndps_tree, hf_ndps_long_edge_feeds, tvb, foffset, 4, FALSE);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_xmin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xmin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_xmax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xmax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ymin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ymin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ymax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ymax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
else
{
- proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_inc_across_feed, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_inc_across_feed, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_lower_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_upper_range_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_size_inc_in_feed, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_size_inc_in_feed, tvb, foffset, 8, ENC_NA);
foffset += 8;
proto_tree_add_item(ndps_tree, hf_ndps_long_edge_feeds, tvb, foffset, 4, FALSE);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_xmin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xmin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_xmax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xmax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ymin_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ymin_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ymax_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ymax_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Page Information %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_page_order, tvb, foffset, 4, FALSE);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Category %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Value %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
break;
case 87: /* Finishing */
case 88: /* Print Contained Object ID */
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
foffset += 4;
break;
case 89: /* Print Config Object ID */
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
foffset = qualifiedname(tvb, ndps_tree, foffset);
break;
case 90: /* Typed Name */
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_level, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_interval, tvb, foffset, 4, FALSE);
foffset += 4;
if (length!=0)
{
- proto_tree_add_item(ndps_tree, hf_ndps_add_bytes, tvb, foffset, 4, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_add_bytes, tvb, foffset, 4, ENC_NA);
}
foffset += length;
break;
break;
case 0:
- proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_xdimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
- proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_ydimension_n64, tvb, foffset, 8, ENC_NA);
foffset += 8;
break;
foffset = objectidentification(tvb, ndps_tree, foffset);
proto_tree_add_item(ndps_tree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
foffset += 4;
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4*number_of_items;
+ /*foffset += align_4(tvb, foffset);*/
foffset = name_or_id(tvb, ndps_tree, foffset);
+
break;
case 96: /* Qualified Name */
foffset = qualifiedname(tvb, ndps_tree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Name %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = qualifiedname(tvb, atree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Colorant %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = name_or_id(tvb, atree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Printer %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_printer_type, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_printer_manuf, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_type, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_printer_manuf, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
break;
case 100: /* Event Object ID */
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
foffset = objectidentifier(tvb, ndps_tree, foffset);
proto_tree_add_item(ndps_tree, hf_ndps_event_type, tvb, foffset, 4, FALSE);
foffset += 4;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Object %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
case 0: /*MHS ADDR*/
case 1: /*DISTINGUISHED_NAME*/
case 2: /*TEXT*/
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
break;
case 3: /*OCTET_STRING*/
length = tvb_get_ntohl(tvb, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_octet_string, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
THROW(ReportedBoundsError);
break;
case 4: /*DIST_NAME_STRING*/
- foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, ndps_tree, foffset, NULL);
foffset = name_or_id(tvb, ndps_tree, foffset);
break;
case 5: /*RPC_ADDRESS*/
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Event %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_object_name, atree, foffset, NULL);
foffset = objectidentifier(tvb, atree, foffset);
proto_tree_add_item(atree, hf_ndps_event_type, tvb, foffset, 4, FALSE);
foffset += 4;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Object %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = objectidentifier(tvb, atree, foffset);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
break;
default:
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Argument %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
- foffset = attribute_value(tvb, atree, foffset);
+ foffset = attribute_value(tvb, btree, foffset);
proto_item_set_end(bitem, tvb, foffset);
}
proto_item_set_end(aitem, tvb, foffset);
case 0: /* Print Drivers */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL);
break;
case 1: /* Printer Definitions */
- foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL);
break;
case 2: /* Banner Page Files */
- foffset = ndps_string(tvb, hf_ndps_banner_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_banner_name, ndps_tree, foffset, NULL);
break;
case 3: /* Font Types */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_font_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL);
break;
case 4: /* Generic Files/ Archive */
case 5: /* Printer Driver Archive */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_archive_type, tvb, foffset, 4, FALSE);
foffset += 4;
break;
static const fragment_items ndps_frag_items = {
- &ett_ndps_segment,
- &ett_ndps_segments,
- &hf_ndps_segments,
- &hf_ndps_segment,
- &hf_ndps_segment_overlap,
- &hf_ndps_segment_overlap_conflict,
- &hf_ndps_segment_multiple_tails,
- &hf_ndps_segment_too_long_segment,
- &hf_ndps_segment_error,
- NULL,
- "segments"
+ &ett_ndps_segment,
+ &ett_ndps_segments,
+ &hf_ndps_segments,
+ &hf_ndps_segment,
+ &hf_ndps_segment_overlap,
+ &hf_ndps_segment_overlap_conflict,
+ &hf_ndps_segment_multiple_tails,
+ &hf_ndps_segment_too_long_segment,
+ &hf_ndps_segment_error,
+ &hf_ndps_segment_count,
+ NULL,
+ &hf_ndps_reassembled_length,
+ "segments"
};
static dissector_handle_t ndps_data_handle;
* struct tells us the NDPS Program and Function and gives the NDPS_record pointer.
*/
typedef struct {
- conversation_t *conversation;
- guint32 ndps_xport;
+ conversation_t *conversation;
+ guint32 ndps_xport;
} ndps_req_hash_key;
typedef struct {
- guint32 ndps_prog;
- guint32 ndps_func;
- guint32 ndps_frame_num;
- gboolean ndps_frag;
- guint32 ndps_end_frag;
+ guint32 ndps_prog;
+ guint32 ndps_func;
+ guint32 ndps_frame_num;
+ gboolean ndps_frag;
+ guint32 ndps_end_frag;
} ndps_req_hash_value;
static GHashTable *ndps_req_hash = NULL;
static gint
ndps_equal(gconstpointer v, gconstpointer v2)
{
- const ndps_req_hash_key *val1 = (const ndps_req_hash_key*)v;
- const ndps_req_hash_key *val2 = (const ndps_req_hash_key*)v2;
-
- if (val1->conversation == val2->conversation &&
- val1->ndps_xport == val2->ndps_xport ) {
- return 1;
- }
- return 0;
+ const ndps_req_hash_key *val1 = (const ndps_req_hash_key*)v;
+ const ndps_req_hash_key *val2 = (const ndps_req_hash_key*)v2;
+
+ if (val1->conversation == val2->conversation &&
+ val1->ndps_xport == val2->ndps_xport ) {
+ return 1;
+ }
+ return 0;
}
static guint
ndps_hash(gconstpointer v)
{
- const ndps_req_hash_key *ndps_key = (const ndps_req_hash_key*)v;
- return GPOINTER_TO_UINT(ndps_key->conversation) + ndps_key->ndps_xport;
+ const ndps_req_hash_key *ndps_key = (const ndps_req_hash_key*)v;
+ return GPOINTER_TO_UINT(ndps_key->conversation) + ndps_key->ndps_xport;
}
/* Initializes the hash table and the mem_chunk area each time a new
static void
ndps_init_protocol(void)
{
- /* fragment */
- fragment_table_init(&ndps_fragment_table);
- reassembled_table_init(&ndps_reassembled_table);
+ /* fragment */
+ fragment_table_init(&ndps_fragment_table);
+ reassembled_table_init(&ndps_reassembled_table);
- if (ndps_req_hash)
- g_hash_table_destroy(ndps_req_hash);
+ if (ndps_req_hash)
+ g_hash_table_destroy(ndps_req_hash);
- ndps_req_hash = g_hash_table_new(ndps_hash, ndps_equal);
+ ndps_req_hash = g_hash_table_new(ndps_hash, ndps_equal);
}
/* After the sequential run, we don't need the ncp_request hash and keys
static void
ndps_postseq_cleanup(void)
{
- if (ndps_req_hash) {
- /* Destroy the hash, but don't clean up request_condition data. */
- g_hash_table_destroy(ndps_req_hash);
- ndps_req_hash = NULL;
- }
- /* Don't free the ncp_req_hash_values, as they're
- * needed during random-access processing of the proto_tree.*/
+ if (ndps_req_hash) {
+ /* Destroy the hash, but don't clean up request_condition data. */
+ g_hash_table_destroy(ndps_req_hash);
+ ndps_req_hash = NULL;
+ }
+ /* Don't free the ncp_req_hash_values, as they're
+ * needed during random-access processing of the proto_tree.*/
}
static ndps_req_hash_value*
ndps_hash_insert(conversation_t *conversation, guint32 ndps_xport)
{
- ndps_req_hash_key *request_key;
- ndps_req_hash_value *request_value;
-
- /* Now remember the request, so we can find it if we later
- a reply to it. */
- request_key = se_alloc(sizeof(ndps_req_hash_key));
- request_key->conversation = conversation;
- request_key->ndps_xport = ndps_xport;
-
- request_value = se_alloc(sizeof(ndps_req_hash_value));
- request_value->ndps_prog = 0;
- request_value->ndps_func = 0;
- request_value->ndps_frame_num = 0;
+ ndps_req_hash_key *request_key;
+ ndps_req_hash_value *request_value;
+
+ /* Now remember the request, so we can find it if we later
+ a reply to it. */
+ request_key = se_alloc(sizeof(ndps_req_hash_key));
+ request_key->conversation = conversation;
+ request_key->ndps_xport = ndps_xport;
+
+ request_value = se_alloc(sizeof(ndps_req_hash_value));
+ request_value->ndps_prog = 0;
+ request_value->ndps_func = 0;
+ request_value->ndps_frame_num = 0;
request_value->ndps_frag = FALSE;
request_value->ndps_end_frag = 0;
- g_hash_table_insert(ndps_req_hash, request_key, request_value);
+ g_hash_table_insert(ndps_req_hash, request_key, request_value);
- return request_value;
+ return request_value;
}
/* Returns the ncp_rec*, or NULL if not found. */
static ndps_req_hash_value*
ndps_hash_lookup(conversation_t *conversation, guint32 ndps_xport)
{
- ndps_req_hash_key request_key;
+ ndps_req_hash_key request_key;
- request_key.conversation = conversation;
- request_key.ndps_xport = ndps_xport;
+ request_key.conversation = conversation;
+ request_key.ndps_xport = ndps_xport;
- return g_hash_table_lookup(ndps_req_hash, &request_key);
+ return g_hash_table_lookup(ndps_req_hash, &request_key);
}
/* ================================================================= */
guint32 ndps_xid;
guint32 ndps_prog;
guint32 ndps_packet_type;
- guint32 ndps_rpc_version;
int foffset;
guint32 ndps_hfname;
guint32 ndps_func;
ndps_packet_type = tvb_get_ntohl(tvb, 8);
if (ndps_packet_type != 0 && ndps_packet_type != 1) { /* Packet Type */
- if (check_col(pinfo->cinfo, COL_INFO))
- col_set_str(pinfo->cinfo, COL_INFO, "(Continuation Data)");
- proto_tree_add_text(ndps_tree, tvb, 0, tvb_length_remaining(tvb, 0), "Data - (%d Bytes)", tvb_length_remaining(tvb, 0));
+ col_set_str(pinfo->cinfo, COL_INFO, "(Continuation Data)");
+ proto_tree_add_text(ndps_tree, tvb, 0, tvb_length(tvb), "Data - (%d Bytes)", tvb_length(tvb));
return;
}
foffset = 0;
foffset += 4;
if(ndps_packet_type == 0x00000001) /* Reply packet */
{
- if (check_col(pinfo->cinfo, COL_INFO))
- col_set_str(pinfo->cinfo, COL_INFO, "R NDPS ");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS ");
proto_tree_add_item(ndps_tree, hf_ndps_rpc_accept, tvb, foffset, 4, FALSE);
if (tvb_get_ntohl(tvb, foffset)==0) {
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_auth_null, tvb, foffset, 8, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_auth_null, tvb, foffset, 8, ENC_NA);
foffset += 8;
}
else
}
else
{
- if (check_col(pinfo->cinfo, COL_INFO))
- col_set_str(pinfo->cinfo, COL_INFO, "C NDPS ");
- ndps_rpc_version = tvb_get_ntohl(tvb, foffset);
+ col_set_str(pinfo->cinfo, COL_INFO, "C NDPS ");
proto_tree_add_item(ndps_tree, hf_ndps_rpc_version, tvb, foffset, 4, FALSE);
foffset += 4;
ndps_prog = tvb_get_ntohl(tvb, foffset);
col_append_str(pinfo->cinfo, COL_INFO, (const gchar*) ndps_func_string);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_ndps_auth_null, tvb, foffset, 16, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_auth_null, tvb, foffset, 16, ENC_NA);
foffset+=16;
dissect_ndps_request(tvb, pinfo, ndps_tree, ndps_prog, ndps_func, foffset);
}
}
static guint
-get_ndps_pdu_len(tvbuff_t *tvb, int offset)
+get_ndps_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset)
{
return tvb_get_ntohs(tvb, offset +2) + 4;
}
static void
dissect_ndps_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- proto_tree *ndps_tree = NULL;
- proto_item *ti;
+ proto_tree *ndps_tree = NULL;
+ proto_item *ti;
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
- col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDPS");
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDPS");
- if (check_col(pinfo->cinfo, COL_INFO))
- col_clear(pinfo->cinfo, COL_INFO);
+ col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
ti = proto_tree_add_item(tree, proto_ndps, tvb, 0, -1, FALSE);
static void
ndps_defrag(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- int len=0;
+ guint len=0;
tvbuff_t *next_tvb = NULL;
fragment_data *fd_head;
- spx_info *spx_info;
- ndps_req_hash_value *request_value = NULL;
+ spx_info *spx_info_p;
+ ndps_req_hash_value *request_value = NULL;
conversation_t *conversation;
/* Get SPX info from SPX dissector */
- spx_info = pinfo->private_data;
+ spx_info_p = pinfo->private_data;
/* Check to see if defragmentation is enabled in the dissector */
if (!ndps_defragment) {
dissect_ndps(tvb, pinfo, tree);
/* It's not part of any conversation - create a new one. */
conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
PT_NCP, (guint32) pinfo->srcport, (guint32) pinfo->srcport, 0);
- /* Create new request value hash */
- request_value = ndps_hash_insert(conversation, (guint32) pinfo->srcport);
}
+
/* So now we need to get the request info for this conversation */
request_value = ndps_hash_lookup(conversation, (guint32) pinfo->srcport);
if (request_value == NULL)
return;
}
/* Check to see of this is a fragment. If so then mark as a fragment. */
- if (!spx_info->eom) {
+ if (!spx_info_p->eom) {
request_value->ndps_frag = TRUE;
}
/* Now we process the fragments */
* Fragment
*/
tid = (pinfo->srcport+pinfo->destport);
- len = tvb_reported_length_remaining(tvb, 0);
- if (tvb_bytes_exist(tvb, 0, len))
+ len = tvb_reported_length(tvb);
+ if (tvb_length(tvb) >= len)
{
- fd_head = fragment_add_seq_next(tvb, 0, pinfo, tid, ndps_fragment_table, ndps_reassembled_table, len, !spx_info->eom);
+ fd_head = fragment_add_seq_next(tvb, 0, pinfo, tid, ndps_fragment_table, ndps_reassembled_table, len, !spx_info_p->eom);
if (fd_head != NULL)
{
/* Is this the last fragment? EOM will indicate */
- if (fd_head->next != NULL && spx_info->eom)
+ if (fd_head->next != NULL && spx_info_p->eom)
{
proto_item *frag_tree_item;
- next_tvb = tvb_new_real_data(fd_head->data,
+ next_tvb = tvb_new_child_real_data(tvb, fd_head->data,
fd_head->len, fd_head->len);
- tvb_set_child_real_data_tvbuff(tvb,
- next_tvb);
add_new_data_source(pinfo,
next_tvb,
"Reassembled NDPS");
else
{
/* This is either a beggining or middle fragment on second dissection */
- next_tvb = tvb_new_subset(tvb, 0, -1, -1);
+ next_tvb = tvb_new_subset_remaining(tvb, 0);
if (check_col(pinfo->cinfo, COL_INFO))
{
- if (!spx_info->eom)
+ if (!spx_info_p->eom)
{
- col_append_fstr(pinfo->cinfo, COL_INFO, "[NDPS Fragment]");
+ col_append_str(pinfo->cinfo, COL_INFO, "[NDPS Fragment]");
}
}
}
/* Fragment from first pass of dissection */
if (check_col(pinfo->cinfo, COL_INFO))
{
- if (!spx_info->eom)
+ if (!spx_info_p->eom)
{
- col_append_fstr(pinfo->cinfo, COL_INFO, "[NDPS Fragment]");
+ col_append_str(pinfo->cinfo, COL_INFO, "[NDPS Fragment]");
}
}
next_tvb = NULL;
/*
* There are no bytes so Dissect this
*/
- next_tvb = tvb_new_subset(tvb, 0, -1, -1);
+ next_tvb = tvb_new_subset_remaining(tvb, 0);
}
if (next_tvb == NULL)
{
/* This is a fragment packet */
- next_tvb = tvb_new_subset (tvb, 0, -1, -1);
+ next_tvb = tvb_new_subset_remaining (tvb, 0);
call_dissector(ndps_data_handle, next_tvb, pinfo, tree);
}
else
{
/* This is the end fragment so dissect and mark end */
- if (spx_info->eom) {
+ if (spx_info_p->eom) {
request_value->ndps_frag = FALSE;
dissect_ndps(next_tvb, pinfo, tree);
}
static void
dissect_ndps_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- tcp_dissect_pdus(tvb, pinfo, tree, ndps_desegment, 4, get_ndps_pdu_len,
- dissect_ndps_pdu);
+ tcp_dissect_pdus(tvb, pinfo, tree, ndps_desegment, 4, get_ndps_pdu_len, dissect_ndps_pdu);
}
static void
dissect_ndps_ipx(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- proto_tree *ndps_tree = NULL;
- proto_item *ti;
+ proto_tree *ndps_tree = NULL;
+ proto_item *ti;
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
- col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDPS");
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDPS");
- if (check_col(pinfo->cinfo, COL_INFO))
- col_clear(pinfo->cinfo, COL_INFO);
+ col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
ti = proto_tree_add_item(tree, proto_ndps, tvb, 0, -1, FALSE);
ndps_defrag(tvb, pinfo, ndps_tree);
}
-static void
+static int
dissect_ndps_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ndps_tree, guint32 ndps_prog, guint32 ndps_func, int foffset)
{
- ndps_req_hash_value *request_value = NULL;
+ ndps_req_hash_value *request_value = NULL;
conversation_t *conversation;
guint32 i;
guint32 j;
guint32 profiles_choice_type;
guint32 integer_type_flag;
guint32 local_servers_type;
- gint length_remaining;
+ gint length_remaining;
proto_tree *atree;
proto_item *aitem;
proto_tree *btree;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Security %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
switch (print_type)
{
case 0: /* Create Job */
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_sub_complete, tvb, foffset, 4, FALSE);
foffset += 4;
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Transfer Method");
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Value %u", j);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = attribute_value(tvb, ctree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Type %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Value %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
if (doc_content==0)
if (length_remaining == -1 || length > (guint32) length_remaining) /* Segmented Data */
{
proto_tree_add_item(btree, hf_ndps_data, tvb, foffset, -1, FALSE);
- return;
+ return foffset;
}
if (length==4)
{
- proto_tree_add_item(btree, hf_ndps_included_doc, tvb, foffset, length, FALSE);
+ proto_tree_add_item(btree, hf_ndps_included_doc, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
}
else
{
- foffset = ndps_string(tvb, hf_ndps_ref_name, btree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_ref_name, btree, foffset, NULL);
foffset = name_or_id(tvb, btree, foffset);
}
proto_item_set_end(bitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Value %u", j);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = attribute_value(tvb, ctree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Document Attributes */
}
break;
case 1: /* Add Job */
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_sub_complete, tvb, foffset, 4, FALSE);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Method %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset); /* Transfer Method */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Type %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset); /* Document Type */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Document Attributes */
proto_item_set_end(aitem, tvb, foffset);
break;
case 2: /* Close Job */
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
break;
case 0x00000005: /* Modify Job */
proto_tree_add_item(ndps_tree, hf_ndps_session, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_ndps_document_number, tvb, foffset, 4, FALSE);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Modification %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Job Modifications */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Modification %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Document Modifications */
case 0x00000006: /* Cancel Job */
proto_tree_add_item(ndps_tree, hf_ndps_session, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_ndps_document_number, tvb, foffset, 4, FALSE);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Attribute %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = attribute_value(tvb, atree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Option %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentification(tvb, btree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
foffset = filteritem(tvb, ndps_tree, foffset);
}
proto_item_set_end(aitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job ID");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job ID");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
}
else
{
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
}
/* Start of nameorid */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Interrupt Message Option");
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Interrupting Job");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job ID");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
}
else
{
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
}
/* Start of nameorid */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Pause Message Option");
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job ID");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Object Attribute Set */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
/* Start of NWDPPrtContainedObjectId */
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Job ID");
btree = proto_item_add_subtree(bitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, btree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, btree, foffset, NULL);
proto_tree_add_item(btree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(bitem, tvb, foffset);
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Attribute %u", j);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = attribute_value(tvb, ctree, foffset); /* Object Attribute Set */
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Attribute %u", j);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = attribute_value(tvb, ctree, foffset); /* Object Attribute Set */
proto_item_set_end(bitem, tvb, foffset);
/* End of AttributeSet */
}
- proto_item_set_end(aitem, tvb, foffset); /* End of ResubmitJob Set */
+ proto_item_set_end(aitem, tvb, foffset); /* End of ResubmitJob Set */
/* Start of NameorID */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Resubmit Message Option");
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Modification %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Object Attribute Set */
foffset += 4;
proto_tree_add_item(ndps_tree, hf_shutdown_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
/* Start of NameorID */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Shutdown Message Option");
atree = proto_item_add_subtree(aitem, ett_ndps);
case 0x00000014: /* Startup PA */
proto_tree_add_item(ndps_tree, hf_ndps_session, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
/* Start of NameorID */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Startup Message Option");
atree = proto_item_add_subtree(aitem, ett_ndps);
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job Identification");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Reference Job ID");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
proto_tree_add_item(ndps_tree, hf_ndps_persistence, tvb, foffset, 4, FALSE);
foffset += 4;
foffset = qualifiedname(tvb, ndps_tree, foffset);
- foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_ndps_language_id, tvb, foffset, 4, FALSE);
foffset += 4;
/* Start of NameorID */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Address %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = address_item(tvb, btree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_ndps_ds_info_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_printer_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_name, ndps_tree, foffset, NULL);
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "DS Object Name");
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = qualifiedname(tvb, atree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_guid, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_guid, tvb, foffset, length, ENC_NA);
}
foffset += length;
break;
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = qualifiedname(tvb, atree, foffset);
proto_item_set_end(aitem, tvb, foffset);
- foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_ndps_language_id, tvb, foffset, 4, FALSE);
foffset += 4;
/* Start of NameorID */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Address %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = address_item(tvb, btree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_notify_lease_exp_time, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_notify_printer_uri, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_notify_printer_uri, ndps_tree, foffset, NULL);
/* End of Eventhandling2 */
break;
case 0x00000024: /* ListEventProfiles2 */
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Security %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
length = tvb_get_ntohl(tvb, foffset);
foffset += 4;
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(atree, hf_ndps_item_bytes, tvb, foffset, length, FALSE);
+ proto_tree_add_item(atree, hf_ndps_item_bytes, tvb, foffset, length, ENC_NA);
}
foffset += length;
}
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Security %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
/* NoOp */
break;
case 0x00000005: /* Register Registry */
- foffset = ndps_string(tvb, hf_ndps_registry_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_registry_name, ndps_tree, foffset, NULL);
foffset = print_address(tvb, ndps_tree, foffset);
break;
case 0x00000007: /* Registry Update */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Entry %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = server_entry(tvb, btree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Entry %u", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = server_entry(tvb, btree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Security %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
/* NoOp */
break;
case 0x00000003: /* Register Supplier */
- foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL);
/* Start of QualifiedName Set*/
number_of_items = tvb_get_ntohl(tvb, foffset);
proto_tree_add_uint(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, number_of_items);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Supplier Alias %u", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = qualifiedname(tvb, atree, foffset);
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Address %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = address_item(tvb, btree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Item %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
/* Start of ReportEventItem */
ctree = proto_item_add_subtree(citem, ett_ndps);
for (j = 1 ; j <= number_of_items; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ctree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ctree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
ditem = proto_tree_add_text(ctree, tvb, foffset, -1, "Modification %d", j);
dtree = proto_item_add_subtree(ditem, ett_ndps);
foffset = attribute_value(tvb, dtree, foffset); /* Object Attribute Set */
}
proto_item_set_end(citem, tvb, foffset);
/* End of AttributeSet */
- foffset = ndps_string(tvb, hf_ndps_message, btree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_message, btree, foffset, NULL);
proto_tree_add_item(btree, hf_time, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(bitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Destination %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
/* Start of Destination */
/* End of Destination */
}
/* End of DestinationSet */
- foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_supplier_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_ndps_event_type, tvb, foffset, 4, FALSE);
foffset += 4;
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Containing Class");
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset);
}
proto_item_set_end(aitem, tvb, foffset);
/* End of AttributeSet */
- foffset = ndps_string(tvb, hf_ndps_message, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_message, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_time, tvb, foffset, 4, FALSE);
foffset += 4;
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Account");
proto_item_set_end(aitem, tvb, foffset);
break;
case 0x0000000c: /* Add Delivery Method */
- foffset = ndps_string(tvb, hf_ndps_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_file_name, ndps_tree, foffset, NULL);
break;
case 0x0000000d: /* Remove Delivery Method */
/* Start of NameorID */
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_context, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset += (length%2);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Security %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length=tvb_get_ntohl(tvb, foffset);
length_remaining = tvb_length_remaining(tvb, foffset);
if(length_remaining == -1 || (guint32) length_remaining < length)
{
- return;
+ return foffset;
}
- proto_tree_add_item(atree, hf_ndps_item_ptr, tvb, foffset, length, FALSE);
+ proto_tree_add_item(atree, hf_ndps_item_ptr, tvb, foffset, length, ENC_NA);
foffset += length;
proto_item_set_end(aitem, tvb, foffset);
}
break;
case 1: /* Printer Definitions */
case 2: /* Printer Definitions Short */
- foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL);
break;
case 3: /* Banner Page Files */
proto_tree_add_item(ndps_tree, hf_banner_type, tvb, foffset, 4, FALSE);
case 9: /* Generic Files */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_printer_type, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_printer_manuf, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_type, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_printer_manuf, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, ndps_tree, foffset, NULL);
field_len = tvb_get_ntohl(tvb, foffset);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_printer_id, tvb, foffset, field_len, FALSE);
+ proto_tree_add_item(ndps_tree, hf_printer_id, tvb, foffset, field_len, ENC_NA);
break;
case 6: /* Printer Definition File */
case 10: /* Printer Definition File 2 */
- foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_printer_type, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_printer_manuf, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_type, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_printer_manuf, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, ndps_tree, foffset, NULL);
field_len = tvb_get_ntohl(tvb, foffset);
foffset += 4;
- proto_tree_add_item(ndps_tree, hf_printer_id, tvb, foffset, field_len, FALSE);
+ proto_tree_add_item(ndps_tree, hf_printer_id, tvb, foffset, field_len, ENC_NA);
break;
case 7: /* Font Files */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_font_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_font_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_font_name, ndps_tree, foffset, NULL);
break;
case 8: /* Generic Type */
case 11: /* Printer Driver Types 2 */
case 13: /* Printer Driver Types Archive */
- foffset = ndps_string(tvb, hf_ndps_printer_manuf, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_printer_type, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_manuf, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_printer_type, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, ndps_tree, foffset, NULL);
break;
case 14: /* Languages Available */
break;
case 0: /* Print Drivers */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL);
break;
case 1: /* Printer Definitions */
- foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_vendor_dir, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL);
break;
case 2: /* Banner Page Files */
- foffset = ndps_string(tvb, hf_ndps_banner_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_banner_name, ndps_tree, foffset, NULL);
break;
case 3: /* Font Types */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(ndps_tree, hf_font_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, ndps_tree, foffset, NULL);
break;
case 4: /* Generic Files/ Archive */
case 5: /* Printer Driver Archive */
proto_tree_add_item(ndps_tree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_archive_type, tvb, foffset, 4, FALSE);
foffset += 4;
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_session, tvb, foffset, 4, FALSE);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = objectidentifier(tvb, btree, foffset);
foffset = attribute_value(tvb, atree, foffset);
- foffset = ndps_string(tvb, hf_ndps_message, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_message, atree, foffset, NULL);
proto_tree_add_item(atree, hf_time, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(bitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Object %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_session, tvb, foffset, 4, FALSE);
btree = proto_item_add_subtree(bitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
foffset = attribute_value(tvb, btree, foffset);
}
proto_item_set_end(bitem, tvb, foffset);
/* End of AttributeSet */
- foffset = ndps_string(tvb, hf_ndps_message, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_message, atree, foffset, NULL);
proto_tree_add_item(atree, hf_time, tvb, foffset, 4, FALSE);
foffset += 4;
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Account");
default:
break;
}
- return;
+ return foffset;
}
static int
proto_item *aitem;
proto_tree *btree;
proto_item *bitem;
+ proto_item *expert_item;
ndps_problem_type = tvb_get_ntohl(tvb, foffset);
- if (check_col(pinfo->cinfo, COL_INFO))
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
expert_item = proto_tree_add_uint(ndps_tree, hf_ndps_problem_type, tvb, foffset, 4, ndps_problem_type);
expert_add_info_format(pinfo, expert_item, PI_RESPONSE_CODE, PI_ERROR, "Fault: %s", val_to_str(ndps_problem_type, error_type_enum, "Unknown NDPS Error (0x%08x)"));
foffset += 4;
foffset += 4;
proto_tree_add_item(ndps_tree, hf_ndps_other_error_2, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_other_error_string, ndps_tree, foffset, NULL, 0);
+ if (tvb_length_remaining(tvb, foffset) >= 4) {
+ foffset = ndps_string(tvb, hf_ndps_other_error_string, ndps_tree, foffset, NULL);
+ }
break;
case 2: /* Access Error */
proto_tree_add_item(ndps_tree, hf_problem_type, tvb, foffset, 4, FALSE);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_problem_type, tvb, foffset, 4, FALSE);
static int
return_code(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ndps_tree, int foffset)
{
+ guint32 expert_status;
+ proto_item *expert_item;
+
expert_status = tvb_get_ntohl(tvb, foffset);
expert_item = proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
if (expert_status != 0) {
}
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
if (tvb_get_ntohl(tvb, foffset-4) == 0)
{
return foffset;
return foffset;
}
-static void
+static int
dissect_ndps_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ndps_tree, int foffset)
{
conversation_t *conversation = NULL;
guint32 ndps_prog=0;
guint32 error_val=0;
guint32 resource_type=0;
- gint length_remaining;
+ gint length_remaining;
+ proto_item *expert_item;
+ guint32 expert_status;
if (!pinfo->fd->flags.visited) {
/* Find the conversation whence the request would have come. */
if (tvb_length_remaining(tvb, foffset) < 12 && tvb_get_ntohl(tvb, foffset) == 0) /* No error and no return data */
{
proto_tree_add_uint(ndps_tree, hf_ndps_error_val, tvb, foffset, 4, error_val);
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_str(pinfo->cinfo, COL_INFO, "- Ok");
- return;
+ col_append_str(pinfo->cinfo, COL_INFO, "- Ok");
+ return foffset;
}
if(ndps_func == 1 || ndps_func == 2)
{
}
foffset += 4;
if (tvb_length_remaining(tvb,foffset) < 4 ) {
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_str(pinfo->cinfo, COL_INFO, "- Error");
- return;
+ col_append_str(pinfo->cinfo, COL_INFO, "- Error");
+ return foffset;
}
proto_tree_add_item(ndps_tree, hf_ndps_rpc_acc_results, tvb, foffset, 4, FALSE);
foffset += 4;
if (tvb_length_remaining(tvb,foffset) < 4) {
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_str(pinfo->cinfo, COL_INFO, "- Error");
- return;
+ col_append_str(pinfo->cinfo, COL_INFO, "- Error");
+ return foffset;
}
}
error_val = tvb_get_ntohl(tvb, foffset);
expert_status = tvb_get_ntohl(tvb, foffset);
expert_item = proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
expert_add_info_format(pinfo, expert_item, PI_RESPONSE_CODE, PI_ERROR, "Fault: %s", val_to_str(expert_status, ndps_error_types, "Unknown NDPS Error (0x%08x)"));
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_str(pinfo->cinfo, COL_INFO, "- Error");
- return;
+ col_append_str(pinfo->cinfo, COL_INFO, "- Error");
+ return foffset;
}
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_str(pinfo->cinfo, COL_INFO, "- Ok");
+ col_append_str(pinfo->cinfo, COL_INFO, "- Ok");
switch(ndps_prog)
{
case 0x060976: /* Print */
proto_tree_add_item(ndps_tree, hf_ndps_session, tvb, foffset, 4, FALSE);
foffset += 4;
}
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
break;
case 0x00000003: /* Unbind */
break;
case 0x00000004: /* Print */
- foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ndps_tree, foffset, NULL);
proto_tree_add_item(ndps_tree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
if(error_val != 0)
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Object Attribute Set */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Option %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
length=tvb_get_ntohl(tvb, foffset);
length_remaining = tvb_length_remaining(tvb, foffset);
if(length_remaining == -1 || (guint32) length_remaining < length)
{
- return;
+ return foffset;
}
- proto_tree_add_item(btree, hf_ndps_item_ptr, tvb, foffset, length, FALSE);
+ proto_tree_add_item(btree, hf_ndps_item_ptr, tvb, foffset, length, ENC_NA);
foffset += length;
proto_item_set_end(bitem, tvb, foffset);
}
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_len, tvb, foffset, 4, FALSE);
foffset += 4;
- proto_tree_add_item(atree, hf_limit_enc, tvb, foffset, 4, FALSE);
+ proto_tree_add_item(atree, hf_ndps_limit_enc, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
/* Object Results Set */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
- bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Result %d", i);
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated Result]");
+ break;
+ }
+ bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Results: (%d)", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
+ if (i>1) {
+ foffset += 2;
+ }
foffset = objectidentification(tvb, btree, foffset);
number_of_items2 = tvb_get_ntohl(tvb, foffset);
proto_tree_add_uint(btree, hf_ndps_num_objects, tvb, foffset, 4, number_of_items2);
foffset += 4;
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
- citem = proto_tree_add_text(btree, tvb, foffset, -1, "Attribute %d", j);
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated Object]");
+ break;
+ }
+ citem = proto_tree_add_text(btree, tvb, foffset, -1, "Object: (%d)", j);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = objectidentifier(tvb, ctree, foffset);
foffset += align_4(tvb, foffset);
number_of_items3 = tvb_get_ntohl(tvb, foffset);
- proto_tree_add_uint(ctree, hf_ndps_num_attributes, tvb, foffset, 4, number_of_items3);
+ proto_tree_add_uint(ctree, hf_ndps_num_values, tvb, foffset, 4, number_of_items3);
foffset += 4;
for (k = 1 ; k <= number_of_items3; k++ )
{
- if (k > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ctree, tvb, foffset, -1, "[Truncated]");
- break;
- }
- ditem = proto_tree_add_text(ctree, tvb, foffset, -1, "Value %d", k);
+ if (k > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ctree, tvb, foffset, -1, "[Truncated Value]");
+ break;
+ }
+ ditem = proto_tree_add_text(ctree, tvb, foffset, -1, "Value: (%d)", k);
dtree = proto_item_add_subtree(ditem, ett_ndps);
foffset = attribute_value(tvb, dtree, foffset);
- foffset += align_4(tvb, foffset);
proto_item_set_end(ditem, tvb, foffset);
}
proto_tree_add_item(ctree, hf_ndps_qualifier, tvb, foffset, 4, FALSE);
foffset += 4;
+ foffset += align_4(tvb, foffset);
proto_item_set_end(citem, tvb, foffset);
}
+
+ /*foffset += align_4(tvb, foffset);*/
foffset = objectidentifier(tvb, btree, foffset);
- foffset += 2;
+ /*foffset += align_4(tvb, foffset);*/
proto_item_set_end(bitem, tvb, foffset);
}
proto_item_set_end(aitem, tvb, foffset);
/* Start of NWDPPrtContainedObjectId */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Job ID");
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Attribute %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Object Attribute Set */
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Job %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
/* Start of NWDPPrtContainedObjectId */
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Old Job");
ctree = proto_item_add_subtree(citem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, ctree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ctree, foffset, NULL);
proto_tree_add_item(ctree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(citem, tvb, foffset);
/* Start of NWDPPrtContainedObjectId */
citem = proto_tree_add_text(btree, tvb, foffset, -1, "New Job");
ctree = proto_item_add_subtree(citem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_pa_name, ctree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_pa_name, ctree, foffset, NULL);
proto_tree_add_item(ctree, hf_local_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(citem, tvb, foffset);
ctree = proto_item_add_subtree(citem, ett_ndps);
for (j = 1 ; j <= number_of_items2; j++ )
{
- if (j > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ctree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (j > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ctree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
ditem = proto_tree_add_text(ctree, tvb, foffset, -1, "Object %d", j);
dtree = proto_item_add_subtree(ditem, ett_ndps);
foffset = attribute_value(tvb, dtree, foffset); /* Object Attribute Set */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Object %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = attribute_value(tvb, btree, foffset); /* Object Attribute Set */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Object %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
- foffset = attribute_value(tvb, atree, foffset); /* Object Attribute Set */
+ foffset = attribute_value(tvb, btree, foffset); /* Object Attribute Set */
proto_item_set_end(bitem, tvb, foffset);
}
proto_item_set_end(aitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Address %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = address_item(tvb, btree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, ENC_NA);
}
foffset += length;
if(error_val != 0)
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Event %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
/* Start of Eventhandling2 */
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Consumer Name");
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = qualifiedname(tvb, btree, foffset);
- foffset = ndps_string(tvb, hf_ndps_supplier_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_supplier_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_ndps_language_id, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(bitem, tvb, foffset);
btree = proto_item_add_subtree(bitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Address %d", i);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = address_item(tvb, ctree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
citem = proto_tree_add_text(btree, tvb, foffset, -1, "Attribute %d", i);
ctree = proto_item_add_subtree(citem, ett_ndps);
foffset = objectidentifier(tvb, ctree, foffset);
foffset += 4;
proto_tree_add_item(atree, hf_notify_lease_exp_time, tvb, foffset, 4, FALSE);
foffset += 4;
- foffset = ndps_string(tvb, hf_notify_printer_uri, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_notify_printer_uri, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
/* End of Eventhandling2 */
length = tvb_get_ntohl(tvb, foffset); /* Added on 10-17-03 */
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, ENC_NA);
}
foffset += length;
if(error_val != 0)
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Service %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_service_type, tvb, foffset, 4, FALSE);
break;
case 0x00000007: /* Get Broker NDS Object Name */
proto_tree_add_item(ndps_tree, hf_ndps_item_count, tvb, foffset,
- 4, FALSE); /* XXX - what does this count? */
+ 4, FALSE); /* XXX - what does this count? */
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_broker_name, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_broker_name, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
foffset = return_code(tvb, pinfo, ndps_tree, foffset);
break;
case 0x00000008: /* Get Broker Session Information */
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Attribute %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(atree, hf_ndps_attribute_set, tvb, foffset, length, FALSE);
+ proto_tree_add_item(atree, hf_ndps_attribute_set, tvb, foffset, length, ENC_NA);
}
proto_item_set_end(aitem, tvb, foffset);
}
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = server_entry(tvb, atree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset = return_code(tvb, pinfo, ndps_tree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_item(ndps_tree, hf_ndps_client_server_type, tvb, foffset, 4, FALSE);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_registry_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_registry_name, atree, foffset, NULL);
foffset = print_address(tvb, atree, foffset);
}
length = tvb_get_ntohl(tvb, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset = return_code(tvb, pinfo, ndps_tree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Attribute %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
length = tvb_get_ntohl(tvb, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(atree, hf_ndps_attribute_set, tvb, foffset, length, FALSE);
+ proto_tree_add_item(atree, hf_ndps_attribute_set, tvb, foffset, length, ENC_NA);
}
proto_item_set_end(aitem, tvb, foffset);
}
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Address %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = address_item(tvb, btree, foffset);
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_continuation_option, tvb, foffset, length, ENC_NA);
}
foffset += length;
foffset = return_code(tvb, pinfo, ndps_tree, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
/* Start of DeliveryMethod */
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Method %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset += align_4(tvb, foffset);
proto_item_set_end(bitem, tvb, foffset);
/* End of NameorID */
- foffset = ndps_string(tvb, hf_ndps_method_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_method_ver, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_method_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_method_ver, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_file_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_ndps_admin_submit, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
atree = proto_item_add_subtree(aitem, ett_ndps);
foffset = name_or_id(tvb, atree, foffset);
/* End of NameorID */
- foffset = ndps_string(tvb, hf_ndps_method_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_method_ver, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_method_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_method_ver, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_file_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_ndps_admin_submit, tvb, foffset, 4, FALSE);
foffset += 4;
proto_item_set_end(aitem, tvb, foffset);
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Address %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
foffset = address_item(tvb, btree, foffset);
break;
case 0x00000010: /* Get Notify NDS Object Name */
proto_tree_add_item(ndps_tree, hf_ndps_item_count, tvb, foffset,
- 4, FALSE); /* XXX - what does this count? */
+ 4, FALSE); /* XXX - what does this count? */
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_broker_name, ndps_tree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_broker_name, ndps_tree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_tree, ndps_tree, foffset, NULL);
foffset = return_code(tvb, pinfo, ndps_tree, foffset);
break;
case 0x00000011: /* Get Notify Session Information */
if (length!=0)
{
tvb_ensure_bytes_exist(tvb, foffset, length);
- proto_tree_add_item(ndps_tree, hf_ndps_attribute_set, tvb, foffset, length, FALSE);
+ proto_tree_add_item(ndps_tree, hf_ndps_attribute_set, tvb, foffset, length, ENC_NA);
}
break;
case 0x00000002: /* Unbind */
proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
if (tvb_get_ntohl(tvb, foffset-4) != 0)
{
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Definition %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
if (tvb_get_ntohl(tvb, foffset)==0) { /* Offset for old type support */
foffset += 2;
}
foffset += 4; /* Item always == 1 */
- foffset = ndps_string(tvb, hf_ndps_printer_manuf, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_manuf, atree, foffset, NULL);
if (tvb_get_ntohl(tvb, foffset)==0) {
foffset += 2;
}
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_printer_type, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_type, atree, foffset, NULL);
if (tvb_get_ntohl(tvb, foffset)==0) {
foffset += 2;
}
foffset += 4;
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Banner %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_banner_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_banner_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Font %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_font_type_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_font_type_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Font File %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_font_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_font_file_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "File %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
break;
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Definition %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_inf_file_name, atree, foffset, NULL);
proto_item_set_end(aitem, tvb, foffset);
}
number_of_items = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Item %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_def_file_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_def_file_name, atree, foffset, NULL);
number_of_items2 = tvb_get_ntohl(tvb, foffset);
proto_tree_add_uint(atree, hf_ndps_num_win31_keys, tvb, foffset, 4, number_of_items2);
bitem = proto_tree_add_text(atree, tvb, foffset, 4, "Windows 3.1 Keys");
foffset += 4;
for (i = 1 ; i <= number_of_items2; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
- foffset = ndps_string(tvb, hf_ndps_windows_key, btree, foffset, NULL, 0);
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
+ foffset = ndps_string(tvb, hf_ndps_windows_key, btree, foffset, NULL);
}
proto_item_set_end(bitem, tvb, foffset);
number_of_items2 = tvb_get_ntohl(tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items2; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
- break;
- }
- foffset = ndps_string(tvb, hf_ndps_windows_key, btree, foffset, NULL, 0);
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(btree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
+ foffset = ndps_string(tvb, hf_ndps_windows_key, btree, foffset, NULL);
}
proto_item_set_end(bitem, tvb, foffset);
proto_item_set_end(aitem, tvb, foffset);
}
break;
case 10: /* Printer Definition File 2 */
- foffset = ndps_string(tvb, hf_ndps_def_file_name, ndps_tree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_def_file_name, ndps_tree, foffset, NULL);
number_of_items = tvb_get_ntohl(tvb, foffset);
proto_tree_add_uint(ndps_tree, hf_os_count, tvb, foffset, 4, number_of_items);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "OS %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_os_type, tvb, foffset, 4, FALSE);
foffset += 4;
for (i = 1 ; i <= number_of_items2; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Key %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_windows_key, btree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_windows_key, btree, foffset, NULL);
proto_item_set_end(bitem, tvb, foffset);
}
proto_item_set_end(aitem, tvb, foffset);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Type %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
- foffset = ndps_string(tvb, hf_ndps_printer_manuf, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_printer_type, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_file_name, atree, foffset, NULL, 0);
- foffset = ndps_string(tvb, hf_ndps_prn_dir_name, atree, foffset, NULL, 0);
+ foffset = ndps_string(tvb, hf_ndps_printer_manuf, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_printer_type, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_file_name, atree, foffset, NULL);
+ foffset = ndps_string(tvb, hf_ndps_prn_dir_name, atree, foffset, NULL);
proto_tree_add_item(atree, hf_archive_type, tvb, foffset, 4, FALSE);
foffset += 4;
proto_tree_add_item(atree, hf_archive_file_size, tvb, foffset, 4, FALSE);
foffset += 4;
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(ndps_tree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
aitem = proto_tree_add_text(ndps_tree, tvb, foffset, -1, "Language %d", i);
atree = proto_item_add_subtree(aitem, ett_ndps);
proto_tree_add_item(atree, hf_ndps_language_id, tvb, foffset, 4, FALSE);
proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
if (tvb_get_ntohl(tvb, foffset-4) != 0)
{
break;
proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
if (tvb_get_ntohl(tvb, foffset-4) != 0)
{
break;
proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
if (tvb_get_ntohl(tvb, foffset-4) != 0)
{
break;
proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
break;
case 0x00000002: /* Delivery Unbind */
/* NoOp */
proto_tree_add_item(ndps_tree, hf_ndps_return_code, tvb, foffset, 4, FALSE);
foffset += 4;
if (check_col(pinfo->cinfo, COL_INFO) && tvb_get_ntohl(tvb, foffset-4) != 0)
- col_add_fstr(pinfo->cinfo, COL_INFO, "R NDPS - Error");
+ col_set_str(pinfo->cinfo, COL_INFO, "R NDPS - Error");
if (tvb_get_ntohl(tvb, foffset-4) != 0)
{
break;
atree = proto_item_add_subtree(aitem, ett_ndps);
for (i = 1 ; i <= number_of_items; i++ )
{
- if (i > NDPS_MAX_ITEMS) {
- proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
- break;
- }
+ if (i > NDPS_MAX_ITEMS) {
+ proto_tree_add_text(atree, tvb, foffset, -1, "[Truncated]");
+ break;
+ }
bitem = proto_tree_add_text(atree, tvb, foffset, -1, "Item %d", i);
btree = proto_item_add_subtree(bitem, ett_ndps);
length=tvb_get_ntohl(tvb, foffset);
length_remaining = tvb_length_remaining(tvb, foffset);
if(length_remaining == -1 || (guint32) length_remaining < length)
{
- return;
+ return foffset;
}
- proto_tree_add_item(btree, hf_ndps_item_ptr, tvb, foffset, length, FALSE);
+ proto_tree_add_item(btree, hf_ndps_item_ptr, tvb, foffset, length, ENC_NA);
foffset += length;
proto_item_set_end(bitem, tvb, foffset);
}
default:
break;
}
- return;
+ return foffset;
}
void
proto_register_ndps(void)
{
- static hf_register_info hf_ndps[] = {
- { &hf_ndps_record_mark,
- { "Record Mark", "ndps.record_mark", FT_UINT16, BASE_HEX, NULL, 0x0,
- "Record Mark", HFILL }},
+ static hf_register_info hf_ndps[] = {
+ { &hf_ndps_record_mark,
+ { "Record Mark", "ndps.record_mark", FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_packet_type,
- { "Packet Type", "ndps.packet_type",
- FT_UINT32, BASE_HEX, VALS(ndps_packet_types), 0x0,
- "Packet Type", HFILL }},
+ { "Packet Type", "ndps.packet_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_packet_types), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_length,
- { "Record Length", "ndps.record_length",
- FT_UINT16, BASE_DEC, NULL, 0x0,
- "Record Length", HFILL }},
+ { "Record Length", "ndps.record_length",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_xid,
- { "Exchange ID", "ndps.xid",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Exchange ID", HFILL }},
+ { "Exchange ID", "ndps.xid",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_rpc_version,
- { "RPC Version", "ndps.rpc_version",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "RPC Version", HFILL }},
+ { "RPC Version", "ndps.rpc_version",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_program,
- { "NDPS Program Number", "spx.ndps_program",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_program_vals), 0x0,
- "NDPS Program Number", HFILL }},
+ { "NDPS Program Number", "spx.ndps_program",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_program_vals), 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_version,
- { "Program Version", "spx.ndps_version",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Program Version", HFILL }},
+ { "Program Version", "spx.ndps_version",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_error,
- { "NDPS Error", "spx.ndps_error",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "NDPS Error", HFILL }},
+ { "NDPS Error", "spx.ndps_error",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_other_error_string,
- { "Extended Error String", "ndps.ext_err_string",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Extended Error String", HFILL }},
+ { "Extended Error String", "ndps.ext_err_string",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_func_print,
- { "Print Program", "spx.ndps_func_print",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_print_func_vals), 0x0,
- "Print Program", HFILL }},
+ { "Print Program", "spx.ndps_func_print",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_print_func_vals), 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_func_notify,
- { "Notify Program", "spx.ndps_func_notify",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_notify_func_vals), 0x0,
- "Notify Program", HFILL }},
+ { "Notify Program", "spx.ndps_func_notify",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_notify_func_vals), 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_func_delivery,
- { "Delivery Program", "spx.ndps_func_delivery",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_deliver_func_vals), 0x0,
- "Delivery Program", HFILL }},
+ { "Delivery Program", "spx.ndps_func_delivery",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_deliver_func_vals), 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_func_registry,
- { "Registry Program", "spx.ndps_func_registry",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_registry_func_vals), 0x0,
- "Registry Program", HFILL }},
+ { "Registry Program", "spx.ndps_func_registry",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_registry_func_vals), 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_func_resman,
- { "ResMan Program", "spx.ndps_func_resman",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_resman_func_vals), 0x0,
- "ResMan Program", HFILL }},
+ { "ResMan Program", "spx.ndps_func_resman",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_resman_func_vals), 0x0,
+ NULL, HFILL }},
{ &hf_spx_ndps_func_broker,
- { "Broker Program", "spx.ndps_func_broker",
- FT_UINT32, BASE_HEX, VALS(spx_ndps_broker_func_vals), 0x0,
- "Broker Program", HFILL }},
+ { "Broker Program", "spx.ndps_func_broker",
+ FT_UINT32, BASE_HEX, VALS(spx_ndps_broker_func_vals), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_objects,
- { "Number of Objects", "ndps.num_objects",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Objects", HFILL }},
+ { "Number of Objects", "ndps.num_objects",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_attributes,
- { "Number of Attributes", "ndps.num_attributes",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Attributes", HFILL }},
+ { "Number of Attributes", "ndps.num_attributes",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_sbuffer,
- { "Server", "ndps.sbuffer",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Server", HFILL }},
+ { "Server", "ndps.sbuffer",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_rbuffer,
- { "Connection", "ndps.rbuffer",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Connection", HFILL }},
+ { "Connection", "ndps.rbuffer",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_user_name,
- { "Trustee Name", "ndps.user_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Trustee Name", HFILL }},
+ { "Trustee Name", "ndps.user_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_broker_name,
- { "Broker Name", "ndps.broker_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Broker Name", HFILL }},
+ { "Broker Name", "ndps.broker_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_results,
- { "Number of Results", "ndps.num_results",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Results", HFILL }},
+ { "Number of Results", "ndps.num_results",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_options,
- { "Number of Options", "ndps.num_options",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Options", HFILL }},
+ { "Number of Options", "ndps.num_options",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_jobs,
- { "Number of Jobs", "ndps.num_jobs",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Jobs", HFILL }},
+ { "Number of Jobs", "ndps.num_jobs",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_pa_name,
- { "Printer Name", "ndps.pa_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer Name", HFILL }},
+ { "Printer Name", "ndps.pa_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_tree,
- { "Tree", "ndps.tree",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Tree", HFILL }},
+ { "Tree", "ndps.tree",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_reqframe,
- { "Request Frame", "ndps.reqframe",
- FT_FRAMENUM, BASE_NONE, NULL, 0x0,
- "Request Frame", HFILL }},
+ { "Request Frame", "ndps.reqframe",
+ FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_error_val,
- { "Return Status", "ndps.error_val",
- FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
- "Return Status", HFILL }},
+ { "Return Status", "ndps.error_val",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_object,
- { "Object ID", "ndps.object",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Object ID", HFILL }},
+ { "Object ID", "ndps.object",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_cred_type,
- { "Credential Type", "ndps.cred_type",
- FT_UINT32, BASE_HEX, VALS(ndps_credential_enum), 0x0,
- "Credential Type", HFILL }},
+ { "Credential Type", "ndps.cred_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_credential_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_server_name,
- { "Server Name", "ndps.server_name",
- FT_STRING, BASE_DEC, NULL, 0x0,
- "Server Name", HFILL }},
+ { "Server Name", "ndps.server_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_connection,
- { "Connection", "ndps.connection",
- FT_UINT16, BASE_DEC, NULL, 0x0,
- "Connection", HFILL }},
+ { "Connection", "ndps.connection",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ext_error,
- { "Extended Error Code", "ndps.ext_error",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Extended Error Code", HFILL }},
+ { "Extended Error Code", "ndps.ext_error",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_auth_null,
- { "Auth Null", "ndps.auth_null",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Auth Null", HFILL }},
+ { "Auth Null", "ndps.auth_null",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_rpc_accept,
- { "RPC Accept or Deny", "ndps.rpc_acc",
- FT_UINT32, BASE_HEX, VALS(true_false), 0x0,
- "RPC Accept or Deny", HFILL }},
+ { "RPC Accept or Deny", "ndps.rpc_acc",
+ FT_UINT32, BASE_HEX, VALS(true_false), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_rpc_acc_stat,
- { "RPC Accept Status", "ndps.rpc_acc_stat",
- FT_UINT32, BASE_HEX, VALS(accept_stat), 0x0,
- "RPC Accept Status", HFILL }},
+ { "RPC Accept Status", "ndps.rpc_acc_stat",
+ FT_UINT32, BASE_HEX, VALS(accept_stat), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_rpc_rej_stat,
- { "RPC Reject Status", "ndps.rpc_rej_stat",
- FT_UINT32, BASE_HEX, VALS(reject_stat), 0x0,
- "RPC Reject Status", HFILL }},
+ { "RPC Reject Status", "ndps.rpc_rej_stat",
+ FT_UINT32, BASE_HEX, VALS(reject_stat), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_rpc_acc_results,
- { "RPC Accept Results", "ndps.rpc_acc_res",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "RPC Accept Results", HFILL }},
+ { "RPC Accept Results", "ndps.rpc_acc_res",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_problem_type,
- { "Problem Type", "ndps.rpc_prob_type",
- FT_UINT32, BASE_HEX, VALS(error_type_enum), 0x0,
- "Problem Type", HFILL }},
+ { "Problem Type", "ndps.rpc_prob_type",
+ FT_UINT32, BASE_HEX, VALS(error_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_security_problem_type,
- { "Security Problem", "ndps.rpc_sec_prob",
- FT_UINT32, BASE_HEX, VALS(security_problem_enum), 0x0,
- "Security Problem", HFILL }},
+ { "Security Problem", "ndps.rpc_sec_prob",
+ FT_UINT32, BASE_HEX, VALS(security_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_service_problem_type,
- { "Service Problem", "ndps.rpc_serv_prob",
- FT_UINT32, BASE_HEX, VALS(service_problem_enum), 0x0,
- "Service Problem", HFILL }},
+ { "Service Problem", "ndps.rpc_serv_prob",
+ FT_UINT32, BASE_HEX, VALS(service_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_access_problem_type,
- { "Access Problem", "ndps.rpc_acc_prob",
- FT_UINT32, BASE_HEX, VALS(access_problem_enum), 0x0,
- "Access Problem", HFILL }},
+ { "Access Problem", "ndps.rpc_acc_prob",
+ FT_UINT32, BASE_HEX, VALS(access_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_printer_problem_type,
- { "Printer Problem", "ndps.rpc_print_prob",
- FT_UINT32, BASE_HEX, VALS(printer_problem_enum), 0x0,
- "Printer Problem", HFILL }},
+ { "Printer Problem", "ndps.rpc_print_prob",
+ FT_UINT32, BASE_HEX, VALS(printer_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_selection_problem_type,
- { "Selection Problem", "ndps.rpc_sel_prob",
- FT_UINT32, BASE_HEX, VALS(selection_problem_enum), 0x0,
- "Selection Problem", HFILL }},
+ { "Selection Problem", "ndps.rpc_sel_prob",
+ FT_UINT32, BASE_HEX, VALS(selection_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_doc_access_problem_type,
- { "Document Access Problem", "ndps.rpc_doc_acc_prob",
- FT_UINT32, BASE_HEX, VALS(doc_access_problem_enum), 0x0,
- "Document Access Problem", HFILL }},
+ { "Document Access Problem", "ndps.rpc_doc_acc_prob",
+ FT_UINT32, BASE_HEX, VALS(doc_access_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_attribute_problem_type,
- { "Attribute Problem", "ndps.rpc_attr_prob",
- FT_UINT32, BASE_HEX, VALS(attribute_problem_enum), 0x0,
- "Attribute Problem", HFILL }},
+ { "Attribute Problem", "ndps.rpc_attr_prob",
+ FT_UINT32, BASE_HEX, VALS(attribute_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_update_problem_type,
- { "Update Problem", "ndps.rpc_update_prob",
- FT_UINT32, BASE_HEX, VALS(update_problem_enum), 0x0,
- "Update Problem", HFILL }},
+ { "Update Problem", "ndps.rpc_update_prob",
+ FT_UINT32, BASE_HEX, VALS(update_problem_enum), 0x0,
+ NULL, HFILL }},
{ &hf_obj_id_type,
- { "Object ID Type", "ndps.rpc_obj_id_type",
- FT_UINT32, BASE_HEX, VALS(obj_identification_enum), 0x0,
- "Object ID Type", HFILL }},
+ { "Object ID Type", "ndps.rpc_obj_id_type",
+ FT_UINT32, BASE_HEX, VALS(obj_identification_enum), 0x0,
+ NULL, HFILL }},
{ &hf_oid_struct_size,
- { "OID Struct Size", "ndps.rpc_oid_struct_size",
- FT_UINT16, BASE_DEC, NULL, 0x0,
- "OID Struct Size", HFILL }},
+ { "OID Struct Size", "ndps.rpc_oid_struct_size",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_object_name,
- { "Object Name", "ndps.ndps_object_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Object Name", HFILL }},
+ { "Object Name", "ndps.object_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_document_number,
- { "Document Number", "ndps.ndps_doc_num",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Document Number", HFILL }},
+ { "Document Number", "ndps.doc_num",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_doc_content,
- { "Document Content", "ndps.ndps_doc_content",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Document Content", HFILL }},
+ { "Document Content", "ndps.doc_content",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_nameorid,
- { "Name or ID Type", "ndps.ndps_nameorid",
- FT_UINT32, BASE_HEX, VALS(nameorid_enum), 0x0,
- "Name or ID Type", HFILL }},
+ { "Name or ID Type", "ndps.nameorid",
+ FT_UINT32, BASE_HEX, VALS(nameorid_enum), 0x0,
+ NULL, HFILL }},
- { &hf_local_object_name,
- { "Local Object Name", "ndps.ndps_loc_object_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Local Object Name", HFILL }},
+ { &hf_ndps_local_object_name,
+ { "Local Object Name", "ndps.loc_object_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
- { &hf_printer_name,
- { "Printer Name", "ndps.ndps_printer_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer Name", HFILL }},
+ { &hf_ndps_printer_name,
+ { "Printer Name", "ndps.printer_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_qualified_name,
- { "Qualified Name Type", "ndps.ndps_qual_name_type",
- FT_UINT32, BASE_HEX, VALS(qualified_name_enum), 0x0,
- "Qualified Name Type", HFILL }},
+ { "Qualified Name Type", "ndps.qual_name_type",
+ FT_UINT32, BASE_HEX, VALS(qualified_name_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_qualified_name2,
- { "Qualified Name Type", "ndps.ndps_qual_name_type2",
- FT_UINT32, BASE_HEX, VALS(qualified_name_enum2), 0x0,
- "Qualified Name Type", HFILL }},
+ { "Qualified Name Type", "ndps.qual_name_type2",
+ FT_UINT32, BASE_HEX, VALS(qualified_name_enum2), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_item_count,
- { "Number of Items", "ndps.ndps_item_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Items", HFILL }},
+ { "Number of Items", "ndps.item_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_passwords,
- { "Number of Passwords", "ndps.num_passwords",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Passwords", HFILL }},
+ { "Number of Passwords", "ndps.num_passwords",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_servers,
- { "Number of Servers", "ndps.num_servers",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Servers", HFILL }},
+ { "Number of Servers", "ndps.num_servers",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_locations,
- { "Number of Locations", "ndps.num_locations",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Locations", HFILL }},
+ { "Number of Locations", "ndps.num_locations",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_areas,
- { "Number of Areas", "ndps.num_areas",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Areas", HFILL }},
+ { "Number of Areas", "ndps.num_areas",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_address_items,
- { "Number of Address Items", "ndps.num_address_items",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Address Items", HFILL }},
+ { "Number of Address Items", "ndps.num_address_items",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_job_categories,
- { "Number of Job Categories", "ndps.num_job_categories",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Job Categories", HFILL }},
+ { "Number of Job Categories", "ndps.num_job_categories",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_page_selects,
- { "Number of Page Select Items", "ndps.num_page_selects",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Page Select Items", HFILL }},
+ { "Number of Page Select Items", "ndps.num_page_selects",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_page_informations,
- { "Number of Page Information Items", "ndps.num_page_informations",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Page Information Items", HFILL }},
+ { "Number of Page Information Items", "ndps.num_page_informations",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_names,
- { "Number of Names", "ndps.num_names",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Names", HFILL }},
+ { "Number of Names", "ndps.num_names",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_categories,
- { "Number of Categories", "ndps.num_categories",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Categories", HFILL }},
+ { "Number of Categories", "ndps.num_categories",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_colorants,
- { "Number of Colorants", "ndps.num_colorants",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Colorants", HFILL }},
+ { "Number of Colorants", "ndps.num_colorants",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_events,
- { "Number of Events", "ndps.num_events",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Events", HFILL }},
+ { "Number of Events", "ndps.num_events",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_args,
- { "Number of Arguments", "ndps.num_argss",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Arguments", HFILL }},
+ { "Number of Arguments", "ndps.num_argss",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_transfer_methods,
- { "Number of Transfer Methods", "ndps.num_transfer_methods",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Transfer Methods", HFILL }},
+ { "Number of Transfer Methods", "ndps.num_transfer_methods",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_doc_types,
- { "Number of Document Types", "ndps.num_doc_types",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Document Types", HFILL }},
+ { "Number of Document Types", "ndps.num_doc_types",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_destinations,
- { "Number of Destinations", "ndps.num_destinations",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Destinations", HFILL }},
+ { "Number of Destinations", "ndps.num_destinations",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_qualifier,
- { "Qualifier", "ndps.ndps_qual",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Qualifier", HFILL }},
+ { "Qualifier", "ndps.qual",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_lib_error,
- { "Library Error", "ndps.ndps_lib_error",
- FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
- "Library Error", HFILL }},
+ { "Library Error", "ndps.lib_error",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_other_error,
- { "Other Error", "ndps.ndps_other_error",
- FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
- "Other Error", HFILL }},
+ { "Other Error", "ndps.other_error",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_other_error_2,
- { "Other Error 2", "ndps.ndps_other_error_2",
- FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
- "Other Error 2", HFILL }},
+ { "Other Error 2", "ndps.other_error_2",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_session,
- { "Session Handle", "ndps.ndps_session",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Session Handle", HFILL }},
+ { "Session Handle", "ndps.session",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_abort_flag,
- { "Abort?", "ndps.ndps_abort",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Abort?", HFILL }},
+ { "Abort?", "ndps.abort",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
- { &hf_obj_attribute_type,
- { "Value Syntax", "ndps.ndps_attrib_type",
- FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
- "Value Syntax", HFILL }},
+ { &hf_ndps_obj_attribute_type,
+ { "Value Syntax", "ndps.attrib_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_attribute_value,
- { "Value", "ndps.attribue_value",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Value", HFILL }},
+ { "Value", "ndps.attribue_value",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_lower_range,
- { "Lower Range", "ndps.lower_range",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Lower Range", HFILL }},
+ { "Lower Range", "ndps.lower_range",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_upper_range,
- { "Upper Range", "ndps.upper_range",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Upper Range", HFILL }},
+ { "Upper Range", "ndps.upper_range",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_n64,
- { "Value", "ndps.n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Value", HFILL }},
+ { "Value", "ndps.n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_lower_range_n64,
- { "Lower Range", "ndps.lower_range_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Lower Range", HFILL }},
+ { "Lower Range", "ndps.lower_range_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_upper_range_n64,
- { "Upper Range", "ndps.upper_range_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Upper Range", HFILL }},
+ { "Upper Range", "ndps.upper_range_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_attrib_boolean,
- { "Value?", "ndps.ndps_attrib_boolean",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Value?", HFILL }},
+ { "Value?", "ndps.attrib_boolean",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_realization,
- { "Realization Type", "ndps.ndps_realization",
- FT_UINT32, BASE_HEX, VALS(ndps_realization_enum), 0x0,
- "Realization Type", HFILL }},
+ { "Realization Type", "ndps.realization",
+ FT_UINT32, BASE_HEX, VALS(ndps_realization_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_xdimension_n64,
- { "X Dimension", "ndps.xdimension_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "X Dimension", HFILL }},
+ { "X Dimension", "ndps.xdimension_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ydimension_n64,
- { "Y Dimension", "ndps.xdimension_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Y Dimension", HFILL }},
+ { "Y Dimension", "ndps.xdimension_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_dim_value,
- { "Dimension Value Type", "ndps.ndps_dim_value",
- FT_UINT32, BASE_HEX, VALS(ndps_dim_value_enum), 0x0,
- "Dimension Value Type", HFILL }},
+ { "Dimension Value Type", "ndps.dim_value",
+ FT_UINT32, BASE_HEX, VALS(ndps_dim_value_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_dim_flag,
- { "Dimension Flag", "ndps.ndps_dim_falg",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Dimension Flag", HFILL }},
+ { "Dimension Flag", "ndps.dim_falg",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_xydim_value,
- { "XY Dimension Value Type", "ndps.ndps_xydim_value",
- FT_UINT32, BASE_HEX, VALS(ndps_xydim_value_enum), 0x0,
- "XY Dimension Value Type", HFILL }},
+ { "XY Dimension Value Type", "ndps.xydim_value",
+ FT_UINT32, BASE_HEX, VALS(ndps_xydim_value_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_location_value,
- { "Location Value Type", "ndps.ndps_location_value",
- FT_UINT32, BASE_HEX, VALS(ndps_location_value_enum), 0x0,
- "Location Value Type", HFILL }},
+ { "Location Value Type", "ndps.location_value",
+ FT_UINT32, BASE_HEX, VALS(ndps_location_value_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_xmin_n64,
- { "Minimum X Dimension", "ndps.xmin_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Minimum X Dimension", HFILL }},
+ { "Minimum X Dimension", "ndps.xmin_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_xmax_n64,
- { "Maximum X Dimension", "ndps.xmax_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Maximum X Dimension", HFILL }},
+ { "Maximum X Dimension", "ndps.xmax_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ymin_n64,
- { "Minimum Y Dimension", "ndps.ymin_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Minimum Y Dimension", HFILL }},
+ { "Minimum Y Dimension", "ndps.ymin_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ymax_n64,
- { "Maximum Y Dimension", "ndps.ymax_n64",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Maximum Y Dimension", HFILL }},
+ { "Maximum Y Dimension", "ndps.ymax_n64",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_edge_value,
- { "Edge Value", "ndps.ndps_edge_value",
- FT_UINT32, BASE_HEX, VALS(ndps_edge_value_enum), 0x0,
- "Edge Value", HFILL }},
+ { "Edge Value", "ndps.edge_value",
+ FT_UINT32, BASE_HEX, VALS(ndps_edge_value_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_cardinal_or_oid,
- { "Cardinal or OID", "ndps.ndps_car_or_oid",
- FT_UINT32, BASE_HEX, VALS(ndps_card_or_oid_enum), 0x0,
- "Cardinal or OID", HFILL }},
+ { "Cardinal or OID", "ndps.car_or_oid",
+ FT_UINT32, BASE_HEX, VALS(ndps_card_or_oid_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_cardinal_name_or_oid,
- { "Cardinal Name or OID", "ndps.ndps_car_name_or_oid",
- FT_UINT32, BASE_HEX, VALS(ndps_card_name_or_oid_enum), 0x0,
- "Cardinal Name or OID", HFILL }},
+ { "Cardinal Name or OID", "ndps.car_name_or_oid",
+ FT_UINT32, BASE_HEX, VALS(ndps_card_name_or_oid_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_integer_or_oid,
- { "Integer or OID", "ndps.ndps_integer_or_oid",
- FT_UINT32, BASE_HEX, VALS(ndps_integer_or_oid_enum), 0x0,
- "Integer or OID", HFILL }},
+ { "Integer or OID", "ndps.integer_or_oid",
+ FT_UINT32, BASE_HEX, VALS(ndps_integer_or_oid_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_profile_id,
- { "Profile ID", "ndps.ndps_profile_id",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Profile ID", HFILL }},
+ { "Profile ID", "ndps.profile_id",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_persistence,
- { "Persistence", "ndps.ndps_persistence",
- FT_UINT32, BASE_HEX, VALS(ndps_persistence_enum), 0x0,
- "Persistence", HFILL }},
+ { "Persistence", "ndps.persistence",
+ FT_UINT32, BASE_HEX, VALS(ndps_persistence_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_language_count,
- { "Number of Languages", "ndps.ndps_language_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Languages", HFILL }},
+ { "Number of Languages", "ndps.language_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_language_id,
- { "Language ID", "ndps.ndps_lang_id",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Language ID", HFILL }},
+ { "Language ID", "ndps.lang_id",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_address_type,
- { "Address Type", "ndps.ndps_address_type",
- FT_UINT32, BASE_HEX, VALS(ndps_address_type_enum), 0x0,
- "Address Type", HFILL }},
+ { "Address Type", "ndps.address_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_address_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_address,
- { "Address", "ndps.ndps_address",
- FT_UINT32, BASE_HEX, VALS(ndps_address_enum), 0x0,
- "Address", HFILL }},
+ { "Address", "ndps.address",
+ FT_UINT32, BASE_HEX, VALS(ndps_address_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_add_bytes,
- { "Address Bytes", "ndps.add_bytes",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Address Bytes", HFILL }},
+ { "Address Bytes", "ndps.add_bytes",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_event_type,
- { "Event Type", "ndps.ndps_event_type",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Event Type", HFILL }},
+ { "Event Type", "ndps.event_type",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_event_object_identifier,
- { "Event Object Type", "ndps.ndps_event_object_identifier",
- FT_UINT32, BASE_HEX, VALS(ndps_event_object_enum), 0x0,
- "Event Object Type", HFILL }},
+ { "Event Object Type", "ndps.event_object_identifier",
+ FT_UINT32, BASE_HEX, VALS(ndps_event_object_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_octet_string,
- { "Octet String", "ndps.octet_string",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Octet String", HFILL }},
+ { "Octet String", "ndps.octet_string",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_scope,
- { "Scope", "ndps.scope",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Scope", HFILL }},
+ { "Scope", "ndps.scope",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_address_len,
- { "Address Length", "ndps.addr_len",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Address Length", HFILL }},
+ { "Address Length", "ndps.addr_len",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_net,
- { "IPX Network", "ndps.net",
- FT_IPXNET, BASE_NONE, NULL, 0x0,
- "Scope", HFILL }},
+ { "IPX Network", "ndps.net",
+ FT_IPXNET, BASE_NONE, NULL, 0x0,
+ "Scope", HFILL }},
{ &hf_ndps_node,
- { "Node", "ndps.node",
- FT_ETHER, BASE_NONE, NULL, 0x0,
- "Node", HFILL }},
+ { "Node", "ndps.node",
+ FT_ETHER, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_socket,
- { "IPX Socket", "ndps.socket",
- FT_UINT16, BASE_HEX, NULL, 0x0,
- "IPX Socket", HFILL }},
+ { "IPX Socket", "ndps.socket",
+ FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_port,
- { "IP Port", "ndps.port",
- FT_UINT16, BASE_DEC, NULL, 0x0,
- "IP Port", HFILL }},
+ { "IP Port", "ndps.port",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ip,
- { "IP Address", "ndps.ip",
- FT_IPv4, BASE_DEC, NULL, 0x0,
- "IP Address", HFILL }},
+ { "IP Address", "ndps.ip",
+ FT_IPv4, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_server_type,
- { "NDPS Server Type", "ndps.ndps_server_type",
- FT_UINT32, BASE_HEX, VALS(ndps_server_type_enum), 0x0,
- "NDPS Server Type", HFILL }},
+ { "NDPS Server Type", "ndps.server_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_server_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_services,
- { "Number of Services", "ndps.ndps_num_services",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Services", HFILL }},
+ { "Number of Services", "ndps.num_services",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_service_type,
- { "NDPS Service Type", "ndps.ndps_service_type",
- FT_UINT32, BASE_HEX, VALS(ndps_service_type_enum), 0x0,
- "NDPS Service Type", HFILL }},
+ { "NDPS Service Type", "ndps.service_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_service_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_service_enabled,
- { "Service Enabled?", "ndps.ndps_service_enabled",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Service Enabled?", HFILL }},
+ { "Service Enabled?", "ndps.service_enabled",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_method_name,
- { "Method Name", "ndps.method_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Method Name", HFILL }},
+ { "Method Name", "ndps.method_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_method_ver,
- { "Method Version", "ndps.method_ver",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Method Version", HFILL }},
+ { "Method Version", "ndps.method_ver",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_file_name,
- { "File Name", "ndps.file_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "File Name", HFILL }},
+ { "File Name", "ndps.file_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_admin_submit,
- { "Admin Submit Flag?", "ndps.admin_submit_flag",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Admin Submit Flag?", HFILL }},
+ { "Admin Submit Flag?", "ndps.admin_submit_flag",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_oid,
- { "Object ID", "ndps.oid",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Object ID", HFILL }},
+ { "Object ID", "ndps.oid",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_object_op,
- { "Operation", "ndps.ndps_object_op",
- FT_UINT32, BASE_HEX, VALS(ndps_object_op_enum), 0x0,
- "Operation", HFILL }},
+ { "Operation", "ndps.object_op",
+ FT_UINT32, BASE_HEX, VALS(ndps_object_op_enum), 0x0,
+ NULL, HFILL }},
{ &hf_answer_time,
- { "Answer Time", "ndps.answer_time",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Answer Time", HFILL }},
+ { "Answer Time", "ndps.answer_time",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_oid_asn1_type,
- { "ASN.1 Type", "ndps.asn1_type",
- FT_UINT16, BASE_DEC, NULL, 0x0,
- "ASN.1 Type", HFILL }},
+ { "ASN.1 Type", "ndps.asn1_type",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_item_ptr,
- { "Item Pointer", "ndps.item_ptr",
- FT_BYTES, BASE_DEC, NULL, 0x0,
- "Item Pointer", HFILL }},
+ { "Item Pointer", "ndps.item_ptr",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_len,
- { "Length", "ndps.ndps_len",
- FT_UINT16, BASE_DEC, NULL, 0x0,
- "Length", HFILL }},
+ { "Length", "ndps.len",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
- { &hf_limit_enc,
- { "Limit Encountered", "ndps.ndps_limit_enc",
- FT_UINT32, BASE_HEX, VALS(ndps_limit_enc_enum), 0x0,
- "Limit Encountered", HFILL }},
+ { &hf_ndps_limit_enc,
+ { "Limit Encountered", "ndps.limit_enc",
+ FT_UINT32, BASE_HEX, VALS(ndps_limit_enc_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_delivery_add_count,
- { "Number of Delivery Addresses", "ndps.delivery_add_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Delivery Addresses", HFILL }},
+ { "Number of Delivery Addresses", "ndps.delivery_add_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_delivery_add_type,
- { "Delivery Address Type", "ndps.ndps_delivery_add_type",
- FT_UINT32, BASE_HEX, VALS(ndps_delivery_add_enum), 0x0,
- "Delivery Address Type", HFILL }},
+ { "Delivery Address Type", "ndps.delivery_add_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_delivery_add_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_criterion_type,
- { "Criterion Type", "ndps.ndps_criterion_type",
- FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
- "Criterion Type", HFILL }},
+ { "Criterion Type", "ndps.criterion_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_ignored_attributes,
- { "Number of Ignored Attributes", "ndps.num_ignored_attributes",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Ignored Attributes", HFILL }},
+ { "Number of Ignored Attributes", "ndps.num_ignored_attributes",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ignored_type,
- { "Ignored Type", "ndps.ndps_ignored_type",
- FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
- "Ignored Type", HFILL }},
+ { "Ignored Type", "ndps.ignored_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_resources,
- { "Number of Resources", "ndps.ndps_num_resources",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Resources", HFILL }},
+ { "Number of Resources", "ndps.num_resources",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_resource_type,
- { "Resource Type", "ndps.ndps_resource_type",
- FT_UINT32, BASE_HEX, VALS(ndps_resource_enum), 0x0,
- "Resource Type", HFILL }},
+ { "Resource Type", "ndps.resource_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_resource_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_identifier_type,
- { "Identifier Type", "ndps.ndps_identifier_type",
- FT_UINT32, BASE_HEX, VALS(ndps_identifier_enum), 0x0,
- "Identifier Type", HFILL }},
+ { "Identifier Type", "ndps.identifier_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_identifier_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_page_flag,
- { "Page Flag", "ndps.ndps_page_flag",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Page Flag", HFILL }},
+ { "Page Flag", "ndps.page_flag",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_media_type,
- { "Media Type", "ndps.ndps_media_type",
- FT_UINT32, BASE_HEX, VALS(ndps_media_enum), 0x0,
- "Media Type", HFILL }},
+ { "Media Type", "ndps.media_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_media_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_page_size,
- { "Page Size", "ndps.ndps_page_size",
- FT_UINT32, BASE_HEX, VALS(ndps_page_size_enum), 0x0,
- "Page Size", HFILL }},
+ { "Page Size", "ndps.page_size",
+ FT_UINT32, BASE_HEX, VALS(ndps_page_size_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_direction,
- { "Direction", "ndps.ndps_direction",
- FT_UINT32, BASE_HEX, VALS(ndps_pres_direction_enum), 0x0,
- "Direction", HFILL }},
+ { "Direction", "ndps.direction",
+ FT_UINT32, BASE_HEX, VALS(ndps_pres_direction_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_page_order,
- { "Page Order", "ndps.ndps_page_order",
- FT_UINT32, BASE_HEX, VALS(ndps_page_order_enum), 0x0,
- "Page Order", HFILL }},
+ { "Page Order", "ndps.page_order",
+ FT_UINT32, BASE_HEX, VALS(ndps_page_order_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_medium_size,
- { "Medium Size", "ndps.ndps_medium_size",
- FT_UINT32, BASE_HEX, VALS(ndps_medium_size_enum), 0x0,
- "Medium Size", HFILL }},
+ { "Medium Size", "ndps.medium_size",
+ FT_UINT32, BASE_HEX, VALS(ndps_medium_size_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_long_edge_feeds,
- { "Long Edge Feeds?", "ndps.ndps_long_edge_feeds",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Long Edge Feeds?", HFILL }},
+ { "Long Edge Feeds?", "ndps.long_edge_feeds",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_inc_across_feed,
- { "Increment Across Feed", "ndps.inc_across_feed",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Increment Across Feed", HFILL }},
+ { "Increment Across Feed", "ndps.inc_across_feed",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_size_inc_in_feed,
- { "Size Increment in Feed", "ndps.size_inc_in_feed",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Size Increment in Feed", HFILL }},
+ { "Size Increment in Feed", "ndps.size_inc_in_feed",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_page_orientation,
- { "Page Orientation", "ndps.ndps_page_orientation",
- FT_UINT32, BASE_HEX, VALS(ndps_page_orientation_enum), 0x0,
- "Page Orientation", HFILL }},
+ { "Page Orientation", "ndps.page_orientation",
+ FT_UINT32, BASE_HEX, VALS(ndps_page_orientation_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_numbers_up,
- { "Numbers Up", "ndps.ndps_numbers_up",
- FT_UINT32, BASE_HEX, VALS(ndps_numbers_up_enum), 0x0,
- "Numbers Up", HFILL }},
+ { "Numbers Up", "ndps.numbers_up",
+ FT_UINT32, BASE_HEX, VALS(ndps_numbers_up_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_xdimension,
- { "X Dimension", "ndps.ndps_xdimension",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "X Dimension", HFILL }},
+ { "X Dimension", "ndps.xdimension",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ydimension,
- { "Y Dimension", "ndps.ndps_ydimension",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Y Dimension", HFILL }},
+ { "Y Dimension", "ndps.ydimension",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_state_severity,
- { "State Severity", "ndps.ndps_state_severity",
- FT_UINT32, BASE_HEX, VALS(ndps_state_severity_enum), 0x0,
- "State Severity", HFILL }},
+ { "State Severity", "ndps.state_severity",
+ FT_UINT32, BASE_HEX, VALS(ndps_state_severity_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_training,
- { "Training", "ndps.ndps_training",
- FT_UINT32, BASE_HEX, VALS(ndps_training_enum), 0x0,
- "Training", HFILL }},
+ { "Training", "ndps.training",
+ FT_UINT32, BASE_HEX, VALS(ndps_training_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_colorant_set,
- { "Colorant Set", "ndps.ndps_colorant_set",
- FT_UINT32, BASE_HEX, VALS(ndps_colorant_set_enum), 0x0,
- "Colorant Set", HFILL }},
+ { "Colorant Set", "ndps.colorant_set",
+ FT_UINT32, BASE_HEX, VALS(ndps_colorant_set_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_card_enum_time,
- { "Cardinal, Enum, or Time", "ndps.ndps_card_enum_time",
- FT_UINT32, BASE_HEX, VALS(ndps_card_enum_time_enum), 0x0,
- "Cardinal, Enum, or Time", HFILL }},
+ { "Cardinal, Enum, or Time", "ndps.card_enum_time",
+ FT_UINT32, BASE_HEX, VALS(ndps_card_enum_time_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_attrs_arg,
- { "List Attribute Operation", "ndps.ndps_attrs_arg",
- FT_UINT32, BASE_HEX, VALS(ndps_attrs_arg_enum), 0x0,
- "List Attribute Operation", HFILL }},
+ { "List Attribute Operation", "ndps.attrs_arg",
+ FT_UINT32, BASE_HEX, VALS(ndps_attrs_arg_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_context_len,
- { "Context Length", "ndps.context_len",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Context Length", HFILL }},
+ { "Context Length", "ndps.context_len",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_context,
- { "Context", "ndps.context",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Context", HFILL }},
+ { "Context", "ndps.context",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_filter,
- { "Filter Type", "ndps.ndps_filter",
- FT_UINT32, BASE_HEX, VALS(ndps_filter_enum), 0x0,
- "Filter Type", HFILL }},
+ { "Filter Type", "ndps.filter",
+ FT_UINT32, BASE_HEX, VALS(ndps_filter_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_item_filter,
- { "Filter Item Operation", "ndps.ndps_filter_item",
- FT_UINT32, BASE_HEX, VALS(ndps_filter_item_enum), 0x0,
- "Filter Item Operation", HFILL }},
+ { "Filter Item Operation", "ndps.filter_item",
+ FT_UINT32, BASE_HEX, VALS(ndps_filter_item_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_substring_match,
- { "Substring Match", "ndps.ndps_substring_match",
- FT_UINT32, BASE_HEX, VALS(ndps_match_criteria_enum), 0x0,
- "Substring Match", HFILL }},
+ { "Substring Match", "ndps.substring_match",
+ FT_UINT32, BASE_HEX, VALS(ndps_match_criteria_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_time_limit,
- { "Time Limit", "ndps.ndps_time_limit",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Time Limit", HFILL }},
+ { "Time Limit", "ndps.time_limit",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_count_limit,
- { "Count Limit", "ndps.ndps_count_limit",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Count Limit", HFILL }},
+ { "Count Limit", "ndps.count_limit",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_operator,
- { "Operator Type", "ndps.ndps_operator",
- FT_UINT32, BASE_DEC, VALS(ndps_operator_enum), 0x0,
- "Operator Type", HFILL }},
+ { "Operator Type", "ndps.operator",
+ FT_UINT32, BASE_DEC, VALS(ndps_operator_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_password,
- { "Password", "ndps.password",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Password", HFILL }},
+ { "Password", "ndps.password",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_retrieve_restrictions,
- { "Retrieve Restrictions", "ndps.ndps_ret_restrict",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Retrieve Restrictions", HFILL }},
+ { "Retrieve Restrictions", "ndps.ret_restrict",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_bind_security_option_count,
- { "Number of Bind Security Options", "ndps.ndps_bind_security_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Bind Security Options", HFILL }},
+ { "Number of Bind Security Options", "ndps.bind_security_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_bind_security,
- { "Bind Security Options", "ndps.ndps_bind_security",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Bind Security Options", HFILL }},
+ { "Bind Security Options", "ndps.bind_security",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_max_items,
- { "Maximum Items in List", "ndps.ndps_max_items",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Maximum Items in List", HFILL }},
+ { "Maximum Items in List", "ndps.max_items",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_status_flags,
- { "Status Flag", "ndps.ndps_status_flags",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Status Flag", HFILL }},
+ { "Status Flag", "ndps.status_flags",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_resource_list_type,
- { "Resource Type", "ndps.ndps_resource_type",
- FT_UINT32, BASE_DEC, VALS(ndps_resource_type_enum), 0x0,
- "Resource Type", HFILL }},
+ { "Resource Type", "ndps.resource_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_resource_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_os_count,
- { "Number of OSes", "ndps.os_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of OSes", HFILL }},
+ { "Number of OSes", "ndps.os_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_os_type,
- { "OS Type", "ndps.os_type",
- FT_UINT32, BASE_DEC, VALS(ndps_os_type_enum), 0x0,
- "OS Type", HFILL }},
+ { "OS Type", "ndps.os_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_os_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_printer_type_count,
- { "Number of Printer Types", "ndps.printer_type_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Printer Types", HFILL }},
+ { "Number of Printer Types", "ndps.printer_type_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_printer_type,
- { "Printer Type", "ndps.prn_type",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer Type", HFILL }},
+ { "Printer Type", "ndps.prn_type",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_printer_manuf,
- { "Printer Manufacturer", "ndps.prn_manuf",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer Manufacturer", HFILL }},
+ { "Printer Manufacturer", "ndps.prn_manuf",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_inf_file_name,
- { "INF File Name", "ndps.inf_file_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "INF File Name", HFILL }},
+ { "INF File Name", "ndps.inf_file_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_vendor_dir,
- { "Vendor Directory", "ndps.vendor_dir",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Vendor Directory", HFILL }},
+ { "Vendor Directory", "ndps.vendor_dir",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_banner_type,
- { "Banner Type", "ndps.banner_type",
- FT_UINT32, BASE_DEC, VALS(ndps_banner_type_enum), 0x0,
- "Banner Type", HFILL }},
+ { "Banner Type", "ndps.banner_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_banner_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_font_type,
- { "Font Type", "ndps.font_type",
- FT_UINT32, BASE_DEC, VALS(ndps_font_type_enum), 0x0,
- "Font Type", HFILL }},
+ { "Font Type", "ndps.font_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_font_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_printer_id,
- { "Printer ID", "ndps.printer_id",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Printer ID", HFILL }},
+ { "Printer ID", "ndps.printer_id",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_font_name,
- { "Font Name", "ndps.font_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Font Name", HFILL }},
+ { "Font Name", "ndps.font_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_return_code,
- { "Return Code", "ndps.ret_code",
- FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
- "Return Code", HFILL }},
+ { "Return Code", "ndps.ret_code",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_banner_count,
- { "Number of Banners", "ndps.banner_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Banners", HFILL }},
+ { "Number of Banners", "ndps.banner_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_banner_name,
- { "Banner Name", "ndps.banner_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Banner Name", HFILL }},
+ { "Banner Name", "ndps.banner_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_font_type_count,
- { "Number of Font Types", "ndps.font_type_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Font Types", HFILL }},
+ { "Number of Font Types", "ndps.font_type_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_font_type_name,
- { "Font Type Name", "ndps.font_type_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Font Type Name", HFILL }},
+ { "Font Type Name", "ndps.font_type_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_font_file_count,
- { "Number of Font Files", "ndps.font_file_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Font Files", HFILL }},
+ { "Number of Font Files", "ndps.font_file_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_font_file_name,
- { "Font File Name", "ndps.font_file_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Font File Name", HFILL }},
+ { "Font File Name", "ndps.font_file_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_printer_def_count,
- { "Number of Printer Definitions", "ndps.printer_def_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Printer Definitions", HFILL }},
+ { "Number of Printer Definitions", "ndps.printer_def_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_prn_file_name,
- { "Printer File Name", "ndps.print_file_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer File Name", HFILL }},
+ { "Printer File Name", "ndps.print_file_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_prn_dir_name,
- { "Printer Directory Name", "ndps.print_dir_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer Directory Name", HFILL }},
+ { "Printer Directory Name", "ndps.print_dir_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_def_file_name,
- { "Printer Definition Name", "ndps.print_def_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Printer Definition Name", HFILL }},
+ { "Printer Definition Name", "ndps.print_def_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_win31_keys,
- { "Number of Windows 3.1 Keys", "ndps.num_win31_keys",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Windows 3.1 Keys", HFILL }},
+ { "Number of Windows 3.1 Keys", "ndps.num_win31_keys",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_win95_keys,
- { "Number of Windows 95 Keys", "ndps.num_win95_keys",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Windows 95 Keys", HFILL }},
+ { "Number of Windows 95 Keys", "ndps.num_win95_keys",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_windows_keys,
- { "Number of Windows Keys", "ndps.num_windows_keys",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Windows Keys", HFILL }},
+ { "Number of Windows Keys", "ndps.num_windows_keys",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_windows_key,
- { "Windows Key", "ndps.windows_key",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Windows Key", HFILL }},
+ { "Windows Key", "ndps.windows_key",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_archive_type,
- { "Archive Type", "ndps.archive_type",
- FT_UINT32, BASE_DEC, VALS(ndps_archive_enum), 0x0,
- "Archive Type", HFILL }},
+ { "Archive Type", "ndps.archive_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_archive_enum), 0x0,
+ NULL, HFILL }},
{ &hf_archive_file_size,
- { "Archive File Size", "ndps.archive_size",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Archive File Size", HFILL }},
+ { "Archive File Size", "ndps.archive_size",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_segment_overlap,
- { "Segment overlap", "ndps.segment.overlap", FT_BOOLEAN, BASE_NONE,
- NULL, 0x0, "Segment overlaps with other segments", HFILL }},
+ { "Segment overlap", "ndps.segment.overlap", FT_BOOLEAN, BASE_NONE,
+ NULL, 0x0, "Segment overlaps with other segments", HFILL }},
{ &hf_ndps_segment_overlap_conflict,
{ "Conflicting data in segment overlap", "ndps.segment.overlap.conflict",
- FT_BOOLEAN, BASE_NONE,
- NULL, 0x0, "Overlapping segments contained conflicting data", HFILL }},
+ FT_BOOLEAN, BASE_NONE,
+ NULL, 0x0, "Overlapping segments contained conflicting data", HFILL }},
{ &hf_ndps_segment_multiple_tails,
{ "Multiple tail segments found", "ndps.segment.multipletails",
- FT_BOOLEAN, BASE_NONE,
- NULL, 0x0, "Several tails were found when desegmenting the packet", HFILL }},
+ FT_BOOLEAN, BASE_NONE,
+ NULL, 0x0, "Several tails were found when desegmenting the packet", HFILL }},
{ &hf_ndps_segment_too_long_segment,
- { "Segment too long", "ndps.segment.toolongsegment", FT_BOOLEAN, BASE_NONE,
- NULL, 0x0, "Segment contained data past end of packet", HFILL }},
+ { "Segment too long", "ndps.segment.toolongsegment", FT_BOOLEAN, BASE_NONE,
+ NULL, 0x0, "Segment contained data past end of packet", HFILL }},
{ &hf_ndps_segment_error,
- {"Desegmentation error", "ndps.segment.error", FT_FRAMENUM, BASE_NONE,
- NULL, 0x0, "Desegmentation error due to illegal segments", HFILL }},
+ {"Desegmentation error", "ndps.segment.error", FT_FRAMENUM, BASE_NONE,
+ NULL, 0x0, "Desegmentation error due to illegal segments", HFILL }},
+
+ { &hf_ndps_segment_count,
+ {"Segment count", "ndps.segment.count", FT_UINT32, BASE_DEC,
+ NULL, 0x0, NULL, HFILL }},
+
+ { &hf_ndps_reassembled_length,
+ {"Reassembled NDPS length", "ndps.reassembled.length", FT_UINT32, BASE_DEC,
+ NULL, 0x0, "The total length of the reassembled payload", HFILL }},
{ &hf_ndps_segment,
- { "NDPS Fragment", "ndps.fragment", FT_FRAMENUM, BASE_NONE,
- NULL, 0x0, "NDPS Fragment", HFILL }},
+ { "NDPS Fragment", "ndps.fragment", FT_FRAMENUM, BASE_NONE,
+ NULL, 0x0, NULL, HFILL }},
{ &hf_ndps_segments,
- { "NDPS Fragments", "ndps.fragments", FT_NONE, BASE_NONE,
- NULL, 0x0, "NDPS Fragments", HFILL }},
+ { "NDPS Fragments", "ndps.fragments", FT_NONE, BASE_NONE,
+ NULL, 0x0, NULL, HFILL }},
{ &hf_ndps_data,
- { "[Data]", "ndps.data", FT_NONE, BASE_NONE,
- NULL, 0x0, "[Data]", HFILL }},
+ { "[Data]", "ndps.data", FT_NONE, BASE_NONE,
+ NULL, 0x0, NULL, HFILL }},
{ &hf_get_status_flag,
- { "Get Status Flag", "ndps.get_status_flags",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Get Status Flag", HFILL }},
+ { "Get Status Flag", "ndps.get_status_flags",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_res_type,
- { "Resource Type", "ndps.res_type",
- FT_UINT32, BASE_DEC, VALS(ndps_res_type_enum), 0x0,
- "Resource Type", HFILL }},
+ { "Resource Type", "ndps.res_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_res_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_file_timestamp,
- { "File Time Stamp", "ndps.file_time_stamp",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "File Time Stamp", HFILL }},
+ { "File Time Stamp", "ndps.file_time_stamp",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_print_arg,
- { "Print Type", "ndps.print_arg",
- FT_UINT32, BASE_DEC, VALS(ndps_print_arg_enum), 0x0,
- "Print Type", HFILL }},
+ { "Print Type", "ndps.print_arg",
+ FT_UINT32, BASE_DEC, VALS(ndps_print_arg_enum), 0x0,
+ NULL, HFILL }},
{ &hf_sub_complete,
- { "Submission Complete?", "ndps.sub_complete", FT_BOOLEAN, BASE_NONE,
- NULL, 0x0, "Submission Complete?", HFILL }},
+ { "Submission Complete?", "ndps.sub_complete", FT_BOOLEAN, BASE_NONE,
+ NULL, 0x0, NULL, HFILL }},
{ &hf_doc_content,
- { "Document Content", "ndps.doc_content",
- FT_UINT32, BASE_DEC, VALS(ndps_doc_content_enum), 0x0,
- "Document Content", HFILL }},
+ { "Document Content", "ndps.doc_content",
+ FT_UINT32, BASE_DEC, VALS(ndps_doc_content_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_doc_name,
- { "Document Name", "ndps.doc_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Document Name", HFILL }},
+ { "Document Name", "ndps.doc_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_local_id,
- { "Local ID", "ndps.local_id",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Local ID", HFILL }},
+ { "Local ID", "ndps.local_id",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_included_doc_len,
- { "Included Document Length", "ndps.included_doc_len",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Included Document Length", HFILL }},
+ { "Included Document Length", "ndps.included_doc_len",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_included_doc,
- { "Included Document", "ndps.included_doc",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Included Document", HFILL }},
+ { "Included Document", "ndps.included_doc",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ref_name,
- { "Referenced Document Name", "ndps.ref_doc_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Referenced Document Name", HFILL }},
+ { "Referenced Document Name", "ndps.ref_doc_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_interrupt_job_type,
- { "Interrupt Job Identifier", "ndps.interrupt_job_type",
- FT_UINT32, BASE_DEC, VALS(ndps_interrupt_job_enum), 0x0,
- "Interrupt Job Identifier", HFILL }},
+ { "Interrupt Job Identifier", "ndps.interrupt_job_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_interrupt_job_enum), 0x0,
+ NULL, HFILL }},
{ &hf_pause_job_type,
- { "Pause Job Identifier", "ndps.pause_job_type",
- FT_UINT32, BASE_DEC, VALS(ndps_pause_job_enum), 0x0,
- "Pause Job Identifier", HFILL }},
+ { "Pause Job Identifier", "ndps.pause_job_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_pause_job_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_force,
- { "Force?", "ndps.ndps_force",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Force?", HFILL }},
+ { "Force?", "ndps.force",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_resubmit_op_type,
- { "Resubmit Operation Type", "ndps.resubmit_op_type",
- FT_UINT32, BASE_DEC, VALS(ndps_resubmit_op_enum), 0x0,
- "Resubmit Operation Type", HFILL }},
+ { "Resubmit Operation Type", "ndps.resubmit_op_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_resubmit_op_enum), 0x0,
+ NULL, HFILL }},
{ &hf_shutdown_type,
- { "Shutdown Type", "ndps.shutdown_type",
- FT_UINT32, BASE_DEC, VALS(ndps_shutdown_enum), 0x0,
- "Shutdown Type", HFILL }},
+ { "Shutdown Type", "ndps.shutdown_type",
+ FT_UINT32, BASE_DEC, VALS(ndps_shutdown_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_supplier_flag,
- { "Supplier Data?", "ndps.supplier_flag",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Supplier Data?", HFILL }},
+ { "Supplier Data?", "ndps.supplier_flag",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_language_flag,
- { "Language Data?", "ndps.language_flag",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Language Data?", HFILL }},
+ { "Language Data?", "ndps.language_flag",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_method_flag,
- { "Method Data?", "ndps.method_flag",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Method Data?", HFILL }},
+ { "Method Data?", "ndps.method_flag",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_delivery_address_flag,
- { "Delivery Address Data?", "ndps.delivery_flag",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Delivery Address Data?", HFILL }},
+ { "Delivery Address Data?", "ndps.delivery_flag",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_list_profiles_type,
- { "List Profiles Type", "ndps.ndps_list_profiles_type",
- FT_UINT32, BASE_HEX, VALS(ndps_attrs_arg_enum), 0x0,
- "List Profiles Type", HFILL }},
+ { "List Profiles Type", "ndps.list_profiles_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_attrs_arg_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_list_profiles_choice_type,
- { "List Profiles Choice Type", "ndps.ndps_list_profiles_choice_type",
- FT_UINT32, BASE_HEX, VALS(ndps_list_profiles_choice_enum), 0x0,
- "List Profiles Choice Type", HFILL }},
+ { "List Profiles Choice Type", "ndps.list_profiles_choice_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_list_profiles_choice_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_list_profiles_result_type,
- { "List Profiles Result Type", "ndps.ndps_list_profiles_result_type",
- FT_UINT32, BASE_HEX, VALS(ndps_list_profiles_result_enum), 0x0,
- "List Profiles Result Type", HFILL }},
+ { "List Profiles Result Type", "ndps.list_profiles_result_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_list_profiles_result_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_integer_type_flag,
- { "Integer Type Flag", "ndps.ndps_integer_type_flag",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Integer Type Flag", HFILL }},
+ { "Integer Type Flag", "ndps.integer_type_flag",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_integer_type_value,
- { "Integer Type Value", "ndps.ndps_integer_type_value",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Integer Type Value", HFILL }},
+ { "Integer Type Value", "ndps.integer_type_value",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_continuation_option,
- { "Continuation Option", "ndps.ndps_continuation_option",
- FT_BYTES, BASE_HEX, NULL, 0x0,
- "Continuation Option", HFILL }},
+ { "Continuation Option", "ndps.continuation_option",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_ds_info_type,
- { "DS Info Type", "ndps.ndps_ds_info_type",
- FT_UINT32, BASE_HEX, VALS(ndps_ds_info_enum), 0x0,
- "DS Info Type", HFILL }},
+ { "DS Info Type", "ndps.ds_info_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_ds_info_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_guid,
- { "GUID", "ndps.guid",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "GUID", HFILL }},
+ { "GUID", "ndps.guid",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_list_services_type,
- { "Services Type", "ndps.ndps_list_services_type",
- FT_UINT32, BASE_HEX, VALS(ndps_list_services_enum), 0x0,
- "Services Type", HFILL }},
+ { "Services Type", "ndps.list_services_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_list_services_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_item_bytes,
- { "Item Ptr", "ndps.item_bytes",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Item Ptr", HFILL }},
+ { "Item Ptr", "ndps.item_bytes",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_certified,
- { "Certified", "ndps.certified",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Certified", HFILL }},
+ { "Certified", "ndps.certified",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_attribute_set,
- { "Attribute Set", "ndps.attribute_set",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Attribute Set", HFILL }},
+ { "Attribute Set", "ndps.attribute_set",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_data_item_type,
- { "Item Type", "ndps.ndps_data_item_type",
- FT_UINT32, BASE_HEX, VALS(ndps_data_item_enum), 0x0,
- "Item Type", HFILL }},
+ { "Item Type", "ndps.data_item_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_data_item_enum), 0x0,
+ NULL, HFILL }},
{ &hf_info_int,
- { "Integer Value", "ndps.info_int",
- FT_UINT8, BASE_HEX, NULL, 0x0,
- "Integer Value", HFILL }},
+ { "Integer Value", "ndps.info_int",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_info_int16,
- { "16 Bit Integer Value", "ndps.info_int16",
- FT_UINT16, BASE_HEX, NULL, 0x0,
- "16 Bit Integer Value", HFILL }},
+ { "16 Bit Integer Value", "ndps.info_int16",
+ FT_UINT16, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_info_int32,
- { "32 Bit Integer Value", "ndps.info_int32",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "32 Bit Integer Value", HFILL }},
+ { "32 Bit Integer Value", "ndps.info_int32",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_info_boolean,
- { "Boolean Value", "ndps.info_boolean",
- FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "Boolean Value", HFILL }},
+ { "Boolean Value", "ndps.info_boolean",
+ FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_info_string,
- { "String Value", "ndps.info_string",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "String Value", HFILL }},
+ { "String Value", "ndps.info_string",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_info_bytes,
- { "Byte Value", "ndps.info_bytes",
- FT_BYTES, BASE_NONE, NULL, 0x0,
- "Byte Value", HFILL }},
+ { "Byte Value", "ndps.info_bytes",
+ FT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_list_local_servers_type,
- { "Server Type", "ndps.ndps_list_local_server_type",
- FT_UINT32, BASE_HEX, VALS(ndps_list_local_servers_enum), 0x0,
- "Server Type", HFILL }},
+ { "Server Type", "ndps.list_local_server_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_list_local_servers_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_registry_name,
- { "Registry Name", "ndps.registry_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Registry Name", HFILL }},
+ { "Registry Name", "ndps.registry_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_client_server_type,
- { "Client/Server Type", "ndps.ndps_client_server_type",
- FT_UINT32, BASE_HEX, VALS(ndps_client_server_enum), 0x0,
- "Client/Server Type", HFILL }},
+ { "Client/Server Type", "ndps.client_server_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_client_server_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_session_type,
- { "Session Type", "ndps.ndps_session_type",
- FT_UINT32, BASE_HEX, VALS(ndps_session_type_enum), 0x0,
- "Session Type", HFILL }},
+ { "Session Type", "ndps.session_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_session_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_time,
- { "Time", "ndps.time",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Time", HFILL }},
+ { "Time", "ndps.time",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_supplier_name,
- { "Supplier Name", "ndps.supplier_name",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Supplier Name", HFILL }},
+ { "Supplier Name", "ndps.supplier_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_message,
- { "Message", "ndps.message",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Message", HFILL }},
+ { "Message", "ndps.message",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_delivery_method_count,
- { "Number of Delivery Methods", "ndps.delivery_method_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Delivery Methods", HFILL }},
+ { "Number of Delivery Methods", "ndps.delivery_method_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_delivery_method_type,
- { "Delivery Method Type", "ndps.delivery_method_type",
- FT_UINT32, BASE_HEX, VALS(ndps_delivery_method_enum), 0x0,
- "Delivery Method Type", HFILL }},
+ { "Delivery Method Type", "ndps.delivery_method_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_delivery_method_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_get_session_type,
- { "Session Type", "ndps.ndps_get_session_type",
- FT_UINT32, BASE_HEX, VALS(ndps_get_session_type_enum), 0x0,
- "Session Type", HFILL }},
+ { "Session Type", "ndps.get_session_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_get_session_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_packet_count,
- { "Packet Count", "ndps.packet_count",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Packet Count", HFILL }},
+ { "Packet Count", "ndps.packet_count",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_last_packet_flag,
- { "Last Packet Flag", "ndps.last_packet_flag",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Last Packet Flag", HFILL }},
+ { "Last Packet Flag", "ndps.last_packet_flag",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_get_resman_session_type,
- { "Session Type", "ndps.ndps_get_resman_session_type",
- FT_UINT32, BASE_HEX, VALS(ndps_get_resman_session_type_enum), 0x0,
- "Session Type", HFILL }},
+ { "Session Type", "ndps.get_resman_session_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_get_resman_session_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_problem_type,
- { "Problem Type", "ndps.ndps_get_resman_session_type",
- FT_UINT32, BASE_HEX, VALS(problem_type_enum), 0x0,
- "Problem Type", HFILL }},
+ { "Problem Type", "ndps.get_resman_session_type",
+ FT_UINT32, BASE_HEX, VALS(problem_type_enum), 0x0,
+ NULL, HFILL }},
{ &hf_ndps_num_values,
- { "Number of Values", "ndps.num_values",
- FT_UINT32, BASE_DEC, NULL, 0x0,
- "Number of Values", HFILL }},
+ { "Number of Values", "ndps.num_values",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_ndps_object_ids_7,
- { "Object ID Definition", "ndps.objectid_def7",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def7",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_8,
- { "Object ID Definition", "ndps.objectid_def8",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def8",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_9,
- { "Object ID Definition", "ndps.objectid_def9",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def9",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_10,
- { "Object ID Definition", "ndps.objectid_def10",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def10",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_11,
- { "Object ID Definition", "ndps.objectid_def11",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def11",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_12,
- { "Object ID Definition", "ndps.objectid_def12",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def12",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_13,
- { "Object ID Definition", "ndps.objectid_def13",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def13",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_14,
- { "Object ID Definition", "ndps.objectid_def14",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def14",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_15,
- { "Object ID Definition", "ndps.objectid_def15",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def15",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_object_ids_16,
- { "Object ID Definition", "ndps.objectid_def16",
- FT_NONE, BASE_HEX, NULL,
- 0x0, "Object ID Definition", HFILL }},
+ { "Object ID Definition", "ndps.objectid_def16",
+ FT_NONE, BASE_NONE, NULL,
+ 0x0, NULL, HFILL }},
{ &hf_ndps_attribute_time,
- { "Time", "ndps.attribute_time",
- FT_ABSOLUTE_TIME, BASE_DEC, NULL, 0x0,
- "Time", HFILL }},
+ { "Time", "ndps.attribute_time",
+ FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_print_security,
- { "Printer Security", "ndps.print_security",
- FT_UINT32, BASE_HEX, VALS(ndps_print_security), 0x0,
- "Printer Security", HFILL }},
+ { "Printer Security", "ndps.print_security",
+ FT_UINT32, BASE_HEX, VALS(ndps_print_security), 0x0,
+ NULL, HFILL }},
{ &hf_notify_time_interval,
- { "Notify Time Interval", "ndps.notify_time_interval",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Notify Time Interval", HFILL }},
+ { "Notify Time Interval", "ndps.notify_time_interval",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_notify_sequence_number,
- { "Notify Sequence Number", "ndps.notify_seq_number",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Notify Sequence Number", HFILL }},
+ { "Notify Sequence Number", "ndps.notify_seq_number",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_notify_lease_exp_time,
- { "Notify Lease Expiration Time", "ndps.notify_lease_exp_time",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Notify Lease Expiration Time", HFILL }},
+ { "Notify Lease Expiration Time", "ndps.notify_lease_exp_time",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_notify_printer_uri,
- { "Notify Printer URI", "ndps.notify_printer_uri",
- FT_STRING, BASE_NONE, NULL, 0x0,
- "Notify Printer URI", HFILL }},
+ { "Notify Printer URI", "ndps.notify_printer_uri",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_level,
- { "Level", "ndps.level",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Level", HFILL }},
+ { "Level", "ndps.level",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
{ &hf_interval,
- { "Interval", "ndps.interval",
- FT_UINT32, BASE_HEX, NULL, 0x0,
- "Interval", HFILL }},
+ { "Interval", "ndps.interval",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }},
};
- static gint *ett[] = {
- &ett_ndps,
- &ett_ndps_segments,
- &ett_ndps_segment,
- };
- module_t *ndps_module;
-
- proto_ndps = proto_register_protocol("Novell Distributed Print System", "NDPS", "ndps");
- proto_register_field_array(proto_ndps, hf_ndps, array_length(hf_ndps));
- proto_register_subtree_array(ett, array_length(ett));
-
- ndps_module = prefs_register_protocol(proto_ndps, NULL);
- prefs_register_bool_preference(ndps_module, "desegment_tcp",
- "Reassemble NDPS messages spanning multiple TCP segments",
- "Whether the NDPS dissector should reassemble messages spanning multiple TCP segments."
- " To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
- &ndps_desegment);
- prefs_register_bool_preference(ndps_module, "desegment_spx",
- "Reassemble fragmented NDPS messages spanning multiple SPX packets",
- "Whether the NDPS dissector should reassemble fragmented NDPS messages spanning multiple SPX packets",
- &ndps_defragment);
- prefs_register_bool_preference(ndps_module, "show_oid",
- "Display NDPS Details",
- "Whether or not the NDPS dissector should show object id's and other details",
- &ndps_show_oids);
-
- register_init_routine(&ndps_init_protocol);
- register_postseq_cleanup_routine(&ndps_postseq_cleanup);
+ static gint *ett[] = {
+ &ett_ndps,
+ &ett_ndps_segments,
+ &ett_ndps_segment,
+ };
+ module_t *ndps_module;
+
+ proto_ndps = proto_register_protocol("Novell Distributed Print System", "NDPS", "ndps");
+ proto_register_field_array(proto_ndps, hf_ndps, array_length(hf_ndps));
+ proto_register_subtree_array(ett, array_length(ett));
+
+ ndps_module = prefs_register_protocol(proto_ndps, NULL);
+ prefs_register_bool_preference(ndps_module, "desegment_tcp",
+ "Reassemble NDPS messages spanning multiple TCP segments",
+ "Whether the NDPS dissector should reassemble messages spanning multiple TCP segments."
+ " To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
+ &ndps_desegment);
+ prefs_register_bool_preference(ndps_module, "desegment_spx",
+ "Reassemble fragmented NDPS messages spanning multiple SPX packets",
+ "Whether the NDPS dissector should reassemble fragmented NDPS messages spanning multiple SPX packets",
+ &ndps_defragment);
+ prefs_register_bool_preference(ndps_module, "show_oid",
+ "Display NDPS Details",
+ "Whether or not the NDPS dissector should show object id's and other details",
+ &ndps_show_oids);
+
+ register_init_routine(&ndps_init_protocol);
+ register_postseq_cleanup_routine(&ndps_postseq_cleanup);
}
void
proto_reg_handoff_ndps(void)
{
- dissector_handle_t ndps_handle, ndps_tcp_handle;
-
- ndps_handle = create_dissector_handle(dissect_ndps_ipx, proto_ndps);
- ndps_tcp_handle = create_dissector_handle(dissect_ndps_tcp, proto_ndps);
-
- dissector_add("spx.socket", SPX_SOCKET_PA, ndps_handle);
- dissector_add("spx.socket", SPX_SOCKET_BROKER, ndps_handle);
- dissector_add("spx.socket", SPX_SOCKET_SRS, ndps_handle);
- dissector_add("spx.socket", SPX_SOCKET_ENS, ndps_handle);
- dissector_add("spx.socket", SPX_SOCKET_RMS, ndps_handle);
- dissector_add("spx.socket", SPX_SOCKET_NOTIFY_LISTENER, ndps_handle);
- dissector_add("tcp.port", TCP_PORT_PA, ndps_tcp_handle);
- dissector_add("tcp.port", TCP_PORT_BROKER, ndps_tcp_handle);
- dissector_add("tcp.port", TCP_PORT_SRS, ndps_tcp_handle);
- dissector_add("tcp.port", TCP_PORT_ENS, ndps_tcp_handle);
- dissector_add("tcp.port", TCP_PORT_RMS, ndps_tcp_handle);
- dissector_add("tcp.port", TCP_PORT_NOTIFY_LISTENER, ndps_tcp_handle);
- ndps_data_handle = find_dissector("data");
+ dissector_handle_t ndps_handle, ndps_tcp_handle;
+
+ ndps_handle = create_dissector_handle(dissect_ndps_ipx, proto_ndps);
+ ndps_tcp_handle = create_dissector_handle(dissect_ndps_tcp, proto_ndps);
+
+ dissector_add_uint("spx.socket", SPX_SOCKET_PA, ndps_handle);
+ dissector_add_uint("spx.socket", SPX_SOCKET_BROKER, ndps_handle);
+ dissector_add_uint("spx.socket", SPX_SOCKET_SRS, ndps_handle);
+ dissector_add_uint("spx.socket", SPX_SOCKET_ENS, ndps_handle);
+ dissector_add_uint("spx.socket", SPX_SOCKET_RMS, ndps_handle);
+ dissector_add_uint("spx.socket", SPX_SOCKET_NOTIFY_LISTENER, ndps_handle);
+ dissector_add_uint("tcp.port", TCP_PORT_PA, ndps_tcp_handle);
+ dissector_add_uint("tcp.port", TCP_PORT_BROKER, ndps_tcp_handle);
+ dissector_add_uint("tcp.port", TCP_PORT_SRS, ndps_tcp_handle);
+ dissector_add_uint("tcp.port", TCP_PORT_ENS, ndps_tcp_handle);
+ dissector_add_uint("tcp.port", TCP_PORT_RMS, ndps_tcp_handle);
+ dissector_add_uint("tcp.port", TCP_PORT_NOTIFY_LISTENER, ndps_tcp_handle);
+ ndps_data_handle = find_dissector("data");
}
git.samba.org / obnox / wireshark / wip.git / blobdiff