#ifndef _PPCPRAGMA_SOCKET_H
#define _PPCPRAGMA_SOCKET_H

#ifndef POWERUP_PPCLIB_INTERFACE_H
#include <powerup/ppclib/interface.h>
#endif

#ifndef POWERUP_GCCLIB_PROTOS_H
#include <powerup/gcclib/powerup_protos.h>
#endif

#ifndef _STRING_H
#include <string.h>
#endif

#ifndef NO_PPCINLINE_STDARG
#define NO_PPCINLINE_STDARG
#endif/* SAS C PPC inlines */

#ifndef SOCKET_BASE_NAME
#define SOCKET_BASE_NAME SocketBase
#endif

#define socket(d,t,p) _socket(SOCKET_BASE_NAME,d,t,p)

static __inline long
_socket(void *SocketBase,long d,long t,long p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)d;
	MyCaos.d1=(ULONG)t;
	MyCaos.d2=(ULONG)p;
	MyCaos.caos_Un.Offset=-30;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define bind(s,n,nl) _bind(SOCKET_BASE_NAME,s,n,nl)

static __inline long
_bind(void *SocketBase,long s,const struct sockaddr *n,long nl) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)n;
	MyCaos.d1=(ULONG)nl;
	MyCaos.caos_Un.Offset=-36;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define listen(s,b) _listen(SOCKET_BASE_NAME,s,b)

static __inline long
_listen(void *SocketBase,long s,long b) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.d1=(ULONG)b;
	MyCaos.caos_Un.Offset=-42;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define accept(s,a,al) _accept(SOCKET_BASE_NAME,s,a,al)

static __inline long
_accept(void *SocketBase,long s,struct sockaddr *a,long *al) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)a;
	MyCaos.a1=(ULONG)al;
	MyCaos.caos_Un.Offset=-48;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define connect(s,n,nl) _connect(SOCKET_BASE_NAME,s,n,nl)

static __inline long
_connect(void *SocketBase,long s,struct sockaddr *n,long nl) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)n;
	MyCaos.d1=(ULONG)nl;
	MyCaos.caos_Un.Offset=-54;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define sendto(s,m,l,f,t,tl) _sendto(SOCKET_BASE_NAME,s,m,l,f,t,tl)

static __inline long
_sendto(void *SocketBase,long s,const unsigned char *m,long l,long f,
 const struct sockaddr *t,long tl) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)m;
	MyCaos.d1=(ULONG)l;
	MyCaos.d2=(ULONG)f;
	MyCaos.a1=(ULONG)t;
	MyCaos.d3=(ULONG)tl;
	MyCaos.caos_Un.Offset=-60;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define send(s,m,l,f) _send(SOCKET_BASE_NAME,s,m,l,f)

static __inline long
_send(void *SocketBase,long s,const unsigned char *m,long l,long f) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)m;
	MyCaos.d1=(ULONG)l;
	MyCaos.d2=(ULONG)f;
	MyCaos.caos_Un.Offset=-66;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define recvfrom(s,b,l,f,fr,frl) _recvfrom(SOCKET_BASE_NAME,s,b,l,f,fr,frl)

static __inline long
_recvfrom(void *SocketBase,long s,unsigned char *b,long l,long f,
 struct sockaddr *fr,long *frl) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)b;
	MyCaos.d1=(ULONG)l;
	MyCaos.d2=(ULONG)f;
	MyCaos.a1=(ULONG)fr;
	MyCaos.a2=(ULONG)frl;
	MyCaos.caos_Un.Offset=-72;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define recv(s,b,l,f) _recv(SOCKET_BASE_NAME,s,b,l,f)

static __inline long
_recv(void *SocketBase,long s,unsigned char *b,long l,long f) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCStart=b;
	MyCaos.PPCLength=l;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)b;
	MyCaos.d1=(ULONG)l;
	MyCaos.d2=(ULONG)f;
	MyCaos.caos_Un.Offset=-78;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define shutdown(s,h) _shutdown(SOCKET_BASE_NAME,s,h)

static __inline long
_shutdown(void *SocketBase,long s,long h) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.d1=(ULONG)h;
	MyCaos.caos_Un.Offset=-84;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define setsockopt(s,l,o,ov,ol) _setsockopt(SOCKET_BASE_NAME,s,l,o,ov,ol)

static __inline long
_setsockopt(void *SocketBase,long s,long l,long o,const void *ov,long ol) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.d1=(ULONG)l;
	MyCaos.d2=(ULONG)o;
	MyCaos.a0=(ULONG)ov;
	MyCaos.d3=(ULONG)ol;
	MyCaos.caos_Un.Offset=-90;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define getsockopt(s,l,o,ov,ol) _getsockopt(SOCKET_BASE_NAME,s,l,o,ov,ol)

