home *** CD-ROM | disk | FTP | other *** search
/ Softwarová Záchrana 3 / Softwarova-zachrana-3.bin / pserv.cpl / pserv-2.4.exe / source / cservice.cpp < prev    next >
C/C++ Source or Header  |  2005-01-05  |  30KB  |  909 lines
  1. #include "stdafx.h"
  2. #include "resource.h"
  3. #include "cservice.h"
  4. #include "WriteOptimizedFile.h"
  5. #include "2kwrapper.h"
  6. #include "cconfiguration.h"
  7. #include "MemoryBuffer.h"
  8. #include "stringresources.h"
  9.  
  10. CService::CService(CServiceList* owner)
  11.     :   m_pOwner( owner ),
  12.         m_hTempSCM( 0 ),
  13.         m_hTempService( 0 ),
  14.         m_dwChangeFlags( 0 ),
  15.         m_dwErrorControl( 0 ),
  16.         m_bRestartPending( FALSE ),
  17.         m_dwServiceType( (owner->m_dwEnumType == SERVICE_WIN32) ? SERVICE_WIN32_OWN_PROCESS : SERVICE_KERNEL_DRIVER ),
  18.         m_dwStartType( SERVICE_DEMAND_START )
  19. {
  20.     ZeroMemory( &m_ServiceStatus, sizeof(m_ServiceStatus) );
  21. }
  22.  
  23. COLORREF CService::GetTextColor()
  24. {
  25.     if(IsRunning())
  26.     {
  27.         return RGB(0, 0, 200);
  28.     }
  29.     else if(IsDisabled())
  30.     {
  31.         return RGB(128,128,128);
  32.     }
  33.     return RGB(0,0,0);
  34. }
  35.  
  36. CString CService::GetDisplayString(DWORD dwIndex)
  37. {
  38.     switch(dwIndex)
  39.     {
  40.     case 0: return m_strDisplayName;
  41.     case 1: return m_strServiceName;
  42.     case 2: return GetStatusAsString();
  43.     case 3: return GetStartAsString();
  44.     case 4: return GetTypeAsString();
  45.     case 5: return m_strBinaryPathName;
  46.     case 6: return GetPidAsString();
  47.     case 7: return m_strServiceStartName;
  48.     case 8: return m_strLoadOrderGroup;
  49.     case 9: return m_strDescription;
  50.     }
  51.     return CString();
  52. }
  53.  
  54. CString CService::GetInfoTip()
  55. {
  56.     return m_strDescription;
  57. }
  58.  
  59.  
  60. CService::~CService()
  61. {
  62.     FinishStateType();
  63. }
  64.  
  65. BOOL CService::RefreshServiceStatus()
  66. {
  67.     MemoryBuffer mb;
  68.     if( lpfnQueryServiceStatusEx )
  69.     {
  70.         LPSERVICE_STATUS_PROCESS ssp = mb.QueryServiceStatusEx(m_hTempService);
  71.         if( ssp )
  72.         {
  73.             m_ServiceStatus = *ssp;
  74.             return TRUE;
  75.         }
  76.         return FALSE;
  77.     }
  78.     return QueryServiceStatus( m_hTempService, (LPSERVICE_STATUS) &m_ServiceStatus );
  79. }
  80.  
  81. BOOL CService::ApplyChanges()
  82. {
  83.     // no changes -> success always
  84.     if(!m_dwChangeFlags )
  85.         return TRUE;
  86.  
  87.     BOOL bSuccess = FALSE;
  88.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT );
  89.     if( m_hTempSCM )
  90.     {
  91.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, SERVICE_CHANGE_CONFIG|SERVICE_QUERY_STATUS );
  92.         if( m_hTempService )
  93.         {
  94.             LPCTSTR lpszStartName = NULL, lpszStartPassword = NULL;
  95.             if( m_dwChangeFlags & CHANGED_LOGON_SYSTEM )
  96.             {
  97.                 lpszStartName = TEXT(".\\LOCALSYSTEM");
  98.                 lpszStartPassword = TEXT("");
  99.             }
  100.             else if( m_dwChangeFlags & CHANGED_LOGON_USER )
  101.             {
  102.                 lpszStartName = m_strServiceStartName;
  103.                 lpszStartPassword = m_strServiceStartPassword;
  104.             }
  105.  
  106.             bSuccess = ChangeServiceConfig( 
  107.                             m_hTempService, 
  108.                             (m_dwChangeFlags & CHANGED_ALLOW_UI) ? m_dwServiceType : SERVICE_NO_CHANGE,
  109.                             (m_dwChangeFlags & CHANGED_START_TYPE) ? m_dwStartType : SERVICE_NO_CHANGE,
  110.                             (m_dwChangeFlags & CHANGED_ERROR_CONTROL) ? m_dwErrorControl : SERVICE_NO_CHANGE,
  111.                             (m_dwChangeFlags & CHANGED_BINARYPATH) ? (LPCTSTR) m_strBinaryPathName : NULL,
  112.                             NULL,
  113.                             NULL, 
  114.                             NULL,
  115.                             lpszStartName,
  116.                             lpszStartPassword,
  117.                             (m_dwChangeFlags & CHANGED_DISPLAYNAME) ? (LPCTSTR) m_strDisplayName : NULL );
  118.             
  119.             if( bSuccess && (m_dwChangeFlags & CHANGED_DESCRIPTION) && (lpfnChangeServiceConfig2 != NULL))
  120.             {
  121.                 SERVICE_DESCRIPTION sd;
  122.                 sd.lpDescription = (LPTSTR) (LPCTSTR) m_strDescription;
  123.                 bSuccess = lpfnChangeServiceConfig2( m_hTempService, SERVICE_CONFIG_DESCRIPTION, &sd );
  124.             }
  125.  
  126.             DWORD dwLastError = GetLastError();
  127.             RefreshServiceStatus();
  128.             CloseServiceHandle( m_hTempService );
  129.             m_hTempService = 0;
  130.             SetLastError(dwLastError);
  131.         }
  132.         DWORD dwLastError = GetLastError();
  133.         CloseServiceHandle(m_hTempSCM);
  134.         m_hTempSCM = 0;
  135.         SetLastError(dwLastError);
  136.     }
  137.     return bSuccess;
  138. }
  139.  
  140. BOOL CService::Delete()
  141. {
  142.     BOOL bSuccess = FALSE;
  143.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, STANDARD_RIGHTS_REQUIRED );
  144.     if( m_hTempSCM )
  145.     {
  146.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, STANDARD_RIGHTS_REQUIRED  );
  147.         if( m_hTempService )
  148.         {
  149.             bSuccess = DeleteService(m_hTempService);
  150.             DWORD dwLastError = GetLastError();
  151.             CloseServiceHandle( m_hTempService );
  152.             m_hTempService = 0;
  153.             SetLastError(dwLastError);
  154.         }
  155.         DWORD dwLastError = GetLastError();
  156.         CloseServiceHandle(m_hTempSCM);
  157.         m_hTempSCM = 0;
  158.         SetLastError(dwLastError);
  159.     }
  160.     return bSuccess;
  161. }
  162.  
  163. BOOL CService::Install()
  164. {
  165.     BOOL bSuccess = FALSE;
  166.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CREATE_SERVICE );
  167.     if( m_hTempSCM )
  168.     {
  169.         LPCTSTR lpszStartName = NULL, lpszStartPassword = NULL;
  170.         if( !IsEmptyString( m_strServiceStartName ) )
  171.         {
  172.             lpszStartName = m_strServiceStartName;
  173.             lpszStartPassword = m_strServiceStartPassword;
  174.         }
  175.  
  176.         m_hTempService = CreateService(m_hTempSCM,
  177.                                        m_strServiceName,
  178.                                        m_strDisplayName,
  179.                                        SERVICE_QUERY_CONFIG|SERVICE_QUERY_STATUS|SERVICE_CHANGE_CONFIG,
  180.                                        m_dwServiceType,
  181.                                        m_dwStartType,
  182.                                        m_dwErrorControl,
  183.                                        m_strBinaryPathName,
  184.                                        NULL,
  185.                                        NULL, 
  186.                                        NULL, 
  187.                                        lpszStartName,
  188.                                        lpszStartPassword );
  189.         if( m_hTempService )
  190.         {
  191.             bSuccess = TRUE;
  192.             if( !IsEmptyString(m_strDescription))
  193.             {
  194.                 SERVICE_DESCRIPTION sd;
  195.                 sd.lpDescription = (LPTSTR) (LPCTSTR) m_strDescription;
  196.                 bSuccess = lpfnChangeServiceConfig2( m_hTempService, SERVICE_CONFIG_DESCRIPTION, &sd );
  197.             }
  198.  
  199.             DWORD dwLastError = GetLastError();
  200.             RefreshServiceStatus();
  201.             CloseServiceHandle( m_hTempService );
  202.             m_hTempService = 0;
  203.             SetLastError(dwLastError);
  204.         }
  205.         DWORD dwLastError = GetLastError();
  206.         CloseServiceHandle(m_hTempSCM);
  207.         m_hTempSCM = 0;
  208.         SetLastError(dwLastError);
  209.     }
  210.     return bSuccess;
  211. }
  212.  
  213. BOOL CService::StartAtBoot()
  214. {
  215.     if( m_dwStartType != SERVICE_BOOT_START )
  216.     {
  217.         m_dwStartType = SERVICE_BOOT_START;
  218.         m_dwChangeFlags = CHANGED_START_TYPE;
  219.         return ApplyChanges();
  220.     }
  221.     return TRUE;
  222. }
  223.  
  224. BOOL CService::StartAtSystem()
  225. {
  226.     if( m_dwStartType != SERVICE_SYSTEM_START )
  227.     {
  228.         m_dwStartType = SERVICE_SYSTEM_START;
  229.         m_dwChangeFlags = CHANGED_START_TYPE;
  230.         return ApplyChanges();
  231.     }
  232.     return TRUE;
  233. }
  234.  
  235. BOOL CService::Enable()
  236. {
  237.     if( m_dwStartType != SERVICE_DEMAND_START )
  238.     {
  239.         m_dwStartType = SERVICE_DEMAND_START;
  240.         m_dwChangeFlags = CHANGED_START_TYPE;
  241.         return ApplyChanges();
  242.     }
  243.     return TRUE;
  244. }
  245.  
  246. BOOL CService::Disable()
  247. {
  248.     if( m_dwStartType != SERVICE_DISABLED )
  249.     {
  250.         m_dwStartType = SERVICE_DISABLED;
  251.         m_dwChangeFlags = CHANGED_START_TYPE;
  252.         return ApplyChanges();
  253.     }
  254.     return TRUE;
  255. }
  256.  
  257. BOOL CService::StartAutomatically()
  258. {
  259.     if( m_dwStartType != SERVICE_AUTO_START )
  260.     {
  261.         m_dwStartType = SERVICE_AUTO_START;
  262.         m_dwChangeFlags = CHANGED_START_TYPE;
  263.         return ApplyChanges();
  264.     }
  265.     return TRUE;
  266. }
  267.  
  268. SERVICE_STATE_TYPE CService::BeginStart(LPDWORD lpdwWaitHint)
  269. {
  270.     FinishStateType();
  271.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT );
  272.     if( m_hTempSCM )
  273.     {
  274.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, SERVICE_START|SERVICE_QUERY_STATUS );
  275.         if( m_hTempService )
  276.         {
  277.             if( StartService( m_hTempService, 0, NULL ) )
  278.             {
  279.                 if( RefreshServiceStatus() )
  280.                 {
  281.                     if( m_ServiceStatus.dwCurrentState == SERVICE_RUNNING )
  282.                     {
  283.                         return SERVICE_STATE_REACHED;
  284.                     }
  285.                     else if( m_ServiceStatus.dwCurrentState == SERVICE_START_PENDING )
  286.                     { 
  287.                         *lpdwWaitHint = m_ServiceStatus.dwWaitHint;
  288.                         return SERVICE_STATE_PENDING;
  289.                     }
  290.                 }
  291.             }
  292.         }
  293.     }
  294.     return SERVICE_STATE_FAILED;
  295. } 
  296.  
  297. SERVICE_STATE_TYPE CService::BeginStop(LPDWORD lpdwWaitHint)
  298. {
  299.     FinishStateType();
  300.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT );
  301.     if( m_hTempSCM )
  302.     {
  303.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, SERVICE_STOP|SERVICE_QUERY_STATUS );
  304.         if( m_hTempService )
  305.         {
  306.             if( ControlService( m_hTempService, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS) &m_ServiceStatus) )
  307.             {
  308.                 if( m_ServiceStatus.dwCurrentState == SERVICE_STOPPED )
  309.                 {
  310.                     return SERVICE_STATE_REACHED;
  311.                 }
  312.                 else if( m_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING )
  313.                 { 
  314.                     *lpdwWaitHint = m_ServiceStatus.dwWaitHint;
  315.                     return SERVICE_STATE_PENDING;
  316.                 }
  317.             }
  318.         }
  319.     }
  320.     return SERVICE_STATE_FAILED;
  321. } 
  322.  
  323. SERVICE_STATE_TYPE CService::BeginRestart(LPDWORD lpdwWaitHint)
  324. {
  325.     FinishStateType();
  326.     m_bRestartPending = TRUE;
  327.     m_bRestartHasBeenStopped = FALSE;
  328.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT );
  329.     if( m_hTempSCM )
  330.     {
  331.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, SERVICE_STOP|SERVICE_QUERY_STATUS );
  332.         if( m_hTempService )
  333.         {
  334.             if( ControlService( m_hTempService, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS) &m_ServiceStatus) )
  335.             {
  336.                 if( m_ServiceStatus.dwCurrentState == SERVICE_STOPPED )
  337.                 {
  338.                     // ok, stopped, now restart
  339.                     m_bRestartHasBeenStopped = TRUE;
  340.                     return BeginStart(lpdwWaitHint);
  341.                 }
  342.                 else if( m_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING )
  343.                 { 
  344.                     *lpdwWaitHint = m_ServiceStatus.dwWaitHint + (10 * 1000);
  345.                     return SERVICE_STATE_PENDING;
  346.                 }
  347.             }
  348.         }
  349.     }
  350.     return SERVICE_STATE_FAILED;
  351. } 
  352.  
  353. SERVICE_STATE_TYPE CService::BeginPause(LPDWORD lpdwWaitHint)
  354. {
  355.     FinishStateType();
  356.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT );
  357.     if( m_hTempSCM )
  358.     {
  359.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, SERVICE_PAUSE_CONTINUE|SERVICE_QUERY_STATUS );
  360.         if( m_hTempService )
  361.         {
  362.             if( ControlService( m_hTempService, SERVICE_CONTROL_PAUSE, (LPSERVICE_STATUS) &m_ServiceStatus) )
  363.             {
  364.                 if( m_ServiceStatus.dwCurrentState == SERVICE_PAUSED )
  365.                 {
  366.                     return SERVICE_STATE_REACHED;
  367.                 }
  368.                 else if( m_ServiceStatus.dwCurrentState == SERVICE_PAUSE_PENDING )
  369.                 { 
  370.                     *lpdwWaitHint = m_ServiceStatus.dwWaitHint;
  371.                     return SERVICE_STATE_PENDING;
  372.                 }
  373.             }
  374.         }
  375.     }
  376.     return SERVICE_STATE_FAILED;
  377. } 
  378.  
  379. SERVICE_STATE_TYPE CService::BeginContinue(LPDWORD lpdwWaitHint)
  380. {
  381.     FinishStateType();
  382.     m_hTempSCM = OpenSCManager( m_pOwner->m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT );
  383.     if( m_hTempSCM )
  384.     {
  385.         m_hTempService = OpenService(m_hTempSCM, m_strServiceName, SERVICE_PAUSE_CONTINUE|SERVICE_QUERY_STATUS );
  386.         if( m_hTempService )
  387.         {
  388.             if( ControlService( m_hTempService, SERVICE_CONTROL_CONTINUE, (LPSERVICE_STATUS) &m_ServiceStatus) )
  389.             {
  390.                 if( m_ServiceStatus.dwCurrentState == SERVICE_RUNNING )
  391.                 {
  392.                     return SERVICE_STATE_REACHED;
  393.                 }
  394.                 else if( m_ServiceStatus.dwCurrentState == SERVICE_CONTINUE_PENDING )
  395.                 { 
  396.                     *lpdwWaitHint = m_ServiceStatus.dwWaitHint;
  397.                     return SERVICE_STATE_PENDING;
  398.                 }
  399.             }
  400.         }
  401.     }
  402.     return SERVICE_STATE_FAILED;
  403. } 
  404.  
  405. SERVICE_STATE_TYPE CService::IsStarted()
  406. {
  407.     if( !m_hTempService || RefreshServiceStatus() )
  408.     {
  409.         if( m_ServiceStatus.dwCurrentState == SERVICE_RUNNING )
  410.         {
  411.             return SERVICE_STATE_REACHED;
  412.         }
  413.         else if( m_ServiceStatus.dwCurrentState == SERVICE_START_PENDING )
  414.         { 
  415.             return SERVICE_STATE_PENDING;
  416.         }
  417.     }
  418.     return SERVICE_STATE_FAILED;
  419. }
  420.  
  421. SERVICE_STATE_TYPE CService::IsRestarted()
  422. {
  423.     if( !m_hTempService || RefreshServiceStatus() )
  424.     {
  425.         if( m_ServiceStatus.dwCurrentState == SERVICE_RUNNING )
  426.         {
  427.             if( m_bRestartHasBeenStopped )
  428.             {
  429.                 return SERVICE_STATE_REACHED;
  430.             }
  431.             else
  432.             {
  433.                 // unable to restart, abort
  434.                 return SERVICE_STATE_FAILED;
  435.             }
  436.         }
  437.         else if( m_ServiceStatus.dwCurrentState == SERVICE_STOPPED )
  438.         {
  439.             if( m_bRestartHasBeenStopped )
  440.             {
  441.                 // unable to restart, abort
  442.                 return SERVICE_STATE_FAILED;
  443.             }
  444.             DWORD dwIgnoreMe;
  445.             SERVICE_STATE_TYPE result = BeginStart(&dwIgnoreMe);
  446.             if( result == SERVICE_STATE_PENDING )
  447.                 m_bRestartHasBeenStopped = TRUE;
  448.             return result;
  449.         }
  450.         else if( m_ServiceStatus.dwCurrentState == SERVICE_START_PENDING )
  451.         { 
  452.             return SERVICE_STATE_PENDING;
  453.         }
  454.         else if( m_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING )
  455.         { 
  456.             return SERVICE_STATE_PENDING;
  457.         }
  458.     }
  459.     return SERVICE_STATE_FAILED;
  460. }
  461.  
  462. SERVICE_STATE_TYPE CService::IsStopped()
  463. {
  464.     if( !m_hTempService || RefreshServiceStatus() )
  465.     {
  466.         if( m_ServiceStatus.dwCurrentState == SERVICE_STOPPED )
  467.         {
  468.             return SERVICE_STATE_REACHED;
  469.         }
  470.         else if( m_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING )
  471.         { 
  472.             return SERVICE_STATE_PENDING;
  473.         }
  474.     }
  475.     return SERVICE_STATE_FAILED;
  476. }
  477.  
  478. SERVICE_STATE_TYPE CService::IsContinued()
  479. {
  480.     if( !m_hTempService || RefreshServiceStatus() )
  481.     {
  482.         if( m_ServiceStatus.dwCurrentState == SERVICE_RUNNING )
  483.         {
  484.             return SERVICE_STATE_REACHED;
  485.         }
  486.         else if( m_ServiceStatus.dwCurrentState == SERVICE_CONTINUE_PENDING )
  487.         { 
  488.             return SERVICE_STATE_PENDING;
  489.         }
  490.     }
  491.     return SERVICE_STATE_FAILED;
  492. }
  493.  
  494.  
  495. SERVICE_STATE_TYPE CService::IsPaused()
  496. {
  497.     if( !m_hTempService || RefreshServiceStatus() )
  498.     {
  499.         if( m_ServiceStatus.dwCurrentState == SERVICE_PAUSED )
  500.         {
  501.             return SERVICE_STATE_REACHED;
  502.         }
  503.         else if( m_ServiceStatus.dwCurrentState == SERVICE_PAUSE_PENDING )
  504.         { 
  505.             return SERVICE_STATE_PENDING;
  506.         }
  507.     }
  508.     return SERVICE_STATE_FAILED;
  509. }
  510.  
  511. void CService::FinishStateType()
  512. {
  513.     if( m_hTempService )
  514.     {
  515.         CloseServiceHandle(m_hTempService);
  516.         m_hTempService = 0;
  517.     }
  518.     if( m_hTempSCM )
  519.     {
  520.         CloseServiceHandle(m_hTempSCM);
  521.         m_hTempSCM = 0;
  522.     }
  523.     m_bRestartPending = FALSE;
  524. }
  525.  
  526. CString CService::GetPidAsString()
  527. {
  528.     CString result( _T("") );
  529.     if( m_ServiceStatus.dwProcessId )
  530.         result.Format( _T("%d"), m_ServiceStatus.dwProcessId );
  531.     return result;
  532. }
  533.  
  534. CString CService::GetStatusAsString()
  535. {
  536.     switch(m_ServiceStatus.dwCurrentState)
  537.     {
  538.     case SERVICE_STOPPED:
  539.         return  strSERVICE_STATUS_STOPPED;
  540.     case SERVICE_START_PENDING:
  541.         return strSERVICE_STATUS_START_PENDING;
  542.     case SERVICE_STOP_PENDING:
  543.         return strSERVICE_STATUS_STOP_PENDING;
  544.     case SERVICE_RUNNING:
  545.         return strSERVICE_STATUS_RUNNING;
  546.     case SERVICE_CONTINUE_PENDING:
  547.         return strSERVICE_STATUS_CONTINUE_PENDING;
  548.     case SERVICE_PAUSE_PENDING:
  549.         return strSERVICE_STATUS_PAUSE_PENDING;
  550.     case SERVICE_PAUSED:
  551.         return strSERVICE_STATUS_PAUSED;
  552.     }
  553.     CString result;
  554.     result.Format(strSERVICE_STATUS_INVALID, m_ServiceStatus.dwCurrentState );
  555.     return result;
  556. }
  557.  
  558. CString CService::GetPrintStatusAsString()
  559. {
  560.     switch(m_ServiceStatus.dwCurrentState)
  561.     {
  562.     case SERVICE_STOPPED:
  563.         return _T("Stopped");
  564.     case SERVICE_START_PENDING:
  565.         return _T("Start pending");
  566.     case SERVICE_STOP_PENDING:
  567.         return _T("Stop pending");
  568.     case SERVICE_RUNNING:
  569.         return _T("Running");
  570.     case SERVICE_CONTINUE_PENDING:
  571.         return _T("Continue pending");
  572.     case SERVICE_PAUSE_PENDING:
  573.         return _T("Pause pending");
  574.     case SERVICE_PAUSED:
  575.         return _T("Paused");
  576.     }
  577.  
  578.     CString result;
  579.     result.Format(_T("<INVALID: 0x%08lx>"), m_ServiceStatus.dwCurrentState );
  580.     return result;
  581. }
  582.  
  583. CString CService::GetStartAsString()
  584. {
  585.     return GetStartAsString(m_dwStartType);
  586. }
  587.  
  588. CString CService::GetStartAsString(DWORD dwStartType)
  589. {
  590.     switch(dwStartType)
  591.     {
  592.     // WARNING: also used in PXmlReader.cpp !!!
  593.     case SERVICE_BOOT_START:
  594.         return _T("Boot");
  595.     case SERVICE_SYSTEM_START:    
  596.         return _T("System");
  597.     case SERVICE_AUTO_START:    
  598.         return _T("Automatic");
  599.     case SERVICE_DEMAND_START:    
  600.         return _T("Manual");
  601.     case SERVICE_DISABLED:        
  602.         return _T("Disabled");
  603.     }
  604.     CString result;
  605.     result.Format(_T("<INVALID: 0x%08lx>"), dwStartType );
  606.     return result;
  607. }
  608.  
  609. CString CService::GetTypeAsString()
  610. {
  611.     CString result;
  612.     if( m_dwServiceType & SERVICE_WIN32_OWN_PROCESS )        
  613.         result += _T("Process " );
  614.     if( m_dwServiceType & SERVICE_WIN32_SHARE_PROCESS )    
  615.         result += _T("Shared ");
  616.     if( m_dwServiceType & SERVICE_KERNEL_DRIVER )            
  617.         result += _T("Driver ");
  618.     if( m_dwServiceType & SERVICE_FILE_SYSTEM_DRIVER )    
  619.         result += _T("File System ");
  620.     if( m_dwServiceType & SERVICE_INTERACTIVE_PROCESS )    
  621.         result += _T("(Interactive) ");
  622.     return result;
  623. }
  624.  
  625. BOOL CService::CreateFrom(SC_HANDLE hSCM, LPENUM_SERVICE_STATUS_PROCESS lpStatus)
  626. {
  627.     m_strServiceName = lpStatus->lpServiceName;
  628.     m_strDisplayName = lpStatus->lpDisplayName;
  629.     m_ServiceStatus = lpStatus->ServiceStatusProcess;
  630.     m_strDescription = (LPCSTR) NULL;
  631.  
  632.     SC_HANDLE hService = OpenService(hSCM, m_strServiceName, SERVICE_QUERY_CONFIG );
  633.     if( hService )
  634.     {
  635.         MemoryBuffer mb;
  636.         LPQUERY_SERVICE_CONFIG pServiceConfig = mb.QueryServiceConfig(hService);
  637.         if( pServiceConfig )
  638.         {
  639.             m_strBinaryPathName = pServiceConfig->lpBinaryPathName;
  640.             m_dwErrorControl = pServiceConfig->dwErrorControl;
  641.             m_dwServiceType = pServiceConfig->dwServiceType;
  642.             m_dwStartType = pServiceConfig->dwStartType;
  643.             m_strServiceStartName = pServiceConfig->lpServiceStartName;
  644.             m_strLoadOrderGroup = pServiceConfig->lpLoadOrderGroup;
  645.             m_strDescription = mb.GetServiceDescription(hService);
  646.         }
  647.         CloseServiceHandle(hService);
  648.     }
  649.     return TRUE;
  650. }
  651.  
  652. void CServiceList::SetEnumType( DWORD dwEnumType )
  653. {
  654.     m_dwEnumType = dwEnumType;
  655.     RefreshTitleString();
  656. }
  657.  
  658. static GENERICCOMPAREFN SortMethods[10] = {
  659.     GENERICCOMPAREFN(&CServiceList::SortByDisplayName),
  660.     GENERICCOMPAREFN(&CServiceList::SortByServiceName),
  661.     GENERICCOMPAREFN(&CServiceList::SortByStatus),
  662.     GENERICCOMPAREFN(&CServiceList::SortByStart),
  663.     GENERICCOMPAREFN(&CServiceList::SortByType),
  664.     GENERICCOMPAREFN(&CServiceList::SortByBinaryPathName),
  665.     GENERICCOMPAREFN(&CServiceList::SortByPid),
  666.     GENERICCOMPAREFN(&CServiceList::SortByUser),
  667.     GENERICCOMPAREFN(&CServiceList::SortByLoadOrderGroup),
  668.     GENERICCOMPAREFN(&CServiceList::SortByDescription),
  669. };
  670.  
  671. CServiceList::CServiceList()
  672.     :   CListViewEntries( SortMethods, _T("Services") ),
  673.         m_dwEnumType( SERVICE_WIN32 )
  674. {
  675.     CreateColumns( _T("Service"), _T("Section"), _T("Status"), _T("Start"), _T("Type"), _T("Path"), _T("PID"), _T("User"), _T("Load Order Group"), _T("Description"), NULL );
  676.  
  677.     RefreshTitleString();
  678.  
  679.     // read in m_LoadOrderGroups
  680.     HKEY hKey;
  681.     LONG lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
  682.                         _T("SYSTEM\\CurrentControlSet\\Control\\ServiceGroupOrder"),
  683.                         0,
  684.                         _T(""),
  685.                         0,
  686.                         KEY_READ,
  687.                         NULL,
  688.                         &hKey,
  689.                         0 );
  690.     if( lResult == 0 )
  691.     {
  692.         DWORD dwType = 0, dwData = 0, dwData2;
  693.         RegQueryValueEx(hKey, _T("List"), 0, &dwType, NULL, &dwData ); 
  694.         if( dwData )
  695.         {
  696.             LPBYTE lpbData = new BYTE[dwData+1];
  697.             if( lpbData )
  698.             {
  699.                 dwData2 = dwData;
  700.                 if( RegQueryValueEx(hKey, _T("List"), 0, &dwType, lpbData, &dwData2 ) == 0 )
  701.                 {
  702.                     lpbData[dwData] = 0;
  703.                     ASSERT( dwType == REG_MULTI_SZ );
  704.  
  705.                     LPCTSTR p = (LPCTSTR) lpbData;
  706.                     while( *p )
  707.                     {
  708.                         m_LoadOrderGroups.Add( p );
  709.                         p += (lstrlen(p)+1)*sizeof(TCHAR);
  710.                     }
  711.  
  712.                 }
  713.                 delete lpbData;
  714.             }
  715.         }
  716.         RegCloseKey(hKey);
  717.     }
  718.  
  719. }
  720.  
  721. CServiceList::~CServiceList()
  722. {
  723. }
  724.  
  725. void CServiceList::ConnectTo( LPCTSTR lpszMachine )
  726. {
  727.     m_strServiceMachine = lpszMachine;
  728.     RefreshTitleString();
  729. }
  730.  
  731. void CServiceList::RefreshTitleString()
  732. {
  733.     LPCTSTR lpszTag = GetTagString();
  734.     LPCTSTR lpszMachine = m_strServiceMachine;
  735.     if( !lpszMachine || !*lpszMachine )
  736.     {
  737.         m_strTitle.Format( TEXT("pserv ") CURRENT_VERSION TEXT(": %s on local machine"), lpszTag );
  738.     }
  739.     else
  740.     {
  741.         m_strTitle.Format( TEXT("pserv ") CURRENT_VERSION TEXT(": %s on \\\\%s"), lpszTag, (LPCTSTR)m_strServiceMachine  );
  742.     }
  743. }
  744.  
  745.  
  746. int CServiceList::SortByDisplayName(const CService** ps1, const CService** ps2)
  747. {
  748.     return (*ps1)->m_strDisplayName.CompareNoCase((*ps2)->m_strDisplayName);
  749. }
  750.  
  751. int CServiceList::SortByServiceName(const CService** ps1, const CService** ps2)
  752. {
  753.     return (*ps1)->m_strServiceName.CompareNoCase((*ps2)->m_strServiceName);
  754. }
  755.  
  756. int CServiceList::SortByStatus(const CService** ps1, const CService** ps2)
  757. {
  758.     return LONG((*ps1)->m_ServiceStatus.dwCurrentState)-LONG((*ps2)->m_ServiceStatus.dwCurrentState);
  759. }
  760.  
  761. int CServiceList::SortByStart(const CService** ps1, const CService** ps2)
  762. {
  763.     return LONG((*ps1)->m_dwStartType)-LONG((*ps2)->m_dwStartType);
  764. }
  765.  
  766. int CServiceList::SortByType(const CService** ps1, const CService** ps2)
  767. {
  768.     return LONG((*ps1)->m_dwServiceType)-LONG((*ps2)->m_dwServiceType);
  769. }
  770.  
  771. int CServiceList::SortByBinaryPathName(const CService** ps1, const CService** ps2)
  772. {
  773.     return (*ps1)->m_strBinaryPathName.CompareNoCase((*ps2)->m_strBinaryPathName);
  774. }
  775.  
  776. int CServiceList::SortByUser(const CService** ps1, const CService** ps2)
  777. {
  778.     return (*ps1)->m_strServiceStartName.CompareNoCase((*ps2)->m_strServiceStartName);
  779. }
  780.  
  781. int CServiceList::SortByLoadOrderGroup(const CService** ps1, const CService** ps2)
  782. {
  783.     return (*ps1)->m_strLoadOrderGroup.CompareNoCase((*ps2)->m_strLoadOrderGroup);
  784. }
  785.  
  786. int CServiceList::SortByPid(const CService** ps1, const CService** ps2)
  787. {
  788.     return LONG((*ps1)->m_ServiceStatus.dwProcessId)-LONG((*ps2)->m_ServiceStatus.dwProcessId);
  789. }
  790.  
  791. int CServiceList::SortByDescription(const CService** ps1, const CService** ps2)
  792. {
  793.     return (*ps1)->m_strDescription.CompareNoCase((*ps2)->m_strDescription);
  794. }
  795.  
  796.  
  797. BOOL CServiceList::AddServiceFromStatus(SC_HANDLE hSCM, LPENUM_SERVICE_STATUS_PROCESS lpStatus)
  798. {
  799.     CService* instance = new CService(this);
  800.     if( instance != NULL )
  801.     {
  802.         if( instance->CreateFrom( hSCM, lpStatus ) )
  803.         {
  804.             m_Entries.Add(instance);
  805.             return TRUE;
  806.         }
  807.         else delete instance;
  808.     }
  809.     return FALSE;
  810. }
  811.  
  812. void CServiceList::ExportXmlToFile( CFile* pFile )
  813. {
  814.     LPCTSTR lpszTag = GetTagString();
  815.  
  816.     PrintToFile(pFile, _T("<?xml version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"yes\"?>\r\n")
  817.               _T("<%s>\r\n"), lpszTag );
  818.  
  819.     for(int n = 0, nmax = m_Entries.GetSize(); n < nmax; n++ )
  820.     {
  821.         CService* p = (CService*)m_Entries.GetAt(n);
  822.         PrintToFile(pFile, _T("\t<service id=\"%s\">\r\n"), (LPCTSTR) XmlEscape(p->m_strServiceName) );
  823.         PrintToFile(pFile, _T("\t\t<name>%s</name>\r\n"),(LPCTSTR)  XmlEscape(p->m_strDisplayName) );
  824.         PrintToFile(pFile, _T("\t\t<status>%s</status>\r\n"), (LPCTSTR) p->GetStatusAsString() );
  825.         PrintToFile(pFile, _T("\t\t<start>%s</start>\r\n"), (LPCTSTR) p->GetStartAsString() );
  826.         PrintToFile(pFile, _T("\t\t<type>%s</type>\r\n"), (LPCTSTR) p->GetTypeAsString() );
  827.         PrintToFile(pFile, _T("\t\t<path>%s</path>\r\n"), (LPCTSTR) p->m_strBinaryPathName );
  828.         PrintToFile(pFile, _T("\t\t<pid>%s</pid>\r\n"), (LPCTSTR) p->GetPidAsString() );
  829.         PrintToFile(pFile, _T("\t\t<description>%s</description>\r\n"), (LPCTSTR) XmlEscape(p->m_strDescription) );
  830.         PrintToFile(pFile, _T("\t</service>\r\n") );
  831.     }
  832.  
  833.     PrintToFile(pFile, _T("</%s>"), lpszTag);
  834. }
  835.  
  836. BOOL CServiceList::Refresh()
  837. {
  838.     BOOL bSuccess = FALSE;
  839.     DeleteObjects( m_Entries );
  840.  
  841.     SC_HANDLE hSCM = OpenSCManager( m_strServiceMachine, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ENUMERATE_SERVICE ); 
  842.     if( hSCM )
  843.     {
  844.         DWORD dwBytesNeeded, dwServicesReturned, dwResumeHandle = 0;
  845.         if( lpfnEnumServicesStatusEx )
  846.         {
  847.             VERIFY( !lpfnEnumServicesStatusEx( hSCM, SC_ENUM_PROCESS_INFO, m_dwEnumType, SERVICE_STATE_ALL, 
  848.                 NULL, 0, &dwBytesNeeded, &dwServicesReturned, &dwResumeHandle, NULL ) );
  849.             
  850.             ASSERT( GetLastError() == ERROR_MORE_DATA );
  851.  
  852.             LPBYTE bBuffer = new BYTE[dwBytesNeeded];
  853.             if( bBuffer )
  854.             {
  855.                 if( lpfnEnumServicesStatusEx( hSCM, SC_ENUM_PROCESS_INFO, m_dwEnumType, SERVICE_STATE_ALL, 
  856.                     bBuffer, dwBytesNeeded, &dwBytesNeeded, &dwServicesReturned, &dwResumeHandle, NULL ) )
  857.                 {
  858.                     LPENUM_SERVICE_STATUS_PROCESS lpStatus = (LPENUM_SERVICE_STATUS_PROCESS)bBuffer;
  859.                     for( DWORD dwIndex = 0; dwIndex < dwServicesReturned; dwIndex++ )
  860.                     {
  861.                         bSuccess = AddServiceFromStatus( hSCM, &(lpStatus[dwIndex]));
  862.                     }
  863.                 }
  864.                 delete bBuffer;
  865.             }
  866.         }
  867.         else 
  868.         {
  869.             VERIFY( !EnumServicesStatus( hSCM, m_dwEnumType, SERVICE_STATE_ALL, 0, 0, &dwBytesNeeded, &dwServicesReturned, &dwResumeHandle ) );
  870.             ASSERT( GetLastError() == ERROR_MORE_DATA );
  871.  
  872.             LPBYTE bBuffer = new BYTE[dwBytesNeeded];
  873.             if( bBuffer )
  874.             {
  875.             
  876.                 if( EnumServicesStatus( hSCM, m_dwEnumType, SERVICE_STATE_ALL, (LPENUM_SERVICE_STATUS)bBuffer, dwBytesNeeded, &dwBytesNeeded, &dwServicesReturned, &dwResumeHandle ) )
  877.                 {
  878.                     LPENUM_SERVICE_STATUS lpStatus = (LPENUM_SERVICE_STATUS)bBuffer;
  879.                     for( DWORD dwIndex = 0; dwIndex < dwServicesReturned; dwIndex++ )
  880.                     {
  881.                         LPENUM_SERVICE_STATUS s = &(lpStatus[dwIndex]);
  882.                         ENUM_SERVICE_STATUS_PROCESS esp;
  883.                         CopyMemory( &esp, s, sizeof(ENUM_SERVICE_STATUS) );
  884.                         esp.ServiceStatusProcess.dwProcessId = 0;
  885.                         esp.ServiceStatusProcess.dwServiceFlags = 0;
  886.                         bSuccess = AddServiceFromStatus( hSCM, &esp);
  887.                     }
  888.                 }
  889.                 delete bBuffer;
  890.             }
  891.         }
  892.  
  893.         Sort();
  894.  
  895.         CloseServiceHandle(hSCM);
  896.     }
  897.     if( !bSuccess )
  898.         DisplayErrorMessage(_T("Unable to get initial list of %s"), GetTagString() );
  899.  
  900.     return bSuccess;
  901. }
  902.  
  903. UINT CServiceList::GetContextMenuID()
  904. {
  905.     return IDR_CONTEXTMENU;
  906. }
  907.  
  908.  
  909.