[apple/configd.git] / configd.tproj / _SCD.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 *
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */


#include "configd.h"


CFMutableDictionaryRef	sessionData          = NULL;

CFMutableDictionaryRef	cacheData            = NULL;
CFMutableDictionaryRef	cacheData_s	     = NULL;

CFMutableSetRef		changedKeys          = NULL;
CFMutableSetRef		changedKeys_s        = NULL;

CFMutableSetRef		deferredRemovals     = NULL;
CFMutableSetRef		deferredRemovals_s   = NULL;

CFMutableSetRef		removedSessionKeys   = NULL;
CFMutableSetRef		removedSessionKeys_s = NULL;

CFMutableSetRef		needsNotification    = NULL;


void
_swapLockedCacheData()
{
	void	*temp;

	temp                 = cacheData;
	cacheData            = cacheData_s;
	cacheData_s          = temp;

	temp                 = changedKeys;
	changedKeys          = changedKeys_s;
	changedKeys_s        = temp;

	temp                 = deferredRemovals;
	deferredRemovals     = deferredRemovals_s;
	deferredRemovals_s   = temp;

	temp                 = removedSessionKeys;
	removedSessionKeys   = removedSessionKeys_s;
	removedSessionKeys_s = temp;

	return;
}


void
_addWatcher(CFNumberRef sessionNum, CFStringRef watchedKey)
{
	CFDictionaryRef		dict;
	CFMutableDictionaryRef	newDict;
	CFArrayRef		watchers;
	CFMutableArrayRef	newWatchers;
	CFArrayRef		watcherRefs;
	CFMutableArrayRef	newWatcherRefs;
	CFIndex			i;
	int			refCnt;
	CFNumberRef		refNum;

	/*
	 * Get the dictionary associated with this key out of the cache
	 */
	dict = CFDictionaryGetValue(cacheData, watchedKey);
	if (dict) {
		newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
	} else {
		newDict = CFDictionaryCreateMutable(NULL,
						    0,
						    &kCFTypeDictionaryKeyCallBacks,
						    &kCFTypeDictionaryValueCallBacks);
	}

	/*
	 * Get the set of watchers out of the keys dictionary
	 */
	watchers    = CFDictionaryGetValue(newDict, kSCDWatchers);
	watcherRefs = CFDictionaryGetValue(newDict, kSCDWatcherRefs);
	if (watchers) {
		newWatchers    = CFArrayCreateMutableCopy(NULL, 0, watchers);
		newWatcherRefs = CFArrayCreateMutableCopy(NULL, 0, watcherRefs);
	} else {
		newWatchers    = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
		newWatcherRefs = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
	}

	/*
	 * Add my session to the set of watchers
	 */
	i = CFArrayGetFirstIndexOfValue(newWatchers,
					CFRangeMake(0, CFArrayGetCount(newWatchers)),
					sessionNum);
	if (i == -1) {
		/* if this is the first instance of this session watching this key */
		CFArrayAppendValue(newWatchers, sessionNum);
		refCnt = 1;
		refNum = CFNumberCreate(NULL, kCFNumberIntType, &refCnt);
		CFArrayAppendValue(newWatcherRefs, refNum);
		CFRelease(refNum);
	} else {
		/* if this is another instance of this session watching this key */
		refNum = CFArrayGetValueAtIndex(newWatcherRefs, i);
		CFNumberGetValue(refNum, kCFNumberIntType, &refCnt);
		refCnt++;
		refNum = CFNumberCreate(NULL, kCFNumberIntType, &refCnt);
		CFArraySetValueAtIndex(newWatcherRefs, i, refNum);
		CFRelease(refNum);
	}

	/*
	 * Update the keys dictionary
	 */
	CFDictionarySetValue(newDict, kSCDWatchers, newWatchers);
	CFRelease(newWatchers);
	CFDictionarySetValue(newDict, kSCDWatcherRefs, newWatcherRefs);
	CFRelease(newWatcherRefs);

	/*
	 * Update the cache for this key
	 */
	CFDictionarySetValue(cacheData, watchedKey, newDict);
	CFRelease(newDict);

	SCDLog(LOG_DEBUG, CFSTR("  _addWatcher: %@, %@"), sessionNum, watchedKey);

	return;
}


/*
 * _addRegexWatcherByKey()
 *
 * This is a CFDictionaryApplierFunction which will iterate over each key
 * defined in the "cacheData" dictionary. The arguments are the dictionary
 * key, it's associated cache dictionary, and a context structure which
 * includes the following:
 *
 *   1. the session which has just added a regex notification request
 *   2. the compiled regular expression associated with the above key.
 *
 * If a (real) dictionary key is found which matches the provided regular
 * expression then we mark that key as being watched by the session.
 */
