rbdc 0.8.0

data/dyncall/dynload/dynload_alloc.h

@@ -0,0 +1,40 @@
+/*
+
+ Package: dyncall
+ Library: dynload
+ File: dynload/dynload_alloc.h
+ Description: heap memory management interface (header only)
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+#ifndef DL_ALLOC_H
+#define DL_ALLOC_H
+
+#ifndef dlAllocMem
+#include <stdlib.h>
+#define dlAllocMem malloc
+#endif
+
+#ifndef dlFreeMem
+#define dlFreeMem  free
+#endif
+
+#endif /* DL_ALLOC_H */
+

data/dyncall/dynload/dynload_darwin.c

@@ -0,0 +1,89 @@
+/*
+
+ Package: dyncall
+ Library: dynload
+ File: dynload/dynload_darwin.c
+ Description: dynload module for .dylib (mach-o darwin/OS X) files
+ License:
+
+   Copyright (c) 2007-2011 Olivier Chafik <olivier.chafik@gmail.com>
+                           Minor bug-fix modifications by Daniel Adler.
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+/*
+
+  dynload_darwin.c
+
+  dynload module for .dylib (mach-o darwin/OS X) files
+
+*/
+
+
+#include "dynload.h"
+#include "dynload_alloc.h"
+#include <dlfcn.h>
+#include <string.h>
+
+struct DLLib_
+{
+	char* libPath;
+	void* handle;
+};
+
+
+DLLib* dlLoadLibrary(const char* libPath)
+{
+	void* handle;
+	size_t len;
+	DLLib* lib;
+	
+	handle = dlopen(libPath, RTLD_LAZY);
+	if (!handle)
+		return NULL;
+
+      
+        lib = (DLLib*)dlAllocMem(sizeof(DLLib));
+        lib->handle = handle;
+        /* libPath might be null (self reference on image) [Daniel] */
+        if (libPath != NULL) {
+                len = strlen(libPath);
+                lib->libPath = (char*)dlAllocMem(len + 1);
+                strcpy(lib->libPath, libPath);
+                lib->libPath[len] = '\0';
+        } else {
+                lib->libPath = NULL;
+        }
+        return lib;
+}
+
+void* dlFindSymbol(DLLib* libHandle, const char* symbol)
+{
+  return dlsym(libHandle && libHandle->handle ? libHandle->handle : RTLD_DEFAULT, symbol);
+}
+
+
+void  dlFreeLibrary(DLLib* libHandle)
+{
+	if (!libHandle)
+		return;
+	
+	dlclose(libHandle->handle);
+        if (libHandle->libPath)
+	        dlFreeMem(libHandle->libPath);
+	dlFreeMem(libHandle);
+}
+

data/dyncall/dynload/dynload_syms.c

