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