static DWORD DoUnregServer(void)
{
static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0};
SC_HANDLE scm, service;
DWORD ret = 0;
if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CONNECT)))
{
fprintf(stderr, "Failed to open service control manager\n");
return 1;
}
if ((service = OpenServiceW(scm, msiserverW, DELETE)))
{
if (!DeleteService(service))
{
fprintf(stderr, "Failed to delete MSI service\n");
ret = 1;
}
CloseServiceHandle(service);
}
else if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
{
fprintf(stderr, "Failed to open MSI service\n");
ret = 1;
}
CloseServiceHandle(scm);
return ret;
}
BOOL
UpdateServiceStatus(ENUM_SERVICE_STATUS_PROCESS* pService)
{
SC_HANDLE hScm;
BOOL bRet = FALSE;
hScm = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ENUMERATE_SERVICE);
if (hScm != NULL)
{
SC_HANDLE hService;
hService = OpenServiceW(hScm,
pService->lpServiceName,
SERVICE_QUERY_STATUS);
if (hService)
{
DWORD size;
QueryServiceStatusEx(hService,
SC_STATUS_PROCESS_INFO,
(LPBYTE)&pService->ServiceStatusProcess,
sizeof(SERVICE_STATUS_PROCESS),
&size);
CloseServiceHandle(hService);
bRet = TRUE;
}
CloseServiceHandle(hScm);
}
return bRet;
}
BOOL DrvCtrl::LoadWdmInf(WCHAR *inf, WCHAR* szDrvSvcName)
{
WCHAR exe[] = L"c:\\windows\\system32\\InfDefaultInstall.exe ";
STARTUPINFOW si = { 0 };
PROCESS_INFORMATION pi = { 0 };
WCHAR *cmd = cs(exe, inf);
if (!CreateProcessW(NULL, cmd, NULL, NULL, 0, 0, NULL, NULL, &si, &pi))
return FALSE;
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
SC_HANDLE hSCM = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
SC_HANDLE hSvcHandle = OpenServiceW(hSCM, szDrvSvcName, SERVICE_ALL_ACCESS);
if (hSvcHandle)
{
CloseServiceHandle(hSCM);
CloseServiceHandle(hSvcHandle);
return TRUE;
}
else
{
CloseServiceHandle(hSCM);
return FALSE;
}
}
BOOL IsStopService(LPCWSTR lpcwszName)
{
BOOL bRet = FALSE;
SC_HANDLE hScm = NULL;
SC_HANDLE hSrv = NULL;
hScm = OpenSCManagerW(0, 0, SC_MANAGER_CONNECT);
if(hScm == NULL){
OutputDebugString(_T("OpenSCManager failed"));
return FALSE;
}
hSrv = OpenServiceW(hScm, lpcwszName, SERVICE_QUERY_STATUS);
if(hSrv == NULL){
OutputDebugString(_T("OpenService failed"));
CloseServiceHandle(hScm);
return FALSE;
}
SERVICE_STATUS stStatus;
if( QueryServiceStatus(hSrv, &stStatus) != FALSE ){
if(stStatus.dwCurrentState == SERVICE_STOPPED){
bRet = TRUE;
}
}else{
OutputDebugString(_T("QueryServiceStatus failed"));
}
CloseServiceHandle(hSrv);
CloseServiceHandle(hScm);
return bRet;
}
void Service::install()
{
// Open service manager
SC_HANDLE pSCM = OpenSCManagerW( nullptr, nullptr,
SC_MANAGER_CREATE_SERVICE );
if ( !pSCM )
EXCEPT_WINAPI( L"Couldn't open service manager" );
// Fetch & escape path, add argument
WCHAR wszPath[MAX_PATH];
if ( !GetModuleFileNameW( nullptr, wszPath, MAX_PATH ) )
EXCEPT_WINAPI( L"Couldn't get module file name" );
PathQuoteSpacesW( wszPath );
wcscat_s( wszPath, MAX_PATH, L" -s" );
// Create service
SC_HANDLE hService = CreateServiceW( pSCM, mName.c_str(),
mDisplayName.c_str(), SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, wszPath, nullptr,
nullptr, nullptr, L"NT AUTHORITY\\NetworkService", nullptr );
if ( !hService )
EXCEPT_WINAPI( L"Couldn't create service" );
// Set description
SERVICE_DESCRIPTIONW descriptor;
descriptor.lpDescription = new WCHAR[mDescription.length()];
wcscpy_s( descriptor.lpDescription, mDescription.length(), mDescription.c_str() );
ChangeServiceConfig2W( hService, SERVICE_CONFIG_DESCRIPTION, &descriptor );
delete[] descriptor.lpDescription;
// Done
CloseServiceHandle( hService );
CloseServiceHandle( pSCM );
}
void Service::uninstall()
{
// Open service manager
SC_HANDLE hSCM = OpenSCManagerW( nullptr, nullptr,
SC_MANAGER_CREATE_SERVICE );
if ( !hSCM )
EXCEPT_WINAPI( L"Couldn't open service manager" );
// Open service for query + deletion
SC_HANDLE hService = OpenServiceW( hSCM, mName.c_str(),
SERVICE_QUERY_STATUS | DELETE );
if ( !hService )
EXCEPT_WINAPI( L"Couldn't open service" );
// Make sure it's stopped
SERVICE_STATUS stStatus;
if ( !QueryServiceStatus( hService, &stStatus ) )
EXCEPT_WINAPI( L"Couldn't query service status" );
if ( stStatus.dwCurrentState != SERVICE_STOPPED )
EXCEPT( L"Cannot uninstall service while it's running" );
// Delete service
if ( !DeleteService( hService ) )
EXCEPT_WINAPI( L"Couldn't delete service" );
// Done
CloseServiceHandle( hService );
CloseServiceHandle( hSCM );
}
static DWORD DoRegServer(void)
{
static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0};
static const WCHAR msiexecW[] = {'\\','m','s','i','e','x','e','c',' ','/','V',0};
SC_HANDLE scm, service;
WCHAR path[MAX_PATH+12];
DWORD len, ret = 0;
if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CREATE_SERVICE)))
{
fprintf(stderr, "Failed to open the service control manager.\n");
return 1;
}
len = GetSystemDirectoryW(path, MAX_PATH);
lstrcpyW(path + len, msiexecW);
if ((service = CreateServiceW(scm, msiserverW, msiserverW, GENERIC_ALL,
SERVICE_WIN32_SHARE_PROCESS, SERVICE_DEMAND_START,
SERVICE_ERROR_NORMAL, path, NULL, NULL, NULL, NULL, NULL)))
{
CloseServiceHandle(service);
}
else if (GetLastError() != ERROR_SERVICE_EXISTS)
{
fprintf(stderr, "Failed to create MSI service\n");
ret = 1;
}
CloseServiceHandle(scm);
return ret;
}
BOOL
UnregisterDriver(LPCWSTR lpDriverName)
{
SC_HANDLE hService;
SC_HANDLE hSCManager;
BOOL bRet;
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (!hSCManager)
return FALSE;
hService = OpenServiceW(hSCManager,
lpDriverName,
SERVICE_ALL_ACCESS);
if (!hService)
{
CloseServiceHandle(hSCManager);
return FALSE;
}
bRet = DeleteService(hService);
CloseServiceHandle(hService);
CloseServiceHandle(hSCManager);
return bRet;
}
static HRESULT register_service(BOOL do_register)
{
static const WCHAR name[] = { 'B','I','T','S', 0 };
static const WCHAR path[] = { 's','v','c','h','o','s','t','.','e','x','e',
' ','-','k',' ','n','e','t','s','v','c','s', 0 };
SC_HANDLE scm, service;
scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (!scm)
return SELFREG_E_CLASS;
if (do_register)
service = CreateServiceW(scm, name, name, SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS,
SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
path, NULL, NULL, NULL, NULL, NULL);
else
service = OpenServiceW(scm, name, DELETE);
CloseServiceHandle(scm);
if (service)
{
if (!do_register) DeleteService(service);
CloseServiceHandle(service);
}
return S_OK;
}
VOID SvcUninstall() {
SC_HANDLE schSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (NULL == schSCManager) {
printf(">> OpenSCManager failed (LastError=0x%x)\n", GetLastError());
goto _ret;
}
SC_HANDLE schService = OpenServiceW(schSCManager, SERVICE_NAME, SERVICE_ALL_ACCESS);
if (schService == NULL) {
DWORD LastError = GetLastError();
if (LastError == ERROR_SERVICE_DOES_NOT_EXIST) printf(">> Service does not exist!\n");
else printf(">> OpenServiceW failed (LastError=0x%x)\n", GetLastError());
goto _close_sc;
}
SERVICE_STATUS ServiceStatus;
if (!ControlService(schService, SERVICE_CONTROL_STOP, &ServiceStatus)) {
DWORD LastError = GetLastError();
if (LastError != ERROR_SERVICE_NOT_ACTIVE) {
printf(">> ControlService(..., SERVICE_STOP, ...) failed (LastError=0x%x)\n", GetLastError());
goto _close_service;
}
}
if (!DeleteService(schService)) {
printf(">> DeleteService failed (LastError=0x%x)\n", GetLastError());
goto _close_service;
}
printf(">> Service uninstalled successfully!\n");
_close_service:
CloseServiceHandle(schService);
_close_sc:
CloseServiceHandle(schSCManager);
_ret:
return;
}
DWORD GetServiceStatus(LPCWSTR lpcwszName)
{
SC_HANDLE hScm = NULL;
SC_HANDLE hSrv = NULL;
SERVICE_STATUS stStatus;
hScm = OpenSCManagerW(0, 0, SC_MANAGER_CONNECT);
if(hScm == NULL){
OutputDebugString(_T("OpenSCManager failed"));
return FALSE;
}
hSrv = OpenServiceW(hScm, lpcwszName, SERVICE_QUERY_STATUS);
if(hSrv == NULL){
OutputDebugString(_T("OpenService failed"));
CloseServiceHandle(hScm);
return FALSE;
}
if(QueryServiceStatus(hSrv, &stStatus) == FALSE ){
OutputDebugString(_T("QueryServiceStatus failed"));
CloseServiceHandle(hSrv);
CloseServiceHandle(hScm);
return FALSE;
}
DWORD dwStatus = stStatus.dwCurrentState;
return dwStatus;
}
static void test_service(void)
{
static const WCHAR spooler[] = {'S','p','o','o','l','e','r',0};
static const WCHAR dummyW[] = {'d','u','m','m','y',0};
SERVICE_STATUS_PROCESS status;
SC_HANDLE scm, service;
IShellDispatch2 *sd;
DWORD dummy;
HRESULT hr;
BSTR name;
VARIANT v;
hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellDispatch2, (void**)&sd);
if (hr != S_OK)
{
win_skip("IShellDispatch2 not supported\n");
return;
}
V_VT(&v) = VT_I2;
V_I2(&v) = 10;
hr = IShellDispatch2_IsServiceRunning(sd, NULL, &v);
ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
EXPECT_HR(hr, S_OK);
scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
service = OpenServiceW(scm, spooler, SERVICE_QUERY_STATUS);
QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy);
CloseServiceHandle(service);
CloseServiceHandle(scm);
/* service should exist */
name = SysAllocString(spooler);
V_VT(&v) = VT_I2;
hr = IShellDispatch2_IsServiceRunning(sd, name, &v);
EXPECT_HR(hr, S_OK);
ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
if (status.dwCurrentState == SERVICE_RUNNING)
ok(V_BOOL(&v) == VARIANT_TRUE, "got %d\n", V_BOOL(&v));
else
ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
SysFreeString(name);
/* service doesn't exist */
name = SysAllocString(dummyW);
V_VT(&v) = VT_I2;
hr = IShellDispatch2_IsServiceRunning(sd, name, &v);
EXPECT_HR(hr, S_OK);
ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
SysFreeString(name);
IShellDispatch2_Release(sd);
}
static BOOL net_service(int operation, const WCHAR* service_name)
{
SC_HANDLE SCManager, serviceHandle;
BOOL result = 0;
WCHAR service_display_name[4096];
DWORD buffer_size;
SCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if(!SCManager)
{
output_string(STRING_NO_SCM);
return FALSE;
}
serviceHandle = OpenServiceW(SCManager, service_name, SC_MANAGER_ALL_ACCESS);
if(!serviceHandle)
{
output_string(STRING_NO_SVCHANDLE);
CloseServiceHandle(SCManager);
return FALSE;
}
buffer_size = sizeof(service_display_name)/sizeof(*service_display_name);
GetServiceDisplayNameW(SCManager, service_name, service_display_name, &buffer_size);
if (!service_display_name[0]) lstrcpyW(service_display_name, service_name);
switch(operation)
{
case NET_START:
output_string(STRING_START_SVC, service_display_name);
result = StartServiceW(serviceHandle, 0, NULL);
if(result) output_string(STRING_START_SVC_SUCCESS, service_display_name);
else
{
if (!output_error_string(GetLastError()))
output_string(STRING_START_SVC_FAIL, service_display_name);
}
break;
case NET_STOP:
output_string(STRING_STOP_SVC, service_display_name);
result = StopService(SCManager, serviceHandle);
if(result) output_string(STRING_STOP_SVC_SUCCESS, service_display_name);
else
{
if (!output_error_string(GetLastError()))
output_string(STRING_STOP_SVC_FAIL, service_display_name);
}
break;
}
CloseServiceHandle(serviceHandle);
CloseServiceHandle(SCManager);
return result;
}
static BOOL
DoCreate(PCREATE_DATA Data)
{
SC_HANDLE hSCManager;
SC_HANDLE hSc;
BOOL bRet = FALSE;
/* open handle to the SCM */
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (hSCManager)
{
hSc = CreateServiceW(hSCManager,
Data->ServiceName,
Data->DisplayName,
SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS,
SERVICE_DEMAND_START,
SERVICE_ERROR_NORMAL,
Data->BinPath,
NULL,
NULL,
NULL,
NULL,
NULL);
if (hSc)
{
LPWSTR lpSuccess;
/* Set the service description as CreateService
does not do this for us */
SetServiceDescription(Data->ServiceName,
Data->Description);
/* report success to user */
if (AllocAndLoadString(&lpSuccess,
hInstance,
IDS_CREATE_SUCCESS))
{
DisplayString(lpSuccess);
LocalFree(lpSuccess);
}
CloseServiceHandle(hSc);
bRet = TRUE;
}
CloseServiceHandle(hSCManager);
}
return bRet;
}
// https://msdn.microsoft.com/ru-ru/library/windows/desktop/bb540475%28v=vs.85%29.aspx
VOID SvcInstall() {
WCHAR szPath[MAX_PATH];
if (!GetModuleFileNameW(NULL, szPath, MAX_PATH)) {
printf(">> Cannot install service (LastError=0x%x)\n", GetLastError());
goto _ret;
}
SC_HANDLE schSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (NULL == schSCManager) {
printf(">> OpenSCManagerW failed (LastError=0x%x)\n", GetLastError());
goto _ret;
}
WCHAR wchAccountName[64];
for (;;) {
printf(">> Account for granting privilage: ");
fgetws(wchAccountName, sizeof(wchAccountName), stdin);
PWCHAR pLineEnd = wcschr(wchAccountName, '\n');
if (pLineEnd) *pLineEnd = '\0';
PSID pSid;
DWORD dwSidLength;
if (!GetSidByName(wchAccountName, &pSid, &dwSidLength)) {
printf(">> Failed to get SID by name (\"%S\"). Try again.\n", wchAccountName);
continue;
}
free(pSid);
break;
}
wcscat_s(szPath, L" \"");
wcscat_s(szPath, wchAccountName);
wcscat_s(szPath, L"\"");
//printf("Command line: \"%S\"\n", szPath);
SC_HANDLE schService = CreateServiceW(schSCManager, SERVICE_NAME, SERVICE_NAME, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, szPath, NULL, NULL, NULL, NULL, NULL);
if (schService == NULL) {
DWORD LastError = GetLastError();
if (LastError == ERROR_SERVICE_EXISTS) {
printf(">> Service already exists!\n");
goto _close_sc;
} else {
printf(">> CreateServiceW failed (LastError=0x%x)\n", GetLastError());
goto _close_sc;
}
} else printf(">> Service installed successfully!\n");
if (!StartServiceW(schService, 0, NULL)) {
printf(">> StartServiceW failed (LastError=0x%x)\n", GetLastError());
goto _close_service;
} else printf(">> Service started successfully!\n");
_close_service:
CloseServiceHandle(schService);
_close_sc:
CloseServiceHandle(schSCManager);
_ret:
return;
}
LPQUERY_SERVICE_CONFIG
GetServiceConfig(LPWSTR lpServiceName)
{
LPQUERY_SERVICE_CONFIGW lpServiceConfig = NULL;
SC_HANDLE hSCManager;
SC_HANDLE hService;
DWORD dwBytesNeeded;
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (hSCManager)
{
hService = OpenServiceW(hSCManager,
lpServiceName,
SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_QUERY_CONFIG);
if (hService)
{
if (!QueryServiceConfigW(hService,
NULL,
0,
&dwBytesNeeded))
{
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
lpServiceConfig = (LPQUERY_SERVICE_CONFIG)HeapAlloc(GetProcessHeap(),
0,
dwBytesNeeded);
if (lpServiceConfig)
{
if (!QueryServiceConfigW(hService,
lpServiceConfig,
dwBytesNeeded,
&dwBytesNeeded))
{
HeapFree(GetProcessHeap(),
0,
lpServiceConfig);
lpServiceConfig = NULL;
}
}
}
}
CloseServiceHandle(hService);
}
CloseServiceHandle(hSCManager);
}
return lpServiceConfig;
}
static BOOL
EnableUserModePnpManager(VOID)
{
SC_HANDLE hSCManager = NULL;
SC_HANDLE hService = NULL;
BOOL bRet = FALSE;
hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
if (hSCManager == NULL)
{
DPRINT1("Unable to open the service control manager.\n");
DPRINT1("Last Error %d\n", GetLastError());
goto cleanup;
}
hService = OpenServiceW(hSCManager,
L"PlugPlay",
SERVICE_CHANGE_CONFIG | SERVICE_START);
if (hService == NULL)
{
DPRINT1("Unable to open PlugPlay service\n");
goto cleanup;
}
bRet = ChangeServiceConfigW(hService,
SERVICE_NO_CHANGE,
SERVICE_AUTO_START,
SERVICE_NO_CHANGE,
NULL, NULL, NULL,
NULL, NULL, NULL, NULL);
if (!bRet)
{
DPRINT1("Unable to change the service configuration\n");
goto cleanup;
}
bRet = StartServiceW(hService, 0, NULL);
if (!bRet && (GetLastError() != ERROR_SERVICE_ALREADY_RUNNING))
{
DPRINT1("Unable to start service\n");
goto cleanup;
}
bRet = TRUE;
cleanup:
if (hService != NULL)
CloseServiceHandle(hService);
if (hSCManager != NULL)
CloseServiceHandle(hSCManager);
return bRet;
}
BOOL
SetServiceConfig(LPQUERY_SERVICE_CONFIG pServiceConfig,
LPWSTR lpServiceName,
LPWSTR lpPassword)
{
SC_HANDLE hSCManager;
SC_HANDLE hSc;
SC_LOCK scLock;
BOOL bRet = FALSE;
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_LOCK);
if (hSCManager)
{
scLock = LockServiceDatabase(hSCManager);
if (scLock)
{
hSc = OpenServiceW(hSCManager,
lpServiceName,
SERVICE_CHANGE_CONFIG);
if (hSc)
{
if (ChangeServiceConfigW(hSc,
pServiceConfig->dwServiceType,
pServiceConfig->dwStartType,
pServiceConfig->dwErrorControl,
pServiceConfig->lpBinaryPathName,
pServiceConfig->lpLoadOrderGroup,
pServiceConfig->dwTagId ? &pServiceConfig->dwTagId : NULL,
pServiceConfig->lpDependencies,
pServiceConfig->lpServiceStartName,
lpPassword,
pServiceConfig->lpDisplayName))
{
bRet = TRUE;
}
CloseServiceHandle(hSc);
}
UnlockServiceDatabase(scLock);
}
CloseServiceHandle(hSCManager);
}
if (!bRet)
GetError();
return bRet;
}
/**
* @brief
* @param
* @see
* @remarks
* @code
* @endcode
* @return
*/
bool
scm_context::install_service(
_In_ bool auto_start
)
{
SC_HANDLE scm_handle = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (NULL == scm_handle)
{
log_err "OpenSCManagerW() faield. gle = %u", GetLastError() log_end
return false;
}
BOOL
RegisterDriver(LPCWSTR lpDriverName,
LPCWSTR lpPathName)
{
SC_HANDLE hSCManager;
SC_HANDLE hService;
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (!hSCManager)
return FALSE;
retry:
hService = CreateServiceW(hSCManager,
lpDriverName,
lpDriverName,
SERVICE_ALL_ACCESS,
SERVICE_KERNEL_DRIVER,
SERVICE_DEMAND_START,
SERVICE_ERROR_NORMAL,
lpPathName,
NULL,
NULL,
NULL,
NULL,
NULL);
if (hService)
{
CloseServiceHandle(hService);
CloseServiceHandle(hSCManager);
return TRUE;
}
else
{
DWORD err = GetLastError();
if (err == ERROR_SERVICE_MARKED_FOR_DELETE)
{
StopDriver(DRIVER_NAME);
goto retry;
}
CloseServiceHandle(hSCManager);
// return TRUE if the driver is already registered
return (err == ERROR_SERVICE_EXISTS);
}
}
HRESULT
pxDiStartStopService(
__in LPCWSTR ServiceName,
__in BOOL Start)
{
HRESULT hr;
SC_HANDLE scManagerHandle = OpenSCManagerW(
NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT);
if (NULL == scManagerHandle)
{
hr = HRESULT_FROM_WIN32(GetLastError());
return hr;
}
DWORD serviceAccess = Start ? SERVICE_START : SERVICE_STOP;
serviceAccess |= SERVICE_QUERY_STATUS;
if (!Start) serviceAccess |= SERVICE_ENUMERATE_DEPENDENTS;
SC_HANDLE serviceHandle = OpenServiceW(
scManagerHandle, ServiceName,
serviceAccess);
if (NULL == serviceHandle)
{
hr = HRESULT_FROM_WIN32(GetLastError());
CloseServiceHandle(scManagerHandle);
return hr;
}
if (Start)
{
hr = xDiStartService(scManagerHandle, serviceHandle, 30*1000);
}
else
{
hr = xDiStopService(scManagerHandle, serviceHandle, TRUE, 30*1000);
}
CloseServiceHandle(serviceHandle);
CloseServiceHandle(scManagerHandle);
return hr;
}
BOOL
SetServiceDescription(LPWSTR lpServiceName,
LPWSTR lpDescription)
{
SC_HANDLE hSCManager;
SC_HANDLE hSc;
SC_LOCK scLock;
SERVICE_DESCRIPTION ServiceDescription;
BOOL bRet = FALSE;
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_LOCK);
if (hSCManager)
{
scLock = LockServiceDatabase(hSCManager);
if (scLock)
{
hSc = OpenServiceW(hSCManager,
lpServiceName,
SERVICE_CHANGE_CONFIG);
if (hSc)
{
ServiceDescription.lpDescription = lpDescription;
if (ChangeServiceConfig2W(hSc,
SERVICE_CONFIG_DESCRIPTION,
&ServiceDescription))
{
bRet = TRUE;
}
CloseServiceHandle(hSc);
}
UnlockServiceDatabase(scLock);
}
CloseServiceHandle(hSCManager);
}
if (!bRet)
GetError();
return bRet;
}
static void GetServices(BOOL bHideOSVendorServices = FALSE)
{
//
// First of all, clear the list.
//
ClearServicesList();
//
// Now, we can list the services.
//
// Open the Service Control Manager.
SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
if (hSCManager == NULL)
return;
// Enumerate all the Win32 services.
DWORD dwBytesNeeded = 0;
DWORD dwNumServices = 0;
// DWORD dwResumeHandle = 0;
EnumServicesStatusExW(hSCManager, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &dwBytesNeeded, &dwNumServices, NULL /* &dwResumeHandle */, NULL);
// if (GetLastError() == ERROR_MORE_DATA)
LPENUM_SERVICE_STATUS_PROCESS lpServices = (LPENUM_SERVICE_STATUS_PROCESS)MemAlloc(0, dwBytesNeeded);
if (!lpServices)
{
CloseServiceHandle(hSCManager);
return;
}
EnumServicesStatusExW(hSCManager, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, (LPBYTE)lpServices, dwBytesNeeded, &dwBytesNeeded, &dwNumServices, NULL /* &dwResumeHandle */, NULL);
// Add them into the list.
for (DWORD i = 0 ; i < dwNumServices ; ++i)
{
AddService(hSCManager, lpServices + i, bHideOSVendorServices);
}
// Cleaning.
MemFree(lpServices);
CloseServiceHandle(hSCManager);
return;
}
DWORD
WINAPI
SetupStartService(
LPCWSTR lpServiceName,
BOOL bWait)
{
SC_HANDLE hManager = NULL;
SC_HANDLE hService = NULL;
DWORD dwError = ERROR_SUCCESS;
hManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (hManager == NULL)
{
dwError = GetLastError();
goto done;
}
hService = OpenServiceW(hManager,
lpServiceName,
SERVICE_START);
if (hService == NULL)
{
dwError = GetLastError();
goto done;
}
if (!StartService(hService, 0, NULL))
{
dwError = GetLastError();
goto done;
}
done:
if (hService != NULL)
CloseServiceHandle(hService);
if (hManager != NULL)
CloseServiceHandle(hManager);
return dwError;
}
static HRESULT WINAPI ShellDispatch_IsServiceRunning(IShellDispatch2 *iface, BSTR name, VARIANT *running)
{
SERVICE_STATUS_PROCESS status;
SC_HANDLE scm, service;
DWORD dummy;
TRACE("(%s, %p)\n", debugstr_w(name), running);
V_VT(running) = VT_BOOL;
V_BOOL(running) = VARIANT_FALSE;
scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
if (!scm)
{
ERR("failed to connect to service manager\n");
return S_OK;
}
service = OpenServiceW(scm, name, SERVICE_QUERY_STATUS);
if (!service)
{
ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
CloseServiceHandle(scm);
return S_OK;
}
if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status,
sizeof(SERVICE_STATUS_PROCESS), &dummy))
{
TRACE("failed to query service status (%u)\n", GetLastError());
CloseServiceHandle(service);
CloseServiceHandle(scm);
return S_OK;
}
if (status.dwCurrentState == SERVICE_RUNNING)
V_BOOL(running) = VARIANT_TRUE;
CloseServiceHandle(service);
CloseServiceHandle(scm);
return S_OK;
}
static BOOL
DoDeleteService(PMAIN_WND_INFO Info,
HWND hDlg)
{
SC_HANDLE hSCManager;
SC_HANDLE hSc;
BOOL bRet = FALSE;
hSCManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_ALL_ACCESS);
if (hSCManager)
{
hSc = OpenServiceW(hSCManager,
Info->pCurrentService->lpServiceName,
DELETE);
if (hSc)
{
if (DeleteService(hSc))
{
LPWSTR lpSuccess;
/* report success to user */
if (AllocAndLoadString(&lpSuccess,
hInstance,
IDS_DELETE_SUCCESS))
{
DisplayString(lpSuccess);
LocalFree(lpSuccess);
}
bRet = TRUE;
}
CloseServiceHandle(hSc);
}
CloseServiceHandle(hSCManager);
}
return bRet;
}
EASYHOOK_BOOL_EXPORT RhIsAdministrator()
{
/*
Description:
If someone is able to open the SCM with all access he is also able to create and start system services
and so he is also able to act as a part of the system! We are just letting
windows decide and don't enforce that the user is in the builtin admin group.
*/
SC_HANDLE hSCManager = NULL;
if((hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS)) == NULL)
return FALSE;
CloseServiceHandle(hSCManager);
return TRUE;
}
static BOOL net_enum_services(void)
{
static const WCHAR runningW[]={' ',' ',' ',' ','%','s','\n',0};
SC_HANDLE SCManager;
LPENUM_SERVICE_STATUS_PROCESSW services;
DWORD size, i, count, resume;
BOOL success = FALSE;
SCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if(!SCManager)
{
output_string(STRING_NO_SCM);
return FALSE;
}
EnumServicesStatusExW(SCManager, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_ACTIVE, NULL, 0, &size, &count, NULL, NULL);
if(GetLastError() != ERROR_MORE_DATA)
{
output_error_string(GetLastError());
goto end;
}
services = HeapAlloc(GetProcessHeap(), 0, size);
resume = 0;
if(!EnumServicesStatusExW(SCManager, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_ACTIVE, (LPBYTE)services, size, &size, &count, &resume, NULL))
{
output_error_string(GetLastError());
goto end;
}
output_string(STRING_RUNNING_HEADER);
for(i = 0; i < count; i++)
{
output_printf(runningW, services[i].lpDisplayName);
WINE_TRACE("service=%s state=%d controls=%x\n",
wine_dbgstr_w(services[i].lpServiceName),
services[i].ServiceStatusProcess.dwCurrentState,
services[i].ServiceStatusProcess.dwControlsAccepted);
}
success = TRUE;
end:
CloseServiceHandle(SCManager);
return success;
}
BOOL IsInstallService(LPCWSTR lpcwszName)
{
SC_HANDLE hScm = NULL;
SC_HANDLE hSrv = NULL;
hScm = OpenSCManagerW(0, 0, SC_MANAGER_CONNECT);
if(hScm == NULL){
OutputDebugString(_T("OpenSCManager failed"));
return FALSE;
}
hSrv = OpenServiceW(hScm, lpcwszName, SERVICE_QUERY_STATUS);
if(hSrv == NULL){
OutputDebugString(_T("OpenService failed"));
CloseServiceHandle(hScm);
return FALSE;
}
CloseServiceHandle(hSrv);
CloseServiceHandle(hScm);
return TRUE;
}
static SC_HANDLE OpenServiceControlManager()
{
LPCWSTR machineName = 0; // local
LPCWSTR databaseName = 0; // default
SC_HANDLE hSCM = OpenSCManagerW(machineName, databaseName, SC_MANAGER_ALL_ACCESS);
if(!hSCM)
{
// administrator privileges are required. note: installing the
// service and having it start automatically would allow
// Least-Permission accounts to use it, but is too invasive and
// thus out of the question.
// rule out other problems
ENSURE(GetLastError() == ERROR_ACCESS_DENIED);
return 0;
}
return hSCM; // success
}
