src/xmalloc.c

   1 /*
   2  * netyack
   3  * By Daniel Borkmann <daniel@netyack.org>
   4  * Copyright 2009, 2010 Daniel Borkmann.
   5  * Subject to the GPL.
   6  */
   7
   8 /*
   9  * Copyright (C) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland,
  10  *                    All rights reserved
  11  * Copyright (C) 2010 Daniel Borkmann <daniel@netyack.org>,
  12  *                    Ported from SSH and added several other functions and
  13  *                    heap consistency checks
  14  *
  15  * Versions of malloc and friends that check their results, and never return
  16  * failure (they call fatal if they encounter an error).
  17  *
  18  * As far as I am concerned, the code I have written for this software
  19  * can be used freely for any purpose.  Any derived versions of this
  20  * software must be clearly marked as such, and if the derived work is
  21  * incompatible with the protocol description in the RFC file, it must be
  22  * called by a name other than "ssh" or "Secure Shell".
  23  */
  24
  25 #define _GNU_SOURCE
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <mcheck.h>
  31 #include <unistd.h>
  32 #include <alloca.h>
  33 #include <malloc.h>
  34
  35 #ifndef SIZE_T_MAX
  36 # define SIZE_T_MAX  ((size_t) ~0)
  37 #endif
  38
  39 #include "compiler.h"
  40 #include "xmalloc.h"
  41 #include "strlcpy.h"
  42 #include "tty.h"
  43 #include "error_and_die.h"
  44
  45 __hidden void mcheck_abort(enum mcheck_status stat)
  46 {
  47         if (stat != MCHECK_OK)
  48                 error_and_die(EXIT_FAILURE, "mcheck: mem inconsistency "
  49                               "detected: %d\n", stat);
  50 }
  51
  52 static void xmalloc_mcheck_init(void)
  53 {
  54         /*
  55          * If we would use mcheck_pedantic() here, then libloudmouth
  56          * is not able to perform SSL/TLS authentication. Weird.
  57          */
  58         int ret = mcheck(mcheck_abort);
  59         if (ret < 0)
  60                 error_and_die(EXIT_FAILURE, "xmalloc: cannot init "
  61                               "mcheck! bug\n");
  62         mtrace();
  63 }
  64
  65 static void xmalloc_init_hook(void)
  66 {
  67         xmalloc_mcheck_init();
  68 }
  69
  70 void (*__malloc_initialize_hook)(void) = xmalloc_init_hook;
  71
  72 __hidden void muntrace_handler(int signal)
  73 {
  74         muntrace();
  75         abort();
  76 }
  77
  78 __hidden int xmem_used(void)
  79 {
  80         struct mallinfo mi = mallinfo();
  81         return mi.uordblks;
  82 }
  83
  84 __hidden int xmem_free(void)
  85 {
  86         struct mallinfo mi = mallinfo();
  87         return mi.fordblks;
  88 }
  89
  90 __hidden int xmem_totalarena(void)
  91 {
  92         struct mallinfo mi = mallinfo();
  93         return mi.arena;
  94 }
  95
  96 __hidden void *xmalloc(size_t size)
  97 {
  98         void *ptr;
  99         enum mcheck_status stat;
 100
 101         if (size == 0)
 102                 error_and_die(EXIT_FAILURE, "xmalloc: zero size\n");
 103
 104         ptr = malloc(size);
 105         if (ptr == NULL)
 106                 error_and_die(EXIT_FAILURE, "xmalloc: out of memory "
 107                               "(allocating %lu bytes)\n", (u_long) size);
 108         stat = mprobe(ptr);
 109         if (stat != MCHECK_OK)
 110                 error_and_die(EXIT_FAILURE, "xmalloc: mem inconsistency "
 111                               "detected: %d\n", stat);
 112
 113         debug_blue("%p: %zu", ptr, size);
 114         return ptr;
 115 }
 116
 117 __hidden void *xalloca(size_t size)
 118 {
 119         void *ptr;
 120
 121         if (size == 0)
 122                 error_and_die(EXIT_FAILURE, "xalloca: zero size\n");
 123
 124         ptr = alloca(size);
 125         if (ptr == NULL)
 126                 error_and_die(EXIT_FAILURE, "xalloca: out of memory "
 127                               "(allocating %lu bytes on stack)\n",
 128                               (u_long) size);
 129
 130         debug_blue("%p: %zu (stack)", ptr, size);
 131         return ptr;
 132 }
 133
 134 __hidden void *xvalloc(size_t size)
 135 {
 136         void *ptr;
 137         enum mcheck_status stat;
 138
 139         if (size == 0)
 140                 error_and_die(EXIT_FAILURE, "xmalloc: zero size\n");
 141
 142         ptr = valloc(size);
 143         if (ptr == NULL)
 144                 error_and_die(EXIT_FAILURE, "xvalloc: out of memory "
 145                               "(allocating %lu bytes)\n", (u_long) size);
 146         stat = mprobe(ptr);
 147         if (stat != MCHECK_OK)
 148                 error_and_die(EXIT_FAILURE, "xvalloc: mem inconsistency "
 149                               "detected: %d\n", stat);
 150
 151         debug_blue("%p: %zu", ptr, size);
 152         return ptr;
 153 }
 154
 155 __hidden void *xzmalloc(size_t size)
 156 {
 157         void *ptr;
 158         enum mcheck_status stat;
 159
 160         if (size == 0)
 161                 error_and_die(EXIT_FAILURE, "xzmalloc: zero size\n");
 162
 163         ptr = malloc(size);
 164         if (ptr == NULL)
 165                 error_and_die(EXIT_FAILURE, "xzmalloc: out of memory "
 166                               "(allocating %lu bytes)\n", (u_long) size);
 167         stat = mprobe(ptr);
 168         if (stat != MCHECK_OK)
 169                 error_and_die(EXIT_FAILURE, "xzmalloc: mem inconsistency "
 170                               "detected: %d\n", stat);
 171
 172         memset(ptr, 0, size);
 173
 174         debug_blue("%p: %zu", ptr, size);
 175         return ptr;
 176 }
 177
 178 __hidden void *xmalloc_aligned(size_t size, size_t alignment)
 179 {
 180         int ret;
 181         void *ptr;
 182         enum mcheck_status stat;
 183
 184         if (size == 0)
 185                 error_and_die(EXIT_FAILURE, "xmalloc_aligned: zero size\n");
 186
 187         ret = posix_memalign(&ptr, alignment, size);
 188         if (ret != 0)
 189                 error_and_die(EXIT_FAILURE, "xmalloc_aligned: out of memory "
 190                               "(allocating %lu bytes)\n", (u_long) size);
 191         stat = mprobe(ptr);
 192         if (stat != MCHECK_OK)
 193                 error_and_die(EXIT_FAILURE, "xmalloc_aligned: mem "
 194                               "inconsistency detected: %d\n", stat);
 195
 196         debug_blue("%p: %zu", ptr, size);
 197         return ptr;
 198 }
 199
 200 __hidden void *xmallocz(size_t size)
 201 {
 202         void *ptr;
 203
 204         if (size + 1 < size)
 205                 error_and_die(EXIT_FAILURE, "xmallocz: data too large to fit "
 206                               "into virtual memory space\n");
 207
 208         ptr = xmalloc(size + 1);
 209         ((char*) ptr)[size] = 0;
 210
 211         return ptr;
 212 }
 213
 214 __hidden void *xmemdupz(const void *data, size_t len)
 215 {
 216         return memcpy(xmallocz(len), data, len);
 217 }
 218
 219 __hidden void *xcalloc(size_t nmemb, size_t size)
 220 {
 221         void *ptr;
 222         enum mcheck_status stat;
 223
 224         if (size == 0 || nmemb == 0)
 225                 error_and_die(EXIT_FAILURE, "xcalloc: zero size\n");
 226         if (SIZE_T_MAX / nmemb < size)
 227                 error_and_die(EXIT_FAILURE, "xcalloc: nmemb * size > "
 228                               "SIZE_T_MAX\n");
 229
 230         ptr = calloc(nmemb, size);
 231         if (ptr == NULL)
 232                 error_and_die(EXIT_FAILURE, "xcalloc: out of memory "
 233                               "(allocating %lu bytes)\n",
 234                               (u_long) (size * nmemb));
 235         stat = mprobe(ptr);
 236         if (stat != MCHECK_OK)
 237                 error_and_die(EXIT_FAILURE, "xcalloc: mem inconsistency "
 238                               "detected: %d\n", stat);
 239
 240         debug_blue("%p: %zu", ptr, size);
 241         return ptr;
 242 }
 243
 244 __hidden void *xrealloc(void *ptr, size_t nmemb, size_t size)
 245 {
 246         void *new_ptr;
 247         size_t new_size = nmemb * size;
 248         enum mcheck_status stat;
 249
 250         if (new_size == 0)
 251                 error_and_die(EXIT_FAILURE, "xrealloc: zero size\n");
 252         if (SIZE_T_MAX / nmemb < size)
 253                 error_and_die(EXIT_FAILURE, "xrealloc: nmemb * size > "
 254                               "SIZE_T_MAX\n");
 255
 256         if (ptr == NULL)
 257                 new_ptr = malloc(new_size);
 258         else
 259                 new_ptr = realloc(ptr, new_size);
 260
 261         if (new_ptr == NULL)
 262                 error_and_die(EXIT_FAILURE, "xrealloc: out of memory "
 263                               "(new_size %lu bytes)\n", (u_long) new_size);
 264         stat = mprobe(ptr);
 265         if (stat != MCHECK_OK)
 266                 error_and_die(EXIT_FAILURE, "xrealloc: mem inconsistency "
 267                               "detected: %d\n", stat);
 268
 269         debug_blue("%p: %zu => %p: %zu", ptr, size, new_ptr, new_size);
 270         return new_ptr;
 271 }
 272
 273 __hidden void xfree(void *ptr)
 274 {
 275         enum mcheck_status stat;
 276
 277         if (ptr == NULL)
 278                 error_and_die(EXIT_FAILURE, "xfree: NULL pointer given as "
 279                               "argument\n");
 280
 281         stat = mprobe(ptr);
 282         if (stat != MCHECK_OK)
 283                 error_and_die(EXIT_FAILURE, "xfree: mem inconsistency "
 284                               "detected: %d\n", stat);
 285
 286         debug_blue("%p => 0", ptr);
 287
 288         free(ptr);
 289 }
 290
 291 __hidden char *xstrdup(const char *str)
 292 {
 293         size_t len;
 294         char *cp;
 295
 296         len = strlen(str) + 1;
 297         cp = xmalloc(len);
 298         strlcpy(cp, str, len);
 299
 300         return cp;
 301 }
 302
 303 __hidden char *xstrndup(const char *str, size_t size)
 304 {
 305         size_t len;
 306         char *cp;
 307
 308         len = strlen(str) + 1;
 309         if (size < len)
 310                 len = size;
 311
 312         cp = xmalloc(len);
 313         strlcpy(cp, str, len);
 314
 315         return cp;
 316 }
 317
 318 __hidden int xdup(int fd)
 319 {
 320         int ret = dup(fd);
 321         if (ret < 0)
 322                 error_and_die(EXIT_FAILURE, "xdup: dup failed\n");
 323
 324         return ret;
 325 }
 326