Archipelago » qemu

/*

 * QEMU BOOTP/DHCP server

 * 

 * Copyright (c) 2004 Fabrice Bellard

 * 

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include <slirp.h>

/* XXX: only DHCP is supported */

#define NB_ADDR 16

#define START_ADDR 15

#define LEASE_TIME (24 * 3600)

typedef struct {

    uint8_t allocated;

} BOOTPClient;

BOOTPClient bootp_clients[NB_ADDR];

static const uint8_t rfc1533_cookie[] = { RFC1533_COOKIE };

#ifdef DEBUG

#define dprintf(fmt, args...) \

if (slirp_debug & DBG_CALL) { fprintf(dfd, fmt, ## args); fflush(dfd); }

#else

#define dprintf(fmt, args...)

#endif

static BOOTPClient *get_new_addr(struct in_addr *paddr)

{

    BOOTPClient *bc;

    int i;

    for(i = 0; i < NB_ADDR; i++) {

        if (!bootp_clients[i].allocated)

            goto found;

    }

    return NULL;

 found:

    bc = &bootp_clients[i];

    bc->allocated = 1;

    paddr->s_addr = htonl(ntohl(special_addr.s_addr) | (i + START_ADDR));

    return bc;

}

static void dhcp_decode(const uint8_t *buf, int size,

                        int *pmsg_type)

{

    const uint8_t *p, *p_end;

    int len, tag;

    *pmsg_type = 0;    

    p = buf;

    p_end = buf + size;

    if (size < 5)

        return;

    if (memcmp(p, rfc1533_cookie, 4) != 0)

        return;

    p += 4;

    while (p < p_end) {

        tag = p[0];

        if (tag == RFC1533_PAD) {

            p++; 

        } else if (tag == RFC1533_END) {

            break;

        } else {

            p++;

            if (p >= p_end)

                break;

            len = *p++;

            dprintf("dhcp: tag=0x%02x len=%d\n", tag, len);

            switch(tag) {

            case RFC2132_MSG_TYPE:

                if (len >= 1)

                    *pmsg_type = p[0];

                break;

            default:

                break;

            }

            p += len;

        }

    }

}

static void bootp_reply(struct bootp_t *bp)

{

    BOOTPClient *bc;

    struct mbuf *m;

    struct bootp_t *rbp;

    struct sockaddr_in saddr, daddr;

    struct in_addr dns_addr;

    int dhcp_msg_type, val;

    uint8_t *q;

    /* extract exact DHCP msg type */

    dhcp_decode(bp->bp_vend, DHCP_OPT_LEN, &dhcp_msg_type);

    dprintf("bootp packet op=%d msgtype=%d\n", bp->bp_op, dhcp_msg_type);

    if (dhcp_msg_type != DHCPDISCOVER && 

        dhcp_msg_type != DHCPREQUEST)

        return;

    /* XXX: this is a hack to get the client mac address */

    memcpy(client_ethaddr, bp->bp_hwaddr, 6);

    if ((m = m_get()) == NULL)

        return;

    m->m_data += if_maxlinkhdr;

    rbp = (struct bootp_t *)m->m_data;

    m->m_data += sizeof(struct udpiphdr);

    memset(rbp, 0, sizeof(struct bootp_t));

    bc = get_new_addr(&daddr.sin_addr);

    if (!bc) {

        dprintf("no address left\n");

        return;

    }

    dprintf("offered addr=%08x\n", ntohl(daddr.sin_addr.s_addr));

    saddr.sin_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_ALIAS);

    saddr.sin_port = htons(BOOTP_SERVER);

    daddr.sin_port = htons(BOOTP_CLIENT);

    rbp->bp_op = BOOTP_REPLY;

    rbp->bp_xid = bp->bp_xid;

    rbp->bp_htype = 1;

    rbp->bp_hlen = 6;

    memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6);

    rbp->bp_yiaddr = daddr.sin_addr; /* IP address */

    q = rbp->bp_vend;

    memcpy(q, rfc1533_cookie, 4);

    q += 4;

    if (dhcp_msg_type == DHCPDISCOVER) {

        *q++ = RFC2132_MSG_TYPE;

        *q++ = 1;

        *q++ = DHCPOFFER;

    } else if (dhcp_msg_type == DHCPREQUEST) {

        *q++ = RFC2132_MSG_TYPE;

        *q++ = 1;

        *q++ = DHCPACK;

    }

    if (dhcp_msg_type == DHCPDISCOVER ||

        dhcp_msg_type == DHCPREQUEST) {

        *q++ = RFC2132_SRV_ID;

        *q++ = 4;

        memcpy(q, &saddr.sin_addr, 4);

        q += 4;

        *q++ = RFC1533_NETMASK;

        *q++ = 4;

        *q++ = 0xff;

        *q++ = 0xff;

        *q++ = 0xff;

        *q++ = 0x00;

        *q++ = RFC1533_GATEWAY;

        *q++ = 4;

        memcpy(q, &saddr.sin_addr, 4);

        q += 4;

        *q++ = RFC1533_DNS;

        *q++ = 4;

        dns_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_DNS);

        memcpy(q, &dns_addr, 4);

        q += 4;

        *q++ = RFC2132_LEASE_TIME;

        *q++ = 4;

        val = htonl(LEASE_TIME);

        memcpy(q, &val, 4);

        q += 4;

    }

    *q++ = RFC1533_END;

    m->m_len = sizeof(struct bootp_t);

    udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);

}

void bootp_input(struct mbuf *m)

{

    struct bootp_t *bp = (struct bootp_t *)m->m_data;

    if (bp->bp_op == BOOTP_REQUEST) {

        bootp_reply(bp);

    }

}

/* bootp/dhcp defines */

