Ticket #10: 2_beos_partial.diff

README.BEOS

@@ +1 @@
+./configure --enable-32 --enable-readline --use-etags --set-shell "\"/bin/sh\"" --set-editor "\"vi\"" --set-modpath "\"/boot/home/config/share/elfsh/\"" --prefix "\"/boot/home/config\"" --set-lib-path  "\"/boot/beos/system/lib;/boot/home/config/lib\""
+
+config.h:
+remove -rdynamic
+
+export RANLIB="ranlib"
+
+Makefile:
+BASEPATH = $(DESTDIR)
+   comment libmalloc, e2dbg
+

e2dbg/dumpregs.c

@@ -41 +41 @@
 
 #if defined(__amd64__) && defined(__FreeBSD__)
 
-#elif defined(__FreeBSD__)
+#elif defined(__FreeBSD__) || defined(__BEOS__)
   vm_dumpreg("EAX", e2dbgworld.curthread->context->uc_mcontext.mc_eax);
   vm_dumpreg("EBX", e2dbgworld.curthread->context->uc_mcontext.mc_ebx);
   vm_dumpreg("ECX", e2dbgworld.curthread->context->uc_mcontext.mc_ecx);

e2dbg/include/e2dbg.h

@@ -9 +9 @@
 #ifndef __E2DBG_H__
  #define __E2DBG_H__
 
+#ifdef __BEOS__
+typedef char siginfo_t;
+#define SA_SIGINFO NSIG
+#define sa_sigaction sa_handler
+#endif
+
 #define         __DEBUG_E2DBG__         0
 #define         __DEBUG_MUTEX__         1
 #define         __DEBUG_BP__            0

e2dbg/xmalloc.c

@@ -149 +149 @@
 
 
 /* Wrapper for calloc */
-#if __FreeBSD__ > 5
+#if (__FreeBSD__ > 5) || defined(__BEOS__)
 void            *calloc(size_t t, size_t nbr)
 #else
 void            *calloc(size_t t, u_int nbr)

libasm/include/libasm.h

@@ -10 +10 @@
 
 
 #include <sys/types.h>
+#ifdef __BEOS__
+#include <stdint.h>
+#endif
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>

libasm/src/arch/ia32/ei386-7.c

@@ -12 +12 @@
  */
 
 int     i386_group12(asm_instr *new, u_char *opcode, u_int len, asm_processor *proc) {
+  struct s_modrm *modrm = (struct s_modrm *) opcode + 1;
   new->ptr_instr = opcode;
   new->len += 1;
-  struct s_modrm *modrm = (struct s_modrm *) opcode + 1;
   
   switch (modrm->r) {
     case 2:
@@ -64 +64 @@
  */
 
 int     i386_group14(asm_instr *new, u_char *opcode, u_int len, asm_processor *proc) {
+  struct s_modrm *modrm = (struct s_modrm *) opcode + 1;
   new->ptr_instr = opcode;
   new->len += 1;
-  struct s_modrm *modrm = (struct s_modrm *) opcode + 1;
   
   switch (modrm->r) {
     case 2:

libelfsh/got.c

@@ -420 +420 @@
 
 
 
-
-/*
-** Only used on BeoS 
-** Tested and developed by zadig@myrealbox.com
-**
-*/
-int   elfsh_get_got_symbol_reloc(elfshobj_t     *file,
-                                 uint8          *name,
-                                 elfsh_Rel      *rel_entry)
-{
-   elfshsect_t *got, *rel_got;
-   u_int       index, got_rel_index;
-   u_int       entsz;
-   int         got_index;
-   elfsh_Off   off;
-   void         *data;
-   
-   ELFSH_PROFILE_IN(__FILE__, __FUNCTION__, __LINE__);
-   
-   /* Sanity checks */
-   entsz = elfsh_get_pltentsz(file);
-   if (entsz < 0)
-     ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__,
-                       "Invalid PLT entry size", -1);
-
-  if (NULL == elfsh_get_dynsymtab(file, NULL))
-    ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__,
-                      "Unable to get DYNSYM", -1);
-
-  if (NULL == elfsh_get_symtab(file, NULL))
-    ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__,
-                      "Unable to get SYMTAB", -1);
-  
-  /* get got section index */
-  got = elfsh_get_section_by_name(file,
-                                  ELFSH_SECTION_NAME_GOT,
-                                  &got_index, NULL, NULL);
-  if (got == NULL)
-    ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__,
-                      "Unable to get GOT", -1);
-  
-  /* search the got relocation section */
-  rel_got = NULL;
-  for (got_rel_index = 0; got_rel_index < file->hdr->e_shnum; got_rel_index++)
-    {
-      rel_got = elfsh_get_section_by_index(file, got_rel_index,
-                                          NULL, NULL);
-    if (rel_got->shdr->sh_info == got_index)
-      break;
-    }
-  
-  if ((rel_got == NULL) || (rel_got->shdr->sh_info != got_index))
-    ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__,
-                      "Unable to get GOT relocations", -1);
-  
-  /* search for the requested symbol */
-  off = entsz;
-  data = elfsh_get_raw(rel_got);
-  for (index = 0; 
-       index < (rel_got->shdr->sh_size / rel_got->shdr->sh_entsize); 
-       off += entsz, index ++)
-    {
-      elfsh_Rel *cur_rel;
-      cur_rel = ((elfsh_Rel*) data) + index;
-      if(strcmp(elfsh_get_symname_from_reloc(file, cur_rel), name) == 0)
-        {
-          *rel_entry = *cur_rel;
-          ELFSH_PROFILE_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
-        }
-    }
-
-  ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__,
-                    "Symbol not found", -1);
-}
-
-
-
-