static __inline long
_getsockopt(void *SocketBase,long s,long l,long o,const void *ov,long *ol) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.d1=(ULONG)l;
	MyCaos.d2=(ULONG)o;
	MyCaos.a0=(ULONG)ov;
	MyCaos.a1=(ULONG)ol;
	MyCaos.caos_Un.Offset=-96;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define getsockname(s,h,n) _getsockname(SOCKET_BASE_NAME,s,h,n)

static __inline long
_getsockname(void *SocketBase,long s,struct sockaddr *h,long *n) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)h;
	MyCaos.a1=(ULONG)n;
	MyCaos.caos_Un.Offset=-102;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define getpeername(s,h,n) _getpeername(SOCKET_BASE_NAME,s,h,n)

static __inline long
_getpeername(void *SocketBase,long s,struct sockaddr *h,long *n) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)h;
	MyCaos.a1=(ULONG)n;
	MyCaos.caos_Un.Offset=-108;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define IoctlSocket(d,r,a) _IoctlSocket(SOCKET_BASE_NAME,d,r,a)

static __inline long
_IoctlSocket(void *SocketBase,long d,unsigned long r,char *a) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)d;
	MyCaos.d1=(ULONG)r;
	MyCaos.a0=(ULONG)a;
	MyCaos.caos_Un.Offset=-114;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define CloseSocket(d) _CloseSocket(SOCKET_BASE_NAME,d)

static __inline long
_CloseSocket(void *SocketBase,long d) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)d;
	MyCaos.caos_Un.Offset=-120;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define WaitSelect(n,r,w,e,t,m) _WaitSelect(SOCKET_BASE_NAME,n,r,w,e,t,m)
#define select(n,r,w,e,t) _WaitSelect(SOCKET_BASE_NAME,n,r,w,e,t,0)

static __inline long
_WaitSelect(void *SocketBase,long n,fd_set *r,fd_set *w,fd_set *e,
 void *t,unsigned long *m) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)n;
	MyCaos.a0=(ULONG)r;
	MyCaos.a1=(ULONG)w;
	MyCaos.a2=(ULONG)e;
	MyCaos.a3=(ULONG)t;
	MyCaos.d1=(ULONG)m;
	MyCaos.caos_Un.Offset=-126;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define SetSocketSignals(sin,sio,su) _SetSocketSignals(SOCKET_BASE_NAME,sin,sio,su)

static __inline void
_SetSocketSignals(void *SocketBase,unsigned long sin,unsigned long sio,
 unsigned long su) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)sin;
	MyCaos.d1=(ULONG)sio;
	MyCaos.d2=(ULONG)su;
	MyCaos.caos_Un.Offset=-132;
	MyCaos.a6=(ULONG)SocketBase;
	PPCCallOS(&MyCaos);
}

#define getdtablesize() _getdtablesize(SOCKET_BASE_NAME)

static __inline long
_getdtablesize(void *SocketBase) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.caos_Un.Offset=-138;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define ObtainSocket(i,d,t,p) _ObtainSocket(SOCKET_BASE_NAME,i,d,t,p)

static __inline long
_ObtainSocket(void *SocketBase,long i,long d,long t,long p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)i;
	MyCaos.d1=(ULONG)d;
	MyCaos.d2=(ULONG)t;
	MyCaos.d3=(ULONG)p;
	MyCaos.caos_Un.Offset=-144;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define ReleaseSocket(f,i) _ReleaseSocket(SOCKET_BASE_NAME,f,i)

static __inline long
_ReleaseSocket(void *SocketBase,long f,long i) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)f;
	MyCaos.d1=(ULONG)i;
	MyCaos.caos_Un.Offset=-150;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define ReleaseCopyOfSocket(f,i) _ReleaseCopyOfSocket(SOCKET_BASE_NAME,f,i)

static __inline long
_ReleaseCopyOfSocket(void *SocketBase,long f,long i) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)f;
	MyCaos.d1=(ULONG)i;
	MyCaos.caos_Un.Offset=-156;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define Errno() _Errno(SOCKET_BASE_NAME)

static __inline long
_Errno(void *SocketBase) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.caos_Un.Offset=-162;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define SetErrnoPtr(e,s) _SetErrnoPtr(SOCKET_BASE_NAME,e,s)