#define BOOTP_SERVER	67

#define BOOTP_CLIENT	68

#define BOOTP_REQUEST	1

#define BOOTP_REPLY	2

#define RFC1533_COOKIE		99, 130, 83, 99

#define RFC1533_PAD		0

#define RFC1533_NETMASK		1

#define RFC1533_TIMEOFFSET	2

#define RFC1533_GATEWAY		3

#define RFC1533_TIMESERVER	4

#define RFC1533_IEN116NS	5

#define RFC1533_DNS		6

#define RFC1533_LOGSERVER	7

#define RFC1533_COOKIESERVER	8

#define RFC1533_LPRSERVER	9

#define RFC1533_IMPRESSSERVER	10

#define RFC1533_RESOURCESERVER	11

#define RFC1533_HOSTNAME	12

#define RFC1533_BOOTFILESIZE	13

#define RFC1533_MERITDUMPFILE	14

#define RFC1533_DOMAINNAME	15

#define RFC1533_SWAPSERVER	16

#define RFC1533_ROOTPATH	17

#define RFC1533_EXTENSIONPATH	18

#define RFC1533_IPFORWARDING	19

#define RFC1533_IPSOURCEROUTING	20

#define RFC1533_IPPOLICYFILTER	21

#define RFC1533_IPMAXREASSEMBLY	22

#define RFC1533_IPTTL		23

#define RFC1533_IPMTU		24

#define RFC1533_IPMTUPLATEAU	25

#define RFC1533_INTMTU		26

#define RFC1533_INTLOCALSUBNETS	27

#define RFC1533_INTBROADCAST	28

#define RFC1533_INTICMPDISCOVER	29

#define RFC1533_INTICMPRESPOND	30

#define RFC1533_INTROUTEDISCOVER 31

#define RFC1533_INTROUTESOLICIT	32

#define RFC1533_INTSTATICROUTES	33

#define RFC1533_LLTRAILERENCAP	34

#define RFC1533_LLARPCACHETMO	35

#define RFC1533_LLETHERNETENCAP	36

#define RFC1533_TCPTTL		37

#define RFC1533_TCPKEEPALIVETMO	38

#define RFC1533_TCPKEEPALIVEGB	39

#define RFC1533_NISDOMAIN	40

#define RFC1533_NISSERVER	41

#define RFC1533_NTPSERVER	42

#define RFC1533_VENDOR		43

#define RFC1533_NBNS		44

#define RFC1533_NBDD		45

#define RFC1533_NBNT		46

#define RFC1533_NBSCOPE		47

#define RFC1533_XFS		48

#define RFC1533_XDM		49

#define RFC2132_REQ_ADDR	50

#define RFC2132_LEASE_TIME      51

#define RFC2132_MSG_TYPE	53

#define RFC2132_SRV_ID		54

#define RFC2132_PARAM_LIST	55

#define RFC2132_MAX_SIZE	57

#define RFC2132_RENEWAL_TIME    58

#define RFC2132_REBIND_TIME     59

#define DHCPDISCOVER		1

#define DHCPOFFER		2

#define DHCPREQUEST		3

#define DHCPACK			5

#define RFC1533_VENDOR_MAJOR	0

#define RFC1533_VENDOR_MINOR	0

#define RFC1533_VENDOR_MAGIC	128

#define RFC1533_VENDOR_ADDPARM	129

#define	RFC1533_VENDOR_ETHDEV	130

#define RFC1533_VENDOR_HOWTO    132

#define RFC1533_VENDOR_MNUOPTS	160

#define RFC1533_VENDOR_SELECTION 176

#define RFC1533_VENDOR_MOTD	184

#define RFC1533_VENDOR_NUMOFMOTD 8

#define RFC1533_VENDOR_IMG	192

#define RFC1533_VENDOR_NUMOFIMG	16

#define RFC1533_END		255

#define BOOTP_VENDOR_LEN	64

#define DHCP_OPT_LEN		312

struct bootp_t {

    struct ip ip;

    struct udphdr udp;

    uint8_t bp_op;

    uint8_t bp_htype;

    uint8_t bp_hlen;

    uint8_t bp_hops;

    unsigned long bp_xid;

    unsigned short bp_secs;

    unsigned short unused;

    struct in_addr bp_ciaddr;

    struct in_addr bp_yiaddr;

    struct in_addr bp_siaddr;

    struct in_addr bp_giaddr;

    uint8_t bp_hwaddr[16];

    uint8_t bp_sname[64];

    uint8_t bp_file[128];

    uint8_t bp_vend[DHCP_OPT_LEN];

};

void bootp_input(struct mbuf *m);

/*

 * Copyright (c) 1988, 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *	This product includes software developed by the University of

 *	California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *	@(#)in_cksum.c	8.1 (Berkeley) 6/10/93

 * in_cksum.c,v 1.2 1994/08/02 07:48:16 davidg Exp

 */

#include <slirp.h>

/*

 * Checksum routine for Internet Protocol family headers (Portable Version).

 *

 * This routine is very heavily used in the network

 * code and should be modified for each CPU to be as fast as possible.

 * 

 * XXX Since we will never span more than 1 mbuf, we can optimise this

 */

#define ADDCARRY(x)  (x > 65535 ? x -= 65535 : x)

#define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);}

int cksum(struct mbuf *m, int len)

