1 /* 2 * Copyright (c) 1998, 2008, 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 package com.sun.tools.jdi; 27 28 import com.sun.jdi.*; 29 import java.util.*; 30 import java.io.ByteArrayOutputStream; 31 32 class PacketStream { 33 final VirtualMachineImpl vm; 34 private int inCursor = 0; 35 final Packet pkt; 36 private ByteArrayOutputStream dataStream = new ByteArrayOutputStream(); 37 private boolean isCommitted = false; 38 39 PacketStream(VirtualMachineImpl vm, int cmdSet, int cmd) { 40 this.vm = vm; 41 this.pkt = new Packet(); 42 pkt.cmdSet = (short)cmdSet; 43 pkt.cmd = (short)cmd; 44 } 45 46 PacketStream(VirtualMachineImpl vm, Packet pkt) { 47 this.vm = vm; 48 this.pkt = pkt; 49 this.isCommitted = true; /* read only stream */ 50 } 51 52 int id() { 53 return pkt.id; 54 } 55 56 void send() { 57 if (!isCommitted) { 58 pkt.data = dataStream.toByteArray(); 59 vm.sendToTarget(pkt); 60 isCommitted = true; 61 } 62 } 63 64 void waitForReply() throws JDWPException { 65 if (!isCommitted) { 66 throw new InternalException("waitForReply without send"); 67 } 68 69 vm.waitForTargetReply(pkt); 70 71 if (pkt.errorCode != Packet.ReplyNoError) { 72 throw new JDWPException(pkt.errorCode); 73 } 74 } 75 76 void writeBoolean(boolean data) { 77 if(data) { 78 dataStream.write( 1 ); 79 } else { 80 dataStream.write( 0 ); 81 } 82 } 83 84 void writeByte(byte data) { 85 dataStream.write( data ); 86 } 87 88 void writeChar(char data) { 89 dataStream.write( (byte)((data >>> 8) & 0xFF) ); 90 dataStream.write( (byte)((data >>> 0) & 0xFF) ); 91 } 92 93 void writeShort(short data) { 94 dataStream.write( (byte)((data >>> 8) & 0xFF) ); 95 dataStream.write( (byte)((data >>> 0) & 0xFF) ); 96 } 97 98 void writeInt(int data) { 99 dataStream.write( (byte)((data >>> 24) & 0xFF) ); 100 dataStream.write( (byte)((data >>> 16) & 0xFF) ); 101 dataStream.write( (byte)((data >>> 8) & 0xFF) ); 102 dataStream.write( (byte)((data >>> 0) & 0xFF) ); 103 } 104 105 void writeLong(long data) { 106 dataStream.write( (byte)((data >>> 56) & 0xFF) ); 107 dataStream.write( (byte)((data >>> 48) & 0xFF) ); 108 dataStream.write( (byte)((data >>> 40) & 0xFF) ); 109 dataStream.write( (byte)((data >>> 32) & 0xFF) ); 110 111 dataStream.write( (byte)((data >>> 24) & 0xFF) ); 112 dataStream.write( (byte)((data >>> 16) & 0xFF) ); 113 dataStream.write( (byte)((data >>> 8) & 0xFF) ); 114 dataStream.write( (byte)((data >>> 0) & 0xFF) ); 115 } 116 117 void writeFloat(float data) { 118 writeInt(Float.floatToIntBits(data)); 119 } 120 121 void writeDouble(double data) { 122 writeLong(Double.doubleToLongBits(data)); 123 } 124 125 void writeID(int size, long data) { 126 switch (size) { 127 case 8: 128 writeLong(data); 129 break; 130 case 4: 131 writeInt((int)data); 132 break; 133 case 2: 134 writeShort((short)data); 135 break; 136 default: 137 throw new UnsupportedOperationException("JDWP: ID size not supported: " + size); 138 } 139 } 140 141 void writeNullObjectRef() { 142 writeObjectRef(0); 143 } 144 145 void writeObjectRef(long data) { 146 writeID(vm.sizeofObjectRef, data); 147 } 148 149 void writeClassRef(long data) { 150 writeID(vm.sizeofClassRef, data); 151 } 152 153 void writeMethodRef(long data) { 154 writeID(vm.sizeofMethodRef, data); 155 } 156 157 void writeFieldRef(long data) { 158 writeID(vm.sizeofFieldRef, data); 159 } 160 161 void writeFrameRef(long data) { 162 writeID(vm.sizeofFrameRef, data); 163 } 164 165 void writeByteArray(byte[] data) { 166 dataStream.write(data, 0, data.length); 167 } 168 169 void writeString(String string) { 170 try { 171 byte[] stringBytes = string.getBytes("UTF8"); 172 writeInt(stringBytes.length); 173 writeByteArray(stringBytes); 174 } catch (java.io.UnsupportedEncodingException e) { 175 throw new InternalException("Cannot convert string to UTF8 bytes"); 176 } 177 } 178 179 void writeLocation(Location location) { 180 ReferenceTypeImpl refType = (ReferenceTypeImpl)location.declaringType(); 181 byte tag; 182 if (refType instanceof ClassType) { 183 tag = JDWP.TypeTag.CLASS; 184 } else if (refType instanceof InterfaceType) { 185 // It's possible to have executable code in an interface 186 tag = JDWP.TypeTag.INTERFACE; 187 } else { 188 throw new InternalException("Invalid Location"); 189 } 190 writeByte(tag); 191 writeClassRef(refType.ref()); 192 writeMethodRef(((MethodImpl)location.method()).ref()); 193 writeLong(location.codeIndex()); 194 } 195 196 void writeValue(Value val) { 197 try { 198 writeValueChecked(val); 199 } catch (InvalidTypeException exc) { // should never happen 200 throw new RuntimeException( 201 "Internal error: Invalid Tag/Type pair"); 202 } 203 } 204 205 void writeValueChecked(Value val) throws InvalidTypeException { 206 writeByte(ValueImpl.typeValueKey(val)); 207 writeUntaggedValue(val); 208 } 209 210 void writeUntaggedValue(Value val) { 211 try { 212 writeUntaggedValueChecked(val); 213 } catch (InvalidTypeException exc) { // should never happen 214 throw new RuntimeException( 215 "Internal error: Invalid Tag/Type pair"); 216 } 217 } 218 219 void writeUntaggedValueChecked(Value val) throws InvalidTypeException { 220 byte tag = ValueImpl.typeValueKey(val); 221 if (isObjectTag(tag)) { 222 if (val == null) { 223 writeObjectRef(0); 224 } else { 225 if (!(val instanceof ObjectReference)) { 226 throw new InvalidTypeException(); 227 } 228 writeObjectRef(((ObjectReferenceImpl)val).ref()); 229 } 230 } else { 231 switch (tag) { 232 case JDWP.Tag.BYTE: 233 if(!(val instanceof ByteValue)) 234 throw new InvalidTypeException(); 235 236 writeByte(((PrimitiveValue)val).byteValue()); 237 break; 238 239 case JDWP.Tag.CHAR: 240 if(!(val instanceof CharValue)) 241 throw new InvalidTypeException(); 242 243 writeChar(((PrimitiveValue)val).charValue()); 244 break; 245 246 case JDWP.Tag.FLOAT: 247 if(!(val instanceof FloatValue)) 248 throw new InvalidTypeException(); 249 250 writeFloat(((PrimitiveValue)val).floatValue()); 251 break; 252 253 case JDWP.Tag.DOUBLE: 254 if(!(val instanceof DoubleValue)) 255 throw new InvalidTypeException(); 256 257 writeDouble(((PrimitiveValue)val).doubleValue()); 258 break; 259 260 case JDWP.Tag.INT: 261 if(!(val instanceof IntegerValue)) 262 throw new InvalidTypeException(); 263 264 writeInt(((PrimitiveValue)val).intValue()); 265 break; 266 267 case JDWP.Tag.LONG: 268 if(!(val instanceof LongValue)) 269 throw new InvalidTypeException(); 270 271 writeLong(((PrimitiveValue)val).longValue()); 272 break; 273 274 case JDWP.Tag.SHORT: 275 if(!(val instanceof ShortValue)) 276 throw new InvalidTypeException(); 277 278 writeShort(((PrimitiveValue)val).shortValue()); 279 break; 280 281 case JDWP.Tag.BOOLEAN: 282 if(!(val instanceof BooleanValue)) 283 throw new InvalidTypeException(); 284 285 writeBoolean(((PrimitiveValue)val).booleanValue()); 286 break; 287 } 288 } 289 } 290 291 292 293 /** 294 * Read byte represented as one bytes. 295 */ 296 byte readByte() { 297 byte ret = pkt.data[inCursor]; 298 inCursor += 1; 299 return ret; 300 } 301 302 /** 303 * Read boolean represented as one byte. 304 */ 305 boolean readBoolean() { 306 byte ret = readByte(); 307 return (ret != 0); 308 } 309 310 /** 311 * Read char represented as two bytes. 312 */ 313 char readChar() { 314 int b1, b2; 315 316 b1 = pkt.data[inCursor++] & 0xff; 317 b2 = pkt.data[inCursor++] & 0xff; 318 319 return (char)((b1 << 8) + b2); 320 } 321 322 /** 323 * Read short represented as two bytes. 324 */ 325 short readShort() { 326 int b1, b2; 327 328 b1 = pkt.data[inCursor++] & 0xff; 329 b2 = pkt.data[inCursor++] & 0xff; 330 331 return (short)((b1 << 8) + b2); 332 } 333 334 /** 335 * Read int represented as four bytes. 336 */ 337 int readInt() { 338 int b1,b2,b3,b4; 339 340 b1 = pkt.data[inCursor++] & 0xff; 341 b2 = pkt.data[inCursor++] & 0xff; 342 b3 = pkt.data[inCursor++] & 0xff; 343 b4 = pkt.data[inCursor++] & 0xff; 344 345 return ((b1 << 24) + (b2 << 16) + (b3 << 8) + b4); 346 } 347 348 /** 349 * Read long represented as eight bytes. 350 */ 351 long readLong() { 352 long b1,b2,b3,b4; 353 long b5,b6,b7,b8; 354 355 b1 = pkt.data[inCursor++] & 0xff; 356 b2 = pkt.data[inCursor++] & 0xff; 357 b3 = pkt.data[inCursor++] & 0xff; 358 b4 = pkt.data[inCursor++] & 0xff; 359 360 b5 = pkt.data[inCursor++] & 0xff; 361 b6 = pkt.data[inCursor++] & 0xff; 362 b7 = pkt.data[inCursor++] & 0xff; 363 b8 = pkt.data[inCursor++] & 0xff; 364 365 return ((b1 << 56) + (b2 << 48) + (b3 << 40) + (b4 << 32) 366 + (b5 << 24) + (b6 << 16) + (b7 << 8) + b8); 367 } 368 369 /** 370 * Read float represented as four bytes. 371 */ 372 float readFloat() { 373 return Float.intBitsToFloat(readInt()); 374 } 375 376 /** 377 * Read double represented as eight bytes. 378 */ 379 double readDouble() { 380 return Double.longBitsToDouble(readLong()); 381 } 382 383 /** 384 * Read string represented as four byte length followed by 385 * characters of the string. 386 */ 387 String readString() { 388 String ret; 389 int len = readInt(); 390 391 try { 392 ret = new String(pkt.data, inCursor, len, "UTF8"); 393 } catch(java.io.UnsupportedEncodingException e) { 394 System.err.println(e); 395 ret = "Conversion error!"; 396 } 397 inCursor += len; 398 return ret; 399 } 400 401 private long readID(int size) { 402 switch (size) { 403 case 8: 404 return readLong(); 405 case 4: 406 return (long)readInt(); 407 case 2: 408 return (long)readShort(); 409 default: 410 throw new UnsupportedOperationException("JDWP: ID size not supported: " + size); 411 } 412 } 413 414 /** 415 * Read object represented as vm specific byte sequence. 416 */ 417 long readObjectRef() { 418 return readID(vm.sizeofObjectRef); 419 } 420 421 long readClassRef() { 422 return readID(vm.sizeofClassRef); 423 } 424 425 ObjectReferenceImpl readTaggedObjectReference() { 426 byte typeKey = readByte(); 427 return vm.objectMirror(readObjectRef(), typeKey); 428 } 429 430 ObjectReferenceImpl readObjectReference() { 431 return vm.objectMirror(readObjectRef()); 432 } 433 434 StringReferenceImpl readStringReference() { 435 long ref = readObjectRef(); 436 return vm.stringMirror(ref); 437 } 438 439 ArrayReferenceImpl readArrayReference() { 440 long ref = readObjectRef(); 441 return vm.arrayMirror(ref); 442 } 443 444 ThreadReferenceImpl readThreadReference() { 445 long ref = readObjectRef(); 446 return vm.threadMirror(ref); 447 } 448 449 ThreadGroupReferenceImpl readThreadGroupReference() { 450 long ref = readObjectRef(); 451 return vm.threadGroupMirror(ref); 452 } 453 454 ClassLoaderReferenceImpl readClassLoaderReference() { 455 long ref = readObjectRef(); 456 return vm.classLoaderMirror(ref); 457 } 458 459 ClassObjectReferenceImpl readClassObjectReference() { 460 long ref = readObjectRef(); 461 return vm.classObjectMirror(ref); 462 } 463 464 ReferenceTypeImpl readReferenceType() { 465 byte tag = readByte(); 466 long ref = readObjectRef(); 467 return vm.referenceType(ref, tag); 468 } 469 470 /** 471 * Read method reference represented as vm specific byte sequence. 472 */ 473 long readMethodRef() { 474 return readID(vm.sizeofMethodRef); 475 } 476 477 /** 478 * Read field reference represented as vm specific byte sequence. 479 */ 480 long readFieldRef() { 481 return readID(vm.sizeofFieldRef); 482 } 483 484 /** 485 * Read field represented as vm specific byte sequence. 486 */ 487 Field readField() { 488 ReferenceTypeImpl refType = readReferenceType(); 489 long fieldRef = readFieldRef(); 490 return refType.getFieldMirror(fieldRef); 491 } 492 493 /** 494 * Read frame represented as vm specific byte sequence. 495 */ 496 long readFrameRef() { 497 return readID(vm.sizeofFrameRef); 498 } 499 500 /** 501 * Read a value, first byte describes type of value to read. 502 */ 503 ValueImpl readValue() { 504 byte typeKey = readByte(); 505 return readUntaggedValue(typeKey); 506 } 507 508 ValueImpl readUntaggedValue(byte typeKey) { 509 ValueImpl val = null; 510 511 if (isObjectTag(typeKey)) { 512 val = vm.objectMirror(readObjectRef(), typeKey); 513 } else { 514 switch(typeKey) { 515 case JDWP.Tag.BYTE: 516 val = new ByteValueImpl(vm, readByte()); 517 break; 518 519 case JDWP.Tag.CHAR: 520 val = new CharValueImpl(vm, readChar()); 521 break; 522 523 case JDWP.Tag.FLOAT: 524 val = new FloatValueImpl(vm, readFloat()); 525 break; 526 527 case JDWP.Tag.DOUBLE: 528 val = new DoubleValueImpl(vm, readDouble()); 529 break; 530 531 case JDWP.Tag.INT: 532 val = new IntegerValueImpl(vm, readInt()); 533 break; 534 535 case JDWP.Tag.LONG: 536 val = new LongValueImpl(vm, readLong()); 537 break; 538 539 case JDWP.Tag.SHORT: 540 val = new ShortValueImpl(vm, readShort()); 541 break; 542 543 case JDWP.Tag.BOOLEAN: 544 val = new BooleanValueImpl(vm, readBoolean()); 545 break; 546 547 case JDWP.Tag.VOID: 548 val = new VoidValueImpl(vm); 549 break; 550 } 551 } 552 return val; 553 } 554 555 /** 556 * Read location represented as vm specific byte sequence. 557 */ 558 Location readLocation() { 559 byte tag = readByte(); 560 long classRef = readObjectRef(); 561 long methodRef = readMethodRef(); 562 long codeIndex = readLong(); 563 if (classRef != 0) { 564 /* Valid location */ 565 ReferenceTypeImpl refType = vm.referenceType(classRef, tag); 566 return new LocationImpl(vm, refType, methodRef, codeIndex); 567 } else { 568 /* Null location (example: uncaught exception) */ 569 return null; 570 } 571 } 572 573 byte[] readByteArray(int length) { 574 byte[] array = new byte[length]; 575 System.arraycopy(pkt.data, inCursor, array, 0, length); 576 inCursor += length; 577 return array; 578 } 579 580 List<Value> readArrayRegion() { 581 byte typeKey = readByte(); 582 int length = readInt(); 583 List<Value> list = new ArrayList<Value>(length); 584 boolean gettingObjects = isObjectTag(typeKey); 585 for (int i = 0; i < length; i++) { 586 /* 587 * Each object comes back with a type key which might 588 * identify a more specific type than the type key we 589 * passed in, so we use it in the decodeValue call. 590 * (For primitives, we just use the original one) 591 */ 592 if (gettingObjects) { 593 typeKey = readByte(); 594 } 595 Value value = readUntaggedValue(typeKey); 596 list.add(value); 597 } 598 599 return list; 600 } 601 602 void writeArrayRegion(List<Value> srcValues) { 603 writeInt(srcValues.size()); 604 for (int i = 0; i < srcValues.size(); i++) { 605 Value value = srcValues.get(i); 606 writeUntaggedValue(value); 607 } 608 } 609 610 int skipBytes(int n) { 611 inCursor += n; 612 return n; 613 } 614 615 byte command() { 616 return (byte)pkt.cmd; 617 } 618 619 static boolean isObjectTag(byte tag) { 620 return (tag == JDWP.Tag.OBJECT) || 621 (tag == JDWP.Tag.ARRAY) || 622 (tag == JDWP.Tag.STRING) || 623 (tag == JDWP.Tag.THREAD) || 624 (tag == JDWP.Tag.THREAD_GROUP) || 625 (tag == JDWP.Tag.CLASS_LOADER) || 626 (tag == JDWP.Tag.CLASS_OBJECT); 627 } 628 } 629