libelfsh/hooks.c

@@ -641 +641 @@
                          ELFSH_OS_OPENBSD, elfsh_hijack_plt_ia32);
   elfsh_register_plthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                          ELFSH_OS_SOLARIS, elfsh_hijack_plt_ia32);
+  elfsh_register_plthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                         ELFSH_OS_BEOS, elfsh_hijack_plt_ia32);
   
   /* Usual PLT targets for ET_EXEC/Sparc32 */
   elfsh_register_plthook(ELFSH_ARCH_SPARC32, ELFSH_TYPE_EXEC, 
@@ -729 +731 @@
                             ELFSH_OS_OPENBSD, elfsh_void_altplthandler);
   elfsh_register_altplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                             ELFSH_OS_SOLARIS, elfsh_void_altplthandler);
+  elfsh_register_altplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                            ELFSH_OS_BEOS, elfsh_void_altplthandler);
   
   /* Usual ALTPLT targets for ET_EXEC/Sparc32 */
   elfsh_register_altplthook(ELFSH_ARCH_SPARC32, ELFSH_TYPE_EXEC, 
@@ -818 +822 @@
                          ELFSH_OS_OPENBSD, elfsh_relocate_ia32);
   elfsh_register_relhook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                          ELFSH_OS_SOLARIS, elfsh_relocate_ia32);
+  elfsh_register_relhook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                         ELFSH_OS_BEOS, elfsh_relocate_ia32);
   
   /* Usual REL targets for ET_EXEC/Sparc32 */
   elfsh_register_relhook(ELFSH_ARCH_SPARC32, ELFSH_TYPE_EXEC, 
@@ -906 +912 @@
                            ELFSH_OS_OPENBSD, elfsh_cflow_ia32);
   elfsh_register_cflowhook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                            ELFSH_OS_SOLARIS, elfsh_cflow_ia32);
+  elfsh_register_cflowhook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                           ELFSH_OS_BEOS, elfsh_cflow_ia32);
 
   /* Usual CFLOW targets for ET_EXEC/IA64 */
   elfsh_register_cflowhook(ELFSH_ARCH_IA64, ELFSH_TYPE_EXEC, 
@@ -980 +988 @@
                            ELFSH_OS_SOLARIS, elfsh_cflow_mips64);
   elfsh_register_cflowhook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                            ELFSH_OS_LINUX, elfsh_cflow_ia32);
