diff options
Diffstat (limited to 'ACE/ace/SOCK_SEQPACK_Connector.cpp')
| -rw-r--r-- | ACE/ace/SOCK_SEQPACK_Connector.cpp | 443 |
1 files changed, 443 insertions, 0 deletions
diff --git a/ACE/ace/SOCK_SEQPACK_Connector.cpp b/ACE/ace/SOCK_SEQPACK_Connector.cpp new file mode 100644 index 00000000000..128beb23f22 --- /dev/null +++ b/ACE/ace/SOCK_SEQPACK_Connector.cpp @@ -0,0 +1,443 @@ +// $Id$ + +#include "ace/SOCK_SEQPACK_Connector.h" + +#include "ace/INET_Addr.h" +#include "ace/Log_Msg.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_RCSID(ace, SOCK_SEQPACK_Connector, "SOCK_SEQPACK_Connector.cpp,v 4.35 2002/03/08 23:18:09 spark Exp") + +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; + ACE_NEW_NORETURN (local_inet_addrs, sockaddr_in[num_addresses]); + 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 */ + + delete [] local_inet_addrs; + } + + // 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->sec () == 0 + && timeout->usec () == 0) + 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)) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_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)) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector"))); +} + +ACE_END_VERSIONED_NAMESPACE_DECL |