[apple/configd.git] / Plugins / LinkConfiguration / linkconfig.c

/*
 * Copyright (c) 2002-2007 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 * Modification History
 *
 * October 21, 2000		Allan Nathanson <ajn@apple.com>
 * - initial revision
 */


#include <stdio.h>
#include <unistd.h>
//#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <net/if.h>
#include <net/if_media.h>

#include <SystemConfiguration/SystemConfiguration.h>
#include <SystemConfiguration/SCPrivate.h>
#include <SystemConfiguration/SCValidation.h>
#include <SystemConfiguration/LinkConfiguration.h>
#include <SystemConfiguration/SCDPlugin.h>		// for _SCDPluginExecCommand


static CFMutableDictionaryRef	baseSettings	= NULL;
static CFStringRef		interfacesKey	= NULL;
static SCDynamicStoreRef	store		= NULL;
static CFRunLoopSourceRef	rls		= NULL;
static CFMutableDictionaryRef	wantSettings	= NULL;

static Boolean			_verbose	= FALSE;


/* in SystemConfiguration/LinkConfiguration.c */
int
__createMediaOptions(CFStringRef interfaceName, CFDictionaryRef media_options);


static CFDictionaryRef
__copyMediaOptions(CFDictionaryRef options)
{
	CFMutableDictionaryRef	requested	= NULL;
	CFTypeRef		val;

	if (!isA_CFDictionary(options)) {
		return NULL;
	}

	val = CFDictionaryGetValue(options, kSCPropNetEthernetMediaSubType);
	if (isA_CFString(val)) {
		requested = CFDictionaryCreateMutable(NULL,
						      0,
						      &kCFTypeDictionaryKeyCallBacks,
						      &kCFTypeDictionaryValueCallBacks);
		CFDictionaryAddValue(requested, kSCPropNetEthernetMediaSubType, val);
	} else {
		/* if garbage */;
		return NULL;
	}

	val = CFDictionaryGetValue(options, kSCPropNetEthernetMediaOptions);
	if (isA_CFArray(val)) {
		CFDictionaryAddValue(requested, kSCPropNetEthernetMediaOptions, val);
	} else {
		/* if garbage */;
		CFRelease(requested);
		return NULL;
	}

	return requested;
}


__private_extern__
Boolean
_SCNetworkInterfaceSetMediaOptions(SCNetworkInterfaceRef	interface,
				   CFDictionaryRef		options)
{
	CFArrayRef		available	= NULL;
	CFDictionaryRef		current		= NULL;
	struct ifmediareq	ifm;
	struct ifreq		ifr;
	CFStringRef		interfaceName;
	Boolean			ok		= FALSE;
	int			newOptions;
	CFDictionaryRef		requested;
	int			sock		= -1;

	interfaceName = SCNetworkInterfaceGetBSDName(interface);
	if (interfaceName == NULL) {
		/* if no BSD interface name */
		SCLog(_verbose, LOG_INFO, CFSTR("no BSD interface name for %@"), interface);
		return FALSE;
	}

	/* get current & available options */
	if (!SCNetworkInterfaceCopyMediaOptions(interface, &current, NULL, &available, FALSE)) {
		/* could not get current media options */
		SCLog(_verbose, LOG_INFO, CFSTR("no media options for %@"), interfaceName);
		return FALSE;
	}

	/* extract just the dictionary key/value pairs of interest */
	requested = __copyMediaOptions(options);
	if (requested == NULL) {
		CFDictionaryRef	baseOptions;

		/* get base options */
		baseOptions = CFDictionaryGetValue(baseSettings, interfaceName);
		requested = __copyMediaOptions(baseOptions);
	}
	if (requested == NULL) {
		/* get base options */
		requested = __copyMediaOptions(current);
	}
	if (requested == NULL) {
		/* if no media options to set */
		goto done;
	}

	if ((current != NULL) && CFEqual(current, requested)) {
		/* if current settings are as requested */
		ok = TRUE;
		goto done;
	}

	if (!CFArrayContainsValue(available, CFRangeMake(0, CFArrayGetCount(available)), requested)) {
		/* if requested settings not currently available */
		SCLog(_verbose, LOG_INFO, CFSTR("requested media settings unavailable for %@"), interfaceName);
		goto done;
	}

	newOptions = __createMediaOptions(interfaceName, requested);
	if (newOptions == -1) {
		/* since we have just validated, this should never happen */
		goto done;
	}

	sock = socket(AF_INET, SOCK_DGRAM, 0);
	if (sock == -1) {
		SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
		goto done;
	}

	bzero((char *)&ifm, sizeof(ifm));
	(void)_SC_cfstring_to_cstring(interfaceName, ifm.ifm_name, sizeof(ifm.ifm_name), kCFStringEncodingASCII);

	if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifm) == -1) {
		SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCGIFMEDIA) failed: %s"), strerror(errno));
		goto done;
	}

	bzero((char *)&ifr, sizeof(ifr));
	bcopy(ifm.ifm_name, ifr.ifr_name, sizeof(ifr.ifr_name));
	ifr.ifr_media =  ifm.ifm_current & ~(IFM_NMASK|IFM_TMASK|IFM_OMASK|IFM_GMASK);
	ifr.ifr_media |= newOptions;

	SCLog(_verbose, LOG_INFO, CFSTR("old media settings: 0x%8.8x (0x%8.8x)"), ifm.ifm_current, ifm.ifm_active);
	SCLog(_verbose, LOG_INFO, CFSTR("new media settings: 0x%8.8x"), ifr.ifr_media);

	if (ioctl(sock, SIOCSIFMEDIA, (caddr_t)&ifr) == -1) {
		SCLog(TRUE, LOG_DEBUG, CFSTR("%@: ioctl(SIOCSIFMEDIA) failed: %s"), interfaceName, strerror(errno));
		goto done;
	}

	ok = TRUE;

    done :

	if (available != NULL)	CFRelease(available);
	if (current != NULL)	CFRelease(current);
	if (requested != NULL)	CFRelease(requested);
	if (sock != -1)	(void)close(sock);

	return ok;
}


