Merge from vendor branch WPA_SUPPLICANT:
[dragonfly.git] / usr.sbin / IPXrouted / timer.c
1 /*
2  * Copyright (c) 1985, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Copyright (c) 1995 John Hay.  All rights reserved.
6  *
7  * This file includes significant work done at Cornell University by
8  * Bill Nesheim.  That work included by permission.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  * $FreeBSD: src/usr.sbin/IPXrouted/timer.c,v 1.5 1999/08/28 01:15:06 peter Exp $
39  * $DragonFly: src/usr.sbin/IPXrouted/timer.c,v 1.3 2004/03/11 09:38:59 hmp Exp $
40  *
41  * @(#)timer.c  8.1 (Berkeley) 6/5/93
42  */
43
44 /*
45  * Routing Table Management Daemon
46  */
47 #include "defs.h"
48 #include <unistd.h>
49 #include <stdlib.h>
50
51 int     timeval = -TIMER_RATE;
52
53 /*
54  * Timer routine.  Performs routing information supply
55  * duties and manages timers on routing and SAP table entries.
56  */
57 void
58 timer(void)
59 {
60         struct rthash *rh;
61         struct rt_entry *rt;
62         struct sap_hash *sh;
63         struct sap_entry *sap;
64         struct sap_hash *sap_base = sap_head;
65         int timetobroadcast, ripbroadcast, sapbroadcast;
66
67         timeval += TIMER_RATE;
68         if (lookforinterfaces && (timeval % CHECK_INTERVAL) == 0)
69                 ifinit();
70         timetobroadcast = supplier && (timeval % SUPPLY_INTERVAL) == 0;
71         ripbroadcast = supplier && timetobroadcast && 
72                         (timeval % RIP_INTERVAL) == 0;
73         sapbroadcast = timetobroadcast && dosap && !ripbroadcast;
74
75         for (rh = nethash; rh < &nethash[ROUTEHASHSIZ]; rh++) {
76                 rt = rh->rt_forw;
77                 for (; rt != (struct rt_entry *)rh; rt = rt->rt_forw) {
78                         if (rt->rt_clone) {
79                                 struct rt_entry *trt, *prt;
80                                 /*
81                                  * If a clone expire free it and mark the
82                                  * main route RTS_CHANGED.
83                                  */
84                                 prt = rt;
85                                 trt = rt->rt_clone;
86                                 while (trt) {
87                                         trt->rt_timer += TIMER_RATE;
88                                         if (trt->rt_timer >= EXPIRE_TIME) {
89                                                 prt->rt_clone = trt->rt_clone;
90                                                 free((char *)trt);
91                                                 trt = prt->rt_clone;
92                                                 rt->rt_state |= RTS_CHANGED;
93                                         } else {
94                                                 prt = trt;
95                                                 trt = prt->rt_clone;
96                                         }
97                                 }
98                         }
99                         /*
100                          * We don't advance time on a routing entry for
101                          * a passive gateway or that for our only interface. 
102                          * The latter is excused because we don't act as
103                          * a routing information supplier and hence would
104                          * time it out.  This is fair as if it's down
105                          * we're cut off from the world anyway and it's
106                          * not likely we'll grow any new hardware in
107                          * the mean time.
108                          */
109                         if (!(rt->rt_state & RTS_PASSIVE) &&
110                             !(rt->rt_state & RTS_INTERFACE))
111                                 rt->rt_timer += TIMER_RATE;
112                         if (rt->rt_timer >= EXPIRE_TIME) {
113                                 rt->rt_metric = HOPCNT_INFINITY;
114                                 rt->rt_state |= RTS_CHANGED;
115                         }
116                         if (rt->rt_timer >= GARBAGE_TIME) {
117                                 rt = rt->rt_back;
118                                 /* Perhaps we should send a REQUEST for this route? */
119                                 rtdelete(rt->rt_forw);
120                                 continue;
121                         }
122                         if (rt->rt_state & RTS_CHANGED) {
123                                 rt->rt_state &= ~RTS_CHANGED;
124                                 /* don't send extraneous packets */
125                                 if (!supplier || ripbroadcast)
126                                         continue;
127                                 if ((rt->rt_metric + 1) == HOPCNT_INFINITY)
128                                         continue;
129                                 msg->rip_cmd = htons(RIPCMD_RESPONSE);
130                                 msg->rip_nets[0].rip_dst =
131                                         (satoipx_addr(rt->rt_dst)).x_net;
132                                 msg->rip_nets[0].rip_metric =
133                                         htons(min(rt->rt_metric+1, HOPCNT_INFINITY));
134                                 msg->rip_nets[0].rip_ticks = 
135                                         htons(rt->rt_ticks + 1);
136                                 toall(sndmsg, rt, 0);
137                         }
138                 }
139         }
140         if (ripbroadcast)
141                 toall(supply, NULL, 0);
142
143         /* 
144          * Now do the SAP stuff.
145          */
146         for (sh = sap_base; sh < &sap_base[SAPHASHSIZ]; sh++) {
147                 sap = sh->forw;
148                 for (; sap != (struct sap_entry *)sh; sap = sap->forw) {
149                         if (sap->clone) {
150                                 struct sap_entry *tsap, *psap;
151                                 /*
152                                  * If a clone expire free it and mark the
153                                  * main sap entry RTS_CHANGED.
154                                  */
155                                 psap = sap;
156                                 tsap = sap->clone;
157                                 while (tsap) {
158                                         tsap->timer += TIMER_RATE;
159                                         if (tsap->timer >= EXPIRE_TIME) {
160                                                 psap->clone = tsap->clone;
161                                                 free((char *)tsap);
162                                                 tsap = psap->clone;
163                                                 sap->state |= RTS_CHANGED;
164                                         } else {
165                                                 psap = tsap;
166                                                 tsap = psap->clone;
167                                         }
168                                 }
169                         }
170                         sap->timer += TIMER_RATE;
171                         if (sap->timer >= EXPIRE_TIME) {
172                                 sap->sap.hops = htons(HOPCNT_INFINITY);
173                                 sap->state |= RTS_CHANGED;
174                         }
175                         if (sap->timer >= GARBAGE_TIME) {
176                                 sap = sap->back;
177                                 /* Perhaps we should send a REQUEST for this route? */
178                                 sap_delete(sap->forw);
179                                 continue;
180                         }
181                         /*
182                          * XXX sap_sndmsg on RTS_CHANGED
183                          */
184                         if (sap->state & RTS_CHANGED) {
185                                 sap->state &= ~RTS_CHANGED;
186 #ifdef notyet
187                                 /* don't send extraneous packets */
188                                 if (!supplier || sapbroadcast)
189                                         continue;
190                                 if ((ntohs(sap->sap.hops) + 1) == HOPCNT_INFINITY)
191                                         continue;
192                                 sap_msg->sap_cmd = htons(SAP_RESP);
193                                 sap_msg->sap[0] = sap->sap;
194                                 sap_msg->sap[0].hops =
195                                     htons(min(sap->sap.hops+1, HOPCNT_INFINITY));
196                                 toall(sapsndmsg, rt, 0);
197 #endif
198                         }
199                 }
200         }
201         if (sapbroadcast)
202                 sap_supply_toall(0);
203         if (ftrace && sapbroadcast)
204                 dumpsaptable(ftrace, sap_head);
205 }
206
207 /*
208  * On hangup, let everyone know we're going away.
209  */
210 void
211 hup(void)
212 {
213         struct rthash *rh;
214         struct rt_entry *rt;
215         struct sap_hash *sh;
216         struct sap_entry *sap;
217
218         if (supplier) {
219                 for (rh = nethash; rh < &nethash[ROUTEHASHSIZ]; rh++) {
220                         rt = rh->rt_forw;
221                         for (; rt != (struct rt_entry *)rh; rt = rt->rt_forw)
222                                 rt->rt_metric = HOPCNT_INFINITY;
223                 }
224                 toall(supply, NULL, 0);
225
226                 /*
227                  * Now for SAP.
228                  */
229                 for (sh = sap_head; sh < &sap_head[SAPHASHSIZ]; sh++) {
230                         sap = sh->forw;
231                         for (; sap != (struct sap_entry *)sh; sap = sap->forw)
232                                 sap->sap.hops = htons(HOPCNT_INFINITY);
233                 }
234                 if (dosap)
235                         sap_supply_toall(0);
236         }
237         exit(1);
238 }