* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
+#include "extract.h"
+
/*
- * Definitions to let us compile most of the IPv6 code even on systems
+ * Definition to let us compile most of the IPv6 code even on systems
* without IPv6 support.
*/
-
-#include "extract.h"
-
#ifndef INET6_ADDRSTRLEN
#define INET6_ADDRSTRLEN 46
#endif
*/
static inline const char *
-get_ipaddr_string(netdissect_options *ndo, const u_char *p)
+get_linkaddr_string(netdissect_options *ndo, const uint8_t *p,
+ const unsigned int type, const unsigned int len)
{
- if (!ND_TTEST_4(p))
+ if (!ND_TTEST_LEN(p, len))
longjmp(ndo->ndo_truncated, 1);
- return ipaddr_string(ndo, p);
+ return linkaddr_string(ndo, p, type, len);
}
static inline const char *
-get_ip6addr_string(netdissect_options *ndo, const u_char *p)
+get_etheraddr_string(netdissect_options *ndo, const uint8_t *p)
{
- if (!ND_TTEST_16(p))
+ if (!ND_TTEST_LEN(p, MAC_ADDR_LEN))
longjmp(ndo->ndo_truncated, 1);
- return ip6addr_string(ndo, p);
+ return etheraddr_string(ndo, p);
}
static inline const char *
return le64addr_string(ndo, p);
}
+static inline const char *
+get_isonsap_string(netdissect_options *ndo, const uint8_t *nsap,
+ u_int nsap_length)
+{
+ if (!ND_TTEST_LEN(nsap, nsap_length))
+ longjmp(ndo->ndo_truncated, 1);
+ return isonsap_string(ndo, nsap, nsap_length);
+}
+
+static inline const char *
+get_ipaddr_string(netdissect_options *ndo, const u_char *p)
+{
+ if (!ND_TTEST_4(p))
+ longjmp(ndo->ndo_truncated, 1);
+ return ipaddr_string(ndo, p);
+}
+
+static inline const char *
+get_ip6addr_string(netdissect_options *ndo, const u_char *p)
+{
+ if (!ND_TTEST_16(p))
+ longjmp(ndo->ndo_truncated, 1);
+ return ip6addr_string(ndo, p);
+}
+
+#define GET_LINKADDR_STRING(p, type, len) get_linkaddr_string(ndo, (const u_char *)(p), type, len)
+#define GET_ETHERADDR_STRING(p) get_etheraddr_string(ndo, (const u_char *)(p))
+#define GET_LE64ADDR_STRING(p) get_le64addr_string(ndo, (const u_char *)(p))
+#define GET_ISONSAP_STRING(nsap, nsap_length) get_isonsap_string(ndo, (const u_char *)(nsap), nsap_length)
#define GET_IPADDR_STRING(p) get_ipaddr_string(ndo, (const u_char *)(p))
#define GET_IP6ADDR_STRING(p) get_ip6addr_string(ndo, (const u_char *)(p))
-#define GET_LE64ADDR_STRING(p) get_le64addr_string(ndo, (const u_char *)(p))
if (ndo->ndo_eflag) {
ND_PRINT(": %s", reason);
} else {
- ND_PRINT(" (%s): %s", etheraddr_string(ndo, src), reason);
+ ND_PRINT(" (%s): %s", GET_ETHERADDR_STRING(src), reason);
}
return 1;
trunc:
if (ndo->ndo_eflag) {
ND_PRINT(": ");
} else {
- ND_PRINT(" (%s): ", etheraddr_string(ndo, src));
+ ND_PRINT(" (%s): ", GET_ETHERADDR_STRING(src));
}
switch (GET_U_1(p)) {
case 0: ND_PRINT("Spectrum Management Act#%u", GET_U_1(p + 1)); break;
ND_TCHECK_LEN(p, CTRL_BAR_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" RA:%s TA:%s CTL(%x) SEQ(%u) ",
- etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ra),
- etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ta),
+ GET_ETHERADDR_STRING(((const struct ctrl_bar_hdr_t *)p)->ra),
+ GET_ETHERADDR_STRING(((const struct ctrl_bar_hdr_t *)p)->ta),
GET_LE_U_2(((const struct ctrl_bar_hdr_t *)p)->ctl),
GET_LE_U_2(((const struct ctrl_bar_hdr_t *)p)->seq));
break;
ND_TCHECK_LEN(p, CTRL_BA_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_ba_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_ba_hdr_t *)p)->ra));
break;
case CTRL_PS_POLL:
ND_TCHECK_LEN(p, CTRL_PS_POLL_HDRLEN);
ND_TCHECK_LEN(p, CTRL_RTS_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" TA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ta));
+ GET_ETHERADDR_STRING(((const struct ctrl_rts_hdr_t *)p)->ta));
break;
case CTRL_CTS:
ND_TCHECK_LEN(p, CTRL_CTS_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_cts_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_cts_hdr_t *)p)->ra));
break;
case CTRL_ACK:
ND_TCHECK_LEN(p, CTRL_ACK_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_ack_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_ack_hdr_t *)p)->ra));
break;
case CTRL_CF_END:
ND_TCHECK_LEN(p, CTRL_END_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_end_hdr_t *)p)->ra));
break;
case CTRL_END_ACK:
ND_TCHECK_LEN(p, CTRL_END_ACK_HDRLEN);
if (!ndo->ndo_eflag)
ND_PRINT(" RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_end_ack_hdr_t *)p)->ra));
break;
}
return 1;
if (!FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
ND_PRINT("DA:%s SA:%s BSSID:%s ",
- etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
- etheraddr_string(ndo, ADDR3));
+ GET_ETHERADDR_STRING(ADDR1), GET_ETHERADDR_STRING(ADDR2),
+ GET_ETHERADDR_STRING(ADDR3));
} else if (!FC_TO_DS(fc) && FC_FROM_DS(fc)) {
ND_PRINT("DA:%s BSSID:%s SA:%s ",
- etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
- etheraddr_string(ndo, ADDR3));
+ GET_ETHERADDR_STRING(ADDR1), GET_ETHERADDR_STRING(ADDR2),
+ GET_ETHERADDR_STRING(ADDR3));
} else if (FC_TO_DS(fc) && !FC_FROM_DS(fc)) {
ND_PRINT("BSSID:%s SA:%s DA:%s ",
- etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
- etheraddr_string(ndo, ADDR3));
+ GET_ETHERADDR_STRING(ADDR1), GET_ETHERADDR_STRING(ADDR2),
+ GET_ETHERADDR_STRING(ADDR3));
} else if (FC_TO_DS(fc) && FC_FROM_DS(fc)) {
ND_PRINT("RA:%s TA:%s DA:%s SA:%s ",
- etheraddr_string(ndo, ADDR1), etheraddr_string(ndo, ADDR2),
- etheraddr_string(ndo, ADDR3), etheraddr_string(ndo, ADDR4));
+ GET_ETHERADDR_STRING(ADDR1), GET_ETHERADDR_STRING(ADDR2),
+ GET_ETHERADDR_STRING(ADDR3), GET_ETHERADDR_STRING(ADDR4));
}
#undef ADDR1
const struct mgmt_header_t *hp = (const struct mgmt_header_t *) p;
ND_PRINT("BSSID:%s DA:%s SA:%s ",
- etheraddr_string(ndo, (hp)->bssid), etheraddr_string(ndo, (hp)->da),
- etheraddr_string(ndo, (hp)->sa));
+ GET_ETHERADDR_STRING((hp)->bssid), GET_ETHERADDR_STRING((hp)->da),
+ GET_ETHERADDR_STRING((hp)->sa));
}
static void
switch (FC_SUBTYPE(fc)) {
case CTRL_BAR:
ND_PRINT(" RA:%s TA:%s CTL(%x) SEQ(%u) ",
- etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ra),
- etheraddr_string(ndo, ((const struct ctrl_bar_hdr_t *)p)->ta),
+ GET_ETHERADDR_STRING(((const struct ctrl_bar_hdr_t *)p)->ra),
+ GET_ETHERADDR_STRING(((const struct ctrl_bar_hdr_t *)p)->ta),
GET_LE_U_2(((const struct ctrl_bar_hdr_t *)p)->ctl),
GET_LE_U_2(((const struct ctrl_bar_hdr_t *)p)->seq));
break;
case CTRL_BA:
ND_PRINT("RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_ba_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_ba_hdr_t *)p)->ra));
break;
case CTRL_PS_POLL:
ND_PRINT("BSSID:%s TA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_ps_poll_hdr_t *)p)->bssid),
- etheraddr_string(ndo, ((const struct ctrl_ps_poll_hdr_t *)p)->ta));
+ GET_ETHERADDR_STRING(((const struct ctrl_ps_poll_hdr_t *)p)->bssid),
+ GET_ETHERADDR_STRING(((const struct ctrl_ps_poll_hdr_t *)p)->ta));
break;
case CTRL_RTS:
ND_PRINT("RA:%s TA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ra),
- etheraddr_string(ndo, ((const struct ctrl_rts_hdr_t *)p)->ta));
+ GET_ETHERADDR_STRING(((const struct ctrl_rts_hdr_t *)p)->ra),
+ GET_ETHERADDR_STRING(((const struct ctrl_rts_hdr_t *)p)->ta));
break;
case CTRL_CTS:
ND_PRINT("RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_cts_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_cts_hdr_t *)p)->ra));
break;
case CTRL_ACK:
ND_PRINT("RA:%s ",
- etheraddr_string(ndo, ((const struct ctrl_ack_hdr_t *)p)->ra));
+ GET_ETHERADDR_STRING(((const struct ctrl_ack_hdr_t *)p)->ra));
break;
case CTRL_CF_END:
ND_PRINT("RA:%s BSSID:%s ",
- etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->ra),
- etheraddr_string(ndo, ((const struct ctrl_end_hdr_t *)p)->bssid));
+ GET_ETHERADDR_STRING(((const struct ctrl_end_hdr_t *)p)->ra),
+ GET_ETHERADDR_STRING(((const struct ctrl_end_hdr_t *)p)->bssid));
break;
case CTRL_END_ACK:
ND_PRINT("RA:%s BSSID:%s ",
- etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->ra),
- etheraddr_string(ndo, ((const struct ctrl_end_ack_hdr_t *)p)->bssid));
+ GET_ETHERADDR_STRING(((const struct ctrl_end_ack_hdr_t *)p)->ra),
+ GET_ETHERADDR_STRING(((const struct ctrl_end_ack_hdr_t *)p)->bssid));
break;
default:
/* We shouldn't get here - we should already have quit */
ND_PRINT("MeshData (AE %u TTL %u seq %u", ae,
GET_U_1(mc->ttl), GET_LE_U_4(mc->seq));
if (ae > 0)
- ND_PRINT(" A4:%s", etheraddr_string(ndo, mc->addr4));
+ ND_PRINT(" A4:%s", GET_ETHERADDR_STRING(mc->addr4));
if (ae > 1)
- ND_PRINT(" A5:%s", etheraddr_string(ndo, mc->addr5));
+ ND_PRINT(" A5:%s", GET_ETHERADDR_STRING(mc->addr5));
if (ae > 2)
- ND_PRINT(" A6:%s", etheraddr_string(ndo, mc->addr6));
+ ND_PRINT(" A6:%s", GET_ETHERADDR_STRING(mc->addr6));
ND_PRINT(") ");
}
if (cp + 16 > ep)
goto invalid;
ND_TCHECK_16(cp);
- ND_PRINT("%s%s", sep, ip6addr_string(ndo, cp));
+ ND_PRINT("%s%s", sep, GET_IP6ADDR_STRING(cp));
cp += 16;
sep = ", ";
}
if (cp + 4 > ep)
goto invalid;
ND_TCHECK_4(cp);
- ND_PRINT("%s%s", sep, ipaddr_string(ndo, cp));
+ ND_PRINT("%s%s", sep, GET_IPADDR_STRING(cp));
cp += 4;
sep = ", ";
}
if (cp + 17 > ep)
goto invalid;
ND_TCHECK_LEN(cp, 17);
- ND_PRINT("%s%s/%u", sep, ip6addr_string(ndo, cp),
+ ND_PRINT("%s%s/%u", sep, GET_IP6ADDR_STRING(cp),
GET_U_1(cp + 16));
cp += 17;
sep = ", ";
if (cp + 5 > ep)
goto invalid;
ND_TCHECK_5(cp);
- ND_PRINT("%s%s/%u", sep, ipaddr_string(ndo, cp),
+ ND_PRINT("%s%s/%u", sep, GET_IPADDR_STRING(cp),
GET_U_1(cp + 4));
cp += 5;
sep = ", ";
cp += 4;
/* Source Id */
ND_TCHECK_8(cp);
- ND_PRINT(", Source Id %s", linkaddr_string(ndo, cp, LINKADDR_OTHER, 8));
+ ND_PRINT(", Source Id %s", GET_LINKADDR_STRING(cp, LINKADDR_OTHER, 8));
cp += 8;
/* Destination Id */
ND_TCHECK_8(cp);
- ND_PRINT(", Destination Id %s", linkaddr_string(ndo, cp, LINKADDR_OTHER, 8));
+ ND_PRINT(", Destination Id %s", GET_LINKADDR_STRING(cp, LINKADDR_OTHER, 8));
cp += 8;
}
/* Body */
GET_U_1(ap->rreq_type) & RREQ_UNKNOWN ? "[U] " : " ",
GET_U_1(ap->rreq_hops),
GET_BE_U_4(ap->rreq_id),
- ipaddr_string(ndo, ap->rreq_da),
+ GET_IPADDR_STRING(ap->rreq_da),
GET_BE_U_4(ap->rreq_ds),
- ipaddr_string(ndo, ap->rreq_oa),
+ GET_IPADDR_STRING(ap->rreq_oa),
GET_BE_U_4(ap->rreq_os));
i = length - sizeof(*ap);
if (i >= sizeof(struct aodv_ext))
GET_U_1(ap->rrep_type) & RREP_ACK ? "[A] " : " ",
GET_U_1(ap->rrep_ps) & RREP_PREFIX_MASK,
GET_U_1(ap->rrep_hops),
- ipaddr_string(ndo, ap->rrep_da),
+ GET_IPADDR_STRING(ap->rrep_da),
GET_BE_U_4(ap->rrep_ds),
- ipaddr_string(ndo, ap->rrep_oa),
+ GET_IPADDR_STRING(ap->rrep_oa),
GET_BE_U_4(ap->rrep_life));
i = length - sizeof(*ap);
if (i >= sizeof(struct aodv_ext))
ND_TCHECK_SIZE(dp);
if (i < sizeof(*dp))
goto trunc;
- ND_PRINT(" {%s}(%u)", ipaddr_string(ndo, dp->u_da),
+ ND_PRINT(" {%s}(%u)", GET_IPADDR_STRING(dp->u_da),
GET_BE_U_4(dp->u_ds));
dp++;
i -= sizeof(*dp);
GET_U_1(ap->rreq_type) & RREQ_UNKNOWN ? "[U] " : " ",
GET_U_1(ap->rreq_hops),
GET_BE_U_4(ap->rreq_id),
- ip6addr_string(ndo, ap->rreq_da),
+ GET_IP6ADDR_STRING(ap->rreq_da),
GET_BE_U_4(ap->rreq_ds),
- ip6addr_string(ndo, ap->rreq_oa),
+ GET_IP6ADDR_STRING(ap->rreq_oa),
GET_BE_U_4(ap->rreq_os));
i = length - sizeof(*ap);
if (i >= sizeof(struct aodv_ext))
GET_U_1(ap->rrep_type) & RREP_ACK ? "[A] " : " ",
GET_U_1(ap->rrep_ps) & RREP_PREFIX_MASK,
GET_U_1(ap->rrep_hops),
- ip6addr_string(ndo, ap->rrep_da),
+ GET_IP6ADDR_STRING(ap->rrep_da),
GET_BE_U_4(ap->rrep_ds),
- ip6addr_string(ndo, ap->rrep_oa),
+ GET_IP6ADDR_STRING(ap->rrep_oa),
GET_BE_U_4(ap->rrep_life));
i = length - sizeof(*ap);
if (i >= sizeof(struct aodv_ext))
ND_TCHECK_SIZE(dp6);
if (i < sizeof(*dp6))
goto trunc;
- ND_PRINT(" {%s}(%u)", ip6addr_string(ndo, dp6->u_da),
+ ND_PRINT(" {%s}(%u)", GET_IP6ADDR_STRING(dp6->u_da),
GET_BE_U_4(dp6->u_ds));
dp6++;
i -= sizeof(*dp6);
GET_U_1(ap->rreq_type) & RREQ_UNKNOWN ? "[U] " : " ",
GET_U_1(ap->rreq_hops),
GET_BE_U_4(ap->rreq_id),
- ip6addr_string(ndo, ap->rreq_da),
+ GET_IP6ADDR_STRING(ap->rreq_da),
GET_BE_U_4(ap->rreq_ds),
- ip6addr_string(ndo, ap->rreq_oa),
+ GET_IP6ADDR_STRING(ap->rreq_oa),
GET_BE_U_4(ap->rreq_os));
i = length - sizeof(*ap);
if (i >= sizeof(struct aodv_ext))
GET_U_1(ap->rrep_type) & RREP_ACK ? "[A] " : " ",
GET_U_1(ap->rrep_ps) & RREP_PREFIX_MASK,
GET_U_1(ap->rrep_hops),
- ip6addr_string(ndo, ap->rrep_da),
+ GET_IP6ADDR_STRING(ap->rrep_da),
GET_BE_U_4(ap->rrep_ds),
- ip6addr_string(ndo, ap->rrep_oa),
+ GET_IP6ADDR_STRING(ap->rrep_oa),
GET_BE_U_4(ap->rrep_life));
i = length - sizeof(*ap);
if (i >= sizeof(struct aodv_ext))
ND_TCHECK_SIZE(dp6);
if (i < sizeof(*dp6))
goto trunc;
- ND_PRINT(" {%s}(%u)", ip6addr_string(ndo, dp6->u_da),
+ ND_PRINT(" {%s}(%u)", GET_IP6ADDR_STRING(dp6->u_da),
GET_BE_U_4(dp6->u_ds));
dp6++;
i -= sizeof(*dp6);
cp += 1;
/* Ethernet Address */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
- ND_PRINT(", Ethernet Address: %s", etheraddr_string(ndo, cp));
+ ND_PRINT(", Ethernet Address: %s", GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
}
return;
/* addresses */
for (i = 0; i < nmacs; i++) {
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
- ND_PRINT("\n\tEthernet Address %u: %s", i, etheraddr_string(ndo, cp));
+ ND_PRINT("\n\tEthernet Address %u: %s", i, GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
}
return;
else if (PROTO_LEN(ap) != 4)
ND_PRINT("<wrong len>");
else
- ND_PRINT("%s", ipaddr_string(ndo, TPA(ap)));
+ ND_PRINT("%s", GET_IPADDR_STRING(TPA(ap)));
}
static void
else if (PROTO_LEN(ap) != 4)
ND_PRINT("<wrong len>");
else
- ND_PRINT("%s", ipaddr_string(ndo, SPA(ap)));
+ ND_PRINT("%s", GET_IPADDR_STRING(SPA(ap)));
}
static void
if (ha_len == 0)
ND_PRINT("<No address>");
else {
- ND_PRINT("%s", linkaddr_string(ndo, ha, LINKADDR_ATM, ha_len));
+ ND_PRINT("%s", GET_LINKADDR_STRING(ha, LINKADDR_ATM, ha_len));
if (srca_len != 0)
ND_PRINT(",%s",
- linkaddr_string(ndo, srca, LINKADDR_ATM, srca_len));
+ GET_LINKADDR_STRING(srca, LINKADDR_ATM, srca_len));
}
}
else if (ATMTPROTO_LEN(ap) != 4)
ND_PRINT("<wrong tplen>");
else
- ND_PRINT("%s", ipaddr_string(ndo, ATMTPA(ap)));
+ ND_PRINT("%s", GET_IPADDR_STRING(ATMTPA(ap)));
}
static void
else if (ATMSPROTO_LEN(ap) != 4)
ND_PRINT("<wrong splen>");
else
- ND_PRINT("%s", ipaddr_string(ndo, ATMSPA(ap)));
+ ND_PRINT("%s", GET_IPADDR_STRING(ATMSPA(ap)));
}
static void
/* if its ATM then call the ATM ARP printer
for Frame-relay ARP most of the fields
are similar to Ethernet so overload the Ethernet Printer
- and set the linkaddr type for linkaddr_string(ndo, ) accordingly */
+ and set the linkaddr type for GET_LINKADDR_STRING() accordingly */
switch(hrd) {
case ARPHRD_ATM2225:
tpaddr_print_ip(ndo, ap, pro);
if (isnonzero(ndo, (const u_char *)THA(ap), HRD_LEN(ap)))
ND_PRINT(" (%s)",
- linkaddr_string(ndo, THA(ap), linkaddr, HRD_LEN(ap)));
+ GET_LINKADDR_STRING(THA(ap), linkaddr, HRD_LEN(ap)));
ND_PRINT(" tell ");
spaddr_print_ip(ndo, ap, pro);
break;
case ARPOP_REPLY:
spaddr_print_ip(ndo, ap, pro);
ND_PRINT(" is-at %s",
- linkaddr_string(ndo, SHA(ap), linkaddr, HRD_LEN(ap)));
+ GET_LINKADDR_STRING(SHA(ap), linkaddr, HRD_LEN(ap)));
break;
case ARPOP_REVREQUEST:
ND_PRINT("who-is %s tell %s",
- linkaddr_string(ndo, THA(ap), linkaddr, HRD_LEN(ap)),
- linkaddr_string(ndo, SHA(ap), linkaddr, HRD_LEN(ap)));
+ GET_LINKADDR_STRING(THA(ap), linkaddr, HRD_LEN(ap)),
+ GET_LINKADDR_STRING(SHA(ap), linkaddr, HRD_LEN(ap)));
break;
case ARPOP_REVREPLY:
ND_PRINT("%s at ",
- linkaddr_string(ndo, THA(ap), linkaddr, HRD_LEN(ap)));
+ GET_LINKADDR_STRING(THA(ap), linkaddr, HRD_LEN(ap)));
tpaddr_print_ip(ndo, ap, pro);
break;
case ARPOP_INVREQUEST:
ND_PRINT("who-is %s tell %s",
- linkaddr_string(ndo, THA(ap), linkaddr, HRD_LEN(ap)),
- linkaddr_string(ndo, SHA(ap), linkaddr, HRD_LEN(ap)));
+ GET_LINKADDR_STRING(THA(ap), linkaddr, HRD_LEN(ap)),
+ GET_LINKADDR_STRING(SHA(ap), linkaddr, HRD_LEN(ap)));
break;
case ARPOP_INVREPLY:
ND_PRINT("%s at ",
- linkaddr_string(ndo, SHA(ap), linkaddr, HRD_LEN(ap)));
+ GET_LINKADDR_STRING(SHA(ap), linkaddr, HRD_LEN(ap)));
spaddr_print_ip(ndo, ap, pro);
break;
return;
case 2: /* response */
- ND_PRINT("reply %s is-at %s", AT(psaddr), etheraddr_string(ndo, ap->hsaddr));
+ ND_PRINT("reply %s is-at %s", AT(psaddr), GET_ETHERADDR_STRING(ap->hsaddr));
return;
case 3: /* probe (oy!) */
format_prefix(netdissect_options *ndo, const u_char *prefix, unsigned char plen)
{
static char buf[50];
+
+ /*
+ * prefix points to a buffer on the stack into which the prefix has
+ * been placed, so we can't use GET_IPADDR_STRING() or
+ * GET_IP6ADDR_STRING() on it.
+ */
if(plen >= 96 && memcmp(prefix, v4prefix, 12) == 0)
snprintf(buf, 50, "%s/%u", ipaddr_string(ndo, prefix + 12), plen - 96);
else
static const char *
format_address(netdissect_options *ndo, const u_char *prefix)
{
+ /*
+ * prefix points to a buffer on the stack into which the prefix has
+ * been placed, so we can't use GET_IPADDR_STRING() or
+ * GET_IP6ADDR_STRING() on it.
+ */
if(memcmp(prefix, v4prefix, 12) == 0)
return ipaddr_string(ndo, prefix + 12);
else
switch(addr_length) {
case (sizeof(nd_ipv4) << 3): /* 32 */
ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
- snprintf(pos, sizeof(addr), "%s", ipaddr_string(ndo, pptr));
+ snprintf(pos, sizeof(addr), "%s", GET_IPADDR_STRING(pptr));
break;
case (sizeof(nd_ipv6) << 3): /* 128 */
ND_TCHECK_LEN(pptr, sizeof(nd_ipv6));
- snprintf(pos, sizeof(addr), "%s", ip6addr_string(ndo, pptr));
+ snprintf(pos, sizeof(addr), "%s", GET_IP6ADDR_STRING(pptr));
break;
default:
snprintf(pos, sizeof(addr), "bogus address length %u", addr_length);
ND_PRINT("%u:%u (= %s)",
GET_BE_U_2(pptr + 2),
GET_BE_U_4(pptr + 4),
- ipaddr_string(ndo, pptr+4));
+ GET_IPADDR_STRING(pptr+4));
break;
case BGP_EXT_COM_RT_1:
case BGP_EXT_COM_L2VPN_RT_1:
case BGP_EXT_COM_VRF_RT_IMP:
ND_PRINT("%s:%u",
- ipaddr_string(ndo, pptr+2),
+ GET_IPADDR_STRING(pptr+2),
GET_BE_U_2(pptr + 6));
break;
case BGP_EXT_COM_VPN_ORIGIN4:
case BGP_EXT_COM_OSPF_RID:
case BGP_EXT_COM_OSPF_RID2:
- ND_PRINT("%s", ipaddr_string(ndo, pptr+2));
+ ND_PRINT("%s", GET_IPADDR_STRING(pptr+2));
break;
case BGP_EXT_COM_OSPF_RTYPE:
case BGP_EXT_COM_OSPF_RTYPE2:
ND_PRINT("area:%s, router-type:%s, metric-type:%s%s",
- ipaddr_string(ndo, pptr+2),
+ GET_IPADDR_STRING(pptr+2),
tok2str(bgp_extd_comm_ospf_rtype_values,
"unknown (0x%02x)",
GET_U_1((pptr + 6))),
ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
snprintf(buf, buflen, "RD: %s, VPN IP Address: %s, MC Group Address: %s",
- bgp_vpn_rd_print(ndo, rd), ipaddr_string(ndo, vpn_ip), ipaddr_string(ndo, pptr));
+ bgp_vpn_rd_print(ndo, rd), GET_IPADDR_STRING(vpn_ip), GET_IPADDR_STRING(pptr));
return MDT_VPN_NLRI_LEN + 1;
buf[0] = '\0';
stringlen = snprintf(buf, buflen, "RD: %s, BGPNH: %s",
bgp_vpn_rd_print(ndo, pptr),
- ipaddr_string(ndo, pptr+8));
+ GET_IPADDR_STRING(pptr+8));
UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
pptr += 12;
tlen -= 12;
ND_PRINT("invalid len");
else {
ND_TCHECK_4(tptr);
- ND_PRINT("%s", ipaddr_string(ndo, tptr));
+ ND_PRINT("%s", GET_IPADDR_STRING(tptr));
}
break;
case BGPTYPE_MULTI_EXIT_DISC:
if (len == 6) {
ND_PRINT(" AS #%s, origin %s",
as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_2(tptr)),
- ipaddr_string(ndo, tptr + 2));
+ GET_IPADDR_STRING(tptr + 2));
} else {
ND_PRINT(" AS #%s, origin %s",
as_printf(ndo, astostr, sizeof(astostr),
- GET_BE_U_4(tptr)), ipaddr_string(ndo, tptr + 4));
+ GET_BE_U_4(tptr)), GET_IPADDR_STRING(tptr + 4));
}
break;
case BGPTYPE_AGGREGATOR4:
ND_TCHECK_8(tptr);
ND_PRINT(" AS #%s, origin %s",
as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_4(tptr)),
- ipaddr_string(ndo, tptr + 4));
+ GET_IPADDR_STRING(tptr + 4));
break;
case BGPTYPE_COMMUNITIES:
if (len % 4) {
break;
}
ND_TCHECK_4(tptr);
- ND_PRINT("%s",ipaddr_string(ndo, tptr));
+ ND_PRINT("%s",GET_IPADDR_STRING(tptr));
break;
case BGPTYPE_CLUSTER_LIST:
if (len % 4) {
if (tlen < 4)
goto trunc;
ND_PRINT("%s%s",
- ipaddr_string(ndo, tptr),
+ GET_IPADDR_STRING(tptr),
(tlen>4) ? ", " : "");
tlen -=4;
tptr +=4;
tnhlen = 0;
} else {
ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
- ND_PRINT("%s",ipaddr_string(ndo, tptr));
+ ND_PRINT("%s",GET_IPADDR_STRING(tptr));
tptr += sizeof(nd_ipv4);
tnhlen -= sizeof(nd_ipv4);
tlen -= sizeof(nd_ipv4);
sizeof(nd_ipv4) + BGP_VPN_RD_LEN);
ND_PRINT("RD: %s, %s",
bgp_vpn_rd_print(ndo, tptr),
- ipaddr_string(ndo, tptr+BGP_VPN_RD_LEN));
+ GET_IPADDR_STRING(tptr+BGP_VPN_RD_LEN));
tptr += (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
tlen -= (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
tnhlen -= (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
tnhlen = 0;
} else {
ND_TCHECK_LEN(tptr, sizeof(nd_ipv6));
- ND_PRINT("%s", ip6addr_string(ndo, tptr));
+ ND_PRINT("%s", GET_IP6ADDR_STRING(tptr));
tptr += sizeof(nd_ipv6);
tlen -= sizeof(nd_ipv6);
tnhlen -= sizeof(nd_ipv6);
sizeof(nd_ipv6) + BGP_VPN_RD_LEN);
ND_PRINT("RD: %s, %s",
bgp_vpn_rd_print(ndo, tptr),
- ip6addr_string(ndo, tptr+BGP_VPN_RD_LEN));
+ GET_IP6ADDR_STRING(tptr+BGP_VPN_RD_LEN));
tptr += (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
tlen -= (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
tnhlen -= (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
tnhlen = 0;
} else {
ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
- ND_PRINT("%s", ipaddr_string(ndo, tptr));
+ ND_PRINT("%s", GET_IPADDR_STRING(tptr));
tptr += (sizeof(nd_ipv4));
tlen -= (sizeof(nd_ipv4));
tnhlen -= (sizeof(nd_ipv4));
case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
ND_TCHECK_LEN(tptr, tnhlen);
- ND_PRINT("%s", isonsap_string(ndo, tptr, tnhlen));
+ ND_PRINT("%s", GET_ISONSAP_STRING(tptr, tnhlen));
tptr += tnhlen;
tlen -= tnhlen;
tnhlen = 0;
ND_TCHECK_LEN(tptr, tnhlen);
ND_PRINT("RD: %s, %s",
bgp_vpn_rd_print(ndo, tptr),
- isonsap_string(ndo, tptr+BGP_VPN_RD_LEN,tnhlen-BGP_VPN_RD_LEN));
+ GET_ISONSAP_STRING(tptr+BGP_VPN_RD_LEN,tnhlen-BGP_VPN_RD_LEN));
/* rfc986 mapped IPv4 address ? */
if (GET_BE_U_4(tptr + BGP_VPN_RD_LEN) == 0x47000601)
- ND_PRINT(" = %s", ipaddr_string(ndo, tptr+BGP_VPN_RD_LEN+4));
+ ND_PRINT(" = %s", GET_IPADDR_STRING(tptr+BGP_VPN_RD_LEN+4));
/* rfc1888 mapped IPv6 address ? */
else if (GET_BE_U_3(tptr + BGP_VPN_RD_LEN) == 0x350000)
- ND_PRINT(" = %s", ip6addr_string(ndo, tptr+BGP_VPN_RD_LEN+3));
+ ND_PRINT(" = %s", GET_IP6ADDR_STRING(tptr+BGP_VPN_RD_LEN+3));
tptr += tnhlen;
tlen -= tnhlen;
tnhlen = 0;
case BGP_PMSI_TUNNEL_PIM_BIDIR:
ND_TCHECK_8(tptr);
ND_PRINT("\n\t Sender %s, P-Group %s",
- ipaddr_string(ndo, tptr),
- ipaddr_string(ndo, tptr+4));
+ GET_IPADDR_STRING(tptr),
+ GET_IPADDR_STRING(tptr+4));
break;
case BGP_PMSI_TUNNEL_PIM_SSM:
ND_TCHECK_8(tptr);
ND_PRINT("\n\t Root-Node %s, P-Group %s",
- ipaddr_string(ndo, tptr),
- ipaddr_string(ndo, tptr+4));
+ GET_IPADDR_STRING(tptr),
+ GET_IPADDR_STRING(tptr+4));
break;
case BGP_PMSI_TUNNEL_INGRESS:
ND_TCHECK_4(tptr);
ND_PRINT("\n\t Tunnel-Endpoint %s",
- ipaddr_string(ndo, tptr));
+ GET_IPADDR_STRING(tptr));
break;
case BGP_PMSI_TUNNEL_LDP_P2MP: /* fall through */
case BGP_PMSI_TUNNEL_LDP_MP2MP:
ND_TCHECK_8(tptr);
ND_PRINT("\n\t Root-Node %s, LSP-ID 0x%08x",
- ipaddr_string(ndo, tptr),
+ GET_IPADDR_STRING(tptr),
GET_BE_U_4(tptr + 4));
break;
case BGP_PMSI_TUNNEL_RSVP_P2MP:
ND_TCHECK_8(tptr);
ND_PRINT("\n\t Extended-Tunnel-ID %s, P2MP-ID 0x%08x",
- ipaddr_string(ndo, tptr),
+ GET_IPADDR_STRING(tptr),
GET_BE_U_4(tptr + 4));
break;
default:
as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_2(bgp_open_header->bgpo_myas)));
ND_PRINT("Holdtime %us, ",
GET_BE_U_2(bgp_open_header->bgpo_holdtime));
- ND_PRINT("ID %s", ipaddr_string(ndo, bgp_open_header->bgpo_id));
+ ND_PRINT("ID %s", GET_IPADDR_STRING(bgp_open_header->bgpo_id));
optslen = GET_U_1(bgp_open_header->bgpo_optlen);
ND_PRINT("\n\t Optional parameters, length: %u", optslen);
bp_hlen = GET_U_1(bp->bp_hlen);
if (bp_htype == 1 && bp_hlen == 6 && bp_op == BOOTPREQUEST) {
ND_TCHECK_6(bp->bp_chaddr);
- ND_PRINT(" from %s", etheraddr_string(ndo, bp->bp_chaddr));
+ ND_PRINT(" from %s", GET_ETHERADDR_STRING(bp->bp_chaddr));
}
ND_PRINT(", length %u", length);
/* Client's ip address */
ND_TCHECK_4(bp->bp_ciaddr);
if (GET_IPV4_TO_NETWORK_ORDER(bp->bp_ciaddr))
- ND_PRINT("\n\t Client-IP %s", ipaddr_string(ndo, bp->bp_ciaddr));
+ ND_PRINT("\n\t Client-IP %s", GET_IPADDR_STRING(bp->bp_ciaddr));
/* 'your' ip address (bootp client) */
ND_TCHECK_4(bp->bp_yiaddr);
if (GET_IPV4_TO_NETWORK_ORDER(bp->bp_yiaddr))
- ND_PRINT("\n\t Your-IP %s", ipaddr_string(ndo, bp->bp_yiaddr));
+ ND_PRINT("\n\t Your-IP %s", GET_IPADDR_STRING(bp->bp_yiaddr));
/* Server's ip address */
ND_TCHECK_4(bp->bp_siaddr);
if (GET_IPV4_TO_NETWORK_ORDER(bp->bp_siaddr))
- ND_PRINT("\n\t Server-IP %s", ipaddr_string(ndo, bp->bp_siaddr));
+ ND_PRINT("\n\t Server-IP %s", GET_IPADDR_STRING(bp->bp_siaddr));
/* Gateway's ip address */
ND_TCHECK_4(bp->bp_giaddr);
if (GET_IPV4_TO_NETWORK_ORDER(bp->bp_giaddr))
- ND_PRINT("\n\t Gateway-IP %s", ipaddr_string(ndo, bp->bp_giaddr));
+ ND_PRINT("\n\t Gateway-IP %s", GET_IPADDR_STRING(bp->bp_giaddr));
/* Client's Ethernet address */
if (bp_htype == 1 && bp_hlen == 6) {
ND_TCHECK_6(bp->bp_chaddr);
- ND_PRINT("\n\t Client-Ethernet-Address %s", etheraddr_string(ndo, bp->bp_chaddr));
+ ND_PRINT("\n\t Client-Ethernet-Address %s", GET_ETHERADDR_STRING(bp->bp_chaddr));
}
ND_TCHECK_1(bp->bp_sname); /* check first char only */
if (!first)
ND_PRINT(",");
if (c == 'i')
- ND_PRINT("%s", ipaddr_string(ndo, bp));
+ ND_PRINT("%s", GET_IPADDR_STRING(bp));
else if (c == 'L')
ND_PRINT("%d", GET_BE_S_4(bp));
else
while (len >= 2*4) {
if (!first)
ND_PRINT(",");
- ND_PRINT("(%s:", ipaddr_string(ndo, bp));
+ ND_PRINT("(%s:", GET_IPADDR_STRING(bp));
bp += 4;
len -= 4;
- ND_PRINT("%s)", ipaddr_string(ndo, bp));
+ ND_PRINT("%s)", GET_IPADDR_STRING(bp));
bp += 4;
len -= 4;
first = 0;
ND_PRINT(".0");
ND_PRINT("/%u", mask_width);
}
- ND_PRINT(":%s)", ipaddr_string(ndo, bp));
+ ND_PRINT(":%s)", GET_IPADDR_STRING(bp));
bp += 4;
len -= (significant_octets + 4);
first = 0;
#define PRINTCMUADDR(m, s) { ND_TCHECK_4(cmu->m); \
if (GET_IPV4_TO_NETWORK_ORDER(cmu->m) != 0) \
- ND_PRINT(" %s:%s", s, ipaddr_string(ndo, cmu->m)); }
+ ND_PRINT(" %s:%s", s, GET_IPADDR_STRING(cmu->m)); }
static void
cmu_print(netdissect_options *ndo,
ND_TCHECK_4(p);
if (p + 4 > endp)
goto trunc;
- ND_PRINT("IPv4 (%u) %s", num, ipaddr_string(ndo, p));
+ ND_PRINT("IPv4 (%u) %s", num, GET_IPADDR_STRING(p));
p += 4;
}
else if (pt == PT_IEEE_802_2 && pl == 8 &&
if (p + al > endp)
goto trunc;
- ND_PRINT("IPv6 (%u) %s", num, ip6addr_string(ndo, p));
+ ND_PRINT("IPv6 (%u) %s", num, GET_IP6ADDR_STRING(p));
p += al;
}
else {
hexdump = TRUE;
break;
}
- ND_PRINT(", %s", ipaddr_string(ndo, tptr + 1));
+ ND_PRINT(", %s", GET_IPADDR_STRING(tptr + 1));
break;
case AFNUM_INET6:
hexdump = TRUE;
break;
}
- ND_PRINT(", %s", ip6addr_string(ndo, tptr + 1));
+ ND_PRINT(", %s", GET_IP6ADDR_STRING(tptr + 1));
break;
default:
case CFM_CCM_MD_FORMAT_MAC:
if (md_namelength == 6) {
- ND_PRINT("\n\t MAC %s", etheraddr_string(ndo,
- md_name));
+ ND_PRINT("\n\t MAC %s", GET_ETHERADDR_STRING(md_name));
} else {
ND_PRINT("\n\t MAC (length invalid)");
}
GET_U_1(msg_ptr.cfm_ltm->ttl));
ND_PRINT("\n\t Original-MAC %s, Target-MAC %s",
- etheraddr_string(ndo, msg_ptr.cfm_ltm->original_mac),
- etheraddr_string(ndo, msg_ptr.cfm_ltm->target_mac));
+ GET_ETHERADDR_STRING(msg_ptr.cfm_ltm->original_mac),
+ GET_ETHERADDR_STRING(msg_ptr.cfm_ltm->target_mac));
break;
case CFM_OPCODE_LTR:
hexdump = TRUE;
break;
}
- ND_PRINT("\n\t MAC %s", etheraddr_string(ndo, tptr + 1));
+ ND_PRINT("\n\t MAC %s", GET_ETHERADDR_STRING(tptr + 1));
break;
case CFM_CHASSIS_ID_NETWORK_ADDRESS:
break;
case SLARP_REPLY:
ND_PRINT("reply %s/%s",
- ipaddr_string(ndo, slarp->un.addr.addr),
- ipaddr_string(ndo, slarp->un.addr.mask));
+ GET_IPADDR_STRING(slarp->un.addr.addr),
+ GET_IPADDR_STRING(slarp->un.addr.mask));
break;
case SLARP_KEEPALIVE:
ND_PRINT("keepalive: mineseen=0x%08x, yourseen=0x%08x, reliability=0x%04x",
break;
}
tp = (const u_char *)(dh6o + 1);
- ND_PRINT(" %s", ip6addr_string(ndo, tp));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(tp));
ND_PRINT(" pltime:%u vltime:%u",
GET_BE_U_4(tp + 16),
GET_BE_U_4(tp + 20));
}
tp = (const u_char *)(dh6o + 1);
for (i = 0; i < optlen; i += 16)
- ND_PRINT(" %s", ip6addr_string(ndo, tp + i));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(tp + i));
ND_PRINT(")");
break;
case DH6OPT_SIP_SERVER_D:
break;
}
tp = (const u_char *)(dh6o + 1);
- ND_PRINT(" %s/%u", ip6addr_string(ndo, tp + 9),
+ ND_PRINT(" %s/%u", GET_IP6ADDR_STRING(tp + 9),
GET_U_1(tp + 8));
ND_PRINT(" pltime:%u vltime:%u",
GET_BE_U_4(tp),
ND_PRINT(" type_%u", dh6_lq_query_type);
break;
}
- ND_PRINT(" %s", ip6addr_string(ndo, tp + 1));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(tp + 1));
if (optlen > 17) {
/* there are query-options */
dhcp6opt_print(ndo, tp + 17, tp + optlen);
break;
}
tp = (const u_char *)(dh6o + 1);
- ND_PRINT(" %s ", ip6addr_string(ndo, tp));
+ ND_PRINT(" %s ", GET_IP6ADDR_STRING(tp));
/*
* Print hex dump first 10 characters.
*/
ND_PRINT(" ?");
break;
}
- ND_PRINT(" %s", ip6addr_string(ndo, tp));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(tp));
break;
case DH6OPT_NTP_SUBOPTION_SRV_FQDN:
ND_PRINT(" ");
} else { /* relay messages */
ND_TCHECK_16(dh6relay->dh6relay_peeraddr);
- ND_PRINT("linkaddr=%s", ip6addr_string(ndo, dh6relay->dh6relay_linkaddr));
+ ND_PRINT("linkaddr=%s", GET_IP6ADDR_STRING(dh6relay->dh6relay_linkaddr));
- ND_PRINT(" peeraddr=%s", ip6addr_string(ndo, dh6relay->dh6relay_peeraddr));
+ ND_PRINT(" peeraddr=%s", GET_IP6ADDR_STRING(dh6relay->dh6relay_peeraddr));
dhcp6opt_print(ndo, (const u_char *)(dh6relay + 1), ep);
}
case DTP_NEIGHBOR_TLV:
if (len < 10)
goto invalid;
- ND_PRINT(", %s", etheraddr_string(ndo, tptr+4));
+ ND_PRINT(", %s", GET_ETHERADDR_STRING(tptr+4));
break;
default:
while ((len > 0) && (bp < ep)) {
ND_TCHECK_4(bp);
- ND_PRINT("\n\tneighbor %s", ipaddr_string(ndo, bp));
+ ND_PRINT("\n\tneighbor %s", GET_IPADDR_STRING(bp));
bp += 4; len -= 4;
}
return (0);
len -= 7;
while (--ncount >= 0) {
ND_TCHECK_4(bp);
- ND_PRINT(" [%s ->", ipaddr_string(ndo, laddr));
+ ND_PRINT(" [%s ->", GET_IPADDR_STRING(laddr));
ND_PRINT(" %s, (%u/%u)]",
- ipaddr_string(ndo, bp), metric, thresh);
+ GET_IPADDR_STRING(bp), metric, thresh);
bp += 4;
len -= 4;
}
bp++;
len -= 8;
while (--ncount >= 0 && (len >= 4) && (bp + 4) <= ep) {
- ND_PRINT(" [%s -> ", ipaddr_string(ndo, laddr));
- ND_PRINT("%s (%u/%u", ipaddr_string(ndo, bp),
+ ND_PRINT(" [%s -> ", GET_IPADDR_STRING(laddr));
+ ND_PRINT("%s (%u/%u", GET_IPADDR_STRING(bp),
metric, thresh);
if (flags & DVMRP_NF_TUNNEL)
ND_PRINT("/tunnel");
const u_char *bp)
{
ND_TCHECK_LEN(bp, 12);
- ND_PRINT(" src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4));
+ ND_PRINT(" src %s grp %s", GET_IPADDR_STRING(bp), GET_IPADDR_STRING(bp + 4));
bp += 8;
ND_PRINT(" timer ");
unsigned_relts_print(ndo, GET_BE_U_4(bp));
const u_char *bp)
{
ND_TCHECK_8(bp);
- ND_PRINT(" src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4));
+ ND_PRINT(" src %s grp %s", GET_IPADDR_STRING(bp), GET_IPADDR_STRING(bp + 4));
return (0);
trunc:
return (-1);
const u_char *bp)
{
ND_TCHECK_8(bp);
- ND_PRINT(" src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4));
+ ND_PRINT(" src %s grp %s", GET_IPADDR_STRING(bp), GET_IPADDR_STRING(bp + 4));
return (0);
trunc:
return (-1);
ND_PRINT(" state:%s", egp_status_updown[status]);
else
ND_PRINT(" [status %u]", status);
- ND_PRINT(" net:%s", ipaddr_string(ndo, egp->egp_sourcenet));
+ ND_PRINT(" net:%s", GET_IPADDR_STRING(egp->egp_sourcenet));
break;
case EGPT_UPDATE:
else
ND_PRINT(" [status %u]", status);
ND_PRINT(" %s int %u ext %u",
- ipaddr_string(ndo, egp->egp_sourcenet),
+ GET_IPADDR_STRING(egp->egp_sourcenet),
GET_U_1(egp->egp_intgw),
GET_U_1(egp->egp_extgw));
if (ndo->ndo_vflag)
GET_CPY_BYTES(prefix, tlv_ptr.eigrp_tlv_ip_int->destination, byte_length);
ND_PRINT("\n\t IPv4 prefix: %15s/%u, nexthop: ",
- ipaddr_string(ndo, prefix),
+ ipaddr_string(ndo, prefix), /* local buffer, not packet data; don't use GET_IPADDR_STRING() */
bit_length);
if (GET_BE_U_4(tlv_ptr.eigrp_tlv_ip_int->nexthop) == 0)
ND_PRINT("self");
else
ND_PRINT("%s",
- ipaddr_string(ndo, tlv_ptr.eigrp_tlv_ip_int->nexthop));
+ GET_IPADDR_STRING(tlv_ptr.eigrp_tlv_ip_int->nexthop));
ND_PRINT("\n\t delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
(GET_BE_U_4(tlv_ptr.eigrp_tlv_ip_int->delay)/100),
GET_CPY_BYTES(prefix, tlv_ptr.eigrp_tlv_ip_ext->destination, byte_length);
ND_PRINT("\n\t IPv4 prefix: %15s/%u, nexthop: ",
- ipaddr_string(ndo, prefix),
+ ipaddr_string(ndo, prefix), /* local buffer, not packet data; don't use GET_IPADDR_STRING() */
bit_length);
if (GET_BE_U_4(tlv_ptr.eigrp_tlv_ip_ext->nexthop) == 0)
ND_PRINT("self");
else
ND_PRINT("%s",
- ipaddr_string(ndo, tlv_ptr.eigrp_tlv_ip_ext->nexthop));
+ GET_IPADDR_STRING(tlv_ptr.eigrp_tlv_ip_ext->nexthop));
ND_PRINT("\n\t origin-router %s, origin-as %u, origin-proto %s, flags [0x%02x], tag 0x%08x, metric %u",
- ipaddr_string(ndo, tlv_ptr.eigrp_tlv_ip_ext->origin_router),
+ GET_IPADDR_STRING(tlv_ptr.eigrp_tlv_ip_ext->origin_router),
GET_BE_U_4(tlv_ptr.eigrp_tlv_ip_ext->origin_as),
tok2str(eigrp_ext_proto_id_values,"unknown",GET_U_1(tlv_ptr.eigrp_tlv_ip_ext->proto_id)),
GET_U_1(tlv_ptr.eigrp_tlv_ip_ext->flags),
const u_char *dst)
{
ND_PRINT("%s > %s, ",
- etheraddr_string(ndo, src), etheraddr_string(ndo, dst));
+ GET_ETHERADDR_STRING(src), GET_ETHERADDR_STRING(dst));
}
static void
uint32_t lat, lon;
ND_TCHECK_LEN(bp, GEONET_ADDR_LEN);
- ND_PRINT("GN_ADDR:%s ", linkaddr_string (ndo, bp, LINKADDR_OTHER, GEONET_ADDR_LEN));
+ ND_PRINT("GN_ADDR:%s ", GET_LINKADDR_STRING(bp, LINKADDR_OTHER, GEONET_ADDR_LEN));
ND_TCHECK_8(bp + 12);
lat = GET_BE_U_4(bp + 12);
format_ip6addr(netdissect_options *ndo, const u_char *cp)
{
if (is_ipv4_mapped_address(cp))
- return ipaddr_string(ndo, cp + IPV4_MAPPED_HEADING_LEN);
+ return GET_IPADDR_STRING(cp + IPV4_MAPPED_HEADING_LEN);
else
- return ip6addr_string(ndo, cp);
+ return GET_IP6ADDR_STRING(cp);
}
static int
return -1;
}
for (t = 0; t < optlen; t += 4)
- ND_PRINT(" %s", ipaddr_string(ndo, value + t));
+ ND_PRINT(" %s", GET_IPADDR_STRING(value + t));
}
break;
case DH4OPT_DOMAIN_SEARCH: {
return -1;
}
for (t = 0; t < optlen; t += 16)
- ND_PRINT(" %s", ip6addr_string(ndo, value + t));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(value + t));
}
break;
case DH6OPT_DOMAIN_LIST: {
ND_PRINT("[reserved=%u!] ", GET_U_1(hp->hsrp_reserved));
}
ND_TCHECK_4(hp->hsrp_virtaddr);
- ND_PRINT("addr=%s", ipaddr_string(ndo, hp->hsrp_virtaddr));
+ ND_PRINT("addr=%s", GET_IPADDR_STRING(hp->hsrp_virtaddr));
if (ndo->ndo_vflag) {
ND_PRINT(" hellotime=");
unsigned_relts_print(ndo, GET_U_1(hp->hsrp_hellotime));
case ICMP_UNREACH_NET:
(void)snprintf(buf, sizeof(buf),
"net %s unreachable",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_HOST:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_PROTOCOL:
ND_TCHECK_1(dp->icmp_ip.ip_p);
(void)snprintf(buf, sizeof(buf),
"%s protocol %u unreachable",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
GET_U_1(dp->icmp_ip.ip_p));
break;
case IPPROTO_TCP:
(void)snprintf(buf, sizeof(buf),
"%s tcp port %s unreachable",
- ipaddr_string(ndo, oip->ip_dst),
+ GET_IPADDR_STRING(oip->ip_dst),
tcpport_string(ndo, dport));
break;
case IPPROTO_UDP:
(void)snprintf(buf, sizeof(buf),
"%s udp port %s unreachable",
- ipaddr_string(ndo, oip->ip_dst),
+ GET_IPADDR_STRING(oip->ip_dst),
udpport_string(ndo, dport));
break;
default:
(void)snprintf(buf, sizeof(buf),
"%s protocol %u port %u unreachable",
- ipaddr_string(ndo, oip->ip_dst),
+ GET_IPADDR_STRING(oip->ip_dst),
ip_proto, dport);
break;
}
if (mtu) {
(void)snprintf(buf, sizeof(buf),
"%s unreachable - need to frag (mtu %u)",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst), mtu);
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst), mtu);
} else {
(void)snprintf(buf, sizeof(buf),
"%s unreachable - need to frag",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
}
}
break;
case ICMP_UNREACH_SRCFAIL:
(void)snprintf(buf, sizeof(buf),
"%s unreachable - source route failed",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_NET_UNKNOWN:
(void)snprintf(buf, sizeof(buf),
"net %s unreachable - unknown",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_HOST_UNKNOWN:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable - unknown",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_ISOLATED:
(void)snprintf(buf, sizeof(buf),
"%s unreachable - source host isolated",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_NET_PROHIB:
(void)snprintf(buf, sizeof(buf),
"net %s unreachable - admin prohibited",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_HOST_PROHIB:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable - admin prohibited",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_TOSNET:
(void)snprintf(buf, sizeof(buf),
"net %s unreachable - tos prohibited",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_TOSHOST:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable - tos prohibited",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_FILTER_PROHIB:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable - admin prohibited filter",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_HOST_PRECEDENCE:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable - host precedence violation",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
case ICMP_UNREACH_PRECEDENCE_CUTOFF:
(void)snprintf(buf, sizeof(buf),
"host %s unreachable - precedence cutoff",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst));
break;
default:
(void)snprintf(buf, sizeof(buf),
"%s unreachable - #%u",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
icmp_code);
break;
}
case ICMP_REDIRECT_NET:
(void)snprintf(buf, sizeof(buf),
"redirect %s to net %s",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
- ipaddr_string(ndo, dp->icmp_gwaddr));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_gwaddr));
break;
case ICMP_REDIRECT_HOST:
(void)snprintf(buf, sizeof(buf),
"redirect %s to host %s",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
- ipaddr_string(ndo, dp->icmp_gwaddr));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_gwaddr));
break;
case ICMP_REDIRECT_TOSNET:
(void)snprintf(buf, sizeof(buf),
"redirect-tos %s to net %s",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
- ipaddr_string(ndo, dp->icmp_gwaddr));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_gwaddr));
break;
case ICMP_REDIRECT_TOSHOST:
(void)snprintf(buf, sizeof(buf),
"redirect-tos %s to host %s",
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
- ipaddr_string(ndo, dp->icmp_gwaddr));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_gwaddr));
break;
default:
(void)snprintf(buf, sizeof(buf),
"redirect-#%u %s to %s", icmp_code,
- ipaddr_string(ndo, dp->icmp_ip.ip_dst),
- ipaddr_string(ndo, dp->icmp_gwaddr));
+ GET_IPADDR_STRING(dp->icmp_ip.ip_dst),
+ GET_IPADDR_STRING(dp->icmp_gwaddr));
break;
}
break;
while (num > 0) {
ND_TCHECK_SIZE(idp);
(void)snprintf(cp, sizeof(buf) - (cp - buf), " {%s %u}",
- ipaddr_string(ndo, idp->ird_addr),
+ GET_IPADDR_STRING(idp->ird_addr),
GET_BE_U_4(idp->ird_pref));
cp = buf + strlen(buf);
++idp;
case ICMP6_DST_UNREACH_NOROUTE: /* fall through */
case ICMP6_DST_UNREACH_ADMIN:
case ICMP6_DST_UNREACH_ADDR:
- ND_PRINT(" %s",ip6addr_string(ndo, oip->ip6_dst));
+ ND_PRINT(" %s",GET_IP6ADDR_STRING(oip->ip6_dst));
break;
case ICMP6_DST_UNREACH_BEYONDSCOPE:
ND_PRINT(" %s, source address %s",
- ip6addr_string(ndo, oip->ip6_dst),
- ip6addr_string(ndo, oip->ip6_src));
+ GET_IP6ADDR_STRING(oip->ip6_dst),
+ GET_IP6ADDR_STRING(oip->ip6_src));
break;
case ICMP6_DST_UNREACH_NOPORT:
if ((ouh = get_upperlayer(ndo, (const u_char *)oip, &prot))
switch (prot) {
case IPPROTO_TCP:
ND_PRINT(", %s tcp port %s",
- ip6addr_string(ndo, oip->ip6_dst),
+ GET_IP6ADDR_STRING(oip->ip6_dst),
tcpport_string(ndo, dport));
break;
case IPPROTO_UDP:
ND_PRINT(", %s udp port %s",
- ip6addr_string(ndo, oip->ip6_dst),
+ GET_IP6ADDR_STRING(oip->ip6_dst),
udpport_string(ndo, dport));
break;
default:
ND_PRINT(", %s protocol %u port %u unreachable",
- ip6addr_string(ndo, oip->ip6_dst),
+ GET_IP6ADDR_STRING(oip->ip6_dst),
prot, dport);
break;
}
switch (icmp6_code) {
case ICMP6_TIME_EXCEED_TRANSIT:
ND_PRINT(" for %s",
- ip6addr_string(ndo, oip->ip6_dst));
+ GET_IP6ADDR_STRING(oip->ip6_dst));
break;
case ICMP6_TIME_EXCEED_REASSEMBLY:
ND_PRINT(" (reassembly)");
const struct nd_neighbor_solicit *p;
p = (const struct nd_neighbor_solicit *)dp;
ND_TCHECK_16(p->nd_ns_target);
- ND_PRINT(", who has %s", ip6addr_string(ndo, p->nd_ns_target));
+ ND_PRINT(", who has %s", GET_IP6ADDR_STRING(p->nd_ns_target));
if (ndo->ndo_vflag) {
#define NDSOLLEN 24
if (icmp6_opt_print(ndo, (const u_char *)dp + NDSOLLEN,
p = (const struct nd_neighbor_advert *)dp;
ND_TCHECK_16(p->nd_na_target);
ND_PRINT(", tgt is %s",
- ip6addr_string(ndo, p->nd_na_target));
+ GET_IP6ADDR_STRING(p->nd_na_target));
if (ndo->ndo_vflag) {
ND_PRINT(", Flags [%s]",
bittok2str(icmp6_nd_na_flag_values,
p = (const struct nd_redirect *)dp;
ND_TCHECK_16(p->nd_rd_dst);
- ND_PRINT(", %s", ip6addr_string(ndo, p->nd_rd_dst));
+ ND_PRINT(", %s", GET_IP6ADDR_STRING(p->nd_rd_dst));
ND_TCHECK_16(p->nd_rd_target);
- ND_PRINT(" to %s", ip6addr_string(ndo, p->nd_rd_target));
+ ND_PRINT(" to %s", GET_IP6ADDR_STRING(p->nd_rd_target));
#define REDIRECTLEN 40
if (ndo->ndo_vflag) {
if (icmp6_opt_print(ndo, (const u_char *)dp + REDIRECTLEN,
p = (const u_char *)(dp + 1);
while (p < cp) {
ND_TCHECK_16(p);
- ND_PRINT(", %s", ip6addr_string(ndo, p));
+ ND_PRINT(", %s", GET_IP6ADDR_STRING(p));
p += 16;
}
}
opp = (const struct nd_opt_prefix_info *)op;
ND_TCHECK_16(opp->nd_opt_pi_prefix);
ND_PRINT("%s/%u%s, Flags [%s], valid time %s",
- ip6addr_string(ndo, opp->nd_opt_pi_prefix),
+ GET_IP6ADDR_STRING(opp->nd_opt_pi_prefix),
GET_U_1(opp->nd_opt_pi_prefix_len),
(opt_len != 4) ? "badlen" : "",
bittok2str(icmp6_opt_pi_flag_values, "none", GET_U_1(opp->nd_opt_pi_flags_reserved)),
for (i = 0; i < l; i++) {
ND_TCHECK_16(oprd->nd_opt_rdnss_addr[i]);
ND_PRINT(" addr: %s",
- ip6addr_string(ndo, oprd->nd_opt_rdnss_addr[i]));
+ GET_IP6ADDR_STRING(oprd->nd_opt_rdnss_addr[i]));
}
break;
case ND_OPT_DNSSL:
return;
ND_PRINT("max resp delay: %u ", GET_BE_U_2(mp->mld6_maxdelay));
- ND_PRINT("addr: %s", ip6addr_string(ndo, mp->mld6_addr));
+ ND_PRINT("addr: %s", GET_IP6ADDR_STRING(mp->mld6_addr));
}
static void
return;
}
ND_TCHECK_LEN(bp + 4 + group, sizeof(nd_ipv6));
- ND_PRINT(" [gaddr %s", ip6addr_string(ndo, bp + group + 4));
+ ND_PRINT(" [gaddr %s", GET_IP6ADDR_STRING(bp + group + 4));
ND_PRINT(" %s", tok2str(mldv2report2str, " [v2-report-#%u]",
GET_U_1(bp + group)));
nsrcs = GET_BE_U_2(bp + group + 2);
for (j = 0; j < nsrcs; j++) {
ND_TCHECK_LEN(bp + group + 20 + (j * sizeof(nd_ipv6)),
sizeof(nd_ipv6));
- ND_PRINT(" %s", ip6addr_string(ndo, bp + group + 20 + (j * sizeof(nd_ipv6))));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(bp + group + 20 + (j * sizeof(nd_ipv6))));
}
ND_PRINT(" }");
}
ND_PRINT(" [max resp delay=%u]", mrt);
}
ND_TCHECK_LEN(bp + 8, sizeof(nd_ipv6));
- ND_PRINT(" [gaddr %s", ip6addr_string(ndo, bp + 8));
+ ND_PRINT(" [gaddr %s", GET_IP6ADDR_STRING(bp + 8));
if (ndo->ndo_vflag) {
ND_TCHECK_1(bp + 25);
for (i = 0; i < nsrcs; i++) {
ND_TCHECK_LEN(bp + 28 + (i * sizeof(nd_ipv6)),
sizeof(nd_ipv6));
- ND_PRINT(" %s", ip6addr_string(ndo, bp + 28 + (i * sizeof(nd_ipv6))));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(bp + 28 + (i * sizeof(nd_ipv6))));
}
ND_PRINT(" }");
} else
break;
}
ND_PRINT(", subject=%s",
- ip6addr_string(ndo, cp));
+ GET_IP6ADDR_STRING(cp));
break;
case ICMP6_NI_SUBJ_FQDN:
ND_PRINT(", subject=DNS name");
break;
}
ND_PRINT(", subject=%s",
- ipaddr_string(ndo, cp));
+ GET_IPADDR_STRING(cp));
break;
default:
ND_PRINT(", unknown subject");
if (i + sizeof(uint32_t) + sizeof(nd_ipv6) > siz)
break;
ND_PRINT(" %s(%u)",
- ip6addr_string(ndo, bp + i + sizeof(uint32_t)),
+ GET_IP6ADDR_STRING(bp + i + sizeof(uint32_t)),
GET_BE_U_4(bp + i));
i += sizeof(uint32_t) + sizeof(nd_ipv6);
}
}
ND_PRINT("mtrace %u: %s to %s reply-to %s",
GET_BE_U_3(tr->tr_qid),
- ipaddr_string(ndo, tr->tr_src), ipaddr_string(ndo, tr->tr_dst),
- ipaddr_string(ndo, tr->tr_raddr));
+ GET_IPADDR_STRING(tr->tr_src), GET_IPADDR_STRING(tr->tr_dst),
+ GET_IPADDR_STRING(tr->tr_raddr));
if (IN_CLASSD(GET_BE_U_4(tr->tr_raddr)))
ND_PRINT(" with-ttl %u", GET_U_1(tr->tr_rttl));
return;
}
ND_PRINT("mresp %u: %s to %s reply-to %s",
GET_BE_U_3(tr->tr_qid),
- ipaddr_string(ndo, tr->tr_src), ipaddr_string(ndo, tr->tr_dst),
- ipaddr_string(ndo, tr->tr_raddr));
+ GET_IPADDR_STRING(tr->tr_src), GET_IPADDR_STRING(tr->tr_dst),
+ GET_IPADDR_STRING(tr->tr_raddr));
if (IN_CLASSD(GET_BE_U_4(tr->tr_raddr)))
ND_PRINT(" with-ttl %u", GET_U_1(tr->tr_rttl));
return;
return;
}
ND_TCHECK_4(bp + (group + 4));
- ND_PRINT(" [gaddr %s", ipaddr_string(ndo, bp + group + 4));
+ ND_PRINT(" [gaddr %s", GET_IPADDR_STRING(bp + group + 4));
ND_PRINT(" %s", tok2str(igmpv3report2str, " [v3-report-#%u]",
GET_U_1(bp + group)));
nsrcs = GET_BE_U_2(bp + group + 2);
ND_PRINT(" {");
for (j=0; j<nsrcs; j++) {
ND_TCHECK_4(bp + (group + 8 + (j << 2)));
- ND_PRINT(" %s", ipaddr_string(ndo, bp + group + 8 + (j << 2)));
+ ND_PRINT(" %s", GET_IPADDR_STRING(bp + group + 8 + (j << 2)));
}
ND_PRINT(" }");
}
ND_TCHECK_4(bp + 4);
if (GET_BE_U_4(bp + 4) == 0)
return;
- ND_PRINT(" [gaddr %s", ipaddr_string(ndo, bp + 4));
+ ND_PRINT(" [gaddr %s", GET_IPADDR_STRING(bp + 4));
ND_TCHECK_2(bp + 10);
nsrcs = GET_BE_U_2(bp + 10);
if (nsrcs > 0) {
ND_PRINT(" {");
for (i=0; i<nsrcs; i++) {
ND_TCHECK_4(bp + (12 + (i << 2)));
- ND_PRINT(" %s", ipaddr_string(ndo, bp + 12 + (i << 2)));
+ ND_PRINT(" %s", GET_IPADDR_STRING(bp + 12 + (i << 2)));
}
ND_PRINT(" }");
} else
ND_PRINT(" v1");
ND_TCHECK_4(bp + 4);
if (GET_BE_U_4(bp + 4))
- ND_PRINT(" [gaddr %s]", ipaddr_string(ndo, bp + 4));
+ ND_PRINT(" [gaddr %s]", GET_IPADDR_STRING(bp + 4));
if (len != 8)
ND_PRINT(" [len %u]", len);
}
break;
case 0x12:
ND_TCHECK_4(bp + 4);
- ND_PRINT("igmp v1 report %s", ipaddr_string(ndo, bp + 4));
+ ND_PRINT("igmp v1 report %s", GET_IPADDR_STRING(bp + 4));
if (len != 8)
ND_PRINT(" [len %u]", len);
break;
case 0x16:
ND_TCHECK_4(bp + 4);
- ND_PRINT("igmp v2 report %s", ipaddr_string(ndo, bp + 4));
+ ND_PRINT("igmp v2 report %s", GET_IPADDR_STRING(bp + 4));
break;
case 0x22:
ND_PRINT("igmp v3 report");
break;
case 0x17:
ND_TCHECK_4(bp + 4);
- ND_PRINT("igmp leave %s", ipaddr_string(ndo, bp + 4));
+ ND_PRINT("igmp leave %s", GET_IPADDR_STRING(bp + 4));
break;
case 0x13:
ND_PRINT("igmp dvmrp");
for (len = 3; len < length; len += 4) {
ND_TCHECK_4(cp + len);
- ND_PRINT(" %s", ipaddr_string(ndo, cp + len));
+ ND_PRINT(" %s", GET_IPADDR_STRING(cp + len));
if (ptr > len)
ND_PRINT(",");
}
type = " ^ ";
ND_TCHECK_LEN(cp + len, hoplen);
ND_PRINT("%s%u@%s", type, GET_BE_U_4(cp + len + hoplen - 4),
- hoplen!=8 ? "" : ipaddr_string(ndo, cp + len));
+ hoplen!=8 ? "" : GET_IPADDR_STRING(cp + len));
type = " ";
}
ND_PRINT(")\n ");
if (truncated) {
ND_PRINT("%s > %s: ",
- ipaddr_string(ndo, ip->ip_src),
- ipaddr_string(ndo, ip->ip_dst));
+ GET_IPADDR_STRING(ip->ip_src),
+ GET_IPADDR_STRING(ip->ip_dst));
nd_print_trunc(ndo);
nd_pop_packet_info(ndo);
return;
if (nh != IPPROTO_TCP && nh != IPPROTO_UDP &&
nh != IPPROTO_SCTP && nh != IPPROTO_DCCP) {
ND_PRINT("%s > %s: ",
- ipaddr_string(ndo, ip->ip_src),
- ipaddr_string(ndo, ip->ip_dst));
+ GET_IPADDR_STRING(ip->ip_src),
+ GET_IPADDR_STRING(ip->ip_dst));
}
ip_print_demux(ndo, (const u_char *)ip + hlen, len, 4,
off & IP_MF, GET_U_1(ip->ip_ttl), nh, bp);
* next level protocol header. print the ip addr
* and the protocol.
*/
- ND_PRINT("%s > %s:", ipaddr_string(ndo, ip->ip_src),
- ipaddr_string(ndo, ip->ip_dst));
+ ND_PRINT("%s > %s:", GET_IPADDR_STRING(ip->ip_src),
+ GET_IPADDR_STRING(ip->ip_dst));
if (!ndo->ndo_nflag && (p_name = netdb_protoname(ip_proto)) != NULL)
ND_PRINT(" %s", p_name);
else
if (cp == (const u_char *)(ip6 + 1) &&
nh != IPPROTO_TCP && nh != IPPROTO_UDP &&
nh != IPPROTO_DCCP && nh != IPPROTO_SCTP) {
- ND_PRINT("%s > %s: ", ip6addr_string(ndo, ip6->ip6_src),
- ip6addr_string(ndo, ip6->ip6_dst));
+ ND_PRINT("%s > %s: ", GET_IP6ADDR_STRING(ip6->ip6_src),
+ GET_IP6ADDR_STRING(ip6->ip6_dst));
}
switch (nh) {
goto trunc;
}
if (ndo->ndo_vflag) {
- ND_PRINT("(homeaddr: %s", ip6addr_string(ndo, bp + i + 2));
+ ND_PRINT("(homeaddr: %s", GET_IP6ADDR_STRING(bp + i + 2));
if (GET_U_1(bp + i + 1) > IP6OPT_HOMEADDR_MINLEN - 2) {
if (ip6_sopt_print(ndo, bp + i + IP6OPT_HOMEADDR_MINLEN,
(optlen - IP6OPT_HOMEADDR_MINLEN)) == -1)
if (len < 4)
ND_PRINT(" len=%u [bad: < 4]", len);
else
- ND_PRINT(" len=%u %s", len, ipaddr_string(ndo, data));
+ ND_PRINT(" len=%u %s", len, GET_IPADDR_STRING(data));
len = 0;
break;
case IPSECDOI_ID_FQDN:
else {
mask = data + sizeof(nd_ipv4);
ND_PRINT(" len=%u %s/%u.%u.%u.%u", len,
- ipaddr_string(ndo, data),
+ GET_IPADDR_STRING(data),
GET_U_1(mask), GET_U_1(mask + 1),
GET_U_1(mask + 2),
GET_U_1(mask + 3));
if (len < 16)
ND_PRINT(" len=%u [bad: < 16]", len);
else
- ND_PRINT(" len=%u %s", len, ip6addr_string(ndo, data));
+ ND_PRINT(" len=%u %s", len, GET_IP6ADDR_STRING(data));
len = 0;
break;
case IPSECDOI_ID_IPV6_ADDR_SUBNET:
mask = (const u_char *)(data + sizeof(nd_ipv6));
/*XXX*/
ND_PRINT(" len=%u %s/0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", len,
- ip6addr_string(ndo, data),
+ GET_IP6ADDR_STRING(data),
GET_U_1(mask), GET_U_1(mask + 1),
GET_U_1(mask + 2),
GET_U_1(mask + 3),
ND_PRINT(" len=%u [bad: < 8]", len);
else {
ND_PRINT(" len=%u %s-%s", len,
- ipaddr_string(ndo, data),
- ipaddr_string(ndo, data + sizeof(nd_ipv4)));
+ GET_IPADDR_STRING(data),
+ GET_IPADDR_STRING(data + sizeof(nd_ipv4)));
}
len = 0;
break;
ND_PRINT(" len=%u [bad: < 32]", len);
else {
ND_PRINT(" len=%u %s-%s", len,
- ip6addr_string(ndo, data),
- ip6addr_string(ndo, data + sizeof(nd_ipv6)));
+ GET_IP6ADDR_STRING(data),
+ GET_IP6ADDR_STRING(data + sizeof(nd_ipv6)));
}
len = 0;
break;
if (ndo->ndo_vflag < 1) {
ND_PRINT("%s%s > %s, %s, length %u",
ndo->ndo_eflag ? "" : ", ",
- isonsap_string(ndo, source_address, source_address_length),
- isonsap_string(ndo, dest_address, dest_address_length),
+ GET_ISONSAP_STRING(source_address, source_address_length),
+ GET_ISONSAP_STRING(dest_address, dest_address_length),
tok2str(clnp_pdu_values,"unknown (%u)",clnp_pdu_type),
length);
return (1);
ND_PRINT("\n\tsource address (length %u): %s\n\tdest address (length %u): %s",
source_address_length,
- isonsap_string(ndo, source_address, source_address_length),
+ GET_ISONSAP_STRING(source_address, source_address_length),
dest_address_length,
- isonsap_string(ndo, dest_address, dest_address_length));
+ GET_ISONSAP_STRING(dest_address, dest_address_length));
if (clnp_flags & CLNP_SEGMENT_PART) {
if (li_remaining < sizeof(struct clnp_segment_header_t)) {
source_address_length);
ND_PRINT("\n\t NSAP address (length %u): %s",
source_address_length,
- isonsap_string(ndo, source_address, source_address_length));
+ GET_ISONSAP_STRING(source_address, source_address_length));
}
tlen-=source_address_length+1;
}
dst = pptr;
pptr += dstl;
li -= dstl;
- ND_PRINT("\n\t %s", isonsap_string(ndo, dst, dstl));
+ ND_PRINT("\n\t %s", GET_ISONSAP_STRING(dst, dstl));
ND_TCHECK_1(pptr);
if (li < 1) {
if (snpal == 6)
ND_PRINT("\n\t SNPA (length: %u): %s",
snpal,
- etheraddr_string(ndo, snpa));
+ GET_ETHERADDR_STRING(snpa));
else
ND_PRINT("\n\t SNPA (length: %u): %s",
snpal,
- linkaddr_string(ndo, snpa, LINKADDR_OTHER, snpal));
+ GET_LINKADDR_STRING(snpa, LINKADDR_OTHER, snpal));
if (netal != 0)
ND_PRINT("\n\t NET (length: %u) %s",
netal,
- isonsap_string(ndo, neta, netal));
+ GET_ISONSAP_STRING(neta, netal));
break;
}
}
ND_PRINT("\n\t NET (length: %u): %s",
source_address_length,
- isonsap_string(ndo, pptr, source_address_length));
+ GET_ISONSAP_STRING(pptr, source_address_length));
pptr += source_address_length;
li -= source_address_length;
source_address_number--;
ND_PRINT(", bad ish/li");
return;
}
- ND_PRINT("\n\t NET (length: %u): %s", source_address_length, isonsap_string(ndo, pptr, source_address_length));
+ ND_PRINT("\n\t NET (length: %u): %s", source_address_length, GET_ISONSAP_STRING(pptr, source_address_length));
pptr += source_address_length;
li -= source_address_length;
break;
if (prefix_len == -1)
ND_PRINT("%sIPv4 prefix: %s mask %s",
ident,
- ipaddr_string(ndo, (tlv_ip_reach->prefix)),
- ipaddr_string(ndo, (tlv_ip_reach->mask)));
+ GET_IPADDR_STRING(tlv_ip_reach->prefix),
+ GET_IPADDR_STRING(tlv_ip_reach->mask));
else
ND_PRINT("%sIPv4 prefix: %15s/%u",
ident,
- ipaddr_string(ndo, (tlv_ip_reach->prefix)),
+ GET_IPADDR_STRING(tlv_ip_reach->prefix),
prefix_len);
ND_PRINT(", Distribution: %s, Metric: %u, %s",
case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
if (subtlv_len >= sizeof(nd_ipv4))
- ND_PRINT(", %s", ipaddr_string(ndo, tptr));
+ ND_PRINT(", %s", GET_IPADDR_STRING(tptr));
break;
case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:
if (afi == AF_INET)
ND_PRINT("%sIPv4 prefix: %15s/%u",
ident,
- ipaddr_string(ndo, prefix),
+ ipaddr_string(ndo, prefix), /* local buffer, not packet data; don't use GET_IPADDR_STRING() */
bit_length);
else if (afi == AF_INET6)
ND_PRINT("%sIPv6 prefix: %s/%u",
ident,
- ip6addr_string(ndo, prefix),
+ ip6addr_string(ndo, prefix), /* local buffer, not packet data; don't use GET_IP6ADDR_STRING() */
bit_length);
ND_PRINT(", Distribution: %s, Metric: %u",
ND_TCHECK_LEN(tptr, alen);
ND_PRINT("\n\t Area address (length: %u): %s",
alen,
- isonsap_string(ndo, tptr, alen));
+ GET_ISONSAP_STRING(tptr, alen));
tptr += alen;
tlen -= alen;
}
ND_TCHECK_LEN(tptr, sizeof(nd_ipv6));
ND_PRINT("\n\t IPv6 interface address: %s",
- ip6addr_string(ndo, tptr));
+ GET_IP6ADDR_STRING(tptr));
tptr += sizeof(nd_ipv6);
tlen -= sizeof(nd_ipv6);
if (tlen < sizeof(nd_ipv4))
goto tlv_trunc;
ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
- ND_PRINT("\n\t Traffic Engineering Router ID: %s", ipaddr_string(ndo, pptr));
+ ND_PRINT("\n\t Traffic Engineering Router ID: %s", GET_IPADDR_STRING(pptr));
break;
case ISIS_TLV_IPADDR:
if (tlen < sizeof(nd_ipv4))
goto tlv_trunc;
ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
- ND_PRINT("\n\t IPv4 interface address: %s", ipaddr_string(ndo, tptr));
+ ND_PRINT("\n\t IPv4 interface address: %s", GET_IPADDR_STRING(tptr));
tptr += sizeof(nd_ipv4);
tlen -= sizeof(nd_ipv4);
}
if (tlen < sizeof(nd_ipv4))
break;
ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
- ND_PRINT("\n\t IPv4 interface address: %s", ipaddr_string(ndo, tptr));
+ ND_PRINT("\n\t IPv4 interface address: %s", GET_IPADDR_STRING(tptr));
tptr+=sizeof(nd_ipv4);
tlen-=sizeof(nd_ipv4);
if (tlen < sizeof(nd_ipv4))
break;
ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
- ND_PRINT("\n\t IPv4 neighbor address: %s", ipaddr_string(ndo, tptr));
+ ND_PRINT("\n\t IPv4 neighbor address: %s", GET_IPADDR_STRING(tptr));
tptr+=sizeof(nd_ipv4);
tlen-=sizeof(nd_ipv4);
break;
ND_TCHECK_LEN(tptr, prefix_len / 2);
ND_PRINT("\n\t\tAddress: %s/%u",
- isonsap_string(ndo, tptr, prefix_len / 2), prefix_len * 4);
+ GET_ISONSAP_STRING(tptr, prefix_len / 2), prefix_len * 4);
tptr+=prefix_len/2;
tlen-=prefix_len/2;
}
break;
}
ND_TCHECK_5(tptr); /* router-id + flags */
- ND_PRINT("\n\t\tRouter-id: %s", ipaddr_string(ndo, tptr));
+ ND_PRINT("\n\t\tRouter-id: %s", GET_IPADDR_STRING(tptr));
ND_PRINT("\n\t\tFlags: [%s]",
bittok2str(isis_tlv_router_capability_flags,
"none",
tok2str(juniper_ipsec_type_values,"Unknown",GET_U_1(ih->type)),
GET_U_1(ih->type),
GET_BE_U_4(ih->spi),
- ipaddr_string(ndo, ih->src_ip),
- ipaddr_string(ndo, ih->dst_ip),
+ GET_IPADDR_STRING(ih->src_ip),
+ GET_IPADDR_STRING(ih->dst_ip),
l2info.length);
} else {
ND_PRINT("ES SA, index %u, ttl %u type %s (%u), length %u\n",
switch (eid_afi) {
case IPv4_AFI:
ND_TCHECK_4(packet_iterator + packet_offset);
- ND_PRINT(" EID %s/%u,", ipaddr_string(ndo,
- packet_iterator + packet_offset), mask_len);
+ ND_PRINT(" EID %s/%u,",
+ GET_IPADDR_STRING(packet_iterator + packet_offset),
+ mask_len);
packet_offset += 4;
break;
case IPv6_AFI:
ND_TCHECK_16(packet_iterator + packet_offset);
- ND_PRINT(" EID %s/%u,", ip6addr_string(ndo,
- packet_iterator + packet_offset), mask_len);
+ ND_PRINT(" EID %s/%u,",
+ GET_IP6ADDR_STRING(packet_iterator + packet_offset),
+ mask_len);
packet_offset += 16;
break;
default:
switch (loc_afi) {
case IPv4_AFI:
ND_TCHECK_4(packet_iterator + packet_offset);
- ND_PRINT(" LOC %s", ipaddr_string(ndo, loc_ip_pointer));
+ ND_PRINT(" LOC %s", GET_IPADDR_STRING(loc_ip_pointer));
packet_offset += 4;
break;
case IPv6_AFI:
ND_TCHECK_16(packet_iterator + packet_offset);
- ND_PRINT(" LOC %s", ip6addr_string(ndo, loc_ip_pointer));
+ ND_PRINT(" LOC %s", GET_IP6ADDR_STRING(loc_ip_pointer));
packet_offset += 16;
break;
default:
if (tlv_len < 1+6) {
goto trunc;
}
- ND_PRINT("%s", etheraddr_string(ndo, tptr + 1));
+ ND_PRINT("%s", GET_ETHERADDR_STRING(tptr + 1));
break;
case LLDP_CHASSIS_INTF_NAME_SUBTYPE: /* fall through */
if (tlv_len < 1+6) {
goto trunc;
}
- ND_PRINT("%s", etheraddr_string(ndo, tptr + 1));
+ ND_PRINT("%s", GET_ETHERADDR_STRING(tptr + 1));
break;
case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */
break;
}
ND_PRINT("\n\t IPv4 Link ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_4(obj_tptr));
break;
case LMP_CTYPE_IPV6_LOC:
break;
}
ND_PRINT("\n\t IPv6 Link ID: %s (0x%08x)",
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_4(obj_tptr));
break;
case LMP_CTYPE_UNMD_LOC:
break;
}
ND_PRINT("\n\t Node ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_4(obj_tptr));
break;
ND_PRINT("\n\t Local Link-ID: %s (0x%08x)"
"\n\t Remote Link-ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr+4),
+ GET_IPADDR_STRING(obj_tptr+4),
GET_BE_U_4(obj_tptr + 4),
- ipaddr_string(ndo, obj_tptr+8),
+ GET_IPADDR_STRING(obj_tptr+8),
GET_BE_U_4(obj_tptr + 8));
break;
ND_PRINT("\n\t Local Link-ID: %s (0x%08x)"
"\n\t Remote Link-ID: %s (0x%08x)",
- ip6addr_string(ndo, obj_tptr+4),
+ GET_IP6ADDR_STRING(obj_tptr+4),
GET_BE_U_4(obj_tptr + 4),
- ip6addr_string(ndo, obj_tptr+20),
+ GET_IP6ADDR_STRING(obj_tptr+20),
GET_BE_U_4(obj_tptr + 20));
break;
GET_U_1(obj_tptr)));
ND_PRINT("\n\t Local Interface ID: %s (0x%08x)"
"\n\t Remote Interface ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr+4),
+ GET_IPADDR_STRING(obj_tptr+4),
GET_BE_U_4(obj_tptr + 4),
- ipaddr_string(ndo, obj_tptr+8),
+ GET_IPADDR_STRING(obj_tptr+8),
GET_BE_U_4(obj_tptr + 8));
if (lmp_print_data_link_subobjs(ndo, obj_tptr, obj_tlen - 12, 12))
GET_U_1(obj_tptr)));
ND_PRINT("\n\t Local Interface ID: %s (0x%08x)"
"\n\t Remote Interface ID: %s (0x%08x)",
- ip6addr_string(ndo, obj_tptr+4),
+ GET_IP6ADDR_STRING(obj_tptr+4),
GET_BE_U_4(obj_tptr + 4),
- ip6addr_string(ndo, obj_tptr+20),
+ GET_IP6ADDR_STRING(obj_tptr+20),
GET_BE_U_4(obj_tptr + 20));
if (lmp_print_data_link_subobjs(ndo, obj_tptr, obj_tlen - 36, 36))
/* Decode pairs: <Interface_ID (4 bytes), Channel_status (4 bytes)> */
while (offset+8 <= obj_tlen) {
ND_PRINT("\n\t Interface ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr+offset),
+ GET_IPADDR_STRING(obj_tptr+offset),
GET_BE_U_4(obj_tptr + offset));
ND_PRINT("\n\t\t Active: %s (%u)",
/* Decode pairs: <Interface_ID (16 bytes), Channel_status (4 bytes)> */
while (offset+20 <= obj_tlen) {
ND_PRINT("\n\t Interface ID: %s (0x%08x)",
- ip6addr_string(ndo, obj_tptr+offset),
+ GET_IP6ADDR_STRING(obj_tptr+offset),
GET_BE_U_4(obj_tptr + offset));
ND_PRINT("\n\t\t Active: %s (%u)",
offset = 0;
while (offset+4 <= obj_tlen) {
ND_PRINT("\n\t Interface ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr+offset),
+ GET_IPADDR_STRING(obj_tptr+offset),
GET_BE_U_4(obj_tptr + offset));
offset+=4;
}
offset = 0;
while (offset+16 <= obj_tlen) {
ND_PRINT("\n\t Interface ID: %s (0x%08x)",
- ip6addr_string(ndo, obj_tptr+offset),
+ GET_IP6ADDR_STRING(obj_tptr+offset),
GET_BE_U_4(obj_tptr + offset));
offset+=16;
}
GET_BE_U_2(obj_tptr + 10));
ND_PRINT("\n\t Local Interface ID: %s (0x%08x)",
- ipaddr_string(ndo, obj_tptr+12),
+ GET_IPADDR_STRING(obj_tptr+12),
GET_BE_U_4(obj_tptr + 12));
break;
goto invalid;
/* forwarding address */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
- ND_PRINT(", forwarding address %s", etheraddr_string(ndo, cp));
+ ND_PRINT(", forwarding address %s", GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
/* data */
ND_PRINT(", data (%u octets)", len - 8);
subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv4 =
(const struct lspping_tlv_targetfec_subtlv_ldp_ipv4_t *)subtlv_tptr;
ND_PRINT("\n\t %s/%u",
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv4->prefix),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv4->prefix),
GET_U_1(subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv4->prefix_len));
}
break;
subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv6 =
(const struct lspping_tlv_targetfec_subtlv_ldp_ipv6_t *)subtlv_tptr;
ND_PRINT("\n\t %s/%u",
- ip6addr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv6->prefix),
+ GET_IP6ADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv6->prefix),
GET_U_1(subtlv_ptr.lspping_tlv_targetfec_subtlv_ldp_ipv6->prefix_len));
}
break;
subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv4 =
(const struct lspping_tlv_targetfec_subtlv_bgp_ipv4_t *)subtlv_tptr;
ND_PRINT("\n\t %s/%u",
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv4->prefix),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv4->prefix),
GET_U_1(subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv4->prefix_len));
}
break;
subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv6 =
(const struct lspping_tlv_targetfec_subtlv_bgp_ipv6_t *)subtlv_tptr;
ND_PRINT("\n\t %s/%u",
- ip6addr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv6->prefix),
+ GET_IP6ADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv6->prefix),
GET_U_1(subtlv_ptr.lspping_tlv_targetfec_subtlv_bgp_ipv6->prefix_len));
}
break;
(const struct lspping_tlv_targetfec_subtlv_rsvp_ipv4_t *)subtlv_tptr;
ND_PRINT("\n\t tunnel end-point %s, tunnel sender %s, lsp-id 0x%04x"
"\n\t tunnel-id 0x%04x, extended tunnel-id %s",
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->tunnel_endpoint),
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->tunnel_sender),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->tunnel_endpoint),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->tunnel_sender),
GET_BE_U_2(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->lsp_id),
GET_BE_U_2(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->tunnel_id),
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->extended_tunnel_id));
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv4->extended_tunnel_id));
}
break;
(const struct lspping_tlv_targetfec_subtlv_rsvp_ipv6_t *)subtlv_tptr;
ND_PRINT("\n\t tunnel end-point %s, tunnel sender %s, lsp-id 0x%04x"
"\n\t tunnel-id 0x%04x, extended tunnel-id %s",
- ip6addr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->tunnel_endpoint),
- ip6addr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->tunnel_sender),
+ GET_IP6ADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->tunnel_endpoint),
+ GET_IP6ADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->tunnel_sender),
GET_BE_U_2(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->lsp_id),
GET_BE_U_2(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->tunnel_id),
- ip6addr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->extended_tunnel_id));
+ GET_IP6ADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_rsvp_ipv6->extended_tunnel_id));
}
break;
(const struct lspping_tlv_targetfec_subtlv_l3vpn_ipv4_t *)subtlv_tptr;
ND_PRINT("\n\t RD: %s, %s/%u",
bgp_vpn_rd_print(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv4->rd),
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv4->prefix),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv4->prefix),
GET_U_1(subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv4->prefix_len));
}
break;
(const struct lspping_tlv_targetfec_subtlv_l3vpn_ipv6_t *)subtlv_tptr;
ND_PRINT("\n\t RD: %s, %s/%u",
bgp_vpn_rd_print(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv6->rd),
- ip6addr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv6->prefix),
+ GET_IP6ADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv6->prefix),
GET_U_1(subtlv_ptr.lspping_tlv_targetfec_subtlv_l3vpn_ipv6->prefix_len));
}
break;
(const struct lspping_tlv_targetfec_subtlv_fec_128_pw_old *)subtlv_tptr;
ND_PRINT("\n\t Remote PE: %s"
"\n\t PW ID: 0x%08x, PW Type: %s (%u)",
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid_old->remote_pe_address),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid_old->remote_pe_address),
GET_BE_U_4(subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid_old->pw_id),
tok2str(mpls_pw_types_values,
"unknown",
(const struct lspping_tlv_targetfec_subtlv_fec_128_pw *)subtlv_tptr;
ND_PRINT("\n\t Sender PE: %s, Remote PE: %s"
"\n\t PW ID: 0x%08x, PW Type: %s (%u)",
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid->sender_pe_address),
- ipaddr_string(ndo, subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid->remote_pe_address),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid->sender_pe_address),
+ GET_IPADDR_STRING(subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid->remote_pe_address),
GET_BE_U_4(subtlv_ptr.lspping_tlv_targetfec_subtlv_l2vpn_vcid->pw_id),
tok2str(mpls_pw_types_values,
"unknown",
(const struct lspping_tlv_downstream_map_ipv4_t *)tlv_tptr;
ND_PRINT("\n\t Downstream IP: %s"
"\n\t Downstream Interface IP: %s",
- ipaddr_string(ndo, tlv_ptr.lspping_tlv_downstream_map_ipv4->downstream_ip),
- ipaddr_string(ndo, tlv_ptr.lspping_tlv_downstream_map_ipv4->downstream_interface));
+ GET_IPADDR_STRING(tlv_ptr.lspping_tlv_downstream_map_ipv4->downstream_ip),
+ GET_IPADDR_STRING(tlv_ptr.lspping_tlv_downstream_map_ipv4->downstream_interface));
tlv_tptr+=sizeof(struct lspping_tlv_downstream_map_ipv4_t);
tlv_tlen-=sizeof(struct lspping_tlv_downstream_map_ipv4_t);
break;
(const struct lspping_tlv_downstream_map_ipv4_unmb_t *)tlv_tptr;
ND_PRINT("\n\t Downstream IP: %s"
"\n\t Downstream Interface Index: 0x%08x",
- ipaddr_string(ndo, tlv_ptr.lspping_tlv_downstream_map_ipv4_unmb->downstream_ip),
+ GET_IPADDR_STRING(tlv_ptr.lspping_tlv_downstream_map_ipv4_unmb->downstream_ip),
GET_BE_U_4(tlv_ptr.lspping_tlv_downstream_map_ipv4_unmb->downstream_interface));
tlv_tptr+=sizeof(struct lspping_tlv_downstream_map_ipv4_unmb_t);
tlv_tlen-=sizeof(struct lspping_tlv_downstream_map_ipv4_unmb_t);
(const struct lspping_tlv_downstream_map_ipv6_t *)tlv_tptr;
ND_PRINT("\n\t Downstream IP: %s"
"\n\t Downstream Interface IP: %s",
- ip6addr_string(ndo, tlv_ptr.lspping_tlv_downstream_map_ipv6->downstream_ip),
- ip6addr_string(ndo, tlv_ptr.lspping_tlv_downstream_map_ipv6->downstream_interface));
+ GET_IP6ADDR_STRING(tlv_ptr.lspping_tlv_downstream_map_ipv6->downstream_ip),
+ GET_IP6ADDR_STRING(tlv_ptr.lspping_tlv_downstream_map_ipv6->downstream_interface));
tlv_tptr+=sizeof(struct lspping_tlv_downstream_map_ipv6_t);
tlv_tlen-=sizeof(struct lspping_tlv_downstream_map_ipv6_t);
break;
(const struct lspping_tlv_downstream_map_ipv6_unmb_t *)tlv_tptr;
ND_PRINT("\n\t Downstream IP: %s"
"\n\t Downstream Interface Index: 0x%08x",
- ip6addr_string(ndo, tlv_ptr.lspping_tlv_downstream_map_ipv6_unmb->downstream_ip),
+ GET_IP6ADDR_STRING(tlv_ptr.lspping_tlv_downstream_map_ipv6_unmb->downstream_ip),
GET_BE_U_4(tlv_ptr.lspping_tlv_downstream_map_ipv6_unmb->downstream_interface));
tlv_tptr+=sizeof(struct lspping_tlv_downstream_map_ipv6_unmb_t);
tlv_tlen-=sizeof(struct lspping_tlv_downstream_map_ipv6_unmb_t);
tlen);
if (has_ap_ident) {
- ND_PRINT("\n\tAP identity: %s", etheraddr_string(ndo, tptr));
+ ND_PRINT("\n\tAP identity: %s", GET_ETHERADDR_STRING(tptr));
tptr+=sizeof(struct lwapp_transport_header)+6;
} else {
tptr+=sizeof(struct lwapp_transport_header);
case 1: /* IPv4 */
if (l < 4)
return -1;
- ND_PRINT(" %s", ipaddr_string(ndo, p));
+ ND_PRINT(" %s", GET_IPADDR_STRING(p));
p += sizeof(nd_ipv4);
break;
case 2: /* IPv6 */
if (l < 16)
return -1;
- ND_PRINT(" %s", ip6addr_string(ndo, p));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(p));
p += sizeof(nd_ipv6);
break;
default:
if (osp) {
ND_PRINT("[S] ");
if (ndo->ndo_vflag)
- ND_PRINT("%s ", ipaddr_string(ndo, mob->osrc));
+ ND_PRINT("%s ", GET_IPADDR_STRING(mob->osrc));
} else {
ND_PRINT("[] ");
}
if (ndo->ndo_vflag) {
- ND_PRINT("> %s ", ipaddr_string(ndo, mob->odst));
+ ND_PRINT("> %s ", GET_IPADDR_STRING(mob->odst));
ND_PRINT("(oproto=%u)", proto>>8);
}
vec[0].ptr = (const uint8_t *)(const void *)mob;
goto trunc;
}
ND_TCHECK_16(bp + i + 2);
- ND_PRINT("(alt-CoA: %s)", ip6addr_string(ndo, bp + i + 2));
+ ND_PRINT("(alt-CoA: %s)", GET_IP6ADDR_STRING(bp + i + 2));
break;
case IP6MOPT_NONCEID:
if (len - i < IP6MOPT_NONCEID_MINLEN) {
/* Reserved */
hlen = IP6M_MINLEN;
ND_TCHECK_16(bp + hlen);
- ND_PRINT(" homeaddr %s", ip6addr_string(ndo, bp + hlen));
+ ND_PRINT(" homeaddr %s", GET_IP6ADDR_STRING(bp + hlen));
hlen += 16;
break;
default:
ND_PRINT(" id %u", GET_U_1(add_addr->addr_id));
switch (ipver) {
case 4:
- ND_PRINT(" %s", ipaddr_string(ndo, add_addr->u.v4.addr));
+ ND_PRINT(" %s", GET_IPADDR_STRING(add_addr->u.v4.addr));
if (opt_len == 10)
ND_PRINT(":%u", GET_BE_U_2(add_addr->u.v4.port));
break;
case 6:
- ND_PRINT(" %s", ip6addr_string(ndo, add_addr->u.v6.addr));
+ ND_PRINT(" %s", GET_IP6ADDR_STRING(add_addr->u.v6.addr));
if (opt_len == 22)
ND_PRINT(":%u", GET_BE_U_2(add_addr->u.v6.port));
break;
case 2:
ND_PRINT(" SA-Request");
ND_TCHECK_5(sp);
- ND_PRINT(" for %s", ipaddr_string(ndo, sp + 1));
+ ND_PRINT(" for %s", GET_IPADDR_STRING(sp + 1));
break;
case 4:
ND_PRINT(" Keepalive");
ND_PRINT("MS NLB heartbeat, host priority: %u,",
GET_LE_U_4((hb->host_prio)));
- ND_PRINT(" cluster IP: %s,", ipaddr_string(ndo, hb->virtual_ip));
- ND_PRINT(" host IP: %s", ipaddr_string(ndo, hb->host_ip));
+ ND_PRINT(" cluster IP: %s,", GET_IPADDR_STRING(hb->virtual_ip));
+ ND_PRINT(" host IP: %s", GET_IPADDR_STRING(hb->host_ip));
return;
trunc:
nd_print_trunc(ndo);
switch (IP_V((const struct ip *)bp)) {
case 4:
ip = (const struct ip *)bp;
- strlcpy(srcaddr, ipaddr_string(ndo, ip->ip_src), sizeof(srcaddr));
- strlcpy(dstaddr, ipaddr_string(ndo, ip->ip_dst), sizeof(dstaddr));
+ strlcpy(srcaddr, GET_IPADDR_STRING(ip->ip_src), sizeof(srcaddr));
+ strlcpy(dstaddr, GET_IPADDR_STRING(ip->ip_dst), sizeof(dstaddr));
break;
case 6:
ip6 = (const struct ip6_hdr *)bp;
- strlcpy(srcaddr, ip6addr_string(ndo, ip6->ip6_src),
+ strlcpy(srcaddr, GET_IP6ADDR_STRING(ip6->ip6_src),
sizeof(srcaddr));
- strlcpy(dstaddr, ip6addr_string(ndo, ip6->ip6_dst),
+ strlcpy(dstaddr, GET_IP6ADDR_STRING(ip6->ip6_dst),
sizeof(dstaddr));
break;
default:
break;
case INFO_QUERY:
- ND_PRINT("%s INFO_QUERY", ipaddr_string(ndo, bp->refid));
+ ND_PRINT("%s INFO_QUERY", GET_IPADDR_STRING(bp->refid));
/* this doesn't have more content */
return;
case INFO_REPLY:
- ND_PRINT("%s INFO_REPLY", ipaddr_string(ndo, bp->refid));
+ ND_PRINT("%s INFO_REPLY", GET_IPADDR_STRING(bp->refid));
/* this is too complex to be worth printing */
return;
ND_PRINT("\n\t neighbor %s, link-quality %.2f%%"
", neighbor-link-quality %.2f%%",
- ipaddr_string(ndo, lq_neighbor->neighbor),
+ GET_IPADDR_STRING(lq_neighbor->neighbor),
((double) GET_U_1(lq_neighbor->link_quality)/2.55),
((double) GET_U_1(lq_neighbor->neighbor_link_quality)/2.55));
ND_PRINT("\n\t neighbor %s, link-quality %.2f%%"
", neighbor-link-quality %.2f%%",
- ip6addr_string(ndo, lq_neighbor->neighbor),
+ GET_IP6ADDR_STRING(lq_neighbor->neighbor),
((double) GET_U_1(lq_neighbor->link_quality)/2.55),
((double) GET_U_1(lq_neighbor->neighbor_link_quality)/2.55));
ND_TCHECK_LEN(msg_data, sizeof(nd_ipv4));
/* print 4 neighbors per line */
- ND_PRINT("%s%s", ipaddr_string(ndo, msg_data),
+ ND_PRINT("%s%s", GET_IPADDR_STRING(msg_data),
neighbor % 4 == 0 ? "\n\t\t" : " ");
msg_data += sizeof(nd_ipv4);
ND_PRINT("\n\t%s Message (%#04x), originator %s, ttl %u, hop %u"
"\n\t vtime %.3fs, msg-seq 0x%04x, length %u%s",
tok2str(olsr_msg_values, "Unknown", msg_type),
- msg_type, ip6addr_string(ndo, msgptr.v6->originator),
+ msg_type, GET_IP6ADDR_STRING(msgptr.v6->originator),
GET_U_1(msgptr.v6->ttl),
GET_U_1(msgptr.v6->hopcount),
ME_TO_DOUBLE(GET_U_1(msgptr.v6->vtime)),
ND_PRINT("\n\t%s Message (%#04x), originator %s, ttl %u, hop %u"
"\n\t vtime %.3fs, msg-seq 0x%04x, length %u%s",
tok2str(olsr_msg_values, "Unknown", msg_type),
- msg_type, ipaddr_string(ndo, msgptr.v4->originator),
+ msg_type, GET_IPADDR_STRING(msgptr.v4->originator),
GET_U_1(msgptr.v4->ttl),
GET_U_1(msgptr.v4->hopcount),
ME_TO_DOUBLE(GET_U_1(msgptr.v4->vtime)),
while (msg_tlen >= addr_size) {
ND_TCHECK_LEN(msg_data, addr_size);
ND_PRINT("\n\t interface address %s",
- is_ipv6 ? ip6addr_string(ndo, msg_data) :
- ipaddr_string(ndo, msg_data));
+ is_ipv6 ? GET_IP6ADDR_STRING(msg_data) :
+ GET_IPADDR_STRING(msg_data));
msg_data += addr_size;
msg_tlen -= addr_size;
hna6 = (const struct olsr_hna6 *)msg_data;
ND_PRINT("\n\t #%i: %s/%u",
- i, ip6addr_string(ndo, hna6->network),
+ i, GET_IP6ADDR_STRING(hna6->network),
mask62plen (hna6->mask));
msg_data += sizeof(struct olsr_hna6);
/* normal route */
ND_PRINT("%s%s/%u",
col == 0 ? "\n\t " : ", ",
- ipaddr_string(ndo, ptr.hna->network),
+ GET_IPADDR_STRING(ptr.hna->network),
mask2plen(GET_BE_U_4(ptr.hna->mask)));
}
if (is_ipv6)
ND_PRINT(", address %s, name \"",
- ip6addr_string(ndo, msg_data));
+ GET_IP6ADDR_STRING(msg_data));
else
ND_PRINT(", address %s, name \"",
- ipaddr_string(ndo, msg_data));
+ GET_IPADDR_STRING(msg_data));
(void)nd_printn(ndo, msg_data + addr_size, name_entry_len, NULL);
ND_PRINT("\"");
cp += 3;
/* mask */
ND_TCHECK_4(cp);
- ND_PRINT(", mask %s", ipaddr_string(ndo, cp));
+ ND_PRINT(", mask %s", GET_IPADDR_STRING(cp));
cp += 4;
break;
case BSN_SET_MIRRORING:
cp += 2;
/* hw_addr */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
- ND_PRINT(", hw_addr %s", etheraddr_string(ndo, cp));
+ ND_PRINT(", hw_addr %s", GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
/* name */
ND_TCHECK_LEN(cp, OFP_MAX_PORT_NAME_LEN);
/* dl_src */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
if (! (wildcards & OFPFW_DL_SRC))
- ND_PRINT("%smatch dl_src %s", pfx, etheraddr_string(ndo, cp));
+ ND_PRINT("%smatch dl_src %s", pfx, GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
/* dl_dst */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
if (! (wildcards & OFPFW_DL_DST))
- ND_PRINT("%smatch dl_dst %s", pfx, etheraddr_string(ndo, cp));
+ ND_PRINT("%smatch dl_dst %s", pfx, GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
/* dl_vlan */
ND_TCHECK_2(cp);
ND_TCHECK_4(cp);
nw_bits = (wildcards & OFPFW_NW_SRC_MASK) >> OFPFW_NW_SRC_SHIFT;
if (nw_bits < 32)
- ND_PRINT("%smatch nw_src %s/%u", pfx, ipaddr_string(ndo, cp), 32 - nw_bits);
+ ND_PRINT("%smatch nw_src %s/%u", pfx, GET_IPADDR_STRING(cp), 32 - nw_bits);
cp += 4;
/* nw_dst */
ND_TCHECK_4(cp);
nw_bits = (wildcards & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT;
if (nw_bits < 32)
- ND_PRINT("%smatch nw_dst %s/%u", pfx, ipaddr_string(ndo, cp), 32 - nw_bits);
+ ND_PRINT("%smatch nw_dst %s/%u", pfx, GET_IPADDR_STRING(cp), 32 - nw_bits);
cp += 4;
/* tp_src */
ND_TCHECK_2(cp);
case OFPAT_SET_DL_DST:
/* dl_addr */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
- ND_PRINT(", dl_addr %s", etheraddr_string(ndo, cp));
+ ND_PRINT(", dl_addr %s", GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
/* pad */
ND_TCHECK_6(cp);
case OFPAT_SET_NW_DST:
/* nw_addr */
ND_TCHECK_4(cp);
- ND_PRINT(", nw_addr %s", ipaddr_string(ndo, cp));
+ ND_PRINT(", nw_addr %s", GET_IPADDR_STRING(cp));
cp += 4;
break;
case OFPAT_SET_NW_TOS:
cp += 2;
/* hw_addr */
ND_TCHECK_LEN(cp, MAC_ADDR_LEN);
- ND_PRINT(", hw_addr %s", etheraddr_string(ndo, cp));
+ ND_PRINT(", hw_addr %s", GET_ETHERADDR_STRING(cp));
cp += MAC_ADDR_LEN;
/* config */
ND_TCHECK_4(cp);
ND_PRINT("\n\t Bogus length %u != 4", tlv_length);
return -1;
}
- ND_PRINT("%s", ipaddr_string(ndo, tptr));
+ ND_PRINT("%s", GET_IPADDR_STRING(tptr));
break;
default:
goto invalid;
}
ND_PRINT(", %s (0x%08x)",
- ipaddr_string(ndo, tptr),
+ GET_IPADDR_STRING(tptr),
GET_BE_U_4(tptr));
if (subtlv_length == 8) /* rfc4203 */
ND_PRINT(", %s (0x%08x)",
- ipaddr_string(ndo, tptr+4),
+ GET_IPADDR_STRING(tptr+4),
GET_BE_U_4(tptr + 4));
break;
case LS_OPAQUE_TE_LINK_SUBTLV_LOCAL_IP:
ND_PRINT(" != 4");
goto invalid;
}
- ND_PRINT(", %s", ipaddr_string(ndo, tptr));
+ ND_PRINT(", %s", GET_IPADDR_STRING(tptr));
break;
case LS_OPAQUE_TE_LINK_SUBTLV_MAX_BW:
case LS_OPAQUE_TE_LINK_SUBTLV_MAX_RES_BW:
return -1;
}
ND_TCHECK_4(tptr);
- ND_PRINT(", %s", ipaddr_string(ndo, tptr));
+ ND_PRINT(", %s", GET_IPADDR_STRING(tptr));
break;
default:
ND_TCHECK_4(lshp->ls_seq); /* XXX - ls_length check checked this */
ND_PRINT("\n\t Advertising Router %s, seq 0x%08x, age %us, length %u",
- ipaddr_string(ndo, lshp->ls_router),
+ GET_IPADDR_STRING(lshp->ls_router),
GET_BE_U_4(lshp->ls_seq),
GET_BE_U_2(lshp->ls_age),
ls_length - (u_int)sizeof(struct lsa_hdr));
ND_PRINT("\n\t %s LSA (%u), LSA-ID: %s",
tok2str(lsa_values,"unknown",ls_type),
ls_type,
- ipaddr_string(ndo, lshp->un_lsa_id.lsa_id));
+ GET_IPADDR_STRING(lshp->un_lsa_id.lsa_id));
break;
}
case RLA_TYPE_VIRTUAL:
ND_PRINT("\n\t Virtual Link: Neighbor Router-ID: %s, Interface Address: %s",
- ipaddr_string(ndo, rlp->link_id),
- ipaddr_string(ndo, rlp->link_data));
+ GET_IPADDR_STRING(rlp->link_id),
+ GET_IPADDR_STRING(rlp->link_data));
break;
case RLA_TYPE_ROUTER:
ND_PRINT("\n\t Neighbor Router-ID: %s, Interface Address: %s",
- ipaddr_string(ndo, rlp->link_id),
- ipaddr_string(ndo, rlp->link_data));
+ GET_IPADDR_STRING(rlp->link_id),
+ GET_IPADDR_STRING(rlp->link_data));
break;
case RLA_TYPE_TRANSIT:
ND_PRINT("\n\t Neighbor Network-ID: %s, Interface Address: %s",
- ipaddr_string(ndo, rlp->link_id),
- ipaddr_string(ndo, rlp->link_data));
+ GET_IPADDR_STRING(rlp->link_id),
+ GET_IPADDR_STRING(rlp->link_data));
break;
case RLA_TYPE_STUB:
ND_PRINT("\n\t Stub Network: %s, Mask: %s",
- ipaddr_string(ndo, rlp->link_id),
- ipaddr_string(ndo, rlp->link_data));
+ GET_IPADDR_STRING(rlp->link_id),
+ GET_IPADDR_STRING(rlp->link_data));
break;
default:
case LS_TYPE_NETWORK:
ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask);
ND_PRINT("\n\t Mask %s\n\t Connected Routers:",
- ipaddr_string(ndo, lsap->lsa_un.un_nla.nla_mask));
+ GET_IPADDR_STRING(lsap->lsa_un.un_nla.nla_mask));
ap = lsap->lsa_un.un_nla.nla_router;
while ((const u_char *)ap < ls_end) {
ND_TCHECK_SIZE(ap);
- ND_PRINT("\n\t %s", ipaddr_string(ndo, *ap));
+ ND_PRINT("\n\t %s", GET_IPADDR_STRING(*ap));
++ap;
}
break;
case LS_TYPE_SUM_IP:
ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask);
ND_PRINT("\n\t Mask %s",
- ipaddr_string(ndo, lsap->lsa_un.un_sla.sla_mask));
+ GET_IPADDR_STRING(lsap->lsa_un.un_sla.sla_mask));
ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric);
lp = (const uint8_t *)lsap->lsa_un.un_sla.sla_tosmetric;
while (lp < ls_end) {
case LS_TYPE_NSSA: /* fall through - those LSAs share the same format */
ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask);
ND_PRINT("\n\t Mask %s",
- ipaddr_string(ndo, lsap->lsa_un.un_asla.asla_mask));
+ GET_IPADDR_STRING(lsap->lsa_un.un_asla.asla_mask));
ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric);
almp = lsap->lsa_un.un_asla.asla_metric;
ND_TCHECK_4(almp->asla_forward);
if (GET_IPV4_TO_NETWORK_ORDER(almp->asla_forward) != 0) {
- ND_PRINT(", forward %s", ipaddr_string(ndo, almp->asla_forward));
+ ND_PRINT(", forward %s", GET_IPADDR_STRING(almp->asla_forward));
}
ND_TCHECK_4(almp->asla_tag);
if (GET_IPV4_TO_NETWORK_ORDER(almp->asla_tag) != 0) {
- ND_PRINT(", tag %s", ipaddr_string(ndo, almp->asla_tag));
+ ND_PRINT(", tag %s", GET_IPADDR_STRING(almp->asla_tag));
}
++almp;
}
case MCLA_VERTEX_ROUTER:
ND_PRINT("\n\t Router Router-ID %s",
- ipaddr_string(ndo, mcp->mcla_vid));
+ GET_IPADDR_STRING(mcp->mcla_vid));
break;
case MCLA_VERTEX_NETWORK:
ND_PRINT("\n\t Network Designated Router %s",
- ipaddr_string(ndo, mcp->mcla_vid));
+ GET_IPADDR_STRING(mcp->mcla_vid));
break;
default:
ND_PRINT("\n\t Hello Timer %us, Dead Timer %us, Mask %s, Priority %u",
GET_BE_U_2(op->ospf_hello.hello_helloint),
GET_BE_U_4(op->ospf_hello.hello_deadint),
- ipaddr_string(ndo, op->ospf_hello.hello_mask),
+ GET_IPADDR_STRING(op->ospf_hello.hello_mask),
GET_U_1(op->ospf_hello.hello_priority));
ND_TCHECK_4(op->ospf_hello.hello_dr);
if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_hello.hello_dr) != 0)
ND_PRINT("\n\t Designated Router %s",
- ipaddr_string(ndo, op->ospf_hello.hello_dr));
+ GET_IPADDR_STRING(op->ospf_hello.hello_dr));
ND_TCHECK_4(op->ospf_hello.hello_bdr);
if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_hello.hello_bdr) != 0)
ND_PRINT(", Backup Designated Router %s",
- ipaddr_string(ndo, op->ospf_hello.hello_bdr));
+ GET_IPADDR_STRING(op->ospf_hello.hello_bdr));
ap = op->ospf_hello.hello_neighbor;
if ((const u_char *)ap < dataend)
ND_PRINT("\n\t Neighbor List:");
while ((const u_char *)ap < dataend) {
ND_TCHECK_SIZE(ap);
- ND_PRINT("\n\t %s", ipaddr_string(ndo, *ap));
+ ND_PRINT("\n\t %s", GET_IPADDR_STRING(*ap));
++ap;
}
break; /* HELLO */
ND_TCHECK_SIZE(lsrp);
ND_PRINT("\n\t Advertising Router: %s, %s LSA (%u)",
- ipaddr_string(ndo, lsrp->ls_router),
+ GET_IPADDR_STRING(lsrp->ls_router),
tok2str(lsa_values,"unknown",GET_BE_U_4(lsrp->ls_type)),
GET_BE_U_4(lsrp->ls_type));
break;
default:
ND_PRINT(", LSA-ID: %s",
- ipaddr_string(ndo, lsrp->un_ls_stateid.ls_stateid));
+ GET_IPADDR_STRING(lsrp->un_ls_stateid.ls_stateid));
break;
}
}
ND_TCHECK_4(op->ospf_routerid);
- ND_PRINT("\n\tRouter-ID %s", ipaddr_string(ndo, op->ospf_routerid));
+ ND_PRINT("\n\tRouter-ID %s", GET_IPADDR_STRING(op->ospf_routerid));
ND_TCHECK_4(op->ospf_areaid);
if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_areaid) != 0)
- ND_PRINT(", Area %s", ipaddr_string(ndo, op->ospf_areaid));
+ ND_PRINT(", Area %s", GET_IPADDR_STRING(op->ospf_areaid));
else
ND_PRINT(", Backbone Area");
ls_type & LS_TYPE_MASK,
tok2str(ospf6_ls_scope_values, "Unknown", ls_type & LS_SCOPE_MASK),
ls_type &0x8000 ? ", transitive" : "", /* U-bit */
- ipaddr_string(ndo, (const u_char *)ls_stateid));
+ GET_IPADDR_STRING((const u_char *)ls_stateid));
}
static int
ND_TCHECK_4(lshp->ls_router);
ND_PRINT("\n\t Advertising Router %s, seq 0x%08x, age %us, length %u",
- ipaddr_string(ndo, lshp->ls_router),
+ GET_IPADDR_STRING(lshp->ls_router),
GET_BE_U_4(lshp->ls_seq),
GET_BE_U_2(lshp->ls_age),
GET_BE_U_2(lshp->ls_length)-(u_int)sizeof(struct lsa6_hdr));
ND_TCHECK_LEN(lsapp->lsa_p_prefix, wordlen * 4);
memset(prefix, 0, sizeof(prefix));
memcpy(prefix, lsapp->lsa_p_prefix, wordlen * 4);
- ND_PRINT("\n\t\t%s/%u", ip6addr_string(ndo, prefix),
+ ND_PRINT("\n\t\t%s/%u", ip6addr_string(ndo, prefix), /* local buffer, not packet data; don't use GET_IP6ADDR_STRING() */
GET_U_1(lsapp->lsa_p_len));
if (GET_U_1(lsapp->lsa_p_opt)) {
ND_PRINT(", Options [%s]",
case RLA_TYPE_VIRTUAL:
ND_PRINT("\n\t Virtual Link: Neighbor Router-ID %s"
"\n\t Neighbor Interface-ID %s, Interface %s",
- ipaddr_string(ndo, rlp->link_nrtid),
- ipaddr_string(ndo, rlp->link_nifid),
- ipaddr_string(ndo, rlp->link_ifid));
+ GET_IPADDR_STRING(rlp->link_nrtid),
+ GET_IPADDR_STRING(rlp->link_nifid),
+ GET_IPADDR_STRING(rlp->link_ifid));
break;
case RLA_TYPE_ROUTER:
ND_PRINT("\n\t Neighbor Router-ID %s"
"\n\t Neighbor Interface-ID %s, Interface %s",
- ipaddr_string(ndo, rlp->link_nrtid),
- ipaddr_string(ndo, rlp->link_nifid),
- ipaddr_string(ndo, rlp->link_ifid));
+ GET_IPADDR_STRING(rlp->link_nrtid),
+ GET_IPADDR_STRING(rlp->link_nifid),
+ GET_IPADDR_STRING(rlp->link_ifid));
break;
case RLA_TYPE_TRANSIT:
ND_PRINT("\n\t Neighbor Network-ID %s"
"\n\t Neighbor Interface-ID %s, Interface %s",
- ipaddr_string(ndo, rlp->link_nrtid),
- ipaddr_string(ndo, rlp->link_nifid),
- ipaddr_string(ndo, rlp->link_ifid));
+ GET_IPADDR_STRING(rlp->link_nrtid),
+ GET_IPADDR_STRING(rlp->link_nifid),
+ GET_IPADDR_STRING(rlp->link_ifid));
break;
default:
return (1);
lsa_length -= sizeof (*ap);
ND_TCHECK_SIZE(ap);
- ND_PRINT("\n\t\t%s", ipaddr_string(ndo, *ap));
+ ND_PRINT("\n\t\t%s", GET_IPADDR_STRING(*ap));
++ap;
}
break;
lsa_length -= sizeof (nd_ipv6);
ND_TCHECK_16(tptr);
ND_PRINT(" forward %s",
- ip6addr_string(ndo, tptr));
+ GET_IP6ADDR_STRING(tptr));
tptr += sizeof(nd_ipv6);
}
lsa_length -= sizeof (uint32_t);
ND_TCHECK_4(tptr);
ND_PRINT(" tag %s",
- ipaddr_string(ndo, tptr));
+ GET_IPADDR_STRING(tptr));
tptr += sizeof(uint32_t);
}
lsa_length -= sizeof (uint32_t);
ND_TCHECK_4(tptr);
ND_PRINT(" RefLSID: %s",
- ipaddr_string(ndo, tptr));
+ GET_IPADDR_STRING(tptr));
tptr += sizeof(uint32_t);
}
break;
prefixes = GET_BE_U_4(llsap->llsa_nprefix);
ND_PRINT("\n\t Priority %u, Link-local address %s, Prefixes %u:",
GET_U_1(llsap->llsa_priority),
- ip6addr_string(ndo, llsap->llsa_lladdr),
+ GET_IP6ADDR_STRING(llsap->llsa_lladdr),
prefixes);
tptr = (const uint8_t *)llsap->llsa_prefix;
ND_PRINT("\n\t Hello Timer %us, Dead Timer %us, Interface-ID %s, Priority %u",
GET_BE_U_2(hellop->hello_helloint),
GET_BE_U_2(hellop->hello_deadint),
- ipaddr_string(ndo, hellop->hello_ifid),
+ GET_IPADDR_STRING(hellop->hello_ifid),
GET_U_1(hellop->hello_priority));
ND_TCHECK_4(hellop->hello_dr);
if (GET_BE_U_4(hellop->hello_dr) != 0)
ND_PRINT("\n\t Designated Router %s",
- ipaddr_string(ndo, hellop->hello_dr));
+ GET_IPADDR_STRING(hellop->hello_dr));
ND_TCHECK_4(hellop->hello_bdr);
if (GET_BE_U_4(hellop->hello_bdr) != 0)
ND_PRINT(", Backup Designated Router %s",
- ipaddr_string(ndo, hellop->hello_bdr));
+ GET_IPADDR_STRING(hellop->hello_bdr));
if (ndo->ndo_vflag > 1) {
ND_PRINT("\n\t Neighbor List:");
ap = hellop->hello_neighbor;
while ((const u_char *)ap < dataend) {
ND_TCHECK_SIZE(ap);
- ND_PRINT("\n\t %s", ipaddr_string(ndo, *ap));
+ ND_PRINT("\n\t %s", GET_IPADDR_STRING(*ap));
++ap;
}
}
while ((const u_char *)lsrp < dataend) {
ND_TCHECK_SIZE(lsrp);
ND_PRINT("\n\t Advertising Router %s",
- ipaddr_string(ndo, lsrp->ls_router));
+ GET_IPADDR_STRING(lsrp->ls_router));
ospf6_print_ls_type(ndo,
GET_BE_U_2(lsrp->ls_type),
&lsrp->ls_stateid);
dataend = bp + datalen;
ND_TCHECK_4(op->ospf6_routerid);
- ND_PRINT("\n\tRouter-ID %s", ipaddr_string(ndo, op->ospf6_routerid));
+ ND_PRINT("\n\tRouter-ID %s", GET_IPADDR_STRING(op->ospf6_routerid));
ND_TCHECK_4(op->ospf6_areaid);
if (GET_BE_U_4(op->ospf6_areaid) != 0)
- ND_PRINT(", Area %s", ipaddr_string(ndo, op->ospf6_areaid));
+ ND_PRINT(", Area %s", GET_IPADDR_STRING(op->ospf6_areaid));
else
ND_PRINT(", Backbone Area");
ND_TCHECK_1(op->ospf6_instanceid);
((njoin = GET_BE_U_2(bp + 20)) + GET_BE_U_2(bp + 22)) == 1) {
u_int hold;
- ND_PRINT(" RPF %s ", ipaddr_string(ndo, bp));
+ ND_PRINT(" RPF %s ", GET_IPADDR_STRING(bp));
hold = GET_BE_U_2(bp + 6);
if (hold != 180) {
ND_PRINT("Hold ");
unsigned_relts_print(ndo, hold);
}
ND_PRINT("%s (%s/%u, %s", njoin ? "Join" : "Prune",
- ipaddr_string(ndo, bp + 26), GET_U_1(bp + 25) & 0x3f,
- ipaddr_string(ndo, bp + 12));
+ GET_IPADDR_STRING(bp + 26), GET_U_1(bp + 25) & 0x3f,
+ GET_IPADDR_STRING(bp + 12));
if (GET_BE_U_4(bp + 16) != 0xffffffff)
- ND_PRINT("/%s", ipaddr_string(ndo, bp + 16));
+ ND_PRINT("/%s", GET_IPADDR_STRING(bp + 16));
ND_PRINT(") %s%s %s",
(GET_U_1(bp + 24) & 0x01) ? "Sparse" : "Dense",
(GET_U_1(bp + 25) & 0x80) ? " WC" : "",
ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
if (ndo->ndo_vflag > 1)
ND_PRINT("\n");
- ND_PRINT(" Upstream Nbr: %s", ipaddr_string(ndo, bp));
+ ND_PRINT(" Upstream Nbr: %s", GET_IPADDR_STRING(bp));
bp += 4;
len -= 4;
if (len < 4)
if (len < 4)
goto trunc;
ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
- ND_PRINT("\n\tGroup: %s", ipaddr_string(ndo, bp));
+ ND_PRINT("\n\tGroup: %s", GET_IPADDR_STRING(bp));
bp += 4;
len -= 4;
if (len < 4)
goto trunc;
ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
if (GET_BE_U_4(bp) != 0xffffffff)
- ND_PRINT("/%s", ipaddr_string(ndo, bp));
+ ND_PRINT("/%s", GET_IPADDR_STRING(bp));
bp += 4;
len -= 4;
if (len < 4)
(GET_U_1(bp) & 0x01) ? "Sparse " : "Dense ",
(GET_U_1(bp + 1) & 0x80) ? "WC " : "",
(GET_U_1(bp + 1) & 0x40) ? "RP " : "SPT ",
- ipaddr_string(ndo, bp + 2),
+ GET_IPADDR_STRING(bp + 2),
GET_U_1(bp + 1) & 0x3f);
bp += 6;
len -= 6;
case PIMV1_TYPE_REGISTER:
ND_TCHECK_LEN(bp + 8, 20); /* ip header */
- ND_PRINT(" for %s > %s", ipaddr_string(ndo, bp + 20),
- ipaddr_string(ndo, bp + 24));
+ ND_PRINT(" for %s > %s", GET_IPADDR_STRING(bp + 20),
+ GET_IPADDR_STRING(bp + 24));
break;
case PIMV1_TYPE_REGISTER_STOP:
ND_TCHECK_LEN(bp + 12, sizeof(nd_ipv4));
- ND_PRINT(" for %s > %s", ipaddr_string(ndo, bp + 8),
- ipaddr_string(ndo, bp + 12));
+ ND_PRINT(" for %s > %s", GET_IPADDR_STRING(bp + 8),
+ GET_IPADDR_STRING(bp + 12));
break;
case PIMV1_TYPE_RP_REACHABILITY:
if (ndo->ndo_vflag) {
ND_TCHECK_2(bp + 22);
- ND_PRINT(" group %s", ipaddr_string(ndo, bp + 8));
+ ND_PRINT(" group %s", GET_IPADDR_STRING(bp + 8));
if (GET_BE_U_4(bp + 12) != 0xffffffff)
- ND_PRINT("/%s", ipaddr_string(ndo, bp + 12));
- ND_PRINT(" RP %s hold ", ipaddr_string(ndo, bp + 16));
+ ND_PRINT("/%s", GET_IPADDR_STRING(bp + 12));
+ ND_PRINT(" RP %s hold ", GET_IPADDR_STRING(bp + 16));
unsigned_relts_print(ndo, GET_BE_U_2(bp + 22));
}
break;
case PIMV1_TYPE_ASSERT:
ND_TCHECK_LEN(bp + 16, sizeof(nd_ipv4));
- ND_PRINT(" for %s > %s", ipaddr_string(ndo, bp + 16),
- ipaddr_string(ndo, bp + 8));
+ ND_PRINT(" for %s > %s", GET_IPADDR_STRING(bp + 16),
+ GET_IPADDR_STRING(bp + 8));
if (GET_BE_U_4(bp + 12) != 0xffffffff)
- ND_PRINT("/%s", ipaddr_string(ndo, bp + 12));
+ ND_PRINT("/%s", GET_IPADDR_STRING(bp + 12));
ND_TCHECK_4(bp + 24);
ND_PRINT(" %s pref %u metric %u",
(GET_U_1(bp + 20) & 0x80) ? "RP-tree" : "SPT",
if (len < 4)
goto trunc;
ND_TCHECK_4(bp);
- ND_PRINT(" RP %s", ipaddr_string(ndo, bp));
+ ND_PRINT(" RP %s", GET_IPADDR_STRING(bp));
bp += 4;
len -= 4;
if (len < 1)
goto trunc;
ND_TCHECK_6(bp);
ND_PRINT("%c%s%s/%u", s, GET_U_1(bp) & 1 ? "!" : "",
- ipaddr_string(ndo, bp + 2), GET_U_1(bp + 1));
+ GET_IPADDR_STRING(bp + 2), GET_U_1(bp + 1));
if (GET_U_1(bp) & 0x02) {
ND_PRINT(" bidir");
}
ND_TCHECK_LEN(bp, addr_len);
if (af == AF_INET) {
if (!silent)
- ND_PRINT("%s", ipaddr_string(ndo, bp));
+ ND_PRINT("%s", GET_IPADDR_STRING(bp));
}
else if (af == AF_INET6) {
if (!silent)
- ND_PRINT("%s", ip6addr_string(ndo, bp));
+ ND_PRINT("%s", GET_IP6ADDR_STRING(bp));
}
return hdrlen + addr_len;
case pimv2_group:
ND_TCHECK_LEN(bp, addr_len + 2);
if (af == AF_INET) {
if (!silent) {
- ND_PRINT("%s", ipaddr_string(ndo, bp + 2));
+ ND_PRINT("%s", GET_IPADDR_STRING(bp + 2));
if (GET_U_1(bp + 1) != 32)
ND_PRINT("/%u", GET_U_1(bp + 1));
}
}
else if (af == AF_INET6) {
if (!silent) {
- ND_PRINT("%s", ip6addr_string(ndo, bp + 2));
+ ND_PRINT("%s", GET_IP6ADDR_STRING(bp + 2));
if (GET_U_1(bp + 1) != 128)
ND_PRINT("/%u", GET_U_1(bp + 1));
}
case 0: /* Null header */
ND_TCHECK_4(ip->ip_dst);
ND_PRINT("IP-Null-header %s > %s",
- ipaddr_string(ndo, ip->ip_src),
- ipaddr_string(ndo, ip->ip_dst));
+ GET_IPADDR_STRING(ip->ip_src),
+ GET_IPADDR_STRING(ip->ip_dst));
break;
case 4: /* IPv4 */
return 0;
}
ND_TCHECK_4(p + 3);
- ND_PRINT(": IPv4 %s", ipaddr_string(ndo, p + 3));
+ ND_PRINT(": IPv4 %s", GET_IPADDR_STRING(p + 3));
break;
case MEDCLASS_MAC:
if (len != 9) {
return 0;
}
ND_TCHECK_6(p + 3);
- ND_PRINT(": MAC %s", etheraddr_string(ndo, p + 3));
+ ND_PRINT(": MAC %s", GET_ETHERADDR_STRING(p + 3));
break;
case MEDCLASS_MNB:
ND_PRINT(": Magic-Num-Block"); /* XXX */
}
ND_TCHECK_4(p + 6);
ND_PRINT(": src %s, dst %s",
- ipaddr_string(ndo, p + 2),
- ipaddr_string(ndo, p + 6));
+ GET_IPADDR_STRING(p + 2),
+ GET_IPADDR_STRING(p + 6));
break;
case IPCPOPT_IPCOMP:
if (len < 4) {
return 0;
}
ND_TCHECK_4(p + 2);
- ND_PRINT(": %s", ipaddr_string(ndo, p + 2));
+ ND_PRINT(": %s", GET_IPADDR_STRING(p + 2));
break;
default:
/*
if (GET_BE_U_4(data) == 0xFFFFFFFE )
ND_PRINT("NAS Select");
else
- ND_PRINT("%s",ipaddr_string(ndo, data));
+ ND_PRINT("%s",GET_IPADDR_STRING(data));
break;
default:
- ND_PRINT("%s", ipaddr_string(ndo, data));
+ ND_PRINT("%s", GET_IPADDR_STRING(data));
break;
}
ND_TCHECK_16(data);
- ND_PRINT("%s", ip6addr_string(ndo, data));
+ ND_PRINT("%s", GET_IP6ADDR_STRING(data));
return;
return;
}
- ND_PRINT("%s/%u", ip6addr_string(ndo, data + 1), GET_U_1(data));
+ ND_PRINT("%s/%u", GET_IP6ADDR_STRING(data + 1), GET_U_1(data));
return;
}
if (family == 0) {
ND_PRINT("\n\t AFI 0, %s, metric: %u",
- ipaddr_string(ndo, ni->rip_dest),
+ GET_IPADDR_STRING(ni->rip_dest),
GET_BE_U_4(ni->rip_metric));
return (RIP_ROUTELEN);
} /* BSD_AFNUM_INET */
ND_PRINT("\n\t %s, metric: %u",
- ipaddr_string(ndo, ni->rip_dest),
+ GET_IPADDR_STRING(ni->rip_dest),
GET_BE_U_4(ni->rip_metric));
return (RIP_ROUTELEN);
trunc:
return (0);
ND_PRINT("\n\t AFI %s, %15s/%-2d, tag 0x%04x, metric: %u, next-hop: ",
tok2str(bsd_af_values, "%u", family),
- ipaddr_string(ndo, ni->rip_dest),
+ GET_IPADDR_STRING(ni->rip_dest),
mask2plen(GET_BE_U_4(ni->rip_dest_mask)),
GET_BE_U_2(ni->rip_tag),
GET_BE_U_4(ni->rip_metric));
if (GET_BE_U_4(ni->rip_router))
- ND_PRINT("%s", ipaddr_string(ndo, ni->rip_router));
+ ND_PRINT("%s", GET_IPADDR_STRING(ni->rip_router));
else
ND_PRINT("self");
}
int l;
uint16_t tag;
- l = ND_PRINT("%s/%u", ip6addr_string(ndo, ni->rip6_dest),
+ l = ND_PRINT("%s/%u", GET_IP6ADDR_STRING(ni->rip6_dest),
GET_U_1(ni->rip6_plen));
tag = GET_BE_U_2(ni->rip6_tag);
if (tag)
pdu = (const rpki_rtr_pdu_ipv4_prefix *)tptr;
ND_PRINT("%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
- ipaddr_string(ndo, pdu->prefix),
+ GET_IPADDR_STRING(pdu->prefix),
GET_U_1(pdu->prefix_length), GET_U_1(pdu->max_length),
GET_BE_U_4(pdu->as), GET_U_1(pdu->flags));
}
pdu = (const rpki_rtr_pdu_ipv6_prefix *)tptr;
ND_PRINT("%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
indent_string(indent+2),
- ip6addr_string(ndo, pdu->prefix),
+ GET_IP6ADDR_STRING(pdu->prefix),
GET_U_1(pdu->prefix_length), GET_U_1(pdu->max_length),
GET_BE_U_4(pdu->as), GET_U_1(pdu->flags));
}
ND_PRINT(" downlink_port=%u, uplink_port=%u, uplink_mac=%s, vendor_id=%08x ,chip_id=%04x ",
GET_U_1(cp + RRCP_DOWNLINK_PORT_OFFSET),
GET_U_1(cp + RRCP_UPLINK_PORT_OFFSET),
- etheraddr_string(ndo, cp + RRCP_UPLINK_MAC_OFFSET),
+ GET_ETHERADDR_STRING(cp + RRCP_UPLINK_MAC_OFFSET),
GET_BE_U_4(cp + RRCP_VENDOR_ID_OFFSET),
GET_BE_U_2(cp + RRCP_CHIP_ID_OFFSET));
}else if (rrcp_opcode==1 || rrcp_opcode==2 || rrcp_proto==2){
return -1;
ND_PRINT("%s IPv4 DestAddress: %s, Protocol ID: 0x%02x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_U_1(obj_tptr + sizeof(nd_ipv4)));
ND_PRINT("%s Flags: [0x%02x], DestPort %u",
indent,
return -1;
ND_PRINT("%s IPv6 DestAddress: %s, Protocol ID: 0x%02x",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_U_1(obj_tptr + sizeof(nd_ipv6)));
ND_PRINT("%s Flags: [0x%02x], DestPort %u",
indent,
return -1;
ND_PRINT("%s IPv6 Tunnel EndPoint: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 18),
- ip6addr_string(ndo, obj_tptr + 20));
+ GET_IP6ADDR_STRING(obj_tptr + 20));
obj_tlen-=36;
obj_tptr+=36;
break;
indent,
GET_BE_U_4(obj_tptr),
GET_BE_U_2(obj_tptr + 6),
- ip6addr_string(ndo, obj_tptr + 8));
+ GET_IP6ADDR_STRING(obj_tptr + 8));
obj_tlen-=26;
obj_tptr+=26;
break;
return -1;
ND_PRINT("%s IPv4 P2MP LSP ID: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6),
- ipaddr_string(ndo, obj_tptr + 8));
+ GET_IPADDR_STRING(obj_tptr + 8));
obj_tlen-=12;
obj_tptr+=12;
break;
return -1;
ND_PRINT("%s IPv4 Tunnel EndPoint: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6),
- ipaddr_string(ndo, obj_tptr + 8));
+ GET_IPADDR_STRING(obj_tptr + 8));
obj_tlen-=12;
obj_tptr+=12;
break;
return -1;
ND_PRINT("%s IPv4 Receiver Address: %s",
indent,
- ipaddr_string(ndo, obj_tptr));
+ GET_IPADDR_STRING(obj_tptr));
obj_tlen-=sizeof(nd_ipv4);
obj_tptr+=sizeof(nd_ipv4);
break;
return -1;
ND_PRINT("%s IPv6 Receiver Address: %s",
indent,
- ip6addr_string(ndo, obj_tptr));
+ GET_IP6ADDR_STRING(obj_tptr));
obj_tlen-=sizeof(nd_ipv6);
obj_tptr+=sizeof(nd_ipv6);
break;
return -1;
ND_PRINT("%s IPv4 Notify Node Address: %s",
indent,
- ipaddr_string(ndo, obj_tptr));
+ GET_IPADDR_STRING(obj_tptr));
obj_tlen-=sizeof(nd_ipv4);
obj_tptr+=sizeof(nd_ipv4);
break;
return-1;
ND_PRINT("%s IPv6 Notify Node Address: %s",
indent,
- ip6addr_string(ndo, obj_tptr));
+ GET_IP6ADDR_STRING(obj_tptr));
obj_tlen-=sizeof(nd_ipv6);
obj_tptr+=sizeof(nd_ipv6);
break;
return-1;
ND_PRINT("%s Source Address: %s, Source Port: %u",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6));
obj_tlen-=8;
obj_tptr+=8;
return-1;
ND_PRINT("%s Source Address: %s, Source Port: %u",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 18));
obj_tlen-=20;
obj_tptr+=20;
ND_PRINT("%s IPv6 Tunnel Sender Address: %s, LSP ID: 0x%04x"
"%s Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 18),
indent,
- ip6addr_string(ndo, obj_tptr+20),
+ GET_IP6ADDR_STRING(obj_tptr+20),
GET_BE_U_2(obj_tptr + 38));
obj_tlen-=40;
obj_tptr+=40;
return-1;
ND_PRINT("%s IPv4 Tunnel Sender Address: %s, LSP-ID: 0x%04x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6));
obj_tlen-=8;
obj_tptr+=8;
ND_PRINT("%s IPv4 Tunnel Sender Address: %s, LSP ID: 0x%04x"
"%s Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6),
indent,
- ipaddr_string(ndo, obj_tptr+8),
+ GET_IPADDR_STRING(obj_tptr+8),
GET_BE_U_2(obj_tptr + 12));
obj_tlen-=16;
obj_tptr+=16;
}
ND_PRINT(", %s, %s/%u, Flags: [%s]",
RSVP_OBJ_XRO_MASK_LOOSE(GET_U_1(obj_tptr)) ? "Loose" : "Strict",
- ipaddr_string(ndo, obj_tptr+2),
+ GET_IPADDR_STRING(obj_tptr+2),
GET_U_1((obj_tptr + 6)),
bittok2str(rsvp_obj_rro_flag_values,
"none",
if (subobj_len < 8)
return -1;
ND_PRINT("%s UNI IPv4 TNA address: %s",
- indent, ipaddr_string(ndo, obj_tptr + 4));
+ indent, GET_IPADDR_STRING(obj_tptr + 4));
break;
case AFNUM_INET6:
if (subobj_len < 20)
return -1;
ND_PRINT("%s UNI IPv6 TNA address: %s",
- indent, ip6addr_string(ndo, obj_tptr + 4));
+ indent, GET_IP6ADDR_STRING(obj_tptr + 4));
break;
case AFNUM_NSAP:
if (subobj_len) {
return-1;
ND_PRINT("%s Previous/Next Interface: %s, Logical Interface Handle: 0x%08x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_4(obj_tptr + 4));
obj_tlen-=8;
obj_tptr+=8;
return-1;
ND_PRINT("%s Previous/Next Interface: %s, Logical Interface Handle: 0x%08x",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_4(obj_tptr + 16));
obj_tlen-=20;
obj_tptr+=20;
return-1;
ND_PRINT("%s Source Address: %s, Source Port: %u",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6));
obj_tlen-=8;
obj_tptr+=8;
return-1;
ND_PRINT("%s Source Address: %s, Source Port: %u",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 18));
obj_tlen-=20;
obj_tptr+=20;
return-1;
ND_PRINT("%s Source Address: %s, Flow Label: %u",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_3(obj_tptr + 17));
obj_tlen-=20;
obj_tptr+=20;
return-1;
ND_PRINT("%s Source Address: %s, LSP-ID: 0x%04x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 18));
obj_tlen-=20;
obj_tptr+=20;
ND_PRINT("%s IPv6 Tunnel Sender Address: %s, LSP ID: 0x%04x"
"%s Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 18),
indent,
- ip6addr_string(ndo, obj_tptr+20),
+ GET_IP6ADDR_STRING(obj_tptr+20),
GET_BE_U_2(obj_tptr + 38));
obj_tlen-=40;
obj_tptr+=40;
return-1;
ND_PRINT("%s Source Address: %s, LSP-ID: 0x%04x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6));
obj_tlen-=8;
obj_tptr+=8;
ND_PRINT("%s IPv4 Tunnel Sender Address: %s, LSP ID: 0x%04x"
"%s Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_BE_U_2(obj_tptr + 6),
indent,
- ipaddr_string(ndo, obj_tptr+8),
+ GET_IPADDR_STRING(obj_tptr+8),
GET_BE_U_2(obj_tptr + 12));
obj_tlen-=16;
obj_tptr+=16;
while(obj_tlen >= 8) {
ND_PRINT("%s PLR-ID: %s, Avoid-Node-ID: %s",
indent,
- ipaddr_string(ndo, obj_tptr),
- ipaddr_string(ndo, obj_tptr + 4));
+ GET_IPADDR_STRING(obj_tptr),
+ GET_IPADDR_STRING(obj_tptr + 4));
obj_tlen-=8;
obj_tptr+=8;
}
error_value=GET_BE_U_2(obj_tptr + 6);
ND_PRINT("%s Error Node Address: %s, Flags: [0x%02x]%s Error Code: %s (%u)",
indent,
- ipaddr_string(ndo, obj_tptr),
+ GET_IPADDR_STRING(obj_tptr),
GET_U_1(obj_tptr + 4),
indent,
tok2str(rsvp_obj_error_code_values,"unknown",error_code),
error_value=GET_BE_U_2(obj_tptr + 18);
ND_PRINT("%s Error Node Address: %s, Flags: [0x%02x]%s Error Code: %s (%u)",
indent,
- ip6addr_string(ndo, obj_tptr),
+ GET_IP6ADDR_STRING(obj_tptr),
GET_U_1(obj_tptr + 16),
indent,
tok2str(rsvp_obj_error_code_values,"unknown",error_code),
if (obj_tlen < 4)
return-1;
ND_PRINT("%s Sub-LSP destination address: %s",
- indent, ipaddr_string(ndo, obj_tptr));
+ indent, GET_IPADDR_STRING(obj_tptr));
obj_tlen-=4;
obj_tptr+=4;
if (obj_tlen < 16)
return-1;
ND_PRINT("%s Sub-LSP destination address: %s",
- indent, ip6addr_string(ndo, obj_tptr));
+ indent, GET_IP6ADDR_STRING(obj_tptr));
obj_tlen-=16;
obj_tptr+=16;
p = (const u_char *) dp0->ip6r0_addr;
for (i = 0; i < len; i++) {
ND_TCHECK_16(p);
- ND_PRINT(", [%u]%s", i, ip6addr_string(ndo, p));
+ ND_PRINT(", [%u]%s", i, GET_IP6ADDR_STRING(p));
p += 16;
}
/*(*/
p = (const u_char *) srh->srh_segments;
for (i = 0; i < len; i++) {
ND_TCHECK_16(p);
- ND_PRINT(", [%u]%s", i, ip6addr_string(ndo, p));
+ ND_PRINT(", [%u]%s", i, GET_IP6ADDR_STRING(p));
p += 16;
}
/*(*/
ND_PRINT("sFlowv%u, %s agent %s, agent-id %u, length %u",
GET_BE_U_4(sflow_datagram->version),
GET_BE_U_4(sflow_datagram->ip_version) == 1 ? "IPv4" : "IPv6",
- ipaddr_string(ndo, sflow_datagram->agent),
+ GET_IPADDR_STRING(sflow_datagram->agent),
GET_BE_U_4(sflow_datagram->agent_id),
len);
return;
ND_PRINT("sFlowv%u, %s agent %s, agent-id %u, seqnum %u, uptime %u, samples %u, length %u",
GET_BE_U_4(sflow_datagram->version),
GET_BE_U_4(sflow_datagram->ip_version) == 1 ? "IPv4" : "IPv6",
- ipaddr_string(ndo, sflow_datagram->agent),
+ GET_IPADDR_STRING(sflow_datagram->agent),
GET_BE_U_4(sflow_datagram->agent_id),
GET_BE_U_4(sflow_datagram->seqnum),
GET_BE_U_4(sflow_datagram->uptime),
* XXX - print others as strings of hex?
*/
if (GET_BE_U_2(sllp->sll_halen) == 6)
- ND_PRINT("%s ", etheraddr_string(ndo, sllp->sll_addr));
+ ND_PRINT("%s ", GET_ETHERADDR_STRING(sllp->sll_addr));
if (!ndo->ndo_qflag) {
ether_type = GET_BE_U_2(sllp->sll_protocol);
* XXX - print others as strings of hex?
*/
if (GET_U_1(sllp->sll2_halen) == 6)
- ND_PRINT("%s ", etheraddr_string(ndo, sllp->sll2_addr));
+ ND_PRINT("%s ", GET_ETHERADDR_STRING(sllp->sll2_addr));
if (!ndo->ndo_qflag) {
ether_type = GET_BE_U_2(sllp->sll2_protocol);
ND_PRINT("\n\t System %s, System Priority %u, Key %u"
", Port %u, Port Priority %u\n\t State Flags [%s]",
- etheraddr_string(ndo, tlv_ptr.lacp_tlv_actor_partner_info->sys),
+ GET_ETHERADDR_STRING(tlv_ptr.lacp_tlv_actor_partner_info->sys),
GET_BE_U_2(tlv_ptr.lacp_tlv_actor_partner_info->sys_pri),
GET_BE_U_2(tlv_ptr.lacp_tlv_actor_partner_info->key),
GET_BE_U_2(tlv_ptr.lacp_tlv_actor_partner_info->port),
tlv_ptr.marker_tlv_marker_info = (const struct marker_tlv_marker_info_t *)tlv_tptr;
ND_PRINT("\n\t Request System %s, Request Port %u, Request Transaction ID 0x%08x",
- etheraddr_string(ndo, tlv_ptr.marker_tlv_marker_info->req_sys),
+ GET_ETHERADDR_STRING(tlv_ptr.marker_tlv_marker_info->req_sys),
GET_BE_U_2(tlv_ptr.marker_tlv_marker_info->req_port),
GET_BE_U_4(tlv_ptr.marker_tlv_marker_info->req_trans_id));
case VQP_OBJ_IP_ADDRESS:
if (vqp_obj_len != 4)
goto trunc;
- ND_PRINT("%s (0x%08x)", ipaddr_string(ndo, tptr),
+ ND_PRINT("%s (0x%08x)", GET_IPADDR_STRING(tptr),
GET_BE_U_4(tptr));
break;
/* those objects have similar semantics - fall through */
case VQP_OBJ_MAC_NULL:
if (vqp_obj_len != MAC_ADDR_LEN)
goto trunc;
- ND_PRINT("%s", etheraddr_string(ndo, tptr));
+ ND_PRINT("%s", GET_ETHERADDR_STRING(tptr));
break;
default:
if (ndo->ndo_vflag <= 1)
bp += 8;
for (i = 0; i < naddrs; i++) {
ND_TCHECK_1(bp + 3);
- ND_PRINT("%c%s", c, ipaddr_string(ndo, bp));
+ ND_PRINT("%c%s", c, GET_IPADDR_STRING(bp));
c = ',';
bp += 4;
}
ND_TCHECK_8(tptr);
ND_PRINT("\n\t Config Rev %x, Updater %s",
GET_BE_U_4(tptr),
- ipaddr_string(ndo, tptr+4));
+ GET_IPADDR_STRING(tptr+4));
tptr += 8;
ND_TCHECK_LEN(tptr, VTP_UPDATE_TIMESTAMP_LEN);
ND_PRINT(", Timestamp 0x%08x 0x%08x 0x%08x",
ND_PRINT(" %u/%s:%u (max %u/%s:%u) ",
GET_BE_U_4(id->pi_ps.slot),
- ipaddr_string(ndo, id->pi_ps.page.p_sid),
+ GET_IPADDR_STRING(id->pi_ps.page.p_sid),
GET_BE_U_4(id->pi_ps.page.p_uid),
GET_BE_U_4(id->pi_mslot),
- ipaddr_string(ndo, id->pi_mpage.p_sid),
+ GET_IPADDR_STRING(id->pi_mpage.p_sid),
GET_BE_U_4(id->pi_mpage.p_uid));
nid = GET_BE_U_2(id->pi_ps.nid);
c = '<';
for (i = 0; i < nid && ND_TTEST_SIZE(io); ++io, ++i) {
ND_PRINT("%c%s:%u",
- c, ipaddr_string(ndo, io->id), GET_BE_U_4(io->off));
+ c, GET_IPADDR_STRING(io->id), GET_BE_U_4(io->off));
c = ',';
}
if (i >= nid) {
return (-1);
ND_PRINT(" please repair %s %s:%u<%u:%u>",
- ipaddr_string(ndo, rreq->pr_id),
- ipaddr_string(ndo, rreq->pr_page.p_sid),
+ GET_IPADDR_STRING(rreq->pr_id),
+ GET_IPADDR_STRING(rreq->pr_page.p_sid),
GET_BE_U_4(rreq->pr_page.p_uid),
GET_BE_U_4(rreq->pr_sseq),
GET_BE_U_4(rreq->pr_eseq));
ND_PRINT(" need %u/%s:%u",
GET_BE_U_4(preq->pp_low),
- ipaddr_string(ndo, preq->pp_page.p_sid),
+ GET_IPADDR_STRING(preq->pp_page.p_sid),
GET_BE_U_4(preq->pp_page.p_uid));
return (0);
}
ND_PRINT(" %u/%s:%u",
GET_BE_U_4(ps->slot),
- ipaddr_string(ndo, ps->page.p_sid),
+ GET_IPADDR_STRING(ps->page.p_sid),
GET_BE_U_4(ps->page.p_uid));
io = (const struct id_off *)(ps + 1);
for (ie = io + GET_U_1(ps->nid); io < ie && ND_TTEST_SIZE(io); ++io) {
- ND_PRINT("%c%s:%u", c, ipaddr_string(ndo, io->id),
+ ND_PRINT("%c%s:%u", c, GET_IPADDR_STRING(io->id),
GET_BE_U_4(io->off));
c = ',';
}
len -= sizeof(*rrep);
ND_PRINT(" for %s %s:%u<%u:%u>",
- ipaddr_string(ndo, rrep->pr_id),
- ipaddr_string(ndo, dop->pd_page.p_sid),
+ GET_IPADDR_STRING(rrep->pr_id),
+ GET_IPADDR_STRING(dop->pd_page.p_sid),
GET_BE_U_4(dop->pd_page.p_uid),
GET_BE_U_4(dop->pd_sseq),
GET_BE_U_4(dop->pd_eseq));
len -= sizeof(*dop);
ND_PRINT(" %s:%u<%u:%u>",
- ipaddr_string(ndo, dop->pd_page.p_sid),
+ GET_IPADDR_STRING(dop->pd_page.p_sid),
GET_BE_U_4(dop->pd_page.p_uid),
GET_BE_U_4(dop->pd_sseq),
GET_BE_U_4(dop->pd_eseq));
projects / tcpdump / commitdiff
