Archipelago » qemu

int cksum(struct mbuf *m, int len)

{

	register int sum = 0;

	register int mlen = 0;

	int byte_swapped = 0;

	union {

	} s_util;

	union {

	} l_util;

	if (m->m_len == 0)

	   goto cont;

	mlen = m->m_len;

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

		REDUCE;

		sum <<= 8;

		mlen--;

		byte_swapped = 1;

	}

		REDUCE;

		sum <<= 8;

		if (mlen == -1) {

			sum += s_util.s;

			mlen = 0;

		} else

		   mlen = -1;

	} else if (mlen == -1)

cont:

#ifdef DEBUG

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

# endif

# ifndef NTOHS

# endif

# ifndef HTONL

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

# endif

# ifndef HTONS

# endif

#endif

/*

 * Definitions for internet protocol version 4.

	u_int ip_hl:4,		/* header length */

		ip_v:4;			/* version */

#endif

#define	IP_DF 0x4000			/* don't fragment flag */

#define	IP_MF 0x2000			/* more fragments flag */

#define	IP_OFFMASK 0x1fff		/* mask for fragmenting bits */

	struct	in_addr ip_src,ip_dst;	/* source and dest address */

} __attribute__((packed));

 * Time stamp option structure.

 */

struct	ip_timestamp {

#ifdef HOST_WORDS_BIGENDIAN

	u_int	ipt_oflw:4,		/* overflow counter */

		ipt_flg:4;		/* flags, see below */

 */

struct ipovly {

	struct mbuf_ptr ih_mbuf;	/* backpointer to mbuf */

	struct	in_addr ih_src;		/* source internet address */

	struct	in_addr ih_dst;		/* destination internet address */

} __attribute__((packed));

struct ipq {

        struct qlink frag_link;			/* to ip headers of fragments */

	struct qlink ip_link;				/* to other reass headers */

	struct	in_addr ipq_src,ipq_dst;

} __attribute__((packed));

#define ipf_tos      ipf_ip.ip_tos

#define ipf_len      ipf_ip.ip_len

#define ipf_next     ipf_link.next

/*

 * Structure stored in mbuf in inpcb.ip_options

 * Per RFC 792, September 1981.

 */

/*

 * Structure of an icmp header.

	register struct in_ifaddr *ia;

	int opt, optlen, cnt, off, code, type, forward = 0;

	struct in_addr *sin, dst;

	n_time ntime;

	dst = ip->ip_dst;

	/*

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

	 */

		ip->ip_sum = 0;

		ip->ip_sum = cksum(m, hlen);

	 */

	m0 = m;

	mhlen = sizeof (struct ip);

	  register struct ip *mhip;

	  m = m_get(slirp);

          if (m == NULL) {

	  mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);

	  if (ip->ip_off & IP_MF)

	    mhip->ip_off |= IP_MF;

	  else

	    mhip->ip_off |= IP_MF;

	  if (m_copy(m, m0, off, len) < 0) {

	    error = -1;

	    goto sendorfree;

	  }

	  mhip->ip_sum = 0;

	  mhip->ip_sum = cksum(m, mhlen);

	  *mnext = m;

	 * and updating header, then send each fragment (in order).

	 */

	m = m0;

	ip->ip_sum = 0;

	ip->ip_sum = cksum(m, hlen);

sendorfree:

extern int slirp_socket;

extern int slirp_socket_unit;

extern int slirp_socket_port;

extern char *slirp_socket_passwd;

extern int ctty_closed;

#define EMU_NOCONNECT 0x10	/* Don't connect */

struct tos_t {

};

struct emu_t {

};

extern int x_port, x_server, x_display;

int show_x(char *, struct socket *);

void slirp_insque(void *, void *);

void slirp_remque(void *);

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

    /* ip states */

    struct ipq ipq;         /* ip reass. queue */

    /* bootp/dhcp states */

    BOOTPClient bootp_clients[NB_BOOTP_CLIENTS];

    struct socket tcb;

    struct socket *tcp_last_so;

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

    /* udp states */

    struct socket udb;

int tcp_fconnect(struct socket *);

void tcp_connect(struct socket *);

int tcp_attach(struct socket *);

int tcp_emu(struct socket *, struct mbuf *);

int tcp_ctl(struct socket *);

struct tcpcb *tcp_drop(struct tcpcb *tp, int err);

/* Define if your compiler doesn't like prototypes */

#undef NO_PROTOTYPES

/* Define to sizeof(char) */

#define SIZEOF_CHAR 1

 * Listen for incoming TCP connections

 */

struct socket *

           u_int lport, int flags)

{

	struct sockaddr_in addr;

  int so_urgc;

  struct in_addr so_faddr;	   /* foreign host table entry */

  struct in_addr so_laddr;	   /* local host table entry */

  u_char	so_type;		/* Type of socket, UDP or TCP */

  int	so_state;		/* internal state flags SS_*, below */

int sowrite(struct socket *);

void sorecvfrom(struct socket *);

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

                               int);

void soisfconnecting(register struct socket *);

void soisfconnected(register struct socket *);

