设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › Windows服务操作
返回列表 发新帖
查看: 2407|回复: 2

[技术交流] Windows服务操作

[复制链接]
鱼C丶彪哥
发表于 2018-3-14 16:31:57 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
学的第一门编程语言是易语言，可能大部分人没有听说过，国内的中文编程，我非常喜欢，但是遇到比较棘手（或者说深入or冷门）的问题时，去网上搜索一些资料吧，发现几乎都是C/C++的源代码，根本看不懂，所以又去学习C/C++，至今有将近两年了，在学校快要毕业了，却一天天的闲的发慌，就找个事做做，仿造开源的精易模块和MSDN的资料参考写了一套服务操作类，现在分享出来，与君共勉。

接下来准备学习一下Python了，不想再继续深入C/C++了，感觉在没毕业前，多学几门语言，会点基础，就业了在考虑深入哪一门吧，准备在接下来的时间在鱼C学习Python了。

下面贴代码

ServiceClass.h

  1. //ServiceClass.h

  3. #ifndef SERVICE_H_
  4. #define SERVICE_H_
  5. #define _CRT_SECURE_NO_WARNINGS
  6. #include <string>
  7. #include <Windows.h>

  9. class ServiceClass
  10. {
  11. public:
  12.         SC_HANDLE m_hSCManager,m_hService;
  13.         char m_serviceName[256];
  14.        
  15.         ServiceClass(char *serviceName=NULL);
  16.         ~ServiceClass(void);
  17.         int GetServiceStat(char *serviceName=NULL);
  18.         DWORD GetServiceType(char *serviceName=NULL);
  19.         char *GetServiceDescrible(char *desc,char *serviceName=NULL);
  20.         BOOL SetServiceDescrible(char *newDescrible,char *serviceName=NULL);
  21.         char *GetDisbleName(char *disbleName,char *serviceName=NULL);
  22.         char *GetServiceName(char *serviceName,char *disbleName);
  23.         BOOL InstallService(char *serviceName,char *disbleName,char *exe,char *serviceDescrble=NULL,BOOL bAllowDesktopInteraction=FALSE,int serviceType=16,int startType=3,char *interdePendent=NULL,char *loginUser=NULL,char *loginPass=NULL);
  24.         BOOL UnInstallService(char *serviceName=NULL);
  25.         BOOL StartServices(char *serviceName=NULL);
  26.         BOOL StopService(char *serviceName=NULL);
  27.         BOOL SuspendService(char *serviceName=NULL);
  28.         BOOL RecoveryService(char *serviceName=NULL);
  29.         BOOL Existence(char *serviceName);
  30.         BOOL SetStartType(int type,char *serviceName=NULL);
  31.         DWORD GetStartType(char *serviceName=NULL);
  32.         char *GetFileUrl(char *fileUrl,char *serviceName=NULL);
  33.         BOOL SetFileUrl(char *fileUrl,char *serviceName=NULL);
  34.         char *GetLoginType(char *loginType,char *serviceName=NULL);
  35.         int GetServiceNumber(int serviceStatus=3);
  36.         BOOL ReStartService(char *serviceName=NULL);
  37. };

  39. #endif
复制代码



