/*

 * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.net;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Date;

import java.util.StringTokenizer;

import java.util.Collections;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Map;

import java.util.List;

import java.util.NoSuchElementException;

/**

 * The abstract class <code>URLConnection</code> is the superclass

 * of all classes that represent a communications link between the

 * application and a URL. Instances of this class can be used both to

 * read from and to write to the resource referenced by the URL. In

 * general, creating a connection to a URL is a multistep process:

 * <p>

 * <center><table border=2 summary="Describes the process of creating a connection to a URL: openConnection() and connect() over time.">

 * <tr><th><code>openConnection()</code></th>

 *     <th><code>connect()</code></th></tr>

 * <tr><td>Manipulate parameters that affect the connection to the remote

 *         resource.</td>

 *     <td>Interact with the resource; query header fields and

 *         contents.</td></tr>

 * </table>

 * ---------------------------->

 * <br>time</center>

 *

 * <ol>

 * <li>The connection object is created by invoking the

 *     <code>openConnection</code> method on a URL.

 * <li>The setup parameters and general request properties are manipulated.

 * <li>The actual connection to the remote object is made, using the

 *    <code>connect</code> method.

 * <li>The remote object becomes available. The header fields and the contents

 *     of the remote object can be accessed.

 * </ol>

 * <p>

 * The setup parameters are modified using the following methods:

 * <ul>

 *   <li><code>setAllowUserInteraction</code>

 *   <li><code>setDoInput</code>

 *   <li><code>setDoOutput</code>

 *   <li><code>setIfModifiedSince</code>

 *   <li><code>setUseCaches</code>

 * </ul>

 * <p>

 * and the general request properties are modified using the method:

 * <ul>

 *   <li><code>setRequestProperty</code>

 * </ul>

 * <p>

 * Default values for the <code>AllowUserInteraction</code> and

 * <code>UseCaches</code> parameters can be set using the methods

 * <code>setDefaultAllowUserInteraction</code> and

 * <code>setDefaultUseCaches</code>.

 * <p>

 * Each of the above <code>set</code> methods has a corresponding

 * <code>get</code> method to retrieve the value of the parameter or

 * general request property. The specific parameters and general

 * request properties that are applicable are protocol specific.

 * <p>

 * The following methods are used to access the header fields and

 * the contents after the connection is made to the remote object:

 * <ul>

 *   <li><code>getContent</code>

 *   <li><code>getHeaderField</code>

 *   <li><code>getInputStream</code>

 *   <li><code>getOutputStream</code>

 * </ul>

 * <p>

 * Certain header fields are accessed frequently. The methods:

 * <ul>

 *   <li><code>getContentEncoding</code>

 *   <li><code>getContentLength</code>

 *   <li><code>getContentType</code>

 *   <li><code>getDate</code>

 *   <li><code>getExpiration</code>

 *   <li><code>getLastModifed</code>

 * </ul>

 * <p>

 * provide convenient access to these fields. The

 * <code>getContentType</code> method is used by the

 * <code>getContent</code> method to determine the type of the remote

 * object; subclasses may find it convenient to override the

 * <code>getContentType</code> method.

 * <p>

 * In the common case, all of the pre-connection parameters and

 * general request properties can be ignored: the pre-connection

 * parameters and request properties default to sensible values. For

 * most clients of this interface, there are only two interesting

 * methods: <code>getInputStream</code> and <code>getContent</code>,

 * which are mirrored in the <code>URL</code> class by convenience methods.

 * <p>

 * More information on the request properties and header fields of

 * an <code>http</code> connection can be found at:

 * <blockquote><pre>

 * <a href="http://www.ietf.org/rfc/rfc2616.txt">http://www.ietf.org/rfc/rfc2616.txt</a>

 * </pre></blockquote>

 *

 * Note about <code>fileNameMap</code>: In versions prior to JDK 1.1.6,

 * field <code>fileNameMap</code> of <code>URLConnection</code> was public.

 * In JDK 1.1.6 and later, <code>fileNameMap</code> is private; accessor

 * and mutator methods {@link #getFileNameMap() getFileNameMap} and

 * {@link #setFileNameMap(java.net.FileNameMap) setFileNameMap} are added

 * to access it.  This change is also described on the <a href=

 * "http://java.sun.com/products/jdk/1.2/compatibility.html">

 * Compatibility</a> page.

 *

 * Invoking the <tt>close()</tt> methods on the <tt>InputStream</tt> or <tt>OutputStream</tt> of an

 * <tt>URLConnection</tt> after a request may free network resources associated with this

 * instance, unless particular protocol specifications specify different behaviours

 * for it.

 *

 * @author  James Gosling

 * @see     java.net.URL#openConnection()

 * @see     java.net.URLConnection#connect()

 * @see     java.net.URLConnection#getContent()

 * @see     java.net.URLConnection#getContentEncoding()

 * @see     java.net.URLConnection#getContentLength()

 * @see     java.net.URLConnection#getContentType()

 * @see     java.net.URLConnection#getDate()

 * @see     java.net.URLConnection#getExpiration()

 * @see     java.net.URLConnection#getHeaderField(int)

 * @see     java.net.URLConnection#getHeaderField(java.lang.String)

 * @see     java.net.URLConnection#getInputStream()

 * @see     java.net.URLConnection#getLastModified()

 * @see     java.net.URLConnection#getOutputStream()

 * @see     java.net.URLConnection#setAllowUserInteraction(boolean)

 * @see     java.net.URLConnection#setDefaultUseCaches(boolean)

 * @see     java.net.URLConnection#setDoInput(boolean)

 * @see     java.net.URLConnection#setDoOutput(boolean)

 * @see     java.net.URLConnection#setIfModifiedSince(long)

 * @see     java.net.URLConnection#setRequestProperty(java.lang.String, java.lang.String)

 * @see     java.net.URLConnection#setUseCaches(boolean)

 * @since   JDK1.0

 */

