/*
* fda_free - check chunk of memory for overruns and free it
*/
void fda_free(void* p)
{
if (p) {
size_t size;
BlkHdr* bh = find_blk(p);
void* bp;
/* p already freed or not allocated? */
assert(0 != bh);
assert(p == bh->buf);
bp = BASE_PTR(p);
/* buffer underflow? */
assert(DEADBEEF == *((size_t*) bp));
/*
* buffer overflow?
* Note: it's possible to have up to 3 bytes of unchecked space
* between size and DEADBEEF
*/
size = BASE_SIZE(bh->size);
assert(DEADBEEF == *((size_t*)(BYTE_PTR(bp) + size - S_SIZE)));
SHRED_MEM(bp, size);
free_blk(p);
free(bp);
}
}
char *err_msg_sn (struct error_data *err, char *fmt, const char *one)
{
char* temp = (char*) MALLOC (BASE_SIZE(err)+strlen(fmt));
char* ret = (char*) MALLOC (BASE_SIZE(err)+strlen(fmt)+strlen(one));
if (ret == NULL || temp == NULL)
{
err->ed_error_value = ERR_OUTOFMEMORY;
return NULL;
}
if (current_line()==1)
sprintf (temp, "%s[%5d] : %s", err->ed_filename,
err->ed_curr_line+current_line(), fmt);
else
sprintf (temp, "%s[%5d-%5d] : %s", err->ed_filename,
err->ed_curr_line+1,
err->ed_curr_line+current_line(),
fmt);
sprintf (ret, temp, one);
FREE (temp);
return ret;
}
/*
* fda_realloc - resize a buffer, force reallocation if new size is
* larger than old size
*/
void* fda_realloc(void* p, size_t size, const char* file, int line)
{
void* np;
size_t old_size;
size_t blk_size;
/*
* don't allow malloc or free through realloc
*/
assert(0 != p);
assert(0 < size);
old_size = fda_sizeof(p);
if (size < old_size)
SHRED_MEM(BYTE_PTR(p) + size, old_size - size);
else if (size > old_size) {
void* t = fda_malloc(size, __FILE__, __LINE__);
memmove(t, p, old_size);
fda_free(p);
p = t;
}
blk_size = BASE_SIZE(size);
if ((np = realloc(BASE_PTR(p), blk_size)) == 0) {
lowMemFn();
if ((np = realloc(BASE_PTR(p), blk_size)) == 0)
noMemFn();
}
/*
* don't allow noMemFn to return
*/
assert(0 != np);
*((size_t*)(BYTE_PTR(np) + blk_size - S_SIZE)) = DEADBEEF;
np = BYTE_PTR(np) + S_SIZE;
update_blk(p, np, size, file, line);
/*
* shred tail
*/
if (size > old_size)
SHRED_MEM(BYTE_PTR(np) + old_size, size - old_size);
return np;
}
char *err_msg_n (struct error_data *err, char *fmt)
{
char* ret = (char*) MALLOC (BASE_SIZE(err)+strlen(fmt));
if (ret == NULL)
{
err->ed_error_value = ERR_OUTOFMEMORY;
return NULL;
}
if (current_line()==1)
sprintf (ret, "%s[%5d] : %s", err->ed_filename,
err->ed_curr_line+1, fmt);
else
sprintf (ret, "%s[%5d-%5d] : %s", err->ed_filename,
err->ed_curr_line+1,
err->ed_curr_line+current_line(),
fmt);
return ret;
}
/*
* fda_malloc - allocate size chunk of memory and create debug
* records for it.
*/
void* fda_malloc(size_t size, const char* file, int line)
{
void* p;
size_t blk_size;
Location* location;
assert(0 < size);
assert(0 != file);
assert(sizeof(void*) == sizeof(size_t));
/*
* memory limiter do not allocate more than byteLimit
*/
if ((size + byteCount) > byteLimit)
return 0;
/*
* Make sure that there is enough room for prefix/postfix
* and we get an aligned buffer
*/
blk_size = BASE_SIZE(size);
if ((p = malloc(blk_size)) == 0) {
lowMemFn();
if ((p = malloc(blk_size)) == 0)
noMemFn();
}
/*
* don't allow malloc to fail
*/
assert(0 != p);
/*
* shred the memory and set bounds markers
*/
SHRED_MEM(p, blk_size);
*((size_t*) p) = DEADBEEF;
*((size_t*) (BYTE_PTR(p) + blk_size - S_SIZE)) = DEADBEEF;
/*
* find the location or create a new one
*/
if (0 == (location = findLocation(file, line))) {
if (0 == (location = addLocation(file, line))) {
free(p);
noMemFn();
}
}
/*
* don't allow noMemFn to return
*/
assert(0 != location);
if (!make_blk(BYTE_PTR(p) + S_SIZE, size, location)) {
if (0 == location->count)
freeLocation(location);
free(p);
p = 0;
noMemFn();
}
/*
* don't allow noMemFn to return
*/
assert(0 != p);
return (BYTE_PTR(p) + S_SIZE);
}
