/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) NGINX, Inc.
 */

#include <nxt_main.h>


nxt_conn_io_t  nxt_unix_conn_io = {
    nxt_conn_io_connect,
    nxt_conn_io_accept,

    nxt_conn_io_read,
    nxt_conn_io_recvbuf,
    nxt_conn_io_recv,

    nxt_conn_io_write,
    nxt_event_conn_io_write_chunk,

#if (NXT_HAVE_LINUX_SENDFILE)
    nxt_linux_event_conn_io_sendfile,
#elif (NXT_HAVE_FREEBSD_SENDFILE)
    nxt_freebsd_event_conn_io_sendfile,
#elif (NXT_HAVE_MACOSX_SENDFILE)
    nxt_macosx_event_conn_io_sendfile,
#elif (NXT_HAVE_SOLARIS_SENDFILEV)
    nxt_solaris_event_conn_io_sendfilev,
#elif (NXT_HAVE_AIX_SEND_FILE)
    nxt_aix_event_conn_io_send_file,
#elif (NXT_HAVE_HPUX_SENDFILE)
    nxt_hpux_event_conn_io_sendfile,
#else
    nxt_event_conn_io_sendbuf,
#endif

    nxt_event_conn_io_writev,
    nxt_event_conn_io_send,

    nxt_conn_io_shutdown,
};


nxt_conn_t *
nxt_conn_create(nxt_mp_t *mp, nxt_task_t *task)
{
    nxt_conn_t    *c;
    nxt_thread_t  *thr;

    c = nxt_mp_zget(mp, sizeof(nxt_conn_t));
    if (nxt_slow_path(c == NULL)) {
        return NULL;
    }

    c->mem_pool = mp;

    c->socket.fd = -1;

    c->socket.log = &c->log;
    c->log = *task->log;

    /* The while loop skips possible uint32_t overflow. */

    while (c->log.ident == 0) {
        c->log.ident = nxt_task_next_ident();
    }

    thr = nxt_thread();
    thr->engine->connections++;

    c->task.thread = thr;
    c->task.log = &c->log;
    c->task.ident = c->log.ident;
    c->socket.task = &c->task;
    c->read_timer.task = &c->task;
    c->write_timer.task = &c->task;

    c->io = thr->engine->event.io;
    c->max_chunk = NXT_INT32_T_MAX;
    c->sendfile = NXT_CONN_SENDFILE_UNSET;

    c->socket.read_work_queue = &thr->engine->fast_work_queue;
    c->socket.write_work_queue = &thr->engine->fast_work_queue;

    nxt_conn_timer_init(&c->read_timer, c, c->socket.read_work_queue);
    nxt_conn_timer_init(&c->write_timer, c, c->socket.write_work_queue);

    nxt_log_debug(&c->log, "connections: %uD", thr->engine->connections);

    return c;
}


void
nxt_conn_free(nxt_task_t *task, nxt_conn_t *c)
{
    nxt_mp_t  *mp;

    task->thread->engine->connections--;

    mp = c->mem_pool;
    nxt_mp_free(mp, c);
    nxt_mp_release(mp);
}


void
nxt_conn_io_shutdown(nxt_task_t *task, void *obj, void *data)
{
    int         ret;
    nxt_conn_t  *c;

    static const struct linger  linger_off = {
        .l_onoff = 1,
        .l_linger = 0,
    };

    c = obj;

    nxt_debug(task, "event conn shutdown");

    if (c->socket.timedout) {
        /*
         * Resetting of timed out connection on close
         * releases kernel memory associated with socket.
         * This also causes sending TCP/IP RST to a peer.
         */
        ret = setsockopt(c->socket.fd, SOL_SOCKET, SO_LINGER, &linger_off,
                         sizeof(struct linger));

        if (nxt_slow_path(ret != 0)) {
            nxt_alert(task, "setsockopt(%d, SO_LINGER) failed %E",
                      c->socket.fd, nxt_socket_errno);
        }
    }

    c->write_state->close_handler(task, c, data);
}


void
nxt_conn_timer(nxt_event_engine_t *engine, nxt_conn_t *c,
    const nxt_conn_state_t *state, nxt_timer_t *timer)
{
    nxt_msec_t  value;

    if (state->timer_value != NULL) {
        value = state->timer_value(c, state->timer_data);

        if (value != 0) {
            timer->handler = state->timer_handler;
            nxt_timer_add(engine, timer, value);
        }
    }
}


void
nxt_conn_work_queue_set(nxt_conn_t *c, nxt_work_queue_t *wq)
{
    c->read_work_queue = wq;
    c->write_work_queue = wq;
    c->read_timer.work_queue = wq;
    c->write_timer.work_queue = wq;
}


nxt_sockaddr_t *
nxt_conn_local_addr(nxt_task_t *task, nxt_conn_t *c)
{
    int             ret;
    size_t          size, length;
    socklen_t       socklen;
    nxt_sockaddr_t  *sa;

    if (c->local != NULL) {
        return c->local;
    }

    /* AF_UNIX should not get in here. */

    switch (c->remote->u.sockaddr.sa_family) {
#if (NXT_INET6)
    case AF_INET6:
        socklen = sizeof(struct sockaddr_in6);
        length = NXT_INET6_ADDR_STR_LEN;
        size = offsetof(nxt_sockaddr_t, u) + socklen + length;
        break;
#endif
    case AF_INET:
    default:
        socklen = sizeof(struct sockaddr_in);
        length = NXT_INET_ADDR_STR_LEN;
        size = offsetof(nxt_sockaddr_t, u) + socklen + length;
        break;
    }

    sa = nxt_mp_get(c->mem_pool, size);
    if (nxt_slow_path(sa == NULL)) {
        return NULL;
    }

    sa->socklen = socklen;
    sa->length = length;

    ret = getsockname(c->socket.fd, &sa->u.sockaddr, &socklen);
    if (nxt_slow_path(ret != 0)) {
        nxt_alert(task, "getsockname(%d) failed", c->socket.fd);
        return NULL;
    }

    c->local = sa;

    nxt_sockaddr_text(sa);

    /*
     * TODO: here we can adjust the end of non-freeable block
     * in c->mem_pool to the end of actual sockaddr length.
     */

    return sa;
}