change make check to work with POSIX shell

[tcpdump] / addrtoname.c

diff --git a/addrtoname.c b/addrtoname.c
index 5831b3467973a297e4261e1bddf31463b4670ddd..15e57411f52c6be2c1bee49af3d254014c5bd35d 100644 (file)
--- a/addrtoname.c
+++ b/addrtoname.c
@@ -120,7 +120,7 @@ win32_gethostbyaddr(const char *addr, int len, int type)
                    hname, sizeof(hname), NULL, 0, 0)) {
                        return NULL;
                } else {
                    hname, sizeof(hname), NULL, 0, 0)) {
                        return NULL;
                } else {

-                       strcpy(host.h_name, hname);
+                       strlcpy(host.h_name, hname, NI_MAXHOST);

                        return &host;
                }
                break;
                        return &host;
                }
                break;


@@ -145,13 +145,23 @@ struct enamemem {
        u_short e_addr2;
        const char *e_name;
        u_char *e_nsap;                 /* used only for nsaptable[] */
        u_short e_addr2;
        const char *e_name;
        u_char *e_nsap;                 /* used only for nsaptable[] */

-#define e_bs e_nsap                    /* for bytestringtable */

        struct enamemem *e_nxt;
 };
 
 static struct enamemem enametable[HASHNAMESIZE];
 static struct enamemem nsaptable[HASHNAMESIZE];
        struct enamemem *e_nxt;
 };
 
 static struct enamemem enametable[HASHNAMESIZE];
 static struct enamemem nsaptable[HASHNAMESIZE];

-static struct enamemem bytestringtable[HASHNAMESIZE];
+
+struct bsnamemem {
+       u_short bs_addr0;
+       u_short bs_addr1;
+       u_short bs_addr2;
+       const char *bs_name;
+       u_char *bs_bytes;
+       unsigned int bs_nbytes;
+       struct bsnamemem *bs_nxt;
+};
+
+static struct bsnamemem bytestringtable[HASHNAMESIZE];

 
 struct protoidmem {
        uint32_t p_oui;
 
 struct protoidmem {
        uint32_t p_oui;


@@ -321,7 +331,7 @@ getname6(netdissect_options *ndo, const u_char *ap)
        return (p->name);
 }
 
        return (p->name);
 }
 

-static const char hex[] = "0123456789abcdef";
+static const char hex[16] = "0123456789abcdef";

 
 
 /* Find the hash node that corresponds the ether address 'ep' */
 
 
 /* Find the hash node that corresponds the ether address 'ep' */


@@ -359,11 +369,11 @@ lookup_emem(netdissect_options *ndo, const u_char *ep)
  * with length 'nlen'
  */
 
  * with length 'nlen'
  */
 