public abstract class URLConnection {

   /**

     * The URL represents the remote object on the World Wide Web to

     * which this connection is opened.

     * <p>

     * The value of this field can be accessed by the

     * <code>getURL</code> method.

     * <p>

     * The default value of this variable is the value of the URL

     * argument in the <code>URLConnection</code> constructor.

     *

     * @see     java.net.URLConnection#getURL()

     * @see     java.net.URLConnection#url

     */

    protected URL url;

   /**

     * This variable is set by the <code>setDoInput</code> method. Its

     * value is returned by the <code>getDoInput</code> method.

     * <p>

     * A URL connection can be used for input and/or output. Setting the

     * <code>doInput</code> flag to <code>true</code> indicates that

     * the application intends to read data from the URL connection.

     * <p>

     * The default value of this field is <code>true</code>.

     *

     * @see     java.net.URLConnection#getDoInput()

     * @see     java.net.URLConnection#setDoInput(boolean)

     */

    protected boolean doInput = true;

   /**

     * This variable is set by the <code>setDoOutput</code> method. Its

     * value is returned by the <code>getDoOutput</code> method.

     * <p>

     * A URL connection can be used for input and/or output. Setting the

     * <code>doOutput</code> flag to <code>true</code> indicates

     * that the application intends to write data to the URL connection.

     * <p>

     * The default value of this field is <code>false</code>.

     *

     * @see     java.net.URLConnection#getDoOutput()

     * @see     java.net.URLConnection#setDoOutput(boolean)

     */

    protected boolean doOutput = false;

    private static boolean defaultAllowUserInteraction = false;

   /**

     * If <code>true</code>, this <code>URL</code> is being examined in

     * a context in which it makes sense to allow user interactions such

     * as popping up an authentication dialog. If <code>false</code>,

     * then no user interaction is allowed.

     * <p>

     * The value of this field can be set by the

     * <code>setAllowUserInteraction</code> method.

     * Its value is returned by the

     * <code>getAllowUserInteraction</code> method.

     * Its default value is the value of the argument in the last invocation

     * of the <code>setDefaultAllowUserInteraction</code> method.

     *

     * @see     java.net.URLConnection#getAllowUserInteraction()

     * @see     java.net.URLConnection#setAllowUserInteraction(boolean)

     * @see     java.net.URLConnection#setDefaultAllowUserInteraction(boolean)

     */

