xmalloc.c

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