/*
 *		PATCHES.C									vi:ts=4
 *
 *      Copyright (c) Eddy Carroll, September 1994.
 *
 *		Controls the patching of dos.library and other functions in a
 *		reliable manner.
 */

#define DEBUG_PATTERN		0

#define MONITOR_SEMAPHORE	0
#define STACK_CHECK			0		/* Not currently used */

#pragma libcall SysBase RawPutChar 204 001

#include "system.h"
#include "snoopdos.h"
#include "patches.h"

/*
 *		These four pointers are imported from PATCHCODE.S, which is
 *		also where the real code size is determined.
 */
#define CODESIZE		88	/* Must equal PatchCode_End - PatchCode_Start   */
#define STACKADJUST		14	/* Must equal pc_JumpOrigFunc - pc_NormalReturn */

#define PatchCode_Size		  (PatchCode_End - PatchCode_Start)
#define PatchCode_StackAdjust (PatchCode_JumpOrigFunc - PatchCode_NormalReturn)

extern char far PatchCode_Start[];
extern char far PatchCode_NormalReturn[];
extern char far PatchCode_JumpOrigFunc[];
extern char far PatchCode_End[];

#define ASM	__asm __saveds

#if MONITOR_SEMAPHORE
Task *LoadTask;				/* Indicates we're inside LoadSeg() */
#endif

/*
 *		Now some packet IDs not defined by Commodore in dos/dosextens.h
 */
#define ACTION_DOUBLE		  2000	/* Conman: create pipe filehandle	*/
#define ACTION_FORCE		  2001	/* Conman: Force input into handler	*/
#define ACTION_DROP			  2004	/* Conman: Discard all queued input	*/

#define ACTION_GET_DISK_FSSM  4201	/* Get disk startup message			*/
#define ACTION_FREE_DISK_FSSM 4202	/* Free disk startup message		*/

/*
 *		Next, our three message types for the background process. These
 *		correspond to pattern and pathname expansion messages.
 */
#define QUIT_MSG		0
#define PATTERN_MSG		1
#define PATHEXPAND_MSG	2

/*
 *		Some miscellaneous strings
 */
char LinkPointerString[] = " --> ";

/*
 *		I needed a quick way to hook into ReleaseSemaphore() to try and
 *		figure out why ramlib would sometimes crash on calling it. What
 *		better way to do this than by re-using one of our existing
 *		patched functions (one which takes a parameter in A0). OpenDevice
 *		fits the bill nicely (we just ignore the additional parameters).
 */
#if MONITOR_SEMAPHORE
#undef LVO_OpenDevice
#define LVO_OpenDevice		-570 // ReleaseSemaphore() LVO vector
#endif

/*
 *		This structure is used to communicate between the PutMsg() patch
 *		and the background SnoopDos process when doing path expansion
 *		for ACTION_MAKE_LINK or ShowFullPaths (when we're monitoring packets,
 *		we can't guarantee that the calling processes' message port is free).
 */
typedef struct NameFromLockMsg {
	struct Message  msg;		/* Standard exec message				*/
	int				type;		/* Type of this message					*/
	BPTR			lock;		/* Lock to calculate path relative to	*/
	char			*filename;	/* Filename relative to lock			*/
	char			*buf;		/* Buffer to store result in			*/
	int				maxlen;		/* Maximum length of buffer				*/
	char			*newbuf;	/* On return, points to path in buffer 	*/
	int				sigmask;	/* Signal number to signal when done	*/
	Task			*task;		/* Task to signal when done				*/
} NameFromLockMsg;

/*
 *		This structure is used to communicate between the patches and
 *		the background SnoopDos process when doing pattern matching.
 */
typedef struct PatternMsg {
	struct Message	msg;		/* Standard exec message				*/
	int				type;		/* Type of this message					*/
	char			*name;		/* Name of task to check				*/
	int				match;		/* Result of pattern match (1 == okay)	*/
	int				sigmask;	/* Signal number to signal when done	*/
	Task			*task;		/* Task to signal when done				*/
} PatternMsg;

/*
 *		This structure is used to cache the results of pattern comparisons
 *		for various tasks.
 */
typedef struct PatternCache {
	struct MinNode	node;		/* Used to link items together				*/
	Task			*task;		/* ID of task stored in this entry			*/
	char			name[PC_NAMELEN];/* Name of task stored in this entry	*/
	int				match;		/* True=monitor this task, false=don't		*/
} PatternCache;

PatternCache	PCacheEntries[NUM_PCACHE_ENTRIES];	/* Entries on list		*/
MsgPort			BackgroundPort;	/* Where to send pattern match requests to	*/
List			PatternList;	/* List of cached patterns					*/
Semaphore		PatternCacheSem;/* Sem to control access to pattern cache  	*/
Semaphore		PatternBufSem;	/* Sem to control access to pattern buffer	*/
Semaphore		TaskCacheSem;	/* Sem used to arbitrate cache access		*/
Semaphore		DosDeviceSem;	/* Sem used to control access to dev list	*/
Process			*BackgroundProc;/* Process used to do pattern matching		*/
ULONG			PatternEnabled;		/* If true, pattern matching is enabled	*/
ULONG			PatternWildcard;	/* If true, pattern contains a wildcard	*/
Task			*SnoopTask;			/* Pointer to our own task				*/
Task			*RamLibTask;		/* Pointer to RamLib process			*/
Task			*RealRamLibTask;	/* Pointer to Ramlib process (always!)	*/
Task			*InputTask;			/* Pointer to input.device's task		*/
ULONG			NewEventSig    = -1;/* Signal bit used when new event ready	*/
ULONG			ScanDosListSig = -1;/* Signal bit used to say rescan list	*/
ULONG			TaskCacheIndex = 1; /* Index into task cache array			*/

#define PAT_MAX_LEN	(MAX_STR_LEN   + 50)
#define PAT_BUF_LEN	(PAT_MAX_LEN*2 + 3)

char			PatternString[PAT_MAX_LEN];			/* Holds source pattern	*/
char			PatternBuf[PAT_BUF_LEN];			/* Holds parsed pattern	*/
Task			*CachedTask[NUM_CACHED_TASKS];		/* Holds cached tasks	*/
Task			*DeviceTaskList[MAX_DOS_DEVICES];	/* Holds device IDs		*/

/*
 *		This structure records outstanding packets (for direct packet i/o
 *		that bypasses AmigaDOS) which we are watching out for a reply to.
 *		We keep all the additional info because it's likely that any given
 *		task will re-use a packet structure when sending packets to different
 *		DOS processes, and we want to be able to distinguish these cases.
 */
typedef struct WaitPacket {
	struct	MinNode		node;			/* Used to link items together	*/
	struct	DosPacket	*dp;			/* Packet that was dispatched	*/
	struct	Task		*sendtask;		/* Task that sent it			*/
	struct	MsgPort		*destport;		/* Port it was sent to			*/
	LONG	eventnum;					/* Associated event number		*/
	Event	*event;						/* Associated event pointer		*/
	ULONG	arg1;						/* ARG1 of the packet			*/
	ULONG	arg2;						/* ARG2 of the packet			*/
	ULONG	arg3;						/* ARG3 of the packet			*/
	char	*resmsg;					/* Message to use for result	*/
	UWORD	flags;						/* Flags associated with result	*/
} WaitPacket;

Semaphore	PacketSem;							/* Arbitrates list access	*/
struct List PacketWaitList;						/* List of waiting packets	*/
struct List	PacketFreeList;						/* List of free nodes		*/
WaitPacket	PacketEntries[NUM_PACKET_ENTRIES];	/* The nodes on the list	*/

/*
 *		Prototypes for all our replacement patched functions
 */

void BackgroundProcCode(void);
char *MyNameFromLock(BPTR lock, char *filename, char *buf, int maxlen);

typedef unsigned long (*FuncPtr)();

#define FPROTO(name)	ULONG ASM New_##name(){return (0);}
#define DPROTO(name)	ULONG ASM New_##name();

DPROTO(AddDosEntry)
DPROTO(CurrentDir)
DPROTO(DeleteFile)
DPROTO(Execute)
DPROTO(GetVar)
DPROTO(FindVar)
DPROTO(LoadSeg)
DPROTO(NewLoadSeg)
DPROTO(Lock)
DPROTO(CreateDir)
DPROTO(MakeLink)
DPROTO(Open)
DPROTO(Rename)
DPROTO(RunCommand)
DPROTO(SetVar)
DPROTO(DeleteVar)
DPROTO(SystemTagList)

DPROTO(FindPort)
DPROTO(FindResident)
DPROTO(FindSemaphore)
DPROTO(FindTask)
DPROTO(OpenDevice)
DPROTO(OpenLibrary)
DPROTO(OpenResource)
DPROTO(PutMsg)

DPROTO(OpenFont)
DPROTO(LockPubScreen)
DPROTO(FindToolType)
DPROTO(MatchToolValue)

/*
 *		These two defines control whether or not a patch is enabled. It's
 *		vital that PATCH_ENABLED be -1 rather than simply any non-zero
 *		value -- see the comments in patchcode.s for more details.
 */
#define PATCH_ENABLED		((ULONG)(-1))
#define PATCH_DISABLED		0

/*
 *		MarkCallAddr
 *		CallAddr
 *
 *		These two macros allow us to determine what address we were called
 *		from in a patch function. MarkCallAddr should be the first
 *		declaration at the start of the patch function, and then CallAddr
 *		will correspond to the caller's address throughout that function.
 *		callmarker[0] is the place marker itself, callmarker[1] is the
 *		immediate return address, and callmarker[3] takes into the
 *		account the assembly language patch stub as well.
 */
#define MarkCallAddr		ULONG volatile callmarker[1]
#define CallAddr			(callmarker[6])

/*
 *		JumpOrigFunc(retval)
 *	
 *		This macro lets us return and call the original function from the
 *		resident patch code rather than from our C code. The passed
 *		parameter can be 0 in most cases, but if the function we're using
 *		this in had a formal parameter passed in reg_d0, then that
 *		formal parameter must be used as the return value.
 *
 *		We implement this by patching the stack directly to adjust the
 *		return address so that we arrive back at a second bit of code
 *		instead of the first bit.
 */
#define JumpOrigFunc(retval) \
	{ callmarker[1] += STACKADJUST; \
	  return (ULONG)(retval); }

/*
 *		The patch structure itself. Don't change the order of the first 
 *		four fields without updating the code in PATCHCODE.S as well!
 *
 *		Note that we use a library number rather than a pointer to an
 *		actual library, for convenience.
 */
typedef struct Patch {
	UWORD	code[CODESIZE/2];		/* Assembly code to handle patch	*/
	FuncPtr	origfunc;				/* Original function pointer		*/
	FuncPtr	newfunc;				/* Replacement function pointer		*/
	ULONG	enabled;				/* If -1, patch currently active	*/
	void	*sysbase;				/* Points to ExecBase				*/
	ULONG	stackneeded;			/* #bytes free stack required		*/
	UWORD	usecount;				/* No. of tasks currently in code	*/
	UWORD	library;				/* Library to patch					*/
	WORD	offset;					/* Offset into library				*/
	WORD	pad;					/* Keep structure longword-aligned	*/
} Patch;

#define PATCH_DEF(lib,func)	{ lib, LVO_##func, (FuncPtr)New_##func }
#define PATCH_END			{ 0, 0, 0 }

/*
 *		This structure is used to initialise the main Patch array in memory.
 *
 *		IMPORTANT -- these patches MUST be defined in exactly the same
 *		order as the first entries in the GID_* defines in snoopdos.h
 *		since those same GID_* values are used to toggle the patches
 *		on and off.
 */
struct PatchInitTable {
	UWORD	library;				/* Library number to patch			*/
	WORD	offset;					/* Offset in that library			*/
	FuncPtr	newfunc;				/* Replacement function to call		*/
} PatchInit[] = {
	PATCH_END,
	PATCH_DEF(	EXEC_LIB,		FindPort		),	/* GID_FINDPORT			*/
	PATCH_DEF(	EXEC_LIB,		FindResident	),	/* GID_FINDRESIDENT		*/
	PATCH_DEF(	EXEC_LIB,		FindSemaphore	),	/* GID_FINDSEMAPHORE	*/
	PATCH_DEF(	EXEC_LIB,		FindTask		),	/* GID_FINDTASK			*/
	PATCH_DEF(	INTUITION_LIB,	LockPubScreen	),	/* GID_LOCKSCREEN		*/
	PATCH_DEF(	EXEC_LIB,		OpenDevice		),	/* GID_OPENDEVICE		*/
	PATCH_DEF(	GRAPHICS_LIB,	OpenFont		),	/* GID_OPENFONT			*/
	PATCH_DEF(	EXEC_LIB,		OpenLibrary		),	/* GID_OPENLIBRARY		*/
	PATCH_DEF(	EXEC_LIB,		OpenResource	),	/* GID_OPENRESOURCE		*/
	PATCH_DEF(	ICON_LIB,		FindToolType	),	/* GID_READTOOLTYPES	*/
	PATCH_DEF(  EXEC_LIB,		PutMsg      	),	/* GID_SENDREXX        	*/

	PATCH_DEF(	DOS_LIB,		CurrentDir		),	/* GID_CHANGEDIR		*/
	PATCH_DEF(	DOS_LIB,		DeleteFile		),	/* GID_DELETE			*/
	PATCH_DEF(	DOS_LIB,		Execute			),	/* GID_EXECUTE			*/
	PATCH_DEF(	DOS_LIB,		GetVar			),	/* GID_GETVAR			*/
	PATCH_DEF(	DOS_LIB,		LoadSeg			),	/* GID_LOADSEG			*/
	PATCH_DEF(	DOS_LIB,		Lock			),	/* GID_LOCKFILE			*/
	PATCH_DEF(	DOS_LIB,		CreateDir		),	/* GID_MAKEDIR			*/
	PATCH_DEF(	DOS_LIB,		MakeLink		),	/* GID_MAKELINK			*/
	PATCH_DEF(	DOS_LIB,		Open			),	/* GID_OPENFILE			*/
	PATCH_DEF(	DOS_LIB,		Rename			),	/* GID_RENAME			*/
	PATCH_DEF(	DOS_LIB,		RunCommand		),	/* GID_RUNCOMMAND		*/
	PATCH_DEF(	DOS_LIB,		SetVar			),	/* GID_SETVAR			*/
	PATCH_DEF(	DOS_LIB,		SystemTagList	),	/* GID_SYSTEM			*/

	/*
	 *		Now the paired functions that track their partner's state
	 */
	PATCH_DEF(	ICON_LIB,		MatchToolValue	),	/* GID_READTOOLTYPES2	*/
	PATCH_DEF(	DOS_LIB,		NewLoadSeg		),	/* GID_LOADSEG2			*/
	PATCH_DEF(	DOS_LIB,		FindVar   		),	/* GID_GETVAR2 			*/
	PATCH_DEF(	DOS_LIB,		DeleteVar 		),	/* GID_SETVAR2  		*/
	PATCH_DEF(  DOS_LIB,		AddDosEntry	    ),	/* GID_ADDDOSENTRY		*/

	PATCH_END
};

#define PatchInitCount	(sizeof(PatchInit) / sizeof(PatchInit[0]))
#define PatchInitSize	(PatchInitCount * sizeof(Patch))

/*
 *		This anchor structure is used to let us locate the patches if we
 *		quit SnoopDos and then rerun it -- the patches themselves always
 *		stay in memory once loaded.
 */
typedef struct {
	Semaphore	sem;			/* Semaphore to arbitrate access to patches	*/
	char		name[30];		/* Somewhere permanent to store sem name	*/
	Patch		patchdata[1];	/* This is an open-ended array				*/
} PatchAnchorData;

PatchAnchorData *PatchAnchor;	/* Points to the current patch anchor		*/

/*
 *		If SAS/C allowed us to examine the value of Enum types from
 *		within the preprocessor, the following check would actually work
 */
#if SASC_ALLOWS_ENUM_CHECKS
#if (sizeof(PatchInit)/sizeof(PatchInit[0])) < (GID_NUMPATCHES+1)
#error "PatchInit[] table has too few entries for patches"
#else
#if (sizeof(PatchInit)/sizeof(PatchInit[0])) > (GID_NUMPATCHES+1)
#error "PatchInit[] table has too many entries for patches"
#endif
#endif
#endif

void *LibList[NUM_LIBS];

Patch *PatchList;

/*
 *		Now we have a big table of DOS packets that we recognise while
 *		monitoring. For each packet, we record the internal AmigaDOS ID
 *		we use to recognise it, the message ID of its name, the number
 *		of dp_Args to display, and the number of results to display.
 */

/*		The following constants define how many parameters are returned
 *		by the handler when it receives this packet. PK_0 means there is
 *		no return value, PK_1 means 1 return value, PK_2 means there are
 *		two return values (with the second being the error code if the
 *		first one indicates failure) and PK_2OK means there are two actual
 *		returned values, both of which are legitimate.
 */
#define PK_0			0			/* No return value from this packet		*/
#define PK_1			1			/* One return value from this packet	*/
#define PK_2			2			/* Two return values from this packet	*/
#define PK_2OK			3			/* Two return values even when okay		*/
#define PK_MASK			3			/* Used to extract PK_CODE				*/

/*
 *		How to detect when an event failed. Selecting none of these means
 *		that the packet can never fail.
 */
#define PKF_BOOL		0x08		/* True if zero result == fail			*/
#define PKF_NEG			0x10		/* True if -1 result == fail			*/

