refine tok2str() buffer use

Switch RRCP and BGP functions from tok2strbuf() to tok2str() to avoid
unnecessary local buffer management. The latter function does it in a
way to allow up to 4 calls to itself from printf(). After that
tok2strbuf() remains used by tok2str() only and can be refined later.

Remove a duplicate macro and place the remaining definition into the
right file.

diff --git a/netdissect.h b/netdissect.h
index 460e42c9533fc8c703af22d43b41f09a32aa9eb1..19cdfe8b3c688e0420a5e81340dab12f0c27a01e 100644 (file)
--- a/netdissect.h
+++ b/netdissect.h
@@ -76,7 +76,6 @@ struct tok {
        const char *s;          /* string */
 };
 
-#define TOKBUFSIZE 128
 extern const char *tok2strbuf(const struct tok *, const char *, u_int,
                              char *buf, size_t bufsize);
 

diff --git a/print-bgp.c b/print-bgp.c
index 1cccd5ab925031ea9bb2df706205c9343a5265ed..562de9675002bfe6cf1244f985b5e0938fa829e0 100644 (file)
--- a/print-bgp.c
+++ b/print-bgp.c
@@ -462,7 +462,6 @@ static const struct tok bgp_extd_comm_ospf_rtype_values[] = {
   { 0, NULL },
 };
 
-#define TOKBUFSIZE 128
 static char astostr[20];
 
 /*
@@ -1323,7 +1322,6 @@ bgp_attr_print(netdissect_options *ndo,
        u_int tlen;
        const u_char *tptr;
        char buf[MAXHOSTNAMELEN + 100];
-       char tokbuf[TOKBUFSIZE];
         int  as_size;
 
         tptr = pptr;
@@ -1335,10 +1333,9 @@ bgp_attr_print(netdissect_options *ndo,
                        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;
 
@@ -1369,9 +1366,8 @@ bgp_attr_print(netdissect_options *ndo,
 
                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 ",
@@ -1381,9 +1377,8 @@ bgp_attr_print(netdissect_options *ndo,
                                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;
                }
@@ -1498,12 +1493,10 @@ bgp_attr_print(netdissect_options *ndo,
                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 */
-                       tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,
-                                 tokbuf, sizeof(tokbuf)),
+                       tok2str(bgp_safi_values, "Unknown SAFI", safi),
                        safi));
 
                 switch(af<<8 | safi) {
@@ -1859,12 +1852,10 @@ bgp_attr_print(netdissect_options *ndo,
                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 */
-                       tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,
-                                 tokbuf, sizeof(tokbuf)),
+                       tok2str(bgp_safi_values, "Unknown SAFI", safi),
                        safi));
 
                 if (len == BGP_MP_NLRI_MINSIZE)
@@ -2025,9 +2016,9 @@ bgp_attr_print(netdissect_options *ndo,
                     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)));
 
@@ -2072,19 +2063,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),
-                               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",
-                               tok2strbuf(l2vpn_encaps_values,
+                               tok2str(l2vpn_encaps_values,
                                          "unknown encaps",
-                                         *(tptr+2),
-                                         tokbuf, sizeof(tokbuf)),
+                                         *(tptr+2)),
                                        *(tptr+3),
                                EXTRACT_16BITS(tptr+4)));
                         break;
@@ -2229,9 +2218,8 @@ bgp_attr_print(netdissect_options *ndo,
                     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));
 
@@ -2275,8 +2263,6 @@ static void
 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;
 
@@ -2286,21 +2272,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",
-                       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)",
-                           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:
@@ -2311,13 +2295,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",
-                               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;
@@ -2364,7 +2346,6 @@ bgp_open_print(netdissect_options *ndo,
        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);
@@ -2394,9 +2375,8 @@ bgp_open_print(netdissect_options *ndo,
                }
 
                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));
 
@@ -2430,7 +2410,6 @@ bgp_update_print(netdissect_options *ndo,
        int withdrawn_routes_len;
        int len;
        int i;
-       char tokbuf[TOKBUFSIZE];
 #ifndef INET6
        char buf[MAXHOSTNAMELEN + 100];
        int wpfx;
@@ -2531,9 +2510,8 @@ bgp_update_print(netdissect_options *ndo,
                        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));
 
