Changeset 812c00f


Ignore:
Timestamp:
Mar 10, 2015 8:05:45 PM (5 years ago)
Author:
str4d <str4d@…>
Branches:
master
Children:
1919e36
Parents:
419e27c
Message:

Move TunnelController? config creation logic into class that Android UI can use

Location:
apps/i2ptunnel/java/src/net/i2p/i2ptunnel
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/web/EditBean.java

    r419e27c r812c00f  
    2828import net.i2p.i2ptunnel.I2PTunnelIRCClient;
    2929import net.i2p.i2ptunnel.I2PTunnelServer;
     30import net.i2p.i2ptunnel.TunnelConfig;
    3031import net.i2p.i2ptunnel.TunnelController;
    3132import net.i2p.i2ptunnel.TunnelControllerGroup;
     
    360361    /** all of these are @since 0.8.3 */
    361362    public int getLimitMinute(int tunnel) {
    362         return getProperty(tunnel, PROP_MAX_CONNS_MIN, 0);
     363        return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_MIN, 0);
    363364    }
    364365
    365366    public int getLimitHour(int tunnel) {
    366         return getProperty(tunnel, PROP_MAX_CONNS_HOUR, 0);
     367        return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_HOUR, 0);
    367368    }
    368369
    369370    public int getLimitDay(int tunnel) {
    370         return getProperty(tunnel, PROP_MAX_CONNS_DAY, 0);
     371        return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_DAY, 0);
    371372    }
    372373
    373374    public int getTotalMinute(int tunnel) {
    374         return getProperty(tunnel, PROP_MAX_TOTAL_CONNS_MIN, 0);
     375        return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_MIN, 0);
    375376    }
    376377
    377378    public int getTotalHour(int tunnel) {
    378         return getProperty(tunnel, PROP_MAX_TOTAL_CONNS_HOUR, 0);
     379        return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_HOUR, 0);
    379380    }
    380381
    381382    public int getTotalDay(int tunnel) {
    382         return getProperty(tunnel, PROP_MAX_TOTAL_CONNS_DAY, 0);
     383        return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_DAY, 0);
    383384    }
    384385
    385386    public int getMaxStreams(int tunnel) {
    386         return getProperty(tunnel, PROP_MAX_STREAMS, 0);
     387        return getProperty(tunnel, TunnelConfig.PROP_MAX_STREAMS, 0);
    387388    }
    388389
     
    500501            for (Map.Entry<Object, Object> e : opts.entrySet()) {
    501502                String key = (String)e.getKey();
    502                 if (_noShowSet.contains(key))
     503                if (TunnelConfig._noShowSet.contains(key))
    503504                    continue;
    504505                // leave in for HTTP and Connect so it can get migrated to MD5
    505506                // hide for SOCKS until migrated to MD5
    506507                if ((!isMD5Proxy) &&
    507                     _nonProxyNoShowSet.contains(key))
     508                    TunnelConfig._nonProxyNoShowSet.contains(key))
    508509                    continue;
    509510                sorted.put(key, (String)e.getValue());
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/web/IndexBean.java

    r419e27c r812c00f  
    1111import java.io.File;
    1212import java.io.IOException;
    13 import java.security.GeneralSecurityException;
    1413import java.util.ArrayList;
    15 import java.util.Arrays;
    16 import java.util.HashSet;
    1714import java.util.List;
    1815import java.util.Locale;
    19 import java.util.Map;
    2016import java.util.Properties;
    21 import java.util.Set;
    22 import java.util.StringTokenizer;
    23 import java.util.concurrent.ConcurrentHashMap;
    2417
    2518import net.i2p.I2PAppContext;
    2619import net.i2p.app.ClientAppManager;
    2720import net.i2p.app.Outproxy;
    28 import net.i2p.client.I2PClient;
    29 import net.i2p.crypto.KeyGenerator;
    30 import net.i2p.crypto.SigType;
    31 import net.i2p.data.Base64;
    3221import net.i2p.data.Certificate;
    3322import net.i2p.data.DataHelper;
     
    3524import net.i2p.data.PrivateKeyFile;
    3625import net.i2p.data.SessionKey;
    37 import net.i2p.data.SimpleDataStructure;
    3826import net.i2p.i2ptunnel.I2PTunnelClientBase;
    39 import net.i2p.i2ptunnel.I2PTunnelConnectClient;
    4027import net.i2p.i2ptunnel.I2PTunnelHTTPClient;
    41 import net.i2p.i2ptunnel.I2PTunnelHTTPClientBase;
    4228import net.i2p.i2ptunnel.I2PTunnelHTTPServer;
    43 import net.i2p.i2ptunnel.I2PTunnelIRCClient;
    4429import net.i2p.i2ptunnel.I2PTunnelServer;
    4530import net.i2p.i2ptunnel.SSLClientUtil;
     31import net.i2p.i2ptunnel.TunnelConfig;
    4632import net.i2p.i2ptunnel.TunnelController;
    4733import net.i2p.i2ptunnel.TunnelControllerGroup;
    4834import net.i2p.util.Addresses;
    49 import net.i2p.util.ConcurrentHashSet;
    5035import net.i2p.util.FileUtil;
    5136import net.i2p.util.Log;
    52 import net.i2p.util.PasswordManager;
    5337import net.i2p.util.SecureFile;
    5438
     
    7256    //private long _nextNonce;
    7357
    74     private String _type;
    75     private String _name;
    76     private String _description;
    77     private String _i2cpHost;
    78     private String _i2cpPort;
    79     private String _tunnelDepth;
    80     private String _tunnelQuantity;
    81     private String _tunnelVariance;
    82     private String _tunnelBackupQuantity;
    83     private boolean _connectDelay;
    84     private String _customOptions;
    85     private String _proxyList;
    86     private String _port;
    87     private String _reachableBy;
    88     private String _targetDestination;
    89     private String _targetHost;
    90     private String _targetPort;
    91     private String _spoofedHost;
    92     private String _privKeyFile;
    93     private String _profile;
    94     private boolean _startOnLoad;
    95     private boolean _sharedClient;
     58    private TunnelConfig _config;
    9659    private boolean _removeConfirmed;
    97     private final Set<String> _booleanOptions;
    98     private final Map<String, String> _otherOptions;
    9960    private int _hashCashValue;
    10061    private int _certType;
    10162    private String _certSigner;
    102     private String _newProxyUser;
    103     private String _newProxyPW;
    10463   
    10564    public static final int RUNNING = 1;
     
    11574    private static final List<String> _nonces = new ArrayList<String>(MAX_NONCES + 1);
    11675
    117     static final String CLIENT_NICKNAME = "shared clients";
    11876    public static final String PROP_THEME_NAME = "routerconsole.theme";
    11977    public static final String DEFAULT_THEME = "light";
     
    14199        _curNonce = "-1";
    142100        addNonce();
    143         _booleanOptions = new ConcurrentHashSet<String>(4);
    144         _otherOptions = new ConcurrentHashMap<String, String>(4);
     101        _config = new TunnelConfig();
    145102    }
    146103   
     
    333290                if (Boolean.parseBoolean(c.getSharedClient()) && isClient(c.getType())) {
    334291                    Properties cOpt = c.getConfig("");
    335                     if (_tunnelQuantity != null) {
    336                         cOpt.setProperty("option.inbound.quantity", _tunnelQuantity);
    337                         cOpt.setProperty("option.outbound.quantity", _tunnelQuantity);
    338                     }
    339                     if (_tunnelDepth != null) {
    340                         cOpt.setProperty("option.inbound.length", _tunnelDepth);
    341                         cOpt.setProperty("option.outbound.length", _tunnelDepth);
    342                     }
    343                     if (_tunnelVariance != null) {
    344                         cOpt.setProperty("option.inbound.lengthVariance", _tunnelVariance);
    345                         cOpt.setProperty("option.outbound.lengthVariance", _tunnelVariance);
    346                     }
    347                     if (_tunnelBackupQuantity != null) {
    348                         cOpt.setProperty("option.inbound.backupQuantity", _tunnelBackupQuantity);
    349                         cOpt.setProperty("option.outbound.backupQuantity", _tunnelBackupQuantity);
    350                     }
    351                     cOpt.setProperty("option.inbound.nickname", CLIENT_NICKNAME);
    352                     cOpt.setProperty("option.outbound.nickname", CLIENT_NICKNAME);
     292                    _config.updateTunnelQuantities(config);
     293                    cOpt.setProperty("option.inbound.nickname", TunnelConfig.SHARED_CLIENT_NICKNAME);
     294                    cOpt.setProperty("option.outbound.nickname", TunnelConfig.SHARED_CLIENT_NICKNAME);
    353295                   
    354296                    c.setConfig(cOpt, "");
     
    397339        String pk = cur.getPrivKeyFile();
    398340        if (pk == null)
    399             pk = _privKeyFile;
     341            pk = _config.getPrivKeyFile();
    400342        if (pk != null && pk.startsWith("i2ptunnel") && pk.endsWith("-privKeys.dat") &&
    401343            ((!isClient(cur.getType())) || cur.getPersistentClientKey())) {
     
    744686     */
    745687    public void setType(String type) {
    746         _type = (type != null ? type.trim() : null);   
    747     }
    748     String getType() { return _type; }
     688        _config.setType(type);
     689    }
     690    String getType() { return _config.getType(); }
    749691   
    750692    /** Short name of the tunnel */
    751693    public void setName(String name) {
    752         _name = (name != null ? name.trim() : null);
     694        _config.setName(name);
    753695    }
    754696    /** one line description */
    755697    public void setNofilter_description(String description) {
    756         // '#' will blow up DataHelper.storeProps()
    757         _description = (description != null ? description.replace('#', ' ').trim() : null);
     698        _config.setDescription(description);
    758699    }
    759700    /** I2CP host the router is on, ignored when in router context */
    760701    public void setClientHost(String host) {
    761         _i2cpHost = (host != null ? host.trim() : null);
     702        _config.setClientHost(host);
    762703    }
    763704    /** I2CP port the router is on, ignored when in router context */
    764705    public void setClientport(String port) {
    765         _i2cpPort = (port != null ? port.trim() : null);
     706        _config.setClientPort(port);
    766707    }
    767708    /** how many hops to use for inbound tunnels */
    768     public void setTunnelDepth(String tunnelDepth) {
    769         _tunnelDepth = (tunnelDepth != null ? tunnelDepth.trim() : null);
     709    public void setTunnelDepth(String tunnelDepth) {
     710        if (tunnelDepth != null) {
     711            try {
     712                _config.setTunnelDepth(Integer.parseInt(tunnelDepth.trim()));
     713            } catch (NumberFormatException nfe) {}
     714        }
    770715    }
    771716    /** how many parallel inbound tunnels to use */
    772     public void setTunnelQuantity(String tunnelQuantity) {
    773         _tunnelQuantity = (tunnelQuantity != null ? tunnelQuantity.trim() : null);
     717    public void setTunnelQuantity(String tunnelQuantity) {
     718        if (tunnelQuantity != null) {
     719            try {
     720                _config.setTunnelQuantity(Integer.parseInt(tunnelQuantity.trim()));
     721            } catch (NumberFormatException nfe) {}
     722        }
    774723    }
    775724    /** how much randomisation to apply to the depth of tunnels */
    776     public void setTunnelVariance(String tunnelVariance) {
    777         _tunnelVariance = (tunnelVariance != null ? tunnelVariance.trim() : null);
     725    public void setTunnelVariance(String tunnelVariance) {
     726        if (tunnelVariance != null) {
     727            try {
     728                _config.setTunnelVariance(Integer.parseInt(tunnelVariance.trim()));
     729            } catch (NumberFormatException nfe) {}
     730        }
    778731    }
    779732    /** how many tunnels to hold in reserve to guard against failures */
    780     public void setTunnelBackupQuantity(String tunnelBackupQuantity) {
    781         _tunnelBackupQuantity = (tunnelBackupQuantity != null ? tunnelBackupQuantity.trim() : null);
     733    public void setTunnelBackupQuantity(String tunnelBackupQuantity) {
     734        if (tunnelBackupQuantity != null) {
     735            try {
     736                _config.setTunnelBackupQuantity(Integer.parseInt(tunnelBackupQuantity.trim()));
     737            } catch (NumberFormatException nfe) {}
     738        }
    782739    }
    783740    /** what I2P session overrides should be used */
    784741    public void setNofilter_customOptions(String customOptions) {
    785         _customOptions = (customOptions != null ? customOptions.trim() : null);
     742        _config.setCustomOptions(customOptions);
    786743    }
    787744    /** what HTTP outproxies should be used (httpclient specific) */
    788745    public void setProxyList(String proxyList) {
    789         _proxyList = (proxyList != null ? proxyList.trim() : null);
     746        _config.setProxyList(proxyList);
    790747    }
    791748    /** what port should this client/httpclient/ircclient listen on */
    792749    public void setPort(String port) {
    793         _port = (port != null ? port.trim() : null);
     750        if (port != null) {
     751            try {
     752                _config.setPort(Integer.parseInt(port.trim()));
     753            } catch (NumberFormatException nfe) {}
     754        }
    794755    }
    795756    /**
     
    797758     */
    798759    public void setReachableBy(String reachableBy) {
    799         _reachableBy = (reachableBy != null ? reachableBy.trim() : null);
     760        _config.setReachableBy(reachableBy);
    800761    }
    801762    /** What peer does this client tunnel point at */
    802763    public void setTargetDestination(String dest) {
    803         _targetDestination = (dest != null ? dest.trim() : null);
     764        _config.setTargetDestination(dest);
    804765    }
    805766    /** What host does this server tunnel point at */
    806767    public void setTargetHost(String host) {
    807         _targetHost = (host != null ? host.trim() : null);
     768        _config.setTargetHost(host);
    808769    }
    809770    /** What port does this server tunnel point at */
    810     public void setTargetPort(String port) {
    811         _targetPort = (port != null ? port.trim() : null);
     771    public void setTargetPort(String port) {
     772        if (port != null) {
     773            try {
     774                _config.setTargetPort(Integer.parseInt(port.trim()));
     775            } catch (NumberFormatException nfe) {}
     776        }
    812777    }
    813778    /** What host does this http server tunnel spoof */
    814779    public void setSpoofedHost(String host) {
    815         _spoofedHost = (host != null ? host.trim() : null);
     780        _config.setSpoofedHost(host);
    816781    }
    817782    /** What filename is this server tunnel's private keys stored in */
    818783    public void setPrivKeyFile(String file) {
    819         _privKeyFile = (file != null ? file.trim() : null);
     784        _config.setPrivKeyFile(file);
    820785    }
    821786    /**
     
    831796     */
    832797    public void setStartOnLoad(String moo) {
    833         _startOnLoad = true;
     798        _config.setStartOnLoad(true);
    834799    }
    835800    public void setShared(String moo) {
    836         _sharedClient=true;
     801        _config.setShared(true);
    837802    }
    838803    public void setShared(boolean val) {
    839         _sharedClient=val;
     804        _config.setShared(val);
    840805    }
    841806    public void setConnectDelay(String moo) {
    842         _connectDelay = true;
     807        _config.setConnectDelay(true);
    843808    }
    844809    public void setProfile(String profile) {
    845         _profile = profile;
     810        _config.setProfile(profile);
    846811    }
    847812
    848813    public void setReduce(String moo) {
    849         _booleanOptions.add("i2cp.reduceOnIdle");
     814        _config.setReduce();
    850815    }
    851816    public void setClose(String moo) {
    852         _booleanOptions.add("i2cp.closeOnIdle");
     817        _config.setClose();
    853818    }
    854819    public void setEncrypt(String moo) {
    855         _booleanOptions.add("i2cp.encryptLeaseSet");
     820        _config.setEncrypt();
    856821    }
    857822
    858823    /** @since 0.8.9 */
    859824    public void setDCC(String moo) {
    860         _booleanOptions.add(I2PTunnelIRCClient.PROP_DCC);
     825        _config.setDCC();
    861826    }
    862827
    863828    /** @since 0.9.9 */
    864829    public void setUseSSL(String moo) {
    865         _booleanOptions.add(I2PTunnelServer.PROP_USE_SSL);
     830        _config.setUseSSL();
    866831    }
    867832
     
    878843    /** @since 0.9.12 */
    879844    public void setRejectInproxy(String moo) {
    880         _booleanOptions.add(I2PTunnelHTTPServer.OPT_REJECT_INPROXY);
     845        _config.setRejectInproxy();
    881846    }
    882847
     
    893858    /** @since 0.9.13 */
    894859    public void setUniqueLocal(String moo) {
    895         _booleanOptions.add(I2PTunnelServer.PROP_UNIQUE_LOCAL);
     860        _config.setUniqueLocal();
    896861    }
    897862
     
    900865
    901866    public void setAccessMode(String val) {
    902         if ("1".equals(val))
    903             _booleanOptions.add(PROP_ENABLE_ACCESS_LIST);
    904         else if ("2".equals(val))
    905             _booleanOptions.add(PROP_ENABLE_BLACKLIST);
     867        _config.setAccessMode(val);
    906868    }
    907869
    908870    public void setDelayOpen(String moo) {
    909         _booleanOptions.add("i2cp.delayOpen");
     871        _config.setDelayOpen();
    910872    }
    911873    public void setNewDest(String val) {
    912         if ("1".equals(val))
    913             _booleanOptions.add("i2cp.newDestOnResume");
    914         else if ("2".equals(val))
    915             _booleanOptions.add("persistentClientKey");
     874        _config.setNewDest(val);
    916875    }
    917876
     
    919878        if (val != null) {
    920879            try {
    921                 _otherOptions.put("i2cp.reduceIdleTime", Integer.toString(Integer.parseInt(val.trim()) * 60*1000));
     880                _config.setReduceTime(Integer.parseInt(val.trim()));
    922881            } catch (NumberFormatException nfe) {}
    923882        }
    924883    }
    925884    public void setReduceCount(String val) {
    926         if (val != null)
    927             _otherOptions.put("i2cp.reduceQuantity", val.trim());
     885        if (val != null) {
     886            try {
     887                _config.setReduceCount(Integer.parseInt(val.trim()));
     888            } catch (NumberFormatException nfe) {}
     889        }
    928890    }
    929891    public void setEncryptKey(String val) {
    930         if (val != null)
    931             _otherOptions.put("i2cp.leaseSetKey", val.trim());
     892        _config.setEncryptKey(val);
    932893    }
    933894
    934895    public void setAccessList(String val) {
    935         if (val != null)
    936             _otherOptions.put("i2cp.accessList", val.trim().replace("\r\n", ",").replace("\n", ",").replace(" ", ","));
     896        _config.setAccessList(val);
    937897    }
    938898
    939899    public void setJumpList(String val) {
    940         if (val != null)
    941             _otherOptions.put(I2PTunnelHTTPClient.PROP_JUMP_SERVERS, val.trim().replace("\r\n", ",").replace("\n", ",").replace(" ", ","));
     900        _config.setJumpList(val);
    942901    }
    943902
     
    945904        if (val != null) {
    946905            try {
    947                 _otherOptions.put("i2cp.closeIdleTime", Integer.toString(Integer.parseInt(val.trim()) * 60*1000));
     906                _config.setCloseTime(Integer.parseInt(val.trim()));
    948907            } catch (NumberFormatException nfe) {}
    949908        }
     
    952911    /** @since 0.9.14 */
    953912    public void setAllowUserAgent(String moo) {
    954         _booleanOptions.add(I2PTunnelHTTPClient.PROP_USER_AGENT);
     913        _config.setAllowUserAgent();
    955914    }
    956915
    957916    /** @since 0.9.14 */
    958917    public void setAllowReferer(String moo) {
    959         _booleanOptions.add(I2PTunnelHTTPClient.PROP_REFERER);
     918        _config.setAllowReferer();
    960919    }
    961920
    962921    /** @since 0.9.14 */
    963922    public void setAllowAccept(String moo) {
    964         _booleanOptions.add(I2PTunnelHTTPClient.PROP_ACCEPT);
     923        _config.setAllowAccept();
    965924    }
    966925
    967926    /** @since 0.9.14 */
    968927    public void setAllowInternalSSL(String moo) {
    969         _booleanOptions.add(I2PTunnelHTTPClient.PROP_INTERNAL_SSL);
     928        _config.setAllowInternalSSL();
    970929    }
    971930
    972931    /** @since 0.9.18 */
    973932    public void setMultihome(String moo) {
    974         _booleanOptions.add("shouldBundleReplyInfo");
     933        _config.setMultihome();
    975934    }
    976935
    977936    /** all proxy auth @since 0.8.2 */
    978937    public void setProxyAuth(String s) {
    979         if (s != null)
    980             _otherOptions.put(I2PTunnelHTTPClientBase.PROP_AUTH, I2PTunnelHTTPClientBase.DIGEST_AUTH);
     938        _config.setProxyAuth(s);
    981939    }
    982940   
    983941    public void setProxyUsername(String s) {
    984         if (s != null)
    985             _newProxyUser = s.trim();
     942        _config.setProxyUsername(s);
    986943    }
    987944   
    988945    public void setNofilter_proxyPassword(String s) {
    989         if (s != null)
    990             _newProxyPW = s.trim();
     946        _config.setProxyPassword(s);
    991947    }
    992948   
    993949    public void setOutproxyAuth(String s) {
    994         _otherOptions.put(I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH, I2PTunnelHTTPClientBase.DIGEST_AUTH);
     950        _config.setOutproxyAuth(s);
    995951    }
    996952   
    997953    public void setOutproxyUsername(String s) {
    998         if (s != null)
    999             _otherOptions.put(I2PTunnelHTTPClientBase.PROP_OUTPROXY_USER, s.trim());
     954        _config.setOutproxyUsername(s);
    1000955    }
    1001956   
    1002957    public void setNofilter_outproxyPassword(String s) {
    1003         if (s != null)
    1004             _otherOptions.put(I2PTunnelHTTPClientBase.PROP_OUTPROXY_PW, s.trim());
     958        _config.setOutproxyPassword(s);
    1005959    }
    1006960
    1007961    /** @since 0.9.11 */
    1008962    public void setSslProxies(String s) {
    1009         if (s != null)
    1010             _otherOptions.put(I2PTunnelHTTPClient.PROP_SSL_OUTPROXIES, s.trim().replace(" ", ","));
     963        _config.setSslProxies(s);
    1011964    }
    1012965
    1013966    /** @since 0.9.11 */
    1014967    public void setUseOutproxyPlugin(String moo) {
    1015         _booleanOptions.add(I2PTunnelHTTPClient.PROP_USE_OUTPROXY_PLUGIN);
    1016     }
    1017    
    1018     /** all of these are @since 0.8.3 */
    1019     protected static final String PROP_MAX_CONNS_MIN = "i2p.streaming.maxConnsPerMinute";
    1020     protected static final String PROP_MAX_CONNS_HOUR = "i2p.streaming.maxConnsPerHour";
    1021     protected static final String PROP_MAX_CONNS_DAY = "i2p.streaming.maxConnsPerDay";
    1022     protected static final String PROP_MAX_TOTAL_CONNS_MIN = "i2p.streaming.maxTotalConnsPerMinute";
    1023     protected static final String PROP_MAX_TOTAL_CONNS_HOUR = "i2p.streaming.maxTotalConnsPerHour";
    1024     protected static final String PROP_MAX_TOTAL_CONNS_DAY = "i2p.streaming.maxTotalConnsPerDay";
    1025     protected static final String PROP_MAX_STREAMS = "i2p.streaming.maxConcurrentStreams";
     968        _config.setUseOutproxyPlugin();
     969    }
    1026970
    1027971    public void setLimitMinute(String s) {
    1028         if (s != null)
    1029             _otherOptions.put(PROP_MAX_CONNS_MIN, s.trim());
     972        if (s != null) {
     973            try {
     974                _config.setLimitMinute(Integer.parseInt(s.trim()));
     975            } catch (NumberFormatException nfe) {}
     976        }
    1030977    }
    1031978
    1032979    public void setLimitHour(String s) {
    1033         if (s != null)
    1034             _otherOptions.put(PROP_MAX_CONNS_HOUR, s.trim());
     980        if (s != null) {
     981            try {
     982                _config.setLimitHour(Integer.parseInt(s.trim()));
     983            } catch (NumberFormatException nfe) {}
     984        }
    1035985    }
    1036986
    1037987    public void setLimitDay(String s) {
    1038         if (s != null)
    1039             _otherOptions.put(PROP_MAX_CONNS_DAY, s.trim());
     988        if (s != null) {
     989            try {
     990                _config.setLimitDay(Integer.parseInt(s.trim()));
     991            } catch (NumberFormatException nfe) {}
     992        }
    1040993    }
    1041994
    1042995    public void setTotalMinute(String s) {
    1043         if (s != null)
    1044             _otherOptions.put(PROP_MAX_TOTAL_CONNS_MIN, s.trim());
     996        if (s != null) {
     997            try {
     998                _config.setTotalMinute(Integer.parseInt(s.trim()));
     999            } catch (NumberFormatException nfe) {}
     1000        }
    10451001    }
    10461002
    10471003    public void setTotalHour(String s) {
    1048         if (s != null)
    1049             _otherOptions.put(PROP_MAX_TOTAL_CONNS_HOUR, s.trim());
     1004        if (s != null) {
     1005            try {
     1006                _config.setTotalHour(Integer.parseInt(s.trim()));
     1007            } catch (NumberFormatException nfe) {}
     1008        }
    10501009    }
    10511010
    10521011    public void setTotalDay(String s) {
    1053         if (s != null)
    1054             _otherOptions.put(PROP_MAX_TOTAL_CONNS_DAY, s.trim());
     1012        if (s != null) {
     1013            try {
     1014                _config.setTotalDay(Integer.parseInt(s.trim()));
     1015            } catch (NumberFormatException nfe) {}
     1016        }
    10551017    }
    10561018
    10571019    public void setMaxStreams(String s) {
    1058         if (s != null)
    1059             _otherOptions.put(PROP_MAX_STREAMS, s.trim());
     1020        if (s != null) {
     1021            try {
     1022                _config.setMaxStreams(Integer.parseInt(s.trim()));
     1023            } catch (NumberFormatException nfe) {}
     1024        }
    10601025    }
    10611026
     
    10651030     */
    10661031    public void setPostMax(String s) {
    1067         if (s != null)
    1068             _otherOptions.put(I2PTunnelHTTPServer.OPT_POST_MAX, s.trim());
     1032        if (s != null) {
     1033            try {
     1034                _config.setPostMax(Integer.parseInt(s.trim()));
     1035            } catch (NumberFormatException nfe) {}
     1036        }
    10691037    }
    10701038
    10711039    public void setPostTotalMax(String s) {
    1072         if (s != null)
    1073             _otherOptions.put(I2PTunnelHTTPServer.OPT_POST_TOTAL_MAX, s.trim());
     1040        if (s != null) {
     1041            try {
     1042                _config.setPostTotalMax(Integer.parseInt(s.trim()));
     1043            } catch (NumberFormatException nfe) {}
     1044        }
    10741045    }
    10751046
    10761047    public void setPostCheckTime(String s) {
    1077         if (s != null)
    1078             _otherOptions.put(I2PTunnelHTTPServer.OPT_POST_WINDOW, Integer.toString(Integer.parseInt(s.trim()) * 60));
     1048        if (s != null) {
     1049            try {
     1050                _config.setPostCheckTime(Integer.parseInt(s.trim()));
     1051            } catch (NumberFormatException nfe) {}
     1052        }
    10791053    }
    10801054
    10811055    public void setPostBanTime(String s) {
    1082         if (s != null)
    1083             _otherOptions.put(I2PTunnelHTTPServer.OPT_POST_BAN_TIME, Integer.toString(Integer.parseInt(s.trim()) * 60));
     1056        if (s != null) {
     1057            try {
     1058                _config.setPostBanTime(Integer.parseInt(s.trim()));
     1059            } catch (NumberFormatException nfe) {}
     1060        }
    10841061    }
    10851062
    10861063    public void setPostTotalBanTime(String s) {
    1087         if (s != null)
    1088             _otherOptions.put(I2PTunnelHTTPServer.OPT_POST_TOTAL_BAN_TIME, Integer.toString(Integer.parseInt(s.trim()) * 60));
     1064        if (s != null) {
     1065            try {
     1066                _config.setPostTotalBanTime(Integer.parseInt(s.trim()));
     1067            } catch (NumberFormatException nfe) {}
     1068        }
    10891069    }
    10901070
     
    11131093    public void setSigType(String val) {
    11141094        if (val != null) {
    1115             _otherOptions.put(I2PClient.PROP_SIGTYPE, val);
     1095            _config.setSigType(val);
    11161096            if (val.equals("0"))
    11171097                _certType = 0;
     
    11281108     */
    11291109    public void setKey1(String s) {
    1130         if (s != null)
    1131             _otherOptions.put("inbound.randomKey", s.trim());
     1110        _config.setInboundRandomKey(s);
    11321111    }
    11331112
    11341113    public void setKey2(String s) {
    1135         if (s != null)
    1136             _otherOptions.put("outbound.randomKey", s.trim());
     1114        _config.setOutboundRandomKey(s);
    11371115    }
    11381116
    11391117    public void setKey3(String s) {
    1140         if (s != null)
    1141             _otherOptions.put("i2cp.leaseSetSigningPrivateKey", s.trim());
     1118        _config.setLeaseSetSigningPrivateKey(s);
    11421119    }
    11431120
    11441121    public void setKey4(String s) {
    1145         if (s != null)
    1146             _otherOptions.put("i2cp.leaseSetPrivateKey", s.trim());
     1122        _config.setLeaseSetPrivateKey(s);
    11471123    }
    11481124
    11491125    /** Modify or create a destination */
    11501126    private String modifyDestination() {
    1151         if (_privKeyFile == null || _privKeyFile.trim().length() <= 0)
     1127        String privKeyFile = _config.getPrivKeyFile();
     1128        if (privKeyFile == null)
    11521129            return "Private Key File not specified";
    11531130
     
    11631140        }
    11641141
    1165         File keyFile = new File(_privKeyFile);
     1142        File keyFile = new File(privKeyFile);
    11661143        if (!keyFile.isAbsolute())
    1167             keyFile = new File(_context.getConfigDir(), _privKeyFile);
     1144            keyFile = new File(_context.getConfigDir(), privKeyFile);
    11681145        PrivateKeyFile pkf = new PrivateKeyFile(keyFile);
    11691146        try {
     
    11951172                if (signerPKF == null || signerPKF.length() <= 0)
    11961173                    return "Signing destination " + _certSigner + " not found";
    1197                 if (_privKeyFile.equals(signerPKF))
     1174                if (privKeyFile.equals(signerPKF))
    11981175                    return "Self-signed destinations not allowed";
    11991176                Certificate c = pkf.setSignedCert(new PrivateKeyFile(signerPKF));
     
    12441221     */
    12451222    private Properties getConfig() {
    1246         Properties config = new Properties();
    1247         updateConfigGeneric(config);
    1248        
    1249         if ((isClient(_type) && !TunnelController.TYPE_STREAMR_CLIENT.equals(_type)) ||
    1250             TunnelController.TYPE_STREAMR_SERVER.equals(_type)) {
    1251             // streamrserver uses interface
    1252             if (_reachableBy != null)
    1253                 config.setProperty(TunnelController.PROP_INTFC, _reachableBy);
    1254             else
    1255                 config.setProperty(TunnelController.PROP_INTFC, "");
    1256         } else {
    1257             // streamrclient uses targetHost
    1258             if (_targetHost != null)
    1259                 config.setProperty(TunnelController.PROP_TARGET_HOST, _targetHost);
    1260         }
    1261 
    1262         if (isClient(_type)) {
    1263             // generic client stuff
    1264             if (_port != null)
    1265                 config.setProperty(TunnelController.PROP_LISTEN_PORT, _port);
    1266             config.setProperty(TunnelController.PROP_SHARED, _sharedClient + "");
    1267             for (String p : _booleanClientOpts)
    1268                 config.setProperty(OPT + p, "" + _booleanOptions.contains(p));
    1269             for (String p : _otherClientOpts) {
    1270                 if (_otherOptions.containsKey(p))
    1271                     config.setProperty(OPT + p, _otherOptions.get(p));
    1272             }
    1273         } else {
    1274             // generic server stuff
    1275             if (_targetPort != null)
    1276                 config.setProperty(TunnelController.PROP_TARGET_PORT, _targetPort);
    1277             for (String p : _booleanServerOpts)
    1278                 config.setProperty(OPT + p, "" + _booleanOptions.contains(p));
    1279             for (String p : _otherServerOpts) {
    1280                 if (_otherOptions.containsKey(p))
    1281                     config.setProperty(OPT + p, _otherOptions.get(p));
    1282             }
    1283         }
    1284 
    1285         // generic proxy stuff
    1286         if (TunnelController.TYPE_HTTP_CLIENT.equals(_type) || TunnelController.TYPE_CONNECT.equals(_type) ||
    1287             TunnelController.TYPE_SOCKS.equals(_type) ||TunnelController.TYPE_SOCKS_IRC.equals(_type)) {
    1288             for (String p : _booleanProxyOpts)
    1289                 config.setProperty(OPT + p, "" + _booleanOptions.contains(p));
    1290             if (_proxyList != null)
    1291                 config.setProperty(TunnelController.PROP_PROXIES, _proxyList);
    1292         }
    1293 
    1294         // Proxy auth including migration to MD5
    1295         if (TunnelController.TYPE_HTTP_CLIENT.equals(_type) || TunnelController.TYPE_CONNECT.equals(_type)) {
    1296             // Migrate even if auth is disabled
    1297             // go get the old from custom options that updateConfigGeneric() put in there
    1298             String puser = OPT + I2PTunnelHTTPClientBase.PROP_USER;
    1299             String user = config.getProperty(puser);
    1300             String ppw = OPT + I2PTunnelHTTPClientBase.PROP_PW;
    1301             String pw = config.getProperty(ppw);
    1302             if (user != null && pw != null && user.length() > 0 && pw.length() > 0) {
    1303                 String pmd5 = OPT + I2PTunnelHTTPClientBase.PROP_PROXY_DIGEST_PREFIX +
    1304                               user + I2PTunnelHTTPClientBase.PROP_PROXY_DIGEST_SUFFIX;
    1305                 if (config.getProperty(pmd5) == null) {
    1306                     // not in there, migrate
    1307                     String realm = _type.equals(TunnelController.TYPE_HTTP_CLIENT) ? I2PTunnelHTTPClient.AUTH_REALM
    1308                                                               : I2PTunnelConnectClient.AUTH_REALM;
    1309                     String hex = PasswordManager.md5Hex(realm, user, pw);
    1310                     if (hex != null) {
    1311                         config.setProperty(pmd5, hex);
    1312                         config.remove(puser);
    1313                         config.remove(ppw);
    1314                     }
    1315                 }
    1316             }
    1317             // New user/password
    1318             String auth = _otherOptions.get(I2PTunnelHTTPClientBase.PROP_AUTH);
    1319             if (auth != null && !auth.equals("false")) {
    1320                 if (_newProxyUser != null && _newProxyPW != null &&
    1321                     _newProxyUser.length() > 0 && _newProxyPW.length() > 0) {
    1322                     String pmd5 = OPT + I2PTunnelHTTPClientBase.PROP_PROXY_DIGEST_PREFIX +
    1323                                   _newProxyUser + I2PTunnelHTTPClientBase.PROP_PROXY_DIGEST_SUFFIX;
    1324                     String realm = _type.equals(TunnelController.TYPE_HTTP_CLIENT) ? I2PTunnelHTTPClient.AUTH_REALM
    1325                                                               : I2PTunnelConnectClient.AUTH_REALM;
    1326                     String hex = PasswordManager.md5Hex(realm, _newProxyUser, _newProxyPW);
    1327                     if (hex != null)
    1328                         config.setProperty(pmd5, hex);
    1329                 }
    1330             }
    1331         }
    1332 
    1333         if (TunnelController.TYPE_IRC_CLIENT.equals(_type) ||
    1334             TunnelController.TYPE_STD_CLIENT.equals(_type) ||
    1335             TunnelController.TYPE_STREAMR_CLIENT.equals(_type)) {
    1336             if (_targetDestination != null)
    1337                 config.setProperty(TunnelController.PROP_DEST, _targetDestination);
    1338         } else if (TunnelController.TYPE_HTTP_SERVER.equals(_type) ||
    1339                    TunnelController.TYPE_HTTP_BIDIR_SERVER.equals(_type)) {
    1340             if (_spoofedHost != null)
    1341                 config.setProperty(TunnelController.PROP_SPOOFED_HOST, _spoofedHost);
    1342             for (String p : _httpServerOpts)
    1343                 if (_otherOptions.containsKey(p))
    1344                     config.setProperty(OPT + p, _otherOptions.get(p));
    1345         }
    1346         if (TunnelController.TYPE_HTTP_BIDIR_SERVER.equals(_type)) {
    1347             if (_port != null)
    1348                 config.setProperty(TunnelController.PROP_LISTEN_PORT, _port);
    1349             if (_reachableBy != null)
    1350                 config.setProperty(TunnelController.PROP_INTFC, _reachableBy);
    1351             else if (_targetHost != null)
    1352                 config.setProperty(TunnelController.PROP_INTFC, _targetHost);
    1353             else
    1354                 config.setProperty(TunnelController.PROP_INTFC, "");
    1355         }
    1356 
    1357         if (TunnelController.TYPE_IRC_CLIENT.equals(_type)) {
    1358             boolean dcc = _booleanOptions.contains(I2PTunnelIRCClient.PROP_DCC);
    1359             config.setProperty(OPT + I2PTunnelIRCClient.PROP_DCC,
    1360                                "" + dcc);
    1361             // add some sane server options since they aren't in the GUI (yet)
    1362             if (dcc) {
    1363                 config.setProperty(OPT + PROP_MAX_CONNS_MIN, "3");
    1364                 config.setProperty(OPT + PROP_MAX_CONNS_HOUR, "10");
    1365                 config.setProperty(OPT + PROP_MAX_TOTAL_CONNS_MIN, "5");
    1366                 config.setProperty(OPT + PROP_MAX_TOTAL_CONNS_HOUR, "25");
    1367             }
    1368         }
    1369 
    1370         if (!isClient(_type) || _booleanOptions.contains("persistentClientKey")) {
    1371             // As of 0.9.17, add a persistent random key if not present
    1372             String p = OPT + "inbound.randomKey";
    1373             if (!config.containsKey(p)) {
    1374                 byte[] rk = new byte[32];
    1375                 _context.random().nextBytes(rk);
    1376                 config.setProperty(p, Base64.encode(rk));
    1377                 p = OPT + "outbound.randomKey";
    1378                 _context.random().nextBytes(rk);
    1379                 config.setProperty(p, Base64.encode(rk));
    1380             }
    1381             // As of 0.9.18, add persistent leaseset keys if not present
    1382             // but only if we know the sigtype
    1383             p = OPT + "i2cp.leaseSetSigningPrivateKey";
    1384             Destination dest = getDestination(_tunnel);
    1385             if (dest != null && !config.containsKey(p)) {
    1386                 try {
    1387                     SigType type = dest.getSigType();
    1388                     SimpleDataStructure keys[] = KeyGenerator.getInstance().generateSigningKeys(type);
    1389                     config.setProperty(p, type.name() + ':' + keys[1].toBase64());
    1390                     p = OPT + "i2cp.leaseSetPrivateKey";
    1391                     keys = KeyGenerator.getInstance().generatePKIKeys();
    1392                     config.setProperty(p, "ELGAMAL_2048:" + keys[1].toBase64());
    1393                 } catch (GeneralSecurityException gse) {
    1394                     // so much for that
    1395                 }
    1396             }
    1397         }
    1398 
    1399         return config;
    1400     }
    1401    
    1402     private static final String _noShowOpts[] = {
    1403         "inbound.length", "outbound.length", "inbound.lengthVariance", "outbound.lengthVariance",
    1404         "inbound.backupQuantity", "outbound.backupQuantity", "inbound.quantity", "outbound.quantity",
    1405         "inbound.nickname", "outbound.nickname", "i2p.streaming.connectDelay", "i2p.streaming.maxWindowSize",
    1406         I2PTunnelIRCClient.PROP_DCC
    1407         };
    1408     private static final String _booleanClientOpts[] = {
    1409         "i2cp.reduceOnIdle", "i2cp.closeOnIdle", "i2cp.newDestOnResume", "persistentClientKey", "i2cp.delayOpen",
    1410         I2PTunnelClientBase.PROP_USE_SSL,
    1411         };
    1412     private static final String _booleanProxyOpts[] = {
    1413         I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH,
    1414         I2PTunnelHTTPClient.PROP_USE_OUTPROXY_PLUGIN,
    1415         I2PTunnelHTTPClient.PROP_USER_AGENT,
    1416         I2PTunnelHTTPClient.PROP_REFERER,
    1417         I2PTunnelHTTPClient.PROP_ACCEPT,
    1418         I2PTunnelHTTPClient.PROP_INTERNAL_SSL
    1419         };
    1420     private static final String _booleanServerOpts[] = {
    1421         "i2cp.reduceOnIdle", "i2cp.encryptLeaseSet", PROP_ENABLE_ACCESS_LIST, PROP_ENABLE_BLACKLIST,
    1422         I2PTunnelServer.PROP_USE_SSL,
    1423         I2PTunnelHTTPServer.OPT_REJECT_INPROXY,
    1424         I2PTunnelServer.PROP_UNIQUE_LOCAL,
    1425         "shouldBundleReplyInfo"
    1426         };
    1427     private static final String _otherClientOpts[] = {
    1428         "i2cp.reduceIdleTime", "i2cp.reduceQuantity", "i2cp.closeIdleTime",
    1429         "outproxyUsername", "outproxyPassword",
    1430         I2PTunnelHTTPClient.PROP_JUMP_SERVERS,
    1431         I2PTunnelHTTPClientBase.PROP_AUTH,
    1432         I2PClient.PROP_SIGTYPE,
    1433         I2PTunnelHTTPClient.PROP_SSL_OUTPROXIES,
    1434         // following are mostly server but could also be persistent client
    1435         "inbound.randomKey", "outbound.randomKey", "i2cp.leaseSetSigningPrivateKey", "i2cp.leaseSetPrivateKey"
    1436         };
    1437     private static final String _otherServerOpts[] = {
    1438         "i2cp.reduceIdleTime", "i2cp.reduceQuantity", "i2cp.leaseSetKey", "i2cp.accessList",
    1439          PROP_MAX_CONNS_MIN, PROP_MAX_CONNS_HOUR, PROP_MAX_CONNS_DAY,
    1440          PROP_MAX_TOTAL_CONNS_MIN, PROP_MAX_TOTAL_CONNS_HOUR, PROP_MAX_TOTAL_CONNS_DAY,
    1441          PROP_MAX_STREAMS, I2PClient.PROP_SIGTYPE,
    1442         "inbound.randomKey", "outbound.randomKey", "i2cp.leaseSetSigningPrivateKey", "i2cp.leaseSetPrivateKey"
    1443         };
    1444     private static final String _httpServerOpts[] = {
    1445         I2PTunnelHTTPServer.OPT_POST_WINDOW,
    1446         I2PTunnelHTTPServer.OPT_POST_BAN_TIME,
    1447         I2PTunnelHTTPServer.OPT_POST_TOTAL_BAN_TIME,
    1448         I2PTunnelHTTPServer.OPT_POST_MAX,
    1449         I2PTunnelHTTPServer.OPT_POST_TOTAL_MAX
    1450         };
    1451 
    1452     /**
    1453      *  do NOT add these to noShoOpts, we must leave them in for HTTPClient and ConnectCLient
    1454      *  so they will get migrated to MD5
    1455      *  TODO migrate socks to MD5
    1456      */
    1457     private static final String _otherProxyOpts[] = {
    1458         "proxyUsername", "proxyPassword"
    1459         };
    1460 
    1461     protected static final Set<String> _noShowSet = new HashSet<String>(128);
    1462     protected static final Set<String> _nonProxyNoShowSet = new HashSet<String>(4);
    1463     static {
    1464         _noShowSet.addAll(Arrays.asList(_noShowOpts));
    1465         _noShowSet.addAll(Arrays.asList(_booleanClientOpts));
    1466         _noShowSet.addAll(Arrays.asList(_booleanProxyOpts));
    1467         _noShowSet.addAll(Arrays.asList(_booleanServerOpts));
    1468         _noShowSet.addAll(Arrays.asList(_otherClientOpts));
    1469         _noShowSet.addAll(Arrays.asList(_otherServerOpts));
    1470         _noShowSet.addAll(Arrays.asList(_httpServerOpts));
    1471         _nonProxyNoShowSet.addAll(Arrays.asList(_otherProxyOpts));
    1472     }
    1473 
    1474     private void updateConfigGeneric(Properties config) {
    1475         config.setProperty(TunnelController.PROP_TYPE, _type);
    1476         if (_name != null)
    1477             config.setProperty(TunnelController.PROP_NAME, _name);
    1478         if (_description != null)
    1479             config.setProperty(TunnelController.PROP_DESCR, _description);
    1480         if (!_context.isRouterContext()) {
    1481             if (_i2cpHost != null)
    1482                 config.setProperty(TunnelController.PROP_I2CP_HOST, _i2cpHost);
    1483             if ( (_i2cpPort != null) && (_i2cpPort.trim().length() > 0) ) {
    1484                 config.setProperty(TunnelController.PROP_I2CP_PORT, _i2cpPort);
    1485             } else {
    1486                 config.setProperty(TunnelController.PROP_I2CP_PORT, "7654");
    1487             }
    1488         }
    1489         if (_privKeyFile != null)
    1490             config.setProperty(TunnelController.PROP_FILE, _privKeyFile);
    1491        
    1492         if (_customOptions != null) {
    1493             StringTokenizer tok = new StringTokenizer(_customOptions);
    1494             while (tok.hasMoreTokens()) {
    1495                 String pair = tok.nextToken();
    1496                 int eq = pair.indexOf('=');
    1497                 if ( (eq <= 0) || (eq >= pair.length()) )
    1498                     continue;
    1499                 String key = pair.substring(0, eq);
    1500                 if (_noShowSet.contains(key))
    1501                     continue;
    1502                 // leave in for HTTP and Connect so it can get migrated to MD5
    1503                 // hide for SOCKS until migrated to MD5
    1504                 if ((!TunnelController.TYPE_HTTP_CLIENT.equals(_type)) &&
    1505                     (!TunnelController.TYPE_CONNECT.equals(_type)) &&
    1506                     _nonProxyNoShowSet.contains(key))
    1507                     continue;
    1508                 String val = pair.substring(eq+1);
    1509                 config.setProperty(OPT + key, val);
    1510             }
    1511         }
    1512 
    1513         config.setProperty(TunnelController.PROP_START, _startOnLoad + "");
    1514 
    1515         if (_tunnelQuantity != null) {
    1516             config.setProperty("option.inbound.quantity", _tunnelQuantity);
    1517             config.setProperty("option.outbound.quantity", _tunnelQuantity);
    1518         }
    1519         if (_tunnelDepth != null) {
    1520             config.setProperty("option.inbound.length", _tunnelDepth);
    1521             config.setProperty("option.outbound.length", _tunnelDepth);
    1522         }
    1523         if (_tunnelVariance != null) {
    1524             config.setProperty("option.inbound.lengthVariance", _tunnelVariance);
    1525             config.setProperty("option.outbound.lengthVariance", _tunnelVariance);
    1526         }
    1527         if (_tunnelBackupQuantity != null) {
    1528             config.setProperty("option.inbound.backupQuantity", _tunnelBackupQuantity);
    1529             config.setProperty("option.outbound.backupQuantity", _tunnelBackupQuantity);
    1530         }
    1531         if (_connectDelay)
    1532             config.setProperty("option.i2p.streaming.connectDelay", "1000");
    1533         else
    1534             config.setProperty("option.i2p.streaming.connectDelay", "0");
    1535         if (isClient(_type) && _sharedClient) {
    1536             config.setProperty("option.inbound.nickname", CLIENT_NICKNAME);
    1537             config.setProperty("option.outbound.nickname", CLIENT_NICKNAME);
    1538         } else if (_name != null) {
    1539             config.setProperty("option.inbound.nickname", _name);
    1540             config.setProperty("option.outbound.nickname", _name);
    1541         }
    1542         if ("interactive".equals(_profile))
    1543             // This was 1 which doesn't make much sense
    1544             // The real way to make it interactive is to make the streaming lib
    1545             // MessageInputStream flush faster but there's no option for that yet,
    1546             // Setting it to 16 instead of the default but not sure what good that is either.
    1547             config.setProperty("option.i2p.streaming.maxWindowSize", "16");
    1548         else
    1549             config.remove("option.i2p.streaming.maxWindowSize");
     1223        // This is easier than requiring TunnelConfig to talk to
     1224        // TunnelControllerGroup and TunnelController
     1225        _config.setDestination(getDestination(_tunnel));
     1226        return _config.getConfig();
    15501227    }
    15511228
Note: See TracChangeset for help on using the changeset viewer.