ACE_SOCK_SEQPACK_Connector Class Reference

Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object. More...

#include <SOCK_SEQPACK_Connector.h>

List of all members.

Public Types

typedef ACE_Multihomed_INET_Addr PEER_ADDR
typedef
ACE_SOCK_SEQPACK_Association 		PEER_STREAM

Public Member Functions

 ACE_SOCK_SEQPACK_Connector (void)
 Default constructor.
 ACE_SOCK_SEQPACK_Connector (ACE_SOCK_SEQPACK_Association &new_association, const ACE_Addr &remote_sap, const ACE_Time_Value *timeout=0, const ACE_Addr &local_sap=ACE_Addr::sap_any, int reuse_addr=0, int flags=0, int perms=0, int protocol=132)
 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=0, int flags=0, int perms=0, int protocol=132)
int connect (ACE_SOCK_SEQPACK_Association &new_association, const ACE_Addr &remote_sap, const ACE_Time_Value *timeout=0, const ACE_Addr &local_sap=ACE_Addr::sap_any, int reuse_addr=0, int flags=0, int perms=0, int protocol=132)
int 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=0, int flags=0, int perms=0, int protocol=132)
 ~ACE_SOCK_SEQPACK_Connector (void)
 Default dtor.
int complete (ACE_SOCK_SEQPACK_Association &new_association, ACE_Addr *remote_sap=0, const ACE_Time_Value *timeout=0)
bool reset_new_handle (ACE_HANDLE handle)
 Resets any event associations on this handle.
void dump (void) const
 Dump the state of an object.

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.

Protected Member Functions

int shared_open (ACE_SOCK_SEQPACK_Association &new_association, int protocol_family, int protocol, int reuse_addr)
int 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)
int shared_connect_start (ACE_SOCK_SEQPACK_Association &new_association, const ACE_Time_Value *timeout, const ACE_Addr &local_sap)
 Perform operations that must be called before <ACE_OS::connect>.
int shared_connect_start (ACE_SOCK_SEQPACK_Association &new_association, const ACE_Time_Value *timeout, const ACE_Multihomed_INET_Addr &local_sap)
int shared_connect_finish (ACE_SOCK_SEQPACK_Association &new_association, const ACE_Time_Value *timeout, int result)
 Perform operations that must be called after <ACE_OS::connect>.

Detailed Description

Defines a factory that actively connects to a remote IP address and TCP port, creating a new ACE_SOCK_SEQPACK_Association object.

The ACE_SOCK_SEQPACK_Connector doesn't have a socket of its own, i.e., it simply "borrows" the one from the ACE_SOCK_SEQPACK_Association that's being connected. The reason for this is that the underlying socket API doesn't use a factory socket to connect data mode sockets. Therefore, there's no need to inherit ACE_SOCK_SEQPACK_Connector from ACE_SOCK. A nice side-effect of this is that ACE_SOCK_SEQPACK_Connector objects do not store state so they can be used reentrantly in multithreaded programs.

Definition at line 51 of file SOCK_SEQPACK_Connector.h.

Member Typedef Documentation

typedef ACE_Multihomed_INET_Addr ACE_SOCK_SEQPACK_Connector::PEER_ADDR

Definition at line 281 of file SOCK_SEQPACK_Connector.h.

typedef ACE_SOCK_SEQPACK_Association ACE_SOCK_SEQPACK_Connector::PEER_STREAM

Definition at line 282 of file SOCK_SEQPACK_Connector.h.

Constructor & Destructor Documentation

ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector ( void   ) 

Default constructor.

Definition at line 19 of file SOCK_SEQPACK_Connector.inl.

00020 {
00021   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector");
00022 }

ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector ( ACE_SOCK_SEQPACK_Association &  new_association,
const ACE_Addr &  remote_sap,
const ACE_Time_Value *  timeout = 0,
const ACE_Addr &  local_sap = ACE_Addr::sap_any,
int  reuse_addr = 0,
int  flags = 0,
int  perms = 0,
int  protocol = 132 
)

Actively connect to a peer, producing a connected ACE_SOCK_SEQPACK_Association object if the connection succeeds.

