/*
 * 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);
}