2012-08-24 23:13:42 +02:00
|
|
|
//
|
|
|
|
// asiodispatch.hpp
|
|
|
|
// OpenVPN
|
|
|
|
//
|
|
|
|
// Copyright (c) 2012 OpenVPN Technologies, Inc. All rights reserved.
|
|
|
|
//
|
|
|
|
|
2012-02-07 12:37:35 +01:00
|
|
|
#ifndef OPENVPN_COMMON_ASIODISPATCH_H
|
|
|
|
#define OPENVPN_COMMON_ASIODISPATCH_H
|
2011-09-26 23:02:13 +02:00
|
|
|
|
2011-09-29 08:35:23 +02:00
|
|
|
#include <openvpn/common/types.hpp>
|
2012-01-04 16:58:31 +01:00
|
|
|
#include <openvpn/common/rc.hpp>
|
2011-09-29 08:35:23 +02:00
|
|
|
|
2011-09-26 23:02:13 +02:00
|
|
|
namespace openvpn {
|
2012-01-21 00:13:48 +01:00
|
|
|
// Dispatcher for asio async_write
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchWrite
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchWrite(Handler handle_write, C* obj)
|
|
|
|
: handle_write_(handle_write), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error, const size_t bytes_sent)
|
|
|
|
{
|
|
|
|
(obj_.get()->*handle_write_)(error, bytes_sent);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handle_write_;
|
|
|
|
boost::intrusive_ptr<C> obj_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchWrite<C, Handler> asio_dispatch_write(Handler handle_write, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchWrite<C, Handler>(handle_write, obj);
|
|
|
|
}
|
|
|
|
|
2011-10-08 08:20:49 +02:00
|
|
|
// Dispatcher for asio async_read
|
2011-09-26 23:02:13 +02:00
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
class AsioDispatchRead
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchRead(Handler handle_read, C* obj, Data data)
|
|
|
|
: handle_read_(handle_read), obj_(obj), data_(data) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error, const size_t bytes_recvd)
|
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handle_read_)(data_, error, bytes_recvd);
|
2011-09-26 23:02:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handle_read_;
|
2012-01-04 16:58:31 +01:00
|
|
|
boost::intrusive_ptr<C> obj_;
|
2011-09-26 23:02:13 +02:00
|
|
|
Data data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
AsioDispatchRead<C, Handler, Data> asio_dispatch_read(Handler handle_read, C* obj, Data data)
|
|
|
|
{
|
|
|
|
return AsioDispatchRead<C, Handler, Data>(handle_read, obj, data);
|
|
|
|
}
|
|
|
|
|
2011-10-08 08:20:49 +02:00
|
|
|
// Dispatcher for asio async_wait with argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
class AsioDispatchTimerArg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchTimerArg(Handler handler, C* obj, Data data)
|
|
|
|
: handler_(handler), obj_(obj), data_(data) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error)
|
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handler_)(data_, error);
|
2011-10-08 08:20:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2012-01-04 16:58:31 +01:00
|
|
|
boost::intrusive_ptr<C> obj_;
|
2011-10-08 08:20:49 +02:00
|
|
|
Data data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
AsioDispatchTimerArg<C, Handler, Data> asio_dispatch_timer_arg(Handler handler, C* obj, Data data)
|
|
|
|
{
|
|
|
|
return AsioDispatchTimerArg<C, Handler, Data>(handler, obj, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Dispatcher for asio async_wait without argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchTimer
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchTimer(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error)
|
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handler_)(error);
|
2011-10-08 08:20:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2012-01-04 16:58:31 +01:00
|
|
|
boost::intrusive_ptr<C> obj_;
|
2011-10-08 08:20:49 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchTimer<C, Handler> asio_dispatch_timer(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchTimer<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2012-02-07 21:52:40 +01:00
|
|
|
// Dispatcher for asio async_connect with argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
class AsioDispatchConnectArg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchConnectArg(Handler handler, C* obj, Data data)
|
|
|
|
: handler_(handler), obj_(obj), data_(data) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error)
|
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(data_, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
|
|
|
boost::intrusive_ptr<C> obj_;
|
|
|
|
Data data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
AsioDispatchConnectArg<C, Handler, Data> asio_dispatch_connect_arg(Handler handler, C* obj, Data data)
|
|
|
|
{
|
|
|
|
return AsioDispatchConnectArg<C, Handler, Data>(handler, obj, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Dispatcher for asio async_connect without argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchConnect
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchConnect(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error)
|
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
|
|
|
boost::intrusive_ptr<C> obj_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchConnect<C, Handler> asio_dispatch_connect(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchConnect<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2012-02-07 12:37:35 +01:00
|
|
|
// Dispatcher for asio post with argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
class AsioDispatchPostArg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchPostArg(Handler handler, C* obj, Data data)
|
|
|
|
: handler_(handler), obj_(obj), data_(data) {}
|
|
|
|
|
|
|
|
void operator()()
|
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(data_);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
|
|
|
boost::intrusive_ptr<C> obj_;
|
|
|
|
Data data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
AsioDispatchPostArg<C, Handler, Data> asio_dispatch_post_arg(Handler handler, C* obj, Data data)
|
|
|
|
{
|
|
|
|
return AsioDispatchPostArg<C, Handler, Data>(handler, obj, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Dispatcher for asio post without argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchPost
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchPost(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()()
|
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
|
|
|
boost::intrusive_ptr<C> obj_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchPost<C, Handler> asio_dispatch_post(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchPost<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2012-01-02 02:58:00 +01:00
|
|
|
// Dispatcher for asynchronous resolver
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename EndpointIterator>
|
|
|
|
class AsioDispatchResolve
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchResolve(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error, EndpointIterator iter)
|
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handler_)(error, iter);
|
2012-01-02 02:58:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2012-01-04 16:58:31 +01:00
|
|
|
boost::intrusive_ptr<C> obj_;
|
2012-01-02 02:58:00 +01:00
|
|
|
};
|
|
|
|
|
2012-01-04 16:58:31 +01:00
|
|
|
// Dispatcher for asio signal
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchSignal
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchSignal(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error, int signal_number)
|
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(error, signal_number);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
|
|
|
boost::intrusive_ptr<C> obj_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchSignal<C, Handler> asio_dispatch_signal(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchSignal<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2011-10-08 08:20:49 +02:00
|
|
|
// General purpose dispatcher with data
|
|
|
|
|
2011-09-26 23:02:13 +02:00
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
class SimpleDispatch
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
SimpleDispatch(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
|
|
|
void operator()(Data data)
|
|
|
|
{
|
|
|
|
(obj_->*handler_)(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2012-01-02 02:58:00 +01:00
|
|
|
C* obj_;
|
2011-09-26 23:02:13 +02:00
|
|
|
};
|
2011-10-08 08:20:49 +02:00
|
|
|
|
2011-09-26 23:02:13 +02:00
|
|
|
} // namespace openvpn
|
|
|
|
|
2012-02-07 12:37:35 +01:00
|
|
|
#endif // OPENVPN_COMMON_ASIODISPATCH_H
|