[mirror_frr.git] / ldpd / accept.c

/*	$OpenBSD$ */

/*
 * Copyright (c) 2012 Claudio Jeker <claudio@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <zebra.h>

#include "ldpd.h"
#include "ldpe.h"
#include "log.h"

struct accept_ev {
	LIST_ENTRY(accept_ev)	 entry;
	struct thread		*ev;
	int			(*accept_cb)(struct thread *);
	void			*arg;
	int			 fd;
};

struct {
	LIST_HEAD(, accept_ev)	 queue;
	struct thread		*evt;
} accept_queue;

static void	accept_arm(void);
static void	accept_unarm(void);
static int	accept_cb(struct thread *);
static int	accept_timeout(struct thread *);

void
accept_init(void)
{
	LIST_INIT(&accept_queue.queue);
}

int
accept_add(int fd, int (*cb)(struct thread *), void *arg)
{
	struct accept_ev	*av;

	if ((av = calloc(1, sizeof(*av))) == NULL)
		return (-1);
	av->fd = fd;
	av->accept_cb = cb;
	av->arg = arg;
	LIST_INSERT_HEAD(&accept_queue.queue, av, entry);

	av->ev = thread_add_read(master, accept_cb, av, av->fd);

	log_debug("%s: accepting on fd %d", __func__, fd);

	return (0);
}

void
accept_del(int fd)
{
	struct accept_ev	*av;

	LIST_FOREACH(av, &accept_queue.queue, entry)
		if (av->fd == fd) {
			log_debug("%s: %d removed from queue", __func__, fd);
			THREAD_READ_OFF(av->ev);
			LIST_REMOVE(av, entry);
			free(av);
			return;
		}
}

void
accept_pause(void)
{
	log_debug(__func__);
	accept_unarm();
	accept_queue.evt = thread_add_timer(master, accept_timeout, NULL, 1);
}

void
accept_unpause(void)
{
	if (accept_queue.evt != NULL) {
		log_debug(__func__);
		THREAD_TIMER_OFF(accept_queue.evt);
		accept_arm();
	}
}

static void
accept_arm(void)
{
	struct accept_ev	*av;
	LIST_FOREACH(av, &accept_queue.queue, entry)
		av->ev = thread_add_read(master, accept_cb, av, av->fd);
}

static void
accept_unarm(void)
{
	struct accept_ev	*av;
	LIST_FOREACH(av, &accept_queue.queue, entry)
		THREAD_READ_OFF(av->ev);
}

static int
accept_cb(struct thread *thread)
{
	struct accept_ev	*av = THREAD_ARG(thread);
	av->ev = thread_add_read(master, accept_cb, av, av->fd);
	av->accept_cb(thread);

	return (0);
}

static int
accept_timeout(struct thread *thread)
{
	accept_queue.evt = NULL;

	log_debug(__func__);
	accept_arm();

	return (0);
}
Commit	Line	Data
8429abe0 RW	1	/* $OpenBSD$ */
	2
	3	/*
	4	* Copyright (c) 2012 Claudio Jeker <claudio@openbsd.org>
	5	*
	6	* Permission to use, copy, modify, and distribute this software for any
	7	* purpose with or without fee is hereby granted, provided that the above
	8	* copyright notice and this permission notice appear in all copies.
	9	*
	10	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	11	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	12	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	13	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	14	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	15	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	17	*/
	18
eac6e3f0	19	#include <zebra.h>
8429abe0 RW	20
	21	#include "ldpd.h"
	22	#include "ldpe.h"
	23	#include "log.h"
	24
	25	struct accept_ev {
	26	LIST_ENTRY(accept_ev) entry;
eac6e3f0 RW	27	struct thread *ev;
eac6e3f0 RW	28	int (accept_cb)(struct thread );
8429abe0 RW	29	void *arg;
	30	int fd;
	31	};
	32
	33	struct {
eac6e3f0 RW	34	LIST_HEAD(, accept_ev) queue;
eac6e3f0 RW	35	struct thread *evt;
8429abe0 RW	36	} accept_queue;
	37
	38	static void accept_arm(void);
	39	static void accept_unarm(void);
