| /* |
| * Copyright (c) 2001, 2018, 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. |
| */ |
| |
| package nsk.share.jdwp; |
| |
| import nsk.share.*; |
| |
| import java.util.Vector; |
| import java.io.*; |
| |
| /** |
| * This class represents a JDWP packet. |
| */ |
| public class Packet extends ByteBuffer { |
| |
| /** JDWP packet flags constant. */ |
| // public final static byte flNoFlags = (byte)0x0; |
| /** JDWP packet flags constant. */ |
| // public final static byte flReply = (byte)0x80; |
| |
| /** Offset of "length" field of JDWP packet. */ |
| public final static int LengthOffset = 0; |
| /** Offset of "id" field of JDWP packet. */ |
| public final static int IdOffset = LengthOffset + 4; |
| /** Offset of "flags" field of JDWP packet. */ |
| public final static int FlagsOffset = IdOffset + 4; |
| /** Offset of full "command" field of JDWP packet. */ |
| public final static int FullCommandOffset = FlagsOffset + 1; |
| /** Offset of "command" field of JDWP command packet. */ |
| public final static int CommandSetOffset = FullCommandOffset; |
| /** Offset of "command" field of JDWP command packet. */ |
| public final static int CommandOffset = CommandSetOffset + 1; |
| /** Offset of "error" field of JDWP reply packet. */ |
| public final static int ErrorCodeOffset = FlagsOffset + 1; |
| /** Offset of "data" section of JDWP packet. */ |
| public final static int DataOffset = FullCommandOffset + 2; |
| |
| /** Size of JDWP packet header. */ |
| public final static int PacketHeaderSize = DataOffset; |
| |
| /** |
| * Makes empty JDWP packet. |
| */ |
| public Packet() { |
| super(); |
| resetBuffer(); |
| } |
| |
| /** |
| * Makes JDWP packet with data from the specified byte buffer. |
| */ |
| // public Packet(ByteBuffer packet) { |
| public Packet(Packet packet) { |
| super(packet); |
| resetPosition(); |
| } |
| |
| /** |
| * Clear buffer of the packet. |
| */ |
| public void resetBuffer() { |
| super.resetBuffer(); |
| while (length() < PacketHeaderSize) |
| addByte((byte) 0); |
| setLength(); |
| resetPosition(); |
| } |
| |
| /** |
| * Return current position from begin of packet data area. |
| */ |
| public int currentDataPosition() { |
| return currentPosition() - PacketHeaderSize; |
| } |
| |
| /** |
| * Return value to the "length" field of JDWP packet. |
| */ |
| public int getLength() { |
| try { |
| return getInt(LengthOffset); |
| } |
| catch (BoundException e) { |
| throw new Failure("Caught unexpected exception while getting packet length value from header:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Assign specified value to the "length" field of JDWP packet. |
| */ |
| public void setLength(int length) { |
| try { |
| putInt(LengthOffset, length); |
| } |
| catch (BoundException e) { |
| throw new Failure("Caught unexpected exception while setting packet length value into header:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Assign packet length value to the "length" field of JDWP packet. |
| */ |
| public void setLength() { |
| setLength(length()); |
| } |
| |
| /** |
| * Return value of the "id" field of JDWP packet. |
| */ |
| public int getPacketID() { |
| try { |
| return getInt(IdOffset); |
| } |
| catch (BoundException e) { |
| throw new Failure("Caught unexpected exception while getting packet ID value from header:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Assign value to the "id" field of JDWP packet. |
| */ |
| public void setPacketID(int Id) { |
| try { |
| putInt(IdOffset, Id); |
| } |
| catch (BoundException e) { |
| throw new Failure("Caught unexpected exception while setting packet ID value into header:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Return value of the "flags" field of JDWP packet. |
| */ |
| public byte getFlags() { |
| try { |
| return getByte(FlagsOffset); |
| } |
| catch (BoundException e) { |
| throw new Failure("Caught unexpected exception while getting packet flags value from header:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Assign value to the "flags" field of JDWP packet. |
| */ |
| public void setFlags(byte flags) { |
| try { |
| putByte(FlagsOffset, flags); |
| } |
| catch (BoundException e) { |
| throw new Failure("Caught unexpected exception while setting packet flags value into header:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Sets the current parser position to "data" field of JDWP packet. |
| */ |
| public void resetPosition() { |
| resetPosition(PacketHeaderSize); |
| } |
| |
| /** |
| * Return size of the "data" part of JDWP packet. |
| */ |
| public int getDataSize() { |
| return length() - PacketHeaderSize; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Append fieldID to the end of this buffer. |
| */ |
| public void addFieldID(long b) { |
| addID(b, JDWP.TypeSize.FIELD_ID); |
| } |
| |
| /** |
| * Append methodID to the end of this buffer. |
| */ |
| public void addMethodID(long b) { |
| addID(b, JDWP.TypeSize.METHOD_ID); |
| } |
| |
| /** |
| * Append objectID to the end of this buffer. |
| */ |
| public void addObjectID(long b) { |
| addID(b, JDWP.TypeSize.OBJECT_ID); |
| } |
| |
| /** |
| * Append referenceID to the end of this buffer. |
| */ |
| public void addReferenceTypeID(long b) { |
| addID(b, JDWP.TypeSize.REFERENCE_TYPE_ID); |
| } |
| |
| /** |
| * Append frameID to the end of this buffer. |
| */ |
| public void addFrameID(long b) { |
| addID(b, JDWP.TypeSize.FRAME_ID); |
| } |
| |
| /** |
| * Append string value (an UTF-8 encoded string, not zero terminated, |
| * preceded by a four-byte integer length) to the end of this buffer. |
| */ |
| public void addString(String value) { |
| final int count = JDWP.TypeSize.INT + value.length(); |
| addInt(value.length()); |
| try { |
| addBytes(value.getBytes("UTF-8"), 0, value.length()); |
| } catch (UnsupportedEncodingException e) { |
| throw new Failure("Unsupported UTF-8 ecnoding while adding string value to JDWP packet:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Append location value to the end of this buffer. |
| */ |
| public void addLocation(JDWP.Location location) { |
| addBytes(location.getBytes(), 0, location.length()); |
| } |
| |
| /** |
| * Append untagged value to the end of this buffer. |
| */ |
| public void addUntaggedValue(JDWP.UntaggedValue value, byte tag) { |
| value.addValueTo(this, tag); |
| } |
| |
| /** |
| * Append tagged value to the end of this buffer. |
| */ |
| public void addValue(JDWP.Value value) { |
| value.addValueTo(this); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // get packet data |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Read a fieldID value from byte buffer at the current parser position. |
| * |
| * @throws BoundException if there is no valid value bytes at the given position |
| */ |
| public long getFieldID() throws BoundException { |
| return getID(JDWP.TypeSize.FIELD_ID); |
| } |
| |
| /** |
| * Read a methodID value from byte buffer at the current parser position. |
| * |
| * @throws BoundException if there is no valid value bytes at the given position |
| */ |
| public long getMethodID() throws BoundException { |
| return getID(JDWP.TypeSize.METHOD_ID); |
| } |
| |
| /** |
| * Read an objectID value from byte buffer at the current parser position. |
| * |
| * @throws BoundException if there is no valid value bytes at the given position |
| */ |
| public long getObjectID() throws BoundException { |
| return getID(JDWP.TypeSize.OBJECT_ID); |
| } |
| |
| /** |
| * Read a referenceTypeID value from byte buffer at the current parser position. |
| * |
| * @throws BoundException if there is no valid value bytes at the given position |
| */ |
| public long getReferenceTypeID() throws BoundException { |
| return getID(JDWP.TypeSize.REFERENCE_TYPE_ID); |
| } |
| |
| /** |
| * Read a frameID value from byte buffer at the current parser position. |
| * |
| * @throws BoundException if there is no valid value bytes at the given position |
| */ |
| public long getFrameID() throws BoundException { |
| return getID(JDWP.TypeSize.FRAME_ID); |
| } |
| |
| /** |
| * Read from this buffer a string value at the current parser |
| * position and returns this value. |
| * |
| * @throws BoundException if there are no valid string bytes in the buffer |
| */ |
| public String getString() throws BoundException { |
| final int count = JDWP.TypeSize.INT; |
| int available = length() - currentPosition(); |
| if (count > available) { |
| throw new BoundException("Unable to get " + count + " bytes of string length value at " + |
| offsetString() + " (available bytes: " + available + ")" ); |
| } |
| |
| int len = getInt(); |
| |
| if (len < 0) |
| throw new BoundException("Negative length of string to get: " + len); |
| |
| if (len == 0) |
| return ""; |
| |
| available = length() - currentPosition(); |
| if (len > available) { |
| throw new BoundException("Unable to get " + len + " bytes of string value at " + |
| offsetString() + " (available bytes: " + available + ")" ); |
| } |
| |
| byte[] s = new byte[len]; |
| for (int i = 0; i < len; i++) |
| s[i] = getByte(); |
| |
| try { |
| return new String(s, "UTF-8"); |
| } catch (UnsupportedEncodingException e) { |
| throw new Failure("Unsupported UTF-8 ecnoding while extracting string value from JDWP packet:\n\t" |
| + e); |
| } |
| } |
| |
| /** |
| * Reads from this buffer an location value at the current parser |
| * position and returns this value. |
| * |
| * @throws BoundException if there are no enough bytes in the buffer |
| */ |
| public JDWP.Location getLocation() throws BoundException { |
| final int count = JDWP.TypeSize.LOCATION; |
| final int available = length() - currentPosition(); |
| if (count > available) { |
| throw new BoundException("Unable to get " + count + " bytes of location value at " + |
| offsetString() + " (available bytes: " + available + ")" ); |
| } |
| |
| JDWP.Location location = new JDWP.Location(); |
| try { |
| for (int i = 0; i < JDWP.TypeSize.LOCATION; i++) { |
| location.putByte(i, getByte()); |
| } |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of location value:\n\t" + e); |
| }; |
| |
| return location; |
| } |
| |
| /** |
| * Reads from this buffer an untagged value at the current parser |
| * position and returns this value. |
| * |
| * @throws BoundException if there are no enough bytes in the buffer |
| */ |
| public JDWP.UntaggedValue getUntaggedValue(byte tag) throws BoundException { |
| JDWP.UntaggedValue value = new JDWP.UntaggedValue(); |
| try { |
| value.getValueFrom(this, tag); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| " bytes of a value:\n\t" + e); |
| }; |
| |
| return value; |
| } |
| |
| /** |
| * Reads from this buffer a tagged value at the current parser |
| * position and returns this value. |
| * |
| * @throws BoundException if there are no enough bytes in the buffer |
| */ |
| public JDWP.Value getValue() throws BoundException { |
| JDWP.Value value = new JDWP.Value(); |
| try { |
| value.getValueFrom(this); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| " bytes of a value:\n\t" + e); |
| }; |
| |
| return value; |
| } |
| |
| |
| //////////////////////////////////////////////////////////////// |
| |
| /** |
| * Read packet bytes from the stream. |
| * |
| * @throws IOException if error occured when reading bytes |
| */ |
| public void readFrom(Transport transport) throws IOException { |
| resetBuffer(); |
| |
| // System.err.println("Reading packet header"); |
| try { |
| for (int i = 0; i < PacketHeaderSize; i++) { |
| byte b = transport.read(); |
| putByte(i, b); |
| } |
| } |
| catch (BoundException e) { |
| throw new TestBug(e); |
| } |
| |
| int length = getLength(); |
| |
| checkSpace(length - PacketHeaderSize); |
| |
| // System.err.println("Packet size: " + length); |
| for (int i = PacketHeaderSize; i < length; i++) { |
| byte b = transport.read(); |
| addByte(b); |
| } |
| // System.err.println("Packet read successfully"); |
| } |
| |
| /** |
| * Write packet bytes to the stream. |
| * |
| * @throws IOException if error occured when reading bytes |
| */ |
| public void writeTo(Transport transport) throws IOException { |
| setLength(); |
| // System.err.println("Writing packet bytes: " + length()); |
| transport.write(bytes, 0, length()); |
| } |
| |
| /** |
| * Check packet header. |
| * This method check if packet has valid values in header fields. |
| * |
| * @throws PacketFormatException if packet header fields has error or invalid values |
| */ |
| public void checkHeader() throws PacketFormatException { |
| if (getLength() != length()) { |
| throw new PacketFormatException("Unexpected packet length value in the header:" |
| + getLength()); |
| } |
| } |
| |
| /** |
| * Check if packet is parsed totally and no trailing bytes left unparsed. |
| * This method check if packet has valid values in header fields. |
| * |
| * @throws PacketFormatException if there are trailing bytes left unparsed |
| */ |
| public void checkParsed() throws PacketFormatException { |
| if (! isParsed()) { |
| throw new PacketFormatException("Extra trailing bytes found in the packet at: " |
| + offsetString()); |
| } |
| } |
| |
| /** |
| * Return string representation of the packet header. |
| */ |
| public String headerToString() { |
| return "Packet header (" + PacketHeaderSize + " bytes):" + "\n" |
| + " " + toHexString(LengthOffset, 4) + " (length) : 0x" + toHexDecString(getLength(), 8) + "\n" |
| + " " + toHexString(IdOffset, 4) + " (id) : 0x" + toHexDecString(getPacketID(), 8) + "\n" |
| + " " + toHexString(FlagsOffset, 4) + " (flags) : 0x" + toHexDecString(getFlags(), 2) + "\n"; |
| } |
| |
| /** |
| * Return string representation of the packet. |
| */ |
| public String toString() { |
| return headerToString() |
| + "Entire packet (" + length() + " bytes): " + "\n" |
| + super.toString(0) |
| + "Packet end"; |
| } |
| |
| /** |
| * Exception indicated that packet has an ivnalid structure. |
| */ |
| class PacketFormatException extends BoundException { |
| PacketFormatException(String message) { |
| super(message); |
| } |
| } |
| } |