@@ -0,0 +1,38 @@
+/*
+
+ Package: dyncall
+ Library: dynload
+ File: dynload/dynload_syms.c
+ Description: 
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+#include "dynload.h"
+#include "../autovar/autovar_ABI.h"
+#if defined(ABI_PE)
+#include "dynload_syms_pe.c"
+#elif defined(ABI_Mach)
+#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

@@ -0,0 +1,214 @@
+/*
+
+ Package: dyncall
+ Library: dynload
+ File: dynload/dynload_syms_elf.c
+ Description: 
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>,
+                           Olivier Chafik <olivier.chafik@gmail.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+#include "../autovar/autovar_OS.h"
+
+/*
+ 
+ dynamic symbol resolver for elf
+
+*/
+
+#include "dynload.h"
+#if defined(OS_OpenBSD)
+#  include <stdint.h>
+#  include <elf_abi.h>
+#elif defined(OS_SunOS)
+#  include <libelf.h>
+#elif defined(OS_BeOS)
+#  include <elf32.h>
+#else
+#  include <elf.h>
+#endif
+
+#if defined(__GLIBC__)
+#  define _GNU_SOURCE
+#  define __USE_GNU
+#endif
+
+#include "dynload_alloc.h"
+
+#include <assert.h>
+#include <fcntl.h>
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <unistd.h> 
+
+/* run-time configuration 64/32 */
+#if defined(OS_OpenBSD)
+#else 
+#  include "../autovar/autovar_ABI.h"
+#  ifdef ABI_ELF64
+
+typedef Elf64_Ehdr   Elf_Ehdr;
+typedef Elf64_Phdr   Elf_Phdr;
+typedef Elf64_Shdr   Elf_Shdr;
+typedef Elf64_Sym    Elf_Sym;
+#    ifndef OS_SunOS
+typedef Elf64_Dyn    Elf_Dyn;
+#    endif
+typedef Elf64_Sxword Elf_tag;
+typedef Elf64_Addr   Elf_Addr;
+
+#  else
+#    if defined(OS_BeOS)
+typedef struct Elf32_Ehdr   Elf_Ehdr;
+typedef struct Elf32_Phdr   Elf_Phdr;
+typedef struct Elf32_Shdr   Elf_Shdr;
+typedef struct Elf32_Sym    Elf_Sym;
+typedef struct Elf32_Dyn    Elf_Dyn;
+typedef        Elf32_Sword  Elf_tag;
+typedef        Elf32_Addr   Elf_Addr;
+
+#    else
+
+typedef Elf32_Ehdr   Elf_Ehdr;
+typedef Elf32_Phdr   Elf_Phdr;
+typedef Elf32_Shdr   Elf_Shdr;
+typedef Elf32_Sym    Elf_Sym;
+#      ifndef OS_SunOS
+typedef Elf32_Dyn    Elf_Dyn;
+#      endif
+typedef Elf32_Sword  Elf_tag;
+typedef Elf32_Addr   Elf_Addr;
+
+#    endif
+#  endif
+#endif
+
+
+struct DLSyms_
+{
+  const char* pStrTab;
+  Elf_Sym*    pSymTab;
+  size_t      strTabSize;
+  size_t      nSymbols;
+  Elf_Ehdr*   pElf_Ehdr;	/* pointer to elf header */
+  int         file;			/* fd of lib */
+  size_t      fileSize;	    /* filesize of open lib */
+};
+
+
+DLSyms* dlSymsInit(const char* libPath)
+{
+  unsigned char* pMem;
+  void* pSectionContent;
+  int i;
+  struct stat st;
+  Elf_Shdr* pS;
+  DLSyms* pSyms = (DLSyms*)dlAllocMem(sizeof(DLSyms));
+  memset(pSyms, 0, sizeof(DLSyms));
+  pSyms->file = open(libPath, O_RDONLY);
+  stat(libPath, &st);
+  pSyms->fileSize = st.st_size;
+  pSyms->pElf_Ehdr = (Elf_Ehdr*) mmap((void*) NULL, pSyms->fileSize, PROT_READ, MAP_SHARED, pSyms->file, 0);
+
+#ifdef ABI_ELF32
+  assert(pSyms->pElf_Ehdr->e_ident[EI_CLASS] == ELFCLASS32);
+#else
+  assert(pSyms->pElf_Ehdr->e_ident[EI_CLASS] == ELFCLASS64);
+#endif
+
+  assert(pSyms->pElf_Ehdr->e_phoff > 0);
+  assert(pSyms->pElf_Ehdr->e_shoff > 0);
+
+
+  pMem = (unsigned char*)pSyms->pElf_Ehdr;
+  
+  /* traverse section headers */
+  pS = (Elf_Shdr*) ( pMem + pSyms->pElf_Ehdr->e_shoff );
+  /* skip section 0 which is always zero due to the Elf standard. */
+  for (i = 1; i < pSyms->pElf_Ehdr->e_shnum; i++) 
+  {
+    Elf_Shdr* pSection = &pS[i];
+    pSectionContent = ((char*)pMem) + pSection->sh_offset;
+    switch (pSection->sh_type)
+    {
+      case SHT_DYNSYM:
+        if (!pSyms->pSymTab) {
+          pSyms->pSymTab  = (Elf_Sym*)pSectionContent;
+          pSyms->nSymbols = pSection->sh_size / pSection->sh_entsize;
+        }
+        break;
+      case SHT_STRTAB:
+        // Do not trust pSyms->pElf_Ehdr->e_shstrndx!
+        if (!pSyms->pStrTab) {
+          pSyms->pStrTab  = (const char*)pSectionContent;
+          pSyms->strTabSize = pSection->sh_size;
+        }
+        break;
+    }
+    if (pSyms->pSymTab && pSyms->pStrTab)
+      break;
+  }
+  return pSyms;
+}
+
+
+void dlSymsCleanup(DLSyms* pSyms)
+{
+  if(pSyms) {
+    munmap((void*) pSyms->pElf_Ehdr, pSyms->fileSize);
+    close(pSyms->file);
+    dlFreeMem(pSyms);
+  }
+}
+
+
+int dlSymsCount(DLSyms* pSyms)
+{
+  if (!pSyms)
+    return 0;
+  return pSyms->nSymbols;
+}
+
+
+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;
+  return &pSyms->pStrTab[str_index];
+}
+
+
+const char* dlSymsNameFromValue(DLSyms* pSyms, void* value)
+{
+  Dl_info info;
+  return (dladdr(value, &info) && (value == info.dli_saddr))
+    ? info.dli_sname
+    : NULL;
+}
+

