开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
NTService.cpp
资源名称：SmartMailSvr　[点击查看]
上传用户：qdlutongda
上传日期：2007-01-14
资源大小：133k
文件大小：32k
源码类别：

Email客户端

开发平台：

Visual C++

NTService.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 1997 by Joerg Koenig and the ADG mbH, Mannheim, Germany
  3. // All rights reserved
  4. //
  5. // Distribute freely, except: don't remove my name from the source or
  6. // documentation (don't take credit for my work), mark your changes (don't
  7. // get me blamed for your possible bugs), don't alter or remove this
  8. // notice.
  9. // No warrantee of any kind, express or implied, is included with this
  10. // software; use at your own risk, responsibility for damages (if any) to
  11. // anyone resulting from the use of this software rests entirely with the
  12. // user.
  13. //
  14. // Send bug reports, bug fixes, enhancements, requests, flames, etc., and
  15. // I'll try to keep a version up to date.  I can be reached as follows:
  16. //    J.Koenig@adg.de                 (company site)
  17. //    Joerg.Koenig@rhein-neckar.de    (private site)
  18. /////////////////////////////////////////////////////////////////////////////
  19. //
  20. // MODIFIED BY TODD C. WILSON FOR THE ROAD RUNNER NT LOGIN SERVICE.
  21. // HOWEVER, THESE MODIFICATIONS ARE BROADER IN SCOPE AND USAGE AND CAN BE USED
  22. // IN OTHER PROJECTS WITH NO CHANGES.
  23. // MODIFIED LINES FLAGGED/BRACKETED BY "//!! TCW MOD"
  24. //
  25. /////////////////////////////////////////////////////////////////////////////
  28. // last revised: $Date: 11.05.98 21:09 $, $Revision: 3 $
  31. /////////////////////////////////////////////////////////////////////////////
  32. // Acknoledgements:
  33. // o Thanks to Victor Vogelpoel (VictorV@Telic.nl) for his bug-fixes
  34. // and enhancements.
  35. // o Thanks to Todd C. Wilson (todd@mediatec.com) for the
  36. // "service" on Win95
  37. //
  38. // Changes:
  39. // 01/21/99
  40. // o Bug fixed in "DeregisterApplicationLog()"
  41. // thanks to Grahame Willis (grahamew@questsoftware.com.au):
  42. //
  43. // 04/30/98
  44. // o Added two more switches to handle command line arguments:
  45. // -e will force a running service to stop (corresponding
  46. // method in this class: virtual BOOL EndService();) and
  47. // -s will force the service to start (method:
  48. // virtual BOOL StartupService())
  49. //
  50. // 02/05/98
  51. // o Added the methods "RegisterApplicationLog()" and
  52. // "DeregisterApplicationLog()" (both virtual). The first one will be
  53. // called from "InstallService()" and creates some registry-entries
  54. // for a better event-log. The second one removes these entries when
  55. // the service will uninstall (see "RemoveService()")
  56. // o The service now obtains the security identifier of the current user
  57. // and uses this SID for event-logging.
  58. // o The memory allocated by "CommandLineToArgvW()" will now release
  59. // (UNICODE version only)
  60. // o The service now uses a simple message catalogue for a nicer
  61. // event logging
  63. #include <stdafx.h>
  64. ///#include <windows.h>
  65. #include <tchar.h>
  66. #include <stdio.h>
  67. #include <crtdbg.h>
  69. #include <io.h> //!! TCW MOD
  70. #include <fcntl.h> //!! TCW MOD
  72. #include "NTService.h"
  73. #include "NTServiceEventLogMsg.h"
  76. #ifndef RSP_SIMPLE_SERVICE
  77. #define RSP_SIMPLE_SERVICE 1
  78. #endif
  79. #ifndef RSP_UNREGISTER_SERVICE
  80. #define RSP_UNREGISTER_SERVICE 0
  81. #endif
  83. BOOL CNTService :: m_bInstance = FALSE;
  85. static CNTService * gpTheService = 0; // the one and only instance
  87. CNTService * AfxGetService() { return gpTheService; }
  92. static LPCTSTR gszAppRegKey = TEXT("SYSTEM\CurrentControlSet\Services\EventLog\Application\");
  93. static LPCTSTR gszWin95ServKey=TEXT("Software\Microsoft\Windows\CurrentVersion\RunServices"); //!! TCW MOD
  96. /////////////////////////////////////////////////////////////////////////////
  97. // class CNTService -- construction/destruction
  99. CNTService :: CNTService( LPCTSTR lpServiceName, LPCTSTR lpDisplayName )
  100. : m_lpServiceName(lpServiceName)
  101. , m_lpDisplayName(lpDisplayName ? lpDisplayName : lpServiceName)
  102. , m_dwCheckPoint(0)
  103. , m_dwErr(0)
  104. , m_bDebug(FALSE)
  105. , m_sshStatusHandle(0)
  106. , m_dwControlsAccepted(SERVICE_ACCEPT_STOP)
  107. , m_pUserSID(0)
  108. , m_fConsoleReady(FALSE)
  109. // parameters to the "CreateService()" function:
  110. , m_dwDesiredAccess(SERVICE_ALL_ACCESS)
  111. , m_dwServiceType(SERVICE_WIN32_OWN_PROCESS)
  112. , m_dwStartType(SERVICE_AUTO_START)
  113. , m_dwErrorControl(SERVICE_ERROR_NORMAL)
  114. , m_pszLoadOrderGroup(0)
  115. , m_dwTagID(0)
  116. , m_pszDependencies(0)
  117. , m_pszStartName(0)
  118. , m_pszPassword(0)
  119. {
  120. _ASSERTE( ! m_bInstance );
  122. OSVERSIONINFO vi;
  123. vi.dwOSVersionInfoSize=sizeof(vi);  // init this.
  124. GetVersionEx(&vi);      //lint !e534
  125. m_bWinNT = (vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
  127. m_bInstance = TRUE;
  128. gpTheService = this;
  130. // SERVICE_STATUS members that rarely change
  131. m_ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
  132. m_ssStatus.dwServiceSpecificExitCode = 0;
  134. if( m_bWinNT ) {
  135. /////////////////////////////////////////////////////////////////////////
  136. // Providing a SID (security identifier) was contributed by Victor
  137. // Vogelpoel (VictorV@Telic.nl).
  138. // The code from Victor was slightly modified.
  140. // Get security information of current user
  141. BYTE security_identifier_buffer[ 4096 ];
  142. DWORD dwSizeSecurityIdBuffer = sizeof( security_identifier_buffer );
  143. PSID user_security_identifier = NULL;
  145. TCHAR sUserName[ 256 ];
  146. DWORD dwSizeUserName  =  255;
  148. TCHAR sDomainName[ 256 ];
  149. DWORD dwSizeDomainName = 255;
  151. SID_NAME_USE sidTypeSecurityId;
  153. ::ZeroMemory( sUserName, sizeof( sUserName ) );
  154. ::ZeroMemory( sDomainName, sizeof( sDomainName ) );
  155. ::ZeroMemory( security_identifier_buffer, dwSizeSecurityIdBuffer );
  157. ::GetUserName( sUserName, &dwSizeUserName );
  159. if( ::LookupAccountName(
  160. 0,
  161. sUserName,
  162. &security_identifier_buffer,
  163. &dwSizeSecurityIdBuffer,
  164. sDomainName,
  165. &dwSizeDomainName,
  166. &sidTypeSecurityId
  167. )) {
  168. if( ::IsValidSid( PSID(security_identifier_buffer) ) ) {
  169. DWORD dwSidLen = ::GetLengthSid(PSID(security_identifier_buffer));
  170. m_pUserSID = PSID(new BYTE [dwSidLen]);
  171. ::CopySid(dwSidLen, m_pUserSID, security_identifier_buffer);
  172. _ASSERTE(::EqualSid(m_pUserSID, security_identifier_buffer));
  173. }
  174. }
  175. }
  176. /////////////////////////////////////////////////////////////////////////
  177. }
  180. CNTService :: ~CNTService() {
  181. _ASSERTE( m_bInstance );
  182. delete [] LPBYTE(m_pUserSID);
  183. m_bInstance = FALSE;
  184. gpTheService = 0;
  185. }
  189. /////////////////////////////////////////////////////////////////////////////
  190. // class CNTService -- overridables
  192. #define NEXT_ARG ((((*Argv)[2])==TEXT(''))?(--Argc,*++Argv):(*Argv)+2)
  195. BOOL CNTService :: RegisterService( int argc, char ** argv ) {
  196. BOOL (CNTService::* fnc)() = &CNTService::StartDispatcher;
  197.     DWORD Argc;
  198.     LPTSTR * Argv;
  200. #ifdef UNICODE
  201.     Argv = CommandLineToArgvW(GetCommandLineW(), &Argc );
  202. #else
  203.     Argc = (DWORD) argc;
  204.     Argv = argv;
  205. #endif
  207.     while( ++Argv, --Argc ) {
  208. if( Argv[0][0] == TEXT('-') ) {
  209. switch( Argv[0][1] ) {
  210. case TEXT('i'): // install the service
  211. fnc = &CNTService::InstallService;
  212. break;
  213. case TEXT('l'): // login-account (only useful with -i)
  214. m_pszStartName = NEXT_ARG;
  215. break;
  216. case TEXT('p'): // password (only useful with -i)
  217. m_pszPassword = NEXT_ARG;
  218. break;
  219. case TEXT('u'): // uninstall the service
  220. fnc = &CNTService::RemoveService;
  221. break;
  222. case TEXT('s'): // start the service
  223. fnc = &CNTService::StartupService;
  224. break;
  225. case TEXT('e'): // end the service
  226. fnc = &CNTService::EndService;
  227. break;
  228. case TEXT('d'): // debug the service
  229. case TEXT('f'): //!! TCW MOD faceless non-service (Win95) mode
  230. #ifdef UNICODE
  231. ::GlobalFree(HGLOBAL)Argv);
  232. #endif
  234. m_bDebug = TRUE;
  235. // pass original parameters to DebugService()
  236. return DebugService(argc, argv,(Argv[0][1]==TEXT('f'))); //!! TCW MOD faceless non-service (Win95) mode
  237. }
  238. }
  239. }
  241. #ifdef UNICODE
  242. ::GlobalFree(HGLOBAL)Argv);
  243. #endif
  245. //!! TCW MOD START - if Win95, run as faceless app.
  246. if( fnc == &CNTService::StartDispatcher && OsIsWin95() ) {
  247. // act as if -f was passed anyways.
  248. m_bDebug = TRUE;
  249. return DebugService(argc, argv, TRUE);
  250. }
  251. //!! TCW MOD END - if Win95, run as faceless app.
  253. return (this->*fnc)();
  254. }
  257. BOOL CNTService :: StartDispatcher() {
  258.     // Default implementation creates a single threaded service.
  259. // Override this method and provide more table entries for
  260. // a multithreaded service (one entry for each thread).
  261. SERVICE_TABLE_ENTRY dispatchTable[] =
  262.     {
  263.         { LPTSTR(m_lpServiceName), (LPSERVICE_MAIN_FUNCTION)ServiceMain },
  264.         { 0, 0 }
  265.     };
  267. BOOL bRet = StartServiceCtrlDispatcher(dispatchTable);
  268. if( ! bRet ) {
  269. TCHAR szBuf[256];
  270.         AddToMessageLog(GetLastErrorText(szBuf,255));
  271. }
  273. return bRet;
  274. }
  277. BOOL CNTService :: InstallService() {
  278.     TCHAR szPath[1024];
  280. SetupConsole(); //!! TCW MOD - have to show the console here for the
  281. // diagnostic or error reason: orignal class assumed
  282. // that we were using _main for entry (a console app).
  283. // This particular usage is a Windows app (no console),
  284. // so we need to create it. Using SetupConsole with _main
  285. // is ok - does nothing, since you only get one console.
  287. if( GetModuleFileName( 0, szPath, 1023 ) == 0 ) {
  288. TCHAR szErr[256];
  289. _tprintf(TEXT("Unable to install %s - %sn"), m_lpDisplayName, GetLastErrorText(szErr, 256));
  290. return FALSE;
  291. }
  293. BOOL bRet = FALSE;
  295. if( OsIsWin95() ) { //!! TCW MOD - code added to install as Win95 service
  296. // Create a key for that application and insert values for
  297. // "EventMessageFile" and "TypesSupported"
  298. HKEY hKey = 0;
  299. LONG lRet = ERROR_SUCCESS;
  300. if( ::RegCreateKey(HKEY_LOCAL_MACHINE, gszWin95ServKey , &hKey) == ERROR_SUCCESS ) {
  301. lRet = ::RegSetValueEx(
  302. hKey, // handle of key to set value for
  303. m_lpServiceName, // address of value to set (NAME OF SERVICE)
  304. 0, // reserved
  305. REG_EXPAND_SZ, // flag for value type
  306. (CONST BYTE*)szPath,// address of value data
  307. _tcslen(szPath) + 1 // size of value data
  308. );
  309. ::RegCloseKey(hKey);
  310. bRet=TRUE;
  311. }
  312. } else {
  313. // Real NT services go here.
  314. SC_HANDLE schSCManager = OpenSCManager(
  315. 0, // machine (NULL == local)
  316. 0, // database (NULL == default)
  317. SC_MANAGER_ALL_ACCESS // access required
  318. );
  319. if( schSCManager ) {
  320. SC_HANDLE schService = CreateService(
  321. schSCManager,
  322. m_lpServiceName,
  323. m_lpDisplayName,
  324. m_dwDesiredAccess,
  325. m_dwServiceType,
  326. m_dwStartType,
  327. m_dwErrorControl,
  328. szPath,
  329. m_pszLoadOrderGroup,
  330. ((m_dwServiceType == SERVICE_KERNEL_DRIVER ||
  331.   m_dwServiceType == SERVICE_FILE_SYSTEM_DRIVER) &&
  332.  (m_dwStartType == SERVICE_BOOT_START ||
  333.   m_dwStartType == SERVICE_SYSTEM_START)) ?
  334. &m_dwTagID : 0,
  335. m_pszDependencies,
  336. m_pszStartName,
  337. m_pszPassword
  338. );
  340. if( schService ) {
  341. _tprintf(TEXT("%s installed.n"), m_lpDisplayName );
  342. CloseServiceHandle(schService);
  343. bRet = TRUE;
  344. } else {
  345. TCHAR szErr[256];
  346. _tprintf(TEXT("CreateService failed - %sn"), GetLastErrorText(szErr, 256));
  347. }
  349. CloseServiceHandle(schSCManager);
  350.  } else {
  351. TCHAR szErr[256];
  352. _tprintf(TEXT("OpenSCManager failed - %sn"), GetLastErrorText(szErr,256));
  353. }
  355. if( bRet ) {
  356. // installation succeeded. Now register the message file
  357. RegisterApplicationLog(
  358. szPath, // the path to the application itself
  359. EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE // supported types
  360. );
  362. AddToMessageLog(TEXT("Service installed"),EVENTLOG_INFORMATION_TYPE);
  363. }
  364. } //!! TCW MOD
  366. return bRet;
  367. }
  370. BOOL CNTService :: RemoveService() {
  371. BOOL bRet = FALSE;
  373. SetupConsole(); //!! TCW MOD - have to show the console here for the
  374. // diagnostic or error reason: orignal class assumed
  375. // that we were using _main for entry (a console app).
  376. // This particular usage is a Windows app (no console),
  377. // so we need to create it. Using SetupConsole with _main
  378. // is ok - does nothing, since you only get one console.
  381. if( OsIsWin95() ) { //!! TCW MOD - code added to install as Win95 service
  382. HKEY hKey = 0;
  383. LONG lRet = ERROR_SUCCESS;
  384. if( ::RegCreateKey(HKEY_LOCAL_MACHINE, gszWin95ServKey , &hKey) == ERROR_SUCCESS ) {
  385. lRet = ::RegDeleteValue(hKey, m_lpServiceName);
  386. ::RegCloseKey(hKey);
  387. bRet=TRUE;
  388. }
  389. } else {
  390. // Real NT services go here.
  391. SC_HANDLE schSCManager = OpenSCManager(
  392. 0, // machine (NULL == local)
  393. 0, // database (NULL == default)
  394. SC_MANAGER_ALL_ACCESS // access required
  395. );
  396. if( schSCManager ) {
  397. SC_HANDLE schService = OpenService(
  398. schSCManager,
  399. m_lpServiceName,
  400. SERVICE_ALL_ACCESS
  401. );
  403. if( schService ) {
  404. // try to stop the service
  405. if( ControlService(schService, SERVICE_CONTROL_STOP, &m_ssStatus) ) {
  406. _tprintf(TEXT("Stopping %s."), m_lpDisplayName);
  407. Sleep(1000);
  409. while( QueryServiceStatus(schService, &m_ssStatus) ) {
  410. if( m_ssStatus.dwCurrentState == SERVICE_STOP_PENDING ) {
  411. _tprintf(TEXT("."));
  412. Sleep( 1000 );
  413. } else
  414. break;
  415. }
  417. if( m_ssStatus.dwCurrentState == SERVICE_STOPPED )
  418. _tprintf(TEXT("n%s stopped.n"), m_lpDisplayName);
  419.  else
  420.   _tprintf(TEXT("n%s failed to stop.n"), m_lpDisplayName);
  421. }
  423. // now remove the service
  424. if( DeleteService(schService) ) {
  425. _tprintf(TEXT("%s removed.n"), m_lpDisplayName);
  426. bRet = TRUE;
  427. } else {
  428. TCHAR szErr[256];
  429. _tprintf(TEXT("DeleteService failed - %sn"), GetLastErrorText(szErr,256));
  430. }
  432. CloseServiceHandle(schService);
  433. } else {
  434. TCHAR szErr[256];
  435. _tprintf(TEXT("OpenService failed - %sn"), GetLastErrorText(szErr,256));
  436. }
  438.   CloseServiceHandle(schSCManager);
  439.  } else {
  440. TCHAR szErr[256];
  441. _tprintf(TEXT("OpenSCManager failed - %sn"), GetLastErrorText(szErr,256));
  442. }
  444. if( bRet )
  445. DeregisterApplicationLog();
  446. }
  448. return bRet;
  449. }
  452. BOOL CNTService :: EndService() {
  453. BOOL bRet = FALSE;
  455. SC_HANDLE schSCManager = ::OpenSCManager(
  456. 0, // machine (NULL == local)
  457. 0, // database (NULL == default)
  458. SC_MANAGER_ALL_ACCESS // access required
  459. );
  460. if( schSCManager ) {
  461. SC_HANDLE schService = ::OpenService(
  462. schSCManager,
  463. m_lpServiceName,
  464. SERVICE_ALL_ACCESS
  465. );
  467. if( schService ) {
  468. // try to stop the service
  469. if( ::ControlService(schService, SERVICE_CONTROL_STOP, &m_ssStatus) ) {
  470. _tprintf(TEXT("Stopping %s."), m_lpDisplayName);
  471. ::Sleep(1000);
  473. while( ::QueryServiceStatus(schService, &m_ssStatus) ) {
  474. if( m_ssStatus.dwCurrentState == SERVICE_STOP_PENDING ) {
  475. _tprintf(TEXT("."));
  476. ::Sleep( 1000 );
  477. } else
  478. break;
  479. }
  481. if( m_ssStatus.dwCurrentState == SERVICE_STOPPED )
  482. bRet = TRUE, _tprintf(TEXT("n%s stopped.n"), m_lpDisplayName);
  483.                 else
  484.                     _tprintf(TEXT("n%s failed to stop.n"), m_lpDisplayName);
  485. }
  487. ::CloseServiceHandle(schService);
  488. } else {
  489. TCHAR szErr[256];
  490. _tprintf(TEXT("OpenService failed - %sn"), GetLastErrorText(szErr,256));
  491. }
  493.         ::CloseServiceHandle(schSCManager);
  494.     } else {
  495. TCHAR szErr[256];
  496. _tprintf(TEXT("OpenSCManager failed - %sn"), GetLastErrorText(szErr,256));
  497. }
  499. return bRet;
  500. }
  503. BOOL CNTService :: StartupService() {
  504. BOOL bRet = FALSE;
  506. SC_HANDLE schSCManager = ::OpenSCManager(
  507. 0, // machine (NULL == local)
  508. 0, // database (NULL == default)
  509. SC_MANAGER_ALL_ACCESS // access required
  510. );
  511. if( schSCManager ) {
  512. SC_HANDLE schService = ::OpenService(
  513. schSCManager,
  514. m_lpServiceName,
  515. SERVICE_ALL_ACCESS
  516. );
  518. if( schService ) {
  519. // try to start the service
  520. _tprintf(TEXT("Starting up %s."), m_lpDisplayName);
  521. if( ::StartService(schService, 0, 0) ) {
  522. Sleep(1000);
  524. while( ::QueryServiceStatus(schService, &m_ssStatus) ) {
  525. if( m_ssStatus.dwCurrentState == SERVICE_START_PENDING ) {
  526. _tprintf(TEXT("."));
  527. Sleep( 1000 );
  528. } else
  529. break;
  530. }
  532. if( m_ssStatus.dwCurrentState == SERVICE_RUNNING )
  533. bRet = TRUE, _tprintf(TEXT("n%s started.n"), m_lpDisplayName);
  534.                 else
  535.                     _tprintf(TEXT("n%s failed to start.n"), m_lpDisplayName);
  536. } else {
  537. // StartService failed
  538. TCHAR szErr[256];
  539. _tprintf(TEXT("n%s failed to start: %sn"), m_lpDisplayName, GetLastErrorText(szErr,256));
  540. }
  542. ::CloseServiceHandle(schService);
  543. } else {
  544. TCHAR szErr[256];
  545. _tprintf(TEXT("OpenService failed - %sn"), GetLastErrorText(szErr,256));
  546. }
  548.         ::CloseServiceHandle(schSCManager);
  549.     } else {
  550. TCHAR szErr[256];
  551. _tprintf(TEXT("OpenSCManager failed - %sn"), GetLastErrorText(szErr,256));
  552. }
  554. return bRet;
  555. }
  558. ////////////////////////////////////////////////////////////////////////////
  559. //!! TCW MOD - faceless window procedure for usage within Win95 (mostly),
  560. // but can be invoked under NT by using -f
  561. LRESULT CALLBACK _FacelessWndProc_( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
  562. if (uMsg==WM_QUERYENDSESSION || uMsg==WM_ENDSESSION || uMsg==WM_QUIT) {
  563. if (lParam==NULL || uMsg==WM_QUIT) {
  564. DestroyWindow(hwnd); // kill me
  565. if (AfxGetService()!=NULL)
  566. AfxGetService()->Stop(); // stop me.
  567. return TRUE;
  568. }
  569. }
  570. return DefWindowProc(hwnd,uMsg,wParam,lParam);
  571. }
  572. ////////////////////////////////////////////////////////////////////////////
  575. BOOL CNTService :: DebugService(int argc, char ** argv, BOOL faceless) {
  576.     DWORD dwArgc;
  577.     LPTSTR *lpszArgv;
  579. #ifdef UNICODE
  580.     lpszArgv = CommandLineToArgvW(GetCommandLineW(), &(dwArgc) );
  581. #else
  582.     dwArgc   = (DWORD) argc;
  583.     lpszArgv = argv;
  584. #endif
  586. if( !faceless ) { //!! TCW MOD - no faceless, so give it a face.
  587. SetupConsole(); //!! TCW MOD - make the console for debugging
  588.    _tprintf(TEXT("Debugging %s.n"), m_lpDisplayName);
  590. SetConsoleCtrlHandler(ControlHandler, TRUE);
  591. }
  593. //!! TCW MOD START - if Win95, register server
  594. typedef DWORD (WINAPI *fp_RegServProc)(DWORD dwProcessId,DWORD dwType);
  595. fp_RegServProc fncptr=NULL;
  597. if( faceless /*&& OsIsWin95()*/ ) {
  598. WNDCLASS wndclass;
  599. memset(&wndclass,0,sizeof(WNDCLASS));
  600. wndclass.lpfnWndProc = _FacelessWndProc_;
  601. wndclass.hInstance = HINSTANCE(::GetModuleHandle(0));
  602. wndclass.lpszClassName = TEXT("RRL__FacelessWndProc_");
  603. ATOM atom = ::RegisterClass(&wndclass);
  604. HWND hwnd = ::CreateWindow(wndclass.lpszClassName,TEXT(""),0,0,0,0,0,0,0,wndclass.hInstance,0);
  605. HMODULE hModule = ::GetModuleHandle(TEXT("kernel32.dll"));
  606. // punch F1 on "RegisterServiceProcess" for what it does and when to use it.
  607. fncptr=(fp_RegServProc)::GetProcAddress(hModule, "RegisterServiceProcess");
  608. if (fncptr!=NULL)
  609. (*fncptr)(0, RSP_SIMPLE_SERVICE);
  610. }
  611. //!! TCW MOD END - if Win95, register server
  614.     Run(dwArgc, lpszArgv);
  616. #ifdef UNICODE
  617. ::GlobalFree(HGLOBAL)lpszArgv);
  618. #endif
  620. if (fncptr!=NULL) //!! TCW MOD - if it's there, remove it: our run is over
  621. (*fncptr)(0, RSP_UNREGISTER_SERVICE);
  623. return TRUE;
  624. }
  627. void CNTService :: Pause() {
  628. }
  631. void CNTService :: Continue() {
  632. }
  635. void CNTService :: Shutdown() {
  636. }
  639. /////////////////////////////////////////////////////////////////////////////
  640. // class CNTService -- default handlers
  642. void WINAPI CNTService :: ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv) {
  643. _ASSERTE( gpTheService != 0 );
  645. // register our service control handler:
  646. gpTheService->m_sshStatusHandle = RegisterServiceCtrlHandler(
  647. gpTheService->m_lpServiceName,
  648. CNTService::ServiceCtrl
  649. );
  651. if( gpTheService->m_sshStatusHandle )
  653. // report the status to the service control manager.
  654. if( gpTheService->ReportStatus(SERVICE_START_PENDING) ){
  655. gpTheService->Run( dwArgc, lpszArgv );}
  657. // try to report the stopped status to the service control manager.
  658. if( gpTheService->m_sshStatusHandle )
  659. gpTheService->ReportStatus(SERVICE_STOPPED);
  660. }
  663. void WINAPI CNTService :: ServiceCtrl(DWORD dwCtrlCode) {
  664. _ASSERTE( gpTheService != 0 );
  666. // Handle the requested control code.
  667. switch( dwCtrlCode ) {
  668. case SERVICE_CONTROL_STOP:
  669. // Stop the service.
  670. gpTheService->m_ssStatus.dwCurrentState = SERVICE_STOP_PENDING;
  671. gpTheService->Stop();
  672. break;
  674. case SERVICE_CONTROL_PAUSE:
  675. gpTheService->m_ssStatus.dwCurrentState = SERVICE_PAUSE_PENDING;
  676. gpTheService->Pause();
  677. break;
  679. case SERVICE_CONTROL_CONTINUE:
  680. gpTheService->m_ssStatus.dwCurrentState = SERVICE_CONTINUE_PENDING;
  681. gpTheService->Continue();
  682. break;
  684. case SERVICE_CONTROL_SHUTDOWN:
  685. gpTheService->Shutdown();
  686. break;
  688. case SERVICE_CONTROL_INTERROGATE:
  689. // Update the service status.
  690. gpTheService->ReportStatus(gpTheService->m_ssStatus.dwCurrentState);
  691. break;
  693. default:
  694. // invalid control code
  695. break;
  696. }
  698. }
  701. BOOL WINAPI CNTService :: ControlHandler(DWORD dwCtrlType) {
  702. _ASSERTE(gpTheService != 0);
  703. switch( dwCtrlType ) {
  704. case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate
  705. case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode
  706. _tprintf(TEXT("Stopping %s.n"), gpTheService->m_lpDisplayName);
  707. gpTheService->Stop();
  708. return TRUE;
  709. }
  710. return FALSE;
  711. }
  714. /////////////////////////////////////////////////////////////////////////////
  715. // class CNTService -- helpers
  717. //!! TCW MOD - added DWORD dwErrExit for error exit value. Defaults to zero
  718. BOOL CNTService :: ReportStatus(
  719. DWORD dwCurrentState,
  720. DWORD dwWaitHint,
  721. DWORD dwErrExit ) {
  722. BOOL fResult = TRUE;
  724. if( !m_bDebug ) { // when debugging we don't report to the SCM
  725.         if( dwCurrentState == SERVICE_START_PENDING)
  726.             m_ssStatus.dwControlsAccepted = 0;
  727.         else
  728.             m_ssStatus.dwControlsAccepted = m_dwControlsAccepted;
  730.         m_ssStatus.dwCurrentState = dwCurrentState;
  731.         m_ssStatus.dwWin32ExitCode = NO_ERROR;
  732.         m_ssStatus.dwWaitHint = dwWaitHint;
  734. //!! TCW MOD START - added code to support error exiting
  735. m_ssStatus.dwServiceSpecificExitCode = dwErrExit;
  736. if (dwErrExit!=0)
  737. m_ssStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
  738. //!! TCW MOD END - added code to support error exiting
  740.         if( dwCurrentState == SERVICE_RUNNING ||
  741.             dwCurrentState == SERVICE_STOPPED )
  742.             m_ssStatus.dwCheckPoint = 0;
  743.         else
  744.             m_ssStatus.dwCheckPoint = ++m_dwCheckPoint;
  746.         // Report the status of the service to the service control manager.
  747.         if (!(fResult = SetServiceStatus( m_sshStatusHandle, &m_ssStatus))) {
  748.             AddToMessageLog(TEXT("SetServiceStatus() failed"));
  749.         }
  750.     }
  752.     return fResult;
  753. }
  756. void CNTService :: AddToMessageLog(LPTSTR lpszMsg, WORD wEventType, DWORD dwEventID) {
  757. m_dwErr = GetLastError();
  759. // use default message-IDs
  760. if( dwEventID == DWORD(-1) ) {
  761. switch( wEventType ) {
  762. case EVENTLOG_ERROR_TYPE:
  763. dwEventID = MSG_ERROR_1;
  764. break;
  765. case EVENTLOG_WARNING_TYPE:
  766. dwEventID = MSG_WARNING_1;
  767. break;
  768. case EVENTLOG_INFORMATION_TYPE:
  769. dwEventID = MSG_INFO_1;
  770. break;
  771. case EVENTLOG_AUDIT_SUCCESS:
  772. dwEventID = MSG_INFO_1;
  773. break;
  774. case EVENTLOG_AUDIT_FAILURE:
  775. dwEventID = MSG_INFO_1;
  776. break;
  777. default:
  778. dwEventID = MSG_INFO_1;
  779. break;
  780. }
  781. }
  783. // Use event logging to log the error.
  784. HANDLE hEventSource = RegisterEventSource(0, m_lpServiceName);
  786. if( hEventSource != 0 ) {
  787. LPCTSTR lpszMessage = lpszMsg;
  789. ReportEvent(
  790. hEventSource, // handle of event source
  791. wEventType, // event type
  792. 0, // event category
  793. dwEventID, // event ID
  794. m_pUserSID, // current user's SID
  795. 1, // strings in lpszStrings
  796. 0, // no bytes of raw data
  797. &lpszMessage, // array of error strings
  798. 0 // no raw data
  799. );
  801. ::DeregisterEventSource(hEventSource);
  802.     }
  803. }
  806. LPTSTR CNTService :: GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize ) {
  807.     LPTSTR lpszTemp = 0;
  809.     DWORD dwRet = ::FormatMessage(
  810. FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
  811. 0,
  812. GetLastError(),
  813. LANG_NEUTRAL,
  814. (LPTSTR)&lpszTemp,
  815. 0,
  816. 0
  817. );
  819.     if( !dwRet || (dwSize < dwRet+14) )
  820.         lpszBuf[0] = TEXT('');
  821.     else {
  822.         lpszTemp[_tcsclen(lpszTemp)-2] = TEXT('');  //remove cr/nl characters
  823.         _tcscpy(lpszBuf, lpszTemp);
  824.     }
  826.     if( lpszTemp )
  827.         LocalFree(HLOCAL(lpszTemp));
  829.     return lpszBuf;
  830. }
  832. /////////////////////////////////////////////////////////////////////////////
  833. // class CNTService -- implementation
  835. void CNTService :: RegisterApplicationLog( LPCTSTR lpszFileName, DWORD dwTypes ) {
  836. TCHAR szKey[256];
  837. _tcscpy(szKey, gszAppRegKey);
  838. _tcscat(szKey, m_lpServiceName);
  839. HKEY hKey = 0;
  840. LONG lRet = ERROR_SUCCESS;
  842. // Create a key for that application and insert values for
  843. // "EventMessageFile" and "TypesSupported"
  844. if( ::RegCreateKey(HKEY_LOCAL_MACHINE, szKey, &hKey) == ERROR_SUCCESS ) {
  845. lRet = ::RegSetValueEx(
  846. hKey, // handle of key to set value for
  847. TEXT("EventMessageFile"), // address of value to set
  848. 0, // reserved
  849. REG_EXPAND_SZ, // flag for value type
  850. (CONST BYTE*)lpszFileName, // address of value data
  851. _tcslen(lpszFileName) + 1 // size of value data
  852. );
  854. // Set the supported types flags.
  855. lRet = ::RegSetValueEx(
  856. hKey, // handle of key to set value for
  857. TEXT("TypesSupported"), // address of value to set
  858. 0, // reserved
  859. REG_DWORD, // flag for value type
  860. (CONST BYTE*)&dwTypes, // address of value data
  861. sizeof(DWORD) // size of value data
  862. );
  863. ::RegCloseKey(hKey);
  864. }
  866. // Add the service to the "Sources" value
  868. lRet = ::RegOpenKeyEx( 
  869. HKEY_LOCAL_MACHINE, // handle of open key 
  870. gszAppRegKey, // address of name of subkey to open 
  871. 0, // reserved 
  872. KEY_ALL_ACCESS, // security access mask 
  873. &hKey // address of handle of open key 
  874. );
  875. if( lRet == ERROR_SUCCESS ) {
  876. DWORD dwSize;
  878. // retrieve the size of the needed value
  879. lRet = ::RegQueryValueEx(
  880. hKey, // handle of key to query 
  881. TEXT("Sources"),// address of name of value to query 
  882. 0, // reserved 
  883. 0, // address of buffer for value type 
  884. 0, // address of data buffer 
  885. &dwSize // address of data buffer size 
  886. );
  888.   if( lRet == ERROR_SUCCESS ) {
  889. DWORD dwType;
  890. DWORD dwNewSize = dwSize+_tcslen(m_lpServiceName)+1;
  891. LPBYTE Buffer = LPBYTE(::GlobalAlloc(GPTR, dwNewSize));
  893. lRet = ::RegQueryValueEx(
  894. hKey, // handle of key to query 
  895. TEXT("Sources"),// address of name of value to query 
  896. 0, // reserved 
  897. &dwType, // address of buffer for value type 
  898. Buffer, // address of data buffer 
  899. &dwSize // address of data buffer size 
  900. );
  901. if( lRet == ERROR_SUCCESS ) {
  902. _ASSERTE(dwType == REG_MULTI_SZ);
  904. // check whether this service is already a known source
  905. register LPTSTR p = LPTSTR(Buffer);
  906. for(; *p; p += _tcslen(p)+1 ) {
  907. if( _tcscmp(p, m_lpServiceName) == 0 )
  908. break;
  909. }
  910. if( ! * p ) {
  911. // We're standing at the end of the stringarray
  912. // and the service does still not exist in the "Sources".
  913. // Now insert it at this point.
  914. // Note that we have already enough memory allocated
  915. // (see GlobalAlloc() above). We also don't need to append
  916. // an additional ''. This is done in GlobalAlloc() above
  917. // too.
  918. _tcscpy(p, m_lpServiceName);
  920. // OK - now store the modified value back into the
  921. // registry.
  922. lRet = ::RegSetValueEx(
  923. hKey, // handle of key to set value for
  924. TEXT("Sources"),// address of value to set
  925. 0, // reserved
  926. dwType, // flag for value type
  927. Buffer, // address of value data
  928. dwNewSize // size of value data
  929. );
  930. }
  931. }
  933. ::GlobalFree(HGLOBAL(Buffer));
  934. }
  936. ::RegCloseKey(hKey);
  937. }
  938. }
  941. void CNTService :: DeregisterApplicationLog() {
  942. TCHAR szKey[256];
  943. _tcscpy(szKey, gszAppRegKey);
  944. _tcscat(szKey, m_lpServiceName);
  945. HKEY hKey = 0;
  946. LONG lRet = ERROR_SUCCESS;
  948. lRet = ::RegDeleteKey(HKEY_LOCAL_MACHINE, szKey);
  950. // now we have to delete the application from the "Sources" value too.
  951. lRet = ::RegOpenKeyEx( 
  952. HKEY_LOCAL_MACHINE, // handle of open key 
  953. gszAppRegKey, // address of name of subkey to open 
  954. 0, // reserved 
  955. KEY_ALL_ACCESS, // security access mask 
  956. &hKey // address of handle of open key 
  957. );
  958. if( lRet == ERROR_SUCCESS ) {
  959. DWORD dwSize;
  961. // retrieve the size of the needed value
  962. lRet = ::RegQueryValueEx(
  963. hKey, // handle of key to query 
  964. TEXT("Sources"),// address of name of value to query 
  965. 0, // reserved 
  966. 0, // address of buffer for value type 
  967. 0, // address of data buffer 
  968. &dwSize // address of data buffer size 
  969. );
  971.   if( lRet == ERROR_SUCCESS ) {
  972. DWORD dwType;
  973. LPBYTE Buffer = LPBYTE(::GlobalAlloc(GPTR, dwSize));
  974. LPBYTE NewBuffer = LPBYTE(::GlobalAlloc(GPTR, dwSize));
  976. lRet = ::RegQueryValueEx(
  977. hKey, // handle of key to query 
  978. TEXT("Sources"),// address of name of value to query 
  979. 0, // reserved 
  980. &dwType, // address of buffer for value type 
  981. Buffer, // address of data buffer 
  982. &dwSize // address of data buffer size 
  983. );
  984. if( lRet == ERROR_SUCCESS ) {
  985. _ASSERTE(dwType == REG_MULTI_SZ);
  987. // check whether this service is already a known source
  988. register LPTSTR p = LPTSTR(Buffer);
  989. register LPTSTR pNew = LPTSTR(NewBuffer);
  990. BOOL bNeedSave = FALSE; // assume the value is already correct
  991. for(; *p; p += _tcslen(p)+1) {
  992. // except ourself: copy the source string into the destination
  993. if( _tcscmp(p, m_lpServiceName) != 0 ) {
  994. _tcscpy(pNew, p);
  995. pNew += _tcslen(pNew)+1;
  996. } else {
  997. bNeedSave = TRUE; // *this* application found
  998. dwSize -= _tcslen(p)+1; // new size of value
  999. }
  1000. }
  1001. if( bNeedSave ) {
  1002. // OK - now store the modified value back into the
  1003. // registry.
  1004. lRet = ::RegSetValueEx(
  1005. hKey, // handle of key to set value for
  1006. TEXT("Sources"),// address of value to set
  1007. 0, // reserved
  1008. dwType, // flag for value type
  1009. NewBuffer, // address of value data
  1010. dwSize // size of value data
  1011. );
  1012. }
  1013. }
  1015. ::GlobalFree(HGLOBAL(Buffer));
  1016. ::GlobalFree(HGLOBAL(NewBuffer));
  1017. }
  1019. ::RegCloseKey(hKey);
  1020. }
  1021. }
  1023. ////////////////////////////////////////////////////////
  1025. //!! TCW MOD - function to create console for faceless apps if not already there
  1026. void CNTService::SetupConsole() {
  1027. if( !m_fConsoleReady ) {
  1028. AllocConsole(); // you only get 1 console.
  1030. // lovely hack to get the standard io (printf, getc, etc) to the new console. Pretty much does what the
  1031. // C lib does for us, but when we want it, and inside of a Window'd app.
  1032. // The ugly look of this is due to the error checking (bad return values. Remove the if xxx checks if you like it that way.
  1033. DWORD astds[3]={STD_OUTPUT_HANDLE,STD_ERROR_HANDLE,STD_INPUT_HANDLE};
  1034. FILE *atrgs[3]={stdout,stderr,stdin};
  1035. for( register int i=0; i<3; i++ ) {
  1036. long hand=(long)GetStdHandle(astds[i]);
  1037. if( hand!=(long)INVALID_HANDLE_VALUE ) {
  1038. int osf=_open_osfhandle(hand,_O_TEXT);
  1039. if( osf!=-1 ) {
  1040. FILE *fp=_fdopen(osf,(astds[i]==STD_INPUT_HANDLE) ? "r" : "w");
  1041. if( fp!=NULL ) {
  1042. *(atrgs[i])=*fp;
  1043. setvbuf(fp,NULL,_IONBF,0);
  1044. }
  1045. }
  1046. }
  1047. }
  1048. m_fConsoleReady=TRUE;
  1049. }
  1050. }