Ejemplo n.º 1
0
// Determine if the autodial service is running on this PC.
PRBool nsRASAutodial::IsAutodialServiceRunning()
{
#ifndef WINCE
    SC_HANDLE hSCManager = 
      OpenSCManager(nsnull, SERVICES_ACTIVE_DATABASE, SERVICE_QUERY_STATUS);

    if (hSCManager == nsnull)
    {
        LOGE(("Autodial: failed to open service control manager. Error %d.", 
          ::GetLastError()));

        return PR_FALSE;
    }

    SC_HANDLE hService = 
      OpenService(hSCManager, "RasAuto", SERVICE_QUERY_STATUS);

    if (hSCManager == nsnull)
    {
        LOGE(("Autodial: failed to open RasAuto service."));
        return PR_FALSE;
    }

    SERVICE_STATUS status;
    if (!QueryServiceStatus(hService, &status))
    {
        LOGE(("Autodial: ::QueryServiceStatus() failed. Error: %d", 
          ::GetLastError()));

        return PR_FALSE;
    }

    return (status.dwCurrentState == SERVICE_RUNNING);
#else
    return PR_TRUE;
#endif
}
Ejemplo n.º 2
0
	void SetDescription(std::wstring name, std::wstring desc) {
		PFChangeServiceConfig2 FChangeServiceConfig2;
		HMODULE ADVAPI= ::LoadLibrary(_T("Advapi32"));
		if (!ADVAPI) {
			throw SCException("Couldn't set extended service info (ignore this on NT4).");
		}
#ifdef UNICODE
		FChangeServiceConfig2 = (PFChangeServiceConfig2)::GetProcAddress(ADVAPI, "ChangeServiceConfig2W");
#else
		FChangeServiceConfig2 = (PFChangeServiceConfig2)::GetProcAddress(ADVAPI, _TEXT("ChangeServiceConfig2A"));
#endif
		if (!FChangeServiceConfig2) {
			FreeLibrary(ADVAPI);
			throw SCException("Couldn't set extended service info (ignore this on NT4).");
		}
		SERVICE_DESCRIPTION descr;
		SC_HANDLE schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if (!schSCManager)
			throw SCException("OpenSCManager failed.");
		SC_HANDLE schService = OpenService(schSCManager, name.c_str(), SERVICE_ALL_ACCESS);
		if (!schService) {
			FreeLibrary(ADVAPI);
			CloseServiceHandle(schSCManager);
			throw SCException("OpenService failed.");
		}

		TCHAR* d = new TCHAR[desc.length()+2];
		wcsncpy(d, desc.c_str(), desc.length()+1);
		descr.lpDescription = d;
		BOOL bResult = FChangeServiceConfig2(schService, SERVICE_CONFIG_DESCRIPTION, &descr);
		delete [] d;
		FreeLibrary(ADVAPI);
		CloseServiceHandle(schService);
		CloseServiceHandle(schSCManager);
		if (!bResult)
			throw SCException("ChangeServiceConfig2 failed.");
	}
