Пример #1
0
__int64 WinPmem::uninstall_driver() {
  SC_HANDLE scm, service;
  SERVICE_STATUS ServiceStatus;

  scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);

  if (!scm) return 0;

  service = OpenService(scm, service_name, SERVICE_ALL_ACCESS);

  if (service) {
    ControlService(service, SERVICE_CONTROL_STOP, &ServiceStatus);
  };

  DeleteService(service);
  CloseServiceHandle(service);
  Log(TEXT("Driver Unloaded.\n"));

  return 1;

  CloseServiceHandle(scm);
  return 0;
}
Пример #2
0
bool WinServiceUninstall()
{
    SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CONNECT);

    if (serviceControlManager)
    {
        SC_HANDLE service = OpenService(serviceControlManager,
            serviceName, SERVICE_QUERY_STATUS | DELETE);
        if (service)
        {
            SERVICE_STATUS serviceStatus2;
            if (QueryServiceStatus(service, &serviceStatus2))
            {
                if (serviceStatus2.dwCurrentState == SERVICE_STOPPED)
                    DeleteService(service);
            }
            CloseServiceHandle(service);
        }

        CloseServiceHandle(serviceControlManager);
    }
    return true;
}
Пример #3
0
/* Remove installed service from servicecontrolmanager */
void
wsvc_remove(FILE* out)
{
        SC_HANDLE scm;
        SC_HANDLE sv;
        if(out) fprintf(out, "removing unbound service\n");
        scm = OpenSCManager(NULL, NULL, (int)SC_MANAGER_ALL_ACCESS);
        if(!scm) fatal_win(out, "could not OpenSCManager");
        sv = OpenService(scm, SERVICE_NAME, DELETE);
        if(!sv) {
                CloseServiceHandle(scm);
                fatal_win(out, "could not OpenService");
        }
        if(!DeleteService(sv)) {
		CloseServiceHandle(sv);
		CloseServiceHandle(scm);
                fatal_win(out, "could not DeleteService");
        }
        CloseServiceHandle(sv);
        CloseServiceHandle(scm);
	event_reg_remove(out);
        if(out) fprintf(out, "unbound service removed\n");
}
Пример #4
0
static BOOL remove_service(void){
  SC_HANDLE scm;
  SC_HANDLE service;
  if((scm = OpenSCManager(NULL, 
			  NULL,  
			  GENERIC_WRITE))
     == NULL)
    return FALSE;
  service = OpenServiceW(scm,
			 real_service_name,
			 SERVICE_ALL_ACCESS);
  if(service == NULL){
    CloseServiceHandle(scm);
    return FALSE;
  }
  if(!DeleteService(service)){
    last_error = GetLastError();
    return FALSE;
  }
  CloseServiceHandle(service);
  CloseServiceHandle(scm);
  return TRUE;
}
Пример #5
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);
}
Пример #6
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);
}
Пример #7
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;
	}
}
Пример #8
0
void
wisvc_UninstallKublService (char **argv, char *service_name)
{
  int called_as_service = 0;	/* Needed by macro err_printf */
  SC_HANDLE schService = wisvc_OpenKublService (argv, service_name,
						"uninstall", DELETE);

  if (!DeleteService (schService))
    {
      DWORD erhe = GetLastError ();

      if (ERROR_SERVICE_MARKED_FOR_DELETE == erhe)
	{
	  err_printf ((
		 "%s: Cannot %s service \"%s\" because a service with that "
			"name still exists, although it has been marked for delete. Use ISQL to "
			"stop the old service with shutdown or raw_exit() before continuing "
			" (errno=%ld).\n",
			argv[0], "uninstall", service_name, erhe));
	}
      else
	{
	  err_printf ((
			"%s: Uninstalling service \"%s\" failed. "
			"DeleteService returned zero, errno=%ld.\n",
			argv[0], service_name, erhe));
	}
      exit (1);
    }
  else
    {
      err_printf (("%s: Service \"%s\" uninstalled successfully.\n",
		   argv[0], service_name));
    }

  CloseServiceHandle (schService);
}
Пример #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;
}
Пример #10
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;
}
Пример #11
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);
}
Пример #12
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);
}
Пример #13
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" );	// Готово
}
Пример #14
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;
}
Пример #15
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;
}
int _cdecl uninstall_minifilter (void) {

	SC_HANDLE  hService = NULL;
	SC_HANDLE  hSCManager = NULL;
	int ret = 0;

	hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);

	PrintResult(L"OpenSCManager", L"Opening Service Control Manager Succeded");

	if(hSCManager) {
		if(!hService) {
			SERVICE_STATUS    ss;

			hService = OpenServiceW(hSCManager, L"protegeDados", SERVICE_START | DELETE | SERVICE_STOP);

			ControlService(hService, SERVICE_CONTROL_STOP, &ss);
			DeleteService(hService);
			ret = 1;
		}
		CloseServiceHandle(hSCManager);
	}
	return ret;
}
Пример #17
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;
}
Пример #18
0
BOOL Delete(LPCTSTR ServiceName)
{
    SC_HANDLE hSCManager = NULL;
    SC_HANDLE hSc = NULL;

#ifdef SCDBG
    _tprintf(_T("service to delete - %s\n\n"), ServiceName);
#endif

    hSCManager = OpenSCManager(NULL,
                               NULL,
                               SC_MANAGER_CONNECT);
    if (hSCManager != NULL)
    {
        hSc = OpenService(hSCManager, ServiceName, DELETE);
        if (hSc != NULL)
        {
            if (DeleteService(hSc))
            {
                _tprintf(_T("[SC] DeleteService SUCCESS\n"));

                CloseServiceHandle(hSc);
                CloseServiceHandle(hSCManager);

                return TRUE;
            }
        }
    }

    ReportLastError();

    if (hSc) CloseServiceHandle(hSc);
    if (hSCManager) CloseServiceHandle(hSCManager);

    return FALSE;
}
/*************************************
* 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;
}
Пример #20
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;
}
Пример #21
0
bool ServiceUtil::remove(const tstring& name)
{
    bool bReturn = false;

    do 
    {
        scoped_svc_handle hService(name, GENERIC_ALL, SERVICE_ALL_ACCESS);
        if (!hService.valid())
        {
            break;
        }

        if (!DeleteService(hService.get()))
        {
            ErrorLogLastErr(TSTR("DeleteService[%s] fail"), name.c_str());
            break;
        }

        bReturn = true;

    } while (false);

    return bReturn;
}
Пример #22
0
BOOL Uninstall()
{
	EventLog log;

	// open SCManager
	SC_HANDLE scMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
	if (scMgr == NULL) {
		log.LogLastError("Unable to open service control manager");
		_tprintf(_T("Unable to open service manager!\n"));
		return FALSE;
	}

	// open service and delete
	SC_HANDLE svc = OpenService(scMgr, _T("EasyDynamicDNS"), DELETE);
	if (svc == NULL) {
		log.LogLastError("Unable to open service");
		_tprintf(_T("Unable to open service!\n"));
		CloseServiceHandle(scMgr);
		return FALSE;
	}
	if (DeleteService(svc) != TRUE) {
		log.LogLastError("Unable to delete service");
		_tprintf(_T("Unable to delete service!\n"));
		CloseServiceHandle(svc);
		CloseServiceHandle(scMgr);
		return FALSE;
	}
	CloseServiceHandle(svc);

	// close SCManager
	CloseServiceHandle(scMgr);

	log.LogEvent(EVENTLOG_INFORMATION_TYPE, "EasyDynamicDNS uninstalled.");
	EventLog::UnregisterEventSource();
	return TRUE;
}
Пример #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;
}
Пример #24
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;
}
Пример #25
0
	/**
	 * Stops and removes the service
	 *
	 * @param name The name of the service to uninstall 
	 *
	 * @author mickem
	 *
	 * @date 03-13-2004
	 *
	 */
	void Uninstall(std::wstring name) {
		SC_HANDLE   schService;
		SC_HANDLE   schSCManager;
		Stop(name);

		schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if (!schSCManager)
			throw SCException("OpenSCManager failed: " + error::lookup::last_error());
		schService = OpenService(schSCManager, name.c_str(), SERVICE_ALL_ACCESS);
		if (schService) {
			if(!DeleteService(schService)) {
				std::string err = "DeleteService failed: " + error::lookup::last_error();
				CloseServiceHandle(schService);
				CloseServiceHandle(schSCManager);
				throw SCException(err);
			}
			CloseServiceHandle(schService);
		} else {
			std::string err = "OpenService failed: " + error::lookup::last_error();
			CloseServiceHandle(schSCManager);
			throw SCException(err);
		}
		CloseServiceHandle(schSCManager);
	}
