git.meshlink.io Git - catta/blob - avahi/malloc.c

   1 /***
   2   This file is part of avahi.
   3
   4   avahi is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU Lesser General Public License as
   6   published by the Free Software Foundation; either version 2.1 of the
   7   License, or (at your option) any later version.
   8
   9   avahi is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  12   Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public
  15   License along with avahi; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  17   USA.
  18 ***/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <assert.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29
  30 #include "malloc.h"
  31
  32 #ifndef va_copy
  33 #ifdef __va_copy
  34 #define va_copy(DEST,SRC) __va_copy((DEST),(SRC))
  35 #else
  36 #define va_copy(DEST,SRC) memcpy(&(DEST), &(SRC), sizeof(va_list))
  37 #endif
  38 #endif
  39
  40 static const AvahiAllocator *allocator = NULL;
  41
  42 static void oom(void) AVAHI_GCC_NORETURN;
  43
  44 static void oom(void) {
  45
  46     static const char msg[] = "Out of memory, aborting ...\n";
  47     const char *n = msg;
  48
  49     while (strlen(n) > 0) {
  50         ssize_t r;
  51
  52         if ((r = write(2, n, strlen(n))) < 0)
  53             break;
  54
  55         n += r;
  56     }
  57
  58     abort();
  59 }
  60
  61 /* Default implementation for avahi_malloc() */
  62 static void* xmalloc(size_t size) {
  63     void *p;
  64
  65     if (size == 0)
  66         return NULL;
  67
  68     if (!(p = malloc(size)))
  69         oom();
  70
  71     return p;
  72 }
  73
  74 /* Default implementation for avahi_realloc() */
  75 static void *xrealloc(void *p, size_t size) {
  76
  77     if (size == 0) {
  78         free(p);
  79         return NULL;
  80     }
  81
  82     if (!(p = realloc(p, size)))
  83         oom();
  84
  85     return p;
  86 }
  87
  88 /* Default implementation for avahi_calloc() */
  89 static void *xcalloc(size_t nmemb, size_t size) {
  90     void *p;
  91
  92     if (size == 0 || nmemb == 0)
  93         return NULL;
  94
  95     if (!(p = calloc(nmemb, size)))
  96         oom();
  97
  98     return p;
  99 }
 100
 101 void *avahi_malloc(size_t size) {
 102
 103     if (size <= 0)
 104         return NULL;
 105
 106     if (!allocator)
 107         return xmalloc(size);
 108
 109     assert(allocator->malloc);
 110     return allocator->malloc(size);
 111 }
 112
 113 void *avahi_malloc0(size_t size) {
 114     void *p;
 115
 116     if (size <= 0)
 117         return NULL;
 118
 119     if (!allocator)
 120         return xcalloc(1, size);
 121
 122     if (allocator->calloc)
 123         return allocator->calloc(1, size);
 124
 125     assert(allocator->malloc);
 126     if ((p = allocator->malloc(size)))
 127         memset(p, 0, size);
 128
 129     return p;
 130 }
 131
 132 void avahi_free(void *p) {
 133
 134     if (!p)
 135         return;
 136
 137     if (!allocator) {
 138         free(p);
 139         return;
 140     }
 141
 142     assert(allocator->free);
 143     allocator->free(p);
 144 }
 145
 146 void *avahi_realloc(void *p, size_t size) {
 147
 148     if (size == 0) {
 149         avahi_free(p);
 150         return NULL;
 151     }
 152
 153     if (!allocator)
 154         return xrealloc(p, size);
 155
 156     assert(allocator->realloc);
 157     return allocator->realloc(p, size);
 158 }
 159
 160 char *avahi_strdup(const char *s) {
 161     char *r;
 162     size_t size;
 163
 164     if (!s)
 165         return NULL;
 166
 167     size = strlen(s);
 168     if (!(r = avahi_malloc(size+1)))
 169         return NULL;
 170
 171     memcpy(r, s, size+1);
 172     return r;
 173 }
 174
 175 char *avahi_strndup(const char *s, size_t max) {
 176     char *r;
 177     size_t size;
 178     const char *p;
 179
 180     if (!s)
 181         return NULL;
 182
 183     for (p = s, size = 0;
 184          size < max && *p;
 185          p++, size++);
 186
 187     if (!(r = avahi_new(char, size+1)))
 188         return NULL;
 189
 190     memcpy(r, s, size);
 191     r[size] = 0;
 192     return r;
 193 }
 194
 195 /* Change the allocator */
 196 void avahi_set_allocator(const AvahiAllocator *a) {
 197     allocator = a;
 198 }
 199
 200 char *avahi_strdup_vprintf(const char *fmt, va_list ap) {
 201     size_t len = 80;
 202     char *buf;
 203
 204     assert(fmt);
 205
 206     if (!(buf = avahi_malloc(len)))
 207         return NULL;
 208
 209     for (;;) {
 210         int n;
 211         char *nbuf;
 212         va_list ap2;
 213
 214         va_copy (ap2, ap);
 215         n = vsnprintf(buf, len, fmt, ap2);
 216         va_end (ap2);
 217
 218         if (n >= 0 && n < (int) len)
 219             return buf;
 220
 221         if (n >= 0)
 222             len = n+1;
 223         else
 224             len *= 2;
 225
 226         if (!(nbuf = avahi_realloc(buf, len))) {
 227             avahi_free(buf);
 228             return NULL;
 229         }
 230
 231         buf = nbuf;
 232     }
 233 }
 234
 235 char *avahi_strdup_printf(const char *fmt, ... ) {
 236     char *s;
 237     va_list ap;
 238
 239     assert(fmt);
 240
 241     va_start(ap, fmt);
 242     s = avahi_strdup_vprintf(fmt, ap);
 243     va_end(ap);
 244
 245     return s;
 246 }
 247
 248 void *avahi_memdup(const void *s, size_t l) {
 249     void *p;
 250     assert(s);
 251
 252     if (!(p = avahi_malloc(l)))
 253         return NULL;
 254
 255     memcpy(p, s, l);
 256     return p;
 257 }