supermario/base/SuperMarioProj.1994-02-09/ProcessMgr/AppleEventExtensions.c

/*
	File:		AppleEventExtensions.c

	Contains:	Routines which support AppleEvents as an extension of EPPC.  Specifically,
				it handles automatic translation of standard AppleEvents saeOpen and
				saeQuit to Puppet Strings, and implements the system AppleEvents (e.g.
				aeQuitAll).

	Written by: David Harrison

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

    This file is used in these builds: BigBang

	Change History (most recent first):
	 
		 <6>	 2/18/91	DFH		BAC,WS#BAC 2/15-1:Add hack to make Installer 3.1 work, since
									they expect slightly obsolete four-letter codes in their
									AppleEvents.
		 <5>	  2/9/91	JWM		DFH,#79583:Restart and Shutdown don't work in low memory
									conditions. This involved several of the messages which are sent
									during the processing of a QuitAll message. The fix was to make
									a new version of ProcessMgrHiNewHandle which on failing to get
									memory from the Process Manager's heap would try to get memory
									from the system heap.
		 <4>	  2/1/91	DFH		stb,WS#DFH-910131c:Fixed HandleFeedback to allow for sender's
									being kSystemProcess (i.e. Puppet string translation).
		 <3>	  2/1/91	DFH		BAC,WS#DFH-910131c:saeAnswer keyword parameter with the OSErr is
									now the 'errn', rather than 'errv'.
		 <0>	 9/20/89	DFH		New Today.

*/ 

#pragma segment	kernel_segment

#include <Aliases.h>
#include <AppleEvents.h>
#include <AppleEventsInternal.h>
#include <Errors.h>
#include <EPPC.h>
#include <Files.h>
#include <SegLoad.h>
#include <MFPrivate.h>

#include "Lomem.h"
#include "Data.h"
#include "Glue.h"
#include "Puppet.h"
#include "OSDispatchPrivate.h"
#include "SysMisc.h"
#include "EppcPrivate.h"
#include "AppleEventExtensions.h"

/************************************************************************************
 *								 Utility routines.
 ************************************************************************************/

/* FindKeywordParameter.  Utility routine to return a pointer the parameter having
 * the specified keyword.  Does not return meta-parameters, since we have no use for
 * them yet.  Returns nil if not found.
 */
AETFParameter *
FindKeywordParameter(AETFHeader *pMsg, unsigned long msgSize, unsigned long keyword)
	{
	AETFParameter	*pParam;
	Ptr				limitPtr;
	Boolean			afterMetaParams;

	afterMetaParams = false;
	limitPtr = (Ptr) pMsg + msgSize;
	pParam = (AETFParameter *) ((Ptr) pMsg + sizeof(AETFHeader));
	while ((Ptr) pParam < limitPtr)
		{
		/* Find what we're looking for? */
		if ((pParam->key == keyword) && (afterMetaParams))
			return(pParam);
		
		/* Move to next parameter, by hook or by crook */
		if (pParam->key == aeEndOfMetaDataKeyword)
			{
			(Ptr) pParam += sizeof(KeyWord);
			afterMetaParams = true;
			}
		else
			(Ptr) pParam += pParam->descriptor.dataLength + sizeof(AETFParameter);
		}
	
	return(nil);
	}

/* ExamineDocList.  Given a message that could contain either a single AETFDescriptor or
 * a list of AETFDescriptors, determine the location of the first AETFDescriptor, and
 * the count of AETFDescriptors.  Does the right thing if pMsg == nil.
 */
void
ExamineDocList(AETFHeader *pMsg, unsigned long msgSize, AETFDescriptor **pFirstFile, short *paramCount)
	{
	AETFParameter		*pParam;
	short				parmCount;
	Ptr					pBuff;

	parmCount = 0;
	pBuff = nil;
	if ( (pMsg != nil) &&
		((pParam = FindKeywordParameter(pMsg, msgSize, aeDirectObjectKeyword)) != nil) )
		{
		if (pParam->descriptor.dataType == aeListParamType)
			{
			AETFDescriptorList	*pAEList;
			
			pAEList = (AETFDescriptorList *) &(pParam->descriptor);
			parmCount = pAEList->count;
			pBuff = (Ptr)pAEList + sizeof(AETFDescriptorList) + pAEList->hdrLength;
			}
		else if (pParam->descriptor.dataType == aeAliasParamType)
			{
			parmCount = 1;
			pBuff = (Ptr) pParam + sizeof(AETFParameter);
			}
		}
	
	/* Return pointer to first AETFDescriptor, and count */
	*pFirstFile = (AETFDescriptor *) pBuff;
	*paramCount = parmCount;
	}

/* NextListParam.  Moves to the next AETFDescriptor in a list (assumes no keyword). */
void
NextListParam(AETFDescriptor **ppParam)
	{
	AETFDescriptor	*pParam;
	Ptr				pBuff;
	
	/* Bump pointer by size of data */
	pParam = *ppParam;
	pBuff = (Ptr) pParam + sizeof(AETFDescriptor) + pParam->dataLength;
	
	/* Check even alignment */
	assert(WORD_ALIGNED((unsigned long) pBuff));

	*ppParam = (AETFDescriptor *) pBuff;
	}