    protected boolean allowUserInteraction = defaultAllowUserInteraction;

    private static boolean defaultUseCaches = true;

   /**

     * If <code>true</code>, the protocol is allowed to use caching

     * whenever it can. If <code>false</code>, the protocol must always

     * try to get a fresh copy of the object.

     * <p>

     * This field is set by the <code>setUseCaches</code> method. Its

     * value is returned by the <code>getUseCaches</code> method.

     * <p>

     * Its default value is the value given in the last invocation of the

     * <code>setDefaultUseCaches</code> method.

     *

     * @see     java.net.URLConnection#setUseCaches(boolean)

     * @see     java.net.URLConnection#getUseCaches()

     * @see     java.net.URLConnection#setDefaultUseCaches(boolean)

     */

    protected boolean useCaches = defaultUseCaches;

   /**

     * Some protocols support skipping the fetching of the object unless

     * the object has been modified more recently than a certain time.

     * <p>

     * A nonzero value gives a time as the number of milliseconds since

     * January 1, 1970, GMT. The object is fetched only if it has been

     * modified more recently than that time.

     * <p>

     * This variable is set by the <code>setIfModifiedSince</code>

     * method. Its value is returned by the

     * <code>getIfModifiedSince</code> method.

     * <p>

     * The default value of this field is <code>0</code>, indicating

     * that the fetching must always occur.

     *

     * @see     java.net.URLConnection#getIfModifiedSince()

     * @see     java.net.URLConnection#setIfModifiedSince(long)

     */

    protected long ifModifiedSince = 0;

   /**

     * If <code>false</code>, this connection object has not created a

     * communications link to the specified URL. If <code>true</code>,

     * the communications link has been established.

     */

    protected boolean connected = false;

    /**

     * @since 1.5

     */

    private int connectTimeout;

    private int readTimeout;

    /**

     * @since 1.6

     */

    private MessageHeader requests;

   /**

    * @since   JDK1.1

    */

    private static FileNameMap fileNameMap;

    /**

     * @since 1.2.2

     */

    private static boolean fileNameMapLoaded = false;

    /**

     * Loads filename map (a mimetable) from a data file. It will

     * first try to load the user-specific table, defined

     * by "content.types.user.table" property. If that fails,

     * it tries to load the default built-in table at

     * lib/content-types.properties under java home.

     *

     * @return the FileNameMap

     * @since 1.2

     * @see #setFileNameMap(java.net.FileNameMap)

     */

    public static synchronized FileNameMap getFileNameMap() {

        if ((fileNameMap == null) && !fileNameMapLoaded) {

            fileNameMap = new FileNameMap() {

                @Override

                public String getContentTypeFor(String fileName) {

                    return "text/plain";

                }

            };

            fileNameMapLoaded = true;

        }

        return new FileNameMap() {

            private FileNameMap map = fileNameMap;

            public String getContentTypeFor(String fileName) {

                return map.getContentTypeFor(fileName);

            }

        };

    }

    /**

     * Sets the FileNameMap.

     * <p>

     * If there is a security manager, this method first calls

     * the security manager's <code>checkSetFactory</code> method

     * to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     * @param map the FileNameMap to be set

     * @exception  SecurityException  if a security manager exists and its

     *             <code>checkSetFactory</code> method doesn't allow the operation.

     * @see        SecurityManager#checkSetFactory

     * @see #getFileNameMap()

     * @since 1.2

     */

    public static void setFileNameMap(FileNameMap map) {

        throw new SecurityException();

    }

    /**

     * Opens a communications link to the resource referenced by this

     * URL, if such a connection has not already been established.

     * <p>

     * If the <code>connect</code> method is called when the connection

     * has already been opened (indicated by the <code>connected</code>

     * field having the value <code>true</code>), the call is ignored.

     * <p>

     * URLConnection objects go through two phases: first they are

     * created, then they are connected.  After being created, and

     * before being connected, various options can be specified

     * (e.g., doInput and UseCaches).  After connecting, it is an

     * error to try to set them.  Operations that depend on being

     * connected, like getContentLength, will implicitly perform the

     * connection, if necessary.

     *

     * @throws SocketTimeoutException if the timeout expires before

     *               the connection can be established

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

     *               connection.

     * @see java.net.URLConnection#connected

     * @see #getConnectTimeout()

     * @see #setConnectTimeout(int)

     */

