/*
* 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.jasper.compiler;
import java.io.BufferedInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayDeque;
import java.util.Deque;
import org.apache.jasper.JasperException;
import org.apache.jasper.JspCompilationContext;
import org.apache.tomcat.Jar;
import org.xml.sax.Attributes;
/**
* Controller for the parsing of a JSP page.
* <p>
* The same ParserController instance is used for a JSP page and any JSP segments included by it (via an include
* directive), where each segment may be provided in standard or XML syntax. This class selects and invokes the
* appropriate parser for the JSP page and its included segments.
*/
public class ParserController implements TagConstants {
private static final String CHARSET = "charset=";
private static final String TAGS_IN_JAR_LOCATION = "/META-INF/tags/";
private final JspCompilationContext ctxt;
private final Compiler compiler;
private final ErrorDispatcher err;
/*
* Indicates the syntax (XML or standard) of the file being processed
*/
private boolean isXml;
/*
* A stack to keep track of the 'current base directory' for include directives that refer to relative paths.
*/
private final Deque<String> baseDirStack = new ArrayDeque<>();
private boolean isEncodingSpecifiedInProlog;
private boolean isBomPresent;
private int skip;
private String sourceEnc;
private boolean isDefaultPageEncoding;
private boolean isTagFile;
private boolean directiveOnly;
/*
* Constructor
*/
ParserController(JspCompilationContext ctxt, Compiler compiler) {
this.ctxt = ctxt;
this.compiler = compiler;
this.err = compiler.getErrorDispatcher();
}
public JspCompilationContext getJspCompilationContext() {
return ctxt;
}
public Compiler getCompiler() {
return compiler;
}
/**
* Parses a JSP page or tag file. This is invoked by the compiler.
*
* @param inFileName The path to the JSP page or tag file to be parsed.
*
* @return The parsed nodes
*
* @throws JasperException If an error occurs during parsing
* @throws IOException If an I/O error occurs such as the file not being found
*/
public Node.Nodes parse(String inFileName) throws JasperException, IOException {
// If we're parsing a packaged tag file or a resource included by it
// (using an include directive), ctxt.getTagFileJar() returns the
// JAR file from which to read the tag file or included resource,
// respectively.
isTagFile = ctxt.isTagFile();
directiveOnly = false;
return doParse(inFileName, null, ctxt.getTagFileJar());
}
/**
* Parses the directives of a JSP page or tag file. This is invoked by the compiler.
*
* @param inFileName The path to the JSP page or tag file to be parsed.
*
* @return The parsed directive nodes
*
* @throws JasperException If an error occurs during parsing
* @throws IOException If an I/O error occurs such as the file not being found
*/
public Node.Nodes parseDirectives(String inFileName) throws JasperException, IOException {
// If we're parsing a packaged tag file or a resource included by it
// (using an include directive), ctxt.getTagFileJar() returns the
// JAR file from which to read the tag file or included resource,
// respectively.
isTagFile = ctxt.isTagFile();
directiveOnly = true;
return doParse(inFileName, null, ctxt.getTagFileJar());
}
/**
* Processes an include directive with the given path.
*
* @param inFileName The path to the resource to be included.
* @param parent The parent node of the include directive.
* @param jar The JAR file from which to read the included resource, or null of the included resource is to
* be read from the filesystem
*
* @return The parsed nodes
*
* @throws JasperException If an error occurs during parsing
* @throws IOException If an I/O error occurs such as the file not being found
*/
public Node.Nodes parse(String inFileName, Node parent, Jar jar) throws JasperException, IOException {
// For files that are statically included, isTagfile and directiveOnly
// remain unchanged.
return doParse(inFileName, parent, jar);
}
/**
* Extracts tag file directive information from the given tag file. This is invoked by the compiler
*
* @param inFileName The name of the tag file to be parsed.
* @param jar The location of the tag file.
*
* @return The parsed tag file nodes
*
* @throws JasperException If an error occurs during parsing
* @throws IOException If an I/O error occurs such as the file not being found
*/
public Node.Nodes parseTagFileDirectives(String inFileName, Jar jar) throws JasperException, IOException {
boolean isTagFileSave = isTagFile;
boolean directiveOnlySave = directiveOnly;
isTagFile = true;
directiveOnly = true;
Node.Nodes page = doParse(inFileName, null, jar);
directiveOnly = directiveOnlySave;
isTagFile = isTagFileSave;
return page;
}
/**
* Parses the JSP page or tag file with the given path name.
*
* @param inFileName The name of the JSP page or tag file to be parsed.
* @param parent The parent node (non-null when processing an include directive)
* @param jar The JAR file from which to read the JSP page or tag file, or null if the JSP page or tag file
* is to be read from the filesystem
*/
@SuppressWarnings("null") // jar can't be null if processingTagInJar is true
private Node.Nodes doParse(String inFileName, Node parent, Jar jar)
throws FileNotFoundException, JasperException, IOException {
Node.Nodes parsedPage;
isEncodingSpecifiedInProlog = false;
isBomPresent = false;
isDefaultPageEncoding = false;
boolean processingTagInJar = jar != null && baseDirStack.peekFirst() != null &&
baseDirStack.peekFirst().startsWith(TAGS_IN_JAR_LOCATION);
String absFileName = null;
try {
absFileName = resolveFileName(inFileName);
} catch (URISyntaxException e) {
err.jspError("jsp.error.invalid.includeInTagFileJar", inFileName, jar.getJarFileURL().toString());
}
if (processingTagInJar && !absFileName.startsWith(TAGS_IN_JAR_LOCATION)) {
/*
* An included file is being parsed that was included from the standard location for tag files in JAR but
* tries to escape that location to either somewhere in the JAR not under the standard location or outside
* the JAR. Neither of these are permitted.
*/
err.jspError("jsp.error.invalid.includeInTagFileJar", inFileName, jar.getJarFileURL().toString());
}
String jspConfigPageEnc = getJspConfigPageEncoding(absFileName);
// Figure out what type of JSP document and encoding type we are
// dealing with
determineSyntaxAndEncoding(absFileName, jar, jspConfigPageEnc);
if (parent != null) {
// Included resource, add to dependent list
if (jar == null) {
compiler.getPageInfo().addDependant(absFileName, ctxt.getLastModified(absFileName));
} else {
String entry = absFileName.substring(1);
compiler.getPageInfo().addDependant(jar.getURL(entry), Long.valueOf(jar.getLastModified(entry)));
}
}
if ((isXml && isEncodingSpecifiedInProlog) || isBomPresent) {
/*
* Make sure the encoding explicitly specified in the XML prolog (if any) matches that in the JSP config
* element (if any), treating "UTF-16", "UTF-16BE", and "UTF-16LE" as identical.
*/
if (jspConfigPageEnc != null && !jspConfigPageEnc.equals(sourceEnc) &&
(!jspConfigPageEnc.startsWith("UTF-16") || !sourceEnc.startsWith("UTF-16"))) {
err.jspError("jsp.error.prolog_config_encoding_mismatch", sourceEnc, jspConfigPageEnc);
}
}
// Dispatch to the appropriate parser
if (isXml) {
// JSP document (XML syntax)
// InputStream for jspx page is created and properly closed in
// JspDocumentParser.
parsedPage = JspDocumentParser.parse(this, absFileName, jar, parent, isTagFile, directiveOnly, sourceEnc,
jspConfigPageEnc, isEncodingSpecifiedInProlog, isBomPresent);
} else {
// Standard syntax
try (InputStreamReader inStreamReader = JspUtil.getReader(absFileName, sourceEnc, jar, ctxt, err, skip)) {
JspReader jspReader = new JspReader(ctxt, absFileName, inStreamReader, err);
parsedPage = Parser.parse(this, jspReader, parent, isTagFile, directiveOnly, jar, sourceEnc,
jspConfigPageEnc, isDefaultPageEncoding, isBomPresent);
}
}
baseDirStack.remove();
return parsedPage;
}
/*
* Checks to see if the given URI is matched by a URL pattern specified in a jsp-property-group in web.xml, and if
* so, returns the value of the <page-encoding> element.
*
* @param absFileName The URI to match
*
* @return The value of the <page-encoding> attribute of the jsp-property-group with matching URL pattern
*/
private String getJspConfigPageEncoding(String absFileName) {
JspConfig jspConfig = ctxt.getOptions().getJspConfig();
JspConfig.JspProperty jspProperty = jspConfig.findJspProperty(absFileName);
return jspProperty.getPageEncoding();
}
/**
* Determines the syntax (standard or XML) and page encoding properties for the given file, and stores them in the
* 'isXml' and 'sourceEnc' instance variables, respectively.
*/
private void determineSyntaxAndEncoding(String absFileName, Jar jar, String jspConfigPageEnc)
throws JasperException, IOException {
isXml = false;
/*
* 'true' if the syntax (XML or standard) of the file is given from external information: either via a JSP
* configuration element, the ".jspx" suffix, or the enclosing file (for included resources)
*/
boolean isExternal = false;
/*
* Indicates whether we need to revert from temporary usage of "ISO-8859-1" back to "UTF-8"
*/
boolean revert = false;
JspConfig jspConfig = ctxt.getOptions().getJspConfig();
JspConfig.JspProperty jspProperty = jspConfig.findJspProperty(absFileName);
if (jspProperty.isXml() != null) {
// If <is-xml> is specified in a <jsp-property-group>, it is used.
isXml = JspUtil.booleanValue(jspProperty.isXml());
isExternal = true;
} else if (absFileName.endsWith(".jspx") || absFileName.endsWith(".tagx")) {
isXml = true;
isExternal = true;
}
if (isExternal && !isXml) {
// JSP (standard) syntax. Use encoding specified in jsp-config
// if provided.
sourceEnc = jspConfigPageEnc;
if (sourceEnc != null) {
return;
}
// We don't know the encoding, so use BOM to determine it
sourceEnc = "ISO-8859-1";
} else {
// XML syntax or unknown, (auto)detect encoding ...
EncodingDetector encodingDetector;
try (BufferedInputStream bis = JspUtil.getInputStream(absFileName, jar, ctxt)) {
encodingDetector = new EncodingDetector(bis);
}
sourceEnc = encodingDetector.getEncoding();
isEncodingSpecifiedInProlog = encodingDetector.isEncodingSpecifiedInProlog();
isBomPresent = (encodingDetector.getSkip() > 0);
skip = encodingDetector.getSkip();
if (!isXml && sourceEnc.equals("UTF-8")) {
/*
* We don't know if we're dealing with XML or standard syntax. Therefore, we need to check to see if the
* page contains a <jsp:root> element.
*
* We need to be careful, because the page may be encoded in ISO-8859-1 (or something entirely
* different), and may contain byte sequences that will cause a UTF-8 converter to throw exceptions.
*
* It is safe to use a source encoding of ISO-8859-1 in this case, as there are no invalid byte
* sequences in ISO-8859-1, and the byte/character sequences we're looking for (i.e., <jsp:root>) are
* identical in either encoding (both UTF-8 and ISO-8859-1 are extensions of ASCII).
*/
sourceEnc = "ISO-8859-1";
revert = true;
}
}
if (isXml) {
// (This implies 'isExternal' is TRUE.)
// We know we're dealing with a JSP document (via JSP config or
// ".jspx" suffix), so we're done.
return;
}
/*
* At this point, 'isExternal' or 'isXml' is FALSE. Search for jsp:root action, in order to determine if we're
* dealing with XML or standard syntax (unless we already know what we're dealing with, i.e., when 'isExternal'
* is TRUE and 'isXml' is FALSE). No check for XML prolog, since nothing prevents a page from outputting XML and
* still using JSP syntax (in this case, the XML prolog is treated as template text).
*/
JspReader jspReader;
try {
jspReader = new JspReader(ctxt, absFileName, sourceEnc, jar, err);
} catch (FileNotFoundException ex) {
throw new JasperException(ex);
}
Mark startMark = jspReader.mark();
if (!isExternal) {
jspReader.reset(startMark);
if (hasJspRoot(jspReader)) {
if (revert) {
sourceEnc = "UTF-8";
}
isXml = true;
return;
} else {
if (revert && isBomPresent) {
sourceEnc = "UTF-8";
}
isXml = false;
}
}
/*
* At this point, we know we're dealing with JSP syntax. If an XML prolog is provided, it's treated as template
* text. Determine the page encoding from the page directive, unless it's specified via JSP config.
*/
if (!isBomPresent) {
sourceEnc = jspConfigPageEnc;
if (sourceEnc == null) {
sourceEnc = getPageEncodingForJspSyntax(jspReader, startMark);
if (sourceEnc == null) {
// Default to "ISO-8859-1" per JSP spec
sourceEnc = "ISO-8859-1";
isDefaultPageEncoding = true;
}
}
}
}
/*
* Determines page source encoding for page or tag file in JSP syntax, by reading (in this order) the value of the
* 'pageEncoding' page directive attribute, or the charset value of the 'contentType' page directive attribute.
*
* @return The page encoding, or null if not found
*/
private String getPageEncodingForJspSyntax(JspReader jspReader, Mark startMark) throws JasperException {
String encoding = null;
String saveEncoding = null;
jspReader.reset(startMark);
/*
* Determine page encoding from directive of the form <%@ page %>, <%@ tag %>, <jsp:directive.page > or
* <jsp:directive.tag >.
*/
while (true) {
if (jspReader.skipUntil("<") == null) {
break;
}
// If this is a comment, skip until its end
if (jspReader.matches("%--")) {
if (jspReader.skipUntil("--%>") == null) {
// error will be caught in Parser
break;
}
continue;
}
boolean isDirective = jspReader.matches("%@");
if (isDirective) {
jspReader.skipSpaces();
} else {
isDirective = jspReader.matches("jsp:directive.");
}
if (!isDirective) {
continue;
}
// Want to match tag and page but not taglib
if (jspReader.matches("tag") && !jspReader.matches("lib") || jspReader.matches("page")) {
jspReader.skipSpaces();
Attributes attrs = Parser.parseAttributes(this, jspReader);
encoding = getPageEncodingFromDirective(attrs, "pageEncoding");
if (encoding != null) {
break;
}
encoding = getPageEncodingFromDirective(attrs, "contentType");
if (encoding != null) {
saveEncoding = encoding;
}
}
}
if (encoding == null) {
encoding = saveEncoding;
}
return encoding;
}
/*
* Scans the given attributes for the attribute with the given name, which is either 'pageEncoding' or
* 'contentType', and returns the specified page encoding.
*
* In the case of 'contentType', the page encoding is taken from the content type's 'charset' component.
*
* @param attrs The page directive attributes
*
* @param attrName The name of the attribute to search for (either 'pageEncoding' or 'contentType')
*
* @return The page encoding, or null
*/
private String getPageEncodingFromDirective(Attributes attrs, String attrName) {
String value = attrs.getValue(attrName);
if (attrName.equals("pageEncoding")) {
return value;
}
// attrName = contentType
String encoding = null;
if (value != null) {
int loc = value.indexOf(CHARSET);
if (loc != -1) {
encoding = value.substring(loc + CHARSET.length());
}
}
return encoding;
}
/*
* Resolve the name of the file and update baseDirStack() to keep track of the current base directory for each
* included file. The 'root' file is always an 'absolute' path, so no need to put an initial value in the
* baseDirStack.
*/
private String resolveFileName(String inFileName) throws URISyntaxException {
String fileName = inFileName.replace('\\', '/');
boolean isAbsolute = fileName.startsWith("/");
if (!isAbsolute) {
URI uri = new URI(baseDirStack.peekFirst() + fileName);
fileName = uri.normalize().toString();
}
String baseDir = fileName.substring(0, fileName.lastIndexOf('/') + 1);
baseDirStack.addFirst(baseDir);
return fileName;
}
/*
* Checks to see if the given page contains, as its first element, a <root> element whose prefix is bound to the JSP
* namespace, as in:
*
* <wombat:root xmlns:wombat="http://java.sun.com/JSP/Page" version="1.2"> ... </wombat:root>
*
* @param reader The reader for this page
*
* @return true if this page contains a root element whose prefix is bound to the JSP namespace, and false otherwise
*/
private boolean hasJspRoot(JspReader reader) {
// <prefix>:root must be the first element
Mark start;
while ((start = reader.skipUntil("<")) != null) {
int c = reader.nextChar();
if (c != '!' && c != '?') {
break;
}
}
if (start == null) {
return false;
}
Mark stop = reader.skipUntil(":root");
if (stop == null) {
return false;
}
// call substring to get rid of leading '<'
String prefix = reader.getText(start, stop).substring(1);
start = stop;
stop = reader.skipUntil(">");
if (stop == null) {
return false;
}
// Determine namespace associated with <root> element's prefix
String root = reader.getText(start, stop);
String xmlnsDecl = "xmlns:" + prefix;
int index = root.indexOf(xmlnsDecl);
if (index == -1) {
return false;
}
index += xmlnsDecl.length();
while (index < root.length() && Character.isWhitespace(root.charAt(index))) {
index++;
}
if (index < root.length() && root.charAt(index) == '=') {
do {
index++;
} while (index < root.length() && Character.isWhitespace(root.charAt(index)));
if (index < root.length() && (root.charAt(index) == '"' || root.charAt(index) == '\'')) {
index++;
return root.regionMatches(index, JSP_URI, 0, JSP_URI.length());
}
}
return false;
}
}