📄 transport.cpp
字号:
// Transport.cpp,v 5.24 2002/07/28 21:28:16 crodrigu Exp
#include "AVStreams_i.h"
#include "sfp.h"
#include "MCast.h"
#include "Nil.h"
#include "RTCP.h"
#include "RTP.h"
#include "UDP.h"
#include "TCP.h"
#include "FlowSpec_Entry.h"
#include "AV_Core.h"
#if defined (ACE_HAS_RAPI) || defined (ACE_HAS_WINSOCK2_GQOS)
#include "QoS_UDP.h"
#endif /* defined (ACE_HAS_RAPI) || defined (ACE_HAS_WINSOCK2_GQOS) */
#include "tao/debug.h"
#include "ace/Dynamic_Service.h"
#if !defined (__ACE_INLINE__)
#include "Transport.i"
#endif /* __ACE_INLINE__ */
//------------------------------------------------------------
// TAO_AV_Transport_Item
//------------------------------------------------------------
TAO_AV_Transport_Item::TAO_AV_Transport_Item (const ACE_CString &name)
: name_ (name),
factory_ (0)
{
}
//------------------------------------------------------------
// TAO_AV_Transport_Item
//------------------------------------------------------------
TAO_AV_Flow_Protocol_Item::TAO_AV_Flow_Protocol_Item (const ACE_CString &name)
: name_ (name),
factory_ (0)
{
}
//------------------------------------------------------------
// TAO_AV_Connector_Registry
//------------------------------------------------------------
TAO_AV_Connector_Registry::TAO_AV_Connector_Registry (void)
{
}
int
TAO_AV_Connector_Registry::open (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core* av_core,
TAO_AV_FlowSpecSet &flow_spec_set)
{
TAO_AV_FlowSpecSetItor last_flowspec = flow_spec_set.end ();
for (TAO_AV_FlowSpecSetItor flow_spec = flow_spec_set.begin ();
flow_spec != last_flowspec;
++flow_spec)
{
TAO_FlowSpec_Entry *entry = (*flow_spec);
ACE_Addr *address = entry->address ();
const char *flow_protocol = entry->flow_protocol_str ();
const char *transport_protocol = entry->carrier_protocol_str ();
if (ACE_OS::strcmp (flow_protocol,"") == 0)
flow_protocol = transport_protocol;
if (address == 0)
{
// Protocol was specified without an endpoint. According to
// the "iioploc" spec, this is valid. As such, we extend
// this feature to all pluggable protocols. All TAO
// pluggable protocols are expected to have the ability to
// create a default endpoint.
ACE_ERROR_RETURN ((LM_ERROR,
"Protocol was specified without an endpoint\n"),
-1);
}
else
{
TAO_AV_Flow_Protocol_Factory *flow_factory =
av_core->get_flow_protocol_factory (flow_protocol);
TAO_AV_Transport_Factory *transport_factory =
av_core->get_transport_factory (transport_protocol);
if ((flow_factory != 0) && (transport_factory != 0))
{
// @@Naga:Instead of making a new connector every time we should try and see if a connector exists
// for this transport already and hence we can reuse it.
TAO_AV_Connector *connector = transport_factory->make_connector ();
if (connector != 0)
{
// add connector to list.
this->connectors_.insert (connector);
if (connector->open (endpoint,
av_core,
flow_factory) == -1)
return -1;
TAO_AV_Transport *transport = 0;
if (connector->connect (entry,
transport,
TAO_AV_Core::TAO_AV_DATA) == -1)
return -1;
entry->transport (transport);
}
else
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Unable to create an "
"connector for <%s>\n",
entry->flowname ()),
-1);
// Now see if the flow factory has a control flow factory.
TAO_AV_Flow_Protocol_Factory *control_flow_factory =
av_core->get_flow_protocol_factory(flow_factory->control_flow_factory ());
if (control_flow_factory != 0)
{
TAO_AV_Connector *control_connector =
transport_factory->make_connector ();
if (control_connector != 0)
{
// add connector to list.
this->connectors_.insert (control_connector);
if (control_connector->open (endpoint,
av_core,
control_flow_factory) == -1)
return -1;
TAO_AV_Transport *control_transport = 0;
if (control_connector->connect (entry,
control_transport,
TAO_AV_Core::TAO_AV_CONTROL) == -1)
return -1;
entry->control_transport (control_transport);
// Now set the control object on the data flow object.
entry->protocol_object ()->control_object (entry->control_protocol_object ());
}
else
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Unable to create an "
"connector for <%s>\n",
entry->flowname ()),
-1);
}
}
}
}
return 0;
}
int
TAO_AV_Connector_Registry::close (TAO_AV_Connector *connector)
{
this->connectors_.remove (connector);
delete connector;
return 0;
}
int
TAO_AV_Connector_Registry::close_all (void)
{
for (TAO_AV_ConnectorSetItor i = this->connectors_.begin ();
i != this->connectors_.end ();
++i)
{
if (*i == 0)
continue;
(*i)->close ();
delete *i;
}
this->connectors_.reset ();
return 0;
}
TAO_AV_Connector_Registry::~TAO_AV_Connector_Registry (void)
{
this->close_all ();
}
//------------------------------------------------------------
// TAO_AV_Acceptor_Registry
//------------------------------------------------------------
TAO_AV_Acceptor_Registry::TAO_AV_Acceptor_Registry (void)
{
}
TAO_AV_Acceptor_Registry::~TAO_AV_Acceptor_Registry (void)
{
this->close_all();
}
int
TAO_AV_Acceptor_Registry::open (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core *av_core,
TAO_AV_FlowSpecSet &flow_spec_set)
{
int retv = 0;
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_AV_Acceptor_Registry::open \n"));
TAO_AV_FlowSpecSetItor last_flowspec
= flow_spec_set.end ();
for (TAO_AV_FlowSpecSetItor flow_spec = flow_spec_set.begin ();
flow_spec != last_flowspec;
++flow_spec)
{
TAO_FlowSpec_Entry *entry = (*flow_spec);
ACE_Addr *address = entry->address ();
const char *flow_protocol = entry->flow_protocol_str ();
const char *transport_protocol = entry->carrier_protocol_str ();
if (ACE_OS::strcmp (flow_protocol,"") == 0)
flow_protocol = transport_protocol;
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,
"TAO_AV_Acceptor_Registry::protocol for flow %s is %s\n",
entry->flowname (),
transport_protocol));
if (address == 0)
{
retv = this->open_default (endpoint,
av_core,
entry);
if(retv < 0)
return retv;
continue;
}
else
{
TAO_AV_Flow_Protocol_Factory *flow_factory =
av_core->get_flow_protocol_factory (flow_protocol);
if (flow_protocol != 0)
{
TAO_AV_Transport_Factory *transport_factory =
av_core->get_transport_factory (transport_protocol);
if (transport_protocol != 0)
{
TAO_AV_Acceptor *acceptor = transport_factory->make_acceptor ();
if (acceptor != 0)
{
// add acceptor to list.
this->acceptors_.insert (acceptor);
if (acceptor->open (endpoint,
av_core,
entry,
flow_factory,
TAO_AV_Core::TAO_AV_DATA) == -1)
return -1;
TAO_AV_Flow_Protocol_Factory *control_flow_factory =
av_core->get_flow_protocol_factory (flow_factory->control_flow_factory ());
if (control_flow_factory != 0)
{
TAO_AV_Acceptor *acceptor = transport_factory->make_acceptor ();
if (acceptor != 0)
{
if (acceptor->open (endpoint,
av_core,
entry,
control_flow_factory,
TAO_AV_Core::TAO_AV_CONTROL) == -1)
return -1;
// add acceptor to list.
this->acceptors_.insert (acceptor);
entry->protocol_object ()->control_object (entry->control_protocol_object ());
}
else
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Unable to create an "
"acceptor for <%s>\n",
entry->flowname ()),
-1);
}
}
else
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Unable to create an "
"acceptor for <%s>\n",
entry->flowname ()),
-1);
}
}
}
}
return 0;
}
int
TAO_AV_Acceptor_Registry::open_default (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core *av_core,
TAO_FlowSpec_Entry *entry)
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_AV_Acceptor_Registry::open_default "));
// No endpoints were specified, we let each protocol pick its own
// default...
const char *flow_protocol = entry->flow_protocol_str ();
const char *transport_protocol = entry->carrier_protocol_str ();
if (ACE_OS::strcmp (flow_protocol,"") == 0)
flow_protocol = transport_protocol;
TAO_AV_Flow_Protocol_Factory *flow_factory =
av_core->get_flow_protocol_factory (flow_protocol);
// No matching flow protocol.
if (flow_factory == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"TAO (%P|%t) (%N,%l) Unable to match protocol prefix "
"for <%s>\n",
flow_protocol),
-1);
if (TAO_debug_level > 0)
ACE_DEBUG((LM_DEBUG, "(%N,%l) Matched flow_protocol: %s, Looking for transport protocol: %s\n", flow_protocol, transport_protocol));
TAO_AV_Transport_Factory *transport_factory =
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -