| /* |
| * 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); |
| if ((*env)->ExceptionOccurred(env)) { |
| /* b shorter than sizeof(pktHeader) */ |
| return; |
| } |
| |
| total_length = (int)pktHeader[3] | ((int)pktHeader[2] << 8) | |
| ((int)pktHeader[1] << 16) | ((int)pktHeader[0] << 24); |
| |
| if (total_length < sizeof(pktHeader)) { |
| throwException(env, "java/lang/IllegalArgumentException", |
| "JDWP header is incorrect"); |
| return; |
| } |
| |
| /* |
| * 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 sizeof(pktHeader) + data |
| */ |
| data_length = total_length - sizeof(pktHeader); |
| |
| 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, sizeof(pktHeader), /*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); |
| } |