1 /*
2 * Copyright (c) 2018, 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 */
23
24 /*
25 * @test
26 * @bug 8010319
27 * @summary Class redefinition must preclude changes to nest attributes
28 * @library /test/lib
29 * @modules java.base/jdk.internal.misc
30 * @modules java.compiler
31 * java.instrument
32 * jdk.jartool/sun.tools.jar
33 * @compile ../NamedBuffer.java
34 * @run main RedefineClassHelper
35 * @compile Host/Host.java
36 * @run main/othervm -javaagent:redefineagent.jar -Xlog:redefine+class+nestmates=trace TestNestmateAttr Host
37 * @compile HostA/Host.java
38 * @run main/othervm -javaagent:redefineagent.jar -Xlog:redefine+class+nestmates=trace TestNestmateAttr HostA
39 * @compile HostAB/Host.java
40 * @run main/othervm -javaagent:redefineagent.jar -Xlog:redefine+class+nestmates=trace TestNestmateAttr HostAB
41 * @compile HostABC/Host.java
42 * @run main/othervm -javaagent:redefineagent.jar -Xlog:redefine+class+nestmates=trace TestNestmateAttr HostABC
43 */
44
45 /* Test Description
46
47 The basic test class is call Host and we have variants that have zero or more
48 nested classes named A, B, C etc. Each variant of Host is defined in source
49 code in its own directory i.e.
50
51 Host/Host.java defines zero nested classes
52 HostA/Host.java defines one nested class A
53 HostAB/Host.java defines two nested classes A and B (in that order)
54 etc.
55
56 Each Host class has the form:
57
58 public class Host {
59 public static String getID() { return "<directory name>/Host.java"; }
60
61 < zero or more empty nested classes>
62
63 public int m() {
64 return 1; // original class
65 }
66 }
67
68 Under each directory is a directory "redef" with a modified version of the Host
69 class that changes the ID to e.g. Host/redef/Host.java, and the method m()
70 returns 2. This allows us to check we have the redefined class loaded.
71
72 Using Host' to represent the redefined version we test redefinition
73 combinations as follows:
74
75 Host:
76 Host -> Host' - succeeds m() returns 2
77 Host -> HostA' - fails - added a nest member
78
79 HostA:
80 HostA -> HostA' - succeeds m() returns 2
81 HostA -> Host' - fails - removed a nest member
82 HostA -> HostAB' - fails - added a nest member
83 HostA -> HostB' - fails - replaced a nest member
84
85 HostAB:
86 HostAB -> HostAB' - succeeds m() returns 2
87 HostAB -> HostBA' - succeeds m() returns 2
88 HostAB -> HostA' - fails - removed a nest member
89 HostAB -> HostABC' - fails - added a nest member
90 HostAB -> HostAC' - fails - replaced a nest member
91
92 HostABC:
93 HostABC -> HostABC' - succeeds m() returns 2
94 HostABC -> HostACB' - succeeds m() returns 2
95 HostABC -> HostBAC' - succeeds m() returns 2
96 HostABC -> HostBCA' - succeeds m() returns 2
97 HostABC -> HostCAB' - succeeds m() returns 2
98 HostABC -> HostCBA' - succeeds m() returns 2
99 HostABC -> HostAB' - fails - removed a nest member
100 HostABC -> HostABCD' - fails - added a nest member
101 HostABC -> HostABD' - fails - replaced a nest member
102
103 More than three nested classes doesn't add to the code coverage so
104 we stop here.
105
106 Note that we always try to load the redefined version even when we expect it
107 to fail.
108
109 We can only directly load one class Host per classloader, so to run all the
110 groups we either need to use new classloaders, or we reinvoke the test
111 requesting a different primary directory. We chose the latter using
112 multiple @run tags. So we preceed as follows:
113
114 @compile Host/Host.java
115 @run TestNestmateAttr Host
116 @compile HostA/Host.java - replaces previous Host.class
117 @run TestNestmateAttr HostA
118 @compile HostAB/Host.java - replaces previous Host.class
119 @run TestNestmateAttr HostAB
120 etc.
121
122 Within the test we directly compile redefined versions of the classes,
123 using CompilerUtil, and then read the .class file directly as a byte[]
124 to use with the RedefineClassHelper.
125
126 Finally we test redefinition of the NestHost attribute - which is
127 conceptually simple, but in fact very tricky to do. We do that
128 when testing HostA so we can reuse the Host$A class.
129
130 */
131
132 import java.io.File;
133 import java.io.FileInputStream;
134 import jdk.test.lib.ByteCodeLoader;
135 import jdk.test.lib.compiler.CompilerUtils;
136 import jdk.test.lib.compiler.InMemoryJavaCompiler;
137 import static jdk.test.lib.Asserts.assertTrue;
138
139 public class TestNestmateAttr {
140
141 static final String SRC = System.getProperty("test.src");
142 static final String DEST = System.getProperty("test.classes");
143 static final boolean VERBOSE = Boolean.getBoolean("verbose");
144
145 public static void main(String[] args) throws Throwable {
146 String origin = args[0];
147 System.out.println("Testing original Host class from " + origin);
148
149 // Make sure the Host class loaded directly is an original version
150 // and from the expected location
151 Host h = new Host();
152 assertTrue(h.m() == 1);
153 assertTrue(Host.getID().startsWith(origin + "/"));
154
155 String[] badTransforms; // directories of bad classes
156 String[] goodTransforms; // directories of good classes
157
158 boolean testNestHostChanges = false;
159
160 switch (origin) {
161 case "Host":
162 badTransforms = new String[] {
163 "HostA" // add member
164 };
165 goodTransforms = new String[] {
166 origin
167 };
168 break;
169
170 case "HostA":
171 badTransforms = new String[] {
172 "Host", // remove member
173 "HostAB", // add member
174 "HostB" // change member
175 };
176 goodTransforms = new String[] {
177 origin
178 };
179 testNestHostChanges = true;
180 break;
181
182 case "HostAB":
183 badTransforms = new String[] {
184 "HostA", // remove member
185 "HostABC", // add member
186 "HostAC" // change member
187 };
188 goodTransforms = new String[] {
189 origin,
190 "HostBA" // reorder members
191 };
192 break;
193
194 case "HostABC":
195 badTransforms = new String[] {
196 "HostAB", // remove member
197 "HostABCD", // add member
198 "HostABD" // change member
199 };
200 goodTransforms = new String[] {
201 origin,
202 "HostACB", // reorder members
203 "HostBAC", // reorder members
204 "HostBCA", // reorder members
205 "HostCAB", // reorder members
206 "HostCBA" // reorder members
207 };
208 break;
209
210 default: throw new Error("Unknown test directory: " + origin);
211 }
212
213 // Compile and check bad transformations
214 checkBadTransforms(Host.class, badTransforms);
215
216 // Compile and check good transformations
217 checkGoodTransforms(Host.class, goodTransforms);
218
219 if (testNestHostChanges)
220 checkNestHostChanges();
221 }
222
223 static void checkNestHostChanges() throws Throwable {
224 // case 1: remove NestHost attribute
225 // - try to redefine Host$A with a top-level
226 // class called Host$A
227 System.out.println("Trying bad retransform that removes the NestHost attribute");
228
229 String name = "Host$A";
230 // This is compiled as a top-level class: the $ in the name is not
231 // significant to the compiler.
232 String hostA = "public class " + name + " {}";
233
234 // Have to do this reflectively as there is no Host$A
235 // when compiling the "Host/" case.
236 Class<?> nestedA = Class.forName(name);
237
238 try {
239 RedefineClassHelper.redefineClass(nestedA, hostA);
240 throw new Error("Retransformation to top-level class " + name +
241 " succeeded unexpectedly");
242 }
243 catch (UnsupportedOperationException uoe) {
244 if (uoe.getMessage().contains("attempted to change the class Nest")) {
245 System.out.println("Got expected exception " + uoe);
246 }
247 else throw new Error("Wrong UnsupportedOperationException", uoe);
248 }
249
250 // case 2: add NestHost attribute
251 // - This is tricky because the class with no NestHost attribute
252 // has to have the name of a nested class! Plus we need the
253 // redefining class in bytecode form.
254 // - Use the InMemoryJavaCompiler plus ByteCodeLoader to load
255 // the top-level Host$A class
256 // - Try to redefine that class with a real nested Host$A
257
258 System.out.println("Trying bad retransform that adds the NestHost attribute");
259 byte[] bytes = InMemoryJavaCompiler.compile(name, hostA);
260 Class<?> topLevelHostA = ByteCodeLoader.load(name, bytes);
261
262 byte[] nestedBytes;
263 File clsfile = new File(DEST + "/" + name + ".class");
264 if (VERBOSE) System.out.println("Reading bytes from " + clsfile);
265 try (FileInputStream str = new FileInputStream(clsfile)) {
266 nestedBytes = NamedBuffer.loadBufferFromStream(str);
267 }
268 try {
269 RedefineClassHelper.redefineClass(topLevelHostA, nestedBytes);
270 throw new Error("Retransformation to nested class " + name +
271 " succeeded unexpectedly");
272 }
273 catch (UnsupportedOperationException uoe) {
274 if (uoe.getMessage().contains("attempted to change the class Nest")) {
275 System.out.println("Got expected exception " + uoe);
276 }
277 else throw new Error("Wrong UnsupportedOperationException", uoe);
278 }
279
280 // case 3: replace the NestHost attribute
281 // - the easiest way (perhaps only reasonable way) to do this
282 // is to search for the Utf8 entry used by the Constant_ClassRef,
283 // set in the NestHost attribute, and edit it to refer to a different
284 // name.
285 System.out.println("Trying bad retransform that changes the NestHost attribute");
286 int utf8Entry_length = 7;
287 boolean found = false;
288 for (int i = 0; i < nestedBytes.length - utf8Entry_length; i++) {
289 if (nestedBytes[i] == 1 && // utf8 tag
290 nestedBytes[i+1] == 0 && // msb of length
291 nestedBytes[i+2] == 4 && // lsb of length
292 nestedBytes[i+3] == (byte) 'H' &&
293 nestedBytes[i+4] == (byte) 'o' &&
294 nestedBytes[i+5] == (byte) 's' &&
295 nestedBytes[i+6] == (byte) 't') {
296
297 if (VERBOSE) System.out.println("Appear to have found Host utf8 entry starting at " + i);
298
299 nestedBytes[i+3] = (byte) 'G';
300 found = true;
301 break;
302 }
303 }
304
305 if (!found)
306 throw new Error("Could not locate 'Host' name in byte array");
307
308 try {
309 RedefineClassHelper.redefineClass(nestedA, nestedBytes);
310 throw new Error("Retransformation to modified nested class" +
311 " succeeded unexpectedly");
312 }
313 catch (UnsupportedOperationException uoe) {
314 if (uoe.getMessage().contains("attempted to change the class Nest")) {
315 System.out.println("Got expected exception " + uoe);
316 }
317 else throw new Error("Wrong UnsupportedOperationException", uoe);
318 }
319
320 }
321
322 static void checkGoodTransforms(Class<?> c, String[] dirs) throws Throwable {
323 for (String dir : dirs) {
324 dir += "/redef";
325 System.out.println("Trying good retransform from " + dir);
326 byte[] buf = bytesForHostClass(dir);
327 RedefineClassHelper.redefineClass(c, buf);
328
329 // Test redefintion worked
330 Host h = new Host();
331 assertTrue(h.m() == 2);
332 if (VERBOSE) System.out.println("Redefined ID: " + Host.getID());
333 assertTrue(Host.getID().startsWith(dir));
334 }
335 }
336
337 static void checkBadTransforms(Class<?> c, String[] dirs) throws Throwable {
338 for (String dir : dirs) {
339 dir += "/redef";
340 System.out.println("Trying bad retransform from " + dir);
341 byte[] buf = bytesForHostClass(dir);
342 try {
343 RedefineClassHelper.redefineClass(c, buf);
344 throw new Error("Retransformation from directory " + dir +
345 " succeeded unexpectedly");
346 }
347 catch (UnsupportedOperationException uoe) {
348 if (uoe.getMessage().contains("attempted to change the class Nest")) {
349 System.out.println("Got expected exception " + uoe);
350 }
351 else throw new Error("Wrong UnsupportedOperationException", uoe);
352 }
353 }
354 }
355
356 static byte[] bytesForHostClass(String dir) throws Throwable {
357 compile("/" + dir);
358 File clsfile = new File(DEST + "/" + dir + "/Host.class");
359 if (VERBOSE) System.out.println("Reading bytes from " + clsfile);
360 byte[] buf = null;
361 try (FileInputStream str = new FileInputStream(clsfile)) {
362 return buf = NamedBuffer.loadBufferFromStream(str);
363 }
364 }
365
366 static void compile(String dir) throws Throwable {
367 File src = new File(SRC + dir);
368 File dst = new File(DEST + dir);
369 if (VERBOSE) System.out.println("Compiling from: " + src + "\n" +
370 " to: " + dst);
371 CompilerUtils.compile(src.toPath(),
372 dst.toPath(),
373 false /* don't recurse */,
374 new String[0]);
375 }
376 }