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