/*************************************************************************************
 * The following routines convert the "standard" subset of AppleEvents to puppet
 * strings in the event the receiver does not understand EPPC.  Currently, the
 * translations we support are saeOpenDocumentMsgID and saeQuitMsgID.
 *
 * Translation works as follows.  When we install the puppet instructions, we include
 * the MFmsgBlk in the p_puppetvars, and post the return receipt, if any.  When
 * the puppet string is over (canceled or completed), postTranslationResult is called
 * with the MFmsgBlk, returning the result in an AppleEvent back to the original
 * sender.  Simple, eh?
 *
 * If the translation is canceled (e.g. the target's file menu Open item is disabled),
 * we leave the target as the foreground process, but a message is sent back to the
 * originator.
 ************************************************************************************/

/* Handy macros */	
#define SendOpenInstruction(pMsgBlk)		SendFileInstruction(instrOpen, pMsgBlk)
#define SendQuitInstruction(pMsgBlk)		SendGenericInstruction(instrQuit, pMsgBlk)

/* SendInstructions.  Given a completed instruction list and message block, install
 * them on the target process.  Makes sure that target will be the frontmost
 * application, since this is a requirement of puppet strings.
 */
OSErr
SendInstructions(EventListHdl eventListH, MFmsgBlkPtr msgBlk)
	{
	PEntryPtr	pProc;
	OSErr		switchError;

	/* Lock on target */
	pProc = PEntryFromPSN(&msgBlk->targetmfid.localPSN);
	assert(pProc != nil);
	
	/* Arrange to have him come forward. */
	if ( (pProc != pFrontProcess) && ((switchError = SetFrontProcess(&pProc->p_serialNumber)) != noErr) )
		return(switchError);
	
	/* Install the instructions */
	if ((switchError = CoreRequestScratchSwitchTask(pProc, eventListH, nil, 0, msgBlk)) != noErr)
		return(switchError);
	
	/* If the target is already frontmost, we have to put him in the mood to look at the
	 * puppet string.
	 */
	if (pProc == pFrontProcess)
		{
		CancelSleep(pProc);
		pProc->p_state = PRPUPPET;
		}
	
	return(noErr);
	}
 
/* SendGenericInstruction.  Sends a puppet string instruction that requires no parameters. */
OSErr
SendGenericInstruction(short theInstruction, MFmsgBlkPtr msgBlk)
	{
	EventListHdl	eventListH;
	EventListPtr	eventListP;
	OSErr			error;
	
	/* Make a new event list handle */
	if ((eventListH = GMBlk(SIZEOF_EVENTLIST_HDR+sizeof(EventRecord), &error)) == nil)
			return(error);
	eventListP = *eventListH;

	/* Fill in the details */
	eventListP->offset = SIZEOF_EVENTLIST_HDR;
	eventListP->count = 1;
	eventListP->events[0].what = app4Evt;
	eventListP->events[0].message = theInstruction << 24;
	
	/* Install the instructions, making sure the application will be frontmost */
	if ((error = SendInstructions(eventListH, msgBlk)) != noErr)
		DisposHandle(eventListH);
	
	return(error);
	}

/* AppFileAndDocList.  Convert an AppFile file specification into the AETFDescriptor
 * equivalent, and append this to the existing DocList handle.
 */
OSErr
AppFileAndDocList(AppParmRecHdl hAPH, unsigned long *pCurrOffset, Handle hDocList)
	{
	AppFile				*pAppFile;
	FSSpec				fileSpec;
	AETFDescriptor		parmDesc;
	AliasHandle			hAlias;
	OSErr				err;
	
	/* Make file spec for use with NewAliasMinimal */
	HLock(hAPH);
	pAppFile = ((Ptr) *hAPH) + *pCurrOffset;
	err = FSMakeFSSpec(pAppFile->vRefNum, 0, &(pAppFile->fName), &fileSpec);
	
	/* Update offset even in error case */
	*pCurrOffset += SizeOfThisAppFile(pAppFile);
	HUnlock(hAPH);
	
	/* Bail if error */
	if (err != noErr)
		return(err);
	
	/* Make a new alias record */
	if ((err = NewAliasMinimal(&fileSpec, &hAlias)) != noErr)
		return(err);

	/* Append new alias info to existing list.
	 * NOTE: The SetHandleSize in the error case assumes that the block shrinks
	 * at the top.
	 */
	parmDesc.dataType = aeAliasParamType;
	parmDesc.dataLength = GetHandleSize(hAlias);
	if ((err = PtrAndHand(&parmDesc, hDocList, sizeof(AETFDescriptor))) == noErr)
		if ((err = HandAndHand(hAlias, hDocList)) != noErr)
			SetHandleSize(hDocList, GetHandleSize(hDocList) - sizeof(AETFDescriptor));
	
	DisposHandle(hAlias);
	return(err);
	}

