00001
00002
00003 #include "ace/SOCK_Acceptor.h"
00004
00005 #include "ace/Log_Msg.h"
00006 #include "ace/OS_Errno.h"
00007 #include "ace/OS_NS_string.h"
00008 #include "ace/OS_NS_sys_socket.h"
00009 #include "ace/os_include/os_fcntl.h"
00010
00011 #if !defined (__ACE_INLINE__)
00012 #include "ace/SOCK_Acceptor.inl"
00013 #endif
00014
00015 #if !defined (ACE_HAS_WINCE)
00016 #include "ace/OS_QoS.h"
00017 #endif // ACE_HAS_WINCE
00018
00019 ACE_RCSID(ace, SOCK_Acceptor, "$Id: SOCK_Acceptor.cpp 79134 2007-07-31 18:23:50Z johnnyw $")
00020
00021 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00022
00023 ACE_ALLOC_HOOK_DEFINE(ACE_SOCK_Acceptor)
00024
00025
00026
00027 ACE_SOCK_Acceptor::ACE_SOCK_Acceptor (void)
00028 {
00029 ACE_TRACE ("ACE_SOCK_Acceptor::ACE_SOCK_Acceptor");
00030 }
00031
00032
00033
00034 int
00035 ACE_SOCK_Acceptor::shared_accept_start (ACE_Time_Value *timeout,
00036 int restart,
00037 int &in_blocking_mode) const
00038 {
00039 ACE_TRACE ("ACE_SOCK_Acceptor::shared_accept_start");
00040
00041 ACE_HANDLE handle = this->get_handle ();
00042
00043
00044 if (timeout != 0)
00045 {
00046 if (ACE::handle_timed_accept (handle,
00047 timeout,
00048 restart) == -1)
00049 return -1;
00050 else
00051 {
00052 in_blocking_mode = ACE_BIT_DISABLED (ACE::get_flags (handle),
00053 ACE_NONBLOCK);
00054
00055
00056 if (in_blocking_mode
00057 && ACE::set_flags (handle,
00058 ACE_NONBLOCK) == -1)
00059 return -1;
00060 }
00061 }
00062
00063 return 0;
00064 }
00065
00066 int
00067 ACE_SOCK_Acceptor::shared_accept_finish (ACE_SOCK_Stream new_stream,
00068 int in_blocking_mode,
00069 int reset_new_handle) const
00070 {
00071 ACE_TRACE ("ACE_SOCK_Acceptor::shared_accept_finish ()");
00072
00073 ACE_HANDLE new_handle = new_stream.get_handle ();
00074
00075
00076
00077
00078 if (in_blocking_mode)
00079 {
00080
00081 ACE_Errno_Guard error (errno);
00082
00083
00084
00085 ACE::clr_flags (this->get_handle (),
00086 ACE_NONBLOCK);
00087 ACE::clr_flags (new_handle,
00088 ACE_NONBLOCK);
00089 }
00090
00091 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
00092 if (reset_new_handle)
00093
00094 ::WSAEventSelect ((SOCKET) new_handle, 0, 0);
00095 #else
00096 ACE_UNUSED_ARG (reset_new_handle);
00097 #endif
00098
00099 return new_handle == ACE_INVALID_HANDLE ? -1 : 0;
00100 }
00101
00102
00103
00104 int
00105 ACE_SOCK_Acceptor::accept (ACE_SOCK_Stream &new_stream,
00106 ACE_Addr *remote_addr,
00107 ACE_Time_Value *timeout,
00108 int restart,
00109 int reset_new_handle) const
00110 {
00111 ACE_TRACE ("ACE_SOCK_Acceptor::accept");
00112
00113 int in_blocking_mode = 0;
00114 if (this->shared_accept_start (timeout,
00115 restart,
00116 in_blocking_mode) == -1)
00117 return -1;
00118 else
00119 {
00120
00121
00122 int *len_ptr = 0;
00123 sockaddr *addr = 0;
00124 int len = 0;
00125
00126 if (remote_addr != 0)
00127 {
00128 len = remote_addr->get_size ();
00129 len_ptr = &len;
00130 addr = (sockaddr *) remote_addr->get_addr ();
00131 }
00132
00133 do
00134 new_stream.set_handle (ACE_OS::accept (this->get_handle (),
00135 addr,
00136 len_ptr));
00137 while (new_stream.get_handle () == ACE_INVALID_HANDLE
00138 && restart != 0
00139 && errno == EINTR
00140 && timeout == 0);
00141
00142
00143
00144 if (new_stream.get_handle () != ACE_INVALID_HANDLE
00145 && remote_addr != 0)
00146 {
00147 remote_addr->set_size (len);
00148 if (addr)
00149 remote_addr->set_type (addr->sa_family);
00150 }
00151 }
00152
00153 return this->shared_accept_finish (new_stream,
00154 in_blocking_mode,
00155 reset_new_handle);
00156 }
00157
00158 #if !defined (ACE_HAS_WINCE)
00159 int
00160 ACE_SOCK_Acceptor::accept (ACE_SOCK_Stream &new_stream,
00161 ACE_Accept_QoS_Params qos_params,
00162 ACE_Addr *remote_addr,
00163 ACE_Time_Value *timeout,
00164 int restart,
00165 int reset_new_handle) const
00166 {
00167 ACE_TRACE ("ACE_SOCK_Acceptor::accept");
00168
00169 int in_blocking_mode = 0;
00170 if (this->shared_accept_start (timeout,
00171 restart,
00172 in_blocking_mode) == -1)
00173 return -1;
00174 else
00175 {
00176
00177
00178 int *len_ptr = 0;
00179 int len = 0;
00180 sockaddr *addr = 0;
00181
00182 if (remote_addr != 0)
00183 {
00184 len = remote_addr->get_size ();
00185 len_ptr = &len;
00186 addr = (sockaddr *) remote_addr->get_addr ();
00187 }
00188
00189 do
00190 new_stream.set_handle (ACE_OS::accept (this->get_handle (),
00191 addr,
00192 len_ptr,
00193 qos_params));
00194 while (new_stream.get_handle () == ACE_INVALID_HANDLE
00195 && restart != 0
00196 && errno == EINTR
00197 && timeout == 0);
00198
00199
00200
00201 if (new_stream.get_handle () != ACE_INVALID_HANDLE
00202 && remote_addr != 0)
00203 remote_addr->set_size (len);
00204 }
00205
00206 return this->shared_accept_finish (new_stream,
00207 in_blocking_mode,
00208 reset_new_handle);
00209 }
00210 #endif // ACE_HAS_WINCE
00211
00212 void
00213 ACE_SOCK_Acceptor::dump (void) const
00214 {
00215 #if defined (ACE_HAS_DUMP)
00216 ACE_TRACE ("ACE_SOCK_Acceptor::dump");
00217 #endif
00218 }
00219
00220 int
00221 ACE_SOCK_Acceptor::shared_open (const ACE_Addr &local_sap,
00222 int protocol_family,
00223 int backlog)
00224 {
00225 ACE_TRACE ("ACE_SOCK_Acceptor::shared_open");
00226 int error = 0;
00227
00228 #if defined (ACE_HAS_IPV6)
00229 if (protocol_family == PF_INET6)
00230 {
00231 sockaddr_in6 local_inet6_addr;
00232 ACE_OS::memset (reinterpret_cast<void *> (&local_inet6_addr),
00233 0,
00234 sizeof local_inet6_addr);
00235
00236 if (local_sap == ACE_Addr::sap_any)
00237 {
00238 local_inet6_addr.sin6_family = AF_INET6;
00239 local_inet6_addr.sin6_port = 0;
00240 local_inet6_addr.sin6_addr = in6addr_any;
00241 }
00242 else
00243 local_inet6_addr = *reinterpret_cast<sockaddr_in6 *> (local_sap.get_addr ());
00244
00245
00246
00247
00248 if (ACE_OS::bind (this->get_handle (),
00249 reinterpret_cast<sockaddr *> (&local_inet6_addr),
00250 sizeof local_inet6_addr) == -1)
00251 error = 1;
00252 }
00253 else
00254 #endif
00255 if (protocol_family == PF_INET)
00256 {
00257 sockaddr_in local_inet_addr;
00258 ACE_OS::memset (reinterpret_cast<void *> (&local_inet_addr),
00259 0,
00260 sizeof local_inet_addr);
00261
00262 if (local_sap == ACE_Addr::sap_any)
00263 {
00264 local_inet_addr.sin_port = 0;
00265 }
00266 else
00267 local_inet_addr = *reinterpret_cast<sockaddr_in *> (local_sap.get_addr ());
00268 if (local_inet_addr.sin_port == 0)
00269 {
00270 if (ACE::bind_port (this->get_handle (),
00271 ACE_NTOHL (ACE_UINT32 (local_inet_addr.sin_addr.s_addr))) == -1)
00272 error = 1;
00273 }
00274 else if (ACE_OS::bind (this->get_handle (),
00275 reinterpret_cast<sockaddr *> (&local_inet_addr),
00276 sizeof local_inet_addr) == -1)
00277 error = 1;
00278 }
00279 else if (ACE_OS::bind (this->get_handle (),
00280 (sockaddr *) local_sap.get_addr (),
00281 local_sap.get_size ()) == -1)
00282 error = 1;
00283
00284 if (error != 0
00285 || ACE_OS::listen (this->get_handle (),
00286 backlog) == -1)
00287 {
00288 ACE_Errno_Guard g (errno);
00289 error = 1;
00290 this->close ();
00291 }
00292
00293 return error ? -1 : 0;
00294 }
00295
00296 int
00297 ACE_SOCK_Acceptor::open (const ACE_Addr &local_sap,
00298 ACE_Protocol_Info *protocolinfo,
00299 ACE_SOCK_GROUP g,
00300 u_long flags,
00301 int reuse_addr,
00302 int protocol_family,
00303 int backlog,
00304 int protocol)
00305 {
00306 ACE_TRACE ("ACE_SOCK_Acceptor::open");
00307
00308 if (protocol_family == PF_UNSPEC)
00309 protocol_family = local_sap.get_type ();
00310
00311 if (ACE_SOCK::open (SOCK_STREAM,
00312 protocol_family,
00313 protocol,
00314 protocolinfo,
00315 g,
00316 flags,
00317 reuse_addr) == -1)
00318 return -1;
00319 else
00320 return this->shared_open (local_sap,
00321 protocol_family,
00322 backlog);
00323 }
00324
00325 ACE_SOCK_Acceptor::ACE_SOCK_Acceptor (const ACE_Addr &local_sap,
00326 ACE_Protocol_Info *protocolinfo,
00327 ACE_SOCK_GROUP g,
00328 u_long flags,
00329 int reuse_addr,
00330 int protocol_family,
00331 int backlog,
00332 int protocol)
00333 {
00334 ACE_TRACE ("ACE_SOCK_Acceptor::ACE_SOCK_Acceptor");
00335 if (this->open (local_sap,
00336 protocolinfo,
00337 g,
00338 flags,
00339 reuse_addr,
00340 protocol_family,
00341 backlog,
00342 protocol) == -1)
00343 ACE_ERROR ((LM_ERROR,
00344 ACE_TEXT ("%p\n"),
00345 ACE_TEXT ("ACE_SOCK_Acceptor")));
00346 }
00347
00348
00349
00350 int
00351 ACE_SOCK_Acceptor::open (const ACE_Addr &local_sap,
00352 int reuse_addr,
00353 int protocol_family,
00354 int backlog,
00355 int protocol)
00356 {
00357 ACE_TRACE ("ACE_SOCK_Acceptor::open");
00358
00359 if (local_sap != ACE_Addr::sap_any)
00360 protocol_family = local_sap.get_type ();
00361 else if (protocol_family == PF_UNSPEC)
00362 {
00363 #if defined (ACE_HAS_IPV6)
00364 protocol_family = ACE::ipv6_enabled () ? PF_INET6 : PF_INET;
00365 #else
00366 protocol_family = PF_INET;
00367 #endif
00368 }
00369
00370 if (ACE_SOCK::open (SOCK_STREAM,
00371 protocol_family,
00372 protocol,
00373 reuse_addr) == -1)
00374 return -1;
00375 else
00376 return this->shared_open (local_sap,
00377 protocol_family,
00378 backlog);
00379 }
00380
00381
00382
00383 ACE_SOCK_Acceptor::ACE_SOCK_Acceptor (const ACE_Addr &local_sap,
00384 int reuse_addr,
00385 int protocol_family,
00386 int backlog,
00387 int protocol)
00388 {
00389 ACE_TRACE ("ACE_SOCK_Acceptor::ACE_SOCK_Acceptor");
00390 if (this->open (local_sap,
00391 reuse_addr,
00392 protocol_family,
00393 backlog,
00394 protocol) == -1)
00395 ACE_ERROR ((LM_ERROR,
00396 ACE_TEXT ("%p\n"),
00397 ACE_TEXT ("ACE_SOCK_Acceptor")));
00398 }
00399
00400 int
00401 ACE_SOCK_Acceptor::close (void)
00402 {
00403 return ACE_SOCK::close ();
00404 }
00405
00406 ACE_END_VERSIONED_NAMESPACE_DECL