void
_addRegexWatcherByKey(const void *key, void *val, void *context)
{
	CFStringRef	cacheStr  = key;
	CFDictionaryRef	info      = val;
	mach_port_t	sessionID = ((addContextRef)context)->session->server;
	regex_t		*preg     = ((addContextRef)context)->preg;
	int		cacheKeyLen;
	char		*cacheKey;
	CFNumberRef	sessionNum;
	int		reError;
	char		reErrBuf[256];
	int		reErrStrLen;

	if (CFDictionaryContainsKey(info, kSCDData) == FALSE) {
		/* if no data (yet) */
		return;
	}

	/* convert cache key to C string */
	cacheKeyLen = CFStringGetLength(cacheStr) + 1;
	cacheKey    = CFAllocatorAllocate(NULL, cacheKeyLen, 0);
	if (!CFStringGetCString(cacheStr, cacheKey, cacheKeyLen, kCFStringEncodingMacRoman)) {
		SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert cache key to C string"));
		CFAllocatorDeallocate(NULL, cacheKey);
		return;
	}

	/* compare cache key to new notification keys regular expression pattern */
	reError = regexec(preg, cacheKey, 0, NULL, 0);
	switch (reError) {
		case 0 :
			/* we've got a match */
			sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionID);
			_addWatcher(sessionNum, cacheStr);
			CFRelease(sessionNum);
			break;
		case REG_NOMATCH :
			/* no match */
			break;
		default :
			reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
			SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
			break;
	}
	CFAllocatorDeallocate(NULL, cacheKey);
}


/*
 * _addRegexWatchersBySession()
 *
 * This is a CFDictionaryApplierFunction which will iterate over each session
 * defined in the "sessionData" dictionary. The arguments are the session
 * key, it's associated session dictionary, , and the cache key being added.
 *
 * If an active session includes any regular expression keys which match the
 * key being added to the "cacheData" dictionary then we mark this key as being
 * watched by the session.
 */
void
_addRegexWatchersBySession(const void *key, void *val, void *context)
{
	CFStringRef	sessionKey = key;
	CFDictionaryRef	info       = val;
	CFStringRef	addedKey   = context;
	CFIndex		newKeyLen;
	char		*newKeyStr;
	CFArrayRef	rKeys;
	CFArrayRef	rData;
	CFIndex		i;

	if (info == NULL) {
		/* if no dictionary for this session */
		return;
	}

	rKeys = CFDictionaryGetValue(info, kSCDRegexKeys);
	if (rKeys == NULL) {
		/* if no regex keys for this session */
		return;
	}
	rData = CFDictionaryGetValue(info, kSCDRegexData);

	/* convert new key to C string */
	newKeyLen = CFStringGetLength(addedKey) + 1;
	newKeyStr = CFAllocatorAllocate(NULL, newKeyLen, 0);
	if (!CFStringGetCString(addedKey, newKeyStr, newKeyLen, kCFStringEncodingMacRoman)) {
		SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert new key to C string"));
		CFAllocatorDeallocate(NULL, newKeyStr);
		return;
	}

	/* iterate over the regex keys looking for an pattern which matches the new key */
	for (i=0; i<CFArrayGetCount(rKeys); i++) {
		CFDataRef	regexData = CFArrayGetValueAtIndex(rData, i);
		regex_t		*preg     = (regex_t *)CFDataGetBytePtr(regexData);
		int		reError;
		char		reErrBuf[256];
		int		reErrStrLen;
		SInt32		sessionInt;
		CFNumberRef	sessionNum;

		/* check if this key matches the regular expression */
		reError = regexec(preg, newKeyStr, 0, NULL, 0);
		switch (reError) {
			case 0 :
				/* we've got a match, add a reference */
				sessionInt = CFStringGetIntValue(sessionKey);
				sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionInt);
				_addWatcher(sessionNum, addedKey);
				CFRelease(sessionNum);
				break;
			case REG_NOMATCH :
				/* no match */
				break;
			default :
				reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
				SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
				break;
		}

	}
	CFAllocatorDeallocate(NULL, newKeyStr);

	return;
}


