rfc2965spec.java

Light in the box 抓取程序。 使用HttpClient

/*
 * $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 [e-mail] (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) {