throw new MalformedCookieException(                    "Unable to parse expiration date parameter: "                     + paramValue);            }        } else {            if (LOG.isDebugEnabled()) {                LOG.debug("Unrecognized cookie attribute: "                     + attribute.toString());            }        }    }        public Collection getValidDateFormats() {        return this.datepatterns;    }    public void setValidDateFormats(final Collection datepatterns) {        this.datepatterns = datepatterns;    }    /**      * Performs most common {@link Cookie} validation      *      * @param host the host from which the {@link Cookie} was received      * @param port the port from which the {@link Cookie} was received      * @param path the path from which the {@link Cookie} was received      * @param secure <tt>true</tt> when the {@link Cookie} was received using a      * secure connection      * @param cookie The cookie to validate.      * @throws MalformedCookieException if an exception occurs during      * validation      */        public void validate(String host, int port, String path,         boolean secure, final Cookie cookie)         throws MalformedCookieException {                    LOG.trace("enter CookieSpecBase.validate("            + "String, port, path, boolean, Cookie)");        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 (path.trim().equals("")) {            path = PATH_DELIM;        }        host = host.toLowerCase();        // check version        if (cookie.getVersion() < 0) {            throw new MalformedCookieException ("Illegal version number "                 + cookie.getValue());        }        // security check... we musn't allow the server to give us an        // invalid domain scope        // Validate the cookies domain attribute.  NOTE:  Domains without         // any dots are allowed to support hosts on private LANs that don't         // have DNS names.  Since they have no dots, to domain-match the         // request-host and domain must be identical for the cookie to sent         // back to the origin-server.        if (host.indexOf(".") >= 0) {            // Not required to have at least two dots.  RFC 2965.            // A Set-Cookie2 with Domain=ajax.com will be accepted.            // domain must match host            if (!host.endsWith(cookie.getDomain())) {                String s = cookie.getDomain();                if (s.startsWith(".")) {                    s = s.substring(1, s.length());                }                if (!host.equals(s)) {                     throw new MalformedCookieException(                        "Illegal domain attribute \"" + cookie.getDomain()                         + "\". Domain of origin: \"" + host + "\"");                }            }        } else {            if (!host.equals(cookie.getDomain())) {                throw new MalformedCookieException(                    "Illegal domain attribute \"" + cookie.getDomain()                     + "\". Domain of origin: \"" + host + "\"");            }        }        // another security check... we musn't allow the server to give us a        // cookie that doesn't match this path        if (!path.startsWith(cookie.getPath())) {            throw new MalformedCookieException(                "Illegal path attribute \"" + cookie.getPath()                 + "\". Path of origin: \"" + path + "\"");        }    }    /**     * 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     * @param cookie {@link Cookie} to be matched     * @return true if the cookie matches the criterium     */    public boolean match(String host, int port, String path,         boolean secure, final Cookie cookie) {                    LOG.trace("enter CookieSpecBase.match("            + "String, int, String, boolean, Cookie");                    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 (cookie == null) {            throw new IllegalArgumentException("Cookie may not be null");        }        if (path.trim().equals("")) {            path = PATH_DELIM;        }        host = host.toLowerCase();        if (cookie.getDomain() == null) {            LOG.warn("Invalid cookie state: domain not specified");            return false;        }        if (cookie.getPath() == null) {            LOG.warn("Invalid cookie state: path not specified");            return false;        }                return            // only add the cookie if it hasn't yet expired             (cookie.getExpiryDate() == null                 || cookie.getExpiryDate().after(new Date()))            // and the domain pattern matches             && (domainMatch(host, cookie.getDomain()))            // and the path is null or matching            && (pathMatch(path, cookie.getPath()))            // and if the secure flag is set, only if the request is             // actually secure             && (cookie.getSecure() ? secure : true);          }    /**     * Performs domain-match as implemented in common browsers.     * @param host The target host.     * @param domain The cookie domain attribute.     * @return true if the specified host matches the given domain.     */    public boolean domainMatch(final String host, String domain) {        if (host.equals(domain)) {            return true;        }        if (!domain.startsWith(".")) {            domain = "." + domain;        }        return host.endsWith(domain) || host.equals(domain.substring(1));    }    /**     * Performs path-match as implemented in common browsers.     * @param path The target path.     * @param topmostPath The cookie path attribute.     * @return true if the paths match     */    public boolean pathMatch(final String path, final String topmostPath) {        boolean match = path.startsWith (topmostPath);        // if there is a match and these values are not exactly the same we have        // to make sure we're not matcing "/foobar" and "/foo"        if (match && path.length() != topmostPath.length()) {            if (!topmostPath.endsWith(PATH_DELIM)) {                match = (path.charAt(topmostPath.length()) == PATH_DELIM_CHAR);            }        }        return match;    }    /**     * Return an array of {@link Cookie}s that 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 (currently     * ignored)     * @param path the path to which the request is being submitted     * @param secure <tt>true</tt> if the request is using a secure protocol     * @param cookies an array of <tt>Cookie</tt>s to be matched     * @return an array of <tt>Cookie</tt>s matching the criterium     */    public Cookie[] match(String host, int port, String path,         boolean secure, final Cookie cookies[]) {                    LOG.trace("enter CookieSpecBase.match("            + "String, int, String, boolean, Cookie[])");        if (cookies == null) {            return null;        }        List matching = new LinkedList();        for (int i = 0; i < cookies.length; i++) {            if (match(host, port, path, secure, cookies[i])) {                addInPathOrder(matching, cookies[i]);            }        }        return (Cookie[]) matching.toArray(new Cookie[matching.size()]);    }    /**     * Adds the given cookie into the given list in descending path order. That     * is, more specific path to least specific paths.  This may not be the     * fastest algorythm, but it'll work OK for the small number of cookies     * we're generally dealing with.     *     * @param list - the list to add the cookie to     * @param addCookie - the Cookie to add to list     */    private static void addInPathOrder(List list, Cookie addCookie) {        int i = 0;        for (i = 0; i < list.size(); i++) {            Cookie c = (Cookie) list.get(i);            if (addCookie.compare(addCookie, c) > 0) {                break;            }        }        list.add(i, addCookie);    }    /**     * Return a string suitable for sending in a <tt>"Cookie"</tt> header     * @param cookie a {@link Cookie} to be formatted as string     * @return a string suitable for sending in a <tt>"Cookie"</tt> header.     */    public String formatCookie(Cookie cookie) {        LOG.trace("enter CookieSpecBase.formatCookie(Cookie)");        if (cookie == null) {            throw new IllegalArgumentException("Cookie may not be null");        }        StringBuffer buf = new StringBuffer();        buf.append(cookie.getName());        buf.append("=");        String s = cookie.getValue();        if (s != null) {            buf.append(s);        }        return buf.toString();    }    /**     * Create a <tt>"Cookie"</tt> header value containing all {@link Cookie}s in     * <i>cookies</i> suitable for sending in a <tt>"Cookie"</tt> header     * @param cookies an array of {@link Cookie}s to be formatted     * @return a string suitable for sending in a Cookie header.     * @throws IllegalArgumentException if an input parameter is illegal     */    public String formatCookies(Cookie[] cookies)      throws IllegalArgumentException {        LOG.trace("enter CookieSpecBase.formatCookies(Cookie[])");        if (cookies == null) {            throw new IllegalArgumentException("Cookie array may not be null");        }        if (cookies.length == 0) {            throw new IllegalArgumentException("Cookie array may not be empty");        }        StringBuffer buffer = new StringBuffer();        for (int i = 0; i < cookies.length; i++) {            if (i > 0) {                buffer.append("; ");            }            buffer.append(formatCookie(cookies[i]));        }        return buffer.toString();    }    /**     * Create a <tt>"Cookie"</tt> {@link Header} containing all {@link Cookie}s     * in <i>cookies</i>.     * @param cookies an array of {@link Cookie}s to be formatted as a <tt>"     * Cookie"</tt> header     * @return a <tt>"Cookie"</tt> {@link Header}.     */    public Header formatCookieHeader(Cookie[] cookies) {        LOG.trace("enter CookieSpecBase.formatCookieHeader(Cookie[])");        return new Header("Cookie", formatCookies(cookies));    }    /**     * Create a <tt>"Cookie"</tt> {@link Header} containing the {@link Cookie}.     * @param cookie <tt>Cookie</tt>s to be formatted as a <tt>Cookie</tt>     * header     * @return a Cookie header.     */    public Header formatCookieHeader(Cookie cookie) {        LOG.trace("enter CookieSpecBase.formatCookieHeader(Cookie)");        return new Header("Cookie", formatCookie(cookie));    }}