Re: MoreSCF fails horribly if the Automatic location is removed

• Subject: Re: MoreSCF fails horribly if the Automatic location is removed
• From: Quinn <email@hidden>
• Date: Fri, 29 Oct 2004 16:05:34 +0100
• Delivered-to: email@hidden
• Delivered-to: email@hidden

The Automatic location has the numerical setID 0. All other location have a GUID as setID.
When you delete the Automatic location you have no numerical setIDs an the MySCPreferencesPathCreateUniqueChild () and LargestNumericKey () routines doesn't work well.

I fixed the problem in two ways.

I've attached the diffs to the end of this email.

Share and Enjoy.
--
Quinn "The Eskimo!"                    <http://www.apple.com/developer/>
Apple Developer Technical Support * Networking, Communications, Hardware

Revision 1.11 2004/10/28 12:39:00 eskimo1
Completely reworked the SCPreferencesPathCreateUniqueChild workaround code to a) not use the workaround on 10.3, because the original bug has been fixed, and b) to correctly handle the case where there are no numeric keys in the child dictionary.

#include <CoreServices/CoreServices.h>

658c662,682
< #define WORKAROUND_RADAR_ID_3024328 1
---

static void LargestNumericKey(const void *key, const void *value, void *context)
// A CFDictionaryApplyFunction callback used by
// SCPreferencesPathCreateUniqueChildWorkaround to find the
// largest simple numeric key within a dictionary.
{
SInt32 * currentMax;
char keyStr[16];
char * endPtr;
SInt32 keyValue;
#pragma unused(value)
assert( CFGetTypeID(key) == CFStringGetTypeID() );
assert( context != NULL );
currentMax = (SInt32 *) context;
// Get the bytes out of the string. If keyStr is too small
// or key contains non-ASCII characters, we get false and
// ignore this key (it's obviously not a simple number).
if ( CFStringGetCString( (CFStringRef) key, keyStr, sizeof(keyStr), kCFStringEncodingASCII) ) {

660c684,710
< #if WORKAROUND_RADAR_ID_3024328
---

// Make sure that the first character of the keyStr
// is a digit, to avoid strtol's acceptance of
// leading whitespace and signs.
if ( keyStr[0] >= '0' && keyStr[0] <= '9' ) {
// Clean errno so that we can detect ERANGE
// errors coming back from strtol.
errno = 0;
keyValue = strtol(keyStr, &endPtr, 10);
// If we got no error and consumed all characters
// then we treat keyValue as valid.
if ( (errno == 0) && (*endPtr == 0) ) {
// If keyValue is greater than our current
// maximum, update the current maximum to keyValue.
if (keyValue > *currentMax) {
*currentMax = keyValue;
}
}
}
}
}

 static CFStringRef SCPreferencesPathCreateUniqueChildWorkaround(
     SCPreferencesRef	session,
     CFStringRef         prefix
 )
     // SCPreferencesPathCreateUniqueChildWorkaround is needed to
     // work around a bug in the Apple menu on 10.2 (see the comments
     // for SCPreferencesPathCreateUniqueChildCompat for a full
     // description of this).  The implementation was stolen
     // almost verbatim from the Mac OS X 10.1 source, a fact which
     // explains the difference in coding style between this code
     // and the rest of MoreSCF.
     //
     // The difference between this version and the original 10.1 version
     // is that this code finds the ID that's one larger than the largest ID.
     // The 10.1 code finds the first unused ID, which can results
     // in possible ID reuse.
 {
     int						status;
     CFDictionaryRef			value;
     CFStringRef				newPath		= NULL;
     Boolean					newValue	= FALSE;
     SInt32					maxValue;
     CFMutableDictionaryRef	newDict		= NULL;

// SCPreferencesPathGetValue follows links, whereas the
// real SCF implementation calls an internal routine,
// getPath, that doesn't follow links. However, this isn't
// a problem because in the MoreSCF usage of
// SCPreferencesPathCreateUniqueChildWorkaround we never give a
// prefix that might be a link.
//
// Also note that the internal implementation used a
// mutable dictionary for value; I changed this to a
// immutable dictionary because a) that's what
// SCPreferencesPathGetValue returns, and b) the code
// doesn't change the contents of the dictionary anyway.
// -- Quinn, 14 Aug 2002
value = SCPreferencesPathGetValue(session, prefix);
status = SCError();
switch (status) {
case kSCStatusOK :
break;
case kSCStatusNoKey :
value = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
newValue = TRUE;
break;
default :
return NULL;
}

     if (CFGetTypeID(value) != CFDictionaryGetTypeID()) {
         /* if specified path is not a dictionary */
         status = kSCStatusNoKey;
         goto error;
     }

     if (CFDictionaryContainsKey(value, kSCResvLink)) {
         /* the path is a link... */
         status = kSCStatusFailed;
         goto error;
     }

783,791c778,819
<		// Find the large numeric key in the dictionary.
<
<		maxValue = 0x80000000;
<		CFDictionaryApplyFunction(value, LargestNumericKey, &maxValue);
<
<		if (maxValue == 0x7FFFFFFF) {
<			status = kSCStatusFailed;
<			goto error;
<		}
---

// Find the large numeric key in the dictionary.
maxValue = 0x80000000;
CFDictionaryApplyFunction(value, LargestNumericKey, &maxValue);
// If maxValue is unchanged, there are /no/ simple numeric
// keys. Ergo, 0 is a perfectly valid value for the new key,
// so set maxValue to -1 (we'll add 1 to it as part of the
// call to CFStringCreateWithFormat below). This fixes a
// bug reported by a developer in <sonr://request/5810451>.

if (maxValue == 0x80000000) {
maxValue = -1;
}
if (maxValue == 0x7FFFFFFF) {
status = kSCStatusFailed;
goto error;
}

// Create a new path one larger than that.
newPath = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@/%i"),
prefix,
maxValue + 1);

     /* save the new dictionary */
     newDict = CFDictionaryCreateMutable(NULL,
                         0,
                         &kCFTypeDictionaryKeyCallBacks,
                         &kCFTypeDictionaryValueCallBacks);
     if (!SCPreferencesPathSetValue(session, newPath, newDict)) {
         goto error;
     }
     CFRelease(newDict);

     if (newValue)	CFRelease(value);
     return newPath;