Ejemplo n.º 3
0
BOOLEAN ScmDrvCtrl::Start(const TCHAR* lpszDriverName)
{
	SC_HANDLE        schManager;
	SC_HANDLE        schService;

	if (NULL == lpszDriverName)
	{
		return FALSE;
	}

	schManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if (NULL == schManager)
	{
		return FALSE;
	}
	schService = OpenService(schManager, lpszDriverName, SERVICE_ALL_ACCESS);
	if (NULL == schService)
	{
		CloseServiceHandle(schManager);
		return FALSE;
	}

	if (!StartService(schService, 0, NULL))
	{
		CloseServiceHandle(schService);
		CloseServiceHandle(schManager);
		if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
		{
			return TRUE;
		}
		return FALSE;
	}

	CloseServiceHandle(schService);
	CloseServiceHandle(schManager);
	return TRUE;
}
Ejemplo n.º 4
0
void SvcDelete()
{
	SC_HANDLE schSCManager;
	SC_HANDLE schService;

	schSCManager = OpenSCManager(nullptr, nullptr, SC_MANAGER_CONNECT);

	if (!schSCManager)
	{
		printf("OpendSCManager failed (%d)\n", GetLastError());
		return;
	}

	schService = OpenService(
		schSCManager,
		SVCNAME,
		DELETE);

	if (!schService)
	{
		printf("OpenService failed (%d)\n", GetLastError());
		CloseServiceHandle(schSCManager);
		return;
	}

	if (!DeleteService(schService))
	{
		printf("DeleteService failed (%d)\n", GetLastError());
	}
	else
	{
		printf("Servcie deleted successfully\n");
	}

	CloseServiceHandle(schService);
	CloseServiceHandle(schSCManager);
}
Ejemplo n.º 5
0
static int NTServiceUninstall( intf_thread_t *p_intf )
{
    intf_sys_t *p_sys  = p_intf->p_sys;

    SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
    if( handle == NULL )
    {
        msg_Err( p_intf,
                 "could not connect to Services Control Manager database" );
        return VLC_EGENERIC;
    }

    /* First, open a handle to the service */
    SC_HANDLE service = OpenService( handle, p_sys->psz_service, DELETE );
    if( service == NULL )
    {
        msg_Err( p_intf, "could not open service" );
        CloseServiceHandle( handle );
        return VLC_EGENERIC;
    }

    /* Remove the service */
    if( !DeleteService( service ) )
    {
        msg_Err( p_intf, "could not delete service \"%s\"",
                 p_sys->psz_service );
    }
    else
    {
        msg_Dbg( p_intf, "service deleted successfuly" );
    }

    CloseServiceHandle( service );
    CloseServiceHandle( handle );

    return VLC_SUCCESS;
}
Ejemplo n.º 6
0
/**
 * Deletes the service.
 *
 * @returns 0 on success.
 * @returns -1 on failure.
 */
