Macintosh-Tools/macemu
1
0
Fork 0
mirror of https://github.com/kanjitalk755/macemu.git synced 2024-11-22 13:31:08 +00:00
Code Issues Projects Releases Wiki Activity

slirp compiles cleanly in MSVC.

Browse Source 
Use standard C prototypes instead of K&R.
This commit is contained in:
James Touton 2015-08-06 01:11:28 -07:00
parent 3271fc9d28
commit 0daa18ab2a
29 changed files with 921 additions and 1071 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BasiliskII/src/slirp/bootp.h
View File

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

15
BasiliskII/src/slirp/debug.c
View File

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

22
BasiliskII/src/slirp/debug.h
View File

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

9
BasiliskII/src/slirp/if.c
View File

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

4
BasiliskII/src/slirp/if.h
View File

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

6
BasiliskII/src/slirp/ip.h
View File

@ -98,7 +98,7 @@ struct ip {
} PACKED__;
#ifdef PRAGMA_PACK_SUPPORTED
#pragma pack(0)
#pragma pack(PACK_RESET)
#endif
#define IP_MAXPACKET 65535 /* maximum packet size */
@ -168,7 +168,7 @@ struct ip_timestamp {
} PACKED__;
#ifdef PRAGMA_PACK_SUPPORTED
#pragma pack(0)
#pragma pack(PACK_RESET)
#endif
/* flag bits for ipt_flg */
@ -230,7 +230,7 @@ struct ipovly {
} PACKED__;
#ifdef PRAGMA_PACK_SUPPORTED
#pragma pack(0)
#pragma pack(PACK_RESET)
#endif
/*

10
BasiliskII/src/slirp/ip_icmp.c
View File

@ -223,9 +223,9 @@ icmp_error(msrc, type, code, minsize, message)
if(!msrc) goto end_error;
ip = mtod(msrc, struct ip *);
#if DEBUG
{ char bufa[20], bufb[20];
strcpy(bufa, inet_ntoa(ip->ip_src));
strcpy(bufb, inet_ntoa(ip->ip_dst));
{ 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));
DEBUG_MISC((dfd, " %.16s to %.16s\n", bufa, bufb));
}
#endif
@ -244,7 +244,7 @@ icmp_error(msrc, type, code, minsize, message)
/* make a copy */
if(!(m=m_get())) goto end_error; /* get mbuf */
{ int new_m_size;
{ u_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(msrc, type, code, minsize, message)
/* fill in ip */
ip->ip_hl = hlen >> 2;
ip->ip_len = m->m_len;
ip->ip_len = (u_int16_t)m->m_len;
ip->ip_tos=((ip->ip_tos & 0x1E) | 0xC0); /* high priority for errors */

8
BasiliskII/src/slirp/ip_icmp.h
View File

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

2
BasiliskII/src/slirp/ip_input.c
View File

@ -68,7 +68,7 @@ ip_input(m)
struct mbuf *m;
{
register struct ip *ip;
int hlen;
u_int hlen;
DEBUG_CALL("ip_input");
DEBUG_ARG("m = %lx", (long)m);

9
BasiliskII/src/slirp/ip_output.c
View File

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

37
BasiliskII/src/slirp/mbuf.c
View File

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

22
BasiliskII/src/slirp/mbuf.h
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 */
int mh_size; /* Size of data */
size_t mh_size; /* Size of data */
struct socket *mh_so;
caddr_t mh_data; /* Location of data */
int mh_len; /* Amount of data in this mbuf */
size_t 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 _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 *));
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 *);
#endif

170
BasiliskII/src/slirp/misc.c
View File

