aboutsummaryrefslogtreecommitdiffstats
path: root/packet-ndps.c
diff options
context:
space:
mode:
authorguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>2002-10-21 18:56:52 +0000
committerguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>2002-10-21 18:56:52 +0000
commitce59d4a5fef1a1d86d0a2a88c21db584133f0599 (patch)
tree1651cd0c70db308585d06be2620be23ce22a0456 /packet-ndps.c
parent7c544d219667f02308e2a5eb558e0fa28b9edbcc (diff)
From Greg Morris:
Various NDS dissector enhancements including NDS verb 0x07, and proper ping flags for NDS ping version 10 request. Updated error codes for several NCP reply packets. NDPS enhancements. git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@6463 f5534014-38df-0310-8fa8-9805f1628bb7
Diffstat (limited to 'packet-ndps.c')
-rw-r--r--packet-ndps.c2796
1 files changed, 2658 insertions, 138 deletions
diff --git a/packet-ndps.c b/packet-ndps.c
index 017e594a02..29e5b20ebd 100644
--- a/packet-ndps.c
+++ b/packet-ndps.c
@@ -2,7 +2,7 @@
* Routines for NetWare's NDPS
* Greg Morris <gmorris@novell.com>
*
- * $Id: packet-ndps.c,v 1.5 2002/10/15 04:30:58 guy Exp $
+ * $Id: packet-ndps.c,v 1.6 2002/10/21 18:56:52 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@@ -31,8 +31,15 @@
#include <glib.h>
#include <epan/packet.h>
#include "packet-ipx.h"
+#include <epan/conversation.h>
#include "packet-ndps.h"
+#define NDPS_PACKET_INIT_COUNT 200
+
+static void dissect_ndps_request(tvbuff_t*, packet_info*, proto_tree*, guint32, guint32, guint32, int);
+
+static void dissect_ndps_reply(tvbuff_t *, packet_info*, proto_tree*, guint32, int);
+
static int proto_ndps = -1;
static int hf_ndps_record_mark = -1;
static int hf_ndps_length = -1;
@@ -40,6 +47,80 @@ static int hf_ndps_xid = -1;
static int hf_ndps_packet_type = -1;
static int hf_ndps_rpc_version = -1;
static int hf_ndps_error = -1;
+static int hf_ndps_items = -1;
+static int hf_ndps_sbuffer = -1;
+static int hf_ndps_rbuffer = -1;
+static int hf_ndps_pa_name = -1;
+static int hf_ndps_context = -1;
+static int hf_ndps_tree = -1;
+static int hf_ndps_error_val = -1;
+static int hf_ndps_ext_error = -1;
+static int hf_ndps_object = -1;
+static int hf_ndps_cred_type = -1;
+static int hf_ndps_server_name = -1;
+static int hf_ndps_connection = -1;
+static int hf_ndps_auth_null = -1;
+static int hf_ndps_rpc_accept = -1;
+static int hf_ndps_rpc_acc_stat = -1;
+static int hf_ndps_rpc_rej_stat = -1;
+static int hf_ndps_rpc_acc_results = -1;
+static int hf_ndps_problem_type = -1;
+static int hf_security_problem_type = -1;
+static int hf_service_problem_type = -1;
+static int hf_access_problem_type = -1;
+static int hf_printer_problem_type = -1;
+static int hf_selection_problem_type = -1;
+static int hf_doc_access_problem_type = -1;
+static int hf_attribute_problem_type = -1;
+static int hf_update_problem_type = -1;
+static int hf_obj_id_type = -1;
+static int hf_oid_struct_size = -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_qualified_name = -1;
+static int hf_ndps_item_count = -1;
+static int hf_ndps_qualifier = -1;
+static int hf_ndps_lib_error = -1;
+static int hf_ndps_other_error = -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_attribute_value = -1;
+static int hf_ndps_lower_range = -1;
+static int hf_ndps_upper_range = -1;
+static int hf_ndps_n64 = -1;
+static int hf_ndps_lower_range_n64 = -1;
+static int hf_ndps_upper_range_n64 = -1;
+static int hf_ndps_attrib_boolean = -1;
+static int hf_ndps_realization = -1;
+static int hf_ndps_xdimension_n64 = -1;
+static int hf_ndps_ydimension_n64 = -1;
+static int hf_ndps_dim_value = -1;
+static int hf_ndps_dim_flag = -1;
+static int hf_ndps_xydim_value = -1;
+static int hf_ndps_location_value = -1;
+static int hf_ndps_xmin_n64 = -1;
+static int hf_ndps_xmax_n64 = -1;
+static int hf_ndps_ymin_n64 = -1;
+static int hf_ndps_ymax_n64 = -1;
+static int hf_ndps_edge_value = -1;
+static int hf_ndps_cardinal_or_oid = -1;
+static int hf_ndps_cardinal_name_or_oid = -1;
+static int hf_ndps_integer_or_oid = -1;
+static int hf_ndps_profile_id = -1;
+static int hf_ndps_persistence = -1;
+static int hf_ndps_language_id = -1;
+static int hf_address_type = -1;
+static int hf_ndps_address = -1;
+static int hf_ndps_add_bytes = -1;
+static int hf_ndps_event_type = -1;
+static int hf_ndps_event_object_identifier = -1;
+static int hf_ndps_octet_string = -1;
+static int hf_ndps_scope = -1;
static int hf_spx_ndps_program = -1;
static int hf_spx_ndps_version = -1;
@@ -53,6 +134,160 @@ static int hf_spx_ndps_func_broker = -1;
static gint ett_ndps = -1;
static dissector_handle_t ndps_data_handle;
+static const value_string true_false[] = {
+ { 0x00000000, "Accept" },
+ { 0x00000001, "Deny" },
+ { 0, NULL }
+};
+
+static const value_string accept_stat[] = {
+ { 0x00000000, "Success" },
+ { 0x00000001, "Program Unavailable" },
+ { 0x00000002, "Program Mismatch" },
+ { 0x00000003, "Procedure Unavailable" },
+ { 0x00000004, "Garbage Arguments" },
+ { 0x00000005, "System Error" },
+ { 0, NULL }
+};
+
+static const value_string reject_stat[] = {
+ { 0x00000000, "RPC Mismatch" },
+ { 0x00000001, "Authentication Error" },
+ { 0, NULL }
+};
+
+static const value_string error_type_enum[] = {
+ { 0x00000000, "Security Error" },
+ { 0x00000001, "Service Error" },
+ { 0x00000002, "Access Error" },
+ { 0x00000003, "Printer Error" },
+ { 0x00000004, "Selection Error" },
+ { 0x00000005, "Document Access Error" },
+ { 0x00000006, "Attribute Error" },
+ { 0x00000007, "Update Error" },
+ { 0, NULL }
+};
+
+static const value_string security_problem_enum[] = {
+ { 0x00000000, "Authentication" },
+ { 0x00000001, "Credentials" },
+ { 0x00000002, "Rights" },
+ { 0x00000003, "Invalid PAC" },
+ { 0, NULL }
+};
+
+static const value_string service_problem_enum[] = {
+ { 0x00000000, "Sever Busy" },
+ { 0x00000001, "Server Unavailable" },
+ { 0x00000002, "Complex Operation" },
+ { 0x00000003, "Resource Limit" },
+ { 0x00000004, "Unclassified Server Error" },
+ { 0x00000005, "Too Many Items in List" },
+ { 0x00000006, "Resource not Available" },
+ { 0x00000007, "Cancel Document Support" },
+ { 0x00000008, "Modify Document Support" },
+ { 0x00000009, "Multiple Document Support" },
+ { 0x0000000a, "Parameter Valid Support" },
+ { 0x0000000b, "Invalid Checkpoint" },
+ { 0x0000000c, "Continuation Context" },
+ { 0x0000000d, "Pause Limit Exceeded" },
+ { 0x0000000e, "Unsupported Operation" },
+ { 0x0000000f, "Notify Service Error" },
+ { 0x00000010, "Accounting Service Error" },
+ { 0, NULL }
+};
+
+static const value_string access_problem_enum[] = {
+ { 0x00000000, "Wrong Object Class" },
+ { 0x00000001, "Lack of Access Rights" },
+ { 0x00000002, "Can't Interrupt Job" },
+ { 0x00000003, "Wrong Object State" },
+ { 0x00000004, "Client Not Bound" },
+ { 0x00000005, "Not Available" },
+ { 0x00000006, "Notify Service Not Connected" },
+ { 0x00000007, "PDS Not Connected" },
+ { 0, NULL }
+};
+
+static const value_string printer_problem_enum[] = {
+ { 0x00000000, "Printer Error" },
+ { 0x00000001, "Printer Needs Attention" },
+ { 0x00000002, "Printer Needs Key Operator" },
+ { 0, NULL }
+};
+
+static const value_string selection_problem_enum[] = {
+ { 0x00000000, "Invalid ID" },
+ { 0x00000001, "Unknown ID" },
+ { 0x00000002, "Object Exists" },
+ { 0x00000003, "ID Changed" },
+ { 0, NULL }
+};
+
+static const value_string doc_access_problem_enum[] = {
+ { 0x00000000, "Access Not Available" },
+ { 0x00000001, "Time Expired" },
+ { 0x00000002, "Access Denied" },
+ { 0x00000003, "Unknown Document" },
+ { 0x00000004, "No Documents in Job" },
+ { 0, NULL }
+};
+
+static const value_string attribute_problem_enum[] = {
+ { 0x00000000, "Invalid Syntax" },
+ { 0x00000001, "Undefined Type" },
+ { 0x00000002, "Wrong Matching" },
+ { 0x00000003, "Constraint Violated" },
+ { 0x00000004, "Unsupported Type" },
+ { 0x00000005, "Illegal Modification" },
+ { 0x00000006, "Consists With Other Attribute" },
+ { 0x00000007, "Undefined Attribute Value" },
+ { 0x00000008, "Unsupported Value" },
+ { 0x00000009, "Invalid Noncompulsed Modification" },
+ { 0x0000000a, "Per Job Inadmissible" },
+ { 0x0000000b, "Not Multivalued" },
+ { 0x0000000c, "Mandatory Omitted" },
+ { 0x0000000d, "Illegal For Class" },
+ { 0, NULL }
+};
+
+static const value_string update_problem_enum[] = {
+ { 0x00000000, "No Modifications Allowed" },
+ { 0x00000001, "Insufficient Rights" },
+ { 0x00000002, "Previous Operation Incomplete" },
+ { 0x00000003, "Cancel Not Possible" },
+ { 0, NULL }
+};
+
+static const value_string obj_identification_enum[] = {
+ { 0x00000000, "None" },
+ { 0x00000001, "Printer Contained Object ID" },
+ { 0x00000002, "Document Identifier" },
+ { 0x00000003, "Object Identifier" },
+ { 0x00000004, "Object Name" },
+ { 0x00000005, "Name or Object ID" },
+ { 0x00000006, "Simple Name" },
+ { 0x00000007, "Printer Configuration Object ID" },
+ { 0x00000008, "Qualified Name" },
+ { 0x00000009, "Event Object ID" },
+ { 0, NULL }
+};
+
+static const value_string nameorid_enum[] = {
+ { 0x00000000, "None" },
+ { 0x00000001, "Global" },
+ { 0x00000002, "Local" },
+ { 0, NULL }
+};
+
+static const value_string qualified_name_enum[] = {
+ { 0x00000000, "None" },
+ { 0x00000001, "Simple" },
+ { 0x00000002, "NDS" },
+ { 0, NULL }
+};
+
+
static const value_string spx_ndps_program_vals[] = {
{ 0x00060976, "Print Program " },
{ 0x00060977, "Broker Program " },
@@ -156,6 +391,7 @@ static const value_string spx_ndps_resman_func_vals[] = {
{ 0x00000007, "Get Resource File Data" },
{ 0x00000008, "Get Resource Manager NDS Object Name" },
{ 0x00000009, "Get Resource Manager Session Information" },
+ { 0x0000000a, "Set Resource Language Context" },
{ 0, NULL }
};
@@ -177,6 +413,218 @@ static const value_string ndps_packet_types[] = {
{ 0, NULL }
};
+static const value_string ndps_realization_enum[] = {
+ { 0x00000000, "Logical" },
+ { 0x00000001, "Physical" },
+ { 0x00000002, "Logical & Physical" },
+ { 0, NULL }
+};
+
+static const value_string ndps_dim_value_enum[] = {
+ { 0x00000000, "Numeric" },
+ { 0x00000001, "Named" },
+ { 0, NULL }
+};
+
+static const value_string ndps_xydim_value_enum[] = {
+ { 0x00000000, "Real" },
+ { 0x00000001, "Named" },
+ { 0x00000002, "Cardinal" },
+ { 0, NULL }
+};
+
+static const value_string ndps_location_value_enum[] = {
+ { 0x00000000, "Numeric" },
+ { 0x00000001, "Named" },
+ { 0, NULL }
+};
+
+static const value_string ndps_edge_value_enum[] = {
+ { 0x00000000, "Bottom" },
+ { 0x00000001, "Right" },
+ { 0x00000002, "Top" },
+ { 0x00000003, "Left" },
+ { 0, NULL }
+};
+
+static const value_string ndps_card_or_oid_enum[] = {
+ { 0x00000000, "Number" },
+ { 0x00000001, "ID" },
+ { 0, NULL }
+};
+
+static const value_string ndps_card_name_or_oid_enum[] = {
+ { 0x00000000, "ID" },
+ { 0x00000001, "Name" },
+ { 0, NULL }
+};
+
+static const value_string ndps_integer_or_oid_enum[] = {
+ { 0x00000000, "ID" },
+ { 0x00000001, "Number" },
+ { 0, NULL }
+};
+
+static const value_string ndps_persistence_enum[] = {
+ { 0x00000000, "Permanent" },
+ { 0x00000001, "Volatile" },
+ { 0, NULL }
+};
+
+static const value_string ndps_address_type_enum[] = {
+ { 0x00000000, "User" },
+ { 0x00000001, "Server" },
+ { 0x00000002, "Volume" },
+ { 0x00000003, "Organization Unit" },
+ { 0x00000004, "Organization" },
+ { 0x00000005, "Group" },
+ { 0x00000006, "Distinguished Name" },
+ { 0x00000007, "User or Container" },
+ { 0x00000008, "Case Exact String" },
+ { 0x00000009, "Case Ignore String" },
+ { 0x0000000a, "Numeric String" },
+ { 0x0000000b, "DOS File Name" },
+ { 0x0000000c, "Phone Number" },
+ { 0x0000000d, "Boolean" },
+ { 0x0000000e, "Integer" },
+ { 0x0000000f, "Network Address" },
+ { 0x00000010, "Choice" },
+ { 0x00000011, "Groupwise User" },
+ { 0, NULL }
+};
+
+static const value_string ndps_address_enum[] = {
+ { 0x00000000, "IPX" },
+ { 0x00000001, "IP" },
+ { 0x00000002, "SDLC" },
+ { 0x00000003, "Token Ring to Ethernet" },
+ { 0x00000004, "OSI" },
+ { 0x00000005, "Appletalk" },
+ { 0x00000006, "Count" },
+ { 0, NULL }
+};
+
+static const value_string ndps_event_object_enum[] = {
+ { 0x00000000, "Object" },
+ { 0x00000001, "Filter" },
+ { 0x00000002, "Detail" },
+ { 0, NULL }
+};
+
+static const value_string ndps_attribute_enum[] = {
+ { 0x00000000, "Null" },
+ { 0x00000001, "Text" },
+ { 0x00000002, "Descriptive Name" },
+ { 0x00000003, "Descriptor" },
+ { 0x00000004, "Message" },
+ { 0x00000005, "Error Message" },
+ { 0x00000006, "Simple Name" },
+ { 0x00000007, "Distinguished Name" },
+ { 0x00000008, "Distinguished Name Seq" },
+ { 0x00000009, "Delta Time" },
+ { 0x0000000a, "Time" },
+ { 0x0000000b, "Integer" },
+ { 0x0000000c, "Integer Seq" },
+ { 0x0000000d, "Cardinal" },
+ { 0x0000000e, "Cardinal Seq" },
+ { 0x0000000f, "Positive Integer" },
+ { 0x00000010, "Integer Range" },
+ { 0x00000011, "Cardinal Range" },
+ { 0x00000012, "Maximum Integer" },
+ { 0x00000013, "Minimum Integer" },
+ { 0x00000014, "Integer 64" },
+ { 0x00000015, "Integer 64 Seq" },
+ { 0x00000016, "Cardinal 64" },
+ { 0x00000017, "Cardinal 64 Seq" },
+ { 0x00000018, "Positive Integer 64" },
+ { 0x00000019, "Integer 64 Range" },
+ { 0x0000001a, "Cardinal 64 Range" },
+ { 0x0000001b, "Maximum Integer 64" },
+ { 0x0000001c, "Minimum Integer 64" },
+ { 0x0000001d, "Real" },
+ { 0x0000001e, "Real Seq" },
+ { 0x0000001f, "Non-Negative Real" },
+ { 0x00000020, "Real Range" },
+ { 0x00000021, "Non-Negative Real Range" },
+ { 0x00000022, "Boolean" },
+ { 0x00000023, "Percent" },
+ { 0x00000024, "Object Identifier" },
+ { 0x00000025, "Object Identifier Seq" },
+ { 0x00000026, "Name or OID" },
+ { 0x00000027, "Name or OID Seq" },
+ { 0x00000028, "Distinguished Name" },
+ { 0x00000029, "Relative Distinguished Name Seq" },
+ { 0x0000002a, "Realization" },
+ { 0x0000002b, "Medium Dimensions" },
+ { 0x0000002c, "Dimension" },
+ { 0x0000002d, "XY Dimensions" },
+ { 0x0000002e, "Locations" },
+ { 0x0000002f, "Area" },
+ { 0x00000030, "Area Seq" },
+ { 0x00000031, "Edge" },
+ { 0x00000032, "Font Reference" },
+ { 0x00000033, "Cardinal or OID" },
+ { 0x00000034, "OID Cardinal Map" },
+ { 0x00000035, "Cardinal or Name or OID" },
+ { 0x00000036, "Positive Integer or OID" },
+ { 0x00000037, "Event Handling Profile" },
+ { 0x00000038, "Octet String" },
+ { 0x00000039, "Priority" },
+ { 0x0000003a, "Locale" },
+ { 0x0000003b, "Method Delivery Address" },
+ { 0x0000003c, "Object Identification" },
+ { 0x0000003d, "Results Profile" },
+ { 0x0000003e, "Criteria" },
+ { 0x0000003f, "Job Password" },
+ { 0x00000040, "Job Level" },
+ { 0x00000041, "Job Categories" },
+ { 0x00000042, "Print Checkpoint" },
+ { 0x00000043, "Ignored Attribute" },
+ { 0x00000044, "Resource" },
+ { 0x00000045, "Medium Substitution" },
+ { 0x00000046, "Font Substitution" },
+ { 0x00000047, "Resource Context Seq" },
+ { 0x00000048, "Sides" },
+ { 0x00000049, "Page Select Seq" },
+ { 0x0000004a, "Page Media Select" },
+ { 0x0000004b, "Document Content" },
+ { 0x0000004c, "Page Size" },
+ { 0x0000004d, "Presentation Direction" },
+ { 0x0000004e, "Page Order" },
+ { 0x0000004f, "File Reference" },
+ { 0x00000050, "Medium Source Size" },
+ { 0x00000051, "Input Tray Medium" },
+ { 0x00000052, "Output Bins Chars" },
+ { 0x00000053, "Page ID Type" },
+ { 0x00000054, "Level Range" },
+ { 0x00000055, "Category Set" },
+ { 0x00000056, "Numbers Up Supported" },
+ { 0x00000057, "Finishing" },
+ { 0x00000058, "Print Contained Object ID" },
+ { 0x00000059, "Print Config Object ID" },
+ { 0x0000005a, "Typed Name" },
+ { 0x0000005b, "Network Address" },
+ { 0x0000005c, "XY Dimensions Value" },
+ { 0x0000005d, "Name or OID Dimensions Map" },
+ { 0x0000005e, "Printer State Reason" },
+ { 0x0000005f, "Enumeration" },
+ { 0x00000060, "Qualified Name" },
+ { 0x00000061, "Qualified Name Set" },
+ { 0x00000062, "Colorant Set" },
+ { 0x00000063, "Resource Printer ID" },
+ { 0x00000064, "Event Object ID" },
+ { 0x00000065, "Qualified Name Map" },
+ { 0x00000066, "File Path" },
+ { 0x00000067, "Uniform Resource Identifier" },
+ { 0x00000068, "Cardinal or Enum or Time" },
+ { 0x00000069, "Print Contained Object ID Set" },
+ { 0x0000006a, "Octet String Pair" },
+ { 0x0000006b, "Octet String Integer Pair" },
+ { 0x0000006c, "Extended Resource Identifier" },
+ { 0x0000006d, "Event Handling Profile 2" },
+ { 0, NULL }
+};
+
static const value_string ndps_error_types[] = {
{ 0xFFFFFC18, "NWDP_OE_BK_OUT_OF_MEMORY" }, /* Broker Errors */
{ 0xFFFFFC17, "NWDP_OE_BK_BAD_NETWARE_VERSION" },
@@ -503,184 +951,1882 @@ static const value_string ndps_error_types[] = {
{ 0, NULL }
};
+static const value_string ndps_credential_enum[] = {
+ { 0, "SIMPLE" },
+ { 1, "CERTIFIED" },
+ { 2, "NDPS 0" },
+ { 3, "NDPS 1" },
+ { 4, "NDPS 2" },
+ { 0, NULL }
+};
+
+static void
+get_string(tvbuff_t* tvb, guint offset, guint str_length, char *dest_buf)
+{
+ guint32 i;
+ guint16 c_char;
+ guint32 length_remaining = 0;
+
+ length_remaining = tvb_length_remaining(tvb, offset);
+ if(str_length > length_remaining || str_length > 1024)
+ {
+ strcpy(dest_buf, "<String to long to process>");
+ return;
+ }
+ if(str_length == 0)
+ {
+ strcpy(dest_buf, "<Not Specified>");
+ return;
+ }
+ for ( i = 0; i < str_length; i++ )
+ {
+ c_char = tvb_get_guint8(tvb, offset );
+ if (c_char<0x20 || c_char>0x7e)
+ {
+ if (c_char != 0x00)
+ {
+ c_char = 0x2e;
+ dest_buf[i] = c_char & 0xff;
+ }
+ else
+ {
+ i--;
+ str_length--;
+ }
+ }
+ else
+ {
+ dest_buf[i] = c_char & 0xff;
+ }
+ offset++;
+ length_remaining--;
+
+ if(length_remaining==1)
+ {
+ dest_buf[i+1] = '\0';
+ return;
+ }
+ }
+dest_buf[i] = '\0';
+return;
+}
+
+static guint32
+align_4(tvbuff_t *tvb, guint32 aoffset)
+{
+ if(tvb_length_remaining(tvb, aoffset) > 4 )
+ {
+ return (aoffset%4);
+ }
+ return 0;
+}
+
+
+static guint32
+objectident(tvbuff_t* tvb, proto_tree *ndps_tree, int foffset)
+{
+ guint8 h;
+ guint8 object_count;
+ guint32 name_len=0;
+ guint32 object_type=0;
+ char buffer[1024];
+ proto_tree *atree;
+ proto_item *aitem;
+
+ /*proto_tree_add_item(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, FALSE);*/
+ object_count = tvb_get_ntohl(tvb, foffset);
+
+
+ foffset += 4;
+ object_type = tvb_get_ntohl(tvb, foffset);
+ aitem = proto_tree_add_item(ndps_tree, hf_obj_id_type, tvb, foffset, 4, FALSE);
+ atree = proto_item_add_subtree(aitem, ett_ndps);
+ foffset += 4;
+ for (h = 1 ; h <= object_count; h++ )
+ {
+ switch(object_type)
+ {
+ case 0: /* None */
+ break;
+ case 1: /* Printer Contained Object ID */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ proto_tree_add_uint(atree, hf_ndps_object, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ foffset += 4;
+ break;
+ case 2: /* Document Identifier */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ proto_tree_add_uint(atree, hf_ndps_object, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ foffset += 4;
+ proto_tree_add_uint(atree, hf_ndps_document_number, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ foffset += 4;
+ break;
+ case 3: /* Object Identifier */
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ return foffset;
+ }
+ foffset += 4;
+ break;
+ case 4: /* Object Name */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ return foffset;
+ }
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 5: /* Name or Object ID */
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 6: /* Simple Name */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 7: /* Printer Configuration Object ID */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ proto_tree_add_uint(atree, hf_ndps_qualified_name, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ if (tvb_get_ntohl(tvb, foffset) != 0) {
+ if (tvb_get_ntohl(tvb, foffset) == 1) {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ }
+ else
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_ndps_context, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_ndps_tree, tvb, foffset,
+ name_len, buffer);
+ }
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ break;
+ case 8: /* Qualified Name */
+ proto_tree_add_uint(atree, hf_ndps_qualified_name, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ if (tvb_get_ntohl(tvb, foffset) != 0) {
+ if (tvb_get_ntohl(tvb, foffset) == 1) {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ }
+ else
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_ndps_context, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_ndps_tree, tvb, foffset,
+ name_len, buffer);
+ }
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ break;
+ case 9: /* Event Object ID */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ return foffset;
+ }
+ foffset += 4;
+ default:
+ break;
+ }
+ }
+ return foffset;
+}
+
+static guint32
+address_item(tvbuff_t* tvb, proto_tree *ndps_tree, int foffset)
+{
+ guint32 address_type=0;
+ guint32 transport_type=0;
+ guint32 name_len=0;
+ guint32 octet_len=0;
+ char buffer[1024];
+
+ address_type = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_item(ndps_tree, hf_address_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ switch(address_type)
+ {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ proto_tree_add_uint(ndps_tree, hf_ndps_qualified_name, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ if (tvb_get_ntohl(tvb, foffset) != 0) {
+ if (tvb_get_ntohl(tvb, foffset) == 1) {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ }
+ else
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_context, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_tree, tvb, foffset,
+ name_len, buffer);
+ }
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ break;
+ case 8:
+ case 9:
+ case 10:
+ case 11:
+ case 12:
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 13:
+ proto_tree_add_item(ndps_tree, hf_ndps_attrib_boolean, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 14:
+ proto_tree_add_item(ndps_tree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 15:
+ transport_type=tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_address, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ octet_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_add_bytes, tvb, foffset, octet_len, FALSE);
+ foffset += octet_len;
+ break;
+ case 16:
+ case 17:
+ default:
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ }
+ return foffset;
+}
+
+static guint32
+attribute_value(tvbuff_t* tvb, proto_tree *ndps_tree, int foffset)
+{
+ guint8 h;
+ guint8 i;
+ guint8 j;
+ guint8 number_of_values=0;
+ guint8 number_of_items=0;
+ guint8 number_of_items2=0;
+ guint32 name_len=0;
+ guint32 attribute_type=0;
+ char buffer[1024];
+ proto_tree *atree;
+ proto_item *aitem;
+ proto_tree *btree;
+ proto_item *bitem;
+ proto_tree *ctree;
+ proto_item *citem;
+
+ number_of_values = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ attribute_type = tvb_get_ntohl(tvb, foffset);
+ aitem = proto_tree_add_item(ndps_tree, hf_obj_attribute_type, tvb, foffset, 4, FALSE);
+ atree = proto_item_add_subtree(aitem, ett_ndps);
+ foffset += 4;
+ for (h = 1 ; h <= number_of_values; h++ )
+ {
+ switch(attribute_type)
+ {
+ case 0: /* Null */
+ break;
+ case 1: /* Text */
+ case 2: /* Descriptive Name */
+ case 3: /* Descriptor */
+ case 6: /* Simple Name */
+ case 40: /* Distinguished Name */
+ case 50: /* Font Reference */
+ case 58: /* Locale */
+ case 102: /* File Path */
+ case 103: /* Uniform Resource Identifier */
+ case 108: /* Extended Resource Identifier */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 4: /* Message */
+ case 5: /* Error Message */
+ case 38: /* Name or OID */
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 7: /* Distinguished Name */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 8: /* Distinguished Name Seq */
+ case 39: /* Name or OID Seq */
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(btree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 9: /* Delta Time */
+ case 10: /* Time */
+ case 11: /* Integer */
+ case 13: /* Cardinal */
+ case 15: /* Positive Integer */
+ case 18: /* Maximum Integer */
+ case 19: /* Minimum Integer */
+ case 35: /* Percent */
+ case 57: /* Priority */
+ case 72: /* Sides */
+ case 95: /* Enumeration */
+ proto_tree_add_item(atree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 12: /* Integer Seq */
+ case 14: /* Cardinal Seq */
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_item(btree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ }
+ break;
+ case 16: /* Integer Range */
+ case 17: /* Cardinal Range */
+ proto_tree_add_item(atree, hf_ndps_lower_range, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_upper_range, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 20: /* Integer 64 */
+ case 22: /* Cardinal 64 */
+ case 24: /* Positive Integer 64 */
+ case 31: /* Non-Negative Real */
+ case 29: /* Real */
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ break;
+ case 21: /* Integer 64 Seq */
+ case 23: /* Cardinal 64 Seq */
+ case 30: /* Real Seq */
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_item(btree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ }
+ break;
+ case 25: /* Integer 64 Range */
+ case 26: /* Cardinal 64 Range */
+ case 32: /* Real Range */
+ case 33: /* Non-Negative Real Range */
+ proto_tree_add_item(atree, hf_ndps_lower_range_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ proto_tree_add_item(atree, hf_ndps_upper_range_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ break;
+ case 27: /* Maximum Integer 64 */
+ proto_tree_add_item(atree, hf_ndps_lower_range_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ break;
+ case 28: /* Minimum Integer 64 */
+ proto_tree_add_item(atree, hf_ndps_upper_range_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ break;
+ case 34: /* Boolean */
+ proto_tree_add_item(atree, hf_ndps_attrib_boolean, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 36: /* Object Identifier */
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ break;
+ case 37: /* Object Identifier Seq */
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_uint(btree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ }
+ break;
+ case 41: /* Relative Distinguished Name Seq */
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(btree, hf_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ break;
+ case 42: /* Realization */
+ proto_tree_add_item(atree, hf_ndps_realization, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 43: /* Medium Dimensions */
+ proto_tree_add_item(atree, hf_ndps_xdimension_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ proto_tree_add_item(atree, hf_ndps_ydimension_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ break;
+ case 44: /* Dimension */
+ proto_tree_add_item(atree, hf_ndps_dim_value, tvb, foffset, 8, FALSE);
+ foffset += 4;
+ if (tvb_get_ntohl(tvb, foffset-4) == 0) {
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ }
+ else
+ {
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ proto_tree_add_item(atree, hf_ndps_dim_flag, tvb, foffset, 8, FALSE);
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ break;
+ case 45: /* XY Dimensions */
+ proto_tree_add_item(atree, hf_ndps_xydim_value, tvb, foffset, 8, FALSE);
+ foffset += 4;
+ if (tvb_get_ntohl(tvb, foffset-4) == 1) {
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ else
+ {
+ proto_tree_add_item(atree, hf_ndps_xdimension_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ proto_tree_add_item(atree, hf_ndps_ydimension_n64, tvb, foffset, 4, FALSE);
+ foffset += 8;
+ }
+ proto_tree_add_item(atree, hf_ndps_dim_flag, tvb, foffset, 8, FALSE);
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ break;
+ case 46: /* Locations */
+ proto_tree_add_item(atree, hf_ndps_location_value, tvb, foffset, 8, FALSE);
+ foffset += 4;
+ if (tvb_get_ntohl(tvb, foffset-4) == 0) {
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_item(btree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ }
+ }
+ else
+ {
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ proto_tree_add_item(atree, hf_ndps_dim_flag, tvb, foffset, 8, FALSE);
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ break;
+ case 47: /* Area */
+ proto_tree_add_item(atree, hf_ndps_xmin_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ proto_tree_add_item(atree, hf_ndps_xmax_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ proto_tree_add_item(atree, hf_ndps_ymin_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ proto_tree_add_item(atree, hf_ndps_ymax_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ break;
+ case 48: /* Area Seq */
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_item(btree, hf_ndps_xmin_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ proto_tree_add_item(btree, hf_ndps_xmax_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ proto_tree_add_item(btree, hf_ndps_ymin_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ proto_tree_add_item(btree, hf_ndps_ymax_n64, tvb, foffset, 8, FALSE);
+ foffset += 8;
+ }
+ break;
+ case 49: /* Edge */
+ proto_tree_add_item(atree, hf_ndps_edge_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 51: /* Cardinal or OID */
+ proto_tree_add_item(atree, hf_ndps_cardinal_or_oid, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ if (tvb_get_ntohl(tvb, foffset-4)==0) {
+ proto_tree_add_item(atree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ }
+ else
+ {
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ }
+ break;
+ case 52: /* OID Cardinal Map */
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 53: /* Cardinal or Name or OID */
+ proto_tree_add_item(atree, hf_ndps_cardinal_name_or_oid, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ if (tvb_get_ntohl(tvb, foffset-4)==0) {
+ proto_tree_add_item(atree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ }
+ else
+ {
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ break;
+ case 54: /* Positive Integer or OID */
+ proto_tree_add_item(atree, hf_ndps_integer_or_oid, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ if (tvb_get_ntohl(tvb, foffset-4)==0) {
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ }
+ else
+ {
+ proto_tree_add_item(atree, hf_ndps_attribute_value, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ }
+ break;
+ case 55: /* Event Handling Profile */
+ proto_tree_add_item(atree, hf_ndps_profile_id, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_persistence, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_uint(atree, hf_ndps_qualified_name, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ if (tvb_get_ntohl(tvb, foffset) != 0) {
+ if (tvb_get_ntohl(tvb, foffset) == 1) {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ }
+ else
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_ndps_context, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_ndps_tree, tvb, foffset,
+ name_len, buffer);
+ }
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_item(btree, hf_ndps_language_id, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_uint(btree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(btree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ bitem = proto_tree_add_item(atree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ btree = proto_item_add_subtree(bitem, ett_ndps);
+ number_of_items = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ foffset += address_item(tvb, btree, foffset);
+ /*proto_tree_add_item(btree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ foffset += 4;*/
+ proto_tree_add_item(btree, hf_ndps_event_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(btree, hf_ndps_event_object_identifier, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ if(tvb_get_ntohl(tvb, foffset-4)==0)
+ {
+ proto_tree_add_uint(btree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ }
+ else
+ {
+ citem = proto_tree_add_item(btree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ ctree = proto_item_add_subtree(citem, ett_ndps);
+ number_of_items2 = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (j = 1 ; j <= number_of_items2; j++ )
+ {
+ proto_tree_add_uint(ctree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ proto_tree_add_uint(ctree, hf_ndps_qualified_name, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ if (tvb_get_ntohl(tvb, foffset) != 0) {
+ if (tvb_get_ntohl(tvb, foffset) == 1) {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ctree, hf_printer_name, tvb, foffset,
+ name_len, buffer);
+ }
+ else
+ {
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ctree, hf_ndps_context, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ctree, hf_ndps_tree, tvb, foffset,
+ name_len, buffer);
+ }
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ }
+ }
+ }
+ }
+ break;
+ case 56: /* Octet String */
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ proto_tree_add_item(atree, hf_ndps_octet_string, tvb, foffset, name_len, FALSE);
+ break;
+ case 59: /* Method Delivery Address */
+ case 60: /* Object Identification */
+ case 61: /* Results Profile */
+ case 62: /* Criteria */
+ case 63: /* Job Password */
+ case 64: /* Job Level */
+ case 65: /* Job Categories */
+ case 66: /* Print Checkpoint */
+ case 67: /* Ignored Attribute */
+ case 68: /* Resource */
+ case 69: /* Medium Substitution */
+ case 70: /* Font Substitution */
+ case 71: /* Resource Context Seq */
+ case 73: /* Page Select Seq */
+ case 74: /* Page Media Select */
+ case 75: /* Document Content */
+ case 76: /* Page Size */
+ case 77: /* Presentation Direction */
+ case 78: /* Page Order */
+ case 79: /* File Reference */
+ case 80: /* Medium Source Size */
+ case 81: /* Input Tray Medium */
+ case 82: /* Output Bins Chars */
+ case 83: /* Page ID Type */
+ case 84: /* Level Range */
+ case 85: /* Category Set */
+ case 86: /* Numbers Up Supported */
+ case 87: /* Finishing */
+ case 88: /* Print Contained Object ID */
+ case 89: /* Print Config Object ID */
+ case 90: /* Typed Name */
+ case 91: /* Network Address */
+ case 92: /* XY Dimensions Value */
+ case 93: /* Name or OID Dimensions Map */
+ case 94: /* Printer State Reason */
+ case 96: /* Qualified Name */
+ case 97: /* Qualified Name Set */
+ case 98: /* Colorant Set */
+ case 99: /* Resource Printer ID */
+ case 100: /* Event Object ID */
+ case 101: /* Qualified Name Map */
+ case 104: /* Cardinal or Enum or Time */
+ case 105: /* Print Contained Object ID Set */
+ case 106: /* Octet String Pair */
+ case 107: /* Octet String Integer Pair */
+ case 109: /* Event Handling Profile 2 */
+ default:
+ break;
+ }
+ }
+ return foffset;
+}
+
+
+/* NDPS packets come in request/reply pairs. The request packets tell the
+ * Function and Program numbers. The response, unfortunately, only
+ * identifies itself via the Exchange ID; you have to know what type of NDPS
+ * request the request packet contained in order to successfully parse the
+ * response. A global method for doing this does not exist in ethereal yet
+ * (NFS also requires it), so for now the NDPS section will keep its own hash
+ * table keeping track of NDPS packets.
+ *
+ * We construct a conversation specified by the client and server
+ * addresses and the connection number; the key representing the unique
+ * NDPS request then is composed of the pointer to the conversation
+ * structure, cast to a "guint" (which may throw away the upper 32
+ * bits of the pointer on a P64 platform, but the low-order 32 bits
+ * are more likely to differ between conversations than the upper 32 bits),
+ * and the sequence number.
+ *
+ * The value stored in the hash table is the ncp_req_hash_value pointer. This
+ * struct tells us the NDPS Program and Function and gives the NDPS_record pointer.
+ */
+typedef struct {
+ conversation_t *conversation;
+ guint32 ndps_xid;
+} ndps_req_hash_key;
+
+typedef struct {
+ guint32 ndps_prog;
+ guint32 ndps_func;
+} ndps_req_hash_value;
+
+static GHashTable *ndps_req_hash = NULL;
+static GMemChunk *ndps_req_hash_keys = NULL;
+static GMemChunk *ndps_req_hash_values = NULL;
+
+/* Hash Functions */
+gint
+ndps_equal(gconstpointer v, gconstpointer v2)
+{
+ ndps_req_hash_key *val1 = (ndps_req_hash_key*)v;
+ ndps_req_hash_key *val2 = (ndps_req_hash_key*)v2;
+
+ if (val1->conversation == val2->conversation &&
+ val1->ndps_xid == val2->ndps_xid ) {
+ return 1;
+ }
+ return 0;
+}
+
+guint
+ndps_hash(gconstpointer v)
+{
+ ndps_req_hash_key *ndps_key = (ndps_req_hash_key*)v;
+ return GPOINTER_TO_UINT(ndps_key->conversation) + ndps_key->ndps_xid;
+}
+
+/* Frees memory used by the ndps_req_hash_value's */
+static void
+ndps_req_hash_cleanup(gpointer key _U_, gpointer value, gpointer user_data _U_)
+{
+ ndps_req_hash_value *request_value = (ndps_req_hash_value*) value;
+
+ /*if (request_value->ndps_func) {
+ g_free(request_value->ndps_func);
+ }*/
+}
+
+/* Initializes the hash table and the mem_chunk area each time a new
+ * file is loaded or re-loaded in ethereal */
+static void
+ndps_init_protocol(void)
+{
+ if (ndps_req_hash) {
+ g_hash_table_foreach(ndps_req_hash, ndps_req_hash_cleanup, NULL);
+ g_hash_table_destroy(ndps_req_hash);
+ }
+ if (ndps_req_hash_keys)
+ g_mem_chunk_destroy(ndps_req_hash_keys);
+ if (ndps_req_hash_values)
+ g_mem_chunk_destroy(ndps_req_hash_values);
+
+ ndps_req_hash = g_hash_table_new(ndps_hash, ndps_equal);
+ ndps_req_hash_keys = g_mem_chunk_new("ndps_req_hash_keys",
+ sizeof(ndps_req_hash_key),
+ NDPS_PACKET_INIT_COUNT * sizeof(ndps_req_hash_key),
+ G_ALLOC_ONLY);
+ ndps_req_hash_values = g_mem_chunk_new("ndps_req_hash_values",
+ sizeof(ndps_req_hash_value),
+ NDPS_PACKET_INIT_COUNT * sizeof(ndps_req_hash_value),
+ G_ALLOC_ONLY);
+}
+
+/* After the sequential run, we don't need the ncp_request hash and keys
+ * anymore; the lookups have already been done and the vital info
+ * saved in the reply-packets' private_data in the frame_data struct. */
+static void
+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;
+ }
+ if (ndps_req_hash_keys) {
+ g_mem_chunk_destroy(ndps_req_hash_keys);
+ ndps_req_hash_keys = NULL;
+ }
+ /* Don't free the ncp_req_hash_values, as they're
+ * needed during random-access processing of the proto_tree.*/
+}
+
+ndps_req_hash_value*
+ndps_hash_insert(conversation_t *conversation, guint32 ndps_xid)
+{
+ 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 = g_mem_chunk_alloc(ndps_req_hash_keys);
+ request_key->conversation = conversation;
+ request_key->ndps_xid = ndps_xid;
+
+ request_value = g_mem_chunk_alloc(ndps_req_hash_values);
+ request_value->ndps_prog = 0;
+ request_value->ndps_func = 0;
+
+ g_hash_table_insert(ndps_req_hash, request_key, request_value);
+
+ return request_value;
+}
+
+/* Returns the ncp_rec*, or NULL if not found. */
+ndps_req_hash_value*
+ndps_hash_lookup(conversation_t *conversation, guint32 ndps_xid)
+{
+ ndps_req_hash_key request_key;
+
+ request_key.conversation = conversation;
+ request_key.ndps_xid = ndps_xid;
+
+ return g_hash_table_lookup(ndps_req_hash, &request_key);
+}
+
/* ================================================================= */
/* NDPS */
/* ================================================================= */
-/*
- * XXX - we probably need separate SPX-based and TCP-based dissectors,
- * with the former dissecting one PDU per frame and the latter
- * dissecting multiple PDUs per segment, if necessary, and doing TCP
- * reassembly.
- */
static void
dissect_ndps(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- proto_tree *ndps_tree = NULL;
+ proto_tree *ndps_tree;
proto_item *ti;
- tvbuff_t *next_tvb;
+ guint16 record_mark;
+ guint16 ndps_length;
+ guint32 ndps_xid;
guint32 ndps_prog;
guint32 ndps_packet_type;
- guint32 foffset;
+ guint32 ndps_rpc_version;
+ int foffset;
guint32 ndps_hfname;
guint32 ndps_func;
- gint reported_length, length;
- guint32 ndps_err;
- guint32 ndps_err_dec;
- const char *ndps_program_string;
- const char *ndps_func_string;
- const char *ndps_error_val;
+ const char *ndps_program_string='\0';
+ const char *ndps_func_string='\0';
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_set_str(pinfo->cinfo, COL_INFO, "NDPS ");
+ col_clear(pinfo->cinfo, COL_INFO);
- foffset = 0;
if (tree) {
+ foffset = 0;
ti = proto_tree_add_item(tree, proto_ndps, tvb, foffset, -1, FALSE);
ndps_tree = proto_item_add_subtree(ti, ett_ndps);
- }
- if (tvb_reported_length_remaining(tvb, foffset) > 28) {
- if (tree) {
- proto_tree_add_item(ndps_tree, hf_ndps_record_mark, tvb,
- foffset, 2, FALSE);
- }
- foffset += 2;
- if (tree) {
- proto_tree_add_item(ndps_tree, hf_ndps_length, tvb,
- foffset, 2, FALSE);
- }
- foffset += 2;
- if (tree)
- proto_tree_add_item(ndps_tree, hf_ndps_xid, tvb, foffset, 4, FALSE);
- foffset += 4;
- ndps_packet_type = tvb_get_ntohl(tvb, foffset);
- if (tree) {
- proto_tree_add_uint(ndps_tree, hf_ndps_packet_type, tvb,
- foffset, 4, ndps_packet_type);
- }
- if (ndps_packet_type == 0x00000001) {
- reported_length = tvb_reported_length(tvb);
- length = tvb_length(tvb);
- if (length >= reported_length && reported_length >= 32) {
- ndps_err = tvb_get_ntohl(tvb, reported_length - 4);
- if ((ndps_err & 0xffff0000) == 0xffff0000) {
- ndps_error_val = match_strval(ndps_err, ndps_error_types);
- if (ndps_error_val == NULL)
- ndps_error_val = "No Error Message Found";
- ndps_err_dec = -ndps_err;
- if (check_col(pinfo->cinfo, COL_INFO)) {
- col_add_fstr(pinfo->cinfo, COL_INFO,
- "NDPS Error - (0x%08x), (-%d), %s",
- ndps_err, ndps_err_dec, ndps_error_val);
+ if (tvb_length_remaining(tvb, foffset) >= 28)
+ {
+ record_mark = tvb_get_ntohs(tvb, foffset);
+ if (tvb_get_ntohl(tvb, foffset+4) == 0x00000065) /* Check xid if not 65 then fragment packet */
+ {
+ proto_tree_add_uint(ndps_tree, hf_ndps_record_mark, tvb,
+ foffset, 2, record_mark);
+ foffset += 2;
+ ndps_length = tvb_get_ntohs(tvb, foffset);
+ proto_tree_add_uint_format(ndps_tree, hf_ndps_length, tvb,
+ foffset, 2, ndps_length,
+ "Length of NDPS Packet: %d", ndps_length);
+ foffset += 2;
+ ndps_xid = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_uint(ndps_tree, hf_ndps_xid, tvb, foffset, 4, ndps_xid);
+ foffset += 4;
+ ndps_packet_type = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_packet_type, tvb, foffset, 4, FALSE);
+ 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 ");
+ 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);
+ foffset += 8;
}
- if (tree) {
- proto_tree_add_uint_format(ndps_tree, hf_ndps_error,
- tvb, reported_length - 4, 4,
- ndps_err,
- "NDPS Error - (0x%08x), (-%d), %s",
- ndps_err, ndps_err_dec,
- ndps_error_val);
+ else
+ {
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_rpc_rej_stat, tvb, foffset+4, 4, FALSE);
+ foffset += 4;
}
- } else {
+ dissect_ndps_reply(tvb, pinfo, ndps_tree, ndps_xid, foffset);
+ }
+ else
+ {
if (check_col(pinfo->cinfo, COL_INFO))
- col_set_str(pinfo->cinfo, COL_INFO, "NDPS Reply - Ok");
+ col_set_str(pinfo->cinfo, COL_INFO, "C NDPS ");
+ ndps_rpc_version = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_rpc_version, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ ndps_prog = tvb_get_ntohl(tvb, foffset);
+ ndps_program_string = match_strval(ndps_prog, spx_ndps_program_vals);
+ if( ndps_program_string != NULL)
+ {
+ proto_tree_add_item(ndps_tree, hf_spx_ndps_program, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ if (check_col(pinfo->cinfo, COL_INFO))
+ {
+ col_append_str(pinfo->cinfo, COL_INFO, (gchar*) ndps_program_string);
+ col_append_str(pinfo->cinfo, COL_INFO, ", ");
+ }
+ proto_tree_add_item(ndps_tree, hf_spx_ndps_version, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ ndps_func = tvb_get_ntohl(tvb, foffset);
+ switch(ndps_prog)
+ {
+ case 0x060976:
+ ndps_hfname = hf_spx_ndps_func_print;
+ ndps_func_string = match_strval(ndps_func, spx_ndps_print_func_vals);
+ break;
+ case 0x060977:
+ ndps_hfname = hf_spx_ndps_func_broker;
+ ndps_func_string = match_strval(ndps_func, spx_ndps_broker_func_vals);
+ break;
+ case 0x060978:
+ ndps_hfname = hf_spx_ndps_func_registry;
+ ndps_func_string = match_strval(ndps_func, spx_ndps_registry_func_vals);
+ break;
+ case 0x060979:
+ ndps_hfname = hf_spx_ndps_func_notify;
+ ndps_func_string = match_strval(ndps_func, spx_ndps_notify_func_vals);
+ break;
+ case 0x06097a:
+ ndps_hfname = hf_spx_ndps_func_resman;
+ ndps_func_string = match_strval(ndps_func, spx_ndps_resman_func_vals);
+ break;
+ case 0x06097b:
+ ndps_hfname = hf_spx_ndps_func_delivery;
+ ndps_func_string = match_strval(ndps_func, spx_ndps_deliver_func_vals);
+ break;
+ default:
+ ndps_hfname = 0;
+ break;
+ }
+ if(ndps_hfname != 0)
+ {
+ proto_tree_add_item(ndps_tree, ndps_hfname, tvb, foffset, 4, FALSE);
+ if (ndps_func_string != NULL)
+ {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, (gchar*) ndps_func_string);
+
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_auth_null, tvb, foffset, 16, FALSE);
+ foffset+=16;
+ dissect_ndps_request(tvb, pinfo, ndps_tree, ndps_xid, ndps_prog, ndps_func, foffset);
+ }
+ }
+ }
}
}
+ else
+ {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, "Continuation Fragment");
+ }
}
- foffset += 4;
- if (tree) {
- proto_tree_add_item(ndps_tree, hf_ndps_rpc_version, tvb,
- foffset, 4, FALSE);
- }
- foffset += 4;
- ndps_prog = tvb_get_ntohl(tvb, foffset);
- if (tree) {
- proto_tree_add_uint(ndps_tree, hf_spx_ndps_program, tvb,
- foffset, 4, ndps_prog);
+ }
+}
+
+static void
+dissect_ndps_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ndps_tree, guint32 ndps_xid, guint32 ndps_prog, guint32 ndps_func, int foffset)
+{
+ ndps_req_hash_value *request_value = NULL;
+ conversation_t *conversation;
+ guint32 name_len;
+ char buffer[1024];
+ guint32 cred_type;
+
+ if (!pinfo->fd->flags.visited)
+ {
+
+ /* This is the first time we've looked at this packet.
+ Keep track of the Program and connection whence the request
+ came, and the address and connection to which the request
+ is being sent, so that we can match up calls with replies.
+ (We don't include the sequence number, as we may want
+ to have all packets over the same connection treated
+ as being part of a single conversation so that we can
+ let the user select that conversation to be displayed.) */
+
+ conversation = find_conversation(&pinfo->src, &pinfo->dst,
+ PT_NCP, ndps_xid, ndps_xid, 0);
+
+ if (conversation == NULL)
+ {
+ /* It's not part of any conversation - create a new one. */
+ conversation = conversation_new(&pinfo->src, &pinfo->dst,
+ PT_NONE, ndps_xid, ndps_xid, 0);
}
- ndps_program_string = match_strval(ndps_prog, spx_ndps_program_vals);
- if (ndps_program_string != NULL) {
- if (check_col(pinfo->cinfo, COL_INFO)) {
- col_append_str(pinfo->cinfo, COL_INFO, (gchar*) ndps_program_string);
- col_append_str(pinfo->cinfo, COL_INFO, ", ");
+
+ request_value = ndps_hash_insert(conversation, ndps_xid);
+ request_value->ndps_prog = ndps_prog;
+ request_value->ndps_func = ndps_func;
+ }
+ switch(ndps_prog)
+ {
+ case 0x060976: /* Print */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind PSM */
+ break;
+ case 0x00000002: /* Bind PA */
+ cred_type = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_cred_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_server_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ if(name_len == 0)
+ {
+ foffset += 2;
}
+ else
+ {
+ foffset += 4;
+ }
+ proto_tree_add_uint(ndps_tree, hf_ndps_connection, tvb, foffset,
+ 2, tvb_get_ntohs(tvb, foffset));
+ foffset += 2;
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_pa_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ foffset += 8; /* Don't know what these 8 bytes signify */
+ proto_tree_add_uint(ndps_tree, hf_ndps_items, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ foffset += 4;
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_context, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_tree, tvb, foffset,
+ name_len, buffer);
+ break;
+ case 0x00000003: /* Unbind */
+ proto_tree_add_uint(ndps_tree, hf_ndps_object, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ break;
+ case 0x00000004: /* Print */
+ case 0x00000005: /* Modify Job */
+ case 0x00000006: /* Cancel Job */
+ break;
+ case 0x00000007: /* List Object Attributes */
+ proto_tree_add_uint(ndps_tree, hf_ndps_object, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ break;
+ case 0x00000008: /* Promote Job */
+ case 0x00000009: /* Interrupt */
+ case 0x0000000a: /* Pause */
+ case 0x0000000b: /* Resume */
+ case 0x0000000c: /* Clean */
+ case 0x0000000d: /* Create */
+ case 0x0000000e: /* Delete */
+ case 0x0000000f: /* Disable PA */
+ case 0x00000010: /* Enable PA */
+ case 0x00000011: /* Resubmit Jobs */
+ case 0x00000012: /* Set */
+ case 0x00000013: /* Shutdown PA */
+ case 0x00000014: /* Startup PA */
+ case 0x00000015: /* Reorder Job */
+ case 0x00000016: /* Pause PA */
+ case 0x00000017: /* Resume PA */
+ case 0x00000018: /* Transfer Data */
+ case 0x00000019: /* Device Control */
+ case 0x0000001a: /* Add Event Profile */
+ case 0x0000001b: /* Remove Event Profile */
+ case 0x0000001c: /* Modify Event Profile */
+ case 0x0000001d: /* List Event Profiles */
+ case 0x0000001e: /* Shutdown PSM */
+ case 0x0000001f: /* Cancel PSM Shutdown */
+ case 0x00000020: /* Set Printer DS Information */
+ case 0x00000021: /* Clean User Jobs */
+ case 0x00000022: /* Map GUID to NDS Name */
+ default:
+ break;
}
- foffset += 4;
- if (tree) {
- proto_tree_add_item(ndps_tree, hf_spx_ndps_version, tvb,
- foffset, 4, FALSE);
+ break;
+ case 0x060977: /* Broker */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind */
+ case 0x00000002: /* Unbind */
+ case 0x00000003: /* List Services */
+ case 0x00000004: /* Enable Service */
+ case 0x00000005: /* Disable Service */
+ case 0x00000006: /* Down Broker */
+ case 0x00000007: /* Get Broker NDS Object Name */
+ case 0x00000008: /* Get Broker Session Information */
+ default:
+ break;
}
- foffset += 4;
- ndps_func = tvb_get_ntohl(tvb, foffset);
- switch (ndps_prog) {
-
- case 0x060976:
- ndps_hfname = hf_spx_ndps_func_print;
- ndps_func_string = match_strval(ndps_func, spx_ndps_print_func_vals);
+ break;
+ case 0x060978: /* Registry */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind */
+ case 0x00000002: /* Unbind */
+ case 0x00000003: /* Register Server */
+ case 0x00000004: /* Deregister Server */
+ case 0x00000005: /* Register Registry */
+ case 0x00000006: /* Deregister Registry */
+ case 0x00000007: /* Registry Update */
+ case 0x00000008: /* List Local Servers */
+ case 0x00000009: /* List Servers */
+ case 0x0000000a: /* List Known Registries */
+ case 0x0000000b: /* Get Registry NDS Object Name */
+ case 0x0000000c: /* Get Registry Session Information */
+ default:
break;
-
- case 0x060977:
- ndps_hfname = hf_spx_ndps_func_broker;
- ndps_func_string = match_strval(ndps_func, spx_ndps_broker_func_vals);
+ }
+ break;
+ case 0x060979: /* Notify */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Notify Bind */
+ case 0x00000002: /* Notify Unbind */
+ case 0x00000003: /* Register Supplier */
+ case 0x00000004: /* Deregister Supplier */
+ case 0x00000005: /* Add Profile */
+ case 0x00000006: /* Remove Profile */
+ case 0x00000007: /* Modify Profile */
+ case 0x00000008: /* List Profiles */
+ case 0x00000009: /* Report Event */
+ case 0x0000000a: /* List Supported Languages */
+ case 0x0000000b: /* Report Notification */
+ case 0x0000000c: /* Add Delivery Method */
+ case 0x0000000d: /* Remove Delivery Method */
+ case 0x0000000e: /* List Delivery Methods */
+ case 0x0000000f: /* Get Delivery Method Information */
+ case 0x00000010: /* Get Notify NDS Object Name */
+ case 0x00000011: /* Get Notify Session Information */
+ default:
break;
-
- case 0x060978:
- ndps_hfname = hf_spx_ndps_func_registry;
- ndps_func_string = match_strval(ndps_func, spx_ndps_registry_func_vals);
+ }
+ break;
+ case 0x06097a: /* Resman */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind */
+ proto_tree_add_uint(ndps_tree, hf_ndps_cred_type, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ foffset += 4;
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_server_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ if(name_len == 0)
+ {
+ foffset += 2;
+ }
+ foffset += 2;
+ proto_tree_add_uint(ndps_tree, hf_ndps_connection, tvb, foffset,
+ 2, tvb_get_ntohs(tvb, foffset));
+ foffset += 2;
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_pa_name, tvb, foffset,
+ name_len, buffer);
break;
-
- case 0x060979:
- ndps_hfname = hf_spx_ndps_func_notify;
- ndps_func_string = match_strval(ndps_func, spx_ndps_notify_func_vals);
+ case 0x00000002: /* Unbind */
+ case 0x00000003: /* Add Resource File */
+ case 0x00000004: /* Delete Resource File */
+ case 0x00000005: /* List Resources */
+ case 0x00000006: /* Get Resource File */
+ case 0x00000007: /* Get Resource File Data */
+ case 0x00000008: /* Get Resource Manager NDS Object Name */
+ case 0x00000009: /* Get Resource Manager Session Information */
+ default:
break;
-
- case 0x06097a:
- ndps_hfname = hf_spx_ndps_func_resman;
- ndps_func_string = match_strval(ndps_func, spx_ndps_resman_func_vals);
+ }
+ break;
+ case 0x06097b: /* Delivery */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Delivery Bind */
+ case 0x00000002: /* Delivery Unbind */
+ case 0x00000003: /* Delivery Send */
+ case 0x00000004: /* Delivery Send2 */
+ default:
break;
+ }
+ break;
+ default:
+ break;
+ }
+ /*proto_tree_add_uint_format(ndps_tree, hf_ndps_xid, tvb, 0,
+ 0, ndps_xid, "This is a Request Packet, XID %08x, Prog %08x, Func %08x", ndps_xid, ndps_prog, ndps_func);*/
+ return;
+}
- case 0x06097b:
- ndps_hfname = hf_spx_ndps_func_delivery;
- ndps_func_string = match_strval(ndps_func, spx_ndps_deliver_func_vals);
+static void
+dissect_ndps_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *ndps_tree, guint32 ndps_xid, int foffset)
+{
+ conversation_t *conversation = NULL;
+ ndps_req_hash_value *request_value = NULL;
+ proto_tree *atree;
+ proto_item *aitem;
+ guint8 i;
+ guint8 number_of_items=0;
+ guint32 ndps_func=0;
+ guint32 ndps_prog=0;
+ guint32 error_val=0;
+ guint32 name_len=0;
+ guint32 problem_type=0;
+ char buffer[1024];
+
+ if (!pinfo->fd->flags.visited) {
+ /* Find the conversation whence the request would have come. */
+ conversation = find_conversation(&pinfo->src, &pinfo->dst,
+ PT_NONE, ndps_xid, ndps_xid, 0);
+ if (conversation != NULL) {
+ /* find the record telling us the request made that caused
+ this reply */
+ request_value = ndps_hash_lookup(conversation, ndps_xid);
+ p_add_proto_data(pinfo->fd, proto_ndps, (void*) request_value);
+ }
+ /* else... we haven't seen an NDPS Request for that conversation. */
+ }
+ else {
+ request_value = p_get_proto_data(pinfo->fd, proto_ndps);
+ }
+ if (request_value) {
+ ndps_prog = request_value->ndps_prog;
+ ndps_func = request_value->ndps_func;
+ }
+ if (tvb_length_remaining(tvb, foffset) < 12)
+ {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, "- Ok");
+ return;
+ }
+ if(ndps_func != 7 && ndps_func != 4 && ndps_func != 8 )
+ {
+ proto_tree_add_item(ndps_tree, hf_ndps_rpc_acc_stat, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_rpc_acc_results, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ }
+ error_val = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_uint(ndps_tree, hf_ndps_error_val, tvb, foffset, 4, error_val);
+ foffset += 4;
+ if (error_val == 0) {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, "- Ok");
+ switch(ndps_prog)
+ {
+ case 0x060976: /* Print */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind PSM */
+ break;
+ case 0x00000002: /* Bind PA */
+ proto_tree_add_item(ndps_tree, hf_ndps_object, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_ndps_pa_name, tvb, foffset,
+ name_len, buffer);
+ break;
+ case 0x00000003: /* Unbind */
+ case 0x00000004: /* Print */
+ case 0x00000005: /* Modify Job */
+ case 0x00000006: /* Cancel Job */
+ break;
+ case 0x00000007: /* List Object Attributes */
+ proto_tree_add_item(ndps_tree, hf_ndps_session, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ number_of_items=tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ foffset += 1;
+ }
+ foffset += align_4(tvb, foffset);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_abort_flag, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);
+ foffset = attribute_value(tvb, ndps_tree, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_qualifier, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ /*foffset = attribute_value(tvb, ndps_tree, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_scope, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);*/
+ break;
+ case 0x00000008: /* Promote Job */
+ case 0x00000009: /* Interrupt */
+ case 0x0000000a: /* Pause */
+ case 0x0000000b: /* Resume */
+ case 0x0000000c: /* Clean */
+ case 0x0000000d: /* Create */
+ case 0x0000000e: /* Delete */
+ case 0x0000000f: /* Disable PA */
+ case 0x00000010: /* Enable PA */
+ case 0x00000011: /* Resubmit Jobs */
+ case 0x00000012: /* Set */
+ case 0x00000013: /* Shutdown PA */
+ case 0x00000014: /* Startup PA */
+ case 0x00000015: /* Reorder Job */
+ case 0x00000016: /* Pause PA */
+ case 0x00000017: /* Resume PA */
+ case 0x00000018: /* Transfer Data */
+ case 0x00000019: /* Device Control */
+ case 0x0000001a: /* Add Event Profile */
+ case 0x0000001b: /* Remove Event Profile */
+ case 0x0000001c: /* Modify Event Profile */
+ case 0x0000001d: /* List Event Profiles */
+ case 0x0000001e: /* Shutdown PSM */
+ case 0x0000001f: /* Cancel PSM Shutdown */
+ case 0x00000020: /* Set Printer DS Information */
+ case 0x00000021: /* Clean User Jobs */
+ case 0x00000022: /* Map GUID to NDS Name */
+ default:
+ break;
+ }
+ break;
+ case 0x060977: /* Broker */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind */
+ case 0x00000002: /* Unbind */
+ case 0x00000003: /* List Services */
+ case 0x00000004: /* Enable Service */
+ case 0x00000005: /* Disable Service */
+ case 0x00000006: /* Down Broker */
+ case 0x00000007: /* Get Broker NDS Object Name */
+ case 0x00000008: /* Get Broker Session Information */
+ default:
+ break;
+ }
+ break;
+ case 0x060978: /* Registry */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind */
+ case 0x00000002: /* Unbind */
+ case 0x00000003: /* Register Server */
+ case 0x00000004: /* Deregister Server */
+ case 0x00000005: /* Register Registry */
+ case 0x00000006: /* Deregister Registry */
+ case 0x00000007: /* Registry Update */
+ case 0x00000008: /* List Local Servers */
+ case 0x00000009: /* List Servers */
+ case 0x0000000a: /* List Known Registries */
+ case 0x0000000b: /* Get Registry NDS Object Name */
+ case 0x0000000c: /* Get Registry Session Information */
+ default:
+ break;
+ }
+ break;
+ case 0x060979: /* Notify */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Notify Bind */
+ case 0x00000002: /* Notify Unbind */
+ case 0x00000003: /* Register Supplier */
+ case 0x00000004: /* Deregister Supplier */
+ case 0x00000005: /* Add Profile */
+ case 0x00000006: /* Remove Profile */
+ case 0x00000007: /* Modify Profile */
+ case 0x00000008: /* List Profiles */
+ case 0x00000009: /* Report Event */
+ case 0x0000000a: /* List Supported Languages */
+ case 0x0000000b: /* Report Notification */
+ case 0x0000000c: /* Add Delivery Method */
+ case 0x0000000d: /* Remove Delivery Method */
+ case 0x0000000e: /* List Delivery Methods */
+ case 0x0000000f: /* Get Delivery Method Information */
+ case 0x00000010: /* Get Notify NDS Object Name */
+ case 0x00000011: /* Get Notify Session Information */
+ default:
+ break;
+ }
+ break;
+ case 0x06097a: /* Resman */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Bind */
+ break;
+ case 0x00000002: /* Unbind */
+ case 0x00000003: /* Add Resource File */
+ case 0x00000004: /* Delete Resource File */
+ case 0x00000005: /* List Resources */
+ case 0x00000006: /* Get Resource File */
+ case 0x00000007: /* Get Resource File Data */
+ case 0x00000008: /* Get Resource Manager NDS Object Name */
+ case 0x00000009: /* Get Resource Manager Session Information */
+ default:
+ break;
+ }
+ break;
+ case 0x06097b: /* Delivery */
+ switch(ndps_func)
+ {
+ case 0x00000001: /* Delivery Bind */
+ case 0x00000002: /* Delivery Unbind */
+ case 0x00000003: /* Delivery Send */
+ case 0x00000004: /* Delivery Send2 */
+ default:
+ break;
+ }
break;
-
default:
- ndps_hfname = 0;
- ndps_func_string = NULL;
break;
}
- if (ndps_hfname != 0) {
- if (tree) {
- proto_tree_add_uint(ndps_tree, ndps_hfname, tvb,
- foffset, 4, ndps_func);
+ }
+ else
+ {
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_append_str(pinfo->cinfo, COL_INFO, "- Error");
+ problem_type = tvb_get_ntohl(tvb, foffset);
+ proto_tree_add_item(ndps_tree, hf_ndps_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ switch(problem_type)
+ {
+ case 0: /* Security Error */
+ proto_tree_add_item(ndps_tree, hf_security_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);
+ break;
+ case 1: /* Service Error */
+ proto_tree_add_item(ndps_tree, hf_service_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ foffset += 8;
+ if (tvb_get_ntohl(tvb, foffset-4) != 0) {
+ foffset = objectident(tvb, ndps_tree, foffset);
}
- if (ndps_func_string != NULL) {
- if (check_col(pinfo->cinfo, COL_INFO))
- col_append_str(pinfo->cinfo, COL_INFO, (gchar*) ndps_func_string);
- }
- } else {
- if (tree) {
- proto_tree_add_text(ndps_tree, tvb, foffset, 4,
- "NDPS Function: 0x%08x", ndps_func);
+ proto_tree_add_item(ndps_tree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_qualifier, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_lib_error, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_other_error, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_item(ndps_tree, hf_ndps_other_error_2, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ break;
+ case 2: /* Access Error */
+ proto_tree_add_item(ndps_tree, hf_access_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ proto_tree_add_uint(ndps_tree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ proto_tree_add_uint(ndps_tree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 3: /* Printer Error */
+ proto_tree_add_item(ndps_tree, hf_printer_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ proto_tree_add_uint(ndps_tree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 4: /* Selection Error */
+ proto_tree_add_item(ndps_tree, hf_selection_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);
+ /*if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ proto_tree_add_uint(ndps_tree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset);*/ /* Need to decode later */
+ /*if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
}
+ foffset += 4;
+ proto_tree_add_uint(ndps_tree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset); */
+ break;
+ case 5: /* Document Access Error */
+ proto_tree_add_item(ndps_tree, hf_doc_access_problem_type, tvb, foffset, 4, FALSE);
+ foffset = objectident(tvb, ndps_tree, foffset);
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ proto_tree_add_uint(ndps_tree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ case 6: /* Attribute Error */
+ proto_tree_add_item(ndps_tree, hf_attribute_problem_type, tvb, foffset, 4, FALSE);
+ foffset += 4;
+ aitem = proto_tree_add_uint(ndps_tree, hf_ndps_item_count, tvb, foffset, 4, FALSE);
+ atree = proto_item_add_subtree(aitem, ett_ndps);
+ foffset += 4;
+ for (i = 1 ; i <= number_of_items; i++ )
+ {
+ proto_tree_add_uint(atree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ proto_tree_add_uint(atree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(atree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ foffset = objectident(tvb, atree, foffset);
+ }
+ break;
+ case 7: /* Update Error */
+ proto_tree_add_item(ndps_tree, hf_update_problem_type, tvb, foffset, 4, FALSE);
+ proto_tree_add_uint(ndps_tree, hf_oid_struct_size, tvb, foffset, 4, FALSE);
+ foffset += tvb_get_ntohl(tvb, foffset); /* Need to decode later */
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ foffset += 4;
+ foffset = objectident(tvb, ndps_tree, foffset);
+ if (foffset > tvb_length_remaining(tvb, foffset)) {
+ break;
+ }
+ proto_tree_add_uint(ndps_tree, hf_ndps_nameorid, tvb, foffset,
+ 4, tvb_get_ntohl(tvb, foffset));
+ name_len = tvb_get_ntohl(tvb, foffset);
+ foffset += 4;
+ get_string(tvb, foffset, name_len, buffer);
+ proto_tree_add_string(ndps_tree, hf_local_object_name, tvb, foffset,
+ name_len, buffer);
+ foffset += name_len;
+ foffset += align_4(tvb, foffset);
+ break;
+ default:
+ break;
}
- next_tvb = tvb_new_subset(tvb, foffset, -1, -1);
- call_dissector(ndps_data_handle,next_tvb, pinfo, tree);
}
+ proto_tree_add_uint_format(ndps_tree, hf_ndps_xid, tvb, 0,
+ 0, ndps_xid, "This is a Reply Packet, XID %08x, Prog %08x, Func %08x", ndps_xid, ndps_prog, ndps_func);
+ return;
}
void
proto_register_ndps(void)
{
static hf_register_info hf_ndps[] = {
- { &hf_ndps_record_mark,
- { "Record Mark", "ndps.record_mark",
- FT_BOOLEAN, BASE_HEX, NULL, 0x80,
- "", HFILL }},
+ { &hf_ndps_record_mark,
+ { "Record Mark", "ndps.record_mark", FT_UINT16, BASE_HEX, NULL, 0x0,
+ "Record Mark", HFILL }},
{ &hf_ndps_packet_type,
{ "Packet Type", "ndps.packet_type",
@@ -689,11 +2835,11 @@ proto_register_ndps(void)
{ &hf_ndps_length,
{ "Record Length", "ndps.record_length",
- FT_UINT16, BASE_DEC, NULL, 0x0,
+ FT_UINT16, BASE_HEX, NULL, 0x0,
"Record Length", HFILL }},
{ &hf_ndps_xid,
- { "Exhange ID", "ndps.xid",
+ { "Exchange ID", "ndps.xid",
FT_UINT32, BASE_HEX, NULL, 0x0,
"Exchange ID", HFILL }},
@@ -745,18 +2891,392 @@ proto_register_ndps(void)
{ &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", HFILL }},
+
+ { &hf_ndps_items,
+ { "Number of Items", "ndps.items",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Number of Items", HFILL }},
+
+ { &hf_ndps_sbuffer,
+ { "Server", "ndps.sbuffer",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Server", HFILL }},
+
+ { &hf_ndps_rbuffer,
+ { "Connection", "ndps.rbuffer",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Connection", HFILL }},
+
+ { &hf_ndps_pa_name,
+ { "Trustee Name", "ndps.pa_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ "Trustee Name", HFILL }},
+
+ { &hf_ndps_context,
+ { "Printer Name", "ndps.context",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ "Printer Name", HFILL }},
+
+ { &hf_ndps_tree,
+ { "Tree", "ndps.tree",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ "Tree", HFILL }},
+
+ { &hf_ndps_error_val,
+ { "Return Status", "ndps.error_val",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Return Status", HFILL }},
+
+ { &hf_ndps_object,
+ { "Object ID", "ndps.object",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Object ID", HFILL }},
+
+ { &hf_ndps_cred_type,
+ { "Credential Type", "ndps.cred_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_credential_enum), 0x0,
+ "Credential Type", HFILL }},
+
+ { &hf_ndps_server_name,
+ { "Server Name", "ndps.server_name",
+ FT_STRING, BASE_DEC, NULL, 0x0,
+ "Server Name", HFILL }},
+
+ { &hf_ndps_connection,
+ { "Connection", "ndps.connection",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ "Connection", HFILL }},
+
+ { &hf_ndps_ext_error,
+ { "Extended Return Status", "ndps.ext_error",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Extended Return Status", HFILL }},
+
+ { &hf_ndps_auth_null,
+ { "Auth Null", "ndps.auth_null",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Auth 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 }},
+
+ { &hf_ndps_rpc_acc_stat,
+ { "RPC Accept Status", "ndps.rpc_acc_stat",
+ FT_UINT32, BASE_HEX, VALS(accept_stat), 0x0,
+ "RPC Accept Status", 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 }},
+
+ { &hf_ndps_rpc_acc_results,
+ { "RPC Accept Results", "ndps.rpc_acc_res",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "RPC Accept Results", HFILL }},
+
+ { &hf_ndps_problem_type,
+ { "Problem Type", "ndps.rpc_prob_type",
+ FT_UINT32, BASE_HEX, VALS(error_type_enum), 0x0,
+ "Problem Type", HFILL }},
+
+ { &hf_security_problem_type,
+ { "Security Problem", "ndps.rpc_sec_prob",
+ FT_UINT32, BASE_HEX, VALS(security_problem_enum), 0x0,
+ "Security Problem", HFILL }},
+
+ { &hf_service_problem_type,
+ { "Service Problem", "ndps.rpc_serv_prob",
+ FT_UINT32, BASE_HEX, VALS(service_problem_enum), 0x0,
+ "Service Problem", HFILL }},
+
+ { &hf_access_problem_type,
+ { "Access Problem", "ndps.rpc_acc_prob",
+ FT_UINT32, BASE_HEX, VALS(access_problem_enum), 0x0,
+ "Access Problem", HFILL }},
+
+ { &hf_printer_problem_type,
+ { "Printer Problem", "ndps.rpc_print_prob",
+ FT_UINT32, BASE_HEX, VALS(printer_problem_enum), 0x0,
+ "Printer Problem", HFILL }},
+
+ { &hf_selection_problem_type,
+ { "Selection Problem", "ndps.rpc_sel_prob",
+ FT_UINT32, BASE_HEX, VALS(selection_problem_enum), 0x0,
+ "Selection Problem", 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 }},
+
+ { &hf_attribute_problem_type,
+ { "Attribute Problem", "ndps.rpc_attr_prob",
+ FT_UINT32, BASE_HEX, VALS(attribute_problem_enum), 0x0,
+ "Attribute Problem", HFILL }},
+
+ { &hf_update_problem_type,
+ { "Update Problem", "ndps.rpc_update_prob",
+ FT_UINT32, BASE_HEX, VALS(update_problem_enum), 0x0,
+ "Update Problem", 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 }},
+
+ { &hf_oid_struct_size,
+ { "OID Struct Size", "ndps.rpc_oid_struct_size",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "OID Struct Size", HFILL }},
+
+ { &hf_object_name,
+ { "Object Name", "ndps.ndps_object_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ "Object Name", HFILL }},
+
+ { &hf_ndps_document_number,
+ { "Document Number", "ndps.ndps_doc_num",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Document Number", HFILL }},
+
+ { &hf_ndps_nameorid,
+ { "Name or ID Type", "ndps.ndps_nameorid",
+ FT_UINT32, BASE_HEX, VALS(nameorid_enum), 0x0,
+ "Name or ID Type", HFILL }},
+
+ { &hf_local_object_name,
+ { "Local Object Name", "ndps.ndps_loc_object_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ "Local Object Name", HFILL }},
- static gint *ett[] = {
- &ett_ndps,
+ { &hf_printer_name,
+ { "Printer Name", "ndps.ndps_printer_name",
+ FT_STRING, BASE_NONE, NULL, 0x0,
+ "Printer Name", 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 }},
+
+ { &hf_ndps_item_count,
+ { "Number of Items", "ndps.ndps_item_count",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Number of Items", HFILL }},
+
+ { &hf_ndps_qualifier,
+ { "Qualifier", "ndps.ndps_qual",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Qualifier", HFILL }},
+
+ { &hf_ndps_lib_error,
+ { "Lib Error", "ndps.ndps_lib_error",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ "Lib Error", HFILL }},
+
+ { &hf_ndps_other_error,
+ { "Other Error", "ndps.ndps_other_error",
+ FT_UINT32, BASE_HEX, VALS(ndps_error_types), 0x0,
+ "Other Error", 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 }},
+
+ { &hf_ndps_session,
+ { "Session", "ndps.ndps_session",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Session", HFILL }},
+
+ { &hf_ndps_abort_flag,
+ { "Abort?", "ndps.ndps_abort",
+ FT_BOOLEAN, BASE_HEX, NULL, 0x0,
+ "Abort?", HFILL }},
+
+ { &hf_obj_attribute_type,
+ { "Attribute Type", "ndps.ndps_attrib_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_attribute_enum), 0x0,
+ "Attribute Type", HFILL }},
+
+ { &hf_ndps_attribute_value,
+ { "Value", "ndps.attribue_value",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Value", HFILL }},
+
+ { &hf_ndps_lower_range,
+ { "Lower Range", "ndps.lower_range",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Lower Range", HFILL }},
+
+ { &hf_ndps_upper_range,
+ { "Upper Range", "ndps.upper_range",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Upper Range", HFILL }},
+
+ { &hf_ndps_n64,
+ { "Value", "ndps.n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Value", HFILL }},
+
+ { &hf_ndps_lower_range_n64,
+ { "Lower Range", "ndps.lower_range_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Lower Range", HFILL }},
+
+ { &hf_ndps_upper_range_n64,
+ { "Upper Range", "ndps.upper_range_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Upper Range", HFILL }},
+
+ { &hf_ndps_attrib_boolean,
+ { "Value?", "ndps.ndps_attrib_boolean",
+ FT_BOOLEAN, BASE_HEX, NULL, 0x0,
+ "Value?", HFILL }},
+
+ { &hf_ndps_realization,
+ { "Realization Type", "ndps.ndps_realization",
+ FT_UINT32, BASE_HEX, VALS(ndps_realization_enum), 0x0,
+ "Realization Type", HFILL }},
+
+ { &hf_ndps_xdimension_n64,
+ { "X Dimension", "ndps.xdimension_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "X Dimension", HFILL }},
+
+ { &hf_ndps_ydimension_n64,
+ { "Y Dimension", "ndps.xdimension_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Y Dimension", 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 }},
+
+ { &hf_ndps_dim_flag,
+ { "Dimension Flag", "ndps.ndps_dim_falg",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Dimension Flag", 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 }},
+
+ { &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 }},
+
+ { &hf_ndps_xmin_n64,
+ { "Minimum X Dimension", "ndps.xmin_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Minimum X Dimension", HFILL }},
+
+ { &hf_ndps_xmax_n64,
+ { "Maximum X Dimension", "ndps.xmax_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Maximum X Dimension", HFILL }},
+
+ { &hf_ndps_ymin_n64,
+ { "Minimum Y Dimension", "ndps.ymin_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Minimum Y Dimension", HFILL }},
+
+ { &hf_ndps_ymax_n64,
+ { "Maximum Y Dimension", "ndps.ymax_n64",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Maximum Y Dimension", HFILL }},
+
+ { &hf_ndps_edge_value,
+ { "Edge Value", "ndps.ndps_edge_value",
+ FT_UINT32, BASE_HEX, VALS(ndps_edge_value_enum), 0x0,
+ "Edge Value", 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 }},
+
+ { &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 }},
+
+ { &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 }},
+
+ { &hf_ndps_profile_id,
+ { "Profile ID", "ndps.ndps_profile_id",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Profile ID", HFILL }},
+
+ { &hf_ndps_persistence,
+ { "Persistence", "ndps.ndps_persistence",
+ FT_UINT32, BASE_HEX, VALS(ndps_persistence_enum), 0x0,
+ "Persistence", HFILL }},
+
+ { &hf_ndps_language_id,
+ { "Lanuage ID", "ndps.ndps_lang_id",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Language ID", HFILL }},
+
+ { &hf_address_type,
+ { "Address Type", "ndps.ndps_address_type",
+ FT_UINT32, BASE_HEX, VALS(ndps_address_type_enum), 0x0,
+ "Address Type", HFILL }},
+
+ { &hf_ndps_address,
+ { "Address", "ndps.ndps_address",
+ FT_UINT32, BASE_HEX, VALS(ndps_address_enum), 0x0,
+ "Address", HFILL }},
+
+ { &hf_ndps_add_bytes,
+ { "Address Length", "ndps.add_bytes",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Address Length", HFILL }},
+
+ { &hf_ndps_event_type,
+ { "Event Type", "ndps.ndps_event_type",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Event Type", 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 }},
+
+ { &hf_ndps_octet_string,
+ { "Octet String", "ndps.octet_string",
+ FT_BYTES, BASE_HEX, NULL, 0x0,
+ "Octet String", HFILL }},
+
+ { &hf_ndps_scope,
+ { "Scope", "ndps.scope",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ "Scope", HFILL }},
+
};
+
+
+ static gint *ett[] = {
+ &ett_ndps,
+ };
- 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));
+ 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));
+ register_init_routine(&ndps_init_protocol);
+ register_postseq_cleanup_routine(&ndps_postseq_cleanup);
}
void