/***
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Exoffice Technologies.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Exoffice Technologies. Exolab is a registered
   *    trademark of Exoffice Technologies.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 2001-2003 (C) Exoffice Technologies Inc. All Rights Reserved.
   *
   * $Id: SslHttpJndiInitialContextFactory.java,v 1.8 2003/08/07 13:32:58 tanderson Exp $
   *
   * Date         Author  Changes
   * $Date        jimm    Created
   */
  package org.exolab.jms.jndi.http;
  
  import java.security.Provider;
  import java.security.Security;
  import java.util.Hashtable;
  
  import javax.naming.ConfigurationException;
  import javax.naming.Context;
  import javax.naming.NamingException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.exolab.core.http.HttpClient;
  import org.exolab.core.util.URI;
  import org.exolab.jms.jndi.JndiConstants;
  
  
  /***
   * This is the client side helper class that retrieves the root context
   * of the JNDI server. This class implements the InitialContextFactory
   * interface.
   *
   * @version     $Revision: 1.8 $ $Date: 2003/08/07 13:32:58 $
   * @author      <a href="mailto:mourikis@exolab.org">Jim Mourikis</a>
   */
  public class SslHttpJndiInitialContextFactory
      extends HttpJndiInitialContextFactory {
  
      /***
       * Indicates if SSL has been initialized
       */
      private boolean _sslInitialized = false;
  
      /***
       * The https protocol identifier
       */
      private static final String HTTPS_SCHEME = "https";
  
      /***
       * The logger
       */
      private static final Log _log
          = LogFactory.getLog(SslHttpJndiInitialContextFactory.class);
  
      /***
       * Default constructor
       */
      public SslHttpJndiInitialContextFactory() {
      }
  
      /***
      * Returns the JNDI provider URL
      *
      * @return the JNDI provider URL
      * @throws NamingException if the URL cannot be determined
      */
     protected String getProviderURL(Hashtable environment)
         throws NamingException {
 
         if (environment == null) {
             throw new ConfigurationException(
                 "Cannot connect to JNDI provider - environment not set");
         }
         String url = (String) environment.get(Context.PROVIDER_URL);
         if (url != null) {
             URI uri;
             try {
                 uri = new URI(url);
             } catch (URI.MalformedURIException exception) {
                 throw new ConfigurationException(
                     "Malformed JNDI provider URL: " + url);
             }
             if (!HTTPS_SCHEME.equals(uri.getScheme())) {
                 throw new ConfigurationException(
                     "URL=" + url + " has an invalid scheme");
             }
             String path = uri.getPath();
             if (path == null || path.length() == 0) {
                 url += "/" + SERVLET;
             } else if (path.equals("/")) {
                 url += SERVLET;
             }
         } else {
             url = getDeprecatedEnvironment(environment);
         }
         return url;
     }
 
     /***
      * Get a connection to the JNDI provider
      *
      * @param url the JNDI provider URL
      * @return a connection to the JNDI provider
      * @throws NamingException if a connection cannot be established
      */
     protected HttpClient openConnection(String url) throws NamingException {
         HttpClient client;
         initSSL();
         try {
             client = new HttpClient(url, "SslHttpJndiInitialContextFactory");
         } catch (Exception exception) {
             NamingException error = new NamingException(
                 "Failed to connect to JNDI provider");
             error.setRootCause(exception);
             throw error;
         }
         return client;
     }
 
     /***
      * Initialises SSL
      *
      * @throws NamingException if SSL can't be initialised
      */
     private synchronized void initSSL() throws NamingException {
         if (!_sslInitialized) {
             try {
                 System.setProperty(
                     "java.protocol.handler.pkgs",
                     "com.sun.net.ssl.internal.www.protocol");
                 Class providerClass =
                     Class.forName("com.sun.net.ssl.internal.ssl.Provider");
                 Provider provider = (Provider) providerClass.newInstance();
                 Security.addProvider(provider);
                 _sslInitialized = true;
             } catch (Exception exception) {
                 NamingException error = new ConfigurationException(
                     "Failed to initialise SSL");
                 error.setRootCause(exception);
                 throw error;
             }
         }
     }
 
     /***
      * Returns the https url using the old environment properties, logging a
      * warning. This method will be removed in future releases
      */
     private String getDeprecatedEnvironment(Hashtable environment) {
         _log.warn(
             getClass().getName()
             + ": using deprecated environment. Use Context.PROVIDER_URL");
 
         StringBuffer url = new StringBuffer(HTTPS_SCHEME);
         String host = (String) environment.get(JndiConstants.HOST_PROPERTY);
         Integer port = (Integer) environment.get(
             JndiConstants.PORT_NUMBER_PROPERTY);
 
         // if the host is specified then use it, otherwise use localhost
         if (host != null) {
             url.append(host);
         } else {
             url.append("localhost");
         }
 
         // if the port has been specified then use it
         if (port != null) {
             url.append(":");
             url.append(port.toString());
         }
 
         url.append("/");
         url.append(SERVLET);
 
         return url.toString();
     }
 
 } //-- SslHttpJndiInitialContextFactory