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 "got_compat.h"
25 
26 #include "xmalloc.h"
27 
28 void *
29 xmalloc(size_t size)
30 {
31 	void *ptr;
32 
33 	if (size == 0) {
34 		fprintf(stderr,"xmalloc: zero size");
35 		exit (1);
36 	}
37 	ptr = malloc(size);
38 	if (ptr == NULL) {
39 		fprintf(stderr, "xmalloc: allocating %zu bytes: %s",
40 		    size, strerror(errno));
41 		exit (1);
42 	}
43 	return ptr;
44 }
45 
46 void *
47 xcalloc(size_t nmemb, size_t size)
48 {
49 	void *ptr;
50 
51 	if (size == 0 || nmemb == 0)
52 		fprintf(stderr,"xcalloc: zero size");
53 	ptr = calloc(nmemb, size);
54 	if (ptr == NULL) {
55 		fprintf(stderr, "xcalloc: allocating %zu * %zu bytes: %s",
56 		    nmemb, size, strerror(errno));
57 		exit (1);
58 	}
59 	return ptr;
60 }
61 
62 void *
63 xrealloc(void *ptr, size_t size)
64 {
65 	return xreallocarray(ptr, 1, size);
66 }
67 
68 void *
69 xreallocarray(void *ptr, size_t nmemb, size_t size)
70 {
71 	void *new_ptr;
72 
73 	if (nmemb == 0 || size == 0) {
74 		fprintf(stderr, "xreallocarray: zero size");
75 		exit (1);
76 	}
77 	new_ptr = reallocarray(ptr, nmemb, size);
78 	if (new_ptr == NULL) {
79 		fprintf(stderr, "xreallocarray: allocating %zu * %zu bytes: %s",
80 		    nmemb, size, strerror(errno));
81 		exit (1);
82 	}
83 	return new_ptr;
84 }
85 
86 void *
87 xrecallocarray(void *ptr, size_t oldnmemb, size_t nmemb, size_t size)
88 {
89 	void *new_ptr;
90 
91 	if (nmemb == 0 || size == 0) {
92 		fprintf(stderr,"xrecallocarray: zero size");
93 		exit (1);
94 	}
95 	new_ptr = recallocarray(ptr, oldnmemb, nmemb, size);
96 	if (new_ptr == NULL) {
97 		fprintf(stderr,"xrecallocarray: allocating %zu * %zu bytes: %s",
98 		    nmemb, size, strerror(errno));
99 		exit (1);
100 	}
101 	return new_ptr;
102 }
103 
104 char *
105 xstrdup(const char *str)
106 {
107 	char *cp;
108 
109 	if ((cp = strdup(str)) == NULL) {
110 		fprintf(stderr,"xstrdup: %s", strerror(errno));
111 		exit (1);
112 	}
113 	return cp;
114 }
115 
116 char *
117 xstrndup(const char *str, size_t maxlen)
118 {
119 	char *cp;
120 
121 	if ((cp = strndup(str, maxlen)) == NULL) {
122 		fprintf(stderr,"xstrndup: %s", strerror(errno));
123 		exit (1);
124 	}
125 	return cp;
126 }
127 
128 int
129 xasprintf(char **ret, const char *fmt, ...)
130 {
131 	va_list ap;
132 	int i;
133 
134 	va_start(ap, fmt);
135 	i = xvasprintf(ret, fmt, ap);
136 	va_end(ap);
137 
138 	return i;
139 }
140 
141 int
142 xvasprintf(char **ret, const char *fmt, va_list ap)
143 {
144 	int i;
145 
146 	i = vasprintf(ret, fmt, ap);
147 
148 	if (i == -1) {
149 		fprintf(stderr,"xasprintf: %s", strerror(errno));
150 		exit  (1);
151 	}
152 
153 	return i;
154 }
155 
156 int
157 xsnprintf(char *str, size_t len, const char *fmt, ...)
158 {
159 	va_list ap;
160 	int i;
161 
162 	va_start(ap, fmt);
163 	i = xvsnprintf(str, len, fmt, ap);
164 	va_end(ap);
165 
166 	return i;
167 }
168 
169 int
170 xvsnprintf(char *str, size_t len, const char *fmt, va_list ap)
171 {
172 	int i;
173 
174 	if (len > INT_MAX)
175 		fprintf(stderr,"xsnprintf: len > INT_MAX");
176 
177 	i = vsnprintf(str, len, fmt, ap);
178 
179 	if (i < 0 || i >= (int)len) {
180 		fprintf(stderr,"xsnprintf: overflow");
181 		exit (1);
182 	}
183 
184 	return i;
185 }