Parameters:
new_association The ACE_SOCK_SEQPACK_Association object that will be connected to the peer.
remote_sap The address that we are trying to connect to. The protocol family of remote_sap is used for the connected socket. That is, if remote_sap contains an IPv6 address, a socket with family PF_INET6 will be used, else it will be PF_INET.
timeout Pointer to an ACE_Time_Value object with amount of time to wait to connect. If the pointer is 0 then the call blocks until the connection attempt is complete, whether it succeeds or fails. If *timeout == {0, 0} then the connection is done using nonblocking mode. In this case, if the connection can't be made immediately, this method returns -1 and errno == EWOULDBLOCK. If *timeout > {0, 0} then this is the maximum amount of time to wait before timing out; if the specified amount of time passes before the connection is made, this method returns -1 and errno == ETIME. Note the difference between this case and when a blocking connect is attempted that TCP times out - in the latter case, errno will be ETIMEDOUT.
local_sap (optional) The local address to bind to. If it's the default value of ACE_Addr::sap_any then the OS will choose an unused port.
reuse_addr (optional) If the value is 1, the local address (local_sap) is reused, even if it hasn't been cleaned up yet.
flags Ignored.
perms Ignored.
protocol (optional) If value is 0, default SOCK_STREAM protocol is selected by kernel (typically TCP).
Returns:
Returns 0 if the connection succeeds. If it fails, -1 is returned and errno contains a specific error code.

Definition at line 389 of file SOCK_SEQPACK_Connector.cpp.

00397 {
00398   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector");
00399 
00400   if (this->connect (new_association,
00401                      remote_sap,
00402                      timeout,
00403                      local_sap,
00404                      reuse_addr,
00405                      flags,
00406                      perms,
00407                      protocol) == -1
00408       && timeout != 0
00409       && !(errno == EWOULDBLOCK || errno == ETIME || errno == ETIMEDOUT))
00410     ACE_ERROR ((LM_ERROR,
00411                 ACE_TEXT ("%p\n"),
00412                 ACE_TEXT ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector")));
00413 }

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 = 0,
int  flags = 0,
int  perms = 0,
int  protocol = 132 
)

Actively connect to a peer, producing a connected ACE_SOCK_SEQPACK_Association object if the connection succeeds.

Parameters:
new_association The ACE_SOCK_SEQPACK_Association object that will be connected to the peer.
remote_sap The address that we are trying to connect to. The protocol family of remote_sap is used for the connected socket. That is, if remote_sap contains an IPv6 address, a socket with family PF_INET6 will be used, else it will be PF_INET.
timeout Pointer to an ACE_Time_Value object with amount of time to wait to connect. If the pointer is 0 then the call blocks until the connection attempt is complete, whether it succeeds or fails. If *timeout == {0, 0} then the connection is done using nonblocking mode. In this case, if the connection can't be made immediately, this method returns -1 and errno == EWOULDBLOCK. If *timeout > {0, 0} then this is the maximum amount of time to wait before timing out; if the specified amount of time passes before the connection is made, this method returns -1 and errno == ETIME. Note the difference between this case and when a blocking connect is attempted that TCP times out - in the latter case, errno will be ETIMEDOUT.
local_sap (optional) The set of local addresses for SCTP to bind to.
reuse_addr (optional) If the value is 1, the local address (local_sap) is reused, even if it hasn't been cleaned up yet.
flags Ignored.
perms Ignored.
protocol (optional) If value is 0, default SOCK_STREAM protocol is selected by kernel (typically TCP).
Returns:
Returns 0 if the connection succeeds. If it fails, -1 is returned and errno contains a specific error code.

Definition at line 416 of file SOCK_SEQPACK_Connector.cpp.

00424 {
00425   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector");
00426 
00427   if (this->connect (new_association,
00428                      remote_sap,
00429                      timeout,
00430                      local_sap,
00431                      reuse_addr,
00432                      flags,
00433                      perms,
00434                      protocol) == -1
00435       && timeout != 0
00436       && !(errno == EWOULDBLOCK || errno == ETIME || errno == ETIMEDOUT))
00437     ACE_ERROR ((LM_ERROR,
00438                 ACE_TEXT ("%p\n"),
00439                 ACE_TEXT ("ACE_SOCK_SEQPACK_Connector::ACE_SOCK_SEQPACK_Connector")));
00440 }

ACE_SOCK_SEQPACK_Connector::~ACE_SOCK_SEQPACK_Connector ( void   ) 

Default dtor.

Definition at line 11 of file SOCK_SEQPACK_Connector.inl.

00012 {
00013   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::~ACE_SOCK_SEQPACK_Connector");
00014 }

Member Function Documentation

int ACE_SOCK_SEQPACK_Connector::complete ( ACE_SOCK_SEQPACK_Association &  new_association,
ACE_Addr *  remote_sap = 0,
const ACE_Time_Value *  timeout = 0 
)

Try to complete a nonblocking connection that was begun by a previous call to connect with a {0, 0} ACE_Time_Value timeout.

See also:
connect().
Parameters:
new_association The ACE_SOCK_SEQPACK_Association object that will be connected to the peer.
remote_sap If non-0, it points to the ACE_INET_Addr object that will contain the address of the connected peer.
timeout Same values and return value possibilites as for connect().
See also:
connect().

Definition at line 338 of file SOCK_SEQPACK_Connector.cpp.

00341 {
00342   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::complete");
00343   ACE_HANDLE h = ACE::handle_timed_complete (new_association.get_handle (),
00344                                              tv);
00345   // We failed to get connected.
00346   if (h == ACE_INVALID_HANDLE)
00347     {
00348 #if defined (ACE_WIN32)
00349       // Win32 has a timing problem - if you check to see if the
00350       // connection has completed too fast, it will fail - so wait
00351       // <ACE_NON_BLOCKING_BUG_DELAY> microseconds to let it catch up
00352       // then retry to see if it's a real failure.
00353       ACE_Time_Value time (0, ACE_NON_BLOCKING_BUG_DELAY);
00354       ACE_OS::sleep (time);
00355       h = ACE::handle_timed_complete (new_association.get_handle (),
00356                                       tv);
00357       if (h == ACE_INVALID_HANDLE)
00358         {
00359 #endif /* ACE_WIN32 */
00360       // Save/restore errno.
00361       ACE_Errno_Guard error (errno);
00362       new_association.close ();
00363       return -1;
00364 #if defined (ACE_WIN32)
00365         }
00366 #endif /* ACE_WIN32 */
00367     }
00368 
00369   if (remote_sap != 0)
00370     {
00371       int len = remote_sap->get_size ();
00372       sockaddr *addr = reinterpret_cast<sockaddr *> (remote_sap->get_addr ());
00373       if (ACE_OS::getpeername (h,
00374                                addr,
00375                                &len) == -1)
00376         {
00377           // Save/restore errno.
00378           ACE_Errno_Guard error (errno);
00379           new_association.close ();
00380           return -1;
00381         }
00382     }
00383 
00384   // Start out with non-blocking disabled on the <new_association>.
00385   new_association.disable (ACE_NONBLOCK);
00386   return 0;
00387 }

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 = 0,
int  flags = 0,
int  perms = 0,
int  protocol = 132 
)

