i2pd/qt/i2pd_qt/TunnelConfig.h

#ifndef TUNNELCONFIG_H
#define TUNNELCONFIG_H

#include "QString"
#include <string>

#include "../../ClientContext.h"


class I2CPParameters{
    QString inbound_length;//number of hops of an inbound tunnel. 3 by default; lower value is faster but dangerous
    QString outbound_length;//number of hops of an outbound tunnel. 3 by default; lower value is faster but dangerous
    QString inbound_quantity; //number of inbound tunnels. 5 by default
    QString outbound_quantity; //number of outbound tunnels. 5 by default
    QString crypto_tagsToSend; //number of ElGamal/AES tags to send. 40 by default; too low value may cause problems with tunnel building
    QString explicitPeers; //list of comma-separated b64 addresses of peers to use, default: unset
public:
    I2CPParameters(): inbound_length(),
                                 outbound_length(),
                                 inbound_quantity(),
                                 outbound_quantity(),
                                 crypto_tagsToSend(),
                                 explicitPeers() {}
    const QString& getInbound_length(){return inbound_length;}
    const QString& getOutbound_length(){return outbound_length;}
    const QString& getInbound_quantity(){return inbound_quantity;}
    const QString& getOutbound_quantity(){return outbound_quantity;}
    const QString& getCrypto_tagsToSend(){return crypto_tagsToSend;}
    const QString& getExplicitPeers(){return explicitPeers;}
    void setInbound_length(QString inbound_length_){inbound_length=inbound_length_;}
    void setOutbound_length(QString outbound_length_){outbound_length=outbound_length_;}
    void setInbound_quantity(QString inbound_quantity_){inbound_quantity=inbound_quantity_;}
    void setOutbound_quantity(QString outbound_quantity_){outbound_quantity=outbound_quantity_;}
    void setCrypto_tagsToSend(QString crypto_tagsToSend_){crypto_tagsToSend=crypto_tagsToSend_;}
    void setExplicitPeers(QString explicitPeers_){explicitPeers=explicitPeers_;}
};


class ClientTunnelConfig;
class ServerTunnelConfig;
class TunnelConfig {
    /*
    const char I2P_TUNNELS_SECTION_TYPE_CLIENT[] = "client";
    const char I2P_TUNNELS_SECTION_TYPE_SERVER[] = "server";
    const char I2P_TUNNELS_SECTION_TYPE_HTTP[] = "http";
    const char I2P_TUNNELS_SECTION_TYPE_IRC[] = "irc";
    const char I2P_TUNNELS_SECTION_TYPE_UDPCLIENT[] = "udpclient";
    const char I2P_TUNNELS_SECTION_TYPE_UDPSERVER[] = "udpserver";
    const char I2P_TUNNELS_SECTION_TYPE_SOCKS[] = "socks";
    const char I2P_TUNNELS_SECTION_TYPE_WEBSOCKS[] = "websocks";
    const char I2P_TUNNELS_SECTION_TYPE_HTTPPROXY[] = "httpproxy";
    */
    QString type;
    std::string name;
public:
    TunnelConfig(std::string name_, QString& type_, I2CPParameters& i2cpParameters_): type(type_), name(name_), i2cpParameters(i2cpParameters_) {}
    virtual ~TunnelConfig(){}
    const QString& getType(){return type;}
    const std::string& getName(){return name;}
    void setType(const QString& type_){type=type_;}
    void setName(const std::string& name_){name=name_;}
    I2CPParameters& getI2cpParameters(){return i2cpParameters;}
    virtual ClientTunnelConfig* asClientTunnelConfig()=0;
    virtual ServerTunnelConfig* asServerTunnelConfig()=0;

private:
    I2CPParameters i2cpParameters;
};

/*
# mandatory parameters:
    std::string dest;
    if (type == I2P_TUNNELS_SECTION_TYPE_CLIENT || type == I2P_TUNNELS_SECTION_TYPE_UDPCLIENT)
        dest = section.second.get<std::string> (I2P_CLIENT_TUNNEL_DESTINATION);
    int port = section.second.get<int> (I2P_CLIENT_TUNNEL_PORT);
# optional parameters (may be omitted)
    std::string keys = section.second.get (I2P_CLIENT_TUNNEL_KEYS, "");
    std::string address = section.second.get (I2P_CLIENT_TUNNEL_ADDRESS, "127.0.0.1");
    int destinationPort = section.second.get (I2P_CLIENT_TUNNEL_DESTINATION_PORT, 0);
    i2p::data::SigningKeyType sigType = section.second.get (I2P_CLIENT_TUNNEL_SIGNATURE_TYPE, i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256);
# * keys -- our identity, if unset, will be generated on every startup,
#     if set and file missing, keys will be generated and placed to this file
# * address -- local interface to bind
# * signaturetype -- signature type for new destination. 0 (DSA/SHA1), 1 (EcDSA/SHA256) or 7 (EdDSA/SHA512)
[somelabel]
type = client
address = 127.0.0.1
port = 6668
destination = irc.postman.i2p
keys = irc-keys.dat
*/
class ClientTunnelConfig : public TunnelConfig {
    std::string dest;
    int port;
    std::string keys;
    std::string address;
    int destinationPort;
    i2p::data::SigningKeyType sigType;
public:
    ClientTunnelConfig(std::string name_, QString type_, I2CPParameters& i2cpParameters_,
                       std::string dest_,
                       int port_,
                       std::string keys_,
                       std::string address_,
                       int destinationPort_,
                       i2p::data::SigningKeyType sigType_): TunnelConfig(name_, type_, i2cpParameters_),
        dest(dest_),
        port(port_),
        keys(keys_),
        address(address_),
        destinationPort(destinationPort_),
        sigType(sigType_){}
    std::string& getdest(){return dest;}
    int getport(){return port;}
    std::string & getkeys(){return keys;}
    std::string & getaddress(){return address;}
    int getdestinationPort(){return destinationPort;}
    i2p::data::SigningKeyType getsigType(){return sigType;}
    void setdest(std::string& dest_){dest=dest_;}
    void setport(int port_){port=port_;}
    void setkeys(std::string & keys_){keys=keys_;}
    void setaddress(std::string & address_){address=address_;}
    void setdestinationPort(int destinationPort_){destinationPort=destinationPort_;}
    void setsigType(i2p::data::SigningKeyType sigType_){sigType=sigType_;}
    virtual ClientTunnelConfig* asClientTunnelConfig(){return this;}
    virtual ServerTunnelConfig* asServerTunnelConfig(){return nullptr;}
};

