badvpn/ncd/modules/socket.c

/**
 * @file socket.c
 * @author Ambroz Bizjak <ambrop7@gmail.com>
 * 
 * @section LICENSE
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the author nor the
 *    names of its contributors may be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * @section DESCRIPTION
 * 
 * Synopsis:
 *   sys.socket sys.connect(string addr [, map options])
 * 
 * Options:
 *   "read_size" - the maximum number of bytes that can be read by a single
 *     read() call. Must be greater than zero. Greater values may improve
 *     performance, but will increase memory usage. Default: 8192.
 * 
 * Variables:
 *   string is_error - "true" if there was an error with the connection,
 *     "false" if not
 * 
 * Description:
 *   Attempts to establish a connection to a server. The address should be
 *   in one of the following forms:
 *   - {"tcp", {"ipv4", ipv4_address, port_number}},
 *   - {"tcp", {"ipv6", ipv6_address, port_number}},
 *   - {"unix", socket_path},
 *   - {"device", device_path}.
 *   When the connection attempt is finished, the sys.connect() statement goes
 *   up, and the 'is_error' variable should be used to check for connection
 *   failure. If there was no error, the read(), write() and close() methods
 *   can be used to work with the connection.
 *   If an error occurs after the connection has been established, the
 *   sys.connect() statement will automatically trigger backtracking, and the
 *   'is_error' variable will be changed to "true". This means that all
 *   errors with the connection can be handled at the place of sys.connect(),
 *   and no special care is normally needed to handle error in read() and
 *   write().
 *   The special "device" address type may be used to connect to a serial
 *   port. But you need to configure the port yourself first (stty).
 *   WARNING: when you're not trying to either send or receive data, the
 *   connection may be unable to detect any events with the connection.
 *   You should never be neither sending nor receiving for an indefinite time.
 * 
 * Synopsis:
 *   sys.socket::read()
 * 
 * Variables:
 *   string (empty) - some data received from the socket, or empty on EOF
 *   string eof - "true" if EOF was encountered, "false" if not
 *   string not_eof - (deprecated) "true" if EOF was not encountered,
 *     "false" if it was
 * 
 * Description:
 *   Receives data from the connection. If EOF was encountered (remote host
 *   has closed the connection), this returns no data. Otherwise it returns
 *   at least one byte.
 *   WARNING: after you receive EOF from a sys.listen() type socket, is is
 *   your responsibility to call close() eventually, else the cline process
 *   may remain alive indefinitely.
 *   WARNING: this may return an arbitrarily small chunk of data. There is
 *   no significance to the size of the chunks. Correct code will behave
 *   the same no matter how the incoming data stream is split up.
 *   WARNING: if a read() is terminated while it is still in progress, i.e.
 *   has not gone up yet, then the connection is automatically closed, as
 *   if close() was called.
 * 
 * Synopsis:
 *   sys.socket::write(string data)
 * 
 * Description:
 *   Sends data to the connection.
 *   WARNING: this may block if the operating system's internal send buffer
 *   is full. Be careful not to enter a deadlock where both ends of the
 *   connection are trying to send data to the other, but neither is trying
 *   to receive any data.
 *   WARNING: if a write() is terminated while it is still in progress, i.e.
 *   has not gone up yet, then the connection is automatically closed, as
 *   if close() was called.
 * 
 * Synopsis:
 *   sys.socket::close()
 * 
 * Description:
 *   Closes the connection. After this, any further read(), write() or close()
 *   will trigger an error with the interpreter. For client sockets created
 *   via sys.listen(), this will immediately trigger termination of the client
 *   process.
 * 
 * Synopsis:
 *   sys.listen(string address, string client_template, list args [, map options])
 * 
 * Options:
 *   "read_size" - the maximum number of bytes that can be read by a single
 *     read() call. Must be greater than zero. Greater values may improve
 *     performance, but will increase memory usage. Default: 8192.
 * 
 * Variables:
 *   string is_error - "true" if listening failed to inittialize, "false" if
 *     not
 * 
 * Special objects and variables in client_template:
 *   sys.socket _socket - the socket object for the client
 *   string _socket.client_addr - the address of the client. The form is
 *     like the second part of the sys.connect() address format, e.g.
 *     {"ipv4", "1.2.3.4", "4000"}.
 * 
 * Description:
 *   Starts listening on the specified address. The format of the device is
 *   as described for sys.connect, but without the "device" address type.
 *   The 'is_error' variable
 *   reflects the success of listening initiation. If listening succeeds,
 *   then for every client that connects, a process is automatically created
 *   from the template specified by 'client_template', and the 'args' list
 *   is used as template arguments. Inside such processes, a special object
 *   '_socket' is available, which represents the connection, and supports
 *   the same methods as sys.connect(), i.e. read(), write() and close().
 *   When an error occurs with the connection, the socket is automatically
 *   closed, triggering process termination.
 */