/*
 *		We want to completely ignore some packets, namely all those sent
 *		by the handler to lower level devices like timer.device or scsi.device
 *		for its own needs. We use PK_IGNORE to identify all such packets
 *		so we can discard them.
 *
 *		PK_COMMON packets are those which are monitored when the
 *		"Monitor Packets" option is enabled. These are connected
 *		with the associated DOS functions Open(), Lock() etc. and
 *		are output as such by SnoopDos, rather than as raw packets.
 *
 *		PK_RAW is used for our sentinel packet which indicates that
 *		even the packet type should be output since it's not recognised.
 */
#define PK_COMMON		0x20		/* Common packet (Open, Lock, etc.)		*/
#define PK_RAW			0x40		/* Completely raw packet				*/
#define PK_IGNORE		0x80		/* Ignore this packet completely		*/

/*
 *		Most packets return a value in dp_Res1 and if that value is
 *		zero or -1, then the error code is in dp_Res2. We define
 *		two constants to handle these common case.
 */
#define PK_BOOLEAN		(PKF_BOOL | PK_2)
#define PK_NEGATIVE		(PKF_NEG  | PK_2)

/*
 *		Warning: this table MUST be sorted by packet ID in ascending order,
 *		since a binary search is used to locate packet types
 */
#define LAST_PACK_MSG		0

struct PacketRef {
	UWORD	packetid;				/* The ID we watch out for				*/
	UWORD	msgid;					/* The name of the action to print		*/
	UBYTE	numparams;				/* Number of parameters to display		*/
	UBYTE	flags;					/* How to interpret the result			*/
} PacketTable[] = {
	ACTION_STARTUP,			MSG_ACT_STARTUP,		 1, PK_1,
	ACTION_GET_BLOCK,		MSG_ACT_GET_BLOCK,		 1, PK_IGNORE,
	ACTION_SET_MAP,			MSG_ACT_SET_MAP,		 1, PK_IGNORE,
	ACTION_DIE,				MSG_ACT_DIE,			 0, PK_BOOLEAN,
	ACTION_EVENT,			MSG_ACT_EVENT,			 1, PK_IGNORE,
	ACTION_CURRENT_VOLUME,	MSG_ACT_CURRENT_VOLUME,	 1, PK_2OK,
	ACTION_LOCATE_OBJECT,	MSG_ACT_LOCATE_OBJECT,	 3, PK_BOOLEAN | PK_COMMON,
	ACTION_RENAME_DISK,		MSG_ACT_RENAME_DISK,	 1, PK_BOOLEAN,
	ACTION_FREE_LOCK,		MSG_ACT_FREE_LOCK,		 1, PK_BOOLEAN,
	ACTION_DELETE_OBJECT,	MSG_ACT_DELETE_OBJECT,	 2, PK_BOOLEAN | PK_COMMON,
	ACTION_RENAME_OBJECT,	MSG_ACT_RENAME_OBJECT,	 4, PK_BOOLEAN | PK_COMMON,
	ACTION_MORE_CACHE,		MSG_ACT_MORE_CACHE,		 1, PKF_BOOL   | PK_2OK,
	ACTION_COPY_DIR,		MSG_ACT_COPY_DIR,		 1, PK_BOOLEAN,
	ACTION_WAIT_CHAR,		MSG_ACT_WAIT_CHAR,		 1, PKF_BOOL   | PK_2OK,
	ACTION_SET_PROTECT,		MSG_ACT_SET_PROTECT,	 4, PK_BOOLEAN,
	ACTION_CREATE_DIR,		MSG_ACT_CREATE_DIR,		 2, PK_BOOLEAN | PK_COMMON,
	ACTION_EXAMINE_OBJECT,	MSG_ACT_EXAMINE_OBJECT,	 2, PK_BOOLEAN,
	ACTION_EXAMINE_NEXT,	MSG_ACT_EXAMINE_NEXT,	 2, PK_BOOLEAN,
	ACTION_DISK_INFO,		MSG_ACT_DISK_INFO,		 1, PK_BOOLEAN,
	ACTION_INFO,			MSG_ACT_INFO,			 2, PK_BOOLEAN,
	ACTION_FLUSH,			MSG_ACT_FLUSH,			 0, PK_BOOLEAN,
	ACTION_SET_COMMENT,		MSG_ACT_SET_COMMENT,	 4, PK_BOOLEAN,
	ACTION_PARENT,			MSG_ACT_PARENT,			 1, PK_BOOLEAN,
	ACTION_TIMER,			MSG_ACT_TIMER,			 1, PK_IGNORE,
	ACTION_INHIBIT,			MSG_ACT_INHIBIT,		 1, PK_BOOLEAN,
	ACTION_DISK_TYPE,		MSG_ACT_DISK_TYPE,		 1, PK_IGNORE,
	ACTION_DISK_CHANGE,		MSG_ACT_DISK_CHANGE,	 1, PK_1,
	ACTION_SET_DATE,		MSG_ACT_SET_DATE,		 4, PK_BOOLEAN,
	ACTION_SAME_LOCK,		MSG_ACT_SAME_LOCK,		 2, PK_BOOLEAN,
	ACTION_READ,			MSG_ACT_READ,			 3, PK_NEGATIVE,
	ACTION_WRITE,			MSG_ACT_WRITE,			 3, PK_NEGATIVE,
	ACTION_SCREEN_MODE,		MSG_ACT_SCREEN_MODE,	 1, PK_BOOLEAN,
	ACTION_CHANGE_SIGNAL,	MSG_ACT_CHANGE_SIGNAL,	 3, PKF_BOOL   | PK_2OK,
	ACTION_READ_RETURN,		MSG_ACT_READ_RETURN,	 1, PK_IGNORE,
	ACTION_WRITE_RETURN,	MSG_ACT_WRITE_RETURN,	 1, PK_IGNORE,
	ACTION_FINDUPDATE,		MSG_ACT_FINDUPDATE,		 3, PK_BOOLEAN | PK_COMMON,
	ACTION_FINDINPUT,		MSG_ACT_FINDINPUT,		 3, PK_BOOLEAN | PK_COMMON,
	ACTION_FINDOUTPUT,		MSG_ACT_FINDOUTPUT,		 3, PK_BOOLEAN | PK_COMMON,
	ACTION_END,				MSG_ACT_END,			 1, PK_BOOLEAN,
	ACTION_SEEK,			MSG_ACT_SEEK,			 3, PK_NEGATIVE,
	ACTION_FORMAT,			MSG_ACT_FORMAT,			 2, PK_BOOLEAN,
	ACTION_MAKE_LINK,		MSG_ACT_MAKE_LINK,		 4, PK_BOOLEAN | PK_COMMON,
	ACTION_SET_FILE_SIZE,	MSG_ACT_SET_FILE_SIZE,	 3, PK_NEGATIVE,
	ACTION_WRITE_PROTECT,	MSG_ACT_WRITE_PROTECT,	 2, PK_BOOLEAN,
	ACTION_READ_LINK,		MSG_ACT_READ_LINK,		 4, PK_BOOLEAN,
	ACTION_FH_FROM_LOCK,	MSG_ACT_FH_FROM_LOCK,	 2, PK_BOOLEAN,
	ACTION_IS_FILESYSTEM,	MSG_ACT_IS_FILESYSTEM,	 0, PK_BOOLEAN,
	ACTION_CHANGE_MODE,		MSG_ACT_CHANGE_MODE,	 3, PK_BOOLEAN,
	ACTION_COPY_DIR_FH,		MSG_ACT_COPY_DIR_FH,	 1, PK_BOOLEAN,
	ACTION_PARENT_FH,		MSG_ACT_PARENT_FH,		 1, PK_BOOLEAN,
	ACTION_EXAMINE_ALL,		MSG_ACT_EXAMINE_ALL,	 5, PK_BOOLEAN,
	ACTION_EXAMINE_FH,		MSG_ACT_EXAMINE_FH,		 2, PK_BOOLEAN,
	ACTION_EXAMINE_ALL_END,	MSG_ACT_EXAMINE_ALL_END, 5, PK_BOOLEAN,
	ACTION_SET_OWNER,		MSG_ACT_SET_OWNER,		 4, PK_BOOLEAN,
	ACTION_DOUBLE,			MSG_ACT_DOUBLE,			 3, PK_BOOLEAN,
	ACTION_FORCE,			MSG_ACT_FORCE,			 3, PK_BOOLEAN,
	ACTION_STACK,			MSG_ACT_STACK,			 3, PK_BOOLEAN,
	ACTION_QUEUE,			MSG_ACT_QUEUE,			 3, PK_BOOLEAN,
	ACTION_DROP,			MSG_ACT_DROP,			 1, PK_BOOLEAN,
	ACTION_LOCK_RECORD,		MSG_ACT_LOCK_RECORD,	 5, PK_BOOLEAN,
	ACTION_FREE_RECORD,		MSG_ACT_FREE_RECORD,	 3, PK_BOOLEAN,
	ACTION_ADD_NOTIFY,		MSG_ACT_ADD_NOTIFY,		 1, PK_BOOLEAN,
	ACTION_REMOVE_NOTIFY,	MSG_ACT_REMOVE_NOTIFY,	 1, PK_BOOLEAN,
	ACTION_SERIALIZE_DISK,	MSG_ACT_SERIALIZE_DISK,	 0, PK_BOOLEAN,
	ACTION_GET_DISK_FSSM,	MSG_ACT_GET_DISK_FSSM,	 0, PK_BOOLEAN,
	ACTION_FREE_DISK_FSSM,	MSG_ACT_FREE_DISK_FSSM,	 0, PK_BOOLEAN,
	/*
 	 *		Our final table entry is used as a sentinel -- we key off the
	 *		final packet message as an indication that we're finished
	 *		searching the table.
 	 */
	0,						LAST_PACK_MSG,			 4, PK_2OK | PK_RAW
};

#define NUM_PACKETS		(sizeof(PacketTable) / sizeof(PacketTable[0]))

/*****************************************************************************
 *
 *		Start of functions!
 *
 *****************************************************************************/

/*
 *		InitPatches()
 *
 *		Sets up the library pointers and makes sure all the patch
 *		code vectors are initialised properly.
 *
 *		Also allocates memory for the patches (if necessary)
 *
 *		Returns TRUE for success, FALSE for failure.
 */
int InitPatches(void)
{
	struct PatchInitTable *pi;
	Patch *p;
	int i;

	/*
	 *		Before doing anything else, do a quick check to ensure that
	 *		the patch code in PATCHCODE.S agrees with the equivalent patch
	 *		structure defined in this file.
	 */
	if (CODESIZE != PatchCode_Size || STACKADJUST != PatchCode_StackAdjust) {
		Printf("In patches.c, adjust CODESIZE by %ld and STACKADJUST by %ld\n",
				PatchCode_Size-CODESIZE, PatchCode_StackAdjust-STACKADJUST);
		return (FALSE);
	}

	LibList[DOS_LIB]		= DOSBase;
	LibList[EXEC_LIB]		= SysBase;
	LibList[INTUITION_LIB]	= IntuitionBase;
	LibList[GRAPHICS_LIB]	= GfxBase;
	LibList[ICON_LIB]		= IconBase;

	/*
	 *		First, let's calculate our ROM start and end address.
	 *		We do this by getting the address pointed to by the
	 *		Open LVO vector in exec.library and rounding it down
	 *		to the nearest 512K
	 */
	RomStart = (*((ULONG *)(((char *)SysBase) + LIB_OPEN + 2))) & 0xFFF80000;
	RomEnd   = RomStart + 0x7FFFF;

	/*
	 *		Now see if the patches were already installed by an earlier
	 *		version of SnoopDos.
	 */
	Forbid();
	PatchAnchor = (PatchAnchorData *)FindSemaphore(PATCHES_NAME);
	if (!PatchAnchor) {
		/*
		 *		Patches weren't found, so allocate a new set and initialise
		 *		it with our patch code.
		 */
		PatchAnchor = AllocMem(sizeof(PatchAnchorData) + PatchInitSize,
							   MEMF_ANY | MEMF_CLEAR);
		if (!PatchAnchor) {
			Permit();
			return (FALSE);
		}
		strcpy(PatchAnchor->name, PATCHES_NAME);
		PatchAnchor->sem.ss_Link.ln_Name = PatchAnchor->name;
		PatchAnchor->sem.ss_Link.ln_Pri  = 0;
		AddSemaphore(&PatchAnchor->sem);
	}
	/*
	 *		Now PatchAnchor points to our patch list in memory -- copy over
	 *		our patch code and initialised data accordingly.
	 */
	PatchList = PatchAnchor->patchdata;
	for (pi = PatchInit+1, p = PatchList+1; pi->offset; p++, pi++) {
		memcpy(p->code, PatchCode_Start, CODESIZE);
		p->library		= pi->library;
		p->offset		= pi->offset;
		p->newfunc		= pi->newfunc;
		p->stackneeded	= CurSettings.StackLimit;
		p->sysbase		= SysBase;
	}
	CacheClearU();	/* Invalidate cache for code we just built */
	Permit();

	/*
	 *		Now initialise other variables associated with the patch code
	 */
	SnoopTask	= SysBase->ThisTask;
	InputTask	= FindTask("input.device");
	InitRamLibPatch();
	InitSemaphore(&PatternBufSem);
	InitSemaphore(&PatternCacheSem);
	InitSemaphore(&TaskCacheSem);
	InitSemaphore(&DosDeviceSem);
	InitSemaphore(&PauseSem);
	InitSemaphore(&PacketSem);

	UpdateDeviceList(SCANDEV_IMMEDIATE);

	NewList(&PatternList);
	for (i = 0; i < NUM_PCACHE_ENTRIES; i++)
		AddHead(&PatternList, (Node *)&PCacheEntries[i]);
	
	NewList(&PacketWaitList);
	NewList(&PacketFreeList);
	for (i = 0; i < NUM_PACKET_ENTRIES; i++)
		AddHead(&PacketFreeList, (Node *)&PacketEntries[i]);

	NewEventSig = AllocSignal(-1);
	if (NewEventSig == -1)
		return (FALSE);
	NewEventMask = 1 << NewEventSig;

	/*
	 *		Signal bit used to tell main task to rescan device list because
	 *		a device was added (or removed?)
	 */
	ScanDosListSig = AllocSignal(-1);
	if (ScanDosListSig == -1)
		return (FALSE);
	ScanDosListMask = 1 << ScanDosListSig;

	/*
	 *		Now create a background process to handle process matching.
	 *		We run this at a high priority to ensure quick response.
	 *
	 *		We first of all initialise our pattern port, and set it
	 *		to NOT signal our task when a message arrives. This ensures
	 *		that if, for some reason, our new process doesn't run
	 *		until after someone tries to send it a message, nothing
	 *		bad will happen (e.g. signalling a task at 0x0000)
	 *		
	 *		The background process itself will replace this with
	 *		PA_SIGNAL to make things work normally again.
	 */
	NewList(&BackgroundPort.mp_MsgList);
	BackgroundPort.mp_Flags = PA_IGNORE;
	BackgroundProc = CreateNewProcTags(NP_Entry,     BackgroundProcCode,
					   				   NP_Name, 	 BACKGROUND_NAME,
									   NP_Priority,  5,
					   				   TAG_DONE);

	return (BackgroundProc != NULL);
}

/*
 *		UpdatePatches()
 *
 *		Scans the list of patches, updating our behaviour as follows.
 *		This means:
 *
 *			- Any patch that's currently active and which has been flagged
 *			  as inactive should be disabled if possible (i.e. origfunc
 *			  set to NULL).
 *
 *			- Any patch that's currently inactive and which has been flagged
 *			  as active should be enabled if possible (i.e. origfunc set
 *			  to point to the original function).
 *
 *		If we are currently Disabled, then all patches are made inactive.
 *		
 */
void UpdatePatches(void)
{
	Patch *p;

	if (!PatchList)
		return;

	if (MonPackets || ShowAllPackets)
		UpdateDeviceList(SCANDEV_IMMEDIATE); /* Keep device list up to date */

	Forbid();			/* Don't even think about letting anyone else run! */

	/*
	 *		Update status of pair functions to reflect the master
	 *		function's status
	 */
	PatchList[GID_READTOOLTYPES2].enabled	=
							PatchList[GID_READTOOLTYPES].enabled;
	PatchList[GID_LOADSEG2].enabled			=
							PatchList[GID_LOADSEG].enabled;
	PatchList[GID_GETVAR2].enabled			=
							PatchList[GID_GETVAR].enabled;
	PatchList[GID_SETVAR2].enabled			=
							PatchList[GID_SETVAR].enabled;

	for (p = PatchList+1; p->offset; p++) {
		void *lib        = LibList[p->library];
		int func_enabled = (Disabled ? PATCH_DISABLED : p->enabled);

		p->stackneeded	 = CurSettings.StackLimit;	/* Update this */

		if (!lib)			/* Skip over any libraries we couldn't open */
			continue;

		if (p->origfunc == NULL && func_enabled != PATCH_DISABLED) {
			/*
			 *		Okay, we want to enable this function.
			 */
			p->origfunc = (FuncPtr)SetFunction(lib, p->offset, (FuncPtr)p);
		} else if (p->origfunc && func_enabled == PATCH_DISABLED) {
			/*
			 *		Okay, we want to disable this function. However, we
			 *		may not be able to do this cleanly, if it's been
			 *		since patched by someone else. Thus, if our attempt
			 *		to unpatch it doesn't return a pointer to our replacement
			 *		code, we have to leave the patch installed. However, it
			 *		will be re-tried automatically the next time someone
			 *		calls this function.
			 */
			FuncPtr curfunc = (FuncPtr)SetFunction(lib, p->offset, p->origfunc);

			if (curfunc != (FuncPtr)p) {
				/*
				 *		Uhoh -- someone else patched us!
				 */
				SetFunction(lib, p->offset, (FuncPtr)curfunc);
			} else {
				/*
				 *		We unpatched successfully, so zero pointer
				 */
				p->origfunc = NULL;
			}
		}
	}
	/*
	 *		We disable stack monitoring for the PutMsg() patch because
	 *		we need to catch the return packet from small-stack processes
	 *		like RAM: etc. Instead, that patch does its own stack checking.
	 */
	PatchList[GID_SENDREXX].stackneeded = 0;

	CacheClearU();	/* Just to be safe */
	Permit();
	/*
	 *		Finally, check if we've disabled packet monitoring and
	 *		there are some outstanding packets that have not yet had
	 *		return values assigned. Free them all as appropriate
	 */
	if (!MonPackets && !ShowAllPackets)
	{
		for (;;) {
			WaitPacket *wp;
			Event *ev;
			LONG  seqnum;

			ObtainSemaphore(&PacketSem);
			if (IsListEmpty(&PacketWaitList)) {
				ReleaseSemaphore(&PacketSem);
				break;
			}
			wp 	   = (WaitPacket *)RemHead(&PacketWaitList);
			AddHead(&PacketFreeList, (Node *)wp);
			ev	   = wp->event;
			seqnum = wp->eventnum;
			ReleaseSemaphore(&PacketSem);

			ObtainSemaphore(&BufSem);
			if (seqnum >= RealFirstSeq) {
				ev->status = ES_READY;
				Signal(SnoopTask, NewEventMask);
			}
			ReleaseSemaphore(&BufSem);
		}
	}
}

