mirror of
https://github.com/mangosfour/server.git
synced 2025-12-12 01:37:00 +00:00
448 lines
15 KiB
C++
448 lines
15 KiB
C++
#include "ace/SOCK_SEQPACK_Connector.h"
|
|
|
|
#include "ace/INET_Addr.h"
|
|
#include "ace/Log_Category.h"
|
|
#include "ace/Time_Value.h"
|
|
#include "ace/OS_Memory.h"
|
|
#include "ace/OS_NS_string.h"
|
|
#include "ace/OS_NS_sys_socket.h"
|
|
#include "ace/os_include/os_fcntl.h"
|
|
|
|
#if defined (ACE_WIN32)
|
|
#include "ace/OS_NS_unistd.h"
|
|
#endif /* ACE_WIN32 */
|
|
|
|
#if !defined (__ACE_INLINE__)
|
|
#include "ace/SOCK_SEQPACK_Connector.inl"
|
|
#endif /* __ACE_INLINE__ */
|
|
|
|
|
|
|
|
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
|
|
|
|
ACE_ALLOC_HOOK_DEFINE(ACE_SOCK_SEQPACK_Connector)
|
|
|
|
void
|
|
ACE_SOCK_SEQPACK_Connector::dump (void) const
|
|
{
|
|
#if defined (ACE_HAS_DUMP)
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::dump");
|
|
#endif /* ACE_HAS_DUMP */
|
|
}
|
|
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::shared_open (ACE_SOCK_SEQPACK_Association &new_association,
|
|
int protocol_family,
|
|
int protocol,
|
|
int reuse_addr)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_open");
|
|
|
|
|
|
|
|
// Only open a new socket if we don't already have a valid handle.
|
|
if (new_association.get_handle () == ACE_INVALID_HANDLE &&
|
|
#if defined (ACE_HAS_LKSCTP)
|
|
new_association.open (SOCK_STREAM,
|
|
#else
|
|
new_association.open (SOCK_SEQPACKET,
|
|
#endif /* ACE_HAS_LKSCTP */
|
|
protocol_family,
|
|
protocol,
|
|
reuse_addr) == -1)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::shared_open (ACE_SOCK_SEQPACK_Association &new_association,
|
|
int protocol_family,
|
|
int protocol,
|
|
ACE_Protocol_Info *protocolinfo,
|
|
ACE_SOCK_GROUP g,
|
|
u_long flags,
|
|
int reuse_addr)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_open");
|
|
|
|
// Only open a new socket if we don't already have a valid handle.
|
|
if (new_association.get_handle () == ACE_INVALID_HANDLE &&
|
|
#if defined (ACE_HAS_LKSCTP)
|
|
new_association.open (SOCK_STREAM,
|
|
#else
|
|
new_association.open (SOCK_SEQPACKET,
|
|
#endif /* ACE_HAS_LKSCTP */
|
|
protocol_family,
|
|
protocol,
|
|
protocolinfo,
|
|
g,
|
|
flags,
|
|
reuse_addr) == -1)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::shared_connect_start (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Time_Value *timeout,
|
|
const ACE_Addr &local_sap)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_connect_start");
|
|
|
|
if (local_sap != ACE_Addr::sap_any)
|
|
{
|
|
sockaddr *laddr = reinterpret_cast<sockaddr *> (local_sap.get_addr ());
|
|
int size = local_sap.get_size ();
|
|
|
|
if (ACE_OS::bind (new_association.get_handle (),
|
|
laddr,
|
|
size) == -1)
|
|
{
|
|
// Save/restore errno.
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Enable non-blocking, if required.
|
|
if (timeout != 0
|
|
&& new_association.enable (ACE_NONBLOCK) == -1)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
// Multihomed version of same
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::shared_connect_start (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Time_Value *timeout,
|
|
const ACE_Multihomed_INET_Addr &local_sap)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_connect_start");
|
|
|
|
if (local_sap.ACE_Addr::operator!= (ACE_Addr::sap_any))
|
|
{
|
|
// The total number of addresses is the number of secondary
|
|
// addresses plus one.
|
|
size_t num_addresses = local_sap.get_num_secondary_addresses() + 1;
|
|
|
|
// Create an array of sockaddr_in to hold the underlying
|
|
// representations of the primary and secondary
|
|
// addresses.
|
|
sockaddr_in* local_inet_addrs = 0;
|
|
#if defined(ACE_HAS_ALLOC_HOOKS)
|
|
ACE_ALLOCATOR_NORETURN (local_inet_addrs, static_cast<sockaddr_in*>(ACE_Allocator::instance()->malloc(sizeof(sockaddr_in) * (num_addresses))));
|
|
#else
|
|
ACE_NEW_NORETURN (local_inet_addrs, sockaddr_in[num_addresses]);
|
|
#endif
|
|
if (!local_inet_addrs)
|
|
return -1;
|
|
|
|
// Populate the array by invoking the get_addresses method on
|
|
// the Multihomed_INET_Addr
|
|
local_sap.get_addresses(local_inet_addrs, num_addresses);
|
|
|
|
#if defined (ACE_HAS_LKSCTP)
|
|
sockaddr_in *local_sockaddr = 0;
|
|
sockaddr_in portst;
|
|
int sn = sizeof(sockaddr);
|
|
|
|
// bind to the primary addr first
|
|
if (ACE_OS::bind(new_association.get_handle (),
|
|
reinterpret_cast<sockaddr *> (&(local_inet_addrs[0])),
|
|
sizeof(sockaddr)))
|
|
{
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
}
|
|
|
|
// do we need to bind multiple addrs
|
|
if (num_addresses > 1)
|
|
{
|
|
// allocate enough memory to hold the number of secondary addrs
|
|
ACE_NEW_NORETURN(local_sockaddr,
|
|
sockaddr_in[num_addresses - 1]);
|
|
|
|
// get sockaddr_in for the local handle
|
|
if (ACE_OS::getsockname(new_association.get_handle (),
|
|
reinterpret_cast<sockaddr *> (&portst),
|
|
&sn))
|
|
{
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
}
|
|
|
|
// set the local port # assigned by the os to every secondary addr
|
|
for (size_t i = 1; i < num_addresses; i++)
|
|
{
|
|
local_inet_addrs[i].sin_port = portst.sin_port;
|
|
}
|
|
|
|
// copy all of the secondary addrs into a sockaddr structure
|
|
for (size_t i = 0; i < num_addresses - 1; i++)
|
|
{
|
|
ACE_OS::memcpy(&(local_sockaddr[i]),
|
|
&(local_inet_addrs[i + 1]),
|
|
sizeof(sockaddr_in));
|
|
}
|
|
|
|
// bind other ifaces
|
|
if (sctp_bindx(new_association.get_handle(),
|
|
reinterpret_cast<sockaddr *> (local_sockaddr),
|
|
num_addresses - 1,
|
|
SCTP_BINDX_ADD_ADDR))
|
|
{
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
}
|
|
|
|
delete [] local_sockaddr;
|
|
}
|
|
#else
|
|
|
|
// Call bind
|
|
size_t name_len = (sizeof (sockaddr_in)) * num_addresses;
|
|
if (ACE_OS::bind (new_association.get_handle (),
|
|
reinterpret_cast<sockaddr *> (local_inet_addrs),
|
|
static_cast<int> (name_len)) == -1)
|
|
{
|
|
// Save/restore errno.
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
}
|
|
#endif /* ACE_HAS_LKSCTP */
|
|
|
|
#if defined (ACE_HAS_ALLOC_HOOKS)
|
|
ACE_Allocator::instance()->free(local_inet_addrs);
|
|
#else
|
|
delete [] local_inet_addrs;
|
|
#endif /* ACE_HAS_ALLOC_HOOKS */
|
|
}
|
|
|
|
// Enable non-blocking, if required.
|
|
if (timeout != 0
|
|
&& new_association.enable (ACE_NONBLOCK) == -1)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::shared_connect_finish (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Time_Value *timeout,
|
|
int result)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_connect_finish");
|
|
// Save/restore errno.
|
|
ACE_Errno_Guard error (errno);
|
|
|
|
if (result == -1 && timeout != 0)
|
|
{
|
|
// Check whether the connection is in progress.
|
|
if (error == EINPROGRESS || error == EWOULDBLOCK)
|
|
{
|
|
// This expression checks if we were polling.
|
|
if (*timeout == ACE_Time_Value::zero)
|
|
error = EWOULDBLOCK;
|
|
// Wait synchronously using timeout.
|
|
else if (this->complete (new_association,
|
|
0,
|
|
timeout) == -1)
|
|
error = errno;
|
|
else
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// EISCONN is treated specially since this routine may be used to
|
|
// check if we are already connected.
|
|
if (result != -1 || error == EISCONN)
|
|
// Start out with non-blocking disabled on the <new_association>.
|
|
new_association.disable (ACE_NONBLOCK);
|
|
else if (!(error == EWOULDBLOCK || error == ETIMEDOUT))
|
|
new_association.close ();
|
|
|
|
return result;
|
|
}
|
|
|
|
// Actively connect and produce a new ACE_SOCK_SEQPACK_Association if things go well...
|
|
|
|
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::connect (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Addr &remote_sap,
|
|
const ACE_Time_Value *timeout,
|
|
const ACE_Addr &local_sap,
|
|
int reuse_addr,
|
|
int /* flags */,
|
|
int /* perms */,
|
|
int protocol)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::connect");
|
|
|
|
if (this->shared_open (new_association,
|
|
remote_sap.get_type (),
|
|
protocol,
|
|
reuse_addr) == -1)
|
|
return -1;
|
|
else if (this->shared_connect_start (new_association,
|
|
timeout,
|
|
local_sap) == -1)
|
|
return -1;
|
|
|
|
int result = ACE_OS::connect (new_association.get_handle (),
|
|
reinterpret_cast<sockaddr *> (remote_sap.get_addr ()),
|
|
remote_sap.get_size ());
|
|
|
|
return this->shared_connect_finish (new_association,
|
|
timeout,
|
|
result);
|
|
}
|
|
|
|
// Multihomed version of same
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::connect (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Addr &remote_sap,
|
|
const ACE_Time_Value *timeout,
|
|
const ACE_Multihomed_INET_Addr &local_sap,
|
|
int reuse_addr,
|
|
int /* flags */,
|
|
int /* perms */,
|
|
int protocol)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::connect");
|
|
|
|
if (this->shared_open (new_association,
|
|
remote_sap.get_type (),
|
|
protocol,
|
|
reuse_addr) == -1)
|
|
return -1;
|
|
else if (this->shared_connect_start (new_association,
|
|
timeout,
|
|
local_sap) == -1)
|
|
return -1;
|
|
|
|
int result = ACE_OS::connect (new_association.get_handle (),
|
|
reinterpret_cast<sockaddr *> (remote_sap.get_addr ()),
|
|
remote_sap.get_size ());
|
|
|
|
return this->shared_connect_finish (new_association,
|
|
timeout,
|
|
result);
|
|
}
|
|
|
|
// Try to complete a non-blocking connection.
|
|
|
|
int
|
|
ACE_SOCK_SEQPACK_Connector::complete (ACE_SOCK_SEQPACK_Association &new_association,
|
|
ACE_Addr *remote_sap,
|
|
const ACE_Time_Value *tv)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::complete");
|
|
ACE_HANDLE h = ACE::handle_timed_complete (new_association.get_handle (),
|
|
tv);
|
|
// We failed to get connected.
|
|
if (h == ACE_INVALID_HANDLE)
|
|
{
|
|
#if defined (ACE_WIN32)
|
|
// Win32 has a timing problem - if you check to see if the
|
|
// connection has completed too fast, it will fail - so wait
|
|
// <ACE_NON_BLOCKING_BUG_DELAY> microseconds to let it catch up
|
|
// then retry to see if it's a real failure.
|
|
ACE_Time_Value time (0, ACE_NON_BLOCKING_BUG_DELAY);
|
|
ACE_OS::sleep (time);
|
|
h = ACE::handle_timed_complete (new_association.get_handle (),
|
|
tv);
|
|
if (h == ACE_INVALID_HANDLE)
|
|
{
|
|
#endif /* ACE_WIN32 */
|
|
// Save/restore errno.
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
#if defined (ACE_WIN32)
|
|
}
|
|
#endif /* ACE_WIN32 */
|
|
}
|
|
|
|
if (remote_sap != 0)
|
|
{
|
|
int len = remote_sap->get_size ();
|
|
sockaddr *addr = reinterpret_cast<sockaddr *> (remote_sap->get_addr ());
|
|
if (ACE_OS::getpeername (h,
|
|
addr,
|
|
&len) == -1)
|
|
{
|
|
// Save/restore errno.
|
|
ACE_Errno_Guard error (errno);
|
|
new_association.close ();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Start out with non-blocking disabled on the <new_association>.
|
|
new_association.disable (ACE_NONBLOCK);
|
|
return 0;
|
|
}
|
|
|
|
ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Addr &remote_sap,
|
|
const ACE_Time_Value *timeout,
|
|
const ACE_Addr &local_sap,
|
|
int reuse_addr,
|
|
int flags,
|
|
int perms,
|
|
int protocol)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector");
|
|
|
|
if (this->connect (new_association,
|
|
remote_sap,
|
|
timeout,
|
|
local_sap,
|
|
reuse_addr,
|
|
flags,
|
|
perms,
|
|
protocol) == -1
|
|
&& timeout != 0
|
|
&& !(errno == EWOULDBLOCK || errno == ETIME || errno == ETIMEDOUT))
|
|
ACELIB_ERROR ((LM_ERROR,
|
|
ACE_TEXT ("%p\n"),
|
|
ACE_TEXT ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector")));
|
|
}
|
|
|
|
// Multihomed version of same
|
|
ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector (ACE_SOCK_SEQPACK_Association &new_association,
|
|
const ACE_Addr &remote_sap,
|
|
const ACE_Time_Value *timeout,
|
|
const ACE_Multihomed_INET_Addr &local_sap,
|
|
int reuse_addr,
|
|
int flags,
|
|
int perms,
|
|
int protocol)
|
|
{
|
|
ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector");
|
|
|
|
if (this->connect (new_association,
|
|
remote_sap,
|
|
timeout,
|
|
local_sap,
|
|
reuse_addr,
|
|
flags,
|
|
perms,
|
|
protocol) == -1
|
|
&& timeout != 0
|
|
&& !(errno == EWOULDBLOCK || errno == ETIME || errno == ETIMEDOUT))
|
|
ACELIB_ERROR ((LM_ERROR,
|
|
ACE_TEXT ("%p\n"),
|
|
ACE_TEXT ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector")));
|
|
}
|
|
|
|
ACE_END_VERSIONED_NAMESPACE_DECL
|