/*
    * Copyright (c) 2012, Maximilian Schmidt
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without modification,
    * are permitted provided that the following conditions are met:
    * 
    * Redistributions of source code must retain the above copyright notice, this 
    * list of conditions and the following disclaimer.
   * 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.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   * ANY EXPRESS 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 THE COPYRIGHT HOLDER OR 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.
   * 
   */
  package de.fub.mi.idenpa.jetty;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.math.BigInteger;
  import java.security.KeyPair;
  import java.security.KeyPairGenerator;
  import java.security.KeyStore;
  import java.security.SecureRandom;
  import java.security.Security;
  import java.security.cert.X509Certificate;
  import java.util.Date;
  
  import org.bouncycastle.jce.X509Principal;
  import org.bouncycastle.jce.provider.BouncyCastleProvider;
  import org.bouncycastle.x509.X509V3CertificateGenerator;
  import org.eclipse.jetty.server.Connector;
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.server.ssl.SslSocketConnector;
  import org.eclipse.jetty.util.ssl.SslContextFactory;
  import org.eclipse.jetty.webapp.WebAppContext;
  
  /**
   * Provides a way to start the embedded Jetty-server, enabling SSL using a static keypair
   */
  public class ServerMain {
  
  	/** The context path. */
  	private static String contextPath = "/";
  	
  	/** The resource base. */
  	private static String resourceBase = "WebContent";
  	
  	/** The http port. */
  	private static int httpPort = 8888;
  	
  	/** The Constant KS_SEC. */
  	private static final String KS_SEC = "df7§j7y/!bn";
  	
  	/** The Constant KSFILE. */
  	private static final String KSFILE = ".idemix/ssl.jks";
  
  	/**
  	 * The main method.
  	 *
  	 * @param args the arguments
  	 * @throws Exception the exception
  	 */
  	public static void main(String[] args) throws Exception {
  		Server server = new Server();
  		SslContextFactory factory = new SslContextFactory(true);
  		KeyStore ks = KeyStore.getInstance("JKS");
  		// String ksPass = UUID.randomUUID().toString();
  		factory.setKeyStore(ks);
  		factory.setKeyStore(getKeystore(KS_SEC));
  		factory.setKeyStorePassword(KS_SEC);
  		factory.setTrustAll(true);
  		SslSocketConnector sslConnector = new SslSocketConnector(factory);
  		sslConnector.setPort(httpPort);
  
  		// SelectChannelConnector selectChannelConnector = new
  		// SelectChannelConnector();
  		// selectChannelConnector.setPort(httpPort); // To accept connection
  		// from 8080, otherwise the normal connection cannot be passed into 8080
  		server.setConnectors(new Connector[] { sslConnector });
  
  		WebAppContext webapp = new WebAppContext();
  		webapp.setContextPath(contextPath);
  		webapp.setDefaultsDescriptor("WebContent/WEB-INF/web.xml");
  		webapp.setResourceBase(resourceBase);
 		webapp.setClassLoader(Thread.currentThread().getContextClassLoader());
 		server.setHandler(webapp);
 		server.start();
 		server.join();
 
 		server.start();
 		server.join();
 	}
 
 	/**
 	 * Gets the keystore.
 	 *
 	 * @param pass the pass
 	 * @return the keystore
 	 */
 	private static KeyStore getKeystore(String pass) {
 		KeyStore result = null;
 
 		Security.addProvider(new BouncyCastleProvider());
 
 		try {
 			result = KeyStore.getInstance("JKS");
 			result.load(getKsStream(), pass.toCharArray());
 
 			if (!isKsFileAvailable()) {
 				KeyPairGenerator keyPairGenerator = KeyPairGenerator
 						.getInstance("RSA");
 				keyPairGenerator.initialize(1024);
 				KeyPair KPair = keyPairGenerator.generateKeyPair();
 				X509V3CertificateGenerator v3CertGen = new X509V3CertificateGenerator();
 				int serial = Math.abs(new SecureRandom().nextInt());
 				v3CertGen.setSerialNumber(BigInteger.valueOf(serial));
 				v3CertGen.setIssuerDN(new X509Principal(
 						"CN=localhost, OU=None, O=None L=None, C=None"));
 				v3CertGen.setNotBefore(new Date(System.currentTimeMillis()
 						- 1000L * 60 * 60 * 24 * 30));
 				v3CertGen.setNotAfter(new Date(System.currentTimeMillis()
 						+ (1000L * 60 * 60 * 24 * 365 * 10)));
 				v3CertGen.setSubjectDN(new X509Principal(
 						"CN=localhost, OU=None, O=None L=None, C=None"));
 				v3CertGen.setPublicKey(KPair.getPublic());
 				v3CertGen.setSignatureAlgorithm("MD5WithRSAEncryption");
 
 				X509Certificate PKCertificate = v3CertGen
 						.generateX509Certificate(KPair.getPrivate());
 
 				result.setKeyEntry("jetty", KPair.getPrivate(),
 						pass.toCharArray(),
 						new java.security.cert.Certificate[] { PKCertificate });
 
 				result.store(getKsOutStream(), pass.toCharArray());
 			}
 		} catch (Throwable t) {
 			t.printStackTrace();
 		}
 
 		return result;
 	}
 
 	/**
 	 * Gets the ks file.
 	 *
 	 * @return the ks file
 	 */
 	private static final String getKsFile() {
 		String result = null;
 		String uHome = System.getProperty("user.home");
 		if (uHome != null) {
 			result = uHome + File.separator + KSFILE;
 		}
 		return result;
 	}
 
 	/**
 	 * Checks if is ks file available.
 	 *
 	 * @return true, if is ks file available
 	 */
 	private static final boolean isKsFileAvailable() {
 		boolean result = false;
 
 		File f = new File(getKsFile());
 		result = f.exists();
 
 		return result;
 	}
 
 	/**
 	 * Gets the ks stream.
 	 *
 	 * @return the ks stream
 	 */
 	private static final InputStream getKsStream() {
 		InputStream result = null;
 
 		if (isKsFileAvailable()) {
 			try {
 				result = new FileInputStream(new File(getKsFile()));
 			} catch (FileNotFoundException e) {
 			}
 		}
 
 		return result;
 	}
 
 	/**
 	 * Gets the ks out stream.
 	 *
 	 * @return the ks out stream
 	 */
 	private static final OutputStream getKsOutStream() {
 		OutputStream result = null;
 
 		try {
 			File f = new File(getKsFile());
 			if (!f.getParentFile().exists())
 				f.getParentFile().mkdirs();
 			
 			result = new FileOutputStream(f);
 		} catch (FileNotFoundException e) {
 		}
 
 		return result;
 	}
 
 }