#include "CConfigs.h"
#include "CLog.h"
#include <SystemConfiguration/SystemConfiguration.h>
#include <string.h> //used for strcpy, etc.
#include <stdlib.h> //used for malloc
#include <sys/stat.h> //used for mkdir and stat
#include "PrivateTypes.h"
#include "DSUtils.h"
CConfigs::CConfigs ( void )
{
fSearchPolicy = kNetInfoSearchPolicy;
fSearchNodeListLength = 0;
pSearchNodeList = nil;
fDirRef = 0;
fConfigDict = nil;
fSearchNodeConfigFileName = nil;
fSearchNodeConfigBackupFileName = nil;
fSearchNodeConfigCorruptedFileName = nil;
fXMLSearchPathVersionKeyString = CFStringCreateWithCString( NULL, kXMLSearchPathVersionKey, kCFStringEncodingUTF8 );
fXMLSearchPolicyKeyString = CFStringCreateWithCString( NULL, kXMLSearchPolicyKey, kCFStringEncodingUTF8 );
fXMLSearchPathArrayKeyString = CFStringCreateWithCString( NULL, kXMLSearchPathArrayKey, kCFStringEncodingUTF8 );
fXMLSearchDHCPLDAPString = CFStringCreateWithCString( NULL, kXMLSearchDHCPLDAP, kCFStringEncodingUTF8 );
}
CConfigs::~CConfigs ( void )
{
if (fConfigDict)
{
CFRelease(fConfigDict);
}
if (fSearchNodeConfigFileName != nil)
{
free(fSearchNodeConfigFileName);
fSearchNodeConfigFileName = nil;
}
if (fSearchNodeConfigBackupFileName != nil)
{
free(fSearchNodeConfigBackupFileName);
fSearchNodeConfigBackupFileName = nil;
}
if (fSearchNodeConfigCorruptedFileName != nil)
{
free(fSearchNodeConfigCorruptedFileName);
fSearchNodeConfigCorruptedFileName = nil;
}
CFRelease(fXMLSearchPathVersionKeyString);
CFRelease(fXMLSearchPolicyKeyString);
CFRelease(fXMLSearchPathArrayKeyString);
CFRelease(fXMLSearchDHCPLDAPString);
}
sInt32 CConfigs::Init ( const char *inSearchNodeConfigFilePrefix, uInt32 &outSearchPolicy )
{
sInt32 siResult = eDSNullParameter;
CFMutableArrayRef cfArrayRef = NULL;
CFIndex cfConfigCount = 0;
CFMutableStringRef cfSearchNode = NULL;
CFRange cfRangeVal;
struct stat statResult;
bool bUpdateConfig = false;
CFStringRef cfStringRef = NULL;
try
{
if (inSearchNodeConfigFilePrefix != nil)
{
fSearchNodeConfigFileName = (char *) ::calloc(::strlen(inSearchNodeConfigFilePrefix) + ::strlen(".plist") + 1 , sizeof(char) );
::strcpy(fSearchNodeConfigFileName, inSearchNodeConfigFilePrefix);
::strcat(fSearchNodeConfigFileName, ".plist");
fSearchNodeConfigBackupFileName = (char *) ::calloc(::strlen(inSearchNodeConfigFilePrefix) + ::strlen("Backup.plist") + 1 , sizeof(char) );
::strcpy(fSearchNodeConfigBackupFileName, inSearchNodeConfigFilePrefix);
::strcat(fSearchNodeConfigBackupFileName, "Backup.plist");
fSearchNodeConfigCorruptedFileName = (char *) ::calloc(::strlen(inSearchNodeConfigFilePrefix) + ::strlen("Corrupted.plist") + 1 , sizeof(char) );
::strcpy(fSearchNodeConfigCorruptedFileName, inSearchNodeConfigFilePrefix);
::strcat(fSearchNodeConfigCorruptedFileName, "Corrupted.plist");
siResult = eDSNoErr;
siResult = ConfigSearchPolicy();
if (siResult == eDSNoErr) {
outSearchPolicy = fSearchPolicy;
}
cfArrayRef = nil;
if ( CFDictionaryContainsKey( fConfigDict, fXMLSearchPathArrayKeyString ) )
{
cfArrayRef = (CFMutableArrayRef)CFDictionaryGetValue( fConfigDict, fXMLSearchPathArrayKeyString );
}
if (cfArrayRef != nil)
{
CFStringRef cfLDAPv2Prefix = CFStringCreateWithCString( NULL, "/LDAPv2/", kCFStringEncodingUTF8 );
CFStringRef cfLDAPv3Prefix = CFStringCreateWithCString( NULL, "/LDAPv3/", kCFStringEncodingUTF8 );
CFStringRef cfBSDOldPrefix = CFStringCreateWithCString( NULL, "/BSD Configuration Files/Local", kCFStringEncodingUTF8 );
CFStringRef cfBSDNewPrefix = CFStringCreateWithCString( NULL, "/BSD/local", kCFStringEncodingUTF8 );
cfConfigCount = ::CFArrayGetCount( cfArrayRef );
for (sInt32 iConfigIndex = 0; iConfigIndex < cfConfigCount; iConfigIndex++)
{
cfSearchNode = (CFMutableStringRef)::CFArrayGetValueAtIndex( cfArrayRef, iConfigIndex );
if ( cfSearchNode != nil )
{
if ( CFGetTypeID( cfSearchNode ) == CFStringGetTypeID() )
{
cfRangeVal = CFStringFind(cfSearchNode, cfLDAPv2Prefix, 0);
if (cfRangeVal.location == 0)
{
if (stat( "/System/Library/Frameworks/DirectoryService.framework/Resources/Plugins/LDAPv2.dsplug", &statResult ) != eDSNoErr)
{
cfSearchNode = CFStringCreateMutableCopy(NULL, 0, cfSearchNode);
CFStringReplace(cfSearchNode, cfRangeVal, cfLDAPv3Prefix);
CFArraySetValueAtIndex( cfArrayRef, iConfigIndex, cfSearchNode );
CFRelease(cfSearchNode);
bUpdateConfig = true;
}
continue;
}
cfRangeVal = CFStringFind(cfSearchNode, cfBSDOldPrefix, 0);
if (cfRangeVal.location == 0)
{
if (stat( "/System/Library/Frameworks/DirectoryService.framework/Resources/Plugins/BSD Configuration Files.dsplug", &statResult ) != eDSNoErr)
{
cfSearchNode = CFStringCreateMutableCopy(NULL, 0, cfSearchNode);
CFStringReplace(cfSearchNode, cfRangeVal, cfBSDNewPrefix);
CFArraySetValueAtIndex( cfArrayRef, iConfigIndex, cfSearchNode );
CFRelease(cfSearchNode);
bUpdateConfig = true;
}
continue;
}
}
}
}
CFRelease(cfLDAPv2Prefix);
cfLDAPv2Prefix = NULL;
CFRelease(cfLDAPv3Prefix);
cfLDAPv3Prefix = NULL;
CFRelease(cfBSDOldPrefix);
cfBSDOldPrefix = NULL;
CFRelease(cfBSDNewPrefix);
cfBSDNewPrefix = NULL;
}
if (bUpdateConfig)
{
cfStringRef = CFStringCreateWithCString( NULL, "Search Node PlugIn Version 1.7", kCFStringEncodingUTF8 );
CFDictionarySetValue( fConfigDict, fXMLSearchPathVersionKeyString, cfStringRef );
CFRelease(cfStringRef);
WriteConfig();
}
}
} catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sSearchList *CConfigs:: GetCustom ( void )
{
sSearchList *outList = nil;
sInt32 siResult = eDSNoErr;
pSearchNodeList = nil;
siResult = ConfigList();
if (siResult == eDSNoErr)
{
outList = pSearchNodeList;
}
return( outList );
}
sInt32 CConfigs:: ConfigSearchPolicy ( void )
{
sInt32 siResult = eDSNoErr;
sInt32 result = eDSNoErr;
CFStringRef errorString;
CFURLRef configFileURL = nil;
CFURLRef configFileCorruptedURL = nil;
CFDataRef xmlData = nil;
CFPropertyListRef configPropertyList = nil;
CFMutableDictionaryRef configDict = nil;
bool bFileOpSuccess = false;
bool bWroteFile = false;
bool bCorruptedFile = false;
char string[ PATH_MAX ];
char *configVersion = nil;
CFNumberRef aSearchPolicy;
struct stat statResult;
CFStringRef cfStringRef = nil;
sInt32 errorCode = 0;
int defaultSearchPolicy = 1;
CFStringRef sBase = nil;
CFStringRef sPath = nil;
CFStringRef sCorruptedPath = nil;
bool bUseXMLData = false;
char *filenameString = nil;
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "/Library/Preferences/DirectoryService/%s" ), fSearchNodeConfigFileName );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
DBGLOG( kLogPlugin, "Checking for Search Node XML config file:" );
DBGLOG1( kLogPlugin, "%s", string );
filenameString = strdup(string);
configFileURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sPath, kCFURLPOSIXPathStyle, false );
CFRelease( sPath ); sPath = nil;
result = ::stat( string, &statResult );
if (result != eDSNoErr)
{
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s" ), sBase, "/Preferences" );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
result = ::stat( string, &statResult );
if (result != eDSNoErr)
{
::mkdir( string , 0775 );
::chmod( string, 0775 ); }
CFRelease( sPath ); sPath = nil;
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s" ), sBase, "/Preferences/DirectoryService" );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
result = ::stat( string, &statResult );
if (result != eDSNoErr)
{
::mkdir( string , 0775 );
::chmod( string, 0775 ); }
CFRelease( sPath ); sPath = nil;
configDict = CFDictionaryCreateMutable( kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks );
cfStringRef = CFSTR("Search Node PlugIn Version 1.7");
CFDictionarySetValue( configDict, fXMLSearchPathVersionKeyString, cfStringRef );
aSearchPolicy = CFNumberCreate(NULL,kCFNumberIntType,&defaultSearchPolicy);
CFDictionarySetValue( configDict, fXMLSearchPolicyKeyString, aSearchPolicy ); if ( aSearchPolicy != nil )
{
CFRelease( aSearchPolicy );
aSearchPolicy = nil;
}
xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, configDict);
bUseXMLData = true;
bFileOpSuccess = CFURLWriteDataAndPropertiesToResource( configFileURL,
xmlData,
NULL,
&errorCode);
::chmod( filenameString, 0600 );
CFRelease(configDict);
configDict = nil;
} else {
bFileOpSuccess = CFURLCreateDataAndPropertiesFromResource( kCFAllocatorDefault,
configFileURL,
&xmlData, NULL,
NULL,
&errorCode);
if (!bFileOpSuccess) {
xmlData = nil;
}
else
{
bUseXMLData = true;
}
}
if (xmlData != nil)
{
configPropertyList = CFPropertyListCreateFromXMLData( kCFAllocatorDefault,
xmlData,
kCFPropertyListMutableContainers, &errorString);
if (configPropertyList != nil )
{
DBGLOG( kLogPlugin, "Have read Search Node XML config file:" );
DBGLOG1( kLogPlugin, "%s", string );
if ( CFDictionaryGetTypeID() == CFGetTypeID( configPropertyList ) )
{
configDict = (CFMutableDictionaryRef) configPropertyList;
}
if (configDict != nil)
{
configVersion = GetVersion(configDict);
if (configVersion == nil ) {
CFRelease(configDict);
configDict = nil;
configPropertyList = nil;
}
else
{
fSearchPolicy = GetSearchPolicy(configDict);
fConfigDict = configDict;
free(configVersion);
configVersion = nil;
} } } if ( configPropertyList == nil) {
DBGLOG( kLogPlugin, "Search Node XML config file is corrupted" );
DBGLOG( kLogPlugin, "Using default NetInfo Search Policy" );
bCorruptedFile = true;
sCorruptedPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s/%s" ), sBase, "/Preferences/DirectoryService", fSearchNodeConfigCorruptedFileName );
configFileCorruptedURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sCorruptedPath, kCFURLPOSIXPathStyle, false );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sCorruptedPath, string, sizeof( string ), kCFStringEncodingUTF8 );
CFRelease( sCorruptedPath ); sCorruptedPath = nil;
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileCorruptedURL,
xmlData,
NULL,
&errorCode);
::chmod( string, 0600 );
} CFRelease(xmlData); xmlData = nil;
}
else
{
DBGLOG( kLogPlugin, "Search Node XML config file is not readable" );
DBGLOG( kLogPlugin, "Using default NetInfo Search Policy" );
bCorruptedFile = true;
}
if (bCorruptedFile)
{
configDict = CFDictionaryCreateMutable( kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks );
cfStringRef = CFSTR("Search Node PlugIn Version 1.7");
CFDictionarySetValue( configDict, fXMLSearchPathVersionKeyString, cfStringRef );
aSearchPolicy = CFNumberCreate(NULL,kCFNumberIntType,&defaultSearchPolicy);
CFDictionarySetValue( configDict, fXMLSearchPolicyKeyString, aSearchPolicy ); if ( aSearchPolicy != nil )
{
CFRelease( aSearchPolicy );
aSearchPolicy = nil;
}
xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, configDict);
CFRelease(configDict);
if (sPath != nil)
{
CFRelease(sPath);
}
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "/Library/Preferences/DirectoryService/%s" ), fSearchNodeConfigFileName );
if (configFileURL != nil)
{
CFRelease(configFileURL);
}
configFileURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sPath, kCFURLPOSIXPathStyle, false );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileURL,
xmlData,
NULL,
&errorCode);
::chmod( string, 0600 );
if (xmlData != nil)
{
configPropertyList = CFPropertyListCreateFromXMLData( kCFAllocatorDefault,
xmlData,
kCFPropertyListMutableContainers, &errorString);
if ( configPropertyList != nil )
{
DBGLOG( kLogPlugin, "Using Newly Replaced Search Node XML config file:" );
DBGLOG1( kLogPlugin, "%s", string );
if ( CFDictionaryGetTypeID() == CFGetTypeID( configPropertyList ) )
{
configDict = (CFMutableDictionaryRef) configPropertyList;
}
if (configDict != nil)
{
configVersion = GetVersion(configDict);
if (configVersion == nil ) {
CFRelease(configDict);
configDict = nil;
configPropertyList = nil;
}
else
{
fSearchPolicy = GetSearchPolicy(configDict);
fConfigDict = configDict;
free(configVersion);
configVersion = nil;
} } } CFRelease(xmlData);
xmlData = nil;
} }
if (configFileURL != nil)
{
CFRelease(configFileURL); configFileURL = nil;
}
if (configFileCorruptedURL != nil)
{
CFRelease(configFileCorruptedURL); configFileCorruptedURL = nil;
}
if (sBase != nil)
{
CFRelease(sBase); sBase = nil;
}
if (sPath != nil)
{
CFRelease(sPath);
sPath = nil;
}
if (filenameString != nil)
{
free(filenameString);
filenameString = nil;
}
return( siResult );
}
sInt32 CConfigs:: WriteConfig ( void )
{
sInt32 siResult = eDSNoErr;
CFURLRef configFileURL;
CFURLRef configFileBackupURL;
CFDataRef xmlData;
bool bWroteFile = false;
bool bReadFile = false;
char string[ PATH_MAX ];
struct stat statResult;
sInt32 errorCode = 0;
char *filenameString = nil;
CFStringRef sPath;
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "/Library/Preferences/DirectoryService/%s" ), fSearchNodeConfigFileName );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
DBGLOG( kLogPlugin, "Checking for Search Node XML config file:" );
DBGLOG1( kLogPlugin, "%s", string );
filenameString = strdup(string);
configFileURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sPath, kCFURLPOSIXPathStyle, false );
CFRelease( sPath ); sPath = nil;
siResult = ::stat( string, &statResult );
if (siResult == eDSNoErr)
{
CFStringRef sBackupPath;
sBackupPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "/Library/Preferences/DirectoryService/%s" ), fSearchNodeConfigBackupFileName );
configFileBackupURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sBackupPath, kCFURLPOSIXPathStyle, false );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sBackupPath, string, sizeof( string ), kCFStringEncodingUTF8 );
CFRelease( sBackupPath ); sBackupPath = nil;
bReadFile = CFURLCreateDataAndPropertiesFromResource(
kCFAllocatorDefault,
configFileURL,
&xmlData, NULL,
NULL,
&siResult);
if (bReadFile)
{
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileBackupURL,
xmlData,
NULL,
&errorCode);
::chmod( string, 0600 );
CFRelease(xmlData);
}
if (configFileBackupURL != nil)
{
CFRelease(configFileBackupURL);
configFileBackupURL = nil;
}
}
if (siResult != eDSNoErr)
{
siResult = eDSNoErr;
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%s" ), "/Library/Preferences" );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
siResult = ::stat( string, &statResult );
if (siResult != eDSNoErr)
{
siResult = eDSNoErr;
::mkdir( string , 0775 );
::chmod( string, 0775 ); }
CFRelease( sPath ); sPath = nil;
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%s" ), "/Library/Preferences/DirectoryService" );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingUTF8 );
siResult = ::stat( string, &statResult );
if (siResult != eDSNoErr)
{
siResult = eDSNoErr;
::mkdir( string , 0775 );
::chmod( string, 0775 ); }
CFRelease( sPath ); sPath = nil;
}
if (fConfigDict)
{
xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, fConfigDict);
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileURL,
xmlData,
NULL,
&errorCode);
::chmod( filenameString, 0600 );
CFRelease(xmlData);
}
if (configFileURL != nil)
{
CFRelease(configFileURL); configFileURL = nil;
}
if (bWroteFile)
{
DBGLOG( kLogPlugin, "Have written the Search Node XML config file:" );
DBGLOG1( kLogPlugin, "%s", string );
siResult = eDSNoErr;
}
else
{
DBGLOG( kLogPlugin, "Search Node XML config file has NOT been written" );
DBGLOG( kLogPlugin, "Update to Custom Search Path Node List in Config File Failed" );
siResult = eDSPlugInConfigFileError;
}
if (filenameString != nil)
{
free(filenameString);
filenameString = nil;
}
return( siResult );
}
sInt32 CConfigs:: ConfigList ( void )
{
sInt32 siResult = eDSNoErr;
sSearchList *pSearchNode = nil;
sSearchList *pTailSearchNode = nil;
CFStringRef cfSearchNode;
CFArrayRef cfArrayRef = nil;
CFIndex cfConfigCount = 0;
char *tmpBuff = nil;
CFIndex cfBuffSize = 1024;
char *outSearchNode = nil;
try
{
cfArrayRef = nil;
cfArrayRef = GetListArray(fConfigDict);
if (cfArrayRef != nil)
{
cfConfigCount = ::CFArrayGetCount( cfArrayRef );
for (sInt32 iConfigIndex = 0; iConfigIndex < cfConfigCount; iConfigIndex++)
{
cfSearchNode = (CFStringRef)::CFArrayGetValueAtIndex( cfArrayRef, iConfigIndex );
if ( cfSearchNode != nil )
{
if ( CFGetTypeID( cfSearchNode ) == CFStringGetTypeID() )
{
tmpBuff = new char[1024];
::memset(tmpBuff,0,1024);
if (CFStringGetCString(cfSearchNode, tmpBuff, cfBuffSize, kCFStringEncodingUTF8))
{
outSearchNode = new char[1+strlen(tmpBuff)];
::strcpy(outSearchNode, tmpBuff);
pSearchNode = MakeListData(outSearchNode);
delete(outSearchNode);
if (pSearchNodeList == nil)
{
pSearchNodeList = pSearchNode;
pTailSearchNode = pSearchNodeList;
}
else
{
while(pTailSearchNode->fNext != nil)
{
pTailSearchNode = pTailSearchNode->fNext;
}
pTailSearchNode->fNext = pSearchNode;
}
pSearchNode = nil;
}
delete( tmpBuff );
}
}
}
}
} catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
char *CConfigs::GetVersion ( CFDictionaryRef configDict )
{
char *outVersion = nil;
CFStringRef cfStringRef = nil;
char *tmpBuff = nil;
CFIndex cfBuffSize = 1024;
if ( CFDictionaryContainsKey( configDict, fXMLSearchPathVersionKeyString ) )
{
cfStringRef = (CFStringRef)CFDictionaryGetValue( configDict, fXMLSearchPathVersionKeyString );
if ( cfStringRef != nil )
{
if ( CFGetTypeID( cfStringRef ) == CFStringGetTypeID() )
{
tmpBuff = new char[1024];
::memset(tmpBuff,0,1024);
if (CFStringGetCString(cfStringRef, tmpBuff, cfBuffSize, kCFStringEncodingUTF8 ))
{
outVersion = new char[1+strlen(tmpBuff)];
::strcpy(outVersion, tmpBuff);
}
delete( tmpBuff );
}
}
}
return( outVersion );
}
uInt32 CConfigs:: GetSearchPolicy ( CFDictionaryRef configDict )
{
uInt32 searchPolicy = kNetInfoSearchPolicy; CFNumberRef cfNumber = 0;
unsigned char cfNumBool = false;
if ( CFDictionaryContainsKey( configDict, fXMLSearchPolicyKeyString ) )
{
cfNumber = (CFNumberRef)CFDictionaryGetValue( configDict, fXMLSearchPolicyKeyString );
if ( cfNumber != nil )
{
cfNumBool = CFNumberGetValue(cfNumber, kCFNumberIntType, &searchPolicy);
}
}
return( searchPolicy );
}
CFArrayRef CConfigs:: GetListArray ( CFDictionaryRef configDict )
{
CFArrayRef cfArrayRef = nil;
if ( CFDictionaryContainsKey( configDict, fXMLSearchPathArrayKeyString ) )
{
cfArrayRef = (CFArrayRef)CFDictionaryGetValue( configDict, fXMLSearchPathArrayKeyString );
}
return( cfArrayRef );
}
CFDictionaryRef CConfigs::GetDHCPLDAPDictionary ( )
{
CFDictionaryRef cfDict = 0;
if (fConfigDict)
{
if ( CFDictionaryContainsKey( fConfigDict, fXMLSearchDHCPLDAPString ) )
{
cfDict = (CFDictionaryRef)CFDictionaryGetValue( fConfigDict, fXMLSearchDHCPLDAPString );
}
}
return( cfDict );
}
bool CConfigs::IsDHCPLDAPEnabled ( )
{
bool dhcpLDAPEnabled = true;
CFDictionaryRef cfDict = 0;
CFBooleanRef cfBool = 0;
SCDynamicStoreRef sysConfigRef = 0;
CFStringRef currentLocation = 0;
if (fConfigDict)
{
sysConfigRef = SCDynamicStoreCreate(NULL,CFSTR("DirectoryService Search Node"),NULL,NULL);
if (sysConfigRef != 0)
{
currentLocation = SCDynamicStoreCopyLocation(sysConfigRef);
if (currentLocation != 0)
{
if ( CFDictionaryContainsKey( fConfigDict, fXMLSearchDHCPLDAPString ) )
{
cfDict = (CFDictionaryRef)CFDictionaryGetValue( fConfigDict, fXMLSearchDHCPLDAPString );
if ( cfDict != 0 && CFGetTypeID(cfDict) == CFDictionaryGetTypeID() )
{
dhcpLDAPEnabled = false;
cfBool = (CFBooleanRef)CFDictionaryGetValue( cfDict, currentLocation );
if ( cfBool != 0 && CFGetTypeID(cfBool) == CFBooleanGetTypeID() )
{
dhcpLDAPEnabled = CFBooleanGetValue(cfBool);
}
}
}
CFRelease(currentLocation);
}
CFRelease(sysConfigRef);
}
}
return( dhcpLDAPEnabled );
}
void CConfigs::SetDHCPLDAPDictionary ( CFDictionaryRef dhcpLDAPdict )
{
if (fConfigDict)
{
CFDictionarySetValue(fConfigDict, fXMLSearchDHCPLDAPString, dhcpLDAPdict);
}
}
sInt32 CConfigs:: SetSearchPolicy ( uInt32 inSearchPolicy )
{
CFNumberRef cfNumber = 0;
sInt32 siResult = eDSNoErr;
fSearchPolicy = inSearchPolicy;
if (fConfigDict)
{
cfNumber = CFNumberCreate(NULL,kCFNumberIntType,&inSearchPolicy);
if ( CFDictionaryContainsKey( fConfigDict, fXMLSearchPolicyKeyString ) )
{
CFDictionaryReplaceValue(fConfigDict, fXMLSearchPolicyKeyString, cfNumber);
}
else
{
CFDictionarySetValue(fConfigDict, fXMLSearchPolicyKeyString, cfNumber);
}
if (cfNumber != 0)
{
CFRelease(cfNumber);
cfNumber = 0;
}
}
return( siResult );
}
sInt32 CConfigs:: SetListArray ( CFMutableArrayRef inCSPArray )
{
sInt32 siResult = eDSNoErr;
if (fConfigDict)
{
if ( CFDictionaryContainsKey( fConfigDict, fXMLSearchPathArrayKeyString ) )
{
CFDictionaryReplaceValue(fConfigDict, fXMLSearchPathArrayKeyString, (const void *) inCSPArray);
}
else
{
CFDictionarySetValue(fConfigDict, fXMLSearchPathArrayKeyString, (const void *) inCSPArray);
}
}
return( siResult );
}
sSearchList *CConfigs::MakeListData ( char *inNodeName )
{
sInt32 siResult = eDSNoErr;
sSearchList *listOut = nil;
try
{
listOut = (sSearchList *) ::calloc( 1, sizeof(sSearchList));
if ( listOut != nil )
{
siResult = CleanListData(listOut);
listOut->fNodeName = new char[1+::strlen(inNodeName)];
::strcpy(listOut->fNodeName,inNodeName);
listOut->fDataList = ::dsBuildFromPathPriv( listOut->fNodeName, "/" );
}
}
catch( sInt32 err )
{
siResult = err;
}
return( listOut );
}
sInt32 CConfigs::CleanListData ( sSearchList *inList )
{
sInt32 siResult = eDSNoErr;
if ( inList != nil )
{
if (inList->fNodeName != nil)
{
delete ( inList->fNodeName );
}
inList->fOpened = false;
inList->fPreviousOpenFailed = false;
if (inList->fNodeRef != 0)
{
::dsCloseDirNode(inList->fNodeRef); inList->fNodeRef = 0;
}
inList->fNext = nil;
if (inList->fDataList != nil)
{
dsDataListDeallocatePriv ( inList->fDataList );
free( inList->fDataList );
inList->fDataList = nil;
}
}
return( siResult );
}