contrib/tcpdump/print-snmp.c

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