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