Datasets:

Che237
/

cyberforge-datasets

	/*
	** This file is a part of PassiveDNS.
	**
	** Copyright (C) 2010-2013, Edward Fjellskål <edwardfjellskaal@gmail.com>
	**
	** This program is free software; you can redistribute it and/or modify
	** it under the terms of the GNU General Public License as published by
	** the Free Software Foundation; either version 2 of the License, or
	** (at your option) any later version.
	**
	** This program is distributed in the hope that it will be useful,
	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	** GNU General Public License for more details.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program; if not, write to the Free Software
	** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	**
	*/

	/* I N C L U D E S **********************************************************/
	#include "config.h"
	#include <stdio.h>
	#include <stdlib.h>
	#include <libgen.h>
	#include <string.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <signal.h>
	#include <pcap.h>
	#include <getopt.h>
	#include <time.h>
	#include <sys/types.h>
	#include <grp.h>
	#include <pwd.h>
	#include <unistd.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <syslog.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <ctype.h>
	#include <limits.h>
	#include "passivedns.h"
	#include "dns.h"

	#ifdef HAVE_JSON
	#include <jansson.h>
	#endif /* HAVE_JSON */

	#ifdef HAVE_PFRING
	#include <pfring.h>
	#endif /* HAVE_PFRING */

	#ifndef CONFDIR
	#define CONFDIR "/etc/passivedns/"
	#endif

	/* G L O B A L S * (or candidates for refactoring, as we say)*********/
	globalconfig config;
	connection *bucket[BUCKET_SIZE];
	static volatile sig_atomic_t signal_reopen_log_files = 0;

	/* I N T E R N A L P R O T O T Y P E S ***********************************/
	static void usage();
	static void show_version();
	void check_vlan (packetinfo *pi);
	void prepare_null (packetinfo *pi);
	void prepare_raw (packetinfo *pi);
	void prepare_sll (packetinfo *pi);
	void prepare_eth (packetinfo *pi);
	void prepare_ip4 (packetinfo *pi);
	void prepare_ip4ip (packetinfo *pi);
	void prepare_ip6 (packetinfo *pi);
	void prepare_ip6ip (packetinfo *pi);
	void prepare_udp (packetinfo *pi);
	void prepare_tcp (packetinfo *pi);
	void parse_eth (packetinfo *pi);
	void parse_ip4 (packetinfo *pi);
	void parse_ip6 (packetinfo *pi);
	void parse_udp (packetinfo *pi);
	void parse_tcp (packetinfo *pi);
	const char u_ntop_src(packetinfo pi, char *dest);
	void set_pkt_end_ptr (packetinfo *pi);
	void check_interrupt();
	void end_sessions();
	void set_end_sessions();
	void set_end_dns_records();
	void cxt_init();
	int connection_tracking(packetinfo *pi);
	connection cxt_new(packetinfo pi);
	void del_connection(connection , connection *);
	void print_pdns_stats();
	void free_config();
	void reopen_log_files();
	void game_over ();
	void got_packet(u_char useless, const struct pcap_pkthdr pheader,
	const u_char *packet);
	#ifdef HAVE_PFRING
	void pfring_got_packet(const struct pfring_pkthdr *pfheader,
	const u_char packet, const u_char useless);
	#endif /* HAVE_PFRING */

	/* F U N C T I O N S ********************************************************/

	#ifdef HAVE_PFRING

	void pfring_got_packet(const struct pfring_pkthdr *pfheader,
	const u_char packet, const u_char useless)
	{
	/* pcap_pkthdr and pfring_pkthdr are identical to each other*/
	struct pcap_pkthdr pheader = (struct pcap_pkthdr )pfheader;

	/* Set timestamp if it's not set */
	if (pheader->ts.tv_sec == 0)
	pheader->ts.tv_sec = time(NULL);

	/* pfring_loop orders the arguments differently than pcap_loop */
	got_packet((u_char )useless, (const struct pcap_pkthdr )pheader, packet);
	}

	#endif /* HAVE_PFRING */

	void got_packet(u_char useless, const struct pcap_pkthdr pheader,
	const u_char *packet)
	{
	config.p_s.got_packets++;
	packetinfo pstruct = {0};
	packetinfo *pi = &pstruct;
	pi->packet = packet;
	pi->pheader = pheader;
	set_pkt_end_ptr (pi);
	memcpy( &config.tstamp, &pi->pheader->ts, sizeof( struct timeval ) ); /* Global */

	if (signal_reopen_log_files)
	reopen_log_files();

	if (config.intr_flag != 0) {
	check_interrupt();
	}
	config.inpacket = 1;

	switch (config.linktype) {
	case DLT_NULL:
	prepare_null(pi);
	break;
	case DLT_RAW:
	prepare_raw(pi);
	break;
	#ifdef DLT_LINUX_SLL
	case DLT_LINUX_SLL:
	prepare_sll(pi);
	break;
	#endif
	default:
	prepare_eth(pi);
	check_vlan(pi);
	break;
	}

	switch (pi->eth_type) {
	case ETHERNET_TYPE_IP:
	prepare_ip4(pi);
	parse_ip4(pi);
	break;
	case ETHERNET_TYPE_IPV6:
	prepare_ip6(pi);
	parse_ip6(pi);
	break;
	default:
	config.p_s.otherl_recv++;
	//vlog(0x3, "[*] ETHERNET TYPE : %x\n",pi->eth_hdr->eth_ip_type);
	break;
	}

	config.inpacket = 0;
	}

	void prepare_null(packetinfo *pi)
	{
	pi->eth_hlen = LOOPBACK_HDR_LEN;
	if ((u_int32_t)*pi->packet == AF_INET) {
	pi->eth_type = ETHERNET_TYPE_IP;
	} else {
	pi->eth_type = ETHERNET_TYPE_IPV6;
	}
	}

	void prepare_raw(packetinfo *pi)
	{
	pi->eth_hlen = 0;
	if (IP_V((ip4_header *)pi->packet) == 4)
	pi->eth_type = ETHERNET_TYPE_IP;
	else
	pi->eth_type = ETHERNET_TYPE_IPV6;
	}

	void prepare_sll(packetinfo *pi)
	{
	pi->eth_hlen = SLL_HDR_LEN;

	if (IP_V((ip4_header *)(pi->packet + SLL_HDR_LEN)) == 4)
	pi->eth_type = ETHERNET_TYPE_IP;
	else
	pi->eth_type = ETHERNET_TYPE_IPV6;
	}

	void prepare_eth(packetinfo *pi)
	{
	if (pi->packet + ETHERNET_HEADER_LEN > pi->end_ptr)
	return;

	config.p_s.eth_recv++;
	pi->eth_hdr = (ether_header *) (pi->packet);
	pi->eth_type = ntohs(pi->eth_hdr->eth_ip_type);
	pi->eth_hlen = ETHERNET_HEADER_LEN;
	}

	void check_vlan(packetinfo *pi)
	{
	if (pi->eth_type == ETHERNET_TYPE_8021Q) {
	vlog(0x3, "[*] ETHERNET TYPE 8021Q\n");
	config.p_s.vlan_recv++;
	pi->vlan = pi->eth_hdr->eth_8_vid;
	pi->eth_type = ntohs(pi->eth_hdr->eth_8_ip_type);
	pi->eth_hlen += 4;
	if ( pi->eth_type == ETHERNET_TYPE_8021Q ) {
	vlog(0x3, "[*] ETHERNET TYPE 8021Q in 8021Q\n");
	pi->eth_type = ntohs(pi->eth_hdr->eth_82_ip_type);
	pi->eth_hlen += 4;
	pi->vlan = pi->eth_hdr->eth_82_vid;
	}
	}
	else if (pi->eth_type == (ETHERNET_TYPE_802Q1MT \| ETHERNET_TYPE_802Q1MT2 \|
	ETHERNET_TYPE_802Q1MT3 \| ETHERNET_TYPE_8021AD)) {
	vlog(0x3, "[*] ETHERNET TYPE 802Q1MT\n");
	pi->mvlan = pi->eth_hdr->eth_82_mvid;
	pi->eth_type = ntohs(pi->eth_hdr->eth_82_ip_type);
	pi->eth_hlen += 8;
	}
	}

	void prepare_ip4(packetinfo *pi)
	{
	config.p_s.ip4_recv++;
	pi->af = AF_INET;
	pi->ip4 = (ip4_header *) (pi->packet + pi->eth_hlen);
	pi->packet_bytes = (pi->ip4->ip_len - (IP_HL(pi->ip4) * 4));
	}

	void parse_ip4(packetinfo *pi)
	{
	/* Paranoia */
	if (((pi->packet + pi->eth_hlen) + (IP_HL(pi->ip4) * 4)) > pi->end_ptr) {
	dlog("[D] Refusing to parse IPv4 packet: IPv4-hdr passed end_ptr\n");
	return;
	}

	switch (pi->ip4->ip_p) {
	case IP_PROTO_TCP:
	prepare_tcp(pi);
	parse_tcp(pi);
	break;
	case IP_PROTO_UDP:
	prepare_udp(pi);
	parse_udp(pi);
	break;
	case IP_PROTO_IP4:
	prepare_ip4ip(pi);
	break;
	case IP_PROTO_IP6:
	prepare_ip4ip(pi);
	break;
	default:
	break;
	}
	}

	void prepare_ip6ip(packetinfo *pi)
	{
	packetinfo pipi;
	memset(&pipi, 0, sizeof(packetinfo));
	config.p_s.ip6ip_recv++;
	pipi.pheader = pi->pheader;
	pipi.packet = (pi->packet + pi->eth_hlen + IP6_HEADER_LEN);
	pipi.end_ptr = pi->end_ptr;

	if (pi->ip6->next == IP_PROTO_IP4) {
	prepare_ip4(&pipi);
	parse_ip4(&pipi);
	}
	else {
	prepare_ip6(&pipi);
	parse_ip6(&pipi);
	}
	}

	void prepare_ip4ip(packetinfo *pi)
	{
	packetinfo pipi;
	memset(&pipi, 0, sizeof(packetinfo));
	config.p_s.ip4ip_recv++;
	pipi.pheader = pi->pheader;
	pipi.packet = (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4));
	pipi.end_ptr = pi->end_ptr;

	if (pi->ip4->ip_p == IP_PROTO_IP4) {
	prepare_ip4(&pipi);
	parse_ip4(&pipi);
	}
	else {
	prepare_ip6(&pipi);
	parse_ip6(&pipi);
	}
	}

	void prepare_ip6(packetinfo *pi)
	{
	config.p_s.ip6_recv++;
	pi->af = AF_INET6;
	pi->ip6 = (ip6_header *) (pi->packet + pi->eth_hlen);
	pi->packet_bytes = pi->ip6->len;
	}

	void parse_ip6(packetinfo *pi)
	{
	switch (pi->ip6->next) {
	case IP_PROTO_TCP:
	prepare_tcp(pi);
	parse_tcp(pi);
	break;
	case IP_PROTO_UDP:
	prepare_udp(pi);
	parse_udp(pi);
	break;
	case IP_PROTO_IP4:
	prepare_ip6ip(pi);
	break;
	case IP_PROTO_IP6:
	prepare_ip6ip(pi);
	break;
	default:
	break;
	}
	}

	void set_pkt_end_ptr(packetinfo *pi)
	{
	/* Paranoia! */
	if (pi->pheader->len <= SNAPLENGTH)
	pi->end_ptr = (pi->packet + pi->pheader->len);
	else
	pi->end_ptr = (pi->packet + SNAPLENGTH);
	}

	void prepare_tcp(packetinfo *pi)
	{
	config.p_s.tcp_recv++;
	if (pi->af == AF_INET) {
	vlog(0x3, "[*] IPv4 PROTOCOL TYPE TCP:\n");
	pi->tcph = (tcp_header *) (pi->packet + pi->eth_hlen +
	(IP_HL(pi->ip4) * 4));
	pi->plen = (pi->pheader->caplen - (TCP_OFFSET(pi->tcph)) * 4 -
	(IP_HL(pi->ip4) * 4) - pi->eth_hlen);
	pi->payload = (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4) +
	(TCP_OFFSET(pi->tcph) * 4));
	}
	else if (pi->af == AF_INET6) {
	vlog(0x3, "[*] IPv6 PROTOCOL TYPE TCP:\n");
	pi->tcph = (tcp_header *) (pi->packet + pi->eth_hlen + IP6_HEADER_LEN);
	pi->plen = (pi->pheader->caplen - (TCP_OFFSET(pi->tcph)) * 4 -
	IP6_HEADER_LEN - pi->eth_hlen);
	pi->payload = (pi->packet + pi->eth_hlen + IP6_HEADER_LEN +
	(TCP_OFFSET(pi->tcph)*4));
	}
	pi->proto = IP_PROTO_TCP;
	pi->s_port = pi->tcph->src_port;
	pi->d_port = pi->tcph->dst_port;
	connection_tracking(pi);
	}

	void prepare_udp(packetinfo *pi)
	{
	config.p_s.udp_recv++;
	if (pi->af == AF_INET) {
	vlog(0x3, "[*] IPv4 PROTOCOL TYPE UDP:\n");
	pi->udph = (udp_header *) (pi->packet + pi->eth_hlen +
	(IP_HL(pi->ip4) * 4));
	pi->plen = pi->pheader->caplen - UDP_HEADER_LEN -
	(IP_HL(pi->ip4) * 4) - pi->eth_hlen;
	pi->payload = (pi->packet + pi->eth_hlen +
	(IP_HL(pi->ip4) * 4) + UDP_HEADER_LEN);
	}
	else if (pi->af == AF_INET6) {
	vlog(0x3, "[*] IPv6 PROTOCOL TYPE UDP:\n");
	pi->udph = (udp_header *) (pi->packet + pi->eth_hlen +
	IP6_HEADER_LEN);
	pi->plen = pi->pheader->caplen - UDP_HEADER_LEN -
	IP6_HEADER_LEN - pi->eth_hlen;
	pi->payload = (pi->packet + pi->eth_hlen +
	IP6_HEADER_LEN + UDP_HEADER_LEN);
	}
	pi->proto = IP_PROTO_UDP;
	pi->s_port = pi->udph->src_port;
	pi->d_port = pi->udph->dst_port;
	connection_tracking(pi);
	}

	void parse_tcp(packetinfo *pi)
	{
	if (pi->plen <= 0) return;

	/* Reliable traffic comes from the servers (normally on port 53 or 5353)
	* and the client has sent at least one packet on that
	* connecton (Maybe asking for an aswer :) */
	dlog("[D] Parsing TCP packet...\n");
	dns_parser(pi);
	}

	void parse_udp(packetinfo *pi)
	{
	if (pi->plen <= 0) return;

	/* Reliable traffic comes from the servers (normally on port 53 or 5353)
	* and the client has sent at least one packet on that
	* connecton (Maybe asking for an aswer :) */
	dlog("[D] Parsing UDP packet...\n");
	dns_parser(pi);
	}

	int connection_tracking(packetinfo *pi)
	{
	struct in6_addr *ip_src;
	struct in6_addr *ip_dst;
	struct in6_addr ips;
	struct in6_addr ipd;
	uint16_t src_port = pi->s_port;
	uint16_t dst_port = pi->d_port;
	int af = pi->af;
	connection *cxt = NULL;
	connection *head = NULL;
	uint32_t hash;

	if(af == AF_INET6){
	ip_src = &PI_IP6SRC(pi);
	ip_dst = &PI_IP6DST(pi);
	}
	else {
	#ifdef BSD_DERIVED
	ips.__u6_addr.__u6_addr32[0] = pi->ip4->ip_src;
	ipd.__u6_addr.__u6_addr32[0] = pi->ip4->ip_dst;
	#else
	ips.s6_addr32[0] = pi->ip4->ip_src;
	ipd.s6_addr32[0] = pi->ip4->ip_dst;
	#endif
	ip_src = &ips;
	ip_dst = &ipd;
	}

	/* Find the right connection bucket */
	if (af == AF_INET)
	hash = CXT_HASH4(IP4ADDR(ip_src), IP4ADDR(ip_dst), src_port, dst_port,
	pi->proto);
	else if (af == AF_INET6)
	hash = CXT_HASH6(ip_src, ip_dst, src_port, dst_port, pi->proto);
	else {
	dlog("[D] Only CTX with AF_INET and AF_INET6 are supported: %d\n", af);
	return 0;
	}

	cxt = bucket[hash];
	head = cxt;

	/* Search through the bucket */
	while (cxt != NULL)
	{
	/* Two-way compare of given connection against connection table */
	if (af == AF_INET) {
	if (CMP_CXT4(cxt, IP4ADDR(ip_src), src_port, IP4ADDR(ip_dst), dst_port)) {
	/* Client sends first packet (TCP/SYN - UDP?) hence this is a client */
	dlog("[D] Found existing v4 client connection.\n");
	return cxt_update_client(cxt, pi);
	}
	else if (CMP_CXT4(cxt, IP4ADDR(ip_dst), dst_port, IP4ADDR(ip_src), src_port)) {

	if (pi->sc == SC_SERVER) {
	/* This is a server */
	dlog("[D] Found existing v4 server connection.\n");
	return cxt_update_server(cxt, pi);
	}
	else {
	/* This is a client, where we saw a mid-stream DNS response first */
	dlog("[D] Found existing unknown v4 server connection.\n");
	return cxt_update_client(cxt, pi);
	}
	}
	}
	else if (af == AF_INET6) {
	if (CMP_CXT6(cxt, ip_src, src_port, ip_dst, dst_port)) {
	dlog("[D] Found existing v6 client connection.\n");
	return cxt_update_client(cxt, pi);
	}
	else if (CMP_CXT6(cxt, ip_dst, dst_port, ip_src, src_port)) {
	dlog("[D] Found existing v6 client connection.\n");
	return cxt_update_server(cxt, pi);
	}
	}
	cxt = cxt->next;
	}
	/* Bucket turned upside down didn't yield anything. New connection */
	dlog("[D] New connection.\n");
	cxt = cxt_new(pi);

	/* New connections are pushed on to the head of bucket[s_hash] */
	cxt->next = head;
	if (head != NULL)
	/* Are we double linked? */
	head->prev = cxt;

	bucket[hash] = cxt;
	pi->cxt = cxt;
	return cxt_update_unknown(cxt, pi);
	}

	/* Freshly smelling connection :d */
	connection cxt_new(packetinfo pi)
	{
	struct in6_addr ips;
	struct in6_addr ipd;
	connection *cxt;
	config.cxtrackerid++;
	cxt = (connection *) calloc(1, sizeof(connection));
	cxt->cxid = config.cxtrackerid;
	cxt->af = pi->af;

	if (pi->tcph)
	cxt->s_tcpFlags \|= pi->tcph->t_flags;

	cxt->start_time = pi->pheader->ts.tv_sec;
	cxt->last_pkt_time = pi->pheader->ts.tv_sec;

	if (pi->af == AF_INET6){
	cxt->s_ip = PI_IP6SRC(pi);
	cxt->d_ip = PI_IP6DST(pi);
	}
	else {
	#ifdef BSD_DERIVED
	ips.__u6_addr.__u6_addr32[0] = pi->ip4->ip_src;
	ipd.__u6_addr.__u6_addr32[0] = pi->ip4->ip_dst;
	#else
	ips.s6_addr32[0] = pi->ip4->ip_src;
	ipd.s6_addr32[0] = pi->ip4->ip_dst;
	#endif
	cxt->s_ip = ips;
	cxt->d_ip = ipd;
	}

	cxt->s_port = pi->s_port;
	cxt->d_port = pi->d_port;
	cxt->proto = pi->proto;

	cxt->check = 0x00;
	cxt->reversed = 0;
	config.curcxt++;

	return cxt;
	}

	int cxt_update_client(connection cxt, packetinfo pi)
	{
	cxt->last_pkt_time = pi->pheader->ts.tv_sec;

	if (pi->tcph)
	cxt->s_tcpFlags \|= pi->tcph->t_flags;

	cxt->s_total_bytes += pi->packet_bytes;
	cxt->s_total_pkts += 1;

	pi->cxt = cxt;
	pi->sc = SC_CLIENT;

	if (cxt->s_total_bytes > MAX_BYTE_CHECK \|\|
	cxt->s_total_pkts > MAX_PKT_CHECK) {
	return 0; /* Don't Check! */
	}

	return SC_CLIENT;
	}

	int cxt_update_unknown(connection cxt, packetinfo pi)
	{
	cxt->last_pkt_time = pi->pheader->ts.tv_sec;

	if (pi->tcph)
	cxt->s_tcpFlags \|= pi->tcph->t_flags;

	cxt->s_total_bytes += pi->packet_bytes;
	cxt->s_total_pkts += 1;

	pi->cxt = cxt;
	pi->sc = SC_UNKNOWN;

	if (cxt->s_total_bytes > MAX_BYTE_CHECK \|\|
	cxt->s_total_pkts > MAX_PKT_CHECK) {
	return 0; /* Don't Check! */
	}

	return SC_UNKNOWN;
	}

	int cxt_update_server(connection cxt, packetinfo pi)
	{
	cxt->last_pkt_time = pi->pheader->ts.tv_sec;

	if (pi->tcph)
	cxt->d_tcpFlags \|= pi->tcph->t_flags;

	cxt->d_total_bytes += pi->packet_bytes;
	cxt->d_total_pkts += 1;

	pi->cxt = cxt;
	pi->sc = SC_SERVER;

	if (cxt->d_total_bytes > MAX_BYTE_CHECK \|\|
	cxt->d_total_pkts > MAX_PKT_CHECK)
	return 0; /* Don't check! */

	return SC_SERVER;
	}

	void end_all_sessions()
	{
	connection *cxt;
	int cxkey;
	config.llcxt = 0;

	for (cxkey = 0; cxkey < BUCKET_SIZE; cxkey++)
	{
	cxt = bucket[cxkey];
	while (cxt != NULL)
	{
	config.llcxt++;
	if (cxt->prev)
	cxt->prev->next = cxt->next;
	if (cxt->next)
	cxt->next->prev = cxt->prev;
	connection *tmp = cxt;

	cxt = cxt->next;
	del_connection(tmp, &bucket[cxkey]);
	if (cxt == NULL)
	bucket[cxkey] = NULL;
	}
	}
	dlog("CXT in list before cleaning: %10u\n", config.llcxt);
	dlog("CXT in list after cleaning: %10u\n", config.curcxt);
	}

	void end_sessions()
	{
	connection *cxt;
	time_t check_time;
	check_time = config.tstamp.tv_sec;
	int ended, expired = 0;
	config.llcxt = 0;

	int iter;

	for (iter = 0; iter < BUCKET_SIZE; iter++)
	{
	cxt = bucket[iter];
	while (cxt != NULL)
	{
	ended = 0;
	config.llcxt++;
	/* TCP */
	if (cxt->proto == IP_PROTO_TCP) {
	/* FIN from both sides */
	if (cxt->s_tcpFlags & TF_FIN && cxt->d_tcpFlags & TF_FIN
	&& (check_time - cxt->last_pkt_time) > 5)
	ended = 1;
	/* RST from either side */
	else if ((cxt->s_tcpFlags & TF_RST \|\| cxt->d_tcpFlags & TF_RST)
	&& (check_time - cxt->last_pkt_time) > 5)
	ended = 1;
	else if ((check_time - cxt->last_pkt_time) > TCP_TIMEOUT)
	expired = 1;
	}
	/* UDP */
	else if (cxt->proto == IP_PROTO_UDP
	&& (check_time - cxt->last_pkt_time) > UDP_TIMEOUT)
	expired = 1;
	/* ICMP */
	else if (cxt->proto == IP_PROTO_ICMP \|\|
	cxt->proto == IP6_PROTO_ICMP) {
	if ((check_time - cxt->last_pkt_time) > ICMP_TIMEOUT)
	expired = 1;
	}
	/* All other protocols */
	else if ((check_time - cxt->last_pkt_time) > OTHER_TIMEOUT)
	expired = 1;

	if (ended == 1 \|\| expired == 1) {
	/* Remove from the hash */
	if (cxt->prev)
	cxt->prev->next = cxt->next;
	if (cxt->next)
	cxt->next->prev = cxt->prev;
	connection *tmp = cxt;
	connection *tmp_pre = cxt->prev;

	ended = expired = 0;

	cxt = cxt->next;

	del_connection(tmp, &bucket[iter]);
	if (cxt == NULL && tmp_pre == NULL)
	bucket[iter] = NULL;
	}
	else
	cxt = cxt->next;
	}
	}
	dlog("CXT in list before cleaning: %10u\n", config.llcxt);
	dlog("CXT in list after cleaning: %10u\n", config.curcxt);
	}

	void del_connection(connection * cxt, connection ** bucket_ptr)
	{
	connection prev = cxt->prev; / Older connections */
	connection next = cxt->next; / Newer connections */

	if (prev == NULL) {
	/* Beginning of list */
	*bucket_ptr = next;
	/* Not only entry */
	if (next)
	next->prev = NULL;
	}
	else if (next == NULL) {
	/* At end of list! */
	prev->next = NULL;
	}
	else {
	/* A node */
	prev->next = next;
	next->prev = prev;
	}

	/* Free and set to NULL */
	free(cxt);
	cxt = NULL;
	config.curcxt--;
	}

	const char u_ntop_src(packetinfo pi, char *dest)
	{
	if (pi->af == AF_INET) {
	if (!inet_ntop(AF_INET, &pi->ip4->ip_src, dest, INET_ADDRSTRLEN + 1)) {
	perror("Something died in inet_ntop");
	return NULL;
	}
	}
	else if (pi->af == AF_INET6) {
	if (!inet_ntop(AF_INET6, &pi->ip6->ip_src, dest,
	INET6_ADDRSTRLEN + 1)) {
	perror("Something died in inet_ntop");
	return NULL;
	}
	}
	return dest;
	}

	void check_interrupt()
	{
	dlog("[D] In interrupt. Flag: %d\n",config.intr_flag);
	if (ISSET_INTERRUPT_END(config))
	game_over();

	else if (ISSET_INTERRUPT_SESSION(config))
	set_end_sessions();

	else if (ISSET_INTERRUPT_DNS(config))
	set_end_dns_records();

	else
	config.intr_flag = 0;
	}

	void sig_alarm_handler()
	{
	time_t now_t;
	now_t = config.tstamp.tv_sec;

	dlog("[D] Got SIG ALRM: %lu\n", now_t);
	/* Each time check for timed out sessions */
	set_end_sessions();

	/* Only check for timed-out dns records each 10 minutes */
	if ((now_t - config.dnslastchk) >= 600) {
	set_end_dns_records();
	}
	alarm(TIMEOUT);
	}

	void sig_hup_handler()
	{
	signal_reopen_log_files = 1;
	}

	void reopen_log_files()
	{
	if (config.output_log) {
	if (config.logfile_fd != NULL && config.logfile_fd != stdout)
	fclose(config.logfile_fd);
	config.logfile_fd = fopen(config.logfile, "a");
	}

	if (config.output_log_nxd) {
	if (config.logfile_all) {
	/* Do nothing, since both logs use the same file */
	}
	else {
	if (config.logfile_nxd_fd != NULL && config.logfile_nxd_fd != stdout)
	fclose(config.logfile_nxd_fd);
	config.logfile_nxd_fd = fopen(config.logfile_nxd, "a");
	}
	}
	signal_reopen_log_files = 0;
	}

	void set_end_dns_records()
	{
	config.intr_flag \|= INTERRUPT_DNS;

	if (config.inpacket == 0) {
	expire_dns_records();
	config.dnslastchk = config.tstamp.tv_sec;
	config.intr_flag &= ~INTERRUPT_DNS;
	}
	}

	void set_end_sessions()
	{
	config.intr_flag \|= INTERRUPT_SESSION;

	if (config.inpacket == 0) {
	end_sessions();
	config.intr_flag &= ~INTERRUPT_SESSION;
	}
	}

	static int set_chroot(void)
	{
	char *absdir;

	/* Change to the directory */
	if (chdir(config.chroot_dir) != 0)
	printf("set_chroot: Can not chdir to \"%s\": %s\n",
	config.chroot_dir,strerror(errno));

	/* Always returns an absolute pathname */
	absdir = getcwd(NULL, 0);

	/* Make the chroot call */
	if (chroot(absdir) < 0)
	printf("Could not chroot to \"%s\": absolute: %s: %s\n",
	config.chroot_dir, absdir, strerror(errno));

	if (chdir("/") < 0)
	printf("Could not chdir to \"/\" after chroot: %s\n", strerror(errno));

	return 0;
	}

	int drop_privs(void)
	{
	struct group *gr;
	struct passwd *pw;
	char *endptr;
	int i;
	int do_setuid = 0;
	int do_setgid = 0;
	unsigned long groupid = 0;
	unsigned long userid = 0;

	if (config.group_name != NULL) {
	do_setgid = 1;
	if (!isdigit(config.group_name[0])) {
	gr = getgrnam(config.group_name);
	if (!gr) {
	if (config.chroot_dir) {
	elog("ERROR: you have chrooted and must set numeric group ID.\n");
	exit(1);
	}
	else {
	elog("ERROR: couldn't get ID for group %s, group does not exist.", config.group_name);
	exit(1);
	}
	}
	groupid = gr->gr_gid;
	}
	else {
	groupid = strtoul(config.group_name, &endptr, 10);
	}
	}

	if (config.user_name != NULL) {
	do_setuid = 1;
	do_setgid = 1;
	if (isdigit(config.user_name[0]) == 0) {
	pw = getpwnam(config.user_name);
	if (pw != NULL) {
	userid = pw->pw_uid;
	}
	else {
	printf("[E] User %s not found!\n", config.user_name);
	}
	}
	else {
	userid = strtoul(config.user_name, &endptr, 10);
	pw = getpwuid(userid);
	}

	if (config.group_name == NULL && pw != NULL)
	groupid = pw->pw_gid;
	}

	if (do_setgid) {
	if ((i = setgid(groupid)) < 0)
	printf("Unable to set group ID: %s", strerror(i));
	}

	endgrent();
	endpwent();

	if (do_setuid) {
	if (getuid() == 0 && initgroups(config.user_name, groupid) < 0)
	printf("Unable to init group names (%s/%lu)", config.user_name,
	groupid);

	if ((i = setuid(userid)) < 0)
	printf("Unable to set user ID: %s\n", strerror(i));
	}
	return 0;
	}

	int is_valid_path(const char *path)
	{
	char dir[STDBUF];
	struct stat st;

	if (path == NULL)
	return 0;

	memcpy(dir, path, strnlen(path, STDBUF));
	dirname(dir);

	if (stat(dir, &st) != 0)
	return 0;

	if (!S_ISDIR(st.st_mode) \|\| access(dir, W_OK) == -1)
	return 0;

	return 1;
	}

	int create_pid_file(const char *path)
	{
	char pid_buffer[12];
	struct flock lock;
	int fd;

	if (!path)
	path = config.pidfile;

	if (!is_valid_path(path))
	printf("PID path \"%s\" aint writable", path);

	if ((fd = open(path, O_CREAT \| O_WRONLY,
	S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH)) == -1)
	return ERROR;

	/* PID file locking */
	lock.l_type = F_WRLCK;
	lock.l_start = 0;
	lock.l_whence = SEEK_SET;
	lock.l_len = 0;

	if (fcntl(fd, F_SETLK, &lock) == -1) {
	close(fd);
	return ERROR;
	}

	snprintf(pid_buffer, sizeof(pid_buffer), "%d\n", (int)getpid());

	if (ftruncate(fd, 0) != 0) {
	close(fd);
	return ERROR;
	}

	if (write(fd, pid_buffer, strlen(pid_buffer)) != 0) {
	close(fd);
	return ERROR;
	}

	close(fd);
	return SUCCESS;
	}

	int daemonize()
	{
	pid_t pid;
	int fd;

	pid = fork();

	if (pid > 0)
	exit(0); /* Parent */

	if (pid < 0)
	return ERROR;

	setsid();

	if ((fd = open("/dev/null", O_RDWR)) >= 0) {
	dup2(fd, 0);
	dup2(fd, 1);
	dup2(fd, 2);
	if (fd > 2) {
	close(fd);
	}
	}

	if (config.pidfile)
	return create_pid_file(config.pidfile);

	return SUCCESS;
	}

	void game_over()
	{
	if (config.inpacket == 0) {
	expire_all_dns_records();
	print_pdns_stats();

	if (config.handle != NULL)
	pcap_close(config.handle);

	config.handle = NULL;

	if (config.hostname != NULL)
	free(config.hostname);

	#ifdef HAVE_PFRING
	if (config.use_pfring && config.pfhandle != NULL) {
	pfring_breakloop(config.pfhandle);
	pfring_close(config.pfhandle);
	}
	#endif /* HAVE_PFRING */

	end_all_sessions();

	if (config.logfile_fd != NULL && config.logfile_fd != stdout)
	fclose(config.logfile_fd);

	if (config.logfile_nxd_fd != NULL && config.logfile_nxd_fd != stdout)
	fclose(config.logfile_nxd_fd);

	free_config();
	olog("\n[*] passivedns ended.\n");
	exit(0);
	}
	config.intr_flag \|= INTERRUPT_END;
	}

	void free_config()
	{
	if (config.cfilter.bf_insns != NULL)
	free(config.cfilter.bf_insns);
	}

	void print_pdns_stats()
	{
	FILE *handle = stdout;
	if (config.use_stats_file) {
	handle = fopen(config.statsfile, "w");
	if (handle == NULL) {
	olog("[!] Error opening stats file %s: %s\n", config.statsfile,
	strerror(errno));
	return;
	}
	}

	flog(handle, "\n");
	flog(handle, "-- Total DNS records allocated :%12u\n",
	config.p_s.dns_records);
	flog(handle, "-- Total DNS assets allocated :%12u\n",
	config.p_s.dns_assets);
	flog(handle, "-- Total DNS packets over IPv4/TCP :%12u\n",
	config.p_s.ip4_dns_tcp);
	flog(handle, "-- Total DNS packets over IPv6/TCP :%12u\n",
	config.p_s.ip6_dns_tcp);
	flog(handle, "-- Total DNS packets over TCP decoded :%12u\n",
	config.p_s.ip4_dec_tcp_ok + config.p_s.ip6_dec_tcp_ok);
	flog(handle, "-- Total DNS packets over TCP failed :%12u\n",
	config.p_s.ip4_dec_tcp_er + config.p_s.ip6_dec_tcp_er);
	flog(handle, "-- Total DNS packets over IPv4/UDP :%12u\n",
	config.p_s.ip4_dns_udp);
	flog(handle, "-- Total DNS packets over IPv6/UDP :%12u\n",
	config.p_s.ip6_dns_udp);
	flog(handle, "-- Total DNS packets over UDP decoded :%12u\n",
	config.p_s.ip4_dec_udp_ok + config.p_s.ip6_dec_udp_ok);
	flog(handle, "-- Total DNS packets over UDP failed :%12u\n",
	config.p_s.ip4_dec_udp_er + config.p_s.ip6_dec_udp_er);
	flog(handle, "-- Total packets received from libpcap :%12u\n",
	config.p_s.got_packets);
	flog(handle, "-- Total Ethernet packets received :%12u\n",
	config.p_s.eth_recv);
	flog(handle, "-- Total VLAN packets received :%12u\n",
	config.p_s.vlan_recv);

	if (config.use_stats_file) {
	fclose(handle);
	}
	}

	void usage()
	{
	olog("\n");
	olog("USAGE:\n");
	olog(" $ passivedns [options]\n\n");
	olog(" OPTIONS:\n\n");
	olog(" -i <iface> Network device <iface> (default: eth0).\n");
	olog(" -r <file> Read pcap <file>.\n");
	olog(" -H <hostname> Choose hostname to print in record.\n");
	#ifdef HAVE_PFRING
	olog(" -n Use PF_RING.\n");
	olog(" -c <cluster_id> Set PF_RING cluster_id.\n");
	#endif /* HAVE_PFRING */
	olog(" -l <file> Logfile normal queries (default: /var/log/passivedns.log).\n");
	olog(" -L <file> Logfile for SRC Error queries (default: /var/log/passivedns.log).\n");
	olog(" -y Log to syslog (uses local7 syslog facility).\n");
	olog(" -Y Log NXDOMAIN to syslog.\n");
	olog(" -d <delimiter> Delimiter between fields in log file (default: \|\|).\n");
	#ifdef HAVE_JSON
	olog(" -j Use JSON as output in log file.\n");
	olog(" -J Use JSON as output in NXDOMAIN log file.\n");
	#endif /* HAVE_JSON */
	olog(" -f <fields> Choose which fields to print (default: -f SMcsCQTAtn).\n");
	olog(" -s <file> Print stats on signal (SIGUSR1) to this file.\n");
	olog(" -b 'BPF' Berkley Packet Filter (default: 'port 53').\n");
	olog(" -p <file> Name of pid file (default: /var/run/passivedns.pid).\n");
	olog(" -S <mem> Soft memory limit in MB (default: 256).\n");
	olog(" -C <sec> Seconds to cache DNS objects in memory (default: %u).\n", DNSCACHETIMEOUT);
	olog(" -P <sec> Seconds between printing duplicate DNS info (default %u).\n", DNSPRINTTIME);
	olog(" -X <flags> Manually set DNS RR Types to care about (default: -X 46CDNPRS).\n");
	olog(" -N Set interface to non promisc. mode.\n");
	olog(" -u <uid> User ID to drop privileges to.\n");
	olog(" -g <gid> Group ID to drop privileges to.\n");
	olog(" -T <dir> Directory to chroot into.\n");
	olog(" -q Quiet mode (no output except errors).\n");
	olog(" -D Run as daemon.\n");
	olog(" -V Show version and exit.\n");
	olog(" -h This help message.\n\n");
	olog(" FIELDS:\n");
	olog("\n");
	olog(" H: YMD-HMS Stamp S: Timestamp(s) M: Timestamp(ms) c: Client IP \n");
	olog(" s: Server IP C: Class Q: Query T: Type \n");
	olog(" A: Answer t: TTL p: Protocol n: Count \n");
	olog(" h: hostname L: QueryLength l: AnswerLength w: Client MAC \n");
	olog(" W: Server MAC \n");
	olog("\n");
	olog(" FLAGS:\n");
	olog("\n");
	olog(" * For Record Types:\n");
	olog(" 4:A 6:AAAA C:CNAME D:DNAME N:NAPTR O:SOA L:LOC F:SPF I:HINFO\n");
	olog(" P:PTR R:RP S:SRV T:TXT M:MX n:NS d:DNSEC H:SSHFP\n");
	olog(" L also enables GPOS\n");
	#ifdef LDNS_RR_TYPE_NSEC3PARAM
	olog(" d enables DS, DNSKEY, NSEC, NSEC3, RRSIG\n");
	#else
	olog(" d enables DS, DNSKEY, NSEC, NSEC3, NSEC3PARAM, RRSIG\n");
	#endif /* LDNS_RR_TYPE_NSEC3PARAM */
	olog("\n");
	olog(" * For Server Return Code (SRC) Errors:\n");
	olog(" f:FORMERR s:SERVFAIL x:NXDOMAIN o:NOTIMPL r:REFUSED\n");
	olog(" y:YXDOMAIN e:YXRRSET t:NXRRSET a:NOTAUTH z:NOTZONE\n");
	olog("\n");
	}

	void show_version()
	{
	olog("\n");
	olog("[*] PassiveDNS %s\n", VERSION);
	olog("[*] By Edward Bjarte Fjellskål <edward.fjellskaal@gmail.com>\n");
	olog("[*] Using %s\n", pcap_lib_version());
	olog("[*] Using ldns version %s\n",ldns_version());
	#ifdef HAVE_PFRING
	/* Print PF_RING version if PF_RING is used */
	if (config.use_pfring) {
	char pfv[50];
	u_int32_t pf_version;
	pfring_version(config.pfhandle, &pf_version);
	snprintf(pfv, 50, "%d.%d.%d",
	(pf_version & 0xFFFF0000) >> 16,
	(pf_version & 0x0000FF00) >> 8,
	pf_version & 0x000000FF);
	olog("[*] Using PF_RING version %s\n", pfv);
	}
	#endif /* HAVE_PFRING */
	#ifdef HAVE_JSON
	if (config.use_json \|\| config.use_json_nxd) {
	olog("[*] Using jansson version %s\n", JANSSON_VERSION);
	}
	#endif /* HAVE_JSON */
	}

	extern int optind, opterr, optopt; // getopt()

	/* magic main */
	int main(int argc, char *argv[])
	{
	int ch = 0; // verbose_already = 0;
	int daemon = 0;
	memset(&config, 0, sizeof(globalconfig));
	config.inpacket = config.intr_flag = 0;
	config.dnslastchk = 0;
	config.bpff = BPFF;
	config.logfile = "/var/log/passivedns.log";
	config.logfile_nxd = "/var/log/passivedns.log";
	config.statsfile = "/var/log/passivedns.stats";
	config.pidfile = "/var/run/passivedns.pid";
	config.promisc = 1;
	config.output_log = 0;
	config.output_log_nxd = 0;
	config.output_syslog = 0;
	config.output_syslog_nxd = 0;
	/* Default memory limit: 256 MB */
	config.mem_limit_max = (256 * 1024 * 1024);
	config.dnsprinttime = DNSPRINTTIME;
	config.dnscachetimeout = DNSCACHETIMEOUT;
	config.dnsf = 0;
	config.log_delimiter = "\|\|";
	config.fieldsf = 0;
	config.fieldsf \|= FIELD_TIMESTAMP_S;
	config.fieldsf \|= FIELD_TIMESTAMP_MS;
	config.fieldsf \|= FIELD_CLIENT;
	config.fieldsf \|= FIELD_SERVER;
	config.fieldsf \|= FIELD_CLASS;
	config.fieldsf \|= FIELD_QUERY;
	config.fieldsf \|= FIELD_TYPE;
	config.fieldsf \|= FIELD_ANSWER;
	config.fieldsf \|= FIELD_TTL;
	config.fieldsf \|= FIELD_COUNT;
	config.dnsf \|= DNS_CHK_A;
	config.dnsf \|= DNS_CHK_AAAA;
	config.dnsf \|= DNS_CHK_PTR;
	config.dnsf \|= DNS_CHK_CNAME;
	config.dnsf \|= DNS_CHK_DNAME;
	config.dnsf \|= DNS_CHK_NAPTR;
	config.dnsf \|= DNS_CHK_RP;
	config.dnsf \|= DNS_CHK_SRV;
	#ifdef HAVE_PFRING
	config.cluster_id = 0;
	u_int32_t flags = 0;
	#endif /* HAVE_PFRING */
	signal(SIGTERM, game_over);
	signal(SIGINT, game_over);
	signal(SIGQUIT, game_over);
	signal(SIGALRM, sig_alarm_handler);
	signal(SIGHUP, sig_hup_handler);
	signal(SIGUSR1, print_pdns_stats);
	signal(SIGUSR2, expire_all_dns_records);

	#define ARGS "i:H:r:qc:nyYNjJl:s:L:d:hb:Dp:C:P:S:f:X:u:g:T:V"

	while ((ch = getopt(argc, argv, ARGS)) != -1)
	switch (ch) {
	case 'i':
	config.dev = optarg;
	break;
	case 'H':
	config.hostname = strdup(optarg);
	break;
	case 'r':
	config.pcap_file = optarg;
	break;
	case 'q':
	config.cflags \|= CONFIG_QUIET;
	break;
	case 'L':
	config.output_log_nxd = 1;
	config.logfile_nxd = optarg;
	break;
	case 'l':
	config.output_log = 1;
	config.logfile = optarg;
	break;
	case 'y':
	config.output_syslog = 1;
	break;
	case 'Y':
	config.output_syslog_nxd = 1;
	break;
	#ifdef HAVE_JSON
	case 'j':
	config.use_json = 1;
	break;
	case 'J':
	config.use_json_nxd = 1;
	break;
	#endif /* HAVE_JSON */
	case 'd':
	config.log_delimiter = optarg;
	break;
	case 'b':
	config.bpff = optarg;
	break;
	case 'p':
	config.pidfile = optarg;
	break;
	case 'C':
	config.dnscachetimeout = strtol(optarg, NULL, 0);
	break;
	case 'P':
	config.dnsprinttime = strtol(optarg, NULL, 0);
	break;
	case 'S':
	config.mem_limit_max = (strtol(optarg, NULL, 0) * 1024 * 1024);
	break;
	case 's':
	config.use_stats_file = 1;
	config.statsfile = optarg;
	break;
	case 'f':
	parse_field_flags(optarg);
	break;
	case 'X':
	parse_dns_flags(optarg);
	break;
	case 'D':
	daemon = 1;
	break;
	case 'T':
	config.chroot_dir = optarg;
	config.chroot_flag = 1;
	break;
	case 'u':
	config.user_name = optarg;
	config.drop_privs_flag = 1;
	break;
	case 'g':
	config.group_name = optarg;
	config.drop_privs_flag = 1;
	break;
	case 'N':
	config.promisc = 0;
	break;
	#ifdef HAVE_PFRING
	case 'n':
	config.use_pfring = 1;
	break;
	case 'c':
	config.cluster_id = strtol(optarg, NULL, 0);
	break;
	#endif /* HAVE_PFRING */
	case 'h':
	usage();
	exit(0);
	break;
	case 'V':
	show_version();
	olog("\n");
	exit(0);
	break;
	case '?':
	elog("unrecognized argument: '%c'\n", optopt);
	break;
	default:
	elog("Did not recognize argument '%c'\n", ch);
	}

	/* Get hostname if not specified by commandline */
	if (config.fieldsf & FIELD_HOSTNAME) {
	if (config.hostname == NULL) {
	config.hostname = malloc(HOST_NAME_MAX + 1);
	gethostname(config.hostname, HOST_NAME_MAX);
	}
	}

	/* Fall back to log file if syslog is not used */
	if (config.output_syslog == 0)
	config.output_log = 1;

	if (config.output_syslog_nxd == 0)
	config.output_log_nxd = 1;

	/* Open log file */
	if (config.output_log) {
	if (config.logfile[0] == '-' && config.logfile[1] == '\0') {
	config.logfile_fd = stdout;
	}
	else {
	config.logfile_fd = fopen(config.logfile, "a");
	if (config.logfile_fd == NULL) {
	elog("[!] Error opening log file %s\n", config.logfile);
	exit(1);
	}
	}
	}

	/* Open NXDOMAIN log file */
	if (config.output_log_nxd) {
	if (config.output_log && strcmp(config.logfile, config.logfile_nxd) == 0) {
	config.logfile_all = 1;
	}
	else if (config.logfile_nxd[0] == '-' && config.logfile_nxd[1] == '\0') {
	config.logfile_nxd_fd = stdout;
	}
	else {
	config.logfile_nxd_fd = fopen(config.logfile_nxd, "a");
	if (config.logfile_nxd_fd == NULL) {
	elog("[!] Error opening NXDOMAIN log file %s\n", config.logfile_nxd);
	exit(1);
	}
	}
	}

	show_version();

	#ifdef HAVE_PFRING
	if (config.use_pfring) {
	/* PF_RING does not have an option to read PCAP files */
	if (config.pcap_file) {
	elog("[!] Reading PCAP files are not supported when using PF_RING\n");
	exit(1);
	}

	if (config.dev == NULL) {
	elog("[!] Must specify capture NIC\n");
	exit(1);
	}

	flags \|= PF_RING_PROMISC;
	config.pfhandle = pfring_open(config.dev, SNAPLENGTH, flags);

	if (config.pfhandle == NULL) {
	elog("[!] Could not start PF_RING capture\n");
	exit(1);
	}

	config.linktype = DLT_EN10MB;
	pfring_set_application_name(config.pfhandle, "passivedns");

	if (config.cluster_id == 0)
	config.cluster_id = 99; /* Default cluster_id */

	/* Don't add ring to cluster when using ZC or DNA */
	if ((strncmp(config.dev, "zc", 2) != 0) && (strncmp(config.dev, "dna", 3)) != 0) {
	if ((pfring_set_cluster(config.pfhandle, config.cluster_id,
	cluster_per_flow)) != 0) {
	elog("[!] Could not set PF_RING cluster_id\n");
	}
	}

	#ifdef HAVE_PFRING_BPF
	if (*config.bpff != '\0') {
	if ((pfring_set_bpf_filter(config.pfhandle, config.bpff)) != 0) {
	elog("[!] Unable to set bpf filter\n");
	}
	}
	#endif /* HAVE_PFRING_BPF */

	if ((pfring_enable_ring(config.pfhandle)) != 0) {
	elog("[!] Could not enable ring\n");
	exit(1);
	}

	if (config.chroot_dir) {
	olog("[*] Chrooting to dir '%s'..\n", config.chroot_dir);
	if (set_chroot()) {
	elog("[!] failed to chroot\n");
	exit(1);
	}
	}

	if (config.drop_privs_flag) {
	olog("[*] Dropping privs...\n");
	drop_privs();
	}

	if (daemon) {
	if (!is_valid_path(config.pidfile))
	elog("[*] Unable to create pidfile '%s'\n", config.pidfile);
	openlog("passivedns", LOG_PID \| LOG_CONS, LOG_DAEMON);
	olog("[*] Daemonizing...\n\n");
	daemonize();
	}

	alarm(TIMEOUT);
	olog("[*] Device: %s\n", config.dev);
	olog("[*] Sniffing...\n\n");

	pfring_loop(config.pfhandle, pfring_got_packet, (u_char*)NULL, 1);

	game_over();
	return 0;
	}
	#endif /* HAVE_PFRING */

	if (config.pcap_file) {
	/* Read from PCAP file specified by '-r' switch. */
	olog("[*] Reading from file %s\n\n", config.pcap_file);
	if (!(config.handle = pcap_open_offline(config.pcap_file, config.errbuf))) {
	elog("[*] Unable to open %s. (%s)", config.pcap_file, config.errbuf);
	}

	}
	else {
	/* Look up an available device if non specified */
	if (config.dev == 0x0) {
	pcap_if_t *alldevs;
	if (0 != pcap_findalldevs(&alldevs, config.errbuf)) {
	elog("[*] Error pcap_findalldevs: %s \n", config.errbuf);
	exit(1);
	}
	config.dev = strdup(alldevs[0].name);
	pcap_freealldevs(alldevs);
	}
	olog("[*] Device: %s\n", config.dev);

	if ((config.handle = pcap_open_live(config.dev, SNAPLENGTH, config.promisc, 500,
	config.errbuf)) == NULL) {
	elog("[*] Error pcap_open_live: %s \n", config.errbuf);
	exit(1);
	}

	if (strlen(config.errbuf) > 0) {
	/* Fix to enable passivedns to run in an OpenVZ container */
	if (strcmp(config.errbuf, "arptype 65535 not supported by libpcap - falling back to cooked socket") == 0) {
	olog("[*] %s \n", config.errbuf);
	}
	else {
	elog("[*] Error errbuf: %s \n", config.errbuf);
	exit(1);
	}
	}

	if (config.chroot_dir) {
	olog("[*] Chrooting to dir '%s'..\n", config.chroot_dir);
	if(set_chroot()){
	elog("[!] failed to chroot\n");
	exit(1);
	}
	}

	if (config.drop_privs_flag) {
	olog("[*] Dropping privs...\n");
	drop_privs();
	}

	if (daemon) {
	if (!is_valid_path(config.pidfile))
	elog("[*] Unable to create pidfile '%s'\n", config.pidfile);
	openlog("passivedns", LOG_PID \| LOG_CONS, LOG_DAEMON);
	olog("[*] Daemonizing...\n\n");
	daemonize();
	}

	}

	if (config.handle == NULL) {
	game_over();
	return 1;
	}

	config.linktype = pcap_datalink(config.handle);

	/* Segfaults on empty pcap! */
	if ((pcap_compile(config.handle, &config.cfilter, config.bpff, 1,
	config.net_mask)) == -1) {
	elog("[*] Error pcap_compile user_filter: %s\n",
	pcap_geterr(config.handle));
	exit(1);
	}

	if (pcap_setfilter(config.handle, &config.cfilter)) {
	olog("[*] Unable to set pcap filter! %s",
	pcap_geterr(config.handle));
	}

	alarm(TIMEOUT);

	if (!config.pcap_file) olog("[*] Sniffing...\n\n");

	pcap_loop(config.handle, -1, got_packet, NULL);

	game_over();
	return 0;
	}