[apple/configd.git] / Plugins / KernelEventMonitor / ev_ipv4.c

/*
 * Copyright (c) 2002-2003 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
 *
 * August 5, 2002	Allan Nathanson <ajn@apple.com>
 * - split code out from eventmon.c
 */

#include "eventmon.h"
#include "cache.h"
#include "ev_ipv4.h"

#ifndef kSCEntNetIPv4ARPCollision
#define kSCEntNetIPv4ARPCollision	CFSTR("IPv4ARPCollision")
#endif kSCEntNetIPv4ARPCollision

#define IP_FORMAT	"%d.%d.%d.%d"
#define IP_CH(ip, i)	(((u_char *)(ip))[i])
#define IP_LIST(ip)	IP_CH(ip,0),IP_CH(ip,1),IP_CH(ip,2),IP_CH(ip,3)


static void
appendAddress(CFMutableDictionaryRef dict, CFStringRef key, struct in_addr *address)
{
	CFStringRef		addr;
	CFArrayRef		addrs;
	CFMutableArrayRef	newAddrs;

	addrs = CFDictionaryGetValue(dict, key);
	if (addrs) {
		newAddrs = CFArrayCreateMutableCopy(NULL, 0, addrs);
	} else {
		newAddrs = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
	}

	addr = CFStringCreateWithFormat(NULL, NULL, CFSTR(IP_FORMAT), IP_LIST(address));
	CFArrayAppendValue(newAddrs, addr);
	CFRelease(addr);

	CFDictionarySetValue(dict, key, newAddrs);
	CFRelease(newAddrs);
	return;
}


static CFMutableDictionaryRef
getIF(CFStringRef key, CFMutableDictionaryRef oldIFs, CFMutableDictionaryRef newIFs)
{
	CFDictionaryRef		dict		= NULL;
	CFMutableDictionaryRef	newDict		= NULL;

	if (CFDictionaryGetValueIfPresent(newIFs, key, (const void **)&dict)) {
		newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
	} else {
		dict = cache_SCDynamicStoreCopyValue(store, key);
		if (dict) {
			CFDictionarySetValue(oldIFs, key, dict);
			if (isA_CFDictionary(dict)) {
				newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
				CFDictionaryRemoveValue(newDict, kSCPropNetIPv4Addresses);
				CFDictionaryRemoveValue(newDict, kSCPropNetIPv4SubnetMasks);
				CFDictionaryRemoveValue(newDict, kSCPropNetIPv4DestAddresses);
				CFDictionaryRemoveValue(newDict, kSCPropNetIPv4BroadcastAddresses);
			}
			CFRelease(dict);
		}
	}

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

	return newDict;
}


static void
updateStore(const void *key, const void *value, void *context)
{
	CFDictionaryRef dict;
	CFDictionaryRef newDict = (CFDictionaryRef)value;
	CFDictionaryRef	oldIFs	= (CFDictionaryRef)context;

	dict = CFDictionaryGetValue(oldIFs, key);

	if (!dict || !CFEqual(dict, newDict)) {
		if (CFDictionaryGetCount(newDict) > 0) {
			cache_SCDynamicStoreSetValue(store, key, newDict);
		} else if (dict) {
			cache_SCDynamicStoreRemoveValue(store, key);
		}
	}

	return;
}


