jdk/src/share/native/com/sun/tools/jdi/SharedMemoryConnection.c - edge/openjdk - Git at Google

 /*
  * Copyright (c) 1999, 2003, 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.
  */
 #include <string.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <jni.h>
 #include "SharedMemory.h"
 #include "com_sun_tools_jdi_SharedMemoryConnection.h"
 #include "jdwpTransport.h"
 #include "shmemBase.h"
 #include "sys.h"

 /*
  * JNI interface to the shared memory transport. These JNI methods
  * call the base shared memory support to do the real work.
  *
  * That is, this is the front-ends interface to our shared memory
  * communication code.
  */

 /*
  * Cached architecture
  */
 static int byte_ordering_known;
 static int is_big_endian;


 /*
  * Returns 1 if big endian architecture
  */
 static int isBigEndian() {
     if (!byte_ordering_known) {
         unsigned int i = 0xff000000;
         if (((char *)(&i))[0] != 0) {
             is_big_endian = 1;
         } else {
             is_big_endian = 0;
         }
         byte_ordering_known = 1;
     }
     return is_big_endian;
 }

 /*
  * Convert to big endian
  */
 static jint intToBigInt(jint i) {
     unsigned int b[4];
     if (isBigEndian()) {
         return i;
     }
     b[0] = (i >> 24) & 0xff;
     b[1] = (i >> 16) & 0xff;
     b[2] = (i >> 8) & 0xff;
     b[3] = i & 0xff;

     /*
      * It doesn't matter that jint is signed as we are or'ing
      * and hence end up with the correct bits.
      */
     return (b[3] << 24) | (b[2] << 16) | (b[1] << 8) | b[0];
 }

 /*
  * Convert unsigned short to big endian
  */
 static unsigned short shortToBigShort(unsigned short s) {
     unsigned int b[2];
     if (isBigEndian()) {
         return s;
     }
     b[0] = (s >> 8) & 0xff;
     b[1] = s & 0xff;
     return (b[1] << 8) + b[0];
 }

 /*
  * Create a byte[] from a packet struct. All data in the byte array
  * is JDWP packet suitable for wire transmission. That is, all fields,
  * and data are in big-endian format as required by the JDWP
  * specification.
  */
 static jbyteArray
 packetToByteArray(JNIEnv *env, jdwpPacket *str)
 {
     jbyteArray array;
     jsize data_length;
     jint total_length;
     jint tmpInt;

     total_length = str->type.cmd.len;
     data_length = total_length - 11;

     /* total packet length is header + data */
     array = (*env)->NewByteArray(env, total_length);
     if ((*env)->ExceptionOccurred(env)) {
         return NULL;
     }

     /* First 4 bytes of packet are the length (in big endian format) */
     tmpInt = intToBigInt((unsigned int)total_length);
     (*env)->SetByteArrayRegion(env, array, 0, 4, (const jbyte *)&tmpInt);

     /* Next 4 bytes are the id field */
     tmpInt = intToBigInt(str->type.cmd.id);
     (*env)->SetByteArrayRegion(env, array, 4, 4, (const jbyte *)&tmpInt);

     /* next byte is the flags */
     (*env)->SetByteArrayRegion(env, array, 8, 1, (const jbyte *)&(str->type.cmd.flags));

     /* next two bytes are either the error code or the command set/command */
     if (str->type.cmd.flags & JDWPTRANSPORT_FLAGS_REPLY) {
         short s = shortToBigShort(str->type.reply.errorCode);
         (*env)->SetByteArrayRegion(env, array, 9, 2, (const jbyte *)&(s));
     } else {
         (*env)->SetByteArrayRegion(env, array, 9, 1, (const jbyte *)&(str->type.cmd.cmdSet));
         (*env)->SetByteArrayRegion(env, array, 10, 1, (const jbyte *)&(str->type.cmd.cmd));
     }

     /* finally the data */

     if (data_length > 0) {
         (*env)->SetByteArrayRegion(env, array, 11,
                                    data_length, str->type.cmd.data);
         if ((*env)->ExceptionOccurred(env)) {
             return NULL;
         }
     }

     return array;
 }

 /*
  * Fill a packet struct from a byte array. The byte array is a
  * JDWP packet suitable for wire transmission. That is, all fields,
  * and data are in big-endian format as required by the JDWP
  * specification. We thus need to convert the fields from big
  * endian to the platform endian.
  *
  * The jbyteArray provided to this function is assumed to
  * of a length than is equal or greater than the length of
  * the JDWP packet that is contains.
  */
 static void
 byteArrayToPacket(JNIEnv *env, jbyteArray b, jdwpPacket *str)
 {
     jsize total_length, data_length;
     jbyte *data;
     unsigned char pktHeader[11]; /* sizeof length + id + flags + cmdSet + cmd */

     /*
      * Get the packet header
      */
     (*env)->GetByteArrayRegion(env, b, 0, sizeof(pktHeader), pktHeader);

     total_length = (int)pktHeader[3] | ((int)pktHeader[2] << 8) |
                    ((int)pktHeader[1] << 16) | ((int)pktHeader[0] << 24);
     /*
      * The id field is in big endian (also errorCode field in the case
      * of reply packets).
      */
     str->type.cmd.id = (int)pktHeader[7] | ((int)pktHeader[6] << 8) |
                        ((int)pktHeader[5] << 16) | ((int)pktHeader[4] << 24);

     str->type.cmd.flags = (jbyte)pktHeader[8];

     if (str->type.cmd.flags & JDWPTRANSPORT_FLAGS_REPLY) {
         str->type.reply.errorCode = (int)pktHeader[9] + ((int)pktHeader[10] << 8);
     } else {
         /* command packet */
         str->type.cmd.cmdSet = (jbyte)pktHeader[9];
         str->type.cmd.cmd = (jbyte)pktHeader[10];
     }

     /*
      * The length of the JDWP packet is 11 + data
      */
     data_length = total_length - 11;

     if (data_length == 0) {
         data = NULL;
     } else {
         data = malloc(data_length);
         if (data == NULL) {
             throwException(env, "java/lang/OutOfMemoryError",
                            "Unable to allocate command data buffer");
             return;
         }

         (*env)->GetByteArrayRegion(env, b, 11, /*sizeof(CmdPacket)+4*/ data_length, data);
         if ((*env)->ExceptionOccurred(env)) {
             free(data);
             return;
         }
     }

     str->type.cmd.len = total_length;
     str->type.cmd.data = data;
 }

 static void
 freePacketData(jdwpPacket *packet)
 {
     if (packet->type.cmd.len > 0) {
         free(packet->type.cmd.data);
     }
 }

 /*
  * Class:     com_sun_tools_jdi_SharedMemoryConnection
  * Method:    close0
  * Signature: (J)V
  */
 JNIEXPORT void JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_close0
   (JNIEnv *env, jobject thisObject, jlong id)
 {
     SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
     shmemBase_closeConnection(connection);
 }

 /*
  * Class:     com_sun_tools_jdi_SharedMemoryConnection
  * Method:    receiveByte0
  * Signature: (J)B
  */
 JNIEXPORT jbyte JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_receiveByte0
   (JNIEnv *env, jobject thisObject, jlong id)
 {
     SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
     jbyte b = 0;
     jint rc;

     rc = shmemBase_receiveByte(connection, &b);
     if (rc != SYS_OK) {
         throwShmemException(env, "shmemBase_receiveByte failed", rc);
     }

     return b;
 }

 /*
  * Class:     com_sun_tools_jdi_SharedMemoryConnection
  * Method:    receivePacket0
  * Signature: (JLcom/sun/tools/jdi/Packet;)V
  */
 JNIEXPORT jbyteArray JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_receivePacket0
   (JNIEnv *env, jobject thisObject, jlong id)
 {
     SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
     jdwpPacket packet;
     jint rc;

     rc = shmemBase_receivePacket(connection, &packet);
     if (rc != SYS_OK) {
         throwShmemException(env, "shmemBase_receivePacket failed", rc);
         return NULL;
     } else {
         jbyteArray array = packetToByteArray(env, &packet);

         /* Free the packet even if there was an exception above */
         freePacketData(&packet);
         return array;
     }
 }

 /*
  * Class:     com_sun_tools_jdi_SharedMemoryConnection
  * Method:    sendByte0
  * Signature: (JB)V
  */
 JNIEXPORT void JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_sendByte0
   (JNIEnv *env, jobject thisObject, jlong id, jbyte b)
 {
     SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
     jint rc;

     rc = shmemBase_sendByte(connection, b);
     if (rc != SYS_OK) {
         throwShmemException(env, "shmemBase_sendByte failed", rc);
     }
 }

 /*
  * Class:     com_sun_tools_jdi_SharedMemoryConnection
  * Method:    sendPacket0
  * Signature: (JLcom/sun/tools/jdi/Packet;)V
  */
 JNIEXPORT void JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_sendPacket0
   (JNIEnv *env, jobject thisObject, jlong id, jbyteArray b)
 {
     SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
     jdwpPacket packet;
     jint rc;

     byteArrayToPacket(env, b, &packet);
     if ((*env)->ExceptionOccurred(env)) {
         return;
     }

     rc = shmemBase_sendPacket(connection, &packet);
     if (rc != SYS_OK) {
         throwShmemException(env, "shmemBase_sendPacket failed", rc);
     }
     freePacketData(&packet);
 }
	/*
	* Copyright (c) 1999, 2003, 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.
	*/
	#include <string.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <jni.h>
	#include "SharedMemory.h"
	#include "com_sun_tools_jdi_SharedMemoryConnection.h"
	#include "jdwpTransport.h"
	#include "shmemBase.h"
	#include "sys.h"

	/*
	* JNI interface to the shared memory transport. These JNI methods
	* call the base shared memory support to do the real work.
	*
	* That is, this is the front-ends interface to our shared memory
	* communication code.
	*/

	/*
	* Cached architecture
	*/
	static int byte_ordering_known;
	static int is_big_endian;


	/*
	* Returns 1 if big endian architecture
	*/
	static int isBigEndian() {
	if (!byte_ordering_known) {
	unsigned int i = 0xff000000;
	if (((char *)(&i))[0] != 0) {
	is_big_endian = 1;
	} else {
	is_big_endian = 0;
	}
	byte_ordering_known = 1;
	}
	return is_big_endian;
	}

	/*
	* Convert to big endian
	*/
	static jint intToBigInt(jint i) {
	unsigned int b[4];
	if (isBigEndian()) {
	return i;
	}
	b[0] = (i >> 24) & 0xff;
	b[1] = (i >> 16) & 0xff;
	b[2] = (i >> 8) & 0xff;
	b[3] = i & 0xff;

	/*
	* It doesn't matter that jint is signed as we are or'ing
	* and hence end up with the correct bits.
	*/
	return (b[3] << 24) \| (b[2] << 16) \| (b[1] << 8) \| b[0];
	}

	/*
	* Convert unsigned short to big endian
	*/
	static unsigned short shortToBigShort(unsigned short s) {
	unsigned int b[2];
	if (isBigEndian()) {
	return s;
	}
	b[0] = (s >> 8) & 0xff;
	b[1] = s & 0xff;
	return (b[1] << 8) + b[0];
	}

	/*
	* Create a byte[] from a packet struct. All data in the byte array
	* is JDWP packet suitable for wire transmission. That is, all fields,
	* and data are in big-endian format as required by the JDWP
	* specification.
	*/
	static jbyteArray
	packetToByteArray(JNIEnv env, jdwpPacket str)
	{
	jbyteArray array;
	jsize data_length;
	jint total_length;
	jint tmpInt;

	total_length = str->type.cmd.len;
	data_length = total_length - 11;

	/* total packet length is header + data */
	array = (*env)->NewByteArray(env, total_length);
	if ((*env)->ExceptionOccurred(env)) {
	return NULL;
	}

	/* First 4 bytes of packet are the length (in big endian format) */
	tmpInt = intToBigInt((unsigned int)total_length);
	(env)->SetByteArrayRegion(env, array, 0, 4, (const jbyte )&tmpInt);

	/* Next 4 bytes are the id field */
	tmpInt = intToBigInt(str->type.cmd.id);
	(env)->SetByteArrayRegion(env, array, 4, 4, (const jbyte )&tmpInt);

	/* next byte is the flags */
	(env)->SetByteArrayRegion(env, array, 8, 1, (const jbyte )&(str->type.cmd.flags));

	/* next two bytes are either the error code or the command set/command */
	if (str->type.cmd.flags & JDWPTRANSPORT_FLAGS_REPLY) {
	short s = shortToBigShort(str->type.reply.errorCode);
	(env)->SetByteArrayRegion(env, array, 9, 2, (const jbyte )&(s));
	} else {
	(env)->SetByteArrayRegion(env, array, 9, 1, (const jbyte )&(str->type.cmd.cmdSet));
	(env)->SetByteArrayRegion(env, array, 10, 1, (const jbyte )&(str->type.cmd.cmd));
	}

	/* finally the data */

	if (data_length > 0) {
	(*env)->SetByteArrayRegion(env, array, 11,
	data_length, str->type.cmd.data);
	if ((*env)->ExceptionOccurred(env)) {
	return NULL;
	}
	}

	return array;
	}

	/*
	* Fill a packet struct from a byte array. The byte array is a
	* JDWP packet suitable for wire transmission. That is, all fields,
	* and data are in big-endian format as required by the JDWP
	* specification. We thus need to convert the fields from big
	* endian to the platform endian.
	*
	* The jbyteArray provided to this function is assumed to
	* of a length than is equal or greater than the length of
	* the JDWP packet that is contains.
	*/
	static void
	byteArrayToPacket(JNIEnv env, jbyteArray b, jdwpPacket str)
	{
	jsize total_length, data_length;
	jbyte *data;
	unsigned char pktHeader[11]; /* sizeof length + id + flags + cmdSet + cmd */

	/*
	* Get the packet header
	*/
	(*env)->GetByteArrayRegion(env, b, 0, sizeof(pktHeader), pktHeader);

	total_length = (int)pktHeader[3] \| ((int)pktHeader[2] << 8) \|
	((int)pktHeader[1] << 16) \| ((int)pktHeader[0] << 24);
	/*
	* The id field is in big endian (also errorCode field in the case
	* of reply packets).
	*/
	str->type.cmd.id = (int)pktHeader[7] \| ((int)pktHeader[6] << 8) \|
	((int)pktHeader[5] << 16) \| ((int)pktHeader[4] << 24);

	str->type.cmd.flags = (jbyte)pktHeader[8];

	if (str->type.cmd.flags & JDWPTRANSPORT_FLAGS_REPLY) {
	str->type.reply.errorCode = (int)pktHeader[9] + ((int)pktHeader[10] << 8);
	} else {
	/* command packet */
	str->type.cmd.cmdSet = (jbyte)pktHeader[9];
	str->type.cmd.cmd = (jbyte)pktHeader[10];
	}

	/*
	* The length of the JDWP packet is 11 + data
	*/
	data_length = total_length - 11;

	if (data_length == 0) {
	data = NULL;
	} else {
	data = malloc(data_length);
	if (data == NULL) {
	throwException(env, "java/lang/OutOfMemoryError",
	"Unable to allocate command data buffer");
	return;
	}

	(env)->GetByteArrayRegion(env, b, 11, /sizeof(CmdPacket)+4*/ data_length, data);
	if ((*env)->ExceptionOccurred(env)) {
	free(data);
	return;
	}
	}

	str->type.cmd.len = total_length;
	str->type.cmd.data = data;
	}

	static void
	freePacketData(jdwpPacket *packet)
	{
	if (packet->type.cmd.len > 0) {
	free(packet->type.cmd.data);
	}
	}

	/*
	* Class: com_sun_tools_jdi_SharedMemoryConnection
	* Method: close0
	* Signature: (J)V
	*/
	JNIEXPORT void JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_close0
	(JNIEnv *env, jobject thisObject, jlong id)
	{
	SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
	shmemBase_closeConnection(connection);
	}

	/*
	* Class: com_sun_tools_jdi_SharedMemoryConnection
	* Method: receiveByte0
	* Signature: (J)B
	*/
	JNIEXPORT jbyte JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_receiveByte0
	(JNIEnv *env, jobject thisObject, jlong id)
	{
	SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
	jbyte b = 0;
	jint rc;

	rc = shmemBase_receiveByte(connection, &b);
	if (rc != SYS_OK) {
	throwShmemException(env, "shmemBase_receiveByte failed", rc);
	}

	return b;
	}

	/*
	* Class: com_sun_tools_jdi_SharedMemoryConnection
	* Method: receivePacket0
	* Signature: (JLcom/sun/tools/jdi/Packet;)V
	*/
	JNIEXPORT jbyteArray JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_receivePacket0
	(JNIEnv *env, jobject thisObject, jlong id)
	{
	SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
	jdwpPacket packet;
	jint rc;

	rc = shmemBase_receivePacket(connection, &packet);
	if (rc != SYS_OK) {
	throwShmemException(env, "shmemBase_receivePacket failed", rc);
	return NULL;
	} else {
	jbyteArray array = packetToByteArray(env, &packet);

	/* Free the packet even if there was an exception above */
	freePacketData(&packet);
	return array;
	}
	}

	/*
	* Class: com_sun_tools_jdi_SharedMemoryConnection
	* Method: sendByte0
	* Signature: (JB)V
	*/
	JNIEXPORT void JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_sendByte0
	(JNIEnv *env, jobject thisObject, jlong id, jbyte b)
	{
	SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
	jint rc;

	rc = shmemBase_sendByte(connection, b);
	if (rc != SYS_OK) {
	throwShmemException(env, "shmemBase_sendByte failed", rc);
	}
	}

	/*
	* Class: com_sun_tools_jdi_SharedMemoryConnection
	* Method: sendPacket0
	* Signature: (JLcom/sun/tools/jdi/Packet;)V
	*/
	JNIEXPORT void JNICALL Java_com_sun_tools_jdi_SharedMemoryConnection_sendPacket0
	(JNIEnv *env, jobject thisObject, jlong id, jbyteArray b)
	{
	SharedMemoryConnection *connection = ID_TO_CONNECTION(id);
	jdwpPacket packet;
	jint rc;

	byteArrayToPacket(env, b, &packet);
	if ((*env)->ExceptionOccurred(env)) {
	return;
	}

	rc = shmemBase_sendPacket(connection, &packet);
	if (rc != SYS_OK) {
	throwShmemException(env, "shmemBase_sendPacket failed", rc);
	}
	freePacketData(&packet);
	}