/*
	File:		Patches.c

	Contains:	Routines which monitor/maintain/switch patches made by applications.

	Written by:	Phil Goldman

	Copyright:	© 1986-1991 by Apple Computer, Inc., all rights reserved.

	Change History (most recent first):
	 
		 <4>	 1/14/91	DFH		(JDR) Fixed latent bug in c_settrapaddress that mishandled
									SetTrapWordAddress of am OSTrap.
		 <3>	 1/10/91	DFH		(JDR) Add hack to prevent HyperCard 1.2.5 patch to SysBeep.
		 <0>	10/26/86	PYG		New Today.

*/ 
 
#include <errors.h>
#include <memory.h>
#include <menus.h>
#include <osutils.h>
#include <retrace.h>
#include <segload.h>
#include <traps.h>
#include <types.h>
#include <MFPrivate.h>

#include "Glue.h"
#include "Lomem.h"
#include "Data.h"
#include "SysMisc.h"
#include "Patches.h"

#define OS_TRAPTABLE_MASK					((short) (0x0FF))
#define TB_TRAPTABLE_MASK					((short) (0x3FF))
#define HIGHEST_CONTIG_MACPLUS_OSTRAPNUM	((short) (0x04F))

#define TRAPNUM_NEWOSSETTRAPADDRESS			(_SetTrapAddress + (1<<9))
#define TRAPNUM_NEWTOOLSETTRAPADDRESS		(_SetTrapAddress + (1<<9) + (1<<10))
#define TRAPNUM_SETTRAPWORDADDRESS			(_SetTrapAddress + (1<<10))
#define SETTRAPWORDADDRESS_TYPE_MASK		(0x0800)

#define NullTrapType				3
#define PATCH_TABLE_COUNT_INIT		10

Ptr						blockTrapAddr;

/* c_GetProcessTrapAddress.  Implements GetProcessTrapAddress selector of OSDispatch. */
pascal OSErr
c_GetProcessTrapAddress(ProcessSerialNumberPtr pPSN, Ptr *pTrapAddr, TrapType trapType, unsigned short trapNum)
	{
	register PEntryPtr	pProc;
	PatchEntryHdl		hPatch;
	PatchEntryPtr		pPatch;
	unsigned long		olda5;

	olda5 = ProcessMgrA5SimpleSetup();
	if ((pProc = PEntryFromPSN(pPSN)) == nil)
		{
		A5SimpleRestore(olda5);
		return(procNotFound);
		}

	/* If target is current process, a simple NGetTrapAddress will do */
	if (pProc == pCurrentProcess)
		{
		*pTrapAddr = (Ptr) NGetTrapAddress(trapNum, trapType);
		A5SimpleRestore(olda5);
		return(noErr);
		}
	
	/* Otherwise, we must look through the process' patch registry */
	hPatch = (*pProc->p_pcb)->applPatchTable;
	trapNum &= (trapType == ToolTrap) ? TB_TRAPTABLE_MASK : OS_TRAPTABLE_MASK;
	*pTrapAddr = 
		((pPatch = GetApplPatch(hPatch, trapNum, (unsigned short) trapType)) != nil)
			? (Ptr) pPatch->newtrap
			: GetRealTrapAddr(trapNum, trapType);

	A5SimpleRestore(olda5);
	return(noErr);
	}

/* c_SetProcessTrapAddress.  Implements SetProcessTrapAddress selector of OSDispatch. */
pascal OSErr
c_SetProcessTrapAddress(ProcessSerialNumberPtr pPSN, Ptr trapAddr, TrapType trapType, unsigned short trapNum)
	{
	PEntryPtr			pProc;
	unsigned long		olda5;
			
	olda5 = ProcessMgrA5SimpleSetup();
	if ((pProc = PEntryFromPSN(pPSN)) == nil)
		{
		A5SimpleRestore(olda5);
		return(procNotFound);
		}
	
	trapNum &= (trapType == ToolTrap) ? TB_TRAPTABLE_MASK : OS_TRAPTABLE_MASK;
	UpdatePatchRegistry(pProc, trapAddr, trapType, trapNum);
	if (pProc == pCurrentProcess)
		settrapaddress_glue(trapAddr, trapNum, _SetTrapAddress, patchtraps[SETTRAPADDRESS].oldtrap);

	A5SimpleRestore(olda5);
	return(noErr);
	}