/* FileIDToAppFile.  Convert an AppleEvent file specification to one suitable for
 * APPARMHANDLE or puppet stringing.  Does not create a working directory, but
 * returns the vRefNum and dirID so one can be opened later.
 */
OSErr
FileIDToAppFile(AETFDescriptor *pFileID, AppFile *pAppFile, short *pVol, long *pDirID)
	{
	AliasHandle			hAlias;
	Boolean				aliasChanged;
	FSSpec				fileSpec;
	HFileParam			fInfoRec;
	OSErr				err;
	
	/* Can do nothing if the spec is not an alias */
	if (pFileID->dataType != aeAliasParamType)
		return(paramErr);
	
	/* Make an AliasHandle out of the spec */
	if ((err = PtrToHand((AliasPtr) ((Ptr) pFileID + sizeof(AETFDescriptor)), &hAlias, pFileID->dataLength)) != noErr)
		return(err);
	
	/* Distill a file spec out of the AliasHandle */
	err = ResolveAlias(nil, hAlias, &fileSpec, &aliasChanged);
	DisposHandle(hAlias);
	if (err != noErr)
		return(err);

	/* Return the file location info */
	pAppFile->vRefNum = 0;
	*pVol = fileSpec.vRefNum;
	*pDirID = fileSpec.parID;
	BlockMove(&(fileSpec.name), &(pAppFile->fName), Length(&(fileSpec.name))+1);
	
	/* Version is no longer used (it was an MFS concept), so zero it. */
	pAppFile->versNum = 0;

	/* Get the type. */
	fInfoRec.ioNamePtr = &(fileSpec.name);
	fInfoRec.ioVRefNum = fileSpec.vRefNum;
	fInfoRec.ioDirID = fileSpec.parID;
	fInfoRec.ioFDirIndex = 0;
	fInfoRec.ioCompletion = nil;
	if ((err = PBHGetFInfo(&fInfoRec, SyncHFS)) == noErr)
		pAppFile->fType = fInfoRec.ioFlFndrInfo.fdType;

	return(err);
	}
	
/* SendFileInstruction.  Sends a puppet string with a file spec to the given process.
 * The instruction must correspond to a menu command in the target app that causes that
 * app to bring up SFGetFile.  For example, instrOpen corresponds to the "File" menu 
 * "Open…" (et al) item, which typically causes the app to call SFGetFile.
 * NOTE: A file instruction can not be the last in the instruction list!  This is
 * because the puppet machinery shuts down when the last instruction is popped (in
 * GetNextPuppetEvent()), but a file instruction is not really finished until later.
 * The patch to SFGetFile (IsForcedOpen()) still needs to hand the file spec to the
 * application.  We tack on a nullEvent as an extra instruction to keep the list alive.
 */
OSErr
SendFileInstruction(short instruction, MFmsgBlkPtr msgBlk)
	{
	short					evtCount;
	Size					theLength;
	AETFDescriptor			*pAEFileSpec;
	EventListHdl			eventListH;
	EventListPtr			eventListP;
	EventRecord				*pEvent;
	OSErr					error;
		
	/* Do a little research */
	ExamineDocList((AETFHeader *) msgBlk->addrOfMsg, msgBlk->eppcMsgBlk.msgLength, &pAEFileSpec, &evtCount);
	if (evtCount == 0)
		return(fnfErr);
	
	/* Make a new event list handle big enough for the instructions */
	evtCount++;
	theLength = SIZEOF_EVENTLIST_HDR + (evtCount * sizeof(EventRecord));
	if ((eventListH = GMBlk(theLength, &error)) == nil)
		return(error);

	/* Adjust addrOfMsg to point to the first file to open */
	msgBlk->addrOfMsg = (Ptr) pAEFileSpec;
	
	/* Fill in the list header info */
	eventListP = *eventListH;
	eventListP->offset = SIZEOF_EVENTLIST_HDR;
	eventListP->count = evtCount;
	
	/* Fill in the file instruction(s) */
	pEvent = &(eventListP->events[0]);
	while(--evtCount)
		{
		pEvent->what = app4Evt;
		pEvent->message = (instruction << 24);
		pEvent++;
		}
	
	/* Fill in the place holder instruction, a null event */
	pEvent->what = nullEvent+evtIsUnimportant;

	/* Send the thing off */
	if ((error = SendInstructions(eventListH, msgBlk)) != noErr)
		DisposHandle(eventListH);
	
	return(error);
	}

/* TranslateAppleEvent.  See whether the high-level event is a translatable AppleEvent.
 * If so, try to convert it to puppet strings.  This routine is called when it appears
 * that the only connection problem is that the receiver is not capable of EPPC.  The
 * err parameter is the address of the OSErr that EPPC will return to the caller of
 * PostHighLevelEvent.  We return the result of the translation attempt there, unless
 * the event is not one that we like to translate (leaving it alone in that case lets 
 * the PostHighLevelEvent caller get the usual connection error provided by EPPC/PPC).
 */