#ifndef	USE_SIOCSIFMTU
static void
ifconfig_exit(pid_t pid, int status, struct rusage *rusage, void *context)
{
	char	*if_name	= (char *)context;

	if (WIFEXITED(status)) {
		if (WEXITSTATUS(status) != 0) {
			SCLog(TRUE, LOG_ERR,
			      CFSTR("ifconfig %s failed, exit status = %d"),
			      if_name,
			      WEXITSTATUS(status));
		}
	} else if (WIFSIGNALED(status)) {
		SCLog(TRUE, LOG_DEBUG,
		      CFSTR("ifconfig %s: terminated w/signal = %d"),
		      if_name,
		      WTERMSIG(status));
	} else {
		SCLog(TRUE, LOG_DEBUG,
		      CFSTR("ifconfig %s: exit status = %d"),
		      if_name,
		      status);
	}

	CFAllocatorDeallocate(NULL, if_name);
	return;
}
#endif	/* !USE_SIOCSIFMTU */


__private_extern__
Boolean
_SCNetworkInterfaceSetMTU(SCNetworkInterfaceRef	interface,
			  CFDictionaryRef	options)
{
	CFStringRef	interfaceName;
	int		mtu_cur		= -1;
	int		mtu_max		= -1;
	int		mtu_min		= -1;
	int		requested;
	CFNumberRef	val;

	interfaceName = SCNetworkInterfaceGetBSDName(interface);
	if (interfaceName == NULL) {
		/* if no BSD interface name */
		return FALSE;
	}

	if (!SCNetworkInterfaceCopyMTU(interface, &mtu_cur, &mtu_min, &mtu_max)) {
		/* could not get current MTU */
		return FALSE;
	}

	val = NULL;
	if (isA_CFDictionary(options)) {
		val = CFDictionaryGetValue(options, kSCPropNetEthernetMTU);
		val = isA_CFNumber(val);
	}
	if (val == NULL) {
		CFDictionaryRef	baseOptions;

		/* get base MTU */
		baseOptions = CFDictionaryGetValue(baseSettings, interfaceName);
		if (baseOptions != NULL) {
			val = CFDictionaryGetValue(baseOptions, kSCPropNetEthernetMTU);
		}
	}
	if (val != NULL) {
		CFNumberGetValue(val, kCFNumberIntType, &requested);
	} else {
		requested = mtu_cur;
	}

	if (requested == mtu_cur) {
		/* if current setting is as requested */
		return TRUE;
	}

	if (((mtu_min >= 0) && (requested < mtu_min)) ||
	    ((mtu_max >= 0) && (requested > mtu_max))) {
		/* if requested MTU outside of the valid range */
		return FALSE;
	}

#ifdef	USE_SIOCSIFMTU
{
	struct ifreq	ifr;
	int		ret;
	int		sock;

	bzero((char *)&ifr, sizeof(ifr));
	(void)_SC_cfstring_to_cstring(interfaceName, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII);
	ifr.ifr_mtu = requested;

	sock = socket(AF_INET, SOCK_DGRAM, 0);
	if (sock == -1) {
		SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
		return FALSE;
	}

	ret = ioctl(sock, SIOCSIFMTU, (caddr_t)&ifr);
	(void)close(sock);
	if (ret == -1) {
		SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCSIFMTU) failed: %s"), strerror(errno));
		return FALSE;
	}
}
#else	/* !USE_SIOCSIFMTU */
{
	char	*ifconfig_argv[] = { "ifconfig", NULL, "mtu", NULL, NULL };
	pid_t	pid;

	ifconfig_argv[1] = _SC_cfstring_to_cstring(interfaceName, NULL, 0, kCFStringEncodingASCII);
	(void)asprintf(&ifconfig_argv[3], "%d", requested);

	pid = _SCDPluginExecCommand(ifconfig_exit,	// callout,
				    ifconfig_argv[1],	// context
				    0,			// uid
				    0,			// gid
				    "/sbin/ifconfig",	// path
				    ifconfig_argv	// argv
				   );

//	CFAllocatorDeallocate(NULL, ifconfig_argv[1]);	// released in ifconfig_exit()
	free(ifconfig_argv[3]);

	if (pid <= 0) {
		return FALSE;
	}
}
#endif	/* !USE_SIOCSIFMTU */

	return TRUE;
}


/*
 * Function: parse_component
 * Purpose:
 *   Given a string 'key' and a string prefix 'prefix',
 *   return the next component in the slash '/' separated
 *   key.
 *
 * Examples:
 * 1. key = "a/b/c" prefix = "a/"
 *    returns "b"
 * 2. key = "a/b/c" prefix = "a/b/"
 *    returns "c"
 */
static CFStringRef
parse_component(CFStringRef key, CFStringRef prefix)
{
	CFMutableStringRef	comp;
	CFRange			range;

	if (CFStringHasPrefix(key, prefix) == FALSE) {
		return NULL;
	}
	comp = CFStringCreateMutableCopy(NULL, 0, key);
	CFStringDelete(comp, CFRangeMake(0, CFStringGetLength(prefix)));
	range = CFStringFind(comp, CFSTR("/"), 0);
	if (range.location == kCFNotFound) {
		return comp;
	}
	range.length = CFStringGetLength(comp) - range.location;
	CFStringDelete(comp, range);
	return comp;
}


static void updateLink(CFStringRef interfaceName, CFDictionaryRef options);


