* @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     * // BEGIN IA/HERITRIX CHANGES     * @deprecated use match(String, int, String, boolean, SortedMap)// END IA/HERITRIX CHANGES     */    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()]);    }//  BEGIN IA/HERITRIX CHANGES    /**     * Return an array of {@link Cookie}s that should be submitted with a     * request with given attributes, <tt>false</tt> otherwise.      *      * If the SortedMap comes from an HttpState and is not itself     * thread-safe, it may be necessary to synchronize on the HttpState     * instance to protect against concurrent modification.      *     * @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 SortedMap 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 SortedMap cookies) {                    LOG.trace("enter CookieSpecBase.match("           + "String, int, String, boolean, SortedMap)");        // TODO: skip meaningless 'narrowing' when host is a numeric IP        // (harmless in the meantime)                if (cookies == null) {            return null;        }        List matching = new LinkedList();        String narrowHost = host;        do {            Iterator iter = cookies.subMap(narrowHost,                    narrowHost + Cookie.DOMAIN_OVERBOUNDS).values().iterator();            while (iter.hasNext()) {                Cookie cookie = (Cookie) (iter.next());                if (match(host, port, path, secure, cookie)) {                    addInPathOrder(matching, cookie);                }            }            StoredIterator.close(iter);            int trimTo = narrowHost.indexOf('.', 1);            narrowHost = (trimTo < 0) ? null : narrowHost.substring(trimTo+1);        } while (narrowHost != null);        return (Cookie[]) matching.toArray(new Cookie[matching.size()]);     }//  END IA/HERITRIX CHANGES        /**     * 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));    }}