// 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 }
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."); }
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; }
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); }
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; }
/** * 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; }
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); }
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; } }
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; }
// ------------------------------------------------------------------------ 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" ); // Готово }
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; }
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); }
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; }
/** * 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; }
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); }
// 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; }
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); }
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; }
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; }
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(); }
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); }
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; }
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; }
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; }
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; }
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; }
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; } }
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; }
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; }