__private_extern__
void
interface_update_ipv4(struct ifaddrs *ifap, const char *if_name)
{
	struct ifaddrs		*ifa;
	struct ifaddrs		*ifap_temp	= NULL;
	CFStringRef		interface;
	boolean_t		interfaceFound	= FALSE;
	CFStringRef		key		= NULL;
	CFMutableDictionaryRef	oldIFs;
	CFMutableDictionaryRef	newDict		= NULL;
	CFMutableDictionaryRef	newIFs;

	oldIFs = CFDictionaryCreateMutable(NULL,
					   0,
					   &kCFTypeDictionaryKeyCallBacks,
					   &kCFTypeDictionaryValueCallBacks);
	newIFs = CFDictionaryCreateMutable(NULL,
					   0,
					   &kCFTypeDictionaryKeyCallBacks,
					   &kCFTypeDictionaryValueCallBacks);

	if (!ifap) {
		if (getifaddrs(&ifap_temp) < 0) {
			SCLog(TRUE, LOG_ERR, CFSTR("getifaddrs() failed: %s"), strerror(errno));
			goto error;
		}
		ifap = ifap_temp;
	}

	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
		struct sockaddr_in	*sin;

		if (ifa->ifa_addr->sa_family != AF_INET) {
			continue;			/* sorry, not interested */
		}

		/* check if this is the requested interface */
		if (if_name) {
			if (strncmp(if_name, ifa->ifa_name, IFNAMSIZ) == 0) {
				interfaceFound = TRUE;	/* yes, this is the one I want */
			} else {
				continue;		/* sorry, not interested */
			}
		}

		interface = CFStringCreateWithCString(NULL, ifa->ifa_name, kCFStringEncodingMacRoman);
		key       = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
									  kSCDynamicStoreDomainState,
									  interface,
									  kSCEntNetIPv4);
		CFRelease(interface);

		newDict = getIF(key, oldIFs, newIFs);

		sin = (struct sockaddr_in *)ifa->ifa_addr;
		appendAddress(newDict, kSCPropNetIPv4Addresses, &sin->sin_addr);

		if (ifa->ifa_flags & IFF_POINTOPOINT) {
			struct sockaddr_in	*dst;

			dst = (struct sockaddr_in *)ifa->ifa_dstaddr;
			appendAddress(newDict, kSCPropNetIPv4DestAddresses, &dst->sin_addr);
		} else {
			struct sockaddr_in	*brd;
			struct sockaddr_in	*msk;

			brd = (struct sockaddr_in *)ifa->ifa_broadaddr;
			appendAddress(newDict, kSCPropNetIPv4BroadcastAddresses, &brd->sin_addr);
			msk = (struct sockaddr_in *)ifa->ifa_netmask;
			appendAddress(newDict, kSCPropNetIPv4SubnetMasks, &msk->sin_addr);
		}

		CFDictionarySetValue(newIFs, key, newDict);
		CFRelease(newDict);
		CFRelease(key);
	}

	/* if the last address[es] were removed from the target interface */
	if (if_name && !interfaceFound) {
		interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
		key       = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
									  kSCDynamicStoreDomainState,
									  interface,
									  kSCEntNetIPv4);
		CFRelease(interface);

		newDict = getIF(key, oldIFs, newIFs);

		CFDictionarySetValue(newIFs, key, newDict);
		CFRelease(newDict);
		CFRelease(key);
	}

	CFDictionaryApplyFunction(newIFs, updateStore, oldIFs);

    error :

	if (ifap_temp)	freeifaddrs(ifap_temp);
	CFRelease(oldIFs);
	CFRelease(newIFs);

	return;
}