/*
 *		CleanupPatches()
 *
 *		Frees any resources allocated when initialising this module. Also
 *		disable any patches that are still active.
 */
void CleanupPatches(void)
{
	static int unpatchtries = 0;

	if (PatchList) {
		struct PatchInitTable *pi;
		Patch *p;

		for (p = PatchList+1; p->offset; p++)
			p->enabled = PATCH_DISABLED;
		UpdatePatches();

		/*
		 *		Now our patches have been disabled, and it's time to
		 *		ensure nobody got left inside our code. We do this by
		 *		checking that all the usecounts are set to zero, and if
		 *		they're not, giving the user the option of continuing
		 *		to try, or exiting.
		 *
		 *		Before we do this, however, we record all the functions
		 *		which still have a usecount > 0 -- this way, if someone
		 *		else runs SnoopDos while we are checking and installs
		 *		a new set of patches in the patchtable, and enables
		 *		some additional functions, we don't have to check that
		 *		ALL usage counts are zero, only those which were non-zero
		 *		at the start of the loop.
		 *
		 *		(That is, we ignore any usage counts which are results of
		 *		functions being re-enabled by the new SnoopDos -- typically,
		 *		there will only be one or two functions at most to be
		 *		checked.)
		 *
		 *		For convenience, we re-use the PatchInit list to hold the
		 *		exit "usage" states for each function -- we won't be needing
		 *		it any more.
		 */
		for (p = (PatchList+1), pi = (PatchInit+1); p->offset; p++, pi++)
			pi->offset = p->usecount;

		for (;;) {
			for (p = (PatchList+1), pi = (PatchInit+1); p->offset; p++, pi++) {
				if (pi->offset > 0) {
					if (p->usecount > 0)
						break;
					pi->offset = 0;	/* No longer active, so mark as done */
				}
			}
			if (p->offset) {
				/*
				 *		Couldn't unpatch, so go around the loop and try
				 *		again. After about 8-10 seconds, we warn the user
				 *		that we're still trying.
				 */
				unpatchtries++;
				if (unpatchtries == 5) {
					char errorbuf[400];
					
					mysprintf(errorbuf, MSG(MSG_ERROR_UNPATCH),
							  GetFuncName(p - PatchList));
					ShowError(errorbuf);
				}
				Delay(2*50);		/* Wait 2 seconds before next try */
			} else
				break;
		}
	}
	if (BackgroundProc) {
		/*
		 *		Send a terminate message to the pattern process and wait
		 *		for it to respond
		 */
		PatternMsg pmsg;

		pmsg.type                = QUIT_MSG;
		pmsg.sigmask			 = SIGF_SINGLE;
		pmsg.task				 = SysBase->ThisTask;
		pmsg.msg.mn_Node.ln_Name = NULL;

		SetSignal(0, SIGF_SINGLE);		/* Ensure signal is clear first */
		PutMsg(&BackgroundPort, &pmsg);	/* Send quit message to process	*/
		Wait(SIGF_SINGLE);				/* Wait for acknowledgement		*/
	}
	if (NewEventSig    != -1) FreeSignal(NewEventSig),    NewEventSig    = -1;
	if (ScanDosListSig != -1) FreeSignal(ScanDosListSig), ScanDosListSig = -1;
}

/*
 *		InitRamLibPatch()
 *
 *		Attempts to patch the ramlib process so that it no longer uses
 *		a message port with the signal bit set to SIGB_SINGLE (which
 *		is asking for trouble if you call any functions that use
 *		semaphores, since a SIGB_SINGLE can be generated by a message
 *		arriving at the message port while waiting for the semaphore,
 *		causing all hell to break loose -- the semaphore appears to be
 *		obtained while in fact it's still in use by someone else).
 */
void InitRamLibPatch(void)
{
	unsigned char *ramdata;
	int i;
	
	RealRamLibTask = FindTask("ramlib");
	if (NoPatchRamLib || !RealRamLibTask) {
		/*
		 *		Not patching ramlib, so instead, install our bypass patch
		 *		that stops us from monitoring any ramlib tasks so that
		 *		we won't get crashed.
		 */
		RamLibTask = RealRamLibTask;
	} else {
		/*
		 *		Patch ramlib itself so that it doesn't use SIGF_SINGLE
		 *		any more.
		 */
		ramdata = (void *)SysBase->ex_RamLibPrivate;
		if (!ramdata) {
			/*
			 *		You never know ... this field may no longer exist. If
			 *		it doesn't, then assume the bug no longer exists either
			 *		and exit.
			 */
			return;
		}
		for (i = 0x20; i < 0x50; i += 2) {
			struct MsgPort *ramport = (struct MsgPort *)(ramdata + i);

			/*
			 *		Depending on the Kickstart version (V37 through V40)
			 *		the ramlib message port lies somewhere in the range
			 *		0x30 to 0x50 of the ramlib's private area. We do
			 *		some integrity checks on the port to make sure it's
			 *		not just a lucky hit. If some future SetPatch fixes
			 *		this, then we will never find a match, which suits
			 *		us fine.
			 */
			if (ramport->mp_Flags   == 0			&&
				ramport->mp_SigBit  == SIGB_SINGLE	&&
				ramport->mp_SigTask == RealRamLibTask)
			{
				/*
				 *		Now patch ramlib's message port so it won't use
				 *		SIGB_SINGLE any more. This is a little tricky, since
				 *		ramlib process will be in the middle of WaitPort()
				 *		and WaitPort() won't return until a message arrives at
				 *		the port. Essentially, we can only change the port's
				 *		message bit while we are sure that the ramlib process
				 *		is NOT in a WaitPort(). We do this by bumping our
				 *		process priority up to 127 temporarily, making the
				 *		call, and then restoring it.
				 *
				 *		Since we're at a higher priority than ramlib, then
				 *		as soon as ramlib responds to the message, it will
				 *		be switched out (in the Ready state) before it has a
				 *		chance to call WaitPort() and go back to sleep again.
				 */
				ULONG oldpri;

				Forbid();
				oldpri = SetTaskPri(SysBase->ThisTask, 127);
				OpenLibrary("ramlib-patch.library", 0);	/* Wake-up ramlib */
				ramport->mp_SigBit = SIGBREAKB_CTRL_E;
				SetTaskPri(SysBase->ThisTask, oldpri);
				Permit();
				break;
			}
		}
	}
}

/*
 *		UpdateDeviceList(method)
 *
 *		Updates the DOS device list. This is used to keep an internal list
 *		of all the task IDs of DOS handlers so we can quickly determine
 *		if a given ID belongs to a handler or not.
 *
 *		This should be called at least once, and ideally every now and
 *		again, so that new devices added to the DOS list can be detected
 *		and old ones ignored.
 *
 *		The method can be SCANDEV_IMMEDIATE, to immediately scan the device
 *		list, or SCANDEV_DELAY to wait for a second before updating. The
 *		delay is because the patch that signals us to rescan (AddDosEntry)
 *		happens before the device is actually fully initialised, so we need
 *		to give it a little extra time to get going.
 *
 *		It's not critical if we don't give it enough time, it just means
 *		that the new device won't appear in the list after all -- a bit
 *		annoying for people using the packet debugger to help debug a
 *		device they keep mounting interactively.
 */
void UpdateDeviceList(int method)
{
	struct DosList *dlist;
	int i = 0;

	if (method == SCANDEV_DELAY)
		Delay(50);

	ObtainSemaphore(&DosDeviceSem);
	dlist = LockDosList(LDF_DEVICES | LDF_READ);
	while ((dlist = NextDosEntry(dlist, LDF_DEVICES))
			 && i < (MAX_DOS_DEVICES-1))
	{
		if (dlist->dol_Task)
			DeviceTaskList[i++] = dlist->dol_Task->mp_SigTask;
	}
	UnLockDosList(LDF_DEVICES | LDF_READ);
	DeviceTaskList[i] = 0;
#if 0
	Printf("New device list:\n");
	for (i = 0; DeviceTaskList[i]; i++)
		Printf("    %2ld = %s\n", i, DeviceTaskList[i]->tc_Node.ln_Name);
#endif
	ReleaseSemaphore(&DosDeviceSem);
}

/*
 *		SetPattern(string, ignorewb)
 *
 *		Sets the current pattern to the given string (possibly containing
 *		wildcards). If ignorewb is true, then the pattern is modified to
 *		also exclude any processes with the names Workbench, Shell Process
 *		or Background CLI.
 */
void SetPattern(char *pattern, int ignorewb)
{
	PatternCache *pc;
	char *p;

	if (*pattern == '\0' && !ignorewb) {
		PatternEnabled = 0;
		return;
	}
	ObtainSemaphore(&PatternCacheSem);
	ObtainSemaphore(&PatternBufSem);
	PatternEnabled = 0;

	/*
	 *		Now, update our pattern string. If the pattern string is empty,
	 *		we disable patterns. If the pattern string contains no wildcards,
	 *		we enable patterns but disable wildcard patching (this is much
	 *		faster, since it can be done in the patch's task, rather than
	 *		having to call back to the main routine).
	 *
	 *		We allocate both pattern semaphores: the Cache semaphore to
	 *		ensure that no pattern code can execute when PatternEnabled
	 *		is zero, and the buffer semaphore to ensure that the pattern
	 *		process doesn't try to do pattern matching while we are
	 *		building the new pattern string.
	 *
	 *		We need to be careful to get the cache semaphore BEFORE we get
	 *		the pattern buffer semaphore, otherwise we could deadlock if
	 *		a patch decided to check a pattern at just the wrong time.
	 */
	if (ignorewb) {
		if (*pattern == '\0')
			strcpy(PatternString, PAT_EASY_EXCLUDE);
		else
			mysprintf(PatternString, PAT_COMPLEX_EXCLUDE, pattern);
	} else
		strcpy(PatternString, pattern);

	/*
	 *		Now, due to a bug in AmigaDOS's ParsePatternNoCase, we
	 *		have to convert the string to upper case first. (The bug
	 *		is that character classes like [a-z] will never match anything,
	 *		only [A-Z] will work. Since it's case insensitive for
	 *		everything else, we simply convert everything to upper case.)
	 */
	for (p = PatternString; *p; p++) {
		if (*p >= 'a' && *p <= 'z')
			*p &= 0x5F;
	}
	PatternWildcard = ParsePatternNoCase(PatternString,
										 PatternBuf, PAT_BUF_LEN);

	if (PatternWildcard != -1)	/* Only enable patterns if successful */
		PatternEnabled = 1;
	
	/*
	 *		Regardless of what happened, invalidate the pattern cache
	 *		to force a new match for each task name.
	 */
	FORLIST(&PatternList, pc)
		pc->task = NULL;

	ReleaseSemaphore(&PatternBufSem);
	ReleaseSemaphore(&PatternCacheSem);
}

/*
 *		FlushWaitingPackets(void)
 *
 *		Flushes any packets currently in the waiting packets queue
 *		(marking them as missed). Usually called after packet monitoring
 *		has been disabled, in case there were any half-completed packets
 *		in the queue.
 */
void FlushWaitingPackets(void)
{
	WaitPacket *wp;
	int flushed = 0;

	ObtainSemaphore(&PacketSem);
	wp = HeadNode(&PacketWaitList);
	while (NextNode(wp)) {
		ULONG seqnum = wp->eventnum;
		Event *ev    = wp->event;

		Remove((Node *)wp);
		AddHead(&PacketFreeList, (Node *)wp);
		ReleaseSemaphore(&PacketSem);	/* Never lock two sem's at once! */
		ObtainSemaphore(&BufSem);
		if (seqnum >= RealFirstSeq) {
			ev->result = MSG(MSG_RES_MISSED);
			ev->status = ES_READY;
			flushed    = 1;
		}
		ReleaseSemaphore(&BufSem);
		ObtainSemaphore(&PacketSem);
		wp = HeadNode(&PacketWaitList);
	}
	ReleaseSemaphore(&PacketSem);

	if (flushed)
		Signal(SnoopTask, NewEventMask);
}

/*
 *		LoadFuncSettings(FuncSets)
 *
 *		Downloads the values in the passed-in FuncSettings array to the
 *		various local structures that require them.
 */
void LoadFuncSettings(FuncSettings *func)
{
	Patch *p;
	int i;

	if (!PatchList)
		return;

	Forbid();
	for (p = PatchList+1, i = 1; p->offset; p++, i++)
		p->enabled = ((func->Opts[i] && !Disabled) ?
							PATCH_ENABLED : PATCH_DISABLED);
	/*
	 *		A bit of a hack -- the PutMsg() function is needed to monitor
	 *		three individual patches: SendRexx, Monitor Packets, and
	 *		Packet Debugger. We do the check for the last two here.
	 */
	if ((func->Opts[GID_MONPACKETS] || func->Opts[GID_MONALLPACKETS]) &&
	     !Disabled)
	{
		PatchList[GID_SENDREXX].enabled    = PATCH_ENABLED;
		PatchList[GID_ADDDOSENTRY].enabled = PATCH_ENABLED;
	} else {
		PatchList[GID_ADDDOSENTRY].enabled = PATCH_DISABLED;
		FlushWaitingPackets();
	}
	UpdatePatches();
	Permit();
	SetPattern(func->Pattern, func->Opts[GID_IGNOREWB]);
}

/*
 *		BackgroundProcCode()
 *
 *		This function is called as a separate process. It is used
 *		to service requests for pattern matching by patched code.
 *		We do this in a separate process to ensure we have enough
 *		stack to perform the pattern matching (pattern matching can
 *		be very stack-intensive.)
 *
 *		This process is also used to do pathname expansion when we
 *		are monitoring packets -- this is needed for both the
 *		ShowAllPaths option and monitoring of the ACTION_MAKE_LINK packet.
 *
 *		We keep going until we get a QUIT_MSG from the main task,
 *		at which point we exit.
 */
void __saveds BackgroundProcCode(void)
{
#if DEBUG_PATTERN
	BPTR dbfile = Open("CON:100/100/400/100/Pattern/WAIT/AUTO/CLOSE",
					   MODE_OLDFILE);
#define DBP(s)	FPrintf s
#else
#define DBP(s)
#endif

	Task  *quittask;
	ULONG  quitsig;
	int    done = 0;

	/*
	 *		Our first task is to re-route the message port allocated
	 *		on our behalf by the main process so that it points to us.
	 *		We also re-enable signals on incoming messages to ensure
	 *		we are correctly interrupted.
	 */		
	BackgroundPort.mp_SigTask = SysBase->ThisTask;
	BackgroundPort.mp_SigBit  = AllocSignal(-1);	/* Better not fail!		*/
	BackgroundPort.mp_Flags   = PA_SIGNAL;			/* Allow signalling now	*/
	DBP((dbfile, "Started pattern debug code\n"));

	while (!done) {
		/*		Now handle all pattern messages queue on the pattern port.
		 *		Unlike normal messages, we don't simply reply to these
		 *		with ReplyMsg(); instead, we signal the indicated task
		 *		using the signal bit specified in the message.
		 *
		 *		This is because the sender may not have an available
		 *		signal bit to use to receive the reply so it uses a
		 *		system bit which is guaranteed to be unused.
		 *
		 *		Note that we grab the pattern semapore while we process
		 *		the messages; this stops the mainline code from updating
		 *		the middle of the buffer while we are doing a comparison.
		 */
		PatternMsg      *pmsg;
		NameFromLockMsg *lmsg;

		WaitPort(&BackgroundPort);

		ObtainSemaphore(&PatternBufSem);
		while ((pmsg = (void *)GetMsg(&BackgroundPort)) != NULL) {
			DBP((dbfile, "Got a message, type = %ld!\n", pmsg->type));
			switch (pmsg->type) {

				case QUIT_MSG:
					/*
					 *		We've been told to quit by the main task, so
					 *		set some variables appropriately. We flush
					 *		the remaining messages in the queue first
					 *		just to be safe (we wouldn't want to leave
					 *		anyone hanging, now, would we?)
					 */
					PatternEnabled	= 0;	/* Safety first */
					done	 		= 1;
					quittask		= pmsg->task;
					quitsig  		= pmsg->sigmask;
					break;

				case PATTERN_MSG:
					DBP((dbfile, "Got a pmatch from %s\n", pmsg->name));
					if (PatternEnabled)
						pmsg->match = MatchPatternNoCase(PatternBuf,
														 pmsg->name);
					else
						pmsg->match = 1; /* If disabled, everything matches */

					Signal(pmsg->task, pmsg->sigmask);
					break;

				case PATHEXPAND_MSG:
					lmsg         = (NameFromLockMsg *)pmsg;
					lmsg->newbuf = MyNameFromLock(lmsg->lock, lmsg->filename,
												  lmsg->buf,  lmsg->maxlen);
					Signal(lmsg->task, lmsg->sigmask);
					break;
			}
		}
		ReleaseSemaphore(&PatternBufSem);
	}

#if DEBUG_PATTERN
	DBP((dbfile, "Quitting...\n"));
	Close(dbfile);
#endif

	/*
	 *		Now cleanup and exit from this task. We need to Forbid()
	 *		before we signal the main task that we're ready to quit,
	 *		since otherwise the main task might go ahead and unload
	 *		us before we have a chance to execute the last few lines
	 *		in the function (e.g. if the main task is running at a
	 *		higher priority than we are).
	 */		
	Forbid();
	FreeSignal(BackgroundPort.mp_SigBit);
	Signal(quittask, quitsig);
}