Actively connect to a peer, producing a connected ACE_SOCK_SEQPACK_Association object if the connection succeeds.

Parameters:
new_association The ACE_SOCK_SEQPACK_Association object that will be connected to the peer.
remote_sap The address that we are trying to connect to. The protocol family of remote_sap is used for the connected socket. That is, if remote_sap contains an IPv6 address, a socket with family PF_INET6 will be used, else it will be PF_INET.
timeout Pointer to an ACE_Time_Value object with amount of time to wait to connect. If the pointer is 0 then the call blocks until the connection attempt is complete, whether it succeeds or fails. If *timeout == {0, 0} then the connection is done using nonblocking mode. In this case, if the connection can't be made immediately, this method returns -1 and errno == EWOULDBLOCK. If *timeout > {0, 0} then this is the maximum amount of time to wait before timing out; if the specified amount of time passes before the connection is made, this method returns -1 and errno == ETIME. Note the difference between this case and when a blocking connect is attempted that TCP times out - in the latter case, errno will be ETIMEDOUT.
local_sap (optional) The set of local addresses for SCTP to bind to.
reuse_addr (optional) If the value is 1, the local address (local_sap) is reused, even if it hasn't been cleaned up yet.
flags Ignored.
perms Ignored.
protocol (optional) If value is 0, default SOCK_STREAM protocol is selected by kernel (typically TCP).
Returns:
Returns 0 if the connection succeeds. If it fails, -1 is returned and errno contains a specific error code.

Definition at line 305 of file SOCK_SEQPACK_Connector.cpp.