void
_removeWatcher(CFNumberRef sessionNum, CFStringRef watchedKey)
{
	CFDictionaryRef		dict;
	CFMutableDictionaryRef	newDict;
	CFArrayRef		watchers;
	CFMutableArrayRef	newWatchers;
	CFArrayRef		watcherRefs;
	CFMutableArrayRef	newWatcherRefs;
	CFIndex			i;
	int			refCnt;
	CFNumberRef		refNum;

	/*
	 * Get the dictionary associated with this key out of the cache
	 */
	dict = CFDictionaryGetValue(cacheData, watchedKey);
	if ((dict == NULL) || (CFDictionaryContainsKey(dict, kSCDWatchers) == FALSE)) {
		/* key doesn't exist (isn't this really fatal?) */
		SCDLog(LOG_DEBUG, CFSTR("_removeWatcher: key not present in dictionary."));
		return;
	}
	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);

	/*
	 * Get the set of watchers out of the keys dictionary and
	 * remove this session from the list.
	 */
	watchers       = CFDictionaryGetValue(newDict, kSCDWatchers);
	newWatchers    = CFArrayCreateMutableCopy(NULL, 0, watchers);

	watcherRefs    = CFDictionaryGetValue(newDict, kSCDWatcherRefs);
	newWatcherRefs = CFArrayCreateMutableCopy(NULL, 0, watcherRefs);

	/* locate the session reference */
	i = CFArrayGetFirstIndexOfValue(newWatchers,
					CFRangeMake(0, CFArrayGetCount(newWatchers)),
					sessionNum);
	if (i == -1) {
		SCDLog(LOG_DEBUG, CFSTR("_removeWatcher: no reference for session %@"), sessionNum);
		CFRelease(newDict);
		CFRelease(newWatchers);
		CFRelease(newWatcherRefs);
		return;
	}

	/* remove one session reference */
	refNum = CFArrayGetValueAtIndex(newWatcherRefs, i);
	CFNumberGetValue(refNum, kCFNumberIntType, &refCnt);
	if (--refCnt > 0) {
		refNum = CFNumberCreate(NULL, kCFNumberIntType, &refCnt);
		CFArraySetValueAtIndex(newWatcherRefs, i, refNum);
		CFRelease(refNum);
	} else {
		/* if this was the last reference */
		CFArrayRemoveValueAtIndex(newWatchers, i);
		CFArrayRemoveValueAtIndex(newWatcherRefs, i);
	}

	if (CFArrayGetCount(newWatchers) > 0) {
		/* if this key is still being "watched" */
		CFDictionarySetValue(newDict, kSCDWatchers, newWatchers);
		CFDictionarySetValue(newDict, kSCDWatcherRefs, newWatcherRefs);
	} else {
		/* no watchers left, remove the empty set */
		CFDictionaryRemoveValue(newDict, kSCDWatchers);
		CFDictionaryRemoveValue(newDict, kSCDWatcherRefs);
	}
	CFRelease(newWatchers);
	CFRelease(newWatcherRefs);

	if (CFDictionaryGetCount(newDict) > 0) {
		/* if this key is still active */
		CFDictionarySetValue(cacheData, watchedKey, newDict);
	} else {
		/* no information left, remove the empty dictionary */
		CFDictionaryRemoveValue(cacheData, watchedKey);
	}
	CFRelease(newDict);

	SCDLog(LOG_DEBUG, CFSTR("  _removeWatcher: %@, %@"), sessionNum, watchedKey);

	return;
}


/*
 * _removeRegexWatcherByKey()
 *
 * This is a CFDictionaryApplierFunction which will iterate over each key
 * defined in the "cacheData" dictionary. The arguments are the dictionary
 * key, it's associated cache dictionary, and a context structure which
 * includes the following:
 *
 *   1. the session which has just removed a regex notification request
 *   2. the compiled regular expression associated with the above key.
 *
 * If a key is found and it matches the provided regular expression then
 * it will its "being watched" status will be cleared.
 */
