1 files changed, 336 insertions, 0 deletions
diff --git a/usr.sbin/bluetooth/btpand/channel.c b/usr.sbin/bluetooth/btpand/channel.c
new file mode 100644
index 000000000000..960b1ae30152
--- /dev/null
+++ b/usr.sbin/bluetooth/btpand/channel.c
@@ -0,0 +1,336 @@
+/*	$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);
+	}
+}