base/safe_strerror_posix.cc

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