00313 {
00314   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::connect");
00315 
00316   if (this->shared_open (new_association,
00317                          remote_sap.get_type (),
00318                          protocol,
00319                          reuse_addr) == -1)
00320     return -1;
00321   else if (this->shared_connect_start (new_association,
00322                                        timeout,
00323                                        local_sap) == -1)
00324     return -1;
00325 
00326   int result = ACE_OS::connect (new_association.get_handle (),
00327                                 reinterpret_cast<sockaddr *> (remote_sap.get_addr ()),
00328                                 remote_sap.get_size ());
00329 
00330   return this->shared_connect_finish (new_association,
00331                                       timeout,
00332                                       result);
00333 }

int ACE_SOCK_SEQPACK_Connector::connect ( ACE_SOCK_SEQPACK_Association &  new_association,
const ACE_Addr &  remote_sap,
const ACE_Time_Value *  timeout = 0,
const ACE_Addr &  local_sap = ACE_Addr::sap_any,
int  reuse_addr = 0,
int  flags = 0,
int  perms = 0,
int  protocol = 132 
)

Actively connect to a peer, producing a connected ACE_SOCK_SEQPACK_Association object if the connection succeeds.

Parameters:
new_association The ACE_SOCK_SEQPACK_Association object that will be connected to the peer.
remote_sap The address that we are trying to connect to. The protocol family of remote_sap is used for the connected socket. That is, if remote_sap contains an IPv6 address, a socket with family PF_INET6 will be used, else it will be PF_INET.
timeout Pointer to an ACE_Time_Value object with amount of time to wait to connect. If the pointer is 0 then the call blocks until the connection attempt is complete, whether it succeeds or fails. If *timeout == {0, 0} then the connection is done using nonblocking mode. In this case, if the connection can't be made immediately, this method returns -1 and errno == EWOULDBLOCK. If *timeout > {0, 0} then this is the maximum amount of time to wait before timing out; if the specified amount of time passes before the connection is made, this method returns -1 and errno == ETIME. Note the difference between this case and when a blocking connect is attempted that TCP times out - in the latter case, errno will be ETIMEDOUT.
local_sap (optional) The local address to bind to. If it's the default value of ACE_Addr::sap_any then the OS will choose an unused port.
reuse_addr (optional) If the value is 1, the local address (local_sap) is reused, even if it hasn't been cleaned up yet.
flags Ignored.
perms Ignored.
protocol (optional) If value is 0, default SOCK_STREAM protocol is selected by kernel (typically TCP).
Returns:
Returns 0 if the connection succeeds. If it fails, -1 is returned and errno contains a specific error code.

Definition at line 273 of file SOCK_SEQPACK_Connector.cpp.

00281 {
00282   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::connect");
00283 
00284   if (this->shared_open (new_association,
00285                          remote_sap.get_type (),
00286                          protocol,
00287                          reuse_addr) == -1)
00288     return -1;
00289   else if (this->shared_connect_start (new_association,
00290                                        timeout,
00291                                        local_sap) == -1)
00292     return -1;
00293 
00294   int result = ACE_OS::connect (new_association.get_handle (),
00295                                 reinterpret_cast<sockaddr *> (remote_sap.get_addr ()),
00296                                 remote_sap.get_size ());
00297 
00298   return this->shared_connect_finish (new_association,
00299                                       timeout,
00300                                       result);
00301 }

void ACE_SOCK_SEQPACK_Connector::dump ( void   )  const

Dump the state of an object.

Definition at line 28 of file SOCK_SEQPACK_Connector.cpp.

00029 {
00030 #if defined (ACE_HAS_DUMP)
00031   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::dump");
00032 #endif /* ACE_HAS_DUMP */
00033 }

bool ACE_SOCK_SEQPACK_Connector::reset_new_handle ( ACE_HANDLE  handle  ) 

Resets any event associations on this handle.

Definition at line 25 of file SOCK_SEQPACK_Connector.inl.

00026 {
00027 #if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
00028   // Reset the event association
00029   return ::WSAEventSelect ((SOCKET) handle,
00030                            0,
00031                            0);
00032 #else /* !defined ACE_HAS_WINSOCK2 */
00033   ACE_UNUSED_ARG (handle);
00034   return false;
00035 #endif /* ACE_WIN32 */
00036 }

