]> The Tcpdump Group git mirrors - tcpdump/blob - print-snmp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Clean up whitespaces/indentation
[tcpdump] / print-snmp.c
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 #include "extract.h"
76
77 #undef OPAQUE /* defined in <wingdi.h> */
78
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 : (nd_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 : (nd_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(suppressdot?"%s":".%s", objp->desc); \
335 objp = objp->child; \
336 } else \
337 ND_PRINT(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 const u_char *p, u_int len, struct be *elem)
421 {
422 u_char form, class, id;
423 u_int i, hdr;
424
425 elem->asnlen = 0;
426 elem->type = BE_ANY;
427 if (len < 1) {
428 ND_PRINT("[nothing to parse]");
429 return -1;
430 }
431 ND_TCHECK_1(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 = EXTRACT_U_1(p) & ASN_ID_BITS; /* lower 5 bits, range 00-1f */
441 #ifdef notdef
442 form = (EXTRACT_U_1(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)(EXTRACT_U_1(p) & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
447 class = (u_char)(EXTRACT_U_1(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_1(p);
467 while (EXTRACT_U_1(p) & ASN_BIT8) {
468 if (len < 1) {
469 ND_PRINT("[Xtagfield?]");
470 return -1;
471 }
472 id = (id << 7) | (EXTRACT_U_1(p) & ~ASN_BIT8);
473 len--;
474 hdr++;
475 p++;
476 ND_TCHECK_1(p);
477 }
478 if (len < 1) {
479 ND_PRINT("[Xtagfield?]");
480 return -1;
481 }
482 ND_TCHECK_1(p);
483 elem->id = id = (id << 7) | EXTRACT_U_1(p);
484 --len;
485 ++hdr;
486 ++p;
487 }
488 if (len < 1) {
489 ND_PRINT("[no asnlen]");
490 return -1;
491 }
492 ND_TCHECK_1(p);
493 elem->asnlen = EXTRACT_U_1(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("[asnlen? %d<%d]", len, noct);
500 return -1;
501 }
502 ND_TCHECK_LEN(p, noct);
503 for (; noct-- > 0; len--, hdr++) {
504 elem->asnlen = (elem->asnlen << ASN_SHIFT8) | EXTRACT_U_1(p);
505 p++;
506 }
507 }
508 if (len < elem->asnlen) {
509 ND_PRINT("[len%d<asnlen%u]", len, elem->asnlen);
510 return -1;
511 }
512 if (form >= sizeof(Form)/sizeof(Form[0])) {
513 ND_PRINT("[form?%d]", form);
514 return -1;
515 }
516 if (class >= sizeof(Class)/sizeof(Class[0])) {
517 ND_PRINT("[class?%c/%d]", *Form[form], class);
518 return -1;
519 }
520 if ((int)id >= Class[class].numIDs) {
521 ND_PRINT("[id?%c/%s/%d]", *Form[form], Class[class].name, id);
522 return -1;
523 }
524 ND_TCHECK_LEN(p, elem->asnlen);
525
526 switch (form) {
527 case PRIMITIVE:
528 switch (class) {
529 case UNIVERSAL:
530 switch (id) {
531 case STRING:
532 elem->type = BE_STR;
533 elem->data.str = p;
534 break;
535
536 case INTEGER: {
537 int32_t data;
538 elem->type = BE_INT;
539 data = 0;
540
541 if (elem->asnlen == 0) {
542 ND_PRINT("[asnlen=0]");
543 return -1;
544 }
545 if (EXTRACT_U_1(p) & ASN_BIT8) /* negative */
546 data = -1;
547 for (i = elem->asnlen; i != 0; p++, i--)
548 data = (data << ASN_SHIFT8) | EXTRACT_U_1(p);
549 elem->data.integer = data;
550 break;
551 }
552
553 case OBJECTID:
554 elem->type = BE_OID;
555 elem->data.raw = (const uint8_t *)p;
556 break;
557
558 case ASN_NULL:
559 elem->type = BE_NULL;
560 elem->data.raw = NULL;
561 break;
562
563 default:
564 elem->type = BE_OCTET;
565 elem->data.raw = (const uint8_t *)p;
566 ND_PRINT("[P/U/%s]", Class[class].Id[id]);
567 break;
568 }
569 break;
570
571 case APPLICATION:
572 switch (id) {
573 case IPADDR:
574 elem->type = BE_INETADDR;
575 elem->data.raw = (const uint8_t *)p;
576 break;
577
578 case COUNTER:
579 case GAUGE:
580 case TIMETICKS: {
581 uint32_t data;
582 elem->type = BE_UNS;
583 data = 0;
584 for (i = elem->asnlen; i != 0; p++, i--)
585 data = (data << 8) + EXTRACT_U_1(p);
586 elem->data.uns = data;
587 break;
588 }
589
590 case COUNTER64: {
591 uint64_t data64;
592 elem->type = BE_UNS64;
593 data64 = 0;
594 for (i = elem->asnlen; i != 0; p++, i--)
595 data64 = (data64 << 8) + EXTRACT_U_1(p);
596 elem->data.uns64 = data64;
597 break;
598 }
599
600 default:
601 elem->type = BE_OCTET;
602 elem->data.raw = (const uint8_t *)p;
603 ND_PRINT("[P/A/%s]",
604 Class[class].Id[id]);
605 break;
606 }
607 break;
608
609 case CONTEXT:
610 switch (id) {
611 case NOSUCHOBJECT:
612 elem->type = BE_NOSUCHOBJECT;
613 elem->data.raw = NULL;
614 break;
615
616 case NOSUCHINSTANCE:
617 elem->type = BE_NOSUCHINST;
618 elem->data.raw = NULL;
619 break;
620
621 case ENDOFMIBVIEW:
622 elem->type = BE_ENDOFMIBVIEW;
623 elem->data.raw = NULL;
624 break;
625 }
626 break;
627
628 default:
629 ND_PRINT("[P/%s/%s]", Class[class].name, Class[class].Id[id]);
630 elem->type = BE_OCTET;
631 elem->data.raw = (const uint8_t *)p;
632 break;
633 }
634 break;
635
636 case CONSTRUCTED:
637 switch (class) {
638 case UNIVERSAL:
639 switch (id) {
640 case SEQUENCE:
641 elem->type = BE_SEQ;
642 elem->data.raw = (const uint8_t *)p;
643 break;
644
645 default:
646 elem->type = BE_OCTET;
647 elem->data.raw = (const uint8_t *)p;
648 ND_PRINT("C/U/%s", Class[class].Id[id]);
649 break;
650 }
651 break;
652
653 case CONTEXT:
654 elem->type = BE_PDU;
655 elem->data.raw = (const uint8_t *)p;
656 break;
657
658 default:
659 elem->type = BE_OCTET;
660 elem->data.raw = (const uint8_t *)p;
661 ND_PRINT("C/%s/%s", Class[class].name, Class[class].Id[id]);
662 break;
663 }
664 break;
665 }
666 p += elem->asnlen;
667 len -= elem->asnlen;
668 return elem->asnlen + hdr;
669
670 trunc:
671 nd_print_trunc(ndo);
672 return -1;
673 }
674
675 static int
676 asn1_print_octets(netdissect_options *ndo, struct be *elem)
677 {
678 const u_char *p = (const u_char *)elem->data.raw;
679 uint32_t asnlen = elem->asnlen;
680 uint32_t i;
681
682 ND_TCHECK_LEN(p, asnlen);
683 for (i = asnlen; i != 0; p++, i--)
684 ND_PRINT("_%.2x", EXTRACT_U_1(p));
685 return 0;
686
687 trunc:
688 nd_print_trunc(ndo);
689 return -1;
690 }
691
692 static int
693 asn1_print_string(netdissect_options *ndo, struct be *elem)
694 {
695 int printable = 1, first = 1;
696 const u_char *p;
697 uint32_t asnlen = elem->asnlen;
698 uint32_t i;
699
700 p = elem->data.str;
701 ND_TCHECK_LEN(p, asnlen);
702 for (i = asnlen; printable && i != 0; p++, i--)
703 printable = ND_ISPRINT(EXTRACT_U_1(p));
704 p = elem->data.str;
705 if (printable) {
706 ND_PRINT("\"");
707 if (nd_printn(ndo, p, asnlen, ndo->ndo_snapend)) {
708 ND_PRINT("\"");
709 goto trunc;
710 }
711 ND_PRINT("\"");
712 } else {
713 for (i = asnlen; i != 0; p++, i--) {
714 ND_PRINT(first ? "%.2x" : "_%.2x", EXTRACT_U_1(p));
715 first = 0;
716 }
717 }
718 return 0;
719
720 trunc:
721 nd_print_trunc(ndo);
722 return -1;
723 }
724
725 /*
726 * Display the ASN.1 object represented by the BE object.
727 * This used to be an integral part of asn1_parse() before the intermediate
728 * BE form was added.
729 */
730 static int
731 asn1_print(netdissect_options *ndo,
732 struct be *elem)
733 {
734 const u_char *p;
735 uint32_t asnlen = elem->asnlen;
736 uint32_t i;
737
738 switch (elem->type) {
739
740 case BE_OCTET:
741 if (asn1_print_octets(ndo, elem) == -1)
742 return -1;
743 break;
744
745 case BE_NULL:
746 break;
747
748 case BE_OID: {
749 int o = 0, first = -1;
750
751 p = (const u_char *)elem->data.raw;
752 i = asnlen;
753 if (!ndo->ndo_nflag && asnlen > 2) {
754 const struct obj_abrev *a = &obj_abrev_list[0];
755 for (; a->node; a++) {
756 if (i < a->oid_len)
757 continue;
758 if (!ND_TTEST_LEN(p, a->oid_len))
759 continue;
760 if (memcmp(a->oid, p, a->oid_len) == 0) {
761 objp = a->node->child;
762 i -= a->oid_len;
763 p += a->oid_len;
764 ND_PRINT("%s", a->prefix);
765 first = 1;
766 break;
767 }
768 }
769 }
770
771 for (; i != 0; p++, i--) {
772 ND_TCHECK_1(p);
773 o = (o << ASN_SHIFT7) + (EXTRACT_U_1(p) & ~ASN_BIT8);
774 if (EXTRACT_U_1(p) & ASN_LONGLEN)
775 continue;
776
777 /*
778 * first subitem encodes two items with
779 * 1st*OIDMUX+2nd
780 * (see X.690:1997 clause 8.19 for the details)
781 */
782 if (first < 0) {
783 int s;
784 if (!ndo->ndo_nflag)
785 objp = mibroot;
786 first = 0;
787 s = o / OIDMUX;
788 if (s > 2) s = 2;
789 OBJ_PRINT(s, first);
790 o -= s * OIDMUX;
791 }
792 OBJ_PRINT(o, first);
793 if (--first < 0)
794 first = 0;
795 o = 0;
796 }
797 break;
798 }
799
800 case BE_INT:
801 ND_PRINT("%d", elem->data.integer);
802 break;
803
804 case BE_UNS:
805 ND_PRINT("%u", elem->data.uns);
806 break;
807
808 case BE_UNS64:
809 ND_PRINT("%" PRIu64, elem->data.uns64);
810 break;
811
812 case BE_STR:
813 if (asn1_print_string(ndo, elem) == -1)
814 return -1;
815 break;
816
817 case BE_SEQ:
818 ND_PRINT("Seq(%u)", elem->asnlen);
819 break;
820
821 case BE_INETADDR:
822 if (asnlen != ASNLEN_INETADDR)
823 ND_PRINT("[inetaddr len!=%d]", ASNLEN_INETADDR);
824 p = (const u_char *)elem->data.raw;
825 ND_TCHECK_LEN(p, asnlen);
826 for (i = asnlen; i != 0; p++, i--) {
827 ND_PRINT((i == asnlen) ? "%u" : ".%u", EXTRACT_U_1(p));
828 }
829 break;
830
831 case BE_NOSUCHOBJECT:
832 case BE_NOSUCHINST:
833 case BE_ENDOFMIBVIEW:
834 ND_PRINT("[%s]", Class[EXCEPTIONS].Id[elem->id]);
835 break;
836
837 case BE_PDU:
838 ND_PRINT("%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen);
839 break;
840
841 case BE_ANY:
842 ND_PRINT("[BE_ANY!?]");
843 break;
844
845 default:
846 ND_PRINT("[be!?]");
847 break;
848 }
849 return 0;
850
851 trunc:
852 nd_print_trunc(ndo);
853 return -1;
854 }
855
856 #ifdef notdef
857 /*
858 * This is a brute force ASN.1 printer: recurses to dump an entire structure.
859 * This will work for any ASN.1 stream, not just an SNMP PDU.
860 *
861 * By adding newlines and spaces at the correct places, this would print in
862 * Rose-Normal-Form.
863 *
864 * This is not currently used.
865 */
866 static void
867 asn1_decode(u_char *p, u_int length)
868 {
869 struct be elem;
870 int i = 0;
871
872 while (i >= 0 && length > 0) {
873 i = asn1_parse(ndo, p, length, &elem);
874 if (i >= 0) {
875 ND_PRINT(" ");
876 if (asn1_print(ndo, &elem) < 0)
877 return;
878 if (elem.type == BE_SEQ || elem.type == BE_PDU) {
879 ND_PRINT(" {");
880 asn1_decode(elem.data.raw, elem.asnlen);
881 ND_PRINT(" }");
882 }
883 length -= i;
884 p += i;
885 }
886 }
887 }
888 #endif
889
890 #ifdef USE_LIBSMI
891
892 struct smi2be {
893 SmiBasetype basetype;
894 int be;
895 };
896
897 static const struct smi2be smi2betab[] = {
898 { SMI_BASETYPE_INTEGER32, BE_INT },
899 { SMI_BASETYPE_OCTETSTRING, BE_STR },
900 { SMI_BASETYPE_OCTETSTRING, BE_INETADDR },
901 { SMI_BASETYPE_OBJECTIDENTIFIER, BE_OID },
902 { SMI_BASETYPE_UNSIGNED32, BE_UNS },
903 { SMI_BASETYPE_INTEGER64, BE_NONE },
904 { SMI_BASETYPE_UNSIGNED64, BE_UNS64 },
905 { SMI_BASETYPE_FLOAT32, BE_NONE },
906 { SMI_BASETYPE_FLOAT64, BE_NONE },
907 { SMI_BASETYPE_FLOAT128, BE_NONE },
908 { SMI_BASETYPE_ENUM, BE_INT },
909 { SMI_BASETYPE_BITS, BE_STR },
910 { SMI_BASETYPE_UNKNOWN, BE_NONE }
911 };
912
913 static int
914 smi_decode_oid(netdissect_options *ndo,
915 struct be *elem, unsigned int *oid,
916 unsigned int oidsize, unsigned int *oidlen)
917 {
918 const u_char *p = (const u_char *)elem->data.raw;
919 uint32_t asnlen = elem->asnlen;
920 uint32_t i = asnlen;
921 int o = 0, first = -1;
922 unsigned int firstval;
923
924 for (*oidlen = 0; i != 0; p++, i--) {
925 ND_TCHECK_1(p);
926 o = (o << ASN_SHIFT7) + (EXTRACT_U_1(p) & ~ASN_BIT8);
927 if (EXTRACT_U_1(p) & ASN_LONGLEN)
928 continue;
929
930 /*
931 * first subitem encodes two items with 1st*OIDMUX+2nd
932 * (see X.690:1997 clause 8.19 for the details)
933 */
934 if (first < 0) {
935 first = 0;
936 firstval = o / OIDMUX;
937 if (firstval > 2) firstval = 2;
938 o -= firstval * OIDMUX;
939 if (*oidlen < oidsize) {
940 oid[(*oidlen)++] = firstval;
941 }
942 }
943 if (*oidlen < oidsize) {
944 oid[(*oidlen)++] = o;
945 }
946 o = 0;
947 }
948 return 0;
949
950 trunc:
951 nd_print_trunc(ndo);
952 return -1;
953 }
954
955 static int smi_check_type(SmiBasetype basetype, int be)
956 {
957 int i;
958
959 for (i = 0; smi2betab[i].basetype != SMI_BASETYPE_UNKNOWN; i++) {
960 if (smi2betab[i].basetype == basetype && smi2betab[i].be == be) {
961 return 1;
962 }
963 }
964
965 return 0;
966 }
967
968 static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
969 struct be *elem)
970 {
971 int ok = 1;
972
973 switch (smiType->basetype) {
974 case SMI_BASETYPE_OBJECTIDENTIFIER:
975 case SMI_BASETYPE_OCTETSTRING:
976 if (smiRange->minValue.value.unsigned32
977 == smiRange->maxValue.value.unsigned32) {
978 ok = (elem->asnlen == smiRange->minValue.value.unsigned32);
979 } else {
980 ok = (elem->asnlen >= smiRange->minValue.value.unsigned32
981 && elem->asnlen <= smiRange->maxValue.value.unsigned32);
982 }
983 break;
984
985 case SMI_BASETYPE_INTEGER32:
986 ok = (elem->data.integer >= smiRange->minValue.value.integer32
987 && elem->data.integer <= smiRange->maxValue.value.integer32);
988 break;
989
990 case SMI_BASETYPE_UNSIGNED32:
991 ok = (elem->data.uns >= smiRange->minValue.value.unsigned32
992 && elem->data.uns <= smiRange->maxValue.value.unsigned32);
993 break;
994
995 case SMI_BASETYPE_UNSIGNED64:
996 /* XXX */
997 break;
998
999 /* case SMI_BASETYPE_INTEGER64: SMIng */
1000 /* case SMI_BASETYPE_FLOAT32: SMIng */
1001 /* case SMI_BASETYPE_FLOAT64: SMIng */
1002 /* case SMI_BASETYPE_FLOAT128: SMIng */
1003
1004 case SMI_BASETYPE_ENUM:
1005 case SMI_BASETYPE_BITS:
1006 case SMI_BASETYPE_UNKNOWN:
1007 ok = 1;
1008 break;
1009
1010 default:
1011 ok = 0;
1012 break;
1013 }
1014
1015 return ok;
1016 }
1017
1018 static int smi_check_range(SmiType *smiType, struct be *elem)
1019 {
1020 SmiRange *smiRange;
1021 int ok = 1;
1022
1023 for (smiRange = smiGetFirstRange(smiType);
1024 smiRange;
1025 smiRange = smiGetNextRange(smiRange)) {
1026
1027 ok = smi_check_a_range(smiType, smiRange, elem);
1028
1029 if (ok) {
1030 break;
1031 }
1032 }
1033
1034 if (ok) {
1035 SmiType *parentType;
1036 parentType = smiGetParentType(smiType);
1037 if (parentType) {
1038 ok = smi_check_range(parentType, elem);
1039 }
1040 }
1041
1042 return ok;
1043 }
1044
1045 static SmiNode *
1046 smi_print_variable(netdissect_options *ndo,
1047 struct be *elem, int *status)
1048 {
1049 unsigned int oid[128], oidlen;
1050 SmiNode *smiNode = NULL;
1051 unsigned int i;
1052
1053 if (!nd_smi_module_loaded) {
1054 *status = asn1_print(ndo, elem);
1055 return NULL;
1056 }
1057 *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),
1058 &oidlen);
1059 if (*status < 0)
1060 return NULL;
1061 smiNode = smiGetNodeByOID(oidlen, oid);
1062 if (! smiNode) {
1063 *status = asn1_print(ndo, elem);
1064 return NULL;
1065 }
1066 if (ndo->ndo_vflag) {
1067 ND_PRINT("%s::", smiGetNodeModule(smiNode)->name);
1068 }
1069 ND_PRINT("%s", smiNode->name);
1070 if (smiNode->oidlen < oidlen) {
1071 for (i = smiNode->oidlen; i < oidlen; i++) {
1072 ND_PRINT(".%u", oid[i]);
1073 }
1074 }
1075 *status = 0;
1076 return smiNode;
1077 }
1078
1079 static int
1080 smi_print_value(netdissect_options *ndo,
1081 SmiNode *smiNode, u_short pduid, struct be *elem)
1082 {
1083 unsigned int i, oid[128], oidlen;
1084 SmiType *smiType;
1085 SmiNamedNumber *nn;
1086 int done = 0;
1087
1088 if (! smiNode || ! (smiNode->nodekind
1089 & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {
1090 return asn1_print(ndo, elem);
1091 }
1092
1093 if (elem->type == BE_NOSUCHOBJECT
1094 || elem->type == BE_NOSUCHINST
1095 || elem->type == BE_ENDOFMIBVIEW) {
1096 return asn1_print(ndo, elem);
1097 }
1098
1099 if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
1100 ND_PRINT("[notNotifyable]");
1101 }
1102
1103 if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) {
1104 ND_PRINT("[notReadable]");
1105 }
1106
1107 if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) {
1108 ND_PRINT("[notWritable]");
1109 }
1110
1111 if (RESPONSE_CLASS(pduid)
1112 && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {
1113 ND_PRINT("[noAccess]");
1114 }
1115
1116 smiType = smiGetNodeType(smiNode);
1117 if (! smiType) {
1118 return asn1_print(ndo, elem);
1119 }
1120
1121 if (! smi_check_type(smiType->basetype, elem->type)) {
1122 ND_PRINT("[wrongType]");
1123 }
1124
1125 if (! smi_check_range(smiType, elem)) {
1126 ND_PRINT("[outOfRange]");
1127 }
1128
1129 /* resolve bits to named bits */
1130
1131 /* check whether instance identifier is valid */
1132
1133 /* apply display hints (integer, octetstring) */
1134
1135 /* convert instance identifier to index type values */
1136
1137 switch (elem->type) {
1138 case BE_OID:
1139 if (smiType->basetype == SMI_BASETYPE_BITS) {
1140 /* print bit labels */
1141 } else {
1142 if (nd_smi_module_loaded &&
1143 smi_decode_oid(ndo, elem, oid,
1144 sizeof(oid)/sizeof(unsigned int),
1145 &oidlen) == 0) {
1146 smiNode = smiGetNodeByOID(oidlen, oid);
1147 if (smiNode) {
1148 if (ndo->ndo_vflag) {
1149 ND_PRINT("%s::", smiGetNodeModule(smiNode)->name);
1150 }
1151 ND_PRINT("%s", smiNode->name);
1152 if (smiNode->oidlen < oidlen) {
1153 for (i = smiNode->oidlen;
1154 i < oidlen; i++) {
1155 ND_PRINT(".%u", oid[i]);
1156 }
1157 }
1158 done++;
1159 }
1160 }
1161 }
1162 break;
1163
1164 case BE_INT:
1165 if (smiType->basetype == SMI_BASETYPE_ENUM) {
1166 for (nn = smiGetFirstNamedNumber(smiType);
1167 nn;
1168 nn = smiGetNextNamedNumber(nn)) {
1169 if (nn->value.value.integer32
1170 == elem->data.integer) {
1171 ND_PRINT("%s", nn->name);
1172 ND_PRINT("(%d)", elem->data.integer);
1173 done++;
1174 break;
1175 }
1176 }
1177 }
1178 break;
1179 }
1180
1181 if (! done) {
1182 return asn1_print(ndo, elem);
1183 }
1184 return 0;
1185 }
1186 #endif
1187
1188 /*
1189 * General SNMP header
1190 * SEQUENCE {
1191 * version INTEGER {version-1(0)},
1192 * community OCTET STRING,
1193 * data ANY -- PDUs
1194 * }
1195 * PDUs for all but Trap: (see rfc1157 from page 15 on)
1196 * SEQUENCE {
1197 * request-id INTEGER,
1198 * error-status INTEGER,
1199 * error-index INTEGER,
1200 * varbindlist SEQUENCE OF
1201 * SEQUENCE {
1202 * name ObjectName,
1203 * value ObjectValue
1204 * }
1205 * }
1206 * PDU for Trap:
1207 * SEQUENCE {
1208 * enterprise OBJECT IDENTIFIER,
1209 * agent-addr NetworkAddress,
1210 * generic-trap INTEGER,
1211 * specific-trap INTEGER,
1212 * time-stamp TimeTicks,
1213 * varbindlist SEQUENCE OF
1214 * SEQUENCE {
1215 * name ObjectName,
1216 * value ObjectValue
1217 * }
1218 * }
1219 */
1220
1221 /*
1222 * Decode SNMP varBind
1223 */
1224 static void
1225 varbind_print(netdissect_options *ndo,
1226 u_short pduid, const u_char *np, u_int length)
1227 {
1228 struct be elem;
1229 int count = 0, ind;
1230 #ifdef USE_LIBSMI
1231 SmiNode *smiNode = NULL;
1232 #endif
1233 int status;
1234
1235 /* Sequence of varBind */
1236 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1237 return;
1238 if (elem.type != BE_SEQ) {
1239 ND_PRINT("[!SEQ of varbind]");
1240 asn1_print(ndo, &elem);
1241 return;
1242 }
1243 if ((u_int)count < length)
1244 ND_PRINT("[%d extra after SEQ of varbind]", length - count);
1245 /* descend */
1246 length = elem.asnlen;
1247 np = (const u_char *)elem.data.raw;
1248
1249 for (ind = 1; length > 0; ind++) {
1250 const u_char *vbend;
1251 u_int vblength;
1252
1253 ND_PRINT(" ");
1254
1255 /* Sequence */
1256 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1257 return;
1258 if (elem.type != BE_SEQ) {
1259 ND_PRINT("[!varbind]");
1260 asn1_print(ndo, &elem);
1261 return;
1262 }
1263 vbend = np + count;
1264 vblength = length - count;
1265 /* descend */
1266 length = elem.asnlen;
1267 np = (const u_char *)elem.data.raw;
1268
1269 /* objName (OID) */
1270 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1271 return;
1272 if (elem.type != BE_OID) {
1273 ND_PRINT("[objName!=OID]");
1274 asn1_print(ndo, &elem);
1275 return;
1276 }
1277 #ifdef USE_LIBSMI
1278 smiNode = smi_print_variable(ndo, &elem, &status);
1279 #else
1280 status = asn1_print(ndo, &elem);
1281 #endif
1282 if (status < 0)
1283 return;
1284 length -= count;
1285 np += count;
1286
1287 if (pduid != GETREQ && pduid != GETNEXTREQ
1288 && pduid != GETBULKREQ)
1289 ND_PRINT("=");
1290
1291 /* objVal (ANY) */
1292 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1293 return;
1294 if (pduid == GETREQ || pduid == GETNEXTREQ
1295 || pduid == GETBULKREQ) {
1296 if (elem.type != BE_NULL) {
1297 ND_PRINT("[objVal!=NULL]");
1298 if (asn1_print(ndo, &elem) < 0)
1299 return;
1300 }
1301 } else {
1302 if (elem.type != BE_NULL) {
1303 #ifdef USE_LIBSMI
1304 status = smi_print_value(ndo, smiNode, pduid, &elem);
1305 #else
1306 status = asn1_print(ndo, &elem);
1307 #endif
1308 }
1309 if (status < 0)
1310 return;
1311 }
1312 length = vblength;
1313 np = vbend;
1314 }
1315 }
1316
1317 /*
1318 * Decode SNMP PDUs: GetRequest, GetNextRequest, GetResponse, SetRequest,
1319 * GetBulk, Inform, V2Trap, and Report
1320 */
1321 static void
1322 snmppdu_print(netdissect_options *ndo,
1323 u_short pduid, const u_char *np, u_int length)
1324 {
1325 struct be elem;
1326 int count = 0, error_status;
1327
1328 /* reqId (Integer) */
1329 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1330 return;
1331 if (elem.type != BE_INT) {
1332 ND_PRINT("[reqId!=INT]");
1333 asn1_print(ndo, &elem);
1334 return;
1335 }
1336 if (ndo->ndo_vflag)
1337 ND_PRINT("R=%d ", elem.data.integer);
1338 length -= count;
1339 np += count;
1340
1341 /* errorStatus (Integer) */
1342 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1343 return;
1344 if (elem.type != BE_INT) {
1345 ND_PRINT("[errorStatus!=INT]");
1346 asn1_print(ndo, &elem);
1347 return;
1348 }
1349 error_status = 0;
1350 if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
1351 || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
1352 && elem.data.integer != 0) {
1353 char errbuf[20];
1354 ND_PRINT("[errorStatus(%s)!=0]",
1355 DECODE_ErrorStatus(elem.data.integer));
1356 } else if (pduid == GETBULKREQ) {
1357 ND_PRINT(" N=%d", elem.data.integer);
1358 } else if (elem.data.integer != 0) {
1359 char errbuf[20];
1360 ND_PRINT(" %s", DECODE_ErrorStatus(elem.data.integer));
1361 error_status = elem.data.integer;
1362 }
1363 length -= count;
1364 np += count;
1365
1366 /* errorIndex (Integer) */
1367 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1368 return;
1369 if (elem.type != BE_INT) {
1370 ND_PRINT("[errorIndex!=INT]");
1371 asn1_print(ndo, &elem);
1372 return;
1373 }
1374 if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
1375 || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
1376 && elem.data.integer != 0)
1377 ND_PRINT("[errorIndex(%d)!=0]", elem.data.integer);
1378 else if (pduid == GETBULKREQ)
1379 ND_PRINT(" M=%d", elem.data.integer);
1380 else if (elem.data.integer != 0) {
1381 if (!error_status)
1382 ND_PRINT("[errorIndex(%d) w/o errorStatus]", elem.data.integer);
1383 else
1384 ND_PRINT("@%d", elem.data.integer);
1385 } else if (error_status) {
1386 ND_PRINT("[errorIndex==0]");
1387 }
1388 length -= count;
1389 np += count;
1390
1391 varbind_print(ndo, pduid, np, length);
1392 return;
1393 }
1394
1395 /*
1396 * Decode SNMP Trap PDU
1397 */
1398 static void
1399 trappdu_print(netdissect_options *ndo,
1400 const u_char *np, u_int length)
1401 {
1402 struct be elem;
1403 int count = 0, generic;
1404
1405 ND_PRINT(" ");
1406
1407 /* enterprise (oid) */
1408 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1409 return;
1410 if (elem.type != BE_OID) {
1411 ND_PRINT("[enterprise!=OID]");
1412 asn1_print(ndo, &elem);
1413 return;
1414 }
1415 if (asn1_print(ndo, &elem) < 0)
1416 return;
1417 length -= count;
1418 np += count;
1419
1420 ND_PRINT(" ");
1421
1422 /* agent-addr (inetaddr) */
1423 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1424 return;
1425 if (elem.type != BE_INETADDR) {
1426 ND_PRINT("[agent-addr!=INETADDR]");
1427 asn1_print(ndo, &elem);
1428 return;
1429 }
1430 if (asn1_print(ndo, &elem) < 0)
1431 return;
1432 length -= count;
1433 np += count;
1434
1435 /* generic-trap (Integer) */
1436 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1437 return;
1438 if (elem.type != BE_INT) {
1439 ND_PRINT("[generic-trap!=INT]");
1440 asn1_print(ndo, &elem);
1441 return;
1442 }
1443 generic = elem.data.integer;
1444 {
1445 char buf[20];
1446 ND_PRINT(" %s", DECODE_GenericTrap(generic));
1447 }
1448 length -= count;
1449 np += count;
1450
1451 /* specific-trap (Integer) */
1452 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1453 return;
1454 if (elem.type != BE_INT) {
1455 ND_PRINT("[specific-trap!=INT]");
1456 asn1_print(ndo, &elem);
1457 return;
1458 }
1459 if (generic != GT_ENTERPRISE) {
1460 if (elem.data.integer != 0)
1461 ND_PRINT("[specific-trap(%d)!=0]", elem.data.integer);
1462 } else
1463 ND_PRINT(" s=%d", elem.data.integer);
1464 length -= count;
1465 np += count;
1466
1467 ND_PRINT(" ");
1468
1469 /* time-stamp (TimeTicks) */
1470 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1471 return;
1472 if (elem.type != BE_UNS) { /* XXX */
1473 ND_PRINT("[time-stamp!=TIMETICKS]");
1474 asn1_print(ndo, &elem);
1475 return;
1476 }
1477 if (asn1_print(ndo, &elem) < 0)
1478 return;
1479 length -= count;
1480 np += count;
1481
1482 varbind_print(ndo, TRAP, np, length);
1483 return;
1484 }
1485
1486 /*
1487 * Decode arbitrary SNMP PDUs.
1488 */
1489 static void
1490 pdu_print(netdissect_options *ndo,
1491 const u_char *np, u_int length, int version)
1492 {
1493 struct be pdu;
1494 int count = 0;
1495
1496 /* PDU (Context) */
1497 if ((count = asn1_parse(ndo, np, length, &pdu)) < 0)
1498 return;
1499 if (pdu.type != BE_PDU) {
1500 ND_PRINT("[no PDU]");
1501 return;
1502 }
1503 if ((u_int)count < length)
1504 ND_PRINT("[%d extra after PDU]", length - count);
1505 if (ndo->ndo_vflag) {
1506 ND_PRINT("{ ");
1507 }
1508 if (asn1_print(ndo, &pdu) < 0)
1509 return;
1510 ND_PRINT(" ");
1511 /* descend into PDU */
1512 length = pdu.asnlen;
1513 np = (const u_char *)pdu.data.raw;
1514
1515 if (version == SNMP_VERSION_1 &&
1516 (pdu.id == GETBULKREQ || pdu.id == INFORMREQ ||
1517 pdu.id == V2TRAP || pdu.id == REPORT)) {
1518 ND_PRINT("[v2 PDU in v1 message]");
1519 return;
1520 }
1521
1522 if (version == SNMP_VERSION_2 && pdu.id == TRAP) {
1523 ND_PRINT("[v1 PDU in v2 message]");
1524 return;
1525 }
1526
1527 switch (pdu.id) {
1528 case TRAP:
1529 trappdu_print(ndo, np, length);
1530 break;
1531 case GETREQ:
1532 case GETNEXTREQ:
1533 case GETRESP:
1534 case SETREQ:
1535 case GETBULKREQ:
1536 case INFORMREQ:
1537 case V2TRAP:
1538 case REPORT:
1539 snmppdu_print(ndo, pdu.id, np, length);
1540 break;
1541 }
1542
1543 if (ndo->ndo_vflag) {
1544 ND_PRINT(" } ");
1545 }
1546 }
1547
1548 /*
1549 * Decode a scoped SNMP PDU.
1550 */
1551 static void
1552 scopedpdu_print(netdissect_options *ndo,
1553 const u_char *np, u_int length, int version)
1554 {
1555 struct be elem;
1556 int count = 0;
1557
1558 /* Sequence */
1559 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1560 return;
1561 if (elem.type != BE_SEQ) {
1562 ND_PRINT("[!scoped PDU]");
1563 asn1_print(ndo, &elem);
1564 return;
1565 }
1566 length = elem.asnlen;
1567 np = (const u_char *)elem.data.raw;
1568
1569 /* contextEngineID (OCTET STRING) */
1570 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1571 return;
1572 if (elem.type != BE_STR) {
1573 ND_PRINT("[contextEngineID!=STR]");
1574 asn1_print(ndo, &elem);
1575 return;
1576 }
1577 length -= count;
1578 np += count;
1579
1580 ND_PRINT("E=");
1581 if (asn1_print_octets(ndo, &elem) == -1)
1582 return;
1583 ND_PRINT(" ");
1584
1585 /* contextName (OCTET STRING) */
1586 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1587 return;
1588 if (elem.type != BE_STR) {
1589 ND_PRINT("[contextName!=STR]");
1590 asn1_print(ndo, &elem);
1591 return;
1592 }
1593 length -= count;
1594 np += count;
1595
1596 ND_PRINT("C=");
1597 if (asn1_print_string(ndo, &elem) == -1)
1598 return;
1599 ND_PRINT(" ");
1600
1601 pdu_print(ndo, np, length, version);
1602 }
1603
1604 /*
1605 * Decode SNMP Community Header (SNMPv1 and SNMPv2c)
1606 */
1607 static void
1608 community_print(netdissect_options *ndo,
1609 const u_char *np, u_int length, int version)
1610 {
1611 struct be elem;
1612 int count = 0;
1613
1614 /* Community (String) */
1615 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1616 return;
1617 if (elem.type != BE_STR) {
1618 ND_PRINT("[comm!=STR]");
1619 asn1_print(ndo, &elem);
1620 return;
1621 }
1622 /* default community */
1623 if (!(elem.asnlen == sizeof(DEF_COMMUNITY) - 1 &&
1624 strncmp((const char *)elem.data.str, DEF_COMMUNITY,
1625 sizeof(DEF_COMMUNITY) - 1) == 0)) {
1626 /* ! "public" */
1627 ND_PRINT("C=");
1628 if (asn1_print_string(ndo, &elem) == -1)
1629 return;
1630 ND_PRINT(" ");
1631 }
1632 length -= count;
1633 np += count;
1634
1635 pdu_print(ndo, np, length, version);
1636 }
1637
1638 /*
1639 * Decode SNMPv3 User-based Security Message Header (SNMPv3)
1640 */
1641 static void
1642 usm_print(netdissect_options *ndo,
1643 const u_char *np, u_int length)
1644 {
1645 struct be elem;
1646 int count = 0;
1647
1648 /* Sequence */
1649 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1650 return;
1651 if (elem.type != BE_SEQ) {
1652 ND_PRINT("[!usm]");
1653 asn1_print(ndo, &elem);
1654 return;
1655 }
1656 length = elem.asnlen;
1657 np = (const u_char *)elem.data.raw;
1658
1659 /* msgAuthoritativeEngineID (OCTET STRING) */
1660 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1661 return;
1662 if (elem.type != BE_STR) {
1663 ND_PRINT("[msgAuthoritativeEngineID!=STR]");
1664 asn1_print(ndo, &elem);
1665 return;
1666 }
1667 length -= count;
1668 np += count;
1669
1670 /* msgAuthoritativeEngineBoots (INTEGER) */
1671 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1672 return;
1673 if (elem.type != BE_INT) {
1674 ND_PRINT("[msgAuthoritativeEngineBoots!=INT]");
1675 asn1_print(ndo, &elem);
1676 return;
1677 }
1678 if (ndo->ndo_vflag)
1679 ND_PRINT("B=%d ", elem.data.integer);
1680 length -= count;
1681 np += count;
1682
1683 /* msgAuthoritativeEngineTime (INTEGER) */
1684 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1685 return;
1686 if (elem.type != BE_INT) {
1687 ND_PRINT("[msgAuthoritativeEngineTime!=INT]");
1688 asn1_print(ndo, &elem);
1689 return;
1690 }
1691 if (ndo->ndo_vflag)
1692 ND_PRINT("T=%d ", elem.data.integer);
1693 length -= count;
1694 np += count;
1695
1696 /* msgUserName (OCTET STRING) */
1697 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1698 return;
1699 if (elem.type != BE_STR) {
1700 ND_PRINT("[msgUserName!=STR]");
1701 asn1_print(ndo, &elem);
1702 return;
1703 }
1704 length -= count;
1705 np += count;
1706
1707 ND_PRINT("U=");
1708 if (asn1_print_string(ndo, &elem) == -1)
1709 return;
1710 ND_PRINT(" ");
1711
1712 /* msgAuthenticationParameters (OCTET STRING) */
1713 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1714 return;
1715 if (elem.type != BE_STR) {
1716 ND_PRINT("[msgAuthenticationParameters!=STR]");
1717 asn1_print(ndo, &elem);
1718 return;
1719 }
1720 length -= count;
1721 np += count;
1722
1723 /* msgPrivacyParameters (OCTET STRING) */
1724 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1725 return;
1726 if (elem.type != BE_STR) {
1727 ND_PRINT("[msgPrivacyParameters!=STR]");
1728 asn1_print(ndo, &elem);
1729 return;
1730 }
1731 length -= count;
1732 np += count;
1733
1734 if ((u_int)count < length)
1735 ND_PRINT("[%d extra after usm SEQ]", length - count);
1736 }
1737
1738 /*
1739 * Decode SNMPv3 Message Header (SNMPv3)
1740 */
1741 static void
1742 v3msg_print(netdissect_options *ndo,
1743 const u_char *np, u_int length)
1744 {
1745 struct be elem;
1746 int count = 0;
1747 u_char flags;
1748 int model;
1749 const u_char *xnp = np;
1750 int xlength = length;
1751
1752 /* Sequence */
1753 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1754 return;
1755 if (elem.type != BE_SEQ) {
1756 ND_PRINT("[!message]");
1757 asn1_print(ndo, &elem);
1758 return;
1759 }
1760 length = elem.asnlen;
1761 np = (const u_char *)elem.data.raw;
1762
1763 if (ndo->ndo_vflag) {
1764 ND_PRINT("{ ");
1765 }
1766
1767 /* msgID (INTEGER) */
1768 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1769 return;
1770 if (elem.type != BE_INT) {
1771 ND_PRINT("[msgID!=INT]");
1772 asn1_print(ndo, &elem);
1773 return;
1774 }
1775 length -= count;
1776 np += count;
1777
1778 /* msgMaxSize (INTEGER) */
1779 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1780 return;
1781 if (elem.type != BE_INT) {
1782 ND_PRINT("[msgMaxSize!=INT]");
1783 asn1_print(ndo, &elem);
1784 return;
1785 }
1786 length -= count;
1787 np += count;
1788
1789 /* msgFlags (OCTET STRING) */
1790 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1791 return;
1792 if (elem.type != BE_STR) {
1793 ND_PRINT("[msgFlags!=STR]");
1794 asn1_print(ndo, &elem);
1795 return;
1796 }
1797 if (elem.asnlen != 1) {
1798 ND_PRINT("[msgFlags size %d]", elem.asnlen);
1799 return;
1800 }
1801 flags = EXTRACT_U_1(elem.data.str);
1802 if (flags != 0x00 && flags != 0x01 && flags != 0x03
1803 && flags != 0x04 && flags != 0x05 && flags != 0x07) {
1804 ND_PRINT("[msgFlags=0x%02X]", flags);
1805 return;
1806 }
1807 length -= count;
1808 np += count;
1809
1810 ND_PRINT("F=%s%s%s ",
1811 flags & 0x01 ? "a" : "",
1812 flags & 0x02 ? "p" : "",
1813 flags & 0x04 ? "r" : "");
1814
1815 /* msgSecurityModel (INTEGER) */
1816 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1817 return;
1818 if (elem.type != BE_INT) {
1819 ND_PRINT("[msgSecurityModel!=INT]");
1820 asn1_print(ndo, &elem);
1821 return;
1822 }
1823 model = elem.data.integer;
1824 length -= count;
1825 np += count;
1826
1827 if ((u_int)count < length)
1828 ND_PRINT("[%d extra after message SEQ]", length - count);
1829
1830 if (ndo->ndo_vflag) {
1831 ND_PRINT("} ");
1832 }
1833
1834 if (model == 3) {
1835 if (ndo->ndo_vflag) {
1836 ND_PRINT("{ USM ");
1837 }
1838 } else {
1839 ND_PRINT("[security model %d]", model);
1840 return;
1841 }
1842
1843 np = xnp + (np - xnp);
1844 length = xlength - (np - xnp);
1845
1846 /* msgSecurityParameters (OCTET STRING) */
1847 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1848 return;
1849 if (elem.type != BE_STR) {
1850 ND_PRINT("[msgSecurityParameters!=STR]");
1851 asn1_print(ndo, &elem);
1852 return;
1853 }
1854 length -= count;
1855 np += count;
1856
1857 if (model == 3) {
1858 usm_print(ndo, elem.data.str, elem.asnlen);
1859 if (ndo->ndo_vflag) {
1860 ND_PRINT("} ");
1861 }
1862 }
1863
1864 if (ndo->ndo_vflag) {
1865 ND_PRINT("{ ScopedPDU ");
1866 }
1867
1868 scopedpdu_print(ndo, np, length, 3);
1869
1870 if (ndo->ndo_vflag) {
1871 ND_PRINT("} ");
1872 }
1873 }
1874
1875 /*
1876 * Decode SNMP header and pass on to PDU printing routines
1877 */
1878 void
1879 snmp_print(netdissect_options *ndo,
1880 const u_char *np, u_int length)
1881 {
1882 struct be elem;
1883 int count = 0;
1884 int version = 0;
1885
1886 ndo->ndo_protocol = "snmp";
1887 ND_PRINT(" ");
1888
1889 /* initial Sequence */
1890 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1891 return;
1892 if (elem.type != BE_SEQ) {
1893 ND_PRINT("[!init SEQ]");
1894 asn1_print(ndo, &elem);
1895 return;
1896 }
1897 if ((u_int)count < length)
1898 ND_PRINT("[%d extra after iSEQ]", length - count);
1899 /* descend */
1900 length = elem.asnlen;
1901 np = (const u_char *)elem.data.raw;
1902
1903 /* Version (INTEGER) */
1904 if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
1905 return;
1906 if (elem.type != BE_INT) {
1907 ND_PRINT("[version!=INT]");
1908 asn1_print(ndo, &elem);
1909 return;
1910 }
1911
1912 switch (elem.data.integer) {
1913 case SNMP_VERSION_1:
1914 case SNMP_VERSION_2:
1915 case SNMP_VERSION_3:
1916 if (ndo->ndo_vflag)
1917 ND_PRINT("{ %s ", SnmpVersion[elem.data.integer]);
1918 break;
1919 default:
1920 ND_PRINT("SNMP [version = %d]", elem.data.integer);
1921 return;
1922 }
1923 version = elem.data.integer;
1924 length -= count;
1925 np += count;
1926
1927 switch (version) {
1928 case SNMP_VERSION_1:
1929 case SNMP_VERSION_2:
1930 community_print(ndo, np, length, version);
1931 break;
1932 case SNMP_VERSION_3:
1933 v3msg_print(ndo, np, length);
1934 break;
1935 default:
1936 ND_PRINT("[version = %d]", elem.data.integer);
1937 break;
1938 }
1939
1940 if (ndo->ndo_vflag) {
1941 ND_PRINT("} ");
1942 }
1943 }
[mirror] the TCPdump network dissector