ACE: ACE_TLI_Connector class Reference

Actively connect and produce a if things go well. The is the address that we are trying to connect with. The is the amount of time to wait to connect. If it's 0 then we block indefinitely. If *timeout == {0, 0} then the connection is done using non-blocking mode. In this case, if the connection can't be made immediately the value of -1 is returned with <errno == EWOULDBLOCK>. If *timeout > {0, 0} then this is the maximum amount of time to wait before timing out. If the time expires before the connection is made <errno == ETIME>. The is the value of local address to bind to. If it's the default value of <ACE_Addr::sap_any> then the user is letting the OS do the binding. If == 1 then the is reused, even if it hasn't been cleanedup yet.

00052 {
00053   ACE_TRACE ("ACE_TLI_Connector::connect");
00054   int result = 0;
00055 
00056   // Only open a new endpoint if we don't already have a valid handle.
00057 
00058   if (new_stream.get_handle () == ACE_INVALID_HANDLE
00059       && new_stream.open (device, flags, info) == ACE_INVALID_HANDLE)
00060     return -1;
00061 
00062   if (local_sap != ACE_Addr::sap_any)
00063     {
00064       // Bind the local endpoint to a specific addr.
00065 
00066       struct t_bind *localaddr;
00067 
00068       localaddr = (struct t_bind *)
00069         ACE_OS::t_alloc (new_stream.get_handle (), T_BIND, T_ADDR);
00070 
00071       if (localaddr == 0)
00072         result = -1;
00073       else
00074         {
00075           int one = 1;
00076 #if !defined (ACE_HAS_FORE_ATM_XTI)
00077           // Reusing the address causes problems with FORE's API. The
00078           // issue may be that t_optmgmt isn't fully supported by
00079           // FORE. t_errno is TBADOPT after the t_optmgmt call so
00080           // maybe options are configured differently for XTI than for
00081           // TLI (at least for FORE's implementation - XTI is supposed
00082           // to be a superset of TLI).
00083           if (reuse_addr
00084               && new_stream.set_option (SOL_SOCKET,
00085                                         SO_REUSEADDR,
00086                                         &one,
00087                                         sizeof one) == -1)
00088             result = -1;
00089           else
00090 #endif /* ACE_HAS_FORE_ATM_XTI */
00091             {
00092               void *addr_buf = local_sap.get_addr ();
00093               localaddr->addr.len = local_sap.get_size ();
00094               ACE_OS::memcpy(localaddr->addr.buf,
00095                              addr_buf,
00096                              localaddr->addr.len);
00097 
00098               if (ACE_OS::t_bind (new_stream.get_handle (),
00099                                   localaddr,
00100                                   localaddr) == -1)
00101                 result = -1;
00102 
00103               ACE_OS::t_free ((char *) localaddr,
00104                               T_BIND);
00105             }
00106         }
00107 
00108       if (result == -1)
00109         {
00110           new_stream.close ();
00111           return -1;
00112         }
00113     }
00114   // Let TLI select the local endpoint addr.
00115   else if (ACE_OS::t_bind (new_stream.get_handle (), 0, 0) == -1)
00116     return -1;
00117 
00118   struct t_call *callptr = 0;
00119 
00120   callptr = (struct t_call *)
00121     ACE_OS::t_alloc (new_stream.get_handle (), T_CALL, T_ADDR);
00122 
00123   if (callptr == 0)
00124     {
00125       new_stream.close ();
00126       return -1;
00127     }
00128 
00129   void *addr_buf = remote_sap.get_addr ();
00130   callptr->addr.len = remote_sap.get_size ();
00131   ACE_OS::memcpy (callptr->addr.buf,
00132                   addr_buf,
00133                   callptr->addr.len);
00134   //callptr->addr.buf = (char *) remote_sap.get_addr ();
00135 
00136   if (udata != 0)
00137     ACE_OS::memcpy ((void *) &callptr->udata, (void *) udata, sizeof *udata);
00138   if (opt != 0)
00139     ACE_OS::memcpy ((void *) &callptr->opt, (void *) opt, sizeof *opt);
00140 
00141   // Connect to remote endpoint.
00142 #if defined (ACE_HAS_FORE_ATM_XTI)
00143   // FORE's XTI/ATM driver has problems with ioctl/fcntl calls so (at least
00144   // for now) always have blocking calls.
00145   timeout = 0;
00146 #endif /* ACE_HAS_FORE_ATM_XTI */
00147 
00148   if (timeout != 0)   // Enable non-blocking, if required.
00149     {
00150       if (new_stream.enable (ACE_NONBLOCK) == -1)
00151         result = -1;
00152 
00153       // Do a non-blocking connect.
00154       if (ACE_OS::t_connect (new_stream.get_handle (), callptr, 0) == -1)
00155         {
00156           result = -1;
00157 
00158           // Check to see if we simply haven't connected yet on a
00159           // non-blocking handle or whether there's really an error.
00160           if (t_errno == TNODATA)
00161             {
00162               if (timeout->sec () == 0 && timeout->usec () == 0)
00163                 errno = EWOULDBLOCK;
00164               else
00165                 result = this->complete (new_stream, 0, timeout);
00166             }
00167           else if (t_errno == TLOOK && new_stream.look () == T_DISCONNECT)
00168             new_stream.rcvdis ();
00169         }
00170     }
00171   // Do a blocking connect to the server.
00172   else if (ACE_OS::t_connect (new_stream.get_handle (), callptr, 0) == -1)
00173     result = -1;
00174 
00175   if (result != -1)
00176     {
00177       new_stream.set_rwflag (rwf);
00178 #if defined (I_PUSH) && !defined (ACE_HAS_FORE_ATM_XTI)
00179       if (new_stream.get_rwflag ())
00180         result = ACE_OS::ioctl (new_stream.get_handle (),
00181                                 I_PUSH,
00182                                 const_cast<char *> ("tirdwr"));
00183 #endif /* I_PUSH */
00184     }
00185   else if (!(errno == EWOULDBLOCK || errno == ETIME))
00186     {
00187       // If things have gone wrong, close down and return an error.
00188       new_stream.close ();
00189       new_stream.set_handle (ACE_INVALID_HANDLE);
00190     }
00191 
00192   if (ACE_OS::t_free ((char *) callptr, T_CALL) == -1)
00193     return -1;
00194   return result;
00195 }


Public Types
typedef ACE_INET_Addr	PEER_ADDR
typedef ACE_TLI_Stream	PEER_STREAM
Public Member Functions
	ACE_TLI_Connector (void)
	Default constructor.
	ACE_TLI_Connector (ACE_TLI_Stream &new_stream, const ACE_Addr &remote_sap, ACE_Time_Value timeout=0, const ACE_Addr &local_sap=ACE_Addr::sap_any, int reuse_addr=0, int flags=O_RDWR, int perms=0, const char device[]=ACE_TLI_TCP_DEVICE, struct t_info info=0, int rw_flag=1, struct netbuf udata=0, struct netbuf opt=0)
int	connect (ACE_TLI_Stream &new_stream, const ACE_Addr &remote_sap, ACE_Time_Value timeout=0, const ACE_Addr &local_sap=ACE_Addr::sap_any, int reuse_addr=0, int flags=O_RDWR, int perms=0, const char device[]=ACE_TLI_TCP_DEVICE, struct t_info info=0, int rw_flag=1, struct netbuf udata=0, struct netbuf opt=0)
int	complete (ACE_TLI_Stream &new_stream, ACE_Addr remote_sap, ACE_Time_Value tv)
int	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.

ACE_TLI_Connector Class Reference

Public Types

Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation