Return to xmalloc.c CVS log

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

Annotation of embedaddon/tmux/xmalloc.c, revision 1.1.1.1

1.1       misho       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: }