void
TranslateAppleEvent(MFmsgBlkPtr msgBlk, OSErr *err)
	{
	PEntryPtr				pDestProc;
	HighLevelEventRecord	*pAEvent;
	u_long					theCommand;
	OSErr					sendError;
	
	/* Is this an AppleEvent? */
	pAEvent = (HighLevelEventRecord *) &(msgBlk->eppcMsgBlk.theMsgEvent);
	if (pAEvent->mClass != standardAppleEventMsgClass)
		return;
	
	/* Can't do it if we're switching (or planning on it). */
	if (coercionState != CS_DONE)
		{
		*err = protocolErr;
		return;
		}
	
	/* Can't do it if destination is not a process that can come to the foreground, or
	 * is the current process (requirements of puppet strings).
	 */
	pDestProc = PEntryFromPSN(&msgBlk->targetmfid.localPSN);
	assert(pDestProc != nil);
	if ( (pDestProc == nil) || ((pDestProc->p_taskmode & modeOnlyBackground) != 0) || (pDestProc == pCurrentProcess) )
		return;
	
	/* See if it's one of the translatable set */
	if ((theCommand = pAEvent->mID) == saeQuitMsgID)
		sendError = SendQuitInstruction(msgBlk);

	else
		{
		/* Look for an AppleEvent that has a file spec. */
		if ((theCommand == saeOpenDocumentMsgID))
			sendError = SendOpenInstruction(msgBlk);
		
		else return;
		}
	
	/* We get here only if we tried to load the puppet instructions.  SendError
	 * holds the result.  If it worked, send a return receipt.  Otherwise, dump
	 * the message buffer.
	 */
	if (sendError == noErr)
		{
		if ((msgBlk->eppcMsgBlk.postingOptions & nReturnReceipt) != 0)
			postReturnReceipt(msgBlk, true);
		}
	else
		RelMsgEventBuffer(msgBlk);
	
	*err = sendError;
	}

/* postTranslationResult.  Pass the word back to the process that sent an AppleEvent
 * needing translation, now that the result is known.  Performs any necessary cleanup.
 * NOTE: Ideally, we want this message to look like it came from the process, not the
 * system, because it is really the last step in acting like the destination was
 * EPPC-aware.  Currently, though, it is done in SystemMode because PPC toolbox
 * requires that the sender have a port.  Also, the "sender" may be dead at this point.
 */
void
postTranslationResult(MFmsgBlkPtr mfMsgBlk, OSErr theResult)
	{
	/* Send AppleEvent with result back to originator (frees message block) */
	postResult(mfMsgBlk, theResult, &pCurrentProcess->p_serialNumber);
	}

/*************************************************************************************
 * The following routines translate from an APPPARMHANDLE to an saeOpenDocumentMsgID/
 * saePrintDocumentMsgID AppleEvent, or vice versa.  This is necessary when a
 * non-AppleEvent application is launching one that is, or vice versa.  These are just
 * utility routines for other modules (like SegmentLoaderPatches.c) to call.
 ************************************************************************************/
	
/* AEParmToAppParmHandle.  Convert the given AppParameters from AppleEventness into an
 * equivalent AppParmRecHdl.  Also sets up the p_appWDList for later consumption by
 * OpenAppWDs.  Note that we provide a trivial AppParmRecHdl in the case that there is
 * no DocList.  This is to accommodate applications that assume APPPARMHANDLE != nil.
 * NOTE: This assumes that the DocList will not be moved by the heap calls we make.
 * Currently, this is met because we're allocating in the new app's heap, which didn't
 * exist when the DocList was made.
 * NOTE: Locking the AppParmHandle is done explicitly for MacWrite 4.5 (and 4.6?) and
 * should someday be removed.
 */
