#ifndef _PPCPRAGMA_MIAMIPCAP_H
#define _PPCPRAGMA_MIAMIPCAP_H

#include <net/pcap.h>
#include <dos/dos.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 MIAMIPCAP_BASE_NAME
#define MIAMIPCAP_BASE_NAME MiamiPCapBase
#endif

#define MiamiPCapInit(m,b) _MiamiPCapInit(MIAMIPCAP_BASE_NAME,m,b)

static __inline void
_MiamiPCapInit(void *MiamiPCapBase,struct Library *m,struct Library *b) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)m;
	MyCaos.a1=(ULONG)b;
	MyCaos.caos_Un.Offset=-30;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	PPCCallOS(&MyCaos);
}

#define MiamiPCapStats(p,s) _MiamiPCapStats(MIAMIPCAP_BASE_NAME,p,s)

static __inline long
_MiamiPCapStats(void *MiamiPCapBase,pcap_t *p,struct pcap_stat *s) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.a1=(ULONG)s;
	MyCaos.caos_Un.Offset=-36;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapOpenLive(d,s,p,t,e) _MiamiPCapOpenLive(MIAMIPCAP_BASE_NAME,d,s,p,t,e)

static __inline pcap_t *
_MiamiPCapOpenLive(void *MiamiPCapBase,char *d,long s,long p,long t,char *e) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)d;
	MyCaos.d0=(ULONG)s;
	MyCaos.d1=(ULONG)p;
	MyCaos.d2=(ULONG)t;
	MyCaos.a1=(ULONG)e;
	MyCaos.caos_Un.Offset=-42;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (pcap_t *)PPCCallOS(&MyCaos);
}

#define MiamiPCapSetfilter(p,pr) _MiamiPCapSetfilter(MIAMIPCAP_BASE_NAME,p,pr)

static __inline long
_MiamiPCapSetfilter(void *MiamiPCapBase,pcap_t *p,struct bpf_program *pr) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.a1=(ULONG)pr;
	MyCaos.caos_Un.Offset=-48;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapOpenOffline(f,e) _MiamiPCapOpenOffline(MIAMIPCAP_BASE_NAME,f,e)

static __inline pcap_t *
_MiamiPCapOpenOffline(void *MiamiPCapBase,char *f,char *e) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)f;
	MyCaos.a1=(ULONG)e;
	MyCaos.caos_Un.Offset=-54;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (pcap_t *)PPCCallOS(&MyCaos);
}

#define MiamiPCapAmigaDump(u,p,s) _MiamiPCapAmigaDump(MIAMIPCAP_BASE_NAME,u,p,s)

static __inline void
_MiamiPCapAmigaDump(void *MiamiPCapBase,u_char *u,struct pcap_pkthdr *p,u_char *s) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)u;
	MyCaos.a1=(ULONG)p;
	MyCaos.a2=(ULONG)s;
	MyCaos.caos_Un.Offset=-60;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	PPCCallOS(&MyCaos);
}

#define MiamiPCapAmigaDumpOpen(p,f) _MiamiPCapAmigaDumpOpen(MIAMIPCAP_BASE_NAME,p,f)

static __inline pcap_dumper_t *
_MiamiPCapAmigaDumpOpen(void *MiamiPCapBase,pcap_t *p,char *f) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.a1=(ULONG)f;
	MyCaos.caos_Un.Offset=-66;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (pcap_dumper_t *)PPCCallOS(&MyCaos);
}

#define MiamiPCapAmigaDumpClose(d) _MiamiPCapAmigaClose(MIAMIPCAP_BASE_NAME,d)

static __inline void
_MiamiPCapAmigaDumpClose(void *MiamiPCapBase,struct pcap_dumper_t *d) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)d;
	MyCaos.caos_Un.Offset=-72;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	PPCCallOS(&MyCaos);
}

#define MiamiPCapLookupdev(e) _MiamiPCapLookupdev(MIAMIPCAP_BASE_NAME,e)

static __inline char *
_MiamiPCapLookupdev(void *MiamiPCapBase,char *e) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)e;
	MyCaos.caos_Un.Offset=-78;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (char *)PPCCallOS(&MyCaos);
}

#define MiamiPCapLookupnet(d,n,m,e) _MiamiPCapLookupnet(MIAMIPCAP_BASE_NAME,d,n,m,e)

static __inline long
_MiamiPCapLookupnet(void *MiamiPCapBase,char *d,bpf_u_int32 *n,
 bpf_u_int32 *m,char *e) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)d;
	MyCaos.a1=(ULONG)n;
	MyCaos.a2=(ULONG)m;
	MyCaos.a3=(ULONG)e;
	MyCaos.caos_Un.Offset=-84;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapDispatch(p,c,cb,u) _MiamiPCapDispatch(MIAMIPCAP_BASE_NAME,p,c,cb,u)

static __inline long
_MiamiPCapDispatch(void *MiamiPCapBase,pcap_t *p,long c,
 pcap_handler cb,u_char *u) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.d0=(ULONG)c;
	MyCaos.a1=(ULONG)cb;
	MyCaos.a2=(ULONG)u;
	MyCaos.caos_Un.Offset=-90;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapLoop(p,c,cb,u) _MiamiPCapLoop(MIAMIPCAP_BASE_NAME,p,c,cb,u)