#include <stdlib.h>
#include <limits.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <misc/offset.h>
#include <misc/debug.h>
#include <structure/LinkedList0.h>
#include <system/BConnection.h>
#include <system/BConnectionGeneric.h>
#include <ncd/extra/address_utils.h>
#include <ncd/extra/NCDBuf.h>

#include <ncd/module_common.h>

#include <generated/blog_channel_ncd_socket.h>

#define CONNECTION_TYPE_CONNECT 1
#define CONNECTION_TYPE_LISTEN 2

#define CONNECTION_STATE_CONNECTING 1
#define CONNECTION_STATE_ESTABLISHED 2
#define CONNECTION_STATE_ERROR 3
#define CONNECTION_STATE_ABORTED 4

#define DEFAULT_READ_BUF_SIZE 8192

struct connection {
    union {
        struct {
            NCDModuleInst *i;
            BConnector connector;
            size_t read_buf_size;
        } connect;
        struct {
            struct listen_instance *listen_inst;
            LinkedList0Node clients_list_node;
            BAddr addr;
            NCDModuleProcess process;
        } listen;
    };
    
    unsigned int type:2;
    unsigned int state:3;
    unsigned int recv_closed:1;
    BConnection connection;
    NCDBufStore store;
    struct read_instance *read_inst;
    struct write_instance *write_inst;
};

struct read_instance {
    NCDModuleInst *i;
    struct connection *con_inst;
    NCDBuf *buf;
    size_t read_size;
};

struct write_instance {
    NCDModuleInst *i;
    struct connection *con_inst;
    MemRef data;
};

struct listen_instance {
    NCDModuleInst *i;
    unsigned int have_error:1;
    unsigned int dying:1;
    size_t read_buf_size;
    NCDValRef client_template;
    NCDValRef client_template_args;
    BListener listener;
    LinkedList0 clients_list;
};

enum {STRING_SOCKET, STRING_SYS_SOCKET, STRING_CLIENT_ADDR};

static const char *strings[] = {
    "_socket", "sys.socket", "client_addr", NULL
};

static int parse_options (NCDModuleInst *i, NCDValRef options, size_t *out_read_size);
static void connection_log (struct connection *o, int level, const char *fmt, ...);
static void connection_free_connection (struct connection *o);
static void connection_error (struct connection *o);
static void connection_abort (struct connection *o);
static void connection_connector_handler (void *user, int is_error);
static void connection_complete_establish (struct connection *o);
static void connection_connection_handler (void *user, int event);
static void connection_send_handler_done (void *user, int data_len);
static void connection_recv_handler_done (void *user, int data_len);
static void connection_process_handler (struct NCDModuleProcess_s *process, int event);
static int connection_process_func_getspecialobj (struct NCDModuleProcess_s *process, NCD_string_id_t name, NCDObject *out_object);
static int connection_process_socket_obj_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value);
static int connection_process_caller_obj_func_getobj (const NCDObject *obj, NCD_string_id_t name, NCDObject *out_object);
static void listen_listener_handler (void *user);

static int parse_options (NCDModuleInst *i, NCDValRef options, size_t *out_read_size)
{
    ASSERT(out_read_size)
    
    *out_read_size = DEFAULT_READ_BUF_SIZE;
    
    if (!NCDVal_IsInvalid(options)) {
        if (!NCDVal_IsMap(options)) {
            ModuleLog(i, BLOG_ERROR, "options argument is not a map");
            return 0;
        }
        
        int num_recognized = 0;
        NCDValRef value;
        
        if (!NCDVal_IsInvalid(value = NCDVal_MapGetValue(options, "read_size"))) {
            uintmax_t read_size;
            if (!ncd_read_uintmax(value, &read_size) || read_size > SIZE_MAX || read_size == 0) {
                ModuleLog(i, BLOG_ERROR, "wrong read_size");
                return 0;
            }
            num_recognized++;
            *out_read_size = read_size;
        }
        
        if (NCDVal_MapCount(options) > num_recognized) {
            ModuleLog(i, BLOG_ERROR, "unrecognized options present");
            return 0;
        }
    }
    
    return 1;
}

