The Tcpdump Group git mirrors - tcpdump/blobdiff

index 283a2d58ea04483329cb1b927b2016f0a9b4d85c..fd25ba84cdbf6e475b40e3614374b2c9bfab9832 100644 (file)

--- a/print-bgp.c

+++ b/print-bgp.c

@@ -30,26 +30,25 @@

* complete BGP support.

-#define NETDISSECT_REWORKED

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

-#include <tcpdump-stdinc.h>

+#include <netdissect-stdinc.h>

#include <stdio.h>

#include <string.h>

#include <stdio.h>

#include <string.h>

-#include "interface.h"

+#include "netdissect.h"

#include "addrtoname.h"

#include "extract.h"

#include "af.h"

#include "l2vpn.h"

struct bgp {

#include "addrtoname.h"

#include "extract.h"

#include "af.h"

#include "l2vpn.h"

struct bgp {

- u_int8_t bgp_marker[16];

- u_int16_t bgp_len;

- u_int8_t bgp_type;

+ uint8_t bgp_marker[16];

+ uint16_t bgp_len;

+ uint8_t bgp_type;

};

#define BGP_SIZE 19 /* unaligned */

};

#define BGP_SIZE 19 /* unaligned */

@@ -69,42 +68,42 @@ static const struct tok bgp_msg_values[] = {

};

struct bgp_open {

};

struct bgp_open {

- u_int8_t bgpo_marker[16];

- u_int16_t bgpo_len;

- u_int8_t bgpo_type;

- u_int8_t bgpo_version;

- u_int16_t bgpo_myas;

- u_int16_t bgpo_holdtime;

- u_int32_t bgpo_id;

- u_int8_t bgpo_optlen;

+ uint8_t bgpo_marker[16];

+ uint16_t bgpo_len;

+ uint8_t bgpo_type;

+ uint8_t bgpo_version;

+ uint16_t bgpo_myas;

+ uint16_t bgpo_holdtime;

+ uint32_t bgpo_id;

+ uint8_t bgpo_optlen;

/* options should follow */

};

#define BGP_OPEN_SIZE 29 /* unaligned */

struct bgp_opt {

/* options should follow */

};

#define BGP_OPEN_SIZE 29 /* unaligned */

struct bgp_opt {

- u_int8_t bgpopt_type;

- u_int8_t bgpopt_len;

+ uint8_t bgpopt_type;

+ uint8_t bgpopt_len;

/* variable length */

};

#define BGP_OPT_SIZE 2 /* some compilers may pad to 4 bytes */

#define BGP_CAP_HEADER_SIZE 2 /* some compilers may pad to 4 bytes */

struct bgp_notification {

/* variable length */

};

#define BGP_OPT_SIZE 2 /* some compilers may pad to 4 bytes */

#define BGP_CAP_HEADER_SIZE 2 /* some compilers may pad to 4 bytes */

struct bgp_notification {

- u_int8_t bgpn_marker[16];

- u_int16_t bgpn_len;

- u_int8_t bgpn_type;

- u_int8_t bgpn_major;

- u_int8_t bgpn_minor;

+ uint8_t bgpn_marker[16];

+ uint16_t bgpn_len;

+ uint8_t bgpn_type;

+ uint8_t bgpn_major;

+ uint8_t bgpn_minor;

};

#define BGP_NOTIFICATION_SIZE 21 /* unaligned */

struct bgp_route_refresh {

};

#define BGP_NOTIFICATION_SIZE 21 /* unaligned */

struct bgp_route_refresh {

- u_int8_t bgp_marker[16];

- u_int16_t len;

- u_int8_t type;

- u_int8_t afi[2]; /* the compiler messes this structure up */

- u_int8_t res; /* when doing misaligned sequences of int8 and int16 */

- u_int8_t safi; /* afi should be int16 - so we have to access it using */

+ uint8_t bgp_marker[16];

+ uint16_t len;

+ uint8_t type;

+ uint8_t afi[2]; /* the compiler messes this structure up */

+ uint8_t res; /* when doing misaligned sequences of int8 and int16 */

+ uint8_t safi; /* afi should be int16 - so we have to access it using */

}; /* EXTRACT_16BITS(&bgp_route_refresh->afi) (sigh) */

#define BGP_ROUTE_REFRESH_SIZE 23

}; /* EXTRACT_16BITS(&bgp_route_refresh->afi) (sigh) */

#define BGP_ROUTE_REFRESH_SIZE 23