-static inline struct enamemem *
+static inline struct bsnamemem *

 lookup_bytestring(netdissect_options *ndo, register const u_char *bs,
                  const unsigned int nlen)
 {
 lookup_bytestring(netdissect_options *ndo, register const u_char *bs,
                  const unsigned int nlen)
 {

-       struct enamemem *tp;
+       struct bsnamemem *tp;

        register u_int i, j, k;
 
        if (nlen >= 6) {
        register u_int i, j, k;
 
        if (nlen >= 6) {


@@ -378,26 +388,28 @@ lookup_bytestring(netdissect_options *ndo, register const u_char *bs,
                i = j = k = 0;
 
        tp = &bytestringtable[(i ^ j) & (HASHNAMESIZE-1)];
                i = j = k = 0;
 
        tp = &bytestringtable[(i ^ j) & (HASHNAMESIZE-1)];

-       while (tp->e_nxt)
-               if (tp->e_addr0 == i &&
-                   tp->e_addr1 == j &&
-                   tp->e_addr2 == k &&
-                   memcmp((const char *)bs, (const char *)(tp->e_bs), nlen) == 0)
+       while (tp->bs_nxt)
+               if (nlen == tp->bs_nbytes &&
+                   tp->bs_addr0 == i &&
+                   tp->bs_addr1 == j &&
+                   tp->bs_addr2 == k &&
+                   memcmp((const char *)bs, (const char *)(tp->bs_bytes), nlen) == 0)

                        return tp;
                else
                        return tp;
                else

-                       tp = tp->e_nxt;
+                       tp = tp->bs_nxt;

 
 

-       tp->e_addr0 = i;
-       tp->e_addr1 = j;
-       tp->e_addr2 = k;
+       tp->bs_addr0 = i;
+       tp->bs_addr1 = j;
+       tp->bs_addr2 = k;

 
 

-       tp->e_bs = (u_char *) calloc(1, nlen + 1);
-       if (tp->e_bs == NULL)
+       tp->bs_bytes = (u_char *) calloc(1, nlen);
+       if (tp->bs_bytes == NULL)

                (*ndo->ndo_error)(ndo, "lookup_bytestring: calloc");
 
                (*ndo->ndo_error)(ndo, "lookup_bytestring: calloc");
 

-       memcpy(tp->e_bs, bs, nlen);
-       tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
-       if (tp->e_nxt == NULL)
+       memcpy(tp->bs_bytes, bs, nlen);
+       tp->bs_nbytes = nlen;
+       tp->bs_nxt = (struct bsnamemem *)calloc(1, sizeof(*tp));
+       if (tp->bs_nxt == NULL)

                (*ndo->ndo_error)(ndo, "lookup_bytestring: calloc");
 
        return tp;
                (*ndo->ndo_error)(ndo, "lookup_bytestring: calloc");
 
        return tp;


@@ -406,14 +418,15 @@ lookup_bytestring(netdissect_options *ndo, register const u_char *bs,
 /* Find the hash node that corresponds the NSAP 'nsap' */
 
 static inline struct enamemem *
 /* Find the hash node that corresponds the NSAP 'nsap' */
 
 static inline struct enamemem *

-lookup_nsap(netdissect_options *ndo, register const u_char *nsap)
+lookup_nsap(netdissect_options *ndo, register const u_char *nsap,
+           register u_int nsap_length)

 {
        register u_int i, j, k;
 {
        register u_int i, j, k;

-       unsigned int nlen = *nsap;

        struct enamemem *tp;
        struct enamemem *tp;

-       const u_char *ensap = nsap + nlen - 6;
+       const u_char *ensap;

 
 

-       if (nlen > 6) {
+       if (nsap_length > 6) {
+               ensap = nsap + nsap_length - 6;

                k = (ensap[0] << 8) | ensap[1];
                j = (ensap[2] << 8) | ensap[3];
                i = (ensap[4] << 8) | ensap[5];
                k = (ensap[0] << 8) | ensap[1];
                j = (ensap[2] << 8) | ensap[3];
                i = (ensap[4] << 8) | ensap[5];


@@ -423,22 +436,23 @@ lookup_nsap(netdissect_options *ndo, register const u_char *nsap)
 
        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];
        while (tp->e_nxt)
 
        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];
        while (tp->e_nxt)

-               if (tp->e_addr0 == i &&
+               if (nsap_length == tp->e_nsap[0] &&
+                   tp->e_addr0 == i &&

                    tp->e_addr1 == j &&
                    tp->e_addr2 == k &&
                    tp->e_addr1 == j &&
                    tp->e_addr2 == k &&

-                   tp->e_nsap[0] == nlen &&
-                   memcmp((const char *)&(nsap[1]),
-                       (char *)&(tp->e_nsap[1]), nlen) == 0)
+                   memcmp((const char *)nsap,
+                       (char *)&(tp->e_nsap[1]), nsap_length) == 0)

                        return tp;
                else
                        tp = tp->e_nxt;
        tp->e_addr0 = i;
        tp->e_addr1 = j;
        tp->e_addr2 = k;
                        return tp;
                else
                        tp = tp->e_nxt;
        tp->e_addr0 = i;
        tp->e_addr1 = j;
        tp->e_addr2 = k;

-       tp->e_nsap = (u_char *)malloc(nlen + 1);
+       tp->e_nsap = (u_char *)malloc(nsap_length + 1);

        if (tp->e_nsap == NULL)
                (*ndo->ndo_error)(ndo, "lookup_nsap: malloc");
        if (tp->e_nsap == NULL)
                (*ndo->ndo_error)(ndo, "lookup_nsap: malloc");

-       memcpy((char *)tp->e_nsap, (const char *)nsap, nlen + 1);
+       tp->e_nsap[0] = (u_char)nsap_length;    /* guaranteed < ISONSAP_MAX_LENGTH */
+       memcpy((char *)&tp->e_nsap[1], (const char *)nsap, nsap_length);

        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)
                (*ndo->ndo_error)(ndo, "lookup_nsap: calloc");
        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)
                (*ndo->ndo_error)(ndo, "lookup_nsap: calloc");


@@ -526,12 +540,12 @@ le64addr_string(netdissect_options *ndo, const u_char *ep)
        const unsigned int len = 8;
        register u_int i;
        register char *cp;
        const unsigned int len = 8;
        register u_int i;
        register char *cp;

-       register struct enamemem *tp;
+       register struct bsnamemem *tp;

        char buf[BUFSIZE];
 
        tp = lookup_bytestring(ndo, ep, len);
        char buf[BUFSIZE];
 
        tp = lookup_bytestring(ndo, ep, len);

-       if (tp->e_name)
-               return (tp->e_name);
+       if (tp->bs_name)
+               return (tp->bs_name);

 
        cp = buf;
        for (i = len; i > 0 ; --i) {
 
        cp = buf;
        for (i = len; i > 0 ; --i) {


@@ -543,11 +557,11 @@ le64addr_string(netdissect_options *ndo, const u_char *ep)
 
        *cp = '\0';
 
 
        *cp = '\0';
 

-       tp->e_name = strdup(buf);
-       if (tp->e_name == NULL)
+       tp->bs_name = strdup(buf);
+       if (tp->bs_name == NULL)

                (*ndo->ndo_error)(ndo, "le64addr_string: strdup(buf)");
 
                (*ndo->ndo_error)(ndo, "le64addr_string: strdup(buf)");
 

-       return (tp->e_name);
+       return (tp->bs_name);

 }
 
 const char *
 }
 
 const char *


@@ -556,7 +570,7 @@ linkaddr_string(netdissect_options *ndo, const u_char *ep,
 {
        register u_int i;
        register char *cp;
 {
        register u_int i;
        register char *cp;

-       register struct enamemem *tp;
+       register struct bsnamemem *tp;

 
        if (len == 0)
                return ("<empty>");
 
        if (len == 0)
                return ("<empty>");


@@ -568,11 +582,11 @@ linkaddr_string(netdissect_options *ndo, const u_char *ep,
                return (q922_string(ndo, ep, len));
 
        tp = lookup_bytestring(ndo, ep, len);
                return (q922_string(ndo, ep, len));
 
        tp = lookup_bytestring(ndo, ep, len);

-       if (tp->e_name)
-               return (tp->e_name);
+       if (tp->bs_name)
+               return (tp->bs_name);

 
 

-       tp->e_name = cp = (char *)malloc(len*3);
-       if (tp->e_name == NULL)
+       tp->bs_name = cp = (char *)malloc(len*3);
+       if (tp->bs_name == NULL)

                (*ndo->ndo_error)(ndo, "linkaddr_string: malloc");
        *cp++ = hex[*ep >> 4];
        *cp++ = hex[*ep++ & 0xf];
                (*ndo->ndo_error)(ndo, "linkaddr_string: malloc");
        *cp++ = hex[*ep >> 4];
        *cp++ = hex[*ep++ & 0xf];


@@ -582,7 +596,7 @@ linkaddr_string(netdissect_options *ndo, const u_char *ep,
                *cp++ = hex[*ep++ & 0xf];
        }
        *cp = '\0';
                *cp++ = hex[*ep++ & 0xf];
        }
        *cp = '\0';

-       return (tp->e_name);
+       return (tp->bs_name);

 }
 
 const char *
 }
 
 const char *


@@ -654,7 +668,7 @@ isonsap_string(netdissect_options *ndo, const u_char *nsap,
        if (nsap_length < 1 || nsap_length > ISONSAP_MAX_LENGTH)
                return ("isonsap_string: illegal length");
 
        if (nsap_length < 1 || nsap_length > ISONSAP_MAX_LENGTH)
                return ("isonsap_string: illegal length");
 

-       tp = lookup_nsap(ndo, nsap);
+       tp = lookup_nsap(ndo, nsap, nsap_length);

        if (tp->e_name)
                return tp->e_name;
 
        if (tp->e_name)
                return tp->e_name;
 


@@ -1212,10 +1226,7 @@ dnaddr_string(netdissect_options *ndo, u_short dnaddr)
 
        tp->addr = dnaddr;
        tp->nxt = newhnamemem(ndo);
 
        tp->addr = dnaddr;
        tp->nxt = newhnamemem(ndo);

-       if (ndo->ndo_nflag)
-               tp->name = dnnum_string(ndo, dnaddr);
-       else
-               tp->name = dnname_string(ndo, dnaddr);
+       tp->name = dnnum_string(ndo, dnaddr);

 
        return(tp->name);
 }
 
        return(tp->name);
 }