1 /* strerror_r.c --- POSIX compatible system error routine 2 3 Copyright (C) 2010-2022 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 } 452