/*      $NetBSD: channel.c,v 1.1 2008/08/17 13:20:57 plunky Exp $       */

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2008 Iain Hibbert
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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.
 */


#include <sys/cdefs.h>
__RCSID("$NetBSD: channel.c,v 1.1 2008/08/17 13:20:57 plunky Exp $");

#include <sys/param.h>
#include <sys/ioctl.h>

#include <libutil.h>
#include <unistd.h>
#define L2CAP_SOCKET_CHECKED
#include "btpand.h"

static struct chlist    channel_list;
static int              channel_count;
static int              channel_tick;

static void channel_start(int, short, void *);
static void channel_read(int, short, void *);
static void channel_dispatch(packet_t *);
static void channel_watchdog(int, short, void *);

void
channel_init(void)
{

        LIST_INIT(&channel_list);
}

channel_t *
channel_alloc(void)
{
        channel_t *chan;

        chan = malloc(sizeof(channel_t));
        if (chan == NULL) {
                log_err("%s() failed: %m", __func__);
                return NULL;
        }

        memset(chan, 0, sizeof(channel_t));
        STAILQ_INIT(&chan->pktlist);
        chan->state = CHANNEL_CLOSED;
        LIST_INSERT_HEAD(&channel_list, chan, next);

        server_update(++channel_count);

        return chan;
}

bool
channel_open(channel_t *chan, int fd)
{
        int n;

        assert(chan->refcnt == 0);
        assert(chan->state != CHANNEL_CLOSED);

        if (chan->mtu > 0) {
                chan->sendbuf = malloc(chan->mtu);
                if (chan->sendbuf == NULL) {
                        log_err("Could not malloc channel sendbuf: %m");
                        return false;
                }
        }

        n = 1;
        if (ioctl(fd, FIONBIO, &n) == -1) {
                log_err("Could not set non-blocking IO: %m");
                return false;
        }

        event_set(&chan->rd_ev, fd, EV_READ | EV_PERSIST, channel_read, chan);
        if (event_add(&chan->rd_ev, NULL) == -1) {
                log_err("Could not add channel read event: %m");
                return false;
        }

        event_set(&chan->wr_ev, fd, EV_WRITE, channel_start, chan);

        chan->refcnt++;
        chan->fd = fd;

        log_debug("(fd#%d)", chan->fd);

        return true;
}

void
channel_close(channel_t *chan)
{
        pkthdr_t *ph;

        assert(chan->state != CHANNEL_CLOSED);

        log_debug("(fd#%d)", chan->fd);

        chan->state = CHANNEL_CLOSED;
        event_del(&chan->rd_ev);
        event_del(&chan->wr_ev);
        close(chan->fd);
        chan->refcnt--;
        chan->tick = 0;

        while ((ph = STAILQ_FIRST(&chan->pktlist)) != NULL) {
                STAILQ_REMOVE_HEAD(&chan->pktlist, next);
                pkthdr_free(ph);
                chan->qlen--;
        }

        if (chan->pfh != NULL) {
                pidfile_remove(chan->pfh);
                chan->pfh = NULL;
        }

        if (chan->refcnt == 0)
                channel_free(chan);
}

void
channel_free(channel_t *chan)
{

        assert(chan->refcnt == 0);
        assert(chan->state == CHANNEL_CLOSED);
        assert(chan->qlen == 0);
        assert(STAILQ_EMPTY(&chan->pktlist));

        LIST_REMOVE(chan, next);
        free(chan->pfilter);
        free(chan->mfilter);
        free(chan->sendbuf);
        free(chan);

        server_update(--channel_count);

        if (server_limit == 0) {
                log_info("connection closed, exiting");
                exit(EXIT_SUCCESS);
        }
}