AppParmRecHdl
AEParmToAppParmHandle(AppParametersPtr pAEParm, PCB **hPCB)
	{
	u_long					theCommand;
	AETFDescriptor			*pFileID;
	short		 			parmCount;
	short					theInstruction;
	AppParmRec				**hAPH;
	AppFile					*pAppFile;
	AppWDRecPtr				pWDInfoRec;
	AppWDListHdl			hWDInfo;
#define SIZEOF_MINAPPFILE	(sizeof(AppFile) - (sizeof(Str255) - sizeof(Str63)))
	
	/* So error recovery works correctly */
	hAPH = nil;
	hWDInfo = nil;
	
	/* Anything at all? */
	if (pAEParm == nil)
		goto ErrorRecovery;
		
	/* Is the AppleEvent something we can translate? */
	theCommand = ((HighLevelEventRecord *) (&pAEParm->theMsgEvent))->mID;
	if ((theCommand == saeOpenDocumentMsgID) || (theCommand == saeLaunchedWithoutDocs))
		theInstruction = appOpen;
	else if (theCommand == saePrintDocumentMsgID)
		theInstruction = appPrint;
	else
		goto ErrorRecovery;
		
	/* Get address of first file spec and count of specs */
	parmCount = 0;
	if (theCommand != saeLaunchedWithoutDocs)
		ExamineDocList( (AETFHeader *) ((Ptr) pAEParm + sizeof(AppParameters)), pAEParm->messageLength, &pFileID, &parmCount);

	/* Create an AppParmRecHdl as a relocatable block. */
	if ( (hAPH = NewAppParmHandle(sizeof(AppParmRec) + (parmCount * SIZEOF_MINAPPFILE))) == nil )
		goto ErrorRecovery;
		
	/* Set up the headers (assume block was zeroed by NewAppParmHandle) */
	(*hAPH)->message = theInstruction;
	
	/* Dice and slice each parameter */
	if (parmCount != 0)
		{
		short			goodCount;
		
		/* Create the parallel WD structure */
		if ( (hWDInfo = (AppWDListHdl) NewHandleClear(sizeof(AppWDList) + (parmCount * sizeof(AppWDRec)))) == nil )
			goto ErrorRecovery;
	
		/* Now translate each entry.  Save WD info in parallel structure */
		HLock(hWDInfo);
		pAppFile = &((*hAPH)->appFiles[0]);
		pWDInfoRec = &((*hWDInfo)->wdlDirectories);
		goodCount = 0;
		do
			{
			OSErr		err;
			
			/* Translate this entry */
			if ((err = FileIDToAppFile(pFileID, pAppFile, &pWDInfoRec->awdVolume, &pWDInfoRec->awdDirID)) == noErr)
				{
				goodCount++;
				NextAppFile(&pAppFile);
				pWDInfoRec++;
				}

			/* Call it a list if the heap pooped out */
			else if (err == memFullErr)
				break;

			/* Move on */
			NextListParam(&pFileID);
			} while (--parmCount);
		
		HUnlock(hWDInfo);
		
		/* Did we wash out? */
		if (((*hWDInfo)->wdlCount = (*hAPH)->count = goodCount) == 0)
			goto ErrorRecovery;
		
		/* Trim AppParmHandle back to just the needed size.
		 * NOTE: Assumes this can be done with the handle locked.
		 */
		SetHandleSize(hAPH, (Ptr) pAppFile - (Ptr) *hAPH);
		assert(MEMERROR == noErr);
		}
	else
		hWDInfo = nil;
	
	/* Finally, the point of all this */
	(*hPCB)->p_appWDList = hWDInfo;
	return(hAPH);

	/* Error handling code conveniently all in one place */
ErrorRecovery:
	if (hAPH != nil)
		DisposHandle(hAPH);
	
	if (hWDInfo != nil)
		DisposHandle(hWDInfo);
	
	/* Try to return trivial AppParmRecHdl) */
	(*hPCB)->p_appWDList = nil;
	return(NewAppParmHandle(sizeof(AppParmRec)));
	}

/* AppParmHandleToAEParm.  Build an AppParameters structure equivalent of the specified
 * AppParmRecHdl.  If hAPH is nil or purged, or the count is 0, an saeLaunchedWithoutDocs
 * AppleEvent is sent so the new app knows there are no documents.
 * NOTE: Caller should make sure the current heap is set correctly!!
 */
Handle
AppParmHandleToAEParm(AppParmRecHdl hAPH)
	{
	short						parmCount, theInstruction;
	AppParametersPtr			pAEParm;
	long						theCommand;
	u_size						msgSize;
	AppParameters				**hAEParm;
	
	/* Figure out what the command is, how many files there are, and the initial message size */
	if ( (hAPH == nil) || (*hAPH == nil) || ((parmCount = (*hAPH)->count) == 0) )
		{
		theCommand = saeLaunchedWithoutDocs;
		msgSize = 0;
		parmCount = 0;
		}
	else
		{
		theInstruction = (*hAPH)->message;
		if (theInstruction == appOpen)
			theCommand = saeOpenDocumentMsgID;
		else if (theInstruction == appPrint)
			theCommand = saePrintDocumentMsgID;
		else
			return(nil);
	
		/* This will grow as we add AETFDescriptors */
		msgSize = sizeof(AppleEventDocMsg);
		}
		
	/* Try to allocate the required amount of memory from the current heap */
	if ((hAEParm = (AppParameters **) NewHandleClear(sizeof(AppParameters) + msgSize)) == nil)
		return(nil);
	
	/* Build the message */
	if (msgSize != 0)
		{
		unsigned long	currOffset;
		unsigned long	goodCount;
		
		/* Lay down the AETFDescriptors */
		goodCount = 0;
		currOffset = sizeof(AppParmRec);
		while (parmCount--)
			{
			if (AppFileAndDocList(hAPH, &currOffset, (Handle) hAEParm) == noErr)
				goodCount++;
			}
		
		/* Fill in the message, or switch to saeLaunchedWithoutDocs if nothing converted */
		if (goodCount != 0)
			{
			AppleEventDocMsg	*pMsg;
			AETFDescriptorList	*pListHdr;
			
			msgSize = GetHandleSize(hAEParm) - sizeof(AppParameters);
			pMsg = (AppleEventDocMsg *) ((Ptr) *hAEParm + sizeof(AppParameters));
			GenericAEMessage(&pMsg->messageHeader);
			pMsg->metaDataMark = aeEndOfMetaDataKeyword;
			SetAEParmHeader((AETFParameter *) &pMsg->listParam, aeDirectObjectKeyword, aeListParamType, msgSize - sizeof(AppleEventDocMsg) + LISTEXTRA);
			pListHdr = &(pMsg->listParam.list);
			pListHdr->count = goodCount;
			pListHdr->hdrLength = 0;
			}
		else
			{
			theCommand = saeLaunchedWithoutDocs;
			msgSize = 0;
			}
		}

	/* Set the message size */
	pAEParm = *hAEParm;
	pAEParm->messageLength = msgSize;
		
	/* Fill in the HighLevelEventRecord */
	SetAppleEvent(theCommand, (HighLevelEventRecord *) &pAEParm->theMsgEvent);

	/* Return what we have made */
	return(hAEParm);
	}

