/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 *

 * 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.

 *

 */

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <stdlib.h>

#include <ctype.h>

#include "jdwpTransport.h"

#include "sysSocket.h"

/*

 * The Socket Transport Library.

 *

 * This module is an implementation of the Java Debug Wire Protocol Transport

 * Service Provider Interface - see src/share/javavm/export/jdwpTransport.h.

 */

static int serverSocketFD;

static int socketFD = -1;

static jdwpTransportCallback *callback;

static JavaVM *jvm;

static int tlsIndex;

static jboolean initialized;

static struct jdwpTransportNativeInterface_ interface;

static jdwpTransportEnv single_env = (jdwpTransportEnv)&interface;

#define RETURN_ERROR(err, msg) \

        if (1==1) { \

            setLastError(err, msg); \

            return err; \

        }

#define RETURN_IO_ERROR(msg)    RETURN_ERROR(JDWPTRANSPORT_ERROR_IO_ERROR, msg);

#define RETURN_RECV_ERROR(n) \

        if (n == 0) { \

            RETURN_ERROR(JDWPTRANSPORT_ERROR_IO_ERROR, "premature EOF"); \

        } else { \

            RETURN_IO_ERROR("recv error"); \

        }

#define HEADER_SIZE     11

#define MAX_DATA_SIZE 1000

/*

 * Record the last error for this thread.

 */

static void

setLastError(jdwpTransportError err, char *newmsg) {

    char buf[255];

    char *msg;

    /* get any I/O first in case any system calls override errno */

    if (err == JDWPTRANSPORT_ERROR_IO_ERROR) {

        dbgsysGetLastIOError(buf, sizeof(buf));

    }

    msg = (char *)dbgsysTlsGet(tlsIndex);

    if (msg != NULL) {

        (*callback->free)(msg);

    }

    if (err == JDWPTRANSPORT_ERROR_IO_ERROR) {

        char *join_str = ": ";

        int msg_len = (int)strlen(newmsg) + (int)strlen(join_str) +

                      (int)strlen(buf) + 3;

        msg = (*callback->alloc)(msg_len);

        if (msg != NULL) {

            strcpy(msg, newmsg);

            strcat(msg, join_str);

            strcat(msg, buf);

        }

    } else {

        msg = (*callback->alloc)((int)strlen(newmsg)+1);

        if (msg != NULL) {

            strcpy(msg, newmsg);

        }

    }

    dbgsysTlsPut(tlsIndex, msg);

}

/*

 * Return the last error for this thread (may be NULL)

 */

static char*

getLastError() {

    return (char *)dbgsysTlsGet(tlsIndex);

}

static jdwpTransportError

setOptions(int fd)