    abstract public void connect() throws IOException;

    /**

     * Sets a specified timeout value, in milliseconds, to be used

     * when opening a communications link to the resource referenced

     * by this URLConnection.  If the timeout expires before the

     * connection can be established, a

     * java.net.SocketTimeoutException is raised. A timeout of zero is

     * interpreted as an infinite timeout.

     * <p> Some non-standard implmentation of this method may ignore

     * the specified timeout. To see the connect timeout set, please

     * call getConnectTimeout().

     *

     * @param timeout an <code>int</code> that specifies the connect

     *               timeout value in milliseconds

     * @throws IllegalArgumentException if the timeout parameter is negative

     *

     * @see #getConnectTimeout()

     * @see #connect()

     * @since 1.5

     */

    public void setConnectTimeout(int timeout) {

        if (timeout < 0) {

            throw new IllegalArgumentException("timeout can not be negative");

        }

        connectTimeout = timeout;

    }

    /**

     * Returns setting for connect timeout.

     * <p>

     * 0 return implies that the option is disabled

     * (i.e., timeout of infinity).

     *

     * @return an <code>int</code> that indicates the connect timeout

     *         value in milliseconds

     * @see #setConnectTimeout(int)

     * @see #connect()

     * @since 1.5

     */

    public int getConnectTimeout() {

        return connectTimeout;

    }

    /**

     * Sets the read timeout to a specified timeout, in

     * milliseconds. A non-zero value specifies the timeout when

     * reading from Input stream when a connection is established to a

     * resource. If the timeout expires before there is data available

     * for read, a java.net.SocketTimeoutException is raised. A

     * timeout of zero is interpreted as an infinite timeout.

     *

     *<p> Some non-standard implementation of this method ignores the

     * specified timeout. To see the read timeout set, please call

     * getReadTimeout().

     *

     * @param timeout an <code>int</code> that specifies the timeout

     * value to be used in milliseconds

     * @throws IllegalArgumentException if the timeout parameter is negative

     *

     * @see #getReadTimeout()

     * @see InputStream#read()

     * @since 1.5

     */

    public void setReadTimeout(int timeout) {

        if (timeout < 0) {

            throw new IllegalArgumentException("timeout can not be negative");

        }

        readTimeout = timeout;

    }

    /**

     * Returns setting for read timeout. 0 return implies that the

     * option is disabled (i.e., timeout of infinity).

     *

     * @return an <code>int</code> that indicates the read timeout

     *         value in milliseconds

     *

     * @see #setReadTimeout(int)

     * @see InputStream#read()

     * @since 1.5

     */

    public int getReadTimeout() {

        return readTimeout;

    }

    /**

     * Constructs a URL connection to the specified URL. A connection to

     * the object referenced by the URL is not created.

     *

     * @param   url   the specified URL.

     */

    protected URLConnection(URL url) {

        this.url = url;

    }

    /**

     * Returns the value of this <code>URLConnection</code>'s <code>URL</code>

     * field.

     *

     * @return  the value of this <code>URLConnection</code>'s <code>URL</code>

     *          field.

     * @see     java.net.URLConnection#url

     */

    public URL getURL() {

        return url;

    }

    /**

     * Returns the value of the <code>content-length</code> header field.

     * <P>

     * <B>Note</B>: {@link #getContentLengthLong() getContentLengthLong()}

     * should be preferred over this method, since it returns a {@code long}

     * instead and is therefore more portable.</P>

     *

     * @return  the content length of the resource that this connection's URL

     *          references, {@code -1} if the content length is not known,

     *          or if the content length is greater than Integer.MAX_VALUE.

     */

    public int getContentLength() {

        long l = getContentLengthLong();

        if (l > Integer.MAX_VALUE)

            return -1;

        return (int) l;

    }

