Return to xmalloc.c CVS log

Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/xmalloc.c, Revision 1.11

1.11    ! nicm        1: /* $OpenBSD: xmalloc.c,v 1.10 2016/04/04 16:19:43 nicm Exp $ */
1.1       nicm        2:
                      3: /*
1.9       nicm        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
1.10      nicm        8:  * failure (they call fatalx if they encounter an error).
1.1       nicm        9:  *
1.9       nicm       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".
1.1       nicm       15:  */
                     16:
1.9       nicm       17: #include <errno.h>
                     18: #include <limits.h>
1.1       nicm       19: #include <stdint.h>
1.9       nicm       20: #include <stdio.h>
1.1       nicm       21: #include <stdlib.h>
                     22: #include <string.h>
                     23:
                     24: #include "tmux.h"
                     25:
1.9       nicm       26: void *
                     27: xmalloc(size_t size)
1.1       nicm       28: {
1.9       nicm       29:        void *ptr;
1.1       nicm       30:
1.9       nicm       31:        if (size == 0)
1.10      nicm       32:                fatalx("xmalloc: zero size");
1.9       nicm       33:        ptr = malloc(size);
                     34:        if (ptr == NULL)
1.10      nicm       35:                fatalx("xmalloc: allocating %zu bytes: %s",
1.9       nicm       36:                    size, strerror(errno));
                     37:        return ptr;
1.1       nicm       38: }
                     39:
                     40: void *
                     41: xcalloc(size_t nmemb, size_t size)
                     42: {
1.9       nicm       43:        void *ptr;
1.1       nicm       44:
1.3       deraadt    45:        if (size == 0 || nmemb == 0)
1.10      nicm       46:                fatalx("xcalloc: zero size");
1.9       nicm       47:        ptr = calloc(nmemb, size);
                     48:        if (ptr == NULL)
1.10      nicm       49:                fatalx("xcalloc: allocating %zu * %zu bytes: %s",
1.9       nicm       50:                    nmemb, size, strerror(errno));
                     51:        return ptr;
1.1       nicm       52: }
                     53:
                     54: void *
1.9       nicm       55: xrealloc(void *ptr, size_t size)
1.1       nicm       56: {
1.9       nicm       57:        return xreallocarray(ptr, 1, size);
1.1       nicm       58: }
                     59:
                     60: void *
1.9       nicm       61: xreallocarray(void *ptr, size_t nmemb, size_t size)
1.5       nicm       62: {
1.9       nicm       63:        void *new_ptr;
1.5       nicm       64:
1.9       nicm       65:        if (nmemb == 0 || size == 0)
1.10      nicm       66:                fatalx("xreallocarray: zero size");
1.9       nicm       67:        new_ptr = reallocarray(ptr, nmemb, size);
                     68:        if (new_ptr == NULL)
1.10      nicm       69:                fatalx("xreallocarray: allocating %zu * %zu bytes: %s",
1.9       nicm       70:                    nmemb, size, strerror(errno));
                     71:        return new_ptr;
1.5       nicm       72: }
                     73:
1.9       nicm       74: char *
                     75: xstrdup(const char *str)
1.1       nicm       76: {
1.9       nicm       77:        char *cp;
1.1       nicm       78:
1.9       nicm       79:        if ((cp = strdup(str)) == NULL)
1.10      nicm       80:                fatalx("xstrdup: %s", strerror(errno));
1.11    ! nicm       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));
1.9       nicm       91:        return cp;
1.1       nicm       92: }
                     93:
1.7       nicm       94: int
1.1       nicm       95: xasprintf(char **ret, const char *fmt, ...)
                     96: {
1.3       deraadt    97:        va_list ap;
1.9       nicm       98:        int i;
1.1       nicm       99:
1.3       deraadt   100:        va_start(ap, fmt);
                    101:        i = xvasprintf(ret, fmt, ap);
                    102:        va_end(ap);
1.1       nicm      103:
1.9       nicm      104:        return i;
1.1       nicm      105: }
                    106:
                    107: int
                    108: xvasprintf(char **ret, const char *fmt, va_list ap)
                    109: {
1.9       nicm      110:        int i;
1.1       nicm      111:
                    112:        i = vasprintf(ret, fmt, ap);
1.9       nicm      113:
1.3       deraadt   114:        if (i < 0 || *ret == NULL)
1.10      nicm      115:                fatalx("xasprintf: %s", strerror(errno));
1.1       nicm      116:
1.9       nicm      117:        return i;
1.1       nicm      118: }
                    119:
1.7       nicm      120: int
1.9       nicm      121: xsnprintf(char *str, size_t len, const char *fmt, ...)
1.1       nicm      122: {
1.3       deraadt   123:        va_list ap;
1.9       nicm      124:        int i;
1.1       nicm      125:
1.3       deraadt   126:        va_start(ap, fmt);
1.9       nicm      127:        i = xvsnprintf(str, len, fmt, ap);
1.3       deraadt   128:        va_end(ap);
1.1       nicm      129:
1.9       nicm      130:        return i;
1.1       nicm      131: }
                    132:
                    133: int
1.9       nicm      134: xvsnprintf(char *str, size_t len, const char *fmt, va_list ap)
1.1       nicm      135: {
1.9       nicm      136:        int i;
1.1       nicm      137:
                    138:        if (len > INT_MAX)
1.10      nicm      139:                fatalx("xsnprintf: len > INT_MAX");
1.9       nicm      140:
                    141:        i = vsnprintf(str, len, fmt, ap);
1.1       nicm      142:
1.8       tobias    143:        if (i < 0 || i >= (int)len)
1.10      nicm      144:                fatalx("xsnprintf: overflow");
1.1       nicm      145:
1.9       nicm      146:        return i;
1.1       nicm      147: }