/////////////////////////////////////////////////////////////////////
//
// SvcUtils.cpp
//
// Utilities routines specific for system services.
// Mostly used to display services properties.
//
// HISTORY
// t-danmo 96.10.10 Creation.
//
/////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <iads.h>
#include <iadsp.h> // IADsPathname
#include <atlcom.h> // CComPtr and CComBSTR
extern "C"
{
#include <objsel.h> // IDsObjectPicker
}
//
// Service current state
//
CString g_strSvcStateStarted; // Service is started
CString g_strSvcStateStarting; // Service is starting
CString g_strSvcStateStopped; // Service is stopped
CString g_strSvcStateStopping; // Service is stopping
CString g_strSvcStatePaused; // Service is paused
CString g_strSvcStatePausing; // Service is pausing
CString g_strSvcStateResuming; // Service is resuming
//
// Service startup type
//
CString g_strSvcStartupBoot;
CString g_strSvcStartupSystem;
CString g_strSvcStartupAutomatic;
CString g_strSvcStartupManual;
CString g_strSvcStartupDisabled;
//
// Service startup account
// JonN 188203 11/13/00
//
CString g_strLocalSystem;
CString g_strLocalService;
CString g_strNetworkService;
CString g_strUnknown;
CString g_strLocalMachine; // "Local Machine"
BOOL g_fStringsLoaded = FALSE;
/////////////////////////////////////////////////////////////////////
void
Service_LoadResourceStrings()
{
if (g_fStringsLoaded)
return;
g_fStringsLoaded = TRUE;
VERIFY(g_strSvcStateStarted.LoadString(IDS_SVC_STATUS_STARTED));
VERIFY(g_strSvcStateStarting.LoadString(IDS_SVC_STATUS_STARTING));
VERIFY(g_strSvcStateStopped.LoadString(IDS_SVC_STATUS_STOPPED));
VERIFY(g_strSvcStateStopping.LoadString(IDS_SVC_STATUS_STOPPING));
VERIFY(g_strSvcStatePaused.LoadString(IDS_SVC_STATUS_PAUSED));
VERIFY(g_strSvcStatePausing.LoadString(IDS_SVC_STATUS_PAUSING));
VERIFY(g_strSvcStateResuming.LoadString(IDS_SVC_STATUS_RESUMING));
VERIFY(g_strSvcStartupBoot.LoadString(IDS_SVC_STARTUP_BOOT));
VERIFY(g_strSvcStartupSystem.LoadString(IDS_SVC_STARTUP_SYSTEM));
VERIFY(g_strSvcStartupAutomatic.LoadString(IDS_SVC_STARTUP_AUTOMATIC));
VERIFY(g_strSvcStartupManual.LoadString(IDS_SVC_STARTUP_MANUAL));
VERIFY(g_strSvcStartupDisabled.LoadString(IDS_SVC_STARTUP_DISABLED));
// JonN 11/13/00 188203 support LocalService/NetworkService
VERIFY(g_strLocalSystem.LoadString(IDS_SVC_STARTUP_LOCALSYSTEM));
VERIFY(g_strLocalService.LoadString(IDS_SVC_STARTUP_LOCALSERVICE));
VERIFY(g_strNetworkService.LoadString(IDS_SVC_STARTUP_NETWORKSERVICE));
VERIFY(g_strUnknown.LoadString(IDS_SVC_UNKNOWN));
VERIFY(g_strLocalMachine.LoadString(IDS_LOCAL_MACHINE));
} // Service_LoadResourceStrings()
/////////////////////////////////////////////////////////////////////
// Service_PszMapStateToName()
//
// Map the service state to a null-terminated string.
//
LPCTSTR
Service_PszMapStateToName(
DWORD dwServiceState, // From SERVICE_STATUS.dwCurrentState
BOOL fLongString) // TRUE => Display the name in a long string format
{
switch(dwServiceState)
{
case SERVICE_STOPPED:
if (fLongString)
{
return g_strSvcStateStopped;
}
// Note that, by design, we never display the service
// status as "Stopped". Instead, we just don't display
// the status. Hence, the empty string.
return _T("");
case SERVICE_STOP_PENDING:
return g_strSvcStateStopping;
case SERVICE_RUNNING:
return g_strSvcStateStarted;
case SERVICE_START_PENDING:
return g_strSvcStateStarting;
case SERVICE_PAUSED:
return g_strSvcStatePaused;
case SERVICE_PAUSE_PENDING:
return g_strSvcStatePausing;
case SERVICE_CONTINUE_PENDING:
return g_strSvcStateResuming;
default:
TRACE0("INFO Unknown service state.\n");
} // switch
return g_strUnknown;
} // Service_PszMapStateToName()
/////////////////////////////////////////////////////////////////////
// Service_PszMapStartupTypeToName()
//
// Map the service startup type to a null-terminated string.
// -1L is blank string
//
LPCTSTR
Service_PszMapStartupTypeToName(DWORD dwStartupType)
{
switch(dwStartupType)
{
case SERVICE_BOOT_START:
return g_strSvcStartupBoot;
case SERVICE_SYSTEM_START:
return g_strSvcStartupSystem;
case SERVICE_AUTO_START:
return g_strSvcStartupAutomatic;
case SERVICE_DEMAND_START:
return g_strSvcStartupManual;
case SERVICE_DISABLED :
return g_strSvcStartupDisabled;
case -1L:
return L"";
default:
ASSERT(FALSE);
}
return g_strUnknown;
} // Service_PszMapStartupTypeToName()
/////////////////////////////////////////////////////////////////////
// Service_PszMapStartupAccountToName()
//
// Map the service startup account to a null-terminated string.
//
// Note that if they use the localized version of the two special
// accounts, I just won't pick that up. JSchwart and I agree that
// this should be acceptable.
//
// JonN 188203 11/13/00
// Services Snapin: Should support NetworkService and LocalService account
//
LPCTSTR
Service_PszMapStartupAccountToName(LPCTSTR pcszStartupAccount)
{
if ( !pcszStartupAccount || !*pcszStartupAccount )
return g_strLocalSystem;
else if ( !_wcsicmp(pcszStartupAccount,TEXT("NT AUTHORITY\\LocalService")) )
return g_strLocalService;
else if ( !_wcsicmp(pcszStartupAccount,TEXT("NT AUTHORITY\\NetworkService")) )
return g_strNetworkService;
return pcszStartupAccount;
} // Service_PszMapStartupAccountToName()
/////////////////////////////////////////////////////////////////////
// Service_FGetServiceButtonStatus()
//
// Query the service control manager database and fill in
// array of flags indicating if the action is enabled.
// rgfEnableButton[0] = TRUE; => Button 'start' is enabled
// rgfEnableButton[0] = FALSE; => Button 'start' is disabled
//
// INTERFACE NOTES
// The length of the array must be length iServiceActionMax (or larger).
// Each representing start, stop, pause, resume and restart respectively.
//
// Return TRUE if the service status was queried successfully, otherwise FALSE.
//
BOOL
Service_FGetServiceButtonStatus(
SC_HANDLE hScManager, // IN: Handle of service control manager database
CONST TCHAR * pszServiceName, // IN: Name of service
BOOL rgfEnableButton[iServiceActionMax], // OUT: Array of flags to enable the buttons
DWORD * pdwCurrentState, // OUT: Optional: Current state of service
BOOL fSilentError) // IN: TRUE => Do not display any error message to user
{
Endorse(hScManager == NULL);
Assert(pszServiceName != NULL);
Assert(rgfEnableButton != NULL);
Endorse(pdwCurrentState == NULL);
// Open service to get its status
BOOL fSuccess = TRUE;
SC_HANDLE hService;
SERVICE_STATUS ss;
QUERY_SERVICE_CONFIG qsc;
DWORD cbBytesNeeded;
DWORD dwErr;
::ZeroMemory(OUT rgfEnableButton, iServiceActionMax * sizeof(BOOL));
if (pdwCurrentState != NULL)
*pdwCurrentState = 0;
if (hScManager == NULL || pszServiceName[0] == '\0')
return FALSE;
hService = ::OpenService(
hScManager,
pszServiceName,
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG);
if (hService == NULL)
{
dwErr = ::GetLastError();
Assert(dwErr != ERROR_SUCCESS);
TRACE2("Failed to open service %s. err=%u.\n",
pszServiceName, dwErr);
if (!fSilentError)
DoServicesErrMsgBox(::GetActiveWindow(), MB_OK | MB_ICONEXCLAMATION, dwErr);
return FALSE;
}
if (!::QueryServiceStatus(hService, OUT &ss))
{
dwErr = ::GetLastError();
Assert(dwErr != ERROR_SUCCESS);
TRACE2("::QueryServiceStatus(Service=%s) failed. err=%u.\n",
pszServiceName, dwErr);
if (!fSilentError)
DoServicesErrMsgBox(::GetActiveWindow(), MB_OK | MB_ICONEXCLAMATION, dwErr);
fSuccess = FALSE;
}
else
{
// Determine which menu items should be grayed
if (pdwCurrentState != NULL)
*pdwCurrentState = ss.dwCurrentState;
switch (ss.dwCurrentState)
{
default:
Assert(FALSE && "Illegal service status state.");
case SERVICE_START_PENDING:
case SERVICE_STOP_PENDING:
case SERVICE_PAUSE_PENDING:
case SERVICE_CONTINUE_PENDING:
break;
case SERVICE_STOPPED:
qsc.dwStartType = (DWORD)-1;
(void)::QueryServiceConfig(
hService,
OUT &qsc,
sizeof(qsc),
OUT IGNORED &cbBytesNeeded);
Report(qsc.dwStartType != (DWORD)-1);
if (qsc.dwStartType != SERVICE_DISABLED)
{
rgfEnableButton[iServiceActionStart] = TRUE; // Enable 'Start' menu item
}
break;
case SERVICE_RUNNING:
// Some services are not allowed to be stoped and/or paused
if (ss.dwControlsAccepted & SERVICE_ACCEPT_STOP)
{
rgfEnableButton[iServiceActionStop] = TRUE; // Enable 'Stop' menu item
}
if (ss.dwControlsAccepted & SERVICE_ACCEPT_PAUSE_CONTINUE)
{
rgfEnableButton[iServiceActionPause] = TRUE; // Enable 'Pause' menu item
}
break;
case SERVICE_PAUSED:
if (ss.dwControlsAccepted & SERVICE_ACCEPT_STOP)
{
rgfEnableButton[iServiceActionStop] = TRUE; // Enable 'Stop' menu item
}
rgfEnableButton[iServiceActionResume] = TRUE; // Enable 'Resume' menu item
break;
} // switch
} // if...else
// A 'Restart' has the same characteristics as a 'Stop'
rgfEnableButton[iServiceActionRestart] = rgfEnableButton[iServiceActionStop];
(void)::CloseServiceHandle(hService);
return fSuccess;
} // Service_FGetServiceButtonStatus()
/////////////////////////////////////////////////////////////////////
// Service_SplitCommandLine()
//
// Split a string into two strings.
// Very similar to PchParseCommandLine() but uses CString objects.
//
void
Service_SplitCommandLine(
LPCTSTR pszFullCommand, // IN: Full command line
CString * pstrBinaryPath, // OUT: Path of the executable binary
CString * pstrParameters, // OUT: Parameters for the executable
BOOL * pfAbend) // OUT: Optional: Search for string "/fail=%1%"
{
Assert(pszFullCommand != NULL);
Assert(pstrBinaryPath != NULL);
Assert(pstrParameters != NULL);
Endorse(pfAbend == NULL);
// Since there is no upper bound on the command
// arguments, we need to allocate memory for
// its processing.
TCHAR * paszCommandT; // Temporary buffer
TCHAR * pszCommandArguments;
INT cchMemAlloc; // Number of bytes to allocate
cchMemAlloc = lstrlen(pszFullCommand) + 1;
paszCommandT = new TCHAR[cchMemAlloc];
paszCommandT[0] = '\0'; // Just in case
pszCommandArguments = PchParseCommandLine(
IN pszFullCommand,
OUT paszCommandT,
cchMemAlloc);
*pstrBinaryPath = paszCommandT;
if (pfAbend != NULL)
{
INT cStringSubstitutions; // Number of string substitutions
// Find out if the string contains "/fail=%1%"
cStringSubstitutions = Str_SubstituteStrStr(
OUT pszCommandArguments,
IN pszCommandArguments,
IN szAbend,
L"");
Report((cStringSubstitutions == 0 || cStringSubstitutions == 1) &&
"INFO: Multiple substitutions will be consolidated.");
*pfAbend = cStringSubstitutions != 0;
}
*pstrParameters = pszCommandArguments;
TrimString(*pstrParameters);
delete paszCommandT;
} // Service_SplitCommandLine()
/////////////////////////////////////////////////////////////////////
// Service_UnSplitCommandLine()
//
// Just do the opposite of Service_SplitCommandLine().
// Combine the executable path and its arguments into a single string.
//
void
Service_UnSplitCommandLine(
CString * pstrFullCommand, // OUT: Full command line
LPCTSTR pszBinaryPath, // IN: Path of the executable binary
LPCTSTR pszParameters) // IN: Parameters for the executable
{
Assert(pstrFullCommand != NULL);
Assert(pszBinaryPath != NULL);
Assert(pszParameters != NULL);
TCHAR * psz;
psz = pstrFullCommand->GetBuffer(lstrlen(pszBinaryPath) + lstrlen(pszParameters) + 32);
// Build a string with the binary path surrounded by quotes
wsprintf(OUT psz, L"\"%s\" %s", pszBinaryPath, pszParameters);
pstrFullCommand->ReleaseBuffer();
} // Service_UnSplitCommandLine()
/////////////////////////////////////////////////////////////////////
// LoadSystemString()
//
// Load a string from system's resources. This function will check if
// the string Id can be located in netmsg.dll before attempting to
// load the string from the 'system resource'.
// If string cannot be loaded, *ppaszBuffer is set to NULL.
//
// RETURN
// Pointer to allocated string and number of characters put
// into *ppaszBuffer.
//
// INTERFACE NOTES
// Caller must call LocalFree(*ppaszBuffer) when done with the string.
//
// HISTORY
// 96.10.21 t-danmo Copied from net\ui\common\src\string\string\strload.cxx.
//
DWORD
LoadSystemString(
UINT wIdString, // IN: String Id. Typically error code from GetLastError().
LPTSTR * ppaszBuffer) // OUT: Address of pointer to allocated string.
{
Assert(ppaszBuffer != NULL);
UINT cch;
HMODULE hModule = NULL;
DWORD dwFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_IGNORE_INSERTS |
FORMAT_MESSAGE_MAX_WIDTH_MASK;
if ((wIdString >= MIN_LANMAN_MESSAGE_ID) && (wIdString <= MAX_LANMAN_MESSAGE_ID))
{
// Network Errors
dwFlags |= FORMAT_MESSAGE_FROM_HMODULE;
hModule = ::LoadLibrary(_T("netmsg.dll"));
if (hModule == NULL)
{
TRACE1("LoadLibrary(\"netmsg.dll\") failed. err=%u.\n", GetLastError());
Report("Unable to get module handle for netmsg.dll");
}
}
else
{
// Other system errors
dwFlags |= FORMAT_MESSAGE_FROM_SYSTEM;
}
*ppaszBuffer = NULL; // Just in case
cch = ::FormatMessage(
dwFlags,
hModule,
wIdString,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
OUT (LPTSTR)ppaszBuffer, // Buffer will be allocated by FormatMessage()
0,
NULL);
Report((cch > 0) && "FormatMessage() returned an empty string");
if (hModule != NULL)
{
VERIFY(FreeLibrary(hModule));
}
return cch;
} // LoadSystemString()
/////////////////////////////////////////////////////////////////////
// GetMsgHelper()
//
// This function will retrieve the error msg if dwErr is specified,
// load resource string if specified, and format the string with
// the error msg and other optional arguments.
//
//
HRESULT
GetMsgHelper(
OUT CString& strMsg,// OUT: the message
DWORD dwErr, // IN: Error code from GetLastError()
UINT wIdString, // IN: String ID
va_list* parglist // IN: OPTIONAL arguments
)
{
if (!dwErr && !wIdString)
return E_INVALIDARG;
TCHAR *pszMsgResourceString = NULL;
TCHAR *pszT = L"";
//
// retrieve error msg
//
CString strErrorMessage;
if (dwErr != 0)
{
GetErrorMessage(dwErr, strErrorMessage);
pszT = (LPTSTR)(LPCTSTR)strErrorMessage;
}
//
// load string resource, and format it with the error msg and
// other optional arguments
//
if (wIdString == 0)
{
strMsg = pszT;
} else
{
pszMsgResourceString = PaszLoadStringPrintf(wIdString, *parglist);
if (dwErr == 0)
strMsg = pszMsgResourceString;
else if ((HRESULT)dwErr < 0)
LoadStringPrintf(IDS_sus_ERROR_HR, OUT &strMsg, pszMsgResourceString, dwErr, pszT);
else
LoadStringPrintf(IDS_sus_ERROR, OUT &strMsg, pszMsgResourceString, dwErr, pszT);
}
if (pszMsgResourceString)
LocalFree(pszMsgResourceString);
return S_OK;
} // GetMsgHelper()
/////////////////////////////////////////////////////////////////////
// GetMsg()
//
// This function will call GetMsgHelp to retrieve the error msg
// if dwErr is specified, load resource string if specified, and
// format the string with the error msg and other optional arguments.
//
//
void
GetMsg(
OUT CString& strMsg,// OUT: the message
DWORD dwErr, // IN: Error code from GetLastError()
UINT wIdString, // IN: String resource Id
...) // IN: Optional arguments
{
va_list arglist;
va_start(arglist, wIdString);
HRESULT hr = GetMsgHelper(strMsg, dwErr, wIdString, &arglist);
if (FAILED(hr))
strMsg.Format(_T("0x%x"), hr);
va_end(arglist);
} // GetMsg()
/////////////////////////////////////////////////////////////////////
// DoErrMsgBox()
//
// Display a message box for the error code. This function will
// load the error message from the system resource and append
// the optional string (if any)
//
// EXAMPLE
// DoErrMsgBox(GetActiveWindow(), MB_OK, GetLastError(), IDS_s_FILE_READ_ERROR, L"foo.txt");
//
INT
DoErrMsgBoxHelper(
HWND hwndParent, // IN: Parent of the dialog box
UINT uType, // IN: style of message box
DWORD dwErr, // IN: Error code from GetLastError()
UINT wIdString, // IN: String resource Id
bool fServicesSnapin, // IN: Is this filemgmt or svcmgmt?
va_list& arglist) // IN: Optional arguments
{
//
// get string and the error msg
//
CString strMsg;
HRESULT hr = GetMsgHelper(strMsg, dwErr, wIdString, &arglist);
if (FAILED(hr))
strMsg.Format(_T("0x%x"), hr);
//
// Load the caption
//
CString strCaption;
strCaption.LoadString(
(fServicesSnapin) ? IDS_CAPTION_SERVICES : IDS_CAPTION_FILEMGMT);
//
// Display the message.
//
CThemeContextActivator activator;;
return MessageBox(hwndParent, strMsg, strCaption, uType);
} // DoErrMsgBox()
INT
DoErrMsgBox(
HWND hwndParent, // IN: Parent of the dialog box
UINT uType, // IN: style of message box
DWORD dwErr, // IN: Error code from GetLastError()
UINT wIdString, // IN: String resource Id
...) // IN: Optional arguments
{
//
// get string and the error msg
//
va_list arglist;
va_start(arglist, wIdString);
INT retval = DoErrMsgBoxHelper(
hwndParent, uType, dwErr, wIdString, false, arglist );
va_end(arglist);
return retval;
} // DoErrMsgBox()
//
// JonN 3/5/01 4635
// Services Snapin - String length error dialog title shouldn't be "File Service Management"
//
INT
DoServicesErrMsgBox(
HWND hwndParent, // IN: Parent of the dialog box
UINT uType, // IN: style of message box
DWORD dwErr, // IN: Error code from GetLastError()
UINT wIdString, // IN: String resource Id
...) // IN: Optional arguments
{
//
// get string and the error msg
//
va_list arglist;
va_start(arglist, wIdString);
INT retval = DoErrMsgBoxHelper(
hwndParent, uType, dwErr, wIdString, true, arglist );
va_end(arglist);
return retval;
}
//+--------------------------------------------------------------------------
//
// Function: InitObjectPickerForUsers
//
// Synopsis: Call IDsObjectPicker::Initialize with arguments that will
// set it to allow the user to pick one user.
//
// Arguments: [pDsObjectPicker] - object picker interface instance
//
// Returns: Result of calling IDsObjectPicker::Initialize.
//
// History: 10-14-1998 DavidMun Sample code InitObjectPickerForGroups
// 10-14-1998 JonN Changed to InitObjectPickerForUsers
// 11-11-2000 JonN 188203 support LocalService/NetworkService
//
//---------------------------------------------------------------------------
// CODEWORK do I want to allow USER_ENTERED?
HRESULT
InitObjectPickerForUsers(
IDsObjectPicker *pDsObjectPicker,
LPCTSTR pszServerName)
{
//
// Prepare to initialize the object picker.
// Set up the array of scope initializer structures.
//
static const int SCOPE_INIT_COUNT = 5;
DSOP_SCOPE_INIT_INFO aScopeInit[SCOPE_INIT_COUNT];
ZeroMemory(aScopeInit, sizeof(DSOP_SCOPE_INIT_INFO) * SCOPE_INIT_COUNT);
//
// Target computer scope. This adds a "Look In" entry for the
// target computer. Computer scopes are always treated as
// downlevel (i.e., they use the WinNT provider).
//
aScopeInit[0].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
aScopeInit[0].flType = DSOP_SCOPE_TYPE_TARGET_COMPUTER;
aScopeInit[0].flScope = DSOP_SCOPE_FLAG_STARTING_SCOPE
| DSOP_SCOPE_FLAG_WANT_PROVIDER_WINNT;
// JonN 11/14/00 188203 support LocalService/NetworkService
aScopeInit[0].FilterFlags.flDownlevel = DSOP_DOWNLEVEL_FILTER_USERS
| DSOP_DOWNLEVEL_FILTER_LOCAL_SERVICE
| DSOP_DOWNLEVEL_FILTER_NETWORK_SERVICE;
//
// The domain to which the target computer is joined. Note we're
// combining two scope types into flType here for convenience.
//
aScopeInit[1].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
aScopeInit[1].flType = DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN
| DSOP_SCOPE_TYPE_DOWNLEVEL_JOINED_DOMAIN;
aScopeInit[1].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_WINNT;
aScopeInit[1].FilterFlags.Uplevel.flNativeModeOnly =
DSOP_FILTER_USERS;
aScopeInit[1].FilterFlags.Uplevel.flMixedModeOnly =
DSOP_FILTER_USERS;
aScopeInit[1].FilterFlags.flDownlevel =
DSOP_DOWNLEVEL_FILTER_USERS;
//
// The domains in the same forest (enterprise) as the domain to which
// the target machine is joined. Note these can only be DS-aware
//
aScopeInit[2].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
aScopeInit[2].flType = DSOP_SCOPE_TYPE_ENTERPRISE_DOMAIN;
aScopeInit[2].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_WINNT;
aScopeInit[2].FilterFlags.Uplevel.flNativeModeOnly =
DSOP_FILTER_USERS;
aScopeInit[2].FilterFlags.Uplevel.flMixedModeOnly =
DSOP_FILTER_USERS;
//
// Domains external to the enterprise but trusted directly by the
// domain to which the target machine is joined.
//
// If the target machine is joined to an NT4 domain, only the
// external downlevel domain scope applies, and it will cause
// all domains trusted by the joined domain to appear.
//
aScopeInit[3].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
aScopeInit[3].flType = DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN
| DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN;
aScopeInit[3].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_WINNT;
aScopeInit[3].FilterFlags.Uplevel.flNativeModeOnly =
DSOP_FILTER_USERS;
aScopeInit[3].FilterFlags.Uplevel.flMixedModeOnly =
DSOP_FILTER_USERS;
aScopeInit[3].FilterFlags.flDownlevel =
DSOP_DOWNLEVEL_FILTER_USERS;
//
// The Global Catalog
//
aScopeInit[4].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
aScopeInit[4].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_WINNT;
aScopeInit[4].flType = DSOP_SCOPE_TYPE_GLOBAL_CATALOG;
// Only native mode applies to gc scope.
aScopeInit[4].FilterFlags.Uplevel.flNativeModeOnly =
DSOP_FILTER_USERS;
//
// Put the scope init array into the object picker init array
//
DSOP_INIT_INFO InitInfo;
ZeroMemory(&InitInfo, sizeof(InitInfo));
InitInfo.cbSize = sizeof(InitInfo);
//
// The pwzTargetComputer member allows the object picker to be
// retargetted to a different computer. It will behave as if it
// were being run ON THAT COMPUTER.
//
InitInfo.pwzTargetComputer = pszServerName; // NULL == local machine
// InitInfo.pwzTargetComputer = NULL; // NULL == local machine
InitInfo.cDsScopeInfos = SCOPE_INIT_COUNT;
InitInfo.aDsScopeInfos = aScopeInit;
// JonN 11/14/00 188203 support LocalService/NetworkService
static PCWSTR g_pszObjectSid = L"objectSid";
InitInfo.cAttributesToFetch = 1;
InitInfo.apwzAttributeNames = &g_pszObjectSid;
//
// Note object picker makes its own copy of InitInfo. Also note
// that Initialize may be called multiple times, last call wins.
//
HRESULT hr = pDsObjectPicker->Initialize(&InitInfo);
ASSERT( SUCCEEDED(hr) );
return hr;
} // InitObjectPickerForUsers
//+--------------------------------------------------------------------------
//
// Function: ExtractADsPathAndUPN
//
// Synopsis: Retrieve the selected username from the data object
// created by the object picker.
//
// Arguments: [pdo] - data object returned by object picker
//
// History: 10-14-1998 DavidMun Sample code ProcessSelectedObjects
// 10-14-1998 JonN Changed to ExtractADsPath
// 01-25-1999 JonN Added pflScopeType parameter
// 03-16-1999 JonN Changed to ExtractADsPathAndUPN
// 11-14-2000 JonN Added svarrefObjectSid for 188203
//
//---------------------------------------------------------------------------
UINT g_cfDsObjectPicker = RegisterClipboardFormat(CFSTR_DSOP_DS_SELECTION_LIST);
HRESULT
ExtractADsPathAndUPN(
IN IDataObject *pdo,
OUT CString& strrefADsPath,
OUT CString& strrefUPN,
OUT CComVariant& svarrefObjectSid,
OUT ULONG *pflScopeType)
{
if (NULL == pdo)
return E_POINTER;
HRESULT hr = S_OK;
STGMEDIUM stgmedium =
{
TYMED_HGLOBAL,
NULL,
NULL
};
FORMATETC formatetc =
{
(CLIPFORMAT)g_cfDsObjectPicker,
NULL,
DVASPECT_CONTENT,
-1,
TYMED_HGLOBAL
};
bool fGotStgMedium = false;
do
{
hr = pdo->GetData(&formatetc, &stgmedium);
if (FAILED(hr))
{
ASSERT(FALSE);
break;
}
fGotStgMedium = true;
PDS_SELECTION_LIST pDsSelList =
(PDS_SELECTION_LIST) GlobalLock(stgmedium.hGlobal);
if ( NULL == pDsSelList
|| 1 != pDsSelList->cItems
)
{
ASSERT(FALSE);
hr = E_FAIL;
break;
}
DS_SELECTION& sel = pDsSelList->aDsSelection[0];
strrefADsPath = sel.pwzADsPath;
strrefUPN = sel.pwzUPN;
if ( sel.pvarFetchedAttributes )
svarrefObjectSid = sel.pvarFetchedAttributes[0];
if (NULL != pflScopeType)
*pflScopeType = pDsSelList->aDsSelection[0].flScopeType;
GlobalUnlock(stgmedium.hGlobal);
} while (0);
if (fGotStgMedium)
{
ReleaseStgMedium(&stgmedium);
}
return hr;
}
/////////////////////////////////////////////////////////////////////
// UiGetUser()
//
// Invoke a user picker dialog.
//
// Return TRUE iff an account was selected.
//
// HISTORY
// 96.10.12 t-danmo Creation. Inspired from function GetUser() located
// at \nt\private\windows\shell\security\aclui\misc.cpp.
// 96.10.30 t-danmo Added/modified comments.
// 98.03.17 jonn Modified to use User/Group Picker
// 98.10.20 jonn Modified to use updated Object Picker interfaces
//
//+--------------------------------------------------------------------------
//
// Function: ExtractDomainUserString
//
// Synopsis: Converts an ADspath to the format needed by Service Controller
//
// History: 10-14-1998 JonN Created
// 01-25-1999 JonN added flScopeType parameter
//
//---------------------------------------------------------------------------
HRESULT
ExtractDomainUserString(
IN LPCTSTR pwzADsPath,
IN ULONG flScopeType,
IN OUT CString& strrefDomainUser)
{
HRESULT hr = S_OK;
CComPtr<IADsPathname> spIADsPathname;
hr = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER,
IID_IADsPathname, (PVOID *)&spIADsPathname);
RETURN_HR_IF_FAIL;
hr = spIADsPathname->Set( const_cast<LPTSTR>(pwzADsPath), ADS_SETTYPE_FULL );
RETURN_HR_IF_FAIL;
CComBSTR sbstrUser;
hr = spIADsPathname->GetElement( 0, &sbstrUser );
RETURN_HR_IF_FAIL;
CComBSTR sbstrDomain = OLESTR(".");
if (DSOP_SCOPE_TYPE_TARGET_COMPUTER != flScopeType)
{
long lnNumPathElements = 0;
hr = spIADsPathname->GetNumElements( &lnNumPathElements );
RETURN_FALSE_IF_FAIL;
switch (lnNumPathElements)
{
case 1:
hr = spIADsPathname->Retrieve( ADS_FORMAT_SERVER, &sbstrDomain );
RETURN_HR_IF_FAIL;
break;
case 2:
hr = spIADsPathname->GetElement( 1, &sbstrDomain );
RETURN_HR_IF_FAIL;
break;
default:
ASSERT(FALSE);
return E_FAIL;
}
}
strrefDomainUser.Format(L"%s\\%s", sbstrDomain, sbstrUser);
return hr;
} // ExtractDomainUserString
BOOL
UiGetUser(
HWND hwndOwner, // IN: Owner window
BOOL /*fIsContainer*/, // IN: TRUE if invoked for a container
LPCTSTR pszServerName, // IN: Initial target machine name
OUT CString& strrefUser) // IN: Allocated buffer containing the user details
{
HRESULT hr = S_OK;
CComPtr<IDsObjectPicker> spDsObjectPicker;
hr = CoCreateInstance(CLSID_DsObjectPicker, NULL, CLSCTX_INPROC_SERVER,
IID_IDsObjectPicker, (PVOID *)&spDsObjectPicker);
RETURN_FALSE_IF_FAIL;
ASSERT( !!spDsObjectPicker );
hr = InitObjectPickerForUsers(spDsObjectPicker, pszServerName);
RETURN_FALSE_IF_FAIL;
CComPtr<IDataObject> spDataObject;
hr = spDsObjectPicker->InvokeDialog(hwndOwner, &spDataObject);
RETURN_FALSE_IF_FAIL;
if (S_FALSE == hr)
return FALSE; // user cancelled
ASSERT( !!spDataObject );
CString strADsPath;
ULONG flScopeType = DSOP_SCOPE_TYPE_TARGET_COMPUTER;
CComVariant svarObjectSid;
hr = ExtractADsPathAndUPN( spDataObject,
strADsPath,
strrefUser,
svarObjectSid,
&flScopeType );
RETURN_FALSE_IF_FAIL;
// JonN 11/15/00 188203 check for LocalService/NetworkService
if (svarObjectSid.vt == (VT_ARRAY|VT_UI1))
{
PSID pSid = svarObjectSid.parray->pvData;
if ( IsWellKnownSid(pSid, WinLocalServiceSid) )
{
strrefUser = TEXT("NT AUTHORITY\\LocalService");
return TRUE;
}
else if ( IsWellKnownSid(pSid, WinNetworkServiceSid) )
{
strrefUser = TEXT("NT AUTHORITY\\NetworkService");
return TRUE;
}
}
if (strrefUser.IsEmpty())
{
if (strADsPath.IsEmpty())
{
ASSERT(FALSE);
return FALSE;
}
hr = ExtractDomainUserString( strADsPath, flScopeType, strrefUser );
RETURN_FALSE_IF_FAIL;
}
return TRUE;
} // UiGetUser()
/////////////////////////////////////////////////////////////////////
// DoHelp()
//
// This routine handles context help for the WM_HELP message.
//
// The return value is always TRUE.
//
BOOL DoHelp(
LPARAM lParam, // Pointer to HELPINFO structure
const DWORD rgzHelpIDs[]) // Array of HelpIDs
{
Assert(rgzHelpIDs != NULL);
const LPHELPINFO pHelpInfo = (LPHELPINFO)lParam;
if (pHelpInfo != NULL)
{
if (pHelpInfo->iContextType == HELPINFO_WINDOW)
{
const HWND hwnd = (HWND)pHelpInfo->hItemHandle;
Assert(IsWindow(hwnd));
// Display context help for a control
WinHelp(
hwnd,
g_szHelpFileFilemgmt,
HELP_WM_HELP,
(DWORD_PTR)rgzHelpIDs);
}
}
return TRUE;
} // DoHelp()
/////////////////////////////////////////////////////////////////////
// DoContextHelp()
//
// This routine handles context help for the WM_CONTEXTMENU message.
//
// The return value is always TRUE.
//
BOOL DoContextHelp(
WPARAM wParam, // Window requesting help
const DWORD rgzHelpIDs[]) // Array of HelpIDs
{
const HWND hwnd = (HWND)wParam;
Assert(IsWindow(hwnd));
Assert(rgzHelpIDs != NULL);
WinHelp(hwnd, g_szHelpFileFilemgmt, HELP_CONTEXTMENU, (DWORD_PTR)rgzHelpIDs);
return TRUE;
} // DoContextHelp()