1074 lines
34 KiB
C++
1074 lines
34 KiB
C++
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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()
|