/*
* Print out a file name and return pointer to 32-bit word past it.
* If packet was truncated, return 0.
*/
static const u_int32_t *
parsefn(register const u_int32_t *dp)
{
register u_int32_t len;
register const u_char *cp;
/* Bail if we don't have the string length */
TCHECK(*dp);
/* Fetch string length; convert to host order */
len = *dp++;
NTOHL(len);
TCHECK2(*dp, ((len + 3) & ~3));
cp = (u_char *)dp;
/* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
dp += ((len + 3) & ~3) / sizeof(*dp);
putchar('"');
if (fn_printn(cp, len, snapend)) {
putchar('"');
goto trunc;
}
putchar('"');
return (dp);
trunc:
return NULL;
}
/*
* Print out a file name and return pointer to 32-bit word past it.
* If packet was truncated, return 0.
*/
static const uint32_t *
parsefn(netdissect_options *ndo,
register const uint32_t *dp)
{
register uint32_t len;
register const u_char *cp;
/* Bail if we don't have the string length */
ND_TCHECK(*dp);
/* Fetch string length; convert to host order */
len = *dp++;
NTOHL(len);
ND_TCHECK2(*dp, ((len + 3) & ~3));
cp = (u_char *)dp;
/* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
dp += ((len + 3) & ~3) / sizeof(*dp);
ND_PRINT((ndo, "\""));
if (fn_printn(ndo, cp, len, ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
return (dp);
trunc:
return NULL;
}
/*
* Print out a file name and return pointer to 32-bit word past it.
* If packet was truncated, return 0.
*/
static const uint32_t *
parsefn(netdissect_options *ndo,
const uint32_t *dp)
{
uint32_t len;
const u_char *cp;
/* Bail if we don't have the string length */
ND_TCHECK_4(dp);
/* Fetch big-endian string length */
len = EXTRACT_BE_U_4(dp);
dp++;
ND_TCHECK_LEN(dp, ((len + 3) & ~3));
cp = (const u_char *)dp;
/* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
dp += ((len + 3) & ~3) / sizeof(*dp);
ND_PRINT("\"");
if (fn_printn(ndo, cp, len, ndo->ndo_snapend)) {
ND_PRINT("\"");
goto trunc;
}
ND_PRINT("\"");
return (dp);
trunc:
return NULL;
}
/* print a <domain-name> */
static const u_char *
ns_nprint(register const u_char *cp, register const u_char *bp)
{
register u_int i;
register const u_char *rp;
register int compress;
i = *cp++;
rp = cp + i;
if ((i & INDIR_MASK) == INDIR_MASK) {
rp = cp + 1;
compress = 1;
} else
compress = 0;
if (i != 0)
while (i && cp < snapend) {
if ((i & INDIR_MASK) == INDIR_MASK) {
cp = bp + (((i << 8) | *cp) & 0x3fff);
i = *cp++;
continue;
}
if (fn_printn(cp, i, snapend))
break;
cp += i;
putchar('.');
i = *cp++;
if (!compress)
rp += i + 1;
}
else
putchar('.');
return (rp);
}
/* print a <character-string> */
static const u_char *
ns_cprint(register const u_char *cp, register const u_char *bp)
{
register u_int i;
i = *cp++;
(void)fn_printn(cp, i, snapend);
return (cp + i);
}
void
vrrp_print(register const u_char *bp, register u_int len, int ttl)
{
int version, type, auth_type;
const char *type_s;
TCHECK(bp[0]);
version = (bp[0] & 0xf0) >> 4;
type = bp[0] & 0x0f;
type_s = tok2str(type2str, "unknown type (%u)", type);
printf("VRRPv%u, %s", version, type_s);
if (ttl != 255)
printf(", (ttl %u)", ttl);
if (version != 2 || type != VRRP_TYPE_ADVERTISEMENT)
return;
TCHECK(bp[2]);
printf(", vrid %u, prio %u", bp[1], bp[2]);
TCHECK(bp[5]);
auth_type = bp[4];
printf(", authtype %s", tok2str(auth2str, NULL, auth_type));
printf(", intvl %us, length %u", bp[5],len);
if (vflag) {
int naddrs = bp[3];
int i;
char c;
if (TTEST2(bp[0], len) && in_cksum((const u_short*)bp, len, 0))
printf(", (bad vrrp cksum %x)",
EXTRACT_16BITS(&bp[6]));
printf(", addrs");
if (naddrs > 1)
printf("(%d)", naddrs);
printf(":");
c = ' ';
bp += 8;
for (i = 0; i < naddrs; i++) {
TCHECK(bp[3]);
printf("%c%s", c, ipaddr_string(bp));
c = ',';
bp += 4;
}
if (auth_type == VRRP_AUTH_SIMPLE) { /* simple text password */
TCHECK(bp[7]);
printf(" auth \"");
if (fn_printn(bp, 8, snapend)) {
printf("\"");
goto trunc;
}
printf("\"");
}
}
return;
trunc:
printf("[|vrrp]");
}
static void
aoev1_query_print(netdissect_options *ndo,
const u_char *cp, const u_int len)
{
const u_char *ep = cp + len;
uint16_t cslen;
if (len < AOEV1_QUERY_ARG_LEN)
goto invalid;
/* Buffer Count */
ND_TCHECK2(*cp, 2);
ND_PRINT((ndo, "\n\tBuffer Count: %u", EXTRACT_16BITS(cp)));
cp += 2;
/* Firmware Version */
ND_TCHECK2(*cp, 2);
ND_PRINT((ndo, ", Firmware Version: %u", EXTRACT_16BITS(cp)));
cp += 2;
/* Sector Count */
ND_TCHECK2(*cp, 1);
ND_PRINT((ndo, ", Sector Count: %u", *cp));
cp += 1;
/* AoE/CCmd */
ND_TCHECK2(*cp, 1);
ND_PRINT((ndo, ", AoE: %u, CCmd: %s", (*cp & 0xF0) >> 4,
tok2str(aoev1_ccmd_str, "Unknown (0x02x)", *cp & 0x0F)));
cp += 1;
/* Config String Length */
ND_TCHECK2(*cp, 2);
cslen = EXTRACT_16BITS(cp);
cp += 2;
if (cslen > AOEV1_MAX_CONFSTR_LEN || AOEV1_QUERY_ARG_LEN + cslen > len)
goto invalid;
/* Config String */
ND_TCHECK2(*cp, cslen);
if (cslen) {
ND_PRINT((ndo, "\n\tConfig String (length %u): ", cslen));
if (fn_printn(ndo, cp, cslen, ndo->ndo_snapend))
goto trunc;
}
return;
invalid:
ND_PRINT((ndo, "%s", istr));
ND_TCHECK2(*cp, ep - cp);
return;
trunc:
ND_PRINT((ndo, "%s", tstr));
}
void
_hsrp_print(netdissect_options *ndo, register const uint8_t *bp, register u_int len)
{
struct hsrp *hp = (struct hsrp *) bp;
ND_TCHECK(hp->hsrp_version);
ND_PRINT((ndo, "HSRPv%d", hp->hsrp_version));
if (hp->hsrp_version != 0)
return;
ND_TCHECK(hp->hsrp_op_code);
ND_PRINT((ndo, "-"));
ND_PRINT((ndo, "%s ", tok2strary(op_code_str, "unknown (%d)", hp->hsrp_op_code)));
ND_PRINT((ndo, "%d: ", len));
ND_TCHECK(hp->hsrp_state);
ND_PRINT((ndo, "state=%s ", tok2str(states, "Unknown (%d)", hp->hsrp_state)));
ND_TCHECK(hp->hsrp_group);
ND_PRINT((ndo, "group=%d ", hp->hsrp_group));
ND_TCHECK(hp->hsrp_reserved);
if (hp->hsrp_reserved != 0) {
ND_PRINT((ndo, "[reserved=%d!] ", hp->hsrp_reserved));
}
ND_TCHECK(hp->hsrp_virtaddr);
ND_PRINT((ndo, "addr=%s", ipaddr_string(ndo, &hp->hsrp_virtaddr)));
if (ndo->ndo_vflag) {
ND_PRINT((ndo, " hellotime="));
relts_print(ndo, hp->hsrp_hellotime);
ND_PRINT((ndo, " holdtime="));
relts_print(ndo, hp->hsrp_holdtime);
ND_PRINT((ndo, " priority=%d", hp->hsrp_priority));
ND_PRINT((ndo, " auth=\""));
if (fn_printn(ndo, hp->hsrp_authdata, sizeof(hp->hsrp_authdata),
ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
}
return;
trunc:
ND_PRINT((ndo, "[|hsrp]"));
}
void
hsrp_print(register const u_int8_t *bp, register u_int len)
{
struct hsrp *hp = (struct hsrp *) bp;
TCHECK(hp->hsrp_version);
printf("HSRPv%d", hp->hsrp_version);
if (hp->hsrp_version != 0)
return;
TCHECK(hp->hsrp_op_code);
printf("-");
printf("%s ", tok2strary(op_code_str, "unknown (%d)", hp->hsrp_op_code));
printf("%d: ", len);
TCHECK(hp->hsrp_state);
printf("state=%s ", tok2str(states, "Unknown (%d)", hp->hsrp_state));
TCHECK(hp->hsrp_group);
printf("group=%d ", hp->hsrp_group);
TCHECK(hp->hsrp_reserved);
if (hp->hsrp_reserved != 0) {
printf("[reserved=%d!] ", hp->hsrp_reserved);
}
TCHECK(hp->hsrp_virtaddr);
printf("addr=%s", ipaddr_string(&hp->hsrp_virtaddr));
if (vflag) {
printf(" hellotime=");
relts_print(hp->hsrp_hellotime);
printf(" holdtime=");
relts_print(hp->hsrp_holdtime);
printf(" priority=%d", hp->hsrp_priority);
printf(" auth=\"");
if (fn_printn(hp->hsrp_authdata, sizeof(hp->hsrp_authdata),
snapend)) {
printf("\"");
goto trunc;
}
printf("\"");
}
return;
trunc:
printf("[|hsrp]");
}
void
cdp_print(netdissect_options *ndo,
const u_char *pptr, u_int length, u_int caplen)
{
int type, len, i, j;
const u_char *tptr;
if (caplen < CDP_HEADER_LEN) {
ND_PRINT((ndo, "%s", tstr));
return;
}
tptr = pptr; /* temporary pointer */
ND_TCHECK2(*tptr, CDP_HEADER_LEN);
ND_PRINT((ndo, "CDPv%u, ttl: %us", *(tptr + CDP_HEADER_VERSION_OFFSET),
*(tptr + CDP_HEADER_TTL_OFFSET)));
if (ndo->ndo_vflag)
ND_PRINT((ndo, ", checksum: 0x%04x (unverified), length %u", EXTRACT_16BITS(tptr+CDP_HEADER_CHECKSUM_OFFSET), length));
tptr += CDP_HEADER_LEN;
while (tptr < (pptr+length)) {
ND_TCHECK2(*tptr, CDP_TLV_HEADER_LEN); /* read out Type and Length */
type = EXTRACT_16BITS(tptr+CDP_TLV_TYPE_OFFSET);
len = EXTRACT_16BITS(tptr+CDP_TLV_LEN_OFFSET); /* object length includes the 4 bytes header length */
if (len < CDP_TLV_HEADER_LEN) {
if (ndo->ndo_vflag)
ND_PRINT((ndo, "\n\t%s (0x%02x), TLV length: %u byte%s (too short)",
tok2str(cdp_tlv_values,"unknown field type", type),
type,
len,
PLURAL_SUFFIX(len))); /* plural */
else
ND_PRINT((ndo, ", %s TLV length %u too short",
tok2str(cdp_tlv_values,"unknown field type", type),
len));
break;
}
tptr += CDP_TLV_HEADER_LEN;
len -= CDP_TLV_HEADER_LEN;
ND_TCHECK2(*tptr, len);
if (ndo->ndo_vflag || type == 1) { /* in non-verbose mode just print Device-ID */
if (ndo->ndo_vflag)
ND_PRINT((ndo, "\n\t%s (0x%02x), value length: %u byte%s: ",
tok2str(cdp_tlv_values,"unknown field type", type),
type,
len,
PLURAL_SUFFIX(len))); /* plural */
switch (type) {
case 0x01: /* Device-ID */
if (!ndo->ndo_vflag)
ND_PRINT((ndo, ", Device-ID "));
ND_PRINT((ndo, "'"));
(void)fn_printn(ndo, tptr, len, NULL);
ND_PRINT((ndo, "'"));
break;
case 0x02: /* Address */
if (cdp_print_addr(ndo, tptr, len) < 0)
goto trunc;
break;
case 0x03: /* Port-ID */
ND_PRINT((ndo, "'"));
(void)fn_printn(ndo, tptr, len, NULL);
ND_PRINT((ndo, "'"));
break;
case 0x04: /* Capabilities */
if (len < 4)
goto trunc;
ND_PRINT((ndo, "(0x%08x): %s",
EXTRACT_32BITS(tptr),
bittok2str(cdp_capability_values, "none", EXTRACT_32BITS(tptr))));
break;
case 0x05: /* Version */
ND_PRINT((ndo, "\n\t "));
for (i=0;i<len;i++) {
j = *(tptr+i);
if (j == '\n') /* lets rework the version string to
get a nice indentation */
ND_PRINT((ndo, "\n\t "));
else
fn_print_char(ndo, j);
}
break;
case 0x06: /* Platform */
ND_PRINT((ndo, "'"));
(void)fn_printn(ndo, tptr, len, NULL);
ND_PRINT((ndo, "'"));
break;
case 0x07: /* Prefixes */
if (cdp_print_prefixes(ndo, tptr, len) < 0)
goto trunc;
break;
case 0x08: /* Protocol Hello Option - not documented */
break;
case 0x09: /* VTP Mgmt Domain - CDPv2 */
ND_PRINT((ndo, "'"));
(void)fn_printn(ndo, tptr, len, NULL);
ND_PRINT((ndo, "'"));
break;
case 0x0a: /* Native VLAN ID - CDPv2 */
if (len < 2)
goto trunc;
ND_PRINT((ndo, "%d", EXTRACT_16BITS(tptr)));
break;
case 0x0b: /* Duplex - CDPv2 */
if (len < 1)
goto trunc;
ND_PRINT((ndo, "%s", *(tptr) ? "full": "half"));
break;
/* http://www.cisco.com/c/en/us/td/docs/voice_ip_comm/cata/186/2_12_m/english/release/notes/186rn21m.html
* plus more details from other sources
*/
case 0x0e: /* ATA-186 VoIP VLAN request - incomplete doc. */
if (len < 3)
goto trunc;
ND_PRINT((ndo, "app %d, vlan %d", *(tptr), EXTRACT_16BITS(tptr + 1)));
break;
case 0x10: /* ATA-186 VoIP VLAN assignment - incomplete doc. */
ND_PRINT((ndo, "%1.2fW", cdp_get_number(tptr, len) / 1000.0));
break;
case 0x11: /* MTU - not documented */
if (len < 4)
goto trunc;
ND_PRINT((ndo, "%u bytes", EXTRACT_32BITS(tptr)));
break;
case 0x12: /* AVVID trust bitmap - not documented */
if (len < 1)
goto trunc;
ND_PRINT((ndo, "0x%02x", *(tptr)));
break;
case 0x13: /* AVVID untrusted port CoS - not documented */
if (len < 1)
goto trunc;
ND_PRINT((ndo, "0x%02x", *(tptr)));
break;
case 0x14: /* System Name - not documented */
ND_PRINT((ndo, "'"));
(void)fn_printn(ndo, tptr, len, NULL);
ND_PRINT((ndo, "'"));
break;
case 0x16: /* System Object ID - not documented */
if (cdp_print_addr(ndo, tptr, len) < 0)
goto trunc;
break;
case 0x17: /* Physical Location - not documented */
if (len < 1)
goto trunc;
ND_PRINT((ndo, "0x%02x", *(tptr)));
if (len > 1) {
ND_PRINT((ndo, "/"));
(void)fn_printn(ndo, tptr + 1, len - 1, NULL);
}
break;
default:
print_unknown_data(ndo, tptr, "\n\t ", len);
break;
}
}
tptr = tptr+len;
}
if (ndo->ndo_vflag < 1)
ND_PRINT((ndo, ", length %u", caplen));
return;
trunc:
ND_PRINT((ndo, "%s", tstr));
}
static void
rfc1048_print(const u_char *bp, u_int length)
{
u_char tag;
u_int len, size;
const char *cp;
u_char c;
int first;
u_int32_t ul;
u_short us;
printf(" vend-rfc1048");
/* Step over magic cookie */
bp += sizeof(int32_t);
/* Loop while we there is a tag left in the buffer */
while (bp + 1 < snapend) {
tag = *bp++;
if (tag == TAG_PAD)
continue;
if (tag == TAG_END)
return;
cp = tok2str(tag2str, "?T%d", tag);
c = *cp++;
printf(" %s:", cp);
/* Get the length; check for truncation */
if (bp + 1 >= snapend) {
fputs(tstr, stdout);
return;
}
len = *bp++;
if (bp + len >= snapend) {
fputs(tstr, stdout);
return;
}
if (tag == TAG_DHCP_MESSAGE && len == 1) {
c = *bp++;
switch (c) {
case DHCPDISCOVER: printf("DISCOVER"); break;
case DHCPOFFER: printf("OFFER"); break;
case DHCPREQUEST: printf("REQUEST"); break;
case DHCPDECLINE: printf("DECLINE"); break;
case DHCPACK: printf("ACK"); break;
case DHCPNAK: printf("NACK"); break;
case DHCPRELEASE: printf("RELEASE"); break;
case DHCPINFORM: printf("INFORM"); break;
default: printf("%u", c); break;
}
continue;
}
if (tag == TAG_PARM_REQUEST) {
first = 1;
while (len-- > 0) {
c = *bp++;
cp = tok2str(tag2str, "?%d", c);
if (!first)
putchar('+');
printf("%s", cp + 1);
first = 0;
}
continue;
}
/* Print data */
size = len;
if (c == '?') {
/* Base default formats for unknown tags on data size */
if (size & 1)
c = 'b';
else if (size & 2)
c = 's';
else
c = 'l';
}
first = 1;
switch (c) {
case 'a':
/* ascii strings */
putchar('"');
(void)fn_printn(bp, size, NULL);
putchar('"');
bp += size;
size = 0;
break;
case 'i':
case 'l':
/* ip addresses/32-bit words */
while (size >= sizeof(ul)) {
if (!first)
putchar(',');
memcpy((char *)&ul, (char *)bp, sizeof(ul));
if (c == 'i')
printf("%s", ipaddr_string(&ul));
else
printf("%u", ntohl(ul));
bp += sizeof(ul);
size -= sizeof(ul);
first = 0;
}
break;
case 'p':
/* IP address pairs */
while (size >= 2*sizeof(ul)) {
if (!first)
putchar(',');
memcpy((char *)&ul, (char *)bp, sizeof(ul));
printf("(%s:", ipaddr_string(&ul));
bp += sizeof(ul);
memcpy((char *)&ul, (char *)bp, sizeof(ul));
printf("%s)", ipaddr_string(&ul));
bp += sizeof(ul);
size -= 2*sizeof(ul);
first = 0;
}
break;
case 's':
/* shorts */
while (size >= sizeof(us)) {
if (!first)
putchar(',');
memcpy((char *)&us, (char *)bp, sizeof(us));
printf("%u", ntohs(us));
bp += sizeof(us);
size -= sizeof(us);
first = 0;
}
break;
case 'B':
/* boolean */
while (size > 0) {
if (!first)
putchar(',');
switch (*bp) {
case 0:
putchar('N');
break;
case 1:
putchar('Y');
break;
default:
printf("%d?", *bp);
break;
}
++bp;
--size;
first = 0;
}
break;
case 'b':
default:
/* Bytes */
while (size > 0) {
if (!first)
putchar('.');
printf("%d", *bp);
++bp;
--size;
first = 0;
}
break;
}
/* Data left over? */
if (size)
printf("[len %d]", len);
}
}
void
vrrp_print(netdissect_options *ndo,
register const u_char *bp, register u_int len,
register const u_char *bp2, int ttl)
{
int version, type, auth_type = VRRP_AUTH_NONE; /* keep compiler happy */
const char *type_s;
ND_TCHECK(bp[0]);
version = (bp[0] & 0xf0) >> 4;
type = bp[0] & 0x0f;
type_s = tok2str(type2str, "unknown type (%u)", type);
ND_PRINT((ndo, "VRRPv%u, %s", version, type_s));
if (ttl != 255)
ND_PRINT((ndo, ", (ttl %u)", ttl));
if (version < 2 || version > 3 || type != VRRP_TYPE_ADVERTISEMENT)
return;
ND_TCHECK(bp[2]);
ND_PRINT((ndo, ", vrid %u, prio %u", bp[1], bp[2]));
ND_TCHECK(bp[5]);
if (version == 2) {
auth_type = bp[4];
ND_PRINT((ndo, ", authtype %s", tok2str(auth2str, NULL, auth_type)));
ND_PRINT((ndo, ", intvl %us, length %u", bp[5], len));
} else { /* version == 3 */
uint16_t intvl = (bp[4] & 0x0f) << 8 | bp[5];
ND_PRINT((ndo, ", intvl %ucs, length %u", intvl, len));
}
if (ndo->ndo_vflag) {
int naddrs = bp[3];
int i;
char c;
if (version == 2 && ND_TTEST2(bp[0], len)) {
struct cksum_vec vec[1];
vec[0].ptr = bp;
vec[0].len = len;
if (in_cksum(vec, 1))
ND_PRINT((ndo, ", (bad vrrp cksum %x)",
EXTRACT_16BITS(&bp[6])));
}
if (version == 3 && ND_TTEST2(bp[0], len)) {
uint16_t cksum = nextproto4_cksum(ndo, (struct ip *)bp2, bp,
len, len, IPPROTO_VRRP);
if (cksum)
ND_PRINT((ndo, ", (bad vrrp cksum %x)",
EXTRACT_16BITS(&bp[6])));
}
ND_PRINT((ndo, ", addrs"));
if (naddrs > 1)
ND_PRINT((ndo, "(%d)", naddrs));
ND_PRINT((ndo, ":"));
c = ' ';
bp += 8;
for (i = 0; i < naddrs; i++) {
ND_TCHECK(bp[3]);
ND_PRINT((ndo, "%c%s", c, ipaddr_string(ndo, bp)));
c = ',';
bp += 4;
}
if (version == 2 && auth_type == VRRP_AUTH_SIMPLE) { /* simple text password */
ND_TCHECK(bp[7]);
ND_PRINT((ndo, " auth \""));
if (fn_printn(ndo, bp, 8, ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
}
}
return;
trunc:
ND_PRINT((ndo, "[|vrrp]"));
}
static void
dhcp6opt_print(netdissect_options *ndo,
const u_char *cp, const u_char *ep)
{
const struct dhcp6opt *dh6o;
const u_char *tp;
u_int i;
uint16_t opttype;
uint16_t optlen;
uint8_t auth_proto;
uint8_t auth_alg;
uint8_t auth_rdm;
u_int authinfolen, authrealmlen;
u_int remain_len; /* Length of remaining options */
u_int label_len; /* Label length */
uint16_t subopt_code;
uint16_t subopt_len;
uint8_t dh6_reconf_type;
uint8_t dh6_lq_query_type;
if (cp == ep)
return;
while (cp < ep) {
if (ep < cp + sizeof(*dh6o))
goto trunc;
dh6o = (const struct dhcp6opt *)cp;
ND_TCHECK_SIZE(dh6o);
optlen = EXTRACT_BE_U_2(dh6o->dh6opt_len);
if (ep < cp + sizeof(*dh6o) + optlen)
goto trunc;
opttype = EXTRACT_BE_U_2(dh6o->dh6opt_type);
ND_PRINT(" (%s", tok2str(dh6opt_str, "opt_%u", opttype));
ND_TCHECK_LEN(cp + sizeof(*dh6o), optlen);
switch (opttype) {
case DH6OPT_CLIENTID:
case DH6OPT_SERVERID:
if (optlen < 2) {
/*(*/
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
switch (EXTRACT_BE_U_2(tp)) {
case 1:
if (optlen >= 2 + 6) {
ND_PRINT(" hwaddr/time type %u time %u ",
EXTRACT_BE_U_2(tp + 2),
EXTRACT_BE_U_4(tp + 4));
for (i = 8; i < optlen; i++)
ND_PRINT("%02x", EXTRACT_U_1(tp + i));
/*(*/
ND_PRINT(")");
} else {
/*(*/
ND_PRINT(" ?)");
}
break;
case 2:
if (optlen >= 2 + 8) {
ND_PRINT(" vid ");
for (i = 2; i < 2 + 8; i++)
ND_PRINT("%02x", EXTRACT_U_1(tp + i));
/*(*/
ND_PRINT(")");
} else {
/*(*/
ND_PRINT(" ?)");
}
break;
case 3:
if (optlen >= 2 + 2) {
ND_PRINT(" hwaddr type %u ",
EXTRACT_BE_U_2(tp + 2));
for (i = 4; i < optlen; i++)
ND_PRINT("%02x", EXTRACT_U_1(tp + i));
/*(*/
ND_PRINT(")");
} else {
/*(*/
ND_PRINT(" ?)");
}
break;
default:
ND_PRINT(" type %u)", EXTRACT_BE_U_2(tp));
break;
}
break;
case DH6OPT_IA_ADDR:
if (optlen < 24) {
/*(*/
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %s", ip6addr_string(ndo, tp));
ND_PRINT(" pltime:%u vltime:%u",
EXTRACT_BE_U_4(tp + 16),
EXTRACT_BE_U_4(tp + 20));
if (optlen > 24) {
/* there are sub-options */
dhcp6opt_print(ndo, tp + 24, tp + optlen);
}
ND_PRINT(")");
break;
case DH6OPT_ORO:
case DH6OPT_ERO:
if (optlen % 2) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
for (i = 0; i < optlen; i += 2) {
ND_PRINT(" %s",
tok2str(dh6opt_str, "opt_%u", EXTRACT_BE_U_2(tp + i)));
}
ND_PRINT(")");
break;
case DH6OPT_PREFERENCE:
if (optlen != 1) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %u)", EXTRACT_U_1(tp));
break;
case DH6OPT_ELAPSED_TIME:
if (optlen != 2) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %u)", EXTRACT_BE_U_2(tp));
break;
case DH6OPT_RELAY_MSG:
ND_PRINT(" (");
tp = (const u_char *)(dh6o + 1);
dhcp6_print(ndo, tp, optlen);
ND_PRINT(")");
break;
case DH6OPT_AUTH:
if (optlen < 11) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
auth_proto = EXTRACT_U_1(tp);
switch (auth_proto) {
case DH6OPT_AUTHPROTO_DELAYED:
ND_PRINT(" proto: delayed");
break;
case DH6OPT_AUTHPROTO_RECONFIG:
ND_PRINT(" proto: reconfigure");
break;
default:
ND_PRINT(" proto: %u", auth_proto);
break;
}
tp++;
auth_alg = EXTRACT_U_1(tp);
switch (auth_alg) {
case DH6OPT_AUTHALG_HMACMD5:
/* XXX: may depend on the protocol */
ND_PRINT(", alg: HMAC-MD5");
break;
default:
ND_PRINT(", alg: %u", auth_alg);
break;
}
tp++;
auth_rdm = EXTRACT_U_1(tp);
switch (auth_rdm) {
case DH6OPT_AUTHRDM_MONOCOUNTER:
ND_PRINT(", RDM: mono");
break;
default:
ND_PRINT(", RDM: %u", auth_rdm);
break;
}
tp++;
ND_PRINT(", RD:");
for (i = 0; i < 4; i++, tp += 2)
ND_PRINT(" %04x", EXTRACT_BE_U_2(tp));
/* protocol dependent part */
authinfolen = optlen - 11;
switch (auth_proto) {
case DH6OPT_AUTHPROTO_DELAYED:
if (authinfolen == 0)
break;
if (authinfolen < 20) {
ND_PRINT(" ??");
break;
}
authrealmlen = authinfolen - 20;
if (authrealmlen > 0) {
ND_PRINT(", realm: ");
}
for (i = 0; i < authrealmlen; i++, tp++)
ND_PRINT("%02x", EXTRACT_U_1(tp));
ND_PRINT(", key ID: %08x", EXTRACT_BE_U_4(tp));
tp += 4;
ND_PRINT(", HMAC-MD5:");
for (i = 0; i < 4; i++, tp+= 4)
ND_PRINT(" %08x", EXTRACT_BE_U_4(tp));
break;
case DH6OPT_AUTHPROTO_RECONFIG:
if (authinfolen != 17) {
ND_PRINT(" ??");
break;
}
switch (EXTRACT_U_1(tp)) {
case DH6OPT_AUTHRECONFIG_KEY:
ND_PRINT(" reconfig-key");
break;
case DH6OPT_AUTHRECONFIG_HMACMD5:
ND_PRINT(" type: HMAC-MD5");
break;
default:
ND_PRINT(" type: ??");
break;
}
tp++;
ND_PRINT(" value:");
for (i = 0; i < 4; i++, tp+= 4)
ND_PRINT(" %08x", EXTRACT_BE_U_4(tp));
break;
default:
ND_PRINT(" ??");
break;
}
ND_PRINT(")");
break;
case DH6OPT_RAPID_COMMIT: /* nothing todo */
ND_PRINT(")");
break;
case DH6OPT_INTERFACE_ID:
case DH6OPT_SUBSCRIBER_ID:
/*
* Since we cannot predict the encoding, print hex dump
* at most 10 characters.
*/
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" ");
for (i = 0; i < optlen && i < 10; i++)
ND_PRINT("%02x", EXTRACT_U_1(tp + i));
ND_PRINT("...)");
break;
case DH6OPT_RECONF_MSG:
if (optlen != 1) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
dh6_reconf_type = EXTRACT_U_1(tp);
switch (dh6_reconf_type) {
case DH6_RENEW:
ND_PRINT(" for renew)");
break;
case DH6_INFORM_REQ:
ND_PRINT(" for inf-req)");
break;
default:
ND_PRINT(" for ?\?\?(%02x))", dh6_reconf_type);
break;
}
break;
case DH6OPT_RECONF_ACCEPT: /* nothing todo */
ND_PRINT(")");
break;
case DH6OPT_SIP_SERVER_A:
case DH6OPT_DNS_SERVERS:
case DH6OPT_SNTP_SERVERS:
case DH6OPT_NIS_SERVERS:
case DH6OPT_NISP_SERVERS:
case DH6OPT_BCMCS_SERVER_A:
case DH6OPT_PANA_AGENT:
case DH6OPT_LQ_CLIENT_LINK:
if (optlen % 16) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
for (i = 0; i < optlen; i += 16)
ND_PRINT(" %s", ip6addr_string(ndo, tp + i));
ND_PRINT(")");
break;
case DH6OPT_SIP_SERVER_D:
case DH6OPT_DOMAIN_LIST:
tp = (const u_char *)(dh6o + 1);
while (tp < cp + sizeof(*dh6o) + optlen) {
ND_PRINT(" ");
if ((tp = ns_nprint(ndo, tp, cp + sizeof(*dh6o) + optlen)) == NULL)
goto trunc;
}
ND_PRINT(")");
break;
case DH6OPT_STATUS_CODE:
if (optlen < 2) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %s)", dhcp6stcode(EXTRACT_BE_U_2(tp)));
break;
case DH6OPT_IA_NA:
case DH6OPT_IA_PD:
if (optlen < 12) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" IAID:%u T1:%u T2:%u",
EXTRACT_BE_U_4(tp),
EXTRACT_BE_U_4(tp + 4),
EXTRACT_BE_U_4(tp + 8));
if (optlen > 12) {
/* there are sub-options */
dhcp6opt_print(ndo, tp + 12, tp + optlen);
}
ND_PRINT(")");
break;
case DH6OPT_IA_TA:
if (optlen < 4) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" IAID:%u", EXTRACT_BE_U_4(tp));
if (optlen > 4) {
/* there are sub-options */
dhcp6opt_print(ndo, tp + 4, tp + optlen);
}
ND_PRINT(")");
break;
case DH6OPT_IA_PD_PREFIX:
if (optlen < 25) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %s/%u", ip6addr_string(ndo, tp + 9), EXTRACT_U_1(tp + 8));
ND_PRINT(" pltime:%u vltime:%u",
EXTRACT_BE_U_4(tp),
EXTRACT_BE_U_4(tp + 4));
if (optlen > 25) {
/* there are sub-options */
dhcp6opt_print(ndo, tp + 25, tp + optlen);
}
ND_PRINT(")");
break;
case DH6OPT_LIFETIME:
case DH6OPT_CLT_TIME:
if (optlen != 4) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %u)", EXTRACT_BE_U_4(tp));
break;
case DH6OPT_REMOTE_ID:
if (optlen < 4) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %u ", EXTRACT_BE_U_4(tp));
/*
* Print hex dump first 10 characters.
*/
for (i = 4; i < optlen && i < 14; i++)
ND_PRINT("%02x", EXTRACT_U_1(tp + i));
ND_PRINT("...)");
break;
case DH6OPT_LQ_QUERY:
if (optlen < 17) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
dh6_lq_query_type = EXTRACT_U_1(tp);
switch (dh6_lq_query_type) {
case 1:
ND_PRINT(" by-address");
break;
case 2:
ND_PRINT(" by-clientID");
break;
default:
ND_PRINT(" type_%u", dh6_lq_query_type);
break;
}
ND_PRINT(" %s", ip6addr_string(ndo, tp + 1));
if (optlen > 17) {
/* there are query-options */
dhcp6opt_print(ndo, tp + 17, tp + optlen);
}
ND_PRINT(")");
break;
case DH6OPT_CLIENT_DATA:
tp = (const u_char *)(dh6o + 1);
if (optlen > 0) {
/* there are encapsulated options */
dhcp6opt_print(ndo, tp, tp + optlen);
}
ND_PRINT(")");
break;
case DH6OPT_LQ_RELAY_DATA:
if (optlen < 16) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT(" %s ", ip6addr_string(ndo, tp));
/*
* Print hex dump first 10 characters.
*/
for (i = 16; i < optlen && i < 26; i++)
ND_PRINT("%02x", EXTRACT_U_1(tp + i));
ND_PRINT("...)");
break;
case DH6OPT_NTP_SERVER:
if (optlen < 4) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
while (tp < cp + sizeof(*dh6o) + optlen - 4) {
subopt_code = EXTRACT_BE_U_2(tp);
tp += 2;
subopt_len = EXTRACT_BE_U_2(tp);
tp += 2;
if (tp + subopt_len > cp + sizeof(*dh6o) + optlen)
goto trunc;
ND_PRINT(" subopt:%u", subopt_code);
switch (subopt_code) {
case DH6OPT_NTP_SUBOPTION_SRV_ADDR:
case DH6OPT_NTP_SUBOPTION_MC_ADDR:
if (subopt_len != 16) {
ND_PRINT(" ?");
break;
}
ND_PRINT(" %s", ip6addr_string(ndo, tp));
break;
case DH6OPT_NTP_SUBOPTION_SRV_FQDN:
ND_PRINT(" ");
if (ns_nprint(ndo, tp, tp + subopt_len) == NULL)
goto trunc;
break;
default:
ND_PRINT(" ?");
break;
}
tp += subopt_len;
}
ND_PRINT(")");
break;
case DH6OPT_AFTR_NAME:
if (optlen < 3) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
remain_len = optlen;
ND_PRINT(" ");
/* Encoding is described in section 3.1 of RFC 1035 */
while (remain_len && EXTRACT_U_1(tp)) {
label_len = EXTRACT_U_1(tp);
tp++;
if (label_len < remain_len - 1) {
(void)fn_printn(ndo, tp, label_len, NULL);
tp += label_len;
remain_len -= (label_len + 1);
if(EXTRACT_U_1(tp)) ND_PRINT(".");
} else {
ND_PRINT(" ?");
break;
}
}
ND_PRINT(")");
break;
case DH6OPT_NEW_POSIX_TIMEZONE: /* all three of these options */
case DH6OPT_NEW_TZDB_TIMEZONE: /* are encoded similarly */
case DH6OPT_MUDURL: /* although GMT might not work */
if (optlen < 5) {
ND_PRINT(" ?)");
break;
}
tp = (const u_char *)(dh6o + 1);
ND_PRINT("=");
(void)fn_printn(ndo, tp, (u_int)optlen, NULL);
ND_PRINT(")");
break;
default:
ND_PRINT(")");
break;
}
cp += sizeof(*dh6o) + optlen;
}
return;
trunc:
ND_PRINT("[|dhcp6ext]");
}
/*
* Print a single PDU.
*/
static void
rpki_rtr_pdu_print (netdissect_options *ndo, const u_char *tptr, u_int indent)
{
const rpki_rtr_pdu *pdu_header;
u_int pdu_type, pdu_len, hexdump;
const u_char *msg;
pdu_header = (const rpki_rtr_pdu *)tptr;
pdu_type = pdu_header->pdu_type;
pdu_len = EXTRACT_32BITS(pdu_header->length);
ND_TCHECK2(*tptr, pdu_len);
hexdump = FALSE;
ND_PRINT((ndo, "%sRPKI-RTRv%u, %s PDU (%u), length: %u",
indent_string(8),
pdu_header->version,
tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),
pdu_type, pdu_len));
switch (pdu_type) {
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_SERIAL_NOTIFY_PDU:
case RPKI_RTR_SERIAL_QUERY_PDU:
case RPKI_RTR_END_OF_DATA_PDU:
msg = (const u_char *)(pdu_header + 1);
ND_PRINT((ndo, "%sSession ID: 0x%04x, Serial: %u",
indent_string(indent+2),
EXTRACT_16BITS(pdu_header->u.session_id),
EXTRACT_32BITS(msg)));
break;
/*
* The following PDUs share the message format.
*/
case RPKI_RTR_RESET_QUERY_PDU:
case RPKI_RTR_CACHE_RESET_PDU:
/*
* Zero payload PDUs.
*/
break;
case RPKI_RTR_CACHE_RESPONSE_PDU:
ND_PRINT((ndo, "%sSession ID: 0x%04x",
indent_string(indent+2),
EXTRACT_16BITS(pdu_header->u.session_id)));
break;
case RPKI_RTR_IPV4_PREFIX_PDU:
{
const rpki_rtr_pdu_ipv4_prefix *pdu;
pdu = (const rpki_rtr_pdu_ipv4_prefix *)tptr;
ND_PRINT((ndo, "%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ipaddr_string(ndo, pdu->prefix),
pdu->prefix_length, pdu->max_length,
EXTRACT_32BITS(pdu->as), pdu->flags));
}
break;
case RPKI_RTR_IPV6_PREFIX_PDU:
{
const rpki_rtr_pdu_ipv6_prefix *pdu;
pdu = (const rpki_rtr_pdu_ipv6_prefix *)tptr;
ND_PRINT((ndo, "%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
ip6addr_string(ndo, pdu->prefix),
pdu->prefix_length, pdu->max_length,
EXTRACT_32BITS(pdu->as), pdu->flags));
}
break;
case RPKI_RTR_ERROR_REPORT_PDU:
{
const rpki_rtr_pdu_error_report *pdu;
u_int encapsulated_pdu_length, text_length, tlen, error_code;
pdu = (const rpki_rtr_pdu_error_report *)tptr;
encapsulated_pdu_length = EXTRACT_32BITS(pdu->encapsulated_pdu_length);
ND_TCHECK2(*tptr, encapsulated_pdu_length);
tlen = pdu_len;
error_code = EXTRACT_16BITS(pdu->pdu_header.u.error_code);
ND_PRINT((ndo, "%sError code: %s (%u), Encapsulated PDU length: %u",
indent_string(indent+2),
tok2str(rpki_rtr_error_codes, "Unknown", error_code),
error_code, encapsulated_pdu_length));
tptr += sizeof(*pdu);
tlen -= sizeof(*pdu);
/*
* Recurse if there is an encapsulated PDU.
*/
if (encapsulated_pdu_length &&
(encapsulated_pdu_length <= tlen)) {
ND_PRINT((ndo, "%s-----encapsulated PDU-----", indent_string(indent+4)));
rpki_rtr_pdu_print(ndo, tptr, indent+2);
}
tptr += encapsulated_pdu_length;
tlen -= encapsulated_pdu_length;
/*
* Extract, trail-zero and print the Error message.
*/
text_length = 0;
if (tlen > 4) {
text_length = EXTRACT_32BITS(tptr);
tptr += 4;
tlen -= 4;
}
ND_TCHECK2(*tptr, text_length);
if (text_length && (text_length <= tlen )) {
ND_PRINT((ndo, "%sError text: ", indent_string(indent+2)));
fn_printn(ndo, tptr, text_length, ndo->ndo_snapend);
}
}
break;
default:
/*
* Unknown data, please hexdump.
*/
hexdump = TRUE;
}
/* do we also want to see a hex dump ? */
if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
print_unknown_data(ndo,tptr,"\n\t ", pdu_len);
}
return;
trunc:
ND_PRINT((ndo, "|trunc"));
return;
}
void
udld_print (netdissect_options *ndo, const u_char *pptr, u_int length)
{
int code, type, len;
const u_char *tptr;
if (length < UDLD_HEADER_LEN)
goto trunc;
tptr = pptr;
ND_TCHECK2(*tptr, UDLD_HEADER_LEN);
code = UDLD_EXTRACT_OPCODE(*tptr);
ND_PRINT((ndo, "UDLDv%u, Code %s (%x), Flags [%s] (0x%02x), length %u",
UDLD_EXTRACT_VERSION(*tptr),
tok2str(udld_code_values, "Reserved", code),
code,
bittok2str(udld_flags_values, "none", *(tptr+1)),
*(tptr+1),
length));
/*
* In non-verbose mode, just print version and opcode type
*/
if (ndo->ndo_vflag < 1) {
return;
}
ND_PRINT((ndo, "\n\tChecksum 0x%04x (unverified)", EXTRACT_16BITS(tptr+2)));
tptr += UDLD_HEADER_LEN;
while (tptr < (pptr+length)) {
ND_TCHECK2(*tptr, 4);
type = EXTRACT_16BITS(tptr);
len = EXTRACT_16BITS(tptr+2);
ND_PRINT((ndo, "\n\t%s (0x%04x) TLV, length %u",
tok2str(udld_tlv_values, "Unknown", type),
type, len));
if (type == 0)
goto invalid;
/* infinite loop check */
if (len <= 4)
goto invalid;
len -= 4;
tptr += 4;
ND_TCHECK2(*tptr, len);
switch (type) {
case UDLD_DEVICE_ID_TLV:
case UDLD_PORT_ID_TLV:
case UDLD_DEVICE_NAME_TLV:
ND_PRINT((ndo, ", "));
fn_printzp(ndo, tptr, len, NULL);
break;
case UDLD_ECHO_TLV:
ND_PRINT((ndo, ", "));
(void)fn_printn(ndo, tptr, len, NULL);
break;
case UDLD_MESSAGE_INTERVAL_TLV:
case UDLD_TIMEOUT_INTERVAL_TLV:
if (len != 1)
goto invalid;
ND_PRINT((ndo, ", %us", (*tptr)));
break;
case UDLD_SEQ_NUMBER_TLV:
if (len != 4)
goto invalid;
ND_PRINT((ndo, ", %u", EXTRACT_32BITS(tptr)));
break;
default:
break;
}
tptr += len;
}
return;
invalid:
ND_PRINT((ndo, "%s", istr));
return;
trunc:
ND_PRINT((ndo, "%s", tstr));
}
static void
rfc1048_print(netdissect_options *ndo,
register const u_char *bp)
{
register uint16_t tag;
register u_int len;
register const char *cp;
register char c;
int first, idx;
uint32_t ul;
uint16_t us;
uint8_t uc, subopt, suboptlen;
ND_PRINT((ndo, "\n\t Vendor-rfc1048 Extensions"));
/* Step over magic cookie */
ND_PRINT((ndo, "\n\t Magic Cookie 0x%08x", EXTRACT_32BITS(bp)));
bp += sizeof(int32_t);
/* Loop while we there is a tag left in the buffer */
while (ND_TTEST2(*bp, 1)) {
tag = *bp++;
if (tag == TAG_PAD && ndo->ndo_vflag < 3)
continue;
if (tag == TAG_END && ndo->ndo_vflag < 3)
return;
if (tag == TAG_EXTENDED_OPTION) {
ND_TCHECK2(*(bp + 1), 2);
tag = EXTRACT_16BITS(bp + 1);
/* XXX we don't know yet if the IANA will
* preclude overlap of 1-byte and 2-byte spaces.
* If not, we need to offset tag after this step.
*/
cp = tok2str(xtag2str, "?xT%u", tag);
} else
cp = tok2str(tag2str, "?T%u", tag);
c = *cp++;
if (tag == TAG_PAD || tag == TAG_END)
len = 0;
else {
/* Get the length; check for truncation */
ND_TCHECK2(*bp, 1);
len = *bp++;
}
ND_PRINT((ndo, "\n\t %s Option %u, length %u%s", cp, tag, len,
len > 0 ? ": " : ""));
if (tag == TAG_PAD && ndo->ndo_vflag > 2) {
u_int ntag = 1;
while (ND_TTEST2(*bp, 1) && *bp == TAG_PAD) {
bp++;
ntag++;
}
if (ntag > 1)
ND_PRINT((ndo, ", occurs %u", ntag));
}
if (!ND_TTEST2(*bp, len)) {
ND_PRINT((ndo, "[|rfc1048 %u]", len));
return;
}
if (tag == TAG_DHCP_MESSAGE && len == 1) {
uc = *bp++;
ND_PRINT((ndo, "%s", tok2str(dhcp_msg_values, "Unknown (%u)", uc)));
continue;
}
if (tag == TAG_PARM_REQUEST) {
idx = 0;
while (len-- > 0) {
uc = *bp++;
cp = tok2str(tag2str, "?Option %u", uc);
if (idx % 4 == 0)
ND_PRINT((ndo, "\n\t "));
else
ND_PRINT((ndo, ", "));
ND_PRINT((ndo, "%s", cp + 1));
idx++;
}
continue;
}
if (tag == TAG_EXTENDED_REQUEST) {
first = 1;
while (len > 1) {
len -= 2;
us = EXTRACT_16BITS(bp);
bp += 2;
cp = tok2str(xtag2str, "?xT%u", us);
if (!first)
ND_PRINT((ndo, "+"));
ND_PRINT((ndo, "%s", cp + 1));
first = 0;
}
continue;
}
/* Print data */
if (c == '?') {
/* Base default formats for unknown tags on data size */
if (len & 1)
c = 'b';
else if (len & 2)
c = 's';
else
c = 'l';
}
first = 1;
switch (c) {
case 'a':
/* ascii strings */
ND_PRINT((ndo, "\""));
if (fn_printn(ndo, bp, len, ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
bp += len;
len = 0;
break;
case 'i':
case 'l':
case 'L':
/* ip addresses/32-bit words */
while (len >= sizeof(ul)) {
if (!first)
ND_PRINT((ndo, ","));
ul = EXTRACT_32BITS(bp);
if (c == 'i') {
ul = htonl(ul);
ND_PRINT((ndo, "%s", ipaddr_string(ndo, &ul)));
} else if (c == 'L')
ND_PRINT((ndo, "%d", ul));
else
ND_PRINT((ndo, "%u", ul));
bp += sizeof(ul);
len -= sizeof(ul);
first = 0;
}
break;
case 'p':
/* IP address pairs */
while (len >= 2*sizeof(ul)) {
if (!first)
ND_PRINT((ndo, ","));
memcpy((char *)&ul, (const char *)bp, sizeof(ul));
ND_PRINT((ndo, "(%s:", ipaddr_string(ndo, &ul)));
bp += sizeof(ul);
memcpy((char *)&ul, (const char *)bp, sizeof(ul));
ND_PRINT((ndo, "%s)", ipaddr_string(ndo, &ul)));
bp += sizeof(ul);
len -= 2*sizeof(ul);
first = 0;
}
break;
case 's':
/* shorts */
while (len >= sizeof(us)) {
if (!first)
ND_PRINT((ndo, ","));
us = EXTRACT_16BITS(bp);
ND_PRINT((ndo, "%u", us));
bp += sizeof(us);
len -= sizeof(us);
first = 0;
}
break;
case 'B':
/* boolean */
while (len > 0) {
if (!first)
ND_PRINT((ndo, ","));
switch (*bp) {
case 0:
ND_PRINT((ndo, "N"));
break;
case 1:
ND_PRINT((ndo, "Y"));
break;
default:
ND_PRINT((ndo, "%u?", *bp));
break;
}
++bp;
--len;
first = 0;
}
break;
case 'b':
case 'x':
default:
/* Bytes */
while (len > 0) {
if (!first)
ND_PRINT((ndo, c == 'x' ? ":" : "."));
if (c == 'x')
ND_PRINT((ndo, "%02x", *bp));
else
ND_PRINT((ndo, "%u", *bp));
++bp;
--len;
first = 0;
}
break;
case '$':
/* Guys we can't handle with one of the usual cases */
switch (tag) {
case TAG_NETBIOS_NODE:
/* this option should be at least 1 byte long */
if (len < 1) {
ND_PRINT((ndo, "ERROR: length < 1 bytes"));
break;
}
tag = *bp++;
--len;
ND_PRINT((ndo, "%s", tok2str(nbo2str, NULL, tag)));
break;
case TAG_OPT_OVERLOAD:
/* this option should be at least 1 byte long */
if (len < 1) {
ND_PRINT((ndo, "ERROR: length < 1 bytes"));
break;
}
tag = *bp++;
--len;
ND_PRINT((ndo, "%s", tok2str(oo2str, NULL, tag)));
break;
case TAG_CLIENT_FQDN:
/* this option should be at least 3 bytes long */
if (len < 3) {
ND_PRINT((ndo, "ERROR: length < 3 bytes"));
bp += len;
len = 0;
break;
}
if (*bp)
ND_PRINT((ndo, "[%s] ", client_fqdn_flags(*bp)));
bp++;
if (*bp || *(bp+1))
ND_PRINT((ndo, "%u/%u ", *bp, *(bp+1)));
bp += 2;
ND_PRINT((ndo, "\""));
if (fn_printn(ndo, bp, len - 3, ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
bp += len - 3;
len = 0;
break;
case TAG_CLIENT_ID:
{
int type;
/* this option should be at least 1 byte long */
if (len < 1) {
ND_PRINT((ndo, "ERROR: length < 1 bytes"));
break;
}
type = *bp++;
len--;
if (type == 0) {
ND_PRINT((ndo, "\""));
if (fn_printn(ndo, bp, len, ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
bp += len;
len = 0;
break;
} else {
ND_PRINT((ndo, "%s ", tok2str(arp2str, "hardware-type %u,", type)));
while (len > 0) {
if (!first)
ND_PRINT((ndo, ":"));
ND_PRINT((ndo, "%02x", *bp));
++bp;
--len;
first = 0;
}
}
break;
}
case TAG_AGENT_CIRCUIT:
while (len >= 2) {
subopt = *bp++;
suboptlen = *bp++;
len -= 2;
if (suboptlen > len) {
ND_PRINT((ndo, "\n\t %s SubOption %u, length %u: length goes past end of option",
tok2str(agent_suboption_values, "Unknown", subopt),
subopt,
suboptlen));
bp += len;
len = 0;
break;
}
ND_PRINT((ndo, "\n\t %s SubOption %u, length %u: ",
tok2str(agent_suboption_values, "Unknown", subopt),
subopt,
suboptlen));
switch (subopt) {
case AGENT_SUBOPTION_CIRCUIT_ID: /* fall through */
case AGENT_SUBOPTION_REMOTE_ID:
case AGENT_SUBOPTION_SUBSCRIBER_ID:
if (fn_printn(ndo, bp, suboptlen, ndo->ndo_snapend))
goto trunc;
break;
default:
print_unknown_data(ndo, bp, "\n\t\t", suboptlen);
}
len -= suboptlen;
bp += suboptlen;
}
break;
case TAG_CLASSLESS_STATIC_RT:
case TAG_CLASSLESS_STA_RT_MS:
{
u_int mask_width, significant_octets, i;
/* this option should be at least 5 bytes long */
if (len < 5) {
ND_PRINT((ndo, "ERROR: length < 5 bytes"));
bp += len;
len = 0;
break;
}
while (len > 0) {
if (!first)
ND_PRINT((ndo, ","));
mask_width = *bp++;
len--;
/* mask_width <= 32 */
if (mask_width > 32) {
ND_PRINT((ndo, "[ERROR: Mask width (%d) > 32]", mask_width));
bp += len;
len = 0;
break;
}
significant_octets = (mask_width + 7) / 8;
/* significant octets + router(4) */
if (len < significant_octets + 4) {
ND_PRINT((ndo, "[ERROR: Remaining length (%u) < %u bytes]", len, significant_octets + 4));
bp += len;
len = 0;
break;
}
ND_PRINT((ndo, "("));
if (mask_width == 0)
ND_PRINT((ndo, "default"));
else {
for (i = 0; i < significant_octets ; i++) {
if (i > 0)
ND_PRINT((ndo, "."));
ND_PRINT((ndo, "%d", *bp++));
}
for (i = significant_octets ; i < 4 ; i++)
ND_PRINT((ndo, ".0"));
ND_PRINT((ndo, "/%d", mask_width));
}
memcpy((char *)&ul, (const char *)bp, sizeof(ul));
ND_PRINT((ndo, ":%s)", ipaddr_string(ndo, &ul)));
bp += sizeof(ul);
len -= (significant_octets + 4);
first = 0;
}
break;
}
case TAG_USER_CLASS:
{
u_int suboptnumber = 1;
first = 1;
if (len < 2) {
ND_PRINT((ndo, "ERROR: length < 2 bytes"));
bp += len;
len = 0;
break;
}
while (len > 0) {
suboptlen = *bp++;
len--;
ND_PRINT((ndo, "\n\t "));
ND_PRINT((ndo, "instance#%u: ", suboptnumber));
if (suboptlen == 0) {
ND_PRINT((ndo, "ERROR: suboption length must be non-zero"));
bp += len;
len = 0;
break;
}
if (len < suboptlen) {
ND_PRINT((ndo, "ERROR: invalid option"));
bp += len;
len = 0;
break;
}
ND_PRINT((ndo, "\""));
if (fn_printn(ndo, bp, suboptlen, ndo->ndo_snapend)) {
ND_PRINT((ndo, "\""));
goto trunc;
}
ND_PRINT((ndo, "\""));
ND_PRINT((ndo, ", length %d", suboptlen));
suboptnumber++;
len -= suboptlen;
bp += suboptlen;
}
break;
}
default:
ND_PRINT((ndo, "[unknown special tag %u, size %u]",
tag, len));
bp += len;
len = 0;
break;
}
break;
}
/* Data left over? */
if (len) {
ND_PRINT((ndo, "\n\t trailing data length %u", len));
bp += len;
}
}
return;
trunc:
ND_PRINT((ndo, "|[rfc1048]"));
}
void
olsr_print (packetbody_t pptr, u_int length, int is_ipv6)
{
union {
__capability const struct olsr_common *common;
__capability const struct olsr_msg4 *msg4;
__capability const struct olsr_msg6 *msg6;
__capability const struct olsr_hello *hello;
__capability const struct olsr_hello_link *hello_link;
__capability const struct olsr_tc *tc;
__capability const struct olsr_hna4 *hna;
} ptr;
u_int msg_type, msg_len, msg_tlen, hello_len;
u_int16_t name_entry_type, name_entry_len;
u_int name_entry_padding;
u_int8_t link_type, neighbor_type;
packetbody_t tptr, msg_data;
tptr = pptr;
if (length < sizeof(struct olsr_common)) {
goto trunc;
}
if (!PACKET_HAS_SPACE(tptr, sizeof(struct olsr_common))) {
goto trunc;
}
ptr.common = (__capability struct olsr_common *)tptr;
length = MIN(length, EXTRACT_16BITS(ptr.common->packet_len));
printf("OLSRv%i, seq 0x%04x, length %u",
(is_ipv6 == 0) ? 4 : 6,
EXTRACT_16BITS(ptr.common->packet_seq),
length);
tptr += sizeof(struct olsr_common);
/*
* In non-verbose mode, just print version.
*/
if (vflag < 1) {
return;
}
while (tptr < (pptr+length)) {
union
{
__capability struct olsr_msg4 *v4;
__capability struct olsr_msg6 *v6;
} msgptr;
int msg_len_valid = 0;
if (!PACKET_HAS_SPACE(tptr, sizeof(struct olsr_msg4)))
goto trunc;
#if INET6
if (is_ipv6)
{
msgptr.v6 = (__capability struct olsr_msg6 *) tptr;
msg_type = msgptr.v6->msg_type;
msg_len = EXTRACT_16BITS(msgptr.v6->msg_len);
if ((msg_len >= sizeof (struct olsr_msg6))
&& (msg_len <= length))
msg_len_valid = 1;
/* infinite loop check */
if (msg_type == 0 || msg_len == 0) {
return;
}
printf("\n\t%s Message (%#04x), originator %s, ttl %u, hop %u"
"\n\t vtime %.3lfs, msg-seq 0x%04x, length %u%s",
tok2str(olsr_msg_values, "Unknown", msg_type),
msg_type, ip6addr_string(msgptr.v6->originator),
msgptr.v6->ttl,
msgptr.v6->hopcount,
ME_TO_DOUBLE(msgptr.v6->vtime),
EXTRACT_16BITS(msgptr.v6->msg_seq),
msg_len, (msg_len_valid == 0) ? " (invalid)" : "");
msg_tlen = msg_len - sizeof(struct olsr_msg6);
msg_data = tptr + sizeof(struct olsr_msg6);
}
else /* (!is_ipv6) */
#endif /* INET6 */
{
msgptr.v4 = (__capability struct olsr_msg4 *) tptr;
msg_type = msgptr.v4->msg_type;
msg_len = EXTRACT_16BITS(msgptr.v4->msg_len);
if ((msg_len >= sizeof (struct olsr_msg4))
&& (msg_len <= length))
msg_len_valid = 1;
/* infinite loop check */
if (msg_type == 0 || msg_len == 0) {
return;
}
printf("\n\t%s Message (%#04x), originator %s, ttl %u, hop %u"
"\n\t vtime %.3lfs, msg-seq 0x%04x, length %u%s",
tok2str(olsr_msg_values, "Unknown", msg_type),
msg_type, ipaddr_string(msgptr.v4->originator),
msgptr.v4->ttl,
msgptr.v4->hopcount,
ME_TO_DOUBLE(msgptr.v4->vtime),
EXTRACT_16BITS(msgptr.v4->msg_seq),
msg_len, (msg_len_valid == 0) ? " (invalid)" : "");
msg_tlen = msg_len - sizeof(struct olsr_msg4);
msg_data = tptr + sizeof(struct olsr_msg4);
}
switch (msg_type) {
case OLSR_HELLO_MSG:
case OLSR_HELLO_LQ_MSG:
if (!PACKET_HAS_SPACE(msg_data, sizeof(struct olsr_hello)))
goto trunc;
ptr.hello = (__capability struct olsr_hello *)msg_data;
printf("\n\t hello-time %.3lfs, MPR willingness %u",
ME_TO_DOUBLE(ptr.hello->htime), ptr.hello->will);
msg_data += sizeof(struct olsr_hello);
msg_tlen -= sizeof(struct olsr_hello);
while (msg_tlen >= sizeof(struct olsr_hello_link)) {
int hello_len_valid = 0;
/*
* link-type.
*/
if (!PACKET_HAS_SPACE(msg_data, sizeof(struct olsr_hello_link)))
goto trunc;
ptr.hello_link = (__capability struct olsr_hello_link *)msg_data;
hello_len = EXTRACT_16BITS(ptr.hello_link->len);
link_type = OLSR_EXTRACT_LINK_TYPE(ptr.hello_link->link_code);
neighbor_type = OLSR_EXTRACT_NEIGHBOR_TYPE(ptr.hello_link->link_code);
if ((hello_len <= msg_tlen)
&& (hello_len >= sizeof(struct olsr_hello_link)))
hello_len_valid = 1;
printf("\n\t link-type %s, neighbor-type %s, len %u%s",
tok2str(olsr_link_type_values, "Unknown", link_type),
tok2str(olsr_neighbor_type_values, "Unknown", neighbor_type),
hello_len,
(hello_len_valid == 0) ? " (invalid)" : "");
if (hello_len_valid == 0)
break;
msg_data += sizeof(struct olsr_hello_link);
msg_tlen -= sizeof(struct olsr_hello_link);
hello_len -= sizeof(struct olsr_hello_link);
if (msg_type == OLSR_HELLO_MSG) {
olsr_print_neighbor(msg_data, hello_len);
} else {
#if INET6
if (is_ipv6)
olsr_print_lq_neighbor6(msg_data, hello_len);
else
#endif
olsr_print_lq_neighbor4(msg_data, hello_len);
}
msg_data += hello_len;
msg_tlen -= hello_len;
}
break;
case OLSR_TC_MSG:
case OLSR_TC_LQ_MSG:
if (!PACKET_HAS_SPACE(msg_data, sizeof(struct olsr_tc)))
goto trunc;
ptr.tc = (__capability struct olsr_tc *)msg_data;
printf("\n\t advertised neighbor seq 0x%04x",
EXTRACT_16BITS(ptr.tc->ans_seq));
msg_data += sizeof(struct olsr_tc);
msg_tlen -= sizeof(struct olsr_tc);
if (msg_type == OLSR_TC_MSG) {
olsr_print_neighbor(msg_data, msg_tlen);
} else {
#if INET6
if (is_ipv6)
olsr_print_lq_neighbor6(msg_data, msg_tlen);
else
#endif
olsr_print_lq_neighbor4(msg_data, msg_tlen);
}
break;
case OLSR_MID_MSG:
{
size_t addr_size = sizeof(struct in_addr);
#if INET6
if (is_ipv6)
addr_size = sizeof(struct in6_addr);
#endif
while (msg_tlen >= addr_size) {
if (!PACKET_HAS_SPACE(msg_data, addr_size))
goto trunc;
printf("\n\t interface address %s",
#if INET6
is_ipv6 ? ip6addr_string(msg_data) :
#endif
ipaddr_string(msg_data));
msg_data += addr_size;
msg_tlen -= addr_size;
}
break;
}
case OLSR_HNA_MSG:
printf("\n\t Advertised networks (total %u)",
(unsigned int) (msg_tlen / sizeof(struct olsr_hna6)));
#if INET6
if (is_ipv6)
{
int i = 0;
while (msg_tlen >= sizeof(struct olsr_hna6)) {
__capability struct olsr_hna6 *hna6;
if (!PACKET_HAS_SPACE(msg_data, sizeof(struct olsr_hna6)))
goto trunc;
hna6 = (__capability struct olsr_hna6 *)msg_data;
printf("\n\t #%i: %s/%u",
i, ip6addr_string(hna6->network),
mask62plen (hna6->mask));
msg_data += sizeof(struct olsr_hna6);
msg_tlen -= sizeof(struct olsr_hna6);
}
}
else
#endif
{
int col = 0;
while (msg_tlen >= sizeof(struct olsr_hna4)) {
if (!PACKET_HAS_SPACE(msg_data, sizeof(struct olsr_hna4)))
goto trunc;
ptr.hna = (__capability struct olsr_hna4 *)msg_data;
/* print 4 prefixes per line */
if (col == 0)
printf ("\n\t ");
else
printf (", ");
printf("%s/%u",
ipaddr_string(ptr.hna->network),
mask2plen(EXTRACT_32BITS(ptr.hna->mask)));
msg_data += sizeof(struct olsr_hna4);
msg_tlen -= sizeof(struct olsr_hna4);
col = (col + 1) % 4;
}
}
break;
case OLSR_NAMESERVICE_MSG:
{
u_int name_entries = EXTRACT_16BITS(msg_data+2);
u_int addr_size = 4;
int name_entries_valid = 0;
u_int i;
if (is_ipv6)
addr_size = 16;
if ((name_entries > 0)
&& ((name_entries * (4 + addr_size)) <= msg_tlen))
name_entries_valid = 1;
if (msg_tlen < 4)
goto trunc;
if (!PACKET_HAS_SPACE(msg_data, 4))
goto trunc;
printf("\n\t Version %u, Entries %u%s",
EXTRACT_16BITS(msg_data),
name_entries, (name_entries_valid == 0) ? " (invalid)" : "");
if (name_entries_valid == 0)
break;
msg_data += 4;
msg_tlen -= 4;
for (i = 0; i < name_entries; i++) {
int name_entry_len_valid = 0;
if (msg_tlen < 4)
break;
if (!PACKET_HAS_SPACE(msg_data, 4))
goto trunc;
name_entry_type = EXTRACT_16BITS(msg_data);
name_entry_len = EXTRACT_16BITS(msg_data+2);
msg_data += 4;
msg_tlen -= 4;
if ((name_entry_len > 0) && ((addr_size + name_entry_len) <= msg_tlen))
name_entry_len_valid = 1;
printf("\n\t #%u: type %#06x, length %u%s",
(unsigned int) i, name_entry_type,
name_entry_len, (name_entry_len_valid == 0) ? " (invalid)" : "");
if (name_entry_len_valid == 0)
break;
/* 32-bit alignment */
name_entry_padding = 0;
if (name_entry_len%4 != 0)
name_entry_padding = 4-(name_entry_len%4);
if (msg_tlen < addr_size + name_entry_len + name_entry_padding)
goto trunc;
if (!PACKET_HAS_SPACE(msg_data, addr_size + name_entry_len + name_entry_padding))
goto trunc;
#if INET6
if (is_ipv6)
printf(", address %s, name \"",
ip6addr_string(msg_data));
else
#endif
printf(", address %s, name \"",
ipaddr_string(msg_data));
fn_printn(msg_data + addr_size, name_entry_len, NULL);
printf("\"");
msg_data += addr_size + name_entry_len + name_entry_padding;
msg_tlen -= addr_size + name_entry_len + name_entry_padding;
} /* for (i = 0; i < name_entries; i++) */
break;
} /* case OLSR_NAMESERVICE_MSG */
/*
* FIXME those are the defined messages that lack a decoder
* you are welcome to contribute code ;-)
*/
case OLSR_POWERINFO_MSG:
default:
print_unknown_data(msg_data, "\n\t ", msg_tlen);
break;
} /* switch (msg_type) */
tptr += msg_len;
} /* while (tptr < (pptr+length)) */
return;
trunc:
printf("[|olsr]");
}
static void
rfc1048_print(register const u_char *bp)
{
register u_int16_t tag;
register u_int len, size;
register const char *cp;
register char c;
int first, idx;
u_int32_t ul;
u_int16_t us;
u_int8_t uc, subopt, suboptlen;
printf("\n\t Vendor-rfc1048 Extensions");
/* Step over magic cookie */
printf("\n\t Magic Cookie 0x%08x", EXTRACT_32BITS(bp));
bp += sizeof(int32_t);
/* Loop while we there is a tag left in the buffer */
while (bp + 1 < snapend) {
tag = *bp++;
if (tag == TAG_PAD)
continue;
if (tag == TAG_END)
return;
if (tag == TAG_EXTENDED_OPTION) {
TCHECK2(*(bp + 1), 2);
tag = EXTRACT_16BITS(bp + 1);
/* XXX we don't know yet if the IANA will
* preclude overlap of 1-byte and 2-byte spaces.
* If not, we need to offset tag after this step.
*/
cp = tok2str(xtag2str, "?xT%u", tag);
} else
cp = tok2str(tag2str, "?T%u", tag);
c = *cp++;
/* Get the length; check for truncation */
if (bp + 1 >= snapend) {
fputs(tstr, stdout);
return;
}
len = *bp++;
printf("\n\t %s Option %u, length %u: ", cp, tag, len);
if (bp + len >= snapend) {
printf("[|bootp %u]", len);
return;
}
if (tag == TAG_DHCP_MESSAGE && len == 1) {
uc = *bp++;
printf("%s", tok2str(dhcp_msg_values, "Unknown (%u)", uc));
continue;
}
if (tag == TAG_PARM_REQUEST) {
first = 1;
idx = 0;
printf("\n\t ");
while (len-- > 0) {
uc = *bp++;
cp = tok2str(tag2str, "?Option %u", uc);
printf("%s%s", (first || (!(idx %4))) ? "" : ", ", cp + 1);
if ((idx %4) == 3) {
printf("\n\t ");
}
first = 0;
idx ++;
}
continue;
}
if (tag == TAG_EXTENDED_REQUEST) {
first = 1;
while (len > 1) {
len -= 2;
us = EXTRACT_16BITS(bp);
bp += 2;
cp = tok2str(xtag2str, "?xT%u", us);
if (!first)
putchar('+');
printf("%s", cp + 1);
first = 0;
}
continue;
}
/* Print data */
size = len;
if (c == '?') {
/* Base default formats for unknown tags on data size */
if (size & 1)
c = 'b';
else if (size & 2)
c = 's';
else
c = 'l';
}
first = 1;
switch (c) {
case 'a':
/* ascii strings */
putchar('"');
if (fn_printn(bp, size, snapend)) {
putchar('"');
goto trunc;
}
putchar('"');
bp += size;
size = 0;
break;
case 'i':
case 'l':
case 'L':
/* ip addresses/32-bit words */
while (size >= sizeof(ul)) {
if (!first)
putchar(',');
ul = EXTRACT_32BITS(bp);
if (c == 'i') {
ul = htonl(ul);
printf("%s", ipaddr_string(&ul));
} else if (c == 'L')
printf("%d", ul);
else
printf("%u", ul);
bp += sizeof(ul);
size -= sizeof(ul);
first = 0;
}
break;
case 'p':
/* IP address pairs */
while (size >= 2*sizeof(ul)) {
if (!first)
putchar(',');
memcpy((char *)&ul, (const char *)bp, sizeof(ul));
printf("(%s:", ipaddr_string(&ul));
bp += sizeof(ul);
memcpy((char *)&ul, (const char *)bp, sizeof(ul));
printf("%s)", ipaddr_string(&ul));
bp += sizeof(ul);
size -= 2*sizeof(ul);
first = 0;
}
break;
case 's':
/* shorts */
while (size >= sizeof(us)) {
if (!first)
putchar(',');
us = EXTRACT_16BITS(bp);
printf("%u", us);
bp += sizeof(us);
size -= sizeof(us);
first = 0;
}
break;
case 'B':
/* boolean */
while (size > 0) {
if (!first)
putchar(',');
switch (*bp) {
case 0:
putchar('N');
break;
case 1:
putchar('Y');
break;
default:
printf("%u?", *bp);
break;
}
++bp;
--size;
first = 0;
}
break;
case 'b':
case 'x':
default:
/* Bytes */
while (size > 0) {
if (!first)
putchar(c == 'x' ? ':' : '.');
if (c == 'x')
printf("%02x", *bp);
else
printf("%u", *bp);
++bp;
--size;
first = 0;
}
break;
case '$':
/* Guys we can't handle with one of the usual cases */
switch (tag) {
case TAG_NETBIOS_NODE:
tag = *bp++;
--size;
fputs(tok2str(nbo2str, NULL, tag), stdout);
break;
case TAG_OPT_OVERLOAD:
tag = *bp++;
--size;
fputs(tok2str(oo2str, NULL, tag), stdout);
break;
case TAG_CLIENT_FQDN:
/* option 81 should be at least 4 bytes long */
if (len < 4) {
printf("ERROR: options 81 len %u < 4 bytes", len);
break;
}
if (*bp++)
printf("[svrreg]");
if (*bp)
printf("%u/%u/", *bp, *(bp+1));
bp += 2;
putchar('"');
if (fn_printn(bp, size - 3, snapend)) {
putchar('"');
goto trunc;
}
putchar('"');
bp += size - 3;
size = 0;
break;
case TAG_CLIENT_ID:
{ int type = *bp++;
size--;
if (type == 0) {
putchar('"');
if (fn_printn(bp, size, snapend)) {
putchar('"');
goto trunc;
}
putchar('"');
bp += size;
size = 0;
break;
} else {
printf("%s ", tok2str(arp2str, "hardware-type %u,", type));
}
while (size > 0) {
if (!first)
putchar(':');
printf("%02x", *bp);
++bp;
--size;
first = 0;
}
break;
}
case TAG_AGENT_CIRCUIT:
{
while (size > 0 ) {
subopt = *bp++;
suboptlen = *bp++;
size -= 2;
printf("\n\t %s SubOption %u, length %u: ",
tok2str(agent_suboption_values, "Unknown", subopt),
subopt,
suboptlen);
if (subopt == 0 || suboptlen == 0) {
break;
}
switch(subopt) {
case AGENT_SUBOPTION_CIRCUIT_ID:
for (idx = 0; idx < suboptlen; idx++) {
safeputchar(*(bp+idx));
}
break;
default:
print_unknown_data(bp, "\n\t\t", suboptlen);
}
size -= suboptlen;
bp += suboptlen;
}
}
break;
default:
printf("[unknown special tag %u, size %u]",
tag, size);
bp += size;
size = 0;
break;
}
break;
}
/* Data left over? */
if (size) {
printf("\n\t trailing data length %u", len);
bp += size;
}
}
return;
trunc:
printf("|[rfc1048]");
}
/* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
static void
handle_ctrl_proto(netdissect_options *ndo,
u_int proto, const u_char *pptr, int length)
{
const char *typestr;
u_int code, len;
int (*pfunc)(netdissect_options *, const u_char *, int);
int x, j;
const u_char *tptr;
tptr=pptr;
typestr = tok2str(ppptype2str, "unknown ctrl-proto (0x%04x)", proto);
ND_PRINT((ndo, "%s, ", typestr));
if (length < 4) /* FIXME weak boundary checking */
goto trunc;
ND_TCHECK2(*tptr, 2);
code = *tptr++;
ND_PRINT((ndo, "%s (0x%02x), id %u, length %u",
tok2str(cpcodes, "Unknown Opcode",code),
code,
*tptr++, /* ID */
length + 2));
if (!ndo->ndo_vflag)
return;
if (length <= 4)
return; /* there may be a NULL confreq etc. */
ND_TCHECK2(*tptr, 2);
len = EXTRACT_16BITS(tptr);
tptr += 2;
ND_PRINT((ndo, "\n\tencoded length %u (=Option(s) length %u)", len, len - 4));
if (ndo->ndo_vflag > 1)
print_unknown_data(ndo, pptr - 2, "\n\t", 6);
switch (code) {
case CPCODES_VEXT:
if (length < 11)
break;
ND_TCHECK2(*tptr, 4);
ND_PRINT((ndo, "\n\t Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));
tptr += 4;
ND_TCHECK2(*tptr, 3);
ND_PRINT((ndo, " Vendor: %s (%u)",
tok2str(oui_values,"Unknown",EXTRACT_24BITS(tptr)),
EXTRACT_24BITS(tptr)));
/* XXX: need to decode Kind and Value(s)? */
break;
case CPCODES_CONF_REQ:
case CPCODES_CONF_ACK:
case CPCODES_CONF_NAK:
case CPCODES_CONF_REJ:
x = len - 4; /* Code(1), Identifier(1) and Length(2) */
do {
switch (proto) {
case PPP_LCP:
pfunc = print_lcp_config_options;
break;
case PPP_IPCP:
pfunc = print_ipcp_config_options;
break;
case PPP_IPV6CP:
pfunc = print_ip6cp_config_options;
break;
case PPP_CCP:
pfunc = print_ccp_config_options;
break;
case PPP_BACP:
pfunc = print_bacp_config_options;
break;
default:
/*
* No print routine for the options for
* this protocol.
*/
pfunc = NULL;
break;
}
if (pfunc == NULL) /* catch the above null pointer if unknown CP */
break;
if ((j = (*pfunc)(ndo, tptr, len)) == 0)
break;
x -= j;
tptr += j;
} while (x > 0);
break;
case CPCODES_TERM_REQ:
case CPCODES_TERM_ACK:
/* XXX: need to decode Data? */
break;
case CPCODES_CODE_REJ:
/* XXX: need to decode Rejected-Packet? */
break;
case CPCODES_PROT_REJ:
if (length < 6)
break;
ND_TCHECK2(*tptr, 2);
ND_PRINT((ndo, "\n\t Rejected %s Protocol (0x%04x)",
tok2str(ppptype2str,"unknown", EXTRACT_16BITS(tptr)),
EXTRACT_16BITS(tptr)));
/* XXX: need to decode Rejected-Information? - hexdump for now */
if (len > 6) {
ND_PRINT((ndo, "\n\t Rejected Packet"));
print_unknown_data(ndo, tptr + 2, "\n\t ", len - 2);
}
break;
case CPCODES_ECHO_REQ:
case CPCODES_ECHO_RPL:
case CPCODES_DISC_REQ:
if (length < 8)
break;
ND_TCHECK2(*tptr, 4);
ND_PRINT((ndo, "\n\t Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));
/* XXX: need to decode Data? - hexdump for now */
if (len > 8) {
ND_PRINT((ndo, "\n\t -----trailing data-----"));
ND_TCHECK2(tptr[4], len - 8);
print_unknown_data(ndo, tptr + 4, "\n\t ", len - 8);
}
break;
case CPCODES_ID:
if (length < 8)
break;
ND_TCHECK2(*tptr, 4);
ND_PRINT((ndo, "\n\t Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));
/* RFC 1661 says this is intended to be human readable */
if (len > 8) {
ND_PRINT((ndo, "\n\t Message\n\t "));
if (fn_printn(ndo, tptr + 4, len - 4, ndo->ndo_snapend))
goto trunc;
}
break;
case CPCODES_TIME_REM:
if (length < 12)
break;
ND_TCHECK2(*tptr, 4);
ND_PRINT((ndo, "\n\t Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));
ND_TCHECK2(*(tptr + 4), 4);
ND_PRINT((ndo, ", Seconds-Remaining %us", EXTRACT_32BITS(tptr + 4)));
/* XXX: need to decode Message? */
break;
default:
/* XXX this is dirty but we do not get the
* original pointer passed to the begin
* the PPP packet */
if (ndo->ndo_vflag <= 1)
print_unknown_data(ndo, pptr - 2, "\n\t ", length + 2);
break;
}
return;
trunc:
ND_PRINT((ndo, "[|%s]", typestr));
}
/*
* Print ntp requests
*/
void
ntp_print(register const u_char *cp, u_int length)
{
register const struct ntpdata *bp;
int mode, version, leapind;
bp = (struct ntpdata *)cp;
TCHECK(bp->status);
version = (int)(bp->status & VERSIONMASK) >> 3;
printf("NTPv%d", version);
mode = bp->status & MODEMASK;
if (!vflag) {
printf (", %s, length %u",
tok2str(ntp_mode_values, "Unknown mode", mode),
length);
return;
}
printf (", length %u\n\t%s",
length,
tok2str(ntp_mode_values, "Unknown mode", mode));
leapind = bp->status & LEAPMASK;
printf (", Leap indicator: %s (%u)",
tok2str(ntp_leapind_values, "Unknown", leapind),
leapind);
TCHECK(bp->stratum);
printf(", Stratum %u (%s)",
bp->stratum,
tok2str(ntp_stratum_values, (bp->stratum >=2 && bp->stratum<=15) ? "secondary reference" : "reserved", bp->stratum));
TCHECK(bp->ppoll);
printf(", poll %u (%us)", bp->ppoll, 1 << bp->ppoll);
/* Can't TCHECK bp->precision bitfield so bp->distance + 0 instead */
TCHECK2(bp->root_delay, 0);
printf(", precision %d", bp->precision);
TCHECK(bp->root_delay);
fputs("\n\tRoot Delay: ", stdout);
p_sfix(&bp->root_delay);
TCHECK(bp->root_dispersion);
fputs(", Root dispersion: ", stdout);
p_sfix(&bp->root_dispersion);
TCHECK(bp->refid);
fputs(", Reference-ID: ", stdout);
/* Interpretation depends on stratum */
switch (bp->stratum) {
case UNSPECIFIED:
printf("(unspec)");
break;
case PRIM_REF:
if (fn_printn((u_char *)&(bp->refid), 4, snapend))
goto trunc;
break;
case INFO_QUERY:
printf("%s INFO_QUERY", ipaddr_string(&(bp->refid)));
/* this doesn't have more content */
return;
case INFO_REPLY:
printf("%s INFO_REPLY", ipaddr_string(&(bp->refid)));
/* this is too complex to be worth printing */
return;
default:
printf("%s", ipaddr_string(&(bp->refid)));
break;
}
TCHECK(bp->ref_timestamp);
fputs("\n\t Reference Timestamp: ", stdout);
p_ntp_time(&(bp->ref_timestamp));
TCHECK(bp->org_timestamp);
fputs("\n\t Originator Timestamp: ", stdout);
p_ntp_time(&(bp->org_timestamp));
TCHECK(bp->rec_timestamp);
fputs("\n\t Receive Timestamp: ", stdout);
p_ntp_time(&(bp->rec_timestamp));
TCHECK(bp->xmt_timestamp);
fputs("\n\t Transmit Timestamp: ", stdout);
p_ntp_time(&(bp->xmt_timestamp));
fputs("\n\t Originator - Receive Timestamp: ", stdout);
p_ntp_delta(&(bp->org_timestamp), &(bp->rec_timestamp));
fputs("\n\t Originator - Transmit Timestamp: ", stdout);
p_ntp_delta(&(bp->org_timestamp), &(bp->xmt_timestamp));
if ( (sizeof(struct ntpdata) - length) == 16) { /* Optional: key-id */
TCHECK(bp->key_id);
printf("\n\tKey id: %u", bp->key_id);
} else if ( (sizeof(struct ntpdata) - length) == 0) { /* Optional: key-id + authentication */
TCHECK(bp->key_id);
printf("\n\tKey id: %u", bp->key_id);
TCHECK2(bp->message_digest, sizeof (bp->message_digest));
printf("\n\tAuthentication: %08x%08x%08x%08x",
EXTRACT_32BITS(bp->message_digest),
EXTRACT_32BITS(bp->message_digest + 4),
EXTRACT_32BITS(bp->message_digest + 8),
EXTRACT_32BITS(bp->message_digest + 12));
}
return;
trunc:
fputs(" [|ntp]", stdout);
}
void
ospf_print(register const u_char *bp, register u_int length,
register const u_char *bp2)
{
register const struct ospfhdr *op;
register const struct ip *ip;
register const u_char *dataend;
register const char *cp;
op = (struct ospfhdr *)bp;
ip = (struct ip *)bp2;
/* Print the source and destination address */
(void) printf("%s > %s:",
ipaddr_string(&ip->ip_src),
ipaddr_string(&ip->ip_dst));
/* XXX Before we do anything else, strip off the MD5 trailer */
TCHECK(op->ospf_authtype);
if (ntohs(op->ospf_authtype) == OSPF_AUTH_MD5) {
length -= OSPF_AUTH_MD5_LEN;
snapend -= OSPF_AUTH_MD5_LEN;
}
/* If the type is valid translate it, or just print the type */
/* value. If it's not valid, say so and return */
TCHECK(op->ospf_type);
cp = tok2str(type2str, "type%d", op->ospf_type);
printf(" OSPFv%d-%s ", op->ospf_version, cp);
if (*cp == 't')
return;
TCHECK(op->ospf_len);
if (length < ntohs(op->ospf_len)) {
printf(" [len %d]", ntohs(op->ospf_len));
return;
} else if (length > ntohs(op->ospf_len)) {
printf(" %d[%d]:", ntohs(op->ospf_len), length);
length = ntohs(op->ospf_len);
} else
printf(" %d:", length);
dataend = bp + length;
/* Print the routerid if it is not the same as the source */
TCHECK(op->ospf_routerid);
if (ip->ip_src.s_addr != op->ospf_routerid.s_addr)
printf(" rtrid %s", ipaddr_string(&op->ospf_routerid));
TCHECK(op->ospf_areaid);
if (op->ospf_areaid.s_addr != 0)
printf(" area %s", ipaddr_string(&op->ospf_areaid));
else
printf(" backbone");
if (vflag) {
/* Print authentication data (should we really do this?) */
TCHECK2(op->ospf_authdata[0], sizeof(op->ospf_authdata));
switch (ntohs(op->ospf_authtype)) {
case OSPF_AUTH_NONE:
break;
case OSPF_AUTH_SIMPLE:
printf(" auth \"");
(void)fn_printn(op->ospf_authdata,
sizeof(op->ospf_authdata), NULL);
printf("\"");
break;
case OSPF_AUTH_MD5:
printf(" auth MD5");
break;
default:
printf(" ??authtype-%d??", ntohs(op->ospf_authtype));
return;
}
}
/* Do rest according to version. */
switch (op->ospf_version) {
case 2:
/* ospf version 2 */
if (ospf_decode_v2(op, dataend))
goto trunc;
break;
default:
printf(" ospf [version %d]", op->ospf_version);
break;
} /* end switch on version */
return;
trunc:
fputs(tstr, stdout);
}
void
cdp_print(const u_char *pptr, u_int length, u_int caplen)
{
int type, len, i, j;
const u_char *tptr;
if (caplen < CDP_HEADER_LEN) {
(void)printf("[|cdp]");
return;
}
tptr = pptr; /* temporary pointer */
if (!TTEST2(*tptr, CDP_HEADER_LEN))
goto trunc;
printf("CDPv%u, ttl: %us", *tptr, *(tptr+1));
if (vflag)
printf(", checksum: %u (unverified), length %u", EXTRACT_16BITS(tptr), length);
tptr += CDP_HEADER_LEN;
while (tptr < (pptr+length)) {
if (!TTEST2(*tptr, 4)) /* read out Type and Length */
goto trunc;
type = EXTRACT_16BITS(tptr);
len = EXTRACT_16BITS(tptr+2); /* object length includes the 4 bytes header length */
tptr += 4;
len -= 4;
if (!TTEST2(*tptr, len))
goto trunc;
if (vflag || type == 1) { /* in non-verbose mode just print Device-ID */
if (vflag)
printf("\n\t%s (0x%02x), length: %u byte%s: ",
tok2str(cdp_tlv_values,"unknown field type", type),
type,
len,
PLURAL_SUFFIX(len)); /* plural */
switch (type) {
case 0x01: /* Device-ID */
if (!vflag)
printf(", Device-ID ");
printf("'");
fn_printn(tptr, len, NULL);
printf("'");
break;
case 0x02: /* Address */
if (cdp_print_addr(tptr, len) < 0)
goto trunc;
break;
case 0x03: /* Port-ID */
printf("'");
fn_printn(tptr, len, NULL);
printf("'");
break;
case 0x04: /* Capabilities */
printf("(0x%08x): %s",
EXTRACT_32BITS(tptr),
bittok2str(cdp_capability_values, "none",EXTRACT_32BITS(tptr)));
break;
case 0x05: /* Version */
printf("\n\t ");
for (i=0;i<len;i++) {
j = *(tptr+i);
putchar(j);
if (j == 0x0a) /* lets rework the version string to get a nice identation */
printf("\t ");
}
break;
case 0x06: /* Platform */
printf("'");
fn_printn(tptr, len, NULL);
printf("'");
break;
case 0x07: /* Prefixes */
if (cdp_print_prefixes(tptr, len) < 0)
goto trunc;
break;
case 0x08: /* Protocol Hello Option - not documented */
break;
case 0x09: /* VTP Mgmt Domain - not documented */
printf("'");
fn_printn(tptr, len, NULL);
printf("'");
break;
case 0x0a: /* Native VLAN ID - not documented */
printf("%d",EXTRACT_16BITS(tptr));
break;
case 0x0b: /* Duplex - not documented */
printf("%s", *(tptr) ? "full": "half");
break;
/* http://www.cisco.com/univercd/cc/td/doc/product/voice/ata/atarn/186rn21m.htm
* plus more details from other sources
*/
case 0x0e: /* ATA-186 VoIP VLAN request - incomplete doc. */
printf("app %d, vlan %d",
*(tptr), EXTRACT_16BITS(tptr+1));
break;
case 0x10: /* ATA-186 VoIP VLAN assignment - incomplete doc. */
printf("%1.2fW",
cdp_get_number(tptr, len)/1000.0 );
break;
case 0x11: /* MTU - not documented */
printf("%u bytes", EXTRACT_32BITS(tptr));
break;
case 0x12: /* AVVID trust bitmap - not documented */
printf("0x%02x", *(tptr) );
break;
case 0x13: /* AVVID untrusted port CoS - not documented */
printf("0x%02x", *(tptr));
break;
case 0x14: /* System Name - not documented */
printf("'");
fn_printn(tptr, len, NULL);
printf("'");
break;
case 0x16: /* System Object ID - not documented */
if (cdp_print_addr(tptr, len) < 0)
goto trunc;
break;
case 0x17: /* Physical Location - not documented */
printf("0x%02x", *(tptr));
if (len > 1) {
printf("/");
fn_printn(tptr + 1, len - 1, NULL);
}
break;
default:
print_unknown_data(tptr,"\n\t ",len);
break;
}
}
/* avoid infinite loop */
if (len == 0)
break;
tptr = tptr+len;
}
if (vflag < 1)
printf(", length %u",caplen);
return;
trunc:
printf("[|cdp]");
}
