lib/strerror_r.c

   1 /* strerror_r.c --- POSIX compatible system error routine
   2
   3    Copyright (C) 2010-2016 Free Software Foundation, Inc.
   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
  16    along with this program.  If not, see <http://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
  32 #include "strerror-override.h"
  33
  34 #if (__GLIBC__ >= 2 || defined __UCLIBC__ || defined __CYGWIN__) && HAVE___XPG_STRERROR_R /* glibc >= 2.3.4, cygwin >= 1.7.9 */
  35
  36 # define USE_XPG_STRERROR_R 1
  37 extern
  38 #ifdef __cplusplus
  39 "C"
  40 #endif
  41 int __xpg_strerror_r (int errnum, char *buf, size_t buflen);
  42
  43 #elif HAVE_DECL_STRERROR_R && !(__GLIBC__ >= 2 || defined __UCLIBC__ || defined __CYGWIN__)
  44
  45 /* The system's strerror_r function 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 # define USE_SYSTEM_STRERROR_R 1
  51
  52 #else /* (__GLIBC__ >= 2 || defined __UCLIBC__ || defined __CYGWIN__ ? !HAVE___XPG_STRERROR_R : !HAVE_DECL_STRERROR_R) */
  53
  54 /* Use the system's strerror().  Exclude glibc and cygwin because the
  55    system strerror_r has the wrong return type, and cygwin 1.7.9
  56    strerror_r clobbers strerror.  */
  57 # undef strerror
  58
  59 # define USE_SYSTEM_STRERROR 1
  60
  61 # if defined __NetBSD__ || defined __hpux || ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__) || defined __sgi || (defined __sun && !defined _LP64) || defined __CYGWIN__
  62
  63 /* No locking needed.  */
  64
  65 /* Get catgets internationalization functions.  */
  66 #  if HAVE_CATGETS
  67 #   include <nl_types.h>
  68 #  endif
  69
  70 #ifdef __cplusplus
  71 extern "C" {
  72 #endif
  73
  74 /* Get sys_nerr, sys_errlist on HP-UX (otherwise only declared in C++ mode).
  75    Get sys_nerr, sys_errlist on IRIX (otherwise only declared with _SGIAPI).  */
  76 #  if defined __hpux || defined __sgi
  77 extern int sys_nerr;
  78 extern char *sys_errlist[];
  79 #  endif
  80
  81 /* Get sys_nerr on Solaris.  */
  82 #  if defined __sun && !defined _LP64
  83 extern int sys_nerr;
  84 #  endif
  85
  86 #ifdef __cplusplus
  87 }
  88 #endif
  89
  90 # else
  91
  92 #  include "glthread/lock.h"
  93
  94 /* This lock protects the buffer returned by strerror().  We assume that
  95    no other uses of strerror() exist in the program.  */
  96 gl_lock_define_initialized(static, strerror_lock)
  97
  98 # endif
  99
 100 #endif
 101
 102 /* On MSVC, there is no snprintf() function, just a _snprintf().
 103    It is of lower quality, but sufficient for the simple use here.
 104    We only have to make sure to NUL terminate the result (_snprintf
 105    does not NUL terminate, like strncpy).  */
 106 #if !HAVE_SNPRINTF
 107 static int
 108 local_snprintf (char *buf, size_t buflen, const char *format, ...)
 109 {
 110   va_list args;
 111   int result;
 112
 113   va_start (args, format);
 114   result = _vsnprintf (buf, buflen, format, args);
 115   va_end (args);
 116   if (buflen > 0 && (result < 0 || result >= buflen))
 117     buf[buflen - 1] = '\0';
 118   return result;
 119 }
 120 # define snprintf local_snprintf
 121 #endif
 122
 123 /* Copy as much of MSG into BUF as possible, without corrupting errno.
 124    Return 0 if MSG fit in BUFLEN, otherwise return ERANGE.  */
 125 static int
 126 safe_copy (char *buf, size_t buflen, const char *msg)
 127 {
 128   size_t len = strlen (msg);
 129   int ret;
 130
 131   if (len < buflen)
 132     {
 133       /* Although POSIX allows memcpy() to corrupt errno, we don't
 134          know of any implementation where this is a real problem.  */
 135       memcpy (buf, msg, len + 1);
 136       ret = 0;
 137     }
 138   else
 139     {
 140       memcpy (buf, msg, buflen - 1);
 141       buf[buflen - 1] = '\0';
 142       ret = ERANGE;
 143     }
 144   return ret;
 145 }
 146
 147
 148 int
 149 strerror_r (int errnum, char *buf, size_t buflen)
 150 #undef strerror_r
 151 {
 152   /* Filter this out now, so that rest of this replacement knows that
 153      there is room for a non-empty message and trailing NUL.  */
 154   if (buflen <= 1)
 155     {
 156       if (buflen)
 157         *buf = '\0';
 158       return ERANGE;
 159     }
 160   *buf = '\0';
 161
 162   /* Check for gnulib overrides.  */
 163   {
 164     char const *msg = strerror_override (errnum);
 165
 166     if (msg)
 167       return safe_copy (buf, buflen, msg);
 168   }
 169
 170   {
 171     int ret;
 172     int saved_errno = errno;
 173
 174 #if USE_XPG_STRERROR_R
 175
 176     {
 177       ret = __xpg_strerror_r (errnum, buf, buflen);
 178       if (ret < 0)
 179         ret = errno;
 180       if (!*buf)
 181         {
 182           /* glibc 2.13 would not touch buf on err, so we have to fall
 183              back to GNU strerror_r which always returns a thread-safe
 184              untruncated string to (partially) copy into our buf.  */
 185           safe_copy (buf, buflen, strerror_r (errnum, buf, buflen));
 186         }
 187     }
 188
 189 #elif USE_SYSTEM_STRERROR_R
 190
 191     if (buflen > INT_MAX)
 192       buflen = INT_MAX;
 193
 194 # ifdef __hpux
 195     /* On HP-UX 11.31, strerror_r always fails when buflen < 80; it
 196        also fails to change buf on EINVAL.  */
 197     {
 198       char stackbuf[80];
 199
 200       if (buflen < sizeof stackbuf)
 201         {
 202           ret = strerror_r (errnum, stackbuf, sizeof stackbuf);
 203           if (ret == 0)
 204             ret = safe_copy (buf, buflen, stackbuf);
 205         }
 206       else
 207         ret = strerror_r (errnum, buf, buflen);
 208     }
 209 # else
 210     ret = strerror_r (errnum, buf, buflen);
 211
 212     /* Some old implementations may return (-1, EINVAL) instead of EINVAL.  */
 213     if (ret < 0)
 214       ret = errno;
 215 # endif
 216
 217 # ifdef _AIX
 218     /* AIX returns 0 rather than ERANGE when truncating strings; try
 219        again until we are sure we got the entire string.  */
 220     if (!ret && strlen (buf) == buflen - 1)
 221       {
 222         char stackbuf[STACKBUF_LEN];
 223         size_t len;
 224         strerror_r (errnum, stackbuf, sizeof stackbuf);
 225         len = strlen (stackbuf);
 226         /* STACKBUF_LEN should have been large enough.  */
 227         if (len + 1 == sizeof stackbuf)
 228           abort ();
 229         if (buflen <= len)
 230           ret = ERANGE;
 231       }
 232 # else
 233     /* Solaris 10 does not populate buf on ERANGE.  OpenBSD 4.7
 234        truncates early on ERANGE rather than return a partial integer.
 235        We prefer the maximal string.  We set buf[0] earlier, and we
 236        know of no implementation that modifies buf to be an
 237        unterminated string, so this strlen should be portable in
 238        practice (rather than pulling in a safer strnlen).  */
 239     if (ret == ERANGE && strlen (buf) < buflen - 1)
 240       {
 241         char stackbuf[STACKBUF_LEN];
 242
 243         /* STACKBUF_LEN should have been large enough.  */
 244         if (strerror_r (errnum, stackbuf, sizeof stackbuf) == ERANGE)
 245           abort ();
 246         safe_copy (buf, buflen, stackbuf);
 247       }
 248 # endif
 249
 250 #else /* USE_SYSTEM_STRERROR */
 251
 252     /* Try to do what strerror (errnum) does, but without clobbering the
 253        buffer used by strerror().  */
 254
 255 # if defined __NetBSD__ || defined __hpux || ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__) || defined __CYGWIN__ /* NetBSD, HP-UX, native Windows, Cygwin */
 256
 257     /* NetBSD:         sys_nerr, sys_errlist are declared through _NETBSD_SOURCE
 258                        and <errno.h> above.
 259        HP-UX:          sys_nerr, sys_errlist are declared explicitly above.
 260        native Windows: sys_nerr, sys_errlist are declared in <stdlib.h>.
 261        Cygwin:         sys_nerr, sys_errlist are declared in <errno.h>.  */
 262     if (errnum >= 0 && errnum < sys_nerr)
 263       {
 264 #  if HAVE_CATGETS && (defined __NetBSD__ || defined __hpux)
 265 #   if defined __NetBSD__
 266         nl_catd catd = catopen ("libc", NL_CAT_LOCALE);
 267         const char *errmsg =
 268           (catd != (nl_catd)-1
 269            ? catgets (catd, 1, errnum, sys_errlist[errnum])
 270            : sys_errlist[errnum]);
 271 #   endif
 272 #   if defined __hpux
 273         nl_catd catd = catopen ("perror", NL_CAT_LOCALE);
 274         const char *errmsg =
 275           (catd != (nl_catd)-1
 276            ? catgets (catd, 1, 1 + errnum, sys_errlist[errnum])
 277            : sys_errlist[errnum]);
 278 #   endif
 279 #  else
 280         const char *errmsg = sys_errlist[errnum];
 281 #  endif
 282         if (errmsg == NULL || *errmsg == '\0')
 283           ret = EINVAL;
 284         else
 285           ret = safe_copy (buf, buflen, errmsg);
 286 #  if HAVE_CATGETS && (defined __NetBSD__ || defined __hpux)
 287         if (catd != (nl_catd)-1)
 288           catclose (catd);
 289 #  endif
 290       }
 291     else
 292       ret = EINVAL;
 293
 294 # elif defined __sgi || (defined __sun && !defined _LP64) /* IRIX, Solaris <= 9 32-bit */
 295
 296     /* For a valid error number, the system's strerror() function returns
 297        a pointer to a not copied string, not to a buffer.  */
 298     if (errnum >= 0 && errnum < sys_nerr)
 299       {
 300         char *errmsg = strerror (errnum);
 301
 302         if (errmsg == NULL || *errmsg == '\0')
 303           ret = EINVAL;
 304         else
 305           ret = safe_copy (buf, buflen, errmsg);
 306       }
 307     else
 308       ret = EINVAL;
 309
 310 # else
 311
 312     gl_lock_lock (strerror_lock);
 313
 314     {
 315       char *errmsg = strerror (errnum);
 316
 317       /* For invalid error numbers, strerror() on
 318            - IRIX 6.5 returns NULL,
 319            - HP-UX 11 returns an empty string.  */
 320       if (errmsg == NULL || *errmsg == '\0')
 321         ret = EINVAL;
 322       else
 323         ret = safe_copy (buf, buflen, errmsg);
 324     }
 325
 326     gl_lock_unlock (strerror_lock);
 327
 328 # endif
 329
 330 #endif
 331
 332     if (ret == EINVAL && !*buf)
 333       snprintf (buf, buflen, "Unknown error %d", errnum);
 334
 335     errno = saved_errno;
 336     return ret;
 337   }
 338 }