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 <optional>
  18 #include <string.h>
  19 #include <string>
  20 #include <system_error>
  21
  22 #include "include/config_elast.h"
  23
  24 #if defined(_LIBCPP_WIN32API)
  25 #  include <windows.h>
  26 #  include <winerror.h>
  27 #endif
  28
  29 _LIBCPP_BEGIN_NAMESPACE_STD
  30
  31 #if defined(_LIBCPP_WIN32API)
  32
  33 namespace {
  34 std::optional<errc> __win_err_to_errc(int err) {
  35   switch (err) {
  36   case ERROR_ACCESS_DENIED:
  37     return errc::permission_denied;
  38   case ERROR_ALREADY_EXISTS:
  39     return errc::file_exists;
  40   case ERROR_BAD_NETPATH:
  41     return errc::no_such_file_or_directory;
  42   case ERROR_BAD_PATHNAME:
  43     return errc::no_such_file_or_directory;
  44   case ERROR_BAD_UNIT:
  45     return errc::no_such_device;
  46   case ERROR_BROKEN_PIPE:
  47     return errc::broken_pipe;
  48   case ERROR_BUFFER_OVERFLOW:
  49     return errc::filename_too_long;
  50   case ERROR_BUSY:
  51     return errc::device_or_resource_busy;
  52   case ERROR_BUSY_DRIVE:
  53     return errc::device_or_resource_busy;
  54   case ERROR_CANNOT_MAKE:
  55     return errc::permission_denied;
  56   case ERROR_CANTOPEN:
  57     return errc::io_error;
  58   case ERROR_CANTREAD:
  59     return errc::io_error;
  60   case ERROR_CANTWRITE:
  61     return errc::io_error;
  62   case ERROR_CURRENT_DIRECTORY:
  63     return errc::permission_denied;
  64   case ERROR_DEV_NOT_EXIST:
  65     return errc::no_such_device;
  66   case ERROR_DEVICE_IN_USE:
  67     return errc::device_or_resource_busy;
  68   case ERROR_DIR_NOT_EMPTY:
  69     return errc::directory_not_empty;
  70   case ERROR_DIRECTORY:
  71     return errc::invalid_argument;
  72   case ERROR_DISK_FULL:
  73     return errc::no_space_on_device;
  74   case ERROR_FILE_EXISTS:
  75     return errc::file_exists;
  76   case ERROR_FILE_NOT_FOUND:
  77     return errc::no_such_file_or_directory;
  78   case ERROR_HANDLE_DISK_FULL:
  79     return errc::no_space_on_device;
  80   case ERROR_INVALID_ACCESS:
  81     return errc::permission_denied;
  82   case ERROR_INVALID_DRIVE:
  83     return errc::no_such_device;
  84   case ERROR_INVALID_FUNCTION:
  85     return errc::function_not_supported;
  86   case ERROR_INVALID_HANDLE:
  87     return errc::invalid_argument;
  88   case ERROR_INVALID_NAME:
  89     return errc::no_such_file_or_directory;
  90   case ERROR_INVALID_PARAMETER:
  91     return errc::invalid_argument;
  92   case ERROR_LOCK_VIOLATION:
  93     return errc::no_lock_available;
  94   case ERROR_LOCKED:
  95     return errc::no_lock_available;
  96   case ERROR_NEGATIVE_SEEK:
  97     return errc::invalid_argument;
  98   case ERROR_NOACCESS:
  99     return errc::permission_denied;
 100   case ERROR_NOT_ENOUGH_MEMORY:
 101     return errc::not_enough_memory;
 102   case ERROR_NOT_READY:
 103     return errc::resource_unavailable_try_again;
 104   case ERROR_NOT_SAME_DEVICE:
 105     return errc::cross_device_link;
 106   case ERROR_NOT_SUPPORTED:
 107     return errc::not_supported;
 108   case ERROR_OPEN_FAILED:
 109     return errc::io_error;
 110   case ERROR_OPEN_FILES:
 111     return errc::device_or_resource_busy;
 112   case ERROR_OPERATION_ABORTED:
 113     return errc::operation_canceled;
 114   case ERROR_OUTOFMEMORY:
 115     return errc::not_enough_memory;
 116   case ERROR_PATH_NOT_FOUND:
 117     return errc::no_such_file_or_directory;
 118   case ERROR_READ_FAULT:
 119     return errc::io_error;
 120   case ERROR_REPARSE_TAG_INVALID:
 121     return errc::invalid_argument;
 122   case ERROR_RETRY:
 123     return errc::resource_unavailable_try_again;
 124   case ERROR_SEEK:
 125     return errc::io_error;
 126   case ERROR_SHARING_VIOLATION:
 127     return errc::permission_denied;
 128   case ERROR_TOO_MANY_OPEN_FILES:
 129     return errc::too_many_files_open;
 130   case ERROR_WRITE_FAULT:
 131     return errc::io_error;
 132   case ERROR_WRITE_PROTECT:
 133     return errc::permission_denied;
 134   default:
 135     return {};
 136   }
 137 }
 138 } // namespace
 139 #endif
 140
 141 namespace {
 142 #if _LIBCPP_HAS_THREADS
 143
 144 //  GLIBC also uses 1024 as the maximum buffer size internally.
 145 constexpr size_t strerror_buff_size = 1024;
 146
 147 string do_strerror_r(int ev);
 148
 149 #  if defined(_LIBCPP_MSVCRT_LIKE)
 150 string do_strerror_r(int ev) {
 151   char buffer[strerror_buff_size];
 152   if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
 153     return string(buffer);
 154   std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
 155   return string(buffer);
 156 }
 157 #  else
 158
 159 // Only one of the two following functions will be used, depending on
 160 // the return type of strerror_r:
 161
 162 // For the GNU variant, a char* return value:
 163 __attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) {
 164   // GNU always returns a string pointer in its return value. The
 165   // string might point to either the input buffer, or a static
 166   // buffer, but we don't care which.
 167   return strerror_return;
 168 }
 169
 170 // For the POSIX variant: an int return value.
 171 __attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) {
 172   // The POSIX variant either:
 173   // - fills in the provided buffer and returns 0
 174   // - returns a positive error value, or
 175   // - returns -1 and fills in errno with an error value.
 176   if (strerror_return == 0)
 177     return buffer;
 178
 179   // Only handle EINVAL. Other errors abort.
 180   int new_errno = strerror_return == -1 ? errno : strerror_return;
 181   if (new_errno == EINVAL)
 182     return "";
 183
 184   _LIBCPP_ASSERT_INTERNAL(new_errno == ERANGE, "unexpected error from ::strerror_r");
 185   // FIXME maybe? 'strerror_buff_size' is likely to exceed the
 186   // maximum error size so ERANGE shouldn't be returned.
 187   std::abort();
 188 }
 189
 190 // This function handles both GNU and POSIX variants, dispatching to
 191 // one of the two above functions.
 192 string do_strerror_r(int ev) {
 193   char buffer[strerror_buff_size];
 194   // Preserve errno around the call. (The C++ standard requires that
 195   // system_error functions not modify errno).
 196   const int old_errno       = errno;
 197   const char* error_message = handle_strerror_r_return(::strerror_r(ev, buffer, strerror_buff_size), buffer);
 198   // If we didn't get any message, print one now.
 199   if (!error_message[0]) {
 200     std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
 201     error_message = buffer;
 202   }
 203   errno = old_errno;
 204   return string(error_message);
 205 }
 206 #  endif
 207
 208 #endif // _LIBCPP_HAS_THREADS
 209
 210 string make_error_str(const error_code& ec, string what_arg) {
 211   if (ec) {
 212     if (!what_arg.empty()) {
 213       what_arg += ": ";
 214     }
 215     what_arg += ec.message();
 216   }
 217   return what_arg;
 218 }
 219
 220 string make_error_str(const error_code& ec) {
 221   if (ec) {
 222     return ec.message();
 223   }
 224   return string();
 225 }
 226 } // namespace
 227
 228 string __do_message::message(int ev) const {
 229 #if !_LIBCPP_HAS_THREADS
 230   return string(::strerror(ev));
 231 #else
 232   return do_strerror_r(ev);
 233 #endif
 234 }
 235
 236 class _LIBCPP_HIDDEN __generic_error_category : public __do_message {
 237 public:
 238   virtual const char* name() const noexcept;
 239   virtual string message(int ev) const;
 240 };
 241
 242 const char* __generic_error_category::name() const noexcept { return "generic"; }
 243
 244 string __generic_error_category::message(int ev) const {
 245 #ifdef _LIBCPP_ELAST
 246   if (ev > _LIBCPP_ELAST)
 247     return string("unspecified generic_category error");
 248 #endif // _LIBCPP_ELAST
 249   return __do_message::message(ev);
 250 }
 251
 252 const error_category& generic_category() noexcept {
 253   union AvoidDestroyingGenericCategory {
 254     __generic_error_category generic_error_category;
 255     constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
 256     ~AvoidDestroyingGenericCategory() {}
 257   };
 258   constinit static AvoidDestroyingGenericCategory helper;
 259   return helper.generic_error_category;
 260 }
 261
 262 class _LIBCPP_HIDDEN __system_error_category : public __do_message {
 263 public:
 264   virtual const char* name() const noexcept;
 265   virtual string message(int ev) const;
 266   virtual error_condition default_error_condition(int ev) const noexcept;
 267 };
 268
 269 const char* __system_error_category::name() const noexcept { return "system"; }
 270
 271 string __system_error_category::message(int ev) const {
 272 #ifdef _LIBCPP_WIN32API
 273   std::string result;
 274   char* str               = nullptr;
 275   unsigned long num_chars = ::FormatMessageA(
 276       FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 277       nullptr,
 278       ev,
 279       0,
 280       reinterpret_cast<char*>(&str),
 281       0,
 282       nullptr);
 283   auto is_whitespace = [](char ch) { return ch == '\n' || ch == '\r' || ch == ' '; };
 284   while (num_chars > 0 && is_whitespace(str[num_chars - 1]))
 285     --num_chars;
 286
 287   if (num_chars)
 288     result = std::string(str, num_chars);
 289   else
 290     result = "Unknown error";
 291
 292   LocalFree(str);
 293   return result;
 294 #else
 295 #  ifdef _LIBCPP_ELAST
 296   if (ev > _LIBCPP_ELAST)
 297     return string("unspecified system_category error");
 298 #  endif // _LIBCPP_ELAST
 299   return __do_message::message(ev);
 300 #endif
 301 }
 302
 303 error_condition __system_error_category::default_error_condition(int ev) const noexcept {
 304 #ifdef _LIBCPP_WIN32API
 305   // Remap windows error codes to generic error codes if possible.
 306   if (ev == 0)
 307     return error_condition(0, generic_category());
 308   if (auto maybe_errc = __win_err_to_errc(ev))
 309     return error_condition(static_cast<int>(*maybe_errc), generic_category());
 310   return error_condition(ev, system_category());
 311 #else
 312 #  ifdef _LIBCPP_ELAST
 313   if (ev > _LIBCPP_ELAST)
 314     return error_condition(ev, system_category());
 315 #  endif // _LIBCPP_ELAST
 316   return error_condition(ev, generic_category());
 317 #endif
 318 }
 319
 320 const error_category& system_category() noexcept {
 321   union AvoidDestroyingSystemCategory {
 322     __system_error_category system_error_category;
 323     constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
 324     ~AvoidDestroyingSystemCategory() {}
 325   };
 326   constinit static AvoidDestroyingSystemCategory helper;
 327   return helper.system_error_category;
 328 }
 329
 330 // error_condition
 331
 332 string error_condition::message() const { return __cat_->message(__val_); }
 333
 334 // error_code
 335
 336 string error_code::message() const { return __cat_->message(__val_); }
 337
 338 // system_error
 339
 340 system_error::system_error(error_code ec, const string& what_arg)
 341     : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
 342
 343 system_error::system_error(error_code ec, const char* what_arg)
 344     : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
 345
 346 system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {}
 347
 348 system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
 349     : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
 350
 351 system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
 352     : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
 353
 354 system_error::system_error(int ev, const error_category& ecat)
 355     : runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {}
 356
 357 system_error::~system_error() noexcept {}
 358
 359 void __throw_system_error(int ev, const char* what_arg) {
 360 #if _LIBCPP_HAS_EXCEPTIONS
 361   std::__throw_system_error(error_code(ev, generic_category()), what_arg);
 362 #else
 363   // The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
 364   _LIBCPP_VERBOSE_ABORT(
 365       "system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
 366 #endif
 367 }
 368
 369 _LIBCPP_END_NAMESPACE_STD