static void
channel_start(int fd, short ev, void *arg)
{
        channel_t *chan = arg;
        pkthdr_t *ph;

        chan->oactive = true;

        while (chan->qlen > 0) {
                ph = STAILQ_FIRST(&chan->pktlist);

                channel_timeout(chan, 10);
                if (chan->send(chan, ph->data) == false) {
                        if (event_add(&chan->wr_ev, NULL) == -1) {
                                log_err("Could not add channel write event: %m");
                                channel_close(chan);
                        }
                        return;
                }

                STAILQ_REMOVE_HEAD(&chan->pktlist, next);
                pkthdr_free(ph);
                chan->qlen--;
        }

        channel_timeout(chan, 0);
        chan->oactive = false;
}

static void
channel_read(int fd, short ev, void *arg)
{
        channel_t *chan = arg;
        packet_t *pkt;
        ssize_t nr;

        pkt = packet_alloc(chan);
        if (pkt == NULL) {
                channel_close(chan);
                return;
        }

        nr = read(fd, pkt->buf, chan->mru);
        if (nr == -1) {
                log_err("channel read error: %m");
                packet_free(pkt);
                channel_close(chan);
                return;
        }
        if (nr == 0) {  /* EOF */
                log_debug("(fd#%d) EOF", fd);
                packet_free(pkt);
                channel_close(chan);
                return;
        }
        pkt->len = nr;

        if (chan->recv(pkt) == true)
                channel_dispatch(pkt);

        packet_free(pkt);
}

static void
channel_dispatch(packet_t *pkt)
{
        channel_t *chan;

        /*
         * This is simple routing. I'm not sure if its allowed by
         * the PAN or BNEP specifications, but it seems logical
         * to send unicast packets to connected destinations where
         * possible.
         */
        if (!ETHER_IS_MULTICAST(pkt->dst)) {
                LIST_FOREACH(chan, &channel_list, next) {
                        if (chan == pkt->chan
                            || chan->state != CHANNEL_OPEN)
                                continue;

                        if (memcmp(pkt->dst, chan->raddr, ETHER_ADDR_LEN) == 0) {
                                if (chan->qlen > CHANNEL_MAXQLEN)
                                        log_notice("Queue overflow");
                                else
                                        channel_put(chan, pkt);

                                return;
                        }
                }
        }

        LIST_FOREACH(chan, &channel_list, next) {
                if (chan == pkt->chan
                    || chan->state != CHANNEL_OPEN)
                        continue;

                if (chan->qlen > CHANNEL_MAXQLEN) {
                        log_notice("Queue overflow");
                        continue;
                }

                channel_put(chan, pkt);
        }
}

void
channel_put(channel_t *chan, packet_t *pkt)
{
        pkthdr_t *ph;

        ph = pkthdr_alloc(pkt);
        if (ph == NULL)
                return;

        chan->qlen++;
        STAILQ_INSERT_TAIL(&chan->pktlist, ph, next);

        if (!chan->oactive)
                channel_start(chan->fd, EV_WRITE, chan);
}

/*
 * Simple watchdog timer, only ticks when it is required and
 * closes the channel down if it times out.
 */
void
channel_timeout(channel_t *chan, int to)
{
        static struct event ev;

        if (to == 0)
                chan->tick = 0;
        else
                chan->tick = (channel_tick + to) % 60;

        if (channel_tick == 0) {
                evtimer_set(&ev, channel_watchdog, &ev);
                channel_watchdog(0, 0, &ev);
        }
}

static void
channel_watchdog(int fd, short ev, void *arg)
{
        static struct timeval tv = { .tv_sec = 1 };
        channel_t *chan, *next;
        int tick;

        tick = (channel_tick % 60) + 1;
        channel_tick = 0;

        next = LIST_FIRST(&channel_list);
        while ((chan = next) != NULL) {
                next = LIST_NEXT(chan, next);

                if (chan->tick == tick)
                        channel_close(chan);
                else if (chan->tick != 0)
                        channel_tick = tick;
        }

        if (channel_tick != 0 && evtimer_add(arg, &tv) < 0) {
                log_err("Could not add watchdog event: %m");
                exit(EXIT_FAILURE);
        }
}