static __inline long
_MiamiPCapLoop(void *MiamiPCapBase,pcap_t *p,long c,
 pcap_handler cb,u_char *u) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.d0=(ULONG)c;
	MyCaos.a1=(ULONG)cb;
	MyCaos.a2=(ULONG)u;
	MyCaos.caos_Un.Offset=-96;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapNext(p,ph) _MiamiPCapNext(MIAMIPCAP_BASE_NAME,p,ph)

static __inline const u_char *
_MiamiPCapNext(void *MiamiPCapBase,pcap_t *p,struct pcap_pkthdr *ph) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.a1=(ULONG)ph;
	MyCaos.caos_Un.Offset=-102;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (const u_char *)PPCCallOS(&MyCaos);
}

#define MiamiPCapDatalink(p) _MiamiPCapDatalink(MIAMIPCAP_BASE_NAME,p)

static __inline long
_MiamiPCapDatalink(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-108;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapSnapshot(p) _MiamiPCapSnapshot(MIAMIPCAP_BASE_NAME,p)

static __inline long
_MiamiPCapSnapshot(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-114;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapIsSwapped(p) _MiamiPCapIsSwapped(MIAMIPCAP_BASE_NAME,p)

static __inline long
_MiamiPCapIsSwapped(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-120;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapMajorVersion(p) _MiamiPCapMajorVersion(MIAMIPCAP_BASE_NAME,p)

static __inline long
_MiamiPCapMajorVersion(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-126;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapMinorVersion(p) _MiamiPCapMinorVersion(MIAMIPCAP_BASE_NAME,p)

static __inline long
_MiamiPCapMinorVersion(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-132;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapAmigaFile(p) _MiamiPCapAmigaFile(MIAMIPCAP_BASE_NAME,p)

static __inline BPTR
_MiamiPCapAmigaFile(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-138;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (BPTR)PPCCallOS(&MyCaos);
}

#define MiamiPCapPerror(p,pr) _MiamiPCapPerror(MIAMIPCAP_BASE_NAME,p,pr)

static __inline void
_MiamiPCapPerror(void *MiamiPCapBase,pcap_t *p,char *pr) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.a1=(ULONG)pr;
	MyCaos.caos_Un.Offset=-144;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	PPCCallOS(&MyCaos);
}

#define MiamiPCapGeterr(p) _MiamiPCapGeterr(MIAMIPCAP_BASE_NAME,p)

static __inline char *
_MiamiPCapGeterr(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-150;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (char *)PPCCallOS(&MyCaos);
}

#define MiamiPCapStrerror(e) _MiamiPCapStrerror(MIAMIPCAP_BASE_NAME,e)

static __inline char *
_MiamiPCapStrerror(void *MiamiPCapBase,long e) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.d0=(ULONG)e;
	MyCaos.caos_Un.Offset=-156;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (char *)PPCCallOS(&MyCaos);
}

#define MiamiPCapClose(p) _MiamiPCapClose(MIAMIPCAP_BASE_NAME,p)

static __inline void
_MiamiPCapClose(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-162;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	PPCCallOS(&MyCaos);
}

#define MiamiPCapCompile(p,pr,b,o,m) _MiamiPCapCompile(MIAMIPCAP_BASE_NAME,p,pr,b,o,m)

static __inline long
_MiamiPCapCompile(void *MiamiPCapBase,pcap_t *p,struct bpf_program *pr,
 char *b,long o,unsigned long m) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.a1=(ULONG)pr;
	MyCaos.a2=(ULONG)b;
	MyCaos.d0=(ULONG)o;
	MyCaos.d1=(ULONG)m;
	MyCaos.caos_Un.Offset=-168;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapAmigaBPFHandle(p) _MiamiPCapAmigaBPFHandle(MIAMIPCAP_BASE_NAME,p)

static __inline long
_MiamiPCapAmigaBPFHandle(void *MiamiPCapBase,pcap_t *p) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.caos_Un.Offset=-174;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#define MiamiPCapBPFImage(p,n) _MiamiPCapBPFImage(MIAMIPCAP_BASE_NAME,p,n)

static __inline char *
_MiamiPCapBPFImage(void *MiamiPCapBase,struct bpf_insn *p,long n) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.d0=(ULONG)n;
	MyCaos.caos_Un.Offset=-180;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (char *)PPCCallOS(&MyCaos);
}

#define MiamiPCapSetCallbackType(p,c) _MiamiPCapSetCallbackType(MIAMIPCAP_BASE_NAME,p,c)

static __inline long
_MiamiPCapSetCallbackType(void *MiamiPCapBase,pcap_t *p,long c) {
	struct Caos MyCaos;
	MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
	MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
	MyCaos.a0=(ULONG)p;
	MyCaos.d0=(ULONG)c;
	MyCaos.caos_Un.Offset=-204;
	MyCaos.a6=(ULONG)MiamiPCapBase;
	return (long)PPCCallOS(&MyCaos);
}

#endif