/* c_settrapaddress.  Patch to SetTrapAddress to record patches made by applications.
 * App patches get a) removed on minor switch out or app death, b) re-implanted on
 * minor switch in.
 *
 * Although SetTrapAddress is one trap, there are three variants based on bits 9 & 10
 * of the trap word.  Both off is the original SetTrapAddress, which is mostly out of
 * date since the trap explosion in the Mac II resulted in an overlap between OS and
 * toolbox trap numbers.  The newer SetTrapAddresses cope by having the caller specify
 * in the trap word (i.e. bits 9 & 10) whether the trap is an OS trap or a toolbox trap.
 * Both on means ToolTrap.  Bit 9 on and bit 10 off means OSTrap.  Our table records
 * both the trap number and trap type, so we can make the correct calls later on.  The
 * trap number is masked to the significant part so we can compare them.
 * NOTE: This contains a hack to prevent HyperCard 1.2.5 from patching SysBeep.  Said
 * patch breaks horribly under System 7.0 and later.  We go to pains to prevent just
 * the first patch attempt, because XCMDs and sub-pieces may have their own patches.
 */
void
c_settrapaddress(Ptr trapAddr, unsigned short trapNum, short staTrapWord)
	{
	register unsigned short		trapType, trapNumCopy;
	unsigned long				olda5;

	olda5 = ProcessMgrA5SimpleSetup();
	
	/* Assert this since we assume that masking to OS_TRAPTABLE_MASK after masking to
	 * TB_TRAPTABLE_MASK will not lose any bits from the OS_TRAPTABLE_MASK.
	 */
	assert((TB_TRAPTABLE_MASK & OS_TRAPTABLE_MASK) == OS_TRAPTABLE_MASK);
	
	/* Assume TB until proven OS */
	trapType = ToolTrap;
	trapNumCopy = trapNum;
	trapNum &= TB_TRAPTABLE_MASK;
	
	/* Check whether trap is OSTrap.  Inhibit HyperCard 1.2.5 SysBeep patch. */
	if ( (staTrapWord == (short) TRAPNUM_NEWOSSETTRAPADDRESS) ||
		((staTrapWord == (short) TRAPNUM_SETTRAPWORDADDRESS) && ((trapNumCopy & SETTRAPWORDADDRESS_TYPE_MASK) == 0)) ||
		((staTrapWord == (short) _SetTrapAddress) && 
			((trapNum <= HIGHEST_CONTIG_MACPLUS_OSTRAPNUM) ||
			(trapNum == (_UprString & TB_TRAPTABLE_MASK)) ||
			(trapNum == (_SetApplBase & TB_TRAPTABLE_MASK)))) )
		{
		trapType = OSTrap;
		trapNum &= OS_TRAPTABLE_MASK;
		}
	else if ( (trapNum == (_SysBeep & TB_TRAPTABLE_MASK)) &&
			(pCurrentProcess->p_preventFirstSysBeepPatch) )
		{
		pCurrentProcess->p_preventFirstSysBeepPatch = false;
		A5SimpleRestore(olda5);
		return;
		}
	
	/* Record it.
	 * NOTE: Gee, great… if pCurrentProcess is nil (like during switch_task) the trap
	 * doesn't get recorded.  This means it becomes the "original" for new apps or any
	 * existing ones that haven't patched it.  Gross.  Hopefully, apps are the only
	 * things calling SetTrapAddress after INIT time.
	 */
	if (pCurrentProcess != nil)
		UpdatePatchRegistry(pCurrentProcess, trapAddr, trapType, trapNum);

	/* Call old routine */
	settrapaddress_glue(trapAddr, trapNum, staTrapWord, patchtraps[SETTRAPADDRESS].oldtrap);

	A5SimpleRestore(olda5);
	}

/* GetApplPatch.  Get ptr to application patch entry for given trapNum, or nil. */
PatchEntryPtr
GetApplPatch(PatchEntryHdl hPatch, register unsigned short trapNum, register unsigned short trapType)
	{
	register PatchEntryPtr		pPatch;
	PatchEntryPtr				pPatchMax;

	/* Get base and bound of table */	
	pPatch = (PatchEntryPtr) StripAddress(*hPatch);
	pPatchMax = ((Ptr) pPatch + GetHandleSize(hPatch));
	
	/* Search for a matching entry */
	while (pPatch < pPatchMax)
		{
		if (pPatch->trapnum == trapNum && pPatch->traptype == trapType)
			return(pPatch);
		pPatch++;
		}
	
	/* exiting loop means no-find */
	return(nil);
	}

/* UpdatePatchRegistry.  Add, remove, or change the patch registry entry for the
 * given patch and process.
 */
