| /* |
| * Copyright 2002 Sun Microsystems, Inc. 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. |
| * |
| * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| |
| /** |
| * @test |
| * @bug 4769350 |
| * @library ../../../sun/net/www/httptest/ |
| * @build HttpCallback HttpServer ClosedChannelList HttpTransaction AbstractCallback |
| * @run main B4769350 server |
| * @run main B4769350 proxy |
| * @summary proxy authentication username and password caching only works in serial case |
| */ |
| |
| import java.io.*; |
| import java.net.*; |
| |
| public class B4769350 { |
| |
| static int count = 0; |
| static boolean error = false; |
| |
| static void read (InputStream is) throws IOException { |
| int c; |
| while ((c=is.read()) != -1) { |
| //System.out.write (c); |
| } |
| } |
| |
| static class Client extends Thread { |
| String authority, path; |
| boolean allowerror; |
| |
| Client (String authority, String path, boolean allowerror) { |
| this.authority = authority; |
| this.path = path; |
| this.allowerror = allowerror; |
| } |
| |
| public void run () { |
| try { |
| URI u = new URI ("http", authority, path, null, null); |
| URL url = u.toURL(); |
| URLConnection urlc = url.openConnection (); |
| InputStream is = urlc.getInputStream (); |
| read (is); |
| is.close(); |
| } catch (URISyntaxException e) { |
| System.out.println (e); |
| error = true; |
| } catch (IOException e) { |
| if (!allowerror) { |
| System.out.println (e); |
| error = true; |
| } |
| } |
| } |
| } |
| |
| static class CallBack extends AbstractCallback { |
| |
| void errorReply (HttpTransaction req, String reply) throws IOException { |
| req.addResponseHeader ("Connection", "close"); |
| req.addResponseHeader ("WWW-Authenticate", reply); |
| req.sendResponse (401, "Unauthorized"); |
| req.orderlyClose(); |
| } |
| |
| void proxyReply (HttpTransaction req, String reply) throws IOException { |
| req.addResponseHeader ("Proxy-Authenticate", reply); |
| req.sendResponse (407, "Proxy Authentication Required"); |
| } |
| |
| void okReply (HttpTransaction req) throws IOException { |
| req.setResponseEntityBody ("Hello ."); |
| req.sendResponse (200, "Ok"); |
| req.orderlyClose(); |
| } |
| |
| public void request (HttpTransaction req, int count) { |
| try { |
| URI uri = req.getRequestURI(); |
| String path = uri.getPath(); |
| if (path.endsWith ("/t1a")) { |
| doT1a (req, count); |
| } else if (path.endsWith ("/t1b")) { |
| doT1b (req, count); |
| } else if (path.endsWith ("/t1c")) { |
| doT1c (req, count); |
| } else if (path.endsWith ("/t1d")) { |
| doT1d (req, count); |
| } else if (path.endsWith ("/t2a")) { |
| doT2a (req, count); |
| } else if (path.endsWith ("/t2b")) { |
| doT2b (req, count); |
| } else if (path.endsWith ("/t3a")) { |
| doT3a (req, count); |
| } else if (path.endsWith ("/t3b")) { |
| doT3bc (req, count); |
| } else if (path.endsWith ("/t3c")) { |
| doT3bc (req, count); |
| } else { |
| System.out.println ("unexpected request URI"); |
| } |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| /* T1 tests the client by sending 4 requests to 2 different realms |
| * in parallel. The client should recognise two pairs of dependent requests |
| * and execute the first of each pair in parallel. When they both succeed |
| * the second requests should be executed without calling the authenticator. |
| * The test succeeds if the authenticator was only called twice. |
| */ |
| void doT1a (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| errorReply (req, "Basic realm=\"realm1\""); |
| HttpServer.rendezvous ("one", 2); |
| break; |
| case 1: |
| HttpServer.waitForCondition ("cond2"); |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| |
| |
| void doT1b (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| errorReply (req, "Basic realm=\"realm2\""); |
| HttpServer.rendezvous ("one", 2); |
| HttpServer.setCondition ("cond1"); |
| break; |
| case 1: |
| HttpServer.waitForCondition ("cond2"); |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| |
| void doT1c (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| errorReply (req, "Basic realm=\"realm1\""); |
| HttpServer.rendezvous ("two", 2); |
| break; |
| case 1: |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| |
| void doT1d (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| errorReply (req, "Basic realm=\"realm2\""); |
| HttpServer.rendezvous ("two", 2); |
| HttpServer.setCondition ("cond2"); |
| break; |
| case 1: |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| |
| |
| /* T2 tests to check that if initial authentication fails, the second will |
| * succeed, and the authenticator is called twice |
| */ |
| |
| void doT2a (HttpTransaction req, int count) throws IOException { |
| /* This will be called several times */ |
| if (count == 1) { |
| HttpServer.setCondition ("T2cond1"); |
| } |
| errorReply (req, "Basic realm=\"realm3\""); |
| } |
| |
| void doT2b (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| errorReply (req, "Basic realm=\"realm3\""); |
| break; |
| case 1: |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| |
| /* T3 tests proxy and server authentication. three threads request same |
| * resource at same time. Authenticator should be called once for server |
| * and once for proxy |
| */ |
| void doT3a (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| proxyReply (req, "Basic realm=\"proxy\""); |
| HttpServer.setCondition ("T3cond1"); |
| break; |
| case 1: |
| errorReply (req, "Basic realm=\"realm4\""); |
| break; |
| case 2: |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| |
| void doT3bc (HttpTransaction req, int count) throws IOException { |
| switch (count) { |
| case 0: |
| proxyReply (req, "Basic realm=\"proxy\""); |
| break; |
| case 1: |
| okReply (req); |
| break; |
| default: |
| System.out.println ("Unexpected request"); |
| } |
| } |
| }; |
| |
| static HttpServer server; |
| static MyAuthenticator auth = new MyAuthenticator (); |
| |
| static int redirects = 4; |
| |
| static Client c1,c2,c3,c4,c5,c6,c7,c8,c9; |
| |
| static void doServerTests (String authority) throws Exception { |
| System.out.println ("Doing Server tests"); |
| System.out.println ("T1"); |
| c1 = new Client (authority, "/test/realm1/t1a", false); |
| c2 = new Client (authority, "/test/realm2/t1b", false); |
| c3 = new Client (authority, "/test/realm1/t1c", false); |
| c4 = new Client (authority, "/test/realm2/t1d", false); |
| |
| c1.start(); c2.start(); |
| HttpServer.waitForCondition ("cond1"); |
| c3.start(); c4.start(); |
| c1.join(); c2.join(); c3.join(); c4.join(); |
| |
| int f = auth.getCount(); |
| if (f != 2) { |
| except ("Authenticator was called "+f+" times. Should be 2"); |
| } |
| if (error) { |
| except ("error occurred"); |
| } |
| |
| auth.resetCount(); |
| System.out.println ("T2"); |
| |
| c5 = new Client (authority, "/test/realm3/t2a", true); |
| c6 = new Client (authority, "/test/realm3/t2b", false); |
| c5.start (); |
| HttpServer.waitForCondition ("T2cond1"); |
| c6.start (); |
| c5.join(); c6.join(); |
| |
| f = auth.getCount(); |
| if (f != redirects+1) { |
| except ("Authenticator was called "+f+" times. Should be: " + redirects+1); |
| } |
| if (error) { |
| except ("error occurred"); |
| } |
| } |
| |
| static void doProxyTests (String authority) throws Exception { |
| System.out.println ("Doing Proxy tests"); |
| c7 = new Client (authority, "/test/realm4/t3a", false); |
| c8 = new Client (authority, "/test/realm4/t3b", false); |
| c9 = new Client (authority, "/test/realm4/t3c", false); |
| c7.start (); |
| HttpServer.waitForCondition ("T3cond1"); |
| c8.start (); |
| c9.start (); |
| c7.join(); c8.join(); c9.join(); |
| |
| int f = auth.getCount(); |
| if (f != 2) { |
| except ("Authenticator was called "+f+" times. Should be: " + 2); |
| } |
| if (error) { |
| except ("error occurred"); |
| } |
| } |
| |
| public static void main (String[] args) throws Exception { |
| System.setProperty ("http.maxRedirects", Integer.toString (redirects)); |
| System.setProperty ("http.auth.serializeRequests", "true"); |
| Authenticator.setDefault (auth); |
| boolean proxy = args[0].equals ("proxy"); |
| try { |
| server = new HttpServer (new CallBack(), 10, 1, 0); |
| System.out.println ("Server: listening on port: " + server.getLocalPort()); |
| if (proxy) { |
| System.setProperty ("http.proxyHost", "localhost"); |
| System.setProperty ("http.proxyPort",Integer.toString(server.getLocalPort())); |
| doProxyTests ("www.foo.com"); |
| } else { |
| doServerTests ("localhost:"+server.getLocalPort()); |
| } |
| server.terminate(); |
| |
| } catch (Exception e) { |
| if (server != null) { |
| server.terminate(); |
| } |
| throw e; |
| } |
| } |
| |
| static void pause (int millis) { |
| try { |
| Thread.sleep (millis); |
| } catch (InterruptedException e) {} |
| } |
| |
| public static void except (String s) { |
| server.terminate(); |
| throw new RuntimeException (s); |
| } |
| |
| static class MyAuthenticator extends Authenticator { |
| MyAuthenticator () { |
| super (); |
| } |
| |
| int count = 0; |
| |
| public PasswordAuthentication getPasswordAuthentication () { |
| //System.out.println ("Authenticator called: " + getRequestingPrompt()); |
| //try { |
| //Thread.sleep (1000); |
| //} catch (InterruptedException e) {} |
| PasswordAuthentication pw; |
| pw = new PasswordAuthentication ("user", "pass1".toCharArray()); |
| count ++; |
| return pw; |
| } |
| |
| public void resetCount () { |
| count = 0; |
| } |
| |
| public int getCount () { |
| return (count); |
| } |
| } |
| } |