BasiliskII/src/slirp/* copied from jvernet/macemu

BasiliskII/src/slirp/VERSION

@@ -1 +1,2 @@
 qemu 0.9.0 (2007/02/05)
+Plus 64 Bits Patchs

BasiliskII/src/slirp/bootp.h

@@ -115,7 +115,7 @@ struct bootp_t {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 void bootp_input(struct mbuf *m);

BasiliskII/src/slirp/debug.c

@@ -16,6 +16,8 @@ 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;
@@ -292,7 +294,6 @@ mbufstats()
 void
 sockstats()
 {
-	char addr[INET_ADDRSTRLEN];
 	char buff[256];
 	int n;
 	struct socket *so;
@@ -310,11 +311,9 @@ sockstats()
 		buff[17] = 0;
 		lprint("%s %3d   %15s %5d ",
 				buff, so->s,
-				inet_ntop(AF_INET, &so->so_laddr, addr, sizeof(addr)),
-				ntohs(so->so_lport));
+				inet_ntoa(so->so_laddr), ntohs(so->so_lport));
 		lprint("%15s %5d %5d %5d\r\n",
-				inet_ntop(AF_INET, &so->so_faddr, addr, sizeof(addr)),
-				ntohs(so->so_fport),
+				inet_ntoa(so->so_faddr), ntohs(so->so_fport),
 				so->so_rcv.sb_cc, so->so_snd.sb_cc);
 	}
 		   
@@ -326,11 +325,9 @@ sockstats()
 		buff[17] = 0;
 		lprint("%s %3d  %15s %5d  ",
 				buff, so->s,
-				inet_ntop(AF_INET, &so->so_laddr, addr, sizeof(addr)),
-				ntohs(so->so_lport));
+				inet_ntoa(so->so_laddr), ntohs(so->so_lport));
 		lprint("%15s %5d %5d %5d\r\n",
-				inet_ntop(AF_INET, &so->so_faddr, addr, sizeof(addr)),
-				ntohs(so->so_fport),
+				inet_ntoa(so->so_faddr), ntohs(so->so_fport),
 				so->so_rcv.sb_cc, so->so_snd.sb_cc);
 	}
 }

BasiliskII/src/slirp/debug.h

@@ -36,15 +36,15 @@ extern int slirp_debug;
 
 #endif
 
-void debug_init(char *, int);
-//void ttystats(struct ttys *);
-void allttystats(void);
-void ipstats(void);
-void vjstats(void);
-void tcpstats(void);
-void udpstats(void);
-void icmpstats(void);
-void mbufstats(void);
-void sockstats(void);
-void slirp_exit(int);
+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));
 

BasiliskII/src/slirp/if.c

@@ -7,11 +7,11 @@
 
 #include <slirp.h>
 
-size_t if_mtu, if_mru;
+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
+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) */
@@ -116,8 +116,7 @@ if_input(ttyp)
 	DEBUG_MISC((dfd, " read %d bytes\n", if_n));
 	
 	if (if_n <= 0) {
-		int error = WSAGetLastError();
-		if (if_n == 0 || (error != WSAEINTR && error != EAGAIN)) {
+		if (if_n == 0 || (errno != EINTR && errno != EAGAIN)) {
 			if (ttyp->up)
 			   link_up--;
 			tty_detached(ttyp, 0);

BasiliskII/src/slirp/if.h

@@ -15,8 +15,8 @@
 
 /* Needed for FreeBSD */
 #undef if_mtu
-extern size_t	if_mtu;
-extern size_t	if_mru;	/* MTU and MRU */
+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 */

BasiliskII/src/slirp/ip.h

@@ -98,7 +98,7 @@ struct ip {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 #define	IP_MAXPACKET	65535		/* maximum packet size */
@@ -168,7 +168,7 @@ struct	ip_timestamp {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 /* flag bits for ipt_flg */
@@ -195,23 +195,19 @@ struct	ip_timestamp {
 
 #define	IP_MSS		576		/* default maximum segment size */
 
-#ifdef HAVE_SYS_TYPES32_H  /* Overcome some Solaris 2.x junk */
-#include <sys/types32.h>
-#else
 #if SIZEOF_CHAR_P == 4
-typedef caddr_t caddr32_t;
+ struct mbuf_ptr {
+ 	struct mbuf *mptr;
+ 	uint32_t dummy;
+ };
 #else
-typedef u_int32_t caddr32_t;
-#endif
-#endif
-
-#if SIZEOF_CHAR_P == 4
-typedef struct ipq *ipqp_32;
-typedef struct ipasfrag *ipasfragp_32;
-#else
-typedef caddr32_t ipqp_32;
-typedef caddr32_t ipasfragp_32;
+ struct mbuf_ptr {
+ 	struct mbuf *mptr;
+ };
 #endif
+struct qlink {
+ 	void *next, *prev;
+};
 
 /*
  * Overlay for ip header used by other protocols (tcp, udp).
@@ -221,16 +217,16 @@ typedef caddr32_t ipasfragp_32;
 #endif
 
 struct ipovly {
-	caddr32_t	ih_next, ih_prev;	/* for protocol sequence q's */
+	struct mbuf_ptr ih_mbuf;	/* backpointer to mbuf */
 	u_int8_t	ih_x1;			/* (unused) */
 	u_int8_t	ih_pr;			/* protocol */
 	u_int16_t	ih_len;			/* protocol length */
 	struct	in_addr ih_src;		/* source internet address */
 	struct	in_addr ih_dst;		/* destination internet address */
-} PACKED__;
+}  __attribute__((packed));
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 /*
@@ -241,12 +237,13 @@ struct ipovly {
  * size 28 bytes
  */
 struct ipq {
-	ipqp_32 next,prev;	/* to other reass headers */
+	struct qlink frag_link;			/* to ip headers of fragments */
+	struct qlink ip_link;				/* to other reass headers */
+
 	u_int8_t	ipq_ttl;		/* time for reass q to live */
 	u_int8_t	ipq_p;			/* protocol of this fragment */
 	u_int16_t	ipq_id;			/* sequence id for reassembly */
-	ipasfragp_32 ipq_next,ipq_prev;
-					/* to ip headers of fragments */
+
 	struct	in_addr ipq_src,ipq_dst;
 };
 
@@ -256,29 +253,16 @@ struct ipq {
  * Note: ipf_next must be at same offset as ipq_next above
  */
 struct	ipasfrag {
-#ifdef WORDS_BIGENDIAN
-	u_char	ip_v:4,
- 		ip_hl:4;
-#else
-	u_char	ip_hl:4,
-		ip_v:4;
-#endif
-                                        /* BUG : u_int changed to u_int8_t.
-                                         * sizeof(u_int)==4 on linux 2.0
-					 */
-        u_int8_t ipf_mff;		/* XXX overlays ip_tos: use low bit
-					 * to avoid destroying tos (PPPDTRuu);
-					 * copied from (ip_off&IP_MF) */
-	u_int16_t	ip_len;
-	u_int16_t	ip_id;
-	u_int16_t	ip_off;
-	u_int8_t	ip_ttl;
-	u_int8_t	ip_p;
-	u_int16_t	ip_sum;
-	ipasfragp_32 ipf_next;		/* next fragment */
-	ipasfragp_32 ipf_prev;		/* previous fragment */
+	struct qlink ipf_link;
+ 	struct ip ipf_ip;
 };
 
+#define ipf_off      ipf_ip.ip_off
+#define ipf_tos      ipf_ip.ip_tos
+#define ipf_len      ipf_ip.ip_len
+#define ipf_next     ipf_link.next
+#define ipf_prev     ipf_link.prev 
+
 /*
  * Structure stored in mbuf in inpcb.ip_options
  * and passed to ip_output when ip options are in use.

BasiliskII/src/slirp/ip_icmp.c

@@ -77,7 +77,7 @@ icmp_input(m, hlen)
 	
   DEBUG_CALL("icmp_input");
   DEBUG_ARG("m = %lx", (long )m);
-  DEBUG_ARG("m_len = %zu", m->m_len);
+  DEBUG_ARG("m_len = %d", m->m_len);
 
   icmpstat.icps_received++;
 	
@@ -201,12 +201,12 @@ end_error:
 
 #define ICMP_MAXDATALEN (IP_MSS-28)
 void
-icmp_error(
-     struct mbuf *msrc,
-     u_char type,
-     u_char code,
-     int minsize,
-     char *message)
+icmp_error(msrc, type, code, minsize, message)
+     struct mbuf *msrc;
+     u_char type;
+     u_char code;
+     int minsize;
+     char *message;
 {
   unsigned hlen, shlen, s_ip_len;
   register struct ip *ip;
@@ -215,7 +215,7 @@ icmp_error(
 
   DEBUG_CALL("icmp_error");
   DEBUG_ARG("msrc = %lx", (long )msrc);
-  DEBUG_ARG("msrc_len = %zu", msrc->m_len);
+  DEBUG_ARG("msrc_len = %d", msrc->m_len);
 
   if(type!=ICMP_UNREACH && type!=ICMP_TIMXCEED) goto end_error;
 
@@ -223,9 +223,9 @@ icmp_error(
   if(!msrc) goto end_error;
   ip = mtod(msrc, struct ip *);
 #if DEBUG  
-  { char bufa[INET_ADDRSTRLEN], bufb[INET_ADDRSTRLEN];
-    inet_ntop(AF_INET, &ip->ip_src, bufa, sizeof(bufa));
-	inet_ntop(AF_INET, &ip->ip_dst, bufb, sizeof(bufb));
+  { char bufa[20], bufb[20];
+    strcpy(bufa, inet_ntoa(ip->ip_src));
+    strcpy(bufb, inet_ntoa(ip->ip_dst));
     DEBUG_MISC((dfd, " %.16s to %.16s\n", bufa, bufb));
   }
 #endif
@@ -244,7 +244,7 @@ icmp_error(
 
   /* make a copy */
   if(!(m=m_get())) goto end_error;               /* get mbuf */
-  { u_int new_m_size;
+  { int new_m_size;
     new_m_size=sizeof(struct ip )+ICMP_MINLEN+msrc->m_len+ICMP_MAXDATALEN;
     if(new_m_size>m->m_size) m_inc(m, new_m_size);
   }
@@ -299,7 +299,7 @@ icmp_error(
 
   /* fill in ip */
   ip->ip_hl = hlen >> 2;
-  ip->ip_len = (u_int16_t)m->m_len;
+  ip->ip_len = m->m_len;
   
   ip->ip_tos=((ip->ip_tos & 0x1E) | 0xC0);  /* high priority for errors */
 

BasiliskII/src/slirp/ip_icmp.h

@@ -95,7 +95,7 @@ struct icmp {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 /*
@@ -161,8 +161,8 @@ struct icmp {
 	(type) == ICMP_IREQ || (type) == ICMP_IREQREPLY || \
 	(type) == ICMP_MASKREQ || (type) == ICMP_MASKREPLY)
 
-void icmp_input(struct mbuf *, int);
-void icmp_error(struct mbuf *, u_char, u_char, int, char *);
-void icmp_reflect(struct mbuf *);
+void icmp_input _P((struct mbuf *, int));
+void icmp_error _P((struct mbuf *, u_char, u_char, int, char *));
+void icmp_reflect _P((struct mbuf *));
 
 #endif

BasiliskII/src/slirp/ip_input.c

@@ -38,6 +38,16 @@
  * terms and conditions of the copyright.
  */
 
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#define container_of(ptr, type, member) ({                      \
+        const typeof(((type *) 0)->member) *__mptr = (ptr);     \
+        (type *) ((char *) __mptr - offsetof(type, member));})
+
+
 #include <slirp.h>
 #include "ip_icmp.h"
 
@@ -52,7 +62,7 @@ struct ipq ipq;
 void
 ip_init()
 {
-	ipq.next = ipq.prev = (ipqp_32)&ipq;
+	ipq.ip_link.next = ipq.ip_link.prev = &ipq.ip_link;
 	ip_id = tt.tv_sec & 0xffff;
 	udp_init();
 	tcp_init();
@@ -68,11 +78,11 @@ ip_input(m)
 	struct mbuf *m;
 {
 	register struct ip *ip;
-	u_int hlen;
+	int hlen;
 	
 	DEBUG_CALL("ip_input");
 	DEBUG_ARG("m = %lx", (long)m);
-	DEBUG_ARG("m_len = %zu", m->m_len);
+	DEBUG_ARG("m_len = %d", m->m_len);
 
 	ipstat.ips_total++;
 	
@@ -155,18 +165,20 @@ ip_input(m)
 	 */
 	if (ip->ip_off &~ IP_DF) {
 	  register struct ipq *fp;
+      struct qlink *l;
 		/*
 		 * Look for queue of fragments
 		 * of this datagram.
 		 */
-		for (fp = (struct ipq *) ipq.next; fp != &ipq;
-		     fp = (struct ipq *) fp->next)
-		  if (ip->ip_id == fp->ipq_id &&
-		      ip->ip_src.s_addr == fp->ipq_src.s_addr &&
-		      ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
-		      ip->ip_p == fp->ipq_p)
+		for (l = ipq.ip_link.next; l != &ipq.ip_link; l = l->next) {
+            fp = container_of(l, struct ipq, ip_link);
+            if (ip->ip_id == fp->ipq_id &&
+                    ip->ip_src.s_addr == fp->ipq_src.s_addr &&
+                    ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
+                    ip->ip_p == fp->ipq_p)
 		    goto found;
-		fp = 0;
+        }
+        fp = NULL;
 	found:
 
 		/*
@@ -176,9 +188,9 @@ ip_input(m)
 		 */
 		ip->ip_len -= hlen;
 		if (ip->ip_off & IP_MF)
-		  ((struct ipasfrag *)ip)->ipf_mff |= 1;
+			ip->ip_tos |= 1;
 		else 
-		  ((struct ipasfrag *)ip)->ipf_mff &= ~1;
+		  	ip->ip_tos &= ~1;
 
 		ip->ip_off <<= 3;
 
@@ -187,9 +199,9 @@ ip_input(m)
 		 * or if this is not the first fragment,
 		 * attempt reassembly; if it succeeds, proceed.
 		 */
-		if (((struct ipasfrag *)ip)->ipf_mff & 1 || ip->ip_off) {
+		if (ip->ip_tos & 1 || ip->ip_off) {	
 			ipstat.ips_fragments++;
-			ip = ip_reass((struct ipasfrag *)ip, fp);
+			ip = ip_reass(ip, fp);
 			if (ip == 0)
 				return;
 			ipstat.ips_reassembled++;
@@ -225,21 +237,21 @@ bad:
 	return;
 }
 
+#define iptofrag(P) ((struct ipasfrag *)(((char*)(P)) - sizeof(struct qlink)))
+#define fragtoip(P) ((struct ip*)(((char*)(P)) + sizeof(struct qlink)))
 /*
  * Take incoming datagram fragment and try to
  * reassemble it into whole datagram.  If a chain for
  * reassembly of this datagram already exists, then it
  * is given as fp; otherwise have to make a chain.
  */
-struct ip *
-ip_reass(ip, fp)
-	register struct ipasfrag *ip;
-	register struct ipq *fp;
+static struct ip *
+ip_reass(register struct ip *ip, register struct ipq *fp)
 {
 	register struct mbuf *m = dtom(ip);
 	register struct ipasfrag *q;
 	int hlen = ip->ip_hl << 2;
-	int i, next;
+	u_int16_t i, next;
 	
 	DEBUG_CALL("ip_reass");
 	DEBUG_ARG("ip = %lx", (long)ip);
@@ -261,13 +273,13 @@ ip_reass(ip, fp)
 	  struct mbuf *t;
 	  if ((t = m_get()) == NULL) goto dropfrag;
 	  fp = mtod(t, struct ipq *);
-	  insque_32(fp, &ipq);
+	  insque(&fp->ip_link, &ipq.ip_link);
 	  fp->ipq_ttl = IPFRAGTTL;
 	  fp->ipq_p = ip->ip_p;
 	  fp->ipq_id = ip->ip_id;
-	  fp->ipq_next = fp->ipq_prev = (ipasfragp_32)fp;
-	  fp->ipq_src = ((struct ip *)ip)->ip_src;
-	  fp->ipq_dst = ((struct ip *)ip)->ip_dst;
+	  fp->frag_link.next = fp->frag_link.prev = &fp->frag_link;
+	  fp->ipq_src = ip->ip_src;
+	  fp->ipq_dst = ip->ip_dst;
 	  q = (struct ipasfrag *)fp;
 	  goto insert;
 	}
@@ -275,9 +287,9 @@ ip_reass(ip, fp)
 	/*
 	 * Find a segment which begins after this one does.
 	 */
-	for (q = (struct ipasfrag *)fp->ipq_next; q != (struct ipasfrag *)fp;
-	    q = (struct ipasfrag *)q->ipf_next)
-		if (q->ip_off > ip->ip_off)
+	for (q = fp->frag_link.next; q != (struct ipasfrag *)&fp->frag_link;
+            q = q->ipf_next)
+		if (q->ipf_off > ip->ip_off)
 			break;
 
 	/*
@@ -285,9 +297,9 @@ ip_reass(ip, fp)
 	 * our data already.  If so, drop the data from the incoming
 	 * segment.  If it provides all of our data, drop us.
 	 */
-	if (q->ipf_prev != (ipasfragp_32)fp) {
-		i = ((struct ipasfrag *)(q->ipf_prev))->ip_off +
-		  ((struct ipasfrag *)(q->ipf_prev))->ip_len - ip->ip_off;
+	if (q->ipf_prev != &fp->frag_link) {
+        struct ipasfrag *pq = q->ipf_prev;
+		i = pq->ipf_off + pq->ipf_len - ip->ip_off;
 		if (i > 0) {
 			if (i >= ip->ip_len)
 				goto dropfrag;
@@ -301,17 +313,18 @@ ip_reass(ip, fp)
 	 * While we overlap succeeding segments trim them or,
 	 * if they are completely covered, dequeue them.
 	 */
-	while (q != (struct ipasfrag *)fp && ip->ip_off + ip->ip_len > q->ip_off) {
-		i = (ip->ip_off + ip->ip_len) - q->ip_off;
-		if (i < q->ip_len) {
-			q->ip_len -= i;
-			q->ip_off += i;
+	while (q != (struct ipasfrag*)&fp->frag_link &&
+            ip->ip_off + ip->ip_len > q->ipf_off) {
+		i = (ip->ip_off + ip->ip_len) - q->ipf_off;
+		if (i < q->ipf_len) {
+			q->ipf_len -= i;
+			q->ipf_off += i;
 			m_adj(dtom(q), i);
 			break;
 		}
-		q = (struct ipasfrag *) q->ipf_next;
-		m_freem(dtom((struct ipasfrag *) q->ipf_prev));
-		ip_deq((struct ipasfrag *) q->ipf_prev);
+		q = q->ipf_next;
+		m_freem(dtom(q->ipf_prev));
+		ip_deq(q->ipf_prev);
 	}
 
 insert:
@@ -319,27 +332,26 @@ insert:
 	 * Stick new segment in its place;
 	 * check for complete reassembly.
 	 */
-	ip_enq(ip, (struct ipasfrag *) q->ipf_prev);
+	ip_enq(iptofrag(ip), q->ipf_prev);
 	next = 0;
-	for (q = (struct ipasfrag *) fp->ipq_next; q != (struct ipasfrag *)fp;
-	     q = (struct ipasfrag *) q->ipf_next) {
-		if (q->ip_off != next)
+	for (q = fp->frag_link.next; q != (struct ipasfrag*)&fp->frag_link;
+            q = q->ipf_next) {
+		if (q->ipf_off != next)
 			return (0);
-		next += q->ip_len;
+		next += q->ipf_len;
 	}
-	if (((struct ipasfrag *)(q->ipf_prev))->ipf_mff & 1)
+	if (((struct ipasfrag *)(q->ipf_prev))->ipf_tos & 1)
 		return (0);
 
 	/*
 	 * Reassembly is complete; concatenate fragments.
 	 */
-	q = (struct ipasfrag *) fp->ipq_next;
+    q = fp->frag_link.next;
 	m = dtom(q);
 
 	q = (struct ipasfrag *) q->ipf_next;
-	while (q != (struct ipasfrag *)fp) {
-	  struct mbuf *t;
-	  t = dtom(q);
+	while (q != (struct ipasfrag*)&fp->frag_link) {
+	  struct mbuf *t = dtom(q);
 	  q = (struct ipasfrag *) q->ipf_next;
 	  m_cat(m, t);
 	}
@@ -350,7 +362,7 @@ insert:
 	 * dequeue and discard fragment reassembly header.
 	 * Make header visible.
 	 */
-	ip = (struct ipasfrag *) fp->ipq_next;
+	q = fp->frag_link.next;
 
 	/*
 	 * If the fragments concatenated to an mbuf that's
@@ -361,24 +373,24 @@ insert:
 	 */
 	if (m->m_flags & M_EXT) {
 	  int delta;
-	  delta = (char *)ip - m->m_dat;
-	  ip = (struct ipasfrag *)(m->m_ext + delta);
+	  delta = (char *)q - m->m_dat;
+	  q = (struct ipasfrag *)(m->m_ext + delta);
 	}
 
 	/* DEBUG_ARG("ip = %lx", (long)ip); 
 	 * ip=(struct ipasfrag *)m->m_data; */
 
+	ip = fragtoip(q);
 	ip->ip_len = next;
-	ip->ipf_mff &= ~1;
-	((struct ip *)ip)->ip_src = fp->ipq_src;
-	((struct ip *)ip)->ip_dst = fp->ipq_dst;
-	remque_32(fp);
+	ip->ip_tos &= ~1;
+	ip->ip_src = fp->ipq_src;
+	ip->ip_dst = fp->ipq_dst;
+	remque(&fp->ip_link);
 	(void) m_free(dtom(fp));
-	m = dtom(ip);
 	m->m_len += (ip->ip_hl << 2);
 	m->m_data -= (ip->ip_hl << 2);
 
-	return ((struct ip *)ip);
+	return ip;
 
 dropfrag:
 	ipstat.ips_fragdropped++;
@@ -396,13 +408,12 @@ ip_freef(fp)
 {
 	register struct ipasfrag *q, *p;
 
-	for (q = (struct ipasfrag *) fp->ipq_next; q != (struct ipasfrag *)fp;
-	    q = p) {
-		p = (struct ipasfrag *) q->ipf_next;
+	for (q = fp->frag_link.next; q != (struct ipasfrag*)&fp->frag_link; q = p) {
+		p = q->ipf_next;
 		ip_deq(q);
 		m_freem(dtom(q));
 	}
-	remque_32(fp);
+	remque(&fp->ip_link);
 	(void) m_free(dtom(fp));
 }
 
@@ -416,10 +427,10 @@ ip_enq(p, prev)
 {
 	DEBUG_CALL("ip_enq");
 	DEBUG_ARG("prev = %lx", (long)prev);
-	p->ipf_prev = (ipasfragp_32) prev;
+	p->ipf_prev =  prev;
 	p->ipf_next = prev->ipf_next;
-	((struct ipasfrag *)(prev->ipf_next))->ipf_prev = (ipasfragp_32) p;
-	prev->ipf_next = (ipasfragp_32) p;
+	((struct ipasfrag *)(prev->ipf_next))->ipf_prev = p;
+	prev->ipf_next = p;
 }
 
 /*
@@ -441,20 +452,21 @@ ip_deq(p)
 void
 ip_slowtimo()
 {
-	register struct ipq *fp;
+	struct qlink *l;
 	
 	DEBUG_CALL("ip_slowtimo");
 	
-	fp = (struct ipq *) ipq.next;
-	if (fp == 0)
+	l = ipq.ip_link.next;
+
+ 	if (l == 0)
 	   return;
 
-	while (fp != &ipq) {
-		--fp->ipq_ttl;
-		fp = (struct ipq *) fp->next;
-		if (((struct ipq *)(fp->prev))->ipq_ttl == 0) {
+	while (l != &ipq.ip_link) {
+		struct ipq *fp = container_of(l, struct ipq, ip_link);
+		l = l->next;
+		if (--fp->ipq_ttl == 0) {
 			ipstat.ips_fragtimeout++;
-			ip_freef((struct ipq *) fp->prev);
+			ip_freef(fp);
 		}
 	}
 }

BasiliskII/src/slirp/ip_output.c

@@ -55,9 +55,8 @@ ip_output(so, m0)
 {
 	register struct ip *ip;
 	register struct mbuf *m = m0;
-	register u_int hlen = sizeof(struct ip);
-	u_int len, off;
-	int error = 0;
+	register int hlen = sizeof(struct ip );
+	int len, off, error = 0;
 
 	DEBUG_CALL("ip_output");
 	DEBUG_ARG("so = %lx", (long)so);
@@ -129,7 +128,7 @@ ip_output(so, m0)
 	 */
 	m0 = m;
 	mhlen = sizeof (struct ip);
-	for (off = hlen + len; off < ip->ip_len; off += len) {
+	for (off = hlen + len; off < (u_int16_t)ip->ip_len; off += len) {
 	  register struct ip *mhip;
 	  m = m_get();
 	  if (m == 0) {
@@ -174,7 +173,7 @@ ip_output(so, m0)
 	 * and updating header, then send each fragment (in order).
 	 */
 	m = m0;
-	m_adj(m, hlen + firstlen - ip->ip_len);
+	m_adj(m, hlen + firstlen - (u_int16_t)ip->ip_len);
 	ip->ip_len = htons((u_int16_t)m->m_len);
 	ip->ip_off = htons((u_int16_t)(ip->ip_off | IP_MF));
 	ip->ip_sum = 0;

BasiliskII/src/slirp/mbuf.c

@@ -24,16 +24,18 @@ int mbuf_alloced = 0;
 struct mbuf m_freelist, m_usedlist;
 int mbuf_thresh = 30;
 int mbuf_max = 0;
-size_t msize;
+int msize;
 
-void m_init()
+void
+m_init()
 {
 	m_freelist.m_next = m_freelist.m_prev = &m_freelist;
 	m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
 	msize_init();
 }
 
-void msize_init()
+void
+msize_init()
 {
 	/*
 	 * Find a nice value for msize
@@ -51,7 +53,8 @@ void msize_init()
  * free old mbufs, we mark all mbufs above mbuf_thresh as M_DOFREE,
  * which tells m_free to actually free() it
  */
-struct mbuf *m_get()
+struct mbuf *
+m_get()
 {
 	register struct mbuf *m;
 	int flags = 0;
@@ -86,7 +89,9 @@ end_error:
 	return m;
 }
 
-void m_free(struct mbuf *m)
+void
+m_free(m)
+	struct mbuf *m;
 {
 	
   DEBUG_CALL("m_free");
@@ -119,7 +124,9 @@ void m_free(struct mbuf *m)
  * the other.. if result is too big for one mbuf, malloc()
  * an M_EXT data segment
  */
-void m_cat(register struct mbuf *m, register struct mbuf *n)
+void
+m_cat(m, n)
+	register struct mbuf *m, *n;
 {
 	/*
 	 * If there's no room, realloc
@@ -135,7 +142,10 @@ void m_cat(register struct mbuf *m, register struct mbuf *n)
 
 
 /* make m size bytes large */
-void m_inc(struct mbuf *m, u_int size)
+void
+m_inc(m, size)
+        struct mbuf *m;
+        int size;
 {
        int datasize;
 
@@ -169,7 +179,10 @@ void m_inc(struct mbuf *m, u_int size)
 
 
 
-void m_adj(struct mbuf *m, int len)
+void
+m_adj(m, len)
+	struct mbuf *m;
+	int len;
 {
 	if (m == NULL)
 		return;
@@ -189,7 +202,9 @@ void m_adj(struct mbuf *m, int len)
  * Copy len bytes from m, starting off bytes into n
  */
 int
-m_copy(struct mbuf *n, struct mbuf *m, u_int off, u_int len)
+m_copy(n, m, off, len)
+	struct mbuf *n, *m;
+	int off, len;
 {
 	if (len > M_FREEROOM(n))
 		return -1;
@@ -205,7 +220,9 @@ m_copy(struct mbuf *n, struct mbuf *m, u_int off, u_int len)
  * XXX This is a kludge, I should eliminate the need for it
  * Fortunately, it's not used often
  */
-struct mbuf *dtom(void *dat)
+struct mbuf *
+dtom(dat)
+	void *dat;
 {
 	struct mbuf *m;
 	

BasiliskII/src/slirp/mbuf.h

@@ -63,11 +63,11 @@ struct m_hdr {
 	struct	mbuf *mh_prevpkt; /* Flags aren't used in the output queue */
 	int	mh_flags;	  /* Misc flags */
 
-	size_t	mh_size;		/* Size of data */
+	int	mh_size;		/* Size of data */
 	struct	socket *mh_so;
 	
 	caddr_t	mh_data;		/* Location of data */
-	size_t	mh_len;			/* Amount of data in this mbuf */
+	int	mh_len;			/* Amount of data in this mbuf */
 };
 
 /* 
@@ -130,14 +130,14 @@ extern int mbuf_alloced;
 extern struct mbuf m_freelist, m_usedlist;
 extern int mbuf_max;
 
-void m_init(void);
-void msize_init(void);
-struct mbuf * m_get(void);
-void m_free(struct mbuf *);
-void m_cat(register struct mbuf *, register struct mbuf *);
-void m_inc(struct mbuf *, u_int);
-void m_adj(struct mbuf *, int);
-int m_copy(struct mbuf *, struct mbuf *, u_int, u_int);
-struct mbuf * dtom(void *);
+void m_init _P((void));
+void msize_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 *));
+void m_inc _P((struct mbuf *, int));
+void m_adj _P((struct mbuf *, int));
+int m_copy _P((struct mbuf *, struct mbuf *, int, int));
+struct mbuf * dtom _P((void *));
 
 #endif

BasiliskII/src/slirp/misc.c

@@ -17,7 +17,10 @@ int x_port = -1;
 int x_display = 0;
 int x_screen = 0;
 
-int show_x(char *buff, struct socket *inso)
+int
+show_x(buff, inso)
+	char *buff;
+	struct socket *inso;
 {
 	if (x_port < 0) {
 		lprint("X Redir: X not being redirected.\r\n");
@@ -37,7 +40,12 @@ int show_x(char *buff, struct socket *inso)
 /*
  * XXX Allow more than one X redirection?
  */
-void redir_x(u_int32_t inaddr, int start_port, int display, int screen)
+void
+redir_x(inaddr, start_port, display, screen)
+	u_int32_t inaddr;
+	int start_port;
+	int display;
+	int screen;
 {
 	int i;
 	
@@ -61,69 +69,44 @@ void redir_x(u_int32_t inaddr, int start_port, int display, int screen)
 #endif
 
 #ifndef HAVE_INET_ATON
-int inet_aton(const char *cp, struct in_addr *ia)
+int
+inet_aton(cp, ia)
+	const char *cp;
+	struct in_addr *ia;
 {
-	return inet_pton(AF_INET, cp, &ia->s_addr);
+	u_int32_t addr = inet_addr(cp);
+	if (addr == 0xffffffff)
+		return 0;
+	ia->s_addr = addr;
+	return 1;
 }
 #endif
 
 /*
  * Get our IP address and put it in our_addr
  */
-void getouraddr()
+void
+getouraddr()
 {
 	char buff[256];
-
-	if (gethostname(buff, sizeof(buff)) == 0)
-	{
-		struct addrinfo hints = { 0 };
-		hints.ai_flags = AI_NUMERICHOST;
-		hints.ai_family = AF_INET;
-		struct addrinfo* ai;
-		if (getaddrinfo(buff, NULL, &hints, &ai) == 0)
-		{
-			our_addr = *(struct in_addr *)ai->ai_addr->sa_data;
-			freeaddrinfo(ai);
-		}
-	}
-    if (our_addr.s_addr == 0)
-        our_addr.s_addr = loopback_addr.s_addr;
+	struct hostent *he = NULL;
+	
+	if (gethostname(buff,256) == 0)
+            he = gethostbyname(buff);
+        if (he)
+            our_addr = *(struct in_addr *)he->h_addr;
+        if (our_addr.s_addr == 0)
+            our_addr.s_addr = loopback_addr.s_addr;
 }
 
-#if SIZEOF_CHAR_P == 8
-
-struct quehead_32 {
-	u_int32_t qh_link;
-	u_int32_t qh_rlink;
-};
-
-inline void insque_32(void *a, void *b)
-{
-	register struct quehead_32 *element = (struct quehead_32 *) a;
-	register struct quehead_32 *head = (struct quehead_32 *) b;
-	element->qh_link = head->qh_link;
-	head->qh_link = (u_int32_t)element;
-	element->qh_rlink = (u_int32_t)head;
-	((struct quehead_32 *)(element->qh_link))->qh_rlink
-	= (u_int32_t)element;
-}
-
-inline void remque_32(void *a)
-{
-	register struct quehead_32 *element = (struct quehead_32 *) a;
-	((struct quehead_32 *)(element->qh_link))->qh_rlink = element->qh_rlink;
-	((struct quehead_32 *)(element->qh_rlink))->qh_link = element->qh_link;
-	element->qh_rlink = 0;
-}
-
-#endif /* SIZEOF_CHAR_P == 8 */
-
 struct quehead {
 	struct quehead *qh_link;
 	struct quehead *qh_rlink;
 };
 
-void insque(void *a, void *b)
+void
+insque(a, b)
+	void *a, *b;
 {
 	register struct quehead *element = (struct quehead *) a;
 	register struct quehead *head = (struct quehead *) b;
@@ -134,7 +117,9 @@ void insque(void *a, void *b)
 	= (struct quehead *)element;
 }
 
-void remque(void *a)
+void
+remque(a)
+     void *a;
 {
   register struct quehead *element = (struct quehead *) a;
   ((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;
@@ -146,7 +131,13 @@ void remque(void *a)
 /* #endif */
 
 
-int add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, int addr, int port)
+int
+add_exec(ex_ptr, do_pty, exec, addr, port)
+	struct ex_list **ex_ptr;
+	int do_pty;
+	char *exec;
+	int addr;
+	int port;
 {
 	struct ex_list *tmp_ptr;
 	
@@ -175,7 +166,9 @@ int add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, int addr, int port
 extern int sys_nerr;
 extern char *sys_errlist[];
 
-char *strerror(int error)
+char *
+strerror(error)
+	int error;
 {
 	if (error < sys_nerr)
 	   return sys_errlist[error];
@@ -188,7 +181,11 @@ char *strerror(int error)
 
 #ifdef _WIN32
 
-int fork_exec(struct socket *so, char *ex, int do_pty)
+int
+fork_exec(so, ex, do_pty)
+	struct socket *so;
+	char *ex;
+	int do_pty;
 {
     /* not implemented */
     return 0;
@@ -196,7 +193,9 @@ int fork_exec(struct socket *so, char *ex, int do_pty)
 
 #else
 
-int slirp_openpty(int *amaster, int *aslave)
+int
+slirp_openpty(amaster, aslave)
+     int *amaster, *aslave;
 {
 	register int master, slave;
 
@@ -270,7 +269,11 @@ int slirp_openpty(int *amaster, int *aslave)
  * do_pty = 1   Fork/exec using slirp.telnetd
  * do_ptr = 2   Fork/exec using pty
  */
-int fork_exec(struct socket *so, char *ex, int do_pty)
+int
+fork_exec(so, ex, do_pty)
+	struct socket *so;
+	char *ex;
+	int do_pty;
 {
 	int s;
 	struct sockaddr_in addr;
@@ -426,7 +429,9 @@ int fork_exec(struct socket *so, char *ex, int do_pty)
 #endif
 
 #ifndef HAVE_STRDUP
-char *strdup(const char *str)
+char *
+strdup(str)
+	const char *str;
 {
 	char *bptr;
 	
@@ -438,7 +443,9 @@ char *strdup(const char *str)
 #endif
 
 #if 0
-void snooze_hup(int num)
+void
+snooze_hup(num)
+	int num;
 {
 	int s, ret;
 #ifndef NO_UNIX_SOCKETS
@@ -478,7 +485,8 @@ void snooze_hup(int num)
 }
 	
 	
-void snooze()
+void
+snooze()
 {
 	sigset_t s;
 	int i;
@@ -502,7 +510,9 @@ void snooze()
 	exit(255);
 }
 
-void relay(int s)
+void
+relay(s)
+	int s;
 {
 	char buf[8192];
 	int n;
@@ -562,14 +572,25 @@ void relay(int s)
 }
 #endif
 
-int (*lprint_print)(void *, const char *, va_list);
+int (*lprint_print) _P((void *, const char *, va_list));
 char *lprint_ptr, *lprint_ptr2, **lprint_arg;
 
-void lprint(const char *format, ...)
+void
+#ifdef __STDC__
+lprint(const char *format, ...)
+#else
+lprint(va_alist) va_dcl
+#endif
 {
 	va_list args;
         
-    va_start(args, format);
+#ifdef __STDC__
+        va_start(args, format);
+#else
+        char *format;
+        va_start(args);
+        format = va_arg(args, char *);
+#endif
 #if 0
 	/* If we're printing to an sbuf, make sure there's enough room */
 	/* XXX +100? */
@@ -618,7 +639,9 @@ void lprint(const char *format, ...)
 	va_end(args);
 }
 
-void add_emu(char *buff)
+void
+add_emu(buff)
+	char *buff;
 {
 	u_int lport, fport;
 	u_int8_t tos = 0, emu = 0;
@@ -710,24 +733,42 @@ void add_emu(char *buff)
  * Some BSD-derived systems have a sprintf which returns char *
  */
 
-int vsprintf_len(char *string, const char *format, va_list args)
+int
+vsprintf_len(string, format, args)
+	char *string;
+	const char *format;
+	va_list args;
 {
 	vsprintf(string, format, args);
 	return strlen(string);
 }
 
-int sprintf_len(char *string, const char *format, ...)
+int
+#ifdef __STDC__
+sprintf_len(char *string, const char *format, ...)
+#else
+sprintf_len(va_alist) va_dcl
+#endif
 {
 	va_list args;
+#ifdef __STDC__
 	va_start(args, format);
+#else
+	char *string;
+	char *format;
+	va_start(args);
+	string = va_arg(args, char *);
+	format = va_arg(args, char *);
+#endif
 	vsprintf(string, format, args);
-	va_end(args);
 	return strlen(string);
 }
 
 #endif
 
-void u_sleep(int usec)
+void
+u_sleep(usec)
+	int usec;
 {
 	struct timeval t;
 	fd_set fdset;
@@ -744,7 +785,9 @@ void u_sleep(int usec)
  * Set fd blocking and non-blocking
  */
 
-void fd_nonblock(int fd)
+void
+fd_nonblock(fd)
+	int fd;
 {
 #if defined USE_FIONBIO && defined FIONBIO
 	ioctlsockopt_t opt = 1;
@@ -759,7 +802,9 @@ void fd_nonblock(int fd)
 #endif
 }
 
-void fd_block(int fd)
+void
+fd_block(fd)
+	int fd;
 {
 #if defined USE_FIONBIO && defined FIONBIO
 	ioctlsockopt_t opt = 0;
@@ -779,8 +824,13 @@ void fd_block(int fd)
 /*
  * invoke RSH
  */
-int rsh_exec(struct socket *so, struct socket *ns,
-	char *user, char *host, char *args)
+int
+rsh_exec(so,ns, user, host, args)
+	struct socket *so;
+	struct socket *ns;
+	char *user;
+	char *host;
+	char *args;
 {
 	int fd[2];
 	int fd0[2];

BasiliskII/src/slirp/misc.h

@@ -19,15 +19,15 @@ struct ex_list {
 extern struct ex_list *exec_list;
 extern u_int curtime, time_fasttimo, last_slowtimo, detach_time, detach_wait;
 
-extern int (*lprint_print)(void *, const char *, va_list);
+extern int (*lprint_print) _P((void *, const char *, va_list));
 extern char *lprint_ptr, *lprint_ptr2, **lprint_arg;
 extern struct sbuf *lprint_sb;
 
 #ifndef HAVE_STRDUP
-char *strdup(const char *);
+char *strdup _P((const char *));
 #endif
 
-void do_wait(int);
+void do_wait _P((int));
 
 #define EMU_NONE 0x0
 
@@ -67,21 +67,21 @@ extern struct emu_t *tcpemu;
 
 extern int x_port, x_server, x_display;
 
-int show_x(char *, struct socket *);
-void redir_x(u_int32_t, int, int, int);
-void getouraddr(void);
-void slirp_insque(void *, void *);
-void slirp_remque(void *);
-int add_exec(struct ex_list **, int, char *, int, int);
-int slirp_openpty(int *, int *);
-int fork_exec(struct socket *, char *, int);
-void snooze_hup(int);
-void snooze(void);
-void relay(int);
-void add_emu(char *);
-void u_sleep(int);
-void fd_nonblock(int);
-void fd_block(int);
-int rsh_exec(struct socket *, struct socket *, char *, char *, char *);
+int show_x _P((char *, struct socket *));
+void redir_x _P((u_int32_t, int, int, int));
+void getouraddr _P((void));
+void slirp_insque  _P((void *, void *));
+void slirp_remque  _P((void *));
+int add_exec _P((struct ex_list **, int, char *, int, int));
+int slirp_openpty _P((int *, int *));
+int fork_exec _P((struct socket *, char *, int));
+void snooze_hup _P((int));
+void snooze _P((void));
+void relay _P((int));
+void add_emu _P((char *));
+void u_sleep _P((int));
+void fd_nonblock _P((int));
+void fd_block _P((int));
+int rsh_exec _P((struct socket *, struct socket *, char *, char *, char *));
 
 #endif

BasiliskII/src/slirp/sbuf.c

@@ -5,7 +5,7 @@
  * terms and conditions of the copyright.
  */
 
-#include <stdlib.h>
+// #include <stdlib.h>
 #include <slirp.h>
 
 /* Done as a macro in socket.h */
@@ -16,12 +16,17 @@
  * }
  */
 
-void sbfree(struct sbuf *sb)
+void
+sbfree(sb)
+	struct sbuf *sb;
 {
 	free(sb->sb_data);
 }
 
-void sbdrop(struct sbuf *sb, u_int num)
+void
+sbdrop(sb, num)
+	struct sbuf *sb;
+	int num; 
 {
 	/* 
 	 * We can only drop how much we have
@@ -36,7 +41,10 @@ void sbdrop(struct sbuf *sb, u_int num)
    
 }
 
-void sbreserve(struct sbuf *sb, size_t size)
+void
+sbreserve(sb, size)
+	struct sbuf *sb;
+	int size;
 {
 	if (sb->sb_data) {
 		/* Already alloced, realloc if necessary */
@@ -64,14 +72,17 @@ void sbreserve(struct sbuf *sb, size_t size)
  * this prevents an unnecessary copy of the data
  * (the socket is non-blocking, so we won't hang)
  */
-void sbappend(struct socket *so, struct mbuf *m)
+void
+sbappend(so, m)
+	struct socket *so;
+	struct mbuf *m;
 {
 	int ret = 0;
 	
 	DEBUG_CALL("sbappend");
 	DEBUG_ARG("so = %lx", (long)so);
 	DEBUG_ARG("m = %lx", (long)m);
-	DEBUG_ARG("m->m_len = %zu", m->m_len);
+	DEBUG_ARG("m->m_len = %d", m->m_len);
 	
 	/* Shouldn't happen, but...  e.g. foreign host closes connection */
 	if (m->m_len <= 0) {
@@ -123,7 +134,10 @@ void sbappend(struct socket *so, struct mbuf *m)
  * Copy the data from m into sb
  * The caller is responsible to make sure there's enough room
  */
-void sbappendsb(struct sbuf *sb, struct mbuf *m)
+void
+sbappendsb(sb, m)
+	 struct sbuf *sb;
+	 struct mbuf *m;
 {
 	int len, n,  nn;
 	
@@ -159,7 +173,12 @@ void sbappendsb(struct sbuf *sb, struct mbuf *m)
  * Don't update the sbuf rptr, this will be
  * done in sbdrop when the data is acked
  */
-void sbcopy(struct sbuf *sb, u_int off, u_int len, char *to)
+void
+sbcopy(sb, off, len, to)
+	struct sbuf *sb;
+	int off;
+	int len;
+	char *to;
 {
 	char *from;
 	

BasiliskII/src/slirp/sbuf.h

@@ -8,8 +8,6 @@
 #ifndef _SBUF_H_
 #define _SBUF_H_
 
-#include <stddef.h>
-
 #define sbflush(sb) sbdrop((sb),(sb)->sb_cc)
 #define sbspace(sb) ((sb)->sb_datalen - (sb)->sb_cc)
 
@@ -23,11 +21,11 @@ struct sbuf {
 	char	*sb_data;	/* Actual data */
 };
 
-void sbfree(struct sbuf *);
-void sbdrop(struct sbuf *, u_int);
-void sbreserve(struct sbuf *, size_t);
-void sbappend(struct socket *, struct mbuf *);
-void sbappendsb(struct sbuf *, struct mbuf *);
-void sbcopy(struct sbuf *, u_int, u_int, char *);
+void sbfree _P((struct sbuf *));
+void sbdrop _P((struct sbuf *, int));
+void sbreserve _P((struct sbuf *, int));
+void sbappend _P((struct socket *, struct mbuf *));
+void sbappendsb _P((struct sbuf *, struct mbuf *));
+void sbcopy _P((struct sbuf *, int, int, char *));
 
 #endif

BasiliskII/src/slirp/slirp.c

@@ -84,7 +84,7 @@ static int get_dns_addr(struct in_addr *pdns_addr)
 static int get_dns_addr(struct in_addr *pdns_addr)
 {
     char buff[512];
-    char buff2[256+1];
+    char buff2[256];
     FILE *f;
     int found = 0;
     struct in_addr tmp_addr;
@@ -211,8 +211,8 @@ int slirp_select_fill(int *pnfds,
 		 * in the fragment queue, or there are TCP connections active
 		 */
 		do_slowtimo = ((tcb.so_next != &tcb) ||
-			       ((struct ipasfrag *)&ipq != (struct ipasfrag *)ipq.next));
-		
+			 (&ipq.ip_link != ipq.ip_link.next));
+	
 		for (so = tcb.so_next; so != &tcb; so = so_next) {
 			so_next = so->so_next;
 			
@@ -220,14 +220,14 @@ int slirp_select_fill(int *pnfds,
 			 * See if we need a tcp_fasttimo
 			 */
 			if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
-				time_fasttimo = curtime; /* Flag when we want a fasttimo */
+			   time_fasttimo = curtime; /* Flag when we want a fasttimo */
 			
 			/*
 			 * NOFDREF can include still connecting to local-host,
 			 * newly socreated() sockets etc. Don't want to select these.
 	 		 */
 			if (so->so_state & SS_NOFDREF || so->s == -1)
-				continue;
+			   continue;
 			
 			/*
 			 * Set for reading sockets which are accepting
@@ -346,18 +346,18 @@ int slirp_select_fill(int *pnfds,
 
 void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds)
 {
-	struct socket *so, *so_next;
-	int ret;
+    struct socket *so, *so_next;
+    int ret;
 
-	global_readfds = readfds;
-	global_writefds = writefds;
-	global_xfds = xfds;
+    global_readfds = readfds;
+    global_writefds = writefds;
+    global_xfds = xfds;
 
 	/* Update time */
 	updtime();
-
+	
 	/*
-	 * See if anything has timed out
+	 * See if anything has timed out 
 	 */
 	if (link_up) {
 		if (time_fasttimo && ((curtime - time_fasttimo) >= FAST_TIMO)) {
@@ -370,7 +370,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds)
 			last_slowtimo = curtime;
 		}
 	}
-
+	
 	/*
 	 * Check sockets
 	 */
@@ -380,21 +380,21 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds)
 		 */
 		for (so = tcb.so_next; so != &tcb; so = so_next) {
 			so_next = so->so_next;
-
+			
 			/*
 			 * FD_ISSET is meaningless on these sockets
 			 * (and they can crash the program)
 			 */
 			if (so->so_state & SS_NOFDREF || so->s == -1)
-				continue;
-
+			   continue;
+			
 			/*
 			 * Check for URG data
 			 * This will soread as well, so no need to
 			 * test for readfds below if this succeeds
 			 */
 			if (FD_ISSET(so->s, xfds))
-				sorecvoob(so);
+			   sorecvoob(so);
 			/*
 			 * Check sockets for reading
 			 */
@@ -407,92 +407,86 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds)
 					continue;
 				} /* else */
 				ret = soread(so);
-
+				
 				/* Output it if we read something */
 				if (ret > 0)
-					tcp_output(sototcpcb(so));
+				   tcp_output(sototcpcb(so));
 			}
-
+			
 			/*
 			 * Check sockets for writing
 			 */
 			if (FD_ISSET(so->s, writefds)) {
-				/*
-				 * Check for non-blocking, still-connecting sockets
-				 */
-				if (so->so_state & SS_ISFCONNECTING) {
-					/* Connected */
-					so->so_state &= ~SS_ISFCONNECTING;
-
-					ret = send(so->s, (char*)&ret, 0, 0);
-					if (ret < 0) {
-						/* XXXXX Must fix, zero bytes is a NOP */
-						int error = WSAGetLastError();
-						if (error == EAGAIN || error == WSAEWOULDBLOCK ||
-							error == WSAEINPROGRESS || error == WSAENOTCONN)
-							continue;
-
-						/* else failed */
-						so->so_state = SS_NOFDREF;
-					}
-					/* else so->so_state &= ~SS_ISFCONNECTING; */
-
-					/*
-					 * Continue tcp_input
-					 */
-					tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
-					/* continue; */
-				}
-				else
-					ret = sowrite(so);
-				/*
-				 * XXXXX If we wrote something (a lot), there
-				 * could be a need for a window update.
-				 * In the worst case, the remote will send
-				 * a window probe to get things going again
-				 */
+			  /*
+			   * Check for non-blocking, still-connecting sockets
+			   */
+			  if (so->so_state & SS_ISFCONNECTING) {
+			    /* Connected */
+			    so->so_state &= ~SS_ISFCONNECTING;
+			    
+			    ret = send(so->s, &ret, 0, 0);
+			    if (ret < 0) {
+			      /* XXXXX Must fix, zero bytes is a NOP */
+			      if (errno == EAGAIN || errno == EWOULDBLOCK ||
+				  errno == EINPROGRESS || errno == ENOTCONN)
+				continue;
+			      
+			      /* else failed */
+			      so->so_state = SS_NOFDREF;
+			    }
+			    /* else so->so_state &= ~SS_ISFCONNECTING; */
+			    
+			    /*
+			     * Continue tcp_input
+			     */
+			    tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
+			    /* continue; */
+			  } else
+			    ret = sowrite(so);
+			  /*
+			   * XXXXX If we wrote something (a lot), there 
+			   * could be a need for a window update.
+			   * In the worst case, the remote will send
+			   * a window probe to get things going again
+			   */
 			}
-
+			
 			/*
 			 * Probe a still-connecting, non-blocking socket
 			 * to check if it's still alive
-			 */
+	 	 	 */
 #ifdef PROBE_CONN
 			if (so->so_state & SS_ISFCONNECTING) {
-				ret = recv(so->s, (char *)&ret, 0, 0);
-
-				if (ret < 0) {
-					/* XXX */
-					int error = WSAGetLastError();
-					if (error == EAGAIN || error == WSAEWOULDBLOCK ||
-						error == WSAEINPROGRESS || error == WSAENOTCONN)
-						continue; /* Still connecting, continue */
-
-					  /* else failed */
-					so->so_state = SS_NOFDREF;
-
-					/* tcp_input will take care of it */
-				}
-				else {
-					ret = send(so->s, &ret, 0, 0);
-					if (ret < 0) {
-						/* XXX */
-						int error = WSAGetLastError();
-						if (error == EAGAIN || error == WSAEWOULDBLOCK ||
-							error == WSAEINPROGRESS || error == WSAENOTCONN)
-							continue;
-						/* else failed */
-						so->so_state = SS_NOFDREF;
-					}
-					else
-						so->so_state &= ~SS_ISFCONNECTING;
-
-				}
-				tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
-		} /* SS_ISFCONNECTING */
+			  ret = recv(so->s, (char *)&ret, 0,0);
+			  
+			  if (ret < 0) {
+			    /* XXX */
+			    if (errno == EAGAIN || errno == EWOULDBLOCK ||
+				errno == EINPROGRESS || errno == ENOTCONN)
+			      continue; /* Still connecting, continue */
+			    
+			    /* else failed */
+			    so->so_state = SS_NOFDREF;
+			    
+			    /* tcp_input will take care of it */
+			  } else {
+			    ret = send(so->s, &ret, 0,0);
+			    if (ret < 0) {
+			      /* XXX */
+			      if (errno == EAGAIN || errno == EWOULDBLOCK ||
+				  errno == EINPROGRESS || errno == ENOTCONN)
+				continue;
+			      /* else failed */
+			      so->so_state = SS_NOFDREF;
+			    } else
+			      so->so_state &= ~SS_ISFCONNECTING;
+			    
+			  }
+			  tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
+			} /* SS_ISFCONNECTING */
 #endif
-	}
-
+		}
+		
 		/*
 		 * Now UDP sockets.
 		 * Incoming packets are sent straight away, they're not buffered.
@@ -500,27 +494,27 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds)
 		 */
 		for (so = udb.so_next; so != &udb; so = so_next) {
 			so_next = so->so_next;
-
+			
 			if (so->s != -1 && FD_ISSET(so->s, readfds)) {
-				sorecvfrom(so);
-			}
+                            sorecvfrom(so);
+                        }
 		}
-}
-
+	}
+	
 	/*
 	 * See if we can start outputting
 	 */
 	if (if_queued && link_up)
-		if_start();
+	   if_start();
 
 	/* clear global file descriptor sets.
 	 * these reside on the stack in vl.c
 	 * so they're unusable if we're not in
 	 * slirp_select_fill or slirp_select_poll.
 	 */
-	global_readfds = NULL;
-	global_writefds = NULL;
-	global_xfds = NULL;
+	 global_readfds = NULL;
+	 global_writefds = NULL;
+	 global_xfds = NULL;
 }
 
 #define ETH_ALEN 6

BasiliskII/src/slirp/slirp.h

@@ -22,12 +22,18 @@ typedef char *caddr_t;
 typedef int socklen_t;
 typedef unsigned long ioctlsockopt_t;
 
+# include <windows.h>
 # include <winsock2.h>
-# include <WS2tcpip.h>
 # include <sys/timeb.h>
 # include <iphlpapi.h>
 
 # define USE_FIONBIO 1
+# define EWOULDBLOCK WSAEWOULDBLOCK
+# define EINPROGRESS WSAEINPROGRESS
+# define ENOTCONN WSAENOTCONN
+# define EHOSTUNREACH WSAEHOSTUNREACH
+# define ENETUNREACH WSAENETUNREACH
+# define ECONNREFUSED WSAECONNREFUSED
 
 /* Basilisk II Router defines those */
 # define udp_read_completion slirp_udp_read_completion
@@ -133,29 +139,35 @@ typedef u_int32_t uint32;
 #include <arpa/inet.h>
 #endif
 
+#ifndef _P
+#ifndef NO_PROTOTYPES
+#  define   _P(x)   x
+#else
+#  define   _P(x)   ()
+#endif
+#endif
+
+
 #ifdef GETTIMEOFDAY_ONE_ARG
 #define gettimeofday(x, y) gettimeofday(x)
 #endif
 
 /* Systems lacking strdup() definition in <string.h>. */
 #if defined(ultrix)
-char *strdup(const char *);
+char *strdup _P((const char *));
 #endif
 
 /* Systems lacking malloc() definition in <stdlib.h>. */
 #if defined(ultrix) || defined(hcx)
-void *malloc(size_t arg);
-void free(void *ptr);
+void *malloc _P((size_t arg));
+void free _P((void *ptr));
 #endif
 
 #ifndef HAVE_INET_ATON
-int inet_aton(const char *cp, struct in_addr *ia);
+int inet_aton _P((const char *cp, struct in_addr *ia));
 #endif
 
 #include <fcntl.h>
-#ifdef _WIN32
-#include <io.h>
-#endif
 #ifndef NO_UNIX_SOCKETS
 #include <sys/un.h>
 #endif
@@ -187,7 +199,11 @@ int inet_aton(const char *cp, struct in_addr *ia);
 #include <ppp/slirppp.h>
 #endif
 
+#ifdef __STDC__
 #include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
 
 #include <sys/stat.h>
 
@@ -204,13 +220,8 @@ int inet_aton(const char *cp, struct in_addr *ia);
 
 #if defined __GNUC__
 #define PACKED__ __attribute__ ((packed))
-#elif defined _MSC_VER 
-#define PRAGMA_PACK_SUPPORTED 1
-#define PACK_RESET
-#define PACKED__
 #elif defined __sgi
 #define PRAGMA_PACK_SUPPORTED 1
-#define PACK_RESET 0
 #define PACKED__
 #else
 #error "Packed attribute or pragma shall be supported"
@@ -246,49 +257,41 @@ extern struct ttys *ttys_unit[MAX_INTERFACES];
 #endif
 
 #ifndef FULL_BOLT
-void if_start(void);
+void if_start _P((void));
 #else
-void if_start(struct ttys *);
+void if_start _P((struct ttys *));
 #endif
 
 #ifdef BAD_SPRINTF
 # define vsprintf vsprintf_len
 # define sprintf sprintf_len
- extern int vsprintf_len(char *, const char *, va_list);
- extern int sprintf_len(char *, const char *, ...);
+ extern int vsprintf_len _P((char *, const char *, va_list));
+ extern int sprintf_len _P((char *, const char *, ...));
 #endif
 
 #ifdef DECLARE_SPRINTF
 # ifndef BAD_SPRINTF
- extern int vsprintf(char *, const char *, va_list);
+ extern int vsprintf _P((char *, const char *, va_list));
 # endif
- extern int vfprintf(FILE *, const char *, va_list);
+ extern int vfprintf _P((FILE *, const char *, va_list));
 #endif
 
 #ifndef HAVE_STRERROR
- extern char *strerror(int error);
+ extern char *strerror _P((int error));
 #endif
 
 #ifndef HAVE_INDEX
- char *index(const char *, int);
+ char *index _P((const char *, int));
 #endif
 
 #ifndef HAVE_GETHOSTID
- long gethostid(void);
+ long gethostid _P((void));
 #endif
 
-void lprint(const char *, ...);
+void lprint _P((const char *, ...));
 
 extern int do_echo;
 
-#if SIZEOF_CHAR_P == 4
-# define insque_32 insque
-# define remque_32 remque
-#else
- extern inline void insque_32(void *, void *);
- extern inline void remque_32(void *);
-#endif
-
 #ifndef _WIN32
 #include <netdb.h>
 #endif
@@ -299,47 +302,48 @@ extern int do_echo;
 int cksum(struct mbuf *m, int len);
 
 /* if.c */
-void if_init(void);
-void if_output(struct socket *, struct mbuf *);
+void if_init _P((void));
+void if_output _P((struct socket *, struct mbuf *));
 
 /* ip_input.c */
-void ip_init(void);
-void ip_input(struct mbuf *);
-struct ip * ip_reass(register struct ipasfrag *, register struct ipq *);
-void ip_freef(struct ipq *);
-void ip_enq(register struct ipasfrag *, register struct ipasfrag *);
-void ip_deq(register struct ipasfrag *);
-void ip_slowtimo(void);
-void ip_stripoptions(register struct mbuf *, struct mbuf *);
+void ip_init _P((void));
+void ip_input _P((struct mbuf *));
+static struct ip *
+ip_reass(register struct ip *ip, register struct ipq *);
+void ip_freef _P((struct ipq *));
+void ip_enq _P((register struct ipasfrag *, register struct ipasfrag *));
+void ip_deq _P((register struct ipasfrag *));
+void ip_slowtimo _P((void));
+void ip_stripoptions _P((register struct mbuf *, struct mbuf *));
 
 /* ip_output.c */
-int ip_output(struct socket *, struct mbuf *);
+int ip_output _P((struct socket *, struct mbuf *));
 
 /* tcp_input.c */
-int tcp_reass(register struct tcpcb *, register struct tcpiphdr *, struct mbuf *);
-void tcp_input(register struct mbuf *, int, struct socket *);
-void tcp_dooptions(struct tcpcb *, u_char *, int, struct tcpiphdr *);
-void tcp_xmit_timer(register struct tcpcb *, int);
-u_int tcp_mss(register struct tcpcb *, u_int);
+int tcp_reass _P((register struct tcpcb *, register struct tcpiphdr *, struct mbuf *));
+void tcp_input _P((register struct mbuf *, int, struct socket *));
+void tcp_dooptions _P((struct tcpcb *, u_char *, int, struct tcpiphdr *));
+void tcp_xmit_timer _P((register struct tcpcb *, int));
+int tcp_mss _P((register struct tcpcb *, u_int));
 
 /* tcp_output.c */
-int tcp_output(register struct tcpcb *);
-void tcp_setpersist(register struct tcpcb *);
+int tcp_output _P((register struct tcpcb *));
+void tcp_setpersist _P((register struct tcpcb *));
 
 /* tcp_subr.c */
-void tcp_init(void);
-void tcp_template(struct tcpcb *);
-void tcp_respond(struct tcpcb *, register struct tcpiphdr *, register struct mbuf *, tcp_seq, tcp_seq, int);
-struct tcpcb * tcp_newtcpcb(struct socket *);
-struct tcpcb * tcp_close(register struct tcpcb *);
-void tcp_drain(void);
-void tcp_sockclosed(struct tcpcb *);
-int tcp_fconnect(struct socket *);
-void tcp_connect(struct socket *);
-int tcp_attach(struct socket *);
-u_int8_t tcp_tos(struct socket *);
-int tcp_emu(struct socket *, struct mbuf *);
-int tcp_ctl(struct socket *);
+void tcp_init _P((void));
+void tcp_template _P((struct tcpcb *));
+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_drain _P((void));
+void tcp_sockclosed _P((struct tcpcb *));
+int tcp_fconnect _P((struct socket *));
+void tcp_connect _P((struct socket *));
+int tcp_attach _P((struct socket *));
+u_int8_t tcp_tos _P((struct socket *));
+int tcp_emu _P((struct socket *, struct mbuf *));
+int tcp_ctl _P((struct socket *));
 struct tcpcb *tcp_drop(struct tcpcb *tp, int err);
 
 #ifdef USE_PPP
@@ -355,4 +359,9 @@ struct tcpcb *tcp_drop(struct tcpcb *tp, int err);
 #define max(x,y) ((x) > (y) ? (x) : (y))
 #endif
 
+#ifdef _WIN32
+#undef errno
+#define errno (WSAGetLastError())
+#endif
+
 #endif

BasiliskII/src/slirp/slirp_config.h

@@ -40,6 +40,11 @@
  */
 #undef USE_LOWCPU
 
+/* Define this if your compiler doesn't like prototypes */
+#ifndef __STDC__
+#define NO_PROTOTYPES
+#endif
+
 /*********************************************************/
 /*
  * Autoconf defined configuration options
@@ -72,6 +77,9 @@
 /* Define if you have sys/stropts.h */
 #undef HAVE_SYS_STROPTS_H
 
+/* Define if your compiler doesn't like prototypes */
+#undef NO_PROTOTYPES
+
 /* Define if you don't have u_int32_t etc. typedef'd */
 #undef NEED_TYPEDEFS
 #ifdef __sun__

BasiliskII/src/slirp/socket.c

@@ -14,12 +14,6 @@
 #include <sys/filio.h>
 #endif
 
-#ifdef _WIN32
-#define IS_EAGAIN(e) ((e) == WSAEINTR || (e) == EAGAIN)
-#else
-#define IS_EAGAIN(e) ((e) == EAGAIN)
-#endif
-
 void
 so_init()
 {
@@ -103,12 +97,11 @@ int
 soread(so)
 	struct socket *so;
 {
-	int n, nn;
-	u_int lss, total;
+	int n, nn, lss, total;
 	struct sbuf *sb = &so->so_snd;
-	u_int len = sb->sb_datalen - sb->sb_cc;
+	int len = sb->sb_datalen - sb->sb_cc;
 	struct iovec iov[2];
-	u_int mss = so->so_tcpcb->t_maxseg;
+	int mss = so->so_tcpcb->t_maxseg;
 	
 	DEBUG_CALL("soread");
 	DEBUG_ARG("so = %lx", (long )so);
@@ -166,8 +159,7 @@ soread(so)
 	nn = recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
 #endif	
 	if (nn <= 0) {
-		int error = WSAGetLastError();
-		if (nn < 0 && IS_EAGAIN(error))
+		if (nn < 0 && (errno == EINTR || errno == EAGAIN))
 			return 0;
 		else {
 			DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
@@ -305,7 +297,7 @@ sowrite(so)
 {
 	int  n,nn;
 	struct sbuf *sb = &so->so_rcv;
-	u_int len = sb->sb_cc;
+	int len = sb->sb_cc;
 	struct iovec iov[2];
 	
 	DEBUG_CALL("sowrite");
@@ -352,12 +344,9 @@ sowrite(so)
 	nn = send(so->s, iov[0].iov_base, iov[0].iov_len,0);
 #endif
 	/* This should never happen, but people tell me it does *shrug* */
-	if (nn < 0) {
-		int error = WSAGetLastError();
-		if (IS_EAGAIN(error))
-			return 0;
-	}
-
+	if (nn < 0 && (errno == EAGAIN || errno == EINTR))
+		return 0;
+	
 	if (nn <= 0) {
 		DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
 			so->so_state, errno));
@@ -416,9 +405,8 @@ sorecvfrom(so)
 	  if(len == -1 || len == 0) {
 	    u_char code=ICMP_UNREACH_PORT;
 
-		int error = WSAGetLastError();
-	    if(error == WSAEHOSTUNREACH) code=ICMP_UNREACH_HOST;
-	    else if(error == WSAENETUNREACH) code=ICMP_UNREACH_NET;
+	    if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
+	    else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
 	    
 	    DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
 			errno,strerror(errno)));
@@ -431,7 +419,7 @@ sorecvfrom(so)
 	  udp_detach(so);
 	} else {                            	/* A "normal" UDP packet */
 	  struct mbuf *m;
-	  u_int len;
+	  int len;
 	  ioctlsockopt_t n;
 
 	  if (!(m = m_get())) return;
@@ -454,14 +442,13 @@ sorecvfrom(so)
 		
 	  m->m_len = recvfrom(so->s, m->m_data, len, 0,
 			      (struct sockaddr *)&addr, &addrlen);
-	  DEBUG_MISC((dfd, " did recvfrom %zu, errno = %d-%s\n",
+	  DEBUG_MISC((dfd, " did recvfrom %d, errno = %d-%s\n", 
 		      m->m_len, errno,strerror(errno)));
 	  if(m->m_len<0) {
 	    u_char code=ICMP_UNREACH_PORT;
 
-		int error = WSAGetLastError();
-	    if(error == WSAEHOSTUNREACH) code=ICMP_UNREACH_HOST;
-	    else if(error == WSAENETUNREACH) code=ICMP_UNREACH_NET;
+	    if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
+	    else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
 	    
 	    DEBUG_MISC((dfd," rx error, tx icmp ICMP_UNREACH:%i\n", code));
 	    icmp_error(so->so_m, ICMP_UNREACH,code, 0,strerror(errno));
@@ -526,9 +513,7 @@ sosendto(so, m)
 	  addr.sin_addr = so->so_faddr;
 	addr.sin_port = so->so_fport;
 
-	char addrstr[INET_ADDRSTRLEN];
-	DEBUG_MISC((dfd, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n",
-		ntohs(addr.sin_port), inet_ntop(AF_INET, &addr.sin_addr, addrstr, sizeof(addrstr))));
+	DEBUG_MISC((dfd, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n", ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));
 	
 	/* Don't care what port we get */
 	ret = sendto(so->s, m->m_data, m->m_len, 0,
@@ -599,12 +584,16 @@ solisten(port, laddr, lport, flags)
 	    (setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)) < 0) ||
 	    (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) ||
 	    (listen(s,1) < 0)) {
-		int error = WSAGetLastError(); /* Don't clobber the real reason we failed */
+		int tmperrno = errno; /* Don't clobber the real reason we failed */
 		
 		close(s);
 		sofree(so);
 		/* Restore the real errno */
-		WSASetLastError(error);
+#ifdef _WIN32
+		WSASetLastError(tmperrno);
+#else
+		errno = tmperrno;
+#endif
 		return NULL;
 	}
 	setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));

BasiliskII/src/slirp/socket.h

@@ -81,24 +81,24 @@ struct iovec {
 };
 #endif
 
-void so_init(void);
-struct socket * solookup(struct socket *, struct in_addr, u_int, struct in_addr, u_int);
-struct socket * socreate(void);
-void sofree(struct socket *);
-int soread(struct socket *);
-void sorecvoob(struct socket *);
-int sosendoob(struct socket *);
-int sowrite(struct socket *);
-void sorecvfrom(struct socket *);
-int sosendto(struct socket *, struct mbuf *);
-struct socket * solisten(u_int, u_int32_t, u_int, int);
-void sorwakeup(struct socket *);
-void sowwakeup(struct socket *);
-void soisfconnecting(register struct socket *);
-void soisfconnected(register struct socket *);
-void sofcantrcvmore(struct  socket *);
-void sofcantsendmore(struct socket *);
-void soisfdisconnected(struct socket *);
-void sofwdrain(struct socket *);
+void so_init _P((void));
+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 *));
+int soread _P((struct socket *));
+void sorecvoob _P((struct socket *));
+int sosendoob _P((struct socket *));
+int sowrite _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 sorwakeup _P((struct socket *));
+void sowwakeup _P((struct socket *));
+void soisfconnecting _P((register struct socket *));
+void soisfconnected _P((register struct socket *));
+void sofcantrcvmore _P((struct  socket *));
+void sofcantsendmore _P((struct socket *));
+void soisfdisconnected _P((struct socket *));
+void sofwdrain _P((struct socket *));
 
 #endif /* _SOCKET_H_ */

BasiliskII/src/slirp/tcp.h

@@ -38,8 +38,8 @@ typedef	u_int32_t	tcp_seq;
 #define      PR_SLOWHZ       2               /* 2 slow timeouts per second (approx) */
 #define      PR_FASTHZ       5               /* 5 fast timeouts per second (not important) */
 
-extern size_t tcp_rcvspace;
-extern size_t tcp_sndspace;
+extern int tcp_rcvspace;
+extern int tcp_sndspace;
 extern struct socket *tcp_last_so;
 
 #define TCP_SNDSPACE 8192
@@ -78,7 +78,7 @@ struct tcphdr {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 #include "tcp_var.h"

BasiliskII/src/slirp/tcp_output.c

@@ -63,7 +63,9 @@ u_char  tcp_outflags[TCP_NSTATES] = {
 /*
  * Tcp output routine: figure out what should be sent and send it.
  */
-int tcp_output(register struct tcpcb *tp)
+int
+tcp_output(tp)
+	register struct tcpcb *tp;
 {
 	register struct socket *so = tp->t_socket;
 	register long len, win;
@@ -124,7 +126,7 @@ again:
 			 * to send then the probe will be the FIN
 			 * itself.
 			 */
-			if (off < (int)so->so_snd.sb_cc)
+			if (off < so->so_snd.sb_cc)
 				flags &= ~TH_FIN;
 			win = 1;
 		} else {
@@ -199,12 +201,12 @@ again:
 		 * taking into account that we are limited by
 		 * TCP_MAXWIN << tp->rcv_scale.
 		 */
-		long adv = min(win, TCP_MAXWIN << tp->rcv_scale) -
+		long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale) -
 			(tp->rcv_adv - tp->rcv_nxt);
 
-		if (adv >= (long)(2 * tp->t_maxseg))
+		if (adv >= (long) (2 * tp->t_maxseg))
 			goto send;
-		if (2 * adv >= (long)so->so_rcv.sb_datalen)
+		if (2 * adv >= (long) so->so_rcv.sb_datalen)
 			goto send;
 	}
 
@@ -357,7 +359,7 @@ send:
 		 */
 /*		if (len <= MHLEN - hdrlen - max_linkhdr) { */
 
-			sbcopy(&so->so_snd, off, len, mtod(m, caddr_t) + hdrlen);
+			sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);
 			m->m_len += len;
 
 /*		} else {
@@ -433,12 +435,12 @@ send:
 	 * Calculate receive window.  Don't shrink window,
 	 * but avoid silly window syndrome.
 	 */
-	if (win < (so->so_rcv.sb_datalen / 4) && win < tp->t_maxseg)
+	if (win < (long)(so->so_rcv.sb_datalen / 4) && win < (long)tp->t_maxseg)
 		win = 0;
-	if (win > (u_long) (TCP_MAXWIN << tp->rcv_scale))
-		win = (u_long) (TCP_MAXWIN << tp->rcv_scale);
-	if (win < (tp->rcv_adv - tp->rcv_nxt))
-		win = (tp->rcv_adv - tp->rcv_nxt);
+	if (win > (long)TCP_MAXWIN << tp->rcv_scale)
+		win = (long)TCP_MAXWIN << tp->rcv_scale;
+	if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
+		win = (long)(tp->rcv_adv - tp->rcv_nxt);
 	ti->ti_win = htons((u_int16_t) (win>>tp->rcv_scale));
 	
 	if (SEQ_GT(tp->snd_up, tp->snd_una)) {
@@ -528,7 +530,7 @@ send:
 	
     {
 	    
-	((struct ip *)ti)->ip_len = (u_int16_t) m->m_len;
+	((struct ip *)ti)->ip_len = m->m_len;
 
 	((struct ip *)ti)->ip_ttl = ip_defttl;
 	((struct ip *)ti)->ip_tos = so->so_iptos;
@@ -579,7 +581,9 @@ out:
 	return (0);
 }
 
-void tcp_setpersist(register struct tcpcb *tp)
+void
+tcp_setpersist(tp)
+	register struct tcpcb *tp;
 {
     int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
 

BasiliskII/src/slirp/tcp_subr.c

@@ -46,13 +46,14 @@
 int 	tcp_mssdflt = TCP_MSS;
 int 	tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
 int	tcp_do_rfc1323 = 0;	/* Don't do rfc1323 performance enhancements */
-size_t	tcp_rcvspace;	/* You may want to change this */
-size_t	tcp_sndspace;	/* Keep small if you have an error prone link */
+int	tcp_rcvspace;	/* You may want to change this */
+int	tcp_sndspace;	/* Keep small if you have an error prone link */
 
 /*
  * Tcp initialization
  */
-void tcp_init()
+void
+tcp_init()
 {
 	tcp_iss = 1;		/* wrong */
 	tcb.so_next = tcb.so_prev = &tcb;
@@ -73,12 +74,14 @@ void tcp_init()
  * necessary when the connection is used.
  */
 /* struct tcpiphdr * */
-void tcp_template(struct tcpcb *tp)
+void
+tcp_template(tp)
+	struct tcpcb *tp;
 {
 	struct socket *so = tp->t_socket;
 	register struct tcpiphdr *n = &tp->t_template;
 
-	n->ti_next = n->ti_prev = 0;
+	n->ti_mbuf = NULL;
 	n->ti_x1 = 0;
 	n->ti_pr = IPPROTO_TCP;
 	n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
@@ -110,8 +113,13 @@ void tcp_template(struct tcpcb *tp)
  * In any case the ack and sequence number of the transmitted
  * segment are as specified by the parameters.
  */
-void tcp_respond(struct tcpcb *tp, register struct tcpiphdr *ti,
-	register struct mbuf *m, tcp_seq ack, tcp_seq seq, int flags)
+void
+tcp_respond(tp, ti, m, ack, seq, flags)
+	struct tcpcb *tp;
+	register struct tcpiphdr *ti;
+	register struct mbuf *m;
+	tcp_seq ack, seq;
+	int flags;
 {
 	register int tlen;
 	int win = 0;
@@ -156,7 +164,7 @@ void tcp_respond(struct tcpcb *tp, register struct tcpiphdr *ti,
 	tlen += sizeof (struct tcpiphdr);
 	m->m_len = tlen;
 
-	ti->ti_next = ti->ti_prev = 0;
+	ti->ti_mbuf = 0;
 	ti->ti_x1 = 0;
 	ti->ti_seq = htonl(seq);
 	ti->ti_ack = htonl(ack);
@@ -185,7 +193,9 @@ void tcp_respond(struct tcpcb *tp, register struct tcpiphdr *ti,
  * empty reassembly queue and hooking it to the argument
  * protocol control block.
  */
-struct tcpcb *tcp_newtcpcb(struct socket *so)
+struct tcpcb *
+tcp_newtcpcb(so)
+	struct socket *so;
 {
 	register struct tcpcb *tp;
 	
@@ -194,7 +204,7 @@ struct tcpcb *tcp_newtcpcb(struct socket *so)
 		return ((struct tcpcb *)0);
 	
 	memset((char *) tp, 0, sizeof(struct tcpcb));
-	tp->seg_next = tp->seg_prev = (tcpiphdrp_32)tp;
+	tp->seg_next = tp->seg_prev = (struct tcpiphdr*)tp;
 	tp->t_maxseg = tcp_mssdflt;
 	
 	tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
@@ -258,7 +268,9 @@ struct tcpcb *tcp_drop(struct tcpcb *tp, int err)
  *	discard internet protocol block
  *	wake up any sleepers
  */
-struct tcpcb *tcp_close(register struct tcpcb *tp)
+struct tcpcb *
+tcp_close(tp)
+	register struct tcpcb *tp;
 {
 	register struct tcpiphdr *t;
 	struct socket *so = tp->t_socket;
@@ -268,11 +280,11 @@ struct tcpcb *tcp_close(register struct tcpcb *tp)
 	DEBUG_ARG("tp = %lx", (long )tp);
 	
 	/* free the reassembly queue, if any */
-	t = (struct tcpiphdr *) tp->seg_next;
-	while (t != (struct tcpiphdr *)tp) {
-		t = (struct tcpiphdr *)t->ti_next;
-		m = (struct mbuf *) REASS_MBUF((struct tcpiphdr *)t->ti_prev);
-		remque_32((struct tcpiphdr *) t->ti_prev);
+	t = tcpfrag_list_first(tp);
+	while (!tcpfrag_list_end(t, tp)) {
+		t = tcpiphdr_next(t);
+		m = tcpiphdr_prev(t)->ti_mbuf;
+		remque(tcpiphdr2qlink(tcpiphdr_prev(t)));
 		m_freem(m);
 	}
 	/* It's static */
@@ -294,7 +306,8 @@ struct tcpcb *tcp_close(register struct tcpcb *tp)
 	return ((struct tcpcb *)0);
 }
 
-void tcp_drain()
+void
+tcp_drain()
 {
 	/* XXX */
 }
@@ -306,7 +319,10 @@ void tcp_drain()
 
 #ifdef notdef
 
-void tcp_quench(int i, int errno)
+void
+tcp_quench(i, errno)
+
+	int errno;
 {
 	struct tcpcb *tp = intotcpcb(inp);
 
@@ -330,7 +346,9 @@ void tcp_quench(int i, int errno)
  * for peer to send FIN or not respond to keep-alives, etc.
  * We can let the user exit from the close as soon as the FIN is acked.
  */
-void tcp_sockclosed(struct tcpcb *tp)
+void
+tcp_sockclosed(tp)
+	struct tcpcb *tp;
 {
 
 	DEBUG_CALL("tcp_sockclosed");
@@ -371,7 +389,8 @@ void tcp_sockclosed(struct tcpcb *tp)
  * nonblocking.  Connect returns after the SYN is sent, and does 
  * not wait for ACK+SYN.
  */
-int tcp_fconnect(struct socket *so)
+int tcp_fconnect(so)
+     struct socket *so;
 {
   int ret=0;
   
@@ -404,12 +423,10 @@ int tcp_fconnect(struct socket *so)
     } else
       addr.sin_addr = so->so_faddr;
     addr.sin_port = so->so_fport;
-
-	char addrstr[INET_ADDRSTRLEN];
+    
     DEBUG_MISC((dfd, " connect()ing, addr.sin_port=%d, "
 		"addr.sin_addr.s_addr=%.16s\n", 
-		ntohs(addr.sin_port), inet_ntop(AF_INET, &addr.sin_addr,
-			addrstr, sizeof(addrstr))));
+		ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));
     /* We don't care what port we get */
     ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
     
@@ -435,7 +452,9 @@ int tcp_fconnect(struct socket *so)
  * the time it gets to accept(), so... We simply accept
  * here and SYN the local-host.
  */ 
-void tcp_connect(struct socket *inso)
+void
+tcp_connect(inso)
+	struct socket *inso;
 {
 	struct socket *so;
 	struct sockaddr_in addr;
@@ -467,7 +486,7 @@ void tcp_connect(struct socket *inso)
 		so->so_lport = inso->so_lport;
 	}
 	
-	tcp_mss(sototcpcb(so), 0);
+	(void) tcp_mss(sototcpcb(so), 0);
 
 	if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
 		tcp_close(sototcpcb(so)); /* This will sofree() as well */
@@ -520,7 +539,9 @@ void tcp_connect(struct socket *inso)
 /*
  * Attach a TCPCB to a socket.
  */
-int tcp_attach(struct socket *so)
+int
+tcp_attach(so)
+	struct socket *so;
 {
 	if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL)
 	   return -1;
@@ -554,7 +575,9 @@ struct emu_t *tcpemu = 0;
 /*
  * Return TOS according to the above table
  */
-u_int8_t tcp_tos(struct socket *so)
+u_int8_t
+tcp_tos(so)
+	struct socket *so;
 {
 	int i = 0;
 	struct emu_t *emup;
@@ -606,7 +629,10 @@ int do_echo = -1;
  * 
  * NOTE: if you return 0 you MUST m_free() the mbuf!
  */
-int tcp_emu(struct socket *so, struct mbuf *m)
+int
+tcp_emu(so, m)
+	struct socket *so;
+	struct mbuf *m;
 {
 	u_int n1, n2, n3, n4, n5, n6;
 	char buff[256];
@@ -807,7 +833,7 @@ int tcp_emu(struct socket *so, struct mbuf *m)
 				ns->so_laddr=so->so_laddr;
 				ns->so_lport=htons(port);
 
-				tcp_mss(sototcpcb(ns), 0);
+				(void) tcp_mss(sototcpcb(ns), 0);
 
 				ns->so_faddr=so->so_faddr;
 				ns->so_fport=htons(IPPORT_RESERVED-1); /* Use a fake port. */
@@ -1034,7 +1060,7 @@ do_prompt:
 		 * of the connection as a NUL-terminated decimal ASCII string.
 		 */
 		so->so_emu = 0;
-		for (lport = 0, i = 0; i < (int) (m->m_len-1); ++i) {
+		for (lport = 0, i = 0; i < m->m_len-1; ++i) {
 			if (m->m_data[i] < '0' || m->m_data[i] > '9')
 				return 1;       /* invalid number */
 			lport *= 10;
@@ -1219,7 +1245,9 @@ do_prompt:
  * Return 0 if this connections is to be closed, 1 otherwise,
  * return 2 if this is a command-line connection
  */
-int tcp_ctl(struct socket *so)
+int
+tcp_ctl(so)
+	struct socket *so;
 {
 	struct sbuf *sb = &so->so_snd;
 	int command;

BasiliskII/src/slirp/tcp_timer.h

@@ -130,9 +130,9 @@ extern int tcp_backoff[];
 
 struct tcpcb;
 
-void tcp_fasttimo(void);
-void tcp_slowtimo(void);
-void tcp_canceltimers(struct tcpcb *);
-struct tcpcb * tcp_timers(register struct tcpcb *, int);
+void tcp_fasttimo _P((void));
+void tcp_slowtimo _P((void));
+void tcp_canceltimers _P((struct tcpcb *));
+struct tcpcb * tcp_timers _P((register struct tcpcb *, int));
 
 #endif

BasiliskII/src/slirp/tcp_var.h

@@ -36,18 +36,12 @@
 #include "tcpip.h"
 #include "tcp_timer.h"
 
-#if SIZEOF_CHAR_P == 4
- typedef struct tcpiphdr *tcpiphdrp_32;
-#else
- typedef u_int32_t tcpiphdrp_32;
-#endif
-
 /*
  * Tcp control block, one per tcp; fields:
  */
 struct tcpcb {
-	tcpiphdrp_32 seg_next;	/* sequencing queue */
-	tcpiphdrp_32 seg_prev;
+	struct tcpiphdr *seg_next;	/* sequencing queue */
+	struct tcpiphdr *seg_prev;
 	short	t_state;		/* state of this connection */
 	short	t_timer[TCPT_NTIMERS];	/* tcp timers */
 	short	t_rxtshift;		/* log(2) of rexmt exp. backoff */
@@ -166,21 +160,6 @@ struct tcpcb {
 #define	TCP_REXMTVAL(tp) \
 	(((tp)->t_srtt >> TCP_RTT_SHIFT) + (tp)->t_rttvar)
 
-/* XXX
- * We want to avoid doing m_pullup on incoming packets but that
- * means avoiding dtom on the tcp reassembly code.  That in turn means
- * keeping an mbuf pointer in the reassembly queue (since we might
- * have a cluster).  As a quick hack, the source & destination
- * port numbers (which are no longer needed once we've located the
- * tcpcb) are overlayed with an mbuf pointer.
- */
-#if SIZEOF_CHAR_P == 4
-typedef struct mbuf *mbufp_32;
-#else
-typedef u_int32_t mbufp_32;
-#endif
-#define REASS_MBUF(ti) (*(mbufp_32 *)&((ti)->ti_t))
-
 /*
  * TCP statistics.
  * Many of these should be kept per connection,

BasiliskII/src/slirp/tcpip.h

@@ -40,8 +40,7 @@ struct tcpiphdr {
 	struct 	ipovly ti_i;		/* overlaid ip structure */
 	struct	tcphdr ti_t;		/* tcp header */
 };
-#define	ti_next		ti_i.ih_next
-#define	ti_prev		ti_i.ih_prev
+#define	ti_mbuf		ti_i.ih_mbuf.mptr
 #define	ti_x1		ti_i.ih_x1
 #define	ti_pr		ti_i.ih_pr
 #define	ti_len		ti_i.ih_len
@@ -58,6 +57,14 @@ struct tcpiphdr {
 #define	ti_sum		ti_t.th_sum
 #define	ti_urp		ti_t.th_urp
 
+#define tcpiphdr2qlink(T) ((struct qlink*)(((char*)(T)) - sizeof(struct qlink)))
+#define qlink2tcpiphdr(Q) ((struct tcpiphdr*)(((char*)(Q)) + sizeof(struct qlink)))
+#define tcpiphdr_next(T) qlink2tcpiphdr(tcpiphdr2qlink(T)->next)
+#define tcpiphdr_prev(T) qlink2tcpiphdr(tcpiphdr2qlink(T)->prev)
+#define tcpfrag_list_first(T) qlink2tcpiphdr((T)->seg_next)
+#define tcpfrag_list_end(F, T) (tcpiphdr2qlink(F) == (struct qlink*)(T))
+#define tcpfrag_list_empty(T) ((T)->seg_next == (struct tcpiphdr*)(T))
+
 /*
  * Just a clean way to get to the first byte
  * of the packet

BasiliskII/src/slirp/tftp.c

@@ -127,6 +127,7 @@ static int tftp_send_error(struct tftp_session *spt,
   struct sockaddr_in saddr, daddr;
   struct mbuf *m;
   struct tftp_t *tp;
+  int nobytes;
 
   m = m_get();
 
@@ -151,6 +152,8 @@ static int tftp_send_error(struct tftp_session *spt,
   daddr.sin_addr = spt->client_ip;
   daddr.sin_port = spt->client_port;
 
+  nobytes = 2;
+
   m->m_len = sizeof(struct tftp_t) - 514 + 3 + strlen(msg) - 
         sizeof(struct ip) - sizeof(struct udphdr);
 

BasiliskII/src/slirp/tftp.h

@@ -34,7 +34,7 @@ struct tftp_t {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 void tftp_input(struct mbuf *m);

BasiliskII/src/slirp/udp.c

@@ -128,8 +128,7 @@ udp_input(m, iphlen)
 	 * Checksum extended UDP header and data.
 	 */
 	if (udpcksum && uh->uh_sum) {
-	  ((struct ipovly *)ip)->ih_next = 0;
-	  ((struct ipovly *)ip)->ih_prev = 0;
+	  memset(&((struct ipovly *)ip)->ih_mbuf, 0, sizeof(struct mbuf_ptr));
 	  ((struct ipovly *)ip)->ih_x1 = 0;
 	  ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
 	  /* keep uh_sum for ICMP reply
@@ -272,10 +271,10 @@ int udp_output2(struct socket *so, struct mbuf *m,
 	 * and addresses and length put into network format.
 	 */
 	ui = mtod(m, struct udpiphdr *);
-	ui->ui_next = ui->ui_prev = 0;
+    memset(&ui->ui_i.ih_mbuf, 0 , sizeof(struct mbuf_ptr));
 	ui->ui_x1 = 0;
 	ui->ui_pr = IPPROTO_UDP;
-	ui->ui_len = htons((u_short) (m->m_len - sizeof(struct ip))); /* + sizeof (struct udphdr)); */
+	ui->ui_len = htons(m->m_len - sizeof(struct ip)); /* + sizeof (struct udphdr)); */
 	/* XXXXX Check for from-one-location sockets, or from-any-location sockets */
         ui->ui_src = saddr->sin_addr;
 	ui->ui_dst = daddr->sin_addr;
@@ -291,7 +290,7 @@ int udp_output2(struct socket *so, struct mbuf *m,
 	    if ((ui->ui_sum = cksum(m, /* sizeof (struct udpiphdr) + */ m->m_len)) == 0)
 		ui->ui_sum = 0xffff;
 	}
-	((struct ip *)ui)->ip_len = (u_int16_t) m->m_len;
+	((struct ip *)ui)->ip_len = m->m_len;
 
 	((struct ip *)ui)->ip_ttl = ip_defttl;
 	((struct ip *)ui)->ip_tos = iptos;
@@ -338,10 +337,14 @@ udp_attach(so)
     addr.sin_port = 0;
     addr.sin_addr.s_addr = INADDR_ANY;
     if(bind(so->s, (struct sockaddr *)&addr, sizeof(addr))<0) {
-      int error = WSAGetLastError();
+      int lasterrno=errno;
       closesocket(so->s);
       so->s=-1;
-      WSASetLastError(error);
+#ifdef _WIN32
+      WSASetLastError(lasterrno);
+#else
+      errno=lasterrno;
+#endif
     } else {
       /* success, insert in queue */
       so->so_expire = curtime + SO_EXPIRE;

BasiliskII/src/slirp/udp.h

@@ -54,7 +54,7 @@ struct udphdr {
 } PACKED__;
 
 #ifdef PRAGMA_PACK_SUPPORTED
-#pragma pack(PACK_RESET)
+#pragma pack(0)
 #endif
 
 /*
@@ -64,8 +64,7 @@ struct udpiphdr {
 	        struct  ipovly ui_i;            /* overlaid ip structure */
 	        struct  udphdr ui_u;            /* udp header */
 };
-#define ui_next         ui_i.ih_next
-#define ui_prev         ui_i.ih_prev
+#define ui_mbuf         ui_i.ih_mbuf.mptr
 #define ui_x1           ui_i.ih_x1
 #define ui_pr           ui_i.ih_pr
 #define ui_len          ui_i.ih_len
@@ -100,14 +99,14 @@ extern struct udpstat udpstat;
 extern struct socket udb;
 struct mbuf;
 
-void udp_init(void);
-void udp_input(register struct mbuf *, int);
-int udp_output(struct socket *, struct mbuf *, struct sockaddr_in *);
-int udp_attach(struct socket *);
-void udp_detach(struct socket *);
-u_int8_t udp_tos(struct socket *);
-void udp_emu(struct socket *, struct mbuf *);
-struct socket * udp_listen(u_int, u_int32_t, u_int, int);
+void udp_init _P((void));
+void udp_input _P((register struct mbuf *, int));
+int udp_output _P((struct socket *, struct mbuf *, struct sockaddr_in *));
+int udp_attach _P((struct socket *));
+void udp_detach _P((struct socket *));
+u_int8_t udp_tos _P((struct socket *));
+void udp_emu _P((struct socket *, struct mbuf *));
+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,
                 int iptos);