nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
3 * John Robert LoVerso. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 *
28 * This implementation has been influenced by the CMU SNMP release,
29 * by Steve Waldbusser. However, this shares no code with that system.
30 * Additional ASN.1 insight gained from Marshall T. Rose's _The_Open_Book_.
31 * Earlier forms of this implementation were derived and/or inspired by an
32 * awk script originally written by C. Philip Wood of LANL (but later
33 * heavily modified by John Robert LoVerso). The copyright notice for
34 * that work is preserved below, even though it may not rightly apply
35 * to this file.
36 *
37 * Support for SNMPv2c/SNMPv3 and the ability to link the module against
38 * the libsmi was added by J. Schoenwaelder, Copyright (c) 1999.
39 *
40 * This started out as a very simple program, but the incremental decoding
41 * (into the BE structure) complicated things.
42 *
43 # Los Alamos National Laboratory
44 #
45 # Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
46 # This software was produced under a U.S. Government contract
47 # (W-7405-ENG-36) by Los Alamos National Laboratory, which is
48 # operated by the University of California for the U.S. Department
49 # of Energy. The U.S. Government is licensed to use, reproduce,
50 # and distribute this software. Permission is granted to the
51 # public to copy and use this software without charge, provided
52 # that this Notice and any statement of authorship are reproduced
53 # on all copies. Neither the Government nor the University makes
54 # any warranty, express or implied, or assumes any liability or
55 # responsibility for the use of this software.
56 # @(#)snmp.awk.x 1.1 (LANL) 1/15/90
57 */
58  
59 #define NETDISSECT_REWORKED
60 #ifdef HAVE_CONFIG_H
61 #include "config.h"
62 #endif
63  
64 #include <tcpdump-stdinc.h>
65  
66 #include <stdio.h>
67 #include <string.h>
68  
69 #ifdef USE_LIBSMI
70 #include <smi.h>
71 #endif
72  
73 #include "interface.h"
74  
75 #undef OPAQUE /* defined in <wingdi.h> */
76  
77 static const char tstr[] = "[|snmp]";
78  
79 /*
80 * Universal ASN.1 types
81 * (we only care about the tag values for those allowed in the Internet SMI)
82 */
83 static const char *Universal[] = {
84 "U-0",
85 "Boolean",
86 "Integer",
87 #define INTEGER 2
88 "Bitstring",
89 "String",
90 #define STRING 4
91 "Null",
92 #define ASN_NULL 5
93 "ObjID",
94 #define OBJECTID 6
95 "ObjectDes",
96 "U-8","U-9","U-10","U-11", /* 8-11 */
97 "U-12","U-13","U-14","U-15", /* 12-15 */
98 "Sequence",
99 #define SEQUENCE 16
100 "Set"
101 };
102  
103 /*
104 * Application-wide ASN.1 types from the Internet SMI and their tags
105 */
106 static const char *Application[] = {
107 "IpAddress",
108 #define IPADDR 0
109 "Counter",
110 #define COUNTER 1
111 "Gauge",
112 #define GAUGE 2
113 "TimeTicks",
114 #define TIMETICKS 3
115 "Opaque",
116 #define OPAQUE 4
117 "C-5",
118 "Counter64"
119 #define COUNTER64 6
120 };
121  
122 /*
123 * Context-specific ASN.1 types for the SNMP PDUs and their tags
124 */
125 static const char *Context[] = {
126 "GetRequest",
127 #define GETREQ 0
128 "GetNextRequest",
129 #define GETNEXTREQ 1
130 "GetResponse",
131 #define GETRESP 2
132 "SetRequest",
133 #define SETREQ 3
134 "Trap",
135 #define TRAP 4
136 "GetBulk",
137 #define GETBULKREQ 5
138 "Inform",
139 #define INFORMREQ 6
140 "V2Trap",
141 #define V2TRAP 7
142 "Report"
143 #define REPORT 8
144 };
145  
146 #define NOTIFY_CLASS(x) (x == TRAP || x == V2TRAP || x == INFORMREQ)
147 #define READ_CLASS(x) (x == GETREQ || x == GETNEXTREQ || x == GETBULKREQ)
148 #define WRITE_CLASS(x) (x == SETREQ)
149 #define RESPONSE_CLASS(x) (x == GETRESP)
150 #define INTERNAL_CLASS(x) (x == REPORT)
151  
152 /*
153 * Context-specific ASN.1 types for the SNMP Exceptions and their tags
154 */
155 static const char *Exceptions[] = {
156 "noSuchObject",
157 #define NOSUCHOBJECT 0
158 "noSuchInstance",
159 #define NOSUCHINSTANCE 1
160 "endOfMibView",
161 #define ENDOFMIBVIEW 2
162 };
163  
164 /*
165 * Private ASN.1 types
166 * The Internet SMI does not specify any
167 */
168 static const char *Private[] = {
169 "P-0"
170 };
171  
172 /*
173 * error-status values for any SNMP PDU
174 */
175 static const char *ErrorStatus[] = {
176 "noError",
177 "tooBig",
178 "noSuchName",
179 "badValue",
180 "readOnly",
181 "genErr",
182 "noAccess",
183 "wrongType",
184 "wrongLength",
185 "wrongEncoding",
186 "wrongValue",
187 "noCreation",
188 "inconsistentValue",
189 "resourceUnavailable",
190 "commitFailed",
191 "undoFailed",
192 "authorizationError",
193 "notWritable",
194 "inconsistentName"
195 };
196 #define DECODE_ErrorStatus(e) \
197 ( e >= 0 && (size_t)e < sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) \
198 ? ErrorStatus[e] \
199 : (snprintf(errbuf, sizeof(errbuf), "err=%u", e), errbuf))
200  
201 /*
202 * generic-trap values in the SNMP Trap-PDU
203 */
204 static const char *GenericTrap[] = {
205 "coldStart",
206 "warmStart",
207 "linkDown",
208 "linkUp",
209 "authenticationFailure",
210 "egpNeighborLoss",
211 "enterpriseSpecific"
212 #define GT_ENTERPRISE 6
213 };
214 #define DECODE_GenericTrap(t) \
215 ( t >= 0 && (size_t)t < sizeof(GenericTrap)/sizeof(GenericTrap[0]) \
216 ? GenericTrap[t] \
217 : (snprintf(buf, sizeof(buf), "gt=%d", t), buf))
218  
219 /*
220 * ASN.1 type class table
221 * Ties together the preceding Universal, Application, Context, and Private
222 * type definitions.
223 */
224 #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */
225 static const struct {
226 const char *name;
227 const char **Id;
228 int numIDs;
229 } Class[] = {
230 defineCLASS(Universal),
231 #define UNIVERSAL 0
232 defineCLASS(Application),
233 #define APPLICATION 1
234 defineCLASS(Context),
235 #define CONTEXT 2
236 defineCLASS(Private),
237 #define PRIVATE 3
238 defineCLASS(Exceptions),
239 #define EXCEPTIONS 4
240 };
241  
242 /*
243 * defined forms for ASN.1 types
244 */
245 static const char *Form[] = {
246 "Primitive",
247 #define PRIMITIVE 0
248 "Constructed",
249 #define CONSTRUCTED 1
250 };
251  
252 /*
253 * A structure for the OID tree for the compiled-in MIB.
254 * This is stored as a general-order tree.
255 */
256 struct obj {
257 const char *desc; /* name of object */
258 u_char oid; /* sub-id following parent */
259 u_char type; /* object type (unused) */
260 struct obj *child, *next; /* child and next sibling pointers */
261 } *objp = NULL;
262  
263 /*
264 * Include the compiled in SNMP MIB. "mib.h" is produced by feeding
265 * RFC-1156 format files into "makemib". "mib.h" MUST define at least
266 * a value for `mibroot'.
267 *
268 * In particular, this is gross, as this is including initialized structures,
269 * and by right shouldn't be an "include" file.
270 */
271 #include "mib.h"
272  
273 /*
274 * This defines a list of OIDs which will be abbreviated on output.
275 * Currently, this includes the prefixes for the Internet MIB, the
276 * private enterprises tree, and the experimental tree.
277 */
278 static const struct obj_abrev {
279 const char *prefix; /* prefix for this abrev */
280 struct obj *node; /* pointer into object table */
281 const char *oid; /* ASN.1 encoded OID */
282 } obj_abrev_list[] = {
283 #ifndef NO_ABREV_MIB
284 /* .iso.org.dod.internet.mgmt.mib */
285 { "", &_mib_obj, "\53\6\1\2\1" },
286 #endif
287 #ifndef NO_ABREV_ENTER
288 /* .iso.org.dod.internet.private.enterprises */
289 { "E:", &_enterprises_obj, "\53\6\1\4\1" },
290 #endif
291 #ifndef NO_ABREV_EXPERI
292 /* .iso.org.dod.internet.experimental */
293 { "X:", &_experimental_obj, "\53\6\1\3" },
294 #endif
295 #ifndef NO_ABBREV_SNMPMODS
296 /* .iso.org.dod.internet.snmpV2.snmpModules */
297 { "S:", &_snmpModules_obj, "\53\6\1\6\3" },
298 #endif
299 { 0,0,0 }
300 };
301  
302 /*
303 * This is used in the OID print routine to walk down the object tree
304 * rooted at `mibroot'.
305 */
306 #define OBJ_PRINT(o, suppressdot) \
307 { \
308 if (objp) { \
309 do { \
310 if ((o) == objp->oid) \
311 break; \
312 } while ((objp = objp->next) != NULL); \
313 } \
314 if (objp) { \
315 ND_PRINT((ndo, suppressdot?"%s":".%s", objp->desc)); \
316 objp = objp->child; \
317 } else \
318 ND_PRINT((ndo, suppressdot?"%u":".%u", (o))); \
319 }
320  
321 /*
322 * This is the definition for the Any-Data-Type storage used purely for
323 * temporary internal representation while decoding an ASN.1 data stream.
324 */
325 struct be {
326 uint32_t asnlen;
327 union {
328 caddr_t raw;
329 int32_t integer;
330 uint32_t uns;
331 const u_char *str;
332 struct {
333 uint32_t high;
334 uint32_t low;
335 } uns64;
336 } data;
337 u_short id;
338 u_char form, class; /* tag info */
339 u_char type;
340 #define BE_ANY 255
341 #define BE_NONE 0
342 #define BE_NULL 1
343 #define BE_OCTET 2
344 #define BE_OID 3
345 #define BE_INT 4
346 #define BE_UNS 5
347 #define BE_STR 6
348 #define BE_SEQ 7
349 #define BE_INETADDR 8
350 #define BE_PDU 9
351 #define BE_UNS64 10
352 #define BE_NOSUCHOBJECT 128
353 #define BE_NOSUCHINST 129
354 #define BE_ENDOFMIBVIEW 130
355 };
356  
357 /*
358 * SNMP versions recognized by this module
359 */
360 static const char *SnmpVersion[] = {
361 "SNMPv1",
362 #define SNMP_VERSION_1 0
363 "SNMPv2c",
364 #define SNMP_VERSION_2 1
365 "SNMPv2u",
366 #define SNMP_VERSION_2U 2
367 "SNMPv3"
368 #define SNMP_VERSION_3 3
369 };
370  
371 /*
372 * Defaults for SNMP PDU components
373 */
374 #define DEF_COMMUNITY "public"
375  
376 /*
377 * constants for ASN.1 decoding
378 */
379 #define OIDMUX 40
380 #define ASNLEN_INETADDR 4
381 #define ASN_SHIFT7 7
382 #define ASN_SHIFT8 8
383 #define ASN_BIT8 0x80
384 #define ASN_LONGLEN 0x80
385  
386 #define ASN_ID_BITS 0x1f
387 #define ASN_FORM_BITS 0x20
388 #define ASN_FORM_SHIFT 5
389 #define ASN_CLASS_BITS 0xc0
390 #define ASN_CLASS_SHIFT 6
391  
392 #define ASN_ID_EXT 0x1f /* extension ID in tag field */
393  
394 /*
395 * This decodes the next ASN.1 object in the stream pointed to by "p"
396 * (and of real-length "len") and stores the intermediate data in the
397 * provided BE object.
398 *
399 * This returns -l if it fails (i.e., the ASN.1 stream is not valid).
400 * O/w, this returns the number of bytes parsed from "p".
401 */
402 static int
403 asn1_parse(netdissect_options *ndo,
404 register const u_char *p, u_int len, struct be *elem)
405 {
406 u_char form, class, id;
407 int i, hdr;
408  
409 elem->asnlen = 0;
410 elem->type = BE_ANY;
411 if (len < 1) {
412 ND_PRINT((ndo, "[nothing to parse]"));
413 return -1;
414 }
415 ND_TCHECK(*p);
416  
417 /*
418 * it would be nice to use a bit field, but you can't depend on them.
419 * +---+---+---+---+---+---+---+---+
420 * + class |frm| id |
421 * +---+---+---+---+---+---+---+---+
422 * 7 6 5 4 3 2 1 0
423 */
424 id = *p & ASN_ID_BITS; /* lower 5 bits, range 00-1f */
425 #ifdef notdef
426 form = (*p & 0xe0) >> 5; /* move upper 3 bits to lower 3 */
427 class = form >> 1; /* bits 7&6 -> bits 1&0, range 0-3 */
428 form &= 0x1; /* bit 5 -> bit 0, range 0-1 */
429 #else
430 form = (u_char)(*p & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
431 class = (u_char)(*p & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT;
432 #endif
433 elem->form = form;
434 elem->class = class;
435 elem->id = id;
436 p++; len--; hdr = 1;
437 /* extended tag field */
438 if (id == ASN_ID_EXT) {
439 /*
440 * The ID follows, as a sequence of octets with the
441 * 8th bit set and the remaining 7 bits being
442 * the next 7 bits of the value, terminated with
443 * an octet with the 8th bit not set.
444 *
445 * First, assemble all the octets with the 8th
446 * bit set. XXX - this doesn't handle a value
447 * that won't fit in 32 bits.
448 */
449 for (id = 0; *p & ASN_BIT8; len--, hdr++, p++) {
450 if (len < 1) {
451 ND_PRINT((ndo, "[Xtagfield?]"));
452 return -1;
453 }
454 ND_TCHECK(*p);
455 id = (id << 7) | (*p & ~ASN_BIT8);
456 }
457 if (len < 1) {
458 ND_PRINT((ndo, "[Xtagfield?]"));
459 return -1;
460 }
461 ND_TCHECK(*p);
462 elem->id = id = (id << 7) | *p;
463 --len;
464 ++hdr;
465 ++p;
466 }
467 if (len < 1) {
468 ND_PRINT((ndo, "[no asnlen]"));
469 return -1;
470 }
471 ND_TCHECK(*p);
472 elem->asnlen = *p;
473 p++; len--; hdr++;
474 if (elem->asnlen & ASN_BIT8) {
475 uint32_t noct = elem->asnlen % ASN_BIT8;
476 elem->asnlen = 0;
477 if (len < noct) {
478 ND_PRINT((ndo, "[asnlen? %d<%d]", len, noct));
479 return -1;
480 }
481 ND_TCHECK2(*p, noct);
482 for (; noct-- > 0; len--, hdr++)
483 elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
484 }
485 if (len < elem->asnlen) {
486 ND_PRINT((ndo, "[len%d<asnlen%u]", len, elem->asnlen));
487 return -1;
488 }
489 if (form >= sizeof(Form)/sizeof(Form[0])) {
490 ND_PRINT((ndo, "[form?%d]", form));
491 return -1;
492 }
493 if (class >= sizeof(Class)/sizeof(Class[0])) {
494 ND_PRINT((ndo, "[class?%c/%d]", *Form[form], class));
495 return -1;
496 }
497 if ((int)id >= Class[class].numIDs) {
498 ND_PRINT((ndo, "[id?%c/%s/%d]", *Form[form], Class[class].name, id));
499 return -1;
500 }
501  
502 switch (form) {
503 case PRIMITIVE:
504 switch (class) {
505 case UNIVERSAL:
506 switch (id) {
507 case STRING:
508 elem->type = BE_STR;
509 elem->data.str = p;
510 break;
511  
512 case INTEGER: {
513 register int32_t data;
514 elem->type = BE_INT;
515 data = 0;
516  
517 ND_TCHECK2(*p, elem->asnlen);
518 if (*p & ASN_BIT8) /* negative */
519 data = -1;
520 for (i = elem->asnlen; i-- > 0; p++)
521 data = (data << ASN_SHIFT8) | *p;
522 elem->data.integer = data;
523 break;
524 }
525  
526 case OBJECTID:
527 elem->type = BE_OID;
528 elem->data.raw = (caddr_t)p;
529 break;
530  
531 case ASN_NULL:
532 elem->type = BE_NULL;
533 elem->data.raw = NULL;
534 break;
535  
536 default:
537 elem->type = BE_OCTET;
538 elem->data.raw = (caddr_t)p;
539 ND_PRINT((ndo, "[P/U/%s]", Class[class].Id[id]));
540 break;
541 }
542 break;
543  
544 case APPLICATION:
545 switch (id) {
546 case IPADDR:
547 elem->type = BE_INETADDR;
548 elem->data.raw = (caddr_t)p;
549 break;
550  
551 case COUNTER:
552 case GAUGE:
553 case TIMETICKS: {
554 register uint32_t data;
555 ND_TCHECK2(*p, elem->asnlen);
556 elem->type = BE_UNS;
557 data = 0;
558 for (i = elem->asnlen; i-- > 0; p++)
559 data = (data << 8) + *p;
560 elem->data.uns = data;
561 break;
562 }
563  
564 case COUNTER64: {
565 register uint32_t high, low;
566 ND_TCHECK2(*p, elem->asnlen);
567 elem->type = BE_UNS64;
568 high = 0, low = 0;
569 for (i = elem->asnlen; i-- > 0; p++) {
570 high = (high << 8) |
571 ((low & 0xFF000000) >> 24);
572 low = (low << 8) | *p;
573 }
574 elem->data.uns64.high = high;
575 elem->data.uns64.low = low;
576 break;
577 }
578  
579 default:
580 elem->type = BE_OCTET;
581 elem->data.raw = (caddr_t)p;
582 ND_PRINT((ndo, "[P/A/%s]",
583 Class[class].Id[id]));
584 break;
585 }
586 break;
587  
588 case CONTEXT:
589 switch (id) {
590 case NOSUCHOBJECT:
591 elem->type = BE_NOSUCHOBJECT;
592 elem->data.raw = NULL;
593 break;
594  
595 case NOSUCHINSTANCE:
596 elem->type = BE_NOSUCHINST;
597 elem->data.raw = NULL;
598 break;
599  
600 case ENDOFMIBVIEW:
601 elem->type = BE_ENDOFMIBVIEW;
602 elem->data.raw = NULL;
603 break;
604 }
605 break;
606  
607 default:
608 ND_PRINT((ndo, "[P/%s/%s]", Class[class].name, Class[class].Id[id]));
609 ND_TCHECK2(*p, elem->asnlen);
610 elem->type = BE_OCTET;
611 elem->data.raw = (caddr_t)p;
612 break;
613 }
614 break;
615  
616 case CONSTRUCTED:
617 switch (class) {
618 case UNIVERSAL:
619 switch (id) {
620 case SEQUENCE:
621 elem->type = BE_SEQ;
622 elem->data.raw = (caddr_t)p;
623 break;
624  
625 default:
626 elem->type = BE_OCTET;
627 elem->data.raw = (caddr_t)p;
628 ND_PRINT((ndo, "C/U/%s", Class[class].Id[id]));
629 break;
630 }
631 break;
632  
633 case CONTEXT:
634 elem->type = BE_PDU;
635 elem->data.raw = (caddr_t)p;
636 break;
637  
638 default:
639 elem->type = BE_OCTET;
640 elem->data.raw = (caddr_t)p;
641 ND_PRINT((ndo, "C/%s/%s", Class[class].name, Class[class].Id[id]));
642 break;
643 }
644 break;
645 }
646 p += elem->asnlen;
647 len -= elem->asnlen;
648 return elem->asnlen + hdr;
649  
650 trunc:
651 ND_PRINT((ndo, "%s", tstr));
652 return -1;
653 }
654  
655 /*
656 * Display the ASN.1 object represented by the BE object.
657 * This used to be an integral part of asn1_parse() before the intermediate
658 * BE form was added.
659 */
660 static int
661 asn1_print(netdissect_options *ndo,
662 struct be *elem)
663 {
664 u_char *p = (u_char *)elem->data.raw;
665 uint32_t asnlen = elem->asnlen;
666 uint32_t i;
667  
668 switch (elem->type) {
669  
670 case BE_OCTET:
671 ND_TCHECK2(*p, asnlen);
672 for (i = asnlen; i-- > 0; p++)
673 ND_PRINT((ndo, "_%.2x", *p));
674 break;
675  
676 case BE_NULL:
677 break;
678  
679 case BE_OID: {
680 int o = 0, first = -1, i = asnlen;
681  
682 if (!ndo->ndo_sflag && !ndo->ndo_nflag && asnlen > 2) {
683 const struct obj_abrev *a = &obj_abrev_list[0];
684 size_t a_len = strlen(a->oid);
685 for (; a->node; a++) {
686 ND_TCHECK2(*p, a_len);
687 if (memcmp(a->oid, (char *)p, a_len) == 0) {
688 objp = a->node->child;
689 i -= strlen(a->oid);
690 p += strlen(a->oid);
691 ND_PRINT((ndo, "%s", a->prefix));
692 first = 1;
693 break;
694 }
695 }
696 }
697  
698 for (; !ndo->ndo_sflag && i-- > 0; p++) {
699 ND_TCHECK(*p);
700 o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
701 if (*p & ASN_LONGLEN)
702 continue;
703  
704 /*
705 * first subitem encodes two items with 1st*OIDMUX+2nd
706 * (see X.690:1997 clause 8.19 for the details)
707 */
708 if (first < 0) {
709 int s;
710 if (!ndo->ndo_nflag)
711 objp = mibroot;
712 first = 0;
713 s = o / OIDMUX;
714 if (s > 2) s = 2;
715 OBJ_PRINT(s, first);
716 o -= s * OIDMUX;
717 }
718 OBJ_PRINT(o, first);
719 if (--first < 0)
720 first = 0;
721 o = 0;
722 }
723 break;
724 }
725  
726 case BE_INT:
727 ND_PRINT((ndo, "%d", elem->data.integer));
728 break;
729  
730 case BE_UNS:
731 ND_PRINT((ndo, "%u", elem->data.uns));
732 break;
733  
734 case BE_UNS64: { /* idea borrowed from by Marshall Rose */
735 double d;
736 int j, carry;
737 char *cpf, *cpl, last[6], first[30];
738 if (elem->data.uns64.high == 0) {
739 ND_PRINT((ndo, "%u", elem->data.uns64.low));
740 break;
741 }
742 d = elem->data.uns64.high * 4294967296.0; /* 2^32 */
743 if (elem->data.uns64.high <= 0x1fffff) {
744 d += elem->data.uns64.low;
745 #if 0 /*is looks illegal, but what is the intention?*/
746 ND_PRINT((ndo, "%.f", d));
747 #else
748 ND_PRINT((ndo, "%f", d));
749 #endif
750 break;
751 }
752 d += (elem->data.uns64.low & 0xfffff000);
753 #if 0 /*is looks illegal, but what is the intention?*/
754 snprintf(first, sizeof(first), "%.f", d);
755 #else
756 snprintf(first, sizeof(first), "%f", d);
757 #endif
758 snprintf(last, sizeof(last), "%5.5d",
759 elem->data.uns64.low & 0xfff);
760 for (carry = 0, cpf = first+strlen(first)-1, cpl = last+4;
761 cpl >= last;
762 cpf--, cpl--) {
763 j = carry + (*cpf - '0') + (*cpl - '0');
764 if (j > 9) {
765 j -= 10;
766 carry = 1;
767 } else {
768 carry = 0;
769 }
770 *cpf = j + '0';
771 }
772 ND_PRINT((ndo, "%s", first));
773 break;
774 }
775  
776 case BE_STR: {
777 register int printable = 1, first = 1;
778 const u_char *p = elem->data.str;
779 ND_TCHECK2(*p, asnlen);
780 for (i = asnlen; printable && i-- > 0; p++)
781 printable = ND_ISPRINT(*p);
782 p = elem->data.str;
783 if (printable) {
784 ND_PRINT((ndo, "\""));
785 if (fn_printn(ndo, p, asnlen, ndo->ndo_snapend)) {
786 ND_PRINT((ndo, "\""));
787 goto trunc;
788 }
789 ND_PRINT((ndo, "\""));
790 } else
791 for (i = asnlen; i-- > 0; p++) {
792 ND_PRINT((ndo, first ? "%.2x" : "_%.2x", *p));
793 first = 0;
794 }
795 break;
796 }
797  
798 case BE_SEQ:
799 ND_PRINT((ndo, "Seq(%u)", elem->asnlen));
800 break;
801  
802 case BE_INETADDR:
803 if (asnlen != ASNLEN_INETADDR)
804 ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR));
805 ND_TCHECK2(*p, asnlen);
806 for (i = asnlen; i-- != 0; p++) {
807 ND_PRINT((ndo, (i == asnlen-1) ? "%u" : ".%u", *p));
808 }
809 break;
810  
811 case BE_NOSUCHOBJECT:
812 case BE_NOSUCHINST:
813 case BE_ENDOFMIBVIEW:
814 ND_PRINT((ndo, "[%s]", Class[EXCEPTIONS].Id[elem->id]));
815 break;
816  
817 case BE_PDU:
818 ND_PRINT((ndo, "%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen));
819 break;
820  
821 case BE_ANY:
822 ND_PRINT((ndo, "[BE_ANY!?]"));
823 break;
824  
825 default:
826 ND_PRINT((ndo, "[be!?]"));
827 break;
828 }
829 return 0;
830  
831 trunc:
832 ND_PRINT((ndo, "%s", tstr));
833 return -1;
834 }
835  
836 #ifdef notdef
837 /*
838 * This is a brute force ASN.1 printer: recurses to dump an entire structure.
839 * This will work for any ASN.1 stream, not just an SNMP PDU.
840 *
841 * By adding newlines and spaces at the correct places, this would print in
842 * Rose-Normal-Form.
843 *
844 * This is not currently used.
845 */
846 static void
847 asn1_decode(u_char *p, u_int length)
848 {
849 struct be elem;
850 int i = 0;
851  
852 while (i >= 0 && length > 0) {
853 i = asn1_parse(ndo, p, length, &elem);
854 if (i >= 0) {
855 ND_PRINT((ndo, " "));
856 if (asn1_print(ndo, &elem) < 0)
857 return;
858 if (elem.type == BE_SEQ || elem.type == BE_PDU) {
859 ND_PRINT((ndo, " {"));
860 asn1_decode(elem.data.raw, elem.asnlen);
861 ND_PRINT((ndo, " }"));
862 }
863 length -= i;
864 p += i;
865 }
866 }
867 }
868 #endif
869  
870 #ifdef USE_LIBSMI
871  
872 struct smi2be {
873 SmiBasetype basetype;
874 int be;
875 };
876  
877 static const struct smi2be smi2betab[] = {
878 { SMI_BASETYPE_INTEGER32, BE_INT },
879 { SMI_BASETYPE_OCTETSTRING, BE_STR },
880 { SMI_BASETYPE_OCTETSTRING, BE_INETADDR },
881 { SMI_BASETYPE_OBJECTIDENTIFIER, BE_OID },
882 { SMI_BASETYPE_UNSIGNED32, BE_UNS },
883 { SMI_BASETYPE_INTEGER64, BE_NONE },
884 { SMI_BASETYPE_UNSIGNED64, BE_UNS64 },
885 { SMI_BASETYPE_FLOAT32, BE_NONE },
886 { SMI_BASETYPE_FLOAT64, BE_NONE },
887 { SMI_BASETYPE_FLOAT128, BE_NONE },
888 { SMI_BASETYPE_ENUM, BE_INT },
889 { SMI_BASETYPE_BITS, BE_STR },
890 { SMI_BASETYPE_UNKNOWN, BE_NONE }
891 };
892  
893 static int
894 smi_decode_oid(netdissect_options *ndo,
895 struct be *elem, unsigned int *oid,
896 unsigned int oidsize, unsigned int *oidlen)
897 {
898 u_char *p = (u_char *)elem->data.raw;
899 uint32_t asnlen = elem->asnlen;
900 int o = 0, first = -1, i = asnlen;
901 unsigned int firstval;
902  
903 for (*oidlen = 0; ndo->ndo_sflag && i-- > 0; p++) {
904 ND_TCHECK(*p);
905 o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
906 if (*p & ASN_LONGLEN)
907 continue;
908  
909 /*
910 * first subitem encodes two items with 1st*OIDMUX+2nd
911 * (see X.690:1997 clause 8.19 for the details)
912 */
913 if (first < 0) {
914 first = 0;
915 firstval = o / OIDMUX;
916 if (firstval > 2) firstval = 2;
917 o -= firstval * OIDMUX;
918 if (*oidlen < oidsize) {
919 oid[(*oidlen)++] = firstval;
920 }
921 }
922 if (*oidlen < oidsize) {
923 oid[(*oidlen)++] = o;
924 }
925 o = 0;
926 }
927 return 0;
928  
929 trunc:
930 ND_PRINT((ndo, "%s", tstr));
931 return -1;
932 }
933  
934 static int smi_check_type(SmiBasetype basetype, int be)
935 {
936 int i;
937  
938 for (i = 0; smi2betab[i].basetype != SMI_BASETYPE_UNKNOWN; i++) {
939 if (smi2betab[i].basetype == basetype && smi2betab[i].be == be) {
940 return 1;
941 }
942 }
943  
944 return 0;
945 }
946  
947 static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
948 struct be *elem)
949 {
950 int ok = 1;
951  
952 switch (smiType->basetype) {
953 case SMI_BASETYPE_OBJECTIDENTIFIER:
954 case SMI_BASETYPE_OCTETSTRING:
955 if (smiRange->minValue.value.unsigned32
956 == smiRange->maxValue.value.unsigned32) {
957 ok = (elem->asnlen == smiRange->minValue.value.unsigned32);
958 } else {
959 ok = (elem->asnlen >= smiRange->minValue.value.unsigned32
960 && elem->asnlen <= smiRange->maxValue.value.unsigned32);
961 }
962 break;
963  
964 case SMI_BASETYPE_INTEGER32:
965 ok = (elem->data.integer >= smiRange->minValue.value.integer32
966 && elem->data.integer <= smiRange->maxValue.value.integer32);
967 break;
968  
969 case SMI_BASETYPE_UNSIGNED32:
970 ok = (elem->data.uns >= smiRange->minValue.value.unsigned32
971 && elem->data.uns <= smiRange->maxValue.value.unsigned32);
972 break;
973  
974 case SMI_BASETYPE_UNSIGNED64:
975 /* XXX */
976 break;
977  
978 /* case SMI_BASETYPE_INTEGER64: SMIng */
979 /* case SMI_BASETYPE_FLOAT32: SMIng */
980 /* case SMI_BASETYPE_FLOAT64: SMIng */
981 /* case SMI_BASETYPE_FLOAT128: SMIng */
982  
983 case SMI_BASETYPE_ENUM:
984 case SMI_BASETYPE_BITS:
985 case SMI_BASETYPE_UNKNOWN:
986 ok = 1;
987 break;
988  
989 default:
990 ok = 0;
991 break;
992 }
993  
994 return ok;
995 }
996  
997 static int smi_check_range(SmiType *smiType, struct be *elem)
998 {
999 SmiRange *smiRange;
1000 int ok = 1;
1001  
1002 for (smiRange = smiGetFirstRange(smiType);
1003 smiRange;
1004 smiRange = smiGetNextRange(smiRange)) {
1005  
1006 ok = smi_check_a_range(smiType, smiRange, elem);
1007  
1008 if (ok) {
1009 break;
1010 }
1011 }
1012  
1013 if (ok) {
1014 SmiType *parentType;
1015 parentType = smiGetParentType(smiType);
1016 if (parentType) {
1017 ok = smi_check_range(parentType, elem);
1018 }
1019 }
1020  
1021 return ok;
1022 }
1023  
1024 static SmiNode *
1025 smi_print_variable(netdissect_options *ndo,
1026 struct be *elem, int *status)
1027 {
1028 unsigned int oid[128], oidlen;
1029 SmiNode *smiNode = NULL;
1030 unsigned int i;
1031  
1032 *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),
1033 &oidlen);
1034 if (*status < 0)
1035 return NULL;
1036 smiNode = smiGetNodeByOID(oidlen, oid);
1037 if (! smiNode) {
1038 *status = asn1_print(ndo, elem);
1039 return NULL;
1040 }
1041 if (ndo->ndo_vflag) {
1042 ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
1043 }
1044 ND_PRINT((ndo, "%s", smiNode->name));
1045 if (smiNode->oidlen < oidlen) {
1046 for (i = smiNode->oidlen; i < oidlen; i++) {
1047 ND_PRINT((ndo, ".%u", oid[i]));
1048 }
1049 }
1050 *status = 0;
1051 return smiNode;
1052 }
1053  
1054 static int
1055 smi_print_value(netdissect_options *ndo,
1056 SmiNode *smiNode, u_char pduid, struct be *elem)
1057 {
1058 unsigned int i, oid[128], oidlen;
1059 SmiType *smiType;
1060 SmiNamedNumber *nn;
1061 int done = 0;
1062  
1063 if (! smiNode || ! (smiNode->nodekind
1064 & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {
1065 return asn1_print(ndo, elem);
1066 }
1067  
1068 if (elem->type == BE_NOSUCHOBJECT
1069 || elem->type == BE_NOSUCHINST
1070 || elem->type == BE_ENDOFMIBVIEW) {
1071 return asn1_print(ndo, elem);
1072 }
1073  
1074 if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
1075 ND_PRINT((ndo, "[notNotifyable]"));
1076 }
1077  
1078 if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) {
1079 ND_PRINT((ndo, "[notReadable]"));
1080 }
1081  
1082 if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) {
1083 ND_PRINT((ndo, "[notWritable]"));
1084 }
1085  
1086 if (RESPONSE_CLASS(pduid)
1087 && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {
1088 ND_PRINT((ndo, "[noAccess]"));
1089 }
1090  
1091 smiType = smiGetNodeType(smiNode);
1092 if (! smiType) {
1093 return asn1_print(ndo, elem);
1094 }
1095  
1096 if (! smi_check_type(smiType->basetype, elem->type)) {
1097 ND_PRINT((ndo, "[wrongType]"));
1098 }
1099  
1100 if (! smi_check_range(smiType, elem)) {
1101 ND_PRINT((ndo, "[outOfRange]"));
1102 }
1103  
1104 /* resolve bits to named bits */
1105  
1106 /* check whether instance identifier is valid */
1107  
1108 /* apply display hints (integer, octetstring) */
1109  
1110 /* convert instance identifier to index type values */
1111  
1112 switch (elem->type) {
1113 case BE_OID:
1114 if (smiType->basetype == SMI_BASETYPE_BITS) {
1115 /* print bit labels */
1116 } else {
1117 smi_decode_oid(ndo, elem, oid,
1118 sizeof(oid)/sizeof(unsigned int),
1119 &oidlen);
1120 smiNode = smiGetNodeByOID(oidlen, oid);
1121 if (smiNode) {
1122 if (ndo->ndo_vflag) {
1123 ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
1124 }
1125 ND_PRINT((ndo, "%s", smiNode->name));
1126 if (smiNode->oidlen < oidlen) {
1127 for (i = smiNode->oidlen;
1128 i < oidlen; i++) {
1129 ND_PRINT((ndo, ".%u", oid[i]));
1130 }
1131 }
1132 done++;
1133 }
1134 }
1135 break;
1136  
1137 case BE_INT:
1138 if (smiType->basetype == SMI_BASETYPE_ENUM) {
1139 for (nn = smiGetFirstNamedNumber(smiType);
1140 nn;
1141 nn = smiGetNextNamedNumber(nn)) {
1142 if (nn->value.value.integer32
1143 == elem->data.integer) {
1144 ND_PRINT((ndo, "%s", nn->name));
1145 ND_PRINT((ndo, "(%d)", elem->data.integer));
1146 done++;
1147 break;
1148 }
1149 }
1150 }
1151 break;
1152 }
1153  
1154 if (! done) {
1155 return asn1_print(ndo, elem);
1156 }
1157 return 0;
1158 }
1159 #endif
1160  
1161 /*
1162 * General SNMP header
1163 * SEQUENCE {
1164 * version INTEGER {version-1(0)},
1165 * community OCTET STRING,
1166 * data ANY -- PDUs
1167 * }
1168 * PDUs for all but Trap: (see rfc1157 from page 15 on)
1169 * SEQUENCE {
1170 * request-id INTEGER,
1171 * error-status INTEGER,
1172 * error-index INTEGER,
1173 * varbindlist SEQUENCE OF
1174 * SEQUENCE {
1175 * name ObjectName,
1176 * value ObjectValue
1177 * }
1178 * }
1179 * PDU for Trap:
1180 * SEQUENCE {
1181 * enterprise OBJECT IDENTIFIER,
1182 * agent-addr NetworkAddress,
1183 * generic-trap INTEGER,
1184 * specific-trap INTEGER,
1185 * time-stamp TimeTicks,
1186 * varbindlist SEQUENCE OF
1187 * SEQUENCE {
1188 * name ObjectName,
1189 * value ObjectValue
1190 * }
1191 * }
1192 */
1193  
1194 /*
1195 * Decode SNMP varBind
1196 */
1197 static void
1198 varbind_print(netdissect_options *ndo,
1199 u_char pduid, const u_char *np, u_int length)
1200 {
1201 struct be elem;
1202 int count = 0, ind;
1203 #ifdef USE_LIBSMI
1204 SmiNode *smiNode = NULL;
1205 #endif
1206 int status;
1207  
1208 /* Sequence of varBind */
1209 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1210 return;
1211 if (elem.type != BE_SEQ) {
1212 ND_PRINT((ndo, "[!SEQ of varbind]"));
1213 asn1_print(ndo, &elem);
1214 return;
1215 }
1216 if ((u_int)count < length)
1217 ND_PRINT((ndo, "[%d extra after SEQ of varbind]", length - count));
1218 /* descend */
1219 length = elem.asnlen;
1220 np = (u_char *)elem.data.raw;
1221  
1222 for (ind = 1; length > 0; ind++) {
1223 const u_char *vbend;
1224 u_int vblength;
1225  
1226 ND_PRINT((ndo, " "));
1227  
1228 /* Sequence */
1229 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1230 return;
1231 if (elem.type != BE_SEQ) {
1232 ND_PRINT((ndo, "[!varbind]"));
1233 asn1_print(ndo, &elem);
1234 return;
1235 }
1236 vbend = np + count;
1237 vblength = length - count;
1238 /* descend */
1239 length = elem.asnlen;
1240 np = (u_char *)elem.data.raw;
1241  
1242 /* objName (OID) */
1243 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1244 return;
1245 if (elem.type != BE_OID) {
1246 ND_PRINT((ndo, "[objName!=OID]"));
1247 asn1_print(ndo, &elem);
1248 return;
1249 }
1250 #ifdef USE_LIBSMI
1251 smiNode = smi_print_variable(ndo, &elem, &status);
1252 #else
1253 status = asn1_print(ndo, &elem);
1254 #endif
1255 if (status < 0)
1256 return;
1257 length -= count;
1258 np += count;
1259  
1260 if (pduid != GETREQ && pduid != GETNEXTREQ
1261 && pduid != GETBULKREQ)
1262 ND_PRINT((ndo, "="));
1263  
1264 /* objVal (ANY) */
1265 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1266 return;
1267 if (pduid == GETREQ || pduid == GETNEXTREQ
1268 || pduid == GETBULKREQ) {
1269 if (elem.type != BE_NULL) {
1270 ND_PRINT((ndo, "[objVal!=NULL]"));
1271 if (asn1_print(ndo, &elem) < 0)
1272 return;
1273 }
1274 } else {
1275 if (elem.type != BE_NULL) {
1276 #ifdef USE_LIBSMI
1277 status = smi_print_value(ndo, smiNode, pduid, &elem);
1278 #else
1279 status = asn1_print(ndo, &elem);
1280 #endif
1281 }
1282 if (status < 0)
1283 return;
1284 }
1285 length = vblength;
1286 np = vbend;
1287 }
1288 }
1289  
1290 /*
1291 * Decode SNMP PDUs: GetRequest, GetNextRequest, GetResponse, SetRequest,
1292 * GetBulk, Inform, V2Trap, and Report
1293 */
1294 static void
1295 snmppdu_print(netdissect_options *ndo,
1296 u_short pduid, const u_char *np, u_int length)
1297 {
1298 struct be elem;
1299 int count = 0, error;
1300  
1301 /* reqId (Integer) */
1302 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1303 return;
1304 if (elem.type != BE_INT) {
1305 ND_PRINT((ndo, "[reqId!=INT]"));
1306 asn1_print(ndo, &elem);
1307 return;
1308 }
1309 if (ndo->ndo_vflag)
1310 ND_PRINT((ndo, "R=%d ", elem.data.integer));
1311 length -= count;
1312 np += count;
1313  
1314 /* errorStatus (Integer) */
1315 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1316 return;
1317 if (elem.type != BE_INT) {
1318 ND_PRINT((ndo, "[errorStatus!=INT]"));
1319 asn1_print(ndo, &elem);
1320 return;
1321 }
1322 error = 0;
1323 if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
1324 || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
1325 && elem.data.integer != 0) {
1326 char errbuf[20];
1327 ND_PRINT((ndo, "[errorStatus(%s)!=0]",
1328 DECODE_ErrorStatus(elem.data.integer)));
1329 } else if (pduid == GETBULKREQ) {
1330 ND_PRINT((ndo, " N=%d", elem.data.integer));
1331 } else if (elem.data.integer != 0) {
1332 char errbuf[20];
1333 ND_PRINT((ndo, " %s", DECODE_ErrorStatus(elem.data.integer)));
1334 error = elem.data.integer;
1335 }
1336 length -= count;
1337 np += count;
1338  
1339 /* errorIndex (Integer) */
1340 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1341 return;
1342 if (elem.type != BE_INT) {
1343 ND_PRINT((ndo, "[errorIndex!=INT]"));
1344 asn1_print(ndo, &elem);
1345 return;
1346 }
1347 if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
1348 || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
1349 && elem.data.integer != 0)
1350 ND_PRINT((ndo, "[errorIndex(%d)!=0]", elem.data.integer));
1351 else if (pduid == GETBULKREQ)
1352 ND_PRINT((ndo, " M=%d", elem.data.integer));
1353 else if (elem.data.integer != 0) {
1354 if (!error)
1355 ND_PRINT((ndo, "[errorIndex(%d) w/o errorStatus]", elem.data.integer));
1356 else {
1357 ND_PRINT((ndo, "@%d", elem.data.integer));
1358 error = elem.data.integer;
1359 }
1360 } else if (error) {
1361 ND_PRINT((ndo, "[errorIndex==0]"));
1362 error = 0;
1363 }
1364 length -= count;
1365 np += count;
1366  
1367 varbind_print(ndo, pduid, np, length);
1368 return;
1369 }
1370  
1371 /*
1372 * Decode SNMP Trap PDU
1373 */
1374 static void
1375 trappdu_print(netdissect_options *ndo,
1376 const u_char *np, u_int length)
1377 {
1378 struct be elem;
1379 int count = 0, generic;
1380  
1381 ND_PRINT((ndo, " "));
1382  
1383 /* enterprise (oid) */
1384 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1385 return;
1386 if (elem.type != BE_OID) {
1387 ND_PRINT((ndo, "[enterprise!=OID]"));
1388 asn1_print(ndo, &elem);
1389 return;
1390 }
1391 if (asn1_print(ndo, &elem) < 0)
1392 return;
1393 length -= count;
1394 np += count;
1395  
1396 ND_PRINT((ndo, " "));
1397  
1398 /* agent-addr (inetaddr) */
1399 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1400 return;
1401 if (elem.type != BE_INETADDR) {
1402 ND_PRINT((ndo, "[agent-addr!=INETADDR]"));
1403 asn1_print(ndo, &elem);
1404 return;
1405 }
1406 if (asn1_print(ndo, &elem) < 0)
1407 return;
1408 length -= count;
1409 np += count;
1410  
1411 /* generic-trap (Integer) */
1412 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1413 return;
1414 if (elem.type != BE_INT) {
1415 ND_PRINT((ndo, "[generic-trap!=INT]"));
1416 asn1_print(ndo, &elem);
1417 return;
1418 }
1419 generic = elem.data.integer;
1420 {
1421 char buf[20];
1422 ND_PRINT((ndo, " %s", DECODE_GenericTrap(generic)));
1423 }
1424 length -= count;
1425 np += count;
1426  
1427 /* specific-trap (Integer) */
1428 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1429 return;
1430 if (elem.type != BE_INT) {
1431 ND_PRINT((ndo, "[specific-trap!=INT]"));
1432 asn1_print(ndo, &elem);
1433 return;
1434 }
1435 if (generic != GT_ENTERPRISE) {
1436 if (elem.data.integer != 0)
1437 ND_PRINT((ndo, "[specific-trap(%d)!=0]", elem.data.integer));
1438 } else
1439 ND_PRINT((ndo, " s=%d", elem.data.integer));
1440 length -= count;
1441 np += count;
1442  
1443 ND_PRINT((ndo, " "));
1444  
1445 /* time-stamp (TimeTicks) */
1446 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1447 return;
1448 if (elem.type != BE_UNS) { /* XXX */
1449 ND_PRINT((ndo, "[time-stamp!=TIMETICKS]"));
1450 asn1_print(ndo, &elem);
1451 return;
1452 }
1453 if (asn1_print(ndo, &elem) < 0)
1454 return;
1455 length -= count;
1456 np += count;
1457  
1458 varbind_print(ndo, TRAP, np, length);
1459 return;
1460 }
1461  
1462 /*
1463 * Decode arbitrary SNMP PDUs.
1464 */
1465 static void
1466 pdu_print(netdissect_options *ndo,
1467 const u_char *np, u_int length, int version)
1468 {
1469 struct be pdu;
1470 int count = 0;
1471  
1472 /* PDU (Context) */
1473 if ((count = asn1_parse(ndo, np, length, &pdu)) < 0)
1474 return;
1475 if (pdu.type != BE_PDU) {
1476 ND_PRINT((ndo, "[no PDU]"));
1477 return;
1478 }
1479 if ((u_int)count < length)
1480 ND_PRINT((ndo, "[%d extra after PDU]", length - count));
1481 if (ndo->ndo_vflag) {
1482 ND_PRINT((ndo, "{ "));
1483 }
1484 if (asn1_print(ndo, &pdu) < 0)
1485 return;
1486 ND_PRINT((ndo, " "));
1487 /* descend into PDU */
1488 length = pdu.asnlen;
1489 np = (u_char *)pdu.data.raw;
1490  
1491 if (version == SNMP_VERSION_1 &&
1492 (pdu.id == GETBULKREQ || pdu.id == INFORMREQ ||
1493 pdu.id == V2TRAP || pdu.id == REPORT)) {
1494 ND_PRINT((ndo, "[v2 PDU in v1 message]"));
1495 return;
1496 }
1497  
1498 if (version == SNMP_VERSION_2 && pdu.id == TRAP) {
1499 ND_PRINT((ndo, "[v1 PDU in v2 message]"));
1500 return;
1501 }
1502  
1503 switch (pdu.id) {
1504 case TRAP:
1505 trappdu_print(ndo, np, length);
1506 break;
1507 case GETREQ:
1508 case GETNEXTREQ:
1509 case GETRESP:
1510 case SETREQ:
1511 case GETBULKREQ:
1512 case INFORMREQ:
1513 case V2TRAP:
1514 case REPORT:
1515 snmppdu_print(ndo, pdu.id, np, length);
1516 break;
1517 }
1518  
1519 if (ndo->ndo_vflag) {
1520 ND_PRINT((ndo, " } "));
1521 }
1522 }
1523  
1524 /*
1525 * Decode a scoped SNMP PDU.
1526 */
1527 static void
1528 scopedpdu_print(netdissect_options *ndo,
1529 const u_char *np, u_int length, int version)
1530 {
1531 struct be elem;
1532 int i, count = 0;
1533  
1534 /* Sequence */
1535 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1536 return;
1537 if (elem.type != BE_SEQ) {
1538 ND_PRINT((ndo, "[!scoped PDU]"));
1539 asn1_print(ndo, &elem);
1540 return;
1541 }
1542 length = elem.asnlen;
1543 np = (u_char *)elem.data.raw;
1544  
1545 /* contextEngineID (OCTET STRING) */
1546 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1547 return;
1548 if (elem.type != BE_STR) {
1549 ND_PRINT((ndo, "[contextEngineID!=STR]"));
1550 asn1_print(ndo, &elem);
1551 return;
1552 }
1553 length -= count;
1554 np += count;
1555  
1556 ND_PRINT((ndo, "E= "));
1557 for (i = 0; i < (int)elem.asnlen; i++) {
1558 ND_PRINT((ndo, "0x%02X", elem.data.str[i]));
1559 }
1560 ND_PRINT((ndo, " "));
1561  
1562 /* contextName (OCTET STRING) */
1563 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1564 return;
1565 if (elem.type != BE_STR) {
1566 ND_PRINT((ndo, "[contextName!=STR]"));
1567 asn1_print(ndo, &elem);
1568 return;
1569 }
1570 length -= count;
1571 np += count;
1572  
1573 ND_PRINT((ndo, "C=%.*s ", (int)elem.asnlen, elem.data.str));
1574  
1575 pdu_print(ndo, np, length, version);
1576 }
1577  
1578 /*
1579 * Decode SNMP Community Header (SNMPv1 and SNMPv2c)
1580 */
1581 static void
1582 community_print(netdissect_options *ndo,
1583 const u_char *np, u_int length, int version)
1584 {
1585 struct be elem;
1586 int count = 0;
1587  
1588 /* Community (String) */
1589 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1590 return;
1591 if (elem.type != BE_STR) {
1592 ND_PRINT((ndo, "[comm!=STR]"));
1593 asn1_print(ndo, &elem);
1594 return;
1595 }
1596 /* default community */
1597 if (!(elem.asnlen == sizeof(DEF_COMMUNITY) - 1 &&
1598 strncmp((char *)elem.data.str, DEF_COMMUNITY,
1599 sizeof(DEF_COMMUNITY) - 1) == 0))
1600 /* ! "public" */
1601 ND_PRINT((ndo, "C=%.*s ", (int)elem.asnlen, elem.data.str));
1602 length -= count;
1603 np += count;
1604  
1605 pdu_print(ndo, np, length, version);
1606 }
1607  
1608 /*
1609 * Decode SNMPv3 User-based Security Message Header (SNMPv3)
1610 */
1611 static void
1612 usm_print(netdissect_options *ndo,
1613 const u_char *np, u_int length)
1614 {
1615 struct be elem;
1616 int count = 0;
1617  
1618 /* Sequence */
1619 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1620 return;
1621 if (elem.type != BE_SEQ) {
1622 ND_PRINT((ndo, "[!usm]"));
1623 asn1_print(ndo, &elem);
1624 return;
1625 }
1626 length = elem.asnlen;
1627 np = (u_char *)elem.data.raw;
1628  
1629 /* msgAuthoritativeEngineID (OCTET STRING) */
1630 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1631 return;
1632 if (elem.type != BE_STR) {
1633 ND_PRINT((ndo, "[msgAuthoritativeEngineID!=STR]"));
1634 asn1_print(ndo, &elem);
1635 return;
1636 }
1637 length -= count;
1638 np += count;
1639  
1640 /* msgAuthoritativeEngineBoots (INTEGER) */
1641 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1642 return;
1643 if (elem.type != BE_INT) {
1644 ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]"));
1645 asn1_print(ndo, &elem);
1646 return;
1647 }
1648 if (ndo->ndo_vflag)
1649 ND_PRINT((ndo, "B=%d ", elem.data.integer));
1650 length -= count;
1651 np += count;
1652  
1653 /* msgAuthoritativeEngineTime (INTEGER) */
1654 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1655 return;
1656 if (elem.type != BE_INT) {
1657 ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]"));
1658 asn1_print(ndo, &elem);
1659 return;
1660 }
1661 if (ndo->ndo_vflag)
1662 ND_PRINT((ndo, "T=%d ", elem.data.integer));
1663 length -= count;
1664 np += count;
1665  
1666 /* msgUserName (OCTET STRING) */
1667 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1668 return;
1669 if (elem.type != BE_STR) {
1670 ND_PRINT((ndo, "[msgUserName!=STR]"));
1671 asn1_print(ndo, &elem);
1672 return;
1673 }
1674 length -= count;
1675 np += count;
1676  
1677 ND_PRINT((ndo, "U=%.*s ", (int)elem.asnlen, elem.data.str));
1678  
1679 /* msgAuthenticationParameters (OCTET STRING) */
1680 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1681 return;
1682 if (elem.type != BE_STR) {
1683 ND_PRINT((ndo, "[msgAuthenticationParameters!=STR]"));
1684 asn1_print(ndo, &elem);
1685 return;
1686 }
1687 length -= count;
1688 np += count;
1689  
1690 /* msgPrivacyParameters (OCTET STRING) */
1691 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1692 return;
1693 if (elem.type != BE_STR) {
1694 ND_PRINT((ndo, "[msgPrivacyParameters!=STR]"));
1695 asn1_print(ndo, &elem);
1696 return;
1697 }
1698 length -= count;
1699 np += count;
1700  
1701 if ((u_int)count < length)
1702 ND_PRINT((ndo, "[%d extra after usm SEQ]", length - count));
1703 }
1704  
1705 /*
1706 * Decode SNMPv3 Message Header (SNMPv3)
1707 */
1708 static void
1709 v3msg_print(netdissect_options *ndo,
1710 const u_char *np, u_int length)
1711 {
1712 struct be elem;
1713 int count = 0;
1714 u_char flags;
1715 int model;
1716 const u_char *xnp = np;
1717 int xlength = length;
1718  
1719 /* Sequence */
1720 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1721 return;
1722 if (elem.type != BE_SEQ) {
1723 ND_PRINT((ndo, "[!message]"));
1724 asn1_print(ndo, &elem);
1725 return;
1726 }
1727 length = elem.asnlen;
1728 np = (u_char *)elem.data.raw;
1729  
1730 if (ndo->ndo_vflag) {
1731 ND_PRINT((ndo, "{ "));
1732 }
1733  
1734 /* msgID (INTEGER) */
1735 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1736 return;
1737 if (elem.type != BE_INT) {
1738 ND_PRINT((ndo, "[msgID!=INT]"));
1739 asn1_print(ndo, &elem);
1740 return;
1741 }
1742 length -= count;
1743 np += count;
1744  
1745 /* msgMaxSize (INTEGER) */
1746 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1747 return;
1748 if (elem.type != BE_INT) {
1749 ND_PRINT((ndo, "[msgMaxSize!=INT]"));
1750 asn1_print(ndo, &elem);
1751 return;
1752 }
1753 length -= count;
1754 np += count;
1755  
1756 /* msgFlags (OCTET STRING) */
1757 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1758 return;
1759 if (elem.type != BE_STR) {
1760 ND_PRINT((ndo, "[msgFlags!=STR]"));
1761 asn1_print(ndo, &elem);
1762 return;
1763 }
1764 if (elem.asnlen != 1) {
1765 ND_PRINT((ndo, "[msgFlags size %d]", elem.asnlen));
1766 return;
1767 }
1768 flags = elem.data.str[0];
1769 if (flags != 0x00 && flags != 0x01 && flags != 0x03
1770 && flags != 0x04 && flags != 0x05 && flags != 0x07) {
1771 ND_PRINT((ndo, "[msgFlags=0x%02X]", flags));
1772 return;
1773 }
1774 length -= count;
1775 np += count;
1776  
1777 ND_PRINT((ndo, "F=%s%s%s ",
1778 flags & 0x01 ? "a" : "",
1779 flags & 0x02 ? "p" : "",
1780 flags & 0x04 ? "r" : ""));
1781  
1782 /* msgSecurityModel (INTEGER) */
1783 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1784 return;
1785 if (elem.type != BE_INT) {
1786 ND_PRINT((ndo, "[msgSecurityModel!=INT]"));
1787 asn1_print(ndo, &elem);
1788 return;
1789 }
1790 model = elem.data.integer;
1791 length -= count;
1792 np += count;
1793  
1794 if ((u_int)count < length)
1795 ND_PRINT((ndo, "[%d extra after message SEQ]", length - count));
1796  
1797 if (ndo->ndo_vflag) {
1798 ND_PRINT((ndo, "} "));
1799 }
1800  
1801 if (model == 3) {
1802 if (ndo->ndo_vflag) {
1803 ND_PRINT((ndo, "{ USM "));
1804 }
1805 } else {
1806 ND_PRINT((ndo, "[security model %d]", model));
1807 return;
1808 }
1809  
1810 np = xnp + (np - xnp);
1811 length = xlength - (np - xnp);
1812  
1813 /* msgSecurityParameters (OCTET STRING) */
1814 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1815 return;
1816 if (elem.type != BE_STR) {
1817 ND_PRINT((ndo, "[msgSecurityParameters!=STR]"));
1818 asn1_print(ndo, &elem);
1819 return;
1820 }
1821 length -= count;
1822 np += count;
1823  
1824 if (model == 3) {
1825 usm_print(ndo, elem.data.str, elem.asnlen);
1826 if (ndo->ndo_vflag) {
1827 ND_PRINT((ndo, "} "));
1828 }
1829 }
1830  
1831 if (ndo->ndo_vflag) {
1832 ND_PRINT((ndo, "{ ScopedPDU "));
1833 }
1834  
1835 scopedpdu_print(ndo, np, length, 3);
1836  
1837 if (ndo->ndo_vflag) {
1838 ND_PRINT((ndo, "} "));
1839 }
1840 }
1841  
1842 /*
1843 * Decode SNMP header and pass on to PDU printing routines
1844 */
1845 void
1846 snmp_print(netdissect_options *ndo,
1847 const u_char *np, u_int length)
1848 {
1849 struct be elem;
1850 int count = 0;
1851 int version = 0;
1852  
1853 ND_PRINT((ndo, " "));
1854  
1855 /* initial Sequence */
1856 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1857 return;
1858 if (elem.type != BE_SEQ) {
1859 ND_PRINT((ndo, "[!init SEQ]"));
1860 asn1_print(ndo, &elem);
1861 return;
1862 }
1863 if ((u_int)count < length)
1864 ND_PRINT((ndo, "[%d extra after iSEQ]", length - count));
1865 /* descend */
1866 length = elem.asnlen;
1867 np = (u_char *)elem.data.raw;
1868  
1869 /* Version (INTEGER) */
1870 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1871 return;
1872 if (elem.type != BE_INT) {
1873 ND_PRINT((ndo, "[version!=INT]"));
1874 asn1_print(ndo, &elem);
1875 return;
1876 }
1877  
1878 switch (elem.data.integer) {
1879 case SNMP_VERSION_1:
1880 case SNMP_VERSION_2:
1881 case SNMP_VERSION_3:
1882 if (ndo->ndo_vflag)
1883 ND_PRINT((ndo, "{ %s ", SnmpVersion[elem.data.integer]));
1884 break;
1885 default:
1886 ND_PRINT((ndo, "[version = %d]", elem.data.integer));
1887 return;
1888 }
1889 version = elem.data.integer;
1890 length -= count;
1891 np += count;
1892  
1893 switch (version) {
1894 case SNMP_VERSION_1:
1895 case SNMP_VERSION_2:
1896 community_print(ndo, np, length, version);
1897 break;
1898 case SNMP_VERSION_3:
1899 v3msg_print(ndo, np, length);
1900 break;
1901 default:
1902 ND_PRINT((ndo, "[version = %d]", elem.data.integer));
1903 break;
1904 }
1905  
1906 if (ndo->ndo_vflag) {
1907 ND_PRINT((ndo, "} "));
1908 }
1909 }