Changeset 8c7898de


Ignore:
Timestamp:
Nov 21, 2017 1:29:31 AM (3 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
b2dcf20
Parents:
07a83bf
Message:

Reseed: Add support for reseeding via outproxy or Orchid (ticket #1841)
InternalSocket?: Add support for some methods needed for reseed to work

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • apps/routerconsole/java/src/net/i2p/router/web/ConfigReseedHelper.java

    r07a83bf r8c7898de  
    6868            (mode == 1 && !disabled && c.equals("HTTP")) ||
    6969            (mode == 2 && !disabled && c.equals("SOCKS4")) ||
    70             (mode == 3 && !disabled && c.equals("SOCKS5")))
     70            (mode == 3 && !disabled && c.equals("SOCKS5")) ||
     71            (mode == 4 && !disabled && c.equals("INTERNAL")))
    7172            return CHECKED;
    7273        return "";
  • apps/routerconsole/jsp/configreseed.jsp

    r07a83bf r8c7898de  
    3535</li><li>
    3636<%=intl._t("If you are running command-line Tor, reseed through it by configuring SOCKS 5, localhost, port 9050.")%>
     37</li><li>
     38<%=intl._t("If you have some peers but need more, you may try the I2P Outproxy option. Leave the host and port blank.")%>
     39<%=intl._t("This will not work for an initial reseed when you have no peers at all.")%>
    3740</li><li>
    3841<%=intl._t("Then, click \"{0}\".", intl._t("Save changes and reseed now"))%>
     
    139142
    140143<% if (reseedHelper.shouldShowHTTPSProxy()) { %>
    141 <tr><td align="right"><b><%=intl._t("Reseed Proxy Type")%>:</b></td>
     144<tr><td align="right"><b><%=intl._t("Proxy type for https reseed URLs")%>:</b></td>
    142145<td><label><input type="radio" class="optbox" name="pmode" value="" <%=reseedHelper.pmodeChecked(0) %> >
    143146<%=intl._t("None")%></label><br>
     
    147150<%=intl._t("SOCKS 4/4a")%></label><br>
    148151<label><input type="radio" class="optbox" name="pmode" value="SOCKS5" <%=reseedHelper.pmodeChecked(3) %> >
    149 <%=intl._t("SOCKS 5")%></label></td></tr>
     152<%=intl._t("SOCKS 5")%></label><br>
     153<label><input type="radio" class="optbox" name="pmode" value="INTERNAL" <%=reseedHelper.pmodeChecked(4) %> >
     154<%=intl._t("I2P Outproxy")%></label>
     155(<%=intl._t("Not for initial reseed. Leave host and port blank.")%>)
     156</td></tr>
    150157<tr><td align="right"><b><%=intl._t("HTTPS Proxy Host")%>:</b></td>
    151158<td><input name="shost" type="text" value="<jsp:getProperty name="reseedHelper" property="shost" />" ></td></tr>
     
    164171
    165172<% if (reseedHelper.shouldShowHTTPProxy()) { %>
    166 <tr><td align="right"><label for="enableproxy"><b><%=intl._t("Enable HTTP Proxy?")%></b></label></td>
     173<tr><td align="right"><label for="enableproxy"><b><%=intl._t("Enable proxy for http reseed URLs?")%></b></label></td>
    167174<td><input type="checkbox" class="optbox" name="enable" id="enableproxy" value="true" <jsp:getProperty name="reseedHelper" property="enable" /> ></td></tr>
    168175<tr><td align="right"><b><%=intl._t("HTTP Proxy Host")%>:</b></td>
  • core/java/src/net/i2p/util/InternalSocket.java

    r07a83bf r8c7898de  
    88import java.net.SocketAddress;
    99import java.nio.channels.SocketChannel;
     10
     11import net.i2p.I2PAppContext;
    1012
    1113/**
     
    1820    private InputStream _is;
    1921    private OutputStream _os;
     22    private final int _port;
    2023
    2124    /** server side */
     
    2326        _is = is;
    2427        _os = os;
     28        _port = 1;
    2529    }
    2630
     
    3236         if (port <= 0)
    3337             throw new IOException("bad port number");
     38         _port = port;
    3439         InternalServerSocket.internalConnect(port, this);
    3540    }
     
    4045     */
    4146    public static Socket getSocket(String host, int port) throws IOException {
    42         if (System.getProperty("router.version") != null &&
     47        if (I2PAppContext.getGlobalContext().isRouterContext() &&
    4348            (host.equals("127.0.0.1") || host.equals("localhost"))) {
    4449            try {
     
    104109    }
    105110
    106     // everything below here unsupported
     111    // everything below here unsupported unless otherwise noted
     112
    107113    /** @deprecated unsupported */
    108114    @Deprecated
     
    147153        throw new UnsupportedOperationException();
    148154    }
    149     /** @deprecated unsupported */
    150     @Deprecated
     155
     156    /**
     157     * Supported as of 0.9.33, prior to that threw UnsupportedOperationException
     158     * @return 1 if connected, -1 if not
     159     */
    151160    @Override
    152161    public int getLocalPort() {
    153         throw new UnsupportedOperationException();
    154     }
     162        return isConnected() ? 1 : -1;
     163    }
     164
    155165    /** @deprecated unsupported */
    156166    @Deprecated
     
    165175        throw new UnsupportedOperationException();
    166176    }
    167     /** @deprecated unsupported */
    168     @Deprecated
     177
     178    /**
     179     * Supported as of 0.9.33, prior to that threw UnsupportedOperationException
     180     * @return if connected: actual port for clients, 1 for servers; -1 if not
     181     */
    169182    @Override
    170183    public int getPort() {
    171         throw new UnsupportedOperationException();
     184        return isConnected() ? _port : 0;
    172185    }
    173186    /** @deprecated unsupported */
     
    195208        throw new UnsupportedOperationException();
    196209    }
    197     /** @deprecated unsupported */
    198     @Deprecated
     210
     211    /**
     212     * Supported as of 0.9.33, prior to that threw UnsupportedOperationException
     213     * @return -1 always
     214     */
    199215    @Override
    200216    public int getSoLinger() {
    201         throw new UnsupportedOperationException();
    202     }
     217        return -1;
     218    }
     219
    203220    /** @deprecated unsupported */
    204221    @Deprecated
     
    219236        throw new UnsupportedOperationException();
    220237    }
    221     /** @deprecated unsupported */
    222     @Deprecated
    223     @Override
    224     public boolean isConnected() {
    225         throw new UnsupportedOperationException();
    226     }
     238
     239    /**
     240     * Supported as of 0.9.33, prior to that threw UnsupportedOperationException
     241     */
     242    @Override
     243    public synchronized boolean isConnected() {
     244        return _is != null || _os != null;
     245    }
     246
    227247    /** @deprecated unsupported */
    228248    @Deprecated
  • core/java/src/net/i2p/util/SSLEepGet.java

    r07a83bf r8c7898de  
    148148     *  Use a proxy.
    149149     *
    150      *  @param proxyPort must be valid, -1 disallowed, no default
     150     *  @param proxyHost Must be valid hostname or literal IPv4/v6.
     151     *                   If type is INTERNAL, set to "localhost".
     152     *  @param proxyPort Must be valid, -1 disallowed, no default.
     153     *                   If type is INTERNAL, set to 4444.
    151154     *  @since 0.9.33
    152155     */
     
    159162     *  Use a proxy.
    160163     *
    161      *  @param proxyPort must be valid, -1 disallowed, no default
     164     *  @param proxyHost Must be valid hostname or literal IPv4/v6.
     165     *                   If type is INTERNAL, set to "localhost".
     166     *  @param proxyPort Must be valid, -1 disallowed, no default.
     167     *                   If type is INTERNAL, set to 4444.
    162168     *  @param state an SSLState retrieved from a previous SSLEepGet with getSSLState(), or null.
    163169     *               This makes repeated fetches from the same host MUCH faster,
     
    184190     *  Use a proxy.
    185191     *
    186      *  @param proxyPort must be valid, -1 disallowed, no default
     192     *  @param proxyHost Must be valid hostname or literal IPv4/v6.
     193     *                   If type is INTERNAL, set to "localhost".
     194     *  @param proxyPort Must be valid, -1 disallowed, no default.
     195     *                   If type is INTERNAL, set to 4444.
    187196     *  @since 0.9.33
    188197     */
     
    195204     *  Use a proxy.
    196205     *
    197      *  @param proxyPort must be valid, -1 disallowed, no default
     206     *  @param proxyHost Must be valid hostname or literal IPv4/v6.
     207     *                   If type is INTERNAL, set to "localhost".
     208     *  @param proxyPort Must be valid, -1 disallowed, no default.
     209     *                   If type is INTERNAL, set to 4444.
    198210     *  @param state an SSLState retrieved from a previous SSLEepGet with getSSLState(), or null.
    199211     *               This makes repeated fetches from the same host MUCH faster,
     
    277289                    } else if (y.equals("SOCKS5")) {
    278290                        ptype = ProxyType.SOCKS5;
     291                    } else if (y.equals("I2P")) {
     292                        ptype = ProxyType.INTERNAL;
     293                        proxyHost = "localhost";
     294                        proxyPort = 4444;
    279295                    } else {
    280296                        error = true;
     
    334350    private static void usage() {
    335351        System.err.println("Usage: SSLEepGet [-psyz] https://url\n" +
    336                            "  -p proxyHost[:proxyPort]    // default port 8080 for HTTPS and 1080 for SOCKS\n" +
    337                            "  -y HTTPS|SOCKS4|SOCKS5      // proxy type, default HTTPS if proxyHost is set\n" +
     352                           "  -p proxyHost[:proxyPort]    // default port 8080 for HTTPS and 1080 for SOCKS; default localhost:4444 for I2P\n" +
     353                           "  -y HTTPS|SOCKS4|SOCKS5|I2P  // proxy type, default HTTPS if proxyHost is set\n" +
    338354                           "  -s save unknown certs\n" +
    339355                           "  -s -s save all certs\n" +
     
    699715                        break;
    700716
     717                      case INTERNAL:
     718                        internalHttpProxyConnect(host, port);
     719                        break;
     720
    701721                      case SOCKS4:
    702722                        socksProxyConnect(false, host, port);
     
    708728
    709729                      case HTTPS:
    710                       case INTERNAL:
    711730                      case TRANSPARENT:
    712731                      default:
     
    804823            _proxy = new Socket(_proxyHost, _proxyPort);
    805824        }
     825        httpProxyConnect(_proxy, host, port);
     826    }
     827
     828    /**
     829     *  Connect to a HTTP proxy.
     830     *  Proxy address must be in _proxyHost and _proxyPort.
     831     *  Side effects: Sets _proxy, _proxyIn, _proxyOut,
     832     *  and other globals via readHeaders()
     833     *
     834     *  @param port what the proxy should connect to, probably 4444
     835     *  @since 0.9.33
     836     */
     837    private void internalHttpProxyConnect(String host, int port) throws IOException {
     838        // connect to the proxy
     839        _proxy = InternalSocket.getSocket(_proxyHost, _proxyPort);
     840        httpProxyConnect(_proxy, host, port);
     841    }
     842
     843    /**
     844     *  Connect to a HTTP proxy.
     845     *  Proxy address must be in _proxyHost and _proxyPort.
     846     *  Side effects: Sets _proxyIn, _proxyOut,
     847     *  and other globals via readHeaders()
     848     *
     849     *  @param host what the proxy should connect to
     850     *  @param port what the proxy should connect to
     851     *  @since 0.9.33
     852     */
     853    private void httpProxyConnect(Socket proxy, String host, int port) throws IOException {
    806854        _proxyIn = _proxy.getInputStream();
    807855        _proxyOut = _proxy.getOutputStream();
  • history.txt

    r07a83bf r8c7898de  
     12017-11-21 zzz
     2 * EepGet: Refuse attempted redirect to HTTPS, won't work
     3 * Reseed: Add support for reseeding via outproxy or Orchid (ticket #1841)
     4
     52017-11-20 zzz
     6 * HTTP Proxy: Better HTTP status message when no outproxy configured
     7 * i2prouter: Fix echo -n on OSX
     8 * Reseed: Add outproxy and Orchid proxy support (ticket #1841)
     9
    1102017-11-19 zzz
    211 * Debian:
  • router/java/src/net/i2p/router/RouterVersion.java

    r07a83bf r8c7898de  
    1919    public final static String ID = "Monotone";
    2020    public final static String VERSION = CoreVersion.VERSION;
    21     public final static long BUILD = 5;
     21    public final static long BUILD = 6;
    2222
    2323    /** for example "-test" */
  • router/java/src/net/i2p/router/networkdb/reseed/Reseeder.java

    r07a83bf r8c7898de  
    3333import net.i2p.util.I2PAppThread;
    3434import net.i2p.util.Log;
     35import net.i2p.util.PortMapper;
    3536import net.i2p.util.SecureDirectory;
    3637import net.i2p.util.SecureFileOutputStream;
     
    300301            }
    301302            _shouldProxyHTTP = _proxyHost != null && _proxyHost.length() > 0 && _proxyPort > 0;
    302             if (_context.getBooleanProperty(PROP_SPROXY_ENABLE)) {
    303                 _sproxyHost = _context.getProperty(PROP_SPROXY_HOST);
    304                 _sproxyPort = _context.getProperty(PROP_SPROXY_PORT, -1);
     303
     304            boolean shouldProxySSL = _context.getBooleanProperty(PROP_SPROXY_ENABLE);
     305            SSLEepGet.ProxyType sproxyType;
     306            if (shouldProxySSL) {
     307                sproxyType = getProxyType();
     308                if (sproxyType == SSLEepGet.ProxyType.INTERNAL) {
     309                    _sproxyHost = "localhost";
     310                    _sproxyPort = _context.portMapper().getPort(PortMapper.SVC_HTTP_PROXY, 4444);
     311                } else {
     312                    _sproxyHost = _context.getProperty(PROP_SPROXY_HOST);
     313                    _sproxyPort = _context.getProperty(PROP_SPROXY_PORT, -1);
     314                }
    305315            } else {
     316                sproxyType = SSLEepGet.ProxyType.NONE;
    306317                _sproxyHost = null;
    307318                _sproxyPort = -1;
    308319            }
    309             _shouldProxySSL = _sproxyHost != null && _sproxyHost.length() > 0 && _sproxyPort > 0;
    310             _sproxyType = _shouldProxySSL ? getProxyType() : SSLEepGet.ProxyType.NONE;
     320            _shouldProxySSL = shouldProxySSL && _sproxyHost != null && _sproxyHost.length() > 0 && _sproxyPort > 0;
     321            _sproxyType = _shouldProxySSL ? sproxyType : SSLEepGet.ProxyType.NONE;
    311322        }
    312323
     
    354365            } else {
    355366                if (total == 0) {
    356                     System.out.println("Reseed failed " + getDisplayString(_url) + ", check network connection");
     367                    System.out.println("Reseed failed " + getDisplayString(_url) + "- check network connection");
    357368                    System.out.println("Ensure that nothing blocks outbound HTTP or HTTPS, check the logs, " +
    358369                                       "and if nothing helps, read the FAQ about reseeding manually.");
    359370                    if (_url == null || "https".equals(_url.getScheme())) {
    360371                        if (_sproxyHost != null && _sproxyPort > 0)
    361                             System.out.println("Check HTTPS proxy setting - host: " + _sproxyHost + " port: " + _sproxyPort);
     372                            System.out.println("Check current proxy setting! Type: " + getDisplayString(_sproxyType) +
     373                                               " Host: " + _sproxyHost + " Port: " + _sproxyPort);
    362374                        else
    363                             System.out.println("Consider enabling an HTTPS proxy on the reseed configuration page");
     375                            System.out.println("Consider enabling a proxy for https on the reseed configuration page");
    364376                    } else {
    365377                        if (_proxyHost != null && _proxyPort > 0)
     
    11311143            if (ssl && _shouldProxySSL) {
    11321144                buf.append(" (using ");
    1133                 switch(_sproxyType) {
    1134                   case HTTP:
    1135                     buf.append("HTTPS");
    1136                     break;
    1137                   case SOCKS4:
    1138                     buf.append("SOCKS 4/4a");
    1139                     break;
    1140                   case SOCKS5:
    1141                     buf.append("SOCKS 5");
    1142                     break;
    1143                   default:
    1144                     buf.append(_sproxyType.toString());
    1145                     break;
    1146                 }
     1145                buf.append(getDisplayString(_sproxyType));
    11471146                buf.append(" proxy ");
    11481147                if (_sproxyHost.contains(":"))
     
    11631162            return buf.toString();
    11641163        }
     1164
     1165        /**
     1166         *  Display string for what we're fetching.
     1167         *  Untranslated, for logs only.
     1168         *
     1169         *  @since 0.9.33
     1170         */
     1171        private String getDisplayString(SSLEepGet.ProxyType type) {
     1172            switch(type) {
     1173              case HTTP:
     1174                return "HTTPS";
     1175              case SOCKS4:
     1176                return "SOCKS 4/4a";
     1177              case SOCKS5:
     1178                return "SOCKS 5";
     1179              case INTERNAL:
     1180                return "I2P Outproxy";
     1181              default:
     1182                return type.toString();
     1183            }
     1184        }
    11651185    }
    11661186
Note: See TracChangeset for help on using the changeset viewer.