| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999-2003 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xalan" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 1999, Lotus |
| * Development Corporation., http://www.lotus.com. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| package servlet; |
| |
| import java.io.*; |
| import java.util.*; |
| import javax.servlet.*; |
| import javax.servlet.http.*; |
| import java.net.URL; |
| import java.net.MalformedURLException; |
| import java.net.URLConnection; |
| import javax.xml.transform.OutputKeys; |
| |
| import org.apache.xalan.templates.Constants; |
| import org.apache.xalan.templates.StylesheetRoot; |
| import org.apache.xalan.templates.OutputProperties; |
| // SAX2 Imports |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.Locator; |
| import org.xml.sax.helpers.XMLReaderFactory; |
| import org.xml.sax.ext.DeclHandler; |
| import org.xml.sax.ext.LexicalHandler; |
| import org.xml.sax.SAXNotRecognizedException; |
| import org.xml.sax.SAXNotSupportedException; |
| |
| import org.w3c.dom.*; |
| import javax.xml.transform.*; |
| import javax.xml.transform.stream.*; |
| import javax.xml.transform.sax.SAXTransformerFactory; |
| import org.apache.xalan.transformer.TransformerImpl; |
| import org.apache.xpath.objects.XObject; |
| import org.apache.xpath.objects.XString; |
| import org.apache.xalan.processor.*; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| |
| import org.xml.sax.XMLReader; |
| import org.xml.sax.helpers.XMLReaderFactory; |
| import org.xml.sax.helpers.XMLFilterImpl; |
| |
| /***************************************************************************************************** |
| * |
| * ApplyXSLT supplies the basic |
| * functions for transforming XML data using XSL stylesheets. |
| * |
| * @author Spencer Shepard (sshepard@us.ibm.com) |
| * @author R. Adam King (rak@us.ibm.com) |
| * @author Tom Rowe (trowe@us.ibm.com) |
| * @author Don Leslie (donald_leslie@lotus.com) |
| * |
| *****************************************************************************************************/ |
| |
| public class ApplyXSLT extends HttpServlet |
| { |
| |
| /** |
| * Operational parameters for this class. |
| * <p>Request-time values override init-time values which override class defaults.</p> |
| * @see #init |
| * @serial |
| */ |
| protected ApplyXSLTProperties ourDefaultParameters = null; |
| private boolean useDefaultTemplates = false; |
| private Templates defaultTemplates = null; |
| |
| /** |
| * String representing the end of line characters for the System. |
| */ |
| public final static String EOL = System.getProperty("line.separator"); |
| |
| /** |
| * String representing the file separator characters for the System. |
| */ |
| public final static String FS = System.getProperty("file.separator"); |
| |
| /** |
| * String representing the current directory for properties files. See init(). |
| */ |
| public final static String ROOT = System.getProperty("server.root"); |
| public static String CURRENTDIR; |
| |
| /** |
| * Initialize operational parameters from the configuration. |
| * @param config Configuration |
| * @exception ServletException Never thrown |
| */ |
| public void init(ServletConfig config) |
| throws ServletException |
| { |
| super.init(config); |
| // If the server.root property --see above-- is null, use current working directory |
| // as default location for media.properties. |
| if (ROOT != null) |
| CURRENTDIR= ROOT + FS + "servlets" + FS; |
| else |
| CURRENTDIR = System.getProperty("user.dir")+ FS; |
| |
| setDefaultParameters(config); |
| |
| setMediaProps(config.getInitParameter("mediaURL")); |
| String defaultXSL = config.getInitParameter("xslURL"); |
| try |
| { |
| if (defaultXSL !=null && defaultXSL.length() > 0) |
| compileXSL(defaultXSL); |
| } |
| catch (Exception e){} |
| } |
| |
| /** |
| * If a default setting exists for xslURL, create a Templates object |
| * for rapid transformations. |
| */ |
| protected void compileXSL(String defaultXSL) |
| throws TransformerConfigurationException |
| { |
| TransformerFactory tFactory = TransformerFactory.newInstance(); |
| defaultTemplates = tFactory.newTemplates(new StreamSource(defaultXSL)); |
| useDefaultTemplates = true; |
| } |
| |
| /** |
| * Sets the default parameters for the servlet from the configuration. |
| * Also sets required system properties until we figure out why servlet |
| * sometimess fails to read properties from properties files. |
| * @param config Configuration |
| */ |
| protected void setDefaultParameters(ServletConfig config) |
| { |
| ourDefaultParameters = new DefaultApplyXSLTProperties(config); |
| } |
| |
| /** |
| * Loads the media properties file specified by the given string. |
| * @param mediaURLstring Location of the media properties file. Can be either a full URL or a path relative |
| * to the System's server.root /servlets directory. If this parameter is null, |
| * server.root/servlets/media.properties will be used. |
| * @see ApplyXSL#CURRENTDIR |
| */ |
| protected void setMediaProps(String mediaURLstring) |
| { |
| if (mediaURLstring != null) |
| { |
| URL url = null; |
| try |
| { |
| url = new URL(mediaURLstring); |
| } |
| catch (MalformedURLException mue1) |
| { |
| try |
| { |
| url = new URL("file", "", CURRENTDIR + mediaURLstring); |
| } |
| catch (MalformedURLException mue2) |
| { |
| writeLog("Unable to find the media properties file based on parameter 'mediaURL' = " |
| + mediaURLstring, HttpServletResponse.SC_ACCEPTED, mue2); |
| url = null; |
| } |
| } |
| if (url != null) |
| { |
| try |
| { |
| ourMediaProps = new OrderedProps(url.openStream()); |
| } |
| catch (IOException ioe1) |
| { |
| writeLog("Exception occurred while opening media properties file: " + mediaURLstring + |
| ". Media table may be invalid.", HttpServletResponse.SC_ACCEPTED, ioe1); |
| } |
| } |
| } |
| else |
| { |
| String defaultProp = CURRENTDIR + "media.properties"; |
| try |
| { |
| ourMediaProps = new OrderedProps(new FileInputStream(defaultProp)); |
| } |
| catch (IOException ioe2) |
| { |
| writeLog("Default media properties file " + defaultProp + " not found.", |
| HttpServletResponse.SC_ACCEPTED, ioe2); |
| } |
| } |
| } |
| |
| public String getMedia(HttpServletRequest request) |
| { |
| return ourMediaProps.getValue(request.getHeader(HEADER_NAME)); |
| } |
| |
| // doPost removed for security reasons due to the possibility of sending |
| // unsecure XML and XSL XSLTInputSources through the request input stream |
| |
| /** |
| * HTTP Get method passed on to process(). |
| * @param request The request |
| * @param response The response |
| * @see #process |
| * @exception ServletException Never thrown |
| * @exception IOException Never thrown |
| */ |
| public void doGet (HttpServletRequest request, |
| HttpServletResponse response) |
| throws ServletException, IOException |
| { |
| try |
| { |
| TransformerFactory tFactory = TransformerFactory.newInstance(); |
| process(tFactory, request, response); |
| } |
| catch (Exception e) |
| { |
| } |
| } |
| |
| /** |
| * Coordinates applying an XSL stylesheet to XML data using operational parameters. |
| * <p>If successfully applied, the result tree will be streamed to the response object |
| * and the content type set according to the XSL stylesheet's <xsl:output> element(s).</p> |
| * <p>If there is a problem in parsing the XML/XSL or if there is a problem in applying |
| * the XSL to the XML, an exception will be streamed to the response object. The detail |
| * of the information returned in the response object will depend on whether we're |
| * running in debug mode or not.</p> |
| * @param processor implementation of TRaX processor |
| * @param request May contain information relevant to creating XML and XSL XSLTInputSource's |
| * @param response Where to write the transformation result |
| * @see #getDocument |
| * @see #getStylesheet |
| * @see #getContentType |
| * @see #displayException |
| * @see #setStylesheetParams |
| * @exception ServletException Never thrown |
| * @exception IOException Never thrown |
| */ |
| |
| public void process(TransformerFactory tFactory, |
| HttpServletRequest request, |
| HttpServletResponse response) |
| throws ServletException, IOException, SAXException |
| { |
| boolean debug = ourDefaultParameters.isDebug(request); |
| |
| long time = 0; |
| if (debug) |
| time = System.currentTimeMillis(); |
| |
| // Listener to be used for all reporting |
| ApplyXSLTListener listener = new ApplyXSLTListener(); |
| listener.out.println("debug is " + debug); |
| |
| Source xmlSource = null; |
| Source xslSource = null; |
| try |
| { |
| if ((xmlSource = getDocument(request, listener)) == null) |
| throw new ApplyXSLTException("getDocument() returned null", |
| new NullPointerException(), |
| response.SC_NOT_FOUND); |
| } |
| catch (ApplyXSLTException axe) |
| { |
| axe.appendMessage(EOL + "getDocument() resulted in ApplyXSLTException" + EOL |
| + listener.getMessage()); |
| if (debug) writeLog(axe); |
| displayException(response, axe, debug); |
| xmlSource = null; |
| } |
| // creating XSL Stylesheet |
| if (xmlSource != null) |
| { |
| try |
| { |
| if ((xslSource = getStylesheet(tFactory, request, xmlSource, listener)) == null) |
| throw new ApplyXSLTException("getStylesheet() returned null", |
| new NullPointerException(), |
| response.SC_NOT_FOUND); |
| |
| // Must "reset" xmlSource (a StreamSource) after looking for stylesheet PI |
| xmlSource = getDocument(request, listener); |
| } |
| catch (ApplyXSLTException axe) |
| { |
| axe.appendMessage(EOL + "getStylesheet() resulted in ApplyXSLTException" + EOL |
| + listener.getMessage()); |
| if (debug) writeLog(axe); |
| displayException(response, axe, debug); |
| xslSource = null; |
| } |
| // perform Transformation |
| |
| if (useDefaultTemplates) |
| { |
| try |
| { |
| listener.out.println("Using default templates"); |
| if (defaultTemplates == null) |
| { |
| listener.out.println("Must recompile default templates"); |
| defaultTemplates = tFactory.newTemplates(xslSource); |
| } |
| Transformer transformer = defaultTemplates.newTransformer(); |
| String contentType = null; |
| contentType = getContentType(defaultTemplates); |
| if (contentType != null); |
| response.setContentType(contentType); |
| |
| if (transformer instanceof TransformerImpl) |
| { |
| TransformerImpl transformerImpl = (TransformerImpl)transformer; |
| transformerImpl.setQuietConflictWarnings(ourDefaultParameters.isNoCW(request)); |
| } |
| |
| setStylesheetParams(transformer, request); |
| transformer.transform(xmlSource, new StreamResult(response.getOutputStream())); |
| |
| if (debug) |
| writeLog(listener.getMessage(), response.SC_OK); |
| |
| } |
| catch (Exception exc) |
| { |
| ApplyXSLTException axe = new ApplyXSLTException |
| ("Exception occurred during Transformation:" |
| + EOL + listener.getMessage() + EOL |
| + exc.getMessage(), |
| exc, |
| response.SC_INTERNAL_SERVER_ERROR); |
| if (debug) writeLog(axe); |
| displayException(response, axe, debug); |
| } |
| } |
| |
| else if ((xmlSource != null) && (xslSource != null)) |
| { |
| try |
| { |
| listener.out.println("Performing transformation..."); |
| Templates templates = tFactory.newTemplates(xslSource); |
| Transformer transformer = templates.newTransformer(); |
| |
| try |
| { |
| String contentType = null; |
| contentType = getContentType(templates); |
| if (contentType != null); |
| response.setContentType(contentType); |
| |
| if (transformer instanceof TransformerImpl) |
| { |
| TransformerImpl transformerImpl = (TransformerImpl)transformer; |
| transformerImpl.setQuietConflictWarnings(ourDefaultParameters.isNoCW(request)); |
| } |
| |
| setStylesheetParams(transformer, request); |
| transformer.transform(xmlSource, new StreamResult(response.getOutputStream())); |
| |
| if (debug) |
| writeLog(listener.getMessage(), response.SC_OK); |
| } |
| catch (Exception exc) |
| { |
| ApplyXSLTException axe = new ApplyXSLTException |
| ("Exception occurred during Transformation:" |
| + EOL + listener.getMessage() + EOL |
| + exc.getMessage(), |
| exc, |
| response.SC_INTERNAL_SERVER_ERROR); |
| if (debug) writeLog(axe); |
| displayException(response, axe, debug); |
| } |
| finally |
| { |
| // transformer.reset(); |
| } // end of try ... catch ... finally |
| } |
| catch (/*org.xml.sax.SAX*/Exception saxExc) |
| { |
| ApplyXSLTException axe = new ApplyXSLTException |
| ("Exception occurred during ctor/Transformation:" |
| + EOL + listener.getMessage() + EOL |
| + saxExc.getMessage(), |
| saxExc, |
| response.SC_INTERNAL_SERVER_ERROR); |
| if (debug) writeLog(axe); |
| displayException(response, axe, debug); |
| } // end of new try ... catch |
| } // end of if((stylesheetRoot != null) ... |
| if (debug) |
| { |
| time = System.currentTimeMillis() - time; |
| writeLog(" No Conflict Warnings = " + ourDefaultParameters.isNoCW(request) + |
| " Transformation time: " + time + " ms", response.SC_OK); |
| } |
| } |
| } |
| |
| /** |
| * Returns a Source object with the XML document to be transformed. Attempts will be make to create the |
| * Source object from the following: |
| * <ol> |
| * <li>A relative URL specified in the HTTP request's path information. This capability is intended |
| * for use by <b>servlet engines that map</b> some or all XML data to be processed at the server.</li> |
| * <li>A URL specified in the HTTP request's <code>URL=</code> parameter. This capability |
| * is intended for <b>clients wishing to selectively process</b> XML data at the server. For |
| * security reasons, this URL will be forced to the local IP host.</li> |
| * <li>The HTTP request's XML input stream. This capability is intended for use by chained servlets.</li> |
| * </ol> |
| * @param request client HTTPRequest object |
| * @param listener To record detailed parsing messages for possible return to requestor |
| * @return Source with XML document to be transformed, or null if the Source could not be located |
| * @exception ApplyXSLTException Thrown if exception occurs while handling request |
| */ |
| protected Source getDocument(HttpServletRequest request, |
| ApplyXSLTListener listener) |
| throws ApplyXSLTException |
| { |
| try |
| { |
| String xmlURL = null; |
| // document from PathInfo |
| if ((xmlURL = request.getPathInfo()) != null) |
| { |
| listener.out.println("Parsing XML Document from PathInfo: " + xmlURL); |
| return new StreamSource(new URL("http", ((DefaultApplyXSLTProperties) |
| ourDefaultParameters).getLocalHost(), |
| xmlURL.replace('\\', '/')).openStream()); |
| } |
| // document from Request parameter |
| if ((xmlURL = ourDefaultParameters.getXMLurl(request)) != null) |
| { |
| listener.out.println("Parsing XML Document from request parameter: " + xmlURL); |
| return new StreamSource(new URL(xmlURL).openStream()); |
| } |
| // document from chain |
| String contentType = request.getContentType(); |
| if ((contentType != null) && contentType.startsWith("text/xml")) |
| { |
| listener.out.println("Parsing XML Document from request chain"); |
| return new StreamSource(request.getInputStream()); |
| } |
| } |
| catch (IOException ioe) |
| { |
| throw new ApplyXSLTException(ioe, HttpServletResponse.SC_NOT_FOUND); |
| } |
| catch (Exception e) |
| { |
| throw new ApplyXSLTException(e, HttpServletResponse.SC_INTERNAL_SERVER_ERROR); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a Source object containing the stylesheet. Attempts will be make to obtain the stylesheet |
| * from the following sources: |
| * <ol> |
| * <li>A URL specified in the HTTP request's <code>xslURL=</code> parameter. For security reasons, |
| * this URL will be forced to the local IP host.</li> |
| * <li>A URL specified in the XML document xsl:stylesheet Processing Instruction. XML documents may contain |
| * Processing Instruction references to one or more stylesheets using the |
| * <a HREF="http://www.w3.org/TR/xml-stylesheet/>Associating Style Sheets with XML documents</a> |
| * W3C ecommendation. |
| * If the XML document does contain such references, a best match will be chosen based on the browser |
| * type making the request and the default association. This capability enables relationships to be |
| * defined between client capabilities and stylesheets capable of acting on these capabilities.</li> |
| * <li>A default stylesheet URL specified when the servlet is loaded. During init(), the servlet |
| * uses this xslURL startup parameter to create a Templates object, which is the used for transformations |
| * where no other stylesheet is designated.</li> |
| * </ol> |
| * @param request the client HTTP request, which may include an xslURL parameter |
| * @param xmlSource the XML document to be transformed |
| * @param listener To record detailed parsing messages for possible return to requestor |
| * @return Source, or null if the stylesheet could not be located. |
| * @see #getMedia |
| * @see #STYLESHEET_ATTRIBUTE |
| * @see #toAcceptLanguageConnection |
| * @exception ApplyXSLTException Thrown if exception occurs while locating the stylesheet |
| */ |
| protected Source getStylesheet(TransformerFactory tFactory, |
| HttpServletRequest request, |
| Source xmlSource, |
| ApplyXSLTListener listener) |
| throws ApplyXSLTException |
| { |
| try |
| { |
| //stylesheet URL from request |
| String xslURL = ((DefaultApplyXSLTProperties) ourDefaultParameters).getXSLRequestURL(request); |
| |
| if (xslURL != null) |
| { |
| listener.out.println("Parsing XSL Stylesheet Document from request parameter: " |
| + xslURL); |
| useDefaultTemplates = false; |
| } |
| else |
| { |
| // find stylesheet from XML Document, Media tag preference |
| SAXTransformerFactory stf = (SAXTransformerFactory)tFactory; |
| Source styleSource = |
| stf.getAssociatedStylesheet(xmlSource,getMedia(request), null, null); |
| if (styleSource != null) |
| { |
| listener.out.println("Parsing XSL Stylesheet from XML document stylesheet PI."); |
| useDefaultTemplates = false; |
| return styleSource; |
| } |
| |
| // Configuration Default |
| if ((xslURL = ourDefaultParameters.getXSLurl(null)) != null) |
| { |
| listener.out.println("Parsing XSL Stylesheet Document from configuration: " + xslURL); |
| useDefaultTemplates = true; |
| } |
| } |
| return new StreamSource(xslURL); |
| } |
| catch (IOException ioe) |
| { |
| throw new ApplyXSLTException(ioe, HttpServletResponse.SC_NOT_FOUND); |
| } |
| catch (Exception e) |
| { |
| throw new ApplyXSLTException(e, HttpServletResponse.SC_INTERNAL_SERVER_ERROR); |
| } |
| } |
| |
| /** |
| * Returns the response content type specified by the media-type and encoding attributes of |
| * the <xsl:output> element(s) of the stylesheet. |
| * Default output property settings are used for any properties not set by the stylesheet. |
| * @param xslSourceRoot XSL Stylesheet to be examined for <xsl:output> elements. |
| * @return The response content type (MIME type and charset) of the stylesheet output |
| * @see #process |
| */ |
| public String getContentType(Templates templates) |
| { |
| Properties oprops = templates.getOutputProperties(); |
| String method = oprops.getProperty(OutputKeys.METHOD); |
| if (method == null) method = "xml"; // the default. |
| |
| Properties defoprops = null; |
| if (method.equals("html")) |
| defoprops = OutputProperties.getDefaultMethodProperties("html"); |
| else if (method.equals("text")) |
| defoprops = OutputProperties.getDefaultMethodProperties("text"); |
| else |
| defoprops = OutputProperties.getDefaultMethodProperties("xml"); |
| |
| String encoding = oprops.getProperty(OutputKeys.ENCODING); |
| if (encoding == null) |
| encoding = defoprops.getProperty(OutputKeys.ENCODING); |
| |
| String media = oprops.getProperty(OutputKeys.MEDIA_TYPE); |
| if (media == null) |
| media = defoprops.getProperty(OutputKeys.MEDIA_TYPE); |
| |
| return media + "; charset=" + encoding; |
| } |
| |
| |
| /** |
| * Defines and sets select top-level XSL stylesheet variables from the HTTP request, which |
| * can be evaluated using <xsl:param-variable>. The following variables will be |
| * automatically set: |
| * <dl> |
| * <dt><i>ParameterName</i></dt> |
| * <dd>Each non-reserved request parameter returned from request.getParameterNames(). If a |
| * parameter contains more than a single value, only the first value is available.</dd> |
| * <dt>servlet-RemoteAddr</dt> |
| * <dd>Contains String output from request.getRemoteAddr(), which is the IP address |
| * of the client machine.</dd> |
| * <dt>servlet-RemoteHost</dt> |
| * <dd>Contains String output from request.getRemoteHost(), which is the host name |
| * of the client machine.</dd> |
| * <dt>servlet-RemoteUser</dt> |
| * <dd>Contains String output from request.getRemoteUser(), which was the user name |
| * accepted by the server to grant access to this servlet.</dd> |
| * <dt>servlet-Request</dt> |
| * <dd>Contains the request object.</dd> |
| * </dl> |
| * @param xslprocessor Where to register parameters to be set |
| * @param request Provides access to all meaningful parameters to set |
| * @see #process |
| */ |
| public void setStylesheetParams(Transformer transformer, HttpServletRequest request) |
| { |
| Enumeration paramNames = request.getParameterNames(); |
| while (paramNames.hasMoreElements()) |
| { |
| String paramName = (String) paramNames.nextElement(); |
| try |
| { |
| String[] paramVals = request.getParameterValues(paramName); |
| if (paramVals != null) |
| transformer.setParameter(paramName, new XString(paramVals[0])); |
| |
| } |
| catch (Exception e) |
| { |
| } |
| } |
| try |
| { |
| transformer.setParameter("servlet-RemoteAddr", new XString(request.getRemoteAddr())); |
| |
| } |
| catch (Exception e) |
| { |
| } |
| try |
| { |
| transformer.setParameter("servlet-RemoteHost", new XString(request.getRemoteHost())); |
| |
| } |
| catch (Exception e) |
| { |
| } |
| try |
| { |
| transformer.setParameter("servlet-RemoteUser", new XString(request.getRemoteUser())); |
| |
| } |
| catch (Exception e) |
| { |
| } |
| } |
| |
| |
| /** |
| * Writes the following information to the servlet log: |
| * <ol> |
| * <li>HTTP status code</li> |
| * <li>Message</li> |
| * <li>Stack trace</li> |
| * </ol> |
| * @param axe Contains valid HTTP status code, message, and stack trace (optional) |
| */ |
| protected void writeLog(ApplyXSLTException axe) |
| { |
| writeLog(axe.getMessage(), axe.getStatusCode(), axe.getException()); |
| } |
| |
| /** |
| * Writes the following information to the servlet log: |
| * <ol> |
| * <li>HTTP status code</li> |
| * <li>Message</li> |
| * <li>Stack trace</li> |
| * </ol> |
| * @param msg Message to be logged |
| * @param statusCode Valid status code from javax.servlet.http.HttpServletResponse |
| * @param t Used to generate stack trace (may be =null to suppress stack trace) |
| */ |
| protected void writeLog(String msg, int statusCode, Throwable t) |
| { |
| if (t == null) |
| writeLog(msg, statusCode); |
| else |
| { |
| ByteArrayOutputStream bytes = new ByteArrayOutputStream(); |
| PrintWriter writer = new PrintWriter(bytes, true); |
| System.out.println("Exception is " + t.getClass().getName()); |
| t.printStackTrace(writer); |
| log("HTTP Status Code: " + statusCode + " - " + msg + EOL + bytes.toString()); |
| } |
| } |
| |
| /** |
| * Writes the following information to the servlet log: |
| * <ol> |
| * <li>HTTP status code</li> |
| * <li>Message</li> |
| * </ol> |
| * @param msg Message to be logged |
| * @param statusCode Valid status code from javax.servlet.http.HttpServletResponse |
| */ |
| protected void writeLog(String msg, int statusCode) |
| { |
| log("HTTP Status Code: " + statusCode + " - " + msg); |
| } |
| |
| /** |
| * Invokes response.sendError setting an HTTP status code and optionally an error message |
| * as an HTML page. |
| * <p>If running in debug mode, also try to return a stack trace of the exception and |
| * and xml/xsl processor messages.</p> |
| * @param response Where to stream the exception to |
| * @param xse The wrapper which contains the exception and its HTTP status code |
| * @param debug Indicates whether to include stack trace, etc. |
| */ |
| protected void displayException(HttpServletResponse response, ApplyXSLTException xse, boolean debug) |
| { |
| String mesg = xse.getMessage(); |
| if (mesg == null) |
| mesg = ""; |
| else mesg = "<B>" + mesg + "</B>"; |
| StringTokenizer tokens = new StringTokenizer(mesg, EOL); |
| StringBuffer strBuf = new StringBuffer(); |
| while (tokens.hasMoreTokens()) |
| strBuf.append(tokens.nextToken() + EOL + "<BR>"); |
| mesg = strBuf.toString(); |
| if (debug) |
| { |
| ByteArrayOutputStream bytes = new ByteArrayOutputStream(); |
| PrintWriter writer = new PrintWriter(bytes, true); |
| xse.getException().printStackTrace(writer); |
| mesg += " <PRE> " + bytes.toString() + " </PRE> "; |
| } |
| response.setContentType("text/html"); |
| try |
| { |
| response.sendError(xse.getStatusCode(), mesg); |
| } |
| catch (IOException ioe) |
| { |
| System.err.println("IOException is occurring when sendError is called"); |
| } |
| } |
| |
| /** |
| * Mapping of HTTP request's user-Agent values to stylesheet media= values. |
| * <p>This mapping is defined by a file pointed to by the operational parameter "mediaURL" which can |
| * either contain a full URL or a path relative to the System's server.root /servlets directory.</p> |
| * @see #setMediaProps |
| * @see #getMedia |
| * @serial |
| */ |
| protected OrderedProps ourMediaProps = null; |
| |
| /** |
| * Returns a connection which respects the Accept-Language header of the HTTP request. This |
| * is useful when XSL files are internationalized for use with Web servers which respect this |
| * header. |
| * <p>For example, Apache 1.3.6 may be configured for multiviews. Under this configuration, |
| * requests for http://myhost/index.html would return http://myhost/index.html.fr to French browsers |
| * and http://myhost/index.html.en to English browsers.</p> |
| * @param url Location to connect to |
| * @param request Could contain an Accept-Language header |
| * @return An Accept-Language-enabled URL connection |
| * @see #getStylesheet |
| */ |
| protected URLConnection toAcceptLanguageConnection(URL url, HttpServletRequest request) |
| throws Exception |
| { |
| URLConnection tempConnection = url.openConnection(); |
| tempConnection.setRequestProperty("Accept-Language", request.getHeader("Accept-Language")); |
| return tempConnection; |
| } |
| |
| |
| /** |
| * Returns the XSL stylesheet URL associated with the specified XML document. If multiple XSL |
| * stylesheets are associated with the XML document, preference will be given to the stylesheet |
| * which contains an attribute name/value pair that corresponds to the specified attributeName |
| * and attributeValue. |
| * @param xmlSource XML XSLTInputSource to be searched for associated XSL stylesheets |
| * @param attributeName Attribute name to provide preferential matching |
| * @param attributeValue Attribute value to provide preferential matching |
| * @return The preferred XSL stylesheet URL, or null if no XSL stylesheet association is found |
| * @see #getStylesheet |
| */ |
| /* public static String getXSLURLfromDoc(StreamSource xmlSource, |
| String attributeName, |
| String attributeValue, |
| TransformerFactory tFactory) |
| { |
| String tempURL = null, returnURL = null; |
| try |
| { |
| DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance(); |
| DocumentBuilder docBuilder = dfactory.newDocumentBuilder(); |
| Node sourceTree = docBuilder.parse(xmlSource.getInputStream()); |
| for(Node child=sourceTree.getFirstChild(); null != child; child=child.getNextSibling()) |
| { |
| if(Node.PROCESSING_INSTRUCTION_NODE == child.getNodeType()) |
| { |
| ProcessingInstruction pi = (ProcessingInstruction)child; |
| if(pi.getNodeName().equals("xml-stylesheet")) |
| { |
| PIA pia = new PIA(pi); |
| if("text/xsl".equals(pia.getAttribute("type"))) |
| { |
| tempURL = pia.getAttribute("href"); |
| String attribute = pia.getAttribute(attributeName); |
| if ((attribute != null) && (attribute.indexOf(attributeValue) > -1)) |
| return tempURL; |
| if (!"yes".equals(pia.getAttribute("alternate"))) |
| returnURL = tempURL; |
| } |
| } |
| } |
| } |
| } |
| catch(Exception saxExc) |
| { |
| } |
| return returnURL; |
| } |
| */ |
| /** |
| * The attribute name in the <?xml-stylesheet> tag used in stylesheet selection. |
| */ |
| protected static final String STYLESHEET_ATTRIBUTE = "media"; |
| |
| /** |
| * The HTTP Header used for matching the Stylesheet attribute via the |
| * media properties file selected. |
| */ |
| protected static final String HEADER_NAME = "user-Agent"; |
| } |
| |
| /** |
| * Stores the keys and values from a file (similar to a properties file) and |
| * can return the first value which has a key contained in its string. |
| * File can have comment lines starting with '#" and for each line the entries are |
| * separated by tabs and '=' char. |
| */ |
| class OrderedProps |
| { |
| |
| /** |
| * Stores the Key and Values as an array of Strings |
| */ |
| private Vector attVec = new Vector(15); |
| |
| /** |
| * Constructor. |
| * @param inputStream Stream containing the properties file. |
| * @exception IOException Thrown if unable to read from stream |
| */ |
| OrderedProps(InputStream inputStream) |
| throws IOException |
| { |
| BufferedReader input = new BufferedReader(new InputStreamReader(inputStream)); |
| String currentLine, Key = null; |
| StringTokenizer currentTokens; |
| while ((currentLine = input.readLine()) != null) |
| { |
| currentTokens = new StringTokenizer(currentLine, "=\t\r\n"); |
| if (currentTokens.hasMoreTokens()) Key = currentTokens.nextToken().trim(); |
| if ((Key != null) && !Key.startsWith("#") && currentTokens.hasMoreTokens()) |
| { |
| String temp[] = new String[2]; |
| temp[0] = Key; temp[1] = currentTokens.nextToken().trim(); |
| attVec.addElement(temp); |
| } |
| } |
| } |
| |
| /** |
| * Iterates through the Key list and returns the first value for whose |
| * key the given string contains. Returns "unknown" if no key is contained |
| * in the string. |
| * @param s String being searched for a key. |
| * @return Value for key found in string, otherwise "unknown" |
| */ |
| String getValue(String s) |
| { |
| int i, j = attVec.size(); |
| for (i = 0; i < j; i++) |
| { |
| String temp[] = (String[]) attVec.elementAt(i); |
| if (s.indexOf(temp[0]) > -1) |
| return temp[1]; |
| } |
| return "unknown"; |
| } |
| } |
| |
| /** |
| * Parses a processing instruction's (PI) attributes for easy retrieval. |
| */ |
| class PIA |
| { |
| |
| private Hashtable piAttributes = null; |
| |
| /** |
| * Constructor. |
| * @param pi The processing instruction whose attributes are to be parsed |
| */ |
| PIA(ProcessingInstruction pi) |
| { |
| piAttributes = new Hashtable(); |
| StringTokenizer tokenizer = new StringTokenizer(pi.getNodeValue(), "=\""); |
| while(tokenizer.hasMoreTokens()) |
| { |
| piAttributes.put(tokenizer.nextToken().trim(), tokenizer.nextToken().trim()); |
| } |
| } |
| |
| /** |
| * Returns value of specified attribute. |
| * @param name Attribute name |
| * @return Attribute value, or null if the attribute name does not exist |
| */ |
| String getAttribute(String name) |
| { |
| return (String) piAttributes.get(name); |
| } |
| } |
