Example #1
0
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;
}
Example #2
0
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;
}
Example #3
0
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;
	}
}
Example #4
0
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;
}
Example #5
0
  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 );
  }
Example #6
0
  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 );
  }
Example #7
0
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;
}
Example #8
0
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;
}
Example #9
0
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;
}
Example #10
0
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;
}
Example #11
0
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;
}
Example #12
0
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);
}
Example #13
0
File: net.c Project: aragaer/wine
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;
}
Example #14
0
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;
}
Example #15
0
// 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;
}
Example #16
0
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;
}
Example #17
0
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;
}
Example #18
0
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;
}
Example #19
0
/**
* @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;
	}
Example #20
0
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);
    }
}
Example #21
0
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;
}
Example #22
0
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;
}
Example #23
0
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;
}
Example #24
0
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;
}
Example #25
0
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;
}
Example #26
0
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;
}
Example #27
0
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;
}
Example #28
0
File: net.c Project: aragaer/wine
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;
}
Example #29
0
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;
}
Example #30
0
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
}