package com.atlassian.sal.core.net;
   
   import java.io.IOException;
   import java.net.URL;
   import java.net.UnknownHostException;
   import java.security.AccessController;
   import java.security.KeyStore;
   import java.security.PrivilegedAction;
   import java.security.Provider;
  import java.security.Security;
  import java.security.cert.X509Certificate;
  import java.util.Arrays;
  import java.util.Set;
  
  import javax.net.ssl.ManagerFactoryParameters;
  import javax.net.ssl.TrustManager;
  import javax.net.ssl.TrustManagerFactorySpi;
  import javax.net.ssl.X509TrustManager;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import com.atlassian.sal.api.net.Request;
  import com.atlassian.sal.api.net.ResponseException;
  import com.atlassian.sal.api.net.ResponseHandler;
  import com.atlassian.sal.api.net.ResponseProtocolException;
  
  import com.google.common.collect.Sets;
  
  import org.apache.commons.httpclient.params.HttpClientParams;
  import org.apache.commons.io.IOUtils;
  import org.eclipse.jetty.server.Connector;
  import org.eclipse.jetty.server.Handler;
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.server.handler.AbstractHandler;
  import org.eclipse.jetty.server.ssl.SslSocketConnector;
  import org.eclipse.jetty.util.ssl.SslContextFactory;
  import org.junit.After;
  import org.junit.AfterClass;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import org.junit.Test;
  
  import static junit.framework.Assert.assertEquals;
  import static org.apache.commons.io.IOUtils.write;
  import static org.junit.Assert.fail;
  
  public class TestHttpClientRequestRedirects
  {
      private HttpTestServer server;
      private HttpClientRequestFactory requestFactory;
  
      @BeforeClass
      public static void installTrustProvider()
      {
          GullibleTrustProvider.install();
      }
  
      @AfterClass
      public static void uninstallTrustProvider()
      {
          GullibleTrustProvider.uninstall();
      }
  
      @Before
      public void setUp()
      {
          requestFactory = new HttpClientRequestFactory(null, null);
      }
  
      @After
      public void stopServer() throws Exception
      {
          System.clearProperty(HttpClientParams.MAX_REDIRECTS);
          server.stop();
      }
  
      @Test
      public void testHttpClientAccessHttpUrl() throws Exception
      {
          server = new HttpTestServer();
          server.start();
  
          testGetUrl("http://localhost:" + server.getHttpPort());
      }
  
      @Test
      public void testHttpClientAccessHttpsWithSSL() throws Exception
      {
          server = new SslTestServer();
          server.start();
  
          testGetUrl("https://localhost:" + server.getHttpPort());
      }
  
      @Test
      public void testHttpClientAccessHttpsWithSSLv3Only() throws Exception
      {
          server = new SslTestServer("SSLv3");
         server.start();
 
         testGetUrl("https://localhost:" + server.getHttpPort());
     }
 
     @Test
     public void testHttpClientAccessHttpsWithTLSv1Only() throws Exception
     {
         server = new SslTestServer("TLSv1");
         server.start();
 
         testGetUrl("https://localhost:" + server.getHttpPort());
     }
 
     @Test (expected = ResponseProtocolException.class)
     public void testHttpClientAccessFailsWithSSlv3OnTLSv1() throws Exception
     {
         server = new SslTestServer("TLSv1");
         server.start();
 
         try
         {
             System.setProperty("https.protocols", "SSLv3");
             HttpClientRequest request = requestFactory.createRequest(Request.MethodType.GET, ("http://localhost:" + server.getHttpPort()));
             request.execute(checkResponseHandler);
         }
         finally
         {
             System.clearProperty("https.protocols");
         }
     }
 
     @Test (expected = ResponseProtocolException.class)
     public void testHttpClientAccessFailsWithTLSv1OnSSLv3() throws Exception
     {
         server = new SslTestServer("SSLv3");
         server.start();
 
         try
         {
             System.setProperty("https.protocols", "TLSv1");
             HttpClientRequest request = requestFactory.createRequest(Request.MethodType.GET, ("http://localhost:" + server.getHttpPort()));
             request.execute(checkResponseHandler);
         }
         finally
         {
             System.clearProperty("https.protocols");
         }
     }
 
     @Test
     public void testReusingRequestWithAndWithoutSSL() throws Exception
     {
         server = new HttpTestServer();
         server.start();
 
         HttpClientRequest request = requestFactory.createRequest(Request.MethodType.GET, ("http://localhost:" + server.getHttpPort()));
         request.execute(checkResponseHandler);
 
         server.stop();
         server = new SslTestServer("SSLv3");
         server.start();
 
         request.setUrl("https://localhost:" + server.getHttpPort());
         request.execute(checkResponseHandler);
     }
 
     @Test
     public void testRedirectToSSLv3() throws Exception
     {
         HttpTestServer targetServer = new SslTestServer("SSLv3");
         server = new HttpRedirectTestServer(targetServer, "localhost");
         server.start();
 
         try
         {
             targetServer.start();
 
             testGetUrl("http://localhost:" + server.getHttpPort());
         }
         finally
         {
             targetServer.stop();
         }
     }
 
     @Test
     public void testRedirectFromSSLv3() throws Exception
     {
         HttpTestServer targetServer = new HttpTestServer();
         server = new SslTestServer("SSLv3").handler(new RedirectMockHandler(targetServer, "localhost"));
         server.start();
 
         try
         {
             targetServer.start();
 
             testGetUrl("https://localhost:" + server.getHttpPort());
         }
         finally
         {
             targetServer.stop();
         }
     }
 
     @Test
     public void testRedirectFromTLSv1ToSSLv3() throws Exception
     {
         HttpTestServer targetServer = new SslTestServer("SSLv3");
 
         server = new SslTestServer("TLSv1").handler(new RedirectMockHandler(targetServer, "localhost"));
         server.start();
         try
         {
             targetServer.start();
 
             testGetUrl("https://localhost:" + server.getHttpPort());
         }
         finally
         {
             targetServer.stop();
         }
     }
 
     @Test
     public void verifyRedirectSucceedsWithRedirectsUptoTheDefaultThreshold() throws Exception
     {
         // attempt to redirect the request as many times as the default allows
         server = new RedirectingHttpServer(HttpClientRequest.MAX_REDIRECTS);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test
     public void verifyRedirectSucceedsWithRedirectsWithinTheDefaultThreshold() throws Exception
     {
         // attempt to redirect the request as fewer times than the default allows
         server = new RedirectingHttpServer(HttpClientRequest.MAX_REDIRECTS - 1);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test(expected = ResponseProtocolException.class)
     public void verifyRedirectFailsWithRedirectsMoreThanTheDefaultThreshold() throws Exception
     {
         // attempt to redirect 1 more time than the default allows
         server = new RedirectingHttpServer(HttpClientRequest.MAX_REDIRECTS + 1);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test(expected = ResponseProtocolException.class)
     public void verifyRedirectFailsWithRedirectsMoreThanLoweredThreshold() throws Exception
     {
         // reduce the allowed redirects below the default.
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "1");
 
         // attempt to redirect the default number of times
         server = new RedirectingHttpServer(HttpClientRequest.MAX_REDIRECTS);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test(expected = ResponseProtocolException.class)
     public void verifyRedirectFailsWithRedirectsMoreThanRaisedThreshold() throws Exception
     {
         // increase the allowed redirects
         int allowedRedirects = HttpClientRequest.MAX_REDIRECTS + 1;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + allowedRedirects);
 
         // attempt to redirect the default number of times
         server = new RedirectingHttpServer(allowedRedirects + 1);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test
     public void verifyRedirectSucceedsWithRedirectsUpTpRaisedThreshold() throws Exception
     {
         // increase the number of allowed redirects.
         int allowedRedirects = HttpClientRequest.MAX_REDIRECTS + 1;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + allowedRedirects);
 
         // try and redirect up to the new threshold.
         server = new RedirectingHttpServer(allowedRedirects);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test
     public void verifyRedirectSucceedsWithRedirectsWithinRaisedThreshold() throws Exception
     {
         // increase the number of allowed redirects.
         int allowedRedirects = HttpClientRequest.MAX_REDIRECTS + 1;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + allowedRedirects);
 
         // try and redirect within the new threshold.
         server = new RedirectingHttpServer(allowedRedirects - 1);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test
     public void verifyRedirectSucceedsWithRedirectsWithinLoweredThreshold() throws Exception
     {
         // increase the number of allowed redirects.
         int allowedRedirects = HttpClientRequest.MAX_REDIRECTS - 1;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + allowedRedirects);
 
         // try and redirect within the new threshold.
         server = new RedirectingHttpServer(allowedRedirects - 1);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test(expected = ResponseProtocolException.class)
     public void verifyRedirectFailsSensiblyWithZeroThreshold() throws Exception
     {
         // increase the number of allowed redirects.
         int allowedRedirects = 0;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + allowedRedirects);
 
         // try and redirect above the new threshold.
         server = new RedirectingHttpServer(1);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     @Test(expected = ResponseProtocolException.class)
     public void verifyRedirectFailsSensiblyWithNegativeThreshold() throws Exception
     {
         // increase the number of allowed redirects.
         int allowedRedirects = -1;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + allowedRedirects);
 
         // try and redirect up to the new threshold.
         server = new RedirectingHttpServer(2);
 
         server.start();
         testGetUrl("http://localhost:" + server.getHttpPort());
     }
 
     private ResponseHandler<HttpClientResponse> checkResponseHandler = new ResponseHandler<HttpClientResponse>()
     {
         @Override
         public void handle(HttpClientResponse response) throws ResponseException
         {
             assertEquals(200, response.getStatusCode());
             try
             {
                 assertEquals(HttpTestServer.RESPONSE, IOUtils.toString(response.getResponseBodyAsStream(), "UTF-8"));
             } catch (IOException e)
             {
                 fail("Failed to read response body: " + e.getMessage());
             }
         }
     };
 
     private void testGetUrl(String url) throws Exception
     {
         requestFactory.createRequest(Request.MethodType.GET, url).execute(checkResponseHandler);
     }
 
     private class HttpTestServer
     {
         public static final int HTTP_PORT = 0;
         public static final String RESPONSE = "Response body";
 
         private Server server;
         private String responseBody;
         private Handler handler;
 
         public void start() throws Exception
         {
             configureServer();
             startServer();
         }
 
         private void startServer() throws Exception
         {
             server.start();
         }
 
         protected void configureServer()
         {
             server = new Server(HTTP_PORT);
             server.setHandler(getHandler());
         }
 
         public int getHttpPort()
         {
             return server.getConnectors()[0].getLocalPort();
         }
 
         public Handler getHandler()
         {
             if (handler != null)
             {
                 return handler;
             }
 
             return new AbstractHandler()
             {
                 @Override
                 public void handle(final String s, final org.eclipse.jetty.server.Request request, final HttpServletRequest httpServletRequest, final HttpServletResponse response)
                         throws IOException, ServletException
                 {
                     setResponseBody(RESPONSE);
                     response.setStatus(200);
                     response.setContentType("text/plain;charset=utf-8");
                     write(getResponseBody(), response.getOutputStream());
                     request.setHandled(true);
                 }
             };
         }
 
         public void stop() throws Exception
         {
             server.stop();
         }
 
         public void setResponseBody(String responseBody)
         {
             this.responseBody = responseBody;
         }
 
         public String getResponseBody()
         {
             return responseBody;
         }
 
         protected Server getServer()
         {
             return server;
         }
 
         public HttpTestServer handler(Handler handler)
         {
             this.handler = handler;
             return this;
         }
     }
 
     private class RedirectingHttpServer extends HttpTestServer
     {
         private final int maxRedirects;
 
         public RedirectingHttpServer(int maxRedirects)
         {
             this.maxRedirects = maxRedirects;
         }
         public Handler getHandler()
         {
             return new RedirectMockHandler(this, "localhost", maxRedirects);
         }
     }
 
     public class SslTestServer extends HttpTestServer
     {
         private static final int HTTPS_PORT = 0;
 
         private final Set<String> excludedProtocols = Sets.newHashSet("TLSv1", "SSLv3", "SSLv2Hello");
         private final String includeProtocols;
 
         private Connector secureConnector;
 
         public SslTestServer()
         {
             includeProtocols = "TLSv1,SSLv3,SSLv2Hello";
         }
 
         public SslTestServer(String includeProtocols)
         {
             this.includeProtocols = includeProtocols;
         }
 
         @Override
         protected void configureServer()
         {
             super.configureServer();
             secureConnector = createSecureConnector();
             getServer().addConnector(secureConnector);
         }
 
         private Connector createSecureConnector()
         {
 
             SslContextFactory sslContextFactory = new SslContextFactory();
             URL keystoreUrl = getClass().getClassLoader().getResource("keystore");
             sslContextFactory.setKeyStorePath(keystoreUrl.getFile());
             sslContextFactory.setKeyStorePassword("changeit");
             String[] includes = includeProtocols.split(",");
 
             excludedProtocols.removeAll(Arrays.asList(includes));
             sslContextFactory.setExcludeProtocols(excludedProtocols.toArray(new String[excludedProtocols.size()]));
             sslContextFactory.setIncludeProtocols(includes);
 
             SslSocketConnector connector = new SslSocketConnector(sslContextFactory);
             connector.setPort(HTTPS_PORT);
 
             return connector;
         }
 
         @Override
         public int getHttpPort()
         {
             return secureConnector.getLocalPort();
         }
 
         public Handler getHandler()
         {
             final Handler handler = super.getHandler();
             return new AbstractHandler()
             {
                 @Override
                 public void handle(final String s, final org.eclipse.jetty.server.Request request, final HttpServletRequest httpServletRequest, final HttpServletResponse response)
                         throws IOException, ServletException
                 {
                     assertEquals("localhost:" + getHttpPort(), httpServletRequest.getHeader("Host"));
                     handler.handle(s, request, httpServletRequest, response);
                 }
             };
         }
     }
 
     /**
      * Provides all secure socket factories, with a socket that ignores
      * certificate problems (e.g. self-signed certificate).
      */
     private static final class GullibleTrustProvider extends Provider
     {
         private static String previousAlgorithm;
         private static final String TRUST_PROVIDER_ALGORITHM = "GullibleTrustAlgorithm";
         private static final String TRUST_PROVIDER_ID = "GullibleTrustProvider";
 
         protected GullibleTrustProvider()
         {
             super(TRUST_PROVIDER_ID, 1.0, "provides all secure socket factories by ignoring problems in the chain of certificate trust");
 
             AccessController.doPrivileged(new PrivilegedAction()
             {
                 public Object run()
                 {
                     put("TrustManagerFactory." + GullibleTrustManagerFactory
                             .getAlgorithm(), GullibleTrustManagerFactory.class.getName());
                     return null;
                 }
             });
         }
 
         public static void install()
         {
             if (Security.getProvider(TRUST_PROVIDER_ID) == null)
             {
                 Security.insertProviderAt(new GullibleTrustProvider(), 2);
                 previousAlgorithm = Security.getProperty("ssl.TrustManagerFactory.algorithm");
                 Security.setProperty("ssl.TrustManagerFactory.algorithm", GullibleTrustManagerFactory.getAlgorithm());
             }
         }
 
         public static void uninstall()
         {
             if (Security.getProvider(TRUST_PROVIDER_ID) != null)
             {
                 Security.removeProvider(TRUST_PROVIDER_ID);
                 Security.setProperty("ssl.TrustManagerFactory.algorithm", previousAlgorithm);
             }
         }
 
         public final static class GullibleTrustManagerFactory extends TrustManagerFactorySpi
         {
             public GullibleTrustManagerFactory()
             {
             }
 
             protected void engineInit(ManagerFactoryParameters managerFactoryParameters)
             {
             }
 
             protected void engineInit(KeyStore keystore)
             {
             }
 
             protected TrustManager[] engineGetTrustManagers()
             {
                 return new TrustManager[]{
                         new X509TrustManager()
                         {
                             public X509Certificate[] getAcceptedIssuers()
                             {
                                 return null;
                             }
 
                             public void checkClientTrusted(X509Certificate[] certs, String authType)
                             {
                             }
 
                             public void checkServerTrusted(X509Certificate[] certs, String authType)
                             {
                             }
                         }
                 };
             }
 
             public static String getAlgorithm()
             {
                 return TRUST_PROVIDER_ALGORITHM;
             }
         }
     }
 
     private class HttpRedirectTestServer extends HttpTestServer
     {
         private HttpRedirectTestServer(HttpTestServer targetServer, String targetHostname) throws UnknownHostException
         {
             handler(new RedirectMockHandler(targetServer, targetHostname));
         }
     }
 
     private static class RedirectMockHandler extends AbstractHandler
     {
         private final String targetHostname;
         private final HttpTestServer targetServer;
         private final int maxRedirects;
         private int redirectsCount = 0;
 
         private RedirectMockHandler(HttpTestServer targetServer, String targetHostname) throws UnknownHostException
         {
             this(targetServer, targetHostname, 1);
         }
 
         private RedirectMockHandler(HttpTestServer targetServer, String targetHostname, int maxRedirects)
         {
             this.targetServer = targetServer;
             this.targetHostname = targetHostname;
             this.maxRedirects = maxRedirects;
         }
 
         @Override
         public void handle(final String target, final org.eclipse.jetty.server.Request baseRequest, final HttpServletRequest request, final HttpServletResponse response)
                 throws IOException, ServletException
         {
             if(redirectsCount >= maxRedirects)
             {
                 response.setStatus(200);
                 write(HttpTestServer.RESPONSE, response.getOutputStream());
             }
             else
             {
                 redirectsCount++;
                 response.setStatus(301);
                 String scheme = (targetServer instanceof SslTestServer) ? "https://" : "http://";
                 response.setHeader("Location", scheme + targetHostname + ":" + targetServer.getHttpPort());
                 write("Redirect", response.getOutputStream());
             }
 
             response.setContentType("text/plain;charset=utf-8");
             baseRequest.setHandled(true);
         }
     }
 }