* Internet, ethernet, port, and protocol string to address
* and address to string conversion routines
*/
-#ifndef lint
-static const char rcsid[] _U_ =
- "@(#) $Header: /tcpdump/master/tcpdump/addrtoname.c,v 1.106 2005-01-04 00:07:09 guy Exp $ (LBL)";
-#endif
#ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
#endif
-#include <tcpdump-stdinc.h>
+#ifdef HAVE_CASPER
+#include <libcasper.h>
+#include <casper/cap_dns.h>
+#endif /* HAVE_CASPER */
-#ifdef USE_ETHER_NTOHOST
-#ifdef HAVE_NETINET_IF_ETHER_H
-struct mbuf; /* Squelch compiler warnings on some platforms for */
-struct rtentry; /* declarations in <net/if.h> */
-#include <net/if.h> /* for "struct ifnet" in "struct arpcom" on Solaris */
-#include <netinet/if_ether.h>
-#endif /* HAVE_NETINET_IF_ETHER_H */
-#ifdef HAVE_NETINET_ETHER_H
-#include <netinet/ether.h> /* ether_ntohost on linux */
-#endif /* HAVE_NETINET_ETHER_H */
-#endif /* USE_ETHER_NTOHOST */
+#include "netdissect-stdinc.h"
+
+#ifndef NTOHL
+#define NTOHL(x) (x) = ntohl(x)
+#define NTOHS(x) (x) = ntohs(x)
+#define HTONL(x) (x) = htonl(x)
+#define HTONS(x) (x) = htons(x)
+#endif
+
+#ifdef _WIN32
+ /*
+ * We have our own ether_ntohost(), reading from the system's
+ * Ethernet address file.
+ */
+ #include "missing/win_ether_ntohost.h"
+#else
+ #ifdef USE_ETHER_NTOHOST
+ #if defined(NET_ETHERNET_H_DECLARES_ETHER_NTOHOST)
+ /*
+ * OK, just include <net/ethernet.h>.
+ */
+ #include <net/ethernet.h>
+ #elif defined(NETINET_ETHER_H_DECLARES_ETHER_NTOHOST)
+ /*
+ * OK, just include <netinet/ether.h>
+ */
+ #include <netinet/ether.h>
+ #elif defined(SYS_ETHERNET_H_DECLARES_ETHER_NTOHOST)
+ /*
+ * OK, just include <sys/ethernet.h>
+ */
+ #include <sys/ethernet.h>
+ #elif defined(ARPA_INET_H_DECLARES_ETHER_NTOHOST)
+ /*
+ * OK, just include <arpa/inet.h>
+ */
+ #include <arpa/inet.h>
+ #elif defined(NETINET_IF_ETHER_H_DECLARES_ETHER_NTOHOST)
+ /*
+ * OK, include <netinet/if_ether.h>, after all the other stuff we
+ * need to include or define for its benefit.
+ */
+ #define NEED_NETINET_IF_ETHER_H
+ #else
+ /*
+ * We'll have to declare it ourselves.
+ * If <netinet/if_ether.h> defines struct ether_addr, include
+ * it. Otherwise, define it ourselves.
+ */
+ #ifdef HAVE_STRUCT_ETHER_ADDR
+ #define NEED_NETINET_IF_ETHER_H
+ #else /* HAVE_STRUCT_ETHER_ADDR */
+ struct ether_addr {
+ unsigned char ether_addr_octet[6];
+ };
+ #endif /* HAVE_STRUCT_ETHER_ADDR */
+ #endif /* what declares ether_ntohost() */
+
+ #ifdef NEED_NETINET_IF_ETHER_H
+ #include <net/if.h> /* Needed on some platforms */
+ #include <netinet/in.h> /* Needed on some platforms */
+ #include <netinet/if_ether.h>
+ #endif /* NEED_NETINET_IF_ETHER_H */
+
+ #ifndef HAVE_DECL_ETHER_NTOHOST
+ /*
+ * No header declares it, so declare it ourselves.
+ */
+ extern int ether_ntohost(char *, const struct ether_addr *);
+ #endif /* !defined(HAVE_DECL_ETHER_NTOHOST) */
+ #endif /* USE_ETHER_NTOHOST */
+#endif /* _WIN32 */
#include <pcap.h>
#include <pcap-namedb.h>
+#ifndef HAVE_GETSERVENT
+#include <getservent.h>
+#endif
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
-#include "interface.h"
+#include "netdissect.h"
#include "addrtoname.h"
+#include "addrtostr.h"
+#include "ethertype.h"
#include "llc.h"
-#include "setsignal.h"
+#include "extract.h"
+#include "oui.h"
/*
* hash tables for whatever-to-name translations
*
- * XXX there has to be error checks against strdup(3) failure
+ * ndo_error() called on strdup(3) failure with S_ERR_ND_MEM_ALLOC status
*/
#define HASHNAMESIZE 4096
struct hnamemem {
- u_int32_t addr;
+ uint32_t addr;
const char *name;
struct hnamemem *nxt;
};
-struct hnamemem hnametable[HASHNAMESIZE];
-struct hnamemem tporttable[HASHNAMESIZE];
-struct hnamemem uporttable[HASHNAMESIZE];
-struct hnamemem eprototable[HASHNAMESIZE];
-struct hnamemem dnaddrtable[HASHNAMESIZE];
-struct hnamemem llcsaptable[HASHNAMESIZE];
-struct hnamemem ipxsaptable[HASHNAMESIZE];
+static struct hnamemem hnametable[HASHNAMESIZE];
+static struct hnamemem tporttable[HASHNAMESIZE];
+static struct hnamemem uporttable[HASHNAMESIZE];
+static struct hnamemem eprototable[HASHNAMESIZE];
+static struct hnamemem dnaddrtable[HASHNAMESIZE];
+static struct hnamemem ipxsaptable[HASHNAMESIZE];
-#if defined(INET6) && defined(WIN32)
+#ifdef _WIN32
/*
* fake gethostbyaddr for Win2k/XP
* gethostbyaddr() returns incorrect value when AF_INET6 is passed
hname, sizeof(hname), NULL, 0, 0)) {
return NULL;
} else {
- strcpy(host.h_name, hname);
+ strlcpy(host.h_name, hname, NI_MAXHOST);
return &host;
}
break;
}
}
#define gethostbyaddr win32_gethostbyaddr
-#endif /* INET6 & WIN32 */
+#endif /* _WIN32 */
-#ifdef INET6
struct h6namemem {
struct in6_addr addr;
char *name;
struct h6namemem *nxt;
};
-struct h6namemem h6nametable[HASHNAMESIZE];
-#endif /* INET6 */
+static struct h6namemem h6nametable[HASHNAMESIZE];
struct enamemem {
u_short e_addr0;
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;
};
-struct enamemem enametable[HASHNAMESIZE];
-struct enamemem nsaptable[HASHNAMESIZE];
-struct enamemem bytestringtable[HASHNAMESIZE];
+static struct enamemem enametable[HASHNAMESIZE];
+static struct enamemem nsaptable[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 {
- u_int32_t p_oui;
+ uint32_t p_oui;
u_short p_proto;
const char *p_name;
struct protoidmem *p_nxt;
};
-struct protoidmem protoidtable[HASHNAMESIZE];
+static struct protoidmem protoidtable[HASHNAMESIZE];
/*
* A faster replacement for inet_ntoa().
*/
const char *
-intoa(u_int32_t addr)
+intoa(uint32_t addr)
{
- register char *cp;
- register u_int byte;
- register int n;
+ char *cp;
+ u_int byte;
+ int n;
static char buf[sizeof(".xxx.xxx.xxx.xxx")];
NTOHL(addr);
- cp = &buf[sizeof buf];
+ cp = buf + sizeof(buf);
*--cp = '\0';
n = 4;
do {
byte = addr & 0xff;
- *--cp = byte % 10 + '0';
+ *--cp = (char)(byte % 10) + '0';
byte /= 10;
if (byte > 0) {
- *--cp = byte % 10 + '0';
+ *--cp = (char)(byte % 10) + '0';
byte /= 10;
if (byte > 0)
- *--cp = byte + '0';
+ *--cp = (char)byte + '0';
}
*--cp = '.';
addr >>= 8;
return cp + 1;
}
-static u_int32_t f_netmask;
-static u_int32_t f_localnet;
+static uint32_t f_netmask;
+static uint32_t f_localnet;
+#ifdef HAVE_CASPER
+extern cap_channel_t *capdns;
+#endif
/*
* Return a name for the IP address pointed to by ap. This address
*
* NOTE: ap is *NOT* necessarily part of the packet data (not even if
* this is being called with the "ipaddr_string()" macro), so you
- * *CANNOT* use the TCHECK{2}/TTEST{2} macros on it. Furthermore,
+ * *CANNOT* use the ND_TCHECK_* or ND_TTEST_* macros on it. Furthermore,
* even in cases where it *is* part of the packet data, the caller
* would still have to check for a null return value, even if it's
* just printing the return value with "%s" - not all versions of
* also needs to check whether they're present in the packet buffer.
*/
const char *
-getname(const u_char *ap)
+ipaddr_string(netdissect_options *ndo, const u_char *ap)
{
- register struct hostent *hp;
- u_int32_t addr;
- static struct hnamemem *p; /* static for longjmp() */
+ struct hostent *hp;
+ uint32_t addr;
+ struct hnamemem *p;
memcpy(&addr, ap, sizeof(addr));
p = &hnametable[addr & (HASHNAMESIZE-1)];
return (p->name);
}
p->addr = addr;
- p->nxt = newhnamemem();
+ p->nxt = newhnamemem(ndo);
/*
* Print names unless:
* given, f_netmask and f_localnet are 0 and the test
* evaluates to true)
*/
- if (!nflag &&
+ if (!ndo->ndo_nflag &&
(addr & f_netmask) == f_localnet) {
- hp = gethostbyaddr((char *)&addr, 4, AF_INET);
+#ifdef HAVE_CASPER
+ if (capdns != NULL) {
+ hp = cap_gethostbyaddr(capdns, (char *)&addr, 4,
+ AF_INET);
+ } else
+#endif
+ hp = gethostbyaddr((char *)&addr, 4, AF_INET);
if (hp) {
char *dotp;
p->name = strdup(hp->h_name);
- if (Nflag) {
+ if (p->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "ipaddr_string: strdup(hp->h_name)");
+ if (ndo->ndo_Nflag) {
/* Remove domain qualifications */
dotp = strchr(p->name, '.');
if (dotp)
}
}
p->name = strdup(intoa(addr));
+ if (p->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "ipaddr_string: strdup(intoa(addr))");
return (p->name);
}
-#ifdef INET6
/*
* Return a name for the IP6 address pointed to by ap. This address
* is assumed to be in network byte order.
*/
const char *
-getname6(const u_char *ap)
+ip6addr_string(netdissect_options *ndo, const u_char *ap)
{
- register struct hostent *hp;
- struct in6_addr addr;
- static struct h6namemem *p; /* static for longjmp() */
- register const char *cp;
+ struct hostent *hp;
+ union {
+ struct in6_addr addr;
+ struct for_hash_addr {
+ char fill[14];
+ uint16_t d;
+ } addra;
+ } addr;
+ struct h6namemem *p;
+ const char *cp;
char ntop_buf[INET6_ADDRSTRLEN];
memcpy(&addr, ap, sizeof(addr));
- p = &h6nametable[*(u_int16_t *)&addr.s6_addr[14] & (HASHNAMESIZE-1)];
+ p = &h6nametable[addr.addra.d & (HASHNAMESIZE-1)];
for (; p->nxt; p = p->nxt) {
if (memcmp(&p->addr, &addr, sizeof(addr)) == 0)
return (p->name);
}
- p->addr = addr;
- p->nxt = newh6namemem();
+ p->addr = addr.addr;
+ p->nxt = newh6namemem(ndo);
/*
* Do not print names if -n was given.
*/
- if (!nflag) {
- hp = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET6);
+ if (!ndo->ndo_nflag) {
+#ifdef HAVE_CASPER
+ if (capdns != NULL) {
+ hp = cap_gethostbyaddr(capdns, (char *)&addr,
+ sizeof(addr), AF_INET6);
+ } else
+#endif
+ hp = gethostbyaddr((char *)&addr, sizeof(addr),
+ AF_INET6);
if (hp) {
char *dotp;
p->name = strdup(hp->h_name);
- if (Nflag) {
+ if (p->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "ip6addr_string: strdup(hp->h_name)");
+ if (ndo->ndo_Nflag) {
/* Remove domain qualifications */
dotp = strchr(p->name, '.');
if (dotp)
return (p->name);
}
}
- cp = inet_ntop(AF_INET6, &addr, ntop_buf, sizeof(ntop_buf));
+ cp = addrtostr6(ap, ntop_buf, sizeof(ntop_buf));
p->name = strdup(cp);
+ if (p->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "ip6addr_string: strdup(cp)");
return (p->name);
}
-#endif /* INET6 */
-
-static char hex[] = "0123456789abcdef";
+static const char hex[16] = {
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+};
/* Find the hash node that corresponds the ether address 'ep' */
-static inline struct enamemem *
-lookup_emem(const u_char *ep)
+static struct enamemem *
+lookup_emem(netdissect_options *ndo, const u_char *ep)
{
- register u_int i, j, k;
+ u_int i, j, k;
struct enamemem *tp;
k = (ep[0] << 8) | ep[1];
return tp;
else
tp = tp->e_nxt;
- tp->e_addr0 = i;
- tp->e_addr1 = j;
- tp->e_addr2 = k;
+ tp->e_addr0 = (u_short)i;
+ tp->e_addr1 = (u_short)j;
+ tp->e_addr2 = (u_short)k;
tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
if (tp->e_nxt == NULL)
- error("lookup_emem: calloc");
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_emem: calloc");
return tp;
}
* with length 'nlen'
*/
-static inline struct enamemem *
-lookup_bytestring(register const u_char *bs, const unsigned int nlen)
+static struct bsnamemem *
+lookup_bytestring(netdissect_options *ndo, const u_char *bs,
+ const unsigned int nlen)
{
- struct enamemem *tp;
- register u_int i, j, k;
+ struct bsnamemem *tp;
+ u_int i, j, k;
if (nlen >= 6) {
k = (bs[0] << 8) | bs[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
- tp = tp->e_nxt;
+ tp = tp->bs_nxt;
- tp->e_addr0 = i;
- tp->e_addr1 = j;
- tp->e_addr2 = k;
+ tp->bs_addr0 = (u_short)i;
+ tp->bs_addr1 = (u_short)j;
+ tp->bs_addr2 = (u_short)k;
- tp->e_bs = (u_char *) calloc(1, nlen + 1);
- memcpy(tp->e_bs, bs, nlen);
- tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
- if (tp->e_nxt == NULL)
- error("lookup_bytestring: calloc");
+ tp->bs_bytes = (u_char *) calloc(1, nlen);
+ if (tp->bs_bytes == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "lookup_bytestring: calloc");
+
+ 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, S_ERR_ND_MEM_ALLOC,
+ "lookup_bytestring: calloc");
return tp;
}
/* Find the hash node that corresponds the NSAP 'nsap' */
-static inline struct enamemem *
-lookup_nsap(register const u_char *nsap)
+static struct enamemem *
+lookup_nsap(netdissect_options *ndo, const u_char *nsap,
+ u_int nsap_length)
{
- register u_int i, j, k;
- unsigned int nlen = *nsap;
+ u_int i, j, k;
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];
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_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;
- tp->e_nsap = (u_char *)malloc(nlen + 1);
+ tp->e_addr0 = (u_short)i;
+ tp->e_addr1 = (u_short)j;
+ tp->e_addr2 = (u_short)k;
+ tp->e_nsap = (u_char *)malloc(nsap_length + 1);
if (tp->e_nsap == NULL)
- error("lookup_nsap: malloc");
- memcpy((char *)tp->e_nsap, (const char *)nsap, nlen + 1);
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_nsap: malloc");
+ 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)
- error("lookup_nsap: calloc");
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_nsap: calloc");
return tp;
}
/* Find the hash node that corresponds the protoid 'pi'. */
-static inline struct protoidmem *
-lookup_protoid(const u_char *pi)
+static struct protoidmem *
+lookup_protoid(netdissect_options *ndo, const u_char *pi)
{
- register u_int i, j;
+ u_int i, j;
struct protoidmem *tp;
/* 5 octets won't be aligned */
else
tp = tp->p_nxt;
tp->p_oui = i;
- tp->p_proto = j;
+ tp->p_proto = (u_short)j;
tp->p_nxt = (struct protoidmem *)calloc(1, sizeof(*tp));
if (tp->p_nxt == NULL)
- error("lookup_protoid: calloc");
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_protoid: calloc");
return tp;
}
const char *
-etheraddr_string(register const u_char *ep)
+etheraddr_string(netdissect_options *ndo, const uint8_t *ep)
{
- register u_int i;
- register char *cp;
- register struct enamemem *tp;
- char buf[sizeof("00:00:00:00:00:00")];
+ int i;
+ char *cp;
+ struct enamemem *tp;
+ int oui;
+ char buf[BUFSIZE];
- tp = lookup_emem(ep);
+ tp = lookup_emem(ndo, ep);
if (tp->e_name)
return (tp->e_name);
#ifdef USE_ETHER_NTOHOST
- if (!nflag) {
- char buf2[128];
+ if (!ndo->ndo_nflag) {
+ char buf2[BUFSIZE];
+
if (ether_ntohost(buf2, (const struct ether_addr *)ep) == 0) {
tp->e_name = strdup(buf2);
+ if (tp->e_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "etheraddr_string: strdup(buf2)");
return (tp->e_name);
}
}
#endif
cp = buf;
- *cp++ = hex[*ep >> 4 ];
+ oui = EXTRACT_BE_U_3(ep);
+ *cp++ = hex[*ep >> 4 ];
*cp++ = hex[*ep++ & 0xf];
- for (i = 5; (int)--i >= 0;) {
+ for (i = 5; --i >= 0;) {
*cp++ = ':';
- *cp++ = hex[*ep >> 4 ];
+ *cp++ = hex[*ep >> 4 ];
*cp++ = hex[*ep++ & 0xf];
}
- *cp = '\0';
+
+ if (!ndo->ndo_nflag) {
+ nd_snprintf(cp, BUFSIZE - (2 + 5*3), " (oui %s)",
+ tok2str(oui_values, "Unknown", oui));
+ } else
+ *cp = '\0';
tp->e_name = strdup(buf);
+ if (tp->e_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "etheraddr_string: strdup(buf)");
return (tp->e_name);
}
const char *
-linkaddr_string(const u_char *ep, const unsigned int len)
+le64addr_string(netdissect_options *ndo, const uint8_t *ep)
{
- register u_int i;
- register char *cp;
- register struct enamemem *tp;
+ const unsigned int len = 8;
+ u_int i;
+ char *cp;
+ struct bsnamemem *tp;
+ char buf[BUFSIZE];
- if (len == 6) /* XXX not totally correct... */
- return etheraddr_string(ep);
+ tp = lookup_bytestring(ndo, ep, len);
+ if (tp->bs_name)
+ return (tp->bs_name);
- tp = lookup_bytestring(ep, len);
- if (tp->e_name)
- return (tp->e_name);
-
- tp->e_name = cp = (char *)malloc(len*3);
- if (tp->e_name == NULL)
- error("linkaddr_string: malloc");
- *cp++ = hex[*ep >> 4];
- *cp++ = hex[*ep++ & 0xf];
- for (i = len-1; i > 0 ; --i) {
+ cp = buf;
+ for (i = len; i > 0 ; --i) {
+ *cp++ = hex[*(ep + i - 1) >> 4];
+ *cp++ = hex[*(ep + i - 1) & 0xf];
*cp++ = ':';
- *cp++ = hex[*ep >> 4];
- *cp++ = hex[*ep++ & 0xf];
}
+ cp --;
+
*cp = '\0';
- return (tp->e_name);
+
+ tp->bs_name = strdup(buf);
+ if (tp->bs_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "le64addr_string: strdup(buf)");
+
+ return (tp->bs_name);
}
const char *
-etherproto_string(u_short port)
+linkaddr_string(netdissect_options *ndo, const uint8_t *ep,
+ const unsigned int type, const unsigned int len)
{
- register char *cp;
- register struct hnamemem *tp;
- register u_int32_t i = port;
- char buf[sizeof("0000")];
-
- for (tp = &eprototable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
- if (tp->addr == i)
- return (tp->name);
+ u_int i;
+ char *cp;
+ struct bsnamemem *tp;
- tp->addr = i;
- tp->nxt = newhnamemem();
+ if (len == 0)
+ return ("<empty>");
- cp = buf;
- NTOHS(port);
- *cp++ = hex[port >> 12 & 0xf];
- *cp++ = hex[port >> 8 & 0xf];
- *cp++ = hex[port >> 4 & 0xf];
- *cp++ = hex[port & 0xf];
- *cp++ = '\0';
- tp->name = strdup(buf);
- return (tp->name);
-}
+ if (type == LINKADDR_ETHER && len == MAC_ADDR_LEN)
+ return (etheraddr_string(ndo, ep));
-const char *
-protoid_string(register const u_char *pi)
-{
- register u_int i, j;
- register char *cp;
- register struct protoidmem *tp;
- char buf[sizeof("00:00:00:00:00")];
+ if (type == LINKADDR_FRELAY)
+ return (q922_string(ndo, ep, len));
- tp = lookup_protoid(pi);
- if (tp->p_name)
- return tp->p_name;
+ tp = lookup_bytestring(ndo, ep, len);
+ if (tp->bs_name)
+ return (tp->bs_name);
- cp = buf;
- if ((j = *pi >> 4) != 0)
- *cp++ = hex[j];
- *cp++ = hex[*pi++ & 0xf];
- for (i = 4; (int)--i >= 0;) {
+ tp->bs_name = cp = (char *)malloc(len*3);
+ if (tp->bs_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "linkaddr_string: malloc");
+ *cp++ = hex[*ep >> 4];
+ *cp++ = hex[*ep++ & 0xf];
+ for (i = len-1; i > 0 ; --i) {
*cp++ = ':';
- if ((j = *pi >> 4) != 0)
- *cp++ = hex[j];
- *cp++ = hex[*pi++ & 0xf];
+ *cp++ = hex[*ep >> 4];
+ *cp++ = hex[*ep++ & 0xf];
}
*cp = '\0';
- tp->p_name = strdup(buf);
- return (tp->p_name);
+ return (tp->bs_name);
}
+#define ISONSAP_MAX_LENGTH 20
const char *
-llcsap_string(u_char sap)
+isonsap_string(netdissect_options *ndo, const uint8_t *nsap,
+ u_int nsap_length)
{
- register struct hnamemem *tp;
- register u_int32_t i = sap;
- char buf[sizeof("sap 00")];
-
- for (tp = &llcsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
- if (tp->addr == i)
- return (tp->name);
-
- tp->addr = i;
- tp->nxt = newhnamemem();
-
- snprintf(buf, sizeof(buf), "sap %02x", sap & 0xff);
- tp->name = strdup(buf);
- return (tp->name);
-}
+ u_int nsap_idx;
+ char *cp;
+ struct enamemem *tp;
-const char *
-isonsap_string(const u_char *nsap)
-{
- register u_int i, nlen = nsap[0];
- register char *cp;
- register struct enamemem *tp;
+ if (nsap_length < 1 || nsap_length > ISONSAP_MAX_LENGTH)
+ return ("isonsap_string: illegal length");
- tp = lookup_nsap(nsap);
+ tp = lookup_nsap(ndo, nsap, nsap_length);
if (tp->e_name)
return tp->e_name;
- tp->e_name = cp = (char *)malloc(nlen * 2 + 2);
+ tp->e_name = cp = (char *)malloc(sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx"));
if (cp == NULL)
- error("isonsap_string: malloc");
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "isonsap_string: malloc");
- nsap++;
- *cp++ = '/';
- for (i = nlen; (int)--i >= 0;) {
+ for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {
*cp++ = hex[*nsap >> 4];
*cp++ = hex[*nsap++ & 0xf];
+ if (((nsap_idx & 1) == 0) &&
+ (nsap_idx + 1 < nsap_length)) {
+ *cp++ = '.';
+ }
}
*cp = '\0';
return (tp->e_name);
}
const char *
-tcpport_string(u_short port)
+tcpport_string(netdissect_options *ndo, u_short port)
{
- register struct hnamemem *tp;
- register u_int32_t i = port;
+ struct hnamemem *tp;
+ uint32_t i = port;
char buf[sizeof("00000")];
for (tp = &tporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
return (tp->name);
tp->addr = i;
- tp->nxt = newhnamemem();
+ tp->nxt = newhnamemem(ndo);
- (void)snprintf(buf, sizeof(buf), "%u", i);
+ (void)nd_snprintf(buf, sizeof(buf), "%u", i);
tp->name = strdup(buf);
+ if (tp->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "tcpport_string: strdup(buf)");
return (tp->name);
}
const char *
-udpport_string(register u_short port)
+udpport_string(netdissect_options *ndo, u_short port)
{
- register struct hnamemem *tp;
- register u_int32_t i = port;
+ struct hnamemem *tp;
+ uint32_t i = port;
char buf[sizeof("00000")];
for (tp = &uporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
return (tp->name);
tp->addr = i;
- tp->nxt = newhnamemem();
+ tp->nxt = newhnamemem(ndo);
- (void)snprintf(buf, sizeof(buf), "%u", i);
+ (void)nd_snprintf(buf, sizeof(buf), "%u", i);
tp->name = strdup(buf);
+ if (tp->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "udpport_string: strdup(buf)");
return (tp->name);
}
const char *
-ipxsap_string(u_short port)
+ipxsap_string(netdissect_options *ndo, u_short port)
{
- register char *cp;
- register struct hnamemem *tp;
- register u_int32_t i = port;
+ char *cp;
+ struct hnamemem *tp;
+ uint32_t i = port;
char buf[sizeof("0000")];
for (tp = &ipxsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
return (tp->name);
tp->addr = i;
- tp->nxt = newhnamemem();
+ tp->nxt = newhnamemem(ndo);
cp = buf;
NTOHS(port);
*cp++ = hex[port & 0xf];
*cp++ = '\0';
tp->name = strdup(buf);
+ if (tp->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "ipxsap_string: strdup(buf)");
return (tp->name);
}
static void
-init_servarray(void)
+init_servarray(netdissect_options *ndo)
{
struct servent *sv;
- register struct hnamemem *table;
- register int i;
+ struct hnamemem *table;
+ int i;
char buf[sizeof("0000000000")];
while ((sv = getservent()) != NULL) {
while (table->name)
table = table->nxt;
- if (nflag) {
- (void)snprintf(buf, sizeof(buf), "%d", port);
+ if (ndo->ndo_nflag) {
+ (void)nd_snprintf(buf, sizeof(buf), "%d", port);
table->name = strdup(buf);
} else
table->name = strdup(sv->s_name);
+ if (table->name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "init_servarray: strdup");
+
table->addr = port;
- table->nxt = newhnamemem();
+ table->nxt = newhnamemem(ndo);
}
endservent();
}
-/* in libpcap.a (nametoaddr.c) */
-#if defined(WIN32) && !defined(USE_STATIC_LIBPCAP)
-__declspec(dllimport)
-#else
-extern
-#endif
-const struct eproto {
+static const struct eproto {
const char *s;
u_short p;
-} eproto_db[];
+} eproto_db[] = {
+ { "pup", ETHERTYPE_PUP },
+ { "xns", ETHERTYPE_NS },
+ { "ip", ETHERTYPE_IP },
+ { "ip6", ETHERTYPE_IPV6 },
+ { "arp", ETHERTYPE_ARP },
+ { "rarp", ETHERTYPE_REVARP },
+ { "sprite", ETHERTYPE_SPRITE },
+ { "mopdl", ETHERTYPE_MOPDL },
+ { "moprc", ETHERTYPE_MOPRC },
+ { "decnet", ETHERTYPE_DN },
+ { "lat", ETHERTYPE_LAT },
+ { "sca", ETHERTYPE_SCA },
+ { "lanbridge", ETHERTYPE_LANBRIDGE },
+ { "vexp", ETHERTYPE_VEXP },
+ { "vprod", ETHERTYPE_VPROD },
+ { "atalk", ETHERTYPE_ATALK },
+ { "atalkarp", ETHERTYPE_AARP },
+ { "loopback", ETHERTYPE_LOOPBACK },
+ { "decdts", ETHERTYPE_DECDTS },
+ { "decdns", ETHERTYPE_DECDNS },
+ { (char *)0, 0 }
+};
static void
-init_eprotoarray(void)
+init_eprotoarray(netdissect_options *ndo)
{
- register int i;
- register struct hnamemem *table;
+ int i;
+ struct hnamemem *table;
for (i = 0; eproto_db[i].s; i++) {
int j = htons(eproto_db[i].p) & (HASHNAMESIZE-1);
table = table->nxt;
table->name = eproto_db[i].s;
table->addr = htons(eproto_db[i].p);
- table->nxt = newhnamemem();
+ table->nxt = newhnamemem(ndo);
}
}
-static struct protoidlist {
+static const struct protoidlist {
const u_char protoid[5];
const char *name;
} protoidlist[] = {
* types.
*/
static void
-init_protoidarray(void)
+init_protoidarray(netdissect_options *ndo)
{
- register int i;
- register struct protoidmem *tp;
- struct protoidlist *pl;
+ int i;
+ struct protoidmem *tp;
+ const struct protoidlist *pl;
u_char protoid[5];
protoid[0] = 0;
u_short etype = htons(eproto_db[i].p);
memcpy((char *)&protoid[3], (char *)&etype, 2);
- tp = lookup_protoid(protoid);
+ tp = lookup_protoid(ndo, protoid);
tp->p_name = strdup(eproto_db[i].s);
+ if (tp->p_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "init_protoidarray: strdup(eproto_db[i].s)");
}
/* Hardwire some SNAP proto ID names */
for (pl = protoidlist; pl->name != NULL; ++pl) {
- tp = lookup_protoid(pl->protoid);
+ tp = lookup_protoid(ndo, pl->protoid);
/* Don't override existing name */
if (tp->p_name != NULL)
continue;
}
}
-static struct etherlist {
+static const struct etherlist {
const u_char addr[6];
const char *name;
} etherlist[] = {
* translation, so we just pcap_next_etherent as a convenience.
*/
static void
-init_etherarray(void)
+init_etherarray(netdissect_options *ndo)
{
- register struct etherlist *el;
- register struct enamemem *tp;
+ const struct etherlist *el;
+ struct enamemem *tp;
#ifdef USE_ETHER_NTOHOST
char name[256];
#else
- register struct pcap_etherent *ep;
- register FILE *fp;
+ struct pcap_etherent *ep;
+ FILE *fp;
/* Suck in entire ethers file */
fp = fopen(PCAP_ETHERS_FILE, "r");
if (fp != NULL) {
while ((ep = pcap_next_etherent(fp)) != NULL) {
- tp = lookup_emem(ep->addr);
+ tp = lookup_emem(ndo, ep->addr);
tp->e_name = strdup(ep->name);
+ if (tp->e_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "init_etherarray: strdup(ep->addr)");
}
(void)fclose(fp);
}
/* Hardwire some ethernet names */
for (el = etherlist; el->name != NULL; ++el) {
- tp = lookup_emem(el->addr);
+ tp = lookup_emem(ndo, el->addr);
/* Don't override existing name */
if (tp->e_name != NULL)
continue;
#ifdef USE_ETHER_NTOHOST
- /* Use yp/nis version of name if available */
- if (ether_ntohost(name, (const struct ether_addr *)el->addr) == 0) {
- tp->e_name = strdup(name);
+ /*
+ * Use YP/NIS version of name if available.
+ */
+ if (ether_ntohost(name, (const struct ether_addr *)el->addr) == 0) {
+ tp->e_name = strdup(name);
+ if (tp->e_name == NULL)
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "init_etherarray: strdup(name)");
continue;
}
#endif
}
}
-static struct tok llcsap_db[] = {
- { LLCSAP_NULL, "null" },
- { LLCSAP_8021B_I, "802.1b-gsap" },
- { LLCSAP_8021B_G, "802.1b-isap" },
- { LLCSAP_IP, "ip-sap" },
- { LLCSAP_PROWAYNM, "proway-nm" },
- { LLCSAP_8021D, "802.1d" },
- { LLCSAP_RS511, "eia-rs511" },
- { LLCSAP_ISO8208, "x.25/llc2" },
- { LLCSAP_PROWAY, "proway" },
- { LLCSAP_SNAP, "snap" },
- { LLCSAP_IPX, "IPX" },
- { LLCSAP_NETBEUI, "netbeui" },
- { LLCSAP_ISONS, "iso-clns" },
- { LLCSAP_GLOBAL, "global" },
- { 0, NULL }
-};
-
-static void
-init_llcsaparray(void)
-{
- register int i;
- register struct hnamemem *table;
-
- for (i = 0; llcsap_db[i].s != NULL; i++) {
- table = &llcsaptable[llcsap_db[i].v];
- while (table->name)
- table = table->nxt;
- table->name = llcsap_db[i].s;
- table->addr = llcsap_db[i].v;
- table->nxt = newhnamemem();
- }
-}
-
-static struct tok ipxsap_db[] = {
+static const struct ipxsap_ent {
+ uint16_t v;
+ const char *s;
+} ipxsap_db[] = {
{ 0x0000, "Unknown" },
{ 0x0001, "User" },
{ 0x0002, "User Group" },
};
static void
-init_ipxsaparray(void)
+init_ipxsaparray(netdissect_options *ndo)
{
- register int i;
- register struct hnamemem *table;
+ int i;
+ struct hnamemem *table;
for (i = 0; ipxsap_db[i].s != NULL; i++) {
- int j = htons(ipxsap_db[i].v) & (HASHNAMESIZE-1);
+ u_int j = htons(ipxsap_db[i].v) & (HASHNAMESIZE-1);
table = &ipxsaptable[j];
while (table->name)
table = table->nxt;
table->name = ipxsap_db[i].s;
table->addr = htons(ipxsap_db[i].v);
- table->nxt = newhnamemem();
+ table->nxt = newhnamemem(ndo);
}
}
/*
* Initialize the address to name translation machinery. We map all
- * non-local IP addresses to numeric addresses if fflag is true (i.e.,
- * to prevent blocking on the nameserver). localnet is the IP address
+ * non-local IP addresses to numeric addresses if ndo->ndo_fflag is true
+ * (i.e., to prevent blocking on the nameserver). localnet is the IP address
* of the local network. mask is its subnet mask.
*/
void
-init_addrtoname(u_int32_t localnet, u_int32_t mask)
+init_addrtoname(netdissect_options *ndo, uint32_t localnet, uint32_t mask)
{
- if (fflag) {
+ if (ndo->ndo_fflag) {
f_localnet = localnet;
f_netmask = mask;
}
- if (nflag)
+ if (ndo->ndo_nflag)
/*
* Simplest way to suppress names.
*/
return;
- init_etherarray();
- init_servarray();
- init_eprotoarray();
- init_llcsaparray();
- init_protoidarray();
- init_ipxsaparray();
+ init_etherarray(ndo);
+ init_servarray(ndo);
+ init_eprotoarray(ndo);
+ init_protoidarray(ndo);
+ init_ipxsaparray(ndo);
}
const char *
-dnaddr_string(u_short dnaddr)
+dnaddr_string(netdissect_options *ndo, u_short dnaddr)
{
- register struct hnamemem *tp;
+ struct hnamemem *tp;
- for (tp = &dnaddrtable[dnaddr & (HASHNAMESIZE-1)]; tp->nxt != 0;
+ for (tp = &dnaddrtable[dnaddr & (HASHNAMESIZE-1)]; tp->nxt != NULL;
tp = tp->nxt)
if (tp->addr == dnaddr)
return (tp->name);
tp->addr = dnaddr;
- tp->nxt = newhnamemem();
- if (nflag)
- tp->name = dnnum_string(dnaddr);
+ tp->nxt = newhnamemem(ndo);
+ if (ndo->ndo_nflag)
+ tp->name = dnnum_string(ndo, dnaddr);
else
- tp->name = dnname_string(dnaddr);
+ tp->name = dnname_string(ndo, dnaddr);
return(tp->name);
}
/* Return a zero'ed hnamemem struct and cuts down on calloc() overhead */
struct hnamemem *
-newhnamemem(void)
+newhnamemem(netdissect_options *ndo)
{
- register struct hnamemem *p;
+ struct hnamemem *p;
static struct hnamemem *ptr = NULL;
static u_int num = 0;
num = 64;
ptr = (struct hnamemem *)calloc(num, sizeof (*ptr));
if (ptr == NULL)
- error("newhnamemem: calloc");
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "newhnamemem: calloc");
}
--num;
p = ptr++;
return (p);
}
-#ifdef INET6
/* Return a zero'ed h6namemem struct and cuts down on calloc() overhead */
struct h6namemem *
-newh6namemem(void)
+newh6namemem(netdissect_options *ndo)
{
- register struct h6namemem *p;
+ struct h6namemem *p;
static struct h6namemem *ptr = NULL;
static u_int num = 0;
num = 64;
ptr = (struct h6namemem *)calloc(num, sizeof (*ptr));
if (ptr == NULL)
- error("newh6namemem: calloc");
+ (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+ "newh6namemem: calloc");
}
--num;
p = ptr++;
return (p);
}
-#endif /* INET6 */
+
+/* Represent TCI part of the 802.1Q 4-octet tag as text. */
+const char *
+ieee8021q_tci_string(const uint16_t tci)
+{
+ static char buf[128];
+ nd_snprintf(buf, sizeof(buf), "vlan %u, p %u%s",
+ tci & 0xfff,
+ tci >> 13,
+ (tci & 0x1000) ? ", DEI" : "");
+ return buf;
+}
projects / tcpdump / blobdiff