Home | History | Annotate | Download | only in posix 
      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 
     21 namespace 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.
     42 static 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).
     65 static 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 
    110 void 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 
    121 std::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