int ACE_SOCK_SEQPACK_Connector::shared_connect_finish ( ACE_SOCK_SEQPACK_Association &  new_association,
const ACE_Time_Value *  timeout,
int  result 
) [protected]

Perform operations that must be called after <ACE_OS::connect>.

Definition at line 232 of file SOCK_SEQPACK_Connector.cpp.

00235 {
00236   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_connect_finish");
00237   // Save/restore errno.
00238   ACE_Errno_Guard error (errno);
00239 
00240   if (result == -1 && timeout != 0)
00241     {
00242       // Check whether the connection is in progress.
00243       if (error == EINPROGRESS || error == EWOULDBLOCK)
00244         {
00245           // This expression checks if we were polling.
00246           if (*timeout == ACE_Time_Value::zero)
00247             error = EWOULDBLOCK;
00248           // Wait synchronously using timeout.
00249           else if (this->complete (new_association,
00250                                    0,
00251                                    timeout) == -1)
00252             error = errno;
00253           else
00254             return 0;
00255         }
00256     }
00257 
00258   // EISCONN is treated specially since this routine may be used to
00259   // check if we are already connected.
00260   if (result != -1 || error == EISCONN)
00261     // Start out with non-blocking disabled on the <new_association>.
00262     new_association.disable (ACE_NONBLOCK);
00263   else if (!(error == EWOULDBLOCK || error == ETIMEDOUT))
00264     new_association.close ();
00265 
00266   return result;
00267 }

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 
) [protected]

Definition at line 122 of file SOCK_SEQPACK_Connector.cpp.

00125 {
00126   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_connect_start");
00127 
00128   if (local_sap.ACE_Addr::operator!= (ACE_Addr::sap_any))
00129     {
00130       // The total number of addresses is the number of secondary
00131       // addresses plus one.
00132       size_t num_addresses = local_sap.get_num_secondary_addresses() + 1;
00133 
00134       // Create an array of sockaddr_in to hold the underlying
00135       // representations of the primary and secondary
00136       // addresses.
00137       sockaddr_in*  local_inet_addrs = 0;
00138       ACE_NEW_NORETURN (local_inet_addrs, sockaddr_in[num_addresses]);
00139       if (!local_inet_addrs)
00140         return -1;
00141 
00142       // Populate the array by invoking the get_addresses method on
00143       // the Multihomed_INET_Addr
00144       local_sap.get_addresses(local_inet_addrs, num_addresses);
00145 
00146 #if defined (ACE_HAS_LKSCTP)
00147       sockaddr_in *local_sockaddr = 0;
00148       sockaddr_in portst;
00149       int sn = sizeof(sockaddr);
00150 
00151       // bind to the primary addr first
00152       if (ACE_OS::bind(new_association.get_handle (),
00153                        reinterpret_cast<sockaddr *> (&(local_inet_addrs[0])),
00154                        sizeof(sockaddr)))
00155       {
00156         ACE_Errno_Guard error (errno);
00157         new_association.close ();
00158         return -1;
00159       }
00160 
00161       // do we need to bind multiple addrs
00162       if (num_addresses > 1)
00163       {
00164         // allocate enough memory to hold the number of secondary addrs
00165         ACE_NEW_NORETURN(local_sockaddr,
00166                          sockaddr_in[num_addresses - 1]);
00167 
00168         // get sockaddr_in for the local handle
00169         if (ACE_OS::getsockname(new_association.get_handle (),
00170                                 reinterpret_cast<sockaddr *> (&portst),
00171                                                      &sn))
00172         {
00173           ACE_Errno_Guard error (errno);
00174           new_association.close ();
00175           return -1;
00176         }
00177 
00178         // set the local port # assigned by the os to every secondary addr
00179         for (size_t i = 1; i < num_addresses; i++)
00180         {
00181           local_inet_addrs[i].sin_port = portst.sin_port;
00182         }
00183 
00184         // copy all of the secondary addrs into a sockaddr structure
00185         for (size_t i = 0; i < num_addresses - 1; i++)
00186         {
00187           ACE_OS::memcpy(&(local_sockaddr[i]),
00188                          &(local_inet_addrs[i + 1]),
00189                          sizeof(sockaddr_in));
00190         }
00191 
00192         // bind other ifaces
00193         if (sctp_bindx(new_association.get_handle(),
00194                        reinterpret_cast<sockaddr *> (local_sockaddr),
00195                        num_addresses - 1,
00196                        SCTP_BINDX_ADD_ADDR))
00197         {
00198           ACE_Errno_Guard error (errno);
00199           new_association.close ();
00200           return -1;
00201         }
00202 
00203         delete [] local_sockaddr;
00204       }
00205 #else
00206 
00207       // Call bind
00208       size_t name_len = (sizeof (sockaddr_in)) * num_addresses;
00209       if (ACE_OS::bind (new_association.get_handle (),
00210                         reinterpret_cast<sockaddr *> (local_inet_addrs),
00211                         static_cast<int> (name_len)) == -1)
00212         {
00213           // Save/restore errno.
00214           ACE_Errno_Guard error (errno);
00215           new_association.close ();
00216           return -1;
00217         }
00218 #endif /* ACE_HAS_LKSCTP */
00219 
00220       delete [] local_inet_addrs;
00221     }
00222 
00223   // Enable non-blocking, if required.
00224   if (timeout != 0
00225       && new_association.enable (ACE_NONBLOCK) == -1)
00226     return -1;
00227   else
00228     return 0;
00229 }