    /**

     * Returns the value of the <code>content-length</code> header field as a

     * long.

     *

     * @return  the content length of the resource that this connection's URL

     *          references, or <code>-1</code> if the content length is

     *          not known.

     * @since 7.0

     */

    public long getContentLengthLong() {

        return getHeaderFieldLong("content-length", -1);

    }

    /**

     * Returns the value of the <code>content-type</code> header field.

     *

     * @return  the content type of the resource that the URL references,

     *          or <code>null</code> if not known.

     * @see     java.net.URLConnection#getHeaderField(java.lang.String)

     */

    public String getContentType() {

        return getHeaderField("content-type");

    }

    /**

     * Returns the value of the <code>content-encoding</code> header field.

     *

     * @return  the content encoding of the resource that the URL references,

     *          or <code>null</code> if not known.

     * @see     java.net.URLConnection#getHeaderField(java.lang.String)

     */

    public String getContentEncoding() {

        return getHeaderField("content-encoding");

    }

    /**

     * Returns the value of the <code>expires</code> header field.

     *

     * @return  the expiration date of the resource that this URL references,

     *          or 0 if not known. The value is the number of milliseconds since

     *          January 1, 1970 GMT.

     * @see     java.net.URLConnection#getHeaderField(java.lang.String)

     */

    public long getExpiration() {

        return getHeaderFieldDate("expires", 0);

    }

    /**

     * Returns the value of the <code>date</code> header field.

     *

     * @return  the sending date of the resource that the URL references,

     *          or <code>0</code> if not known. The value returned is the

     *          number of milliseconds since January 1, 1970 GMT.

     * @see     java.net.URLConnection#getHeaderField(java.lang.String)

     */

    public long getDate() {

        return getHeaderFieldDate("date", 0);

    }

    /**

     * Returns the value of the <code>last-modified</code> header field.

     * The result is the number of milliseconds since January 1, 1970 GMT.

     *

     * @return  the date the resource referenced by this

     *          <code>URLConnection</code> was last modified, or 0 if not known.

     * @see     java.net.URLConnection#getHeaderField(java.lang.String)

     */

    public long getLastModified() {

        return getHeaderFieldDate("last-modified", 0);

    }

    /**

     * Returns the value of the named header field.

     * <p>

     * If called on a connection that sets the same header multiple times

     * with possibly different values, only the last value is returned.

     *

     *

     * @param   name   the name of a header field.

     * @return  the value of the named header field, or <code>null</code>

     *          if there is no such field in the header.

     */

    public String getHeaderField(String name) {

        return null;

    }

    /**

     * Returns an unmodifiable Map of the header fields.

     * The Map keys are Strings that represent the

     * response-header field names. Each Map value is an

     * unmodifiable List of Strings that represents

     * the corresponding field values.

     *

     * @return a Map of header fields

     * @since 1.4

     */

    public Map<String,List<String>> getHeaderFields() {

        return Collections.EMPTY_MAP;

    }

    /**

     * Returns the value of the named field parsed as a number.

     * <p>

     * This form of <code>getHeaderField</code> exists because some

     * connection types (e.g., <code>http-ng</code>) have pre-parsed

     * headers. Classes for that connection type can override this method

     * and short-circuit the parsing.

     *

     * @param   name      the name of the header field.

     * @param   Default   the default value.

     * @return  the value of the named field, parsed as an integer. The

     *          <code>Default</code> value is returned if the field is

     *          missing or malformed.

     */

    public int getHeaderFieldInt(String name, int Default) {

        String value = getHeaderField(name);

        try {

            return Integer.parseInt(value);

        } catch (Exception e) { }

        return Default;

    }

    /**

     * Returns the value of the named field parsed as a number.

     * <p>

     * This form of <code>getHeaderField</code> exists because some

     * connection types (e.g., <code>http-ng</code>) have pre-parsed

     * headers. Classes for that connection type can override this method

     * and short-circuit the parsing.

     *

     * @param   name      the name of the header field.

     * @param   Default   the default value.

     * @return  the value of the named field, parsed as a long. The

     *          <code>Default</code> value is returned if the field is

     *          missing or malformed.

     * @since 7.0

     */

