libcxx/src/system_error.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <__assert>
  10 #include <__config>
  11 #include <__system_error/throw_system_error.h>
  12 #include <__verbose_abort>
  13 #include <cerrno>
  14 #include <cstdio>
  15 #include <cstdlib>
  16 #include <cstring>
  17 #include <string.h>
  18 #include <string>
  19 #include <system_error>
  20
  21 #include "include/config_elast.h"
  22
  23 #if defined(__ANDROID__)
  24 #  include <android/api-level.h>
  25 #endif
  26
  27 _LIBCPP_BEGIN_NAMESPACE_STD
  28
  29 namespace {
  30 #if _LIBCPP_HAS_THREADS
  31
  32 //  GLIBC also uses 1024 as the maximum buffer size internally.
  33 constexpr size_t strerror_buff_size = 1024;
  34
  35 string do_strerror_r(int ev);
  36
  37 #  if defined(_LIBCPP_MSVCRT_LIKE)
  38 string do_strerror_r(int ev) {
  39   char buffer[strerror_buff_size];
  40   if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
  41     return string(buffer);
  42   std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
  43   return string(buffer);
  44 }
  45 #  else
  46
  47 // Only one of the two following functions will be used, depending on
  48 // the return type of strerror_r:
  49
  50 // For the GNU variant, a char* return value:
  51 __attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) {
  52   // GNU always returns a string pointer in its return value. The
  53   // string might point to either the input buffer, or a static
  54   // buffer, but we don't care which.
  55   return strerror_return;
  56 }
  57
  58 // For the POSIX variant: an int return value.
  59 __attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) {
  60   // The POSIX variant either:
  61   // - fills in the provided buffer and returns 0
  62   // - returns a positive error value, or
  63   // - returns -1 and fills in errno with an error value.
  64   if (strerror_return == 0)
  65     return buffer;
  66
  67   // Only handle EINVAL. Other errors abort.
  68   int new_errno = strerror_return == -1 ? errno : strerror_return;
  69   if (new_errno == EINVAL)
  70     return "";
  71
  72   _LIBCPP_ASSERT_INTERNAL(new_errno == ERANGE, "unexpected error from ::strerror_r");
  73   // FIXME maybe? 'strerror_buff_size' is likely to exceed the
  74   // maximum error size so ERANGE shouldn't be returned.
  75   std::abort();
  76 }
  77
  78 // This function handles both GNU and POSIX variants, dispatching to
  79 // one of the two above functions.
  80 string do_strerror_r(int ev) {
  81   char buffer[strerror_buff_size];
  82   // Preserve errno around the call. (The C++ standard requires that
  83   // system_error functions not modify errno).
  84   const int old_errno       = errno;
  85   const char* error_message = handle_strerror_r_return(::strerror_r(ev, buffer, strerror_buff_size), buffer);
  86   // If we didn't get any message, print one now.
  87   if (!error_message[0]) {
  88     std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
  89     error_message = buffer;
  90   }
  91   errno = old_errno;
  92   return string(error_message);
  93 }
  94 #  endif
  95
  96 #endif // _LIBCPP_HAS_THREADS
  97
  98 string make_error_str(const error_code& ec, string what_arg) {
  99   if (ec) {
 100     if (!what_arg.empty()) {
 101       what_arg += ": ";
 102     }
 103     what_arg += ec.message();
 104   }
 105   return what_arg;
 106 }
 107
 108 string make_error_str(const error_code& ec) {
 109   if (ec) {
 110     return ec.message();
 111   }
 112   return string();
 113 }
 114 } // namespace
 115
 116 string __do_message::message(int ev) const {
 117 #if !_LIBCPP_HAS_THREADS
 118   return string(::strerror(ev));
 119 #else
 120   return do_strerror_r(ev);
 121 #endif
 122 }
 123
 124 class _LIBCPP_HIDDEN __generic_error_category : public __do_message {
 125 public:
 126   virtual const char* name() const noexcept;
 127   virtual string message(int ev) const;
 128 };
 129
 130 const char* __generic_error_category::name() const noexcept { return "generic"; }
 131
 132 string __generic_error_category::message(int ev) const {
 133 #ifdef _LIBCPP_ELAST
 134   if (ev > _LIBCPP_ELAST)
 135     return string("unspecified generic_category error");
 136 #endif // _LIBCPP_ELAST
 137   return __do_message::message(ev);
 138 }
 139
 140 const error_category& generic_category() noexcept {
 141   union AvoidDestroyingGenericCategory {
 142     __generic_error_category generic_error_category;
 143     constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
 144     ~AvoidDestroyingGenericCategory() {}
 145   };
 146   constinit static AvoidDestroyingGenericCategory helper;
 147   return helper.generic_error_category;
 148 }
 149
 150 class _LIBCPP_HIDDEN __system_error_category : public __do_message {
 151 public:
 152   virtual const char* name() const noexcept;
 153   virtual string message(int ev) const;
 154   virtual error_condition default_error_condition(int ev) const noexcept;
 155 };
 156
 157 const char* __system_error_category::name() const noexcept { return "system"; }
 158
 159 string __system_error_category::message(int ev) const {
 160 #ifdef _LIBCPP_ELAST
 161   if (ev > _LIBCPP_ELAST)
 162     return string("unspecified system_category error");
 163 #endif // _LIBCPP_ELAST
 164   return __do_message::message(ev);
 165 }
 166
 167 error_condition __system_error_category::default_error_condition(int ev) const noexcept {
 168 #ifdef _LIBCPP_ELAST
 169   if (ev > _LIBCPP_ELAST)
 170     return error_condition(ev, system_category());
 171 #endif // _LIBCPP_ELAST
 172   return error_condition(ev, generic_category());
 173 }
 174
 175 const error_category& system_category() noexcept {
 176   union AvoidDestroyingSystemCategory {
 177     __system_error_category system_error_category;
 178     constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
 179     ~AvoidDestroyingSystemCategory() {}
 180   };
 181   constinit static AvoidDestroyingSystemCategory helper;
 182   return helper.system_error_category;
 183 }
 184
 185 // error_condition
 186
 187 string error_condition::message() const { return __cat_->message(__val_); }
 188
 189 // error_code
 190
 191 string error_code::message() const { return __cat_->message(__val_); }
 192
 193 // system_error
 194
 195 system_error::system_error(error_code ec, const string& what_arg)
 196     : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
 197
 198 system_error::system_error(error_code ec, const char* what_arg)
 199     : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
 200
 201 system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {}
 202
 203 system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
 204     : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
 205
 206 system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
 207     : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
 208
 209 system_error::system_error(int ev, const error_category& ecat)
 210     : runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {}
 211
 212 system_error::~system_error() noexcept {}
 213
 214 void __throw_system_error(int ev, const char* what_arg) {
 215 #if _LIBCPP_HAS_EXCEPTIONS
 216   std::__throw_system_error(error_code(ev, system_category()), what_arg);
 217 #else
 218   // The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
 219   _LIBCPP_VERBOSE_ABORT(
 220       "system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
 221 #endif
 222 }
 223
 224 _LIBCPP_END_NAMESPACE_STD