1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.logging.log4j.core.config.xml;
18
19 import java.io.ByteArrayInputStream;
20 import java.io.File;
21 import java.io.IOException;
22 import java.io.InputStream;
23 import java.util.ArrayList;
24 import java.util.Arrays;
25 import java.util.List;
26 import java.util.Map;
27 import javax.xml.XMLConstants;
28 import javax.xml.parsers.DocumentBuilder;
29 import javax.xml.parsers.DocumentBuilderFactory;
30 import javax.xml.parsers.ParserConfigurationException;
31 import javax.xml.transform.Source;
32 import javax.xml.transform.stream.StreamSource;
33 import javax.xml.validation.Schema;
34 import javax.xml.validation.SchemaFactory;
35 import javax.xml.validation.Validator;
36
37 import org.apache.logging.log4j.core.LoggerContext;
38 import org.apache.logging.log4j.core.config.AbstractConfiguration;
39 import org.apache.logging.log4j.core.config.Configuration;
40 import org.apache.logging.log4j.core.config.ConfigurationSource;
41 import org.apache.logging.log4j.core.config.ConfiguratonFileWatcher;
42 import org.apache.logging.log4j.core.config.Node;
43 import org.apache.logging.log4j.core.config.Reconfigurable;
44 import org.apache.logging.log4j.core.config.plugins.util.PluginType;
45 import org.apache.logging.log4j.core.config.plugins.util.ResolverUtil;
46 import org.apache.logging.log4j.core.config.status.StatusConfiguration;
47 import org.apache.logging.log4j.core.util.Closer;
48 import org.apache.logging.log4j.core.util.FileWatcher;
49 import org.apache.logging.log4j.core.util.Loader;
50 import org.apache.logging.log4j.core.util.Patterns;
51 import org.apache.logging.log4j.core.util.Throwables;
52 import org.w3c.dom.Attr;
53 import org.w3c.dom.Document;
54 import org.w3c.dom.Element;
55 import org.w3c.dom.NamedNodeMap;
56 import org.w3c.dom.NodeList;
57 import org.w3c.dom.Text;
58 import org.xml.sax.InputSource;
59 import org.xml.sax.SAXException;
60
61
62
63
64 public class XmlConfiguration extends AbstractConfiguration implements Reconfigurable {
65
66 private static final String XINCLUDE_FIXUP_LANGUAGE =
67 "http://apache.org/xml/features/xinclude/fixup-language";
68 private static final String XINCLUDE_FIXUP_BASE_URIS =
69 "http://apache.org/xml/features/xinclude/fixup-base-uris";
70 private static final String[] VERBOSE_CLASSES = new String[] {ResolverUtil.class.getName()};
71 private static final String LOG4J_XSD = "Log4j-config.xsd";
72
73 private final List<Status> status = new ArrayList<>();
74 private Element rootElement;
75 private boolean strict;
76 private String schemaResource;
77
78 public XmlConfiguration(final LoggerContext loggerContext, final ConfigurationSource configSource) {
79 super(loggerContext, configSource);
80 final File configFile = configSource.getFile();
81 byte[] buffer = null;
82
83 try {
84 final InputStream configStream = configSource.getInputStream();
85 try {
86 buffer = toByteArray(configStream);
87 } finally {
88 Closer.closeSilently(configStream);
89 }
90 final InputSource source = new InputSource(new ByteArrayInputStream(buffer));
91 source.setSystemId(configSource.getLocation());
92 final DocumentBuilder documentBuilder = newDocumentBuilder(true);
93 Document document;
94 try {
95 document = documentBuilder.parse(source);
96 } catch (final Exception e) {
97
98 final Throwable throwable = Throwables.getRootCause(e);
99 if (throwable instanceof UnsupportedOperationException) {
100 LOGGER.warn(
101 "The DocumentBuilder {} does not support an operation: {}."
102 + "Trying again without XInclude...",
103 documentBuilder, e);
104 document = newDocumentBuilder(false).parse(source);
105 } else {
106 throw e;
107 }
108 }
109 rootElement = document.getDocumentElement();
110 final Map<String, String> attrs = processAttributes(rootNode, rootElement);
111 final StatusConfiguration statusConfig = new StatusConfiguration().withVerboseClasses(VERBOSE_CLASSES)
112 .withStatus(getDefaultStatus());
113 for (final Map.Entry<String, String> entry : attrs.entrySet()) {
114 final String key = entry.getKey();
115 final String value = getStrSubstitutor().replace(entry.getValue());
116 if ("status".equalsIgnoreCase(key)) {
117 statusConfig.withStatus(value);
118 } else if ("dest".equalsIgnoreCase(key)) {
119 statusConfig.withDestination(value);
120 } else if ("shutdownHook".equalsIgnoreCase(key)) {
121 isShutdownHookEnabled = !"disable".equalsIgnoreCase(value);
122 } else if ("shutdownTimeout".equalsIgnoreCase(key)) {
123 shutdownTimeoutMillis = Long.parseLong(value);
124 } else if ("verbose".equalsIgnoreCase(key)) {
125 statusConfig.withVerbosity(value);
126 } else if ("packages".equalsIgnoreCase(key)) {
127 pluginPackages.addAll(Arrays.asList(value.split(Patterns.COMMA_SEPARATOR)));
128 } else if ("name".equalsIgnoreCase(key)) {
129 setName(value);
130 } else if ("strict".equalsIgnoreCase(key)) {
131 strict = Boolean.parseBoolean(value);
132 } else if ("schema".equalsIgnoreCase(key)) {
133 schemaResource = value;
134 } else if ("monitorInterval".equalsIgnoreCase(key)) {
135 final int intervalSeconds = Integer.parseInt(value);
136 if (intervalSeconds > 0) {
137 getWatchManager().setIntervalSeconds(intervalSeconds);
138 if (configFile != null) {
139 final FileWatcher watcher = new ConfiguratonFileWatcher(this, listeners);
140 getWatchManager().watchFile(configFile, watcher);
141 }
142 }
143 } else if ("advertiser".equalsIgnoreCase(key)) {
144 createAdvertiser(value, configSource, buffer, "text/xml");
145 }
146 }
147 statusConfig.initialize();
148 } catch (final SAXException | IOException | ParserConfigurationException e) {
149 LOGGER.error("Error parsing " + configSource.getLocation(), e);
150 }
151 if (strict && schemaResource != null && buffer != null) {
152 try (InputStream is = Loader.getResourceAsStream(schemaResource, XmlConfiguration.class.getClassLoader())) {
153 if (is != null) {
154 final Source src = new StreamSource(is, LOG4J_XSD);
155 final SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
156 Schema schema = null;
157 try {
158 schema = factory.newSchema(src);
159 } catch (final SAXException ex) {
160 LOGGER.error("Error parsing Log4j schema", ex);
161 }
162 if (schema != null) {
163 final Validator validator = schema.newValidator();
164 try {
165 validator.validate(new StreamSource(new ByteArrayInputStream(buffer)));
166 } catch (final IOException ioe) {
167 LOGGER.error("Error reading configuration for validation", ioe);
168 } catch (final SAXException ex) {
169 LOGGER.error("Error validating configuration", ex);
170 }
171 }
172 }
173 } catch (final Exception ex) {
174 LOGGER.error("Unable to access schema {}", this.schemaResource, ex);
175 }
176 }
177
178 if (getName() == null) {
179 setName(configSource.getLocation());
180 }
181 }
182
183
184
185
186
187
188
189
190 static DocumentBuilder newDocumentBuilder(final boolean xIncludeAware) throws ParserConfigurationException {
191 final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
192 factory.setNamespaceAware(true);
193
194 disableDtdProcessing(factory);
195
196 if (xIncludeAware) {
197 enableXInclude(factory);
198 }
199 return factory.newDocumentBuilder();
200 }
201
202 private static void disableDtdProcessing(final DocumentBuilderFactory factory) throws ParserConfigurationException {
203 factory.setValidating(false);
204 factory.setExpandEntityReferences(false);
205 factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
206 factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
207 factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
208 }
209
210
211
212
213
214
215 private static void enableXInclude(final DocumentBuilderFactory factory) {
216 try {
217
218
219 factory.setXIncludeAware(true);
220 } catch (final UnsupportedOperationException e) {
221 LOGGER.warn("The DocumentBuilderFactory [{}] does not support XInclude: {}", factory, e);
222 } catch (@SuppressWarnings("ErrorNotRethrown") final AbstractMethodError | NoSuchMethodError err) {
223 LOGGER.warn("The DocumentBuilderFactory [{}] is out of date and does not support XInclude: {}", factory,
224 err);
225 }
226 try {
227
228
229 factory.setFeature(XINCLUDE_FIXUP_BASE_URIS, true);
230 } catch (final ParserConfigurationException e) {
231 LOGGER.warn("The DocumentBuilderFactory [{}] does not support the feature [{}]: {}", factory,
232 XINCLUDE_FIXUP_BASE_URIS, e);
233 } catch (@SuppressWarnings("ErrorNotRethrown") final AbstractMethodError err) {
234 LOGGER.warn("The DocumentBuilderFactory [{}] is out of date and does not support setFeature: {}", factory,
235 err);
236 }
237 try {
238 factory.setFeature(XINCLUDE_FIXUP_LANGUAGE, true);
239 } catch (final ParserConfigurationException e) {
240 LOGGER.warn("The DocumentBuilderFactory [{}] does not support the feature [{}]: {}", factory,
241 XINCLUDE_FIXUP_LANGUAGE, e);
242 } catch (@SuppressWarnings("ErrorNotRethrown") final AbstractMethodError err) {
243 LOGGER.warn("The DocumentBuilderFactory [{}] is out of date and does not support setFeature: {}", factory,
244 err);
245 }
246 }
247
248 @Override
249 public void setup() {
250 if (rootElement == null) {
251 LOGGER.error("No logging configuration");
252 return;
253 }
254 constructHierarchy(rootNode, rootElement);
255 if (status.size() > 0) {
256 for (final Status s : status) {
257 LOGGER.error("Error processing element {} ({}): {}", s.name, s.element, s.errorType);
258 }
259 return;
260 }
261 rootElement = null;
262 }
263
264 @Override
265 public Configuration reconfigure() {
266 try {
267 final ConfigurationSource source = getConfigurationSource().resetInputStream();
268 if (source == null) {
269 return null;
270 }
271 final XmlConfiguration config = new XmlConfiguration(getLoggerContext(), source);
272 return config.rootElement == null ? null : config;
273 } catch (final IOException ex) {
274 LOGGER.error("Cannot locate file {}", getConfigurationSource(), ex);
275 }
276 return null;
277 }
278
279 private void constructHierarchy(final Node node, final Element element) {
280 processAttributes(node, element);
281 final StringBuilder buffer = new StringBuilder();
282 final NodeList list = element.getChildNodes();
283 final List<Node> children = node.getChildren();
284 for (int i = 0; i < list.getLength(); i++) {
285 final org.w3c.dom.Node w3cNode = list.item(i);
286 if (w3cNode instanceof Element) {
287 final Element child = (Element) w3cNode;
288 final String name = getType(child);
289 final PluginType<?> type = pluginManager.getPluginType(name);
290 final Node childNode = new Node(node, name, type);
291 constructHierarchy(childNode, child);
292 if (type == null) {
293 final String value = childNode.getValue();
294 if (!childNode.hasChildren() && value != null) {
295 node.getAttributes().put(name, value);
296 } else {
297 status.add(new Status(name, element, ErrorType.CLASS_NOT_FOUND));
298 }
299 } else {
300 children.add(childNode);
301 }
302 } else if (w3cNode instanceof Text) {
303 final Text data = (Text) w3cNode;
304 buffer.append(data.getData());
305 }
306 }
307
308 final String text = buffer.toString().trim();
309 if (text.length() > 0 || (!node.hasChildren() && !node.isRoot())) {
310 node.setValue(text);
311 }
312 }
313
314 private String getType(final Element element) {
315 if (strict) {
316 final NamedNodeMap attrs = element.getAttributes();
317 for (int i = 0; i < attrs.getLength(); ++i) {
318 final org.w3c.dom.Node w3cNode = attrs.item(i);
319 if (w3cNode instanceof Attr) {
320 final Attr attr = (Attr) w3cNode;
321 if (attr.getName().equalsIgnoreCase("type")) {
322 final String type = attr.getValue();
323 attrs.removeNamedItem(attr.getName());
324 return type;
325 }
326 }
327 }
328 }
329 return element.getTagName();
330 }
331
332 private Map<String, String> processAttributes(final Node node, final Element element) {
333 final NamedNodeMap attrs = element.getAttributes();
334 final Map<String, String> attributes = node.getAttributes();
335
336 for (int i = 0; i < attrs.getLength(); ++i) {
337 final org.w3c.dom.Node w3cNode = attrs.item(i);
338 if (w3cNode instanceof Attr) {
339 final Attr attr = (Attr) w3cNode;
340 if (attr.getName().equals("xml:base")) {
341 continue;
342 }
343 attributes.put(attr.getName(), attr.getValue());
344 }
345 }
346 return attributes;
347 }
348
349 @Override
350 public String toString() {
351 return getClass().getSimpleName() + "[location=" + getConfigurationSource() + "]";
352 }
353
354
355
356
357 private enum ErrorType {
358 CLASS_NOT_FOUND
359 }
360
361
362
363
364 private static class Status {
365 private final Element element;
366 private final String name;
367 private final ErrorType errorType;
368
369 public Status(final String name, final Element element, final ErrorType errorType) {
370 this.name = name;
371 this.element = element;
372 this.errorType = errorType;
373 }
374
375 @Override
376 public String toString() {
377 return "Status [name=" + name + ", element=" + element + ", errorType=" + errorType + "]";
378 }
379
380 }
381
382 }