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