src/xmalloc.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2009, 2010, 2011, 2012 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <stdarg.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <signal.h>
  15 #include <limits.h>
  16 #include <sys/types.h>
  17
  18 #include "xmalloc.h"
  19 #include "xstring.h"
  20 #include "built_in.h"
  21 #include "die.h"
  22
  23 __hidden void *xmalloc(size_t size)
  24 {
  25         void *ptr;
  26
  27         if (unlikely(size == 0))
  28                 panic("xmalloc: zero size\n");
  29
  30         ptr = malloc(size);
  31         if (unlikely(ptr == NULL))
  32                 panic("xmalloc: out of memory (allocating %zu bytes)\n",
  33                       size);
  34
  35         return ptr;
  36 }
  37
  38 __hidden void *xzmalloc(size_t size)
  39 {
  40         void *ptr = xmalloc(size);
  41         memset(ptr, 0, size);
  42         return ptr;
  43 }
  44
  45 __hidden void *xmalloc_aligned(size_t size, size_t alignment)
  46 {
  47         int ret;
  48         void *ptr;
  49
  50         if (unlikely(size == 0))
  51                 panic("xmalloc_aligned: zero size\n");
  52
  53         ret = posix_memalign(&ptr, alignment, size);
  54         if (unlikely(ret != 0))
  55                 panic("xmalloc_aligned: out of memory (allocating %zu "
  56                       "bytes)\n", size);
  57
  58         return ptr;
  59 }
  60
  61 __hidden void *xzmalloc_aligned(size_t size, size_t alignment)
  62 {
  63         void *ptr = xmalloc_aligned(size, alignment);
  64         memset(ptr, 0, size);
  65         return ptr;
  66 }
  67
  68 __hidden void *xmallocz(size_t size)
  69 {
  70         void *ptr;
  71
  72         if (unlikely(size + 1 < size))
  73                 panic("xmallocz: data too large to fit into virtual "
  74                       "memory space\n");
  75
  76         ptr = xmalloc(size + 1);
  77         ((char*) ptr)[size] = 0;
  78
  79         return ptr;
  80 }
  81
  82 __hidden void *xmemdupz(const void *data, size_t len)
  83 {
  84         return memcpy(xmallocz(len), data, len);
  85 }
  86
  87 __hidden void *xrealloc(void *ptr, size_t nmemb, size_t size)
  88 {
  89         void *new_ptr;
  90         size_t new_size = nmemb * size;
  91
  92         if (unlikely(new_size == 0))
  93                 panic("xrealloc: zero size\n");
  94         if (unlikely(((size_t) ~0) / nmemb < size))
  95                 panic("xrealloc: nmemb * size > SIZE_T_MAX\n");
  96
  97         if (ptr == NULL)
  98                 new_ptr = malloc(new_size);
  99         else
 100                 new_ptr = realloc(ptr, new_size);
 101
 102         if (unlikely(new_ptr == NULL))
 103                 panic("xrealloc: out of memory (new_size %zu bytes)\n",
 104                       new_size);
 105
 106         return new_ptr;
 107 }
 108
 109 __hidden void xfree_func(void *ptr)
 110 {
 111         if (unlikely(ptr == NULL))
 112                 panic("xfree: NULL pointer given as argument\n");
 113
 114         free(ptr);
 115 }
 116
 117 __hidden char *xstrdup(const char *str)
 118 {
 119         size_t len;
 120         char *cp;
 121
 122         len = strlen(str) + 1;
 123         cp = xmalloc(len);
 124
 125         strlcpy(cp, str, len);
 126
 127         return cp;
 128 }
 129
 130 __hidden char *xstrndup(const char *str, size_t size)
 131 {
 132         size_t len;
 133         char *cp;
 134
 135         len = strlen(str) + 1;
 136         if (size < len)
 137                 len = size;
 138
 139         cp = xmalloc(len);
 140
 141         strlcpy(cp, str, len);
 142
 143         return cp;
 144 }
 145
 146 __hidden int xdup(int fd)
 147 {
 148         int ret = dup(fd);
 149         if (unlikely(ret < 0))
 150                 panic("xdup: dup failed\n");
 151         return ret;
 152 }