ServiceClass.cpp

  1. // ServiceClass.cpp
  2. #include "stdafx.h"
  3. #include "ServiceClass.h"

  5. ServiceClass::ServiceClass(char *serviceName)
  6. {
  7.         if (serviceName)
  8.         {
  9.                 strcpy(ServiceClass::m_serviceName,serviceName);
  10.                 ServiceClass::m_hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  11.                 if (!m_hSCManager)
  12.                 {
  13.                         printf("ServiceClass Init fail!\n");
  14.                 } else {
  15.                         ServiceClass::m_hService = OpenService(ServiceClass::m_hSCManager,ServiceClass::m_serviceName,SC_MANAGER_ALL_ACCESS );
  16.                         if (!ServiceClass::m_hSCManager)
  17.                         {
  18.                                 printf("ServiceClass::hService Init fail!\n");
  19.                         }
  20.                 }
  21.         } else {
  22.                 ServiceClass::m_hSCManager = NULL;
  23.                 ServiceClass::m_hService = NULL;
  24.                 memset(ServiceClass::m_serviceName,'\0',sizeof(ServiceClass::m_serviceName));
  25.         }
  26. }

  28. ServiceClass::~ServiceClass(void)
  29. {
  30.         CloseServiceHandle(ServiceClass::m_hService);
  31.         CloseServiceHandle(ServiceClass::m_hSCManager);
  32. }

  34. int ServiceClass::GetServiceStat(char *serviceName)
  35. {
  36.         SERVICE_STATUS serStatus;
  37.         int CurrentState;

  39.         if (serviceName)
  40.         {
  41.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);
  42.                 SC_HANDLE hService = 0;

  44.                 if (!hSCManager)
  45.                 {
  46.                         return -1;
  47.                 }
  48.                 hService = OpenService(hSCManager,serviceName,GENERIC_READ);
  49.                 if (!hService)
  50.                 {
  51.                         CloseServiceHandle(hSCManager);
  52.                         return -2;
  53.                 }
  54.                 if (QueryServiceStatus(hService,&serStatus))
  55.                 {
  56.                         CurrentState = serStatus.dwCurrentState;
  57.                         CloseServiceHandle(hService);
  58.                         CloseServiceHandle(hSCManager);
  59.                 }
  60.         } else {
  61.                 if (QueryServiceStatus(m_hService,&serStatus))
  62.                 {
  63.                         CurrentState = serStatus.dwCurrentState;
  64.                 }
  65.         }
  66.         return CurrentState;
  67. }

  69. DWORD ServiceClass::GetServiceType(char *serviceName)
  70. {
  71.         DWORD dwLen;
  72.         BOOL bResult;
  73.         DWORD dwServiceType = 0;
  74.         LPQUERY_SERVICE_CONFIG lpServiceConfig;

  76.         if (serviceName)
  77.         {
  78.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);
  79.                 SC_HANDLE hService = 0;

  81.                 if (!hSCManager)
  82.                 {
  83.                         return 0;
  84.                 }
  85.                 hService = OpenService(hSCManager,serviceName,GENERIC_READ);
  86.                 if (!hService)
  87.                 {
  88.                         CloseServiceHandle(hSCManager);
  89.                         return 0;
  90.                 }
  91.                 QueryServiceConfig(hService,NULL,NULL,&dwLen);
  92.                 lpServiceConfig = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwLen);
  93.                 bResult = QueryServiceConfig(hService,lpServiceConfig,dwLen,&dwLen);
  94.                 CloseHandle(hService);
  95.                 CloseHandle(hSCManager);
  96.         } else {
  97.                 QueryServiceConfig(m_hService,NULL,NULL,&dwLen);
  98.                 lpServiceConfig = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwLen);
  99.                 bResult = QueryServiceConfig(m_hService,lpServiceConfig,dwLen,&dwLen);
  100.         }
  101.         if (bResult)
  102.         {
  103.                 dwServiceType = lpServiceConfig->dwServiceType;
  104.         }
  105.         GlobalFree(lpServiceConfig);
  106.         return dwServiceType;
  107. }

  109. char *ServiceClass::GetServiceDescrible(char *desc,char *serviceName)
  110. {
  111.         DWORD dwLen = 0;
  112.         BYTE *hMem = NULL;
  113.         SERVICE_DESCRIPTION lpBuffer = {0};

  115.         if (serviceName)
  116.         {
  117.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);
  118.                 SC_HANDLE hService = 0;

  120.                 if (!hSCManager)
  121.                 {
  122.                         return NULL;
  123.                 }
  124.                 hService = OpenService(hSCManager,serviceName,GENERIC_READ);
  125.                 if (!hService)
  126.                 {
  127.                         CloseServiceHandle(hSCManager);
  128.                         return NULL;
  129.                 }
  130.                 QueryServiceConfig2(hService,1,NULL,NULL,&dwLen);
  131.                 hMem = (BYTE *)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,dwLen);
  132.                 if (QueryServiceConfig2(hService,1,hMem,dwLen,&dwLen))
  133.                 {
  134.                         RtlMoveMemory(&lpBuffer,hMem,4);        // memmove
  135.                 }
  136.                 CloseServiceHandle(hService);
  137.                 CloseServiceHandle(hSCManager);
  138.         } else {
  139.                 QueryServiceConfig2(m_hService,1,NULL,NULL,&dwLen);
  140.                 hMem = (BYTE *)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,dwLen);
  141.                 if (QueryServiceConfig2(m_hService,1,hMem,dwLen,&dwLen))
  142.                 {
  143.                         RtlMoveMemory(&lpBuffer,hMem,4);        // memmove
  144.                 }
  145.         }
  146.         strcpy(desc,lpBuffer.lpDescription);
  147.         HeapFree(GetProcessHeap(),HEAP_ZERO_MEMORY,hMem);
  148.         return desc;
  149. }

  151. BOOL ServiceClass::SetServiceDescrible(char *newDescrible,char *serviceName)
  152. {
  153.         BOOL bOk = FALSE;
  154.         SERVICE_DESCRIPTION sd = {0};
  155.         LPSTR szDesc = newDescrible;

  157.         sd.lpDescription = szDesc;
  158.         if (serviceName)
  159.         {
  160.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_EXECUTE);
  161.                 SC_HANDLE hService = 0;

  163.                 if (!hSCManager)
  164.                 {
  165.                         return FALSE;
  166.                 }
  167.                 hService = OpenService(hSCManager,serviceName,GENERIC_EXECUTE);
  168.                 if (!hService)
  169.                 {
  170.                         CloseServiceHandle(hSCManager);
  171.                         return FALSE;
  172.                 }
  173.                 bOk = ChangeServiceConfig2A(hService,1,&sd);
  174.                 CloseServiceHandle(hService);
  175.                 CloseServiceHandle(hSCManager);
  176.         } else {
  177.                 bOk = ChangeServiceConfig2(m_hService,1,&sd);
  178.         }
  179.         return bOk;
  180. }

  182. char *ServiceClass::GetDisbleName(char *disbleName,char *serviceName)
  183. {
  184.         BOOL bResult;
  185.         DWORD dwLen;

  187.         if (serviceName)
  188.         {
  189.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);

  191.                 if (!hSCManager)
  192.                 {
  193.                         return NULL;
  194.                 }
  195.                 GetServiceDisplayName(hSCManager,serviceName,NULL,&dwLen);
  196.                 bResult = GetServiceDisplayName(hSCManager,serviceName,disbleName,&dwLen);
  197.                 CloseServiceHandle(hSCManager);
  198.         } else {
  199.                 GetServiceDisplayName(m_hSCManager,serviceName,NULL,&dwLen);
  200.                 bResult = GetServiceDisplayName(m_hSCManager,m_serviceName,disbleName,&dwLen);
  201.         }
  202.         return (bResult?disbleName:NULL);
  203. }

  205. char *ServiceClass::GetServiceName(char *serviceName,char *disbleName)
  206. {
  207.         DWORD dwLen = 0;
  208.         BOOL bOk = FALSE;

  210.         GetServiceKeyName(ServiceClass::m_hSCManager,disbleName,NULL,&dwLen);
  211.         bOk = GetServiceKeyName(ServiceClass::m_hSCManager,disbleName,serviceName,&dwLen);
  212.         return (bOk?serviceName:NULL);
  213. }

  215. BOOL ServiceClass::InstallService(char *serviceName,char *disbleName,char *exe,char *serviceDescrble,BOOL bAllowDesktopInteraction,int serviceType,int startType,char *interdePendent,char *loginUser,char *loginPass)
  216. {
  217.         if (bAllowDesktopInteraction)
  218.         {
  219.                 serviceType = serviceType|SERVICE_INTERACTIVE_PROCESS;
  220.         }
  221.         ServiceClass::m_hService = CreateService(ServiceClass::m_hSCManager,serviceName,disbleName,SERVICE_ALL_ACCESS,serviceType,startType,SERVICE_ERROR_NORMAL,exe,NULL,NULL,interdePendent,loginUser,loginPass);
  222.         if (ServiceClass::m_hService)
  223.         {
  224.                 ServiceClass::SetServiceDescrible(serviceDescrble,serviceName);
  225.         }
  226.         return (ServiceClass::m_hService != 0);
  227. }

  229. BOOL ServiceClass::UnInstallService(char *serviceName)
  230. {
  231.         BOOL bOk;

  233.         if (serviceName)
  234.         {
  235.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  236.                 SC_HANDLE hService = 0;

  238.                 if (!hSCManager)
  239.                 {
  240.                         return FALSE;
  241.                 }
  242.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  243.                 if (!hService)
  244.                 {
  245.                         CloseServiceHandle(hSCManager);
  246.                         return FALSE;
  247.                 }
  248.                 bOk = DeleteService(hService);
  249.                 CloseHandle(hService);
  250.         } else {
  251.                 bOk = DeleteService(ServiceClass::m_hService);
  252.                 CloseHandle(ServiceClass::m_hService);
  253.         }
  254.         return bOk;
  255. }

  257. BOOL ServiceClass::StartServices(char *serviceName)
  258. {
  259.         BOOL bOk;

  261.         if (serviceName)
  262.         {
  263.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SERVICE_START);
  264.                 SC_HANDLE hService = 0;

  266.                 if (!hSCManager)
  267.                 {
  268.                         return FALSE;
  269.                 }
  270.                 hService = OpenService(hSCManager,serviceName,SERVICE_START);
  271.                 if (!hService)
  272.                 {
  273.                         CloseServiceHandle(hSCManager);
  274.                         return FALSE;
  275.                 }
  276.                 bOk = StartService(hService,NULL,NULL);
  277.                 CloseServiceHandle(hService);
  278.                 CloseServiceHandle(hSCManager);
  279.         } else {
  280.                 bOk = StartService(ServiceClass::m_hService,NULL,NULL);
  281.         }
  282.         return bOk;
  283. }

  285. BOOL ServiceClass::StopService(char *serviceName)
  286. {
  287.         BOOL bOk;
  288.         SERVICE_STATUS status;

  290.         if (serviceName)
  291.         {
  292.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  293.                 SC_HANDLE hService = 0;

  295.                 if (!hSCManager)
  296.                 {
  297.                         return FALSE;
  298.                 }
  299.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  300.                 if (!hService)
  301.                 {
  302.                         CloseServiceHandle(hSCManager);
  303.                         return FALSE;
  304.                 }
  305.                 bOk = ControlService(hService,1,&status);
  306.         } else {
  307.                 bOk = ControlService(ServiceClass::m_hService,1,&status);
  308.         }
  309.         return bOk;
  310. }

  312. BOOL ServiceClass::SuspendService(char *serviceName)
  313. {
  314.         BOOL bOk;
  315.         SERVICE_STATUS status;

  317.         if (serviceName)
  318.         {
  319.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  320.                 SC_HANDLE hService = 0;

  322.                 if (!hSCManager)
  323.                 {
  324.                         return FALSE;
  325.                 }
  326.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  327.                 if (!hService)
  328.                 {
  329.                         CloseServiceHandle(hSCManager);
  330.                         return FALSE;
  331.                 }
  332.                 bOk = ControlService(hService,2,&status);
  333.                 CloseServiceHandle(hService);
  334.                 CloseServiceHandle(hSCManager);
  335.         } else {
  336.                 bOk = ControlService(ServiceClass::m_hService,2,&status);
  337.         }
  338.         return bOk;
  339. }

  341. BOOL ServiceClass::RecoveryService(char *serviceName)
  342. {
  343.         BOOL bOk;
  344.         SERVICE_STATUS status;

  346.         if (serviceName)
  347.         {
  348.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  349.                 SC_HANDLE hService = 0;

  351.                 if (!hSCManager)
  352.                 {
  353.                         return FALSE;
  354.                 }
  355.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  356.                 if (!hService)
  357.                 {
  358.                         CloseServiceHandle(hSCManager);
  359.                         return FALSE;
  360.                 }
  361.                 bOk = ControlService(hService,SERVICE_CONTROL_CONTINUE,&status);
  362.                 CloseServiceHandle(hService);
  363.                 CloseServiceHandle(hSCManager);
  364.         } else {
  365.                 bOk = ControlService(ServiceClass::m_hService,SERVICE_CONTROL_CONTINUE,&status);
  366.         }
  367.         return bOk;
  368. }

  370. BOOL ServiceClass::Existence(char *serviceName)
  371. {
  372.         SC_HANDLE hSCManager,hService;

  374.         hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);
  375.         if (!hSCManager)
  376.         {
  377.                 hService = OpenService(hSCManager,serviceName,GENERIC_READ);
  378.                 CloseServiceHandle(hService);
  379.                 CloseServiceHandle(hSCManager);
  380.         }
  381.         return (hService!=0);
  382. }

  384. BOOL ServiceClass::SetStartType(int type,char *serviceName)
  385. {
  386.         BOOL bOk;

  388.         if (serviceName)
  389.         {
  390.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  391.                 SC_HANDLE hService = 0;

  393.                 if (!hSCManager)
  394.                 {
  395.                         return FALSE;
  396.                 }
  397.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  398.                 if (!hService)
  399.                 {
  400.                         CloseServiceHandle(hSCManager);
  401.                         return FALSE;
  402.                 }
  403.                 bOk = ChangeServiceConfig(hService,4294967295,type,4294967295,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  404.                 CloseServiceHandle(hService);
  405.                 CloseServiceHandle(hSCManager);
  406.         } else {
  407.                 bOk = ChangeServiceConfig(ServiceClass::m_hService,4294967295,type,4294967295,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  408.         }
  409.         return bOk;
  410. }

  412. DWORD ServiceClass::GetStartType(char *serviceName)
  413. {
  414.         LPQUERY_SERVICE_CONFIG lpsc = NULL;
  415.         DWORD dwLen,type;
  416.         BOOL bOk;

  418.         if (serviceName)
  419.         {
  420.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);
  421.                 SC_HANDLE hService = 0;

  423.                 if (!hSCManager)
  424.                 {
  425.                         return -1;
  426.                 }
  427.                 hService = OpenService(hSCManager,serviceName,GENERIC_READ);
  428.                 if (!hService)
  429.                 {
  430.                         CloseServiceHandle(hSCManager);
  431.                         return -1;
  432.                 }
  433.                 QueryServiceConfig(hService,NULL,NULL,&dwLen);
  434.                 lpsc = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwLen);
  435.                 bOk = QueryServiceConfig(hService,lpsc,dwLen,&dwLen);
  436.                 CloseServiceHandle(hService);
  437.                 CloseServiceHandle(hSCManager);
  438.         } else {
  439.                 QueryServiceConfig(ServiceClass::m_hService,NULL,NULL,&dwLen);
  440.                 lpsc = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwLen);
  441.                 bOk = QueryServiceConfig(ServiceClass::m_hService,lpsc,dwLen,&dwLen);
  442.         }
  443.         if (bOk)
  444.         {
  445.                 if (lpsc->dwStartType == 2 && lpsc->dwServiceType == 32)
  446.                 {
  447.                         type = 1;        // 自动
  448.                 } else if (lpsc->dwStartType == 2 && lpsc->dwServiceType == 16)
  449.                 {
  450.                         type = 2;        // 自动(延迟启动)
  451.                 } else if (lpsc->dwStartType == 3)
  452.                 {
  453.                         type =3;        // 手动
  454.                 } else if (lpsc->dwStartType == 4)
  455.                 {
  456.                         type = 4;        // 禁用
  457.                 }
  458.         }
  459.         GlobalFree(lpsc);
  460.         return type;
  461. }

  463. char *ServiceClass::GetFileUrl(char *fileUrl,char *serviceName)
  464. {
  465.         BOOL bOk;
  466.         DWORD dwByteneeded;
  467.         LPQUERY_SERVICE_CONFIG lpsc = {0};

  469.         if (serviceName)
  470.         {
  471.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  472.                 SC_HANDLE hService = 0;

  474.                 if (!hSCManager)
  475.                 {
  476.                         return FALSE;
  477.                 }
  478.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  479.                 if (!hService)
  480.                 {
  481.                         CloseServiceHandle(hSCManager);
  482.                         return FALSE;
  483.                 }
  484.                 QueryServiceConfig(hService,NULL,NULL,&dwByteneeded);
  485.                 lpsc = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwByteneeded);
  486.                 bOk = QueryServiceConfig(hService,lpsc,dwByteneeded,&dwByteneeded);
  487.                 CloseServiceHandle(hService);
  488.                 CloseServiceHandle(hSCManager);
  489.         } else {
  490.                 QueryServiceConfig(ServiceClass::m_hService,NULL,NULL,&dwByteneeded);
  491.                 lpsc = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwByteneeded);
  492.                 bOk = QueryServiceConfig(ServiceClass::m_hService,lpsc,dwByteneeded,&dwByteneeded);
  493.         }
  494.         _strset(fileUrl,0);
  495.         strcpy(fileUrl,lpsc->lpBinaryPathName);
  496.         GlobalFree(lpsc);
  497.         return fileUrl;
  498. }

  500. BOOL ServiceClass::SetFileUrl(char *fileUrl,char *serviceName)
  501. {
  502.         BOOL bOk;

  504.         if (serviceName)
  505.         {
  506.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  507.                 SC_HANDLE hService = 0;

  509.                 if (!hSCManager)
  510.                 {
  511.                         return FALSE;
  512.                 }
  513.                 hService = OpenService(hSCManager,serviceName,SC_MANAGER_ALL_ACCESS);
  514.                 if (!hService)
  515.                 {
  516.                         CloseServiceHandle(hSCManager);
  517.                         return FALSE;
  518.                 }
  519.                 bOk = ChangeServiceConfig(hService,4294967295,4294967295,4294967295,fileUrl,NULL,NULL,NULL,NULL,NULL,NULL);
  520.                 CloseServiceHandle(hService);
  521.                 CloseServiceHandle(hSCManager);
  522.         } else {
  523.                 bOk = ChangeServiceConfig(ServiceClass::m_hService,4294967295,4294967295,4294967295,fileUrl,NULL,NULL,NULL,NULL,NULL,NULL);
  524.         }
  525.         return bOk;
  526. }

  528. char *ServiceClass::GetLoginType(char *loginType,char *serviceName)
  529. {
  530.         char ss[100] = "";
  531.         char *index = NULL;
  532.         BOOL bOk = FALSE;
  533.         DWORD dwByteneeded=0;
  534.        
  535.         LPQUERY_SERVICE_CONFIG lpsc = NULL;
  536.        

  538.         if (serviceName)
  539.         {
  540.                 SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,GENERIC_READ);
  541.                 SC_HANDLE hService = 0;

  543.                 if (!hSCManager)
  544.                 {
  545.                         return NULL;
  546.                 }
  547.                 hService = OpenService(hSCManager,serviceName,GENERIC_READ);
  548.                 if (!hService)
  549.                 {
  550.                         CloseServiceHandle(hSCManager);
  551.                         return NULL;
  552.                 }
  553.                 QueryServiceConfig(hService,NULL,NULL,&dwByteneeded);
  554.                 lpsc = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwByteneeded);
  555.                 bOk = QueryServiceConfig(hService,lpsc,dwByteneeded,&dwByteneeded);
  556.                 CloseServiceHandle(hService);
  557.                 CloseServiceHandle(hSCManager);
  558.         } else {
  559.                 QueryServiceConfig(ServiceClass::m_hService,NULL,NULL,&dwByteneeded);
  560.                 lpsc = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(64,dwByteneeded);
  561.                 bOk = QueryServiceConfig(ServiceClass::m_hService,lpsc,dwByteneeded,&dwByteneeded);
  562.         }
  563.         if (bOk)
  564.         {
  565.                 strcpy(ss,_strupr(lpsc->lpServiceStartName));
  566.                 GlobalFree(lpsc);
  567.                 _strset(loginType,0);
  568.                 if (!strstr(ss,"localservice"))
  569.                 {
  570.                         strcpy(loginType,"本地服务");
  571.                 } else if (!strstr(ss,"Networkservice"))
  572.                 {
  573.                         strcpy(loginType,"网络服务");
  574.                 } else if (!strstr(ss,"localsystem"))
  575.                 {
  576.                         strcpy(loginType,"本地系统");
  577.                 }
  578.         }
  579.         return loginType;
  580. }

  582. int ServiceClass::GetServiceNumber(int serviceStatus)
  583. {
  584.         LPENUM_SERVICE_STATUS lpsc = NULL;
  585.         DWORD dwBytesNeeded = 0,dwReturned = 0,dwHandle = 0;
  586.         BOOL bOk = FALSE;

  588.         EnumServicesStatus(ServiceClass::m_hSCManager,48,serviceStatus,NULL,NULL,&dwBytesNeeded,&dwReturned,&dwHandle);
  589.         lpsc = (LPENUM_SERVICE_STATUS)GlobalAlloc(64,dwBytesNeeded);
  590.         EnumServicesStatus(ServiceClass::m_hSCManager,48,serviceStatus,lpsc,dwBytesNeeded,&dwBytesNeeded,&dwReturned,&dwHandle);
  591.         GlobalFree(lpsc);
  592.         return dwReturned;
  593. }

  595. BOOL ServiceClass::ReStartService(char *serviceName)
  596. {
  597.         if (serviceName)
  598.         {
  599.                 if (ServiceClass::StopService(serviceName))
  600.                         return ServiceClass::StartServices(serviceName);
  601.         } else {
  602.                 if (ServiceClass::StopService(ServiceClass::m_serviceName))
  603.                         return ServiceClass::StartServices(ServiceClass::m_serviceName);
  604.         }
  605.         return FALSE;
  606. }
