/*
* 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.
*/
package org.apache.cocoon.webapps.session.context;
import java.io.IOException;
import java.io.StringReader;
import java.util.Enumeration;
import java.util.Map;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.Cookie;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.transformation.CIncludeTransformer;
import org.apache.cocoon.xml.IncludeXMLConsumer;
import org.apache.cocoon.xml.dom.DOMUtil;
import org.apache.commons.lang.BooleanUtils;
import org.apache.excalibur.source.SourceParameters;
import org.apache.excalibur.xml.sax.SAXParser;
import org.apache.excalibur.xml.xpath.XPathProcessor;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.ext.LexicalHandler;
/**
* A SessionContext which encapsulates the current Request object.
*
* It is not allowed to change this context.
* The following paths are valid:
* /parameter - lists all parameters, parameter names build the
* elements with the value of the first parameter with
* this name as text node childs
* /parameter/<parameter_name> - one text node containing the value of the first
* parameter with this name
* /querystring - the querystring with a leading '?' or null (the querystring is only for GET)
*
* /parametervalues - same as /parameter but values are listed as described
* below and each value of a parameter is listed.
* <cinclude:parameters>
* <cinclude:parameter>
* <cinclude:name>parameter name</cinclude:name>
* <cinclude:value>parameter value</cinclude:value>
* </cinclude:parameter>
* ...
* <cinclude:parameter>
* <cinclude:name>parameter name</cinclude:name>
* <cinclude:value>parameter value</cinclude:value>
* </session:parameter>
* </cinclude:parameters>
* If a parameter has more than one value for each value a
* <cinclude:parameter/> block is generated.
* This output has the namespace of the CIncludeTransformer
* to use it as input for a <cinclude:includexml> command.
* /attributes - lists all attributes, attribute names build the elements
* with the values as childs
* /headers - lists all headers, header names build the elements
* with the values as text node childs
* /cookies ----- <cookie name="...">
* <comment/>
* <domain/>
* <maxAge/>
* <name/>
* <path/>
* <secure/>
* <value/>
* <version/>
* /characterEncoding
* /contentLength
* /contentType
* /protocol
* /remoteAddress
* /remoteHost
* /scheme
* /serverName
* /serverPort
* /method
* /contextPath
* /pathInfo
* /pathTranslated
* /remoteUser
* /requestedSessionId
* /requestURI
* /servletPath
* /isRequestedSessionIdFromCookie
* /isRequestedSessionIdFromCookie
* /isRequestedSessionIdValid
*
* The following attributes of the servlet api 2.2 are missing:
* - getUserPrincipal()
* - getLocale()
* - getLocales()
* - getAuthType()
*
* @author <a href="mailto:cziegeler@s-und-n.de">Carsten Ziegeler</a>
* @deprecated This block is deprecated and will be removed in future versions.
* @version CVS $Id$
*/
public final class RequestSessionContext
implements SessionContext {
private static final String PARAMETERS_ELEMENT = "cinclude:" + CIncludeTransformer.CINCLUDE_PARAMETERS_ELEMENT;
private static final String PARAMETER_ELEMENT = "cinclude:" + CIncludeTransformer.CINCLUDE_PARAMETER_ELEMENT;
private static final String NAME_ELEMENT = "cinclude:" + CIncludeTransformer.CINCLUDE_NAME_ELEMENT;
private static final String VALUE_ELEMENT = "cinclude:" + CIncludeTransformer.CINCLUDE_VALUE_ELEMENT;
/** The logger. */
protected Logger logger;
/** Name of this context */
private String name;
/** The current {@link org.apache.cocoon.environment.Request} */
transient private Request request;
/** The content of this context */
private Document contextData;
/** The XPath Processor */
private XPathProcessor xpathProcessor;
public RequestSessionContext(Logger logger) {
this.logger = logger;
}
/**
* Setup this context
*/
public void setup(String value, String loadResource, String saveResource) {
this.name = value;
}
/**
* Set the Request
*/
public void setup(Map objectModel, ServiceManager manager, XPathProcessor processor)
throws ProcessingException {
this.xpathProcessor = processor;
this.request = ObjectModelHelper.getRequest(objectModel);
contextData = DOMUtil.createDocument();
contextData.appendChild(contextData.createElementNS(null, "context"));
Element root = contextData.getDocumentElement();
SAXParser parser = null;
try {
parser = (SAXParser) manager.lookup( SAXParser.ROLE );
this.buildParameterXML(root, parser);
} catch (ServiceException ce) {
throw new ProcessingException("Unable to lookup parser.", ce);
} finally {
manager.release(parser );
}
this.buildAttributesXML(root);
this.buildMiscXML(root);
this.buildCookiesXML(root);
this.buildHeadersXML(root);
}
/**
* Get the name of the context
*/
public String getName() {
return this.name;
}
/**
* Get the request object
*/
public Request getRequest() {
return this.request;
}
/**
* Build path
*/
private String createPath(String path) {
if (path == null) path = "/";
if (path.startsWith("/") == false) path = "/" + path;
path = "/context" + path;
if (path.endsWith("/") == true) path = path.substring(0, path.length() - 1);
return path;
}
private Node createTextNode(Document doc, String value) {
return doc.createTextNode(value != null ? value : "");
}
/**
* Build attributes XML
*/
private void buildMiscXML(Element root) {
Document doc = root.getOwnerDocument();
Element node;
node = doc.createElementNS(null, "characterEncoding");
node.appendChild(this.createTextNode(doc, this.request.getCharacterEncoding()));
root.appendChild(node);
node = doc.createElementNS(null, "contentLength");
node.appendChild(this.createTextNode(doc, "" + this.request.getContentLength()));
root.appendChild(node);
node = doc.createElementNS(null, "contentType");
node.appendChild(this.createTextNode(doc, this.request.getContentType()));
root.appendChild(node);
node = doc.createElementNS(null, "protocol");
node.appendChild(this.createTextNode(doc, this.request.getProtocol()));
root.appendChild(node);
node = doc.createElementNS(null, "remoteAddress");
node.appendChild(this.createTextNode(doc, this.request.getRemoteAddr()));
root.appendChild(node);
node = doc.createElementNS(null, "remoteHost");
node.appendChild(this.createTextNode(doc, this.request.getRemoteHost()));
root.appendChild(node);
node = doc.createElementNS(null, "scheme");
node.appendChild(this.createTextNode(doc, this.request.getScheme()));
root.appendChild(node);
node = doc.createElementNS(null, "serverName");
node.appendChild(this.createTextNode(doc, this.request.getServerName()));
root.appendChild(node);
node = doc.createElementNS(null, "serverPort");
node.appendChild(this.createTextNode(doc, ""+this.request.getServerPort()));
root.appendChild(node);
node = doc.createElementNS(null, "method");
node.appendChild(this.createTextNode(doc, this.request.getMethod()));
root.appendChild(node);
node = doc.createElementNS(null, "contextPath");
node.appendChild(this.createTextNode(doc, this.request.getContextPath()));
root.appendChild(node);
node = doc.createElementNS(null, "pathInfo");
node.appendChild(this.createTextNode(doc, this.request.getPathInfo()));
root.appendChild(node);
node = doc.createElementNS(null, "pathTranslated");
node.appendChild(this.createTextNode(doc, this.request.getPathTranslated()));
root.appendChild(node);
node = doc.createElementNS(null, "remoteUser");
node.appendChild(this.createTextNode(doc, this.request.getRemoteUser()));
root.appendChild(node);
node = doc.createElementNS(null, "requestedSessionId");
node.appendChild(this.createTextNode(doc, this.request.getRequestedSessionId()));
root.appendChild(node);
node = doc.createElementNS(null, "requestURI");
node.appendChild(this.createTextNode(doc, this.request.getRequestURI()));
root.appendChild(node);
node = doc.createElementNS(null, "servletPath");
node.appendChild(this.createTextNode(doc, this.request.getServletPath()));
root.appendChild(node);
node = doc.createElementNS(null, "isRequestedSessionIdFromCookie");
node.appendChild(doc.createTextNode(BooleanUtils.toStringTrueFalse(this.request.isRequestedSessionIdFromCookie())));
root.appendChild(node);
node = doc.createElementNS(null, "isRequestedSessionIdFromURL");
node.appendChild(doc.createTextNode(BooleanUtils.toStringTrueFalse(this.request.isRequestedSessionIdFromURL())));
root.appendChild(node);
node = doc.createElementNS(null, "isRequestedSessionIdValid");
node.appendChild(doc.createTextNode(BooleanUtils.toStringTrueFalse(this.request.isRequestedSessionIdValid())));
root.appendChild(node);
}
/**
* Build attributes XML
*/
private void buildAttributesXML(Element root)
throws ProcessingException {
Document doc = root.getOwnerDocument();
Element attrElement = doc.createElementNS(null, "attributes");
String attrName;
Element attr;
root.appendChild(attrElement);
Enumeration all = this.request.getAttributeNames();
while (all.hasMoreElements() == true) {
attrName = (String) all.nextElement();
try {
attr = doc.createElementNS(null, attrName);
attrElement.appendChild(attr);
DOMUtil.valueOf(attr, this.request.getAttribute(attrName));
} catch (DOMException de) {
// Some request attributes have names that are invalid as element names.
// Example : "FOM JavaScript GLOBAL SCOPE/file://my/path/to/flow/script.js"
this.logger.info("RequestSessionContext: Cannot create XML element from request attribute '" + attrName + "' : " + de.getMessage());
}
}
}
/**
* Build cookies XML
*/
private void buildCookiesXML(Element root) {
Document doc = root.getOwnerDocument();
Element cookiesElement = doc.createElementNS(null, "cookies");
root.appendChild(cookiesElement);
Cookie[] cookies = this.request.getCookies();
if (cookies != null) {
Cookie current;
Element node;
Element parent;
for(int i = 0; i < cookies.length; i++) {
current = cookies[i];
parent = doc.createElementNS(null, "cookie");
parent.setAttributeNS(null, "name", current.getName());
cookiesElement.appendChild(parent);
node = doc.createElementNS(null, "comment");
node.appendChild(this.createTextNode(doc, current.getComment()));
parent.appendChild(node);
node = doc.createElementNS(null, "domain");
node.appendChild(this.createTextNode(doc, current.getDomain()));
parent.appendChild(node);
node = doc.createElementNS(null, "maxAge");
node.appendChild(this.createTextNode(doc, "" + current.getMaxAge()));
parent.appendChild(node);
node = doc.createElementNS(null, "name");
node.appendChild(this.createTextNode(doc, current.getName()));
parent.appendChild(node);
node = doc.createElementNS(null, "path");
node.appendChild(this.createTextNode(doc, current.getPath()));
parent.appendChild(node);
node = doc.createElementNS(null, "secure");
node.appendChild(doc.createTextNode(BooleanUtils.toStringTrueFalse(current.getSecure())));
parent.appendChild(node);
node = doc.createElementNS(null, "value");
node.appendChild(this.createTextNode(doc, current.getValue()));
parent.appendChild(node);
node = doc.createElementNS(null, "version");
node.appendChild(this.createTextNode(doc, "" + current.getVersion()));
parent.appendChild(node);
}
}
}
/**
* Build headers XML
*/
private void buildHeadersXML(Element root) {
Document doc = root.getOwnerDocument();
Element headersElement = doc.createElementNS(null, "headers");
String headerName;
Element header;
root.appendChild(headersElement);
Enumeration all = this.request.getHeaderNames();
while (all.hasMoreElements() == true) {
headerName = (String) all.nextElement();
try {
header = doc.createElementNS(null, headerName);
headersElement.appendChild(header);
header.appendChild(this.createTextNode(doc, this.request.getHeader(headerName)));
} catch (Exception ignore) {
// if the header name is not a valid element name, we simply ignore it
}
}
}
/**
* Build parameter XML
*/
private void buildParameterXML(Element root, SAXParser parser) {
Document doc = root.getOwnerDocument();
// include all parameters
// process "/parameter" and "/parametervalues" at the same time
Element parameterElement = doc.createElementNS(null, "parameter");
Element parameterValuesElement = doc.createElementNS(null, "parametervalues");
root.appendChild(parameterElement);
root.appendChild(parameterValuesElement);
String parameterName = null;
Enumeration pars = this.request.getParameterNames();
Element parameter;
Element element;
Node valueNode;
String[] values;
String parValue;
element = doc.createElementNS(CIncludeTransformer.CINCLUDE_NAMESPACE_URI, PARAMETERS_ELEMENT);
element.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:cinclude", CIncludeTransformer.CINCLUDE_NAMESPACE_URI);
parameterValuesElement.appendChild(element);
parameterValuesElement = element;
while (pars.hasMoreElements() == true) {
parameterName = (String)pars.nextElement();
values = this.request.getParameterValues(parameterName);
for(int i = 0; i < values.length; i++) {
// this is a fast test, if the parameter value contains xml!
parValue = values[i].trim();
if (parValue.length() > 0 && parValue.charAt(0) == '<') {
try {
valueNode = DOMUtil.getDocumentFragment(parser, new StringReader(parValue));
valueNode = doc.importNode(valueNode, true);
} catch (Exception noXMLException) {
valueNode = doc.createTextNode(parValue);
}
} else {
valueNode = doc.createTextNode(parValue);
}
// create "/parameter" entry for first value
if (i == 0) {
try {
parameter = doc.createElementNS(null, parameterName);
parameter.appendChild(valueNode);
parameterElement.appendChild(parameter);
} catch (Exception local) {
// the exception is ignored and only this parameters is ignored
}
}
try {
// create "/parametervalues" entry
element = doc.createElementNS(CIncludeTransformer.CINCLUDE_NAMESPACE_URI, PARAMETER_ELEMENT);
parameterValuesElement.appendChild(element);
parameter = element;
element = doc.createElementNS(CIncludeTransformer.CINCLUDE_NAMESPACE_URI, NAME_ELEMENT);
parameter.appendChild(element);
element.appendChild(doc.createTextNode(parameterName));
element = doc.createElementNS(CIncludeTransformer.CINCLUDE_NAMESPACE_URI, VALUE_ELEMENT);
parameter.appendChild(element);
element.appendChild(valueNode.cloneNode(true));
} catch (Exception local) {
// the exception is ignored and only this parameters is ignored
}
}
}
// and now the query string
element = doc.createElementNS(null, "querystring");
root.appendChild(element);
String value = request.getQueryString();
if (value != null) {
element.appendChild(doc.createTextNode('?' + value));
}
}
/**
* Get the XML from the request object
*/
public DocumentFragment getXML(String path)
throws ProcessingException {
if (path == null || path.charAt(0) != '/') {
throw new ProcessingException("Not a valid XPath: " + path);
}
path = this.createPath(path);
DocumentFragment result = null;
NodeList list;
try {
list = DOMUtil.selectNodeList(this.contextData, path, this.xpathProcessor);
} catch (javax.xml.transform.TransformerException localException) {
throw new ProcessingException("Exception: " + localException, localException);
}
if (list != null && list.getLength() > 0) {
result = DOMUtil.getOwnerDocument(contextData).createDocumentFragment();
for(int i = 0; i < list.getLength(); i++) {
// the found node is either an attribute or an element
if (list.item(i).getNodeType() == Node.ATTRIBUTE_NODE) {
// if it is an attribute simple create a new text node with the value of the attribute
result.appendChild(DOMUtil.getOwnerDocument(contextData).createTextNode(list.item(i).getNodeValue()));
} else {
// now we have an element
// copy all children of this element in the resulting tree
NodeList childs = list.item(i).getChildNodes();
if (childs != null) {
for(int m = 0; m < childs.getLength(); m++) {
result.appendChild(DOMUtil.getOwnerDocument(contextData).importNode(childs.item(m), true));
}
}
}
}
}
return result;
}
/**
* Setting of xml is not possible for the request context
*/
public void setXML(String path, DocumentFragment fragment)
throws ProcessingException {
throw new ProcessingException("RequestSessionContext: Setting of xml not allowed");
}
/**
* Setting of xml is not possible for the request context
*/
public void setValueOfNode(String path, String value)
throws ProcessingException {
throw new ProcessingException("RequestSessionContext: Setting of xml not allowed");
}
/**
* Append a document fragment is not possible for the request context.
*/
public void appendXML(String path, DocumentFragment fragment)
throws ProcessingException {
throw new ProcessingException("RequestSessionContext: Appending of xml not allowed");
}
/**
* Removing is not possible for the request context.
*/
public void removeXML(String path)
throws ProcessingException {
throw new ProcessingException("RequestSessionContext: Removing of xml not allowed");
}
/**
* Set a context attribute. If value is null the attribute is removed.
*/
public void setAttribute(String key, Object value)
throws ProcessingException {
if (value == null) {
this.request.removeAttribute(key);
} else {
this.request.setAttribute(key, value);
}
}
/**
* Get a context attribute. If the attribute is not available return null
*/
public Object getAttribute(String key)
throws ProcessingException {
return this.request.getAttribute(key);
}
/**
* Get a context attribute. If the attribute is not available the defaultObject is returned
*/
public Object getAttribute(String key, Object defaultObject)
throws ProcessingException {
Object obj = this.getAttribute(key);
return (obj != null ? obj : defaultObject);
}
/**
* Get a copy the first node specified by the path.
*/
public Node getSingleNode(String path)
throws ProcessingException {
path = this.createPath(path);
Node node = null;
try {
node = DOMUtil.getSingleNode(this.contextData, path, this.xpathProcessor);
} catch (javax.xml.transform.TransformerException localException) {
throw new ProcessingException("Exception: " + localException, localException);
}
return node;
}
/**
* Get a copy all the nodes specified by the path.
*/
public NodeList getNodeList(String path)
throws ProcessingException {
path = this.createPath(path);
NodeList list = null;
try {
list = DOMUtil.selectNodeList(this.contextData, path, this.xpathProcessor);
} catch (javax.xml.transform.TransformerException localException) {
throw new ProcessingException("Exception: " + localException, localException);
}
return list;
}
/**
* Set the value of a node. The node is copied before insertion.
*/
public void setNode(String path, Node node)
throws ProcessingException {
throw new ProcessingException("RequestSessionContext: Setting of XML not allowed");
}
/**
* Get the value of this node. This is similiar to the xsl:value-of
* function. If the node does not exist, <code>null</code> is returned.
*/
public String getValueOfNode(String path)
throws ProcessingException {
String value = null;
Node node = this.getSingleNode(path);
if (node != null) {
value = DOMUtil.getValueOfNode(node);
}
return value;
}
/**
* Stream the XML directly to the handler. This streams the contents of getXML()
* to the given handler without creating a DocumentFragment containing a copy
* of the data
*/
public boolean streamXML(String path,
ContentHandler contentHandler,
LexicalHandler lexicalHandler)
throws SAXException, ProcessingException {
boolean result = false;
NodeList list;
try {
list = DOMUtil.selectNodeList(this.contextData, this.createPath(path), this.xpathProcessor);
} catch (javax.xml.transform.TransformerException local) {
throw new ProcessingException("TransformerException: " + local, local);
}
if (list != null && list.getLength() > 0) {
result = true;
for(int i = 0; i < list.getLength(); i++) {
// the found node is either an attribute or an element
if (list.item(i).getNodeType() == Node.ATTRIBUTE_NODE) {
// if it is an attribute simple create a new text node with the value of the attribute
String value = list.item(i).getNodeValue();
contentHandler.characters(value.toCharArray(), 0, value.length());
} else {
// now we have an element
// stream all children of this element to the resulting tree
NodeList childs = list.item(i).getChildNodes();
if (childs != null) {
for(int m = 0; m < childs.getLength(); m++) {
IncludeXMLConsumer.includeNode(childs.item(m), contentHandler, lexicalHandler);
}
}
}
}
}
return result;
}
/**
* Get the request parameter as xml
*/
public DocumentFragment getParameterAsXML(final String parameterName)
throws ProcessingException {
return this.getXML("/parameter/"+parameterName);
}
/**
* Get the request parameter as a String
*/
public String getParameter(final String parameterName) {
return this.request.getParameter(parameterName);
}
/**
* Try to load XML into the context.
* If the context does not provide the ability of loading,
* an exception is thrown.
*/
public void loadXML(String path,
SourceParameters parameters)
throws SAXException, ProcessingException, IOException {
throw new ProcessingException("The context " + this.name + " does not support loading.");
}
/**
* Try to save XML from the context.
* If the context does not provide the ability of saving,
* an exception is thrown.
*/
public void saveXML(String path,
SourceParameters parameters)
throws SAXException, ProcessingException, IOException {
throw new ProcessingException("The context " + this.name + " does not support saving.");
}
}