/*************************************************************************************
 * The following routines implement the system AppleEvents.  We support is aeQuitAll,
 * aeCreatorType, aeRestart, and aeShutDown.  We do the aeQuitAll ourselves.  The
 * others we pass on to Finder.
 ************************************************************************************/

/* SendSystemQuit.  Utility subroutine to send aeQuit to specified process, based on
 * pSystemQuitAllMsg.
 * NOTE: This uses the refcon from the original aeQuitAll high-level event.  That way,
 * the target will naturally echo the proper refcon in its response.  If you decide to
 * use a different refcon, you have to be sure to restore it in any messages passed
 * through to the aeQuitAll initiator from a target (e.g. in HandleFeedback).
 */
OSErr
SendSystemQuit(PEntryPtr pDest)
	{
	OSErr					result;
	MFmsgBlkPtr				pMsgBlk;
	HighLevelEventRecord	theEvent;

	pMsgBlk = pSystemQuitAllMsg;
	pMsgBlk->targetmfid.localPSN = pDest->p_serialNumber;

	SetAppleEvent(saeQuitMsgID, &theEvent);

	(void) BeginSystemMode();
	result = PostHighLevelEvent((EventRecord *) &theEvent, (u_long) &pDest->p_serialNumber, pMsgBlk->eppcMsgBlk.userRefcon, pMsgBlk->addrOfMsg, pMsgBlk->eppcMsgBlk.msgLength, receiverIDisPSN);
	(void) EndSystemMode();
	if (result == noErr)
		(void) SetFrontProcess(&pDest->p_serialNumber);

	return(result);
	}

/* ContinueQuitAll.  Initiate or continue the shutting down of processes.  Sends a
 * Quit AppleEvent to the next eligible process.  Does all foreground processes
 * except Finder before starting in on the background ones (because if the user
 * cancels, it will be easier for him to restart just the foreground apps).
 * We want the Quit messages to look like they came from the system, so any result
 * messages can be ignored.
 */
void
ContinueQuitAll(void)
	{
	PEntryPtr		pProc, pKillerProc;
	LayerPtr		pLayer;
	MFmsgBlkPtr		pMsgBlk;

	assert(pSystemQuitAllMsg != nil)
	
	/* Cache some costly info.  Also, we want pMsgBlk to be valid even after we
	 * MUST nil the pSystemQuitAllMsg global.
	 */
	pMsgBlk = pSystemQuitAllMsg;
	pKillerProc = PEntryFromPSN(&(pMsgBlk->sendermfid.localPSN));
	assert(pKillerProc != nil);
	
	/* Look for foreground job to wipe */
	pProc = pFrontProcess;
	for (;;)
		{	
		/* OK to do right now if pProc is neither killer nor the Finder. */
		if ((pProc != pKillerProc) && (pProc != pShellProcess))
			{
			(void) SendSystemQuit(pProc);
			return;
			}
		
		/* Try to get next layer down.  Exit if we hit bottom. */
		if ((pLayer = LGetNextLayer(pProc->p_layer, false)) == nil)
			break;
		
		pProc = LayerOwner(pLayer);
		}
 	
	/* Foregrounders are gone, now try the background */
	pProc = pProcessList;
	while (pProc != nil)
		{
		if ( (pProc->p_state != PRNULL)
			&& (pProc != pKillerProc)
			&& (pProc != pShellProcess) )
			{
			assert((pProc->p_taskmode & modeOnlyBackground) != 0);
			if (SendSystemQuit(pProc) == noErr)
				return;
			pProc->p_state = PRNULL;
			}
			
		pProc = pProc->p_NextProcess;
		}
	
	/* Now do Finder, if he's not the one that started this whole thing */
	if ((pShellProcess != pKillerProc) && (pShellProcess != nil))
		{
		(void) SendSystemQuit(pShellProcess);
		return;
		}

	/* Everyone's gone!  Tell grim reaper the good news.  We want this message
	 * to look like it came from the system.
	 */
	assert(pMsgBlk == pSystemQuitAllMsg);
	pSystemQuitAllMsg = nil;
	postResult(pMsgBlk, noErr, nil);
	}