static void connection_log (struct connection *o, int level, const char *fmt, ...)
{
    va_list vl;
    va_start(vl, fmt);
    
    switch (o->type) {
        case CONNECTION_TYPE_CONNECT: {
            NCDModuleInst_Backend_LogVarArg(o->connect.i, BLOG_CURRENT_CHANNEL, level, fmt, vl);
        } break;
        
        case CONNECTION_TYPE_LISTEN: {
            if (BLog_WouldLog(BLOG_CURRENT_CHANNEL, level)) {
                BLog_Begin();
                o->listen.listen_inst->i->params->logfunc(o->listen.listen_inst->i);
                char addr_str[BADDR_MAX_PRINT_LEN];
                BAddr_Print(&o->listen.addr, addr_str);
                BLog_Append("client %s: ", addr_str);
                BLog_AppendVarArg(fmt, vl);
                BLog_Finish(BLOG_CURRENT_CHANNEL, level);
            }
        } break;
        
        default: ASSERT(0);
    }
    
    va_end(vl);
}

static void connection_free_connection (struct connection *o)
{
    // disconnect read instance
    if (o->read_inst) {
        ASSERT(o->read_inst->con_inst == o)
        o->read_inst->con_inst = NULL;
    }
    
    // disconnect write instance
    if (o->write_inst) {
        ASSERT(o->write_inst->con_inst == o)
        o->write_inst->con_inst = NULL;
    }
    
    // free connection interfaces
    BConnection_RecvAsync_Free(&o->connection);
    BConnection_SendAsync_Free(&o->connection);
    
    // free connection
    BConnection_Free(&o->connection);
    
    // free store
    NCDBufStore_Free(&o->store);
}

static void connection_error (struct connection *o)
{
    ASSERT(o->state == CONNECTION_STATE_CONNECTING ||
           o->state == CONNECTION_STATE_ESTABLISHED)
    
    // for listen clients, we don't report errors directly,
    // we just terminate the client process
    if (o->type == CONNECTION_TYPE_LISTEN) {
        ASSERT(o->state != CONNECTION_STATE_CONNECTING)
        connection_abort(o);
        return;
    }
    
    // free connector
    if (o->state == CONNECTION_STATE_CONNECTING) {
        BConnector_Free(&o->connect.connector);
    }
    
    // free connection resources
    if (o->state == CONNECTION_STATE_ESTABLISHED) {
        connection_free_connection(o);
    }
    
    // trigger reporting of failure
    if (o->state == CONNECTION_STATE_ESTABLISHED) {
        NCDModuleInst_Backend_Down(o->connect.i);
    }
    NCDModuleInst_Backend_Up(o->connect.i);
    
    // set state
    o->state = CONNECTION_STATE_ERROR;
}

static void connection_abort (struct connection *o)
{
    ASSERT(o->state == CONNECTION_STATE_ESTABLISHED)
    
    // free connection resources
    connection_free_connection(o);
    
    // if this is a listen connection, terminate client process
    if (o->type == CONNECTION_TYPE_LISTEN) {
        NCDModuleProcess_Terminate(&o->listen.process);
    }
    
    // set state
    o->state = CONNECTION_STATE_ABORTED;
}

static void connection_connector_handler (void *user, int is_error)
{
    struct connection *o = user;
    ASSERT(o->type == CONNECTION_TYPE_CONNECT)
    ASSERT(o->state == CONNECTION_STATE_CONNECTING)
    
    // check error
    if (is_error) {
        connection_log(o, BLOG_ERROR, "connection failed");
        goto fail;
    }
    
    // init connection
    if (!BConnection_Init(&o->connection, BConnection_source_connector(&o->connect.connector), o->connect.i->params->iparams->reactor, o, connection_connection_handler)) {
        connection_log(o, BLOG_ERROR, "BConnection_Init failed");
        goto fail;
    }
    
    // free connector
    BConnector_Free(&o->connect.connector);
    
    return connection_complete_establish(o);
    
fail:
    connection_error(o);
}

static void connection_complete_establish (struct connection *o)
{
    // init connection interfaces
    BConnection_SendAsync_Init(&o->connection);
    BConnection_RecvAsync_Init(&o->connection);
    
    // setup send/recv done callbacks
    StreamPassInterface_Sender_Init(BConnection_SendAsync_GetIf(&o->connection), connection_send_handler_done, o);
    StreamRecvInterface_Receiver_Init(BConnection_RecvAsync_GetIf(&o->connection), connection_recv_handler_done, o);
    
    // init store
    NCDBufStore_Init(&o->store, o->connect.read_buf_size);
    
    // set not reading, not writing, recv not closed
    o->read_inst = NULL;
    o->write_inst = NULL;
    o->recv_closed = 0;
    
    // set state
    o->state = CONNECTION_STATE_ESTABLISHED;
    
    // go up
    NCDModuleInst_Backend_Up(o->connect.i);
}