@@ -132,6 +131,7 @@ struct bgp_route_refresh {

#define BGPTYPE_AS4_PATH 17 /* RFC4893 */

#define BGPTYPE_AGGREGATOR4 18 /* RFC4893 */

#define BGPTYPE_PMSI_TUNNEL 22 /* draft-ietf-l3vpn-2547bis-mcast-bgp-02.txt */

#define BGPTYPE_AS4_PATH 17 /* RFC4893 */

#define BGPTYPE_AGGREGATOR4 18 /* RFC4893 */

#define BGPTYPE_PMSI_TUNNEL 22 /* draft-ietf-l3vpn-2547bis-mcast-bgp-02.txt */

+#define BGPTYPE_AIGP 26 /* RFC7311 */

#define BGPTYPE_ATTR_SET 128 /* draft-marques-ppvpn-ibgp */

#define BGP_MP_NLRI_MINSIZE 3 /* End of RIB Marker detection */

#define BGPTYPE_ATTR_SET 128 /* draft-marques-ppvpn-ibgp */

#define BGP_MP_NLRI_MINSIZE 3 /* End of RIB Marker detection */

@@ -156,6 +156,7 @@ static const struct tok bgp_attr_values[] = {

{ BGPTYPE_MP_UNREACH_NLRI, "Multi-Protocol Unreach NLRI"},

{ BGPTYPE_EXTD_COMMUNITIES, "Extended Community"},

{ BGPTYPE_PMSI_TUNNEL, "PMSI Tunnel"},

{ BGPTYPE_MP_UNREACH_NLRI, "Multi-Protocol Unreach NLRI"},

{ BGPTYPE_EXTD_COMMUNITIES, "Extended Community"},

{ BGPTYPE_PMSI_TUNNEL, "PMSI Tunnel"},

+ { BGPTYPE_AIGP, "Accumulated IGP Metric"},

{ BGPTYPE_ATTR_SET, "Attribute Set"},

{ 255, "Reserved for development"},

{ 0, NULL}

{ BGPTYPE_ATTR_SET, "Attribute Set"},

{ 255, "Reserved for development"},

{ 0, NULL}

@@ -201,6 +202,7 @@ static const struct tok bgp_opt_values[] = {

#define BGP_CAPCODE_RESTART 64 /* draft-ietf-idr-restart-05 */

#define BGP_CAPCODE_AS_NEW 65 /* XXX */

#define BGP_CAPCODE_DYN_CAP 67 /* XXX */

#define BGP_CAPCODE_RESTART 64 /* draft-ietf-idr-restart-05 */

#define BGP_CAPCODE_AS_NEW 65 /* XXX */

#define BGP_CAPCODE_DYN_CAP 67 /* XXX */

+#define BGP_CAPCODE_ADD_PATH 69 /* draft-ietf-idr-add-paths-10 */

#define BGP_CAPCODE_RR_CISCO 128

static const struct tok bgp_capcode_values[] = {

#define BGP_CAPCODE_RR_CISCO 128

static const struct tok bgp_capcode_values[] = {

@@ -210,6 +212,7 @@ static const struct tok bgp_capcode_values[] = {

{ BGP_CAPCODE_RESTART, "Graceful Restart"},

{ BGP_CAPCODE_AS_NEW, "32-Bit AS Number"},

{ BGP_CAPCODE_DYN_CAP, "Dynamic Capability"},

{ BGP_CAPCODE_RESTART, "Graceful Restart"},

{ BGP_CAPCODE_AS_NEW, "32-Bit AS Number"},

{ BGP_CAPCODE_DYN_CAP, "Dynamic Capability"},

+ { BGP_CAPCODE_ADD_PATH, "Multiple Paths"},

{ BGP_CAPCODE_RR_CISCO, "Route Refresh (Cisco)"},

{ 0, NULL}

};

{ BGP_CAPCODE_RR_CISCO, "Route Refresh (Cisco)"},

{ 0, NULL}

};

@@ -318,6 +321,13 @@ static const struct tok bgp_pmsi_flag_values[] = {

{ 0, NULL}

};

{ 0, NULL}

};

+#define BGP_AIGP_TLV 1

+static const struct tok bgp_aigp_values[] = {

+ { BGP_AIGP_TLV, "AIGP"},

+ { 0, NULL}

+};

/* Subsequent address family identifier, RFC2283 section 7 */

#define SAFNUM_RES 0

/* Subsequent address family identifier, RFC2283 section 7 */

#define SAFNUM_RES 0

@@ -454,7 +464,14 @@ static const struct tok bgp_extd_comm_ospf_rtype_values[] = {

{ 0, NULL },

};

{ 0, NULL },

};

-#define TOKBUFSIZE 128

+/* ADD-PATH Send/Receive field values */

+static const struct tok bgp_add_path_recvsend[] = {

+ { 1, "Receive" },

+ { 2, "Send" },

+ { 3, "Both" },

+ { 0, NULL },

+};

static char astostr[20];

@@ -530,7 +547,7 @@ decode_labeled_prefix4(netdissect_options *ndo,

is added to the prefix length;

we also do only read out just one label -

there is no real application for advertisement of

is added to the prefix length;

we also do only read out just one label -

there is no real application for advertisement of

- stacked labels in a a single BGP message

+ stacked labels in a single BGP message

if (24 > plen)

@@ -574,7 +591,8 @@ badtlv:

static char *

bgp_vpn_ip_print(netdissect_options *ndo,

static char *

bgp_vpn_ip_print(netdissect_options *ndo,

- const u_char *pptr, u_int addr_length) {

+ const u_char *pptr, u_int addr_length)

/* worst case string is s fully formatted v6 address */

static char addr[sizeof("1234:5678:89ab:cdef:1234:5678:89ab:cdef")];

/* worst case string is s fully formatted v6 address */

static char addr[sizeof("1234:5678:89ab:cdef:1234:5678:89ab:cdef")];

@@ -585,12 +603,10 @@ bgp_vpn_ip_print(netdissect_options *ndo,

ND_TCHECK2(pptr[0], sizeof(struct in_addr));

snprintf(pos, sizeof(addr), "%s", ipaddr_string(ndo, pptr));

break;

ND_TCHECK2(pptr[0], sizeof(struct in_addr));

snprintf(pos, sizeof(addr), "%s", ipaddr_string(ndo, pptr));

break;

-#ifdef INET6

case (sizeof(struct in6_addr) << 3): /* 128 */

ND_TCHECK2(pptr[0], sizeof(struct in6_addr));

snprintf(pos, sizeof(addr), "%s", ip6addr_string(ndo, pptr));

break;

case (sizeof(struct in6_addr) << 3): /* 128 */

ND_TCHECK2(pptr[0], sizeof(struct in6_addr));

snprintf(pos, sizeof(addr), "%s", ip6addr_string(ndo, pptr));

break;

-#endif

default:

snprintf(pos, sizeof(addr), "bogus address length %u", addr_length);

break;

default:

snprintf(pos, sizeof(addr), "bogus address length %u", addr_length);

break;

@@ -622,9 +638,9 @@ trunc:

static int

bgp_vpn_sg_print(netdissect_options *ndo,

static int

bgp_vpn_sg_print(netdissect_options *ndo,

- const u_char *pptr, char *buf, u_int buflen) {

- u_int8_t addr_length;

+ const u_char *pptr, char *buf, u_int buflen)

+ uint8_t addr_length;

u_int total_length, offset;

total_length = 0;

u_int total_length, offset;

total_length = 0;

@@ -667,8 +683,8 @@ trunc:

* printing route targets inside a NLRI */

char *

bgp_vpn_rd_print(netdissect_options *ndo,

* printing route targets inside a NLRI */

char *

bgp_vpn_rd_print(netdissect_options *ndo,

- const u_char *pptr) {

+ const u_char *pptr)

/* allocate space for the largest possible string */

static char rd[sizeof("xxxxxxxxxx:xxxxx (xxx.xxx.xxx.xxx:xxxxx)")];

char *pos = rd;

/* allocate space for the largest possible string */

static char rd[sizeof("xxxxxxxxxx:xxxxx (xxx.xxx.xxx.xxx:xxxxx)")];

char *pos = rd;

@@ -710,14 +726,16 @@ static int

decode_rt_routing_info(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

decode_rt_routing_info(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

- u_int8_t route_target[8];

+ uint8_t route_target[8];

u_int plen;

ND_TCHECK(pptr[0]);

plen = pptr[0]; /* get prefix length */

u_int plen;

ND_TCHECK(pptr[0]);

plen = pptr[0]; /* get prefix length */

- if (0 == plen)

- return 1; /* default route target */

+ if (0 == plen) {

+ snprintf(buf, buflen, "default route target");

+ return 1;

+ }

if (32 > plen)

return -1;

if (32 > plen)

return -1;

@@ -806,7 +824,7 @@ decode_mdt_vpn_nlri(netdissect_options *ndo,

ND_TCHECK(pptr[0]);

/* if the NLRI is not predefined length, quit.*/

ND_TCHECK(pptr[0]);

/* if the NLRI is not predefined length, quit.*/

- if (*pptr != MDT_VPN_NLRI_LEN * NBBY)

+ if (*pptr != MDT_VPN_NLRI_LEN * 8)

return -1;

pptr++;

return -1;

pptr++;

@@ -855,7 +873,7 @@ static int

decode_multicast_vpn(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

decode_multicast_vpn(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

- u_int8_t route_type, route_length, addr_length, sg_length;

+ uint8_t route_type, route_length, addr_length, sg_length;

u_int offset;

ND_TCHECK2(pptr[0], 2);

u_int offset;

ND_TCHECK2(pptr[0], 2);

@@ -948,21 +966,21 @@ trunc:

* the buffer would have overflowed; again, set buflen to 0 in

* that case.

* the buffer would have overflowed; again, set buflen to 0 in

* that case.

-#define UPDATE_BUF_BUFLEN(buf, buflen, strlen) \

- if (strlen<0) \

+#define UPDATE_BUF_BUFLEN(buf, buflen, stringlen) \

+ if (stringlen<0) \

buflen=0; \

- else if ((u_int)strlen>buflen) \

+ else if ((u_int)stringlen>buflen) \

buflen=0; \

else { \

buflen=0; \

else { \

- buflen-=strlen; \

- buf+=strlen; \

+ buflen-=stringlen; \

+ buf+=stringlen; \

}

static int

decode_labeled_vpn_l2(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

}

static int

decode_labeled_vpn_l2(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

- int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;

+ int plen,tlen,stringlen,tlv_type,tlv_len,ttlv_len;

ND_TCHECK2(pptr[0], 2);

plen=EXTRACT_16BITS(pptr);

ND_TCHECK2(pptr[0], 2);

plen=EXTRACT_16BITS(pptr);

@@ -976,12 +994,12 @@ decode_labeled_vpn_l2(netdissect_options *ndo,

/* assume AD-only with RD, BGPNH */

ND_TCHECK2(pptr[0],12);

buf[0]='\0';

/* assume AD-only with RD, BGPNH */

ND_TCHECK2(pptr[0],12);

buf[0]='\0';

- strlen=snprintf(buf, buflen, "RD: %s, BGPNH: %s",

- bgp_vpn_rd_print(ndo, pptr),

- /* need something like getname(ndo, ) here */

- getname(ndo, pptr+8)

- );

- UPDATE_BUF_BUFLEN(buf, buflen, strlen);

+ stringlen=snprintf(buf, buflen, "RD: %s, BGPNH: %s",

+ bgp_vpn_rd_print(ndo, pptr),

+ /* need something like getname(ndo, ) here */

+ getname(ndo, pptr+8)

+ );

+ UPDATE_BUF_BUFLEN(buf, buflen, stringlen);

pptr+=12;

tlen-=12;

return plen;

pptr+=12;

tlen-=12;

return plen;

@@ -991,12 +1009,12 @@ decode_labeled_vpn_l2(netdissect_options *ndo,

ND_TCHECK2(pptr[0],15);

buf[0]='\0';

ND_TCHECK2(pptr[0],15);

buf[0]='\0';

- strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",

- bgp_vpn_rd_print(ndo, pptr),

- EXTRACT_16BITS(pptr+8),

- EXTRACT_16BITS(pptr+10),

- EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */

- UPDATE_BUF_BUFLEN(buf, buflen, strlen);

+ stringlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",

+ bgp_vpn_rd_print(ndo, pptr),

+ EXTRACT_16BITS(pptr+8),

+ EXTRACT_16BITS(pptr+10),

+ EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */

+ UPDATE_BUF_BUFLEN(buf, buflen, stringlen);

pptr+=15;

tlen-=15;

pptr+=15;

tlen-=15;

@@ -1013,27 +1031,27 @@ decode_labeled_vpn_l2(netdissect_options *ndo,

switch(tlv_type) {

case 1:

if (buflen!=0) {

switch(tlv_type) {

case 1:

if (buflen!=0) {

- strlen=snprintf(buf,buflen, "\n\t\tcircuit status vector (%u) length: %u: 0x",

- tlv_type,

- tlv_len);

- UPDATE_BUF_BUFLEN(buf, buflen, strlen);

+ stringlen=snprintf(buf,buflen, "\n\t\tcircuit status vector (%u) length: %u: 0x",

+ tlv_type,

+ tlv_len);

+ UPDATE_BUF_BUFLEN(buf, buflen, stringlen);

}

ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */

while (ttlv_len>0) {

ND_TCHECK(pptr[0]);

if (buflen!=0) {

}

ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */

while (ttlv_len>0) {

ND_TCHECK(pptr[0]);

if (buflen!=0) {

- strlen=snprintf(buf,buflen, "%02x",*pptr++);

- UPDATE_BUF_BUFLEN(buf, buflen, strlen);

+ stringlen=snprintf(buf,buflen, "%02x",*pptr++);

+ UPDATE_BUF_BUFLEN(buf, buflen, stringlen);

}

ttlv_len--;

}

break;

default:

if (buflen!=0) {

}

ttlv_len--;

}

break;

default:

if (buflen!=0) {

- strlen=snprintf(buf,buflen, "\n\t\tunknown TLV #%u, length: %u",

- tlv_type,

- tlv_len);

- UPDATE_BUF_BUFLEN(buf, buflen, strlen);

+ stringlen=snprintf(buf,buflen, "\n\t\tunknown TLV #%u, length: %u",

+ tlv_type,

+ tlv_len);

+ UPDATE_BUF_BUFLEN(buf, buflen, stringlen);

}

break;

}

break;

}

@@ -1051,7 +1069,6 @@ trunc:

return -2;

}

return -2;

}

-#ifdef INET6

int

decode_prefix6(netdissect_options *ndo,

const u_char *pd, u_int itemlen, char *buf, u_int buflen)

int

decode_prefix6(netdissect_options *ndo,

const u_char *pd, u_int itemlen, char *buf, u_int buflen)

@@ -1168,13 +1185,12 @@ decode_labeled_vpn_prefix6(netdissect_options *ndo,

trunc:

return -2;

}

trunc:

return -2;

}

-#endif

static int

decode_clnp_prefix(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

static int

decode_clnp_prefix(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

- u_int8_t addr[19];

+ uint8_t addr[19];

u_int plen;

ND_TCHECK(pptr[0]);

u_int plen;

ND_TCHECK(pptr[0]);

@@ -1191,7 +1207,7 @@ decode_clnp_prefix(netdissect_options *ndo,

((0xff00 >> (plen % 8)) & 0xff);

}

snprintf(buf, buflen, "%s/%d",

((0xff00 >> (plen % 8)) & 0xff);

}

snprintf(buf, buflen, "%s/%d",

- isonsap_string(addr,(plen + 7) / 8),

+ isonsap_string(ndo, addr,(plen + 7) / 8),

plen);

return 1 + (plen + 7) / 8;

plen);

return 1 + (plen + 7) / 8;

@@ -1204,7 +1220,7 @@ static int

decode_labeled_vpn_clnp_prefix(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

decode_labeled_vpn_clnp_prefix(netdissect_options *ndo,

const u_char *pptr, char *buf, u_int buflen)

{

- u_int8_t addr[19];

+ uint8_t addr[19];

u_int plen;

ND_TCHECK(pptr[0]);

u_int plen;

ND_TCHECK(pptr[0]);

@@ -1228,7 +1244,7 @@ decode_labeled_vpn_clnp_prefix(netdissect_options *ndo,

/* the label may get offsetted by 4 bits so lets shift it right */

snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",

bgp_vpn_rd_print(ndo, pptr+4),

/* the label may get offsetted by 4 bits so lets shift it right */

snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",

bgp_vpn_rd_print(ndo, pptr+4),

- isonsap_string(addr,(plen + 7) / 8),

+ isonsap_string(ndo, addr,(plen + 7) / 8),

plen,

EXTRACT_24BITS(pptr+1)>>4,

((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );

plen,

EXTRACT_24BITS(pptr+1)>>4,

((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );

@@ -1248,7 +1264,7 @@ trunc:

static int

bgp_attr_get_as_size(netdissect_options *ndo,

static int

bgp_attr_get_as_size(netdissect_options *ndo,

- u_int8_t bgpa_type, const u_char *pptr, int len)

+ uint8_t bgpa_type, const u_char *pptr, int len)

{

const u_char *tptr = pptr;

{

const u_char *tptr = pptr;

@@ -1302,17 +1318,16 @@ bgp_attr_print(netdissect_options *ndo,

u_int atype, const u_char *pptr, u_int len)

{

int i;

u_int atype, const u_char *pptr, u_int len)

{

int i;

- u_int16_t af;

- u_int8_t safi, snpa, nhlen;

+ uint16_t af;

+ uint8_t safi, snpa, nhlen;

union { /* copy buffer for bandwidth values */

float f;

union { /* copy buffer for bandwidth values */

float f;

- u_int32_t i;

+ uint32_t i;

} bw;

int advance;

u_int tlen;

const u_char *tptr;

char buf[MAXHOSTNAMELEN + 100];

} bw;

int advance;

u_int tlen;

const u_char *tptr;

char buf[MAXHOSTNAMELEN + 100];

- char tokbuf[TOKBUFSIZE];

int as_size;

tptr = pptr;

int as_size;

tptr = pptr;

@@ -1324,10 +1339,9 @@ bgp_attr_print(netdissect_options *ndo,

ND_PRINT((ndo, "invalid len"));

else {

ND_TCHECK(*tptr);

ND_PRINT((ndo, "invalid len"));

else {

ND_TCHECK(*tptr);

- ND_PRINT((ndo, "%s", tok2strbuf(bgp_origin_values,

+ ND_PRINT((ndo, "%s", tok2str(bgp_origin_values,

"Unknown Origin Typecode",

- tptr[0],

- tokbuf, sizeof(tokbuf))));

+ tptr[0])));

}

break;

}

break;

@@ -1358,9 +1372,8 @@ bgp_attr_print(netdissect_options *ndo,

while (tptr < pptr + len) {

ND_TCHECK(tptr[0]);

while (tptr < pptr + len) {

ND_TCHECK(tptr[0]);

- ND_PRINT((ndo, "%s", tok2strbuf(bgp_as_path_segment_open_values,

- "?", tptr[0],

- tokbuf, sizeof(tokbuf))));

+ ND_PRINT((ndo, "%s", tok2str(bgp_as_path_segment_open_values,

+ "?", tptr[0])));

for (i = 0; i < tptr[1] * as_size; i += as_size) {

ND_TCHECK2(tptr[2 + i], as_size);

ND_PRINT((ndo, "%s ",

for (i = 0; i < tptr[1] * as_size; i += as_size) {

ND_TCHECK2(tptr[2 + i], as_size);

ND_PRINT((ndo, "%s ",

@@ -1370,9 +1383,8 @@ bgp_attr_print(netdissect_options *ndo,

EXTRACT_32BITS(&tptr[2 + i]))));

}

ND_TCHECK(tptr[0]);

EXTRACT_32BITS(&tptr[2 + i]))));

}

ND_TCHECK(tptr[0]);

- ND_PRINT((ndo, "%s", tok2strbuf(bgp_as_path_segment_close_values,

- "?", tptr[0],

- tokbuf, sizeof(tokbuf))));

+ ND_PRINT((ndo, "%s", tok2str(bgp_as_path_segment_close_values,

+ "?", tptr[0])));

ND_TCHECK(tptr[1]);

tptr += 2 + tptr[1] * as_size;

}

ND_TCHECK(tptr[1]);

tptr += 2 + tptr[1] * as_size;

}

@@ -1435,7 +1447,7 @@ bgp_attr_print(netdissect_options *ndo,

break;

}

while (tlen>0) {

break;

}

while (tlen>0) {

- u_int32_t comm;

+ uint32_t comm;

ND_TCHECK2(tptr[0], 4);

comm = EXTRACT_32BITS(tptr);

switch (comm) {

ND_TCHECK2(tptr[0], 4);

comm = EXTRACT_32BITS(tptr);

switch (comm) {

@@ -1487,12 +1499,10 @@ bgp_attr_print(netdissect_options *ndo,

safi = tptr[2];

ND_PRINT((ndo, "\n\t AFI: %s (%u), %sSAFI: %s (%u)",

safi = tptr[2];

ND_PRINT((ndo, "\n\t AFI: %s (%u), %sSAFI: %s (%u)",

- tok2strbuf(af_values, "Unknown AFI", af,

- tokbuf, sizeof(tokbuf)),

+ tok2str(af_values, "Unknown AFI", af),

af,

(safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */

af,

(safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */

- tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_safi_values, "Unknown SAFI", safi),

safi));

switch(af<<8 | safi) {

safi));

switch(af<<8 | safi) {

@@ -1506,7 +1516,6 @@ bgp_attr_print(netdissect_options *ndo,

case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):

case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):

case (AFNUM_INET<<8 | SAFNUM_MDT):

case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):

case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):

case (AFNUM_INET<<8 | SAFNUM_MDT):

-#ifdef INET6

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

@@ -1514,7 +1523,6 @@ bgp_attr_print(netdissect_options *ndo,

case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):

-#endif

case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):

case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):

case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):

case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):

case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):

case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):

@@ -1582,7 +1590,6 @@ bgp_attr_print(netdissect_options *ndo,

tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);

}

break;

tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);

}

break;

-#ifdef INET6

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

@@ -1612,7 +1619,6 @@ bgp_attr_print(netdissect_options *ndo,

tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);

}

break;

tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);

}

break;

-#endif

case (AFNUM_VPLS<<8 | SAFNUM_VPLS):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):

case (AFNUM_VPLS<<8 | SAFNUM_VPLS):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):

@@ -1631,7 +1637,7 @@ bgp_attr_print(netdissect_options *ndo,

case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):

case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):

ND_TCHECK2(tptr[0], tlen);

case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):

case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):

ND_TCHECK2(tptr[0], tlen);

- ND_PRINT((ndo, "%s", isonsap_string(tptr, tlen)));

+ ND_PRINT((ndo, "%s", isonsap_string(ndo, tptr, tlen)));

tptr += tlen;

tlen = 0;

break;

tptr += tlen;

tlen = 0;

break;

@@ -1646,15 +1652,13 @@ bgp_attr_print(netdissect_options *ndo,

ND_TCHECK2(tptr[0], tlen);

ND_PRINT((ndo, "RD: %s, %s",

bgp_vpn_rd_print(ndo, tptr),

ND_TCHECK2(tptr[0], tlen);

ND_PRINT((ndo, "RD: %s, %s",

bgp_vpn_rd_print(ndo, tptr),

- isonsap_string(tptr+BGP_VPN_RD_LEN,tlen-BGP_VPN_RD_LEN)));

+ isonsap_string(ndo, tptr+BGP_VPN_RD_LEN,tlen-BGP_VPN_RD_LEN)));

/* rfc986 mapped IPv4 address ? */

if (EXTRACT_32BITS(tptr+BGP_VPN_RD_LEN) == 0x47000601)

ND_PRINT((ndo, " = %s", getname(ndo, tptr+BGP_VPN_RD_LEN+4)));

/* rfc986 mapped IPv4 address ? */

if (EXTRACT_32BITS(tptr+BGP_VPN_RD_LEN) == 0x47000601)

ND_PRINT((ndo, " = %s", getname(ndo, tptr+BGP_VPN_RD_LEN+4)));

-#ifdef INET6

/* rfc1888 mapped IPv6 address ? */

else if (EXTRACT_24BITS(tptr+BGP_VPN_RD_LEN) == 0x350000)

ND_PRINT((ndo, " = %s", getname6(ndo, tptr+BGP_VPN_RD_LEN+3)));

/* rfc1888 mapped IPv6 address ? */

else if (EXTRACT_24BITS(tptr+BGP_VPN_RD_LEN) == 0x350000)

ND_PRINT((ndo, " = %s", getname6(ndo, tptr+BGP_VPN_RD_LEN+3)));

-#endif

tptr += tlen;

tlen = 0;

}

tptr += tlen;

tlen = 0;

}

@@ -1755,7 +1759,6 @@ bgp_attr_print(netdissect_options *ndo,

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

-#ifdef INET6

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

@@ -1791,7 +1794,6 @@ bgp_attr_print(netdissect_options *ndo,

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

-#endif

case (AFNUM_VPLS<<8 | SAFNUM_VPLS):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):

case (AFNUM_VPLS<<8 | SAFNUM_VPLS):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):

@@ -1848,12 +1850,10 @@ bgp_attr_print(netdissect_options *ndo,

safi = tptr[2];

ND_PRINT((ndo, "\n\t AFI: %s (%u), %sSAFI: %s (%u)",

safi = tptr[2];

ND_PRINT((ndo, "\n\t AFI: %s (%u), %sSAFI: %s (%u)",

- tok2strbuf(af_values, "Unknown AFI", af,

- tokbuf, sizeof(tokbuf)),

+ tok2str(af_values, "Unknown AFI", af),

af,

(safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */

af,

(safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */

- tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_safi_values, "Unknown SAFI", safi),

safi));

if (len == BGP_MP_NLRI_MINSIZE)

safi));

if (len == BGP_MP_NLRI_MINSIZE)

@@ -1898,7 +1898,6 @@ bgp_attr_print(netdissect_options *ndo,

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

-#ifdef INET6

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNICAST):

case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):

case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):

@@ -1934,7 +1933,6 @@ bgp_attr_print(netdissect_options *ndo,

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

else

ND_PRINT((ndo, "\n\t %s", buf));

break;

-#endif

case (AFNUM_VPLS<<8 | SAFNUM_VPLS):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):

case (AFNUM_VPLS<<8 | SAFNUM_VPLS):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):

case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):

@@ -2008,15 +2006,15 @@ bgp_attr_print(netdissect_options *ndo,

break;

}

while (tlen>0) {

break;

}

while (tlen>0) {

- u_int16_t extd_comm;

+ uint16_t extd_comm;

ND_TCHECK2(tptr[0], 2);

extd_comm=EXTRACT_16BITS(tptr);

ND_PRINT((ndo, "\n\t %s (0x%04x), Flags [%s]",

ND_TCHECK2(tptr[0], 2);

extd_comm=EXTRACT_16BITS(tptr);

ND_PRINT((ndo, "\n\t %s (0x%04x), Flags [%s]",

- tok2strbuf(bgp_extd_comm_subtype_values,

+ tok2str(bgp_extd_comm_subtype_values,

"unknown extd community typecode",

- extd_comm, tokbuf, sizeof(tokbuf)),

+ extd_comm),

extd_comm,

bittok2str(bgp_extd_comm_flag_values, "none", extd_comm)));

extd_comm,

bittok2str(bgp_extd_comm_flag_values, "none", extd_comm)));

@@ -2061,19 +2059,17 @@ bgp_attr_print(netdissect_options *ndo,

case BGP_EXT_COM_OSPF_RTYPE2:

ND_PRINT((ndo, ": area:%s, router-type:%s, metric-type:%s%s",

getname(ndo, tptr+2),

case BGP_EXT_COM_OSPF_RTYPE2:

ND_PRINT((ndo, ": area:%s, router-type:%s, metric-type:%s%s",

getname(ndo, tptr+2),

- tok2strbuf(bgp_extd_comm_ospf_rtype_values,

+ tok2str(bgp_extd_comm_ospf_rtype_values,

"unknown (0x%02x)",

- *(tptr+6),

- tokbuf, sizeof(tokbuf)),

+ *(tptr+6)),

(*(tptr+7) & BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",

((*(tptr+6) == BGP_OSPF_RTYPE_EXT) || (*(tptr+6) == BGP_OSPF_RTYPE_NSSA)) ? "E1" : ""));

break;

case BGP_EXT_COM_L2INFO:

ND_PRINT((ndo, ": %s Control Flags [0x%02x]:MTU %u",

(*(tptr+7) & BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",

((*(tptr+6) == BGP_OSPF_RTYPE_EXT) || (*(tptr+6) == BGP_OSPF_RTYPE_NSSA)) ? "E1" : ""));

break;

case BGP_EXT_COM_L2INFO:

ND_PRINT((ndo, ": %s Control Flags [0x%02x]:MTU %u",

- tok2strbuf(l2vpn_encaps_values,

+ tok2str(l2vpn_encaps_values,

"unknown encaps",

- *(tptr+2),

- tokbuf, sizeof(tokbuf)),

+ *(tptr+2)),

*(tptr+3),

EXTRACT_16BITS(tptr+4)));

break;

*(tptr+3),

EXTRACT_16BITS(tptr+4)));

break;

@@ -2092,7 +2088,7 @@ bgp_attr_print(netdissect_options *ndo,

case BGPTYPE_PMSI_TUNNEL:

{

case BGPTYPE_PMSI_TUNNEL:

{

- u_int8_t tunnel_type, flags;

+ uint8_t tunnel_type, flags;

tunnel_type = *(tptr+1);

flags = *tptr;

tunnel_type = *(tptr+1);

flags = *tptr;

@@ -2148,6 +2144,49 @@ bgp_attr_print(netdissect_options *ndo,

}

break;

}

break;

}

+ case BGPTYPE_AIGP:

+ {

+ uint8_t type;

+ uint16_t length;

+ ND_TCHECK2(tptr[0], 3);

+ tlen = len;

+ while (tlen >= 3) {

+ type = *tptr;

+ length = EXTRACT_16BITS(tptr+1);

+ ND_PRINT((ndo, "\n\t %s TLV (%u), length %u",

+ tok2str(bgp_aigp_values, "Unknown", type),

+ type, length));

+ /*

+ * Check if we can read the TLV data.

+ */

+ ND_TCHECK2(tptr[3], length - 3);

+ switch (type) {

+ case BGP_AIGP_TLV:

+ ND_TCHECK2(tptr[3], 8);

+ ND_PRINT((ndo, ", metric %" PRIu64,

+ EXTRACT_64BITS(tptr+3)));

+ break;

+ default:

+ if (ndo->ndo_vflag <= 1) {

+ print_unknown_data(ndo, tptr+3,"\n\t ", length-3);

+ }

+ tptr += length;

+ tlen -= length;

+ }

+ break;

+ }

case BGPTYPE_ATTR_SET:

ND_TCHECK2(tptr[0], 4);

if (len < 4)

case BGPTYPE_ATTR_SET:

ND_TCHECK2(tptr[0], 4);

if (len < 4)

@@ -2158,7 +2197,7 @@ bgp_attr_print(netdissect_options *ndo,

len -=4;

while (len) {

len -=4;

while (len) {

- u_int aflags, atype, alenlen, alen;

+ u_int aflags, alenlen, alen;

ND_TCHECK2(tptr[0], 2);

if (len < 2)

ND_TCHECK2(tptr[0], 2);

if (len < 2)

@@ -2176,9 +2215,8 @@ bgp_attr_print(netdissect_options *ndo,

len -= alenlen;

ND_PRINT((ndo, "\n\t %s (%u), length: %u",

len -= alenlen;

ND_PRINT((ndo, "\n\t %s (%u), length: %u",

- tok2strbuf(bgp_attr_values,

- "Unknown Attribute", atype,

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_attr_values,

+ "Unknown Attribute", atype),

atype,

alen));

atype,

alen));

@@ -2222,8 +2260,6 @@ static void

bgp_capabilities_print(netdissect_options *ndo,

const u_char *opt, int caps_len)

{

bgp_capabilities_print(netdissect_options *ndo,

const u_char *opt, int caps_len)

{

- char tokbuf[TOKBUFSIZE];

- char tokbuf2[TOKBUFSIZE];

int cap_type, cap_len, tcap_len, cap_offset;

int i = 0;

int cap_type, cap_len, tcap_len, cap_offset;

int i = 0;

@@ -2233,21 +2269,19 @@ bgp_capabilities_print(netdissect_options *ndo,

cap_len=opt[i+1];

tcap_len=cap_len;

ND_PRINT((ndo, "\n\t %s (%u), length: %u",

cap_len=opt[i+1];

tcap_len=cap_len;

ND_PRINT((ndo, "\n\t %s (%u), length: %u",

- tok2strbuf(bgp_capcode_values, "Unknown",

- cap_type, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_capcode_values, "Unknown",

+ cap_type),

cap_type,

cap_len));

ND_TCHECK2(opt[i+2], cap_len);

switch (cap_type) {

case BGP_CAPCODE_MP:

ND_PRINT((ndo, "\n\t\tAFI %s (%u), SAFI %s (%u)",

cap_type,

cap_len));

ND_TCHECK2(opt[i+2], cap_len);

switch (cap_type) {

case BGP_CAPCODE_MP:

ND_PRINT((ndo, "\n\t\tAFI %s (%u), SAFI %s (%u)",

- tok2strbuf(af_values, "Unknown",

- EXTRACT_16BITS(opt+i+2),

- tokbuf, sizeof(tokbuf)),

+ tok2str(af_values, "Unknown",

+ EXTRACT_16BITS(opt+i+2)),

EXTRACT_16BITS(opt+i+2),

- tok2strbuf(bgp_safi_values, "Unknown",

- opt[i+5],

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_safi_values, "Unknown",

+ opt[i+5]),

opt[i+5]));

break;

case BGP_CAPCODE_RESTART:

opt[i+5]));

break;

case BGP_CAPCODE_RESTART:

@@ -2258,13 +2292,11 @@ bgp_capabilities_print(netdissect_options *ndo,

cap_offset=4;

while(tcap_len>=4) {

ND_PRINT((ndo, "\n\t\t AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",

cap_offset=4;

while(tcap_len>=4) {

ND_PRINT((ndo, "\n\t\t AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",

- tok2strbuf(af_values,"Unknown",

- EXTRACT_16BITS(opt+i+cap_offset),

- tokbuf, sizeof(tokbuf)),

+ tok2str(af_values,"Unknown",

+ EXTRACT_16BITS(opt+i+cap_offset)),

EXTRACT_16BITS(opt+i+cap_offset),

- tok2strbuf(bgp_safi_values,"Unknown",

- opt[i+cap_offset+2],

- tokbuf2, sizeof(tokbuf2)),

+ tok2str(bgp_safi_values,"Unknown",

+ opt[i+cap_offset+2]),

opt[i+cap_offset+2],

((opt[i+cap_offset+3])&0x80) ? "yes" : "no" ));

tcap_len-=4;

opt[i+cap_offset+2],

((opt[i+cap_offset+3])&0x80) ? "yes" : "no" ));

tcap_len-=4;

@@ -2285,6 +2317,28 @@ bgp_capabilities_print(netdissect_options *ndo,

EXTRACT_32BITS(opt + i + 2))));

}

break;

EXTRACT_32BITS(opt + i + 2))));

}

break;

+ case BGP_CAPCODE_ADD_PATH:

+ cap_offset=2;

+ if (tcap_len == 0) {

+ ND_PRINT((ndo, " (bogus)")); /* length */

+ break;

+ }

+ while (tcap_len > 0) {

+ if (tcap_len < 4) {

+ ND_PRINT((ndo, "\n\t\t(invalid)"));

+ break;

+ }

+ ND_PRINT((ndo, "\n\t\tAFI %s (%u), SAFI %s (%u), Send/Receive: %s",

+ tok2str(af_values,"Unknown",EXTRACT_16BITS(opt+i+cap_offset)),

+ EXTRACT_16BITS(opt+i+cap_offset),

+ tok2str(bgp_safi_values,"Unknown",opt[i+cap_offset+2]),

+ opt[i+cap_offset+2],

+ tok2str(bgp_add_path_recvsend,"Bogus (0x%02x)",opt[i+cap_offset+3])

+ ));

+ tcap_len-=4;

+ cap_offset+=4;

+ }

+ break;

default:

ND_PRINT((ndo, "\n\t\tno decoder for Capability %u",

cap_type));

default:

ND_PRINT((ndo, "\n\t\tno decoder for Capability %u",

cap_type));

@@ -2311,7 +2365,6 @@ bgp_open_print(netdissect_options *ndo,

struct bgp_opt bgpopt;

const u_char *opt;

int i;

struct bgp_opt bgpopt;

const u_char *opt;

int i;

- char tokbuf[TOKBUFSIZE];

ND_TCHECK2(dat[0], BGP_OPEN_SIZE);

memcpy(&bgpo, dat, BGP_OPEN_SIZE);

ND_TCHECK2(dat[0], BGP_OPEN_SIZE);

memcpy(&bgpo, dat, BGP_OPEN_SIZE);

@@ -2341,9 +2394,8 @@ bgp_open_print(netdissect_options *ndo,

}

ND_PRINT((ndo, "\n\t Option %s (%u), length: %u",

}

ND_PRINT((ndo, "\n\t Option %s (%u), length: %u",

- tok2strbuf(bgp_opt_values,"Unknown",

- bgpopt.bgpopt_type,

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_opt_values,"Unknown",

+ bgpopt.bgpopt_type),

bgpopt.bgpopt_type,

bgpopt.bgpopt_len));

bgpopt.bgpopt_type,

bgpopt.bgpopt_len));

@@ -2377,11 +2429,6 @@ bgp_update_print(netdissect_options *ndo,

int withdrawn_routes_len;

int len;

int i;

int withdrawn_routes_len;

int len;

int i;

- char tokbuf[TOKBUFSIZE];

-#ifndef INET6

- char buf[MAXHOSTNAMELEN + 100];

- int wpfx;

-#endif

ND_TCHECK2(dat[0], BGP_SIZE);

if (length < BGP_SIZE)

ND_TCHECK2(dat[0], BGP_SIZE);

if (length < BGP_SIZE)

@@ -2406,36 +2453,9 @@ bgp_update_print(netdissect_options *ndo,

ND_TCHECK2(p[0], withdrawn_routes_len);

if (length < withdrawn_routes_len)

goto trunc;

ND_TCHECK2(p[0], withdrawn_routes_len);

if (length < withdrawn_routes_len)

goto trunc;

-#ifdef INET6

ND_PRINT((ndo, "\n\t Withdrawn routes: %d bytes", withdrawn_routes_len));

p += withdrawn_routes_len;

length -= withdrawn_routes_len;

ND_PRINT((ndo, "\n\t Withdrawn routes: %d bytes", withdrawn_routes_len));

p += withdrawn_routes_len;

length -= withdrawn_routes_len;

-#else

- if (withdrawn_routes_len < 2)

- goto trunc;

- length -= 2;

- withdrawn_routes_len -= 2;

- ND_PRINT((ndo, "\n\t Withdrawn routes:"));

- while(withdrawn_routes_len > 0) {

- wpfx = decode_prefix4(ndo, p, withdrawn_routes_len, buf, sizeof(buf));

- if (wpfx == -1) {

- ND_PRINT((ndo, "\n\t (illegal prefix length)"));

- break;

- } else if (wpfx == -2)

- goto trunc;

- else if (wpfx == -3)

- goto trunc; /* bytes left, but not enough */

- else {

- ND_PRINT((ndo, "\n\t %s", buf));

- p += wpfx;

- length -= wpfx;

- withdrawn_routes_len -= wpfx;

- }

-#endif

}

ND_TCHECK2(p[0], 2);

}

ND_TCHECK2(p[0], 2);

@@ -2478,9 +2498,8 @@ bgp_update_print(netdissect_options *ndo,

length -= alenlen;

ND_PRINT((ndo, "\n\t %s (%u), length: %u",

length -= alenlen;

ND_PRINT((ndo, "\n\t %s (%u), length: %u",

- tok2strbuf(bgp_attr_values, "Unknown Attribute",

- atype,

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_attr_values, "Unknown Attribute",

+ atype),

atype,

alen));

atype,

alen));

@@ -2544,8 +2563,6 @@ bgp_notification_print(netdissect_options *ndo,

{

struct bgp_notification bgpn;

const u_char *tptr;

{

struct bgp_notification bgpn;

const u_char *tptr;

- char tokbuf[TOKBUFSIZE];

- char tokbuf2[TOKBUFSIZE];

ND_TCHECK2(dat[0], BGP_NOTIFICATION_SIZE);

memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);

ND_TCHECK2(dat[0], BGP_NOTIFICATION_SIZE);

memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);

@@ -2555,39 +2572,39 @@ bgp_notification_print(netdissect_options *ndo,

return;

ND_PRINT((ndo, ", %s (%u)",

return;

ND_PRINT((ndo, ", %s (%u)",

- tok2strbuf(bgp_notify_major_values, "Unknown Error",

- bgpn.bgpn_major, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_notify_major_values, "Unknown Error",

+ bgpn.bgpn_major),

bgpn.bgpn_major));

switch (bgpn.bgpn_major) {

case BGP_NOTIFY_MAJOR_MSG:

ND_PRINT((ndo, ", subcode %s (%u)",

bgpn.bgpn_major));

switch (bgpn.bgpn_major) {

case BGP_NOTIFY_MAJOR_MSG:

ND_PRINT((ndo, ", subcode %s (%u)",

- tok2strbuf(bgp_notify_minor_msg_values, "Unknown",

- bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_notify_minor_msg_values, "Unknown",

+ bgpn.bgpn_minor),

bgpn.bgpn_minor));

break;

case BGP_NOTIFY_MAJOR_OPEN:

ND_PRINT((ndo, ", subcode %s (%u)",

bgpn.bgpn_minor));

break;

case BGP_NOTIFY_MAJOR_OPEN:

ND_PRINT((ndo, ", subcode %s (%u)",

- tok2strbuf(bgp_notify_minor_open_values, "Unknown",

- bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_notify_minor_open_values, "Unknown",

+ bgpn.bgpn_minor),

bgpn.bgpn_minor));

break;

case BGP_NOTIFY_MAJOR_UPDATE:

ND_PRINT((ndo, ", subcode %s (%u)",

bgpn.bgpn_minor));

break;

case BGP_NOTIFY_MAJOR_UPDATE:

ND_PRINT((ndo, ", subcode %s (%u)",

- tok2strbuf(bgp_notify_minor_update_values, "Unknown",

- bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_notify_minor_update_values, "Unknown",

+ bgpn.bgpn_minor),

bgpn.bgpn_minor));

break;

case BGP_NOTIFY_MAJOR_CAP:

ND_PRINT((ndo, " subcode %s (%u)",

bgpn.bgpn_minor));

break;

case BGP_NOTIFY_MAJOR_CAP:

ND_PRINT((ndo, " subcode %s (%u)",

- tok2strbuf(bgp_notify_minor_cap_values, "Unknown",

- bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_notify_minor_cap_values, "Unknown",

+ bgpn.bgpn_minor),

bgpn.bgpn_minor));

case BGP_NOTIFY_MAJOR_CEASE:

ND_PRINT((ndo, ", subcode %s (%u)",

bgpn.bgpn_minor));

case BGP_NOTIFY_MAJOR_CEASE:

ND_PRINT((ndo, ", subcode %s (%u)",

- tok2strbuf(bgp_notify_minor_cease_values, "Unknown",

- bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_notify_minor_cease_values, "Unknown",

+ bgpn.bgpn_minor),

bgpn.bgpn_minor));

/* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes

bgpn.bgpn_minor));

/* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes

@@ -2597,11 +2614,10 @@ bgp_notification_print(netdissect_options *ndo,

tptr = dat + BGP_NOTIFICATION_SIZE;

ND_TCHECK2(*tptr, 7);

ND_PRINT((ndo, ", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",

tptr = dat + BGP_NOTIFICATION_SIZE;

ND_TCHECK2(*tptr, 7);

ND_PRINT((ndo, ", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",

- tok2strbuf(af_values, "Unknown",

- EXTRACT_16BITS(tptr), tokbuf, sizeof(tokbuf)),

+ tok2str(af_values, "Unknown",

+ EXTRACT_16BITS(tptr)),

EXTRACT_16BITS(tptr),

- tok2strbuf(bgp_safi_values, "Unknown", *(tptr+2),

- tokbuf2, sizeof(tokbuf)),

+ tok2str(bgp_safi_values, "Unknown", *(tptr+2)),

*(tptr+2),

EXTRACT_32BITS(tptr+3)));

}

*(tptr+2),

EXTRACT_32BITS(tptr+3)));

}

@@ -2617,11 +2633,9 @@ trunc:

static void

bgp_route_refresh_print(netdissect_options *ndo,

static void

bgp_route_refresh_print(netdissect_options *ndo,

- const u_char *pptr, int len) {

+ const u_char *pptr, int len)

const struct bgp_route_refresh *bgp_route_refresh_header;

- char tokbuf[TOKBUFSIZE];

- char tokbuf2[TOKBUFSIZE];

ND_TCHECK2(pptr[0], BGP_ROUTE_REFRESH_SIZE);

@@ -2632,15 +2646,13 @@ bgp_route_refresh_print(netdissect_options *ndo,

bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;

ND_PRINT((ndo, "\n\t AFI %s (%u), SAFI %s (%u)",

bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;

ND_PRINT((ndo, "\n\t AFI %s (%u), SAFI %s (%u)",

- tok2strbuf(af_values,"Unknown",

+ tok2str(af_values,"Unknown",

/* this stinks but the compiler pads the structure

* weird */

/* this stinks but the compiler pads the structure

* weird */

- EXTRACT_16BITS(&bgp_route_refresh_header->afi),

- tokbuf, sizeof(tokbuf)),

+ EXTRACT_16BITS(&bgp_route_refresh_header->afi)),

EXTRACT_16BITS(&bgp_route_refresh_header->afi),

- tok2strbuf(bgp_safi_values,"Unknown",

- bgp_route_refresh_header->safi,

- tokbuf2, sizeof(tokbuf2)),

+ tok2str(bgp_safi_values,"Unknown",

+ bgp_route_refresh_header->safi),

bgp_route_refresh_header->safi));

if (ndo->ndo_vflag > 1) {

bgp_route_refresh_header->safi));

if (ndo->ndo_vflag > 1) {

@@ -2658,13 +2670,11 @@ bgp_header_print(netdissect_options *ndo,

const u_char *dat, int length)

{

struct bgp bgp;

const u_char *dat, int length)

{

struct bgp bgp;

- char tokbuf[TOKBUFSIZE];

ND_TCHECK2(dat[0], BGP_SIZE);

memcpy(&bgp, dat, BGP_SIZE);

ND_PRINT((ndo, "\n\t%s Message (%u), length: %u",

ND_TCHECK2(dat[0], BGP_SIZE);

memcpy(&bgp, dat, BGP_SIZE);

ND_PRINT((ndo, "\n\t%s Message (%u), length: %u",

- tok2strbuf(bgp_msg_values, "Unknown", bgp.bgp_type,

- tokbuf, sizeof(tokbuf)),

+ tok2str(bgp_msg_values, "Unknown", bgp.bgp_type),

bgp.bgp_type,

length));

bgp.bgp_type,

length));

@@ -2708,14 +2718,13 @@ bgp_print(netdissect_options *ndo,

0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

};

struct bgp bgp;

0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

};

struct bgp bgp;

- u_int16_t hlen;

- char tokbuf[TOKBUFSIZE];

+ uint16_t hlen;

ep = dat + length;

if (ndo->ndo_snapend < dat + length)

ep = ndo->ndo_snapend;

ep = dat + length;

if (ndo->ndo_snapend < dat + length)

ep = ndo->ndo_snapend;

- ND_PRINT((ndo, ": BGP, length: %u", length));

+ ND_PRINT((ndo, ": BGP"));

if (ndo->ndo_vflag < 1) /* lets be less chatty */

return;

if (ndo->ndo_vflag < 1) /* lets be less chatty */

return;

@@ -2758,10 +2767,9 @@ bgp_print(netdissect_options *ndo,

start = p;

} else {

ND_PRINT((ndo, "\n[|BGP %s]",

start = p;

} else {

ND_PRINT((ndo, "\n[|BGP %s]",

- tok2strbuf(bgp_msg_values,

+ tok2str(bgp_msg_values,

"Unknown Message Type",

- bgp.bgp_type,

- tokbuf, sizeof(tokbuf))));

+ bgp.bgp_type)));

break;

}

break;

}