/*
 * sel.c: implementation of sel.h.
 */

#include <stddef.h>
#include <string.h>
#include <errno.h>
#include <assert.h>

#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>

#include "sel.h"
#include "malloc.h"

/* ----------------------------------------------------------------------
 * Chunk of code lifted from PuTTY's misc.c to manage buffers of
 * data to be written to an fd.
 */

#define BUFFER_GRANULE  512

typedef struct bufchain_tag {
    struct bufchain_granule *head, *tail;
    size_t buffersize;                 /* current amount of buffered data */
} bufchain;
struct bufchain_granule {
    struct bufchain_granule *next;
    size_t buflen, bufpos;
    char buf[BUFFER_GRANULE];
};

static void bufchain_init(bufchain *ch)
{
    ch->head = ch->tail = NULL;
    ch->buffersize = 0;
}

static void bufchain_clear(bufchain *ch)
{
    struct bufchain_granule *b;
    while (ch->head) {
        b = ch->head;
        ch->head = ch->head->next;
        sfree(b);
    }
    ch->tail = NULL;
    ch->buffersize = 0;
}

static size_t bufchain_size(bufchain *ch)
{
    return ch->buffersize;
}

static void bufchain_add(bufchain *ch, const void *data, size_t len)
{
    const char *buf = (const char *)data;

    if (len == 0) return;

    ch->buffersize += len;

    if (ch->tail && ch->tail->buflen < BUFFER_GRANULE) {
        size_t copylen = BUFFER_GRANULE - ch->tail->buflen;
        if (copylen > len)
            copylen = len;
        memcpy(ch->tail->buf + ch->tail->buflen, buf, copylen);
        buf += copylen;
        len -= copylen;
        ch->tail->buflen += copylen;
    }
    while (len > 0) {
        struct bufchain_granule *newbuf;
        size_t grainlen = BUFFER_GRANULE;
        if (grainlen > len)
            grainlen = len;
        newbuf = snew(struct bufchain_granule);
        newbuf->bufpos = 0;
        newbuf->buflen = grainlen;
        memcpy(newbuf->buf, buf, grainlen);
        buf += grainlen;
        len -= grainlen;
        if (ch->tail)
            ch->tail->next = newbuf;
        else
            ch->head = ch->tail = newbuf;
        newbuf->next = NULL;
        ch->tail = newbuf;
    }
}

static void bufchain_consume(bufchain *ch, size_t len)
{
    struct bufchain_granule *tmp;

    assert(ch->buffersize >= len);
    while (len > 0) {
        size_t remlen = len;
        assert(ch->head != NULL);
        if (remlen >= ch->head->buflen - ch->head->bufpos) {
            remlen = ch->head->buflen - ch->head->bufpos;
            tmp = ch->head;
            ch->head = tmp->next;
            sfree(tmp);
            if (!ch->head)
                ch->tail = NULL;
        } else
            ch->head->bufpos += remlen;
        ch->buffersize -= remlen;
        len -= remlen;
    }
}

static void bufchain_prefix(bufchain *ch, void **data, size_t *len)
{
    *len = ch->head->buflen - ch->head->bufpos;
    *data = ch->head->buf + ch->head->bufpos;
}

/* ----------------------------------------------------------------------
 * The actual implementation of the sel interface.
 */

struct sel {
    void *ctx;
    sel_rfd *rhead, *rtail;
    sel_wfd *whead, *wtail;
};

struct sel_rfd {
    sel *parent;
    sel_rfd *prev, *next;
    sel_readdata_fn_t readdata;
    sel_readerr_fn_t readerr;
    void *ctx;
    int fd;
    int frozen;
};

struct sel_wfd {
    sel *parent;
    sel_wfd *prev, *next;
    sel_written_fn_t written;
    sel_writeerr_fn_t writeerr;
    void *ctx;
    int fd;
    bufchain buf;
};

sel *sel_new(void *ctx)
{
    sel *sel = snew(struct sel);

    sel->ctx = ctx;
    sel->rhead = sel->rtail = NULL;
    sel->whead = sel->wtail = NULL;

    return sel;
}

sel_wfd *sel_wfd_add(sel *sel, int fd,
                     sel_written_fn_t written, sel_writeerr_fn_t writeerr,
                     void *ctx)
{
    sel_wfd *wfd = snew(sel_wfd);

    wfd->written = written;
    wfd->writeerr = writeerr;
    wfd->ctx = ctx;
    wfd->fd = fd;
    bufchain_init(&wfd->buf);

    wfd->next = NULL;
    wfd->prev = sel->wtail;
    if (sel->wtail)
        sel->wtail->next = wfd;
    else
        sel->whead = wfd;
    sel->wtail = wfd;
    wfd->parent = sel;

    return wfd;
}

sel_rfd *sel_rfd_add(sel *sel, int fd,
                     sel_readdata_fn_t readdata, sel_readerr_fn_t readerr,
                     void *ctx)
{
    sel_rfd *rfd = snew(sel_rfd);

    rfd->readdata = readdata;
    rfd->readerr = readerr;
    rfd->ctx = ctx;
    rfd->fd = fd;
    rfd->frozen = 0;

    rfd->next = NULL;
    rfd->prev = sel->rtail;
    if (sel->rtail)
        sel->rtail->next = rfd;
    else
        sel->rhead = rfd;
    sel->rtail = rfd;
    rfd->parent = sel;

    return rfd;
}

