dist/tcpdump/print-snmp.c

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