+  elfsh_register_cflowhook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
+                           ELFSH_OS_BEOS, elfsh_cflow_ia32);
 
   /* Usual REL/PLT/ALTPLT targets for ET_DYN/x86 */
   elfsh_register_plthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
@@ -1043 +1053 @@
                                ELFSH_OS_OPENBSD, elfsh_encodeplt_ia32);
   elfsh_register_encodeplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                                ELFSH_OS_SOLARIS, elfsh_encodeplt_ia32);
+  elfsh_register_encodeplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                               ELFSH_OS_BEOS, elfsh_encodeplt_ia32);
   elfsh_register_encodeplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                                ELFSH_OS_LINUX, elfsh_encodeplt_ia32);
   elfsh_register_encodeplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
@@ -1053 +1065 @@
                                ELFSH_OS_OPENBSD, elfsh_encodeplt_ia32);
   elfsh_register_encodeplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                                ELFSH_OS_SOLARIS, elfsh_encodeplt_ia32);
+  elfsh_register_encodeplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
+                               ELFSH_OS_BEOS, elfsh_encodeplt_ia32);
 
   /* Usual ENCODEPLT1 targets for ET_EXEC/IA32 */
   elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
@@ -1065 +1079 @@
                                 ELFSH_OS_OPENBSD, elfsh_encodeplt1_ia32);
   elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                                 ELFSH_OS_SOLARIS, elfsh_encodeplt1_ia32);
+  elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                                ELFSH_OS_BEOS, elfsh_encodeplt1_ia32);
   elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                                 ELFSH_OS_LINUX, elfsh_encodeplt1_ia32);
   elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
@@ -1075 +1091 @@
                                 ELFSH_OS_OPENBSD, elfsh_encodeplt1_ia32);
   elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                                 ELFSH_OS_SOLARIS, elfsh_encodeplt1_ia32);
+  elfsh_register_encodeplt1hook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
+                                ELFSH_OS_BEOS, elfsh_encodeplt1_ia32);
 
   /*** Now EXTPLT handlers ***/
 
@@ -1089 +1107 @@
                             ELFSH_OS_OPENBSD, elfsh_extplt_ia32);
   elfsh_register_extplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
                             ELFSH_OS_SOLARIS, elfsh_extplt_ia32);
+  elfsh_register_extplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_EXEC, 
+                            ELFSH_OS_BEOS, elfsh_extplt_ia32);
   elfsh_register_extplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                             ELFSH_OS_LINUX, elfsh_extplt_ia32);
   elfsh_register_extplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
@@ -1099 +1119 @@
                             ELFSH_OS_OPENBSD, elfsh_extplt_ia32);
   elfsh_register_extplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
                             ELFSH_OS_SOLARIS, elfsh_extplt_ia32);
+  elfsh_register_extplthook(ELFSH_ARCH_IA32, ELFSH_TYPE_DYN, 
+                            ELFSH_OS_BEOS, elfsh_extplt_ia32);
 
   /***************************************/
   /****** ARGC arguments counting  ******/

libelfsh/include/libelfsh/libelfsh-internal.h

@@ -14 +14 @@
  #define                ELFSH_ERR_ARRAY         sys_errlist[sys_nerr]
 #endif
 
+#ifdef __BEOS__
+/* the internal allocator is not ported yet. For elfsh it should be enough
+ * for the moment. The allocator will be ported to enable e2dbg support */
+#define elfsh_calloc    calloc
+#define elfsh_realloc   realloc
+#define elfsh_malloc    malloc
+#define elfsh_valloc    valloc
+#define elfsh_memalign  memalign
+#define elfsh_free      free
+#define __elfsh_libc_malloc_pthread_startup(first_time)
+#else
 /* Some calls defined in libmalloc */
 void            *elfsh_calloc(size_t, char);
 void            *elfsh_realloc(void *, size_t);