static __inline long
_SetErrnoPtr(void *SocketBase,long *e,long s) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)e;
	MyCaos.d0=(ULONG)s;
	MyCaos.caos_Un.Offset=-168;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define Inet_NtoA(i) _Inet_NtoA(SOCKET_BASE_NAME,i)
#define inet_ntoa(i) _Inet_NtoA(SOCKET_BASE_NAME,(i).s_addr)

static __inline char *
_Inet_NtoA(void *SocketBase,unsigned long i) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)i;
	MyCaos.caos_Un.Offset=-174;
	MyCaos.a6=(ULONG)SocketBase;
	return (char *)PPCCallOS(&MyCaos);
}

#define inet_addr(c) _inet_addr(SOCKET_BASE_NAME,c)

static __inline unsigned long
_inet_addr(void *SocketBase,const unsigned char *c) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)c;
	MyCaos.caos_Un.Offset=-180;
	MyCaos.a6=(ULONG)SocketBase;
	return (unsigned long)PPCCallOS(&MyCaos);
}

#define Inet_LnaOf(i) _Inet_LnaOf(SOCKET_BASE_NAME,i)
#define inet_lnaof(i) _Inet_LnaOf(SOCKET_BASE_NAME,(i).s_addr)

static __inline unsigned long
_Inet_LnaOf(void *SocketBase,long i) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)i;
	MyCaos.caos_Un.Offset=-186;
	MyCaos.a6=(ULONG)SocketBase;
	return (unsigned long)PPCCallOS(&MyCaos);
}

#define Inet_NetOf(i) _Inet_NetOf(SOCKET_BASE_NAME,i)
#define inet_netof(i) _Inet_NetOf(SOCKET_BASE_NAME,(i).s_addr)

static __inline unsigned long
_Inet_NetOf(void *SocketBase,long i) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)i;
	MyCaos.caos_Un.Offset=-192;
	MyCaos.a6=(ULONG)SocketBase;
	return (unsigned long)PPCCallOS(&MyCaos);
}

#define Inet_MakeAddr(n,h) _Inet_MakeAddr(SOCKET_BASE_NAME,n,h)

static __inline unsigned long
_Inet_MakeAddr(void *SocketBase,unsigned long n,unsigned long h) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)n;
	MyCaos.d1=(ULONG)h;
	MyCaos.caos_Un.Offset=-198;
	MyCaos.a6=(ULONG)SocketBase;
	return (unsigned long)PPCCallOS(&MyCaos);
}

#define inet_makeaddr(n,h) _inet_makeaddr(SOCKET_BASE_NAME,n,h)

static __inline struct in_addr
_inet_makeaddr(void *SocketBase,unsigned long n,unsigned long h) {
	struct in_addr addr;
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)n;
	MyCaos.d1=(ULONG)h;
	MyCaos.caos_Un.Offset=-198;
	MyCaos.a6=(ULONG)SocketBase;
	addr.s_addr=(unsigned long)PPCCallOS(&MyCaos);
	return addr;
}

#define inet_network(c) _inet_network(SOCKET_BASE_NAME,c)

static __inline unsigned long
_inet_network(void *SocketBase,long c) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)c;
	MyCaos.caos_Un.Offset=-204;
	MyCaos.a6=(ULONG)SocketBase;
	return (unsigned long)PPCCallOS(&MyCaos);
}

#define gethostbyname(n) _gethostbyname(SOCKET_BASE_NAME,n)

static __inline struct hostent *
_gethostbyname(void *SocketBase,const unsigned char *n) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)n;
	MyCaos.caos_Un.Offset=-210;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct hostent *)PPCCallOS(&MyCaos);
}

#define gethostbyaddr(a,l,t) _gethostbyaddr(SOCKET_BASE_NAME,a,l,t)

static __inline struct hostent *
_gethostbyaddr(void *SocketBase,const unsigned char *a,long l,long t) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)a;
	MyCaos.d0=(ULONG)l;
	MyCaos.d1=(ULONG)t;
	MyCaos.caos_Un.Offset=-216;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct hostent *)PPCCallOS(&MyCaos);
}

#define getnetbyname(n) _getnetbyname(SOCKET_BASE_NAME,n)

static __inline struct netent *
_getnetbyname(void *SocketBase,const unsigned char *n) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)n;
	MyCaos.caos_Un.Offset=-222;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct netent *)PPCCallOS(&MyCaos);
}

#define getnetbyaddr(n,t) _getnetbyaddr(SOCKET_BASE_NAME,n,t)

static __inline struct netent *
_getnetbyaddr(void *SocketBase,long n,long t) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)n;
	MyCaos.d1=(ULONG)t;
	MyCaos.caos_Un.Offset=-228;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct netent *)PPCCallOS(&MyCaos);
}

