error.hpp

Go to the documentation of this file.

//
// error.hpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2008 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 ASIO_ERROR_HPP
#define ASIO_ERROR_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include "asio/detail/push_options.hpp"

#include "asio/detail/push_options.hpp"
#include <cerrno>
#include <boost/config.hpp>
#include "asio/detail/pop_options.hpp"

#include "asio/error_code.hpp"
#include "asio/detail/socket_types.hpp"

#if defined(GENERATING_DOCUMENTATION)

# define ASIO_NATIVE_ERROR(e) implementation_defined

# define ASIO_SOCKET_ERROR(e) implementation_defined

# define ASIO_NETDB_ERROR(e) implementation_defined

# define ASIO_GETADDRINFO_ERROR(e) implementation_defined

# define ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined
#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
# define ASIO_NATIVE_ERROR(e) e
# define ASIO_SOCKET_ERROR(e) WSA ## e
# define ASIO_NETDB_ERROR(e) WSA ## e
# define ASIO_GETADDRINFO_ERROR(e) WSA ## e
# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
#else
# define ASIO_NATIVE_ERROR(e) e
# define ASIO_SOCKET_ERROR(e) e
# define ASIO_NETDB_ERROR(e) e
# define ASIO_GETADDRINFO_ERROR(e) e
# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_posix
#endif

namespace asio {
namespace error {

enum basic_errors
{
  access_denied = ASIO_SOCKET_ERROR(EACCES),

  address_family_not_supported = ASIO_SOCKET_ERROR(EAFNOSUPPORT),

  address_in_use = ASIO_SOCKET_ERROR(EADDRINUSE),

  already_connected = ASIO_SOCKET_ERROR(EISCONN),

  already_started = ASIO_SOCKET_ERROR(EALREADY),

  broken_pipe = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(ERROR_BROKEN_PIPE),
      ASIO_NATIVE_ERROR(EPIPE)),

  connection_aborted = ASIO_SOCKET_ERROR(ECONNABORTED),

  connection_refused = ASIO_SOCKET_ERROR(ECONNREFUSED),

  connection_reset = ASIO_SOCKET_ERROR(ECONNRESET),

  bad_descriptor = ASIO_SOCKET_ERROR(EBADF),

  fault = ASIO_SOCKET_ERROR(EFAULT),

  host_unreachable = ASIO_SOCKET_ERROR(EHOSTUNREACH),

  in_progress = ASIO_SOCKET_ERROR(EINPROGRESS),

  interrupted = ASIO_SOCKET_ERROR(EINTR),

  invalid_argument = ASIO_SOCKET_ERROR(EINVAL),

  message_size = ASIO_SOCKET_ERROR(EMSGSIZE),

  name_too_long = ASIO_SOCKET_ERROR(ENAMETOOLONG),

  network_down = ASIO_SOCKET_ERROR(ENETDOWN),

  network_reset = ASIO_SOCKET_ERROR(ENETRESET),

  network_unreachable = ASIO_SOCKET_ERROR(ENETUNREACH),

  no_descriptors = ASIO_SOCKET_ERROR(EMFILE),

  no_buffer_space = ASIO_SOCKET_ERROR(ENOBUFS),

  no_memory = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(ERROR_OUTOFMEMORY),
      ASIO_NATIVE_ERROR(ENOMEM)),

  no_permission = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(ERROR_ACCESS_DENIED),
      ASIO_NATIVE_ERROR(EPERM)),

  no_protocol_option = ASIO_SOCKET_ERROR(ENOPROTOOPT),

  not_connected = ASIO_SOCKET_ERROR(ENOTCONN),

  not_socket = ASIO_SOCKET_ERROR(ENOTSOCK),

  operation_aborted = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(ERROR_OPERATION_ABORTED),
      ASIO_NATIVE_ERROR(ECANCELED)),

  operation_not_supported = ASIO_SOCKET_ERROR(EOPNOTSUPP),

  shut_down = ASIO_SOCKET_ERROR(ESHUTDOWN),

  timed_out = ASIO_SOCKET_ERROR(ETIMEDOUT),

  try_again = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(ERROR_RETRY),
      ASIO_NATIVE_ERROR(EAGAIN)),

  would_block = ASIO_SOCKET_ERROR(EWOULDBLOCK)
};

enum netdb_errors
{
  host_not_found = ASIO_NETDB_ERROR(HOST_NOT_FOUND),

  host_not_found_try_again = ASIO_NETDB_ERROR(TRY_AGAIN),

  no_data = ASIO_NETDB_ERROR(NO_DATA),

  no_recovery = ASIO_NETDB_ERROR(NO_RECOVERY)
};

enum addrinfo_errors
{
  service_not_found = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND),
      ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),

  socket_type_not_supported = ASIO_WIN_OR_POSIX(
      ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT),
      ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE))
};

enum misc_errors
{
  already_open = 1,

  eof,

  not_found,

  fd_set_failure
};

enum ssl_errors
{
};

// boostify: error category definitions go here.

inline asio::error_code make_error_code(basic_errors e)
{
  return asio::error_code(
      static_cast<int>(e), get_system_category());
}

inline asio::error_code make_error_code(netdb_errors e)
{
  return asio::error_code(
      static_cast<int>(e), get_netdb_category());
}

inline asio::error_code make_error_code(addrinfo_errors e)
{
  return asio::error_code(
      static_cast<int>(e), get_addrinfo_category());
}

inline asio::error_code make_error_code(misc_errors e)
{
  return asio::error_code(
      static_cast<int>(e), get_misc_category());
}

inline asio::error_code make_error_code(ssl_errors e)
{
  return asio::error_code(
      static_cast<int>(e), get_ssl_category());
}

} // namespace error
} // namespace asio

#undef ASIO_NATIVE_ERROR
#undef ASIO_SOCKET_ERROR
#undef ASIO_NETDB_ERROR
#undef ASIO_GETADDRINFO_ERROR
#undef ASIO_WIN_OR_POSIX

#include "asio/impl/error_code.ipp"

#include "asio/detail/pop_options.hpp"

#endif // ASIO_ERROR_HPP