OLD | NEW |
| (Empty) |
1 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #if defined(__ANDROID__) | |
6 // Post-L versions of bionic define the GNU-specific strerror_r if _GNU_SOURCE | |
7 // is defined, but the symbol is renamed to __gnu_strerror_r which only exists | |
8 // on those later versions. To preserve ABI compatibility with older versions, | |
9 // undefine _GNU_SOURCE and use the POSIX version. | |
10 #undef _GNU_SOURCE | |
11 #endif | |
12 | |
13 #include "build/build_config.h" | |
14 #include "base/safe_strerror_posix.h" | |
15 | |
16 #include <errno.h> | |
17 #include <stdio.h> | |
18 #include <string.h> | |
19 | |
20 #define USE_HISTORICAL_STRERRO_R (defined(__GLIBC__) || defined(OS_NACL)) | |
21 | |
22 #if USE_HISTORICAL_STRERRO_R && defined(__GNUC__) | |
23 // GCC will complain about the unused second wrap function unless we tell it | |
24 // that we meant for them to be potentially unused, which is exactly what this | |
25 // attribute is for. | |
26 #define POSSIBLY_UNUSED __attribute__((unused)) | |
27 #else | |
28 #define POSSIBLY_UNUSED | |
29 #endif | |
30 | |
31 #if USE_HISTORICAL_STRERRO_R | |
32 // glibc has two strerror_r functions: a historical GNU-specific one that | |
33 // returns type char *, and a POSIX.1-2001 compliant one available since 2.3.4 | |
34 // that returns int. This wraps the GNU-specific one. | |
35 static void POSSIBLY_UNUSED wrap_posix_strerror_r( | |
36 char *(*strerror_r_ptr)(int, char *, size_t), | |
37 int err, | |
38 char *buf, | |
39 size_t len) { | |
40 // GNU version. | |
41 char *rc = (*strerror_r_ptr)(err, buf, len); | |
42 if (rc != buf) { | |
43 // glibc did not use buf and returned a static string instead. Copy it | |
44 // into buf. | |
45 buf[0] = '\0'; | |
46 strncat(buf, rc, len - 1); | |
47 } | |
48 // The GNU version never fails. Unknown errors get an "unknown error" message. | |
49 // The result is always null terminated. | |
50 } | |
51 #endif // USE_HISTORICAL_STRERRO_R | |
52 | |
53 // Wrapper for strerror_r functions that implement the POSIX interface. POSIX | |
54 // does not define the behaviour for some of the edge cases, so we wrap it to | |
55 // guarantee that they are handled. This is compiled on all POSIX platforms, but | |
56 // it will only be used on Linux if the POSIX strerror_r implementation is | |
57 // being used (see below). | |
58 static void POSSIBLY_UNUSED wrap_posix_strerror_r( | |
59 int (*strerror_r_ptr)(int, char *, size_t), | |
60 int err, | |
61 char *buf, | |
62 size_t len) { | |
63 int old_errno = errno; | |
64 // Have to cast since otherwise we get an error if this is the GNU version | |
65 // (but in such a scenario this function is never called). Sadly we can't use | |
66 // C++-style casts because the appropriate one is reinterpret_cast but it's | |
67 // considered illegal to reinterpret_cast a type to itself, so we get an | |
68 // error in the opposite case. | |
69 int result = (*strerror_r_ptr)(err, buf, len); | |
70 if (result == 0) { | |
71 // POSIX is vague about whether the string will be terminated, although | |
72 // it indirectly implies that typically ERANGE will be returned, instead | |
73 // of truncating the string. We play it safe by always terminating the | |
74 // string explicitly. | |
75 buf[len - 1] = '\0'; | |
76 } else { | |
77 // Error. POSIX is vague about whether the return value is itself a system | |
78 // error code or something else. On Linux currently it is -1 and errno is | |
79 // set. On BSD-derived systems it is a system error and errno is unchanged. | |
80 // We try and detect which case it is so as to put as much useful info as | |
81 // we can into our message. | |
82 int strerror_error; // The error encountered in strerror | |
83 int new_errno = errno; | |
84 if (new_errno != old_errno) { | |
85 // errno was changed, so probably the return value is just -1 or something | |
86 // else that doesn't provide any info, and errno is the error. | |
87 strerror_error = new_errno; | |
88 } else { | |
89 // Either the error from strerror_r was the same as the previous value, or | |
90 // errno wasn't used. Assume the latter. | |
91 strerror_error = result; | |
92 } | |
93 // snprintf truncates and always null-terminates. | |
94 snprintf(buf, | |
95 len, | |
96 "Error %d while retrieving error %d", | |
97 strerror_error, | |
98 err); | |
99 } | |
100 errno = old_errno; | |
101 } | |
102 | |
103 void safe_strerror_r(int err, char *buf, size_t len) { | |
104 if (buf == NULL || len <= 0) { | |
105 return; | |
106 } | |
107 // If using glibc (i.e., Linux), the compiler will automatically select the | |
108 // appropriate overloaded function based on the function type of strerror_r. | |
109 // The other one will be elided from the translation unit since both are | |
110 // static. | |
111 wrap_posix_strerror_r(&strerror_r, err, buf, len); | |
112 } | |
113 | |
114 std::string safe_strerror(int err) { | |
115 const int buffer_size = 256; | |
116 char buf[buffer_size]; | |
117 safe_strerror_r(err, buf, sizeof(buf)); | |
118 return std::string(buf); | |
119 } | |
OLD | NEW |