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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
svcproc.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：48k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

svcproc.cxx：源码内容
  1. /*
  2.  * svcproc.cxx
  3.  *
  4.  * Service process implementation for Win95 and WinNT
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: svcproc.cxx,v $
  30.  * Revision 1.57  2000/05/02 03:16:46  robertj
  31.  * Added display of thread name in SystemLog, thanks Ashley Unitt.
  32.  *
  33.  * Revision 1.56  1999/09/13 13:15:08  robertj
  34.  * Changed PTRACE so will output to system log in PServiceProcess applications.
  35.  *
  36.  * Revision 1.55  1999/08/07 01:43:41  robertj
  37.  * Added "NoWin" option to prevent display of window in command line commands.
  38.  *
  39.  * Revision 1.54  1999/07/16 03:22:16  robertj
  40.  * Fixed tray icon version command so does not ask question.
  41.  *
  42.  * Revision 1.53  1999/06/14 07:59:39  robertj
  43.  * Enhanced tracing again to add options to trace output (timestamps etc).
  44.  *
  45.  * Revision 1.52  1999/04/21 01:57:09  robertj
  46.  * Added confirmation dialog to menu commands.
  47.  *
  48.  * Revision 1.51  1999/03/09 10:30:19  robertj
  49.  * Fixed ability to have PMEMORY_CHECK on/off on both debug/release versions.
  50.  *
  51.  * Revision 1.50  1999/02/16 08:08:07  robertj
  52.  * MSVC 6.0 compatibility changes.
  53.  *
  54.  * Revision 1.49  1999/01/29 12:20:19  robertj
  55.  * Changed service process to output trace info to the Win32 debug output.
  56.  *
  57.  * Revision 1.48  1998/12/04 10:10:45  robertj
  58.  * Added virtual for determining if process is a service. Fixes linkage problem.
  59.  *
  60.  * Revision 1.47  1998/11/30 04:50:17  robertj
  61.  * New directory structure
  62.  *
  63.  * Revision 1.46  1998/10/18 14:28:34  robertj
  64.  * Renamed argv/argc to eliminate accidental usage.
  65.  * Fixed strange problem withs etting debug window tabstops in optimised version.
  66.  *
  67.  * Revision 1.45  1998/10/13 14:14:09  robertj
  68.  * Added thread ID to log.
  69.  * Added heap debug display to service menus.
  70.  *
  71.  * Revision 1.44  1998/09/24 03:30:57  robertj
  72.  * Added open software license.
  73.  *
  74.  * Revision 1.43  1998/08/20 06:06:03  robertj
  75.  * Fixed bug where web page can be asked for when service not running.
  76.  *
  77.  * Revision 1.42  1998/05/21 04:29:44  robertj
  78.  * Fixed "Proxies stopped" dialog appearing when shutting down windows.
  79.  *
  80.  * Revision 1.41  1998/05/07 05:21:38  robertj
  81.  * Improved formatting of debug window, adding tabs and tab stops.
  82.  *
  83.  * Revision 1.40  1998/04/07 13:32:14  robertj
  84.  * Changed startup code to support PApplication class.
  85.  *
  86.  * Revision 1.39  1998/04/01 01:52:53  robertj
  87.  * Fixed problem with NoAutoDelete threads.
  88.  *
  89.  * Revision 1.38  1998/03/29 06:16:53  robertj
  90.  * Rearranged initialisation sequence so PProcess descendent constructors can do "things".
  91.  *
  92.  * Revision 1.37  1998/03/20 03:20:45  robertj
  93.  * Lined up debug output.
  94.  *
  95.  * Revision 1.36  1998/03/05 12:49:55  robertj
  96.  * MemCheck fixes.
  97.  *
  98.  * Revision 1.35  1998/02/20 23:01:10  robertj
  99.  * Fixed bug where application exits on log out in win95.
  100.  *
  101.  * Revision 1.34  1998/02/16 01:43:57  robertj
  102.  * Really fixed spurious error display on install/start/stop etc
  103.  *
  104.  * Revision 1.33  1998/02/16 00:12:22  robertj
  105.  * Added tray icon support.
  106.  * Fixed problem with services and directory paths with spaces in them.
  107.  *
  108.  * Revision 1.32  1998/02/03 06:16:31  robertj
  109.  * Added extra log levels.
  110.  * Fixed bug where window disappears after debug service termination.
  111.  *
  112.  * Revision 1.31  1998/01/26 00:56:11  robertj
  113.  * Changed ServiceProcess to exclusively use named event to detect running process.
  114.  *
  115.  * Revision 1.30  1997/12/18 05:05:45  robertj
  116.  * Added Edit menu.
  117.  *
  118.  * Revision 1.29  1997/11/04 06:01:45  robertj
  119.  * Fix of "service hung at startup" message for NT service.
  120.  *
  121.  * Revision 1.28  1997/10/30 10:17:10  robertj
  122.  * Fixed bug in detection of running service.
  123.  *
  124.  * Revision 1.27  1997/10/03 15:14:17  robertj
  125.  * Fixed crash on exit.
  126.  *
  127.  * Revision 1.26  1997/08/28 12:50:32  robertj
  128.  * Fixed race condition in cleaning up threads on application termination.
  129.  *
  130.  * Revision 1.25  1997/07/17 12:43:29  robertj
  131.  * Fixed bug for auto-start of service under '95.
  132.  *
  133.  * Revision 1.24  1997/07/14 11:47:20  robertj
  134.  * Added "const" to numerous variables.
  135.  *
  136.  * Revision 1.23  1997/07/08 13:00:30  robertj
  137.  * DLL support.
  138.  * Fixed '95 support so service runs without logging in.
  139.  *
  140.  * Revision 1.22  1997/04/27 05:50:27  robertj
  141.  * DLL support.
  142.  *
  143.  * Revision 1.21  1997/03/18 21:23:27  robertj
  144.  * Fix service manager falsely accusing app of crashing if OnStart() is slow.
  145.  *
  146.  * Revision 1.20  1997/02/05 11:50:40  robertj
  147.  * Changed current process function to return reference and validate objects descendancy.
  148.  * Changed log file name calculation to occur only once.
  149.  * Added some MSVC memory debugging functions.
  150.  *
  151.  * Revision 1.19  1996/12/05 11:53:49  craigs
  152.  * Fixed failure to output PError to debug window if CRLF pairs used
  153.  *
  154.  * Revision 1.18  1996/11/30 12:07:19  robertj
  155.  * Changed service creation for NT so is auto-start,
  156.  *
  157.  * Revision 1.17  1996/11/18 11:32:04  robertj
  158.  * Fixed bug in doing a "stop" command closing ALL instances of service.
  159.  *
  160.  * Revision 1.16  1996/11/12 10:15:16  robertj
  161.  * Fixed bug in NT 3.51 locking up when needs to output to window.
  162.  *
  163.  * Revision 1.15  1996/11/10 21:04:32  robertj
  164.  * Added category names to event log.
  165.  * Fixed menu enables for debug and command modes.
  166.  *
  167.  * Revision 1.14  1996/11/04 03:39:13  robertj
  168.  * Improved detection of running service so debug mode cannot run.
  169.  *
  170.  * Revision 1.13  1996/10/31 12:54:01  robertj
  171.  * Fixed bug in window not being displayed when command line used.
  172.  *
  173.  * Revision 1.12  1996/10/18 11:22:14  robertj
  174.  * Fixed problems with window not being shown under NT.
  175.  *
  176.  * Revision 1.11  1996/10/14 03:09:58  robertj
  177.  * Fixed major bug in debug outpuit locking up (infinite loop)
  178.  * Changed menus so cannot start service if in debug mode
  179.  *
  180.  * Revision 1.10  1996/10/08 13:04:43  robertj
  181.  * Rewrite to use standard window isntead of console window.
  182.  *
  183.  * Revision 1.9  1996/09/16 12:56:27  robertj
  184.  * DLL support
  185.  *
  186.  * Revision 1.8  1996/09/14 12:34:23  robertj
  187.  * Fixed problem with spontaneous exit from app under Win95.
  188.  *
  189.  * Revision 1.7  1996/08/19 13:36:03  robertj
  190.  * Added "Debug" level to system log.
  191.  *
  192.  * Revision 1.6  1996/07/30 12:23:32  robertj
  193.  * Added better service running test.
  194.  * Changed SIGINTR handler to just set termination event.
  195.  *
  196.  * Revision 1.5  1996/07/27 04:07:57  robertj
  197.  * Changed thread creation to use C library function instead of direct WIN32.
  198.  * Changed SystemLog to be stream based rather than printf based.
  199.  * Fixed Win95 support for service start/stop and prevent multiple starts.
  200.  *
  201.  * Revision 1.4  1996/06/10 09:54:08  robertj
  202.  * Fixed Win95 service install bug (typo!)
  203.  *
  204.  * Revision 1.3  1996/05/30 11:49:10  robertj
  205.  * Fixed crash on exit bug.
  206.  *
  207.  * Revision 1.2  1996/05/23 10:03:21  robertj
  208.  * Windows 95 support.
  209.  *
  210.  * Revision 1.1  1996/05/15 21:11:51  robertj
  211.  * Initial revision
  212.  *
  213.  */
  215. #include <ptlib.h>
  217. #include <winuser.h>
  218. #include <winnls.h>
  219. #include <shellapi.h>
  221. #include <process.h>
  222. #include <fstream.h>
  223. #include <signal.h>
  224. #include <fcntl.h>
  225. #include <io.h>
  227. #include <ptlib/svcproc.h>
  228. #include <ptlib/debstrm.h>
  231. #define UWM_SYSTRAY (WM_USER + 1)
  232. #define ICON_RESID 1
  233. #define SYSTRAY_ICON_ID 1
  235. static HINSTANCE hInstance;
  237. #define DATE_WIDTH    72
  238. #define THREAD_WIDTH  48
  239. #define LEVEL_WIDTH   32
  240. #define PROTO_WIDTH   40
  241. #define ACTION_WIDTH  48
  243. enum {
  244.   SvcCmdTray,
  245.   SvcCmdNoTray,
  246.   SvcCmdVersion,
  247.   SvcCmdInstall,
  248.   SvcCmdRemove,
  249.   SvcCmdStart,
  250.   SvcCmdStop,
  251.   SvcCmdPause,
  252.   SvcCmdResume,
  253.   SvcCmdDeinstall,
  254.   NumSvcCmds
  255. };
  257. static const char * const ServiceCommandNames[NumSvcCmds] = {
  258.   "Tray",
  259.   "NoTray",
  260.   "Version",
  261.   "Install",
  262.   "Remove",
  263.   "Start",
  264.   "Stop",
  265.   "Pause",
  266.   "Resume",
  267.   "Deinstall"
  268. };
  271. class PNotifyIconData : public NOTIFYICONDATA {
  272.   public:
  273.     PNotifyIconData(HWND hWnd, UINT flags, const char * tip = NULL);
  274.     void Add()    { Shell_NotifyIcon(NIM_ADD,    this); }
  275.     void Delete() { Shell_NotifyIcon(NIM_DELETE, this); }
  276.     void Modify() { Shell_NotifyIcon(NIM_MODIFY, this); }
  277. };
  280. PNotifyIconData::PNotifyIconData(HWND window, UINT flags, const char * tip)
  281. {
  282.   cbSize = sizeof(NOTIFYICONDATA);
  283.   hWnd   = window;
  284.   uID    = SYSTRAY_ICON_ID;
  285.   uFlags = flags;
  286.   if (tip != NULL) {
  287.     strncpy(szTip, tip, sizeof(szTip)-1);
  288.     szTip[sizeof(szTip)-1] = '';
  289.     uFlags |= NIF_TIP;
  290.   }
  291. }
  294. enum TrayIconRegistryCommand {
  295.   AddTrayIcon,
  296.   DelTrayIcon,
  297.   CheckTrayIcon
  298. };
  300. static BOOL TrayIconRegistry(PServiceProcess * svc, TrayIconRegistryCommand cmd)
  301. {
  302.   HKEY key;
  303.   if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  304.                    "SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
  305.                    0, KEY_ALL_ACCESS, &key) != ERROR_SUCCESS)
  306.     return FALSE;
  308.   DWORD err = 1;
  309.   DWORD type;
  310.   DWORD len;
  311.   PString str;
  312.   switch (cmd) {
  313.     case CheckTrayIcon :
  314.       err = RegQueryValueEx(key, svc->GetName(), 0, &type, NULL, &len);
  315.       break;
  317.     case AddTrayIcon :
  318.       str = """ + svc->GetFile() + "" Tray";
  319.       err = RegSetValueEx(key, svc->GetName(), 0, REG_SZ,
  320.                          (LPBYTE)(const char *)str, str.GetLength() + 1);
  321.       break;
  323.     case DelTrayIcon :
  324.       err = RegDeleteValue(key, (char *)(const char *)svc->GetName());
  325.   }
  327.   RegCloseKey(key);
  328.   return err == ERROR_SUCCESS;
  329. }
  333. ///////////////////////////////////////////////////////////////////////////////
  334. // PSystemLog
  336. static PString CreateLogFileName(const PString & processName)
  337. {
  338.   PString dir;
  339.   GetWindowsDirectory(dir.GetPointer(256), 255);
  340.   return dir + "\" + processName + " Log.TXT";
  341. }
  343. void PSystemLog::Output(Level level, const char * msg)
  344. {
  345.   PServiceProcess & process = PServiceProcess::Current();
  346.   if (level > process.GetLogLevel())
  347.     return;
  349.   DWORD err = ::GetLastError();
  351.   if (process.isWin95 || process.debugWindow != NULL) {
  352.     static HANDLE mutex = CreateMutex(NULL, FALSE, NULL);
  353.     WaitForSingleObject(mutex, INFINITE);
  355.     ostream * out;
  356.     if (process.debugWindow != NULL)
  357.       out = new PStringStream;
  358.     else {
  359.       static PString logFileName = CreateLogFileName(process.GetName());
  360.       out = new ofstream(logFileName, ios::app);
  361.     }
  363.     static const char * const levelName[NumLogLevels+1] = {
  364.       "Message",
  365.       "Fatal error",
  366.       "Error",
  367.       "Warning",
  368.       "Info",
  369.       "Debug1",
  370.       "Debug2",
  371.       "Debug3"
  372.     };
  373.     PTime now;
  374.     *out << now.AsString("yyyy/MM/dd hh:mm:sst");
  375.     PString threadName = PThread::Current()->GetThreadName();
  376.     if (!threadName)
  377.       *out << setw(15) << threadName.Left(15);
  378.     else
  379.       *out << (void *)PThread::Current();
  380.     *out << 't'
  381.          << levelName[level+1] << 't' << msg;
  382.     if (level < Info && err != 0)
  383.       *out << " - error = " << err << endl;
  384.     else if (msg[0] == '' || msg[strlen(msg)-1] != 'n')
  385.       *out << endl;
  387.     process.DebugOutput(*(PStringStream*)out);
  389.     delete out;
  390.     ReleaseMutex(mutex);
  391.     SetLastError(0);
  392.   }
  393.   else {
  394.     // Use event logging to log the error.
  395.     HANDLE hEventSource = RegisterEventSource(NULL, process.GetName());
  396.     if (hEventSource == NULL)
  397.       return;
  399.     char errbuf[25];
  400.     if (level > StdError && level < Info && err != 0)
  401.       ::sprintf(errbuf, "nError code = %d", err);
  402.     else
  403.       errbuf[0] = '';
  405.     LPCTSTR strings[3];
  406.     strings[0] = msg;
  407.     strings[1] = errbuf;
  408.     strings[2] = level != Fatal ? "" : " Program aborted.";
  410.     static const WORD levelType[NumLogLevels+1] = {
  411.       EVENTLOG_INFORMATION_TYPE,
  412.       EVENTLOG_ERROR_TYPE,
  413.       EVENTLOG_ERROR_TYPE,
  414.       EVENTLOG_WARNING_TYPE,
  415.       EVENTLOG_INFORMATION_TYPE,
  416.       EVENTLOG_INFORMATION_TYPE,
  417.       EVENTLOG_INFORMATION_TYPE,
  418.       EVENTLOG_INFORMATION_TYPE
  419.     };
  420.     ReportEvent(hEventSource, // handle of event source
  421.                 levelType[level+1],   // event type
  422.                 (WORD)(level+1),      // event category
  423.                 0x1000,               // event ID
  424.                 NULL,                 // current user's SID
  425.                 PARRAYSIZE(strings),  // number of strings
  426.                 0,                    // no bytes of raw data
  427.                 strings,              // array of error strings
  428.                 NULL);                // no raw data
  429.     DeregisterEventSource(hEventSource);
  430.   }
  431. }
  434. int PSystemLog::Buffer::overflow(int c)
  435. {
  436.   if (pptr() >= epptr()) {
  437.     int ppos = pptr() - pbase();
  438.     char * newptr = string.GetPointer(string.GetSize() + 10);
  439.     setp(newptr, newptr + string.GetSize() - 1);
  440.     pbump(ppos);
  441.   }
  442.   if (c != EOF) {
  443.     *pptr() = (char)c;
  444.     pbump(1);
  445.   }
  446.   return 0;
  447. }
  450. int PSystemLog::Buffer::underflow()
  451. {
  452.   return EOF;
  453. }
  456. int PSystemLog::Buffer::sync()
  457. {
  458.   PSystemLog::Output(log->logLevel, string);
  460.   string.SetSize(10);
  461.   char * base = string.GetPointer();
  462.   *base = '';
  463.   setp(base, base + string.GetSize() - 1);
  464.   return 0;
  465. }
  468. ///////////////////////////////////////////////////////////////////////////////
  469. // PServiceProcess
  471. PServiceProcess::PServiceProcess(const char * manuf, const char * name,
  472.                            WORD major, WORD minor, CodeStatus stat, WORD build)
  473.   : PProcess(manuf, name, major, minor, stat, build)
  474. {
  475.   controlWindow = debugWindow = NULL;
  476.   currentLogLevel = PSystemLog::Warning;
  477. }
  480. PServiceProcess & PServiceProcess::Current()
  481. {
  482.   PServiceProcess & process = (PServiceProcess &)PProcess::Current();
  483.   PAssert(process.IsDescendant(PServiceProcess::Class()), "Not a service!");
  484.   return process;
  485. }
  488. BOOL PServiceProcess::IsServiceProcess() const
  489. {
  490.   return TRUE;
  491. }
  494. static BOOL IsServiceRunning(PServiceProcess * svc)
  495. {
  496.   HANDLE hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, svc->GetName());
  497.   if (hEvent == NULL)
  498.     return ::GetLastError() == ERROR_ACCESS_DENIED;
  500.   CloseHandle(hEvent);
  501.   return TRUE;
  502. }
  505. int PServiceProcess::_main(void * arg)
  506. {
  507. #if PMEMORY_CHECK
  508.   PMemoryHeap::SetIgnoreAllocations(TRUE);
  509. #endif
  510.   PSetErrorStream(new PSystemLog(PSystemLog::StdError));
  511.   PTrace::SetStream(new PSystemLog(PSystemLog::Debug3));
  512.   PTrace::ClearOptions(PTrace::FileAndLine);
  513.   PTrace::SetOptions(PTrace::SystemLogStream);
  514.   PTrace::SetLevel(4);
  515. #if PMEMORY_CHECK
  516.   PMemoryHeap::SetIgnoreAllocations(FALSE);
  517. #endif
  519.   hInstance = (HINSTANCE)arg;
  521.   isWin95 = GetOSName() == "95";
  522.   debugMode = arguments.GetCount() > 0 && stricmp(arguments[0], "Debug") == 0;
  523.   currentLogLevel = debugMode ? PSystemLog::Info : PSystemLog::Warning;
  525.   if (!debugMode && arguments.GetCount() > 0) {
  526.     if (stricmp(arguments[0], "NoWin") == 0)
  527.       arguments.Shift(1);
  528.     else {
  529.       if (!CreateControlWindow(TRUE))
  530.         return 1;
  531.     }
  533.     for (PINDEX a = 0; a < arguments.GetCount(); a++)
  534.       ProcessCommand(arguments[a]);
  536.     if (controlWindow == NULL)
  537.       return GetTerminationValue();
  539.     if (debugWindow != NULL && debugWindow != (HWND)-1) {
  540.       ::SetLastError(0);
  541.       PError << "Close window or select another command from the Control menu.n" << endl;
  542.     }
  544.     MSG msg;
  545.     while (GetMessage(&msg, NULL, 0, 0) != 0) {
  546.       TranslateMessage(&msg);
  547.       DispatchMessage(&msg);
  548.     }
  550.     return GetTerminationValue();
  551.   }
  553.   if (!debugMode && !isWin95) {
  554.     static SERVICE_TABLE_ENTRY dispatchTable[] = {
  555.       { "", PServiceProcess::StaticMainEntry },
  556.       { NULL, NULL }
  557.     };
  558.     dispatchTable[0].lpServiceName = (char *)(const char *)GetName();
  560.     if (StartServiceCtrlDispatcher(dispatchTable))
  561.       return GetTerminationValue();
  563.     PSystemLog::Output(PSystemLog::Fatal, "StartServiceCtrlDispatcher failed.");
  564.     MessageBox(NULL, "Not run as a service!", GetName(), MB_TASKMODAL);
  565.     return 1;
  566.   }
  568.   if (!CreateControlWindow(debugMode))
  569.     return 1;
  571.   if (IsServiceRunning(this)) {
  572.     MessageBox(NULL, "Service already running", GetName(), MB_TASKMODAL);
  573.     return 3;
  574.   }
  576.   if (debugMode) {
  577.     ::SetLastError(0);
  578.     PError << "Service simulation started for "" << GetName() << "".n"
  579.               "Close window to terminate.n" << endl;
  580.   }
  582.   terminationEvent = CreateEvent(NULL, TRUE, FALSE, GetName());
  583.   PAssertOS(terminationEvent != NULL);
  585.   threadHandle = (HANDLE)_beginthread(StaticThreadEntry, 0, this);
  586.   PAssertOS(threadHandle != (HANDLE)-1);
  588.   SetTerminationValue(0);
  590.   MSG msg;
  591.   msg.message = WM_QUIT+1; //Want somethingthat is not WM_QUIT
  592.   do {
  593.     switch (MsgWaitForMultipleObjects(1, &terminationEvent,
  594.                                       FALSE, INFINITE, QS_ALLINPUT)) {
  595.       case WAIT_OBJECT_0+1 :
  596.         while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  597.           if (msg.message != WM_QUIT) {
  598.             TranslateMessage(&msg);
  599.             DispatchMessage(&msg);
  600.           }
  601.         }
  602.         break;
  604.       default :
  605.         // This is a work around for '95 coming up with an erroneous error
  606.         if (::GetLastError() == ERROR_INVALID_HANDLE &&
  607.                           WaitForSingleObject(terminationEvent, 0) == WAIT_TIMEOUT)
  608.           break;
  609.         // Else fall into next case
  611.       case WAIT_OBJECT_0 :
  612.         if (!debugMode || controlWindow == NULL)
  613.           msg.message = WM_QUIT;
  614.         else {
  615.           PError << "nService simulation stopped for "" << GetName() << "".nn"
  616.                     "Close window to terminate.n" << endl;
  617.           ResetEvent(terminationEvent);
  618.         }
  619.     }
  620.   } while (msg.message != WM_QUIT);
  622.   if (controlWindow != NULL)
  623.     DestroyWindow(controlWindow);
  625.   // Set thread ID for process to this thread
  626.   activeThreadMutex.Wait();
  627.   activeThreads.SetAt(threadId, NULL);
  628.   threadId = GetCurrentThreadId();
  629.   threadHandle = GetCurrentThread();
  630.   activeThreads.SetAt(threadId, this);
  631.   activeThreadMutex.Signal();
  632.   OnStop();
  634.   return GetTerminationValue();
  635. }
  638. enum {
  639.   ExitMenuID = 100,
  640.   HideMenuID,
  641.   ControlMenuID,
  642.   CopyMenuID,
  643.   CutMenuID,
  644.   DeleteMenuID,
  645.   SelectAllMenuID,
  646. #ifdef _DEBUG
  647.   MarkMenuID,
  648.   DumpMenuID,
  649.   StatsMenuID,
  650. #endif
  651.   SvcCmdBaseMenuID = 1000,
  652.   LogLevelBaseMenuID = 2000
  653. };
  655. BOOL PServiceProcess::CreateControlWindow(BOOL createDebugWindow)
  656. {
  657.   if (controlWindow != NULL)
  658.     return TRUE;
  660.   WNDCLASS wclass;
  661.   wclass.style = CS_HREDRAW|CS_VREDRAW;
  662.   wclass.lpfnWndProc = (WNDPROC)StaticWndProc;
  663.   wclass.cbClsExtra = 0;
  664.   wclass.cbWndExtra = 0;
  665.   wclass.hInstance = hInstance;
  666.   wclass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(ICON_RESID));
  667.   wclass.hCursor = NULL;
  668.   wclass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  669.   wclass.lpszMenuName = NULL;
  670.   wclass.lpszClassName = GetName();
  671.   if (RegisterClass(&wclass) == 0)
  672.     return FALSE;
  674.   HMENU menubar = CreateMenu();
  675.   HMENU menu = CreatePopupMenu();
  676.   AppendMenu(menu, MF_STRING, ControlMenuID, "&Control");
  677.   AppendMenu(menu, MF_STRING, HideMenuID, "&Hide");
  678.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdVersion, "&Version");
  679.   AppendMenu(menu, MF_SEPARATOR, 0, NULL);
  680. #ifdef _DEBUG
  681.   AppendMenu(menu, MF_STRING, MarkMenuID, "&Mark Memory");
  682.   AppendMenu(menu, MF_STRING, DumpMenuID, "&Dump Memory");
  683.   AppendMenu(menu, MF_STRING, StatsMenuID, "&Statistics");
  684.   AppendMenu(menu, MF_SEPARATOR, 0, NULL);
  685. #endif
  686.   AppendMenu(menu, MF_STRING, ExitMenuID, "E&xit");
  687.   AppendMenu(menubar, MF_POPUP, (UINT)menu, "&File");
  689.   menu = CreatePopupMenu();
  690.   AppendMenu(menu, MF_STRING, CopyMenuID, "&Copy");
  691.   AppendMenu(menu, MF_STRING, CutMenuID, "C&ut");
  692.   AppendMenu(menu, MF_STRING, DeleteMenuID, "&Delete");
  693.   AppendMenu(menu, MF_SEPARATOR, 0, NULL);
  694.   AppendMenu(menu, MF_STRING, SelectAllMenuID, "&Select All");
  695.   AppendMenu(menubar, MF_POPUP, (UINT)menu, "&Edit");
  697.   menu = CreatePopupMenu();
  698.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdInstall, "&Install");
  699.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdRemove, "&Remove");
  700.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdDeinstall, "&Deinstall");
  701.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdStart, "&Start");
  702.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdStop, "S&top");
  703.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdPause, "&Pause");
  704.   AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdResume, "R&esume");
  705.   AppendMenu(menubar, MF_POPUP, (UINT)menu, "&Control");
  707.   menu = CreatePopupMenu();
  708.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Fatal,   "&Fatal Error");
  709.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Error,   "&Error");
  710.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Warning, "&Warning");
  711.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Info,    "&Information");
  712.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Debug,   "&Debug");
  713.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Debug2,  "Debug &2");
  714.   AppendMenu(menu, MF_STRING, LogLevelBaseMenuID+PSystemLog::Debug3,  "Debug &3");
  715.   AppendMenu(menubar, MF_POPUP, (UINT)menu, "&Log Level");
  717.   if (CreateWindow(GetName(),
  718.                    GetName(),
  719.                    WS_OVERLAPPEDWINDOW,
  720.                    CW_USEDEFAULT, CW_USEDEFAULT,
  721.                    CW_USEDEFAULT, CW_USEDEFAULT, 
  722.                    NULL,
  723.                    menubar,
  724.                    hInstance,
  725.                    NULL) == NULL)
  726.     return FALSE;
  728.   if (createDebugWindow && debugWindow == NULL) {
  729.     debugWindow = CreateWindow("edit",
  730.                                "",
  731.                                WS_CHILD|WS_HSCROLL|WS_VSCROLL|WS_VISIBLE|WS_BORDER|
  732.                                       ES_MULTILINE|ES_READONLY,
  733.                                0, 0, 0, 0,
  734.                                controlWindow,
  735.                                (HMENU)10,
  736.                                hInstance,
  737.                                NULL);
  738.     SendMessage(debugWindow, EM_SETLIMITTEXT, isWin95 ? 32000 : 128000, 0);
  739.     DWORD TabStops[] = {
  740.       DATE_WIDTH,
  741.       DATE_WIDTH+THREAD_WIDTH,
  742.       DATE_WIDTH+THREAD_WIDTH+LEVEL_WIDTH,
  743.       DATE_WIDTH+THREAD_WIDTH+LEVEL_WIDTH+PROTO_WIDTH,
  744.       DATE_WIDTH+THREAD_WIDTH+LEVEL_WIDTH+PROTO_WIDTH+ACTION_WIDTH,
  745.       DATE_WIDTH+THREAD_WIDTH+LEVEL_WIDTH+PROTO_WIDTH+ACTION_WIDTH+32  // Standard tab width
  746.     };
  747.     SendMessage(debugWindow, EM_SETTABSTOPS, PARRAYSIZE(TabStops), (LPARAM)(LPDWORD)TabStops);
  748.   }
  750.   return TRUE;
  751. }
  754. LPARAM WINAPI PServiceProcess::StaticWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  755. {
  756.   return Current().WndProc(hWnd, msg, wParam, lParam);
  757. }
  760. LPARAM PServiceProcess::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  761. {
  762. #ifdef _DEBUG
  763.   static DWORD allocationNumber;
  764. #endif
  766.   switch (msg) {
  767.     case WM_CREATE :
  768.       controlWindow = hWnd;
  769.       break;
  771.     case WM_DESTROY :
  772.       if (debugWindow == (HWND)-1) {
  773.         PNotifyIconData nid(hWnd, NIF_TIP);
  774.         nid.Delete(); // This removes the systray icon
  775.       }
  777.       controlWindow = debugWindow = NULL;
  779.       PostQuitMessage(0);
  780.       break;
  782.     case WM_ENDSESSION :
  783.       if (wParam && (debugMode || lParam != ENDSESSION_LOGOFF) && debugWindow != (HWND)-1)
  784.         OnStop();
  785.       return 0;
  787.     case WM_SIZE :
  788.       if (debugWindow != NULL && debugWindow != (HWND)-1)
  789.         MoveWindow(debugWindow, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
  790.       break;
  792.     case WM_INITMENUPOPUP :
  793.     {
  794.       int enableItems = MF_BYCOMMAND|(debugMode ? MF_ENABLED : MF_GRAYED);
  795.       for (int i = PSystemLog::Fatal; i < PSystemLog::NumLogLevels; i++) {
  796.         CheckMenuItem((HMENU)wParam, LogLevelBaseMenuID+i, MF_BYCOMMAND|MF_UNCHECKED);
  797.         EnableMenuItem((HMENU)wParam, LogLevelBaseMenuID+i, enableItems);
  798.       }
  799.       CheckMenuItem((HMENU)wParam, LogLevelBaseMenuID+GetLogLevel(), MF_BYCOMMAND|MF_CHECKED);
  801.       enableItems = MF_BYCOMMAND|(debugMode ? MF_GRAYED : MF_ENABLED);
  802.       EnableMenuItem((HMENU)wParam, SvcCmdBaseMenuID+SvcCmdStart, enableItems);
  803.       EnableMenuItem((HMENU)wParam, SvcCmdBaseMenuID+SvcCmdStop, enableItems);
  804.       EnableMenuItem((HMENU)wParam, SvcCmdBaseMenuID+SvcCmdPause, enableItems);
  805.       EnableMenuItem((HMENU)wParam, SvcCmdBaseMenuID+SvcCmdResume, enableItems);
  807.       DWORD start, finish;
  808.       if (debugWindow != NULL && debugWindow != (HWND)-1)
  809.         SendMessage(debugWindow, EM_GETSEL, (WPARAM)&start, (LPARAM)&finish);
  810.       else
  811.         start = finish = 0;
  812.       enableItems = MF_BYCOMMAND|(start == finish ? MF_GRAYED : MF_ENABLED);
  813.       EnableMenuItem((HMENU)wParam, CopyMenuID, enableItems);
  814.       EnableMenuItem((HMENU)wParam, CutMenuID, enableItems);
  815.       EnableMenuItem((HMENU)wParam, DeleteMenuID, enableItems);
  817.       enableItems = MF_BYCOMMAND|(IsServiceRunning(this) ? MF_ENABLED : MF_GRAYED);
  818.       EnableMenuItem((HMENU)wParam, ControlMenuID, enableItems);
  819.       break;
  820.     }
  822.     case WM_COMMAND :
  823.       switch (wParam) {
  824.         case ExitMenuID :
  825.           DestroyWindow(hWnd);
  826.           break;
  828.         case ControlMenuID :
  829.           if (IsServiceRunning(this))
  830.             OnControl();
  831.           break;
  833.         case HideMenuID :
  834.           ShowWindow(hWnd, SW_HIDE);
  835.           break;
  837. #if PMEMORY_CHECK
  838.         case MarkMenuID :
  839.           allocationNumber = PMemoryHeap::GetAllocationRequest();
  840.           break;
  842.         case DumpMenuID :
  843.           PMemoryHeap::DumpObjectsSince(allocationNumber);
  844.           break;
  846.         case StatsMenuID :
  847.           PMemoryHeap::DumpStatistics();
  848.           break;
  849. #endif
  851.         case CopyMenuID :
  852.           if (debugWindow != NULL && debugWindow != (HWND)-1)
  853.             SendMessage(debugWindow, WM_COPY, 0, 0);
  854.           break;
  856.         case CutMenuID :
  857.           if (debugWindow != NULL && debugWindow != (HWND)-1)
  858.             SendMessage(debugWindow, WM_CUT, 0, 0);
  859.           break;
  861.         case DeleteMenuID :
  862.           if (debugWindow != NULL && debugWindow != (HWND)-1)
  863.             SendMessage(debugWindow, WM_CLEAR, 0, 0);
  864.           break;
  866.         case SelectAllMenuID :
  867.           if (debugWindow != NULL && debugWindow != (HWND)-1)
  868.             SendMessage(debugWindow, EM_SETSEL, 0, -1);
  869.           break;
  871.         default :
  872.           if (wParam >= LogLevelBaseMenuID+PSystemLog::Fatal && wParam < LogLevelBaseMenuID+PSystemLog::NumLogLevels)
  873.             SetLogLevel((PSystemLog::Level)(wParam-LogLevelBaseMenuID));
  874.           else if (wParam >= SvcCmdBaseMenuID && wParam < SvcCmdBaseMenuID+NumSvcCmds) {
  875.             const char * cmdname = ServiceCommandNames[wParam-SvcCmdBaseMenuID];
  876.             if (wParam == SvcCmdBaseMenuID+SvcCmdVersion ||
  877.                 MessageBox(hWnd, cmdname & GetName() & "?", GetName(),
  878.                            MB_ICONQUESTION|MB_YESNO) == IDYES)
  879.               ProcessCommand(cmdname);
  880.           }
  881.       }
  882.       break;
  884.     // Notification of event over sysTray icon
  885.     case UWM_SYSTRAY :
  886.       switch (lParam) {
  887.         case WM_MOUSEMOVE :
  888.           // update status of process for tool tips if no buttons down
  889.           if (wParam == SYSTRAY_ICON_ID) {
  890.             PNotifyIconData nid(hWnd, NIF_TIP,
  891.                           GetName() & (IsServiceRunning(this) ? "is" : "not") & "running.");
  892.             nid.Modify(); // Modify tooltip
  893.           }
  894.           break;
  896.         // Click on icon - display message
  897.         case WM_LBUTTONDBLCLK :
  898.           if (IsServiceRunning(this))
  899.             OnControl();
  900.           else {
  901.             SetForegroundWindow(hWnd); // Our MessageBox pops up in front
  902.             MessageBox(hWnd, "Service is not running!", GetName(), MB_TASKMODAL);
  903.           }
  904.           break;
  906.         // Popup menu
  907.         case WM_RBUTTONUP :
  908.           POINT pt;
  909.           GetCursorPos(&pt);
  911.           HMENU menu = CreatePopupMenu();
  912.           AppendMenu(menu, MF_STRING, ControlMenuID, "&Open Properties");
  913.           AppendMenu(menu, MF_SEPARATOR, 0, NULL);
  914.           AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdVersion, "&Version");
  915.           if (IsServiceRunning(this)) {
  916.             MENUITEMINFO inf;
  917.             inf.cbSize = sizeof(inf);
  918.             inf.fMask = MIIM_STATE;
  919.             inf.fState = MFS_DEFAULT;
  920.             SetMenuItemInfo(menu, ControlMenuID, FALSE, &inf);
  921.             AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdStop, "&Stop Service");
  922.           }
  923.           else {
  924.             EnableMenuItem(menu, ControlMenuID, MF_GRAYED);
  925.             AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdStart, "&Start Service");
  926.           }
  927.           AppendMenu(menu, MF_STRING, SvcCmdBaseMenuID+SvcCmdNoTray, "&Tray Icon");
  928.           CheckMenuItem(menu, SvcCmdBaseMenuID+SvcCmdNoTray,
  929.                         TrayIconRegistry(this, CheckTrayIcon) ? MF_CHECKED : MF_UNCHECKED);
  930.           AppendMenu(menu, MF_SEPARATOR, 0, NULL);
  931.           AppendMenu(menu, MF_STRING, ExitMenuID, "&Close");
  933.           /* SetForegroundWindow and the ensuing null PostMessage is a
  934.              workaround for a Windows 95 bug (see MSKB article Q135788,
  935.              http://www.microsoft.com/kb/articles/q135/7/88.htm, I think).
  936.              In typical Microsoft style this bug is listed as "by design".
  937.              SetForegroundWindow also causes our MessageBox to pop up in front
  938.              of any other application's windows. */
  939.           SetForegroundWindow(hWnd);
  941.           /* We specifiy TPM_RETURNCMD, so TrackPopupMenu returns the menu
  942.              selection instead of returning immediately and our getting a
  943.              WM_COMMAND with the selection. You don't have to do it this way.
  944.           */
  945.           WndProc(hWnd, WM_COMMAND, TrackPopupMenu(menu,            // Popup menu to track
  946.                                                    TPM_RETURNCMD |  // Return menu code
  947.                                                    TPM_RIGHTBUTTON, // Track right mouse button?
  948.                                                    pt.x, pt.y,      // screen coordinates
  949.                                                    0,               // reserved
  950.                                                    hWnd,            // owner
  951.                                                    NULL),           // LPRECT user can click in without dismissing menu
  952.                                                    0);
  953.           PostMessage(hWnd, 0, 0, 0); // see above
  954.           DestroyMenu(menu); // Delete loaded menu and reclaim its resources
  955.           break;
  956.       }
  957.   }
  959.   return DefWindowProc(hWnd, msg, wParam, lParam);
  960. }
  963. void PServiceProcess::DebugOutput(const char * out)
  964. {
  965.   if (controlWindow == NULL || debugWindow == NULL)
  966.     return;
  968.   if (debugWindow == (HWND)-1) {
  969.     MessageBox(controlWindow, out, GetName(), MB_TASKMODAL);
  970.     return;
  971.   }
  974.   if (!IsWindowVisible(controlWindow))
  975.     ShowWindow(controlWindow, SW_SHOWDEFAULT);
  977.   int len = strlen(out);
  978.   int max = isWin95 ? 32000 : 128000;
  979.   while (GetWindowTextLength(debugWindow)+len >= max) {
  980.     SendMessage(debugWindow, WM_SETREDRAW, FALSE, 0);
  981.     DWORD start, finish;
  982.     SendMessage(debugWindow, EM_GETSEL, (WPARAM)&start, (LPARAM)&finish);
  983.     SendMessage(debugWindow, EM_SETSEL, 0,
  984.                 SendMessage(debugWindow, EM_LINEINDEX, 1, 0));
  985.     SendMessage(debugWindow, EM_REPLACESEL, FALSE, (DWORD)"");
  986.     SendMessage(debugWindow, EM_SETSEL, start, finish);
  987.     SendMessage(debugWindow, WM_SETREDRAW, TRUE, 0);
  988.   }
  990.   SendMessage(debugWindow, EM_SETSEL, max, max);
  991.   char * lf;
  992.   const char * prev = out;
  993.   while ((lf = strchr(prev, 'n')) != NULL) {
  994.     if (*(lf-1) == 'r')
  995.       prev = lf+1;
  996.     else {
  997.       *lf++ = '';
  998.       SendMessage(debugWindow, EM_REPLACESEL, FALSE, (DWORD)out);
  999.       SendMessage(debugWindow, EM_REPLACESEL, FALSE, (DWORD)"rn");
  1000.       prev = out = lf;
  1001.     }
  1002.   }
  1003.   if (*out != '')
  1004.     SendMessage(debugWindow, EM_REPLACESEL, FALSE, (DWORD)out);
  1005. }
  1008. void PServiceProcess::StaticMainEntry(DWORD argc, LPTSTR * argv)
  1009. {
  1010.   Current().MainEntry(argc, argv);
  1011. }
  1014. void PServiceProcess::MainEntry(DWORD argc, LPTSTR * argv)
  1015. {
  1016.   // SERVICE_STATUS members that don't change
  1017.   status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
  1018.   status.dwServiceSpecificExitCode = 0;
  1020.   // register our service control handler:
  1021.   statusHandle = RegisterServiceCtrlHandler(GetName(), StaticControlEntry);
  1022.   if (statusHandle == NULL)
  1023.     return;
  1025.   // report the status to Service Control Manager.
  1026.   if (!ReportStatus(SERVICE_START_PENDING, NO_ERROR, 1, 20000))
  1027.     return;
  1029.   // create the stop event object. The control handler function signals
  1030.   // this event when it receives the "stop" control code.
  1031.   terminationEvent = CreateEvent(NULL, TRUE, FALSE, (const char *)GetName());
  1032.   if (terminationEvent == NULL)
  1033.     return;
  1035.   startedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  1036.   if (startedEvent == NULL)
  1037.     return;
  1039.   GetArguments().SetArgs(argc, argv);
  1041.   // start the thread that performs the work of the service.
  1042.   threadHandle = (HANDLE)_beginthread(StaticThreadEntry, 0, this);
  1043.   if (threadHandle != (HANDLE)-1) {
  1044.     while (WaitForSingleObject(startedEvent, 10000) == WAIT_TIMEOUT) {
  1045.       if (!ReportStatus(SERVICE_START_PENDING, NO_ERROR, 1, 20000))
  1046.         return;
  1047.     }
  1048.     // Wait here for the end
  1049.     WaitForSingleObject(terminationEvent, INFINITE);
  1050.   }
  1052.   CloseHandle(startedEvent);
  1053.   CloseHandle(terminationEvent);
  1054.   ReportStatus(SERVICE_STOPPED, 0);
  1055. }
  1058. void PServiceProcess::StaticThreadEntry(void * arg)
  1059. {
  1060.   ((PServiceProcess *)arg)->ThreadEntry();
  1061. }
  1064. void PServiceProcess::ThreadEntry()
  1065. {
  1066.   activeThreadMutex.Wait();
  1067.   threadId = GetCurrentThreadId();
  1068.   threadHandle = GetCurrentThread();
  1069.   activeThreads.SetAt(threadId, this);
  1070.   activeThreadMutex.Signal();
  1072.   SetTerminationValue(1);
  1073.   if (OnStart()) {
  1075.     if (!debugMode)
  1076.       SetEvent(startedEvent);
  1077.     ReportStatus(SERVICE_RUNNING);
  1078.     SetTerminationValue(0);
  1080.     Main();
  1082.     ReportStatus(SERVICE_STOP_PENDING, NO_ERROR, 1, 30000);
  1083.   }
  1085.   SetEvent(terminationEvent);
  1086. }
  1089. void PServiceProcess::StaticControlEntry(DWORD code)
  1090. {
  1091.   Current().ControlEntry(code);
  1092. }
  1095. void PServiceProcess::ControlEntry(DWORD code)
  1096. {
  1097.   switch (code) {
  1098.     case SERVICE_CONTROL_PAUSE : // Pause the service if it is running.
  1099.       if (status.dwCurrentState != SERVICE_RUNNING)
  1100.         ReportStatus(status.dwCurrentState);
  1101.       else {
  1102.         if (OnPause())
  1103.           ReportStatus(SERVICE_PAUSED);
  1104.       }
  1105.       break;
  1107.     case SERVICE_CONTROL_CONTINUE : // Resume the paused service.
  1108.       if (status.dwCurrentState == SERVICE_PAUSED)
  1109.         OnContinue();
  1110.       ReportStatus(status.dwCurrentState);
  1111.       break;
  1113.     case SERVICE_CONTROL_STOP : // Stop the service.
  1114.       // Report the status, specifying the checkpoint and waithint, before
  1115.       // setting the termination event.
  1116.       ReportStatus(SERVICE_STOP_PENDING, NO_ERROR, 1, 30000);
  1117.       OnStop();
  1118.       SetEvent(terminationEvent);
  1119.       break;
  1121.     case SERVICE_CONTROL_INTERROGATE : // Update the service status.
  1122.     default :
  1123.       ReportStatus(status.dwCurrentState);
  1124.   }
  1125. }
  1128. BOOL PServiceProcess::ReportStatus(DWORD dwCurrentState,
  1129.                                    DWORD dwWin32ExitCode,
  1130.                                    DWORD dwCheckPoint,
  1131.                                    DWORD dwWaitHint)
  1132. {
  1133.   // Disable control requests until the service is started.
  1134.   if (dwCurrentState == SERVICE_START_PENDING)
  1135.     status.dwControlsAccepted = 0;
  1136.   else
  1137.     status.dwControlsAccepted =
  1138.                            SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;
  1140.   // These SERVICE_STATUS members are set from parameters.
  1141.   status.dwCurrentState = dwCurrentState;
  1142.   status.dwWin32ExitCode = dwWin32ExitCode;
  1143.   status.dwCheckPoint = dwCheckPoint;
  1144.   status.dwWaitHint = dwWaitHint;
  1146.   if (debugMode || isWin95)
  1147.     return TRUE;
  1149.   // Report the status of the service to the service control manager.
  1150.   if (SetServiceStatus(statusHandle, &status))
  1151.     return TRUE;
  1153.   // If an error occurs, stop the service.
  1154.   PSystemLog::Output(PSystemLog::Error, "SetServiceStatus failed");
  1155.   return FALSE;
  1156. }
  1159. void PServiceProcess::OnStop()
  1160. {
  1161. }
  1164. BOOL PServiceProcess::OnPause()
  1165. {
  1166.   SuspendThread(threadHandle);
  1167.   return TRUE;
  1168. }
  1171. void PServiceProcess::OnContinue()
  1172. {
  1173.   ResumeThread(threadHandle);
  1174. }
  1177. void PServiceProcess::OnControl()
  1178. {
  1179. }
  1183. class ServiceManager
  1184. {
  1185.   public:
  1186.     ServiceManager()  { error = 0; }
  1188.     virtual BOOL Create(PServiceProcess * svc) = 0;
  1189.     virtual BOOL Delete(PServiceProcess * svc) = 0;
  1190.     virtual BOOL Start(PServiceProcess * svc) = 0;
  1191.     virtual BOOL Stop(PServiceProcess * svc) = 0;
  1192.     virtual BOOL Pause(PServiceProcess * svc) = 0;
  1193.     virtual BOOL Resume(PServiceProcess * svc) = 0;
  1195.     DWORD GetError() const { return error; }
  1197.   protected:
  1198.     DWORD error;
  1199. };
  1202. class Win95_ServiceManager : public ServiceManager
  1203. {
  1204.   public:
  1205.     virtual BOOL Create(PServiceProcess * svc);
  1206.     virtual BOOL Delete(PServiceProcess * svc);
  1207.     virtual BOOL Start(PServiceProcess * svc);
  1208.     virtual BOOL Stop(PServiceProcess * svc);
  1209.     virtual BOOL Pause(PServiceProcess * svc);
  1210.     virtual BOOL Resume(PServiceProcess * svc);
  1211. };
  1214. BOOL Win95_ServiceManager::Create(PServiceProcess * svc)
  1215. {
  1216.   HKEY key;
  1217.   if (RegCreateKey(HKEY_LOCAL_MACHINE,
  1218.                    "SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
  1219.                    &key) == ERROR_SUCCESS) {
  1220.     RegDeleteValue(key, (char *)(const char *)svc->GetName());
  1221.     RegCloseKey(key);
  1222.   }
  1224.   if ((error = RegCreateKey(HKEY_LOCAL_MACHINE,
  1225.                             "SOFTWARE\Microsoft\Windows\CurrentVersion\RunServices",
  1226.                             &key)) != ERROR_SUCCESS)
  1227.     return FALSE;
  1229.   PString cmd = """ + svc->GetFile() + """;
  1230.   error = RegSetValueEx(key, svc->GetName(), 0, REG_SZ,
  1231.                         (LPBYTE)(const char *)cmd, cmd.GetLength() + 1);
  1233.   RegCloseKey(key);
  1235.   return error == ERROR_SUCCESS;
  1236. }
  1239. BOOL Win95_ServiceManager::Delete(PServiceProcess * svc)
  1240. {
  1241.   HKEY key;
  1242.   if (RegCreateKey(HKEY_LOCAL_MACHINE,
  1243.                    "SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
  1244.                    &key) == ERROR_SUCCESS) {
  1245.     RegDeleteValue(key, (char *)(const char *)svc->GetName());
  1246.     RegCloseKey(key);
  1247.   }
  1249.   if ((error = RegCreateKey(HKEY_LOCAL_MACHINE,
  1250.                             "SOFTWARE\Microsoft\Windows\CurrentVersion\RunServices",
  1251.                             &key)) != ERROR_SUCCESS)
  1252.     return FALSE;
  1254.   error = RegDeleteValue(key, (char *)(const char *)svc->GetName());
  1256.   RegCloseKey(key);
  1258.   return error == ERROR_SUCCESS;
  1259. }
  1262. BOOL Win95_ServiceManager::Start(PServiceProcess * service)
  1263. {
  1264.   if (IsServiceRunning(service)) {
  1265.     PError << "Service already running" << endl;
  1266.     error = 1;
  1267.     return FALSE;
  1268.   }
  1270.   BOOL ok = _spawnl(_P_DETACH, service->GetFile(), service->GetFile(), NULL) >= 0;
  1271.   error = errno;
  1272.   return ok;
  1273. }
  1276. BOOL Win95_ServiceManager::Stop(PServiceProcess * service)
  1277. {
  1278.   HANDLE hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, service->GetName());
  1279.   if (hEvent == NULL) {
  1280.     error = ::GetLastError();
  1281.     PError << "Service is not running" << endl;
  1282.     return FALSE;
  1283.   }
  1285.   SetEvent(hEvent);
  1286.   CloseHandle(hEvent);
  1287.   return TRUE;
  1288. }
  1291. BOOL Win95_ServiceManager::Pause(PServiceProcess *)
  1292. {
  1293.   PError << "Cannot pause service under Windows 95" << endl;
  1294.   error = 1;
  1295.   return FALSE;
  1296. }
  1299. BOOL Win95_ServiceManager::Resume(PServiceProcess *)
  1300. {
  1301.   PError << "Cannot resume service under Windows 95" << endl;
  1302.   error = 1;
  1303.   return FALSE;
  1304. }
  1308. class NT_ServiceManager : public ServiceManager
  1309. {
  1310.   public:
  1311.     NT_ServiceManager()  { schSCManager = schService = NULL; }
  1312.     ~NT_ServiceManager();
  1314.     BOOL Create(PServiceProcess * svc);
  1315.     BOOL Delete(PServiceProcess * svc);
  1316.     BOOL Start(PServiceProcess * svc);
  1317.     BOOL Stop(PServiceProcess * svc)
  1318.       { return Control(svc, SERVICE_CONTROL_STOP); }
  1319.     BOOL Pause(PServiceProcess * svc)
  1320.       { return Control(svc, SERVICE_CONTROL_PAUSE); }
  1321.     BOOL Resume(PServiceProcess * svc)
  1322.       { return Control(svc, SERVICE_CONTROL_CONTINUE); }
  1324.     DWORD GetError() const { return error; }
  1326.   private:
  1327.     BOOL OpenManager();
  1328.     BOOL Open(PServiceProcess * svc);
  1329.     BOOL Control(PServiceProcess * svc, DWORD command);
  1331.     SC_HANDLE schSCManager, schService;
  1332. };
  1335. NT_ServiceManager::~NT_ServiceManager()
  1336. {
  1337.   if (schService != NULL)
  1338.     CloseServiceHandle(schService);
  1339.   if (schSCManager != NULL)
  1340.     CloseServiceHandle(schSCManager);
  1341. }
  1344. BOOL NT_ServiceManager::OpenManager()
  1345. {
  1346.   schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
  1347.   if (schSCManager != NULL)
  1348.     return TRUE;
  1350.   error = ::GetLastError();
  1351.   PError << "Could not open Service Manager." << endl;
  1352.   return FALSE;
  1353. }
  1356. BOOL NT_ServiceManager::Open(PServiceProcess * svc)
  1357. {
  1358.   if (!OpenManager())
  1359.     return FALSE;
  1361.   schService = OpenService(schSCManager, svc->GetName(), SERVICE_ALL_ACCESS);
  1362.   if (schService != NULL)
  1363.     return TRUE;
  1365.   error = ::GetLastError();
  1366.   PError << "Service is not installed." << endl;
  1367.   return FALSE;
  1368. }
  1371. BOOL NT_ServiceManager::Create(PServiceProcess * svc)
  1372. {
  1373.   if (!OpenManager())
  1374.     return FALSE;
  1376.   schService = OpenService(schSCManager, svc->GetName(), SERVICE_ALL_ACCESS);
  1377.   if (schService != NULL) {
  1378.     PError << "Service is already installed." << endl;
  1379.     return FALSE;
  1380.   }
  1382.   PString binaryFilename;
  1383.   GetShortPathName(svc->GetFile(), binaryFilename.GetPointer(_MAX_PATH), _MAX_PATH);
  1384.   schService = CreateService(
  1385.                     schSCManager,                   // SCManager database
  1386.                     svc->GetName(),                 // name of service
  1387.                     svc->GetName(),                 // name to display
  1388.                     SERVICE_ALL_ACCESS,             // desired access
  1389.                     SERVICE_WIN32_OWN_PROCESS,      // service type
  1390.                     SERVICE_AUTO_START,             // start type
  1391.                     SERVICE_ERROR_NORMAL,           // error control type
  1392.                     binaryFilename,                 // service's binary
  1393.                     NULL,                           // no load ordering group
  1394.                     NULL,                           // no tag identifier
  1395.                     svc->GetServiceDependencies(),  // no dependencies
  1396.                     NULL,                           // LocalSystem account
  1397.                     NULL);                          // no password
  1398.   if (schService == NULL) {
  1399.     error = ::GetLastError();
  1400.     return FALSE;
  1401.   }
  1403.   HKEY key;
  1404.   if ((error = RegCreateKey(HKEY_LOCAL_MACHINE,
  1405.              "SYSTEM\CurrentControlSet\Services\EventLog\Application\" +
  1406.                                        svc->GetName(), &key)) != ERROR_SUCCESS)
  1407.     return FALSE;
  1409.   LPBYTE fn = (LPBYTE)(const char *)binaryFilename;
  1410.   PINDEX fnlen = binaryFilename.GetLength()+1;
  1411.   if ((error = RegSetValueEx(key, "EventMessageFile",
  1412.                              0, REG_EXPAND_SZ, fn, fnlen)) == ERROR_SUCCESS &&
  1413.       (error = RegSetValueEx(key, "CategoryMessageFile",
  1414.                              0, REG_EXPAND_SZ, fn, fnlen)) == ERROR_SUCCESS) {
  1415.     DWORD dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
  1416.     if ((error = RegSetValueEx(key, "TypesSupported",
  1417.                                0, REG_DWORD, (LPBYTE)&dwData, sizeof(DWORD))) == ERROR_SUCCESS) {
  1418.       dwData = PSystemLog::NumLogLevels;
  1419.       error = RegSetValueEx(key, "CategoryCount", 0, REG_DWORD, (LPBYTE)&dwData, sizeof(DWORD));
  1420.     }
  1421.   }
  1423.   RegCloseKey(key);
  1425.   return error == ERROR_SUCCESS;
  1426. }
  1429. BOOL NT_ServiceManager::Delete(PServiceProcess * svc)
  1430. {
  1431.   if (!Open(svc))
  1432.     return FALSE;
  1434.   PString name = "SYSTEM\CurrentControlSet\Services\EventLog\Application\" + svc->GetName();
  1435.   error = ::RegDeleteKey(HKEY_LOCAL_MACHINE, (char *)(const char *)name);
  1437.   if (!::DeleteService(schService))
  1438.     error = ::GetLastError();
  1440.   return error == ERROR_SUCCESS;
  1441. }
  1444. BOOL NT_ServiceManager::Start(PServiceProcess * svc)
  1445. {
  1446.   if (!Open(svc))
  1447.     return FALSE;
  1449.   BOOL ok = ::StartService(schService, 0, NULL);
  1450.   error = ::GetLastError();
  1451.   return ok;
  1452. }
  1455. BOOL NT_ServiceManager::Control(PServiceProcess * svc, DWORD command)
  1456. {
  1457.   if (!Open(svc))
  1458.     return FALSE;
  1460.   SERVICE_STATUS status;
  1461.   BOOL ok = ::ControlService(schService, command, &status);
  1462.   error = ::GetLastError();
  1463.   return ok;
  1464. }
  1467. BOOL PServiceProcess::ProcessCommand(const char * cmd)
  1468. {
  1469.   PINDEX cmdNum = 0;
  1470.   while (stricmp(cmd, ServiceCommandNames[cmdNum]) != 0) {
  1471.     if (++cmdNum >= NumSvcCmds) {
  1472.       if (!CreateControlWindow(TRUE))
  1473.         return FALSE;
  1474.       if (*cmd != '')
  1475.         PError << "Unknown command "" << cmd << "".n";
  1476.       else
  1477.         PError << "Could not start service.n";
  1478.       PError << "usage: " << GetName() << " [ ";
  1479.       for (cmdNum = 0; cmdNum < NumSvcCmds-1; cmdNum++)
  1480.         PError << ServiceCommandNames[cmdNum] << " | ";
  1481.       PError << ServiceCommandNames[cmdNum] << " ]" << endl;
  1482.       return FALSE;
  1483.     }
  1484.   }
  1486.   NT_ServiceManager nt;
  1487.   Win95_ServiceManager win95;
  1489.   ServiceManager * svcManager;
  1490.   if (isWin95)
  1491.     svcManager = &win95;
  1492.   else
  1493.     svcManager = &nt;
  1495.   BOOL good = FALSE;
  1496.   switch (cmdNum) {
  1497.     case SvcCmdTray :
  1498.     {
  1499.       PNotifyIconData nid(controlWindow, NIF_MESSAGE|NIF_ICON, GetName());
  1500.       nid.hIcon = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(ICON_RESID), IMAGE_ICON, // 16x16 icon
  1501.                              GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0);
  1502.       nid.uCallbackMessage = UWM_SYSTRAY; // message sent to nid.hWnd
  1503.       nid.Add();    // This adds the icon
  1504.       debugWindow = (HWND)-1;
  1505.       return TRUE;
  1506.     }
  1508.     case SvcCmdNoTray :
  1509.       if (TrayIconRegistry(this, CheckTrayIcon)) {
  1510.         TrayIconRegistry(this, DelTrayIcon);
  1511.         PError << "Tray icon removed.";
  1512.       }
  1513.       else {
  1514.         TrayIconRegistry(this, AddTrayIcon);
  1515.         PError << "Tray icon installed.";
  1516.       }
  1517.       return TRUE;
  1519.     case SvcCmdVersion : // Version command
  1520.       ::SetLastError(0);
  1521.       PError << GetName() << ' '
  1522.              << GetOSClass() << '/' << GetOSName()
  1523.              << " Version " << GetVersion(TRUE) << endl;
  1524.       return TRUE;
  1526.     case SvcCmdInstall : // install
  1527.       good = svcManager->Create(this);
  1528.       TrayIconRegistry(this, AddTrayIcon);
  1529.       break;
  1531.     case SvcCmdRemove : // remove
  1532.       good = svcManager->Delete(this);
  1533.       TrayIconRegistry(this, DelTrayIcon);
  1534.       break;
  1536.     case SvcCmdStart : // start
  1537.       good = svcManager->Start(this);
  1538.       break;
  1540.     case SvcCmdStop : // stop
  1541.       good = svcManager->Stop(this);
  1542.       break;
  1544.     case SvcCmdPause : // pause
  1545.       good = svcManager->Pause(this);
  1546.       break;
  1548.     case SvcCmdResume : // resume
  1549.       good = svcManager->Resume(this);
  1550.       break;
  1552.     case SvcCmdDeinstall : // deinstall
  1553.       svcManager->Delete(this);
  1554.       TrayIconRegistry(this, DelTrayIcon);
  1555.       PConfig cfg;
  1556.       PStringList sections = cfg.GetSections();
  1557.       PINDEX i;
  1558.       for (i = 0; i < sections.GetSize(); i++)
  1559.         cfg.DeleteSection(sections[i]);
  1560.       good = TRUE;
  1561.       break;
  1562.   }
  1564.   SetLastError(0);
  1566.   PError << "Service command "" << ServiceCommandNames[cmdNum] << "" ";
  1567.   if (good)
  1568.     PError << "successful.";
  1569.   else {
  1570.     PError << "failed - ";
  1571.     switch (svcManager->GetError()) {
  1572.       case ERROR_ACCESS_DENIED :
  1573.         PError << "Access denied";
  1574.         break;
  1575.       default :
  1576.         PError << "error code = " << svcManager->GetError();
  1577.     }
  1578.   }
  1579.   PError << endl;
  1581.   return TRUE;
  1582. }
  1585. // End Of File ///////////////////////////////////////////////////////////////