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