![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddp_r_zip.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_r_zip.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: * Copyright (c) 1988-1998 Apple Computer, Inc. ! 24: */ ! 25: /* ! 26: * 0.01 05/12/94 Laurent Dumont Creation ! 27: * ! 28: * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX. ! 29: */ ! 30: /* ! 31: * ! 32: * Router ZIP protocol functions: ! 33: * ! 34: * This file contains Routing specifics to handle ZIP requests and responses ! 35: * sent and received by a router node. ! 36: * ! 37: * The entry point for the zip input in ddp is valid only when we're ! 38: * running in router mode. ! 39: * ! 40: */ ! 41: ! 42: #include <sys/errno.h> ! 43: #include <sys/types.h> ! 44: #include <sys/param.h> ! 45: #include <machine/spl.h> ! 46: #include <sys/systm.h> ! 47: #include <sys/kernel.h> ! 48: #include <sys/proc.h> ! 49: #include <sys/filedesc.h> ! 50: #include <sys/fcntl.h> ! 51: #include <sys/mbuf.h> ! 52: #include <sys/ioctl.h> ! 53: #include <sys/malloc.h> ! 54: #include <sys/socket.h> ! 55: #include <sys/socketvar.h> ! 56: ! 57: #include <net/if.h> ! 58: #include <net/if_types.h> ! 59: ! 60: #include <netat/sysglue.h> ! 61: #include <netat/appletalk.h> ! 62: #include <netat/at_var.h> ! 63: #include <netat/lap.h> ! 64: #include <netat/ddp.h> ! 65: #include <netat/nbp.h> ! 66: #include <netat/zip.h> ! 67: #include <netat/at_pcb.h> ! 68: #include <netat/atp.h> ! 69: #include <netat/routing_tables.h> ! 70: #include <netat/debug.h> ! 71: ! 72: static void zip_reply_to_getmyzone(); ! 73: extern int at_reg_mcast(), at_unreg_mcast(); ! 74: ! 75: /* globals */ ! 76: extern at_ifaddr_t *ifID_table[], *ifID_home; ! 77: extern short ErrorZIPoverflow; ! 78: ! 79: /********************************************************************** ! 80: * Remarks : ! 81: * ZIP is implemented as a "peer" of DDP, so the packets coming in ! 82: * to ZIP have the same headers as those coming in to DDP {ddp...}. ! 83: * Same applies to outgoing packets. Also, unlike DDP, ZIP assumes ! 84: * that an incoming packet is in a contiguous gbuf_t. ! 85: * ! 86: **********************************************************************/ ! 87: ! 88: static int netinfo_reply_pending; ! 89: static void zip_netinfo_reply(at_x_zip_t *, at_ifaddr_t *); ! 90: static void zip_getnetinfo(at_ifaddr_t *); ! 91: static void send_phony_reply(gbuf_t *); ! 92: ! 93: /* ! 94: * zip_send_getnetinfo_reply: we received a GetNetInfo packet, we need to reply ! 95: * with the right information for the port. ! 96: */ ! 97: static void zip_send_getnetinfo_reply(m, ifID) ! 98: register gbuf_t *m; ! 99: register at_ifaddr_t *ifID; ! 100: { ! 101: at_nvestr_t *zname; ! 102: gbuf_t *m_sent; ! 103: at_ddp_t *ddp, *ddp_sent; ! 104: short ZoneNameProvided = FALSE; ! 105: short RequestIsBroadcasted = FALSE; ! 106: u_short znumber, len, packet_length, size, status; ! 107: RT_entry *Entry; ! 108: char GNIReply[128]; ! 109: ! 110: ddp = (at_ddp_t *)gbuf_rptr(m); ! 111: ! 112: /* access the Zone Name info part of the GetNetInfo Request */ ! 113: ! 114: zname = (at_nvestr_t *)(gbuf_rptr(m) + DDP_X_HDR_SIZE + 6); ! 115: ! 116: if (zname->len > ZIP_MAX_ZONE_LENGTH) { ! 117: dPrintf(D_M_ZIP, D_L_WARNING, ! 118: ("zip_s_gni_r: zone len too long l=%d ddplen=%d\n", ! 119: zname->len, DDPLEN_VALUE(ddp))); ! 120: return; ! 121: } ! 122: ! 123: ! 124: if (zname->len) ! 125: ZoneNameProvided = TRUE; ! 126: ! 127: GNIReply[0] = ZIP_NETINFO_REPLY; ! 128: GNIReply[1] = ZIP_ZONENAME_INVALID; ! 129: ! 130: /* check if we are the originator is in the cable range for this interface */ ! 131: ! 132: if ((NET_VALUE(ddp->src_net) < CableStart || NET_VALUE(ddp->src_net) > CableStop) && ! 133: (NET_VALUE(ddp->dst_net) == 0 && ddp->dst_node == 0xff)) { ! 134: RequestIsBroadcasted = TRUE; ! 135: } ! 136: Entry = rt_blookup(CableStop); ! 137: ! 138: if (Entry != NULL && RT_ALL_ZONES_KNOWN(Entry)) { /* this net is well known... */ ! 139: ! 140: GNIReply[2] = (Entry->NetStart & 0xFF00) >> 8; ! 141: GNIReply[3] = (Entry->NetStart & 0x00FF); ! 142: GNIReply[4] = (Entry->NetStop & 0xFF00) >> 8; ! 143: GNIReply[5] = (Entry->NetStop & 0x00FF); ! 144: ! 145: /* copy the zone name found in the request */ ! 146: ! 147: GNIReply[6] = zname->len; ! 148: bcopy(&zname->str, &GNIReply[7], zname->len); ! 149: ! 150: ! 151: if (znumber = zt_find_zname(zname)) { ! 152: ! 153: if (ZT_ISIN_ZMAP((znumber), Entry->ZoneBitMap)) { ! 154: ! 155: GNIReply[1] = 0; /* Zone Valid */ ! 156: ! 157: if (len = zt_get_zmcast(ifID, zname, &GNIReply[8+zname->len])) ! 158: GNIReply[7+zname->len] = len; ! 159: else { ! 160: GNIReply[1] |= ZIP_USE_BROADCAST; ! 161: GNIReply[7+zname->len] = 0; /* multicast address length */ ! 162: } ! 163: packet_length = 8 + zname->len + len; ! 164: } ! 165: } ! 166: ! 167: } ! 168: ! 169: else { /* should not happen, we are supposed to know our net */ ! 170: dPrintf(D_M_ZIP, D_L_WARNING, ("zip_s_gni_r: Don't know about our zone infos!!!\n")); ! 171: return; ! 172: } ! 173: ! 174: if (zt_ent_zcount(Entry) == 1) ! 175: GNIReply[1] |= ZIP_ONE_ZONE; ! 176: ! 177: if (GNIReply[1] & ZIP_ZONENAME_INVALID) { ! 178: ! 179: short Index = ifID->ifDefZone; ! 180: ! 181: if (Index <= 0 || Index >= ZT_MAXEDOUT) { ! 182: dPrintf(D_M_ZIP, D_L_WARNING, ! 183: ("zip_s_gni_r: Invalid starting index =%d port%d\n", ! 184: Index, ifID->ifPort)); ! 185: return; ! 186: } ! 187: ! 188: ! 189: Index--; ! 190: ! 191: if (len = zt_get_zmcast(ifID, &ZT_table[Index].Zone, &GNIReply[8+zname->len])) ! 192: GNIReply[7+zname->len] = len; ! 193: else { ! 194: GNIReply[1] |= ZIP_USE_BROADCAST; ! 195: GNIReply[7+zname->len] = 0; /* multicast address length */ ! 196: } ! 197: ! 198: packet_length = 7 + zname->len + len; ! 199: ! 200: /* in the case the zone name asked for in the request was invalid, we need ! 201: * to copy the good default zone for this net ! 202: */ ! 203: ! 204: GNIReply[packet_length + 1] = ZT_table[Index].Zone.len; ! 205: bcopy(&ZT_table[Index].Zone.str, &GNIReply[packet_length + 2], ! 206: ZT_table[Index].Zone.len); ! 207: packet_length = packet_length +2 + ZT_table[Index].Zone.len; ! 208: } ! 209: ! 210: ! 211: /* ! 212: * we're finally ready to send out the GetNetInfo Reply ! 213: * ! 214: */ ! 215: ! 216: ! 217: size = DDP_X_HDR_SIZE + packet_length; ! 218: if ((m_sent = gbuf_alloc(AT_WR_OFFSET+size, PRI_HI)) == NULL) { ! 219: return; /* was return(ENOBUFS); */ ! 220: } ! 221: ! 222: gbuf_rinc(m_sent,AT_WR_OFFSET); ! 223: gbuf_wset(m_sent,size); ! 224: ddp_sent = (at_ddp_t *)(gbuf_rptr(m_sent)); ! 225: ! 226: /* Prepare the DDP header */ ! 227: ! 228: ddp_sent->unused = ddp_sent->hopcount = 0; ! 229: UAS_ASSIGN(ddp->checksum, 0); ! 230: DDPLEN_ASSIGN(ddp_sent, size); ! 231: NET_ASSIGN(ddp_sent->src_net, ifID->ifThisNode.s_net); ! 232: ddp_sent->src_node = ifID->ifThisNode.s_node; ! 233: ddp_sent->src_socket = ZIP_SOCKET; ! 234: ddp_sent->dst_socket = ddp->src_socket; ! 235: ! 236: if (RequestIsBroadcasted) { /* if this was a broadcast, must respond from that */ ! 237: ! 238: NET_ASSIGN(ddp_sent->dst_net, 0); ! 239: ddp_sent->dst_node = 0xFF; ! 240: } ! 241: else { ! 242: ! 243: NET_NET(ddp_sent->dst_net, ddp->src_net); ! 244: ddp_sent->dst_node = ddp->src_node; ! 245: } ! 246: ddp_sent->type = DDP_ZIP; ! 247: ! 248: bcopy(&GNIReply, &ddp_sent->data, packet_length); ! 249: ! 250: dPrintf(D_M_ZIP_LOW, D_L_ROUTING, ! 251: ("zip_s_gni_r: send to %d:%d port#%d pack_len=%d\n", ! 252: NET_VALUE(ddp_sent->dst_net), ddp_sent->dst_node, ! 253: ifID->ifPort, packet_length)); ! 254: if ((status = ! 255: ddp_router_output(m_sent, ifID, AT_ADDR, ! 256: NET_VALUE(ddp_sent->dst_net), ddp_sent->dst_node, 0))) { ! 257: dPrintf(D_M_ZIP, D_L_ERROR, ! 258: ("zip_s_gni_r: ddp_router_output returns =%d\n", status)); ! 259: return; /* was return(status); */ ! 260: } ! 261: } /* zip_send_getnetinfo_reply */ ! 262: ! 263: ! 264: /* ! 265: * build_ZIP_reply_packet: is used to create and send a DDP packet and use the ! 266: * provided buffer as a ZIP reply. This is used by zip_send_ext_reply_to_query ! 267: * and zip_send_reply_to_query for sending their replies to ZIP queries. ! 268: */ ! 269: gbuf_t *prep_ZIP_reply_packet(m, ifID) ! 270: register gbuf_t *m; /* this is the original zip query */ ! 271: register at_ifaddr_t *ifID; ! 272: { ! 273: register gbuf_t *m_sent; ! 274: register at_ddp_t *ddp, *src_ddp; ! 275: ! 276: /* access the source Net and Node informations */ ! 277: ! 278: src_ddp = (at_ddp_t *)gbuf_rptr(m); ! 279: ! 280: if ((m_sent = gbuf_alloc (AT_WR_OFFSET+1024, PRI_HI)) == NULL) { ! 281: return((gbuf_t *)NULL); ! 282: } ! 283: gbuf_rinc(m_sent,AT_WR_OFFSET); ! 284: gbuf_wset(m_sent,DDP_X_HDR_SIZE); ! 285: ddp = (at_ddp_t *)(gbuf_rptr(m_sent)); ! 286: ! 287: /* Prepare the DDP header */ ! 288: ! 289: ddp->unused = ddp->hopcount = 0; ! 290: UAS_ASSIGN(ddp->checksum, 0); ! 291: ! 292: NET_ASSIGN(ddp->src_net, ifID->ifThisNode.s_net); ! 293: ddp->src_node = ifID->ifThisNode.s_node; ! 294: ddp->src_socket = ZIP_SOCKET; ! 295: ! 296: ddp->dst_socket = src_ddp->src_socket; ! 297: NET_NET(ddp->dst_net, src_ddp->src_net); ! 298: ddp->dst_node = src_ddp->src_node; ! 299: ! 300: ddp->type = DDP_ZIP; ! 301: ! 302: return(m_sent); ! 303: } ! 304: /* ! 305: * zip_send_ext_reply_to_query: this function deals with ZIP Queries for extended nets. ! 306: * When we recognize an extended net (that might have several zone name associated with ! 307: * it), we send A SEPARATE ZIP reply for that network. This is called from the ! 308: * regular zip_send_reply_to_query, that just deals with non-ext nets. ! 309: */ ! 310: ! 311: static void zip_send_ext_reply_to_query(mreceived, ifID, Entry, NetAsked) ! 312: register gbuf_t *mreceived; ! 313: register at_ifaddr_t *ifID; ! 314: RT_entry *Entry; /* info about the network we're looking for */ ! 315: u_short NetAsked; ! 316: { ! 317: register gbuf_t *m; ! 318: register at_ddp_t *ddp; ! 319: short i, j, reply_length, Index, zone_count, status; ! 320: u_char *zmap; ! 321: char *ReplyBuff, *ZonesInPacket; ! 322: ! 323: zone_count = zt_ent_zcount(Entry); ! 324: zmap = Entry->ZoneBitMap; ! 325: i = ZT_BYTES -1; ! 326: ! 327: ! 328: newPacket: ! 329: ! 330: if (!(m = prep_ZIP_reply_packet (mreceived, ifID))) { ! 331: return; /* was return(ENOBUFS); */ ! 332: } ! 333: ! 334: ddp = (at_ddp_t *)(gbuf_rptr(m)); ! 335: ReplyBuff = (char *)(ddp->data); ! 336: ! 337: ! 338: *ReplyBuff++ = 8; /* ZIP function = 8 [extended reply] */ ! 339: ! 340: ZonesInPacket= ReplyBuff; ! 341: *ZonesInPacket= 0; ! 342: ReplyBuff ++; ! 343: reply_length = 2; /* 1st byte is ZIP reply code, 2nd is network count */ ! 344: j= 0; ! 345: ! 346: /* For all zones, we check if they belong to the map for that Network */ ! 347: ! 348: for (; i >= 0; i--) { ! 349: ! 350: /* find the zones defined in this entry bitmap */ ! 351: ! 352: if (zmap[i]) { ! 353: for (; j < 8 ; j++) ! 354: if (zmap[i] << j & 0x80) { /* bingo */ ! 355: ! 356: Index = i*8 + j; /* zone index in zone table */ ! 357: ! 358: if (reply_length + 3 + ZT_table[Index].Zone.len > DDP_MAX_DATA) { ! 359: ! 360: /* we need to send the packet before, this won't fit... */ ! 361: ! 362: zone_count -= *ZonesInPacket; ! 363: ! 364: DDPLEN_ASSIGN(ddp, reply_length + DDP_X_HDR_SIZE); ! 365: gbuf_winc(m,reply_length); ! 366: if ((status = ! 367: ddp_router_output(m, ifID, AT_ADDR, ! 368: NET_VALUE(ddp->dst_net), ddp->dst_node, 0))) { ! 369: dPrintf(D_M_ZIP, D_L_ERROR, ! 370: ("zip_s_ext_repl: ddp_router_output returns =%d\n", ! 371: status)); ! 372: return; /* was return (status); */ ! 373: } ! 374: ! 375: goto newPacket; ! 376: ! 377: } ! 378: /* this should fit in this packet, build the NetNumber, ZoneLen, ! 379: * ZoneName triple ! 380: */ ! 381: ! 382: if (ZT_table[Index].Zone.len) { ! 383: *ZonesInPacket += 1; /* bump NetCount field */ ! 384: *ReplyBuff++ = (NetAsked & 0xFF00) >> 8; ! 385: *ReplyBuff++ = (NetAsked & 0x00FF) ; ! 386: *ReplyBuff++ = ZT_table[Index].Zone.len; ! 387: ! 388: bcopy(&ZT_table[Index].Zone.str, ReplyBuff, ! 389: ZT_table[Index].Zone.len); ! 390: ! 391: ReplyBuff += ZT_table[Index].Zone.len; ! 392: reply_length += ZT_table[Index].Zone.len +3; ! 393: } ! 394: ! 395: } ! 396: } ! 397: j= 0; /* reset the bit count */ ! 398: } ! 399: ! 400: /* if we have some zone info in a half-empty packet, send it now. ! 401: * Remember, for extended nets we send *at least* one Reply ! 402: */ ! 403: ! 404: if (zone_count) { ! 405: DDPLEN_ASSIGN(ddp, reply_length + DDP_X_HDR_SIZE); ! 406: gbuf_winc(m,reply_length); ! 407: if ((status = ! 408: ddp_router_output(m, ifID, AT_ADDR, ! 409: NET_VALUE(ddp->dst_net), ddp->dst_node, 0))) { ! 410: dPrintf(D_M_ZIP, D_L_ERROR, ! 411: ("zip_s_ext_reply: ddp_router_output returns =%d\n", status)); ! 412: return; /* was return (status); */ ! 413: } ! 414: } ! 415: else /* free the buffer not used */ ! 416: ! 417: gbuf_freem(m); ! 418: } /* zip_send_ext_reply_to_query */ ! 419: ! 420: /* ! 421: * zip_send_reply_to_query: we received a ZIPQuery packet, we need to reply ! 422: * with the right information for the nets requested (if we have ! 423: * the right information. ! 424: */ ! 425: static void zip_send_reply_to_query(mreceived, ifID) ! 426: register gbuf_t *mreceived; ! 427: register at_ifaddr_t *ifID; ! 428: { ! 429: register gbuf_t *m; ! 430: register at_ddp_t *ddp, *ddp_received; ! 431: RT_entry *Entry; ! 432: short i, reply_length, Index, status; ! 433: u_char network_count; ! 434: u_short *NetAsked; ! 435: char *ReplyBuff, *ZonesInPacket; ! 436: ! 437: ddp_received = (at_ddp_t *)gbuf_rptr(mreceived); ! 438: ! 439: /* access the number of nets requested in the Query */ ! 440: network_count = *((char *)(ddp_received->data) + 1); ! 441: NetAsked = (u_short *)(ddp_received->data+ 2); ! 442: ! 443: /* check the validity of the Query packet */ ! 444: ! 445: if (DDPLEN_VALUE(ddp_received) != ! 446: (2 + network_count * 2 + DDP_X_HDR_SIZE)) { ! 447: ! 448: dPrintf(D_M_ZIP, D_L_WARNING, ! 449: ("zip_s_reply_to_q: bad length netcount=%d len=%d\n", ! 450: network_count, DDPLEN_VALUE(ddp))); ! 451: return; /* was return(1); */ ! 452: } ! 453: ! 454: /* walk the Query Network list */ ! 455: /* we want to build a response with the network number followed by the zone name ! 456: * length and the zone name. If there is more than one zone per network asked, ! 457: * we repeat the network number and stick the zone length and zone name. ! 458: * We need to be carefull with the max DDP size for data. If we see that a new ! 459: * NetNum, ZoneLen, ZoneName sequence won't fit, we send the previous packet and ! 460: * begin to build a new one. ! 461: */ ! 462: ! 463: newPacket: ! 464: ! 465: if (!(m = prep_ZIP_reply_packet (mreceived, ifID))) { ! 466: return; /* was return(ENOBUFS); */ ! 467: } ! 468: ! 469: ddp = (at_ddp_t *)(gbuf_rptr(m)); ! 470: ReplyBuff = (char *)(ddp->data); ! 471: ! 472: *ReplyBuff++ = 2; /* ZIP function = 2 [Non extended reply] */ ! 473: ZonesInPacket = ReplyBuff; ! 474: *ZonesInPacket = 0; ! 475: ReplyBuff++; ! 476: reply_length = 2; /* 1st byte is ZIP reply code, 2nd is network count */ ! 477: ! 478: for (i = 0 ; i < network_count ; i ++, NetAsked++) { ! 479: Entry = rt_blookup(*NetAsked); ! 480: ! 481: if (Entry != NULL && ((Entry->EntryState & 0x0F) >= RTE_STATE_SUSPECT) && ! 482: RT_ALL_ZONES_KNOWN(Entry)) { /* this net is well known... */ ! 483: ! 484: if (Entry->NetStart == 0) { /* asking for a NON EXTENDED network */ ! 485: ! 486: if ( (Index = zt_ent_zindex(Entry->ZoneBitMap)) == 0) ! 487: continue; ! 488: ! 489: Index--; ! 490: ! 491: if (reply_length + 3 + ZT_table[Index].Zone.len > DDP_MAX_DATA) { ! 492: ! 493: /* we need to send the packet before, this won't fit... */ ! 494: ! 495: DDPLEN_ASSIGN(ddp, reply_length + DDP_X_HDR_SIZE); ! 496: gbuf_winc(m,reply_length); ! 497: ! 498: if ((status = ! 499: ddp_router_output(m, ifID, AT_ADDR, ! 500: NET_VALUE(ddp->dst_net), ! 501: ddp->dst_node, 0))) { ! 502: dPrintf(D_M_ZIP, D_L_ERROR, ! 503: ("zip_s_reply: ddp_router_output returns =%d\n", ! 504: status)); ! 505: return; /* was return (status); */ ! 506: } ! 507: ! 508: /* this is not nice, I know, but we reenter the loop with ! 509: * a packet is sent with the next network field in the Query ! 510: */ ! 511: ! 512: network_count -= i; ! 513: goto newPacket; ! 514: ! 515: } ! 516: ! 517: /* this should fit in this packet, build the NetNumber, ZoneLen, ! 518: * ZoneName triple ! 519: */ ! 520: ! 521: if (ZT_table[Index].Zone.len) { ! 522: ZonesInPacket += 1; /* bump NetCount field */ ! 523: *ReplyBuff++ = (*NetAsked & 0xFF00) >> 8; ! 524: *ReplyBuff++ = (*NetAsked & 0x00FF) ; ! 525: *ReplyBuff++ = ZT_table[Index].Zone.len; ! 526: bcopy(&ZT_table[Index].Zone.str, ReplyBuff, ! 527: ZT_table[Index].Zone.len); ! 528: ! 529: ReplyBuff += ZT_table[Index].Zone.len; ! 530: ! 531: reply_length += ZT_table[Index].Zone.len + 3; ! 532: ! 533: ! 534: } ! 535: ! 536: ! 537: } ! 538: else { /* extended network, check for multiple zone name attached ! 539: * and build a separate packet for each extended network requested ! 540: */ ! 541: ! 542: zip_send_ext_reply_to_query(mreceived, ifID, Entry, *NetAsked); ! 543: ! 544: } ! 545: } ! 546: } ! 547: ! 548: /* If we have a non extended packet (code 2) with some stuff in it, ! 549: * we need to send it now ! 550: */ ! 551: ! 552: if ( reply_length > 2) { ! 553: DDPLEN_ASSIGN(ddp, reply_length + DDP_X_HDR_SIZE); ! 554: gbuf_winc(m,reply_length); ! 555: if ((status = ! 556: ddp_router_output(m, ifID, AT_ADDR, ! 557: NET_VALUE(ddp->dst_net), ! 558: ddp->dst_node, 0))) { ! 559: dPrintf(D_M_ZIP, D_L_ERROR, ! 560: ("zip_send_reply: ddp_router_output returns =%d\n", status)); ! 561: return; /* was return (status); */ ! 562: } ! 563: } ! 564: else /* free the buffer not used */ ! 565: gbuf_freem(m); ! 566: } /* zip_send_reply_to_query */ ! 567: ! 568: /*********************************************************************** ! 569: * zip_router_input() ! 570: * ! 571: **********************************************************************/ ! 572: ! 573: void zip_router_input (m, ifID) ! 574: register gbuf_t *m; ! 575: register at_ifaddr_t *ifID; ! 576: { ! 577: register at_ddp_t *ddp; ! 578: register at_atp_t *atp; ! 579: register at_zip_t *zip; ! 580: register u_long user_bytes; ! 581: register u_short user_byte; ! 582: ! 583: /* variables for ZipNotify processing */ ! 584: register char old_zone_len; ! 585: register char new_zone_len; ! 586: register char *old_zone; ! 587: char *new_zone; ! 588: void zip_sched_getnetinfo(); /* forward reference */ ! 589: ! 590: if (gbuf_type(m) != MSG_DATA) { ! 591: /* If this is a M_ERROR message, DDP is shutting down, ! 592: * nothing to do here...If it's something else, we don't ! 593: * understand what it is ! 594: */ ! 595: dPrintf(D_M_ZIP, D_L_WARNING, ("zip_router_input: not an M_DATA message\n")); ! 596: gbuf_freem(m); ! 597: return; ! 598: } ! 599: ! 600: if (!ifID) { ! 601: dPrintf(D_M_ZIP, D_L_WARNING, ("zip_router_input: BAD ifID\n")); ! 602: gbuf_freem(m); ! 603: return; ! 604: } ! 605: ! 606: /* ! 607: * The ZIP listener receives two types of requests: ! 608: * ! 609: * ATP requests: GetZoneList, GetLocalZone, or GetMyZone ! 610: * ZIP requests: Netinfo, Query, Reply, takedown, bringup ! 611: */ ! 612: ! 613: ddp = (at_ddp_t *)gbuf_rptr(m); ! 614: ! 615: if (ddp->type == DDP_ZIP) { ! 616: zip = (at_zip_t *)(gbuf_rptr(m) + DDP_X_HDR_SIZE); ! 617: dPrintf(D_M_ZIP_LOW, D_L_INPUT, ! 618: ("zip_input: received a ZIP_DDP command=%d\n", ! 619: zip->command)); ! 620: switch (zip->command) { ! 621: case ZIP_QUERY : /* we received a Zip Query request */ ! 622: dPrintf(D_M_ZIP, D_L_INPUT, ! 623: ("zip_input: Received a Zip Query in from %d.%d\n", ! 624: NET_VALUE(ddp->src_net), ddp->src_node)); ! 625: ! 626: if (!RT_LOOKUP_OKAY(ifID, ddp)) { ! 627: dPrintf(D_M_ZIP, D_L_INPUT, ! 628: ("zip_input:: refused ZIP_QUERY from %d:%d\n", ! 629: NET_VALUE(ddp->src_net), ddp->src_node)); ! 630: } ! 631: else ! 632: zip_send_reply_to_query(m, ifID); ! 633: gbuf_freem(m); ! 634: break; ! 635: ! 636: case ZIP_REPLY : /* we received a Zip Query Reply packet */ ! 637: case ZIP_EXTENDED_REPLY: ! 638: if (ifID->ifRoutingState == PORT_OFFLINE) { ! 639: dPrintf(D_M_ZIP, D_L_INPUT, ! 640: ("zip_input: Received a Zip Reply in user mode\n")); ! 641: } ! 642: else ! 643: zip_reply_received(m, ifID, zip->command); ! 644: gbuf_freem(m); ! 645: break; ! 646: ! 647: case ZIP_TAKEDOWN : ! 648: /* we received a Zip Takedown packet */ ! 649: dPrintf(D_M_ZIP, D_L_WARNING, ("zip_input: Received a Zip takedown!!!\n")); ! 650: gbuf_freem(m); ! 651: break; ! 652: ! 653: case ZIP_BRINGUP : ! 654: /* we received a Zip BringUp packet */ ! 655: dPrintf(D_M_ZIP, D_L_WARNING, ("zip_input: Received a Zip BringUp!!!\n")); ! 656: gbuf_freem(m); ! 657: break; ! 658: ! 659: case ZIP_GETNETINFO: /* we received a GetNetInfo request */ ! 660: dPrintf(D_M_ZIP, D_L_INPUT, ! 661: ("zip_input: Received a GetNetInfo Req in from %d.%d\n", ! 662: NET_VALUE(ddp->src_net), ddp->src_node)); ! 663: if (RT_LOOKUP_OKAY(ifID, ddp)) { ! 664: dPrintf(D_M_ZIP, D_L_OUTPUT, ! 665: ("zip_input: we, as node %d:%d send GNI reply to %d:%d\n", ! 666: ifID->ifThisNode.s_net, ifID->ifThisNode.s_node, ! 667: NET_VALUE(ddp->src_net), ddp->src_node)); ! 668: zip_send_getnetinfo_reply(m, ifID); ! 669: } ! 670: gbuf_freem(m); ! 671: break; ! 672: ! 673: ! 674: case ZIP_NETINFO_REPLY : ! 675: ! 676: /* If we are not waiting for a GetNetInfo reply ! 677: * to arrive, this must be a broadcast ! 678: * message for someone else on the zone, so ! 679: * no need to even look at it! ! 680: */ ! 681: if (!ROUTING_MODE && ! 682: ((NET_VALUE(ddp->src_net) != ifID->ifThisNode.s_net) || ! 683: (ddp->src_node != ifID->ifThisNode.s_node)) && netinfo_reply_pending) ! 684: { ! 685: extern void trackrouter(); ! 686: dPrintf(D_M_ZIP, D_L_INPUT, ! 687: ("zip_input: Received a GetNetInfo Reply from %d.%d\n", ! 688: NET_VALUE(ddp->src_net), ddp->src_node)); ! 689: trackrouter(ifID, NET_VALUE(ddp->src_net), ddp->src_node); ! 690: zip_netinfo_reply((at_x_zip_t *)zip, ifID); ! 691: } ! 692: ! 693: gbuf_freem(m); ! 694: break; ! 695: ! 696: case ZIP_NOTIFY : ! 697: /* processing of ZipNotify message : first, change ! 698: * our zone name, then if NIS is open, let NBP demon ! 699: process know of this change...(just forward the ! 700: * Notify packet ! 701: */ ! 702: /* First, check if this is really a packet for us */ ! 703: old_zone = &zip->data[4]; ! 704: if (!zonename_equal(&ifID->ifZoneName, ! 705: (at_nvestr_t *)old_zone)) { ! 706: /* the old zone name in the packet is not the ! 707: * same as ours, so this packet couldn't be ! 708: * for us. ! 709: */ ! 710: gbuf_freem(m); ! 711: break; ! 712: ! 713: } ! 714: old_zone_len = *old_zone; ! 715: new_zone_len = zip->data[4 + old_zone_len + 1]; ! 716: new_zone = old_zone + old_zone_len; ! 717: ! 718: /* Reset the zone multicast address */ ! 719: (void)at_unreg_mcast(ifID, (caddr_t)&ifID->ZoneMcastAddr); ! 720: bzero((caddr_t)&ifID->ZoneMcastAddr, ETHERNET_ADDR_LEN); ! 721: ! 722: /* change the zone name - copy both the length and the string */ ! 723: bcopy((caddr_t)new_zone, (caddr_t)&ifID->ifZoneName, ! 724: new_zone_len+1); ! 725: ! 726: /* add the new zone to the list of local zones */ ! 727: if (!MULTIPORT_MODE && !DEFAULT_ZONE(&ifID->ifZoneName)) ! 728: (void)setLocalZones(&ifID->ifZoneName, ! 729: (ifID->ifZoneName.len+1)); ! 730: ! 731: /* Before trying to request our new multicast address, ! 732: * wait a while... someone might have alredy requested ! 733: * it, so we may see some broadcast messages flying ! 734: * by... Set up the structures so that it appears that ! 735: * we have already requested the NetInfo. ! 736: */ ! 737: ifID->ifNumRetries = ZIP_NETINFO_RETRIES; ! 738: netinfo_reply_pending = 1; ! 739: timeout(zip_sched_getnetinfo, (caddr_t) ifID, ! 740: 2*ZIP_TIMER_INT); ! 741: ! 742: gbuf_freem(m); ! 743: break; ! 744: default : ! 745: routing_needed(m, ifID, TRUE); ! 746: break; ! 747: } ! 748: } ! 749: else if (ddp->type == DDP_ATP && ! 750: RT_LOOKUP_OKAY(ifID, ddp)) { ! 751: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 752: atp = (at_atp_t *)(gbuf_rptr(m)+DDP_X_HDR_SIZE); ! 753: else ! 754: atp = (at_atp_t *)(gbuf_rptr(gbuf_cont(m))); ! 755: ! 756: /* Get the user bytes in network order */ ! 757: ! 758: user_bytes = UAL_VALUE(atp->user_bytes); ! 759: user_byte = user_bytes >> 24; /* Get the zeroth byte */ ! 760: ! 761: dPrintf(D_M_ZIP, D_L_INPUT, ! 762: ("zip_input: received a ZIP_ATP command=%d\n", user_byte)); ! 763: ! 764: switch (user_byte) { ! 765: case ZIP_GETMYZONE: ! 766: zip_reply_to_getmyzone(ifID, m); ! 767: gbuf_freem(m); ! 768: break; ! 769: ! 770: case ZIP_GETZONELIST: ! 771: zip_reply_to_getzonelist(ifID, m); ! 772: gbuf_freem(m); ! 773: break; ! 774: ! 775: case ZIP_GETLOCALZONES: ! 776: zip_reply_to_getlocalzones(ifID, m); ! 777: gbuf_freem(m); ! 778: break; ! 779: ! 780: default: ! 781: dPrintf(D_M_ZIP, D_L_WARNING, ! 782: ("zip_input: received unknown ZIP_ATP command=%d\n", user_byte)); ! 783: routing_needed(m, ifID, TRUE); ! 784: break; ! 785: } ! 786: } else { ! 787: gbuf_freem(m); ! 788: } ! 789: return; ! 790: } /* zip_router_input */ ! 791: ! 792: /*********************************************************************** ! 793: * zonename_equal() ! 794: * ! 795: * Remarks : ! 796: * ! 797: **********************************************************************/ ! 798: int zonename_equal (zone1, zone2) ! 799: register at_nvestr_t *zone1, *zone2; ! 800: { ! 801: register char c1, c2; ! 802: char upshift8(); ! 803: register int i; ! 804: ! 805: if (zone1->len != zone2->len) ! 806: return(0); ! 807: ! 808: for (i=0; i< (int) zone1->len; i++) { ! 809: c1 = zone1->str[i]; ! 810: c2 = zone2->str[i]; ! 811: if (c1 >= 'a' && c1 <= 'z') ! 812: c1 += 'A' - 'a'; ! 813: if (c2 >= 'a' && c2 <= 'z') ! 814: c2 += 'A' - 'a'; ! 815: if (c1 & 0x80) ! 816: c1 = upshift8(c1); ! 817: if (c2 & 0x80) ! 818: c2 = upshift8(c2); ! 819: if (c1 != c2) ! 820: return(0); ! 821: } ! 822: return(1); ! 823: } ! 824: ! 825: ! 826: char upshift8 (ch) ! 827: register char ch; ! 828: { ! 829: register int i; ! 830: ! 831: static unsigned char lower_case[] = ! 832: {0x8a, 0x8c, 0x8d, 0x8e, 0x96, 0x9a, 0x9f, 0xbe, ! 833: 0xbf, 0xcf, 0x9b, 0x8b, 0x88, 0}; ! 834: static unsigned char upper_case[] = ! 835: {0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xae, ! 836: 0xaf, 0xce, 0xcd, 0xcc, 0xcb, 0}; ! 837: ! 838: for (i=0; lower_case[i]; i++) ! 839: if (ch == lower_case[i]) ! 840: return (upper_case[i]); ! 841: ! 842: return(ch); ! 843: } ! 844: ! 845: ! 846: /*********************************************************************** ! 847: * zip_netinfo_reply () ! 848: * ! 849: * Remarks : ! 850: * ! 851: **********************************************************************/ ! 852: static void zip_netinfo_reply (netinfo, ifID) ! 853: register at_x_zip_t *netinfo; ! 854: register at_ifaddr_t *ifID; ! 855: { ! 856: u_char mcast_len; ! 857: void zip_sched_getnetinfo(); /* forward reference */ ! 858: register at_net_al this_net; ! 859: char *default_zone; ! 860: register u_char zone_name_len; ! 861: ! 862: /* There may be multiple zones on the cable.... we need to ! 863: * worry about whether or not this packet is addressed ! 864: * to us. ! 865: */ ! 866: /* *** Do we really need to check this? *** */ ! 867: if (!zonename_equal((at_nvestr_t *)netinfo->data, &ifID->ifZoneName)) ! 868: return; ! 869: ! 870: ifID->ifThisCableStart = NET_VALUE(netinfo->cable_range_start); ! 871: ifID->ifThisCableEnd = NET_VALUE(netinfo->cable_range_end); ! 872: dPrintf(D_M_ZIP, D_L_OUTPUT, ("Zip_netinfo_reply: Set cable to %d-%d\n", ! 873: ifID->ifThisCableStart, ifID->ifThisCableEnd)); ! 874: ! 875: /* The packet is in response to our request */ ! 876: untimeout (zip_sched_getnetinfo, (caddr_t) ifID); ! 877: netinfo_reply_pending = 0; ! 878: zone_name_len = netinfo->data[0]; ! 879: mcast_len = netinfo->data[zone_name_len + 1]; ! 880: ! 881: if (netinfo->flags & ZIP_ZONENAME_INVALID) { ! 882: /* copy out the default zone name from packet */ ! 883: default_zone = (char *)&netinfo->data[zone_name_len+1+mcast_len+1]; ! 884: bcopy((caddr_t)default_zone, (caddr_t)&ifID->ifZoneName, ! 885: *default_zone + 1); ! 886: } ! 887: ! 888: /* add the new zone to the list of local zones */ ! 889: if (!MULTIPORT_MODE && !DEFAULT_ZONE(&ifID->ifZoneName)) ! 890: (void)setLocalZones(&ifID->ifZoneName, (ifID->ifZoneName.len+1)); ! 891: ! 892: /* get the multicast address out of the GetNetInfo reply, if there is one */ ! 893: if (!(netinfo->flags & ZIP_USE_BROADCAST)) { ! 894: /* If ZIP_USE_BROADCAST is set, we will use the cable ! 895: broadcast address as the multicast address, however ! 896: the cable multicast address has already been registered. ! 897: */ ! 898: /* This packet contains a multicast address, so ! 899: * send to elap to register it. ! 900: */ ! 901: if (FDDI_OR_TOKENRING(ifID->aa_ifp->if_type)) ! 902: ddp_bit_reverse(&netinfo->data[zone_name_len + 2]); ! 903: ! 904: bcopy((caddr_t)&netinfo->data[zone_name_len + 2], ! 905: (caddr_t)&ifID->ZoneMcastAddr, ETHERNET_ADDR_LEN); ! 906: (void)at_reg_mcast(ifID, (caddr_t)&ifID->ZoneMcastAddr); ! 907: } ! 908: ! 909: this_net = ifID->ifThisNode.s_net; ! 910: if ((this_net >= ifID->ifThisCableStart) && ! 911: (this_net <= ifID->ifThisCableEnd)) { ! 912: /* ThisNet is in the range of valid network numbers ! 913: * for the cable. Do nothing. ! 914: */ ! 915: } else { ! 916: /* ThisNet is not in the range of valid network ! 917: * numbers for the cable. This may be either because ! 918: * the chosen number was from start-up range, or ! 919: * because the user has a misconception of where the ! 920: * machine is!! Since ThisCableRange is set up, next ! 921: * time aarp is invoked, it would select address in ! 922: * the right range. ! 923: */ ! 924: ! 925: /* to reset initial_net and initial_node to zero, so ! 926: * that aarp is forced to choose new values ! 927: */ ! 928: ifID->initial_addr.s_net = 0; ! 929: ifID->initial_addr.s_node = 0; ! 930: ! 931: /* Wake up elap_online sleeping on this interface. */ ! 932: ZIPwakeup(ifID, ZIP_RE_AARP); ! 933: return; ! 934: } ! 935: ! 936: ZIPwakeup(ifID, 0); /* no error */ ! 937: return; ! 938: } /* zip_netinfo_reply */ ! 939: ! 940: ! 941: /********************************************************************** ! 942: * zip_control() ! 943: * ! 944: **********************************************************************/ ! 945: int zip_control (ifID, control) ! 946: register at_ifaddr_t *ifID; ! 947: int control; ! 948: { ! 949: dPrintf(D_M_ZIP, D_L_INFO, ("zip_control called port=%d control=%d\n", ! 950: ifID->ifPort, control)); ! 951: switch (control) { ! 952: case ZIP_ONLINE : ! 953: case ZIP_LATE_ROUTER : ! 954: ifID->ifNumRetries = 0; ! 955: /* Get the desired zone name from elap and put it in ! 956: * ifID for zip_getnetinfo() to use. ! 957: */ ! 958: if (ifID->startup_zone.len) ! 959: ifID->ifZoneName = ifID->startup_zone; ! 960: zip_getnetinfo(ifID); ! 961: break; ! 962: case ZIP_NO_ROUTER : ! 963: ifID->ifZoneName.len = 1; ! 964: ifID->ifZoneName.str[0] = '*'; ! 965: ifID->ifZoneName.str[1] = '\0'; ! 966: break; ! 967: default : ! 968: break; ! 969: } ! 970: return (0); ! 971: } ! 972: ! 973: /********************************************************************** ! 974: * zip_getnetinfo() ! 975: * ! 976: **********************************************************************/ ! 977: static void zip_getnetinfo (ifID) ! 978: register at_ifaddr_t *ifID; ! 979: { ! 980: register at_x_zip_t *zip; ! 981: gbuf_t *m; ! 982: register at_ddp_t *ddp; ! 983: void zip_sched_getnetinfo(); ! 984: register struct atalk_addr *at_dest; ! 985: register int size; ! 986: ! 987: size = DDP_X_HDR_SIZE + ZIP_X_HDR_SIZE + ifID->ifZoneName.len + 1 ! 988: + sizeof(struct atalk_addr) + 1; ! 989: if ((m = gbuf_alloc (AT_WR_OFFSET+size, PRI_HI)) == NULL) { ! 990: /* This time, we're unable to allocate buffer to ! 991: * send a packet out, so schedule to send a packet ! 992: * out later, and exit. ! 993: */ ! 994: dPrintf(D_M_ZIP, D_L_WARNING, ("zip_getnetinfo: no buffer, call later port=%d\n", ! 995: ifID->ifPort)); ! 996: timeout (zip_getnetinfo, (caddr_t) ifID, ZIP_TIMER_INT/10); ! 997: return; ! 998: } ! 999: ! 1000: gbuf_rinc(m,AT_WR_OFFSET); ! 1001: gbuf_wset(m,0); ! 1002: *(u_char *)gbuf_rptr(m) = AT_ADDR; ! 1003: at_dest = (struct atalk_addr *)(gbuf_rptr(m) + 1); ! 1004: ddp = (at_ddp_t *)(gbuf_rptr(m) + sizeof(struct atalk_addr) + 1); ! 1005: zip = (at_x_zip_t *)ddp->data; ! 1006: gbuf_winc(m,size); ! 1007: ! 1008: zip->command = ZIP_GETNETINFO; ! 1009: zip->flags = 0; ! 1010: NET_ASSIGN(zip->cable_range_start, 0); ! 1011: NET_ASSIGN(zip->cable_range_end, 0); ! 1012: if (ifID->ifZoneName.len) /* has to match reply exactly */ ! 1013: bcopy((caddr_t)&ifID->ifZoneName, (caddr_t)zip->data, ! 1014: ifID->ifZoneName.len + 1); ! 1015: else ! 1016: zip->data[0] = 0; /* No zone name is availbale */ ! 1017: ! 1018: /* let the lap fields be uninitialized, 'cause it doesn't ! 1019: * matter. ! 1020: */ ! 1021: DDPLEN_ASSIGN(ddp, size - (sizeof(struct atalk_addr) + 1)); ! 1022: UAS_ASSIGN(ddp->checksum, 0); ! 1023: ddp->hopcount = ddp->unused = 0; ! 1024: NET_ASSIGN(ddp->dst_net, 0); /* cable-wide broadcast */ ! 1025: NET_ASSIGN(ddp->src_net, ifID->ifThisNode.s_net); ! 1026: /* By this time, AARP is done */ ! 1027: ! 1028: ddp->dst_node = 0xff; ! 1029: ddp->src_node = ifID->ifThisNode.s_node; ! 1030: ddp->dst_socket = ZIP_SOCKET; ! 1031: ddp->src_socket = ZIP_SOCKET; ! 1032: ddp->type = DDP_ZIP; ! 1033: ! 1034: at_dest->atalk_unused = 0; ! 1035: NET_NET(at_dest->atalk_net, ddp->dst_net); ! 1036: at_dest->atalk_node = ddp->dst_node; ! 1037: ! 1038: dPrintf(D_M_ZIP, D_L_INPUT, ("zip_getnetinfo: called for port=%d\n", ! 1039: ifID->ifPort)); ! 1040: ! 1041: if (elap_dataput(m, ifID, 0, NULL)) { ! 1042: dPrintf(D_M_ZIP, D_L_ERROR, ! 1043: ("zip_getnetinfo: error sending zip_getnetinfo\n")); ! 1044: return; ! 1045: } ! 1046: ! 1047: ifID->ifNumRetries++; ! 1048: netinfo_reply_pending = 1; ! 1049: ! 1050: timeout (zip_sched_getnetinfo, (caddr_t) ifID, ZIP_TIMER_INT); ! 1051: } /* zip_getnetinfo */ ! 1052: ! 1053: ! 1054: /********************************************************************** ! 1055: * zip_sched_getnetinfo() ! 1056: * ! 1057: **********************************************************************/ ! 1058: ! 1059: void zip_sched_getnetinfo (ifID) ! 1060: register at_ifaddr_t *ifID; ! 1061: { ! 1062: if (ifID->ifNumRetries >= ZIP_NETINFO_RETRIES) { ! 1063: /* enough packets sent.... give up! */ ! 1064: /* we didn't get any response from the net, so ! 1065: * assume there's no router around and the given ! 1066: * zone name, if any, is not valid. Change the ! 1067: * zone name to "*". ! 1068: */ ! 1069: ifID->ifZoneName.len = 1; ! 1070: ifID->ifZoneName.str[0] = '*'; ! 1071: ifID->ifZoneName.str[1] = '\0'; ! 1072: /* Should NBP be notified of this "new" zone name?? */ ! 1073: netinfo_reply_pending = 0; ! 1074: ! 1075: ifID->ifRouterState = NO_ROUTER; ! 1076: ifID->ifARouter.s_net = 0; ! 1077: ifID->ifARouter.s_node = 0; ! 1078: ! 1079: dPrintf(D_M_ZIP, D_L_INFO, ("zip_sched_getnetinfo: Reset Cable Range\n")); ! 1080: ! 1081: ifID->ifThisCableStart = DDP_MIN_NETWORK; ! 1082: ifID->ifThisCableEnd = DDP_MAX_NETWORK; ! 1083: ! 1084: if (ifID->ifState == LAP_ONLINE_FOR_ZIP) ! 1085: ZIPwakeup (ifID, 0); /* no error */ ! 1086: } else ! 1087: zip_getnetinfo(ifID); ! 1088: } ! 1089: ! 1090: ! 1091: /********************************************************************** ! 1092: * zip_type_packet() ! 1093: * ! 1094: * Remarks: ! 1095: * This routine checks whether or not the packet contained in "m" ! 1096: * is an (outgoing) ZIP packet. If not, it returns 0. If it is a ! 1097: * ZIP packet, it returns the ZIP packet type (ZIP command). "m" ! 1098: * points to a packet with extended DDP header. The rest of the ! 1099: * DDP data may or may not be in the first gbuf. ! 1100: * ! 1101: **********************************************************************/ ! 1102: int zip_type_packet (m) ! 1103: register gbuf_t *m; ! 1104: { ! 1105: register at_atp_t *atp; ! 1106: register at_ddp_t *ddp; ! 1107: register at_zip_t *zip; ! 1108: register u_long user_bytes; ! 1109: register int user_byte; ! 1110: ! 1111: ddp = (at_ddp_t *)gbuf_rptr(m); ! 1112: if (ddp->dst_socket == ZIP_SOCKET) { ! 1113: switch (ddp->type) { ! 1114: case DDP_ZIP : ! 1115: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 1116: zip = (at_zip_t *)(gbuf_rptr(m) ! 1117: + DDP_X_HDR_SIZE); ! 1118: else ! 1119: zip=(at_zip_t *)(gbuf_rptr(gbuf_cont(m))); ! 1120: return ((int)zip->command); ! 1121: case DDP_ATP : ! 1122: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 1123: atp = (at_atp_t *)(gbuf_rptr(m)+DDP_X_HDR_SIZE); ! 1124: else ! 1125: atp = (at_atp_t *)(gbuf_rptr(gbuf_cont(m))); ! 1126: /* Get the user bytes in network order */ ! 1127: user_bytes = UAL_VALUE(atp->user_bytes); ! 1128: user_byte = user_bytes >> 24; /* Get the zeroth byte */ ! 1129: if ((user_byte == ZIP_GETMYZONE) || ! 1130: (user_byte == ZIP_GETZONELIST) || ! 1131: (user_byte == ZIP_GETLOCALZONES)) ! 1132: return (user_byte); ! 1133: else ! 1134: return (0); ! 1135: default : ! 1136: return (0); ! 1137: } ! 1138: } else ! 1139: return (0); ! 1140: } ! 1141: ! 1142: /********************************************************************** ! 1143: * zip_handle_getmyzone() ! 1144: * ! 1145: * Remarks: ! 1146: * Routine to handle ZIP GetMyZone request locally. It generates ! 1147: * a phony response to the outgoing ATP request and sends it up. ! 1148: * ! 1149: * 07/12/94 : remark2 only called from ddp.c / ddp_output ! 1150: * should only be called from the home port, but ! 1151: * when we are a router we should know the infos for all ! 1152: * anyway, so reply locally with what we have in stock... ! 1153: * ! 1154: **********************************************************************/ ! 1155: ! 1156: int zip_handle_getmyzone(ifID, m) ! 1157: register at_ifaddr_t *ifID; ! 1158: register gbuf_t *m; ! 1159: { ! 1160: at_atp_t *atp; ! 1161: register at_ddp_t *ddp; ! 1162: register at_ddp_t *r_ddp; ! 1163: register at_atp_t *r_atp; ! 1164: gbuf_t *rm; /* reply message */ ! 1165: register int size; ! 1166: u_long ulongtmp; ! 1167: ! 1168: dPrintf(D_M_ZIP, D_L_INFO, ! 1169: ("zip_handle_getmyzone: local reply for port=%d\n", ! 1170: ifID->ifPort)); ! 1171: ! 1172: size = DDP_X_HDR_SIZE + ATP_HDR_SIZE + 1 + ifID->ifZoneName.len; ! 1173: /* space for two headers and the zone name */ ! 1174: if ((rm = gbuf_alloc(AT_WR_OFFSET+size, PRI_HI)) == NULL) { ! 1175: dPrintf(D_M_ZIP, D_L_WARNING, ! 1176: ("zip_handle_getmyzone: no buffer, port=%d\n", ! 1177: ifID->ifPort)); ! 1178: return (ENOBUFS); ! 1179: } ! 1180: ! 1181: gbuf_rinc(rm,AT_WR_OFFSET); ! 1182: gbuf_wset(rm,0); ! 1183: r_ddp = (at_ddp_t *)(gbuf_rptr(rm)); ! 1184: r_atp = (at_atp_t *)r_ddp->data; ! 1185: gbuf_winc(rm,size); ! 1186: ! 1187: ddp = (at_ddp_t *)gbuf_rptr(m); ! 1188: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 1189: atp = (at_atp_t *)(gbuf_rptr(m) + DDP_X_HDR_SIZE); ! 1190: else ! 1191: atp = (at_atp_t *)(gbuf_rptr(gbuf_cont(m))); ! 1192: ! 1193: /* fill up the ddp header for reply */ ! 1194: DDPLEN_ASSIGN(r_ddp, size); ! 1195: r_ddp->hopcount = r_ddp->unused = 0; ! 1196: UAS_ASSIGN(r_ddp->checksum, 0); ! 1197: NET_ASSIGN(r_ddp->dst_net, ifID->ifThisNode.s_net); ! 1198: NET_NET(r_ddp->src_net, ddp->dst_net); ! 1199: r_ddp->dst_node = ifID->ifThisNode.s_node; ! 1200: r_ddp->src_node = ddp->dst_node; ! 1201: r_ddp->dst_socket = ddp->src_socket; ! 1202: r_ddp->src_socket = ZIP_SOCKET; ! 1203: r_ddp->type = DDP_ATP; ! 1204: ! 1205: /* fill up the atp header */ ! 1206: r_atp->cmd = ATP_CMD_TRESP; ! 1207: r_atp->xo = 0; ! 1208: r_atp->eom = 1; ! 1209: r_atp->sts = 0; ! 1210: r_atp->xo_relt = 0; ! 1211: r_atp->bitmap = 0; ! 1212: UAS_UAS(r_atp->tid, atp->tid); ! 1213: ulongtmp = 1; ! 1214: ulongtmp = htonl(ulongtmp); ! 1215: UAL_ASSIGN(r_atp->user_bytes, ulongtmp); /* no of zones */ ! 1216: ! 1217: /* fill up atp data part */ ! 1218: bcopy((caddr_t) &ifID->ifZoneName, (caddr_t) r_atp->data, ifID->ifZoneName.len+1); ! 1219: ! 1220: /* all set to send the packet back up */ ! 1221: ! 1222: timeout(send_phony_reply, (caddr_t) rm, HZ/20); ! 1223: return (0); ! 1224: } ! 1225: ! 1226: static void ! 1227: send_phony_reply(rm) ! 1228: gbuf_t *rm; ! 1229: { ! 1230: ddp_input(rm, ifID_home); ! 1231: return; ! 1232: } ! 1233: ! 1234: ! 1235: /* ! 1236: * zip_prep_query_packet: build the actual ddp packet for the zip query ! 1237: */ ! 1238: ! 1239: gbuf_t *zip_prep_query_packet(ifID, RouterNet, RouterNode) ! 1240: at_ifaddr_t *ifID; ! 1241: at_net_al RouterNet; /* we want to send the Zip Query to that router */ ! 1242: at_node RouterNode; ! 1243: { ! 1244: ! 1245: register gbuf_t *m; ! 1246: register at_ddp_t *ddp; ! 1247: ! 1248: if ((m = gbuf_alloc (AT_WR_OFFSET+1024, PRI_HI)) == NULL) { ! 1249: dPrintf(D_M_ZIP, D_L_WARNING, ! 1250: ("zip_send_query_packet: no buffer, port=%d\n", ! 1251: ifID->ifPort)); ! 1252: return((gbuf_t *)NULL); ! 1253: } ! 1254: gbuf_rinc(m,AT_WR_OFFSET); ! 1255: gbuf_wset(m,0); ! 1256: ! 1257: ddp = (at_ddp_t *)(gbuf_rptr(m)); ! 1258: ! 1259: /* Prepare the DDP header */ ! 1260: ! 1261: ddp->unused = ddp->hopcount = 0; ! 1262: UAS_ASSIGN(ddp->checksum, 0); ! 1263: NET_ASSIGN(ddp->src_net, ifID->ifThisNode.s_net); ! 1264: ddp->src_node = ifID->ifThisNode.s_node; ! 1265: ddp->src_socket = ZIP_SOCKET; ! 1266: ! 1267: ddp->dst_socket = ZIP_SOCKET; ! 1268: NET_ASSIGN(ddp->dst_net, RouterNet); ! 1269: ddp->dst_node = RouterNode; ! 1270: ! 1271: ddp->type = DDP_ZIP; ! 1272: ! 1273: return (m); ! 1274: } /* zip_prep_query_packet */ ! 1275: ! 1276: ! 1277: /* ! 1278: * zip_send_queries: this function send queries for the routing table entries that ! 1279: * need to know their zones. It scans the routing table for entries with unknown ! 1280: * zones and build Query packets accordingly. ! 1281: * Note: this is called on a per port basis. ! 1282: */ ! 1283: ! 1284: void zip_send_queries(ifID, RouterNet, RouterNode) ! 1285: register at_ifaddr_t *ifID; ! 1286: at_net_al RouterNet; /* we want to send the Zip Query to that router */ ! 1287: at_node RouterNode; ! 1288: { ! 1289: RT_entry *Entry = &RT_table[0]; ! 1290: register gbuf_t *m; ! 1291: register at_ddp_t *ddp; ! 1292: int status; ! 1293: short Query_index, EntryNumber = 0 ; ! 1294: register u_char port = ifID->ifPort; ! 1295: char *QueryBuff, *ZoneCount; ! 1296: short zip_sent = FALSE; ! 1297: ! 1298: newPacket: ! 1299: ! 1300: if (!(m = zip_prep_query_packet(ifID, RouterNet, RouterNode))) { ! 1301: return; /* was return (ENOBUFS); */ ! 1302: } ! 1303: ! 1304: ddp = (at_ddp_t *)(gbuf_rptr(m)); ! 1305: QueryBuff = (char *)ddp->data; ! 1306: ! 1307: *QueryBuff++ = ZIP_QUERY; ! 1308: ZoneCount = QueryBuff; /* network count */ ! 1309: *ZoneCount = 0; ! 1310: QueryBuff++; ! 1311: Query_index = 2; ! 1312: ! 1313: ! 1314: while (EntryNumber < RT_maxentry) { ! 1315: ! 1316: /* scan the table, and build the packet with the right entries: ! 1317: * - entry in use and on the right Port ! 1318: * - with unknwon zones and in an active state ! 1319: * - talking to the right router ! 1320: */ ! 1321: ! 1322: if ((Query_index) > 2*254 +2) { ! 1323: ! 1324: /* we need to send the packet now, but we can't have more than 256 ! 1325: * requests for networks: the Netcount field is a 8bit in the zip query ! 1326: * packet format as defined in Inside Atalk ! 1327: */ ! 1328: ! 1329: dPrintf(D_M_ZIP_LOW, D_L_OUTPUT, ! 1330: ("zip_send_query: FULL query for %d nets on port#%d.(len=%d)\n", ! 1331: *ZoneCount, port, Query_index)); ! 1332: zip_sent = TRUE; ! 1333: ! 1334: gbuf_winc(m,DDP_X_HDR_SIZE + Query_index); ! 1335: DDPLEN_ASSIGN(ddp, DDP_X_HDR_SIZE + Query_index); ! 1336: ! 1337: if ((status = ! 1338: ddp_router_output(m, ifID, AT_ADDR, ! 1339: RouterNet, RouterNode, 0))) { ! 1340: dPrintf(D_M_ZIP, D_L_ERROR, ! 1341: ("zip_send_query: ddp_router_output returns =%d\n", status)); ! 1342: return; /* was return (status); */ ! 1343: } ! 1344: ! 1345: goto newPacket; ! 1346: } ! 1347: ! 1348: ! 1349: if (((Entry->EntryState & 0x0F) >= RTE_STATE_SUSPECT) && ! 1350: (Entry->NetStop) && (Entry->NetPort == port) && ! 1351: (!RT_ALL_ZONES_KNOWN(Entry))){ ! 1352: ! 1353: /* we're ready to had that to our list of stuff to send */ ! 1354: ! 1355: if (Entry->NetStart) { /* extended net*/ ! 1356: ! 1357: *QueryBuff++ = (Entry->NetStart & 0xFF00) >> 8; ! 1358: *QueryBuff++ = (Entry->NetStart & 0x00FF); ! 1359: ! 1360: } ! 1361: else { ! 1362: *QueryBuff++ = (Entry->NetStop & 0xFF00) >> 8; ! 1363: *QueryBuff++ = (Entry->NetStop & 0x00FF); ! 1364: } ! 1365: ! 1366: Query_index += 2; ! 1367: *ZoneCount += 1;/* bump the number of network requested */ ! 1368: ! 1369: } ! 1370: ! 1371: Entry++; ! 1372: EntryNumber++; ! 1373: ! 1374: } ! 1375: ! 1376: dPrintf(D_M_ZIP_LOW, D_L_OUTPUT, ! 1377: ("zip_send_query: query for %d nets on port#%d.(len=%d)\n", ! 1378: *ZoneCount, port, Query_index)); ! 1379: ! 1380: if (*ZoneCount) { /* non-full Query needs to be sent */ ! 1381: zip_sent = TRUE; ! 1382: gbuf_winc(m,DDP_X_HDR_SIZE + Query_index); ! 1383: DDPLEN_ASSIGN(ddp, DDP_X_HDR_SIZE + Query_index); ! 1384: ! 1385: if ((status = ! 1386: ddp_router_output(m, ifID, AT_ADDR, ! 1387: RouterNet, RouterNode, 0))) { ! 1388: dPrintf(D_M_ZIP, D_L_ERROR, ! 1389: ("zip_send_query: ddp_router_output returns =%d\n", ! 1390: status)); ! 1391: return; /* was return (status); */ ! 1392: } ! 1393: } ! 1394: else ! 1395: gbuf_freem(m); ! 1396: ! 1397: if (!zip_sent) /* we didn't need to send anything for that port */ ! 1398: ifID->ifZipNeedQueries = 0; ! 1399: } /* zip_send_queries */ ! 1400: ! 1401: /* zip_reply_received: we recieved the reply to one of our query, update the ! 1402: * zone bitmap and stuffs with was we received. ! 1403: * we receive two types of replies: non extended and extended. ! 1404: * For extended replies, the network count is the Total of zones for that net. ! 1405: */ ! 1406: ! 1407: zip_reply_received(m, ifID, reply_type) ! 1408: register gbuf_t *m; ! 1409: register at_ifaddr_t *ifID; ! 1410: int reply_type; ! 1411: { ! 1412: register at_nvestr_t *zname; ! 1413: RT_entry *Entry = &RT_table[0]; ! 1414: register at_ddp_t *ddp; ! 1415: at_net_al Network; ! 1416: u_short payload_len, result; ! 1417: u_char network_count; ! 1418: char *PacketPtr; ! 1419: ! 1420: ddp = (at_ddp_t *)gbuf_rptr(m); ! 1421: ! 1422: /* access the number of nets provided in the ZIP Reply */ ! 1423: ! 1424: network_count = *(u_char *)(gbuf_rptr(m) + DDP_X_HDR_SIZE + 1); ! 1425: ! 1426: PacketPtr = (char *)(gbuf_rptr(m) + DDP_X_HDR_SIZE + 2); ! 1427: ! 1428: payload_len = DDPLEN_VALUE(ddp) - (DDP_X_HDR_SIZE + 2); ! 1429: ! 1430: dPrintf(D_M_ZIP_LOW, D_L_INPUT, ("zip_reply_received from %d:%d type=%d netcount=%d\n", ! 1431: NET_VALUE(ddp->src_net), ddp->src_node, reply_type, network_count)); ! 1432: ! 1433: ! 1434: while (payload_len > 0 && network_count >0) { ! 1435: ! 1436: Network = *(at_net_al *)PacketPtr; ! 1437: PacketPtr += 2; ! 1438: zname = (at_nvestr_t *)PacketPtr; ! 1439: if (payload_len) ! 1440: payload_len = payload_len -(zname->len + 3); ! 1441: ! 1442: if (zname->len <= 0) { /* not valid, we got a problem here... */ ! 1443: dPrintf(D_M_ZIP, D_L_WARNING, ! 1444: ("zip_reply_received: Problem zlen=0 for net=%d from %d:%d type=%d netcnt=%d\n", ! 1445: Network, NET_VALUE(ddp->src_net), ddp->src_node, reply_type, network_count)); ! 1446: payload_len =0; ! 1447: continue; ! 1448: } ! 1449: ! 1450: ! 1451: Entry = rt_blookup(Network); ! 1452: ! 1453: if (Entry != NULL) { ! 1454: ! 1455: if (Entry->EntryState >= RTE_STATE_SUSPECT) { ! 1456: ! 1457: result = zt_add_zonename(zname); ! 1458: ! 1459: if (result == ZT_MAXEDOUT) { ! 1460: ! 1461: dPrintf(D_M_ZIP, D_L_ERROR, ! 1462: ("zip_reply_received: ZTable full from %d:%d on zone '%s'\n", ! 1463: NET_VALUE(ddp->src_net), ddp->src_node, zname->str)); ! 1464: ErrorZIPoverflow = 1; ! 1465: return(1); ! 1466: } ! 1467: ! 1468: zt_set_zmap(result, Entry->ZoneBitMap); ! 1469: ! 1470: RT_SET_ZONE_KNOWN(Entry); ! 1471: ! 1472: } ! 1473: else { ! 1474: dPrintf(D_M_ZIP, D_L_INPUT, ! 1475: ("zip_reply_received: entry %d-%d not updated, cause state=%d\n", ! 1476: Entry->NetStart, Entry->NetStop, Entry->EntryState)); ! 1477: } ! 1478: } ! 1479: else { ! 1480: dPrintf(D_M_ZIP, D_L_WARNING, ! 1481: ("zip_reply_received: network %d not found in RT\n", Network)); ! 1482: } ! 1483: ! 1484: ! 1485: /* now bump the PacketPtr pointer */ ! 1486: PacketPtr += zname->len + 1; ! 1487: network_count--; ! 1488: } ! 1489: ! 1490: if ((reply_type == ZIP_REPLY) && network_count > 0) { ! 1491: if (Entry) ! 1492: dPrintf(D_M_ZIP, D_L_WARNING, ! 1493: ("zip_reply_received: Problem decoding zone (after net:%d-%d)\n", ! 1494: Entry->NetStart, Entry->NetStop)); ! 1495: ifID->ifZipNeedQueries = 1; ! 1496: } ! 1497: else { ! 1498: ifID->ifZipNeedQueries = 0; ! 1499: if (Entry) ! 1500: dPrintf(D_M_ZIP_LOW, D_L_INFO, ! 1501: ("zip_reply_received: entry %d-%d all zones known\n", ! 1502: Entry->NetStart, Entry->NetStop)); ! 1503: } ! 1504: } ! 1505: ! 1506: /* ! 1507: * zip_reply_to_getmyzone: replies to ZIP GetMyZone received from the Net ! 1508: */ ! 1509: ! 1510: static void zip_reply_to_getmyzone (ifID, m) ! 1511: register at_ifaddr_t *ifID; ! 1512: register gbuf_t *m; ! 1513: { ! 1514: at_atp_t *atp; ! 1515: register at_ddp_t *ddp; ! 1516: register at_ddp_t *r_ddp; ! 1517: register at_atp_t *r_atp; ! 1518: register gbuf_t *rm; /* reply message */ ! 1519: register int size, Index, status; ! 1520: char *data_ptr; ! 1521: RT_entry *Entry; ! 1522: u_long ulongtmp; ! 1523: ! 1524: size = DDP_X_HDR_SIZE + ATP_HDR_SIZE + 1 + ifID->ifZoneName.len; ! 1525: /* space for two headers and the zone name */ ! 1526: if ((rm = gbuf_alloc(AT_WR_OFFSET+size, PRI_HI)) == NULL) { ! 1527: dPrintf(D_M_ZIP, D_L_WARNING, ! 1528: ("zip_reply_to_getmyzone: no buffer, port=%d\n", ifID->ifPort)); ! 1529: return; /* was return (ENOBUFS); */ ! 1530: } ! 1531: gbuf_rinc(rm,AT_WR_OFFSET); ! 1532: gbuf_wset(rm,size); ! 1533: r_ddp = (at_ddp_t *)(gbuf_rptr(rm)); ! 1534: r_atp = (at_atp_t *)r_ddp->data; ! 1535: ! 1536: ddp = (at_ddp_t *)gbuf_rptr(m); ! 1537: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 1538: atp = (at_atp_t *)(gbuf_rptr(m) + DDP_X_HDR_SIZE); ! 1539: else ! 1540: atp = (at_atp_t *)(gbuf_rptr(gbuf_cont(m))); ! 1541: ! 1542: /* fill up the ddp header for reply */ ! 1543: DDPLEN_ASSIGN(r_ddp, size); ! 1544: r_ddp->hopcount = r_ddp->unused = 0; ! 1545: UAS_ASSIGN(r_ddp->checksum, 0); ! 1546: ! 1547: NET_ASSIGN(r_ddp->src_net, ifID->ifThisNode.s_net); ! 1548: NET_NET(r_ddp->dst_net, ddp->src_net); ! 1549: ! 1550: r_ddp->src_node = ifID->ifThisNode.s_node; ! 1551: r_ddp->dst_node = ddp->src_node; ! 1552: ! 1553: r_ddp->dst_socket = ddp->src_socket; ! 1554: r_ddp->src_socket = ZIP_SOCKET; ! 1555: r_ddp->type = DDP_ATP; ! 1556: ! 1557: /* fill up the atp header */ ! 1558: r_atp->cmd = ATP_CMD_TRESP; ! 1559: r_atp->xo = 0; ! 1560: r_atp->eom = 1; ! 1561: r_atp->sts = 0; ! 1562: r_atp->xo_relt = 0; ! 1563: r_atp->bitmap = 0; ! 1564: UAS_UAS(r_atp->tid, atp->tid); ! 1565: ulongtmp = 1; ! 1566: ulongtmp = htonl(ulongtmp); ! 1567: UAL_ASSIGN(r_atp->user_bytes, ulongtmp); /* no of zones */ ! 1568: ! 1569: data_ptr = (char *)r_atp->data; ! 1570: ! 1571: /* ! 1572: * fill up atp data part with the zone name if we can find it... ! 1573: */ ! 1574: ! 1575: Entry = rt_blookup(NET_VALUE(ddp->src_net)); ! 1576: if (Entry != NULL && ((Entry->EntryState & 0x0F) >= RTE_STATE_SUSPECT) && ! 1577: RT_ALL_ZONES_KNOWN(Entry)) { /* this net is well known... */ ! 1578: ! 1579: Index = zt_ent_zindex(Entry->ZoneBitMap) -1; ! 1580: ! 1581: *data_ptr = ZT_table[Index].Zone.len; ! 1582: bcopy((caddr_t) &ZT_table[Index].Zone.str, (caddr_t) ++data_ptr, ! 1583: ZT_table[Index].Zone.len); ! 1584: ! 1585: /* all set to send the packet back up */ ! 1586: dPrintf(D_M_ZIP_LOW, D_L_OUTPUT, ! 1587: ("zip_reply_to_GMZ: ddp_router_output to %d:%d port %d\n", ! 1588: NET_VALUE(r_ddp->dst_net), r_ddp->dst_node, ifID->ifPort)); ! 1589: ! 1590: if ((status = ! 1591: ddp_router_output(rm, ifID, AT_ADDR, ! 1592: NET_VALUE(r_ddp->dst_net), r_ddp->dst_node, 0))) { ! 1593: dPrintf(D_M_ZIP, D_L_ERROR, ! 1594: ("zip_reply_to_GMZ: ddp_r_output returns =%d\n", status)); ! 1595: return; /* was return (status); */ ! 1596: } ! 1597: } ! 1598: else ! 1599: gbuf_freem(rm); ! 1600: } ! 1601: ! 1602: /* ! 1603: * zip_reply_to_getzonelist: replies to ZIP GetZoneList requested from the Net ! 1604: */ ! 1605: ! 1606: zip_reply_to_getzonelist (ifID, m) ! 1607: register at_ifaddr_t *ifID; ! 1608: register gbuf_t *m; ! 1609: { ! 1610: at_atp_t *atp; ! 1611: register at_ddp_t *ddp; ! 1612: register at_ddp_t *r_ddp; ! 1613: register at_atp_t *r_atp; ! 1614: register gbuf_t *rm; /* reply message */ ! 1615: register int size, status; ! 1616: register short Index=0, StartPoint, ZLength, PacketLen=0; ! 1617: u_long ulongtmp= 0; ! 1618: char *Reply; ! 1619: ! 1620: ddp = (at_ddp_t *)gbuf_rptr(m); ! 1621: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 1622: atp = (at_atp_t *)(gbuf_rptr(m) + DDP_X_HDR_SIZE); ! 1623: else ! 1624: atp = (at_atp_t *)(gbuf_rptr(gbuf_cont(m))); ! 1625: ! 1626: ! 1627: /* space for two headers and the zone name */ ! 1628: ! 1629: if ((rm = gbuf_alloc(AT_WR_OFFSET+1024, PRI_HI)) == NULL) { ! 1630: return (ENOBUFS); ! 1631: } ! 1632: ! 1633: gbuf_rinc(rm,AT_WR_OFFSET); ! 1634: gbuf_wset(rm,0); ! 1635: r_ddp = (at_ddp_t *)(gbuf_rptr(rm)); ! 1636: r_atp = (at_atp_t *)r_ddp->data; ! 1637: ! 1638: /* fill up the ddp header for reply */ ! 1639: ! 1640: r_ddp->hopcount = r_ddp->unused = 0; ! 1641: UAS_ASSIGN(r_ddp->checksum, 0); ! 1642: NET_ASSIGN(r_ddp->src_net, ifID->ifThisNode.s_net); ! 1643: NET_NET(r_ddp->dst_net, ddp->src_net); ! 1644: r_ddp->src_node = ifID->ifThisNode.s_node; ! 1645: r_ddp->dst_node = ddp->src_node; ! 1646: r_ddp->dst_socket = ddp->src_socket; ! 1647: r_ddp->src_socket = ZIP_SOCKET; ! 1648: r_ddp->type = DDP_ATP; ! 1649: ! 1650: /* fill up the atp header */ ! 1651: ! 1652: r_atp->cmd = ATP_CMD_TRESP; ! 1653: r_atp->xo = 0; ! 1654: r_atp->eom = 1; ! 1655: r_atp->sts = 0; ! 1656: r_atp->xo_relt = 0; ! 1657: r_atp->bitmap = 0; ! 1658: UAS_UAS(r_atp->tid, atp->tid); ! 1659: ! 1660: Reply = (char *)r_atp->data; ! 1661: ! 1662: /* get the start index from the ATP request */ ! 1663: ! 1664: StartPoint = (UAL_VALUE(atp->user_bytes) & 0xffff) -1; ! 1665: ! 1666: /* find the next zone to send */ ! 1667: ! 1668: while ((Index < ZT_maxentry) && StartPoint > 0) { ! 1669: if (ZT_table[Index].Zone.len) ! 1670: StartPoint--; ! 1671: Index++; ! 1672: } ! 1673: ! 1674: ! 1675: dPrintf(D_M_ZIP_LOW, D_L_OUTPUT, ("zip_reply_to_GZL: Index=%d\n", Index)); ! 1676: /* ! 1677: * fill up atp data part with the zone name if we can find it... ! 1678: */ ! 1679: ! 1680: while (Index < ZT_maxentry) { ! 1681: ! 1682: ZLength = ZT_table[Index].Zone.len; ! 1683: ! 1684: if (ZT_table[Index].ZoneCount && ZLength) { ! 1685: ! 1686: ! 1687: if (PacketLen + 8 + ZLength+1 > DDP_MAX_DATA) /* packet full */ ! 1688: break; ! 1689: ! 1690: *Reply++ = ZLength; ! 1691: bcopy((caddr_t) &ZT_table[Index].Zone.str, ! 1692: Reply, ZLength); ! 1693: Reply += ZLength; ! 1694: PacketLen += ZLength + 1; ! 1695: ulongtmp++; ! 1696: } ! 1697: Index++; ! 1698: } ! 1699: ! 1700: if (Index >= ZT_maxentry) /* this is the end of the list */ ! 1701: ! 1702: ulongtmp += 0x01000000; ! 1703: ! 1704: ! 1705: UAL_ASSIGN(r_atp->user_bytes, ulongtmp); /* # of zones and flag*/ ! 1706: ! 1707: size = DDP_X_HDR_SIZE + ATP_HDR_SIZE + PacketLen; ! 1708: gbuf_winc(rm,size); ! 1709: DDPLEN_ASSIGN(r_ddp, size); ! 1710: ! 1711: /* all set to send the packet back up */ ! 1712: ! 1713: dPrintf(D_M_ZIP_LOW, D_L_OUTPUT, ! 1714: ("zip_r_GZL: send packet to %d:%d port %d atp_len =%d\n", ! 1715: NET_VALUE(r_ddp->dst_net), r_ddp->dst_node, ifID->ifPort, PacketLen)); ! 1716: ! 1717: ! 1718: if (status= ddp_router_output(rm, ifID, AT_ADDR, ! 1719: NET_VALUE(r_ddp->dst_net), r_ddp->dst_node, 0)) { ! 1720: dPrintf(D_M_ZIP, D_L_ERROR, ("zip_reply_to_GZL: ddp_router_output returns=%d\n", ! 1721: status)); ! 1722: return (status); ! 1723: } ! 1724: return (0); ! 1725: ! 1726: } ! 1727: ! 1728: /* ! 1729: * zip_reply_to_getlocalzones: replies to ZIP GetLocalZones requested from the Net ! 1730: */ ! 1731: ! 1732: int zip_reply_to_getlocalzones (ifID, m) ! 1733: register at_ifaddr_t *ifID; ! 1734: register gbuf_t *m; ! 1735: { ! 1736: at_atp_t *atp; ! 1737: register at_ddp_t *ddp; ! 1738: register at_ddp_t *r_ddp; ! 1739: register at_atp_t *r_atp; ! 1740: register gbuf_t *rm; /* reply message */ ! 1741: int size, status; ! 1742: short Index, Index_wanted, ZLength; ! 1743: short i,j, packet_len; ! 1744: short zCount, ZoneCount, ZonesInPacket; ! 1745: char *zmap, last_flag = 0; ! 1746: RT_entry *Entry; ! 1747: char *Reply; ! 1748: ! 1749: u_long ulongtmp = 0; ! 1750: ! 1751: Index = Index_wanted = ZLength = i = j = packet_len = zCount = ZoneCount = ! 1752: ZonesInPacket = 0; ! 1753: ! 1754: ddp = (at_ddp_t *)gbuf_rptr(m); ! 1755: if (gbuf_len(m) > DDP_X_HDR_SIZE) ! 1756: atp = (at_atp_t *)(gbuf_rptr(m) + DDP_X_HDR_SIZE); ! 1757: else ! 1758: atp = (at_atp_t *)(gbuf_rptr(gbuf_cont(m))); ! 1759: ! 1760: /* space for two headers and the zone name */ ! 1761: ! 1762: if ((rm = gbuf_alloc(AT_WR_OFFSET+1024, PRI_HI)) == NULL) { ! 1763: return (ENOBUFS); ! 1764: } ! 1765: ! 1766: gbuf_rinc(rm,AT_WR_OFFSET); ! 1767: gbuf_wset(rm,0); ! 1768: r_ddp = (at_ddp_t *)(gbuf_rptr(rm)); ! 1769: r_atp = (at_atp_t *)r_ddp->data; ! 1770: ! 1771: Reply = (char *)r_atp->data; ! 1772: ! 1773: ! 1774: /* get the start index from the ATP request */ ! 1775: ! 1776: Index_wanted = (UAL_VALUE(atp->user_bytes) & 0xffff) -1; ! 1777: ! 1778: dPrintf(D_M_ZIP_LOW, D_L_INFO, ! 1779: ("zip_r_GLZ: for station %d:%d Index_wanted = %d\n", ! 1780: NET_VALUE(ddp->src_net), ddp->src_node, Index_wanted)); ! 1781: ! 1782: Entry = rt_blookup(NET_VALUE(ddp->src_net)); ! 1783: ! 1784: if (Entry != NULL && ((Entry->EntryState & 0x0F) >= RTE_STATE_SUSPECT) && ! 1785: RT_ALL_ZONES_KNOWN(Entry)) { /* this net is well known... */ ! 1786: ! 1787: ZoneCount = zt_ent_zcount(Entry) ; ! 1788: ! 1789: dPrintf(D_M_ZIP_LOW, D_L_INFO, ! 1790: ("zip_reply_GLZ: for %d:%d ZoneCount=%d\n", ! 1791: NET_VALUE(ddp->src_net), ddp->src_node, ZoneCount)); ! 1792: ! 1793: zmap = &Entry->ZoneBitMap[0]; ! 1794: ! 1795: /* ! 1796: * first of all, we want to find the "first next zone" in the bitmap, ! 1797: * to do so, we need to scan the bitmap and add the number of valid ! 1798: * zones we find until we reach the next zone to be sent in the reply ! 1799: */ ! 1800: ! 1801: if (ZoneCount > Index_wanted) { ! 1802: ! 1803: ZoneCount -= Index_wanted; ! 1804: ! 1805: /* find the starting point in the bitmap according to index */ ! 1806: ! 1807: for (i = 0; Index_wanted >= 0 && i < ZT_BYTES; i++) ! 1808: if (zmap[i]) { ! 1809: if (Index_wanted < 8) { ! 1810: /* how many zones in the bitmap byte */ ! 1811: for (j = 0, zCount =0; j < 8 ; j++) ! 1812: if ((zmap[i] << j) & 0x80) ! 1813: zCount++; ! 1814: if (Index_wanted < zCount) { ! 1815: for (j = 0 ; Index_wanted > 0 && j < 8 ; j++) ! 1816: if ((zmap[i] << j) & 0x80) ! 1817: Index_wanted--; ! 1818: break; ! 1819: } ! 1820: else ! 1821: Index_wanted -= zCount; ! 1822: } ! 1823: else ! 1824: for (j = 0 ; j < 8 ; j++) ! 1825: if ((zmap[i] << j) & 0x80) ! 1826: Index_wanted--; ! 1827: } ! 1828: ! 1829: /* ! 1830: * now, we point to the begining of our next zones in the bitmap ! 1831: */ ! 1832: ! 1833: while (i < ZT_BYTES) { ! 1834: ! 1835: if (zmap[i]) { ! 1836: for (; j < 8 ; j++) ! 1837: if ((zmap[i] << j) & 0x80) { ! 1838: Index = i*8 + j; /* get the index in ZT */ ! 1839: ! 1840: ZLength = ZT_table[Index].Zone.len; ! 1841: ! 1842: if (ZT_table[Index].ZoneCount && ZLength) { ! 1843: if (packet_len + ATP_HDR_SIZE + ZLength + 1 > ! 1844: DDP_MAX_DATA) ! 1845: goto FullPacket; ! 1846: ! 1847: *Reply++ = ZLength; ! 1848: bcopy((caddr_t) &ZT_table[Index].Zone.str, ! 1849: Reply, ZLength); ! 1850: Reply += ZLength; ! 1851: packet_len += ZLength + 1; ! 1852: ZonesInPacket ++; ! 1853: dPrintf(D_M_ZIP_LOW, D_L_INFO, ! 1854: ("zip_reply_GLZ: add z#%d to packet (l=%d)\n", ! 1855: Index, packet_len)); ! 1856: } ! 1857: else { ! 1858: dPrintf(D_M_ZIP, D_L_WARNING, ! 1859: ("zip_reply_GLZ: no len for index=%d\n", ! 1860: Index)); ! 1861: } ! 1862: } ! 1863: } ! 1864: i++; ! 1865: j = 0; ! 1866: } ! 1867: } ! 1868: else /* set the "last flag" bit in the reply */ ! 1869: last_flag = 1; ! 1870: } ! 1871: else /* set the "last flag" bit in the reply */ ! 1872: last_flag = 1; ! 1873: ! 1874: FullPacket: ! 1875: ! 1876: if (ZonesInPacket == ZoneCount) ! 1877: last_flag = 1; ! 1878: ! 1879: ! 1880: /* fill up the ddp header for reply */ ! 1881: ! 1882: r_ddp->hopcount = r_ddp->unused = 0; ! 1883: UAS_ASSIGN(r_ddp->checksum, 0); ! 1884: ! 1885: NET_ASSIGN(r_ddp->src_net, ifID->ifThisNode.s_net); ! 1886: NET_NET(r_ddp->dst_net, ddp->src_net); ! 1887: ! 1888: r_ddp->src_node = ifID->ifThisNode.s_node; ! 1889: r_ddp->dst_node = ddp->src_node; ! 1890: ! 1891: r_ddp->dst_socket = ddp->src_socket; ! 1892: r_ddp->src_socket = ZIP_SOCKET; ! 1893: r_ddp->type = DDP_ATP; ! 1894: ! 1895: /* fill up the atp header */ ! 1896: r_atp->cmd = ATP_CMD_TRESP; ! 1897: r_atp->xo = 0; ! 1898: r_atp->eom = 1; ! 1899: r_atp->sts = 0; ! 1900: r_atp->xo_relt = 0; ! 1901: r_atp->bitmap = 0; ! 1902: UAS_UAS(r_atp->tid, atp->tid); ! 1903: ulongtmp = ((last_flag << 24) & 0xFF000000) + ZonesInPacket; /* # of zones and flag*/ ! 1904: UAL_ASSIGN(r_atp->user_bytes, ulongtmp); ! 1905: size = DDP_X_HDR_SIZE + ATP_HDR_SIZE + packet_len; ! 1906: gbuf_winc(rm,size); ! 1907: DDPLEN_ASSIGN(r_ddp, size); ! 1908: ! 1909: /* all set to send the packet back up */ ! 1910: ! 1911: dPrintf(D_M_ZIP_LOW, D_L_OUTPUT, ! 1912: ("zip_r_GLZ: send packet to %d:%d port %d atp_len =%d\n", ! 1913: NET_VALUE(r_ddp->dst_net), r_ddp->dst_node, ifID->ifPort, packet_len)); ! 1914: ! 1915: if (status= ddp_router_output(rm, ifID, AT_ADDR, ! 1916: NET_VALUE(r_ddp->dst_net), r_ddp->dst_node, 0)) { ! 1917: dPrintf(D_M_ZIP, D_L_ERROR, ! 1918: ("zip_reply_to_GLZ: ddp_router_output returns =%d\n", ! 1919: status)); ! 1920: return (status); ! 1921: } ! 1922: return (0); ! 1923: } /* zip_reply_to_getlocalzones */ ! 1924: ! 1925: int regDefaultZone(ifID) ! 1926: at_ifaddr_t *ifID; ! 1927: { ! 1928: int i; ! 1929: char data[ETHERNET_ADDR_LEN]; ! 1930: ! 1931: if (!ifID) ! 1932: return(-1); ! 1933: ! 1934: zt_get_zmcast(ifID, &ifID->ifZoneName, data); ! 1935: if (FDDI_OR_TOKENRING(ifID->aa_ifp->if_type)) ! 1936: ddp_bit_reverse(data); ! 1937: bcopy((caddr_t)data, (caddr_t)&ifID->ZoneMcastAddr, ETHERNET_ADDR_LEN); ! 1938: (void)at_reg_mcast(ifID, (caddr_t)&ifID->ZoneMcastAddr); ! 1939: return(0); ! 1940: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.