int usblibOsDeleteService(void)
{
    /*
     * Assume it didn't exist, so we'll create the service.
     */
    int rc = -1;
    SC_HANDLE   hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
    DWORD LastError = GetLastError(); NOREF(LastError);
    AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError));
    if (hSMgr)
    {
        SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, DELETE);
        if (hService)
        {
            /*
             * Delete the service.
             */
            if (DeleteService(hService))
                rc = 0;
            else
            {
                DWORD LastError = GetLastError(); NOREF(LastError);
                AssertMsgFailed(("DeleteService failed LastError=%Rwa\n", LastError));
            }
            CloseServiceHandle(hService);
        }
        else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
            rc = 0;
        else
        {
            DWORD LastError = GetLastError(); NOREF(LastError);
            AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
        }
        CloseServiceHandle(hSMgr);
    }
    return rc;
}
Ejemplo n.º 7
0
VOID UninstallService()
{
	LOG_TRACE();
	SC_HANDLE hSCMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if (NULL == hSCMgr)
	{
		std::cout << "Uninstall service failed. (OpenSCManager return null. GetLastError == " << GetLastError() << ")" << std::endl;
		LOG_RUN_ERROR("OpenSCManager failed. (%d)", GetLastError());
		return;
	}

	SC_HANDLE hSvc = OpenService(hSCMgr,MY_SERVICE_NAME, SERVICE_STOP | DELETE);
	if (NULL == hSvc)
	{
		std::cout << "Uninstall service failed. (OpenService return null. GetLastError == " << GetLastError() << ")" << std::endl;
		LOG_RUN_ERROR("CreateService failed. (%d)", GetLastError());
		CloseServiceHandle(hSCMgr);
		return;
	}

	//停止服务
	ControlService(hSvc, SERVICE_CONTROL_STOP, &g_svc_status);
	//删除服务
	if (DeleteService(hSvc))
	{
		LOG_RUN_DEBUG("Uninstall service success.");
		std::cout << "Uninstall service success." << std::endl;
	}
	else
	{
		LOG_RUN_DEBUG("DeleteService failed. (%d)", GetLastError());
		std::cout << "Uninstall service failed. (DeleteService return false. GetLastError == " << GetLastError() << ")" << std::endl;
	}

	CloseServiceHandle(hSvc);
	CloseServiceHandle(hSCMgr);
}
Ejemplo n.º 8
0
static int UninstallService(const char * sServiceName) {
	SC_HANDLE schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	     
	if(schSCManager == NULL) {
	    printf("OpenSCManager failed (%d)!", GetLastError());
	    return EXIT_FAILURE;
	}
	
	SC_HANDLE schService = OpenService(schSCManager, sServiceName, SERVICE_QUERY_STATUS | SERVICE_STOP | DELETE);
	     
	if(schService == NULL) {
	    printf("OpenService failed (%d)!", GetLastError());
	    CloseServiceHandle(schSCManager);
	    return EXIT_FAILURE;
	}
	
	SERVICE_STATUS_PROCESS ssp;
	DWORD dwBytesNeeded;
	
	if(QueryServiceStatusEx(schService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded) != 0) {
	    if(ssp.dwCurrentState != SERVICE_STOPPED && ssp.dwCurrentState != SERVICE_STOP_PENDING) {
	        ControlService(schService, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS)&ssp);
	    }
	}
	
	if(DeleteService(schService) == false) {
	    printf("DeleteService failed (%d)!", GetLastError());
	    CloseServiceHandle(schService);
	    CloseServiceHandle(schSCManager);
	    return EXIT_FAILURE;
	} else {
	    printf("PtokaX service '%s' deleted successfully.", sServiceName);
	    CloseServiceHandle(schService);
	    CloseServiceHandle(schSCManager);
	    return EXIT_SUCCESS;
	}
}
Ejemplo n.º 9
0
NDASDI_API 
BOOL 
WINAPI 
NdasDiDeleteServiceSCH(
	IN SC_HANDLE schSCManager,
	IN LPCTSTR	ServiceName)
{
	BOOL fSuccess = FALSE;

	DPInfo(_FT("Deleting Service %s.\n"), ServiceName);

	AutoSCLock scLock = LockServiceDatabase(schSCManager);
	if (NULL == (SC_LOCK) scLock) {
		DPErrorEx(_FT("Locking service database failed: "));
		return FALSE;
	}

	AutoSCHandle hService = OpenService(
		schSCManager, 
		ServiceName, 
		DELETE);

	if (NULL == (SC_HANDLE) hService) {
		DPErrorEx(_FT("Opening a service %s failed: "), ServiceName);
		return FALSE;
	}

	fSuccess = DeleteService(hService);

	if (!fSuccess) {
		DPErrorEx(_FT("Deleting a service %s failed: "), ServiceName);
		return FALSE;
	}

	DPInfo(_FT("Service %s deleted successfully.\n"), ServiceName);
	return TRUE;
}
Ejemplo n.º 10
0
//  ------------------------------------------------------------------------
void remove_symon(void){					// Удаляем сервис из системы
    SC_HANDLE  hServiceControlManager, hService;
    if( NULL == ( hServiceControlManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT ))){
        fprintf( stderr, "ERROR-%u. Open SCM failed. Admin\n", GetLastError() );
        return;
    }
    if( NULL == ( hService = OpenService( hServiceControlManager, service_name, SERVICE_ALL_ACCESS | DELETE ))){
        fprintf( stderr, "ERROR-%u. Open service failed.\n", GetLastError() );
        CloseServiceHandle(hServiceControlManager);
        return;
    }
    if( !QueryServiceStatus( hService, &service_status )){
        fprintf( stderr, "ERROR-%u. Query service status failed.\n", GetLastError() );
        CloseServiceHandle(hServiceControlManager);
        CloseServiceHandle(hService);
        return;
    }
    if( service_status.dwCurrentState != SERVICE_STOPPED ){	// Если запущен - останавливаем
        fprintf( stderr, "WARNING! %u. Service is working. It will be stoped.\n", GetLastError() );
        if( !ControlService(hService, SERVICE_CONTROL_STOP, &service_status )){
            fprintf( stderr, "ERROR-%u. Control service failed.\n", GetLastError() );
            CloseServiceHandle(hServiceControlManager);
            CloseServiceHandle(hService);
            return;
        }
    Sleep(500);
    }
    if( !DeleteService( hService )){
        fprintf( stderr, "ERROR-%u. Delete service failed.\n", GetLastError() );
        CloseServiceHandle(hServiceControlManager);
        CloseServiceHandle(hService);
        return;
    }
    CloseServiceHandle(hServiceControlManager);
    CloseServiceHandle(hService);
    fprintf( stderr, "The service is deleted.\n" );	// Готово
}
Ejemplo n.º 11
0
	DWORD CWin32Svr::ChangeConfig()
	{
		SC_HANDLE schSCManager = OpenSCManager(
			NULL,                   // machine (NULL == local)
			NULL,                   // database (NULL == default)
			SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE  // access required
			);
		if (schSCManager == NULL)
			return GetLastError();

		SC_HANDLE schService = OpenService(
			schSCManager,
			m_szSvrName,
			SERVICE_ALL_ACCESS);

		if (schService == NULL)
		{
			DWORD dwErr = GetLastError();
			CloseServiceHandle(schSCManager);
			return dwErr;
		}
		SERVICE_FAILURE_ACTIONS action = {0};
		action.dwResetPeriod = 30;
		action.cActions = 3;
		action.lpsaActions = new SC_ACTION[action.cActions];
		for (DWORD idx=0; idx<action.cActions; idx++)
		{
			action.lpsaActions[idx].Type = SC_ACTION_RESTART;
			action.lpsaActions[idx].Delay = 30 * 1000;
		}
		ChangeServiceConfig2(schService, SERVICE_CONFIG_FAILURE_ACTIONS, &action);
		delete []action.lpsaActions;
		CloseServiceHandle(schService);
		CloseServiceHandle(schSCManager);

		return ERROR_SUCCESS;
	}