/*
 *		CheckPattern(name, namelen)
 *
 *		Checks if our task's name has been masked out by the
 *		user, using our current AmigaDOS pattern string.
 *
 *		We can't call the DOS pattern match function directly, due to
 *		stack limitations (the caller may not have a very big stack).
 *		So, we maintain a cache of recently used tasks -- the first
 *		task on the list is always the most recently monitored task.
 *
 *		If a task doesn't appear on the list, or if it appears on the
 *		list but its name has changed, then we send a message to the
 *		main SnoopDos task asking it to check the pattern. We also
 *		add the result of this check to our cache for future calls.
 *
 *		Sending a message to another task from within a patch is tricky;
 *		more specifically, receiving the acknowledgement back from the
 *		main task is tricky. This is because we don't know what signal
 *		bits the caller might be using, and so we can't just grab one.
 *		We could use AllocSignal(), but then what if the caller has no
 *		free signal bits?
 *
 *		Our solution (not necessarily the best) is to use the reserved
 *		exec signal bit SIGB_SINGLE. This is used for semaphore operations,
 *		among others, and is only ever used while waiting for a single
 *		event to happen. Thus, when our code is reached, we know this
 *		bit is not in use and thus we can use it ourselves.
 *
 *		Returns true if no pattern is set, or if the pattern matches
 *		the current task name. Returns false otherwise.
 *
 */
int CheckPattern(char *taskname, int namelen)
{
	PatternCache *pc;
	Task *thistask = SysBase->ThisTask;
	PatternMsg pmsg;

	if (!PatternEnabled)
		return (TRUE);

	if (!PatternWildcard)
		return (stricmp(taskname, PatternString) == 0);

	namelen = MIN(namelen, PC_NAMELEN-1);

	/*
	 *		Got a pattern, so search our cache list
	 */
	ObtainSemaphore(&PatternCacheSem);
	FORLIST(&PatternList, pc)
		if (pc->task == thistask)
			break;
	
	/*
	 *		Okay, now pc is either the matching task, or else a pointer
	 *		to the end of our list.
	 */
	if (NextNode(pc) && pc->task == thistask) {
		/*
		 *		We broke out of the loop since we matched the task.
		 *		Now check if the name matches too.
		 */
		if (strncmp(pc->name, taskname, namelen) == 0) {
			/*
			 *		We're the same. Move this node to the start of
			 *		the list, and return the appropriate state.
			 */
			Remove((Node *)pc);
			AddHead(&PatternList, (Node *)pc);
			ReleaseSemaphore(&PatternCacheSem);
			return (pc->match);
		}
		/*
		 *		The name is different but the Task ID is the same --
		 *		most likely, someone ran a new CLI command. Thus, use
		 *		this cache entry for our new task name and fall through.
		 */
	} else {
		/*
		 *		We didn't match a task so grab one from the end of the
		 *		list and use that instead.
		 */
		pc		 = TailNode(&PatternList);
		pc->task = thistask;
	}

	/*
	 *		Move the node to the start of the list to stop it being flushed
	 *		any time soon, and update the name to match our own name.
	 */
	Remove((Node *)pc);
	AddHead(&PatternList, (Node *)pc);
	strncpy(pc->name, taskname, namelen);
	pc->name[namelen] = 0;
	ReleaseSemaphore(&PatternCacheSem);

	/*
	 *		Now send a message to the main task asking it to perform a name
	 *		match for us. We need to be careful to make sure our pmsg won't
	 *		be confused with a DOS packet by our PutMsg() patch -- we do
	 *		this by NULLing out the name field.
	 */
	pmsg.type                = PATTERN_MSG;
	pmsg.name				 = taskname;
	pmsg.sigmask			 = SIGF_SINGLE;
	pmsg.task				 = thistask;
	pmsg.msg.mn_Node.ln_Name = NULL;

	SetSignal(0, SIGF_SINGLE);		/* Ensure signal is clear first		*/
	PutMsg(&BackgroundPort, &pmsg);	/* Send request to background task	*/
	Wait(SIGF_SINGLE);				/* Wait for acknowledgement			*/
	pc->match = pmsg.match;			/* And save result in cache			*/

	return (pmsg.match);
}

/*
 *		GetVolName(lock, buf, maxlen)
 *
 *		Copies the volume name associated with lock into the buffer,
 *		with terminating ':'. If lock is NULL, the volume address is
 *		taken directly from volume.
 *
 *		If UseDevNames is true, the device list is searched looking
 *		for the device node associated with the volume node (i.e. two
 *		nodes sharing the same task address).
 *
 *		WARNING: This function must not be called from within a DOS
 *				 device handler due to potential deadlock errors!
 *
 */
void GetVolName(BPTR lock, char *buf, int maxlen)
{
	struct DeviceList *vol;
	struct DosList *dl;
	int gotdev = 0;

	if (lock == NULL) {
		NameFromLock(lock, buf, maxlen);
		return;
	}
	vol = BTOC(((struct FileLock *)BTOC(lock))->fl_Volume);

	if (UseDevNames == 0 || vol->dl_Task == NULL) {
		/*
		 *		Use volume name, especially if the volume isn't currently
		 *		mounted!
		 */
		UBYTE *volname = BTOC(vol->dl_Name); 
		int len = MIN(maxlen-2, *volname);

		memcpy(buf, volname+1, len);
		buf[len++] = ':';
		buf[len] = '\0';
		return;
	}

	/*
	 *		The user wants the device name. The only way to obtain this
	 *		is to search the device list looking for the device node with
	 *		the same task address as this volume.
	 */
	dl = LockDosList(LDF_DEVICES | LDF_READ);
	while (dl = NextDosEntry(dl, LDF_DEVICES)) {
		if (dl->dol_Task == vol->dl_Task) {
			/*
			 *		Found our task, so now copy device name
			 */
			UBYTE *devname = BTOC(dl->dol_Name);
			int len = MIN(maxlen-2, *devname);

			memcpy(buf, devname+1, len);
			buf[len++] = ':';
			buf[len] = '\0';
			gotdev = 1;
			break;
		}
	}
	UnLockDosList(LDF_DEVICES | LDF_READ);
	if (!gotdev)
		strcpy(buf, "???:");
}

/*
 *		MyNameFromLock(lock, filename, buf, maxlen)
 *
 *		This is a custom version of the DOS function NameFromLock()
 *		which expands a disk lock into a full path.
 *
 *		Our version adds the following features. The device name will be
 *		given as either the physical device (like DH0:) if UseDevNames
 *		is true, or the volume name (like System3.0:) if UseDevNames is
 *		false.
 *
 *		If filename is non-NULL, then it will be appended to the lock
 *		path. If filename contains path info, then this will be taken
 *		into account when generating the lock, so that an absolute path
 *		in filename will not have any effect, and a relative filename
 *		(like //directory) will cause the original lock to be ParentDir()'d
 *		twice before being resolved.
 *
 *		This function can't fail. In the event of an error (string too
 *		long, or something like that), the buffer will be filled accordingly.
 *		It is assumed that the buffer will always be big enough to hold short
 *		error messages or a volume name.
 *
 *		Returns a pointer to the path (which will not necessarily be at
 *		the start of the buffer, but is guaranteed null-terminated.)
 *		Note that it's even possible that the pointer returned will be
 *		to the original filename if no path expansion was required.
 *
 *		New: We now preserve the IoErr() that was present on entry, since
 *		it may have been set by the calling function if OnlyShowFails is
 *		true. Otherwise, IoErr() will be screwed up by the operations we
 *		do here (e.g. SAS/C deleting a non-existent file when OnlyShowFails
 *		is true).
 *
 *		WARNING: This function must not be called from within a DOS
 *				 device handler due to potential deadlock errors!
 */		
char *MyNameFromLock(BPTR lock, char *filename, char *buf, int maxlen)
{
	Process *myproc = (Process *)SysBase->ThisTask;
	int pos = maxlen - 1;
	D_S(fib, struct FileInfoBlock);
	LONG savedioerr = IoErr();
	BPTR curlock;
	BPTR newlock;
	void *savewinptr;
	char *p;
	int len;
	int skipfirstslash = 0;	/* If true, skip first slash when building name */
	int err = 0;

	/*
	 *		Check for special magic filehandle
	 */
	if (filename && *filename) {
		if (strcmp(filename, "*") == 0)
			return (filename);

		/*
		 *		First determine if we have any work to do.
		 */
		if (*filename == ':') {
			/*
			 *		Got a reference relative to the root directory. Simply
			 *		grab the volume (or device) name from the lock and go
			 *		with that.
			 */
			int len;

			GetVolName(lock, buf, maxlen);
			len = strlen(buf);
			strncat(buf+len, filename+1, maxlen-len);
			buf[maxlen-1] = '\0';
			SetIoErr(savedioerr);
			return (buf);
		}
		for (p = filename; *p; p++) {
			if (*p == ':')			/* If absolute path name, leave it alone */
				return (filename);
		}
	} else {
		/*
		 *		Filename is null, so indicate we want to skip the first
		 *		slash when building the directory path
		 */
		skipfirstslash = 1;
	}

	savewinptr = myproc->pr_WindowPtr;
	myproc->pr_WindowPtr = (APTR)-1;		/* Disable error requesters	  */

	newlock = DupLock(lock);
	if (lock && !newlock) {
		GetVolName(lock, buf, 20);
		if (filename) {
			strcat(buf, ".../");
			strcat(buf, filename);
		}
		myproc->pr_WindowPtr = savewinptr;	/* Re-enable error requesters */
		SetIoErr(savedioerr);
		return (buf);
	}
	buf[pos] = '\0';
	curlock = newlock;
	if (filename) {
		while (newlock && *filename == '/') {
			/*
			 *		Handle leading /'s by moving back a directory level
			 *		but nothing else
			 */
			newlock = ParentDir(curlock);
			if (newlock) {
				UnLock(curlock);
				curlock = newlock;
				filename++;
			}
		}
		len = strlen(filename);
		if (len > (pos-2)) {
			memcpy(buf+2, filename+len-pos, pos-2);
			buf[0] = buf[1] = '.';
			pos = 0;
			UnLock(curlock);
		} else {
			pos -= len;
			memcpy(buf+pos, filename, len);
		}
	}

	/*
	 *		At this point, we have buf containing the filename (minus any
	 *		leading /'s), starting at the index given by pos. If filename
	 *		was NULL or empty, then pos indexes to a \0 terminator.
	 *
	 *		Next, we want to pre-pend directory names to the front of
	 *		the filename (assuming there _is_ a filename) until we get
	 *		to the device root.
	 */
	newlock = curlock;
	while (newlock) {

		if (!Examine(curlock, fib)) {
			err++;
			break;
		}
		len = strlen(fib->fib_FileName);
		if (len > (pos-3)) {
			/*
			 *		Not enough room: prefix dots at start to indicate
			 *		an overrun. We use pos-3 since we need one char
			 *		for a possible slash and two more to accomodate a
			 *		leading ".."
			 */
			memcpy(buf+2, fib->fib_FileName+len-pos+3, pos-2);
			buf[0] = buf[1] = '.';
			buf[pos-1] = '/';
			pos = 0;
			break;
		}
		newlock = ParentDir(curlock);
		if (newlock) {
			UnLock(curlock);
			curlock = newlock;
			pos -= len + 1;
			memcpy(buf + pos, fib->fib_FileName, len);
			if (skipfirstslash) {
				skipfirstslash = 0;
				buf[pos+len] = '\0';
			} else
				buf[pos+len] = '/';
		}
	}
	/*
	 *		Now we've built the path components; add the volume node
	 *		to the beginning if possible.
	 */
	if (err) {
		/*
		 *		If an error occurred, the volume is probably not mounted,
		 *		so we include a ".../" component in the path to show
		 *		we couldn't get all the info
		 */
		pos -= 4;
		memcpy(buf + pos, ".../", 4);
	}
	if (pos > 0) {
		char volname[20];
		int len;
		char *p;

		GetVolName(curlock, volname, 20);
		len = strlen(volname);
		if (len > pos) {
			p = volname + len - pos;
			len = pos;
		} else {
			p = volname;
		}
		pos -= len;
		memcpy(buf + pos, p, len);
	}
	if (curlock)
		UnLock(curlock);

	myproc->pr_WindowPtr = savewinptr;		/* Re-enable error requesters */
	SetIoErr(savedioerr);
	return (buf+pos);
}

/*
 *		AsyncNameFromLock(volname, lock, filename, dest, maxlen)
 *
 *		This is identical to the MyNameFromLock() function except that
 *		it gets the background SnoopDos process to do the path expansion
 *		instead of doinng it from within the caller's process. This is
 *		necessary if we need to expand paths and we are not sure if the
 *		caller's process mesage port is free.
 *
 *		Volname is the volume on which the lock resides. If the lock itself
 *		is NULL, then the root of the volume will be assumed and this
 *		string will be copied into the buffer as the volume name.
 *
 *		WARNING: This function must not be called from within a DOS
 *				 device handler due to potential deadlock errors!
 */
char *AsyncNameFromLock(char *volname, BPTR lock, char *filename,
						char *buf, int maxlen)
{
	NameFromLockMsg lmsg;

	if (lock == NULL) {
		/*
		 *		Do a quick scan on the filename itself to see
		 *		if it contains a colon prefixed by some text;
		 *		if it does, then we already have a full path.
		 *		If it's just a colon, prefix it with the
		 *		volume name. If it has no colon, prefix it
		 *		with the volume name and a colon.
		 */
		char *p;

		strcpy(buf, volname);
		if (filename) {
			if (*filename == ':') {
				strcat(buf, filename);
			} else {
				for (p = filename; *p && *p != ':'; p++)
					;
				if (*p)
					strcpy(buf, filename);
				else
					mysprintf(buf, "%s:%s", volname, filename);
			}
		}
		return (buf);
	}
	lmsg.type		= PATHEXPAND_MSG;
	lmsg.lock		= lock;
	lmsg.filename	= filename;
	lmsg.buf		= buf;
	lmsg.maxlen		= maxlen;
	lmsg.sigmask	= SIGF_SINGLE;
	lmsg.task		= SysBase->ThisTask;
	lmsg.msg.mn_Node.ln_Name = NULL;

	SetSignal(0, SIGF_SINGLE);		/* Ensure signal is clear first		*/
	PutMsg(&BackgroundPort, &lmsg);	/* Send request to background task	*/
	Wait(SIGF_SINGLE);				/* Wait for acknowledgement			*/
	return (lmsg.newbuf);
}

#if STACK_CHECK
/*
 *		GetFreeStack()
 *
 *		Returns the amount of free space available on the calling task's
 *		stack (thanks to Ralph Babel for this).
 */
ULONG GetFreeStack(void)
{
	Process *pr = (Process *)SysBase->ThisTask;
	char *upper;
	char *lower;
	ULONG total;
	ULONG avail;

	if (pr->pr_Task.tc_Node.ln_Type == NT_PROCESS && pr->pr_CLI != NULL) {
		upper = (char *)pr->pr_ReturnAddr + sizeof(ULONG);
		total = *(ULONG *)pr->pr_ReturnAddr;
		lower = upper - total;
	} else {
		upper = (char *)pr->pr_Task.tc_SPUpper;
		lower = (char *)pr->pr_Task.tc_SPLower;
		total = upper - lower;
	}
	avail = (char *)getreg(REG_A7) - lower;
	return (avail);
}
#endif

/*
 *		CreateEvent(calladdr, seqnum, action, filename,
 *					options, expandname [, lock] )
 *
 *		Allocates a new event for the current task and initialises
 *		almost all the fields in it accordingly.
 *
 *		seqnum is initialised to the sequence number of the new event. This
 *		is used to allow later detection of events which have scrolled off
 *		the top of the buffer.
 *
 *		filename and options are text strings, and actionid is a message ID.
 *		The storage for these will be allocated in the event buffer.
 *
 *		If expandname is EXPAND_NAME, then 'filename' is assumed to represent
 *		a real disk filename, and it will be expanded to a full path if that
 *		option is set. If expandname is NO_EXPAND, then the name is passed
 *		unchanged.
 *
 *		If expandname is neither EXPAND_NAME or NO_EXPAND, then it is
 *		interpreted as a volume name, and one additional parameter
 *		following it will be expected -- this additional parameter will
 *		be a lock on that volume. The filename will then be expanded
 *		to a full pathname on that volume. If the lock is null, then it
 *		is assumed to represent the root of the volume. The filename
 *		expansion is done by the background process, making it safe to
 *		call from within the PutMsg() patch which monitors raw packets.
 *		
 *		If you pass in a NULL value for any of the three pointers, it will
 *		be made to point to a blank string.
 *
 *		If for some reason the event could not be created, returns NULL,
 *		else returns a pointer to the initialised event.
 *
 *		Possible reasons for failure include:
 *
 *			- Calling task is main SnoopDos task (!)
 *			- Calling task is not included in the match pattern
 *			- Calling task was called by a ROM function
 *			- Disk error occurred expanding filename
 *			- Out of memory allocating new event
 */