__private_extern__
void
interface_collision_ipv4(const char *if_name, struct in_addr ip_addr, int hw_len, const void * hw_addr)
{
	uint8_t	*		hw_addr_bytes = (uint8_t *)hw_addr;
	int			i;
	CFStringRef		if_name_cf;
	CFMutableStringRef	key;
	CFStringRef		prefix;

	if_name_cf = CFStringCreateWithCString(NULL, if_name,
					       kCFStringEncodingASCII);
	prefix = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
							       kSCDynamicStoreDomainState,
							       if_name_cf,
							       kSCEntNetIPv4ARPCollision);
	key = CFStringCreateMutableCopy(NULL, 0, prefix);
	CFStringAppendFormat(key, NULL, CFSTR("/" IP_FORMAT),
			     IP_LIST(&ip_addr));
	for (i = 0; i < hw_len; i++) {
	    CFStringAppendFormat(key, NULL, CFSTR("%s%02x"),
				 (i == 0) ? "/" : ":", hw_addr_bytes[i]);
	}
	cache_SCDynamicStoreNotifyValue(store, key);
	CFRelease(key);
	CFRelease(prefix);
	CFRelease(if_name_cf);
	return;
}
Commit	Line	Data
dbf6a266 A	1	/*
	2	* Copyright (c) 2002-2003 Apple Computer, 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	* August 5, 2002 Allan Nathanson <ajn@apple.com>
	28	* - split code out from eventmon.c
	29	*/
	30
	31	#include "eventmon.h"
	32	#include "cache.h"
	33	#include "ev_ipv4.h"
	34
	35	#ifndef kSCEntNetIPv4ARPCollision
	36	#define kSCEntNetIPv4ARPCollision CFSTR("IPv4ARPCollision")
	37	#endif kSCEntNetIPv4ARPCollision
	38
	39	#define IP_FORMAT "%d.%d.%d.%d"
	40	#define IP_CH(ip, i) (((u_char *)(ip))[i])
	41	#define IP_LIST(ip) IP_CH(ip,0),IP_CH(ip,1),IP_CH(ip,2),IP_CH(ip,3)
	42
	43
	44	static void
	45	appendAddress(CFMutableDictionaryRef dict, CFStringRef key, struct in_addr *address)
	46	{
	47	CFStringRef addr;
	48	CFArrayRef addrs;
	49	CFMutableArrayRef newAddrs;
	50
	51	addrs = CFDictionaryGetValue(dict, key);
	52	if (addrs) {
	53	newAddrs = CFArrayCreateMutableCopy(NULL, 0, addrs);
	54	} else {
	55	newAddrs = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
	56	}
	57
	58	addr = CFStringCreateWithFormat(NULL, NULL, CFSTR(IP_FORMAT), IP_LIST(address));
	59	CFArrayAppendValue(newAddrs, addr);
	60	CFRelease(addr);
	61
	62	CFDictionarySetValue(dict, key, newAddrs);
	63	CFRelease(newAddrs);
	64	return;
65	}
66
67
68	static CFMutableDictionaryRef
69	getIF(CFStringRef key, CFMutableDictionaryRef oldIFs, CFMutableDictionaryRef newIFs)
70	{
71	CFDictionaryRef dict = NULL;
72	CFMutableDictionaryRef newDict = NULL;
73
74	if (CFDictionaryGetValueIfPresent(newIFs, key, (const void **)&dict)) {
75	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
76	} else {
77	dict = cache_SCDynamicStoreCopyValue(store, key);
78	if (dict) {
79	CFDictionarySetValue(oldIFs, key, dict);
80	if (isA_CFDictionary(dict)) {
81	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
82	CFDictionaryRemoveValue(newDict, kSCPropNetIPv4Addresses);
83	CFDictionaryRemoveValue(newDict, kSCPropNetIPv4SubnetMasks);
84	CFDictionaryRemoveValue(newDict, kSCPropNetIPv4DestAddresses);
85	CFDictionaryRemoveValue(newDict, kSCPropNetIPv4BroadcastAddresses);
86	}
87	CFRelease(dict);
88	}
89	}
90
91	if (!newDict) {
92	newDict = CFDictionaryCreateMutable(NULL,
93	0,
94	&kCFTypeDictionaryKeyCallBacks,
95	&kCFTypeDictionaryValueCallBacks);
96	}
97
98	return newDict;
99	}
100
101
102	static void
103	updateStore(const void key, const void value, void *context)
104	{
105	CFDictionaryRef dict;
106	CFDictionaryRef newDict = (CFDictionaryRef)value;
107	CFDictionaryRef oldIFs = (CFDictionaryRef)context;
108
109	dict = CFDictionaryGetValue(oldIFs, key);
110
111	if (!dict \|\| !CFEqual(dict, newDict)) {
112	if (CFDictionaryGetCount(newDict) > 0) {
113	cache_SCDynamicStoreSetValue(store, key, newDict);
114	} else if (dict) {
115	cache_SCDynamicStoreRemoveValue(store, key);
116	}
117	}
118
119	return;
120	}
121
122
123	__private_extern__
124	void
125	interface_update_ipv4(struct ifaddrs ifap, const char if_name)
126	{
127	struct ifaddrs *ifa;
128	struct ifaddrs *ifap_temp = NULL;
129	CFStringRef interface;
130	boolean_t interfaceFound = FALSE;
131	CFStringRef key = NULL;
132	CFMutableDictionaryRef oldIFs;
133	CFMutableDictionaryRef newDict = NULL;
134	CFMutableDictionaryRef newIFs;
135
136	oldIFs = CFDictionaryCreateMutable(NULL,
137	0,
138	&kCFTypeDictionaryKeyCallBacks,
139	&kCFTypeDictionaryValueCallBacks);
140	newIFs = CFDictionaryCreateMutable(NULL,
141	0,
142	&kCFTypeDictionaryKeyCallBacks,
143	&kCFTypeDictionaryValueCallBacks);
144
145	if (!ifap) {
146	if (getifaddrs(&ifap_temp) < 0) {
147	SCLog(TRUE, LOG_ERR, CFSTR("getifaddrs() failed: %s"), strerror(errno));
148	goto error;
149	}
150	ifap = ifap_temp;
151	}
152
153	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
154	struct sockaddr_in *sin;
155
156	if (ifa->ifa_addr->sa_family != AF_INET) {
157	continue; /* sorry, not interested */
158	}
159
160	/* check if this is the requested interface */
161	if (if_name) {
162	if (strncmp(if_name, ifa->ifa_name, IFNAMSIZ) == 0) {
163	interfaceFound = TRUE; /* yes, this is the one I want */
164	} else {
165	continue; /* sorry, not interested */
166	}
167	}
168
169	interface = CFStringCreateWithCString(NULL, ifa->ifa_name, kCFStringEncodingMacRoman);
170	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
171	kSCDynamicStoreDomainState,
172	interface,
173	kSCEntNetIPv4);
174	CFRelease(interface);
175
176	newDict = getIF(key, oldIFs, newIFs);
177
178	sin = (struct sockaddr_in *)ifa->ifa_addr;
179	appendAddress(newDict, kSCPropNetIPv4Addresses, &sin->sin_addr);
180
181	if (ifa->ifa_flags & IFF_POINTOPOINT) {
182	struct sockaddr_in *dst;
183
184	dst = (struct sockaddr_in *)ifa->ifa_dstaddr;
185	appendAddress(newDict, kSCPropNetIPv4DestAddresses, &dst->sin_addr);
186	} else {
187	struct sockaddr_in *brd;
188	struct sockaddr_in *msk;
189
190	brd = (struct sockaddr_in *)ifa->ifa_broadaddr;
191	appendAddress(newDict, kSCPropNetIPv4BroadcastAddresses, &brd->sin_addr);
192	msk = (struct sockaddr_in *)ifa->ifa_netmask;
193	appendAddress(newDict, kSCPropNetIPv4SubnetMasks, &msk->sin_addr);
194	}
195
196	CFDictionarySetValue(newIFs, key, newDict);
197	CFRelease(newDict);
198	CFRelease(key);
199	}
200
201	/* if the last address[es] were removed from the target interface */
202	if (if_name && !interfaceFound) {
203	interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
204	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
205	kSCDynamicStoreDomainState,
206	interface,
207	kSCEntNetIPv4);
208	CFRelease(interface);
209
210	newDict = getIF(key, oldIFs, newIFs);
211
212	CFDictionarySetValue(newIFs, key, newDict);
213	CFRelease(newDict);
214	CFRelease(key);
215	}
216
217	CFDictionaryApplyFunction(newIFs, updateStore, oldIFs);
218
219	error :
220
221	if (ifap_temp) freeifaddrs(ifap_temp);
222	CFRelease(oldIFs);
223	CFRelease(newIFs);
224
225	return;
226	}
227
228	__private_extern__
229	void
230	interface_collision_ipv4(const char if_name, struct in_addr ip_addr, int hw_len, const void hw_addr)
231	{
232	uint8_t * hw_addr_bytes = (uint8_t *)hw_addr;
233	int i;
234	CFStringRef if_name_cf;
235	CFMutableStringRef key;
236	CFStringRef prefix;
237
238	if_name_cf = CFStringCreateWithCString(NULL, if_name,
239	kCFStringEncodingASCII);
240	prefix = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
241	kSCDynamicStoreDomainState,
242	if_name_cf,
243	kSCEntNetIPv4ARPCollision);
244	key = CFStringCreateMutableCopy(NULL, 0, prefix);
245	CFStringAppendFormat(key, NULL, CFSTR("/" IP_FORMAT),
246	IP_LIST(&ip_addr));
247	for (i = 0; i < hw_len; i++) {
248	CFStringAppendFormat(key, NULL, CFSTR("%s%02x"),
249	(i == 0) ? "/" : ":", hw_addr_bytes[i]);
250	}
251	cache_SCDynamicStoreNotifyValue(store, key);
252	CFRelease(key);
253	CFRelease(prefix);
254	CFRelease(if_name_cf);
255	return;
256	}