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.logging.log4j.util;
018
019import java.io.IOException;
020import java.lang.reflect.InvocationTargetException;
021import java.net.URL;
022import java.security.AccessController;
023import java.security.PrivilegedAction;
024import java.util.ArrayList;
025import java.util.Collection;
026import java.util.Enumeration;
027import java.util.LinkedHashSet;
028import java.util.List;
029import java.util.Objects;
030
031/**
032 * <em>Consider this class private.</em> Utility class for ClassLoaders.
033 *
034 * @see ClassLoader
035 * @see RuntimePermission
036 * @see Thread#getContextClassLoader()
037 * @see ClassLoader#getSystemClassLoader()
038 */
039public final class LoaderUtil {
040
041    /**
042     * System property to set to ignore the thread context ClassLoader.
043     *
044     * @since 2.1
045     */
046    public static final String IGNORE_TCCL_PROPERTY = "log4j.ignoreTCL";
047
048    private static final SecurityManager SECURITY_MANAGER = System.getSecurityManager();
049
050    // this variable must be lazily loaded; otherwise, we get a nice circular class loading problem where LoaderUtil
051    // wants to use PropertiesUtil, but then PropertiesUtil wants to use LoaderUtil.
052    private static Boolean ignoreTCCL;
053
054    private static final boolean GET_CLASS_LOADER_DISABLED;
055
056    private static final PrivilegedAction<ClassLoader> TCCL_GETTER = new ThreadContextClassLoaderGetter();
057
058    static {
059        if (SECURITY_MANAGER != null) {
060            boolean getClassLoaderDisabled;
061            try {
062                SECURITY_MANAGER.checkPermission(new RuntimePermission("getClassLoader"));
063                getClassLoaderDisabled = false;
064            } catch (final SecurityException ignored) {
065                getClassLoaderDisabled = true;
066            }
067            GET_CLASS_LOADER_DISABLED = getClassLoaderDisabled;
068        } else {
069            GET_CLASS_LOADER_DISABLED = false;
070        }
071    }
072
073    private LoaderUtil() {
074    }
075
076    /**
077     * Gets the current Thread ClassLoader. Returns the system ClassLoader if the TCCL is {@code null}. If the system
078     * ClassLoader is {@code null} as well, then the ClassLoader for this class is returned. If running with a
079     * {@link SecurityManager} that does not allow access to the Thread ClassLoader or system ClassLoader, then the
080     * ClassLoader for this class is returned.
081     *
082     * @return the current ThreadContextClassLoader.
083     */
084    public static ClassLoader getThreadContextClassLoader() {
085        if (GET_CLASS_LOADER_DISABLED) {
086            // we can at least get this class's ClassLoader regardless of security context
087            // however, if this is null, there's really no option left at this point
088            return LoaderUtil.class.getClassLoader();
089        }
090        return SECURITY_MANAGER == null ? TCCL_GETTER.run() : AccessController.doPrivileged(TCCL_GETTER);
091    }
092
093    /**
094     *
095     */
096    private static class ThreadContextClassLoaderGetter implements PrivilegedAction<ClassLoader> {
097        @Override
098        public ClassLoader run() {
099            final ClassLoader cl = Thread.currentThread().getContextClassLoader();
100            if (cl != null) {
101                return cl;
102            }
103            final ClassLoader ccl = LoaderUtil.class.getClassLoader();
104            return ccl == null && !GET_CLASS_LOADER_DISABLED ? ClassLoader.getSystemClassLoader() : ccl;
105        }
106    }
107
108    public static ClassLoader[] getClassLoaders() {
109        List<ClassLoader> classLoaders = new ArrayList<>();
110        ClassLoader tcl = getThreadContextClassLoader();
111        classLoaders.add(tcl);
112        ClassLoader current = LoaderUtil.class.getClassLoader();
113        if (current != tcl) {
114            classLoaders.add(current);
115            ClassLoader parent = current.getParent();
116            while (parent != null && !classLoaders.contains(parent)) {
117                classLoaders.add(parent);
118            }
119        }
120        ClassLoader parent = tcl;
121        while (parent != null && !classLoaders.contains(parent)) {
122            classLoaders.add(parent);
123        }
124        if (!classLoaders.contains(ClassLoader.getSystemClassLoader())) {
125            classLoaders.add(ClassLoader.getSystemClassLoader());
126        }
127        return classLoaders.toArray(new ClassLoader[classLoaders.size()]);
128    }
129
130    /**
131     * Determines if a named Class can be loaded or not.
132     *
133     * @param className The class name.
134     * @return {@code true} if the class could be found or {@code false} otherwise.
135     * @since 2.7
136     */
137    public static boolean isClassAvailable(final String className) {
138        try {
139            final Class<?> clazz = loadClass(className);
140            return clazz != null;
141        } catch (final ClassNotFoundException | LinkageError e) {
142            return false;
143        } catch (final Throwable e) {
144            LowLevelLogUtil.logException("Unknown error checking for existence of class: " + className, e);
145            return false;
146        }
147    }
148
149    /**
150     * Loads a class by name. This method respects the {@link #IGNORE_TCCL_PROPERTY} Log4j property. If this property is
151     * specified and set to anything besides {@code false}, then the default ClassLoader will be used.
152     *
153     * @param className The class name.
154     * @return the Class for the given name.
155     * @throws ClassNotFoundException if the specified class name could not be found
156     * @since 2.1
157     */
158    public static Class<?> loadClass(final String className) throws ClassNotFoundException {
159        if (isIgnoreTccl()) {
160            return Class.forName(className);
161        }
162        try {
163            return getThreadContextClassLoader().loadClass(className);
164        } catch (final Throwable ignored) {
165            return Class.forName(className);
166        }
167    }
168
169    /**
170     * Loads and instantiates a Class using the default constructor.
171     *
172     * @param clazz The class.
173     * @return new instance of the class.
174     * @throws IllegalAccessException if the class can't be instantiated through a public constructor
175     * @throws InstantiationException if there was an exception whilst instantiating the class
176     * @throws InvocationTargetException if there was an exception whilst constructing the class
177     * @since 2.7
178     */
179    public static <T> T newInstanceOf(final Class<T> clazz)
180            throws InstantiationException, IllegalAccessException, InvocationTargetException {
181        try {
182            return clazz.getConstructor().newInstance();
183        } catch (final NoSuchMethodException ignored) {
184            // FIXME: looking at the code for Class.newInstance(), this seems to do the same thing as above
185            return clazz.newInstance();
186        }
187    }
188
189    /**
190     * Loads and instantiates a Class using the default constructor.
191     *
192     * @param className The class name.
193     * @return new instance of the class.
194     * @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
195     * @throws IllegalAccessException if the class can't be instantiated through a public constructor
196     * @throws InstantiationException if there was an exception whilst instantiating the class
197     * @throws NoSuchMethodException if there isn't a no-args constructor on the class
198     * @throws InvocationTargetException if there was an exception whilst constructing the class
199     * @since 2.1
200     */
201    @SuppressWarnings("unchecked")
202    public static <T> T newInstanceOf(final String className) throws ClassNotFoundException, IllegalAccessException,
203            InstantiationException, NoSuchMethodException, InvocationTargetException {
204        return newInstanceOf((Class<T>) loadClass(className));
205    }
206
207    /**
208     * Loads and instantiates a derived class using its default constructor.
209     *
210     * @param className The class name.
211     * @param clazz The class to cast it to.
212     * @param <T> The type of the class to check.
213     * @return new instance of the class cast to {@code T}
214     * @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
215     * @throws IllegalAccessException if the class can't be instantiated through a public constructor
216     * @throws InstantiationException if there was an exception whilst instantiating the class
217     * @throws NoSuchMethodException if there isn't a no-args constructor on the class
218     * @throws InvocationTargetException if there was an exception whilst constructing the class
219     * @throws ClassCastException if the constructed object isn't type compatible with {@code T}
220     * @since 2.1
221     */
222    public static <T> T newCheckedInstanceOf(final String className, final Class<T> clazz)
223            throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException,
224            IllegalAccessException {
225        return clazz.cast(newInstanceOf(className));
226    }
227
228    /**
229     * Loads and instantiates a class given by a property name.
230     *
231     * @param propertyName The property name to look up a class name for.
232     * @param clazz        The class to cast it to.
233     * @param <T>          The type to cast it to.
234     * @return new instance of the class given in the property or {@code null} if the property was unset.
235     * @throws ClassNotFoundException    if the class isn't available to the usual ClassLoaders
236     * @throws IllegalAccessException    if the class can't be instantiated through a public constructor
237     * @throws InstantiationException    if there was an exception whilst instantiating the class
238     * @throws NoSuchMethodException     if there isn't a no-args constructor on the class
239     * @throws InvocationTargetException if there was an exception whilst constructing the class
240     * @throws ClassCastException        if the constructed object isn't type compatible with {@code T}
241     * @since 2.5
242     */
243    public static <T> T newCheckedInstanceOfProperty(final String propertyName, final Class<T> clazz)
244        throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException,
245        IllegalAccessException {
246        final String className = PropertiesUtil.getProperties().getStringProperty(propertyName);
247        if (className == null) {
248            return null;
249        }
250        return newCheckedInstanceOf(className, clazz);
251    }
252
253    private static boolean isIgnoreTccl() {
254        // we need to lazily initialize this, but concurrent access is not an issue
255        if (ignoreTCCL == null) {
256            final String ignoreTccl = PropertiesUtil.getProperties().getStringProperty(IGNORE_TCCL_PROPERTY, null);
257            ignoreTCCL = ignoreTccl != null && !"false".equalsIgnoreCase(ignoreTccl.trim());
258        }
259        return ignoreTCCL;
260    }
261
262    /**
263     * Finds classpath {@linkplain URL resources}.
264     *
265     * @param resource the name of the resource to find.
266     * @return a Collection of URLs matching the resource name. If no resources could be found, then this will be empty.
267     * @since 2.1
268     */
269    public static Collection<URL> findResources(final String resource) {
270        final Collection<UrlResource> urlResources = findUrlResources(resource);
271        final Collection<URL> resources = new LinkedHashSet<>(urlResources.size());
272        for (final UrlResource urlResource : urlResources) {
273            resources.add(urlResource.getUrl());
274        }
275        return resources;
276    }
277
278    static Collection<UrlResource> findUrlResources(final String resource) {
279        final ClassLoader[] candidates = {getThreadContextClassLoader(), LoaderUtil.class.getClassLoader(),
280                GET_CLASS_LOADER_DISABLED ? null : ClassLoader.getSystemClassLoader()};
281        final Collection<UrlResource> resources = new LinkedHashSet<>();
282        for (final ClassLoader cl : candidates) {
283            if (cl != null) {
284                try {
285                    final Enumeration<URL> resourceEnum = cl.getResources(resource);
286                    while (resourceEnum.hasMoreElements()) {
287                        resources.add(new UrlResource(cl, resourceEnum.nextElement()));
288                    }
289                } catch (final IOException e) {
290                    LowLevelLogUtil.logException(e);
291                }
292            }
293        }
294        return resources;
295    }
296
297    /**
298     * {@link URL} and {@link ClassLoader} pair.
299     */
300    static class UrlResource {
301        private final ClassLoader classLoader;
302        private final URL url;
303
304        UrlResource(final ClassLoader classLoader, final URL url) {
305            this.classLoader = classLoader;
306            this.url = url;
307        }
308
309        public ClassLoader getClassLoader() {
310            return classLoader;
311        }
312
313        public URL getUrl() {
314            return url;
315        }
316
317        @Override
318        public boolean equals(final Object o) {
319            if (this == o) {
320                return true;
321            }
322            if (o == null || getClass() != o.getClass()) {
323                return false;
324            }
325
326            final UrlResource that = (UrlResource) o;
327
328            if (classLoader != null ? !classLoader.equals(that.classLoader) : that.classLoader != null) {
329                return false;
330            }
331            if (url != null ? !url.equals(that.url) : that.url != null) {
332                return false;
333            }
334
335            return true;
336        }
337
338        @Override
339        public int hashCode() {
340            return Objects.hashCode(classLoader) + Objects.hashCode(url);
341        }
342    }
343}