Archipelago » qemu

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

        return;

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

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

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

	lprint(" \r\n");

	   strcpy(buff, "on");

	   strcpy(buff, "off");

	else

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

#include <slirp.h>

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) */

void

if_init()

{

	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);

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

#define IF_NOCIDCOMP	0x08	/* CID compression */

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	ipq	ipq;			/* ip reass. queue */

extern u_int16_t	ip_id;				/* ip packet ctr, for ids */

#endif

char icmp_ping_msg[] = "This is a psuedo-PING packet used by Slirp to emulate ICMP ECHO-REQUEST packets.\n";

/* list of actions for icmp_error() on RX of an icmp message */

/*  ECHO REPLY (0)  */   0,

		         1,

		         1,

#include <slirp.h>

#include "ip_icmp.h"

#ifdef LOG_ENABLED

struct ipstat ipstat;

#endif

struct ipq ipq;

/*

 * IP initialization: fill in IP protocol switch table.

 * All protocols not implemented in kernel go to raw IP protocol handler.

	ip_id = tt.tv_sec & 0xffff;

	udp_init();

	tcp_init();

}

/*

 * reassembly of this datagram already exists, then it

 * is given as fp; otherwise have to make a chain.

 */

{

	register struct mbuf *m = dtom(ip);

	register struct ipasfrag *q;

 * Free a fragment reassembly header and all

 * associated datagrams.

 */

{

	register struct ipasfrag *q, *p;

 * Put an ip fragment on a reassembly chain.

 * Like insque, but pointers in middle of structure.

 */

{

	DEBUG_CALL("ip_enq");

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

/*

 * To ip_enq as remque is to insque.

 */

{

	((struct ipasfrag *)(p->ipf_prev))->ipf_next = p->ipf_next;

	((struct ipasfrag *)(p->ipf_next))->ipf_prev = p->ipf_prev;

	/*

	 * If small enough for interface, can just send directly.

	 */

		ip->ip_len = htons((u_int16_t)ip->ip_len);

		ip->ip_off = htons((u_int16_t)ip->ip_off);

		ip->ip_sum = 0;

		goto bad;

	}

	if (len < 8) {

		error = -1;

		goto bad;

	    STAT(ipstat.ips_odropped++);

	    goto sendorfree;

	  }

	  mhip = mtod(m, struct ip *);

	  *mhip = *ip;

extern char *socket_path;

extern int towrite_max;

extern int ppp_exit;

extern int tcp_keepintvl;

extern uint8_t client_ethaddr[6];

char	*mclrefcnt;

int mbuf_alloced = 0;

struct mbuf m_freelist, m_usedlist;

int mbuf_max = 0;

void

m_init()

{

	m_freelist.m_next = m_freelist.m_prev = &m_freelist;

	m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;

}

/*

	DEBUG_CALL("m_get");

	if (m_freelist.m_next == &m_freelist) {

		if (m == NULL) goto end_error;

		mbuf_alloced++;

			flags = M_DOFREE;

		if (mbuf_alloced > mbuf_max)

			mbuf_max = mbuf_alloced;

	m->m_flags = (flags | M_USEDLIST);

	/* Initialise it */

	m->m_data = m->m_dat;

	m->m_len = 0;

	m->m_nextpkt = 0;

extern int mbuf_max;

void m_init _P((void));

struct mbuf * m_get _P((void));

void m_free _P((struct mbuf *));

void m_cat _P((register struct mbuf *, register struct mbuf *));

#define WANT_SYS_IOCTL_H

#include <slirp.h>

#if 0

int x_port = -1;

#ifdef _WIN32

int

{

    /* not implemented */

    return 0;

#else

int

slirp_openpty(amaster, aslave)

     int *amaster, *aslave;

	return (-1);

#endif

}

/*

 * XXX This is ugly

 * do_ptr = 2   Fork/exec using pty

 */

int

{

	int s;

	struct sockaddr_in addr;

	int addrlen = sizeof(addr);

	int opt;

	char *argv[256];

#if 0

	char buff[256];

#endif

	/* don't want to clobber the original */

	char *bptr;

	int c, i, ret;

	DEBUG_CALL("fork_exec");

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

	if (do_pty == 2) {

		if (slirp_openpty(&master, &s) == -1) {

			lprint("Error: openpty failed: %s\n", strerror(errno));

			return 0;

		}

	} else {

		addr.sin_family = AF_INET;

		addr.sin_port = 0;

		dup2(s, 0);

		dup2(s, 1);

		dup2(s, 2);

		   close(s);

		i = 0;

	int ex_pty;			/* Do we want a pty? */

	int ex_addr;			/* The last byte of the address */

	int ex_fport;                   /* Port to telnet to */

	struct ex_list *ex_next;

};

extern struct ex_list *exec_list;

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

extern char *lprint_ptr, *lprint_ptr2, **lprint_arg;

inline  void slirp_remque  _P((void *));

int add_exec _P((struct ex_list **, int, char *, int, int));

int slirp_openpty _P((int *, int *));

void snooze_hup _P((int));

void snooze _P((void));

void relay _P((int));

#include <slirp.h>

/* Done as a macro in socket.h */

/* int

 * sbspace(struct sockbuff *sb)

 * Copy the data from m into sb

 * The caller is responsible to make sure there's enough room

 */

{

	int len, n,  nn;

void sbdrop _P((struct sbuf *, int));

void sbreserve _P((struct sbuf *, int));

void sbappend _P((struct socket *, struct mbuf *));

void sbcopy _P((struct sbuf *, int, int, char *));

#endif

/* virtual address alias for host */

struct in_addr alias_addr;

    0x52, 0x54, 0x00, 0x12, 0x35, 0x00

};

#endif

#ifdef _WIN32

{

    WSACleanup();

}

#define DEFAULT_BAUD 115200

/* cksum.c */

int cksum(struct mbuf *m, int len);

/* ip_input.c */

void ip_init _P((void));

void ip_input _P((struct mbuf *));

void ip_slowtimo _P((void));

void ip_stripoptions _P((register struct mbuf *, struct mbuf *));

int ip_output _P((struct socket *, struct mbuf *));

/* tcp_input.c */

void tcp_input _P((register struct mbuf *, int, struct socket *));

int tcp_mss _P((register struct tcpcb *, u_int));

/* tcp_output.c */

void tcp_respond _P((struct tcpcb *, register struct tcpiphdr *, register struct mbuf *, tcp_seq, tcp_seq, int));

struct tcpcb * tcp_newtcpcb _P((struct socket *));

struct tcpcb * tcp_close _P((register struct tcpcb *));

void tcp_sockclosed _P((struct tcpcb *));

int tcp_fconnect _P((struct socket *));

void tcp_connect _P((struct socket *));

#include <sys/filio.h>

#endif

so_init()

{

	/* Nothing yet */

}

struct socket *

solookup(head, laddr, lport, faddr, fport)

	  int len, n;

	  if (!(m = m_get())) return;

	  /*

	   * XXX Shouldn't FIONREAD packets destined for port 53,

	return so;

}

/*

 * Data is available in so_rcv

 * Just write() the data to the socket

 * XXX not yet...

 */

sorwakeup(so)

	struct socket *so;

{

 * We have room for a read() if we want to

 * For now, don't read, it'll be done in the main loop

 */

sowwakeup(so)

	struct socket *so;

{

	/* Nothing, yet */

}

/*

 * Various session state calls

	so->so_state |= SS_ISFCONNECTED; /* Clobber other states */

}

{

	if ((so->so_state & SS_NOFDREF) == 0) {

		shutdown(so->s,0);

	   so->so_state |= SS_FCANTRCVMORE;

}

{

	if ((so->so_state & SS_NOFDREF) == 0) {

            shutdown(so->s,1);           /* send FIN to fhost */

};

#endif

struct socket * solookup _P((struct socket *, struct in_addr, u_int, struct in_addr, u_int));

struct socket * socreate _P((void));

void sofree _P((struct socket *));

void sorecvfrom _P((struct socket *));

int sosendto _P((struct socket *, struct mbuf *));

struct socket * solisten _P((u_int, u_int32_t, u_int, int));

void soisfconnecting _P((register struct socket *));

void soisfconnected _P((register struct socket *));

void soisfdisconnected _P((struct socket *));

void sofwdrain _P((struct socket *));

#define      PR_SLOWHZ       2               /* 2 slow timeouts per second (approx) */

#define      PR_FASTHZ       5               /* 5 fast timeouts per second (not important) */

extern struct socket *tcp_last_so;

#define TCP_SNDSPACE 8192

extern tcp_seq tcp_iss;                /* tcp initial send seq # */

#endif

struct socket tcb;

struct	socket *tcp_last_so = &tcb;

tcp_seq tcp_iss;                /* tcp initial send seq # */

	} \

}

#endif

{

	register struct tcpiphdr *q;

	struct socket *so = tp->t_socket;

	    goto dropwithreset;

	  }

	  /*		tcp_last_so = so; */  /* XXX ? */

	  /*		tp = sototcpcb(so);    */

	 * Reset idle time and keep-alive timer.

	 */

	tp->t_idle = 0;

	else

	/*

	 * Process options if not in LISTEN state,

				if (tp->t_timer[TCPT_REXMT] == 0 ||

				    ti->ti_ack != tp->snd_una)

					tp->t_dupacks = 0;

					tcp_seq onxt = tp->snd_nxt;

					u_int win =

					    min(tp->snd_wnd, tp->snd_cwnd) / 2 /

					if (SEQ_GT(onxt, tp->snd_nxt))

						tp->snd_nxt = onxt;

					goto drop;

					tp->snd_cwnd += tp->t_maxseg;

					(void) tcp_output(tp);

					goto drop;

		 * If the congestion window was inflated to account

		 * for the other side's cached packets, retract it.

		 */

		    tp->snd_cwnd > tp->snd_ssthresh)

			tp->snd_cwnd = tp->snd_ssthresh;

		tp->t_dupacks = 0;

				 */

				if (so->so_state & SS_FCANTRCVMORE) {

					soisfdisconnected(so);

				}

				tp->t_state = TCPS_FIN_WAIT_2;

			}

/*	int *ts_present;

 *	u_int32_t *ts_val, *ts_ecr;

 */

{

	u_int16_t mss;

	int opt, optlen;

 * and update averages and current timeout.

 */

{

	register short delta;

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

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

	if (offer)

		mss = min(mss, offer);

	mss = max(mss, 32);

	tp->snd_cwnd = mss;

	DEBUG_MISC((dfd, " returning mss = %d\n", mss));

 * Since this is only used in "stats socket", we give meaning

 * names instead of the REAL names

 */

/*	"CLOSED",       "LISTEN",       "SYN_SENT",     "SYN_RCVD", */

	"REDIRECT",	"LISTEN",	"SYN_SENT",     "SYN_RCVD",

	"ESTABLISHED",  "CLOSE_WAIT",   "FIN_WAIT_1",   "CLOSING",

	"LAST_ACK",     "FIN_WAIT_2",   "TIME_WAIT",

};

	TH_RST|TH_ACK, 0,      TH_SYN,        TH_SYN|TH_ACK,

	TH_ACK,        TH_ACK, TH_FIN|TH_ACK, TH_FIN|TH_ACK,

	TH_FIN|TH_ACK, TH_ACK, TH_ACK,

			error = 1;

			goto out;

		}

		m->m_len = hdrlen;

		/*

			error = 1;

			goto out;

		}

		m->m_len = hdrlen;

	}

	((struct ip *)ti)->ip_len = m->m_len;

	((struct ip *)ti)->ip_tos = so->so_iptos;

/* #if BSD >= 43 */

#include <slirp.h>

/* patchable/settable parameters for tcp */

/*

 * Tcp initialization

{

	tcp_iss = 1;		/* wrong */

	tcb.so_next = tcb.so_prev = &tcb;

}

/*

#else

		tlen = 0;

#endif

		*mtod(m, struct tcpiphdr *) = *ti;

		ti = mtod(m, struct tcpiphdr *);

		flags = TH_ACK;

	if(flags & TH_RST)

	  ((struct ip *)ti)->ip_ttl = MAXTTL;

	else

	(void) ip_output((struct socket *)0, m);

}

	memset((char *) tp, 0, sizeof(struct tcpcb));

	tp->seg_next = tp->seg_prev = (tcpiphdrp_32)tp;

	tp->t_socket = so;

	/*

	 * reasonable initial retransmit time.

	 */

	tp->t_srtt = TCPTV_SRTTBASE;

	tp->t_rttmin = TCPTV_MIN;

	TCPT_RANGESET(tp->t_rxtcur,

	return ((struct tcpcb *)0);

}

void

tcp_drain()

{

 * When a source quench is received, close congestion window

 * to one segment.  We will gradually open it again as we proceed.

 */

void

tcp_quench(i, errno)

/*

 * Set the socket's type of service field

 */

	  {0, 20, IPTOS_THROUGHPUT, 0},	/* ftp data */

	  {21, 21, IPTOS_LOWDELAY,  EMU_FTP},	/* ftp control */

	  {0, 23, IPTOS_LOWDELAY, 0},	/* telnet */

	  {0, 0, 0, 0}

};

/*

 * Return TOS according to the above table

			so_rcv->sb_rptr += m->m_len;

			m->m_data[m->m_len] = 0; /* NULL terminate */

			if (strchr(m->m_data, '\r') || strchr(m->m_data, '\n')) {

					HTONS(n1);

					HTONS(n2);

					/* n2 is the one on our host */

			/*

			 * Need to emulate the PORT command

			 */

				   &n1, &n2, &n3, &n4, &n5, &n6, buff);

			if (x < 6)

			   return 1;

			/*

			 * Need to emulate the PASV response

			 */

				   &n1, &n2, &n3, &n4, &n5, &n6, buff);

			if (x < 6)

			   return 1;