eac6e3f0 RW	40	static int accept_cb(struct thread *);
eac6e3f0 RW	41	static int accept_timeout(struct thread *);
8429abe0 RW	42
	43	void
	44	accept_init(void)
	45	{
	46	LIST_INIT(&accept_queue.queue);
8429abe0 RW	47	}
	48
	49	int
eac6e3f0	50	accept_add(int fd, int (cb)(struct thread ), void *arg)
8429abe0 RW	51	{
	52	struct accept_ev *av;
	53
	54	if ((av = calloc(1, sizeof(*av))) == NULL)
	55	return (-1);
	56	av->fd = fd;
	57	av->accept_cb = cb;
	58	av->arg = arg;
	59	LIST_INSERT_HEAD(&accept_queue.queue, av, entry);
	60
eac6e3f0	61	av->ev = thread_add_read(master, accept_cb, av, av->fd);
8429abe0 RW	62
	63	log_debug("%s: accepting on fd %d", __func__, fd);
	64
	65	return (0);
	66	}
	67
	68	void
	69	accept_del(int fd)
	70	{
	71	struct accept_ev *av;
	72
	73	LIST_FOREACH(av, &accept_queue.queue, entry)
	74	if (av->fd == fd) {
	75	log_debug("%s: %d removed from queue", __func__, fd);
eac6e3f0	76	THREAD_READ_OFF(av->ev);
8429abe0 RW	77	LIST_REMOVE(av, entry);
	78	free(av);
	79	return;
	80	}
	81	}
	82
	83	void
	84	accept_pause(void)
	85	{
8429abe0 RW	86	log_debug(__func__);
8429abe0 RW	87	accept_unarm();
eac6e3f0	88	accept_queue.evt = thread_add_timer(master, accept_timeout, NULL, 1);
8429abe0 RW	89	}
	90
	91	void
	92	accept_unpause(void)
	93	{
eac6e3f0	94	if (accept_queue.evt != NULL) {
8429abe0	95	log_debug(__func__);
eac6e3f0	96	THREAD_TIMER_OFF(accept_queue.evt);
8429abe0 RW	97	accept_arm();
	98	}
	99	}
	100
	101	static void
	102	accept_arm(void)
	103	{
	104	struct accept_ev *av;
	105	LIST_FOREACH(av, &accept_queue.queue, entry)
eac6e3f0	106	av->ev = thread_add_read(master, accept_cb, av, av->fd);
8429abe0 RW	107	}
	108
	109	static void
	110	accept_unarm(void)
	111	{
	112	struct accept_ev *av;
	113	LIST_FOREACH(av, &accept_queue.queue, entry)
eac6e3f0	114	THREAD_READ_OFF(av->ev);
8429abe0 RW	115	}
8429abe0 RW	116
eac6e3f0 RW	117	static int
eac6e3f0 RW	118	accept_cb(struct thread *thread)
8429abe0	119	{
eac6e3f0 RW	120	struct accept_ev *av = THREAD_ARG(thread);
	121	av->ev = thread_add_read(master, accept_cb, av, av->fd);
	122	av->accept_cb(thread);
	123
	124	return (0);
8429abe0 RW	125	}
8429abe0 RW	126
eac6e3f0 RW	127	static int
eac6e3f0 RW	128	accept_timeout(struct thread *thread)
8429abe0	129	{
eac6e3f0 RW	130	accept_queue.evt = NULL;
eac6e3f0 RW	131
8429abe0 RW	132	log_debug(__func__);
8429abe0 RW	133	accept_arm();
eac6e3f0 RW	134
eac6e3f0 RW	135	return (0);
8429abe0	136	}