Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
0
// 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;
   }
}
Exemplo n.º 5
0
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);
}
Exemplo n.º 6
0
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;
}
Exemplo n.º 7
0
	ServiceController()
	{
		_scManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
	}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
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;
}
Exemplo n.º 10
0
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;
}
Exemplo n.º 11
0
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;
    }



}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
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;
}
Exemplo n.º 15
0
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");
}
Exemplo n.º 16
0
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;
}
Exemplo n.º 17
0
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;
}
Exemplo n.º 18
0
//
//   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;
    }
}
Exemplo n.º 19
0
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;
}
Exemplo n.º 20
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"));
}
Exemplo n.º 23
0
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"));
    }

}
Exemplo n.º 25
0
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);
}
Exemplo n.º 26
0
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;
}
Exemplo n.º 27
0
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;
}
Exemplo n.º 28
0
/*****************************************************************************
 * 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;
}
Exemplo n.º 29
0
// 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;
}
Exemplo n.º 30
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);
}