{

	register u_int16_t *w;

	register int sum = 0;

	register int mlen = 0;

	int byte_swapped = 0;

	union {

		u_int8_t	c[2];

		u_int16_t	s;

	} s_util;

	union {

		u_int16_t s[2];

		u_int32_t l;

	} l_util;

	if (m->m_len == 0)

	   goto cont;

	w = mtod(m, u_int16_t *);

	mlen = m->m_len;

	if (len < mlen)

	   mlen = len;

	len -= mlen;

	/*

	 * Force to even boundary.

	 */

	if ((1 & (long) w) && (mlen > 0)) {

		REDUCE;

		sum <<= 8;

		s_util.c[0] = *(u_int8_t *)w;

		w = (u_int16_t *)((int8_t *)w + 1);

		mlen--;

		byte_swapped = 1;

	}

	/*

	 * Unroll the loop to make overhead from

	 * branches &c small.

	 */

	while ((mlen -= 32) >= 0) {

		sum += w[0]; sum += w[1]; sum += w[2]; sum += w[3];

		sum += w[4]; sum += w[5]; sum += w[6]; sum += w[7];

		sum += w[8]; sum += w[9]; sum += w[10]; sum += w[11];

		sum += w[12]; sum += w[13]; sum += w[14]; sum += w[15];

		w += 16;

	}

	mlen += 32;

	while ((mlen -= 8) >= 0) {

		sum += w[0]; sum += w[1]; sum += w[2]; sum += w[3];

		w += 4;

	}

	mlen += 8;

	if (mlen == 0 && byte_swapped == 0)

	   goto cont;

	REDUCE;

	while ((mlen -= 2) >= 0) {

		sum += *w++;

	}

	if (byte_swapped) {

		REDUCE;

		sum <<= 8;

		byte_swapped = 0;

		if (mlen == -1) {

			s_util.c[1] = *(u_int8_t *)w;

			sum += s_util.s;

			mlen = 0;

		} else

		   mlen = -1;

	} else if (mlen == -1)

	   s_util.c[0] = *(u_int8_t *)w;

cont:

#ifdef DEBUG

	if (len) {

		DEBUG_ERROR((dfd, "cksum: out of data\n"));

		DEBUG_ERROR((dfd, " len = %d\n", len));

	}

#endif

	if (mlen == -1) {

		/* The last mbuf has odd # of bytes. Follow the

		 standard (the odd byte may be shifted left by 8 bits

			   or not as determined by endian-ness of the machine) */

		s_util.c[1] = 0;

		sum += s_util.s;

	}

	REDUCE;

	return (~sum & 0xffff);

}

#define CTL_CMD		0

#define CTL_EXEC	1

#define CTL_ALIAS	2

#define CTL_DNS		3

#define CTL_SPECIAL	"10.0.2.0"

#define CTL_LOCAL	"10.0.2.15"

/*

 * Copyright (c) 1995 Danny Gasparovski.

 * Portions copyright (c) 2000 Kelly Price.

 * 

 * Please read the file COPYRIGHT for the 

 * terms and conditions of the copyright.

 */

#include <slirp.h>

FILE *dfd = NULL;

#ifdef DEBUG

int dostats = 1;

#else

int dostats = 0;

#endif

int slirp_debug = 0;

extern char *strerror _P((int));

/* Carry over one item from main.c so that the tty's restored. 

 * Only done when the tty being used is /dev/tty --RedWolf */

extern struct termios slirp_tty_settings;

extern int slirp_tty_restore;

void

debug_init(file, dbg)

	char *file;

	int dbg;

{

	/* Close the old debugging file */

	if (dfd)

	   fclose(dfd);

	dfd = fopen(file,"w");

	if (dfd != NULL) {

#if 0

		fprintf(dfd,"Slirp %s - Debugging Started.\n", SLIRP_VERSION);

#endif

		fprintf(dfd,"Debugging Started level %i.\r\n",dbg);

		fflush(dfd);

		slirp_debug = dbg;

	} else {

		lprint("Error: Debugging file \"%s\" could not be opened: %s\r\n",

			file, strerror(errno));

	}

}

/*

 * Dump a packet in the same format as tcpdump -x

 */

#ifdef DEBUG

void

dump_packet(dat, n)

	void *dat;

	int n;

{

	u_char *pptr = (u_char *)dat;

	int j,k;

	n /= 16;

	n++;

	DEBUG_MISC((dfd, "PACKET DUMPED: \n"));

	for(j = 0; j < n; j++) {

		for(k = 0; k < 6; k++)

			DEBUG_MISC((dfd, "%02x ", *pptr++));

		DEBUG_MISC((dfd, "\n"));

		fflush(dfd);

	}

}

#endif

#if 0

/*

 * Statistic routines

 * 

 * These will print statistics to the screen, the debug file (dfd), or

 * a buffer, depending on "type", so that the stats can be sent over

 * the link as well.

 */

void

ttystats(ttyp)

	struct ttys *ttyp;

{

	struct slirp_ifstats *is = &ttyp->ifstats;

	char buff[512];

	lprint(" \r\n");

	if (if_comp & IF_COMPRESS)

	   strcpy(buff, "on");

	else if (if_comp & IF_NOCOMPRESS)

	   strcpy(buff, "off");

	else

	   strcpy(buff, "off (for now)");

	lprint("Unit %d:\r\n", ttyp->unit);

	lprint("  using %s encapsulation (VJ compression is %s)\r\n", (

#ifdef USE_PPP

	       ttyp->proto==PROTO_PPP?"PPP":

#endif

	       "SLIP"), buff);

	lprint("  %d baudrate\r\n", ttyp->baud);

	lprint("  interface is %s\r\n", ttyp->up?"up":"down");

	lprint("  using fd %d, guardian pid is %d\r\n", ttyp->fd, ttyp->pid);

#ifndef FULL_BOLT

	lprint("  towrite is %d bytes\r\n", ttyp->towrite);

#endif

	if (ttyp->zeros)

	   lprint("  %d zeros have been typed\r\n", ttyp->zeros);

	else if (ttyp->ones)

	   lprint("  %d ones have been typed\r\n", ttyp->ones);

