![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddp_rtmp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netat|
Return to ddp_rtmp.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1993-1998 Apple Computer, Inc.
27: * All Rights Reserved.
28: *
29: * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF APPLE COMPUTER, INC.
30: * The copyright notice above does not evidence any actual or
31: * intended publication of such source code.
32: */
33:
34: #include <sysglue.h>
35:
36: #include <at/appletalk.h>
37: #include <at/ddp.h>
38: #include <rtmp.h>
39: #include <lap.h>
40:
41: #include <at/at_lap.h>
42: #include <at_ddp.h>
43: #include <at_zip.h>
44: #include <routing_tables.h>
45: #include <atlog.h>
46:
47: extern void *atalk_timeout();
48: extern void atalk_untimeout();
49: extern void rtmp_router_input();
50:
51: /****************************************************************/
52: /* */
53: /* */
54: /* RTMP Protocol */
55: /* */
56: /* */
57: /****************************************************************/
58:
59:
60: /* rtmp.c: , 1.6; 2/26/93; Apple Computer, Inc." */
61:
62:
63: #define NROUTERS2TRAK 8
64: #define FIFTYSECS 10
65: #define NODE(r) ((r)->ifARouter.atalk_node)
66: #define NET(r) ((r)->ifARouter.atalk_net)
67: #define INUSE(r) (NODE(r))
68:
69: void ddp_age_router();
70:
71:
72:
73: static struct routerinfo {
74: struct atalk_addr ifARouter;
75: at_if_t *ifID;
76: void *tmo;
77: } trackedrouters[NROUTERS2TRAK];
78:
79: void trackrouter_rem_if(ifID)
80: register at_if_t *ifID;
81: {
82: register i;
83: register struct routerinfo *router;
84:
85: for (i = NROUTERS2TRAK; --i >= 0;) {
86: router = &trackedrouters[i];
87: if (trackedrouters[i].ifID == ifID) {
88: atalk_untimeout(ddp_age_router, (caddr_t) router, router->tmo);
89: break;
90: }
91: }
92: }
93:
94:
95: void routershutdown()
96: {
97: register i;
98:
99: for (i = NROUTERS2TRAK; --i >= 0;) {
100: register struct routerinfo *router;
101:
102: router = &trackedrouters[i];
103: if (INUSE(router)) {
104: atalk_untimeout(ddp_age_router, (caddr_t) router, router->tmo);
105: bzero((caddr_t) router, sizeof(struct routerinfo));
106: }
107: }
108: }
109:
110: int router_added = 0;
111: int router_killed = 0;
112:
113:
114:
115: void trackrouter(ifID, net, node)
116: register at_if_t *ifID;
117: register unsigned short net;
118: register unsigned char node;
119: {
120: register struct routerinfo *unused = NULL;
121: register i;
122:
123: for (i = NROUTERS2TRAK; --i >= 0;) {
124: register struct routerinfo *router;
125:
126: router = &trackedrouters[(i + node) & (NROUTERS2TRAK-1)];
127: if ((NODE(router) == node) && (NET_VALUE(NET(router)) == net)) {
128: atalk_untimeout(ddp_age_router, (caddr_t) router, router->tmo);
129: router->tmo = atalk_timeout(ddp_age_router, (caddr_t) router, 50*SYS_HZ);
130: unused = NULL;
131: break;
132: }
133: else if (!INUSE(router) && !unused)
134: unused = router;
135: }
136: if (unused) {
137: router_added++;
138:
139: unused->ifID = ifID;
140: NET_ASSIGN(NET(unused), net);
141: NODE(unused) = node;
142: unused->tmo = atalk_timeout(ddp_age_router, (caddr_t) unused, 50*SYS_HZ);
143: if (NET_EQUAL0(NET(ifID)) && NODE(ifID) == 0) {
144: NET_ASSIGN(NET(ifID), net);
145: NODE(ifID) = node;
146: ifID->ifRouterState = ROUTER_AROUND;
147: }
148: }
149: }
150:
151:
152:
153: void ddp_age_router(deadrouter)
154: register struct routerinfo *deadrouter;
155: {
156: register at_if_t *ourrouter = deadrouter->ifID;
157:
158: dPrintf(D_M_RTMP, D_L_INFO,
159: ("ddp_age_router called deadrouter=%d:%d\n", NODE(deadrouter), NET(deadrouter)));
160:
161: router_killed++;
162:
163: if (NODE(ourrouter) == NODE(deadrouter) &&
164: NET_EQUAL(NET(ourrouter), NET(deadrouter))) {
165: register unsigned long atrandom = random();
166: register struct routerinfo *newrouter;
167: register i;
168:
169: bzero((caddr_t) deadrouter, sizeof(struct routerinfo));
170: for (i = NROUTERS2TRAK; --i >= 0;) {
171: newrouter = &trackedrouters[(i + atrandom) & (NROUTERS2TRAK-1)];
172: if (INUSE(newrouter))
173: break;
174: else
175: newrouter = NULL;
176: }
177: if (newrouter) {
178: NET_NET(NET(ourrouter), NET(newrouter));
179: NODE(ourrouter) = NODE(newrouter);
180: }
181: else {
182: void gorouterless();
183: gorouterless(ourrouter);
184: }
185: } else
186: bzero((caddr_t) deadrouter, sizeof(struct routerinfo));
187: }
188:
189:
190:
191: /*
192: * This is the timeout function that is called after 50 seconds,
193: * if no router packets come in. That way we won't send extended
194: * frames to something that is not there. Untimeout is called if
195: * an RTMP packet comes in so this routine will not be called.
196: */
197:
198: static void gorouterless(int_ifID)
199: {
200: register at_if_t *ifID = (at_if_t *)int_ifID;
201:
202: ATTRACE(AT_MID_DDP, AT_SID_TIMERS, AT_LV_WARNING, FALSE,
203: "ddp_age_router entry : ARouter = 0x%x, RouterState = 0x%x",
204: ATALK_VALUE(ifID->ifARouter), ifID->ifRouterState, 0);
205:
206: switch (ifID->ifRouterState) {
207: case ROUTER_AROUND :
208: ATALK_ASSIGN(ifID->ifARouter, 0, 0, 0);
209: dPrintf(D_M_RTMP,D_L_INFO,
210: ("rtmp.c Gorouterless!!!!!!!!\n"));
211: ifID->ifThisCableStart = 2;
212: ifID->ifThisCableEnd = 0xfffd;
213: ifID->ifRouterState = NO_ROUTER;
214: zip_control (ifID, ZIP_NO_ROUTER);
215: break;
216: case ROUTER_WARNING :
217: /* there was a router that we were ignoring...
218: * now, even that's gone. But we want to tackle the
219: * case where another router may come up after all
220: * of them have died...
221: */
222: ifID->ifRouterState = NO_ROUTER;
223: break;
224: }
225: }
226:
227:
228:
229: void
230: rtmp_input (mp, ifID)
231: register gbuf_t *mp;
232: register at_if_t *ifID;
233: {
234: register at_net_al this_net;
235: register at_net_al range_start, range_end;
236: register at_ddp_t *ddp = (at_ddp_t *)gbuf_rptr(mp);
237: /* NOTE: there is an assumption here that the
238: * DATA follows the header. */
239: register at_rtmp *rtmp = (at_rtmp *)ddp->data;
240:
241: if (gbuf_type(mp) != MSG_DATA) {
242: /* If this is a M_ERROR message, DDP is shutting down,
243: * nothing to do here...If it's something else, we don't
244: * understand what it is
245: */
246: gbuf_freem(mp);
247: return;
248: }
249:
250: if (!ifID) {
251: gbuf_freem(mp);
252: return;
253: }
254: if (gbuf_len(mp) < (DDP_X_HDR_SIZE + sizeof(at_rtmp))) {
255: gbuf_freem(mp);
256: return;
257: }
258: this_net = NET_VALUE(ifID->ifThisNode.atalk_net);
259: if (rtmp->at_rtmp_id_length != 8) {
260: gbuf_freem(mp);
261: return;
262: }
263:
264: {
265: at_rtmp_tuple *tp;
266: tp = ((at_rtmp_tuple *)&rtmp->at_rtmp_id[1]);
267: range_start = NET_VALUE(tp->at_rtmp_net);
268: tp = ((at_rtmp_tuple *)&rtmp->at_rtmp_id[4]);
269: range_end = NET_VALUE(tp->at_rtmp_net);
270:
271: if (ifID->ifRouterState == ROUTER_AROUND) {
272: if ((ifID->ifThisCableStart == range_start) &&
273: (ifID->ifThisCableEnd == range_end)) {
274: trackrouter(
275: ifID,
276: NET_VALUE(rtmp->at_rtmp_this_net),
277: rtmp->at_rtmp_id[0]
278: );
279: }
280: } else {
281: /* There was no router around earlier, one
282: * probably just came up.
283: */
284: if ((this_net >= DDP_STARTUP_LOW) &&
285: (this_net <= DDP_STARTUP_HIGH)) {
286: /* we're operating in the startup range,
287: * ignore the presence of router
288: */
289: if (ifID->ifRouterState == NO_ROUTER) {
290: dPrintf(D_M_RTMP, D_L_STARTUP,
291: ("Warning: new router came up: invalid startup net/node\n"));
292: trackrouter(
293: ifID,
294: NET_VALUE(rtmp->at_rtmp_this_net),
295: rtmp->at_rtmp_id[0]
296: );
297: ifID->ifRouterState = ROUTER_WARNING;
298: }
299: } else {
300: /* our address
301: * is not in startup range; Is our
302: * address good for the cable??
303: */
304: if ((this_net >= range_start) &&
305: (this_net <= range_end)) {
306: /* Our address is in the range
307: * valid for this cable... Note
308: * the router address and then
309: * get ZIP rolling to get the
310: * zone info.
311: */
312: ifID->ifThisCableStart = range_start;
313: ifID->ifThisCableEnd = range_end;
314: trackrouter(
315: ifID,
316: NET_VALUE(rtmp->at_rtmp_this_net),
317: rtmp->at_rtmp_id[0]
318: );
319: zip_control(ifID, ZIP_LATE_ROUTER);
320: } else {
321: /* Our address is not in the
322: * range valid for this cable..
323: * ignore presence of the
324: * router
325: */
326: if (ifID->ifRouterState == NO_ROUTER) {
327: dPrintf(D_M_RTMP,D_L_ERROR,
328: ("Warning: new router came up: invalid net/node\n"));
329: trackrouter(
330: ifID,
331: NET_VALUE(rtmp->at_rtmp_this_net),
332: rtmp->at_rtmp_id[0]
333: );
334: ifID->ifRouterState =
335: ROUTER_WARNING;
336: }
337: }
338: }
339: }
340: }
341:
342: gbuf_freem(mp);
343: return;
344: }
345:
346:
347: int rtmp_init()
348: {
349: bzero((caddr_t) trackedrouters, sizeof(struct routerinfo)*NROUTERS2TRAK);
350:
351: if (!ROUTING_MODE)
352: return((int)rtmp_input);
353:
354: else
355: return ((int)rtmp_router_input);
356: }
357:
358:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.