/***************************************************************************
 * ncat_lua_connect.c -- Ncat Lua filters connect-mode facilities          *
 ***********************IMPORTANT NMAP LICENSE TERMS************************
 *                                                                         *
 * The Nmap Security Scanner is (C) 1996-2013 Insecure.Com LLC. Nmap is    *
 * also a registered trademark of Insecure.Com LLC.  This program is free  *
 * software; you may redistribute and/or modify it under the terms of the  *
 * GNU General Public License as published by the Free Software            *
 * Foundation; Version 2 ("GPL"), BUT ONLY WITH ALL OF THE CLARIFICATIONS  *
 * AND EXCEPTIONS DESCRIBED HEREIN.  This guarantees your right to use,    *
 * modify, and redistribute this software under certain conditions.  If    *
 * you wish to embed Nmap technology into proprietary software, we sell    *
 * alternative licenses (contact sales@nmap.com).  Dozens of software      *
 * vendors already license Nmap technology such as host discovery, port    *
 * scanning, OS detection, version detection, and the Nmap Scripting       *
 * Engine.                                                                 *
 *                                                                         *
 * Note that the GPL places important restrictions on "derivative works",  *
 * yet it does not provide a detailed definition of that term.  To avoid   *
 * misunderstandings, we interpret that term as broadly as copyright law   *
 * allows.  For example, we consider an application to constitute a        *
 * derivative work for the purpose of this license if it does any of the   *
 * following with any software or content covered by this license          *
 * ("Covered Software"):                                                   *
 *                                                                         *
 * o Integrates source code from Covered Software.                         *
 *                                                                         *
 * o Reads or includes copyrighted data files, such as Nmap's nmap-os-db   *
 * or nmap-service-probes.                                                 *
 *                                                                         *
 * o Is designed specifically to execute Covered Software and parse the    *
 * results (as opposed to typical shell or execution-menu apps, which will *
 * execute anything you tell them to).                                     *
 *                                                                         *
 * o Includes Covered Software in a proprietary executable installer.  The *
 * installers produced by InstallShield are an example of this.  Including *
 * Nmap with other software in compressed or archival form does not        *
 * trigger this provision, provided appropriate open source decompression  *
 * or de-archiving software is widely available for no charge.  For the    *
 * purposes of this license, an installer is considered to include Covered *
 * Software even if it actually retrieves a copy of Covered Software from  *
 * another source during runtime (such as by downloading it from the       *
 * Internet).                                                              *
 *                                                                         *
 * o Links (statically or dynamically) to a library which does any of the  *
 * above.                                                                  *
 *                                                                         *
 * o Executes a helper program, module, or script to do any of the above.  *
 *                                                                         *
 * This list is not exclusive, but is meant to clarify our interpretation  *
 * of derived works with some common examples.  Other people may interpret *
 * the plain GPL differently, so we consider this a special exception to   *
 * the GPL that we apply to Covered Software.  Works which meet any of     *
 * these conditions must conform to all of the terms of this license,      *
 * particularly including the GPL Section 3 requirements of providing      *
 * source code and allowing free redistribution of the work as a whole.    *
 *                                                                         *
 * As another special exception to the GPL terms, Insecure.Com LLC grants  *
 * permission to link the code of this program with any version of the     *
 * OpenSSL library which is distributed under a license identical to that  *
 * listed in the included docs/licenses/OpenSSL.txt file, and distribute   *
 * linked combinations including the two.                                  *
 *                                                                         *
 * Any redistribution of Covered Software, including any derived works,    *
 * must obey and carry forward all of the terms of this license, including *
 * obeying all GPL rules and restrictions.  For example, source code of    *
 * the whole work must be provided and free redistribution must be         *
 * allowed.  All GPL references to "this License", are to be treated as    *
 * including the terms and conditions of this license text as well.       *
 *                                                                         *
 * Because this license imposes special exceptions to the GPL, Covered     *
 * Work may not be combined (even as part of a larger work) with plain GPL *
 * software.  The terms, conditions, and exceptions of this license must   *
 * be included as well.  This license is incompatible with some other open *
 * source licenses as well.  In some cases we can relicense portions of    *
 * Nmap or grant special permissions to use it in other open source        *
 * software.  Please contact fyodor@nmap.org with any such requests.       *
 * Similarly, we don't incorporate incompatible open source software into  *
 * Covered Software without special permission from the copyright holders. *
 *                                                                         *
 * If you have any questions about the licensing restrictions on using     *
 * Nmap in other works, are happy to help.  As mentioned above, we also    *
 * offer alternative license to integrate Nmap into proprietary            *
 * applications and appliances.  These contracts have been sold to dozens  *
 * of software vendors, and generally include a perpetual license as well  *
 * as providing for priority support and updates.  They also fund the      *
 * continued development of Nmap.  Please email sales@nmap.com for further *
 * information.                                                            *
 *                                                                         *
 * If you have received a written license agreement or contract for        *
 * Covered Software stating terms other than these, you may choose to use  *
 * and redistribute Covered Software under those terms instead of these.   *
 *                                                                         *
 * Source is provided to this software because we believe users have a     *
 * right to know exactly what a program is going to do before they run it. *
 * This also allows you to audit the software for security holes (none     *
 * have been found so far).                                                *
 *                                                                         *
 * Source code also allows you to port Nmap to new platforms, fix bugs,    *
 * and add new features.  You are highly encouraged to send your changes   *
 * to the dev@nmap.org mailing list for possible incorporation into the    *
 * main distribution.  By sending these changes to Fyodor or one of the    *
 * Insecure.Org development mailing lists, or checking them into the Nmap  *
 * source code repository, it is understood (unless you specify otherwise) *
 * that you are offering the Nmap Project (Insecure.Com LLC) the           *
 * unlimited, non-exclusive right to reuse, modify, and relicense the      *
 * code.  Nmap will always be available Open Source, but this is important *
 * because the inability to relicense code has caused devastating problems *
 * for other Free Software projects (such as KDE and NASM).  We also       *
 * occasionally relicense the code to third parties as discussed above.    *
 * If you wish to specify special license conditions of your               *
 * contributions, just say so when you send them.                          *
 *                                                                         *
 * This program 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 Nmap      *
 * license file for more details (it's in a COPYING file included with     *
 * Nmap, and also available from https://svn.nmap.org/nmap/COPYING         *
 *                                                                         *
 ***************************************************************************/