void
UpdatePatchRegistry(PEntryPtr pProc, Ptr trapAddr, TrapType trapType, unsigned short trapNum)
	{
	PatchEntryHdl		hPatch;
	PatchEntryPtr		pPatch;
	PCB					**pcbHdl;
	Ptr					currTrapAddr;
#ifdef WRITENOW_FIX
	ProcPtr				SetOverlaySystemEvent(ProcPtr);
#endif WRITENOW_FIX
#ifdef MSWORKS_FIX
	ProcPtr				SetOverlayRecoverHandle(ProcPtr);
#endif MSWORKS_FIX

	/* Get handle to table and size.
	 * NOTE: The extraordinary case of a nil pProc->p_pcb happens if someone patches
	 * while pCurrentProcess == pNullProcess.  Not impossible!  An INIT can patch
	 * a trap we call while launching Finder.  If that patch makes a patch, we're there!
	 */
	if ((pcbHdl = pProc->p_pcb) == nil)
		return;
	hPatch = (*pcbHdl)->applPatchTable;
	
	/* See if app is modifying an existing patch (i.e. whether entry already exists). */
	if ((pPatch = GetApplPatch(hPatch, trapNum, (unsigned short) trapType)) != nil)
		{
		/* Application is unpatching if new address same as its original */
		if (pPatch->oldtrap == trapAddr)
			{
			RemoveApplPatch(pPatch);
			(*pcbHdl)->applPatchCount--;
			}
		
		/* Application is re-adjusting a patch.  Don't touch pPatch->oldtrap! */
		else
			pPatch->newtrap = trapAddr;
		}
		
	/* Application is making a new patch */
	else
		{
#ifdef WRITENOW_FIX
		/* NOTE:  Special hack for WriteNow -- see DeskMgrPatches.c */
		if ( (trapNum == (_SystemEvent & TB_TRAPTABLE_MASK))
			&& trapType == ToolTrap
			&& pCurrentProcess->p_signature == 'nX^n' )
			{
			(ProcPtr)trapAddr = SetOverlaySystemEvent(trapAddr);
			}
#endif WRITENOW_FIX

#ifdef MSWORKS_FIX
		/* NOTE:  Special hack for Works -- see MiscPatches.a and Utilities.c */
		else if ( (trapNum == (_RecoverHandle & OS_TRAPTABLE_MASK))
					&& (trapType == OSTrap)
					&& (pCurrentProcess->p_signature == 'PSIP') )
			{
			(ProcPtr)trapAddr = SetOverlayRecoverHandle(trapAddr);
			}
#endif MSWORKS_FIX

		currTrapAddr = (pProc == pCurrentProcess)
			? (Ptr) NGetTrapAddress(trapNum, trapType) : GetRealTrapAddr(trapNum, trapType);
		AddApplPatch(hPatch, currTrapAddr, trapAddr, trapNum, trapType);
		(*pcbHdl)->applPatchCount++;
		}
	}
	
/* AddApplPatch.  Add trap to application's trap table */
void
AddApplPatch(PatchEntryHdl hPatch, Ptr currTrapAddr, Ptr trapAddr, unsigned short trapNum, unsigned short trapType)
	{
	PatchEntryPtr		pPatch, pPatchMax;
	u_long				trapTabSize, newTrapTabSize;
	
	/* Find size, base, and bound of trap table */
	trapTabSize = GetHandleSize(hPatch);
	pPatch = *hPatch;
	pPatchMax = ((Ptr) pPatch + trapTabSize);
	
	/* Find an empty entry */
	while (pPatch < pPatchMax)
		{
		if (pPatch->traptype == NullTrapType)
			break;
		pPatch++;
		}
		
	/* Did we reach end of table? */
	if (pPatch >= pPatchMax)
		{
		/* If so, grow by one entry.  Reset pPatch since table handle might move. */
		newTrapTabSize = trapTabSize + sizeof(PatchEntry);
		SetHandleSize(hPatch, newTrapTabSize);
		pPatch = (PatchEntryPtr) (((Ptr) *hPatch) + trapTabSize);
		}

	/* Initialize the patch entry. */		
	pPatch->trapnum = trapNum;
	pPatch->traptype = trapType;
	pPatch->oldtrap = currTrapAddr;
	pPatch->newtrap = trapAddr;
	}

/* GetRealTrapAddr.  Get the trap address underneath the application patch level.
 * NOTE: This does not work well if called while we are in the parts of switch_task
 * where pCurrentProcess == nil, but either app's patches are still installed.
 */