@ -17,10 +17,7 @@ int x_port = -1;
int x_display = 0;
int x_screen = 0;
int
show_x(buff, inso)
char *buff;
struct socket *inso;
int show_x(char *buff, struct socket *inso)
{
if (x_port < 0) {
lprint("X Redir: X not being redirected.\r\n");
@ -40,12 +37,7 @@ show_x(buff, inso)
/*
* XXX Allow more than one X redirection?
*/
void
redir_x(inaddr, start_port, display, screen)
u_int32_t inaddr;
int start_port;
int display;
int screen;
void redir_x(u_int32_t inaddr, int start_port, int display, int screen)
{
int i;
@ -69,34 +61,34 @@ redir_x(inaddr, start_port, display, screen)
#endif
#ifndef HAVE_INET_ATON
int
inet_aton(cp, ia)
const char *cp;
struct in_addr *ia;
int inet_aton(const char *cp, struct in_addr *ia)
{
u_int32_t addr = inet_addr(cp);
if (addr == 0xffffffff)
return 0;
ia->s_addr = addr;
return 1;
return inet_pton(AF_INET, cp, &ia->s_addr);
}
#endif
/*
* Get our IP address and put it in our_addr
*/
void
getouraddr()
void getouraddr()
{
char buff[256];
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;
{
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;
}
#if SIZEOF_CHAR_P == 8
@ -106,10 +98,7 @@ struct quehead_32 {
u_int32_t qh_rlink;
};
inline void
insque_32(a, b)
void *a;
void *b;
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;
@ -120,9 +109,7 @@ insque_32(a, b)
= (u_int32_t)element;
}
inline void
remque_32(a)
void *a;
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;
@ -137,9 +124,7 @@ struct quehead {
struct quehead *qh_rlink;
};
void
insque(a, b)
void *a, *b;
void insque(void *a, void *b)
{
register struct quehead *element = (struct quehead *) a;
register struct quehead *head = (struct quehead *) b;
@ -150,9 +135,7 @@ insque(a, b)
= (struct quehead *)element;
}
void
remque(a)
void *a;
void remque(void *a)
{
register struct quehead *element = (struct quehead *) a;
((struct quehead *)(element->qh_link))->qh_rlink = element->qh_rlink;
@ -164,13 +147,7 @@ remque(a)
/* #endif */
int
add_exec(ex_ptr, do_pty, exec, addr, port)
struct ex_list **ex_ptr;
int do_pty;
char *exec;
int addr;
int port;
int add_exec(struct ex_list **ex_ptr, int do_pty, char *exec, int addr, int port)
{
struct ex_list *tmp_ptr;
@ -199,9 +176,7 @@ add_exec(ex_ptr, do_pty, exec, addr, port)
extern int sys_nerr;
extern char *sys_errlist[];
char *
strerror(error)
int error;
char *strerror(int error)
{
if (error < sys_nerr)
return sys_errlist[error];
@ -214,11 +189,7 @@ strerror(error)
#ifdef _WIN32
int
fork_exec(so, ex, do_pty)
struct socket *so;
char *ex;
int do_pty;
int fork_exec(struct socket *so, char *ex, int do_pty)
{
/* not implemented */
return 0;
@ -226,9 +197,7 @@ fork_exec(so, ex, do_pty)
#else
int
slirp_openpty(amaster, aslave)
int *amaster, *aslave;
int slirp_openpty(int *amaster, int *aslave)
{
register int master, slave;
@ -302,11 +271,7 @@ slirp_openpty(amaster, aslave)
* do_pty = 1 Fork/exec using slirp.telnetd
* do_ptr = 2 Fork/exec using pty
*/
int
fork_exec(so, ex, do_pty)
struct socket *so;
char *ex;
int do_pty;
int fork_exec(struct socket *so, char *ex, int do_pty)
{
int s;
struct sockaddr_in addr;
@ -462,9 +427,7 @@ fork_exec(so, ex, do_pty)
#endif
#ifndef HAVE_STRDUP
char *
strdup(str)
const char *str;
char *strdup(const char *str)
{
char *bptr;
@ -476,9 +439,7 @@ strdup(str)
#endif
#if 0
void
snooze_hup(num)
int num;
void snooze_hup(int num)
{
int s, ret;
#ifndef NO_UNIX_SOCKETS
@ -518,8 +479,7 @@ snooze_hup(num)
}
void
snooze()
void snooze()
{
sigset_t s;
int i;
@ -543,9 +503,7 @@ snooze()
exit(255);
}
void
relay(s)
int s;
void relay(int s)
{
char buf[8192];
int n;
@ -605,25 +563,14 @@ relay(s)
}
#endif
int (*lprint_print) _P((void *, const char *, va_list));
int (*lprint_print)(void *, const char *, va_list);
char *lprint_ptr, *lprint_ptr2, **lprint_arg;
void
#ifdef __STDC__
lprint(const char *format, ...)
#else
lprint(va_alist) va_dcl
#endif
void lprint(const char *format, ...)
{
va_list args;
#ifdef __STDC__
va_start(args, format);
#else
char *format;
va_start(args);
format = va_arg(args, char *);
#endif
va_start(args, format);
#if 0
/* If we're printing to an sbuf, make sure there's enough room */
/* XXX +100? */
@ -672,9 +619,7 @@ lprint(va_alist) va_dcl
va_end(args);
}
void
add_emu(buff)
char *buff;
void add_emu(char *buff)
{
u_int lport, fport;
u_int8_t tos = 0, emu = 0;
@ -766,42 +711,24 @@ add_emu(buff)
* Some BSD-derived systems have a sprintf which returns char *
*/
int
vsprintf_len(string, format, args)
char *string;
const char *format;
va_list args;
int vsprintf_len(char *string, const char *format, va_list args)
{
vsprintf(string, format, args);
return strlen(string);
}
int
#ifdef __STDC__
sprintf_len(char *string, const char *format, ...)
#else
sprintf_len(va_alist) va_dcl
#endif
int sprintf_len(char *string, const char *format, ...)
{
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(usec)
int usec;
void u_sleep(int usec)
{
struct timeval t;
fd_set fdset;
@ -818,9 +745,7 @@ u_sleep(usec)
* Set fd blocking and non-blocking
*/
void
fd_nonblock(fd)
int fd;
void fd_nonblock(int fd)
{
#if defined USE_FIONBIO && defined FIONBIO
ioctlsockopt_t opt = 1;
@ -835,9 +760,7 @@ fd_nonblock(fd)
#endif
}
void
fd_block(fd)
int fd;
void fd_block(int fd)
{
#if defined USE_FIONBIO && defined FIONBIO
ioctlsockopt_t opt = 0;
@ -857,13 +780,8 @@ fd_block(fd)
/*
* invoke RSH
*/
int
rsh_exec(so,ns, user, host, args)
struct socket *so;
struct socket *ns;
char *user;
char *host;
char *args;
int rsh_exec(struct socket *so, struct socket *ns,
char *user, char *host, char *args)
{
int fd[2];
int fd0[2];

38
BasiliskII/src/slirp/misc.h
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) _P((void *, const char *, va_list));
extern int (*lprint_print)(void *, const char *, va_list);
extern char *lprint_ptr, *lprint_ptr2, **lprint_arg;
extern struct sbuf *lprint_sb;
#ifndef HAVE_STRDUP
char *strdup _P((const char *));
char *strdup(const char *);
#endif
void do_wait _P((int));
void do_wait(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 _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 *));
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 *);
#endif

31
BasiliskII/src/slirp/sbuf.c
View File

@ -16,17 +16,12 @@
* }
*/
void
sbfree(sb)
struct sbuf *sb;
void sbfree(struct sbuf *sb)
{
free(sb->sb_data);
}
void
sbdrop(sb, num)
struct sbuf *sb;
int num;
void sbdrop(struct sbuf *sb, u_int num)
{
/*
* We can only drop how much we have
@ -41,10 +36,7 @@ sbdrop(sb, num)
}
void
sbreserve(sb, size)
struct sbuf *sb;
int size;
void sbreserve(struct sbuf *sb, size_t size)
{
if (sb->sb_data) {
/* Already alloced, realloc if necessary */
@ -72,10 +64,7 @@ sbreserve(sb, size)
* this prevents an unnecessary copy of the data
* (the socket is non-blocking, so we won't hang)
*/
void
sbappend(so, m)
struct socket *so;
struct mbuf *m;
void sbappend(struct socket *so, struct mbuf *m)
{
int ret = 0;
@ -134,10 +123,7 @@ sbappend(so, m)
* Copy the data from m into sb
* The caller is responsible to make sure there's enough room
*/
void
sbappendsb(sb, m)
struct sbuf *sb;
struct mbuf *m;
void sbappendsb(struct sbuf *sb, struct mbuf *m)
{
int len, n, nn;
@ -173,12 +159,7 @@ sbappendsb(sb, m)
* Don't update the sbuf rptr, this will be
* done in sbdrop when the data is acked
*/
void
sbcopy(sb, off, len, to)
struct sbuf *sb;
int off;
int len;
char *to;
void sbcopy(struct sbuf *sb, u_int off, u_int len, char *to)
{
char *from;

14
BasiliskII/src/slirp/sbuf.h
View File

@ -8,6 +8,8 @@
#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)
@ -21,11 +23,11 @@ struct sbuf {
char *sb_data; /* Actual data */
};
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 *));
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 *);
#endif

184
BasiliskII/src/slirp/slirp.c
View File

@ -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,86 +407,92 @@ 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, &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
*/
/*
* 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
*/
}
/*
* 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 */
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 */
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 */
#endif
}
}
/*
* Now UDP sockets.
* Incoming packets are sent straight away, they're not buffered.
@ -494,27 +500,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

140
BasiliskII/src/slirp/slirp.h
View File

@ -22,18 +22,12 @@ 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
@ -41,6 +35,14 @@ typedef unsigned long ioctlsockopt_t;
# define init_udp slirp_init_udp
# define final_udp slirp_final_udp
#else
# define WSAGetLastError() (int)(errno)
# define WSASetLastError(e) (void)(errno = (e))
# define WSAEWOULDBLOCK EWOULDBLOCK
# define WSAEINPROGRESS EINPROGRESS
# define WSAENOTCONN ENOTCONN
# define WSAEHOSTUNREACH EHOSTUNREACH
# define WSAENETUNREACH ENETUNREACH
# define WSAECONNREFUSED ECONNREFUSED
typedef int ioctlsockopt_t;
# define ioctlsocket ioctl
# define closesocket(s) close(s)
@ -55,7 +57,9 @@ typedef int ioctlsockopt_t;
# include <stdint.h>
#endif
#ifndef _WIN32
#include <sys/time.h>
#endif
#ifdef NEED_TYPEDEFS
typedef char int8_t;
@ -125,17 +129,6 @@ typedef u_int32_t uint32;
#ifndef _WIN32
#include <sys/uio.h>
#endif
#ifndef _P
#ifndef NO_PROTOTYPES
# define _P(x) x
#else
# define _P(x) ()
#endif
#endif
#ifndef _WIN32
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
@ -146,20 +139,23 @@ typedef u_int32_t uint32;
/* Systems lacking strdup() definition in <string.h>. */
#if defined(ultrix)
char *strdup _P((const char *));
char *strdup(const char *);
#endif
/* Systems lacking malloc() definition in <stdlib.h>. */
#if defined(ultrix) || defined(hcx)
void *malloc _P((size_t arg));
void free _P((void *ptr));
void *malloc(size_t arg);
void free(void *ptr);
#endif
#ifndef HAVE_INET_ATON
int inet_aton _P((const char *cp, struct in_addr *ia));
int inet_aton(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
@ -191,11 +187,7 @@ int inet_aton _P((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>
@ -212,8 +204,13 @@ int inet_aton _P((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"
@ -249,38 +246,38 @@ extern struct ttys *ttys_unit[MAX_INTERFACES];
#endif
#ifndef FULL_BOLT
void if_start _P((void));
void if_start(void);
#else
void if_start _P((struct ttys *));
void if_start(struct ttys *);
#endif
#ifdef BAD_SPRINTF
# define vsprintf vsprintf_len
# define sprintf sprintf_len
extern int vsprintf_len _P((char *, const char *, va_list));
extern int sprintf_len _P((char *, const char *, ...));
extern int vsprintf_len(char *, const char *, va_list);
extern int sprintf_len(char *, const char *, ...);
#endif
#ifdef DECLARE_SPRINTF
# ifndef BAD_SPRINTF
extern int vsprintf _P((char *, const char *, va_list));
extern int vsprintf(char *, const char *, va_list);
# endif
extern int vfprintf _P((FILE *, const char *, va_list));
extern int vfprintf(FILE *, const char *, va_list);
#endif
#ifndef HAVE_STRERROR
extern char *strerror _P((int error));
extern char *strerror(int error);
#endif
#ifndef HAVE_INDEX
char *index _P((const char *, int));
char *index(const char *, int);
#endif
#ifndef HAVE_GETHOSTID
long gethostid _P((void));
long gethostid(void);
#endif
void lprint _P((const char *, ...));
void lprint(const char *, ...);
extern int do_echo;
@ -288,8 +285,8 @@ extern int do_echo;
# define insque_32 insque
# define remque_32 remque
#else
extern inline void insque_32 _P((void *, void *));
extern inline void remque_32 _P((void *));
extern inline void insque_32(void *, void *);
extern inline void remque_32(void *);
#endif
#ifndef _WIN32
@ -302,47 +299,47 @@ extern int do_echo;
int cksum(struct mbuf *m, int len);
/* if.c */
void if_init _P((void));
void if_output _P((struct socket *, struct mbuf *));
void if_init(void);
void if_output(struct socket *, struct mbuf *);
/* ip_input.c */
void ip_init _P((void));
void ip_input _P((struct mbuf *));
struct ip * ip_reass _P((register struct ipasfrag *, 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 *));
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 *);
/* ip_output.c */
int ip_output _P((struct socket *, struct mbuf *));
int ip_output(struct socket *, struct mbuf *);
/* tcp_input.c */
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));
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);
/* tcp_output.c */
int tcp_output _P((register struct tcpcb *));
void tcp_setpersist _P((register struct tcpcb *));
int tcp_output(register struct tcpcb *);
void tcp_setpersist(register struct tcpcb *);
/* tcp_subr.c */
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 *));
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 *);
struct tcpcb *tcp_drop(struct tcpcb *tp, int err);
#ifdef USE_PPP
@ -358,9 +355,4 @@ 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
View File

@ -40,11 +40,6 @@
*/
#undef USE_LOWCPU
/* Define this if your compiler doesn't like prototypes */
#ifndef __STDC__
#define NO_PROTOTYPES
#endif
/*********************************************************/
/*
* Autoconf defined configuration options
@ -77,9 +72,6 @@
/* 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__

45
BasiliskII/src/slirp/socket.c
View File

@ -97,11 +97,12 @@ int
soread(so)
struct socket *so;
{
int n, nn, lss, total;
int n, nn;
u_int lss, total;
struct sbuf *sb = &so->so_snd;
int len = sb->sb_datalen - sb->sb_cc;
u_int len = sb->sb_datalen - sb->sb_cc;
struct iovec iov[2];
int mss = so->so_tcpcb->t_maxseg;
u_int mss = so->so_tcpcb->t_maxseg;
DEBUG_CALL("soread");
DEBUG_ARG("so = %lx", (long )so);
@ -159,7 +160,8 @@ soread(so)
nn = recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
#endif
if (nn <= 0) {
if (nn < 0 && (errno == EINTR || errno == EAGAIN))
int error = WSAGetLastError();
if (nn < 0 && (error == WSAEINTR || error == EAGAIN))
return 0;
else {
DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
@ -297,7 +299,7 @@ sowrite(so)
{
int n,nn;
struct sbuf *sb = &so->so_rcv;
int len = sb->sb_cc;
u_int len = sb->sb_cc;
struct iovec iov[2];
DEBUG_CALL("sowrite");
@ -344,9 +346,12 @@ 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 && (errno == EAGAIN || errno == EINTR))
return 0;
if (nn < 0) {
int error = WSAGetLastError();
if (error == EAGAIN || error == WSAEINTR)
return 0;
}
if (nn <= 0) {
DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
so->so_state, errno));
@ -405,8 +410,9 @@ sorecvfrom(so)
if(len == -1 || len == 0) {
u_char code=ICMP_UNREACH_PORT;
if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
int error = WSAGetLastError();
if(error == WSAEHOSTUNREACH) code=ICMP_UNREACH_HOST;
else if(error == WSAENETUNREACH) code=ICMP_UNREACH_NET;
DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
errno,strerror(errno)));
@ -419,7 +425,7 @@ sorecvfrom(so)
udp_detach(so);
} else { /* A "normal" UDP packet */
struct mbuf *m;
int len;
u_int len;
ioctlsockopt_t n;
if (!(m = m_get())) return;
@ -447,8 +453,9 @@ sorecvfrom(so)
if(m->m_len<0) {
u_char code=ICMP_UNREACH_PORT;
if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
int error = WSAGetLastError();
if(error == WSAEHOSTUNREACH) code=ICMP_UNREACH_HOST;
else if(error == WSAENETUNREACH) 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));
@ -513,7 +520,9 @@ sosendto(so, m)
addr.sin_addr = so->so_faddr;
addr.sin_port = so->so_fport;
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)));
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))));
/* Don't care what port we get */
ret = sendto(so->s, m->m_data, m->m_len, 0,
@ -584,16 +593,12 @@ 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 tmperrno = errno; /* Don't clobber the real reason we failed */
int error = WSAGetLastError(); /* Don't clobber the real reason we failed */
close(s);
sofree(so);
/* Restore the real errno */
#ifdef _WIN32
WSASetLastError(tmperrno);
#else
errno = tmperrno;
#endif
WSASetLastError(error);
return NULL;
}
setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));

