The Tcpdump Group git mirrors - libpcap/blob - rpcapd/win32-svc.c

   1 /*
   2  * Copyright (c) 2002 - 2003
   3  * NetGroup, Politecnico di Torino (Italy)
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  * notice, this list of conditions and the following disclaimer in the
  14  * documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the Politecnico di Torino nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  */
  32
  33
  34 #include "rpcapd.h"
  35 #include <signal.h>
  36 #include <pcap.h>               // for PCAP_ERRBUF_SIZE
  37 #include "sockutils.h"  // for SOCK_ASSERT
  38 #include "fileconf.h"
  39
  40 SERVICE_STATUS_HANDLE service_status_handle;
  41 SERVICE_STATUS service_status;
  42
  43 void svc_geterr(char *str);
  44 void WINAPI svc_main(DWORD argc, char **argv);
  45
  46 int svc_start(void)
  47 {
  48         int rc;
  49         SERVICE_TABLE_ENTRY ste[] =
  50         {
  51                 { PROGRAM_NAME, svc_main },
  52                 { NULL, NULL }
  53         };
  54
  55         // This call is blocking. A new thread is created which will launch
  56         // the svc_main() function
  57         if ( (rc = StartServiceCtrlDispatcher(ste)) == 0)
  58                 svc_geterr("StartServiceCtrlDispatcher()");
  59
  60         return rc; // FALSE if this is not started as a service
  61 }
  62
  63 void svc_geterr(char *str)
  64 {
  65         char message[PCAP_ERRBUF_SIZE];
  66         char string[PCAP_ERRBUF_SIZE];
  67         int val;
  68
  69         val = GetLastError();
  70         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |
  71                                   FORMAT_MESSAGE_MAX_WIDTH_MASK,
  72                                   NULL, val, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  73                                   (LPSTR) string, PCAP_ERRBUF_SIZE, NULL);
  74
  75         snprintf(message, PCAP_ERRBUF_SIZE, "%s failed with error %d: %s", str, val, string);
  76
  77         SOCK_ASSERT(message, 1);
  78 }
  79
  80 void WINAPI svc_control_handler(DWORD Opcode)
  81 {
  82         service_status.dwWin32ExitCode = 0;
  83         service_status.dwCheckPoint = 0;
  84         service_status.dwWaitHint = 0;
  85
  86         switch(Opcode)
  87         {
  88                 case SERVICE_CONTROL_STOP:
  89                         service_status.dwCurrentState = SERVICE_STOPPED;
  90
  91                         /*
  92                                 Uses ABORT to clean up the service. To be really honest, only the main socket and
  93                                 such these stuffs are cleared; however the thread which are running are not stopped.
  94                                 This can be seen by placing a breakpoint at the end of svc_main(), in which you will
  95                                 see that is never reached. However, as soon as you set the service status to "stopped",
  96                                 the StartServiceCtrlDispatcher() returns and the main thread ends. Then, Win32 has a good
  97                                 automatic cleanup, so that all the threads which are still running are stopped
  98                                 when the main thread ends.
  99                         */
 100                         raise(SIGABRT);
 101
 102                         SetServiceStatus(service_status_handle, &service_status);
 103                         break;
 104
 105                 /*
 106                         Pause and Continue have an usual meaning and they are used just to be able
 107                         to change the running parameters at run-time. In other words, they act
 108                         like the SIGHUP signal on UNIX. All the running threads continue to run and
 109                         they are not paused at all.
 110                         Particularly,
 111                         - PAUSE does nothing
 112                         - CONTINUE re-reads the configuration file and creates the new threads that
 113                         can be needed according to the new configuration.
 114                 */
 115                 case SERVICE_CONTROL_PAUSE:
 116                         service_status.dwCurrentState = SERVICE_PAUSED;
 117                         SetServiceStatus(service_status_handle, &service_status);
 118                         break;
 119
 120                 case SERVICE_CONTROL_CONTINUE:
 121                         service_status.dwCurrentState = SERVICE_RUNNING;
 122                         SetServiceStatus(service_status_handle, &service_status);
 123                         fileconf_read(0);
 124                         break;
 125
 126                 case SERVICE_CONTROL_INTERROGATE:
 127                         // Fall through to send current status.
 128                         //      WARNING: not implemented
 129                         SetServiceStatus(service_status_handle, &service_status);
 130                         MessageBox(NULL, "Not implemented", "warning", MB_OK);
 131                         break;
 132         }
 133
 134         // Send current status.
 135         return;
 136 }
 137
 138 void WINAPI svc_main(DWORD argc, char **argv)
 139 {
 140         service_status_handle = RegisterServiceCtrlHandler(PROGRAM_NAME, svc_control_handler);
 141
 142         if (!service_status_handle)
 143                 return;
 144
 145         service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
 146         service_status.dwCurrentState = SERVICE_RUNNING;
 147         service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;
 148         // | SERVICE_ACCEPT_SHUTDOWN ;
 149         service_status.dwWin32ExitCode = 0;
 150         service_status.dwServiceSpecificExitCode = 0;
 151         service_status.dwCheckPoint = 0;
 152         service_status.dwWaitHint = 0;
 153
 154         SetServiceStatus(service_status_handle, &service_status);
 155
 156         main_startup();
 157 }
 158
 159 /*
 160 sc create rpcapd DisplayName= "Remote Packet Capture Protocol v.0 (experimental)" binpath= "C:\cvsroot\winpcap\wpcap\PRJ\Debug\rpcapd -d -f rpcapd.ini"
 161 sc description rpcapd "Allows to capture traffic on this host from a remote machine."
 162 */