Пример #26
0
BOOL SvcUninstall(void){
	SC_HANDLE schSCManager;
    schSCManager = OpenSCManager( 
        NULL,                    // local computer
        NULL,                    // ServicesActive database 
        SC_MANAGER_ALL_ACCESS);  // full access rights 
 
    if (NULL == schSCManager)
        return FALSE;

	SC_HANDLE hService = OpenServiceW(schSCManager,SVCNAME,SERVICE_STOP|DELETE);
	if(hService == NULL){
		CloseServiceHandle(schSCManager);
		return FALSE;
	}
	SERVICE_STATUS status;
	BOOL ret=FALSE;
	ControlService(hService,SERVICE_CONTROL_STOP,&status);
	if(DeleteService(hService))
		ret=TRUE;
	CloseServiceHandle(hService);
	CloseServiceHandle(schSCManager);
	return ret;
}
Пример #27
0
BOOL DeleteServiceEx(HWND hWnd, SC_HANDLE schSCManager, char *szSvcName)
{
    SC_HANDLE schService;

    schService = OpenService(
                     schSCManager,       // SCM база с данни
                     szSvcName,          // име на сервиса
                     DELETE);            // достъп за изтриване
    if (schService == NULL) {
        MessageBox(hWnd, GetErrorText(GetLastError()), "FileHide", MB_ICONERROR);
        return FALSE;
    }

    // Изтрива го сервиса
    if (!DeleteService(schService)) {
        MessageBox(hWnd, GetErrorText(GetLastError()), "FileHide", MB_ICONERROR);
        CloseServiceHandle(schService);
        return FALSE;
    }

    MessageBox(hWnd, "Сервисът е успешно изтриен", "FileHide", MB_ICONEXCLAMATION);
    CloseServiceHandle(schService);
    return TRUE;
}
Пример #28
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;
}
Пример #29
0
void
ArchDaemonWindows::uninstallDaemon(const char* name)
{
	// remove parameters for this service.  ignore failures.
	HKEY key = openNTServicesKey();
	key      = ArchMiscWindows::openKey(key, name);
	if (key != NULL) {
		ArchMiscWindows::deleteKey(key, _T("Parameters"));
		ArchMiscWindows::closeKey(key);
	}

	// open service manager
	SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_WRITE);
	if (mgr == NULL) {
		// can't open service manager
		throw XArchDaemonUninstallFailed(new XArchEvalWindows);
	}

	// open the service.  oddly, you must open a service to delete it.
	SC_HANDLE service = OpenService(mgr, name, DELETE | SERVICE_STOP);
	if (service == NULL) {
		DWORD err = GetLastError();
		CloseServiceHandle(mgr);
		if (err != ERROR_SERVICE_DOES_NOT_EXIST) {
			throw XArchDaemonUninstallFailed(new XArchEvalWindows(err));
		}
		throw XArchDaemonUninstallNotInstalled(new XArchEvalWindows(err));
	}

	// stop the service.  we don't care if we fail.
	SERVICE_STATUS status;
	ControlService(service, SERVICE_CONTROL_STOP, &status);

	// delete the service
	const bool okay = (DeleteService(service) == 0);
	const DWORD err = GetLastError();

	// clean up
	CloseServiceHandle(service);
	CloseServiceHandle(mgr);

	// give windows a chance to remove the service before
	// we check if it still exists.
	ARCH->sleep(1);

	// handle failure.  ignore error if service isn't installed anymore.
	if (!okay && isDaemonInstalled(name)) {
		if (err == ERROR_SUCCESS) {
			// this seems to occur even though the uninstall was successful.
			// it could be a timing issue, i.e., isDaemonInstalled is
			// called too soon. i've added a sleep to try and stop this.
			return;
		}
		if (err == ERROR_IO_PENDING) {
			// this seems to be a spurious error
			return;
		}
		if (err != ERROR_SERVICE_MARKED_FOR_DELETE) {
			throw XArchDaemonUninstallFailed(new XArchEvalWindows(err));
		}
		throw XArchDaemonUninstallNotInstalled(new XArchEvalWindows(err));
	}
}
int unregisterService() {
#ifdef WIN32
  Logging::LoggerRef logRef(ppg->getLogger(), "ServiceDeregistrator");

  SC_HANDLE scManager = NULL;
  SC_HANDLE scService = NULL;
  SERVICE_STATUS ssSvcStatus = { };
  int ret = 0;

  for (;;) {
    scManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    if (scManager == NULL) {
      logRef(Logging::FATAL, Logging::BRIGHT_RED) << "OpenSCManager failed with error: " << GetLastErrorMessage(GetLastError());
      ret = 1;
      break;
    }

    scService = OpenService(scManager, SERVICE_NAME, SERVICE_STOP | SERVICE_QUERY_STATUS | DELETE);
    if (scService == NULL) {
      logRef(Logging::FATAL, Logging::BRIGHT_RED) << "OpenService failed with error: " << GetLastErrorMessage(GetLastError());
      ret = 1;
      break;
    }

    if (ControlService(scService, SERVICE_CONTROL_STOP, &ssSvcStatus)) {
      logRef(Logging::INFO) << "Stopping " << SERVICE_NAME;
      Sleep(1000);

      while (QueryServiceStatus(scService, &ssSvcStatus)) {
        if (ssSvcStatus.dwCurrentState == SERVICE_STOP_PENDING) {
          logRef(Logging::INFO) << "Waiting...";
          Sleep(1000);
        } else {
          break;
        }
      }

      std::cout << std::endl;
      if (ssSvcStatus.dwCurrentState == SERVICE_STOPPED) {
        logRef(Logging::INFO) << SERVICE_NAME << " is stopped";
      } else {
        logRef(Logging::FATAL, Logging::BRIGHT_RED) << SERVICE_NAME << " failed to stop" << std::endl;
      }
    }

    if (!DeleteService(scService)) {
      logRef(Logging::FATAL, Logging::BRIGHT_RED) << "DeleteService failed with error: " << GetLastErrorMessage(GetLastError());
      ret = 1;
      break;
    }

    logRef(Logging::INFO) << SERVICE_NAME << " is removed";
    break;
  }

  if (scManager) {
    CloseServiceHandle(scManager);
  }

  if (scService) {
    CloseServiceHandle(scService);
  }

  return ret;
#else
  return 0;
#endif
}