/*

 * Copyright (c) 1998, 2019, 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 "jni.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 = -1;

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 {

    /* subnet and mask are stored as IPv6 addresses, IPv4 is stored as mapped IPv6 */

    struct in6_addr subnet;

    struct in6_addr 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;

static int allowOnlyIPv4 = 0;                  // reflects "java.net.preferIPv4Stack" sys. property

static int preferredAddressFamily = AF_INET;   // "java.net.preferIPv6Addresses"

/*

 * 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 domain, int fd)

{

    jvalue dontcare;

    int err;

    if (domain == AF_INET6) {

        int off = 0;

        // make the socket a dual mode socket

        // this may fail if IPv4 is not supported - it's ok

        setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&off, sizeof(off));

    }

    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 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 unsigned short getPort(struct sockaddr *sa)

{

    return dbgsysNetworkToHostShort(sa->sa_family == AF_INET

                                    ? (((struct sockaddr_in*)sa)->sin_port)

                                    : (((struct sockaddr_in6*)sa)->sin6_port));

}

/*

 * Result must be released with dbgsysFreeAddrInfo.

 */

static jdwpTransportError

parseAddress(const char *address, struct addrinfo **result) {

    const char *colon;

    const char *port;

    struct addrinfo hints;

    *result = NULL;

    /* check for host:port or port */

    colon = strrchr(address, ':');

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

    /* ensure the port is valid (getaddrinfo allows port to be empty) */

    if (getPortNumber(port) < 0) {

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

    }

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

    hints.ai_family = allowOnlyIPv4 ? AF_INET : AF_UNSPEC;

    hints.ai_socktype = SOCK_STREAM;

    hints.ai_protocol = IPPROTO_TCP;

    hints.ai_flags = AI_NUMERICSERV;    // port must be a number

        /* no hostname - use localhost address (pass NULL to getaddrinfo) */

        /* *:port - listen on all interfaces

         * use IPv6 socket (to accept IPv6 and mapped IPv4),

         * pass hostname == NULL to getaddrinfo.

         */

        hints.ai_family = allowOnlyIPv4 ? AF_INET : AF_INET6;

        hints.ai_flags |= AI_PASSIVE | (allowOnlyIPv4 ? 0 : AI_V4MAPPED | AI_ALL);

    }

}

/*

 * Input is sockaddr just because all clients have it.

 */

static void convertIPv4ToIPv6(const struct sockaddr *addr4, struct in6_addr *addr6) {

    // Implement in a platform-independent way.

    // Spec requires in_addr has s_addr member, in6_addr has s6_addr[16] member.

    struct in_addr *a4 = &(((struct sockaddr_in*)addr4)->sin_addr);

    memset(addr6, 0, sizeof(*addr6));   // for safety

    // Mapped address contains 80 zero bits, then 16 "1" bits, then IPv4 address (4 bytes).

    addr6->s6_addr[10] = addr6->s6_addr[11] = 0xFF;

    memcpy(&(addr6->s6_addr[12]), &(a4->s_addr), 4);

}

/*

 * Parses address (IPv4 or IPv6), fills in result by parsed address.

 * For IPv4 mapped IPv6 is returned in result, isIPv4 is set.

 */

static jdwpTransportError

parseAllowedAddr(const char *buffer, struct in6_addr *result, int *isIPv4) {

    struct addrinfo hints;

    struct addrinfo *addrInfo = NULL;

    /*

     * To parse both IPv4 and IPv6 need to specify AF_UNSPEC family

     * (with AF_INET6 IPv4 addresses are not parsed even with AI_V4MAPPED and AI_ALL flags).

     */

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

    hints.ai_family = AF_UNSPEC;            // IPv6 or mapped IPv4

    hints.ai_socktype = SOCK_STREAM;

    hints.ai_protocol = IPPROTO_TCP;

    hints.ai_flags = AI_NUMERICHOST;        // only numeric addresses, no resolution

    }

    if (addrInfo->ai_family == AF_INET6) {

        memcpy(result, &(((struct sockaddr_in6 *)(addrInfo->ai_addr))->sin6_addr), sizeof(*result));

        *isIPv4 = 0;

    } else {    // IPv4 address - convert to mapped IPv6

        struct in6_addr addr6;

        convertIPv4ToIPv6(addrInfo->ai_addr, &addr6);

        memcpy(result, &addr6, sizeof(*result));

        *isIPv4 = 1;

    }

    dbgsysFreeAddrInfo(addrInfo);

    return JDWPTRANSPORT_ERROR_NONE;

}

/*

 * Parses prefix length from buffer (integer value), fills in result with corresponding net mask.

 * For IPv4 (isIPv4 is set), maximum prefix length is 32 bit, for IPv6 - 128 bit.

 */

static jdwpTransportError

parseAllowedMask(const char *buffer, int isIPv4, struct in6_addr *result) {

    int prefixLen = 0;

    int maxValue = isIPv4 ? 32 : 128;

    int i;

    do {

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

            return JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT;

        }

        prefixLen = prefixLen * 10 + (*buffer - '0');

        if (prefixLen > maxValue) {  // avoid overflow

            return JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT;

        }

        buffer++;

    } while (*buffer != '\0');

    if (isIPv4) {

        // IPv4 are stored as mapped IPv6, prefixLen needs to be converted too

        prefixLen += 96;

    }

    if (prefixLen == 0) {

        return JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT;

    }

    // generate mask for prefix length

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

    // prefixLen <= 128, so we won't go over result's size

    for (i = 0; prefixLen > 0; i++, prefixLen -= 8) {

        if (prefixLen >= 8) {

            // set the whole byte

            result->s6_addr[i] = 0xFF;

        } else {

            // set only "prefixLen" bits

            result->s6_addr[i] = (char)(0xFF << (8 - prefixLen));

        }

    }