static void connection_connection_handler (void *user, int event)
{
    struct connection *o = user;
    ASSERT(o->state == CONNECTION_STATE_ESTABLISHED)
    ASSERT(event == BCONNECTION_EVENT_RECVCLOSED || event == BCONNECTION_EVENT_ERROR)
    ASSERT(event != BCONNECTION_EVENT_RECVCLOSED || !o->recv_closed)
    
    if (event == BCONNECTION_EVENT_RECVCLOSED) {
        // if we have read operation, make it finish with eof
        if (o->read_inst) {
            ASSERT(o->read_inst->con_inst == o)
            o->read_inst->con_inst = NULL;
            o->read_inst->read_size = 0;
            NCDModuleInst_Backend_Up(o->read_inst->i);
            o->read_inst = NULL;
        }
        
        // set recv closed
        o->recv_closed = 1;
        return;
    }
    
    connection_log(o, BLOG_ERROR, "connection error");
    
    // handle error
    connection_error(o);
}

static void connection_send_handler_done (void *user, int data_len)
{
    struct connection *o = user;
    ASSERT(o->state == CONNECTION_STATE_ESTABLISHED)
    ASSERT(o->write_inst)
    ASSERT(o->write_inst->con_inst == o)
    ASSERT(data_len > 0)
    ASSERT(data_len <= o->write_inst->data.len)
    
    struct write_instance *wr = o->write_inst;
    
    // update send state
    wr->data = MemRef_SubFrom(wr->data, data_len);
    
    // if there's more to send, send again
    if (wr->data.len > 0) {
        size_t to_send = (wr->data.len > INT_MAX) ? INT_MAX : wr->data.len;
        StreamPassInterface_Sender_Send(BConnection_SendAsync_GetIf(&o->connection), (uint8_t *)wr->data.ptr, to_send);
        return;
    }
    
    // finish write operation
    wr->con_inst = NULL;
    NCDModuleInst_Backend_Up(wr->i);
    o->write_inst = NULL;
}

static void connection_recv_handler_done (void *user, int data_len)
{
    struct connection *o = user;
    ASSERT(o->state == CONNECTION_STATE_ESTABLISHED)
    ASSERT(o->read_inst)
    ASSERT(o->read_inst->con_inst == o)
    ASSERT(!o->recv_closed)
    ASSERT(data_len > 0)
    ASSERT(data_len <= NCDBufStore_BufSize(&o->store))
    
    struct read_instance *re = o->read_inst;
    
    // finish read operation
    re->con_inst = NULL;
    re->read_size = data_len;
    NCDModuleInst_Backend_Up(re->i);
    o->read_inst = NULL;
}

static void connection_process_handler (struct NCDModuleProcess_s *process, int event)
{
    struct connection *o = UPPER_OBJECT(process, struct connection, listen.process);
    ASSERT(o->type == CONNECTION_TYPE_LISTEN)
    
    switch (event) {
        case NCDMODULEPROCESS_EVENT_UP: {
            ASSERT(o->state == CONNECTION_STATE_ESTABLISHED)
        } break;
        
        case NCDMODULEPROCESS_EVENT_DOWN: {
            ASSERT(o->state == CONNECTION_STATE_ESTABLISHED)
            NCDModuleProcess_Continue(&o->listen.process);
        } break;
        
        case NCDMODULEPROCESS_EVENT_TERMINATED: {
            ASSERT(o->state == CONNECTION_STATE_ABORTED)
            
            struct listen_instance *li = o->listen.listen_inst;
            ASSERT(!li->have_error)
            
            // remove from clients list
            LinkedList0_Remove(&li->clients_list, &o->listen.clients_list_node);
            
            // free process
            NCDModuleProcess_Free(&o->listen.process);
            
            // free connection structure
            free(o);
            
            // if listener is dying and this was the last process, have it die
            if (li->dying && LinkedList0_IsEmpty(&li->clients_list)) {
                NCDModuleInst_Backend_Dead(li->i);
            }
        } break;
        
        default: ASSERT(0);
    }
}