int ACE_SOCK_SEQPACK_Connector::shared_connect_start ( ACE_SOCK_SEQPACK_Association &  new_association,
const ACE_Time_Value *  timeout,
const ACE_Addr &  local_sap 
) [protected]

Perform operations that must be called before <ACE_OS::connect>.

Definition at line 90 of file SOCK_SEQPACK_Connector.cpp.

00093 {
00094   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_connect_start");
00095 
00096   if (local_sap != ACE_Addr::sap_any)
00097     {
00098       sockaddr *laddr = reinterpret_cast<sockaddr *> (local_sap.get_addr ());
00099       int size = local_sap.get_size ();
00100 
00101       if (ACE_OS::bind (new_association.get_handle (),
00102                         laddr,
00103                         size) == -1)
00104         {
00105           // Save/restore errno.
00106           ACE_Errno_Guard error (errno);
00107           new_association.close ();
00108           return -1;
00109         }
00110     }
00111 
00112   // Enable non-blocking, if required.
00113   if (timeout != 0
00114       && new_association.enable (ACE_NONBLOCK) == -1)
00115     return -1;
00116   else
00117     return 0;
00118 }

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 
) [protected]

Perform operations that ensure the socket is opened using QoS-enabled semantics.

Definition at line 61 of file SOCK_SEQPACK_Connector.cpp.

00068 {
00069   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_open");
00070 
00071   // Only open a new socket if we don't already have a valid handle.
00072   if (new_association.get_handle () == ACE_INVALID_HANDLE &&
00073 #if defined (ACE_HAS_LKSCTP)
00074       new_association.open (SOCK_STREAM,
00075 #else
00076       new_association.open (SOCK_SEQPACKET,
00077 #endif /* ACE_HAS_LKSCTP */
00078                                protocol_family,
00079                                protocol,
00080                                protocolinfo,
00081                                g,
00082                                flags,
00083                                reuse_addr) == -1)
00084       return -1;
00085   else
00086     return 0;
00087 }

int ACE_SOCK_SEQPACK_Connector::shared_open ( ACE_SOCK_SEQPACK_Association &  new_association,
int  protocol_family,
int  protocol,
int  reuse_addr 
) [protected]

Perform operations that ensure the socket is opened using BSD-style semantics (no QoS).

Definition at line 36 of file SOCK_SEQPACK_Connector.cpp.

00040 {
00041   ACE_TRACE ("ACE_SOCK_SEQPACK_Connector::shared_open");
00042 
00043 
00044 
00045   // Only open a new socket if we don't already have a valid handle.
00046   if (new_association.get_handle () == ACE_INVALID_HANDLE &&
00047 #if defined (ACE_HAS_LKSCTP)
00048          new_association.open (SOCK_STREAM,
00049 #else
00050          new_association.open (SOCK_SEQPACKET,
00051 #endif /* ACE_HAS_LKSCTP */
00052                                protocol_family,
00053                                protocol,
00054                                reuse_addr) == -1)
00055     return -1;
00056   else
00057     return 0;
00058 }

Member Data Documentation

ACE_SOCK_SEQPACK_Connector::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Definition at line 288 of file SOCK_SEQPACK_Connector.h.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Sat Nov 7 23:18:10 2009 for ACE by  doxygen 1.6.1