home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / main.bin / URLStreamHandler.java < prev    next >
Text File  |  1997-10-01  |  8KB  |  241 lines
  1. /*
  2.  * @(#)URLStreamHandler.java    1.21 97/08/11
  3.  * 
  4.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion 1.1_beta
  20.  * 
  21.  */
  22.  
  23. package java.net;
  24.  
  25. import java.io.IOException;
  26. import java.io.InputStream;
  27. import java.io.File;
  28. import java.io.OutputStream;
  29. import java.util.Hashtable;
  30.  
  31. /**
  32.  * The abstract class <code>URLStreamHandler</code> is the common
  33.  * superclass for all stream protocol handlers. A stream protocol
  34.  * handler knows how to make a connection for a particular protocol
  35.  * type, such as <code>http</code>, <code>ftp</code>, or
  36.  * <code>gopher</code>.
  37.  *
  38.  * <p>In most cases, an instance of a <code>URLStreamHandler</code>
  39.  * subclass is not created directly by an application. Rather, the
  40.  * first time a protocol name is encountered when constructing a
  41.  * <code>URL</code>, the appropriate stream protocol handler is
  42.  * automatically loaded.
  43.  *
  44.  * @author  James Gosling
  45.  *
  46.  * @version 1.21, 08/11/97
  47.  *
  48.  * @see java.net.URL#URL(java.lang.String, java.lang.String, int,
  49.  * java.lang.String)
  50.  *
  51.  * @since JDK1.0 
  52.  */
  53. public abstract class URLStreamHandler {
  54.     /**
  55.      * Opens a connection to the object referenced by the 
  56.      * <code>URL</code> argument. 
  57.      * This method should be overridden by a subclass.
  58.      *
  59.      * @param      u   the URL that this connects to.
  60.      *
  61.      * @return a <code>URLConnection</code> object for the
  62.      * <code>URL</code>.
  63.      *
  64.      * @exception  IOException  if an I/O error occurs while opening the
  65.      *               connection.
  66.      * @since JDK1.0 
  67.      */
  68.     abstract protected URLConnection openConnection(URL u) throws IOException;
  69.  
  70.     /** 
  71.      * Parses the string representation of a <code>URL</code> into a 
  72.      * <code>URL</code> object. 
  73.      *
  74.      * <p>If there is any inherited context, then it has already been
  75.      * copied into the <code>URL</code> argument.
  76.      *
  77.      * <p> The <code>parseURL</code> method of
  78.      * <code>URLStreamHandler</code> parses the string representation
  79.      * as if it were an <code>http</code> specification. Most URL
  80.      * protocol families have a similar parsing. A stream protocol
  81.      * handler for a protocol that has a different syntax must
  82.      * override this routine.
  83.      *
  84.      * <p>If the file component of the URL argument contains a
  85.      * question mark (as with CGI HTTP URLs), the context is
  86.      * considered to be the URL's file component up to the first /
  87.      * before the question mark, not including the question mark or
  88.      * the directory before it. For example, if the URL was:
  89.      *
  90.      * <br><pre>    http://www.foo.com/dir/cgi-bin?foo=bar/baz</pre>
  91.      *
  92.      * and the spec argument was
  93.      *
  94.      * <br><pre>    quux.html</pre>
  95.      *
  96.      * the resulting URL would be:
  97.      *
  98.      * <br><pre>    http://www.foo.com/dir/quux.html</pre>.
  99.      * 
  100.      *
  101.      * @param u the <code>URL</code> to receive the result of parsing
  102.      * the spec.
  103.      *
  104.      * @param spec the <code>String</code> representing the URL that
  105.      * must be parsed.
  106.      *
  107.      * @param start the character index at which to begin
  108.      * parsing. This is just past the '<code>:</code>' (if there is
  109.      * one) that specifies the determination of the protocol name.
  110.      *
  111.      * @param limit the character position to stop parsing at. This is
  112.      * the end of the string or the position of the "<code>#</code>"
  113.      * character, if present. All information after the sharp sign
  114.      * indicates an anchor.
  115.      *
  116.      * @since JDK1.0 
  117.      */
  118.     protected void parseURL(URL u, String spec, int start, int limit) {
  119.     String protocol = u.getProtocol();
  120.     String host = u.getHost();
  121.     int port = u.getPort();
  122.     String file = u.getFile();
  123.     String ref = u.getRef();
  124.  
  125.     int i;
  126.     if ((start <= limit - 2) && (spec.charAt(start) == '/') &&
  127.         (spec.charAt(start + 1) == '/')) {
  128.         start += 2;
  129.         i = spec.indexOf('/', start);
  130.         if (i < 0) {
  131.         i = limit;
  132.         }
  133.         int prn = spec.indexOf(':', start);
  134.         port = -1;
  135.         if ((prn < i) && (prn >= 0)) {
  136.         try {
  137.             port = Integer.parseInt(spec.substring(prn + 1, i));
  138.         } catch(Exception e) {
  139.             // ignore bogus port numbers
  140.         }
  141.         if (prn > start) {
  142.             host = spec.substring(start, prn);
  143.         }
  144.         } else {
  145.         host = spec.substring(start, i);
  146.         }
  147.         start = i;
  148.         file = null;
  149.     } else if (host == null) {
  150.         host = "";
  151.     }
  152.     if (start < limit) {
  153.         /* 
  154.          * If the context URL is a CGI URL, the context to be the
  155.          * URL's file up to the / before ? character.
  156.          */
  157.         if (file != null) {
  158.         int questionMarkIndex = file.indexOf('?');
  159.         if (questionMarkIndex > -1) {
  160.             int lastSlashIndex = 
  161.             file.lastIndexOf('?', questionMarkIndex);
  162.             file = file.substring(0, ++lastSlashIndex);
  163.         }
  164.         }
  165.         if (spec.charAt(start) == '/') {
  166.         file = spec.substring(start, limit);
  167.         } else if (file != null && file.length() > 0) {
  168.         /* relative to the context file - use either 
  169.          * Unix separators || platform separators */
  170.         int ind = Math.max(file.lastIndexOf('/'), 
  171.                    file.lastIndexOf(File.separatorChar));
  172.  
  173.         file = file.substring(0, ind) + "/" + spec.substring(start, 
  174.                                      limit);
  175.         } else {
  176.         file = "/" + spec.substring(start, limit);
  177.         }
  178.     }
  179.     if ((file == null) || (file.length() == 0)) {
  180.         file = "/"; 
  181.     }
  182.     while ((i = file.indexOf("/./")) >= 0) {
  183.         file = file.substring(0, i) + file.substring(i + 2);
  184.     }
  185.     while ((i = file.indexOf("/../")) >= 0) {
  186.         if ((limit = file.lastIndexOf('/', i - 1)) >= 0) {
  187.         file = file.substring(0, limit) + file.substring(i + 3);
  188.         } else {
  189.         file = file.substring(i + 3);
  190.         }
  191.     }
  192.  
  193.     u.set(protocol, host, port, file, ref);
  194.     }
  195.  
  196.     /**
  197.      * Converts a <code>URL</code> of a specific protocol to a 
  198.      * <code>String</code>. 
  199.      *
  200.      * @param   u   the URL.
  201.      * @return  a string representation of the <code>URL</code> argument.
  202.      * @since   JDK1.0
  203.      */
  204.     protected String toExternalForm(URL u) {
  205.     String result = u.getProtocol() + ":";
  206.     if ((u.getHost() != null) && (u.getHost().length() > 0)) {
  207.         result = result + "//" + u.getHost();
  208.         if (u.getPort() != -1) {
  209.         result += ":" + u.getPort();
  210.         }
  211.     }
  212.     result += u.getFile();
  213.     if (u.getRef() != null) {
  214.         result += "#" + u.getRef();
  215.     }
  216.     return result;
  217.     }
  218.  
  219.     /**
  220.      * Sets the fields of the <code>URL</code> argument to the
  221.      * indicated values.  Only classes derived from URLStreamHandler
  222.      * are supposed to be able to call the set method on a URL.
  223.      *
  224.      * @param   u         the URL to modify.
  225.      * @param   protocol  the protocol name.
  226.      * @param   host      the remote host value for the URL.
  227.      * @param   port      the port on the remote machine.
  228.      * @param   file      the file.
  229.      * @param   ref       the reference.
  230.      *
  231.      * @see java.net.URL#set(java.lang.String, java.lang.String, int,
  232.      * java.lang.String, java.lang.String)
  233.      *
  234.      * @since JDK1.0 
  235.      */
  236.     protected void setURL(URL u, String protocol, String host, int port,
  237.               String file, String ref) {
  238.         u.set(protocol, host, port, file, ref);
  239.     }
  240. }
  241.