static void
updateInterfaces(CFArrayRef newInterfaces)
{
	CFIndex			i;
	CFIndex			n_old;
	CFIndex			n_new;
	static CFArrayRef	oldInterfaces	= NULL;

	n_old = (oldInterfaces != NULL) ? CFArrayGetCount(oldInterfaces) : 0;
	n_new = CFArrayGetCount(newInterfaces);

	for (i = 0; i < n_new; i++) {
		CFStringRef	interfaceName;

		interfaceName = CFArrayGetValueAtIndex(newInterfaces, i);

		if ((n_old == 0) ||
		    !CFArrayContainsValue(oldInterfaces,
					  CFRangeMake(0, n_old),
					  interfaceName)) {
			CFDictionaryRef	options;

			// if new interface
			options = CFDictionaryGetValue(wantSettings, interfaceName);
			updateLink(interfaceName, options);
		}
	}

	if (oldInterfaces != NULL) CFRelease(oldInterfaces);
	oldInterfaces = CFRetain(newInterfaces);
}


static void
updateLink(CFStringRef interfaceName, CFDictionaryRef options)
{
	SCNetworkInterfaceRef	interface;

	/* retain requested configuration */
	if (options != NULL) {
		CFDictionarySetValue(wantSettings, interfaceName, options);
	} else {
		CFDictionaryRemoveValue(wantSettings, interfaceName);
	}

	/* apply requested configuration */
	interface = _SCNetworkInterfaceCreateWithBSDName(NULL, interfaceName,
							 kIncludeAllVirtualInterfaces);
	if (interface == NULL) {
		return;
	}

	if (options != NULL) {
		if (!CFDictionaryContainsKey(baseSettings, interfaceName)) {
			CFDictionaryRef		cur_media	= NULL;
			CFMutableDictionaryRef	new_media	= NULL;
			int			cur_mtu		= -1;

			/* preserve current media options */
			if (SCNetworkInterfaceCopyMediaOptions(interface, &cur_media, NULL, NULL, FALSE)) {
				if (cur_media != NULL) {
					new_media = CFDictionaryCreateMutableCopy(NULL, 0, cur_media);
					CFRelease(cur_media);
				}
			}

			/* preserve current MTU */
			if (SCNetworkInterfaceCopyMTU(interface, &cur_mtu, NULL, NULL)) {
				if (cur_mtu != -1) {
					CFNumberRef	num;

					if (new_media == NULL) {
						new_media = CFDictionaryCreateMutable(NULL,
										      0,
										      &kCFTypeDictionaryKeyCallBacks,
										      &kCFTypeDictionaryValueCallBacks);
					}

					num = CFNumberCreate(NULL, kCFNumberIntType, &cur_mtu);
					CFDictionaryAddValue(new_media, kSCPropNetEthernetMTU, num);
					CFRelease(num);
				}
			}

			if (new_media != NULL) {
				CFDictionarySetValue(baseSettings, interfaceName, new_media);
				CFRelease(new_media);
			}
		}

		/* establish new settings */
		(void)_SCNetworkInterfaceSetMediaOptions(interface, options);
		(void)_SCNetworkInterfaceSetMTU         (interface, options);
	} else {
		/* no requested settings */
		options = CFDictionaryGetValue(baseSettings, interfaceName);
		if (options != NULL) {
			/* restore original settings */
			(void)_SCNetworkInterfaceSetMediaOptions(interface, options);
			(void)_SCNetworkInterfaceSetMTU         (interface, options);
			CFDictionaryRemoveValue(baseSettings, interfaceName);
		}
	}

	CFRelease(interface);
	return;
}


static void
linkConfigChangedCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *arg)
{
	CFDictionaryRef		changes;
	CFIndex			i;
	CFIndex			n;
	static CFStringRef	prefix		= NULL;

	if (prefix == NULL) {
		prefix = SCDynamicStoreKeyCreate(NULL,
						 CFSTR("%@/%@/%@/"),
						 kSCDynamicStoreDomainSetup,
						 kSCCompNetwork,
						 kSCCompInterface);
	}

	changes = SCDynamicStoreCopyMultiple(store, changedKeys, NULL);

	n = CFArrayGetCount(changedKeys);
	for (i = 0; i < n; i++) {
		CFStringRef	key;
		CFDictionaryRef	info;

		key  = CFArrayGetValueAtIndex(changedKeys, i);
		info = CFDictionaryGetValue(changes, key);

		if (CFEqual(key, interfacesKey)) {
			CFArrayRef	interfaces;

			interfaces = CFDictionaryGetValue(info, kSCPropNetInterfaces);
			if (isA_CFArray(interfaces)) {
				updateInterfaces(interfaces);
			}
		} else {
			CFStringRef	interfaceName;

			interfaceName = parse_component(key, prefix);
			if (interfaceName != NULL) {
				updateLink(interfaceName, info);
				CFRelease(interfaceName);
			}
		}
	}

	CFRelease(changes);

	return;
}