    public long getHeaderFieldLong(String name, long Default) {

        String value = getHeaderField(name);

        try {

            return Long.parseLong(value);

        } catch (Exception e) { }

        return Default;

    }

    /**

     * Returns the value of the named field parsed as date.

     * The result is the number of milliseconds since January 1, 1970 GMT

     * represented by the named field.

     * <p>

     * This form of <code>getHeaderField</code> exists because some

     * connection types (e.g., <code>http-ng</code>) have pre-parsed

     * headers. Classes for that connection type can override this method

     * and short-circuit the parsing.

     *

     * @param   name     the name of the header field.

     * @param   Default   a default value.

     * @return  the value of the field, parsed as a date. The value of the

     *          <code>Default</code> argument is returned if the field is

     *          missing or malformed.

     */

    public long getHeaderFieldDate(String name, long Default) {

        String value = getHeaderField(name);

        try {

            return Date.parse(value);

        } catch (Exception e) { }

        return Default;

    }

    /**

     * Returns the key for the <code>n</code><sup>th</sup> header field.

     * It returns <code>null</code> if there are fewer than <code>n+1</code> fields.

     *

     * @param   n   an index, where n>=0

     * @return  the key for the <code>n</code><sup>th</sup> header field,

     *          or <code>null</code> if there are fewer than <code>n+1</code>

     *          fields.

     */

    public String getHeaderFieldKey(int n) {

        return null;

    }

    /**

     * Returns the value for the <code>n</code><sup>th</sup> header field.

     * It returns <code>null</code> if there are fewer than

     * <code>n+1</code>fields.

     * <p>

     * This method can be used in conjunction with the

     * {@link #getHeaderFieldKey(int) getHeaderFieldKey} method to iterate through all

     * the headers in the message.

     *

     * @param   n   an index, where n>=0

     * @return  the value of the <code>n</code><sup>th</sup> header field

     *          or <code>null</code> if there are fewer than <code>n+1</code> fields

     * @see     java.net.URLConnection#getHeaderFieldKey(int)

     */

    public String getHeaderField(int n) {

        return null;

    }

    /**

     * Retrieves the contents of this URL connection.

     * <p>

     * This method first determines the content type of the object by

     * calling the <code>getContentType</code> method. If this is

     * the first time that the application has seen that specific content

     * type, a content handler for that content type is created:

     * <ol>

     * <li>If the application has set up a content handler factory instance

     *     using the <code>setContentHandlerFactory</code> method, the

     *     <code>createContentHandler</code> method of that instance is called

     *     with the content type as an argument; the result is a content

     *     handler for that content type.

     * <li>If no content handler factory has yet been set up, or if the

     *     factory's <code>createContentHandler</code> method returns

     *     <code>null</code>, then the application loads the class named:

     *     <blockquote><pre>

     *         sun.net.www.content.&lt;<i>contentType</i>&gt;

     *     </pre></blockquote>

     *     where &lt;<i>contentType</i>&gt; is formed by taking the

     *     content-type string, replacing all slash characters with a

     *     <code>period</code> ('.'), and all other non-alphanumeric characters

     *     with the underscore character '<code>_</code>'. The alphanumeric

     *     characters are specifically the 26 uppercase ASCII letters

     *     '<code>A</code>' through '<code>Z</code>', the 26 lowercase ASCII

     *     letters '<code>a</code>' through '<code>z</code>', and the 10 ASCII

     *     digits '<code>0</code>' through '<code>9</code>'. If the specified

     *     class does not exist, or is not a subclass of

     *     <code>ContentHandler</code>, then an

     *     <code>UnknownServiceException</code> is thrown.

     * </ol>

     *

     * @return     the object fetched. The <code>instanceof</code> operator

     *               should be used to determine the specific kind of object

     *               returned.

     * @exception  IOException              if an I/O error occurs while

     *               getting the content.

     * @exception  UnknownServiceException  if the protocol does not support

     *               the content type.

     * @see        java.net.ContentHandlerFactory#createContentHandler(java.lang.String)

     * @see        java.net.URLConnection#getContentType()

     * @see        java.net.URLConnection#setContentHandlerFactory(java.net.ContentHandlerFactory)

     */

    public Object getContent() throws IOException {

        // Must call getInputStream before GetHeaderField gets called

        // so that FileNotFoundException has a chance to be thrown up

        // from here without being caught.

        getInputStream();

        return getContentHandler().getContent(this);

    }

    /**

     * Retrieves the contents of this URL connection.

     *

     * @param classes the <code>Class</code> array

     * indicating the requested types

     * @return     the object fetched that is the first match of the type

     *               specified in the classes array. null if none of

     *               the requested types are supported.

     *               The <code>instanceof</code> operator should be used to

     *               determine the specific kind of object returned.

     * @exception  IOException              if an I/O error occurs while

     *               getting the content.

     * @exception  UnknownServiceException  if the protocol does not support

     *               the content type.

     * @see        java.net.URLConnection#getContent()

     * @see        java.net.ContentHandlerFactory#createContentHandler(java.lang.String)

     * @see        java.net.URLConnection#getContent(java.lang.Class[])

     * @see        java.net.URLConnection#setContentHandlerFactory(java.net.ContentHandlerFactory)

     * @since 1.3

     */

    public Object getContent(Class[] classes) throws IOException {

        // Must call getInputStream before GetHeaderField gets called

        // so that FileNotFoundException has a chance to be thrown up

        // from here without being caught.

        getInputStream();

        return getContentHandler().getContent(this, classes);

    }

    /**

     * Returns a permission object representing the permission

     * necessary to make the connection represented by this

     * object. This method returns null if no permission is

     * required to make the connection. By default, this method

     * returns <code>java.security.AllPermission</code>. Subclasses

     * should override this method and return the permission

     * that best represents the permission required to make a

     * a connection to the URL. For example, a <code>URLConnection</code>

     * representing a <code>file:</code> URL would return a

     * <code>java.io.FilePermission</code> object.

     *

     * <p>The permission returned may dependent upon the state of the

     * connection. For example, the permission before connecting may be

     * different from that after connecting. For example, an HTTP

     * sever, say foo.com, may redirect the connection to a different

     * host, say bar.com. Before connecting the permission returned by

     * the connection will represent the permission needed to connect

     * to foo.com, while the permission returned after connecting will

     * be to bar.com.

     *

     * <p>Permissions are generally used for two purposes: to protect

     * caches of objects obtained through URLConnections, and to check

     * the right of a recipient to learn about a particular URL. In

     * the first case, the permission should be obtained

     * <em>after</em> the object has been obtained. For example, in an

     * HTTP connection, this will represent the permission to connect

     * to the host from which the data was ultimately fetched. In the

     * second case, the permission should be obtained and tested

     * <em>before</em> connecting.

     *

     * @return the permission object representing the permission

     * necessary to make the connection represented by this

     * URLConnection.

     *

     * @exception IOException if the computation of the permission

     * requires network or file I/O and an exception occurs while

     * computing it.

     */

//    public Permission getPermission() throws IOException {

//        return SecurityConstants.ALL_PERMISSION;

//    }

    /**

     * Returns an input stream that reads from this open connection.

     *

     * A SocketTimeoutException can be thrown when reading from the

     * returned input stream if the read timeout expires before data

     * is available for read.

     *

     * @return     an input stream that reads from this open connection.

     * @exception  IOException              if an I/O error occurs while

     *               creating the input stream.

     * @exception  UnknownServiceException  if the protocol does not support

     *               input.

     * @see #setReadTimeout(int)

     * @see #getReadTimeout()

     */

    public InputStream getInputStream() throws IOException {

        throw new UnknownServiceException("protocol doesn't support input");

    }

    /**

     * Returns an output stream that writes to this connection.

     *

     * @return     an output stream that writes to this connection.

     * @exception  IOException              if an I/O error occurs while

     *               creating the output stream.

     * @exception  UnknownServiceException  if the protocol does not support

     *               output.

     */

    public OutputStream getOutputStream() throws IOException {

        throw new UnknownServiceException("protocol doesn't support output");

    }

    /**

     * Returns a <code>String</code> representation of this URL connection.

     *

     * @return  a string representation of this <code>URLConnection</code>.

     */

    public String toString() {

        return this.getClass().getName() + ":" + url;

    }

    /**

     * Sets the value of the <code>doInput</code> field for this

     * <code>URLConnection</code> to the specified value.

     * <p>

     * A URL connection can be used for input and/or output.  Set the DoInput

     * flag to true if you intend to use the URL connection for input,

     * false if not.  The default is true.

     *

     * @param   doinput   the new value.

     * @throws IllegalStateException if already connected

     * @see     java.net.URLConnection#doInput

     * @see #getDoInput()

     */

    public void setDoInput(boolean doinput) {

        if (connected)

            throw new IllegalStateException("Already connected");

        doInput = doinput;

    }

    /**

     * Returns the value of this <code>URLConnection</code>'s

     * <code>doInput</code> flag.

     *

     * @return  the value of this <code>URLConnection</code>'s

     *          <code>doInput</code> flag.

     * @see     #setDoInput(boolean)

     */

    public boolean getDoInput() {

        return doInput;

    }

    /**

     * Sets the value of the <code>doOutput</code> field for this

     * <code>URLConnection</code> to the specified value.

     * <p>

     * A URL connection can be used for input and/or output.  Set the DoOutput

     * flag to true if you intend to use the URL connection for output,

     * false if not.  The default is false.

     *

     * @param   dooutput   the new value.

     * @throws IllegalStateException if already connected

     * @see #getDoOutput()

     */

    public void setDoOutput(boolean dooutput) {

        if (connected)

            throw new IllegalStateException("Already connected");

        doOutput = dooutput;

    }

    /**

     * Returns the value of this <code>URLConnection</code>'s

     * <code>doOutput</code> flag.

     *

     * @return  the value of this <code>URLConnection</code>'s

     *          <code>doOutput</code> flag.

     * @see     #setDoOutput(boolean)

     */

    public boolean getDoOutput() {

        return doOutput;

    }

    /**

     * Set the value of the <code>allowUserInteraction</code> field of

     * this <code>URLConnection</code>.

     *

     * @param   allowuserinteraction   the new value.

     * @throws IllegalStateException if already connected

     * @see     #getAllowUserInteraction()

     */

    public void setAllowUserInteraction(boolean allowuserinteraction) {

        if (connected)

            throw new IllegalStateException("Already connected");

        allowUserInteraction = allowuserinteraction;

    }

    /**

     * Returns the value of the <code>allowUserInteraction</code> field for

     * this object.

     *

     * @return  the value of the <code>allowUserInteraction</code> field for

     *          this object.

     * @see     #setAllowUserInteraction(boolean)

     */

    public boolean getAllowUserInteraction() {

        return allowUserInteraction;

    }

    /**

     * Sets the default value of the

     * <code>allowUserInteraction</code> field for all future

     * <code>URLConnection</code> objects to the specified value.

     *

     * @param   defaultallowuserinteraction   the new value.

     * @see     #getDefaultAllowUserInteraction()

     */

    public static void setDefaultAllowUserInteraction(boolean defaultallowuserinteraction) {

        defaultAllowUserInteraction = defaultallowuserinteraction;

    }

    /**

     * Returns the default value of the <code>allowUserInteraction</code>

     * field.

     * <p>

     * Ths default is "sticky", being a part of the static state of all

     * URLConnections.  This flag applies to the next, and all following

     * URLConnections that are created.

     *

     * @return  the default value of the <code>allowUserInteraction</code>

     *          field.

     * @see     #setDefaultAllowUserInteraction(boolean)

     */

    public static boolean getDefaultAllowUserInteraction() {

        return defaultAllowUserInteraction;

    }

    /**

     * Sets the value of the <code>useCaches</code> field of this

     * <code>URLConnection</code> to the specified value.

     * <p>

     * Some protocols do caching of documents.  Occasionally, it is important

     * to be able to "tunnel through" and ignore the caches (e.g., the

     * "reload" button in a browser).  If the UseCaches flag on a connection

     * is true, the connection is allowed to use whatever caches it can.

     *  If false, caches are to be ignored.

     *  The default value comes from DefaultUseCaches, which defaults to

     * true.

     *