static int connection_process_func_getspecialobj (struct NCDModuleProcess_s *process, NCD_string_id_t name, NCDObject *out_object)
{
    struct connection *o = UPPER_OBJECT(process, struct connection, listen.process);
    ASSERT(o->type == CONNECTION_TYPE_LISTEN)
    
    if (name == ModuleString(o->listen.listen_inst->i, STRING_SOCKET)) {
        *out_object = NCDObject_Build(ModuleString(o->listen.listen_inst->i, STRING_SYS_SOCKET), o, connection_process_socket_obj_func_getvar, NCDObject_no_getobj);
        return 1;
    }
    
    if (name == NCD_STRING_CALLER) {
        *out_object = NCDObject_Build(-1, o, NCDObject_no_getvar, connection_process_caller_obj_func_getobj);
        return 1;
    }
    
    return 0;
}

static int connection_process_socket_obj_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value)
{
    struct connection *o = NCDObject_DataPtr(obj);
    ASSERT(o->type == CONNECTION_TYPE_LISTEN)
    
    if (name == ModuleString(o->listen.listen_inst->i, STRING_CLIENT_ADDR)) {
        *out_value = ncd_make_baddr(o->listen.addr, mem);
        if (NCDVal_IsInvalid(*out_value)) {
            connection_log(o, BLOG_ERROR, "ncd_make_baddr failed");
        }
        return 1;
    }
    
    return 0;
}

static int connection_process_caller_obj_func_getobj (const NCDObject *obj, NCD_string_id_t name, NCDObject *out_object)
{
    struct connection *o = NCDObject_DataPtr(obj);
    ASSERT(o->type == CONNECTION_TYPE_LISTEN)
    
    return NCDModuleInst_Backend_GetObj(o->listen.listen_inst->i, name, out_object);
}

static void listen_listener_handler (void *user)
{
    struct listen_instance *o = user;
    ASSERT(!o->have_error)
    ASSERT(!o->dying)
    
    // allocate connection structure
    struct connection *con = malloc(sizeof(*con));
    if (!con) {
        ModuleLog(o->i, BLOG_ERROR, "malloc failed");
        goto fail0;
    }
    
    // set connection type and listen instance
    con->type = CONNECTION_TYPE_LISTEN;
    con->listen.listen_inst = o;
    
    // init connection
    if (!BConnection_Init(&con->connection, BConnection_source_listener(&o->listener, &con->listen.addr), o->i->params->iparams->reactor, con, connection_connection_handler)) {
        ModuleLog(o->i, BLOG_ERROR, "BConnection_Init failed");
        goto fail1;
    }
    
    // init connection interfaces
    BConnection_SendAsync_Init(&con->connection);
    BConnection_RecvAsync_Init(&con->connection);
    
    // setup send/recv done callbacks
    StreamPassInterface_Sender_Init(BConnection_SendAsync_GetIf(&con->connection), connection_send_handler_done, con);
    StreamRecvInterface_Receiver_Init(BConnection_RecvAsync_GetIf(&con->connection), connection_recv_handler_done, con);
    
    // init process
    if (!NCDModuleProcess_InitValue(&con->listen.process, o->i, o->client_template, o->client_template_args, connection_process_handler)) {
        ModuleLog(o->i, BLOG_ERROR, "NCDModuleProcess_InitValue failed");
        goto fail2;
    }
    
    // set special objects callback
    NCDModuleProcess_SetSpecialFuncs(&con->listen.process, connection_process_func_getspecialobj);
    
    // insert to clients list
    LinkedList0_Prepend(&o->clients_list, &con->listen.clients_list_node);
    
    // init store
    NCDBufStore_Init(&con->store, o->read_buf_size);
    
    // set not reading, not writing, recv not closed
    con->read_inst = NULL;
    con->write_inst = NULL;
    con->recv_closed = 0;
    
    // set state
    con->state = CONNECTION_STATE_ESTABLISHED;
    return;
    
fail2:
    BConnection_RecvAsync_Free(&con->connection);
    BConnection_SendAsync_Free(&con->connection);
    BConnection_Free(&con->connection);
fail1:
    free(con);
fail0:
    return;
}

static int connect_custom_addr_handler (void *user, NCDValRef protocol, NCDValRef data)
{
    NCDValRef *device_path = user;
    if (NCDVal_StringEquals(protocol, "device")) {
        if (!NCDVal_IsStringNoNulls(data)) {
            return 0;
        }
        *device_path = data;
        return 1;
    }
    return 0;
}

