1. /*

  2.  * @(#)URLStreamHandler.java	1.27 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package java.net;

  9. 

  10. import java.io.IOException;

  11. import java.io.InputStream;

  12. import java.io.File;

  13. import java.io.OutputStream;

  14. import java.util.Hashtable;

  15. 

  16. /**

  17.  * The abstract class <code>URLStreamHandler</code> is the common

  18.  * superclass for all stream protocol handlers. A stream protocol

  19.  * handler knows how to make a connection for a particular protocol

  20.  * type, such as <code>http</code>, <code>ftp</code>, or

  21.  * <code>gopher</code>.

  22.  * <p>

  23.  * In most cases, an instance of a <code>URLStreamHandler</code>

  24.  * subclass is not created directly by an application. Rather, the

  25.  * first time a protocol name is encountered when constructing a

  26.  * <code>URL</code>, the appropriate stream protocol handler is

  27.  * automatically loaded.

  28.  *

  29.  * @author  James Gosling

  30.  * @version 1.27, 11/29/01

  31.  * @see     java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)

  32.  * @since   JDK1.0

  33.  */

  34. public abstract class URLStreamHandler {

  35.     /**

  36.      * Opens a connection to the object referenced by the

  37.      * <code>URL</code> argument.

  38.      * This method should be overridden by a subclass.

  39.      *

  40.      * <p>If for the handler's protocol (such as HTTP or JAR), there

  41.      * exists a public, specialized URLConnection subclass belonging

  42.      * to one of the following packages or one of their subpackages:

  43.      * java.lang, java.io, java.util, java.net, the connection

  44.      * returned will be of that subclass. For example, for HTTP an

  45.      * HttpURLConnection will be returned, and for JAR a

  46.      * JarURLConnection will be returned.

  47.      *

  48.      * @param      u   the URL that this connects to.

  49.      * @return     a <code>URLConnection</code> object for the <code>URL</code>.

  50.      * @exception  IOException  if an I/O error occurs while opening the

  51.      *               connection.

  52.      */

  53.     abstract protected URLConnection openConnection(URL u) throws IOException;

  54. 

  55.     /**

  56.      * Parses the string representation of a <code>URL</code> into a

  57.      * <code>URL</code> object.

  58.      * <p>

  59.      * If there is any inherited context, then it has already been

  60.      * copied into the <code>URL</code> argument.

  61.      * <p>

  62.      * The <code>parseURL</code> method of <code>URLStreamHandler</code>

  63.      * parses the string representation as if it were an

  64.      * <code>http</code> specification. Most URL protocol families have a

  65.      * similar parsing. A stream protocol handler for a protocol that has

  66.      * a different syntax must override this routine.

  67.      *

  68.      * @param   u       the <code>URL</code> to receive the result of parsing

  69.      *                  the spec.

  70.      * @param   spec    the <code>String</code> representing the URL that

  71.      *                  must be parsed.

  72.      * @param   start   the character index at which to begin parsing. This is

  73.      *                  just past the '<code>:</code>' (if there is one) that

  74.      *                  specifies the determination of the protocol name.

  75.      * @param   limit   the character position to stop parsing at. This is the

  76.      *                  end of the string or the position of the

  77.      *                  "<code>#</code>" character, if present. All information

  78.      *                  after the sharp sign indicates an anchor.

  79.      */

  80.     protected void parseURL(URL u, String spec, int start, int limit) {

  81. 	String protocol = u.getProtocol();

  82. 	String host = u.getHost();

  83. 	int port = u.getPort();

  84. 	String file = u.getFile();

  85. 	String ref = u.getRef();

  86. 

  87. 	int i;

  88. 	if ((start <= limit - 2) && (spec.charAt(start) == '/') &&

  89. 	    (spec.charAt(start + 1) == '/')) {

  90. 	    start += 2;

  91. 	    i = spec.indexOf('/', start);

  92. 	    if (i < 0) {

  93. 		i = limit;

  94. 	    }

  95. 	    int prn = spec.indexOf(':', start);

  96. 	    port = -1;

  97. 	    if ((prn < i) && (prn >= 0)) {

  98. 		try {

  99. 		    port = Integer.parseInt(spec.substring(prn + 1, i));

  100. 		} catch(Exception e) {

  101. 		    // ignore bogus port numbers

  102. 		}

  103. 		if (prn > start) {

  104. 		    host = spec.substring(start, prn);

  105. 		}

  106. 	    } else {

  107. 		host = spec.substring(start, i);

  108. 	    }

  109. 	    start = i;

  110. 	    file = null;

  111. 	} else if (host == null) {

  112. 	    host = "";

  113. 	}

  114. 	if (start < limit) {

  115. 	    if (spec.charAt(start) == '/') {

  116. 		file = spec.substring(start, limit);

  117. 	    } else if (file != null && file.length() > 0) {

  118. 		/* relative to the context file - use either

  119. 		 * Unix separators || platform separators

  120. 		 */

  121. 		int ind = Math.max(file.lastIndexOf('/'),

  122. 				   file.lastIndexOf(File.separatorChar));

  123.                 // if there is no file separator there is no relative dir

  124.                 if (ind < 0)

  125.                     ind = 0;

  126. 		file = file.substring(0, ind) + "/" + spec.substring(start, limit);

  127. 	    } else {

  128. 		file = "/" + spec.substring(start, limit);

  129. 	    }

  130. 	}

  131. 	if ((file == null) || (file.length() == 0)) {

  132. 	    file = "/";

  133. 	}

  134. 	while ((i = file.indexOf("/./")) >= 0) {

  135. 	    file = file.substring(0, i) + file.substring(i + 2);

  136. 	}

  137. 	while ((i = file.indexOf("/../")) >= 0) {

  138. 	    if ((limit = file.lastIndexOf('/', i - 1)) >= 0) {

  139. 		file = file.substring(0, limit) + file.substring(i + 3);

  140. 	    } else {

  141. 		file = file.substring(i + 3);

  142. 	    }

  143. 	}

  144. 	setURL(u, protocol, host, port, file, ref);

  145.     }

  146. 

  147.     /**

  148.      * Converts a <code>URL</code> of a specific protocol to a

  149.      * <code>String</code>.

  150.      *

  151.      * @param   u   the URL.

  152.      * @return  a string representation of the <code>URL</code> argument.

  153.      */

  154.     protected String toExternalForm(URL u) {

  155. 	String result = u.getProtocol() + ":";

  156. 	if ((u.getHost() != null) && (u.getHost().length() > 0)) {

  157. 	    result = result + "//" + u.getHost();

  158. 	    if (u.getPort() != -1) {

  159. 		result += ":" + u.getPort();

  160. 	    }

  161. 	}

  162. 	result += u.getFile();

  163. 	if (u.getRef() != null) {

  164. 	    result += "#" + u.getRef();

  165. 	}

  166. 	return result;

  167.     }

  168. 

  169.     /**

  170.      * Sets the fields of the <code>URL</code> argument to the indicated values.

  171.      * Only classes derived from URLStreamHandler are supposed to be able

  172.      * to call the set method on a URL.

  173.      *

  174.      * @param   u         the URL to modify.

  175.      * @param   protocol  the protocol name.

  176.      * @param   host      the remote host value for the URL.

  177.      * @param   port      the port on the remote machine.

  178.      * @param   file      the file.

  179.      * @param   ref       the reference.

  180.      * @see     java.net.URL#set(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String)

  181.      */

  182.     protected void setURL(URL u, String protocol, String host, int port,

  183. 			  String file, String ref) {

  184. 	if (this != u.handler) {

  185. 	    throw new SecurityException("handler for url different from " +

  186. 					"this handler");

  187. 	}

  188. 	// ensure that no one can reset the protocol on a given URL.

  189.         u.set(u.getProtocol(), host, port, file, ref);

  190.     }

  191. }