@@ -2597,8 +2575,6 @@ bgp_notification_print(netdissect_options *ndo,
 {
        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);
@@ -2608,39 +2584,39 @@ bgp_notification_print(netdissect_options *ndo,
             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)",
-                  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)",
-                  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)",
-                  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)",
-                  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)",
-                  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
@@ -2650,11 +2626,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",
-                      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)));
            }
@@ -2673,8 +2648,6 @@ bgp_route_refresh_print(netdissect_options *ndo,
                         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);
 
@@ -2685,15 +2658,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)",
-               tok2strbuf(af_values,"Unknown",
+               tok2str(af_values,"Unknown",
                          /* 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) {
@@ -2711,13 +2682,11 @@ bgp_header_print(netdissect_options *ndo,
                  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",
-               tok2strbuf(bgp_msg_values, "Unknown", bgp.bgp_type,
-                         tokbuf, sizeof(tokbuf)),
+               tok2str(bgp_msg_values, "Unknown", bgp.bgp_type),
                bgp.bgp_type,
                length));
 
@@ -2762,7 +2731,6 @@ bgp_print(netdissect_options *ndo,
        };
        struct bgp bgp;
        uint16_t hlen;
-       char tokbuf[TOKBUFSIZE];
 
        ep = dat + length;
        if (ndo->ndo_snapend < dat + length)
@@ -2811,10 +2779,9 @@ bgp_print(netdissect_options *ndo,
                        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;
                }
        }

diff --git a/print-rrcp.c b/print-rrcp.c
index cb1779557723b759bf2c37c857bb2819b3dff359..5f24a43ed7a63aa8e003284da4721648410ebc21 100644 (file)
--- a/print-rrcp.c
+++ b/print-rrcp.c
@@ -77,8 +77,6 @@ rrcp_print(netdissect_options *ndo,
        uint8_t rrcp_proto;
        uint8_t rrcp_opcode;
        register const struct ether_header *ep;
-       char proto_str[16];
-       char opcode_str[32];
 
        ep = (const struct ether_header *)cp;
        rrcp = cp + ETHER_HDRLEN;
@@ -90,11 +88,11 @@ rrcp_print(netdissect_options *ndo,
         ND_PRINT((ndo, "%s > %s, %s %s",
                etheraddr_string(ndo, ESRC(ep)),
                etheraddr_string(ndo, EDST(ep)),
-               tok2strbuf(proto_values,"RRCP-0x%02x",rrcp_proto,proto_str,sizeof(proto_str)),
+               tok2str(proto_values,"RRCP-0x%02x",rrcp_proto),
                ((*(rrcp + RRCP_OPCODE_ISREPLY_OFFSET)) & RRCP_ISREPLY) ? "reply" : "query"));
        if (rrcp_proto==1){
            ND_PRINT((ndo, ": %s",
-                    tok2strbuf(opcode_values,"unknown opcode (0x%02x)",rrcp_opcode,opcode_str,sizeof(opcode_str))));
+                    tok2str(opcode_values,"unknown opcode (0x%02x)",rrcp_opcode)));
        }
        if (rrcp_opcode==1 || rrcp_opcode==2){
            ND_TCHECK2(*(rrcp + RRCP_REG_ADDR_OFFSET), 6);

diff --git a/util-print.c b/util-print.c
index 2c9f54fab17cd92fc5fe2f606dd1f4e0986e93c0..758aa77331bcae80af9d2a12f3d607c2a8f074e7 100644 (file)
--- a/util-print.c
+++ b/util-print.c
@@ -62,6 +62,8 @@ int32_t thiszone;             /* seconds offset from gmt to local time */
  */
 #define TS_BUF_SIZE sizeof("0000000000.000000000")
 
+#define TOKBUFSIZE 128
+
 /*
  * Print out a null-terminated filename (or other ascii string).
  * If ep is NULL, assume no truncation check is needed.
@@ -383,7 +385,7 @@ const char *
 tok2str(register const struct tok *lp, register const char *fmt,
        register u_int v)
 {
-       static char buf[4][128];
+       static char buf[4][TOKBUFSIZE];
        static int idx = 0;
        char *ret;
 
@@ -465,7 +467,7 @@ const char *
 tok2strary_internal(register const char **lp, int n, register const char *fmt,
        register int v)
 {
-       static char buf[128];
+       static char buf[TOKBUFSIZE];
 
        if (v >= 0 && v < n && lp[v] != NULL)
                return lp[v];