📄 sctp_seq.cpp
字号:
// SCTP_SEQ.cpp,v 1.3 2003/11/05 21:06:53 yamuna Exp
#include "SCTP_SEQ.h"
#include "AVStreams_i.h"
#include "ace/Multihomed_INET_Addr.h"
#include "tao/debug.h"
#include "ace/Arg_Shifter.h"
ACE_RCSID (AV,
SCTP_SEQ,
"SCTP_SEQ.cpp,v 1.3 2003/11/05 21:06:53 yamuna Exp")
//------------------------------------------------------------
// TAO_AV_SCTP_SEQ_Transport
//------------------------------------------------------------
TAO_AV_SCTP_SEQ_Transport::TAO_AV_SCTP_SEQ_Transport (void)
:handler_ (0)
{
}
TAO_AV_SCTP_SEQ_Transport::TAO_AV_SCTP_SEQ_Transport (TAO_AV_SCTP_SEQ_Flow_Handler *handler)
:handler_ (handler)
{
}
TAO_AV_SCTP_SEQ_Transport::~TAO_AV_SCTP_SEQ_Transport (void)
{
}
int
TAO_AV_SCTP_SEQ_Transport::open (ACE_Addr * /*address*/)
{
return 0;
}
int
TAO_AV_SCTP_SEQ_Transport::close (void)
{
return 0;
}
int
TAO_AV_SCTP_SEQ_Transport::mtu (void)
{
return 0;
}
ACE_Addr*
TAO_AV_SCTP_SEQ_Transport::get_peer_addr (void)
{
return 0;
}
ssize_t
TAO_AV_SCTP_SEQ_Transport::send (const ACE_Message_Block *mblk, ACE_Time_Value *)
{
// For the most part this was copied from GIOP::send_request and
// friends.
// ACE_Time_Value timeout;
iovec iov[ACE_IOV_MAX];
int iovcnt = 0;
ssize_t n = 0;
ssize_t nbytes = 0;
for (const ACE_Message_Block *i = mblk;
i != 0;
i = i->cont ())
{
// Make sure there is something to send!
if (i->length () > 0)
{
iov[iovcnt].iov_base = i->rd_ptr ();
iov[iovcnt].iov_len = ACE_static_cast (u_long, i->length ());
iovcnt++;
// The buffer is full make a OS call. @@ TODO this should
// be optimized on a per-platform basis, for instance, some
// platforms do not implement writev() there we should copy
// the data into a buffer and call send_n(). In other cases
// there may be some limits on the size of the iovec, there
// we should set ACE_IOV_MAX to that limit.
if (iovcnt == ACE_IOV_MAX)
{
n = this->handler_->peer ().sendv_n ((const iovec *) iov,
iovcnt);
//&timeout);
if (n < 1)
return n;
nbytes += n;
iovcnt = 0;
}
}
}
// Check for remaining buffers to be sent!
if (iovcnt != 0)
{
n = this->handler_->peer ().sendv_n ((const iovec *) iov,
iovcnt);
if (n < 1)
return n;
nbytes += n;
}
return nbytes;
}
ssize_t
TAO_AV_SCTP_SEQ_Transport::send (const char *buf,
size_t len,
ACE_Time_Value *)
{
return this->handler_->peer ().send_n (buf, len);
}
ssize_t
TAO_AV_SCTP_SEQ_Transport::send (const iovec *iov,
int iovcnt,
ACE_Time_Value *)
{
return this->handler_->peer ().sendv_n (iov,
iovcnt);
}
ssize_t
TAO_AV_SCTP_SEQ_Transport::recv (char *buf,
size_t len,
ACE_Time_Value *)
{
return this->handler_->peer ().recv (buf, len);
}
ssize_t
TAO_AV_SCTP_SEQ_Transport::recv (char *buf,
size_t len,
int flags,
ACE_Time_Value *)
{
return this->handler_->peer ().recv (buf,
len,
flags);
}
ssize_t
TAO_AV_SCTP_SEQ_Transport::recv (iovec *iov,
int iovcnt,
ACE_Time_Value *)
{
return handler_->peer ().recvv_n (iov, iovcnt);
}
//------------------------------------------------------------
// TAO_AV_SCTP_SEQ_Base_Acceptor
//------------------------------------------------------------
int
TAO_AV_SCTP_SEQ_Base_Acceptor::acceptor_open (TAO_AV_SCTP_SEQ_Acceptor *acceptor,
ACE_Reactor *reactor,
const ACE_INET_Addr &local_addr,
TAO_FlowSpec_Entry *entry)
{
ACE_DEBUG ((LM_DEBUG,
"In base acceptor open"));
this->acceptor_ = acceptor;
this->reactor_ = reactor;
this->entry_ = entry;
ACE_UINT32 local_ip_addr [entry->num_local_sec_addrs ()];
ACE_INET_Addr ip_addr;
char** addrs = entry->get_local_sec_addr ();
for (int i = 0; i < entry->num_local_sec_addrs (); i++)
{
ACE_CString addr_str (addrs[i]);
addr_str += ":";
ip_addr.set (addr_str.c_str ());
local_ip_addr [i] = ip_addr.get_ip_address ();
}
ACE_Multihomed_INET_Addr multi_addr;
multi_addr.set (local_addr.get_port_number (),
local_addr.get_ip_address (),
1,
local_ip_addr,
entry->num_local_sec_addrs ());
int result = this->open (multi_addr,reactor);
if (result < 0)
ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_Base_Acceptor::open failed\n"),-1);
return 0;
}
int
TAO_AV_SCTP_SEQ_Base_Acceptor::make_svc_handler (TAO_AV_SCTP_SEQ_Flow_Handler *&handler)
{
int result = this->acceptor_->make_svc_handler (handler);
if (result < 0)
return result;
handler->reactor (this->reactor_);
this->entry_->handler (handler);
return 0;
}
//------------------------------------------------------------
// TAO_AV_SCTP_SEQ_Acceptor
//------------------------------------------------------------
TAO_AV_SCTP_SEQ_Acceptor::TAO_AV_SCTP_SEQ_Acceptor (void)
{
}
TAO_AV_SCTP_SEQ_Acceptor::~TAO_AV_SCTP_SEQ_Acceptor (void)
{
}
int
TAO_AV_SCTP_SEQ_Acceptor::make_svc_handler (TAO_AV_SCTP_SEQ_Flow_Handler *&sctp_handler)
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_AV_SCTP_SEQ_Acceptor::make_svc_handler\n"
));
if (this->endpoint_ != 0)
{
ACE_NEW_RETURN (sctp_handler,
TAO_AV_SCTP_SEQ_Flow_Handler,
-1);
TAO_AV_Protocol_Object *object =
this->flow_protocol_factory_->make_protocol_object (this->entry_,
this->endpoint_,
sctp_handler,
sctp_handler->transport ());
sctp_handler->protocol_object (object);
this->endpoint_->set_flow_handler (this->flowname_.c_str (),sctp_handler);
this->entry_->protocol_object (object);
this->entry_->handler (sctp_handler);
}
return 0;
}
int
TAO_AV_SCTP_SEQ_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core *av_core,
TAO_FlowSpec_Entry *entry,
TAO_AV_Flow_Protocol_Factory *factory,
TAO_AV_Core::Flow_Component flow_comp)
{
this->flow_protocol_factory_ = factory;
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_AV_SCTP_SEQ_Acceptor::open "));
this->av_core_ = av_core;
this->endpoint_ = endpoint;
this->entry_ = entry;
if (flow_comp == TAO_AV_Core::TAO_AV_CONTROL)
this->flowname_ = TAO_AV_Core::get_control_flowname (entry->flowname ());
else
this->flowname_ = entry->flowname ();
ACE_Addr *address = entry->address ();
ACE_INET_Addr *inet_addr = (ACE_INET_Addr *) address;
inet_addr->set (inet_addr->get_port_number (),
inet_addr->get_host_name ());
char buf[BUFSIZ];
inet_addr->addr_to_string (buf,
BUFSIZ);
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_AV_SCTP_SEQ_Acceptor::open: %s",
buf
));
//Add code for reading multihomed addresses and pass the multihomed
//addr to the following method. ACE_Multihomed_addr derives from
//ACE_INET_Addr, hence this should not be an issue.
int result = this->acceptor_.acceptor_open (this,
av_core->reactor (),
*inet_addr,
entry);
if (result < 0)
ACE_ERROR_RETURN ((LM_ERROR,
"TAO_AV_SCTP_SEQ_Acceptor::open failed"),
-1);
entry->set_local_addr (address);
return 0;
}
int
TAO_AV_SCTP_SEQ_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core *av_core,
TAO_FlowSpec_Entry *entry,
TAO_AV_Flow_Protocol_Factory *factory,
TAO_AV_Core::Flow_Component flow_comp)
{
this->flow_protocol_factory_ = factory;
this->av_core_ = av_core;
this->endpoint_ = endpoint;
this->entry_ = entry;
if (flow_comp == TAO_AV_Core::TAO_AV_CONTROL)
this->flowname_ = TAO_AV_Core::get_control_flowname (entry->flowname());
else
this->flowname_ = entry->flowname ();
ACE_INET_Addr *address;
ACE_NEW_RETURN (address,
ACE_INET_Addr ("0"),
-1);
int result = this->acceptor_.acceptor_open (this,
av_core->reactor (),
*address,
entry);
if (result < 0)
ACE_ERROR_RETURN ((LM_ERROR,
"TAO_AV_SCTP_SEQ_Acceptor::open failed"),
-1);
this->acceptor_.acceptor ().get_local_addr (*address);
address->set (address->get_port_number (),
address->get_host_name ());
char buf[BUFSIZ];
address->addr_to_string (buf,BUFSIZ);
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_AV_SCTP_SEQ_Acceptor::open_default: %s\n",
buf));
entry->set_local_addr (address);
return 0;
}
int
TAO_AV_SCTP_SEQ_Acceptor::close (void)
{
return 0;
}
//------------------------------------------------------------
// TAO_AV_SCTP_SEQ_Base_Connector
//------------------------------------------------------------
int
TAO_AV_SCTP_SEQ_Base_Connector::connector_open (TAO_AV_SCTP_SEQ_Connector *connector,
ACE_Reactor *reactor)
{
this->connector_ = connector;
this->reactor_ = reactor;
int result = this->open (reactor);
if (result < 0)
ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_Base_Connector::open failed\n"),-1);
return 0;
}
int
TAO_AV_SCTP_SEQ_Base_Connector::make_svc_handler (TAO_AV_SCTP_SEQ_Flow_Handler *&sctp_handler)
{
int result =
this->connector_->make_svc_handler (sctp_handler);
if (result < 0)
return result;
sctp_handler->reactor (this->reactor_);
return 0;
}
int
TAO_AV_SCTP_SEQ_Base_Connector::connector_connect (TAO_AV_SCTP_SEQ_Flow_Handler *&handler,
const ACE_Multihomed_INET_Addr &remote_addr,
const ACE_Multihomed_INET_Addr &local_addr)
{
int result = this->connect (handler,
remote_addr,
0,
local_addr);
if (result < 0)
ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_Base_Connector::connect failed\n"),-1);
return 0;
}
//------------------------------------------------------------
// TAO_AV_SCTP_SEQ_Connector
//------------------------------------------------------------
TAO_AV_SCTP_SEQ_Connector::TAO_AV_SCTP_SEQ_Connector (void)
{
}
TAO_AV_SCTP_SEQ_Connector::~TAO_AV_SCTP_SEQ_Connector (void)
{
}
int
TAO_AV_SCTP_SEQ_Connector::make_svc_handler (TAO_AV_SCTP_SEQ_Flow_Handler *&sctp_handler)
{
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_SCTP_SEQ_Connector::make_svc_handler\n"));
// TAO_AV_Callback *callback = 0;
if (this->endpoint_ != 0)
{
// this->endpoint_->get_callback (this->flowname_.c_str (),
// callback);
ACE_NEW_RETURN (sctp_handler,
// TAO_AV_SCTP_SEQ_Flow_Handler (callback),
TAO_AV_SCTP_SEQ_Flow_Handler,
-1);
TAO_AV_Protocol_Object *object =
this->flow_protocol_factory_->make_protocol_object (this->entry_,
this->endpoint_,
sctp_handler,
sctp_handler->transport ());
sctp_handler->protocol_object (object);
// callback->protocol_object (object);
// this->endpoint_->set_protocol_object (this->flowname_.c_str (),
// object);
this->endpoint_->set_flow_handler (this->flowname_.c_str (),sctp_handler);
this->entry_->protocol_object (object);
this->entry_->handler (sctp_handler);
}
return 0;
}
int
TAO_AV_SCTP_SEQ_Connector::open (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core *av_core,
TAO_AV_Flow_Protocol_Factory *factory)
{
this->endpoint_ = endpoint;
this->flow_protocol_factory_ = factory;
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_SCTP_SEQ_Connector::open "));
int result = this->connector_.connector_open(this,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -