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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
|
// TS_Server_Handler.cpp
// $Id$
#define ACE_BUILD_SVC_DLL
#include "ace/SString.h"
#include "ace/Set.h"
#include "ace/Get_Opt.h"
#include "TS_Server_Handler.h"
int
ACE_TS_Server_Acceptor::parse_args (int argc, char *argv[])
{
ACE_TRACE ("ACE_TS_Server_Acceptor::parse_args");
this->service_port_ = ACE_DEFAULT_SERVER_PORT;
ACE_LOG_MSG->open ("Time Service");
ACE_Get_Opt get_opt (argc, argv, "p:", 0);
for (int c; (c = get_opt ()) != -1; )
{
switch (c)
{
case 'p':
this->service_port_ = ACE_OS::atoi (get_opt.optarg);
break;
default:
ACE_ERROR_RETURN ((LM_ERROR,
"%n:\n[-p server-port]\n%a", 1),
-1);
break;
}
}
this->service_addr_.set (this->service_port_);
return 0;
}
int
ACE_TS_Server_Acceptor::init (int argc, char *argv[])
{
ACE_TRACE ("ACE_TS_Server_Acceptor::init");
// Use the options hook to parse the command line arguments and set
// options.
this->parse_args (argc, argv);
// Set the acceptor endpoint into listen mode (use the Singleton
// global Reactor...).
if (this->open (this->service_addr_, ACE_Service_Config::reactor (),
0, 0, 0,
&this->scheduling_strategy_,
"Time Server", "ACE time service") == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%n: %p on port %d\n",
"acceptor::open failed",
this->service_addr_.get_port_number ()), -1);
// Register ourselves to receive SIGINT so we can shutdown
// gracefully.
if (this->reactor ()->register_handler (SIGINT, this) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%n: %p\n",
"register_handler (SIGINT)"), -1);
// Ignore SIGPIPE so that each <SVC_HANDLER> can handle this on its
// own.
ACE_Sig_Action sig ((ACE_SignalHandler) SIG_IGN, SIGPIPE);
ACE_UNUSED_ARG (sig);
ACE_INET_Addr server_addr;
// Figure out what port we're really bound to.
if (this->acceptor ().get_local_addr (server_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_local_addr"), -1);
ACE_DEBUG ((LM_DEBUG,
"starting up Time Server at port %d on handle %d\n",
server_addr.get_port_number (),
this->acceptor ().get_handle ()));
return 0;
}
// The following is a "Factory" used by the ACE_Service_Config and
// svc.conf file to dynamically initialize the state of the Time Server
ACE_SVC_FACTORY_DEFINE (ACE_TS_Server_Acceptor)
// Default constructor.
ACE_TS_Server_Handler::ACE_TS_Server_Handler (ACE_Thread_Manager *tm)
: ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> (tm)
{
ACE_TRACE ("ACE_TS_Server_Handler::ACE_TS_Server_Handler");
}
// Activate this instance of the ACE_TS_Server_Handler (called by the
// ACE_TS_Server_Acceptor).
/* VIRTUAL */ int
ACE_TS_Server_Handler::open (void *)
{
ACE_TRACE ("ACE_TS_Server_Handler::open");
ACE_INET_Addr client_addr;
// Determine the address of the client and display it.
if (this->peer ().get_remote_addr (client_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_remote_addr"), -1);
ACE_DEBUG ((LM_DEBUG, "(%t) accepted connection from host %s on fd %d\n",
client_addr.get_host_name (), this->peer ().get_handle ()));
// Call down to our parent to register ourselves with the Reactor.
if (ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::open (0) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), -1);
return 0;
}
/* VIRTUAL */ int
ACE_TS_Server_Handler::send_request (ACE_Time_Request &request)
{
ACE_TRACE ("ACE_TS_Server_Handler::send_request");
void *buffer;
ssize_t length = request.encode (buffer);
if (length == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "encode failed"), -1);
// Transmit request via a blocking send.
if (this->peer ().send_n (buffer, length) != length)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send_n failed"), -1);
return 0;
}
// Give up waiting (e.g., when a timeout occurs or a client shuts down
// unexpectedly).
/* VIRTUAL */ int
ACE_TS_Server_Handler::abandon (void)
{
ACE_TRACE ("ACE_TS_Server_Handler::abandon");
// Note we are using the time field to report the errno in case of
// failure.
ACE_Time_Request rq (ACE_Time_Request::FAILURE, errno);
return this->send_request (rq);
}
// Enable clients to limit the amount of time they'll wait
/* VIRTUAL */ int
ACE_TS_Server_Handler::handle_timeout (const ACE_Time_Value &, const void *)
{
ACE_TRACE ("ACE_TS_Server_Handler::handle_timeout");
return this->abandon ();
}
// Return the underlying ACE_HANDLE.
/* VIRTUAL */ ACE_HANDLE
ACE_TS_Server_Handler::get_handle (void) const
{
ACE_TRACE ("ACE_TS_Server_Handler::get_handle");
return this->peer ().get_handle ();
}
// Dispatch the appropriate operation to handle the client request.
/* VIRTUAL */ int
ACE_TS_Server_Handler::dispatch (void)
{
ACE_TRACE ("ACE_TS_Server_Handler::dispatch");
// Get the system time and then create an ACE_Time_Request
time_t t = ACE_OS::time (0);
ACE_Time_Request rq (ACE_Time_Request::TIME_UPDATE, t);
return this->send_request (rq);
}
// Receive, frame, and decode the client's request. Note, this method
// should use non-blocking I/O.
/* VIRTUAL */ int
ACE_TS_Server_Handler::recv_request (void)
{
ACE_TRACE ("ACE_TS_Server_Handler::recv_request");
ssize_t bytes_expected = this->time_request_.size ();
// Since Time_Request messages are fixed size, read the entire
// message in one go.
ssize_t n = this->peer ().recv ((void *) &this->time_request_, bytes_expected);
if (n != bytes_expected)
{
switch (n)
{
case -1:
/* FALLTHROUGH */
ACE_DEBUG ((LM_DEBUG, "****************** recv_request returned -1\n"));
default:
ACE_ERROR ((LM_ERROR, "%p got %d bytes, expected %d bytes\n",
"recv failed", n, bytes_expected));
/* FALLTHROUGH */
case 0:
// We've shutdown unexpectedly, let's abandon the connection.
this->abandon ();
return -1;
/* NOTREACHED */
}
}
else
{
// Decode the request into host byte order.
if (this->time_request_.decode () == -1)
{
ACE_ERROR ((LM_ERROR, "%p\n", "decode failed"));
return this->abandon ();
}
}
return 0;
}
// Callback method invoked by the ACE_Reactor when events arrive from
// the client.
/* VIRTUAL */ int
ACE_TS_Server_Handler::handle_input (ACE_HANDLE)
{
ACE_TRACE ("ACE_TS_Server_Handler::handle_input");
if (this->recv_request () == -1)
return -1;
else
return this->dispatch ();
}
ACE_TS_Server_Handler::~ACE_TS_Server_Handler (void)
{
ACE_TRACE ("ACE_TS_Server_Handler::~ACE_TS_Server_Handler");
ACE_DEBUG ((LM_DEBUG, "closing down Handle %d\n",
this->get_handle ()));
}
#if defined (ACE_TEMPLATES_REQUIRE_SPECIALIZATION)
template class ACE_Accept_Strategy<ACE_TS_Server_Handler, ACE_SOCK_ACCEPTOR>;
template class ACE_Acceptor<ACE_TS_Server_Handler, ACE_SOCK_ACCEPTOR>;
template class ACE_Concurrency_Strategy<ACE_TS_Server_Handler>;
template class ACE_Creation_Strategy<ACE_TS_Server_Handler>;
template class ACE_Message_Queue<ACE_NULL_SYNCH>;
template class ACE_Module<ACE_NULL_SYNCH>;
template class ACE_Schedule_All_Reactive_Strategy<ACE_TS_Server_Handler>;
template class ACE_Scheduling_Strategy<ACE_TS_Server_Handler>;
template class ACE_Strategy_Acceptor<ACE_TS_Server_Handler, ACE_SOCK_ACCEPTOR>;
template class ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
template class ACE_TSS<ACE_Dynamic>;
template class ACE_Task<ACE_NULL_SYNCH>;
template class ACE_Thru_Task<ACE_NULL_SYNCH>;
#endif /* ACE_TEMPLATES_REQUIRE_SPECIALIZATION */
|