BOOLEAN ScmDrvCtrl::Install(const TCHAR* lpszServiceName, const TCHAR* lpszDriverPath, const TCHAR* lpszAltitude, const TCHAR* lpszLink_name) { SC_HANDLE hServiceMgr = NULL; SC_HANDLE hService = NULL; int i = 0; _tcscpy_s(m_link_name, MAX_PATH, lpszLink_name); if (NULL == lpszServiceName || NULL == lpszDriverPath || NULL == lpszAltitude) { return FALSE; } UnInstall(lpszServiceName); WIN32_FIND_DATA FindFileData; if (FindFirstFileW(lpszDriverPath, &FindFileData) == INVALID_HANDLE_VALUE) { return FALSE; } again: hServiceMgr = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (hServiceMgr == NULL) { return FALSE; } hService = CreateService(hServiceMgr, lpszServiceName, // 驱动程序的在注册表中的名字 lpszServiceName, // 注册表驱动程序的DisplayName 值 SERVICE_ALL_ACCESS, // 加载驱动程序的访问权限 SERVICE_FILE_SYSTEM_DRIVER, // 表示加载的服务是文件系统驱动程序 SERVICE_DEMAND_START, // 注册表驱动程序的Start 值 SERVICE_ERROR_IGNORE, // 注册表驱动程序的ErrorControl 值 lpszDriverPath, // 注册表驱动程序的ImagePath 值 _T("FSFilter Activity Monitor"),// 注册表驱动程序的Group 值 NULL, _T("FltMgr"), // 注册表驱动程序的DependOnService 值 NULL, NULL); if (hService == NULL) { CloseServiceHandle(hServiceMgr); if (i > 100000) { return FALSE; } i++; // printf("%d\n", i); goto again; } CloseServiceHandle(hService); // 服务句柄 CloseServiceHandle(hServiceMgr); // SCM句柄 TCHAR szTempStr[MAX_PATH]; HKEY hKey = NULL; DWORD dwData = 0; _tcscpy_s(szTempStr, MAX_PATH, _T("SYSTEM\\CurrentControlSet\\Services\\")); _tcscat_s(szTempStr, MAX_PATH, lpszServiceName); if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szTempStr, 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, (LPDWORD)&dwData) != ERROR_SUCCESS) { return FALSE; } _tcscpy_s(szTempStr, MAX_PATH, lpszServiceName); if (RegSetValueEx(hKey, _T("service_name"), 0, REG_SZ, (CONST BYTE*)szTempStr, (DWORD)_tcslen(szTempStr)*sizeof(TCHAR)) != ERROR_SUCCESS) { return FALSE; } //GetWindowsDirectory(szTempStr,MAX_PATH); //if (RegSetValueEx(hKey, _T("system_dir"), 0, REG_SZ, (CONST BYTE*)szTempStr, (DWORD)_tcslen(szTempStr)*sizeof(TCHAR)) != ERROR_SUCCESS) //{ // return FALSE; //} RegFlushKey(hKey); RegCloseKey(hKey); _tcscpy_s(szTempStr, MAX_PATH, _T("SYSTEM\\CurrentControlSet\\Services\\")); _tcscat_s(szTempStr, MAX_PATH, lpszServiceName); _tcscat_s(szTempStr, MAX_PATH, _T("\\Instances")); if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szTempStr, 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, (LPDWORD)&dwData) != ERROR_SUCCESS) { return FALSE; } _tcscpy_s(szTempStr, MAX_PATH, lpszServiceName); _tcscat_s(szTempStr, MAX_PATH, _T(" Instance")); if (RegSetValueEx(hKey, _T("DefaultInstance"), 0, REG_SZ, (CONST BYTE*)szTempStr, (DWORD)_tcslen(szTempStr)*sizeof(TCHAR)) != ERROR_SUCCESS) { return FALSE; } RegFlushKey(hKey); RegCloseKey(hKey); _tcscpy_s(szTempStr, MAX_PATH, _T("SYSTEM\\CurrentControlSet\\Services\\")); _tcscat_s(szTempStr, MAX_PATH, lpszServiceName); _tcscat_s(szTempStr, MAX_PATH, _T("\\Instances\\")); _tcscat_s(szTempStr, MAX_PATH, lpszServiceName); _tcscat_s(szTempStr, MAX_PATH, _T(" Instance")); if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szTempStr, 0, _T(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, (LPDWORD)&dwData) != ERROR_SUCCESS) { return FALSE; } _tcscpy_s(szTempStr, lpszAltitude); if (RegSetValueEx(hKey, _T("Altitude"), 0, REG_SZ, (CONST BYTE*)szTempStr, (DWORD)_tcslen(szTempStr)*sizeof(TCHAR)) != ERROR_SUCCESS) { return FALSE; } dwData = 0x0; if (RegSetValueEx(hKey, _T("Flags"), 0, REG_DWORD, (CONST BYTE*)&dwData, sizeof(DWORD)) != ERROR_SUCCESS) { return FALSE; } RegFlushKey(hKey); RegCloseKey(hKey); return TRUE; }
BOOL ServiceRun() { SC_HANDLE scm, Service; SERVICE_STATUS ssStatus; DWORD dwOldCheckPoint; DWORD dwStartTickCount; DWORD dwWaitTime; DWORD dwStatus; scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (!scm) { ErrorHandler("OpenSCManager", GetLastError()); } Service = OpenService(scm, ServiceName, SERVICE_ALL_ACCESS); if (!Service) { ErrorHandler("OpenService", GetLastError()); return FALSE; } else { StartService(Service, 0, NULL); srvc.GetStatus(Service); if (!QueryServiceStatus( Service, &ssStatus) ) { ErrorHandler("QueryServiceStatus", GetLastError()); } dwStartTickCount = GetTickCount(); dwOldCheckPoint = ssStatus.dwCheckPoint; while (ssStatus.dwCurrentState == SERVICE_START_PENDING) { dwWaitTime = ssStatus.dwWaitHint / 10; if( dwWaitTime < 1000 ) { dwWaitTime = 1000; } else if ( dwWaitTime > 10000 ) { dwWaitTime = 10000; } Sleep( dwWaitTime ); if (!QueryServiceStatus(Service, &ssStatus) ) { break; } if ( ssStatus.dwCheckPoint > dwOldCheckPoint ) { dwStartTickCount = GetTickCount(); dwOldCheckPoint = ssStatus.dwCheckPoint; } else { if(GetTickCount()-dwStartTickCount > ssStatus.dwWaitHint) { break; } } } if (ssStatus.dwCurrentState == SERVICE_RUNNING) { srvc.GetStatus(Service); dwStatus = NO_ERROR; } else { printf("\nService not started.\n"); printf(" Current State: %d\n", ssStatus.dwCurrentState); printf(" Exit Code: %d\n", ssStatus.dwWin32ExitCode); printf(" Service Specific Exit Code: %d\n", ssStatus.dwServiceSpecificExitCode); printf(" Check Point: %d\n", ssStatus.dwCheckPoint); printf(" Wait Hint: %d\n", ssStatus.dwWaitHint); dwStatus = GetLastError(); } } CloseServiceHandle(scm); CloseServiceHandle(Service); return TRUE; }
BOOL UtilLoadDriver( _In_ LPTSTR szDriverName, _In_ LPTSTR szDriverFileName, _In_ LPTSTR szWin32DeviceName, _Out_ HANDLE *pDriver ) /*++ Routine Description: This routine uses the Service Control Manager APIs to create an entry for a standalone driver. It then opens a handle to the driver. The driver is assumed to be in the current directory. NOTE: This routine creates an entry for a standalone driver. If this is modified for use with a driver that requires a Tag, Group, and/or Dependencies, it may be necessary to query the registry for existing driver information (in order to determine a unique Tag, etc.). Arguments: szDriverName - name of the driver (no extension) szDriverFileName - name of driver (with extension) szWin32DeviceName - Name of driver (no extension) prefixed with \\.\ pDriver - pointer to a variable that receives the handle to the driver Return Value: TRUE if driver is loaded successfully. --*/ { BOOL ReturnValue = FALSE; TCHAR* pPathSeparator; TCHAR szDriverPath[MAX_PATH] = _T(""); DWORD dwSize; SC_HANDLE hSCM = NULL; HANDLE hDriver = NULL; *pDriver = NULL; // // Construct driver path. // dwSize = GetModuleFileName(NULL, szDriverPath, ARRAY_LENGTH(szDriverPath)); if (dwSize == 0) { ErrorPrint("GetModuleFileName failed, last error 0x%u", GetLastError()); goto Exit; } pPathSeparator = _tcsrchr(szDriverPath, _T('\\')); if (pPathSeparator != NULL) { pPathSeparator[1] = _T('\0'); _tcscat_s(szDriverPath, MAX_PATH, szDriverFileName); } else { ErrorPrint("_tcsrchr failed to file \\ in driver path."); goto Exit; } // // Get a handle to SCM // hSCM = OpenSCManager ( NULL, NULL, SC_MANAGER_ALL_ACCESS ); if (hSCM == NULL) { ErrorPrint("OpenSCManager failed, last error 0x%x", GetLastError()); goto Exit; } // // First, uninstall and unload the driver. // ReturnValue = UtilUnloadDriver( INVALID_HANDLE_VALUE, hSCM, szDriverName); if (ReturnValue != TRUE) { ErrorPrint("UnloadDriver failed"); goto Exit; } // // Install the driver. // ReturnValue = UtilCreateService(hSCM, szDriverName, szDriverPath); if (ReturnValue == FALSE) { ErrorPrint("UtilCreateService failed"); goto Exit; } // // Load the driver. // ReturnValue = UtilStartService(hSCM, szDriverName); if (ReturnValue == FALSE) { ErrorPrint("UtilStartService failed"); goto Exit; } // // Open a handle to the device. // ReturnValue = UtilOpenDevice(szWin32DeviceName, &hDriver); if (ReturnValue == FALSE) { ErrorPrint("UtilOpenDevice failed"); goto Exit; } *pDriver = hDriver; ReturnValue = TRUE; Exit: if (hSCM != NULL) { CloseServiceHandle(hSCM); } return ReturnValue; }
// Invoked with the /INSTALL switch. Installs LightRepeater Engine as a // Windows NT Service using Service Control Manager. EXTERN_C int WINAPI InstallService(int argc, char **argv) { if (argc > 4) puts("InstallService(): Too many parameters."); LPSTR pcMachineName = NULL; if (argc >= 4) pcMachineName = argv[argc-1]; const char cRunServiceSwitch[] = "\" /RUNSERVICE"; char cImagePath[MAX_PATH+sizeof(cRunServiceSwitch)+2] = "\""; if (argv[2]) strncpy(cImagePath+1, argv[2], MAX_PATH); else GetModuleFileName(NULL, cImagePath+1, MAX_PATH); strcat(cImagePath, cRunServiceSwitch); if (argc > 4) { if (strlen(cImagePath)+strlen(argv[3])+4 > sizeof(cImagePath)) { fputs("Too long parameter.\r\n", stderr); return 1; } strcat(cImagePath, " \""); strcat(cImagePath, argv[3]); strcat(cImagePath, "\""); } puts("Opening Service Control Manager..."); SC_HANDLE hSC = OpenSCManager(pcMachineName, NULL, SC_MANAGER_CREATE_SERVICE); if (hSC == NULL) { if (win_errno == ERROR_CALL_NOT_IMPLEMENTED) fputs("Error: There is no Service Control Manager available in this " "operating system.\r\n", stderr); else win_perror(); return 1; } puts("Creating service..."); SC_HANDLE hService = CreateService(hSC, LR_SERVICE_NAME, LR_SERVICE_DESCRIPTION, 0, SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, cImagePath, NULL, NULL, NULL, NULL, NULL); if (hService) { puts("Service install successful."); CloseServiceHandle(hService); CloseServiceHandle(hSC); return 0; } else { win_perror(); CloseServiceHandle(hSC); return 1; } }
unsigned char StartPortTalkDriver(void) { SC_HANDLE SchSCManager; SC_HANDLE schService; BOOL ret; DWORD err; /* Open Handle to Service Control Manager */ SchSCManager = OpenSCManager (NULL, /* machine (NULL == local) */ NULL, /* database (NULL == default) */ SC_MANAGER_ALL_ACCESS); /* access required */ if (SchSCManager == NULL) if (GetLastError() == ERROR_ACCESS_DENIED) { /* We do not have enough rights to open the SCM, therefore we must */ /* be a poor user with only user rights. */ printf("PortTalk: You do not have rights to access the Service Control Manager and\n"); printf("PortTalk: the PortTalk driver is not installed or started. Please ask \n"); printf("PortTalk: your administrator to install the driver on your behalf.\n"); return(0); } do { /* Open a Handle to the PortTalk Service Database */ schService = OpenService(SchSCManager, /* handle to service control manager database */ "PortTalk", /* pointer to name of service to start */ SERVICE_ALL_ACCESS); /* type of access to service */ if (schService == NULL) switch (GetLastError()) { case ERROR_ACCESS_DENIED: printf("PortTalk: You do not have rights to the PortTalk service database\n"); return(0); case ERROR_INVALID_NAME: printf("PortTalk: The specified service name is invalid.\n"); return(0); case ERROR_SERVICE_DOES_NOT_EXIST: printf("PortTalk: The PortTalk driver does not exist. Installing driver.\n"); printf("PortTalk: This can take up to 30 seconds on some machines . .\n"); InstallPortTalkDriver(); break; } } while (schService == NULL); /* Start the PortTalk Driver. Errors will occur here if PortTalk.SYS file doesn't exist */ ret = StartService (schService, /* service identifier */ 0, /* number of arguments */ NULL); /* pointer to arguments */ if (ret) printf("PortTalk: The PortTalk driver has been successfully started.\n"); else { err = GetLastError(); if (err == ERROR_SERVICE_ALREADY_RUNNING) printf("PortTalk: The PortTalk driver is already running.\n"); else { printf("PortTalk: Unknown error while starting PortTalk driver service.\n"); printf("PortTalk: Does PortTalk.SYS exist in your \\System32\\Drivers Directory?\n"); return(0); } } /* Close handle to Service Control Manager */ CloseServiceHandle (schService); return(TRUE); }
DLLEXP bool NewSvr(PSvrHnds pSH) { bool bSuccess = false; char FullName[MAX_PATH]; if(pSH == NULL) { PRINT("[%s]error : pSH == NULL!\n",__func__); goto QUIT; } pSH->hSCM = OpenSCManager(NULL,NULL,SC_MANAGER_CREATE_SERVICE); if(!pSH->hSCM) { PRINT("[%s]error : OpenSCManager Failed!\n",\ __func__); goto QUIT; } if(GetFullPathName(SYSNAME,sizeof(FullName),\ FullName,NULL) < strlen(SYSNAME)+1) { PRINT("[%s]error : Get SYS FullPathName Failed!\n",\ __func__); goto QUIT; } pSH->hSVR = CreateService(pSH->hSCM,SVRNAME,SVRNOTE,\ SERVICE_ALL_ACCESS,SERVICE_KERNEL_DRIVER,\ SERVICE_DEMAND_START,SERVICE_ERROR_IGNORE,\ FullName,NULL,NULL,NULL,NULL,NULL); if(!pSH->hSVR && GetLastError() == ERROR_SERVICE_EXISTS) { PRINT("[%s]msg : Servicr Existed , Try To Open!\n",\ __func__); pSH->hSVR = OpenService(pSH->hSCM,SVRNAME,\ SERVICE_ALL_ACCESS); if(!pSH->hSVR) { PRINT("[%s]err : OpenService Failed!\n",\ __func__); goto QUIT; } } else if(!pSH->hSVR) { PRINT("[%s]error : CreateService Failed!\n",\ __func__); goto QUIT; } bSuccess = true; QUIT: if(!bSuccess) { if(pSH->hSCM) CloseServiceHandle(pSH->hSCM); if(pSH->hSVR) CloseServiceHandle(pSH->hSVR); } return bSuccess; }
ServiceController() { _scManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); }
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) { if( lpCmdLine[0] == _T('-') || lpCmdLine[0] == _T('/') ){ if( lstrcmpi(_T("install"), lpCmdLine + 1) == 0 ){ bool installed = false; TCHAR exePath[512]; if( GetModuleFileName(NULL, exePath, _countof(exePath)) != 0 ){ SC_HANDLE hScm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE); if( hScm != NULL ){ SC_HANDLE hSrv = CreateService( hScm, SERVICE_NAME, SERVICE_NAME, 0, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, exePath, NULL, NULL, NULL, NULL, NULL); if( hSrv != NULL ){ installed = true; CloseServiceHandle(hSrv); } CloseServiceHandle(hScm); } } if( installed == false ){ //コンソールがないのでメッセージボックスで伝える MessageBox(NULL, L"Failed to install/remove " SERVICE_NAME L".\r\nRun as Administrator on Vista and later.", NULL, MB_ICONERROR); } return 0; }else if( lstrcmpi(_T("remove"), lpCmdLine + 1) == 0 ){ bool removed = false; SC_HANDLE hScm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT); if( hScm != NULL ){ SC_HANDLE hSrv = OpenService(hScm, SERVICE_NAME, DELETE | SERVICE_STOP | SERVICE_QUERY_STATUS); if( hSrv != NULL ){ SERVICE_STATUS srvStatus; if( QueryServiceStatus(hSrv, &srvStatus) != FALSE ){ if( srvStatus.dwCurrentState == SERVICE_STOPPED || ControlService(hSrv, SERVICE_CONTROL_STOP, &srvStatus) != FALSE ){ removed = DeleteService(hSrv) != FALSE; } } CloseServiceHandle(hSrv); } CloseServiceHandle(hScm); } if( removed == false ){ MessageBox(NULL, L"Failed to install/remove " SERVICE_NAME L".\r\nRun as Administrator on Vista and later.", NULL, MB_ICONERROR); } return 0; } } if( IsInstallService(SERVICE_NAME) == FALSE ){ //普通にexeとして起動を行う HANDLE hMutex = CreateMutex(NULL, TRUE, EPG_TIMER_BON_SRV_MUTEX); if( hMutex != NULL ){ if( GetLastError() != ERROR_ALREADY_EXISTS ){ StartDebugLog(); //メインスレッドに対するCOMの初期化 CoInitialize(NULL); CEpgTimerSrvMain* pMain = new CEpgTimerSrvMain; if( pMain->Main(false) == false ){ OutputDebugString(_T("_tWinMain(): Failed to start\r\n")); } delete pMain; CoUninitialize(); StopDebugLog(); } ReleaseMutex(hMutex); CloseHandle(hMutex); } }else if( IsStopService(SERVICE_NAME) == FALSE ){ //サービスとして実行 HANDLE hMutex = CreateMutex(NULL, TRUE, EPG_TIMER_BON_SRV_MUTEX); if( hMutex != NULL ){ if( GetLastError() != ERROR_ALREADY_EXISTS ){ StartDebugLog(); SERVICE_TABLE_ENTRY dispatchTable[] = { { SERVICE_NAME, service_main }, { NULL, NULL } }; if( StartServiceCtrlDispatcher(dispatchTable) == FALSE ){ OutputDebugString(_T("_tWinMain(): StartServiceCtrlDispatcher failed\r\n")); } StopDebugLog(); } ReleaseMutex(hMutex); CloseHandle(hMutex); } }else{ //Stop状態なのでサービスの開始を要求 bool started = false; SC_HANDLE hScm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT); if( hScm != NULL ){ SC_HANDLE hSrv = OpenService(hScm, SERVICE_NAME, SERVICE_START); if( hSrv != NULL ){ started = StartService(hSrv, 0, NULL) != FALSE; CloseServiceHandle(hSrv); } CloseServiceHandle(hScm); } if( started == false ){ OutputDebugString(_T("_tWinMain(): Failed to start\r\n")); } } return 0; }
BOOL install_service() { SC_HANDLE hSCManager; SC_HANDLE hService; char path[MAX_PATH]; // Get the current module name if (!GetModuleFileName(NULL, path, MAX_PATH)) { printf("Cannot get module name (0x%08x)\n", GetLastError()); return FALSE; } // Build the service command line char cmd[MAX_PATH]; int len = _snprintf(cmd, sizeof(cmd), "\"%s\" service", path); if (len < 0 || len == sizeof(cmd)) { printf("Cannot build service command line (0x%08x)\n", -1); return FALSE; } // Open the service manager hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE); if (hSCManager == NULL) { printf("Cannot open service manager (0x%08x)\n", GetLastError()); return FALSE; } printf(" * Installing service %s\n", SERVICE_NAME); fflush(stdout); // Create the service hService = CreateService( hSCManager, SERVICE_NAME, DISPLAY_NAME, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, cmd, NULL, NULL, NULL, NULL, /* LocalSystem account */ NULL ); if (hService == NULL) { printf("Cannot create service (0x%08x)\n", GetLastError()); CloseServiceHandle(hSCManager); return FALSE; } // Start the service printf(" * Starting service\n"); fflush(stdout); char* args[] = { path, "service" }; if (StartService(hService, 2, (const char**)&args) == 0) { DWORD err = GetLastError(); if (err != ERROR_SERVICE_ALREADY_RUNNING) { printf("Cannot start service %s (0x%08x)\n", SERVICE_NAME, err); CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return FALSE; } } // Cleanup CloseServiceHandle(hService); CloseServiceHandle(hSCManager); printf("Service %s successfully installed.\n", SERVICE_NAME); fflush(stdout); return TRUE; }
int SERVICE_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result) { ENUM_SERVICE_STATUS_PROCESS *ssp = NULL; QUERY_SERVICE_CONFIG *qsc = NULL; SERVICE_DESCRIPTION *scd = NULL; SC_HANDLE h_mgr; DWORD sz = 0, szn, i, k, services, resume_handle = 0; char *utf8; struct zbx_json j; if (NULL == (h_mgr = OpenSCManager(NULL, NULL, GENERIC_READ))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain system information.")); return SYSINFO_RET_FAIL; } zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN); zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA); while (0 != EnumServicesStatusEx(h_mgr, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, (LPBYTE)ssp, sz, &szn, &services, &resume_handle, NULL) || ERROR_MORE_DATA == GetLastError()) { for (i = 0; i < services; i++) { SC_HANDLE h_srv; DWORD current_state; if (NULL == (h_srv = OpenService(h_mgr, ssp[i].lpServiceName, SERVICE_QUERY_CONFIG))) continue; QueryServiceConfig(h_srv, NULL, 0, &sz); if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain configuration of service \"%s\": %s", ssp[i].lpServiceName, strerror_from_system(GetLastError())); goto next; } qsc = (QUERY_SERVICE_CONFIG *)zbx_malloc(qsc, sz); if (0 == QueryServiceConfig(h_srv, qsc, sz, &sz)) { zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain configuration of service \"%s\": %s", ssp[i].lpServiceName, strerror_from_system(GetLastError())); goto next; } QueryServiceConfig2(h_srv, SERVICE_CONFIG_DESCRIPTION, NULL, 0, &sz); if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain description of service \"%s\": %s", ssp[i].lpServiceName, strerror_from_system(GetLastError())); goto next; } scd = (SERVICE_DESCRIPTION *)zbx_malloc(scd, sz); if (0 == QueryServiceConfig2(h_srv, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)scd, sz, &sz)) { zabbix_log(LOG_LEVEL_DEBUG, "cannot obtain description of service \"%s\": %s", ssp[i].lpServiceName, strerror_from_system(GetLastError())); goto next; } zbx_json_addobject(&j, NULL); utf8 = zbx_unicode_to_utf8(ssp[i].lpServiceName); zbx_json_addstring(&j, "{#SERVICE.NAME}", utf8, ZBX_JSON_TYPE_STRING); zbx_free(utf8); utf8 = zbx_unicode_to_utf8(ssp[i].lpDisplayName); zbx_json_addstring(&j, "{#SERVICE.DISPLAYNAME}", utf8, ZBX_JSON_TYPE_STRING); zbx_free(utf8); if (NULL != scd->lpDescription) { utf8 = zbx_unicode_to_utf8(scd->lpDescription); zbx_json_addstring(&j, "{#SERVICE.DESCRIPTION}", utf8, ZBX_JSON_TYPE_STRING); zbx_free(utf8); } else zbx_json_addstring(&j, "{#SERVICE.DESCRIPTION}", "", ZBX_JSON_TYPE_STRING); current_state = ssp[i].ServiceStatusProcess.dwCurrentState; for (k = 0; k < ARRSIZE(service_states) && current_state != service_states[k]; k++) ; zbx_json_adduint64(&j, "{#SERVICE.STATE}", k); zbx_json_addstring(&j, "{#SERVICE.STATENAME}", get_state_string(current_state), ZBX_JSON_TYPE_STRING); utf8 = zbx_unicode_to_utf8(qsc->lpBinaryPathName); zbx_json_addstring(&j, "{#SERVICE.PATH}", utf8, ZBX_JSON_TYPE_STRING); zbx_free(utf8); utf8 = zbx_unicode_to_utf8(qsc->lpServiceStartName); zbx_json_addstring(&j, "{#SERVICE.USER}", utf8, ZBX_JSON_TYPE_STRING); zbx_free(utf8); if (SERVICE_AUTO_START == qsc->dwStartType) { if (SUCCEED == check_delayed_start(h_srv)) { zbx_json_adduint64(&j, "{#SERVICE.STARTUP}", 1); zbx_json_addstring(&j, "{#SERVICE.STARTUPNAME}", "automatic delayed", ZBX_JSON_TYPE_STRING); } else { zbx_json_adduint64(&j, "{#SERVICE.STARTUP}", 0); zbx_json_addstring(&j, "{#SERVICE.STARTUPNAME}", "automatic", ZBX_JSON_TYPE_STRING); } } else { for (k = 2; k < ARRSIZE(start_types) && qsc->dwStartType != start_types[k]; k++) ; zbx_json_adduint64(&j, "{#SERVICE.STARTUP}", k); zbx_json_addstring(&j, "{#SERVICE.STARTUPNAME}", get_startup_string(qsc->dwStartType), ZBX_JSON_TYPE_STRING); } zbx_json_close(&j); next: zbx_free(scd); zbx_free(qsc); CloseServiceHandle(h_srv); } if (0 == szn) break; if (NULL == ssp) { sz = szn; ssp = (ENUM_SERVICE_STATUS_PROCESS *)zbx_malloc(ssp, sz); } } zbx_free(ssp); CloseServiceHandle(h_mgr); zbx_json_close(&j); SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer)); zbx_json_free(&j); return SYSINFO_RET_OK; }
int main(int argc, char *argv[]) { char *bslash; VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx(&VerInfo); if (argc < 2) { show_usage(); return -1; } hAdvapi = LoadLibrary("advapi32.dll"); uChangeServiceConfig2 = (UCHANGESERVICECONFIG2)GetProcAddress(hAdvapi, "ChangeServiceConfig2A"); if (!stricmp(argv[1], "install")) { SC_HANDLE hService, hSCManager; char path[MAX_PATH+1]; char binpath[MAX_PATH+1]; hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE); if (!hSCManager) { exit(0); } GetModuleFileName(NULL,path,MAX_PATH); if ((bslash = strrchr(path, '\\'))) *bslash = 0; strcpy(binpath,path); strcat(binpath, "\\wircd.exe"); hService = CreateService(hSCManager, "UnrealIRCd", "UnrealIRCd", SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, binpath, NULL, NULL, NULL, NULL, NULL); if (hService) { printf("UnrealIRCd NT Service successfully installed"); if (VerInfo.dwMajorVersion >= 5) { SERVICE_DESCRIPTION info; info.lpDescription = "Internet Relay Chat Server. Allows users to chat with eachother via an IRC client."; uChangeServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, &info); } CloseServiceHandle(hService); } else printf("Failed to install UnrealIRCd NT Service - %s", show_error(GetLastError())); CloseServiceHandle(hSCManager); return 0; } else if (!stricmp(argv[1], "uninstall")) { SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); SC_HANDLE hService = OpenService(hSCManager, "UnrealIRCd", DELETE); if (DeleteService(hService)) printf("UnrealIRCd NT Service successfully uninstalled"); else printf("Failed to uninstall UnrealIRCd NT Service - %s", show_error(GetLastError())); CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return 0; } else if (!stricmp(argv[1], "start")) { SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); SC_HANDLE hService = OpenService(hSCManager, "UnrealIRCd", SERVICE_START); if (StartService(hService, 0, NULL)) printf("UnrealIRCd NT Service successfully started"); else printf("Failed to start UnrealIRCd NT Service - %s", show_error(GetLastError())); CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return 0; } else if (!stricmp(argv[1], "stop")) { SERVICE_STATUS status; SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); SC_HANDLE hService = OpenService(hSCManager, "UnrealIRCd", SERVICE_STOP); ControlService(hService, SERVICE_CONTROL_STOP, &status); printf("UnrealIRCd NT Service successfully stopped"); CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return 0; } else if (!stricmp(argv[1], "restart")) { SERVICE_STATUS status; SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); SC_HANDLE hService = OpenService(hSCManager, "UnrealIRCd", SERVICE_STOP|SERVICE_START); ControlService(hService, SERVICE_CONTROL_STOP, &status); if (StartService(hService, 0, NULL)) printf("UnrealIRCd NT Service successfully restarted"); CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return 0; } else if (!stricmp(argv[1], "rehash")) { SERVICE_STATUS status; SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); SC_HANDLE hService = OpenService(hSCManager, "UnrealIRCd", SERVICE_USER_DEFINED_CONTROL); ControlService(hService, IRCD_SERVICE_CONTROL_REHASH, &status); printf("UnrealIRCd NT Service successfully rehashed"); } else if (!stricmp(argv[1], "config")) { SERVICE_STATUS status; SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); SC_HANDLE hService = OpenService(hSCManager, "UnrealIRCd", SERVICE_CHANGE_CONFIG|SERVICE_START); if (argc < 3) { show_usage(); return -1; } if (!stricmp(argv[2], "startup")) { if (ChangeServiceConfig(hService, SERVICE_NO_CHANGE, !stricmp(argv[3], "auto") ? SERVICE_AUTO_START : SERVICE_DEMAND_START, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL)) printf("UnrealIRCd NT Service configuration changed"); else printf("UnrealIRCd NT Service configuration change failed - %s", show_error(GetLastError())); } else if (!stricmp(argv[2], "crashrestart") && VerInfo.dwMajorVersion == 5) { SERVICE_FAILURE_ACTIONS hFailActions; SC_ACTION hAction; memset(&hFailActions, 0, sizeof(hFailActions)); if (argc >= 4) { hFailActions.dwResetPeriod = 30; hFailActions.cActions = 1; hAction.Type = SC_ACTION_RESTART; hAction.Delay = atoi(argv[3])*60000; hFailActions.lpsaActions = &hAction; if (uChangeServiceConfig2(hService, SERVICE_CONFIG_FAILURE_ACTIONS, &hFailActions)) printf("UnrealIRCd NT Service configuration changed"); else printf("UnrealIRCd NT Service configuration change failed - %s", show_error(GetLastError())); } else { hFailActions.dwResetPeriod = 0; hFailActions.cActions = 0; hAction.Type = SC_ACTION_NONE; hFailActions.lpsaActions = &hAction; if (uChangeServiceConfig2(hService, SERVICE_CONFIG_FAILURE_ACTIONS, &hFailActions)) printf("UnrealIRCd NT Service configuration changed"); else printf("UnrealIRCd NT Service configuration change failed - %s", show_error(GetLastError())); } } else { show_usage(); return -1; } } else { show_usage(); return -1; } }
int SERVICES(AGENT_REQUEST *request, AGENT_RESULT *result) { int start_type, service_state; char *type, *state, *exclude, *buf = NULL, *utf8; SC_HANDLE h_mgr; ENUM_SERVICE_STATUS_PROCESS *ssp = NULL; DWORD sz = 0, szn, i, services, resume_handle = 0; if (3 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } type = get_rparam(request, 0); state = get_rparam(request, 1); exclude = get_rparam(request, 2); if (NULL == type || '\0' == *type || 0 == strcmp(type, "all")) /* default parameter */ start_type = ZBX_SRV_STARTTYPE_ALL; else if (0 == strcmp(type, "automatic")) start_type = ZBX_SRV_STARTTYPE_AUTOMATIC; else if (0 == strcmp(type, "manual")) start_type = ZBX_SRV_STARTTYPE_MANUAL; else if (0 == strcmp(type, "disabled")) start_type = ZBX_SRV_STARTTYPE_DISABLED; else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return SYSINFO_RET_FAIL; } if (NULL == state || '\0' == *state || 0 == strcmp(state, "all")) /* default parameter */ service_state = ZBX_SRV_STATE_ALL; else if (0 == strcmp(state, "stopped")) service_state = ZBX_SRV_STATE_STOPPED; else if (0 == strcmp(state, "started")) service_state = ZBX_SRV_STATE_STARTED; else if (0 == strcmp(state, "start_pending")) service_state = ZBX_SRV_STATE_START_PENDING; else if (0 == strcmp(state, "stop_pending")) service_state = ZBX_SRV_STATE_STOP_PENDING; else if (0 == strcmp(state, "running")) service_state = ZBX_SRV_STATE_RUNNING; else if (0 == strcmp(state, "continue_pending")) service_state = ZBX_SRV_STATE_CONTINUE_PENDING; else if (0 == strcmp(state, "pause_pending")) service_state = ZBX_SRV_STATE_PAUSE_PENDING; else if (0 == strcmp(state, "paused")) service_state = ZBX_SRV_STATE_PAUSED; else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid second parameter.")); return SYSINFO_RET_FAIL; } if (NULL == (h_mgr = OpenSCManager(NULL, NULL, GENERIC_READ))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain system information.")); return SYSINFO_RET_FAIL; } while (0 != EnumServicesStatusEx(h_mgr, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, (LPBYTE)ssp, sz, &szn, &services, &resume_handle, NULL) || ERROR_MORE_DATA == GetLastError()) { for (i = 0; i < services; i++) { SC_HANDLE h_srv; if (NULL == (h_srv = OpenService(h_mgr, ssp[i].lpServiceName, SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG))) { continue; } if (SUCCEED == check_service_starttype(h_srv, start_type)) { if (SUCCEED == check_service_state(h_srv, service_state)) { utf8 = zbx_unicode_to_utf8(ssp[i].lpServiceName); if (NULL == exclude || FAIL == str_in_list(exclude, utf8, ',')) buf = zbx_strdcatf(buf, "%s\n", utf8); zbx_free(utf8); } } CloseServiceHandle(h_srv); } if (0 == szn) break; if (NULL == ssp) { sz = szn; ssp = (ENUM_SERVICE_STATUS_PROCESS *)zbx_malloc(ssp, sz); } } zbx_free(ssp); CloseServiceHandle(h_mgr); if (NULL == buf) buf = zbx_strdup(buf, "0"); SET_STR_RESULT(result, buf); return SYSINFO_RET_OK; }
int SERVICE_STATE(AGENT_REQUEST *request, AGENT_RESULT *result) { SC_HANDLE mgr, service; char *name; wchar_t *wname; wchar_t service_name[MAX_STRING_LEN]; DWORD max_len_name = MAX_STRING_LEN; int i; SERVICE_STATUS status; if (1 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } name = get_rparam(request, 0); if (NULL == name || '\0' == *name) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return SYSINFO_RET_FAIL; } if (NULL == (mgr = OpenSCManager(NULL, NULL, GENERIC_READ))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain system information.")); return SYSINFO_RET_FAIL; } wname = zbx_utf8_to_unicode(name); service = OpenService(mgr, wname, SERVICE_QUERY_STATUS); if (NULL == service && 0 != GetServiceKeyName(mgr, wname, service_name, &max_len_name)) service = OpenService(mgr, service_name, SERVICE_QUERY_STATUS); zbx_free(wname); if (NULL == service) { SET_UI64_RESULT(result, 255); } else { if (0 != QueryServiceStatus(service, &status)) { for (i = 0; i < ARRSIZE(service_states) && status.dwCurrentState != service_states[i]; i++) ; SET_UI64_RESULT(result, i); } else SET_UI64_RESULT(result, 7); CloseServiceHandle(service); } CloseServiceHandle(mgr); return SYSINFO_RET_OK; }
int SERVICE_INFO(AGENT_REQUEST *request, AGENT_RESULT *result) { QUERY_SERVICE_CONFIG *qsc = NULL; SERVICE_DESCRIPTION *scd = NULL; SERVICE_STATUS status; SC_HANDLE h_mgr, h_srv; DWORD sz = 0; int param_type, i; char *name, *param; wchar_t *wname, service_name[MAX_STRING_LEN]; DWORD max_len_name = MAX_STRING_LEN; if (2 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } name = get_rparam(request, 0); param = get_rparam(request, 1); if (NULL == name || '\0' == *name) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return SYSINFO_RET_FAIL; } if (NULL == param || '\0' == *param || 0 == strcmp(param, "state")) /* default second parameter */ param_type = ZBX_SRV_PARAM_STATE; else if (0 == strcmp(param, "displayname")) param_type = ZBX_SRV_PARAM_DISPLAYNAME; else if (0 == strcmp(param, "path")) param_type = ZBX_SRV_PARAM_PATH; else if (0 == strcmp(param, "user")) param_type = ZBX_SRV_PARAM_USER; else if (0 == strcmp(param, "startup")) param_type = ZBX_SRV_PARAM_STARTUP; else if (0 == strcmp(param, "description")) param_type = ZBX_SRV_PARAM_DESCRIPTION; else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid second parameter.")); return SYSINFO_RET_FAIL; } if (NULL == (h_mgr = OpenSCManager(NULL, NULL, GENERIC_READ))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain system information.")); return SYSINFO_RET_FAIL; } wname = zbx_utf8_to_unicode(name); h_srv = OpenService(h_mgr, wname, SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG); if (NULL == h_srv && 0 != GetServiceKeyName(h_mgr, wname, service_name, &max_len_name)) h_srv = OpenService(h_mgr, service_name, SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG); zbx_free(wname); if (NULL == h_srv) { int ret; if (ZBX_SRV_PARAM_STATE == param_type) { SET_UI64_RESULT(result, 255); ret = SYSINFO_RET_OK; } else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot find the specified service.")); ret = SYSINFO_RET_FAIL; } CloseServiceHandle(h_mgr); return ret; } if (ZBX_SRV_PARAM_STATE == param_type) { if (0 != QueryServiceStatus(h_srv, &status)) { for (i = 0; i < ARRSIZE(service_states) && status.dwCurrentState != service_states[i]; i++) ; SET_UI64_RESULT(result, i); } else SET_UI64_RESULT(result, 7); } else if (ZBX_SRV_PARAM_DESCRIPTION == param_type) { QueryServiceConfig2(h_srv, SERVICE_CONFIG_DESCRIPTION, NULL, 0, &sz); if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain service description: %s", strerror_from_system(GetLastError()))); CloseServiceHandle(h_srv); CloseServiceHandle(h_mgr); return SYSINFO_RET_FAIL; } scd = (SERVICE_DESCRIPTION *)zbx_malloc(scd, sz); if (0 == QueryServiceConfig2(h_srv, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)scd, sz, &sz)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain service description: %s", strerror_from_system(GetLastError()))); zbx_free(scd); CloseServiceHandle(h_srv); CloseServiceHandle(h_mgr); return SYSINFO_RET_FAIL; } if (NULL == scd->lpDescription) SET_TEXT_RESULT(result, zbx_strdup(NULL, "")); else SET_TEXT_RESULT(result, zbx_unicode_to_utf8(scd->lpDescription)); zbx_free(scd); } else { QueryServiceConfig(h_srv, NULL, 0, &sz); if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain service configuration: %s", strerror_from_system(GetLastError()))); CloseServiceHandle(h_srv); CloseServiceHandle(h_mgr); return SYSINFO_RET_FAIL; } qsc = (QUERY_SERVICE_CONFIG *)zbx_malloc(qsc, sz); if (0 == QueryServiceConfig(h_srv, qsc, sz, &sz)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain service configuration: %s", strerror_from_system(GetLastError()))); zbx_free(qsc); CloseServiceHandle(h_srv); CloseServiceHandle(h_mgr); return SYSINFO_RET_FAIL; } switch (param_type) { case ZBX_SRV_PARAM_DISPLAYNAME: SET_STR_RESULT(result, zbx_unicode_to_utf8(qsc->lpDisplayName)); break; case ZBX_SRV_PARAM_PATH: SET_STR_RESULT(result, zbx_unicode_to_utf8(qsc->lpBinaryPathName)); break; case ZBX_SRV_PARAM_USER: SET_STR_RESULT(result, zbx_unicode_to_utf8(qsc->lpServiceStartName)); break; case ZBX_SRV_PARAM_STARTUP: if (SERVICE_AUTO_START == qsc->dwStartType) { if (SUCCEED == check_delayed_start(h_srv)) SET_UI64_RESULT(result, 1); else SET_UI64_RESULT(result, 0); } else { for (i = 2; i < ARRSIZE(start_types) && qsc->dwStartType != start_types[i]; i++) ; SET_UI64_RESULT(result, i); } break; } zbx_free(qsc); } CloseServiceHandle(h_srv); CloseServiceHandle(h_mgr); return SYSINFO_RET_OK; }
void LoadKernelDriver() { CONFIG_DATA *cd = GetConfigData(); // Open the service control manager g_hSCM = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS); if (!g_hSCM) Die("Unable to open the service control manager"); // Stop the old driver service if its running g_hDriverService = OpenService(g_hSCM, PROCFILTER_DRIVER_SERVICE_NAME, SERVICE_START | SERVICE_STOP | DELETE | SERVICE_QUERY_STATUS); if (g_hDriverService) { if (!ServiceStop(g_hDriverService, 2 * 60 * 1000)) Die("Unable to stop previously running driver service"); LogDebugFmt("Opened driver service"); } else { Die("Unable to open old driver service: %u", GetLastError()); } // Service handle opened and the driver is to be started // Start the driver service BOOL rc = StartService(g_hDriverService, 0, NULL); DWORD dwErrorCode = GetLastError(); if (!rc) Die("Unable to start driver service: %u", dwErrorCode); // It's running, so open it g_hDriver = CreateFileW(PROCFILTER_DEVICE_PATH, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (g_hDriver == INVALID_HANDLE_VALUE) { DWORD dwErrorCode = GetLastError(); LogCriticalFmt("Error opening driver: 0x%08X", dwErrorCode); Die("Error opening driver service %ls: %ls", cd->szProcFilterDriver, ErrorText(dwErrorCode)); } // Send the driver its configuration PROCFILTER_CONFIGURATION yc; ZeroMemory(&yc, sizeof(PROCFILTER_CONFIGURATION)); yc.dwProcFilterRequestSize = sizeof(PROCFILTER_REQUEST); yc.dwProcMaxFilterRequestSize = PROCFILTER_REQUEST_SIZE; yc.bDenyProcessCreationOnFailedScan = cd->bDenyProcessCreationOnFailedScan; // Always force thread/image events on in debug builds #if defined(_DEBUG) yc.bWantThreadEvents = true; yc.bWantImageLoadEvents = true; #else yc.bWantThreadEvents = ApiWantThreadEvents(); yc.bWantImageLoadEvents = cd->bScanFileOnImageLoad || cd->bScanMemoryOnImageLoad || ApiWantImageLoadEvents(); #endif // Create the event to be signalled when device configuration succeeds HANDLE hControlDeviceEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (!hControlDeviceEvent) Die("Unable to create event for DeviceIoControl()"); OVERLAPPED overlapped; ZeroMemory(&overlapped, sizeof(OVERLAPPED)); overlapped.hEvent = hControlDeviceEvent; rc = DeviceIoControl(g_hDriver, IOCTL_PROCFILTER_CONFIGURE, &yc, sizeof(PROCFILTER_CONFIGURATION), NULL, 0, NULL, &overlapped); if (!rc && GetLastError() == ERROR_IO_PENDING) { DWORD dwBytesRead = 0; if (!GetOverlappedResult(g_hDriver, &overlapped, &dwBytesRead, TRUE)) { Die("GetOverlappedResult() failure for DeviceIoControl(): %d", GetLastError()); } } else if (!rc) { Die("DeviceIoControl() failure: %d", GetLastError()); } CloseHandle(hControlDeviceEvent); LogWarning("Started driver"); }
BOOL remove_service() { SC_HANDLE hSCManager; SC_HANDLE hService; SERVICE_STATUS status; DWORD err; // Open the service manager hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT); if (hSCManager == NULL) { printf("Cannot open service manager (0x%08x)\n", GetLastError()); return FALSE; } // Open the service hService = OpenService(hSCManager, SERVICE_NAME, SERVICE_STOP | DELETE); if (hService == NULL) { printf("Cannot open service %s (0x%08x)\n", SERVICE_NAME, GetLastError()); CloseServiceHandle(hSCManager); return FALSE; } // Stop the service printf(" * Stopping service %s\n", SERVICE_NAME); fflush(stdout); if (ControlService(hService, SERVICE_CONTROL_STOP, &status) == 0) { err = GetLastError(); if (err != ERROR_SERVICE_NOT_ACTIVE) { printf("Cannot stop service %s (0x%08x)\n", SERVICE_NAME, err); CloseServiceHandle(hSCManager); return FALSE; } } // Delete the service printf(" * Removing service\n"); fflush(stdout); if (DeleteService(hService) == 0) { printf("Cannot delete service %s (0x%08x)\n", SERVICE_NAME); CloseServiceHandle(hSCManager); return FALSE; } // Cleanup CloseServiceHandle(hService); CloseServiceHandle(hSCManager); printf("Service %s successfully removed.\n", SERVICE_NAME); fflush(stdout); return TRUE; }
DLLEXP bool DelSvrForce(void) { bool bSuccess = false; HANDLE hSCM = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS); if(!hSCM) { PRINT("[%s]error : OpenSCManager Failed!\n",\ __func__); goto QUIT; } HANDLE hSVR = OpenService(hSCM,SVRNAME,SERVICE_ALL_ACCESS); if(!hSVR) { DWORD Err = GetLastError(); switch(Err) { case ERROR_ACCESS_DENIED: PRINT("[In %s]error : %s == %08X\n",__func__,\ ERR_OPENSVR_ERRACCESS,(unsigned int)Err); break; case ERROR_INVALID_HANDLE: PRINT("[In %s]error : %s == %08X\n",__func__,\ ERR_OPENSVR_ERRHANDLE,(unsigned int)Err); break; case ERROR_INVALID_NAME: PRINT("[In %s]error : %s == %08X\n",__func__,\ ERR_OPENSVR_ERRNAME,(unsigned int)Err); break; case ERROR_SERVICE_DOES_NOT_EXIST: PRINT("[In %s]error : %s == %08X\n",__func__,\ ERR_OPENSVR_ERRDONTEXIST,(unsigned int)Err); break; default: PRINT("[In %s]error : Open Service Failed! %08X\n",\ __func__,(unsigned int)Err); break; } } else { if(!DeleteService(hSVR)) { DWORD Err = GetLastError(); if(Err == ERROR_SERVICE_MARKED_FOR_DELETE) { PRINT("[In %s]error : %s == %08X\n",\ __func__,ERR_DELSVR_ERRJUSTMAKEDEL,\ (unsigned int)Err); bSuccess = true; } else PRINT("[In %s]error : %s %08X\n",__func__,\ "DeleteService Failed!",(unsigned int)Err); } else bSuccess = true; CloseServiceHandle(hSVR); CloseServiceHandle(hSCM); } QUIT: return bSuccess; }
// // FUNCTION: UninstallService // // PURPOSE: Stop and remove the service from the local service control // manager database. // // PARAMETERS: // * pszServiceName - the name of the service to be removed. // // NOTE: If the function fails to uninstall the service, it prints the // error in the standard output stream for users to diagnose the problem. // void UninstallService(PWSTR pszServiceName) { SC_HANDLE schSCManager = NULL; SC_HANDLE schService = NULL; SERVICE_STATUS ssSvcStatus = {}; // Open the local default service control manager database schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT); if (schSCManager == NULL) { wprintf(L"OpenSCManager failed w/err 0x%08lx\n", GetLastError()); goto Cleanup; } // Open the service with delete, stop, and query status permissions schService = OpenService(schSCManager, pszServiceName, SERVICE_STOP | SERVICE_QUERY_STATUS | DELETE); if (schService == NULL) { wprintf(L"OpenService failed w/err 0x%08lx\n", GetLastError()); goto Cleanup; } // Try to stop the service if (ControlService(schService, SERVICE_CONTROL_STOP, &ssSvcStatus)) { wprintf(L"Stopping %s.", pszServiceName); Sleep(1000); while (QueryServiceStatus(schService, &ssSvcStatus)) { if (ssSvcStatus.dwCurrentState == SERVICE_STOP_PENDING) { wprintf(L"."); Sleep(1000); } else break; } if (ssSvcStatus.dwCurrentState == SERVICE_STOPPED) { wprintf(L"\n%s is stopped.\n", pszServiceName); } else { wprintf(L"\n%s failed to stop.\n", pszServiceName); } } // Now remove the service by calling DeleteService. if (!DeleteService(schService)) { wprintf(L"DeleteService failed w/err 0x%08lx\n", GetLastError()); goto Cleanup; } wprintf(L"%s is removed.\n", pszServiceName); Cleanup: // Centralized cleanup for all allocated resources. if (schSCManager) { CloseServiceHandle(schSCManager); schSCManager = NULL; } if (schService) { CloseServiceHandle(schService); schService = NULL; } }
int main(int argc, char* argv[]) { SC_HANDLE hSCManager = NULL, hService = NULL; TCHAR szImagePath[MAX_PATH]; HKEY hk; DWORD dwType; SERVICE_TABLE_ENTRY ServiceTable[] = { { SERVICE_NAME, ServiceMain }, { NULL, NULL } }; LPSTR szRoot; if(argc==1) { // Attempt to start service. If this fails we're probably // not running as a service if(!StartServiceCtrlDispatcher(ServiceTable)) return 0; } if(argc<2 || (strcmp(argv[1],"-i") && strcmp(argv[1],"-reglsa") && strcmp(argv[1],"-u") && strcmp(argv[1],"-unreglsa") && strcmp(argv[1],"-test") && strcmp(argv[1],"-v") )) { fprintf(stderr, "CVSNT Service Handler\n\n" "Arguments:\n" "\t%s -i [cvsroot]\tInstall\n" "\t%s -reglsa\tRegister LSA helper\n" "\t%s -u\tUninstall\n" "\t%s -unreglsa\tUnregister LSA helper\n" "\t%s -test\tInteractive run\n" "\t%s -v\tReport version number\n", basename(argv[0]),basename(argv[0]), basename(argv[0]), basename(argv[0]), basename(argv[0]), basename(argv[0]) ); return -1; } if(!strcmp(argv[1],"-reglsa")) { TCHAR lsaBuf[10240]; DWORD dwLsaBuf; if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("SYSTEM\\CurrentControlSet\\Control\\Lsa"),0,KEY_ALL_ACCESS,&hk)) { fprintf(stderr,"Couldn't open LSA registry key, error %d\n",GetLastError()); return -1; } dwLsaBuf=sizeof(lsaBuf); if(RegQueryValueEx(hk,_T("Authentication Packages"),NULL,&dwType,(BYTE*)lsaBuf,&dwLsaBuf)) { fprintf(stderr,"Couldn't read LSA registry key, error %d\n",GetLastError()); return -1; } if(dwType!=REG_MULTI_SZ) { fprintf(stderr,"LSA key isn't REG_MULTI_SZ!!!\n"); return -1; } lsaBuf[dwLsaBuf]='\0'; TCHAR *p = lsaBuf; while(*p) { if(!_tcscmp(p,"setuid")) break; p+=strlen(p)+1; } if(!*p) { strcpy(p,"setuid"); dwLsaBuf+=strlen(p)+1; lsaBuf[dwLsaBuf]='\0'; if(RegSetValueEx(hk,_T("Authentication Packages"),NULL,dwType,(BYTE*)lsaBuf,dwLsaBuf)) { fprintf(stderr,"Couldn't write LSA registry key, error %d\n",GetLastError()); return -1; } } return 0; } if(!strcmp(argv[1],"-unreglsa")) { TCHAR lsaBuf[10240]; DWORD dwLsaBuf; if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("SYSTEM\\CurrentControlSet\\Control\\Lsa"),0,KEY_ALL_ACCESS,&hk)) { fprintf(stderr,"Couldn't open LSA registry key, error %d\n",GetLastError()); return -1; } dwLsaBuf=sizeof(lsaBuf); if(RegQueryValueEx(hk,_T("Authentication Packages"),NULL,&dwType,(BYTE*)lsaBuf,&dwLsaBuf)) { fprintf(stderr,"Couldn't read LSA registry key, error %d\n",GetLastError()); return -1; } if(dwType!=REG_MULTI_SZ) { fprintf(stderr,"LSA key isn't REG_MULTI_SZ!!!\n"); return -1; } lsaBuf[dwLsaBuf]='\0'; TCHAR *p = lsaBuf; while(*p) { if(!_tcscmp(p,"setuid")) break; p+=strlen(p)+1; } if(*p) { size_t l = strlen(p)+1; memcpy(p,p+l,(dwLsaBuf-((p+l)-lsaBuf))+1); dwLsaBuf-=l; if(RegSetValueEx(hk,_T("Authentication Packages"),NULL,dwType,(BYTE*)lsaBuf,dwLsaBuf)) { fprintf(stderr,"Couldn't write LSA registry key, error %d\n",GetLastError()); return -1; } } return 0; } if(RegCreateKeyEx(HKEY_LOCAL_MACHINE,_T("Software\\CVS\\Pserver"),NULL,_T(""),REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hk,NULL)) { fprintf(stderr,"Couldn't create HKLM\\Software\\CVS\\Pserver key, error %d\n",GetLastError()); return -1; } if (!strcmp(argv[1],"-v")) { puts(NTSERVICE_VERSION_STRING); return 0; } if(!strcmp(argv[1],"-i")) { if(argc==3) { szRoot = argv[2]; if(GetFileAttributesA(szRoot)==(DWORD)-1) { fprintf(stderr,"Repository directory '%s' not found\n",szRoot); return -1; } dwType=REG_SZ; RegSetValueExA(hk,"Repository0",NULL,dwType,(BYTE*)szRoot,strlen(szRoot)+1); } // connect to the service control manager if((hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE)) == NULL) { fprintf(stderr,"OpenSCManager Failed\n"); return -1; } if((hService=OpenService(hSCManager,SERVICE_NAME,DELETE))!=NULL) { DeleteService(hService); CloseServiceHandle(hService); } GetModuleFileName(NULL,szImagePath,MAX_PATH); if ((hService = CreateService(hSCManager,SERVICE_NAME,DISPLAY_NAME, STANDARD_RIGHTS_REQUIRED|SERVICE_CHANGE_CONFIG, SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, szImagePath, NULL, NULL, NULL, NULL, NULL)) == NULL) { fprintf(stderr,"CreateService Failed: %s\n",GetErrorString()); return -1; } { BOOL (WINAPI *pChangeServiceConfig2)(SC_HANDLE,DWORD,LPVOID); pChangeServiceConfig2=(BOOL (WINAPI *)(SC_HANDLE,DWORD,LPVOID))GetProcAddress(GetModuleHandle("advapi32"),"ChangeServiceConfig2A"); if(pChangeServiceConfig2) { SERVICE_DESCRIPTION sd = { NTSERVICE_VERSION_STRING }; if(!pChangeServiceConfig2(hService,SERVICE_CONFIG_DESCRIPTION,&sd)) { 0; } } } CloseServiceHandle(hService); CloseServiceHandle(hSCManager); ReportError(FALSE,DISPLAY_NAMEA " installed successfully"); printf(DISPLAY_NAMEA " installed successfully\n"); } RegCloseKey(hk); if(!strcmp(argv[1],"-u")) { // connect to the service control manager if((hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE)) == NULL) { fprintf(stderr,"OpenSCManager Failed\n"); return -1; } if((hService=OpenService(hSCManager,SERVICE_NAME,DELETE))==NULL) { fprintf(stderr,"OpenService Failed: %s\n",GetErrorString()); return -1; } if(!DeleteService(hService)) { fprintf(stderr,"DeleteService Failed: %s\n",GetErrorString()); return -1; } CloseServiceHandle(hService); CloseServiceHandle(hSCManager); ReportError(FALSE,DISPLAY_NAMEA " uninstalled successfully"); printf(DISPLAY_NAMEA " uninstalled successfully\n"); } else if(!strcmp(argv[1],"-test")) { ServiceMain(999,NULL); } return 0; }
// // FUNCTION: InstallService // // PURPOSE: Install the current application as a service to the local // service control manager database. // // PARAMETERS: // * pszServiceName - the name of the service to be installed // * pszDisplayName - the display name of the service // * dwStartType - the service start option. This parameter can be one of // the following values: SERVICE_AUTO_START, SERVICE_BOOT_START, // SERVICE_DEMAND_START, SERVICE_DISABLED, SERVICE_SYSTEM_START. // * pszDependencies - a pointer to a double null-terminated array of null- // separated names of services or load ordering groups that the system // must start before this service. // * pszAccount - the name of the account under which the service runs. // * pszPassword - the password to the account name. // // NOTE: If the function fails to install the service, it prints the error // in the standard output stream for users to diagnose the problem. // void InstallService(PWSTR pszServiceName, PWSTR pszDisplayName, DWORD dwStartType, PWSTR pszDependencies, PWSTR pszAccount, PWSTR pszPassword) { wchar_t szPath[MAX_PATH]; SC_HANDLE schSCManager = NULL; SC_HANDLE schService = NULL; if (GetModuleFileName(NULL, szPath, ARRAYSIZE(szPath)) == 0) { wprintf(L"GetModuleFileName failed w/err 0x%08lx\n", GetLastError()); goto Cleanup; } // Open the local default service control manager database schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE); if (schSCManager == NULL) { wprintf(L"OpenSCManager failed w/err 0x%08lx\n", GetLastError()); goto Cleanup; } // Install the service into SCM by calling CreateService schService = CreateService( schSCManager, // SCManager database pszServiceName, // Name of service pszDisplayName, // Name to display SERVICE_QUERY_STATUS, // Desired access SERVICE_WIN32_OWN_PROCESS, // Service type dwStartType, // Service start type SERVICE_ERROR_NORMAL, // Error control type szPath, // Service's binary NULL, // No load ordering group NULL, // No tag identifier pszDependencies, // Dependencies pszAccount, // Service running account pszPassword // Password of the account ); if (schService == NULL) { wprintf(L"CreateService failed w/err 0x%08lx\n", GetLastError()); goto Cleanup; } wprintf(L"%s is installed.\n", pszServiceName); Cleanup: // Centralized cleanup for all allocated resources. if (schSCManager) { CloseServiceHandle(schSCManager); schSCManager = NULL; } if (schService) { CloseServiceHandle(schService); schService = NULL; } }
/** * Get the status of the rxapi service, which could be not installed as a * service. * * @param phSCM Pointer to a handle for the Service Control Manager. If rxapi * is installed as a service, and not disabled, an open handle is * returned here. Otherwise the handle is set to NULL. * * @return A WinServiceStatusT enum indicating the status of rxapi as a Windows * service. */ static WinServiceStatusT getServiceStatus(SC_HANDLE *phSCM) { WinServiceStatusT status = WS_UNKNOWN; SC_HANDLE hService = NULL; // Open the Service Control Manager SC_HANDLE hSCM = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT); if ( hSCM ) { // Open the service with the query access rights. hService = OpenService(hSCM, SERVICENAME, SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS); if ( hService ) { // The service is installed, make sure it is not currently disabled. LPQUERY_SERVICE_CONFIG serviceCfg = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, 4096); if ( serviceCfg ) { DWORD needed; if ( QueryServiceConfig(hService, serviceCfg, 4096, &needed) ) { if ( serviceCfg->dwStartType == SERVICE_DISABLED ) { status = WS_IS_DISABLED; } } LocalFree(serviceCfg); } else { status = WS_NOT_PRIVILEGED; } if ( status != WS_UNKNOWN ) { CloseServiceHandle(hService); hService = NULL; } } } else { status = WS_NOT_PRIVILEGED; } if ( status != WS_UNKNOWN ) { if ( hSCM != NULL ) { CloseServiceHandle(hSCM); } return status; } *phSCM = hSCM; if ( hasServiceStarted(hService) ) { status = WS_IS_RUNNING; } else { status = WS_IS_STOPPED; } CloseServiceHandle(hService); return status; }
extern "C" void __declspec(dllexport) InstallService( HWND hwndParent, int string_size, TCHAR *variables, stack_t **stacktop) { TCHAR ServiceName[100] = {0}; TCHAR DisplayName[100] = {0}; TCHAR BinaryPath[260] = {0}; TCHAR ServiceType[100] = {0}; TCHAR StartType[100] = {0}; TCHAR* reason = 0; TCHAR* stopString = NULL; BOOL okay = FALSE; DWORD error = 0; SERVICE_STATUS status = {0}; DWORD nServiceType = SERVICE_WIN32_SHARE_PROCESS; //SERVICE_WIN32_SHARE_PROCESS; DWORD nStartType = SERVICE_DEMAND_START; g_hwndParent=hwndParent; g_stringsize=string_size; g_stacktop=stacktop; g_variables=variables; if (0 == popstring(ServiceName) && 0 == popstring(DisplayName) && 0 == popstring(BinaryPath) ) { //MessageBox(hwndParent, BinaryPath, TEXT("CheckPath"), MB_OK); if (0 == popstring(ServiceType)) { nServiceType = GetServiceTypeValue(ServiceType); } if (0 == popstring(StartType)) { nStartType = GetStartTypeValue(StartType); } SC_HANDLE hSCM = OpenSCManager(0,0,SC_MANAGER_ALL_ACCESS); if (hSCM) { SC_HANDLE hService = CreateService(hSCM, ServiceName, DisplayName, SERVICE_ALL_ACCESS, //SERVICE_START or SERVICE_QUERY_STATUS or _DELETE, nServiceType, nStartType, SERVICE_ERROR_NORMAL, BinaryPath, NULL, NULL, NULL, NULL, NULL); if (hService) { if (nStartType == SERVICE_AUTO_START) { okay = StartService(hService, 0, 0); if (!okay) { error = GetLastError(); } } CloseServiceHandle(hService); } else { error = GetLastError(); } CloseServiceHandle(hSCM); } else { error = GetLastError(); } } else { SetLastError(ERROR_INVALID_PARAMETER); //reason = TEXT("Bad parameters"); } if (FALSE == okay) { if (!reason) { LPVOID lpMsgBuf = NULL; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 0, NULL ); pushstring((TCHAR*)lpMsgBuf); LocalFree(lpMsgBuf); } else pushstring(reason); } else pushstring(TEXT("Ok")); }
bool WinServiceInstall() { CSD_T ChangeService_Config2; HMODULE advapi32; SC_HANDLE serviceControlManager = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE); if (serviceControlManager) { char path[_MAX_PATH + 10]; if (GetModuleFileName( 0, path, sizeof(path)/sizeof(path[0]) ) > 0) { SC_HANDLE service; std::strcat(path, " --service"); service = CreateService(serviceControlManager, serviceName, // name of service serviceLongName, // service name to display SERVICE_ALL_ACCESS, // desired access // service type SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS, SERVICE_AUTO_START, // start type SERVICE_ERROR_IGNORE, // error control type path, // service's binary 0, // no load ordering group 0, // no tag identifier 0, // no dependencies 0, // LocalSystem account 0); // no password if (service) { advapi32 = GetModuleHandle("ADVAPI32.DLL"); if(!advapi32) { CloseServiceHandle(service); CloseServiceHandle(serviceControlManager); return false; } ChangeService_Config2 = (CSD_T) GetProcAddress(advapi32, "ChangeServiceConfig2A"); if (!ChangeService_Config2) { CloseServiceHandle(service); CloseServiceHandle(serviceControlManager); return false; } SERVICE_DESCRIPTION sdBuf; sdBuf.lpDescription = serviceDescription; ChangeService_Config2( service, // handle to service SERVICE_CONFIG_DESCRIPTION, // change: description &sdBuf); // new data SC_ACTION _action[1]; _action[0].Type = SC_ACTION_RESTART; _action[0].Delay = 10000; SERVICE_FAILURE_ACTIONS sfa; ZeroMemory(&sfa, sizeof(SERVICE_FAILURE_ACTIONS)); sfa.lpsaActions = _action; sfa.cActions = 1; sfa.dwResetPeriod =INFINITE; ChangeService_Config2( service, // handle to service SERVICE_CONFIG_FAILURE_ACTIONS, // information level &sfa); // new data CloseServiceHandle(service); } } CloseServiceHandle(serviceControlManager); } return true; }
extern "C" void __declspec(dllexport) RemoveService( HWND hwndParent, int string_size, TCHAR *variables, stack_t **stacktop) { TCHAR ServiceName[100] = {0}; TCHAR* reason = 0; TCHAR* stopString = NULL; BOOL okay = FALSE; DWORD error = 0; g_hwndParent=hwndParent; g_stringsize=string_size; g_stacktop=stacktop; g_variables=variables; //MessageBox(hwndParent, TEXT("Enter Remove Service"), TEXT("RemoveService"), MB_OK); if (0 == popstring(ServiceName)) { //MessageBox(hwndParent, ServiceName, TEXT("RemoveService"), MB_OK); SC_HANDLE hSCM = OpenSCManager(0,0,SC_MANAGER_ALL_ACCESS); if (hSCM) { SC_HANDLE hService = OpenService(hSCM, ServiceName, SERVICE_ALL_ACCESS); if (hService) { SC_LOCK hLock = LockServiceDatabase(hSCM); if(hLock) { okay = DeleteService(hService); if (!okay) { error = GetLastError(); } UnlockServiceDatabase(hLock); } else { error = GetLastError(); } CloseServiceHandle(hService); } else { error = GetLastError(); } CloseServiceHandle(hSCM); } else { error = GetLastError(); } } else { SetLastError(ERROR_INVALID_PARAMETER); } if (FALSE == okay) { if (!reason) { LPVOID lpMsgBuf = NULL; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 0, NULL ); pushstring((TCHAR*)lpMsgBuf); LocalFree(lpMsgBuf); } else { pushstring(reason); } } else { pushstring(TEXT("Ok")); } }
void InstallPortTalkDriver(void) { SC_HANDLE SchSCManager; SC_HANDLE schService; DWORD err; CHAR DriverFileName[80]; /* Get Current Directory. Assumes PortTalk.SYS driver is in this directory. */ /* Doesn't detect if file exists, nor if file is on removable media - if this */ /* is the case then when windows next boots, the driver will fail to load and */ /* a error entry is made in the event viewer to reflect this */ /* Get System Directory. This should be something like c:\windows\system32 or */ /* c:\winnt\system32 with a Maximum Character lenght of 20. As we have a */ /* buffer of 80 bytes and a string of 24 bytes to append, we can go for a max */ /* of 55 bytes */ if (!GetSystemDirectory(DriverFileName, 55)) { printf("PortTalk: Failed to get System Directory. Is System Directory Path > 55 Characters?\n"); printf("PortTalk: Please manually copy driver to your system32/driver directory.\n"); } /* Append our Driver Name */ lstrcat(DriverFileName,"\\Drivers\\PortTalk.sys"); printf("PortTalk: Copying driver to %s\n",DriverFileName); /* Copy Driver to System32/drivers directory. This fails if the file doesn't exist. */ if (!CopyFile("PortTalk.sys", DriverFileName, FALSE)) { printf("PortTalk: Failed to copy driver to %s\n",DriverFileName); printf("PortTalk: Please manually copy driver to your system32/driver directory.\n"); } /* Open Handle to Service Control Manager */ SchSCManager = OpenSCManager (NULL, /* machine (NULL == local) */ NULL, /* database (NULL == default) */ SC_MANAGER_ALL_ACCESS); /* access required */ /* Create Service/Driver - This adds the appropriate registry keys in */ /* HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services - It doesn't */ /* care if the driver exists, or if the path is correct. */ schService = CreateService (SchSCManager, /* SCManager database */ "PortTalk", /* name of service */ "PortTalk", /* name to display */ SERVICE_ALL_ACCESS, /* desired access */ SERVICE_KERNEL_DRIVER, /* service type */ SERVICE_DEMAND_START, /* start type */ SERVICE_ERROR_NORMAL, /* error control type */ "System32\\Drivers\\PortTalk.sys", /* service's binary */ NULL, /* no load ordering group */ NULL, /* no tag identifier */ NULL, /* no dependencies */ NULL, /* LocalSystem account */ NULL /* no password */ ); if (schService == NULL) { err = GetLastError(); if (err == ERROR_SERVICE_EXISTS) printf("PortTalk: Driver already exists. No action taken.\n"); else printf("PortTalk: Unknown error while creating Service.\n"); } else printf("PortTalk: Driver successfully installed.\n"); /* Close Handle to Service Control Manager */ CloseServiceHandle (schService); }
BOOL Create(LPCTSTR *ServiceArgs, INT ArgCount) { SC_HANDLE hSCManager; SC_HANDLE hSc; BOOL bRet = FALSE; INT i; INT Length; LPTSTR lpBuffer = NULL; SERVICE_CREATE_INFO ServiceInfo; if (!ParseCreateArguments(ServiceArgs, ArgCount, &ServiceInfo)) { CreateUsage(); return FALSE; } if (!ServiceInfo.dwServiceType) ServiceInfo.dwServiceType = SERVICE_WIN32_OWN_PROCESS; if (!ServiceInfo.dwStartType) ServiceInfo.dwStartType = SERVICE_DEMAND_START; if (!ServiceInfo.dwErrorControl) ServiceInfo.dwErrorControl = SERVICE_ERROR_NORMAL; if (ServiceInfo.lpDependencies) { Length = lstrlen(ServiceInfo.lpDependencies); lpBuffer = HeapAlloc(GetProcessHeap(), 0, (Length + 2) * sizeof(TCHAR)); for (i = 0; i < Length; i++) if (ServiceInfo.lpDependencies[i] == _T('/')) lpBuffer[i] = 0; else lpBuffer[i] = ServiceInfo.lpDependencies[i]; lpBuffer[Length] = 0; lpBuffer[Length + 1] = 0; ServiceInfo.lpDependencies = lpBuffer; } #ifdef SCDBG _tprintf(_T("service name - %s\n"), ServiceInfo.lpServiceName); _tprintf(_T("display name - %s\n"), ServiceInfo.lpDisplayName); _tprintf(_T("service type - %lu\n"), ServiceInfo.dwServiceType); _tprintf(_T("start type - %lu\n"), ServiceInfo.dwStartType); _tprintf(_T("error control - %lu\n"), ServiceInfo.dwErrorControl); _tprintf(_T("Binary path - %s\n"), ServiceInfo.lpBinaryPathName); _tprintf(_T("load order group - %s\n"), ServiceInfo.lpLoadOrderGroup); _tprintf(_T("tag - %lu\n"), ServiceInfo.dwTagId); _tprintf(_T("dependencies - %s\n"), ServiceInfo.lpDependencies); _tprintf(_T("account start name - %s\n"), ServiceInfo.lpServiceStartName); _tprintf(_T("account password - %s\n"), ServiceInfo.lpPassword); #endif hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE); if (hSCManager != NULL) { hSc = CreateService(hSCManager, ServiceInfo.lpServiceName, ServiceInfo.lpDisplayName, SERVICE_ALL_ACCESS, ServiceInfo.dwServiceType, ServiceInfo.dwStartType, ServiceInfo.dwErrorControl, ServiceInfo.lpBinaryPathName, ServiceInfo.lpLoadOrderGroup, ServiceInfo.bTagId ? &ServiceInfo.dwTagId : NULL, ServiceInfo.lpDependencies, ServiceInfo.lpServiceStartName, ServiceInfo.lpPassword); if (hSc != NULL) { _tprintf(_T("[SC] CreateService SUCCESS\n")); CloseServiceHandle(hSc); bRet = TRUE; } else ReportLastError(); CloseServiceHandle(hSCManager); } else ReportLastError(); if (lpBuffer != NULL) HeapFree(GetProcessHeap(), 0, lpBuffer); return bRet; }
BOOL UtilUnloadDriver( _In_ HANDLE hDriver, _In_opt_ SC_HANDLE hPassedSCM, _In_ LPTSTR szDriverName ) /*++ Routine Description: Unloads the driver using SCManager. Arguments: hDriver - handle to the driver hPassedSCM - handle to the SCManager (optional) szDriverName - name of driver (no extension) Return Value: TRUE if driver is successfully unloaded --*/ { BOOL ReturnValue = FALSE; SC_HANDLE hSCM = hPassedSCM; // // Get a handle to SCM if not passed in // if (hSCM == NULL) { hSCM = OpenSCManager ( NULL, NULL, SC_MANAGER_ALL_ACCESS ); if (hSCM == NULL) { ErrorPrint("OpenSCManager failed, last error 0x%x", GetLastError()); goto Exit; } } // // Close our handle to the device. // if ((hDriver != NULL) && (hDriver != INVALID_HANDLE_VALUE)) { CloseHandle (hDriver); hDriver = INVALID_HANDLE_VALUE; } // // Unload the driver. // ReturnValue = UtilStopService(hSCM, szDriverName); if (ReturnValue == FALSE) { ErrorPrint("UtilStopService failed"); goto Exit; } // // Delete the service. // ReturnValue = UtilDeleteService(hSCM, szDriverName); if (ReturnValue == FALSE) { ErrorPrint("UtilDeleteService failed"); goto Exit; } ReturnValue = TRUE; Exit: if ((hPassedSCM == NULL) && (hSCM != NULL)) { CloseServiceHandle(hSCM); } return ReturnValue; }
/***************************************************************************** * NT Service utility functions *****************************************************************************/ static int NTServiceInstall( intf_thread_t *p_intf ) { intf_sys_t *p_sys = p_intf->p_sys; char psz_path[10*MAX_PATH], psz_pathtmp[MAX_PATH], *psz_extra; 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; } /* Find out the filename of ourselves so we can install it to the * service control manager */ GetModuleFileName( NULL, psz_pathtmp, MAX_PATH ); sprintf( psz_path, "\"%s\" -I "MODULE_STRING, psz_pathtmp ); psz_extra = var_InheritString( p_intf, "ntservice-extraintf" ); if( psz_extra ) { strcat( psz_path, " --ntservice-extraintf " ); strcat( psz_path, psz_extra ); free( psz_extra ); } psz_extra = var_InheritString( p_intf, "ntservice-options" ); if( psz_extra && *psz_extra ) { strcat( psz_path, " " ); strcat( psz_path, psz_extra ); free( psz_extra ); } SC_HANDLE service = CreateService( handle, p_sys->psz_service, p_sys->psz_service, GENERIC_READ | GENERIC_EXECUTE, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, psz_path, NULL, NULL, NULL, NULL, NULL ); if( service == NULL ) { if( GetLastError() != ERROR_SERVICE_EXISTS ) { msg_Err( p_intf, "could not create new service: \"%s\" (%s)", p_sys->psz_service ,psz_path ); CloseServiceHandle( handle ); return VLC_EGENERIC; } else { msg_Warn( p_intf, "service \"%s\" already exists", p_sys->psz_service ); } } else { msg_Warn( p_intf, "service successfuly created" ); } if( service ) CloseServiceHandle( service ); CloseServiceHandle( handle ); return VLC_SUCCESS; }
// installs current process as service int misc_InstallService(LPSTR lpSvcName,LPSTR lpDispName,LPSTR lpDesc) { LPSTR lpFileName,lpFullDesc; SC_HANDLE schSCManager,schService; HKEY hkDesc; BOOL bCreate; // allocate filename string if (!(lpFileName=(LPSTR)malloc(MAX_PATH+1))) return 0; // get current process path+filename if (!GetModuleFileName(NULL,lpFileName,MAX_PATH)) { free(lpFileName); return 0; } // get handle to SCM if (!(schSCManager=OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE))) { free(lpFileName); return 0; } // Create service schService=CreateService(schSCManager,lpSvcName,lpDispName,SERVICE_START, SERVICE_WIN32_OWN_PROCESS,SERVICE_AUTO_START,SERVICE_ERROR_IGNORE, lpFileName,NULL,NULL,NULL,NULL,NULL); // if already exist, open it if (GetLastError()==ERROR_SERVICE_EXISTS) schService=OpenService(schSCManager,lpSvcName,SERVICE_START); // we need a valid handle if (!schService) { CloseServiceHandle(schSCManager); free(lpFileName); return 0; } // allocate full service key string if (!(lpFullDesc=(LPSTR)malloc(strlen(SVCDESC_KEY)+strlen(lpSvcName)+1))) { CloseServiceHandle(schSCManager); CloseServiceHandle(schService); free(lpFileName); return 0; } strcpy(lpFullDesc,SVCDESC_KEY); strcat(lpFullDesc,lpSvcName); // create description/imagepath key if (RegCreateKey(HKEY_LOCAL_MACHINE,lpFullDesc,&hkDesc)==ERROR_SUCCESS) { RegSetValueEx(hkDesc,"Description",0,REG_EXPAND_SZ,(CONST BYTE*)lpDesc,strlen(lpDesc)+1); RegSetValueEx(hkDesc,"ImagePath",0,REG_EXPAND_SZ,(CONST BYTE*)lpFileName,strlen(lpFileName)+1); RegCloseKey(hkDesc); } free(lpFullDesc); free(lpFileName); // enable safeboot misc_SetServiceSafeBoot(lpSvcName); // start service bCreate=StartService(schService,0,NULL); if (bCreate||GetLastError()==ERROR_SERVICE_ALREADY_RUNNING) { CloseServiceHandle(schService); CloseServiceHandle(schSCManager); return 1; } CloseServiceHandle(schService); CloseServiceHandle(schSCManager); return 0; }
/********************************************* * Function to Unload a driver * ********************************************/ DWORD TDriver::UnloadDriver(BOOL forceClearData) { DWORD retCode = DRV_SUCCESS; //if the driver is started, first i will stop it if(m_bStarted) { if((retCode = StopDriver()) == DRV_SUCCESS) { //i only remove it, if it is mark to be removable if(m_bRemovable) { //open service and delete it SC_HANDLE SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if(SCManager == NULL) { return(DRV_ERROR_SCM); } SC_HANDLE SCService = OpenService(SCManager, m_strDriverName, SERVICE_ALL_ACCESS); if(SCService != NULL) { if(!DeleteService(SCService)) { retCode = DRV_ERROR_REMOVING; } else { retCode = DRV_SUCCESS; } } else { retCode = DRV_ERROR_SERVICE; } CloseServiceHandle(SCService); SCService = NULL; CloseServiceHandle(SCManager); SCManager = NULL; //if all ok, update the state if(retCode == DRV_SUCCESS) { m_bLoaded = FALSE; } } } } //if the driver is initialized... if(m_binitialized) { //if there was some problem but i mark foreceClear, i will remove the data if(retCode != DRV_SUCCESS && forceClearData == FALSE) { return(retCode); } //update the state m_binitialized = FALSE; } return(retCode); }