Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *     http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.configuration2.resolver;
018
019import java.io.IOException;
020import java.io.InputStream;
021import java.net.FileNameMap;
022import java.net.URL;
023import java.net.URLConnection;
024import java.util.Vector;
025
026import org.apache.commons.configuration2.ex.ConfigurationException;
027import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
028import org.apache.commons.configuration2.io.ConfigurationLogger;
029import org.apache.commons.configuration2.io.FileLocatorUtils;
030import org.apache.commons.configuration2.io.FileSystem;
031import org.apache.commons.lang3.SystemProperties;
032import org.apache.xml.resolver.CatalogException;
033import org.apache.xml.resolver.readers.CatalogReader;
034import org.xml.sax.EntityResolver;
035import org.xml.sax.InputSource;
036import org.xml.sax.SAXException;
037
038/**
039 * Thin wrapper around xml commons CatalogResolver to allow list of catalogs to be provided.
040 *
041 * @since 1.7
042 */
043public class CatalogResolver implements EntityResolver {
044    /**
045     * Overrides the Catalog implementation to use the underlying FileSystem.
046     */
047    public static class Catalog extends org.apache.xml.resolver.Catalog {
048        /** The FileSystem */
049        private FileSystem fs;
050
051        /** FileNameMap to determine the mime type */
052        private final FileNameMap fileNameMap = URLConnection.getFileNameMap();
053
054        /**
055         * Load the catalogs.
056         *
057         * @throws IOException if an error occurs.
058         */
059        @Override
060        public void loadSystemCatalogs() throws IOException {
061            fs = ((CatalogManager) catalogManager).getFileSystem();
062            final String base = ((CatalogManager) catalogManager).getBaseDir();
063
064            // This is safe because the catalog manager returns a vector of strings.
065            final Vector<String> catalogs = catalogManager.getCatalogFiles();
066            if (catalogs != null) {
067                for (int count = 0; count < catalogs.size(); count++) {
068                    final String fileName = catalogs.elementAt(count);
069
070                    URL url = null;
071                    InputStream inputStream = null;
072
073                    try {
074                        url = locate(fs, base, fileName);
075                        if (url != null) {
076                            inputStream = fs.getInputStream(url);
077                        }
078                    } catch (final ConfigurationException ce) {
079                        final String name = url.toString();
080                        // Ignore the exception.
081                        catalogManager.debug.message(DEBUG_ALL, "Unable to get input stream for " + name + ". " + ce.getMessage());
082                    }
083                    if (inputStream != null) {
084                        final String mimeType = fileNameMap.getContentTypeFor(fileName);
085                        try {
086                            if (mimeType != null) {
087                                parseCatalog(mimeType, inputStream);
088                                continue;
089                            }
090                        } catch (final Exception ex) {
091                            // Ignore the exception.
092                            catalogManager.debug.message(DEBUG_ALL, "Exception caught parsing input stream for " + fileName + ". " + ex.getMessage());
093                        } finally {
094                            inputStream.close();
095                        }
096                    }
097                    parseCatalog(base, fileName);
098                }
099            }
100
101        }
102
103        /**
104         * Performs character normalization on a URI reference.
105         *
106         * @param uriref The URI reference
107         * @return The normalized URI reference.
108         */
109        @Override
110        protected String normalizeURI(final String uriref) {
111            final ConfigurationInterpolator ci = ((CatalogManager) catalogManager).getInterpolator();
112            final String resolved = ci != null ? String.valueOf(ci.interpolate(uriref)) : uriref;
113            return super.normalizeURI(resolved);
114        }
115
116        /**
117         * Parses the specified catalog file.
118         *
119         * @param baseDir The base directory, if not included in the file name.
120         * @param fileName The catalog file. May be a full URI String.
121         * @throws IOException If an error occurs.
122         */
123        public void parseCatalog(final String baseDir, final String fileName) throws IOException {
124            base = locate(fs, baseDir, fileName);
125            catalogCwd = base;
126            default_override = catalogManager.getPreferPublic();
127            catalogManager.debug.message(DEBUG_NORMAL, "Parse catalog: " + fileName);
128
129            boolean parsed = false;
130
131            for (int count = 0; !parsed && count < readerArr.size(); count++) {
132                final CatalogReader reader = (CatalogReader) readerArr.get(count);
133                InputStream inputStream;
134
135                try {
136                    inputStream = fs.getInputStream(base);
137                } catch (final Exception ex) {
138                    catalogManager.debug.message(DEBUG_NORMAL, "Unable to access " + base + ex.getMessage());
139                    break;
140                }
141
142                try {
143                    reader.readCatalog(this, inputStream);
144                    parsed = true;
145                } catch (final CatalogException ce) {
146                    catalogManager.debug.message(DEBUG_NORMAL, "Parse failed for " + fileName + ce.getMessage());
147                    if (ce.getExceptionType() == CatalogException.PARSE_FAILED) {
148                        break;
149                    }
150                    // try again!
151                    continue;
152                } finally {
153                    try {
154                        inputStream.close();
155                    } catch (final IOException ioe) {
156                        // Ignore the exception.
157                        inputStream = null;
158                    }
159                }
160            }
161
162            if (parsed) {
163                parsePendingCatalogs();
164            }
165        }
166    }
167
168    /**
169     * Extends the CatalogManager to make the FileSystem and base directory accessible.
170     */
171    public static class CatalogManager extends org.apache.xml.resolver.CatalogManager {
172        /** The static catalog used by this manager. */
173        private static org.apache.xml.resolver.Catalog staticCatalog;
174
175        /** The FileSystem */
176        private FileSystem fs;
177
178        /** The base directory */
179        private String baseDir = SystemProperties.getUserDir();
180
181        /** The object for handling interpolation. */
182        private ConfigurationInterpolator interpolator;
183
184        /**
185         * Gets the base directory.
186         *
187         * @return The base directory.
188         */
189        public String getBaseDir() {
190            return this.baseDir;
191        }
192
193        /**
194         * Gets a catalog instance.
195         *
196         * If this manager uses static catalogs, the same static catalog will always be returned. Otherwise a new catalog will
197         * be returned.
198         *
199         * @return The Catalog.
200         */
201        @Override
202        public org.apache.xml.resolver.Catalog getCatalog() {
203            return getPrivateCatalog();
204        }
205
206        /**
207         * Gets the FileSystem.
208         *
209         * @return The FileSystem.
210         */
211        public FileSystem getFileSystem() {
212            return this.fs;
213        }
214
215        /**
216         * Gets the ConfigurationInterpolator.
217         *
218         * @return the ConfigurationInterpolator.
219         */
220        public ConfigurationInterpolator getInterpolator() {
221            return interpolator;
222        }
223
224        /**
225         * Gets a new catalog instance. This method is only overridden because xml-resolver might be in a parent ClassLoader and
226         * will be incapable of loading our Catalog implementation.
227         *
228         * This method always returns a new instance of the underlying catalog class.
229         *
230         * @return the Catalog.
231         */
232        @Override
233        public org.apache.xml.resolver.Catalog getPrivateCatalog() {
234            org.apache.xml.resolver.Catalog catalog = staticCatalog;
235
236            if (catalog == null || !getUseStaticCatalog()) {
237                try {
238                    catalog = new Catalog();
239                    catalog.setCatalogManager(this);
240                    catalog.setupReaders();
241                    catalog.loadSystemCatalogs();
242                } catch (final Exception ex) {
243                    ex.printStackTrace();
244                }
245
246                if (getUseStaticCatalog()) {
247                    staticCatalog = catalog;
248                }
249            }
250
251            return catalog;
252        }
253
254        /**
255         * Sets the base directory.
256         *
257         * @param baseDir The base directory.
258         */
259        public void setBaseDir(final String baseDir) {
260            if (baseDir != null) {
261                this.baseDir = baseDir;
262            }
263        }
264
265        /**
266         * Sets the FileSystem
267         *
268         * @param fileSystem The FileSystem in use.
269         */
270        public void setFileSystem(final FileSystem fileSystem) {
271            this.fs = fileSystem;
272        }
273
274        /**
275         * Sets the ConfigurationInterpolator.
276         *
277         * @param configurationInterpolator the ConfigurationInterpolator.
278         */
279        public void setInterpolator(final ConfigurationInterpolator configurationInterpolator) {
280            interpolator = configurationInterpolator;
281        }
282    }
283
284    /**
285     * Debug everything.
286     */
287    private static final int DEBUG_ALL = 9;
288
289    /**
290     * Normal debug setting.
291     */
292    private static final int DEBUG_NORMAL = 4;
293
294    /**
295     * Debug nothing.
296     */
297    private static final int DEBUG_NONE = 0;
298
299    /**
300     * Locates a given file. This implementation delegates to the corresponding method in {@link FileLocatorUtils}.
301     *
302     * @param fs the {@code FileSystem}
303     * @param basePath the base path
304     * @param name the file name
305     * @return the URL pointing to the file
306     */
307    private static URL locate(final FileSystem fs, final String basePath, final String name) {
308        return FileLocatorUtils.locate(FileLocatorUtils.fileLocator().fileSystem(fs).basePath(basePath).fileName(name).create());
309    }
310
311    /**
312     * The CatalogManager
313     */
314    private final CatalogManager manager = new CatalogManager();
315
316    /**
317     * The FileSystem in use.
318     */
319    private FileSystem fs = FileLocatorUtils.DEFAULT_FILE_SYSTEM;
320
321    /**
322     * The CatalogResolver
323     */
324    private org.apache.xml.resolver.tools.CatalogResolver resolver;
325
326    /**
327     * Stores the logger.
328     */
329    private ConfigurationLogger log;
330
331    /**
332     * Constructs the CatalogResolver
333     */
334    public CatalogResolver() {
335        manager.setIgnoreMissingProperties(true);
336        manager.setUseStaticCatalog(false);
337        manager.setFileSystem(fs);
338        initLogger(null);
339    }
340
341    /**
342     * Gets the logger used by this configuration object.
343     *
344     * @return the logger
345     */
346    public ConfigurationLogger getLogger() {
347        return log;
348    }
349
350    private synchronized org.apache.xml.resolver.tools.CatalogResolver getResolver() {
351        if (resolver == null) {
352            resolver = new org.apache.xml.resolver.tools.CatalogResolver(manager);
353        }
354        return resolver;
355    }
356
357    /**
358     * Initializes the logger. Checks for null parameters.
359     *
360     * @param log the new logger
361     */
362    private void initLogger(final ConfigurationLogger log) {
363        this.log = log != null ? log : ConfigurationLogger.newDummyLogger();
364    }
365
366    /**
367     * <p>
368     * Implements the {@code resolveEntity} method for the SAX interface.
369     * </p>
370     * <p>
371     * Presented with an optional public identifier and a system identifier, this function attempts to locate a mapping in
372     * the catalogs.
373     * </p>
374     * <p>
375     * If such a mapping is found, the resolver attempts to open the mapped value as an InputSource and return it.
376     * Exceptions are ignored and null is returned if the mapped value cannot be opened as an input source.
377     * </p>
378     * <p>
379     * If no mapping is found (or an error occurs attempting to open the mapped value as an input source), null is returned
380     * and the system will use the specified system identifier as if no entityResolver was specified.
381     * </p>
382     *
383     * @param publicId The public identifier for the entity in question. This may be null.
384     * @param systemId The system identifier for the entity in question. XML requires a system identifier on all external
385     *        entities, so this value is always specified.
386     * @return An InputSource for the mapped identifier, or null.
387     * @throws SAXException if an error occurs.
388     */
389    @SuppressWarnings("resource") // InputSource wraps an InputStream.
390    @Override
391    public InputSource resolveEntity(final String publicId, final String systemId) throws SAXException {
392        String resolved = getResolver().getResolvedEntity(publicId, systemId);
393
394        if (resolved != null) {
395            final String badFilePrefix = "file://";
396            final String correctFilePrefix = "file:///";
397
398            // Java 5 has a bug when constructing file URLs
399            if (resolved.startsWith(badFilePrefix) && !resolved.startsWith(correctFilePrefix)) {
400                resolved = correctFilePrefix + resolved.substring(badFilePrefix.length());
401            }
402
403            try {
404                final URL url = locate(fs, null, resolved);
405                if (url == null) {
406                    throw new ConfigurationException("Could not locate " + resolved);
407                }
408                final InputStream inputStream = fs.getInputStream(url);
409                final InputSource inputSource = new InputSource(resolved);
410                inputSource.setPublicId(publicId);
411                inputSource.setByteStream(inputStream);
412                return inputSource;
413            } catch (final Exception e) {
414                log.warn("Failed to create InputSource for " + resolved, e);
415            }
416        }
417
418        return null;
419    }
420
421    /**
422     * Sets the base path.
423     *
424     * @param baseDir The base path String.
425     */
426    public void setBaseDir(final String baseDir) {
427        manager.setBaseDir(baseDir);
428    }
429
430    /**
431     * Sets the list of catalog file names
432     *
433     * @param catalogs The delimited list of catalog files.
434     */
435    public void setCatalogFiles(final String catalogs) {
436        manager.setCatalogFiles(catalogs);
437    }
438
439    /**
440     * Enables debug logging of xml-commons Catalog processing.
441     *
442     * @param debug True if debugging should be enabled, false otherwise.
443     */
444    public void setDebug(final boolean debug) {
445        manager.setVerbosity(debug ? DEBUG_ALL : DEBUG_NONE);
446    }
447
448    /**
449     * Sets the FileSystem.
450     *
451     * @param fileSystem The FileSystem.
452     */
453    public void setFileSystem(final FileSystem fileSystem) {
454        this.fs = fileSystem;
455        manager.setFileSystem(fileSystem);
456    }
457
458    /**
459     * Sets the {@code ConfigurationInterpolator}.
460     *
461     * @param ci the {@code ConfigurationInterpolator}
462     */
463    public void setInterpolator(final ConfigurationInterpolator ci) {
464        manager.setInterpolator(ci);
465    }
466
467    /**
468     * Allows setting the logger to be used by this object. This method makes it possible for clients to exactly control
469     * logging behavior. Per default a logger is set that will ignore all log messages. Derived classes that want to enable
470     * logging should call this method during their initialization with the logger to be used. Passing in <b>null</b> as
471     * argument disables logging.
472     *
473     * @param log the new logger
474     */
475    public void setLogger(final ConfigurationLogger log) {
476        initLogger(log);
477    }
478}