error :

793c821,834
<		// Create a new path one large than that.
---

     if (newDict)	CFRelease(newDict);
     if (newValue)	CFRelease(value);
     if (newPath)	CFRelease(newPath);
     return NULL;
 }

static UInt32 MoreSCGetSystemVersion(void)
// An inline copy of MoreGetSystemVersion because I don't want to
// couple MoreSCF to MoreOSUtils.
{
static UInt32 sMoreSCSystemVersion = 0;
if (sMoreSCSystemVersion == 0) {
OSStatus junk;

junk = Gestalt(gestaltSystemVersion, (SInt32 *) &sMoreSCSystemVersion);
assert(junk == noErr);
}

	return sMoreSCSystemVersion;
 }

static CFStringRef SCPreferencesPathCreateUniqueChildCompat(
SCPreferencesRef session,
CFStringRef prefix
)
// A replacement for SCPreferencesPathCreateUniqueChild that
// does the right thing on all platforms. This deserves some
// explanation (-:
// SCPreferencesPathCreateUnique works by creating a child
// node with a unique name. There are two basic approaches
// to creating a unique name, small unique integers and GUIDs. // We're in the process of transitioning from the former to the
// latter. Here's how the transition has progressed.
//
// SCPreferencesPathCreateUniqueChild System Preferences
// OS Version Behaviour Behaviour
// ---------- ---------------------------------- ------------------
// 10.1 small integers small integers
// 10.2 GUIDs small integers
// 10.3 GUIDs GUIDs
//
// The problem with this is that Mac OS X 10.2 had a bug,
// <rdar://problem/3024328>, whereby, if you create a set with a
// GUID name (rather than a small integer), the Apple menu would not
// be able to switch to that set. That bug was fixed in Mac OS X 10.3,
// but its existence means that you can't call SCPreferencesPathCreateUniqueChild
// on all platforms. It's fine on 10.1 (where it produces small
// integers) and 10.3 (where it produces GUIDs, but the GUIDs don't upset
// the Apple menu), but it's problematic on 10.2.
//
// This routine is the solution to the problem described above. It calls
// SCPreferencesPathCreateUniqueChild on all platforms other than 10.2. // On 10.2 it calls SCPreferencesPathCreateUniqueChildCompatWorkaround,
// which contains our own implementation of SCPreferencesPathCreateUniqueChild
// that creates small integer values that are compatible with the
// 10.2 Apple menu.
//
// *phew*
{
CFStringRef result;
static const Boolean kForceUseOfWorkAround = true;
if ( ((MoreSCGetSystemVersion() &~ 0x0F) == 0x01020) || kForceUseOfWorkAround ) {
result = SCPreferencesPathCreateUniqueChildWorkaround(session, prefix);
} else {
result = SCPreferencesPathCreateUniqueChild(session, prefix);
}
return result;
}

*newSePath = SCPreferencesPathCreateUniqueChildCompat(gPrefsRef, sePrefix);

_______________________________________________
Do not post admin requests to the list. They will be ignored.
Macnetworkprog mailing list      (email@hidden)
Help/Unsubscribe/Update your Subscription:
http://lists.apple.com/mailman/options/macnetworkprog/email@hidden

• Prev by Date: Re: Receive UDP broadcast packets with OTRcvUData
• Next by Date: Re: Airport Configuration
• Previous by thread: USB-To-Ethernet Driver
• Next by thread: Orderly disconnecting using PowerPlant networking classes
• Index(es):
  • Date
  • Thread