CConfigurePlugin.cpp [plain text]
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> //used for mkdir and stat
#include <CoreFoundation/CoreFoundation.h>
#include <SystemConfiguration/SystemConfiguration.h>
#include <Security/Authorization.h>
#include "DirServices.h"
#include "DirServicesUtils.h"
#include "DirServicesConst.h"
#include "SharedConsts.h"
#include "PrivateTypes.h"
#include "DSUtils.h"
#include "COSUtils.h"
#include "CAttributeList.h"
#include "CPlugInRef.h"
#include "CBuff.h"
#include "CDataBuff.h"
#include "CLog.h"
#include "CConfigurePlugin.h"
#include "ServerModuleLib.h"
#include "PluginData.h"
#include "DSCThread.h"
#include "DSEventSemaphore.h"
#include "CContinue.h"
#include "CPlugInList.h"
#include "ServerControl.h"
#include "CPluginConfig.h"
typedef struct {
uInt32 fRecNameIndex;
uInt32 fRecTypeIndex;
uInt32 fAllRecIndex;
uInt32 fAttrIndex;
} sConfigContinueData;
static CPlugInRef *gConfigNodeRef = nil;
static CContinue *gConfigContinue = nil;
static DSEventSemaphore *gKickConfigRequests = nil;
extern CPlugInList *gPlugins;
extern CPluginConfig *gPluginConfig;
#define kDSConfigPluginsRecType "dsConfigType::Plugins"
#define kDSConfigRecordsType "dsConfigType::RecordTypes"
#define kDSConfigAttributesType "dsConfigType::AttributeTypes"
#define kDSConfigRecordsAll "dsConfigType::GetAllRecords"
#define kDSConfigAttrVersion "dsConfigAttrType::Version"
#define kDSConfigAttrState "dsConfigAttrType::State"
#define kDSConfigAttrConfigAvail "dsConfigAttrType::ConfigAvailable"
#define kDSConfigAttrConfigFile "dsConfigAttrType::ConfigFile"
#define kDSConfigAttrPlugInIndex "dsConfigAttrType::PlugInIndex"
#define kAttrTypeConsts 118
static const char *sAttrTypes[ kAttrTypeConsts ] =
{
kDS1AttrAdminLimits,
kDS1AttrAliasData,
kDS1AttrAlternateDatastoreLocation,
kDS1AttrAuthenticationHint,
kDS1AttrCapabilities,
kDS1AttrChange,
kDS1AttrComment,
kDS1AttrDataStamp,
kDS1AttrDistinguishedName,
kDS1AttrDNSDomain,
kDS1AttrDNSNameServer,
kDS1AttrENetAddress,
kDS1AttrExpire,
kDS1AttrFirstName,
kDS1AttrGeneratedUID,
kDS1AttrHomeDirectoryQuota,
kDS1AttrHomeDirectorySoftQuota,
kDS1AttrHomeLocOwner,
kDS1AttrInternetAlias,
kDS1AttrKDCConfigData,
kDS1AttrLastName,
kDS1AttrLocation,
kDS1AttrMCXFlags,
kDS1AttrMailAttribute,
kDS1AttrMiddleName,
kDS1AttrNFSHomeDirectory,
kDS1AttrNote,
kDS1AttrPassword,
kDS1AttrPasswordPolicyOptions,
kDS1AttrPasswordServerList,
kDS1AttrPasswordServerLocation,
kDS1AttrPicture,
kDS1AttrPort,
kDS1AttrPresetUserIsAdmin,
kDS1AttrPrimaryGroupID,
kDS1AttrPrinter1284DeviceID,
kDS1AttrPrinterLPRHost,
kDS1AttrPrinterLPRQueue,
kDS1AttrPrinterMakeAndModel,
kDS1AttrPrinterType,
kDS1AttrPrinterURI,
kDSNAttrPrinterXRISupported,
kDS1AttrPrintServiceInfoText,
kDS1AttrPrintServiceInfoXML,
kDS1AttrPrintServiceUserData,
kDS1AttrRealUserID,
kDS1AttrRelativeDNPrefix,
kDS1AttrSMBAcctFlags,
kDS1AttrSMBGroupRID,
kDS1AttrSMBHome,
kDS1AttrSMBHomeDrive,
kDS1AttrSMBKickoffTime,
kDS1AttrSMBLogoffTime,
kDS1AttrSMBLogonTime,
kDS1AttrSMBPWDLastSet,
kDS1AttrSMBProfilePath,
kDS1AttrSMBRID,
kDS1AttrSMBScriptPath,
kDS1AttrSMBUserWorkstations,
kDS1AttrServiceType,
kDS1AttrSetupAdvertising,
kDS1AttrSetupAutoRegister,
kDS1AttrSetupLocation,
kDS1AttrSetupOccupation,
kDS1AttrUniqueID,
kDS1AttrUserShell,
kDS1AttrVFSDumpFreq,
kDS1AttrVFSLinkDir,
kDS1AttrVFSPassNo,
kDS1AttrVFSType,
kDS1AttrXMLPlist,
kDSNAttrAddressLine1,
kDSNAttrAddressLine2,
kDSNAttrAddressLine3,
kDSNAttrAreaCode,
kDSNAttrAuthenticationAuthority,
kDSNAttrBootParams,
kDSNAttrBuilding,
kDSNAttrCity,
kDSNAttrComputers,
kDSNAttrCountry,
kDSNAttrDepartment,
kDSNAttrDNSName,
kDSNAttrEMailAddress,
kDSNAttrFaxNumber,
kDSNAttrGroup,
kDSNAttrGroupMembership,
kDSNAttrHTML,
kDSNAttrHomeDirectory,
kDSNAttrIMHandle,
kDSNAttrIPAddress,
kDSNAttrJobTitle,
kDSNAttrKDCAuthKey,
kDSNAttrKeywords,
kDSNAttrLDAPReadReplicas,
kDSNAttrLDAPWriteReplicas,
kDSNAttrMCXSettings,
kDSNAttrMIME,
kDSNAttrMember,
kDSNAttrMobileNumber,
kDSNAttrNBPEntry,
kDSNAttrNetGroups,
kDSNAttrNickName,
kDSNAttrOrganizationName,
kDSNAttrPagerNumber,
kDSNAttrPhoneNumber,
kDSNAttrPGPPublicKey,
kDSNAttrPostalAddress,
kDSNAttrPostalCode,
kDSNAttrNamePrefix,
kDSNAttrProtocols,
kDSNAttrRecordName,
kDSNAttrState,
kDSNAttrStreet,
kDSNAttrNameSuffix,
kDSNAttrURL,
kDSNAttrURLForNSL,
kDSNAttrVFSOpts
};
#define kRecTypeConsts 41
static const char *sRecTypes[ kRecTypeConsts ] =
{
kDSStdRecordTypeAFPServer,
kDSStdRecordTypeAFPUserAliases,
kDSStdRecordTypeAliases,
kDSStdRecordTypeAutoServerSetup,
kDSStdRecordTypeBootp,
kDSStdRecordTypeComputerLists,
kDSStdRecordTypeComputers,
kDSStdRecordTypeConfig,
kDSStdRecordTypeEthernets,
kDSStdRecordTypeFTPServer,
kDSStdRecordTypeGroupAliases,
kDSStdRecordTypeGroups,
kDSStdRecordTypeHostServices,
kDSStdRecordTypeHosts,
kDSStdRecordTypeLDAPServer,
kDSStdRecordTypeLocations,
kDSStdRecordTypeMachines,
kDSStdRecordTypeMeta,
kDSStdRecordTypeMounts,
kDSStdRecordTypeNFS,
kDSStdRecordTypeNetDomains,
kDSStdRecordTypeNetGroups,
kDSStdRecordTypeNetworks,
kDSStdRecordTypePasswordServer,
kDSStdRecordTypePeople,
kDSStdRecordTypePresetComputerLists,
kDSStdRecordTypePresetGroups,
kDSStdRecordTypePresetUsers,
kDSStdRecordTypePrintService,
kDSStdRecordTypePrintServiceUser,
kDSStdRecordTypePrinters,
kDSStdRecordTypeProtocols,
kDSStdRecordTypeQTSServer,
kDSStdRecordTypeRPC,
kDSStdRecordTypeSMBServer,
kDSStdRecordTypeServer,
kDSStdRecordTypeServices,
kDSStdRecordTypeSharePoints,
kDSStdRecordTypeUserAliases,
kDSStdRecordTypeUsers,
kDSStdRecordTypeWebServer
};
CConfigurePlugin::CConfigurePlugin ( FourCharCode inSig, const char *inName ) : CServerPlugin(inSig, inName)
{
fConfigNodeName = nil;
fNodeCount = 0;
fState = kUnknownState;
if ( gConfigNodeRef == nil )
{
gConfigNodeRef = new CPlugInRef( CConfigurePlugin::ContextDeallocProc );
if ( gConfigNodeRef == nil ) throw((sInt32)eMemoryAllocError);
}
if ( gConfigContinue == nil )
{
gConfigContinue = new CContinue( CConfigurePlugin::ContinueDeallocProc );
if ( gConfigContinue == nil ) throw((sInt32)eMemoryAllocError);
}
if ( gKickConfigRequests == nil )
{
gKickConfigRequests = new DSEventSemaphore();
if ( gKickConfigRequests == nil ) throw((sInt32)eMemoryAllocError);
}
}
CConfigurePlugin::~CConfigurePlugin ( void )
{
}
sInt32 CConfigurePlugin::Validate ( const char *inVersionStr, const uInt32 inSignature )
{
fPlugInSignature = inSignature;
return( eDSNoErr );
}
sInt32 CConfigurePlugin::SetPluginState ( const uInt32 inState )
{
return( eDSNoErr );
}
sInt32 CConfigurePlugin::PeriodicTask ( void )
{
return( eDSNoErr );
}
sInt32 CConfigurePlugin::Initialize ( void )
{
sInt32 siResult = eDSNoErr;
fConfigNodeName = ::dsBuildFromPathPriv( "Configure", "/" );
if ( fConfigNodeName != nil )
{
CServerPlugin::_RegisterNode( fPlugInSignature, fConfigNodeName, kConfigNodeType );
}
fState = kUnknownState;
fState += kInitialized;
fState += kActive;
return( siResult );
}
void CConfigurePlugin::WakeUpRequests ( void )
{
gKickConfigRequests->Signal();
}
void CConfigurePlugin::WaitForInit ( void )
{
volatile uInt32 uiAttempts = 0;
while ( !(fState & kInitialized) &&
!(fState & kFailedToInit) )
{
if ( uiAttempts++ >= 240 )
{
return;
}
gKickConfigRequests->Wait( (uInt32)(.5 * kMilliSecsPerSec) );
}
}
sInt32 CConfigurePlugin::ProcessRequest ( void *inData )
{
sInt32 siResult = eDSNoErr;
char *pathStr = nil;
try
{
if ( inData == nil )
{
throw( (sInt32)ePlugInDataError );
}
if (((sHeader *)inData)->fType == kOpenDirNode)
{
if (((sOpenDirNode *)inData)->fInDirNodeName != nil)
{
pathStr = ::dsGetPathFromListPriv( ((sOpenDirNode *)inData)->fInDirNodeName, "/" );
if ( (pathStr != nil) && (strncmp(pathStr,"/Configure",10) != 0) )
{
throw( (sInt32)eDSOpenNodeFailed);
}
}
}
WaitForInit();
if (fState == kUnknownState)
{
throw( (sInt32)ePlugInCallTimedOut );
}
if ( (fState & kFailedToInit) || !(fState & kInitialized) )
{
throw( (sInt32)ePlugInFailedToInitialize );
}
if ( (fState & kInactive) || !(fState & kActive) )
{
throw( (sInt32)ePlugInNotActive );
}
siResult = HandleRequest( inData );
}
catch( sInt32 err )
{
siResult = err;
}
if (pathStr != nil)
{
free(pathStr);
pathStr = nil;
}
return( siResult );
}
sInt32 CConfigurePlugin::HandleRequest ( void *inData )
{
sInt32 siResult = eDSNoErr;
sHeader *pMsgHdr = nil;
try
{
pMsgHdr = (sHeader *)inData;
switch ( pMsgHdr->fType )
{
case kReleaseContinueData:
siResult = ReleaseContinueData( (sReleaseContinueData *)inData );
break;
case kOpenDirNode:
siResult = OpenDirNode( (sOpenDirNode *)inData );
break;
case kCloseDirNode:
siResult = CloseDirNode( (sCloseDirNode *)inData );
break;
case kGetRecordList:
siResult = GetRecordList( (sGetRecordList *)inData );
break;
case kGetRecordEntry:
siResult = GetRecordEntry( (sGetRecordEntry *)inData );
break;
case kGetAttributeEntry:
siResult = GetAttributeEntry( (sGetAttributeEntry *)inData );
break;
case kGetAttributeValue:
siResult = GetAttributeValue( (sGetAttributeValue *)inData );
break;
case kCloseAttributeList:
siResult = CloseAttributeList( (sCloseAttributeList *)inData );
break;
case kCloseAttributeValueList:
siResult = CloseAttributeValueList( (sCloseAttributeValueList *)inData );
break;
case kDoPlugInCustomCall:
siResult = DoPlugInCustomCall( (sDoPlugInCustomCall *)inData );
break;
case kHandleNetworkTransition:
case kServerRunLoop:
siResult = eDSNoErr;
break;
default:
siResult = eNotHandledByThisNode;
break;
}
pMsgHdr->fResult = siResult;
}
catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sInt32 CConfigurePlugin::ReleaseContinueData ( sReleaseContinueData *inData )
{
sInt32 siResult = eDSNoErr;
if ( gConfigContinue->RemoveItem( inData->fInContinueData ) != eDSNoErr )
{
siResult = eDSInvalidContext;
}
return( siResult );
}
sInt32 CConfigurePlugin::OpenDirNode ( sOpenDirNode *inData )
{
sInt32 siResult = eDSOpenNodeFailed;
char *pathStr = nil;
sConfigContextData *pContext = nil;
try
{
if ( inData != nil )
{
pathStr = ::dsGetPathFromListPriv( inData->fInDirNodeName, "/" );
if ( pathStr != nil )
{
if ( ::strcmp( pathStr, "/Configure" ) == 0 )
{
siResult = eDSNoErr;
pContext = MakeContextData();
pContext->fUID = inData->fInUID;
pContext->fEffectiveUID = inData->fInEffectiveUID;
if (pContext == nil ) throw( (sInt32)eMemoryAllocError);
gConfigNodeRef->AddItem( inData->fOutNodeRef, pContext );
}
delete( pathStr );
pathStr = nil;
}
}
}
catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sInt32 CConfigurePlugin::CloseDirNode ( sCloseDirNode *inData )
{
sInt32 siResult = eDSNoErr;
sConfigContextData *pContext = nil;
try
{
pContext = (sConfigContextData *) gConfigNodeRef->GetItemData( inData->fInNodeRef );
if ( pContext == nil ) throw( (sInt32)eDSInvalidNodeRef );
gConfigNodeRef->RemoveItem( inData->fInNodeRef );
gConfigContinue->RemoveItems( inData->fInNodeRef );
}
catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sInt32 CConfigurePlugin::GetRecordList ( sGetRecordList *inData )
{
sInt32 siResult = eDSNoErr;
uInt32 i = 0;
uInt32 uiTotal = 0;
uInt32 uiCount = 0;
char *pRecName = nil;
char *pRecType = nil;
char *pNIRecType = nil;
bool bAttribOnly = false;
tDirPatternMatch pattMatch = eDSNoMatch1;
CAttributeList *cpRecNameList = nil;
CAttributeList *cpRecTypeList = nil;
CAttributeList *cpAttrTypeList = nil;
sConfigContextData *pContext = nil;
sConfigContinueData *pContinue = nil;
CBuff *outBuff = nil;
CPlugInList::sTableData *pPIInfo = nil;
const char *typeName = nil;
sInt32 siValCnt = 0;
uInt32 fillIndex = 0;
CDataBuff *aRecData = nil;
CDataBuff *aAttrData = nil;
CDataBuff *aTmpData = nil;
try
{
aRecData = new CDataBuff();
if ( aRecData == nil ) throw((sInt32)eMemoryAllocError);
aAttrData = new CDataBuff();
if ( aAttrData == nil ) throw((sInt32)eMemoryAllocError);
aTmpData = new CDataBuff();
if ( aTmpData == nil ) throw((sInt32)eMemoryAllocError);
if ( inData == nil ) throw( (sInt32)eMemoryError );
if ( inData->fInDataBuff == nil ) throw( (sInt32)eDSEmptyBuffer );
if (inData->fInDataBuff->fBufferSize == 0) throw( (sInt32)eDSEmptyBuffer );
if ( inData->fInRecNameList == nil ) throw( (sInt32)eDSEmptyRecordNameList );
if ( inData->fInRecTypeList == nil ) throw( (sInt32)eDSEmptyRecordTypeList );
if ( inData->fInAttribTypeList == nil ) throw( (sInt32)eDSEmptyAttributeTypeList );
pContext = (sConfigContextData *)gConfigNodeRef->GetItemData( inData->fInNodeRef );
if ( pContext == nil ) throw( (sInt32)eDSInvalidNodeRef );
if ( inData->fIOContinueData == nil )
{
pContinue = (sConfigContinueData *)::calloc( 1, sizeof( sConfigContinueData ) );
gConfigContinue->AddItem( pContinue, inData->fInNodeRef );
pContinue->fRecNameIndex = 1;
pContinue->fRecTypeIndex = 1;
pContinue->fAttrIndex = 1;
pContinue->fAllRecIndex = 0;
}
else
{
pContinue = (sConfigContinueData *)inData->fIOContinueData;
if ( gConfigContinue->VerifyItem( pContinue ) == false )
{
throw( (sInt32)eDSInvalidContinueData );
}
}
inData->fIOContinueData = nil;
outBuff = new CBuff();
if ( outBuff == nil ) throw( (sInt32)eMemoryError );
siResult = outBuff->Initialize( inData->fInDataBuff, true );
if ( siResult != eDSNoErr ) throw( siResult );
siResult = outBuff->GetBuffStatus();
if ( siResult != eDSNoErr ) throw( siResult );
siResult = outBuff->SetBuffType( 'StdA' );
if ( siResult != eDSNoErr ) throw( siResult );
cpRecNameList = new CAttributeList( inData->fInRecNameList );
if ( cpRecNameList == nil ) throw( (sInt32)eDSEmptyRecordNameList );
if (cpRecNameList->GetCount() == 0) throw( (sInt32)eDSEmptyRecordNameList );
pattMatch = inData->fInPatternMatch;
cpRecTypeList = new CAttributeList( inData->fInRecTypeList );
if ( cpRecTypeList == nil ) throw( (sInt32)eDSEmptyRecordTypeList );
if (cpRecTypeList->GetCount() == 0) throw( (sInt32)eDSEmptyRecordTypeList );
cpAttrTypeList = new CAttributeList( inData->fInAttribTypeList );
if ( cpAttrTypeList == nil ) throw( (sInt32)eDSEmptyAttributeTypeList );
if (cpAttrTypeList->GetCount() == 0) throw( (sInt32)eDSEmptyAttributeTypeList );
bAttribOnly = inData->fInAttribInfoOnly;
while ( cpRecTypeList->GetAttribute( pContinue->fRecTypeIndex, &pRecType ) == eDSNoErr )
{
if ( ::strcmp( pRecType, kDSConfigPluginsRecType ) == 0 )
{
while ( cpRecNameList->GetAttribute( pContinue->fRecNameIndex, &pRecName ) == eDSNoErr )
{
if ( ::strcmp( pRecName, kDSConfigRecordsAll ) == 0 )
{
i = pContinue->fAllRecIndex;
while ( i < CPlugInList::kMaxPlugIns )
{
pPIInfo = gPlugins->GetPlugInInfo( i );
if ( pPIInfo != nil )
{
aRecData->Clear();
siValCnt = 0;
if ( (pPIInfo->fName != nil) && ( ::strcmp(pPIInfo->fName,"Configure") != 0) && ( ::strcmp(pPIInfo->fName,"Search") != 0) )
{
aRecData->AppendShort( ::strlen( kDSConfigPluginsRecType ) );
aRecData->AppendString( kDSConfigPluginsRecType );
aRecData->AppendShort( ::strlen( pPIInfo->fName ) );
aRecData->AppendString( pPIInfo->fName );
aAttrData->Clear();
siValCnt = 5;
aTmpData->Clear();
aTmpData->AppendShort( ::strlen( kDSConfigAttrPlugInIndex ) );
aTmpData->AppendString( kDSConfigAttrPlugInIndex );
aTmpData->AppendShort( 1 );
aTmpData->AppendLong( i );
for (fillIndex = 0; fillIndex < i; fillIndex++)
{
aTmpData->AppendString( "x" );
}
aAttrData->AppendLong( aTmpData->GetLength() );
aAttrData->AppendBlock( aTmpData->GetData(), aTmpData->GetLength() );
aTmpData->Clear();
aTmpData->AppendShort( ::strlen( kDSConfigAttrState ) );
aTmpData->AppendString( kDSConfigAttrState );
aTmpData->AppendShort( 1 );
if (pPIInfo->fState & kActive)
{
aTmpData->AppendLong( ::strlen("Active" ));
aTmpData->AppendString( "Active" );
} else if (pPIInfo->fState & kInitialized)
{
aTmpData->AppendLong( ::strlen("Initted" ));
aTmpData->AppendString( "Initted" );
} else if (pPIInfo->fState & kFailedToInit)
{
aTmpData->AppendLong( ::strlen("FailedToInit" ));
aTmpData->AppendString( "FailedToInit" );
} else
{
aTmpData->AppendLong( ::strlen("Unknown" ));
aTmpData->AppendString( "Unknown" );
}
aAttrData->AppendLong( aTmpData->GetLength() );
aAttrData->AppendBlock( aTmpData->GetData(), aTmpData->GetLength() );
aTmpData->Clear();
aTmpData->AppendShort( ::strlen( kDSConfigAttrVersion ) );
aTmpData->AppendString( kDSConfigAttrVersion );
aTmpData->AppendShort( 1 );
aTmpData->AppendLong( ::strlen( pPIInfo->fVersion ));
aTmpData->AppendString( pPIInfo->fVersion );
aAttrData->AppendLong( aTmpData->GetLength() );
aAttrData->AppendBlock( aTmpData->GetData(), aTmpData->GetLength() );
aTmpData->Clear();
aTmpData->AppendShort( ::strlen( kDSConfigAttrConfigAvail ) );
aTmpData->AppendString( kDSConfigAttrConfigAvail );
aTmpData->AppendShort( 1 );
aTmpData->AppendLong( ::strlen( pPIInfo->fConfigAvail ));
aTmpData->AppendString( pPIInfo-> fConfigAvail );
aAttrData->AppendLong( aTmpData->GetLength() );
aAttrData->AppendBlock( aTmpData->GetData(), aTmpData->GetLength() );
aTmpData->Clear();
aTmpData->AppendShort( ::strlen( kDSConfigAttrConfigFile ) );
aTmpData->AppendString( kDSConfigAttrConfigFile );
aTmpData->AppendShort( 1 );
aTmpData->AppendLong( ::strlen( pPIInfo->fConfigFile ));
aTmpData->AppendString( pPIInfo-> fConfigFile );
aAttrData->AppendLong( aTmpData->GetLength() );
aAttrData->AppendBlock( aTmpData->GetData(), aTmpData->GetLength() );
aTmpData->Clear();
aRecData->AppendShort( siValCnt );
aRecData->AppendBlock( aAttrData->GetData(), aAttrData->GetLength() );
siResult = outBuff->AddData( aRecData->GetData(), aRecData->GetLength() );
if ( siResult != eDSNoErr )
{
pContinue->fAllRecIndex = i;
break;
}
}
} i++;
}
outBuff->GetDataBlockCount( &uiCount );
if ( siResult == CBuff::kBuffFull )
{
uiTotal += uiCount;
if ( uiTotal == 0 )
{
throw( (sInt32)eDSBufferTooSmall );
}
else
{
inData->fIOContinueData = pContinue;
inData->fOutRecEntryCount = uiTotal;
outBuff->SetLengthToSize();
throw( (sInt32)eDSNoErr );
}
}
else if ( siResult == eDSNoErr )
{
uiTotal += uiCount;
}
else
{
break;
}
}
pContinue->fRecNameIndex++;
}
} else if ( ::strcmp( pRecType, kDSConfigRecordsType ) == 0 )
{
while ( cpRecNameList->GetAttribute( pContinue->fRecNameIndex, &pRecName ) == eDSNoErr )
{
if ( ::strcmp( pRecName, kDSConfigRecordsAll ) == 0 )
{
i = pContinue->fAllRecIndex;
while ( i < kRecTypeConsts )
{
typeName = sRecTypes[i];
if ( typeName != nil )
{
aRecData->Clear();
siValCnt = 0;
aRecData->AppendShort( ::strlen( pRecType ) );
aRecData->AppendString( pRecType );
aRecData->AppendShort( ::strlen( typeName ) );
aRecData->AppendString( typeName );
aAttrData->Clear();
siValCnt = 0;
aRecData->AppendShort( siValCnt );
aRecData->AppendBlock( aAttrData->GetData(), aAttrData->GetLength() );
siResult = outBuff->AddData( aRecData->GetData(), aRecData->GetLength() );
if ( siResult != eDSNoErr )
{
pContinue->fAllRecIndex = i;
break;
}
} i++;
}
outBuff->GetDataBlockCount( &uiCount );
if ( siResult == CBuff::kBuffFull )
{
uiTotal += uiCount;
if ( uiTotal == 0 )
{
throw( (sInt32)eDSBufferTooSmall );
}
else
{
inData->fIOContinueData = pContinue;
inData->fOutRecEntryCount = uiTotal;
outBuff->SetLengthToSize();
throw( (sInt32)eDSNoErr );
}
}
else if ( siResult == eDSNoErr )
{
uiTotal += uiCount;
}
else
{
break;
}
}
pContinue->fRecNameIndex++;
}
} else if ( ::strcmp( pRecType, kDSConfigAttributesType ) == 0 )
{
while ( cpRecNameList->GetAttribute( pContinue->fRecNameIndex, &pRecName ) == eDSNoErr )
{
if ( ::strcmp( pRecName, kDSConfigRecordsAll ) == 0 )
{
i = pContinue->fAllRecIndex;
while ( i < kAttrTypeConsts )
{
typeName = sAttrTypes[i];
if ( typeName != nil )
{
aRecData->Clear();
siValCnt = 0;
aRecData->AppendShort( ::strlen( pRecType ) );
aRecData->AppendString( pRecType );
aRecData->AppendShort( ::strlen( typeName ) );
aRecData->AppendString( typeName );
aAttrData->Clear();
siValCnt = 0;
aRecData->AppendShort( siValCnt );
aRecData->AppendBlock( aAttrData->GetData(), aAttrData->GetLength() );
siResult = outBuff->AddData( aRecData->GetData(), aRecData->GetLength() );
if ( siResult != eDSNoErr )
{
pContinue->fAllRecIndex = i;
break;
}
} i++;
}
outBuff->GetDataBlockCount( &uiCount );
if ( siResult == CBuff::kBuffFull )
{
uiTotal += uiCount;
if ( uiTotal == 0 )
{
throw( (sInt32)eDSBufferTooSmall );
}
else
{
inData->fIOContinueData = pContinue;
inData->fOutRecEntryCount = uiTotal;
outBuff->SetLengthToSize();
throw( (sInt32)eDSNoErr );
}
}
else if ( siResult == eDSNoErr )
{
uiTotal += uiCount;
}
else
{
break;
}
}
pContinue->fRecNameIndex++;
}
} else
{
siResult = eDSInvalidRecordType;
}
if (siResult != eDSNoErr)
{
break;
}
pContinue->fRecTypeIndex++;
}
if ( siResult == eDSNoErr )
{
if ( uiTotal == 0 )
{
outBuff->ClearBuff();
}
else
{
outBuff->SetLengthToSize();
}
inData->fOutRecEntryCount = uiTotal;
} }
catch( sInt32 err )
{
siResult = err;
}
if ( (inData->fIOContinueData == nil) && (pContinue != nil) )
{
gConfigContinue->RemoveItem( pContinue );
pContinue = nil;
}
if ( outBuff != nil )
{
delete( outBuff );
outBuff = nil;
}
if ( pNIRecType != nil )
{
delete( pNIRecType );
pNIRecType = nil;
}
if ( cpRecNameList != nil )
{
delete( cpRecNameList );
cpRecNameList = nil;
}
if ( cpRecTypeList != nil )
{
delete( cpRecTypeList );
cpRecTypeList = nil;
}
if ( cpAttrTypeList != nil )
{
delete( cpAttrTypeList );
cpAttrTypeList = nil;
}
if ( aRecData != nil )
{
delete( aRecData );
aRecData = nil;
}
if ( aAttrData != nil )
{
delete( aAttrData );
aAttrData = nil;
}
if ( aTmpData != nil )
{
delete( aTmpData );
aTmpData = nil;
}
return( siResult );
}
sInt32 CConfigurePlugin::GetRecordEntry ( sGetRecordEntry *inData )
{
sInt32 siResult = eDSNoErr;
uInt32 uiIndex = 0;
uInt32 uiCount = 0;
uInt32 uiOffset = 0;
uInt32 uberOffset = 0;
char *pData = nil;
tRecordEntryPtr pRecEntry = nil;
sConfigContextData *pContext = nil;
CBuff inBuff;
uInt32 offset = 0;
uInt16 usTypeLen = 0;
char *pRecType = nil;
uInt16 usNameLen = 0;
char *pRecName = nil;
uInt16 usAttrCnt = 0;
uInt32 buffLen = 0;
try
{
if ( inData == nil ) throw( (sInt32)eMemoryError );
if ( inData->fInOutDataBuff == nil ) throw( (sInt32)eDSEmptyBuffer );
if (inData->fInOutDataBuff->fBufferSize == 0) throw( (sInt32)eDSEmptyBuffer );
siResult = inBuff.Initialize( inData->fInOutDataBuff );
if ( siResult != eDSNoErr ) throw( siResult );
siResult = inBuff.GetDataBlockCount( &uiCount );
if ( siResult != eDSNoErr ) throw( siResult );
uiIndex = inData->fInRecEntryIndex;
if ((uiIndex > uiCount) || (uiIndex == 0)) throw( (sInt32)eDSInvalidIndex );
pData = inBuff.GetDataBlock( uiIndex, &uberOffset );
if ( pData == nil ) throw( (sInt32)eDSCorruptBuffer );
buffLen = inBuff.GetDataBlockLength( uiIndex );
pData += 4;
offset = 0;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usTypeLen, pData, 2 );
pData += 2;
offset += 2;
pRecType = pData;
pData += usTypeLen;
offset += usTypeLen;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usNameLen, pData, 2 );
pData += 2;
offset += 2;
pRecName = pData;
pData += usNameLen;
offset += usNameLen;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usAttrCnt, pData, 2 );
pRecEntry = (tRecordEntry *)::calloc( 1, sizeof( tRecordEntry ) + usNameLen + usTypeLen + 4 + kBuffPad );
pRecEntry->fRecordNameAndType.fBufferSize = usNameLen + usTypeLen + 4 + kBuffPad;
pRecEntry->fRecordNameAndType.fBufferLength = usNameLen + usTypeLen + 4;
::memcpy( pRecEntry->fRecordNameAndType.fBufferData, &usNameLen, 2 );
uiOffset += 2;
::memcpy( pRecEntry->fRecordNameAndType.fBufferData + uiOffset, pRecName, usNameLen );
uiOffset += usNameLen;
::memcpy( pRecEntry->fRecordNameAndType.fBufferData + uiOffset, &usTypeLen, 2 );
uiOffset += 2;
::memcpy( pRecEntry->fRecordNameAndType.fBufferData + uiOffset, pRecType, usTypeLen );
pRecEntry->fRecordAttributeCount = usAttrCnt;
pContext = MakeContextData();
if ( pContext == nil ) throw( (sInt32)eMemoryAllocError );
pContext->offset = uberOffset + offset + 4;
gConfigNodeRef->AddItem( inData->fOutAttrListRef, pContext );
inData->fOutRecEntryPtr = pRecEntry;
}
catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sInt32 CConfigurePlugin::GetAttributeEntry ( sGetAttributeEntry *inData )
{
sInt32 siResult = eDSNoErr;
uInt16 usAttrTypeLen = 0;
uInt16 usAttrCnt = 0;
uInt32 usAttrLen = 0;
uInt16 usValueCnt = 0;
uInt32 usValueLen = 0;
uInt32 i = 0;
uInt32 uiIndex = 0;
uInt32 uiAttrEntrySize = 0;
uInt32 uiOffset = 0;
uInt32 uiTotalValueSize = 0;
uInt32 offset = 0;
uInt32 buffSize = 0;
uInt32 buffLen = 0;
char *p = nil;
char *pAttrType = nil;
tDataBuffer *pDataBuff = nil;
tAttributeValueListRef attrValueListRef = 0;
tAttributeEntryPtr pAttribInfo = nil;
sConfigContextData *pAttrContext = nil;
sConfigContextData *pValueContext = nil;
try
{
if ( inData == nil ) throw( (sInt32)eMemoryError );
pAttrContext = (sConfigContextData *)gConfigNodeRef->GetItemData( inData->fInAttrListRef );
if ( pAttrContext == nil ) throw( (sInt32)eDSBadContextData );
uiIndex = inData->fInAttrInfoIndex;
if (uiIndex == 0) throw( (sInt32)eDSInvalidIndex );
pDataBuff = inData->fInOutDataBuff;
if ( pDataBuff == nil ) throw( (sInt32)eDSNullDataBuff );
buffSize = pDataBuff->fBufferSize;
p = pDataBuff->fBufferData + pAttrContext->offset;
offset = pAttrContext->offset;
if (2 + offset > buffSize) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usAttrCnt, p, 2 );
if (uiIndex > usAttrCnt) throw( (sInt32)eDSInvalidIndex );
p += 2;
offset += 2;
for ( i = 1; i < uiIndex; i++ )
{
if (4 + offset > buffSize) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usAttrLen, p, 4 );
p += 4 + usAttrLen;
offset += 4 + usAttrLen;
}
uiOffset = offset;
if (4 + offset > buffSize) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usAttrLen, p, 4 );
p += 4;
offset += 4;
buffLen = offset + usAttrLen;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usAttrTypeLen, p, 2 );
pAttrType = p + 2;
p += 2 + usAttrTypeLen;
offset += 2 + usAttrTypeLen;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usValueCnt, p, 2 );
p += 2;
offset += 2;
for ( i = 0; i < usValueCnt; i++ )
{
if (4 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usValueLen, p, 2 );
p += 4 + usValueLen;
offset += 4 + usValueLen;
uiTotalValueSize += usValueLen;
}
uiAttrEntrySize = sizeof( tAttributeEntry ) + usAttrTypeLen + kBuffPad;
pAttribInfo = (tAttributeEntry *)::calloc( 1, uiAttrEntrySize );
pAttribInfo->fAttributeValueCount = usValueCnt;
pAttribInfo->fAttributeDataSize = uiTotalValueSize;
pAttribInfo->fAttributeValueMaxSize = 512; pAttribInfo->fAttributeSignature.fBufferSize = usAttrTypeLen + kBuffPad;
pAttribInfo->fAttributeSignature.fBufferLength = usAttrTypeLen;
::memcpy( pAttribInfo->fAttributeSignature.fBufferData, pAttrType, usAttrTypeLen );
attrValueListRef = inData->fOutAttrValueListRef;
pValueContext = MakeContextData();
if ( pValueContext == nil ) throw( (sInt32)eMemoryAllocError );
pValueContext->offset = uiOffset;
gConfigNodeRef->AddItem( inData->fOutAttrValueListRef, pValueContext );
inData->fOutAttrInfoPtr = pAttribInfo;
}
catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sInt32 CConfigurePlugin::GetAttributeValue ( sGetAttributeValue *inData )
{
sInt32 siResult = eDSNoErr;
uInt16 usValueCnt = 0;
uInt32 usValueLen = 0;
uInt16 usAttrNameLen = 0;
uInt32 i = 0;
uInt32 uiIndex = 0;
uInt32 offset = 0;
char *p = nil;
tDataBuffer *pDataBuff = nil;
tAttributeValueEntry *pAttrValue = nil;
sConfigContextData *pValueContext = nil;
uInt32 buffSize = 0;
uInt32 buffLen = 0;
uInt32 attrLen = 0;
try
{
pValueContext = (sConfigContextData *)gConfigNodeRef->GetItemData( inData->fInAttrValueListRef );
if ( pValueContext == nil ) throw( (sInt32)eDSBadContextData );
uiIndex = inData->fInAttrValueIndex;
if (uiIndex == 0) throw( (sInt32)eDSInvalidIndex );
pDataBuff = inData->fInOutDataBuff;
if ( pDataBuff == nil ) throw( (sInt32)eDSNullDataBuff );
buffSize = pDataBuff->fBufferSize;
p = pDataBuff->fBufferData + pValueContext->offset;
offset = pValueContext->offset;
if (4 + offset > buffSize) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &attrLen, p, 4 );
buffLen = attrLen + pValueContext->offset + 4;
if (buffLen > buffSize) throw( (sInt32)eDSInvalidBuffFormat );
p += 4;
offset += 4;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usAttrNameLen, p, 2 );
p += 2 + usAttrNameLen;
offset += 2 + usAttrNameLen;
if (2 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usValueCnt, p, 2 );
p += 2;
offset += 2;
if (uiIndex > usValueCnt) throw( (sInt32)eDSInvalidIndex );
for ( i = 1; i < uiIndex; i++ )
{
if (4 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usValueLen, p, 4 );
p += 4 + usValueLen;
offset += 4 + usValueLen;
}
if (4 + offset > buffLen) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( &usValueLen, p, 4 );
p += 4;
offset += 4;
pAttrValue = (tAttributeValueEntry *)::calloc( 1, sizeof( tAttributeValueEntry ) + usValueLen + kBuffPad );
pAttrValue->fAttributeValueData.fBufferSize = usValueLen + kBuffPad;
pAttrValue->fAttributeValueData.fBufferLength = usValueLen;
if ( usValueLen + offset > buffLen ) throw( (sInt32)eDSInvalidBuffFormat );
::memcpy( pAttrValue->fAttributeValueData.fBufferData, p, usValueLen );
pAttrValue->fAttributeValueID = 0x00;
inData->fOutAttrValue = pAttrValue;
}
catch( sInt32 err )
{
siResult = err;
}
return( siResult );
}
sConfigContextData* CConfigurePlugin::MakeContextData ( void )
{
sConfigContextData *pOut = nil;
pOut = new sConfigContextData;
if ( pOut != nil )
{
::memset( pOut, 0, sizeof( sConfigContextData ) );
}
return( pOut );
}
sInt32 CConfigurePlugin::DoPlugInCustomCall ( sDoPlugInCustomCall *inData )
{
sInt32 siResult = eDSNoErr;
unsigned long aRequest = 0;
uInt32 pluginIndex = 0;
CPlugInList::sTableData *pPIInfo = nil;
uInt32 thePIState = 0;
unsigned long bufLen = 0;
AuthorizationExternalForm authExtForm;
AuthorizationRef authRef = 0;
AuthorizationItemSet *resultRightSet = NULL;
sConfigContextData *pContext = nil;
try
{
bzero(&authExtForm,sizeof(AuthorizationExternalForm));
pContext = (sConfigContextData *)gConfigNodeRef->GetItemData( inData->fInNodeRef );
if ( pContext == nil ) throw( (sInt32)eDSInvalidNodeRef );
if ( inData == nil ) throw( (sInt32)eDSNullParameter );
if ( inData->fInRequestData == nil ) throw( (sInt32)eDSNullDataBuff );
if ( inData->fOutRequestResponse == nil ) throw( (sInt32)eDSNullDataBuff );
if ( inData->fInRequestData->fBufferData == nil ) throw( (sInt32)eDSEmptyBuffer );
aRequest = inData->fInRequestCode;
AuthorizationItem rights[] = { {"system.services.directory.configure", 0, 0, 0} };
AuthorizationItemSet rightSet = { sizeof(rights)/ sizeof(*rights), rights };
bufLen = inData->fInRequestData->fBufferLength;
if ( aRequest == 111 )
{
uInt32 userNameLength = 0;
char* userName = NULL;
uInt32 passwordLength = 0;
char* password = NULL;
char* current = inData->fInRequestData->fBufferData;
uInt32 offset = 0;
if ( bufLen < 2 * sizeof( uInt32 ) + 1 ) throw( (sInt32)eDSInvalidBuffFormat );
memcpy( &userNameLength, current, sizeof( uInt32 ) );
current += sizeof( uInt32 );
offset += sizeof( uInt32 );
if ( bufLen - offset < userNameLength ) throw( (sInt32)eDSInvalidBuffFormat );
userName = current; current += userNameLength;
offset += userNameLength;
if ( bufLen - offset < sizeof( uInt32 ) ) throw( (sInt32)eDSInvalidBuffFormat );
memcpy( &passwordLength, current, sizeof( uInt32 ) );
current += sizeof( uInt32 );
offset += sizeof( uInt32 );
if ( passwordLength == 0 )
{
password = "";
}
else
{
if ( bufLen - offset < passwordLength ) throw( (sInt32)eDSInvalidBuffFormat );
password = current;
}
AuthorizationItem params[] = { {"username", userNameLength, (void*)userName, 0}, {"password", passwordLength, (void*)password, 0} };
AuthorizationEnvironment environment = { sizeof(params)/ sizeof(*params), params };
siResult = AuthorizationCreate( &rightSet, &environment, kAuthorizationFlagExtendRights, &authRef);
if (siResult != errAuthorizationSuccess)
{
throw( (sInt32)eDSPermissionError );
}
if ( inData->fOutRequestResponse->fBufferSize < sizeof( AuthorizationExternalForm ) ) throw( (sInt32)eDSInvalidBuffFormat );
siResult = AuthorizationMakeExternalForm(authRef, (AuthorizationExternalForm*)inData->fOutRequestResponse->fBufferData);
if (siResult != errAuthorizationSuccess)
{
throw( (sInt32)eDSPermissionError );
}
inData->fOutRequestResponse->fBufferLength = sizeof( AuthorizationExternalForm );
siResult = eDSNoErr;
authRef = 0;
}
else if (aRequest == 222)
{
uInt32 versLength = strlen( "1" );
char* current = inData->fOutRequestResponse->fBufferData;
inData->fOutRequestResponse->fBufferLength = 0;
if ( inData->fOutRequestResponse->fBufferSize < sizeof(versLength) + versLength ) throw( (sInt32)eDSInvalidBuffFormat );
memcpy(current, &versLength, sizeof(versLength));
current += sizeof(versLength);
inData->fOutRequestResponse->fBufferLength += sizeof(versLength);
memcpy(current, "1", versLength);
current += versLength;
inData->fOutRequestResponse->fBufferLength += versLength;
}
else if (aRequest == 444 || aRequest == 445)
{
uInt32 keyLength = bufLen;
CFStringRef key = NULL;
CFPropertyListRef dict = NULL;
CFDataRef xmlData = NULL;
char* current = inData->fInRequestData->fBufferData;
key = CFStringCreateWithBytes(NULL, (UInt8*)current, keyLength, kCFStringEncodingUTF8,
false);
if (pContext->session == 0)
{
pContext->session = SCPreferencesCreate( NULL, CFSTR("DSConfigurePlugIn"), NULL );
}
dict = SCPreferencesPathGetValue( pContext->session, key );
xmlData = CFPropertyListCreateXMLData( NULL, dict );
if (xmlData != 0)
{
CFRange aRange;
aRange.location = 0;
aRange.length = CFDataGetLength(xmlData);
if (aRequest == 444)
{
if ( inData->fOutRequestResponse->fBufferSize < sizeof(CFIndex) ) throw( (sInt32)eDSBufferTooSmall );
memcpy(inData->fOutRequestResponse->fBufferData,&aRange.length,sizeof(CFIndex));
}
else
{
if ( inData->fOutRequestResponse->fBufferSize < (uInt32)aRange.length ) throw( (sInt32)eDSBufferTooSmall );
CFDataGetBytes( xmlData, aRange,
(UInt8*)(inData->fOutRequestResponse->fBufferData) );
inData->fOutRequestResponse->fBufferLength = aRange.length;
}
CFRelease(xmlData);
xmlData = 0;
}
if (key != NULL)
{
CFRelease(key);
key = NULL;
}
}
else if (aRequest == 446 || aRequest == 447)
{
uInt32 keyLength = bufLen;
CFStringRef key = NULL;
CFStringRef stringValue = NULL;
char* current = inData->fInRequestData->fBufferData;
key = CFStringCreateWithBytes(NULL, (UInt8*)current, keyLength, kCFStringEncodingUTF8,
false);
if (pContext->session == 0)
{
pContext->session = SCPreferencesCreate( NULL, CFSTR("DSConfigurePlugIn"), NULL );
}
stringValue = (CFStringRef)SCPreferencesGetValue( pContext->session, key );
if (stringValue != 0)
{
CFRange aRange;
aRange.location = 0;
aRange.length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(stringValue),
kCFStringEncodingUTF8);
if (aRequest == 446)
{
if ( inData->fOutRequestResponse->fBufferSize < sizeof(CFIndex) ) throw( (sInt32)eDSBufferTooSmall );
memcpy(inData->fOutRequestResponse->fBufferData,&aRange.length,sizeof(CFIndex));
}
else
{
if ( inData->fOutRequestResponse->fBufferSize < (uInt32)aRange.length ) throw( (sInt32)eDSBufferTooSmall );
CFStringGetCString(stringValue, inData->fOutRequestResponse->fBufferData, inData->fOutRequestResponse->fBufferSize, kCFStringEncodingUTF8);
inData->fOutRequestResponse->fBufferLength = aRange.length;
}
}
if (key != NULL)
{
CFRelease(key);
key = NULL;
}
}
#ifdef BUILD_IN_PERFORMANCE
else if ( aRequest == 666 )
{
gSrvrCntl->ActivatePeformanceStatGathering();
}
else if ( aRequest == 667 )
{
gSrvrCntl->DeactivatePeformanceStatGathering();
}
#endif
else
{
if ( bufLen < sizeof( AuthorizationExternalForm ) ) throw( (sInt32)eDSInvalidBuffFormat );
if (!(pContext->fEffectiveUID == 0 &&
memcmp(inData->fInRequestData->fBufferData,&authExtForm,
sizeof(AuthorizationExternalForm)) == 0)) {
siResult = AuthorizationCreateFromExternalForm((AuthorizationExternalForm *)inData->fInRequestData->fBufferData,
&authRef);
if (siResult != errAuthorizationSuccess)
{
throw( (sInt32)eDSPermissionError );
}
siResult = AuthorizationCopyRights(authRef, &rightSet, NULL,
kAuthorizationFlagExtendRights, &resultRightSet);
if (resultRightSet != NULL)
{
AuthorizationFreeItemSet(resultRightSet);
resultRightSet = NULL;
}
if (siResult != errAuthorizationSuccess)
{
throw( (sInt32)eDSPermissionError );
}
}
}
if (aRequest > 999)
{
pluginIndex = aRequest - 1000;
if (pluginIndex < CPlugInList::kMaxPlugIns)
{
pPIInfo = gPlugins->GetPlugInInfo( pluginIndex );
if (pPIInfo->fState & kActive)
{
thePIState = pPIInfo->fState;
thePIState += (uInt32)kInactive;
thePIState -= (uInt32)kActive;
gPlugins->SetState( pPIInfo->fName, thePIState );
gPluginConfig->SetPluginState( pPIInfo->fName, kInactive);
gPluginConfig->SaveConfigData();
SRVRLOG1( kLogApplication, "Plug-in %s state is now set inactive.", pPIInfo->fName );
}
else if (pPIInfo->fState & kInactive)
{
thePIState = pPIInfo->fState;
thePIState -= kInactive;
thePIState += kActive;
gPlugins->SetState( pPIInfo->fName, thePIState );
gPluginConfig->SetPluginState( pPIInfo->fName, kActive);
gPluginConfig->SaveConfigData();
SRVRLOG1( kLogApplication, "Plug-in %s state is now set active.", pPIInfo->fName );
}
}
}
else if (aRequest == 333)
{
if (authRef != 0)
{
AuthorizationFree(authRef, kAuthorizationFlagDestroyRights);
authRef = 0;
}
}
else if (aRequest == 555)
{
bool success = false;
sInt32 xmlDataLength = 0;
CFDataRef xmlData = nil;
CFPropertyListRef propList = nil;
xmlDataLength = (sInt32) bufLen - sizeof( AuthorizationExternalForm );
if ( xmlDataLength <= 0 ) throw( (sInt32)eDSInvalidBuffFormat );
xmlData = CFDataCreate(NULL,(UInt8 *)(inData->fInRequestData->fBufferData + sizeof( AuthorizationExternalForm )),xmlDataLength);
if ( xmlData == nil ) throw( (sInt32)eMemoryError );
propList = CFPropertyListCreateFromXMLData(NULL,xmlData,0,NULL);
if ( propList == nil ) throw( (sInt32)eMemoryError );
if (pContext->session == 0)
{
pContext->session = SCPreferencesCreate( NULL, CFSTR("DSNetInfoPlugIn"), NULL );
}
if (pContext->session != 0)
{
CFStringRef key = SCDynamicStoreKeyCreate( NULL, CFSTR("/%@"), kSCPrefSets );
success = SCPreferencesPathSetValue(pContext->session, key,
(CFDictionaryRef)propList);
if (success)
success &= SCPreferencesCommitChanges(pContext->session);
if (success)
success &= SCPreferencesApplyChanges(pContext->session);
if (!success)
siResult = eDSOperationFailed;
if (key != NULL)
CFRelease(key);
}
CFRelease(propList);
propList = nil;
CFRelease(xmlData);
xmlData = nil;
}
else if (aRequest == 777)
{
struct stat statResult;
siResult = ::stat( "/Library/Preferences/DirectoryService/.DSTCPListening", &statResult );
if (siResult != eDSNoErr)
{
siResult = ::stat( "/Library/Preferences", &statResult );
if (siResult != eDSNoErr)
{
::mkdir( "/Library/Preferences", 0775 );
::chmod( "/Library/Preferences", 0775 ); }
siResult = ::stat( "/Library/Preferences/DirectoryService", &statResult );
if (siResult != eDSNoErr)
{
::mkdir( "/Library/Preferences/DirectoryService", 0775 );
::chmod( "/Library/Preferences/DirectoryService", 0775 ); }
dsTouch( "/Library/Preferences/DirectoryService/.DSTCPListening" );
gSrvrCntl->StartTCPListener(kDSDefaultListenPort);
}
else
{
dsRemove( "/Library/Preferences/DirectoryService/.DSTCPListening" );
gSrvrCntl->StopTCPListener();
}
}
}
catch( sInt32 err )
{
siResult = err;
}
if (authRef != 0)
{
AuthorizationFree(authRef, 0);
authRef = 0;
}
return( siResult );
}
sInt32 CConfigurePlugin::CloseAttributeList ( sCloseAttributeList *inData )
{
sInt32 siResult = eDSNoErr;
sConfigContextData *pContext = nil;
pContext = (sConfigContextData *) gConfigNodeRef->GetItemData( inData->fInAttributeListRef );
if ( pContext != nil )
{
gConfigNodeRef->RemoveItem( inData->fInAttributeListRef );
}
else
{
siResult = eDSInvalidAttrListRef;
}
return( siResult );
}
sInt32 CConfigurePlugin::CloseAttributeValueList ( sCloseAttributeValueList *inData )
{
sInt32 siResult = eDSNoErr;
sConfigContextData *pContext = nil;
pContext = (sConfigContextData *) gConfigNodeRef->GetItemData( inData->fInAttributeValueListRef );
if ( pContext != nil )
{
gConfigNodeRef->RemoveItem( inData->fInAttributeValueListRef );
}
else
{
siResult = eDSInvalidAttrValueRef;
}
return( siResult );
}
void CConfigurePlugin::ContinueDeallocProc ( void* inContinueData )
{
sConfigContinueData* pContinue = (sConfigContinueData *)inContinueData;
if ( pContinue != nil )
{
free( pContinue );
pContinue = nil;
}
}
void CConfigurePlugin::ContextDeallocProc ( void* inContextData )
{
sConfigContextData *pContext = (sConfigContextData *) inContextData;
if ( pContext != nil )
{
if ( pContext->session != NULL )
{
CFRelease( pContext->session );
pContext->session = NULL;
}
free( pContext );
pContext = nil;
}
}