	lprint("Interface stats:\r\n");

	lprint("  %6d output packets sent (%d bytes)\r\n", is->out_pkts, is->out_bytes);

	lprint("  %6d output packets dropped (%d bytes)\r\n", is->out_errpkts, is->out_errbytes);

	lprint("  %6d input packets received (%d bytes)\r\n", is->in_pkts, is->in_bytes);

	lprint("  %6d input packets dropped (%d bytes)\r\n", is->in_errpkts, is->in_errbytes);

	lprint("  %6d bad input packets\r\n", is->in_mbad);

}

void

allttystats()

{

	struct ttys *ttyp;

	for (ttyp = ttys; ttyp; ttyp = ttyp->next)

	   ttystats(ttyp);

}

#endif

void

ipstats()

{

	lprint(" \r\n");	

	lprint("IP stats:\r\n");

	lprint("  %6d total packets received (%d were unaligned)\r\n",

			ipstat.ips_total, ipstat.ips_unaligned);

	lprint("  %6d with incorrect version\r\n", ipstat.ips_badvers);

	lprint("  %6d with bad header checksum\r\n", ipstat.ips_badsum);

	lprint("  %6d with length too short (len < sizeof(iphdr))\r\n", ipstat.ips_tooshort);

	lprint("  %6d with length too small (len < ip->len)\r\n", ipstat.ips_toosmall);

	lprint("  %6d with bad header length\r\n", ipstat.ips_badhlen);

	lprint("  %6d with bad packet length\r\n", ipstat.ips_badlen);

	lprint("  %6d fragments received\r\n", ipstat.ips_fragments);

	lprint("  %6d fragments dropped\r\n", ipstat.ips_fragdropped);

	lprint("  %6d fragments timed out\r\n", ipstat.ips_fragtimeout);

	lprint("  %6d packets reassembled ok\r\n", ipstat.ips_reassembled);

	lprint("  %6d outgoing packets fragmented\r\n", ipstat.ips_fragmented);

	lprint("  %6d total outgoing fragments\r\n", ipstat.ips_ofragments);

	lprint("  %6d with bad protocol field\r\n", ipstat.ips_noproto);

	lprint("  %6d total packets delivered\r\n", ipstat.ips_delivered);

}

#if 0

void

vjstats()

{

	lprint(" \r\n");

	lprint("VJ compression stats:\r\n");

	lprint("  %6d outbound packets (%d compressed)\r\n",

	       comp_s.sls_packets, comp_s.sls_compressed);

	lprint("  %6d searches for connection stats (%d misses)\r\n",

	       comp_s.sls_searches, comp_s.sls_misses);

	lprint("  %6d inbound uncompressed packets\r\n", comp_s.sls_uncompressedin);

	lprint("  %6d inbound compressed packets\r\n", comp_s.sls_compressedin);

	lprint("  %6d inbound unknown type packets\r\n", comp_s.sls_errorin);

	lprint("  %6d inbound packets tossed due to error\r\n", comp_s.sls_tossed);

}

#endif

void

tcpstats()

{

	lprint(" \r\n");

	lprint("TCP stats:\r\n");

	lprint("  %6d packets sent\r\n", tcpstat.tcps_sndtotal);

	lprint("          %6d data packets (%d bytes)\r\n",

			tcpstat.tcps_sndpack, tcpstat.tcps_sndbyte);

	lprint("          %6d data packets retransmitted (%d bytes)\r\n",

			tcpstat.tcps_sndrexmitpack, tcpstat.tcps_sndrexmitbyte);

	lprint("          %6d ack-only packets (%d delayed)\r\n",

			tcpstat.tcps_sndacks, tcpstat.tcps_delack);

	lprint("          %6d URG only packets\r\n", tcpstat.tcps_sndurg);

	lprint("          %6d window probe packets\r\n", tcpstat.tcps_sndprobe);

	lprint("          %6d window update packets\r\n", tcpstat.tcps_sndwinup);

	lprint("          %6d control (SYN/FIN/RST) packets\r\n", tcpstat.tcps_sndctrl);

	lprint("          %6d times tcp_output did nothing\r\n", tcpstat.tcps_didnuttin);

	lprint("  %6d packets received\r\n", tcpstat.tcps_rcvtotal);       

	lprint("          %6d acks (for %d bytes)\r\n",

			tcpstat.tcps_rcvackpack, tcpstat.tcps_rcvackbyte);

	lprint("          %6d duplicate acks\r\n", tcpstat.tcps_rcvdupack);

	lprint("          %6d acks for unsent data\r\n", tcpstat.tcps_rcvacktoomuch);

	lprint("          %6d packets received in sequence (%d bytes)\r\n",

			tcpstat.tcps_rcvpack, tcpstat.tcps_rcvbyte);

        lprint("          %6d completely duplicate packets (%d bytes)\r\n",

			tcpstat.tcps_rcvduppack, tcpstat.tcps_rcvdupbyte);

	lprint("          %6d packets with some duplicate data (%d bytes duped)\r\n",

			tcpstat.tcps_rcvpartduppack, tcpstat.tcps_rcvpartdupbyte);

	lprint("          %6d out-of-order packets (%d bytes)\r\n",

			tcpstat.tcps_rcvoopack, tcpstat.tcps_rcvoobyte);

	lprint("          %6d packets of data after window (%d bytes)\r\n",

			tcpstat.tcps_rcvpackafterwin, tcpstat.tcps_rcvbyteafterwin);

	lprint("          %6d window probes\r\n", tcpstat.tcps_rcvwinprobe);

	lprint("          %6d window update packets\r\n", tcpstat.tcps_rcvwinupd);

	lprint("          %6d packets received after close\r\n", tcpstat.tcps_rcvafterclose);

	lprint("          %6d discarded for bad checksums\r\n", tcpstat.tcps_rcvbadsum);

	lprint("          %6d discarded for bad header offset fields\r\n",

			tcpstat.tcps_rcvbadoff);

	lprint("  %6d connection requests\r\n", tcpstat.tcps_connattempt);

	lprint("  %6d connection accepts\r\n", tcpstat.tcps_accepts);

	lprint("  %6d connections established (including accepts)\r\n", tcpstat.tcps_connects);

	lprint("  %6d connections closed (including %d drop)\r\n",

			tcpstat.tcps_closed, tcpstat.tcps_drops);

	lprint("  %6d embryonic connections dropped\r\n", tcpstat.tcps_conndrops);

	lprint("  %6d segments we tried to get rtt (%d succeeded)\r\n",

			tcpstat.tcps_segstimed, tcpstat.tcps_rttupdated);

	lprint("  %6d retransmit timeouts\r\n", tcpstat.tcps_rexmttimeo);

	lprint("          %6d connections dropped by rxmt timeout\r\n",

			tcpstat.tcps_timeoutdrop);

	lprint("  %6d persist timeouts\r\n", tcpstat.tcps_persisttimeo);

	lprint("  %6d keepalive timeouts\r\n", tcpstat.tcps_keeptimeo);

	lprint("          %6d keepalive probes sent\r\n", tcpstat.tcps_keepprobe);

	lprint("          %6d connections dropped by keepalive\r\n", tcpstat.tcps_keepdrops);

	lprint("  %6d correct ACK header predictions\r\n", tcpstat.tcps_predack);

	lprint("  %6d correct data packet header predictions\n", tcpstat.tcps_preddat);

	lprint("  %6d TCP cache misses\r\n", tcpstat.tcps_socachemiss);

/*	lprint("    Packets received too short:		%d\r\n", tcpstat.tcps_rcvshort); */

/*	lprint("    Segments dropped due to PAWS:	%d\r\n", tcpstat.tcps_pawsdrop); */

}

