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