SystemConfiguration.fproj/LinkConfiguration.c

   1 /*
   2  * Copyright (c) 2002-2007, 2010, 2011 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*
  25  * Modification History
  26  *
  27  * October 21, 2000             Allan Nathanson <ajn@apple.com>
  28  * - initial revision
  29  */
  30
  31
  32 #include <unistd.h>
  33 #define KERNEL_PRIVATE
  34 #include <sys/ioctl.h>
  35 #undef  KERNEL_PRIVATE
  36 #include <sys/socket.h>
  37 #include <net/ethernet.h>
  38 #include <net/if.h>
  39 #include <net/if_vlan_var.h>
  40 #include <net/if_media.h>
  41 #include <net/if_types.h>
  42 #include <netinet/in.h>
  43 #include <netinet/ip6.h>                        // for IPV6_MMTU
  44
  45 #include <SystemConfiguration/SystemConfiguration.h>
  46 #include <SystemConfiguration/SCPrivate.h>      // for SCLog()
  47 #include "SCNetworkConfigurationInternal.h"     // for __SCNetworkInterfaceCreatePrivate
  48 #include <SystemConfiguration/SCValidation.h>
  49
  50 #include <IOKit/IOKitLib.h>
  51 #include <IOKit/network/IONetworkInterface.h>
  52 #include <IOKit/network/IONetworkController.h>
  53 #include "dy_framework.h"
  54
  55
  56 #pragma mark -
  57 #pragma mark Capabilities
  58
  59
  60 // the following table needs to keep the capabilitiy names and values
  61 // between the <SystemConfiguration/SCSchemaDefinitionsPrivate.h> and
  62 // <net/if.h> headers in sync.
  63 static const struct {
  64         const CFStringRef       *name;
  65         Boolean                 readwrite;
  66         int                     val;
  67 } capabilityMappings[] = {
  68 #ifdef  SIOCGIFCAP
  69         { &kSCPropNetEthernetCapabilityRXCSUM,          TRUE,   IFCAP_RXCSUM            },      // can offload checksum on RX
  70         { &kSCPropNetEthernetCapabilityTXCSUM,          TRUE,   IFCAP_TXCSUM            },      // can offload checksum on TX
  71         { &kSCPropNetEthernetCapabilityVLAN_MTU,        FALSE,  IFCAP_VLAN_MTU          },      // VLAN-compatible MTU
  72         { &kSCPropNetEthernetCapabilityVLAN_HWTAGGING,  FALSE,  IFCAP_VLAN_HWTAGGING    },      // hardware VLAN tag support
  73         { &kSCPropNetEthernetCapabilityJUMBO_MTU,       FALSE,  IFCAP_JUMBO_MTU         },      // 9000 byte MTU supported
  74         { &kSCPropNetEthernetCapabilityTSO,             TRUE,   IFCAP_TSO               },      // can do TCP/TCP6 Segmentation Offload
  75         { &kSCPropNetEthernetCapabilityTSO4,            FALSE,  IFCAP_TSO4              },      // can do TCP Segmentation Offload
  76         { &kSCPropNetEthernetCapabilityTSO6,            FALSE,  IFCAP_TSO6              },      // can do TCP6 Segmentation Offload
  77         { &kSCPropNetEthernetCapabilityLRO,             TRUE,   IFCAP_LRO               },      // can do Large Receive Offload
  78         { &kSCPropNetEthernetCapabilityAV,              TRUE,   IFCAP_AV                },      // can do 802.1 AV Bridging
  79 #endif  // SIOCGIFCAP
  80 };
  81
  82
  83 static CFIndex
  84 findCapability(CFStringRef capability)
  85 {
  86         CFIndex         i;
  87
  88         for (i = 0; i < sizeof(capabilityMappings) / sizeof(capabilityMappings[0]); i++) {
  89                 if (CFEqual(capability, *capabilityMappings[i].name)) {
  90                         return i;
  91                 }
  92         }
  93
  94         return kCFNotFound;
  95 }
  96
  97
  98 static Boolean
  99 __getCapabilities(CFStringRef   interfaceName,
 100                   int           *current,
 101                   int           *available)
 102 {
 103 #ifdef  SIOCGIFCAP
 104         struct ifreq    ifr;
 105         Boolean         ok              = FALSE;
 106         int             sock            = -1;
 107
 108         bzero((void *)&ifr, sizeof(ifr));
 109         if (_SC_cfstring_to_cstring(interfaceName, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII) == NULL) {
 110                 SCLog(TRUE, LOG_ERR, CFSTR("could not convert interface name"));
 111                 _SCErrorSet(kSCStatusInvalidArgument);
 112                 return FALSE;
 113         }
 114
 115         sock = socket(AF_INET, SOCK_DGRAM, 0);
 116         if (sock == -1) {
 117                 _SCErrorSet(errno);
 118                 SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
 119                 return FALSE;
 120         }
 121
 122         if (ioctl(sock, SIOCGIFCAP, (caddr_t)&ifr) == -1) {
 123                 _SCErrorSet(errno);
 124                 SCLog(TRUE, LOG_ERR, CFSTR("ioctl(SIOCGIFCAP) failed: %s"), strerror(errno));
 125                 goto done;
 126         }
 127
 128         if (current   != NULL)  *current   = ifr.ifr_curcap;
 129         if (available != NULL)  *available = ifr.ifr_reqcap;
 130
 131         ok = TRUE;
 132
 133     done :
 134
 135         (void)close(sock);
 136         return ok;
 137 #else   // SIOCGIFCAP
 138         if (current != NULL)    *current = 0;
 139         if (available != NULL)  *available = 0;
 140         return TRUE;
 141 #endif  // SIOCGIFCAP
 142 }
 143
 144
 145 int
 146 __SCNetworkInterfaceCreateCapabilities(SCNetworkInterfaceRef    interface,
 147                                        int                      capability_base,
 148                                        CFDictionaryRef          capability_options)
 149 {
 150         int             cap_available   = 0;
 151         int             cap_current     = capability_base;
 152         CFIndex         i;
 153         CFStringRef     interfaceName;
 154
 155         if (!isA_SCNetworkInterface(interface)) {
 156                 _SCErrorSet(kSCStatusInvalidArgument);
 157                 goto done;
 158         }
 159
 160         interfaceName = SCNetworkInterfaceGetBSDName(interface);
 161         if (interfaceName == NULL) {
 162                 _SCErrorSet(kSCStatusInvalidArgument);
 163                 goto done;
 164         }
 165
 166         if (!__getCapabilities(interfaceName,
 167                                (capability_base == -1) ? &cap_current : NULL,
 168                                &cap_available)) {
 169                 goto done;
 170         }
 171
 172         if (cap_available == 0) {
 173                 goto done;
 174         }
 175
 176         if (capability_options == NULL) {
 177                 goto done;
 178         }
 179
 180         for (i = 0; i < sizeof(capabilityMappings) / sizeof(capabilityMappings[0]); i++) {
 181                 int             cap_val;
 182                 CFTypeRef       val;
 183
 184                 if (((cap_available & capabilityMappings[i].val) != 0) &&
 185                     capabilityMappings[i].readwrite &&
 186                     CFDictionaryGetValueIfPresent(capability_options,
 187                                                   *capabilityMappings[i].name,
 188                                                   &val) &&
 189                     isA_CFNumber(val) &&
 190                     CFNumberGetValue(val, kCFNumberIntType, &cap_val)) {
 191                         // update capability
 192                         if (cap_val != 0) {
 193                                 cap_current |= (cap_available & capabilityMappings[i].val);
 194                         } else {
 195                                 cap_current &= ~capabilityMappings[i].val;
 196                         }
 197
 198                         // don't process again
 199                         cap_available &= ~capabilityMappings[i].val;
 200                 }
 201         }
 202
 203     done :
 204
 205         return cap_current;
 206 }
 207
 208
 209 CFTypeRef
 210 SCNetworkInterfaceCopyCapability(SCNetworkInterfaceRef  interface,
 211                                  CFStringRef            capability)
 212 {
 213         int             cap_current     = 0;
 214         int             cap_available   = 0;
 215         int             cap_val;
 216         CFIndex         i;
 217         CFStringRef     interfaceName;
 218         CFTypeRef       val             = NULL;
 219
 220         if (!isA_SCNetworkInterface(interface)) {
 221                 _SCErrorSet(kSCStatusInvalidArgument);
 222                 return NULL;
 223         }
 224
 225         interfaceName = SCNetworkInterfaceGetBSDName(interface);
 226         if (interfaceName == NULL) {
 227                 _SCErrorSet(kSCStatusInvalidArgument);
 228                 return NULL;
 229         }
 230
 231         if (!__getCapabilities(interfaceName, &cap_current, &cap_available)) {
 232                 return NULL;
 233         }
 234
 235         if (capability == NULL) {
 236                 CFMutableDictionaryRef  all     = NULL;
 237
 238                 // if ALL capabilities requested
 239                 for (i = 0; i < sizeof(capabilityMappings) / sizeof(capabilityMappings[0]); i++) {
 240                         if ((cap_available & capabilityMappings[i].val) == capabilityMappings[i].val) {
 241                                 if (all == NULL) {
 242                                         all = CFDictionaryCreateMutable(NULL,
 243                                                                         0,
 244                                                                         &kCFTypeDictionaryKeyCallBacks,
 245                                                                         &kCFTypeDictionaryValueCallBacks);
 246                                 }
 247                                 cap_val = ((cap_current & capabilityMappings[i].val) == capabilityMappings[i].val) ? 1 : 0;
 248                                 val = CFNumberCreate(NULL, kCFNumberIntType, &cap_val);
 249                                 CFDictionarySetValue(all, *capabilityMappings[i].name, val);
 250                                 CFRelease(val);
 251                                 cap_available &= ~capabilityMappings[i].val;
 252                         }
 253                 }
 254
 255                 val = all;
 256         } else {
 257                 i = findCapability(capability);
 258                 if (i == kCFNotFound) {
 259                         // if unknown capability
 260                         _SCErrorSet(kSCStatusInvalidArgument);
 261                         return NULL;
 262                 }
 263
 264                 if ((cap_available & capabilityMappings[i].val) != capabilityMappings[i].val) {
 265                         // if capability not available
 266                         _SCErrorSet(kSCStatusInvalidArgument);
 267                         return NULL;
 268                 }
 269
 270                 cap_val = ((cap_current & capabilityMappings[i].val) == capabilityMappings[i].val) ? 1 : 0;
 271                 val = CFNumberCreate(NULL, kCFNumberIntType, &cap_val);
 272         }
 273
 274         return val;
 275 }
 276
 277
 278 Boolean
 279 SCNetworkInterfaceSetCapability(SCNetworkInterfaceRef   interface,
 280                                 CFStringRef             capability,
 281                                 CFTypeRef               newValue)
 282 {
 283         int                     cap_available           = 0;
 284         CFDictionaryRef         configuration;
 285         CFIndex                 i;
 286         CFStringRef             interfaceName;
 287         CFMutableDictionaryRef  newConfiguration        = NULL;
 288         Boolean                 ok                      = FALSE;
 289
 290         if (!isA_SCNetworkInterface(interface)) {
 291                 _SCErrorSet(kSCStatusInvalidArgument);
 292                 return FALSE;
 293         }
 294
 295         interfaceName = SCNetworkInterfaceGetBSDName(interface);
 296         if (interfaceName == NULL) {
 297                 // if no interface name
 298                 _SCErrorSet(kSCStatusInvalidArgument);
 299                 return FALSE;
 300         }
 301
 302         i = findCapability(capability);
 303         if (i == kCFNotFound) {
 304                 // if unknown capability
 305                 _SCErrorSet(kSCStatusInvalidArgument);
 306                 return FALSE;
 307         }
 308
 309         if (!capabilityMappings[i].readwrite) {
 310                 // if not read-write
 311                 _SCErrorSet(kSCStatusInvalidArgument);
 312                 return FALSE;
 313         }
 314
 315         if ((newValue != NULL) && !isA_CFNumber(newValue)) {
 316                 // all values must (for now) be CFNumber[0 or 1]'s
 317                 _SCErrorSet(kSCStatusInvalidArgument);
 318                 return FALSE;
 319         }
 320
 321         if (!__getCapabilities(interfaceName, NULL, &cap_available)) {
 322                 return FALSE;
 323         }
 324
 325         if ((cap_available & capabilityMappings[i].val) == 0) {
 326                 // if capability not available
 327                 _SCErrorSet(kSCStatusInvalidArgument);
 328                 return FALSE;
 329         }
 330
 331         configuration = SCNetworkInterfaceGetConfiguration(interface);
 332         if (configuration == NULL) {
 333                 newConfiguration = CFDictionaryCreateMutable(NULL,
 334                                                              0,
 335                                                              &kCFTypeDictionaryKeyCallBacks,
 336                                                              &kCFTypeDictionaryValueCallBacks);
 337         } else {
 338                 newConfiguration = CFDictionaryCreateMutableCopy(NULL, 0, configuration);
 339                 CFDictionaryRemoveValue(newConfiguration, kSCResvInactive);
 340         }
 341
 342         if ((newValue != NULL)) {
 343                 CFDictionarySetValue(newConfiguration, capability, newValue);
 344         } else {
 345                 CFDictionaryRemoveValue(newConfiguration, capability);
 346                 if (CFDictionaryGetCount(newConfiguration) == 0) {
 347                         CFRelease(newConfiguration);
 348                         newConfiguration = NULL;
 349                 }
 350         }
 351
 352         ok = SCNetworkInterfaceSetConfiguration(interface, newConfiguration);
 353         if (newConfiguration != NULL) CFRelease(newConfiguration);
 354
 355         return ok;
 356 }
 357
 358
 359 #pragma mark -
 360 #pragma mark Media Options
 361
 362
 363 static const struct ifmedia_description ifm_subtype_shared_descriptions[] =
 364     IFM_SUBTYPE_SHARED_DESCRIPTIONS;
 365
 366 static const struct ifmedia_description ifm_subtype_ethernet_descriptions[] =
 367     IFM_SUBTYPE_ETHERNET_DESCRIPTIONS;
 368
 369 static const struct ifmedia_description ifm_subtype_ieee80211_descriptions[] =
 370     IFM_SUBTYPE_IEEE80211_DESCRIPTIONS;
 371
 372 static const struct ifmedia_description ifm_shared_option_descriptions[] =
 373     IFM_SHARED_OPTION_DESCRIPTIONS;
 374
 375 static const struct ifmedia_description ifm_subtype_ethernet_option_descriptions[] =
 376     IFM_SUBTYPE_ETHERNET_OPTION_DESCRIPTIONS;
 377
 378 static const struct ifmedia_description ifm_subtype_ieee80211_option_descriptions[] =
 379     IFM_SUBTYPE_IEEE80211_OPTION_DESCRIPTIONS;
 380
 381
 382 static void
 383 __freeMediaList(struct ifmediareq *ifm)
 384 {
 385         if (ifm->ifm_ulist != NULL) CFAllocatorDeallocate(NULL, ifm->ifm_ulist);
 386         CFAllocatorDeallocate(NULL, ifm);
 387         return;
 388 }
 389
 390
 391 static struct ifmediareq *
 392 __copyMediaList(CFStringRef interfaceName)
 393 {
 394         struct ifmediareq       *ifm;
 395         Boolean                 ok      = FALSE;
 396         int                     sock    = -1;
 397
 398         ifm = (struct ifmediareq *)CFAllocatorAllocate(NULL, sizeof(struct ifmediareq), 0);
 399         bzero((void *)ifm, sizeof(*ifm));
 400
 401         if (_SC_cfstring_to_cstring(interfaceName, ifm->ifm_name, sizeof(ifm->ifm_name), kCFStringEncodingASCII) == NULL) {
 402                 SCLog(TRUE, LOG_ERR, CFSTR("could not convert interface name"));
 403                 goto done;
 404         }
 405
 406         sock = socket(AF_INET, SOCK_DGRAM, 0);
 407         if (sock == -1) {
 408                 SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
 409                 goto done;
 410         }
 411
 412         if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)ifm) == -1) {
 413 //              SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCGIFMEDIA) failed: %s"), strerror(errno));
 414                 goto done;
 415         }
 416
 417         if (ifm->ifm_count > 0) {
 418                 ifm->ifm_ulist = (int *)CFAllocatorAllocate(NULL, ifm->ifm_count * sizeof(int), 0);
 419                 if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)ifm) == -1) {
 420                         SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCGIFMEDIA) failed: %s"), strerror(errno));
 421                         goto done;
 422                 }
 423         }
 424
 425         ok = TRUE;
 426
 427     done :
 428
 429         if (sock != -1) (void)close(sock);
 430         if (!ok) {
 431                 __freeMediaList(ifm);
 432                 ifm = NULL;
 433                 _SCErrorSet(kSCStatusFailed);
 434         }
 435         return ifm;
 436 }
 437
 438
 439 static CFDictionaryRef
 440 __createMediaDictionary(int media_options, Boolean filter)
 441 {
 442         CFMutableDictionaryRef                  dict                    = NULL;
 443         int                                     i;
 444         const struct ifmedia_description        *option_descriptions    = NULL;
 445         CFMutableArrayRef                       options                 = NULL;
 446         const struct ifmedia_description        *subtype_descriptions   = NULL;
 447         CFStringRef                             val;
 448
 449         if (filter &&
 450             ((IFM_SUBTYPE(media_options) == IFM_NONE) ||
 451              ((IFM_OPTIONS(media_options) & IFM_LOOP) != 0))) {
 452                 return NULL;    /* filter */
 453         }
 454
 455         switch (IFM_TYPE(media_options)) {
 456                 case IFM_ETHER :
 457                         option_descriptions  = ifm_subtype_ethernet_option_descriptions;
 458                         subtype_descriptions = ifm_subtype_ethernet_descriptions;
 459                         break;
 460                 case IFM_IEEE80211 :
 461                         option_descriptions  = ifm_subtype_ieee80211_option_descriptions;
 462                         subtype_descriptions = ifm_subtype_ieee80211_descriptions;
 463                         break;
 464                 default :
 465                         return NULL;
 466         }
 467
 468         dict = CFDictionaryCreateMutable(NULL,
 469                                          0,
 470                                          &kCFTypeDictionaryKeyCallBacks,
 471                                          &kCFTypeDictionaryValueCallBacks);
 472
 473         /* subtype */
 474
 475         val = NULL;
 476         for (i = 0; !val && ifm_subtype_shared_descriptions[i].ifmt_string; i++) {
 477                 if (IFM_SUBTYPE(media_options) == ifm_subtype_shared_descriptions[i].ifmt_word) {
 478                         val = CFStringCreateWithCString(NULL,
 479                                                         ifm_subtype_shared_descriptions[i].ifmt_string,
 480                                                         kCFStringEncodingASCII);
 481                         break;
 482                 }
 483         }
 484
 485         if (subtype_descriptions != NULL) {
 486                 for (i = 0; !val && subtype_descriptions[i].ifmt_string; i++) {
 487                         if (IFM_SUBTYPE(media_options) == subtype_descriptions[i].ifmt_word) {
 488                                 val = CFStringCreateWithCString(NULL,
 489                                                                 subtype_descriptions[i].ifmt_string,
 490                                                                 kCFStringEncodingASCII);
 491                                 break;
 492                         }
 493                 }
 494         }
 495
 496         if (val) {
 497                 CFDictionaryAddValue(dict, kSCPropNetEthernetMediaSubType, val);
 498                 CFRelease(val);
 499         }
 500
 501         /* options */
 502
 503         options = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 504
 505         for (i = 0; (IFM_OPTIONS(media_options) != 0) && (ifm_shared_option_descriptions[i].ifmt_string != NULL); i++) {
 506                 if ((media_options & ifm_shared_option_descriptions[i].ifmt_word) != 0) {
 507                         val = CFStringCreateWithCString(NULL,
 508                                                         ifm_shared_option_descriptions[i].ifmt_string,
 509                                                         kCFStringEncodingASCII);
 510                         CFArrayAppendValue(options, val);
 511                         CFRelease(val);
 512
 513                         media_options &= ~ifm_shared_option_descriptions[i].ifmt_word;
 514                 }
 515         }
 516
 517         if (option_descriptions != NULL) {
 518                 for (i = 0; (IFM_OPTIONS(media_options) != 0) && (option_descriptions[i].ifmt_string != NULL); i++) {
 519                         if ((media_options & option_descriptions[i].ifmt_word) != 0) {
 520                                 val = CFStringCreateWithCString(NULL,
 521                                                                 option_descriptions[i].ifmt_string,
 522                                                                 kCFStringEncodingASCII);
 523                                 CFArrayAppendValue(options, val);
 524                                 CFRelease(val);
 525
 526                                 media_options &= ~option_descriptions[i].ifmt_word;
 527                         }
 528                 }
 529         }
 530
 531         CFDictionaryAddValue(dict, kSCPropNetEthernetMediaOptions, options);
 532         CFRelease(options);
 533
 534         return dict;
 535 }
 536
 537
 538 int
 539 __SCNetworkInterfaceCreateMediaOptions(SCNetworkInterfaceRef interface, CFDictionaryRef media_options)
 540 {
 541         CFIndex                                 i;
 542         struct ifmediareq                       *ifm;
 543         int                                     ifm_new = -1;
 544         CFStringRef                             interfaceName;
 545         Boolean                                 match;
 546         CFIndex                                 n;
 547         const struct ifmedia_description        *option_descriptions    = NULL;
 548         CFArrayRef                              options;
 549         char                                    *str;
 550         const struct ifmedia_description        *subtype_descriptions   = NULL;
 551         CFStringRef                             val;
 552
 553         if (!isA_SCNetworkInterface(interface)) {
 554                 _SCErrorSet(kSCStatusInvalidArgument);
 555                 return -1;
 556         }
 557
 558         interfaceName = SCNetworkInterfaceGetBSDName(interface);
 559         if (interfaceName == NULL) {
 560                 _SCErrorSet(kSCStatusInvalidArgument);
 561                 return -1;
 562         }
 563
 564         /* set type */
 565
 566         ifm = __copyMediaList(interfaceName);
 567         if (ifm != NULL) {
 568                 if (ifm->ifm_count > 0) {
 569                         ifm_new = IFM_TYPE(ifm->ifm_ulist[0]);
 570                 }
 571                 __freeMediaList(ifm);
 572         }
 573
 574         if (ifm_new == -1) {
 575                 // if we cannot determine the media type for the interface
 576                 return -1;
 577         }
 578
 579         switch (IFM_TYPE(ifm_new)) {
 580                 case IFM_ETHER :
 581                         option_descriptions  = ifm_subtype_ethernet_option_descriptions;
 582                         subtype_descriptions = ifm_subtype_ethernet_descriptions;
 583                         break;
 584                 case IFM_IEEE80211 :
 585                         option_descriptions  = ifm_subtype_ieee80211_option_descriptions;
 586                         subtype_descriptions = ifm_subtype_ieee80211_descriptions;
 587                         break;
 588         }
 589
 590         /* set subtype */
 591
 592         val = CFDictionaryGetValue(media_options, kSCPropNetEthernetMediaSubType);
 593         if (!isA_CFString(val)) {
 594                 return -1;
 595         }
 596
 597         str = _SC_cfstring_to_cstring(val, NULL, 0, kCFStringEncodingASCII);
 598         if (str == NULL) {
 599                 return -1;
 600         }
 601
 602         match = FALSE;
 603         for (i = 0; !match && ifm_subtype_shared_descriptions[i].ifmt_string; i++) {
 604                 if (strcasecmp(str, ifm_subtype_shared_descriptions[i].ifmt_string) == 0) {
 605                         ifm_new |= ifm_subtype_shared_descriptions[i].ifmt_word;
 606                         match = TRUE;
 607                         break;
 608                 }
 609         }
 610
 611         if (subtype_descriptions != NULL) {
 612                 for (i = 0; !match && subtype_descriptions[i].ifmt_string; i++) {
 613                         if (strcasecmp(str, subtype_descriptions[i].ifmt_string) == 0) {
 614                                 ifm_new |= subtype_descriptions[i].ifmt_word;
 615                                 match = TRUE;
 616                                 break;
 617                         }
 618                 }
 619         }
 620
 621         CFAllocatorDeallocate(NULL, str);
 622
 623         if (!match) {
 624                 return -1;      /* if no subtype */
 625         }
 626
 627         /* set options */
 628
 629         options = CFDictionaryGetValue(media_options, kSCPropNetEthernetMediaOptions);
 630         if (!isA_CFArray(options)) {
 631                 return -1;
 632         }
 633
 634         n = CFArrayGetCount(options);
 635         for (i = 0; i < n; i++) {
 636                 CFIndex         j;
 637
 638                 val = CFArrayGetValueAtIndex(options, i);
 639                 if (!isA_CFString(val)) {
 640                         return -1;
 641                 }
 642
 643                 str = _SC_cfstring_to_cstring(val, NULL, 0, kCFStringEncodingASCII);
 644                 if (str == NULL) {
 645                         return -1;
 646                 }
 647
 648
 649                 match = FALSE;
 650                 for (j = 0; !match && ifm_shared_option_descriptions[j].ifmt_string; j++) {
 651                         if (strcasecmp(str, ifm_shared_option_descriptions[j].ifmt_string) == 0) {
 652                                 ifm_new |= ifm_shared_option_descriptions[j].ifmt_word;
 653                                 match = TRUE;
 654                                 break;
 655                         }
 656                 }
 657
 658                 if (option_descriptions != NULL) {
 659                         for (j = 0; !match && option_descriptions[j].ifmt_string; j++) {
 660                                 if (strcasecmp(str, option_descriptions[j].ifmt_string) == 0) {
 661                                         ifm_new |= option_descriptions[j].ifmt_word;
 662                                         match = TRUE;
 663                                         break;
 664                                 }
 665                         }
 666                 }
 667
 668                 CFAllocatorDeallocate(NULL, str);
 669
 670                 if (!match) {
 671                         return -1;      /* if no option */
 672                 }
 673         }
 674
 675         return ifm_new;
 676 }
 677
 678
 679 Boolean
 680 SCNetworkInterfaceCopyMediaOptions(SCNetworkInterfaceRef        interface,
 681                                    CFDictionaryRef              *current,
 682                                    CFDictionaryRef              *active,
 683                                    CFArrayRef                   *available,
 684                                    Boolean                      filter)
 685 {
 686         int                     i;
 687         struct ifmediareq       *ifm;
 688         CFStringRef             interfaceName;
 689
 690         if (!isA_SCNetworkInterface(interface)) {
 691                 _SCErrorSet(kSCStatusInvalidArgument);
 692                 return FALSE;
 693         }
 694
 695         interfaceName = SCNetworkInterfaceGetBSDName(interface);
 696         if (interfaceName == NULL) {
 697                 _SCErrorSet(kSCStatusInvalidArgument);
 698                 return FALSE;
 699         }
 700
 701         ifm = __copyMediaList(interfaceName);
 702         if (ifm == NULL) {
 703                 return FALSE;
 704         }
 705
 706         if (active != NULL)     *active    = NULL;
 707         if (current != NULL)    *current   = NULL;
 708         if (available != NULL) {
 709                 CFMutableArrayRef       media_options;
 710
 711                 media_options = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 712                 for (i = 0; i < ifm->ifm_count; i++) {
 713                         CFDictionaryRef options;
 714
 715                         options = __createMediaDictionary(ifm->ifm_ulist[i], filter);
 716                         if (options == NULL) {
 717                                 continue;
 718                         }
 719
 720                         if ((active != NULL)  && (*active == NULL)  && (ifm->ifm_active == ifm->ifm_ulist[i])) {
 721                                 *active  = CFRetain(options);
 722                         }
 723
 724                         if ((current != NULL) && (*current == NULL) && (ifm->ifm_current == ifm->ifm_ulist[i])) {
 725                                 *current = CFRetain(options);
 726                         }
 727
 728                         if (!CFArrayContainsValue(media_options, CFRangeMake(0, CFArrayGetCount(media_options)), options)) {
 729                                 CFArrayAppendValue(media_options, options);
 730                         }
 731
 732                         CFRelease(options);
 733                 }
 734                 *available = (CFArrayRef)media_options;
 735         }
 736
 737         if ((active != NULL)  && (*active == NULL)) {
 738                 *active = __createMediaDictionary(ifm->ifm_active, FALSE);
 739         }
 740
 741         if ((current != NULL) && (*current == NULL)) {
 742                 if ((active != NULL) && (ifm->ifm_active == ifm->ifm_current)) {
 743                         if (*active != NULL)    *current = CFRetain(*active);
 744                 } else {
 745                         *current = __createMediaDictionary(ifm->ifm_current, FALSE);
 746                 }
 747         }
 748
 749         __freeMediaList(ifm);
 750         return TRUE;
 751 }
 752
 753
 754 CFArrayRef
 755 SCNetworkInterfaceCopyMediaSubTypes(CFArrayRef  available)
 756 {
 757         CFIndex                 i;
 758         CFIndex                 n;
 759         CFMutableArrayRef       subTypes;
 760
 761         if (!isA_CFArray(available)) {
 762                 _SCErrorSet(kSCStatusInvalidArgument);
 763                 return NULL;
 764         }
 765
 766         subTypes = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 767
 768         n = CFArrayGetCount(available);
 769         for (i = 0; i < n; i++) {
 770                 CFDictionaryRef options;
 771                 CFStringRef     subType;
 772
 773                 options = CFArrayGetValueAtIndex(available, i);
 774                 if (!isA_CFDictionary(options)) {
 775                         continue;
 776                 }
 777
 778                 subType = CFDictionaryGetValue(options, kSCPropNetEthernetMediaSubType);
 779                 if (!isA_CFString(subType)) {
 780                         continue;
 781                 }
 782
 783                 if (!CFArrayContainsValue(subTypes, CFRangeMake(0, CFArrayGetCount(subTypes)), subType)) {
 784                         CFArrayAppendValue(subTypes, subType);
 785                 }
 786         }
 787
 788         if (CFArrayGetCount(subTypes) == 0) {
 789                 CFRelease(subTypes);
 790                 subTypes = NULL;
 791                 _SCErrorSet(kSCStatusOK);
 792         }
 793
 794         return subTypes;
 795 }
 796
 797
 798 CFArrayRef
 799 SCNetworkInterfaceCopyMediaSubTypeOptions(CFArrayRef    available,
 800                                           CFStringRef   subType)
 801 {
 802         CFIndex                 i;
 803         CFIndex                 n;
 804         CFMutableArrayRef       subTypeOptions;
 805
 806         if (!isA_CFArray(available)) {
 807                 _SCErrorSet(kSCStatusInvalidArgument);
 808                 return NULL;
 809         }
 810
 811         subTypeOptions = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 812
 813         n = CFArrayGetCount(available);
 814         for (i = 0; i < n; i++) {
 815                 CFDictionaryRef options;
 816                 CFArrayRef      mediaOptions;
 817                 CFStringRef     mediaSubType;
 818
 819                 options = CFArrayGetValueAtIndex(available, i);
 820                 if (!isA_CFDictionary(options)) {
 821                         continue;
 822                 }
 823
 824                 mediaSubType = CFDictionaryGetValue(options, kSCPropNetEthernetMediaSubType);
 825                 if (!isA_CFString(mediaSubType) || !CFEqual(subType, mediaSubType)) {
 826                         continue;
 827                 }
 828
 829                 mediaOptions = CFDictionaryGetValue(options, kSCPropNetEthernetMediaOptions);
 830                 if (!isA_CFArray(mediaOptions)) {
 831                         continue;
 832                 }
 833
 834                 if (!CFArrayContainsValue(subTypeOptions, CFRangeMake(0, CFArrayGetCount(subTypeOptions)), mediaOptions)) {
 835                         CFArrayAppendValue(subTypeOptions, mediaOptions);
 836                 }
 837         }
 838
 839         if (CFArrayGetCount(subTypeOptions) == 0) {
 840                 CFRelease(subTypeOptions);
 841                 subTypeOptions = NULL;
 842                 _SCErrorSet(kSCStatusOK);
 843         }
 844
 845         return subTypeOptions;
 846 }
 847
 848
 849 Boolean
 850 _SCNetworkInterfaceIsPhysicalEthernet(SCNetworkInterfaceRef interface)
 851 {
 852         int                     i;
 853         struct ifmediareq       *ifm;
 854         CFStringRef             interfaceName;
 855         Boolean                 realEthernet = FALSE;
 856
 857         if (!isA_SCNetworkInterface(interface)) {
 858                 _SCErrorSet(kSCStatusInvalidArgument);
 859                 return FALSE;
 860         }
 861
 862         interfaceName = SCNetworkInterfaceGetBSDName(interface);
 863         if (interfaceName == NULL) {
 864                 _SCErrorSet(kSCStatusInvalidArgument);
 865                 return FALSE;
 866         }
 867
 868         ifm = __copyMediaList(interfaceName);
 869         if (ifm == NULL) {
 870                 return FALSE;
 871         }
 872         _SCErrorSet(kSCStatusOK);
 873         if (IFM_TYPE(ifm->ifm_current) != IFM_ETHER) {
 874                 goto done;
 875         }
 876         if (ifm->ifm_count == 1
 877             && IFM_SUBTYPE(ifm->ifm_ulist[0]) == IFM_AUTO) {
 878                 /* only support autoselect, not really ethernet */
 879                 goto done;
 880         }
 881         for (i = 0; i < ifm->ifm_count; i++) {
 882                 if ((ifm->ifm_ulist[i] & IFM_FDX) != 0) {
 883                         realEthernet = TRUE;
 884                         break;
 885                 }
 886         }
 887  done:
 888         __freeMediaList(ifm);
 889         return (realEthernet);
 890 }
 891
 892 static Boolean
 893 __getMTULimits(char     ifr_name[IFNAMSIZ],
 894                int      *mtu_min,
 895                int      *mtu_max)
 896 {
 897         int                     ifType          = 0;
 898         io_iterator_t           io_iter         = 0;
 899         io_registry_entry_t     io_interface    = 0;
 900         io_registry_entry_t     io_controller   = 0;
 901         kern_return_t           kr;
 902         static mach_port_t      masterPort      = MACH_PORT_NULL;
 903         CFMutableDictionaryRef  matchingDict;
 904
 905         /* look for a matching interface in the IORegistry */
 906
 907         if (masterPort == MACH_PORT_NULL) {
 908                 kr = IOMasterPort(MACH_PORT_NULL, &masterPort);
 909                 if (kr != KERN_SUCCESS) {
 910                         return FALSE;
 911                 }
 912         }
 913
 914         matchingDict = IOBSDNameMatching(masterPort, 0, ifr_name);
 915         if (matchingDict) {
 916                 /* Note: IOServiceGetMatchingServices consumes a reference on the 'matchingDict' */
 917                 kr = IOServiceGetMatchingServices(masterPort, matchingDict, &io_iter);
 918                 if ((kr == KERN_SUCCESS) && io_iter) {
 919                     /* should only have a single match */
 920                     io_interface = IOIteratorNext(io_iter);
 921                 }
 922                 if (io_iter)    IOObjectRelease(io_iter);
 923         }
 924
 925         if (io_interface) {
 926                 CFNumberRef     num;
 927
 928                 /*
 929                  * found an interface, get the interface type
 930                  */
 931                 num = IORegistryEntryCreateCFProperty(io_interface, CFSTR(kIOInterfaceType), NULL, kNilOptions);
 932                 if (num) {
 933                         if (isA_CFNumber(num)) {
 934                                 CFNumberGetValue(num, kCFNumberIntType, &ifType);
 935                         }
 936                         CFRelease(num);
 937                 }
 938
 939                 /*
 940                  * ...and the property we are REALLY interested is in the controller,
 941                  * which is the parent of the interface object.
 942                  */
 943                 (void)IORegistryEntryGetParentEntry(io_interface, kIOServicePlane, &io_controller);
 944                 IOObjectRelease(io_interface);
 945         } else {
 946                 /* if no matching interface */
 947                 return FALSE;
 948         }
 949
 950         if (io_controller) {
 951                 CFNumberRef     num;
 952
 953                 num = IORegistryEntryCreateCFProperty(io_controller, CFSTR(kIOMaxPacketSize), NULL, kNilOptions);
 954                 if (num) {
 955                         if (isA_CFNumber(num)) {
 956                                 int     value;
 957
 958                                 /*
 959                                  * Get the value and subtract the FCS bytes and Ethernet header
 960                                  * sizes from the maximum frame size reported by the controller
 961                                  * to get the MTU size. The 14 byte media header can be found
 962                                  * in the registry, but not the size for the trailing FCS bytes.
 963                                  */
 964                                 CFNumberGetValue(num, kCFNumberIntType, &value);
 965
 966                                 if (ifType == IFT_ETHER) {
 967                                         value -= (ETHER_HDR_LEN + ETHER_CRC_LEN);
 968                                 }
 969
 970                                 if (mtu_min)    *mtu_min = IF_MINMTU;
 971                                 if (mtu_max)    *mtu_max = value;
 972                         }
 973                         CFRelease(num);
 974                 }
 975
 976                 IOObjectRelease(io_controller);
 977         }
 978
 979         return TRUE;
 980 }
 981
 982
 983 Boolean
 984 SCNetworkInterfaceCopyMTU(SCNetworkInterfaceRef interface,
 985                           int                   *mtu_cur,
 986                           int                   *mtu_min,
 987                           int                   *mtu_max)
 988 {
 989         struct ifreq    ifr;
 990         CFStringRef     interfaceName;
 991         Boolean         ok              = FALSE;
 992         int             sock            = -1;
 993
 994         if (!isA_SCNetworkInterface(interface)) {
 995                 _SCErrorSet(kSCStatusInvalidArgument);
 996                 return FALSE;
 997         }
 998
 999         interfaceName = SCNetworkInterfaceGetBSDName(interface);
1000         if (interfaceName == NULL) {
1001                 _SCErrorSet(kSCStatusInvalidArgument);
1002                 return FALSE;
1003         }
1004
1005         bzero((void *)&ifr, sizeof(ifr));
1006         if (_SC_cfstring_to_cstring(interfaceName, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII) == NULL) {
1007                 SCLog(TRUE, LOG_ERR, CFSTR("could not convert interface name"));
1008                 _SCErrorSet(kSCStatusInvalidArgument);
1009                 return FALSE;
1010         }
1011
1012         sock = socket(AF_INET, SOCK_DGRAM, 0);
1013         if (sock == -1) {
1014                 _SCErrorSet(errno);
1015                 SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
1016                 return FALSE;
1017         }
1018
1019         if (ioctl(sock, SIOCGIFMTU, (caddr_t)&ifr) == -1) {
1020                 _SCErrorSet(errno);
1021 //              SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCGIFMTU) failed: %s"), strerror(errno));
1022                 goto done;
1023         }
1024
1025         if (mtu_cur)    *mtu_cur = ifr.ifr_mtu;
1026         if (mtu_min)    *mtu_min = ifr.ifr_mtu;
1027         if (mtu_max)    *mtu_max = ifr.ifr_mtu;
1028
1029         /* get valid MTU range */
1030
1031         if (mtu_min != NULL || mtu_max != NULL) {
1032                 if (ioctl(sock, SIOCGIFDEVMTU, (caddr_t)&ifr) == 0) {
1033                         struct ifdevmtu *       devmtu_p;
1034
1035                         devmtu_p = &ifr.ifr_devmtu;
1036                         if (mtu_min != NULL) {
1037                                 *mtu_min = (devmtu_p->ifdm_min > IF_MINMTU)
1038                                         ? devmtu_p->ifdm_min : IF_MINMTU;
1039                         }
1040                         if (mtu_max != NULL) {
1041                                 *mtu_max = devmtu_p->ifdm_max;
1042                         }
1043                 } else {
1044                         (void)__getMTULimits(ifr.ifr_name, mtu_min, mtu_max);
1045                 }
1046
1047                 if (mtu_min != NULL) {
1048 #if     IP_MSS > IPV6_MMTU
1049                         if (*mtu_min < IP_MSS) {
1050                                 /* bump up the minimum MTU */
1051                                 *mtu_min = IP_MSS/*576*/;
1052                         }
1053 #else   // IP_MSS > IPV6_MMTU
1054                         if (*mtu_min < IPV6_MMTU) {
1055                                 /* bump up the minimum MTU */
1056                                 *mtu_min = IPV6_MMTU;
1057                         }
1058 #endif  // IP_MSS > IPV6_MMTU
1059
1060                         if ((mtu_cur != NULL) && (*mtu_min > *mtu_cur)) {
1061                                 /* min must be <= cur */
1062                                 *mtu_min = *mtu_cur;
1063                         }
1064
1065                         if ((mtu_max != NULL) && (*mtu_min > *mtu_max)) {
1066                                 /* min must be <= max */
1067                                 *mtu_min = *mtu_max;
1068                         }
1069                 }
1070         }
1071
1072         ok = TRUE;
1073
1074     done :
1075
1076         (void)close(sock);
1077         return ok;
1078 }
1079
1080
1081 Boolean
1082 SCNetworkInterfaceSetMediaOptions(SCNetworkInterfaceRef interface,
1083                                   CFStringRef           subtype,
1084                                   CFArrayRef            options)
1085 {
1086         CFDictionaryRef         configuration;
1087         CFMutableDictionaryRef  newConfiguration        = NULL;
1088         Boolean                 ok                      = FALSE;
1089
1090         if (!isA_SCNetworkInterface(interface)) {
1091                 _SCErrorSet(kSCStatusInvalidArgument);
1092                 return FALSE;
1093         }
1094
1095         configuration = SCNetworkInterfaceGetConfiguration(interface);
1096         if (configuration == NULL) {
1097                 newConfiguration = CFDictionaryCreateMutable(NULL,
1098                                                              0,
1099                                                              &kCFTypeDictionaryKeyCallBacks,
1100                                                              &kCFTypeDictionaryValueCallBacks);
1101         } else {
1102                 newConfiguration = CFDictionaryCreateMutableCopy(NULL, 0, configuration);
1103                 CFDictionaryRemoveValue(newConfiguration, kSCResvInactive);
1104         }
1105
1106         if (subtype != NULL) {
1107                 CFArrayRef      available       = NULL;
1108                 CFArrayRef      config_options  = options;
1109                 CFArrayRef      subtypes        = NULL;
1110                 CFArrayRef      subtype_options = NULL;
1111
1112                 if (options == NULL) {
1113                         config_options = CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks);
1114                 }
1115
1116                 if (!SCNetworkInterfaceCopyMediaOptions(interface, NULL, NULL, &available, FALSE)) {
1117                         SCLog(_sc_debug, LOG_DEBUG, CFSTR("media type / options not available"));
1118                         goto checked;
1119                 }
1120
1121                 if (available == NULL) {
1122                         _SCErrorSet(kSCStatusInvalidArgument);
1123                         goto checked;
1124                 }
1125
1126                 subtypes = SCNetworkInterfaceCopyMediaSubTypes(available);
1127                 if ((subtypes == NULL) ||
1128                     !CFArrayContainsValue(subtypes,
1129                                          CFRangeMake(0, CFArrayGetCount(subtypes)),
1130                                          subtype)) {
1131                         SCLog(_sc_debug, LOG_DEBUG, CFSTR("media type not valid"));
1132                         _SCErrorSet(kSCStatusInvalidArgument);
1133                         goto checked;
1134                 }
1135
1136                 subtype_options = SCNetworkInterfaceCopyMediaSubTypeOptions(available, subtype);
1137                 if ((subtype_options == NULL) ||
1138                     !CFArrayContainsValue(subtype_options,
1139                                           CFRangeMake(0, CFArrayGetCount(subtype_options)),
1140                                           config_options)) {
1141                         SCLog(_sc_debug, LOG_DEBUG, CFSTR("media options not valid for \"%@\""), subtype);
1142                         _SCErrorSet(kSCStatusInvalidArgument);
1143                         goto checked;
1144                 }
1145
1146                 CFDictionarySetValue(newConfiguration, kSCPropNetEthernetMediaSubType, subtype);
1147                 CFDictionarySetValue(newConfiguration,
1148                                      kSCPropNetEthernetMediaOptions,
1149                                      (options != NULL) ? options : config_options);
1150
1151                 ok = TRUE;
1152
1153             checked :
1154
1155                 if (available       != NULL)    CFRelease(available);
1156                 if (subtypes        != NULL)    CFRelease(subtypes);
1157                 if (subtype_options != NULL)    CFRelease(subtype_options);
1158                 if (options         == NULL)    CFRelease(config_options);
1159         } else if (options == NULL) {
1160                 CFDictionaryRemoveValue(newConfiguration, kSCPropNetEthernetMediaSubType);
1161                 CFDictionaryRemoveValue(newConfiguration, kSCPropNetEthernetMediaOptions);
1162                 if (CFDictionaryGetCount(newConfiguration) == 0) {
1163                         CFRelease(newConfiguration);
1164                         newConfiguration = NULL;
1165                 }
1166                 ok = TRUE;
1167         } else {
1168                 SCLog(_sc_debug, LOG_DEBUG, CFSTR("media type must be specified with options"));
1169                 _SCErrorSet(kSCStatusInvalidArgument);
1170         }
1171
1172         if (ok) {
1173                 ok = SCNetworkInterfaceSetConfiguration(interface, newConfiguration);
1174         }
1175
1176         if (newConfiguration != NULL) CFRelease(newConfiguration);
1177         return ok;
1178 }
1179
1180
1181 Boolean
1182 SCNetworkInterfaceSetMTU(SCNetworkInterfaceRef  interface,
1183                          int                    mtu)
1184 {
1185         CFDictionaryRef         configuration;
1186         int                     mtu_max;
1187         int                     mtu_min;
1188         CFMutableDictionaryRef  newConfiguration        = NULL;
1189         Boolean                 ok                      = FALSE;
1190
1191         if (!isA_SCNetworkInterface(interface)) {
1192                 _SCErrorSet(kSCStatusInvalidArgument);
1193                 return FALSE;
1194         }
1195
1196         if (!SCNetworkInterfaceCopyMTU(interface, NULL, &mtu_min, &mtu_max)) {
1197                 SCLog(_sc_debug, LOG_DEBUG, CFSTR("MTU bounds not available"));
1198                 return FALSE;
1199         }
1200
1201         configuration = SCNetworkInterfaceGetConfiguration(interface);
1202         if (configuration == NULL) {
1203                 newConfiguration = CFDictionaryCreateMutable(NULL,
1204                                                              0,
1205                                                              &kCFTypeDictionaryKeyCallBacks,
1206                                                              &kCFTypeDictionaryValueCallBacks);
1207         } else {
1208                 newConfiguration = CFDictionaryCreateMutableCopy(NULL, 0, configuration);
1209                 CFDictionaryRemoveValue(newConfiguration, kSCResvInactive);
1210         }
1211
1212         if ((mtu >= mtu_min) && (mtu <= mtu_max)) {
1213                 CFNumberRef     num;
1214
1215                 num = CFNumberCreate(NULL, kCFNumberIntType, &mtu);
1216                 CFDictionarySetValue(newConfiguration, kSCPropNetEthernetMTU, num);
1217                 CFRelease(num);
1218                 ok = TRUE;
1219         } else if (mtu == 0) {
1220                 CFDictionaryRemoveValue(newConfiguration, kSCPropNetEthernetMTU);
1221                 if (CFDictionaryGetCount(newConfiguration) == 0) {
1222                         CFRelease(newConfiguration);
1223                         newConfiguration = NULL;
1224                 }
1225                 ok = TRUE;
1226         } else {
1227                 SCLog(_sc_debug, LOG_DEBUG, CFSTR("MTU out of range"));
1228                 _SCErrorSet(kSCStatusInvalidArgument);
1229         }
1230
1231         if (ok) {
1232                 ok = SCNetworkInterfaceSetConfiguration(interface, newConfiguration);
1233         }
1234
1235         if (newConfiguration != NULL) CFRelease(newConfiguration);
1236         return ok;
1237 }
1238
1239
1240 // XXXXX
1241 // XXXXX Remove the following SPIs as soon as we have migrated all
1242 // XXXXX internal users
1243 // XXXXX
1244
1245 /* DEPRECATED */ Boolean
1246 NetworkInterfaceCopyMediaOptions(CFStringRef            interfaceName,
1247                                  CFDictionaryRef        *current,
1248                                  CFDictionaryRef        *active,
1249                                  CFArrayRef             *available,
1250                                  Boolean                filter)
1251 {
1252         SCNetworkInterfacePrivateRef    interfacePrivate;
1253         Boolean                         ok;
1254
1255         interfacePrivate = __SCNetworkInterfaceCreatePrivate(NULL, NULL, NULL, NULL, NULL);
1256         if (interfacePrivate == NULL) {
1257                 return FALSE;
1258         }
1259         interfacePrivate->entity_device = CFRetain(interfaceName);
1260         ok = SCNetworkInterfaceCopyMediaOptions((SCNetworkInterfaceRef)interfacePrivate,
1261                                                 current,
1262                                                 active,
1263                                                 available,
1264                                                 filter);
1265         CFRelease(interfacePrivate);
1266         return ok;
1267 }
1268
1269
1270 /* DEPRECATED */ CFArrayRef
1271 NetworkInterfaceCopyMediaSubTypes(CFArrayRef    available)
1272 {
1273         return SCNetworkInterfaceCopyMediaSubTypes(available);
1274 }
1275
1276
1277 /* DEPRECATED */ CFArrayRef
1278 NetworkInterfaceCopyMediaSubTypeOptions(CFArrayRef      available,
1279                                         CFStringRef     subType)
1280 {
1281         return SCNetworkInterfaceCopyMediaSubTypeOptions(available, subType);
1282 }
1283
1284
1285 /* DEPRECATED */ Boolean
1286 NetworkInterfaceCopyMTU(CFStringRef     interfaceName,
1287                         int             *mtu_cur,
1288                         int             *mtu_min,
1289                         int             *mtu_max)
1290 {
1291         SCNetworkInterfacePrivateRef    interfacePrivate;
1292         Boolean                         ok;
1293
1294         interfacePrivate = __SCNetworkInterfaceCreatePrivate(NULL, NULL, NULL, NULL, NULL);
1295         if (interfacePrivate == NULL) {
1296                 return FALSE;
1297         }
1298         interfacePrivate->entity_device = CFRetain(interfaceName);
1299         ok = SCNetworkInterfaceCopyMTU((SCNetworkInterfaceRef)interfacePrivate,
1300                                        mtu_cur,
1301                                        mtu_min,
1302                                        mtu_max);
1303         CFRelease(interfacePrivate);
1304         return ok;
1305 }