/*

	File:		CFMLateImport.c

	Contains:	Implementation of CFM late import library.

	Written by:	Quinn

	Copyright:	Copyright © 1999 by Apple Computer, Inc., all rights reserved.

				You may incorporate this Apple sample source code into your program(s) without

				restriction. This Apple sample source code has been provided "AS IS" and the

				responsibility for its operation is yours. You are not permitted to redistribute

				this Apple sample source code as "Apple sample source code" after having made

				changes. If you're going to re-distribute the source, we require that you make

				it clear in the source that the code was descended from Apple sample source

				code, but that you've made changes.

	Change History (most recent first):

        <13>     24/9/01    Quinn   Fixes to compile with C++ activated.

        <12>     21/9/01    Quinn   [2710489] Fix typo in the comments for FragmentLookup.

        <11>     21/9/01    Quinn   Changes for CWPro7 Mach-O build.

        <10>     19/9/01    Quinn   Corrected implementation of kPEFRelocSmBySection. Added

                                    implementations of kPEFRelocSetPosition and kPEFRelocLgByImport

                                    (from code contributed by Eric Grant, Ned Holbrook, and Steve

                                    Kalkwarf), although I can't test them yet.

         <9>     19/9/01    Quinn   We now handle unpacked data sections, courtesy of some code from

                                    Ned Holbrook.

         <8>     19/9/01    Quinn   Minor fixes for the previous checkin. Updated some comments and

                                    killed some dead code.

         <7>     19/9/01    Quinn   Simplified API and implementation after a suggestion by Eric

                                    Grant. You no longer have to CFM export a dummy function; you

                                    can just pass in the address of your fragment's init routine.

         <6>     15/2/01    Quinn   Modify compile-time warnings to complain if you try to build

                                    this module into a Mach-O binary.

         <5>      5/2/01    Quinn   Removed redundant assignment in CFMLateImportCore.

         <4>    30/11/00    Quinn   Added comment about future of data symbols in CF.

         <3>    16/11/00    Quinn   Allow symbol finding via a callback and use that to implement

                                    CFBundle support.

         <2>    18/10/99    Quinn   Renamed CFMLateImport to CFMLateImportLibrary to allow for

                                    possible future API expansion.

         <1>     15/6/99    Quinn   First checked in.

*/

// To Do List:

//

// o get rid of dependence on ANSI "string.h", but how?

//

// Done:

//

// Ã investigate alternative APIs, like an external lookup routine

//   renamed CFMLateImport to CFMLateImportLibrary to allow for

//   future expansion of the APIs for things like CFMLateImportSymbol

// Ã test with non-zero fragment offset in the file

// Ã test more with MPW fragments

// Ã test data imports

/////////////////////////////////////////////////////////////////

// MoreIsBetter Setup

//#include "MoreSetup.h"

#define MoreAssert(x) (true)

#define MoreAssertQ(x)

// Mac OS Interfaces

#if ! MORE_FRAMEWORK_INCLUDES

	#include <CodeFragments.h>

	#include <PEFBinaryFormat.h>

#endif

// Standard C Interfaces

#include <string.h>

// MIB Prototypes

//#include "MoreInterfaceLib.h"

#define MoreBlockZero BlockZero

// Our Prototypes

#include "CFMLateImport.h"

/////////////////////////////////////////////////////////////////

#if TARGET_RT_MAC_MACHO

	#error CFMLateImport is not suitable for use in a Mach-O project.

#elif !TARGET_RT_MAC_CFM || !TARGET_CPU_PPC

	#error CFMLateImport has not been qualified for 68K or CFM-68K use.

#endif

/////////////////////////////////////////////////////////////////

#pragma mark ----- Utility Routines -----

static OSStatus FSReadAtOffset(SInt16 refNum, SInt32 offset, SInt32 count, void *buffer)

	// A convenient wrapper around PBRead which has two advantages

	// over FSRead.  First, it takes count as a value parameter.

	// Second, it reads from an arbitrary offset into the file,

	// which avoids a bunch of SetFPos calls.

	//

	// I guess this should go into "MoreFiles.h", but I'm not sure

	// how we're going to integrate such a concept into MIB yet.

