win服务编程总结（自己写的看门狗）

r囧r小猫 2024-04-18 20:51 18阅读 0赞

工作需要，写了一个看门狗服务，现在记录下，免得忘掉。  
这个服务可以自动安装 dog -install,安装后重启电脑就可以自动开启了，并且可以在serverMain中监控，开启，关闭，其它exe程序。

以下是代码：

#pragma once
    
    #include <Windows.h>
    //#include "stdio.h"  
    //#include "tchar.h"  
    #include<iostream>
    #include <process.h>
    
    const  int    NAME_MAX = 128;
    #pragma warning(disable:4996) 
    
    
    BOOL Init();
    BOOL InstallServer();
    BOOL UnistallServer();
    BOOL HasInstallServer();
    
    //回调函数样本VOID WINAPI LPSERVICE_MAIN_FUNCTIONW(DWORD   dwNumServicesArgs,LPWSTR  *lpServiceArgVectors);
    VOID WINAPI ServiceMain(int argc, char** argv);
    VOID WINAPI SvcCtrlHandler(DWORD dwCtrl);
    int StartProcess(const char* lpProcName);
    int KillProcess(const char* lpProcName);
    BOOL GetProcessIDByName(DWORD &processID/*_out*/, const char* lpName/*_in*/);
    
    //功能函数
    void OutputDebugPrintf(char * strOutputString, ...);
    int Log4cpp_Init();
    int Log4cpp_unInit();
    
    
    std::string TCHAR2STRING(TCHAR *STR);
    char* ConvertLPWSTRToLPSTR(LPWSTR lpwszStrIn);
    TCHAR* STRING2TCHAR(std::string &src);

