/*

 * Copyright (c) 1998, 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.  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 <stdio.h>

#include <string.h>

#include <errno.h>

#include <stdlib.h>

#include <ctype.h>

#include "jdwpTransport.h"

#include "sysSocket.h"

#ifdef _WIN32

 #include <winsock2.h>

 #include <ws2tcpip.h>

#else

 #include <arpa/inet.h>

 #include <sys/socket.h>

#endif

/*

 * 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 MAX_DATA_SIZE 1000

static jint recv_fully(int, char *, int);

static jint send_fully(int, char *, int);

/* version >= JDWPTRANSPORT_VERSION_1_1 */

typedef struct {

    uint32_t subnet;

    uint32_t netmask;

} AllowedPeerInfo;

#define STR(x) #x

#define MAX_PEER_ENTRIES 32

#define MAX_PEERS_STR STR(MAX_PEER_ENTRIES)

static AllowedPeerInfo _peers[MAX_PEER_ENTRIES];

static int _peers_cnt = 0;

/*

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

}

/* Set options common to client and server sides */

static jdwpTransportError

setOptionsCommon(int fd)

{

    jvalue dontcare;

    int err;

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

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

    if (err < 0) {

        RETURN_IO_ERROR("setsockopt TCPNODELAY failed");

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

/* Set the SO_REUSEADDR option */

static jdwpTransportError

setReuseAddrOption(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");

    }

    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 = recv_fully(fd, buf, helloLen-received);

        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 (send_fully(fd, (char*)hello, helloLen) != helloLen) {

        RETURN_IO_ERROR("send failed during handshake");

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static uint32_t

getLocalHostAddress() {

    // Simple routine to guess localhost address.

    // it looks up "localhost" and returns 127.0.0.1 if lookup

    // fails.

    struct addrinfo hints, *res = NULL;

    uint32_t addr;

    int err;

    // Use portable way to initialize the structure

    memset((void *)&hints, 0, sizeof(hints));

    hints.ai_family = AF_INET;

    err = getaddrinfo("localhost", NULL, &hints, &res);

    if (err < 0 || res == NULL) {

        return dbgsysHostToNetworkLong(INADDR_LOOPBACK);

    }

    // getaddrinfo might return more than one address

    // but we are using first one only

    addr = ((struct sockaddr_in *)(res->ai_addr))->sin_addr.s_addr;

    freeaddrinfo(res);

    return addr;

}

static int

getPortNumber(const char *s_port) {

    u_long n;

    char *eptr;

    if (*s_port == 0) {

        // bad address - colon with no port number in parameters

        return -1;

    }

    n = strtoul(s_port, &eptr, 10);

    if (eptr != s_port + strlen(s_port)) {

        // incomplete conversion - port number contains non-digit

        return -1;

    }

    if (n > (u_short) -1) {

        // check that value supplied by user is less than

        // maximum possible u_short value (65535) and

        // will not be truncated later.

        return -1;

    }

    return n;

}

static jdwpTransportError

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

    char *colon;

    int port;

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

    sa->sin_family = AF_INET;

    /* check for host:port or port */

    colon = strchr(address, ':');

    port = getPortNumber((colon == NULL) ? address : colon +1);

    if (port < 0) {

        RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT, "invalid port number specified");

    }

    sa->sin_port = dbgsysHostToNetworkShort((u_short)port);

    if (colon == NULL) {

        // bind to localhost only if no address specified

        sa->sin_addr.s_addr = getLocalHostAddress();

    } else if (strncmp(address, "localhost:", 10) == 0) {

        // optimize for common case

        sa->sin_addr.s_addr = getLocalHostAddress();

    } else if (*address == '*' && *(address+1) == ':') {

        // we are explicitly asked to bind server to all available IP addresses

        // has no meaning for client.

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

     } else {

        char *buf;

        char *hostname;

        uint32_t addr;

        int ai;

        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;

        /*

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

         * If not then try to resolve it.

         */

        addr = dbgsysInetAddr(hostname);

        if (addr == 0xffffffff) {

            struct addrinfo hints;

            struct addrinfo *results = NULL;

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

            hints.ai_family = AF_INET;

            hints.ai_socktype = SOCK_STREAM;

            hints.ai_protocol = IPPROTO_TCP;

            ai = dbgsysGetAddrInfo(hostname, NULL, &hints, &results);

            if (ai != 0) {

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

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

                (*callback->free)(buf);

                return JDWPTRANSPORT_ERROR_IO_ERROR;

            }

            /* lookup was successful */

            sa->sin_addr =  ((struct sockaddr_in *)results->ai_addr)->sin_addr;

            freeaddrinfo(results);

        } else {

            sa->sin_addr.s_addr = addr;

        }

        (*callback->free)(buf);

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static const char *

ip_s2u(const char *instr, uint32_t *ip) {

    // Convert string representation of ip to integer

    // in network byte order (big-endian)

    char t[4] = { 0, 0, 0, 0 };

    const char *s = instr;

    int i = 0;

    while (1) {

        if (*s == '.') {

            ++i;

            ++s;

            continue;

        }

        if (*s == 0 || *s == '+' || *s == '/') {

            break;

        }

        if (*s < '0' || *s > '9') {

            return instr;

        }

        t[i] = (t[i] * 10) + (*s - '0');

        ++s;

    }

    *ip = *(uint32_t*)(t);

    return s;

}

static const char *

mask_s2u(const char *instr, uint32_t *mask) {

    // Convert the number of bits to a netmask

    // in network byte order (big-endian)

    unsigned char m = 0;

    const char *s = instr;

    while (1) {

        if (*s == 0 || *s == '+') {

            break;

        }

        if (*s < '0' || *s > '9') {

            return instr;

        }

        m = (m * 10) + (*s - '0');

        ++s;

    }

    if (m == 0 || m > 32) {

       // Drop invalid input

       return instr;

    }

    *mask = htonl((uint32_t)(~0) << (32 - m));

    return s;

}

static int

ip_in_subnet(uint32_t subnet, uint32_t mask, uint32_t ipaddr) {

    return (ipaddr & mask) == subnet;

}

static jdwpTransportError

parseAllowedPeers(const char *allowed_peers) {

    // Build a list of allowed peers from char string

    // of format 192.168.0.10+192.168.0.0/24

    const char *s = NULL;

    const char *p = allowed_peers;

    uint32_t   ip = 0;

    uint32_t mask = 0xFFFFFFFF;

    while (1) {

        s = ip_s2u(p, &ip);

        if (s == p) {

            _peers_cnt = 0;

            fprintf(stderr, "Error in allow option: '%s'\n", s);

            RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT,

                         "invalid IP address in allow option");

        }

        if (*s == '/') {

            // netmask specified

            s = mask_s2u(s + 1, &mask);

            if (*(s - 1) == '/') {

                // Input is not consumed, something bad happened

                _peers_cnt = 0;

                fprintf(stderr, "Error in allow option: '%s'\n", s);

                RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT,

                             "invalid netmask in allow option");

            }

        } else {

            // reset netmask

            mask = 0xFFFFFFFF;

        }

        if (*s == '+' || *s == 0) {

            if (_peers_cnt >= MAX_PEER_ENTRIES) {

                fprintf(stderr, "Error in allow option: '%s'\n", allowed_peers);

                RETURN_ERROR(JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT,

                             "exceeded max number of allowed peers: " MAX_PEERS_STR);

            }

            _peers[_peers_cnt].subnet = ip;

            _peers[_peers_cnt].netmask = mask;

            _peers_cnt++;

            if (*s == 0) {

                // end of options

                break;

            }

            // advance to next IP block

            p = s + 1;

        }

    }

    return JDWPTRANSPORT_ERROR_NONE;

}

static int

isPeerAllowed(struct sockaddr_in *peer) {

    int i;

    for (i = 0; i < _peers_cnt; ++i) {

        int peer_ip = peer->sin_addr.s_addr;

        if (ip_in_subnet(_peers[i].subnet, _peers[i].netmask, peer_ip)) {

            return 1;

        }

    }

    return 0;

}

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')) {