Ptr
GetRealTrapAddr(unsigned short trapNum, unsigned short trapType)
	{
	register PatchEntryPtr	pPatch;
	register PatchEntryHdl	hPatch;
	
	pPatch = nil;
	if (pCurrentProcess != nil)
		{
		hPatch = (*pCurrentProcess->p_pcb)->applPatchTable;
		pPatch = GetApplPatch(hPatch, trapNum, (unsigned short) trapType);
		}
		
	return (pPatch != nil) ? (Ptr) pPatch->oldtrap : (Ptr) NGetTrapAddress(trapNum, trapType);
	}

/* save_or_restore_dispatch.  Switch in or out the patches made by the 
 * specified process.  Patches should be switched out only after all the
 * executable objects that need these patches have been switched out.
 * Patches should be switched in before switching in any executable
 * objects that need them.  These executables include the VBLs, drivers,
 * and "hooks".
 */
void
save_or_restore_dispatch(PCB *PCBPtr, int do_restore)
	{
	PatchEntryHdl			hPatch;
	register PatchEntryPtr	pPatch, pPatchMax;

	/* Check if valid */
	if (PCBPtr == nil
		|| PCBPtr->applPatchCount == 0
		|| (hPatch = PCBPtr->applPatchTable) == nil)
			return;

	pPatch = *hPatch;
	pPatchMax = ((Ptr) pPatch + GetHandleSize(hPatch));
	
	while (pPatch < pPatchMax)
		{
		if (pPatch->traptype != NullTrapType)
			{
			/* (Un)patch this trap */
			settrapaddress_glue(
				(do_restore != SAVE_DISPATCH) ? pPatch->newtrap : pPatch->oldtrap,
				pPatch->trapnum,
				(pPatch->traptype ? TRAPNUM_NEWTOOLSETTRAPADDRESS : TRAPNUM_NEWOSSETTRAPADDRESS),
				patchtraps[SETTRAPADDRESS].oldtrap);
			}
		pPatch++;
		}
	}

/* kill_dispatch.  Remove app's patches, and the registry. */
void
kill_dispatch(PCB *PCBPtr)
	{
	if (PCBPtr->applPatchTable != nil)
		{
		save_or_restore_dispatch(PCBPtr, SAVE_DISPATCH);
		PCBPtr->applPatchCount = 0;
		DisposHandle(PCBPtr->applPatchTable);
		PCBPtr->applPatchTable = nil;
		}
	}

/* InitApplPatchTable.  Initialize specified trap table and counter. */
void
InitApplPatchTable(PatchEntryHdl *pApplPatchTab, short *applPatchCountPtr)
	{
	PatchEntryPtr	pPatch, pPatchMax;
	long			size = PATCH_TABLE_COUNT_INIT * sizeof(PatchEntry);
	PatchEntryHdl	hPatch;

	/* Initialize the parameters */
	*applPatchCountPtr = 0;
	*pApplPatchTab = hPatch = NewHandle(size);
	if (hPatch == nil)
		return;
	
	/* Initialize the table */
	pPatch = *hPatch;
	pPatchMax = ((Ptr) pPatch + size);
	while(pPatch < pPatchMax)
		(pPatch++)->traptype = NullTrapType;
	}

#pragma segment INIT

/* InstallPatches. Install the Process Mgr's patches. */
void
InstallPatches(void)
	{
	register PatchEntryPtr		pPatch;
	unsigned long				isNewTrap;
	Ptr							unimplTrapAddr;

	blockTrapAddr = (Ptr) NGetTrapAddress(_BlockMove, OSTrap);
	unimplTrapAddr = (Ptr) NGetTrapAddress(_Unimplemented, ToolTrap);
	
	pPatch = (IS_NUMAC_ROMS(ROM85)) ? &patchtraps[FIRST_ROM78_TRAP] : &patchtraps[FIRST_ROM75_TRAP];
		
	while ( (unsigned long) pPatch->newtrap != 0)
		{
		isNewTrap = (long) pPatch->oldtrap;	/* Marked by -1 in this field */
		pPatch->oldtrap = (void (*)()) NGetTrapAddress(pPatch->trapnum, pPatch->traptype);
		if (isNewTrap || pPatch->oldtrap != unimplTrapAddr)
			{
			NSetTrapAddress((long) ROUTINE_ADDR(pPatch->newtrap), pPatch->trapnum, pPatch->traptype);
			}
		pPatch++;
		}
	
	/* Cache address of CheckLoad */
	SetOldCheckLoad(patchtraps[CHECKLOAD].oldtrap);
	}
	
#pragma segment Main