void

udpstats()

{

        lprint(" \r\n");

	lprint("UDP stats:\r\n");

	lprint("  %6d datagrams received\r\n", udpstat.udps_ipackets);

	lprint("  %6d with packets shorter than header\r\n", udpstat.udps_hdrops);

	lprint("  %6d with bad checksums\r\n", udpstat.udps_badsum);

	lprint("  %6d with data length larger than packet\r\n", udpstat.udps_badlen);

	lprint("  %6d UDP socket cache misses\r\n", udpstat.udpps_pcbcachemiss);

	lprint("  %6d datagrams sent\r\n", udpstat.udps_opackets);

}

void

icmpstats()

{

	lprint(" \r\n");

	lprint("ICMP stats:\r\n");

	lprint("  %6d ICMP packets received\r\n", icmpstat.icps_received);

	lprint("  %6d were too short\r\n", icmpstat.icps_tooshort);

	lprint("  %6d with bad checksums\r\n", icmpstat.icps_checksum);

	lprint("  %6d with type not supported\r\n", icmpstat.icps_notsupp);

	lprint("  %6d with bad type feilds\r\n", icmpstat.icps_badtype);

	lprint("  %6d ICMP packets sent in reply\r\n", icmpstat.icps_reflect);

}

void

mbufstats()

{

	struct mbuf *m;

	int i;

        lprint(" \r\n");

	lprint("Mbuf stats:\r\n");

	lprint("  %6d mbufs allocated (%d max)\r\n", mbuf_alloced, mbuf_max);

	i = 0;

	for (m = m_freelist.m_next; m != &m_freelist; m = m->m_next)

		i++;

	lprint("  %6d mbufs on free list\r\n",  i);

	i = 0;

	for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next)

		i++;

	lprint("  %6d mbufs on used list\r\n",  i);

        lprint("  %6d mbufs queued as packets\r\n\r\n", if_queued);

}

void

sockstats()

{

	char buff[256];

	int n;

	struct socket *so;

        lprint(" \r\n");

	lprint(

	   "Proto[state]     Sock     Local Address, Port  Remote Address, Port RecvQ SendQ\r\n");

	for (so = tcb.so_next; so != &tcb; so = so->so_next) {

		n = sprintf(buff, "tcp[%s]", so->so_tcpcb?tcpstates[so->so_tcpcb->t_state]:"NONE");

		while (n < 17)

		   buff[n++] = ' ';

		buff[17] = 0;

		lprint("%s %3d   %15s %5d ",

				buff, so->s,

				inet_ntoa(so->so_laddr), ntohs(so->so_lport));

		lprint("%15s %5d %5d %5d\r\n",

				inet_ntoa(so->so_faddr), ntohs(so->so_fport),

				so->so_rcv.sb_cc, so->so_snd.sb_cc);

	}

	for (so = udb.so_next; so != &udb; so = so->so_next) {

		n = sprintf(buff, "udp[%d sec]", (so->so_expire - curtime) / 1000);

		while (n < 17)

		   buff[n++] = ' ';

		buff[17] = 0;

		lprint("%s %3d  %15s %5d  ",

				buff, so->s,

				inet_ntoa(so->so_laddr), ntohs(so->so_lport));

		lprint("%15s %5d %5d %5d\r\n",

				inet_ntoa(so->so_faddr), ntohs(so->so_fport),

				so->so_rcv.sb_cc, so->so_snd.sb_cc);

	}

}

#if 0

void

slirp_exit(exit_status)

	int exit_status;

