modules/ut/memwrap.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. UT_memory_log
  2. UT_alloc_log
  3. UT_free_log
  4. wr_free_list_log
  5. UT_memory_log
  6. UT_alloc_log
  7. UT_free_log
  8. UT_free_list_log
  9. UT_malloc_real
  10. UT_calloc_real
  11. UT_realloc_real
  12. UT_free_real
  13. UT_strdup_real
  14. wr_log_set
  15. wr_real_malloc
  16. wr_real_calloc
  17. wr_real_realloc
  18. wr_real_free
  19. wr_real_string
  20. wr_free_list_element
  21. wr_real_clear_list

   1 /***************************************
   2   $Revision: 1.11 $
   3 
   4   Utilities (ut). memwrap.c - memory allocation wrappers. 
   5                               Facilitate easy changing a memory allocation
   6                               library and provide uniform error codes.
   7 
   8   Status: NOT REVUED, TESTED, 
   9 
  10   Design and implementation by: Marek Bukowy
  11 
  12   ******************/ /******************
  13   Copyright (c) 1999                              RIPE NCC
  14  
  15   All Rights Reserved
  16   
  17   Permission to use, copy, modify, and distribute this software and its
  18   documentation for any purpose and without fee is hereby granted,
  19   provided that the above copyright notice appear in all copies and that
  20   both that copyright notice and this permission notice appear in
  21   supporting documentation, and that the name of the author not be
  22   used in advertising or publicity pertaining to distribution of the
  23   software without specific, written prior permission.
  24   
  25   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
  27   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  28   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  29   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  30   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  31   ***************************************/
  32 
  33 #include <stdlib.h>
  34 #include <erroutines.h>
  35 #include <stubs.h>
  36 #include <glib.h>
  37 
  38 #define USE_LOGGING
  39 
  40 #ifdef USE_LOGGING
  41 /* flag whether logging now active */
  42 static int UT_memory_logging = 0;
  43 
  44 void 
  45 UT_memory_log (int active) 
     /* [<][>][^][v][top][bottom][index][help] */
  46 {
  47     if (active) {
  48         UT_memory_logging = 1;
  49     } else {
  50         UT_memory_logging = 0;
  51     }
  52 }
  53 
  54 static void
  55 UT_alloc_log (const void *ptr, int len, const char* file, int line) 
     /* [<][>][^][v][top][bottom][index][help] */
  56 {
  57     if (UT_memory_logging) {
  58         ER_dbg_va(FAC_UT, ASP_UT_MEM, 
  59             "allocated %d bytes at address %p in %s:%d",
  60             len, ptr, file, line);
  61     }
  62 }
  63 
  64 static void
  65 UT_free_log (const void *ptr, const char* file, int line) 
     /* [<][>][^][v][top][bottom][index][help] */
  66 {
  67     if (UT_memory_logging) {
  68         ER_dbg_va(FAC_UT, ASP_UT_MEM, 
  69             "freed memory at address %p in %s:%d", 
  70             ptr, file, line); 
  71     }
  72 }
  73 
  74 static void
  75 wr_free_list_log (const void *ptr, const char* file, int line) 
     /* [<][>][^][v][top][bottom][index][help] */
  76 {
  77     if (UT_memory_logging) {
  78         ER_dbg_va(FAC_UT, ASP_UT_MEM,
  79             "freeing list and elements at address %p in %s:%d", 
  80             ptr, file, line); 
  81     }
  82 }
  83 #else
  84 
  85 void 
  86 UT_memory_log (int active)
     /* [<][>][^][v][top][bottom][index][help] */
  87 {
  88     ER_perror(FAC_UT, UT_NOMEMLOG, 
  89         "logging not supported, recompile %s to enable", __FILE__);
  90 }
  91 
  92 /* if logging is disabled, then these functions are NOOP's */
  93 #define UT_alloc_log(ptr,len,file,line)
     /* [<][>][^][v][top][bottom][index][help] */
  94 #define UT_free_log(ptr,file,line) 
     /* [<][>][^][v][top][bottom][index][help] */
  95 #define UT_free_list_log(ptr,file,line) 
     /* [<][>][^][v][top][bottom][index][help] */
  96 
  97 #endif /* USE_LOGGING */
  98 
  99 void *
 100 UT_malloc_real (size_t size, const char *file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 101 {
 102     void *ptr;
 103 
 104     ptr = malloc(size);
 105     if (ptr == NULL) {
 106         ER_perror(FAC_UT, UT_OUTMEM, 
 107             "malloc(%u) out of memory at %s:%d", size, file, line);
 108         die;
 109     }
 110     UT_alloc_log(ptr, size, file, line); 
 111     return ptr;
 112 }
 113 
 114 void *
 115 UT_calloc_real (size_t num, size_t size, const char *file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 116 {
 117     void *ptr;
 118 
 119     ptr = calloc(num, size);
 120     if (ptr == NULL) {
 121         ER_perror(FAC_UT, UT_OUTMEM, 
 122             "calloc(%u, %u) out of memory at %s:%d", num, size, file, line);
 123         die; 
 124     }
 125     UT_alloc_log(ptr, size * num, file, line);
 126     return ptr;
 127 }
 128 
 129 void *
 130 UT_realloc_real (void *ptr, size_t size, const char *file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 131 {
 132     char *tmp_ptr;
 133     
 134     tmp_ptr = realloc(ptr, size);
 135     if (tmp_ptr == NULL ) {
 136         ER_perror(FAC_UT, UT_OUTMEM, 
 137             "realloc(%p, %u) out of memory at %s:%d", ptr, size, file, line);
 138         die; 
 139     } 
 140     UT_free_log(ptr, file, line);
 141     UT_alloc_log(tmp_ptr, size, file, line);
 142     return tmp_ptr;
 143 }
 144 
 145 void 
 146 UT_free_real (void *ptr, const char *file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 147 {
 148     dieif(ptr == NULL);
 149     free(ptr);
 150     UT_free_log(ptr, file, line); 
 151 }
 152 
 153 char *
 154 UT_strdup_real (const char *str, const char *file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 155 {
 156     char *area;
 157 
 158     area = UT_malloc_real(strlen(str) + 1, file, line);
 159     strcpy(area, str);
 160     
 161     return area;
 162 }
 163 
 164 
 165 /* legacy functions */
 166 
 167 void 
 168 wr_log_set (int value) 
     /* [<][>][^][v][top][bottom][index][help] */
 169 {
 170     UT_memory_log(value);
 171 }
 172 
 173 er_ret_t 
 174 wr_real_malloc (void **ptr, size_t size, const char* file, int line) 
     /* [<][>][^][v][top][bottom][index][help] */
 175 {
 176     *ptr = UT_malloc_real(size, file, line);
 177     return UT_OK;
 178 }
 179 
 180 er_ret_t 
 181 wr_real_calloc (void **ptr, size_t num, size_t size, const char* file, 
     /* [<][>][^][v][top][bottom][index][help] */
 182                 int line) 
 183 {
 184     *ptr = UT_calloc_real(num, size, file, line);
 185     return UT_OK;
 186 }
 187 
 188 
 189 er_ret_t  
 190 wr_real_realloc (void **ptr, size_t size, const char* file, int line) 
     /* [<][>][^][v][top][bottom][index][help] */
 191 {
 192     *ptr = UT_realloc_real(*ptr, size, file, line);
 193     return UT_OK;
 194 }
 195 
 196 er_ret_t 
 197 wr_real_free (void *ptr, const char* file, int line) 
     /* [<][>][^][v][top][bottom][index][help] */
 198 {
 199     UT_free_real(ptr, file, line);
 200     return UT_OK;
 201 }
 202 
 203 
 204 /* make a copy and return the pointer to the allocated area, like strdup() */
 205 char *
 206 wr_real_string (const char *text, const char *file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 207 {
 208     return UT_strdup_real(text, file, line);
 209 }
 210 
 211 /* for GList's foreach */
 212 static
 213 void
 214 wr_free_list_element (void *cpy, void *trash)
     /* [<][>][^][v][top][bottom][index][help] */
 215 {
 216     wr_real_free(cpy, __FILE__, __LINE__);
 217 }
 218 
 219 /* for GList's foreach */
 220 void
 221 wr_real_clear_list (GList **list, const char* file, int line)
     /* [<][>][^][v][top][bottom][index][help] */
 222 {
 223     /* allow NULL argument */
 224     if( *list != NULL ) {
 225         wr_free_list_log(*list, file, line); 
 226         g_list_foreach(*list, wr_free_list_element, NULL);
 227         g_list_free(*list);
 228         *list = NULL;
 229     }
 230 }
 231 

/* [<][>][^][v][top][bottom][index][help] */