// | |
// error.hpp | |
// ~~~~~~~~~ | |
// | |
// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com) | |
// | |
// Distributed under the Boost Software License, Version 1.0. (See accompanying | |
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
// | |
#ifndef BOOST_ASIO_ERROR_HPP | |
#define BOOST_ASIO_ERROR_HPP | |
#if defined(_MSC_VER) && (_MSC_VER >= 1200) | |
# pragma once | |
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) | |
#include <boost/asio/detail/config.hpp> | |
#include <boost/cerrno.hpp> | |
#include <boost/system/error_code.hpp> | |
#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) | |
# include <winerror.h> | |
#else | |
# include <cerrno> | |
# include <netdb.h> | |
#endif | |
#if defined(GENERATING_DOCUMENTATION) | |
/// INTERNAL ONLY. | |
# define BOOST_ASIO_NATIVE_ERROR(e) implementation_defined | |
/// INTERNAL ONLY. | |
# define BOOST_ASIO_SOCKET_ERROR(e) implementation_defined | |
/// INTERNAL ONLY. | |
# define BOOST_ASIO_NETDB_ERROR(e) implementation_defined | |
/// INTERNAL ONLY. | |
# define BOOST_ASIO_GETADDRINFO_ERROR(e) implementation_defined | |
/// INTERNAL ONLY. | |
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined | |
#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__) | |
# define BOOST_ASIO_NATIVE_ERROR(e) e | |
# define BOOST_ASIO_SOCKET_ERROR(e) WSA ## e | |
# define BOOST_ASIO_NETDB_ERROR(e) WSA ## e | |
# define BOOST_ASIO_GETADDRINFO_ERROR(e) WSA ## e | |
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_win | |
#else | |
# define BOOST_ASIO_NATIVE_ERROR(e) e | |
# define BOOST_ASIO_SOCKET_ERROR(e) e | |
# define BOOST_ASIO_NETDB_ERROR(e) e | |
# define BOOST_ASIO_GETADDRINFO_ERROR(e) e | |
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_posix | |
#endif | |
#include <boost/asio/detail/push_options.hpp> | |
namespace boost { | |
namespace asio { | |
namespace error { | |
enum basic_errors | |
{ | |
/// Permission denied. | |
access_denied = BOOST_ASIO_SOCKET_ERROR(EACCES), | |
/// Address family not supported by protocol. | |
address_family_not_supported = BOOST_ASIO_SOCKET_ERROR(EAFNOSUPPORT), | |
/// Address already in use. | |
address_in_use = BOOST_ASIO_SOCKET_ERROR(EADDRINUSE), | |
/// Transport endpoint is already connected. | |
already_connected = BOOST_ASIO_SOCKET_ERROR(EISCONN), | |
/// Operation already in progress. | |
already_started = BOOST_ASIO_SOCKET_ERROR(EALREADY), | |
/// Broken pipe. | |
broken_pipe = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(ERROR_BROKEN_PIPE), | |
BOOST_ASIO_NATIVE_ERROR(EPIPE)), | |
/// A connection has been aborted. | |
connection_aborted = BOOST_ASIO_SOCKET_ERROR(ECONNABORTED), | |
/// Connection refused. | |
connection_refused = BOOST_ASIO_SOCKET_ERROR(ECONNREFUSED), | |
/// Connection reset by peer. | |
connection_reset = BOOST_ASIO_SOCKET_ERROR(ECONNRESET), | |
/// Bad file descriptor. | |
bad_descriptor = BOOST_ASIO_SOCKET_ERROR(EBADF), | |
/// Bad address. | |
fault = BOOST_ASIO_SOCKET_ERROR(EFAULT), | |
/// No route to host. | |
host_unreachable = BOOST_ASIO_SOCKET_ERROR(EHOSTUNREACH), | |
/// Operation now in progress. | |
in_progress = BOOST_ASIO_SOCKET_ERROR(EINPROGRESS), | |
/// Interrupted system call. | |
interrupted = BOOST_ASIO_SOCKET_ERROR(EINTR), | |
/// Invalid argument. | |
invalid_argument = BOOST_ASIO_SOCKET_ERROR(EINVAL), | |
/// Message too long. | |
message_size = BOOST_ASIO_SOCKET_ERROR(EMSGSIZE), | |
/// The name was too long. | |
name_too_long = BOOST_ASIO_SOCKET_ERROR(ENAMETOOLONG), | |
/// Network is down. | |
network_down = BOOST_ASIO_SOCKET_ERROR(ENETDOWN), | |
/// Network dropped connection on reset. | |
network_reset = BOOST_ASIO_SOCKET_ERROR(ENETRESET), | |
/// Network is unreachable. | |
network_unreachable = BOOST_ASIO_SOCKET_ERROR(ENETUNREACH), | |
/// Too many open files. | |
no_descriptors = BOOST_ASIO_SOCKET_ERROR(EMFILE), | |
/// No buffer space available. | |
no_buffer_space = BOOST_ASIO_SOCKET_ERROR(ENOBUFS), | |
/// Cannot allocate memory. | |
no_memory = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(ERROR_OUTOFMEMORY), | |
BOOST_ASIO_NATIVE_ERROR(ENOMEM)), | |
/// Operation not permitted. | |
no_permission = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(ERROR_ACCESS_DENIED), | |
BOOST_ASIO_NATIVE_ERROR(EPERM)), | |
/// Protocol not available. | |
no_protocol_option = BOOST_ASIO_SOCKET_ERROR(ENOPROTOOPT), | |
/// Transport endpoint is not connected. | |
not_connected = BOOST_ASIO_SOCKET_ERROR(ENOTCONN), | |
/// Socket operation on non-socket. | |
not_socket = BOOST_ASIO_SOCKET_ERROR(ENOTSOCK), | |
/// Operation cancelled. | |
operation_aborted = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(ERROR_OPERATION_ABORTED), | |
BOOST_ASIO_NATIVE_ERROR(ECANCELED)), | |
/// Operation not supported. | |
operation_not_supported = BOOST_ASIO_SOCKET_ERROR(EOPNOTSUPP), | |
/// Cannot send after transport endpoint shutdown. | |
shut_down = BOOST_ASIO_SOCKET_ERROR(ESHUTDOWN), | |
/// Connection timed out. | |
timed_out = BOOST_ASIO_SOCKET_ERROR(ETIMEDOUT), | |
/// Resource temporarily unavailable. | |
try_again = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(ERROR_RETRY), | |
BOOST_ASIO_NATIVE_ERROR(EAGAIN)), | |
/// The socket is marked non-blocking and the requested operation would block. | |
would_block = BOOST_ASIO_SOCKET_ERROR(EWOULDBLOCK) | |
}; | |
enum netdb_errors | |
{ | |
/// Host not found (authoritative). | |
host_not_found = BOOST_ASIO_NETDB_ERROR(HOST_NOT_FOUND), | |
/// Host not found (non-authoritative). | |
host_not_found_try_again = BOOST_ASIO_NETDB_ERROR(TRY_AGAIN), | |
/// The query is valid but does not have associated address data. | |
no_data = BOOST_ASIO_NETDB_ERROR(NO_DATA), | |
/// A non-recoverable error occurred. | |
no_recovery = BOOST_ASIO_NETDB_ERROR(NO_RECOVERY) | |
}; | |
enum addrinfo_errors | |
{ | |
/// The service is not supported for the given socket type. | |
service_not_found = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND), | |
BOOST_ASIO_GETADDRINFO_ERROR(EAI_SERVICE)), | |
/// The socket type is not supported. | |
socket_type_not_supported = BOOST_ASIO_WIN_OR_POSIX( | |
BOOST_ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT), | |
BOOST_ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE)) | |
}; | |
enum misc_errors | |
{ | |
/// Already open. | |
already_open = 1, | |
/// End of file or stream. | |
eof, | |
/// Element not found. | |
not_found, | |
/// The descriptor cannot fit into the select system call's fd_set. | |
fd_set_failure | |
}; | |
enum ssl_errors | |
{ | |
}; | |
inline const boost::system::error_category& get_system_category() | |
{ | |
return boost::system::system_category(); | |
} | |
#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) | |
extern BOOST_ASIO_DECL | |
const boost::system::error_category& get_netdb_category(); | |
extern BOOST_ASIO_DECL | |
const boost::system::error_category& get_addrinfo_category(); | |
#else // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) | |
inline const boost::system::error_category& get_netdb_category() | |
{ | |
return get_system_category(); | |
} | |
inline const boost::system::error_category& get_addrinfo_category() | |
{ | |
return get_system_category(); | |
} | |
#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__) | |
extern BOOST_ASIO_DECL | |
const boost::system::error_category& get_misc_category(); | |
extern BOOST_ASIO_DECL | |
const boost::system::error_category& get_ssl_category(); | |
static const boost::system::error_category& system_category | |
= boost::asio::error::get_system_category(); | |
static const boost::system::error_category& netdb_category | |
= boost::asio::error::get_netdb_category(); | |
static const boost::system::error_category& addrinfo_category | |
= boost::asio::error::get_addrinfo_category(); | |
static const boost::system::error_category& misc_category | |
= boost::asio::error::get_misc_category(); | |
static const boost::system::error_category& ssl_category | |
= boost::asio::error::get_ssl_category(); | |
} // namespace error | |
} // namespace asio | |
namespace system { | |
template<> struct is_error_code_enum<boost::asio::error::basic_errors> | |
{ | |
static const bool value = true; | |
}; | |
template<> struct is_error_code_enum<boost::asio::error::netdb_errors> | |
{ | |
static const bool value = true; | |
}; | |
template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors> | |
{ | |
static const bool value = true; | |
}; | |
template<> struct is_error_code_enum<boost::asio::error::misc_errors> | |
{ | |
static const bool value = true; | |
}; | |
template<> struct is_error_code_enum<boost::asio::error::ssl_errors> | |
{ | |
static const bool value = true; | |
}; | |
} // namespace system | |
namespace asio { | |
namespace error { | |
inline boost::system::error_code make_error_code(basic_errors e) | |
{ | |
return boost::system::error_code( | |
static_cast<int>(e), get_system_category()); | |
} | |
inline boost::system::error_code make_error_code(netdb_errors e) | |
{ | |
return boost::system::error_code( | |
static_cast<int>(e), get_netdb_category()); | |
} | |
inline boost::system::error_code make_error_code(addrinfo_errors e) | |
{ | |
return boost::system::error_code( | |
static_cast<int>(e), get_addrinfo_category()); | |
} | |
inline boost::system::error_code make_error_code(misc_errors e) | |
{ | |
return boost::system::error_code( | |
static_cast<int>(e), get_misc_category()); | |
} | |
inline boost::system::error_code make_error_code(ssl_errors e) | |
{ | |
return boost::system::error_code( | |
static_cast<int>(e), get_ssl_category()); | |
} | |
} // namespace error | |
} // namespace asio | |
} // namespace boost | |
#include <boost/asio/detail/pop_options.hpp> | |
#undef BOOST_ASIO_NATIVE_ERROR | |
#undef BOOST_ASIO_SOCKET_ERROR | |
#undef BOOST_ASIO_NETDB_ERROR | |
#undef BOOST_ASIO_GETADDRINFO_ERROR | |
#undef BOOST_ASIO_WIN_OR_POSIX | |
#if defined(BOOST_ASIO_HEADER_ONLY) | |
# include <boost/asio/impl/error.ipp> | |
#endif // defined(BOOST_ASIO_HEADER_ONLY) | |
#endif // BOOST_ASIO_ERROR_HPP |