{

	struct ttys *ttyp;

	DEBUG_CALL("slirp_exit");

	DEBUG_ARG("exit_status = %d", exit_status);

	if (dostats) {

		lprint_print = (int (*) _P((void *, const char *, va_list)))vfprintf;

		if (!dfd)

		   debug_init("slirp_stats", 0xf);

		lprint_arg = (char **)&dfd;

		ipstats();

		tcpstats();

		udpstats();

		icmpstats();

		mbufstats();

		sockstats();

		allttystats();

		vjstats();

	}

	for (ttyp = ttys; ttyp; ttyp = ttyp->next)

	   tty_detached(ttyp, 1);

	if (slirp_forked) {

		/* Menendez time */

		if (kill(getppid(), SIGQUIT) < 0)

			lprint("Couldn't kill parent process %ld!\n",

			    (long) getppid());

    	}

	/* Restore the terminal if we gotta */

	if(slirp_tty_restore)

	  tcsetattr(0,TCSANOW, &slirp_tty_settings);  /* NOW DAMMIT! */

	exit(exit_status);

}

#endif

/*

 * Copyright (c) 1995 Danny Gasparovski.

 * 

 * Please read the file COPYRIGHT for the 

 * terms and conditions of the copyright.

 */

#define PRN_STDERR	1

#define PRN_SPRINTF	2

extern FILE *dfd;

extern FILE *lfd;

extern int dostats;

extern int slirp_debug;

#define DBG_CALL 0x1

#define DBG_MISC 0x2

#define DBG_ERROR 0x4

#define DEBUG_DEFAULT DBG_CALL|DBG_MISC|DBG_ERROR

#ifdef DEBUG

#define DEBUG_CALL(x) if (slirp_debug & DBG_CALL) { fprintf(dfd, "%s...\n", x); fflush(dfd); }

#define DEBUG_ARG(x, y) if (slirp_debug & DBG_CALL) { fputc(' ', dfd); fprintf(dfd, x, y); fputc('\n', dfd); fflush(dfd); }

#define DEBUG_ARGS(x) if (slirp_debug & DBG_CALL) { fprintf x ; fflush(dfd); }

#define DEBUG_MISC(x) if (slirp_debug & DBG_MISC) { fprintf x ; fflush(dfd); }

#define DEBUG_ERROR(x) if (slirp_debug & DBG_ERROR) {fprintf x ; fflush(dfd); }

#else

#define DEBUG_CALL(x)

#define DEBUG_ARG(x, y)

#define DEBUG_ARGS(x)

#define DEBUG_MISC(x)

#define DEBUG_ERROR(x)

#endif

void debug_init _P((char *, int));

//void ttystats _P((struct ttys *));

void allttystats _P((void));

void ipstats _P((void));

void vjstats _P((void));

void tcpstats _P((void));

void udpstats _P((void));

void icmpstats _P((void));

void mbufstats _P((void));

void sockstats _P((void));

void slirp_exit _P((int));

/*

 * Copyright (c) 1982, 1986, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *	This product includes software developed by the University of

 *	California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *	@(#)icmp_var.h	8.1 (Berkeley) 6/10/93

 * icmp_var.h,v 1.4 1995/02/16 00:27:40 wollman Exp

 */

#ifndef _NETINET_ICMP_VAR_H_

#define _NETINET_ICMP_VAR_H_

/*

 * Variables related to this implementation

 * of the internet control message protocol.

 */

struct icmpstat {

/* statistics related to input messages processed */

	u_long  icps_received;		/* #ICMP packets received */

	u_long	icps_tooshort;		/* packet < ICMP_MINLEN */

	u_long	icps_checksum;		/* bad checksum */

	u_long	icps_notsupp;		/* #ICMP packets not supported */

	u_long  icps_badtype;		/* #with bad type feild */

	u_long	icps_reflect;		/* number of responses */

};

/*

 * Names for ICMP sysctl objects

 */

#define	ICMPCTL_MASKREPL	1	/* allow replies to netmask requests */

#define	ICMPCTL_STATS		2	/* statistics (read-only) */

#define ICMPCTL_MAXID		3

#define ICMPCTL_NAMES { \

	{ 0, 0 }, \

	{ "maskrepl", CTLTYPE_INT }, \

	{ "stats", CTLTYPE_STRUCT }, \

}

extern struct icmpstat icmpstat;

#endif

/*

 * Copyright (c) 1995 Danny Gasparovski.

 *

 * Please read the file COPYRIGHT for the

 * terms and conditions of the copyright.

 */

#include <slirp.h>

int if_mtu, if_mru;

int if_comp;

int if_maxlinkhdr;

int     if_queued = 0;                  /* Number of packets queued so far */

int     if_thresh = 10;                 /* Number of packets queued before we start sending

					 * (to prevent allocing too many mbufs) */

struct  mbuf if_fastq;                  /* fast queue (for interactive data) */

struct  mbuf if_batchq;                 /* queue for non-interactive data */

struct	mbuf *next_m;			/* Pointer to next mbuf to output */

#define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))

void

ifs_insque(ifm, ifmhead)

	struct mbuf *ifm, *ifmhead;

{

	ifm->ifs_next = ifmhead->ifs_next;

	ifmhead->ifs_next = ifm;

	ifm->ifs_prev = ifmhead;

	ifm->ifs_next->ifs_prev = ifm;

}

void

ifs_remque(ifm)

	struct mbuf *ifm;

{

	ifm->ifs_prev->ifs_next = ifm->ifs_next;

	ifm->ifs_next->ifs_prev = ifm->ifs_prev;

}

void

if_init()

{

#if 0

	/*

	 * Set if_maxlinkhdr to 48 because it's 40 bytes for TCP/IP,

	 * and 8 bytes for PPP, but need to have it on an 8byte boundary

	 */

#ifdef USE_PPP

	if_maxlinkhdr = 48;

#else

	if_maxlinkhdr = 40;

#endif

#else

        /* 14 for ethernet + 40 */

        if_maxlinkhdr = 14 + 40;

#endif

	if_mtu = 1500;

	if_mru = 1500;

	if_comp = IF_AUTOCOMP;

	if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq;

	if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;

        //	sl_compress_init(&comp_s);

	next_m = &if_batchq;

}

