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