mirror of
https://github.com/PurpleI2P/i2pd.git
synced 2024-11-04 06:00:37 +00:00
227 lines
10 KiB
C++
227 lines
10 KiB
C++
#ifndef TUNNELCONFIG_H
|
|
#define TUNNELCONFIG_H
|
|
|
|
#include "QString"
|
|
#include <string>
|
|
|
|
#include "../../libi2pd_client/ClientContext.h"
|
|
#include "../../libi2pd/Destination.h"
|
|
#include "TunnelsPageUpdateListener.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;}
|
|
void saveHeaderToStringStream(std::stringstream& out);
|
|
void saveI2CPParametersToStringStream(std::stringstream& out);
|
|
virtual void saveToStringStream(std::stringstream& out)=0;
|
|
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(const std::string& dest_){dest=dest_;}
|
|
void setport(int port_){port=port_;}
|
|
void setkeys(const std::string & keys_){keys=keys_;}
|
|
void setaddress(const std::string & address_){address=address_;}
|
|
void setdestinationPort(int destinationPort_){destinationPort=destinationPort_;}
|
|
void setsigType(i2p::data::SigningKeyType sigType_){sigType=sigType_;}
|
|
virtual void saveToStringStream(std::stringstream& out);
|
|
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);
|
|
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;
|
|
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_,
|
|
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_),
|
|
address(address_),
|
|
isUniqueLocal(isUniqueLocal_) {}
|
|
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;}
|
|
std::string& getaddress(){return address;}
|
|
bool getisUniqueLocal(){return isUniqueLocal;}
|
|
void sethost(const std::string& host_){host=host_;}
|
|
void setport(int port_){port=port_;}
|
|
void setkeys(const std::string& keys_){keys=keys_;}
|
|
void setinPort(int inPort_){inPort=inPort_;}
|
|
void setaccessList(const std::string& accessList_){accessList=accessList_;}
|
|
void sethostOverride(const std::string& hostOverride_){hostOverride=hostOverride_;}
|
|
void setwebircpass(const std::string& webircpass_){webircpass=webircpass_;}
|
|
void setgzip(bool gzip_){gzip=gzip_;}
|
|
void setsigType(i2p::data::SigningKeyType sigType_){sigType=sigType_;}
|
|
void setaddress(const std::string& address_){address=address_;}
|
|
void setisUniqueLocal(bool isUniqueLocal_){isUniqueLocal=isUniqueLocal_;}
|
|
virtual void saveToStringStream(std::stringstream& out);
|
|
virtual ClientTunnelConfig* asClientTunnelConfig(){return nullptr;}
|
|
virtual ServerTunnelConfig* asServerTunnelConfig(){return this;}
|
|
};
|
|
|
|
|
|
#endif // TUNNELCONFIG_H
|