ab5ca5e3ec5c50d83282afe9b07abe7aedb87a2d
[obnox/wireshark/wip.git] / packet-cops.c
1 /* packet-cops.c
2  * Routines for the COPS (Common Open Policy Service) protocol dissection
3  * RFC2748 & COPS-PR extension RFC3084
4  *
5  * Copyright 2000, Heikki Vatiainen <hessu@cs.tut.fi>
6  *
7  * $Id: packet-cops.c,v 1.38 2003/12/13 02:10:30 guy Exp $
8  *
9  * Ethereal - Network traffic analyzer
10  * By Gerald Combs <gerald@ethereal.com>
11  * Copyright 1998 Gerald Combs
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  */
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <ctype.h>
36
37 #include <glib.h>
38 #include <epan/packet.h>
39 #include "packet-ipv6.h"
40 #include "packet-tcp.h"
41
42 #ifdef HAVE_SOME_SNMP
43 #ifdef HAVE_NET_SNMP
44 # include <net-snmp/net-snmp-config.h>
45 # include <net-snmp/mib_api.h>
46 # include <net-snmp/library/default_store.h>
47 # include <net-snmp/config_api.h>
48 #else /* HAVE_NET_SNMP */
49 # include <ucd-snmp/ucd-snmp-config.h>
50 # include <ucd-snmp/asn1.h>
51 # include <ucd-snmp/snmp_api.h>
52 # include <ucd-snmp/snmp_impl.h>
53 # include <ucd-snmp/mib.h>
54 # include <ucd-snmp/default_store.h>
55 # include <ucd-snmp/read_config.h>
56 # include <ucd-snmp/tools.h>
57 #endif /* HAVE_NET_SNMP */
58 #endif /* HAVE_SOME_SNMP */
59
60 #include "asn1.h"
61 #include "format-oid.h"
62 #include "prefs.h"
63
64 #define TCP_PORT_COPS 3288
65
66 /* Preference: Variable to hold the tcp port preference */
67 static guint global_cops_tcp_port = TCP_PORT_COPS;
68
69 /* Preference: desegmentation of COPS */
70 static gboolean cops_desegment = TRUE;
71
72 /* Variable to allow for proper deletion of dissector registration
73  * when the user changes port from the gui
74  */
75
76 static guint cops_tcp_port = 0;
77
78 /*Some local globals needed to read COPS-PR ASN.1 Types from PIB-MIBs */
79 /*MAX_OID_LEN from NET-SNMP's asn1.h*/
80
81 #ifdef HAVE_NET_SNMP
82 static  subid_t last_decoded_prid_oid[MAX_OID_LEN]={0};
83 static  subid_t last_decoded_prid_oid_length=0;
84 extern struct tree *tree_head;
85
86 /* Preference: COPS-PR ASN.1 type decoding based on PIB/MIB or data in packet */
87 static gboolean cops_typefrommib = FALSE;
88
89 #endif /* HAVE_NET_SNMP */
90
91 #define COPS_OBJECT_HDR_SIZE 4
92
93 /* Null string of type "guchar[]". */
94 static const guchar nullstring[] = "";
95
96 #define SAFE_STRING(s)  (((s) != NULL) ? (s) : nullstring)
97
98 /* COPS PR Tags */
99
100 #define COPS_IPA    0           /* IP Address */
101 #define COPS_U32    2           /* Unsigned 32*/
102 #define COPS_TIT    3           /* TimeTicks */
103 #define COPS_OPQ    4           /* Opaque */
104 #define COPS_I64    10          /* Integer64 */
105 #define COPS_U64    11          /* Uinteger64 */
106
107 /* COPS PR Types */
108
109 #define COPS_NULL                0
110 #define COPS_INTEGER             1    /* l  */
111 #define COPS_OCTETSTR            2    /* c  */
112 #define COPS_OBJECTID            3    /* ul */
113 #define COPS_IPADDR              4    /* uc */
114 #define COPS_UNSIGNED32          5    /* ul */
115 #define COPS_TIMETICKS           7    /* ul */
116 #define COPS_OPAQUE              8    /* c  */
117 #define COPS_INTEGER64           10   /* ll */
118 #define COPS_UNSIGNED64          11   /* ull  */
119
120
121 typedef struct _COPS_CNV COPS_CNV;
122
123 struct _COPS_CNV
124 {
125   guint class;
126   guint tag;
127   gint  syntax;
128   gchar *name;
129 };
130
131 static COPS_CNV CopsCnv [] =
132 {
133   {ASN1_UNI, ASN1_NUL, COPS_NULL,      "NULL"},
134   {ASN1_UNI, ASN1_INT, COPS_INTEGER,   "INTEGER"},
135   {ASN1_UNI, ASN1_OTS, COPS_OCTETSTR,  "OCTET STRING"},
136   {ASN1_UNI, ASN1_OJI, COPS_OBJECTID,  "OBJECTID"},
137   {ASN1_APL, COPS_IPA, COPS_IPADDR,    "IPADDR"},
138   {ASN1_APL, COPS_U32, COPS_UNSIGNED32,"UNSIGNED32"},
139   {ASN1_APL, COPS_TIT, COPS_TIMETICKS, "TIMETICKS"},
140   {ASN1_APL, COPS_OPQ, COPS_OPAQUE,    "OPAQUE"},
141   {ASN1_APL, COPS_I64, COPS_INTEGER64, "INTEGER64"},
142   {ASN1_APL, COPS_U64, COPS_UNSIGNED64, "UNSIGNED64"},
143   {0,       0,         -1,                  NULL}
144 };
145
146 static gchar *
147 cops_tag_cls2syntax ( guint tag, guint cls, gushort *syntax)
148 {
149   COPS_CNV *cnv;
150
151   cnv = CopsCnv;
152   while (cnv->syntax != -1)
153   {
154     if (cnv->tag == tag && cnv->class == cls)
155     {
156       *syntax = cnv->syntax;
157       return cnv->name;
158     }
159     cnv++;
160   }
161   return NULL;
162 }
163
164 static const value_string cops_flags_vals[] = {
165   { 0x00,          "None" },
166   { 0x01,          "Solicited Message Flag Bit" },
167   { 0, NULL },
168 };
169
170 /* The different COPS message types */
171 enum cops_op_code {
172   COPS_NO_MSG,          /* Not a COPS Message type     */
173
174   COPS_MSG_REQ,         /* Request (REQ)               */
175   COPS_MSG_DEC,         /* Decision (DEC)              */
176   COPS_MSG_RPT,         /* Report State (RPT)          */
177   COPS_MSG_DRQ,         /* Delete Request State (DRQ)  */
178   COPS_MSG_SSQ,         /* Synchronize State Req (SSQ) */
179   COPS_MSG_OPN,         /* Client-Open (OPN)           */
180   COPS_MSG_CAT,         /* Client-Accept (CAT)         */
181   COPS_MSG_CC,          /* Client-Close (CC)           */
182   COPS_MSG_KA,          /* Keep-Alive (KA)             */
183   COPS_MSG_SSC,         /* Synchronize Complete (SSC)  */
184
185   COPS_LAST_OP_CODE     /* For error checking          */
186 };
187
188 static const value_string cops_op_code_vals[] = {
189   { COPS_MSG_REQ,          "Request (REQ)" },
190   { COPS_MSG_DEC,          "Decision (DEC)" },
191   { COPS_MSG_RPT,          "Report State (RPT)" },
192   { COPS_MSG_DRQ,          "Delete Request State (DRQ)" },
193   { COPS_MSG_SSQ,          "Synchronize State Req (SSQ)" },
194   { COPS_MSG_OPN,          "Client-Open (OPN)" },
195   { COPS_MSG_CAT,          "Client-Accept (CAT)" },
196   { COPS_MSG_CC,           "Client-Close (CC)" },
197   { COPS_MSG_KA,           "Keep-Alive (KA)" },
198   { COPS_MSG_SSC,          "Synchronize Complete (SSC)" },
199   { 0, NULL },
200 };
201
202
203 /* The different objects in COPS messages */
204 enum cops_c_num {
205   COPS_NO_OBJECT,        /* Not a COPS Object type               */
206
207   COPS_OBJ_HANDLE,       /* Handle Object (Handle)               */
208   COPS_OBJ_CONTEXT,      /* Context Object (Context)             */
209   COPS_OBJ_IN_INT,       /* In-Interface Object (IN-Int)         */
210   COPS_OBJ_OUT_INT,      /* Out-Interface Object (OUT-Int)       */
211   COPS_OBJ_REASON,       /* Reason Object (Reason)               */
212   COPS_OBJ_DECISION,     /* Decision Object (Decision)           */
213   COPS_OBJ_LPDPDECISION, /* LPDP Decision Object (LPDPDecision)  */
214   COPS_OBJ_ERROR,        /* Error Object (Error)                 */
215   COPS_OBJ_CLIENTSI,     /* Client Specific Information Object (ClientSI) */
216   COPS_OBJ_KATIMER,      /* Keep-Alive Timer Object (KATimer)    */
217   COPS_OBJ_PEPID,        /* PEP Identification Object (PEPID)    */
218   COPS_OBJ_REPORT_TYPE,  /* Report-Type Object (Report-Type)     */
219   COPS_OBJ_PDPREDIRADDR, /* PDP Redirect Address Object (PDPRedirAddr) */
220   COPS_OBJ_LASTPDPADDR,  /* Last PDP Address (LastPDPaddr)       */
221   COPS_OBJ_ACCTTIMER,    /* Accounting Timer Object (AcctTimer)  */
222   COPS_OBJ_INTEGRITY,    /* Message Integrity Object (Integrity) */
223   COPS_LAST_C_NUM        /* For error checking                   */
224 };
225
226 static const value_string cops_c_num_vals[] = {
227   { COPS_OBJ_HANDLE,       "Handle Object (Handle)" },
228   { COPS_OBJ_CONTEXT,      "Context Object (Context)" },
229   { COPS_OBJ_IN_INT,       "In-Interface Object (IN-Int)" },
230   { COPS_OBJ_OUT_INT,      "Out-Interface Object (OUT-Int)" },
231   { COPS_OBJ_REASON,       "Reason Object (Reason)" },
232   { COPS_OBJ_DECISION,     "Decision Object (Decision)" },
233   { COPS_OBJ_LPDPDECISION, "LPDP Decision Object (LPDPDecision)" },
234   { COPS_OBJ_ERROR,        "Error Object (Error)" },
235   { COPS_OBJ_CLIENTSI,     "Client Specific Information Object (ClientSI)" },
236   { COPS_OBJ_KATIMER,      "Keep-Alive Timer Object (KATimer)" },
237   { COPS_OBJ_PEPID,        "PEP Identification Object (PEPID)" },
238   { COPS_OBJ_REPORT_TYPE,  "Report-Type Object (Report-Type)" },
239   { COPS_OBJ_PDPREDIRADDR, "PDP Redirect Address Object (PDPRedirAddr)" },
240   { COPS_OBJ_LASTPDPADDR,  "Last PDP Address (LastPDPaddr)" },
241   { COPS_OBJ_ACCTTIMER,    "Accounting Timer Object (AcctTimer)" },
242   { COPS_OBJ_INTEGRITY,    "Message Integrity Object (Integrity)" },
243   { 0, NULL },
244 };
245
246
247 /* The different objects in COPS-PR messages */
248 enum cops_s_num {
249   COPS_NO_PR_OBJECT,     /* Not a COPS-PR Object type               */
250   COPS_OBJ_PRID,         /* Provisioning Instance Identifier (PRID) */
251   COPS_OBJ_PPRID,        /* Prefix Provisioning Instance Identifier (PPRID) */
252   COPS_OBJ_EPD,          /* Encoded Provisioning Instance Data (EPD) */
253   COPS_OBJ_GPERR,        /* Global Provisioning Error Object (GPERR) */
254   COPS_OBJ_CPERR,        /* PRC Class Provisioning Error Object (CPERR) */
255   COPS_OBJ_ERRPRID,      /* Error Provisioning Instance Identifier (ErrorPRID)*/
256
257   COPS_LAST_S_NUM        /* For error checking                   */
258 };
259
260
261 static const value_string cops_s_num_vals[] = {
262   { COPS_OBJ_PRID,         "Provisioning Instance Identifier (PRID)" },
263   { COPS_OBJ_PPRID,        "Prefix Provisioning Instance Identifier (PPRID)" },
264   { COPS_OBJ_EPD,          "Encoded Provisioning Instance Data (EPD)" },
265   { COPS_OBJ_GPERR,        "Global Provisioning Error Object (GPERR)" },
266   { COPS_OBJ_CPERR,        "PRC Class Provisioning Error Object (CPERR)" },
267   { COPS_OBJ_ERRPRID,      "Error Provisioning Instance Identifier (ErrorPRID)" },
268   { 0, NULL },
269
270 };
271
272 /* R-Type is carried within the Context Object */
273 static const value_string cops_r_type_vals[] = {
274   { 0x01, "Incoming-Message/Admission Control request" },
275   { 0x02, "Resource-Allocation request" },
276   { 0x04, "Outgoing-Message request" },
277   { 0x08, "Configuration request" },
278   { 0, NULL },
279 };
280 /* S-Type is carried within the ClientSI Object for COPS-PR*/
281 static const value_string cops_s_type_vals[] = {
282   { 0x01, "BER" },
283   { 0, NULL },
284 };
285
286 /* Reason-Code is carried within the Reason object */
287 static const value_string cops_reason_vals[] = {
288   { 1,  "Unspecified" },
289   { 2,  "Management" },
290   { 3,  "Preempted (Another request state takes precedence)" },
291   { 4,  "Tear (Used to communicate a signaled state removal)" },
292   { 5,  "Timeout (Local state has timed-out)" },
293   { 6,  "Route Change (Change invalidates request state)" },
294   { 7,  "Insufficient Resources (No local resource available)" },
295   { 8,  "PDP's Directive (PDP decision caused the delete)" },
296   { 9,  "Unsupported decision (PDP decision not supported)" },
297   { 10, "Synchronize Handle Unknown" },
298   { 11, "Transient Handle (stateless event)" },
299   { 12, "Malformed Decision (could not recover)" },
300   { 13, "Unknown COPS Object from PDP" },
301   { 0, NULL },
302 };
303
304 /* Command-Code is carried within the Decision object if C-Type is 1 */
305 static const value_string cops_dec_cmd_code_vals[] = {
306   { 0, "NULL Decision (No configuration data available)" },
307   { 1, "Install (Admit request/Install configuration)" },
308   { 2, "Remove (Remove request/Remove configuration)" },
309   { 0, NULL },
310 };
311
312 /* Decision flags are also carried with the Decision object if C-Type is 1 */
313 static const value_string cops_dec_cmd_flag_vals[] = {
314   { 0x00, "<None set>" },
315   { 0x01, "Trigger Error (Trigger error message if set)" },
316   { 0, NULL },
317 };
318
319 /* Error-Code from Error object */
320 static const value_string cops_error_vals[] = {
321   {1,  "Bad handle" },
322   {2,  "Invalid handle reference" },
323   {3,  "Bad message format (Malformed Message)" },
324   {4,  "Unable to process (server gives up on query)" },
325   {5,  "Mandatory client-specific info missing" },
326   {6,  "Unsupported client" },
327   {7,  "Mandatory COPS object missing" },
328   {8,  "Client Failure" },
329   {9,  "Communication Failure" },
330   {10, "Unspecified" },
331   {11, "Shutting down" },
332   {12, "Redirect to Preferred Server" },
333   {13, "Unknown COPS Object" },
334   {14, "Authentication Failure" },
335   {15, "Authentication Required" },
336   {0,  NULL },
337 };
338 /* Error-Code from GPERR object */
339 static const value_string cops_gperror_vals[] = {
340   {1,  "AvailMemLow" },
341   {2,  "AvailMemExhausted" },
342   {3,  "unknownASN.1Tag" },
343   {4,  "maxMsgSizeExceeded" },
344   {5,  "unknownError" },
345   {6,  "maxRequestStatesOpen" },
346   {7,  "invalidASN.1Length" },
347   {8,  "invalidObjectPad" },
348   {9,  "unknownPIBData" },
349   {10, "unknownCOPSPRObject" },
350   {11, "malformedDecision" },
351   {0,  NULL },
352 };
353
354 /* Error-Code from CPERR object */
355 static const value_string cops_cperror_vals[] = {
356   {1,  "priSpaceExhausted" },
357   {2,  "priInstanceInvalid" },
358   {3,  "attrValueInvalid" },
359   {4,  "attrValueSupLimited" },
360   {5,  "attrEnumSupLimited" },
361   {6,  "attrMaxLengthExceeded" },
362   {7,  "attrReferenceUnknown" },
363   {8,  "priNotifyOnly" },
364   {9,  "unknownPrc" },
365   {10, "tooFewAttrs" },
366   {11, "invalidAttrType" },
367   {12, "deletedInRef" },
368   {13, "priSpecificError" },
369         {0,  NULL },
370 };
371
372
373 /* Report-Type from Report-Type object */
374 static const value_string cops_report_type_vals[] = {
375   {1, " Success   : Decision was successful at the PEP" },
376   {2, " Failure   : Decision could not be completed by PEP" },
377   {3, " Accounting: Accounting update for an installed state" },
378   {0, NULL },
379 };
380
381 /* Initialize the protocol and registered fields */
382 static gint proto_cops = -1;
383 static gint hf_cops_ver_flags = -1;
384 static gint hf_cops_version = -1;
385 static gint hf_cops_flags = -1;
386
387 static gint hf_cops_op_code = -1;
388 static gint hf_cops_client_type = -1;
389 static gint hf_cops_msg_len = -1;
390
391 static gint hf_cops_obj_len = -1;
392 static gint hf_cops_obj_c_num = -1;
393 static gint hf_cops_obj_c_type = -1;
394
395 static gint hf_cops_obj_s_num = -1;
396 static gint hf_cops_obj_s_type = -1;
397
398 static gint hf_cops_r_type_flags = -1;
399 static gint hf_cops_m_type_flags = -1;
400
401 static gint hf_cops_in_int_ipv4 = -1;
402 static gint hf_cops_in_int_ipv6 = -1;
403 static gint hf_cops_out_int_ipv4 = -1;
404 static gint hf_cops_out_int_ipv6 = -1;
405 static gint hf_cops_int_ifindex = -1;
406
407 static gint hf_cops_reason = -1;
408 static gint hf_cops_reason_sub = -1;
409
410 static gint hf_cops_dec_cmd_code = -1;
411 static gint hf_cops_dec_flags = -1;
412
413 static gint hf_cops_error = -1;
414 static gint hf_cops_error_sub = -1;
415
416 static gint hf_cops_gperror = -1;
417 static gint hf_cops_gperror_sub = -1;
418
419 static gint hf_cops_cperror = -1;
420 static gint hf_cops_cperror_sub = -1;
421
422 static gint hf_cops_katimer = -1;
423
424 static gint hf_cops_pepid = -1;
425
426 static gint hf_cops_report_type = -1;
427
428 static gint hf_cops_pdprediraddr_ipv4 = -1;
429 static gint hf_cops_pdprediraddr_ipv6 = -1;
430 static gint hf_cops_lastpdpaddr_ipv4 = -1;
431 static gint hf_cops_lastpdpaddr_ipv6 = -1;
432 static gint hf_cops_pdp_tcp_port = -1;
433
434 static gint hf_cops_accttimer = -1;
435
436 static gint hf_cops_key_id = -1;
437 static gint hf_cops_seq_num = -1;
438
439 /* Initialize the subtree pointers */
440 static gint ett_cops = -1;
441 static gint ett_cops_ver_flags = -1;
442 static gint ett_cops_obj = -1;
443 static gint ett_cops_pr_obj = -1;
444 static gint ett_cops_obj_data = -1;
445 static gint ett_cops_r_type_flags = -1;
446 static gint ett_cops_itf = -1;
447 static gint ett_cops_reason = -1;
448 static gint ett_cops_decision = -1;
449 static gint ett_cops_error = -1;
450 static gint ett_cops_clientsi = -1;
451 static gint ett_cops_asn1 = -1;
452 static gint ett_cops_gperror = -1;
453 static gint ett_cops_cperror = -1;
454 static gint ett_cops_pdp = -1;
455
456 void proto_reg_handoff_cops(void);
457
458 static guint get_cops_pdu_len(tvbuff_t *tvb, int offset);
459 static void dissect_cops_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
460
461 static int dissect_cops_object(tvbuff_t *tvb, guint32 offset, proto_tree *tree);
462 static void dissect_cops_object_data(tvbuff_t *tvb, guint32 offset, proto_tree *tree,
463                                      guint8 c_num, guint8 c_type, guint16 len);
464
465 static void dissect_cops_pr_objects(tvbuff_t *tvb, guint32 offset, proto_tree *tree, guint16 pr_len);
466 static int dissect_cops_pr_object_data(tvbuff_t *tvb, guint32 offset, proto_tree *tree,
467                                        guint8 s_num, guint8 s_type, guint16 len);
468
469 /* Code to actually dissect the packets */
470 static void
471 dissect_cops(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
472 {
473   tcp_dissect_pdus(tvb, pinfo, tree, cops_desegment, 8,
474                    get_cops_pdu_len, dissect_cops_pdu);
475 }
476
477 static guint
478 get_cops_pdu_len(tvbuff_t *tvb, int offset)
479 {
480   /*
481    * Get the length of the COPS message.
482    */
483   return tvb_get_ntohl(tvb, offset + 4);
484 }
485
486 static void
487 dissect_cops_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
488 {
489   guint8 op_code;
490   int object_len;
491
492   if (check_col(pinfo->cinfo, COL_PROTOCOL))
493     col_set_str(pinfo->cinfo, COL_PROTOCOL, "COPS");
494   if (check_col(pinfo->cinfo, COL_INFO))
495     col_clear(pinfo->cinfo, COL_INFO);
496
497   op_code = tvb_get_guint8(tvb, 1);
498   if (check_col(pinfo->cinfo, COL_INFO))
499     col_add_fstr(pinfo->cinfo, COL_INFO, "COPS %s",
500                  val_to_str(op_code, cops_op_code_vals, "Unknown Op Code"));
501
502   if (tree) {
503     proto_item *ti, *tv;
504     proto_tree *cops_tree, *ver_flags_tree;
505     guint32 msg_len;
506     guint32 offset = 0;
507     guint8 ver_flags;
508     gint garbage;
509
510     ti = proto_tree_add_item(tree, proto_cops, tvb, offset, -1, FALSE);
511     cops_tree = proto_item_add_subtree(ti, ett_cops);
512
513     /* Version and flags share the same byte, put them in a subtree */
514     ver_flags = tvb_get_guint8(tvb, offset);
515     tv = proto_tree_add_uint_format(cops_tree, hf_cops_ver_flags, tvb, offset, 1,
516                                       ver_flags, "Version: %u, Flags: %s",
517                                       hi_nibble(ver_flags),
518                                       val_to_str(lo_nibble(ver_flags), cops_flags_vals, "Unknown"));
519     ver_flags_tree = proto_item_add_subtree(tv, ett_cops_ver_flags);
520     proto_tree_add_uint(ver_flags_tree, hf_cops_version, tvb, offset, 1, ver_flags);
521     proto_tree_add_uint(ver_flags_tree, hf_cops_flags, tvb, offset, 1, ver_flags);
522     offset++;
523
524     proto_tree_add_item(cops_tree, hf_cops_op_code, tvb, offset, 1, FALSE);
525     offset ++;
526     proto_tree_add_item(cops_tree, hf_cops_client_type, tvb, offset, 2, FALSE);
527     offset += 2;
528
529     msg_len = tvb_get_ntohl(tvb, offset);
530     proto_tree_add_uint(cops_tree, hf_cops_msg_len, tvb, offset, 4, msg_len);
531     offset += 4;
532
533     while (tvb_reported_length_remaining(tvb, offset) >= COPS_OBJECT_HDR_SIZE) {
534       object_len = dissect_cops_object(tvb, offset, cops_tree);
535       if (object_len < 0)
536         return;
537       offset += object_len;
538     }
539
540     garbage = tvb_length_remaining(tvb, offset);
541     if (garbage > 0)
542       proto_tree_add_text(cops_tree, tvb, offset, garbage,
543                           "Trailing garbage: %d byte%s", garbage,
544                           plurality(garbage, "", "s"));
545   }
546 }
547
548 static char *cops_c_type_to_str(guint8 c_num, guint8 c_type)
549 {
550   switch (c_num) {
551   case COPS_OBJ_HANDLE:
552     if (c_type == 1)
553       return "Client Handle";
554     break;
555   case COPS_OBJ_IN_INT:
556   case COPS_OBJ_OUT_INT:
557     if (c_type == 1)
558       return "IPv4 Address + Interface";
559     else if (c_type == 2)
560       return "IPv6 Address + Interface";
561     break;
562   case COPS_OBJ_DECISION:
563   case COPS_OBJ_LPDPDECISION:
564     if (c_type == 1)
565       return "Decision Flags (Mandatory)";
566     else if (c_type == 2)
567       return "Stateless Data";
568     else if (c_type == 3)
569       return "Replacement Data";
570     else if (c_type == 4)
571       return "Client Specific Decision Data";
572     else if (c_type == 5)
573       return "Named Decision Data";
574     break;
575   case COPS_OBJ_CLIENTSI:
576     if (c_type == 1)
577       return "Signaled ClientSI";
578     else if (c_type == 2)
579       return "Named ClientSI";
580     break;
581   case COPS_OBJ_KATIMER:
582     if (c_type == 1)
583       return "Keep-alive timer value";
584     break;
585   case COPS_OBJ_PDPREDIRADDR:
586   case COPS_OBJ_LASTPDPADDR:
587     if (c_type == 1)
588       return "IPv4 Address + TCP Port";
589     else if (c_type == 2)
590       return "IPv6 Address + TCP Port";
591     break;
592   case COPS_OBJ_ACCTTIMER:
593     if (c_type == 1)
594       return "Accounting timer value";
595     break;
596   case COPS_OBJ_INTEGRITY:
597     if (c_type == 1)
598       return "HMAC digest";
599     break;
600   }
601
602   return "";
603 }
604
605 static int dissect_cops_object(tvbuff_t *tvb, guint32 offset, proto_tree *tree)
606 {
607   guint16 object_len, contents_len;
608   guint8 c_num, c_type;
609   proto_item *ti;
610   proto_tree *obj_tree;
611   char *type_str;
612
613   object_len = tvb_get_ntohs(tvb, offset);
614   if (object_len < COPS_OBJECT_HDR_SIZE) {
615     /* Bogus! */
616     proto_tree_add_text(tree, tvb, offset, 2,
617                         "Bad COPS object length: %u, should be at least %u\n",
618                         object_len, COPS_OBJECT_HDR_SIZE);
619     return -1;
620   }
621   c_num = tvb_get_guint8(tvb, offset + 2);
622   c_type = tvb_get_guint8(tvb, offset + 3);
623
624   ti = proto_tree_add_uint_format(tree, hf_cops_obj_c_num, tvb, offset, object_len, c_num,
625                                   "%s: %s", val_to_str(c_num, cops_c_num_vals, "Unknown"),
626                                   cops_c_type_to_str(c_num, c_type));
627   obj_tree = proto_item_add_subtree(ti, ett_cops_obj);
628
629   proto_tree_add_uint(obj_tree, hf_cops_obj_len, tvb, offset, 2, object_len);
630   offset += 2;
631
632   proto_tree_add_uint(obj_tree, hf_cops_obj_c_num, tvb, offset, 1, c_num);
633   offset++;
634
635   type_str = cops_c_type_to_str(c_num, c_type);
636   proto_tree_add_text(obj_tree, tvb, offset, 1, "C-Type: %s%s%u%s",
637                       type_str,
638                       strlen(type_str) ? " (" : "",
639                       c_type,
640                       strlen(type_str) ? ")" : "");
641   offset++;
642
643   contents_len = object_len - COPS_OBJECT_HDR_SIZE;
644   dissect_cops_object_data(tvb, offset, obj_tree, c_num, c_type, contents_len);
645
646   /* Pad to 32bit boundary */
647   if (object_len % sizeof (guint32))
648     object_len += (sizeof (guint32) - object_len % sizeof (guint32));
649
650   return object_len;
651 }
652
653 static void dissect_cops_pr_objects(tvbuff_t *tvb, guint32 offset, proto_tree *tree, guint16 pr_len)
654 {
655   guint16 object_len, contents_len;
656   guint8 s_num, s_type;
657   char *type_str;
658   int ret;
659   proto_tree *cops_pr_tree, *obj_tree;
660   proto_item *ti;
661
662   cops_pr_tree = proto_item_add_subtree(tree, ett_cops_pr_obj);
663
664   while (pr_len >= COPS_OBJECT_HDR_SIZE) {
665     object_len = tvb_get_ntohs(tvb, offset);
666     if (object_len < COPS_OBJECT_HDR_SIZE) {
667       /* Bogus! */
668       proto_tree_add_text(tree, tvb, offset, 2,
669                           "Bad COPS PR object length: %u, should be at least %u\n",
670                           object_len, COPS_OBJECT_HDR_SIZE);
671       return;
672     }
673     s_num = tvb_get_guint8(tvb, offset + 2);
674
675     ti = proto_tree_add_uint_format(cops_pr_tree, hf_cops_obj_s_num, tvb, offset, object_len, s_num,
676                                     "%s", val_to_str(s_num, cops_s_num_vals, "Unknown"));
677     obj_tree = proto_item_add_subtree(cops_pr_tree, ett_cops_pr_obj);
678
679     proto_tree_add_uint(obj_tree, hf_cops_obj_len, tvb, offset, 2, object_len);
680     offset += 2;
681     pr_len -= 2;
682
683     proto_tree_add_uint(obj_tree, hf_cops_obj_s_num, tvb, offset, 1, s_num);
684     offset++;
685     pr_len--;
686
687     s_type = tvb_get_guint8(tvb, offset);
688     type_str = val_to_str(s_type, cops_s_type_vals, "Unknown");
689     proto_tree_add_text(obj_tree, tvb, offset, 1, "S-Type: %s%s%u%s",
690                         type_str,
691                         strlen(type_str) ? " (" : "",
692                         s_type,
693                         strlen(type_str) ? ")" : "");
694     offset++;
695     pr_len--;
696
697     contents_len = object_len - COPS_OBJECT_HDR_SIZE;
698     ret = dissect_cops_pr_object_data(tvb, offset, obj_tree, s_num, s_type, contents_len);
699     if (ret < 0)
700       break;
701
702     /*Pad to 32bit boundary */
703     if (object_len % sizeof (guint32))
704       object_len += (sizeof (guint32) - object_len % sizeof (guint32));
705
706     pr_len -= object_len - COPS_OBJECT_HDR_SIZE;
707     offset += object_len - COPS_OBJECT_HDR_SIZE;
708   }
709 }
710
711 static void dissect_cops_object_data(tvbuff_t *tvb, guint32 offset, proto_tree *tree,
712                                      guint8 c_num, guint8 c_type, guint16 len)
713 {
714   proto_item *ti;
715   proto_tree *r_type_tree, *itf_tree, *reason_tree, *dec_tree, *error_tree, *clientsi_tree, *pdp_tree;
716   guint16 r_type, m_type, reason, reason_sub, cmd_code, cmd_flags, error, error_sub, tcp_port;
717   guint32 ipv4addr, ifindex;
718   struct e_in6_addr ipv6addr;
719
720   switch (c_num) {
721   case COPS_OBJ_CONTEXT:
722     r_type = tvb_get_ntohs(tvb, offset);
723     m_type = tvb_get_ntohs(tvb, offset + 2);
724     ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: R-Type: %s, M-Type: %u",
725                              val_to_str(r_type, cops_r_type_vals, "Unknown"),
726                              m_type);
727
728     r_type_tree = proto_item_add_subtree(ti, ett_cops_r_type_flags);
729     proto_tree_add_uint(r_type_tree, hf_cops_r_type_flags, tvb, offset, 2, r_type);
730     offset += 2;
731     proto_tree_add_uint(r_type_tree, hf_cops_m_type_flags, tvb, offset, 2, m_type);
732
733     break;
734   case COPS_OBJ_IN_INT:
735   case COPS_OBJ_OUT_INT:
736     if (c_type == 1) {          /* IPv4 */
737       tvb_memcpy(tvb, (guint8 *)&ipv4addr, offset, 4);
738       ifindex = tvb_get_ntohl(tvb, offset + 4);
739       ti = proto_tree_add_text(tree, tvb, offset, 8, "Contents: IPv4 address %s, ifIndex: %u",
740                                ip_to_str((guint8 *)&ipv4addr), ifindex);
741       itf_tree = proto_item_add_subtree(ti, ett_cops_itf);
742       proto_tree_add_ipv4(itf_tree,
743                           (c_num == COPS_OBJ_IN_INT) ? hf_cops_in_int_ipv4 : hf_cops_out_int_ipv4,
744                           tvb, offset, 4, ipv4addr);
745       offset += 4;
746     } else if (c_type == 2) {   /* IPv6 */
747       tvb_memcpy(tvb, (guint8 *)&ipv6addr, offset, sizeof ipv6addr);
748       ifindex = tvb_get_ntohl(tvb, offset + sizeof ipv6addr);
749       ti = proto_tree_add_text(tree, tvb, offset, 20, "Contents: IPv6 address %s, ifIndex: %u",
750                                ip6_to_str(&ipv6addr), ifindex);
751       itf_tree = proto_item_add_subtree(ti, ett_cops_itf);
752       proto_tree_add_ipv6(itf_tree,
753                           (c_num == COPS_OBJ_IN_INT) ? hf_cops_in_int_ipv6 : hf_cops_out_int_ipv6,
754                           tvb, offset, 16, (guint8 *)&ipv6addr);
755       offset += 16;
756     } else {
757       break;
758     }
759     proto_tree_add_uint(itf_tree, hf_cops_int_ifindex, tvb, offset, 4, ifindex);
760
761     break;
762   case COPS_OBJ_REASON:
763     reason = tvb_get_ntohs(tvb, offset);
764     reason_sub = tvb_get_ntohs(tvb, offset + 2);
765     ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: Reason-Code: %s, Reason Sub-code: 0x%04x",
766                              val_to_str(reason, cops_reason_vals, "<Unknown value>"), reason_sub);
767     reason_tree = proto_item_add_subtree(ti, ett_cops_reason);
768     proto_tree_add_uint(reason_tree, hf_cops_reason, tvb, offset, 2, reason);
769     offset += 2;
770     if (reason == 13) {
771       proto_tree_add_text(reason_tree, tvb, offset, 2, "Reason Sub-code: "
772                           "Unknown object's C-Num %u, C-Type %u",
773                           tvb_get_guint8(tvb, offset), tvb_get_guint8(tvb, offset + 1));
774     } else
775       proto_tree_add_uint(reason_tree, hf_cops_reason_sub, tvb, offset, 2, reason_sub);
776
777     break;
778   case COPS_OBJ_DECISION:
779   case COPS_OBJ_LPDPDECISION:
780     if (c_type == 1) {
781       cmd_code = tvb_get_ntohs(tvb, offset);
782       cmd_flags = tvb_get_ntohs(tvb, offset + 2);
783       ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: Command-Code: %s, Flags: %s",
784                                val_to_str(cmd_code, cops_dec_cmd_code_vals, "<Unknown value>"),
785                                val_to_str(cmd_flags, cops_dec_cmd_flag_vals, "<Unknown flag>"));
786       dec_tree = proto_item_add_subtree(ti, ett_cops_decision);
787       proto_tree_add_uint(dec_tree, hf_cops_dec_cmd_code, tvb, offset, 2, cmd_code);
788       offset += 2;
789       proto_tree_add_uint(dec_tree, hf_cops_dec_flags, tvb, offset, 2, cmd_flags);
790     } else if (c_type == 5) { /*COPS-PR Data*/
791       ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: %u bytes", len);
792       dec_tree = proto_item_add_subtree(ti, ett_cops_decision);
793       dissect_cops_pr_objects(tvb, offset, dec_tree, len);
794     }
795
796     break;
797   case COPS_OBJ_ERROR:
798     if (c_type != 1)
799       break;
800
801     error = tvb_get_ntohs(tvb, offset);
802     error_sub = tvb_get_ntohs(tvb, offset + 2);
803     ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: Error-Code: %s, Error Sub-code: 0x%04x",
804                              val_to_str(error, cops_error_vals, "<Unknown value>"), error_sub);
805     error_tree = proto_item_add_subtree(ti, ett_cops_error);
806     proto_tree_add_uint(error_tree, hf_cops_error, tvb, offset, 2, error);
807     offset += 2;
808     if (error == 13) {
809       proto_tree_add_text(error_tree, tvb, offset, 2, "Error Sub-code: "
810                           "Unknown object's C-Num %u, C-Type %u",
811                           tvb_get_guint8(tvb, offset), tvb_get_guint8(tvb, offset + 1));
812     } else
813       proto_tree_add_uint(error_tree, hf_cops_error_sub, tvb, offset, 2, error_sub);
814
815     break;
816   case COPS_OBJ_CLIENTSI:
817
818     if (c_type != 2) /*Not COPS-PR data*/
819       break;
820
821     ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: %u bytes", len);
822     clientsi_tree = proto_item_add_subtree(ti, ett_cops_clientsi);
823
824     dissect_cops_pr_objects(tvb, offset, clientsi_tree, len);
825
826     break;
827   case COPS_OBJ_KATIMER:
828     if (c_type != 1)
829       break;
830
831     proto_tree_add_item(tree, hf_cops_katimer, tvb, offset + 2, 2, FALSE);
832     if (tvb_get_ntohs(tvb, offset + 2) == 0)
833       proto_tree_add_text(tree, tvb, offset, 0, "Value of zero implies infinity.");
834
835     break;
836   case COPS_OBJ_PEPID:
837     if (c_type != 1)
838       break;
839
840     if (tvb_strnlen(tvb, offset, len) == -1)
841       proto_tree_add_text(tree, tvb, offset, len, "<PEP Id is not a NUL terminated ASCII string>");
842     else
843       proto_tree_add_item(tree, hf_cops_pepid, tvb, offset,
844                           tvb_strnlen(tvb, offset, len) + 1, FALSE);
845
846     break;
847   case COPS_OBJ_REPORT_TYPE:
848     if (c_type != 1)
849       break;
850
851     proto_tree_add_item(tree, hf_cops_report_type, tvb, offset, 2, FALSE);
852
853     break;
854   case COPS_OBJ_PDPREDIRADDR:
855   case COPS_OBJ_LASTPDPADDR:
856     if (c_type == 1) {          /* IPv4 */
857       tvb_memcpy(tvb, (guint8 *)&ipv4addr, offset, 4);
858       tcp_port = tvb_get_ntohs(tvb, offset + 4 + 2);
859       ti = proto_tree_add_text(tree, tvb, offset, 8, "Contents: IPv4 address %s, TCP Port Number: %u",
860                                ip_to_str((guint8 *)&ipv4addr), tcp_port);
861       pdp_tree = proto_item_add_subtree(ti, ett_cops_pdp);
862       proto_tree_add_ipv4(pdp_tree,
863                           (c_num == COPS_OBJ_PDPREDIRADDR) ? hf_cops_pdprediraddr_ipv4 : hf_cops_lastpdpaddr_ipv4,
864                           tvb, offset, 4, ipv4addr);
865       offset += 4;
866     } else if (c_type == 2) {   /* IPv6 */
867       tvb_memcpy(tvb, (guint8 *)&ipv6addr, offset, sizeof ipv6addr);
868       tcp_port = tvb_get_ntohs(tvb, offset + sizeof ipv6addr + 2);
869       ti = proto_tree_add_text(tree, tvb, offset, 20, "Contents: IPv6 address %s, TCP Port Number: %u",
870                                ip6_to_str(&ipv6addr), tcp_port);
871       pdp_tree = proto_item_add_subtree(ti, ett_cops_pdp);
872       proto_tree_add_ipv6(pdp_tree,
873                           (c_num == COPS_OBJ_PDPREDIRADDR) ? hf_cops_pdprediraddr_ipv6 : hf_cops_lastpdpaddr_ipv6,
874                           tvb, offset, 16, (guint8 *)&ipv6addr);
875       offset += 16;
876     } else {
877       break;
878     }
879     offset += 2;
880     proto_tree_add_uint(pdp_tree, hf_cops_pdp_tcp_port, tvb, offset, 2, tcp_port);
881
882     break;
883   case COPS_OBJ_ACCTTIMER:
884     if (c_type != 1)
885       break;
886
887     proto_tree_add_item(tree, hf_cops_accttimer, tvb, offset + 2, 2, FALSE);
888     if (tvb_get_ntohs(tvb, offset + 2) == 0)
889       proto_tree_add_text(tree, tvb, offset, 0, "Value of zero means "
890                           "there SHOULD be no unsolicited accounting updates.");
891
892     break;
893   case COPS_OBJ_INTEGRITY:
894     if (c_type != 1)
895       break;      /* Not HMAC digest */
896
897     proto_tree_add_item(tree, hf_cops_key_id, tvb, offset, 4, FALSE);
898     proto_tree_add_item(tree, hf_cops_seq_num, tvb, offset + 4, 4, FALSE);
899     proto_tree_add_text(tree, tvb, offset + 8 , len - 8, "Contents: Keyed Message Digest");
900
901     break;
902   default:
903     proto_tree_add_text(tree, tvb, offset, len, "Contents: %u bytes", len);
904
905     break;
906   }
907 }
908
909 #ifdef HAVE_NET_SNMP
910 static guchar*format_asn_value (struct variable_list *variable, subid_t *variable_oid,
911                                 guint variable_oid_length,gushort type_from_packet)
912 {
913   struct tree *subtree=tree_head;
914   
915   guchar *buf=NULL;
916   size_t buf_len=0;
917   size_t out_len=0;
918   
919   /*Get the ASN.1 type etc. from the PIB-MIB. If unsuccessful use the type from packet*/
920   subtree = get_tree(variable_oid,variable_oid_length, subtree);
921   
922   if (subtree->type == 0)
923     variable->type=type_from_packet;
924   
925   buf_len = SPRINT_MAX_LEN; /*defined in NET-SNMP's snmp-impl.h*/
926   buf = g_malloc(buf_len);
927   *buf = '\0';
928   out_len = 0;
929  
930   /*If the ASN.1 type was found from PIB-MIB, use it for decoding*/
931   if (!variable->type)
932     variable->type=mib_to_asn_type(subtree->type);
933  
934   if (!sprint_realloc_by_type(&buf, &buf_len, &out_len, TRUE, variable, subtree->enums, subtree->hint, NULL))
935     sprintf(buf,"%s","sprint_realloc_by_type failed");
936   
937   return buf;
938 }
939 #endif  /* HAVE_NET_SNMP */
940
941 static int decode_cops_pr_asn1_data(tvbuff_t *tvb, guint32 offset,
942     proto_tree *tree, guint asnlen, guint8 cops_pr_obj
943 #ifndef HAVE_NET_SNMP
944                                                   _U_
945 #endif
946     )
947 {
948   ASN1_SCK asn1;
949   int start;
950   gboolean def;
951   guint length;
952
953   guint vb_length;
954   gushort vb_type;
955   gchar *vb_type_name;
956
957   int ret;
958   guint cls, con, tag;
959   subid_t epd_attribute_index=0;
960
961   gint32 vb_integer_value;
962   guint32 vb_uinteger_value;
963
964   guint8 *vb_octet_string;
965
966   subid_t *vb_oid;
967   guint vb_oid_length;
968
969   gchar *vb_display_string;
970   gchar *vb_display_string2;
971
972 #ifdef HAVE_NET_SNMP
973   struct variable_list variable;
974   long value;
975 #endif  /* HAVE_NET_SNMP */
976   
977   unsigned int i;
978   gchar *buf;
979   int len;
980
981   while (asnlen > 0) { /*while there is ASN stuff to be decoded*/
982
983     epd_attribute_index++;
984 #ifdef HAVE_NET_SNMP
985     last_decoded_prid_oid[last_decoded_prid_oid_length-1]=epd_attribute_index;
986 #endif  /* HAVE_NET_SNMP */
987     asn1_open(&asn1, tvb, offset);
988
989     /* parse the type of the object */
990
991     start = asn1.offset;
992
993     ret = asn1_header_decode (&asn1, &cls, &con, &tag, &def, &vb_length);
994     if (ret != ASN1_ERR_NOERROR)
995       return 0;
996     if (!def)
997       return ASN1_ERR_LENGTH_NOT_DEFINITE;
998
999     /* Convert the class, constructed flag, and tag to a type. */
1000     vb_type_name = cops_tag_cls2syntax(tag, cls, &vb_type);
1001     if (vb_type_name == NULL) {
1002       /*
1003        * Unsupported type.
1004        * Dissect the value as an opaque string of octets.
1005        */
1006       vb_type_name = "unsupported type";
1007       vb_type = COPS_OPAQUE;
1008     }
1009
1010     /* parse the value */
1011
1012     switch (vb_type) {
1013
1014     case COPS_INTEGER:
1015       ret = asn1_int32_value_decode(&asn1, vb_length, &vb_integer_value);
1016       if (ret != ASN1_ERR_NOERROR)
1017         return ret;
1018       length = asn1.offset - start;
1019       if (tree) {
1020 #ifdef HAVE_NET_SNMP
1021         if (cops_typefrommib == TRUE)
1022         {
1023           variable.type = 0;
1024           value = vb_integer_value;
1025           variable.val.integer = &value;
1026           variable.val_len = vb_length ;
1027           vb_display_string=format_asn_value(&variable, 
1028                                              last_decoded_prid_oid,last_decoded_prid_oid_length,ASN_INTEGER);
1029    
1030           proto_tree_add_text(tree, asn1.tvb, offset, length,
1031                               "Value: %s", vb_display_string);
1032           g_free(vb_display_string);
1033         }
1034         else
1035 #endif /* HAVE_NET_SNMP */
1036           proto_tree_add_text(tree, asn1.tvb, offset, length,
1037                               "Value: %s: %d (%#x)", vb_type_name,
1038                               vb_integer_value, vb_integer_value);
1039       }
1040       break;
1041
1042     case COPS_UNSIGNED32:
1043     case COPS_TIMETICKS:
1044       ret = asn1_uint32_value_decode(&asn1, vb_length, &vb_uinteger_value);
1045       if (ret != ASN1_ERR_NOERROR)
1046         return ret;
1047       length = asn1.offset - start;
1048       if (tree) {
1049 #ifdef HAVE_NET_SNMP
1050         if (cops_typefrommib == TRUE)
1051         {
1052           variable.type = 0;
1053           value = vb_uinteger_value;
1054           variable.val.integer = &value;
1055           variable.val_len = vb_length;
1056
1057           vb_display_string=format_asn_value(&variable,
1058                                              last_decoded_prid_oid,last_decoded_prid_oid_length,ASN_UINTEGER);
1059      
1060           proto_tree_add_text(tree, asn1.tvb, offset, length, "Value %s: %s",vb_type_name, vb_display_string);
1061   
1062           g_free(vb_display_string);
1063         }
1064         else
1065 #endif /* HAVE_NET_SNMP */
1066           proto_tree_add_text(tree, asn1.tvb, offset, length,
1067                               "Value: %s: %u (%#x)", vb_type_name,
1068                               vb_uinteger_value, vb_uinteger_value);
1069       }
1070       break;
1071
1072     case COPS_OCTETSTR:
1073     case COPS_IPADDR:
1074     case COPS_OPAQUE:
1075     case COPS_UNSIGNED64:
1076     case COPS_INTEGER64:
1077       ret = asn1_string_value_decode (&asn1, vb_length, &vb_octet_string);
1078       if (ret != ASN1_ERR_NOERROR)
1079         return ret;
1080       length = asn1.offset - start;
1081       if (tree) {
1082 #ifdef HAVE_NET_SNMP
1083         if (cops_typefrommib == TRUE)
1084         {
1085           variable.type = 0;
1086           variable.val.string = vb_octet_string;
1087           variable.val_len = vb_length;
1088           vb_display_string = format_asn_value(&variable, 
1089                                                last_decoded_prid_oid,last_decoded_prid_oid_length,ASN_OCTET_STR);
1090           proto_tree_add_text(tree, asn1.tvb, offset, length,
1091                               "Value: %s (ASN.1 type from packet: %s)", vb_display_string, vb_type_name);
1092        
1093           g_free(vb_display_string);
1094         }
1095         else
1096         {
1097 #endif /* HAVE_NET_SNMP */
1098           for (i = 0; i < vb_length; i++) {
1099             if (!(isprint(vb_octet_string[i]) ||isspace(vb_octet_string[i])))
1100               break;
1101           }
1102
1103           /*
1104            * If some characters are not printable, display the string as bytes.
1105            */
1106           if (i < vb_length) {
1107             /*
1108              * We stopped, due to a non-printable character, before we got
1109              * to the end of the string.
1110              */
1111             vb_display_string = g_malloc(4*vb_length);
1112             buf = &vb_display_string[0];
1113             len = sprintf(buf, "%03u", vb_octet_string[0]);
1114             buf += len;
1115             for (i = 1; i < vb_length; i++) {
1116               len = sprintf(buf, ".%03u", vb_octet_string[i]);
1117               buf += len;
1118             }
1119             proto_tree_add_text(tree, asn1.tvb, offset, length,
1120                                 "Value: %s: %s", vb_type_name, vb_display_string);
1121             g_free(vb_display_string);
1122           } else {
1123             proto_tree_add_text(tree, asn1.tvb, offset, length,
1124                                 "Value: %s: %.*s", vb_type_name, (int)vb_length,
1125                                 SAFE_STRING(vb_octet_string));
1126           }
1127 #ifdef HAVE_NET_SNMP
1128         }
1129 #endif /* HAVE_NET_SNMP */
1130       }
1131       g_free(vb_octet_string);
1132       break;
1133
1134     case COPS_NULL:
1135       ret = asn1_null_decode (&asn1, vb_length);
1136       if (ret != ASN1_ERR_NOERROR)
1137         return ret;
1138       length = asn1.offset - start;
1139       if (tree)
1140         proto_tree_add_text(tree, asn1.tvb, offset, length, "Value: %s", vb_type_name);
1141       break;
1142
1143     case COPS_OBJECTID:
1144       ret = asn1_oid_value_decode (&asn1, vb_length, &vb_oid, &vb_oid_length);
1145       if (ret != ASN1_ERR_NOERROR)
1146         return ret;
1147       length = asn1.offset - start;
1148
1149       if (tree) {
1150         if (cops_pr_obj == COPS_OBJ_PPRID){
1151           /*we're decoding Prefix PRID, that doesn't have a instance Id,
1152            *Use full length of the OID when decoding it.
1153            */
1154           new_format_oid(vb_oid,vb_oid_length,&vb_display_string,&vb_display_string2);
1155
1156           if (!vb_display_string2)   /*if OID couldn't be decoded, print only numeric format*/
1157             proto_tree_add_text(tree, asn1.tvb, offset, length,
1158                                 "Value: %s: %s", vb_type_name, vb_display_string);
1159           else
1160             proto_tree_add_text(tree, asn1.tvb, offset, length,
1161                                 "Value: %s: %s (%s)", vb_type_name,
1162                                 vb_display_string,
1163                                 vb_display_string2);
1164         }
1165         else { /*we're decoding PRID, Error PRID or EPD*/
1166           /*strip the instance Id from the OIDs before decoding and paste it back during printing*/
1167           new_format_oid(vb_oid,vb_oid_length-1,&vb_display_string,&vb_display_string2);
1168           
1169           if (!vb_display_string2)  /*if OID couldn't be decoded, print only numeric format*/
1170             proto_tree_add_text(tree, asn1.tvb, offset, length,
1171                                 "Value: %s: %s.%lu", vb_type_name,
1172                                 vb_display_string,
1173                                 (unsigned long)vb_oid[vb_oid_length-1]);
1174           else
1175             proto_tree_add_text(tree, asn1.tvb, offset, length,
1176                                 "Value: %s: %s.%lu (%s.%lu)", vb_type_name,
1177                                 vb_display_string,
1178                                 (unsigned long)vb_oid[vb_oid_length-1],
1179                                 vb_display_string2,
1180                                 (unsigned long)vb_oid[vb_oid_length-1]);
1181         }
1182 #ifdef HAVE_NET_SNMP
1183         if (cops_pr_obj != COPS_OBJ_EPD) {
1184           /* we're not decoding EPD, so let's store the OID of the PRID so that later
1185              when we're decoding this PRID's EPD we can finetune the output.*/
1186           memcpy(last_decoded_prid_oid,vb_oid,vb_oid_length*sizeof(subid_t));
1187           last_decoded_prid_oid_length=vb_oid_length;
1188         }
1189 #endif /* HAVE_NET_SNMP */
1190         
1191       g_free(vb_display_string);
1192       if(vb_display_string2)
1193         g_free(vb_display_string2);
1194       }
1195       g_free(vb_oid);
1196       break;
1197
1198     default:
1199       g_assert_not_reached();
1200       return ASN1_ERR_WRONG_TYPE;
1201     }
1202
1203     asn1_close(&asn1,&offset);
1204
1205     asnlen -= length;
1206   }
1207   epd_attribute_index=0;
1208   return 0;
1209 }
1210
1211 static int dissect_cops_pr_object_data(tvbuff_t *tvb, guint32 offset, proto_tree *tree,
1212                                        guint8 s_num, guint8 s_type, guint16 len)
1213 {
1214   proto_item *ti;
1215   proto_tree *asn1_object_tree, *gperror_tree, *cperror_tree;
1216   guint16 gperror=0, gperror_sub=0, cperror=0, cperror_sub=0;
1217
1218   switch (s_num){
1219   case COPS_OBJ_PRID:
1220    if (s_type != 1) /* Not Provisioning Instance Identifier (PRID) */
1221       break;
1222
1223     ti=proto_tree_add_text(tree, tvb, offset, len, "Contents:");
1224     asn1_object_tree = proto_item_add_subtree(ti, ett_cops_asn1);
1225
1226     decode_cops_pr_asn1_data(tvb, offset, asn1_object_tree, len, COPS_OBJ_PRID);
1227
1228     break;
1229   case COPS_OBJ_PPRID:
1230     if (s_type != 1) /* Not Prefix Provisioning Instance Identifier (PPRID) */
1231       break;
1232
1233     ti = proto_tree_add_text(tree, tvb, offset, len, "Contents:");
1234     asn1_object_tree = proto_item_add_subtree(ti, ett_cops_asn1);
1235
1236     decode_cops_pr_asn1_data(tvb, offset, asn1_object_tree, len, COPS_OBJ_PPRID);
1237
1238     break;
1239   case COPS_OBJ_EPD:
1240     if (s_type != 1) /* Not  Encoded Provisioning Instance Data (EPD) */
1241       break;
1242
1243     ti = proto_tree_add_text(tree, tvb, offset, len, "Contents:");
1244     asn1_object_tree = proto_item_add_subtree(ti, ett_cops_asn1);
1245
1246     decode_cops_pr_asn1_data(tvb, offset, asn1_object_tree, len, COPS_OBJ_EPD);
1247
1248     break;
1249   case COPS_OBJ_GPERR:
1250     if (s_type != 1) /* Not Global Provisioning Error Object (GPERR) */
1251       break;
1252
1253     gperror = tvb_get_ntohs(tvb, offset);
1254     gperror_sub = tvb_get_ntohs(tvb, offset + 2);
1255     ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: Error-Code: %s, Error Sub-code: 0x%04x",
1256                        val_to_str(gperror, cops_gperror_vals, "<Unknown value>"), gperror_sub);
1257     gperror_tree = proto_item_add_subtree(ti, ett_cops_gperror);
1258     proto_tree_add_uint(gperror_tree, hf_cops_gperror, tvb, offset, 2, gperror);
1259     offset += 2;
1260     if (cperror == 13) {
1261       proto_tree_add_text(gperror_tree, tvb, offset, 2, "Error Sub-code: "
1262                           "Unknown object's C-Num %u, C-Type %u",
1263                           tvb_get_guint8(tvb, offset), tvb_get_guint8(tvb, offset + 1));
1264     } else
1265       proto_tree_add_uint(gperror_tree, hf_cops_gperror_sub, tvb, offset, 2, gperror_sub);
1266
1267     break;
1268   case COPS_OBJ_CPERR:
1269     if (s_type != 1) /*Not PRC Class Provisioning Error Object (CPERR) */
1270       break;
1271
1272     break;
1273
1274     cperror = tvb_get_ntohs(tvb, offset);
1275     cperror_sub = tvb_get_ntohs(tvb, offset + 2);
1276     ti = proto_tree_add_text(tree, tvb, offset, 4, "Contents: Error-Code: %s, Error Sub-code: 0x%04x",
1277                        val_to_str(cperror, cops_cperror_vals, "<Unknown value>"), cperror_sub);
1278     cperror_tree = proto_item_add_subtree(ti, ett_cops_cperror);
1279     proto_tree_add_uint(cperror_tree, hf_cops_cperror, tvb, offset, 2, cperror);
1280     offset += 2;
1281     if (cperror == 13) {
1282       proto_tree_add_text(cperror_tree, tvb, offset, 2, "Error Sub-code: "
1283                           "Unknown object's S-Num %u, C-Type %u",
1284                           tvb_get_guint8(tvb, offset), tvb_get_guint8(tvb, offset + 1));
1285     } else
1286       proto_tree_add_uint(cperror_tree, hf_cops_cperror_sub, tvb, offset, 2, cperror_sub);
1287
1288     break;
1289   case COPS_OBJ_ERRPRID:
1290     if (s_type != 1) /*Not  Error Provisioning Instance Identifier (ErrorPRID)*/
1291       break;
1292
1293     ti = proto_tree_add_text(tree, tvb, offset, len, "Contents:");
1294     asn1_object_tree = proto_item_add_subtree(ti, ett_cops_asn1);
1295
1296     decode_cops_pr_asn1_data(tvb, offset, asn1_object_tree, len, COPS_OBJ_ERRPRID);
1297
1298     break;
1299   default:
1300     proto_tree_add_text(tree, tvb, offset, len, "Contents: %u bytes", len);
1301     break;
1302   }
1303
1304   return 0;
1305 }
1306
1307
1308 /* Register the protocol with Ethereal */
1309 void proto_register_cops(void)
1310 {
1311   /* Setup list of header fields */
1312   static hf_register_info hf[] = {
1313     { &hf_cops_ver_flags,
1314       { "Version and Flags",           "cops.ver_flags",
1315       FT_UINT8, BASE_HEX, NULL, 0x0,
1316       "Version and Flags in COPS Common Header", HFILL }
1317     },
1318     { &hf_cops_version,
1319       { "Version",           "cops.version",
1320       FT_UINT8, BASE_DEC, NULL, 0xF0,
1321       "Version in COPS Common Header", HFILL }
1322     },
1323     { &hf_cops_flags,
1324       { "Flags",           "cops.flags",
1325       FT_UINT8, BASE_HEX, VALS(cops_flags_vals), 0x0F,
1326       "Flags in COPS Common Header", HFILL }
1327     },
1328     { &hf_cops_op_code,
1329       { "Op Code",           "cops.op_code",
1330       FT_UINT8, BASE_DEC, VALS(cops_op_code_vals), 0x0,
1331       "Op Code in COPS Common Header", HFILL }
1332     },
1333     { &hf_cops_client_type,
1334       { "Client Type",           "cops.client_type",
1335       FT_UINT16, BASE_DEC, NULL, 0x0,
1336       "Client Type in COPS Common Header", HFILL }
1337     },
1338     { &hf_cops_msg_len,
1339       { "Message Length",           "cops.msg_len",
1340       FT_UINT32, BASE_DEC, NULL, 0x0,
1341       "Message Length in COPS Common Header", HFILL }
1342     },
1343     { &hf_cops_obj_len,
1344       { "Object Length",           "cops.obj.len",
1345       FT_UINT32, BASE_DEC, NULL, 0x0,
1346       "Object Length in COPS Object Header", HFILL }
1347     },
1348     { &hf_cops_obj_c_num,
1349       { "C-Num",           "cops.c_num",
1350       FT_UINT8, BASE_DEC, VALS(cops_c_num_vals), 0x0,
1351       "C-Num in COPS Object Header", HFILL }
1352     },
1353     { &hf_cops_obj_c_type,
1354       { "C-Type",           "cops.c_type",
1355       FT_UINT8, BASE_DEC, NULL, 0x0,
1356       "C-Type in COPS Object Header", HFILL }
1357     },
1358
1359     { &hf_cops_obj_s_num,
1360       { "S-Num",           "cops.s_num",
1361       FT_UINT8, BASE_DEC, VALS(cops_s_num_vals), 0x0,
1362       "S-Num in COPS-PR Object Header", HFILL }
1363     },
1364     { &hf_cops_obj_s_type,
1365       { "S-Type",           "cops.s_type",
1366       FT_UINT8, BASE_DEC, NULL, 0x0,
1367       "S-Type in COPS-PR Object Header", HFILL }
1368     },
1369
1370     { &hf_cops_r_type_flags,
1371       { "R-Type",           "cops.context.r_type",
1372       FT_UINT16, BASE_HEX, VALS(cops_r_type_vals), 0xFFFF,
1373       "R-Type in COPS Context Object", HFILL }
1374     },
1375     { &hf_cops_m_type_flags,
1376       { "M-Type",           "cops.context.m_type",
1377       FT_UINT16, BASE_HEX, NULL, 0xFFFF,
1378       "M-Type in COPS Context Object", HFILL }
1379     },
1380     { &hf_cops_in_int_ipv4,
1381       { "IPv4 address",           "cops.in-int.ipv4",
1382       FT_IPv4, 0, NULL, 0xFFFF,
1383       "IPv4 address in COPS IN-Int object", HFILL }
1384     },
1385     { &hf_cops_in_int_ipv6,
1386       { "IPv6 address",           "cops.in-int.ipv6",
1387       FT_IPv6, 0, NULL, 0xFFFF,
1388       "IPv6 address in COPS IN-Int object", HFILL }
1389     },
1390     { &hf_cops_out_int_ipv4,
1391       { "IPv4 address",           "cops.out-int.ipv4",
1392       FT_IPv4, 0, NULL, 0xFFFF,
1393       "IPv4 address in COPS OUT-Int object", HFILL }
1394     },
1395     { &hf_cops_out_int_ipv6,
1396       { "IPv6 address",           "cops.out-int.ipv6",
1397       FT_IPv6, 0, NULL, 0xFFFF,
1398       "IPv6 address in COPS OUT-Int", HFILL }
1399     },
1400     { &hf_cops_int_ifindex,
1401       { "ifIndex",           "cops.in-out-int.ifindex",
1402       FT_UINT32, BASE_DEC, NULL, 0x0,
1403       "If SNMP is supported, corresponds to MIB-II ifIndex", HFILL }
1404     },
1405     { &hf_cops_reason,
1406       { "Reason",           "cops.reason",
1407       FT_UINT16, BASE_DEC, VALS(cops_reason_vals), 0,
1408       "Reason in Reason object", HFILL }
1409     },
1410     { &hf_cops_reason_sub,
1411       { "Reason Sub-code",           "cops.reason_sub",
1412       FT_UINT16, BASE_HEX, NULL, 0,
1413       "Reason Sub-code in Reason object", HFILL }
1414     },
1415     { &hf_cops_dec_cmd_code,
1416       { "Command-Code",           "cops.decision.cmd",
1417       FT_UINT16, BASE_DEC, VALS(cops_dec_cmd_code_vals), 0,
1418       "Command-Code in Decision/LPDP Decision object", HFILL }
1419     },
1420     { &hf_cops_dec_flags,
1421       { "Flags",           "cops.decision.flags",
1422       FT_UINT16, BASE_HEX, VALS(cops_dec_cmd_flag_vals), 0xffff,
1423       "Flags in Decision/LPDP Decision object", HFILL }
1424     },
1425     { &hf_cops_error,
1426       { "Error",           "cops.error",
1427       FT_UINT16, BASE_DEC, VALS(cops_error_vals), 0,
1428       "Error in Error object", HFILL }
1429     },
1430     { &hf_cops_error_sub,
1431       { "Error Sub-code",           "cops.error_sub",
1432       FT_UINT16, BASE_HEX, NULL, 0,
1433       "Error Sub-code in Error object", HFILL }
1434     },
1435     { &hf_cops_katimer,
1436       { "Contents: KA Timer Value",           "cops.katimer.value",
1437       FT_UINT16, BASE_DEC, NULL, 0,
1438       "Keep-Alive Timer Value in KATimer object", HFILL }
1439     },
1440     { &hf_cops_pepid,
1441       { "Contents: PEP Id",           "cops.pepid.id",
1442       FT_STRING, BASE_NONE, NULL, 0,
1443       "PEP Id in PEPID object", HFILL }
1444     },
1445     { &hf_cops_report_type,
1446       { "Contents: Report-Type",           "cops.report_type",
1447       FT_UINT16, BASE_DEC, VALS(cops_report_type_vals), 0,
1448       "Report-Type in Report-Type object", HFILL }
1449     },
1450     { &hf_cops_pdprediraddr_ipv4,
1451       { "IPv4 address",           "cops.pdprediraddr.ipv4",
1452       FT_IPv4, 0, NULL, 0xFFFF,
1453       "IPv4 address in COPS PDPRedirAddr object", HFILL }
1454     },
1455     { &hf_cops_pdprediraddr_ipv6,
1456       { "IPv6 address",           "cops.pdprediraddr.ipv6",
1457       FT_IPv6, 0, NULL, 0xFFFF,
1458       "IPv6 address in COPS PDPRedirAddr object", HFILL }
1459     },
1460     { &hf_cops_lastpdpaddr_ipv4,
1461       { "IPv4 address",           "cops.lastpdpaddr.ipv4",
1462       FT_IPv4, 0, NULL, 0xFFFF,
1463       "IPv4 address in COPS LastPDPAddr object", HFILL }
1464     },
1465     { &hf_cops_lastpdpaddr_ipv6,
1466       { "IPv6 address",           "cops.lastpdpaddr.ipv6",
1467       FT_IPv6, 0, NULL, 0xFFFF,
1468       "IPv6 address in COPS LastPDPAddr object", HFILL }
1469     },
1470     { &hf_cops_pdp_tcp_port,
1471       { "TCP Port Number",           "cops.pdp.tcp_port",
1472       FT_UINT32, BASE_DEC, NULL, 0x0,
1473        "TCP Port Number of PDP in PDPRedirAddr/LastPDPAddr object", HFILL }
1474     },
1475     { &hf_cops_accttimer,
1476       { "Contents: ACCT Timer Value",           "cops.accttimer.value",
1477       FT_UINT16, BASE_DEC, NULL, 0,
1478       "Accounting Timer Value in AcctTimer object", HFILL }
1479     },
1480     { &hf_cops_key_id,
1481       { "Contents: Key ID",           "cops.integrity.key_id",
1482       FT_UINT32, BASE_DEC, NULL, 0,
1483       "Key ID in Integrity object", HFILL }
1484     },
1485     { &hf_cops_seq_num,
1486       { "Contents: Sequence Number",           "cops.integrity.seq_num",
1487       FT_UINT32, BASE_DEC, NULL, 0,
1488       "Sequence Number in Integrity object", HFILL }
1489     },
1490     { &hf_cops_gperror,
1491       { "Error",           "cops.gperror",
1492       FT_UINT16, BASE_DEC, VALS(cops_gperror_vals), 0,
1493       "Error in Error object", HFILL }
1494     },
1495     { &hf_cops_gperror_sub,
1496       { "Error Sub-code",           "cops.gperror_sub",
1497       FT_UINT16, BASE_HEX, NULL, 0,
1498       "Error Sub-code in Error object", HFILL }
1499     },
1500     { &hf_cops_cperror,
1501       { "Error",           "cops.cperror",
1502       FT_UINT16, BASE_DEC, VALS(cops_cperror_vals), 0,
1503       "Error in Error object", HFILL }
1504     },
1505     { &hf_cops_cperror_sub,
1506       { "Error Sub-code",           "cops.cperror_sub",
1507       FT_UINT16, BASE_HEX, NULL, 0,
1508       "Error Sub-code in Error object", HFILL }
1509     },
1510
1511   };
1512
1513   /* Setup protocol subtree array */
1514   static gint *ett[] = {
1515     &ett_cops,
1516     &ett_cops_ver_flags,
1517     &ett_cops_obj,
1518     &ett_cops_pr_obj,
1519     &ett_cops_obj_data,
1520     &ett_cops_r_type_flags,
1521     &ett_cops_itf,
1522     &ett_cops_reason,
1523     &ett_cops_decision,
1524     &ett_cops_error,
1525     &ett_cops_clientsi,
1526     &ett_cops_asn1,
1527     &ett_cops_gperror,
1528     &ett_cops_cperror,
1529     &ett_cops_pdp,
1530   };
1531
1532   module_t* cops_module;
1533
1534   /* Register the protocol name and description */
1535   proto_cops = proto_register_protocol("Common Open Policy Service",
1536       "COPS", "cops");
1537
1538   /* Required function calls to register the header fields and subtrees used */
1539   proto_register_field_array(proto_cops, hf, array_length(hf));
1540   proto_register_subtree_array(ett, array_length(ett));
1541
1542   /* Register our configuration options for cops */
1543   cops_module = prefs_register_protocol(proto_cops, proto_reg_handoff_cops);
1544   prefs_register_uint_preference(cops_module,"tcp.cops_port",
1545                                  "COPS TCP Port",
1546                                  "Set the TCP port for COPS messages",
1547                                  10,&global_cops_tcp_port);
1548   prefs_register_bool_preference(cops_module, "desegment",
1549                                  "Desegment all COPS messages spanning multiple TCP segments",
1550                                  "Whether the COPS dissector should desegment all messages spanning multiple TCP segments",
1551                                  &cops_desegment);
1552 #ifdef HAVE_NET_SNMP /*enable preference only if compiled with NET-SNMP*/
1553   prefs_register_bool_preference(cops_module, "typefrommib",
1554                                  "Decode COPS-PR ASN.1 types by reading them from PIBs (converted to MIBs)",
1555                                  "Whether the COPS dissector should decode COPS-PR ASN.1 types based on data types read from packet or PIBs (converted to MIBs)",
1556                                  &cops_typefrommib);
1557 #endif /*HAVE_NET_SNMP*/
1558 };
1559
1560 void proto_reg_handoff_cops(void)
1561 {
1562   static int cops_prefs_initialized = FALSE;
1563   static dissector_handle_t cops_handle;
1564   
1565   if (!cops_prefs_initialized) {
1566     cops_handle = create_dissector_handle(dissect_cops, proto_cops);
1567     cops_prefs_initialized = TRUE;
1568   } else
1569     dissector_delete("tcp.port",cops_tcp_port,cops_handle);
1570   
1571   /* Set our port numbers for future use */
1572   cops_tcp_port = global_cops_tcp_port;
1573   
1574   dissector_add("tcp.port", cops_tcp_port, cops_handle);
1575 }