static void connect_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
    struct connection *o = vo;
    o->type = CONNECTION_TYPE_CONNECT;
    o->connect.i = i;
    
    // pass connection pointer to methods so the same methods can work for
    // listen type connections
    NCDModuleInst_Backend_PassMemToMethods(i);
    
    // read arguments
    NCDValRef address_arg;
    NCDValRef options_arg = NCDVal_NewInvalid();
    if (!NCDVal_ListRead(params->args, 1, &address_arg) &&
        !NCDVal_ListRead(params->args, 2, &address_arg, &options_arg)
    ) {
        ModuleLog(i, BLOG_ERROR, "wrong arity");
        goto fail0;
    }
    
    // parse options
    if (!parse_options(i, options_arg, &o->connect.read_buf_size)) {
        goto fail0;
    }
    
    // read address
    struct BConnection_addr address;
    NCDValRef device_path;
    if (!ncd_read_bconnection_addr_ext(address_arg, connect_custom_addr_handler, &device_path, &address)) {
        ModuleLog(i, BLOG_ERROR, "wrong address");
        goto error;
    }
    
    // Did the custom handler handle the address as a device?
    if (address.type == -1) {
        // get null terminated device path
        NCDValNullTermString device_path_nts;
        if (!NCDVal_StringNullTerminate(device_path, &device_path_nts)) {
            ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
            goto error;
        }
        
        // open the device
        int devfd = open(device_path_nts.data, O_RDWR|O_NONBLOCK);
        NCDValNullTermString_Free(&device_path_nts);
        if (devfd < 0) {
            ModuleLog(i, BLOG_ERROR, "open failed");
            goto error;
        }
        
        // init connection
        if (!BConnection_Init(&o->connection, BConnection_source_pipe(devfd, 1), i->params->iparams->reactor, o, connection_connection_handler)) {
            ModuleLog(i, BLOG_ERROR, "BConnection_Init failed");
            goto error;
        }
        
        connection_complete_establish(o);
    } else {
        // init connector
        if (!BConnector_InitGeneric(&o->connect.connector, address, i->params->iparams->reactor, o, connection_connector_handler)) {
            ModuleLog(i, BLOG_ERROR, "BConnector_InitGeneric failed");
            goto error;
        }
        
        // set state
        o->state = CONNECTION_STATE_CONNECTING;
    }
    
    return;
    
error:
    // go up in error state
    o->state = CONNECTION_STATE_ERROR;
    NCDModuleInst_Backend_Up(i);
    return;
    
fail0:
    NCDModuleInst_Backend_DeadError(i);
}

static void connect_func_die (void *vo)
{
    struct connection *o = vo;
    ASSERT(o->type == CONNECTION_TYPE_CONNECT)
    
    // free connector
    if (o->state == CONNECTION_STATE_CONNECTING) {
        BConnector_Free(&o->connect.connector);
    }
    
    // free connection resources
    if (o->state == CONNECTION_STATE_ESTABLISHED) {
        connection_free_connection(o);
    }
    
    NCDModuleInst_Backend_Dead(o->connect.i);
}

static int connect_func_getvar (void *vo, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out)
{
    struct connection *o = vo;
    ASSERT(o->type == CONNECTION_TYPE_CONNECT)
    ASSERT(o->state != CONNECTION_STATE_CONNECTING)
    
    if (name == NCD_STRING_IS_ERROR) {
        int is_error = (o->state == CONNECTION_STATE_ERROR);
        *out = ncd_make_boolean(mem, is_error);
        return 1;
    }
    
    return 0;
}

static void read_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
    struct read_instance *o = vo;
    o->i = i;
    
    // read arguments
    if (!NCDVal_ListRead(params->args, 0)) {
        ModuleLog(i, BLOG_ERROR, "wrong arity");
        goto fail0;
    }
    
    // get connection
    struct connection *con_inst = params->method_user;
    
    // check connection state
    if (con_inst->state != CONNECTION_STATE_ESTABLISHED) {
        ModuleLog(i, BLOG_ERROR, "connection is not established");
        goto fail0;
    }
    
    // check if there's already a read in progress
    if (con_inst->read_inst) {
        ModuleLog(i, BLOG_ERROR, "read is already in progress");
        goto fail0;
    }
    
    // get buffer
    o->buf = NCDBufStore_GetBuf(&con_inst->store);
    if (!o->buf) {
        ModuleLog(i, BLOG_ERROR, "NCDBufStore_GetBuf failed");
        goto fail0;
    }
    
    // if eof was reached, go up immediately
    if (con_inst->recv_closed) {
        o->con_inst = NULL;
        o->read_size = 0;
        NCDModuleInst_Backend_Up(i);
        return;
    }
    
    // set connection
    o->con_inst = con_inst;
    
    // register read operation in connection
    con_inst->read_inst = o;
    
    // receive
    size_t buf_size = NCDBufStore_BufSize(&con_inst->store);
    int to_read = (buf_size > INT_MAX ? INT_MAX : buf_size);
    StreamRecvInterface_Receiver_Recv(BConnection_RecvAsync_GetIf(&con_inst->connection), (uint8_t *)NCDBuf_Data(o->buf), to_read);
    return;
    
