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 "compiler.h"
  21 #include "die.h"
  22
  23 __hidden void *xmalloc(size_t size)
  24 {
  25         void *ptr;
  26         if (unlikely(size == 0))
  27                 panic("xmalloc: zero size\n");
  28         ptr = malloc(size);
  29         if (unlikely(ptr == NULL))
  30                 panic("xmalloc: out of memory (allocating %zu bytes)\n",
  31                       size);
  32         return ptr;
  33 }
  34
  35 __hidden void *xzmalloc(size_t size)
  36 {
  37         void *ptr;
  38         if (unlikely(size == 0))
  39                 panic("xzmalloc: zero size\n");
  40         ptr = malloc(size);
  41         if (unlikely(ptr == NULL))
  42                 panic("xzmalloc: out of memory (allocating %zu bytes)\n",
  43                       size);
  44         memset(ptr, 0, size);
  45         return ptr;
  46 }
  47
  48 __hidden void *xmalloc_aligned(size_t size, size_t alignment)
  49 {
  50         int ret;
  51         void *ptr;
  52         if (unlikely(size == 0))
  53                 panic("xmalloc_aligned: zero size\n");
  54         ret = posix_memalign(&ptr, alignment, size);
  55         if (unlikely(ret != 0))
  56                 panic("xmalloc_aligned: out of memory (allocating %zu "
  57                       "bytes)\n", size);
  58         return ptr;
  59 }
  60
  61 __hidden void *xmallocz(size_t size)
  62 {
  63         void *ptr;
  64         if (unlikely(size + 1 < size))
  65                 panic("xmallocz: data too large to fit into virtual "
  66                       "memory space\n");
  67         ptr = xmalloc(size + 1);
  68         ((char*) ptr)[size] = 0;
  69         return ptr;
  70 }
  71
  72 __hidden void *xmemdupz(const void *data, size_t len)
  73 {
  74         return memcpy(xmallocz(len), data, len);
  75 }
  76
  77 __hidden void *xrealloc(void *ptr, size_t nmemb, size_t size)
  78 {
  79         void *new_ptr;
  80         size_t new_size = nmemb * size;
  81         if (unlikely(new_size == 0))
  82                 panic("xrealloc: zero size\n");
  83         if (unlikely(((size_t) ~0) / nmemb < size))
  84                 panic("xrealloc: nmemb * size > SIZE_T_MAX\n");
  85         if (ptr == NULL)
  86                 new_ptr = malloc(new_size);
  87         else
  88                 new_ptr = realloc(ptr, new_size);
  89         if (unlikely(new_ptr == NULL))
  90                 panic("xrealloc: out of memory (new_size %zu bytes)\n",
  91                       new_size);
  92         return new_ptr;
  93 }
  94
  95 __hidden void xfree_func(void *ptr)
  96 {
  97         if (unlikely(ptr == NULL))
  98                 panic("xfree: NULL pointer given as argument\n");
  99         free(ptr);
 100 }
 101
 102 __hidden char *xstrdup(const char *str)
 103 {
 104         size_t len;
 105         char *cp;
 106         len = strlen(str) + 1;
 107         cp = xmalloc(len);
 108         strlcpy(cp, str, len);
 109         return cp;
 110 }
 111
 112 __hidden char *xstrndup(const char *str, size_t size)
 113 {
 114         size_t len;
 115         char *cp;
 116         len = strlen(str) + 1;
 117         if (size < len)
 118                 len = size;
 119         cp = xmalloc(len);
 120         strlcpy(cp, str, len);
 121         return cp;
 122 }
 123
 124 __hidden int xdup(int fd)
 125 {
 126         int ret = dup(fd);
 127         if (unlikely(ret < 0))
 128                 panic("xdup: dup failed\n");
 129         return ret;
 130 }