/* $Id$ */

#include "ncat.h"
#include "ncat_lua.h"
#include "ncat_lua_filters.h"
#include "ncat_lua_connect.h"

/* This function is quite similar to write_socket_handler from ncat_connect.c,
   with the exception that we're not reading from stdin - this is meant for
   lua_run_onconnect, which is ran before the ncat_connect.c main loop. */
static void write_socket_handler_nostdin(nsock_pool nsp, nsock_event evt, void *data)
{
    enum nse_status status = nse_status(evt);
    enum nse_type type = nse_type(evt);

    ncat_assert(type == NSE_TYPE_WRITE);

    if (status == NSE_STATUS_ERROR) {
        loguser("%s.\n", socket_strerror(nse_errorcode(evt)));
        exit(1);
    } else if (status == NSE_STATUS_TIMEOUT) {
        loguser("%s.\n", socket_strerror(ETIMEDOUT));
        exit(1);
    } else if (status == NSE_STATUS_CANCELLED || status == NSE_STATUS_KILL) {
        return;
    } else {
        ncat_assert(status == NSE_STATUS_SUCCESS);
    }
}

void lua_store_nsi(nsock_iod nsiod)
{
    struct ncat_lua_state *nl = get_connection(NULL, NULL);
    nl->nsiod = nsiod;
    lua_pop(filters_L, 1);
}

/* Read the nsock buffer, resume the coroutine, passing it as an argument and
   perform ncat_nsock_postread on whatever it returned. Remove the coroutine
   and schedule another read. */