#if 0

/*

 * This shouldn't be needed since the modem is blocking and

 * we don't expect any signals, but what the hell..

 */

inline int

writen(fd, bptr, n)

	int fd;

	char *bptr;

	int n;

{

	int ret;

	int total;

	/* This should succeed most of the time */

	ret = write(fd, bptr, n);

	if (ret == n || ret <= 0)

	   return ret;

	/* Didn't write everything, go into the loop */

	total = ret;

	while (n > total) {

		ret = write(fd, bptr+total, n-total);

		if (ret <= 0)

		   return ret;

		total += ret;

	}

	return total;

}

/*

 * if_input - read() the tty, do "top level" processing (ie: check for any escapes),

 * and pass onto (*ttyp->if_input)

 * 

 * XXXXX Any zeros arriving by themselves are NOT placed into the arriving packet.

 */

#define INBUFF_SIZE 2048 /* XXX */

void

if_input(ttyp)

	struct ttys *ttyp;

{

	u_char if_inbuff[INBUFF_SIZE];

	int if_n;

	DEBUG_CALL("if_input");

	DEBUG_ARG("ttyp = %lx", (long)ttyp);

	if_n = read(ttyp->fd, (char *)if_inbuff, INBUFF_SIZE);

	DEBUG_MISC((dfd, " read %d bytes\n", if_n));

	if (if_n <= 0) {

		if (if_n == 0 || (errno != EINTR && errno != EAGAIN)) {

			if (ttyp->up)

			   link_up--;

			tty_detached(ttyp, 0);

		}

		return;

	}

	if (if_n == 1) {

		if (*if_inbuff == '0') {

			ttyp->ones = 0;

			if (++ttyp->zeros >= 5)

			   slirp_exit(0);

			return;

		}

		if (*if_inbuff == '1') {

			ttyp->zeros = 0;

			if (++ttyp->ones >= 5)

			   tty_detached(ttyp, 0);

			return;

		}

	}

	ttyp->ones = ttyp->zeros = 0;

	(*ttyp->if_input)(ttyp, if_inbuff, if_n);

}

#endif	

/*

 * if_output: Queue packet into an output queue.

 * There are 2 output queue's, if_fastq and if_batchq. 

 * Each output queue is a doubly linked list of double linked lists

 * of mbufs, each list belonging to one "session" (socket).  This

 * way, we can output packets fairly by sending one packet from each

 * session, instead of all the packets from one session, then all packets

 * from the next session, etc.  Packets on the if_fastq get absolute 

 * priority, but if one session hogs the link, it gets "downgraded"

 * to the batchq until it runs out of packets, then it'll return

 * to the fastq (eg. if the user does an ls -alR in a telnet session,

 * it'll temporarily get downgraded to the batchq)

 */

void

if_output(so, ifm)

	struct socket *so;

	struct mbuf *ifm;

{

	struct mbuf *ifq;

	int on_fastq = 1;

	DEBUG_CALL("if_output");

	DEBUG_ARG("so = %lx", (long)so);

	DEBUG_ARG("ifm = %lx", (long)ifm);

	/*

	 * First remove the mbuf from m_usedlist,

	 * since we're gonna use m_next and m_prev ourselves

	 * XXX Shouldn't need this, gotta change dtom() etc.

	 */

	if (ifm->m_flags & M_USEDLIST) {

		remque(ifm);

		ifm->m_flags &= ~M_USEDLIST;

	}

	/*

	 * See if there's already a batchq list for this session.  

	 * This can include an interactive session, which should go on fastq,

	 * but gets too greedy... hence it'll be downgraded from fastq to batchq.

	 * We mustn't put this packet back on the fastq (or we'll send it out of order)

	 * XXX add cache here?

	 */

	for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev) {

		if (so == ifq->ifq_so) {

			/* A match! */

			ifm->ifq_so = so;

			ifs_insque(ifm, ifq->ifs_prev);

			goto diddit;

		}

	}

	/* No match, check which queue to put it on */

	if (so && (so->so_iptos & IPTOS_LOWDELAY)) {

		ifq = if_fastq.ifq_prev;

		on_fastq = 1;

		/*

		 * Check if this packet is a part of the last

		 * packet's session

		 */

		if (ifq->ifq_so == so) {

			ifm->ifq_so = so;

			ifs_insque(ifm, ifq->ifs_prev);

			goto diddit;

		}

	} else

		ifq = if_batchq.ifq_prev;

	/* Create a new doubly linked list for this session */

	ifm->ifq_so = so;

	ifs_init(ifm);

	insque(ifm, ifq);

diddit:

	++if_queued;

	if (so) {

		/* Update *_queued */

		so->so_queued++;

		so->so_nqueued++;

		/*

		 * Check if the interactive session should be downgraded to

		 * the batchq.  A session is downgraded if it has queued 6

		 * packets without pausing, and at least 3 of those packets

		 * have been sent over the link

		 * (XXX These are arbitrary numbers, probably not optimal..)

		 */

		if (on_fastq && ((so->so_nqueued >= 6) && 

				 (so->so_nqueued - so->so_queued) >= 3)) {

			/* Remove from current queue... */

			remque(ifm->ifs_next);

			/* ...And insert in the new.  That'll teach ya! */

			insque(ifm->ifs_next, &if_batchq);

		}

	}

#ifndef FULL_BOLT

	/*

	 * This prevents us from malloc()ing too many mbufs

	 */

	if (link_up) {

		/* if_start will check towrite */

		if_start();

	}

