tmux  3.2a
About: tmux is a terminal multiplexer that lets you switch easily between several programs in one terminal.
  Fossies Dox: tmux-3.2a.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

xmalloc.c
Go to the documentation of this file.
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 void *
75 xrecallocarray(void *ptr, size_t oldnmemb, size_t nmemb, size_t size)
76 {
77  void *new_ptr;
78 
79  if (nmemb == 0 || size == 0)
80  fatalx("xrecallocarray: zero size");
81  new_ptr = recallocarray(ptr, oldnmemb, nmemb, size);
82  if (new_ptr == NULL)
83  fatalx("xrecallocarray: allocating %zu * %zu bytes: %s",
84  nmemb, size, strerror(errno));
85  return new_ptr;
86 }
87 
88 char *
89 xstrdup(const char *str)
90 {
91  char *cp;
92 
93  if ((cp = strdup(str)) == NULL)
94  fatalx("xstrdup: %s", strerror(errno));
95  return cp;
96 }
97 
98 char *
99 xstrndup(const char *str, size_t maxlen)
100 {
101  char *cp;
102 
103  if ((cp = strndup(str, maxlen)) == NULL)
104  fatalx("xstrndup: %s", strerror(errno));
105  return cp;
106 }
107 
108 int
109 xasprintf(char **ret, const char *fmt, ...)
110 {
111  va_list ap;
112  int i;
113 
114  va_start(ap, fmt);
115  i = xvasprintf(ret, fmt, ap);
116  va_end(ap);
117 
118  return i;
119 }
120 
121 int
122 xvasprintf(char **ret, const char *fmt, va_list ap)
123 {
124  int i;
125 
126  i = vasprintf(ret, fmt, ap);
127 
128  if (i == -1)
129  fatalx("xasprintf: %s", strerror(errno));
130 
131  return i;
132 }
133 
134 int
135 xsnprintf(char *str, size_t len, const char *fmt, ...)
136 {
137  va_list ap;
138  int i;
139 
140  va_start(ap, fmt);
141  i = xvsnprintf(str, len, fmt, ap);
142  va_end(ap);
143 
144  return i;
145 }
146 
147 int
148 xvsnprintf(char *str, size_t len, const char *fmt, va_list ap)
149 {
150  int i;
151 
152  if (len > INT_MAX)
153  fatalx("xsnprintf: len > INT_MAX");
154 
155  i = vsnprintf(str, len, fmt, ap);
156 
157  if (i < 0 || i >= (int)len)
158  fatalx("xsnprintf: overflow");
159 
160  return i;
161 }
void * recallocarray(void *, size_t, size_t, size_t)
int vasprintf(char **, const char *, va_list)
void * reallocarray(void *, size_t, size_t)
char * strndup(const char *, size_t)
void fatalx(const char *msg,...)
Definition: log.c:159
int xvsnprintf(char *str, size_t len, const char *fmt, va_list ap)
Definition: xmalloc.c:148
char * xstrndup(const char *str, size_t maxlen)
Definition: xmalloc.c:99
void * xmalloc(size_t size)
Definition: xmalloc.c:27
int xsnprintf(char *str, size_t len, const char *fmt,...)
Definition: xmalloc.c:135
void * xreallocarray(void *ptr, size_t nmemb, size_t size)
Definition: xmalloc.c:61
void * xrecallocarray(void *ptr, size_t oldnmemb, size_t nmemb, size_t size)
Definition: xmalloc.c:75
void * xrealloc(void *ptr, size_t size)
Definition: xmalloc.c:55
int xasprintf(char **ret, const char *fmt,...)
Definition: xmalloc.c:109
void * xcalloc(size_t nmemb, size_t size)
Definition: xmalloc.c:41
char * xstrdup(const char *str)
Definition: xmalloc.c:89
int xvasprintf(char **ret, const char *fmt, va_list ap)
Definition: xmalloc.c:122