static void lua_read_socket_handler(nsock_pool nsp, nsock_event evt, void *data)
{
    int nbytes, resume_result;
    size_t nbytes_s;
    lua_State *recv_coroutine;
    const char *buf;

    get_connection(NULL, NULL);

    check_nsock_error(nsp, evt);

    buf = nse_readbuf(evt, &nbytes);

    lua_getfield(filters_L, -1, "recv_coroutine");
    recv_coroutine = lua_tothread(filters_L, -1);

    lua_insert(filters_L, -2);
    lua_pushlstring(recv_coroutine, buf, nbytes);

    resume_result = lua_resume(recv_coroutine, filters_L, 1);
    if (resume_result != LUA_OK) {
        if (o.debug)
            logdebug("lua_nsock_read: resume_result=%d\n", resume_result);
        lua_report(filters_L, "read() error after yield", 0);
        return;
    }

    buf = lua_tolstring(recv_coroutine, -1, &nbytes_s);

    ncat_nsock_postread(nsp, evt, buf, nbytes_s);

    lua_pushnil(filters_L);
    lua_setfield(filters_L, -2, "recv_coroutine");

    lua_pop(filters_L, 2);

    lua_nsock_read();
}

/* Lowest-level recv() - schedule an nsock read and yield. */
int lua_nsock_recv_raw(lua_State *L)
{
    int ret;
    struct ncat_lua_state *nls = lua_fetch_userdata(L, 1, &ret);

    if (!nls->connected) {
        lua_pushstring(L, "Trying to call recv() on a socket that is not connected.");
        lua_error(L);
    }

    if (ret >= 0)
        return ret;

    nsock_read(nls->nsp, nls->nsiod, lua_read_socket_handler, -1, NULL);

    lua_pushthread(L);
    lua_setfield(L, 1, "recv_thread");
    return lua_yield(L, 0);
}

int lua_nsock_write_raw(lua_State *L)
{
    char *buf;
    size_t size;

    int ret;
    struct ncat_lua_state *nls = lua_fetch_userdata(L, 1, &ret);
    if (ret >= 0)
        return ret;

    if (!nls->connected) {
        lua_pushstring(L, "Trying to call send() on a socket that is not connected.");
        lua_error(L);
    }

    buf = (char *) lua_tolstring(L, 2, &size);
    if (nls->in_send)
        nsock_write(nls->nsp, nls->nsiod, write_socket_handler, -1, NULL, buf, size);
    else
        nsock_write(nls->nsp, nls->nsiod, write_socket_handler_nostdin, -1, NULL, buf, size);
    ncat_log_send(buf, size);

    lua_pushboolean(L, 1);
    return 1;
}

int lua_nsock_write(nsock_pool nsp, nsock_iod nsiod, const char *data, int datalen)
{
    int old_top, num_returned;
    struct ncat_lua_state *nl = get_connection(NULL, NULL);
    nl->in_send = 1;

    nl->nsp = nsp;
    nl->nsiod = nsiod;

    old_top = lua_gettop(filters_L);
    lua_getfield(filters_L, -1, "send");
    lua_insert(filters_L, -2);
    lua_pushlstring(filters_L, data, datalen);

    if (lua_pcall(filters_L, 2, LUA_MULTRET, 0) != LUA_OK) {
        if (o.debug)
            lua_report(filters_L, "send() error", 0);
        return -1;
    }

    num_returned = lua_gettop(filters_L) - old_top + 1;

    if (num_returned < 1 || num_returned > 2) {
        if (o.debug)
            logdebug("send() returned wrong number of values.\n");
        lua_pop(filters_L, num_returned);
        return -1;
    }

    if (lua_isnil(filters_L, -num_returned)) {
        if (o.debug) {
            logdebug("send() returned nil");
            if (num_returned == 2)
                loguser_noprefix(": %s\n", lua_tostring(filters_L, -1));
            else
                loguser_noprefix(".\n");
        }
        lua_pop(filters_L, num_returned);
        return -1;
    }

    lua_pop(filters_L, num_returned);
    return 0;
}