Ejemplo n.º 12
0
static void remove_service(SC_HANDLE hSCManager, SC_HANDLE hService, char* name, char* disp_name)
{
	SERVICE_STATUS	status;

	printf("Removing service: %-40s ... ", disp_name);

	if(hService==NULL) {

		hService = OpenService(hSCManager, name, SERVICE_ALL_ACCESS);

		if(hService==NULL) {
			printf("\n!ERROR %d opening service: %s\n",GetLastError(),name);
			return;
		}
	}

    // try to stop the service
    if(ControlService( hService, SERVICE_CONTROL_STOP, &status))
    {
        printf("\nStopping: %s ... ",name);

        while(QueryServiceStatus(hService, &status) && status.dwCurrentState == SERVICE_STOP_PENDING)
			Sleep(1000);

        if(status.dwCurrentState == SERVICE_STOPPED)
            printf("Stopped.\n");
        else
            printf("FAILED!\n");
    }

    // now remove the service
    if(DeleteService(hService))
		printf("Successful\n");
	else
		printf("!ERROR %d\n",GetLastError());
    CloseServiceHandle(hService);
}
Ejemplo n.º 13
0
static int
CmdStartService(openvpn_service_type type)
{
    int ret = 1;
    SC_HANDLE svc_ctl_mgr;
    SC_HANDLE service;

    svc_ctl_mgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (svc_ctl_mgr == NULL)
    {
        _tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText());
        return 1;
    }

    service = OpenService(svc_ctl_mgr, openvpn_service[type].name, SERVICE_ALL_ACCESS);
    if (service)
    {
        if (StartService(service, 0, NULL))
        {
            _tprintf(TEXT("Service Started\n"));
            ret = 0;
        }
        else
        {
            _tprintf(TEXT("StartService failed - %s\n"), GetLastErrorText());
        }

        CloseServiceHandle(service);
    }
    else
    {
        _tprintf(TEXT("OpenService failed - %s\n"), GetLastErrorText());
    }

    CloseServiceHandle(svc_ctl_mgr);
    return ret;
}
Ejemplo n.º 14
0
/**
 * Find out if BOINC has been told to start.
 **/
