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

/*
 * Copyright (c) 2002-2005 Apple Computer, 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 SCDynamicStoreRef	store		= NULL;
static CFRunLoopSourceRef	rls		= NULL;

static Boolean			_verbose	= FALSE;


/* in SystemConfiguration/LinkConfiguration.c */
int
__createMediaOptions(CFStringRef interface, 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
_NetworkInterfaceSetMediaOptions(CFStringRef		interface,
				 CFDictionaryRef	options)
{
	CFArrayRef		available	= NULL;
	CFDictionaryRef		current		= NULL;
	struct ifmediareq	ifm;
	struct ifreq		ifr;
	Boolean			ok		= FALSE;
	int			newOptions;
	CFDictionaryRef		requested;
	int			sock		= -1;

	/* get current & available options */
	if (!NetworkInterfaceCopyMediaOptions(interface, &current, NULL, &available, FALSE)) {
		/* could not get current media options */
		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, interface);
		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(TRUE, LOG_DEBUG, CFSTR("requested media settings unavailable"));
		goto done;
	}

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

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

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

	if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifm) < 0) {
		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(TRUE, LOG_INFO, CFSTR("old media settings: 0x%8.8x (0x%8.8x)"), ifm.ifm_current, ifm.ifm_active);
//SCLog(TRUE, LOG_INFO, CFSTR("new media settings: 0x%8.8x"), ifr.ifr_media);

	if (ioctl(sock, SIOCSIFMEDIA, (caddr_t)&ifr) < 0) {
		SCLog(TRUE, LOG_DEBUG, CFSTR("ioctl(SIOCSIFMEDIA) failed: %s"), strerror(errno));
		goto done;
	}

	ok = TRUE;

    done :

	if (available)	CFRelease(available);
	if (current)	CFRelease(current);
	if (requested)	CFRelease(requested);
	if (sock >= 0)	(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
_NetworkInterfaceSetMTU(CFStringRef	interface,
			CFDictionaryRef	options)
{
	int		mtu_cur		= -1;
	int		mtu_max		= -1;
	int		mtu_min		= -1;
	int		requested;
	CFNumberRef	val;

	if (!NetworkInterfaceCopyMTU(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, interface);
		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(interface, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII);
	ifr.ifr_mtu = requested;

	sock = socket(AF_INET, SOCK_DGRAM, 0);
	if (sock < 0) {
		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(interface, 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 ifKey, CFDictionaryRef options)
{
	CFStringRef		interface	= NULL;
	static CFStringRef	prefix		= NULL;

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

	interface = parse_component(ifKey, prefix);
	if (!interface) {
		goto done;
	}

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

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

			/* preserve current MTU */
			if (NetworkInterfaceCopyMTU(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, interface, new_media);
				CFRelease(new_media);
			}
		}

		/* establish new settings */
		(void)_NetworkInterfaceSetMediaOptions(interface, options);
		(void)_NetworkInterfaceSetMTU         (interface, options);
	} else {
		/* no requested settings */
		options = CFDictionaryGetValue(baseSettings, interface);
		if (options) {
			/* restore original settings */
			(void)_NetworkInterfaceSetMediaOptions(interface, options);
			(void)_NetworkInterfaceSetMTU         (interface, options);
			CFDictionaryRemoveValue(baseSettings, interface);
		}
	}

    done :

	if (interface)	CFRelease(interface);
	return;
}


static void
linkConfigChangedCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *arg)
{
	CFIndex			i;
	CFIndex			n;
	CFDictionaryRef		linkInfo;

	linkInfo = SCDynamicStoreCopyMultiple(store, changedKeys, NULL);

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

		key  = CFArrayGetValueAtIndex(changedKeys, i);
		link = CFDictionaryGetValue(linkInfo, key);
		updateLink(key, link);
	}

	CFRelease(linkInfo);

	return;
}


__private_extern__
void
load_LinkConfiguration(CFBundleRef bundle, Boolean bundleVerbose)
{
	CFStringRef		key;
	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);

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

	/* establish notification keys and patterns */

	patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);

	/* ...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 */
	if (!SCDynamicStoreSetNotificationKeys(store, NULL, patterns)) {
		SCLog(TRUE, LOG_ERR,
		      CFSTR("SCDynamicStoreSetNotificationKeys() failed: %s"),
		      SCErrorString(SCError()));
		goto error;
	}

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

	CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);

	CFRelease(patterns);
	return;

    error :

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