[apple/configd.git] / Plugins / KernelEventMonitor / ev_appletalk.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_appletalk.h"

// from <netat/ddp.h>
#define DDP_MIN_NETWORK	0x0001
#define DDP_MAX_NETWORK	0xfffe


static int
get_atalk_interface_cfg(const char *if_name, at_if_cfg_t *cfg)
{
	int 	fd;

	/* open socket */
	if ((fd = socket(AF_APPLETALK, SOCK_RAW, 0)) < 0)
		return -1;

	/* get config info for given interface */
	strncpy(cfg->ifr_name, if_name, sizeof(cfg->ifr_name));
	if (ioctl(fd, AIOCGETIFCFG, (caddr_t)cfg) < 0) {
		(void)close(fd);
		return -1;
	}

	(void)close(fd);
	return 0;
}


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, kSCPropNetAppleTalkNetworkID);
				CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkNodeID);
				CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkNetworkRange);
				CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkDefaultZone);
			}
			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_appletalk(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) {
		at_if_cfg_t		cfg;
		int			iVal;
		CFNumberRef		num;
		struct sockaddr_at	*sat;

		if (ifa->ifa_addr->sa_family != AF_APPLETALK) {
			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 */
			}
		}

		/* get the current cache information */
		interface = CFStringCreateWithCString(NULL, ifa->ifa_name, kCFStringEncodingMacRoman);
		key       = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
									  kSCDynamicStoreDomainState,
									  interface,
									  kSCEntNetAppleTalk);
		CFRelease(interface);

		newDict = getIF(key, oldIFs, newIFs);

		sat = (struct sockaddr_at *)ifa->ifa_addr;

		iVal = (int)sat->sat_addr.s_net;
		num  = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
		CFDictionarySetValue(newDict, kSCPropNetAppleTalkNetworkID, num);
		CFRelease(num);

		iVal = (int)sat->sat_addr.s_node;
		num  = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
		CFDictionarySetValue(newDict, kSCPropNetAppleTalkNodeID, num);
		CFRelease(num);

		if (get_atalk_interface_cfg(ifa->ifa_name, &cfg) == 0) {
			CFStringRef		zone;

			/*
			 * Set starting and ending net values
			 */
			if (!(((cfg.netStart == 0) && (cfg.netEnd == 0)) ||
			      ((cfg.netStart == DDP_MIN_NETWORK) && (cfg.netEnd == DDP_MAX_NETWORK)))) {
				CFMutableArrayRef	array;

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

				iVal = cfg.netStart;
				num  = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
				CFArrayAppendValue(array, num);
				CFRelease(num);

				iVal = cfg.netEnd;
				num  = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
				CFArrayAppendValue(array, num);
				CFRelease(num);

				CFDictionarySetValue(newDict, kSCPropNetAppleTalkNetworkRange, array);
				CFRelease(array);
			}

			/*
			 * Set the default zone
			 */
			zone = CFStringCreateWithPascalString(NULL,
							      (ConstStr255Param)&cfg.zonename,
							      kCFStringEncodingMacRoman);
			CFDictionarySetValue(newDict, kSCPropNetAppleTalkDefaultZone, zone);
			CFRelease(zone);
		}

		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,
									  kSCEntNetAppleTalk);
		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_update_atalk_address(struct kev_atalk_data *aEvent, const char *if_name)
{
	CFStringRef		interface;
	CFStringRef		key;
	CFDictionaryRef		dict;
	CFMutableDictionaryRef	newDict = NULL;
	CFNumberRef		newNode, newNet;
	int			node;
	int			net;

	/* get the current cache information */
	interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
	key       = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
								  kSCDynamicStoreDomainState,
								  interface,
								  kSCEntNetAppleTalk);
	CFRelease(interface);

	dict = cache_SCDynamicStoreCopyValue(store, key);
	if (dict) {
		if (isA_CFDictionary(dict)) {
			newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
		}
		CFRelease(dict);
	}

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

	/* Update node/net values in cache */
	node	= (int)aEvent->node_data.address.s_node;
	net	= (int)aEvent->node_data.address.s_net;

	newNode	= CFNumberCreate(NULL, kCFNumberIntType, &node);
	newNet 	= CFNumberCreate(NULL, kCFNumberIntType, &net);

	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNodeID, newNode);
	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNetworkID, newNet);

	CFRelease(newNode);
	CFRelease(newNet);

	/* update cache */
	cache_SCDynamicStoreSetValue(store, key, newDict);
	CFRelease(newDict);
	CFRelease(key);
	return;
}


