Changeset 8e77188


Ignore:
Timestamp:
Nov 7, 2015 10:38:05 PM (5 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
a3b55cc
Parents:
1e5a35c7
Message:

Replace URL with URI where possible
URL bad for anon and has traps like equals()

Files:
12 edited

Legend:

Unmodified
Added
Removed
  • apps/i2psnark/java/src/org/klomp/snark/I2PSnarkUtil.java

    r1e5a35c7 r8e77188  
    44import java.io.File;
    55import java.io.IOException;
    6 import java.net.MalformedURLException;
    7 import java.net.URL;
     6import java.net.URI;
     7import java.net.URISyntaxException;
    88import java.util.Collections;
    99import java.util.HashMap;
     
    591591    public boolean isKnownOpenTracker(String url) {
    592592        try {
    593            URL u = new URL(url);
     593           URI u = new URI(url);
    594594           String host = u.getHost();
    595595           return host != null && SnarkManager.KNOWN_OPENTRACKERS.contains(host);
    596         } catch (MalformedURLException mue) {
     596        } catch (URISyntaxException use) {
    597597           return false;
    598598        }
  • apps/i2psnark/java/src/org/klomp/snark/TrackerClient.java

    r1e5a35c7 r8e77188  
    2424import java.io.IOException;
    2525import java.io.InputStream;
    26 import java.net.MalformedURLException;
    27 import java.net.URL;
     26import java.net.URI;
     27import java.net.URISyntaxException;
    2828import java.util.ArrayList;
    2929import java.util.Collection;
     
    881881   */
    882882  public static boolean isValidAnnounce(String ann) {
    883     URL url;
     883    URI url;
    884884    try {
    885        url = new URL(ann);
    886     } catch (MalformedURLException mue) {
     885       url = new URI(ann);
     886    } catch (URISyntaxException use) {
    887887       return false;
    888888    }
    889     return url.getProtocol().equals("http") &&
     889    return "http".equals(url.getScheme()) && url.getHost() != null &&
    890890           (url.getHost().endsWith(".i2p") || url.getHost().equals("i2p"));
    891891  }
     
    897897   */
    898898  private static Hash getHostHash(String ann) {
    899     URL url;
     899    URI url;
    900900    try {
    901         url = new URL(ann);
    902     } catch (MalformedURLException mue) {
     901        url = new URI(ann);
     902    } catch (URISyntaxException use) {
    903903        return null;
    904904    }
    905     if (!url.getProtocol().equals("http"))
     905    if (!"http".equals(url.getScheme()))
    906906        return null;
    907907    String host = url.getHost();
  • apps/ministreaming/java/src/net/i2p/client/streaming/I2PSocketEepGet.java

    r1e5a35c7 r8e77188  
    66import java.net.MalformedURLException;
    77import java.net.UnknownHostException;
    8 import java.net.URL;
     8import java.net.URI;
     9import java.net.URISyntaxException;
    910import java.util.Locale;
    1011import java.util.Properties;
     
    113114
    114115        try {
    115             URL url = new URL(_actualURL);
    116             if ("http".equals(url.getProtocol())) {
     116            URI url = new URI(_actualURL);
     117            if ("http".equals(url.getScheme())) {
    117118                String host = url.getHost();
    118119                int port = url.getPort();
     
    124125                // as the naming service accepts B64KEY (but not B64KEY.i2p atm)
    125126                if ("i2p".equals(host)) {
    126                     String file = url.getFile();
     127                    String file = url.getPath();
    127128                    try {
    128129                        int slash = 1 + file.substring(1).indexOf("/");
     
    130131                        _actualURL = "http://" + host + file.substring(slash);
    131132                    } catch (IndexOutOfBoundsException ioobe) {
    132                         throw new IOException("Bad /i2p/ format: " + _actualURL);
     133                        throw new MalformedURLException("Bad /i2p/ format: " + _actualURL);
    133134                    }
    134135                }
     
    174175                _socket = _socketManager.connect(dest, opts);
    175176            } else {
    176                 throw new IOException("Unsupported protocol: " + _actualURL);
     177                throw new MalformedURLException("Unsupported protocol: " + _actualURL);
    177178            }
    178         } catch (MalformedURLException mue) {
    179             throw new IOException("Request URL is invalid: " + _actualURL);
     179        } catch (URISyntaxException use) {
     180            IOException ioe = new MalformedURLException("Bad URL");
     181            ioe.initCause(use);
     182            throw ioe;
    180183        } catch (I2PException ie) {
    181             throw new IOException(ie.toString());
     184            throw new IOException("I2P error", ie);
    182185        }
    183186
     
    203206    protected String getRequest() throws IOException {
    204207        StringBuilder buf = new StringBuilder(2048);
    205         URL url = new URL(_actualURL);
     208        URI url;
     209        try {
     210            url = new URI(_actualURL);
     211        } catch (URISyntaxException use) {
     212            IOException ioe = new MalformedURLException("Bad URL");
     213            ioe.initCause(use);
     214            throw ioe;
     215        }
    206216        //String host = url.getHost();
    207217        String path = url.getPath();
  • apps/routerconsole/java/src/net/i2p/router/web/ConfigReseedHandler.java

    r1e5a35c7 r8e77188  
    33import java.io.InputStream;
    44import java.io.IOException;
    5 import java.net.URL;
    6 import java.net.MalformedURLException;
     5import java.net.URI;
     6import java.net.URISyntaxException;
    77import java.util.ArrayList;
    88import java.util.HashMap;
     
    3838                return;
    3939            }
    40             URL url;
     40            URI url;
    4141            try {
    42                 url = new URL(val);
    43             } catch (MalformedURLException mue) {
     42                url = new URI(val);
     43            } catch (URISyntaxException mue) {
    4444                addFormError(_t("Bad URL {0}", val));
    4545                return;
  • apps/systray/java/src/net/i2p/apps/systray/UrlLauncher.java

    r1e5a35c7 r8e77188  
    1919import java.net.Socket;
    2020import java.net.SocketAddress;
    21 import java.net.URL;
     21import java.net.URI;
     22import java.net.URISyntaxException;
    2223import java.util.Locale;
    2324
     
    116117     */
    117118    private static boolean waitForServer(String urlString) {
    118         URL url;
     119        URI url;
    119120        try {
    120             url = new URL(urlString);
    121         } catch (MalformedURLException e) {
     121            url = new URI(urlString);
     122        } catch (URISyntaxException e) {
    122123            return false;
    123124        }
     
    125126        int port = url.getPort();
    126127        if (port <= 0) {
    127             port = url.getDefaultPort();
    128             if (port <= 0)
    129                 return false;
     128            port = "https".equals(url.getScheme()) ? 443 : 80;
    130129        }
    131130        SocketAddress sa;
     
    262261         try {
    263262            // just to check validity
    264             new URL(urlString);
    265         } catch (MalformedURLException e) {
     263            new URI(urlString);
     264        } catch (URISyntaxException e) {
    266265            return false;
    267266        }
  • core/java/src/net/i2p/util/EepGet.java

    r1e5a35c7 r8e77188  
    1616import java.net.Socket;
    1717import java.net.UnknownHostException;
    18 import java.net.URL;
     18import java.net.URI;
     19import java.net.URISyntaxException;
    1920import java.text.DecimalFormat;
    2021import java.util.ArrayList;
     
    322323     */
    323324    public static String suggestName(String url) {
    324         URL nameURL = null;  // URL object
     325        URI nameURL = null;
    325326        String name;         // suggested name
    326327
    327328        try {
    328             nameURL = new URL(url);
    329         } catch (MalformedURLException e) {
     329            nameURL = new URI(url);
     330        } catch (URISyntaxException e) {
    330331            System.err.println("Please enter a properly formed URL.");
    331332            System.exit(1);
     
    723724        if (_redirectLocation != null) {
    724725            // we also are here after a 407
    725             //try {
     726            try {
    726727                if (_redirectLocation.startsWith("http://")) {
    727728                    _actualURL = _redirectLocation;
     
    730731                    // RFC 1945 (HTTP/1.0 1996), so it isn't clear what the point of this is.
    731732                    // This oddly adds a ":" even if no port, but that seems to work.
    732                     URL url = new URL(_actualURL);
     733                    URI url = new URI(_actualURL);
    733734                    if (_redirectLocation.startsWith("/"))
    734735                        _actualURL = "http://" + url.getHost() + ":" + url.getPort() + _redirectLocation;
     
    737738                        _actualURL = "http://" + url.getHost() + ":" + url.getPort() + "/" + _redirectLocation;
    738739                }
    739             // an MUE is an IOE
    740             //} catch (MalformedURLException mue) {
    741             //    throw new IOException("Redirected from an invalid URL");
    742             //}
     740            } catch (URISyntaxException use) {
     741                IOException ioe = new MalformedURLException("Redirected to invalid URL");
     742                ioe.initCause(use);
     743                throw ioe;
     744            }
    743745
    744746            AuthState as = _authState;
     
    12271229            _proxy = InternalSocket.getSocket(_proxyHost, _proxyPort);
    12281230        } else {
    1229             //try {
    1230                 URL url = new URL(_actualURL);
    1231                 if ("http".equals(url.getProtocol())) {
     1231            try {
     1232                URI url = new URI(_actualURL);
     1233                if ("http".equals(url.getScheme())) {
    12321234                    String host = url.getHost();
    12331235                    String hostlc = host.toLowerCase(Locale.US);
     
    12491251                    throw new MalformedURLException("URL is not supported:" + _actualURL);
    12501252                }
    1251             // an MUE is an IOE
    1252             //} catch (MalformedURLException mue) {
    1253             //    throw new IOException("Request URL is invalid");
    1254             //}
     1253            } catch (URISyntaxException use) {
     1254                IOException ioe = new MalformedURLException("Request URL is invalid");
     1255                ioe.initCause(use);
     1256                throw ioe;
     1257            }
    12551258        }
    12561259        _proxyIn = _proxy.getInputStream();
     
    12741277        if ( (_postData != null) && (_postData.length() > 0) )
    12751278            post = true;
    1276         URL url = new URL(_actualURL);
     1279        URI url;
     1280        try {
     1281            url = new URI(_actualURL);
     1282        } catch (URISyntaxException use) {
     1283            IOException ioe = new MalformedURLException("Bad URL");
     1284            ioe.initCause(use);
     1285            throw ioe;
     1286        }
    12771287        String host = url.getHost();
    12781288        if (host == null || host.length() <= 0)
  • core/java/src/net/i2p/util/EepHead.java

    r1e5a35c7 r8e77188  
    77import java.io.InputStreamReader;
    88import java.io.OutputStream;
    9 import java.net.URL;
     9import java.net.MalformedURLException;
     10import java.net.URI;
     11import java.net.URISyntaxException;
    1012
    1113import gnu.getopt.Getopt;
     
    177179        // Should we even follow redirects for HEAD?
    178180        if (_redirectLocation != null) {
    179             //try {
     181            try {
    180182                if (_redirectLocation.startsWith("http://")) {
    181183                    _actualURL = _redirectLocation;
     
    184186                    // RFC 1945 (HTTP/1.0 1996), so it isn't clear what the point of this is.
    185187                    // This oddly adds a ":" even if no port, but that seems to work.
    186                     URL url = new URL(_actualURL);
     188                    URI url = new URI(_actualURL);
    187189                    if (_redirectLocation.startsWith("/"))
    188190                        _actualURL = "http://" + url.getHost() + ":" + url.getPort() + _redirectLocation;
     
    191193                        _actualURL = "http://" + url.getHost() + ":" + url.getPort() + "/" + _redirectLocation;
    192194                }
    193             // an MUE is an IOE
    194             //} catch (MalformedURLException mue) {
    195             //    throw new IOException("Redirected from an invalid URL");
    196             //}
     195            } catch (URISyntaxException use) {
     196                IOException ioe = new MalformedURLException("Redirected to invalid URL");
     197                ioe.initCause(use);
     198                throw ioe;
     199            }
    197200            AuthState as = _authState;
    198201            if (_responseCode == 407) {
     
    253256    protected String getRequest() throws IOException {
    254257        StringBuilder buf = new StringBuilder(512);
    255         URL url = new URL(_actualURL);
     258        URI url;
     259        try {
     260            url = new URI(_actualURL);
     261        } catch (URISyntaxException use) {
     262            IOException ioe = new MalformedURLException("Bad URL");
     263            ioe.initCause(use);
     264            throw ioe;
     265        }
    256266        String host = url.getHost();
    257267        int port = url.getPort();
  • core/java/src/net/i2p/util/PartialEepGet.java

    r1e5a35c7 r8e77188  
    77import java.io.OutputStream;
    88import java.net.MalformedURLException;
    9 import java.net.URL;
     9import java.net.URI;
     10import java.net.URISyntaxException;
    1011import java.util.Locale;
    1112
     
    168169    protected String getRequest() throws IOException {
    169170        StringBuilder buf = new StringBuilder(2048);
    170         URL url = new URL(_actualURL);
     171        URI url;
     172        try {
     173            url = new URI(_actualURL);
     174        } catch (URISyntaxException use) {
     175            IOException ioe = new MalformedURLException("Bad URL");
     176            ioe.initCause(use);
     177            throw ioe;
     178        }
    171179        String host = url.getHost();
    172180        if (host == null || host.length() <= 0)
  • core/java/src/net/i2p/util/SSLEepGet.java

    r1e5a35c7 r8e77188  
    4747import java.net.InetSocketAddress;
    4848import java.net.MalformedURLException;
    49 import java.net.URL;
     49import java.net.URI;
     50import java.net.URISyntaxException;
    5051import java.security.KeyStore;
    5152import java.security.GeneralSecurityException;
     
    554555        String req = getRequest();
    555556
    556         //try {
    557             URL url = new URL(_actualURL);
    558             String host = null;
    559             int port = 0;
    560             if ("https".equals(url.getProtocol())) {
     557        String host;
     558        int port;
     559        try {
     560            URI url = new URI(_actualURL);
     561            if ("https".equals(url.getScheme())) {
    561562                host = url.getHost();
    562563                if (host.toLowerCase(Locale.US).endsWith(".i2p"))
     
    590591                throw new MalformedURLException("Only https supported: " + _actualURL);
    591592            }
    592         // an MUE is an IOE
    593         //} catch (MalformedURLException mue) {
    594         //    throw new IOException("Request URL is invalid");
    595         //}
     593        } catch (URISyntaxException use) {
     594            IOException ioe = new MalformedURLException("Redirected to invalid URL");
     595            ioe.initCause(use);
     596            throw ioe;
     597        }
    596598
    597599        _proxyIn = _proxy.getInputStream();
  • router/java/src/net/i2p/router/networkdb/reseed/ReseedChecker.java

    r1e5a35c7 r8e77188  
    44import java.io.InputStream;
    55import java.io.IOException;
    6 import java.net.URL;
     6import java.net.URI;
    77import java.util.concurrent.atomic.AtomicBoolean;
    88
     
    132132     *  @since 0.9.19
    133133     */
    134     public boolean requestReseed(URL url) throws IllegalArgumentException {
     134    public boolean requestReseed(URI url) throws IllegalArgumentException {
    135135        if (_inProgress.compareAndSet(false, true)) {
    136136            Reseeder reseeder = new Reseeder(_context, this);
  • router/java/src/net/i2p/router/networkdb/reseed/Reseeder.java

    r1e5a35c7 r8e77188  
    88import java.io.IOException;
    99import java.io.OutputStream;
    10 import java.net.MalformedURLException;
    1110import java.net.URI;
    1211import java.net.URISyntaxException;
    13 import java.net.URL;
    1412import java.util.Arrays;
    1513import java.util.ArrayList;
     
    154152     *  @since 0.9.19
    155153     */
    156     void requestReseed(URL url) throws IllegalArgumentException {
     154    void requestReseed(URI url) throws IllegalArgumentException {
    157155        ReseedRunner reseedRunner = new ReseedRunner(url);
    158156        // set to daemon so it doesn't hang a shutdown
     
    240238        private final List<Long> _bandwidths;
    241239        private static final int MAX_DATE_SETS = 2;
    242         private final URL _url;
     240        private final URI _url;
    243241
    244242        /**
     
    257255         *  @since 0.9.19
    258256         */
    259         public ReseedRunner(URL url) throws IllegalArgumentException {
     257        public ReseedRunner(URI url) throws IllegalArgumentException {
    260258            String lc = url.getPath().toLowerCase(Locale.US);
    261259            if (!(lc.endsWith(".zip") || lc.endsWith(".su3")))
     
    413411        */
    414412        private int reseed(boolean echoStatus) {
    415             List<URL> URLList = new ArrayList<URL>();
     413            List<URI> URLList = new ArrayList<URI>();
    416414            String URLs = _context.getProperty(PROP_RESEED_URL);
    417415            boolean defaulted = URLs == null;
     
    430428                        u = u + '/';
    431429                    try {
    432                         URLList.add(new URL(u));
    433                     } catch (MalformedURLException mue) {}
     430                        URLList.add(new URI(u));
     431                    } catch (URISyntaxException mue) {}
    434432                }
    435433                Collections.shuffle(URLList, _context.random());
    436434                if (!SSLDisable && !SSLRequired) {
    437435                    // put the non-SSL at the end of the SSL
    438                     List<URL> URLList2 = new ArrayList<URL>();
     436                    List<URI> URLList2 = new ArrayList<URI>();
    439437                    tok = new StringTokenizer(DEFAULT_SEED_URL, " ,");
    440438                    while (tok.hasMoreTokens()) {
     
    443441                            u = u + '/';
    444442                        try {
    445                             URLList2.add(new URL(u));
    446                         } catch (MalformedURLException mue) {}
     443                            URLList2.add(new URI(u));
     444                        } catch (URISyntaxException mue) {}
    447445                    }
    448446                    Collections.shuffle(URLList2, _context.random());
     
    451449            } else {
    452450                // custom list given
    453                 List<URL> SSLList = new ArrayList<URL>();
    454                 List<URL> nonSSLList = new ArrayList<URL>();
     451                List<URI> SSLList = new ArrayList<URI>();
     452                List<URI> nonSSLList = new ArrayList<URI>();
    455453                StringTokenizer tok = new StringTokenizer(URLs, " ,");
    456454                while (tok.hasMoreTokens()) {
     
    462460                    if (u.startsWith("https")) {
    463461                        try {
    464                             SSLList.add(new URL(u));
    465                         } catch (MalformedURLException mue) {}
     462                            SSLList.add(new URI(u));
     463                        } catch (URISyntaxException mue) {}
    466464                    } else {
    467465                        try {
    468                             nonSSLList.add(new URL(u));
    469                         } catch (MalformedURLException mue) {}
     466                            nonSSLList.add(new URI(u));
     467                        } catch (URISyntaxException mue) {}
    470468                    }
    471469                }
     
    483481            if (!isSNISupported()) {
    484482                try {
    485                     URLList.remove(new URL("https://netdb.i2p2.no/"));
    486                 } catch (MalformedURLException mue) {}
     483                    URLList.remove(new URI("https://netdb.i2p2.no/"));
     484                } catch (URISyntaxException mue) {}
    487485            }
    488486            if (URLList.isEmpty()) {
     
    502500        * @return count of routerinfos successfully fetched
    503501        */
    504         private int reseed(List<URL> URLList, boolean echoStatus) {
     502        private int reseed(List<URI> URLList, boolean echoStatus) {
    505503            int total = 0;
    506504            for (int i = 0; i < URLList.size() && _isRunning; i++) {
     
    509507                    return total;
    510508                }
    511                 URL url = URLList.get(i);
     509                URI url = URLList.get(i);
    512510                int dl = 0;
    513511                if (ENABLE_SU3) {
    514512                    try {
    515                         dl = reseedSU3(new URL(url.toString() + SU3_FILENAME), echoStatus);
    516                     } catch (MalformedURLException mue) {}
     513                        dl = reseedSU3(new URI(url.toString() + SU3_FILENAME), echoStatus);
     514                    } catch (URISyntaxException mue) {}
    517515                }
    518516                if (ENABLE_NON_SU3) {
     
    558556         * @return count of routerinfos successfully fetched
    559557         **/
    560         private int reseedOne(URL seedURL, boolean echoStatus) {
     558        private int reseedOne(URI seedURL, boolean echoStatus) {
    561559            try {
    562560                // Don't use context clock as we may be adjusting the time
     
    660658         *  @since 0.9.14
    661659         **/
    662         public int reseedSU3(URL seedURL, boolean echoStatus) {
     660        public int reseedSU3(URI seedURL, boolean echoStatus) {
    663661            return reseedSU3OrZip(seedURL, true, echoStatus);
    664662        }
     
    674672         *  @since 0.9.19
    675673         **/
    676         public int reseedZip(URL seedURL, boolean echoStatus) {
     674        public int reseedZip(URI seedURL, boolean echoStatus) {
    677675            return reseedSU3OrZip(seedURL, false, echoStatus);
    678676        }
     
    688686         *  @since 0.9.19
    689687         **/
    690         private int reseedSU3OrZip(URL seedURL, boolean isSU3, boolean echoStatus) {
     688        private int reseedSU3OrZip(URI seedURL, boolean isSU3, boolean echoStatus) {
    691689            int fetched = 0;
    692690            int errors = 0;
     
    870868                return false;
    871869
    872             URL url = new URL(seedURL + (seedURL.endsWith("/") ? "" : "/") + ROUTERINFO_PREFIX + peer + ROUTERINFO_SUFFIX);
     870            URI url = new URI(seedURL + (seedURL.endsWith("/") ? "" : "/") + ROUTERINFO_PREFIX + peer + ROUTERINFO_SUFFIX);
    873871
    874872            byte data[] = readURL(url);
     
    879877
    880878        /** @return null on error */
    881         private byte[] readURL(URL url) throws IOException {
     879        private byte[] readURL(URI url) throws IOException {
    882880            ByteArrayOutputStream baos = new ByteArrayOutputStream(4*1024);
    883881            EepGet get;
     
    924922         *  @since 0.9.14
    925923         */
    926         private File fetchURL(URL url) throws IOException {
     924        private File fetchURL(URI url) throws IOException {
    927925            File out = new File(_context.getTempDir(), "reseed-" + _context.random().nextInt() + ".tmp");
    928926            EepGet get;
  • router/java/src/net/i2p/router/transport/UPnP.java

    r1e5a35c7 r8e77188  
    55
    66import java.net.InetAddress;
    7 import java.net.MalformedURLException;
    87import java.net.UnknownHostException;
    9 import java.net.URL;
     8import java.net.URI;
     9import java.net.URISyntaxException;
    1010import java.util.Collections;
    1111import java.util.HashMap;
     
    824824                if (him != null && him.length() > 0) {
    825825                        try {
    826                                 URL url = new URL(him);
     826                                URI url = new URI(him);
    827827                                hisIP = url.getHost();
    828                         } catch (MalformedURLException mue) {}
     828                        } catch (URISyntaxException use) {}
    829829                }
    830830                if (hisIP == null) {
     
    832832                        if (him != null && him.length() > 0) {
    833833                                try {
    834                                         URL url = new URL(him);
     834                                        URI url = new URI(him);
    835835                                        hisIP = url.getHost();
    836                                 } catch (MalformedURLException mue) {}
     836                                } catch (URISyntaxException use) {}
    837837                        }
    838838                }
Note: See TracChangeset for help on using the changeset viewer.