Exemple #1
0
static void ufree_check(void *md, void *ptr)
{
    struct hdr *hdr = ((struct hdr *) ptr) - 1;
    struct mdesc *mdp;

    mdp = MD_TO_MDP(md);
    checkhdr(mdp, hdr);
    hdr->magic = MAGICWORDFREE;
    mdp->ufree_hook = NULL;
    ufree(md, (void *) hdr);
    mdp->ufree_hook = ufree_check;
}
Exemple #2
0
void
mcheck_check_all (void)
{
  /* Walk through all the active blocks and test whether they were tampered
     with.  */
  struct hdr *runp = root;

  /* Temporarily turn off the checks.  */
  pedantic = 0;

  while (runp != NULL)
    {
      (void) checkhdr (runp);

      runp = runp->next;
    }

  /* Turn checks on again.  */
  pedantic = 1;
}
Exemple #3
0
static void *urealloc_check(void *md, void *ptr, uintptr_t size)
{
    struct hdr *hdr = ((struct hdr *) ptr) - 1;
    struct mdesc *mdp;
    uintptr_t nbytes;

    mdp = MD_TO_MDP(md);
    checkhdr(mdp, hdr);
    mdp->ufree_hook = NULL;
    mdp->umalloc_hook = NULL;
    mdp->urealloc_hook = NULL;
    nbytes = sizeof(struct hdr) + size + 1;
    hdr = (struct hdr *) urealloc(md, (void *) hdr, nbytes);
    mdp->ufree_hook = ufree_check;
    mdp->umalloc_hook = umalloc_check;
    mdp->urealloc_hook = urealloc_check;
    if (hdr != NULL) {
	hdr->size = size;
	hdr++;
	*((char *) hdr + size) = MAGICBYTE;
    }
    return ((void *) hdr);
}
Exemple #4
0
static void
freehook (__ptr_t ptr, const __ptr_t caller)
{
  if (pedantic)
    mcheck_check_all ();
  if (ptr)
    {
      struct hdr *hdr = ((struct hdr *) ptr) - 1;
      checkhdr (hdr);
      hdr->magic = MAGICFREE;
      hdr->magic2 = MAGICFREE;
      unlink_blk (hdr);
      hdr->prev = hdr->next = NULL;
      flood (ptr, FREEFLOOD, hdr->size);
      ptr = hdr->block;
    }
  __free_hook = old_free_hook;
  if (old_free_hook != NULL)
    (*old_free_hook)(ptr, caller);
  else
    free (ptr);
  __free_hook = freehook;
}
Exemple #5
0
static __ptr_t
reallochook (__ptr_t ptr, size_t size, const __ptr_t caller)
{
  if (size == 0)
    {
      freehook (ptr, caller);
      return NULL;
    }

  struct hdr *hdr;
  size_t osize;

  if (pedantic)
    mcheck_check_all ();

  if (size > ~((size_t) 0) - (sizeof (struct hdr) + 1))
    {
      __set_errno (ENOMEM);
      return NULL;
    }

  if (ptr)
    {
      hdr = ((struct hdr *) ptr) - 1;
      osize = hdr->size;

      checkhdr (hdr);
      unlink_blk (hdr);
      if (size < osize)
        flood ((char *) ptr + size, FREEFLOOD, osize - size);
    }
  else
    {
      osize = 0;
      hdr = NULL;
    }
  __free_hook = old_free_hook;
  __malloc_hook = old_malloc_hook;
  __memalign_hook = old_memalign_hook;
  __realloc_hook = old_realloc_hook;
  if (old_realloc_hook != NULL)
    hdr = (struct hdr *) (*old_realloc_hook)((__ptr_t) hdr,
                                             sizeof (struct hdr) + size + 1,
                                             caller);
  else
    hdr = (struct hdr *) realloc ((__ptr_t) hdr,
                                  sizeof (struct hdr) + size + 1);
  __free_hook = freehook;
  __malloc_hook = mallochook;
  __memalign_hook = memalignhook;
  __realloc_hook = reallochook;
  if (hdr == NULL)
    return NULL;

  hdr->size = size;
  link_blk (hdr);
  hdr->block = hdr;
  hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
  ((char *) &hdr[1])[size] = MAGICBYTE;
  if (size > osize)
    flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
  return (__ptr_t) (hdr + 1);
}
Exemple #6
0
enum mcheck_status
mprobe (__ptr_t ptr)
{
  return mcheck_used ? checkhdr (((struct hdr *) ptr) - 1) : MCHECK_DISABLED;
}