#define getservbyname(n,p) _getservbyname(SOCKET_BASE_NAME,n,p)

static __inline struct servent *
_getservbyname(void *SocketBase,const unsigned char *n,const unsigned char *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)n;
	MyCaos.a1=(ULONG)p;
	MyCaos.caos_Un.Offset=-234;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct servent *)PPCCallOS(&MyCaos);
}

#define getservbyport(p,pr) _getservbyport(SOCKET_BASE_NAME,p,pr)

static __inline struct servent *
_getservbyport(void *SocketBase,long p,const unsigned char *pr) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)p;
	MyCaos.a0=(ULONG)pr;
	MyCaos.caos_Un.Offset=-240;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct servent *)PPCCallOS(&MyCaos);
}

#define getprotobyname(n) _getprotobyname(SOCKET_BASE_NAME,n)

static __inline struct protoent *
_getprotobyname(void *SocketBase,const unsigned char *n) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)n;
	MyCaos.caos_Un.Offset=-246;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct protoent *)PPCCallOS(&MyCaos);
}

#define getprotobynumber(p) _getprotobynumber(SOCKET_BASE_NAME,p)

static __inline struct protoent *
_getprotobynumber(void *SocketBase,long p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)p;
	MyCaos.caos_Un.Offset=-252;
	MyCaos.a6=(ULONG)SocketBase;
	return (struct protoent *)PPCCallOS(&MyCaos);
}

#define vsyslog(l,f,a) _vsyslog(SOCKET_BASE_NAME,l,f,a)

static __inline void
_vsyslog(void *SocketBase,unsigned long l,const char *f,long *a) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)l;
	MyCaos.a0=(ULONG)f;
	MyCaos.a1=(ULONG)a;
	MyCaos.caos_Un.Offset=-258;
	MyCaos.a6=(ULONG)SocketBase;
	PPCCallOS(&MyCaos);
}

#ifndef NO_PPCINLINE_STDARG
#define syslog(l, f, tags...) \
	({ULONG _tags[] = {tags}; vsyslog((l), (f), (long) _tags);})
#endif

#define Dup2Socket(fa,fb) _Dup2Socket(SOCKET_BASE_NAME,fa,fb)

static __inline long
_Dup2Socket(void *SocketBase,long fa,long fb) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)fa;
	MyCaos.d1=(ULONG)fb;
	MyCaos.caos_Un.Offset=-264;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define sendmsg(s,m,f) _sendmsg(SOCKET_BASE_NAME,s,m,f)

static __inline long
_sendmsg(void *SocketBase,long s,struct msghdr *m,long f) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)m;
	MyCaos.d1=(ULONG)f;
	MyCaos.caos_Un.Offset=-270;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define recvmsg(s,m,f) _recvmsg(SOCKET_BASE_NAME,s,m,f)

static __inline long
_recvmsg(void *SocketBase,long s,struct msghdr *m,long f) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)s;
	MyCaos.a0=(ULONG)m;
	MyCaos.d1=(ULONG)f;
	MyCaos.caos_Un.Offset=-276;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define gethostname(h,s) _gethostname(SOCKET_BASE_NAME,h,s)

static __inline long
_gethostname(void *SocketBase,char *h,long s) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)h;
	MyCaos.d0=(ULONG)s;
	MyCaos.caos_Un.Offset=-282;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#define gethostid() _gethostid(SOCKET_BASE_NAME)

static __inline unsigned long
_gethostid(void *SocketBase) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.caos_Un.Offset=-288;
	MyCaos.a6=(ULONG)SocketBase;
	return (unsigned long)PPCCallOS(&MyCaos);
}

#define SocketBaseTagList(t) _SocketBaseTagList(SOCKET_BASE_NAME,t)

static __inline long
_SocketBaseTagList(void *SocketBase,struct TagItem *t) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)t;
	MyCaos.caos_Un.Offset=-294;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#ifndef NO_PPCINLINE_STDARG
#define SocketBaseTags(tags...) \
	({ULONG _tags[] = {tags}; SocketBaseTagList((struct TagItem *)_tags);})
#endif

#define GetSocketEvents(e) _GetSocketEvents(SOCKET_BASE_NAME,e)

static __inline long
_GetSocketEvents(void *SocketBase,unsigned long *e) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)e;
	MyCaos.caos_Un.Offset=-300;
	MyCaos.a6=(ULONG)SocketBase;
	return (long)PPCCallOS(&MyCaos);
}

#endif