jaxws/src/share/classes/com/sun/xml/internal/ws/transport/http/client/CookieJar.java - platform/libcore - Git at Google

 /*
  * Copyright 2005-2006 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.  Sun designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Sun in the LICENSE file that accompanied this code.
  *
  * 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.
  */

 package com.sun.xml.internal.ws.transport.http.client;

 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Vector;

 /**
  * Generic class to hold onto HTTP cookies.  Can record, retrieve, and
  * persistently store cookies associated with particular URLs.
  *
  * @author WS Development Team
  */
 public class CookieJar {

     // The representation of cookies is relatively simple right now:
     // a hash table with key being the domain and the value being
     // a vector of cookies for that domain.
     // REMIND: create this on demand in the future
     private transient Hashtable<String,Vector<HttpCookie>> cookieJar = new Hashtable<String, Vector<HttpCookie>>();

     /**
      * Create a new, empty cookie jar.
      */
     public CookieJar() {
     }

     /**
      * Records any cookies which have been sent as part of an HTTP response.
      * The connection parameter must be already have been opened, so that
      * the response headers are available.  It's ok to pass a non-HTTP
      * URL connection, or one which does not have any set-cookie headers.
      */


     public synchronized void recordAnyCookies(URLConnection connection) {

         HttpURLConnection httpConn = (HttpURLConnection) connection;
         String headerKey;

         for (int hi = 1;
             (headerKey = httpConn.getHeaderFieldKey(hi)) != null;
             hi++) {
             if (headerKey.equalsIgnoreCase("set-cookie")) {
                 String cookieValue = httpConn.getHeaderField(hi);

                 recordCookie(httpConn, cookieValue);
             }
         }
     }

     /**
      * Create a cookie from the cookie, and use the HttpURLConnection to
      * fill in unspecified values in the cookie with defaults.
      */
     private void recordCookie(HttpURLConnection httpConn, String cookieValue) {

         HttpCookie cookie = new HttpCookie(httpConn.getURL(), cookieValue);

         // First, check to make sure the cookie's domain matches the
         // server's, and has the required number of '.'s
         String twodot[] = { "com", "edu", "net", "org", "gov", "mil", "int" };
         String domain = cookie.getDomain();

         if (domain == null) {
             return;
         }

         domain = domain.toLowerCase();

         String host = httpConn.getURL().getHost();

         host = host.toLowerCase();

         boolean domainOK = host.equals(domain);

         if (!domainOK && host.endsWith(domain)) {
             int dotsNeeded = 2;

             for (int i = 0; i < twodot.length; i++) {
                 if (domain.endsWith(twodot[i])) {
                     dotsNeeded = 1;
                 }
             }

             int lastChar = domain.length();

             for (;(lastChar > 0) && (dotsNeeded > 0); dotsNeeded--) {
                 lastChar = domain.lastIndexOf('.', lastChar - 1);
             }

             if (lastChar > 0) {
                 domainOK = true;
             }
         }

         if (domainOK) {
             recordCookie(cookie);
         }
     }

     /**
      * Record the cookie in the in-memory container of cookies.  If there
      * is already a cookie which is in the exact same domain with the
      * exact same
      */
     private void recordCookie(HttpCookie cookie) {
         recordCookieToJar(cookie, cookieJar, true);
     }


     /**
      * Adds a Cookie for a given URL to the Cookie Jar.
      * <P>
      * New connections to the given URL will include the Cookie.
      * <P>
      * It allows to add Cookie information, to the Cookie jar, received
      * by other mean.
      * <P>
      *
      * @param url the URL to bind the Cookie to.
      *
      * @param cookieHeader String defining the Cookie:
      *        <P>
      *        &lt;name&gt;=&lt;value&gt;[;expires=<WHEN>]
      *        [;path=<PATH>][;domain=<DOMAIN>][;secure]
      *        <P>
      *        Refer to <A HREF=
      *          "http://home.netscape.com/newsref/std/cookie_spec.htm">
      *        Netscape Cookie specification</A> for the complete documentation.
      *
      */
     private void setCookie(URL url, String cookieHeader) {

         HttpCookie cookie = new HttpCookie(url, cookieHeader);

         this.recordCookie(cookie);
     }

     //
     // Records the given cookie to the desired jar.  If doNotify is true,
     // tell globals to inform interested parties.  It *only* makes since for
     // doNotify to be true if jar is the static jar (i.e. Cookies.cookieJar).
     //
     //
     private void recordCookieToJar(
         HttpCookie cookie,
         Hashtable<String,Vector<HttpCookie>> jar,
         boolean doNotify) {

         if (shouldRejectCookie(cookie)) {
             return;
         }

         String domain = cookie.getDomain().toLowerCase();
         Vector<HttpCookie> cookieList = jar.get(domain);

         if (cookieList == null) {
             cookieList = new Vector<HttpCookie>();
         }

         if (addOrReplaceCookie(cookieList, cookie, doNotify)) {
             jar.put(domain, cookieList);
         }
     }

     /**
      * Scans the vector of cookies looking for an exact match with the
      * given cookie.  Replaces it if there is one, otherwise adds
      * one at the end.  The vector is presumed to have cookies which all
      * have the same domain, so the domain of the cookie is not checked.
      * <p>
      * If doNotify is true, we'll do a vetoable notification of changing the
      * cookie.  This <b>only</b> makes since if the jar being operated on
      * is Cookies.cookieJar.
      * <p>
      * If this is called, it is assumed that the cookie jar is exclusively
      * held by the current thread.
      *
      * @return true if the cookie is actually set
      */
     private boolean addOrReplaceCookie(
         Vector<HttpCookie> cookies,
         final HttpCookie cookie,
         boolean doNotify) {

         int numCookies = cookies.size();
         String path = cookie.getPath();
         String name = cookie.getName();
         HttpCookie replaced = null;
         int replacedIndex = -1;

         for (int i = 0; i < numCookies; i++) {
             HttpCookie existingCookie = cookies.elementAt(i);
             String existingPath = existingCookie.getPath();

             if (path.equals(existingPath)) {
                 String existingName = existingCookie.getName();

                 if (name.equals(existingName)) {

                     // need to replace this one!
                     replaced = existingCookie;
                     replacedIndex = i;

                     break;
                 }
             }
         }

         // Do the replace
         if (replaced != null) {
             cookies.setElementAt(cookie, replacedIndex);
         } else {
             cookies.addElement(cookie);
         }

         return true;
     }

     /**
      * Predicate function which returns true if the cookie appears to be
      * invalid somehow and should not be added to the cookie set.
      */
     private boolean shouldRejectCookie(HttpCookie cookie) {

         // REMIND: implement per http-state-mgmt Internet Draft
         return false;
     }

     // ab oct/17/01 - added synchronized
     public synchronized void applyRelevantCookies(URLConnection connection) {
         this.applyRelevantCookies(connection.getURL(), connection);
     }

     private void applyRelevantCookies(URL url, URLConnection connection) {

         HttpURLConnection httpConn = (HttpURLConnection) connection;
         String host = url.getHost();

         applyCookiesForHost(host, url, httpConn);

         // REMIND: should be careful about IP addresses here.
         int index;

         while ((index = host.indexOf('.', 1)) >= 0) {

             // trim off everything up to, and including the dot.
             host = host.substring(index + 1);

             applyCookiesForHost(host, url, httpConn);
         }
     }

     /**
      * Host may be a FQDN, or a partial domain name starting with a dot.
      * Adds any cookies which match the host and path to the
      * cookie set on the URL connection.
      */
     private void applyCookiesForHost(
         String host,
         URL url,
         HttpURLConnection httpConn) {

         //System.out.println("X0"+cookieJar.size());
         Vector<HttpCookie> cookieList = cookieJar.get(host);

         if (cookieList == null) {

             // Hax.debugln("no matching hosts" + host);
             return;
         }

         //System.out.println("X1"+cookieList.size());
         String path = url.getFile();
         int queryInd = path.indexOf('?');

         if (queryInd > 0) {

             // strip off the part following the ?
             path = path.substring(0, queryInd);
         }

         Enumeration<HttpCookie> cookies = cookieList.elements();
         Vector<HttpCookie> cookiesToSend = new Vector<HttpCookie>(10);

         while (cookies.hasMoreElements()) {
             HttpCookie cookie = cookies.nextElement();
             String cookiePath = cookie.getPath();

             if (path.startsWith(cookiePath)) {

                 // larrylf: Actually, my documentation (from Netscape)
                 // says that /foo should
                 // match /foobar and /foo/bar.  Yuck!!!
                 if (!cookie.hasExpired()) {
                     cookiesToSend.addElement(cookie);
                 }

                 /*
                    We're keeping this piece of commented out code around just in
                    case we decide to put it back.  the spec does specify the above.


                                 int cookiePathLen = cookiePath.length();

                                 // verify that /foo does not match /foobar by mistake
                                 if ((path.length() == cookiePathLen)
                                     || (path.length() > cookiePathLen &&
                                         path.charAt(cookiePathLen) == '/')) {

                                     // We have a matching cookie!

                                     if (!cookie.hasExpired()) {
                                         cookiesToSend.addElement(cookie);
                                     }
                                 }
                 */
             }
         }

         // Now, sort the cookies in most to least specific order
         // Yes, its the deaded bubblesort!!
         // (it should be a small vector, so perf is not an issue...)
         if (cookiesToSend.size() > 1) {
             for (int i = 0; i < cookiesToSend.size() - 1; i++) {
                 HttpCookie headC = cookiesToSend.elementAt(i);
                 String head = headC.getPath();

                 // This little excercise is a cheap way to get
                 // '/foo' to read more specfic then '/'
                 if (!head.endsWith("/")) {
                     head = head + "/";
                 }

                 for (int j = i + 1; j < cookiesToSend.size(); j++) {
                     HttpCookie scanC = cookiesToSend.elementAt(j);
                     String scan = scanC.getPath();

                     if (!scan.endsWith("/")) {
                         scan = scan + "/";
                     }

                     int headCount = 0;
                     int index = -1;

                     while ((index = head.indexOf('/', index + 1)) != -1) {
                         headCount++;
                     }

                     index = -1;

                     int scanCount = 0;

                     while ((index = scan.indexOf('/', index + 1)) != -1) {
                         scanCount++;
                     }

                     if (scanCount > headCount) {
                         cookiesToSend.setElementAt(headC, j);
                         cookiesToSend.setElementAt(scanC, i);

                         headC = scanC;
                         head = scan;
                     }
                 }
             }
         }

         // And send the sorted cookies...
         cookies = cookiesToSend.elements();

         String cookieStr = null;

         while (cookies.hasMoreElements()) {
             HttpCookie cookie = cookies.nextElement();

             if (cookieStr == null) {
                 cookieStr = cookie.getNameValue();
             } else {
                 cookieStr = cookieStr + "; " + cookie.getNameValue();
             }
         }

         if (cookieStr != null) {
             httpConn.setRequestProperty("Cookie", cookieStr);
         }
     }
 }
	/*
	* Copyright 2005-2006 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. Sun designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Sun in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	package com.sun.xml.internal.ws.transport.http.client;

	import java.net.HttpURLConnection;
	import java.net.URL;
	import java.net.URLConnection;
	import java.util.Enumeration;
	import java.util.Hashtable;
	import java.util.Vector;

	/**
	* Generic class to hold onto HTTP cookies. Can record, retrieve, and
	* persistently store cookies associated with particular URLs.
	*
	* @author WS Development Team
	*/
	public class CookieJar {

	// The representation of cookies is relatively simple right now:
	// a hash table with key being the domain and the value being
	// a vector of cookies for that domain.
	// REMIND: create this on demand in the future
	private transient Hashtable<String,Vector<HttpCookie>> cookieJar = new Hashtable<String, Vector<HttpCookie>>();

	/**
	* Create a new, empty cookie jar.
	*/
	public CookieJar() {
	}

	/**
	* Records any cookies which have been sent as part of an HTTP response.
	* The connection parameter must be already have been opened, so that
	* the response headers are available. It's ok to pass a non-HTTP
	* URL connection, or one which does not have any set-cookie headers.
	*/


	public synchronized void recordAnyCookies(URLConnection connection) {

	HttpURLConnection httpConn = (HttpURLConnection) connection;
	String headerKey;

	for (int hi = 1;
	(headerKey = httpConn.getHeaderFieldKey(hi)) != null;
	hi++) {
	if (headerKey.equalsIgnoreCase("set-cookie")) {
	String cookieValue = httpConn.getHeaderField(hi);

	recordCookie(httpConn, cookieValue);
	}
	}
	}

	/**
	* Create a cookie from the cookie, and use the HttpURLConnection to
	* fill in unspecified values in the cookie with defaults.
	*/
	private void recordCookie(HttpURLConnection httpConn, String cookieValue) {

	HttpCookie cookie = new HttpCookie(httpConn.getURL(), cookieValue);

	// First, check to make sure the cookie's domain matches the
	// server's, and has the required number of '.'s
	String twodot[] = { "com", "edu", "net", "org", "gov", "mil", "int" };
	String domain = cookie.getDomain();

	if (domain == null) {
	return;
	}

	domain = domain.toLowerCase();

	String host = httpConn.getURL().getHost();

	host = host.toLowerCase();

	boolean domainOK = host.equals(domain);

	if (!domainOK && host.endsWith(domain)) {
	int dotsNeeded = 2;

	for (int i = 0; i < twodot.length; i++) {
	if (domain.endsWith(twodot[i])) {
	dotsNeeded = 1;
	}
	}

	int lastChar = domain.length();

	for (;(lastChar > 0) && (dotsNeeded > 0); dotsNeeded--) {
	lastChar = domain.lastIndexOf('.', lastChar - 1);
	}

	if (lastChar > 0) {
	domainOK = true;
	}
	}

	if (domainOK) {
	recordCookie(cookie);
	}
	}

	/**
	* Record the cookie in the in-memory container of cookies. If there
	* is already a cookie which is in the exact same domain with the
	* exact same
	*/
	private void recordCookie(HttpCookie cookie) {
	recordCookieToJar(cookie, cookieJar, true);
	}


	/**
	* Adds a Cookie for a given URL to the Cookie Jar.
	* <P>
	* New connections to the given URL will include the Cookie.
	* <P>
	* It allows to add Cookie information, to the Cookie jar, received
	* by other mean.
	* <P>
	*
	* @param url the URL to bind the Cookie to.
	*
	* @param cookieHeader String defining the Cookie:
	* <P>
	* <name>=<value>[;expires=<WHEN>]
	* [;path=<PATH>][;domain=<DOMAIN>][;secure]
	* <P>
	* Refer to <A HREF=
	* "http://home.netscape.com/newsref/std/cookie_spec.htm">
	* Netscape Cookie specification</A> for the complete documentation.
	*
	*/
	private void setCookie(URL url, String cookieHeader) {

	HttpCookie cookie = new HttpCookie(url, cookieHeader);

	this.recordCookie(cookie);
	}

	//
	// Records the given cookie to the desired jar. If doNotify is true,
	// tell globals to inform interested parties. It only makes since for
	// doNotify to be true if jar is the static jar (i.e. Cookies.cookieJar).
	//
	//
	private void recordCookieToJar(
	HttpCookie cookie,
	Hashtable<String,Vector<HttpCookie>> jar,
	boolean doNotify) {

	if (shouldRejectCookie(cookie)) {
	return;
	}

	String domain = cookie.getDomain().toLowerCase();
	Vector<HttpCookie> cookieList = jar.get(domain);

	if (cookieList == null) {
	cookieList = new Vector<HttpCookie>();
	}

	if (addOrReplaceCookie(cookieList, cookie, doNotify)) {
	jar.put(domain, cookieList);
	}
	}

	/**
	* Scans the vector of cookies looking for an exact match with the
	* given cookie. Replaces it if there is one, otherwise adds
	* one at the end. The vector is presumed to have cookies which all
	* have the same domain, so the domain of the cookie is not checked.
	* <p>
	* If doNotify is true, we'll do a vetoable notification of changing the
	* cookie. This <b>only</b> makes since if the jar being operated on
	* is Cookies.cookieJar.
	* <p>
	* If this is called, it is assumed that the cookie jar is exclusively
	* held by the current thread.
	*
	* @return true if the cookie is actually set
	*/
	private boolean addOrReplaceCookie(
	Vector<HttpCookie> cookies,
	final HttpCookie cookie,
	boolean doNotify) {

	int numCookies = cookies.size();
	String path = cookie.getPath();
	String name = cookie.getName();
	HttpCookie replaced = null;
	int replacedIndex = -1;

	for (int i = 0; i < numCookies; i++) {
	HttpCookie existingCookie = cookies.elementAt(i);
	String existingPath = existingCookie.getPath();

	if (path.equals(existingPath)) {
	String existingName = existingCookie.getName();

	if (name.equals(existingName)) {

	// need to replace this one!
	replaced = existingCookie;
	replacedIndex = i;

	break;
	}
	}
	}

	// Do the replace
	if (replaced != null) {
	cookies.setElementAt(cookie, replacedIndex);
	} else {
	cookies.addElement(cookie);
	}

	return true;
	}

	/**
	* Predicate function which returns true if the cookie appears to be
	* invalid somehow and should not be added to the cookie set.
	*/
	private boolean shouldRejectCookie(HttpCookie cookie) {

	// REMIND: implement per http-state-mgmt Internet Draft
	return false;
	}

	// ab oct/17/01 - added synchronized
	public synchronized void applyRelevantCookies(URLConnection connection) {
	this.applyRelevantCookies(connection.getURL(), connection);
	}

	private void applyRelevantCookies(URL url, URLConnection connection) {

	HttpURLConnection httpConn = (HttpURLConnection) connection;
	String host = url.getHost();

	applyCookiesForHost(host, url, httpConn);

	// REMIND: should be careful about IP addresses here.
	int index;

	while ((index = host.indexOf('.', 1)) >= 0) {

	// trim off everything up to, and including the dot.
	host = host.substring(index + 1);

	applyCookiesForHost(host, url, httpConn);
	}
	}

	/**
	* Host may be a FQDN, or a partial domain name starting with a dot.
	* Adds any cookies which match the host and path to the
	* cookie set on the URL connection.
	*/
	private void applyCookiesForHost(
	String host,
	URL url,
	HttpURLConnection httpConn) {

	//System.out.println("X0"+cookieJar.size());
	Vector<HttpCookie> cookieList = cookieJar.get(host);

	if (cookieList == null) {

	// Hax.debugln("no matching hosts" + host);
	return;
	}

	//System.out.println("X1"+cookieList.size());
	String path = url.getFile();
	int queryInd = path.indexOf('?');

	if (queryInd > 0) {

	// strip off the part following the ?
	path = path.substring(0, queryInd);
	}

	Enumeration<HttpCookie> cookies = cookieList.elements();
	Vector<HttpCookie> cookiesToSend = new Vector<HttpCookie>(10);

	while (cookies.hasMoreElements()) {
	HttpCookie cookie = cookies.nextElement();
	String cookiePath = cookie.getPath();

	if (path.startsWith(cookiePath)) {

	// larrylf: Actually, my documentation (from Netscape)
	// says that /foo should
	// match /foobar and /foo/bar. Yuck!!!
	if (!cookie.hasExpired()) {
	cookiesToSend.addElement(cookie);
	}

	/*
	We're keeping this piece of commented out code around just in
	case we decide to put it back. the spec does specify the above.


	int cookiePathLen = cookiePath.length();

	// verify that /foo does not match /foobar by mistake
	if ((path.length() == cookiePathLen)
	\|\| (path.length() > cookiePathLen &&
	path.charAt(cookiePathLen) == '/')) {

	// We have a matching cookie!

	if (!cookie.hasExpired()) {
	cookiesToSend.addElement(cookie);
	}
	}
	*/
	}
	}

	// Now, sort the cookies in most to least specific order
	// Yes, its the deaded bubblesort!!
	// (it should be a small vector, so perf is not an issue...)
	if (cookiesToSend.size() > 1) {
	for (int i = 0; i < cookiesToSend.size() - 1; i++) {
	HttpCookie headC = cookiesToSend.elementAt(i);
	String head = headC.getPath();

	// This little excercise is a cheap way to get
	// '/foo' to read more specfic then '/'
	if (!head.endsWith("/")) {
	head = head + "/";
	}

	for (int j = i + 1; j < cookiesToSend.size(); j++) {
	HttpCookie scanC = cookiesToSend.elementAt(j);
	String scan = scanC.getPath();

	if (!scan.endsWith("/")) {
	scan = scan + "/";
	}

	int headCount = 0;
	int index = -1;

	while ((index = head.indexOf('/', index + 1)) != -1) {
	headCount++;
	}

	index = -1;

	int scanCount = 0;

	while ((index = scan.indexOf('/', index + 1)) != -1) {
	scanCount++;
	}

	if (scanCount > headCount) {
	cookiesToSend.setElementAt(headC, j);
	cookiesToSend.setElementAt(scanC, i);

	headC = scanC;
	head = scan;
	}
	}
	}
	}

	// And send the sorted cookies...
	cookies = cookiesToSend.elements();

	String cookieStr = null;

	while (cookies.hasMoreElements()) {
	HttpCookie cookie = cookies.nextElement();

	if (cookieStr == null) {
	cookieStr = cookie.getNameValue();
	} else {
	cookieStr = cookieStr + "; " + cookie.getNameValue();
	}
	}

	if (cookieStr != null) {
	httpConn.setRequestProperty("Cookie", cookieStr);
	}
	}
	}