150 lines
3.8 KiB
C
150 lines
3.8 KiB
C
/*
|
|
* (c) Copyright 1990 Conor P. Cahill (uunet!virtech!cpcahil).
|
|
* You may copy, distribute, and use this software as long as this
|
|
* copyright statement is not removed.
|
|
*/
|
|
#include <stdio.h>
|
|
#include "malloc.h"
|
|
#include "debug.h"
|
|
|
|
/*
|
|
* Function: free()
|
|
*
|
|
* Purpose: to deallocate malloced data
|
|
*
|
|
* Arguments: ptr - pointer to data area to deallocate
|
|
*
|
|
* Returns: nothing of any value
|
|
*
|
|
* Narrative:
|
|
* verify pointer is within malloc region
|
|
* get mlist pointer from passed address
|
|
* verify magic number
|
|
* verify inuse flag
|
|
* verify pointer connections with surrounding segments
|
|
* turn off inuse flag
|
|
* verify no data overrun into non-malloced area at end of segment
|
|
* IF possible join segment with next segment
|
|
* IF possible join segment with previous segment
|
|
* Clear all data in segment (to make sure it isn't reused)
|
|
*
|
|
*/
|
|
#ifndef lint
|
|
static
|
|
char rcs_hdr[] = "$Id: free.c,v 1.2 2006-07-25 10:07:53 rt Exp $";
|
|
#endif
|
|
|
|
void
|
|
free(cptr)
|
|
char * cptr;
|
|
{
|
|
char * func = "free";
|
|
int i;
|
|
extern int malloc_checking;
|
|
extern struct mlist * malloc_end;
|
|
extern int malloc_errno;
|
|
extern char * malloc_data_end;
|
|
extern char * malloc_data_start;
|
|
void malloc_join();
|
|
void malloc_memset();
|
|
struct mlist * oldptr;
|
|
struct mlist * ptr;
|
|
|
|
/*
|
|
* IF malloc chain checking is on, go do it.
|
|
*/
|
|
if( malloc_checking )
|
|
{
|
|
(void) malloc_chain_check(1);
|
|
}
|
|
|
|
/*
|
|
* verify that cptr is within the malloc region...
|
|
*/
|
|
if( cptr < malloc_data_start || cptr > malloc_data_end )
|
|
{
|
|
malloc_errno = M_CODE_BAD_PTR;
|
|
malloc_warning(func);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* convert pointer to mlist struct pointer. To do this we must
|
|
* move the pointer backwards the correct number of bytes...
|
|
*/
|
|
|
|
ptr = (struct mlist *) (cptr - M_SIZE);
|
|
|
|
if( (ptr->flag&M_MAGIC) != M_MAGIC )
|
|
{
|
|
malloc_errno = M_CODE_BAD_MAGIC;
|
|
malloc_warning(func);
|
|
return;
|
|
}
|
|
|
|
if( ! (ptr->flag & M_INUSE) )
|
|
{
|
|
malloc_errno = M_CODE_NOT_INUSE;
|
|
malloc_warning(func);
|
|
return;
|
|
}
|
|
|
|
if( (ptr->prev && (ptr->prev->next != ptr) ) ||
|
|
(ptr->next && (ptr->next->prev != ptr) ) ||
|
|
((ptr->next == NULL) && (ptr->prev == NULL)) )
|
|
{
|
|
malloc_errno = M_CODE_BAD_CONNECT;
|
|
malloc_warning(func);
|
|
return;
|
|
}
|
|
|
|
ptr->flag &= ~M_INUSE;
|
|
|
|
/*
|
|
* verify that the user did not overrun the requested number of bytes.
|
|
*/
|
|
for(i=ptr->r_size; i < ptr->s.size; i++)
|
|
{
|
|
if( ptr->data[i] != M_FILL )
|
|
{
|
|
malloc_errno = M_CODE_OVERRUN;
|
|
malloc_warning(func);
|
|
break;
|
|
}
|
|
}
|
|
|
|
DEBUG3(10,"pointers: prev: 0x%.7x, ptr: 0x%.7x, next: 0x%.7x",
|
|
ptr->prev, ptr, ptr->next);
|
|
|
|
DEBUG3(10,"size: prev: %9d, ptr: %9d, next: %9d",
|
|
ptr->prev->s.size, ptr->s.size, ptr->next->s.size);
|
|
|
|
DEBUG3(10,"flags: prev: 0x%.7x, ptr: 0x%.7x, next: 0x%.7x",
|
|
ptr->prev->flag, ptr->flag, ptr->next->flag);
|
|
|
|
/*
|
|
* check to see if this block can be combined with the next and/or
|
|
* previous block. Since it may be joined with the previous block
|
|
* we will save a pointer to the previous block and test to verify
|
|
* if it is joined (it's next ptr will no longer point to ptr).
|
|
*/
|
|
malloc_join(ptr,ptr->next,0,0);
|
|
|
|
oldptr = ptr->prev;
|
|
|
|
malloc_join(ptr->prev, ptr,0,0);
|
|
|
|
if( oldptr->next != ptr )
|
|
{
|
|
DEBUG0(10,"Oldptr was changed");
|
|
ptr = oldptr;
|
|
}
|
|
|
|
/*
|
|
* fill this block with '\02's to ensure that nobody is using a
|
|
* pointer to already freed data...
|
|
*/
|
|
malloc_memset(ptr->data,M_FREE_FILL,(int)ptr->s.size);
|
|
|
|
}
|
|
|