@@ -22 +33 @@
 void            *elfsh_memalign(size_t t, u_int nbr);
 void            elfsh_free(void *);
 void            __elfsh_libc_malloc_pthread_startup(int first_time);
+#endif
 
 /* Safe calloc() */
 #define         XALLOC(a, b, c)                                                                 \

libelfsh/include/libelfsh.h

@@ -18 +18 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <sys/stat.h>
+#ifndef __BEOS__
 #include <sys/mman.h>
+#endif
 
 
 #include "elfsh-libc.h"
@@ -28 +30 @@
 #include <libelfsh/libelfsh-compat.h>
 
 #ifdef __BEOS__
- #include <bsd_mem.h>
+#include <inttypes.h>
+#include <stdint.h>
+#include <bsd_mem.h>
+#include <OS.h>
+#include <bsd_mem.h>
 #endif
 
 
@@ -865 +871 @@
 u_int           elfsh_set_got_val(elfsh_Addr *got, elfsh_Addr val);
 elfsh_Addr      elfsh_get_got_addr(elfsh_Addr *got);
 u_int           elfsh_set_got_addr(elfsh_Addr *got, elfsh_Addr val);
-int             elfsh_get_got_symbol_reloc(elfshobj_t *file, uint8 *name,
-                                 elfsh_Rel *rel_entry);
 int             elfsh_endianize_got(elfshsect_t *_new);
 elfshsect_t     *elfsh_get_gotsct(elfshobj_t *file);
 int             elfsh_shift_got(elfshobj_t *file, u_int size);

libelfsh/mips32.c

@@ -509 +509 @@
                  GP = GP
               */
               *HI16_dword += 
