#include "config.h"
#endif
+#ifdef HAVE_CASPER
+#include <libcasper.h>
+#include <casper/cap_dns.h>
+#endif /* HAVE_CASPER */
+
#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 USE_ETHER_NTOHOST
#ifdef HAVE_NETINET_IF_ETHER_H
struct mbuf; /* Squelch compiler warnings on some platforms for */
#include <pcap.h>
#include <pcap-namedb.h>
+#ifndef HAVE_GETSERVENT
+#include <getservent.h>
+#endif
#include <signal.h>
#include <stdio.h>
#include <string.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"
-#ifndef ETHER_ADDR_LEN
-#define ETHER_ADDR_LEN 6
-#endif
-
/*
* hash tables for whatever-to-name translations
*
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];
-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;
const char *
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);
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
const char *
getname(netdissect_options *ndo, const u_char *ap)
{
- register struct hostent *hp;
+ struct hostent *hp;
uint32_t addr;
struct hnamemem *p;
*/
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;
const char *
getname6(netdissect_options *ndo, const u_char *ap)
{
- register struct hostent *hp;
+ struct hostent *hp;
union {
struct in6_addr addr;
struct for_hash_addr {
} addra;
} addr;
struct h6namemem *p;
- register const char *cp;
+ const char *cp;
char ntop_buf[INET6_ADDRSTRLEN];
memcpy(&addr, ap, sizeof(addr));
* Do not print names if -n was given.
*/
if (!ndo->ndo_nflag) {
- hp = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET6);
+#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;
return (p->name);
}
-static const 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(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];
* with length 'nlen'
*/
-static inline struct enamemem *
-lookup_bytestring(netdissect_options *ndo, register const u_char *bs,
+static inline 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 = 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");
- 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;
/* 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, 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_nsap = (u_char *)malloc(nsap_length + 1);
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");
static inline 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 */
}
const char *
-etheraddr_string(netdissect_options *ndo, register const u_char *ep)
+etheraddr_string(netdissect_options *ndo, const u_char *ep)
{
- register int i;
- register char *cp;
- register struct enamemem *tp;
+ int i;
+ char *cp;
+ struct enamemem *tp;
int oui;
char buf[BUFSIZE];
}
#endif
cp = buf;
- oui = EXTRACT_24BITS(ep);
+ oui = EXTRACT_BE_U_3(ep);
*cp++ = hex[*ep >> 4 ];
*cp++ = hex[*ep++ & 0xf];
for (i = 5; --i >= 0;) {
le64addr_string(netdissect_options *ndo, const u_char *ep)
{
const unsigned int len = 8;
- register u_int i;
- register char *cp;
- register struct enamemem *tp;
+ u_int i;
+ char *cp;
+ struct bsnamemem *tp;
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 = '\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)");
- return (tp->e_name);
+ return (tp->bs_name);
}
const char *
linkaddr_string(netdissect_options *ndo, const u_char *ep,
const unsigned int type, const unsigned int len)
{
- register u_int i;
- register char *cp;
- register struct enamemem *tp;
+ u_int i;
+ char *cp;
+ struct bsnamemem *tp;
if (len == 0)
return ("<empty>");
- if (type == LINKADDR_ETHER && len == ETHER_ADDR_LEN)
+ if (type == LINKADDR_ETHER && len == MAC_ADDR_LEN)
return (etheraddr_string(ndo, ep));
if (type == LINKADDR_FRELAY)
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];
*cp++ = hex[*ep++ & 0xf];
}
*cp = '\0';
- return (tp->e_name);
+ return (tp->bs_name);
}
const char *
etherproto_string(netdissect_options *ndo, u_short port)
{
- register char *cp;
- register struct hnamemem *tp;
- register uint32_t i = port;
+ char *cp;
+ struct hnamemem *tp;
+ uint32_t i = port;
char buf[sizeof("0000")];
for (tp = &eprototable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
return (tp->name);
}
-const char *
-protoid_string(netdissect_options *ndo, 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")];
-
- tp = lookup_protoid(ndo, pi);
- if (tp->p_name)
- return tp->p_name;
-
- cp = buf;
- if ((j = *pi >> 4) != 0)
- *cp++ = hex[j];
- *cp++ = hex[*pi++ & 0xf];
- for (i = 4; (int)--i >= 0;) {
- *cp++ = ':';
- if ((j = *pi >> 4) != 0)
- *cp++ = hex[j];
- *cp++ = hex[*pi++ & 0xf];
- }
- *cp = '\0';
- tp->p_name = strdup(buf);
- if (tp->p_name == NULL)
- (*ndo->ndo_error)(ndo, "protoid_string: strdup(buf)");
- return (tp->p_name);
-}
-
#define ISONSAP_MAX_LENGTH 20
const char *
isonsap_string(netdissect_options *ndo, const u_char *nsap,
- register u_int nsap_length)
+ u_int nsap_length)
{
- register u_int nsap_idx;
- register char *cp;
- register struct enamemem *tp;
+ u_int nsap_idx;
+ char *cp;
+ struct enamemem *tp;
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;
const char *
tcpport_string(netdissect_options *ndo, u_short port)
{
- register struct hnamemem *tp;
- register uint32_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)
}
const char *
-udpport_string(netdissect_options *ndo, register u_short port)
+udpport_string(netdissect_options *ndo, u_short port)
{
- register struct hnamemem *tp;
- register uint32_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)
const char *
ipxsap_string(netdissect_options *ndo, u_short port)
{
- register char *cp;
- register struct hnamemem *tp;
- register uint32_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)
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) {
endservent();
}
-/* in libpcap.a (nametoaddr.c) */
-#if defined(_WIN32) && !defined(USE_STATIC_LIBPCAP)
-extern __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(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);
static void
init_protoidarray(netdissect_options *ndo)
{
- register int i;
- register struct protoidmem *tp;
+ int i;
+ struct protoidmem *tp;
const struct protoidlist *pl;
u_char protoid[5];
static void
init_etherarray(netdissect_options *ndo)
{
- register const 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");
static 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);
const char *
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);
struct hnamemem *
newhnamemem(netdissect_options *ndo)
{
- register struct hnamemem *p;
+ struct hnamemem *p;
static struct hnamemem *ptr = NULL;
static u_int num = 0;
struct h6namemem *
newh6namemem(netdissect_options *ndo)
{
- register struct h6namemem *p;
+ struct h6namemem *p;
static struct h6namemem *ptr = NULL;
static u_int num = 0;
projects / tcpdump / blobdiff