📄 flowspec_entry.cpp
字号:
break;
default:
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"ATM support not added yet\n"));
}
}
else
{
ACE_DEBUG ((LM_DEBUG,
"AV BOTH %s \n",
protocol_tokenizer[1]));
TAO_Tokenizer address_tokenizer (protocol_tokenizer[1], ':');
TAO_Tokenizer port_tokenizer (address_tokenizer[1], ';');
ACE_CString addr;
addr += address_tokenizer[0];
addr += ":";
addr += port_tokenizer[0];
if (this->protocol_ == TAO_AV_Core::TAO_AV_SCTP_SEQ)
{
ACE_DEBUG ((LM_DEBUG,
"Number of local sec addresses = %d\n",
port_tokenizer.num_tokens () - 1));
if (port_tokenizer.num_tokens () - 1 != 0)
{
ACE_NEW_RETURN (local_sec_addr_, char* [port_tokenizer.num_tokens () - 1],-1);
for (int j = 1; j <= port_tokenizer.num_tokens () - 1; j++)
{
ACE_DEBUG ((LM_DEBUG,
"adding addresses to sequence %s\n",
port_tokenizer [j]));
local_sec_addr_ [j-1] = CORBA::string_dup (port_tokenizer [j]);
}
num_local_sec_addrs_ = port_tokenizer.num_tokens () - 1;
}
}
short control_port = ACE_OS::atoi(port_tokenizer[0]) + 1;
char control_port_str[6];
sprintf (control_port_str, "%d", control_port);
ACE_CString control_addr = "";
if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"RTP/UDP") == 0)
{
control_addr += address_tokenizer[0];
control_addr += ":";
if (port_tokenizer[1] != 0)
control_addr += port_tokenizer[1];
else
control_addr += control_port_str;
}
switch (this->protocol_)
{
case TAO_AV_Core::TAO_AV_SFP_UDP:
case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
case TAO_AV_Core::TAO_AV_RTP_UDP:
case TAO_AV_Core::TAO_AV_TCP:
case TAO_AV_Core::TAO_AV_SCTP_SEQ:
case TAO_AV_Core::TAO_AV_UDP:
case TAO_AV_Core::TAO_AV_QOS_UDP:
{
this->address_str_ = addr;
ACE_INET_Addr *inet_addr;
ACE_NEW_RETURN (inet_addr,
ACE_INET_Addr (addr.c_str() ),
-1);
this->clean_up_address_ = 1;
this->address_ = inet_addr;
if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"RTP/UDP") == 0)
{
ACE_INET_Addr *control_inet_addr;
ACE_NEW_RETURN (control_inet_addr,
ACE_INET_Addr (control_addr.c_str() ),
-1);
this->clean_up_control_address_ = 1;
this->control_address_ = control_inet_addr;
}
if (IN_CLASSD (inet_addr->get_ip_address ()))
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG, "TAO_FlowSpec_Entry::parse_address is multicast\n"));
this->is_multicast_ = 1;
switch (this->protocol_)
{
case TAO_AV_Core::TAO_AV_UDP:
this->protocol_ = TAO_AV_Core::TAO_AV_UDP_MCAST;
break;
case TAO_AV_Core::TAO_AV_RTP_UDP:
this->protocol_ = TAO_AV_Core::TAO_AV_RTP_UDP_MCAST;
break;
case TAO_AV_Core::TAO_AV_SFP_UDP:
this->protocol_ = TAO_AV_Core::TAO_AV_SFP_UDP_MCAST;
break;
case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
this->protocol_ = TAO_AV_Core::TAO_AV_USERDEFINED_UDP_MCAST;
break;
default:
break;
}
}
}
break;
default:
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"ATM support not added yet\n"));
}
}
}
ACE_DEBUG ((LM_DEBUG,
"Return from parse address\n"));
return 0;
}
char *
TAO_FlowSpec_Entry::get_local_addr_str (void)
{
if (this->local_addr_ == 0)
return 0;
switch (this->local_addr_->get_type ())
{
case AF_INET:
{
char *buf;
ACE_NEW_RETURN (buf,
char [BUFSIZ],
0);
ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr *,this->local_addr_);
inet_addr->addr_to_string (buf,BUFSIZ);
ACE_CString cstring (buf, 0, 0);
return cstring.rep ();
}
default:
ACE_ERROR_RETURN ((LM_ERROR,"Address family not supported"),0);
}
}
//------------------------------------------------------------
// TAO_Forward_FlowSpec_Entry
//------------------------------------------------------------
// default constructor.
TAO_Forward_FlowSpec_Entry::TAO_Forward_FlowSpec_Entry (void)
{
// no-op.
}
// constructor to construct the entry from the arguments.
TAO_Forward_FlowSpec_Entry::TAO_Forward_FlowSpec_Entry (const char *flowname,
const char *direction,
const char *format_name ,
const char *flow_protocol ,
const char *carrier_protocol ,
ACE_Addr *address,
ACE_Addr *control_address )
:TAO_FlowSpec_Entry (flowname,
direction,
format_name,
flow_protocol,
carrier_protocol,
address,
control_address)
{
// no-op.
}
// constructor to construct the entry from the arguments.
TAO_Forward_FlowSpec_Entry::TAO_Forward_FlowSpec_Entry (const char *flowname,
const char *direction,
const char *format_name ,
const char *flow_protocol ,
const char *address )
:TAO_FlowSpec_Entry (flowname,
direction,
format_name,
flow_protocol,
address)
{
// no-op.
}
TAO_Forward_FlowSpec_Entry::~TAO_Forward_FlowSpec_Entry (void)
{
// no-op.
}
int
TAO_Forward_FlowSpec_Entry::parse (const char *flowSpec_entry)
{
TAO_Tokenizer tokenizer (flowSpec_entry,'\\');
this->flowname_ = tokenizer [TAO_AV_FLOWNAME];
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"TAO_Forward_FlowSpec_Entry::parse %s\n",
flowSpec_entry));
if (tokenizer [TAO_AV_DIRECTION] != 0)
this->set_direction (tokenizer [TAO_AV_DIRECTION]);
if (tokenizer [TAO_AV_FORMAT] != 0)
this->format_ = tokenizer [TAO_AV_FORMAT];
if (tokenizer [TAO_AV_ADDRESS] != 0)
if (this->parse_address (tokenizer [TAO_AV_ADDRESS], TAO_AV_Core::TAO_AV_BOTH) < 0)
return -1;
if (tokenizer [TAO_AV_PEER_ADDR] != 0)
{
ACE_INET_Addr *addr = 0;
if (this->protocol_ == TAO_AV_Core::TAO_AV_SCTP_SEQ)
{
TAO_Tokenizer addr_token (tokenizer [TAO_AV_PEER_ADDR], ';');
ACE_DEBUG ((LM_DEBUG,
"Number of peer sec addresses = %d\n",
addr_token.num_tokens () - 1));
if (addr_token.num_tokens () != 0)
{
ACE_NEW_RETURN (addr,
ACE_INET_Addr (addr_token [0]),
0);
ACE_NEW_RETURN (peer_sec_addr_, char* [addr_token.num_tokens () - 1],-1);
for (int j = 1; j <= addr_token.num_tokens () - 1; j++)
{
ACE_DEBUG ((LM_DEBUG,
"adding addresses to sequence %s\n",
addr_token [j]));
peer_sec_addr_ [j-1] = CORBA::string_dup (addr_token [j]);
}
num_peer_sec_addrs_ = addr_token.num_tokens () - 1;
}
}
else
{
ACE_NEW_RETURN (addr,
ACE_INET_Addr (tokenizer [TAO_AV_PEER_ADDR]),
0);
}
this->peer_addr_ = addr;
char buf [BUFSIZ];
addr->addr_to_string (buf, BUFSIZ);
ACE_DEBUG ((LM_DEBUG,
"Peer Address %s \n",
buf));
}
if (tokenizer [TAO_AV_FLOW_PROTOCOL] != 0)
if (this->parse_flow_protocol_string (tokenizer [TAO_AV_FLOW_PROTOCOL]) < 0)
return -1;
return 0;
}
TAO_FlowSpec_Entry::Role
TAO_Forward_FlowSpec_Entry::role (void)
{
if (this->role_ != TAO_AV_INVALID_ROLE)
return this->role_;
switch (this->direction_)
{
case TAO_AV_DIR_IN:
// Forward IN means we're the Source.
return TAO_AV_PRODUCER;
case TAO_AV_DIR_OUT:
// Forward out means we're the sink.
return TAO_AV_CONSUMER;
default:
return TAO_AV_INVALID_ROLE;
}
}
const char *
TAO_Forward_FlowSpec_Entry::entry_to_string (void)
{
if (this->flowname_.length() == 0)
return "";
char address [BUFSIZ];
ACE_CString address_str;
ACE_CString peer_address_str;
if (this->address_ != 0)
{
switch (this->protocol_)
{
case TAO_AV_Core::TAO_AV_SFP_UDP:
case TAO_AV_Core::TAO_AV_SFP_UDP_MCAST:
case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
case TAO_AV_Core::TAO_AV_USERDEFINED_UDP_MCAST:
case TAO_AV_Core::TAO_AV_RTP_UDP:
case TAO_AV_Core::TAO_AV_RTP_UDP_MCAST:
case TAO_AV_Core::TAO_AV_UDP:
case TAO_AV_Core::TAO_AV_QOS_UDP:
case TAO_AV_Core::TAO_AV_UDP_MCAST:
case TAO_AV_Core::TAO_AV_TCP:
case TAO_AV_Core::TAO_AV_SCTP_SEQ:
{
ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr*,this->address_);
inet_addr->addr_to_string (address,BUFSIZ);
}
break;
default:
break;
}
ACE_CString cstring (address);
address_str = this->carrier_protocol_;
address_str += "=";
address_str += cstring;
if (this->protocol_ == TAO_AV_Core::TAO_AV_SCTP_SEQ)
{
for (int i = 0; i < this->num_local_sec_addrs_; i++)
{
address_str += ";";
address_str += this->local_sec_addr_ [i];
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -