gt:             int v = 1000 * Integer.parseInt(ttl);
context: /* HTTPConnection.java --
     Copyright (C) 2004, 2005, 2006  Free Software Foundation, Inc.
  
  This file is part of GNU Classpath.
  
  GNU Classpath is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.
  
  GNU Classpath 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 for more details.
  
  You should have received a copy of the GNU General Public License
  along with GNU Classpath; see the file COPYING.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA.
  
  Linking this library statically or dynamically with other modules is
  making a combined work based on this library.  Thus, the terms and
  conditions of the GNU General Public License cover the whole
  combination.
  
  As a special exception, the copyright holders of this library give you
  permission to link this library with independent modules to produce an
  executable, regardless of the license terms of these independent
  modules, and to copy and distribute the resulting executable under
  terms of your choice, provided that you also meet, for each linked
  independent module, the terms and conditions of the license of that
  module.  An independent module is a module which is not derived from
  or based on this library.  If you modify this library, you may extend
  this exception to your version of the library, but you are not
  obligated to do so.  If you do not wish to do so, delete this
  exception statement from your version. */
  
  
  package gnu.java.net.protocol.http;
  
  import gnu.classpath.SystemProperties;
  
  import gnu.java.lang.CPStringBuilder;
  import gnu.java.net.EmptyX509TrustManager;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.InetSocketAddress;
  import java.net.Socket;
  import java.net.SocketException;
  import java.security.GeneralSecurityException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Map;
  
  import javax.net.ssl.HandshakeCompletedListener;
  import javax.net.ssl.SSLContext;
  import javax.net.ssl.SSLSocket;
  import javax.net.ssl.SSLSocketFactory;
  import javax.net.ssl.TrustManager;
  
  /**
   * A connection to an HTTP server.
   *
   * @author Chris Burdess (dog@gnu.org)
   */
  public class HTTPConnection
  {
  
    /**
     * The default HTTP port.
     */
    public static final int HTTP_PORT = 80;
  
    /**
     * The default HTTPS port.
     */
    public static final int HTTPS_PORT = 443;
  
    private static final String userAgent = SystemProperties.getProperty("http.agent");
  
    /**
     * The host name of the server to connect to.
     */
    protected final String hostname;
  
    /**
     * The port to connect to.
     */
    protected final int port;
  
    /**
     * Whether the connection should use transport level security (HTTPS).
     */
    protected final boolean secure;
  
    /**
     * The connection timeout for connecting the underlying socket.
     */
    protected final int connectionTimeout;
  
    /**
     * The read timeout for reads on the underlying socket.
     */
    protected final int timeout;
  
    /**
     * The host name of the proxy to connect to.
     */
    protected String proxyHostname;
  
    /**
     * The port on the proxy to connect to.
     */
    protected int proxyPort;
  
    /**
     * The major version of HTTP supported by this client.
     */
    protected int majorVersion;
  
    /**
     * The minor version of HTTP supported by this client.
     */
    protected int minorVersion;
  
    private final List<HandshakeCompletedListener> handshakeCompletedListeners;
  
    /**
     * The socket this connection communicates on.
     */
    protected Socket socket;
  
    /**
     * The SSL socket factory to use.
     */
    private SSLSocketFactory sslSocketFactory;
  
    /**
     * The socket input stream.
     */
    protected InputStream in;
  
    /**
     * The socket output stream.
     */
    protected OutputStream out;
  
    /**
     * Nonce values seen by this connection.
     */
    private Map<String, Integer> nonceCounts;
  
    /**
     * The cookie manager for this connection.
     */
    protected CookieManager cookieManager;
  
  
    /**
     * The pool that this connection is a member of (if any).
     */
    private Pool pool;
  
    /**
     * Creates a new HTTP connection.
     * @param hostname the name of the host to connect to
     */
    public HTTPConnection(String hostname)
    {
      this(hostname, HTTP_PORT, false, 0, 0);
    }
  
    /**
     * Creates a new HTTP or HTTPS connection.
     * @param hostname the name of the host to connect to
     * @param secure whether to use a secure connection
     */
    public HTTPConnection(String hostname, boolean secure)
    {
      this(hostname, secure ? HTTPS_PORT : HTTP_PORT, secure, 0, 0);
    }
  
    /**
     * Creates a new HTTP or HTTPS connection on the specified port.
     * @param hostname the name of the host to connect to
     * @param secure whether to use a secure connection
     * @param connectionTimeout the connection timeout
     * @param timeout the socket read timeout
     */
    public HTTPConnection(String hostname, boolean secure,
                          int connectionTimeout, int timeout)
    {
      this(hostname, secure ? HTTPS_PORT : HTTP_PORT, secure,
           connectionTimeout, timeout);
    }
  
    /**
     * Creates a new HTTP connection on the specified port.
     * @param hostname the name of the host to connect to
     * @param port the port on the host to connect to
     */
    public HTTPConnection(String hostname, int port)
    {
      this(hostname, port, false, 0, 0);
    }
  
    /**
     * Creates a new HTTP or HTTPS connection on the specified port.
     * @param hostname the name of the host to connect to
     * @param port the port on the host to connect to
     * @param secure whether to use a secure connection
     */
    public HTTPConnection(String hostname, int port, boolean secure)
    {
      this(hostname, port, secure, 0, 0);
    }
  
    /**
     * Creates a new HTTP or HTTPS connection on the specified port.
     * @param hostname the name of the host to connect to
     * @param port the port on the host to connect to
     * @param secure whether to use a secure connection
     * @param connectionTimeout the connection timeout
     * @param timeout the socket read timeout
     *
     * @throws IllegalArgumentException if either connectionTimeout or
     * timeout less than zero.
     */
    public HTTPConnection(String hostname, int port, boolean secure,
                          int connectionTimeout, int timeout)
    {
      if (connectionTimeout < 0 || timeout < 0)
        throw new IllegalArgumentException();
  
      this.hostname = hostname;
      this.port = port;
      this.secure = secure;
      this.connectionTimeout = connectionTimeout;
      this.timeout = timeout;
      majorVersion = minorVersion = 1;
      handshakeCompletedListeners
        = new ArrayList<HandshakeCompletedListener>(2);
    }
  
    /**
     * Returns the name of the host to connect to.
     */
    public String getHostName()
    {
      return hostname;
    }
  
    /**
     * Returns the port on the host to connect to.
     */
    public int getPort()
    {
      return port;
    }
  
    /**
     * Indicates whether to use a secure connection or not.
     */
    public boolean isSecure()
    {
      return secure;
    }
  
    /**
     * Returns the HTTP version string supported by this connection.
     * @see #majorVersion
     * @see #minorVersion
     */
    public String getVersion()
    {
      return "HTTP/" + majorVersion + '.' + minorVersion;
    }
  
    /**
     * Sets the HTTP version supported by this connection.
     * @param majorVersion the major version
     * @param minorVersion the minor version
     */
    public void setVersion(int majorVersion, int minorVersion)
    {
      if (majorVersion != 1)
        {
          throw new IllegalArgumentException("major version not supported: " +
                                             majorVersion);
        }
      if (minorVersion < 0 || minorVersion > 1)
        {
          throw new IllegalArgumentException("minor version not supported: " +
                                             minorVersion);
        }
      this.majorVersion = majorVersion;
      this.minorVersion = minorVersion;
    }
  
    /**
     * Directs this connection to use the specified proxy.
     * @param hostname the proxy host name
     * @param port the port on the proxy to connect to
     */
    public void setProxy(String hostname, int port)
    {
      proxyHostname = hostname;
      proxyPort = port;
    }
  
    /**
     * Indicates whether this connection is using an HTTP proxy.
     */
    public boolean isUsingProxy()
    {
      return (proxyHostname != null && proxyPort > 0);
    }
  
    /**
     * Sets the cookie manager to use for this connection.
     * @param cookieManager the cookie manager
     */
    public void setCookieManager(CookieManager cookieManager)
    {
      this.cookieManager = cookieManager;
    }
  
    /**
     * Returns the cookie manager in use for this connection.
     */
    public CookieManager getCookieManager()
    {
      return cookieManager;
    }
  
    /**
     * Manages a pool of HTTPConections.  The pool will have a maximum
     * size determined by the value of the maxConn parameter passed to
     * the {@link #get} method.  This value inevitably comes from the
     * http.maxConnections system property.  If the
     * classpath.net.http.keepAliveTTL system property is set, that will
     * be the maximum time (in seconds) that an idle connection will be
     * maintained.
     */
    static class Pool
    {
      /**
       * Singleton instance of the pool.
       */
      static Pool instance = new Pool();
  
      /**
       * The pool
       */
      final LinkedList<HTTPConnection> connectionPool
        = new LinkedList<HTTPConnection>();
  
      /**
       * Maximum size of the pool.
       */
      int maxConnections;
  
      /**
       * If greater than zero, the maximum time a connection will remain
       * int the pool.
       */
      int connectionTTL;
  
      /**
       * A thread that removes connections older than connectionTTL.
       */
      class Reaper
        implements Runnable
      {
        public void run()
        {
          synchronized (Pool.this)
            {
              try
                {
                  do
                    {
                      while (connectionPool.size() > 0)
                        {
                          long currentTime = System.currentTimeMillis();
  
                          HTTPConnection c = connectionPool.getFirst();
  
                          long waitTime = c.timeLastUsed
                            + connectionTTL - currentTime;
  
                          if (waitTime <= 0)
                            removeOldest();
                          else
                            try
                              {
                                Pool.this.wait(waitTime);
                              }
                            catch (InterruptedException _)
                              {
                                // Ignore the interrupt.
                              }
                        }
                      // After the pool is empty, wait TTL to see if it
                      // is used again.  This is because in the
                      // situation where a single thread is making HTTP
                      // requests to the same server it can remove the
                      // connection from the pool before the Reaper has
                      // a chance to start.  This would cause the Reaper
                      // to exit if it were not for this extra delay.
                      // The result would be starting a Reaper thread
                      // for each HTTP request.  With the delay we get
                      // at most one Reaper created each TTL.
                      try
                        {
                          Pool.this.wait(connectionTTL);
                        }
                      catch (InterruptedException _)
                        {
                          // Ignore the interrupt.
                        }
                    }
                  while (connectionPool.size() > 0);
                }
              finally
                {
                  reaper = null;
                }
            }
        }
      }
  
      Reaper reaper;
  
      /**
       * Private constructor to ensure singleton.
       */
      private Pool()
      {
      }
  
      /**
       * Tests for a matching connection.
       *
       * @param c connection to match.
       * @param h the host name.
       * @param p the port.
       * @param sec true if using https.
       *
       * @return true if c matches h, p, and sec.
       */
      private static boolean matches(HTTPConnection c,
                                     String h, int p, boolean sec)
      {
        return h.equals(c.hostname) && (p == c.port) && (sec == c.secure);
      }
  
      /**
       * Get a pooled HTTPConnection.  If there is an existing idle
       * connection to the requested server it is returned.  Otherwise a
       * new connection is created.
       *
       * @param host the name of the host to connect to
       * @param port the port on the host to connect to
       * @param secure whether to use a secure connection
       *
       * @return the HTTPConnection.
       */
      synchronized HTTPConnection get(String host,
                                      int port,
                                      boolean secure,
                                      int connectionTimeout, int timeout)
      {
        String ttl =
          SystemProperties.getProperty("classpath.net.http.keepAliveTTL");
        connectionTTL = 10000;
        if (ttl != null && ttl.length() > 0)
          try
            {
  