/*
* collectd - src/utils_dns.c
- * Modifications Copyright (C) 2006 Florian octo Forster
- * Copyright (C) 2002 The Measurement Factory, Inc.
+ * Copyright (C) 2006 Florian octo Forster
+ * Copyright (C) 2002 The Measurement Factory, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
*
* Authors:
* The Measurement Factory, Inc. <http://www.measurement-factory.com/>
- * Florian octo Forster <octo at verplant.org>
+ * Florian octo Forster <octo at collectd.org>
*/
-#include "collectd.h"
+#define _BSD_SOURCE
-#if HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#if HAVE_PCAP_H
-# include <pcap.h>
-#endif
-#if HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
+#include "collectd.h"
+#include "plugin.h"
+#include "common.h"
-#if HAVE_ARPA_NAMESER_H
-# include <arpa/nameser.h>
-#elif HAVE_ARPA_NAMESER_COMPAT_H
-# include <arpa/nameser_compat.h>
+#if HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
#endif
#if HAVE_NET_IF_ARP_H
#if HAVE_NET_IF_H
# include <net/if.h>
#endif
-#if HAVE_NETINET_IF_ETHER_H
-# include <netinet/if_ether.h>
+#if HAVE_NET_PPP_DEFS_H
+# include <net/ppp_defs.h>
#endif
#if HAVE_NET_IF_PPP_H
# include <net/if_ppp.h>
#endif
-#if HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#if HAVE_NETDB_H
-# include <netdb.h>
-#endif
-
#if HAVE_NETINET_IN_SYSTM_H
# include <netinet/in_systm.h>
#endif
#if HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif
+#if HAVE_NETINET_IP6_H
+# include <netinet/ip6.h>
+#endif
+#if HAVE_NETINET_IP_COMPAT_H
+# include <netinet/ip_compat.h>
+#endif
+#if HAVE_NETINET_IF_ETHER_H
+# include <netinet/if_ether.h>
+#endif
#if HAVE_NETINET_IP_H
# include <netinet/ip.h>
#endif
#ifdef HAVE_NETINET_IP_VAR_H
# include <netinet/ip_var.h>
#endif
-#if HAVE_NETINET_IP6_H
-# include <netinet/ip6.h>
-#endif
#if HAVE_NETINET_UDP_H
# include <netinet/udp.h>
#endif
+#if HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif
+#if HAVE_ARPA_NAMESER_H
+# include <arpa/nameser.h>
+#endif
+#if HAVE_ARPA_NAMESER_COMPAT_H
+# include <arpa/nameser_compat.h>
+#endif
+
+#if HAVE_NETDB_H
+# include <netdb.h>
+#endif
+
+#if HAVE_PCAP_H
+# include <pcap.h>
+#endif
+
#define PCAP_SNAPLEN 1460
#ifndef ETHER_HDR_LEN
#define ETHER_ADDR_LEN 6
# define PPP_CONTROL_VAL 0x03 /* The control byte value */
#endif
-#ifdef __linux__
-#define uh_sport source
-#define uh_dport dest
+#if HAVE_STRUCT_UDPHDR_UH_DPORT && HAVE_STRUCT_UDPHDR_UH_SPORT
+# define UDP_DEST uh_dport
+# define UDP_SRC uh_sport
+#elif HAVE_STRUCT_UDPHDR_DEST && HAVE_STRUCT_UDPHDR_SOURCE
+# define UDP_DEST dest
+# define UDP_SRC source
+#else
+# error "`struct udphdr' is unusable."
#endif
#include "utils_dns.h"
static ip_list_t *IgnoreList = NULL;
+#if HAVE_PCAP_H
static void (*Callback) (const rfc1035_header_t *) = NULL;
static int query_count_intvl = 0;
static int query_count_total = 0;
-#ifdef __OpenBSD__
+# ifdef __OpenBSD__
static struct bpf_timeval last_ts;
-#else
+# else
static struct timeval last_ts;
-#endif
+# endif /* __OpenBSD__ */
+#endif /* HAVE_PCAP_H */
static int cmp_in6_addr (const struct in6_addr *a,
const struct in6_addr *b)
{
int i;
- for (i = 0; i < 4; i++)
- if (a->s6_addr32[i] != b->s6_addr32[i])
+ assert (sizeof (struct in6_addr) == 16);
+
+ for (i = 0; i < 16; i++)
+ if (a->s6_addr[i] != b->s6_addr[i])
break;
- if (i >= 4)
+ if (i >= 16)
return (0);
- return (a->s6_addr32[i] > b->s6_addr32[i] ? 1 : -1);
+ return (a->s6_addr[i] > b->s6_addr[i] ? 1 : -1);
} /* int cmp_addrinfo */
static inline int ignore_list_match (const struct in6_addr *addr)
{
if (ai_ptr->ai_family == AF_INET)
{
- addr.s6_addr32[0] = 0;
- addr.s6_addr32[1] = 0;
- addr.s6_addr32[2] = htonl (0x0000FFFF);
- addr.s6_addr32[3] = ((struct sockaddr_in *) ai_ptr->ai_addr)->sin_addr.s_addr;
+ memset (&addr, '\0', sizeof (addr));
+ addr.s6_addr[10] = 0xFF;
+ addr.s6_addr[11] = 0xFF;
+ memcpy (addr.s6_addr + 12, &((struct sockaddr_in *) ai_ptr->ai_addr)->sin_addr, 4);
ignore_list_add (&addr);
}
freeaddrinfo (ai_list);
}
+#if HAVE_PCAP_H
static void in6_addr_from_buffer (struct in6_addr *ia,
const void *buf, size_t buf_len,
int family)
memset (ia, 0, sizeof (struct in6_addr));
if ((AF_INET == family) && (sizeof (uint32_t) == buf_len))
{
- ia->s6_addr32[2] = htonl (0x0000FFFF);
- ia->s6_addr32[3] = *((uint32_t *) buf);
+ ia->s6_addr[10] = 0xFF;
+ ia->s6_addr[11] = 0xFF;
+ memcpy (ia->s6_addr + 12, buf, buf_len);
}
else if ((AF_INET6 == family) && (sizeof (struct in6_addr) == buf_len))
{
}
} /* void in6_addr_from_buffer */
-#if HAVE_PCAP_H
void dnstop_set_pcap_obj (pcap_t *po)
{
pcap_obj = po;
}
-#endif
void dnstop_set_callback (void (*cb) (const rfc1035_header_t *))
{
off_t no = 0;
unsigned char c;
size_t len;
- assert(ns > 0);
+ static int loop_detect = 0;
+ if (loop_detect > 2)
+ return 4; /* compression loop */
+ if (ns <= 0)
+ return 4; /* probably compression loop */
do {
if ((*off) >= sz)
break;
c = *(buf + (*off));
if (c > 191) {
/* blasted compression */
+ int rc;
unsigned short s;
off_t ptr;
memcpy(&s, buf + (*off), sizeof(s));
(*off) += sizeof(s);
/* Sanity check */
if ((*off) >= sz)
- return 1;
+ return 1; /* message too short */
ptr = s & 0x3FFF;
/* Make sure the pointer is inside this message */
if (ptr >= sz)
- return 2;
- return rfc1035NameUnpack(buf, sz, &ptr, name + no, ns - no);
+ return 2; /* bad compression ptr */
+ if (ptr < DNS_MSG_HDR_SZ)
+ return 2; /* bad compression ptr */
+ loop_detect++;
+ rc = rfc1035NameUnpack(buf, sz, &ptr, name + no, ns - no);
+ loop_detect--;
+ return rc;
} else if (c > RFC1035_MAXLABELSZ) {
/*
* "(The 10 and 01 combinations are reserved for future use.)"
*/
+ return 3; /* reserved label/compression flags */
break;
- return 3;
} else {
(*off)++;
len = (size_t) c;
break;
if (len > (ns - 1))
len = ns - 1;
- if ((*off) + len > sz) /* message is too short */
- return 4;
+ if ((*off) + len > sz)
+ return 4; /* message is too short */
+ if (no + len + 1 > ns)
+ return 5; /* qname would overflow name buffer */
memcpy(name + no, buf + (*off), len);
(*off) += len;
no += len;
*(name + (no++)) = '.';
}
} while (c > 0);
- *(name + no - 1) = '\0';
+ if (no > 0)
+ *(name + no - 1) = '\0';
/* make sure we didn't allow someone to overflow the name buffer */
assert(no <= ns);
return 0;
}
static int
-handle_dns(const char *buf, int len,
- const struct in6_addr *s_addr,
- const struct in6_addr *d_addr)
+handle_dns(const char *buf, int len)
{
rfc1035_header_t qh;
uint16_t us;
off_t offset;
char *t;
- int x;
+ int status;
/* The DNS header is 12 bytes long */
- if (len < 12)
+ if (len < DNS_MSG_HDR_SZ)
return 0;
memcpy(&us, buf + 0, 2);
memcpy(&us, buf + 2, 2);
us = ntohs(us);
- fprintf (stderr, "Bytes 0, 1: 0x%04hx\n", us);
qh.qr = (us >> 15) & 0x01;
qh.opcode = (us >> 11) & 0x0F;
qh.aa = (us >> 10) & 0x01;
memcpy(&us, buf + 10, 2);
qh.arcount = ntohs(us);
- offset = 12;
+ offset = DNS_MSG_HDR_SZ;
memset(qh.qname, '\0', MAX_QNAME_SZ);
- x = rfc1035NameUnpack(buf, len, &offset, qh.qname, MAX_QNAME_SZ);
- if (0 != x)
+ status = rfc1035NameUnpack(buf, len, &offset, qh.qname, MAX_QNAME_SZ);
+ if (status != 0)
+ {
+ INFO ("utils_dns: handle_dns: rfc1035NameUnpack failed "
+ "with status %i.", status);
return 0;
+ }
if ('\0' == qh.qname[0])
- strcpy(qh.qname, ".");
+ sstrncpy (qh.qname, ".", sizeof (qh.qname));
while ((t = strchr(qh.qname, '\n')))
*t = ' ';
while ((t = strchr(qh.qname, '\r')))
*t = ' ';
for (t = qh.qname; *t; t++)
- *t = tolower(*t);
+ *t = tolower((int) *t);
memcpy(&us, buf + offset, 2);
qh.qtype = ntohs(us);
}
static int
-handle_udp(const struct udphdr *udp, int len,
- const struct in6_addr *s_addr,
- const struct in6_addr *d_addr)
+handle_udp(const struct udphdr *udp, int len)
{
char buf[PCAP_SNAPLEN];
- if ((ntohs (udp->uh_dport) != 53)
- && (ntohs (udp->uh_sport) != 53))
+ if ((ntohs (udp->UDP_DEST) != 53)
+ && (ntohs (udp->UDP_SRC) != 53))
return 0;
memcpy(buf, udp + 1, len - sizeof(*udp));
- if (0 == handle_dns(buf, len - sizeof(*udp), s_addr, d_addr))
+ if (0 == handle_dns(buf, len - sizeof(*udp)))
return 0;
return 1;
}
+#if HAVE_NETINET_IP6_H
static int
handle_ipv6 (struct ip6_hdr *ipv6, int len)
{
char buf[PCAP_SNAPLEN];
- int offset;
+ unsigned int offset;
int nexthdr;
- struct in6_addr s_addr;
- struct in6_addr d_addr;
+ struct in6_addr c_src_addr;
uint16_t payload_len;
+ if (0 > len)
+ return (0);
+
offset = sizeof (struct ip6_hdr);
nexthdr = ipv6->ip6_nxt;
- s_addr = ipv6->ip6_src;
- d_addr = ipv6->ip6_dst;
+ c_src_addr = ipv6->ip6_src;
payload_len = ntohs (ipv6->ip6_plen);
- if (ignore_list_match (&s_addr))
+ if (ignore_list_match (&c_src_addr))
return (0);
/* Parse extension headers. This only handles the standard headers, as
|| (IPPROTO_HOPOPTS == nexthdr) /* Hop-by-Hop options. */
|| (IPPROTO_FRAGMENT == nexthdr) /* fragmentation header. */
|| (IPPROTO_DSTOPTS == nexthdr) /* destination options. */
- || (IPPROTO_DSTOPTS == nexthdr) /* destination options. */
|| (IPPROTO_AH == nexthdr) /* destination options. */
|| (IPPROTO_ESP == nexthdr)) /* encapsulating security payload. */
{
uint16_t ext_hdr_len;
/* Catch broken packets */
- if ((offset + sizeof (struct ip6_ext)) > len)
+ if ((offset + sizeof (struct ip6_ext)) > (unsigned int)len)
return (0);
/* Cannot handle fragments. */
} /* while */
/* Catch broken and empty packets */
- if (((offset + payload_len) > len)
+ if (((offset + payload_len) > (unsigned int)len)
|| (payload_len == 0)
|| (payload_len > PCAP_SNAPLEN))
return (0);
return (0);
memcpy (buf, (char *) ipv6 + offset, payload_len);
- if (handle_udp ((struct udphdr *) buf, payload_len, &s_addr, &d_addr) == 0)
+ if (handle_udp ((struct udphdr *) buf, payload_len) == 0)
return (0);
return (1); /* Success */
} /* int handle_ipv6 */
+/* #endif HAVE_NETINET_IP6_H */
+
+#else /* if !HAVE_NETINET_IP6_H */
+static int
+handle_ipv6 (__attribute__((unused)) void *pkg,
+ __attribute__((unused)) int len)
+{
+ return (0);
+}
+#endif /* !HAVE_NETINET_IP6_H */
static int
handle_ip(const struct ip *ip, int len)
{
char buf[PCAP_SNAPLEN];
int offset = ip->ip_hl << 2;
- struct in6_addr s_addr;
- struct in6_addr d_addr;
+ struct in6_addr c_src_addr;
+ struct in6_addr c_dst_addr;
if (ip->ip_v == 6)
- return (handle_ipv6 ((struct ip6_hdr *) ip, len));
+ return (handle_ipv6 ((void *) ip, len));
- in6_addr_from_buffer (&s_addr, &ip->ip_src.s_addr, sizeof (ip->ip_src.s_addr), AF_INET);
- in6_addr_from_buffer (&d_addr, &ip->ip_dst.s_addr, sizeof (ip->ip_dst.s_addr), AF_INET);
- if (ignore_list_match (&s_addr))
+ in6_addr_from_buffer (&c_src_addr, &ip->ip_src.s_addr, sizeof (ip->ip_src.s_addr), AF_INET);
+ in6_addr_from_buffer (&c_dst_addr, &ip->ip_dst.s_addr, sizeof (ip->ip_dst.s_addr), AF_INET);
+ if (ignore_list_match (&c_src_addr))
return (0);
if (IPPROTO_UDP != ip->ip_p)
return 0;
memcpy(buf, (void *) ip + offset, len - offset);
- if (0 == handle_udp((struct udphdr *) buf, len - offset, &s_addr, &d_addr))
+ if (0 == handle_udp((struct udphdr *) buf, len - offset))
return 0;
return 1;
}
+#if HAVE_NET_IF_PPP_H
static int
handle_ppp(const u_char * pkt, int len)
{
memcpy(buf, pkt, len);
return handle_ip((struct ip *) buf, len);
}
+#endif /* HAVE_NET_IF_PPP_H */
static int
handle_null(const u_char * pkt, int len)
return 0;
memcpy(buf, pkt, len);
if (ETHERTYPE_IPV6 == etype)
- return (handle_ipv6 ((struct ip6_hdr *) buf, len));
+ return (handle_ipv6 ((void *) buf, len));
else
return handle_ip((struct ip *) buf, len);
}
+#ifdef DLT_LINUX_SLL
+static int
+handle_linux_sll (const u_char *pkt, int len)
+{
+ struct sll_header
+ {
+ uint16_t pkt_type;
+ uint16_t dev_type;
+ uint16_t addr_len;
+ uint8_t addr[8];
+ uint16_t proto_type;
+ } *hdr;
+ uint16_t etype;
+
+ if ((0 > len) || ((unsigned int)len < sizeof (struct sll_header)))
+ return (0);
+
+ hdr = (struct sll_header *) pkt;
+ pkt = (u_char *) (hdr + 1);
+ len -= sizeof (struct sll_header);
+
+ etype = ntohs (hdr->proto_type);
+
+ if ((ETHERTYPE_IP != etype)
+ && (ETHERTYPE_IPV6 != etype))
+ return 0;
+
+ if (ETHERTYPE_IPV6 == etype)
+ return (handle_ipv6 ((void *) pkt, len));
+ else
+ return handle_ip((struct ip *) pkt, len);
+}
+#endif /* DLT_LINUX_SLL */
+
/* public function */
-#if HAVE_PCAP_H
void handle_pcap(u_char *udata, const struct pcap_pkthdr *hdr, const u_char *pkt)
{
int status;
- fprintf (stderr, "handle_pcap (udata = %p, hdr = %p, pkt = %p): hdr->caplen = %i\n",
- (void *) udata, (void *) hdr, (void *) pkt,
- hdr->caplen);
-
if (hdr->caplen < ETHER_HDR_LEN)
return;
case DLT_EN10MB:
status = handle_ether (pkt, hdr->caplen);
break;
+#if HAVE_NET_IF_PPP_H
case DLT_PPP:
status = handle_ppp (pkt, hdr->caplen);
break;
+#endif
#ifdef DLT_LOOP
case DLT_LOOP:
status = handle_loop (pkt, hdr->caplen);
status = handle_raw (pkt, hdr->caplen);
break;
#endif
+#ifdef DLT_LINUX_SLL
+ case DLT_LINUX_SLL:
+ status = handle_linux_sll (pkt, hdr->caplen);
+ break;
+#endif
case DLT_NULL:
status = handle_null (pkt, hdr->caplen);
break;
default:
- fprintf (stderr, "unsupported data link type %d\n",
+ ERROR ("handle_pcap: unsupported data link type %d",
pcap_datalink(pcap_obj));
status = 0;
break;
query_count_total++;
last_ts = hdr->ts;
}
-#endif
+#endif /* HAVE_PCAP_H */
const char *qtype_str(int t)
{
static char buf[32];
switch (t) {
+#if (defined (__NAMESER)) && (__NAMESER >= 19991001)
case ns_t_a: return ("A");
case ns_t_ns: return ("NS");
case ns_t_md: return ("MD");
case ns_t_dname: return ("DNAME");
case ns_t_sink: return ("SINK");
case ns_t_opt: return ("OPT");
+# if __NAMESER >= 19991006
case ns_t_tsig: return ("TSIG");
+# endif
case ns_t_ixfr: return ("IXFR");
case ns_t_axfr: return ("AXFR");
case ns_t_mailb: return ("MAILB");
case ns_t_maila: return ("MAILA");
case ns_t_any: return ("ANY");
case ns_t_zxfr: return ("ZXFR");
+/* #endif __NAMESER >= 19991006 */
+#elif (defined (__BIND)) && (__BIND >= 19950621)
+ case T_A: return ("A"); /* 1 ... */
+ case T_NS: return ("NS");
+ case T_MD: return ("MD");
+ case T_MF: return ("MF");
+ case T_CNAME: return ("CNAME");
+ case T_SOA: return ("SOA");
+ case T_MB: return ("MB");
+ case T_MG: return ("MG");
+ case T_MR: return ("MR");
+ case T_NULL: return ("NULL");
+ case T_WKS: return ("WKS");
+ case T_PTR: return ("PTR");
+ case T_HINFO: return ("HINFO");
+ case T_MINFO: return ("MINFO");
+ case T_MX: return ("MX");
+ case T_TXT: return ("TXT");
+ case T_RP: return ("RP");
+ case T_AFSDB: return ("AFSDB");
+ case T_X25: return ("X25");
+ case T_ISDN: return ("ISDN");
+ case T_RT: return ("RT");
+ case T_NSAP: return ("NSAP");
+ case T_NSAP_PTR: return ("NSAP_PTR");
+ case T_SIG: return ("SIG");
+ case T_KEY: return ("KEY");
+ case T_PX: return ("PX");
+ case T_GPOS: return ("GPOS");
+ case T_AAAA: return ("AAAA");
+ case T_LOC: return ("LOC");
+ case T_NXT: return ("NXT");
+ case T_EID: return ("EID");
+ case T_NIMLOC: return ("NIMLOC");
+ case T_SRV: return ("SRV");
+ case T_ATMA: return ("ATMA");
+ case T_NAPTR: return ("NAPTR"); /* ... 35 */
+#if (__BIND >= 19960801)
+ case T_KX: return ("KX"); /* 36 ... */
+ case T_CERT: return ("CERT");
+ case T_A6: return ("A6");
+ case T_DNAME: return ("DNAME");
+ case T_SINK: return ("SINK");
+ case T_OPT: return ("OPT");
+ case T_APL: return ("APL");
+ case T_DS: return ("DS");
+ case T_SSHFP: return ("SSHFP");
+ case T_RRSIG: return ("RRSIG");
+ case T_NSEC: return ("NSEC");
+ case T_DNSKEY: return ("DNSKEY"); /* ... 48 */
+ case T_TKEY: return ("TKEY"); /* 249 */
+#endif /* __BIND >= 19960801 */
+ case T_TSIG: return ("TSIG"); /* 250 ... */
+ case T_IXFR: return ("IXFR");
+ case T_AXFR: return ("AXFR");
+ case T_MAILB: return ("MAILB");
+ case T_MAILA: return ("MAILA");
+ case T_ANY: return ("ANY"); /* ... 255 */
+#endif /* __BIND >= 19950621 */
default:
- snprintf (buf, 32, "#%i", t);
- buf[31] = '\0';
+ ssnprintf (buf, sizeof (buf), "#%i", t);
return (buf);
}; /* switch (t) */
/* NOTREACHED */
return "Update";
break;
default:
- snprintf(buf, 30, "Opcode%d", o);
+ ssnprintf(buf, sizeof (buf), "Opcode%d", o);
return buf;
}
/* NOTREACHED */
static char buf[32];
switch (rcode)
{
+#if (defined (__NAMESER)) && (__NAMESER >= 19991006)
case ns_r_noerror: return ("NOERROR");
case ns_r_formerr: return ("FORMERR");
case ns_r_servfail: return ("SERVFAIL");
case ns_r_badsig: return ("BADSIG");
case ns_r_badkey: return ("BADKEY");
case ns_r_badtime: return ("BADTIME");
+/* #endif __NAMESER >= 19991006 */
+#elif (defined (__BIND)) && (__BIND >= 19950621)
+ case NOERROR: return ("NOERROR");
+ case FORMERR: return ("FORMERR");
+ case SERVFAIL: return ("SERVFAIL");
+ case NXDOMAIN: return ("NXDOMAIN");
+ case NOTIMP: return ("NOTIMP");
+ case REFUSED: return ("REFUSED");
+#if defined (YXDOMAIN) && defined (NXRRSET)
+ case YXDOMAIN: return ("YXDOMAIN");
+ case YXRRSET: return ("YXRRSET");
+ case NXRRSET: return ("NXRRSET");
+ case NOTAUTH: return ("NOTAUTH");
+ case NOTZONE: return ("NOTZONE");
+#endif /* RFC2136 rcodes */
+#endif /* __BIND >= 19950621 */
default:
- snprintf (buf, 32, "RCode%i", rcode);
- buf[31] = '\0';
+ ssnprintf (buf, sizeof (buf), "RCode%i", rcode);
return (buf);
}
/* Never reached */
case DLT_EN10MB:
handle_datalink = handle_ether;
break;
-#if USE_PPP
+#if HAVE_NET_IF_PPP_H
case DLT_PPP:
handle_datalink = handle_ppp;
break;
return 0;
} /* static int main(int argc, char *argv[]) */
#endif
+/*
+ * vim:shiftwidth=4:tabstop=8:softtabstop=4
+ */
projects / collectd.git / blobdiff