void
_removeRegexWatcherByKey(const void *key, void *val, void *context)
{
	CFStringRef	cacheStr  = key;
	CFDictionaryRef	info      = val;
	mach_port_t	sessionID = ((removeContextRef)context)->session->server;
	regex_t		*preg     = ((removeContextRef)context)->preg;
	CFNumberRef	sessionNum;
	CFArrayRef	watchers;
	int		cacheKeyLen;
	char		*cacheKey;
	int		reError;
	char		reErrBuf[256];
	int		reErrStrLen;

	if ((info == NULL) || (CFDictionaryContainsKey(info, kSCDWatchers) == FALSE)) {
		/* no dictionary or no watchers */
		return;
	}

	sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionID);

	watchers = CFDictionaryGetValue(info, kSCDWatchers);
	if (CFArrayContainsValue(watchers,
				 CFRangeMake(0, CFArrayGetCount(watchers)),
				 sessionNum) == FALSE) {
		/* this session is not watching this key */
		CFRelease(sessionNum);
		return;
	}

	/* convert key to C string */
	cacheKeyLen = CFStringGetLength(cacheStr) + 1;
	cacheKey    = CFAllocatorAllocate(NULL, cacheKeyLen, 0);
	if (!CFStringGetCString(cacheStr, cacheKey, cacheKeyLen, kCFStringEncodingMacRoman)) {
		SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert key to C string"));
		CFAllocatorDeallocate(NULL, cacheKey);
		CFRelease(sessionNum);
		return;
	}

	/* check if this key matches the regular expression */
	reError = regexec(preg, cacheKey, 0, NULL, 0);
	switch (reError) {
		case 0 :
			/* we've got a match */
			_removeWatcher(sessionNum, cacheStr);
			break;
		case REG_NOMATCH :
			/* no match */
			break;
		default :
			reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
			SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
			break;
	}
	CFAllocatorDeallocate(NULL, cacheKey);
	CFRelease(sessionNum);
}


/*
 * _removeRegexWatchersBySession()
 *
 * This is a CFDictionaryApplierFunction which will iterate over each session
 * defined in the "sessionData" dictionary. The arguments are the session
 * key, it's associated session dictionary, and the cache key being removed.
 *
 * If an active session includes any regular expression keys which match the
 * key being removed from the "cacheData" dictionary then we clear this keys
 * reference of being watched.
 */
