contrib/tcpdump/print-snmp.c

   1 /*
   2  * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that the above copyright notice and this paragraph are
   7  * duplicated in all such forms and that any documentation,
   8  * advertising materials, and other materials related to such
   9  * distribution and use acknowledge that the software was developed
  10  * by John Robert LoVerso.
  11  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  12  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  13  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  14  *
  15  * This implementation has been influenced by the CMU SNMP release,
  16  * by Steve Waldbusser.  However, this shares no code with that system.
  17  * Additional ASN.1 insight gained from Marshall T. Rose's _The_Open_Book_.
  18  * Earlier forms of this implementation were derived and/or inspired by an
  19  * awk script originally written by C. Philip Wood of LANL (but later
  20  * heavily modified by John Robert LoVerso).  The copyright notice for
  21  * that work is preserved below, even though it may not rightly apply
  22  * to this file.
  23  *
  24  * This started out as a very simple program, but the incremental decoding
  25  * (into the BE structure) complicated things.
  26  *
  27  #                      Los Alamos National Laboratory
  28  #
  29  #      Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
  30  #      This software was produced under a U.S. Government contract
  31  #      (W-7405-ENG-36) by Los Alamos National Laboratory, which is
  32  #      operated by the University of California for the U.S. Department
  33  #      of Energy.  The U.S. Government is licensed to use, reproduce,
  34  #      and distribute this software.  Permission is granted to the
  35  #      public to copy and use this software without charge, provided
  36  #      that this Notice and any statement of authorship are reproduced
  37  #      on all copies.  Neither the Government nor the University makes
  38  #      any warranty, express or implied, or assumes any liability or
  39  #      responsibility for the use of this software.
  40  #      @(#)snmp.awk.x  1.1 (LANL) 1/15/90
  41  */
  42
  43 #ifndef lint
  44 static const char rcsid[] =
  45     "@(#) $Header: print-snmp.c,v 1.33 97/06/15 13:20:28 leres Exp $ (LBL)";
  46 #endif
  47
  48 #include <sys/param.h>
  49 #include <sys/time.h>
  50
  51 #include <ctype.h>
  52 #ifdef HAVE_MEMORY_H
  53 #include <memory.h>
  54 #endif
  55 #include <stdio.h>
  56 #include <string.h>
  57
  58 #include "interface.h"
  59 #include "addrtoname.h"
  60
  61 /*
  62  * Universal ASN.1 types
  63  * (we only care about the tag values for those allowed in the Internet SMI)
  64  */
  65 char *Universal[] = {
  66         "U-0",
  67         "Boolean",
  68         "Integer",
  69 #define INTEGER 2
  70         "Bitstring",
  71         "String",
  72 #define STRING 4
  73         "Null",
  74 #define ASN_NULL 5
  75         "ObjID",
  76 #define OBJECTID 6
  77         "ObjectDes",
  78         "U-8","U-9","U-10","U-11",      /* 8-11 */
  79         "U-12","U-13","U-14","U-15",    /* 12-15 */
  80         "Sequence",
  81 #define SEQUENCE 16
  82         "Set"
  83 };
  84
  85 /*
  86  * Application-wide ASN.1 types from the Internet SMI and their tags
  87  */
  88 char *Application[] = {
  89         "IpAddress",
  90 #define IPADDR 0
  91         "Counter",
  92 #define COUNTER 1
  93         "Gauge",
  94 #define GAUGE 2
  95         "TimeTicks",
  96 #define TIMETICKS 3
  97         "Opaque"
  98 };
  99
 100 /*
 101  * Context-specific ASN.1 types for the SNMP PDUs and their tags
 102  */
 103 char *Context[] = {
 104         "GetRequest",
 105 #define GETREQ 0
 106         "GetNextRequest",
 107 #define GETNEXTREQ 1
 108         "GetResponse",
 109 #define GETRESP 2
 110         "SetRequest",
 111 #define SETREQ 3
 112         "Trap"
 113 #define TRAP 4
 114 };
 115
 116 /*
 117  * Private ASN.1 types
 118  * The Internet SMI does not specify any
 119  */
 120 char *Private[] = {
 121         "P-0"
 122 };
 123
 124 /*
 125  * error-status values for any SNMP PDU
 126  */
 127 char *ErrorStatus[] = {
 128         "noError",
 129         "tooBig",
 130         "noSuchName",
 131         "badValue",
 132         "readOnly",
 133         "genErr"
 134 };
 135 #define DECODE_ErrorStatus(e) \
 136         ( e >= 0 && e <= sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) \
 137         ? ErrorStatus[e] : (sprintf(errbuf, "err=%u", e), errbuf))
 138
 139 /*
 140  * generic-trap values in the SNMP Trap-PDU
 141  */
 142 char *GenericTrap[] = {
 143         "coldStart",
 144         "warmStart",
 145         "linkDown",
 146         "linkUp",
 147         "authenticationFailure",
 148         "egpNeighborLoss",
 149         "enterpriseSpecific"
 150 #define GT_ENTERPRISE 7
 151 };
 152 #define DECODE_GenericTrap(t) \
 153         ( t >= 0 && t <= sizeof(GenericTrap)/sizeof(GenericTrap[0]) \
 154         ? GenericTrap[t] : (sprintf(buf, "gt=%d", t), buf))
 155
 156 /*
 157  * ASN.1 type class table
 158  * Ties together the preceding Universal, Application, Context, and Private
 159  * type definitions.
 160  */
 161 #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */
 162 struct {
 163         char    *name;
 164         char    **Id;
 165             int numIDs;
 166     } Class[] = {
 167         defineCLASS(Universal),
 168 #define UNIVERSAL       0
 169         defineCLASS(Application),
 170 #define APPLICATION     1
 171         defineCLASS(Context),
 172 #define CONTEXT         2
 173         defineCLASS(Private),
 174 #define PRIVATE         3
 175 };
 176
 177 /*
 178  * defined forms for ASN.1 types
 179  */
 180 char *Form[] = {
 181         "Primitive",
 182 #define PRIMITIVE       0
 183         "Constructed",
 184 #define CONSTRUCTED     1
 185 };
 186
 187 /*
 188  * A structure for the OID tree for the compiled-in MIB.
 189  * This is stored as a general-order tree.
 190  */
 191 struct obj {
 192         char    *desc;                  /* name of object */
 193         u_char  oid;                    /* sub-id following parent */
 194         u_char  type;                   /* object type (unused) */
 195         struct obj *child, *next;       /* child and next sibling pointers */
 196 } *objp = NULL;
 197
 198 /*
 199  * Include the compiled in SNMP MIB.  "mib.h" is produced by feeding
 200  * RFC-1156 format files into "makemib".  "mib.h" MUST define at least
 201  * a value for `mibroot'.
 202  *
 203  * In particular, this is gross, as this is including initialized structures,
 204  * and by right shouldn't be an "include" file.
 205  */
 206 #include "mib.h"
 207
 208 /*
 209  * This defines a list of OIDs which will be abbreviated on output.
 210  * Currently, this includes the prefixes for the Internet MIB, the
 211  * private enterprises tree, and the experimental tree.
 212  */
 213 struct obj_abrev {
 214         char *prefix;                   /* prefix for this abrev */
 215         struct obj *node;               /* pointer into object table */
 216         char *oid;                      /* ASN.1 encoded OID */
 217 } obj_abrev_list[] = {
 218 #ifndef NO_ABREV_MIB
 219         /* .iso.org.dod.internet.mgmt.mib */
 220         { "",   &_mib_obj,              "\53\6\1\2\1" },
 221 #endif
 222 #ifndef NO_ABREV_ENTER
 223         /* .iso.org.dod.internet.private.enterprises */
 224         { "E:", &_enterprises_obj,      "\53\6\1\4\1" },
 225 #endif
 226 #ifndef NO_ABREV_EXPERI
 227         /* .iso.org.dod.internet.experimental */
 228         { "X:", &_experimental_obj,     "\53\6\1\3" },
 229 #endif
 230         { 0,0,0 }
 231 };
 232
 233 /*
 234  * This is used in the OID print routine to walk down the object tree
 235  * rooted at `mibroot'.
 236  */
 237 #define OBJ_PRINT(o, suppressdot) \
 238 { \
 239         if (objp) { \
 240                 do { \
 241                         if ((o) == objp->oid) \
 242                                 break; \
 243                 } while ((objp = objp->next) != NULL); \
 244         } \
 245         if (objp) { \
 246                 printf(suppressdot?"%s":".%s", objp->desc); \
 247                 objp = objp->child; \
 248         } else \
 249                 printf(suppressdot?"%u":".%u", (o)); \
 250 }
 251
 252 /*
 253  * This is the definition for the Any-Data-Type storage used purely for
 254  * temporary internal representation while decoding an ASN.1 data stream.
 255  */
 256 struct be {
 257         u_int32_t asnlen;
 258         union {
 259                 caddr_t raw;
 260                 int32_t integer;
 261                 u_int32_t uns;
 262                 const u_char *str;
 263         } data;
 264         u_short id;
 265         u_char form, class;             /* tag info */
 266         u_char type;
 267 #define BE_ANY          255
 268 #define BE_NONE         0
 269 #define BE_NULL         1
 270 #define BE_OCTET        2
 271 #define BE_OID          3
 272 #define BE_INT          4
 273 #define BE_UNS          5
 274 #define BE_STR          6
 275 #define BE_SEQ          7
 276 #define BE_INETADDR     8
 277 #define BE_PDU          9
 278 };
 279
 280 /*
 281  * Defaults for SNMP PDU components
 282  */
 283 #define DEF_COMMUNITY "public"
 284 #define DEF_VERSION 0
 285
 286 /*
 287  * constants for ASN.1 decoding
 288  */
 289 #define OIDMUX 40
 290 #define ASNLEN_INETADDR 4
 291 #define ASN_SHIFT7 7
 292 #define ASN_SHIFT8 8
 293 #define ASN_BIT8 0x80
 294 #define ASN_LONGLEN 0x80
 295
 296 #define ASN_ID_BITS 0x1f
 297 #define ASN_FORM_BITS 0x20
 298 #define ASN_FORM_SHIFT 5
 299 #define ASN_CLASS_BITS 0xc0
 300 #define ASN_CLASS_SHIFT 6
 301
 302 #define ASN_ID_EXT 0x1f         /* extension ID in tag field */
 303
 304 /*
 305  * truncated==1 means the packet was complete, but we don't have all of
 306  * it to decode.
 307  */
 308 static int truncated;
 309 #define ifNotTruncated if (truncated) fputs("[|snmp]", stdout); else
 310
 311 /*
 312  * This decodes the next ASN.1 object in the stream pointed to by "p"
 313  * (and of real-length "len") and stores the intermediate data in the
 314  * provided BE object.
 315  *
 316  * This returns -l if it fails (i.e., the ASN.1 stream is not valid).
 317  * O/w, this returns the number of bytes parsed from "p".
 318  */
 319 static int
 320 asn1_parse(register const u_char *p, u_int len, struct be *elem)
 321 {
 322         u_char form, class, id;
 323         int i, hdr;
 324
 325         elem->asnlen = 0;
 326         elem->type = BE_ANY;
 327         if (len < 1) {
 328                 ifNotTruncated puts("[nothing to parse], stdout");
 329                 return -1;
 330         }
 331
 332         /*
 333          * it would be nice to use a bit field, but you can't depend on them.
 334          *  +---+---+---+---+---+---+---+---+
 335          *  + class |frm|        id         |
 336          *  +---+---+---+---+---+---+---+---+
 337          *    7   6   5   4   3   2   1   0
 338          */
 339         id = *p & ASN_ID_BITS;          /* lower 5 bits, range 00-1f */
 340 #ifdef notdef
 341         form = (*p & 0xe0) >> 5;        /* move upper 3 bits to lower 3 */
 342         class = form >> 1;              /* bits 7&6 -> bits 1&0, range 0-3 */
 343         form &= 0x1;                    /* bit 5 -> bit 0, range 0-1 */
 344 #else
 345         form = (u_char)(*p & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
 346         class = (u_char)(*p & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT;
 347 #endif
 348         elem->form = form;
 349         elem->class = class;
 350         elem->id = id;
 351         if (vflag)
 352                 printf("|%.2x", *p);
 353         p++; len--; hdr = 1;
 354         /* extended tag field */
 355         if (id == ASN_ID_EXT) {
 356                 for (id = 0; *p & ASN_BIT8 && len > 0; len--, hdr++, p++) {
 357                         if (vflag)
 358                                 printf("|%.2x", *p);
 359                         id = (id << 7) | (*p & ~ASN_BIT8);
 360                 }
 361                 if (len == 0 && *p & ASN_BIT8) {
 362                         ifNotTruncated fputs("[Xtagfield?]", stdout);
 363                         return -1;
 364                 }
 365                 elem->id = id = (id << 7) | *p;
 366                 --len;
 367                 ++hdr;
 368                 ++p;
 369         }
 370         if (len < 1) {
 371                 ifNotTruncated fputs("[no asnlen]", stdout);
 372                 return -1;
 373         }
 374         elem->asnlen = *p;
 375         if (vflag)
 376                 printf("|%.2x", *p);
 377         p++; len--; hdr++;
 378         if (elem->asnlen & ASN_BIT8) {
 379                 int noct = elem->asnlen % ASN_BIT8;
 380                 elem->asnlen = 0;
 381                 if (len < noct) {
 382                         ifNotTruncated printf("[asnlen? %d<%d]", len, noct);
 383                         return -1;
 384                 }
 385                 for (; noct-- > 0; len--, hdr++) {
 386                         if (vflag)
 387                                 printf("|%.2x", *p);
 388                         elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
 389                 }
 390         }
 391         if (len < elem->asnlen) {
 392                 if (!truncated) {
 393                         printf("[len%d<asnlen%u]", len, elem->asnlen);
 394                         return -1;
 395                 }
 396                 /* maybe should check at least 4? */
 397                 elem->asnlen = len;
 398         }
 399         if (form >= sizeof(Form)/sizeof(Form[0])) {
 400                 ifNotTruncated printf("[form?%d]", form);
 401                 return -1;
 402         }
 403         if (class >= sizeof(Class)/sizeof(Class[0])) {
 404                 ifNotTruncated printf("[class?%c/%d]", *Form[form], class);
 405                 return -1;
 406         }
 407         if ((int)id >= Class[class].numIDs) {
 408                 ifNotTruncated printf("[id?%c/%s/%d]", *Form[form],
 409                         Class[class].name, id);
 410                 return -1;
 411         }
 412
 413         switch (form) {
 414         case PRIMITIVE:
 415                 switch (class) {
 416                 case UNIVERSAL:
 417                         switch (id) {
 418                         case STRING:
 419                                 elem->type = BE_STR;
 420                                 elem->data.str = p;
 421                                 break;
 422
 423                         case INTEGER: {
 424                                 register int32_t data;
 425                                 elem->type = BE_INT;
 426                                 data = 0;
 427
 428                                 if (*p & ASN_BIT8)      /* negative */
 429                                         data = -1;
 430                                 for (i = elem->asnlen; i-- > 0; p++)
 431                                         data = (data << ASN_SHIFT8) | *p;
 432                                 elem->data.integer = data;
 433                                 break;
 434                         }
 435
 436                         case OBJECTID:
 437                                 elem->type = BE_OID;
 438                                 elem->data.raw = (caddr_t)p;
 439                                 break;
 440
 441                         case ASN_NULL:
 442                                 elem->type = BE_NULL;
 443                                 elem->data.raw = NULL;
 444                                 break;
 445
 446                         default:
 447                                 elem->type = BE_OCTET;
 448                                 elem->data.raw = (caddr_t)p;
 449                                 printf("[P/U/%s]",
 450                                         Class[class].Id[id]);
 451                                 break;
 452                         }
 453                         break;
 454
 455                 case APPLICATION:
 456                         switch (id) {
 457                         case IPADDR:
 458                                 elem->type = BE_INETADDR;
 459                                 elem->data.raw = (caddr_t)p;
 460                                 break;
 461
 462                         case COUNTER:
 463                         case GAUGE:
 464                         case TIMETICKS: {
 465                                 register u_int32_t data;
 466                                 elem->type = BE_UNS;
 467                                 data = 0;
 468                                 for (i = elem->asnlen; i-- > 0; p++)
 469                                         data = (data << 8) + *p;
 470                                 elem->data.uns = data;
 471                                 break;
 472                         }
 473
 474                         default:
 475                                 elem->type = BE_OCTET;
 476                                 elem->data.raw = (caddr_t)p;
 477                                 printf("[P/A/%s]",
 478                                         Class[class].Id[id]);
 479                                 break;
 480                         }
 481                         break;
 482
 483                 default:
 484                         elem->type = BE_OCTET;
 485                         elem->data.raw = (caddr_t)p;
 486                         printf("[P/%s/%s]",
 487                                 Class[class].name, Class[class].Id[id]);
 488                         break;
 489                 }
 490                 break;
 491
 492         case CONSTRUCTED:
 493                 switch (class) {
 494                 case UNIVERSAL:
 495                         switch (id) {
 496                         case SEQUENCE:
 497                                 elem->type = BE_SEQ;
 498                                 elem->data.raw = (caddr_t)p;
 499                                 break;
 500
 501                         default:
 502                                 elem->type = BE_OCTET;
 503                                 elem->data.raw = (caddr_t)p;
 504                                 printf("C/U/%s", Class[class].Id[id]);
 505                                 break;
 506                         }
 507                         break;
 508
 509                 case CONTEXT:
 510                         elem->type = BE_PDU;
 511                         elem->data.raw = (caddr_t)p;
 512                         break;
 513
 514                 default:
 515                         elem->type = BE_OCTET;
 516                         elem->data.raw = (caddr_t)p;
 517                         printf("C/%s/%s",
 518                                 Class[class].name, Class[class].Id[id]);
 519                         break;
 520                 }
 521                 break;
 522         }
 523         p += elem->asnlen;
 524         len -= elem->asnlen;
 525         return elem->asnlen + hdr;
 526 }
 527
 528 /*
 529  * Display the ASN.1 object represented by the BE object.
 530  * This used to be an integral part of asn1_parse() before the intermediate
 531  * BE form was added.
 532  */
 533 static void
 534 asn1_print(struct be *elem)
 535 {
 536         u_char *p = (u_char *)elem->data.raw;
 537         u_int32_t asnlen = elem->asnlen;
 538         int i;
 539
 540         switch (elem->type) {
 541
 542         case BE_OCTET:
 543                 for (i = asnlen; i-- > 0; p++);
 544                         printf("_%.2x", *p);
 545                 break;
 546
 547         case BE_NULL:
 548                 break;
 549
 550         case BE_OID: {
 551         int o = 0, first = -1, i = asnlen;
 552
 553                 if (!nflag && asnlen > 2) {
 554                         struct obj_abrev *a = &obj_abrev_list[0];
 555                         for (; a->node; a++) {
 556                                 if (!memcmp(a->oid, (char *)p,
 557                                     strlen(a->oid))) {
 558                                         objp = a->node->child;
 559                                         i -= strlen(a->oid);
 560                                         p += strlen(a->oid);
 561                                         fputs(a->prefix, stdout);
 562                                         first = 1;
 563                                         break;
 564                                 }
 565                         }
 566                 }
 567                 for (; i-- > 0; p++) {
 568                         o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
 569                         if (*p & ASN_LONGLEN)
 570                                 continue;
 571
 572                         /*
 573                          * first subitem encodes two items with 1st*OIDMUX+2nd
 574                          */
 575                         if (first < 0) {
 576                                 if (!nflag)
 577                                         objp = mibroot;
 578                                 first = 0;
 579                                 OBJ_PRINT(o/OIDMUX, first);
 580                                 o %= OIDMUX;
 581                         }
 582                         OBJ_PRINT(o, first);
 583                         if (--first < 0)
 584                                 first = 0;
 585                         o = 0;
 586                 }
 587                 break;
 588         }
 589
 590         case BE_INT:
 591                 printf("%d", elem->data.integer);
 592                 break;
 593
 594         case BE_UNS:
 595                 printf("%d", elem->data.uns);
 596                 break;
 597
 598         case BE_STR: {
 599                 register int printable = 1, first = 1;
 600                 const u_char *p = elem->data.str;
 601                 for (i = asnlen; printable && i-- > 0; p++)
 602                         printable = isprint(*p) || isspace(*p);
 603                 p = elem->data.str;
 604                 if (printable) {
 605                         putchar('"');
 606                         (void)fn_print(p, p + asnlen);
 607                         putchar('"');
 608                 } else
 609                         for (i = asnlen; i-- > 0; p++) {
 610                                 printf(first ? "%.2x" : "_%.2x", *p);
 611                                 first = 0;
 612                         }
 613                 break;
 614         }
 615
 616         case BE_SEQ:
 617                 printf("Seq(%u)", elem->asnlen);
 618                 break;
 619
 620         case BE_INETADDR: {
 621                 char sep;
 622                 if (asnlen != ASNLEN_INETADDR)
 623                         printf("[inetaddr len!=%d]", ASNLEN_INETADDR);
 624                 sep='[';
 625                 for (i = asnlen; i-- > 0; p++) {
 626                         printf("%c%u", sep, *p);
 627                         sep='.';
 628                 }
 629                 putchar(']');
 630                 break;
 631         }
 632
 633         case BE_PDU:
 634                 printf("%s(%u)",
 635                         Class[CONTEXT].Id[elem->id], elem->asnlen);
 636                 break;
 637
 638         case BE_ANY:
 639                 fputs("[BE_ANY!?]", stdout);
 640                 break;
 641
 642         default:
 643                 fputs("[be!?]", stdout);
 644                 break;
 645         }
 646 }
 647
 648 #ifdef notdef
 649 /*
 650  * This is a brute force ASN.1 printer: recurses to dump an entire structure.
 651  * This will work for any ASN.1 stream, not just an SNMP PDU.
 652  *
 653  * By adding newlines and spaces at the correct places, this would print in
 654  * Rose-Normal-Form.
 655  *
 656  * This is not currently used.
 657  */
 658 static void
 659 asn1_decode(u_char *p, u_int length)
 660 {
 661         struct be elem;
 662         int i = 0;
 663
 664         while (i >= 0 && length > 0) {
 665                 i = asn1_parse(p, length, &elem);
 666                 if (i >= 0) {
 667                         fputs(" ", stdout);
 668                         asn1_print(&elem);
 669                         if (elem.type == BE_SEQ || elem.type == BE_PDU) {
 670                                 fputs(" {", stdout);
 671                                 asn1_decode(elem.data.raw, elem.asnlen);
 672                                 fputs(" }", stdout);
 673                         }
 674                         length -= i;
 675                         p += i;
 676                 }
 677         }
 678 }
 679 #endif
 680
 681 /*
 682  * General SNMP header
 683  *      SEQUENCE {
 684  *              version INTEGER {version-1(0)},
 685  *              community OCTET STRING,
 686  *              data ANY        -- PDUs
 687  *      }
 688  * PDUs for all but Trap: (see rfc1157 from page 15 on)
 689  *      SEQUENCE {
 690  *              request-id INTEGER,
 691  *              error-status INTEGER,
 692  *              error-index INTEGER,
 693  *              varbindlist SEQUENCE OF
 694  *                      SEQUENCE {
 695  *                              name ObjectName,
 696  *                              value ObjectValue
 697  *                      }
 698  *      }
 699  * PDU for Trap:
 700  *      SEQUENCE {
 701  *              enterprise OBJECT IDENTIFIER,
 702  *              agent-addr NetworkAddress,
 703  *              generic-trap INTEGER,
 704  *              specific-trap INTEGER,
 705  *              time-stamp TimeTicks,
 706  *              varbindlist SEQUENCE OF
 707  *                      SEQUENCE {
 708  *                              name ObjectName,
 709  *                              value ObjectValue
 710  *                      }
 711  *      }
 712  */
 713
 714 /*
 715  * Decode SNMP varBind
 716  */
 717 static void
 718 varbind_print(u_char pduid, const u_char *np, u_int length, int error)
 719 {
 720         struct be elem;
 721         int count = 0, ind;
 722
 723         /* Sequence of varBind */
 724         if ((count = asn1_parse(np, length, &elem)) < 0)
 725                 return;
 726         if (elem.type != BE_SEQ) {
 727                 fputs("[!SEQ of varbind]", stdout);
 728                 asn1_print(&elem);
 729                 return;
 730         }
 731         if (count < length)
 732                 printf("[%d extra after SEQ of varbind]", length - count);
 733         /* descend */
 734         length = elem.asnlen;
 735         np = (u_char *)elem.data.raw;
 736
 737         for (ind = 1; length > 0; ind++) {
 738                 const u_char *vbend;
 739                 u_int vblength;
 740
 741                 if (!error || ind == error)
 742                         fputs(" ", stdout);
 743
 744                 /* Sequence */
 745                 if ((count = asn1_parse(np, length, &elem)) < 0)
 746                         return;
 747                 if (elem.type != BE_SEQ) {
 748                         fputs("[!varbind]", stdout);
 749                         asn1_print(&elem);
 750                         return;
 751                 }
 752                 vbend = np + count;
 753                 vblength = length - count;
 754                 /* descend */
 755                 length = elem.asnlen;
 756                 np = (u_char *)elem.data.raw;
 757
 758                 /* objName (OID) */
 759                 if ((count = asn1_parse(np, length, &elem)) < 0)
 760                         return;
 761                 if (elem.type != BE_OID) {
 762                         fputs("[objName!=OID]", stdout);
 763                         asn1_print(&elem);
 764                         return;
 765                 }
 766                 if (!error || ind == error)
 767                         asn1_print(&elem);
 768                 length -= count;
 769                 np += count;
 770
 771                 if (pduid != GETREQ && pduid != GETNEXTREQ && !error)
 772                                 fputs("=", stdout);
 773
 774                 /* objVal (ANY) */
 775                 if ((count = asn1_parse(np, length, &elem)) < 0)
 776                         return;
 777                 if (pduid == GETREQ || pduid == GETNEXTREQ) {
 778                         if (elem.type != BE_NULL) {
 779                                 fputs("[objVal!=NULL]", stdout);
 780                                 asn1_print(&elem);
 781                         }
 782                 } else
 783                         if (error && ind == error && elem.type != BE_NULL)
 784                                 fputs("[err objVal!=NULL]", stdout);
 785                         if (!error || ind == error)
 786                                 asn1_print(&elem);
 787
 788                 length = vblength;
 789                 np = vbend;
 790         }
 791 }
 792
 793 /*
 794  * Decode SNMP PDUs: GetRequest, GetNextRequest, GetResponse, and SetRequest
 795  */
 796 static void
 797 snmppdu_print(u_char pduid, const u_char *np, u_int length)
 798 {
 799         struct be elem;
 800         int count = 0, error;
 801
 802         /* reqId (Integer) */
 803         if ((count = asn1_parse(np, length, &elem)) < 0)
 804                 return;
 805         if (elem.type != BE_INT) {
 806                 fputs("[reqId!=INT]", stdout);
 807                 asn1_print(&elem);
 808                 return;
 809         }
 810         /* ignore the reqId */
 811         length -= count;
 812         np += count;
 813
 814         /* errorStatus (Integer) */
 815         if ((count = asn1_parse(np, length, &elem)) < 0)
 816                 return;
 817         if (elem.type != BE_INT) {
 818                 fputs("[errorStatus!=INT]", stdout);
 819                 asn1_print(&elem);
 820                 return;
 821         }
 822         error = 0;
 823         if ((pduid == GETREQ || pduid == GETNEXTREQ)
 824             && elem.data.integer != 0) {
 825                 char errbuf[10];
 826                 printf("[errorStatus(%s)!=0]",
 827                         DECODE_ErrorStatus(elem.data.integer));
 828         } else if (elem.data.integer != 0) {
 829                 char errbuf[10];
 830                 printf(" %s", DECODE_ErrorStatus(elem.data.integer));
 831                 error = elem.data.integer;
 832         }
 833         length -= count;
 834         np += count;
 835
 836         /* errorIndex (Integer) */
 837         if ((count = asn1_parse(np, length, &elem)) < 0)
 838                 return;
 839         if (elem.type != BE_INT) {
 840                 fputs("[errorIndex!=INT]", stdout);
 841                 asn1_print(&elem);
 842                 return;
 843         }
 844         if ((pduid == GETREQ || pduid == GETNEXTREQ)
 845             && elem.data.integer != 0)
 846                 printf("[errorIndex(%d)!=0]", elem.data.integer);
 847         else if (elem.data.integer != 0) {
 848                 if (!error)
 849                         printf("[errorIndex(%d) w/o errorStatus]",
 850                                 elem.data.integer);
 851                 else {
 852                         printf("@%d", elem.data.integer);
 853                         error = elem.data.integer;
 854                 }
 855         } else if (error) {
 856                 fputs("[errorIndex==0]", stdout);
 857                 error = 0;
 858         }
 859         length -= count;
 860         np += count;
 861
 862         varbind_print(pduid, np, length, error);
 863         return;
 864 }
 865
 866 /*
 867  * Decode SNMP Trap PDU
 868  */
 869 static void
 870 trap_print(const u_char *np, u_int length)
 871 {
 872         struct be elem;
 873         int count = 0, generic;
 874
 875         putchar(' ');
 876
 877         /* enterprise (oid) */
 878         if ((count = asn1_parse(np, length, &elem)) < 0)
 879                 return;
 880         if (elem.type != BE_OID) {
 881                 fputs("[enterprise!=OID]", stdout);
 882                 asn1_print(&elem);
 883                 return;
 884         }
 885         asn1_print(&elem);
 886         length -= count;
 887         np += count;
 888
 889         putchar(' ');
 890
 891         /* agent-addr (inetaddr) */
 892         if ((count = asn1_parse(np, length, &elem)) < 0)
 893                 return;
 894         if (elem.type != BE_INETADDR) {
 895                 fputs("[agent-addr!=INETADDR]", stdout);
 896                 asn1_print(&elem);
 897                 return;
 898         }
 899         asn1_print(&elem);
 900         length -= count;
 901         np += count;
 902
 903         /* generic-trap (Integer) */
 904         if ((count = asn1_parse(np, length, &elem)) < 0)
 905                 return;
 906         if (elem.type != BE_INT) {
 907                 fputs("[generic-trap!=INT]", stdout);
 908                 asn1_print(&elem);
 909                 return;
 910         }
 911         generic = elem.data.integer;
 912         {
 913                 char buf[10];
 914                 printf(" %s", DECODE_GenericTrap(generic));
 915         }
 916         length -= count;
 917         np += count;
 918
 919         /* specific-trap (Integer) */
 920         if ((count = asn1_parse(np, length, &elem)) < 0)
 921                 return;
 922         if (elem.type != BE_INT) {
 923                 fputs("[specific-trap!=INT]", stdout);
 924                 asn1_print(&elem);
 925                 return;
 926         }
 927         if (generic != GT_ENTERPRISE) {
 928                 if (elem.data.integer != 0)
 929                         printf("[specific-trap(%d)!=0]", elem.data.integer);
 930         } else
 931                 printf(" s=%d", elem.data.integer);
 932         length -= count;
 933         np += count;
 934
 935         putchar(' ');
 936
 937         /* time-stamp (TimeTicks) */
 938         if ((count = asn1_parse(np, length, &elem)) < 0)
 939                 return;
 940         if (elem.type != BE_UNS) {                      /* XXX */
 941                 fputs("[time-stamp!=TIMETICKS]", stdout);
 942                 asn1_print(&elem);
 943                 return;
 944         }
 945         asn1_print(&elem);
 946         length -= count;
 947         np += count;
 948
 949         varbind_print (TRAP, np, length, 0);
 950         return;
 951 }
 952
 953 /*
 954  * Decode SNMP header and pass on to PDU printing routines
 955  */
 956 void
 957 snmp_print(const u_char *np, u_int length)
 958 {
 959         struct be elem, pdu;
 960         int count = 0;
 961
 962         truncated = 0;
 963
 964         /* truncated packet? */
 965         if (np + length > snapend) {
 966                 truncated = 1;
 967                 length = snapend - np;
 968         }
 969
 970         putchar(' ');
 971
 972         /* initial Sequence */
 973         if ((count = asn1_parse(np, length, &elem)) < 0)
 974                 return;
 975         if (elem.type != BE_SEQ) {
 976                 fputs("[!init SEQ]", stdout);
 977                 asn1_print(&elem);
 978                 return;
 979         }
 980         if (count < length)
 981                 printf("[%d extra after iSEQ]", length - count);
 982         /* descend */
 983         length = elem.asnlen;
 984         np = (u_char *)elem.data.raw;
 985         /* Version (Integer) */
 986         if ((count = asn1_parse(np, length, &elem)) < 0)
 987                 return;
 988         if (elem.type != BE_INT) {
 989                 fputs("[version!=INT]", stdout);
 990                 asn1_print(&elem);
 991                 return;
 992         }
 993         /* only handle version==0 */
 994         if (elem.data.integer != DEF_VERSION) {
 995                 printf("[version(%d)!=0]", elem.data.integer);
 996                 return;
 997         }
 998         length -= count;
 999         np += count;
1000
1001         /* Community (String) */
1002         if ((count = asn1_parse(np, length, &elem)) < 0)
1003                 return;
1004         if (elem.type != BE_STR) {
1005                 fputs("[comm!=STR]", stdout);
1006                 asn1_print(&elem);
1007                 return;
1008         }
1009         /* default community */
1010         if (strncmp((char *)elem.data.str, DEF_COMMUNITY,
1011             sizeof(DEF_COMMUNITY) - 1))
1012                 /* ! "public" */
1013                 printf("C=%.*s ", (int)elem.asnlen, elem.data.str);
1014         length -= count;
1015         np += count;
1016
1017         /* PDU (Context) */
1018         if ((count = asn1_parse(np, length, &pdu)) < 0)
1019                 return;
1020         if (pdu.type != BE_PDU) {
1021                 fputs("[no PDU]", stdout);
1022                 return;
1023         }
1024         if (count < length)
1025                 printf("[%d extra after PDU]", length - count);
1026         asn1_print(&pdu);
1027         /* descend into PDU */
1028         length = pdu.asnlen;
1029         np = (u_char *)pdu.data.raw;
1030
1031         switch (pdu.id) {
1032         case TRAP:
1033                 trap_print(np, length);
1034                 break;
1035         case GETREQ:
1036         case GETNEXTREQ:
1037         case GETRESP:
1038         case SETREQ:
1039                 snmppdu_print(pdu.id, np, length);
1040                 break;
1041         }
1042         return;
1043 }