-                VERIFY16((((old_HI16_dword << 16) + (short) A) +                /* AHL */
+                VERIFY16((elfsh_Addr)(((old_HI16_dword << 16) + (short) A) +            /* AHL */
                           GP -                                                  /* GP */
                           (new->shdr->sh_addr + HI16_cur->r_offset) -           /* P */
                           (short) (((old_HI16_dword << 16) + (short) A) +       /* AHL */
@@ -539 +539 @@
       
       if (ISGPDISP(cur))
         {
-          *dword = VERIFY16(((old_HI16_dword << 16) + (short) A) + GP + P + 4);
+          *dword = VERIFY16(((old_HI16_dword << 16) + (short) A) + (elfsh_Addr)GP + (elfsh_Addr)P + 4);
           ELFSH_PROFILE_ROUT(__FILE__, __FUNCTION__, __LINE__, (retval));
         }
       

libelfsh/plt.c

@@ -79 +79 @@
 
   if (sym->st_size != file->secthash[ELFSH_SECTION_PLT]->shdr->sh_size)
   {
+    if ( (file->hdr->e_type == ET_DYN) && (sym->st_value == 0) )
+      ELFSH_PROFILE_ROUT(__FILE__, __FUNCTION__, __LINE__, (1));
+
     if (INTERVAL(file->secthash[ELFSH_SECTION_PLT]->shdr->sh_addr, 
                  sym->st_value, 
                  file->secthash[ELFSH_SECTION_PLT]->shdr->sh_addr + 

libelfsh/runtime.c

@@ -33 +33 @@
 
   ELFSH_PROFILE_IN(__FILE__, __FUNCTION__, __LINE__);
 
+#ifdef __BEOS__
+  if (elfsh_segment_is_readable(segment))
+    prot |= B_READ_AREA;
+  if (elfsh_segment_is_writable(segment))
+    prot |= B_WRITE_AREA;
+  if (elfsh_segment_is_executable(segment))
+    prot |= B_READ_AREA;
+#else
   if (elfsh_segment_is_readable(segment))
     prot |= PROT_READ;
   if (elfsh_segment_is_writable(segment))
     prot |= PROT_WRITE;
   if (elfsh_segment_is_executable(segment))
     prot |= PROT_EXEC;
+#endif
 
 #if     __DEBUG_RUNTIME__
   printf("[DEBUG_RUNTIME] MMAP: " XFMT " of %d bytes \n", segment->p_vaddr, segment->p_memsz);
@@ -62 +71 @@
                            zero, 0);
  close(zero);
 }
+#elif defined(__BEOS__)
+  if(create_area("ElfSh", (void **) &addr, B_ANY_ADDRESS, segment->p_memsz,
+           B_NO_LOCK, prot) < 0)
+  {
+     addr = 0;
+  }
+
 #else  
   addr = (elfsh_Addr) mmap((void *) 0, segment->p_memsz, 
                            prot,
@@ -92 +108 @@
 int             elfsh_runtime_unmap(elfsh_Phdr *segment)
 {
   int           ret;
+#ifdef __BEOS__
+   area_id  area;
+#endif
 
   ELFSH_PROFILE_IN(__FILE__, __FUNCTION__, __LINE__);
   
+#ifdef __BEOS__
+  area = area_for((void*)(segment->p_vaddr));
+  ret = delete_area(area);
+#else
   ret = munmap((void *) segment->p_vaddr, segment->p_memsz);
+#endif
 
   //if (!ret)
   //memset(segment, 0x00, sizeof(elfsh_Phdr));
@@ -146 +170 @@
   elfsh_Phdr    *phdr;
   int           retval;
   int           prot;
+#ifdef __BEOS__
+   area_id  area;
+#endif
 
   ELFSH_PROFILE_IN(__FILE__, __FUNCTION__, __LINE__);
   if (!elfsh_is_debug_mode())
@@ -159 +186 @@
   phdr = elfsh_get_parent_segment(file, sect);
   prot = 0;
 
+#ifdef __BEOS__
+  if (elfsh_segment_is_readable(phdr))
+    prot |= B_READ_AREA;
+  if (elfsh_segment_is_writable(phdr))
+    prot |= B_WRITE_AREA;
+  if (elfsh_segment_is_executable(phdr))
+    prot |= B_READ_AREA;
+  
+  area = area_for((void*)(addr));
+  if(area == B_ERROR)
+    ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
+        "Cannot find area", -1);
+
+  retval = set_area_protection(area, B_WRITE_AREA | B_READ_AREA);
+#else
   if (elfsh_segment_is_readable(phdr))
     prot |= PROT_READ;
   if (elfsh_segment_is_writable(phdr))
@@ -168 +210 @@
 
   retval = mprotect((void *) (addr - addr % getpagesize()), 
                     getpagesize(), PROT_READ | PROT_WRITE);
+#endif
 
   if (retval != 0)
     {
@@ -186 +229 @@
 int             elfsh_mprotect(elfsh_Addr addr, uint32_t sz, int prot)
 {
   int           retval;
+#ifdef __BEOS__
+   area_id  area;
+#endif
 
   ELFSH_PROFILE_IN(__FILE__, __FUNCTION__, __LINE__);
   if (!elfsh_is_debug_mode())
     ELFSH_PROFILE_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
 
+#ifdef __BEOS__
+  area = area_for((void*)(addr));
+  if(area == B_ERROR)
+    ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
+        "Cannot find area", -1);
+
+  retval = set_area_protection(area, prot);
+#else
   retval = mprotect((void *) addr - addr % getpagesize(), 
                     getpagesize(), prot);
+#endif
 
   if (retval != 0)
       ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 

libmalloc/include/malloc-machine.h

@@ -21 +21 @@
 #ifndef _GENERIC_MALLOC_MACHINE_H
 #define _GENERIC_MALLOC_MACHINE_H
 
-#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__BEOS__)
+ #include <SupportDefs.h>
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
  #include <machine/atomic.h>
 #elif !defined(IRIX)
  #include <asm/atomic.h>

libui/log.c

@@ -60 +60 @@
 
 static void             logtofile(char *str)
 {
-  
+  char *tmp;
+   
   elfshpath_t           *stripvar;
   u_int                 len;
 
@@ -73 +74 @@
     ELFSH_NOPROFILE_OUT();
 
   /* We made only local modifications */
-  char tmp[len+1];
+  tmp = (char*)malloc(len+1);
   strcpy(tmp, str);
 
   stripvar = hash_get(&vars_hash, ELFSH_SLOGVAR);
@@ -94 +95 @@
   len = strlen(tmp);
   XWRITE(world.curjob->logfd, tmp, len, );
 
+  free(tmp);
   ELFSH_NOPROFILE_OUT();
 }
 

vm/include/elfsh.h

@@ -984 +984 @@
 int             vm_getvarparams(u_int index, u_int argc, char **argv);
 
 /* Libasm resolve handlers */
-void            asm_do_resolve(void *data, u_int vaddr, char *, u_int);
+void            asm_do_resolve(void *data, elfsh_Addr vaddr, char *, u_int);
 char            *vm_resolve(elfshobj_t *file, elfsh_Addr addr, elfsh_SAddr *roff);
 
 /* General VM functions */
@@ -1023 +1023 @@
 int             vm_version_unk(u_int ai, u_int i, char *id, char *n, char *t);
 
 /* Disassembling and hexadecimal view functions */
-u_int           vm_display_instr(int, u_int, u_int, u_int, u_int,
+u_int           vm_display_instr(int, u_int, elfsh_Addr, u_int, u_int,
                                  char *, u_int, char *);
 int             vm_display_section(elfshsect_t *s, char *name, elfshlist_t *re);
 int             vm_match_sht(elfshobj_t *file, elfshsect_t *l, elfshlist_t *actual);

vm/trace.c

@@ -296 +296 @@
   int           osize = strlen(tfname) + 3;
   char          rsofname[osize];
   char          rtfname[osize];
+  char          **selfuncs;
 
   ELFSH_PROFILE_IN(__FILE__, __FUNCTION__, __LINE__);
 
@@ -318 +319 @@
                       "Cannot init tmp files", (-1));
 
   /* Create temporary storage */
-  char          *selfuncs[symnum + dynsymnum + 1];
+  selfuncs = elfsh_malloc(symnum+1 * sizeof(char));
 
   for (index = 0; index < symnum + dynsymnum + 1; index++)
     selfuncs[index] = NULL;
@@ -334 +335 @@
 
   /* If we didn't trace a function, we don't need to continue */
   if (!count)
+  {
+    elfsh_free(selfuncs);
     ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
                       "No function found", (-1));
+  }
   
 #if __DEBUG_TRACE__
   printf("[DEBUG TRACE] RENAME %s to %s\n", tfname, rtfname);
@@ -343 +347 @@
 
   /* Compile the tmp c file to create a relocatable file to inject */
   if (rename(tfname, rtfname) < 0)
+  {
+    elfsh_free(selfuncs);
     ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
                       "Rename failed", (-1));
+  }
 
   snprintf(buf, BUFSIZ, "gcc -c %s -o %s", rtfname, rsofname);
   vm_system(buf);
@@ -352 +359 @@
   /* Load the new relocatable file for ET_REL injection */
   tobj = elfsh_map_obj(rsofname);
   if (!tobj)
+  {
+    elfsh_free(selfuncs);
     ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
                       "Failed to load relocatable file", (-1));
+  }
 
   idx = elfsh_inject_etrel(world.curjob->current, tobj);          
   if (idx < 0)
+  {
+    elfsh_free(selfuncs);
     ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
                       "Failed to inject ET_REL with workspace", (-1));
+  }
 
   /* Hijack functions with the new functions injected */
   for (index = 0; index < count; index++)
@@ -382 +395 @@
                                         selfuncs[index], 
                                         addr, NULL);
     if (err < 0)
+    {
+      elfsh_free(selfuncs);
       ELFSH_PROFILE_ERR(__FILE__, __FUNCTION__, __LINE__, 
                         "Failed to hijack a function", (-1));
+    }
   }
   
   vm_output("\n [*] Binary ready to be traced. You can now save and run it.\n\n");
 
+  elfsh_free(selfuncs);
   ELFSH_PROFILE_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
 }