![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOEthernetInterface.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IONetworking|
Return to IOEthernetInterface.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IONetworking |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-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) 1999 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * IOEthernetInterface.cpp ! 26: * ! 27: * HISTORY ! 28: * 8-Jan-1999 Joe Liu (jliu) created. ! 29: * ! 30: */ ! 31: ! 32: #include <IOKit/assert.h> ! 33: #include <IOKit/IOLib.h> ! 34: #include <libkern/c++/OSData.h> ! 35: #include <IOKit/network/IOEthernetInterface.h> ! 36: #include <IOKit/network/IOEthernetController.h> ! 37: #include <IOKit/network/IONetworkUserClient.h> ! 38: ! 39: extern "C" { ! 40: #include <sys/param.h> ! 41: #include <sys/errno.h> ! 42: #include <net/if_dl.h> ! 43: #include <net/if_types.h> ! 44: #include <sys/sockio.h> ! 45: #include <netinet/in_var.h> ! 46: #include <sys/malloc.h> ! 47: void arpwhohas(struct arpcom * ac, struct in_addr * addr); ! 48: } ! 49: ! 50: //--------------------------------------------------------------------------- ! 51: ! 52: #define super IONetworkInterface ! 53: ! 54: OSDefineMetaClassAndStructors( IOEthernetInterface, IONetworkInterface ) ! 55: ! 56: // The name prefix for all BSD Ethernet interfaces. ! 57: // ! 58: #define kIOEthernetInterfaceNamePrefix "en" ! 59: ! 60: //--------------------------------------------------------------------------- ! 61: // Macros ! 62: ! 63: #define CTLR_SYNC_REQ(ctlr, action, ret, args...) \ ! 64: ctlr->syncRequest(this, this, (IONetworkAction) action, \ ! 65: (UInt32 *) ret, ## args) ! 66: ! 67: #ifdef DEBUG ! 68: #define DLOG(fmt, args...) IOLog(fmt, ## args) ! 69: #else ! 70: #define DLOG ! 71: #endif ! 72: ! 73: //--------------------------------------------------------------------------- ! 74: // Initialize an IOEthernetInterface instance. Instance variables are ! 75: // initialized, and an arpcom structure is allocated. ! 76: ! 77: bool IOEthernetInterface::init(OSDictionary * properties = 0) ! 78: { ! 79: // Initialize instance variables. ! 80: // ! 81: _arpcom = 0; // arpcom structure. ! 82: _mcAddrCount = 0; // number of multicast addresses. ! 83: _features = 0; // controller's family specific features. ! 84: _activeFilters = 0; // active packet filters. ! 85: _availableFilters = 0; // available packet filters. ! 86: _controllerEnabled = false; ! 87: ! 88: // Allocate an arpcom structure, clear it, then call super::init(). ! 89: // We expect our superclass to call getIfnet() during its init() ! 90: // method. So we have to create arpcom before calling super::init(). ! 91: ! 92: if ((_arpcom = (struct arpcom *) IOMalloc(sizeof(*_arpcom))) == 0) ! 93: { ! 94: DLOG("IOEthernetInterface: arpcom allocation failed\n"); ! 95: return false; ! 96: } ! 97: ! 98: bzero(_arpcom, sizeof(*_arpcom)); ! 99: ! 100: // Pass the init() call to our superclass. ! 101: // ! 102: if (!super::init(properties)) ! 103: return false; ! 104: ! 105: // Add an IONetworkData with room to hold an IOEthernetStats structure. ! 106: // This class does not reference the data object created, and no harm ! 107: // is done if the data object is released. ! 108: ! 109: IONetworkData * data = IONetworkData::withName(kIOEthernetStatsKey, ! 110: sizeof(IOEthernetStats)); ! 111: if (data) { ! 112: addNetworkData(data); ! 113: data->release(); ! 114: } ! 115: ! 116: return true; ! 117: } ! 118: ! 119: //--------------------------------------------------------------------------- ! 120: // Initialize the ifnet structure. The argument specified is ! 121: // a pointer to an ifnet structure obtained through getIfnet(). ! 122: // IOEthernetInterface will initialize this structure in a manner that ! 123: // is appropriate for Ethernet interfaces. ! 124: // ! 125: // ifp: Pointer to the ifnet structure to be initialized. ! 126: // ! 127: // Returns true if successful, false otherwise. ! 128: ! 129: bool IOEthernetInterface::initIfnet(struct ifnet * ifp) ! 130: { ! 131: struct arpcom * ac = (struct arpcom *) ifp; ! 132: ! 133: assert(ac); ! 134: ! 135: lock(); // lock interface state ! 136: ! 137: bzero(ac, sizeof(*ac)); ! 138: ! 139: // Set defaults suitable for Ethernet interfaces. ! 140: ! 141: setInterfaceType(IFT_ETHER); ! 142: setMaxTransferUnit(ETHERMTU); ! 143: setMediaAddressLength(NUM_EN_ADDR_BYTES); ! 144: setMediaHeaderLength(ETHERHDRSIZE); ! 145: setFlags(IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS); ! 146: ! 147: unlock(); // unlock interface state ! 148: ! 149: return super::initIfnet(ifp); ! 150: } ! 151: ! 152: //--------------------------------------------------------------------------- ! 153: // Free the IOEthernetInterface instance. The memory allocated ! 154: // for the arpcom structure is released. ! 155: ! 156: void IOEthernetInterface::free() ! 157: { ! 158: if (_arpcom) IOFree(_arpcom, sizeof(*_arpcom)); ! 159: ! 160: super::free(); ! 161: } ! 162: ! 163: //--------------------------------------------------------------------------- ! 164: // This method returns a pointer to an ifnet structure ! 165: // maintained by the family specific interface. IOEthernetInterface ! 166: // allocates an arpcom structure during initialization, and returns ! 167: // a pointer to this structure when this method is called. ! 168: // ! 169: // Returns a pointer to an ifnet structure. ! 170: ! 171: struct ifnet * IOEthernetInterface::getIfnet() const ! 172: { ! 173: return (&(_arpcom->ac_if)); ! 174: } ! 175: ! 176: //--------------------------------------------------------------------------- ! 177: // The name of the interface advertised to the network layer ! 178: // is generated by concatenating the string returned by this method, ! 179: // and an unit number. ! 180: // ! 181: // Returns a pointer to a constant string "en". Thus Ethernet interfaces ! 182: // will be registered as en0, en1, etc. ! 183: ! 184: const char * IOEthernetInterface::getNamePrefix() const ! 185: { ! 186: return kIOEthernetInterfaceNamePrefix; ! 187: } ! 188: ! 189: //--------------------------------------------------------------------------- ! 190: // Update the packet filter property. This property contains the set of ! 191: // packet filters needed by the interface. It may not represent the set ! 192: // of packet filters that are actually in use and enabled. ! 193: // ! 194: // Returns true if the newFilter provided is different from the previously ! 195: // cached value. ! 196: ! 197: bool IOEthernetInterface::_setActiveFilters(UInt32 newFilters) ! 198: { ! 199: if (newFilters == _activeFilters) ! 200: return false; ! 201: ! 202: _activeFilters = newFilters; ! 203: setProperty(kIOPacketFilters, _activeFilters, 32); ! 204: return true; ! 205: } ! 206: ! 207: //--------------------------------------------------------------------------- ! 208: // Prepare the controller after it has been opened. ! 209: // This method will be called by our superclass after a ! 210: // network controller has accepted an open from this interface. ! 211: // IOEthernetInterface uses this method to inspect the controller ! 212: // and to cache certain controller properties, such as its hardware ! 213: // address, and its set of supported packet filters. ! 214: // ! 215: // controller: The controller object that was opened. ! 216: // ! 217: // Returns true if the controller was accepted, false otherwise ! 218: // (which will cause the controller to be closed). ! 219: ! 220: bool IOEthernetInterface::controllerDidOpen(IONetworkController * inController) ! 221: { ! 222: bool ret = false; ! 223: IOEthernetController * controller = OSDynamicCast(IOEthernetController, ! 224: inController); ! 225: ! 226: do { ! 227: IOReturn r; ! 228: ! 229: if (!controller) ! 230: break; ! 231: ! 232: // Call the superclass' controllerDidOpen(). ! 233: // ! 234: if (!super::controllerDidOpen(controller)) ! 235: break; ! 236: ! 237: // Cache the controller's family feature set. ! 238: // ! 239: _features = controller->getFamilyFeatureSet(); ! 240: ! 241: // Get the controller's (supported) packet filters. ! 242: // ! 243: r = controller->doGetPacketFilters(this, &_availableFilters); ! 244: ! 245: if (r != kIOReturnSuccess) ! 246: { ! 247: DLOG("%s: doGetPacketFilters error %x\n", getName(), r); ! 248: break; ! 249: } ! 250: ! 251: // Controller must support Unicast and Broadcast filtering. ! 252: // ! 253: if ((_availableFilters & ! 254: (kIOPacketFilterUnicast | kIOPacketFilterBroadcast)) != ! 255: (kIOPacketFilterUnicast | kIOPacketFilterBroadcast)) ! 256: { ! 257: DLOG("%s: No Unicast/Broadcast packet filters %lx\n", ! 258: getName(), _availableFilters); ! 259: break; ! 260: } ! 261: ! 262: // If controller reports multicast or multicast-all capability, ! 263: // then update if_flags to include multicast support. ! 264: // ! 265: if (_availableFilters & ! 266: (kIOPacketFilterMulticast | kIOPacketFilterMulticastAll)) ! 267: { ! 268: setFlagsInt(IFF_MULTICAST); ! 269: } ! 270: ! 271: // Even though the network stack will not explicitly request the ! 272: // interface to enable Unicast and Broadcast filtering. It is ! 273: // implicit. Therefore, we will always activate both of those ! 274: // filter types. ! 275: ! 276: _setActiveFilters(kIOPacketFilterUnicast | kIOPacketFilterBroadcast); ! 277: ! 278: r = controller->doEnablePacketFilters(this, _activeFilters); ! 279: ! 280: if (r != kIOReturnSuccess) ! 281: { ! 282: DLOG("%s: Failed to enable Unicast/Broadcast filters %x\n", ! 283: getName(), r); ! 284: break; ! 285: } ! 286: ! 287: // Read and save the controller's MAC address. ! 288: // ! 289: r = ((IOEthernetController *) ! 290: controller)->doGetHardwareAddress(this, &_macAddr); ! 291: if (r != kIOReturnSuccess) ! 292: { ! 293: DLOG("%s: kRequestGetHardwareAddress error %x\n", getName(), r); ! 294: break; ! 295: } ! 296: ! 297: #if 1 // Print the MAC address ! 298: IOLog("%s: Ethernet address %02x:%02x:%02x:%02x:%02x:%02x\n", ! 299: getName(), ! 300: _macAddr.ether_addr_octet[0], ! 301: _macAddr.ether_addr_octet[1], ! 302: _macAddr.ether_addr_octet[2], ! 303: _macAddr.ether_addr_octet[3], ! 304: _macAddr.ether_addr_octet[4], ! 305: _macAddr.ether_addr_octet[5]); ! 306: #endif ! 307: ! 308: // Copy the hardware address we obtained from the controller ! 309: // to the arpcom structure. ! 310: // ! 311: bcopy(&_macAddr, _arpcom->ac_enaddr, NUM_EN_ADDR_BYTES); ! 312: ! 313: // Store MAC address in interface's propertyTable. ! 314: // ! 315: setProperty(kIOMACAddress, (void *) &_macAddr, NUM_EN_ADDR_BYTES); ! 316: ! 317: ret = true; ! 318: } ! 319: while (0); ! 320: ! 321: return ret; ! 322: } ! 323: ! 324: //--------------------------------------------------------------------------- ! 325: // When the last close from our client is received, the ! 326: // interface object will close its controller. But before the controller ! 327: // is closed, this method will be called by our superclass to perform any ! 328: // final cleanup. IOEthernetInterface will ensure that the controller ! 329: // is disabled before it is closed. ! 330: // ! 331: // controller: The currently opened controller object. ! 332: ! 333: void IOEthernetInterface::controllerWillClose(IONetworkController * controller) ! 334: { ! 335: if (_controllerEnabled) ! 336: { ! 337: // Make sure the controller is disabled when we have lost all ! 338: // our clients, and is about to close the controller. It ! 339: // should be safe to update the _controllerEnabled variable ! 340: // shared with the ioctl handlers, which shouldn't run without ! 341: // an open client. ! 342: ! 343: controller->doDisable(this); ! 344: _controllerEnabled = false; ! 345: } ! 346: ! 347: super::controllerWillClose(controller); ! 348: } ! 349: ! 350: //--------------------------------------------------------------------------- ! 351: // The handler for ioctl commands sent from the network layer. ! 352: // Commands not handled by this method are passed to our superclass. ! 353: // ! 354: // Argument convention is: ! 355: // ! 356: // arg0 - (struct ifnet *) ! 357: // arg1 - (void *) ! 358: // ! 359: // The commands handled by IOEthernetInterface are: ! 360: // ! 361: // SIOCSIFADDR ! 362: // SIOCSIFFLAGS ! 363: // SIOCADDMULTI ! 364: // SIOCDELMULTI ! 365: // ! 366: // Returns an error code defined in errno.h (BSD). ! 367: ! 368: SInt IOEthernetInterface::performCommand(IONetworkController * inController, ! 369: UInt32 cmd, ! 370: void * arg0, ! 371: void * arg1) ! 372: { ! 373: struct arpcom * ac = (struct arpcom *) _arpcom; ! 374: struct ifaddr * ifa = (struct ifaddr *) arg1; ! 375: SInt ret = EBUSY; ! 376: IOEthernetController * controller = (IOEthernetController *) inController; ! 377: ! 378: assert(arg0 == _arpcom); ! 379: ! 380: if (!controller) return EINVAL; ! 381: ! 382: switch (cmd) ! 383: { ! 384: case SIOCSIFADDR: ! 385: CTLR_SYNC_REQ(controller, &IOEthernetInterface::syncSIOCSIFADDR, ! 386: &ret, controller); ! 387: if (ret) ! 388: { ! 389: IOLog("IOEthernetInterface: SIOCSIFADDR returned %d\n", ret); ! 390: break; ! 391: } ! 392: ! 393: switch (ifa->ifa_addr->sa_family) ! 394: { ! 395: case AF_INET: ! 396: // ! 397: // See if another station has *our* IP address. ! 398: // i.e.: There is an address conflict! If a ! 399: // conflict exists, a message is sent to the ! 400: // console. ! 401: // ! 402: if (IA_SIN(ifa)->sin_addr.s_addr != 0) ! 403: { ! 404: /* don't bother for 0.0.0.0 */ ! 405: ac->ac_ipaddr = IA_SIN(ifa)->sin_addr; ! 406: arpwhohas(ac, &IA_SIN(ifa)->sin_addr); ! 407: } ! 408: break; ! 409: ! 410: default: ! 411: break; ! 412: } ! 413: break; ! 414: ! 415: case SIOCSIFFLAGS: ! 416: CTLR_SYNC_REQ(controller, &IOEthernetInterface::syncSIOCSIFFLAGS, ! 417: &ret, controller); ! 418: break; ! 419: ! 420: case SIOCADDMULTI: ! 421: CTLR_SYNC_REQ(controller, &IOEthernetInterface::syncSIOCADDMULTI, ! 422: &ret, controller); ! 423: break; ! 424: ! 425: case SIOCDELMULTI: ! 426: CTLR_SYNC_REQ(controller, &IOEthernetInterface::syncSIOCDELMULTI, ! 427: &ret, controller); ! 428: break; ! 429: ! 430: default: ! 431: // Don't know what to do with this ioctl command, forward it ! 432: // to our superclass. ! 433: // ! 434: ret = super::performCommand(controller, cmd, arg0, arg1); ! 435: break; ! 436: } ! 437: ! 438: return ret; ! 439: } ! 440: ! 441: //--------------------------------------------------------------------------- ! 442: // _enableController() is reponsible for calling the controller's enable() ! 443: // method and restoring the state of the controller. We assume that ! 444: // controllers can completely reset its state upon receiving a disable() ! 445: // method call. And when it is brought back up, the interface should ! 446: // assist in restoring the previous state of the Ethernet controller. ! 447: ! 448: IOReturn IOEthernetInterface::_enableController(IONetworkController * ctlr) ! 449: { ! 450: IOReturn ret; ! 451: ! 452: assert(ctlr); ! 453: ! 454: // Send the controller an enable request. ! 455: // ! 456: ret = ctlr->doEnable(this); ! 457: if (ret != kIOReturnSuccess) ! 458: return ret; // unable to bring up the controller. ! 459: ! 460: // Restore current filter settings. ! 461: // ! 462: ret = ctlr->doEnablePacketFilters(this, _activeFilters); ! 463: if (ret != kIOReturnSuccess) ! 464: goto error; ! 465: ! 466: // Update multicast address list. ! 467: // ! 468: if (_availableFilters & kIOPacketFilterMulticast) ! 469: { ! 470: ret = _loadMulticastList((IOEthernetController *) ctlr); ! 471: if (ret != kIOReturnSuccess) ! 472: goto error; ! 473: } ! 474: ! 475: _controllerEnabled = true; ! 476: ! 477: return kIOReturnSuccess; ! 478: ! 479: error: ! 480: // If the controller was enabled, make sure we disable it if an ! 481: // error occurred. ! 482: // ! 483: DLOG("%s: _enableController error %x\n", getName(), ret); ! 484: ! 485: ret = ctlr->doDisable(this); ! 486: ! 487: return ret; ! 488: } ! 489: ! 490: //--------------------------------------------------------------------------- ! 491: // Handles SIOCSIFFLAGS ioctl command for Ethernet interfaces. The network ! 492: // stack has changed the if_flags field in ifnet. Our job is to go ! 493: // through if_flags and see what has changed, and act accordingly. ! 494: // ! 495: // The fact that if_flags contains both generic and Ethernet specific bits ! 496: // means that we cannot move some of the default flag processing to the ! 497: // superclass. Sigh... ! 498: ! 499: int IOEthernetInterface::syncSIOCSIFFLAGS(IOEthernetController * ctlr) ! 500: { ! 501: SInt r = 0; ! 502: UInt16 flags = getFlags(); ! 503: IOReturn ret; ! 504: UInt32 newFilters = _activeFilters; ! 505: ! 506: if ( !(flags & IFF_UP) && (flags & IFF_RUNNING) ) ! 507: { ! 508: // If interface is marked down and it is running, ! 509: // then stop it. ! 510: ! 511: ctlr->doDisable(this); ! 512: flags &= ~IFF_RUNNING; ! 513: _controllerEnabled = false; ! 514: } ! 515: else if ( (flags & IFF_UP) && !(flags & IFF_RUNNING) ) ! 516: { ! 517: // If interface is marked up and it is stopped, then ! 518: // start it. ! 519: ! 520: if ((ret = _enableController(ctlr)) == kIOReturnSuccess) ! 521: flags |= IFF_RUNNING; ! 522: else ! 523: r = errnoFromReturn(ret); ! 524: } ! 525: ! 526: if (flags & IFF_RUNNING) ! 527: { ! 528: // Set/Clear promiscuous mode. ! 529: // ! 530: if (_availableFilters & kIOPacketFilterPromiscuous) ! 531: { ! 532: if (flags & IFF_PROMISC) ! 533: newFilters |= kIOPacketFilterPromiscuous; ! 534: else ! 535: newFilters &= ~kIOPacketFilterPromiscuous; ! 536: } ! 537: ! 538: // Set/Clear Multicast-All mode. ! 539: // ! 540: if (_availableFilters & kIOPacketFilterMulticastAll) ! 541: { ! 542: if (flags & IFF_ALLMULTI) ! 543: newFilters |= kIOPacketFilterMulticastAll; ! 544: else ! 545: newFilters &= ~kIOPacketFilterMulticastAll; ! 546: } ! 547: } ! 548: ! 549: if (_setActiveFilters(newFilters)) ! 550: { ! 551: ret = ctlr->doEnablePacketFilters(this, newFilters); ! 552: if (ret != kIOReturnSuccess) ! 553: r = errnoFromReturn(ret); ! 554: } ! 555: ! 556: // Update the flags field to pick up any modifications. Also update the ! 557: // property table to reflect any flag changes. ! 558: // ! 559: setFlagsInt(flags, ~flags); ! 560: ! 561: return r; ! 562: } ! 563: ! 564: //--------------------------------------------------------------------------- ! 565: // Handles SIOCSIFADDR ioctl command for Ethernet interfaces. ! 566: ! 567: SInt IOEthernetInterface::syncSIOCSIFADDR(IOEthernetController * ctlr) ! 568: { ! 569: SInt r = 0; ! 570: UInt16 flags = getFlags(); ! 571: ! 572: flags |= IFF_UP; ! 573: ! 574: if (!(flags & IFF_RUNNING)) ! 575: { ! 576: r = errnoFromReturn(_enableController(ctlr)); ! 577: if (r == 0) ! 578: flags |= IFF_RUNNING; ! 579: } ! 580: ! 581: setFlagsInt(flags, ~flags); ! 582: ! 583: return r; ! 584: } ! 585: ! 586: //--------------------------------------------------------------------------- ! 587: // This method is called by syncSIOCADDMULTI() and syncSIOCDELMULTI() to ! 588: // reload the hardware's multicast filter whenever the multicast address ! 589: // list is changed. A OSData is published in the property table containing ! 590: // the multicast addresses. ! 591: ! 592: IOReturn ! 593: IOEthernetInterface::_loadMulticastList(IOEthernetController * ctlr) ! 594: { ! 595: enet_addr_t * multiAddrs = 0; ! 596: UInt mcount; ! 597: OSData * mcData = 0; ! 598: struct ifnet * ifp = (struct ifnet *) _arpcom; ! 599: struct ifmultiaddr * ifma; ! 600: IOReturn ret; ! 601: bool ok; ! 602: ! 603: assert(ifp); ! 604: ! 605: // Update the multicast addresses count ivar. ! 606: // ! 607: mcount = 0; ! 608: for (ifma = ifp->if_multiaddrs.lh_first; ! 609: ifma != NULL; ! 610: ifma = ifma->ifma_link.le_next) ! 611: { ! 612: if ((ifma->ifma_addr->sa_family == AF_UNSPEC) || ! 613: (ifma->ifma_addr->sa_family == AF_LINK)) ! 614: mcount++; ! 615: } ! 616: _mcAddrCount = mcount; ! 617: ! 618: if (mcount) ! 619: { ! 620: char * addrp; ! 621: ! 622: mcData = OSData::withCapacity(mcount * NUM_EN_ADDR_BYTES); ! 623: if (!mcData) ! 624: { ! 625: DLOG("%s: multicast memory allocation failed\n", getName()); ! 626: return kIOReturnNoMemory; ! 627: } ! 628: ! 629: // Loop through the linked multicast structures and write the ! 630: // address to the OSData. ! 631: // ! 632: for (ifma = ifp->if_multiaddrs.lh_first; ! 633: ifma != NULL; ! 634: ifma = ifma->ifma_link.le_next) ! 635: { ! 636: if (ifma->ifma_addr->sa_family == AF_UNSPEC) ! 637: addrp = &ifma->ifma_addr->sa_data[0]; ! 638: else ! 639: if (ifma->ifma_addr->sa_family == AF_LINK) ! 640: addrp = LLADDR((struct sockaddr_dl *) ifma->ifma_addr); ! 641: else ! 642: continue; ! 643: ! 644: ok = mcData->appendBytes((const void *) addrp, NUM_EN_ADDR_BYTES); ! 645: assert(ok); ! 646: } ! 647: ! 648: multiAddrs = (enet_addr_t *) mcData->getBytesNoCopy(); ! 649: assert(multiAddrs); ! 650: } ! 651: ! 652: // Call the controller's setMulticastList() method. ! 653: // ! 654: ret = ctlr->doSetMulticastList(this, multiAddrs, mcount); ! 655: ! 656: if (mcData) ! 657: { ! 658: if (ret == kIOReturnSuccess) ! 659: setProperty(kIOMulticastAddresses, mcData); ! 660: mcData->release(); ! 661: } ! 662: else { ! 663: removeProperty(kIOMulticastAddresses); ! 664: } ! 665: ! 666: return ret; ! 667: } ! 668: ! 669: //--------------------------------------------------------------------------- ! 670: // Handles SIOCADDMULTI ioctl command. ! 671: ! 672: SInt IOEthernetInterface::syncSIOCADDMULTI(IOEthernetController * ctlr) ! 673: { ! 674: IOReturn ret; ! 675: UInt32 activatedFilters; ! 676: SInt r = 0; ! 677: ! 678: if (_availableFilters & kIOPacketFilterMulticast) ! 679: { ! 680: _setActiveFilters(_activeFilters | kIOPacketFilterMulticast); ! 681: ! 682: // Make sure the multicast filter is active. ! 683: // ! 684: ret = ctlr->doEnablePacketFilters(this, _activeFilters, ! 685: &activatedFilters); ! 686: ! 687: // If the controller did not activate the multicast filter, ! 688: // report an error. ! 689: // ! 690: if ((activatedFilters & kIOPacketFilterMulticast) == 0) ! 691: { ! 692: assert(ret != kIOReturnSuccess); ! 693: r = errnoFromReturn(ret); ! 694: } ! 695: ! 696: // Do not load multicast list if the multicast filter ! 697: // did not become active. ! 698: // ! 699: if (r == 0) ! 700: r = errnoFromReturn(_loadMulticastList(ctlr)); ! 701: } ! 702: else ! 703: r = EOPNOTSUPP; // no multicast support. ! 704: ! 705: return r; ! 706: } ! 707: ! 708: //--------------------------------------------------------------------------- ! 709: // Handles SIOCDELMULTI ioctl command. ! 710: ! 711: SInt IOEthernetInterface::syncSIOCDELMULTI(IOEthernetController * ctlr) ! 712: { ! 713: IOReturn ret; ! 714: UInt32 activatedFilters; ! 715: SInt r = 0; ! 716: ! 717: if (_availableFilters & kIOPacketFilterMulticast) ! 718: { ! 719: r = errnoFromReturn(_loadMulticastList(ctlr)); ! 720: ! 721: if (r == 0) ! 722: { ! 723: // If the multicast list is now empty, instruct the controller ! 724: // to turn off its multicast filter. ! 725: ! 726: if (_mcAddrCount == 0) ! 727: { ! 728: _setActiveFilters(_activeFilters & ~kIOPacketFilterMulticast); ! 729: ! 730: ret = ctlr->doEnablePacketFilters(this, _activeFilters, ! 731: &activatedFilters); ! 732: ! 733: if (activatedFilters & kIOPacketFilterMulticast) ! 734: { ! 735: assert(ret != kIOReturnSuccess); ! 736: r = errnoFromReturn(ret); ! 737: } ! 738: } ! 739: } ! 740: } ! 741: else ! 742: r = EOPNOTSUPP; // no multicast support. ! 743: ! 744: return r; ! 745: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.