void
_removeRegexWatchersBySession(const void *key, void *val, void *context)
{
	CFStringRef	sessionKey = key;
	CFDictionaryRef	info       = val;
	CFStringRef	removedKey = context;
	CFIndex		oldKeyLen;
	char		*oldKeyStr;
	CFArrayRef	rKeys;
	CFArrayRef	rData;
	CFIndex		i;

	if (info == NULL) {
		/* if no dictionary for this session */
		return;
	}

	rKeys = CFDictionaryGetValue(info, kSCDRegexKeys);
	if (rKeys == NULL) {
		/* if no regex keys for this session */
		return;
	}
	rData = CFDictionaryGetValue(info, kSCDRegexData);

	/* convert new key to C string */
	oldKeyLen = CFStringGetLength(removedKey) + 1;
	oldKeyStr = CFAllocatorAllocate(NULL, oldKeyLen, 0);
	if (!CFStringGetCString(removedKey, oldKeyStr, oldKeyLen, kCFStringEncodingMacRoman)) {
		SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert old key to C string"));
		CFAllocatorDeallocate(NULL, oldKeyStr);
		return;
	}

	/* iterate over the regex keys looking for an pattern which matches the old key */
	for (i=0; i<CFArrayGetCount(rKeys); i++) {
		CFDataRef	regexData = CFArrayGetValueAtIndex(rData, i);
		regex_t		*preg     = (regex_t *)CFDataGetBytePtr(regexData);
		int		reError;
		char		reErrBuf[256];
		int		reErrStrLen;
		SInt32		sessionInt;
		CFNumberRef	sessionNum;

		/* check if this key matches the regular expression */
		reError = regexec(preg, oldKeyStr, 0, NULL, 0);
		switch (reError) {
			case 0 :
				/* we've got a match, remove a reference */
				sessionInt = CFStringGetIntValue(sessionKey);
				sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionInt);
				_removeWatcher(sessionNum, removedKey);
				CFRelease(sessionNum);
				break;
			case REG_NOMATCH :
				/* no match */
				break;
			default :
				reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
				SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
				break;
		}

	}
	CFAllocatorDeallocate(NULL, oldKeyStr);

	return;
}
Commit	Line	Data
5958d7c0 A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22
	23
	24	#include "configd.h"
	25
	26
	27	CFMutableDictionaryRef sessionData = NULL;
	28
	29	CFMutableDictionaryRef cacheData = NULL;
	30	CFMutableDictionaryRef cacheData_s = NULL;
	31
	32	CFMutableSetRef changedKeys = NULL;
	33	CFMutableSetRef changedKeys_s = NULL;
	34
	35	CFMutableSetRef deferredRemovals = NULL;
	36	CFMutableSetRef deferredRemovals_s = NULL;
	37
	38	CFMutableSetRef removedSessionKeys = NULL;
	39	CFMutableSetRef removedSessionKeys_s = NULL;
	40
	41	CFMutableSetRef needsNotification = NULL;
	42
	43
	44	void
	45	_swapLockedCacheData()
	46	{
	47	void *temp;
	48
	49	temp = cacheData;
	50	cacheData = cacheData_s;
	51	cacheData_s = temp;
	52
	53	temp = changedKeys;
	54	changedKeys = changedKeys_s;
	55	changedKeys_s = temp;
	56
	57	temp = deferredRemovals;
	58	deferredRemovals = deferredRemovals_s;
	59	deferredRemovals_s = temp;
	60
	61	temp = removedSessionKeys;
	62	removedSessionKeys = removedSessionKeys_s;
	63	removedSessionKeys_s = temp;
	64
65	return;
66	}
67
68
69	void
70	_addWatcher(CFNumberRef sessionNum, CFStringRef watchedKey)
71	{
72	CFDictionaryRef dict;
73	CFMutableDictionaryRef newDict;
74	CFArrayRef watchers;
75	CFMutableArrayRef newWatchers;
76	CFArrayRef watcherRefs;
77	CFMutableArrayRef newWatcherRefs;
78	CFIndex i;
79	int refCnt;
80	CFNumberRef refNum;
81
82	/*
83	* Get the dictionary associated with this key out of the cache
84	*/
85	dict = CFDictionaryGetValue(cacheData, watchedKey);
86	if (dict) {
87	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
88	} else {
89	newDict = CFDictionaryCreateMutable(NULL,
90	0,
91	&kCFTypeDictionaryKeyCallBacks,
92	&kCFTypeDictionaryValueCallBacks);
93	}
94
95	/*
96	* Get the set of watchers out of the keys dictionary
97	*/
98	watchers = CFDictionaryGetValue(newDict, kSCDWatchers);
99	watcherRefs = CFDictionaryGetValue(newDict, kSCDWatcherRefs);
100	if (watchers) {
101	newWatchers = CFArrayCreateMutableCopy(NULL, 0, watchers);
102	newWatcherRefs = CFArrayCreateMutableCopy(NULL, 0, watcherRefs);
103	} else {
104	newWatchers = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
105	newWatcherRefs = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
106	}
107
108	/*
109	* Add my session to the set of watchers
110	*/
111	i = CFArrayGetFirstIndexOfValue(newWatchers,
112	CFRangeMake(0, CFArrayGetCount(newWatchers)),
113	sessionNum);
114	if (i == -1) {
115	/* if this is the first instance of this session watching this key */
116	CFArrayAppendValue(newWatchers, sessionNum);
117	refCnt = 1;
118	refNum = CFNumberCreate(NULL, kCFNumberIntType, &refCnt);
119	CFArrayAppendValue(newWatcherRefs, refNum);
120	CFRelease(refNum);
121	} else {
122	/* if this is another instance of this session watching this key */
123	refNum = CFArrayGetValueAtIndex(newWatcherRefs, i);
124	CFNumberGetValue(refNum, kCFNumberIntType, &refCnt);
125	refCnt++;
126	refNum = CFNumberCreate(NULL, kCFNumberIntType, &refCnt);
127	CFArraySetValueAtIndex(newWatcherRefs, i, refNum);
128	CFRelease(refNum);
129	}
130
131	/*
132	* Update the keys dictionary
133	*/
134	CFDictionarySetValue(newDict, kSCDWatchers, newWatchers);
135	CFRelease(newWatchers);
136	CFDictionarySetValue(newDict, kSCDWatcherRefs, newWatcherRefs);
137	CFRelease(newWatcherRefs);
138
139	/*
140	* Update the cache for this key
141	*/
142	CFDictionarySetValue(cacheData, watchedKey, newDict);
143	CFRelease(newDict);
144
145	SCDLog(LOG_DEBUG, CFSTR(" _addWatcher: %@, %@"), sessionNum, watchedKey);
146
147	return;
148	}
149
150
151	/*
152	* _addRegexWatcherByKey()
153	*
154	* This is a CFDictionaryApplierFunction which will iterate over each key
155	* defined in the "cacheData" dictionary. The arguments are the dictionary
156	* key, it's associated cache dictionary, and a context structure which
157	* includes the following:
158	*
159	* 1. the session which has just added a regex notification request
160	* 2. the compiled regular expression associated with the above key.
161	*
162	* If a (real) dictionary key is found which matches the provided regular
163	* expression then we mark that key as being watched by the session.
164	*/
165	void
166	_addRegexWatcherByKey(const void key, void val, void *context)
167	{
168	CFStringRef cacheStr = key;
169	CFDictionaryRef info = val;
170	mach_port_t sessionID = ((addContextRef)context)->session->server;
171	regex_t *preg = ((addContextRef)context)->preg;
172	int cacheKeyLen;
173	char *cacheKey;
174	CFNumberRef sessionNum;
175	int reError;
176	char reErrBuf[256];
177	int reErrStrLen;
178
179	if (CFDictionaryContainsKey(info, kSCDData) == FALSE) {
180	/* if no data (yet) */
181	return;
182	}
183
184	/* convert cache key to C string */
185	cacheKeyLen = CFStringGetLength(cacheStr) + 1;
186	cacheKey = CFAllocatorAllocate(NULL, cacheKeyLen, 0);
187	if (!CFStringGetCString(cacheStr, cacheKey, cacheKeyLen, kCFStringEncodingMacRoman)) {
188	SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert cache key to C string"));
189	CFAllocatorDeallocate(NULL, cacheKey);
190	return;
191	}
192
193	/* compare cache key to new notification keys regular expression pattern */
194	reError = regexec(preg, cacheKey, 0, NULL, 0);
195	switch (reError) {
196	case 0 :
197	/* we've got a match */
198	sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionID);
199	_addWatcher(sessionNum, cacheStr);
200	CFRelease(sessionNum);
201	break;
202	case REG_NOMATCH :
203	/* no match */
204	break;
205	default :
206	reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
207	SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
208	break;
209	}
210	CFAllocatorDeallocate(NULL, cacheKey);
211	}
212
213
214	/*
215	* _addRegexWatchersBySession()
216	*
217	* This is a CFDictionaryApplierFunction which will iterate over each session
218	* defined in the "sessionData" dictionary. The arguments are the session
219	* key, it's associated session dictionary, , and the cache key being added.
220	*
221	* If an active session includes any regular expression keys which match the
222	* key being added to the "cacheData" dictionary then we mark this key as being
223	* watched by the session.
224	*/
225	void
226	_addRegexWatchersBySession(const void key, void val, void *context)
227	{
228	CFStringRef sessionKey = key;
229	CFDictionaryRef info = val;
230	CFStringRef addedKey = context;
231	CFIndex newKeyLen;
232	char *newKeyStr;
233	CFArrayRef rKeys;
234	CFArrayRef rData;
235	CFIndex i;
236
237	if (info == NULL) {
238	/* if no dictionary for this session */
239	return;
240	}
241
242	rKeys = CFDictionaryGetValue(info, kSCDRegexKeys);
243	if (rKeys == NULL) {
244	/* if no regex keys for this session */
245	return;
246	}
247	rData = CFDictionaryGetValue(info, kSCDRegexData);
248
249	/* convert new key to C string */
250	newKeyLen = CFStringGetLength(addedKey) + 1;
251	newKeyStr = CFAllocatorAllocate(NULL, newKeyLen, 0);
252	if (!CFStringGetCString(addedKey, newKeyStr, newKeyLen, kCFStringEncodingMacRoman)) {
253	SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert new key to C string"));
254	CFAllocatorDeallocate(NULL, newKeyStr);
255	return;
256	}
257
258	/* iterate over the regex keys looking for an pattern which matches the new key */
259	for (i=0; i<CFArrayGetCount(rKeys); i++) {
260	CFDataRef regexData = CFArrayGetValueAtIndex(rData, i);
261	regex_t preg = (regex_t )CFDataGetBytePtr(regexData);
262	int reError;
263	char reErrBuf[256];
264	int reErrStrLen;
265	SInt32 sessionInt;
266	CFNumberRef sessionNum;
267
268	/* check if this key matches the regular expression */
269	reError = regexec(preg, newKeyStr, 0, NULL, 0);
270	switch (reError) {
271	case 0 :
272	/* we've got a match, add a reference */
273	sessionInt = CFStringGetIntValue(sessionKey);
274	sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionInt);
275	_addWatcher(sessionNum, addedKey);
276	CFRelease(sessionNum);
277	break;
278	case REG_NOMATCH :
279	/* no match */
280	break;
281	default :
282	reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
283	SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
284	break;
285	}
286
287	}
288	CFAllocatorDeallocate(NULL, newKeyStr);
289
290	return;
291	}
292
293
294	void
295	_removeWatcher(CFNumberRef sessionNum, CFStringRef watchedKey)
296	{
297	CFDictionaryRef dict;
298	CFMutableDictionaryRef newDict;
299	CFArrayRef watchers;
300	CFMutableArrayRef newWatchers;
301	CFArrayRef watcherRefs;
302	CFMutableArrayRef newWatcherRefs;
303	CFIndex i;
304	int refCnt;
305	CFNumberRef refNum;
306
307	/*
308	* Get the dictionary associated with this key out of the cache
309	*/
310	dict = CFDictionaryGetValue(cacheData, watchedKey);
311	if ((dict == NULL) \|\| (CFDictionaryContainsKey(dict, kSCDWatchers) == FALSE)) {
312	/* key doesn't exist (isn't this really fatal?) */
313	SCDLog(LOG_DEBUG, CFSTR("_removeWatcher: key not present in dictionary."));
314	return;
315	}
316	newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
317
318	/*
319	* Get the set of watchers out of the keys dictionary and
320	* remove this session from the list.
321	*/
322	watchers = CFDictionaryGetValue(newDict, kSCDWatchers);
323	newWatchers = CFArrayCreateMutableCopy(NULL, 0, watchers);
324
325	watcherRefs = CFDictionaryGetValue(newDict, kSCDWatcherRefs);
326	newWatcherRefs = CFArrayCreateMutableCopy(NULL, 0, watcherRefs);
327
328	/* locate the session reference */
329	i = CFArrayGetFirstIndexOfValue(newWatchers,
330	CFRangeMake(0, CFArrayGetCount(newWatchers)),
331	sessionNum);
332	if (i == -1) {
333	SCDLog(LOG_DEBUG, CFSTR("_removeWatcher: no reference for session %@"), sessionNum);
334	CFRelease(newDict);
335	CFRelease(newWatchers);
336	CFRelease(newWatcherRefs);
337	return;
338	}
339
340	/* remove one session reference */
341	refNum = CFArrayGetValueAtIndex(newWatcherRefs, i);
342	CFNumberGetValue(refNum, kCFNumberIntType, &refCnt);
343	if (--refCnt > 0) {
344	refNum = CFNumberCreate(NULL, kCFNumberIntType, &refCnt);
345	CFArraySetValueAtIndex(newWatcherRefs, i, refNum);
346	CFRelease(refNum);
347	} else {
348	/* if this was the last reference */
349	CFArrayRemoveValueAtIndex(newWatchers, i);
350	CFArrayRemoveValueAtIndex(newWatcherRefs, i);
351	}
352
353	if (CFArrayGetCount(newWatchers) > 0) {
354	/* if this key is still being "watched" */
355	CFDictionarySetValue(newDict, kSCDWatchers, newWatchers);
356	CFDictionarySetValue(newDict, kSCDWatcherRefs, newWatcherRefs);
357	} else {
358	/* no watchers left, remove the empty set */
359	CFDictionaryRemoveValue(newDict, kSCDWatchers);
360	CFDictionaryRemoveValue(newDict, kSCDWatcherRefs);
361	}
362	CFRelease(newWatchers);
363	CFRelease(newWatcherRefs);
364
365	if (CFDictionaryGetCount(newDict) > 0) {
366	/* if this key is still active */
367	CFDictionarySetValue(cacheData, watchedKey, newDict);
368	} else {
369	/* no information left, remove the empty dictionary */
370	CFDictionaryRemoveValue(cacheData, watchedKey);
371	}
372	CFRelease(newDict);
373
374	SCDLog(LOG_DEBUG, CFSTR(" _removeWatcher: %@, %@"), sessionNum, watchedKey);
375
376	return;
377	}
378
379
380	/*
381	* _removeRegexWatcherByKey()
382	*
383	* This is a CFDictionaryApplierFunction which will iterate over each key
384	* defined in the "cacheData" dictionary. The arguments are the dictionary
385	* key, it's associated cache dictionary, and a context structure which
386	* includes the following:
387	*
388	* 1. the session which has just removed a regex notification request
389	* 2. the compiled regular expression associated with the above key.
390	*
391	* If a key is found and it matches the provided regular expression then
392	* it will its "being watched" status will be cleared.
393	*/
394	void
395	_removeRegexWatcherByKey(const void key, void val, void *context)
396	{
397	CFStringRef cacheStr = key;
398	CFDictionaryRef info = val;
399	mach_port_t sessionID = ((removeContextRef)context)->session->server;
400	regex_t *preg = ((removeContextRef)context)->preg;
401	CFNumberRef sessionNum;
402	CFArrayRef watchers;
403	int cacheKeyLen;
404	char *cacheKey;
405	int reError;
406	char reErrBuf[256];
407	int reErrStrLen;
408
409	if ((info == NULL) \|\| (CFDictionaryContainsKey(info, kSCDWatchers) == FALSE)) {
410	/* no dictionary or no watchers */
411	return;
412	}
413
414	sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionID);
415
416	watchers = CFDictionaryGetValue(info, kSCDWatchers);
417	if (CFArrayContainsValue(watchers,
418	CFRangeMake(0, CFArrayGetCount(watchers)),
419	sessionNum) == FALSE) {
420	/* this session is not watching this key */
421	CFRelease(sessionNum);
422	return;
423	}
424
425	/* convert key to C string */
426	cacheKeyLen = CFStringGetLength(cacheStr) + 1;
427	cacheKey = CFAllocatorAllocate(NULL, cacheKeyLen, 0);
428	if (!CFStringGetCString(cacheStr, cacheKey, cacheKeyLen, kCFStringEncodingMacRoman)) {
429	SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert key to C string"));
430	CFAllocatorDeallocate(NULL, cacheKey);
431	CFRelease(sessionNum);
432	return;
433	}
434
435	/* check if this key matches the regular expression */
436	reError = regexec(preg, cacheKey, 0, NULL, 0);
437	switch (reError) {
438	case 0 :
439	/* we've got a match */
440	_removeWatcher(sessionNum, cacheStr);
441	break;
442	case REG_NOMATCH :
443	/* no match */
444	break;
445	default :
446	reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
447	SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
448	break;
449	}
450	CFAllocatorDeallocate(NULL, cacheKey);
451	CFRelease(sessionNum);
452	}
453
454
455	/*
456	* _removeRegexWatchersBySession()
457	*
458	* This is a CFDictionaryApplierFunction which will iterate over each session
459	* defined in the "sessionData" dictionary. The arguments are the session
460	* key, it's associated session dictionary, and the cache key being removed.
461	*
462	* If an active session includes any regular expression keys which match the
463	* key being removed from the "cacheData" dictionary then we clear this keys
464	* reference of being watched.
465	*/
466	void
467	_removeRegexWatchersBySession(const void key, void val, void *context)
468	{
469	CFStringRef sessionKey = key;
470	CFDictionaryRef info = val;
471	CFStringRef removedKey = context;
472	CFIndex oldKeyLen;
473	char *oldKeyStr;
474	CFArrayRef rKeys;
475	CFArrayRef rData;
476	CFIndex i;
477
478	if (info == NULL) {
479	/* if no dictionary for this session */
480	return;
481	}
482
483	rKeys = CFDictionaryGetValue(info, kSCDRegexKeys);
484	if (rKeys == NULL) {
485	/* if no regex keys for this session */
486	return;
487	}
488	rData = CFDictionaryGetValue(info, kSCDRegexData);
489
490	/* convert new key to C string */
491	oldKeyLen = CFStringGetLength(removedKey) + 1;
492	oldKeyStr = CFAllocatorAllocate(NULL, oldKeyLen, 0);
493	if (!CFStringGetCString(removedKey, oldKeyStr, oldKeyLen, kCFStringEncodingMacRoman)) {
494	SCDLog(LOG_DEBUG, CFSTR("CFStringGetCString: could not convert old key to C string"));
495	CFAllocatorDeallocate(NULL, oldKeyStr);
496	return;
497	}
498
499	/* iterate over the regex keys looking for an pattern which matches the old key */
500	for (i=0; i<CFArrayGetCount(rKeys); i++) {
501	CFDataRef regexData = CFArrayGetValueAtIndex(rData, i);
502	regex_t preg = (regex_t )CFDataGetBytePtr(regexData);
503	int reError;
504	char reErrBuf[256];
505	int reErrStrLen;
506	SInt32 sessionInt;
507	CFNumberRef sessionNum;
508
509	/* check if this key matches the regular expression */
510	reError = regexec(preg, oldKeyStr, 0, NULL, 0);
511	switch (reError) {
512	case 0 :
513	/* we've got a match, remove a reference */
514	sessionInt = CFStringGetIntValue(sessionKey);
515	sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &sessionInt);
516	_removeWatcher(sessionNum, removedKey);
517	CFRelease(sessionNum);
518	break;
519	case REG_NOMATCH :
520	/* no match */
521	break;
522	default :
523	reErrStrLen = regerror(reError, preg, reErrBuf, sizeof(reErrBuf));
524	SCDLog(LOG_DEBUG, CFSTR("regexec(): %s"), reErrBuf);
525	break;
526	}
527
528	}
529	CFAllocatorDeallocate(NULL, oldKeyStr);
530
531	return;
532	}