boost/asio/error.hpp

   1 //
   2 // error.hpp
   3 // ~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 #ifndef BOOST_ASIO_ERROR_HPP
  12 #define BOOST_ASIO_ERROR_HPP
  13
  14 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  15 # pragma once
  16 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  17
  18 #include <boost/asio/detail/push_options.hpp>
  19
  20 #include <boost/asio/detail/push_options.hpp>
  21 #include <boost/config.hpp>
  22 #include <boost/cerrno.hpp>
  23 #include <boost/system/error_code.hpp>
  24 #include <boost/asio/detail/pop_options.hpp>
  25
  26 #include <boost/asio/detail/socket_types.hpp>
  27
  28 #if defined(GENERATING_DOCUMENTATION)
  29 /// INTERNAL ONLY.
  30 # define BOOST_ASIO_NATIVE_ERROR(e) implementation_defined
  31 /// INTERNAL ONLY.
  32 # define BOOST_ASIO_SOCKET_ERROR(e) implementation_defined
  33 /// INTERNAL ONLY.
  34 # define BOOST_ASIO_NETDB_ERROR(e) implementation_defined
  35 /// INTERNAL ONLY.
  36 # define BOOST_ASIO_GETADDRINFO_ERROR(e) implementation_defined
  37 /// INTERNAL ONLY.
  38 # define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined
  39 #elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
  40 # define BOOST_ASIO_NATIVE_ERROR(e) e
  41 # define BOOST_ASIO_SOCKET_ERROR(e) WSA ## e
  42 # define BOOST_ASIO_NETDB_ERROR(e) WSA ## e
  43 # define BOOST_ASIO_GETADDRINFO_ERROR(e) WSA ## e
  44 # define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
  45 #else
  46 # define BOOST_ASIO_NATIVE_ERROR(e) e
  47 # define BOOST_ASIO_SOCKET_ERROR(e) e
  48 # define BOOST_ASIO_NETDB_ERROR(e) e
  49 # define BOOST_ASIO_GETADDRINFO_ERROR(e) e
  50 # define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_posix
  51 #endif
  52
  53 namespace boost {
  54 namespace asio {
  55 namespace error {
  56
  57 enum basic_errors
  58 {
  59   /// Permission denied.
  60   access_denied = BOOST_ASIO_SOCKET_ERROR(EACCES),
  61
  62   /// Address family not supported by protocol.
  63   address_family_not_supported = BOOST_ASIO_SOCKET_ERROR(EAFNOSUPPORT),
  64
  65   /// Address already in use.
  66   address_in_use = BOOST_ASIO_SOCKET_ERROR(EADDRINUSE),
  67
  68   /// Transport endpoint is already connected.
  69   already_connected = BOOST_ASIO_SOCKET_ERROR(EISCONN),
  70
  71   /// Operation already in progress.
  72   already_started = BOOST_ASIO_SOCKET_ERROR(EALREADY),
  73
  74   /// Broken pipe.
  75   broken_pipe = BOOST_ASIO_WIN_OR_POSIX(
  76       BOOST_ASIO_NATIVE_ERROR(ERROR_BROKEN_PIPE),
  77       BOOST_ASIO_NATIVE_ERROR(EPIPE)),
  78
  79   /// A connection has been aborted.
  80   connection_aborted = BOOST_ASIO_SOCKET_ERROR(ECONNABORTED),
  81
  82   /// Connection refused.
  83   connection_refused = BOOST_ASIO_SOCKET_ERROR(ECONNREFUSED),
  84
  85   /// Connection reset by peer.
  86   connection_reset = BOOST_ASIO_SOCKET_ERROR(ECONNRESET),
  87
  88   /// Bad file descriptor.
  89   bad_descriptor = BOOST_ASIO_SOCKET_ERROR(EBADF),
  90
  91   /// Bad address.
  92   fault = BOOST_ASIO_SOCKET_ERROR(EFAULT),
  93
  94   /// No route to host.
  95   host_unreachable = BOOST_ASIO_SOCKET_ERROR(EHOSTUNREACH),
  96
  97   /// Operation now in progress.
  98   in_progress = BOOST_ASIO_SOCKET_ERROR(EINPROGRESS),
  99
 100   /// Interrupted system call.
 101   interrupted = BOOST_ASIO_SOCKET_ERROR(EINTR),
 102
 103   /// Invalid argument.
 104   invalid_argument = BOOST_ASIO_SOCKET_ERROR(EINVAL),
 105
 106   /// Message too long.
 107   message_size = BOOST_ASIO_SOCKET_ERROR(EMSGSIZE),
 108
 109   /// The name was too long.
 110   name_too_long = BOOST_ASIO_SOCKET_ERROR(ENAMETOOLONG),
 111
 112   /// Network is down.
 113   network_down = BOOST_ASIO_SOCKET_ERROR(ENETDOWN),
 114
 115   /// Network dropped connection on reset.
 116   network_reset = BOOST_ASIO_SOCKET_ERROR(ENETRESET),
 117
 118   /// Network is unreachable.
 119   network_unreachable = BOOST_ASIO_SOCKET_ERROR(ENETUNREACH),
 120
 121   /// Too many open files.
 122   no_descriptors = BOOST_ASIO_SOCKET_ERROR(EMFILE),
 123
 124   /// No buffer space available.
 125   no_buffer_space = BOOST_ASIO_SOCKET_ERROR(ENOBUFS),
 126
 127   /// Cannot allocate memory.
 128   no_memory = BOOST_ASIO_WIN_OR_POSIX(
 129       BOOST_ASIO_NATIVE_ERROR(ERROR_OUTOFMEMORY),
 130       BOOST_ASIO_NATIVE_ERROR(ENOMEM)),
 131
 132   /// Operation not permitted.
 133   no_permission = BOOST_ASIO_WIN_OR_POSIX(
 134       BOOST_ASIO_NATIVE_ERROR(ERROR_ACCESS_DENIED),
 135       BOOST_ASIO_NATIVE_ERROR(EPERM)),
 136
 137   /// Protocol not available.
 138   no_protocol_option = BOOST_ASIO_SOCKET_ERROR(ENOPROTOOPT),
 139
 140   /// Transport endpoint is not connected.
 141   not_connected = BOOST_ASIO_SOCKET_ERROR(ENOTCONN),
 142
 143   /// Socket operation on non-socket.
 144   not_socket = BOOST_ASIO_SOCKET_ERROR(ENOTSOCK),
 145
 146   /// Operation cancelled.
 147   operation_aborted = BOOST_ASIO_WIN_OR_POSIX(
 148       BOOST_ASIO_NATIVE_ERROR(ERROR_OPERATION_ABORTED),
 149       BOOST_ASIO_NATIVE_ERROR(ECANCELED)),
 150
 151   /// Operation not supported.
 152   operation_not_supported = BOOST_ASIO_SOCKET_ERROR(EOPNOTSUPP),
 153
 154   /// Cannot send after transport endpoint shutdown.
 155   shut_down = BOOST_ASIO_SOCKET_ERROR(ESHUTDOWN),
 156
 157   /// Connection timed out.
 158   timed_out = BOOST_ASIO_SOCKET_ERROR(ETIMEDOUT),
 159
 160   /// Resource temporarily unavailable.
 161   try_again = BOOST_ASIO_WIN_OR_POSIX(
 162       BOOST_ASIO_NATIVE_ERROR(ERROR_RETRY),
 163       BOOST_ASIO_NATIVE_ERROR(EAGAIN)),
 164
 165   /// The socket is marked non-blocking and the requested operation would block.
 166   would_block = BOOST_ASIO_SOCKET_ERROR(EWOULDBLOCK)
 167 };
 168
 169 enum netdb_errors
 170 {
 171   /// Host not found (authoritative).
 172   host_not_found = BOOST_ASIO_NETDB_ERROR(HOST_NOT_FOUND),
 173
 174   /// Host not found (non-authoritative).
 175   host_not_found_try_again = BOOST_ASIO_NETDB_ERROR(TRY_AGAIN),
 176
 177   /// The query is valid but does not have associated address data.
 178   no_data = BOOST_ASIO_NETDB_ERROR(NO_DATA),
 179
 180   /// A non-recoverable error occurred.
 181   no_recovery = BOOST_ASIO_NETDB_ERROR(NO_RECOVERY)
 182 };
 183
 184 enum addrinfo_errors
 185 {
 186   /// The service is not supported for the given socket type.
 187   service_not_found = BOOST_ASIO_WIN_OR_POSIX(
 188       BOOST_ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND),
 189       BOOST_ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),
 190
 191   /// The socket type is not supported.
 192   socket_type_not_supported = BOOST_ASIO_WIN_OR_POSIX(
 193       BOOST_ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT),
 194       BOOST_ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE))
 195 };
 196
 197 enum misc_errors
 198 {
 199   /// Already open.
 200   already_open = 1,
 201
 202   /// End of file or stream.
 203   eof,
 204
 205   /// Element not found.
 206   not_found,
 207
 208   /// The descriptor cannot fit into the select system call's fd_set.
 209   fd_set_failure
 210 };
 211
 212 enum ssl_errors
 213 {
 214 };
 215
 216 inline const boost::system::error_category& get_system_category()
 217 {
 218   return boost::system::get_system_category();
 219 }
 220
 221 #if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 222
 223 namespace detail {
 224
 225 class netdb_category : public boost::system::error_category
 226 {
 227 public:
 228   const char* name() const
 229   {
 230     return "asio.netdb";
 231   }
 232
 233   std::string message(int value) const
 234   {
 235     if (value == error::host_not_found)
 236       return "Host not found (authoritative)";
 237     if (value == error::host_not_found_try_again)
 238       return "Host not found (non-authoritative), try again later";
 239     if (value == error::no_data)
 240       return "The query is valid, but it does not have associated data";
 241     if (value == error::no_recovery)
 242       return "A non-recoverable error occurred during database lookup";
 243     return "asio.netdb error";
 244   }
 245 };
 246
 247 } // namespace detail
 248
 249 inline const boost::system::error_category& get_netdb_category()
 250 {
 251   static detail::netdb_category instance;
 252   return instance;
 253 }
 254
 255 namespace detail {
 256
 257 class addrinfo_category : public boost::system::error_category
 258 {
 259 public:
 260   const char* name() const
 261   {
 262     return "asio.addrinfo";
 263   }
 264
 265   std::string message(int value) const
 266   {
 267     if (value == error::service_not_found)
 268       return "Service not found";
 269     if (value == error::socket_type_not_supported)
 270       return "Socket type not supported";
 271     return "asio.addrinfo error";
 272   }
 273 };
 274
 275 } // namespace detail
 276
 277 inline const boost::system::error_category& get_addrinfo_category()
 278 {
 279   static detail::addrinfo_category instance;
 280   return instance;
 281 }
 282
 283 #else // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 284
 285 inline const boost::system::error_category& get_netdb_category()
 286 {
 287   return get_system_category();
 288 }
 289
 290 inline const boost::system::error_category& get_addrinfo_category()
 291 {
 292   return get_system_category();
 293 }
 294
 295 #endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 296
 297 namespace detail {
 298
 299 class misc_category : public boost::system::error_category
 300 {
 301 public:
 302   const char* name() const
 303   {
 304     return "asio.misc";
 305   }
 306
 307   std::string message(int value) const
 308   {
 309     if (value == error::already_open)
 310       return "Already open";
 311     if (value == error::eof)
 312       return "End of file";
 313     if (value == error::not_found)
 314       return "Element not found";
 315     if (value == error::fd_set_failure)
 316       return "The descriptor does not fit into the select call's fd_set";
 317     return "asio.misc error";
 318   }
 319 };
 320
 321 } // namespace detail
 322
 323 inline const boost::system::error_category& get_misc_category()
 324 {
 325   static detail::misc_category instance;
 326   return instance;
 327 }
 328
 329 namespace detail {
 330
 331 class ssl_category : public boost::system::error_category
 332 {
 333 public:
 334   const char* name() const
 335   {
 336     return "asio.ssl";
 337   }
 338
 339   std::string message(int) const
 340   {
 341     return "asio.ssl error";
 342   }
 343 };
 344
 345 } // namespace detail
 346
 347 inline const boost::system::error_category& get_ssl_category()
 348 {
 349   static detail::ssl_category instance;
 350   return instance;
 351 }
 352
 353 static const boost::system::error_category& system_category
 354   = boost::asio::error::get_system_category();
 355 static const boost::system::error_category& netdb_category
 356   = boost::asio::error::get_netdb_category();
 357 static const boost::system::error_category& addrinfo_category
 358   = boost::asio::error::get_addrinfo_category();
 359 static const boost::system::error_category& misc_category
 360   = boost::asio::error::get_misc_category();
 361 static const boost::system::error_category& ssl_category
 362   = boost::asio::error::get_ssl_category();
 363
 364 } // namespace error
 365 } // namespace asio
 366
 367 namespace system {
 368
 369 template<> struct is_error_code_enum<boost::asio::error::basic_errors>
 370 {
 371   static const bool value = true;
 372 };
 373
 374 template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
 375 {
 376   static const bool value = true;
 377 };
 378
 379 template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
 380 {
 381   static const bool value = true;
 382 };
 383
 384 template<> struct is_error_code_enum<boost::asio::error::misc_errors>
 385 {
 386   static const bool value = true;
 387 };
 388
 389 template<> struct is_error_code_enum<boost::asio::error::ssl_errors>
 390 {
 391   static const bool value = true;
 392 };
 393
 394 } // namespace system
 395
 396 namespace asio {
 397 namespace error {
 398
 399 inline boost::system::error_code make_error_code(basic_errors e)
 400 {
 401   return boost::system::error_code(
 402       static_cast<int>(e), get_system_category());
 403 }
 404
 405 inline boost::system::error_code make_error_code(netdb_errors e)
 406 {
 407   return boost::system::error_code(
 408       static_cast<int>(e), get_netdb_category());
 409 }
 410
 411 inline boost::system::error_code make_error_code(addrinfo_errors e)
 412 {
 413   return boost::system::error_code(
 414       static_cast<int>(e), get_addrinfo_category());
 415 }
 416
 417 inline boost::system::error_code make_error_code(misc_errors e)
 418 {
 419   return boost::system::error_code(
 420       static_cast<int>(e), get_misc_category());
 421 }
 422
 423 inline boost::system::error_code make_error_code(ssl_errors e)
 424 {
 425   return boost::system::error_code(
 426       static_cast<int>(e), get_ssl_category());
 427 }
 428
 429 } // namespace error
 430 } // namespace asio
 431 } // namespace boost
 432
 433 #undef BOOST_ASIO_NATIVE_ERROR
 434 #undef BOOST_ASIO_SOCKET_ERROR
 435 #undef BOOST_ASIO_NETDB_ERROR
 436 #undef BOOST_ASIO_GETADDRINFO_ERROR
 437 #undef BOOST_ASIO_WIN_OR_POSIX
 438
 439
 440 #include <boost/asio/detail/pop_options.hpp>
 441
 442 #endif // BOOST_ASIO_ERROR_HPP