{

	ParamBlockRec pb;

	pb.ioParam.ioRefNum     = refNum;

	pb.ioParam.ioBuffer     = (Ptr) buffer;

	pb.ioParam.ioReqCount   = count;

	pb.ioParam.ioPosMode    = fsFromStart;

	pb.ioParam.ioPosOffset  = offset;

	return PBReadSync(&pb);

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- Late Import Engine -----

// This structure represents the core data structure of the late import

// engine.  It basically holds information about the fragment we're going

// to fix up.  It starts off with the first three fields, which are

// provided by the client.  Then, as we procede through the operation,

// we fill out more fields.

struct FragToFixInfo {

	CFragSystem7DiskFlatLocator	locator;				// How to find the fragment's container.

	CFragConnectionID 			connID;					// CFM connection to the fragment.

	CFragInitFunction 			initRoutine;			// The CFM init routine for the fragment.

	PEFContainerHeader 			containerHeader;		// The CFM header, read in from the container.

	PEFSectionHeader			*sectionHeaders;		// The CFM section headers.  A pointer block containing an array of containerHeader.sectionCount elements.

	PEFLoaderInfoHeader			*loaderSection;			// The entire CFM loader section in a pointer block.

	SInt16						fileRef;				// A read-only path to the CFM container.  We keep this here because one that one routine needs to read from the container.

	void 						*section0Base;			// The base address of section 0, which we go through hoops to calculate.

	void 						*section1Base;			// The base address of section 1, which we go through hoops to calculate.

	Boolean						disposeSectionPointers;	// See below.

};

typedef struct FragToFixInfo FragToFixInfo;

// The disposeSectionPointers Boolean is designed for future cool VM

// support.  If VM is on, the entire code fragment is file mapped into

// high memory, including the data we're forced to allocate the

// sectionHeaders and loaderSection memory blocks to maintain.  If

// we could find the address of the entire file mapped container,

// we could access the information directly from there and thus

// we wouldn't need to allocate (or dispose of) the memory blocks

// for sectionHeaders and loaderSection.

//

// I haven't implemented this yet because a) I'm not sure how to do

// it with documented APIs, and b) I couldn't be bothered, but

// disposeSectionPointers remains as vestigial support for the concept.

static OSStatus ReadContainerBasics(FragToFixInfo *fragToFix)

	// Reads some basic information from the container of the

	// fragment to fix and stores it in various fields of

	// fragToFix.  This includes:

	//

	// o containerHeader -- The contain header itself.

	// o sectionHeaders  -- The array of section headers (in a newly allocated pointer block).

	// o loaderSection   -- The entire loader section (in a newly allocated pointer block).

	//

	// Also sets disposeSectionPointers to indicate whether

	// the last two pointers should be disposed of.

	//

	// Finally, it leaves the container file open for later

	// folks who want to read data from it.

{

	OSStatus 	err;

	UInt16 		sectionIndex;

	Boolean 	found;

	MoreAssertQ(fragToFix != nil);

	MoreAssertQ(fragToFix->locator.fileSpec != nil);

	MoreAssertQ(fragToFix->connID != nil);

	MoreAssertQ(fragToFix->loaderSection == nil);

	MoreAssertQ(fragToFix->sectionHeaders == nil);

	MoreAssertQ(fragToFix->fileRef == 0);

	fragToFix->disposeSectionPointers = true;

	// Open up the file, read the container head, then read in

	// all the section headers, then go looking through the

	// section headers for the loader section (PEF defines

	// that there can be only one).

	err = FSpOpenDF(fragToFix->locator.fileSpec, fsRdPerm, &fragToFix->fileRef);

	if (err == noErr) {

		err = FSReadAtOffset(fragToFix->fileRef,

								fragToFix->locator.offset,

								sizeof(fragToFix->containerHeader),

								&fragToFix->containerHeader);

		if (err == noErr) {

			if (   fragToFix->containerHeader.tag1 != kPEFTag1

				|| fragToFix->containerHeader.tag2 != kPEFTag2

				|| fragToFix->containerHeader.architecture != kCompiledCFragArch

				|| fragToFix->containerHeader.formatVersion != kPEFVersion) {

				err = cfragFragmentFormatErr;

			}

		}

		if (err == noErr) {

			fragToFix->sectionHeaders = (PEFSectionHeader *) NewPtr(fragToFix->containerHeader.sectionCount * sizeof(PEFSectionHeader));

			err = MemError();

		}

		if (err == noErr) {

			err = FSReadAtOffset(fragToFix->fileRef,

									fragToFix->locator.offset + sizeof(fragToFix->containerHeader),

									fragToFix->containerHeader.sectionCount * sizeof(PEFSectionHeader), 

									fragToFix->sectionHeaders);

		}

		if (err == noErr) {

			sectionIndex = 0;

			found = false;

			while ( sectionIndex < fragToFix->containerHeader.sectionCount && ! found ) {

				found = (fragToFix->sectionHeaders[sectionIndex].sectionKind == kPEFLoaderSection);

				if ( ! found ) {

					sectionIndex += 1;

				}

			}

		}

		if (err == noErr && ! found) {

			err = cfragNoSectionErr;

		}

		// Now read allocate a pointer block and read the loader section into it.

		if (err == noErr) {

			fragToFix->loaderSection = (PEFLoaderInfoHeader *) NewPtr(fragToFix->sectionHeaders[sectionIndex].containerLength);

			err = MemError();

		}

		if (err == noErr) {

			err = FSReadAtOffset(fragToFix->fileRef, 

									fragToFix->locator.offset + fragToFix->sectionHeaders[sectionIndex].containerOffset,

									fragToFix->sectionHeaders[sectionIndex].containerLength, 

									fragToFix->loaderSection);

		}				

	}

	// No clean up.  The client must init fragToFix to zeros and then

	// clean up regardless of whether we return an error.

	return err;

}

static UInt32 DecodeVCountValue(const UInt8 *start, UInt32 *outCount)

	// Given a pointer to the start of a variable length PEF value, 

	// work out the value (in *outCount).  Returns the number of bytes 

	// consumed by the value.

{

	UInt8 *			bytePtr;

	UInt8			byte;

	UInt32			count;

	bytePtr = (UInt8 *)start;

	// Code taken from "PEFBinaryFormat.h".

	count = 0;

	do {

		byte = *bytePtr++;

		count = (count << kPEFPkDataVCountShift) | (byte & kPEFPkDataVCountMask);

	} while ((byte & kPEFPkDataVCountEndMask) != 0);

	*outCount = count;

	return bytePtr - start;

}

static UInt32 DecodeInstrCountValue(const UInt8 *inOpStart, UInt32 *outCount)

	// Given a pointer to the start of an opcode (inOpStart), work out the 

	// count argument for that opcode (*outCount).  Returns the number of 

	// bytes consumed by the opcode and count combination.

{

	MoreAssertQ(inOpStart != nil);

	MoreAssertQ(outCount  != nil);

	if (PEFPkDataCount5(*inOpStart) != 0)

	{

		// Simple case, count encoded in opcode.

		*outCount = PEFPkDataCount5(*inOpStart);

		return 1;

	}

	else

	{

		// Variable-length case.

		return 1 + DecodeVCountValue(inOpStart + 1, outCount);

	}

}

static OSStatus UnpackPEFDataSection(const UInt8 * const packedData,   UInt32 packedSize,

								           UInt8 * const unpackedData, UInt32 unpackedSize)

{

	OSErr			err;

	UInt32			offset;

	UInt8			opCode;

	UInt8 *			unpackCursor;

	MoreAssertQ(packedData != nil);

	MoreAssertQ(unpackedData != nil);

	MoreAssertQ(unpackedSize >= packedSize);

	// The following asserts assume that the client allocated the memory with NewPtr, 

	// which may not always be true.  However, the asserts' value in preventing accidental 

	// memory block overruns outweighs the possible maintenance effort.

	MoreAssertQ( packedSize   == GetPtrSize( (Ptr) packedData  ) );

	MoreAssertQ( unpackedSize == GetPtrSize( (Ptr) unpackedData) );

	err          = noErr;

	offset       = 0;

	unpackCursor = unpackedData;

	while (offset < packedSize) {

		MoreAssertQ(unpackCursor < &unpackedData[unpackedSize]);

		opCode = packedData[offset];

		switch (PEFPkDataOpcode(opCode)) {

			case kPEFPkDataZero:

				{

					UInt32	count;

					offset += DecodeInstrCountValue(&packedData[offset], &count);

					MoreBlockZero(unpackCursor, count);

					unpackCursor += count;

				}

				break;

			case kPEFPkDataBlock:

				{

					UInt32	blockSize;

					offset += DecodeInstrCountValue(&packedData[offset], &blockSize);

					BlockMoveData(&packedData[offset], unpackCursor, blockSize);

					unpackCursor += blockSize;

					offset += blockSize;

				}

				break;

			case kPEFPkDataRepeat:

				{

					UInt32	blockSize;

					UInt32	repeatCount;

					UInt32  loopCounter;

					offset += DecodeInstrCountValue(&packedData[offset], &blockSize);

					offset += DecodeVCountValue(&packedData[offset], &repeatCount);

					repeatCount += 1;	// stored value is (repeatCount - 1)

					for (loopCounter = 0; loopCounter < repeatCount; loopCounter++) {

						BlockMoveData(&packedData[offset], unpackCursor, blockSize);

						unpackCursor += blockSize;

					}

					offset += blockSize;

				}

				break;

			case kPEFPkDataRepeatBlock:

				{

					UInt32	commonSize;

					UInt32	customSize;

					UInt32	repeatCount;

					const UInt8 *commonData;

					const UInt8 *customData;

					UInt32 loopCounter;

					offset += DecodeInstrCountValue(&packedData[offset], &commonSize);

					offset += DecodeVCountValue(&packedData[offset], &customSize);

					offset += DecodeVCountValue(&packedData[offset], &repeatCount);

					commonData = &packedData[offset];

					customData = &packedData[offset + commonSize];

					for (loopCounter = 0; loopCounter < repeatCount; loopCounter++) {

						BlockMoveData(commonData, unpackCursor, commonSize);

						unpackCursor += commonSize;

						BlockMoveData(customData, unpackCursor, customSize);

						unpackCursor += customSize;

						customData += customSize;

					}

					BlockMoveData(commonData, unpackCursor, commonSize);

					unpackCursor += commonSize;

					offset += (repeatCount * (commonSize + customSize)) + commonSize;

				}

				break;

			case kPEFPkDataRepeatZero:

				{

					UInt32	commonSize;

					UInt32	customSize;

					UInt32	repeatCount;

					const UInt8 *customData;

					UInt32 loopCounter;

					offset += DecodeInstrCountValue(&packedData[offset], &commonSize);

					offset += DecodeVCountValue(&packedData[offset], &customSize);

					offset += DecodeVCountValue(&packedData[offset], &repeatCount);

					customData = &packedData[offset];

					for (loopCounter = 0; loopCounter < repeatCount; loopCounter++) {

						MoreBlockZero(unpackCursor, commonSize);

						unpackCursor += commonSize;

						BlockMoveData(customData, unpackCursor, customSize);

						unpackCursor += customSize;

						customData += customSize;

					}

					MoreBlockZero(unpackCursor, commonSize);

					unpackCursor += commonSize;

					offset += repeatCount * customSize;

				}

				break;

			default:

				#if MORE_DEBUG

					DebugStr("\pUnpackPEFDataSection: Unexpected data opcode");

				#endif

				err = cfragFragmentCorruptErr;

				goto leaveNow;

				break;

		}

	}

leaveNow:

	return err;

}

/*	SetupSectionBaseAddresses Rationale

	-----------------------------------

	OK, here's where things get weird.  In order to run the relocation

	engine, I need to be able to find the base address of an instantiated

	section of the fragment we're fixing up given only its section number.

	This isn't hard for CFM to do because it's the one that instantiated the

	sections in the first place.  It's surprisingly difficult to do if

	you're not CFM.  [And you don't have access to the private CFM APis for 

	doing it.]

	[Alan Lillich is going to kill me when he reads this!  I should point out

	 that TVector's don't have to contain two words, they can be longer,

	 and that the second word isn't necessarily a TOC pointer, it's

	 just that the calling conventions require that it be put in the

	 TOC register when the code is called.

	 Furthermore, the code section isn't always section 0, and the data

	 section isn't always section 1, and there can be zero to many sections

	 of each type.

	 But these niceties are besides the point: I'm doing something tricky 

	 because I don't have a nice API for getting section base addresses.  

	 If I had a nice API for doing that, none of this code would exist.

	]

	The technique is very sneaky (thanks to Eric Grant).  The fragment to 

	fix necessarily has a CFM init routine (because it needs that routine 

	in order to capture the fragment location and connection ID).  Thus the 

	fragment to fix must have a TVector in its data section.  TVectors are 

	interesting because they're made up of two words.  The first is a pointer 

	to the code that implements the routine; the second is a pointer to the TOC

	for the fragment that's exporting the TVector.  How TVectors are

	created is interesting too.  On disk, a TVector consists of two words,

	the first being the offset from the start of the code section to the

	routine, the second being the offset from the start of the data section

	to the TOC base.  When CFM prepares a TVector, it applies the following

	transform:

		tvector.codePtr = tvector.codeOffset + base of code section

		tvector.tocPtr  = tvector.tocOffset  + base of data section

	Now, you can reverse these questions to make them:

		base of code section = tvector.codePtr - tvector.codeOffset

		base of data section = tvector.dataPtr - tvector.dataOffset

	So if you can find the relocated contents of the TVector and

	find the original offsets that made up the TVector, you can then

	calculate the base address of both the code and data sections.

	Finding the relocated contents of the TVector is easy; I simply 

	require the client to pass in a pointer to its init routine. 

	A routine pointer is a TVector pointer, so you can just cast it 

	and extract the pair of words.

	Finding the original offsets is a trickier.  My technique is to

	look up the init routine in the fragment's loader info header.  This

	yields the section number and offset where the init routine's unrelocated 

	TVector exists.  Once I have that, I can just read the unrelocated TVector

	out of the file and extract the offsets.

*/

struct TVector {

	void *codePtr;

	void *tocPtr;

};

typedef struct TVector TVector;

static OSStatus SetupSectionBaseAddresses(FragToFixInfo *fragToFix)

	// This routine initialises the section0Base and section1Base

	// base fields of fragToFix to the base addresses of the

	// instantiated fragment represented by the other fields

	// of fragToFix.  The process works in three states:

	//

	// 1. 	Find the contents of the relocated TVector of the 

	//      fragment's initialisation routine, provided to us by 

	//      the caller.

	//

	// 2.	Find the contents of the non-relocated TVector by 

	//      looking it up in the PEF loader info header and then 

	//      using that to read the TVector contents from disk.

	//      This yields the offsets from the section bases for 

	//      the init routine.

	//

	// 3.	Subtract 2 from 3.

{

	OSStatus 			err;

	TVector *			relocatedExport;

	SInt32				initSection;

	UInt32				initOffset;

	PEFSectionHeader *	initSectionHeader;

	Ptr					packedDataSection;

	Ptr					unpackedDataSection;

	TVector 			originalOffsets;

	packedDataSection   = nil;

	unpackedDataSection = nil;

	// Step 1.

	// First find the init routine's TVector, which gives us the relocated 

	// offsets of the init routine into the data and code sections.