diff options
Diffstat (limited to 'src/LYLeaks.c')
| -rw-r--r-- | src/LYLeaks.c | 1169 |
1 files changed, 1169 insertions, 0 deletions
diff --git a/src/LYLeaks.c b/src/LYLeaks.c new file mode 100644 index 0000000..d082a77 --- /dev/null +++ b/src/LYLeaks.c @@ -0,0 +1,1169 @@ +/* + * $LynxId: LYLeaks.c,v 1.43 2018/12/27 23:48:37 Kamil.Dudka Exp $ + * + * Copyright (c) 1994, University of Kansas, All Rights Reserved + * (this file was rewritten twice - 1998/1999 and 2003/2004) + * + * This code will be used only if LY_FIND_LEAKS is defined. + * + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + * 10-30-97 modified to handle StrAllocCopy() and + * StrAllocCat(). - KW & FM + * 07-23-07 free leaks of THIS module too -TD + * 02-09-12 add bstring functions -TD + */ + +/* + * Disable the overriding of the memory routines for this file. + */ +#define NO_MEMORY_TRACKING + +#include <HTUtils.h> +#include <LYexit.h> +#include <LYLeaks.h> +#include <LYUtils.h> +#include <LYGlobalDefs.h> + +#ifdef LY_FIND_LEAKS + +static AllocationList *ALp_RunTimeAllocations = NULL; + +#define LEAK_SUMMARY + +#ifdef LEAK_SUMMARY + +static size_t now_allocated = 0; +static size_t peak_alloced = 0; + +static size_t total_alloced = 0; +static size_t total_freed = 0; + +static long count_mallocs = 0; +static long count_frees = 0; + +static void CountMallocs(size_t size) +{ + ++count_mallocs; + total_alloced += size; + now_allocated += size; + if (peak_alloced < now_allocated) + peak_alloced = now_allocated; +} + +static void CountFrees(size_t size) +{ + ++count_frees; + total_freed += size; + now_allocated -= size; +} + +#else +#define CountMallocs(size) ++count_mallocs +#define CountFrees(size) /* nothing */ +#endif + +/* + * Purpose: Add a new allocation item to the list. + * Arguments: ALp_new The new item to add. + * Return Value: void + * Remarks/Portability/Dependencies/Restrictions: + * Static function made to make code reusable in projects beyond + * Lynx (some might ask why not use HTList). + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +static void AddToList(AllocationList * ALp_new) +{ + /* + * Just make this the first item in the list. + */ + ALp_new->ALp_Next = ALp_RunTimeAllocations; + ALp_RunTimeAllocations = ALp_new; +} + +/* + * Purpose: Find the place in the list where vp_find is currently + * tracked. + * Arguments: vp_find A pointer to look for in the list. + * Return Value: AllocationList * Either vp_find's place in the + * list or NULL if not found. + * Remarks/Portability/Dependencies/Restrictions: + * Static function made to make code reusable in projects outside + * of Lynx (some might ask why not use HTList). + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +static AllocationList *FindInList(void *vp_find) +{ + AllocationList *ALp_find = ALp_RunTimeAllocations; + + /* + * Go through the list of allocated pointers until end of list or vp_find + * is found. + */ + while (ALp_find != NULL) { + if (ALp_find->vp_Alloced == vp_find) { + break; + } + ALp_find = ALp_find->ALp_Next; + } + + return (ALp_find); +} + +/* + * Purpose: Remove the specified item from the list. + * Arguments: ALp_del The item to remove from the list. + * Return Value: void + * Remarks/Portability/Dependencies/Restrictions: + * Static function made to make code reusable in projects outside + * of Lynx (some might ask why not use HTList). + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +static void RemoveFromList(AllocationList * ALp_del) +{ + AllocationList *ALp_findbefore = ALp_RunTimeAllocations; + + /* + * There is one special case, where the item to remove is the first in the + * list. + */ + if (ALp_del == ALp_findbefore) { + ALp_RunTimeAllocations = ALp_del->ALp_Next; + } else { + + /* + * Loop through checking all of the next values, if a match don't + * continue. Always assume the item will be found. + */ + while (ALp_findbefore->ALp_Next != ALp_del) { + ALp_findbefore = ALp_findbefore->ALp_Next; + } + + /* + * We are one item before the one to get rid of. Get rid of it. + */ + ALp_findbefore->ALp_Next = ALp_del->ALp_Next; + } +} + +/* + * Make the malloc-sequence available for debugging/tracing. + */ +#ifndef LYLeakSequence +long LYLeakSequence(void) +{ + return count_mallocs; +} +#endif + +/* + * Purpose: Print a report of all memory left unallocated by + * Lynx code or attempted unallocations on + * pointers that are not valid and then free + * all unfreed memory. + * Arguments: void + * Return Value: void + * Remarks/Portability/Dependencies/Restrictions: + * This function should be registered for execution with the + * atexit (stdlib.h) function as the first statement + * in main. + * All output of this function is sent to the file defined in + * the header LYLeaks.h (LEAKAGE_SINK). + */ +void LYLeaks(void) +{ + AllocationList *ALp_head; + size_t st_total = (size_t) 0; + FILE *Fp_leakagesink; + + CTRACE((tfp, "entering LYLeaks, flag=%d\n", LYfind_leaks)); + + if (LYfind_leaks == FALSE) { + /* + * Free MY leaks too, in case someone else is watching. + */ + while (ALp_RunTimeAllocations != NULL) { + ALp_head = ALp_RunTimeAllocations; + ALp_RunTimeAllocations = ALp_head->ALp_Next; + free(ALp_head); + } + return; + } + + /* + * Open the leakage sink to take all the output. Recreate the file each + * time. Do nothing if unable to open the file. + */ + Fp_leakagesink = LYNewTxtFile(LYLeaksPath); + if (Fp_leakagesink == NULL) { + return; + } + + while (ALp_RunTimeAllocations != NULL) { + /* + * Take the head off of the run time allocation list. + */ + ALp_head = ALp_RunTimeAllocations; + ALp_RunTimeAllocations = ALp_head->ALp_Next; + + /* + * Print the type of leak/error. Release memory when we no longer + * need it. + */ + if (ALp_head->vp_Alloced == NULL) { + /* + * If there is realloc information on the bad request, then it was + * a bad pointer value in a realloc statement. + */ + fprintf(Fp_leakagesink, "%s.\n", + gettext("Invalid pointer detected.")); + fprintf(Fp_leakagesink, "%s\t%ld\n", + gettext("Sequence:"), + ALp_head->st_Sequence); + fprintf(Fp_leakagesink, "%s\t%p\n", + gettext("Pointer:"), ALp_head->vp_BadRequest); + + /* + * Don't free the bad request, it is an invalid pointer. If the + * free source information is empty, we should check the realloc + * information too since it can get passed bad pointer values also. + */ + if (ALp_head->SL_memory.cp_FileName == NULL) { + fprintf(Fp_leakagesink, "%s\t%s\n", + gettext("FileName:"), + ALp_head->SL_realloc.cp_FileName); + fprintf(Fp_leakagesink, "%s\t%d\n", + gettext("LineCount:"), + ALp_head->SL_realloc.ssi_LineNumber); + } else { + fprintf(Fp_leakagesink, "%s\t%s\n", + gettext("FileName:"), + ALp_head->SL_memory.cp_FileName); + fprintf(Fp_leakagesink, "%s\t%d\n", + gettext("LineCount:"), + ALp_head->SL_memory.ssi_LineNumber); + } + } else { + size_t i_counter; + char *value = (char *) (ALp_head->vp_Alloced); + + /* + * Increment the count of total memory lost and then print the + * information. + */ + st_total += ALp_head->st_Bytes; + + fprintf(Fp_leakagesink, "%s\n", + gettext("Memory leak detected.")); + fprintf(Fp_leakagesink, "%s\t%ld\n", + gettext("Sequence:"), + ALp_head->st_Sequence); + fprintf(Fp_leakagesink, "%s\t%p\n", + gettext("Pointer:"), + ALp_head->vp_Alloced); + fprintf(Fp_leakagesink, "%s\t", + gettext("Contains:")); + for (i_counter = 0; + i_counter < ALp_head->st_Bytes && + i_counter < MAX_CONTENT_LENGTH; + i_counter++) { + if (isprint(UCH(value[i_counter]))) { + fprintf(Fp_leakagesink, "%c", value[i_counter]); + } else { + fprintf(Fp_leakagesink, "|"); + } + } + fprintf(Fp_leakagesink, "\n"); + fprintf(Fp_leakagesink, "%s\t%d\n", + gettext("ByteSize:"), + (int) (ALp_head->st_Bytes)); + fprintf(Fp_leakagesink, "%s\t%s\n", + gettext("FileName:"), + ALp_head->SL_memory.cp_FileName); + fprintf(Fp_leakagesink, "%s\t%d\n", + gettext("LineCount:"), + ALp_head->SL_memory.ssi_LineNumber); + /* + * Give the last time the pointer was realloced if it happened + * also. + */ + if (ALp_head->SL_realloc.cp_FileName != NULL) { + fprintf(Fp_leakagesink, "%s\t%s\n", + gettext("realloced:"), + ALp_head->SL_realloc.cp_FileName); + fprintf(Fp_leakagesink, "%s\t%d\n", + gettext("LineCount:"), + ALp_head->SL_realloc.ssi_LineNumber); + } + fflush(Fp_leakagesink); + FREE(ALp_head->vp_Alloced); + } + + /* + * Create a blank line and release the memory held by the item. + */ + fprintf(Fp_leakagesink, "\n"); + FREE(ALp_head); + } + + /* + * Give a grand total of the leakage. Close the output file. + */ + fprintf(Fp_leakagesink, "%s\t%u\n", + gettext("Total memory leakage this run:"), + (unsigned) st_total); +#ifdef LEAK_SUMMARY + fprintf(Fp_leakagesink, + "%s\t%lu\n", gettext("Peak allocation"), (unsigned long) peak_alloced); + fprintf(Fp_leakagesink, + "%s\t%lu\n", gettext("Bytes allocated"), (unsigned long) total_alloced); + fprintf(Fp_leakagesink, + "%s\t%ld\n", gettext("Total mallocs"), count_mallocs); + fprintf(Fp_leakagesink, + "%s\t%ld\n", gettext("Total frees"), count_frees); +#endif + fclose(Fp_leakagesink); + + HTSYS_purge(LEAKAGE_SINK); +} + +/* + * Purpose: Capture allocations using malloc (stdlib.h) and track + * the information in a list. + * Arguments: st_bytes The size of the allocation requested + * in bytes. + * cp_File The file from which the request for + * allocation came from. + * ssi_Line The line number in cp_File where the + * allocation request came from. + * Return Value: void * A pointer to the allocated memory or NULL on + * failure as per malloc (stdlib.h) + * Remarks/Portability/Dependencies/Restrictions: + * If no memory is allocated, then no entry is added to the + * allocation list. + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +void *LYLeakMalloc(size_t st_bytes, const char *cp_File, + const short ssi_Line) +{ + void *vp_malloc; + + if (LYfind_leaks == FALSE) { + vp_malloc = (void *) malloc(st_bytes); + } else { + + /* + * Do the actual allocation. + */ + vp_malloc = (void *) malloc(st_bytes); + CountMallocs(st_bytes); + + /* + * Only on successful allocation do we track any information. + */ + if (vp_malloc != NULL) { + /* + * Further allocate memory to store the information. Just return + * on failure to allocate more. + */ + AllocationList *ALp_new = typecalloc(AllocationList); + + if (ALp_new != NULL) { + /* + * Copy over the relevant information. There is no need to + * allocate more memory for the file name as it is a static + * string anyway. + */ + ALp_new->st_Sequence = count_mallocs; + ALp_new->vp_Alloced = vp_malloc; + ALp_new->st_Bytes = st_bytes; + ALp_new->SL_memory.cp_FileName = cp_File; + ALp_new->SL_memory.ssi_LineNumber = ssi_Line; + + /* + * Add the new item to the allocation list. + */ + AddToList(ALp_new); + } + } + } + return (vp_malloc); +} + +/* + * Purpose: Add information about new allocation to the list, + * after a call to malloc or calloc or an equivalent + * function which may or may not have already created + * a list entry. + * Arguments: vp_malloc The pointer to newly allocated memory. + * Arguments: st_bytes The size of the allocation requested + * in bytes. + * cp_File The file from which the request for + * allocation came from. + * ssi_Line The line number in cp_File where the + * allocation request came from. + * Return Value: void * A pointer to the allocated memory or NULL on + * failure. + * Remarks/Portability/Dependencies/Restrictions: + * If no memory is allocated, then no entry is added to the + * allocation list. + * Revision History: + * 1999-02-08 created, modelled after LYLeakMalloc - kw + */ +AllocationList *LYLeak_mark_malloced(void *vp_malloced, + size_t st_bytes, + const char *cp_File, + const short ssi_Line) +{ + AllocationList *ALp_new = NULL; + + if (LYfind_leaks != FALSE) { + /* + * The actual allocation has already been done! + * + * Only on successful allocation do we track any information. + */ + if (vp_malloced != NULL) { + /* + * See if there is already an entry. If so, just update the source + * location info. + */ + ALp_new = FindInList(vp_malloced); + if (ALp_new) { + ALp_new->SL_memory.cp_FileName = cp_File; + ALp_new->SL_memory.ssi_LineNumber = ssi_Line; + } else { + /* + * Further allocate memory to store the information. Just + * return on failure to allocate more. + */ + ALp_new = typecalloc(AllocationList); + if (ALp_new != NULL) { + /* + * Copy over the relevant information. + */ + ALp_new->vp_Alloced = vp_malloced; + ALp_new->st_Bytes = st_bytes; + ALp_new->SL_memory.cp_FileName = cp_File; + ALp_new->SL_memory.ssi_LineNumber = ssi_Line; + + /* + * Add the new item to the allocation list. + */ + AddToList(ALp_new); + CountMallocs(st_bytes); + } + } + } + } + return (ALp_new); +} + +/* + * Purpose: Capture allocations by calloc (stdlib.h) and + * save relevant information in a list. + * Arguments: st_number The number of items to allocate. + * st_bytes The size of each item. + * cp_File The file which wants to allocation. + * ssi_Line The line number in cp_File requesting + * the allocation. + * Return Value: void * The allocated memory, or NULL on failure as + * per calloc (stdlib.h) + * Remarks/Portability/Dependencies/Restrictions: + * If no memory can be allocated, then no entry will be added + * to the list. + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +void *LYLeakCalloc(size_t st_number, size_t st_bytes, const char *cp_File, + const short ssi_Line) +{ + void *vp_calloc; + + if (LYfind_leaks == FALSE) { + vp_calloc = (void *) calloc(st_number, st_bytes); + } else { + + /* + * Allocate the requested memory. + */ + vp_calloc = (void *) calloc(st_number, st_bytes); + CountMallocs(st_bytes * st_number); + + /* + * Only if the allocation was a success do we track information. + */ + if (vp_calloc != NULL) { + /* + * Allocate memory for the item to be in the list. If unable, just + * return. + */ + AllocationList *ALp_new = typecalloc(AllocationList); + + if (ALp_new != NULL) { + + /* + * Copy over the relevant information. There is no need to + * allocate memory for the file name as it is a static string + * anyway. + */ + ALp_new->st_Sequence = count_mallocs; + ALp_new->vp_Alloced = vp_calloc; + ALp_new->st_Bytes = (st_number * st_bytes); + ALp_new->SL_memory.cp_FileName = cp_File; + ALp_new->SL_memory.ssi_LineNumber = ssi_Line; + + /* + * Add the item to the allocation list. + */ + AddToList(ALp_new); + } + } + } + return (vp_calloc); +} + +/* + * Purpose: Capture any realloc (stdlib.h) calls in order to + * properly keep track of our run time allocation + * table. + * Arguments: vp_Alloced The previously allocated block of + * memory to resize. If NULL, + * realloc works just like + * malloc. + * st_newBytes The new size of the chunk of memory. + * cp_File The file containing the realloc. + * ssi_Line The line containing the realloc in cp_File. + * Return Value: void * The new pointer value (could be the same) or + * NULL if unable to resize (old block + * still exists). + * Remarks/Portability/Dependencies/Restrictions: + * If unable to resize vp_Alloced, then no change in the + * allocation list will be made. + * If vp_Alloced is an invalid pointer value, the program will + * exit after one last entry is added to the allocation list. + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +void *LYLeakRealloc(void *vp_Alloced, + size_t st_newBytes, + const char *cp_File, + const short ssi_Line) +{ + void *vp_realloc; + AllocationList *ALp_renew; + + if (LYfind_leaks == FALSE) { + vp_realloc = (void *) realloc(vp_Alloced, st_newBytes); + + } else if (vp_Alloced == NULL) { + /* + * If we are asked to resize a NULL pointer, this is just a malloc + * call. + */ + vp_realloc = LYLeakMalloc(st_newBytes, cp_File, ssi_Line); + + } else { + + /* + * Find the current vp_Alloced block in the list. If NULL, this is an + * invalid pointer value. + */ + ALp_renew = FindInList(vp_Alloced); + if (ALp_renew == NULL) { + /* + * Track the invalid pointer value and then exit. If unable to + * allocate, just exit. + */ + AllocationList *ALp_new = typecalloc(AllocationList); + + if (ALp_new == NULL) { + exit_immediately(EXIT_FAILURE); + } + + /* + * Set the information up; no need to allocate file name since it is a + * static string. + */ + ALp_new->vp_Alloced = NULL; + ALp_new->vp_BadRequest = vp_Alloced; + ALp_new->SL_realloc.cp_FileName = cp_File; + ALp_new->SL_realloc.ssi_LineNumber = ssi_Line; + + /* + * Add the item to the list. Exit. + */ + AddToList(ALp_new); + exit_immediately(EXIT_FAILURE); + } + + /* + * Perform the resize. If not NULL, record the information. + */ + vp_realloc = (void *) realloc(vp_Alloced, st_newBytes); + CountFrees(ALp_renew->st_Bytes); + CountMallocs(st_newBytes); + + if (vp_realloc != NULL) { + ALp_renew->st_Sequence = count_mallocs; + ALp_renew->vp_Alloced = vp_realloc; + ALp_renew->st_Bytes = st_newBytes; + + /* + * Update the realloc information, too. No need to allocate file name, + * static string. + */ + ALp_renew->SL_realloc.cp_FileName = cp_File; + ALp_renew->SL_realloc.ssi_LineNumber = ssi_Line; + } + } + return (vp_realloc); +} + +/* + * Purpose: Add information about reallocated memory to the list, + * after a call to realloc or an equivalent + * function which has not already created or updated + * a list entry. + * Arguments: ALp_old List entry for previously allocated + * block of memory to resize. If NULL, + * mark_realloced works just like + * mark_malloced. + * vp_realloced The new pointer, after resizing. + * st_newBytes The new size of the chunk of memory. + * cp_File The file to record. + * ssi_Line The line to record. + * Return Value: Pointer to new or updated list entry + * for this memory block. + * NULL on allocation error. + * Revision History: + * 1999-02-11 created kw + */ +#if defined(LY_FIND_LEAKS) && defined(LY_FIND_LEAKS_EXTENDED) +static AllocationList *mark_realloced(AllocationList * ALp_old, void *vp_realloced, + size_t st_newBytes, + const char *cp_File, + const short ssi_Line) +{ + /* + * If there is no list entry for the old allocation, treat this as if a new + * allocation had happened. + */ + if (ALp_old == NULL) { + return (LYLeak_mark_malloced(vp_realloced, st_newBytes, cp_File, ssi_Line)); + } + + /* + * ALp_old represents the memory block before reallocation. Assume that if + * we get here, there isn't yet a list entry for the new, possibly + * different, address after realloc, that is our list hasn't been updated - + * so we're going to do that now. + */ + + if (vp_realloced != NULL) { + ALp_old->vp_Alloced = vp_realloced; + ALp_old->st_Bytes = st_newBytes; + ALp_old->SL_realloc.cp_FileName = cp_File; + ALp_old->SL_realloc.ssi_LineNumber = ssi_Line; + } + + return (ALp_old); +} +#endif /* not LY_FIND_LEAKS and LY_FIND_LEAKS_EXTENDED */ + +/* + * Purpose: Capture all requests to free information and also + * remove items from the allocation list. + * Arguments: vp_Alloced The memory to free. + * cp_File The file calling free. + * ssi_Line The line of cp_File calling free. + * Return Value: void + * Remarks/Portability/Dependencies/Restrictions: + * If the pointer value is invalid, then an item will be added + * to the list and nothing else is done. + * I really like the name of this function and one day hope + * that Lynx is Leak Free. + * Revision History: + * 05-26-94 created Lynx 2-3-1 Garrett Arch Blythe + */ +void LYLeakFree(void *vp_Alloced, + const char *cp_File, + const short ssi_Line) +{ + AllocationList *ALp_free; + + if (LYfind_leaks == FALSE) { + free(vp_Alloced); + } else { + + /* + * Find the pointer in the allocated list. If not found, bad pointer. + * If found, free list item and vp_Alloced. + */ + ALp_free = FindInList(vp_Alloced); + if (ALp_free == NULL) { + /* + * Create the final entry before exiting marking this error. If + * unable to allocate more memory just exit. + */ + AllocationList *ALp_new = typecalloc(AllocationList); + + if (ALp_new == NULL) { + exit_immediately(EXIT_FAILURE); + } + + /* + * Set up the information, no memory need be allocated for the file + * name since it is a static string. + */ + ALp_new->vp_Alloced = NULL; + ALp_new->vp_BadRequest = vp_Alloced; + ALp_new->SL_memory.cp_FileName = cp_File; + ALp_new->SL_memory.ssi_LineNumber = ssi_Line; + + /* + * Add the entry to the list and then return. + */ + AddToList(ALp_new); + } else { + /* + * Free off the memory. Take entry out of allocation list. + */ + CountFrees(ALp_free->st_Bytes); + RemoveFromList(ALp_free); + FREE(ALp_free); + free(vp_Alloced); + } + } +} + +/* + * Check for leaked strdup() results -TD + */ +char *LYLeakStrdup(const char *source, + const char *cp_File, + const short ssi_Line) +{ + size_t length = strlen(source) + 1; + char *target = (char *) LYLeakMalloc(length, cp_File, ssi_Line); + + if (target != 0) { + memcpy(target, source, length); + } + return target; +} + +/* + * Allocates a new copy of a string, and returns it. + * Tracks allocations by using other LYLeakFoo functions. + * Equivalent to HTSACopy in HTString.c - KW + */ +char *LYLeakSACopy(char **dest, + const char *src, + const char *cp_File, + const short ssi_Line) +{ + if (src != NULL && src == *dest) { + CTRACE((tfp, + "LYLeakSACopy: *dest equals src, contains \"%s\"\n", + src)); + } else { + if (*dest) { + LYLeakFree(*dest, cp_File, ssi_Line); + *dest = NULL; + } + if (src) { + *dest = (char *) LYLeakMalloc(strlen(src) + 1, cp_File, ssi_Line); + if (*dest == NULL) + outofmem(__FILE__, "LYLeakSACopy"); + strcpy(*dest, src); + } + } + return *dest; +} + +/* + * String Allocate and Concatenate. + * Tracks allocations by using other LYLeakFoo functions. + * Equivalent to HTSACat in HTUtils.c - KW + */ +char *LYLeakSACat(char **dest, + const char *src, + const char *cp_File, + const short ssi_Line) +{ + if (src && *src) { + if (src == *dest) { + CTRACE((tfp, + "LYLeakSACat: *dest equals src, contains \"%s\"\n", + src)); + } else if (*dest) { + size_t length = strlen(*dest); + + *dest = (char *) LYLeakRealloc(*dest, + (length + strlen(src) + 1), + cp_File, + ssi_Line); + if (*dest == NULL) + outofmem(__FILE__, "LYLeakSACat"); + strcpy(*dest + length, src); + } else { + *dest = (char *) LYLeakMalloc((strlen(src) + 1), + cp_File, + ssi_Line); + if (*dest == NULL) + outofmem(__FILE__, "LYLeakSACat"); + strcpy(*dest, src); + } + } + return *dest; +} + +/******************************************************************************/ + +/* + * Equivalents for bstring functions in HTString.c -TD + */ +/* same as HTSABAlloc */ +void LYLeakSABAlloc(bstring **dest, + int len, + const char *cp_File, + const short ssi_Line) +{ + if (*dest == 0) { + *dest = LYLeakCalloc(1, sizeof(bstring), cp_File, ssi_Line); + } + + if ((*dest)->len != len) { + (*dest)->str = (char *) LYLeakRealloc((*dest)->str, + (size_t) len, + cp_File, + ssi_Line); + if ((*dest)->str == NULL) + outofmem(__FILE__, "LYLeakSABalloc"); + + (*dest)->len = len; + } +} + +/* same as HTSABCopy */ +void LYLeakSABCopy(bstring **dest, + const char *src, + int len, + const char *cp_File, + const short ssi_Line) +{ + bstring *t; + unsigned need = (unsigned) (len + 1); + + CTRACE2(TRACE_BSTRING, + (tfp, "HTSABCopy(%p, %p, %d)\n", + (void *) dest, (const void *) src, len)); + LYLeakSABFree(dest, cp_File, ssi_Line); + if (src) { + if (TRACE_BSTRING) { + CTRACE((tfp, "=== %4d:", len)); + trace_bstring2(src, len); + CTRACE((tfp, "\n")); + } + if ((t = (bstring *) LYLeakMalloc(sizeof(bstring), cp_File, ssi_Line)) + == NULL) + outofmem(__FILE__, "HTSABCopy"); + + if ((t->str = (char *) LYLeakMalloc(need, cp_File, ssi_Line)) == NULL) + outofmem(__FILE__, "HTSABCopy"); + + MemCpy(t->str, src, len); + t->len = len; + t->str[t->len] = '\0'; + *dest = t; + } + if (TRACE_BSTRING) { + CTRACE((tfp, "=> %4d:", BStrLen(*dest))); + trace_bstring(*dest); + CTRACE((tfp, "\n")); + } +} + +/* same as HTSABCopy0 */ +void LYLeakSABCopy0(bstring **dest, + const char *src, + const char *cp_File, + const short ssi_Line) +{ + LYLeakSABCopy(dest, src, (int) strlen(src), cp_File, ssi_Line); +} + +/* same as HTSABCat */ +void LYLeakSABCat(bstring **dest, + const char *src, + int len, + const char *cp_File, + const short ssi_Line) +{ + bstring *t = *dest; + + CTRACE2(TRACE_BSTRING, + (tfp, "HTSABCat(%p, %p, %d)\n", + (void *) dest, (const void *) src, len)); + if (src) { + unsigned need = (unsigned) (len + 1); + + if (TRACE_BSTRING) { + CTRACE((tfp, "=== %4d:", len)); + trace_bstring2(src, len); + CTRACE((tfp, "\n")); + } + if (t) { + unsigned length = (unsigned) t->len + need; + + t->str = (char *) LYLeakRealloc(t->str, length, cp_File, ssi_Line); + } else { + if ((t = (bstring *) LYLeakCalloc(1, sizeof(bstring), cp_File, + ssi_Line)) == NULL) + outofmem(__FILE__, "HTSACat"); + + t->str = (char *) LYLeakMalloc(need, cp_File, ssi_Line); + } + if (t->str == NULL) + outofmem(__FILE__, "HTSACat"); + + MemCpy(t->str + t->len, src, len); + t->len += len; + t->str[t->len] = '\0'; + *dest = t; + } + if (TRACE_BSTRING) { + CTRACE((tfp, "=> %4d:", BStrLen(*dest))); + trace_bstring(*dest); + CTRACE((tfp, "\n")); + } +} + +/* same as HTSABCat0 */ +void LYLeakSABCat0(bstring **dest, + const char *src, + const char *cp_File, + const short ssi_Line) +{ + LYLeakSABCat(dest, src, (int) strlen(src), cp_File, ssi_Line); +} + +/* same as HTSABFree */ +void LYLeakSABFree(bstring **ptr, + const char *cp_File, + const short ssi_Line) +{ + if (*ptr != NULL) { + if ((*ptr)->str) + LYLeakFree((*ptr)->str, cp_File, ssi_Line); + LYLeakFree(*ptr, cp_File, ssi_Line); + *ptr = NULL; + } +} + +/******************************************************************************/ + +#if defined(LY_FIND_LEAKS) && defined(LY_FIND_LEAKS_EXTENDED) + +const char *leak_cp_File_hack = __FILE__; +short leak_ssi_Line_hack = __LINE__; + +/* + * Purpose: A wrapper around StrAllocVsprintf (the workhorse of + * HTSprintf/HTSprintf0, implemented in HTString.c) that + * tries to make sure that our allocation list is always + * properly updated, whether StrAllocVsprintf itself was + * compiled with memory tracking or not (or even a mixture, + * like tracking the freeing but not the new allocation). + * Some source files can be compiled with LY_FIND_LEAKS_EXTENDED + * in effect while others only have LY_FIND_LEAKS in effect, + * and as long as HTString.c is complied with memory tracking + * (of either kind) string objects allocated by HTSprintf/ + * HTSprintf0 (or otherwise) can be passed around among them and + * manipulated both ways. + * Arguments: dest As for StrAllocVsprintf. + * cp_File The source file of the caller (i.e. the + * caller of HTSprintf/HTSprintf0, hopefully). + * ssi_Line The line of cp_File calling. + * inuse,fmt,ap As for StrAllocVsprintf. + * Return Value: The char pointer to resulting string, as set + * by StrAllocVsprintf, or + * NULL if dest==0 (wrong use!). + * Remarks/Portability/Dependencies/Restrictions: + * The price for generality is severe inefficiency: several + * list lookups are done to be on the safe side. + * We don't get the real allocation size, only a minimum based + * on the string length of the result. So the amount of memory + * leakage may get underestimated. + * If *dest is an invalid pointer value on entry (i.e. was not + * tracked), the program will exit after one last entry is added + * to the allocation list. + * If StrAllocVsprintf fails to return a valid string via the + * indirect string pointer (its first parameter), invalid memory + * access will result and the program will probably terminate + * with a signal. This can happen if, on entry, *dest is NULL + * and fmt is empty or NULL, so just Don't Do That. + * Revision History: + * 1999-02-11 created kw + * 1999-10-15 added comments kw + */ +static char *LYLeakSAVsprintf(char **dest, + const char *cp_File, + const short ssi_Line, + size_t inuse, + const char *fmt, + va_list * ap) +{ + AllocationList *ALp_old; + void *vp_oldAlloced; + + const char *old_cp_File = __FILE__; + short old_ssi_Line = __LINE__; + + if (!dest) + return NULL; + + if (LYfind_leaks == FALSE) { + StrAllocVsprintf(dest, inuse, fmt, ap); + return (*dest); + } + + vp_oldAlloced = *dest; + if (!vp_oldAlloced) { + StrAllocVsprintf(dest, inuse, fmt, ap); + LYLeak_mark_malloced(*dest, strlen(*dest) + 1, cp_File, ssi_Line); + return (*dest); + } else { + void *vp_realloced; + + ALp_old = FindInList(vp_oldAlloced); + if (ALp_old == NULL) { + /* + * Track the invalid pointer value and then exit. If unable to + * allocate, just exit. + */ + AllocationList *ALp_new = typecalloc(AllocationList); + + if (ALp_new == NULL) { + exit_immediately(EXIT_FAILURE); + } + + /* + * Set the information up; no need to allocate file name since it + * is a static string. + */ + ALp_new->vp_Alloced = NULL; + ALp_new->vp_BadRequest = vp_oldAlloced; + ALp_new->SL_realloc.cp_FileName = cp_File; + ALp_new->SL_realloc.ssi_LineNumber = ssi_Line; + + /* + * Add the item to the list. Exit. + */ + AddToList(ALp_new); + exit_immediately(EXIT_FAILURE); + } + + old_cp_File = ALp_old->SL_memory.cp_FileName; + old_ssi_Line = ALp_old->SL_memory.ssi_LineNumber; + /* + * DO THE REAL WORK, by calling StrAllocVsprintf. If result is not + * NULL, record the information. + */ + StrAllocVsprintf(dest, inuse, fmt, ap); + vp_realloced = (void *) *dest; + if (vp_realloced != NULL) { + AllocationList *ALp_new = FindInList(vp_realloced); + + if (!ALp_new) { + /* Look up again, list may have changed! - kw */ + ALp_old = FindInList(vp_oldAlloced); + if (ALp_old == NULL) { + LYLeak_mark_malloced(*dest, strlen(*dest) + 1, cp_File, ssi_Line); + return (*dest); + } + mark_realloced(ALp_old, *dest, strlen(*dest) + 1, cp_File, ssi_Line); + return (*dest); + } + ALp_new->SL_memory.cp_FileName = old_cp_File; + ALp_new->SL_memory.ssi_LineNumber = old_ssi_Line; + ALp_new->SL_realloc.cp_FileName = cp_File; + ALp_new->SL_realloc.ssi_LineNumber = ssi_Line; + } + return (*dest); + } +} + +/* Note: the following may need updating if HTSprintf in HTString.c + * is changed. - kw */ +static char *LYLeakHTSprintf(char **pstr, const char *fmt, ...) +{ + char *str; + size_t inuse = 0; + va_list ap; + + LYva_start(ap, fmt); + + if (pstr != 0 && *pstr != 0) + inuse = strlen(*pstr); + str = LYLeakSAVsprintf(pstr, leak_cp_File_hack, leak_ssi_Line_hack, + inuse, fmt, &ap); + + va_end(ap); + return str; +} + +/* Note: the following may need updating if HTSprintf0 in HTString.c + * is changed. - kw */ +static char *LYLeakHTSprintf0(char **pstr, const char *fmt, ...) +{ + char *str; + va_list ap; + + LYva_start(ap, fmt); + + str = LYLeakSAVsprintf(pstr, leak_cp_File_hack, leak_ssi_Line_hack, + 0, fmt, &ap); + + va_end(ap); + return str; +} + +/* + * HTSprintf and HTSprintf0 will be defined such that they effectively call one + * of the following two functions that store away a copy to the File & Line + * info in temporary hack variables, and then call the real function (which is + * returned here as a function pointer) to the regular HTSprintf/HTSprintf0 + * arguments. It's probably a bit inefficient, but that shouldn't be + * noticeable compared to all the time that memory tracking takes up for list + * traversal. - kw + */ +HTSprintflike *Get_htsprintf_fn(const char *cp_File, + const short ssi_Line) +{ + leak_cp_File_hack = cp_File; + leak_ssi_Line_hack = ssi_Line; + return &LYLeakHTSprintf; +} + +HTSprintflike *Get_htsprintf0_fn(const char *cp_File, + const short ssi_Line) +{ + leak_cp_File_hack = cp_File; + leak_ssi_Line_hack = ssi_Line; + return &LYLeakHTSprintf0; +} + +#endif /* LY_FIND_LEAKS and LY_FIND_LEAKS_EXTENDED */ +#else +/* Standard C forbids an empty file */ +void no_leak_checking(void); +void no_leak_checking(void) +{ +} +#endif /* LY_FIND_LEAKS */ |