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