__private_extern__
void
load_LinkConfiguration(CFBundleRef bundle, Boolean bundleVerbose)
{
	CFStringRef		key;
	CFMutableArrayRef	keys		= NULL;
	Boolean			ok;
	CFMutableArrayRef	patterns	= NULL;

	if (bundleVerbose) {
		_verbose = TRUE;
	}

	SCLog(_verbose, LOG_DEBUG, CFSTR("load() called"));
	SCLog(_verbose, LOG_DEBUG, CFSTR("  bundle ID = %@"), CFBundleGetIdentifier(bundle));

	/* initialize a few globals */

	baseSettings = CFDictionaryCreateMutable(NULL,
						 0,
						 &kCFTypeDictionaryKeyCallBacks,
						 &kCFTypeDictionaryValueCallBacks);
	wantSettings = CFDictionaryCreateMutable(NULL,
						 0,
						 &kCFTypeDictionaryKeyCallBacks,
						 &kCFTypeDictionaryValueCallBacks);

	/* open a "configd" store to allow cache updates */
	store = SCDynamicStoreCreate(NULL,
				     CFSTR("Link Configuraton plug-in"),
				     linkConfigChangedCallback,
				     NULL);
	if (store == NULL) {
		SCLog(TRUE, LOG_ERR, CFSTR("SCDynamicStoreCreate() failed: %s"), SCErrorString(SCError()));
		goto error;
	}

	/* establish notification keys and patterns */
	keys     = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
	patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);

	/* ...watch for a change in the list of network interfaces */
	interfacesKey = SCDynamicStoreKeyCreateNetworkInterface(NULL,
								kSCDynamicStoreDomainState);
	CFArrayAppendValue(keys, interfacesKey);

	/* ...watch for (per-interface) AirPort configuration changes */
	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
							    kSCDynamicStoreDomainSetup,
							    kSCCompAnyRegex,
							    kSCEntNetAirPort);
	CFArrayAppendValue(patterns, key);
	CFRelease(key);

	/* ...watch for (per-interface) Ethernet configuration changes */
	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
							    kSCDynamicStoreDomainSetup,
							    kSCCompAnyRegex,
							    kSCEntNetEthernet);
	CFArrayAppendValue(patterns, key);
	CFRelease(key);

	/* ...watch for (per-interface) FireWire configuration changes */
	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
							    kSCDynamicStoreDomainSetup,
							    kSCCompAnyRegex,
							    kSCEntNetFireWire);
	CFArrayAppendValue(patterns, key);
	CFRelease(key);

	/* register the keys/patterns */
	ok = SCDynamicStoreSetNotificationKeys(store, keys, patterns);
	CFRelease(keys);
	CFRelease(patterns);
	if (!ok) {
		SCLog(TRUE, LOG_ERR,
		      CFSTR("SCDynamicStoreSetNotificationKeys() failed: %s"),
		      SCErrorString(SCError()));
		goto error;
	}

	rls = SCDynamicStoreCreateRunLoopSource(NULL, store, 0);
	if (rls == NULL) {
		SCLog(TRUE, LOG_ERR,
		      CFSTR("SCDynamicStoreCreateRunLoopSource() failed: %s"),
		      SCErrorString(SCError()));
		goto error;
	}

	CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
	return;

    error :

	if (baseSettings != NULL)	CFRelease(baseSettings);
	if (wantSettings != NULL)	CFRelease(wantSettings);
	if (store != NULL) 		CFRelease(store);
	return;
}


#ifdef	MAIN
int
main(int argc, char **argv)
{
	_sc_log     = FALSE;
	_sc_verbose = (argc > 1) ? TRUE : FALSE;

	load_LinkConfiguration(CFBundleGetMainBundle(), (argc > 1) ? TRUE : FALSE);
	CFRunLoopRun();
	/* not reached */
	exit(0);
	return 0;
}
#endif
Commit	Line	Data
dbf6a266	1	/*
edebe297	2	* Copyright (c) 2002-2007 Apple Inc. All rights reserved.
dbf6a266 A	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 <stdio.h>
	33	#include <unistd.h>
	34	//#include <sys/fcntl.h>
	35	#include <sys/ioctl.h>
	36	#include <sys/socket.h>
	37	#include <sys/wait.h>
	38	#include <net/if.h>
	39	#include <net/if_media.h>
	40
	41	#include <SystemConfiguration/SystemConfiguration.h>
	42	#include <SystemConfiguration/SCPrivate.h>
	43	#include <SystemConfiguration/SCValidation.h>
	44	#include <SystemConfiguration/LinkConfiguration.h>
	45	#include <SystemConfiguration/SCDPlugin.h> // for _SCDPluginExecCommand
	46
	47
	48	static CFMutableDictionaryRef baseSettings = NULL;
edebe297	49	static CFStringRef interfacesKey = NULL;
dbf6a266 A	50	static SCDynamicStoreRef store = NULL;
dbf6a266 A	51	static CFRunLoopSourceRef rls = NULL;
edebe297	52	static CFMutableDictionaryRef wantSettings = NULL;
dbf6a266 A	53
	54	static Boolean _verbose = FALSE;
	55
	56
	57	/* in SystemConfiguration/LinkConfiguration.c */
	58	int
edebe297	59	__createMediaOptions(CFStringRef interfaceName, CFDictionaryRef media_options);
d6c893b2 A	60
	61
	62	static CFDictionaryRef
	63	__copyMediaOptions(CFDictionaryRef options)
	64	{
	65	CFMutableDictionaryRef requested = NULL;
	66	CFTypeRef val;
	67
	68	if (!isA_CFDictionary(options)) {
	69	return NULL;
	70	}
	71
	72	val = CFDictionaryGetValue(options, kSCPropNetEthernetMediaSubType);
	73	if (isA_CFString(val)) {
	74	requested = CFDictionaryCreateMutable(NULL,
	75	0,
	76	&kCFTypeDictionaryKeyCallBacks,
	77	&kCFTypeDictionaryValueCallBacks);
	78	CFDictionaryAddValue(requested, kSCPropNetEthernetMediaSubType, val);
	79	} else {
	80	/* if garbage */;
	81	return NULL;
	82	}
	83
	84	val = CFDictionaryGetValue(options, kSCPropNetEthernetMediaOptions);
	85	if (isA_CFArray(val)) {
	86	CFDictionaryAddValue(requested, kSCPropNetEthernetMediaOptions, val);
	87	} else {
	88	/* if garbage */;
	89	CFRelease(requested);
	90	return NULL;
	91	}
	92
	93	return requested;
	94	}
dbf6a266 A	95
	96
	97	__private_extern__
	98	Boolean
