mirror of
https://github.com/deneraraujo/OpenVPNAdapter.git
synced 2026-04-24 00:00:05 +08:00
Merge commit '86cc97e55fe346502462284d2e636a2b3708163e' as 'Sources/OpenVPN3'
This commit is contained in:
Sergey Abramchuk
@@ -0,0 +1,47 @@
|
||||
// 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.
|
||||
//
|
||||
// Copyright (C) 2012-2017 OpenVPN Inc.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License Version 3
|
||||
// as published by the Free Software Foundation.
|
||||
//
|
||||
// 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
|
||||
// GNU Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program in the COPYING file.
|
||||
// If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef OPENVPN_TRANSPORT_CLIENT_EXTERN_CONFIG_H
|
||||
#define OPENVPN_TRANSPORT_CLIENT_EXTERN_CONFIG_H
|
||||
|
||||
#include <sstream>
|
||||
#include <openvpn/transport/client/transbase.hpp>
|
||||
#include <openvpn/transport/socket_protect.hpp>
|
||||
#include <openvpn/client/remotelist.hpp>
|
||||
|
||||
namespace openvpn
|
||||
{
|
||||
namespace ExternalTransport
|
||||
{
|
||||
struct Config
|
||||
{
|
||||
Protocol protocol;
|
||||
RemoteList::Ptr remote_list;
|
||||
bool server_addr_float = false;
|
||||
bool synchronous_dns_lookup = false;
|
||||
Frame::Ptr frame;
|
||||
SessionStats::Ptr stats;
|
||||
SocketProtect* socket_protect = nullptr;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
// 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.
|
||||
//
|
||||
// Copyright (C) 2012-2017 OpenVPN Inc.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License Version 3
|
||||
// as published by the Free Software Foundation.
|
||||
//
|
||||
// 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
|
||||
// GNU Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program in the COPYING file.
|
||||
// If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef OPENVPN_TRANSPORT_CLIENT_EXTERN_FW_H
|
||||
#define OPENVPN_TRANSPORT_CLIENT_EXTERN_FW_H
|
||||
|
||||
#ifdef OPENVPN_EXTERNAL_TRANSPORT_FACTORY
|
||||
#include <openvpn/transport/client/transbase.hpp>
|
||||
#endif
|
||||
|
||||
namespace openvpn {
|
||||
namespace ExternalTransport {
|
||||
#ifdef OPENVPN_EXTERNAL_TRANSPORT_FACTORY
|
||||
struct Config;
|
||||
struct Factory
|
||||
{
|
||||
virtual TransportClientFactory* new_transport_factory(const Config& conf) = 0;
|
||||
virtual ~Factory() {}
|
||||
};
|
||||
#else
|
||||
struct Factory {};
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,165 @@
|
||||
// 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.
|
||||
//
|
||||
// Copyright (C) 2012-2017 OpenVPN Inc.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License Version 3
|
||||
// as published by the Free Software Foundation.
|
||||
//
|
||||
// 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
|
||||
// GNU Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program in the COPYING file.
|
||||
// If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// Create a special transport factory that persists an existing
|
||||
// transport client. This is used to preserve the transport
|
||||
// socket when other client components are restarted after
|
||||
// a RELAY message is received from the server.
|
||||
|
||||
#ifndef OPENVPN_TRANSPORT_CLIENT_RELAY_H
|
||||
#define OPENVPN_TRANSPORT_CLIENT_RELAY_H
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include <openvpn/transport/client/transbase.hpp>
|
||||
|
||||
namespace openvpn {
|
||||
class TransportRelayFactory : public TransportClientFactory
|
||||
{
|
||||
public:
|
||||
TransportRelayFactory(openvpn_io::io_context& io_context,
|
||||
TransportClient::Ptr transport,
|
||||
TransportClientParent* old_parent)
|
||||
: io_context_(io_context),
|
||||
transport_(std::move(transport)),
|
||||
null_parent_(new NullParent(old_parent))
|
||||
{
|
||||
// Temporarily point transport to our null parent
|
||||
transport_->transport_reparent(null_parent_.get());
|
||||
}
|
||||
|
||||
class TransportClientNull : public TransportClient
|
||||
{
|
||||
public:
|
||||
TransportClientNull(TransportClient* old)
|
||||
: endpoint_(old->server_endpoint_addr()),
|
||||
protocol_(old->transport_protocol())
|
||||
{
|
||||
old->server_endpoint_info(host_, port_, proto_, ip_addr_);
|
||||
}
|
||||
|
||||
private:
|
||||
virtual void transport_start() {}
|
||||
virtual void stop() {}
|
||||
virtual bool transport_send_const(const Buffer& buf) { return false; }
|
||||
virtual bool transport_send(BufferAllocated& buf) { return false; }
|
||||
virtual bool transport_send_queue_empty() { return false; }
|
||||
virtual bool transport_has_send_queue() { return false; }
|
||||
virtual unsigned int transport_send_queue_size() { return 0; }
|
||||
virtual void transport_stop_requeueing() { }
|
||||
virtual void reset_align_adjust(const size_t align_adjust) {}
|
||||
virtual void transport_reparent(TransportClientParent* parent) {}
|
||||
|
||||
virtual IP::Addr server_endpoint_addr() const
|
||||
{
|
||||
return endpoint_;
|
||||
}
|
||||
|
||||
virtual Protocol transport_protocol() const
|
||||
{
|
||||
return protocol_;
|
||||
}
|
||||
|
||||
virtual void server_endpoint_info(std::string& host, std::string& port, std::string& proto, std::string& ip_addr) const
|
||||
{
|
||||
host = host_;
|
||||
port = port_;
|
||||
proto = proto_;
|
||||
ip_addr = ip_addr_;
|
||||
}
|
||||
|
||||
IP::Addr endpoint_;
|
||||
Protocol protocol_;
|
||||
std::string host_;
|
||||
std::string port_;
|
||||
std::string proto_;
|
||||
std::string ip_addr_;
|
||||
};
|
||||
|
||||
private:
|
||||
class NullParent : public TransportClientParent
|
||||
{
|
||||
public:
|
||||
NullParent(TransportClientParent* old_parent)
|
||||
: is_openvpn_protocol(old_parent->transport_is_openvpn_protocol())
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
virtual void transport_recv(BufferAllocated& buf) {}
|
||||
virtual void transport_needs_send() {}
|
||||
|
||||
virtual void transport_error(const Error::Type fatal_err, const std::string& err_text)
|
||||
{
|
||||
OPENVPN_LOG("TransportRelayFactory: Transport Error in null parent: " << Error::name(fatal_err) << " : " << err_text);
|
||||
}
|
||||
|
||||
virtual void proxy_error(const Error::Type fatal_err, const std::string& err_text)
|
||||
{
|
||||
OPENVPN_LOG("TransportRelayFactory: Proxy Error in null parent: " << Error::name(fatal_err) << " : " << err_text);
|
||||
}
|
||||
|
||||
// Return true if we are transporting OpenVPN protocol
|
||||
virtual bool transport_is_openvpn_protocol() { return is_openvpn_protocol; }
|
||||
|
||||
// progress notifications
|
||||
virtual void transport_pre_resolve() {}
|
||||
virtual void transport_wait_proxy() {}
|
||||
virtual void transport_wait() {}
|
||||
virtual void transport_connecting() {}
|
||||
|
||||
// Return true if keepalive parameter(s) are enabled.
|
||||
virtual bool is_keepalive_enabled() const { return false; }
|
||||
|
||||
// Disable keepalive for rest of session, but fetch
|
||||
// the keepalive parameters (in seconds).
|
||||
virtual void disable_keepalive(unsigned int& keepalive_ping, unsigned int& keepalive_timeout)
|
||||
{
|
||||
keepalive_ping = 0;
|
||||
keepalive_timeout = 0;
|
||||
}
|
||||
|
||||
bool is_openvpn_protocol;
|
||||
};
|
||||
|
||||
virtual TransportClient::Ptr new_transport_client_obj(openvpn_io::io_context& io_context,
|
||||
TransportClientParent* parent) override
|
||||
{
|
||||
// io_context MUST stay consistent
|
||||
if (&io_context != &io_context_)
|
||||
throw Exception("TransportRelayFactory: inconsistent io_context");
|
||||
|
||||
transport_->transport_reparent(parent);
|
||||
return transport_;
|
||||
}
|
||||
|
||||
virtual bool is_relay() override
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
openvpn_io::io_context& io_context_; // only used to verify consistency
|
||||
TransportClient::Ptr transport_; // the persisted transport
|
||||
std::unique_ptr<TransportClientParent> null_parent_; // placeholder for TransportClient parent before reparenting
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,399 @@
|
||||
// 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.
|
||||
//
|
||||
// Copyright (C) 2012-2017 OpenVPN Inc.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License Version 3
|
||||
// as published by the Free Software Foundation.
|
||||
//
|
||||
// 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
|
||||
// GNU Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program in the COPYING file.
|
||||
// If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// TCP transport object specialized for client.
|
||||
|
||||
#ifndef OPENVPN_TRANSPORT_CLIENT_TCPCLI_H
|
||||
#define OPENVPN_TRANSPORT_CLIENT_TCPCLI_H
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include <openvpn/io/io.hpp>
|
||||
|
||||
#include <openvpn/transport/tcplink.hpp>
|
||||
#ifdef OPENVPN_TLS_LINK
|
||||
#include <openvpn/transport/tlslink.hpp>
|
||||
#endif
|
||||
#include <openvpn/transport/client/transbase.hpp>
|
||||
#include <openvpn/transport/socket_protect.hpp>
|
||||
#include <openvpn/client/remotelist.hpp>
|
||||
|
||||
namespace openvpn {
|
||||
namespace TCPTransport {
|
||||
|
||||
class ClientConfig : public TransportClientFactory
|
||||
{
|
||||
public:
|
||||
typedef RCPtr<ClientConfig> Ptr;
|
||||
|
||||
RemoteList::Ptr remote_list;
|
||||
size_t free_list_max_size;
|
||||
Frame::Ptr frame;
|
||||
SessionStats::Ptr stats;
|
||||
|
||||
SocketProtect* socket_protect;
|
||||
|
||||
#ifdef OPENVPN_TLS_LINK
|
||||
bool use_tls = false;
|
||||
std::string tls_ca;
|
||||
#endif
|
||||
|
||||
#ifdef OPENVPN_GREMLIN
|
||||
Gremlin::Config::Ptr gremlin_config;
|
||||
#endif
|
||||
|
||||
static Ptr new_obj()
|
||||
{
|
||||
return new ClientConfig;
|
||||
}
|
||||
|
||||
virtual TransportClient::Ptr new_transport_client_obj(openvpn_io::io_context& io_context,
|
||||
TransportClientParent* parent);
|
||||
|
||||
private:
|
||||
ClientConfig()
|
||||
: free_list_max_size(8),
|
||||
socket_protect(nullptr)
|
||||
{}
|
||||
};
|
||||
|
||||
class Client : public TransportClient, AsyncResolvableTCP
|
||||
{
|
||||
typedef RCPtr<Client> Ptr;
|
||||
|
||||
typedef Link<openvpn_io::ip::tcp, Client*, false> LinkImpl;
|
||||
#ifdef OPENVPN_TLS_LINK
|
||||
typedef TLSLink<openvpn_io::ip::tcp, Client*, false> LinkImplTLS;
|
||||
#endif
|
||||
|
||||
friend class ClientConfig; // calls constructor
|
||||
friend LinkImpl::Base; // calls tcp_read_handler
|
||||
|
||||
public:
|
||||
void transport_start() override
|
||||
{
|
||||
if (!impl)
|
||||
{
|
||||
halt = false;
|
||||
stop_requeueing = false;
|
||||
if (config->remote_list->endpoint_available(&server_host,
|
||||
&server_port,
|
||||
&server_protocol))
|
||||
{
|
||||
start_connect_();
|
||||
}
|
||||
else
|
||||
{
|
||||
parent->transport_pre_resolve();
|
||||
|
||||
async_resolve_name(server_host, server_port);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool transport_send_const(const Buffer& buf) override
|
||||
{
|
||||
return send_const(buf);
|
||||
}
|
||||
|
||||
bool transport_send(BufferAllocated& buf) override
|
||||
{
|
||||
return send(buf);
|
||||
}
|
||||
|
||||
bool transport_send_queue_empty() override
|
||||
{
|
||||
if (impl)
|
||||
return impl->send_queue_empty();
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
bool transport_has_send_queue() override
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
unsigned int transport_send_queue_size() override
|
||||
{
|
||||
if (impl)
|
||||
return impl->send_queue_size();
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void reset_align_adjust(const size_t align_adjust) override
|
||||
{
|
||||
if (impl)
|
||||
impl->reset_align_adjust(align_adjust);
|
||||
}
|
||||
|
||||
void server_endpoint_info(std::string& host, std::string& port, std::string& proto, std::string& ip_addr) const override
|
||||
{
|
||||
host = server_host;
|
||||
port = server_port;
|
||||
const IP::Addr addr = server_endpoint_addr();
|
||||
proto = server_protocol.str();
|
||||
ip_addr = addr.to_string();
|
||||
}
|
||||
|
||||
IP::Addr server_endpoint_addr() const override
|
||||
{
|
||||
return IP::Addr::from_asio(server_endpoint.address());
|
||||
}
|
||||
|
||||
Protocol transport_protocol() const override
|
||||
{
|
||||
return server_protocol;
|
||||
}
|
||||
|
||||
void stop() override { stop_(); }
|
||||
~Client() override { stop_(); }
|
||||
|
||||
private:
|
||||
Client(openvpn_io::io_context& io_context_arg,
|
||||
ClientConfig* config_arg,
|
||||
TransportClientParent* parent_arg)
|
||||
: AsyncResolvableTCP(io_context_arg),
|
||||
io_context(io_context_arg),
|
||||
socket(io_context_arg),
|
||||
config(config_arg),
|
||||
parent(parent_arg),
|
||||
resolver(io_context_arg),
|
||||
halt(false),
|
||||
stop_requeueing(false)
|
||||
{
|
||||
}
|
||||
|
||||
void transport_reparent(TransportClientParent* parent_arg) override
|
||||
{
|
||||
parent = parent_arg;
|
||||
}
|
||||
|
||||
void transport_stop_requeueing() override
|
||||
{
|
||||
stop_requeueing = true;
|
||||
}
|
||||
|
||||
bool send_const(const Buffer& cbuf)
|
||||
{
|
||||
if (impl)
|
||||
{
|
||||
BufferAllocated buf(cbuf, 0);
|
||||
return impl->send(buf);
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
bool send(BufferAllocated& buf)
|
||||
{
|
||||
if (impl)
|
||||
return impl->send(buf);
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
void tcp_eof_handler() // called by LinkImpl::Base
|
||||
{
|
||||
config->stats->error(Error::NETWORK_EOF_ERROR);
|
||||
tcp_error_handler("NETWORK_EOF_ERROR");
|
||||
}
|
||||
|
||||
bool tcp_read_handler(BufferAllocated& buf) // called by LinkImpl::Base
|
||||
{
|
||||
parent->transport_recv(buf);
|
||||
return !stop_requeueing;
|
||||
}
|
||||
|
||||
void tcp_write_queue_needs_send() // called by LinkImpl::Base
|
||||
{
|
||||
parent->transport_needs_send();
|
||||
}
|
||||
|
||||
void tcp_error_handler(const char *error) // called by LinkImpl::Base
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << "Transport error on '" << server_host << ": " << error;
|
||||
stop();
|
||||
parent->transport_error(Error::TRANSPORT_ERROR, os.str());
|
||||
}
|
||||
|
||||
void stop_()
|
||||
{
|
||||
if (!halt)
|
||||
{
|
||||
halt = true;
|
||||
if (impl)
|
||||
impl->stop();
|
||||
|
||||
socket.close();
|
||||
resolver.cancel();
|
||||
async_resolve_cancel();
|
||||
}
|
||||
}
|
||||
|
||||
// do DNS resolve
|
||||
void resolve_callback(const openvpn_io::error_code& error,
|
||||
openvpn_io::ip::tcp::resolver::results_type results) override
|
||||
{
|
||||
if (!halt)
|
||||
{
|
||||
if (!error)
|
||||
{
|
||||
// save resolved endpoint list in remote_list
|
||||
config->remote_list->set_endpoint_range(results);
|
||||
start_connect_();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << "DNS resolve error on '" << server_host << "' for " << server_protocol.str() << " session: " << error.message();
|
||||
config->stats->error(Error::RESOLVE_ERROR);
|
||||
stop();
|
||||
parent->transport_error(Error::UNDEF, os.str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// do TCP connect
|
||||
void start_connect_()
|
||||
{
|
||||
config->remote_list->get_endpoint(server_endpoint);
|
||||
OPENVPN_LOG("Contacting " << server_endpoint << " via "
|
||||
<< server_protocol.str());
|
||||
parent->transport_wait();
|
||||
socket.open(server_endpoint.protocol());
|
||||
|
||||
if (config->socket_protect)
|
||||
{
|
||||
if (!config->socket_protect->socket_protect(socket.native_handle(), server_endpoint_addr()))
|
||||
{
|
||||
config->stats->error(Error::SOCKET_PROTECT_ERROR);
|
||||
stop();
|
||||
parent->transport_error(Error::UNDEF, "socket_protect error (" + std::string(server_protocol.str()) + ")");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
socket.set_option(openvpn_io::ip::tcp::no_delay(true));
|
||||
socket.async_connect(server_endpoint, [self=Ptr(this)](const openvpn_io::error_code& error)
|
||||
{
|
||||
OPENVPN_ASYNC_HANDLER;
|
||||
self->start_impl_(error);
|
||||
});
|
||||
}
|
||||
|
||||
// start I/O on TCP socket
|
||||
void start_impl_(const openvpn_io::error_code& error)
|
||||
{
|
||||
if (!halt)
|
||||
{
|
||||
if (!error)
|
||||
{
|
||||
#ifdef OPENVPN_TLS_LINK
|
||||
if (config->use_tls)
|
||||
{
|
||||
int flags = SSLConst::LOG_VERIFY_STATUS|SSLConst::ENABLE_CLIENT_SNI;
|
||||
SSLLib::SSLAPI::Config::Ptr ssl_conf;
|
||||
ssl_conf.reset(new SSLLib::SSLAPI::Config());
|
||||
ssl_conf->set_mode(Mode(Mode::CLIENT));
|
||||
ssl_conf->set_local_cert_enabled(false);
|
||||
ssl_conf->set_frame(config->frame);
|
||||
ssl_conf->set_rng(new SSLLib::RandomAPI(false));
|
||||
|
||||
if (!config->tls_ca.empty())
|
||||
{
|
||||
ssl_conf->load_ca(config->tls_ca, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
flags |= SSLConst::NO_VERIFY_PEER;
|
||||
}
|
||||
|
||||
ssl_conf->set_flags(flags);
|
||||
ssl_factory = ssl_conf->new_factory();
|
||||
|
||||
impl.reset(new LinkImplTLS(this,
|
||||
io_context,
|
||||
socket,
|
||||
0,
|
||||
config->free_list_max_size,
|
||||
config->frame,
|
||||
config->stats,
|
||||
ssl_factory));
|
||||
}
|
||||
else
|
||||
#endif
|
||||
impl.reset(new LinkImpl(this,
|
||||
socket,
|
||||
0, // send_queue_max_size is unlimited because we regulate size in cliproto.hpp
|
||||
config->free_list_max_size,
|
||||
(*config->frame)[Frame::READ_LINK_TCP],
|
||||
config->stats));
|
||||
|
||||
#ifdef OPENVPN_GREMLIN
|
||||
impl->gremlin_config(config->gremlin_config);
|
||||
#endif
|
||||
impl->start();
|
||||
if (!parent->transport_is_openvpn_protocol())
|
||||
impl->set_raw_mode(true);
|
||||
parent->transport_connecting();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << server_protocol.str() << " connect error on '" << server_host << ':' << server_port << "' (" << server_endpoint << "): " << error.message();
|
||||
config->stats->error(Error::TCP_CONNECT_ERROR);
|
||||
stop();
|
||||
parent->transport_error(Error::UNDEF, os.str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string server_host;
|
||||
std::string server_port;
|
||||
Protocol server_protocol;
|
||||
|
||||
openvpn_io::io_context& io_context;
|
||||
openvpn_io::ip::tcp::socket socket;
|
||||
ClientConfig::Ptr config;
|
||||
TransportClientParent* parent;
|
||||
LinkBase::Ptr impl;
|
||||
openvpn_io::ip::tcp::resolver resolver;
|
||||
LinkImpl::Base::protocol::endpoint server_endpoint;
|
||||
bool halt;
|
||||
bool stop_requeueing;
|
||||
|
||||
#ifdef OPENVPN_TLS_LINK
|
||||
SSLFactoryAPI::Ptr ssl_factory;
|
||||
#endif
|
||||
};
|
||||
|
||||
inline TransportClient::Ptr ClientConfig::new_transport_client_obj(openvpn_io::io_context& io_context,
|
||||
TransportClientParent* parent)
|
||||
{
|
||||
return TransportClient::Ptr(new Client(io_context, this, parent));
|
||||
}
|
||||
}
|
||||
} // namespace openvpn
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,105 @@
|
||||
// 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.
|
||||
//
|
||||
// Copyright (C) 2012-2017 OpenVPN Inc.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License Version 3
|
||||
// as published by the Free Software Foundation.
|
||||
//
|
||||
// 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
|
||||
// GNU Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program in the COPYING file.
|
||||
// If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// Abstract base classes for client transport objects that implement UDP, TCP,
|
||||
// HTTP Proxy, etc.
|
||||
|
||||
#ifndef OPENVPN_TRANSPORT_CLIENT_TRANSBASE_H
|
||||
#define OPENVPN_TRANSPORT_CLIENT_TRANSBASE_H
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <openvpn/io/io.hpp>
|
||||
|
||||
#include <openvpn/common/exception.hpp>
|
||||
#include <openvpn/common/rc.hpp>
|
||||
#include <openvpn/buffer/buffer.hpp>
|
||||
#include <openvpn/addr/ip.hpp>
|
||||
#include <openvpn/error/error.hpp>
|
||||
#include <openvpn/crypto/cryptodc.hpp>
|
||||
#include <openvpn/transport/protocol.hpp>
|
||||
|
||||
namespace openvpn {
|
||||
struct TransportClientParent;
|
||||
|
||||
// Base class for client transport object.
|
||||
struct TransportClient : public virtual RC<thread_unsafe_refcount>
|
||||
{
|
||||
typedef RCPtr<TransportClient> Ptr;
|
||||
|
||||
virtual void transport_start() = 0;
|
||||
virtual void stop() = 0;
|
||||
virtual bool transport_send_const(const Buffer& buf) = 0;
|
||||
virtual bool transport_send(BufferAllocated& buf) = 0;
|
||||
virtual bool transport_send_queue_empty() = 0;
|
||||
virtual bool transport_has_send_queue() = 0;
|
||||
virtual void transport_stop_requeueing() = 0;
|
||||
virtual unsigned int transport_send_queue_size() = 0;
|
||||
virtual void reset_align_adjust(const size_t align_adjust) = 0;
|
||||
virtual IP::Addr server_endpoint_addr() const = 0;
|
||||
virtual void server_endpoint_info(std::string& host, std::string& port, std::string& proto, std::string& ip_addr) const = 0;
|
||||
virtual Protocol transport_protocol() const = 0;
|
||||
virtual void transport_reparent(TransportClientParent* parent) = 0;
|
||||
};
|
||||
|
||||
// Base class for parent of client transport object, used by client transport
|
||||
// objects to communicate received data packets, exceptions, and progress
|
||||
// notifications.
|
||||
struct TransportClientParent
|
||||
{
|
||||
virtual void transport_recv(BufferAllocated& buf) = 0;
|
||||
virtual void transport_needs_send() = 0; // notification that send queue is empty
|
||||
virtual void transport_error(const Error::Type fatal_err, const std::string& err_text) = 0;
|
||||
virtual void proxy_error(const Error::Type fatal_err, const std::string& err_text) = 0;
|
||||
|
||||
// Return true if we are transporting OpenVPN protocol
|
||||
virtual bool transport_is_openvpn_protocol() = 0;
|
||||
|
||||
// progress notifications
|
||||
virtual void transport_pre_resolve() = 0;
|
||||
virtual void transport_wait_proxy() = 0;
|
||||
virtual void transport_wait() = 0;
|
||||
virtual void transport_connecting() = 0;
|
||||
|
||||
// Return true if keepalive parameter(s) are enabled.
|
||||
virtual bool is_keepalive_enabled() const = 0;
|
||||
|
||||
// Disable keepalive for rest of session, but fetch
|
||||
// the keepalive parameters (in seconds).
|
||||
virtual void disable_keepalive(unsigned int& keepalive_ping,
|
||||
unsigned int& keepalive_timeout) = 0;
|
||||
|
||||
virtual ~TransportClientParent() {}
|
||||
};
|
||||
|
||||
// Factory for client transport object.
|
||||
struct TransportClientFactory : public virtual RC<thread_unsafe_refcount>
|
||||
{
|
||||
typedef RCPtr<TransportClientFactory> Ptr;
|
||||
|
||||
virtual TransportClient::Ptr new_transport_client_obj(openvpn_io::io_context& io_context,
|
||||
TransportClientParent* parent) = 0;
|
||||
virtual bool is_relay() { return false; }
|
||||
};
|
||||
|
||||
} // namespace openvpn
|
||||
|
||||
#endif // OPENVPN_TRANSPORT_CLIENT_TRANSBASE_H
|
||||
@@ -0,0 +1,336 @@
|
||||
// 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.
|
||||
//
|
||||
// Copyright (C) 2012-2017 OpenVPN Inc.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Affero General Public License Version 3
|
||||
// as published by the Free Software Foundation.
|
||||
//
|
||||
// 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
|
||||
// GNU Affero General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Affero General Public License
|
||||
// along with this program in the COPYING file.
|
||||
// If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// UDP transport object specialized for client.
|
||||
|
||||
#ifndef OPENVPN_TRANSPORT_CLIENT_UDPCLI_H
|
||||
#define OPENVPN_TRANSPORT_CLIENT_UDPCLI_H
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include <openvpn/io/io.hpp>
|
||||
|
||||
#include <openvpn/common/bigmutex.hpp>
|
||||
#include <openvpn/common/likely.hpp>
|
||||
#include <openvpn/common/platform.hpp>
|
||||
#include <openvpn/transport/udplink.hpp>
|
||||
#include <openvpn/transport/client/transbase.hpp>
|
||||
#include <openvpn/transport/socket_protect.hpp>
|
||||
#include <openvpn/client/remotelist.hpp>
|
||||
|
||||
namespace openvpn {
|
||||
namespace UDPTransport {
|
||||
|
||||
class ClientConfig : public TransportClientFactory
|
||||
{
|
||||
public:
|
||||
typedef RCPtr<ClientConfig> Ptr;
|
||||
|
||||
RemoteList::Ptr remote_list;
|
||||
bool server_addr_float;
|
||||
bool synchronous_dns_lookup;
|
||||
int n_parallel;
|
||||
Frame::Ptr frame;
|
||||
SessionStats::Ptr stats;
|
||||
|
||||
SocketProtect* socket_protect;
|
||||
|
||||
#ifdef OPENVPN_GREMLIN
|
||||
Gremlin::Config::Ptr gremlin_config;
|
||||
#endif
|
||||
|
||||
static Ptr new_obj()
|
||||
{
|
||||
return new ClientConfig;
|
||||
}
|
||||
|
||||
virtual TransportClient::Ptr new_transport_client_obj(openvpn_io::io_context& io_context,
|
||||
TransportClientParent* parent);
|
||||
|
||||
private:
|
||||
ClientConfig()
|
||||
: server_addr_float(false),
|
||||
synchronous_dns_lookup(false),
|
||||
n_parallel(8),
|
||||
socket_protect(nullptr)
|
||||
{}
|
||||
};
|
||||
|
||||
class Client : public TransportClient, AsyncResolvableUDP
|
||||
{
|
||||
typedef RCPtr<Client> Ptr;
|
||||
|
||||
friend class ClientConfig; // calls constructor
|
||||
friend class Link<Client*>; // calls udp_read_handler
|
||||
|
||||
typedef Link<Client*> LinkImpl;
|
||||
|
||||
public:
|
||||
void transport_start() override
|
||||
{
|
||||
if (!impl)
|
||||
{
|
||||
halt = false;
|
||||
if (config->remote_list->endpoint_available(&server_host, &server_port, nullptr))
|
||||
{
|
||||
start_connect_();
|
||||
}
|
||||
else
|
||||
{
|
||||
parent->transport_pre_resolve();
|
||||
|
||||
if (config->synchronous_dns_lookup)
|
||||
{
|
||||
openvpn_io::error_code error;
|
||||
openvpn_io::ip::udp::resolver::results_type results = resolver.resolve(server_host, server_port, error);
|
||||
resolve_callback(error, results);
|
||||
}
|
||||
else
|
||||
{
|
||||
async_resolve_name(server_host, server_port);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool transport_send_const(const Buffer& buf) override
|
||||
{
|
||||
return send(buf);
|
||||
}
|
||||
|
||||
bool transport_send(BufferAllocated& buf) override
|
||||
{
|
||||
return send(buf);
|
||||
}
|
||||
|
||||
bool transport_send_queue_empty() override // really only has meaning for TCP
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool transport_has_send_queue() override
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
void transport_stop_requeueing() override { }
|
||||
|
||||
unsigned int transport_send_queue_size() override
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void reset_align_adjust(const size_t align_adjust) override
|
||||
{
|
||||
if (impl)
|
||||
impl->reset_align_adjust(align_adjust);
|
||||
}
|
||||
|
||||
void server_endpoint_info(std::string& host, std::string& port, std::string& proto, std::string& ip_addr) const override
|
||||
{
|
||||
host = server_host;
|
||||
port = server_port;
|
||||
const IP::Addr addr = server_endpoint_addr();
|
||||
proto = "UDP";
|
||||
proto += addr.version_string();
|
||||
ip_addr = addr.to_string();
|
||||
}
|
||||
|
||||
IP::Addr server_endpoint_addr() const override
|
||||
{
|
||||
return IP::Addr::from_asio(server_endpoint.address());
|
||||
}
|
||||
|
||||
Protocol transport_protocol() const override
|
||||
{
|
||||
if (server_endpoint.address().is_v4())
|
||||
return Protocol(Protocol::UDPv4);
|
||||
else if (server_endpoint.address().is_v6())
|
||||
return Protocol(Protocol::UDPv6);
|
||||
else
|
||||
return Protocol();
|
||||
}
|
||||
|
||||
void stop() override { stop_(); }
|
||||
~Client() override { stop_(); }
|
||||
|
||||
private:
|
||||
Client(openvpn_io::io_context& io_context_arg,
|
||||
ClientConfig* config_arg,
|
||||
TransportClientParent* parent_arg)
|
||||
: AsyncResolvableUDP(io_context_arg),
|
||||
socket(io_context_arg),
|
||||
config(config_arg),
|
||||
parent(parent_arg),
|
||||
resolver(io_context_arg),
|
||||
halt(false)
|
||||
{
|
||||
}
|
||||
|
||||
void transport_reparent(TransportClientParent* parent_arg) override
|
||||
{
|
||||
parent = parent_arg;
|
||||
}
|
||||
|
||||
bool send(const Buffer& buf)
|
||||
{
|
||||
if (impl)
|
||||
{
|
||||
const int err = impl->send(buf, nullptr);
|
||||
if (unlikely(err))
|
||||
{
|
||||
// While UDP errors are generally ignored, certain
|
||||
// errors should be forwarded up to the higher levels.
|
||||
#ifdef OPENVPN_PLATFORM_IPHONE
|
||||
if (err == EADDRNOTAVAIL)
|
||||
{
|
||||
stop();
|
||||
parent->transport_error(Error::TRANSPORT_ERROR, "EADDRNOTAVAIL: Can't assign requested address");
|
||||
}
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
else
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
void udp_read_handler(PacketFrom::SPtr& pfp) // called by LinkImpl
|
||||
{
|
||||
if (config->server_addr_float || pfp->sender_endpoint == server_endpoint)
|
||||
parent->transport_recv(pfp->buf);
|
||||
else
|
||||
config->stats->error(Error::BAD_SRC_ADDR);
|
||||
}
|
||||
|
||||
void stop_()
|
||||
{
|
||||
if (!halt)
|
||||
{
|
||||
halt = true;
|
||||
if (impl)
|
||||
impl->stop();
|
||||
socket.close();
|
||||
resolver.cancel();
|
||||
async_resolve_cancel();
|
||||
}
|
||||
}
|
||||
|
||||
// called after DNS resolution has succeeded or failed
|
||||
void resolve_callback(const openvpn_io::error_code& error,
|
||||
openvpn_io::ip::udp::resolver::results_type results) override
|
||||
{
|
||||
if (!halt)
|
||||
{
|
||||
if (!error)
|
||||
{
|
||||
// save resolved endpoint list in remote_list
|
||||
config->remote_list->set_endpoint_range(results);
|
||||
start_connect_();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << "DNS resolve error on '" << server_host << "' for UDP session: " << error.message();
|
||||
config->stats->error(Error::RESOLVE_ERROR);
|
||||
stop();
|
||||
parent->transport_error(Error::UNDEF, os.str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// do UDP connect
|
||||
void start_connect_()
|
||||
{
|
||||
config->remote_list->get_endpoint(server_endpoint);
|
||||
OPENVPN_LOG("Contacting " << server_endpoint << " via UDP");
|
||||
parent->transport_wait();
|
||||
socket.open(server_endpoint.protocol());
|
||||
|
||||
if (config->socket_protect)
|
||||
{
|
||||
if (!config->socket_protect->socket_protect(socket.native_handle(), server_endpoint_addr()))
|
||||
{
|
||||
config->stats->error(Error::SOCKET_PROTECT_ERROR);
|
||||
stop();
|
||||
parent->transport_error(Error::UNDEF, "socket_protect error (UDP)");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
socket.async_connect(server_endpoint, [self=Ptr(this)](const openvpn_io::error_code& error)
|
||||
{
|
||||
OPENVPN_ASYNC_HANDLER;
|
||||
self->start_impl_(error);
|
||||
});
|
||||
}
|
||||
|
||||
// start I/O on UDP socket
|
||||
void start_impl_(const openvpn_io::error_code& error)
|
||||
{
|
||||
if (!halt)
|
||||
{
|
||||
if (!error)
|
||||
{
|
||||
impl.reset(new LinkImpl(this,
|
||||
socket,
|
||||
(*config->frame)[Frame::READ_LINK_UDP],
|
||||
config->stats));
|
||||
#ifdef OPENVPN_GREMLIN
|
||||
impl->gremlin_config(config->gremlin_config);
|
||||
#endif
|
||||
impl->start(config->n_parallel);
|
||||
parent->transport_connecting();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::ostringstream os;
|
||||
os << "UDP connect error on '" << server_host << ':' << server_port << "' (" << server_endpoint << "): " << error.message();
|
||||
config->stats->error(Error::UDP_CONNECT_ERROR);
|
||||
stop();
|
||||
parent->transport_error(Error::UNDEF, os.str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string server_host;
|
||||
std::string server_port;
|
||||
|
||||
openvpn_io::ip::udp::socket socket;
|
||||
ClientConfig::Ptr config;
|
||||
TransportClientParent* parent;
|
||||
LinkImpl::Ptr impl;
|
||||
openvpn_io::ip::udp::resolver resolver;
|
||||
UDPTransport::AsioEndpoint server_endpoint;
|
||||
bool halt;
|
||||
};
|
||||
|
||||
inline TransportClient::Ptr ClientConfig::new_transport_client_obj(openvpn_io::io_context& io_context,
|
||||
TransportClientParent* parent)
|
||||
{
|
||||
return TransportClient::Ptr(new Client(io_context, this, parent));
|
||||
}
|
||||
}
|
||||
} // namespace openvpn
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user