fail0:
    NCDModuleInst_Backend_DeadError(i);
}

static void read_func_die (void *vo)
{
    struct read_instance *o = vo;
    
    // if we're receiving, abort connection
    if (o->con_inst) {
        ASSERT(o->con_inst->state == CONNECTION_STATE_ESTABLISHED)
        ASSERT(o->con_inst->read_inst == o)
        connection_abort(o->con_inst);
    }
    
    // release buffer
    BRefTarget_Deref(NCDBuf_RefTarget(o->buf));
    
    NCDModuleInst_Backend_Dead(o->i);
}

static int read_func_getvar (void *vo, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out)
{
    struct read_instance *o = vo;
    ASSERT(!o->con_inst)
    
    if (name == NCD_STRING_EMPTY) {
        *out = NCDVal_NewExternalString(mem, NCDBuf_Data(o->buf), o->read_size, NCDBuf_RefTarget(o->buf));
        return 1;
    }
    
    if (name == NCD_STRING_EOF || name == NCD_STRING_NOT_EOF) {
        *out = ncd_make_boolean(mem, (o->read_size == 0) == (name == NCD_STRING_EOF));
        return 1;
    }
    
    return 0;
}

static void write_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
    struct write_instance *o = vo;
    o->i = i;
    
    // read arguments
    NCDValRef data_arg;
    if (!NCDVal_ListRead(params->args, 1, &data_arg)) {
        ModuleLog(i, BLOG_ERROR, "wrong arity");
        goto fail0;
    }
    if (!NCDVal_IsString(data_arg)) {
        ModuleLog(i, BLOG_ERROR, "wrong type");
        goto fail0;
    }
    
    // get connection
    struct connection *con_inst = params->method_user;
    
    // check connection state
    if (con_inst->state != CONNECTION_STATE_ESTABLISHED) {
        ModuleLog(i, BLOG_ERROR, "connection is not established");
        goto fail0;
    }
    
    // check if there's already a write in progress
    if (con_inst->write_inst) {
        ModuleLog(i, BLOG_ERROR, "write is already in progress");
        goto fail0;
    }
    
    // set send state
    o->data = NCDVal_StringMemRef(data_arg);
    
    // if there's nothing to send, go up immediately
    if (o->data.len == 0) {
        o->con_inst = NULL;
        NCDModuleInst_Backend_Up(i);
        return;
    }
    
    // set connection
    o->con_inst = con_inst;
    
    // register write operation in connection
    con_inst->write_inst = o;
    
    // send
    size_t to_send = (o->data.len > INT_MAX) ? INT_MAX : o->data.len;
    StreamPassInterface_Sender_Send(BConnection_SendAsync_GetIf(&con_inst->connection), (uint8_t *)o->data.ptr, to_send);
    return;
    
fail0:
    NCDModuleInst_Backend_DeadError(i);
}

static void write_func_die (void *vo)
{
    struct write_instance *o = vo;
    
    // if we're sending, abort connection
    if (o->con_inst) {
        ASSERT(o->con_inst->state == CONNECTION_STATE_ESTABLISHED)
        ASSERT(o->con_inst->write_inst == o)
        connection_abort(o->con_inst);
    }
    
    NCDModuleInst_Backend_Dead(o->i);
}

static void close_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
    // read arguments
    if (!NCDVal_ListRead(params->args, 0)) {
        ModuleLog(i, BLOG_ERROR, "wrong arity");
        goto fail0;
    }
    
    // get connection
    struct connection *con_inst = params->method_user;
    
    // check connection state
    if (con_inst->state != CONNECTION_STATE_ESTABLISHED) {
        ModuleLog(i, BLOG_ERROR, "connection is not established");
        goto fail0;
    }
    
    // go up
    NCDModuleInst_Backend_Up(i);
    
    // abort
    connection_abort(con_inst);
    return;
    
