| File: | src/usr.sbin/tcpdump/print-snmp.c |
| Warning: | line 640, column 2 Value stored to 'p' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* $OpenBSD: print-snmp.c,v 1.28 2021/10/23 10:47:50 martijn Exp $ */ |
| 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 | * This started out as a very simple program, but the incremental decoding |
| 40 | * (into the BE structure) complicated things. |
| 41 | * |
| 42 | # Los Alamos National Laboratory |
| 43 | # |
| 44 | # Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997 |
| 45 | # This software was produced under a U.S. Government contract |
| 46 | # (W-7405-ENG-36) by Los Alamos National Laboratory, which is |
| 47 | # operated by the University of California for the U.S. Department |
| 48 | # of Energy. The U.S. Government is licensed to use, reproduce, |
| 49 | # and distribute this software. Permission is granted to the |
| 50 | # public to copy and use this software without charge, provided |
| 51 | # that this Notice and any statement of authorship are reproduced |
| 52 | # on all copies. Neither the Government nor the University makes |
| 53 | # any warranty, express or implied, or assumes any liability or |
| 54 | # responsibility for the use of this software. |
| 55 | # @(#)snmp.awk.x 1.1 (LANL) 1/15/90 |
| 56 | */ |
| 57 | |
| 58 | #include <sys/time.h> |
| 59 | |
| 60 | #include <ctype.h> |
| 61 | #include <stdio.h> |
| 62 | #include <string.h> |
| 63 | |
| 64 | #include "interface.h" |
| 65 | #include "addrtoname.h" |
| 66 | |
| 67 | /* |
| 68 | * Universal ASN.1 types |
| 69 | * (we only care about the tag values for those allowed in the Internet SMI) |
| 70 | */ |
| 71 | char *Universal[] = { |
| 72 | "U-0", |
| 73 | "Boolean", |
| 74 | "Integer", |
| 75 | #define INTEGER2 2 |
| 76 | "Bitstring", |
| 77 | "String", |
| 78 | #define STRING4 4 |
| 79 | "Null", |
| 80 | #define ASN_NULL5 5 |
| 81 | "ObjID", |
| 82 | #define OBJECTID6 6 |
| 83 | "ObjectDes", |
| 84 | "U-8","U-9","U-10","U-11", /* 8-11 */ |
| 85 | "U-12","U-13","U-14","U-15", /* 12-15 */ |
| 86 | "Sequence", |
| 87 | #define SEQUENCE16 16 |
| 88 | "Set" |
| 89 | }; |
| 90 | |
| 91 | /* |
| 92 | * Application-wide ASN.1 types from the Internet SMI and their tags |
| 93 | */ |
| 94 | char *Application[] = { |
| 95 | "IpAddress", |
| 96 | #define IPADDR0 0 |
| 97 | "Counter", |
| 98 | #define COUNTER1 1 |
| 99 | "Gauge", |
| 100 | #define GAUGE2 2 |
| 101 | "TimeTicks", |
| 102 | #define TIMETICKS3 3 |
| 103 | "Opaque", |
| 104 | #define OPAQUE4 4 |
| 105 | "NsapAddress", |
| 106 | #define NSAPADDR5 5 |
| 107 | "Counter64", |
| 108 | #define COUNTER646 6 |
| 109 | "UInteger32" /* Defined in RFC1442, removed since RFC1902 */ |
| 110 | #define UINTEGER327 7 |
| 111 | }; |
| 112 | |
| 113 | /* |
| 114 | * Context-specific ASN.1 types for the SNMP PDUs and their tags |
| 115 | */ |
| 116 | char *Context[] = { |
| 117 | "GetRequest", |
| 118 | #define GETREQ0 0 |
| 119 | "GetNextRequest", |
| 120 | #define GETNEXTREQ1 1 |
| 121 | "GetResponse", |
| 122 | #define GETRESP2 2 |
| 123 | "SetRequest", |
| 124 | #define SETREQ3 3 |
| 125 | "Trap", |
| 126 | #define TRAP4 4 |
| 127 | "GetBulkReq", |
| 128 | #define GETBULKREQ5 5 |
| 129 | "InformReq", |
| 130 | #define INFORMREQ6 6 |
| 131 | "TrapV2", |
| 132 | #define TRAPV27 7 |
| 133 | "Report" |
| 134 | #define REPORT8 8 |
| 135 | }; |
| 136 | |
| 137 | char *ContextVarbind[] = { |
| 138 | "noSuchObject", |
| 139 | #define NOSUCHOBJECT0 0 |
| 140 | "noSuchInstance", |
| 141 | #define NOSUCHINSTANCE1 1 |
| 142 | "endOfMibView" |
| 143 | #define ENDOFMIBVIEW2 2 |
| 144 | }; |
| 145 | |
| 146 | /* |
| 147 | * Private ASN.1 types |
| 148 | * The Internet SMI does not specify any |
| 149 | */ |
| 150 | char *Private[] = { |
| 151 | "P-0" |
| 152 | }; |
| 153 | |
| 154 | /* |
| 155 | * error-status values for any SNMP PDU |
| 156 | */ |
| 157 | char *ErrorStatus[] = { |
| 158 | "noError", |
| 159 | "tooBig", |
| 160 | "noSuchName", |
| 161 | "badValue", |
| 162 | "readOnly", |
| 163 | "genErr", |
| 164 | "noAccess", |
| 165 | "wrongType", |
| 166 | "wrongLength", |
| 167 | "wrongEnc", |
| 168 | "wrongValue", |
| 169 | "noCreation", |
| 170 | "inconValue", |
| 171 | "resUnavail", |
| 172 | "commitFailed", |
| 173 | "undoFailed", |
| 174 | "authError", |
| 175 | "notWritable", |
| 176 | "inconName" |
| 177 | }; |
| 178 | #define DECODE_ErrorStatus(e)( e >= 0 && e <= sizeof(ErrorStatus)/sizeof(ErrorStatus [0]) ? ErrorStatus[e] : (snprintf(errbuf, sizeof(errbuf), "err=%u" , e), errbuf)) \ |
| 179 | ( e >= 0 && e <= sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) \ |
| 180 | ? ErrorStatus[e] : (snprintf(errbuf, sizeof(errbuf), "err=%u", e), errbuf)) |
| 181 | |
| 182 | /* |
| 183 | * generic-trap values in the SNMP Trap-PDU |
| 184 | */ |
| 185 | char *GenericTrap[] = { |
| 186 | "coldStart", |
| 187 | "warmStart", |
| 188 | "linkDown", |
| 189 | "linkUp", |
| 190 | "authenticationFailure", |
| 191 | "egpNeighborLoss", |
| 192 | "enterpriseSpecific" |
| 193 | #define GT_ENTERPRISE6 6 |
| 194 | }; |
| 195 | #define DECODE_GenericTrap(t)( t >= 0 && t < sizeof(GenericTrap)/sizeof(GenericTrap [0]) ? GenericTrap[t] : (snprintf(buf, sizeof(buf), "gt=%d", t ), buf)) \ |
| 196 | ( t >= 0 && t < sizeof(GenericTrap)/sizeof(GenericTrap[0]) \ |
| 197 | ? GenericTrap[t] : (snprintf(buf, sizeof(buf), "gt=%d", t), buf)) |
| 198 | |
| 199 | /* |
| 200 | * ASN.1 type class table |
| 201 | * Ties together the preceding Universal, Application, Context, and Private |
| 202 | * type definitions. |
| 203 | */ |
| 204 | #define defineCLASS(x){ "x", x, sizeof(x)/sizeof(x[0]) } { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */ |
| 205 | struct { |
| 206 | char *name; |
| 207 | char **Id; |
| 208 | int numIDs; |
| 209 | } Class[] = { |
| 210 | defineCLASS(Universal){ "x", Universal, sizeof(Universal)/sizeof(Universal[0]) }, |
| 211 | #define UNIVERSAL0 0 |
| 212 | defineCLASS(Application){ "x", Application, sizeof(Application)/sizeof(Application[0] ) }, |
| 213 | #define APPLICATION1 1 |
| 214 | defineCLASS(Context){ "x", Context, sizeof(Context)/sizeof(Context[0]) }, |
| 215 | #define CONTEXT2 2 |
| 216 | defineCLASS(Private){ "x", Private, sizeof(Private)/sizeof(Private[0]) }, |
| 217 | #define PRIVATE3 3 |
| 218 | }; |
| 219 | |
| 220 | /* |
| 221 | * defined forms for ASN.1 types |
| 222 | */ |
| 223 | char *Form[] = { |
| 224 | "Primitive", |
| 225 | #define PRIMITIVE0 0 |
| 226 | "Constructed", |
| 227 | #define CONSTRUCTED1 1 |
| 228 | }; |
| 229 | |
| 230 | /* |
| 231 | * A structure for the OID tree for the compiled-in MIB. |
| 232 | * This is stored as a general-order tree. |
| 233 | */ |
| 234 | struct obj { |
| 235 | char *desc; /* name of object */ |
| 236 | u_int oid; /* sub-id following parent */ |
| 237 | u_char type; /* object type (unused) */ |
| 238 | struct obj *child, *next; /* child and next sibling pointers */ |
| 239 | } *objp = NULL((void *)0); |
| 240 | |
| 241 | /* |
| 242 | * Include the compiled in SNMP MIB. "mib.h" is produced by feeding |
| 243 | * RFC-1156 format files into "makemib". "mib.h" MUST define at least |
| 244 | * a value for `mibroot'. |
| 245 | * |
| 246 | * In particular, this is gross, as this is including initialized structures, |
| 247 | * and by right shouldn't be an "include" file. |
| 248 | */ |
| 249 | #include "mib.h" |
| 250 | |
| 251 | /* |
| 252 | * This defines a list of OIDs which will be abbreviated on output. |
| 253 | * Currently, this includes the prefixes for the Internet MIB, the |
| 254 | * private enterprises tree, and the experimental tree. |
| 255 | */ |
| 256 | struct obj_abrev { |
| 257 | char *prefix; /* prefix for this abrev */ |
| 258 | struct obj *node; /* pointer into object table */ |
| 259 | char *oid; /* ASN.1 encoded OID */ |
| 260 | } obj_abrev_list[] = { |
| 261 | #ifndef NO_ABREV_MIB |
| 262 | /* .iso.org.dod.internet.mgmt.mib */ |
| 263 | { "", &_mib_obj, "\53\6\1\2\1" }, |
| 264 | #endif |
| 265 | #ifndef NO_ABREV_ENTER |
| 266 | /* .iso.org.dod.internet.private.enterprises */ |
| 267 | { "E:", &_enterprises_obj, "\53\6\1\4\1" }, |
| 268 | #endif |
| 269 | #ifndef NO_ABREV_EXPERI |
| 270 | /* .iso.org.dod.internet.experimental */ |
| 271 | { "X:", &_experimental_obj, "\53\6\1\3" }, |
| 272 | #endif |
| 273 | #ifndef NO_ABREV_SNMPMIBOBJECTS |
| 274 | /* .iso.org.dod.internet.snmpV2.snmpModules.snmpMIB.snmpMIBObjects */ |
| 275 | { "S:", &_snmpmibobjects_obj, "\53\6\1\6\3\1\1" }, |
| 276 | #endif |
| 277 | { 0,0,0 } |
| 278 | }; |
| 279 | |
| 280 | /* |
| 281 | * This is used in the OID print routine to walk down the object tree |
| 282 | * rooted at `mibroot'. |
| 283 | */ |
| 284 | #define OBJ_PRINT(o, suppressdot){ if (objp) { do { if ((o) == objp->oid) break; } while (( objp = objp->next) != ((void *)0)); } if (objp) { printf(suppressdot ?"%s":".%s", objp->desc); objp = objp->child; } else printf (suppressdot?"%u":".%u", (o)); } \ |
| 285 | { \ |
| 286 | if (objp) { \ |
| 287 | do { \ |
| 288 | if ((o) == objp->oid) \ |
| 289 | break; \ |
| 290 | } while ((objp = objp->next) != NULL((void *)0)); \ |
| 291 | } \ |
| 292 | if (objp) { \ |
| 293 | printf(suppressdot?"%s":".%s", objp->desc); \ |
| 294 | objp = objp->child; \ |
| 295 | } else \ |
| 296 | printf(suppressdot?"%u":".%u", (o)); \ |
| 297 | } |
| 298 | |
| 299 | /* |
| 300 | * This is the definition for the Any-Data-Type storage used purely for |
| 301 | * temporary internal representation while decoding an ASN.1 data stream. |
| 302 | */ |
| 303 | struct be { |
| 304 | u_int32_t asnlen; |
| 305 | union { |
| 306 | caddr_t raw; |
| 307 | int32_t integer; |
| 308 | u_int32_t uns; |
| 309 | u_int64_t uns64; |
| 310 | const u_char *str; |
| 311 | } data; |
| 312 | u_short id; |
| 313 | u_char form, class; /* tag info */ |
| 314 | u_char type; |
| 315 | #define BE_ANY255 255 |
| 316 | #define BE_NONE0 0 |
| 317 | #define BE_NULL1 1 |
| 318 | #define BE_OCTET2 2 |
| 319 | #define BE_OID3 3 |
| 320 | #define BE_INT4 4 |
| 321 | #define BE_UNS5 5 |
| 322 | #define BE_STR6 6 |
| 323 | #define BE_SEQ7 7 |
| 324 | #define BE_INETADDR8 8 |
| 325 | #define BE_PDU9 9 |
| 326 | #define BE_UNS6410 10 |
| 327 | #define BE_VB11 11 |
| 328 | }; |
| 329 | |
| 330 | |
| 331 | /* |
| 332 | * SNMP components |
| 333 | */ |
| 334 | static int snmp3_print_usmparams(const u_char *, u_int); |
| 335 | |
| 336 | enum snmp_version { |
| 337 | SNMP_V1 = 0, |
| 338 | SNMP_V2C = 1, |
| 339 | SNMP_V3 = 3 |
| 340 | }; |
| 341 | #define SNMP3_AUTH(f)(f & 0x01) (f & 0x01) |
| 342 | #define SNMP3_PRIV(f)(f & 0x02) (f & 0x02) |
| 343 | #define SNMP3_REPORT(f)(f & 0x04) (f & 0x04) |
| 344 | |
| 345 | struct snmp3_sm { |
| 346 | int id; |
| 347 | char *name; |
| 348 | int (*parse_params)(const u_char *, u_int); |
| 349 | } snmp3_securitymodel[] = { |
| 350 | {3, "USM", snmp3_print_usmparams}, |
| 351 | {0, NULL((void *)0), NULL((void *)0)} |
| 352 | }; |
| 353 | |
| 354 | /* |
| 355 | * constants for ASN.1 decoding |
| 356 | */ |
| 357 | #define OIDMUX40 40 |
| 358 | #define ASNLEN_INETADDR4 4 |
| 359 | #define ASN_SHIFT77 7 |
| 360 | #define ASN_SHIFT88 8 |
| 361 | #define ASN_BIT80x80 0x80 |
| 362 | #define ASN_LONGLEN0x80 0x80 |
| 363 | |
| 364 | #define ASN_ID_BITS0x1f 0x1f |
| 365 | #define ASN_FORM_BITS0x20 0x20 |
| 366 | #define ASN_FORM_SHIFT5 5 |
| 367 | #define ASN_CLASS_BITS0xc0 0xc0 |
| 368 | #define ASN_CLASS_SHIFT6 6 |
| 369 | |
| 370 | #define ASN_ID_EXT0x1f 0x1f /* extension ID in tag field */ |
| 371 | |
| 372 | /* |
| 373 | * truncated==1 means the packet was complete, but we don't have all of |
| 374 | * it to decode. |
| 375 | */ |
| 376 | static int truncated; |
| 377 | |
| 378 | /* |
| 379 | * This decodes the next ASN.1 object in the stream pointed to by "p" |
| 380 | * (and of real-length "len") and stores the intermediate data in the |
| 381 | * provided BE object. |
| 382 | * |
| 383 | * This returns -l if it fails (i.e., the ASN.1 stream is not valid). |
| 384 | * O/w, this returns the number of bytes parsed from "p". |
| 385 | */ |
| 386 | static int |
| 387 | asn1_parse(const u_char *p, u_int len, struct be *elem) |
| 388 | { |
| 389 | u_char form, class, id; |
| 390 | int i, hdr; |
| 391 | |
| 392 | elem->asnlen = 0; |
| 393 | elem->type = BE_ANY255; |
| 394 | if (len < 1) { |
| 395 | if (truncated) |
| 396 | printf("[|snmp]"); |
| 397 | else |
| 398 | printf("[nothing to parse]"); |
| 399 | return -1; |
| 400 | } |
| 401 | |
| 402 | /* |
| 403 | * it would be nice to use a bit field, but you can't depend on them. |
| 404 | * +---+---+---+---+---+---+---+---+ |
| 405 | * + class |frm| id | |
| 406 | * +---+---+---+---+---+---+---+---+ |
| 407 | * 7 6 5 4 3 2 1 0 |
| 408 | */ |
| 409 | id = *p & ASN_ID_BITS0x1f; /* lower 5 bits, range 00-1f */ |
| 410 | #ifdef notdef |
| 411 | form = (*p & 0xe0) >> 5; /* move upper 3 bits to lower 3 */ |
| 412 | class = form >> 1; /* bits 7&6 -> bits 1&0, range 0-3 */ |
| 413 | form &= 0x1; /* bit 5 -> bit 0, range 0-1 */ |
| 414 | #else |
| 415 | form = (u_char)(*p & ASN_FORM_BITS0x20) >> ASN_FORM_SHIFT5; |
| 416 | class = (u_char)(*p & ASN_CLASS_BITS0xc0) >> ASN_CLASS_SHIFT6; |
| 417 | #endif |
| 418 | elem->form = form; |
| 419 | elem->class = class; |
| 420 | elem->id = id; |
| 421 | if (vflag > 1) |
| 422 | printf("|%.2x", *p); |
| 423 | p++; len--; hdr = 1; |
| 424 | /* extended tag field */ |
| 425 | if (id == ASN_ID_EXT0x1f) { |
| 426 | for (id = 0; *p & ASN_BIT80x80 && len > 0; len--, hdr++, p++) { |
| 427 | if (vflag > 1) |
| 428 | printf("|%.2x", *p); |
| 429 | id = (id << 7) | (*p & ~ASN_BIT80x80); |
| 430 | } |
| 431 | if (len == 0 && *p & ASN_BIT80x80) { |
| 432 | if (truncated) |
| 433 | printf("[|snmp]"); |
| 434 | else |
| 435 | printf("[Xtagfield?]"); |
| 436 | return -1; |
| 437 | } |
| 438 | elem->id = id = (id << 7) | *p; |
| 439 | --len; |
| 440 | ++hdr; |
| 441 | ++p; |
| 442 | } |
| 443 | if (len < 1) { |
| 444 | if (truncated) |
| 445 | printf("[|snmp]"); |
| 446 | else |
| 447 | printf("[no asnlen]"); |
| 448 | return -1; |
| 449 | } |
| 450 | elem->asnlen = *p; |
| 451 | if (vflag > 1) |
| 452 | printf("|%.2x", *p); |
| 453 | p++; len--; hdr++; |
| 454 | if (elem->asnlen & ASN_BIT80x80) { |
| 455 | int noct = elem->asnlen % ASN_BIT80x80; |
| 456 | elem->asnlen = 0; |
| 457 | if (len < noct) { |
| 458 | if (truncated) |
| 459 | printf("[|snmp]"); |
| 460 | else |
| 461 | printf("[asnlen? %d<%d]", len, noct); |
| 462 | return -1; |
| 463 | } |
| 464 | for (; noct-- > 0; len--, hdr++) { |
| 465 | if (vflag > 1) |
| 466 | printf("|%.2x", *p); |
| 467 | elem->asnlen = (elem->asnlen << ASN_SHIFT88) | *p++; |
| 468 | } |
| 469 | } |
| 470 | if (len < elem->asnlen) { |
| 471 | if (!truncated) { |
| 472 | printf("[len%d<asnlen%u]", len, elem->asnlen); |
| 473 | return -1; |
| 474 | } |
| 475 | /* maybe should check at least 4? */ |
| 476 | elem->asnlen = len; |
| 477 | } |
| 478 | if (form >= sizeof(Form)/sizeof(Form[0])) { |
| 479 | if (truncated) |
| 480 | printf("[|snmp]"); |
| 481 | else |
| 482 | printf("[form?%d]", form); |
| 483 | return -1; |
| 484 | } |
| 485 | if (class >= sizeof(Class)/sizeof(Class[0])) { |
| 486 | if (truncated) |
| 487 | printf("[|snmp]"); |
| 488 | else |
| 489 | printf("[class?%c/%d]", *Form[form], class); |
| 490 | return -1; |
| 491 | } |
| 492 | if ((int)id >= Class[class].numIDs) { |
| 493 | if (truncated) |
| 494 | printf("[|snmp]"); |
| 495 | else |
| 496 | printf("[id?%c/%s/%d]", *Form[form], |
| 497 | Class[class].name, id); |
| 498 | return -1; |
| 499 | } |
| 500 | |
| 501 | switch (form) { |
| 502 | case PRIMITIVE0: |
| 503 | switch (class) { |
| 504 | case UNIVERSAL0: |
| 505 | switch (id) { |
| 506 | case STRING4: |
| 507 | elem->type = BE_STR6; |
| 508 | elem->data.str = p; |
| 509 | break; |
| 510 | |
| 511 | case INTEGER2: { |
| 512 | int32_t data; |
| 513 | elem->type = BE_INT4; |
| 514 | data = 0; |
| 515 | |
| 516 | if (*p & ASN_BIT80x80) /* negative */ |
| 517 | data = -1; |
| 518 | for (i = elem->asnlen; i-- > 0; p++) |
| 519 | data = (data << ASN_SHIFT88) | *p; |
| 520 | elem->data.integer = data; |
| 521 | break; |
| 522 | } |
| 523 | |
| 524 | case OBJECTID6: |
| 525 | elem->type = BE_OID3; |
| 526 | elem->data.raw = (caddr_t)p; |
| 527 | break; |
| 528 | |
| 529 | case ASN_NULL5: |
| 530 | elem->type = BE_NULL1; |
| 531 | elem->data.raw = NULL((void *)0); |
| 532 | break; |
| 533 | |
| 534 | default: |
| 535 | elem->type = BE_OCTET2; |
| 536 | elem->data.raw = (caddr_t)p; |
| 537 | printf("[P/U/%s]", |
| 538 | Class[class].Id[id]); |
| 539 | break; |
| 540 | } |
| 541 | break; |
| 542 | |
| 543 | case APPLICATION1: |
| 544 | switch (id) { |
| 545 | case IPADDR0: |
| 546 | elem->type = BE_INETADDR8; |
| 547 | elem->data.raw = (caddr_t)p; |
| 548 | break; |
| 549 | |
| 550 | case COUNTER1: |
| 551 | case GAUGE2: |
| 552 | case TIMETICKS3: |
| 553 | case OPAQUE4: |
| 554 | case NSAPADDR5: |
| 555 | case UINTEGER327: { |
| 556 | u_int32_t data; |
| 557 | elem->type = BE_UNS5; |
| 558 | data = 0; |
| 559 | for (i = elem->asnlen; i-- > 0; p++) |
| 560 | data = (data << 8) + *p; |
| 561 | elem->data.uns = data; |
| 562 | break; |
| 563 | } |
| 564 | |
| 565 | case COUNTER646: { |
| 566 | u_int64_t data; |
| 567 | elem->type = BE_UNS6410; |
| 568 | data = 0; |
| 569 | for (i = elem->asnlen; i-- > 0; p++) |
| 570 | data = (data << 8) + *p; |
| 571 | elem->data.uns64 = data; |
| 572 | break; |
| 573 | } |
| 574 | |
| 575 | default: |
| 576 | elem->type = BE_OCTET2; |
| 577 | elem->data.raw = (caddr_t)p; |
| 578 | printf("[P/A/%s]", |
| 579 | Class[class].Id[id]); |
| 580 | break; |
| 581 | } |
| 582 | break; |
| 583 | |
| 584 | case CONTEXT2: |
| 585 | switch (id) { |
| 586 | case NOSUCHOBJECT0: |
| 587 | case NOSUCHINSTANCE1: |
| 588 | case ENDOFMIBVIEW2: |
| 589 | elem->type = BE_VB11; |
| 590 | elem->data.raw = NULL((void *)0); |
| 591 | break; |
| 592 | default: |
| 593 | elem->type = BE_OCTET2; |
| 594 | elem->data.raw = (caddr_t)p; |
| 595 | printf("[P/C/%d]", id); |
| 596 | break; |
| 597 | } |
| 598 | break; |
| 599 | |
| 600 | default: |
| 601 | elem->type = BE_OCTET2; |
| 602 | elem->data.raw = (caddr_t)p; |
| 603 | printf("[P/%s/%s]", |
| 604 | Class[class].name, Class[class].Id[id]); |
| 605 | break; |
| 606 | } |
| 607 | break; |
| 608 | |
| 609 | case CONSTRUCTED1: |
| 610 | switch (class) { |
| 611 | case UNIVERSAL0: |
| 612 | switch (id) { |
| 613 | case SEQUENCE16: |
| 614 | elem->type = BE_SEQ7; |
| 615 | elem->data.raw = (caddr_t)p; |
| 616 | break; |
| 617 | |
| 618 | default: |
| 619 | elem->type = BE_OCTET2; |
| 620 | elem->data.raw = (caddr_t)p; |
| 621 | printf("C/U/%s", Class[class].Id[id]); |
| 622 | break; |
| 623 | } |
| 624 | break; |
| 625 | |
| 626 | case CONTEXT2: |
| 627 | elem->type = BE_PDU9; |
| 628 | elem->data.raw = (caddr_t)p; |
| 629 | break; |
| 630 | |
| 631 | default: |
| 632 | elem->type = BE_OCTET2; |
| 633 | elem->data.raw = (caddr_t)p; |
| 634 | printf("C/%s/%s", |
| 635 | Class[class].name, Class[class].Id[id]); |
| 636 | break; |
| 637 | } |
| 638 | break; |
| 639 | } |
| 640 | p += elem->asnlen; |
Value stored to 'p' is never read | |
| 641 | len -= elem->asnlen; |
| 642 | return elem->asnlen + hdr; |
| 643 | } |
| 644 | |
| 645 | /* |
| 646 | * Display the ASN.1 object represented by the BE object. |
| 647 | * This used to be an integral part of asn1_parse() before the intermediate |
| 648 | * BE form was added. |
| 649 | */ |
| 650 | static void |
| 651 | asn1_print(struct be *elem) |
| 652 | { |
| 653 | u_char *p = (u_char *)elem->data.raw; |
| 654 | u_int32_t asnlen = elem->asnlen; |
| 655 | int i; |
| 656 | |
| 657 | switch (elem->type) { |
| 658 | case BE_OCTET2: |
| 659 | for (i = asnlen; i-- > 0; p++) |
| 660 | printf("_%.2x", *p); |
| 661 | break; |
| 662 | case BE_NULL1: |
| 663 | break; |
| 664 | case BE_OID3: { |
| 665 | int o = 0, first = -1, i = asnlen; |
| 666 | |
| 667 | if (!nflag && asnlen > 2) { |
| 668 | struct obj_abrev *a = &obj_abrev_list[0]; |
| 669 | for (; a->node; a++) { |
| 670 | if (!memcmp(a->oid, (char *)p, |
| 671 | strlen(a->oid))) { |
| 672 | objp = a->node->child; |
| 673 | i -= strlen(a->oid); |
| 674 | p += strlen(a->oid); |
| 675 | printf("%s", a->prefix); |
| 676 | first = 1; |
| 677 | break; |
| 678 | } |
| 679 | } |
| 680 | } |
| 681 | for (; i-- > 0; p++) { |
| 682 | o = (o << ASN_SHIFT77) + (*p & ~ASN_BIT80x80); |
| 683 | if (*p & ASN_LONGLEN0x80) |
| 684 | continue; |
| 685 | |
| 686 | /* |
| 687 | * first subitem encodes two items with 1st*OIDMUX+2nd |
| 688 | */ |
| 689 | if (first < 0) { |
| 690 | if (!nflag) |
| 691 | objp = mibroot; |
| 692 | first = 0; |
| 693 | OBJ_PRINT(o/OIDMUX, first){ if (objp) { do { if ((o/40) == objp->oid) break; } while ((objp = objp->next) != ((void *)0)); } if (objp) { printf (first?"%s":".%s", objp->desc); objp = objp->child; } else printf(first?"%u":".%u", (o/40)); }; |
| 694 | o %= OIDMUX40; |
| 695 | } |
| 696 | OBJ_PRINT(o, first){ if (objp) { do { if ((o) == objp->oid) break; } while (( objp = objp->next) != ((void *)0)); } if (objp) { printf(first ?"%s":".%s", objp->desc); objp = objp->child; } else printf (first?"%u":".%u", (o)); }; |
| 697 | if (--first < 0) |
| 698 | first = 0; |
| 699 | o = 0; |
| 700 | } |
| 701 | break; |
| 702 | } |
| 703 | case BE_INT4: |
| 704 | printf("%d", elem->data.integer); |
| 705 | break; |
| 706 | case BE_UNS5: |
| 707 | printf("%d", elem->data.uns); |
| 708 | break; |
| 709 | case BE_UNS6410: |
| 710 | printf("%lld", elem->data.uns64); |
| 711 | break; |
| 712 | case BE_STR6: { |
| 713 | int printable = 1, first = 1; |
| 714 | const u_char *p = elem->data.str; |
| 715 | for (i = asnlen; printable && i-- > 0; p++) |
| 716 | printable = isprint(*p) || isspace(*p); |
| 717 | p = elem->data.str; |
| 718 | if (printable) { |
| 719 | putchar('"')(!__isthreaded ? __sputc('"', (&__sF[1])) : (putc)('"', ( &__sF[1]))); |
| 720 | (void)fn_print(p, p + asnlen); |
| 721 | putchar('"')(!__isthreaded ? __sputc('"', (&__sF[1])) : (putc)('"', ( &__sF[1]))); |
| 722 | } else |
| 723 | for (i = asnlen; i-- > 0; p++) { |
| 724 | printf(first ? "%.2x" : "_%.2x", *p); |
| 725 | first = 0; |
| 726 | } |
| 727 | break; |
| 728 | } |
| 729 | case BE_SEQ7: |
| 730 | printf("Seq(%u)", elem->asnlen); |
| 731 | break; |
| 732 | case BE_INETADDR8: { |
| 733 | char sep; |
| 734 | if (asnlen != ASNLEN_INETADDR4) |
| 735 | printf("[inetaddr len!=%d]", ASNLEN_INETADDR4); |
| 736 | sep='['; |
| 737 | for (i = asnlen; i-- > 0; p++) { |
| 738 | printf("%c%u", sep, *p); |
| 739 | sep='.'; |
| 740 | } |
| 741 | putchar(']')(!__isthreaded ? __sputc(']', (&__sF[1])) : (putc)(']', ( &__sF[1]))); |
| 742 | break; |
| 743 | } |
| 744 | case BE_PDU9: |
| 745 | printf("%s(%u)", |
| 746 | Class[CONTEXT2].Id[elem->id], elem->asnlen); |
| 747 | break; |
| 748 | case BE_VB11: |
| 749 | if (elem->id > sizeof(ContextVarbind)/sizeof(ContextVarbind[0])) |
| 750 | break; |
| 751 | printf("%s", ContextVarbind[elem->id]); |
| 752 | break; |
| 753 | case BE_ANY255: |
| 754 | printf("[BE_ANY!?]"); |
| 755 | break; |
| 756 | default: |
| 757 | printf("[be!?]"); |
| 758 | break; |
| 759 | } |
| 760 | } |
| 761 | |
| 762 | #ifdef notdef |
| 763 | /* |
| 764 | * This is a brute force ASN.1 printer: recurses to dump an entire structure. |
| 765 | * This will work for any ASN.1 stream, not just an SNMP PDU. |
| 766 | * |
| 767 | * By adding newlines and spaces at the correct places, this would print in |
| 768 | * Rose-Normal-Form. |
| 769 | * |
| 770 | * This is not currently used. |
| 771 | */ |
| 772 | static void |
| 773 | asn1_decode(u_char *p, u_int length) |
| 774 | { |
| 775 | struct be elem; |
| 776 | int i = 0; |
| 777 | |
| 778 | while (i >= 0 && length > 0) { |
| 779 | i = asn1_parse(p, length, &elem); |
| 780 | if (i >= 0) { |
| 781 | printf(" "); |
| 782 | asn1_print(&elem); |
| 783 | if (elem.type == BE_SEQ7 || elem.type == BE_PDU9) { |
| 784 | printf(" {"); |
| 785 | asn1_decode(elem.data.raw, elem.asnlen); |
| 786 | printf(" }"); |
| 787 | } |
| 788 | length -= i; |
| 789 | p += i; |
| 790 | } |
| 791 | } |
| 792 | } |
| 793 | #endif |
| 794 | |
| 795 | /* |
| 796 | * General SNMP header |
| 797 | * SEQUENCE { |
| 798 | * version INTEGER {version-1(0)}, |
| 799 | * community OCTET STRING, |
| 800 | * data ANY -- PDUs |
| 801 | * } |
| 802 | * PDUs for all but Trap: (see rfc1157 from page 15 on) |
| 803 | * SEQUENCE { |
| 804 | * request-id INTEGER, |
| 805 | * error-status INTEGER, |
| 806 | * error-index INTEGER, |
| 807 | * varbindlist SEQUENCE OF |
| 808 | * SEQUENCE { |
| 809 | * name ObjectName, |
| 810 | * value ObjectValue |
| 811 | * } |
| 812 | * } |
| 813 | * PDU for Trap: |
| 814 | * SEQUENCE { |
| 815 | * enterprise OBJECT IDENTIFIER, |
| 816 | * agent-addr NetworkAddress, |
| 817 | * generic-trap INTEGER, |
| 818 | * specific-trap INTEGER, |
| 819 | * time-stamp TimeTicks, |
| 820 | * varbindlist SEQUENCE OF |
| 821 | * SEQUENCE { |
| 822 | * name ObjectName, |
| 823 | * value ObjectValue |
| 824 | * } |
| 825 | * } |
| 826 | */ |
| 827 | |
| 828 | /* |
| 829 | * Decode SNMP varBind |
| 830 | */ |
| 831 | static void |
| 832 | varbind_print(u_char pduid, const u_char *np, u_int length, int error) |
| 833 | { |
| 834 | struct be elem; |
| 835 | int count = 0, ind; |
| 836 | |
| 837 | /* Sequence of varBind */ |
| 838 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 839 | return; |
| 840 | if (elem.type != BE_SEQ7) { |
| 841 | printf("[!SEQ of varbind]"); |
| 842 | asn1_print(&elem); |
| 843 | return; |
| 844 | } |
| 845 | if (count < length) |
| 846 | printf("[%d extra after SEQ of varbind]", length - count); |
| 847 | /* descend */ |
| 848 | length = elem.asnlen; |
| 849 | np = (u_char *)elem.data.raw; |
| 850 | |
| 851 | for (ind = 1; length > 0; ind++) { |
| 852 | const u_char *vbend; |
| 853 | u_int vblength; |
| 854 | |
| 855 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 856 | /* Sequence */ |
| 857 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 858 | return; |
| 859 | if (elem.type != BE_SEQ7) { |
| 860 | printf("[!varbind]"); |
| 861 | asn1_print(&elem); |
| 862 | return; |
| 863 | } |
| 864 | vbend = np + count; |
| 865 | vblength = length - count; |
| 866 | /* descend */ |
| 867 | length = elem.asnlen; |
| 868 | np = (u_char *)elem.data.raw; |
| 869 | |
| 870 | /* objName (OID) */ |
| 871 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 872 | return; |
| 873 | if (elem.type != BE_OID3) { |
| 874 | printf("[objName!=OID]"); |
| 875 | asn1_print(&elem); |
| 876 | return; |
| 877 | } |
| 878 | if (!error || ind == error) |
| 879 | asn1_print(&elem); |
| 880 | length -= count; |
| 881 | np += count; |
| 882 | |
| 883 | if (pduid != GETREQ0 && pduid != GETNEXTREQ1 && !error) |
| 884 | printf("="); |
| 885 | |
| 886 | /* objVal (ANY) */ |
| 887 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 888 | return; |
| 889 | if (pduid == GETREQ0 || pduid == GETNEXTREQ1 || pduid == GETBULKREQ5) { |
| 890 | if (elem.type != BE_NULL1) { |
| 891 | printf("[objVal!=NULL]"); |
| 892 | asn1_print(&elem); |
| 893 | } |
| 894 | } else { |
| 895 | if (error && ind == error && elem.type != BE_NULL1) |
| 896 | printf("[err objVal!=NULL]"); |
| 897 | if (!error || ind == error) |
| 898 | asn1_print(&elem); |
| 899 | } |
| 900 | |
| 901 | length = vblength; |
| 902 | np = vbend; |
| 903 | } |
| 904 | } |
| 905 | |
| 906 | /* |
| 907 | * Decode SNMP PDUs: GetRequest, GetNextRequest, GetResponse, and SetRequest |
| 908 | */ |
| 909 | static void |
| 910 | snmppdu_print(u_char pduid, const u_char *np, u_int length) |
| 911 | { |
| 912 | struct be elem; |
| 913 | int count = 0, error; |
| 914 | |
| 915 | /* reqId (Integer) */ |
| 916 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 917 | return; |
| 918 | if (elem.type != BE_INT4) { |
| 919 | printf("[reqId!=INT]"); |
| 920 | asn1_print(&elem); |
| 921 | return; |
| 922 | } |
| 923 | if (vflag) |
| 924 | printf(" reqId=%d", elem.data.integer); |
| 925 | length -= count; |
| 926 | np += count; |
| 927 | |
| 928 | /* errorStatus (Integer) */ |
| 929 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 930 | return; |
| 931 | if (elem.type != BE_INT4) { |
| 932 | printf("[errorStatus!=INT]"); |
| 933 | asn1_print(&elem); |
| 934 | return; |
| 935 | } |
| 936 | error = 0; |
| 937 | if ((pduid == GETREQ0 || pduid == GETNEXTREQ1) |
| 938 | && elem.data.integer != 0) { |
| 939 | char errbuf[20]; |
| 940 | printf("[errorStatus(%s)!=0]", |
| 941 | DECODE_ErrorStatus(elem.data.integer)( elem.data.integer >= 0 && elem.data.integer <= sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) ? ErrorStatus[elem .data.integer] : (snprintf(errbuf, sizeof(errbuf), "err=%u", elem .data.integer), errbuf))); |
| 942 | } else if (pduid == GETBULKREQ5) |
| 943 | printf(" non-repeaters=%d", elem.data.integer); |
| 944 | else if (elem.data.integer != 0) { |
| 945 | char errbuf[20]; |
| 946 | printf(" %s", DECODE_ErrorStatus(elem.data.integer)( elem.data.integer >= 0 && elem.data.integer <= sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) ? ErrorStatus[elem .data.integer] : (snprintf(errbuf, sizeof(errbuf), "err=%u", elem .data.integer), errbuf))); |
| 947 | error = elem.data.integer; |
| 948 | } |
| 949 | length -= count; |
| 950 | np += count; |
| 951 | |
| 952 | /* errorIndex (Integer) */ |
| 953 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 954 | return; |
| 955 | if (elem.type != BE_INT4) { |
| 956 | printf("[errorIndex!=INT]"); |
| 957 | asn1_print(&elem); |
| 958 | return; |
| 959 | } |
| 960 | if ((pduid == GETREQ0 || pduid == GETNEXTREQ1) |
| 961 | && elem.data.integer != 0) |
| 962 | printf("[errorIndex(%d)!=0]", elem.data.integer); |
| 963 | else if (pduid == GETBULKREQ5) |
| 964 | printf(" max-repetitions=%d", elem.data.integer); |
| 965 | else if (elem.data.integer != 0) { |
| 966 | if (!error) |
| 967 | printf("[errorIndex(%d) w/o errorStatus]", |
| 968 | elem.data.integer); |
| 969 | else { |
| 970 | printf("@%d", elem.data.integer); |
| 971 | error = elem.data.integer; |
| 972 | } |
| 973 | } else if (error) { |
| 974 | printf("[errorIndex==0]"); |
| 975 | error = 0; |
| 976 | } |
| 977 | length -= count; |
| 978 | np += count; |
| 979 | |
| 980 | varbind_print(pduid, np, length, error); |
| 981 | return; |
| 982 | } |
| 983 | |
| 984 | /* |
| 985 | * Decode SNMP Trap PDU |
| 986 | */ |
| 987 | static void |
| 988 | trap_print(const u_char *np, u_int length) |
| 989 | { |
| 990 | struct be elem; |
| 991 | int count = 0, generic; |
| 992 | |
| 993 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 994 | |
| 995 | /* enterprise (oid) */ |
| 996 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 997 | return; |
| 998 | if (elem.type != BE_OID3) { |
| 999 | printf("[enterprise!=OID]"); |
| 1000 | asn1_print(&elem); |
| 1001 | return; |
| 1002 | } |
| 1003 | asn1_print(&elem); |
| 1004 | length -= count; |
| 1005 | np += count; |
| 1006 | |
| 1007 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 1008 | |
| 1009 | /* agent-addr (inetaddr) */ |
| 1010 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1011 | return; |
| 1012 | if (elem.type != BE_INETADDR8) { |
| 1013 | printf("[agent-addr!=INETADDR]"); |
| 1014 | asn1_print(&elem); |
| 1015 | return; |
| 1016 | } |
| 1017 | asn1_print(&elem); |
| 1018 | length -= count; |
| 1019 | np += count; |
| 1020 | |
| 1021 | /* generic-trap (Integer) */ |
| 1022 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1023 | return; |
| 1024 | if (elem.type != BE_INT4) { |
| 1025 | printf("[generic-trap!=INT]"); |
| 1026 | asn1_print(&elem); |
| 1027 | return; |
| 1028 | } |
| 1029 | generic = elem.data.integer; |
| 1030 | { |
| 1031 | char buf[20]; |
| 1032 | printf(" %s", DECODE_GenericTrap(generic)( generic >= 0 && generic < sizeof(GenericTrap) /sizeof(GenericTrap[0]) ? GenericTrap[generic] : (snprintf(buf , sizeof(buf), "gt=%d", generic), buf))); |
| 1033 | } |
| 1034 | length -= count; |
| 1035 | np += count; |
| 1036 | |
| 1037 | /* specific-trap (Integer) */ |
| 1038 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1039 | return; |
| 1040 | if (elem.type != BE_INT4) { |
| 1041 | printf("[specific-trap!=INT]"); |
| 1042 | asn1_print(&elem); |
| 1043 | return; |
| 1044 | } |
| 1045 | if (generic != GT_ENTERPRISE6) { |
| 1046 | if (elem.data.integer != 0) |
| 1047 | printf("[specific-trap(%d)!=0]", elem.data.integer); |
| 1048 | } else |
| 1049 | printf(" s=%d", elem.data.integer); |
| 1050 | length -= count; |
| 1051 | np += count; |
| 1052 | |
| 1053 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 1054 | |
| 1055 | /* time-stamp (TimeTicks) */ |
| 1056 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1057 | return; |
| 1058 | if (elem.type != BE_UNS5) { /* XXX */ |
| 1059 | printf("[time-stamp!=TIMETICKS]"); |
| 1060 | asn1_print(&elem); |
| 1061 | return; |
| 1062 | } |
| 1063 | asn1_print(&elem); |
| 1064 | length -= count; |
| 1065 | np += count; |
| 1066 | |
| 1067 | varbind_print (TRAP4, np, length, 0); |
| 1068 | return; |
| 1069 | } |
| 1070 | |
| 1071 | /* |
| 1072 | * Decode SNMP header and pass on to PDU printing routines |
| 1073 | */ |
| 1074 | static void |
| 1075 | snmp12_print(const u_char *np, u_int length) |
| 1076 | { |
| 1077 | struct be elem; |
| 1078 | int count; |
| 1079 | |
| 1080 | /* Community (String) */ |
| 1081 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1082 | return; |
| 1083 | if (elem.type != BE_STR6) { |
| 1084 | printf("[comm!=STR]"); |
| 1085 | asn1_print(&elem); |
| 1086 | return; |
| 1087 | } |
| 1088 | printf("C=%.*s ", (int)elem.asnlen, elem.data.str); |
| 1089 | length -= count; |
| 1090 | np += count; |
| 1091 | |
| 1092 | /* PDU (Context) */ |
| 1093 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1094 | return; |
| 1095 | if (elem.type != BE_PDU9) { |
| 1096 | printf("[no PDU]"); |
| 1097 | return; |
| 1098 | } |
| 1099 | if (count < length) |
| 1100 | printf("[%d extra after PDU]", length - count); |
| 1101 | asn1_print(&elem); |
| 1102 | /* descend into PDU */ |
| 1103 | length = elem.asnlen; |
| 1104 | np = (u_char *)elem.data.raw; |
| 1105 | |
| 1106 | switch (elem.id) { |
| 1107 | case TRAP4: |
| 1108 | trap_print(np, length); |
| 1109 | break; |
| 1110 | case GETREQ0: |
| 1111 | case GETNEXTREQ1: |
| 1112 | case GETRESP2: |
| 1113 | case SETREQ3: |
| 1114 | case GETBULKREQ5: |
| 1115 | case INFORMREQ6: |
| 1116 | case TRAPV27: |
| 1117 | case REPORT8: |
| 1118 | snmppdu_print(elem.id, np, length); |
| 1119 | break; |
| 1120 | } |
| 1121 | return; |
| 1122 | } |
| 1123 | |
| 1124 | static int |
| 1125 | snmp3_print_usmparams(const u_char *np, u_int length) |
| 1126 | { |
| 1127 | struct be elem; |
| 1128 | int count; |
| 1129 | int i; |
| 1130 | |
| 1131 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1132 | return -1; |
| 1133 | if (elem.type != BE_SEQ7) { |
| 1134 | printf("[!usmSM SEQ]"); |
| 1135 | asn1_print(&elem); |
| 1136 | return -1; |
| 1137 | } |
| 1138 | if (count < length) { |
| 1139 | printf("[%d extra after usmSM]", length - count); |
| 1140 | return -1; |
| 1141 | } |
| 1142 | /* descend */ |
| 1143 | length = elem.asnlen; |
| 1144 | np = (u_char *)elem.data.raw; |
| 1145 | |
| 1146 | /* msgAuthoritativeEngineID */ |
| 1147 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1148 | return -1; |
| 1149 | if (elem.type != BE_STR6) { |
| 1150 | printf("[umsEID!=STR]"); |
| 1151 | asn1_print(&elem); |
| 1152 | return -1; |
| 1153 | } |
| 1154 | if (vflag && elem.asnlen > 0) { |
| 1155 | printf("umsEID=0x"); |
| 1156 | for (i = 0; i < elem.asnlen; i++) |
| 1157 | printf("%02hhX", elem.data.str[i]); |
| 1158 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 1159 | } |
| 1160 | length -= count; |
| 1161 | np += count; |
| 1162 | |
| 1163 | /* msgAuthoritativeEngineBoots */ |
| 1164 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1165 | return -1; |
| 1166 | if (elem.type != BE_INT4) { |
| 1167 | printf("[EBoots!=INT]"); |
| 1168 | asn1_print(&elem); |
| 1169 | return -1; |
| 1170 | } |
| 1171 | if (vflag) |
| 1172 | printf("EBoots=%d ", elem.data.integer); |
| 1173 | length -= count; |
| 1174 | np += count; |
| 1175 | |
| 1176 | /* msgAuthoritativeEngineTime */ |
| 1177 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1178 | return -1; |
| 1179 | if (elem.type != BE_INT4) { |
| 1180 | printf("[ETime!=INT]"); |
| 1181 | asn1_print(&elem); |
| 1182 | return -1; |
| 1183 | } |
| 1184 | if (vflag) |
| 1185 | printf("ETime=%d ", elem.data.integer); |
| 1186 | length -= count; |
| 1187 | np += count; |
| 1188 | |
| 1189 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1190 | return -1; |
| 1191 | if (elem.type != BE_STR6) { |
| 1192 | printf("[User!=STR]"); |
| 1193 | asn1_print(&elem); |
| 1194 | return -1; |
| 1195 | } |
| 1196 | if (elem.asnlen > 0) { |
| 1197 | printf("User="); |
| 1198 | asn1_print(&elem); |
| 1199 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 1200 | } |
| 1201 | length -= count; |
| 1202 | np += count; |
| 1203 | |
| 1204 | /* msgAuthenticationParameters */ |
| 1205 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1206 | return -1; |
| 1207 | if (elem.type != BE_STR6) { |
| 1208 | printf("[AuthParam!=STR]"); |
| 1209 | asn1_print(&elem); |
| 1210 | return -1; |
| 1211 | } |
| 1212 | /* Can't validate msgAuthenticationParameters without pass */ |
| 1213 | length -= count; |
| 1214 | np += count; |
| 1215 | |
| 1216 | /* msgPrivacyParameters */ |
| 1217 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1218 | return -1; |
| 1219 | if (elem.type != BE_STR6) { |
| 1220 | printf("[PrivParam!=STR]"); |
| 1221 | asn1_print(&elem); |
| 1222 | return -1; |
| 1223 | } |
| 1224 | /* Salt is not useful if we can't decrypt */ |
| 1225 | if (length - count != 0) { |
| 1226 | printf("[%d extra after usmSM]", length - count); |
| 1227 | return -1; |
| 1228 | } |
| 1229 | return 0; |
| 1230 | } |
| 1231 | |
| 1232 | static void |
| 1233 | snmp3_print(const u_char *np, u_int length) |
| 1234 | { |
| 1235 | struct be elem; |
| 1236 | struct snmp3_sm *sm = NULL((void *)0); |
| 1237 | int count; |
| 1238 | int sublen; |
| 1239 | int i; |
| 1240 | int authpriv; |
| 1241 | u_char *subnp; |
| 1242 | |
| 1243 | /* Header sequence */ |
| 1244 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1245 | return; |
| 1246 | if (elem.type != BE_SEQ7) { |
| 1247 | printf("[!header SEQ]"); |
| 1248 | asn1_print(&elem); |
| 1249 | return; |
| 1250 | } |
| 1251 | np += count; |
| 1252 | length -= count; |
| 1253 | /* descend */ |
| 1254 | /* msgID */ |
| 1255 | sublen = elem.asnlen; |
| 1256 | subnp = (u_char *)elem.data.raw; |
| 1257 | if ((count = asn1_parse(subnp, sublen, &elem)) < 0) |
| 1258 | return; |
| 1259 | if (elem.type != BE_INT4) { |
| 1260 | printf("[msgID!=INT]"); |
| 1261 | asn1_print(&elem); |
| 1262 | return; |
| 1263 | } |
| 1264 | if (vflag) |
| 1265 | printf("msgID=%d ", elem.data.integer); |
| 1266 | sublen -= count; |
| 1267 | subnp += count; |
| 1268 | |
| 1269 | /* msgMaxSize */ |
| 1270 | if ((count = asn1_parse(subnp, sublen, &elem)) < 0) |
| 1271 | return; |
| 1272 | if (elem.type != BE_INT4) { |
| 1273 | printf("[msgMS!=INT]"); |
| 1274 | asn1_print(&elem); |
| 1275 | return; |
| 1276 | } |
| 1277 | if (vflag) |
| 1278 | printf("msgMS=%d ", elem.data.integer); |
| 1279 | sublen -= count; |
| 1280 | subnp += count; |
| 1281 | |
| 1282 | /* msgFlags */ |
| 1283 | if ((count = asn1_parse(subnp, sublen, &elem)) < 0) |
| 1284 | return; |
| 1285 | if (elem.type != BE_STR6) { |
| 1286 | printf("[msgFl!=STR]"); |
| 1287 | asn1_print(&elem); |
| 1288 | return; |
| 1289 | } |
| 1290 | if (elem.asnlen != 1) |
| 1291 | printf("[%d extra after msgFl]", elem.asnlen - 1); |
| 1292 | authpriv = *elem.data.str & 0x3; |
| 1293 | if (vflag && (*elem.data.str & 0x7) != 0) { |
| 1294 | printf("(%suth%sPriv%s) ", |
| 1295 | SNMP3_AUTH(*elem.data.str)(*elem.data.str & 0x01) ? "a" : "noA", |
| 1296 | SNMP3_PRIV(*elem.data.str)(*elem.data.str & 0x02) ? "" : "No", |
| 1297 | SNMP3_REPORT(*elem.data.str)(*elem.data.str & 0x04) ? "|Reportable" : "" |
| 1298 | ); |
| 1299 | } |
| 1300 | sublen -= count; |
| 1301 | subnp += count; |
| 1302 | |
| 1303 | /* msgSecurityModel */ |
| 1304 | if ((count = asn1_parse(subnp, sublen, &elem)) < 0) |
| 1305 | return; |
| 1306 | if (elem.type != BE_INT4) { |
| 1307 | printf("[msgSM!=INT]"); |
| 1308 | asn1_print(&elem); |
| 1309 | return; |
| 1310 | } |
| 1311 | for (i = 0; snmp3_securitymodel[i].id != 0; i++) { |
| 1312 | if (snmp3_securitymodel[i].id == elem.data.integer) { |
| 1313 | sm = &(snmp3_securitymodel[i]); |
| 1314 | break; |
| 1315 | } |
| 1316 | } |
| 1317 | if (vflag) { |
| 1318 | if (sm != NULL((void *)0) && nflag == 0) |
| 1319 | printf("msgSM=%s ", sm->name); |
| 1320 | else |
| 1321 | printf("msgSM=%d ", elem.data.integer); |
| 1322 | } |
| 1323 | if (sublen - count != 0) { |
| 1324 | printf("[%d extra after header]", sublen - count); |
| 1325 | return; |
| 1326 | } |
| 1327 | |
| 1328 | /* ascend */ |
| 1329 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1330 | return; |
| 1331 | if (elem.type != BE_STR6) { |
| 1332 | printf("msgSP!=STR]"); |
| 1333 | asn1_print(&elem); |
| 1334 | return; |
| 1335 | } |
| 1336 | if (sm != NULL((void *)0) && sm->parse_params != NULL((void *)0)) { |
| 1337 | if (sm->parse_params(elem.data.raw, elem.asnlen) == -1) |
| 1338 | return; |
| 1339 | } |
| 1340 | length -= count; |
| 1341 | np += count; |
| 1342 | |
| 1343 | if (SNMP3_PRIV(authpriv)(authpriv & 0x02) != 0) { |
| 1344 | printf("[encrypted PDU]"); |
| 1345 | return; |
| 1346 | } |
| 1347 | |
| 1348 | /* msgData */ |
| 1349 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1350 | return; |
| 1351 | if (elem.type != BE_SEQ7) { |
| 1352 | printf("[ScPDU!=SEQ]"); |
| 1353 | asn1_print(&elem); |
| 1354 | return; |
| 1355 | } |
| 1356 | if (count < length) |
| 1357 | printf("[%d extra after ScPDU]", length - count); |
| 1358 | /* descend */ |
| 1359 | length = elem.asnlen; |
| 1360 | np = (u_char *)elem.data.raw; |
| 1361 | |
| 1362 | /* contextEngineID */ |
| 1363 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1364 | return; |
| 1365 | if (elem.type != BE_STR6) { |
| 1366 | printf("ctxEID!=STR]"); |
| 1367 | asn1_print(&elem); |
| 1368 | return; |
| 1369 | } |
| 1370 | if (vflag && elem.asnlen > 0) { |
| 1371 | printf("ctxEID=0x"); |
| 1372 | for (i = 0; i < elem.asnlen; i++) |
| 1373 | printf("%02hhX", elem.data.str[i]); |
| 1374 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 1375 | } |
| 1376 | length -= count; |
| 1377 | np += count; |
| 1378 | |
| 1379 | /* contextName */ |
| 1380 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1381 | return; |
| 1382 | if (elem.type != BE_STR6) { |
| 1383 | printf("[ctxEName!=STR]"); |
| 1384 | asn1_print(&elem); |
| 1385 | return; |
| 1386 | } |
| 1387 | if (vflag && elem.asnlen > 0) { |
| 1388 | printf("ctxName="); |
| 1389 | asn1_print(&elem); |
| 1390 | putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
| 1391 | } |
| 1392 | length -= count; |
| 1393 | np += count; |
| 1394 | |
| 1395 | /* Data */ |
| 1396 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1397 | return; |
| 1398 | if (elem.type != BE_PDU9) { |
| 1399 | printf("[data!=PDU]"); |
| 1400 | asn1_print(&elem); |
| 1401 | return; |
| 1402 | } |
| 1403 | if (count < length) |
| 1404 | printf("[%d extra after PDU]", length - count); |
| 1405 | asn1_print(&elem); |
| 1406 | /* descend into PDU */ |
| 1407 | length = elem.asnlen; |
| 1408 | np = (u_char *)elem.data.raw; |
| 1409 | switch (elem.id) { |
| 1410 | case TRAP4: |
| 1411 | trap_print(np, length); |
| 1412 | break; |
| 1413 | case GETREQ0: |
| 1414 | case GETNEXTREQ1: |
| 1415 | case GETRESP2: |
| 1416 | case SETREQ3: |
| 1417 | case GETBULKREQ5: |
| 1418 | case INFORMREQ6: |
| 1419 | case TRAPV27: |
| 1420 | case REPORT8: |
| 1421 | snmppdu_print(elem.id, np, length); |
| 1422 | break; |
| 1423 | } |
| 1424 | } |
| 1425 | |
| 1426 | void |
| 1427 | snmp_print(const u_char *np, u_int length) |
| 1428 | { |
| 1429 | struct be elem; |
| 1430 | int count = 0; |
| 1431 | |
| 1432 | truncated = 0; |
| 1433 | |
| 1434 | /* truncated packet? */ |
| 1435 | if (np + length > snapend) { |
| 1436 | truncated = 1; |
| 1437 | length = snapend - np; |
| 1438 | } |
| 1439 | |
| 1440 | /* initial Sequence */ |
| 1441 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1442 | return; |
| 1443 | if (elem.type != BE_SEQ7) { |
| 1444 | printf("[!init SEQ]"); |
| 1445 | asn1_print(&elem); |
| 1446 | return; |
| 1447 | } |
| 1448 | if (count < length) |
| 1449 | printf("[%d extra after iSEQ]", length - count); |
| 1450 | /* descend */ |
| 1451 | length = elem.asnlen; |
| 1452 | np = (u_char *)elem.data.raw; |
| 1453 | /* Version (Integer) */ |
| 1454 | if ((count = asn1_parse(np, length, &elem)) < 0) |
| 1455 | return; |
| 1456 | if (elem.type != BE_INT4) { |
| 1457 | printf("[version!=INT]"); |
| 1458 | asn1_print(&elem); |
| 1459 | return; |
| 1460 | } |
| 1461 | length -= count; |
| 1462 | np += count; |
| 1463 | switch (elem.data.integer) { |
| 1464 | case SNMP_V1: |
| 1465 | case SNMP_V2C: |
| 1466 | if (vflag) |
| 1467 | printf("SNMPv%s ", elem.data.integer == SNMP_V1 ? |
| 1468 | "1" : "2c"); |
| 1469 | snmp12_print(np, length); |
| 1470 | return; |
| 1471 | case SNMP_V3: |
| 1472 | if (vflag) |
| 1473 | printf("SNMPv3 "); |
| 1474 | snmp3_print(np, length); |
| 1475 | return; |
| 1476 | default: |
| 1477 | printf("[snmp version(%d)]", elem.data.integer); |
| 1478 | return; |
| 1479 | } |
| 1480 | } |