int
ACE_TLI_Acceptor::accept (ACE_TLI_Stream &new_tli_sap,
ACE_Addr *remote_addr,
ACE_Time_Value *timeout,
bool restart,
bool reset_new_handle,
int rwf,
netbuf *udata,
netbuf *opt)
{
ACE_TRACE ("ACE_TLI_Acceptor::accept");
ACE_UNUSED_ARG (reset_new_handle);
ACE_TLI_Request *req = 0;
int res = 0;
if (timeout != 0
&& ACE::handle_timed_accept (this->get_handle (),
timeout,
restart) == -1)
return -1;
else if (this->queue_->is_empty ())
{
req = this->queue_->alloc ();
do
res = ACE_OS::t_listen (this->get_handle (),
req->callp_);
while (res == -1
&& restart
&& errno == EINTR);
if (res != -1)
{
req->handle_ = open_new_endpoint (this->get_handle (),
this->device_,
req->callp_,
rwf
#if defined (ACE_WIN32)
, remote_addr
#endif /* ACE_WIN32 */
);
if (req->handle_ == ACE_INVALID_HANDLE)
res = -1;
else
res = 0;
}
}
else
res = this->queue_->dequeue (req);
if (udata != 0)
ACE_OS::memcpy ((void *) &req->callp_->udata,
(void *) udata,
sizeof *udata);
if (opt != 0)
ACE_OS::memcpy ((void *) &req->callp_->opt,
(void *) opt,
sizeof *opt);
while (res != -1)
{
res = ACE_OS::t_accept (this->get_handle (),
req->handle_,
req->callp_);
if (res != -1)
break; // Got one!
else if (t_errno == TLOOK)
res = this->handle_async_event (restart, rwf);
else if (restart && t_errno == TSYSERR && errno == EINTR)
res = 0;
}
if (res == -1)
{
if (errno != EWOULDBLOCK)
{
new_tli_sap.set_handle (ACE_INVALID_HANDLE);
if (req->handle_ != ACE_INVALID_HANDLE)
ACE_OS::t_close (req->handle_);
}
}
else
{
new_tli_sap.set_handle (req->handle_);
if (remote_addr != 0)
remote_addr->set_addr ((void *) req->callp_->addr.buf,
req->callp_->addr.len);
}
req->handle_ = ACE_INVALID_HANDLE;
this->queue_->free (req);
new_tli_sap.set_rwflag (rwf);
return new_tli_sap.get_handle () == ACE_INVALID_HANDLE ? -1 : 0;
}
int
ACE_TLI_Connector::connect (ACE_TLI_Stream &new_stream,
const ACE_Addr &remote_sap,
ACE_Time_Value *timeout,
const ACE_Addr &local_sap,
int reuse_addr,
int flags,
int /* perms */,
const char device[],
struct t_info *info,
int rwf,
struct netbuf *udata,
struct netbuf *opt)
{
ACE_TRACE ("ACE_TLI_Connector::connect");
int result = 0;
// Only open a new endpoint if we don't already have a valid handle.
if (new_stream.get_handle () == ACE_INVALID_HANDLE
&& new_stream.open (device, flags, info) == ACE_INVALID_HANDLE)
return -1;
if (local_sap != ACE_Addr::sap_any)
{
// Bind the local endpoint to a specific addr.
struct t_bind *localaddr;
localaddr = (struct t_bind *)
ACE_OS::t_alloc (new_stream.get_handle (), T_BIND, T_ADDR);
if (localaddr == 0)
result = -1;
else
{
int one = 1;
#if !defined (ACE_HAS_FORE_ATM_XTI)
// Reusing the address causes problems with FORE's API. The
// issue may be that t_optmgmt isn't fully supported by
// FORE. t_errno is TBADOPT after the t_optmgmt call so
// maybe options are configured differently for XTI than for
// TLI (at least for FORE's implementation - XTI is supposed
// to be a superset of TLI).
if (reuse_addr
&& new_stream.set_option (SOL_SOCKET,
SO_REUSEADDR,
&one,
sizeof one) == -1)
result = -1;
else
#endif /* ACE_HAS_FORE_ATM_XTI */
{
void *addr_buf = local_sap.get_addr ();
localaddr->addr.len = local_sap.get_size ();
ACE_OS::memcpy(localaddr->addr.buf,
addr_buf,
localaddr->addr.len);
if (ACE_OS::t_bind (new_stream.get_handle (),
localaddr,
localaddr) == -1)
result = -1;
ACE_OS::t_free ((char *) localaddr,
T_BIND);
}
}
if (result == -1)
{
new_stream.close ();
return -1;
}
}
// Let TLI select the local endpoint addr.
else if (ACE_OS::t_bind (new_stream.get_handle (), 0, 0) == -1)
return -1;
struct t_call *callptr = 0;
callptr = (struct t_call *)
ACE_OS::t_alloc (new_stream.get_handle (), T_CALL, T_ADDR);
if (callptr == 0)
{
new_stream.close ();
return -1;
}
void *addr_buf = remote_sap.get_addr ();
callptr->addr.len = remote_sap.get_size ();
ACE_OS::memcpy (callptr->addr.buf,
addr_buf,
callptr->addr.len);
//callptr->addr.buf = (char *) remote_sap.get_addr ();
if (udata != 0)
ACE_OS::memcpy ((void *) &callptr->udata, (void *) udata, sizeof *udata);
if (opt != 0)
ACE_OS::memcpy ((void *) &callptr->opt, (void *) opt, sizeof *opt);
// Connect to remote endpoint.
#if defined (ACE_HAS_FORE_ATM_XTI)
// FORE's XTI/ATM driver has problems with ioctl/fcntl calls so (at least
// for now) always have blocking calls.
timeout = 0;
#endif /* ACE_HAS_FORE_ATM_XTI */
if (timeout != 0) // Enable non-blocking, if required.
{
if (new_stream.enable (ACE_NONBLOCK) == -1)
result = -1;
// Do a non-blocking connect.
if (ACE_OS::t_connect (new_stream.get_handle (), callptr, 0) == -1)
{
result = -1;
// Check to see if we simply haven't connected yet on a
// non-blocking handle or whether there's really an error.
if (t_errno == TNODATA)
{
if (*timeout == ACE_Time_Value::zero)
errno = EWOULDBLOCK;
else
result = this->complete (new_stream, 0, timeout);
}
else if (t_errno == TLOOK && new_stream.look () == T_DISCONNECT)
new_stream.rcvdis ();
}
}
// Do a blocking connect to the server.
else if (ACE_OS::t_connect (new_stream.get_handle (), callptr, 0) == -1)
result = -1;
if (result != -1)
{
new_stream.set_rwflag (rwf);
#if defined (I_PUSH) && !defined (ACE_HAS_FORE_ATM_XTI)
if (new_stream.get_rwflag ())
result = ACE_OS::ioctl (new_stream.get_handle (),
I_PUSH,
const_cast<char *> ("tirdwr"));
#endif /* I_PUSH */
}
else if (!(errno == EWOULDBLOCK || errno == ETIME))
{
// If things have gone wrong, close down and return an error.
new_stream.close ();
new_stream.set_handle (ACE_INVALID_HANDLE);
}
if (ACE_OS::t_free ((char *) callptr, T_CALL) == -1)
return -1;
return result;
}