X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/a03ba28e199692fa339e17f73cbd94a07d2d09de..refs/pull/494/head:/print-snmp.c diff --git a/print-snmp.c b/print-snmp.c index 60ba4d22..a2aa0742 100644 --- a/print-snmp.c +++ b/print-snmp.c @@ -56,34 +56,30 @@ # @(#)snmp.awk.x 1.1 (LANL) 1/15/90 */ -#ifndef lint -static const char rcsid[] _U_ = - "@(#) $Header: /tcpdump/master/tcpdump/print-snmp.c,v 1.63 2005-04-18 00:07:31 guy Exp $ (LBL)"; -#endif - #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include +#include #include #include -#ifdef HAVE_SMI_H +#ifdef USE_LIBSMI #include #endif -#include "interface.h" -#include "addrtoname.h" +#include "netdissect.h" #undef OPAQUE /* defined in */ +static const char tstr[] = "[|snmp]"; + /* * Universal ASN.1 types * (we only care about the tag values for those allowed in the Internet SMI) */ -const char *Universal[] = { +static const char *Universal[] = { "U-0", "Boolean", "Integer", @@ -106,7 +102,7 @@ const char *Universal[] = { /* * Application-wide ASN.1 types from the Internet SMI and their tags */ -const char *Application[] = { +static const char *Application[] = { "IpAddress", #define IPADDR 0 "Counter", @@ -125,7 +121,7 @@ const char *Application[] = { /* * Context-specific ASN.1 types for the SNMP PDUs and their tags */ -const char *Context[] = { +static const char *Context[] = { "GetRequest", #define GETREQ 0 "GetNextRequest", @@ -155,7 +151,7 @@ const char *Context[] = { /* * Context-specific ASN.1 types for the SNMP Exceptions and their tags */ -const char *Exceptions[] = { +static const char *Exceptions[] = { "noSuchObject", #define NOSUCHOBJECT 0 "noSuchInstance", @@ -168,14 +164,14 @@ const char *Exceptions[] = { * Private ASN.1 types * The Internet SMI does not specify any */ -const char *Private[] = { +static const char *Private[] = { "P-0" }; /* * error-status values for any SNMP PDU */ -const char *ErrorStatus[] = { +static const char *ErrorStatus[] = { "noError", "tooBig", "noSuchName", @@ -204,7 +200,7 @@ const char *ErrorStatus[] = { /* * generic-trap values in the SNMP Trap-PDU */ -const char *GenericTrap[] = { +static const char *GenericTrap[] = { "coldStart", "warmStart", "linkDown", @@ -225,7 +221,7 @@ const char *GenericTrap[] = { * type definitions. */ #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */ -struct { +static const struct { const char *name; const char **Id; int numIDs; @@ -245,7 +241,7 @@ struct { /* * defined forms for ASN.1 types */ -const char *Form[] = { +static const char *Form[] = { "Primitive", #define PRIMITIVE 0 "Constructed", @@ -278,7 +274,7 @@ struct obj { * Currently, this includes the prefixes for the Internet MIB, the * private enterprises tree, and the experimental tree. */ -struct obj_abrev { +static const struct obj_abrev { const char *prefix; /* prefix for this abrev */ struct obj *node; /* pointer into object table */ const char *oid; /* ASN.1 encoded OID */ @@ -315,10 +311,10 @@ struct obj_abrev { } while ((objp = objp->next) != NULL); \ } \ if (objp) { \ - printf(suppressdot?"%s":".%s", objp->desc); \ + ND_PRINT((ndo, suppressdot?"%s":".%s", objp->desc)); \ objp = objp->child; \ } else \ - printf(suppressdot?"%u":".%u", (o)); \ + ND_PRINT((ndo, suppressdot?"%u":".%u", (o))); \ } /* @@ -326,15 +322,15 @@ struct obj_abrev { * temporary internal representation while decoding an ASN.1 data stream. */ struct be { - u_int32_t asnlen; + uint32_t asnlen; union { - caddr_t raw; + const uint8_t *raw; int32_t integer; - u_int32_t uns; + uint32_t uns; const u_char *str; struct { - u_int32_t high; - u_int32_t low; + uint32_t high; + uint32_t low; } uns64; } data; u_short id; @@ -360,7 +356,7 @@ struct be { /* * SNMP versions recognized by this module */ -const char *SnmpVersion[] = { +static const char *SnmpVersion[] = { "SNMPv1", #define SNMP_VERSION_1 0 "SNMPv2c", @@ -403,7 +399,8 @@ const char *SnmpVersion[] = { * O/w, this returns the number of bytes parsed from "p". */ static int -asn1_parse(register const u_char *p, u_int len, struct be *elem) +asn1_parse(netdissect_options *ndo, + register const u_char *p, u_int len, struct be *elem) { u_char form, class, id; int i, hdr; @@ -411,10 +408,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) elem->asnlen = 0; elem->type = BE_ANY; if (len < 1) { - fputs("[nothing to parse]", stdout); + ND_PRINT((ndo, "[nothing to parse]")); return -1; } - TCHECK(*p); + ND_TCHECK(*p); /* * it would be nice to use a bit field, but you can't depend on them. @@ -450,54 +447,54 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) */ for (id = 0; *p & ASN_BIT8; len--, hdr++, p++) { if (len < 1) { - fputs("[Xtagfield?]", stdout); + ND_PRINT((ndo, "[Xtagfield?]")); return -1; } - TCHECK(*p); + ND_TCHECK(*p); id = (id << 7) | (*p & ~ASN_BIT8); } if (len < 1) { - fputs("[Xtagfield?]", stdout); + ND_PRINT((ndo, "[Xtagfield?]")); return -1; } - TCHECK(*p); + ND_TCHECK(*p); elem->id = id = (id << 7) | *p; --len; ++hdr; ++p; } if (len < 1) { - fputs("[no asnlen]", stdout); + ND_PRINT((ndo, "[no asnlen]")); return -1; } - TCHECK(*p); + ND_TCHECK(*p); elem->asnlen = *p; p++; len--; hdr++; if (elem->asnlen & ASN_BIT8) { - u_int32_t noct = elem->asnlen % ASN_BIT8; + uint32_t noct = elem->asnlen % ASN_BIT8; elem->asnlen = 0; if (len < noct) { - printf("[asnlen? %d<%d]", len, noct); + ND_PRINT((ndo, "[asnlen? %d<%d]", len, noct)); return -1; } - TCHECK2(*p, noct); + ND_TCHECK2(*p, noct); for (; noct-- > 0; len--, hdr++) elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++; } if (len < elem->asnlen) { - printf("[len%dasnlen); + ND_PRINT((ndo, "[len%dasnlen)); return -1; } if (form >= sizeof(Form)/sizeof(Form[0])) { - printf("[form?%d]", form); + ND_PRINT((ndo, "[form?%d]", form)); return -1; } if (class >= sizeof(Class)/sizeof(Class[0])) { - printf("[class?%c/%d]", *Form[form], class); + ND_PRINT((ndo, "[class?%c/%d]", *Form[form], class)); return -1; } if ((int)id >= Class[class].numIDs) { - printf("[id?%c/%s/%d]", *Form[form], Class[class].name, id); + ND_PRINT((ndo, "[id?%c/%s/%d]", *Form[form], Class[class].name, id)); return -1; } @@ -516,7 +513,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) elem->type = BE_INT; data = 0; - TCHECK2(*p, elem->asnlen); + ND_TCHECK2(*p, elem->asnlen); if (*p & ASN_BIT8) /* negative */ data = -1; for (i = elem->asnlen; i-- > 0; p++) @@ -527,7 +524,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) case OBJECTID: elem->type = BE_OID; - elem->data.raw = (caddr_t)p; + elem->data.raw = (const uint8_t *)p; break; case ASN_NULL: @@ -537,9 +534,8 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) default: elem->type = BE_OCTET; - elem->data.raw = (caddr_t)p; - printf("[P/U/%s]", - Class[class].Id[id]); + elem->data.raw = (const uint8_t *)p; + ND_PRINT((ndo, "[P/U/%s]", Class[class].Id[id])); break; } break; @@ -548,14 +544,14 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) switch (id) { case IPADDR: elem->type = BE_INETADDR; - elem->data.raw = (caddr_t)p; + elem->data.raw = (const uint8_t *)p; break; case COUNTER: case GAUGE: case TIMETICKS: { - register u_int32_t data; - TCHECK2(*p, elem->asnlen); + register uint32_t data; + ND_TCHECK2(*p, elem->asnlen); elem->type = BE_UNS; data = 0; for (i = elem->asnlen; i-- > 0; p++) @@ -565,8 +561,8 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) } case COUNTER64: { - register u_int32_t high, low; - TCHECK2(*p, elem->asnlen); + register uint32_t high, low; + ND_TCHECK2(*p, elem->asnlen); elem->type = BE_UNS64; high = 0, low = 0; for (i = elem->asnlen; i-- > 0; p++) { @@ -581,9 +577,9 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) default: elem->type = BE_OCTET; - elem->data.raw = (caddr_t)p; - printf("[P/A/%s]", - Class[class].Id[id]); + elem->data.raw = (const uint8_t *)p; + ND_PRINT((ndo, "[P/A/%s]", + Class[class].Id[id])); break; } break; @@ -608,11 +604,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) break; default: - printf("[P/%s/%s]", - Class[class].name, Class[class].Id[id]); - TCHECK2(*p, elem->asnlen); + ND_PRINT((ndo, "[P/%s/%s]", Class[class].name, Class[class].Id[id])); + ND_TCHECK2(*p, elem->asnlen); elem->type = BE_OCTET; - elem->data.raw = (caddr_t)p; + elem->data.raw = (const uint8_t *)p; break; } break; @@ -623,27 +618,26 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) switch (id) { case SEQUENCE: elem->type = BE_SEQ; - elem->data.raw = (caddr_t)p; + elem->data.raw = (const uint8_t *)p; break; default: elem->type = BE_OCTET; - elem->data.raw = (caddr_t)p; - printf("C/U/%s", Class[class].Id[id]); + elem->data.raw = (const uint8_t *)p; + ND_PRINT((ndo, "C/U/%s", Class[class].Id[id])); break; } break; case CONTEXT: elem->type = BE_PDU; - elem->data.raw = (caddr_t)p; + elem->data.raw = (const uint8_t *)p; break; default: elem->type = BE_OCTET; - elem->data.raw = (caddr_t)p; - printf("C/%s/%s", - Class[class].name, Class[class].Id[id]); + elem->data.raw = (const uint8_t *)p; + ND_PRINT((ndo, "C/%s/%s", Class[class].name, Class[class].Id[id])); break; } break; @@ -653,7 +647,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem) return elem->asnlen + hdr; trunc: - fputs("[|snmp]", stdout); + ND_PRINT((ndo, "%s", tstr)); return -1; } @@ -663,44 +657,46 @@ trunc: * BE form was added. */ static int -asn1_print(struct be *elem) +asn1_print(netdissect_options *ndo, + struct be *elem) { - u_char *p = (u_char *)elem->data.raw; - u_int32_t asnlen = elem->asnlen; - u_int32_t i; + const u_char *p = (const u_char *)elem->data.raw; + uint32_t asnlen = elem->asnlen; + uint32_t i; switch (elem->type) { case BE_OCTET: - TCHECK2(*p, asnlen); + ND_TCHECK2(*p, asnlen); for (i = asnlen; i-- > 0; p++) - printf("_%.2x", *p); + ND_PRINT((ndo, "_%.2x", *p)); break; case BE_NULL: break; case BE_OID: { - int o = 0, first = -1, i = asnlen; + int o = 0, first = -1; - if (!sflag && !nflag && asnlen > 2) { - struct obj_abrev *a = &obj_abrev_list[0]; + i = asnlen; + if (!ndo->ndo_mflag && !ndo->ndo_nflag && asnlen > 2) { + const struct obj_abrev *a = &obj_abrev_list[0]; size_t a_len = strlen(a->oid); for (; a->node; a++) { - TCHECK2(*p, a_len); - if (memcmp(a->oid, (char *)p, a_len) == 0) { + ND_TCHECK2(*p, a_len); + if (memcmp(a->oid, p, a_len) == 0) { objp = a->node->child; i -= strlen(a->oid); p += strlen(a->oid); - fputs(a->prefix, stdout); + ND_PRINT((ndo, "%s", a->prefix)); first = 1; break; } } } - for (; !sflag && i-- > 0; p++) { - TCHECK(*p); + for (; !ndo->ndo_mflag && i-- > 0; p++) { + ND_TCHECK(*p); o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8); if (*p & ASN_LONGLEN) continue; @@ -711,7 +707,7 @@ asn1_print(struct be *elem) */ if (first < 0) { int s; - if (!nflag) + if (!ndo->ndo_nflag) objp = mibroot; first = 0; s = o / OIDMUX; @@ -728,11 +724,11 @@ asn1_print(struct be *elem) } case BE_INT: - printf("%d", elem->data.integer); + ND_PRINT((ndo, "%d", elem->data.integer)); break; case BE_UNS: - printf("%u", elem->data.uns); + ND_PRINT((ndo, "%u", elem->data.uns)); break; case BE_UNS64: { /* idea borrowed from by Marshall Rose */ @@ -740,16 +736,16 @@ asn1_print(struct be *elem) int j, carry; char *cpf, *cpl, last[6], first[30]; if (elem->data.uns64.high == 0) { - printf("%u", elem->data.uns64.low); - break; + ND_PRINT((ndo, "%u", elem->data.uns64.low)); + break; } d = elem->data.uns64.high * 4294967296.0; /* 2^32 */ if (elem->data.uns64.high <= 0x1fffff) { d += elem->data.uns64.low; #if 0 /*is looks illegal, but what is the intention?*/ - printf("%.f", d); + ND_PRINT((ndo, "%.f", d)); #else - printf("%f", d); + ND_PRINT((ndo, "%f", d)); #endif break; } @@ -773,65 +769,68 @@ asn1_print(struct be *elem) } *cpf = j + '0'; } - fputs(first, stdout); + ND_PRINT((ndo, "%s", first)); break; } case BE_STR: { register int printable = 1, first = 1; - const u_char *p = elem->data.str; - TCHECK2(*p, asnlen); + + p = elem->data.str; + ND_TCHECK2(*p, asnlen); for (i = asnlen; printable && i-- > 0; p++) - printable = isprint(*p) || isspace(*p); + printable = ND_ISPRINT(*p); p = elem->data.str; if (printable) { - putchar('"'); - (void)fn_print(p, p + asnlen); - putchar('"'); + ND_PRINT((ndo, "\"")); + if (fn_printn(ndo, p, asnlen, ndo->ndo_snapend)) { + ND_PRINT((ndo, "\"")); + goto trunc; + } + ND_PRINT((ndo, "\"")); } else for (i = asnlen; i-- > 0; p++) { - printf(first ? "%.2x" : "_%.2x", *p); + ND_PRINT((ndo, first ? "%.2x" : "_%.2x", *p)); first = 0; } break; } case BE_SEQ: - printf("Seq(%u)", elem->asnlen); + ND_PRINT((ndo, "Seq(%u)", elem->asnlen)); break; case BE_INETADDR: if (asnlen != ASNLEN_INETADDR) - printf("[inetaddr len!=%d]", ASNLEN_INETADDR); - TCHECK2(*p, asnlen); + ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR)); + ND_TCHECK2(*p, asnlen); for (i = asnlen; i-- != 0; p++) { - printf((i == asnlen-1) ? "%u" : ".%u", *p); + ND_PRINT((ndo, (i == asnlen-1) ? "%u" : ".%u", *p)); } break; case BE_NOSUCHOBJECT: case BE_NOSUCHINST: case BE_ENDOFMIBVIEW: - printf("[%s]", Class[EXCEPTIONS].Id[elem->id]); + ND_PRINT((ndo, "[%s]", Class[EXCEPTIONS].Id[elem->id])); break; case BE_PDU: - printf("%s(%u)", - Class[CONTEXT].Id[elem->id], elem->asnlen); + ND_PRINT((ndo, "%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen)); break; case BE_ANY: - fputs("[BE_ANY!?]", stdout); + ND_PRINT((ndo, "[BE_ANY!?]")); break; default: - fputs("[be!?]", stdout); + ND_PRINT((ndo, "[be!?]")); break; } return 0; trunc: - fputs("[|snmp]", stdout); + ND_PRINT((ndo, "%s", tstr)); return -1; } @@ -852,15 +851,15 @@ asn1_decode(u_char *p, u_int length) int i = 0; while (i >= 0 && length > 0) { - i = asn1_parse(p, length, &elem); + i = asn1_parse(ndo, p, length, &elem); if (i >= 0) { - fputs(" ", stdout); - if (asn1_print(&elem) < 0) + ND_PRINT((ndo, " ")); + if (asn1_print(ndo, &elem) < 0) return; if (elem.type == BE_SEQ || elem.type == BE_PDU) { - fputs(" {", stdout); + ND_PRINT((ndo, " {")); asn1_decode(elem.data.raw, elem.asnlen); - fputs(" }", stdout); + ND_PRINT((ndo, " }")); } length -= i; p += i; @@ -869,14 +868,14 @@ asn1_decode(u_char *p, u_int length) } #endif -#ifdef LIBSMI +#ifdef USE_LIBSMI struct smi2be { SmiBasetype basetype; int be; }; -static struct smi2be smi2betab[] = { +static const struct smi2be smi2betab[] = { { SMI_BASETYPE_INTEGER32, BE_INT }, { SMI_BASETYPE_OCTETSTRING, BE_STR }, { SMI_BASETYPE_OCTETSTRING, BE_INETADDR }, @@ -893,15 +892,17 @@ static struct smi2be smi2betab[] = { }; static int -smi_decode_oid(struct be *elem, unsigned int *oid, - unsigned int oidsize, unsigned int *oidlen) +smi_decode_oid(netdissect_options *ndo, + struct be *elem, unsigned int *oid, + unsigned int oidsize, unsigned int *oidlen) { - u_char *p = (u_char *)elem->data.raw; - u_int32_t asnlen = elem->asnlen; + const u_char *p = (const u_char *)elem->data.raw; + uint32_t asnlen = elem->asnlen; int o = 0, first = -1, i = asnlen; + unsigned int firstval; - for (*oidlen = 0; sflag && i-- > 0; p++) { - TCHECK(*p); + for (*oidlen = 0; ndo->ndo_mflag && i-- > 0; p++) { + ND_TCHECK(*p); o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8); if (*p & ASN_LONGLEN) continue; @@ -912,12 +913,12 @@ smi_decode_oid(struct be *elem, unsigned int *oid, */ if (first < 0) { first = 0; + firstval = o / OIDMUX; + if (firstval > 2) firstval = 2; + o -= firstval * OIDMUX; if (*oidlen < oidsize) { - oid[*oidlen] = o / OIDMUX; - if (oid[*oidlen] > 2) oid[*oidlen] = 2; + oid[(*oidlen)++] = firstval; } - o -= oid[*oidlen] * OIDMUX; - if (*oidlen < oidsize) (*oidlen)++; } if (*oidlen < oidsize) { oid[(*oidlen)++] = o; @@ -927,7 +928,7 @@ smi_decode_oid(struct be *elem, unsigned int *oid, return 0; trunc: - fputs("[|snmp]", stdout); + ND_PRINT((ndo, "%s", tstr)); return -1; } @@ -1021,29 +1022,30 @@ static int smi_check_range(SmiType *smiType, struct be *elem) return ok; } -static SmiNode *smi_print_variable(struct be *elem, int *status) +static SmiNode * +smi_print_variable(netdissect_options *ndo, + struct be *elem, int *status) { unsigned int oid[128], oidlen; SmiNode *smiNode = NULL; unsigned int i; - *status = smi_decode_oid(elem, oid, sizeof(oid)/sizeof(unsigned int), + *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int), &oidlen); if (*status < 0) return NULL; smiNode = smiGetNodeByOID(oidlen, oid); if (! smiNode) { - *status = asn1_print(elem); + *status = asn1_print(ndo, elem); return NULL; } - if (vflag) { - fputs(smiGetNodeModule(smiNode)->name, stdout); - fputs("::", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name)); } - fputs(smiNode->name, stdout); + ND_PRINT((ndo, "%s", smiNode->name)); if (smiNode->oidlen < oidlen) { - for (i = smiNode->oidlen; i < oidlen; i++) { - printf(".%u", oid[i]); + for (i = smiNode->oidlen; i < oidlen; i++) { + ND_PRINT((ndo, ".%u", oid[i])); } } *status = 0; @@ -1051,7 +1053,8 @@ static SmiNode *smi_print_variable(struct be *elem, int *status) } static int -smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem) +smi_print_value(netdissect_options *ndo, + SmiNode *smiNode, u_short pduid, struct be *elem) { unsigned int i, oid[128], oidlen; SmiType *smiType; @@ -1060,43 +1063,43 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem) if (! smiNode || ! (smiNode->nodekind & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) { - return asn1_print(elem); + return asn1_print(ndo, elem); } if (elem->type == BE_NOSUCHOBJECT || elem->type == BE_NOSUCHINST || elem->type == BE_ENDOFMIBVIEW) { - return asn1_print(elem); + return asn1_print(ndo, elem); } if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) { - fputs("[notNotifyable]", stdout); + ND_PRINT((ndo, "[notNotifyable]")); } if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) { - fputs("[notReadable]", stdout); + ND_PRINT((ndo, "[notReadable]")); } if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) { - fputs("[notWritable]", stdout); + ND_PRINT((ndo, "[notWritable]")); } if (RESPONSE_CLASS(pduid) && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) { - fputs("[noAccess]", stdout); + ND_PRINT((ndo, "[noAccess]")); } smiType = smiGetNodeType(smiNode); if (! smiType) { - return asn1_print(elem); + return asn1_print(ndo, elem); } if (! smi_check_type(smiType->basetype, elem->type)) { - fputs("[wrongType]", stdout); + ND_PRINT((ndo, "[wrongType]")); } if (! smi_check_range(smiType, elem)) { - fputs("[outOfRange]", stdout); + ND_PRINT((ndo, "[outOfRange]")); } /* resolve bits to named bits */ @@ -1112,20 +1115,19 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem) if (smiType->basetype == SMI_BASETYPE_BITS) { /* print bit labels */ } else { - smi_decode_oid(elem, oid, + smi_decode_oid(ndo, elem, oid, sizeof(oid)/sizeof(unsigned int), &oidlen); smiNode = smiGetNodeByOID(oidlen, oid); if (smiNode) { - if (vflag) { - fputs(smiGetNodeModule(smiNode)->name, stdout); - fputs("::", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name)); } - fputs(smiNode->name, stdout); + ND_PRINT((ndo, "%s", smiNode->name)); if (smiNode->oidlen < oidlen) { for (i = smiNode->oidlen; i < oidlen; i++) { - printf(".%u", oid[i]); + ND_PRINT((ndo, ".%u", oid[i])); } } done++; @@ -1140,8 +1142,8 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem) nn = smiGetNextNamedNumber(nn)) { if (nn->value.value.integer32 == elem->data.integer) { - fputs(nn->name, stdout); - printf("(%d)", elem->data.integer); + ND_PRINT((ndo, "%s", nn->name)); + ND_PRINT((ndo, "(%d)", elem->data.integer)); done++; break; } @@ -1151,7 +1153,7 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem) } if (! done) { - return asn1_print(elem); + return asn1_print(ndo, elem); } return 0; } @@ -1194,61 +1196,62 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem) * Decode SNMP varBind */ static void -varbind_print(u_char pduid, const u_char *np, u_int length) +varbind_print(netdissect_options *ndo, + u_short pduid, const u_char *np, u_int length) { struct be elem; int count = 0, ind; -#ifdef LIBSMI +#ifdef USE_LIBSMI SmiNode *smiNode = NULL; #endif int status; /* Sequence of varBind */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_SEQ) { - fputs("[!SEQ of varbind]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[!SEQ of varbind]")); + asn1_print(ndo, &elem); return; } if ((u_int)count < length) - printf("[%d extra after SEQ of varbind]", length - count); + ND_PRINT((ndo, "[%d extra after SEQ of varbind]", length - count)); /* descend */ length = elem.asnlen; - np = (u_char *)elem.data.raw; + np = (const u_char *)elem.data.raw; for (ind = 1; length > 0; ind++) { const u_char *vbend; u_int vblength; - fputs(" ", stdout); + ND_PRINT((ndo, " ")); /* Sequence */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_SEQ) { - fputs("[!varbind]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[!varbind]")); + asn1_print(ndo, &elem); return; } vbend = np + count; vblength = length - count; /* descend */ length = elem.asnlen; - np = (u_char *)elem.data.raw; + np = (const u_char *)elem.data.raw; /* objName (OID) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_OID) { - fputs("[objName!=OID]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[objName!=OID]")); + asn1_print(ndo, &elem); return; } -#ifdef LIBSMI - smiNode = smi_print_variable(&elem, &status); +#ifdef USE_LIBSMI + smiNode = smi_print_variable(ndo, &elem, &status); #else - status = asn1_print(&elem); + status = asn1_print(ndo, &elem); #endif if (status < 0) return; @@ -1257,24 +1260,24 @@ varbind_print(u_char pduid, const u_char *np, u_int length) if (pduid != GETREQ && pduid != GETNEXTREQ && pduid != GETBULKREQ) - fputs("=", stdout); + ND_PRINT((ndo, "=")); /* objVal (ANY) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (pduid == GETREQ || pduid == GETNEXTREQ || pduid == GETBULKREQ) { if (elem.type != BE_NULL) { - fputs("[objVal!=NULL]", stdout); - if (asn1_print(&elem) < 0) + ND_PRINT((ndo, "[objVal!=NULL]")); + if (asn1_print(ndo, &elem) < 0) return; } } else { if (elem.type != BE_NULL) { -#ifdef LIBSMI - status = smi_print_value(smiNode, pduid, &elem); +#ifdef USE_LIBSMI + status = smi_print_value(ndo, smiNode, pduid, &elem); #else - status = asn1_print(&elem); + status = asn1_print(ndo, &elem); #endif } if (status < 0) @@ -1290,79 +1293,76 @@ varbind_print(u_char pduid, const u_char *np, u_int length) * GetBulk, Inform, V2Trap, and Report */ static void -snmppdu_print(u_short pduid, const u_char *np, u_int length) +snmppdu_print(netdissect_options *ndo, + u_short pduid, const u_char *np, u_int length) { struct be elem; - int count = 0, error; + int count = 0, error_status; /* reqId (Integer) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[reqId!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[reqId!=INT]")); + asn1_print(ndo, &elem); return; } - if (vflag) - printf("R=%d ", elem.data.integer); + if (ndo->ndo_vflag) + ND_PRINT((ndo, "R=%d ", elem.data.integer)); length -= count; np += count; /* errorStatus (Integer) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[errorStatus!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[errorStatus!=INT]")); + asn1_print(ndo, &elem); return; } - error = 0; + error_status = 0; if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT) && elem.data.integer != 0) { char errbuf[20]; - printf("[errorStatus(%s)!=0]", - DECODE_ErrorStatus(elem.data.integer)); + ND_PRINT((ndo, "[errorStatus(%s)!=0]", + DECODE_ErrorStatus(elem.data.integer))); } else if (pduid == GETBULKREQ) { - printf(" N=%d", elem.data.integer); + ND_PRINT((ndo, " N=%d", elem.data.integer)); } else if (elem.data.integer != 0) { char errbuf[20]; - printf(" %s", DECODE_ErrorStatus(elem.data.integer)); - error = elem.data.integer; + ND_PRINT((ndo, " %s", DECODE_ErrorStatus(elem.data.integer))); + error_status = elem.data.integer; } length -= count; np += count; /* errorIndex (Integer) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[errorIndex!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[errorIndex!=INT]")); + asn1_print(ndo, &elem); return; } if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT) && elem.data.integer != 0) - printf("[errorIndex(%d)!=0]", elem.data.integer); + ND_PRINT((ndo, "[errorIndex(%d)!=0]", elem.data.integer)); else if (pduid == GETBULKREQ) - printf(" M=%d", elem.data.integer); + ND_PRINT((ndo, " M=%d", elem.data.integer)); else if (elem.data.integer != 0) { - if (!error) - printf("[errorIndex(%d) w/o errorStatus]", - elem.data.integer); - else { - printf("@%d", elem.data.integer); - error = elem.data.integer; - } - } else if (error) { - fputs("[errorIndex==0]", stdout); - error = 0; + if (!error_status) + ND_PRINT((ndo, "[errorIndex(%d) w/o errorStatus]", elem.data.integer)); + else + ND_PRINT((ndo, "@%d", elem.data.integer)); + } else if (error_status) { + ND_PRINT((ndo, "[errorIndex==0]")); } length -= count; np += count; - varbind_print(pduid, np, length); + varbind_print(ndo, pduid, np, length); return; } @@ -1370,89 +1370,90 @@ snmppdu_print(u_short pduid, const u_char *np, u_int length) * Decode SNMP Trap PDU */ static void -trappdu_print(const u_char *np, u_int length) +trappdu_print(netdissect_options *ndo, + const u_char *np, u_int length) { struct be elem; int count = 0, generic; - putchar(' '); + ND_PRINT((ndo, " ")); /* enterprise (oid) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_OID) { - fputs("[enterprise!=OID]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[enterprise!=OID]")); + asn1_print(ndo, &elem); return; } - if (asn1_print(&elem) < 0) + if (asn1_print(ndo, &elem) < 0) return; length -= count; np += count; - putchar(' '); + ND_PRINT((ndo, " ")); /* agent-addr (inetaddr) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INETADDR) { - fputs("[agent-addr!=INETADDR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[agent-addr!=INETADDR]")); + asn1_print(ndo, &elem); return; } - if (asn1_print(&elem) < 0) + if (asn1_print(ndo, &elem) < 0) return; length -= count; np += count; /* generic-trap (Integer) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[generic-trap!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[generic-trap!=INT]")); + asn1_print(ndo, &elem); return; } generic = elem.data.integer; { char buf[20]; - printf(" %s", DECODE_GenericTrap(generic)); + ND_PRINT((ndo, " %s", DECODE_GenericTrap(generic))); } length -= count; np += count; /* specific-trap (Integer) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[specific-trap!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[specific-trap!=INT]")); + asn1_print(ndo, &elem); return; } if (generic != GT_ENTERPRISE) { if (elem.data.integer != 0) - printf("[specific-trap(%d)!=0]", elem.data.integer); + ND_PRINT((ndo, "[specific-trap(%d)!=0]", elem.data.integer)); } else - printf(" s=%d", elem.data.integer); + ND_PRINT((ndo, " s=%d", elem.data.integer)); length -= count; np += count; - putchar(' '); + ND_PRINT((ndo, " ")); /* time-stamp (TimeTicks) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_UNS) { /* XXX */ - fputs("[time-stamp!=TIMETICKS]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[time-stamp!=TIMETICKS]")); + asn1_print(ndo, &elem); return; } - if (asn1_print(&elem) < 0) + if (asn1_print(ndo, &elem) < 0) return; length -= count; np += count; - varbind_print (TRAP, np, length); + varbind_print(ndo, TRAP, np, length); return; } @@ -1460,45 +1461,46 @@ trappdu_print(const u_char *np, u_int length) * Decode arbitrary SNMP PDUs. */ static void -pdu_print(const u_char *np, u_int length, int version) +pdu_print(netdissect_options *ndo, + const u_char *np, u_int length, int version) { struct be pdu; int count = 0; /* PDU (Context) */ - if ((count = asn1_parse(np, length, &pdu)) < 0) + if ((count = asn1_parse(ndo, np, length, &pdu)) < 0) return; if (pdu.type != BE_PDU) { - fputs("[no PDU]", stdout); + ND_PRINT((ndo, "[no PDU]")); return; } if ((u_int)count < length) - printf("[%d extra after PDU]", length - count); - if (vflag) { - fputs("{ ", stdout); + ND_PRINT((ndo, "[%d extra after PDU]", length - count)); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "{ ")); } - if (asn1_print(&pdu) < 0) + if (asn1_print(ndo, &pdu) < 0) return; - fputs(" ", stdout); + ND_PRINT((ndo, " ")); /* descend into PDU */ length = pdu.asnlen; - np = (u_char *)pdu.data.raw; + np = (const u_char *)pdu.data.raw; if (version == SNMP_VERSION_1 && (pdu.id == GETBULKREQ || pdu.id == INFORMREQ || pdu.id == V2TRAP || pdu.id == REPORT)) { - printf("[v2 PDU in v1 message]"); + ND_PRINT((ndo, "[v2 PDU in v1 message]")); return; } if (version == SNMP_VERSION_2 && pdu.id == TRAP) { - printf("[v1 PDU in v2 message]"); + ND_PRINT((ndo, "[v1 PDU in v2 message]")); return; } switch (pdu.id) { case TRAP: - trappdu_print(np, length); + trappdu_print(ndo, np, length); break; case GETREQ: case GETNEXTREQ: @@ -1508,12 +1510,12 @@ pdu_print(const u_char *np, u_int length, int version) case INFORMREQ: case V2TRAP: case REPORT: - snmppdu_print(pdu.id, np, length); + snmppdu_print(ndo, pdu.id, np, length); break; } - if (vflag) { - fputs(" } ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, " } ")); } } @@ -1521,185 +1523,189 @@ pdu_print(const u_char *np, u_int length, int version) * Decode a scoped SNMP PDU. */ static void -scopedpdu_print(const u_char *np, u_int length, int version) +scopedpdu_print(netdissect_options *ndo, + const u_char *np, u_int length, int version) { struct be elem; int i, count = 0; /* Sequence */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_SEQ) { - fputs("[!scoped PDU]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[!scoped PDU]")); + asn1_print(ndo, &elem); return; } length = elem.asnlen; - np = (u_char *)elem.data.raw; + np = (const u_char *)elem.data.raw; /* contextEngineID (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[contextEngineID!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[contextEngineID!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; - fputs("E= ", stdout); + ND_PRINT((ndo, "E= ")); for (i = 0; i < (int)elem.asnlen; i++) { - printf("0x%02X", elem.data.str[i]); - } - fputs(" ", stdout); + ND_PRINT((ndo, "0x%02X", elem.data.str[i])); + } + ND_PRINT((ndo, " ")); /* contextName (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[contextName!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[contextName!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; - printf("C=%.*s ", (int)elem.asnlen, elem.data.str); + ND_PRINT((ndo, "C=%.*s ", (int)elem.asnlen, elem.data.str)); - pdu_print(np, length, version); + pdu_print(ndo, np, length, version); } /* * Decode SNMP Community Header (SNMPv1 and SNMPv2c) */ static void -community_print(const u_char *np, u_int length, int version) +community_print(netdissect_options *ndo, + const u_char *np, u_int length, int version) { struct be elem; int count = 0; /* Community (String) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[comm!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[comm!=STR]")); + asn1_print(ndo, &elem); return; } /* default community */ if (!(elem.asnlen == sizeof(DEF_COMMUNITY) - 1 && - strncmp((char *)elem.data.str, DEF_COMMUNITY, + strncmp((const char *)elem.data.str, DEF_COMMUNITY, sizeof(DEF_COMMUNITY) - 1) == 0)) /* ! "public" */ - printf("C=%.*s ", (int)elem.asnlen, elem.data.str); + ND_PRINT((ndo, "C=%.*s ", (int)elem.asnlen, elem.data.str)); length -= count; np += count; - pdu_print(np, length, version); + pdu_print(ndo, np, length, version); } /* * Decode SNMPv3 User-based Security Message Header (SNMPv3) */ static void -usm_print(const u_char *np, u_int length) +usm_print(netdissect_options *ndo, + const u_char *np, u_int length) { struct be elem; int count = 0; /* Sequence */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_SEQ) { - fputs("[!usm]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[!usm]")); + asn1_print(ndo, &elem); return; } length = elem.asnlen; - np = (u_char *)elem.data.raw; + np = (const u_char *)elem.data.raw; /* msgAuthoritativeEngineID (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[msgAuthoritativeEngineID!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgAuthoritativeEngineID!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; /* msgAuthoritativeEngineBoots (INTEGER) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[msgAuthoritativeEngineBoots!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]")); + asn1_print(ndo, &elem); return; } - if (vflag) - printf("B=%d ", elem.data.integer); + if (ndo->ndo_vflag) + ND_PRINT((ndo, "B=%d ", elem.data.integer)); length -= count; np += count; /* msgAuthoritativeEngineTime (INTEGER) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[msgAuthoritativeEngineTime!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]")); + asn1_print(ndo, &elem); return; } - if (vflag) - printf("T=%d ", elem.data.integer); + if (ndo->ndo_vflag) + ND_PRINT((ndo, "T=%d ", elem.data.integer)); length -= count; np += count; /* msgUserName (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[msgUserName!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgUserName!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; - printf("U=%.*s ", (int)elem.asnlen, elem.data.str); + ND_PRINT((ndo, "U=%.*s ", (int)elem.asnlen, elem.data.str)); /* msgAuthenticationParameters (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[msgAuthenticationParameters!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgAuthenticationParameters!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; /* msgPrivacyParameters (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[msgPrivacyParameters!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgPrivacyParameters!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; if ((u_int)count < length) - printf("[%d extra after usm SEQ]", length - count); + ND_PRINT((ndo, "[%d extra after usm SEQ]", length - count)); } /* * Decode SNMPv3 Message Header (SNMPv3) */ static void -v3msg_print(const u_char *np, u_int length) +v3msg_print(netdissect_options *ndo, + const u_char *np, u_int length) { struct be elem; int count = 0; @@ -1709,75 +1715,74 @@ v3msg_print(const u_char *np, u_int length) int xlength = length; /* Sequence */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_SEQ) { - fputs("[!message]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[!message]")); + asn1_print(ndo, &elem); return; } length = elem.asnlen; - np = (u_char *)elem.data.raw; + np = (const u_char *)elem.data.raw; - if (vflag) { - fputs("{ ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "{ ")); } /* msgID (INTEGER) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[msgID!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgID!=INT]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; /* msgMaxSize (INTEGER) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[msgMaxSize!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgMaxSize!=INT]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; /* msgFlags (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[msgFlags!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgFlags!=STR]")); + asn1_print(ndo, &elem); return; } if (elem.asnlen != 1) { - printf("[msgFlags size %d]", elem.asnlen); + ND_PRINT((ndo, "[msgFlags size %d]", elem.asnlen)); return; } flags = elem.data.str[0]; if (flags != 0x00 && flags != 0x01 && flags != 0x03 && flags != 0x04 && flags != 0x05 && flags != 0x07) { - printf("[msgFlags=0x%02X]", flags); + ND_PRINT((ndo, "[msgFlags=0x%02X]", flags)); return; } length -= count; np += count; - fputs("F=", stdout); - if (flags & 0x01) fputs("a", stdout); - if (flags & 0x02) fputs("p", stdout); - if (flags & 0x04) fputs("r", stdout); - fputs(" ", stdout); + ND_PRINT((ndo, "F=%s%s%s ", + flags & 0x01 ? "a" : "", + flags & 0x02 ? "p" : "", + flags & 0x04 ? "r" : "")); /* msgSecurityModel (INTEGER) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[msgSecurityModel!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgSecurityModel!=INT]")); + asn1_print(ndo, &elem); return; } model = elem.data.integer; @@ -1785,18 +1790,18 @@ v3msg_print(const u_char *np, u_int length) np += count; if ((u_int)count < length) - printf("[%d extra after message SEQ]", length - count); + ND_PRINT((ndo, "[%d extra after message SEQ]", length - count)); - if (vflag) { - fputs("} ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "} ")); } if (model == 3) { - if (vflag) { - fputs("{ USM ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "{ USM ")); } } else { - printf("[security model %d]", model); + ND_PRINT((ndo, "[security model %d]", model)); return; } @@ -1804,31 +1809,31 @@ v3msg_print(const u_char *np, u_int length) length = xlength - (np - xnp); /* msgSecurityParameters (OCTET STRING) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_STR) { - fputs("[msgSecurityParameters!=STR]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[msgSecurityParameters!=STR]")); + asn1_print(ndo, &elem); return; } length -= count; np += count; if (model == 3) { - usm_print(elem.data.str, elem.asnlen); - if (vflag) { - fputs("} ", stdout); + usm_print(ndo, elem.data.str, elem.asnlen); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "} ")); } } - if (vflag) { - fputs("{ ScopedPDU ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "{ ScopedPDU ")); } - scopedpdu_print(np, length, 3); + scopedpdu_print(ndo, np, length, 3); - if (vflag) { - fputs("} ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "} ")); } } @@ -1836,34 +1841,35 @@ v3msg_print(const u_char *np, u_int length) * Decode SNMP header and pass on to PDU printing routines */ void -snmp_print(const u_char *np, u_int length) +snmp_print(netdissect_options *ndo, + const u_char *np, u_int length) { struct be elem; int count = 0; int version = 0; - putchar(' '); + ND_PRINT((ndo, " ")); /* initial Sequence */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_SEQ) { - fputs("[!init SEQ]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[!init SEQ]")); + asn1_print(ndo, &elem); return; } if ((u_int)count < length) - printf("[%d extra after iSEQ]", length - count); + ND_PRINT((ndo, "[%d extra after iSEQ]", length - count)); /* descend */ length = elem.asnlen; - np = (u_char *)elem.data.raw; + np = (const u_char *)elem.data.raw; /* Version (INTEGER) */ - if ((count = asn1_parse(np, length, &elem)) < 0) + if ((count = asn1_parse(ndo, np, length, &elem)) < 0) return; if (elem.type != BE_INT) { - fputs("[version!=INT]", stdout); - asn1_print(&elem); + ND_PRINT((ndo, "[version!=INT]")); + asn1_print(ndo, &elem); return; } @@ -1871,11 +1877,11 @@ snmp_print(const u_char *np, u_int length) case SNMP_VERSION_1: case SNMP_VERSION_2: case SNMP_VERSION_3: - if (vflag) - printf("{ %s ", SnmpVersion[elem.data.integer]); + if (ndo->ndo_vflag) + ND_PRINT((ndo, "{ %s ", SnmpVersion[elem.data.integer])); break; default: - printf("[version = %d]", elem.data.integer); + ND_PRINT((ndo, "[version = %d]", elem.data.integer)); return; } version = elem.data.integer; @@ -1885,17 +1891,17 @@ snmp_print(const u_char *np, u_int length) switch (version) { case SNMP_VERSION_1: case SNMP_VERSION_2: - community_print(np, length, version); + community_print(ndo, np, length, version); break; case SNMP_VERSION_3: - v3msg_print(np, length); + v3msg_print(ndo, np, length); break; default: - printf("[version = %d]", elem.data.integer); + ND_PRINT((ndo, "[version = %d]", elem.data.integer)); break; } - if (vflag) { - fputs("} ", stdout); + if (ndo->ndo_vflag) { + ND_PRINT((ndo, "} ")); } }