void lua_nsock_read()
{
    int resume_result;
    lua_State *NL = lua_newthread(filters_L);
    get_connection(NULL, NULL);

    lua_getfield(filters_L, -1, "recv_coroutine");
    if (!lua_isnil(filters_L, -1))
        loguser("TODO: WARNING: socket.recv_coro not nil, its value is '%s'.\n",
            lua_tostring(filters_L, -1));
    lua_pop(filters_L, 1);
    lua_pushvalue(filters_L, -2);
    lua_setfield(filters_L, -2, "recv_coroutine"); /* socket.recv_coro = thread */

    /* Create a coroutine for socket:recv() */
    lua_getfield(filters_L, -1, "recv");
    lua_insert(filters_L, -2);
    lua_xmove(filters_L, NL, 2);

    resume_result = lua_resume(NL, filters_L, 1);
    if (resume_result != LUA_YIELD) {
        if (o.debug)
            logdebug("lua_nsock_read: resume_result=%d\n", resume_result);
        lua_report(filters_L, "read() error before yield", 0);
        return;
    }

    lua_pop(filters_L, 1); /* pop the thread */
}

int lua_nsock_close(lua_State *L)
{
    int ret;
    struct ncat_lua_state *nls = lua_fetch_userdata(L, 1, &ret);
    if (ret >= 0)
        return ret;

    if (!nls->connected) {
        lua_pushstring(L, "Trying to call close() on a socket that is not connected.");
        lua_error(L);
    }

    nsi_delete(nls->nsiod, NSOCK_PENDING_NOTIFY);
    lua_unregister_fd(NULL);
    nls->connected = 0;

    lua_pushboolean(L, 1);
    return 1;
}

int lua_connect_raw(lua_State *L)
{
    int ret, fetch_ret, portno, nargs;
    const char *hostname;
    struct ncat_lua_state *nls;

    nargs = lua_gettop(L);

    nls = lua_fetch_userdata(L, 1, &fetch_ret);
    if (fetch_ret >= 0)
        return fetch_ret;

    if (nls->connected) {
        lua_pushstring(L, "Trying to call connect() on an already connected socket.");
        lua_error(L);
    }

    if (nargs != 3) {
        lua_pushstring(L, "connect(): received wrong number of arguments.");
        lua_error(L);
    }

    hostname = lua_tostring(L, 2);
    portno = lua_tointeger(L, 3);

    /* TODO: Handle special cases - proxies, unix sockets. */
    ret = resolve(hostname, 0, &targetss.storage, &targetsslen, o.af);

    if (targetss.storage.ss_family == AF_INET)
        targetss.in.sin_port = htons(portno);
#ifdef HAVE_IPV6
    else if (targetss.storage.ss_family == AF_INET6)
        targetss.in6.sin6_port = htons(portno);
#endif

    if (ret || run_connect(&nls->nsp))
        lua_pushnil(L);
    else {
        lua_pushboolean(L, 1);
        nls->connected = 1;
    }

    return 1;
}

int lua_run_connect(nsock_pool *nsp, char *hostname, unsigned int portno)
{
    int ret;
    struct ncat_lua_state *nl = get_connection(NULL, NULL);
    nl->nsp = *nsp;
    nl->in_send = 0;

    lua_getfield(filters_L, -1, "connect");
    lua_insert(filters_L, -2);
    lua_pushstring(filters_L, hostname);
    if (portno != -1)
        lua_pushinteger(filters_L, portno);
    else
        lua_pushnil(filters_L);
    if (lua_pcall(filters_L, 3, 1, 0) != LUA_OK) {
        lua_report(filters_L, "connect() error", 0);
        return -1;
    }

    *nsp = nl->nsp;
    ret = lua_isnil(filters_L, -1);
    lua_pop(filters_L, 1);
    return ret;
}