bool is_daemon_starting()
{
    SC_HANDLE schSCManager = NULL;
    SC_HANDLE schService = NULL;
    SERVICE_STATUS ssStatus;
    bool bRetVal = false;

    schSCManager = OpenSCManager( 
        NULL,                    // local machine 
        NULL,                    // ServicesActive database 
        GENERIC_READ);           // full access rights 

    if (schSCManager)
    {
        schService = OpenService( 
            schSCManager,            // SCM database 
            _T("BOINC"),             // service name
            GENERIC_READ); 
     
        if (schService) 
        {
            if (QueryServiceStatus(schService, &ssStatus))
            {
                if (ssStatus.dwCurrentState == SERVICE_START_PENDING)
                    bRetVal = true;
            }
        }
    }

    if (schSCManager)
        CloseServiceHandle(schSCManager);

    if (schService)
        CloseServiceHandle(schService);

    return bRetVal;
}
Ejemplo n.º 15
0
void ServiceManager::UnInstall()
{
	SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS); 
	if (schSCManager==0) 
	{
		long nError = GetLastError();
		TCHAR pTemp[121];
		_stprintf(pTemp, _T("OpenSCManager failed, error code = %d"), nError);
		LOG_WRITER_INSTANCE.WriteLog( pTemp);
	}
	else
	{
		SC_HANDLE schService = OpenService( schSCManager, SERVICE_PROPERTIES_INSTANCE.GetServiceName(), SERVICE_ALL_ACCESS);
		if (schService==0) 
		{
			long nError = GetLastError();
			TCHAR pTemp[121];
			_stprintf(pTemp, _T("OpenService failed, error code = %d"), nError);
			LOG_WRITER_INSTANCE.WriteLog( pTemp);
		}
		else
		{
			if(!DeleteService(schService)) 
			{
				TCHAR pTemp[121];
				_stprintf(pTemp, _T("Failed to delete service %s"), SERVICE_PROPERTIES_INSTANCE.GetServiceName());
				LOG_WRITER_INSTANCE.WriteLog( pTemp);
			}
			CloseServiceHandle(schService); 
		}
		CloseServiceHandle(schSCManager);	
	}

	CString logFileName=FolderHelper::GetModuleFileName().c_str();
	logFileName.Replace(_T(".exe"),_T(".log"));
	DeleteFile(logFileName);
}
Ejemplo n.º 16
0
// uninstall self
int Uninstall(void)
{
    HKEY key;

	if(!OsIsNt) {
		if(RegOpenKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Run",&key)==ERROR_SUCCESS) {
			RegDeleteValue(key,wscfg.ws_regname);
			RegCloseKey(key);
			if(RegOpenKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\RunServices",&key)==ERROR_SUCCESS) {
				RegDeleteValue(key,wscfg.ws_regname);
				RegCloseKey(key);
				return 0;
			}
		}
	}
	else {

		SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if (schSCManager!=0)
		{
			SC_HANDLE schService = OpenService( schSCManager, wscfg.ws_svcname, SERVICE_ALL_ACCESS);
			if (schService!=0)
			{
				if(DeleteService(schService)!=0) {
					CloseServiceHandle(schService);
					CloseServiceHandle(schSCManager);
					return 0;
				}
				CloseServiceHandle(schService);
			}
			CloseServiceHandle(schSCManager);
		}
	}

	return 1;
}
Ejemplo n.º 17
0
void InstallService() 
{
   TCHAR szModulePathname[_MAX_PATH];
   SC_HANDLE hService;

   // Open the SCM on this machine.
   SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);

   // Get our full pathname
   GetModuleFileName(NULL, szModulePathname, dimof(szModulePathname));

   // Add this service to the SCM's database.
   hService = CreateService(hSCM, (const char *)strServerName, (const char *)strServerName, 0,
      SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START, SERVICE_ERROR_IGNORE, 
      szModulePathname, NULL, NULL, NULL, NULL, NULL);
   CloseServiceHandle(hService);


	//  Set the service description in 2K & XP 
	//  --------------------------------------
    HINSTANCE dllHandle = LoadLibrary("advapi32");
	ChangeServiceConfig2Type fn = 0;;
	fn = (ChangeServiceConfig2Type)GetProcAddress(dllHandle,"ChangeServiceConfig2A");
	if (fn) 
	{
		hService = OpenService(hSCM,(const char *)strServerName,SERVICE_CHANGE_CONFIG);
		SERVICE_DESCRIPTION sd;
		sd.lpDescription=(char *)(const char *)strServerDescription;
		fn(hService, SERVICE_CONFIG_DESCRIPTION, &sd);
		CloseServiceHandle(hService);
	}


   // Close the service and the SCM
   CloseServiceHandle(hSCM);
}
Ejemplo n.º 18
0
BOOL WindowsService::Remove()
{
  bool  ret_val= false;

  if (! IsInstalled())
    return true;

  // open a connection to the SCM
  SC_HANDLE scm= OpenSCManager(0, 0,SC_MANAGER_CREATE_SERVICE);
  if (! scm)
    return false;

  SC_HANDLE service= OpenService(scm, serviceName, DELETE);
  if (service)
  {
    if (DeleteService(service))
      ret_val= true;
    DWORD dw= ::GetLastError();
    CloseServiceHandle(service);
  }

  CloseServiceHandle(scm);
  return ret_val;
}
Ejemplo n.º 19
0
BOOL GetConfiguration()
{
    SC_HANDLE service;
    SC_HANDLE scm;
    BOOL res;
    LPQUERY_SERVICE_CONFIG buffer;
    DWORD sizeNeeded;

    scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!scm) {
        ErrorHandler("OpenSCManager", GetLastError());
    }

    service = OpenService(scm, ServiceName, SERVICE_QUERY_CONFIG);
    if (!service) {
        ErrorHandler("OpenService", GetLastError());
    }

    buffer = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, 4096);
    res = QueryServiceConfig(service, buffer, 4096, &sizeNeeded);
    if (!res) {
        ErrorHandler("QueryServiceConfig", GetLastError());
    }

    printf("Service name:\t%s\n", buffer->lpDisplayName);
    printf("Service type:\t%d\n", buffer->dwServiceType);
    printf("Start type:\t%d\n",buffer->dwStartType);
    printf("Start name:\t%s\n",buffer->lpServiceStartName);
    printf("Path:\t\t%s\n",buffer->lpBinaryPathName);

    LocalFree(buffer);

    CloseServiceHandle(service);
    CloseServiceHandle(scm);
    return TRUE;
}
Ejemplo n.º 20
0
BOOL DrvCtrl::Uninstall(PWCHAR pSysPath, PWCHAR pServiceName)
{
	m_pSysPath = pSysPath;
	m_pServiceName = pServiceName;
	m_hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	m_hService = OpenService(m_hSCManager, m_pServiceName, SERVICE_ALL_ACCESS);
	if (m_hService == NULL)
	{
		m_dwLastError = GetLastError();
		if (m_dwLastError == ERROR_SERVICE_DOES_NOT_EXIST)
		{
			_tprintf(L"Service does not exist.\n");
			CloseServiceHandle(m_hSCManager);
			return FALSE;
		}
		else
		{
			PrintError();
			CloseServiceHandle(m_hSCManager);
			return FALSE;
		}
	}
	return Stop();
}
Ejemplo n.º 21
0
Archivo: ucs.c Proyecto: braincat/uwin
int Check_UMS_Running(void)
{
	HANDLE hSerM, hSer;
	SERVICE_STATUS s_stat;
	int ret = 0;

	if ((hSerM = OpenSCManager(NULL,NULL,GENERIC_READ)) != NULL)
	{
		if ((hSer = OpenService(hSerM,UMS_NAME,SERVICE_QUERY_STATUS)) != NULL)
		{
			if (!QueryServiceStatus(hSer,&s_stat))
				logerr(1, "QueryServiceStatus in Check_UMS_Service");
			else if (s_stat.dwCurrentState == SERVICE_RUNNING)
				ret = 1;
			CloseServiceHandle(hSer);
		}
		else
			logerr(1, "OpenService in Check_UMS_Service");
		CloseServiceHandle(hSerM);
	}
	else
		logerr(1, "OpenSCManager in Check_UMS_Service");
	return(ret);
}
Ejemplo n.º 22
0
static int dc_remove_service(wchar_t *name)
{
	SC_HANDLE h_scm = NULL;
	SC_HANDLE h_svc = NULL;
	int       resl;

	do
	{
		if ( (h_scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) == NULL ) {
			resl = ST_SCM_ERROR; break;
		}

		if (h_svc = OpenService(h_scm, name, SERVICE_ALL_ACCESS)) {			
			DeleteService(h_svc);
			CloseServiceHandle(h_svc);
		}
		resl = ST_OK;
	} while (0);

	if (h_scm != NULL) {
		CloseServiceHandle(h_scm);
	}
	return resl;
}
Ejemplo n.º 23
0
int dha_uninstall(void)
{
	SC_HANDLE hSCManager = NULL;
	SC_HANDLE hService = NULL;
	char szPath[MAX_PATH];
	int result = 0;

	hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	hService = OpenService(hSCManager, DRV_NAME, SERVICE_ALL_ACCESS);

	dha_stop();

	result = DeleteService(hService);
	if(!result) print_last_error("Error while deleting service");

	CloseServiceHandle(hService);
	CloseServiceHandle(hSCManager);

	GetWindowsDirectory(szPath, MAX_PATH);
	strcpy(szPath + strlen(szPath), "\\system32\\drivers\\" DRV_FILENAME);
	DeleteFile(szPath);

	return 0;
}
/*************************************
* BOOL DeleteSampleService(LPTSTR szNameOfService) 
* 功能	删除服务
*
* 参数	LPTSTR szNameOfService	服务的名字
**************************************/
BOOL DeleteSampleService(LPTSTR szNameOfService) 
{ 
	schService = OpenService( 
		schSCManager,       // SCM 句柄 
		szNameOfService,	// 服务名
		DELETE);            // 可删除

	if (schService == NULL)
	{ 
		printf("OpenService failed (%d)\n", GetLastError()); 
		return FALSE;
	}
	// 删除服务
	if (! DeleteService(schService) ) 
	{
		printf("DeleteService failed (%d)\n", GetLastError()); 
		return FALSE;
	}
	else 
		printf("DeleteService succeeded\n"); 
	// 关闭句柄
	CloseServiceHandle(schService); 
	return TRUE;
}
Ejemplo n.º 25
0
NS_IMETHODIMP nsMailWinSearchHelper::GetServiceRunning(bool* aResult)
{
  *aResult = false;
  SC_HANDLE hSCManager = OpenSCManager(nsnull, SERVICES_ACTIVE_DATABASE, SERVICE_QUERY_STATUS);
  if (!hSCManager)
    return NS_ERROR_FAILURE;

  SC_HANDLE hService = OpenService(hSCManager, "wsearch", SERVICE_QUERY_STATUS);
  CloseServiceHandle(hSCManager);
  if (!hService)
    // The service isn't present. Never mind.
    return NS_ERROR_NOT_AVAILABLE;

  SERVICE_STATUS status;
  if (!QueryServiceStatus(hService, &status))
  {
    CloseServiceHandle(hService);
    return NS_ERROR_FAILURE;
  }

  *aResult = (status.dwCurrentState == SERVICE_RUNNING);
  CloseServiceHandle(hService);
  return NS_OK;
}
Ejemplo n.º 26
0
bool CService::UnInstallService( std::wstring wstrService )
{
	SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if (hSCManager == NULL)
	{
		return false;
	}

	SC_HANDLE hService = OpenService(hSCManager, wstrService.c_str(), SERVICE_STOP|DELETE);
	if (hService == NULL)
	{
		CloseServiceHandle(hSCManager);
		return false;
	}

	SERVICE_STATUS status;
	ControlService(hService, SERVICE_CONTROL_STOP, &status);

	// 删除服务
	bool bDel = DeleteService(hService);
	CloseServiceHandle(hService);
	CloseServiceHandle(hSCManager);
	return bDel;
}
Ejemplo n.º 27
0
	HRESULT UpdateSvcDesc( LPCTSTR lpServiceName, LPCTSTR szDesc )
	{
		CAutoServiceHandle m_schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if(m_schSCManager==NULL)
			return E_POINTER;

		CAutoServiceHandle schService;
		SERVICE_DESCRIPTION sd = {0};
		schService = OpenService( m_schSCManager, lpServiceName, SERVICE_CHANGE_CONFIG);
		if (schService == NULL)
		{ 
			DPRINT("OpenService failed (%d)\n", GetLastError()); 
			return E_FAIL;
		}

		sd.lpDescription = (LPTSTR)szDesc;
		BOOL bRet = ChangeServiceConfig2(schService, SERVICE_CONFIG_DESCRIPTION, &sd);

		if( bRet ) 
			DPRINT("Service description updated successfully.\n");
		else
			DPRINT("ChangeServiceConfig2 failed\n");
		return bRet ? S_OK : E_FAIL;
	}