/* CancelQuitAll.  Cancel the system quit initiated by an application.  This is called
 * when either a) the intended victim sent a refusal, b) a high-level switch out of an
 * intended victim is occurring, or c) when the initiator himself has died.  We don't
 * have to worry about reviving background jobs, since they are not frozen until after
 * all foreground jobs have quit.
 * If an intendedVictim is specified, the QuitAll is being cancelled by a switch
 * (case b), and we need to send the result message to the originator.  We want this
 * message to look like it came from the system.  In the other cases a message is not
 * necessary: in case (a) the refusnik's message has already been relayed; in case (c)
 * the originator is too dead to care.
 */
void
CancelQuitAll(ProcessSerialNumberPtr intendedVictim)
	{
	MFmsgBlkPtr		msgBlk;

	msgBlk = pSystemQuitAllMsg;
	pSystemQuitAllMsg = nil;
	
	/* Send result only if caller wanted us to */
	if (intendedVictim == nil)
		RelMsgEventBuffer(msgBlk);
	else
		postResult(msgBlk, userCanceledErr, intendedVictim);
	}

/* HandleSystemQuit.  Make all applications other than the current one quit or go idle.
 * This puts the system in a quiescent state, useful prior to shutdown or major surgery.
 */
OSErr
HandleSystemQuit(MFmsgBlkPtr msgBlk)
	{
	/* make sure there will still be a user interface when all is done */
	if ((pCurrentProcess->p_taskmode & modeOnlyBackground) != 0)
		return(appIsDaemon);
		
	/* make sure no one else is shutting down already */
	if (pSystemQuitAllMsg != nil)
		return(tooManyReqs);
	
	/* set the scythe to swingin' */
	pSystemQuitAllMsg = msgBlk;
	ContinueQuitAll();
	return(noErr);
	}

/* AnswerWasFromQuitAll.  Determine whether the specified message is a reply from the
 * most recently targeted process in a QuitAll.  Mostly, allow for the message to
 * have been sent in system mode, since we PostResult does that.
 */
Boolean
AnswerWasFromQuitAll(register MFmsgBlkPtr pMsgBlk)
	{
	AETFParameter	*pParm;
	
	/* Check whether there is even a quitall in progress */
	if (pSystemQuitAllMsg == nil)
		return(false);
		
	/* We know right away if the sender has the same PSN as the most recent intended victim */
	if (EqualPSN(&pSystemQuitAllMsg->targetmfid.localPSN, &pMsgBlk->sendermfid.localPSN))
		return(true);
	
	/* The only other possibility is that we are seeing our own result message for the
	 * quit event we translated during a quitall.  In this case, the result message will
	 * contain the ProcessSerialNumber of the application that was being translated for.
	 */
	if (EqualPSNConst(kSystemProcess, &pMsgBlk->sendermfid.localPSN))
		{
		pParm = FindKeywordParameter((AETFHeader *) pMsgBlk->addrOfMsg, pMsgBlk->eppcMsgBlk.msgLength, aeProcessKeyword);
		if ( (pParm != nil)
			&& (pParm->descriptor.dataType == aeProcessParamType)
			&& (EqualPSN((ProcessSerialNumber *) ((Ptr) pParm + sizeof(AETFParameter)), &pSystemQuitAllMsg->targetmfid.localPSN)) )		
			return(true);
		}

	return(false);
	}

/* HandleFeedback.  Deal with a message returned by a previous destination.  The only
 * responses we care about are negative ones from intended victims of saeQuitMsgID
 * (we cancel the aeQuitAll).
 */
OSErr
HandleFeedback(MFmsgBlkPtr pMsgBlk)
	{
	AETFParameter	*pParm;
	PEntryPtr		pDestProc;

	/* Is there a QuitAll in progress? */
	if (AnswerWasFromQuitAll(pMsgBlk))
		{
		/* Cancel the QuitAll if the process is refusing to die. */
		pParm = FindKeywordParameter((AETFHeader *) pMsgBlk->addrOfMsg, pMsgBlk->eppcMsgBlk.msgLength, keyErrorNumber);
		if ( (pParm != nil)
			&& (pParm->descriptor.dataType == aeLongintParamType)
			&& ((*(long *) ((Ptr) pParm + sizeof(AETFParameter))) != noErr) )
			{
			/* Make Installer 3.1 work.  That product was shipped before 7.0 went final, but
			 * relied on 7.0 features such as AppleEvents.  In the mean time, some four-letter
			 * codes changed, including the keyword for params holding an OSErr, and the
			 * keyword and type for params holding a ProcessSerialNumber.
			 */
			if (((pDestProc = PEntryFromPSN(&pSystemQuitAllMsg->sendermfid.localPSN)) != nil) &&
				(pDestProc->p_signature == 'cfbj'))
				{
				/* Convert (only?) keyErrorNumber parameter keyword to 'errv' */
				pParm->key = 'errv';

				/* Convert (only?) aeProcessKeyword parameter keyword and type to 'proc' */
				pParm = FindKeywordParameter((AETFHeader *) pMsgBlk->addrOfMsg, pMsgBlk->eppcMsgBlk.msgLength, aeProcessKeyword);
				if (pParm != nil)
					{
					pParm->key = 'proc';
					if (pParm->descriptor.dataType == aeProcessKeyword)
						pParm->descriptor.dataType = 'proc';
					}
				}
				
			pMsgBlk->targetmfid.localPSN = pSystemQuitAllMsg->sendermfid.localPSN;
			postMsg(pMsgBlk);
			CancelQuitAll(nil);
			return(noErr);
			}
		}

	RelMsgEventBuffer(pMsgBlk);
	return(noErr);
	}

