winpcap/wpcap/libpcap/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 #define _WINSOCKAPI_
  37 #include "windows.h"
  38 #include <pcap.h>               // for PCAP_ERRBUF_SIZE
  39 #include "sockutils.h"  // for SOCK_ASSERT
  40 #include "fileconf.h"
  41
  42
  43 SERVICE_STATUS_HANDLE service_status_handle;
  44 SERVICE_STATUS service_status;
  45
  46
  47 void svc_geterr(char *str);
  48 void WINAPI svc_main(DWORD argc, char **argv);
  49
  50
  51
  52 int svc_start(void)
  53 {
  54         int rc;
  55         SERVICE_TABLE_ENTRY ste[] =
  56         {
  57                 { PROGRAM_NAME, svc_main },
  58                 { NULL, NULL }
  59         };
  60
  61         // This call is blocking. A new thread is created which will launch
  62         // the svc_main() function
  63         if ( (rc = StartServiceCtrlDispatcher(ste)) == 0)
  64                 svc_geterr("StartServiceCtrlDispatcher()");
  65
  66         return rc; // FALSE if this is not started as a service
  67 }
  68
  69
  70 void svc_geterr(char *str)
  71 {
  72 char message[PCAP_ERRBUF_SIZE];
  73 char string[PCAP_ERRBUF_SIZE];
  74 int val;
  75
  76         val= GetLastError();
  77         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |
  78                                   FORMAT_MESSAGE_MAX_WIDTH_MASK,
  79                                   NULL, val, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  80                                   (LPSTR) string, PCAP_ERRBUF_SIZE, NULL);
  81
  82         snprintf(message, PCAP_ERRBUF_SIZE, "%s failed with error %d: %s", str, val, string);
  83
  84         SOCK_ASSERT(message, 1);
  85 }
  86
  87
  88
  89 void WINAPI svc_control_handler(DWORD Opcode)
  90 {
  91         service_status.dwWin32ExitCode= 0;
  92         service_status.dwCheckPoint= 0;
  93         service_status.dwWaitHint= 0;
  94
  95         switch(Opcode)
  96         {
  97                 case SERVICE_CONTROL_STOP:
  98                         service_status.dwCurrentState= SERVICE_STOPPED;
  99
 100                         /*
 101                                 Uses ABORT to clean up the service. To be really honest, only the main socket and
 102                                 such these stuffs are cleared; however the thread which are running are not stopped.
 103                                 This can be seen by placing a breakpoint at the end of svc_main(), in which you will
 104                                 see that is never reached. However, as soon as you set the service status to "stopped",
 105                                 the StartServiceCtrlDispatcher() returns and the main thread ends. Then, Win32 has a good
 106                                 authomatic cleanup, so that all the threads which are still running are stopped
 107                                 when the main thread ends.
 108                         */
 109                         raise(SIGABRT);
 110
 111                         SetServiceStatus(service_status_handle, &service_status);
 112                         break;
 113
 114                 /*
 115                         Pause and Continue have an usual meaning and they are used just to be able
 116                         to change the running parameters at run-time. In other words, they act
 117                         like the SIGHUP signal on UNIX. All the running threads continue to run and
 118                         they are not paused at all.
 119                         Particularly,
 120                         - PAUSE does nothing
 121                         - CONTINUE re-reads the configuration file and creates the new threads that
 122                         can be needed according to the new configuration.
 123                 */
 124                 case SERVICE_CONTROL_PAUSE:
 125                         service_status.dwCurrentState= SERVICE_PAUSED;
 126                         SetServiceStatus(service_status_handle, &service_status);
 127                         break;
 128
 129                 case SERVICE_CONTROL_CONTINUE:
 130                         service_status.dwCurrentState= SERVICE_RUNNING;
 131                         SetServiceStatus(service_status_handle, &service_status);
 132                         fileconf_read(0);
 133                         break;
 134
 135                 case SERVICE_CONTROL_INTERROGATE:
 136                         // Fall through to send current status.
 137                         //      WARNING: not implemented
 138                         SetServiceStatus(service_status_handle, &service_status);
 139                         MessageBox(NULL, "Not implemented", "warning", MB_OK);
 140                         break;
 141         }
 142
 143         // Send current status.
 144         return;
 145 }
 146
 147
 148
 149 void WINAPI svc_main(DWORD argc, char **argv)
 150 {
 151         service_status_handle = RegisterServiceCtrlHandler(PROGRAM_NAME, svc_control_handler);
 152
 153         if (!service_status_handle)
 154                 return;
 155
 156         service_status.dwServiceType= SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
 157         service_status.dwCurrentState= SERVICE_RUNNING;
 158         service_status.dwControlsAccepted= SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;
 159         // | SERVICE_ACCEPT_SHUTDOWN ;
 160         service_status.dwWin32ExitCode= 0;
 161         service_status.dwServiceSpecificExitCode= 0;
 162         service_status.dwCheckPoint= 0;
 163         service_status.dwWaitHint= 0;
 164
 165         SetServiceStatus(service_status_handle, &service_status);
 166
 167         main_startup();
 168 }
 169
 170 /*
 171 sc create rpcapd DisplayName= "Remote Packet Capture Protocol v.0 (experimental)" binpath= "C:\cvsroot\winpcap\wpcap\PRJ\Debug\rpcapd -d -f rpcapd.ini"
 172 sc description rpcapd "Allows to capture traffic on this host from a remote machine."
 173 */