rbdc 0.9.0 → 1.0.0

data/dyncall/dynload/dynload.h

@@ -6,7 +6,7 @@
  Description: public header for library dynload
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -36,17 +36,21 @@ extern "C" {
 #define DL_API
 #endif
 
-/* --- public api ---------------------------------------------------------- */
 
 /* shared library loading and explicit symbol resolving */
+/* dlLoadLibrary will search for specified lib (e.g. as leaf name, only), */
+/* to the platforms dynamic linking style */
 
 typedef struct DLLib_ DLLib;
 
-DL_API DLLib* dlLoadLibrary(const char* libpath);
-DL_API void   dlFreeLibrary(DLLib* pLib);
-DL_API void*  dlFindSymbol(DLLib* pLib, const char* pSymbolName);
+DL_API DLLib* dlLoadLibrary   (const char* libPath);
+DL_API void   dlFreeLibrary   (DLLib* pLib);
+DL_API void*  dlFindSymbol    (DLLib* pLib, const char* pSymbolName);
+DL_API int    dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize);
+
 
 /* symbol table enumeration - only for symbol lookup, not resolve */
+/* note that dlSymsInit does not search library paths */
 
 typedef struct DLSyms_ DLSyms;
 

data/dyncall/dynload/dynload_alloc.h

@@ -6,7 +6,7 @@
  Description: heap memory management interface (header only)
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any

data/dyncall/dynload/dynload_syms.c

@@ -6,7 +6,7 @@
  Description: 
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -33,7 +33,5 @@
 #include "dynload_syms_mach-o.c"
 #elif defined(ABI_ELF)
 #include "dynload_syms_elf.c"
-#else
-void dummy() { }
 #endif
 

data/dyncall/dynload/dynload_syms_elf.c

@@ -6,7 +6,7 @@
  Description: 
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 
                            Tassilo Philipp <tphilipp@potion-studios.com>,
                            Olivier Chafik <olivier.chafik@gmail.com>
 
@@ -38,6 +38,9 @@
 #if defined(OS_OpenBSD)
 #  include <stdint.h>
 #  include <elf_abi.h>
+#elif defined(OS_NetBSD)
+#  include <stddef.h>
+#  include <elf.h>
 #elif defined(OS_SunOS)
 #  include <libelf.h>
 #elif defined(OS_BeOS)
