// | |
// detail/kqueue_reactor.hpp | |
// ~~~~~~~~~~~~~~~~~~~~~~~~~ | |
// | |
// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com) | |
// Copyright (c) 2005 Stefan Arentz (stefan at soze 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_DETAIL_KQUEUE_REACTOR_HPP | |
#define BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP | |
#if defined(_MSC_VER) && (_MSC_VER >= 1200) | |
# pragma once | |
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) | |
#include <boost/asio/detail/config.hpp> | |
#if defined(BOOST_ASIO_HAS_KQUEUE) | |
#include <cstddef> | |
#include <sys/types.h> | |
#include <sys/event.h> | |
#include <sys/time.h> | |
#include <boost/asio/detail/kqueue_reactor_fwd.hpp> | |
#include <boost/asio/detail/mutex.hpp> | |
#include <boost/asio/detail/object_pool.hpp> | |
#include <boost/asio/detail/op_queue.hpp> | |
#include <boost/asio/detail/reactor_op.hpp> | |
#include <boost/asio/detail/select_interrupter.hpp> | |
#include <boost/asio/detail/socket_types.hpp> | |
#include <boost/asio/detail/timer_op.hpp> | |
#include <boost/asio/detail/timer_queue_base.hpp> | |
#include <boost/asio/detail/timer_queue_fwd.hpp> | |
#include <boost/asio/detail/timer_queue_set.hpp> | |
#include <boost/asio/error.hpp> | |
#include <boost/asio/io_service.hpp> | |
// Older versions of Mac OS X may not define EV_OOBAND. | |
#if !defined(EV_OOBAND) | |
# define EV_OOBAND EV_FLAG1 | |
#endif // !defined(EV_OOBAND) | |
#include <boost/asio/detail/push_options.hpp> | |
namespace boost { | |
namespace asio { | |
namespace detail { | |
class kqueue_reactor | |
: public boost::asio::detail::service_base<kqueue_reactor> | |
{ | |
public: | |
enum op_types { read_op = 0, write_op = 1, | |
connect_op = 1, except_op = 2, max_ops = 3 }; | |
// Per-descriptor queues. | |
struct descriptor_state | |
{ | |
friend class kqueue_reactor; | |
friend class object_pool_access; | |
mutex mutex_; | |
op_queue<reactor_op> op_queue_[max_ops]; | |
bool shutdown_; | |
descriptor_state* next_; | |
descriptor_state* prev_; | |
}; | |
// Per-descriptor data. | |
typedef descriptor_state* per_descriptor_data; | |
// Constructor. | |
BOOST_ASIO_DECL kqueue_reactor(boost::asio::io_service& io_service); | |
// Destructor. | |
BOOST_ASIO_DECL ~kqueue_reactor(); | |
// Destroy all user-defined handler objects owned by the service. | |
BOOST_ASIO_DECL void shutdown_service(); | |
// Initialise the task. | |
BOOST_ASIO_DECL void init_task(); | |
// Register a socket with the reactor. Returns 0 on success, system error | |
// code on failure. | |
BOOST_ASIO_DECL int register_descriptor(socket_type descriptor, | |
per_descriptor_data& descriptor_data); | |
// Post a reactor operation for immediate completion. | |
void post_immediate_completion(reactor_op* op) | |
{ | |
io_service_.post_immediate_completion(op); | |
} | |
// Start a new operation. The reactor operation will be performed when the | |
// given descriptor is flagged as ready, or an error has occurred. | |
BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, | |
per_descriptor_data& descriptor_data, | |
reactor_op* op, bool allow_speculative); | |
// Cancel all operations associated with the given descriptor. The | |
// handlers associated with the descriptor will be invoked with the | |
// operation_aborted error. | |
BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, | |
per_descriptor_data& descriptor_data); | |
// Cancel any operations that are running against the descriptor and remove | |
// its registration from the reactor. | |
BOOST_ASIO_DECL void close_descriptor(socket_type descriptor, | |
per_descriptor_data& descriptor_data); | |
// Add a new timer queue to the reactor. | |
template <typename Time_Traits> | |
void add_timer_queue(timer_queue<Time_Traits>& queue); | |
// Remove a timer queue from the reactor. | |
template <typename Time_Traits> | |
void remove_timer_queue(timer_queue<Time_Traits>& queue); | |
// Schedule a new operation in the given timer queue to expire at the | |
// specified absolute time. | |
template <typename Time_Traits> | |
void schedule_timer(timer_queue<Time_Traits>& queue, | |
const typename Time_Traits::time_type& time, | |
typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op); | |
// Cancel the timer operations associated with the given token. Returns the | |
// number of operations that have been posted or dispatched. | |
template <typename Time_Traits> | |
std::size_t cancel_timer(timer_queue<Time_Traits>& queue, | |
typename timer_queue<Time_Traits>::per_timer_data& timer); | |
// Run the kqueue loop. | |
BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops); | |
// Interrupt the kqueue loop. | |
BOOST_ASIO_DECL void interrupt(); | |
private: | |
// Create the kqueue file descriptor. Throws an exception if the descriptor | |
// cannot be created. | |
BOOST_ASIO_DECL static int do_kqueue_create(); | |
// Helper function to add a new timer queue. | |
BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); | |
// Helper function to remove a timer queue. | |
BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); | |
// Get the timeout value for the kevent call. | |
BOOST_ASIO_DECL timespec* get_timeout(timespec& ts); | |
// The io_service implementation used to post completions. | |
io_service_impl& io_service_; | |
// Mutex to protect access to internal data. | |
mutex mutex_; | |
// The kqueue file descriptor. | |
int kqueue_fd_; | |
// The interrupter is used to break a blocking kevent call. | |
select_interrupter interrupter_; | |
// The timer queues. | |
timer_queue_set timer_queues_; | |
// Whether the service has been shut down. | |
bool shutdown_; | |
// Mutex to protect access to the registered descriptors. | |
mutex registered_descriptors_mutex_; | |
// Keep track of all registered descriptors. | |
object_pool<descriptor_state> registered_descriptors_; | |
}; | |
} // namespace detail | |
} // namespace asio | |
} // namespace boost | |
#include <boost/asio/detail/pop_options.hpp> | |
#include <boost/asio/detail/impl/kqueue_reactor.hpp> | |
#if defined(BOOST_ASIO_HEADER_ONLY) | |
# include <boost/asio/detail/impl/kqueue_reactor.ipp> | |
#endif // defined(BOOST_ASIO_HEADER_ONLY) | |
#endif // defined(BOOST_ASIO_HAS_KQUEUE) | |
#endif // BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP |