FileHandlerPatternExceptions.java revision 11822:110f7f35760f 
1/*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23import java.io.ByteArrayInputStream;
24import java.io.ByteArrayOutputStream;
25import java.io.IOException;
26import java.nio.file.Files;
27import java.nio.file.Paths;
28import java.security.AccessControlException;
29import java.security.CodeSource;
30import java.security.Permission;
31import java.security.PermissionCollection;
32import java.security.Permissions;
33import java.security.Policy;
34import java.security.ProtectionDomain;
35import java.util.Arrays;
36import java.util.Collections;
37import java.util.Enumeration;
38import java.util.List;
39import java.util.Properties;
40import java.util.UUID;
41import java.util.concurrent.atomic.AtomicBoolean;
42import java.util.logging.FileHandler;
43import java.util.logging.LogManager;
44
45/**
46 * @test
47 * @bug 8025690
48 * @summary tests that an empty or null pattern always result in an exception.
49 * @run main/othervm FileHandlerPatternExceptions UNSECURE
50 * @run main/othervm FileHandlerPatternExceptions SECURE
51 * @author danielfuchs
52 * @key randomness
53 */
54public class FileHandlerPatternExceptions {
55
56    /**
57     * We will test null/empty pattern in two configurations.
58     * UNSECURE: No security manager.
59     * SECURE: With the security manager present - and the required
60     *         permissions granted.
61     */
62    public static enum TestCase {
63        UNSECURE, SECURE;
64        public void run(Properties propertyFile) throws Exception {
65            System.out.println("Running test case: " + name());
66            Configure.setUp(this, propertyFile);
67            test(this.name() + " " + propertyFile.getProperty("test.name"));
68        }
69    }
70
71
72    private static final String PREFIX =
73            "FileHandler-" + UUID.randomUUID() + ".log";
74    private static final String userDir = System.getProperty("user.dir", ".");
75    private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));
76
77    private static final List<Properties> properties;
78    static {
79        Properties props1 = new Properties();
80        Properties props2 = new Properties();
81        props1.setProperty("test.name", "with count=1");
82        props1.setProperty(FileHandler.class.getName() + ".pattern", "");
83        props1.setProperty(FileHandler.class.getName() + ".count", "1");
84        props2.setProperty("test.name", "with count=2");
85        props2.setProperty(FileHandler.class.getName() + ".pattern", "");
86        props2.setProperty(FileHandler.class.getName() + ".count", "2");
87        properties = Collections.unmodifiableList(Arrays.asList(
88                    props1,
89                    props2));
90    }
91
92    public static void main(String... args) throws Exception {
93
94
95        if (args == null || args.length == 0) {
96            args = new String[] {
97                TestCase.UNSECURE.name(),
98                TestCase.SECURE.name(),
99            };
100        }
101
102        try {
103            for (String testName : args) {
104                for (Properties propertyFile : properties) {
105                    TestCase test = TestCase.valueOf(testName);
106                    test.run(propertyFile);
107                }
108            }
109        } finally {
110            if (userDirWritable) {
111                Configure.doPrivileged(() -> {
112                    // cleanup - delete files that have been created
113                    try {
114                        Files.list(Paths.get(userDir))
115                            .filter((f) -> f.toString().contains(PREFIX))
116                            .forEach((f) -> {
117                                try {
118                                    System.out.println("deleting " + f);
119                                    Files.delete(f);
120                                } catch(Throwable t) {
121                                    System.err.println("Failed to delete " + f + ": " + t);
122                                }
123                            });
124                    } catch(Throwable t) {
125                        System.err.println("Cleanup failed to list files: " + t);
126                        t.printStackTrace();
127                    }
128                });
129            }
130        }
131    }
132
133    static class Configure {
134        static Policy policy = null;
135        static final AtomicBoolean allowAll = new AtomicBoolean(false);
136        static void setUp(TestCase test, Properties propertyFile) {
137            switch (test) {
138                case SECURE:
139                    if (policy == null && System.getSecurityManager() != null) {
140                        throw new IllegalStateException("SecurityManager already set");
141                    } else if (policy == null) {
142                        policy = new SimplePolicy(TestCase.SECURE, allowAll);
143                        Policy.setPolicy(policy);
144                        System.setSecurityManager(new SecurityManager());
145                    }
146                    if (System.getSecurityManager() == null) {
147                        throw new IllegalStateException("No SecurityManager.");
148                    }
149                    if (policy == null) {
150                        throw new IllegalStateException("policy not configured");
151                    }
152                    break;
153                case UNSECURE:
154                    if (System.getSecurityManager() != null) {
155                        throw new IllegalStateException("SecurityManager already set");
156                    }
157                    break;
158                default:
159                    new InternalError("No such testcase: " + test);
160            }
161            doPrivileged(() -> {
162                try {
163                    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
164                    propertyFile.store(bytes, propertyFile.getProperty("test.name"));
165                    ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());
166                    LogManager.getLogManager().readConfiguration(bais);
167                } catch (IOException ex) {
168                    throw new RuntimeException(ex);
169                }
170            });
171        }
172        static void doPrivileged(Runnable run) {
173            allowAll.set(true);
174            try {
175                run.run();
176            } finally {
177                allowAll.set(false);
178            }
179        }
180    }
181
182    @FunctionalInterface
183    public static interface FileHandlerSupplier {
184        public FileHandler test() throws Exception;
185    }
186
187    private static void checkException(Class<? extends Exception> type, FileHandlerSupplier test) {
188        Throwable t = null;
189        FileHandler f = null;
190        try {
191            f = test.test();
192        } catch (Throwable x) {
193            t = x;
194        }
195        try {
196            if (type != null && t == null) {
197                throw new RuntimeException("Expected " + type.getName() + " not thrown");
198            } else if (type != null && t != null) {
199                if (type.isInstance(t)) {
200                    System.out.println("Recieved expected exception: " + t);
201                } else {
202                    throw new RuntimeException("Exception type mismatch: "
203                        + type.getName() + " expected, "
204                        + t.getClass().getName() + " received.", t);
205                }
206            } else if (t != null) {
207                throw new RuntimeException("Unexpected exception received: " + t, t);
208            }
209        } finally {
210            if (f != null) {
211                // f should always be null when an exception is expected,
212                // but in case the test doesn't behave as expected we will
213                // want to close f.
214                try { f.close(); } catch (Throwable x) {};
215            }
216        }
217    }
218
219    public static void test(String name) throws Exception {
220        System.out.println("Testing: " + name);
221        checkException(RuntimeException.class, () -> new FileHandler());
222        checkException(IllegalArgumentException.class, () -> new FileHandler(""));
223        checkException(NullPointerException.class, () -> new FileHandler(null));
224
225        checkException(IllegalArgumentException.class, () -> new FileHandler("", true));
226        checkException(IllegalArgumentException.class, () -> new FileHandler("", false));
227        checkException(NullPointerException.class, () -> new FileHandler(null, true));
228        checkException(NullPointerException.class, () -> new FileHandler(null, false));
229
230        checkException(IllegalArgumentException.class, () -> new FileHandler("", 1, 1));
231        checkException(IllegalArgumentException.class, () -> new FileHandler(PREFIX, 0, 0));
232        checkException(IllegalArgumentException.class, () -> new FileHandler(PREFIX, -1, 1));
233        checkException(IllegalArgumentException.class, () -> new FileHandler("", 0, 0));
234        checkException(IllegalArgumentException.class, () -> new FileHandler("", -1, 1));
235
236        checkException(IllegalArgumentException.class, () -> new FileHandler("", 1, 1, true));
237        checkException(IllegalArgumentException.class, () -> new FileHandler(PREFIX, 0, 0, true));
238        checkException(IllegalArgumentException.class, () -> new FileHandler(PREFIX, -1, 1, true));
239        checkException(IllegalArgumentException.class, () -> new FileHandler("", 0, 0, true));
240        checkException(IllegalArgumentException.class, () -> new FileHandler("", -1, 1, true));
241
242        checkException(IllegalArgumentException.class, () -> new FileHandler("", 1, 1, false));
243        checkException(IllegalArgumentException.class, () -> new FileHandler(PREFIX, 0, 0, false));
244        checkException(IllegalArgumentException.class, () -> new FileHandler(PREFIX, -1, 1, false));
245        checkException(IllegalArgumentException.class, () -> new FileHandler("", 0, 0, false));
246        checkException(IllegalArgumentException.class, () -> new FileHandler("", -1, 1, false));
247
248        final Class<? extends Exception> expectedException =
249                System.getSecurityManager() != null ? AccessControlException.class : null;
250
251        if (userDirWritable || expectedException != null) {
252            // These calls will create files in user.dir in the UNSECURE case.
253            // The file name contain a random UUID (PREFIX) which identifies them
254            // and allow us to remove them cleanly at the end (see finally block
255            // in main()).
256            checkException(expectedException,
257                           () -> new FileHandler(PREFIX, 0, 1, true));
258            checkException(expectedException,
259                           () -> new FileHandler(PREFIX, 1, 2, true));
260            checkException(expectedException,
261                           () -> new FileHandler(PREFIX, 0, 1, false));
262            checkException(expectedException,
263                           () -> new FileHandler(PREFIX, 1, 2, false));
264        }
265    }
266
267
268    final static class PermissionsBuilder {
269        final Permissions perms;
270        public PermissionsBuilder() {
271            this(new Permissions());
272        }
273        public PermissionsBuilder(Permissions perms) {
274            this.perms = perms;
275        }
276        public PermissionsBuilder add(Permission p) {
277            perms.add(p);
278            return this;
279        }
280        public PermissionsBuilder addAll(PermissionCollection col) {
281            if (col != null) {
282                for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
283                    perms.add(e.nextElement());
284                }
285            }
286            return this;
287        }
288        public Permissions toPermissions() {
289            final PermissionsBuilder builder = new PermissionsBuilder();
290            builder.addAll(perms);
291            return builder.perms;
292        }
293    }
294
295    public static class SimplePolicy extends Policy {
296
297        final Permissions permissions;
298        final Permissions allPermissions;
299        final AtomicBoolean allowAll;
300        public SimplePolicy(TestCase test, AtomicBoolean allowAll) {
301            this.allowAll = allowAll;
302            // we don't actually need any permission to create our
303            // FileHandlers because we're passing invalid parameters
304            // which will make the creation fail...
305            permissions = new Permissions();
306
307            // these are used for configuring the test itself...
308            allPermissions = new Permissions();
309            allPermissions.add(new java.security.AllPermission());
310
311        }
312
313        @Override
314        public boolean implies(ProtectionDomain domain, Permission permission) {
315            if (allowAll.get()) return allPermissions.implies(permission);
316            return permissions.implies(permission);
317        }
318
319        @Override
320        public PermissionCollection getPermissions(CodeSource codesource) {
321            return new PermissionsBuilder().addAll(allowAll.get()
322                    ? allPermissions : permissions).toPermissions();
323        }
324
325        @Override
326        public PermissionCollection getPermissions(ProtectionDomain domain) {
327            return new PermissionsBuilder().addAll(allowAll.get()
328                    ? allPermissions : permissions).toPermissions();
329        }
330    }
331
332}
333