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.2 2003/06/17 04:29:52 dillon 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()
59: {
60: register struct rthash *rh;
61: register struct rt_entry *rt;
62: register struct sap_hash *sh;
63: register 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()
212: {
213: register struct rthash *rh;
214: register struct rt_entry *rt;
215: register struct sap_hash *sh;
216: register 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: }
![[BACK]](/icons//back.gif){kind=icon}
Return to timer.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / usr.sbin / IPXrouted