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