/* * $HeadURL: https://svn.apache.org/repos/asf/jakarta/httpcomponents/oac.hc3x/tags/HTTPCLIENT_3_1/src/java/org/apache/commons/httpclient/cookie/RFC2965Spec.java $ * $Revision: 507134 $ * $Date: 2007-02-13 19:18:05 +0100 (Tue, 13 Feb 2007) $ *  * ==================================================================== * *  Licensed to the Apache Software Foundation (ASF) under one or more *  contributor license agreements.  See the NOTICE file distributed with *  this work for additional information regarding copyright ownership. *  The ASF licenses this file to You under the Apache License, Version 2.0 *  (the "License"); you may not use this file except in compliance with *  the License.  You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * *  Unless required by applicable law or agreed to in writing, software *  distributed under the License is distributed on an "AS IS" BASIS, *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *  See the License for the specific language governing permissions and *  limitations under the License. * ==================================================================== * * This software consists of voluntary contributions made by many * individuals on behalf of the Apache Software Foundation.  For more * information on the Apache Software Foundation, please see * <http://www.apache.org/>. * */package org.apache.commons.httpclient.cookie;import java.util.ArrayList;import java.util.Arrays;import java.util.Comparator;import java.util.Date;import java.util.HashMap;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.StringTokenizer;import org.apache.commons.httpclient.Cookie;import org.apache.commons.httpclient.Header;import org.apache.commons.httpclient.HeaderElement;import org.apache.commons.httpclient.NameValuePair;import org.apache.commons.httpclient.util.ParameterFormatter;/** * <p>RFC 2965 specific cookie management functions.</p> *  * @author jain.samit@gmail.com (Samit Jain) * * @since 3.1 */public class RFC2965Spec extends CookieSpecBase implements CookieVersionSupport {    private static final Comparator PATH_COMPOARATOR = new CookiePathComparator();        /**    * Cookie Response Header  name for cookies processed    * by this spec.    */    public final static String SET_COOKIE2_KEY = "set-cookie2";        /**    * used for formatting RFC 2956 style cookies    */    private final ParameterFormatter formatter;         /**     * Stores the list of attribute handlers     */    private final List attribHandlerList;        /**    * Stores attribute name -> attribute handler mappings    */    private final Map attribHandlerMap;    /**     * Fallback cookie spec (RFC 2109)     */    private final CookieSpec rfc2109;        /**      * Default constructor      * */    public RFC2965Spec() {        super();        this.formatter = new ParameterFormatter();        this.formatter.setAlwaysUseQuotes(true);        this.attribHandlerMap = new HashMap(10);                this.attribHandlerList = new ArrayList(10);        this.rfc2109 = new RFC2109Spec();                registerAttribHandler(Cookie2.PATH, new Cookie2PathAttributeHandler());        registerAttribHandler(Cookie2.DOMAIN, new Cookie2DomainAttributeHandler());        registerAttribHandler(Cookie2.PORT, new Cookie2PortAttributeHandler());        registerAttribHandler(Cookie2.MAXAGE, new Cookie2MaxageAttributeHandler());        registerAttribHandler(Cookie2.SECURE, new CookieSecureAttributeHandler());        registerAttribHandler(Cookie2.COMMENT, new CookieCommentAttributeHandler());        registerAttribHandler(Cookie2.COMMENTURL, new CookieCommentUrlAttributeHandler());        registerAttribHandler(Cookie2.DISCARD, new CookieDiscardAttributeHandler());        registerAttribHandler(Cookie2.VERSION, new Cookie2VersionAttributeHandler());    }    protected void registerAttribHandler(            final String name, final CookieAttributeHandler handler) {        if (name == null) {            throw new IllegalArgumentException("Attribute name may not be null");        }        if (handler == null) {            throw new IllegalArgumentException("Attribute handler may not be null");        }        if (!this.attribHandlerList.contains(handler)) {            this.attribHandlerList.add(handler);        }        this.attribHandlerMap.put(name, handler);    }        /**     * Finds an attribute handler {@link CookieAttributeHandler} for the     * given attribute. Returns <tt>null</tt> if no attribute handler is     * found for the specified attribute.     *     * @param name attribute name. e.g. Domain, Path, etc.     * @return an attribute handler or <tt>null</tt>     */    protected CookieAttributeHandler findAttribHandler(final String name) {        return (CookieAttributeHandler) this.attribHandlerMap.get(name);    }        /**     * Gets attribute handler {@link CookieAttributeHandler} for the     * given attribute.     *     * @param name attribute name. e.g. Domain, Path, etc.     * @throws IllegalStateException if handler not found for the     *          specified attribute.     */    protected CookieAttributeHandler getAttribHandler(final String name) {        CookieAttributeHandler handler = findAttribHandler(name);        if (handler == null) {            throw new IllegalStateException("Handler not registered for " +                                            name + " attribute.");        } else {            return handler;        }    }    protected Iterator getAttribHandlerIterator() {        return this.attribHandlerList.iterator();    }        /**     * Parses the Set-Cookie2 value into an array of <tt>Cookie</tt>s.     *     * <P>The syntax for the Set-Cookie2 response header is:     *     * <PRE>     * set-cookie      =    "Set-Cookie2:" cookies     * cookies         =    1#cookie     * cookie          =    NAME "=" VALUE * (";" cookie-av)     * NAME            =    attr     * VALUE           =    value     * cookie-av       =    "Comment" "=" value     *                 |    "CommentURL" "=" <"> http_URL <">     *                 |    "Discard"     *                 |    "Domain" "=" value     *                 |    "Max-Age" "=" value     *                 |    "Path" "=" value     *                 |    "Port" [ "=" <"> portlist <"> ]     *                 |    "Secure"     *                 |    "Version" "=" 1*DIGIT     * portlist        =       1#portnum     * portnum         =       1*DIGIT     * </PRE>     *     * @param host the host from which the <tt>Set-Cookie2</tt> value was     * received     * @param port the port from which the <tt>Set-Cookie2</tt> value was     * received     * @param path the path from which the <tt>Set-Cookie2</tt> value was     * received     * @param secure <tt>true</tt> when the <tt>Set-Cookie2</tt> value was     * received over secure conection     * @param header the <tt>Set-Cookie2</tt> <tt>Header</tt> received from the server     * @return an array of <tt>Cookie</tt>s parsed from the Set-Cookie2 value     * @throws MalformedCookieException if an exception occurs during parsing     */    public Cookie[] parse(            String host, int port, String path, boolean secure, final Header header)            throws MalformedCookieException {        LOG.trace("enter RFC2965.parse("                  + "String, int, String, boolean, Header)");        if (header == null) {            throw new IllegalArgumentException("Header may not be null.");        }        if (header.getName() == null) {            throw new IllegalArgumentException("Header name may not be null.");        }        if (header.getName().equalsIgnoreCase(SET_COOKIE2_KEY)) {            // parse cookie2 cookies            return parse(host, port, path, secure, header.getValue());        } else if (header.getName().equalsIgnoreCase(RFC2109Spec.SET_COOKIE_KEY)) {            // delegate parsing of old-style cookies to rfc2109Spec            return this.rfc2109.parse(host, port, path, secure, header.getValue());        } else {            throw new MalformedCookieException("Header name is not valid. " +                                               "RFC 2965 supports \"set-cookie\" " +                                               "and \"set-cookie2\" headers.");        }    }    /**     * @see #parse(String, int, String, boolean, org.apache.commons.httpclient.Header)     */    public Cookie[] parse(String host, int port, String path,                          boolean secure, final String header)            throws MalformedCookieException {        LOG.trace("enter RFC2965Spec.parse("                  + "String, int, String, boolean, String)");        // before we do anything, lets check validity of arguments        if (host == null) {            throw new IllegalArgumentException(                    "Host of origin may not be null");        }        if (host.trim().equals("")) {            throw new IllegalArgumentException(                    "Host of origin may not be blank");        }        if (port < 0) {            throw new IllegalArgumentException("Invalid port: " + port);        }        if (path == null) {            throw new IllegalArgumentException(                    "Path of origin may not be null.");        }        if (header == null) {            throw new IllegalArgumentException("Header may not be null.");        }        if (path.trim().equals("")) {            path = PATH_DELIM;        }        host = getEffectiveHost(host);        HeaderElement[] headerElements =                HeaderElement.parseElements(header.toCharArray());        List cookies = new LinkedList();        for (int i = 0; i < headerElements.length; i++) {            HeaderElement headerelement = headerElements[i];            Cookie2 cookie = null;            try {                cookie = new Cookie2(host,                                    headerelement.getName(),                                    headerelement.getValue(),                                    path,                                    null,                                    false,                                    new int[] {port});            } catch (IllegalArgumentException ex) {                throw new MalformedCookieException(ex.getMessage());            }            NameValuePair[] parameters = headerelement.getParameters();            // could be null. In case only a header element and no parameters.            if (parameters != null) {                // Eliminate duplicate attribues. The first occurence takes precedence                Map attribmap = new HashMap(parameters.length);                 for (int j = parameters.length - 1; j >= 0; j--) {                    NameValuePair param = parameters[j];                    attribmap.put(param.getName().toLowerCase(), param);                }                for (Iterator it = attribmap.entrySet().iterator(); it.hasNext(); ) {                    Map.Entry entry = (Map.Entry) it.next();                    parseAttribute((NameValuePair) entry.getValue(), cookie);                }            }            cookies.add(cookie);            // cycle through the parameters        }        return (Cookie[]) cookies.toArray(new Cookie[cookies.size()]);    }    /**     * Parse RFC 2965 specific cookie attribute and update the corresponsing     * {@link org.apache.commons.httpclient.Cookie} properties.     *     * @param attribute {@link org.apache.commons.httpclient.NameValuePair} cookie attribute from the     * <tt>Set-Cookie2</tt> header.     * @param cookie {@link org.apache.commons.httpclient.Cookie} to be updated     * @throws MalformedCookieException if an exception occurs during parsing     */    public void parseAttribute(            final NameValuePair attribute, final Cookie cookie)            throws MalformedCookieException {        if (attribute == null) {            throw new IllegalArgumentException("Attribute may not be null.");        }        if (attribute.getName() == null) {            throw new IllegalArgumentException("Attribute Name may not be null.");        }        if (cookie == null) {            throw new IllegalArgumentException("Cookie may not be null.");        }        final String paramName = attribute.getName().toLowerCase();        final String paramValue = attribute.getValue();        CookieAttributeHandler handler = findAttribHandler(paramName);        if (handler == null) {            // ignore unknown attribute-value pairs            if (LOG.isDebugEnabled())                LOG.debug("Unrecognized cookie attribute: " +                          attribute.toString());        } else {            handler.parse(cookie, paramValue);        }    }    /**     * Performs RFC 2965 compliant {@link org.apache.commons.httpclient.Cookie} validation     *     * @param host the host from which the {@link org.apache.commons.httpclient.Cookie} was received     * @param port the port from which the {@link org.apache.commons.httpclient.Cookie} was received     * @param path the path from which the {@link org.apache.commons.httpclient.Cookie} was received     * @param secure <tt>true</tt> when the {@link org.apache.commons.httpclient.Cookie} was received using a     * secure connection     * @param cookie The cookie to validate     * @throws MalformedCookieException if an exception occurs during     * validation     */    public void validate(final String host, int port, final String path,                         boolean secure, final Cookie cookie)            throws MalformedCookieException {        LOG.trace("enter RFC2965Spec.validate(String, int, String, "                  + "boolean, Cookie)");        if (cookie instanceof Cookie2) {            if (cookie.getName().indexOf(' ') != -1) {                throw new MalformedCookieException("Cookie name may not contain blanks");            }            if (cookie.getName().startsWith("$")) {                throw new MalformedCookieException("Cookie name may not start with $");            }            CookieOrigin origin = new CookieOrigin(getEffectiveHost(host), port, path, secure);             for (Iterator i = getAttribHandlerIterator(); i.hasNext(); ) {              CookieAttributeHandler handler = (CookieAttributeHandler) i.next();              handler.validate(cookie, origin);            }        } else {            // old-style cookies are validated according to the old rules            this.rfc2109.validate(host, port, path, secure, cookie);        }    }    /**     * Return <tt>true</tt> if the cookie should be submitted with a request     * with given attributes, <tt>false</tt> otherwise.     * @param host the host to which the request is being submitted     * @param port the port to which the request is being submitted (ignored)     * @param path the path to which the request is being submitted     * @param secure <tt>true</tt> if the request is using a secure connection     * @return true if the cookie matches the criterium     */    public boolean match(String host, int port, String path,                         boolean secure, final Cookie cookie) {