/*

 * tclLoadDyld.c --

 *

 *	This procedure provides a version of the TclLoadFile that works with

 *	Apple's dyld dynamic loading.

 *	Original version of his file (now superseded long ago) provided by

 *	Wilfredo Sanchez (wsanchez@apple.com).

 *

 * Copyright (c) 1995 Apple Computer, Inc.

 * Copyright (c) 2001-2007 Daniel A. Steffen <das@users.sourceforge.net>

 *

 * See the file "license.terms" for information on usage and redistribution of

 * this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclLoadDyld.c,v 1.14.2.9 2007/04/29 02:20:16 das Exp $

 */

#include "tclInt.h"

#include "tclPort.h"

#include <mach-o/dyld.h>

#include <mach-o/fat.h>

#include <mach-o/swap.h>

#include <mach-o/arch.h>

#include <libkern/OSByteOrder.h>

#undef panic

#include <mach/mach.h>

#ifndef MODULE_SCOPE

#define MODULE_SCOPE extern

#endif

typedef struct Tcl_DyldModuleHandle {

    struct Tcl_DyldModuleHandle *nextPtr;

    NSModule module;

} Tcl_DyldModuleHandle;

typedef struct Tcl_DyldLoadHandle {

    CONST struct mach_header *dyldLibHeader;

    Tcl_DyldModuleHandle *modulePtr;

} Tcl_DyldLoadHandle;

#ifdef TCL_LOAD_FROM_MEMORY

MODULE_SCOPE long tclMacOSXDarwinRelease;

#endif

/*

 *----------------------------------------------------------------------

 *

 * DyldOFIErrorMsg --

 *

 *	Converts a numerical NSObjectFileImage error into an error message

 *	string.

 *

 * Results:

 *	Error message string.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

static CONST char*

DyldOFIErrorMsg(

    int err)

{

    switch(err) {

    case NSObjectFileImageSuccess:

	return NULL;

    case NSObjectFileImageFailure:

	return "object file setup failure";

    case NSObjectFileImageInappropriateFile:

	return "not a Mach-O MH_BUNDLE file";

    case NSObjectFileImageArch:

	return "no object for this architecture";

    case NSObjectFileImageFormat:

	return "bad object file format";

    case NSObjectFileImageAccess:

	return "can't read object file";

    default:

	return "unknown error";

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclpDlopen --

 *

 *	Dynamically loads a binary code file into memory and returns a handle

 *	to the new code.

 *

 * Results:

 *	A standard Tcl completion code. If an error occurs, an error message

 *	is left in the interpreter's result.

 *

 * Side effects:

 *	New code suddenly appears in memory.

 *

 *----------------------------------------------------------------------

 */

MODULE_SCOPE int

TclpDlopen(

    Tcl_Interp *interp,		/* Used for error reporting. */

    Tcl_Obj *pathPtr,		/* Name of the file containing the desired

				 * code (UTF-8). */

    Tcl_LoadHandle *loadHandle,	/* Filled with token for dynamically loaded

				 * file which will be passed back to

				 * (*unloadProcPtr)() to unload the file. */

    Tcl_FSUnloadFileProc **unloadProcPtr)

				/* Filled with address of Tcl_FSUnloadFileProc

				 * function which should be used for this

				 * file. */