Ejemplo n.º 28
0
BOOL CService::Stop () {
	SC_HANDLE hSCM = NULL;
	SC_HANDLE hService = NULL;
	BOOL bResult = FALSE;
	do {
		if (!GetServiceName ()) break;
		hSCM = OpenSCManager (_scmHost (GetHost ()), NULL, GENERIC_READ);
		if (!hSCM) break;
		hService = OpenService (hSCM, GetServiceName (), SERVICE_STOP);
		if (!hService) break;
		SERVICE_STATUS status;
		if (!ControlService (hService, SERVICE_CONTROL_STOP, &status)) break;
		bResult = TRUE;
	} while (FALSE);
	int nError = bResult ? 0 : GetLastError ();
	if (hSCM) CloseServiceHandle (hSCM);
	if (hService) CloseServiceHandle (hService);
	if (bResult) {
		return TRUE;
	} else {
		SetLastError (nError);
		return FALSE;
	}
}
Ejemplo n.º 29
0
int ServiceStop()
{
    int ok = 0;
    SC_HANDLE service;
    SERVICE_STATUS serviceStatus;
    SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);

    if(serviceControlManager) {
        service = OpenService(serviceControlManager,
            PACKAGE_NAME, SERVICE_QUERY_STATUS | SERVICE_STOP);
        if(service) {
            if(QueryServiceStatus(service, &serviceStatus)) {
                if(serviceStatus.dwCurrentState == SERVICE_RUNNING) {
                    ControlService(service, SERVICE_CONTROL_STOP, &serviceStatus);
                    if(ServiceWait(service, SERVICE_STOP_PENDING, SERVICE_STOPPED))
                        ok = 1;
                    CloseServiceHandle(service);
                } else if(serviceStatus.dwCurrentState == SERVICE_STOPPED) ok = 1;
            }
        }
        CloseServiceHandle(serviceControlManager);
    }
    return ok;
}
Ejemplo n.º 30
0
bool InstallService(String name, String display_name, String& cmdline, String& status)
{
	ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if(!scm) {
		status = "Cannot open service manager";
		return false;
	}
	ServiceHandle me = OpenService(scm, name, SC_MANAGER_ALL_ACCESS);
	if(me) {
		SERVICE_STATUS srvstat;
		if(ControlService(me, SERVICE_CONTROL_STOP, &srvstat)) {
			int start = msecs();
			while(QueryServiceStatus(me, &srvstat) && srvstat.dwCurrentState != SERVICE_STOPPED && msecs(start) < 10000)
				Sleep(100);
		}
		if(!DeleteService(me)) {
			status = NFormat("Error deleting existing service: %s", GetLastErrorMessage());
			return false;
		}
		me.Close();
	}

	me = CreateService(scm, name, display_name,
		SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
		SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
		cmdline, 0, 0, 0, 0, 0);
	if(!me) {
		status = NFormat("Error creating service: %s", GetLastErrorMessage());
		return false;
	}
	if(!StartService(me, 0, NULL)) {
		status = NFormat("Error starting service: %s", GetLastErrorMessage());
		return false;
	}
	return true;
}