long PlugInShell_Initialize(void)
{
long macError = eDSNoErr;
bool gotUnameInfo = false;
PSTR pszVersion = NULL;
PCSTR pszVersionName = NULL;
bool isUnsupported = false;
PNETADAPTERINFO pTempNetInfo = NULL;
struct utsname info;
BOOLEAN bMergeModeMCX = FALSE;
BOOLEAN bEnableForceHomedirOnStartupDisk = FALSE;
BOOLEAN bUseADUNCForHomeLocation = FALSE;
PSTR pszUNCProtocolForHomeLocation = NULL;
PSTR pszAllowAdministrationBy = NULL;
BOOLEAN bMergeAdmins = FALSE;
PVOID pAllowAdminCheckData = NULL;
memset(info.sysname, 0, sizeof(info.sysname));
memset(info.nodename, 0, sizeof(info.nodename));
memset(info.release, 0, sizeof(info.release));
memset(info.version, 0, sizeof(info.version));
memset(info.machine, 0, sizeof(info.machine));
LOG_ENTER("");
LOG("Current State = 0x%08x", GlobalState.PluginState);
//
// We expect to be called exactly once, except if we fail to initialize.
// When that happens, we can get called again several times to try to
// initialize successfully.
//
if (GlobalState.IsInitialized)
{
LOG("Plug-in already initialized");
GOTO_CLEANUP();
}
/* Clear all values for GlobalState */
GlobalState.IsInitialized = false;
GlobalState.PluginState = kUnknownState;
GlobalState.IsJoinedToAD = false;
GlobalState.Flags = LWE_DS_FLAG_NO_OPTIONS_SET;
GlobalState.NodeNameList = NULL;
GlobalState.pGPOs = NULL;
GlobalState.pszRealm = NULL;
macError = InitializeContextList();
GOTO_CLEANUP_ON_MACERROR(macError);
if (uname(&info))
{
gotUnameInfo = false;
macError = LWCaptureOutput((char*)"sw_vers -productVersion", &pszVersion);
GOTO_CLEANUP_ON_MACERROR(macError);
if (strstr(pszVersion, "10.4.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags & (~LWE_DS_FLAG_IS_LEOPARD);
pszVersionName = MAC_OS_X_VERSION_NAME_10_4;
}
else if (strstr(pszVersion, "10.5.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_IS_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_5;
}
else if (strstr(pszVersion, "10.6.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_IS_LEOPARD | LWE_DS_FLAG_IS_SNOW_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_6;
}
else if (strstr(pszVersion, "10.7.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_IS_LEOPARD | LWE_DS_FLAG_IS_SNOW_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_7;
}
else
{
isUnsupported = true;
}
}
else
{
gotUnameInfo = true;
macError = LwAllocateString(info.release, &pszVersion);
GOTO_CLEANUP_ON_MACERROR(macError);
if (strstr(pszVersion, "8.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags & ~LWE_DS_FLAG_IS_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_4;
}
else if (strstr(pszVersion, "9.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_IS_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_5;
}
else if (strstr(pszVersion, "10.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_IS_LEOPARD | LWE_DS_FLAG_IS_SNOW_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_6;
}
else if (strstr(pszVersion, "11.") == pszVersion)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_IS_LEOPARD | LWE_DS_FLAG_IS_SNOW_LEOPARD;
pszVersionName = MAC_OS_X_VERSION_NAME_10_6;
}
else
{
isUnsupported = true;
}
}
if (isUnsupported)
{
pszVersionName = "unsupported";
}
LOG("Starting up Likewise - Active directory DS plug-in, detected %s Mac OS X %s(%s)",
pszVersionName, gotUnameInfo ? "kernel " : "", pszVersion);
if (isUnsupported)
{
macError = ePlugInFailedToInitialize;
GOTO_CLEANUP_ON_MACERROR(macError);
}
/* Get the network adpater details - We only care about the ENetAddress info */
macError = LWGetNetAdapterList(true, &GlobalState.pNetAdapterList);
GOTO_CLEANUP_ON_MACERROR(macError);
if (!GlobalState.pNetAdapterList)
{
LOG("Could not find an ethernet network adapter, will retry later. Computer settings maybe not be applied till one is found.");
}
pTempNetInfo = GlobalState.pNetAdapterList;
while (pTempNetInfo)
{
LOG("Found network adapter...");
LOG(" Name: %s", pTempNetInfo->pszName);
LOG(" ENet: %s", pTempNetInfo->pszENetAddress ? pTempNetInfo->pszENetAddress : "----");
LOG(" IP: %s", pTempNetInfo->pszIPAddress ? pTempNetInfo->pszIPAddress : "----");
LOG(" Up: %s", pTempNetInfo->IsUp ? "yes" : "no");
LOG(" Running: %s", pTempNetInfo->IsRunning ? "yes" : "no");
pTempNetInfo = pTempNetInfo->pNext;
}
macError = GetConfigurationSettings(&bMergeModeMCX,
&bEnableForceHomedirOnStartupDisk,
&bUseADUNCForHomeLocation,
&pszUNCProtocolForHomeLocation,
&pszAllowAdministrationBy,
&bMergeAdmins);
GOTO_CLEANUP_ON_MACERROR(macError);
/* See if MCX setting aggregation feature is to be supported */
if (bMergeModeMCX)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_MERGE_MODE_MCX;
LOG("Merge mode MCX is enabled. Settings from multiple Group Policy Objects will be merged for the AD user accounts at logon.");
}
/* See if Force Home Directory On Startup Disk feature is to be supported */
if (bEnableForceHomedirOnStartupDisk)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_FORCE_LOCAL_HOME_DIRECTORY_ON_STARTUP_DISK;
LOG("Force Home Directory On Startup Disk is enabled.");
}
/* See if Use AD UNC for Home Location - SMB feature is to be supported */
if (bUseADUNCForHomeLocation)
{
if (pszUNCProtocolForHomeLocation && !strcmp(pszUNCProtocolForHomeLocation, "smb"))
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_USE_AD_UNC_FOR_HOME_LOCATION_SMB;
LOG("Use AD UNC for Home Location - SMB is enabled.");
}
else if (pszUNCProtocolForHomeLocation && !strcmp(pszUNCProtocolForHomeLocation, "afp"))
{
/* See if Use AD UNC for Home Location - AFP feature is to be supported */
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_USE_AD_UNC_FOR_HOME_LOCATION_AFP;
LOG("Use AD UNC for Home Location - AFP is enabled.");
}
else
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_USE_AD_UNC_FOR_HOME_LOCATION_SMB;
LOG("Use AD UNC for Home Location - defaulting to SMB protocol.");
}
}
if (pszAllowAdministrationBy)
{
GlobalState.pszCurrentAllowedAdminsList = pszAllowAdministrationBy;
pszAllowAdministrationBy = NULL;
macError = GetAccessCheckData(GlobalState.pszCurrentAllowedAdminsList, &pAllowAdminCheckData);
if (macError)
{
if (macError == eDSAuthUnknownUser)
{
LOG("GetAccessCheckData(%s) failed with error: eDSAuthUnknownUser. AD user accounts will not be added to admin group (GID:80), since the list provided is incorrectly specified. This error suggests that you have a user or group that is not recognized by Likewise authentication daemon. Recommend checking that system administrator has enabled the items here in the Likewise cell that applies to this computer.", GlobalState.pszCurrentAllowedAdminsList);
}
else
{
LOG("Failed to GetAccessCheckData(%s) with error: %d", GlobalState.pszCurrentAllowedAdminsList, macError);
}
LW_SAFE_FREE_STRING(GlobalState.pszCurrentAllowedAdminsList);
GlobalState.pszCurrentAllowedAdminsList = NULL;
GlobalState.pAllowAdminCheckData = NULL;
macError = eDSNoErr;
}
else
{
LOG("AllowAdministrationBy configured to: %s", GlobalState.pszCurrentAllowedAdminsList);
GlobalState.pAllowAdminCheckData = pAllowAdminCheckData;
pAllowAdminCheckData = NULL;
}
}
/* See if Merge Admins feature is to be supported */
if (bMergeAdmins)
{
GlobalState.Flags = GlobalState.Flags | LWE_DS_FLAG_DONT_REMOVE_LOCAL_ADMINS;
LOG("Option to override allow-administration-by with local computer changes to the admin group is enabled.");
}
if (pthread_rwlock_init(&GlobalState.Lock, NULL) < 0)
{
int libcError = errno;
LOG_ERROR("Failied to init lock: %s (%d)", strerror(libcError), libcError);
macError = ePlugInInitError;
GOTO_CLEANUP();
}
GlobalState.IsLockInitialized = true;
if (pthread_mutex_init(&GlobalState.PeriodicTaskMutex, NULL) < 0)
{
int libcError = errno;
LOG_ERROR("Failied to init mutex: %s (%d)", strerror(libcError), libcError);
macError = ePlugInInitError;
GOTO_CLEANUP();
}
GlobalState.IsPeriodicTaskMutexInitialized = true;
if (pthread_rwlock_init(&GlobalState.AdminAccessListLock, NULL) < 0)
{
int libcError = errno;
LOG_ERROR("Failied to init admin access list lock: %s (%d)", strerror(libcError), libcError);
macError = ePlugInInitError;
GOTO_CLEANUP();
}
GlobalState.IsAdminAccessListLockInitialized = true;
macError = LWIAttrLookup::Initialize();
GOTO_CLEANUP_ON_MACERROR(macError);
macError = LWIRecTypeLookup::Initialize();
GOTO_CLEANUP_ON_MACERROR(macError);
macError = LWIDirNodeQuery::Initialize();
GOTO_CLEANUP_ON_MACERROR(macError);
macError = LWIRecordQuery::Initialize();
GOTO_CLEANUP_ON_MACERROR(macError);
LWICRC::Initialize();
// Allow WGM policy options to define Login/Logoff Hook scripts. We do this to automatically support settings
// we get from group policies.
macError = SetupMCXLoginScriptsSupport();
GOTO_CLEANUP_ON_MACERROR(macError);
GlobalState.IsInitialized = true;
GlobalState.PluginState = kInitialized | kInactive;
//
// If we supported custom calls while not active, we would need to create a
// node for that here.
//
cleanup:
if (pszVersion)
{
LwFreeMemory(pszVersion);
}
if (pszUNCProtocolForHomeLocation)
{
LW_SAFE_FREE_STRING(pszUNCProtocolForHomeLocation);
}
if (pszAllowAdministrationBy)
{
LW_SAFE_FREE_STRING(pszUNCProtocolForHomeLocation);
}
if (pAllowAdminCheckData)
{
FreeAccessCheckData(pAllowAdminCheckData);
}
if (macError)
{
// This is the only error code allowed in the failure case.
macError = ePlugInInitError;
PlugInShell_Shutdown();
GlobalState.PluginState = kFailedToInit | kInactive;
}
LOG("Final State = 0x%08x", GlobalState.PluginState);
LOG_LEAVE("--> %d", macError);
return macError;
}
// ---------------------------------------------------------------------------
// * PlugInShell_ProcessRequest
//
// inData : A pointer to a data structure representing the current
// server call.
//
// This routine is called continuiously throughout the operation of the
// Directory Services process.
// ---------------------------------------------------------------------------
long
PlugInShell_ProcessRequest(void *inData)
{
long macError = eDSNoErr;
bool isAcquired = false;
sHeader * pMsgHdr = (sHeader *)inData;
unsigned long msgType = pMsgHdr ? pMsgHdr->fType : 0;
LOG_ENTER("inData = @%p => { fType = %lu (%s) }", inData, msgType, TypeToString(msgType));
GS_VERIFY_INITIALIZED(macError);
if (!inData)
{
macError = eDSNullParameter;
GOTO_CLEANUP();
}
GS_ACQUIRE_SHARED();
isAcquired = true;
//
// We currently do not handle anything while not "active".
//
if ( !FlagOn(GlobalState.PluginState, kActive) )
{
macError = ePlugInNotActive;
GOTO_CLEANUP();
}
//
// We also do not handle anything while not "startup complete".
//
if (GlobalState.IsStartupComplete == false &&
msgType != kOpenDirNode &&
msgType != kDoPlugInCustomCall &&
msgType != kServerRunLoop &&
msgType != kKerberosMutex)
{
macError = ePlugInNotActive;
LOG("Startup of dependent services not complete, therefore network accounts are offline");
GOTO_CLEANUP();
}
// ISSUE-2007/05/30-dalmeida -- We should use r/w locks instead so that
// we can behave sensibly when someone tries to de-activate the plug-in
// while we are processing something...
try
{
switch ( msgType )
{
case kHandleNetworkTransition:
LOG("Got Network Transition change notice");
macError = eDSNoErr;
break;
case kHandleSystemWillSleep:
LOG("Got Handle System Will Sleep notice");
macError = eDSNoErr;
break;
case kHandleSystemWillPowerOn:
LOG("Got Handle System Will Power On notice");
macError = eDSNoErr;
break;
case kOpenDirNode:
LOG("Start of directory node query");
macError = LWIDirNodeQuery::Open((sOpenDirNode *)inData);
break;
case kDoDirNodeAuth:
GS_ACQUIRE_SHARED_ADMIN_ACCESS_LIST();
macError = LWIDirNodeQuery::DoDirNodeAuth((sDoDirNodeAuth *)inData,
SafeIsJoined(),
GlobalState.pAllowAdminCheckData,
GlobalState.Flags);
GS_RELEASE_ADMIN_ACCESS_LIST();
break;
case kCloseDirNode:
macError = LWIDirNodeQuery::Close((sCloseDirNode *)inData);
break;
case kGetDirNodeInfo:
macError = LWIDirNodeQuery::GetInfo((sGetDirNodeInfo *)inData,
GlobalState.Flags,
GlobalState.pNetAdapterList);
break;
case kGetAttributeEntry:
macError = LWIDirNodeQuery::GetAttributeEntry((sGetAttributeEntry *)inData);
break;
case kGetRecordEntry:
macError = LWIDirNodeQuery::GetAttributeEntry((sGetAttributeEntry *)inData);
break;
case kGetAttributeValue:
macError = LWIDirNodeQuery::GetAttributeValue((sGetAttributeValue *)inData);
break;
case kCloseAttributeValueList:
macError = LWIDirNodeQuery::CloseValueList((sCloseAttributeValueList *)inData);
break;
case kCloseAttributeList:
macError = LWIDirNodeQuery::CloseAttributeList((sCloseAttributeList *)inData);
break;
case kGetRecordList:
macError = LWIRecordListQuery::Run((sGetRecordList *)inData, GlobalState.Flags, GlobalState.pNetAdapterList);
break;
case kReleaseContinueData:
macError = LWIRecordListQuery::ReleaseContinueData((sReleaseContinueData *)inData);
break;
case kDoAttributeValueSearch:
case kDoAttributeValueSearchWithData:
macError = LWIAttrValDataQuery::Run((sDoAttrValueSearchWithData *)inData, GlobalState.Flags, GlobalState.pNetAdapterList);
break;
case kDoMultipleAttributeValueSearch:
case kDoMultipleAttributeValueSearchWithData:
macError = LWIAttrValDataQuery::Run((sDoMultiAttrValueSearchWithData *)inData, GlobalState.Flags, GlobalState.pNetAdapterList);
break;
case kOpenRecord:
LOG("Start of record query");
macError = LWIRecordQuery::Open((sOpenRecord*)inData, GlobalState.Flags, GlobalState.pNetAdapterList);
break;
case kGetRecordReferenceInfo:
macError = LWIRecordQuery::GetReferenceInfo((sGetRecRefInfo*)inData);
break;
case kCloseRecord:
macError = LWIRecordQuery::Close((sCloseRecord*)inData);
break;
case kGetRecordAttributeInfo:
macError = LWIRecordQuery::GetAttributeInfo((sGetRecAttribInfo*)inData);
break;
case kGetRecordAttributeValueByID:
macError = LWIRecordQuery::GetAttributeValueByID((sGetRecordAttributeValueByID*)inData);
break;
case kGetRecordAttributeValueByIndex:
macError = LWIRecordQuery::GetAttributeValueByIndex((sGetRecordAttributeValueByIndex*)inData);
break;
/* Supported update operations */
case kAddAttribute:
macError = LWIRecordQuery::AddAttribute((sAddAttribute*)inData);
break;
case kAddAttributeValue:
macError = LWIRecordQuery::AddAttributeValue((sAddAttributeValue*)inData);
break;
case kRemoveAttribute:
macError = LWIRecordQuery::RemoveAttribute((sRemoveAttribute*)inData);
break;
case kFlushRecord:
macError = LWIRecordQuery::FlushRecord((sFlushRecord*)inData);
break;
case kSetAttributeValues:
macError = LWIRecordQuery::SetAttributeValues((sSetAttributeValues*)inData);
break;
case kSetAttributeValue:
macError = LWIRecordQuery::SetAttributeValue((sSetAttributeValue*)inData);
break;
case kSetRecordName:
case kSetRecordType:
case kDeleteRecord:
case kCreateRecord:
case kCreateRecordAndOpen: /* sCreateRecord */
case kRemoveAttributeValue:
case kDoPlugInCustomCall:
default:
if ((msgType < kDSPlugInCallsBegin) || (msgType > kDSPlugInCallsEnd))
{
LOG("Unsupported request type: %lu (%s)", msgType, TypeToString(msgType));
}
else
{
LOG("Unknown request type: %lu", msgType);
}
macError = eNotHandledByThisNode;
break;
}
}
catch (LWIException& lwi)
{
macError = lwi.getErrorCode();
}
cleanup:
if (isAcquired)
{
GS_RELEASE();
}
if (pMsgHdr)
{
pMsgHdr->fResult = macError;
}
LOG_LEAVE("--> %d", macError);
return macError;
}
static long Activate(void)
{
long macError = eDSNoErr;
tDataListPtr nodeNameList = NULL;
BOOLEAN bIsStarted = FALSE;
int i = 0;
LOG_ENTER("");
LOG("Verify that LSASS service is operational");
GlobalState.IsStartupComplete = false;
for (i = 0; i < 24; i++)
{
// Verify that startup has completed successfully for lsass service.
GetLsaStatus(&bIsStarted);
if (bIsStarted)
{
LOG("LSASS service is operational");
GlobalState.IsStartupComplete = true;
break;
}
sleep(5);
}
if ( !GlobalState.DsRoot )
{
macError = dsOpenDirService( &GlobalState.DsRoot );
GOTO_CLEANUP_ON_MACERROR( macError );
}
if ( !GlobalState.NodeNameList )
{
nodeNameList = dsDataListAllocate(0);
if ( !nodeNameList )
{
macError = eDSAllocationFailed;
GOTO_CLEANUP_ON_MACERROR( macError );
}
macError = dsBuildListFromPathAlloc(0, nodeNameList, PLUGIN_ROOT_PATH, "/");
GOTO_CLEANUP_ON_MACERROR( macError );
macError = DSRegisterNode(GlobalState.Signature, nodeNameList, kDirNodeType);
GOTO_CLEANUP_ON_MACERROR( macError );
GlobalState.NodeNameList = nodeNameList;
nodeNameList = NULL;
}
if ( !GlobalState.NodeDictionary )
{
GlobalState.NodeDictionary = CFDictionaryCreateMutable(NULL, 0,
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
cleanup:
if (nodeNameList)
{
dsDataListDeallocate(0, nodeNameList);
free(nodeNameList);
}
if (macError)
{
long localMacError = Deactivate();
if (localMacError)
{
LOG_ERROR("Unexpected error: %d", localMacError);
}
}
LOG_LEAVE("--> %d", macError);
return macError;
}
long
LWIRecordListQuery::Test(
IN const char* DsPath,
IN tDataListPtr RecNameList,
IN tDirPatternMatch PatternMatch,
IN tDataListPtr RecTypeList,
IN tDataListPtr AttribTypeList,
IN dsBool AttribInfoOnly,
IN unsigned long Size
)
{
long macError = eDSNoErr;
tDirReference dirRef = 0;
tDirNodeReference dirNode = 0;
tDataListPtr dirNodeName = NULL;
tDataBufferPtr pData = NULL;
UInt32 outCount;
tContextData continueData = NULL;
LOG_ENTER("");
macError = dsOpenDirService( &dirRef );
GOTO_CLEANUP_ON_MACERROR( macError );
pData = dsDataBufferAllocate(dirRef, Size);
if (!pData)
{
macError = eDSAllocationFailed;
GOTO_CLEANUP();
}
dirNodeName = dsBuildFromPath( dirRef, DsPath, "/" );
if (!dirNodeName)
{
macError = eDSAllocationFailed;
GOTO_CLEANUP();
}
macError = dsOpenDirNode( dirRef, dirNodeName, &dirNode );
GOTO_CLEANUP_ON_MACERROR( macError );
macError = dsGetRecordList( dirNode,
pData,
RecNameList,
PatternMatch,
RecTypeList,
AttribTypeList,
AttribInfoOnly,
&outCount,
&continueData);
GOTO_CLEANUP_ON_MACERROR( macError );
LOG("Got %d records", outCount);
if (pData->fBufferLength > 0)
{
LOG_BUFFER(pData->fBufferData, pData->fBufferLength);
}
cleanup:
if ( pData )
{
dsDataBufferDeAllocate( dirRef, pData );
}
if ( dirNodeName )
{
dsDataListDeallocate( dirRef, dirNodeName );
}
if ( dirNode )
{
dsCloseDirNode( dirNode );
}
if ( dirRef )
{
dsCloseDirService( dirRef );
}
LOG_LEAVE("--> %d", macError);
return macError;
}
long
LWIRecordListQuery::Run(IN OUT sGetRecordList* pGetRecordList, LWE_DS_FLAGS Flags, PNETADAPTERINFO pNetAdapterList)
{
long macError = eDSNoErr;
long macError_userQuery = eDSNoErr;
long macError_groupQuery = eDSNoErr;
long macError_computerQuery = eDSNoErr;
long macError_computergroupQuery = eDSNoErr;
long macError_computerlistQuery = eDSNoErr;
tDataNodePtr pDataNode = NULL;
const char* szNames = NULL;
unsigned long bytesWritten = 0;
unsigned long nRecordsWritten = 0;
unsigned long TotalRecords = 0;
LWIQuery* pQuery = NULL;
int iter = 0;
int resultCount = 0;
int recordNameCount;
int recordTypeCount;
int recordAttributeCount;
tContextData HandleId = 0;
LOG_ENTER("LWIRecordListQuery::Run - fType = %d, fResult = %d, fInNodeRef = %d, "
"fInDataBuf = @%p { len = %d, size = %d }, fInPatternMatch = 0x%04X, "
"fIOContinueData = %d",
pGetRecordList->fType,
pGetRecordList->fResult,
pGetRecordList->fInNodeRef,
pGetRecordList->fInDataBuff,
pGetRecordList->fInDataBuff->fBufferLength,
pGetRecordList->fInDataBuff->fBufferSize,
pGetRecordList->fInPatternMatch,
pGetRecordList->fIOContinueData);
recordNameCount = dsDataListGetNodeCount(pGetRecordList->fInRecNameList);
recordTypeCount = dsDataListGetNodeCount(pGetRecordList->fInRecTypeList);
recordAttributeCount = dsDataListGetNodeCount(pGetRecordList->fInAttribTypeList);
LOG_PARAM("fInRecNameList.count = %d, fInRecTypeList.count = %d, "
"fInAttribTypeList.count = %d",
recordNameCount,
recordTypeCount,
recordAttributeCount);
/* Initialize the out parameters in case we return with error */
pGetRecordList->fInDataBuff->fBufferLength = 0;
pGetRecordList->fOutRecEntryCount = 0;
if ((UInt32)pGetRecordList->fIOContinueData != 0 &&
(UInt32)pGetRecordList->fIOContinueData != SPECIAL_DS_CONTINUE_HANDLE)
{
macError = GetQueryFromContextList(pGetRecordList->fIOContinueData, &pQuery);
if (macError == eDSNoErr)
{
LOG("Already processed this query, handling IO continuation for result record data");
goto HandleResponse;
}
}
macError = LWIQuery::Create(!pGetRecordList->fInAttribInfoOnly,
true, // The query results will support fIOContinue (split large results over many calls)
pGetRecordList->fInNodeRef,
Flags,
pNetAdapterList,
&pQuery);
GOTO_CLEANUP_ON_MACERROR(macError);
macError = LWIRecTypeLookup::GetVector(pGetRecordList->fInRecTypeList, &pQuery->_recTypeSet);
GOTO_CLEANUP_ON_MACERROR(macError);
macError = LWIAttrLookup::GetVector(pGetRecordList->fInAttribTypeList, &pQuery->_attributeSet);
GOTO_CLEANUP_ON_MACERROR(macError);
for (iter = 0; iter < recordNameCount; iter++)
{
macError = dsDataListGetNodeAlloc( pGetRecordList->fInNodeRef,
pGetRecordList->fInRecNameList,
iter+1,
&pDataNode );
GOTO_CLEANUP_ON_MACERROR( macError );
szNames = pDataNode->fBufferData;
macError = eDSInvalidRecordType;
if (pQuery->ShouldQueryUserInformation())
{
macError_userQuery = pQuery->QueryUserInformationByName(szNames);
if (macError_userQuery != eDSNoErr)
{
LOG("User query failed [Error: %d]", macError_userQuery);
}
else
{
resultCount++;
}
}
if (pQuery->ShouldQueryGroupInformation())
{
macError_groupQuery = pQuery->QueryGroupInformationByName(szNames);
if (macError_groupQuery != eDSNoErr)
{
LOG("Group query failed [Error: %d]", macError_groupQuery);
}
else
{
resultCount++;
}
}
if (pQuery->ShouldQueryComputerInformation())
{
macError_computerQuery = pQuery->QueryComputerInformationByName(szNames);
if (macError_computerQuery != eDSNoErr)
{
LOG("Computer query failed [Error: %d]", macError_computerQuery);
}
else
{
resultCount++;
}
}
if (pQuery->ShouldQueryComputerGroupInformation())
{
macError_computergroupQuery = pQuery->QueryComputerGroupInformationByName(szNames);
if (macError_computergroupQuery != eDSNoErr)
{
LOG("Computer group query failed [Error: %d]", macError_computergroupQuery);
}
else
{
resultCount++;
}
}
if (pQuery->ShouldQueryComputerListInformation())
{
macError_computerlistQuery = pQuery->QueryComputerListInformationByName(szNames);
if (macError_computerlistQuery != eDSNoErr)
{
LOG("Computer list query failed [Error: %d]", macError_computerlistQuery);
}
else
{
resultCount++;
}
}
dsDataNodeDeAllocate(NULL, pDataNode);
pDataNode = NULL;
}
// If both queries failed, it is a problem
if (resultCount == 0 &&
(macError_userQuery != eDSNoErr) &&
(macError_groupQuery != eDSNoErr) &&
(macError_computerQuery != eDSNoErr) &&
(macError_computergroupQuery != eDSNoErr) &&
(macError_computerlistQuery != eDSNoErr))
{
macError = (pQuery->ShouldQueryUserInformation() ? macError_userQuery : macError_groupQuery);
GOTO_CLEANUP_ON_MACERROR(macError);
}
else
macError = eDSNoErr;
HandleResponse:
// Write the results
macError = pQuery->WriteResponse(pGetRecordList->fInDataBuff->fBufferData,
pGetRecordList->fInDataBuff->fBufferSize,
bytesWritten,
nRecordsWritten,
TotalRecords);
GOTO_CLEANUP_ON_MACERROR(macError);
if (TotalRecords > nRecordsWritten)
{
macError = AddQueryToContextList(pQuery, &HandleId);
GOTO_CLEANUP_ON_MACERROR(macError);
pQuery = NULL;
pGetRecordList->fIOContinueData = HandleId;
}
else
{
pGetRecordList->fIOContinueData = 0;
}
pGetRecordList->fInDataBuff->fBufferLength = bytesWritten;
pGetRecordList->fOutRecEntryCount = nRecordsWritten;
if ( bytesWritten > 0 )
{
#ifdef SHOW_ALL_DEBUG_SPEW
LOG_BUFFER(pGetRecordList->fInDataBuff->fBufferData, bytesWritten);
#endif
}
cleanup:
if (pDataNode)
{
dsDataNodeDeAllocate(0, pDataNode);
}
if (pQuery)
{
delete pQuery;
}
if (macError == eDSBufferTooSmall)
{
pGetRecordList->fIOContinueData = (tContextData)SPECIAL_DS_CONTINUE_HANDLE;
}
LOG_LEAVE("fOutRecEntryCount = %d, fInDataBuff = { length = %d, size = %d }, fIOContinueData = %d, macError = %d",
pGetRecordList->fOutRecEntryCount,
pGetRecordList->fInDataBuff->fBufferLength,
pGetRecordList->fInDataBuff->fBufferSize,
pGetRecordList->fIOContinueData,
macError);
return macError;
}
static void setup_display(void) {
XGCValues gv;
XSetWindowAttributes attr;
XColor dummy;
XModifierKeymap *modmap;
/* used in scanning windows (XQueryTree) */
unsigned int i, j, nwins;
Window dw1, dw2, *wins;
XWindowAttributes winattr;
LOG_ENTER("setup_display()");
dpy = XOpenDisplay(opt_display);
if (!dpy) {
LOG_ERROR("can't open display %s\n", opt_display);
exit(1);
}
XSetErrorHandler(handle_xerror);
/* XSynchronize(dpy, True); */
/* Standard & EWMH atoms */
ewmh_init();
font = XLoadQueryFont(dpy, opt_font);
if (!font) font = XLoadQueryFont(dpy, DEF_FONT);
if (!font) {
LOG_ERROR("couldn't find a font to use: try starting with -fn fontname\n");
exit(1);
}
move_curs = XCreateFontCursor(dpy, XC_fleur);
resize_curs = XCreateFontCursor(dpy, XC_plus);
/* find out which modifier is NumLock - we'll use this when grabbing
* every combination of modifiers we can think of */
modmap = XGetModifierMapping(dpy);
for (i = 0; i < 8; i++) {
for (j = 0; j < (unsigned int)modmap->max_keypermod; j++) {
if (modmap->modifiermap[i*modmap->max_keypermod+j] == XKeysymToKeycode(dpy, XK_Num_Lock)) {
numlockmask = (1<<i);
LOG_DEBUG("XK_Num_Lock is (1<<0x%02x)\n", i);
}
}
}
XFreeModifiermap(modmap);
/* set up GC parameters - same for each screen */
gv.function = GXinvert;
gv.subwindow_mode = IncludeInferiors;
gv.line_width = 1; /* opt_bw */
gv.font = font->fid;
/* set up root window attributes - same for each screen */
attr.event_mask = ChildMask | EnterWindowMask | ColormapChangeMask;
/* SHAPE extension? */
#ifdef SHAPE
{
int e_dummy;
have_shape = XShapeQueryExtension(dpy, &shape_event, &e_dummy);
}
#endif
/* Xrandr extension? */
#ifdef RANDR
{
int e_dummy;
have_randr = XRRQueryExtension(dpy, &randr_event_base, &e_dummy);
if (!have_randr) {
LOG_DEBUG("XRandR is not supported on this display.\n");
}
}
#endif
/* now set up each screen in turn */
num_screens = ScreenCount(dpy);
if (num_screens < 0) {
LOG_ERROR("Can't count screens\n");
exit(1);
}
screens = xmalloc(num_screens * sizeof(ScreenInfo));
for (i = 0; i < (unsigned int)num_screens; i++) {
char *ds, *colon, *dot;
ds = DisplayString(dpy);
/* set up DISPLAY environment variable to use */
colon = strrchr(ds, ':');
screens[i].display = xmalloc(14 + strlen(ds));
strcpy(screens[i].display, "DISPLAY=");
strcat(screens[i].display, ds);
if (colon && num_screens > 1) {
colon = strrchr(screens[i].display, ':');
dot = strchr(colon, '.');
if (!dot)
dot = colon + strlen(colon);
snprintf(dot, 5, ".%d", i);
}
screens[i].screen = i;
screens[i].root = RootWindow(dpy, i);
#ifdef RANDR
if (have_randr) {
XRRSelectInput(dpy, screens[i].root, RRScreenChangeNotifyMask);
}
#endif
#ifdef VWM
screens[i].vdesk = KEY_TO_VDESK(XK_1);
#endif
XAllocNamedColor(dpy, DefaultColormap(dpy, i), opt_fg, &screens[i].fg, &dummy);
XAllocNamedColor(dpy, DefaultColormap(dpy, i), opt_bg, &screens[i].bg, &dummy);
#ifdef VWM
XAllocNamedColor(dpy, DefaultColormap(dpy, i), opt_fc, &screens[i].fc, &dummy);
#endif
screens[i].invert_gc = XCreateGC(dpy, screens[i].root, GCFunction | GCSubwindowMode | GCLineWidth | GCFont, &gv);
XChangeWindowAttributes(dpy, screens[i].root, CWEventMask, &attr);
grab_keys_for_screen(&screens[i]);
screens[i].docks_visible = 1;
/* scan all the windows on this screen */
LOG_XENTER("XQueryTree(screen=%d)", i);
XQueryTree(dpy, screens[i].root, &dw1, &dw2, &wins, &nwins);
LOG_XDEBUG("%d windows\n", nwins);
LOG_XLEAVE();
for (j = 0; j < nwins; j++) {
XGetWindowAttributes(dpy, wins[j], &winattr);
if (!winattr.override_redirect && winattr.map_state == IsViewable)
make_new_client(wins[j], &screens[i]);
}
XFree(wins);
ewmh_init_screen(&screens[i]);
}
ewmh_set_net_active_window(NULL);
LOG_LEAVE();
}
HRESULT ui::UIListBox::Initialize(graphics::D3DInteropHelper *pD3DInteropHelper) {
#ifdef DEBUG_UILISTBOX
LOG_ENTER(SEVERITY_LEVEL_DEBUG);
#endif
assert(GetWidth() > 0.0f);
assert(GetHeight() > 0.0f);
ui::UIListBoxItem::LAYOUT_DIRECTION layoutDirection = ui::UIListBoxItem::LAYOUT_DIRECTION_VERTICAL;
switch (m_scrollDirection) {
case ui::UIListBox::SCROLL_DIRECTION_HORIZONTAL:
layoutDirection = ui::UIListBoxItem::LAYOUT_DIRECTION_VERTICAL;
m_itemHeight = GetHeight();
if (m_preferredTextAreaSize.height == 0.0f) {
m_preferredTextAreaSize.height = GetHeight() - m_preferredBitmapSize.height - m_marginBetweenBitmapAndText;
}
if (m_preferredTextAreaSize.width == 0.0f) {
m_preferredTextAreaSize.width = m_preferredBitmapSize.width * 3.0f;
}
m_itemWidth = m_preferredTextAreaSize.width;
break;
case ui::UIListBox::SCROLL_DIRECTION_VERTICAL:
layoutDirection = ui::UIListBoxItem::LAYOUT_DIRECTION_HORIZONTAL;
m_itemWidth = GetWidth();
if (m_preferredTextAreaSize.width == 0.0f) {
m_preferredTextAreaSize.width = GetWidth() - m_preferredBitmapSize.width - m_marginBetweenBitmapAndText;
}
if (m_preferredTextAreaSize.height == 0.0f) {
m_preferredTextAreaSize.height = m_preferredBitmapSize.height;
}
m_itemHeight = m_preferredTextAreaSize.height;
break;
}
for (size_t i = 0; i < GetNumberOfElements(); ++i) {
auto element = GetElement(i);
auto listBoxItem = std::dynamic_pointer_cast<UIListBoxItem>(element);
if (listBoxItem.get() != nullptr) {
listBoxItem->SetLayoutDirection(layoutDirection);
listBoxItem->SetPreferredBitmapSize(m_preferredBitmapSize);
listBoxItem->SetPreferredTextAreaSize(m_preferredTextAreaSize);
listBoxItem->SetBounds(0.0f, 0.0f, m_itemWidth, m_itemHeight);
}
}
CHK_WARN_HRESULT(UIContainer::Initialize(pD3DInteropHelper));
auto frameDecorator = std::make_shared<graphics::decorator::FrameDecorator>();
frameDecorator->SetColorSet(m_colorSet);
for (size_t i = 0; i < m_colorSet->GetNumberOfColors(); ++i) {
frameDecorator->AddFrame(graphics::decorator::Frame(i));
}
m_rectFigure->AddDecorator(frameDecorator);
m_rectFigure->SetX(0.0f);
m_rectFigure->SetY(0.0f);
m_rectFigure->SetWidth(GetWidth());
m_rectFigure->SetHeight(GetHeight());
m_rectFigure->SetColor(graphics::color::ColorValue(graphics::color::ColorValue::COLOR_TYPE_RGBA, 0x222222, 1.0f),
graphics::color::COLOR_PATTERN_FLAT);
CHK_WARN_HRESULT(m_rectFigure->Initialize(pD3DInteropHelper));
m_scrollBar->SetParentContainer(shared_from_this());
m_scrollBar->SetMinValue(0.0f);
m_scrollBar->SetMaxValue(GetNumberOfElements() - 1.0f);
m_scrollBar->SetPageSize(1.0f);
if (m_scrollBar->GetCurrentValue() < m_scrollBar->GetMinValue()
|| m_scrollBar->GetCurrentValue() > m_scrollBar->GetMaxValue() - m_scrollBar->GetPageSize()) {
m_scrollBar->SetCurrentValue(0.0f);
}
FLOAT frameThick = static_cast<FLOAT>(m_colorSet->GetNumberOfColors());
if (m_scrollDirection == ui::UIListBox::SCROLL_DIRECTION_HORIZONTAL) {
m_scrollBar->SetDirection(ui::UIScrollBar::SCROLLBAR_DIRECTION_HORIZONTAL);
m_scrollBar->SetBounds(frameThick + m_scrollBarMarginFromSide,
GetHeight() - m_scrollBarThick - frameThick - m_scrollBarMarginFromSide,
GetWidth() - (frameThick + m_scrollBarMarginFromSide) * 2, m_scrollBarThick);
} else {
m_scrollBar->SetDirection(ui::UIScrollBar::SCROLLBAR_DIRECTION_VERTICAL);
m_scrollBar->SetBounds(GetWidth() - m_scrollBarThick - frameThick - m_scrollBarMarginFromSide,
frameThick + m_scrollBarMarginFromSide, m_scrollBarThick,
GetHeight() - (frameThick + m_scrollBarMarginFromSide) * 2);
}
m_scrollBar->AddPositionChangedCallback([&](FLOAT position) { NotifyScrollPositionChanged(position); });
CHK_FATAL_HRESULT(m_scrollBar->Initialize(pD3DInteropHelper));
#ifdef DEBUG_UILISTBOX
LOG_LEAVE(SEVERITY_LEVEL_DEBUG);
#endif
return S_OK;
}