data/dyncall/dynload/dynload_syms_mach-o.c

@@ -0,0 +1,167 @@
+/*
+
+ Package: dyncall
+ Library: dynload
+ File: dynload/dynload_syms_mach-o.c
+ Description: 
+ License:
+
+   Copyright (c) 2007-2011 Olivier Chafik <olivier.chafik@gmail.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+/*
+ 
+ dynamic symbol resolver for Mach-O
+
+*/
+
+#include "dynload.h"
+#include "dynload_alloc.h"
+
+#include <mach-o/dyld.h>
+#include <mach-o/nlist.h>
+#include <dlfcn.h>
+#include <string.h>
+
+#if defined(ARCH_X64)
+#define MACH_HEADER_TYPE mach_header_64
+#define SEGMENT_COMMAND segment_command_64
+#define NLIST_TYPE nlist_64
+#else
+#define MACH_HEADER_TYPE mach_header
+#define SEGMENT_COMMAND segment_command
+#define NLIST_TYPE nlist
+#endif
+
+
+struct DLLib_
+{
+	char* libPath;
+	void* handle;
+};
+
+
+struct DLSyms_
+{
+	const char* pStringTable;
+	const struct NLIST_TYPE* pSymbolTable;
+	uint32_t symbolCount;
+};
+
+
+DLSyms* dlSymsInit(const char* libPath) 
+{
+	DLSyms* pSyms = NULL;
+	uint32_t iImage, nImages;
+	for (iImage = 0, nImages = _dyld_image_count(); iImage < nImages; iImage++)
+	{
+		const char* name = _dyld_get_image_name(iImage);
+		if (name && !strcmp(name, libPath))
+		{
+			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)
+			{
+				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);
+				}
+			}
+			break;
+		}
+	}
+	return NULL;
+}
+
+
+void dlSymsCleanup(DLSyms* pSyms)
+{
+	if (!pSyms)
+		return;
+	
+	dlFreeMem(pSyms);
+}
+
+int dlSymsCount(DLSyms* pSyms)
+{
+	if (!pSyms)
+		return 0;
+	return pSyms->symbolCount;
+}
+
+static const struct NLIST_TYPE* get_nlist(DLSyms* pSyms, int index)
+{
+	const struct NLIST_TYPE* nl;
+	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;
+}
+
+
+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;
+}
+
+
+void* dlSymsValue(DLSyms* pSyms, int index)
+{
+	const struct NLIST_TYPE* nl = get_nlist(pSyms, index);
+	if (!nl)
+		return NULL;
+	
+	return (void*) (ptrdiff_t) (nl->n_value);
+}
+
+
+const char* dlSymsNameFromValue(DLSyms* pSyms, void* value)
+{
+	Dl_info info;
+	if (!dladdr(value, &info) || (value != info.dli_saddr))
+		return NULL;
+	
+	return info.dli_sname;
+}