edebe297 A	99	_SCNetworkInterfaceSetMediaOptions(SCNetworkInterfaceRef interface,
edebe297 A	100	CFDictionaryRef options)
dbf6a266 A	101	{
	102	CFArrayRef available = NULL;
	103	CFDictionaryRef current = NULL;
	104	struct ifmediareq ifm;
	105	struct ifreq ifr;
edebe297	106	CFStringRef interfaceName;
dbf6a266 A	107	Boolean ok = FALSE;
dbf6a266 A	108	int newOptions;
d6c893b2	109	CFDictionaryRef requested;
dbf6a266	110	int sock = -1;
dbf6a266	111
edebe297 A	112	interfaceName = SCNetworkInterfaceGetBSDName(interface);
	113	if (interfaceName == NULL) {
	114	/* if no BSD interface name */
	115	SCLog(_verbose, LOG_INFO, CFSTR("no BSD interface name for %@"), interface);
	116	return FALSE;
	117	}
	118
dbf6a266	119	/* get current & available options */
edebe297	120	if (!SCNetworkInterfaceCopyMediaOptions(interface, &current, NULL, &available, FALSE)) {
d6c893b2	121	/* could not get current media options */
edebe297	122	SCLog(_verbose, LOG_INFO, CFSTR("no media options for %@"), interfaceName);
dbf6a266 A	123	return FALSE;
	124	}
	125
	126	/* extract just the dictionary key/value pairs of interest */
d6c893b2 A	127	requested = __copyMediaOptions(options);
	128	if (requested == NULL) {
	129	CFDictionaryRef baseOptions;
dbf6a266	130
d6c893b2	131	/* get base options */
edebe297	132	baseOptions = CFDictionaryGetValue(baseSettings, interfaceName);
d6c893b2	133	requested = __copyMediaOptions(baseOptions);
dbf6a266	134	}
d6c893b2 A	135	if (requested == NULL) {
	136	/* get base options */
	137	requested = __copyMediaOptions(current);
dbf6a266	138	}
d6c893b2 A	139	if (requested == NULL) {
d6c893b2 A	140	/* if no media options to set */
dbf6a266 A	141	goto done;
	142	}
	143
d6c893b2	144	if ((current != NULL) && CFEqual(current, requested)) {
dbf6a266 A	145	/* if current settings are as requested */
	146	ok = TRUE;
	147	goto done;
	148	}
	149
	150	if (!CFArrayContainsValue(available, CFRangeMake(0, CFArrayGetCount(available)), requested)) {
	151	/* if requested settings not currently available */
edebe297	152	SCLog(_verbose, LOG_INFO, CFSTR("requested media settings unavailable for %@"), interfaceName);
dbf6a266 A	153	goto done;
	154	}
	155
edebe297	156	newOptions = __createMediaOptions(interfaceName, requested);
dbf6a266 A	157	if (newOptions == -1) {
	158	/* since we have just validated, this should never happen */
	159	goto done;
	160	}
	161
	162	sock = socket(AF_INET, SOCK_DGRAM, 0);
edebe297	163	if (sock == -1) {
dbf6a266 A	164	SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
	165	goto done;
	166	}
	167
	168	bzero((char *)&ifm, sizeof(ifm));
edebe297	169	(void)_SC_cfstring_to_cstring(interfaceName, ifm.ifm_name, sizeof(ifm.ifm_name), kCFStringEncodingASCII);
dbf6a266	170
edebe297	171	if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifm) == -1) {
dbf6a266 A	172	SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCGIFMEDIA) failed: %s"), strerror(errno));
	173	goto done;
	174	}
	175
	176	bzero((char *)&ifr, sizeof(ifr));
	177	bcopy(ifm.ifm_name, ifr.ifr_name, sizeof(ifr.ifr_name));
	178	ifr.ifr_media = ifm.ifm_current & ~(IFM_NMASK\|IFM_TMASK\|IFM_OMASK\|IFM_GMASK);
	179	ifr.ifr_media \|= newOptions;
	180
edebe297 A	181	SCLog(_verbose, LOG_INFO, CFSTR("old media settings: 0x%8.8x (0x%8.8x)"), ifm.ifm_current, ifm.ifm_active);
edebe297 A	182	SCLog(_verbose, LOG_INFO, CFSTR("new media settings: 0x%8.8x"), ifr.ifr_media);
dbf6a266	183
edebe297 A	184	if (ioctl(sock, SIOCSIFMEDIA, (caddr_t)&ifr) == -1) {
edebe297 A	185	SCLog(TRUE, LOG_DEBUG, CFSTR("%@: ioctl(SIOCSIFMEDIA) failed: %s"), interfaceName, strerror(errno));
dbf6a266 A	186	goto done;
	187	}
	188
	189	ok = TRUE;
	190
	191	done :
	192
edebe297 A	193	if (available != NULL) CFRelease(available);
	194	if (current != NULL) CFRelease(current);
	195	if (requested != NULL) CFRelease(requested);
	196	if (sock != -1) (void)close(sock);
dbf6a266 A	197
	198	return ok;
	199	}
	200
	201
	202	#ifndef USE_SIOCSIFMTU
	203	static void
	204	ifconfig_exit(pid_t pid, int status, struct rusage rusage, void context)
	205	{
	206	char if_name = (char )context;
	207
	208	if (WIFEXITED(status)) {
	209	if (WEXITSTATUS(status) != 0) {
	210	SCLog(TRUE, LOG_ERR,
	211	CFSTR("ifconfig %s failed, exit status = %d"),
	212	if_name,
	213	WEXITSTATUS(status));
	214	}
	215	} else if (WIFSIGNALED(status)) {
	216	SCLog(TRUE, LOG_DEBUG,
	217	CFSTR("ifconfig %s: terminated w/signal = %d"),
	218	if_name,
	219	WTERMSIG(status));
	220	} else {
	221	SCLog(TRUE, LOG_DEBUG,
	222	CFSTR("ifconfig %s: exit status = %d"),
	223	if_name,
	224	status);
	225	}
	226
	227	CFAllocatorDeallocate(NULL, if_name);
	228	return;
	229	}
	230	#endif /* !USE_SIOCSIFMTU */
	231
	232
	233	__private_extern__
	234	Boolean
