1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/*
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
* @bug 4140511
* @summary RMIClassLoader's loadClass() methods, when there is no security
* manager installed, should not create or use RMI class loader instances for
* the requested codebases, but they should still succeed to load classes
* that can be found by delegation to parent class loader that would have
* been used for the RMI class loader instance.
* @author Peter Jones
*
* @build Dummy LocalDummy
* @run main/othervm/timeout=120 NoSecurityManager
*/
import java.io.*;
import java.net.*;
import java.security.*;
import java.rmi.server.RMIClassLoader;
/**
* NoSecurityManager verifies the behavior of the RMIClassLoader.loadClass()
* methods when there is no security manager installed in JDK1.2 as prescribed
* by RFE 4140511.
*
* First, a class installed in a codebase (and not in the test's class path)
* is loaded using RMIClassLoader.loadClass(); this should fail with a
* ClassNotFoundException (it failed with a SecurityException in JDK 1.1).
*
* Second, a class installed in the test's class path is loaded using
* RMIClassLoader.loadClass(), which should succeed (again, this used
* to fail with a SecurityException in JDK 1.1).
*/
public class NoSecurityManager {
/** name of target class to attempt to load */
private static final String className = "Dummy";
/** name of file containing definition for target class */
private static final String classFileName = className + ".class";
public static void main(String[] args) throws Exception {
/*
* Specify the file to contain the class definition.
* Make sure that there is a "classes" subdirectory underneath
* the working directory to be used as the codebase for the
* class definition to be located.
*/
File dstDir = new File(System.getProperty("user.dir"), "codebase");
if (!dstDir.exists()) {
if (!dstDir.mkdir()) {
throw new RuntimeException(
"could not create codebase directory");
}
}
File dstFile = new File(dstDir, classFileName);
/*
* Specify where we will copy the class definition from, if
* necessary. After the test is built, the class file can be
* found in the "test.classes" directory.
*/
File srcDir = new File(System.getProperty("test.classes", "."));
File srcFile = new File(srcDir, classFileName);
/*
* If the class definition is not already located at the codebase,
* copy it there from the test build area.
*/
if (!dstFile.exists()) {
if (!srcFile.exists()) {
throw new RuntimeException(
"could not find class file to install in codebase " +
"(try rebuilding the test)");
}
if (!srcFile.renameTo(dstFile)) {
throw new RuntimeException(
"could not install class file in codebase");
}
}
/*
* After the class definition is successfully installed at the
* codebase, delete it from the test's CLASSPATH, so that it will
* not be found there first before the codebase is searched.
*/
if (srcFile.exists()) {
if (!srcFile.delete()) {
throw new RuntimeException(
"could not delete duplicate class file in CLASSPATH");
}
}
/*
* Obtain the URL for the codebase.
*/
URL codebaseURL = new URL("file", "",
dstDir.getAbsolutePath().replace(File.separatorChar, '/') + "/");
/*
* No security manager has been set: verify that we cannot load
* a class from a specified codebase (that is not in the class path).
*/
try {
RMIClassLoader.loadClass(codebaseURL, className);
throw new RuntimeException(
"TEST FAILED: class loaded successfully from codebase");
} catch (ClassNotFoundException e) {
System.err.println(e.toString());
}
/*
* No security manager has been set: verify that we can still
* load a class available in the context class loader (class path).
*/
RMIClassLoader.loadClass(codebaseURL, "LocalDummy");
System.err.println("TEST PASSED: local class loaded successfully");
/*
* Verify that getClassLoader returns context class loader
* if no security manager is set.
*/
System.err.println("/nTest getClassLoader with no security manager set");
ClassLoader loader = RMIClassLoader.getClassLoader("http://codebase");
if (loader == Thread.currentThread().getContextClassLoader()) {
System.err.println("TEST PASSED: returned context class loader");
} else {
throw new RuntimeException(
"TEST FAILED: returned RMI-created class loader");
}
}
}
|
