1858 lines
50 KiB
C
1858 lines
50 KiB
C
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
clasprop.c
|
|
|
|
Abstract:
|
|
|
|
Routines for the following 'built-in' class property page providers:
|
|
|
|
CDROM
|
|
DiskDrive
|
|
TapeDrive
|
|
LegacyDriver
|
|
|
|
Author:
|
|
|
|
Lonny McMichael 15-May-1997
|
|
|
|
--*/
|
|
|
|
|
|
#include "setupp.h"
|
|
#pragma hdrstop
|
|
#include <help.h>
|
|
|
|
//
|
|
// Help Ids for legacy driver property page
|
|
//
|
|
#define idh_devmgr_driver_hidden_servicename 2480
|
|
#define idh_devmgr_driver_hidden_displayname 2481
|
|
#define idh_devmgr_driver_hidden_status 2482
|
|
#define idh_devmgr_driver_hidden_startbut 2483
|
|
#define idh_devmgr_driver_hidden_stopbut 2484
|
|
#define idh_devmgr_driver_hidden_startup 2485
|
|
#define idh_devmgr_devdrv_details 400400
|
|
#define idh_devmgr_driver_copyright 106130
|
|
#define idh_devmgr_driver_driver_files 106100
|
|
#define idh_devmgr_driver_provider 106110
|
|
#define idh_devmgr_driver_file_version 106120
|
|
|
|
const DWORD LegacyDriver_HelpIDs[]=
|
|
{
|
|
IDC_STATIC_SERVICE_NAME, idh_devmgr_driver_hidden_servicename,
|
|
IDC_EDIT_SERVICE_NAME, idh_devmgr_driver_hidden_servicename,
|
|
IDC_STATIC_DISPLAY_NAME, idh_devmgr_driver_hidden_displayname,
|
|
IDC_EDIT_DISPLAY_NAME, idh_devmgr_driver_hidden_displayname,
|
|
IDC_STATIC_CURRENT_STATUS_STATIC, idh_devmgr_driver_hidden_status,
|
|
IDC_STATIC_CURRENT_STATUS, idh_devmgr_driver_hidden_status,
|
|
IDC_BUTTON_START, idh_devmgr_driver_hidden_startbut,
|
|
IDC_BUTTON_STOP, idh_devmgr_driver_hidden_stopbut,
|
|
IDC_COMBO_STARTUP_TYPE, idh_devmgr_driver_hidden_startup,
|
|
IDC_LEGACY_DETAILS, idh_devmgr_devdrv_details,
|
|
IDC_PROP_LEGACY_ICON, NO_HELP,
|
|
IDC_PROP_LEGACY_DESC, NO_HELP,
|
|
IDC_GROUP_CURRENT_STATUS, NO_HELP,
|
|
IDC_GROUP_STARTUP_TYPE, NO_HELP,
|
|
0, 0
|
|
};
|
|
|
|
const DWORD DriverFiles_HelpIDs[]=
|
|
{
|
|
IDC_DRIVERFILES_ICON, NO_HELP,
|
|
IDC_DRIVERFILES_DESC, NO_HELP,
|
|
IDC_DRIVERFILES_FILES, NO_HELP,
|
|
IDC_DRIVERFILES_FILELIST, idh_devmgr_driver_driver_files,
|
|
IDC_DRIVERFILES_TITLE_PROVIDER, idh_devmgr_driver_provider,
|
|
IDC_DRIVERFILES_PROVIDER, idh_devmgr_driver_provider,
|
|
IDC_DRIVERFILES_TITLE_COPYRIGHT,idh_devmgr_driver_copyright,
|
|
IDC_DRIVERFILES_COPYRIGHT, idh_devmgr_driver_copyright,
|
|
IDC_DRIVERFILES_TITLE_VERSION, idh_devmgr_driver_file_version,
|
|
IDC_DRIVERFILES_VERSION, idh_devmgr_driver_file_version,
|
|
0, 0
|
|
};
|
|
|
|
#define SERVICE_BUFFER_SIZE 4096
|
|
#define MAX_SECONDS_UNTIL_TIMEOUT 30
|
|
#define SERVICE_WAIT_TIME 500
|
|
#define WAIT_TIME_SLOT 1
|
|
#define TRIES_COUNT 5
|
|
#define START_LEGACY_DEVICE 0
|
|
#define STOP_LEGACY_DEVICE 1
|
|
|
|
|
|
|
|
//
|
|
// Function definitions
|
|
//
|
|
|
|
BOOL
|
|
CdromPropPageProvider(
|
|
IN PSP_PROPSHEETPAGE_REQUEST PropPageRequest,
|
|
IN LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
//
|
|
// No property pages to add for now
|
|
//
|
|
UNREFERENCED_PARAMETER(PropPageRequest);
|
|
UNREFERENCED_PARAMETER(lpfnAddPropSheetPageProc);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DiskPropPageProvider(
|
|
IN PSP_PROPSHEETPAGE_REQUEST PropPageRequest,
|
|
IN LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
//
|
|
// No property pages to add for now
|
|
//
|
|
UNREFERENCED_PARAMETER(PropPageRequest);
|
|
UNREFERENCED_PARAMETER(lpfnAddPropSheetPageProc);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
TapePropPageProvider(
|
|
IN PSP_PROPSHEETPAGE_REQUEST PropPageRequest,
|
|
IN LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
//
|
|
// No property pages to add for now
|
|
//
|
|
UNREFERENCED_PARAMETER(PropPageRequest);
|
|
UNREFERENCED_PARAMETER(lpfnAddPropSheetPageProc);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Driver Files popup dialog
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
typedef struct _DRIVERFILES_INFO {
|
|
HDEVINFO DeviceInfoSet;
|
|
PSP_DEVINFO_DATA DeviceInfoData;
|
|
} DRIVERFILES_INFO, * PDRIVERFILES_INFO;
|
|
|
|
const TCHAR* tszStringFileInfo = TEXT("StringFileInfo\\%04X%04X\\");
|
|
const TCHAR* tszFileVersion = TEXT("FileVersion");
|
|
const TCHAR* tszLegalCopyright = TEXT("LegalCopyright");
|
|
const TCHAR* tszCompanyName = TEXT("CompanyName");
|
|
const TCHAR* tszTranslation = TEXT("VarFileInfo\\Translation");
|
|
const TCHAR* tszStringFileInfoDefault = TEXT("StringFileInfo\\040904B0\\");
|
|
|
|
BOOL
|
|
GetVersionInfo(
|
|
IN PTSTR FullPathName,
|
|
OUT PTSTR Provider,
|
|
IN ULONG ProviderSize,
|
|
OUT PTSTR Copyright,
|
|
IN ULONG CopyrightSize,
|
|
OUT PTSTR Version,
|
|
IN ULONG VersionSize
|
|
)
|
|
{
|
|
DWORD Size, dwHandle;
|
|
TCHAR str[MAX_PATH];
|
|
TCHAR strStringFileInfo[MAX_PATH];
|
|
PVOID pVerInfo;
|
|
|
|
Size = GetFileVersionInfoSize((LPTSTR)(LPCTSTR)FullPathName, &dwHandle);
|
|
|
|
if (!Size) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if ((pVerInfo = malloc(Size)) != NULL) {
|
|
|
|
if (GetFileVersionInfo((LPTSTR)(LPCTSTR)FullPathName, dwHandle, Size, pVerInfo)) {
|
|
|
|
//
|
|
// get VarFileInfo\Translation
|
|
//
|
|
PVOID pBuffer;
|
|
UINT Len;
|
|
|
|
if (!VerQueryValue(pVerInfo, (LPTSTR)tszTranslation, &pBuffer, &Len))
|
|
{
|
|
lstrcpy(strStringFileInfo, tszStringFileInfoDefault);
|
|
}
|
|
else
|
|
{
|
|
wsprintf(strStringFileInfo, tszStringFileInfo, *((WORD*)pBuffer), *(((WORD*)pBuffer) + 1));
|
|
}
|
|
|
|
lstrcpy(str, strStringFileInfo);
|
|
lstrcat(str, tszFileVersion);
|
|
|
|
if (VerQueryValue(pVerInfo, (LPTSTR)(LPCTSTR)str, &pBuffer, &Len)) {
|
|
|
|
lstrcpyn(Version, (LPTSTR)pBuffer, VersionSize/sizeof(TCHAR));
|
|
Version[(VersionSize-1)/sizeof(TCHAR)] = TEXT('\0');
|
|
|
|
lstrcpy(str, strStringFileInfo);
|
|
lstrcat(str, tszLegalCopyright);
|
|
|
|
if (VerQueryValue(pVerInfo, (LPTSTR)(LPCTSTR)str, &pBuffer, &Len)) {
|
|
|
|
lstrcpyn(Copyright, (LPTSTR)pBuffer, CopyrightSize/sizeof(TCHAR));
|
|
Copyright[(CopyrightSize-1)/sizeof(TCHAR)] = TEXT('\0');
|
|
|
|
lstrcpy(str, strStringFileInfo);
|
|
lstrcat(str, tszCompanyName);
|
|
|
|
if (VerQueryValue(pVerInfo, (LPTSTR)(LPCTSTR)str, &pBuffer, &Len)) {
|
|
|
|
lstrcpyn(Provider, (LPTSTR)pBuffer, ProviderSize/sizeof(TCHAR));
|
|
Provider[(ProviderSize-1)/sizeof(TCHAR)] = TEXT('\0');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(pVerInfo);
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
pDriverFilesGetServiceFilePath(
|
|
HDEVINFO DeviceInfoSet,
|
|
PSP_DEVINFO_DATA DeviceInfoData,
|
|
PTSTR ServiceFilePath,
|
|
ULONG FileSize
|
|
)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
TCHAR ServiceName[MAX_PATH];
|
|
SC_HANDLE hSCManager = NULL;
|
|
SC_HANDLE hSCService = NULL;
|
|
LPQUERY_SERVICE_CONFIG lpqscBuf = NULL;
|
|
DWORD dwBytesNeeded, Size;
|
|
BOOL bComposePathNameFromServiceName = TRUE;
|
|
|
|
ServiceFilePath[0] = TEXT('\0');
|
|
|
|
if (SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
SPDRP_SERVICE,
|
|
NULL,
|
|
(PBYTE)ServiceName,
|
|
sizeof(ServiceName),
|
|
NULL)) {
|
|
|
|
try {
|
|
|
|
//
|
|
// Open the Service Control Manager
|
|
//
|
|
if ((hSCManager = OpenSCManager(NULL, NULL, GENERIC_READ)) != NULL) {
|
|
|
|
//
|
|
// Try to open the service's handle
|
|
//
|
|
if ((hSCService = OpenService(hSCManager, ServiceName, GENERIC_READ)) != NULL) {
|
|
|
|
//
|
|
// Now, attempt to get the configuration
|
|
//
|
|
if ((!QueryServiceConfig(hSCService, NULL, 0, &dwBytesNeeded)) &&
|
|
(ERROR_INSUFFICIENT_BUFFER == GetLastError())) {
|
|
|
|
if ((lpqscBuf = (LPQUERY_SERVICE_CONFIG)malloc(dwBytesNeeded)) != NULL) {
|
|
|
|
if ((QueryServiceConfig(hSCService, lpqscBuf, dwBytesNeeded, &Size)) &&
|
|
(lpqscBuf->lpBinaryPathName[0] != TEXT('\0'))) {
|
|
|
|
if (GetFileAttributes(lpqscBuf->lpBinaryPathName) != 0xFFFFFFFF) {
|
|
|
|
bReturn = TRUE;
|
|
lstrcpyn(ServiceFilePath, lpqscBuf->lpBinaryPathName, FileSize);
|
|
bComposePathNameFromServiceName = FALSE;
|
|
}
|
|
}
|
|
|
|
free(lpqscBuf);
|
|
}
|
|
}
|
|
|
|
CloseServiceHandle(hSCService);
|
|
}
|
|
|
|
CloseServiceHandle(hSCManager);
|
|
}
|
|
|
|
|
|
//
|
|
// If we could not get the path name from the service then we will attempt
|
|
// to find it ourselves
|
|
//
|
|
if (bComposePathNameFromServiceName) {
|
|
|
|
TCHAR FullPathName[MAX_PATH + 1];
|
|
TCHAR SysDir[MAX_PATH + 1];
|
|
GetSystemDirectory(SysDir, sizeof(SysDir)/sizeof(SysDir[0]));
|
|
lstrcpy(FullPathName, SysDir);
|
|
lstrcat(FullPathName, TEXT("\\drivers\\"));
|
|
lstrcat(FullPathName, ServiceName);
|
|
lstrcat(FullPathName, TEXT(".sys"));
|
|
|
|
if (GetFileAttributes(FullPathName) != 0xFFFFFFFF) {
|
|
|
|
bReturn = TRUE;
|
|
lstrcpyn(ServiceFilePath, FullPathName, FileSize);
|
|
}
|
|
}
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
;
|
|
}
|
|
}
|
|
|
|
return(bReturn);
|
|
}
|
|
|
|
void
|
|
DriverFiles_ShowFileDetail(
|
|
HWND hDlg
|
|
)
|
|
{
|
|
TCHAR DriverFile[MAX_PATH];
|
|
TCHAR Provider[MAX_PATH];
|
|
TCHAR Copyright[MAX_PATH];
|
|
TCHAR Version[MAX_PATH];
|
|
DWORD_PTR Index;
|
|
|
|
if ((Index = SendMessage(GetDlgItem(hDlg, IDC_DRIVERFILES_FILELIST), LB_GETCURSEL, 0, 0)) != LB_ERR) {
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_DRIVERFILES_FILELIST), LB_GETTEXT, Index, (LPARAM)DriverFile);
|
|
|
|
Provider[0] = TEXT('\0');
|
|
Copyright[0] = TEXT('\0');
|
|
Version[0] = TEXT('\0');
|
|
|
|
GetVersionInfo(DriverFile,
|
|
Provider,
|
|
sizeof(Provider),
|
|
Copyright,
|
|
sizeof(Copyright),
|
|
Version,
|
|
sizeof(Version));
|
|
|
|
if (Provider[0] != TEXT('\0')) {
|
|
|
|
SetDlgItemText(hDlg, IDC_DRIVERFILES_PROVIDER, Provider);
|
|
}
|
|
|
|
if (Version[0] != TEXT('\0')) {
|
|
|
|
SetDlgItemText(hDlg, IDC_DRIVERFILES_VERSION, Version);
|
|
}
|
|
|
|
if (Copyright[0] != TEXT('\0')) {
|
|
|
|
SetDlgItemText(hDlg, IDC_DRIVERFILES_COPYRIGHT, Copyright);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
DriverFiles_OnInitDialog(
|
|
HWND hDlg,
|
|
HWND FocusHwnd,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
PDRIVERFILES_INFO dfi = (PDRIVERFILES_INFO) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
HICON ClassIcon;
|
|
HICON OldIcon;
|
|
TCHAR DeviceDescription[MAX_DEVICE_ID_LEN];
|
|
TCHAR DriverName[MAX_PATH];
|
|
|
|
dfi = (PDRIVERFILES_INFO)lParam;
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (ULONG_PTR)dfi);
|
|
|
|
//
|
|
// Draw the interface: first the icon
|
|
//
|
|
if (SetupDiLoadClassIcon(&dfi->DeviceInfoData->ClassGuid, &ClassIcon, NULL)) {
|
|
|
|
OldIcon = (HICON)SendDlgItemMessage(hDlg,
|
|
IDC_DRIVERFILES_ICON,
|
|
STM_SETICON,
|
|
(WPARAM)ClassIcon,
|
|
0);
|
|
if (OldIcon) {
|
|
|
|
DestroyIcon(OldIcon);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Then the device name
|
|
//
|
|
if (SetupDiGetDeviceRegistryProperty(dfi->DeviceInfoSet,
|
|
dfi->DeviceInfoData,
|
|
SPDRP_DEVICEDESC,
|
|
NULL,
|
|
(PBYTE)DeviceDescription,
|
|
MAX_DEVICE_ID_LEN,
|
|
NULL)) {
|
|
|
|
SetDlgItemText(hDlg, IDC_DRIVERFILES_DESC, DeviceDescription);
|
|
}
|
|
|
|
if ((pDriverFilesGetServiceFilePath(dfi->DeviceInfoSet, dfi->DeviceInfoData, DriverName, (sizeof(DriverName)/sizeof(DriverName[0])))) &&
|
|
(DriverName[0] != TEXT('\0'))) {
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_DRIVERFILES_FILELIST), LB_ADDSTRING, 0, (LPARAM)DriverName);
|
|
}
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_DRIVERFILES_FILELIST), LB_SETCURSEL, 0, 0);
|
|
DriverFiles_ShowFileDetail(hDlg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
DriverFiles_OnContextMenu(
|
|
HWND HwndControl,
|
|
WORD Xpos,
|
|
WORD Ypos
|
|
)
|
|
{
|
|
WinHelp(HwndControl,
|
|
L"devmgr.hlp",
|
|
HELP_CONTEXTMENU,
|
|
(ULONG_PTR) DriverFiles_HelpIDs);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
DriverFiles_OnHelp(
|
|
HWND ParentHwnd,
|
|
LPHELPINFO HelpInfo
|
|
)
|
|
{
|
|
if (HelpInfo->iContextType == HELPINFO_WINDOW) {
|
|
WinHelp((HWND) HelpInfo->hItemHandle,
|
|
L"devmgr.hlp",
|
|
HELP_WM_HELP,
|
|
(ULONG_PTR) DriverFiles_HelpIDs);
|
|
}
|
|
}
|
|
|
|
void
|
|
DriverFiles_OnCommand(
|
|
HWND hDlg,
|
|
int ControlId,
|
|
HWND ControlHwnd,
|
|
UINT NotifyCode
|
|
)
|
|
{
|
|
|
|
switch (ControlId) {
|
|
|
|
case IDOK:
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, 0);
|
|
break;
|
|
|
|
case IDC_DRIVERFILES_FILELIST:
|
|
if (ControlId == LBN_SELCHANGE) {
|
|
|
|
DriverFiles_ShowFileDetail(hDlg);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
INT_PTR
|
|
APIENTRY
|
|
DriverFiles_DlgProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMessage,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
switch(uMessage) {
|
|
|
|
case WM_INITDIALOG:
|
|
return DriverFiles_OnInitDialog(hDlg, (HWND)wParam, lParam);
|
|
|
|
case WM_COMMAND:
|
|
DriverFiles_OnCommand(hDlg, (int) LOWORD(wParam), (HWND)lParam, (UINT)HIWORD(wParam));
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
EndDialog(hDlg, 0);
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
return DriverFiles_OnContextMenu((HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
|
|
|
case WM_HELP:
|
|
DriverFiles_OnHelp(hDlg, (LPHELPINFO) lParam);
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Legacy Devices property page provider
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
typedef struct _LEGACY_PAGE_INFO {
|
|
HDEVINFO DeviceInfoSet;
|
|
PSP_DEVINFO_DATA DeviceInfoData;
|
|
|
|
SC_HANDLE hSCManager; // Handle to the SC Manager
|
|
SC_HANDLE hService; // The handle to the service
|
|
DWORD dwStartType; // The start type
|
|
SERVICE_STATUS ServiceStatus; // Tells us if the service is started
|
|
TCHAR ServiceName[MAX_DEVICE_ID_LEN];
|
|
TCHAR DisplayName[MAX_PATH];
|
|
DWORD NumDependentServices;
|
|
LPENUM_SERVICE_STATUS pDependentServiceList;
|
|
|
|
} LEGACY_PAGE_INFO, * PLEGACY_PAGE_INFO;
|
|
|
|
BOOL
|
|
DependentServices_OnInitDialog(
|
|
HWND hDlg,
|
|
HWND FocusHwnd,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi;
|
|
HWND hWndListBox;
|
|
DWORD i;
|
|
HICON hicon = NULL;
|
|
|
|
lpi = (PLEGACY_PAGE_INFO)lParam;
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (ULONG_PTR)lpi);
|
|
|
|
if (hicon = LoadIcon(NULL, IDI_WARNING)) {
|
|
SendDlgItemMessage(hDlg, IDC_ICON_WARN_SERVICES, STM_SETICON, (WPARAM)hicon, 0L);
|
|
DestroyIcon(hicon);
|
|
}
|
|
|
|
hWndListBox = GetDlgItem(hDlg, IDC_LIST_SERVICES);
|
|
|
|
for (i=0; i<lpi->NumDependentServices; i++) {
|
|
SendMessage(hWndListBox,
|
|
LB_ADDSTRING,
|
|
0,
|
|
(LPARAM) lpi->pDependentServiceList[i].lpDisplayName
|
|
);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
INT_PTR
|
|
APIENTRY
|
|
DependentServicesDlgProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMessage,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi = (PLEGACY_PAGE_INFO)GetWindowLongPtr(hDlg, DWLP_USER);;
|
|
|
|
switch(uMessage) {
|
|
|
|
case WM_INITDIALOG:
|
|
return DependentServices_OnInitDialog(hDlg, (HWND)wParam, lParam);
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam)) {
|
|
|
|
case IDOK:
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, LOWORD(wParam));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
EndDialog(hDlg, 0);
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int
|
|
pLegacyDriverMapStateToName(
|
|
IN DWORD dwServiceState
|
|
)
|
|
{
|
|
switch(dwServiceState) {
|
|
|
|
case SERVICE_STOPPED:
|
|
return IDS_SVC_STATUS_STOPPED;
|
|
|
|
case SERVICE_STOP_PENDING:
|
|
return IDS_SVC_STATUS_STOPPING;
|
|
|
|
case SERVICE_RUNNING:
|
|
return IDS_SVC_STATUS_STARTED;
|
|
|
|
case SERVICE_START_PENDING:
|
|
return IDS_SVC_STATUS_STARTING;
|
|
|
|
case SERVICE_PAUSED:
|
|
return IDS_SVC_STATUS_PAUSED;
|
|
|
|
case SERVICE_PAUSE_PENDING:
|
|
return IDS_SVC_STATUS_PAUSING;
|
|
|
|
case SERVICE_CONTINUE_PENDING:
|
|
return IDS_SVC_STATUS_RESUMING;
|
|
|
|
default:
|
|
return IDS_SVC_STATUS_UNKNOWN;
|
|
}
|
|
|
|
return IDS_SVC_STATUS_UNKNOWN;
|
|
}
|
|
|
|
VOID
|
|
pLegacyDriverInitializeStartButtons(
|
|
IN HWND hDlg,
|
|
IN LPSERVICE_STATUS ServiceStatus
|
|
)
|
|
{
|
|
//
|
|
// Decide how to paint the two start/stop buttons
|
|
//
|
|
TCHAR szStatus[MAX_PATH];
|
|
|
|
//
|
|
// Set the status text
|
|
//
|
|
if (LoadString(MyModuleHandle,
|
|
pLegacyDriverMapStateToName(ServiceStatus->dwCurrentState),
|
|
szStatus,
|
|
MAX_PATH)) {
|
|
|
|
SetDlgItemText(hDlg, IDC_STATIC_CURRENT_STATUS, szStatus);
|
|
}
|
|
|
|
//
|
|
// Decide if the service is started or stopped
|
|
//
|
|
if ((ServiceStatus->dwCurrentState == SERVICE_STOPPED) ) {
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_START), TRUE);
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_STOP), FALSE);
|
|
|
|
} else {
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_STOP), TRUE);
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_START), FALSE);
|
|
}
|
|
|
|
//
|
|
// If the service doesn't accept stops, grey the stop
|
|
// button
|
|
//
|
|
if (!(ServiceStatus->dwControlsAccepted & SERVICE_ACCEPT_STOP)) {
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_STOP), FALSE);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
pLegacyDriverSetPropertyPageState(
|
|
IN HWND hDlg,
|
|
IN PLEGACY_PAGE_INFO lpi,
|
|
IN BOOL ReadOnly
|
|
)
|
|
{
|
|
DWORD_PTR Index;
|
|
DWORD_PTR ServiceStartType;
|
|
TCHAR szStatus[MAX_PATH];
|
|
|
|
if (ReadOnly) {
|
|
|
|
//
|
|
// Disable everything
|
|
//
|
|
EnableWindow(GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE), FALSE);
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_START), FALSE);
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_STOP), FALSE);
|
|
|
|
//
|
|
// Set the status text
|
|
//
|
|
if (LoadString(MyModuleHandle,
|
|
pLegacyDriverMapStateToName(lpi->ServiceStatus.dwCurrentState),
|
|
szStatus,
|
|
MAX_PATH)) {
|
|
|
|
SetDlgItemText(hDlg, IDC_STATIC_CURRENT_STATUS, szStatus);
|
|
}
|
|
|
|
} else {
|
|
|
|
Index = 0;
|
|
|
|
while ((ServiceStartType = SendMessage(GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE),
|
|
CB_GETITEMDATA, Index, 0)) != CB_ERR) {
|
|
|
|
if (ServiceStartType == lpi->dwStartType) {
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE), CB_SETCURSEL, Index, 0);
|
|
break;
|
|
}
|
|
|
|
Index++;
|
|
}
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE), CB_GETCURSEL, 0, 0);
|
|
|
|
//
|
|
// If the start type is SERVICE_DISABLED then gray out both the start
|
|
// and stop buttons.
|
|
//
|
|
if (lpi->dwStartType == SERVICE_DISABLED) {
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_START), FALSE);
|
|
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_STOP), FALSE);
|
|
|
|
//
|
|
// Set the status text
|
|
//
|
|
if (LoadString(MyModuleHandle,
|
|
pLegacyDriverMapStateToName(lpi->ServiceStatus.dwCurrentState),
|
|
szStatus,
|
|
MAX_PATH)) {
|
|
|
|
SetDlgItemText(hDlg, IDC_STATIC_CURRENT_STATUS, szStatus);
|
|
}
|
|
|
|
} else {
|
|
|
|
pLegacyDriverInitializeStartButtons(hDlg, &lpi->ServiceStatus);
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL
|
|
pLegacyDriverCheckServiceStatus(
|
|
IN SC_HANDLE hService,
|
|
IN OUT LPSERVICE_STATUS ServiceStatus,
|
|
IN USHORT ControlType
|
|
)
|
|
{
|
|
DWORD dwIntendedState;
|
|
DWORD dwCummulateTimeSpent = 0;
|
|
|
|
|
|
if ((ControlType != START_LEGACY_DEVICE) &&
|
|
(ControlType != STOP_LEGACY_DEVICE)) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (ControlType == START_LEGACY_DEVICE) {
|
|
dwIntendedState = SERVICE_RUNNING;
|
|
|
|
} else {
|
|
dwIntendedState = SERVICE_STOPPED;
|
|
}
|
|
|
|
|
|
if (!QueryServiceStatus(hService, ServiceStatus)) {
|
|
return FALSE;
|
|
}
|
|
|
|
while (ServiceStatus->dwCurrentState != dwIntendedState) {
|
|
|
|
//
|
|
// Wait for the specified interval
|
|
//
|
|
Sleep(SERVICE_WAIT_TIME);
|
|
|
|
//
|
|
// Check the status again
|
|
//
|
|
if (!QueryServiceStatus(hService, ServiceStatus)) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// OK, add a (generous) timeout here
|
|
//
|
|
dwCummulateTimeSpent += SERVICE_WAIT_TIME;
|
|
if (dwCummulateTimeSpent > 1000 * MAX_SECONDS_UNTIL_TIMEOUT) {
|
|
SetLastError(ERROR_SERVICE_REQUEST_TIMEOUT);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we are here we can return only TRUE
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
VOID
|
|
pLegacyDriverDisplayErrorMsgBox(
|
|
IN HWND hWnd,
|
|
IN LPTSTR ServiceName,
|
|
IN int ResId,
|
|
IN DWORD ErrorCode
|
|
)
|
|
{
|
|
TCHAR TextBuffer[MAX_PATH * 4];
|
|
TCHAR Title[MAX_PATH];
|
|
PTCHAR ErrorMsg;
|
|
|
|
if (LoadString(MyModuleHandle, ResId, TextBuffer, sizeof(TextBuffer)/sizeof(TCHAR))) {
|
|
|
|
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
ErrorCode,
|
|
0,
|
|
(LPTSTR)&ErrorMsg,
|
|
0,
|
|
NULL
|
|
)) {
|
|
|
|
lstrcat(TextBuffer, ErrorMsg);
|
|
MessageBox(hWnd, TextBuffer, ServiceName, MB_OK);
|
|
|
|
LocalFree(ErrorMsg);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
pLegacyDriverOnStart(
|
|
IN HWND hDlg
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi;
|
|
HCURSOR hOldCursor;
|
|
|
|
//
|
|
// Retrieve the device data structure first
|
|
//
|
|
lpi = (PLEGACY_PAGE_INFO)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
try {
|
|
|
|
if (!StartService(lpi->hService,
|
|
0,
|
|
NULL)) {
|
|
|
|
|
|
pLegacyDriverDisplayErrorMsgBox(hDlg,
|
|
lpi->DisplayName,
|
|
IDS_SVC_START_ERROR,
|
|
GetLastError()
|
|
);
|
|
goto clean0;
|
|
}
|
|
pLegacyDriverCheckServiceStatus(lpi->hService,
|
|
&lpi->ServiceStatus,
|
|
START_LEGACY_DEVICE
|
|
);
|
|
|
|
clean0:
|
|
|
|
//
|
|
// Repaint the status part
|
|
//
|
|
pLegacyDriverSetPropertyPageState(hDlg, lpi, FALSE);
|
|
|
|
|
|
}except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
lpi = lpi;
|
|
}
|
|
|
|
SetCursor(hOldCursor);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
pLegacyDriverOnStop(
|
|
IN HWND hDlg
|
|
)
|
|
{
|
|
BOOL bStopServices = TRUE;
|
|
DWORD Err;
|
|
PLEGACY_PAGE_INFO lpi;
|
|
HCURSOR hOldCursor;
|
|
BOOL bSuccess;
|
|
DWORD cbBytesNeeded;
|
|
DWORD dwServicesReturned = 0;
|
|
DWORD i;
|
|
TCHAR DisplayName[MAX_PATH];
|
|
SC_HANDLE hService;
|
|
SERVICE_STATUS ServiceStatus;
|
|
LPENUM_SERVICE_STATUS pDependentServiceList = NULL;
|
|
|
|
//
|
|
// Retrieve the device data structure first
|
|
//
|
|
lpi = (PLEGACY_PAGE_INFO)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
MYASSERT (lpi);
|
|
if (!lpi) {
|
|
return;
|
|
}
|
|
|
|
hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
try {
|
|
|
|
//
|
|
// Find out if this device has any dependent services, and if so then
|
|
// how many bytes are needed to enumerate the dependent services.
|
|
//
|
|
EnumDependentServices(lpi->hService,
|
|
SERVICE_ACTIVE,
|
|
NULL,
|
|
0,
|
|
&cbBytesNeeded,
|
|
&dwServicesReturned
|
|
);
|
|
|
|
if (cbBytesNeeded > 0) {
|
|
pDependentServiceList = (LPENUM_SERVICE_STATUS)malloc(cbBytesNeeded);
|
|
|
|
if (pDependentServiceList) {
|
|
EnumDependentServices(lpi->hService,
|
|
SERVICE_ACTIVE,
|
|
pDependentServiceList,
|
|
cbBytesNeeded,
|
|
&cbBytesNeeded,
|
|
&dwServicesReturned
|
|
);
|
|
|
|
if (dwServicesReturned > 0) {
|
|
//
|
|
// Ask the user if they want to stop these dependet services.
|
|
//
|
|
lpi->NumDependentServices = dwServicesReturned;
|
|
lpi->pDependentServiceList = pDependentServiceList;
|
|
|
|
if (DialogBoxParam(MyModuleHandle,
|
|
MAKEINTRESOURCE(IDD_SERVICE_STOP_DEPENDENCIES),
|
|
hDlg,
|
|
DependentServicesDlgProc,
|
|
(LPARAM)lpi
|
|
) == IDCANCEL) {
|
|
bStopServices = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Stop this service and all the dependent services if the user did
|
|
// not cancel out of the dialog box.
|
|
//
|
|
if (bStopServices) {
|
|
|
|
Err = ERROR_SUCCESS;
|
|
|
|
SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
//
|
|
// First stop all of the dependent services if their are any.
|
|
//
|
|
if (pDependentServiceList && (dwServicesReturned > 0)) {
|
|
for (i=0; i<dwServicesReturned; i++) {
|
|
hService = OpenService(lpi->hSCManager,
|
|
pDependentServiceList[i].lpServiceName,
|
|
GENERIC_READ | SERVICE_STOP
|
|
);
|
|
|
|
if (hService == NULL) {
|
|
//
|
|
// Just bail out if we encountered an error. The reason
|
|
// is that if one of the services cannot be stopped
|
|
// then we won't be able to stop the selected service.
|
|
//
|
|
Err = GetLastError();
|
|
lstrcpy(DisplayName, pDependentServiceList[i].lpServiceName);
|
|
break;
|
|
}
|
|
|
|
if (!ControlService(hService,
|
|
SERVICE_CONTROL_STOP,
|
|
&ServiceStatus
|
|
)) {
|
|
Err = GetLastError();
|
|
lstrcpy(DisplayName, pDependentServiceList[i].lpServiceName);
|
|
CloseServiceHandle(hService);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Wait for the service to actually stop.
|
|
//
|
|
if (!pLegacyDriverCheckServiceStatus(hService,
|
|
&ServiceStatus,
|
|
STOP_LEGACY_DEVICE
|
|
)) {
|
|
Err = GetLastError();
|
|
lstrcpy(DisplayName, pDependentServiceList[i].lpServiceName);
|
|
CloseServiceHandle(hService);
|
|
break;
|
|
}
|
|
|
|
CloseServiceHandle(hService);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Only attempt to stop the selected service if all of the dependent
|
|
// services were stoped.
|
|
//
|
|
if (Err == ERROR_SUCCESS) {
|
|
//
|
|
// Tell the service to stop.
|
|
//
|
|
if (!ControlService(lpi->hService,
|
|
SERVICE_CONTROL_STOP,
|
|
&lpi->ServiceStatus)) {
|
|
|
|
Err = GetLastError();
|
|
lstrcpy(DisplayName, lpi->DisplayName);
|
|
|
|
} else {
|
|
//
|
|
// Wait for the service to stop.
|
|
//
|
|
if (!pLegacyDriverCheckServiceStatus(lpi->hService,
|
|
&lpi->ServiceStatus,
|
|
STOP_LEGACY_DEVICE
|
|
)) {
|
|
Err = GetLastError();
|
|
lstrcpy(DisplayName, lpi->DisplayName);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Err != ERROR_SUCCESS) {
|
|
pLegacyDriverDisplayErrorMsgBox(hDlg,
|
|
DisplayName,
|
|
IDS_SVC_STOP_ERROR,
|
|
Err
|
|
);
|
|
}
|
|
|
|
//
|
|
// Repaint the status part
|
|
//
|
|
pLegacyDriverSetPropertyPageState(hDlg, lpi, FALSE);
|
|
}
|
|
|
|
}except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
pDependentServiceList = pDependentServiceList;
|
|
}
|
|
|
|
if (pDependentServiceList) {
|
|
free(pDependentServiceList);
|
|
}
|
|
|
|
SetCursor(hOldCursor);
|
|
|
|
return;
|
|
}
|
|
|
|
PLEGACY_PAGE_INFO
|
|
LegacyDriver_CreatePageInfo(
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi = (PLEGACY_PAGE_INFO) MyMalloc(sizeof(LEGACY_PAGE_INFO));
|
|
|
|
if (!lpi) {
|
|
return NULL;
|
|
}
|
|
|
|
lpi->DeviceInfoSet = DeviceInfoSet;
|
|
lpi->DeviceInfoData = DeviceInfoData;
|
|
|
|
return lpi;
|
|
}
|
|
|
|
VOID
|
|
LegacyDriver_OnApply(
|
|
IN HWND hDlg,
|
|
IN DWORD StartType
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi;
|
|
SC_LOCK sclLock = NULL;
|
|
USHORT uCount = 0;
|
|
LPQUERY_SERVICE_CONFIG lpqscBuf = NULL;
|
|
DWORD dwBytesNeeded;
|
|
|
|
//
|
|
// Retrieve the device data structure first
|
|
//
|
|
lpi = (PLEGACY_PAGE_INFO)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
try {
|
|
|
|
//
|
|
// Decide if we need to make any changes
|
|
//
|
|
if ((StartType == lpi->dwStartType) &&
|
|
(StartType != SERVICE_DEMAND_START)) {
|
|
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// I guess we need to make some changes here and there...
|
|
// Get the database lock first.
|
|
//
|
|
do {
|
|
|
|
sclLock = LockServiceDatabase(lpi->hSCManager);
|
|
|
|
if (sclLock == NULL) {
|
|
|
|
//
|
|
// If there is another error then the database locked by
|
|
// another process, bail out
|
|
//
|
|
if (GetLastError() != ERROR_SERVICE_DATABASE_LOCKED) {
|
|
|
|
goto clean0;
|
|
|
|
} else {
|
|
|
|
//
|
|
// (Busy) wait and try again
|
|
//
|
|
Sleep (1000 * WAIT_TIME_SLOT);
|
|
uCount++;
|
|
}
|
|
}
|
|
|
|
} while ((uCount < TRIES_COUNT) && (sclLock == NULL));
|
|
|
|
if (sclLock == NULL) {
|
|
|
|
//
|
|
// Bail out now, we waited enough
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// I have the lock. Hurry and query, then change the config
|
|
//
|
|
//
|
|
// Now, attempt to get the configuration
|
|
//
|
|
if ((lpqscBuf = (LPQUERY_SERVICE_CONFIG)malloc(SERVICE_BUFFER_SIZE)) == NULL) {
|
|
|
|
//
|
|
// We're out of here
|
|
//
|
|
goto clean0;
|
|
|
|
}
|
|
|
|
|
|
if (!QueryServiceConfig(lpi->hService,
|
|
lpqscBuf,
|
|
SERVICE_BUFFER_SIZE,
|
|
&dwBytesNeeded
|
|
)) {
|
|
|
|
//
|
|
// Try again with a new buffer
|
|
//
|
|
if ((lpqscBuf = realloc(lpqscBuf, dwBytesNeeded)) == NULL) {
|
|
|
|
//
|
|
// We're out of here
|
|
//
|
|
goto clean0;
|
|
|
|
}
|
|
|
|
if (!QueryServiceConfig(lpi->hService,
|
|
lpqscBuf,
|
|
SERVICE_BUFFER_SIZE,
|
|
&dwBytesNeeded
|
|
)) {
|
|
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Change tye service type (we needed the service name, too,
|
|
// that's why we're querying it first)
|
|
//
|
|
if (ChangeServiceConfig(lpi->hService,
|
|
SERVICE_NO_CHANGE,
|
|
StartType,
|
|
SERVICE_NO_CHANGE,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL)) {
|
|
|
|
//
|
|
// We succesfully changed the status.
|
|
// Reflect in our page display
|
|
//
|
|
lpi->dwStartType = StartType;
|
|
}
|
|
|
|
//
|
|
// Unlock the database
|
|
//
|
|
if (sclLock) {
|
|
|
|
UnlockServiceDatabase(sclLock);
|
|
sclLock = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// We want to see something different on apply, so repaint
|
|
// the whole stuff
|
|
//
|
|
pLegacyDriverSetPropertyPageState(hDlg,
|
|
lpi,
|
|
FALSE); // if we managed to apply some changes
|
|
// we are not read-only
|
|
|
|
clean0:
|
|
|
|
if (sclLock) {
|
|
|
|
UnlockServiceDatabase(sclLock);
|
|
sclLock = NULL;
|
|
}
|
|
|
|
if (lpqscBuf) {
|
|
|
|
free(lpqscBuf);
|
|
}
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
lpi = lpi;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
BOOL
|
|
LegacyDriver_OnInitDialog(
|
|
HWND hDlg,
|
|
HWND FocusHwnd,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi = (PLEGACY_PAGE_INFO) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
BOOL bNoService = FALSE;
|
|
BOOL ReadOnly = FALSE;
|
|
HICON ClassIcon;
|
|
HICON OldIcon;
|
|
TCHAR DeviceDescription[MAX_DEVICE_ID_LEN];
|
|
TCHAR DriverName[MAX_PATH];
|
|
TCHAR StartupType[MAX_PATH];
|
|
DWORD dwBytesNeeded;
|
|
LPQUERY_SERVICE_CONFIG lpqscBuf = NULL;
|
|
DWORD_PTR index;
|
|
HWND hCombo;
|
|
|
|
lpi = (PLEGACY_PAGE_INFO) ((LPPROPSHEETPAGE)lParam)->lParam;
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (ULONG_PTR)lpi);
|
|
|
|
|
|
//
|
|
// First, open the Service Control Manager
|
|
//
|
|
lpi->hSCManager = OpenSCManager(NULL,
|
|
NULL,
|
|
GENERIC_WRITE | GENERIC_READ | GENERIC_EXECUTE);
|
|
|
|
if (!lpi->hSCManager && (GetLastError() == ERROR_ACCESS_DENIED)) {
|
|
|
|
//
|
|
// This is not fatal, attempt to open the database only
|
|
// for read
|
|
//
|
|
ReadOnly = FALSE;
|
|
|
|
lpi->hSCManager = OpenSCManager(NULL,
|
|
NULL,
|
|
GENERIC_READ);
|
|
|
|
if (!lpi->hSCManager) {
|
|
|
|
//
|
|
// This is fatal
|
|
//
|
|
lpi->hSCManager = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now, get the service name
|
|
//
|
|
if (!SetupDiGetDeviceRegistryProperty(lpi->DeviceInfoSet,
|
|
lpi->DeviceInfoData,
|
|
SPDRP_SERVICE,
|
|
NULL,
|
|
(PBYTE)lpi->ServiceName,
|
|
sizeof(lpi->ServiceName),
|
|
NULL)
|
|
) {
|
|
|
|
LoadString(MyModuleHandle, IDS_UNKNOWN, lpi->ServiceName, sizeof(lpi->ServiceName)/sizeof(lpi->ServiceName[0]));
|
|
ReadOnly = TRUE;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Now we have a service name, try to open its handle
|
|
//
|
|
if (!ReadOnly) {
|
|
|
|
lpi->hService = OpenService(lpi->hSCManager,
|
|
lpi->ServiceName,
|
|
GENERIC_WRITE | GENERIC_READ |
|
|
GENERIC_EXECUTE);
|
|
|
|
if (!lpi->hService) {
|
|
|
|
//
|
|
// OK, let them try again
|
|
//
|
|
ReadOnly = TRUE;
|
|
}
|
|
}
|
|
|
|
if (ReadOnly) {
|
|
|
|
lpi->hService = OpenService(lpi->hSCManager,
|
|
lpi->ServiceName,
|
|
GENERIC_READ);
|
|
|
|
if (!lpi->hService) {
|
|
|
|
//
|
|
// Sorry, this is fatal
|
|
//
|
|
ReadOnly = TRUE;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now, attempt to get the configuration
|
|
//
|
|
lpqscBuf = (LPQUERY_SERVICE_CONFIG)malloc(SERVICE_BUFFER_SIZE);
|
|
if (!lpqscBuf) {
|
|
|
|
ReadOnly = TRUE;
|
|
goto clean0;
|
|
}
|
|
|
|
if (!QueryServiceConfig(lpi->hService,
|
|
lpqscBuf,
|
|
SERVICE_BUFFER_SIZE,
|
|
&dwBytesNeeded
|
|
)) {
|
|
//
|
|
// Try again with a new buffer
|
|
//
|
|
if ((lpqscBuf = realloc(lpqscBuf, dwBytesNeeded)) == NULL) {
|
|
|
|
//
|
|
// We're out of here
|
|
//
|
|
ReadOnly = TRUE;
|
|
goto clean0;
|
|
}
|
|
|
|
if (!QueryServiceConfig(lpi->hService,
|
|
lpqscBuf,
|
|
SERVICE_BUFFER_SIZE,
|
|
&dwBytesNeeded
|
|
)) {
|
|
|
|
ReadOnly = TRUE;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We have the buffer now, get the start type from it
|
|
//
|
|
lpi->dwStartType = lpqscBuf->dwStartType;
|
|
|
|
if (!ControlService(lpi->hService,
|
|
SERVICE_CONTROL_INTERROGATE,
|
|
&lpi->ServiceStatus)) {
|
|
|
|
|
|
DWORD Err = GetLastError();
|
|
|
|
//
|
|
// If ControlService failed with one of the following errors then it is OK
|
|
// and the ServiceStatus was still filled in.
|
|
//
|
|
if ((Err != NO_ERROR) &&
|
|
(Err != ERROR_SERVICE_NOT_ACTIVE)) {
|
|
|
|
//
|
|
// Bail out,
|
|
//
|
|
ReadOnly = TRUE;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Add the startup types to the combo box
|
|
//
|
|
hCombo = GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE);
|
|
|
|
LoadString(MyModuleHandle, IDS_SERVICE_STARTUP_AUTOMATIC, StartupType, sizeof(StartupType)/sizeof(StartupType[0]));
|
|
index = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)StartupType);
|
|
SendMessage(hCombo, CB_SETITEMDATA, index, (LPARAM)SERVICE_AUTO_START);
|
|
|
|
LoadString(MyModuleHandle, IDS_SERVICE_STARTUP_BOOT, StartupType, sizeof(StartupType)/sizeof(StartupType[0]));
|
|
index = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)StartupType);
|
|
SendMessage(hCombo, CB_SETITEMDATA, index, (LPARAM)SERVICE_BOOT_START);
|
|
|
|
LoadString(MyModuleHandle, IDS_SERVICE_STARTUP_DEMAND, StartupType, sizeof(StartupType)/sizeof(StartupType[0]));
|
|
index = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)StartupType);
|
|
SendMessage(hCombo, CB_SETITEMDATA, index, (LPARAM)SERVICE_DEMAND_START);
|
|
|
|
LoadString(MyModuleHandle, IDS_SERVICE_STARTUP_SYSTEM, StartupType, sizeof(StartupType)/sizeof(StartupType[0]));
|
|
index = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)StartupType);
|
|
SendMessage(hCombo, CB_SETITEMDATA, index, (LPARAM)SERVICE_SYSTEM_START);
|
|
|
|
LoadString(MyModuleHandle, IDS_SERVICE_STARTUP_DISABLED, StartupType, sizeof(StartupType)/sizeof(StartupType[0]));
|
|
index = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM)StartupType);
|
|
SendMessage(hCombo, CB_SETITEMDATA, index, (LPARAM)SERVICE_DISABLED);
|
|
|
|
clean0:
|
|
|
|
//
|
|
// Now draw the interface: first the icon
|
|
//
|
|
if (SetupDiLoadClassIcon(&lpi->DeviceInfoData->ClassGuid, &ClassIcon, NULL)) {
|
|
|
|
OldIcon = (HICON)SendDlgItemMessage(hDlg,
|
|
IDC_PROP_LEGACY_ICON,
|
|
STM_SETICON,
|
|
(WPARAM)ClassIcon,
|
|
0);
|
|
if (OldIcon) {
|
|
|
|
DestroyIcon(OldIcon);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Then the device name
|
|
//
|
|
if (SetupDiGetDeviceRegistryProperty(lpi->DeviceInfoSet,
|
|
lpi->DeviceInfoData,
|
|
SPDRP_DEVICEDESC,
|
|
NULL,
|
|
(PBYTE)DeviceDescription,
|
|
MAX_DEVICE_ID_LEN,
|
|
NULL)) {
|
|
|
|
SetDlgItemText(hDlg, IDC_PROP_LEGACY_DESC, DeviceDescription);
|
|
}
|
|
|
|
SetDlgItemText(hDlg, IDC_EDIT_SERVICE_NAME, lpi->ServiceName);
|
|
|
|
if (lpqscBuf && lpqscBuf->lpDisplayName) {
|
|
|
|
SetDlgItemText(hDlg, IDC_EDIT_DISPLAY_NAME, lpqscBuf->lpDisplayName);
|
|
lstrcpy(lpi->DisplayName, lpqscBuf->lpDisplayName);
|
|
|
|
} else {
|
|
|
|
TCHAR Unknown[MAX_PATH];
|
|
LoadString(MyModuleHandle, IDS_UNKNOWN, Unknown, sizeof(Unknown)/sizeof(Unknown[0]));
|
|
SetDlgItemText(hDlg, IDC_EDIT_DISPLAY_NAME, Unknown);
|
|
lstrcpy(lpi->DisplayName, Unknown);
|
|
}
|
|
|
|
pLegacyDriverSetPropertyPageState(hDlg, lpi, ReadOnly);
|
|
|
|
//
|
|
// Show/Gray the details button
|
|
//
|
|
EnableWindow(GetDlgItem(hDlg, IDC_LEGACY_DETAILS),
|
|
(pDriverFilesGetServiceFilePath(lpi->DeviceInfoSet, lpi->DeviceInfoData, DriverName, (sizeof(DriverName)/sizeof(DriverName[0])))));
|
|
|
|
|
|
if (lpqscBuf) {
|
|
|
|
free(lpqscBuf);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
LegacyDriver_OnCommand(
|
|
HWND hDlg,
|
|
int ControlId,
|
|
HWND ControlHwnd,
|
|
UINT NotifyCode
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi = (PLEGACY_PAGE_INFO) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
if (NotifyCode == CBN_SELCHANGE) {
|
|
|
|
PropSheet_Changed(GetParent(hDlg), hDlg);
|
|
}
|
|
|
|
else {
|
|
|
|
switch (ControlId) {
|
|
|
|
case IDC_BUTTON_START:
|
|
pLegacyDriverOnStart(hDlg);
|
|
break;
|
|
|
|
case IDC_BUTTON_STOP:
|
|
pLegacyDriverOnStop(hDlg);
|
|
break;
|
|
|
|
case IDC_LEGACY_DETAILS:
|
|
{
|
|
DRIVERFILES_INFO dfi;
|
|
ZeroMemory(&dfi, sizeof(DRIVERFILES_INFO));
|
|
dfi.DeviceInfoSet = lpi->DeviceInfoSet;
|
|
dfi.DeviceInfoData = lpi->DeviceInfoData;
|
|
DialogBoxParam(MyModuleHandle, MAKEINTRESOURCE(IDD_DRIVERFILES),
|
|
hDlg, DriverFiles_DlgProc, (LPARAM)&dfi);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
LegacyDriver_OnNotify(
|
|
HWND hDlg,
|
|
LPNMHDR NmHdr
|
|
)
|
|
{
|
|
DWORD StartType;
|
|
DWORD_PTR Index;
|
|
|
|
switch (NmHdr->code) {
|
|
|
|
//
|
|
// The user is about to change an up down control
|
|
//
|
|
case UDN_DELTAPOS:
|
|
PropSheet_Changed(GetParent(hDlg), hDlg);
|
|
return FALSE;
|
|
|
|
//
|
|
// Sent when the user clicks on Apply OR OK !!
|
|
//
|
|
case PSN_APPLY:
|
|
if (CB_ERR != (Index = SendMessage(GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE),
|
|
CB_GETCURSEL, 0, 0))) {
|
|
|
|
StartType = (DWORD)SendMessage(GetDlgItem(hDlg, IDC_COMBO_STARTUP_TYPE), CB_GETITEMDATA, Index, 0);
|
|
|
|
LegacyDriver_OnApply(hDlg, StartType);
|
|
}
|
|
|
|
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
LegacyDriver_OnContextMenu(
|
|
HWND HwndControl,
|
|
WORD Xpos,
|
|
WORD Ypos
|
|
)
|
|
{
|
|
WinHelp(HwndControl,
|
|
L"devmgr.hlp",
|
|
HELP_CONTEXTMENU,
|
|
(ULONG_PTR) LegacyDriver_HelpIDs);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
LegacyDriver_OnHelp(
|
|
HWND ParentHwnd,
|
|
LPHELPINFO HelpInfo
|
|
)
|
|
{
|
|
if (HelpInfo->iContextType == HELPINFO_WINDOW) {
|
|
WinHelp((HWND) HelpInfo->hItemHandle,
|
|
L"devmgr.hlp",
|
|
HELP_WM_HELP,
|
|
(ULONG_PTR) LegacyDriver_HelpIDs);
|
|
}
|
|
}
|
|
|
|
INT_PTR
|
|
APIENTRY
|
|
LegacyDriver_DlgProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMessage,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
switch(uMessage) {
|
|
|
|
case WM_COMMAND:
|
|
LegacyDriver_OnCommand(hDlg, (int) LOWORD(wParam), (HWND)lParam, (UINT)HIWORD(wParam));
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
return LegacyDriver_OnInitDialog(hDlg, (HWND)wParam, lParam);
|
|
|
|
case WM_NOTIFY:
|
|
return LegacyDriver_OnNotify(hDlg, (NMHDR *)lParam);
|
|
|
|
case WM_CONTEXTMENU:
|
|
return LegacyDriver_OnContextMenu((HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
|
|
|
case WM_HELP:
|
|
LegacyDriver_OnHelp(hDlg, (LPHELPINFO) lParam);
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
LegacyDriver_DestroyPageInfo(
|
|
PLEGACY_PAGE_INFO lpi
|
|
)
|
|
{
|
|
try {
|
|
|
|
//
|
|
// Close the service handle
|
|
//
|
|
if (lpi->hService) {
|
|
|
|
CloseServiceHandle(lpi->hService);
|
|
}
|
|
|
|
//
|
|
// Close the service manager handle
|
|
//
|
|
if (lpi->hSCManager) {
|
|
|
|
CloseServiceHandle(lpi->hSCManager);
|
|
}
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
//
|
|
// Access a variable, so that the compiler will respect our statement
|
|
// order w.r.t. assignment.
|
|
//
|
|
lpi = lpi;
|
|
}
|
|
|
|
MyFree(lpi);
|
|
}
|
|
|
|
UINT CALLBACK
|
|
LegacyDriver_PropPageCallback(
|
|
HWND Hwnd,
|
|
UINT Message,
|
|
LPPROPSHEETPAGE PropSheetPage
|
|
)
|
|
{
|
|
PLEGACY_PAGE_INFO lpi;
|
|
|
|
switch (Message) {
|
|
|
|
case PSPCB_CREATE:
|
|
return TRUE; // return TRUE to continue with creation of page
|
|
|
|
case PSPCB_RELEASE:
|
|
lpi = (PLEGACY_PAGE_INFO) PropSheetPage->lParam;
|
|
LegacyDriver_DestroyPageInfo(lpi);
|
|
return 0; // return value ignored
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
HPROPSHEETPAGE
|
|
LegacyDriver_CreatePropertyPage(
|
|
PROPSHEETPAGE * PropSheetPage,
|
|
PLEGACY_PAGE_INFO lpi
|
|
)
|
|
{
|
|
//
|
|
// Add the Port Settings property page
|
|
//
|
|
PropSheetPage->dwSize = sizeof(PROPSHEETPAGE);
|
|
PropSheetPage->dwFlags = PSP_USECALLBACK;
|
|
PropSheetPage->dwFlags = PSP_DEFAULT;
|
|
PropSheetPage->hInstance = MyModuleHandle;
|
|
PropSheetPage->pszTemplate = MAKEINTRESOURCE(IDD_PROP_LEGACY_SERVICE);
|
|
|
|
//
|
|
// following points to the dlg window proc
|
|
//
|
|
PropSheetPage->pfnDlgProc = LegacyDriver_DlgProc;
|
|
PropSheetPage->lParam = (LPARAM)lpi;
|
|
|
|
//
|
|
// Following points to the control callback of the dlg window proc.
|
|
// The callback gets called before creation/after destruction of the page
|
|
//
|
|
PropSheetPage->pfnCallback = LegacyDriver_PropPageCallback;
|
|
|
|
//
|
|
// Allocate the actual page
|
|
//
|
|
return CreatePropertySheetPage(PropSheetPage);
|
|
}
|
|
|
|
BOOL
|
|
LegacyDriverPropPageProvider(
|
|
LPVOID Info,
|
|
LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
SP_DEVINSTALL_PARAMS DevInstallParams;
|
|
PSP_PROPSHEETPAGE_REQUEST PropPageRequest;
|
|
PROPSHEETPAGE psp;
|
|
HPROPSHEETPAGE hpsp;
|
|
PLEGACY_PAGE_INFO lpi;
|
|
|
|
PropPageRequest = (PSP_PROPSHEETPAGE_REQUEST) Info;
|
|
|
|
if (PropPageRequest->PageRequested == SPPSR_ENUM_ADV_DEVICE_PROPERTIES) {
|
|
|
|
lpi = LegacyDriver_CreatePageInfo(PropPageRequest->DeviceInfoSet, PropPageRequest->DeviceInfoData);
|
|
|
|
if (!lpi) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
hpsp = LegacyDriver_CreatePropertyPage(&psp, lpi);
|
|
|
|
if (!hpsp) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (!lpfnAddPropSheetPageProc(hpsp, lParam)) {
|
|
|
|
DestroyPropertySheetPage(hpsp);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Tell device manager that we will display our own Driver tab for legacy device
|
|
//
|
|
ZeroMemory(&DevInstallParams, sizeof(DevInstallParams));
|
|
DevInstallParams.cbSize = sizeof(DevInstallParams);
|
|
|
|
SetupDiGetDeviceInstallParams(lpi->DeviceInfoSet, lpi->DeviceInfoData, &DevInstallParams);
|
|
|
|
DevInstallParams.Flags |= DI_DRIVERPAGE_ADDED;
|
|
|
|
SetupDiSetDeviceInstallParams(lpi->DeviceInfoSet, lpi->DeviceInfoData, &DevInstallParams);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
EisaUpHalPropPageProvider(
|
|
IN PSP_PROPSHEETPAGE_REQUEST PropPageRequest,
|
|
IN LPFNADDPROPSHEETPAGE AddPageRoutine,
|
|
IN LPARAM AddPageContext
|
|
)
|
|
{
|
|
return (FALSE);
|
|
}
|