@@ -121,14 +124,21 @@ struct DLSyms_
 DLSyms* dlSymsInit(const char* libPath)
 {
   unsigned char* pMem;
-  void* pSectionContent;
   int i;
   struct stat st;
   Elf_Shdr* pS;
-  DLSyms* pSyms = (DLSyms*)dlAllocMem(sizeof(DLSyms));
+  DLSyms* pSyms;
+
+  if(stat(libPath, &st) == -1)
+    return NULL;
+
+  i = open(libPath, O_RDONLY);
+  if(i == -1)
+    return NULL;
+
+  pSyms = (DLSyms*)dlAllocMem(sizeof(DLSyms));
   memset(pSyms, 0, sizeof(DLSyms));
-  pSyms->file = open(libPath, O_RDONLY);
-  stat(libPath, &st);
+  pSyms->file = i;
   pSyms->fileSize = st.st_size;
   pSyms->pElf_Ehdr = (Elf_Ehdr*) mmap((void*) NULL, pSyms->fileSize, PROT_READ, MAP_SHARED, pSyms->file, 0);
 
@@ -150,7 +160,7 @@ DLSyms* dlSymsInit(const char* libPath)
   for (i = 1; i < pSyms->pElf_Ehdr->e_shnum; i++) 
   {
     Elf_Shdr* pSection = &pS[i];
-    pSectionContent = ((char*)pMem) + pSection->sh_offset;
+    void* pSectionContent = ((char*)pMem) + pSection->sh_offset;
     switch (pSection->sh_type)
     {
       case SHT_DYNSYM:
@@ -160,7 +170,7 @@ DLSyms* dlSymsInit(const char* libPath)
         }
         break;
       case SHT_STRTAB:
-        // Do not trust pSyms->pElf_Ehdr->e_shstrndx!
+        /* Do not trust pSyms->pElf_Ehdr->e_shstrndx! */
         if (!pSyms->pStrTab) {
           pSyms->pStrTab  = (const char*)pSectionContent;
           pSyms->strTabSize = pSection->sh_size;
@@ -186,9 +196,7 @@ void dlSymsCleanup(DLSyms* pSyms)
 
 int dlSymsCount(DLSyms* pSyms)
 {
-  if (!pSyms)
-    return 0;
-  return pSyms->nSymbols;
+  return pSyms ? pSyms->nSymbols : 0;
 }
 
 
@@ -197,7 +205,7 @@ const char* dlSymsName(DLSyms* pSyms, int index)
   int str_index;
   if(!pSyms || !pSyms->pSymTab || index < 0 || index >= pSyms->nSymbols)
     return NULL;
-  
+
   str_index = pSyms->pSymTab[index].st_name;
   if (str_index < 0 || str_index >= pSyms->strTabSize)
     return NULL;

data/dyncall/dynload/dynload_syms_mach-o.c

@@ -3,10 +3,12 @@
  Package: dyncall
  Library: dynload
  File: dynload/dynload_syms_mach-o.c
- Description: 
+ Description:
  License:
 
-   Copyright (c) 2007-2015 Olivier Chafik <olivier.chafik@gmail.com>
+   Copyright (c) 2007-2015 Olivier Chafik <olivier.chafik@gmail.com>,
+                 2017-2018 refactored completely for stability, API
+                           consistency and portability by Tassilo Philipp.
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
@@ -25,136 +27,209 @@
 
 
 /*
- 
+
  dynamic symbol resolver for Mach-O
 
 */
 
 #include "dynload.h"
 #include "dynload_alloc.h"
+#include "../autovar/autovar_ARCH.h"
+#include "../autovar/autovar_OS.h"
 
 #include <mach-o/dyld.h>
 #include <mach-o/nlist.h>
+#include <sys/stat.h>
 #include <dlfcn.h>
 #include <string.h>
 
-#if defined(ARCH_X64) //@@@ use dyncall_macros.h
+#if defined(ARCH_X64) || defined(ARCH_PPC64) || defined(ARCH_ARM64) /*@@@ use dyncall_macros.h*/
 #define MACH_HEADER_TYPE mach_header_64
+#define MACH_HEADER_MAGIC_NR MH_MAGIC_64
+#define SEGMEND_COMMAND_ID LC_SEGMENT_64
 #define SEGMENT_COMMAND segment_command_64
 #define NLIST_TYPE nlist_64
 #else
 #define MACH_HEADER_TYPE mach_header
+#define MACH_HEADER_MAGIC_NR MH_MAGIC
+#define SEGMEND_COMMAND_ID LC_SEGMENT
 #define SEGMENT_COMMAND segment_command
 #define NLIST_TYPE nlist
 #endif
 
 
-struct DLLib_
-{
-	char* libPath;
-	void* handle;
-};
-
-
 struct DLSyms_
 {
-	const char* pStringTable;
+	DLLib*                   pLib;
+	const char*              pStringTable;
 	const struct NLIST_TYPE* pSymbolTable;
-	uint32_t symbolCount;
+	uint32_t                 symbolCount;
+	uintptr_t                symOffset;
 };
 
 
-DLSyms* dlSymsInit(const char* libPath) 
+DLSyms* dlSymsInit(const char* libPath)
 {
+	DLLib* pLib;
 	DLSyms* pSyms = NULL;
-	uint32_t iImage, nImages;
-	for (iImage = 0, nImages = _dyld_image_count(); iImage < nImages; iImage++)
+	uint32_t i, n;
+	struct stat st0;
+	const struct MACH_HEADER_TYPE* pHeader = NULL;
+	const struct dysymtab_command* dysymtab_cmd = NULL;
+
+	if(stat(libPath, &st0) == -1)
+		return NULL;
+
+	pLib = dlLoadLibrary(libPath);
+	if(!pLib)
+		return NULL;
+
+	/* Loop over all dynamically linked images to find ours. */
+	for(i = 0, n = _dyld_image_count(); i < n; ++i)
 	{
-		const char* name = _dyld_get_image_name(iImage);
-		if (name && !strcmp(name, libPath))
+		struct stat st1;
+		const char* name = _dyld_get_image_name(i);
+
+		if(name && (stat(name, &st1) != -1))
 		{
-			const struct MACH_HEADER_TYPE* pHeader = (const struct MACH_HEADER_TYPE*) _dyld_get_image_header(iImage);
-			const char* pBase = ((const char*)pHeader);
-			if (pHeader->filetype != MH_DYLIB)
-				return NULL;
-			if (pHeader->flags & MH_SPLIT_SEGS)
-				return NULL;
-
-			if (pHeader)
+			/* Don't rely on name comparison alone, as libPath might be relative, symlink, differently */
+			/* cased, etc., but compare inode number with the one of the mapped dyld image. */
+			if(st0.st_ino == st1.st_ino/*!strcmp(name, libPath)*/)
+			{
+				pHeader = (const struct MACH_HEADER_TYPE*) _dyld_get_image_header(i);
+//@@@ slide = _dyld_get_image_vmaddr_slide(i);
+				break; /* found header */
+			}
+		}
+	}
+
+	if(pHeader && (pHeader->magic == MACH_HEADER_MAGIC_NR) && (pHeader->filetype == MH_DYLIB)/*@@@ ignore for now, seems to work without it on El Capitan && !(pHeader->flags & MH_SPLIT_SEGS)*/)
+	{
+		const char* pBase = (const char*)pHeader;
+		uintptr_t slide = 0, symOffset = 0;
+		const struct load_command* cmd = (const struct load_command*)(pBase + sizeof(struct MACH_HEADER_TYPE));
+
+		for(i = 0, n = pHeader->ncmds; i < n; ++i, cmd = (const struct load_command*)((const char*)cmd + cmd->cmdsize))
+		{
+			if(cmd->cmd == SEGMEND_COMMAND_ID)
+			{
+				const struct SEGMENT_COMMAND* seg = (struct SEGMENT_COMMAND*)cmd;
+				/*@@@ unsure why I used this instead of checking __TEXT: if((seg->fileoff == 0) && (seg->filesize != 0))*/
+				if(strcmp(seg->segname, "__TEXT") == 0)
+					slide = (uintptr_t)pHeader - seg->vmaddr; /* effective offset of segment from header */
+
+				/* If we have __LINKEDIT segment (= raw data for dynamic linkers), use that one to find symbal table address. */
+				if(strcmp(seg->segname, "__LINKEDIT") == 0) {
+					/* Recompute pBase relative to where __LINKEDIT segment is in memory. */
+					pBase = (const char*)(seg->vmaddr - seg->fileoff) + slide;
+
+					/*@@@ we might want to also check maxprot and initprot here:
+						VM_PROT_READ    ((vm_prot_t) 0x01)
+						VM_PROT_WRITE   ((vm_prot_t) 0x02)
+						VM_PROT_EXECUTE ((vm_prot_t) 0x04)*/
+
+					symOffset = slide; /* this is also offset of symbols */
+				}
+			}
+			else if(cmd->cmd == LC_SYMTAB && !pSyms/* only init once - just safety check */)
+			{
+				const struct symtab_command* scmd = (const struct symtab_command*)cmd;
+
+				/* cmd->cmdsize must be size of struct, otherwise something is off; abort */
+				if(cmd->cmdsize != sizeof(struct symtab_command))
+					break;
+
+				pSyms = (DLSyms*)dlAllocMem(sizeof(DLSyms));
+				pSyms->symbolCount  = scmd->nsyms;
+				pSyms->pStringTable = pBase + scmd->stroff;
+				pSyms->pSymbolTable = (struct NLIST_TYPE*)(pBase + scmd->symoff);
+				pSyms->symOffset    = symOffset;
+				pSyms->pLib         = pLib;
+			}
+			else if(cmd->cmd == LC_DYSYMTAB && !dysymtab_cmd/* only init once - just safety check */)
 			{
-				uint32_t iCmd, nCmds = pHeader->ncmds;
-				const struct load_command* cmd = (const struct load_command*)(pBase + sizeof(struct MACH_HEADER_TYPE));
-				
-				for (iCmd = 0; iCmd < nCmds; iCmd++) 
-				{
-					if (cmd->cmd == LC_SYMTAB) 
-					{
-						const struct symtab_command* scmd = (const struct symtab_command*)cmd;
-					
-						pSyms = (DLSyms*)( dlAllocMem(sizeof(DLSyms)) );
-						pSyms->symbolCount = scmd->nsyms;
-						pSyms->pStringTable = pBase + scmd->stroff;
-						pSyms->pSymbolTable = (struct NLIST_TYPE*)(pBase + scmd->symoff);
-						
-						return pSyms;
-					}
-					cmd = (const struct load_command*)(((char*)cmd) + cmd->cmdsize);
+				/* @@@ unused, we'll always run over all symbols, and not check locals, globals, etc.
+				if(cmd->cmdsize != sizeof(struct symtab_command)) {
+					dlSymsCleanup(pSyms);
+					break;
 				}
+
+				dysymtab_cmd = (const struct dysymtab_command*)cmd;*/
 			}
-			break;
 		}
 	}
+
+	/* Got symbol table? */
+	if(pSyms) {
+		/* Alter symtable info if we got symbols organized in local/defined/undefined groups. */
+		/* Only use local ones in that case. */
+		/*@@@ don't restrict to only local symbols if(dysymtab_cmd) {
+			pSyms->pSymbolTable += dysymtab_cmd->ilocalsym;
+			pSyms->symbolCount = dysymtab_cmd->nlocalsym;
+		}*/
+		return pSyms;
+	}
+
+	/* Couldn't init syms, so free lib and return error. */
+	dlFreeLibrary(pLib);
 	return NULL;
 }
 
 
 void dlSymsCleanup(DLSyms* pSyms)
 {
-	if (!pSyms)
-		return;
-	
-	dlFreeMem(pSyms);
+	if(pSyms) {
+		dlFreeLibrary(pSyms->pLib);
+		dlFreeMem(pSyms);
+	}
 }
 
 int dlSymsCount(DLSyms* pSyms)
 {
-	if (!pSyms)
-		return 0;
-	return pSyms->symbolCount;
+	return pSyms ? pSyms->symbolCount : 0;
 }
 
-static const struct NLIST_TYPE* get_nlist(DLSyms* pSyms, int index)
+
+const char* dlSymsName(DLSyms* pSyms, int index)
 {
 	const struct NLIST_TYPE* nl;
-	if (!pSyms)
+	unsigned char t;
+
+	if(!pSyms)
 		return NULL;
-	
+
 	nl = pSyms->pSymbolTable + index;
-	if (nl->n_un.n_strx <= 1)
-		return NULL; // would be empty string anyway
-	
-	//TODO skip more symbols based on nl->n_desc and nl->n_type ?
-	return nl;
-}
+	t = nl->n_type & N_TYPE;
 
+	/* Return name by lookup through it's address. This guarantees to be consistent with dlsym and dladdr */
+	/* calls as used in dlFindAddress and dlSymsNameFromValue - the "#if 0"-ed code below returns the */
+	/* name directly, but assumes wrongly that everything is prefixed with an underscore on Darwin. */
 
-const char* dlSymsName(DLSyms* pSyms, int index)
-{
-	const struct NLIST_TYPE* nl = get_nlist(pSyms, index);
-	if (!nl)
-		return NULL;
-	
-	return pSyms->pStringTable + nl->n_un.n_strx;
-}
+	/* only handle symbols that are in a section and aren't symbolic debug entries */
+	if((t == N_SECT) && (nl->n_type & N_STAB) == 0)
+		return dlSymsNameFromValue(pSyms, (void*)(nl->n_value + pSyms->symOffset));
 
+	return NULL; /* @@@ handle N_INDR, etc.? */
 
-void* dlSymsValue(DLSyms* pSyms, int index)
-{
-	const struct NLIST_TYPE* nl = get_nlist(pSyms, index);
-	if (!nl)
+#if 0
+	/* Mach-O manual: Symbols with an index into the string table of zero */
+	/* (n_un.n_strx == 0) are defined to have a null ("") name. */
+	if(nl->n_un.n_strx == 0)
+		return NULL; /*@@@ have return pointer to some static "" string? */
+
+	/* Skip undefined symbols. @@@ should we? */
+	if(t == N_UNDF || t == N_PBUD) /* @@@ check if N_PBUD is defined, it's not in the NeXT manual, but on Darwin 8.0.1 */
 		return NULL;
-	
-	return (void*) (ptrdiff_t) (nl->n_value);
+
+	/*TODO skip more symbols based on nl->n_desc and nl->n_type ? */
+
+	/* Return name - handles lookup of indirect names. */
+	return &pSyms->pStringTable[(t == N_INDR ? nl->n_value : nl->n_un.n_strx)
+#if defined(OS_Darwin)
+		+ 1 /* Skip '_'-prefix */
+#endif
+	];
+#endif
 }
 
 
@@ -163,6 +238,7 @@ const char* dlSymsNameFromValue(DLSyms* pSyms, void* value)
 	Dl_info info;
 	if (!dladdr(value, &info) || (value != info.dli_saddr))
 		return NULL;
-	
+
 	return info.dli_sname;
 }
+

data/dyncall/dynload/dynload_syms_pe.c

@@ -6,7 +6,7 @@
  Description: 
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, 
+   Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>,
                            Tassilo Philipp <tphilipp@potion-studios.com>
                            Olivier Chafik <olivier.chafik@gmail.com>
 
@@ -31,12 +31,6 @@
 
 #include <windows.h>
 
-struct DLLib_
-{
-  IMAGE_DOS_HEADER dos_header;
-};
-
-
 struct DLSyms_
 {
   DLLib*                pLib;
@@ -50,14 +44,25 @@ struct DLSyms_
 
 DLSyms* dlSymsInit(const char* libPath)
 {
-  DLLib* pLib = dlLoadLibrary(libPath);
-  DLSyms* pSyms = (DLSyms*)dlAllocMem(sizeof(DLSyms));
-  const char* base = (const char*) pLib;
-  IMAGE_DOS_HEADER*       pDOSHeader      = (IMAGE_DOS_HEADER*) base;  
-  IMAGE_NT_HEADERS*       pNTHeader       = (IMAGE_NT_HEADERS*) ( base + pDOSHeader->e_lfanew );  
-  IMAGE_DATA_DIRECTORY*   pExportsDataDir = &pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
-  IMAGE_EXPORT_DIRECTORY* pExports        = (IMAGE_EXPORT_DIRECTORY*) (base + pExportsDataDir->VirtualAddress);  
-
+  DLLib*                  pLib;
+  DLSyms*                 pSyms;
+  IMAGE_DOS_HEADER*       pDOSHeader;
+  IMAGE_NT_HEADERS*       pNTHeader;
+  IMAGE_DATA_DIRECTORY*   pExportsDataDir;
+  IMAGE_EXPORT_DIRECTORY* pExports;
+  const char*             base;
+
+  pLib = dlLoadLibrary(libPath);
+  if(!pLib)
+    return NULL;
+
+  base            = (const char*)pLib;
+  pDOSHeader      = (IMAGE_DOS_HEADER*)base;
+  pNTHeader       = (IMAGE_NT_HEADERS*)(base + pDOSHeader->e_lfanew);
+  pExportsDataDir = &pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
+  pExports        = (IMAGE_EXPORT_DIRECTORY*)(base + pExportsDataDir->VirtualAddress);
+
+  pSyms         = (DLSyms*)dlAllocMem(sizeof(DLSyms));
   pSyms->pBase  = base;
   pSyms->pNames = (DWORD*)(base + pExports->AddressOfNames);
   pSyms->pFuncs = (DWORD*)(base + pExports->AddressOfFunctions);
@@ -86,25 +91,20 @@ int dlSymsCount(DLSyms* pSyms)
 
 const char* dlSymsName(DLSyms* pSyms, int index)
 {
-  return (const char*)((const char*)pSyms->pBase + pSyms->pNames[index]);
+  return pSyms->pBase + pSyms->pNames[index];
 }
 
 
-void* dlSymsValue(DLSyms* pSyms, int index)
-{
-  return (void*)(pSyms->pBase + pSyms->pFuncs[pSyms->pOrds[index]]);
-}
-
-
-const char* dlSymsNameFromValue(DLSyms* pSyms, void* value) 
+const char* dlSymsNameFromValue(DLSyms* pSyms, void* value)
 {
   int i, c=dlSymsCount(pSyms);
   for(i=0; i<c; ++i)
   {
-    if(dlSymsValue(pSyms, i) == value)
+    if((void*)(pSyms->pBase + pSyms->pFuncs[pSyms->pOrds[i]]) == value)
       return dlSymsName(pSyms, i);
   }
 
   /* Not found. */
   return NULL;
 }
+