{

    Tcl_DyldLoadHandle *dyldLoadHandle;

    CONST struct mach_header *dyldLibHeader;

    NSObjectFileImage dyldObjFileImage = NULL;

    Tcl_DyldModuleHandle *modulePtr = NULL;

    CONST char *native;

    /*

     * First try the full path the user gave us. This is particularly

     * important if the cwd is inside a vfs, and we are trying to load using a

     * relative path.

     */

    native = Tcl_FSGetNativePath(pathPtr);

    dyldLibHeader = NSAddImage(native, NSADDIMAGE_OPTION_RETURN_ON_ERROR);

    if (!dyldLibHeader) {

	NSLinkEditErrors editError;

	int errorNumber;

	CONST char *name, *msg, *objFileImageErrMsg = NULL;

	NSLinkEditError(&editError, &errorNumber, &name, &msg);

	if (editError == NSLinkEditFileAccessError) {

	    /*

	     * The requested file was not found. Let the OS loader examine the

	     * binary search path for whatever string the user gave us which

	     * hopefully refers to a file on the binary path.

	     */

	    Tcl_DString ds;

	    char *fileName = Tcl_GetString(pathPtr);

	    CONST char *native =

		    Tcl_UtfToExternalDString(NULL, fileName, -1, &ds);

	    dyldLibHeader = NSAddImage(native, NSADDIMAGE_OPTION_WITH_SEARCHING

		    | NSADDIMAGE_OPTION_RETURN_ON_ERROR);

	    Tcl_DStringFree(&ds);

	    if (!dyldLibHeader) {

		NSLinkEditError(&editError, &errorNumber, &name, &msg);

	    }

	} else if ((editError == NSLinkEditFileFormatError

		&& errorNumber == EBADMACHO)

		|| editError == NSLinkEditOtherError){

	    /*

	     * The requested file was found but was not of type MH_DYLIB,

	     * attempt to load it as a MH_BUNDLE.

	     */

	    NSObjectFileImageReturnCode err =

		    NSCreateObjectFileImageFromFile(native, &dyldObjFileImage);

	    objFileImageErrMsg = DyldOFIErrorMsg(err);

	}

	if (!dyldLibHeader && !dyldObjFileImage) {

	    Tcl_AppendResult(interp, msg, NULL);

	    if (msg && *msg) {

		Tcl_AppendResult(interp, "\n", NULL);

	    }

	    if (objFileImageErrMsg) {

		Tcl_AppendResult(interp,

			"NSCreateObjectFileImageFromFile() error: ",

			objFileImageErrMsg, NULL);

	    }

	    return TCL_ERROR;

	}

    }

    if (dyldObjFileImage) {

	NSModule module;

	module = NSLinkModule(dyldObjFileImage, native,

		NSLINKMODULE_OPTION_BINDNOW

		| NSLINKMODULE_OPTION_RETURN_ON_ERROR);

	NSDestroyObjectFileImage(dyldObjFileImage);

	if (!module) {

	    NSLinkEditErrors editError;

	    int errorNumber;

	    CONST char *name, *msg;

	    NSLinkEditError(&editError, &errorNumber, &name, &msg);

	    Tcl_AppendResult(interp, msg, NULL);

	    return TCL_ERROR;

	}

	modulePtr = (Tcl_DyldModuleHandle *)

		ckalloc(sizeof(Tcl_DyldModuleHandle));

	modulePtr->module = module;

	modulePtr->nextPtr = NULL;

    }

    dyldLoadHandle = (Tcl_DyldLoadHandle *)

	    ckalloc(sizeof(Tcl_DyldLoadHandle));

    dyldLoadHandle->dyldLibHeader = dyldLibHeader;

    dyldLoadHandle->modulePtr = modulePtr;

    *loadHandle = (Tcl_LoadHandle) dyldLoadHandle;

    *unloadProcPtr = &TclpUnloadFile;

    return TCL_OK;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpFindSymbol --

 *

 *	Looks up a symbol, by name, through a handle associated with a

 *	previously loaded piece of code (shared library).

 *

 * Results:

 *	Returns a pointer to the function associated with 'symbol' if it is

 *	found. Otherwise returns NULL and may leave an error message in the

 *	interp's result.

 *

 *----------------------------------------------------------------------

 */

MODULE_SCOPE Tcl_PackageInitProc *

TclpFindSymbol(

    Tcl_Interp *interp,		/* For error reporting. */

    Tcl_LoadHandle loadHandle,	/* Handle from TclpDlopen. */

    CONST char *symbol)		/* Symbol name to look up. */

{

    NSSymbol nsSymbol;

    CONST char *native;

    Tcl_DString newName, ds;

    Tcl_PackageInitProc *proc = NULL;

    Tcl_DyldLoadHandle *dyldLoadHandle = (Tcl_DyldLoadHandle *) loadHandle;

    /*

     * dyld adds an underscore to the beginning of symbol names.

     */

    native = Tcl_UtfToExternalDString(NULL, symbol, -1, &ds);

    Tcl_DStringInit(&newName);

    Tcl_DStringAppend(&newName, "_", 1);

    native = Tcl_DStringAppend(&newName, native, -1);

    if (dyldLoadHandle->dyldLibHeader) {

	nsSymbol = NSLookupSymbolInImage(dyldLoadHandle->dyldLibHeader, native,

		NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW |

		NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);

	if (nsSymbol) {

	    /*

	     * Until dyld supports unloading of MY_DYLIB binaries, the

	     * following is not needed.

	     */

#ifdef DYLD_SUPPORTS_DYLIB_UNLOADING

	    NSModule module = NSModuleForSymbol(nsSymbol);

	    Tcl_DyldModuleHandle *modulePtr = dyldLoadHandle->modulePtr;

	    while (modulePtr != NULL) {

		if (module == modulePtr->module) {

		    break;

		}

		modulePtr = modulePtr->nextPtr;

	    }

	    if (modulePtr == NULL) {

		modulePtr = (Tcl_DyldModuleHandle *)

			ckalloc(sizeof(Tcl_DyldModuleHandle));

		modulePtr->module = module;

		modulePtr->nextPtr = dyldLoadHandle->modulePtr;

		dyldLoadHandle->modulePtr = modulePtr;

	    }

#endif /* DYLD_SUPPORTS_DYLIB_UNLOADING */

	} else {

	    NSLinkEditErrors editError;

	    int errorNumber;

	    CONST char *name, *msg;

	    NSLinkEditError(&editError, &errorNumber, &name, &msg);

	    Tcl_AppendResult(interp, msg, NULL);

	}

    } else {

	nsSymbol = NSLookupSymbolInModule(dyldLoadHandle->modulePtr->module,

		native);

    }

    if (nsSymbol) {

	proc = NSAddressOfSymbol(nsSymbol);

    }

    Tcl_DStringFree(&newName);

    Tcl_DStringFree(&ds);

    return proc;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpUnloadFile --

 *

 *	Unloads a dynamically loaded binary code file from memory. Code

 *	pointers in the formerly loaded file are no longer valid after calling

 *	this function.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Code dissapears from memory. Note that dyld currently only supports

 *	unloading of binaries of type MH_BUNDLE loaded with NSLinkModule() in

 *	TclpDlopen() above.

 *

 *----------------------------------------------------------------------

 */

MODULE_SCOPE void

TclpUnloadFile(

    Tcl_LoadHandle loadHandle)	/* loadHandle returned by a previous call to

				 * TclpDlopen(). The loadHandle is a token

				 * that represents the loaded file. */

{

    Tcl_DyldLoadHandle *dyldLoadHandle = (Tcl_DyldLoadHandle *) loadHandle;

    Tcl_DyldModuleHandle *modulePtr = dyldLoadHandle->modulePtr;

    while (modulePtr != NULL) {

	void *ptr;

	NSUnLinkModule(modulePtr->module,

		NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);

	ptr = modulePtr;

	modulePtr = modulePtr->nextPtr;

	ckfree(ptr);

    }

    ckfree((char*) dyldLoadHandle);

}

/*

 *----------------------------------------------------------------------

 *

 * TclGuessPackageName --

 *

 *	If the "load" command is invoked without providing a package name,

 *	this procedure is invoked to try to figure it out.

 *

 * Results:

 *	Always returns 0 to indicate that we couldn't figure out a package

 *	name; generic code will then try to guess the package from the file

 *	name. A return value of 1 would have meant that we figured out the

 *	package name and put it in bufPtr.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

int

TclGuessPackageName(

    CONST char *fileName,	/* Name of file containing package (already

				 * translated to local form if needed). */

    Tcl_DString *bufPtr)	/* Initialized empty dstring. Append package

				 * name to this if possible. */

{

    return 0;

}

#ifdef TCL_LOAD_FROM_MEMORY

/*

 *----------------------------------------------------------------------

 *

 * TclpLoadMemoryGetBuffer --

 *

 *	Allocate a buffer that can be used with TclpLoadMemory() below.

 *

 * Results:

 *	Pointer to allocated buffer or NULL if an error occurs.

 *

 * Side effects:

 *	Buffer is allocated.

 *

 *----------------------------------------------------------------------

 */

MODULE_SCOPE void *

TclpLoadMemoryGetBuffer(

    Tcl_Interp *interp,		/* Used for error reporting. */

    int size)			/* Size of desired buffer. */

{

    void *buffer = NULL;

    /*

     * NSCreateObjectFileImageFromMemory is available but always fails

     * prior to Darwin 7.

     */

    if (tclMacOSXDarwinRelease >= 7) {

	/*

	 * We must allocate the buffer using vm_allocate, because

	 * NSCreateObjectFileImageFromMemory will dispose of it using

	 * vm_deallocate.

	 */

	if (vm_allocate(mach_task_self(), (vm_address_t *) &buffer, size, 1)) {

	    buffer = NULL;

	}

    }

    return buffer;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpLoadMemory --

 *

 *	Dynamically loads binary code file from memory and returns a handle to

 *	the new code.

 *

 * Results:

 *	A standard Tcl completion code. If an error occurs, an error message

 *	is left in the interpreter's result.

 *

 * Side effects:

 *	New code is loaded from memory.

 *

 *----------------------------------------------------------------------

 */

MODULE_SCOPE int

TclpLoadMemory(

    Tcl_Interp *interp,		/* Used for error reporting. */

    void *buffer,		/* Buffer containing the desired code

				 * (allocated with TclpLoadMemoryGetBuffer). */

    int size,			/* Allocation size of buffer. */

    int codeSize,		/* Size of code data read into buffer or -1 if

				 * an error occurred and the buffer should

				 * just be freed. */

    Tcl_LoadHandle *loadHandle,	/* Filled with token for dynamically loaded

				 * file which will be passed back to

				 * (*unloadProcPtr)() to unload the file. */

    Tcl_FSUnloadFileProc **unloadProcPtr)

				/* Filled with address of Tcl_FSUnloadFileProc

				 * function which should be used for this

				 * file. */

{

    Tcl_DyldLoadHandle *dyldLoadHandle;

    NSObjectFileImage dyldObjFileImage = NULL;

    Tcl_DyldModuleHandle *modulePtr;

    NSModule module;

    CONST char *objFileImageErrMsg = NULL;

    /*

     * Try to create an object file image that we can load from.

     */

    if (codeSize >= 0) {

	NSObjectFileImageReturnCode err = NSObjectFileImageSuccess;

	CONST struct fat_header *fh = buffer;

	uint32_t ms = 0;

#ifndef __LP64__

	CONST struct mach_header *mh = NULL;

	#define mh_magic OSSwapHostToBigInt32(MH_MAGIC)

	#define mh_size  sizeof(struct mach_header)

#else

	CONST struct mach_header_64 *mh = NULL;

	#define mh_magic OSSwapHostToBigInt32(MH_MAGIC_64)

	#define mh_size  sizeof(struct mach_header_64)

#endif

	if ((size_t) codeSize >= sizeof(struct fat_header)

		&& fh->magic == OSSwapHostToBigInt32(FAT_MAGIC)) {

	    /*

	     * Fat binary, try to find mach_header for our architecture

	     */

	    uint32_t fh_nfat_arch = OSSwapBigToHostInt32(fh->nfat_arch);

	    if ((size_t) codeSize >= sizeof(struct fat_header) + 

		    fh_nfat_arch * sizeof(struct fat_arch)) {

		void *fatarchs = (char*)buffer + sizeof(struct fat_header);

		CONST NXArchInfo *arch = NXGetLocalArchInfo();

		struct fat_arch *fa;

		if (fh->magic != FAT_MAGIC) {

		    swap_fat_arch(fatarchs, fh_nfat_arch, arch->byteorder);

		}

		fa = NXFindBestFatArch(arch->cputype, arch->cpusubtype,

			fatarchs, fh_nfat_arch);

		if (fa) {

		    mh = (void*)((char*)buffer + fa->offset);

		    ms = fa->size;

		} else {

		    err = NSObjectFileImageInappropriateFile;

		}

		if (fh->magic != FAT_MAGIC) {

		    swap_fat_arch(fatarchs, fh_nfat_arch, arch->byteorder);

		}

	    } else {

		err = NSObjectFileImageInappropriateFile;

	    }

	} else {

	    /*

	     * Thin binary

	     */

	    mh = buffer;

	    ms = codeSize;

	}

	if (ms && !(ms >= mh_size && mh->magic == mh_magic &&

		 mh->filetype == OSSwapHostToBigInt32(MH_BUNDLE))) {

	    err = NSObjectFileImageInappropriateFile;

	}

	if (err == NSObjectFileImageSuccess) {

	    err = NSCreateObjectFileImageFromMemory(buffer, codeSize,

		    &dyldObjFileImage);

	}

	objFileImageErrMsg = DyldOFIErrorMsg(err);

    }

    /*

     * If it went wrong (or we were asked to just deallocate), get rid of the

     * memory block and create an error message.

     */

    if (dyldObjFileImage == NULL) {

	vm_deallocate(mach_task_self(), (vm_address_t) buffer, size);

	if (objFileImageErrMsg != NULL) {

	    Tcl_AppendResult(interp,

		    "NSCreateObjectFileImageFromMemory() error: ",

		    objFileImageErrMsg, NULL);

	}

	return TCL_ERROR;

    }

    /*

     * Extract the module we want from the image of the object file.

     */

    module = NSLinkModule(dyldObjFileImage, "[Memory Based Bundle]",

	    NSLINKMODULE_OPTION_BINDNOW | NSLINKMODULE_OPTION_RETURN_ON_ERROR);

    NSDestroyObjectFileImage(dyldObjFileImage);

    if (!module) {

	NSLinkEditErrors editError;

	int errorNumber;

	CONST char *name, *msg;

	NSLinkEditError(&editError, &errorNumber, &name, &msg);

	Tcl_AppendResult(interp, msg, NULL);

	return TCL_ERROR;

    }

    /*

     * Stash the module reference within the load handle we create and return.

     */

    modulePtr = (Tcl_DyldModuleHandle *) ckalloc(sizeof(Tcl_DyldModuleHandle));

    modulePtr->module = module;

    modulePtr->nextPtr = NULL;

    dyldLoadHandle = (Tcl_DyldLoadHandle *)

	    ckalloc(sizeof(Tcl_DyldLoadHandle));

    dyldLoadHandle->dyldLibHeader = NULL;

    dyldLoadHandle->modulePtr = modulePtr;

    *loadHandle = (Tcl_LoadHandle) dyldLoadHandle;

    *unloadProcPtr = &TclpUnloadFile;

    return TCL_OK;

}

#endif

/*

 * Local Variables:

 * mode: c

 * c-basic-offset: 4

 * fill-column: 78

 * End:

 */