#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 = kAutomaticSearchPolicy;
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 );
#if AUGMENT_RECORDS
fXMLAugmentSearchKeyString = CFStringCreateWithCString( NULL, kXMLAugmentSearchKey, kCFStringEncodingUTF8 );
fXMLAugmentDirNodeNameKeyString = CFStringCreateWithCString( NULL, kXMLAugmentDirNodeNameKey, kCFStringEncodingUTF8 );
fXMLToBeAugmentedDirNodeNameKeyString = CFStringCreateWithCString( NULL, kXMLToBeAugmentedDirNodeNameKey, kCFStringEncodingUTF8 );
fXMLAugmentAttrListDictKeyString= CFStringCreateWithCString( NULL, kXMLAugmentAttrListDictKey, kCFStringEncodingUTF8 );
bAugmentSearch = false;
fAugmentDirNodeName = nil;
fAugmentAttrListDict = nil;
#endif
}
CConfigs::~CConfigs ( void )
{
DSCFRelease(fConfigDict);
DSFreeString(fSearchNodeConfigFileName);
DSFreeString(fSearchNodeConfigBackupFileName);
DSFreeString(fSearchNodeConfigCorruptedFileName);
DSCFRelease(fXMLSearchPathVersionKeyString);
DSCFRelease(fXMLSearchPolicyKeyString);
DSCFRelease(fXMLSearchPathArrayKeyString);
DSCFRelease(fXMLSearchDHCPLDAPString);
#if AUGMENT_RECORDS
DSCFRelease(fXMLAugmentSearchKeyString);
DSFreeString(fAugmentDirNodeName);
DSCFRelease(fXMLAugmentDirNodeNameKeyString);
DSCFRelease(fXMLToBeAugmentedDirNodeNameKeyString);
DSCFRelease(fXMLAugmentAttrListDictKeyString);
#endif
}
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:" );
DbgLog( 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:" );
DbgLog( 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);
#if AUGMENT_RECORDS
bAugmentSearch = GetAugmentSearch(configDict);
if (bAugmentSearch)
{
fAugmentDirNodeName = GetAugmentDirNodeName(configDict);
fToBeAugmentedDirNodeName = GetToBeAugmentedDirNodeName(configDict);
fAugmentAttrListDict = GetAugmentAttrListDict(configDict);
}
#endif
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:" );
DbgLog( 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 );
}
#if AUGMENT_RECORDS
void CConfigs:: UpdateAugmentDict( CFDictionaryRef inDict )
{
CFDictionarySetValue(fConfigDict, fXMLAugmentSearchKeyString, (CFBooleanRef)CFDictionaryGetValue( inDict, fXMLAugmentSearchKeyString ));
CFDictionarySetValue(fConfigDict, fXMLAugmentDirNodeNameKeyString, (CFBooleanRef)CFDictionaryGetValue( inDict, fXMLAugmentDirNodeNameKeyString ));
CFDictionarySetValue(fConfigDict, fXMLToBeAugmentedDirNodeNameKeyString, (CFBooleanRef)CFDictionaryGetValue( inDict, fXMLToBeAugmentedDirNodeNameKeyString ));
CFDictionarySetValue(fConfigDict, fXMLAugmentAttrListDictKeyString, (CFBooleanRef)CFDictionaryGetValue( inDict, fXMLAugmentAttrListDictKeyString ));
WriteConfig();
bAugmentSearch = GetAugmentSearch(inDict);
DSFreeString(fAugmentDirNodeName);
fAugmentDirNodeName = GetAugmentDirNodeName(inDict);
DSFreeString(fToBeAugmentedDirNodeName);
fToBeAugmentedDirNodeName = GetToBeAugmentedDirNodeName(inDict);
fAugmentAttrListDict = GetAugmentAttrListDict(fConfigDict);
}
#endif
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:" );
DbgLog( 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" ), kDSLDAPPrefsDirPath );
::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:" );
DbgLog( 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 );
}
#if AUGMENT_RECORDS
char *CConfigs::AugmentDirNodeName ( void )
{
return( fAugmentDirNodeName );
}
char *CConfigs::GetAugmentDirNodeName ( CFDictionaryRef configDict )
{
char *outName = nil;
CFStringRef cfStringRef = nil;
char *tmpBuff = nil;
CFIndex cfBuffSize = 1024;
if ( CFDictionaryContainsKey( configDict, fXMLAugmentDirNodeNameKeyString ) )
{
cfStringRef = (CFStringRef)CFDictionaryGetValue( configDict, fXMLAugmentDirNodeNameKeyString );
if ( cfStringRef != nil )
{
if ( CFGetTypeID( cfStringRef ) == CFStringGetTypeID() )
{
tmpBuff = new char[1024];
::memset(tmpBuff,0,1024);
if (CFStringGetCString(cfStringRef, tmpBuff, cfBuffSize, kCFStringEncodingUTF8 ))
{
outName = new char[1+strlen(tmpBuff)];
::strcpy(outName, tmpBuff);
}
delete( tmpBuff );
}
}
}
return( outName );
}
char *CConfigs::ToBeAugmentedDirNodeName ( void )
{
return( fToBeAugmentedDirNodeName );
}
char *CConfigs::GetToBeAugmentedDirNodeName ( CFDictionaryRef configDict )
{
char *outName = nil;
CFStringRef cfStringRef = nil;
char *tmpBuff = nil;
CFIndex cfBuffSize = 1024;
if ( CFDictionaryContainsKey( configDict, fXMLToBeAugmentedDirNodeNameKeyString ) )
{
cfStringRef = (CFStringRef)CFDictionaryGetValue( configDict, fXMLToBeAugmentedDirNodeNameKeyString );
if ( cfStringRef != nil )
{
if ( CFGetTypeID( cfStringRef ) == CFStringGetTypeID() )
{
tmpBuff = new char[1024];
::memset(tmpBuff,0,1024);
if (CFStringGetCString(cfStringRef, tmpBuff, cfBuffSize, kCFStringEncodingUTF8 ))
{
outName = new char[1+strlen(tmpBuff)];
::strcpy(outName, tmpBuff);
}
delete( tmpBuff );
}
}
}
return( outName );
}
bool CConfigs::AugmentSearch ( void )
{
return( bAugmentSearch );
}
bool CConfigs::GetAugmentSearch ( CFDictionaryRef configDict )
{
CFBooleanRef cfBool = false;
bool bAugSearch = false;
if ( CFDictionaryContainsKey( configDict, fXMLAugmentSearchKeyString ) )
{
cfBool = (CFBooleanRef)CFDictionaryGetValue( configDict, fXMLAugmentSearchKeyString );
if ( cfBool != nil )
{
bAugSearch = CFBooleanGetValue(cfBool);
}
}
return( bAugSearch );
} #endif
UInt32 CConfigs:: GetSearchPolicy ( CFDictionaryRef configDict )
{
UInt32 searchPolicy = kAutomaticSearchPolicy; 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 );
}
#if AUGMENT_RECORDS
CFDictionaryRef CConfigs::AugmentAttrListDict ( void )
{
return( fAugmentAttrListDict );
}
CFDictionaryRef CConfigs::GetAugmentAttrListDict ( CFDictionaryRef configDict )
{
CFDictionaryRef cfDictRef = nil;
if ( CFDictionaryContainsKey( configDict, fXMLAugmentAttrListDictKeyString ) )
{
cfDictRef = (CFDictionaryRef)CFDictionaryGetValue( configDict, fXMLAugmentAttrListDictKeyString );
}
return( cfDictRef );
} #endif
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 = false;
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 )
{
DSFreeString(inList->fNodeName);
inList->fOpened = false;
inList->fHasNeverOpened = true;
inList->fNodeReachable = 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 );
}