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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
NTService.cpp
资源名称：TelnetView_server.zip　[点击查看]
上传用户：chenchao
上传日期：2007-01-09
资源大小：22k
文件大小：32k
源码类别：

Telnet服务器

开发平台：

Visual C++

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