/* * 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); }