/*
# mandatory parameters:
# * host -- ip address of our service
# * port -- port of our service
# * keys -- file with LeaseSet of address in i2p
    std::string host = section.second.get<std::string> (I2P_SERVER_TUNNEL_HOST);
    int port = section.second.get<int> (I2P_SERVER_TUNNEL_PORT);
    std::string keys = section.second.get<std::string> (I2P_SERVER_TUNNEL_KEYS);
# optional parameters (may be omitted)
    int inPort = section.second.get (I2P_SERVER_TUNNEL_INPORT, 0);
    std::string accessList = section.second.get (I2P_SERVER_TUNNEL_ACCESS_LIST, "");
    std::string hostOverride = section.second.get (I2P_SERVER_TUNNEL_HOST_OVERRIDE, "");
    std::string webircpass = section.second.get<std::string> (I2P_SERVER_TUNNEL_WEBIRC_PASSWORD, "");
    bool gzip = section.second.get (I2P_SERVER_TUNNEL_GZIP, true);
    i2p::data::SigningKeyType sigType = section.second.get (I2P_SERVER_TUNNEL_SIGNATURE_TYPE, i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256);
    uint32_t maxConns = section.second.get(i2p::stream::I2CP_PARAM_STREAMING_MAX_CONNS_PER_MIN, i2p::stream::DEFAULT_MAX_CONNS_PER_MIN);
    std::string address = section.second.get<std::string> (I2P_SERVER_TUNNEL_ADDRESS, "127.0.0.1");
    bool isUniqueLocal = section.second.get(I2P_SERVER_TUNNEL_ENABLE_UNIQUE_LOCAL, true);
# * inport -- optional, i2p service port, if unset - the same as 'port'
# * accesslist -- comma-separated list of i2p addresses, allowed to connect
#    every address is b32 without '.b32.i2p' part
[somelabel]
type = server
host = 127.0.0.1
port = 6667
keys = irc.dat
*/
class ServerTunnelConfig : public TunnelConfig {
    std::string host;
    int port;
    std::string keys;
    int inPort;
    std::string accessList;
    std::string hostOverride;
    std::string webircpass;
    bool gzip;
    i2p::data::SigningKeyType sigType;
    uint32_t maxConns;
    std::string address;
    bool isUniqueLocal;
public:
    ServerTunnelConfig(std::string name_, QString type_, I2CPParameters& i2cpParameters_,
                       std::string host_,
                       int port_,
                       std::string keys_,
                       int inPort_,
                       std::string accessList_,
                       std::string hostOverride_,
                       std::string webircpass_,
                       bool gzip_,
                       i2p::data::SigningKeyType sigType_,
                       uint32_t maxConns_,
                       std::string address_,
                       bool isUniqueLocal_): TunnelConfig(name_, type_, i2cpParameters_),
        host(host_),
        port(port_),
        keys(keys_),
        inPort(inPort_),
        accessList(accessList_),
        hostOverride(hostOverride_),
        webircpass(webircpass_),
        gzip(gzip_),
        sigType(sigType_),
        maxConns(maxConns_),
        address(address_) {}
    std::string& gethost(){return host;}
    int getport(){return port;}
    std::string& getkeys(){return keys;}
    int getinPort(){return inPort;}
    std::string& getaccessList(){return accessList;}
    std::string& gethostOverride(){return hostOverride;}
    std::string& getwebircpass(){return webircpass;}
    bool getgzip(){return gzip;}
    i2p::data::SigningKeyType getsigType(){return sigType;}
    uint32_t getmaxConns(){return maxConns;}
    std::string& getaddress(){return address;}
    bool getisUniqueLocal(){return isUniqueLocal;}
    void sethost(std::string& host_){host=host_;}
    void setport(int port_){port=port_;}
    void setkeys(std::string& keys_){keys=keys_;}
    void setinPort(int inPort_){inPort=inPort_;}
    void setaccessList(std::string& accessList_){accessList=accessList_;}
    void sethostOverride(std::string& hostOverride_){hostOverride=hostOverride_;}
    void setwebircpass(std::string& webircpass_){webircpass=webircpass_;}
    void setgzip(bool gzip_){gzip=gzip_;}
    void setsigType(i2p::data::SigningKeyType sigType_){sigType=sigType_;}
    void setmaxConns(uint32_t maxConns_){maxConns=maxConns_;}
    void setaddress(std::string& address_){address=address_;}
    void setisUniqueLocal(bool isUniqueLocal_){isUniqueLocal=isUniqueLocal_;}
    virtual ClientTunnelConfig* asClientTunnelConfig(){return nullptr;}
    virtual ServerTunnelConfig* asServerTunnelConfig(){return this;}
};


#endif // TUNNELCONFIG_H