Return to xmalloc.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux

tmux 2.4

    1: /* $OpenBSD$ */
    2: 
    3: /*
    4:  * Author: Tatu Ylonen <ylo@cs.hut.fi>
    5:  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
    6:  *                    All rights reserved
    7:  * Versions of malloc and friends that check their results, and never return
    8:  * failure (they call fatalx if they encounter an error).
    9:  *
   10:  * As far as I am concerned, the code I have written for this software
   11:  * can be used freely for any purpose.  Any derived versions of this
   12:  * software must be clearly marked as such, and if the derived work is
   13:  * incompatible with the protocol description in the RFC file, it must be
   14:  * called by a name other than "ssh" or "Secure Shell".
   15:  */
   16: 
   17: #include <errno.h>
   18: #include <limits.h>
   19: #include <stdint.h>
   20: #include <stdio.h>
   21: #include <stdlib.h>
   22: #include <string.h>
   23: 
   24: #include "tmux.h"
   25: 
   26: void *
   27: xmalloc(size_t size)
   28: {
   29: 	void *ptr;
   30: 
   31: 	if (size == 0)
   32: 		fatalx("xmalloc: zero size");
   33: 	ptr = malloc(size);
   34: 	if (ptr == NULL)
   35: 		fatalx("xmalloc: allocating %zu bytes: %s",
   36: 		    size, strerror(errno));
   37: 	return ptr;
   38: }
   39: 
   40: void *
   41: xcalloc(size_t nmemb, size_t size)
   42: {
   43: 	void *ptr;
   44: 
   45: 	if (size == 0 || nmemb == 0)
   46: 		fatalx("xcalloc: zero size");
   47: 	ptr = calloc(nmemb, size);
   48: 	if (ptr == NULL)
   49: 		fatalx("xcalloc: allocating %zu * %zu bytes: %s",
   50: 		    nmemb, size, strerror(errno));
   51: 	return ptr;
   52: }
   53: 
   54: void *
   55: xrealloc(void *ptr, size_t size)
   56: {
   57: 	return xreallocarray(ptr, 1, size);
   58: }
   59: 
   60: void *
   61: xreallocarray(void *ptr, size_t nmemb, size_t size)
   62: {
   63: 	void *new_ptr;
   64: 
   65: 	if (nmemb == 0 || size == 0)
   66: 		fatalx("xreallocarray: zero size");
   67: 	new_ptr = reallocarray(ptr, nmemb, size);
   68: 	if (new_ptr == NULL)
   69: 		fatalx("xreallocarray: allocating %zu * %zu bytes: %s",
   70: 		    nmemb, size, strerror(errno));
   71: 	return new_ptr;
   72: }
   73: 
   74: char *
   75: xstrdup(const char *str)
   76: {
   77: 	char *cp;
   78: 
   79: 	if ((cp = strdup(str)) == NULL)
   80: 		fatalx("xstrdup: %s", strerror(errno));
   81: 	return cp;
   82: }
   83: 
   84: char *
   85: xstrndup(const char *str, size_t maxlen)
   86: {
   87: 	char *cp;
   88: 
   89: 	if ((cp = strndup(str, maxlen)) == NULL)
   90: 		fatalx("xstrndup: %s", strerror(errno));
   91: 	return cp;
   92: }
   93: 
   94: int
   95: xasprintf(char **ret, const char *fmt, ...)
   96: {
   97: 	va_list ap;
   98: 	int i;
   99: 
  100: 	va_start(ap, fmt);
  101: 	i = xvasprintf(ret, fmt, ap);
  102: 	va_end(ap);
  103: 
  104: 	return i;
  105: }
  106: 
  107: int
  108: xvasprintf(char **ret, const char *fmt, va_list ap)
  109: {
  110: 	int i;
  111: 
  112: 	i = vasprintf(ret, fmt, ap);
  113: 
  114: 	if (i < 0 || *ret == NULL)
  115: 		fatalx("xasprintf: %s", strerror(errno));
  116: 
  117: 	return i;
  118: }
  119: 
  120: int
  121: xsnprintf(char *str, size_t len, const char *fmt, ...)
  122: {
  123: 	va_list ap;
  124: 	int i;
  125: 
  126: 	va_start(ap, fmt);
  127: 	i = xvsnprintf(str, len, fmt, ap);
  128: 	va_end(ap);
  129: 
  130: 	return i;
  131: }
  132: 
  133: int
  134: xvsnprintf(char *str, size_t len, const char *fmt, va_list ap)
  135: {
  136: 	int i;
  137: 
  138: 	if (len > INT_MAX)
  139: 		fatalx("xsnprintf: len > INT_MAX");
  140: 
  141: 	i = vsnprintf(str, len, fmt, ap);
  142: 
  143: 	if (i < 0 || i >= (int)len)
  144: 		fatalx("xsnprintf: overflow");
  145: 
  146: 	return i;
  147: }