复制代码



VS的预编译文件也贴出来吧  stdafx.h

  1. // stdafx.h : 标准系统包含文件的包含文件，
  2. // 或是经常使用但不常更改的
  3. // 特定于项目的包含文件
  4. //

  6. #pragma once

  8. #include "targetver.h"

  10. #define WIN32_LEAN_AND_MEAN             //  从 Windows 头文件中排除极少使用的信息



  14. // TODO: 在此处引用程序需要的其他头文件
复制代码


VS的预编译文件也贴出来吧  stdafx.cpp

  1. // stdafx.cpp : 只包括标准包含文件的源文件
  2. // ServiceClass.pch 将作为预编译头
  3. // stdafx.obj 将包含预编译类型信息

  5. #include "stdafx.h"

  7. // TODO: 在 STDAFX.H 中
  8. // 引用任何所需的附加头文件，而不是在此文件中引用
复制代码



有什么地方看不懂，回复这个帖子，看到就做出解答！
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

alltolove
发表于 2018-3-14 16:56:57 | 显示全部楼层
这是神马？代码太长啦看不懂
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

鱼C丶彪哥
 楼主| 发表于 2018-3-14 17:12:09 | 显示全部楼层
alltolove 发表于 2018-3-14 16:56
这是神马？代码太长啦看不懂

Windows服务操作的C++代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-4-23 22:58

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表