1 /*
2 * Copyright (c) 1998, 2005, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include "util.h"
27 #include "ReferenceTypeImpl.h"
28 #include "inStream.h"
29 #include "outStream.h"
30
31
32 static jboolean
33 signature(PacketInputStream *in, PacketOutputStream *out)
34 {
35 char *signature = NULL;
36 jclass clazz;
37 jvmtiError error;
38
39 clazz = inStream_readClassRef(getEnv(), in);
40 if (inStream_error(in)) {
41 return JNI_TRUE;
42 }
43
44 error = classSignature(clazz, &signature, NULL);
45 if (error != JVMTI_ERROR_NONE) {
46 outStream_setError(out, map2jdwpError(error));
47 return JNI_TRUE;
48 }
49
50 (void)outStream_writeString(out, signature);
51 jvmtiDeallocate(signature);
52
53 return JNI_TRUE;
54 }
55
56 static jboolean
57 signatureWithGeneric(PacketInputStream *in, PacketOutputStream *out)
58 {
59 /* Returns both the signature and the generic signature */
60 char *signature = NULL;
61 char *genericSignature = NULL;
62 jclass clazz;
63 jvmtiError error;
64
65 clazz = inStream_readClassRef(getEnv(), in);
66 if (inStream_error(in)) {
67 return JNI_TRUE;
68 }
69 error = classSignature(clazz, &signature, &genericSignature);
70 if (error != JVMTI_ERROR_NONE) {
71 outStream_setError(out, map2jdwpError(error));
72 return JNI_TRUE;
73 }
74
75 (void)outStream_writeString(out, signature);
76 writeGenericSignature(out, genericSignature);
77 jvmtiDeallocate(signature);
78 if (genericSignature != NULL) {
79 jvmtiDeallocate(genericSignature);
80 }
81
82
83 return JNI_TRUE;
84 }
85
86 static jboolean
87 getClassLoader(PacketInputStream *in, PacketOutputStream *out)
88 {
89 jclass clazz;
90 jobject loader;
91 jvmtiError error;
92 JNIEnv *env;
93
94 env = getEnv();
95
96 clazz = inStream_readClassRef(env, in);
97 if (inStream_error(in)) {
98 return JNI_TRUE;
99 }
100
101 error = classLoader(clazz, &loader);
102 if (error != JVMTI_ERROR_NONE) {
103 outStream_setError(out, map2jdwpError(error));
104 return JNI_TRUE;
105 }
106
107 (void)outStream_writeObjectRef(env, out, loader);
108 return JNI_TRUE;
109 }
110
111 static jboolean
112 modifiers(PacketInputStream *in, PacketOutputStream *out)
113 {
114 jint modifiers;
115 jclass clazz;
116 jvmtiError error;
117
118 clazz = inStream_readClassRef(getEnv(), in);
119 if (inStream_error(in)) {
120 return JNI_TRUE;
121 }
122
123 error = JVMTI_FUNC_PTR(gdata->jvmti,GetClassModifiers)
124 (gdata->jvmti, clazz, &modifiers);
125 if (error != JVMTI_ERROR_NONE) {
126 outStream_setError(out, map2jdwpError(error));
127 return JNI_TRUE;
128 }
129
130 (void)outStream_writeInt(out, modifiers);
131
132 return JNI_TRUE;
133 }
134
135 static void
136 writeMethodInfo(PacketOutputStream *out, jclass clazz, jmethodID method,
137 int outputGenerics)
138 {
139 char *name = NULL;
140 char *signature = NULL;
141 char *genericSignature = NULL;
142 jint modifiers;
143 jvmtiError error;
144 jboolean isSynthetic;
145
146 error = isMethodSynthetic(method, &isSynthetic);
147 if (error != JVMTI_ERROR_NONE) {
148 outStream_setError(out, map2jdwpError(error));
149 return;
150 }
151
152 error = methodModifiers(method, &modifiers);
153 if (error != JVMTI_ERROR_NONE) {
154 outStream_setError(out, map2jdwpError(error));
155 return;
156 }
157
158 error = methodSignature(method, &name, &signature, &genericSignature);
159 if (error != JVMTI_ERROR_NONE) {
160 outStream_setError(out, map2jdwpError(error));
161 return;
162 }
163
164 if (isSynthetic) {
165 modifiers |= MOD_SYNTHETIC;
166 }
167 (void)outStream_writeMethodID(out, method);
168 (void)outStream_writeString(out, name);
169 (void)outStream_writeString(out, signature);
170 if (outputGenerics == 1) {
171 writeGenericSignature(out, genericSignature);
172 }
173 (void)outStream_writeInt(out, modifiers);
174 jvmtiDeallocate(name);
175 jvmtiDeallocate(signature);
176 if (genericSignature != NULL) {
177 jvmtiDeallocate(genericSignature);
178 }
179 }
180
181 static jboolean
182 methods1(PacketInputStream *in, PacketOutputStream *out,
183 int outputGenerics)
184 {
185 int i;
186 jclass clazz;
187 jint methodCount = 0;
188 jmethodID *methods = NULL;
189 jvmtiError error;
190
191 clazz = inStream_readClassRef(getEnv(), in);
192 if (inStream_error(in)) {
193 return JNI_TRUE;
194 }
195
196 error = JVMTI_FUNC_PTR(gdata->jvmti,GetClassMethods)
197 (gdata->jvmti, clazz, &methodCount, &methods);
198 if (error != JVMTI_ERROR_NONE) {
199 outStream_setError(out, map2jdwpError(error));
200 return JNI_TRUE;
201 }
202
203 (void)outStream_writeInt(out, methodCount);
204 for (i = 0; (i < methodCount) && !outStream_error(out); i++) {
205 writeMethodInfo(out, clazz, methods[i], outputGenerics);
206 }
207
208 /* Free methods array */
209 if ( methods != NULL ) {
210 jvmtiDeallocate(methods);
211 }
212 return JNI_TRUE;
213 }
214
215 static jboolean
216 methods(PacketInputStream *in, PacketOutputStream *out,
217 int outputGenerics)
218 {
219 return methods1(in, out, 0);
220 }
221
222 static jboolean
223 methodsWithGeneric(PacketInputStream *in, PacketOutputStream *out)
224 {
225 return methods1(in, out, 1);
226 }
227
228
229
230 static jboolean
231 instances(PacketInputStream *in, PacketOutputStream *out)
232 {
233 jint maxInstances;
234 jclass clazz;
235 JNIEnv *env;
236
237 if (gdata->vmDead) {
238 outStream_setError(out, JDWP_ERROR(VM_DEAD));
239 return JNI_TRUE;
240 }
241
242 env = getEnv();
243 clazz = inStream_readClassRef(env, in);
244 maxInstances = inStream_readInt(in);
245 if (inStream_error(in)) {
246 return JNI_TRUE;
247 }
248
249 WITH_LOCAL_REFS(env, 1) {
250 jvmtiError error;
251 ObjectBatch batch;
252
253 error = classInstances(clazz, &batch, maxInstances);
254 if (error != JVMTI_ERROR_NONE) {
255 outStream_setError(out, map2jdwpError(error));
256 } else {
257 int kk;
258 jbyte typeKey;
259
260 (void)outStream_writeInt(out, batch.count);
261 if (batch.count > 0) {
262 /*
263 * They are all instances of this class and will all have
264 * the same typeKey, so just compute it once.
265 */
266 typeKey = specificTypeKey(env, batch.objects[0]);
267
268 for (kk = 0; kk < batch.count; kk++) {
269 jobject inst;
270
271 inst = batch.objects[kk];
272 (void)outStream_writeByte(out, typeKey);
273 (void)outStream_writeObjectRef(env, out, inst);
274 }
275 }
276 jvmtiDeallocate(batch.objects);
277 }
278 } END_WITH_LOCAL_REFS(env);
279
280 return JNI_TRUE;
281 }
282
283 static jboolean
284 getClassVersion(PacketInputStream *in, PacketOutputStream *out)
285 {
286 jclass clazz;
287 jvmtiError error;
288 jint majorVersion;
289 jint minorVersion;
290
291 clazz = inStream_readClassRef(getEnv(), in);
292 if (inStream_error(in)) {
293 return JNI_TRUE;
294 }
295
296 error = JVMTI_FUNC_PTR(gdata->jvmti, GetClassVersionNumbers)
297 (gdata->jvmti, clazz, &minorVersion, &majorVersion);
298 if (error != JVMTI_ERROR_NONE) {
299 outStream_setError(out, map2jdwpError(error));
300 return JNI_TRUE;
301 }
302
303 (void)outStream_writeInt(out, majorVersion);
304 (void)outStream_writeInt(out, minorVersion);
305
306 return JNI_TRUE;
307 }
308
309 static jboolean
310 getConstantPool(PacketInputStream *in, PacketOutputStream *out)
311 {
312
313 jclass clazz;
314 jvmtiError error;
315 jint cpCount;
316 jint cpByteCount;
317 unsigned char* cpBytesPtr;
318
319
320 clazz = inStream_readClassRef(getEnv(), in);
321 if (inStream_error(in)) {
322 return JNI_TRUE;
323 }
324
325 /* Initialize assuming no bytecodes and no error */
326 error = JVMTI_ERROR_NONE;
327 cpCount = 0;
328 cpByteCount = 0;
329 cpBytesPtr = NULL;
330
331
332 error = JVMTI_FUNC_PTR(gdata->jvmti,GetConstantPool)
333 (gdata->jvmti, clazz, &cpCount, &cpByteCount, &cpBytesPtr);
334 if (error != JVMTI_ERROR_NONE) {
335 outStream_setError(out, map2jdwpError(error));
336 } else {
337 (void)outStream_writeInt(out, cpCount);
338 (void)outStream_writeByteArray(out, cpByteCount, (jbyte *)cpBytesPtr);
339 jvmtiDeallocate(cpBytesPtr);
340 }
341
342 return JNI_TRUE;
343 }
344
345 static void
346 writeFieldInfo(PacketOutputStream *out, jclass clazz, jfieldID fieldID,
347 int outputGenerics)
348 {
349 char *name;
350 char *signature = NULL;
351 char *genericSignature = NULL;
352 jint modifiers;
353 jboolean isSynthetic;
354 jvmtiError error;
355
356 error = isFieldSynthetic(clazz, fieldID, &isSynthetic);
357 if (error != JVMTI_ERROR_NONE) {
358 outStream_setError(out, map2jdwpError(error));
359 return;
360 }
361
362 error = fieldModifiers(clazz, fieldID, &modifiers);
363 if (error != JVMTI_ERROR_NONE) {
364 outStream_setError(out, map2jdwpError(error));
365 return;
366 }
367
368 error = fieldSignature(clazz, fieldID, &name, &signature, &genericSignature);
369 if (error != JVMTI_ERROR_NONE) {
370 outStream_setError(out, map2jdwpError(error));
371 return;
372 }
373 if (isSynthetic) {
374 modifiers |= MOD_SYNTHETIC;
375 }
376 (void)outStream_writeFieldID(out, fieldID);
377 (void)outStream_writeString(out, name);
378 (void)outStream_writeString(out, signature);
379 if (outputGenerics == 1) {
380 writeGenericSignature(out, genericSignature);
381 }
382 (void)outStream_writeInt(out, modifiers);
383 jvmtiDeallocate(name);
384 jvmtiDeallocate(signature);
385 if (genericSignature != NULL) {
386 jvmtiDeallocate(genericSignature);
387 }
388 }
389
390 static jboolean
391 fields1(PacketInputStream *in, PacketOutputStream *out, int outputGenerics)
392 {
393 int i;
394 jclass clazz;
395 jint fieldCount = 0;
396 jfieldID *fields = NULL;
397 jvmtiError error;
398
399 clazz = inStream_readClassRef(getEnv(), in);
400 if (inStream_error(in)) {
401 return JNI_TRUE;
402 }
403
404 error = JVMTI_FUNC_PTR(gdata->jvmti,GetClassFields)
405 (gdata->jvmti, clazz, &fieldCount, &fields);
406 if (error != JVMTI_ERROR_NONE) {
407 outStream_setError(out, map2jdwpError(error));
408 return JNI_TRUE;
409 }
410
411 (void)outStream_writeInt(out, fieldCount);
412 for (i = 0; (i < fieldCount) && !outStream_error(out); i++) {
413 writeFieldInfo(out, clazz, fields[i], outputGenerics);
414 }
415
416 /* Free fields array */
417 if ( fields != NULL ) {
418 jvmtiDeallocate(fields);
419 }
420 return JNI_TRUE;
421 }
422
423
424 static jboolean
425 fields(PacketInputStream *in, PacketOutputStream *out)
426 {
427 return fields1(in, out, 0);
428 }
429
430 static jboolean
431 fieldsWithGeneric(PacketInputStream *in, PacketOutputStream *out)
432 {
433 return fields1(in, out, 1);
434
435 }
436
437 static jboolean
438 getValues(PacketInputStream *in, PacketOutputStream *out)
439 {
440 sharedGetFieldValues(in, out, JNI_TRUE);
441 return JNI_TRUE;
442 }
443
444 static jboolean
445 sourceFile(PacketInputStream *in, PacketOutputStream *out)
446 {
447 char *fileName;
448 jvmtiError error;
449 jclass clazz;
450
451 clazz = inStream_readClassRef(getEnv(), in);
452 if (inStream_error(in)) {
453 return JNI_TRUE;
454 }
455
456 error = JVMTI_FUNC_PTR(gdata->jvmti,GetSourceFileName)
457 (gdata->jvmti, clazz, &fileName);
458 if (error != JVMTI_ERROR_NONE) {
459 outStream_setError(out, map2jdwpError(error));
460 return JNI_TRUE;
461 }
462
463 (void)outStream_writeString(out, fileName);
464 jvmtiDeallocate(fileName);
465 return JNI_TRUE;
466 }
467
468 static jboolean
469 sourceDebugExtension(PacketInputStream *in, PacketOutputStream *out)
470 {
471 char *extension;
472 jvmtiError error;
473 jclass clazz;
474
475 clazz = inStream_readClassRef(getEnv(), in);
476 if (inStream_error(in)) {
477 return JNI_TRUE;
478 }
479
480 error = getSourceDebugExtension(clazz, &extension);
481 if (error != JVMTI_ERROR_NONE) {
482 outStream_setError(out, map2jdwpError(error));
483 return JNI_TRUE;
484 }
485
486 (void)outStream_writeString(out, extension);
487 jvmtiDeallocate(extension);
488 return JNI_TRUE;
489 }
490
491 static jboolean
492 nestedTypes(PacketInputStream *in, PacketOutputStream *out)
493 {
494 JNIEnv *env;
495 jclass clazz;
496
497 env = getEnv();
498
499 clazz = inStream_readClassRef(env, in);
500 if (inStream_error(in)) {
501 return JNI_TRUE;
502 }
503
504 WITH_LOCAL_REFS(env, 1) {
505
506 jvmtiError error;
507 jint count;
508 jclass *nested;
509
510 error = allNestedClasses(clazz, &nested, &count);
511 if (error != JVMTI_ERROR_NONE) {
512 outStream_setError(out, map2jdwpError(error));
513 } else {
514 int i;
515 (void)outStream_writeInt(out, count);
516 for (i = 0; i < count; i++) {
517 (void)outStream_writeByte(out, referenceTypeTag(nested[i]));
518 (void)outStream_writeObjectRef(env, out, nested[i]);
519 }
520 if ( nested != NULL ) {
521 jvmtiDeallocate(nested);
522 }
523 }
524
525 } END_WITH_LOCAL_REFS(env);
526
527 return JNI_TRUE;
528 }
529
530 static jboolean
531 getClassStatus(PacketInputStream *in, PacketOutputStream *out)
532 {
533 jint status;
534 jclass clazz;
535
536 clazz = inStream_readClassRef(getEnv(), in);
537 if (inStream_error(in)) {
538 return JNI_TRUE;
539 }
540
541 status = classStatus(clazz);
542 (void)outStream_writeInt(out, map2jdwpClassStatus(status));
543 return JNI_TRUE;
544 }
545
546 static jboolean
547 interfaces(PacketInputStream *in, PacketOutputStream *out)
548 {
549 JNIEnv *env;
550 jclass clazz;
551
552 env = getEnv();
553
554 clazz = inStream_readClassRef(env, in);
555 if (inStream_error(in)) {
556 return JNI_TRUE;
557 }
558
559 WITH_LOCAL_REFS(env, 1) {
560
561 jvmtiError error;
562 jint interfaceCount;
563 jclass *interfaces;
564
565 error = allInterfaces(clazz, &interfaces, &interfaceCount);
566 if (error != JVMTI_ERROR_NONE) {
567 outStream_setError(out, map2jdwpError(error));
568 } else {
569 int i;
570
571 (void)outStream_writeInt(out, interfaceCount);
572 for (i = 0; i < interfaceCount; i++) {
573 (void)outStream_writeObjectRef(env, out, interfaces[i]);
574 }
575 if ( interfaces != NULL ) {
576 jvmtiDeallocate(interfaces);
577 }
578 }
579
580 } END_WITH_LOCAL_REFS(env);
581
582 return JNI_TRUE;
583 }
584
585 static jboolean
586 classObject(PacketInputStream *in, PacketOutputStream *out)
587 {
588 jclass clazz;
589 JNIEnv *env;
590
591 env = getEnv();
592 clazz = inStream_readClassRef(env, in);
593 if (inStream_error(in)) {
594 return JNI_TRUE;
595 }
596
597 /*
598 * In our implementation, the reference type id is the same as the
599 * class object id, so we bounce it right back.
600 *
601 */
602
603 (void)outStream_writeObjectRef(env, out, clazz);
604
605 return JNI_TRUE;
606 }
607
608 void *ReferenceType_Cmds[] = { (void *)18
609 ,(void *)signature
610 ,(void *)getClassLoader
611 ,(void *)modifiers
612 ,(void *)fields
613 ,(void *)methods
614 ,(void *)getValues
615 ,(void *)sourceFile
616 ,(void *)nestedTypes
617 ,(void *)getClassStatus
618 ,(void *)interfaces
619 ,(void *)classObject
620 ,(void *)sourceDebugExtension
621 ,(void *)signatureWithGeneric
622 ,(void *)fieldsWithGeneric
623 ,(void *)methodsWithGeneric
624 ,(void *)instances
625 ,(void *)getClassVersion
626 ,(void *)getConstantPool
627 };