xref: /freebsd/usr.sbin/rtadvd/timer.c (revision c98323078dede7579020518ec84cdcb478e5c142)
1 /*	$FreeBSD$	*/
2 /*	$KAME: timer.c,v 1.9 2002/06/10 19:59:47 itojun Exp $	*/
3 
4 /*
5  * Copyright (C) 1998 WIDE Project.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the project nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/time.h>
34 
35 #include <unistd.h>
36 #include <syslog.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include "timer.h"
40 
41 static struct rtadvd_timer timer_head;
42 
43 #define MILLION 1000000
44 #define TIMEVAL_EQUAL(t1,t2) ((t1)->tv_sec == (t2)->tv_sec &&\
45  (t1)->tv_usec == (t2)->tv_usec)
46 
47 static struct timeval tm_max = {0x7fffffff, 0x7fffffff};
48 
49 void
50 rtadvd_timer_init()
51 {
52 	memset(&timer_head, 0, sizeof(timer_head));
53 
54 	timer_head.next = timer_head.prev = &timer_head;
55 	timer_head.tm = tm_max;
56 }
57 
58 struct rtadvd_timer *
59 rtadvd_add_timer(struct rtadvd_timer *(*timeout) __P((void *)),
60     void (*update) __P((void *, struct timeval *)),
61     void *timeodata, void *updatedata)
62 {
63 	struct rtadvd_timer *newtimer;
64 
65 	if ((newtimer = malloc(sizeof(*newtimer))) == NULL) {
66 		syslog(LOG_ERR,
67 		       "<%s> can't allocate memory", __func__);
68 		exit(1);
69 	}
70 
71 	memset(newtimer, 0, sizeof(*newtimer));
72 
73 	if (timeout == NULL) {
74 		syslog(LOG_ERR,
75 		       "<%s> timeout function unspecified", __func__);
76 		exit(1);
77 	}
78 	newtimer->expire = timeout;
79 	newtimer->update = update;
80 	newtimer->expire_data = timeodata;
81 	newtimer->update_data = updatedata;
82 	newtimer->tm = tm_max;
83 
84 	/* link into chain */
85 	insque(newtimer, &timer_head);
86 
87 	return(newtimer);
88 }
89 
90 void
91 rtadvd_remove_timer(struct rtadvd_timer **timer)
92 {
93 	remque(*timer);
94 	free(*timer);
95 	*timer = NULL;
96 }
97 
98 void
99 rtadvd_set_timer(struct timeval *tm, struct rtadvd_timer *timer)
100 {
101 	struct timeval now;
102 
103 	/* reset the timer */
104 	gettimeofday(&now, NULL);
105 
106 	TIMEVAL_ADD(&now, tm, &timer->tm);
107 
108 	/* update the next expiration time */
109 	if (TIMEVAL_LT(timer->tm, timer_head.tm))
110 		timer_head.tm = timer->tm;
111 
112 	return;
113 }
114 
115 /*
116  * Check expiration for each timer. If a timer expires,
117  * call the expire function for the timer and update the timer.
118  * Return the next interval for select() call.
119  */
120 struct timeval *
121 rtadvd_check_timer()
122 {
123 	static struct timeval returnval;
124 	struct timeval now;
125 	struct rtadvd_timer *tm = timer_head.next, *tm_next;
126 
127 	gettimeofday(&now, NULL);
128 
129 	timer_head.tm = tm_max;
130 
131 	for (tm = timer_head.next; tm != &timer_head; tm = tm_next) {
132 		tm_next = tm->next;
133 
134 		if (TIMEVAL_LEQ(tm->tm, now)) {
135 			if (((*tm->expire)(tm->expire_data) == NULL))
136 				continue; /* the timer was removed */
137 			if (tm->update)
138 				(*tm->update)(tm->update_data, &tm->tm);
139 			TIMEVAL_ADD(&tm->tm, &now, &tm->tm);
140 		}
141 
142 		if (TIMEVAL_LT(tm->tm, timer_head.tm))
143 			timer_head.tm = tm->tm;
144 	}
145 
146 	if (TIMEVAL_EQUAL(&tm_max, &timer_head.tm)) {
147 		/* no need to timeout */
148 		return(NULL);
149 	} else if (TIMEVAL_LT(timer_head.tm, now)) {
150 		/* this may occur when the interval is too small */
151 		returnval.tv_sec = returnval.tv_usec = 0;
152 	} else
153 		TIMEVAL_SUB(&timer_head.tm, &now, &returnval);
154 	return(&returnval);
155 }
156 
157 struct timeval *
158 rtadvd_timer_rest(struct rtadvd_timer *timer)
159 {
160 	static struct timeval returnval, now;
161 
162 	gettimeofday(&now, NULL);
163 	if (TIMEVAL_LEQ(timer->tm, now)) {
164 		syslog(LOG_DEBUG,
165 		       "<%s> a timer must be expired, but not yet",
166 		       __func__);
167 		returnval.tv_sec = returnval.tv_usec = 0;
168 	}
169 	else
170 		TIMEVAL_SUB(&timer->tm, &now, &returnval);
171 
172 	return(&returnval);
173 }
174 
175 /* result = a + b */
176 void
177 TIMEVAL_ADD(struct timeval *a, struct timeval *b, struct timeval *result)
178 {
179 	long l;
180 
181 	if ((l = a->tv_usec + b->tv_usec) < MILLION) {
182 		result->tv_usec = l;
183 		result->tv_sec = a->tv_sec + b->tv_sec;
184 	}
185 	else {
186 		result->tv_usec = l - MILLION;
187 		result->tv_sec = a->tv_sec + b->tv_sec + 1;
188 	}
189 }
190 
191 /*
192  * result = a - b
193  * XXX: this function assumes that a >= b.
194  */
195 void
196 TIMEVAL_SUB(struct timeval *a, struct timeval *b, struct timeval *result)
197 {
198 	long l;
199 
200 	if ((l = a->tv_usec - b->tv_usec) >= 0) {
201 		result->tv_usec = l;
202 		result->tv_sec = a->tv_sec - b->tv_sec;
203 	}
204 	else {
205 		result->tv_usec = MILLION + l;
206 		result->tv_sec = a->tv_sec - b->tv_sec - 1;
207 	}
208 }
209