![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddp_rtmptable.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to ddp_rtmptable.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*----------------------------------------------------------------------------
23: *
24: * RTMP & ZIP routing tables access routines
25: *
26: * This code implement b-tree search and manipulation of
27: * of the RTMP routing table and ZIP zone table.
28: *
29: * The RTMP routing table is a data block divided in several routing
30: * entries sorted during insertion in a b-tree form. We use a table and
31: * not dynamically allocated entries because it allow us to scan the whole
32: * table when RTMP packets are generated. The routing table entries are sorted
33: * by there NetStop value (because non extended nets have a NetStart value of
34: * zero. From any point in the tree, the left side contains Network ranges
35: * smaller or equal to the current Node, and the right tree points to higher
36: * values network ranges.
37: *
38: *
39: * 0.01 3/16/94 LD Creation
40: * Modified for MP, 1996 by Tuyen Nguyen
41: * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
42: *
43: *----------------------------------------------------------------------------
44: *
45: * Copyright (c) 1994, 1996, 1997, 1998 Apple Computer, Inc.
46: */
47:
48: #include <sys/errno.h>
49: #include <sys/types.h>
50: #include <sys/param.h>
51: #include <machine/spl.h>
52: #include <sys/systm.h>
53: #include <sys/kernel.h>
54: #include <sys/proc.h>
55: #include <sys/filedesc.h>
56: #include <sys/fcntl.h>
57: #include <sys/mbuf.h>
58: #include <sys/ioctl.h>
59: #include <sys/malloc.h>
60: #include <sys/socket.h>
61: #include <sys/socketvar.h>
62:
63: #include <net/if.h>
64: #include <net/if_types.h>
65:
66: #include <netat/sysglue.h>
67: #include <netat/appletalk.h>
68: #include <netat/at_var.h>
69: #include <netat/lap.h>
70: #include <netat/ddp.h>
71: #include <netat/rtmp.h>
72: #include <netat/at_pcb.h>
73: #include <netat/zip.h>
74: #include <netat/routing_tables.h>
75: #include <netat/at_snmp.h>
76: #include <netat/debug.h>
77: #include <netat/at_config.h>
78:
79: RT_entry *RT_table_freelist; /* start of free entry list */
80: RT_entry RT_table_start; /* start of the actual entry table */
81: RT_entry *RT_table; /* the routing table */
82: ZT_entry *ZT_table; /* the Zone Information Protocol table */
83: short RT_maxentry; /* Number of entry in RTMP table */
84: short ZT_maxentry; /* Number of entry in ZIP table */
85:
86: char errstr[512]; /* used to display meaningfull router errors*/
87:
88: extern at_ifaddr_t *ifID_table[];
89: extern at_ifaddr_t *ifID_home;
90: extern snmpStats_t snmpStats;
91: extern atlock_t ddpinp_lock;
92:
93: short ErrorRTMPoverflow = 0; /* flag if RTMP table is too small for this net */
94: short ErrorZIPoverflow = 0; /* flag if ZIP table is too small for this net */
95:
96: /* prototypes */
97: void getIfUsage( int, char*);
98:
99: /*
100: * This a temporary function : just to display the router error
101: */
102:
103: void RouterError(port, err_number)
104: short port, err_number;
105:
106: {
107: switch (err_number) {
108:
109: case ERTR_SEED_CONFLICT:
110: dPrintf(D_M_RTMP, D_L_ERROR,
111: ("**** RTR Error on port# %d SEED_CONFLICT\n", port));
112: break;
113:
114: case ERTR_CABLE_CONFLICT:
115: dPrintf(D_M_RTMP, D_L_ERROR,
116: ("**** RTR Error on port# %d CABLE_CONFLICT\n", port));
117: break;
118:
119: case ERTR_RTMP_BAD_VERSION:
120: dPrintf(D_M_RTMP, D_L_ERROR,
121: ("**** RTR Error on port# %d RTMP_BAD_VERSION\n", port));
122: break;
123:
124: case ERTR_CABLE_STARTUP:
125: dPrintf(D_M_RTMP, D_L_ERROR,
126: ("**** RTR Error on port# %d RTMP_CABLE_STARTUP\n",
127: port));
128: break;
129:
130: default:
131: dPrintf(D_M_RTMP, D_L_ERROR,
132: ("**** RTR Error on port# %d WHAT IN THE WORLD IS THIS ONE? code=%d\n",
133: port, err_number));
134: break;
135: }
136: dPrintf(D_M_RTMP, D_L_ERROR, ("Explanation: %s\n", errstr));
137: }
138:
139:
140: /*
141: * this function just look for a NetNumber in the routing table,
142: * no check is done for the validity of the entry
143: */
144:
145: RT_entry *rt_blookup (NetNumber)
146: at_net_al NetNumber;
147: {
148:
149: RT_entry *ptree = &RT_table_start;
150: at_net_al LowEnd;
151: register unsigned int s;
152: /*
153: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : Lookup for Net=%d\n",
154: "rt_blookup", NetNumber));
155: */
156: ATDISABLE(s, ddpinp_lock);
157: while (ptree) {
158:
159: if (NetNumber > ptree->NetStop) {
160: /*
161: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : Go Right from #%d\n",
162: "rt_blookup", ptree->NextIRNet));
163: */
164: ptree = ptree->right;
165: continue;
166: }
167: else {
168: if (ptree->NetStart)
169: LowEnd = ptree->NetStart;
170: else
171: LowEnd = ptree->NetStop;
172:
173: if (NetNumber < LowEnd ) {
174: /*
175: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : Go Left from #%d\n",
176: "rt_blookup", ptree->NextIRNet));
177: */
178: ptree = ptree->left;
179: continue;
180: }
181: ATENABLE(s, ddpinp_lock);
182:
183: /* we're in the range (either extended or not)
184: * return the entry found.
185: */
186:
187: /* dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : found %04d-%04d Port=%d State=0x%x\n",
188: "rt_blookup", ptree->NetStart, ptree->NetStop, ptree->NetPort,
189: ptree->EntryState));
190: */
191:
192: return (ptree);
193: }
194: }
195: ATENABLE(s, ddpinp_lock);
196:
197: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : %04d : NOT FOUND\n",
198: "rt_blookup", NetNumber));
199: return ((RT_entry *)NULL);
200: }
201:
202:
203: /* Routing table btree insert routine
204: * Uses a RT_entry parameter as the input, the insert is sorted in
205: * the tree on the NetStop field. Provision is made for non extented
206: * net (ie NetStart = 0).
207: * The function returns the element where the new entry was inserted, or
208: * NULL if the insert didn't work. (In this cas there is a problem with
209: * the tree coherency...
210: *
211: */
212:
213:
214: RT_entry *rt_binsert (NewEntry)
215: RT_entry *NewEntry;
216: {
217: RT_entry *ptree = &RT_table_start;
218:
219: register at_net_al NetStart = NewEntry->NetStart;
220: register at_net_al NetStop = NewEntry->NetStop;
221:
222: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("rt_binsert: for Net %d-%d state=x%x NextIR %d:%d\n",
223: NetStart, NetStop, NewEntry->EntryState,NewEntry->NextIRNet, NewEntry->NextIRNode));
224:
225: if (ptree == (RT_entry *)NULL) {
226: *ptree = *NewEntry;
227: at_state.flags |= AT_ST_RT_CHANGED;
228: return (NewEntry);
229: }
230:
231:
232: while (ptree) {
233:
234: if (NetStop > ptree->NetStop) { /* walk the right sub-tree */
235: if (ptree->right)
236: ptree = ptree->right;
237: else {
238: ptree->right = NewEntry;
239: at_state.flags |= AT_ST_RT_CHANGED;
240: return (ptree);
241: }
242: }
243: else { /* walk the left sub-tree */
244: if (ptree->left)
245: ptree = ptree->left;
246: else {
247: ptree->left = NewEntry;
248: at_state.flags |= AT_ST_RT_CHANGED;
249: return (ptree);
250: }
251: }
252:
253: }
254:
255: dPrintf(D_M_RTMP, D_L_WARNING, ("%s : ERROR NOT INSERTED Net %d-%d\n",
256: "rt_binsert", NetStart, NetStop));
257: return ((RT_entry *)NULL);
258: }
259:
260: RT_entry *rt_insert(NStop, NStart, NxNet, NxNode, NtDist, NtPort, EntS)
261: at_net_al NStop, NStart, NxNet;
262: at_node NxNode;
263: u_char NtDist, NtPort, EntS;
264: {
265: RT_entry *New;
266: if ((New = RT_table_freelist)) {
267: RT_table_freelist = RT_table_freelist->right;
268: } else
269: return ((RT_entry *)NULL);
270: New->right = NULL;
271: New->NetStop = NStop;
272: New->NetStart = NStart;
273: New->NextIRNet = NxNet;
274: New->NextIRNode = NxNode;
275: New->NetDist = NtDist;
276: New->NetPort = NtPort;
277: New->EntryState = EntS;
278: bzero(New->ZoneBitMap, sizeof(New->ZoneBitMap));
279: at_state.flags |= AT_ST_RT_CHANGED;
280: return(rt_binsert(New));
281: }
282:
283: /*
284: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : %04d : NOT FOUND\n",
285: "rt_blookup", NetNumber));
286: * Routing table btree deletion routine
287: *
288: */
289:
290: RT_entry *rt_bdelete (NetStop, NetStart)
291: at_net_al NetStop, NetStart;
292: {
293:
294: RT_entry *rt_found, *pprevious, *pnext, *pnextl, *psub;
295: at_net_al LowEnd;
296:
297: rt_found = &RT_table_start;
298:
299: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("%s : Delete %d-%d\n",
300: "rt_bdelete", NetStart, NetStop));
301:
302: while (rt_found) {
303:
304: if (NetStop > rt_found->NetStop) {
305: pprevious = rt_found;
306: rt_found = rt_found->right;
307: continue;
308: }
309: else {
310:
311: /* non extended nets cases */
312:
313: if (rt_found->NetStart)
314: LowEnd = rt_found->NetStart;
315: else
316: LowEnd = rt_found->NetStop;
317:
318: if (NetStop < LowEnd) {
319: pprevious = rt_found;
320: rt_found = rt_found->left;
321: continue;
322: }
323:
324: /* we're in the range (either extended or not)
325: * return the entry found.
326: */
327:
328: break;
329: }
330: }
331:
332: dPrintf(D_M_RTMP, D_L_ROUTING, ("%s : Delete %d-%d found to delete %d-%d\n",
333: "rt_bdelete", NetStart, NetStop, rt_found->NetStart,rt_found->NetStop));
334:
335: if (rt_found) {
336:
337:
338:
339: /* we found the entry, now reorg the sub-trees
340: * spanning from our node.
341: */
342:
343: if ((pnext = rt_found->right)) {
344:
345: /* Tree pruning: take the left branch of the current
346: * node and place it at the lowest left branch
347: * of the current right branch
348: */
349:
350: psub = pnext;
351:
352: /* walk the Right/Left sub tree from current node */
353:
354: while ((pnextl = psub->left))
355: psub = pnextl;
356:
357: /* plug the old left tree to the new ->Right leftmost node */
358:
359: psub->left = rt_found->left;
360:
361:
362: } else { /* only left sub-tree, simple case */
363:
364: pnext = rt_found->left;
365: }
366:
367: /* Now, plug the current node sub tree to the good pointer of
368: * our parent node.
369: */
370:
371:
372: if (pprevious->left == rt_found)
373: pprevious->left = pnext;
374: else
375: pprevious->right = pnext;
376:
377: /* clean-up entry and add to the free-list */
378:
379: at_state.flags |= AT_ST_RT_CHANGED;
380: return(rt_found);
381: }
382:
383: else { /* Trying to delete something that doesn't exist? */
384:
385: dPrintf(D_M_RTMP, D_L_WARNING, ("%s : %d NOT Removed\n",
386: "rt_bdelete", NetStop));
387:
388: return ((RT_entry *)NULL);
389: }
390:
391:
392: }
393:
394:
395: RT_entry *rt_sortedshow(parent)
396: RT_entry *parent;
397: {
398: RT_entry *me;
399:
400: me = parent;
401:
402: if (parent == NULL) {
403: me = &RT_table_start;
404: while (me)
405: if (me->left) {
406: parent = me;
407: me = me->left;
408: }
409: /* parent = parent->parent; */
410: }
411: return (parent);
412: }
413:
414: /*
415: * debug only: display the contents of the routing table
416: */
417:
418: void rt_show ()
419: {
420: RT_entry *ptree;
421: int i=0;
422:
423: ptree = &RT_table[0];
424:
425: while (ptree && i < 600 ) {
426: if (ptree->NetStop) {
427: dPrintf(D_M_RTMP_LOW, D_L_VERBOSE,
428: ("%4d-%4d IR=%d:%d Dist=%d\n",
429: ptree->NetStop, ptree->NetStart, ptree->NextIRNet,
430: ptree->NextIRNode, (short)ptree->NetDist));
431: } else {
432: dPrintf(D_M_RTMP_LOW, D_L_VERBOSE,
433: ("%04d : * FREE ENTRY\n", i));
434: }
435: ptree++;
436: i++;
437: }
438: }
439:
440: /*
441: * prepare the indexing of the free entries in the RTMP table
442: */
443:
444: rt_table_init()
445: {
446: short i;
447:
448: if ((RT_table = (RT_entry *)_MALLOC(sizeof(RT_entry)*RT_maxentry,
449: M_RTABLE, M_NOWAIT)) == NULL) {
450: dPrintf(D_M_RTMP, D_L_WARNING,
451: ("rtmptable: Can't allocate RT_table\n"));
452: return (ENOMEM);
453: }
454: if ((ZT_table = (ZT_entry *)_MALLOC(sizeof(ZT_entry)*ZT_maxentry,
455: M_RTABLE, M_NOWAIT)) == NULL) {
456: dPrintf(D_M_RTMP, D_L_WARNING,
457: ("rtmptable: Can't allocate ZT_table\n"));
458: return (ENOMEM);
459: }
460: dPrintf(D_M_RTMP, D_L_STARTUP, ("rt_table_init called\n"));
461: bzero(&RT_table[0], sizeof(RT_entry)* RT_maxentry);
462: for (i= 1 ; i < RT_maxentry ; i++) {
463: (&RT_table[i-1])->right = &RT_table[i];
464: }
465: RT_table_freelist = &RT_table[0];
466:
467: at_state.flags |= AT_ST_RT_CHANGED;
468: at_state.flags |= AT_ST_ZT_CHANGED;
469: bzero(&RT_table_start, sizeof(RT_entry));
470:
471: /* also clean up the ZIP table */
472:
473: bzero(&ZT_table[0], sizeof(ZT_entry)* ZT_maxentry);
474: ErrorRTMPoverflow = 0;
475: ErrorZIPoverflow = 0;
476: return(0);
477: }
478:
479: /*
480: * zt_add_zone: add a zone name in the zone table.
481: */
482:
483: zt_add_zone(name, length)
484: char *name;
485: short length;
486: {
487: at_nvestr_t zname;
488: bcopy(name, &zname.str, length);
489: zname.len = length;
490: return (zt_add_zonename(&zname));
491: }
492:
493: /*
494: * zt_add_zonename: add a zone name in the zone table.
495: */
496:
497: int zt_add_zonename(zname)
498: at_nvestr_t *zname;
499: {
500: register short res,i;
501: register unsigned int s;
502:
503: if (res = zt_find_zname(zname))
504: return(res);
505:
506: ATDISABLE(s, ddpinp_lock);
507: for (i = 0; i < ZT_maxentry ; i++) {
508: if (ZT_table[i].ZoneCount == 0 && ZT_table[i].Zone.len == 0) {/* free entry */
509: ZT_table[i].Zone = *zname;
510: dPrintf(D_M_RTMP, D_L_VERBOSE, ("zt_add_zonename: zone #%d %s len=%d\n",
511: i, ZT_table[i].Zone.str, ZT_table[i].Zone.len));
512: at_state.flags |= AT_ST_ZT_CHANGED;
513: ATENABLE(s, ddpinp_lock);
514: return(i+1);
515: }
516: }
517: ATENABLE(s, ddpinp_lock);
518: /* table full... */
519: return (ZT_MAXEDOUT);
520: }
521:
522: /* Adjust zone counts for a removed network entry.
523: * If the ZoneCount of a zone reaches zero, delete the zone from the zone table
524: */
525: void zt_remove_zones(zmap)
526: u_char *zmap;
527: {
528:
529: register u_short i,j, Index;
530:
531: for (i=0; i< ZT_BYTES ; i++) {
532:
533: if (zmap[i]) {
534: for (j=0; j < 8 ; j++)
535: if ((zmap[i] << j) & 0x80) {
536: Index = i*8 + j; /* get the index in ZT */
537: /* 1-23-97 this routine caused a crash once, presumably
538: zmap bits beyond ZT_table size got set somehow.
539: prevent that here
540: */
541: if (Index >= ZT_maxentry) {
542: dPrintf(D_M_RTMP, D_L_ERROR,
543: ("zt_remove_zones: index (%d) GT ZT_maxentry (%d) (zmap:%d)\n",
544: Index,ZT_maxentry,i));
545: return;
546: }
547: dPrintf(D_M_RTMP, D_L_VERBOSE,
548: ("zt_remove_zones: zone #%d %s was=%d\n", Index,
549: ZT_table[Index].Zone.str, ZT_table[Index].ZoneCount));
550: if (ZT_table[Index].ZoneCount > 0)
551: ZT_table[Index].ZoneCount--;
552: if (ZT_table[Index].ZoneCount == 0)
553: ZT_table[Index].Zone.len = 0;
554: at_state.flags |= AT_ST_ZT_CHANGED;
555: }
556: }
557: }
558: }
559:
560:
561:
562: /*
563: * zt_compute_hash: compute hash index from the zone name string
564: */
565:
566: short zt_compute_hash(zname)
567: at_nvestr_t *zname;
568: {
569: register u_short checksum=0, i;
570: register char c1;
571:
572: /* apply the upper name + DDP checksum algorithm */
573:
574: for (i= 0 ; i < zname->len; i++) {
575:
576: /* upperize the character */
577:
578: c1 = zname->str[i];
579: if (c1 >= 'a' && c1 <= 'z')
580: c1 += 'A' - 'a';
581: if (c1 & 0x80)
582: c1 = upshift8(c1);
583:
584: /* DDP Checksum */
585:
586: checksum += c1;
587: checksum = ((checksum & 0x8000) ?
588: (checksum << 1 | 1) : (checksum << 1));
589: }
590:
591: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("zt_comphash: value computed for zone=%s h=%d\n",
592: zname->str, checksum));
593:
594: if (checksum)
595: return (checksum);
596: else
597: return (0xffff);
598:
599: }
600:
601: /*
602: * zt_upper_zname: translate the name string into uppercase
603: */
604:
605: void zt_upper_zname(zname)
606: at_nvestr_t *zname;
607: {
608: register short i;
609: register char c1;
610:
611: for (i= 0 ; i < zname->len; i++) {
612:
613: c1 = zname->str[i];
614: if (c1 >= 'a' && c1 <= 'z')
615: c1 += 'A' - 'a';
616: if (c1 & 0x80)
617: c1 = upshift8(c1);
618:
619: zname->str[i] = c1;
620: }
621: }
622:
623: /*
624: * zt_get_zmcast: calcularte the zone multicast address for a
625: * given zone name.
626: * Returns the result in "buffer"
627: */
628:
629: zt_get_zmcast(ifID, zname, buffer)
630: at_ifaddr_t *ifID; /* we want to know the media type */
631: at_nvestr_t *zname; /* source name for multicast address */
632: char *buffer; /* resulting Zone Multicast address */
633: {
634: u_short h;
635:
636: h = zt_compute_hash(zname);
637:
638: /*
639: * Find a nice way to decide if it is TokenRing or Ethernet for
640: * the Multicast address computation....
641: */
642:
643: if (ifID->aa_ifp->if_type != IFT_ISO88025) { /* token ring */
644:
645: /* Ethernet case */
646:
647: buffer[0] = 0x09;
648: buffer[1] = 0x00;
649: buffer[2] = 0x07;
650: /* no router, use cable multicast */
651: if (MULTIHOME_MODE && ifID->ifRouterState == NO_ROUTER ) {
652: buffer[3] = buffer[4] = buffer[5] = 0xff;
653: }
654: else {
655: buffer[3] = 0x00;
656: buffer[4] = 0x00;
657: buffer[5] = h % 0xFD;
658: }
659: dPrintf(D_M_RTMP_LOW, D_L_ROUTING, ("zt_get_multi: computed for h=%d %x %x\n",
660: h, *(u_int *)&buffer[0], *(u_short *)&buffer[4]));
661:
662: return(6); /* returns Multicast address length */
663:
664: }
665: else {
666: /* assume it is token ring: note for the magic number computation,
667: * first see Inside Mac Page 3-10, there is 20 multicast addresses
668: * for TLAP, and they are from 0xC000 0000 0008 00 to 0xC000 0200 0000 00
669: */
670: buffer[0] = 0xC0;
671: buffer[1] = 0x00;
672: *(u_int *)&buffer[2] = 1 << ((h % 19) + 11);
673: dPrintf(D_M_RTMP, D_L_WARNING,("zt_get_multi: BROAD not found forr h=%d \n",
674: h));
675: return(6);
676: }
677:
678:
679:
680: }
681:
682: /*
683: * zt_ent_zindex: return the first zone index found in the zone map
684: * return the entry number+1 in the Zone Table, or zero if not found
685: */
686:
687: int zt_ent_zindex(zmap)
688: u_char *zmap;
689: {
690: u_short i,j;
691:
692:
693: for (i = 0 ; i < ZT_BYTES ; i++)
694:
695: if (zmap[i])
696: for (j = 0 ; j < 8 ; j++)
697: if ((zmap[i] << j) & 0x80)
698: return (8*i + j +1);
699:
700: return (0);
701: }
702: /*
703: * zt_ent_zcount: count the number of actives zone for a routing entry
704: */
705:
706: zt_ent_zcount(ent)
707: RT_entry *ent;
708: {
709: register u_char *zmap;
710: register u_short i,j;
711: register int zone_count = 0 ;
712: register unsigned int s;
713:
714: ATDISABLE(s, ddpinp_lock);
715:
716: if (!RT_ALL_ZONES_KNOWN(ent)) {
717: ATENABLE(s, ddpinp_lock);
718: return (0);
719: }
720: zmap = ent->ZoneBitMap;
721:
722: for (i = 0 ; i < ZT_BYTES ; i++) {
723:
724: if (*zmap)
725:
726: for (j = 0 ; j < 8 ; j++)
727: if ((*zmap << j) & 0x80)
728: zone_count++;
729: zmap++;
730: }
731:
732: ATENABLE(s, ddpinp_lock);
733: return (zone_count);
734: }
735:
736: /*
737: * zt_find_zname: match a zone name in the zone table and return the entry if found
738: */
739: zt_find_zname(zname)
740: at_nvestr_t *zname;
741: {
742: register short i, j, found;
743: register char c1, c2;
744: register unsigned int s;
745:
746:
747: if (!zname->len)
748: return(0);
749:
750: ATDISABLE(s, ddpinp_lock);
751: for (i = 0 ; i < ZT_maxentry ; i++) {
752: if (!ZT_table[i].ZoneCount || zname->len != ZT_table[i].Zone.len)
753: continue;
754:
755: found = 1; /* did we get the right one? */
756:
757: for (j = 0 ; j < zname->len ; j++) {
758: c1 = zname->str[j];
759: c2 = ZT_table[i].Zone.str[j];
760: if (c1 >= 'a' && c1 <= 'z')
761: c1 += 'A' - 'a';
762: if (c2 >= 'a' && c2 <= 'z')
763: c2 += 'A' - 'a';
764: if (c1 & 0x80)
765: c1 = upshift8(c1);
766: if (c2 & 0x80)
767: c2 = upshift8(c2);
768: if (c1 != c2) {
769: found = 0;
770: break;
771: }
772: }
773:
774: if (found) {
775: ATENABLE(s, ddpinp_lock);
776: return (i+1);
777: }
778: }
779:
780: ATENABLE(s, ddpinp_lock);
781: return(0);
782: }
783:
784:
785: /*
786: * zt_set_zmap: set a bit for the corresponding zone map in an entry bitmap
787: */
788: void zt_set_zmap(znum, zmap)
789: u_short znum;
790: char *zmap;
791: {
792: register u_short num = znum -1;
793: register unsigned int s;
794:
795: ATDISABLE(s, ddpinp_lock);
796: if (!(zmap[num >> 3] & 0x80 >> (num % 8))) {
797: zmap[num >> 3] |= 0x80 >> (num % 8);
798: ZT_table[num].ZoneCount++;
799: }
800: ATENABLE(s, ddpinp_lock);
801: }
802:
803:
804: /*
805: * zt_clr_zmap: clear a bit for the corresponding zone map in an entry bitmap
806: */
807: void zt_clr_zmap(znum, zmap)
808: u_short znum;
809: char *zmap;
810: {
811: register u_short num = znum -1;
812: register unsigned int s;
813:
814: ATDISABLE(s, ddpinp_lock);
815: if (zmap[num >> 3] & 0x80 >> (num % 8)) {
816: zmap[num >> 3] ^= 0x80 >> (num % 8);
817: ZT_table[num].ZoneCount--;
818: }
819: ATENABLE(s, ddpinp_lock);
820: }
821:
822:
823: /*
824: * routing_needed :
825: * This function performs the actual lookup and forward of packets
826: * send to the box for routing.
827: *
828: * The destination network is looked up in our tables, and if we
829: * know the next IR to send the packet to, we forward the packet
830: * on the right port.
831: *
832: * If the destination is unknown, we simply dump the packet.
833: */
834:
835: void routing_needed(mp, ifID, bypass)
836: gbuf_t *mp;
837: at_ifaddr_t *ifID;
838: char bypass; /* set by special socket handlers */
839: {
840:
841: register at_ddp_t *ddp;
842: register int msgsize;
843: register RT_entry *Entry;
844: register gbuf_t *tmp_m;
845:
846: /* first check the interface is up and forwarding */
847:
848: if (!ifID) {
849: dPrintf(D_M_RTMP, D_L_WARNING,
850: ("routing_needed: non valid IFID!\n"));
851: gbuf_freel(mp);
852: return;
853: }
854: if ((ifID->ifRoutingState < PORT_ONLINE)) {
855: dPrintf(D_M_RTMP, D_L_WARNING,
856: ("routing_needed: port %d not online yet\n",
857: ifID->ifPort));
858: gbuf_freel(mp);
859: return;
860: }
861:
862: ddp = (at_ddp_t *)gbuf_rptr(mp);
863: msgsize = DDPLEN_VALUE(ddp);
864: for (tmp_m = gbuf_next(mp); tmp_m; tmp_m = gbuf_next(tmp_m))
865: msgsize += DDPLEN_VALUE(((at_ddp_t *)gbuf_rptr(tmp_m)));
866:
867: if (ddp->hopcount++ > 15) {
868: dPrintf(D_M_RTMP, D_L_WARNING,
869: ("routing_needed: drop packet for %d:%d, hopcount too high\n",
870: NET_VALUE(ddp->dst_net), ddp->dst_node));
871: gbuf_freel(mp);
872: snmpStats.dd_hopCount++;
873: return; /* was return(1); */
874: }
875:
876: if ((Entry = rt_blookup(NET_VALUE(ddp->dst_net)))) {
877:
878: dPrintf(D_M_RTMP_LOW, D_L_ROUTING,
879: ("routing_needed: FOUND for %d.%d p=%d to %d.%d \n",
880: NET_VALUE(ddp->dst_net), ddp->dst_node, ifID->ifPort,
881: Entry->NextIRNet, Entry->NextIRNode));
882:
883: /* somehow, come to that point... */
884:
885: ifID->ifStatistics.fwdPkts++;
886: ifID->ifStatistics.fwdBytes += msgsize;
887:
888: if (Entry->NetDist) /* net not directly connected */
889: ddp_router_output(mp, ifID_table[Entry->NetPort], AT_ADDR,
890: Entry->NextIRNet, Entry->NextIRNode, 0);
891: else {/* we are directly on this net */
892:
893: /* we want to avoid duplicating broadcast packet on the same net,
894: * but special sockets handlers are ok to do that (mainly for
895: * for loopback purpose). So, if the "bypass" flag is set, we don't
896: * check for that test... [Problem was "movietalk"].
897: */
898:
899: if (bypass || ifID_table[Entry->NetPort] != ifID)
900: ddp_router_output(mp, ifID_table[Entry->NetPort], AT_ADDR,
901: NET_VALUE(ddp->dst_net), ddp->dst_node, 0);
902: else {
903: dPrintf(D_M_RTMP, D_L_ROUTING,
904: ("routing_needed: bad loopback for add %d.%d from port %d (%d.%d)\n",
905: NET_VALUE(ddp->dst_net), ddp->dst_node, ifID->ifPort,
906: NET_VALUE(ddp->src_net), ddp->src_node));
907: ifID->ifStatistics.droppedPkts++;
908: ifID->ifStatistics.droppedBytes += msgsize;
909:
910: gbuf_freel(mp);
911: return; /* was return (2); */
912: }
913:
914:
915: }
916: }
917: else {
918: dPrintf(D_M_RTMP, D_L_ROUTING,
919: ("routing_needed: NOT FOUND for add %d.%d from port %d our %d.%d\n",
920: NET_VALUE(ddp->dst_net), ddp->dst_node, ifID->ifPort,
921: ifID_home->ifThisNode.s_net,
922: ifID_home->ifThisNode.s_node));
923:
924: ifID->ifStatistics.droppedPkts++;
925: ifID->ifStatistics.droppedBytes += msgsize;
926: snmpStats.dd_noRoutes++;
927:
928: gbuf_freel(mp);
929: return; /* was return (2); */
930:
931: }
932: /* return(0); */
933: } /* routing_needed */
934:
935: ZT_entryno *zt_getNextZone(first)
936: int first;
937: /* a call made with first = TRUE returns the first valid entry in
938: the ZT_table, if first != TRUE, then then each call returns the
939: next valid entry in the table. The next call after the last
940: valid entry was read returns NULL
941: */
942: {
943: int i;
944: static int idx=0;
945: static ZT_entryno zte;
946:
947: if (!ZT_table)
948: return NULL;
949:
950: if (first)
951: idx=0;
952:
953: for (i=idx; i<ZT_maxentry; i++) {
954: if (ZT_table[i].ZoneCount)
955: break;
956: }
957: if (i<ZT_maxentry) {
958: idx = i+1;
959: zte.zt = ZT_table[i];
960: zte.entryno = i;
961: return(&zte);
962: }
963: else
964: return(NULL);
965: }
966:
967: RT_entry *rt_getNextRoute(first)
968: int first;
969:
970: /* a call made with first = TRUE returns the first valid entry in
971: the RT_table, if first != TRUE, then then each call returns the
972: next valid entry in the table. The next call after the last
973: valid entry was read returns NULL
974: */
975:
976: {
977: int i;
978: static int idx=0;
979:
980: if (!RT_table)
981: return(NULL);
982:
983: if (first)
984: idx=0;
985:
986: for (i=idx; i<RT_maxentry; i++) {
987: if (RT_table[i].EntryState != RTE_STATE_UNUSED)
988: break;
989: }
990: if (i<RT_maxentry) {
991: idx = i+1;
992: return(&RT_table[i]);
993: }
994: else
995: return(NULL);
996: }
997:
998:
999: getRtmpTableSize()
1000: {
1001: register int i;
1002: register RT_entry *rt;
1003: static int size=0;
1004:
1005: if(!(at_state.flags &AT_ST_RT_CHANGED))
1006: return(size);
1007:
1008: for (i=RT_maxentry,rt = &RT_table[RT_maxentry-1]; i; i--,rt--)
1009: if (rt->EntryState != RTE_STATE_UNUSED) {
1010: size = i;
1011: return(i);
1012: }
1013: return(0);
1014: }
1015:
1016: getZipTableSize()
1017: {
1018: register int i;
1019: register ZT_entry *zt;
1020: static int size=0;
1021:
1022: if (!(at_state.flags & AT_ST_ZT_CHANGED))
1023: return(size);
1024:
1025: for (i=ZT_maxentry,zt = &ZT_table[ZT_maxentry-1]; i; i--,zt--)
1026: if (zt->ZoneCount) {
1027: size = i;
1028: return(i);
1029: }
1030: return(0);
1031: }
1032:
1033: getRtmpTable(d,s,c)
1034: RT_entry *d; /* destination */
1035: int s; /* starting entry */
1036: int c; /* # entries to copy */
1037: {
1038: register int i,n=0;
1039: register RT_entry *rt;
1040:
1041: for(i=s,rt=&RT_table[s]; i<RT_maxentry && n<c; rt++,i++)
1042: if (rt->EntryState != RTE_STATE_UNUSED) {
1043: *d++ = *rt;
1044: n++;
1045: }
1046: }
1047:
1048: getZipTable(d,s,c)
1049: ZT_entry *d; /* destination */
1050: int s; /* starting entry */
1051: int c; /* # entries to copy */
1052: {
1053:
1054: bcopy(&ZT_table[s], d, c*sizeof(ZT_entry));
1055: }
1056:
1057: at_nvestr_t *getRTRLocalZone(ifz)
1058: if_zone_t *ifz;
1059: {
1060: char *zmap;
1061: RT_entry *route;
1062: int i, j, index;
1063: int zcnt=0; /* zone we're pointing to in the list */
1064: char zonesChecked[ZT_BYTES];
1065: at_ifaddr_t *ifID;
1066:
1067: if (ifz->ifzn.zone < 0) {
1068: return((at_nvestr_t*)NULL);
1069: }
1070: bzero(zonesChecked,sizeof(zonesChecked));
1071: TAILQ_FOREACH(ifID, &at_ifQueueHd, aa_link) {
1072: if (!(route = rt_blookup(ifID->ifThisNode.s_net))) {
1073: return((at_nvestr_t*)NULL);
1074: }
1075: zmap=route->ZoneBitMap;
1076: dPrintf(D_M_RTMP_LOW, D_L_USR1,
1077: ("getRTRLocal: i/f %s, net:%d\n",ifID->ifName,
1078: ifID->ifThisNode.s_net));
1079: for (i = 0 ; i < ZT_BYTES; i++) {
1080: if (zmap[i]) {
1081: for (j = 0; j < 8 ; j++)
1082: if ( (zmap[i] & (0x80 >> j)) &&
1083: !(zonesChecked[i] & (0x80 >> j))
1084: ) {
1085: zonesChecked[i] |= (0x80 >> j);
1086: if (ifz->ifzn.zone == zcnt) {
1087: index = i * 8 + j;
1088: getIfUsage(index,ifz->usage);
1089: ifz->ifzn.ifnve = ZT_table[index].Zone;
1090: dPrintf(D_M_RTMP_LOW, D_L_USR1,
1091: ("getRTRLocal:zmap:%8x zcnt:%d usage:%8x\n",
1092: *(int*)zmap,zcnt,*(int*)ifz->usage));
1093: ifz->index = index+1;
1094: return(&ZT_table[index].Zone);
1095: }
1096: zcnt++;
1097: }
1098: }
1099: }
1100: }
1101: dPrintf(D_M_RTMP_LOW, D_L_USR1,
1102: ("getRTRLocal: returning NULL last ent:%d net:%d zmap:%08x\n",
1103: (ifID ? ifID->ifPort : 0),
1104: (ifID ? ifID->ifThisNode.s_net : 0),*(int*)zmap));
1105: ifz->ifzn.ifnve.len = 0;
1106: return((at_nvestr_t*)NULL);
1107: } /* getRTRLocalZone */
1108:
1109: void getIfUsage(zone, ifs_in_zone)
1110: int zone;
1111: char *ifs_in_zone;
1112:
1113: /* sets a "1" in each element of the char array for each I/F in the
1114: requested zone. The char array has a 1:1 correspondence with the
1115: ifID_table. Zone is assumed to be valid and local, so if we're in
1116: single port mode, we'll set the home port and thats it.
1117: */
1118: {
1119: u_int zmi; /* zone map index for zone */
1120: u_char zmb; /* zone map bit mask for zone */
1121: RT_entry *route;
1122: int cnt=0;
1123: at_ifaddr_t *ifID;
1124:
1125: if (!MULTIPORT_MODE) {
1126: ifs_in_zone[0] = 1;
1127: return;
1128: }
1129: bzero(ifs_in_zone,IF_TOTAL_MAX);
1130: zmi = zone>>3;
1131: zmb = 0x80>>(zone % 8);
1132: dPrintf(D_M_NBP_LOW, D_L_USR3, ("get_ifs znum:%d zmi%d zmb:%x\n",
1133: zone, zmi, zmb));
1134: TAILQ_FOREACH(ifID, &at_ifQueueHd, aa_link) {
1135: if (!(route = rt_blookup(ifID->ifThisNode.s_net)))
1136: return;
1137: if (route->ZoneBitMap[zmi] & zmb) {
1138: dPrintf(D_M_NBP_LOW, D_L_USR3, ("zone in port %d \n",
1139: route->NetPort));
1140: ifs_in_zone[route->NetPort] = 1;
1141: cnt++;
1142: }
1143: }
1144: return;
1145: } /* getIfUsage */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.