struct Event *CreateEvent(ULONG calladdr, LONG *seqnum, ULONG actionid,
						  char *filename, char *options, int expandname, ...)
{
	Task *thistask = SysBase->ThisTask;
	struct CommandLineInterface *cli;
	Event *ev;
	char *procname;
	char *strptr;
	char *action;
	char namebuf[MAX_SHORT_LEN+1];
	char pathbuf[MAX_STR_LEN+1];
	int plen = 0;
	int flen = 0;
	int olen = 0;
	int alen = 0;
	int slen = 0;
	int clinum;

	/*
	 *		We ignore all calls from the main SnoopDOS process and
	 *		background process, and also any nested calls made while
	 *		we have the semaphore locked (which might otherwise lead
	 *		to nasty trashing of the list!)
	 *
	 *		Also, any calls from input.device are ignored since these
	 *		typically call us with layers locked, and the slightest
	 *		delay could be fatal.
	 */
	if (thistask == SnoopTask || thistask == (Task *)BackgroundProc
							  || thistask == BufSem.ss_Owner
							  || thistask == RamLibTask
							  || thistask == InputTask)
		return (NULL);

	/*
	 *		We also ignore any calls made from ROM addresses (if this
	 *		option is enabled), since this cuts down the amount of
	 *		superfluos output considerably.
	 *
	 *		We specifically DO allow calls from within ramlib, since
	 *		it's very easy to disable ramlib directly if need be (by
	 *		putting ~ramlib in the match name) and ramlib does
	 *		many useful operations that are convenient to monitor.
	 */
	if (thistask != RealRamLibTask && !MonROMCalls &&
							  calladdr >= RomStart && calladdr <= RomEnd)
		return (NULL);

	/*
	 *		Work out the correct name for our task. This will either be
	 *		the task name, the process name, or the current CLI command
	 *		(if the process is a CLI, _and_ is currently running a command.)
	 *
	 *		In addition, for CLIs, we set clinum to the CLI number. For
	 *		tasks and non-CLI processes, clinum becomes zero.
	 */
	procname = thistask->tc_Node.ln_Name;
	plen	 = strlen(procname);
	cli		 = BTOC(((Process *)thistask)->pr_CLI);
	clinum   = 0;

	if (thistask->tc_Node.ln_Type == NT_PROCESS && cli) {
		/*
		 *		If we have a CLI command, we have to convert the name
		 *		from a BSTR into a C string
		 */
		clinum = ((Process *)thistask)->pr_TaskNum;
		if (cli->cli_Module) {
			UBYTE *cliname = BTOC(cli->cli_CommandName);
			plen = *cliname;

			if (plen) {
				if (plen > MAX_SHORT_LEN)
					plen = MAX_SHORT_LEN;
				memcpy(namebuf, cliname+1, plen);
				namebuf[plen] = 0;
			} else {
				strcpy(namebuf, "<Unknown>");
				plen = strlen(namebuf);
			}
			procname = namebuf;
		}
	}

#if 0
	if (stricmp(procname, "ramlib") == 0) {
		KPrintF("Ramlib: Stacksize is %ld\n", GetFreeStack());
	}
#endif

	if (!CheckPattern(procname, plen))		/* Perform pattern check */
		return (FALSE);

	/*
	 *		Now deal with our three strings
	 */
	if (ShowPaths && filename != NULL) {
		if (expandname == EXPAND_NAME) {
			/*
			 *		Expand filename to full path
			 */
			filename = MyNameFromLock(((Process *)thistask)->pr_CurrentDir,
									  filename, pathbuf, MAX_STR_LEN);
		} else if (expandname != NO_EXPAND) {
			/*
			 *		Expand filename to full path using background process
			 *		and the lock specified in expandname.
			 */
			BPTR lock = *(ULONG *)(&expandname+1);

			filename = AsyncNameFromLock((char *)expandname, lock, filename, 
									     pathbuf, MAX_STR_LEN);
		}
	}
	plen++;
	if (ShowCLINum && clinum)
		plen += 8;						/* Leave room for CLI display */

	action = MSG(actionid);
	alen   = strlen(action) + 1;

	if (filename)	flen = strlen(filename)	+ 1;
	if (options)	olen = strlen(options)	+ 1;

	if (SegTrackerActive)
		slen = MAX_SEGTRACKER_LEN;

	/*
	 *		If the calling task has locked the layers of the SnoopDos
	 *		screen, then we ignore all calls by that task. This prevents
	 *		us deadlocking when we wait for the semaphore (while meanwhile,
	 *		the SnoopDos mainline code could own the semaphore, and be
	 *		waiting for the layers to be unlocked by our caller so it can
	 *		render some output).
	 *
	 *		We Forbid() to make sure the window doesn't get closed from
	 *		under our feet while we're checking it. We have to try and
	 *		allocate the event while still Forbid'd since otherwise, there
	 *		is a small window where the main window could open, lock the
	 *		layers, and lock the semaphore, in between our check. It's
	 *		unlikely, but not _that_ unlikely (especially since the main
	 *		window always does an immediate redraw when it opens)
	 */		
	Forbid();
	if (MainWindow &&
			(MainWindow->RPort->Layer->Lock.ss_Owner   == thistask ||
			 MainWindow->WScreen->LayerInfo.Lock.ss_Owner == thistask)) {
		Permit();
		return (NULL);
	}
	ev = GetNewEvent(plen + alen + flen + olen + slen);
	Permit();

	if (!ev)
		return (NULL);
	
	ev->action = ev->filename = ev->options = ev->result = "";

	strptr = (char *)(ev+1);

	if (ShowCLINum && clinum)
		mysprintf(strptr, "[%ld] %s", clinum, procname);
	else
		strcpy(strptr, procname);
	ev->procname  = strptr;
	strptr       += plen;

//	KPrintF("New event: %ld, %s, %s\n", ev->seqnum, procname, action); /* DB */
	if (alen) {
		strcpy(strptr, action);
		ev->action   = strptr;
		strptr	  	+= alen;
	}
	if (flen) {
		strcpy(strptr, filename);
		ev->filename  = strptr;
		strptr   	 += flen;
	}
	if (olen) {
		strcpy(strptr, options);
		ev->options   = strptr;
		strptr       += olen;
	}
	if (slen) {
		ev->segname	  = strptr;
		strptr       += slen;
	} else {
		ev->segname   = NULL;	/* Say no segtracker storage allocated */
	}
	// DateStamp(&ev->datestamp);
	ev->calladdr	= calladdr;
	ev->processid	= (ULONG)thistask;
	// ev->processid	= GetFreeStack();

	if (seqnum)
		*seqnum = ev->seqnum;
	return (ev);
}

/*
 *		CheckTaskRecursion()
 *
 *		Checks if the current task is already listed as being on the
 *		recursion list. If so, returns FALSE, indicating that the
 *		caller should immediately pass control back to the original
 *		function and not try and do anything else.
 *
 *		Otherwise, records the task's address in a recursion list
 *		and returns a handle. This handle should be passed back to
 *		EndTaskRecursion() when the function is complete, which will
 *		cause it to be removed from the list.
 *
 *		OpenLibrary() needs to surround its call to CreateEvent() with
 *		CheckTaskRecursion()/EndTaskRecursion. Also, GetMsg()/PutMsg() need 
 *		this to check if any of the DOS packets it monitors have been
 *		generated by AmigaDOS functions we monitor.
 */
ULONG CheckTaskRecursion(void)
{
	Task *taskid = SysBase->ThisTask;
	ULONG taskhandle;
	int i;

	for (i = 1; i < NUM_CACHED_TASKS; i++)
		if (CachedTask[i] == taskid)
			return (0);
	
	ObtainSemaphore(&TaskCacheSem);
	taskhandle = TaskCacheIndex++;
	if (TaskCacheIndex >= NUM_CACHED_TASKS)
		TaskCacheIndex = 1;
	CachedTask[taskhandle] = taskid;
	ReleaseSemaphore(&TaskCacheSem);

	return (taskhandle);
}

/*
 *		EndTaskRecursion(taskhandle)
 *
 *		Called to remove a task from the recursion list.
 *		See CheckTaskRecursion() above.
 */
void EndTaskRecursion(ULONG taskhandle)
{
	CachedTask[taskhandle] = 0;
}

#if 0
/*
 *		TestPatch()
 *
 *		Patches a single function to try it out
 */
void TestPatch(void)
{
	extern List			EventList;			/* List of events		*/
	static EventFormat evformat[50];
	static char outstr[500];
	char *formatstr = "%d %t %c %n %s %h %a %40f %o %r";
	int formatlen;

	OnlyShowFails    = 0;
	SegTrackerActive = 1;
	formatlen = ParseFormatString(formatstr, evformat, 50);

	if (!InitPatches()) {
		printf("Patch initialisation failed!\n");
		return;
	}

	PatchList[GID_OPENFILE].enabled = 1;
	UpdatePatches();
	printf("Patch now enabled!\n\n");

	FormatEvent(evformat, NULL, outstr, 0, formatlen-1);
	printf("%s\n", outstr);
	printf("%s\n", UnderlineTitles(evformat, outstr, '-'));

	for (;;) {
		ULONG mask;

		mask = Wait(SIGBREAKF_CTRL_C | NewEventMask);
		if (mask & SIGBREAKF_CTRL_C)
			break;

		if (mask & NewEventMask) {
			Event *ev;

			SetSignal(0, NewEventMask);	/* Clear signal for next time */
			FORLIST(&EventList, ev) {
				int stat = ev->status;

				if (stat == ES_UPDATING || stat == ES_READY) {
					FormatEvent(evformat, ev, outstr, 0, formatlen-1);
					printf("%s\n", outstr);
					if (stat == ES_READY)
						ev->status = ES_ACCEPTED;
				}
			}
		}
	}
	PatchList[GID_OPENFILE].enabled = 0;
	UpdatePatches();
	printf("Patch disabled\n");
	CleanupPatches();
}
#endif

/*
 *		HandlePaused(event, seqnum)
 *
 *		Should be called when pausing is enabled -- it sets the
 *		event Result code to "...." to indicate the event is about
 *		to be executed, then waits for the pausing to be turned off.
 *		If you pass in NULL as the event code, then this isn't done.
 *
 *		seqnum is the actual event number remembered by the caller,
 *		not (necessarily) the event number stored in the event. This
 *		is so that the code can check if the event has rolled off the
 *		top of the buffer or not before modifying it.
 *
 *		There are some circumstances where it is dangerous for
 *		us to pause because we are being called by a system task
 *		that is needed by the main SnoopDos program.
 *
 *		We work around this as follows. Firstly, if the caller happens
 *		to own the semaphore associated with the layer info for the
 *		window or screen containing the SnoopDos window, then we
 *		don't try and pause it since otherwise we might deadlock
 *		(the user wouldn't be able to unpause SnoopDos because that
 *		requires clicking on a button.)
 *
 *		Secondly, whenever SnoopDos itself does something that might
 *		stop it processing the main messages (e.g. show a requester,
 *		open a file, check for ASL, etc.) then pausing is temporarily
 *		turned off since we have no way of knowing whether a third
 *		party patch might be spinning off a background task to do it
 *		and the background task might try and wait on this. Bummer, eh?
 */
void HandlePaused(Event *ev, LONG seqnum)
{
	if (Paused) {
		/*
		 *		Need to forbid when checking layers since otherwise the
		 *		main window might close while we're reading its pointers.
		 */
		int gotlock = 0;
		char *oldresmsg;

		Forbid();
		if (MainWindow) {
			struct Layer *layer;
			struct Layer_Info *li;
			Task *thistask = SysBase->ThisTask;

			layer = MainWindow->RPort->Layer;
			li    = &MainWindow->WScreen->LayerInfo;

			gotlock = (li->Lock.ss_Owner    == thistask) ||
					  (layer->Lock.ss_Owner == thistask);
		}
		Permit();
		if (gotlock)
			return;

		/*
		 *		Okay, safe to proceed with pausing. We simply set the
		 *		result message to indicate we're paused, signal
		 *		the main task, wait for the pausing to finish, restore
		 *		the result message, and return.
		 */
		if (ev) {
			ObtainSemaphore(&BufSem);
			if (seqnum >= RealFirstSeq) {
				oldresmsg  = ev->result;
				ev->result = MSG(MSG_RES_PAUSE);
			}
			ReleaseSemaphore(&BufSem);
		}
		Signal(SnoopTask, NewEventMask);	/* Make sure main task updates */
		ObtainSemaphore(&PauseSem);
		ReleaseSemaphore(&PauseSem);
		if (ev) {
			ObtainSemaphore(&BufSem);
			if (seqnum >= RealFirstSeq)
				ev->result = oldresmsg;
			ReleaseSemaphore(&BufSem);
		}
	}
}

#define CheckForPause(ev,seqnum)	if (Paused)	{ HandlePaused(ev, seqnum); }

/*****************************************************************************
 *
 *		Now here are all the patches for the 25 or so functions that we
 *		patch into. Most of the patches follow a similar template, and
 *		share similar lower-level functions, but are different enough to
 *		prevent us from using the same patch for several functions.
 *
 *		We always signal both before and after a particular call, so that
 *		in the event of a call causing a crash, it will still show up in
 *		the SnoopDos window.
 *
 *		The OnlyShowFails flag is used to say whether we want to monitor
 *		all calls to a function, or only those which return a failure code.
 *		If the latter, we need to call the function first before deciding
 *		whether or not to create an event to record it -- in this case, the
 *		result code remains cached for the remainder of the function. The
 *		rest of the time, we create the event and signal the main task,
 *		then call the function to get the result, and finally update the
 *		event with the result and signal the main task again.
 *
 *		Each patch that calls a function and then updates the buffer on its
 *		return must ensure that the buffer entry is has a pointer to is still
 *		valid before it updates it. It does this by remembering the sequence
 *		number of the buffer entry, and then checking that the sequence
 *		number of the first buffer entry is still <= that (i.e. the entry
 *		is still somewhere in the buffer). This is vital to ensure that
 *		innocent buffer memory isn't trashed by old events.
 *
 *****************************************************************************/

/*
 *		New_FindPort(name)
 *
 *		Searches the system port list looking for a port name
 */