/* HandleSystemMessage.  Handle a message ostensibly addressed to "the system".
 * If we implement the message, do it.  Otherwise, return an unimpErr so callers
 * from the future know where we stand.
 * NOTE: We just pass aeCreatorType, aeRestart, and aeShutDown straight on to Finder,
 * but having programmers address it to us (rather than Finder) gives us the option of
 * doing something meaningful in the future.
 */
void
HandleSystemMessage(MFmsgBlkPtr pMsgBlk, OSErr *err)
	{
	HighLevelEventRecord	*pAEvent;
	u_long					theCommand;
	OSErr					resultVal;
	
	/* Is this an AppleEvent? */
	resultVal = unimpErr;
	pAEvent = (HighLevelEventRecord *) &(pMsgBlk->eppcMsgBlk.theMsgEvent);
	if (pAEvent->mClass == standardAppleEventMsgClass)
		{
		theCommand = pAEvent->mID;
		
		/* A dose of morphine, perhaps? */
		if (theCommand == aeQuitAll)
			{
			resultVal = HandleSystemQuit(pMsgBlk);
			}
		
		/* Response to a message we sent earlier? */
		else if (theCommand == saeAnswer)
				{
				resultVal = HandleFeedback(pMsgBlk);
				}
		
		/* Look for events handled by Finder */
		else if ( (theCommand == aeCreatorType) ||
					(theCommand == aeRestart) ||
					(theCommand == aeShutDown) )
				{
				if ((pShellProcess != nil) && (pShellProcess != ((Ptr) -1)) && (ShellWasFinderType))
					{
					pMsgBlk->targetmfid.localPSN = pShellProcess->p_serialNumber;
					pAEvent->mClass = FINDERS_TYPE;
					postMsg(pMsgBlk);
					*err = noErr;
					return;
					}
				}
		}

	/* If we were able to do anything, send a return receipt. */
	if (resultVal == noErr)
		{
		if ((pMsgBlk->eppcMsgBlk.postingOptions & nReturnReceipt) != 0)
			postReturnReceipt(pMsgBlk, true);
		}
	
	*err = resultVal;
	}

/* postResult.  Send OSErr back to sender of given message, and free the message. */
void
postResult(MFmsgBlkPtr mfMsgBlk, OSErr theResult, ProcessSerialNumberPtr pIntendedPSN)
	{
	HighLevelEventRecord	theEvent;
	unsigned long			msgRefcon;
	ProcessSerialNumber		receiverID;
	PEntryPtr				pDestProc;
	unsigned long			errorKeyword, processKeyword, processType;
	MyAppleEventReply		mBuff;
	
	/* Prepare the parameters for send (before freeing buffer!) */
	receiverID = mfMsgBlk->sendermfid.localPSN;
	msgRefcon = mfMsgBlk->eppcMsgBlk.userRefcon;

	/* Fill in the high-level event record */
	SetAppleEvent(saeAnswer, &theEvent);
	
	/* Fill in the message. */
	GenericAEMessage(&mBuff.basicReply.messageHeader);
	mBuff.basicReply.metaDataMark = aeEndOfMetaDataKeyword;
			
	/* Make Installer 3.1 work.  That product was shipped before 7.0 went final, but
	 * relied on 7.0 features such as AppleEvents.  In the mean time, some four-letter
	 * codes changed, including the keyword for params holding an OSErr, and the
	 * keyword and type for params holding a ProcessSerialNumber.
	 */
	errorKeyword = keyErrorNumber;
	processKeyword = aeProcessKeyword;
	processType = aeProcessParamType;
	if (((pDestProc = PEntryFromPSN(&receiverID)) != nil) &&
		(pDestProc->p_signature == 'cfbj'))
		{
		errorKeyword = 'errv';
		processKeyword = 'proc';
		processType = 'proc';
		}

	SetAEParmHeader(&mBuff.basicReply.errorCodeHdr, errorKeyword, aeLongintParamType, sizeof(long));
	mBuff.basicReply.errorValue = (long) theResult;
	SetAEParmHeader(&mBuff.processHdr, processKeyword, processType, sizeof(ProcessSerialNumber));
	if (pIntendedPSN != nil)
		mBuff.process = *pIntendedPSN;
	else
		SetPSN(kNoProcess, &mBuff.process);
	
	/* Release the buffer (to free some memory before the send), and send the EPPC. */
	RelMsgEventBuffer(mfMsgBlk);
	(void) BeginSystemMode();
	(void) PostHighLevelEvent((EventRecord *) &theEvent, (unsigned long) &receiverID, msgRefcon, &mBuff, sizeof(MyAppleEventReply), receiverIDisPSN);
	(void) EndSystemMode();
	}