edebe297 A	235	_SCNetworkInterfaceSetMTU(SCNetworkInterfaceRef interface,
edebe297 A	236	CFDictionaryRef options)
dbf6a266	237	{
edebe297	238	CFStringRef interfaceName;
dbf6a266 A	239	int mtu_cur = -1;
	240	int mtu_max = -1;
	241	int mtu_min = -1;
	242	int requested;
	243	CFNumberRef val;
	244
edebe297 A	245	interfaceName = SCNetworkInterfaceGetBSDName(interface);
	246	if (interfaceName == NULL) {
	247	/* if no BSD interface name */
	248	return FALSE;
	249	}
	250
	251	if (!SCNetworkInterfaceCopyMTU(interface, &mtu_cur, &mtu_min, &mtu_max)) {
dbf6a266 A	252	/* could not get current MTU */
	253	return FALSE;
	254	}
	255
d6c893b2 A	256	val = NULL;
	257	if (isA_CFDictionary(options)) {
	258	val = CFDictionaryGetValue(options, kSCPropNetEthernetMTU);
	259	val = isA_CFNumber(val);
	260	}
	261	if (val == NULL) {
	262	CFDictionaryRef baseOptions;
	263
	264	/* get base MTU */
edebe297	265	baseOptions = CFDictionaryGetValue(baseSettings, interfaceName);
d6c893b2 A	266	if (baseOptions != NULL) {
d6c893b2 A	267	val = CFDictionaryGetValue(baseOptions, kSCPropNetEthernetMTU);
dbf6a266	268	}
d6c893b2 A	269	}
	270	if (val != NULL) {
	271	CFNumberGetValue(val, kCFNumberIntType, &requested);
dbf6a266 A	272	} else {
	273	requested = mtu_cur;
	274	}
	275
	276	if (requested == mtu_cur) {
	277	/* if current setting is as requested */
	278	return TRUE;
	279	}
	280
	281	if (((mtu_min >= 0) && (requested < mtu_min)) \|\|
	282	((mtu_max >= 0) && (requested > mtu_max))) {
	283	/* if requested MTU outside of the valid range */
	284	return FALSE;
	285	}
	286
	287	#ifdef USE_SIOCSIFMTU
	288	{
	289	struct ifreq ifr;
	290	int ret;
	291	int sock;
	292
	293	bzero((char *)&ifr, sizeof(ifr));
edebe297	294	(void)_SC_cfstring_to_cstring(interfaceName, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII);
dbf6a266 A	295	ifr.ifr_mtu = requested;
	296
	297	sock = socket(AF_INET, SOCK_DGRAM, 0);
edebe297	298	if (sock == -1) {
dbf6a266 A	299	SCLog(TRUE, LOG_ERR, CFSTR("socket() failed: %s"), strerror(errno));
	300	return FALSE;
	301	}
	302
	303	ret = ioctl(sock, SIOCSIFMTU, (caddr_t)&ifr);
	304	(void)close(sock);
	305	if (ret == -1) {
	306	SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCSIFMTU) failed: %s"), strerror(errno));
	307	return FALSE;
	308	}
	309	}
	310	#else /* !USE_SIOCSIFMTU */
	311	{
	312	char *ifconfig_argv[] = { "ifconfig", NULL, "mtu", NULL, NULL };
	313	pid_t pid;
	314
edebe297	315	ifconfig_argv[1] = _SC_cfstring_to_cstring(interfaceName, NULL, 0, kCFStringEncodingASCII);
dbf6a266 A	316	(void)asprintf(&ifconfig_argv[3], "%d", requested);
	317
	318	pid = _SCDPluginExecCommand(ifconfig_exit, // callout,
	319	ifconfig_argv[1], // context
	320	0, // uid
	321	0, // gid
	322	"/sbin/ifconfig", // path
	323	ifconfig_argv // argv
	324	);
	325
	326	// CFAllocatorDeallocate(NULL, ifconfig_argv[1]); // released in ifconfig_exit()
	327	free(ifconfig_argv[3]);
	328
	329	if (pid <= 0) {
	330	return FALSE;
	331	}
	332	}
	333	#endif /* !USE_SIOCSIFMTU */
	334
	335	return TRUE;
	336	}
	337
	338
	339	/*
	340	* Function: parse_component
	341	* Purpose:
	342	* Given a string 'key' and a string prefix 'prefix',
	343	* return the next component in the slash '/' separated
	344	* key.
	345	*
	346	* Examples:
	347	* 1. key = "a/b/c" prefix = "a/"
	348	* returns "b"
	349	* 2. key = "a/b/c" prefix = "a/b/"
	350	* returns "c"
	351	*/
	352	static CFStringRef
	353	parse_component(CFStringRef key, CFStringRef prefix)
	354	{
	355	CFMutableStringRef comp;
	356	CFRange range;
	357
	358	if (CFStringHasPrefix(key, prefix) == FALSE) {
	359	return NULL;
	360	}
	361	comp = CFStringCreateMutableCopy(NULL, 0, key);
	362	CFStringDelete(comp, CFRangeMake(0, CFStringGetLength(prefix)));
	363	range = CFStringFind(comp, CFSTR("/"), 0);
	364	if (range.location == kCFNotFound) {
	365	return comp;
	366	}
	367	range.length = CFStringGetLength(comp) - range.location;
	368	CFStringDelete(comp, range);
	369	return comp;
	370	}
	371
	372
