#include "CConfigs.h"
#include "CSharedData.h"
#include <CoreFoundation/CFPriv.h> // used for ::CFCopySearchPathForDirectoriesInDomains
#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"
#define kAllocatorDefault NULL
CConfigs::CConfigs ( void )
{
fSearchPolicy = kNetInfoSearchPolicy;
fSearchNodeListLength = 0;
pSearchNodeList = nil;
fDirRef = 0;
fConfigDict = nil;
fSearchNodeConfigFileName = nil;
fSearchNodeConfigBackupFileName = nil;
fSearchNodeConfigCorruptedFileName = nil;
}
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;
}
}
sInt32 CConfigs::Init ( const char *inSearchNodeConfigFilePrefix, uInt32 &outSearchPolicy )
{
sInt32 siResult = eDSNullParameter;
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;
}
}
} 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;
register CFIndex iPath = 0;
CFArrayRef aPaths = nil;
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;
aPaths = ::CFCopySearchPathForDirectoriesInDomains( kCFLibraryDirectory, (CFSearchPathDomainMask)kCFLocalDomainMask, true );
if ( aPaths != nil )
{
iPath = ::CFArrayGetCount( aPaths );
if ( iPath != 0 )
{
while (( iPath-- ) && (!bUseXMLData))
{
configFileURL = (CFURLRef)::CFArrayGetValueAtIndex( aPaths, iPath );
if (sBase != nil)
{
CFRelease(sBase); sBase = nil;
}
sBase = ::CFURLCopyFileSystemPath( configFileURL, kCFURLPOSIXPathStyle );
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s/%s" ), sBase, "/Preferences/DirectoryService", fSearchNodeConfigFileName );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingMacRoman );
CShared::LogIt( 0x0F, (char *)"Checking for Search Node XML config file:" );
CShared::LogIt( 0x0F, 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 ), kCFStringEncodingMacRoman );
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 ), kCFStringEncodingMacRoman );
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.2");
CFDictionarySetValue( configDict, CFSTR( kXMLSearchPathVersionKey ), cfStringRef );
aSearchPolicy = CFNumberCreate(NULL,kCFNumberIntType,&defaultSearchPolicy);
CFDictionarySetValue( configDict, CFSTR( kXMLSearchPolicyKey ), aSearchPolicy ); if ( aSearchPolicy != nil )
{
CFRelease( aSearchPolicy );
aSearchPolicy = nil;
}
xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, configDict);
bUseXMLData = true;
bFileOpSuccess = CFURLWriteDataAndPropertiesToResource( configFileURL,
xmlData,
NULL,
&errorCode);
CFRelease(configDict);
configDict = nil;
} else {
bFileOpSuccess = CFURLCreateDataAndPropertiesFromResource( kAllocatorDefault,
configFileURL,
&xmlData, NULL,
NULL,
&errorCode);
if (!bFileOpSuccess) {
xmlData = nil;
}
else
{
bUseXMLData = true;
}
}
} } CFRelease(aPaths); }
if (xmlData != nil)
{
configPropertyList = CFPropertyListCreateFromXMLData( kAllocatorDefault,
xmlData,
kCFPropertyListMutableContainers, &errorString);
if (configPropertyList != nil )
{
CShared::LogIt( 0x0F, (char *)"Have read Search Node XML config file:" );
CShared::LogIt( 0x0F, 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) {
CShared::LogIt( 0x0F, (char *)"Search Node XML config file is corrupted" );
CShared::LogIt( 0x0F, (char *)"Using default NetInfo Search Policy" );
bCorruptedFile = true;
sCorruptedPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s/%s" ), sBase, "/Preferences/DirectoryService", fSearchNodeConfigCorruptedFileName );
configFileCorruptedURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sCorruptedPath, kCFURLPOSIXPathStyle, false );
CFRelease( sCorruptedPath ); sCorruptedPath = nil;
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileCorruptedURL,
xmlData,
NULL,
&errorCode);
} CFRelease(xmlData); xmlData = nil;
}
else
{
CShared::LogIt( 0x0F, (char *)"Search Node XML config file is not readable" );
CShared::LogIt( 0x0F, (char *)"Using default NetInfo Search Policy" );
bCorruptedFile = true;
}
if (bCorruptedFile)
{
configDict = CFDictionaryCreateMutable( kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks );
cfStringRef = CFSTR("Search Node PlugIn Version 1.2");
CFDictionarySetValue( configDict, CFSTR( kXMLSearchPathVersionKey ), cfStringRef );
aSearchPolicy = CFNumberCreate(NULL,kCFNumberIntType,&defaultSearchPolicy);
CFDictionarySetValue( configDict, CFSTR( kXMLSearchPolicyKey ), aSearchPolicy ); if ( aSearchPolicy != nil )
{
CFRelease( aSearchPolicy );
aSearchPolicy = nil;
}
xmlData = CFPropertyListCreateXMLData( kCFAllocatorDefault, configDict);
CFRelease(configDict);
if (sPath != nil)
{
CFRelease(sPath);
}
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%s/%s" ), sBase, "/Library/Preferences/DirectoryService", fSearchNodeConfigFileName );
if (configFileURL != nil)
{
CFRelease(configFileURL);
}
configFileURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sPath, kCFURLPOSIXPathStyle, false );
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileURL,
xmlData,
NULL,
&errorCode);
if (xmlData != nil)
{
configPropertyList = CFPropertyListCreateFromXMLData( kAllocatorDefault,
xmlData,
kCFPropertyListMutableContainers, &errorString);
if ( configPropertyList != nil )
{
CShared::LogIt( 0x0F, (char *)"Using Newly Replaced Search Node XML config file:" );
CShared::LogIt( 0x0F, 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;
}
return( siResult );
}
sInt32 CConfigs:: WriteConfig ( void )
{
sInt32 siResult = eDSNoErr;
CFURLRef configFileURL;
CFURLRef configFileBackupURL;
CFDataRef xmlData;
bool bWroteFile = false;
bool bReadFile = false;
register CFIndex iPath;
CFArrayRef aPaths = nil;
char string[ PATH_MAX ];
struct stat statResult;
sInt32 errorCode = 0;
try
{
aPaths = ::CFCopySearchPathForDirectoriesInDomains( kCFLibraryDirectory, (CFSearchPathDomainMask)kCFLocalDomainMask, true );
if ( aPaths != nil )
{
iPath = ::CFArrayGetCount( aPaths );
if ( iPath != 0 )
{
while (( iPath-- ) && (!bWroteFile))
{
configFileURL = (CFURLRef)::CFArrayGetValueAtIndex( aPaths, iPath );
CFStringRef sBase, sPath;
sBase = ::CFURLCopyFileSystemPath( configFileURL, kCFURLPOSIXPathStyle );
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s/%s" ), sBase, "/Preferences/DirectoryService", fSearchNodeConfigFileName );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingMacRoman );
CShared::LogIt( 0x0F, (char *)"Checking for Search Node XML config file:" );
CShared::LogIt( 0x0F, 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( "%@/%s/%s" ), sBase, "/Preferences/DirectoryService", fSearchNodeConfigBackupFileName );
configFileBackupURL = ::CFURLCreateWithFileSystemPath( kCFAllocatorDefault, sBackupPath, kCFURLPOSIXPathStyle, false );
CFRelease( sBackupPath ); sBackupPath = nil;
bReadFile = CFURLCreateDataAndPropertiesFromResource(
kAllocatorDefault,
configFileURL,
&xmlData, NULL,
NULL,
&siResult);
if (bReadFile)
{
bWroteFile = CFURLWriteDataAndPropertiesToResource( configFileBackupURL,
xmlData,
NULL,
&errorCode);
CFRelease(xmlData);
}
if (configFileBackupURL != nil)
{
CFRelease(configFileBackupURL);
configFileBackupURL = nil;
}
}
if (siResult != eDSNoErr)
{
siResult = eDSNoErr;
sPath = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@/%s" ), sBase, "/Preferences" );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingMacRoman );
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" ), sBase, "/Preferences/DirectoryService" );
::memset(string,0,PATH_MAX);
::CFStringGetCString( sPath, string, sizeof( string ), kCFStringEncodingMacRoman );
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);
CFRelease(xmlData);
}
CFRelease( sBase ); sBase = nil;
if (configFileURL != nil)
{
CFRelease(configFileURL); configFileURL = nil;
}
} }
CFRelease(aPaths); }
if (bWroteFile)
{
CShared::LogIt( 0x0F, (char *)"Have written the Search Node XML config file:" );
CShared::LogIt( 0x0F, string );
siResult = eDSNoErr;
}
else
{
CShared::LogIt( 0x0F, (char *)"Search Node XML config file has NOT been written" );
CShared::LogIt( 0x0F, (char *)"Update to Custom Search Path Node List in Config File Failed" );
siResult = eDSPlugInConfigFileError;
}
} catch( sInt32 err )
{
siResult = err;
}
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, CFSTR( kXMLSearchPathVersionKey ) ) )
{
cfStringRef = (CFStringRef)CFDictionaryGetValue( configDict, CFSTR( kXMLSearchPathVersionKey ) );
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, CFSTR( kXMLSearchPolicyKey ) ) )
{
cfNumber = (CFNumberRef)CFDictionaryGetValue( configDict, CFSTR( kXMLSearchPolicyKey ) );
if ( cfNumber != nil )
{
cfNumBool = CFNumberGetValue(cfNumber, kCFNumberIntType, &searchPolicy);
}
}
return( searchPolicy );
}
CFArrayRef CConfigs:: GetListArray ( CFDictionaryRef configDict )
{
CFArrayRef cfArrayRef = nil;
if ( CFDictionaryContainsKey( configDict, CFSTR( kXMLSearchPathArrayKey ) ) )
{
cfArrayRef = (CFArrayRef)CFDictionaryGetValue( configDict, CFSTR( kXMLSearchPathArrayKey ) );
}
return( cfArrayRef );
}
CFDictionaryRef CConfigs::GetDHCPLDAPDictionary ( )
{
CFDictionaryRef cfDict = 0;
if (fConfigDict)
{
if ( CFDictionaryContainsKey( fConfigDict, CFSTR( kXMLSearchDHCPLDAP ) ) )
{
cfDict = (CFDictionaryRef)CFDictionaryGetValue( fConfigDict, CFSTR( kXMLSearchDHCPLDAP ) );
}
}
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, CFSTR( kXMLSearchDHCPLDAP ) ) )
{
cfDict = (CFDictionaryRef)CFDictionaryGetValue( fConfigDict, CFSTR( kXMLSearchDHCPLDAP ) );
if ( cfDict != 0 && CFGetTypeID(cfDict) == CFDictionaryGetTypeID() )
{
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, CFSTR( kXMLSearchDHCPLDAP ), dhcpLDAPdict);
}
}
sInt32 CConfigs:: SetSearchPolicy ( uInt32 inSearchPolicy )
{
CFNumberRef cfNumber = 0;
sInt32 siResult = eDSNoErr;
fSearchPolicy = inSearchPolicy;
if (fConfigDict)
{
cfNumber = CFNumberCreate(NULL,kCFNumberIntType,&inSearchPolicy);
if ( CFDictionaryContainsKey( fConfigDict, CFSTR( kXMLSearchPolicyKey ) ) )
{
CFDictionaryReplaceValue(fConfigDict, CFSTR( kXMLSearchPolicyKey ), cfNumber);
}
else
{
CFDictionarySetValue(fConfigDict, CFSTR( kXMLSearchPolicyKey ), cfNumber);
}
if (cfNumber != 0)
{
CFRelease(cfNumber);
cfNumber = 0;
}
}
return( siResult );
}
sInt32 CConfigs:: SetListArray ( CFMutableArrayRef inCSPArray )
{
sInt32 siResult = eDSNoErr;
if (fConfigDict)
{
if ( CFDictionaryContainsKey( fConfigDict, CFSTR( kXMLSearchPathArrayKey ) ) )
{
CFDictionaryReplaceValue(fConfigDict, CFSTR( kXMLSearchPathArrayKey ), (const void *) inCSPArray);
}
else
{
CFDictionarySetValue(fConfigDict, CFSTR( kXMLSearchPathArrayKey ), (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;
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 );
}