![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddp_aarp.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_aarp.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: /* Copyright (c) 1988, 1989, 1997, 1998 Apple Computer, Inc. ! 26: * ! 27: * The information contained herein is subject to change without ! 28: * notice and should not be construed as a commitment by Apple ! 29: * Computer, Inc. Apple Computer, Inc. assumes no responsibility ! 30: * for any errors that may appear. ! 31: * ! 32: * Confidential and Proprietary to Apple Computer, Inc. ! 33: */ ! 34: ! 35: /* at_aarp.c: 2.0, 1.17; 10/4/93; Apple Computer, Inc. */; ! 36: ! 37: /* This file is at_aarp.c and it contains all the routines used by AARP. This ! 38: * is part of the LAP layer. ! 39: */ ! 40: ! 41: #include <sysglue.h> ! 42: #include <at/appletalk.h> ! 43: #include <at/elap.h> ! 44: #include <at/ddp.h> ! 45: #include <at/at_lap.h> ! 46: #include <at_pat.h> ! 47: #include <at_elap.h> ! 48: #include <at_aarp.h> ! 49: #include <at_ddp.h> ! 50: #include <at_snmp.h> ! 51: #include <sys/socket.h> ! 52: #include <net/if.h> ! 53: #include <net/if_types.h> ! 54: #include <net/if_blue.h> ! 55: #include <sys/systm.h> ! 56: ! 57: static int probing; ! 58: /* Following two variables are used to keep track of how many dynamic addresses ! 59: * we have tried out at startup. ! 60: */ ! 61: int no_of_nodes_tried; /* no of node addresses we've tried ! 62: * so far, within a network number ! 63: */ ! 64: int no_of_nets_tried; /* no. of network numbers tried ! 65: */ ! 66: ! 67: struct etalk_addr etalk_multicast_addr = { ! 68: {0x09, 0x00, 0x07, 0xff, 0xff, 0xff}}; ! 69: struct etalk_addr ttalk_multicast_addr = { ! 70: {0xC0, 0x00, 0x40, 0x00, 0x00, 0x00}}; ! 71: ! 72: struct etalk_addr zone_multicast_addr; ! 73: ! 74: struct etalk_addr et_zeroaddr = { ! 75: {0, 0, 0, 0, 0, 0}}; ! 76: ! 77: aarp_amt_t probe_cb; ! 78: aarp_amt_t et_aarp_amt[IF_TYPE_ET_MAX][AMTSIZE]; ! 79: ! 80: int aarp_init(); ! 81: int aarp_send_data(); ! 82: StaticProc int aarp_rcv_pkt(); ! 83: StaticProc int aarp_req_cmd_in(); ! 84: StaticProc int aarp_resp_cmd_in(); ! 85: StaticProc int aarp_probe_cmd_in(); ! 86: StaticProc int aarp_chk_addr(); ! 87: StaticProc int aarp_send_resp(); ! 88: StaticProc int aarp_send_req(); ! 89: StaticProc int aarp_send_probe(); ! 90: StaticProc aarp_amt_t *aarp_lru_entry(); ! 91: StaticProc int aarp_glean_info(); ! 92: StaticProc int aarp_delete_amt_info(); ! 93: StaticProc int aarp_sched_probe(); ! 94: StaticProc int aarp_build_pkt(); ! 95: StaticProc int aarp_sched_req(); ! 96: StaticProc int aarp_get_rand_node(); ! 97: StaticProc int aarp_get_next_node(); ! 98: StaticProc int aarp_get_rand_net(); ! 99: extern elap_specifics_t elap_specifics[]; ! 100: extern void *atalk_timeout(); ! 101: extern void atalk_untimeout(); ! 102: static void *probe_tmo; ! 103: atlock_t arpinp_lock; ! 104: ! 105: extern void AARPwakeup(aarp_amt_t *); ! 106: extern int pat_output(int, gbuf_t *, unsigned char *, int); ! 107: ! 108: /**************************************************************************** ! 109: * aarp_init() ! 110: * ! 111: ****************************************************************************/ ! 112: static int is_registered = 0; /* For y-adapter */ ! 113: ! 114: int ! 115: aarp_init(elapp, aflag) ! 116: register elap_specifics_t *elapp; ! 117: int aflag; ! 118: { ! 119: struct BlueFilter BF, *bf = &BF; ! 120: extern struct BlueFilter RhapFilter[]; ! 121: #ifdef BF_if ! 122: extern at_register_addr(struct BlueFilter *); ! 123: #else ! 124: extern at_register_addr(struct BlueFilter *, struct ifnet *); ! 125: #endif ! 126: extern int pat_control(int, int, void *); ! 127: extern struct ifnet *ifunit(char *); ! 128: ! 129: if (aflag) ! 130: goto aarp_sleep; ! 131: ! 132: if (is_registered) ! 133: { is_registered = 0; ! 134: RhapFilter[BFS_ATALK].BF_flags = 0; ! 135: } ! 136: ! 137: if (probing != PROBE_TENTATIVE) /* How do I set the initial probe */ ! 138: probing = PROBE_IDLE; /* state ???*/ ! 139: else { ! 140: dPrintf(D_M_AARP,D_L_ERROR, ! 141: ("aarp_init: error :probing == PROBE_TENTATIVE\n")); ! 142: return(-1); ! 143: } ! 144: ! 145: pat_control(elapp->pat_id, PAT_REG_AARP_UPSTREAM, aarp_rcv_pkt); ! 146: pat_control(elapp->pat_id, PAT_REG_CHECKADDR, aarp_chk_addr); ! 147: ! 148: /*pick a random addr or start with what we have from initial_node addr */ ! 149: if (!ATALK_VALUE(elapp->cfg.initial_addr)) { ! 150: dPrintf(D_M_AARP, D_L_INFO, ! 151: ("aarp_init: pick up a new node number\n")); ! 152: aarp_get_rand_node(elapp); ! 153: aarp_get_rand_net(elapp); ! 154: } ! 155: probe_cb.elapp = elapp; ! 156: probe_cb.no_of_retries = 0; ! 157: probe_cb.error = 0; ! 158: ! 159: no_of_nodes_tried = 0; /* haven't tried any addresses yet */ ! 160: no_of_nets_tried = 0; ! 161: ! 162: if (aarp_send_probe() == -1) { ! 163: probing = PROBE_IDLE; /* not probing any more */ ! 164: dPrintf(D_M_AARP, D_L_ERROR, ! 165: ("aarp_init: aarp_send_probe returns error\n")); ! 166: return(-1); ! 167: } ! 168: return(ENOTREADY); ! 169: aarp_sleep: ! 170: if (probe_cb.error != 0) { ! 171: probing = PROBE_IDLE; /* not probing any more */ ! 172: dPrintf(D_M_AARP, D_L_ERROR, ! 173: ("aarp_init: probe_cb.error creates error =%d\n", probe_cb.error)); ! 174: return(-1); ! 175: } ! 176: bzero ((caddr_t) et_aarp_amt, sizeof(et_aarp_amt)); ! 177: ! 178: elapp->cfg.node = elapp->cfg.initial_addr; ! 179: elapp->elap_if.ifThisNode = elapp->cfg.initial_addr; ! 180: probing = PROBE_DONE; ! 181: /* Register our node address with the y-adapter */ ! 182: bf->BF_flags = (BF_VALID|BF_ATALK); ! 183: bf->BF_address = *(unsigned short *)&(elapp->cfg.node.atalk_net); /* Sigh */ ! 184: bf->BF_node = elapp->cfg.node.atalk_node; ! 185: #ifdef BF_ifp ! 186: bf->BF_ifp = ifunit(ELAPP2IFNAME(elapp)); ! 187: #endif ! 188: ! 189: #ifdef BF_ifp ! 190: at_register_addr(bf); ! 191: #else ! 192: at_register_addr(bf, ifunit(ELAPP2IFNAME(elapp))); ! 193: #endif ! 194: is_registered = 1; ! 195: ! 196: return(0); ! 197: } ! 198: ! 199: /* ! 200: * Register an appletalk address: ! 201: * plant the info in a filter for the Y-adapter, if enabled ! 202: */ ! 203: int ! 204: at_register_addr(register struct BlueFilter *bf, ! 205: #ifndef BF_ifp ! 206: register struct ifnet *ifp ! 207: #endif ! 208: ) ! 209: { register struct BlueFilter *bf1; ! 210: extern struct ifnet_blue *blue_if; ! 211: #ifdef BF_ifp ! 212: register struct ifnet *ifp = bf->BF_ifp; ! 213: #endif ! 214: bf1=&blue_if->filter[BFS_ATALK]; ! 215: if (bf1->BF_flags & BF_VALID) ! 216: { kprintf("Dammit, Rodney, how can I work with all these interruptions?\n"); ! 217: return(1); ! 218: } ! 219: *bf1 = *bf; ! 220: bf1->BF_flags |= BF_VALID; ! 221: return(0); ! 222: } ! 223: ! 224: /**************************************************************************** ! 225: * aarp_rcv_pkt() ! 226: * ! 227: * remarks : ! 228: * (1) The caller must take care of freeing the real storage (gbuf) ! 229: * (2) The incoming packet is of the form {802.3, 802.2, aarp}. ! 230: * ! 231: ****************************************************************************/ ! 232: StaticProc int aarp_rcv_pkt(pkt, elapp) ! 233: register aarp_pkt_t *pkt; ! 234: elap_specifics_t *elapp; ! 235: { ! 236: switch (pkt->aarp_cmd) { ! 237: case AARP_REQ_CMD: ! 238: return (aarp_req_cmd_in (pkt, elapp)); ! 239: case AARP_RESP_CMD: ! 240: return (aarp_resp_cmd_in (pkt, elapp)); ! 241: case AARP_PROBE_CMD: ! 242: return (aarp_probe_cmd_in (pkt, elapp)); ! 243: default: ! 244: return (-1); ! 245: }/* end of switch*/ ! 246: } ! 247: ! 248: ! 249: ! 250: /**************************************************************************** ! 251: * aarp_req_cmd_in() ! 252: * ! 253: ****************************************************************************/ ! 254: StaticProc int aarp_req_cmd_in (pkt, elapp) ! 255: aarp_pkt_t *pkt; ! 256: elap_specifics_t *elapp; ! 257: { ! 258: /* ! 259: kprintf("aarp_req_cmd_in: ifThisNode=%d:%d srcNode=%d:%d dstNode=%d:%d\n", ! 260: NET_VALUE(elapp->elap_if.ifThisNode.atalk_net), ! 261: elapp->elap_if.ifThisNode.atalk_node, ! 262: NET_VALUE(pkt->src_at_addr.atalk_net), ! 263: pkt->src_at_addr.atalk_node, ! 264: NET_VALUE(pkt->dest_at_addr.atalk_net), ! 265: pkt->dest_at_addr.atalk_node); ! 266: */ ! 267: if ((probing == PROBE_DONE) && ! 268: (ATALK_EQUAL(pkt->dest_at_addr, elapp->elap_if.ifThisNode))) { ! 269: if (aarp_send_resp(elapp, pkt) == -1) ! 270: return(-1); ! 271: } ! 272: /* now to glean some info */ ! 273: aarp_glean_info(pkt, elapp); ! 274: return (0); ! 275: } ! 276: ! 277: ! 278: ! 279: /**************************************************************************** ! 280: * aarp_resp_cmd_in() ! 281: * ! 282: ****************************************************************************/ ! 283: StaticProc int aarp_resp_cmd_in (pkt, elapp) ! 284: aarp_pkt_t *pkt; ! 285: elap_specifics_t *elapp; ! 286: { ! 287: register aarp_amt_t *amt_ptr; ! 288: gbuf_t *m; ! 289: ! 290: switch (probing) { ! 291: case PROBE_TENTATIVE : ! 292: if (ATALK_EQUAL(pkt->src_at_addr, probe_cb.elapp->cfg.initial_addr)) { ! 293: ! 294: /* this is a response to AARP_PROBE_CMD. There's ! 295: * someone out there with the address we desire ! 296: * for ourselves. ! 297: */ ! 298: atalk_untimeout(aarp_sched_probe, 0, probe_tmo); ! 299: probe_cb.no_of_retries = 0; ! 300: aarp_get_next_node(probe_cb.elapp); ! 301: no_of_nodes_tried++; ! 302: ! 303: if (no_of_nodes_tried == AARP_MAX_NODES_TRIED) { ! 304: aarp_get_rand_net(probe_cb.elapp); ! 305: aarp_get_rand_node(probe_cb.elapp); ! 306: no_of_nodes_tried = 0; ! 307: no_of_nets_tried++; ! 308: } ! 309: if (no_of_nets_tried == AARP_MAX_NETS_TRIED) { ! 310: /* We have tried enough nodes and nets, give up. ! 311: */ ! 312: probe_cb.error = EADDRNOTAVAIL; ! 313: AARPwakeup(&probe_cb); ! 314: return(0); ! 315: } ! 316: if (aarp_send_probe() == -1) { ! 317: /* expecting aarp_send_probe to fill in ! 318: * probe_cb.error ! 319: */ ! 320: AARPwakeup(&probe_cb); ! 321: return(-1); ! 322: } ! 323: } else { ! 324: /* hmmmm! got a response packet while still probing ! 325: * for AT address and the AT dest address doesn't ! 326: * match!! ! 327: * What should I do here?? kkkkkkkkk ! 328: */ ! 329: return(-1); ! 330: } ! 331: break; ! 332: ! 333: case PROBE_DONE : ! 334: AMT_LOOK(amt_ptr, pkt->src_at_addr, elapp); ! 335: if (amt_ptr == NULL) ! 336: return(-1); ! 337: if (amt_ptr->tmo) ! 338: atalk_untimeout(aarp_sched_req, amt_ptr, amt_ptr->tmo); ! 339: amt_ptr->tmo = 0; ! 340: ! 341: if (amt_ptr->m == NULL) { ! 342: /* this may be because of a belated response to ! 343: * aarp reaquest. Based on an earlier response, we ! 344: * might have already sent the packet out, so ! 345: * there's nothing to send now. This is okay, no ! 346: * error. ! 347: */ ! 348: return(0); ! 349: } ! 350: amt_ptr->dest_addr = pkt->src_addr; ! 351: if ((elapp->elap_if.ifType == IFTYPE_FDDITALK) ! 352: || (elapp->elap_if.ifType == IFTYPE_TOKENTALK)) ! 353: ddp_bit_reverse(&amt_ptr->dest_addr); ! 354: m = amt_ptr->m; ! 355: amt_ptr->m = NULL; ! 356: pat_output(amt_ptr->elapp->pat_id, m, ! 357: (unsigned char *)&amt_ptr->dest_addr, 0); ! 358: break; ! 359: default : ! 360: /* probing in a weird state?? */ ! 361: return(-1); ! 362: } ! 363: return(0); ! 364: } ! 365: ! 366: ! 367: ! 368: /**************************************************************************** ! 369: * aarp_probe_cmd_in() ! 370: * ! 371: ****************************************************************************/ ! 372: StaticProc int aarp_probe_cmd_in (pkt, elapp) ! 373: register aarp_pkt_t *pkt; ! 374: elap_specifics_t *elapp; ! 375: { ! 376: register aarp_amt_t *amt_ptr; ! 377: ! 378: switch (probing) { ! 379: case PROBE_TENTATIVE : ! 380: if ((elapp == probe_cb.elapp) && ! 381: ATALK_EQUAL(pkt->src_at_addr, probe_cb.elapp->cfg.initial_addr)) { ! 382: /* some bozo is probing for address I want... and I ! 383: * can't tell him to shove off! ! 384: */ ! 385: atalk_untimeout(aarp_sched_probe, 0, probe_tmo); ! 386: probe_cb.no_of_retries = 0; ! 387: aarp_get_next_node(probe_cb.elapp); ! 388: no_of_nodes_tried++; ! 389: ! 390: if (no_of_nodes_tried == AARP_MAX_NODES_TRIED) { ! 391: aarp_get_rand_net(probe_cb.elapp); ! 392: aarp_get_rand_node(probe_cb.elapp); ! 393: no_of_nodes_tried = 0; ! 394: no_of_nets_tried++; ! 395: } ! 396: if (no_of_nets_tried == AARP_MAX_NETS_TRIED) { ! 397: /* We have tried enough nodes and nets, give up. ! 398: */ ! 399: probe_cb.error = EADDRNOTAVAIL; ! 400: AARPwakeup(&probe_cb); ! 401: return(0); ! 402: } ! 403: if (aarp_send_probe() == -1) { ! 404: /* expecting aarp_send_probe to fill in ! 405: * probe_cb.error ! 406: */ ! 407: AARPwakeup(&probe_cb); ! 408: return(-1); ! 409: } ! 410: } else { ! 411: /* somebody's probing... none of my business yet, so ! 412: * just ignore the packet ! 413: */ ! 414: return (0); ! 415: } ! 416: break; ! 417: ! 418: case PROBE_DONE : ! 419: if (ATALK_EQUAL(pkt->src_at_addr, elapp->elap_if.ifThisNode)) { ! 420: if (aarp_send_resp(elapp, pkt) == -1) ! 421: return (-1); ! 422: return (0); ! 423: } ! 424: AMT_LOOK(amt_ptr, pkt->src_at_addr, elapp); ! 425: ! 426: if (amt_ptr) ! 427: aarp_delete_amt_info(amt_ptr); ! 428: break; ! 429: default : ! 430: /* probing in a weird state?? */ ! 431: return (-1); ! 432: } ! 433: return (0); ! 434: } ! 435: ! 436: ! 437: ! 438: /**************************************************************************** ! 439: * aarp_chk_addr() ! 440: ****************************************************************************/ ! 441: StaticProc int aarp_chk_addr(p, elapp) ! 442: char *p; ! 443: register elap_specifics_t *elapp; ! 444: { ! 445: register at_ddp_t *ddp_hdrp; ! 446: ! 447: ddp_hdrp = (at_ddp_t *)p; ! 448: ! 449: if ((ddp_hdrp->dst_node == elapp->cfg.node.atalk_node) && ! 450: (NET_VALUE(ddp_hdrp->dst_net) == ! 451: NET_VALUE(elapp->elap_if.ifThisNode.atalk_net))) { ! 452: return(0); /* exact match in address */ ! 453: } ! 454: ! 455: if (AARP_BROADCAST(ddp_hdrp, elapp)) { ! 456: return(0); /* some kind of broadcast address */ ! 457: } ! 458: return (AARP_ERR_NOT_OURS); /* not for us */ ! 459: } ! 460: ! 461: ! 462: ! 463: /**************************************************************************** ! 464: * aarp_send_data() ! 465: * ! 466: * remarks : ! 467: * 1. The message coming in would be of the form {802.3, 802.2, ddp,...} ! 468: * ! 469: * 2. The message coming in would be freed here if transmission goes ! 470: * through okay. If an error is returned by aarp_send_data, the caller ! 471: * can assume that the message is not freed. The exception to ! 472: * this scenario is the prepended atalk_addr field. This field ! 473: * will ALWAYS be removed. If the message is dropped, ! 474: * it's not an "error". ! 475: * ! 476: ****************************************************************************/ ! 477: ! 478: int aarp_send_data(m, elapp, dest_at_addr, loop) ! 479: register gbuf_t *m; ! 480: register elap_specifics_t *elapp; ! 481: struct atalk_addr *dest_at_addr; ! 482: int loop; /* if true, loopback broadcasts */ ! 483: { ! 484: register aarp_amt_t *amt_ptr; ! 485: register at_ddp_t *ddp_hdrp; ! 486: int error; ! 487: int s; ! 488: extern void elap_input(gbuf_t *, elap_specifics_t *, char *); ! 489: ! 490: if (gbuf_len(m) <= 0) ! 491: ddp_hdrp = (at_ddp_t *)gbuf_rptr(gbuf_cont(m)); ! 492: else ! 493: ddp_hdrp = (at_ddp_t *)gbuf_rptr(m); ! 494: ! 495: if ((ddp_hdrp->dst_node == ddp_hdrp->src_node) && ! 496: (NET_VALUE(ddp_hdrp->dst_net) == NET_VALUE(ddp_hdrp->src_net))) { ! 497: /* ! 498: * we're sending to ourselves ! 499: * so loop it back upstream ! 500: */ ! 501: elap_input(m, elapp, NULL); ! 502: return(0); ! 503: } ! 504: ATDISABLE(s, arpinp_lock); ! 505: AMT_LOOK(amt_ptr, *dest_at_addr, elapp); ! 506: ! 507: ! 508: if (amt_ptr) { ! 509: if (amt_ptr->m) { ! 510: /* ! 511: * there's already a packet awaiting transmission, so ! 512: * drop this one and let the upper layer retransmit ! 513: * later. ! 514: */ ! 515: ATENABLE(s, arpinp_lock); ! 516: gbuf_freel(m); ! 517: return (0); ! 518: } ! 519: ATENABLE(s, arpinp_lock); ! 520: return (pat_output(elapp->pat_id, m, ! 521: (unsigned char *)&amt_ptr->dest_addr, 0)); ! 522: } ! 523: /* ! 524: * either this is a packet to be broadcasted, or the address ! 525: * resolution needs to be done ! 526: */ ! 527: if (AARP_BROADCAST(ddp_hdrp, elapp)) { ! 528: gbuf_t *newm = 0; ! 529: struct etalk_addr *dest_addr; ! 530: ! 531: ATENABLE(s, arpinp_lock); ! 532: dest_addr = &elapp->cable_multicast_addr; ! 533: if (loop) ! 534: newm = (gbuf_t *)gbuf_dupm(m); ! 535: ! 536: if ( !(error = pat_output(elapp->pat_id, m, ! 537: (unsigned char *)dest_addr, 0))) { ! 538: /* ! 539: * The message transmitted successfully; ! 540: * Also loop a copy back up since this ! 541: * is a broadcast message. ! 542: */ ! 543: if (loop) { ! 544: if (newm == NULL) ! 545: return (error); ! 546: elap_input(newm, elapp, NULL); ! 547: } /* endif loop */ ! 548: } else { ! 549: if (newm) ! 550: gbuf_freem(newm); ! 551: } ! 552: return (error); ! 553: } ! 554: NEW_AMT(amt_ptr, *dest_at_addr,elapp); ! 555: ! 556: if (amt_ptr->m) { ! 557: /* ! 558: * no non-busy slots available in the cache, so ! 559: * drop this one and let the upper layer retransmit ! 560: * later. ! 561: */ ! 562: ATENABLE(s, arpinp_lock); ! 563: gbuf_freel(m); ! 564: return (0); ! 565: } ! 566: amt_ptr->dest_at_addr = *dest_at_addr; ! 567: amt_ptr->dest_at_addr.atalk_unused = 0; ! 568: amt_ptr->last_time = time.tv_sec; ! 569: amt_ptr->m = m; ! 570: amt_ptr->elapp = elapp; ! 571: amt_ptr->no_of_retries = 0; ! 572: ATENABLE(s, arpinp_lock); ! 573: ! 574: if ((error = aarp_send_req(amt_ptr))) { ! 575: aarp_delete_amt_info(amt_ptr); ! 576: return(error); ! 577: } ! 578: return(0); ! 579: } ! 580: ! 581: ! 582: ! 583: /**************************************************************************** ! 584: * aarp_send_resp() ! 585: * ! 586: * remarks : ! 587: * The pkt being passed here is only to "look at". It should neither ! 588: * be used for transmission, nor freed. Its contents also must not be ! 589: * altered. ! 590: * ! 591: ****************************************************************************/ ! 592: StaticProc int aarp_send_resp(elapp, pkt) ! 593: register elap_specifics_t *elapp; ! 594: aarp_pkt_t *pkt; ! 595: { ! 596: register aarp_pkt_t *new_pkt; ! 597: register gbuf_t *m; ! 598: ! 599: if ((m = gbuf_alloc(AT_WR_OFFSET+sizeof(aarp_pkt_t), PRI_MED)) == NULL) { ! 600: return (-1); ! 601: } ! 602: gbuf_rinc(m,AT_WR_OFFSET); ! 603: gbuf_wset(m,0); ! 604: ! 605: new_pkt = (aarp_pkt_t *)gbuf_rptr(m); ! 606: aarp_build_pkt(new_pkt, elapp); ! 607: ! 608: new_pkt->aarp_cmd = AARP_RESP_CMD; ! 609: new_pkt->dest_addr = pkt->src_addr; ! 610: new_pkt->dest_at_addr = pkt->src_at_addr; ! 611: new_pkt->dest_at_addr.atalk_unused = 0; ! 612: new_pkt->src_at_addr = elapp->elap_if.ifThisNode; ! 613: new_pkt->src_at_addr.atalk_unused = 0; ! 614: gbuf_winc(m,sizeof(aarp_pkt_t)); ! 615: if ((elapp->elap_if.ifType == IFTYPE_FDDITALK) ! 616: || (elapp->elap_if.ifType == IFTYPE_TOKENTALK)) ! 617: ddp_bit_reverse(&new_pkt->dest_addr); ! 618: ! 619: if (pat_output(elapp->pat_id, m, (unsigned char *)&new_pkt->dest_addr, ! 620: AARP_AT_TYPE)) ! 621: return(-1); ! 622: return(0); ! 623: } ! 624: ! 625: ! 626: ! 627: /**************************************************************************** ! 628: * aarp_send_req() ! 629: * ! 630: ****************************************************************************/ ! 631: ! 632: StaticProc int aarp_send_req (amt_ptr) ! 633: register aarp_amt_t *amt_ptr; ! 634: { ! 635: register aarp_pkt_t *pkt; ! 636: register gbuf_t *m; ! 637: int error; ! 638: ! 639: if ((m = gbuf_alloc(AT_WR_OFFSET+sizeof(aarp_pkt_t), PRI_MED)) == NULL) { ! 640: return (ENOBUFS); ! 641: } ! 642: gbuf_rinc(m,AT_WR_OFFSET); ! 643: gbuf_wset(m,0); ! 644: ! 645: pkt = (aarp_pkt_t *)gbuf_rptr(m); ! 646: aarp_build_pkt(pkt, amt_ptr->elapp); ! 647: ! 648: pkt->aarp_cmd = AARP_REQ_CMD; ! 649: pkt->dest_addr = et_zeroaddr; ! 650: pkt->dest_at_addr = amt_ptr->dest_at_addr; ! 651: pkt->dest_at_addr.atalk_unused = 0; ! 652: pkt->src_at_addr = amt_ptr->elapp->elap_if.ifThisNode; ! 653: gbuf_winc(m,sizeof(aarp_pkt_t)); ! 654: ! 655: amt_ptr->no_of_retries++; ! 656: amt_ptr->tmo = atalk_timeout(aarp_sched_req, amt_ptr, AARP_REQ_TIMER_INT); ! 657: error = pat_output(amt_ptr->elapp->pat_id, m, ! 658: (unsigned char *)&amt_ptr->elapp->cable_multicast_addr, AARP_AT_TYPE); ! 659: if (error) ! 660: { ! 661: atalk_untimeout(aarp_sched_req, amt_ptr, amt_ptr->tmo); ! 662: amt_ptr->tmo = 0; ! 663: return(error); ! 664: } ! 665: ! 666: return(0); ! 667: } ! 668: ! 669: ! 670: ! 671: /**************************************************************************** ! 672: * aarp_send_probe() ! 673: * ! 674: ****************************************************************************/ ! 675: StaticProc int aarp_send_probe() ! 676: { ! 677: register aarp_pkt_t *pkt; ! 678: register gbuf_t *m; ! 679: ! 680: if ((m = gbuf_alloc(AT_WR_OFFSET+sizeof(aarp_pkt_t), PRI_MED)) == NULL) { ! 681: probe_cb.error = ENOBUFS; ! 682: return (-1); ! 683: } ! 684: gbuf_rinc(m,AT_WR_OFFSET); ! 685: gbuf_wset(m,0); ! 686: pkt = (aarp_pkt_t *)gbuf_rptr(m); ! 687: aarp_build_pkt(pkt, probe_cb.elapp); ! 688: ! 689: pkt->aarp_cmd = AARP_PROBE_CMD; ! 690: pkt->dest_addr = et_zeroaddr; ! 691: pkt->src_at_addr.atalk_unused = 0; ! 692: pkt->src_at_addr = probe_cb.elapp->cfg.initial_addr; ! 693: pkt->dest_at_addr = probe_cb.elapp->cfg.initial_addr; ! 694: gbuf_winc(m,sizeof(aarp_pkt_t)); ! 695: ! 696: probe_cb.error = pat_output(probe_cb.elapp->pat_id, m, ! 697: (unsigned char *)&probe_cb.elapp->cable_multicast_addr, AARP_AT_TYPE); ! 698: if (probe_cb.error) { ! 699: return(-1); ! 700: } ! 701: ! 702: probing = PROBE_TENTATIVE; ! 703: probe_cb.no_of_retries++; ! 704: probe_tmo = atalk_timeout(aarp_sched_probe, 0, AARP_PROBE_TIMER_INT); ! 705: ! 706: return(0); ! 707: } ! 708: ! 709: ! 710: ! 711: /**************************************************************************** ! 712: * aarp_lru_entry() ! 713: * ! 714: ****************************************************************************/ ! 715: ! 716: StaticProc aarp_amt_t *aarp_lru_entry(at) ! 717: register aarp_amt_t *at; ! 718: { ! 719: register aarp_amt_t *at_ret; ! 720: register int i; ! 721: ! 722: at_ret = at; ! 723: ! 724: for (i = 1, at++; i < AMT_BSIZ; i++, at++) { ! 725: if (at->last_time < at_ret->last_time && (at->m == NULL)) ! 726: at_ret = at; ! 727: } ! 728: return(at_ret); ! 729: } ! 730: ! 731: ! 732: ! 733: /**************************************************************************** ! 734: * aarp_glean_info() ! 735: * ! 736: ****************************************************************************/ ! 737: ! 738: StaticProc int aarp_glean_info(pkt, elapp) ! 739: register aarp_pkt_t *pkt; ! 740: elap_specifics_t *elapp; ! 741: { ! 742: register aarp_amt_t *amt_ptr; ! 743: int s; ! 744: ! 745: ATDISABLE(s, arpinp_lock); ! 746: AMT_LOOK(amt_ptr, pkt->src_at_addr, elapp); ! 747: ! 748: if (amt_ptr == NULL) { ! 749: /* ! 750: * amt entry for this address doesn't exist, add it to the cache ! 751: */ ! 752: NEW_AMT(amt_ptr, pkt->src_at_addr,elapp); ! 753: ! 754: if (amt_ptr->m) ! 755: { ! 756: ATENABLE(s, arpinp_lock); ! 757: return(0); /* no non-busy slots available in the cache */ ! 758: } ! 759: amt_ptr->dest_at_addr = pkt->src_at_addr; ! 760: amt_ptr->dest_at_addr.atalk_unused = 0; ! 761: amt_ptr->last_time = (int)random(); ! 762: } ! 763: /* ! 764: * update the ethernet address ! 765: * in either case ! 766: */ ! 767: amt_ptr->dest_addr = pkt->src_addr; ! 768: if ((elapp->elap_if.ifType == IFTYPE_FDDITALK) ! 769: || (elapp->elap_if.ifType == IFTYPE_TOKENTALK)) ! 770: ddp_bit_reverse(&amt_ptr->dest_addr); ! 771: ATENABLE(s, arpinp_lock); ! 772: return(1); ! 773: } ! 774: ! 775: ! 776: /**************************************************************************** ! 777: * aarp_delete_amt_info() ! 778: * ! 779: ****************************************************************************/ ! 780: ! 781: StaticProc int aarp_delete_amt_info(amt_ptr) ! 782: register aarp_amt_t *amt_ptr; ! 783: { ! 784: register s; ! 785: register gbuf_t *m; ! 786: ATDISABLE(s, arpinp_lock); ! 787: amt_ptr->last_time = 0; ! 788: ATALK_ASSIGN(amt_ptr->dest_at_addr, 0, 0, 0); ! 789: amt_ptr->no_of_retries = 0; ! 790: ! 791: if (amt_ptr->m) { ! 792: m = amt_ptr->m; ! 793: amt_ptr->m = NULL; ! 794: ATENABLE(s, arpinp_lock); ! 795: gbuf_freel(m); ! 796: } ! 797: else ! 798: ATENABLE(s, arpinp_lock); ! 799: return(0); ! 800: } ! 801: ! 802: ! 803: ! 804: /**************************************************************************** ! 805: * aarp_sched_probe() ! 806: * ! 807: ****************************************************************************/ ! 808: ! 809: StaticProc int aarp_sched_probe() ! 810: { ! 811: if (probe_cb.no_of_retries != AARP_MAX_PROBE_RETRIES) { ! 812: if (aarp_send_probe() == -1) ! 813: AARPwakeup(&probe_cb); ! 814: } else { ! 815: probe_cb.error = 0; ! 816: AARPwakeup(&probe_cb); ! 817: } ! 818: ! 819: return(0); ! 820: } ! 821: ! 822: ! 823: ! 824: /**************************************************************************** ! 825: * aarp_build_pkt() ! 826: * ! 827: ****************************************************************************/ ! 828: ! 829: StaticProc int aarp_build_pkt(pkt, elapp) ! 830: register aarp_pkt_t *pkt; ! 831: elap_specifics_t *elapp; ! 832: { extern void elap_get_addr(int, unsigned char *); ! 833: ! 834: pkt->hardware_type = AARP_ETHER_HW_TYPE; ! 835: pkt->stack_type = AARP_AT_PROTO; ! 836: pkt->hw_addr_len = AARP_ETHER_ADDR_LEN; ! 837: pkt->stack_addr_len = AARP_AT_ADDR_LEN; ! 838: elap_get_addr(elapp->pat_id, pkt->src_addr.etalk_addr_octet); ! 839: if ((elapp->elap_if.ifType == IFTYPE_FDDITALK) ! 840: || (elapp->elap_if.ifType == IFTYPE_TOKENTALK)) ! 841: ddp_bit_reverse(pkt->src_addr.etalk_addr_octet); ! 842: return(0); ! 843: } ! 844: ! 845: ! 846: ! 847: /**************************************************************************** ! 848: * aarp_sched_req() ! 849: * ! 850: ****************************************************************************/ ! 851: ! 852: StaticProc int aarp_sched_req(amt_ptr) ! 853: register aarp_amt_t *amt_ptr; ! 854: { ! 855: int s; ! 856: ! 857: ATDISABLE(s, arpinp_lock); ! 858: if (amt_ptr->tmo == 0) ! 859: { ! 860: ATENABLE(s, arpinp_lock); ! 861: return(0); ! 862: } ! 863: if (amt_ptr->no_of_retries < AARP_MAX_REQ_RETRIES) { ! 864: ATENABLE(s, arpinp_lock); ! 865: if (aarp_send_req(amt_ptr) == 0) ! 866: return(0); ! 867: ATDISABLE(s, arpinp_lock); ! 868: } ! 869: ATENABLE(s, arpinp_lock); ! 870: aarp_delete_amt_info(amt_ptr); ! 871: return(0); ! 872: } ! 873: ! 874: ! 875: ! 876: /**************************************************************************** ! 877: * aarp_get_rand_node() ! 878: * ! 879: ****************************************************************************/ ! 880: StaticProc int aarp_get_rand_node(elapp) ! 881: elap_specifics_t *elapp; ! 882: { ! 883: register u_char node; ! 884: ! 885: /* ! 886: * generate a starting node number in the range 1 thru 0xfd. ! 887: * we use this as the starting probe point for a given net ! 888: * To generate a different node number each time we call ! 889: * aarp_get_next_node ! 890: */ ! 891: node = ((u_char)(random() & 0xff)) % 0xfd + 2; ! 892: ! 893: elapp->cfg.initial_addr.atalk_node = node; ! 894: return(0); ! 895: } ! 896: ! 897: ! 898: ! 899: StaticProc int aarp_get_next_node(elapp) ! 900: elap_specifics_t *elapp; ! 901: { ! 902: register u_char node = elapp->cfg.initial_addr.atalk_node; ! 903: ! 904: /* ! 905: * return the next node number in the range 1 thru 0xfd. ! 906: */ ! 907: node = (node == 0xfd) ? (1) : (node+1); ! 908: ! 909: elapp->cfg.initial_addr.atalk_node = node; ! 910: return(0); ! 911: } ! 912: ! 913: ! 914: ! 915: ! 916: ! 917: /**************************************************************************** ! 918: * aarp_get_rand_net() ! 919: * ! 920: ****************************************************************************/ ! 921: StaticProc int aarp_get_rand_net(elapp) ! 922: register elap_specifics_t *elapp; ! 923: { ! 924: register at_net_al last_net, new_net; ! 925: ! 926: if (elapp->elap_if.ifThisCableStart) { ! 927: last_net = NET_VALUE(elapp->cfg.initial_addr.atalk_net); ! 928: /* ! 929: * the range of network numbers valid for this ! 930: * cable is known. Try to choose a number from ! 931: * this range only. ! 932: */ ! 933: new_net= ((at_net_al)random() & 0xffff); ! 934: /* two-byte random number generated... now fit it in ! 935: * the prescribed range ! 936: */ ! 937: new_net = new_net % (unsigned) (elapp->elap_if.ifThisCableEnd - ! 938: elapp->elap_if.ifThisCableStart + 1) ! 939: + elapp->elap_if.ifThisCableStart; ! 940: ! 941: if (new_net == last_net) { ! 942: if (new_net == elapp->elap_if.ifThisCableEnd) ! 943: new_net = elapp->elap_if.ifThisCableStart; ! 944: else ! 945: new_net++; ! 946: } ! 947: NET_ASSIGN(elapp->cfg.initial_addr.atalk_net, new_net); ! 948: } else { ! 949: /* The range of valid network numbers for this cable ! 950: * is not known... choose a network number from ! 951: * startup range. ! 952: */ ! 953: last_net = (NET_VALUE(elapp->cfg.initial_addr.atalk_net) & 0x00ff); ! 954: new_net = (at_net_al)random() & 0x00ff; ! 955: ! 956: if (new_net == last_net) ! 957: new_net++; ! 958: if (new_net == 0xff) ! 959: new_net = 0; ! 960: NET_ASSIGN(elapp->cfg.initial_addr.atalk_net, (DDP_STARTUP_LOW | new_net)); ! 961: } ! 962: return(0); ! 963: } ! 964: ! 965: ! 966: int ! 967: getAarpTableSize(elapId) ! 968: int elapId; /* elap_specifics array index (should be ! 969: * changed when we add a non-ethernet type ! 970: * of I/F to the mix. Unused for now. ! 971: */ ! 972: { ! 973: return(AMTSIZE); ! 974: } ! 975: ! 976: int ! 977: getPhysAddrSize(elapId) ! 978: int elapId; /* elap_specifics array index (should be ! 979: * changed when we add a non-ethernet type ! 980: * of I/F to the mix. Unused for now. ! 981: */ ! 982: { ! 983: return(AARP_ETHER_ADDR_LEN); ! 984: } ! 985: ! 986: #define ENTRY_SIZE sizeof(struct atalk_addr) + sizeof(struct etalk_addr) ! 987: ! 988: snmpAarpEnt_t * ! 989: getAarp(elapId) ! 990: int *elapId; /* I/F table to retrieve & table ! 991: size entries on return */ ! 992: ! 993: /* gets aarp table for specified interface and builds ! 994: a table in SNMP expected format. Returns pointer to said ! 995: table and sets elapId to byte size of used portion of table ! 996: */ ! 997: { ! 998: int i, cnt=0; ! 999: aarp_amt_t *amtp; ! 1000: static snmpAarpEnt_t snmp[AMTSIZE]; ! 1001: snmpAarpEnt_t *snmpp; ! 1002: ! 1003: ! 1004: if (*elapId <0 || *elapId >= IF_TYPE_ET_MAX ! 1005: /* || elap_specifics[*elapId].elap_if.ifState == LAP_OFFLINE */ ! 1006: ) ! 1007: return NULL; ! 1008: ! 1009: ! 1010: for (i=0, amtp = et_aarp_amt[*elapId],snmpp = snmp; ! 1011: i < AMTSIZE; i++,amtp++) { ! 1012: ! 1013: /* last_time will be 0 if entry was never used */ ! 1014: if (amtp->last_time) { ! 1015: /* copy just network & mac address. ! 1016: * For speed, we assume that the atalk_addr ! 1017: * & etalk_addr positions in the aarp_amt_t struct ! 1018: * has not changed and copy both at once ! 1019: */ ! 1020: bcopy(&amtp->dest_at_addr, &snmpp->ap_ddpAddr, ENTRY_SIZE); ! 1021: snmpp++; ! 1022: cnt++; ! 1023: ! 1024: } ! 1025: } ! 1026: *elapId = cnt; ! 1027: return(snmp); ! 1028: } ! 1029: /*#endif *//* COMMENTED_OUT */ ! 1030:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.