eloop.c - chromiumos/third_party/dhcpcd - Git at Google

 /*
  * dhcpcd - DHCP client daemon
  * Copyright (c) 2006-2013 Roy Marples <roy@marples.name>
  * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
  */

 /* Needed for ppoll(2) */
 #define _GNU_SOURCE

 #include <sys/queue.h>
 #include <sys/time.h>

 #include <errno.h>
 #include <limits.h>
 #include <poll.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <syslog.h>

 #include "common.h"
 #include "dhcpcd.h"
 #include "eloop.h"

 static struct timeval now;

 struct event {
 	TAILQ_ENTRY(event) next;
 	int fd;
 	void (*callback)(void *);
 	void *arg;
 	struct pollfd *pollfd;
 };
 static size_t events_len;
 static TAILQ_HEAD (event_head, event) events = TAILQ_HEAD_INITIALIZER(events);
 static struct event_head free_events = TAILQ_HEAD_INITIALIZER(free_events);

 struct timeout {
 	TAILQ_ENTRY(timeout) next;
 	struct timeval when;
 	void (*callback)(void *);
 	void *arg;
 	int queue;
 };
 static TAILQ_HEAD (timeout_head, timeout) timeouts
     = TAILQ_HEAD_INITIALIZER(timeouts);
 static struct timeout_head free_timeouts
     = TAILQ_HEAD_INITIALIZER(free_timeouts);

 static void (*volatile timeout0)(void *);
 static void *volatile timeout0_arg;

 static struct pollfd *fds;
 static size_t fds_len;

 static void
 eloop_event_setup_fds(void)
 {
 	struct event *e;
 	size_t i;

 	i = 0;
 	TAILQ_FOREACH(e, &events, next) {
 		fds[i].fd = e->fd;
 		fds[i].events = POLLIN;
 		fds[i].revents = 0;
 		e->pollfd = &fds[i];
 		i++;
 	}
 }

 int
 eloop_event_add(int fd, void (*callback)(void *), void *arg)
 {
 	struct event *e;

 	/* We should only have one callback monitoring the fd */
 	TAILQ_FOREACH(e, &events, next) {
 		if (e->fd == fd) {
 			e->callback = callback;
 			e->arg = arg;
 			return 0;
 		}
 	}

 	/* Allocate a new event if no free ones already allocated */
 	if ((e = TAILQ_FIRST(&free_events))) {
 		TAILQ_REMOVE(&free_events, e, next);
 	} else {
 		e = malloc(sizeof(*e));
 		if (e == NULL) {
 			syslog(LOG_ERR, "%s: %m", __func__);
 			return -1;
 		}
 	}

 	/* Ensure we can actually listen to it */
 	events_len++;
 	if (events_len > fds_len) {
 		fds_len += 5;
 		free(fds);
 		fds = malloc(sizeof(*fds) * fds_len);
 		if (fds == NULL) {
 			syslog(LOG_ERR, "%s: %m", __func__);
 			free(e);
 			return -1;
 		}
 	}

 	/* Now populate the structure and add it to the list */
 	e->fd = fd;
 	e->callback = callback;
 	e->arg = arg;
 	/* The order of events should not matter.
 	 * However, some PPP servers love to close the link right after
 	 * sending their final message. So to ensure dhcpcd processes this
 	 * message (which is likely to be that the DHCP addresses are wrong)
 	 * we insert new events at the queue head as the link fd will be
 	 * the first event added. */
 	TAILQ_INSERT_HEAD(&events, e, next);
 	eloop_event_setup_fds();
 	return 0;
 }

 void
 eloop_event_delete(int fd)
 {
 	struct event *e;

 	TAILQ_FOREACH(e, &events, next) {
 		if (e->fd == fd) {
 			TAILQ_REMOVE(&events, e, next);
 			TAILQ_INSERT_TAIL(&free_events, e, next);
 			events_len--;
 			eloop_event_setup_fds();
 			break;
 		}
 	}
 }

 int
 eloop_q_timeout_add_tv(int queue,
     const struct timeval *when, void (*callback)(void *), void *arg)
 {
 	struct timeval w;
 	struct timeout *t, *tt = NULL;

 	get_monotonic(&now);
 	timeradd(&now, when, &w);
 	/* Check for time_t overflow. */
 	if (timercmp(&w, &now, <)) {
 		errno = ERANGE;
 		return -1;
 	}

 	/* Remove existing timeout if present */
 	TAILQ_FOREACH(t, &timeouts, next) {
 		if (t->callback == callback && t->arg == arg) {
 			TAILQ_REMOVE(&timeouts, t, next);
 			break;
 		}
 	}

 	if (t == NULL) {
 		/* No existing, so allocate or grab one from the free pool */
 		if ((t = TAILQ_FIRST(&free_timeouts))) {
 			TAILQ_REMOVE(&free_timeouts, t, next);
 		} else {
 			t = malloc(sizeof(*t));
 			if (t == NULL) {
 				syslog(LOG_ERR, "%s: %m", __func__);
 				return -1;
 			}
 		}
 	}

 	t->when.tv_sec = w.tv_sec;
 	t->when.tv_usec = w.tv_usec;
 	t->callback = callback;
 	t->arg = arg;
 	t->queue = queue;

 	/* The timeout list should be in chronological order,
 	 * soonest first. */
 	TAILQ_FOREACH(tt, &timeouts, next) {
 		if (timercmp(&t->when, &tt->when, <)) {
 			TAILQ_INSERT_BEFORE(tt, t, next);
 			return 0;
 		}
 	}
 	TAILQ_INSERT_TAIL(&timeouts, t, next);
 	return 0;
 }

 int
 eloop_q_timeout_add_sec(int queue, time_t when,
     void (*callback)(void *), void *arg)
 {
 	struct timeval tv;

 	tv.tv_sec = when;
 	tv.tv_usec = 0;
 	return eloop_q_timeout_add_tv(queue, &tv, callback, arg);
 }

 int
 eloop_timeout_add_now(void (*callback)(void *), void *arg)
 {

 	if (timeout0 != NULL) {
 		syslog(LOG_WARNING, "%s: timeout0 already set", __func__);
 		return eloop_q_timeout_add_sec(0, 0, callback, arg);
 	}

 	timeout0 = callback;
 	timeout0_arg = arg;
 	return 0;
 }

 /* This deletes all timeouts for the interface EXCEPT for ones with the
  * callbacks given. Handy for deleting everything apart from the expire
  * timeout. */
 static void
 eloop_q_timeouts_delete_v(int queue, void *arg,
     void (*callback)(void *), va_list v)
 {
 	struct timeout *t, *tt;
 	va_list va;
 	void (*f)(void *);

 	TAILQ_FOREACH_SAFE(t, &timeouts, next, tt) {
 		if ((queue == 0 || t->queue == queue) && t->arg == arg &&
 		    t->callback != callback)
 		{
 			va_copy(va, v);
 			while ((f = va_arg(va, void (*)(void *)))) {
 				if (f == t->callback)
 					break;
 			}
 			va_end(va);
 			if (f == NULL) {
 				TAILQ_REMOVE(&timeouts, t, next);
 				TAILQ_INSERT_TAIL(&free_timeouts, t, next);
 			}
 		}
 	}
 }

 void
 eloop_q_timeouts_delete(int queue, void *arg, void (*callback)(void *), ...)
 {
 	va_list va;

 	va_start(va, callback);
 	eloop_q_timeouts_delete_v(queue, arg, callback, va);
 	va_end(va);
 }

 void
 eloop_q_timeout_delete(int queue, void (*callback)(void *), void *arg)
 {
 	struct timeout *t, *tt;

 	TAILQ_FOREACH_SAFE(t, &timeouts, next, tt) {
 		if (t->queue == queue && t->arg == arg &&
 		    (!callback || t->callback == callback))
 		{
 			TAILQ_REMOVE(&timeouts, t, next);
 			TAILQ_INSERT_TAIL(&free_timeouts, t, next);
 		}
 	}
 }

 #ifdef DEBUG_MEMORY
 /* Define this to free all malloced memory.
  * Normally we don't do this as the OS will do it for us at exit,
  * but it's handy for debugging other leaks in valgrind. */
 static void
 eloop_cleanup(void)
 {
 	struct event *e;
 	struct timeout *t;

 	while ((e = TAILQ_FIRST(&events))) {
 		TAILQ_REMOVE(&events, e, next);
 		free(e);
 	}
 	while ((e = TAILQ_FIRST(&free_events))) {
 		TAILQ_REMOVE(&free_events, e, next);
 		free(e);
 	}
 	while ((t = TAILQ_FIRST(&timeouts))) {
 		TAILQ_REMOVE(&timeouts, t, next);
 		free(t);
 	}
 	while ((t = TAILQ_FIRST(&free_timeouts))) {
 		TAILQ_REMOVE(&free_timeouts, t, next);
 		free(t);
 	}
 	free(fds);
 }

 void
 eloop_init(void)
 {

 	atexit(eloop_cleanup);
 }
 #endif

 __dead void
 eloop_start(const sigset_t *sigmask)
 {
 	int n;
 	struct event *e;
 	struct timeout *t;
 	struct timeval tv;
 	struct timespec ts, *tsp;
 	void (*t0)(void *);

 	for (;;) {
 		/* Run all timeouts first */
 		if (timeout0) {
 			t0 = timeout0;
 			timeout0 = NULL;
 			t0(timeout0_arg);
 			continue;
 		}
 		if ((t = TAILQ_FIRST(&timeouts))) {
 			get_monotonic(&now);
 			if (timercmp(&now, &t->when, >)) {
 				TAILQ_REMOVE(&timeouts, t, next);
 				t->callback(t->arg);
 				TAILQ_INSERT_TAIL(&free_timeouts, t, next);
 				continue;
 			}
 			timersub(&t->when, &now, &tv);
 			TIMEVAL_TO_TIMESPEC(&tv, &ts);
 			tsp = &ts;
 		} else
 			/* No timeouts, so wait forever */
 			tsp = NULL;

 		if (tsp == NULL && events_len == 0) {
 			syslog(LOG_ERR, "nothing to do");
 			exit(EXIT_FAILURE);
 		}

 		n = pollts(fds, events_len, tsp, sigmask);
 		if (n == -1) {
 			if (errno == EAGAIN || errno == EINTR)
 				continue;
 			syslog(LOG_ERR, "poll: %m");
 			exit(EXIT_FAILURE);
 		}

 		/* Process any triggered events. */
 		if (n > 0) {
 			TAILQ_FOREACH(e, &events, next) {
 				if (e->pollfd->revents & (POLLIN | POLLHUP)) {
 					e->callback(e->arg);
 					/* We need to break here as the
 					 * callback could destroy the next
 					 * fd to process. */
 					break;
 				}
 			}
 		}
 	}
 }
	/*
	* dhcpcd - DHCP client daemon
	* Copyright (c) 2006-2013 Roy Marples <roy@marples.name>
	* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
	*/

	/* Needed for ppoll(2) */
	#define _GNU_SOURCE

	#include <sys/queue.h>
	#include <sys/time.h>

	#include <errno.h>
	#include <limits.h>
	#include <poll.h>
	#include <signal.h>
	#include <stdarg.h>
	#include <stdlib.h>
	#include <syslog.h>

	#include "common.h"
	#include "dhcpcd.h"
	#include "eloop.h"

	static struct timeval now;

	struct event {
	TAILQ_ENTRY(event) next;
	int fd;
	void (callback)(void );
	void *arg;
	struct pollfd *pollfd;
	};
	static size_t events_len;
	static TAILQ_HEAD (event_head, event) events = TAILQ_HEAD_INITIALIZER(events);
	static struct event_head free_events = TAILQ_HEAD_INITIALIZER(free_events);

	struct timeout {
	TAILQ_ENTRY(timeout) next;
	struct timeval when;
	void (callback)(void );
	void *arg;
	int queue;
	};
	static TAILQ_HEAD (timeout_head, timeout) timeouts
	= TAILQ_HEAD_INITIALIZER(timeouts);
	static struct timeout_head free_timeouts
	= TAILQ_HEAD_INITIALIZER(free_timeouts);

	static void (volatile timeout0)(void );
	static void *volatile timeout0_arg;

	static struct pollfd *fds;
	static size_t fds_len;

	static void
	eloop_event_setup_fds(void)
	{
	struct event *e;
	size_t i;

	i = 0;
	TAILQ_FOREACH(e, &events, next) {
	fds[i].fd = e->fd;
	fds[i].events = POLLIN;
	fds[i].revents = 0;
	e->pollfd = &fds[i];
	i++;
	}
	}

	int
	eloop_event_add(int fd, void (callback)(void ), void *arg)
	{
	struct event *e;

	/* We should only have one callback monitoring the fd */
	TAILQ_FOREACH(e, &events, next) {
	if (e->fd == fd) {
	e->callback = callback;
	e->arg = arg;
	return 0;
	}
	}

	/* Allocate a new event if no free ones already allocated */
	if ((e = TAILQ_FIRST(&free_events))) {
	TAILQ_REMOVE(&free_events, e, next);
	} else {
	e = malloc(sizeof(*e));
	if (e == NULL) {
	syslog(LOG_ERR, "%s: %m", __func__);
	return -1;
	}
	}

	/* Ensure we can actually listen to it */
	events_len++;
	if (events_len > fds_len) {
	fds_len += 5;
	free(fds);
	fds = malloc(sizeof(fds) fds_len);
	if (fds == NULL) {
	syslog(LOG_ERR, "%s: %m", __func__);
	free(e);
	return -1;
	}
	}

	/* Now populate the structure and add it to the list */
	e->fd = fd;
	e->callback = callback;
	e->arg = arg;
	/* The order of events should not matter.
	* However, some PPP servers love to close the link right after
	* sending their final message. So to ensure dhcpcd processes this
	* message (which is likely to be that the DHCP addresses are wrong)
	* we insert new events at the queue head as the link fd will be
	* the first event added. */
	TAILQ_INSERT_HEAD(&events, e, next);
	eloop_event_setup_fds();
	return 0;
	}

	void
	eloop_event_delete(int fd)
	{
	struct event *e;

	TAILQ_FOREACH(e, &events, next) {
	if (e->fd == fd) {
	TAILQ_REMOVE(&events, e, next);
	TAILQ_INSERT_TAIL(&free_events, e, next);
	events_len--;
	eloop_event_setup_fds();
	break;
	}
	}
	}

	int
	eloop_q_timeout_add_tv(int queue,
	const struct timeval when, void (callback)(void ), void arg)
	{
	struct timeval w;
	struct timeout t, tt = NULL;

	get_monotonic(&now);
	timeradd(&now, when, &w);
	/* Check for time_t overflow. */
	if (timercmp(&w, &now, <)) {
	errno = ERANGE;
	return -1;
	}

	/* Remove existing timeout if present */
	TAILQ_FOREACH(t, &timeouts, next) {
	if (t->callback == callback && t->arg == arg) {
	TAILQ_REMOVE(&timeouts, t, next);
	break;
	}
	}

	if (t == NULL) {
	/* No existing, so allocate or grab one from the free pool */
	if ((t = TAILQ_FIRST(&free_timeouts))) {
	TAILQ_REMOVE(&free_timeouts, t, next);
	} else {
	t = malloc(sizeof(*t));
	if (t == NULL) {
	syslog(LOG_ERR, "%s: %m", __func__);
	return -1;
	}
	}
	}

	t->when.tv_sec = w.tv_sec;
	t->when.tv_usec = w.tv_usec;
	t->callback = callback;
	t->arg = arg;
	t->queue = queue;

	/* The timeout list should be in chronological order,
	* soonest first. */
	TAILQ_FOREACH(tt, &timeouts, next) {
	if (timercmp(&t->when, &tt->when, <)) {
	TAILQ_INSERT_BEFORE(tt, t, next);
	return 0;
	}
	}
	TAILQ_INSERT_TAIL(&timeouts, t, next);
	return 0;
	}

	int
	eloop_q_timeout_add_sec(int queue, time_t when,
	void (callback)(void ), void *arg)
	{
	struct timeval tv;

	tv.tv_sec = when;
	tv.tv_usec = 0;
	return eloop_q_timeout_add_tv(queue, &tv, callback, arg);
	}

	int
	eloop_timeout_add_now(void (callback)(void ), void *arg)
	{

	if (timeout0 != NULL) {
	syslog(LOG_WARNING, "%s: timeout0 already set", __func__);
	return eloop_q_timeout_add_sec(0, 0, callback, arg);
	}

	timeout0 = callback;
	timeout0_arg = arg;
	return 0;
	}

	/* This deletes all timeouts for the interface EXCEPT for ones with the
	* callbacks given. Handy for deleting everything apart from the expire
	* timeout. */
	static void
	eloop_q_timeouts_delete_v(int queue, void *arg,
	void (callback)(void ), va_list v)
	{
	struct timeout t, tt;
	va_list va;
	void (f)(void );

	TAILQ_FOREACH_SAFE(t, &timeouts, next, tt) {
	if ((queue == 0 \|\| t->queue == queue) && t->arg == arg &&
	t->callback != callback)
	{
	va_copy(va, v);
	while ((f = va_arg(va, void ()(void )))) {
	if (f == t->callback)
	break;
	}
	va_end(va);
	if (f == NULL) {
	TAILQ_REMOVE(&timeouts, t, next);
	TAILQ_INSERT_TAIL(&free_timeouts, t, next);
	}
	}
	}
	}

	void
	eloop_q_timeouts_delete(int queue, void arg, void (callback)(void *), ...)
	{
	va_list va;

	va_start(va, callback);
	eloop_q_timeouts_delete_v(queue, arg, callback, va);
	va_end(va);
	}

	void
	eloop_q_timeout_delete(int queue, void (callback)(void ), void *arg)
	{
	struct timeout t, tt;

	TAILQ_FOREACH_SAFE(t, &timeouts, next, tt) {
	if (t->queue == queue && t->arg == arg &&
	(!callback \|\| t->callback == callback))
	{
	TAILQ_REMOVE(&timeouts, t, next);
	TAILQ_INSERT_TAIL(&free_timeouts, t, next);
	}
	}
	}

	#ifdef DEBUG_MEMORY
	/* Define this to free all malloced memory.
	* Normally we don't do this as the OS will do it for us at exit,
	* but it's handy for debugging other leaks in valgrind. */
	static void
	eloop_cleanup(void)
	{
	struct event *e;
	struct timeout *t;

	while ((e = TAILQ_FIRST(&events))) {
	TAILQ_REMOVE(&events, e, next);
	free(e);
	}
	while ((e = TAILQ_FIRST(&free_events))) {
	TAILQ_REMOVE(&free_events, e, next);
	free(e);
	}
	while ((t = TAILQ_FIRST(&timeouts))) {
	TAILQ_REMOVE(&timeouts, t, next);
	free(t);
	}
	while ((t = TAILQ_FIRST(&free_timeouts))) {
	TAILQ_REMOVE(&free_timeouts, t, next);
	free(t);
	}
	free(fds);
	}

	void
	eloop_init(void)
	{

	atexit(eloop_cleanup);
	}
	#endif

	__dead void
	eloop_start(const sigset_t *sigmask)
	{
	int n;
	struct event *e;
	struct timeout *t;
	struct timeval tv;
	struct timespec ts, *tsp;
	void (t0)(void );

	for (;;) {
	/* Run all timeouts first */
	if (timeout0) {
	t0 = timeout0;
	timeout0 = NULL;
	t0(timeout0_arg);
	continue;
	}
	if ((t = TAILQ_FIRST(&timeouts))) {
	get_monotonic(&now);
	if (timercmp(&now, &t->when, >)) {
	TAILQ_REMOVE(&timeouts, t, next);
	t->callback(t->arg);
	TAILQ_INSERT_TAIL(&free_timeouts, t, next);
	continue;
	}
	timersub(&t->when, &now, &tv);
	TIMEVAL_TO_TIMESPEC(&tv, &ts);
	tsp = &ts;
	} else
	/* No timeouts, so wait forever */
	tsp = NULL;

	if (tsp == NULL && events_len == 0) {
	syslog(LOG_ERR, "nothing to do");
	exit(EXIT_FAILURE);
	}

	n = pollts(fds, events_len, tsp, sigmask);
	if (n == -1) {
	if (errno == EAGAIN \|\| errno == EINTR)
	continue;
	syslog(LOG_ERR, "poll: %m");
	exit(EXIT_FAILURE);
	}

	/* Process any triggered events. */
	if (n > 0) {
	TAILQ_FOREACH(e, &events, next) {
	if (e->pollfd->revents & (POLLIN \| POLLHUP)) {
	e->callback(e->arg);
	/* We need to break here as the
	* callback could destroy the next
	* fd to process. */
	break;
	}
	}
	}
	}
	}