38
BasiliskII/src/slirp/socket.h
View File

@ -81,24 +81,24 @@ struct iovec {
};
#endif
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 *));
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 *);
#endif /* _SOCKET_H_ */

6
BasiliskII/src/slirp/tcp.h
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 int tcp_rcvspace;
extern int tcp_sndspace;
extern size_t tcp_rcvspace;
extern size_t 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(0)
#pragma pack(PACK_RESET)
#endif
#include "tcp_var.h"

1024
BasiliskII/src/slirp/tcp_input.c
View File

File diff suppressed because it is too large Load Diff

32
BasiliskII/src/slirp/tcp_output.c
View File

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

76
BasiliskII/src/slirp/tcp_subr.c
View File

@ -46,14 +46,13 @@
int tcp_mssdflt = TCP_MSS;
int tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
int tcp_do_rfc1323 = 0; /* Don't do rfc1323 performance enhancements */
int tcp_rcvspace; /* You may want to change this */
int tcp_sndspace; /* Keep small if you have an error prone link */
size_t tcp_rcvspace; /* You may want to change this */
size_t 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;
@ -74,9 +73,7 @@ tcp_init()
* necessary when the connection is used.
*/
/* struct tcpiphdr * */
void
tcp_template(tp)
struct tcpcb *tp;
void tcp_template(struct tcpcb *tp)
{
struct socket *so = tp->t_socket;
register struct tcpiphdr *n = &tp->t_template;
@ -113,13 +110,8 @@ tcp_template(tp)
* In any case the ack and sequence number of the transmitted
* segment are as specified by the parameters.
*/
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;
void tcp_respond(struct tcpcb *tp, register struct tcpiphdr *ti,
register struct mbuf *m, tcp_seq ack, tcp_seq seq, int flags)
{
register int tlen;
int win = 0;
@ -193,9 +185,7 @@ tcp_respond(tp, ti, m, ack, seq, flags)
* empty reassembly queue and hooking it to the argument
* protocol control block.
*/
struct tcpcb *
tcp_newtcpcb(so)
struct socket *so;
struct tcpcb *tcp_newtcpcb(struct socket *so)
{
register struct tcpcb *tp;
@ -268,9 +258,7 @@ struct tcpcb *tcp_drop(struct tcpcb *tp, int err)
* discard internet protocol block
* wake up any sleepers
*/
struct tcpcb *
tcp_close(tp)
register struct tcpcb *tp;
struct tcpcb *tcp_close(register struct tcpcb *tp)
{
register struct tcpiphdr *t;
struct socket *so = tp->t_socket;
@ -306,8 +294,7 @@ tcp_close(tp)
return ((struct tcpcb *)0);
}
void
tcp_drain()
void tcp_drain()
{
/* XXX */
}
@ -319,10 +306,7 @@ tcp_drain()
#ifdef notdef
void
tcp_quench(i, errno)
int errno;
void tcp_quench(int i, int errno)
{
struct tcpcb *tp = intotcpcb(inp);
@ -346,9 +330,7 @@ tcp_quench(i, 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(tp)
struct tcpcb *tp;
void tcp_sockclosed(struct tcpcb *tp)
{
DEBUG_CALL("tcp_sockclosed");
@ -389,8 +371,7 @@ tcp_sockclosed(tp)
* nonblocking. Connect returns after the SYN is sent, and does
* not wait for ACK+SYN.
*/
int tcp_fconnect(so)
struct socket *so;
int tcp_fconnect(struct socket *so)
{
int ret=0;
@ -423,10 +404,12 @@ int tcp_fconnect(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_ntoa(addr.sin_addr)));
ntohs(addr.sin_port), inet_ntop(AF_INET, &addr.sin_addr,
addrstr, sizeof(addrstr))));
/* We don't care what port we get */
ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
@ -452,9 +435,7 @@ int tcp_fconnect(so)
* the time it gets to accept(), so... We simply accept
* here and SYN the local-host.
*/
void
tcp_connect(inso)
struct socket *inso;
void tcp_connect(struct socket *inso)
{
struct socket *so;
struct sockaddr_in addr;
@ -486,7 +467,7 @@ tcp_connect(inso)
so->so_lport = inso->so_lport;
}
(void) tcp_mss(sototcpcb(so), 0);
tcp_mss(sototcpcb(so), 0);
if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
tcp_close(sototcpcb(so)); /* This will sofree() as well */
@ -539,9 +520,7 @@ tcp_connect(inso)
/*
* Attach a TCPCB to a socket.
*/
int
tcp_attach(so)
struct socket *so;
int tcp_attach(struct socket *so)
{
if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL)
return -1;
@ -575,9 +554,7 @@ struct emu_t *tcpemu = 0;
/*
* Return TOS according to the above table
*/
u_int8_t
tcp_tos(so)
struct socket *so;
u_int8_t tcp_tos(struct socket *so)
{
int i = 0;
struct emu_t *emup;
@ -629,10 +606,7 @@ int do_echo = -1;
*
* NOTE: if you return 0 you MUST m_free() the mbuf!
*/
int
tcp_emu(so, m)
struct socket *so;
struct mbuf *m;
int tcp_emu(struct socket *so, struct mbuf *m)
{
u_int n1, n2, n3, n4, n5, n6;
char buff[256];
@ -833,7 +807,7 @@ tcp_emu(so, m)
ns->so_laddr=so->so_laddr;
ns->so_lport=htons(port);
(void) tcp_mss(sototcpcb(ns), 0);
tcp_mss(sototcpcb(ns), 0);
ns->so_faddr=so->so_faddr;
ns->so_fport=htons(IPPORT_RESERVED-1); /* Use a fake port. */
@ -1060,7 +1034,7 @@ do_prompt:
* of the connection as a NUL-terminated decimal ASCII string.
*/
so->so_emu = 0;
for (lport = 0, i = 0; i < m->m_len-1; ++i) {
for (lport = 0, i = 0; i < (int) (m->m_len-1); ++i) {
if (m->m_data[i] < '0' || m->m_data[i] > '9')
return 1; /* invalid number */
lport *= 10;
@ -1245,9 +1219,7 @@ 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(so)
struct socket *so;
int tcp_ctl(struct socket *so)
{
struct sbuf *sb = &so->so_snd;
int command;

8
BasiliskII/src/slirp/tcp_timer.h
View File

@ -130,9 +130,9 @@ extern int tcp_backoff[];
struct tcpcb;
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));
void tcp_fasttimo(void);
void tcp_slowtimo(void);
void tcp_canceltimers(struct tcpcb *);
struct tcpcb * tcp_timers(register struct tcpcb *, int);
#endif

2
BasiliskII/src/slirp/tftp.h
View File

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

12
BasiliskII/src/slirp/udp.c
View File

@ -275,7 +275,7 @@ int udp_output2(struct socket *so, struct mbuf *m,
ui->ui_next = ui->ui_prev = 0;
ui->ui_x1 = 0;
ui->ui_pr = IPPROTO_UDP;
ui->ui_len = htons(m->m_len - sizeof(struct ip)); /* + sizeof (struct udphdr)); */
ui->ui_len = htons((u_short) (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 +291,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 = m->m_len;
((struct ip *)ui)->ip_len = (u_int16_t) m->m_len;
((struct ip *)ui)->ip_ttl = ip_defttl;
((struct ip *)ui)->ip_tos = iptos;
@ -338,14 +338,10 @@ 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 lasterrno=errno;
int error = WSAGetLastError();
closesocket(so->s);
so->s=-1;
#ifdef _WIN32
WSASetLastError(lasterrno);
#else
errno=lasterrno;
#endif
WSASetLastError(error);
} else {
/* success, insert in queue */
so->so_expire = curtime + SO_EXPIRE;

18
BasiliskII/src/slirp/udp.h
View File

@ -54,7 +54,7 @@ struct udphdr {
} PACKED__;
#ifdef PRAGMA_PACK_SUPPORTED
#pragma pack(0)
#pragma pack(PACK_RESET)
#endif
/*
@ -100,14 +100,14 @@ extern struct udpstat udpstat;
extern struct socket udb;
struct mbuf;
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));
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);
int udp_output2(struct socket *so, struct mbuf *m,
struct sockaddr_in *saddr, struct sockaddr_in *daddr,
int iptos);