/* Prototypes for __malloc_hook, __free_hook, __realloc_hook */
#include <malloc.h>
#include <string.h>

/* Prototypes for our hooks.  */
static void my_init_hook (void);
static void *my_malloc_hook (size_t, const void *);
static void my_free_hook (void *, const void *);
static void *my_realloc_hook (void *, size_t, const void *);

/* Override initializing hook from the C library. */
void (*__malloc_initialize_hook) (void) = my_init_hook;

static void (*old_free_hook) __MALLOC_PMT ((void *__ptr,
					__const __malloc_ptr_t));
static void *(*old_malloc_hook) __MALLOC_PMT ((size_t __size,
					     __const __malloc_ptr_t));
static void *(*old_realloc_hook) __MALLOC_PMT ((void *__ptr, size_t __size,
					      __const __malloc_ptr_t));

static void
my_init_hook (void)
{
  old_malloc_hook = __malloc_hook;
  old_free_hook = __free_hook;
  old_realloc_hook = __realloc_hook;
  __malloc_hook = my_malloc_hook;
  __free_hook = my_free_hook;
  __realloc_hook = my_realloc_hook;
}

static void *
my_malloc_hook (size_t size, const void *caller)
{
  void *result;
  /* Restore all old hooks */
  __malloc_hook = old_malloc_hook;
  __free_hook = old_free_hook;
  __realloc_hook = old_realloc_hook;
  /* Call recursively */
  result = malloc (sizeof (size_t) + size);
  if (result != NULL)
    {
      *(size_t *) result = size;
      result += sizeof (size_t);
      memset (result, 0xF3, size);
    }
  /* Restore our own hooks */
  __malloc_hook = my_malloc_hook;
  __free_hook = my_free_hook;
  __realloc_hook = my_realloc_hook;
  return result;
}

static void
my_free_hook (void *ptr, const void *caller)
{
  /* Restore all old hooks */
  __malloc_hook = old_malloc_hook;
  __free_hook = old_free_hook;
  __realloc_hook = old_realloc_hook;
  if (ptr != NULL)
    {
      ptr -= sizeof (size_t);
      size_t size = *(size_t *) ptr;

      memset (ptr, 0xD7, sizeof (size_t) + size);
    }
  /* Call recursively */
  free (ptr);
  /* Restore our own hooks */
  __malloc_hook = my_malloc_hook;
  __free_hook = my_free_hook;
  __realloc_hook = my_realloc_hook;
}

static void *
my_realloc_hook (void *ptr, size_t size, const void *caller)
{
  void *result;
  size_t old_size = 0;

  /* Restore all old hooks */
  __malloc_hook = old_malloc_hook;
  __free_hook = old_free_hook;
  __realloc_hook = old_realloc_hook;
  if (ptr != NULL)
    {
      ptr -= sizeof (size_t);
      old_size = *(size_t *) ptr;

      if (size < old_size)
        memset (ptr + sizeof (size_t) + size, 0x7D, old_size - size);
    }
  /* Call recursively */
  result = realloc (ptr, (size != 0 ? sizeof (size_t) + size : 0));
  if (result != NULL)
    {
      *(size_t *) result = size;
      result += sizeof (size_t);
      if (size > old_size)
        memset (result + old_size, 0x3F, size - old_size);
    }
  /* Restore our own hooks */
  __malloc_hook = my_malloc_hook;
  __free_hook = my_free_hook;
  __realloc_hook = my_realloc_hook;
  return result;
}