Changeset 56d7057


Ignore:
Timestamp:
Mar 15, 2015 8:26:36 PM (6 years ago)
Author:
str4d <str4d@…>
Branches:
master
Children:
4fccd25
Parents:
2a9d61b
Message:

Migrate accessors to GeneralHelper?, fix broken outproxyAuth boolean

Location:
apps/i2ptunnel/java/src/net/i2p/i2ptunnel
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/ui/GeneralHelper.java

    r2a9d61b r56d7057  
    55import java.util.ArrayList;
    66import java.util.List;
     7import java.util.Map;
    78import java.util.Properties;
     9import java.util.TreeMap;
    810
    911import net.i2p.I2PAppContext;
     12import net.i2p.client.I2PClient;
     13import net.i2p.crypto.SigType;
     14import net.i2p.data.DataHelper;
     15import net.i2p.data.Destination;
     16import net.i2p.data.PrivateKeyFile;
    1017import net.i2p.i2ptunnel.I2PTunnelClientBase;
     18import net.i2p.i2ptunnel.I2PTunnelHTTPClient;
     19import net.i2p.i2ptunnel.I2PTunnelHTTPClientBase;
     20import net.i2p.i2ptunnel.I2PTunnelHTTPServer;
     21import net.i2p.i2ptunnel.I2PTunnelIRCClient;
     22import net.i2p.i2ptunnel.I2PTunnelServer;
    1123import net.i2p.i2ptunnel.SSLClientUtil;
    1224import net.i2p.i2ptunnel.TunnelController;
     
    2335 */
    2436public class GeneralHelper {
     37    public static final int RUNNING = 1;
     38    public static final int STARTING = 2;
     39    public static final int NOT_RUNNING = 3;
     40    public static final int STANDBY = 4;
     41
     42    protected static final String PROP_ENABLE_ACCESS_LIST = "i2cp.enableAccessList";
     43    protected static final String PROP_ENABLE_BLACKLIST = "i2cp.enableBlackList";
     44
    2545    private static final String OPT = TunnelController.PFX_OPTION;
    2646
     47    private I2PAppContext _context;
     48    protected TunnelControllerGroup _group;
     49
     50    public GeneralHelper(TunnelControllerGroup tcg) {
     51        this(I2PAppContext.getGlobalContext(), tcg);
     52    }
     53
     54    public GeneralHelper(I2PAppContext context, TunnelControllerGroup tcg) {
     55        _context = context;
     56        _group = tcg;
     57    }
     58
     59    public TunnelController getController(int tunnel) {
     60        return getController(_group, tunnel);
     61    }
    2762    public static TunnelController getController(TunnelControllerGroup tcg, int tunnel) {
    2863        if (tunnel < 0) return null;
     
    3570    }
    3671
     72    public List<String> saveTunnel(int tunnel, TunnelConfig config) {
     73        return saveTunnel(_context, _group, tunnel, config);
     74    }
    3775    public static List<String> saveTunnel(
    3876            I2PAppContext context, TunnelControllerGroup tcg, int tunnel, TunnelConfig config) {
     
    118156    }
    119157
     158    public List<String> deleteTunnel(int tunnel, String privKeyFile) {
     159        return deleteTunnel(_context, _group, tunnel, privKeyFile);
     160    }
    120161    /**
    121      *  Stop the tunnel, delete from config,
    122      *  rename the private key file if in the default directory
     162     * Stop the tunnel, delete from config,
     163     * rename the private key file if in the default directory
     164     *
     165     * @param privKeyFile The priv key file name from the tunnel edit form. Can
     166     *                    be null if not known.
    123167     */
    124168    public static List<String> deleteTunnel(
    125             I2PAppContext context, TunnelControllerGroup tcg,int tunnel, TunnelConfig config) {
     169            I2PAppContext context, TunnelControllerGroup tcg, int tunnel, String privKeyFile) {
    126170        List<String> msgs;
    127171        TunnelController cur = getController(tcg, tunnel);
    128172        if (cur == null) {
    129             msgs = new ArrayList<>();
     173            msgs = new ArrayList<String>();
    130174            msgs.add("Invalid tunnel number");
    131175            return msgs;
     
    141185        String pk = cur.getPrivKeyFile();
    142186        if (pk == null)
    143             pk = config.getPrivKeyFile();
     187            pk = privKeyFile;
    144188        if (pk != null && pk.startsWith("i2ptunnel") && pk.endsWith("-privKeys.dat") &&
    145189            ((!TunnelController.isClient(cur.getType())) || cur.getPersistentClientKey())) {
     
    172216    }
    173217
     218    //
     219    // Accessors
     220    //
     221
     222    public String getTunnelType(int tunnel) {
     223        TunnelController tun = getController(tunnel);
     224        return (tun != null && tun.getType() != null) ? tun.getType() : "";
     225    }
     226
     227    public String getTunnelName(int tunnel) {
     228        return getTunnelName(_group, tunnel);
     229    }
    174230    public static String getTunnelName(TunnelControllerGroup tcg, int tunnel) {
    175231        TunnelController tun = getController(tcg, tunnel);
    176         if (tun != null)
    177             return tun.getName();
     232        return tun != null ? tun.getName() : null;
     233    }
     234
     235    public String getTunnelDescription(int tunnel) {
     236        TunnelController tun = getController(tunnel);
     237        return (tun != null && tun.getDescription() != null) ? tun.getDescription() : "";
     238    }
     239
     240    public String getTargetHost(int tunnel) {
     241        TunnelController tun = getController(tunnel);
     242        return (tun != null && tun.getTargetHost() != null) ? tun.getTargetHost() : "127.0.0.1";
     243    }
     244
     245    /**
     246     * @param tunnel
     247     * @return -1 if unset or invalid
     248     */
     249    public int getTargetPort(int tunnel) {
     250        TunnelController tun = getController(tunnel);
     251        if (tun != null && tun.getTargetPort() != null) {
     252            try {
     253                return Integer.parseInt(tun.getTargetPort());
     254            } catch (NumberFormatException e) {
     255                return -1;
     256            }
     257        } else
     258            return -1;
     259    }
     260
     261    public String getSpoofedHost(int tunnel) {
     262        TunnelController tun = getController(tunnel);
     263        return (tun != null && tun.getSpoofedHost() != null) ? tun.getSpoofedHost() :"";
     264    }
     265
     266    public String getPrivateKeyFile(int tunnel) {
     267        return getPrivateKeyFile(_group, tunnel);
     268    }
     269    public static String getPrivateKeyFile(TunnelControllerGroup tcg, int tunnel) {
     270        TunnelController tun = getController(tcg, tunnel);
     271        if (tun != null && tun.getPrivKeyFile() != null)
     272            return tun.getPrivKeyFile();
     273        if (tunnel < 0)
     274            tunnel = tcg == null ? 999 : tcg.getControllers().size();
     275        return "i2ptunnel" + tunnel + "-privKeys.dat";
     276    }
     277
     278    public String getClientInterface(int tunnel) {
     279        TunnelController tun = getController(tunnel);
     280        if (tun != null) {
     281            if ("streamrclient".equals(tun.getType()))
     282                return tun.getTargetHost();
     283            else
     284                return tun.getListenOnInterface();
     285        } else
     286            return "127.0.0.1";
     287    }
     288
     289    public int getTunnelStatus(int tunnel) {
     290        TunnelController tun = getController(tunnel);
     291        if (tun == null) return NOT_RUNNING;
     292        if (tun.getIsRunning()) {
     293            if (tun.isClient() && tun.getIsStandby())
     294                return STANDBY;
     295            else
     296                return RUNNING;
     297        } else if (tun.getIsStarting()) return STARTING;
     298        else return NOT_RUNNING;
     299    }
     300
     301    public String getClientDestination(int tunnel) {
     302        TunnelController tun = getController(tunnel);
     303        if (tun == null) return "";
     304        String rv;
     305        if (TunnelController.TYPE_STD_CLIENT.equals(tun.getType()) ||
     306            TunnelController.TYPE_IRC_CLIENT.equals(tun.getType()) ||
     307            TunnelController.TYPE_STREAMR_CLIENT.equals(tun.getType()))
     308            rv = tun.getTargetDestination();
    178309        else
    179             return null;
     310            rv = tun.getProxyList();
     311        return rv != null ? rv : "";
     312    }
     313
     314    /**
     315     *  Works even if tunnel is not running.
     316     *  @return Destination or null
     317     */
     318    public Destination getDestination(int tunnel) {
     319        TunnelController tun = getController(tunnel);
     320        if (tun != null) {
     321            Destination rv = tun.getDestination();
     322            if (rv != null)
     323                return rv;
     324            // if not running, do this the hard way
     325            File keyFile = tun.getPrivateKeyFile();
     326            if (keyFile != null) {
     327                PrivateKeyFile pkf = new PrivateKeyFile(keyFile);
     328                try {
     329                    rv = pkf.getDestination();
     330                    if (rv != null)
     331                        return rv;
     332                } catch (Exception e) {}
     333            }
     334        }
     335        return null;
     336    }
     337
     338    public boolean shouldStartAutomatically(int tunnel) {
     339        TunnelController tun = getController(tunnel);
     340        return tun != null ? tun.getStartOnLoad() : false;
     341    }
     342
     343    public boolean isSharedClient(int tunnel) {
     344        TunnelController tun = getController(tunnel);
     345        return tun != null ? Boolean.parseBoolean(tun.getSharedClient()) : false;
     346    }
     347
     348    public boolean shouldDelayConnect(int tunnel) {
     349        return getProperty(tunnel, "i2p.streaming.connectDelay", 0) > 0;
     350    }
     351
     352    public boolean isInteractive(int tunnel) {
     353        return getProperty(tunnel, "i2p.streaming.maxWindowSize", 128) == 16;
     354    }
     355
     356    public int getTunnelDepth(int tunnel, int defaultLength) {
     357        return getProperty(tunnel, "inbound.length", defaultLength);
     358    }
     359
     360    public int getTunnelQuantity(int tunnel, int defaultQuantity) {
     361        return getProperty(tunnel, "inbound.quantity", defaultQuantity);
     362    }
     363
     364    public int getTunnelBackupQuantity(int tunnel, int defaultBackupQuantity) {
     365        return getProperty(tunnel, "inbound.backupQuantity", defaultBackupQuantity);
     366    }
     367
     368    public int getTunnelVariance(int tunnel, int defaultVariance) {
     369        return getProperty(tunnel, "inbound.lengthVariance", defaultVariance);
     370    }
     371
     372    public boolean getReduceOnIdle(int tunnel, boolean def) {
     373        return getBooleanProperty(tunnel, "i2cp.reduceOnIdle", def);
     374    }
     375
     376    public int getReduceCount(int tunnel, int def) {
     377        return getProperty(tunnel, "i2cp.reduceQuantity", def);
     378    }
     379
     380    /**
     381     * @param tunnel
     382     * @param def in minutes
     383     * @return time in minutes
     384     */
     385    public int getReduceTime(int tunnel, int def) {
     386        return getProperty(tunnel, "i2cp.reduceIdleTime", def*60*1000) / (60*1000);
     387    }
     388
     389    public int getCert(int tunnel) {
     390        return 0;
     391    }
     392
     393    public int getEffort(int tunnel) {
     394        return 23;
     395    }
     396
     397    public String getSigner(int tunnel) {
     398        return "";
     399    }
     400
     401    public boolean getEncrypt(int tunnel) {
     402        return getBooleanProperty(tunnel, "i2cp.encryptLeaseSet");
     403    }
     404
     405    /**
     406     *  @param newTunnelType used if tunnel < 0
     407     */
     408    public int getSigType(int tunnel, String newTunnelType) {
     409        SigType type;
     410        String ttype;
     411        boolean isShared;
     412        if (tunnel >= 0) {
     413            Destination d = getDestination(tunnel);
     414            if (d != null) {
     415                type = d.getSigType();
     416                if (type != null)
     417                    return type.getCode();
     418            }
     419            String stype = getProperty(tunnel, I2PClient.PROP_SIGTYPE, null);
     420            type = stype != null ? SigType.parseSigType(stype) : null;
     421            ttype = getTunnelType(tunnel);
     422            isShared = isSharedClient(tunnel);
     423        } else {
     424            type = null;
     425            ttype = newTunnelType;
     426            isShared = false;
     427        }
     428        if (type == null) {
     429            // same default logic as in TunnelController.setConfig()
     430            if ((!TunnelController.isClient(ttype) ||
     431                ((TunnelController.TYPE_IRC_CLIENT.equals(ttype) ||
     432                  TunnelController.TYPE_SOCKS_IRC.equals(ttype) ||
     433                  TunnelController.TYPE_STREAMR_CLIENT.equals(ttype) ||
     434                  TunnelController.TYPE_STD_CLIENT.equals(ttype)) &&
     435                 !isShared)))
     436                type = TunnelController.PREFERRED_SIGTYPE;
     437            else
     438                type = SigType.DSA_SHA1;
     439        }
     440        return type.getCode();
     441    }
     442
     443    /**
     444     *  Random keys
     445     */
     446    public String getInboundRandomKey(int tunnel) {
     447        return getProperty(tunnel, "inbound.randomKey", "");
     448    }
     449
     450    public String getOutboundRandomKey(int tunnel) {
     451        return getProperty(tunnel, "outbound.randomKey", "");
     452    }
     453
     454    public String getLeaseSetSigningPrivateKey(int tunnel) {
     455        return getProperty(tunnel, "i2cp.leaseSetSigningPrivateKey", "");
     456    }
     457
     458    public String getLeaseSetPrivateKey(int tunnel) {
     459        return getProperty(tunnel, "i2cp.leaseSetPrivateKey", "");
     460    }
     461
     462    public boolean getDCC(int tunnel) {
     463        return getBooleanProperty(tunnel, I2PTunnelIRCClient.PROP_DCC);
     464    }
     465
     466    public String getEncryptKey(int tunnel) {
     467        return getProperty(tunnel, "i2cp.leaseSetKey", "");
     468    }
     469
     470    public int getAccessMode(int tunnel) {
     471        if (getBooleanProperty(tunnel, PROP_ENABLE_ACCESS_LIST))
     472            return 1;
     473        if (getBooleanProperty(tunnel, PROP_ENABLE_BLACKLIST))
     474            return 2;
     475        return 0;
     476    }
     477   
     478    public String getAccessList(int tunnel) {
     479        return getProperty(tunnel, "i2cp.accessList", "").replace(",", "\n");
     480    }
     481   
     482    public String getJumpList(int tunnel) {
     483        return getProperty(tunnel, I2PTunnelHTTPClient.PROP_JUMP_SERVERS,
     484                           I2PTunnelHTTPClient.DEFAULT_JUMP_SERVERS).replace(",", "\n");
     485    }
     486   
     487    public boolean getCloseOnIdle(int tunnel, boolean def) {
     488        return getBooleanProperty(tunnel, "i2cp.closeOnIdle", def);
     489    }
     490
     491    public int getCloseTime(int tunnel, int def) {
     492        return getProperty(tunnel, "i2cp.closeIdleTime", def*60*1000) / (60*1000);
     493    }
     494
     495    public boolean getNewDest(int tunnel) {
     496        return getBooleanProperty(tunnel, "i2cp.newDestOnResume") &&
     497               getBooleanProperty(tunnel, "i2cp.closeOnIdle") &&
     498               !getBooleanProperty(tunnel, "persistentClientKey");
     499    }
     500
     501    public boolean getPersistentClientKey(int tunnel) {
     502        return getBooleanProperty(tunnel, "persistentClientKey");
     503    }
     504
     505    public boolean getDelayOpen(int tunnel) {
     506        return getBooleanProperty(tunnel, "i2cp.delayOpen");
     507    }
     508
     509    public boolean getAllowUserAgent(int tunnel) {
     510        return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_USER_AGENT);
     511    }
     512
     513    public boolean getAllowReferer(int tunnel) {
     514        return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_REFERER);
     515    }
     516
     517    public boolean getAllowAccept(int tunnel) {
     518        return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_ACCEPT);
     519    }
     520
     521    public boolean getAllowInternalSSL(int tunnel) {
     522        return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_INTERNAL_SSL);
     523    }
     524
     525    public boolean getMultihome(int tunnel) {
     526        return getBooleanProperty(tunnel, "shouldBundleReplyInfo");
     527    }
     528
     529    public String getProxyAuth(int tunnel) {
     530        return getProperty(tunnel, I2PTunnelHTTPClientBase.PROP_AUTH, "false");
     531    }
     532   
     533    public boolean getOutproxyAuth(int tunnel) {
     534        return getBooleanProperty(tunnel, I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH);
     535    }
     536   
     537    public String getOutproxyUsername(int tunnel) {
     538        return getProperty(tunnel, I2PTunnelHTTPClientBase.PROP_OUTPROXY_USER, "");
     539    }
     540   
     541    public String getOutproxyPassword(int tunnel) {
     542        if (getOutproxyUsername(tunnel).length() <= 0)
     543            return "";
     544        return getProperty(tunnel, I2PTunnelHTTPClientBase.PROP_OUTPROXY_PW, "");
     545    }
     546
     547    public String getSslProxies(int tunnel) {
     548        return getProperty(tunnel, I2PTunnelHTTPClient.PROP_SSL_OUTPROXIES, "");
     549    }
     550
     551    /**
     552     *  Default true
     553     */
     554    public boolean getUseOutproxyPlugin(int tunnel) {
     555        return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_USE_OUTPROXY_PLUGIN, true);
     556    }
     557
     558    /** all of these are @since 0.8.3 */
     559    public int getLimitMinute(int tunnel) {
     560        return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_MIN, 0);
     561    }
     562
     563    public int getLimitHour(int tunnel) {
     564        return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_HOUR, 0);
     565    }
     566
     567    public int getLimitDay(int tunnel) {
     568        return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_DAY, 0);
     569    }
     570
     571    public int getTotalMinute(int tunnel) {
     572        return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_MIN, 0);
     573    }
     574
     575    public int getTotalHour(int tunnel) {
     576        return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_HOUR, 0);
     577    }
     578
     579    public int getTotalDay(int tunnel) {
     580        return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_DAY, 0);
     581    }
     582
     583    public int getMaxStreams(int tunnel) {
     584        return getProperty(tunnel, TunnelConfig.PROP_MAX_STREAMS, 0);
     585    }
     586
     587    /**
     588     * POST limits
     589     * @since 0.9.9
     590     */
     591    public int getPostMax(int tunnel) {
     592        return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_MAX, 0);
     593    }
     594
     595    public int getPostTotalMax(int tunnel) {
     596        return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_TOTAL_MAX, 0);
     597    }
     598
     599    public int getPostCheckTime(int tunnel) {
     600        return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_WINDOW, I2PTunnelHTTPServer.DEFAULT_POST_WINDOW) / 60;
     601    }
     602
     603    public int getPostBanTime(int tunnel) {
     604        return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_BAN_TIME, I2PTunnelHTTPServer.DEFAULT_POST_BAN_TIME) / 60;
     605    }
     606
     607    public int getPostTotalBanTime(int tunnel) {
     608        return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_TOTAL_BAN_TIME, I2PTunnelHTTPServer.DEFAULT_POST_TOTAL_BAN_TIME) / 60;
     609    }
     610
     611    public boolean getUniqueLocal(int tunnel) {
     612        return getBooleanProperty(tunnel, I2PTunnelServer.PROP_UNIQUE_LOCAL);
     613    }
     614
     615    public String getCustomOptionsString(int tunnel) {
     616        TunnelController tun = getController(tunnel);
     617        if (tun != null) {
     618            Properties opts = tun.getClientOptionProps();
     619            if (opts == null) return "";
     620            boolean isMD5Proxy = TunnelController.TYPE_HTTP_CLIENT.equals(tun.getType()) ||
     621                                 TunnelController.TYPE_CONNECT.equals(tun.getType());
     622            Map<String, String> sorted = new TreeMap<String, String>();
     623            for (Map.Entry<Object, Object> e : opts.entrySet()) {
     624                String key = (String)e.getKey();
     625                if (TunnelConfig._noShowSet.contains(key))
     626                    continue;
     627                // leave in for HTTP and Connect so it can get migrated to MD5
     628                // hide for SOCKS until migrated to MD5
     629                if ((!isMD5Proxy) &&
     630                    TunnelConfig._nonProxyNoShowSet.contains(key))
     631                    continue;
     632                sorted.put(key, (String)e.getValue());
     633            }
     634            if (sorted.isEmpty())
     635                return "";
     636            StringBuilder buf = new StringBuilder(64);
     637            boolean space = false;
     638            for (Map.Entry<String, String> e : sorted.entrySet()) {
     639                if (space)
     640                    buf.append(' ');
     641                else
     642                    space = true;
     643                buf.append(e.getKey()).append('=').append(e.getValue());
     644            }
     645            return DataHelper.escapeHTML(buf.toString());
     646        } else {
     647            return "";
     648        }
     649    }
     650
     651    //
     652    // Internal helpers
     653    //
     654
     655    private int getProperty(int tunnel, String prop, int def) {
     656        TunnelController tun = getController(tunnel);
     657        if (tun != null) {
     658            Properties opts = tun.getClientOptionProps();
     659            if (opts != null) {
     660                String s = opts.getProperty(prop);
     661                if (s == null) return def;
     662                try {
     663                    return Integer.parseInt(s);
     664                } catch (NumberFormatException nfe) {}
     665            }
     666        }
     667        return def;
     668    }
     669
     670    private String getProperty(int tunnel, String prop, String def) {
     671        TunnelController tun = getController(tunnel);
     672        if (tun != null) {
     673            Properties opts = tun.getClientOptionProps();
     674            if (opts != null) {
     675                String rv = opts.getProperty(prop);
     676                if (rv != null)
     677                    return DataHelper.escapeHTML(rv);
     678            }
     679        }
     680        return def;
     681    }
     682
     683    /** default is false */
     684    private boolean getBooleanProperty(int tunnel, String prop) {
     685        return getBooleanProperty(tunnel, prop, false);
     686    }
     687    private boolean getBooleanProperty(int tunnel, String prop, boolean def) {
     688        TunnelController tun = getController(tunnel);
     689        if (tun != null) {
     690            Properties opts = tun.getClientOptionProps();
     691            if (opts != null)
     692                return Boolean.parseBoolean(opts.getProperty(prop));
     693        }
     694        return def;
    180695    }
    181696
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/ui/TunnelConfig.java

    r2a9d61b r56d7057  
    258258     * Controls how ephemeral the I2P Destination of a client tunnel is.
    259259     * <p/>
    260      * If {@link #setClose(boolean)} is set to true then mode 1 == mode 0.
     260     * If {@link #setClose(boolean)} is set to false then mode 1 == mode 0.
    261261     *
    262262     * @param mode 0 for new dest on restart, 1 for new dest on resume from idle, 2 for persistent key
     
    350350            _newProxyUser = s.trim();
    351351    }
    352    
     352
    353353    public void setProxyPassword(String s) {
    354354        if (s != null)
    355355            _newProxyPW = s.trim();
    356356    }
    357    
    358     /**
    359      * Sets the authentication type required for configured outproxies. The
    360      * same authentication type is assumed for all configured outproxies.
    361      * Supported authentication types: "basic", "digest".
     357
     358    /**
     359     * Sets whether authentication is required for any of the configured
     360     * outproxies.
    362361     *
    363      * @param authType the authentication type, or "false" for no authentication
    364      */
    365     public void setOutproxyAuth(String authType) {
    366         if (authType != null)
    367             _otherOptions.put(I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH, authType.trim());
    368     }
    369    
     362     * @param val true if authentication is required, false otherwise
     363     */
     364    public void setOutproxyAuth(boolean val) {
     365        if (val)
     366            _booleanOptions.add(I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH);
     367        else
     368            _booleanOptions.remove(I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH);
     369    }
     370
    370371    public void setOutproxyUsername(String s) {
    371372        if (s != null)
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/web/EditBean.java

    r2a9d61b r56d7057  
    1010
    1111import java.util.List;
    12 import java.util.Map;
    13 import java.util.Properties;
    1412import java.util.Set;
    15 import java.util.TreeMap;
    16 
    17 import net.i2p.client.I2PClient;
    1813import net.i2p.crypto.SigType;
    1914import net.i2p.data.Base64;
     
    2318import net.i2p.data.Signature;
    2419import net.i2p.data.SigningPrivateKey;
    25 import net.i2p.i2ptunnel.I2PTunnelHTTPClient;
    26 import net.i2p.i2ptunnel.I2PTunnelHTTPClientBase;
    27 import net.i2p.i2ptunnel.I2PTunnelHTTPServer;
    28 import net.i2p.i2ptunnel.I2PTunnelIRCClient;
    29 import net.i2p.i2ptunnel.I2PTunnelServer;
    3020import net.i2p.i2ptunnel.TunnelController;
    3121import net.i2p.i2ptunnel.TunnelControllerGroup;
    32 import net.i2p.i2ptunnel.ui.TunnelConfig;
    3322import net.i2p.util.Addresses;
    3423
     
    6352   
    6453    public String getTargetHost(int tunnel) {
    65         TunnelController tun = getController(tunnel);
    66         if (tun != null && tun.getTargetHost() != null)
    67             return DataHelper.escapeHTML(tun.getTargetHost());
    68         else
    69             return "127.0.0.1";
     54        return DataHelper.escapeHTML(_helper.getTargetHost(tunnel));
    7055    }
    7156
    7257    public String getTargetPort(int tunnel) {
    73         TunnelController tun = getController(tunnel);
    74         if (tun != null && tun.getTargetPort() != null)
    75             return DataHelper.escapeHTML(tun.getTargetPort());
    76         else
    77             return "";
     58        int port = _helper.getTargetPort(tunnel);
     59        return port > 0 ? "" + port : "";
    7860    }
    7961
     
    8769
    8870    public String getPrivateKeyFile(int tunnel) {
    89         TunnelController tun = getController(tunnel);
    90         if (tun != null && tun.getPrivKeyFile() != null)
    91             return tun.getPrivKeyFile();
    92         if (tunnel < 0)
    93             tunnel = _group == null ? 999 : _group.getControllers().size();
    94         return "i2ptunnel" + tunnel + "-privKeys.dat";
     71        return _helper.getPrivateKeyFile(tunnel);
    9572    }
    9673   
     
    137114   
    138115    public boolean shouldDelay(int tunnel) {
    139         return getProperty(tunnel, "i2p.streaming.connectDelay", 0) > 0;
     116        return _helper.shouldDelayConnect(tunnel);
    140117    }
    141118   
    142119    public boolean isInteractive(int tunnel) {
    143         return getProperty(tunnel, "i2p.streaming.maxWindowSize", 128) == 16;
     120        return _helper.isInteractive(tunnel);
    144121    }
    145122   
    146123    public int getTunnelDepth(int tunnel, int defaultLength) {
    147         return getProperty(tunnel, "inbound.length", defaultLength);
     124        return _helper.getTunnelDepth(tunnel, defaultLength);
    148125    }
    149126   
    150127    public int getTunnelQuantity(int tunnel, int defaultQuantity) {
    151         return getProperty(tunnel, "inbound.quantity", defaultQuantity);
     128        return _helper.getTunnelQuantity(tunnel, defaultQuantity);
    152129    }
    153130   
    154131    public int getTunnelBackupQuantity(int tunnel, int defaultBackupQuantity) {
    155         return getProperty(tunnel, "inbound.backupQuantity", defaultBackupQuantity);
     132        return _helper.getTunnelBackupQuantity(tunnel, defaultBackupQuantity);
    156133    }
    157134 
    158135    public int getTunnelVariance(int tunnel, int defaultVariance) {
    159         return getProperty(tunnel, "inbound.lengthVariance", defaultVariance);
     136        return _helper.getTunnelVariance(tunnel, defaultVariance);
    160137    }
    161138   
    162139    public boolean getReduce(int tunnel) {
    163         return getBooleanProperty(tunnel, "i2cp.reduceOnIdle");
     140        return _helper.getReduceOnIdle(tunnel, false);
    164141    }
    165142   
    166143    public int getReduceCount(int tunnel) {
    167         return getProperty(tunnel, "i2cp.reduceQuantity", 1);
     144        return _helper.getReduceCount(tunnel, 1);
    168145    }
    169146   
    170147    public int getReduceTime(int tunnel) {
    171         return getProperty(tunnel, "i2cp.reduceIdleTime", 20*60*1000) / (60*1000);
     148        return _helper.getReduceTime(tunnel, 20);
    172149    }
    173150   
    174151    public int getCert(int tunnel) {
    175         return 0;
     152        return _helper.getCert(tunnel);
    176153    }
    177154   
    178155    public int getEffort(int tunnel) {
    179         return 23;
     156        return _helper.getEffort(tunnel);
    180157    }
    181158   
    182159    public String getSigner(int tunnel) {
    183         return "";
     160        return _helper.getSigner(tunnel);
    184161    }
    185162   
    186163    public boolean getEncrypt(int tunnel) {
    187         return getBooleanProperty(tunnel, "i2cp.encryptLeaseSet");
     164        return _helper.getEncrypt(tunnel);
    188165    }
    189166   
     
    193170     */
    194171    public int getSigType(int tunnel, String newTunnelType) {
    195         SigType type;
    196         String ttype;
    197         boolean isShared;
    198         if (tunnel >= 0) {
    199             Destination d = getDestination(tunnel);
    200             if (d != null) {
    201                 type = d.getSigType();
    202                 if (type != null)
    203                     return type.getCode();
    204             }
    205             String stype = getProperty(tunnel, I2PClient.PROP_SIGTYPE, null);
    206             type = stype != null ? SigType.parseSigType(stype) : null;
    207             ttype = getTunnelType(tunnel);
    208             isShared = isSharedClient(tunnel);
    209         } else {
    210             type = null;
    211             ttype = newTunnelType;
    212             isShared = false;
    213         }
    214         if (type == null) {
    215             // same default logic as in TunnelController.setConfig()
    216             if ((!TunnelController.isClient(ttype) ||
    217                 ((TunnelController.TYPE_IRC_CLIENT.equals(ttype) ||
    218                   TunnelController.TYPE_SOCKS_IRC.equals(ttype) ||
    219                   TunnelController.TYPE_STREAMR_CLIENT.equals(ttype) ||
    220                   TunnelController.TYPE_STD_CLIENT.equals(ttype)) &&
    221                  !isShared)))
    222                 type = TunnelController.PREFERRED_SIGTYPE;
    223             else
    224                 type = SigType.DSA_SHA1;
    225         }
    226         return type.getCode();
     172        return _helper.getSigType(tunnel, newTunnelType);
    227173    }
    228174   
     
    237183     */
    238184    public String getKey1(int tunnel) {
    239         return getProperty(tunnel, "inbound.randomKey", "");
     185        return _helper.getInboundRandomKey(tunnel);
    240186    }
    241187
    242188    public String getKey2(int tunnel) {
    243         return getProperty(tunnel, "outbound.randomKey", "");
     189        return _helper.getOutboundRandomKey(tunnel);
    244190    }
    245191
    246192    public String getKey3(int tunnel) {
    247         return getProperty(tunnel, "i2cp.leaseSetSigningPrivateKey", "");
     193        return _helper.getLeaseSetSigningPrivateKey(tunnel);
    248194    }
    249195
    250196    public String getKey4(int tunnel) {
    251         return getProperty(tunnel, "i2cp.leaseSetPrivateKey", "");
     197        return _helper.getLeaseSetPrivateKey(tunnel);
    252198    }
    253199
    254200    /** @since 0.8.9 */
    255201    public boolean getDCC(int tunnel) {
    256         return getBooleanProperty(tunnel, I2PTunnelIRCClient.PROP_DCC);
     202        return _helper.getDCC(tunnel);
    257203    }
    258204
    259205    public String getEncryptKey(int tunnel) {
    260         return getProperty(tunnel, "i2cp.leaseSetKey", "");
     206        return _helper.getEncryptKey(tunnel);
    261207    }
    262208   
    263209    public String getAccessMode(int tunnel) {
    264         if (getBooleanProperty(tunnel, PROP_ENABLE_ACCESS_LIST))
    265             return "1";
    266         if (getBooleanProperty(tunnel, PROP_ENABLE_BLACKLIST))
    267             return "2";
    268         return "0";
     210        return Integer.toString(_helper.getAccessMode(tunnel));
    269211    }
    270212   
    271213    public String getAccessList(int tunnel) {
    272         return getProperty(tunnel, "i2cp.accessList", "").replace(",", "\n");
     214        return _helper.getAccessList(tunnel);
    273215    }
    274216   
    275217    public String getJumpList(int tunnel) {
    276         return getProperty(tunnel, I2PTunnelHTTPClient.PROP_JUMP_SERVERS,
    277                            I2PTunnelHTTPClient.DEFAULT_JUMP_SERVERS).replace(",", "\n");
     218        return _helper.getJumpList(tunnel);
    278219    }
    279220   
    280221    public boolean getClose(int tunnel) {
    281         return getBooleanProperty(tunnel, "i2cp.closeOnIdle");
     222        return _helper.getCloseOnIdle(tunnel, false);
    282223    }
    283224   
    284225    public int getCloseTime(int tunnel) {
    285         return getProperty(tunnel, "i2cp.closeIdleTime", 30*60*1000) / (60*1000);
     226        return _helper.getCloseTime(tunnel, 30);
    286227    }
    287228   
    288229    public boolean getNewDest(int tunnel) {
    289         return getBooleanProperty(tunnel, "i2cp.newDestOnResume") &&
    290                getBooleanProperty(tunnel, "i2cp.closeOnIdle") &&
    291                !getBooleanProperty(tunnel, "persistentClientKey");
     230        return _helper.getNewDest(tunnel);
    292231    }
    293232   
    294233    public boolean getPersistentClientKey(int tunnel) {
    295         return getBooleanProperty(tunnel, "persistentClientKey");
     234        return _helper.getPersistentClientKey(tunnel);
    296235    }
    297236   
    298237    public boolean getDelayOpen(int tunnel) {
    299         return getBooleanProperty(tunnel, "i2cp.delayOpen");
     238        return _helper.getDelayOpen(tunnel);
    300239    }
    301240
    302241    /** @since 0.9.14 */
    303242    public boolean getAllowUserAgent(int tunnel) {
    304         return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_USER_AGENT);
     243        return _helper.getAllowUserAgent(tunnel);
    305244    }
    306245
    307246    /** @since 0.9.14 */
    308247    public boolean getAllowReferer(int tunnel) {
    309         return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_REFERER);
     248        return _helper.getAllowReferer(tunnel);
    310249    }
    311250
    312251    /** @since 0.9.14 */
    313252    public boolean getAllowAccept(int tunnel) {
    314         return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_ACCEPT);
     253        return _helper.getAllowAccept(tunnel);
    315254    }
    316255
    317256    /** @since 0.9.14 */
    318257    public boolean getAllowInternalSSL(int tunnel) {
    319         return getBooleanProperty(tunnel, I2PTunnelHTTPClient.PROP_INTERNAL_SSL);
     258        return _helper.getAllowInternalSSL(tunnel);
    320259    }
    321260
    322261    /** @since 0.9.18 */
    323262    public boolean getMultihome(int tunnel) {
    324         return getBooleanProperty(tunnel, "shouldBundleReplyInfo");
     263        return _helper.getMultihome(tunnel);
    325264    }
    326265
    327266    /** all proxy auth @since 0.8.2 */
    328267    public boolean getProxyAuth(int tunnel) {
    329         return getProperty(tunnel, I2PTunnelHTTPClientBase.PROP_AUTH, "false") != "false";
    330     }
    331    
     268        return _helper.getProxyAuth(tunnel) != "false";
     269    }
     270    // TODO think
    332271    public boolean getOutproxyAuth(int tunnel) {
    333         return getBooleanProperty(tunnel, I2PTunnelHTTPClientBase.PROP_OUTPROXY_AUTH) &&
     272        return _helper.getOutproxyAuth(tunnel) &&
    334273               getOutproxyUsername(tunnel).length() > 0 &&
    335274               getOutproxyPassword(tunnel).length() > 0;
     
    337276   
    338277    public String getOutproxyUsername(int tunnel) {
    339         return getProperty(tunnel, I2PTunnelHTTPClientBase.PROP_OUTPROXY_USER, "");
     278        return _helper.getOutproxyUsername(tunnel);
    340279    }
    341280   
    342281    public String getOutproxyPassword(int tunnel) {
    343         if (getOutproxyUsername(tunnel).length() <= 0)
    344             return "";
    345         return getProperty(tunnel, I2PTunnelHTTPClientBase.PROP_OUTPROXY_PW, "");
     282        return _helper.getOutproxyPassword(tunnel);
    346283    }
    347284
    348285    /** @since 0.9.11 */
    349286    public String getSslProxies(int tunnel) {
    350         return getProperty(tunnel, I2PTunnelHTTPClient.PROP_SSL_OUTPROXIES, "");
     287        return _helper.getSslProxies(tunnel);
    351288    }
    352289   
     
    356293     */
    357294    public boolean getUseOutproxyPlugin(int tunnel) {
    358         return Boolean.parseBoolean(getProperty(tunnel, I2PTunnelHTTPClient.PROP_USE_OUTPROXY_PLUGIN, "true"));
     295        return _helper.getUseOutproxyPlugin(tunnel);
    359296    }
    360297
    361298    /** all of these are @since 0.8.3 */
    362299    public int getLimitMinute(int tunnel) {
    363         return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_MIN, 0);
     300        return _helper.getLimitMinute(tunnel);
    364301    }
    365302
    366303    public int getLimitHour(int tunnel) {
    367         return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_HOUR, 0);
     304        return _helper.getLimitHour(tunnel);
    368305    }
    369306
    370307    public int getLimitDay(int tunnel) {
    371         return getProperty(tunnel, TunnelConfig.PROP_MAX_CONNS_DAY, 0);
     308        return _helper.getLimitDay(tunnel);
    372309    }
    373310
    374311    public int getTotalMinute(int tunnel) {
    375         return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_MIN, 0);
     312        return _helper.getTotalMinute(tunnel);
    376313    }
    377314
    378315    public int getTotalHour(int tunnel) {
    379         return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_HOUR, 0);
     316        return _helper.getTotalHour(tunnel);
    380317    }
    381318
    382319    public int getTotalDay(int tunnel) {
    383         return getProperty(tunnel, TunnelConfig.PROP_MAX_TOTAL_CONNS_DAY, 0);
     320        return _helper.getTotalDay(tunnel);
    384321    }
    385322
    386323    public int getMaxStreams(int tunnel) {
    387         return getProperty(tunnel, TunnelConfig.PROP_MAX_STREAMS, 0);
     324        return _helper.getMaxStreams(tunnel);
    388325    }
    389326
     
    393330     */
    394331    public int getPostMax(int tunnel) {
    395         return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_MAX, 0);
     332        return _helper.getPostMax(tunnel);
    396333    }
    397334
    398335    public int getPostTotalMax(int tunnel) {
    399         return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_TOTAL_MAX, 0);
     336        return _helper.getPostTotalMax(tunnel);
    400337    }
    401338
    402339    public int getPostCheckTime(int tunnel) {
    403         return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_WINDOW, I2PTunnelHTTPServer.DEFAULT_POST_WINDOW) / 60;
     340        return _helper.getPostCheckTime(tunnel);
    404341    }
    405342
    406343    public int getPostBanTime(int tunnel) {
    407         return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_BAN_TIME, I2PTunnelHTTPServer.DEFAULT_POST_BAN_TIME) / 60;
     344        return _helper.getPostBanTime(tunnel);
    408345    }
    409346
    410347    public int getPostTotalBanTime(int tunnel) {
    411         return getProperty(tunnel, I2PTunnelHTTPServer.OPT_POST_TOTAL_BAN_TIME, I2PTunnelHTTPServer.DEFAULT_POST_TOTAL_BAN_TIME) / 60;
     348        return _helper.getPostTotalBanTime(tunnel);
    412349    }
    413350   
    414351    /** @since 0.9.13 */
    415352    public boolean getUniqueLocal(int tunnel) {
    416         return getBooleanProperty(tunnel, I2PTunnelServer.PROP_UNIQUE_LOCAL);
    417     }
    418 
    419     private int getProperty(int tunnel, String prop, int def) {
    420         TunnelController tun = getController(tunnel);
    421         if (tun != null) {
    422             Properties opts = getOptions(tun);
    423             if (opts != null) {
    424                 String s = opts.getProperty(prop);
    425                 if (s == null) return def;
    426                 try {
    427                     return Integer.parseInt(s);
    428                 } catch (NumberFormatException nfe) {}
    429             }
    430         }
    431         return def;
    432     }
    433    
    434     private String getProperty(int tunnel, String prop, String def) {
    435         TunnelController tun = getController(tunnel);
    436         if (tun != null) {
    437             Properties opts = getOptions(tun);
    438             if (opts != null) {
    439                 String rv = opts.getProperty(prop);
    440                 if (rv != null)
    441                     return DataHelper.escapeHTML(rv);
    442             }
    443         }
    444         return def;
    445     }
    446    
    447     /** default is false */
    448     private boolean getBooleanProperty(int tunnel, String prop) {
    449         TunnelController tun = getController(tunnel);
    450         if (tun != null) {
    451             Properties opts = getOptions(tun);
    452             if (opts != null)
    453                 return Boolean.parseBoolean(opts.getProperty(prop));
    454         }
    455         return false;
     353        return _helper.getUniqueLocal(tunnel);
    456354    }
    457355   
     
    492390
    493391    public String getCustomOptions(int tunnel) {
    494         TunnelController tun = getController(tunnel);
    495         if (tun != null) {
    496             Properties opts = getOptions(tun);
    497             if (opts == null) return "";
    498             boolean isMD5Proxy = TunnelController.TYPE_HTTP_CLIENT.equals(tun.getType()) ||
    499                                  TunnelController.TYPE_CONNECT.equals(tun.getType());
    500             Map<String, String> sorted = new TreeMap<String, String>();
    501             for (Map.Entry<Object, Object> e : opts.entrySet()) {
    502                 String key = (String)e.getKey();
    503                 if (TunnelConfig._noShowSet.contains(key))
    504                     continue;
    505                 // leave in for HTTP and Connect so it can get migrated to MD5
    506                 // hide for SOCKS until migrated to MD5
    507                 if ((!isMD5Proxy) &&
    508                     TunnelConfig._nonProxyNoShowSet.contains(key))
    509                     continue;
    510                 sorted.put(key, (String)e.getValue());
    511             }
    512             if (sorted.isEmpty())
    513                 return "";
    514             StringBuilder buf = new StringBuilder(64);
    515             boolean space = false;
    516             for (Map.Entry<String, String> e : sorted.entrySet()) {
    517                 if (space)
    518                     buf.append(' ');
    519                 else
    520                     space = true;
    521                 buf.append(e.getKey()).append('=').append(e.getValue());
    522             }
    523             return DataHelper.escapeHTML(buf.toString());
    524         } else {
    525             return "";
    526         }
    527     }
    528 
    529     /**
    530      * Retrieve the client options from the tunnel
    531      *
    532      * @return map of name=val to be used as I2P session options
    533      */
    534     private static Properties getOptions(TunnelController controller) {
    535         if (controller == null) return null;
    536         return controller.getClientOptionProps();
     392        return _helper.getCustomOptionsString(tunnel);
    537393    }
    538394
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/web/IndexBean.java

    r2a9d61b r56d7057  
    4545    protected final Log _log;
    4646    protected final TunnelControllerGroup _group;
     47    protected final GeneralHelper _helper;
    4748    private final String _fatalError;
    4849    private String _action;
     
    5960    private String _certSigner;
    6061   
    61     public static final int RUNNING = 1;
    62     public static final int STARTING = 2;
    63     public static final int NOT_RUNNING = 3;
    64     public static final int STANDBY = 4;
     62    public static final int RUNNING = GeneralHelper.RUNNING;
     63    public static final int STARTING = GeneralHelper.STARTING;
     64    public static final int NOT_RUNNING = GeneralHelper.NOT_RUNNING;
     65    public static final int STANDBY = GeneralHelper.STANDBY;
    6566   
    6667    //static final String PROP_NONCE = IndexBean.class.getName() + ".nonce";
     
    9192        }
    9293        _group = tcg;
     94        _helper = new GeneralHelper(_context, _group);
    9395        _fatalError = error;
    9496        _tunnel = -1;
     
    237239    private String saveChanges() {
    238240        // FIXME name will be HTML escaped twice
    239         return getMessages(GeneralHelper.saveTunnel(_context, _group, _tunnel, _config));
     241        return getMessages(_helper.saveTunnel(_tunnel, _config));
    240242    }
    241243
     
    248250            return "Please confirm removal";
    249251
    250         return getMessages(GeneralHelper.deleteTunnel(_context, _group, _tunnel, _config));
     252        return getMessages(_helper.deleteTunnel(_tunnel, _config.getPrivKeyFile()));
    251253    }
    252254   
     
    317319   
    318320    public String getTunnelName(int tunnel) {
    319         String name = GeneralHelper.getTunnelName(_group, tunnel);
     321        String name = _helper.getTunnelName(tunnel);
    320322        if (name != null)
    321323            return DataHelper.escapeHTML(name);
     
    392394   
    393395    public String getInternalType(int tunnel) {
    394         TunnelController tun = getController(tunnel);
    395         if (tun != null)
    396             return tun.getType();
    397         else
    398             return "";
     396        return _helper.getTunnelType(tunnel);
    399397    }
    400398   
    401399    public String getClientInterface(int tunnel) {
    402         TunnelController tun = getController(tunnel);
    403         if (tun != null) {
    404             if ("streamrclient".equals(tun.getType()))
    405                 return tun.getTargetHost();
    406             else
    407                 return tun.getListenOnInterface();
    408         } else
    409             return "127.0.0.1";
     400        return _helper.getClientInterface(tunnel);
    410401    }
    411402   
    412403    public int getTunnelStatus(int tunnel) {
    413         TunnelController tun = getController(tunnel);
    414         if (tun == null) return NOT_RUNNING;
    415         if (tun.getIsRunning()) {
    416             if (isClient(tunnel) && tun.getIsStandby())
    417                 return STANDBY;
    418             else
    419                 return RUNNING;
    420         } else if (tun.getIsStarting()) return STARTING;
    421         else return NOT_RUNNING;
     404        return _helper.getTunnelStatus(tunnel);
    422405    }
    423406   
    424407    public String getTunnelDescription(int tunnel) {
    425         TunnelController tun = getController(tunnel);
    426         if (tun != null && tun.getDescription() != null)
    427             return DataHelper.escapeHTML(tun.getDescription());
    428         else
    429             return "";
     408        return DataHelper.escapeHTML(_helper.getTunnelDescription(tunnel));
    430409    }
    431410   
     
    439418   
    440419    public String getClientDestination(int tunnel) {
    441         TunnelController tun = getController(tunnel);
    442         if (tun == null) return "";
    443         String rv;
    444         if (TunnelController.TYPE_STD_CLIENT.equals(tun.getType()) ||
    445             TunnelController.TYPE_IRC_CLIENT.equals(tun.getType()) ||
    446             TunnelController.TYPE_STREAMR_CLIENT.equals(tun.getType()))
    447             rv = tun.getTargetDestination();
    448         else
    449             rv = tun.getProxyList();
    450         return rv != null ? rv : "";
     420        return _helper.getClientDestination(tunnel);
    451421    }
    452422   
     
    496466     */
    497467    protected Destination getDestination(int tunnel) {
    498         TunnelController tun = getController(tunnel);
    499         if (tun != null) {
    500             Destination rv = tun.getDestination();
    501             if (rv != null)
    502                 return rv;
    503             // if not running, do this the hard way
    504             File keyFile = tun.getPrivateKeyFile();
    505             if (keyFile != null) {
    506                 PrivateKeyFile pkf = new PrivateKeyFile(keyFile);
    507                 try {
    508                     rv = pkf.getDestination();
    509                     if (rv != null)
    510                         return rv;
    511                 } catch (Exception e) {}
    512             }
    513         }
    514         return null;
     468        return _helper.getDestination(tunnel);
    515469    }
    516470   
     
    742696    }
    743697
    744     protected static final String PROP_ENABLE_ACCESS_LIST = "i2cp.enableAccessList";
    745     protected static final String PROP_ENABLE_BLACKLIST = "i2cp.enableBlackList";
    746 
    747698    public void setAccessMode(String val) {
    748699        if (val != null) {
     
    837788   
    838789    public void setOutproxyAuth(String s) {
    839         _config.setOutproxyAuth(I2PTunnelHTTPClientBase.DIGEST_AUTH);
     790        _config.setOutproxyAuth(true);
    840791    }
    841792   
     
    11211072   
    11221073    protected TunnelController getController(int tunnel) {
    1123         return GeneralHelper.getController(_group, tunnel);
     1074        return _helper.getController(tunnel);
    11241075    }
    11251076   
Note: See TracChangeset for help on using the changeset viewer.