fail0:
    NCDModuleInst_Backend_DeadError(i);
}

static void listen_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
    struct listen_instance *o = vo;
    o->i = i;
    
    // read arguments
    NCDValRef address_arg;
    NCDValRef client_template_arg;
    NCDValRef args_arg;
    NCDValRef options_arg = NCDVal_NewInvalid();
    if (!NCDVal_ListRead(params->args, 3, &address_arg, &client_template_arg, &args_arg) &&
        !NCDVal_ListRead(params->args, 4, &address_arg, &client_template_arg, &args_arg, &options_arg)
    ) {
        ModuleLog(i, BLOG_ERROR, "wrong arity");
        goto fail0;
    }
    if (!NCDVal_IsString(client_template_arg) || !NCDVal_IsList(args_arg)) {
        ModuleLog(i, BLOG_ERROR, "wrong type");
        goto fail0;
    }
    
    // parse options
    if (!parse_options(i, options_arg, &o->read_buf_size)) {
        goto fail0;
    }
    
    // remember client template and arguments
    o->client_template = client_template_arg;
    o->client_template_args = args_arg;
    
    // set no error, not dying
    o->have_error = 0;
    o->dying = 0;
    
    // read address
    struct BConnection_addr address;
    if (!ncd_read_bconnection_addr(address_arg, &address)) {
        ModuleLog(i, BLOG_ERROR, "wrong address");
        goto error;
    }
    
    // init listener
    if (!BListener_InitGeneric(&o->listener, address, i->params->iparams->reactor, o, listen_listener_handler)) {
        ModuleLog(i, BLOG_ERROR, "BListener_InitGeneric failed");
        goto error;
    }
    
    // init clients list
    LinkedList0_Init(&o->clients_list);
    
    // go up
    NCDModuleInst_Backend_Up(i);
    return;
    
error:
    // go up with error
    o->have_error = 1;
    NCDModuleInst_Backend_Up(i);
    return;
    
fail0:
    NCDModuleInst_Backend_DeadError(i);
}

static void listen_func_die (void *vo)
{
    struct listen_instance *o = vo;
    ASSERT(!o->dying)
    
    // free listener
    if (!o->have_error) {
        BListener_Free(&o->listener);
    }
    
    // if we have no clients, die right away
    if (o->have_error || LinkedList0_IsEmpty(&o->clients_list)) {
        NCDModuleInst_Backend_Dead(o->i);
        return;
    }
    
    // set dying
    o->dying = 1;
    
    // abort all clients and wait for them
    for (LinkedList0Node *ln = LinkedList0_GetFirst(&o->clients_list); ln; ln = LinkedList0Node_Next(ln)) {
        struct connection *con = UPPER_OBJECT(ln, struct connection, listen.clients_list_node);
        ASSERT(con->type == CONNECTION_TYPE_LISTEN)
        ASSERT(con->listen.listen_inst == o)
        ASSERT(con->state == CONNECTION_STATE_ESTABLISHED || con->state == CONNECTION_STATE_ABORTED)
        
        if (con->state != CONNECTION_STATE_ABORTED) {
            connection_abort(con);
        }
    }
}

static int listen_func_getvar (void *vo, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out)
{
    struct listen_instance *o = vo;
    
    if (name == NCD_STRING_IS_ERROR) {
        *out = ncd_make_boolean(mem, o->have_error);
        return 1;
    }
    
    return 0;
}

static struct NCDModule modules[] = {
    {
        .type = "sys.connect",
        .base_type = "sys.socket",
        .func_new2 = connect_func_new,
        .func_die = connect_func_die,
        .func_getvar2 = connect_func_getvar,
        .alloc_size = sizeof(struct connection)
    }, {
        .type = "sys.socket::read",
        .func_new2 = read_func_new,
        .func_die = read_func_die,
        .func_getvar2 = read_func_getvar,
        .alloc_size = sizeof(struct read_instance)
    }, {
        .type = "sys.socket::write",
        .func_new2 = write_func_new,
        .func_die = write_func_die,
        .alloc_size = sizeof(struct write_instance)
    }, {
        .type = "sys.socket::close",
        .func_new2 = close_func_new
    }, {
        .type = "sys.listen",
        .func_new2 = listen_func_new,
        .func_die = listen_func_die,
        .func_getvar2 = listen_func_getvar,
        .alloc_size = sizeof(struct listen_instance)
    }, {
        .type = NULL
    }
};

const struct NCDModuleGroup ncdmodule_socket = {
    .modules = modules,
    .strings = strings
};