mem.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2007 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  02111-1307  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
  37 static struct memlist_s *memlist_remove(struct memlist_s *list, struct memlist_s *r)
  38 {
  39     struct memlist_s *m, *last = NULL, *p;
  40
  41     for (m = list; m; m = m->next) {
  42         if (m->ptr == r->ptr) {
  43             memset(m->ptr, 0, m->size);
  44             free(m->ptr);
  45
  46             if (RUNNING_ON_VALGRIND)
  47                 VALGRIND_FREELIKE_BLOCK(m->ptr, 0);
  48
  49             p = m->next;
  50             free(m);
  51
  52             if (RUNNING_ON_VALGRIND)
  53                 VALGRIND_FREELIKE_BLOCK(m, 0);
  54
  55             if (last) {
  56                 if (p)
  57                     last->next = p;
  58                 else
  59                     last->next = NULL;
  60             }
  61             else if (p)
  62                 list = p;
  63             else
  64                 list = NULL;
  65
  66             break;
  67         }
  68
  69         last = m;
  70     }
  71
  72     return list;
  73 }
  74
  75 static struct memlist_s *memlist_append(struct memlist_s *list, struct memlist_s *p)
  76 {
  77     struct memlist_s *m;
  78
  79     if (!list) {
  80         list = p;
  81         list->next = NULL;
  82         return list;
  83     }
  84
  85     for (m = list; m; m = m->next) {
  86         if (!m->next) {
  87             m->next = p;
  88             m = m->next;
  89             m->next = NULL;
  90             break;
  91         }
  92     }
  93
  94     return list;
  95 }
  96
  97 void xfree(void *ptr)
  98 {
  99     struct memlist_s *m;
 100
 101     if (!ptr)
 102         return;
 103
 104     for (m = memlist; m; m = m->next) {
 105         if (m->ptr == ptr) {
 106 #ifdef DEBUG
 107             fprintf(stderr, "xfree(): %p %i\n", ptr, m->size);
 108 #endif
 109             memlist = memlist_remove(memlist, m);
 110             return;
 111         }
 112     }
 113
 114     warnx("xfree(): %p %s:", ptr, N_("not found"));
 115     assert(0);
 116 }
 117
 118 void *xmalloc(size_t size)
 119 {
 120     void *p;
 121     struct memlist_s *m;
 122
 123     if (size <= 0)
 124         return NULL;
 125
 126     if ((m = (struct memlist_s *)malloc(sizeof(struct memlist_s))) == NULL)
 127         return NULL;
 128
 129     if (RUNNING_ON_VALGRIND)
 130         VALGRIND_MALLOCLIKE_BLOCK(m, sizeof(struct memlist_s), 0, 0);
 131
 132     if ((p = malloc(size)) == NULL) {
 133         free(m);
 134
 135         if (RUNNING_ON_VALGRIND)
 136             VALGRIND_FREELIKE_BLOCK(m, 0);
 137
 138         return NULL;
 139     }
 140
 141     if (RUNNING_ON_VALGRIND)
 142         VALGRIND_MALLOCLIKE_BLOCK(p, size, 0, 0);
 143
 144     m->ptr = p;
 145     m->size = size;
 146     memlist = memlist_append(memlist, m);
 147 #ifdef DEBUG
 148     fprintf(stderr, "xmalloc(): %p %i\n", p, size);
 149 #endif
 150     return m->ptr;
 151 }
 152
 153 void *xcalloc(size_t nmemb, size_t size)
 154 {
 155     void *p;
 156     struct memlist_s *m;
 157
 158     if (size <= 0)
 159         return NULL;
 160
 161     if ((m = (struct memlist_s *)malloc(sizeof(struct memlist_s))) == NULL)
 162         return NULL;
 163
 164     if (RUNNING_ON_VALGRIND)
 165         VALGRIND_MALLOCLIKE_BLOCK(m, sizeof(struct memlist_s), 0, 0);
 166
 167     if ((p = calloc(nmemb, size)) == NULL) {
 168         free(m);
 169
 170         if (RUNNING_ON_VALGRIND)
 171             VALGRIND_FREELIKE_BLOCK(m, 0);
 172
 173         return NULL;
 174     }
 175
 176     if (RUNNING_ON_VALGRIND)
 177         VALGRIND_MALLOCLIKE_BLOCK(p, nmemb * size, 0, 1);
 178
 179     m->ptr = p;
 180     m->size = nmemb * size;
 181     memlist = memlist_append(memlist, m);
 182 #ifdef DEBUG
 183     fprintf(stderr, "xcalloc(): %p %i\n", p, nmemb * size);
 184 #endif
 185     return m->ptr;
 186 }
 187
 188 void *xrealloc(void *ptr, size_t size)
 189 {
 190     void *p;
 191     struct memlist_s *m;
 192
 193     if (!ptr)
 194         return xmalloc(size);
 195
 196     if (size <= 0)
 197         return ptr;
 198
 199     for (m = memlist; m; m = m->next) {
 200         if (m->ptr == ptr) {
 201             if ((p = malloc(size)) == NULL)
 202                 return NULL;
 203
 204             if (RUNNING_ON_VALGRIND)
 205                 VALGRIND_MALLOCLIKE_BLOCK(p, size, 0, 0);
 206
 207             memcpy(p, m->ptr, size < m->size ? size : m->size);
 208             memset(m->ptr, 0, m->size);
 209             free(m->ptr);
 210
 211             if (RUNNING_ON_VALGRIND)
 212                 VALGRIND_FREELIKE_BLOCK(m->ptr, 0);
 213
 214             m->ptr = p;
 215             m->size = size;
 216 #ifdef DEBUG
 217             fprintf(stderr, "xrealloc(): %p %i\n", p, size);
 218 #endif
 219             return m->ptr;
 220         }
 221     }
 222
 223     warnx("xrealloc(): %p %s", ptr, N_("not found"));
 224     assert(0);
 225     return NULL;
 226 }
 227
 228 char *xstrdup(const char *str)
 229 {
 230     char *t, *tp;
 231     size_t len;
 232     const char *p;
 233
 234     if (!str)
 235         return NULL;
 236
 237     len = strlen(str) + 1;
 238
 239     if ((t = (char *)xmalloc(len * sizeof(char))) == NULL)
 240         return NULL;
 241
 242     for (p = str, tp = t; *p; p++)
 243         *tp++ = *p;
 244
 245     *tp = 0;
 246 #ifdef DEBUG
 247     fprintf(stderr, "xstrdup(): %p\n", t);
 248 #endif
 249     return t;
 250 }
 251
 252 void xpanic(void)
 253 {
 254     struct memlist_s *m;
 255
 256     for (m = memlist; m; m = memlist)
 257        xfree(m->ptr);
 258 }