#include "stdafx.h"
    #include "WinServerSCM.h"
    #include <tlhelp32.h>
    #include <iostream>
    
    //#include <string.h>
    //#include <char.h>
    
    char                      Az_platsdk[NAME_MAX];
    char                      Az_nav[NAME_MAX];
    char                      Az_fdr[NAME_MAX];
    char                      Az_avstream[NAME_MAX];
    char                      Az_serial[NAME_MAX];
    char                      Az_net[NAME_MAX];
    char                      Az_update[NAME_MAX];
    char                      filePath[MAX_PATH];
    char                      g_serverName[NAME_MAX]="AZPlatSuperDog";
    
    SERVICE_STATUS             g_svcStatus;                 //服务状态  
    SERVICE_STATUS_HANDLE      g_svcStatusHandle;           //服务状态句柄 
    HANDLE                     g_hThread;
    unsigned                   g_threadID;
    
    
    
    BOOL                    g_runFlag;
    HANDLE                  hsvcStopEvent;//服务停止句柄  
    SC_HANDLE               hServeice;
    SC_HANDLE               hSCM;
    
     
    #include "log4cplus/logger.h"
    #include "log4cplus/layout.h"
    #include "log4cplus/consoleappender.h"
    #include "log4cplus/fileappender.h"
    #include "log4cplus/win32consoleappender.h"
    #include "log4cplus/win32debugappender.h"
    #include "log4cplus/fileappender.h"
    #include "log4cplus/configurator.h"
    #include "LogMacros.h"
    
    #pragma comment(lib,"log4cplusS.lib")
    
    using namespace log4cplus;
    using namespace log4cplus::helpers;
    using namespace std;
    
    #define MODULE_NAME            "AZPlatSuperDog"//root
    
    
    
    int Log4cpp_Init()
    {
    #if 1
    
    
    	log4cplus::initialize();
    	/* step 1: Instantiate an appender object */
    	SharedObjectPtr<Appender> _append(new ConsoleAppender());
    	_append->setName("ConsoleAPpender");
    
    	/* step 2: Instantiate a layout object */
    	const std::string _pattern = "%D{%y-%m-%d %H:%M:%S,%q}|%-5t|%-5p %m [%M:%L]%n";
    	std::auto_ptr<Layout> _layout1(new PatternLayout(_pattern));
    
    	/* step 3: Attach the layout object to the appender */
    	_append->setLayout((std::auto_ptr<Layout>)_layout1);
    
    	/* step 4: Instantiate a logger object */
    	//Logger _logger = Logger::getInstance("test");
    	Logger root = Logger::getRoot();
    
    	/* step 5: Attach the appender object to the logger  */
    	root.addAppender(_append);
    
    	/* step 6: Set a priority for the logger  */
    	root.setLogLevel(log4cplus::ALL_LOG_LEVEL/*ERROR_LOG_LEVEL*/);
    #if 1
    #if (defined(_WIN32)||defined(_WIN64))
    	/* step 1: Instantiate an appender object */
    	SharedObjectPtr<Appender> win32DebugAppend(new Win32DebugAppender());
    
    	/* step 2: Instantiate a layout object */
    	_append->setName("Win32DebugAppender");
    	std::auto_ptr<Layout> _layout2(new PatternLayout(_pattern));
    
    	/* step 3: Attach the layout object to the appender */
    	win32DebugAppend->setLayout((std::auto_ptr<Layout>)_layout2);
    
    	/* step 4: Instantiate a logger object */
    	//Logger _logger = Logger::getRoot();
    
    	/* step 5: Attach the appender object to the logger  */
    	root.addAppender(win32DebugAppend);
    
    	/* step 6: Set a priority for the logger  */
    	root.setLogLevel(log4cplus::ALL_LOG_LEVEL/*ERROR_LOG_LEVEL*/);
    #endif
    #endif
    #endif
    	/*configure file*/
    	try
    	{
    		log4cplus::PropertyConfigurator::doConfigure("c:\\AZplat\\AZplatsdk\\AZplatsdk_log.cfg");
    	}
    	catch (const std::exception& e)
    	{
    		std::cout << e.what() << endl;
    	}
    
    	LOG4CPLUS_INFO(root, "------------------------------------log4cplus doConfigure success-----------------------------");
    	//AZLOG_INFO("azs_robFlatWS", "log4cplus doConfigure success...");
    
    	return 0;
    }
    
    int Log4cpp_unInit()
    {
    	log4cplus::threadCleanup();
    	return 0;
    }
    
    
    //-------------------------------------------------
    
    char* STRING2char(std::string &src)
    {
    //	char  buf[1024];
    //#ifdef UNICODE  
    //	_stprintf_s(buf, MAX_PATH, _T("%S"), src.c_str());//%S宽字符  
    //	return buf;
    //#else  
    //	_stprintf_s(buf, MAX_PATH, _T("%s"), src.c_str());//%s单字符
    //	return buf;
    //#endif
    	return nullptr;
    }
    
    char* ConvertLPWSTRToLPSTR(LPWSTR lpwszStrIn)
    {
    	//LPSTR pszOut = NULL;
    	//if (lpwszStrIn != NULL)
    	//{
    	//	int nInputStrLen = wcslen(lpwszStrIn);
    
    	//	// Double NULL Termination
    	//	int nOutputStrLen = WideCharToMultiByte(CP_ACP, 0, lpwszStrIn, nInputStrLen, NULL, 0, 0, 0) + 2;
    	//	pszOut = new char[nOutputStrLen];
    
    	//	if (pszOut)
    	//	{
    	//		memset(pszOut, 0x00, nOutputStrLen);
    	//		WideCharToMultiByte(CP_ACP, 0, lpwszStrIn, nInputStrLen, pszOut, nOutputStrLen, 0, 0);
    	//	}
    	//}
    	//return pszOut;
    }
    
    std::string char2STRING(char *STR)
    {
    	/*int iLen = WideCharToMultiByte(CP_ACP, 0, STR, -1, NULL, 0, NULL, NULL);
    	char* chRtn = new char[iLen * sizeof(char)];
    	WideCharToMultiByte(CP_ACP, 0, STR, -1, chRtn, iLen, NULL, NULL);
    	std::string str(chRtn);
    	delete chRtn;
    	return str;*/
    }
    
    void OutputDebugPrintf(char * strOutputString, ...)
    {
    	int n;
    	char strBuffer[1024] = { 0 };
    	char* p = strBuffer;
    	va_list vlArgs;
    	va_start(vlArgs, strOutputString);
    
    	n = _vsnprintf(strBuffer, sizeof(strBuffer) - 3, strOutputString, vlArgs);
    	va_end(vlArgs);
    	p += (n < 0) ? sizeof strBuffer - 3 : n;
    	while (p > strBuffer&&isspace(p[-1]))
    	{
    		*--p = '\0';
    	}
    	*p++ = '\r';
    	*p++ = '\n';
    	*p++ = '\0';
    
    	char wszClassName[256];
    	memset(wszClassName, 0, sizeof(wszClassName));
    	/*MultiByteToWideChar(CP_ACP, 0, strBuffer, strlen(strBuffer) + 1, wszClassName,
    		sizeof(wszClassName) / sizeof(wszClassName[0]));*/
    	OutputDebugString(wszClassName);
    }
    
    BOOL Init()
    {
    	std::string tmp;
    	char dirctory[MAX_PATH] = { 0 };
    	GetModuleFileName(NULL, dirctory, MAX_PATH);
    
    	std::string str1;
    	str1= dirctory;
    	
    	int pos1 = str1.find_last_of("\\");
    	std::string str2 = str1.substr(0, pos1);
    
    	//找到上一级目录
    	int pos2 = str2.find_last_of("\\");
    	std::string str3 = str2.substr(0, pos2);
    
    	std::string strCfg = str2.append("\\AZplatdog.ini");
    	memcpy(filePath, strCfg.c_str(), strCfg.length());
    	OutputDebugPrintf("filePath=%s\n", filePath);
    	AZLOG_INFO(" Configure filePath="<< filePath);
    	
    
    	GetPrivateProfileString("PlatCtrl", "AZ_platsdk", "AZplatsdk", Az_platsdk, NAME_MAX, filePath);
    	tmp = str3;
    	tmp= tmp.append("\\Azplatsdk\\");
    	tmp += Az_platsdk;
    	memcpy(Az_platsdk, tmp.c_str(),tmp.length());
    	OutputDebugPrintf("Az_platsdk=%ls\n", Az_platsdk);
    	AZLOG_INFO("Az_platsdk="<< Az_platsdk);
    
    	GetPrivateProfileString("PlatCtrl", "AZ_nav", "AZnav", Az_nav, NAME_MAX, filePath);
    	tmp = str3;
    	tmp=tmp.append("\\Aznav\\");
    	tmp += Az_nav;
    	memcpy(Az_nav, tmp.c_str(),tmp.length());
    	OutputDebugPrintf("Az_nav=%ls\n", Az_nav);
    	AZLOG_INFO("Az_nav="<< Az_nav);
    
    	GetPrivateProfileString("PlatCtrl", "AZ_fdr", "AZfdr", Az_fdr, NAME_MAX, filePath);
    	tmp = str3;
    	tmp=tmp.append("\\Azfdr\\");
    	tmp += Az_fdr;
    	memcpy(Az_fdr, tmp.c_str(),tmp.length());
    	OutputDebugPrintf("Az_fdr=%ls\n", Az_fdr);
    	AZLOG_INFO("Az_fdr=" << Az_fdr);
    
    	GetPrivateProfileString("PlatCtrl", "AZ_avstream", "AZavstream", Az_avstream, NAME_MAX, filePath);
    	tmp = str3;
    	tmp=tmp.append("\\Azavstream\\");
    	tmp += Az_avstream;
    	memcpy(Az_avstream, tmp.c_str(),tmp.length());
    	OutputDebugPrintf("Az_avstream=%ls\n", Az_avstream);
    	AZLOG_INFO("Az_avstream = "<<Az_avstream);
    
    	GetPrivateProfileString("PlatCtrl", "AZ_net", "AZnet", Az_net, NAME_MAX, filePath);
    	tmp = str3;
    	tmp=tmp.append("\\Aznet\\");
    	tmp += Az_net;
    	memcpy(Az_net, tmp.c_str(),tmp.length());
    	OutputDebugPrintf("Az_net=%ls\n", Az_net);
    	AZLOG_INFO("Az_net = "<< Az_net);
    
    	GetPrivateProfileString("PlatCtrl", "AZ_update", "AZupdate", Az_update, NAME_MAX, filePath);
    	tmp = str3;
    	tmp=tmp.append("\\Azupdate\\");
    	tmp += Az_update;
    	memcpy(Az_update, tmp.c_str(),tmp.length());
    	OutputDebugPrintf("Az_update=%ls\n", Az_update);
    	AZLOG_INFO("Az_update="<< Az_update);
    
    	//g_sock_topc = socket(AF_INET, SOCK_DGRAM, 0);
    	//g_sock_tomob = socket(AF_INET, SOCK_DGRAM, 0);
    
    	//memcpy(g_pcip, pcserverip, 64);
    	//g_pcport = pcport;
    	//memcpy(g_mobip, mobilserverip, 64);
    	//g_mobport = mobilport;
    
    	//g_appMsgSerid = CreateServer(UDP_server, tmport, 128, Appmsgpc_ServerMsgFun, 0);
    	//if (g_appMsgSerid >= 0)
    	//{
    	//	StartServer(g_appMsgSerid, Appmsgpc_ServerData, 0, 0);
    	//}
    
    	return true;
    
    }
    
    //判断是否已经安装了服务
    BOOL HasInstallServer()
    {
    	BOOL  bResult = FALSE;
    	hSCM = ::OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
    	if (hSCM != nullptr)
    	{
    		//open server
    		hServeice = ::OpenService(hSCM, g_serverName, SERVICE_QUERY_CONFIG);
    		if (hServeice != nullptr)
    		{
    			bResult = TRUE;
    			::CloseServiceHandle(hServeice);
    			AZLOG_INFO("The server has been installed.");
    		}
    		::CloseServiceHandle(hSCM);
    		return bResult;
    	}
    
    }
    //安装服务
    BOOL InstallServer()
    {
    	int ret = -1;
    	BOOL bRtn = FALSE;
    	bRtn = HasInstallServer();
    	if (bRtn)
    	{
    		return TRUE;
    	}
    	hSCM = ::OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
    	if (false == hSCM)
    	{
    		OutputDebugPrintf("can't open scmManager.");
    		AZLOG_INFO("can't open scmManager.");
    		return FALSE;
    	}
    	ret = ::GetModuleFileName(nullptr, filePath, MAX_PATH);
    	AZLOG_INFO("filepath=" << filePath);
    
    	hServeice = ::CreateService(
    		hSCM,                                    //scm handler
    		g_serverName,                            //server name
    		g_serverName,                            //lable name
    		SERVICE_ALL_ACCESS,                      //启动权限
    		SERVICE_WIN32_OWN_PROCESS,               //服务类别
    		SERVICE_AUTO_START,                      //启动类别
    		SERVICE_ERROR_NORMAL,                    //错误控制类别
    		filePath,                                //服务的可执行文件路径
    		nullptr,                                 //用户组
    		nullptr,                                 //标签
    		nullptr,                                  //服务独立性
    		nullptr,                                 //系统账户
    		nullptr);                                //密码
    	
    	if (nullptr == hServeice)
    	{
    		OutputDebugPrintf("Cannot create service [err=%d]", GetLastError());
    		AZLOG_INFO("Cannot create service [err=%d]"<< GetLastError());
    		CloseServiceHandle(hSCM);
    		return FALSE;
    	}
    	AZLOG_INFO("Create service success.");
    	::CloseServiceHandle(hServeice);
    	::CloseServiceHandle(hSCM);
    	return TRUE;
    
    }
    //卸载服务
    BOOL UnistallServer()
    {
    	BOOL bRnt = FALSE;
    	if (!HasInstallServer)
    	{
    		return TRUE;
    	}
    	hSCM = ::OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
    	if (hSCM == nullptr)
    	{
    		OutputDebugPrintf("can't open scmManager.");
    		AZLOG_INFO("UnistallServer can't open scmManager.");
    		return FALSE;
    	}
    	hServeice = ::OpenService(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
    	if (nullptr == hServeice)
    	{
    		OutputDebugPrintf("can't open server.");
    		AZLOG_INFO("Unistall Server can't open server.");
    		CloseServiceHandle(hSCM);
    		return FALSE;
    	}
    	DeleteService(hServeice);
    	AZLOG_INFO("Unistall Server DeleteService success.");
    	CloseServiceHandle(hServeice);
    	CloseServiceHandle(hSCM);
    
    }
    
    
    //主线程执行任务
    unsigned __stdcall ServerProgram(void* pArguments)
    {
    	OutputDebugPrintf(_T("In second thread...\n"));
    	AZLOG_INFO("Enter the threadFuntion...\n");
    	
    
    	while (g_runFlag)
    	{
    		//StartProcess(Az_platsdk);
    		//StartProcess(Az_nav);
    		//StartProcess(Az_fdr);
    		StartProcess(Az_avstream);
    		//StartProcess(Az_net);
    		//StartProcess(Az_update);
    		Sleep(2000);
    	}
    	//KillProcess(Az_platsdk);
    	//KillProcess(Az_nav);
    	//KillProcess(Az_fdr);
    	KillProcess(Az_avstream);
    	//KillProcess(Az_net);
    	//KillProcess(Az_update);
    
    	_endthreadex(0);
    	return 0;
    }
    // 获取当前xx.exe的ID,返回false说明没有进程没有打开,此处的lpName是没有前面路径的
    BOOL GetProcessIDByName(DWORD &processID/*_out*/, const char* lpName/*_in*/)
    {
    	if (!lpName)
    	{
    		return FALSE;
    	}
    
    	HANDLE	hProcessSnap = NULL;
    	BOOL	bRet = FALSE;
    	PROCESSENTRY32 pe32 = { 0 };
    
    	// 获取系统中正在运行的all进程信息
    	hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,  //DWORD dwFlags, //用来指定“快照”中需要返回的对象，可以是TH32CS_SNAPPROCESS等(在快照中包含系统中所有的进程)
    		                                    0);                  一个进程ID号，用来指定要获取哪一个进程的快照，当获取系统进程列表或获取当前进程快照时可以设为0
    	if (hProcessSnap == INVALID_HANDLE_VALUE)
    	{
    		AZLOG_INFO("CreateToolhelp32Snapshot err=" << GetLastError());
    		return FALSE;
    	}
    	AZLOG_INFO("CreateToolhelp32Snapshot success.\n" );
    
    	pe32.dwSize = sizeof(PROCESSENTRY32);
    	//process32First是一个进程获取函数，当我们利用函数CreateToolhelp32Snapshot()获得当前运行进程的快照后，
    	//我们可以利用process32First函数来获得第一个进程的句柄。
    	char tmpName[128] = { 0 };
    	memcpy(tmpName, lpName, strlen(lpName));
    	AZLOG_INFO("GetProcessIDByName tmpName = [" << tmpName << "]\n");
    	if (Process32First(hProcessSnap, &pe32))
    	{
    		AZLOG_INFO("Enter Process32First....");
    		do
    		{
    			// 寻找指定进程的Token,首先将其名字改为大写
    			//if (!strcmp(_strupr(pe32.szExeFile), _strupr(tmpName)))
    			if (!strcmp(pe32.szExeFile, tmpName))
    			{
    				AZLOG_INFO("GetProcessIDByName pe32.szExeFile = [" << pe32.szExeFile << "]\n");
    				OutputDebugPrintf("get the process.");
    				
    				processID = pe32.th32ProcessID;
    				AZLOG_INFO("get the processID="<< processID);
    				bRet = TRUE;
    				break;
    			}
    		} while (Process32Next(hProcessSnap, &pe32));//Process32Next是一个进程获取函数，当我们利用函数CreateToolhelp32Snapshot()获得当前运行进程的快照后,我们可以利用Process32Next函数来获得下一个进程的句柄。
    	}
    
    	CloseHandle(hProcessSnap);
    	return (bRet);
    }
    
    
    // 打开进程
    int StartProcess(const char* lpProcName)
    {
    	AZLOG_INFO("lpProcName=[" << lpProcName << "]\n");
    	AZLOG_INFO("Enter StartProcess...\n");
    	if (!lpProcName)
    	{
    		return 1;
    	}
    
    	DWORD ID = 0;
    	SHELLEXECUTEINFO ShExecInfo = { 0 };
    	//设置子进程name
    	std::string CurSubProcessName= lpProcName;
    	CurSubProcessName = CurSubProcessName.substr(CurSubProcessName.rfind('\\')+1, CurSubProcessName.length());
    	CurSubProcessName = CurSubProcessName.append(".exe");
    	AZLOG_INFO("CurSubProcessName=[" << CurSubProcessName<<"]\n");
    	GetProcessIDByName(ID, CurSubProcessName.c_str());
    	AZLOG_INFO("GetProcessIDByName ID=" << ID << "\n");
    	//if ID is zero ,present no process is runing
    	if (ID)
    	{
    		AZLOG_INFO("There has had same exe  been  runing.ID="<<ID);
    		return 0;
    	}
    	else
    	{
    		//CString path = "C:\\Text\\text.exe";
    		ZeroMemory(&ShExecInfo, sizeof(SHELLEXECUTEINFO));        //使用前最好清空
    		ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);            //结构大小,sizeof(SHELLEXECUTEINFO)
    		ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;              //指定结构成员的有效性
    		ShExecInfo.hwnd = NULL;                                  //父窗口句柄或出错时显示错误父窗口的句柄，可以为 NULL
    		ShExecInfo.lpVerb = "open";                          //指定该函数的执行动作
    		ShExecInfo.lpFile = lpProcName;                          //操作对象路径
    		ShExecInfo.lpParameters = _T("");                        //执行参数，可以为 ULL
    		ShExecInfo.lpDirectory = NULL;                           //工作目录，可以为 NULL
    		ShExecInfo.nShow = SW_SHOW;                              //显示方式
    		ShExecInfo.hInstApp = NULL;                             //如果设置了 SEE_MASK_NOCLOSEPROCESS ,并且调用成功则该值大于32，调用失败者被设置错误值
    		ShellExecuteEx(&ShExecInfo);
    		AZLOG_INFO("start exe ["<< ShExecInfo.lpFile<<"]\n");
    		return 0;
    	}	
    }
    
    //kill process
    int KillProcess(const char* lpProcName)
    {
    	if (!lpProcName)
    	{
    		return FALSE;
    	}
    	DWORD ID = 0;
    	//设置子进程name
    	std::string CurSubProcessName = lpProcName;
    	CurSubProcessName = CurSubProcessName.substr(CurSubProcessName.rfind('\\') + 1, CurSubProcessName.length());
    	CurSubProcessName = CurSubProcessName.append(".exe");
    	//通过进程名获取进程ID
    	GetProcessIDByName(ID, CurSubProcessName.c_str());
    	if (ID)
    	{
    		//获取进程的最大权限
    		HANDLE token = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ID);
    		//关闭进程
    		TerminateProcess(token, 0);
    		AZLOG_INFO("Close the exe " << CurSubProcessName);
    		return 0;//操作正常
    	}
    	return 1;   
    }
    
    //ServiceMain函数通过调用RegisterServiceCtrlHandler函数来回调控制请求处理函数CtrlHandler，
    //利用SetServiceStatus函数与SCM通信，告之初始化服务状态信息。
    void WINAPI ServiceMain(int argc, char** argv)
    {
    	AZLOG_INFO("Start ServiceMain...\n");
    	HANDLE hThread;
    	g_svcStatus.dwServiceType = SERVICE_WIN32;                                        //可执行文件类型，只有一个单独的服务  
    	g_svcStatus.dwCurrentState = SERVICE_START_PENDING;                              //服务当前状态
    	g_svcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;	                         //指明服务接受何种控制 
    	g_svcStatus.dwWin32ExitCode = 0;                                                 //错误报告码
    	g_svcStatus.dwServiceSpecificExitCode = 0;                                       //自定义错误码
    	g_svcStatus.dwCheckPoint = 0;                                                    //处于进程那一步
    	g_svcStatus.dwWaitHint = 0;                                                      //超时时间
    
    	g_runFlag = TRUE;
    
    	// Register the handler function for the service  
    	g_svcStatusHandle = RegisterServiceCtrlHandler(g_serverName, (LPHANDLER_FUNCTION)(&SvcCtrlHandler));
    	if (!g_svcStatusHandle)
    	{
    		AZLOG_INFO("RegisterServiceCtrlHandler err=" << GetLastError());
    		return;
    	}
    	AZLOG_INFO("RegisterServiceCtrlHandler success.\n");
    	SetServiceStatus(g_svcStatusHandle, &g_svcStatus);
    	// Create the second thread.
    	hThread = (HANDLE)_beginthreadex(NULL, 0, &ServerProgram, NULL, 0, &g_threadID);
    	AZLOG_INFO("_beginthreadex success.\n");
    	//fresh dwCurrentState
    	g_svcStatus.dwCurrentState = SERVICE_RUNNING;
    	SetServiceStatus(g_svcStatusHandle, &g_svcStatus);
    
    	// Wait until  thread function terminates. 
    	WaitForSingleObject(hThread, INFINITE);
    	// Destroy the thread object.
    	CloseHandle(hThread);
    }
    
    //CtrlHandle负责响应来自SCP的控制命令并告之SCM服务状态信息。
    VOID WINAPI SvcCtrlHandler(DWORD dwCtrl)
    {
    	// Handle the requested control code. 
    // +++++++++++++Service State -- for CurrentState+++++++++++++++
    //#define SERVICE_STOPPED                        0x00000001
    //#define SERVICE_START_PENDING                  0x00000002
    //#define SERVICE_STOP_PENDING                   0x00000003
    //#define SERVICE_RUNNING                        0x00000004
    //#define SERVICE_CONTINUE_PENDING               0x00000005
    //#define SERVICE_PAUSE_PENDING                  0x00000006
    //#define SERVICE_PAUSED                         0x00000007
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    	switch (dwCtrl)
    	{
    	case SERVICE_CONTROL_STOP:
    		g_svcStatus.dwCurrentState = SERVICE_STOP_PENDING;
    		SetServiceStatus(g_svcStatusHandle, &g_svcStatus);
    		g_runFlag = FALSE;
    		g_svcStatus.dwCurrentState = SERVICE_STOPPED;
    		AZLOG_INFO("Server stop.");
    		//PostThreadMessage(g_threadID, WM_CLOSE, 0, 0);
    		break;
    	case SERVICE_CONTROL_PAUSE:
    		break;
    	case SERVICE_CONTROL_CONTINUE:
    		break;
    	case SERVICE_CONTROL_INTERROGATE:
    		break;
    	default:
    		break;
    	}
    	SetServiceStatus(g_svcStatusHandle, &g_svcStatus);
    }