#ifndef _TCP_H_

#define _TCP_H_

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

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

 * Per RFC 793, September, 1981.

 */

struct tcphdr {

	tcp_seq	th_seq;			/* sequence number */

	tcp_seq	th_ack;			/* acknowledgement number */

#ifdef HOST_WORDS_BIGENDIAN

	u_int	th_x2:4,		/* (unused) */

		th_off:4;		/* data offset */

#endif

#define	TH_FIN	0x01

#define	TH_SYN	0x02

#define	TH_RST	0x04

#define	TH_PUSH	0x08

#define	TH_ACK	0x10

#define	TH_URG	0x20

};

#include "tcp_var.h"

        tcpiphdr2qlink(ti)->next = tcpiphdr2qlink(ti)->prev = NULL;

        memset(&ti->ti_i.ih_mbuf, 0 , sizeof(struct mbuf_ptr));

	ti->ti_x1 = 0;

	len = sizeof(struct ip ) + tlen;

	if(cksum(m, len)) {

	  goto drop;

static void

tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt, struct tcpiphdr *ti)

{

	int opt, optlen;

	DEBUG_CALL("tcp_dooptions");

	if (flags & TH_SYN) {

		tp->snd_nxt = tp->iss;

		if ((tp->t_flags & TF_NOOPT) == 0) {

			opt[0] = TCPOPT_MAXSEG;

			opt[1] = 4;

			memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));

			optlen = 4;

		}

		win = (long)TCP_MAXWIN << tp->rcv_scale;

	if (win < (long)(tp->rcv_adv - tp->rcv_nxt))

		win = (long)(tp->rcv_adv - tp->rcv_nxt);

	if (SEQ_GT(tp->snd_up, tp->snd_una)) {

		ti->ti_flags |= TH_URG;

	} else

		/*

	 * checksum extended header and data.

	 */

	if (len + optlen)

		    optlen + len));

	ti->ti_sum = cksum(m, (int)(hdrlen + len));

		m->m_len = sizeof (struct tcpiphdr);

		tlen = 0;

#define xchg(a,b,type) { type t; t=a; a=b; b=t; }

#undef xchg

	}

	ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));

	ti->ti_off = sizeof (struct tcphdr) >> 2;

	ti->ti_flags = flags;

	if (tp)

	else

	ti->ti_urp = 0;

	ti->ti_sum = 0;

	ti->ti_sum = cksum(m, tlen);

/*

 * Return TOS according to the above table

 */

tcp_tos(struct socket *so)

{

	int i = 0;

	Slirp *slirp = so->slirp;

	u_int n1, n2, n3, n4, n5, n6;

        char buff[257];

	u_int lport;

	char *bptr;

	tcp_seq	snd_wl1;		/* window update seg seq number */

	tcp_seq	snd_wl2;		/* window update seg ack number */

	tcp_seq	iss;			/* initial send sequence number */

/* receive sequence variables */

	tcp_seq	rcv_nxt;		/* receive next */

	tcp_seq	rcv_up;			/* receive urgent pointer */

	tcp_seq	irs;			/* initial receive sequence number */

					 * used to recognize retransmits

					 */

/* congestion control (for slow start, source quench, retransmit after loss) */

					 * for slow start exponential to

					 * linear switch

					 */

	short	t_srtt;			/* smoothed round-trip time */

	short	t_rttvar;		/* variance in round-trip time */

	u_short	t_rttmin;		/* minimum rtt allowed */

/* out-of-band data */

	char	t_oobflags;		/* have some */

	u_char	rcv_scale;		/* window scaling for recv window */

	u_char	request_r_scale;	/* pending window scaling */

	u_char	requested_s_scale;

	tcp_seq	last_ack_sent;

};

  return -1;

}

{

  int fd;

  int bytes_read = 0;

}

static void tftp_send_error(struct tftp_session *spt,

                            struct tftp_t *recv_tp)

{

  struct sockaddr_in saddr, daddr;

}

static int tftp_send_data(struct tftp_session *spt,

			  struct tftp_t *recv_tp)

{

  struct sockaddr_in saddr, daddr;

struct tftp_t {

  struct ip ip;

  struct udphdr udp;

  union {

    struct {

    } tp_data;

    struct {

    } tp_error;

  } x;

};

    char *filename;

    struct in_addr client_ip;

    int timestamp;

};

#include <slirp.h>

#include "ip_icmp.h"

void

udp_init(Slirp *slirp)

	 * Make mbuf data length reflect UDP length.

	 * If not enough data to reflect UDP length, drop.

	 */

	if (ip->ip_len != len) {

		if (len > ip->ip_len) {

	{0, 0, 0, 0}

};

udp_tos(struct socket *so)

{

	int i = 0;

}

struct socket *

           u_int lport, int flags)

{

	struct sockaddr_in addr;

 * Per RFC 768, September, 1981.

 */

struct udphdr {

};

/*

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

int udp_attach(struct socket *);

void udp_detach(struct socket *);

                           int);

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

                struct sockaddr_in *saddr, struct sockaddr_in *daddr,