ULONG ASM New_FindPort(reg_a1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_FindPort origfunc = (FP_FindPort)PatchList[GID_FINDPORT].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_FINDPORT,
					 name, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_FindResident(name)
 *
 *		Searches the system resident list looking for a resident module
 */
ULONG ASM New_FindResident(reg_a1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_FindResident origfunc = (FP_FindResident)
								PatchList[GID_FINDRESIDENT].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	LONG  seqnum;

	if (SysBase->ThisTask == RealRamLibTask)
		JumpOrigFunc(0);

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_FINDRESIDENT,
					 name, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_FindSemaphore(name)
 *
 *		Searches the system semaphore list looking for the named semaphore
 */
ULONG ASM New_FindSemaphore(reg_a1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_FindSemaphore origfunc = (FP_FindSemaphore)
							 	 PatchList[GID_FINDSEMAPHORE].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_FINDSEM,
					 name, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}
	
/*
 *		New_FindTask(name)
 *
 *		Searches the system task list looking for the named task.
 *		We ignore calls to FindTask(0) since this is just
 *		looking for a pointer to the current task.
 */
ULONG ASM New_FindTask(reg_a1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_FindTask origfunc = (FP_FindTask)PatchList[GID_FINDTASK].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	LONG  seqnum;

	if (name == NULL)
		return (origfunc(name, libbase));

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_FINDTASK,
					 name, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_LockPubScreen(name)
 *
 *		Obtains a lock on the named public screen. If the name is NULL,
 *		then the caller is looking for a Lock() on the default screen,
 *		and we ignore it (otherwise we'd get loads of output).
 */
ULONG ASM New_LockPubScreen(reg_a0 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_LockPubScreen origfunc = (FP_LockPubScreen)
								PatchList[GID_LOCKSCREEN].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	LONG  seqnum;

	if (!name)
		JumpOrigFunc(0);

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_LOCKSCREEN,
					 name, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		Signal(SnoopTask, NewEventMask);
		CheckForPause(ev, seqnum);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_OpenDevice(name, unit, ioreq, flags)
 *
 *		Opens a new device. We need to be careful with the error return
 *		for this function, since success is indicated by a return of 0!
 *
 *		N.b. Kickstart 3.1 has a space-saving hack which allows a NULL
 *		device name to be interpreted as a magic cookie indicating a
 *		particular ROM devices. We ignore such calls (especially from CON,
 *		which does it a lot!) but flag other occurrances of NULL device
 *		names as an error.
 */
ULONG ASM New_OpenDevice(reg_a0 char *name, reg_d0 long unit,
					     reg_a1 struct IORequest *ioreq,
						 reg_d1 long flags, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_OpenDevice origfunc = (FP_OpenDevice)PatchList[GID_OPENDEVICE].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	char unitstr[20];
	char *devname = name;
	LONG  seqnum;

/*
 *		Release Semaphore replacement code for debugging patch
 */
#if MONITOR_SEMAPHORE
	Semaphore *sem = (Semaphore *)name;

	if (LoadTask == SysBase->ThisTask)
		KPrintF("ReleaseSemaphore in LoadSeg: retaddr = %08lx\n", CallAddr);
	return origfunc(name, unit, ioreq, flags, libbase);
#endif

	if (onlyfails) {
		result = origfunc(name, unit, ioreq, flags, libbase);
		if (!result)
			return (result);
	}
	/*
	 *		Now a workaround for a bug in CON that makes it call
	 *		OpenDevice("timer.device" | NULL) very frequently.
	 *		(The NULL is a space-saving shorthand which the 3.1 Kickstart
	 *		interprets as a magic cookie for "timer.device" to save some
	 *		ROM space).
	 */
	if ((CallAddr >= RomStart && CallAddr <= RomEnd) ||
					strcmp(SysBase->ThisTask->tc_Node.ln_Name, "CON") == 0) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(unit);
	}
	if (!devname)
		devname = MSG(MSG_NULLSTR);

	mysprintf(unitstr, MSG(MSG_OPT_DEVUNIT), unit);
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_OPENDEV,
					 devname, unitstr, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(unit);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, unit, ioreq, flags, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (!result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_OpenFont(textattr)
 *
 *		Opens a new font that's currently in memory. OpenDiskFont will
 *		call this function first before checking the disk, so patching
 *		this function catches all accesses.
 */
ULONG ASM New_OpenFont(reg_a0 struct TextAttr *textattr, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_OpenFont origfunc = (FP_OpenFont)PatchList[GID_OPENFONT].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	char *name;
	char sizestr[20];
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(textattr, libbase);
		if (result)
			return (result);
	}
	if (textattr) {
		mysprintf(sizestr, MSG(MSG_OPT_FONTSIZE), textattr->ta_YSize);
		name = textattr->ta_Name;
	} else {
		*sizestr = '\0';
		name = MSG(MSG_NULLSTR);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_OPENFONT,
					 name, sizestr, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(textattr, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_OpenLibrary(name, version)
 *
 *		Opens the named library with the specified version number.
 *
 *		We have a nasty potential for deadlock here -- CreateEvent()
 *		which we call, in turns calls DateStamp(), and DateStamp()
 *		itself calls OpenLibrary(....). So, we need to protect
 *		ourselves against a recursive call.
 *
 *		We do this by ignoring any call to open dos.library made
 *		by a call originating in ROM.
 */
ULONG ASM New_OpenLibrary(reg_a1 char *name, reg_d0 long version,
						  reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_OpenLibrary origfunc = (FP_OpenLibrary)
							   PatchList[GID_OPENLIBRARY].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	char verstr[20];
	ULONG taskhandle;
	LONG  seqnum;

	/*
	 *		Check for re-entrant calling (usually caused by the
	 *		DateStamp call in the GetNewEvent() code).
	 *
	 *		In theory, we should only need to check if the semaphore
	 *		is owned by the current task. In practise, we need
	 *		the additional checks to be really sure (otherwise
	 *		we seem to get unexplained crashes very frequently --
	 *		very mysterious and worrying).
	 *
	 *		We also ignore calls to open dos.library -- this is partly
	 *		because it gets called by DateStamp() inside dos.library
	 *		itself (so things that call DateStamp once a second, like
	 *		Enforcer(), will generate loads of calls to it) and partly
	 *		to avoid problems with our own CreateEvent() code calling it.
	 */
	if (BufSem.ss_Owner == SysBase->ThisTask ||
		strcmp(name, "dos.library") == 0)
	{
		JumpOrigFunc(version);
	}

	if (onlyfails) {
		result = origfunc(name, version, libbase);
		if (result)
			return (result);
	}
	taskhandle = CheckTaskRecursion();
	if (!taskhandle) {
		if (!onlyfails)
			result = origfunc(name, version, libbase);
		return (result);
	}
	mysprintf(verstr, MSG(MSG_OPT_LIBVER), version);
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_OPENLIB,
					 name, verstr, NO_EXPAND);
	EndTaskRecursion(taskhandle);

	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(version);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, version, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_OpenResource(name)
 *
 *		Opens the named resource
 */
ULONG ASM New_OpenResource(reg_a1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_OpenResource origfunc = (FP_OpenResource)
							    PatchList[GID_OPENRESOURCE].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_OPENRES,
					 name, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_FindToolType(array, tooltype)
 *
 *		Searches the tooltype array for a particular tooltype
 */
ULONG ASM New_FindToolType(reg_a0 char **array, reg_a1 char *tooltype,
						   reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_FindToolType origfunc = (FP_FindToolType)
							    PatchList[GID_READTOOLTYPES].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	char *toolname = tooltype;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(array, tooltype, libbase);
		if (result)
			return (result);
	}
	if (toolname == NULL)
		toolname = MSG(MSG_NULLSTR);

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_FINDTOOL,
					 toolname, NULL, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(array, tooltype, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_MatchToolValue(tooltype, value)
 *
 *		Checks if a specified tooltype contains a given value
 */
ULONG ASM New_MatchToolValue(reg_a0 char *tooltype, reg_a1 char *value,
						     reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_MatchToolValue origfunc = (FP_MatchToolValue)
							      PatchList[GID_READTOOLTYPES2].origfunc;
	int onlyfails = OnlyShowFails;
	ULONG result;
	Event *ev;
	char *toolname = tooltype;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(tooltype, value, libbase);
		if (result)
			return (result);
	}
	if (toolname == NULL)
		toolname = MSG(MSG_NULLSTR);

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_MATCHTOOL,
					 toolname, value, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(tooltype, value, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_CurrentDir()
 *
 *		Changes current directory to somewhere else
 */
ULONG ASM New_CurrentDir(reg_d1 BPTR lock, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_CurrentDir origfunc = (FP_CurrentDir)PatchList[GID_CHANGEDIR].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	char lockbuf[MAX_LOCK_LEN+1];
	char *lockpath;
	LONG  seqnum;

	if (onlyfails)
		return origfunc(lock, libbase);		/* CurrentDir never fails */

	lockpath = MyNameFromLock(lock, NULL, lockbuf, MAX_LOCK_LEN);
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_CHANGEDIR,
					 lockpath, NULL, NO_EXPAND);
	if (!ev)
		JumpOrigFunc(0);
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	ev->status = ES_UPDATING;
	CheckForPause(ev, seqnum);
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return origfunc(lock, libbase);
}

/*
 *		New_DeleteFile()
 *
 *		Deletes a file from disk
 */
ULONG ASM New_DeleteFile(reg_d1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_DeleteFile origfunc = (FP_DeleteFile)PatchList[GID_DELETE].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_DELETE,
					 name, NULL, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_Execute()
 *
 *		Executes a command from disk. Now superceded by System and RunCommand
 */
ULONG ASM New_Execute(reg_d1 char *cmdline, reg_d2 BPTR fin, reg_d3 BPTR fout,
					  reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_Execute origfunc = (FP_Execute)PatchList[GID_EXECUTE].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	char *optstr;
	LONG  seqnum;

	/*
	 *		For functions that may potentially take a long time to complete,
	 *		we check if they're being called from ROM straight away, so
	 *		that we can exit and not hang around waiting for them if they
	 *		are, even in the OnlyShowFails case.
	 */
	if (!MonROMCalls && CallAddr >= RomStart && CallAddr <= RomEnd)
		JumpOrigFunc(0);

	if (onlyfails) {
		result = origfunc(cmdline, fin, fout, libbase);
		if (result)
			return (result);
	}
	if (fin == NULL)
		optstr = MSG(MSG_OPT_EXECSINGLE);
	else
		optstr = MSG(MSG_OPT_EXECBATCH);

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_EXECUTE,
					 cmdline, optstr, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(cmdline, fin, fout, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_GetVar()
 *
 *		Inquires about the value of an environment variable
 */
ULONG ASM New_GetVar(reg_d1 char *name, reg_d2 char *buffer,
					 reg_d3 size, reg_d4 flags, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_GetVar origfunc = (FP_GetVar)PatchList[GID_GETVAR].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	char optstr[20];
	ULONG optid;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, buffer, size, flags, libbase);
		if (result != -1)
			return (result);
	}
	/*
	 *		Now determine our flags. We recognise global, local
	 *		or either types of variable. Binary variables are
	 *		flagged with a trailing asterisk.
	 */
	if		(flags & GVF_GLOBAL_ONLY)	optid = MSG_OPT_GLOBAL;
	else if ((flags & 7) == LV_ALIAS)	optid = MSG_OPT_ALIAS;
	else if (flags & GVF_LOCAL_ONLY)	optid = MSG_OPT_LOCAL;
	else								optid = MSG_OPT_ANY;
	strcpy(optstr, MSG(optid));

	if (flags & GVF_BINARY_VAR)			strcat(optstr, "*");

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_GETVAR,
					 name, optstr, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, buffer, size, flags, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result != -1)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_FindVar()
 *
 *		Inquires about the value of a local environment variable
 */
ULONG ASM New_FindVar(reg_d1 char *name, reg_d2 ULONG type,
					  reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_FindVar origfunc = (FP_FindVar)PatchList[GID_GETVAR2].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	ULONG optid;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, type, libbase);
		if (result)
			return (result);
	}

	if		((type & 7) == LV_VAR)		optid = MSG_OPT_LOCAL;
	else if ((type & 7) == LV_ALIAS)	optid = MSG_OPT_ALIAS;
	else								optid = MSG_OPT_UNKNOWN;

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_FINDVAR,
					 name, MSG(optid), NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		Signal(SnoopTask, NewEventMask);
		CheckForPause(ev, seqnum);
		result = origfunc(name, type, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_SetVar()
 *
 *		Sets a (possibly new) variable to a particular value
 */
ULONG ASM New_SetVar(reg_d1 char *name, reg_d2 char *buffer,
					 reg_d3 size, reg_d4 flags, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_SetVar origfunc = (FP_SetVar)PatchList[GID_SETVAR].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	char varstr[MAX_STR_LEN+1];
	int vlen;
	ULONG optid;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, buffer, size, flags, libbase);
		if (result)
			return (result);
	}
	/*
	 *		Now determine our flags. We recognise global, local
	 *		or alias variables.
	 */
	if		(flags & GVF_GLOBAL_ONLY)	optid = MSG_OPT_GLOBAL;
	else if ((flags & 7) == LV_VAR)		optid = MSG_OPT_LOCAL;
	else if ((flags & 7) == LV_ALIAS)	optid = MSG_OPT_ALIAS;
	else								optid = MSG_OPT_UNKNOWN;

	/*
	 *		Now create a string that looks like "Variable=Value"
	 *
	 *		We go to some pains to ensure we don't overwrite our
	 *		string length
	 */
	vlen = strlen(name);
	if (vlen > (MAX_STR_LEN-1)) {
		strncpy(varstr, name, MAX_STR_LEN);
		varstr[MAX_STR_LEN] = 0;
	} else {
		strcpy(varstr, name);
		strcat(varstr, "=");
		vlen = 98 - vlen;
		if (size != -1)
			vlen = MIN(vlen, size);

		strncat(varstr, buffer, vlen);
		varstr[MAX_STR_LEN] = 0;
	}

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_SETVAR,
					 varstr, MSG(optid), NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, buffer, size, flags, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_DeleteVar()
 *
 *		Deletes an environment variable from the environment
 */
ULONG ASM New_DeleteVar(reg_d1 char *name, reg_d2 ULONG flags,
					 	reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_DeleteVar origfunc = (FP_DeleteVar)PatchList[GID_SETVAR2].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	ULONG optid;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, flags, libbase);
		if (result)
			return (result);
	}
	/*
	 *		Now determine our flags. We recognise global, local
	 *		or alias variables.
	 */
	if		(flags & GVF_GLOBAL_ONLY)	optid = MSG_OPT_GLOBAL;
	else if ((flags & 7) == LV_VAR)		optid = MSG_OPT_LOCAL;
	else if ((flags & 7) == LV_ALIAS)	optid = MSG_OPT_ALIAS;
	else								optid = MSG_OPT_UNKNOWN;

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_KILLVAR,
					 name, MSG(optid), NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, flags, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_LoadSeg()
 *
 *		Tries to load in a module from disk
 */
ULONG ASM New_LoadSeg(reg_d1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_LoadSeg origfunc = (FP_LoadSeg)PatchList[GID_LOADSEG].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_LOADSEG,
					 name, NULL, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		
#if MONITOR_SEMAPHORE
		LoadTask = SysBase->ThisTask;
		result = origfunc(name, libbase);
		LoadTask = 0;
#else
		result = origfunc(name, libbase);
#endif
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_NewLoadSeg()
 *
 *		Tries to load in a module from disk
 */
ULONG ASM New_NewLoadSeg(reg_d1 char *name, reg_d2 TAGPTR tags,
						 reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_NewLoadSeg origfunc = (FP_NewLoadSeg)PatchList[GID_LOADSEG2].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, tags, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_NEWLOADSEG,
					 name, NULL, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, tags, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_NewLoadSeg()
 *
 *		Tries to load in a module from disk
 */
ULONG ASM New_Lock(reg_d1 char *name, reg_d2 LONG mode, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_Lock origfunc = (FP_Lock)PatchList[GID_LOCKFILE].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG optid;
	char *curname;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, mode, libbase);
		if (result)
			return (result);
	}
	if		(mode == ACCESS_READ)		optid = MSG_OPT_READ;
	else if (mode == ACCESS_WRITE)		optid = MSG_OPT_WRITE;
	else								optid = MSG_OPT_READBAD;

	curname = name;
	if (!ShowPaths && *curname == '\0')
		curname = "\"\"";

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_LOCK,
					 curname, MSG(optid), EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, mode, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_CreateDir()
 *
 *		Creates a new directory on disk
 */
ULONG ASM New_CreateDir(reg_d1 char *name, reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_CreateDir origfunc = (FP_CreateDir)PatchList[GID_MAKEDIR].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(name, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_MAKEDIR,
					 name, NULL, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_MakeLink()
 *
 *		Creates a new hard or soft link
 */
ULONG ASM New_MakeLink(reg_d1 char *name, reg_d2 LONG dest, reg_d3 LONG soft,
 					   reg_a6 void *libbase)
{
	MarkCallAddr;
	struct Process *myproc = (struct Process *)SysBase->ThisTask;
	FP_MakeLink origfunc   = (FP_MakeLink)PatchList[GID_MAKELINK].origfunc;
	int onlyfails          = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG optid;
	char namestr[MAX_STR_LEN+1];
	LONG seqnum;
	int  len;

	if (onlyfails) {
		result = origfunc(name, dest, soft, libbase);
		if (result)
			return (result);
	}
	if (soft)	optid = MSG_OPT_SOFTLINK;
	else		optid = MSG_OPT_HARDLINK;

	/*
	 *		Now build a string that looks like "name --> <dest>" to display
	 *		as our link. For soft links, we just concatenate the two
	 *		strings. For hard links, we have to generate a filename
	 *		from the lock also.
	 */
	len = strlen(name);
	if (len >= MAX_STR_LEN) {
		strncpy(namestr, name, MAX_STR_LEN);
		namestr[MAX_STR_LEN] = 0;
	} else {
		if (ShowPaths) {
			strcpy(namestr, MyNameFromLock(myproc->pr_CurrentDir,
										   name, namestr, MAX_STR_LEN-2));
			len = strlen(namestr);
		} else
			strcpy(namestr, name);

		strcat(namestr, LinkPointerString);		/* Usually ' --> ' */
		if (soft) {
			strncat(namestr, (char *)dest, MAX_STR_LEN - len - 1);
			namestr[MAX_STR_LEN] = 0;
		} else {
			strcat(namestr, MyNameFromLock(dest, NULL, namestr+len+1,
												 MAX_STR_LEN-len-1));
		}
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_MAKELINK,
					 namestr, MSG(optid), NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, dest, soft, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_Open()
 *
 *		Opens a new file on disk
 */
ULONG ASM New_Open(reg_d1 char *name, reg_d2 LONG accessMode,
				  reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_Open origfunc = (FP_Open)PatchList[GID_OPENFILE].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	char *optstr;
	LONG  seqnum;

	if		(accessMode == MODE_OLDFILE)	optstr = MSG(MSG_OPT_READ);
	else if (accessMode == MODE_NEWFILE)	optstr = MSG(MSG_OPT_WRITE);
	else if (accessMode == MODE_READWRITE)	optstr = MSG(MSG_OPT_MODIFY);
	else									optstr = MSG(MSG_OPT_UNKNOWN);

	if (onlyfails) {
		result = origfunc(name, accessMode, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_OPEN,
					 name, optstr, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(name, accessMode, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_Rename()
 *
 *		Renames a file on disk. This is a little tricky, since we have
 *		to generate two events: one containing the source name and
 *		one containing the destination name.
 */
ULONG ASM New_Rename(reg_d1 char *oldname, reg_d2 char *newname,
				     reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_Rename origfunc = (FP_Rename)PatchList[GID_RENAME].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	LONG  seqnum;

	if (onlyfails) {
		result = origfunc(oldname, newname, libbase);
		if (result)
			return (result);
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_RENAME,
					 oldname, NULL, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	ev->status = ES_READY;
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_RENAME2,
					 newname, NULL, EXPAND_NAME);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(oldname, newname, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result)
			ev->result = MSG(MSG_RES_OKAY);
		else
			ev->result = MSG(MSG_RES_FAIL);
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_RunCommand()
 *
 *		Runs a command from disk. Like Execute() only with more control.
 */
ULONG ASM New_RunCommand(reg_d1 BPTR seglist,  reg_d2 ULONG stack,
						 reg_d3 char *cmdline, reg_d4 cmdlen,
				     	 reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_RunCommand origfunc = (FP_RunCommand)PatchList[GID_RUNCOMMAND].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	char  stacksize[40];	/* Reserve additional space for return code! */
	LONG  seqnum;
	int	  stklen;
	char  *p;

	/*
	 *		For functions that may potentially take a long time to complete,
	 *		we check if they're being called from ROM straight away, so
	 *		that we can exit and not hang around waiting for them if they
	 *		are, even in the OnlyShowFails case.
	 */
	if (!MonROMCalls && CallAddr >= RomStart && CallAddr <= RomEnd)
		JumpOrigFunc(0);

	if (onlyfails) {
		result = origfunc(seglist, stack, cmdline, cmdlen, libbase);
		if (result != -1)
			return (result);
	}

	/*
	 *		This is kind of nasty but it works. We need somewhere to store
	 *		the return code string, but when we call CreateEvent(), we
	 *		don't know what it will be yet. So, we allocate additional
	 *		space at the end of our stacksize to hold this info, and
	 *		overwrite it later on.
	 */
	mysprintf(stacksize, "%ld", stack);
	stklen = strlen(stacksize);
	strcat(stacksize, "................");	/* Storage for return code */

	/*
	 *		Next, a quick hack to get rid of that nasty CR at the end
	 *		of the string (purely for visual purposes -- we put it back
	 *		afterwards, of course!)
	 */
	for (p = cmdline; *p; p++) {
		if (*p == '\n') {
			*p = ' ';
			break;
		}
	}
	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_RUNCOMMAND,
					 cmdline, stacksize, NO_EXPAND);
	if (*p)
		*p = '\n';

	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	ev->options[stklen] = 0;
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->result = "----";
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(seglist, stack, cmdline, cmdlen, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result != -1) {
			ev->result = ev->options + stklen + 1;
			mysprintf(ev->result, "%ld", result);
		} else {
			ev->result = MSG(MSG_RES_FAIL);
		}
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*
 *		New_SystemTagList()
 *
 *		Executes a command line. Like Execute() only more powerful.
 */
ULONG ASM New_SystemTagList(reg_d1 char *cmdline, reg_d2 TAGPTR tags,
					     	reg_a6 void *libbase)
{
	MarkCallAddr;
	FP_SystemTagList origfunc = (FP_SystemTagList)
								 PatchList[GID_SYSTEM].origfunc;
	int onlyfails = OnlyShowFails;
	Event *ev;
	ULONG result;
	char  optstr[20];	/* Reserve additional space for return code! */
	LONG  seqnum;

	/*
	 *		For functions that may potentially take a long time to complete,
	 *		we check if they're being called from ROM straight away, so
	 *		that we can exit and not hang around waiting for them if they
	 *		are, even in the OnlyShowFails case.
	 */
	if (!MonROMCalls && CallAddr >= RomStart && CallAddr <= RomEnd)
		JumpOrigFunc(0);

	if (onlyfails) {
		result = origfunc(cmdline, tags, libbase);
		if (result != -1)
			return (result);
	}
	/*
	 *		This is kind of nasty but it works. We need somewhere to store
	 *		the return code string, but when we call CreateEvent(), we
	 *		don't know what it will be yet. So, we allocate space for our
	 *		option string instead and then replace it with our result
	 *		string later on.
	 */
	strcpy(optstr, "............");	/* Storage for result string */

	ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_SYSTEM, cmdline,
					 optstr, NO_EXPAND);
	if (!ev) {
		if (onlyfails)
			return (result);
		JumpOrigFunc(0);
	}
	*ev->options = '\0';
	
	/*
	 *		Allocated event safely, now tell SnoopDos task to wake up
	 */
	if (onlyfails) {
		CheckForPause(NULL, 0);
	} else {
		ev->result = "----";
		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
		result = origfunc(cmdline, tags, libbase);
	}
	ObtainSemaphore(&BufSem);
	if (seqnum >= RealFirstSeq) {
		if (result != -1) {
			ev->result  = ev->options;
			ev->options = "";
			mysprintf(ev->result, "%ld", result);
		} else {
			ev->result = MSG(MSG_RES_FAIL);
		}
		ev->status = ES_READY;
		Signal(SnoopTask, NewEventMask);
	}
	ReleaseSemaphore(&BufSem);
	return (result);
}

/*****************************************************************************
 *
 *	  Now the Mother of all patches -- the PutMsg() packet monitor/Rexx patch
 *
 *	  (There are quite a few sub-functions associated with this.)
 *
 *****************************************************************************/

/*
 *		New_AddDosEntry(dlist)
 *
 *		This is a very simple patch which is only enabled when we are
 *		monitoring DOS packets. It simply signals the main task to update
 *		the device list whenever a new device is added to the DOS device
 *		list.
 */
ULONG ASM New_AddDosEntry(reg_d1 struct DosList *dlist, reg_a6 void *libbase)
{
	FP_AddDosEntry origfunc = (FP_AddDosEntry)
							   PatchList[GID_ADDDOSENTRY].origfunc;
	ULONG result;

	/*
	 *		Note that we better remember to actually add the new device
	 *		before telling SnoopDos to update its list, otherwise it
	 *		might miss it if it's too quick (e.g. priority > 0).
	 *
	 *		New: Even though we DO add it before signalling SnoopDos, the
	 *		device itself won't be fully initialised for a little bit longer.
	 *		Therefore, the main SnoopDos code 
	 */
	result = origfunc(dlist, libbase);

	if (dlist && dlist->dol_Type == DLT_DEVICE)
		Signal(SnoopTask, ScanDosListMask);
	
	return (result);
}

/*
 *		AddWaitingPacket(ev, seqnum, failmsg, dp, port, pt)
 *
 *		Adds a new entry to the list of waiting packets containing enough
 *		information to allow us to identify the reply to the packet when
 *		it is processed later on (in the main PutMsg() patch).
 *
 *		If there isn't a spare waiting packet, we will steal one and mark
 *		the event it represented as "Miss" to indicate the return code
 *		was missed.
 */
void AddWaitingPacket(Event *ev, LONG seqnum, char *failmsg,
					  struct DosPacket *dp, struct MsgPort *port,
					  struct PacketRef *pt)
{
	WaitPacket *wp;
	Event *oldev;
	ULONG oldseq;

	/*
	 *		Add details about this packet to our list of waiting
	 *		packets, so that when we spot the packet being returned
	 *		by PutMsg() later on, we can fill in the result code.
	 *
	 *		Note that we must not obtain both the buffer and packet
	 *		semaphores simultaneously, or a deadlock could occur.
	 */
	ObtainSemaphore(&PacketSem);
	if (IsListEmpty(&PacketFreeList)) {
		/*
		 *		Removing an existing node which is already in use. We need
		 *		to signal our main task to tell it not to continue waiting
		 *		for this event to complete. We have to wait until we unlock
		 *		the packetsem so we just note the details for now.
		 */
		wp     = (WaitPacket *)RemTail(&PacketWaitList);
		oldseq = wp->eventnum;
		oldev  = wp->event;
		//	if (!wp)
		//		KPrintF("Warning!! No packet available on WaitList!\n");
	} else {
		wp     = (WaitPacket *)RemHead(&PacketFreeList);
		oldseq = 0;
	}
	wp->dp   	 = dp;
	wp->sendtask = SysBase->ThisTask;
	wp->destport = port;
	wp->event    = ev;
	wp->eventnum = seqnum;
	wp->arg1 	 = dp->dp_Arg1;
	wp->arg2 	 = dp->dp_Arg2;
	wp->arg3 	 = dp->dp_Arg3;
	wp->resmsg	 = failmsg;
	wp->flags    = pt->flags;
	AddHead(&PacketWaitList, (Node *)wp);
	ReleaseSemaphore(&PacketSem);

	/*
	 *		Finally, check if we had to flush out an old packet from
	 *		our list of waiting packets when we allocated the new
	 *		packet. If so, mark the packet as missed (if it hasn't
	 *		already scrolled off the top of the buffer)
	 */
	if (oldseq) {
		ObtainSemaphore(&BufSem);
		if (oldseq >= RealFirstSeq) {
			oldev->result = MSG(MSG_RES_MISSED);
			oldev->status = ES_READY;
			Signal(SnoopTask, NewEventMask);
		}
		ReleaseSemaphore(&BufSem);
	}
}

/*
 *		HandleSimplePacket(calladdr, packet, port, packetref)
 *
 *		Handles the given packet by creating an event that matches the
 *		packet type (if we support it) and creating a new entry on the
 *		waiting packet list so we can match it up later.
 *
 *		This function handles only simple packets (i.e. those with the
 *		PK_COMMON flag set in the packet table). If the corresponding
 *		AmigaDOS option (Open, Lock, MakeDir etc.) is not currently
 *		enabled, then no entry is made for this packet.
 */
void HandleSimplePacket(ULONG calladdr, struct DosPacket *dp,
				     	struct MsgPort *port, struct PacketRef *pt)
{
	/*
	 *		Now create our new simple event to represent the packet.
	 *		The contents of this will vary depending on the packet
	 *		itself, but in general, is an exact match with the format
	 *		of the AmigaDOS function associated with the packet.
	 *
	 *		(If that function is not being monitored, then we do nothing.)
	 */
	Event *ev;
	LONG  seqnum;
	ULONG gadid;
	ULONG actid = 0;
	char  *volname = ((Task *)(port->mp_SigTask))->tc_Node.ln_Name;
	BPTR  lock = NULL;
	BSTR  name;
	char  *optstr;
	char  namebuf[MAX_STR_LEN+1];
	char  optbuf[20];

	namebuf[0] = '\0';

	/*
	 *		First, determine the format to use, based on the packet type
	 */
	switch (dp->dp_Type) {
		case ACTION_FINDINPUT:
			gadid	= GID_OPENFILE;
			actid	= MSG_ACT_POPEN;
			lock	= dp->dp_Arg2;
			name	= dp->dp_Arg3;
			optstr	= MSG(MSG_OPT_READ);
			break;

		case ACTION_FINDOUTPUT:
			gadid	= GID_OPENFILE;
			actid	= MSG_ACT_POPEN;
			lock	= dp->dp_Arg2;
			name	= dp->dp_Arg3;
			optstr	= MSG(MSG_OPT_WRITE);
			break;

		case ACTION_FINDUPDATE:
			gadid	= GID_OPENFILE;
			actid	= MSG_ACT_POPEN;
			lock	= dp->dp_Arg2;
			name	= dp->dp_Arg3;
			optstr	= MSG(MSG_OPT_MODIFY);
			break;

		case ACTION_DELETE_OBJECT:
			gadid	= GID_DELETE;
			actid	= MSG_ACT_PDELETE;
			lock    = dp->dp_Arg1;
			name    = dp->dp_Arg2;
			optstr  = NULL;
			break;

		case ACTION_CREATE_DIR:
			gadid	= GID_MAKEDIR;
			actid	= MSG_ACT_PMAKEDIR;
			lock	= dp->dp_Arg1;
			name	= dp->dp_Arg2;
			optstr  = NULL;
			break;

		case ACTION_LOCATE_OBJECT:
			gadid	= GID_LOCKFILE;
			actid	= MSG_ACT_PLOCK;
			lock	= dp->dp_Arg1;
			name	= dp->dp_Arg2;
			switch (dp->dp_Arg3) {
				case ACCESS_READ:	optstr = MSG(MSG_OPT_READ);		break;
				case ACCESS_WRITE:	optstr = MSG(MSG_OPT_WRITE);	break;
				default:			optstr = MSG(MSG_OPT_READBAD);	break;
			}
			break;

		case ACTION_MAKE_LINK:
		{
			int len;
			char *cname;

			gadid	= GID_MAKELINK;
			actid	= MSG_ACT_PMAKELINK;
			lock	= dp->dp_Arg1;
			cname	= BTOC(dp->dp_Arg2);

			/*
			 *		Now build a string that looks like "name --> <dest>" to
			 *		display as our link. For soft links, we just concatenate
			 *		the two strings. For hard links, we have to generate a
			 *		filename from the lock also.
			 */
			len = *cname;
			if (len >= MAX_STR_LEN) {
				strncpy(namebuf, cname+1, MAX_STR_LEN);
				namebuf[MAX_STR_LEN] = 0;
			} else {
				if (ShowPaths) {
					char *tempbuf = namebuf + MAX_STR_LEN-9 - len;

					memcpy(tempbuf, cname+1, len);
					tempbuf[len] = '\0';
					strcpy(namebuf, AsyncNameFromLock(volname, lock, tempbuf,
											          namebuf, MAX_STR_LEN-8));
					len = strlen(namebuf);
				} else {
					memcpy(namebuf, cname+1, len);
					namebuf[len] = '\0';
				}
				strcat(namebuf, LinkPointerString);		/* Usually ' --> ' */
				len += strlen(LinkPointerString);

				if (dp->dp_Arg4 == LINK_HARD) {
					/*
					 *		Hard link: interpret dp->dp_Arg3 as the lock
					 *		being linked to
					 */
					strcat(namebuf, AsyncNameFromLock(volname, dp->dp_Arg3,
													  NULL, namebuf+len+1,
													  MAX_STR_LEN-len-1));
					optstr = MSG(MSG_OPT_HARDLINK);
				} else {
					/*
					 *		Soft link: interpret dp->dp_Arg3 as the name of
					 *		the path to the link
					 */
					strncat(namebuf, (char *)dp->dp_Arg3, MAX_STR_LEN-len-1);
					namebuf[MAX_STR_LEN] = 0;
					optstr = MSG(MSG_OPT_SOFTLINK);
				}
			}
			volname = (char *)NO_EXPAND; /* Don't try and expand filename */
			name    = NULL;
			break;
		}

		case ACTION_RENAME_OBJECT:
			lock	= dp->dp_Arg1;
			name	= dp->dp_Arg2;
			optstr	= NULL;

			/*
			 *		This is a bit cheeky. The Rename action comes in
			 *		two parts, the first line with the original name and
			 *		the second part with the new name. We create the
			 *		first part here, and then fall through to let the
			 *		rest of the code handle the second part.
			 */
			if (CurSettings.Func.Opts[GID_RENAME]) {
				char *cname = BTOC(name);

				lock	  	= dp->dp_Arg3;
				name	  	= dp->dp_Arg4;
				if (*cname) {
					memcpy(namebuf, cname+1, *cname);
					namebuf[*cname] = '\0';
				} else {
					/*
					 *		If we have an empty string, we replace it with ""
					 *		since we may be renaming the current directory (?)
					 */
					strcpy(namebuf, "\"\"");
				}
				ev = CreateEvent(calladdr, &seqnum, MSG_ACT_PRENAME,
								 namebuf, NULL, (int)volname, lock);
				if (!ev)
					return;

				ev->status	= ES_READY;
				gadid		= GID_RENAME;
				actid	 	= MSG_ACT_PRENAME2;
			}
			break;
	}

	/*
	 *		Now, if we recognised the packet type, create a new event
	 *		with the info stored accordingly. We ignore any packets
	 *		for which monitoring is disabled.
	 */
	if (actid && CurSettings.Func.Opts[gadid]) {
		/*
		 *		We reserve 8 bytes at the start of the options string to
		 *		hold the result message (Ok or Fail) that is filled in
		 *		by the PutMsg() code when the packet is returned.
		 */
#define RES_LEN		8

		strcpy(optbuf, "........");
		if (optstr)
			strcat(optbuf, optstr);

		if (name) {
			char *cname = BTOC(name);

			namebuf[0] = '\0';
			if (*cname) {
				memcpy(namebuf, cname+1, *cname);
				namebuf[*cname] = '\0';
			} else {
				/*
				 *		If we have an empty string, we replace it with ""
				 *		since it will typically be a Lock("").
				 */
				strcpy(namebuf, "\"\"");
			}
		}
		ev = CreateEvent(calladdr, &seqnum, actid, namebuf, optbuf,
						 (int)volname, lock);
		if (!ev)
			return;

		ev->result    = ev->options;
		ev->options  += RES_LEN;
		*ev->result   = '\0';
		ev->status    = ES_UPDATING;
		/*
		 *		We add the event to the waiting list BEFORE checking for Pause
		 *		so that if while paused, the user decides to disable packet
		 *		monitoring, the packet will be in the wait queue already and
		 *		thus will be safely flushed; otherwise, it would hang around
		 *		for ever (not doing any damage but wasting resources).
		 */
		AddWaitingPacket(ev, seqnum, "%s", dp, port, pt);
		CheckForPause(ev, seqnum);
		Signal(SnoopTask, NewEventMask);
	}
#undef RES_LEN
}

/*
 *		HandleRawPacket(calladdr, packet, port, packetref)
 *
 *		Handles the given packet by creating an event that matches the
 *		packet type (if we support it) and creating a new entry on the
 *		waiting packet list so we can match it up later.
 *
 *		This function handles all packets and produces a raw hex dump
 *		(with the name of the packet) rather than the more english-like
 *		"Open", "Lock", etc.
 */
void HandleRawPacket(ULONG calladdr, struct DosPacket *dp,
				     struct MsgPort *port, struct PacketRef *pt)
{
	/*
	 *		Building this event is a little tricky, since the result
	 *		string will not be a static string but will contain the
	 *		actual return value. Thus, we allocate enough room in the
	 *		filename portion to hold the result string as well, and
	 *		adjust our variables accordingly after the event has
	 *		been created.
	 *
	 *		The same is true for raw packet types (i.e. those that we
	 *		don't recognise at all).
	 */
#define RAW_LEN		20		/* Length of possible raw packet type	*/
#define RES_LEN		26		/* Length of longest result code		*/ 
#define ARG_LEN		50		/* Length of longest argument list		*/

	static char *fmt[] = {
		"(None)", "%8lx", "%8lx, %8lx", "%8lx, %8lx, %8lx",
		"%8lx, %8lx, %8lx, %8lx", "%8lx, %8lx, %8lx, %8lx, %8lx"
	};
	static char *failmsg[] = {
		"%s", "%-4s %8lx", "%-4s %8lx", "%-4s %8lx, %8lx"
	};
	char args[RAW_LEN+RES_LEN+ARG_LEN];
	char *tname = args;
	Event *ev;
	LONG  seqnum;

	if (pt->flags & PK_RAW)
		tname += RAW_LEN;   

	tname += RES_LEN;
	memset(args, ' ', tname - args);
	mysprintf(tname, fmt[pt->numparams], dp->dp_Arg1, dp->dp_Arg2,
							dp->dp_Arg3, dp->dp_Arg4, dp->dp_Arg5);

	ev = CreateEvent(calladdr, &seqnum, pt->msgid, args,
					 ((Task *)(port->mp_SigTask))->tc_Node.ln_Name,
					 NO_EXPAND);
	if (!ev)
		return;

	if (pt->flags & PK_RAW) {
		/*
		 *		Now fix up action name and target name
		 */
		ev->action    = ev->filename;
		ev->filename += RAW_LEN;
		mysprintf(ev->action, MSG(MSG_ACT_RAWPACKET), dp->dp_Type);
	}
	ev->result    = ev->filename;	/* Point to storage for later result */
	ev->filename += RES_LEN;
	*ev->result   = 0;				/* Make result field empty initially */
	ev->status	  = ES_UPDATING;
	/*
	 *		We add the event to the waiting list BEFORE checking for Pause
	 *		so that if while paused, the user decides to disable packet
	 *		monitoring, the packet will be in the wait queue already and
	 *		thus will be safely flushed; otherwise, it would hang around
	 *		for ever (not doing any damage but wasting resources).
	 */
	AddWaitingPacket(ev, seqnum, failmsg[pt->flags & PK_MASK], dp, port, pt);
	CheckForPause(ev, seqnum);
	Signal(SnoopTask, NewEventMask);
}

/*
 *		New_PutMsg()
 *
 *		This function is used frequently by the system to send a message
 *		from one task to another. It is also used by applications wishing
 *		to send ARexx messages, which is what we want to monitor.
 *
 *		The problem is: how do we distinguish system messages (of which
 *		there are lots!) from ARexx messages (which are relatively
 *		infrequent).
 *
 *		It's almost impossible to get a perfect solution to this, but we
 *		can get fairly close by checking the following:
 *
 *		  - The destination port must have a name
 *		  - The host name associated with the supposed Rexx message must
 *			point to valid memory
 *        - The action type for the Rexx message is RXCOMM
 *        - The Rexx system library must be up and running
 *        - The library base must be word aligned (else we fault on a 68000)
 *        - The Close() vector in the Rexx private system library must
 *			match the Close() vector in the Rexx library base that we
 *			opened ourselves (the library bases themselves can be different).
 *
 *		If all these hold true, then we can assume it is a valid ARexx
 *		message and display it accordingly.
 *
 *		For DOS packets, things are a little simpler since DOS packets contain
 *		cross-links that can be easily checked for validity. To keep things
 *		moving at a reasonable speed, we only consider StandardPackets, where
 *		the DosPacket structure immediately follows the exec message structure.
 *		This is not universally true, but it covers all the cases we want to
 *		monitor.
 *
 *		We need to intercept DOS packets twice -- once on the initial PutMsg
 *		to the target device, and once when the target device PutMsg's the
 *		reply. Thus, we maintain a list of outstanding packets so we can
 *		detect which is which.
 *
 *		To identify DOS packets, we use the following criterion:
 *
 *			- Task is a process
 *			- Message node's name points to valid longword-aligned memory
 *			- DOS packet (from name ptr) points back to message header
 *			- Either current task is on the list of devices we're monitoring
 *			  or the destination message port's owner is on the list of
 *			  devices we're monitoring.
 *		
 *		If any of these conditions fail, we ignore the message.
 *
 */		
ULONG ASM New_PutMsg(reg_a0 struct MsgPort *port, reg_a1 struct Message *msg,
					 reg_a6 void *libbase)
{
	MarkCallAddr;

	FP_PutMsg origfunc   = (FP_PutMsg)PatchList[GID_SENDREXX].origfunc;
	Task *thistask		 = SysBase->ThisTask;

/*
 *		Save a little stack space and time by making these non-local
 */
#define rmsg			((struct RexxMsg *)msg)
#define rexxclosevect 	(ULONG *)(((ULONG)RexxSysBase) - 10)
#define thisclosevect	(ULONG *)(((ULONG)rmsg->rm_LibBase) - 10)

	struct DosPacket *dp;
	Task  *desttask;
	Event *ev;
	LONG  seqnum;
	ULONG taskhandle;

	/*
	 *		Before doing anything else, check if we're being called from
	 *		within an interrupt. If so, get the heck out of here since
	 *		trying to obtain a semaphore from within an interrupt is
	 *		definitely a bad idea!
	 *
	 *		To quickly check if we're within an interrupt, we simply see
	 *		if our stack pointer is within the range of the supervisor stack.
	 *		If it is, then we're probably in an interrupt, or at least in
	 *		Supervisor mode, and either way we don't want to continue.
	 *
	 *		We also ignore ramlib, for the usual reasons, and our own
	 *		background task (since it is used to expand locks from within
	 *		of this patch and an infinite loop would be easy!)
	 */
	if (thistask == RamLibTask || thistask == (Task *)BackgroundProc ||
		(getreg(REG_A7) >= (ULONG)SysBase->SysStkLower &&
		 getreg(REG_A7) <= (ULONG)SysBase->SysStkUpper))
	{
		JumpOrigFunc(0);
	}

	/*
	 *		See if we have a valid ARexx message. See the function
	 *		header for an explanation of all the checks
	 */
	if (CurSettings.Func.Opts[GID_SENDREXX]			&&
		port->mp_Node.ln_Name						&&
		*port->mp_Node.ln_Name						&&
		rmsg->rm_CommAddr							&&
		TypeOfMem(rmsg->rm_CommAddr)				&&
		(rmsg->rm_Action & RXCODEMASK) == RXCOMM	&&
		RexxSysBase									&&
		TypeOfMem(thisclosevect)					&&
		((ULONG)thisclosevect & 1) == 0             &&
		*thisclosevect == *rexxclosevect)
	{
		/*
		 *		Okay, we know we've got a valid Rexx message so now enter
		 *		it into the event buffer. First, however, check that we
		 *		are within our stack bounds (since the normal check done
		 *		in the assembly patch code is bypassed for this function
		 *		to accomodate RAM returning DOS packets).
		 */
		if (getreg(REG_A7) >= (ULONG)thistask->tc_SPLower &&
		 	getreg(REG_A7) <= (ULONG)thistask->tc_SPUpper &&
		 	getreg(REG_A7) <=
			 			((ULONG)thistask->tc_SPLower+CurSettings.StackLimit))
		{
			JumpOrigFunc(0);
		}
		ev = CreateEvent(CallAddr, &seqnum, MSG_ACT_SENDREXX, rmsg->rm_Args[0],
						 port->mp_Node.ln_Name, NO_EXPAND);
		if (!ev)
			return origfunc(port, msg, libbase);

		ev->status = ES_UPDATING;
		CheckForPause(ev, seqnum);
		ObtainSemaphore(&BufSem);
		if (seqnum >= RealFirstSeq) {
			ev->status = ES_READY;
			Signal(SnoopTask, NewEventMask);
		}
		ReleaseSemaphore(&BufSem);
		return origfunc(port, msg, libbase);
	}

	/*
	 *		Not an ARexx message, now check if it's a DOS packet.
	 *		First though, we must check to see if we're already in
	 *		the middle of a SnoopDos patch -- if so, we could end up
	 *		recursing forever unless we don't try and monitor this one.
	 *
	 *		See above for the criteria we use to spot packet messages.
	 */
	taskhandle = CheckTaskRecursion();
	if (!taskhandle)
		return origfunc(port, msg, libbase);

	dp		 = (struct DosPacket *)(msg->mn_Node.ln_Name);
	desttask = port->mp_SigTask;

	if ((ShowAllPackets | MonPackets)							&&
		thistask->tc_Node.ln_Type == NT_PROCESS					&&
		((ULONG)dp & 1) == 0									&&
		TypeOfMem(dp)											&&
		dp->dp_Link == msg										&&
		((ULONG)(dp->dp_Port) & 3) == 0							&&
		TypeOfMem(dp->dp_Port))
	{
		/*
		 *		Looks like we're going to monitor the packet.
		 *
		 *		First, check if the packet is already on our list of
		 *		outstanding packets. If so, we can handle it immediately.
		 */
		struct PacketRef *pt;
		WaitPacket *wp;
		Task **ptask;
		char *p = NULL;

		/*
		 *		Now some slightly tricky stuff. We can have up to TWO
		 *		entries on the waiting packet list which match the current
		 *		packet (one for the Packet Debugger and one for the
		 *		Monitor Packets option) and we need to acknowledge them
		 *		both. However, we also need to ensure we never try and
		 *		lock both the PacketSem and BufferSem at the same time
		 *		(since otherwise we could deadlock).
		 *
		 *		This effectively means we have to restart our list scan
		 *		after each packet has been acknowledged, until we have
		 *		no more left -- a small speed hit, but actually not too
		 *		bad since most times, we will be the only packet on the
		 *		wait list anyway. (We use 'p' as a flag to indicate
		 *		whether or not we found a packet, so we know to return
		 *		at the end of it all.)
		 */
		ObtainSemaphore(&PacketSem);
		wp = HeadNode(&PacketWaitList);
		while (NextNode(wp)) {
			if (wp->dp		 == dp					&&
				wp->sendtask != thistask			&& 
				wp->destport != port				&&
				wp->arg1	 == dp->dp_Arg1			&&
				wp->arg2	 == dp->dp_Arg2			&&
				wp->arg3	 == dp->dp_Arg3)
			{
				/*
				 *		Found the packet on our list, so go ahead and fill in
				 *		the result code for the associated event (assuming it
				 *		hasn't scrolled off the buffer, of course!)
				 */
				Event *ev 	  = wp->event;
				LONG   seqnum = wp->eventnum;
				char  *fmsg   = wp->resmsg;
				char   flags  = wp->flags;

				Remove((Node *)wp);
				AddHead(&PacketFreeList, (Node *)wp);
				ReleaseSemaphore(&PacketSem);
				ObtainSemaphore(&BufSem);
				if (seqnum >= RealFirstSeq) {
					/*
					 *		Okay, now fill in the result string. The space for
					 *		this was allocated when the event was defined.
					 *
					 *		For events that succeed, we can print "Okay",
					 *		"Okay <result>", and "Okay <result1> <result2>".
					 *
					 *		For events which fail, we can print
					 *		"Fail <result2>" or "Fail <result1> <result2>"
					 */
					UWORD fail;
					ULONG param;
					char  *q, *r;

#define					  evresmsg	MSG(fail ? MSG_RES_FAIL : MSG_RES_OKAY)

				 	fail = ((flags & PKF_BOOL) && dp->dp_Res1 == 0)	 ||
						   ((flags & PKF_NEG)  && dp->dp_Res1 == (ULONG)-1);

#if NOT_WORRIED_ABOUT_STACK_SIZE
					/*
					 *		Unfortunately, we can't use this nice simple
					 *		code because calling mysprintf() uses too much
					 *		stack space if we're being called from certain
					 *		handlers with minimal stack space (e.g. RAM).
					 *		Instead, we must do the same effect ourselves.
					 *		This code is left here so you can see what the
					 *		original intention was.
					 */
					if ((flags & PK_MASK) == PK_2OK) {
						mysprintf(ev->result, fmsg, evresmsg,
								  dp->dp_Res1, dp->dp_Res2);
					} else {
						mysprintf(ev->result, fmsg, evresmsg, 
								  (fail ? dp->dp_Res2 : dp->dp_Res1));
					}
					p = (char *)-1;	/* Non-zero means we did something */

#else /* Extremely worried about stack size */

					/*
					 *		Here we roll our own sprintf() (inline!) to keep
					 *		stack usage to an absolute minimum. It's a rather
					 *		small subset and somewhat hacked, you'll notice.
					 *
					 *		We make P non-null to indicate we did some work
					 */
					p = fmsg;
					q = ev->result;

					/*
					 *		First, skip over string formatter at start which
					 *		always holds either 'Ok' or 'Fail'
					 */
					strcpy(q, evresmsg);
					q += strlen(q);
					while (q < (ev->result + 4))
						*q++ = ' ';
					while (*p && *p != 's')
						p++;
					if (*p)
						p++;

					/*
					 *		Now parse remainder of string. The first parameter
					 *		encountered gets replaced with either dp_Res1 or
					 *		dp_Res2, depending on circumstances. The second
					 *		parameter always gets replaced with dp_Res2.
					 */
					if ((flags & PK_MASK) == PK_2OK || !fail)
						param = dp->dp_Res1;
					else
						param = dp->dp_Res2;

					while (*p) {
						if (*p != '%') {
							*q++ = *p++;
							continue;
						}
						while (*p && *p != 'x' && *p != 'X')
							p++;
						p++;
						if (param == 0) {
							strcpy(q, "       0");
						} else if (param == (ULONG)-1) {
							strcpy(q, "      -1");
						} else {
							/*
							 *		Expand param to 8 hex digits, right-aligned
							 */
							r = q + 7;
							while (param > 0) {
								*r-- = "0123456789ABCDEF"[param & 15];
								param >>= 4;
							}
							while (r >= q)
								*r-- = ' ';
						}
						q += 8;
						param = dp->dp_Res2; /* Second parm always dp_Res2 */
					}
					*q = '\0';
#endif
					/*
					 *		Unlike most times, we don't signal SnoopDos that
					 *		an event has been updated (yet) since there may
					 *		be another event to update too, and it's best
					 *		to do a single signal at the end (fewer context
					 *		switches are required.) So, we just mark the
					 *		event as ready.
					 */
					ev->status = ES_READY;
				}
				ReleaseSemaphore(&BufSem);
				ObtainSemaphore(&PacketSem);
				/*
				 *		Now restart the search from the beginning of the
				 *		list (since wp is no longer valid)
				 */
				wp = HeadNode(&PacketWaitList);
			} else {
				/*
				 *		Just advance to next element on list
				 */
				wp = NextNode(wp);
			}
		}
		ReleaseSemaphore(&PacketSem);
		if (p) {
			/*
			 *		Found a matching packet, so wake up the main task
			 *		and finish up. (We only signal the main snoop task
			 *		now, so that both events get printed simultaneously,
			 *		rather than one after another, which would be a little
			 *		messy). This also avoids us getting pre-empted inside
			 *		our loop above if SnoopDos is running at a higher priority
			 *		than this task, which is convenient (though not essential).
			 */
			Signal(SnoopTask, NewEventMask);
			goto done_putmsg;
		}

		/*
		 *		If we didn't find a match on our list of waiting packets,
		 *		then check to see if we're ignoring ROM calls. If so,
		 *		and if we were called from ROM, then immediately abort
		 *		(this would be done later anyway, but by checking now,
		 *		we save quite a bit of time.)
		 *
		 *		(We can't do this checking any earlier, or we'd miss
		 *		returned packets from ROM filesystems like RAM: and FFS).
		 *
		 *		We also exit if we're under the stack limit. (We can't
		 *		check this earlier because otherwise we'd miss the
		 *		return packet from RAM which only has a tiny stack.)
		 */
		if (((!MonROMCalls && CallAddr >= RomStart && CallAddr <= RomEnd)) ||
			(getreg(REG_A7) >= (ULONG)thistask->tc_SPLower &&
			 getreg(REG_A7) <= (ULONG)thistask->tc_SPUpper &&
			 getreg(REG_A7) <=
			 			((ULONG)thistask->tc_SPLower+CurSettings.StackLimit)))
		{
			goto done_putmsg;
		}

		/*
		 *		Okay, didn't match the packet with a previous outgoing one.
		 *		Now search the device list to see if we can match either
		 *		the owner of the port (a new outgoing packet) or the task ID
		 *		of the sender (a returning packet).
		 *
		 *		In the case of a returning packet, we just ignore it since
		 *		we missed it on the way out.
		 */
		for (ptask = DeviceTaskList; *ptask && *ptask != desttask; ptask++) {
			if (*ptask == thistask)
				goto done_putmsg;	/* Sender was a DOS device so ignore */
		}
		if (!*ptask) {
			/*
			 *		Couldn't find dest task on device list so it must
			 *		be a message to somewhere else -- hence, ignore it.
			 */
			goto done_putmsg;
		}

		/*
		 *		Okay, got ourselves a bona fida packet. Next, look it up
		 *		in our packet table to decide what to do with it.
		 *		Unrecognised packets come out as LAST_PACK_MSG which is
		 *		specifically initialised to handle them properly.
		 */
		for (pt = &PacketTable[0]; pt->msgid != LAST_PACK_MSG; pt++)
			if (pt->packetid == dp->dp_Type)
				break;
		
		if (pt->flags & PK_IGNORE)	/* Certain packet types are ignored */
			goto done_putmsg;

		/*
		 *		Okay, we finally (finally!) get to create a new entry
		 *		in our event buffer. Actually, we get to create two
		 *		entries, since if we have both the Packet Debugger
		 *		AND the Monitor Packets option turned on, we want to
		 *		see the output from both of them (even if they're both
		 *		the same event!).
		 *
		 *		Why? Well, if you're debugging a device driver and you
		 *		have Open packets etc. coming back and forth, then 
		 *		as well as the raw packet data, it's also kind of nice
		 *		to see actual filenames etc. in english instead of hex.
		 */
		if (MonPackets && (pt->flags & PK_COMMON))
			HandleSimplePacket(CallAddr, dp, port, pt);

		if (ShowAllPackets)
			HandleRawPacket(CallAddr, dp, port, pt);
	}

done_putmsg:
	EndTaskRecursion(taskhandle);
	return origfunc(port, msg, libbase);
}