/*

 * Stanford Enetfilter subroutines for tcpdump

 *

 * Based on the MERIT NNstat etherifrt.c and the Ultrix pcap-pf.c

 * subroutines.

 *

 * Rayan Zachariassen, CA*Net

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <sys/types.h>

#include <sys/time.h>

#include <sys/file.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <net/if.h>

#include <pcap/bpf.h>

#include <net/enet.h>

#include <netinet/in.h>

#include <netinet/if_ether.h>

#include <stdio.h>

#include <errno.h>

#include "interface.h"

struct packet_header {

#ifdef	IBMRTPC

	struct LengthWords	length;

	struct tap_header	tap;

#endif	/* IBMRTPC */

	u_char			packet[8]

};

extern int errno;

#define BUFSPACE (4*1024)

/* Forwards */

static void efReadError(int, char *);

void

readloop(int cnt, int if_fd, struct bpf_program *fp, printfunc printit)

{

#ifdef	IBMRTPC

	register struct packet_header *ph;

	register u_char *bp;

	register int inc;

#else	/* !IBMRTPC */

	static struct timeval tv = { 0 };

#endif	/* IBMRTPC */

	register int cc, caplen;

	register struct bpf_insn *fcode = fp->bf_insns;

	union {

		struct packet_header hdr;

		u_char	p[BUFSPACE];

		u_short	s;

	} buf;

	while (1) {

		if ((cc = read(if_fd, (char *)buf.p, sizeof(buf))) < 0)

			efReadError(if_fd, "reader");

#ifdef	IBMRTPC

		/*

		 * Loop through each packet.

		 */

		bp = buf.p;

		while (cc > 0) {

			ph = (struct packet_header *)bp;

			caplen = ph->tap.th_wirelen > snaplen ? snaplen : ph->tap

.th_wirelen ;

			if (bpf_filter(fcode, (char *)ph->packet,

						ph->tap.th_wirelen, caplen)) {

				if (cnt >= 0 && --cnt < 0)

					goto out;

				(*printit)((char *)ph->packet,

					(struct timeval *)ph->tap.th_timestamp,

					ph->tap.th_wirelen, caplen);

			}

			inc = ph->length.PacketOffset;

			cc -= inc;

			bp += inc;

		}

#else	/* !IBMRTPC */

		caplen = cc > snaplen ? snaplen : cc ;

		if (bpf_filter(fcode, buf.hdr.packet, cc, caplen)) {

			if (cnt >= 0 && --cnt < 0)

				goto out;

			(*printit)(buf.hdr.packet, &tv, cc, caplen);

		}

#endif	/* IBMRTPC */

	}

 out:

	wrapup(if_fd);

}

/* Call ONLY if read() has returned an error on packet filter */

static void

efReadError(int fid, char *msg)

{

	if (errno == EINVAL) {	/* read MAXINT bytes already! */

		if (lseek(fid, 0, 0) < 0) {

			perror("tcpdump: efReadError/lseek");

			exit(-1);

		}

		else

			return;

	}

	else {

		(void) fprintf(stderr, "tcpdump: ");

		perror(msg);

		exit(-1);

	}

}

void

wrapup(int fd)

{

#ifdef	IBMRTPC

	struct enstats es;

	if (ioctl(fd, EIOSTATS, &es) == -1) {

		perror("tcpdump: enet ioctl EIOSTATS error");

		exit(-1);

	}

	fprintf(stderr, "%d packets queued", es.enStat_Rcnt);

	if (es.enStat_Rdrops > 0)

		fprintf(stderr, ", %d dropped", es.enStat_Rdrops);

	if (es.enStat_Reads > 0)

		fprintf(stderr, ", %d tcpdump %s", es.enStat_Reads,

				es.enStat_Reads > 1 ? "reads" : "read");

	if (es.enStat_MaxRead > 1)

		fprintf(stderr, ", %d packets in largest read",

			es.enStat_MaxRead);

	putc('\n', stderr);

#endif	/* IBMRTPC */

	close(fd);

}

int

initdevice(char *device, int pflag, int *linktype)

{

	struct eniocb ctl;

	struct enfilter filter;

	u_int maxwaiting;

	int if_fd;

#ifdef	IBMRTPC

	GETENETDEVICE(0, O_RDONLY, &if_fd);

#else	/* !IBMRTPC */

	if_fd = open("/dev/enet", O_RDONLY, 0);

#endif	/* IBMRTPC */

	if (if_fd == -1) {

		perror("tcpdump: enet open error");

		error(

"your system may not be properly configured; see \"man enet(4)\"");

		exit(-1);

	}

	/*  Get operating parameters. */

	if (ioctl(if_fd, EIOCGETP, (char *)&ctl) == -1) {

		perror("tcpdump: enet ioctl EIOCGETP error");

		exit(-1);

	}

	/*  Set operating parameters. */

#ifdef	IBMRTPC

	ctl.en_rtout = 1 * ctl.en_hz;

	ctl.en_tr_etherhead = 1;

	ctl.en_tap_network = 1;

	ctl.en_multi_packet = 1;

	ctl.en_maxlen = BUFSPACE;

#else	/* !IBMRTPC */

	ctl.en_rtout = 64;	/* randomly picked value for HZ */

#endif	/* IBMRTPC */

	if (ioctl(if_fd, EIOCSETP, &ctl) == -1) {

		perror("tcpdump: enet ioctl EIOCSETP error");

		exit(-1);

	}

	/*  Flush the receive queue, since we've changed

	    the operating parameters and we otherwise might

	    receive data without headers. */

	if (ioctl(if_fd, EIOCFLUSH) == -1) {

		perror("tcpdump: enet ioctl EIOCFLUSH error");

		exit(-1);

	}

	/*  Set the receive queue depth to its maximum. */

	maxwaiting = ctl.en_maxwaiting;

	if (ioctl(if_fd, EIOCSETW, &maxwaiting) == -1) {

		perror("tcpdump: enet ioctl EIOCSETW error");

		exit(-1);

	}

#ifdef	IBMRTPC

	/*  Clear statistics. */

	if (ioctl(if_fd, EIOCLRSTAT, 0) == -1) {

		perror("tcpdump: enet ioctl EIOCLRSTAT error");

		exit(-1);

	}

#endif	/* IBMRTPC */

	/*  Set the filter (accept all packets). */

	filter.enf_Priority = 3;

	filter.enf_FilterLen = 0;

	if (ioctl(if_fd, EIOCSETF, &filter) == -1) {

		perror("tcpdump: enet ioctl EIOCSETF error");

		exit(-1);

	}

	/*

	 * "enetfilter" supports only ethernets.

	 */

	*linktype = DLT_EN10MB;

	return(if_fd);

}