size_t sel_write(sel_wfd *wfd, const void *data, size_t len)
{
    bufchain_add(&wfd->buf, data, len);
    return bufchain_size(&wfd->buf);
}

void sel_wfd_setfd(sel_wfd *wfd, int fd)
{
    wfd->fd = fd;
}

void sel_rfd_setfd(sel_rfd *rfd, int fd)
{
    rfd->fd = fd;
}

void sel_rfd_freeze(sel_rfd *rfd)
{
    rfd->frozen = 1;
}

void sel_rfd_unfreeze(sel_rfd *rfd)
{
    rfd->frozen = 0;
}

int sel_wfd_delete(sel_wfd *wfd)
{
    sel *sel = wfd->parent;
    int ret;

    if (wfd->prev)
        wfd->prev->next = wfd->next;
    else
        sel->whead = wfd->next;
    if (wfd->next)
        wfd->next->prev = wfd->prev;
    else
        sel->wtail = wfd->prev;

    bufchain_clear(&wfd->buf);

    ret = wfd->fd;
    sfree(wfd);
    return ret;
}

int sel_rfd_delete(sel_rfd *rfd)
{
    sel *sel = rfd->parent;
    int ret;

    if (rfd->prev)
        rfd->prev->next = rfd->next;
    else
        sel->rhead = rfd->next;
    if (rfd->next)
        rfd->next->prev = rfd->prev;
    else
        sel->rtail = rfd->prev;

    ret = rfd->fd;
    sfree(rfd);
    return ret;
}

void sel_free(sel *sel)
{
    while (sel->whead)
        sel_wfd_delete(sel->whead);
    while (sel->rhead)
        sel_rfd_delete(sel->rhead);
    sfree(sel);
}

void *sel_get_ctx(sel *sel) { return sel->ctx; }
void sel_set_ctx(sel *sel, void *ctx) { sel->ctx = ctx; }
void *sel_wfd_get_ctx(sel_wfd *wfd) { return wfd->ctx; }
void sel_wfd_set_ctx(sel_wfd *wfd, void *ctx) { wfd->ctx = ctx; }
void *sel_rfd_get_ctx(sel_rfd *rfd) { return rfd->ctx; }
void sel_rfd_set_ctx(sel_rfd *rfd, void *ctx) { rfd->ctx = ctx; }

int sel_iterate(sel *sel, long timeout)
{
    sel_rfd *rfd;
    sel_wfd *wfd;
    fd_set rset, wset;
    int maxfd = 0;
    struct timeval tv, *ptv;
    char buf[65536];
    int ret;

    FD_ZERO(&rset);
    FD_ZERO(&wset);

    for (rfd = sel->rhead; rfd; rfd = rfd->next) {
        if (rfd->fd >= 0 && !rfd->frozen) {
            FD_SET(rfd->fd, &rset);
            if (maxfd < rfd->fd + 1)
                maxfd = rfd->fd + 1;
        }
    }

    for (wfd = sel->whead; wfd; wfd = wfd->next) {
        if (wfd->fd >= 0 && bufchain_size(&wfd->buf)) {
            FD_SET(wfd->fd, &wset);
            if (maxfd < wfd->fd + 1)
                maxfd = wfd->fd + 1;
        }
    }

    if (timeout < 0) {
        ptv = NULL;
    } else {
        ptv = &tv;
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = 1000 * (timeout % 1000);
    }

    do {
        ret = select(maxfd, &rset, &wset, NULL, ptv);
    } while (ret < 0 && (errno == EINTR || errno == EAGAIN));

    if (ret < 0)
        return errno;

    /*
     * Just in case one of the callbacks destroys an rfd or wfd we
     * had yet to get round to, we must loop from the start every
     * single time. Algorithmically irritating, but necessary
     * unless we want to store the rfd structures in a heavyweight
     * tree sorted by fd. And let's face it, if we cared about
     * good algorithmic complexity it's not at all clear we'd be
     * using select in the first place.
     */
    do {
        for (wfd = sel->whead; wfd; wfd = wfd->next)
            if (wfd->fd >= 0 && FD_ISSET(wfd->fd, &wset)) {
                void *data;
                size_t len;

                FD_CLR(wfd->fd, &wset);
                bufchain_prefix(&wfd->buf, &data, &len);
                ret = write(wfd->fd, data, len);
                assert(ret != 0);
                if (ret < 0) {
                    if (wfd->writeerr)
                        wfd->writeerr(wfd, errno);
                } else {
                    bufchain_consume(&wfd->buf, len);
                    if (wfd->written)
                        wfd->written(wfd, bufchain_size(&wfd->buf));
                }
                break;
            }
    } while (wfd);
    do {
        for (rfd = sel->rhead; rfd; rfd = rfd->next)
            if (rfd->fd >= 0 && !rfd->frozen && FD_ISSET(rfd->fd, &rset)) {
                FD_CLR(rfd->fd, &rset);
                ret = read(rfd->fd, buf, sizeof(buf));
                if (ret < 0) {
                    if (rfd->readerr)
                        rfd->readerr(rfd, errno);
                } else {
                    if (rfd->readdata)
                        rfd->readdata(rfd, buf, ret);
                }
                break;
            }
    } while (rfd);

    return 0;
}
