Back to index...

	/*
	* Copyright (c) 1998, 2008, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	package com.sun.tools.jdi;

	import com.sun.jdi.*;
	import java.util.*;
	import java.io.ByteArrayOutputStream;

	class PacketStream {
	final VirtualMachineImpl vm;
	private int inCursor = 0;
	final Packet pkt;
	private ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
	private boolean isCommitted = false;

	PacketStream(VirtualMachineImpl vm, int cmdSet, int cmd) {
	this.vm = vm;
	this.pkt = new Packet();
	pkt.cmdSet = (short)cmdSet;
	pkt.cmd = (short)cmd;
	}

	PacketStream(VirtualMachineImpl vm, Packet pkt) {
	this.vm = vm;
	this.pkt = pkt;
	this.isCommitted = true; /* read only stream */
	}

	int id() {
	return pkt.id;
	}

	void send() {
	if (!isCommitted) {
	pkt.data = dataStream.toByteArray();
	vm.sendToTarget(pkt);
	isCommitted = true;
	}
	}

	void waitForReply() throws JDWPException {
	if (!isCommitted) {
	throw new InternalException("waitForReply without send");
	}

	vm.waitForTargetReply(pkt);

	if (pkt.errorCode != Packet.ReplyNoError) {
	throw new JDWPException(pkt.errorCode);
	}
	}

	void writeBoolean(boolean data) {
	if(data) {
	dataStream.write( 1 );
	} else {
	dataStream.write( 0 );
	}
	}

	void writeByte(byte data) {
	dataStream.write( data );
	}

	void writeChar(char data) {
	dataStream.write( (byte)((data >>> 8) & 0xFF) );
	dataStream.write( (byte)((data >>> 0) & 0xFF) );
	}

	void writeShort(short data) {
	dataStream.write( (byte)((data >>> 8) & 0xFF) );
	dataStream.write( (byte)((data >>> 0) & 0xFF) );
	}

	void writeInt(int data) {
	dataStream.write( (byte)((data >>> 24) & 0xFF) );
	dataStream.write( (byte)((data >>> 16) & 0xFF) );
	dataStream.write( (byte)((data >>> 8) & 0xFF) );
	dataStream.write( (byte)((data >>> 0) & 0xFF) );
	}

	void writeLong(long data) {
	dataStream.write( (byte)((data >>> 56) & 0xFF) );
	dataStream.write( (byte)((data >>> 48) & 0xFF) );
	dataStream.write( (byte)((data >>> 40) & 0xFF) );
	dataStream.write( (byte)((data >>> 32) & 0xFF) );

	dataStream.write( (byte)((data >>> 24) & 0xFF) );
	dataStream.write( (byte)((data >>> 16) & 0xFF) );
	dataStream.write( (byte)((data >>> 8) & 0xFF) );
	dataStream.write( (byte)((data >>> 0) & 0xFF) );
	}

	void writeFloat(float data) {
	writeInt(Float.floatToIntBits(data));
	}

	void writeDouble(double data) {
	writeLong(Double.doubleToLongBits(data));
	}

	void writeID(int size, long data) {
	switch (size) {
	case 8:
	writeLong(data);
	break;
	case 4:
	writeInt((int)data);
	break;
	case 2:
	writeShort((short)data);
	break;
	default:
	throw new UnsupportedOperationException("JDWP: ID size not supported: " + size);
	}
	}

	void writeNullObjectRef() {
	writeObjectRef(0);
	}

	void writeObjectRef(long data) {
	writeID(vm.sizeofObjectRef, data);
	}

	void writeClassRef(long data) {
	writeID(vm.sizeofClassRef, data);
	}

	void writeMethodRef(long data) {
	writeID(vm.sizeofMethodRef, data);
	}

	void writeFieldRef(long data) {
	writeID(vm.sizeofFieldRef, data);
	}

	void writeFrameRef(long data) {
	writeID(vm.sizeofFrameRef, data);
	}

	void writeByteArray(byte[] data) {
	dataStream.write(data, 0, data.length);
	}

	void writeString(String string) {
	try {
	byte[] stringBytes = string.getBytes("UTF8");
	writeInt(stringBytes.length);
	writeByteArray(stringBytes);
	} catch (java.io.UnsupportedEncodingException e) {
	throw new InternalException("Cannot convert string to UTF8 bytes");
	}
	}

	void writeLocation(Location location) {
	ReferenceTypeImpl refType = (ReferenceTypeImpl)location.declaringType();
	byte tag;
	if (refType instanceof ClassType) {
	tag = JDWP.TypeTag.CLASS;
	} else if (refType instanceof InterfaceType) {
	// It's possible to have executable code in an interface
	tag = JDWP.TypeTag.INTERFACE;
	} else {
	throw new InternalException("Invalid Location");
	}
	writeByte(tag);
	writeClassRef(refType.ref());
	writeMethodRef(((MethodImpl)location.method()).ref());
	writeLong(location.codeIndex());
	}

	void writeValue(Value val) {
	try {
	writeValueChecked(val);
	} catch (InvalidTypeException exc) { // should never happen
	throw new RuntimeException(
	"Internal error: Invalid Tag/Type pair");
	}
	}

	void writeValueChecked(Value val) throws InvalidTypeException {
	writeByte(ValueImpl.typeValueKey(val));
	writeUntaggedValue(val);
	}

	void writeUntaggedValue(Value val) {
	try {
	writeUntaggedValueChecked(val);
	} catch (InvalidTypeException exc) { // should never happen
	throw new RuntimeException(
	"Internal error: Invalid Tag/Type pair");
	}
	}

	void writeUntaggedValueChecked(Value val) throws InvalidTypeException {
	byte tag = ValueImpl.typeValueKey(val);
	if (isObjectTag(tag)) {
	if (val == null) {
	writeObjectRef(0);
	} else {
	if (!(val instanceof ObjectReference)) {
	throw new InvalidTypeException();
	}
	writeObjectRef(((ObjectReferenceImpl)val).ref());
	}
	} else {
	switch (tag) {
	case JDWP.Tag.BYTE:
	if(!(val instanceof ByteValue))
	throw new InvalidTypeException();

	writeByte(((PrimitiveValue)val).byteValue());
	break;

	case JDWP.Tag.CHAR:
	if(!(val instanceof CharValue))
	throw new InvalidTypeException();

	writeChar(((PrimitiveValue)val).charValue());
	break;

	case JDWP.Tag.FLOAT:
	if(!(val instanceof FloatValue))
	throw new InvalidTypeException();

	writeFloat(((PrimitiveValue)val).floatValue());
	break;

	case JDWP.Tag.DOUBLE:
	if(!(val instanceof DoubleValue))
	throw new InvalidTypeException();

	writeDouble(((PrimitiveValue)val).doubleValue());
	break;

	case JDWP.Tag.INT:
	if(!(val instanceof IntegerValue))
	throw new InvalidTypeException();

	writeInt(((PrimitiveValue)val).intValue());
	break;

	case JDWP.Tag.LONG:
	if(!(val instanceof LongValue))
	throw new InvalidTypeException();

	writeLong(((PrimitiveValue)val).longValue());
	break;

	case JDWP.Tag.SHORT:
	if(!(val instanceof ShortValue))
	throw new InvalidTypeException();

	writeShort(((PrimitiveValue)val).shortValue());
	break;

	case JDWP.Tag.BOOLEAN:
	if(!(val instanceof BooleanValue))
	throw new InvalidTypeException();

	writeBoolean(((PrimitiveValue)val).booleanValue());
	break;
	}
	}
	}



	/**
	* Read byte represented as one bytes.
	*/
	byte readByte() {
	byte ret = pkt.data[inCursor];
	inCursor += 1;
	return ret;
	}

	/**
	* Read boolean represented as one byte.
	*/
	boolean readBoolean() {
	byte ret = readByte();
	return (ret != 0);
	}

	/**
	* Read char represented as two bytes.
	*/
	char readChar() {
	int b1, b2;

	b1 = pkt.data[inCursor++] & 0xff;
	b2 = pkt.data[inCursor++] & 0xff;

	return (char)((b1 << 8) + b2);
	}

	/**
	* Read short represented as two bytes.
	*/
	short readShort() {
	int b1, b2;

	b1 = pkt.data[inCursor++] & 0xff;
	b2 = pkt.data[inCursor++] & 0xff;

	return (short)((b1 << 8) + b2);
	}

	/**
	* Read int represented as four bytes.
	*/
	int readInt() {
	int b1,b2,b3,b4;

	b1 = pkt.data[inCursor++] & 0xff;
	b2 = pkt.data[inCursor++] & 0xff;
	b3 = pkt.data[inCursor++] & 0xff;
	b4 = pkt.data[inCursor++] & 0xff;

	return ((b1 << 24) + (b2 << 16) + (b3 << 8) + b4);
	}

	/**
	* Read long represented as eight bytes.
	*/
	long readLong() {
	long b1,b2,b3,b4;
	long b5,b6,b7,b8;

	b1 = pkt.data[inCursor++] & 0xff;
	b2 = pkt.data[inCursor++] & 0xff;
	b3 = pkt.data[inCursor++] & 0xff;
	b4 = pkt.data[inCursor++] & 0xff;

	b5 = pkt.data[inCursor++] & 0xff;
	b6 = pkt.data[inCursor++] & 0xff;
	b7 = pkt.data[inCursor++] & 0xff;
	b8 = pkt.data[inCursor++] & 0xff;

	return ((b1 << 56) + (b2 << 48) + (b3 << 40) + (b4 << 32)
	+ (b5 << 24) + (b6 << 16) + (b7 << 8) + b8);
	}

	/**
	* Read float represented as four bytes.
	*/
	float readFloat() {
	return Float.intBitsToFloat(readInt());
	}

	/**
	* Read double represented as eight bytes.
	*/
	double readDouble() {
	return Double.longBitsToDouble(readLong());
	}

	/**
	* Read string represented as four byte length followed by
	* characters of the string.
	*/
	String readString() {
	String ret;
	int len = readInt();

	try {
	ret = new String(pkt.data, inCursor, len, "UTF8");
	} catch(java.io.UnsupportedEncodingException e) {
	System.err.println(e);
	ret = "Conversion error!";
	}
	inCursor += len;
	return ret;
	}

	private long readID(int size) {
	switch (size) {
	case 8:
	return readLong();
	case 4:
	return (long)readInt();
	case 2:
	return (long)readShort();
	default:
	throw new UnsupportedOperationException("JDWP: ID size not supported: " + size);
	}
	}

	/**
	* Read object represented as vm specific byte sequence.
	*/
	long readObjectRef() {
	return readID(vm.sizeofObjectRef);
	}

	long readClassRef() {
	return readID(vm.sizeofClassRef);
	}

	ObjectReferenceImpl readTaggedObjectReference() {
	byte typeKey = readByte();
	return vm.objectMirror(readObjectRef(), typeKey);
	}

	ObjectReferenceImpl readObjectReference() {
	return vm.objectMirror(readObjectRef());
	}

	StringReferenceImpl readStringReference() {
	long ref = readObjectRef();
	return vm.stringMirror(ref);
	}

	ArrayReferenceImpl readArrayReference() {
	long ref = readObjectRef();
	return vm.arrayMirror(ref);
	}

	ThreadReferenceImpl readThreadReference() {
	long ref = readObjectRef();
	return vm.threadMirror(ref);
	}

	ThreadGroupReferenceImpl readThreadGroupReference() {
	long ref = readObjectRef();
	return vm.threadGroupMirror(ref);
	}

	ClassLoaderReferenceImpl readClassLoaderReference() {
	long ref = readObjectRef();
	return vm.classLoaderMirror(ref);
	}

	ClassObjectReferenceImpl readClassObjectReference() {
	long ref = readObjectRef();
	return vm.classObjectMirror(ref);
	}

	ReferenceTypeImpl readReferenceType() {
	byte tag = readByte();
	long ref = readObjectRef();
	return vm.referenceType(ref, tag);
	}

	/**
	* Read method reference represented as vm specific byte sequence.
	*/
	long readMethodRef() {
	return readID(vm.sizeofMethodRef);
	}

	/**
	* Read field reference represented as vm specific byte sequence.
	*/
	long readFieldRef() {
	return readID(vm.sizeofFieldRef);
	}

	/**
	* Read field represented as vm specific byte sequence.
	*/
	Field readField() {
	ReferenceTypeImpl refType = readReferenceType();
	long fieldRef = readFieldRef();
	return refType.getFieldMirror(fieldRef);
	}

	/**
	* Read frame represented as vm specific byte sequence.
	*/
	long readFrameRef() {
	return readID(vm.sizeofFrameRef);
	}

	/**
	* Read a value, first byte describes type of value to read.
	*/
	ValueImpl readValue() {
	byte typeKey = readByte();
	return readUntaggedValue(typeKey);
	}

	ValueImpl readUntaggedValue(byte typeKey) {
	ValueImpl val = null;

	if (isObjectTag(typeKey)) {
	val = vm.objectMirror(readObjectRef(), typeKey);
	} else {
	switch(typeKey) {
	case JDWP.Tag.BYTE:
	val = new ByteValueImpl(vm, readByte());
	break;

	case JDWP.Tag.CHAR:
	val = new CharValueImpl(vm, readChar());
	break;

	case JDWP.Tag.FLOAT:
	val = new FloatValueImpl(vm, readFloat());
	break;

	case JDWP.Tag.DOUBLE:
	val = new DoubleValueImpl(vm, readDouble());
	break;

	case JDWP.Tag.INT:
	val = new IntegerValueImpl(vm, readInt());
	break;

	case JDWP.Tag.LONG:
	val = new LongValueImpl(vm, readLong());
	break;

	case JDWP.Tag.SHORT:
	val = new ShortValueImpl(vm, readShort());
	break;

	case JDWP.Tag.BOOLEAN:
	val = new BooleanValueImpl(vm, readBoolean());
	break;

	case JDWP.Tag.VOID:
	val = new VoidValueImpl(vm);
	break;
	}
	}
	return val;
	}

	/**
	* Read location represented as vm specific byte sequence.
	*/
	Location readLocation() {
	byte tag = readByte();
	long classRef = readObjectRef();
	long methodRef = readMethodRef();
	long codeIndex = readLong();
	if (classRef != 0) {
	/* Valid location */
	ReferenceTypeImpl refType = vm.referenceType(classRef, tag);
	return new LocationImpl(vm, refType, methodRef, codeIndex);
	} else {
	/* Null location (example: uncaught exception) */
	return null;
	}
	}

	byte[] readByteArray(int length) {
	byte[] array = new byte[length];
	System.arraycopy(pkt.data, inCursor, array, 0, length);
	inCursor += length;
	return array;
	}

	List<Value> readArrayRegion() {
	byte typeKey = readByte();
	int length = readInt();
	List<Value> list = new ArrayList<Value>(length);
	boolean gettingObjects = isObjectTag(typeKey);
	for (int i = 0; i < length; i++) {
	/*
	* Each object comes back with a type key which might
	* identify a more specific type than the type key we
	* passed in, so we use it in the decodeValue call.
	* (For primitives, we just use the original one)
	*/
	if (gettingObjects) {
	typeKey = readByte();
	}
	Value value = readUntaggedValue(typeKey);
	list.add(value);
	}

	return list;
	}

	void writeArrayRegion(List<Value> srcValues) {
	writeInt(srcValues.size());
	for (int i = 0; i < srcValues.size(); i++) {
	Value value = srcValues.get(i);
	writeUntaggedValue(value);
	}
	}

	int skipBytes(int n) {
	inCursor += n;
	return n;
	}

	byte command() {
	return (byte)pkt.cmd;
	}

	static boolean isObjectTag(byte tag) {
	return (tag == JDWP.Tag.OBJECT) \|\|
	(tag == JDWP.Tag.ARRAY) \|\|
	(tag == JDWP.Tag.STRING) \|\|
	(tag == JDWP.Tag.THREAD) \|\|
	(tag == JDWP.Tag.THREAD_GROUP) \|\|
	(tag == JDWP.Tag.CLASS_LOADER) \|\|
	(tag == JDWP.Tag.CLASS_OBJECT);
	}
	}

Back to index...