* Internet, ethernet, port, and protocol string to address
* and address to string conversion routines
*/
-#ifndef lint
-static const char rcsid[] =
- "@(#) $Header: /tcpdump/master/tcpdump/addrtoname.c,v 1.96 2003-07-31 22:36:44 fenner Exp $ (LBL)";
-#endif
+#define NETDISSECT_REWORKED
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#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 */
+#ifdef NETINET_ETHER_H_DECLARES_ETHER_NTOHOST
+#include <netinet/ether.h>
+#endif /* NETINET_ETHER_H_DECLARES_ETHER_NTOHOST */
+
+#if !defined(HAVE_DECL_ETHER_NTOHOST) || !HAVE_DECL_ETHER_NTOHOST
+#ifndef HAVE_STRUCT_ETHER_ADDR
+struct ether_addr {
+ unsigned char ether_addr_octet[6];
+};
+#endif
+extern int ether_ntohost(char *, const struct ether_addr *);
+#endif
+
#endif /* USE_ETHER_NTOHOST */
#include <pcap.h>
#include "addrtoname.h"
#include "llc.h"
#include "setsignal.h"
+#include "extract.h"
+#include "oui.h"
+
+#ifndef ETHER_ADDR_LEN
+#define ETHER_ADDR_LEN 6
+#endif
/*
* hash tables for whatever-to-name translations
#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)
/*
addr6.sin6_family = AF_INET6;
memcpy(&addr6.sin6_addr, addr, len);
if (getnameinfo((struct sockaddr *)&addr6, sizeof(addr6),
- hname, sizeof(hname), NULL, 0, 0)) {
- return NULL;
+ hname, sizeof(hname), NULL, 0, 0)) {
+ return NULL;
} else {
strcpy(host.h_name, hname);
return &host;
}
}
#define gethostbyaddr win32_gethostbyaddr
-#endif /* INET6 & WIN32*/
+#endif /* INET6 & WIN32 */
#ifdef INET6
struct h6namemem {
struct h6namemem *nxt;
};
-struct h6namemem h6nametable[HASHNAMESIZE];
+static struct h6namemem h6nametable[HASHNAMESIZE];
#endif /* INET6 */
struct enamemem {
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];
+static struct enamemem 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;
static char buf[sizeof(".xxx.xxx.xxx.xxx")];
NTOHL(addr);
- cp = &buf[sizeof buf];
+ cp = buf + sizeof(buf);
*--cp = '\0';
n = 4;
return cp + 1;
}
-static u_int32_t f_netmask;
-static u_int32_t f_localnet;
-static u_int32_t netmask;
+static uint32_t f_netmask;
+static uint32_t f_localnet;
/*
* Return a name for the IP address pointed to by ap. This address
* is assumed to be in network byte order.
+ *
+ * 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,
+ * 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
+ * printf print "(null)" with "%s" and a null pointer, some of them
+ * don't check for a null pointer and crash in that case.
+ *
+ * The callers of this routine should, before handing this routine
+ * a pointer to packet data, be sure that the data is present in
+ * the packet buffer. They should probably do those checks anyway,
+ * as other data at that layer might not be IP addresses, and it
+ * also needs to check whether they're present in the packet buffer.
*/
const char *
-getname(const u_char *ap)
+getname(netdissect_options *ndo, const u_char *ap)
{
register struct hostent *hp;
- u_int32_t addr;
+ uint32_t addr;
static struct hnamemem *p; /* static for longjmp() */
memcpy(&addr, ap, sizeof(addr));
* 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);
if (hp) {
char *dotp;
p->name = strdup(hp->h_name);
- if (Nflag) {
+ if (ndo->ndo_Nflag) {
/* Remove domain qualifications */
dotp = strchr(p->name, '.');
if (dotp)
* is assumed to be in network byte order.
*/
const char *
-getname6(const u_char *ap)
+getname6(netdissect_options *ndo, const u_char *ap)
{
register struct hostent *hp;
- struct in6_addr addr;
+ union {
+ struct in6_addr addr;
+ struct for_hash_addr {
+ char fill[14];
+ uint16_t d;
+ } addra;
+ } addr;
static struct h6namemem *p; /* static for longjmp() */
register 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->addr = addr.addr;
p->nxt = newh6namemem();
/*
* Do not print names if -n was given.
*/
- if (!nflag) {
+ if (!ndo->ndo_nflag) {
hp = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET6);
if (hp) {
char *dotp;
p->name = strdup(hp->h_name);
- if (Nflag) {
+ if (ndo->ndo_Nflag) {
/* Remove domain qualifications */
dotp = strchr(p->name, '.');
if (dotp)
}
#endif /* INET6 */
-static char hex[] = "0123456789abcdef";
+static const char hex[] = "0123456789abcdef";
/* Find the hash node that corresponds the ether address 'ep' */
tp->e_addr2 = k;
tp->e_bs = (u_char *) calloc(1, nlen + 1);
+ if (tp->e_bs == NULL)
+ error("lookup_bytestring: calloc");
+
memcpy(tp->e_bs, bs, nlen);
tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
if (tp->e_nxt == NULL)
}
const char *
-etheraddr_string(register const u_char *ep)
+etheraddr_string(netdissect_options *ndo, register const u_char *ep)
{
- register u_int i;
+ register int i;
register char *cp;
register struct enamemem *tp;
- char buf[sizeof("00:00:00:00:00:00")];
+ int oui;
+ char buf[BUFSIZE];
tp = lookup_emem(ep);
if (tp->e_name)
return (tp->e_name);
#ifdef USE_ETHER_NTOHOST
- if (!nflag) {
- char buf2[128];
- if (ether_ntohost(buf2, (const struct ether_addr *)ep) == 0) {
+ if (!ndo->ndo_nflag) {
+ char buf2[BUFSIZE];
+
+ /*
+ * We don't cast it to "const struct ether_addr *"
+ * because some systems fail to declare the second
+ * argument as a "const" pointer, even though they
+ * don't modify what it points to.
+ */
+ if (ether_ntohost(buf2, (struct ether_addr *)ep) == 0) {
tp->e_name = strdup(buf2);
return (tp->e_name);
}
}
#endif
cp = buf;
- *cp++ = hex[*ep >> 4 ];
+ oui = EXTRACT_24BITS(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];
}
+
+ if (!ndo->ndo_nflag) {
+ snprintf(cp, BUFSIZE - (2 + 5*3), " (oui %s)",
+ tok2str(oui_values, "Unknown", oui));
+ } else
+ *cp = '\0';
+ tp->e_name = strdup(buf);
+ return (tp->e_name);
+}
+
+const char *
+le64addr_string(const u_char *ep)
+{
+ const unsigned int len = 8;
+ register u_int i;
+ register char *cp;
+ register struct enamemem *tp;
+ char buf[BUFSIZE];
+
+ tp = lookup_bytestring(ep, len);
+ if (tp->e_name)
+ return (tp->e_name);
+
+ cp = buf;
+ for (i = len; i > 0 ; --i) {
+ *cp++ = hex[*(ep + i - 1) >> 4];
+ *cp++ = hex[*(ep + i - 1) & 0xf];
+ *cp++ = ':';
+ }
+ cp --;
+
*cp = '\0';
+
tp->e_name = strdup(buf);
+
return (tp->e_name);
}
const char *
-linkaddr_string(const u_char *ep, const unsigned int len)
+linkaddr_string(netdissect_options *ndo, const u_char *ep, const unsigned int type, const unsigned int len)
{
- register u_int i, j;
+ register u_int i;
register char *cp;
register struct enamemem *tp;
- if (len == 6) /* XXX not totally correct... */
- return etheraddr_string(ep);
+ if (len == 0)
+ return ("<empty>");
+
+ if (type == LINKADDR_ETHER && len == ETHER_ADDR_LEN)
+ return (etheraddr_string(ndo, ep));
+
+ if (type == LINKADDR_FRELAY)
+ return (q922_string(ep));
tp = lookup_bytestring(ep, len);
if (tp->e_name)
tp->e_name = cp = (char *)malloc(len*3);
if (tp->e_name == NULL)
error("linkaddr_string: malloc");
- if ((j = *ep >> 4) != 0)
- *cp++ = hex[j];
+ *cp++ = hex[*ep >> 4];
*cp++ = hex[*ep++ & 0xf];
for (i = len-1; i > 0 ; --i) {
*cp++ = ':';
- if ((j = *ep >> 4) != 0)
- *cp++ = hex[j];
+ *cp++ = hex[*ep >> 4];
*cp++ = hex[*ep++ & 0xf];
}
*cp = '\0';
{
register char *cp;
register struct hnamemem *tp;
- register u_int32_t i = port;
+ register uint32_t i = port;
char buf[sizeof("0000")];
for (tp = &eprototable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
return (tp->p_name);
}
+#define ISONSAP_MAX_LENGTH 20
const char *
-llcsap_string(u_char sap)
-{
- 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);
-}
-
-const char *
-isonsap_string(const u_char *nsap)
+isonsap_string(const u_char *nsap, register u_int nsap_length)
{
- register u_int i, nlen = nsap[0];
+ register u_int nsap_idx;
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);
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");
- 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);
tcpport_string(u_short port)
{
register struct hnamemem *tp;
- register u_int32_t i = port;
+ register uint32_t i = port;
char buf[sizeof("00000")];
for (tp = &tporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
udpport_string(register u_short port)
{
register struct hnamemem *tp;
- register u_int32_t i = port;
+ register uint32_t i = port;
char buf[sizeof("00000")];
for (tp = &uporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
{
register char *cp;
register struct hnamemem *tp;
- register u_int32_t i = port;
+ register uint32_t i = port;
char buf[sizeof("0000")];
for (tp = &ipxsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
}
static void
-init_servarray(void)
+init_servarray(netdissect_options *ndo)
{
struct servent *sv;
register struct hnamemem *table;
while (table->name)
table = table->nxt;
- if (nflag) {
+ if (ndo->ndo_nflag) {
(void)snprintf(buf, sizeof(buf), "%d", port);
table->name = strdup(buf);
} else
endservent();
}
-/*XXX from libbpfc.a */
-#ifndef WIN32
-extern struct eproto {
+/* in libpcap.a (nametoaddr.c) */
+#if defined(WIN32) && !defined(USE_STATIC_LIBPCAP)
+extern __declspec(dllimport)
#else
-__declspec( dllimport) struct eproto {
+extern
#endif
- char *s;
+const struct eproto {
+ const char *s;
u_short p;
} eproto_db[];
}
}
-static struct protoidlist {
+static const struct protoidlist {
const u_char protoid[5];
const char *name;
} protoidlist[] = {
{
register int i;
register struct protoidmem *tp;
- struct protoidlist *pl;
+ const struct protoidlist *pl;
u_char protoid[5];
protoid[0] = 0;
}
}
-static struct etherlist {
+static const struct etherlist {
const u_char addr[6];
const char *name;
} etherlist[] = {
static void
init_etherarray(void)
{
- register struct etherlist *el;
+ register const struct etherlist *el;
register struct enamemem *tp;
#ifdef USE_ETHER_NTOHOST
char name[256];
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.
+ *
+ * We don't cast it to "const struct ether_addr *"
+ * because some systems don't modify the Ethernet
+ * address but fail to declare the second argument
+ * as a "const" pointer.
+ */
+ if (ether_ntohost(name, (struct ether_addr *)el->addr) == 0) {
+ tp->e_name = 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 tok ipxsap_db[] = {
{ 0x0000, "Unknown" },
{ 0x0001, "User" },
{ 0x0002, "User Group" },
/*
* 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)
{
- netmask = 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_servarray(ndo);
init_eprotoarray();
- init_llcsaparray();
init_protoidarray();
init_ipxsaparray();
}
const char *
-dnaddr_string(u_short dnaddr)
+dnaddr_string(netdissect_options *ndo, u_short dnaddr)
{
register struct hnamemem *tp;
tp->addr = dnaddr;
tp->nxt = newhnamemem();
- if (nflag)
+ if (ndo->ndo_nflag)
tp->name = dnnum_string(dnaddr);
else
tp->name = dnname_string(dnaddr);
projects / tcpdump / blobdiff