From f13e2cb5b190f25e86d0c5a5a9b020e804d523f0 Mon Sep 17 00:00:00 2001 From: bdc34 Date: Fri, 12 Mar 2010 19:32:09 +0000 Subject: [PATCH] Adding ContentType for working with accept header. --- .../mannlib/vitro/webapp/web/ContentType.java | 753 ++++++++++++++++++ .../vitro/webapp/web/MiscWebUtils.java | 51 +- 2 files changed, 788 insertions(+), 16 deletions(-) create mode 100644 webapp/src/edu/cornell/mannlib/vitro/webapp/web/ContentType.java diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/web/ContentType.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/web/ContentType.java new file mode 100644 index 000000000..f1f850710 --- /dev/null +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/web/ContentType.java @@ -0,0 +1,753 @@ +package edu.cornell.mannlib.vitro.webapp.web; + +/* Copyright (c) 2008 Google Inc. +* +* Licensed 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. +*/ + +/* + * The code in this file is from the Google data API project 1.40.3 on 2010-03-08. + * See full license from gdata at bottom of this file. + * The Vitro project only uses the method getBestContentType(). + */ + +//package com.google.gdata.util; + +//import com.google.gdata.client.Service; + +import java.io.Serializable; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** +* Simple class for parsing and generating Content-Type header values, per +* RFC 2045 (MIME) and 2616 (HTTP 1.1). +* +* +*/ +public class ContentType implements Serializable { + + private static String TOKEN = + "[\\p{ASCII}&&[^\\p{Cntrl} ;/=\\[\\]\\(\\)\\<\\>\\@\\,\\:\\\"\\?\\=]]+"; + + // Precisely matches a token + private static Pattern TOKEN_PATTERN = Pattern.compile( + "^" + TOKEN + "$"); + + // Matches a media type value + private static Pattern TYPE_PATTERN = Pattern.compile( + "(" + TOKEN + ")" + // type (G1) + "/" + // separator + "(" + TOKEN + ")" + // subtype (G2) + "\\s*(.*)\\s*", Pattern.DOTALL); + + // Matches an attribute value + private static Pattern ATTR_PATTERN = Pattern.compile( + "\\s*;\\s*" + + "(" + TOKEN + ")" + // attr name (G1) + "\\s*=\\s*" + + "(?:" + + "\"([^\"]*)\"" + // value as quoted string (G3) + "|" + + "(" + TOKEN + ")?" + // value as token (G2) + ")" + ); + + /** + * Name of the attribute that contains the encoding character set for + * the content type. + * @see #getCharset() + */ + public static final String ATTR_CHARSET = "charset"; + + /** + * Special "*" character to match any type or subtype. + */ + private static final String STAR = "*"; + + /** + * The UTF-8 charset encoding is used by default for all text and xml + * based MIME types. + */ + private static final String DEFAULT_CHARSET = ATTR_CHARSET + "=UTF-8"; + + /** + * A ContentType constant that describes the base unqualified Atom content + * type. + */ + public static final ContentType ATOM = + new ContentType("application/atom+xml;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the qualified Atom entry content + * type. + * + * @see #getAtomEntry() + */ + public static final ContentType ATOM_ENTRY = + new ContentType("application/atom+xml;type=entry;" + DEFAULT_CHARSET) + .lock(); + + /** + * A ContentType constant that describes the qualified Atom feed content + * type. + * + * @see #getAtomFeed() + */ + public static final ContentType ATOM_FEED = + new ContentType("application/atom+xml;type=feed;" + DEFAULT_CHARSET) + .lock(); + + /** + * Returns the ContentType that should be used in contexts that expect + * an Atom entry. + */ + public static ContentType getAtomEntry() { + // Use the unqualifed type for v1, the qualifed one for later versions + //return Service.getVersion().isCompatible(Service.Versions.V1) ? + // ATOM : ATOM_ENTRY; + return ATOM_ENTRY; + } + + /** + * Returns the ContentType that should be used in contexts that expect + * an Atom feed. + */ + public static ContentType getAtomFeed() { + // Use the unqualified type for v1, the qualified one for later versions + //return Service.getVersion().isCompatible(Service.Versions.V1) ? + // ATOM : ATOM_FEED; + return ATOM_FEED; + } + + /** + * A ContentType constant that describes the Atom Service content type. + */ + public static final ContentType ATOM_SERVICE = + new ContentType("application/atomsvc+xml;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the RSS channel/item content type. + */ + public static final ContentType RSS = + new ContentType("application/rss+xml;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the JSON content type. + */ + public static final ContentType JSON = + new ContentType("application/json;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the Javascript content type. + */ + public static final ContentType JAVASCRIPT = + new ContentType("text/javascript;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the generic text/xml content type. + */ + public static final ContentType TEXT_XML = + new ContentType("text/xml;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the generic text/html content type. + */ + public static final ContentType TEXT_HTML = + new ContentType("text/html;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the generic text/plain content type. + */ + public static final ContentType TEXT_PLAIN = + new ContentType("text/plain;" + DEFAULT_CHARSET).lock(); + + /** + * A ContentType constant that describes the GData error content type. + */ + public static final ContentType GDATA_ERROR = + new ContentType("application/vnd.google.gdata.error+xml").lock(); + + /** + * A ContentType constant that describes the OpenSearch description document + */ + public static final ContentType OPENSEARCH = + new ContentType("application/opensearchdescription+xml").lock(); + + + /** + * A ContentType constant that describes the MIME multipart/related content + * type. + */ + public static final ContentType MULTIPART_RELATED = + new ContentType("multipart/related").lock(); + + /** + * A ContentType constant that describes the application/xml content + * type. + */ + public static final ContentType APPLICATION_XML = + new ContentType("application/xml").lock(); + + /** + * A ContentType constant that indicates that the body contains an + * encapsulated message, with the syntax of an RFC 822 email message. + */ + public static final ContentType MESSAGE_RFC822 = + new ContentType("message/rfc822").lock(); + + /** + * Wildcard content type that will match any MIME type + */ + public static final ContentType ANY = new ContentType("*/*").lock(); + + /** + * Determines the best "Content-Type" header to use in a servlet response + * based on the "Accept" header from a servlet request. + * + * @param acceptHeader "Accept" header value from a servlet request (not + * null) + * @param actualContentTypes actual content types in descending order of + * preference (non-empty, and each entry is of the + * form "type/subtype" without the wildcard char + * '*') or null if no "Accept" header + * was specified + * @return the best content type to use (or null on no match). + */ + public static ContentType getBestContentType(String acceptHeader, + List actualContentTypes) { + + // If not accept header is specified, return the first actual type + if (acceptHeader == null) { + return actualContentTypes.get(0); + } + + // iterate over all of the accepted content types to find the best match + float bestQ = 0; + ContentType bestContentType = null; + String[] acceptedTypes = acceptHeader.split(","); + for (String acceptedTypeString : acceptedTypes) { + + // create the content type object + ContentType acceptedContentType; + try { + acceptedContentType = new ContentType(acceptedTypeString.trim()); + } catch (IllegalArgumentException ex) { + // ignore exception + continue; + } + + // parse the "q" value (default of 1) + float curQ = 1; + try { + String qAttr = acceptedContentType.getAttribute("q"); + if (qAttr != null) { + float qValue = Float.valueOf(qAttr); + if (qValue <= 0 || qValue > 1) { + continue; + } + curQ = qValue; + } + } catch (NumberFormatException ex) { + // ignore exception + continue; + } + + // only check it if it's at least as good ("q") as the best one so far + if (curQ < bestQ) { + continue; + } + + /* iterate over the actual content types in order to find the best match + to the current accepted content type */ + for (ContentType actualContentType : actualContentTypes) { + + /* if the "q" value is the same as the current best, only check for + better content types */ + if (curQ == bestQ && bestContentType == actualContentType) { + break; + } + + /* check if the accepted content type matches the current actual + content type */ + if (actualContentType.match(acceptedContentType)) { + bestContentType = actualContentType; + bestQ = curQ; + break; + } + } + } + + // if found an acceptable content type, return the best one + if (bestQ != 0) { + return bestContentType; + } + + // Return null if no match + return null; + } + +/** + * Constructs a new instance with default media type + */ + public ContentType() { + this(null); + } + + /** + * Constructs a new instance from a content-type header value + * parsing the MIME content type (RFC2045) format. If the type + * is {@code null}, then media type and charset will be + * initialized to default values. + * + * @param typeHeader content type value in RFC2045 header format. + */ + public ContentType(String typeHeader) { + + // If the type header is no provided, then use the HTTP defaults. + if (typeHeader == null) { + type = "application"; + subType = "octet-stream"; + attributes.put(ATTR_CHARSET, "iso-8859-1"); // http default + return; + } + + // Get type and subtype + Matcher typeMatch = TYPE_PATTERN.matcher(typeHeader); + if (!typeMatch.matches()) { + throw new IllegalArgumentException("Invalid media type:" + typeHeader); + } + + type = typeMatch.group(1).toLowerCase(); + subType = typeMatch.group(2).toLowerCase(); + if (typeMatch.groupCount() < 3) { + return; + } + + // Get attributes (if any) + Matcher attrMatch = ATTR_PATTERN.matcher(typeMatch.group(3)); + while (attrMatch.find()) { + + String value = attrMatch.group(2); + if (value == null) { + value = attrMatch.group(3); + if (value == null) { + value = ""; + } + } + + attributes.put(attrMatch.group(1).toLowerCase(), value); + } + + // Infer a default charset encoding if unspecified. + if (!attributes.containsKey(ATTR_CHARSET)) { + inferredCharset = true; + if (subType.endsWith("xml")) { + if (type.equals("application")) { + // BUGBUG: Actually have need to look at the raw stream here, but + // if client omitted the charset for "application/xml", they are + // ignoring the STRONGLY RECOMMEND language in RFC 3023, sec 3.2. + // I have little sympathy. + attributes.put(ATTR_CHARSET, "utf-8"); // best guess + } else { + attributes.put(ATTR_CHARSET, "us-ascii"); // RFC3023, sec 3.1 + } + } else if (subType.equals("json")) { + attributes.put(ATTR_CHARSET, "utf-8"); // RFC4627, sec 3 + } else { + attributes.put(ATTR_CHARSET, "iso-8859-1"); // http default + } + } + } + + /** {@code true} if parsed input didn't contain charset encoding info */ + private boolean inferredCharset = false; + + /** If set to {@code true}, the object is immutable. */ + private boolean locked; + + private String type; + public String getType() { return type; } + public void setType(String type) { + assertNotLocked(); + this.type = type; + } + + + private String subType; + public String getSubType() { return subType; } + public void setSubType(String subType) { + assertNotLocked(); + this.subType = subType; + } + + /** Returns the full media type */ + public String getMediaType() { + StringBuilder sb = new StringBuilder(); + sb.append(type); + sb.append("/"); + sb.append(subType); + if (attributes.containsKey("type")) { + sb.append(";type=").append(attributes.get("type")); + } + return sb.toString(); + } + + private HashMap attributes = new HashMap(); + + /** + * Makes the object immutable and returns it. + * + * This should at least be used when keeping a {@link ContentType} instance as + * a static. + */ + public ContentType lock() { + locked = true; + return this; + } + + private void assertNotLocked() { + if (locked) { + throw new IllegalStateException("Unmodifiable instance"); + } + } + + /** + * Returns the additional attributes of the content type. + */ + public Map getAttributes() { + if (locked) { + return Collections.unmodifiableMap(attributes); + } + return attributes; + } + + /** + * Returns the additional attribute by name of the content type. + * + * @param name attribute name + */ + public String getAttribute(String name) { + return attributes.get(name); + } + + /* + * Returns the charset attribute of the content type or null if the + * attribute has not been set. + */ + public String getCharset() { return attributes.get(ATTR_CHARSET); } + + + /** + * Returns whether this content type is match by the content type found in the + * "Accept" header field of an HTTP request. + * + *

For atom content type, this method will check the optional attribute + * 'type'. If the type attribute is set in both this and {@code + * acceptedContentType}, then they must be the same. That is, {@code + * application/atom+xml} will match both {@code + * application/atom+xml;type=feed} and {@code + * application/atom+xml;type=entry}, but {@code + * application/atom+xml;type=entry} will not match {@code + * application/atom+xml;type=feed}.a + * + * @param acceptedContentType content type found in the "Accept" header field + * of an HTTP request + */ + public boolean match(ContentType acceptedContentType) { + String acceptedType = acceptedContentType.getType(); + String acceptedSubType = acceptedContentType.getSubType(); + return STAR.equals(acceptedType) || type.equals(acceptedType) + && (STAR.equals(acceptedSubType) || subType.equals(acceptedSubType)) + && (!isAtom() || matchAtom(acceptedContentType)); + } + + /** Returns true if this is an atom content type. */ + private boolean isAtom() { + return "application".equals(type) && "atom+xml".equals(subType); + } + + /** + * Compares the optional 'type' attribute of two content types. + * + *

This method accepts atom content type without the 'type' attribute + * but if the types are specified, they must match. + */ + private boolean matchAtom(ContentType acceptedContentType) { + String atomType = getAttribute("type"); + String acceptedAtomType = acceptedContentType.getAttribute("type"); + + return atomType == null || acceptedAtomType == null + || atomType.equals(acceptedAtomType); + } + + /** + * Generates the Content-Type value + */ + @Override + public String toString() { + + StringBuffer sb = new StringBuffer(); + sb.append(type); + sb.append("/"); + sb.append(subType); + for (String name : attributes.keySet()) { + + // Don't include any inferred charset attribute in output. + if (inferredCharset && ATTR_CHARSET.equals(name)) { + continue; + } + sb.append(";"); + sb.append(name); + sb.append("="); + String value = attributes.get(name); + Matcher tokenMatcher = TOKEN_PATTERN.matcher(value); + if (tokenMatcher.matches()) { + sb.append(value); + } else { + sb.append("\"" + value + "\""); + } + } + return sb.toString(); + } + + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + ContentType that = (ContentType) o; + return type.equals(that.type) && subType.equals(that.subType) && attributes + .equals(that.attributes); + } + + + @Override + public int hashCode() { + return (type.hashCode() * 31 + subType.hashCode()) * 31 + attributes + .hashCode(); + } +} +/* + + +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, +and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by +the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all +other entities that control, are controlled by, or are under common +control with that entity. For the purposes of this definition, +"control" means (i) the power, direct or indirect, to cause the +direction or management of such entity, whether by contract or +otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity +exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, +including but not limited to software source code, documentation +source, and configuration files. + +"Object" form shall mean any form resulting from mechanical +transformation or translation of a Source form, including but +not limited to compiled object code, generated documentation, +and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or +Object form, made available under the License, as indicated by a +copyright notice that is included in or attached to the work +(an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object +form, that is based on (or derived from) the Work and for which the +editorial revisions, annotations, elaborations, or other modifications +represent, as a whole, an original work of authorship. For the purposes +of this License, Derivative Works shall not include works that remain +separable from, or merely link (or bind by name) to the interfaces of, +the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including +the original version of the Work and any modifications or additions +to that Work or Derivative Works thereof, that is intentionally +submitted to Licensor for inclusion in the Work by the copyright owner +or by an individual or Legal Entity authorized to submit on behalf of +the copyright owner. For the purposes of this definition, "submitted" +means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, +and issue tracking systems that are managed by, or on behalf of, the +Licensor for the purpose of discussing and improving the Work, but +excluding communication that is conspicuously marked or otherwise +designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity +on behalf of whom a Contribution has been received by Licensor and +subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the +Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +(except as stated in this section) patent license to make, have made, +use, offer to sell, sell, import, and otherwise transfer the Work, +where such license applies only to those patent claims licensable +by such Contributor that are necessarily infringed by their +Contribution(s) alone or by combination of their Contribution(s) +with the Work to which such Contribution(s) was submitted. If You +institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work +or a Contribution incorporated within the Work constitutes direct +or contributory patent infringement, then any patent licenses +granted to You under this License for that Work shall terminate +as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the +Work or Derivative Works thereof in any medium, with or without +modifications, and in Source or Object form, provided that You +meet the following conditions: + +(a) You must give any other recipients of the Work or +Derivative Works a copy of this License; and + +(b) You must cause any modified files to carry prominent notices +stating that You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works +that You distribute, all copyright, patent, trademark, and +attribution notices from the Source form of the Work, +excluding those notices that do not pertain to any part of +the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its +distribution, then any Derivative Works that You distribute must +include a readable copy of the attribution notices contained +within such NOTICE file, excluding those notices that do not +pertain to any part of the Derivative Works, in at least one +of the following places: within a NOTICE text file distributed +as part of the Derivative Works; within the Source form or +documentation, if provided along with the Derivative Works; or, +within a display generated by the Derivative Works, if and +wherever such third-party notices normally appear. The contents +of the NOTICE file are for informational purposes only and +do not modify the License. You may add Your own attribution +notices within Derivative Works that You distribute, alongside +or as an addendum to the NOTICE text from the Work, provided +that such additional attribution notices cannot be construed +as modifying the License. + +You may add Your own copyright statement to Your modifications and +may provide additional or different license terms and conditions +for use, reproduction, or distribution of Your modifications, or +for any such Derivative Works as a whole, provided Your use, +reproduction, and distribution of the Work otherwise complies with +the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, +any Contribution intentionally submitted for inclusion in the Work +by You to the Licensor shall be under the terms and conditions of +this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify +the terms of any separate license agreement you may have executed +with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade +names, trademarks, service marks, or product names of the Licensor, +except as required for reasonable and customary use in describing the +origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or +agreed to in writing, Licensor provides the Work (and each +Contributor provides its Contributions) on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied, including, without limitation, any warranties or conditions +of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A +PARTICULAR PURPOSE. You are solely responsible for determining the +appropriateness of using or redistributing the Work and assume any +risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, +whether in tort (including negligence), contract, or otherwise, +unless required by applicable law (such as deliberate and grossly +negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, +incidental, or consequential damages of any character arising as a +result of this License or out of the use or inability to use the +Work (including but not limited to damages for loss of goodwill, +work stoppage, computer failure or malfunction, or any and all +other commercial damages or losses), even if such Contributor +has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing +the Work or Derivative Works thereof, You may choose to offer, +and charge a fee for, acceptance of support, warranty, indemnity, +or other liability obligations and/or rights consistent with this +License. However, in accepting such obligations, You may act only +on Your own behalf and on Your sole responsibility, not on behalf +of any other Contributor, and only if You agree to indemnify, +defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason +of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following +boilerplate notice, with the fields enclosed by brackets "[]" +replaced with your own identifying information. (Don't include +the brackets!) The text should be enclosed in the appropriate +comment syntax for the file format. We also recommend that a +file or class name and description of purpose be included on the +same "printed page" as the copyright notice for easier +identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed 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. + */ \ No newline at end of file diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/web/MiscWebUtils.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/web/MiscWebUtils.java index 24b4ac3f7..77a969ad7 100755 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/web/MiscWebUtils.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/web/MiscWebUtils.java @@ -2,21 +2,19 @@ package edu.cornell.mannlib.vitro.webapp.web; -import java.util.Enumeration; -import java.util.Properties; - -import javax.servlet.ServletRequest; -import javax.servlet.http.HttpServletRequest; -import javax.servlet.jsp.JspException; - -import org.apache.commons.lang.StringEscapeUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -import com.hp.hpl.jena.rdf.model.Model; -import com.hp.hpl.jena.rdf.model.impl.ModelCom; - -import edu.cornell.mannlib.vitro.webapp.auth.policy.JenaNetidPolicy.ContextSetup; +import java.util.Enumeration; +import java.util.Properties; + +import javax.servlet.ServletRequest; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.jsp.JspException; + +import org.apache.commons.lang.StringEscapeUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import com.hp.hpl.jena.rdf.model.Model; +import com.hp.hpl.jena.rdf.model.impl.ModelCom; public class MiscWebUtils { /** @@ -170,7 +168,28 @@ public class MiscWebUtils { } return rv; } - + + + public static void debugPrintHeaders(HttpServletRequest req){ + Enumeration hnames = req.getHeaderNames(); + while( hnames.hasMoreElements() ){ + String name = (String) hnames.nextElement(); + System.out.println("header " + name); + String value = req.getHeader(name); + System.out.println(" " + value); + Enumeration values = req.getHeaders(name); + if( values == null ){ + System.out.println(" enumeration was null"); + }else{ + System.out.println(" enumeration values"); + while( values.hasMoreElements() ){ + String val = (String) values.nextElement(); + System.out.println(" " + value); + } + } + } + } + /** This isfrom org.json.simple.JSONObject