src/glibcmangle.c

   1 /* Prototypes for __malloc_hook, __free_hook, __realloc_hook */
   2 #include <malloc.h>
   3 #include <string.h>
   4
   5 /* Prototypes for our hooks.  */
   6 static void my_init_hook (void);
   7 static void *my_malloc_hook (size_t, const void *);
   8 static void my_free_hook (void *, const void *);
   9 static void *my_realloc_hook (void *, size_t, const void *);
  10
  11 /* Override initializing hook from the C library. */
  12 void (*__malloc_initialize_hook) (void) = my_init_hook;
  13
  14 static void (*old_free_hook) __MALLOC_PMT ((void *__ptr,
  15                                         __const __malloc_ptr_t));
  16 static void *(*old_malloc_hook) __MALLOC_PMT ((size_t __size,
  17                                              __const __malloc_ptr_t));
  18 static void *(*old_realloc_hook) __MALLOC_PMT ((void *__ptr, size_t __size,
  19                                               __const __malloc_ptr_t));
  20
  21 static void
  22 my_init_hook (void)
  23 {
  24   old_malloc_hook = __malloc_hook;
  25   old_free_hook = __free_hook;
  26   old_realloc_hook = __realloc_hook;
  27   __malloc_hook = my_malloc_hook;
  28   __free_hook = my_free_hook;
  29   __realloc_hook = my_realloc_hook;
  30 }
  31
  32 static void *
  33 my_malloc_hook (size_t size, const void *caller)
  34 {
  35   void *result;
  36   /* Restore all old hooks */
  37   __malloc_hook = old_malloc_hook;
  38   __free_hook = old_free_hook;
  39   __realloc_hook = old_realloc_hook;
  40   /* Call recursively */
  41   result = malloc (sizeof (size_t) + size);
  42   if (result != NULL)
  43     {
  44       *(size_t *) result = size;
  45       result += sizeof (size_t);
  46       memset (result, 0xF3, size);
  47     }
  48   /* Restore our own hooks */
  49   __malloc_hook = my_malloc_hook;
  50   __free_hook = my_free_hook;
  51   __realloc_hook = my_realloc_hook;
  52   return result;
  53 }
  54
  55 static void
  56 my_free_hook (void *ptr, const void *caller)
  57 {
  58   /* Restore all old hooks */
  59   __malloc_hook = old_malloc_hook;
  60   __free_hook = old_free_hook;
  61   __realloc_hook = old_realloc_hook;
  62   if (ptr != NULL)
  63     {
  64       ptr -= sizeof (size_t);
  65       size_t size = *(size_t *) ptr;
  66
  67       memset (ptr, 0xD7, sizeof (size_t) + size);
  68     }
  69   /* Call recursively */
  70   free (ptr);
  71   /* Restore our own hooks */
  72   __malloc_hook = my_malloc_hook;
  73   __free_hook = my_free_hook;
  74   __realloc_hook = my_realloc_hook;
  75 }
  76
  77 static void *
  78 my_realloc_hook (void *ptr, size_t size, const void *caller)
  79 {
  80   void *result;
  81   size_t old_size = 0;
  82
  83   /* Restore all old hooks */
  84   __malloc_hook = old_malloc_hook;
  85   __free_hook = old_free_hook;
  86   __realloc_hook = old_realloc_hook;
  87   if (ptr != NULL)
  88     {
  89       ptr -= sizeof (size_t);
  90       old_size = *(size_t *) ptr;
  91
  92       if (size < old_size)
  93         memset (ptr + sizeof (size_t) + size, 0x7D, old_size - size);
  94     }
  95   /* Call recursively */
  96   result = realloc (ptr, (size != 0 ? sizeof (size_t) + size : 0));
  97   if (result != NULL)
  98     {
  99       *(size_t *) result = size;
 100       result += sizeof (size_t);
 101       if (size > old_size)
 102         memset (result + old_size, 0x3F, size - old_size);
 103     }
 104   /* Restore our own hooks */
 105   __malloc_hook = my_malloc_hook;
 106   __free_hook = my_free_hook;
 107   __realloc_hook = my_realloc_hook;
 108   return result;
 109 }