#include <slirp.h>

#ifdef LOG_ENABLED

struct   tcpstat tcpstat;        /* tcp statistics */

#endif

u_int32_t        tcp_now;                /* for RFC 1323 timestamps */

/*

 * Fast timeout routine for processing delayed acks

 */

	DEBUG_CALL("tcp_slowtimo");

	/*

	 * Search through tcb's and update active timers.

	 */

		tp->t_timer[i] = 0;

}

   { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };

/*

 * TCP timer processing.

 */

{

	register int rexmt;

	 */

	case TCPT_2MSL:

		if (tp->t_state != TCPS_TIME_WAIT &&

		else

			tp = tcp_close(tp);

		break;

			goto dropit;

/*		if (tp->t_socket->so_options & SO_KEEPALIVE && */

				goto dropit;

			/*

			 * Send a packet designed to force a response

			tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,

			    tp->rcv_nxt, tp->snd_una - 1, 0);

#endif

		} else

		break;

	dropit:

		(tv) = (tvmax); \

}

struct tcpcb;

void tcp_fasttimo _P((void));

void tcp_slowtimo _P((void));

void tcp_canceltimers _P((struct tcpcb *));

#endif

    int timestamp;

};

const char *tftp_prefix;

    memset(m->m_data, 0, m->m_size);

    tp = (void *)m->m_data;

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

  memset(m->m_data, 0, m->m_size);

  tp = (void *)m->m_data;

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

  memset(m->m_data, 0, m->m_size);

  tp = (void *)m->m_data;

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

struct socket udb;

/*

 * UDP protocol implementation.

 * Per RFC 768, August, 1980.

 */

#ifndef	COMPAT_42

#else

#endif

struct	socket *udp_last_so = &udb;

	/*

	 * Checksum extended UDP header and data.

	 */

	  ((struct ipovly *)ip)->ih_next = 0;

	  ((struct ipovly *)ip)->ih_prev = 0;

	  ((struct ipovly *)ip)->ih_x1 = 0;

	 * Stuff checksum and output datagram.

	 */

	ui->ui_sum = 0;

	    if ((ui->ui_sum = cksum(m, /* sizeof (struct udpiphdr) + */ m->m_len)) == 0)

		ui->ui_sum = 0xffff;

	}

	((struct ip *)ui)->ip_len = m->m_len;

	((struct ip *)ui)->ip_tos = iptos;

	STAT(udpstat.udps_opackets++);

	sofree(so);

}

	{0, 53, IPTOS_LOWDELAY, 0},			/* DNS */

	{517, 517, IPTOS_LOWDELAY, EMU_TALK},	/* talk */

	{518, 518, IPTOS_LOWDELAY, EMU_NTALK},	/* ntalk */

	{0, 0, 0, 0}

};

{

	int i = 0;

/*

 * Here, talk/ytalk/ntalk requests must be emulated

 */

{

	struct sockaddr_in addr;

        int addrlen = sizeof(addr);

int udp_output _P((struct socket *, struct mbuf *, struct sockaddr_in *));

int udp_attach _P((struct socket *));

void udp_detach _P((struct socket *));

struct socket * udp_listen _P((u_int, u_int32_t, u_int, int));

int udp_output2(struct socket *so, struct mbuf *m,

                struct sockaddr_in *saddr, struct sockaddr_in *daddr,