edebe297 A	373	static void updateLink(CFStringRef interfaceName, CFDictionaryRef options);
	374
	375
dbf6a266	376	static void
edebe297	377	updateInterfaces(CFArrayRef newInterfaces)
dbf6a266	378	{
edebe297 A	379	CFIndex i;
	380	CFIndex n_old;
	381	CFIndex n_new;
	382	static CFArrayRef oldInterfaces = NULL;
dbf6a266	383
edebe297 A	384	n_old = (oldInterfaces != NULL) ? CFArrayGetCount(oldInterfaces) : 0;
	385	n_new = CFArrayGetCount(newInterfaces);
	386
	387	for (i = 0; i < n_new; i++) {
	388	CFStringRef interfaceName;
	389
	390	interfaceName = CFArrayGetValueAtIndex(newInterfaces, i);
	391
	392	if ((n_old == 0) \|\|
	393	!CFArrayContainsValue(oldInterfaces,
	394	CFRangeMake(0, n_old),
	395	interfaceName)) {
	396	CFDictionaryRef options;
	397
	398	// if new interface
	399	options = CFDictionaryGetValue(wantSettings, interfaceName);
	400	updateLink(interfaceName, options);
	401	}
dbf6a266 A	402	}
dbf6a266 A	403
edebe297 A	404	if (oldInterfaces != NULL) CFRelease(oldInterfaces);
	405	oldInterfaces = CFRetain(newInterfaces);
	406	}
	407
	408
	409	static void
	410	updateLink(CFStringRef interfaceName, CFDictionaryRef options)
	411	{
	412	SCNetworkInterfaceRef interface;
	413
	414	/* retain requested configuration */
	415	if (options != NULL) {
	416	CFDictionarySetValue(wantSettings, interfaceName, options);
	417	} else {
	418	CFDictionaryRemoveValue(wantSettings, interfaceName);
	419	}
	420
	421	/* apply requested configuration */
	422	interface = _SCNetworkInterfaceCreateWithBSDName(NULL, interfaceName,
	423	kIncludeAllVirtualInterfaces);
	424	if (interface == NULL) {
	425	return;
dbf6a266 A	426	}
dbf6a266 A	427
edebe297 A	428	if (options != NULL) {
edebe297 A	429	if (!CFDictionaryContainsKey(baseSettings, interfaceName)) {
dbf6a266 A	430	CFDictionaryRef cur_media = NULL;
	431	CFMutableDictionaryRef new_media = NULL;
	432	int cur_mtu = -1;
dbf6a266	433
d6c893b2	434	/* preserve current media options */
edebe297	435	if (SCNetworkInterfaceCopyMediaOptions(interface, &cur_media, NULL, NULL, FALSE)) {
d6c893b2 A	436	if (cur_media != NULL) {
	437	new_media = CFDictionaryCreateMutableCopy(NULL, 0, cur_media);
	438	CFRelease(cur_media);
	439	}
dbf6a266 A	440	}
dbf6a266 A	441
d6c893b2	442	/* preserve current MTU */
edebe297	443	if (SCNetworkInterfaceCopyMTU(interface, &cur_mtu, NULL, NULL)) {
d6c893b2 A	444	if (cur_mtu != -1) {
	445	CFNumberRef num;
	446
	447	if (new_media == NULL) {
	448	new_media = CFDictionaryCreateMutable(NULL,
	449	0,
	450	&kCFTypeDictionaryKeyCallBacks,
	451	&kCFTypeDictionaryValueCallBacks);
	452	}
	453
	454	num = CFNumberCreate(NULL, kCFNumberIntType, &cur_mtu);
	455	CFDictionaryAddValue(new_media, kSCPropNetEthernetMTU, num);
	456	CFRelease(num);
	457	}
dbf6a266 A	458	}
dbf6a266 A	459
d6c893b2	460	if (new_media != NULL) {
edebe297	461	CFDictionarySetValue(baseSettings, interfaceName, new_media);
d6c893b2	462	CFRelease(new_media);
dbf6a266	463	}
dbf6a266 A	464	}
	465
	466	/* establish new settings */
edebe297 A	467	(void)_SCNetworkInterfaceSetMediaOptions(interface, options);
edebe297 A	468	(void)_SCNetworkInterfaceSetMTU (interface, options);
dbf6a266 A	469	} else {
dbf6a266 A	470	/* no requested settings */
edebe297 A	471	options = CFDictionaryGetValue(baseSettings, interfaceName);
edebe297 A	472	if (options != NULL) {
dbf6a266	473	/* restore original settings */
edebe297 A	474	(void)_SCNetworkInterfaceSetMediaOptions(interface, options);
	475	(void)_SCNetworkInterfaceSetMTU (interface, options);
	476	CFDictionaryRemoveValue(baseSettings, interfaceName);
dbf6a266 A	477	}
	478	}
	479
edebe297	480	CFRelease(interface);
dbf6a266 A	481	return;
	482	}
	483
	484
	485	static void
	486	linkConfigChangedCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *arg)
	487	{
edebe297	488	CFDictionaryRef changes;
dbf6a266 A	489	CFIndex i;
dbf6a266 A	490	CFIndex n;
edebe297 A	491	static CFStringRef prefix = NULL;
	492
	493	if (prefix == NULL) {
	494	prefix = SCDynamicStoreKeyCreate(NULL,
	495	CFSTR("%@/%@/%@/"),
	496	kSCDynamicStoreDomainSetup,
	497	kSCCompNetwork,
	498	kSCCompInterface);
	499	}
dbf6a266	500
edebe297	501	changes = SCDynamicStoreCopyMultiple(store, changedKeys, NULL);
dbf6a266 A	502
	503	n = CFArrayGetCount(changedKeys);
	504	for (i = 0; i < n; i++) {
	505	CFStringRef key;
edebe297	506	CFDictionaryRef info;
dbf6a266 A	507
dbf6a266 A	508	key = CFArrayGetValueAtIndex(changedKeys, i);
edebe297 A	509	info = CFDictionaryGetValue(changes, key);
	510
	511	if (CFEqual(key, interfacesKey)) {
	512	CFArrayRef interfaces;
	513
	514	interfaces = CFDictionaryGetValue(info, kSCPropNetInterfaces);
	515	if (isA_CFArray(interfaces)) {
	516	updateInterfaces(interfaces);
	517	}
	518	} else {
	519	CFStringRef interfaceName;
	520
	521	interfaceName = parse_component(key, prefix);
	522	if (interfaceName != NULL) {
	523	updateLink(interfaceName, info);
	524	CFRelease(interfaceName);
	525	}
	526	}
dbf6a266 A	527	}
dbf6a266 A	528
edebe297	529	CFRelease(changes);
dbf6a266 A	530
	531	return;
	532	}
	533
	534
	535	__private_extern__
	536	void
	537	load_LinkConfiguration(CFBundleRef bundle, Boolean bundleVerbose)
	538	{
	539	CFStringRef key;
edebe297 A	540	CFMutableArrayRef keys = NULL;
edebe297 A	541	Boolean ok;
dbf6a266 A	542	CFMutableArrayRef patterns = NULL;
	543
	544	if (bundleVerbose) {
	545	_verbose = TRUE;
	546	}
	547
	548	SCLog(_verbose, LOG_DEBUG, CFSTR("load() called"));
	549	SCLog(_verbose, LOG_DEBUG, CFSTR(" bundle ID = %@"), CFBundleGetIdentifier(bundle));
	550
	551	/* initialize a few globals */
	552
	553	baseSettings = CFDictionaryCreateMutable(NULL,
	554	0,
	555	&kCFTypeDictionaryKeyCallBacks,
	556	&kCFTypeDictionaryValueCallBacks);
edebe297 A	557	wantSettings = CFDictionaryCreateMutable(NULL,
	558	0,
	559	&kCFTypeDictionaryKeyCallBacks,
	560	&kCFTypeDictionaryValueCallBacks);
dbf6a266 A	561
	562	/* open a "configd" store to allow cache updates */
	563	store = SCDynamicStoreCreate(NULL,
	564	CFSTR("Link Configuraton plug-in"),
	565	linkConfigChangedCallback,
	566	NULL);
edebe297	567	if (store == NULL) {
dbf6a266 A	568	SCLog(TRUE, LOG_ERR, CFSTR("SCDynamicStoreCreate() failed: %s"), SCErrorString(SCError()));
	569	goto error;
	570	}
	571
	572	/* establish notification keys and patterns */
edebe297	573	keys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
dbf6a266 A	574	patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
dbf6a266 A	575
edebe297 A	576	/* ...watch for a change in the list of network interfaces */
	577	interfacesKey = SCDynamicStoreKeyCreateNetworkInterface(NULL,
	578	kSCDynamicStoreDomainState);
	579	CFArrayAppendValue(keys, interfacesKey);
	580
d6c893b2 A	581	/* ...watch for (per-interface) AirPort configuration changes */
	582	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
	583	kSCDynamicStoreDomainSetup,
	584	kSCCompAnyRegex,
	585	kSCEntNetAirPort);
	586	CFArrayAppendValue(patterns, key);
	587	CFRelease(key);
	588
