Commit | Line | Data |
---|---|---|
5abebf3c CB |
1 | /* strerror_r.c --- POSIX compatible system error routine |
2 | ||
9c9d63b1 | 3 | Copyright (C) 2010-2021 Free Software Foundation, Inc. |
5abebf3c CB |
4 | |
5 | This program is free software: you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 3 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
c0c3707f | 16 | along with this program. If not, see <https://www.gnu.org/licenses/>. */ |
5abebf3c CB |
17 | |
18 | /* Written by Bruno Haible <bruno@clisp.org>, 2010. */ | |
19 | ||
20 | #include <config.h> | |
21 | ||
22 | /* Enable declaration of sys_nerr and sys_errlist in <errno.h> on NetBSD. */ | |
23 | #define _NETBSD_SOURCE 1 | |
24 | ||
25 | /* Specification. */ | |
26 | #include <string.h> | |
27 | ||
28 | #include <errno.h> | |
29 | #include <stdio.h> | |
30 | #include <stdlib.h> | |
c0c3707f CB |
31 | #if !HAVE_SNPRINTF |
32 | # include <stdarg.h> | |
33 | #endif | |
5abebf3c CB |
34 | |
35 | #include "strerror-override.h" | |
36 | ||
37 | #if (__GLIBC__ >= 2 || defined __UCLIBC__ || defined __CYGWIN__) && HAVE___XPG_STRERROR_R /* glibc >= 2.3.4, cygwin >= 1.7.9 */ | |
38 | ||
39 | # define USE_XPG_STRERROR_R 1 | |
40 | extern | |
41 | #ifdef __cplusplus | |
42 | "C" | |
43 | #endif | |
44 | int __xpg_strerror_r (int errnum, char *buf, size_t buflen); | |
45 | ||
c0c3707f | 46 | #elif HAVE_DECL_STRERROR_R && !(__GLIBC__ >= 2 || defined __UCLIBC__ || defined __CYGWIN__) |
5abebf3c CB |
47 | |
48 | /* The system's strerror_r function is OK, except that its third argument | |
49 | is 'int', not 'size_t', or its return type is wrong. */ | |
50 | ||
51 | # include <limits.h> | |
52 | ||
53 | # define USE_SYSTEM_STRERROR_R 1 | |
54 | ||
55 | #else /* (__GLIBC__ >= 2 || defined __UCLIBC__ || defined __CYGWIN__ ? !HAVE___XPG_STRERROR_R : !HAVE_DECL_STRERROR_R) */ | |
56 | ||
57 | /* Use the system's strerror(). Exclude glibc and cygwin because the | |
58 | system strerror_r has the wrong return type, and cygwin 1.7.9 | |
59 | strerror_r clobbers strerror. */ | |
60 | # undef strerror | |
61 | ||
62 | # define USE_SYSTEM_STRERROR 1 | |
63 | ||
c0c3707f | 64 | # if defined __NetBSD__ || defined __hpux || (defined _WIN32 && !defined __CYGWIN__) || defined __sgi || (defined __sun && !defined _LP64) || defined __CYGWIN__ |
5abebf3c CB |
65 | |
66 | /* No locking needed. */ | |
67 | ||
68 | /* Get catgets internationalization functions. */ | |
69 | # if HAVE_CATGETS | |
70 | # include <nl_types.h> | |
71 | # endif | |
72 | ||
73 | #ifdef __cplusplus | |
74 | extern "C" { | |
75 | #endif | |
76 | ||
77 | /* Get sys_nerr, sys_errlist on HP-UX (otherwise only declared in C++ mode). | |
78 | Get sys_nerr, sys_errlist on IRIX (otherwise only declared with _SGIAPI). */ | |
79 | # if defined __hpux || defined __sgi | |
80 | extern int sys_nerr; | |
81 | extern char *sys_errlist[]; | |
82 | # endif | |
83 | ||
84 | /* Get sys_nerr on Solaris. */ | |
85 | # if defined __sun && !defined _LP64 | |
86 | extern int sys_nerr; | |
87 | # endif | |
88 | ||
89 | #ifdef __cplusplus | |
90 | } | |
91 | #endif | |
92 | ||
93 | # else | |
94 | ||
95 | # include "glthread/lock.h" | |
96 | ||
97 | /* This lock protects the buffer returned by strerror(). We assume that | |
98 | no other uses of strerror() exist in the program. */ | |
99 | gl_lock_define_initialized(static, strerror_lock) | |
100 | ||
101 | # endif | |
102 | ||
103 | #endif | |
104 | ||
105 | /* On MSVC, there is no snprintf() function, just a _snprintf(). | |
106 | It is of lower quality, but sufficient for the simple use here. | |
107 | We only have to make sure to NUL terminate the result (_snprintf | |
108 | does not NUL terminate, like strncpy). */ | |
109 | #if !HAVE_SNPRINTF | |
110 | static int | |
111 | local_snprintf (char *buf, size_t buflen, const char *format, ...) | |
112 | { | |
113 | va_list args; | |
114 | int result; | |
115 | ||
116 | va_start (args, format); | |
117 | result = _vsnprintf (buf, buflen, format, args); | |
118 | va_end (args); | |
119 | if (buflen > 0 && (result < 0 || result >= buflen)) | |
120 | buf[buflen - 1] = '\0'; | |
121 | return result; | |
122 | } | |
9c9d63b1 | 123 | # undef snprintf |
5abebf3c CB |
124 | # define snprintf local_snprintf |
125 | #endif | |
126 | ||
127 | /* Copy as much of MSG into BUF as possible, without corrupting errno. | |
128 | Return 0 if MSG fit in BUFLEN, otherwise return ERANGE. */ | |
129 | static int | |
130 | safe_copy (char *buf, size_t buflen, const char *msg) | |
131 | { | |
132 | size_t len = strlen (msg); | |
c0c3707f | 133 | size_t moved = len < buflen ? len : buflen - 1; |
5abebf3c | 134 | |
c0c3707f CB |
135 | /* Although POSIX lets memmove corrupt errno, we don't |
136 | know of any implementation where this is a real problem. */ | |
137 | memmove (buf, msg, moved); | |
138 | buf[moved] = '\0'; | |
139 | return len < buflen ? 0 : ERANGE; | |
5abebf3c CB |
140 | } |
141 | ||
142 | ||
143 | int | |
144 | strerror_r (int errnum, char *buf, size_t buflen) | |
145 | #undef strerror_r | |
146 | { | |
147 | /* Filter this out now, so that rest of this replacement knows that | |
148 | there is room for a non-empty message and trailing NUL. */ | |
149 | if (buflen <= 1) | |
150 | { | |
151 | if (buflen) | |
152 | *buf = '\0'; | |
153 | return ERANGE; | |
154 | } | |
155 | *buf = '\0'; | |
156 | ||
157 | /* Check for gnulib overrides. */ | |
158 | { | |
159 | char const *msg = strerror_override (errnum); | |
160 | ||
161 | if (msg) | |
162 | return safe_copy (buf, buflen, msg); | |
163 | } | |
164 | ||
165 | { | |
166 | int ret; | |
167 | int saved_errno = errno; | |
168 | ||
169 | #if USE_XPG_STRERROR_R | |
170 | ||
171 | { | |
172 | ret = __xpg_strerror_r (errnum, buf, buflen); | |
173 | if (ret < 0) | |
174 | ret = errno; | |
175 | if (!*buf) | |
176 | { | |
177 | /* glibc 2.13 would not touch buf on err, so we have to fall | |
178 | back to GNU strerror_r which always returns a thread-safe | |
179 | untruncated string to (partially) copy into our buf. */ | |
180 | safe_copy (buf, buflen, strerror_r (errnum, buf, buflen)); | |
181 | } | |
182 | } | |
183 | ||
184 | #elif USE_SYSTEM_STRERROR_R | |
185 | ||
186 | if (buflen > INT_MAX) | |
187 | buflen = INT_MAX; | |
188 | ||
189 | # ifdef __hpux | |
190 | /* On HP-UX 11.31, strerror_r always fails when buflen < 80; it | |
191 | also fails to change buf on EINVAL. */ | |
192 | { | |
193 | char stackbuf[80]; | |
194 | ||
195 | if (buflen < sizeof stackbuf) | |
196 | { | |
197 | ret = strerror_r (errnum, stackbuf, sizeof stackbuf); | |
198 | if (ret == 0) | |
199 | ret = safe_copy (buf, buflen, stackbuf); | |
200 | } | |
201 | else | |
202 | ret = strerror_r (errnum, buf, buflen); | |
203 | } | |
204 | # else | |
205 | ret = strerror_r (errnum, buf, buflen); | |
206 | ||
c0c3707f CB |
207 | /* Some old implementations may return (-1, EINVAL) instead of EINVAL. |
208 | But on Haiku, valid error numbers are negative. */ | |
209 | # if !defined __HAIKU__ | |
5abebf3c CB |
210 | if (ret < 0) |
211 | ret = errno; | |
c0c3707f | 212 | # endif |
5abebf3c CB |
213 | # endif |
214 | ||
c0c3707f CB |
215 | # if defined _AIX || defined __HAIKU__ |
216 | /* AIX and Haiku return 0 rather than ERANGE when truncating strings; try | |
5abebf3c CB |
217 | again until we are sure we got the entire string. */ |
218 | if (!ret && strlen (buf) == buflen - 1) | |
219 | { | |
220 | char stackbuf[STACKBUF_LEN]; | |
221 | size_t len; | |
222 | strerror_r (errnum, stackbuf, sizeof stackbuf); | |
223 | len = strlen (stackbuf); | |
224 | /* STACKBUF_LEN should have been large enough. */ | |
225 | if (len + 1 == sizeof stackbuf) | |
226 | abort (); | |
227 | if (buflen <= len) | |
228 | ret = ERANGE; | |
229 | } | |
230 | # else | |
231 | /* Solaris 10 does not populate buf on ERANGE. OpenBSD 4.7 | |
232 | truncates early on ERANGE rather than return a partial integer. | |
233 | We prefer the maximal string. We set buf[0] earlier, and we | |
234 | know of no implementation that modifies buf to be an | |
235 | unterminated string, so this strlen should be portable in | |
236 | practice (rather than pulling in a safer strnlen). */ | |
237 | if (ret == ERANGE && strlen (buf) < buflen - 1) | |
238 | { | |
239 | char stackbuf[STACKBUF_LEN]; | |
240 | ||
241 | /* STACKBUF_LEN should have been large enough. */ | |
242 | if (strerror_r (errnum, stackbuf, sizeof stackbuf) == ERANGE) | |
243 | abort (); | |
244 | safe_copy (buf, buflen, stackbuf); | |
245 | } | |
246 | # endif | |
247 | ||
248 | #else /* USE_SYSTEM_STRERROR */ | |
249 | ||
250 | /* Try to do what strerror (errnum) does, but without clobbering the | |
251 | buffer used by strerror(). */ | |
252 | ||
c0c3707f | 253 | # if defined __NetBSD__ || defined __hpux || (defined _WIN32 && !defined __CYGWIN__) || defined __CYGWIN__ /* NetBSD, HP-UX, native Windows, Cygwin */ |
5abebf3c CB |
254 | |
255 | /* NetBSD: sys_nerr, sys_errlist are declared through _NETBSD_SOURCE | |
256 | and <errno.h> above. | |
257 | HP-UX: sys_nerr, sys_errlist are declared explicitly above. | |
258 | native Windows: sys_nerr, sys_errlist are declared in <stdlib.h>. | |
259 | Cygwin: sys_nerr, sys_errlist are declared in <errno.h>. */ | |
260 | if (errnum >= 0 && errnum < sys_nerr) | |
261 | { | |
262 | # if HAVE_CATGETS && (defined __NetBSD__ || defined __hpux) | |
263 | # if defined __NetBSD__ | |
264 | nl_catd catd = catopen ("libc", NL_CAT_LOCALE); | |
265 | const char *errmsg = | |
266 | (catd != (nl_catd)-1 | |
267 | ? catgets (catd, 1, errnum, sys_errlist[errnum]) | |
268 | : sys_errlist[errnum]); | |
269 | # endif | |
270 | # if defined __hpux | |
271 | nl_catd catd = catopen ("perror", NL_CAT_LOCALE); | |
272 | const char *errmsg = | |
273 | (catd != (nl_catd)-1 | |
274 | ? catgets (catd, 1, 1 + errnum, sys_errlist[errnum]) | |
275 | : sys_errlist[errnum]); | |
276 | # endif | |
277 | # else | |
278 | const char *errmsg = sys_errlist[errnum]; | |
279 | # endif | |
280 | if (errmsg == NULL || *errmsg == '\0') | |
281 | ret = EINVAL; | |
282 | else | |
283 | ret = safe_copy (buf, buflen, errmsg); | |
284 | # if HAVE_CATGETS && (defined __NetBSD__ || defined __hpux) | |
285 | if (catd != (nl_catd)-1) | |
286 | catclose (catd); | |
287 | # endif | |
288 | } | |
289 | else | |
290 | ret = EINVAL; | |
291 | ||
292 | # elif defined __sgi || (defined __sun && !defined _LP64) /* IRIX, Solaris <= 9 32-bit */ | |
293 | ||
294 | /* For a valid error number, the system's strerror() function returns | |
295 | a pointer to a not copied string, not to a buffer. */ | |
296 | if (errnum >= 0 && errnum < sys_nerr) | |
297 | { | |
298 | char *errmsg = strerror (errnum); | |
299 | ||
300 | if (errmsg == NULL || *errmsg == '\0') | |
301 | ret = EINVAL; | |
302 | else | |
303 | ret = safe_copy (buf, buflen, errmsg); | |
304 | } | |
305 | else | |
306 | ret = EINVAL; | |
307 | ||
308 | # else | |
309 | ||
310 | gl_lock_lock (strerror_lock); | |
311 | ||
312 | { | |
313 | char *errmsg = strerror (errnum); | |
314 | ||
315 | /* For invalid error numbers, strerror() on | |
316 | - IRIX 6.5 returns NULL, | |
317 | - HP-UX 11 returns an empty string. */ | |
318 | if (errmsg == NULL || *errmsg == '\0') | |
319 | ret = EINVAL; | |
320 | else | |
321 | ret = safe_copy (buf, buflen, errmsg); | |
322 | } | |
323 | ||
324 | gl_lock_unlock (strerror_lock); | |
325 | ||
326 | # endif | |
327 | ||
c0c3707f CB |
328 | #endif |
329 | ||
330 | #if defined _WIN32 && !defined __CYGWIN__ | |
331 | /* MSVC 14 defines names for many error codes in the range 100..140, | |
332 | but _sys_errlist contains strings only for the error codes | |
333 | < _sys_nerr = 43. */ | |
334 | if (ret == EINVAL) | |
335 | { | |
336 | const char *errmsg; | |
337 | ||
338 | switch (errnum) | |
339 | { | |
340 | case 100 /* EADDRINUSE */: | |
341 | errmsg = "Address already in use"; | |
342 | break; | |
343 | case 101 /* EADDRNOTAVAIL */: | |
344 | errmsg = "Cannot assign requested address"; | |
345 | break; | |
346 | case 102 /* EAFNOSUPPORT */: | |
347 | errmsg = "Address family not supported by protocol"; | |
348 | break; | |
349 | case 103 /* EALREADY */: | |
350 | errmsg = "Operation already in progress"; | |
351 | break; | |
352 | case 105 /* ECANCELED */: | |
353 | errmsg = "Operation canceled"; | |
354 | break; | |
355 | case 106 /* ECONNABORTED */: | |
356 | errmsg = "Software caused connection abort"; | |
357 | break; | |
358 | case 107 /* ECONNREFUSED */: | |
359 | errmsg = "Connection refused"; | |
360 | break; | |
361 | case 108 /* ECONNRESET */: | |
362 | errmsg = "Connection reset by peer"; | |
363 | break; | |
364 | case 109 /* EDESTADDRREQ */: | |
365 | errmsg = "Destination address required"; | |
366 | break; | |
367 | case 110 /* EHOSTUNREACH */: | |
368 | errmsg = "No route to host"; | |
369 | break; | |
370 | case 112 /* EINPROGRESS */: | |
371 | errmsg = "Operation now in progress"; | |
372 | break; | |
373 | case 113 /* EISCONN */: | |
374 | errmsg = "Transport endpoint is already connected"; | |
375 | break; | |
376 | case 114 /* ELOOP */: | |
377 | errmsg = "Too many levels of symbolic links"; | |
378 | break; | |
379 | case 115 /* EMSGSIZE */: | |
380 | errmsg = "Message too long"; | |
381 | break; | |
382 | case 116 /* ENETDOWN */: | |
383 | errmsg = "Network is down"; | |
384 | break; | |
385 | case 117 /* ENETRESET */: | |
386 | errmsg = "Network dropped connection on reset"; | |
387 | break; | |
388 | case 118 /* ENETUNREACH */: | |
389 | errmsg = "Network is unreachable"; | |
390 | break; | |
391 | case 119 /* ENOBUFS */: | |
392 | errmsg = "No buffer space available"; | |
393 | break; | |
394 | case 123 /* ENOPROTOOPT */: | |
395 | errmsg = "Protocol not available"; | |
396 | break; | |
397 | case 126 /* ENOTCONN */: | |
398 | errmsg = "Transport endpoint is not connected"; | |
399 | break; | |
400 | case 128 /* ENOTSOCK */: | |
401 | errmsg = "Socket operation on non-socket"; | |
402 | break; | |
403 | case 129 /* ENOTSUP */: | |
404 | errmsg = "Not supported"; | |
405 | break; | |
406 | case 130 /* EOPNOTSUPP */: | |
407 | errmsg = "Operation not supported"; | |
408 | break; | |
409 | case 132 /* EOVERFLOW */: | |
410 | errmsg = "Value too large for defined data type"; | |
411 | break; | |
412 | case 133 /* EOWNERDEAD */: | |
413 | errmsg = "Owner died"; | |
414 | break; | |
415 | case 134 /* EPROTO */: | |
416 | errmsg = "Protocol error"; | |
417 | break; | |
418 | case 135 /* EPROTONOSUPPORT */: | |
419 | errmsg = "Protocol not supported"; | |
420 | break; | |
421 | case 136 /* EPROTOTYPE */: | |
422 | errmsg = "Protocol wrong type for socket"; | |
423 | break; | |
424 | case 138 /* ETIMEDOUT */: | |
425 | errmsg = "Connection timed out"; | |
426 | break; | |
427 | case 140 /* EWOULDBLOCK */: | |
428 | errmsg = "Operation would block"; | |
429 | break; | |
430 | default: | |
431 | errmsg = NULL; | |
432 | break; | |
433 | } | |
434 | if (errmsg != NULL) | |
435 | ret = safe_copy (buf, buflen, errmsg); | |
436 | } | |
5abebf3c CB |
437 | #endif |
438 | ||
439 | if (ret == EINVAL && !*buf) | |
c0c3707f CB |
440 | { |
441 | #if defined __HAIKU__ | |
442 | /* For consistency with perror(). */ | |
443 | snprintf (buf, buflen, "Unknown Application Error (%d)", errnum); | |
444 | #else | |
445 | snprintf (buf, buflen, "Unknown error %d", errnum); | |
446 | #endif | |
447 | } | |
5abebf3c CB |
448 | |
449 | errno = saved_errno; | |
450 | return ret; | |
451 | } | |
452 | } |