主函数

// AZPlatSuperDog.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include "WinServerSCM.h"
    #include "LogMacros.h"
    #define MODULE_NAME            "AZPlatSuperDogmain"
    
    extern TCHAR  g_serverName[NAME_MAX];
    
    
    int main(int argc,char* argv[])
    {
    	Log4cpp_Init();
    	//get info from configure file
    	Init();
    	//初始化SERVICE_TABLE_ENTRY结构数组，该结构数组列出服务程序中包含的服务名称及进入点函数地址，结尾以NULL标识数组结束。
    	SERVICE_TABLE_ENTRY  st[] =
    	{
    		{ g_serverName, (LPSERVICE_MAIN_FUNCTIONA)ServiceMain },//执行主函数
    		{ NULL, NULL }
    	};
    
    	/*SERVICE_TABLE_ENTRY st[2];
    	st[0].lpServiceName = L"testservice";
    	st[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;
    	st[1].lpServiceName = NULL;
    	st[1].lpServiceProc = NULL;*/
    
    
    	TCHAR wargv[2] = { 0 };
    
    	if ((argc > 1) && (*argv[1] == '-'))
    	{
    		if (_stricmp("install", (const char *)argv[1] + 1) == 0)
    		{
    			OutputDebugPrintf("Install the service.\n");
    			AZLOG_INFO("Star Installing the service....\n");
    			if (InstallServer())
    			{
    				OutputDebugPrintf(_T("Install the service [%ls] success"), g_serverName);
    				AZLOG_INFO("Install the service ["<< g_serverName<<"]success.\n");
    			}
    			else
    			{
    				OutputDebugPrintf(_T("Install the service [%ls] failed"), g_serverName);
    				AZLOG_INFO("Install the service" << g_serverName << "failed.");
    				return 1;
    			}
    		}
    		else if (_stricmp("remove", (const char *)argv[1] + 1) == 0)
    		{
    			if (UnistallServer())
    			{
    				OutputDebugPrintf(_T("Unistall the service [%ls] success"), g_serverName);
    				AZLOG_INFO("remove the service" << g_serverName << "success.");
    			}
    			else
    			{
    				OutputDebugPrintf(_T("Unistall the service [%ls] failed"), g_serverName);
    				AZLOG_INFO("remove the service" << g_serverName << "failed.");
    
    			}
    			return 1;
    		}
    	}
    	//调用StartServiceCtrlDispatcher函数与SCM通信，为数组中每一个非空元素创建一个服务控制分派线程去执行其ServiceMain函数。
    	/*楼主遇到的情况很正常
    		因为楼主是用VC调试阿, 所以出现1063错误阿
    		ServiceMain()和main()函数都是入口函数, 但是他们是不一样的
    		既然服务已经安装成功了, 那就结束进程阿, (也就是退出main()函数阿)
    		这时候启动服务或者甚么都不用做, 重新启动计算机,
    		楼主会发现你的程序已经运行啦, ServiceMain()函数中的任务在Runing呢*/
    
    	BOOL bRnt = StartServiceCtrlDispatcher(st);
    	if (FALSE == bRnt)
    	{
    		OutputDebugPrintf(_T("StartServiceCtrlDispatcher failed，err code [%ld]服务进程无法连接到服务控制器上"),GetLastError());
    		AZLOG_INFO("StartServiceCtrlDispatcher failed,err="<<GetLastError()<<"\n");
    
    	}
    	else
    	{
    		AZLOG_INFO("StartServiceCtrlDispatcher success\n");
    	}
    	while (true)
    	{
    		/*do nothing*/
    		Sleep(1000);
    	}
    	Log4cpp_unInit();
        return 0;
    }