__private_extern__
void
interface_update_atalk_zone(struct kev_atalk_data *aEvent, const char *if_name)
{
	CFStringRef		interface;
	CFStringRef		key;
	CFDictionaryRef		dict;
	CFMutableDictionaryRef	newDict	= NULL;
	CFStringRef		newZone;

	/* get the current cache information */
	interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
	key       = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
								  kSCDynamicStoreDomainState,
								  interface,
								  kSCEntNetAppleTalk);
	CFRelease(interface);

	dict = cache_SCDynamicStoreCopyValue(store, key);
	if (dict) {
		if (isA_CFDictionary(dict)) {
			newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
		}
		CFRelease(dict);
	}

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

	/* Update zone value in cache */
	newZone = CFStringCreateWithPascalString(NULL, (ConstStr255Param)&(aEvent->node_data.zone), kCFStringEncodingMacRoman);

	CFDictionarySetValue(newDict, kSCPropNetAppleTalkDefaultZone, newZone);

	CFRelease(newZone);

	/* update cache */
	cache_SCDynamicStoreSetValue(store, key, newDict);
	CFRelease(newDict);
	CFRelease(key);
	return;
}


__private_extern__
void
interface_update_shutdown_atalk()
{
	CFStringRef			cacheKey;
	CFDictionaryRef			dict;
	CFArrayRef			ifList = NULL;
	CFIndex 			count, index;
	CFStringRef 			interface;
	CFStringRef			key;

	cacheKey  = SCDynamicStoreKeyCreateNetworkInterface(NULL,
							    kSCDynamicStoreDomainState);

	dict = cache_SCDynamicStoreCopyValue(store, cacheKey);
	CFRelease(cacheKey);

	if (dict) {
		if (isA_CFDictionary(dict)) {
			/*get a list of the interfaces*/
			ifList  = isA_CFArray(CFDictionaryGetValue(dict, kSCDynamicStorePropNetInterfaces));
			if (ifList) {
				count = CFArrayGetCount(ifList);

				/*iterate through list and remove AppleTalk data*/
				for (index = 0; index < count; index++) {
					interface = CFArrayGetValueAtIndex(ifList, index);
					key       = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
												  kSCDynamicStoreDomainState,
												  interface,
												  kSCEntNetAppleTalk);
					cache_SCDynamicStoreRemoveValue(store, key);
					CFRelease(key);
				}
			}
		}
		CFRelease(dict);
	}

	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_appletalk.h"
	34
	35	// from <netat/ddp.h>
	36	#define DDP_MIN_NETWORK 0x0001
	37	#define DDP_MAX_NETWORK 0xfffe
	38
	39
	40	static int
	41	get_atalk_interface_cfg(const char if_name, at_if_cfg_t cfg)
	42	{
	43	int fd;
	44
	45	/* open socket */
	46	if ((fd = socket(AF_APPLETALK, SOCK_RAW, 0)) < 0)
	47	return -1;
	48
	49	/* get config info for given interface */
	50	strncpy(cfg->ifr_name, if_name, sizeof(cfg->ifr_name));
	51	if (ioctl(fd, AIOCGETIFCFG, (caddr_t)cfg) < 0) {
	52	(void)close(fd);
	53	return -1;
	54	}
	55
	56	(void)close(fd);
	57	return 0;
	58	}
	59
	60
	61	static CFMutableDictionaryRef
	62	getIF(CFStringRef key, CFMutableDictionaryRef oldIFs, CFMutableDictionaryRef newIFs)
	63	{
	64	CFDictionaryRef dict = NULL;
65	CFMutableDictionaryRef newDict = NULL;
66
67	if (CFDictionaryGetValueIfPresent(newIFs, key, (const void **)&dict)) {
68	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
69	} else {
70	dict = cache_SCDynamicStoreCopyValue(store, key);
71	if (dict) {
72	CFDictionarySetValue(oldIFs, key, dict);
73	if (isA_CFDictionary(dict)) {
74	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
75	CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkNetworkID);
76	CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkNodeID);
77	CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkNetworkRange);
78	CFDictionaryRemoveValue(newDict, kSCPropNetAppleTalkDefaultZone);
79	}
80	CFRelease(dict);
81	}
82	}
83
84	if (!newDict) {
85	newDict = CFDictionaryCreateMutable(NULL,
86	0,
87	&kCFTypeDictionaryKeyCallBacks,
88	&kCFTypeDictionaryValueCallBacks);
89	}
90
91	return newDict;
92	}
93
94
95	static void
96	updateStore(const void key, const void value, void *context)
97	{
98	CFDictionaryRef dict;
99	CFDictionaryRef newDict = (CFDictionaryRef)value;
100	CFDictionaryRef oldIFs = (CFDictionaryRef)context;
101
102	dict = CFDictionaryGetValue(oldIFs, key);
103
104	if (!dict \|\| !CFEqual(dict, newDict)) {
105	if (CFDictionaryGetCount(newDict) > 0) {
106	cache_SCDynamicStoreSetValue(store, key, newDict);
107	} else if (dict) {
108	cache_SCDynamicStoreRemoveValue(store, key);
109	}
110	}
111
112	return;
113	}
114
115
116	__private_extern__
117	void
118	interface_update_appletalk(struct ifaddrs ifap, const char if_name)
119	{
120	struct ifaddrs *ifa;
121	struct ifaddrs *ifap_temp = NULL;
122	CFStringRef interface;
123	boolean_t interfaceFound = FALSE;
124	CFStringRef key = NULL;
125	CFMutableDictionaryRef oldIFs;
126	CFMutableDictionaryRef newDict = NULL;
127	CFMutableDictionaryRef newIFs;
128
129	oldIFs = CFDictionaryCreateMutable(NULL,
130	0,
131	&kCFTypeDictionaryKeyCallBacks,
132	&kCFTypeDictionaryValueCallBacks);
133	newIFs = CFDictionaryCreateMutable(NULL,
134	0,
135	&kCFTypeDictionaryKeyCallBacks,
136	&kCFTypeDictionaryValueCallBacks);
137
138	if (!ifap) {
139	if (getifaddrs(&ifap_temp) < 0) {
140	SCLog(TRUE, LOG_ERR, CFSTR("getifaddrs() failed: %s"), strerror(errno));
141	goto error;
142	}
143	ifap = ifap_temp;
144	}
145
146	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
147	at_if_cfg_t cfg;
148	int iVal;
149	CFNumberRef num;
150	struct sockaddr_at *sat;
151
152	if (ifa->ifa_addr->sa_family != AF_APPLETALK) {
153	continue; /* sorry, not interested */
154	}
155
156	/* check if this is the requested interface */
157	if (if_name) {
158	if (strncmp(if_name, ifa->ifa_name, IFNAMSIZ) == 0) {
159	interfaceFound = TRUE; /* yes, this is the one I want */
160	} else {
161	continue; /* sorry, not interested */
162	}
163	}
164
165	/* get the current cache information */
166	interface = CFStringCreateWithCString(NULL, ifa->ifa_name, kCFStringEncodingMacRoman);
167	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
168	kSCDynamicStoreDomainState,
169	interface,
170	kSCEntNetAppleTalk);
171	CFRelease(interface);
172
173	newDict = getIF(key, oldIFs, newIFs);
174
175	sat = (struct sockaddr_at *)ifa->ifa_addr;
176
177	iVal = (int)sat->sat_addr.s_net;
178	num = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
179	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNetworkID, num);
180	CFRelease(num);
181
182	iVal = (int)sat->sat_addr.s_node;
183	num = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
184	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNodeID, num);
185	CFRelease(num);
186
187	if (get_atalk_interface_cfg(ifa->ifa_name, &cfg) == 0) {
188	CFStringRef zone;
189
190	/*
191	* Set starting and ending net values
192	*/
193	if (!(((cfg.netStart == 0) && (cfg.netEnd == 0)) \|\|
194	((cfg.netStart == DDP_MIN_NETWORK) && (cfg.netEnd == DDP_MAX_NETWORK)))) {
195	CFMutableArrayRef array;
196
197	array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
198
199	iVal = cfg.netStart;
200	num = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
201	CFArrayAppendValue(array, num);
202	CFRelease(num);
203
204	iVal = cfg.netEnd;
205	num = CFNumberCreate(NULL, kCFNumberIntType, &iVal);
206	CFArrayAppendValue(array, num);
207	CFRelease(num);
208
209	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNetworkRange, array);
210	CFRelease(array);
211	}
212
213	/*
214	* Set the default zone
215	*/
216	zone = CFStringCreateWithPascalString(NULL,
217	(ConstStr255Param)&cfg.zonename,
218	kCFStringEncodingMacRoman);
219	CFDictionarySetValue(newDict, kSCPropNetAppleTalkDefaultZone, zone);
220	CFRelease(zone);
221	}
222
223	CFDictionarySetValue(newIFs, key, newDict);
224	CFRelease(newDict);
225	CFRelease(key);
226	}
227
228	/* if the last address[es] were removed from the target interface */
229	if (if_name && !interfaceFound) {
230	interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
231	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
232	kSCDynamicStoreDomainState,
233	interface,
234	kSCEntNetAppleTalk);
235	CFRelease(interface);
236
237	newDict = getIF(key, oldIFs, newIFs);
238
239	CFDictionarySetValue(newIFs, key, newDict);
240	CFRelease(newDict);
241	CFRelease(key);
242	}
243
244	CFDictionaryApplyFunction(newIFs, updateStore, oldIFs);
245
246	error :
247
248	if (ifap_temp) freeifaddrs(ifap_temp);
249	CFRelease(oldIFs);
250	CFRelease(newIFs);
251
252	return;
253	}
254
255
256	__private_extern__
257	void
258	interface_update_atalk_address(struct kev_atalk_data aEvent, const char if_name)
259	{
260	CFStringRef interface;
261	CFStringRef key;
262	CFDictionaryRef dict;
263	CFMutableDictionaryRef newDict = NULL;
264	CFNumberRef newNode, newNet;
265	int node;
266	int net;
267
268	/* get the current cache information */
269	interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
270	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
271	kSCDynamicStoreDomainState,
272	interface,
273	kSCEntNetAppleTalk);
274	CFRelease(interface);
275
276	dict = cache_SCDynamicStoreCopyValue(store, key);
277	if (dict) {
278	if (isA_CFDictionary(dict)) {
279	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
280	}
281	CFRelease(dict);
282	}
283
284	if (!newDict) {
285	newDict = CFDictionaryCreateMutable(NULL,
286	0,
287	&kCFTypeDictionaryKeyCallBacks,
288	&kCFTypeDictionaryValueCallBacks);
289	}
290
291	/* Update node/net values in cache */
292	node = (int)aEvent->node_data.address.s_node;
293	net = (int)aEvent->node_data.address.s_net;
294
295	newNode = CFNumberCreate(NULL, kCFNumberIntType, &node);
296	newNet = CFNumberCreate(NULL, kCFNumberIntType, &net);
297
298	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNodeID, newNode);
299	CFDictionarySetValue(newDict, kSCPropNetAppleTalkNetworkID, newNet);
300
301	CFRelease(newNode);
302	CFRelease(newNet);
303
304	/* update cache */
305	cache_SCDynamicStoreSetValue(store, key, newDict);
306	CFRelease(newDict);
307	CFRelease(key);
308	return;
309	}
310
311
312	__private_extern__
313	void
314	interface_update_atalk_zone(struct kev_atalk_data aEvent, const char if_name)
315	{
316	CFStringRef interface;
317	CFStringRef key;
318	CFDictionaryRef dict;
319	CFMutableDictionaryRef newDict = NULL;
320	CFStringRef newZone;
321
322	/* get the current cache information */
323	interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
324	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
325	kSCDynamicStoreDomainState,
326	interface,
327	kSCEntNetAppleTalk);
328	CFRelease(interface);
329
330	dict = cache_SCDynamicStoreCopyValue(store, key);
331	if (dict) {
332	if (isA_CFDictionary(dict)) {
333	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
334	}
335	CFRelease(dict);
336	}
337
338	if (!newDict) {
339	newDict = CFDictionaryCreateMutable(NULL,
340	0,
341	&kCFTypeDictionaryKeyCallBacks,
342	&kCFTypeDictionaryValueCallBacks);
343	}
344
345	/* Update zone value in cache */
346	newZone = CFStringCreateWithPascalString(NULL, (ConstStr255Param)&(aEvent->node_data.zone), kCFStringEncodingMacRoman);
347
348	CFDictionarySetValue(newDict, kSCPropNetAppleTalkDefaultZone, newZone);
349
350	CFRelease(newZone);
351
352	/* update cache */
353	cache_SCDynamicStoreSetValue(store, key, newDict);
354	CFRelease(newDict);
355	CFRelease(key);
356	return;
357	}
358
359
360	__private_extern__
361	void
362	interface_update_shutdown_atalk()
363	{
364	CFStringRef cacheKey;
365	CFDictionaryRef dict;
366	CFArrayRef ifList = NULL;
367	CFIndex count, index;
368	CFStringRef interface;
369	CFStringRef key;
370
371	cacheKey = SCDynamicStoreKeyCreateNetworkInterface(NULL,
372	kSCDynamicStoreDomainState);
373
374	dict = cache_SCDynamicStoreCopyValue(store, cacheKey);
375	CFRelease(cacheKey);
376
377	if (dict) {
378	if (isA_CFDictionary(dict)) {
379	/get a list of the interfaces/
380	ifList = isA_CFArray(CFDictionaryGetValue(dict, kSCDynamicStorePropNetInterfaces));
381	if (ifList) {
382	count = CFArrayGetCount(ifList);
383
384	/iterate through list and remove AppleTalk data/
385	for (index = 0; index < count; index++) {
386	interface = CFArrayGetValueAtIndex(ifList, index);
387	key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
388	kSCDynamicStoreDomainState,
389	interface,
390	kSCEntNetAppleTalk);
391	cache_SCDynamicStoreRemoveValue(store, key);
392	CFRelease(key);
393	}
394	}
395	}
396	CFRelease(dict);
397	}
398
399	return;
400	}