base.hpp

Go to the documentation of this file.

//    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- OpenVPN Inc.
//
//    SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
 
#ifndef OPENVPN_TUN_BUILDER_BASE_H
#define OPENVPN_TUN_BUILDER_BASE_H
 
#include <string>
 
#ifdef ENABLE_OVPNDCO
#include <openvpn/dco/key.hpp>
#endif
 
#include <openvpn/addr/ip.hpp>
#include <openvpn/client/dns_options.hpp>
 
namespace openvpn {
 
class TunBuilderBase
{
  public:
    virtual bool tun_builder_new()
    {
        return false;
    }
 
    virtual bool tun_builder_set_layer(int layer)
    {
        return true;
    }
 
    virtual bool tun_builder_set_remote_address(const std::string &address, bool ipv6)
    {
        return false;
    }
 
    virtual bool tun_builder_add_address(const std::string &address,
                                         int prefix_length,
                                         const std::string &gateway, // optional
                                         bool ipv6,
                                         bool net30)
    {
        return false;
    }
 
    virtual bool tun_builder_set_route_metric_default(int metric)
    {
        return true;
    }
 
    virtual bool tun_builder_reroute_gw(bool ipv4,
                                        bool ipv6,
                                        unsigned int flags)
    {
        return false;
    }
 
    virtual bool tun_builder_add_route(const std::string &address,
                                       int prefix_length,
                                       int metric,
                                       bool ipv6)
    {
        return false;
    }
 
    virtual bool tun_builder_exclude_route(const std::string &address,
                                           int prefix_length,
                                           int metric,
                                           bool ipv6)
    {
        return false;
    }
 
    virtual bool tun_builder_set_dns_options(const DnsOptions &dns)
    {
        return false;
    }
 
    virtual bool tun_builder_set_mtu(int mtu)
    {
        return false;
    }
 
    virtual bool tun_builder_set_session_name(const std::string &name)
    {
        return false;
    }
 
    virtual bool tun_builder_add_proxy_bypass(const std::string &bypass_host)
    {
        return false;
    }
 
    virtual bool tun_builder_set_proxy_auto_config_url(const std::string &url)
    {
        return false;
    }
 
    virtual bool tun_builder_set_proxy_http(const std::string &host, int port)
    {
        return false;
    }
 
    virtual bool tun_builder_set_proxy_https(const std::string &host, int port)
    {
        return false;
    }
 
    virtual bool tun_builder_add_wins_server(const std::string &address)
    {
        return false;
    }
 
    virtual bool tun_builder_set_allow_family(int af, bool allow)
    {
        return true;
    }
 
    virtual bool tun_builder_set_allow_local_dns(bool allow)
    {
        return true;
    }
 
    virtual int tun_builder_establish()
    {
        return -1;
    }
 
    virtual bool tun_builder_persist()
    {
        return true;
    }
 
    virtual std::vector<std::string> tun_builder_get_local_networks(bool ipv6)
    {
        return {};
    }
 
    virtual void tun_builder_establish_lite()
    {
    }
 
    virtual void tun_builder_teardown(bool disconnect)
    {
    }
    virtual ~TunBuilderBase() = default;
 
#ifdef ENABLE_OVPNDCO
    virtual bool tun_builder_dco_available()
    {
        return false;
    }
 
    virtual int tun_builder_dco_enable(const std::string &dev_name)
    {
        return -1;
    }
 
    virtual void tun_builder_dco_new_peer(uint32_t peer_id,
                                          uint32_t transport_fd,
                                          struct sockaddr *sa,
                                          socklen_t salen,
                                          IPv4::Addr &vpn4,
                                          IPv6::Addr &vpn6)
    {
    }
 
    virtual void tun_builder_dco_set_peer(uint32_t peer_id, int keepalive_interval, int keepalive_timeout)
    {
    }
 
    virtual void tun_builder_dco_del_peer(uint32_t peer_id)
    {
    }
 
    virtual void tun_builder_dco_get_peer(uint32_t peer_id, bool sync)
    {
    }
 
    virtual void tun_builder_dco_new_key(unsigned int key_slot, const KoRekey::KeyConfig *kc)
    {
    }
 
    virtual void tun_builder_dco_swap_keys(uint32_t peer_id)
    {
    }
 
    virtual void tun_builder_dco_del_key(uint32_t peer_id, unsigned int key_slot)
    {
    }
 
    virtual void tun_builder_dco_establish()
    {
    }
#endif // ENABLE_OVPNDCO
};
} // namespace openvpn
 
#endif