{

    jvalue dontcare;

    int err;

    dontcare.i = 0;  /* keep compiler happy */

    err = dbgsysSetSocketOption(fd, SO_REUSEADDR, JNI_TRUE, dontcare);

    if (err < 0) {

        RETURN_IO_ERROR("setsockopt SO_REUSEADDR failed");

    }

    err = dbgsysSetSocketOption(fd, TCP_NODELAY, JNI_TRUE, dontcare);

    if (err < 0) {

        RETURN_IO_ERROR("setsockopt TCPNODELAY failed");

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError

handshake(int fd, jlong timeout) {

    const char *hello = "JDWP-Handshake";

    char b[16];

    int rv, helloLen, received;

    if (timeout > 0) {

        dbgsysConfigureBlocking(fd, JNI_FALSE);

    }

    helloLen = (int)strlen(hello);

    received = 0;

    while (received < helloLen) {

        int n;

        char *buf;

        if (timeout > 0) {

            rv = dbgsysPoll(fd, JNI_TRUE, JNI_FALSE, (long)timeout);

            if (rv <= 0) {

                setLastError(0, "timeout during handshake");

                return JDWPTRANSPORT_ERROR_IO_ERROR;

            }

        }

        buf = b;

        buf += received;

        n = dbgsysRecv(fd, buf, helloLen-received, 0);

        if (n == 0) {

            setLastError(0, "handshake failed - connection prematurally closed");

            return JDWPTRANSPORT_ERROR_IO_ERROR;

        }

        if (n < 0) {

            RETURN_IO_ERROR("recv failed during handshake");

        }

        received += n;

    }

    if (timeout > 0) {

        dbgsysConfigureBlocking(fd, JNI_TRUE);

    }

    if (strncmp(b, hello, received) != 0) {

        char msg[80+2*16];

        b[received] = '\0';

        /*

         * We should really use snprintf here but it's not available on Windows.

         * We can't use jio_snprintf without linking the transport against the VM.

         */

        sprintf(msg, "handshake failed - received >%s< - expected >%s<", b, hello);

        setLastError(0, msg);

        return JDWPTRANSPORT_ERROR_IO_ERROR;

    }

    if (dbgsysSend(fd, (char*)hello, helloLen, 0) != helloLen) {

        RETURN_IO_ERROR("send failed during handshake");

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError

parseAddress(const char *address, struct sockaddr_in *sa, uint32_t defaultHost) {

    char *colon;

    memset((void *)sa,0,sizeof(struct sockaddr_in));

    sa->sin_family = AF_INET;

    /* check for host:port or port */

    colon = strchr(address, ':');

    if (colon == NULL) {

        u_short port = (u_short)atoi(address);

        sa->sin_port = dbgsysHostToNetworkShort(port);

        sa->sin_addr.s_addr = dbgsysHostToNetworkLong(defaultHost);

    } else {

        char *buf;

        char *hostname;

        u_short port;

        uint32_t addr;

        buf = (*callback->alloc)((int)strlen(address)+1);

        if (buf == NULL) {

            RETURN_ERROR(JDWPTRANSPORT_ERROR_OUT_OF_MEMORY, "out of memory");

        }

        strcpy(buf, address);

        buf[colon - address] = '\0';

        hostname = buf;

        port = atoi(colon + 1);

        sa->sin_port = dbgsysHostToNetworkShort(port);

        /*

         * First see if the host is a literal IP address.

         * If not then try to resolve it.

         */

        addr = dbgsysInetAddr(hostname);

        if (addr == 0xffffffff) {

            struct hostent *hp = dbgsysGetHostByName(hostname);

            if (hp == NULL) {

                /* don't use RETURN_IO_ERROR as unknown host is normal */

                setLastError(0, "gethostbyname: unknown host");

                (*callback->free)(buf);

                return JDWPTRANSPORT_ERROR_IO_ERROR;

            }

            /* lookup was successful */

            memcpy(&(sa->sin_addr), hp->h_addr_list[0], hp->h_length);

        } else {

            sa->sin_addr.s_addr = addr;

        }

        (*callback->free)(buf);

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError JNICALL

socketTransport_getCapabilities(jdwpTransportEnv* env,

        JDWPTransportCapabilities* capabilitiesPtr)

{

    JDWPTransportCapabilities result;

    memset(&result, 0, sizeof(result));

    result.can_timeout_attach = JNI_TRUE;

    result.can_timeout_accept = JNI_TRUE;

    result.can_timeout_handshake = JNI_TRUE;

    *capabilitiesPtr = result;

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError JNICALL

socketTransport_startListening(jdwpTransportEnv* env, const char* address,

                               char** actualAddress)

{

    struct sockaddr_in sa;

    int err;

    memset((void *)&sa,0,sizeof(struct sockaddr_in));

    sa.sin_family = AF_INET;

    /* no address provided */

    if ((address == NULL) || (address[0] == '\0')) {

        address = "0";

    }

    err = parseAddress(address, &sa, INADDR_ANY);

    if (err != JDWPTRANSPORT_ERROR_NONE) {

        return err;

    }

    serverSocketFD = dbgsysSocket(AF_INET, SOCK_STREAM, 0);

    if (serverSocketFD < 0) {

        RETURN_IO_ERROR("socket creation failed");

    }

    err = setOptions(serverSocketFD);

    if (err) {

        return err;

    }

    err = dbgsysBind(serverSocketFD, (struct sockaddr *)&sa, sizeof(sa));

    if (err < 0) {

        RETURN_IO_ERROR("bind failed");

    }

    err = dbgsysListen(serverSocketFD, 1);

    if (err < 0) {

        RETURN_IO_ERROR("listen failed");

    }

    {

        char buf[20];

        int len = sizeof(sa);

        jint portNum;

        err = dbgsysGetSocketName(serverSocketFD,

                               (struct sockaddr *)&sa, &len);

        portNum = dbgsysNetworkToHostShort(sa.sin_port);

        sprintf(buf, "%d", portNum);

        *actualAddress = (*callback->alloc)((int)strlen(buf) + 1);

        if (*actualAddress == NULL) {

            RETURN_ERROR(JDWPTRANSPORT_ERROR_OUT_OF_MEMORY, "out of memory");

        } else {

            strcpy(*actualAddress, buf);

        }

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError JNICALL

socketTransport_accept(jdwpTransportEnv* env, jlong acceptTimeout, jlong handshakeTimeout)

{

    int socketLen, err;

    struct sockaddr_in socket;

    jlong startTime = (jlong)0;

    /*

     * Use a default handshake timeout if not specified - this avoids an indefinite

     * hang in cases where something other than a debugger connects to our port.

     */

    if (handshakeTimeout == 0) {

        handshakeTimeout = 2000;

    }

    do {

        /*

         * If there is an accept timeout then we put the socket in non-blocking

         * mode and poll for a connection.

         */

        if (acceptTimeout > 0) {

            int rv;

            dbgsysConfigureBlocking(serverSocketFD, JNI_FALSE);

            startTime = dbgsysCurrentTimeMillis();

            rv = dbgsysPoll(serverSocketFD, JNI_TRUE, JNI_FALSE, (long)acceptTimeout);

            if (rv <= 0) {

                /* set the last error here as could be overridden by configureBlocking */

                if (rv == 0) {

                    setLastError(JDWPTRANSPORT_ERROR_IO_ERROR, "poll failed");

                }

                /* restore blocking state */

                dbgsysConfigureBlocking(serverSocketFD, JNI_TRUE);

                if (rv == 0) {

                    RETURN_ERROR(JDWPTRANSPORT_ERROR_TIMEOUT, "timed out waiting for connection");

                } else {

                    return JDWPTRANSPORT_ERROR_IO_ERROR;

                }

            }

        }

        /*

         * Accept the connection

         */

        memset((void *)&socket,0,sizeof(struct sockaddr_in));

        socketLen = sizeof(socket);

        socketFD = dbgsysAccept(serverSocketFD,

                                (struct sockaddr *)&socket,

                                &socketLen);

        /* set the last error here as could be overridden by configureBlocking */

        if (socketFD < 0) {

            setLastError(JDWPTRANSPORT_ERROR_IO_ERROR, "accept failed");

        }

        /*

         * Restore the blocking state - note that the accepted socket may be in

         * blocking or non-blocking mode (platform dependent). However as there

         * is a handshake timeout set then it will go into non-blocking mode

         * anyway for the handshake.

         */

        if (acceptTimeout > 0) {

            dbgsysConfigureBlocking(serverSocketFD, JNI_TRUE);

        }

        if (socketFD < 0) {

            return JDWPTRANSPORT_ERROR_IO_ERROR;

        }

        /* handshake with the debugger */

        err = handshake(socketFD, handshakeTimeout);

        /*

         * If the handshake fails then close the connection. If there if an accept

         * timeout then we must adjust the timeout for the next poll.

         */

        if (err) {

            fprintf(stderr, "Debugger failed to attach: %s\n", getLastError());

            dbgsysSocketClose(socketFD);

            socketFD = -1;

            if (acceptTimeout > 0) {

                long endTime = dbgsysCurrentTimeMillis();

                acceptTimeout -= (endTime - startTime);

                if (acceptTimeout <= 0) {

                    setLastError(JDWPTRANSPORT_ERROR_IO_ERROR,

                        "timeout waiting for debugger to connect");

                    return JDWPTRANSPORT_ERROR_IO_ERROR;

                }

            }

        }

    } while (socketFD < 0);

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError JNICALL

socketTransport_stopListening(jdwpTransportEnv *env)

{

    if (serverSocketFD < 0) {

        RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_STATE, "connection not open");

    }

    if (dbgsysSocketClose(serverSocketFD) < 0) {

        RETURN_IO_ERROR("close failed");

    }

    serverSocketFD = -1;

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError JNICALL

socketTransport_attach(jdwpTransportEnv* env, const char* addressString, jlong attachTimeout,

                       jlong handshakeTimeout)

{

    struct sockaddr_in sa;

    int err;

    if (addressString == NULL || addressString[0] == '\0') {

        RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT, "address is missing");

    }

    err = parseAddress(addressString, &sa, 0x7f000001);

    if (err != JDWPTRANSPORT_ERROR_NONE) {

        return err;

    }

    socketFD = dbgsysSocket(AF_INET, SOCK_STREAM, 0);

    if (socketFD < 0) {

        RETURN_IO_ERROR("unable to create socket");

    }

    err = setOptions(socketFD);

    if (err) {

        return err;

    }

    /*

     * To do a timed connect we make the socket non-blocking

     * and poll with a timeout;

     */

    if (attachTimeout > 0) {

        dbgsysConfigureBlocking(socketFD, JNI_FALSE);

    }

    err = dbgsysConnect(socketFD, (struct sockaddr *)&sa, sizeof(sa));

    if (err == DBG_EINPROGRESS && attachTimeout > 0) {

        err = dbgsysFinishConnect(socketFD, (long)attachTimeout);

        if (err == DBG_ETIMEOUT) {

            dbgsysConfigureBlocking(socketFD, JNI_TRUE);

            RETURN_ERROR(JDWPTRANSPORT_ERROR_TIMEOUT, "connect timed out");

        }

    }

    if (err < 0) {

        RETURN_IO_ERROR("connect failed");

    }

    if (attachTimeout > 0) {

        dbgsysConfigureBlocking(socketFD, JNI_TRUE);

    }

    err = handshake(socketFD, handshakeTimeout);

    if (err) {

        dbgsysSocketClose(socketFD);

        socketFD = -1;

        return err;

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static jboolean JNICALL

socketTransport_isOpen(jdwpTransportEnv* env)

{

    if (socketFD >= 0) {

        return JNI_TRUE;

    } else {

        return JNI_FALSE;

    }

}

static jdwpTransportError JNICALL

socketTransport_close(jdwpTransportEnv* env)

{

    int fd = socketFD;

    socketFD = -1;

    if (fd < 0) {

        return JDWPTRANSPORT_ERROR_NONE;

    }

    if (dbgsysSocketClose(fd) < 0) {

        /*

         * close failed - it's pointless to restore socketFD here because

         * any subsequent close will likely fail aswell.

         */

        RETURN_IO_ERROR("close failed");

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static jdwpTransportError JNICALL

socketTransport_writePacket(jdwpTransportEnv* env, const jdwpPacket *packet)

{

    jint len, data_len, id;

    /*

     * room for header and up to MAX_DATA_SIZE data bytes

     */

    char header[HEADER_SIZE + MAX_DATA_SIZE];

    jbyte *data;