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