Macintosh-Tools
/
macemu
mirror of https://github.com/kanjitalk755/macemu.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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

This commit is contained in:
kanjitalk755 2017-12-06 15:35:41 +09:00
parent e42b6a50c3
commit a944344f84
40 changed files with 1226 additions and 1129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BasiliskII/src/slirp/VERSION
View File

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

0
BasiliskII/src/slirp/bootp.c Normal file → Executable file
View File

2
BasiliskII/src/slirp/bootp.h Normal file → Executable file
View File

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

0
BasiliskII/src/slirp/cksum.c Normal file → Executable file
View File

0
BasiliskII/src/slirp/ctl.h Normal file → Executable file
View File

15
BasiliskII/src/slirp/debug.c Normal file → Executable file
View File

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

22
BasiliskII/src/slirp/debug.h Normal file → Executable file
View File

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

0
BasiliskII/src/slirp/icmp_var.h Normal file → Executable file
View File

9
BasiliskII/src/slirp/if.c Normal file → Executable file
View File

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

4
BasiliskII/src/slirp/if.h Normal file → Executable file
View File

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

70
BasiliskII/src/slirp/ip.h Normal file → Executable file
View File

@ -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.

26
BasiliskII/src/slirp/ip_icmp.c Normal file → Executable file
View File

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

8
BasiliskII/src/slirp/ip_icmp.h Normal file → Executable file
View File

@ -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

154
BasiliskII/src/slirp/ip_input.c Normal file → Executable file
View File

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

9
BasiliskII/src/slirp/ip_output.c Normal file → Executable file
View File

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

0
BasiliskII/src/slirp/libslirp.h Normal file → Executable file
View File

0
BasiliskII/src/slirp/main.h Normal file → Executable file
View File

37
BasiliskII/src/slirp/mbuf.c Normal file → Executable file
View File

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

22
BasiliskII/src/slirp/mbuf.h Normal file → Executable file
View File

@ -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

192
BasiliskII/src/slirp/misc.c Normal file → Executable file
View File

@ -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];

38
BasiliskII/src/slirp/misc.h Normal file → Executable file
View File

@ -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

35
BasiliskII/src/slirp/sbuf.c Normal file → Executable file
View File

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

14
BasiliskII/src/slirp/sbuf.h Normal file → Executable file
View File

@ -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

190
BasiliskII/src/slirp/slirp.c Normal file → Executable file
View File

@ -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

133
BasiliskII/src/slirp/slirp.h Normal file → Executable file
View File

@ -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

8
BasiliskII/src/slirp/slirp_config.h Normal file → Executable file
View File

@ -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__

53
BasiliskII/src/slirp/socket.c Normal file → Executable file
View File

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

38
BasiliskII/src/slirp/socket.h Normal file → Executable file
View File

@ -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_ */

6
BasiliskII/src/slirp/tcp.h Normal file → Executable file
View File

@ -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"

1060
BasiliskII/src/slirp/tcp_input.c Normal file → Executable file
View File

File diff suppressed because it is too large Load Diff

30
BasiliskII/src/slirp/tcp_output.c Normal file → Executable file
View File

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

92
BasiliskII/src/slirp/tcp_subr.c Normal file → Executable file
View File

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

0
BasiliskII/src/slirp/tcp_timer.c Normal file → Executable file
View File

8
BasiliskII/src/slirp/tcp_timer.h Normal file → Executable file
View File

@ -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

25
BasiliskII/src/slirp/tcp_var.h Normal file → Executable file
View File

@ -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,

11
BasiliskII/src/slirp/tcpip.h Normal file → Executable file
View File

@ -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

3
BasiliskII/src/slirp/tftp.c Normal file → Executable file
View File

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

2
BasiliskII/src/slirp/tftp.h Normal file → Executable file
View File

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

17
BasiliskII/src/slirp/udp.c Normal file → Executable file
View File

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

21
BasiliskII/src/slirp/udp.h Normal file → Executable file
View File

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