dbf6a266 A	589	/* ...watch for (per-interface) Ethernet configuration changes */
	590	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
	591	kSCDynamicStoreDomainSetup,
	592	kSCCompAnyRegex,
	593	kSCEntNetEthernet);
	594	CFArrayAppendValue(patterns, key);
	595	CFRelease(key);
	596
d6c893b2 A	597	/* ...watch for (per-interface) FireWire configuration changes */
	598	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
	599	kSCDynamicStoreDomainSetup,
	600	kSCCompAnyRegex,
	601	kSCEntNetFireWire);
	602	CFArrayAppendValue(patterns, key);
	603	CFRelease(key);
	604
dbf6a266	605	/* register the keys/patterns */
edebe297 A	606	ok = SCDynamicStoreSetNotificationKeys(store, keys, patterns);
	607	CFRelease(keys);
	608	CFRelease(patterns);
	609	if (!ok) {
dbf6a266 A	610	SCLog(TRUE, LOG_ERR,
	611	CFSTR("SCDynamicStoreSetNotificationKeys() failed: %s"),
	612	SCErrorString(SCError()));
	613	goto error;
	614	}
	615
	616	rls = SCDynamicStoreCreateRunLoopSource(NULL, store, 0);
edebe297	617	if (rls == NULL) {
dbf6a266 A	618	SCLog(TRUE, LOG_ERR,
	619	CFSTR("SCDynamicStoreCreateRunLoopSource() failed: %s"),
	620	SCErrorString(SCError()));
	621	goto error;
	622	}
	623
	624	CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
dbf6a266 A	625	return;
	626
	627	error :
	628
edebe297 A	629	if (baseSettings != NULL) CFRelease(baseSettings);
	630	if (wantSettings != NULL) CFRelease(wantSettings);
	631	if (store != NULL) CFRelease(store);
dbf6a266 A	632	return;
	633	}
	634
	635
	636	#ifdef MAIN
	637	int
	638	main(int argc, char **argv)
	639	{
	640	_sc_log = FALSE;
	641	_sc_verbose = (argc > 1) ? TRUE : FALSE;
	642
	643	load_LinkConfiguration(CFBundleGetMainBundle(), (argc > 1) ? TRUE : FALSE);
	644	CFRunLoopRun();
	645	/* not reached */
	646	exit(0);
	647	return 0;
	648	}
	649	#endif