src/mem.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2009 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02110-1301  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <err.h>
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include "gettext.h"
  31 #define N_(msgid)       gettext(msgid)
  32
  33 #include "mem.h"
  34
  35 static struct memlist_s *memlist;
  36 #ifdef DEBUG
  37 static size_t allocations, deallocations;
  38 #endif
  39
  40 static int memlist_remove(void *ptr, const char *func)
  41 {
  42     struct memlist_s *m, *last = NULL, *p;
  43     int found = 0;
  44
  45     for (m = memlist; m; m = m->next) {
  46         if (m->ptr == ptr) {
  47 #ifdef DEBUG
  48             fprintf(stderr, "%s: %p %i\n", func, ptr, m->size);
  49 #endif
  50             found = 1;
  51             memset(m->ptr, 0, m->size);
  52             free(m->ptr);
  53
  54             p = m->next;
  55             free(m);
  56 #ifdef DEBUG
  57             deallocations++;
  58 #endif
  59
  60             if (last) {
  61                 if (p)
  62                     last->next = p;
  63                 else
  64                     last->next = NULL;
  65             }
  66             else if (p)
  67                 memlist = p;
  68             else
  69                 memlist = NULL;
  70
  71             break;
  72         }
  73
  74         last = m;
  75     }
  76
  77     return found;
  78 }
  79
  80 static void memlist_prepend(struct memlist_s *new)
  81 {
  82 #ifdef DEBUG
  83     allocations++;
  84 #endif
  85     new->next = memlist;
  86     memlist = new;
  87 }
  88
  89 void xfree(void *ptr)
  90 {
  91     if (!ptr)
  92         return;
  93
  94     if (!memlist_remove(ptr, __FUNCTION__)) {
  95         warnx(N_("%s: %p not found"), __FUNCTION__, ptr);
  96         assert(0);
  97     }
  98 }
  99
 100 void *xmalloc(size_t size)
 101 {
 102     void *p;
 103     struct memlist_s *m;
 104
 105     if (size <= 0)
 106         return NULL;
 107
 108     if ((m = (struct memlist_s *)malloc(sizeof(struct memlist_s))) == NULL)
 109         return NULL;
 110
 111     if ((p = malloc(size)) == NULL) {
 112         free(m);
 113         return NULL;
 114     }
 115
 116     m->ptr = p;
 117     m->size = size;
 118     memlist_prepend(m);
 119 #ifdef DEBUG
 120     fprintf(stderr, "%s: %p %i\n", __FUNCTION__, p, size);
 121 #endif
 122     return m->ptr;
 123 }
 124
 125 void *xcalloc(size_t nmemb, size_t size)
 126 {
 127     void *p;
 128     struct memlist_s *m;
 129
 130     if (size <= 0)
 131         return NULL;
 132
 133     if ((m = (struct memlist_s *)malloc(sizeof(struct memlist_s))) == NULL)
 134         return NULL;
 135
 136     if ((p = calloc(nmemb, size)) == NULL) {
 137         free(m);
 138         return NULL;
 139     }
 140
 141     m->ptr = p;
 142     m->size = nmemb * size;
 143     memlist_prepend(m);
 144 #ifdef DEBUG
 145     fprintf(stderr, "%s: %p %i\n", __FUNCTION__, p, nmemb * size);
 146 #endif
 147     return m->ptr;
 148 }
 149
 150 void *xrealloc(void *ptr, size_t size)
 151 {
 152     void *p;
 153     struct memlist_s *m;
 154
 155     if (!ptr)
 156         return xmalloc(size);
 157
 158     if (size <= 0)
 159         return ptr;
 160
 161     for (m = memlist; m; m = m->next) {
 162         if (m->ptr == ptr) {
 163             if ((p = malloc(size)) == NULL)
 164                 return NULL;
 165
 166             memcpy(p, m->ptr, size < m->size ? size : m->size);
 167             memset(m->ptr, 0, m->size);
 168             free(m->ptr);
 169             m->ptr = p;
 170             m->size = size;
 171 #ifdef DEBUG
 172             fprintf(stderr, "%s: %p %i\n", __FUNCTION__, p, size);
 173 #endif
 174             return m->ptr;
 175         }
 176     }
 177
 178     warnx(N_("%s: %p not found"), __FUNCTION__, ptr);
 179     assert(0);
 180     return NULL;
 181 }
 182
 183 char *xstrdup(const char *str)
 184 {
 185     char *t, *tp;
 186     size_t len;
 187     const char *p;
 188
 189     if (!str)
 190         return NULL;
 191
 192     len = strlen(str) + 1;
 193
 194     if ((t = (char *)xmalloc(len * sizeof(char))) == NULL)
 195         return NULL;
 196
 197     for (p = str, tp = t; *p; p++)
 198         *tp++ = *p;
 199
 200     *tp = 0;
 201 #ifdef DEBUG
 202     fprintf(stderr, "%s: %p\n", __FUNCTION__, t);
 203 #endif
 204     return t;
 205 }
 206
 207 void xpanic(void)
 208 {
 209     struct memlist_s *m;
 210
 211     for (m = memlist; m; m = memlist)
 212        xfree(m->ptr);
 213 }
 214
 215 #ifdef DEBUG
 216 void xdump(void)
 217 {
 218     struct memlist_s *m;
 219     size_t total = 0;
 220
 221     for (m = memlist; m; m = m->next) {
 222         fprintf(stderr, "%s: %p %i\n", __FUNCTION__, m->ptr, m->size);
 223         total += m->size;
 224     }
 225
 226     fprintf(stderr, "Total unfreed: %i bytes, allocations: %i, deallocations: %i\n", total,
 227             allocations, deallocations);
 228 }
 229 #endif