#endif

}

/*

 * Send a packet

 * We choose a packet based on it's position in the output queues;

 * If there are packets on the fastq, they are sent FIFO, before

 * everything else.  Otherwise we choose the first packet from the

 * batchq and send it.  the next packet chosen will be from the session

 * after this one, then the session after that one, and so on..  So,

 * for example, if there are 3 ftp session's fighting for bandwidth,

 * one packet will be sent from the first session, then one packet

 * from the second session, then one packet from the third, then back

 * to the first, etc. etc.

 */

void

if_start(void)

{

	struct mbuf *ifm, *ifqt;

	DEBUG_CALL("if_start");

	if (if_queued == 0)

	   return; /* Nothing to do */

 again:

        /* check if we can really output */

        if (!slirp_can_output())

            return;

	/*

	 * See which queue to get next packet from

	 * If there's something in the fastq, select it immediately

	 */

	if (if_fastq.ifq_next != &if_fastq) {

		ifm = if_fastq.ifq_next;

	} else {

		/* Nothing on fastq, see if next_m is valid */

		if (next_m != &if_batchq)

		   ifm = next_m;

		else

		   ifm = if_batchq.ifq_next;

		/* Set which packet to send on next iteration */

		next_m = ifm->ifq_next;

	}

	/* Remove it from the queue */

	ifqt = ifm->ifq_prev;

	remque(ifm);

	--if_queued;

	/* If there are more packets for this session, re-queue them */

	if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm) {

		insque(ifm->ifs_next, ifqt);

		ifs_remque(ifm);

	}

	/* Update so_queued */

	if (ifm->ifq_so) {

		if (--ifm->ifq_so->so_queued == 0)

		   /* If there's no more queued, reset nqueued */

		   ifm->ifq_so->so_nqueued = 0;

	}

	/* Encapsulate the packet for sending */

        if_encap(ifm->m_data, ifm->m_len);

	if (if_queued)

	   goto again;

}

/*

 * Copyright (c) 1995 Danny Gasparovski.

 * 

 * Please read the file COPYRIGHT for the 

 * terms and conditions of the copyright.

 */

#ifndef _IF_H_

#define _IF_H_

#define IF_COMPRESS	0x01	/* We want compression */

#define IF_NOCOMPRESS	0x02	/* Do not do compression */

#define IF_AUTOCOMP	0x04	/* Autodetect (default) */

#define IF_NOCIDCOMP	0x08	/* CID compression */

/* Needed for FreeBSD */

#undef if_mtu

extern int	if_mtu;

extern int	if_mru;	/* MTU and MRU */

extern int	if_comp;	/* Flags for compression */

extern int	if_maxlinkhdr;

extern int	if_queued;	/* Number of packets queued so far */

extern int	if_thresh;	/* Number of packets queued before we start sending

				 * (to prevent allocing too many mbufs) */

extern	struct mbuf if_fastq;                  /* fast queue (for interactive data) */

extern	struct mbuf if_batchq;                 /* queue for non-interactive data */

extern	struct mbuf *next_m;

#define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))

/* Interface statistics */

struct slirp_ifstats {

	u_int out_pkts;		/* Output packets */

	u_int out_bytes;		/* Output bytes */

	u_int out_errpkts;	/* Output Error Packets */

	u_int out_errbytes;	/* Output Error Bytes */

	u_int in_pkts;		/* Input packets */

	u_int in_bytes;		/* Input bytes */

	u_int in_errpkts;		/* Input Error Packets */

	u_int in_errbytes;	/* Input Error Bytes */

	u_int bytes_saved;	/* Number of bytes that compression "saved" */

				/* ie: number of bytes that didn't need to be sent over the link

				 * because of compression */

	u_int in_mbad;		/* Bad incoming packets */

};

#endif

/*

 * Copyright (c) 1982, 1986, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *	This product includes software developed by the University of

 *	California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *	@(#)ip.h	8.1 (Berkeley) 6/10/93

 * ip.h,v 1.3 1994/08/21 05:27:30 paul Exp

 */

#ifndef _IP_H_

#define _IP_H_

#ifdef WORDS_BIGENDIAN

# ifndef NTOHL

#  define NTOHL(d)

# endif

# ifndef NTOHS

#  define NTOHS(d)

# endif

# ifndef HTONL

#  define HTONL(d)

# endif

# ifndef HTONS

#  define HTONS(d)

# endif

#else

# ifndef NTOHL

#  define NTOHL(d) ((d) = ntohl((d)))

# endif

# ifndef NTOHS

#  define NTOHS(d) ((d) = ntohs((u_int16_t)(d)))

# endif

# ifndef HTONL

#  define HTONL(d) ((d) = htonl((d)))

# endif

# ifndef HTONS

#  define HTONS(d) ((d) = htons((u_int16_t)(d)))

# endif

#endif

typedef u_int32_t n_long;                 /* long as received from the net */

/*

 * Definitions for internet protocol version 4.

 * Per RFC 791, September 1981.

 */

#define	IPVERSION	4

/*

 * Structure of an internet header, naked of options.

 *

 * We declare ip_len and ip_off to be short, rather than u_short

 * pragmatically since otherwise unsigned comparisons can result

 * against negative integers quite easily, and fail in subtle ways.

 */

struct ip {

#ifdef WORDS_BIGENDIAN

	u_int ip_v:4,			/* version */

		ip_hl:4;		/* header length */

#else

	u_int ip_hl:4,		/* header length */

		ip_v:4;			/* version */

#endif

	u_int8_t ip_tos;			/* type of service */

	int16_t	ip_len;			/* total length */

	u_int16_t	ip_id;			/* identification */

	int16_t	ip_off;			/* fragment offset field */