2014-07-21 05:22:06 +02:00
|
|
|
// OpenVPN -- An application to securely tunnel IP networks
|
|
|
|
// over a single port, with support for SSL/TLS-based
|
|
|
|
// session authentication and key exchange,
|
|
|
|
// packet encryption, packet authentication, and
|
|
|
|
// packet compression.
|
2012-08-24 23:13:42 +02:00
|
|
|
//
|
2020-03-04 20:48:54 +01:00
|
|
|
// Copyright (C) 2012-2020 OpenVPN Inc.
|
2012-08-24 23:13:42 +02:00
|
|
|
//
|
2014-07-21 05:22:06 +02:00
|
|
|
// This program is free software: you can redistribute it and/or modify
|
2017-03-16 09:41:16 +01:00
|
|
|
// it under the terms of the GNU General Public License Version 3
|
2014-07-21 05:22:06 +02:00
|
|
|
// as published by the Free Software Foundation.
|
2012-08-24 23:13:42 +02:00
|
|
|
//
|
2014-07-21 05:22:06 +02:00
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2017-03-16 09:41:16 +01:00
|
|
|
// GNU General Public License for more details.
|
2014-07-21 05:22:06 +02:00
|
|
|
//
|
2017-03-16 09:41:16 +01:00
|
|
|
// You should have received a copy of the GNU General Public License
|
2014-07-21 05:22:06 +02:00
|
|
|
// along with this program in the COPYING file.
|
|
|
|
// If not, see <http://www.gnu.org/licenses/>.
|
2012-08-24 23:13:42 +02:00
|
|
|
|
2012-11-23 07:18:43 +01:00
|
|
|
// These classes define function objects to be used as asynchronous callbacks
|
|
|
|
// for Asio methods. Think of these as optimized special cases of function
|
|
|
|
// objects that could be more generally (but perhaps less optimally) defined
|
2015-06-06 18:59:18 +02:00
|
|
|
// with lambdas.
|
2012-11-23 07:18:43 +01:00
|
|
|
|
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
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
#include <asio.hpp>
|
2015-04-16 06:18:32 +02:00
|
|
|
|
2015-05-17 21:27:34 +02:00
|
|
|
#include <openvpn/common/size.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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error, const size_t bytes_sent)
|
2012-01-21 00:13:48 +01:00
|
|
|
{
|
|
|
|
(obj_.get()->*handle_write_)(error, bytes_sent);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handle_write_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-01-21 00:13:48 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchWrite<C, Handler> asio_dispatch_write(Handler handle_write, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchWrite<C, Handler>(handle_write, obj);
|
|
|
|
}
|
|
|
|
|
2015-02-10 23:54:34 +01:00
|
|
|
// Dispatcher for asio async_read with argument
|
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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error, const size_t bytes_recvd)
|
2011-09-26 23:02:13 +02:00
|
|
|
{
|
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_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<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);
|
|
|
|
}
|
|
|
|
|
2015-02-10 23:54:34 +01:00
|
|
|
// Dispatcher for asio async_read without argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchReadNoArg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchReadNoArg(Handler handle_read, C* obj)
|
|
|
|
: handle_read_(handle_read), obj_(obj) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error, const size_t bytes_recvd)
|
2015-02-10 23:54:34 +01:00
|
|
|
{
|
|
|
|
(obj_.get()->*handle_read_)(error, bytes_recvd);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handle_read_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2015-02-10 23:54:34 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchReadNoArg<C, Handler> asio_dispatch_read_noarg(Handler handle_read, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchReadNoArg<C, Handler>(handle_read, obj);
|
|
|
|
}
|
|
|
|
|
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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error)
|
2011-10-08 08:20:49 +02:00
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handler_)(data_, error);
|
2011-10-08 08:20:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error)
|
2011-10-08 08:20:49 +02:00
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handler_)(error);
|
2011-10-08 08:20:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error)
|
2012-02-07 21:52:40 +01:00
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(data_, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-02-07 21:52:40 +01:00
|
|
|
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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error)
|
2012-02-07 21:52:40 +01:00
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-02-07 21:52:40 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchConnect<C, Handler> asio_dispatch_connect(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchConnect<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2014-08-11 01:17:11 +02:00
|
|
|
// Dispatcher for asio async_connect (ComposedConnectHandler) without argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
class AsioDispatchComposedConnect
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchComposedConnect(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
2015-06-25 09:32:10 +02:00
|
|
|
void operator()(const asio::error_code& error, asio::ip::tcp::resolver::iterator endpoint_iterator)
|
2014-08-11 01:17:11 +02:00
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(error, endpoint_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2014-08-11 01:17:11 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchComposedConnect<C, Handler> asio_dispatch_composed_connect(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchComposedConnect<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2014-12-14 05:19:18 +01:00
|
|
|
// Dispatcher for asio async_accept with argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
class AsioDispatchAcceptArg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchAcceptArg(Handler handler, C* obj, Data data)
|
|
|
|
: handler_(handler), obj_(obj), data_(data) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error)
|
2014-12-14 05:19:18 +01:00
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(data_, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2014-12-14 05:19:18 +01:00
|
|
|
Data data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename Data>
|
|
|
|
AsioDispatchAcceptArg<C, Handler, Data> asio_dispatch_accept_arg(Handler handler, C* obj, Data data)
|
|
|
|
{
|
|
|
|
return AsioDispatchAcceptArg<C, Handler, Data>(handler, obj, data);
|
|
|
|
}
|
|
|
|
|
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_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-02-07 12:37:35 +01:00
|
|
|
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_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-02-07 12:37:35 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename C, typename Handler>
|
|
|
|
AsioDispatchPost<C, Handler> asio_dispatch_post(Handler handler, C* obj)
|
|
|
|
{
|
|
|
|
return AsioDispatchPost<C, Handler>(handler, obj);
|
|
|
|
}
|
|
|
|
|
2015-06-02 07:31:36 +02:00
|
|
|
// Dispatcher for asynchronous resolver without argument
|
2012-01-02 02:58:00 +01:00
|
|
|
|
|
|
|
template <typename C, typename Handler, typename EndpointIterator>
|
|
|
|
class AsioDispatchResolve
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchResolve(Handler handler, C* obj)
|
|
|
|
: handler_(handler), obj_(obj) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error, EndpointIterator iter)
|
2012-01-02 02:58:00 +01:00
|
|
|
{
|
2012-01-04 16:58:31 +01:00
|
|
|
(obj_.get()->*handler_)(error, iter);
|
2012-01-02 02:58:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-01-02 02:58:00 +01:00
|
|
|
};
|
|
|
|
|
2015-06-02 07:31:36 +02:00
|
|
|
// Dispatcher for asynchronous resolver with argument
|
|
|
|
|
|
|
|
template <typename C, typename Handler, typename EndpointIterator, typename Data>
|
|
|
|
class AsioDispatchResolveArg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AsioDispatchResolveArg(Handler handler, C* obj, Data data)
|
|
|
|
: handler_(handler), obj_(obj), data_(data) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error, EndpointIterator iter)
|
2015-06-02 07:31:36 +02:00
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(error, iter, data_);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
|
|
|
RCPtr<C> obj_;
|
|
|
|
Data data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
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) {}
|
|
|
|
|
2015-06-06 18:59:18 +02:00
|
|
|
void operator()(const asio::error_code& error, int signal_number)
|
2012-01-04 16:58:31 +01:00
|
|
|
{
|
|
|
|
(obj_.get()->*handler_)(error, signal_number);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Handler handler_;
|
2015-05-18 05:26:53 +02:00
|
|
|
RCPtr<C> obj_;
|
2012-01-04 16:58:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
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
|