TAO_FlowSpec_Entry Class Reference

A helper entry class in the flow spec sequence passed to bind_devs. More...

#include <FlowSpec_Entry.h>

Inheritance diagram for TAO_FlowSpec_Entry:

[legend]Collaboration diagram for TAO_FlowSpec_Entry:


Public Types
	TAO_AV_INVALID = -1
	TAO_AV_DIR_IN = 0
	TAO_AV_DIR_OUT = 1
	TAO_AV_INVALID_ROLE = -1
	TAO_AV_PRODUCER = 0
	TAO_AV_CONSUMER = 1
enum	Direction { TAO_AV_INVALID = -1, TAO_AV_DIR_IN = 0, TAO_AV_DIR_OUT = 1 }
enum	Role { TAO_AV_INVALID_ROLE = -1, TAO_AV_PRODUCER = 0, TAO_AV_CONSUMER = 1 }
Public Member Functions
	TAO_FlowSpec_Entry (void)
	default constructor.
	TAO_FlowSpec_Entry (const char flowname, const char direction, const char format_name, const char flow_protocol, const char carrier_protocol, ACE_Addr fwd_address, ACE_Addr *control_address=0)
	constructor to construct an entry from the arguments.
	TAO_FlowSpec_Entry (const char flowname, const char direction, const char format_name, const char flow_protocol, const char *fwd_address)
virtual int	parse (const char *flowSpec_entry)=0
	construct the entry from a string specified by the flowSpec grammar.
virtual	~TAO_FlowSpec_Entry (void)
	virtual destructor.
int	direction (void)
	accessor to the direction.
virtual Role	role (void)=0
void	role (Role role)
const char *	direction_str (void) const
	accessor to string version of direction .
const char *	flow_protocol_str (void) const
	accessor to the flow protocol string.
void	flow_protocol_str (const char *flow_protocol_str)
	set the flow protocol string.
ACE_Addr *	address (void)
	accessor to address of the carrier protocol.
ACE_Addr *	control_address (void)
void	address (ACE_Addr *address, bool cleanup=false)
void	control_address (ACE_Addr *address)
const char *	address_str (void) const
	Address in string format i. hostname:port.
TAO_AV_Core::Protocol	carrier_protocol (void)
	accessor to carrier protocol i.e TCP,UDP,RTP/UDP.
const char *	carrier_protocol_str (void) const
	accessor to string version of carrier protocol.
const char *	format (void) const
	accessor to format to be used for this flow.
const char *	flowname (void) const
	accessor to name of this flow.
virtual const char *	entry_to_string (void)=0
	converts the entry to a string.
int	set_peer_addr (ACE_Addr *peer_addr)
ACE_Addr *	get_peer_addr (void)
int	set_peer_control_addr (ACE_Addr *peer_control_addr)
ACE_Addr *	get_peer_control_addr (void)
int	set_local_sec_addr (char **local_sec_addr, int size)
char **	get_local_sec_addr (void)
int	num_local_sec_addrs (void)
int	set_peer_sec_addr (char **peer_sec_addr, int size)
char **	get_peer_sec_addr (void)
int	num_peer_sec_addrs (void)
int	set_local_addr (ACE_Addr *local_addr)
ACE_Addr *	get_local_addr (void)
char *	get_local_addr_str (void)
int	set_local_control_addr (ACE_Addr *local_control_addr)
ACE_Addr *	get_local_control_addr (void)
char *	get_local_control_addr_str (void)
TAO_AV_Transport *	transport (void)
void	transport (TAO_AV_Transport *transport)
TAO_AV_Transport *	control_transport (void)
void	control_transport (TAO_AV_Transport *control_transport)
TAO_AV_Flow_Handler *	handler (void)
void	handler (TAO_AV_Flow_Handler *handler)
TAO_AV_Flow_Handler *	control_handler (void)
void	control_handler (TAO_AV_Flow_Handler *control_handler)
TAO_AV_Protocol_Object *	protocol_object (void)
void	protocol_object (TAO_AV_Protocol_Object *object)
TAO_AV_Protocol_Object *	control_protocol_object (void)
void	control_protocol_object (TAO_AV_Protocol_Object *object)
int	parse_address (const char *format_string, TAO_AV_Core::Flow_Component flow_component)
	sets the address for this flow.
int	is_multicast (void)
	returns true for a multicast address.
Protected Member Functions
int	parse_flow_protocol_string (const char *flow_options_string)
	parses the flow protocol string with tokens separated by :
int	set_direction (const char *direction_string)
	sets the direction flag.
int	set_protocol (void)
	sets the protocol_ enum from the carrier_protocol_ string.
Protected Attributes
ACE_Addr *	address_
	Addr information for the carrier protocol.
int	clean_up_address_
ACE_Addr *	control_address_
int	clean_up_control_address_
ACE_CString	address_str_
	Fwd Addr in string format i.e hostname:port.
ACE_CString	peer_address_str_
	Peer Addr in string format i.e hostname:port.
ACE_CString	format_
	format string.
Direction	direction_
	Direction of this flow.
ACE_CString	direction_str_
	string representation of the direction.
ACE_CString	flowname_
	name of this flow.
TAO_AV_Core::Protocol	protocol_
	name of the protocol used.
ACE_CString	carrier_protocol_
	carrier protocol string.
ACE_CString	flow_protocol_
	flow protocol string.
int	use_flow_protocol_
ACE_CString	entry_
	The flowspec entry;.
int	is_multicast_
bool	delete_peer_addr_
ACE_Addr *	peer_addr_
char **	local_sec_addr_
int	num_local_sec_addrs_
char **	peer_sec_addr_
int	num_peer_sec_addrs_
ACE_Addr *	peer_control_addr_
ACE_Addr *	local_addr_
ACE_Addr *	local_control_addr_
TAO_AV_Transport *	transport_
TAO_AV_Transport *	control_transport_
TAO_AV_Flow_Handler *	handler_
TAO_AV_Flow_Handler *	control_handler_
TAO_AV_Protocol_Object *	protocol_object_
TAO_AV_Protocol_Object *	control_protocol_object_
Role	role_

Detailed Description

A helper entry class in the flow spec sequence passed to bind_devs.

Definition at line 68 of file FlowSpec_Entry.h.

Member Enumeration Documentation

enum TAO_FlowSpec_Entry::Direction

Enumerator:

TAO_AV_INVALID
TAO_AV_DIR_IN
TAO_AV_DIR_OUT

Definition at line 72 of file FlowSpec_Entry.h.

00073   {
00074     TAO_AV_INVALID   = -1,
00075     TAO_AV_DIR_IN    =  0,
00076     TAO_AV_DIR_OUT   =  1
00077   };

enum TAO_FlowSpec_Entry::Role

Enumerator:

TAO_AV_INVALID_ROLE
TAO_AV_PRODUCER
TAO_AV_CONSUMER

Definition at line 79 of file FlowSpec_Entry.h.

00080   {
00081     TAO_AV_INVALID_ROLE = -1,
00082     TAO_AV_PRODUCER = 0,
00083     TAO_AV_CONSUMER = 1
00084   };

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_FlowSpec_Entry::TAO_FlowSpec_Entry ( void )

default constructor.

Definition at line 21 of file FlowSpec_Entry.cpp.

00022   :address_ (0),
00023    clean_up_address_ (0),
00024    control_address_ (0),
00025    clean_up_control_address_ (0),
00026    address_str_ (),
00027    format_ (),
00028    direction_ (TAO_AV_INVALID),
00029    direction_str_ (),
00030    flowname_ (),
00031    protocol_ (TAO_AV_Core::TAO_AV_NOPROTOCOL),
00032    carrier_protocol_ (),
00033    flow_protocol_ (),
00034    use_flow_protocol_ (0),
00035    entry_ (),
00036    is_multicast_ (0),
00037    delete_peer_addr_ (false),
00038    peer_addr_ (0),
00039    local_sec_addr_ (0),
00040    num_local_sec_addrs_ (0),
00041    peer_sec_addr_ (0),
00042    num_peer_sec_addrs_ (0),
00043    peer_control_addr_ (0),
00044    local_addr_ (0),
00045    local_control_addr_ (0),
00046    transport_ (0),
00047    control_transport_ (0),
00048    handler_ (0),
00049    control_handler_ (0),
00050    protocol_object_ (0),
00051    control_protocol_object_ (0),
00052    role_ (TAO_AV_INVALID_ROLE)
00053 {
00054 }

TAO_FlowSpec_Entry::TAO_FlowSpec_Entry	(	const char *	flowname,
		const char *	direction,
		const char *	format_name,
		const char *	flow_protocol,
		const char *	carrier_protocol,
		ACE_Addr *	fwd_address,
		ACE_Addr *	control_address = `0`
	)

constructor to construct an entry from the arguments.

Definition at line 57 of file FlowSpec_Entry.cpp.

References parse_flow_protocol_string(), set_direction(), and set_protocol().

00065   :address_ (fwd_address),
00066    clean_up_address_ (0),
00067    control_address_ (control_address),
00068    clean_up_control_address_ (0),
00069    address_str_ (),
00070    format_ (format_name),
00071    direction_str_ (), // This is initialized in the call to set_direction()
00072    flowname_ ( flowname ),
00073    carrier_protocol_ ( carrier_protocol ),
00074    flow_protocol_ ( flow_protocol ),
00075    use_flow_protocol_ (0),
00076    entry_ (),
00077    is_multicast_ (0),
00078    delete_peer_addr_ (false),
00079    peer_addr_ (0),
00080    local_sec_addr_ (0),
00081    num_local_sec_addrs_ (0),
00082    peer_sec_addr_ (0),
00083    num_peer_sec_addrs_ (0),
00084    peer_control_addr_ (0),
00085    local_addr_ (0),
00086    local_control_addr_ (0),
00087    transport_ (0),
00088    control_transport_ (0),
00089    handler_ (0),
00090    control_handler_ (0),
00091    protocol_object_ (0),
00092    control_protocol_object_ (0),
00093    role_ (TAO_AV_INVALID_ROLE)
00094 {
00095   this->set_protocol ();
00096   this->set_direction (direction);
00097   this->parse_flow_protocol_string (this->flow_protocol_.c_str());
00098 }

TAO_FlowSpec_Entry::TAO_FlowSpec_Entry	(	const char *	flowname,
		const char *	direction,
		const char *	format_name,
		const char *	flow_protocol,
		const char *	fwd_address
	)

Definition at line 100 of file FlowSpec_Entry.cpp.

References parse_address(), parse_flow_protocol_string(), set_direction(), and TAO_AV_Core::TAO_AV_DATA.

00105   :address_ (0),
00106    clean_up_address_ (0),
00107    control_address_ (0),
00108    clean_up_control_address_ (0),
00109    address_str_ ( address ),
00110    format_ ( format_name ),
00111    direction_str_ (), // This is initialized in the call to set_direction()
00112    flowname_ ( flowname ),
00113    carrier_protocol_ (),
00114    flow_protocol_ ( flow_protocol ),
00115    use_flow_protocol_ (0),
00116    entry_ (),
00117    is_multicast_ (0),
00118    peer_addr_ (0),
00119    local_sec_addr_ (0),
00120    num_local_sec_addrs_ (0),
00121    peer_sec_addr_ (0),
00122    num_peer_sec_addrs_ (0),
00123    peer_control_addr_ (0),
00124    local_addr_ (0),
00125    local_control_addr_ (0),
00126    transport_ (0),
00127    control_transport_ (0),
00128    handler_ (0),
00129    control_handler_ (0),
00130    protocol_object_ (0),
00131    control_protocol_object_ (0),
00132    role_ (TAO_AV_INVALID_ROLE)
00133 {
00134   this->parse_flow_protocol_string (this->flow_protocol_.c_str() );
00135   this->parse_address (this->address_str_.c_str(), TAO_AV_Core::TAO_AV_DATA);
00136   this->set_direction (direction);
00137 }

TAO_FlowSpec_Entry::~TAO_FlowSpec_Entry ( void ) [virtual]

virtual destructor.

Definition at line 140 of file FlowSpec_Entry.cpp.

References address_, control_address_, local_control_addr_, and peer_addr_.

00141 {
00142   if (this->delete_peer_addr_)
00143     delete this->peer_addr_;
00144 
00145   if (this->clean_up_address_)
00146     delete address_;
00147   if (this->clean_up_control_address_)
00148     delete control_address_;
00149   if (local_control_addr_ != 0)
00150     delete local_control_addr_;
00151 }

Member Function Documentation

ACE_INLINE void TAO_FlowSpec_Entry::address	(	ACE_Addr *	address,
		bool	cleanup = `false`
	)

Definition at line 94 of file FlowSpec_Entry.inl.

References address_, and clean_up_address_.

00095 {
00096   if (this->clean_up_address_)
00097     delete this->address_;
00098 
00099   this->address_ = addr;
00100   this->clean_up_address_ = cleanup;
00101 }

ACE_INLINE ACE_Addr * TAO_FlowSpec_Entry::address ( void )

accessor to address of the carrier protocol.

Definition at line 87 of file FlowSpec_Entry.inl.

References address_.

Referenced by TAO_FlowConnection::add_producer(), TAO_AV_UDP_Connector::connect(), TAO_AV_TCP_Connector::connect(), TAO_Reverse_FlowSpec_Entry::entry_to_string(), TAO_Forward_FlowSpec_Entry::entry_to_string(), TAO_StreamEndPoint_A::multiconnect(), TAO_AV_UDP_Acceptor::open(), TAO_AV_TCP_Acceptor::open(), and TAO_AV_UDP_Acceptor::open_i().

00088 {
00089   return this->address_;
00090 }

ACE_INLINE const char * TAO_FlowSpec_Entry::address_str ( void ) const

Address in string format i. hostname:port.

Definition at line 119 of file FlowSpec_Entry.inl.

References address_str_, and ACE_String_Base< CHAR >::c_str().

Referenced by TAO_Reverse_FlowSpec_Entry::entry_to_string(), and TAO_Forward_FlowSpec_Entry::entry_to_string().

00120 {
00121   return this->address_str_.c_str();
00122 }

ACE_INLINE TAO_AV_Core::Protocol TAO_FlowSpec_Entry::carrier_protocol ( void )

accessor to carrier protocol i.e TCP,UDP,RTP/UDP.

Definition at line 73 of file FlowSpec_Entry.inl.

References protocol_.

00074 {
00075   return this->protocol_;
00076 }

ACE_INLINE const char * TAO_FlowSpec_Entry::carrier_protocol_str ( void ) const

accessor to string version of carrier protocol.

Definition at line 80 of file FlowSpec_Entry.inl.

References ACE_String_Base< CHAR >::c_str(), and carrier_protocol_.

Referenced by TAO_StreamEndPoint_A::multiconnect(), and TAO_AV_Acceptor_Registry::open_default().

00081 {
00082   return this->carrier_protocol_.c_str();
00083 }

ACE_INLINE void TAO_FlowSpec_Entry::control_address ( ACE_Addr * address )

Definition at line 112 of file FlowSpec_Entry.inl.

References control_address_.

00113 {
00114   this->control_address_ = addr;
00115 }

ACE_INLINE ACE_Addr * TAO_FlowSpec_Entry::control_address ( void )

Definition at line 105 of file FlowSpec_Entry.inl.

References control_address_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_UDP_Acceptor::open(), and TAO_AV_UDP_Acceptor::open_i().

00106 {
00107   return this->control_address_;
00108 }

ACE_INLINE void TAO_FlowSpec_Entry::control_handler ( TAO_AV_Flow_Handler * control_handler )

Definition at line 304 of file FlowSpec_Entry.inl.

References control_handler_, and handler().

00305 {
00306   this->control_handler_ = handler;
00307 }

ACE_INLINE TAO_AV_Flow_Handler * TAO_FlowSpec_Entry::control_handler ( void )

Definition at line 276 of file FlowSpec_Entry.inl.

References control_handler_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_UDP_Acceptor::open_i(), TAO_StreamEndPoint::stop(), TAO_AV_UDP_Acceptor::~TAO_AV_UDP_Acceptor(), and TAO_AV_UDP_Connector::~TAO_AV_UDP_Connector().

00277 {
00278   return this->control_handler_;
00279 }

ACE_INLINE void TAO_FlowSpec_Entry::control_protocol_object ( TAO_AV_Protocol_Object * object )

Definition at line 332 of file FlowSpec_Entry.inl.

References control_protocol_object_.

00333 {
00334   this->control_protocol_object_ = object;
00335 }

ACE_INLINE TAO_AV_Protocol_Object * TAO_FlowSpec_Entry::control_protocol_object ( void )

Definition at line 325 of file FlowSpec_Entry.inl.

References control_protocol_object_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_Acceptor_Registry::open_default(), and TAO_AV_UDP_Acceptor::open_i().

00326 {
00327   return this->control_protocol_object_;
00328 }

ACE_INLINE void TAO_FlowSpec_Entry::control_transport ( TAO_AV_Transport * control_transport )

Definition at line 262 of file FlowSpec_Entry.inl.

References control_transport(), and control_transport_.

00263 {
00264   this->control_transport_ = control_transport;
00265 }

ACE_INLINE TAO_AV_Transport * TAO_FlowSpec_Entry::control_transport ( void )

Definition at line 255 of file FlowSpec_Entry.inl.

References control_transport_.

Referenced by control_transport().

00256 {
00257   return this->control_transport_;
00258 }

ACE_INLINE int TAO_FlowSpec_Entry::direction ( void )

accessor to the direction.

Definition at line 45 of file FlowSpec_Entry.inl.

References direction_.

00046 {
00047   return this->direction_;
00048 }

ACE_INLINE const char * TAO_FlowSpec_Entry::direction_str ( void ) const

accessor to string version of direction .

Definition at line 52 of file FlowSpec_Entry.inl.

References ACE_String_Base< CHAR >::c_str(), and direction_str_.

Referenced by TAO_StreamEndPoint_A::multiconnect().

00053 {
00054   return this->direction_str_.c_str();
00055 }

virtual const char* TAO_FlowSpec_Entry::entry_to_string ( void ) [pure virtual]

converts the entry to a string.

Implemented in TAO_Forward_FlowSpec_Entry, and TAO_Reverse_FlowSpec_Entry.

ACE_INLINE void TAO_FlowSpec_Entry::flow_protocol_str ( const char * flow_protocol_str )

set the flow protocol string.

Definition at line 66 of file FlowSpec_Entry.inl.

References flow_protocol_, and CORBA::string_dup().

00067 {
00068   this->flow_protocol_ = CORBA::string_dup (str);
00069 }

ACE_INLINE const char * TAO_FlowSpec_Entry::flow_protocol_str ( void ) const

accessor to the flow protocol string.

Definition at line 59 of file FlowSpec_Entry.inl.

References ACE_String_Base< CHAR >::c_str(), and flow_protocol_.

Referenced by TAO_AV_SFP_Factory::make_protocol_object(), TAO_StreamEndPoint_A::multiconnect(), and TAO_AV_Acceptor_Registry::open_default().

00060 {
00061   return this->flow_protocol_.c_str();
00062 }

ACE_INLINE const char * TAO_FlowSpec_Entry::flowname ( void ) const

accessor to name of this flow.

Definition at line 133 of file FlowSpec_Entry.inl.

References ACE_String_Base< CHAR >::c_str(), and flowname_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_TCP_Connector::connect(), TAO_AV_UDP_Flow_Factory::make_protocol_object(), TAO_AV_TCP_Flow_Factory::make_protocol_object(), TAO_AV_SFP_Factory::make_protocol_object(), TAO_AV_RTP_Flow_Factory::make_protocol_object(), TAO_StreamEndPoint_A::multiconnect(), TAO_AV_UDP_Acceptor::open(), TAO_AV_TCP_Acceptor::open(), TAO_AV_UDP_Acceptor::open_default(), and TAO_AV_TCP_Acceptor::open_default().

00134 {
00135   return this->flowname_.c_str();
00136 }

ACE_INLINE const char * TAO_FlowSpec_Entry::format ( void ) const

accessor to format to be used for this flow.

Definition at line 126 of file FlowSpec_Entry.inl.

References ACE_String_Base< CHAR >::c_str(), and format_.

Referenced by TAO_StreamEndPoint_A::multiconnect().

00127 {
00128   return this->format_.c_str();
00129 }

ACE_INLINE ACE_Addr * TAO_FlowSpec_Entry::get_local_addr ( void )

Definition at line 179 of file FlowSpec_Entry.inl.

References local_addr_.

00180 {
00181   return this->local_addr_;
00182 }

char * TAO_FlowSpec_Entry::get_local_addr_str ( void )

Definition at line 462 of file FlowSpec_Entry.cpp.

References ACE_ERROR_RETURN, ACE_NEW_RETURN, AF_INET, inet_addr(), LM_ERROR, local_addr_, and ACE_String_Base< CHAR >::rep().

Referenced by TAO_FlowEndPoint::connect_to_peer_i().

00463 {
00464   if (this->local_addr_ == 0)
00465     return 0;
00466 
00467   switch (this->local_addr_->get_type ())
00468     {
00469     case AF_INET:
00470       {
00471         char *buf;
00472         ACE_NEW_RETURN (buf,
00473                         char [BUFSIZ],
00474                         0);
00475 
00476         ACE_INET_Addr *inet_addr = dynamic_cast<ACE_INET_Addr *> (this->local_addr_);
00477         inet_addr->addr_to_string (buf,BUFSIZ);
00478         ACE_CString cstring (buf, 0, false);
00479 
00480         return cstring.rep ();
00481       }
00482     default:
00483       ACE_ERROR_RETURN ((LM_ERROR,"Address family not supported"),0);
00484     }
00485 }

ACE_INLINE ACE_Addr * TAO_FlowSpec_Entry::get_local_control_addr ( void )

Definition at line 186 of file FlowSpec_Entry.inl.

References local_control_addr_.

Referenced by TAO_AV_UDP_Connector::connect(), and TAO_AV_UDP_Acceptor::open_i().

00187 {
00188   return this->local_control_addr_;
00189 }

char* TAO_FlowSpec_Entry::get_local_control_addr_str ( void )

ACE_INLINE char ** TAO_FlowSpec_Entry::get_local_sec_addr ( void )

Definition at line 203 of file FlowSpec_Entry.inl.

References local_sec_addr_.

00204 {
00205   return this->local_sec_addr_;
00206 }

ACE_INLINE ACE_Addr * TAO_FlowSpec_Entry::get_peer_addr ( void )

Definition at line 156 of file FlowSpec_Entry.inl.

References peer_addr_.

Referenced by TAO_AV_UDP_Connector::connect().

00157 {
00158   return this->peer_addr_;
00159 }

ACE_Addr* TAO_FlowSpec_Entry::get_peer_control_addr ( void )

ACE_INLINE char ** TAO_FlowSpec_Entry::get_peer_sec_addr ( void )

Definition at line 227 of file FlowSpec_Entry.inl.

References peer_sec_addr_.

00228 {
00229   return this->peer_sec_addr_;
00230 }

ACE_INLINE void TAO_FlowSpec_Entry::handler ( TAO_AV_Flow_Handler * handler )

Definition at line 283 of file FlowSpec_Entry.inl.

References handler(), and handler_.

00284 {
00285   this->handler_ = handler;
00286 
00287 //   // Now remove the handler from the reactor if the handler is for a producer.
00288 //   switch (this->role ())
00289 //     {
00290 //     case TAO_AV_PRODUCER:
00291 //       {
00292 //         ACE_Event_Handler *event_handler = handler->event_handler ();
00293 //         int result  = event_handler->reactor ()->remove_handler (event_handler,
00294 //                                                                  ACE_Event_Handler::READ_MASK);
00295 //         if (result < 0)
00296 //           ACE_ERROR ((LM_ERROR,"TAO_FlowSpec_Entry::handler\n"));
00297 //         break;
00298 //       }
00299 //     }
00300 }

ACE_INLINE TAO_AV_Flow_Handler * TAO_FlowSpec_Entry::handler ( void )

Definition at line 269 of file FlowSpec_Entry.inl.

References handler_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_TCP_Connector::connect(), TAO_FlowProducer::connect_mcast(), control_handler(), handler(), TAO_AV_TCP_Acceptor::make_svc_handler(), TAO_AV_TCP_Base_Acceptor::make_svc_handler(), TAO_AV_TCP_Connector::make_svc_handler(), TAO_AV_UDP_Acceptor::open_i(), and TAO_StreamEndPoint::stop().

00270 {
00271   return this->handler_;
00272 }

ACE_INLINE int TAO_FlowSpec_Entry::is_multicast ( void )

returns true for a multicast address.

Definition at line 339 of file FlowSpec_Entry.inl.

References is_multicast_.

Referenced by TAO_AV_UDP_Connector::connect().

00340 {
00341   return this->is_multicast_;
00342 }

ACE_INLINE int TAO_FlowSpec_Entry::num_local_sec_addrs ( void )

Definition at line 210 of file FlowSpec_Entry.inl.

References num_local_sec_addrs_.

00211 {
00212   return this->num_local_sec_addrs_;
00213 }

ACE_INLINE int TAO_FlowSpec_Entry::num_peer_sec_addrs ( void )

Definition at line 234 of file FlowSpec_Entry.inl.

References num_peer_sec_addrs_.

00235 {
00236   return this->num_peer_sec_addrs_;
00237 }

virtual int TAO_FlowSpec_Entry::parse ( const char * flowSpec_entry ) [pure virtual]

construct the entry from a string specified by the flowSpec grammar.

Implemented in TAO_Forward_FlowSpec_Entry, and TAO_Reverse_FlowSpec_Entry.

int TAO_FlowSpec_Entry::parse_address	(	const char *	format_string,
		TAO_AV_Core::Flow_Component	flow_component
	)

sets the address for this flow.

Definition at line 238 of file FlowSpec_Entry.cpp.

Referenced by TAO_FlowSpec_Entry().

00240 {
00241   if (TAO_debug_level > 0)
00242     ACE_DEBUG ((LM_DEBUG, "TAO_FlowSpec_Entry::parse_address [%s]\n", address));
00243 
00244   if (address == 0)
00245     return 0;
00246   if (ACE_OS::strcmp (address,"") == 0)
00247     return 0;
00248   TAO_Tokenizer protocol_tokenizer (address,'=');
00249 
00250   this->carrier_protocol_ = protocol_tokenizer[0];
00251 
00252   int result = this->set_protocol ();
00253   if (result < 0)
00254     return result;
00255 
00256   if (protocol_tokenizer [1] != 0)
00257     {
00258       ACE_DEBUG ((LM_DEBUG,
00259                   "Protocol tokenixer is not null\n"));
00260       if ((flow_comp == TAO_AV_Core::TAO_AV_DATA) ||
00261           //(flow_comp == TAO_AV_Core::TAO_AV_BOTH) ||
00262           (flow_comp == TAO_AV_Core::TAO_AV_CONTROL) )
00263         {
00264           ACE_CString addr;
00265           if (this->protocol_ == TAO_AV_Core::TAO_AV_SCTP_SEQ)
00266             {
00267               TAO_Tokenizer addr_token (protocol_tokenizer [1], ';');
00268 
00269               ACE_DEBUG ((LM_DEBUG,
00270                           "Number of local sec addresses = %d\n",
00271                           addr_token.num_tokens () - 1));
00272 
00273               if (addr_token.num_tokens () != 0)
00274                 {
00275                   addr += addr_token [0];
00276                   ACE_NEW_RETURN (local_sec_addr_, char* [addr_token.num_tokens () - 1],-1);
00277                   for (int j = 1; j <= addr_token.num_tokens () - 1; j++)
00278                     {
00279                       ACE_DEBUG ((LM_DEBUG,
00280                                   "adding addresses to sequence %s\n",
00281                                   addr_token [j]));
00282 
00283                       local_sec_addr_ [j-1] =  CORBA::string_dup (addr_token [j]);
00284                     }
00285                   num_local_sec_addrs_ = addr_token.num_tokens () - 1;
00286                 }
00287             }
00288           else addr += protocol_tokenizer[1];
00289 
00290 
00291           switch (this->protocol_)
00292             {
00293             case TAO_AV_Core::TAO_AV_SFP_UDP:
00294             case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
00295             case TAO_AV_Core::TAO_AV_RTP_UDP:
00296             case TAO_AV_Core::TAO_AV_TCP:
00297             case TAO_AV_Core::TAO_AV_SCTP_SEQ:
00298             case TAO_AV_Core::TAO_AV_UDP:
00299             case TAO_AV_Core::TAO_AV_QOS_UDP:
00300               {
00301                 if (flow_comp == TAO_AV_Core::TAO_AV_DATA)
00302                   this->address_str_ = addr;
00303                 ACE_INET_Addr *inet_addr;
00304                 ACE_NEW_RETURN (inet_addr,
00305                                 ACE_INET_Addr (addr.c_str() ),
00306                                 -1);
00307                 if (flow_comp == TAO_AV_Core::TAO_AV_DATA)
00308                   {
00309                     this->clean_up_address_ = 1;
00310                     this->address_ = inet_addr;
00311                   }
00312                 else
00313                   {
00314                     this->clean_up_control_address_ = 1;
00315                     this->control_address_ = inet_addr;
00316                   }
00317 
00318                 if (IN_CLASSD (inet_addr->get_ip_address ()))
00319                   {
00320                     if (TAO_debug_level > 0)
00321                       ACE_DEBUG ((LM_DEBUG, "TAO_FlowSpec_Entry::parse_address is multicast\n"));
00322 
00323                     this->is_multicast_ = 1;
00324                     switch (this->protocol_)
00325                       {
00326                       case TAO_AV_Core::TAO_AV_UDP:
00327                         this->protocol_ = TAO_AV_Core::TAO_AV_UDP_MCAST;
00328                         break;
00329                       case TAO_AV_Core::TAO_AV_RTP_UDP:
00330                         this->protocol_ = TAO_AV_Core::TAO_AV_RTP_UDP_MCAST;
00331                         break;
00332                       case TAO_AV_Core::TAO_AV_SFP_UDP:
00333                         this->protocol_ = TAO_AV_Core::TAO_AV_SFP_UDP_MCAST;
00334                         break;
00335                       case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
00336                         this->protocol_ = TAO_AV_Core::TAO_AV_USERDEFINED_UDP_MCAST;
00337                         break;
00338                       default:
00339                         break;
00340                       }
00341                   }
00342               }
00343               break;
00344             default:
00345               if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"ATM support not added yet\n"));
00346             }
00347         }
00348       else
00349         {
00350           ACE_DEBUG ((LM_DEBUG,
00351                       "AV BOTH %s \n",
00352                       protocol_tokenizer[1]));
00353 
00354           TAO_Tokenizer address_tokenizer (protocol_tokenizer[1], ':');
00355           TAO_Tokenizer port_tokenizer (address_tokenizer[1], ';');
00356           ACE_CString addr;
00357           addr += address_tokenizer[0];
00358           addr += ":";
00359           addr += port_tokenizer[0];
00360 
00361           if (this->protocol_ == TAO_AV_Core::TAO_AV_SCTP_SEQ)
00362             {
00363               ACE_DEBUG ((LM_DEBUG,
00364                           "Number of local sec addresses = %d\n",
00365                           port_tokenizer.num_tokens () - 1));
00366 
00367               if (port_tokenizer.num_tokens () - 1 != 0)
00368                 {
00369                   ACE_NEW_RETURN (local_sec_addr_, char* [port_tokenizer.num_tokens () - 1],-1);
00370                   for (int j = 1; j <= port_tokenizer.num_tokens () - 1; j++)
00371                     {
00372                       ACE_DEBUG ((LM_DEBUG,
00373                                   "adding addresses to sequence %s\n",
00374                                   port_tokenizer [j]));
00375 
00376                       local_sec_addr_ [j-1] =  CORBA::string_dup (port_tokenizer [j]);
00377                     }
00378                   num_local_sec_addrs_ = port_tokenizer.num_tokens () - 1;
00379                 }
00380             }
00381 
00382           short control_port = static_cast<short> (ACE_OS::atoi(port_tokenizer[0])) + 1;
00383           char control_port_str[6];
00384           ACE_OS::sprintf (control_port_str, "%d", control_port);
00385 
00386           ACE_CString control_addr = "";
00387           if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"RTP/UDP") == 0)
00388             {
00389               control_addr += address_tokenizer[0];
00390               control_addr += ":";
00391               if (port_tokenizer[1] != 0)
00392                 control_addr += port_tokenizer[1];
00393               else
00394                 control_addr += control_port_str;
00395             }
00396 
00397           switch (this->protocol_)
00398             {
00399             case TAO_AV_Core::TAO_AV_SFP_UDP:
00400             case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
00401             case TAO_AV_Core::TAO_AV_RTP_UDP:
00402             case TAO_AV_Core::TAO_AV_TCP:
00403             case TAO_AV_Core::TAO_AV_SCTP_SEQ:
00404             case TAO_AV_Core::TAO_AV_UDP:
00405             case TAO_AV_Core::TAO_AV_QOS_UDP:
00406               {
00407                 this->address_str_ = addr;
00408                 ACE_INET_Addr *inet_addr;
00409                 ACE_NEW_RETURN (inet_addr,
00410                                 ACE_INET_Addr (addr.c_str() ),
00411                                 -1);
00412                 this->clean_up_address_ = 1;
00413                 this->address_ = inet_addr;
00414 
00415                 if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"RTP/UDP") == 0)
00416                   {
00417                     ACE_INET_Addr *control_inet_addr;
00418                     ACE_NEW_RETURN (control_inet_addr,
00419                                     ACE_INET_Addr (control_addr.c_str() ),
00420                                     -1);
00421                     this->clean_up_control_address_ = 1;
00422                     this->control_address_ = control_inet_addr;
00423                   }
00424 
00425                 if (IN_CLASSD (inet_addr->get_ip_address ()))
00426                   {
00427                     if (TAO_debug_level > 0)
00428                       ACE_DEBUG ((LM_DEBUG, "TAO_FlowSpec_Entry::parse_address is multicast\n"));
00429 
00430                     this->is_multicast_ = 1;
00431                     switch (this->protocol_)
00432                       {
00433                       case TAO_AV_Core::TAO_AV_UDP:
00434                         this->protocol_ = TAO_AV_Core::TAO_AV_UDP_MCAST;
00435                         break;
00436                       case TAO_AV_Core::TAO_AV_RTP_UDP:
00437                         this->protocol_ = TAO_AV_Core::TAO_AV_RTP_UDP_MCAST;
00438                         break;
00439                       case TAO_AV_Core::TAO_AV_SFP_UDP:
00440                         this->protocol_ = TAO_AV_Core::TAO_AV_SFP_UDP_MCAST;
00441                         break;
00442                       case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
00443                         this->protocol_ = TAO_AV_Core::TAO_AV_USERDEFINED_UDP_MCAST;
00444                         break;
00445                       default:
00446                         break;
00447                       }
00448                   }
00449               }
00450               break;
00451             default:
00452               if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"ATM support not added yet\n"));
00453             }
00454         }
00455     }
00456   ACE_DEBUG ((LM_DEBUG,
00457               "Return from parse address\n"));
00458   return 0;
00459 }

ACE_INLINE int TAO_FlowSpec_Entry::parse_flow_protocol_string ( const char * flow_options_string ) [protected]

parses the flow protocol string with tokens separated by :

Definition at line 28 of file FlowSpec_Entry.inl.

References flow_protocol_, ACE_OS::strcmp(), and use_flow_protocol_.

Referenced by TAO_FlowSpec_Entry().

00029 {
00030   if (flow_string == 0)
00031     return 0;
00032 
00033   if (ACE_OS::strcmp (flow_string,"") == 0)
00034         return 0;
00035 
00036   this->use_flow_protocol_ = 1;
00037   // do some flow protocol processing.
00038   this->flow_protocol_ = flow_string;
00039 
00040   return 0;
00041 }

ACE_INLINE void TAO_FlowSpec_Entry::protocol_object ( TAO_AV_Protocol_Object * object )

Definition at line 318 of file FlowSpec_Entry.inl.

References protocol_object_.

00319 {
00320   this->protocol_object_ = object;
00321 }

ACE_INLINE TAO_AV_Protocol_Object * TAO_FlowSpec_Entry::protocol_object ( void )

Definition at line 311 of file FlowSpec_Entry.inl.

References protocol_object_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_TCP_Acceptor::make_svc_handler(), TAO_AV_TCP_Connector::make_svc_handler(), TAO_AV_Acceptor_Registry::open_default(), and TAO_AV_UDP_Acceptor::open_i().

00312 {
00313   return this->protocol_object_;
00314 }

ACE_INLINE void TAO_FlowSpec_Entry::role ( Role role )

Definition at line 346 of file FlowSpec_Entry.inl.

References role_.

00347 {
00348   this->role_ = role;
00349 }

virtual Role TAO_FlowSpec_Entry::role ( void ) [pure virtual]

Implemented in TAO_Forward_FlowSpec_Entry, and TAO_Reverse_FlowSpec_Entry.

Referenced by TAO_AV_SFP_Factory::make_protocol_object(), and TAO_StreamEndPoint::stop().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int TAO_FlowSpec_Entry::set_direction ( const char * direction_string ) [protected]

sets the direction flag.

Definition at line 11 of file FlowSpec_Entry.inl.

References direction_, direction_str_, ACE_OS::strcasecmp(), TAO_AV_DIR_IN, TAO_AV_DIR_OUT, and TAO_AV_INVALID.

Referenced by TAO_Forward_FlowSpec_Entry::parse(), and TAO_FlowSpec_Entry().

00012 {
00013   this->direction_str_ = direction;
00014   if (direction == 0)
00015     {
00016       this->direction_ = TAO_AV_INVALID;
00017       return -1;
00018     }
00019   if (ACE_OS::strcasecmp (direction,"in") == 0)
00020     this->direction_ = TAO_AV_DIR_IN;
00021   else if (ACE_OS::strcasecmp (direction,"out") == 0)
00022     this->direction_ = TAO_AV_DIR_OUT;
00023   return 0;
00024 }

ACE_INLINE int TAO_FlowSpec_Entry::set_local_addr ( ACE_Addr * local_addr )

Definition at line 163 of file FlowSpec_Entry.inl.

References local_addr_.

Referenced by TAO_AV_UDP_Connector::connect(), TAO_AV_TCP_Acceptor::open(), TAO_AV_TCP_Acceptor::open_default(), and TAO_AV_UDP_Acceptor::open_i().

00164 {
00165   this->local_addr_ = local_addr;
00166   return 0;
00167 }

ACE_INLINE int TAO_FlowSpec_Entry::set_local_control_addr ( ACE_Addr * local_control_addr )

Definition at line 171 of file FlowSpec_Entry.inl.

References local_control_addr_.

Referenced by TAO_AV_UDP_Connector::connect(), and TAO_AV_UDP_Acceptor::open_i().

00172 {
00173   this->local_control_addr_ = local_addr;
00174   return 0;
00175 }

ACE_INLINE int TAO_FlowSpec_Entry::set_local_sec_addr	(	char **	local_sec_addr,
		int	size
	)

Definition at line 193 of file FlowSpec_Entry.inl.

References local_sec_addr_, and num_local_sec_addrs_.

00195 {
00196   this->local_sec_addr_ = local_sec_addr;
00197   this->num_local_sec_addrs_ = size;
00198   return 0;
00199 }

ACE_INLINE int TAO_FlowSpec_Entry::set_peer_addr ( ACE_Addr * peer_addr )

Definition at line 141 of file FlowSpec_Entry.inl.

References delete_peer_addr_, handler_, peer_addr_, and TAO_AV_Flow_Handler::set_remote_address().

Referenced by TAO_AV_Core::init_reverse_flows().

00142 {
00143   if (this->delete_peer_addr_)
00144     delete this->peer_addr_;
00145 
00146   this->delete_peer_addr_ = false;
00147   this->peer_addr_ = peer_addr;
00148 
00149   if (this->handler_ != 0)
00150     this->handler_->set_remote_address (peer_addr);
00151   return 0;
00152 }

int TAO_FlowSpec_Entry::set_peer_control_addr ( ACE_Addr * peer_control_addr )

ACE_INLINE int TAO_FlowSpec_Entry::set_peer_sec_addr	(	char **	peer_sec_addr,
		int	size
	)

Definition at line 217 of file FlowSpec_Entry.inl.

References num_peer_sec_addrs_, and peer_sec_addr_.

00219 {
00220   this->peer_sec_addr_ = peer_sec_addr;
00221   this->num_peer_sec_addrs_ = size;
00222   return 0;
00223 }

int TAO_FlowSpec_Entry::set_protocol ( void ) [protected]

sets the protocol_ enum from the carrier_protocol_ string.

Definition at line 154 of file FlowSpec_Entry.cpp.

Referenced by parse_address(), and TAO_FlowSpec_Entry().

00155 {
00156   if (!this->use_flow_protocol_)
00157     {
00158       if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"TCP") == 0)
00159         this->protocol_ = TAO_AV_Core::TAO_AV_TCP;
00160       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"SCTP_SEQ") == 0)
00161           this->protocol_ = TAO_AV_Core::TAO_AV_SCTP_SEQ;
00162       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"UDP") == 0)
00163           this->protocol_ = TAO_AV_Core::TAO_AV_UDP;
00164       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"QoS_UDP") == 0)
00165         this->protocol_ = TAO_AV_Core::TAO_AV_QOS_UDP;
00166       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"AAL5") == 0)
00167         this->protocol_ = TAO_AV_Core::TAO_AV_AAL5;
00168       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"AAL3_4") == 0)
00169         this->protocol_ = TAO_AV_Core::TAO_AV_AAL3_4;
00170       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"AAL1") == 0)
00171         this->protocol_ = TAO_AV_Core::TAO_AV_AAL1;
00172       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"RTP/UDP") == 0){
00173         this->protocol_ = TAO_AV_Core::TAO_AV_UDP;
00174         flow_protocol_ = "RTP";
00175       }
00176       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"RTP/AAL5") == 0)
00177         this->protocol_ = TAO_AV_Core::TAO_AV_RTP_AAL5;
00178       else if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"IPX") == 0)
00179         this->protocol_ = TAO_AV_Core::TAO_AV_IPX;
00180       else
00181         {
00182           this->protocol_ = TAO_AV_Core::TAO_AV_NOPROTOCOL;
00183           return -1;
00184         }
00185     }
00186   else
00187     {
00188       if (ACE_OS::strcasecmp (this->carrier_protocol_.c_str(),"UDP") == 0)
00189         {
00190           if (ACE_OS::strncasecmp (this->flow_protocol_.c_str (),"sfp",3) == 0)
00191             {
00192               this->protocol_ = TAO_AV_Core::TAO_AV_SFP_UDP;
00193             }
00194           else this->protocol_ = TAO_AV_Core::TAO_AV_USERDEFINED_UDP;
00195         }
00196       else
00197         {
00198           this->protocol_ = TAO_AV_Core::TAO_AV_NOPROTOCOL;
00199           return -1;
00200         }
00201     }
00202 
00203   if (this->address_ != 0)
00204     {
00205       if (TAO_debug_level > 0)
00206         ACE_DEBUG ((LM_DEBUG, "TAO_FlowSpec_Entry::set_protocol address is not 0\n"));
00207       ACE_INET_Addr *inet_addr = dynamic_cast<ACE_INET_Addr*> (this->address_);
00208       char buf[BUFSIZ];
00209       inet_addr->addr_to_string (buf,BUFSIZ);
00210       if (TAO_debug_level > 0)
00211         ACE_DEBUG ((LM_DEBUG,"TAO_FlowSpec_Entry::set_protocol:%s %x\n",buf, inet_addr->get_ip_address ()));
00212       if (IN_CLASSD (inet_addr->get_ip_address ()))
00213         {
00214           this->is_multicast_ = 1;
00215           switch (this->protocol_)
00216             {
00217             case TAO_AV_Core::TAO_AV_UDP:
00218               this->protocol_ = TAO_AV_Core::TAO_AV_UDP_MCAST;
00219               break;
00220             case TAO_AV_Core::TAO_AV_RTP_UDP:
00221               this->protocol_ = TAO_AV_Core::TAO_AV_RTP_UDP_MCAST;
00222               break;
00223             case TAO_AV_Core::TAO_AV_SFP_UDP:
00224               this->protocol_ = TAO_AV_Core::TAO_AV_SFP_UDP_MCAST;
00225               break;
00226             case TAO_AV_Core::TAO_AV_USERDEFINED_UDP:
00227               this->protocol_ = TAO_AV_Core::TAO_AV_USERDEFINED_UDP_MCAST;
00228               break;
00229             default:
00230               break;
00231             }
00232         }
00233     }
00234   return 0;
00235 }

ACE_INLINE void TAO_FlowSpec_Entry::transport ( TAO_AV_Transport * transport )

Definition at line 248 of file FlowSpec_Entry.inl.

References transport(), and transport_.

00249 {
00250   this->transport_ = transport;
00251 }

ACE_INLINE TAO_AV_Transport * TAO_FlowSpec_Entry::transport ( void )

Definition at line 241 of file FlowSpec_Entry.inl.

References transport_.

Referenced by transport().

00242 {
00243   return this->transport_;
00244 }

Member Data Documentation

ACE_Addr* TAO_FlowSpec_Entry::address_ [protected]

Addr information for the carrier protocol.

Definition at line 206 of file FlowSpec_Entry.h.

Referenced by address(), TAO_Reverse_FlowSpec_Entry::entry_to_string(), TAO_Forward_FlowSpec_Entry::entry_to_string(), parse_address(), set_protocol(), and ~TAO_FlowSpec_Entry().

ACE_CString TAO_FlowSpec_Entry::address_str_ [protected]

Fwd Addr in string format i.e hostname:port.

Definition at line 212 of file FlowSpec_Entry.h.

Referenced by address_str(), and parse_address().

ACE_CString TAO_FlowSpec_Entry::carrier_protocol_ [protected]

carrier protocol string.

Definition at line 233 of file FlowSpec_Entry.h.

Referenced by carrier_protocol_str(), TAO_Reverse_FlowSpec_Entry::entry_to_string(), TAO_Forward_FlowSpec_Entry::entry_to_string(), and parse_address().

int TAO_FlowSpec_Entry::clean_up_address_ [protected]

Definition at line 207 of file FlowSpec_Entry.h.

Referenced by address(), and parse_address().

int TAO_FlowSpec_Entry::clean_up_control_address_ [protected]

Definition at line 209 of file FlowSpec_Entry.h.

Referenced by parse_address().

ACE_Addr* TAO_FlowSpec_Entry::control_address_ [protected]

Definition at line 208 of file FlowSpec_Entry.h.

Referenced by control_address(), TAO_Forward_FlowSpec_Entry::entry_to_string(), parse_address(), and ~TAO_FlowSpec_Entry().

TAO_AV_Flow_Handler* TAO_FlowSpec_Entry::control_handler_ [protected]

Definition at line 256 of file FlowSpec_Entry.h.

Referenced by control_handler().

TAO_AV_Protocol_Object* TAO_FlowSpec_Entry::control_protocol_object_ [protected]

Definition at line 258 of file FlowSpec_Entry.h.

Referenced by control_protocol_object().

TAO_AV_Transport* TAO_FlowSpec_Entry::control_transport_ [protected]

Definition at line 254 of file FlowSpec_Entry.h.

Referenced by control_transport().

bool TAO_FlowSpec_Entry::delete_peer_addr_ [protected]

Definition at line 244 of file FlowSpec_Entry.h.

Referenced by TAO_Forward_FlowSpec_Entry::parse(), and set_peer_addr().

Direction TAO_FlowSpec_Entry::direction_ [protected]

Direction of this flow.

Definition at line 221 of file FlowSpec_Entry.h.

Referenced by direction(), and set_direction().

ACE_CString TAO_FlowSpec_Entry::direction_str_ [protected]

string representation of the direction.

Definition at line 224 of file FlowSpec_Entry.h.

Referenced by direction_str(), and set_direction().

ACE_CString TAO_FlowSpec_Entry::entry_ [protected]

The flowspec entry;.

Definition at line 241 of file FlowSpec_Entry.h.

ACE_CString TAO_FlowSpec_Entry::flow_protocol_ [protected]

flow protocol string.

Definition at line 236 of file FlowSpec_Entry.h.

Referenced by flow_protocol_str(), parse_flow_protocol_string(), and set_protocol().

ACE_CString TAO_FlowSpec_Entry::flowname_ [protected]

name of this flow.

Definition at line 227 of file FlowSpec_Entry.h.

Referenced by flowname(), TAO_Reverse_FlowSpec_Entry::parse(), and TAO_Forward_FlowSpec_Entry::parse().

ACE_CString TAO_FlowSpec_Entry::format_ [protected]

format string.

Definition at line 218 of file FlowSpec_Entry.h.

Referenced by format(), and TAO_Forward_FlowSpec_Entry::parse().

TAO_AV_Flow_Handler* TAO_FlowSpec_Entry::handler_ [protected]

Definition at line 255 of file FlowSpec_Entry.h.

Referenced by handler(), and set_peer_addr().

int TAO_FlowSpec_Entry::is_multicast_ [protected]

Definition at line 243 of file FlowSpec_Entry.h.

Referenced by is_multicast(), parse_address(), and set_protocol().

ACE_Addr* TAO_FlowSpec_Entry::local_addr_ [protected]

Definition at line 251 of file FlowSpec_Entry.h.

Referenced by get_local_addr(), get_local_addr_str(), and set_local_addr().

ACE_Addr* TAO_FlowSpec_Entry::local_control_addr_ [protected]

Definition at line 252 of file FlowSpec_Entry.h.

Referenced by get_local_control_addr(), set_local_control_addr(), and ~TAO_FlowSpec_Entry().

char** TAO_FlowSpec_Entry::local_sec_addr_ [protected]

Definition at line 246 of file FlowSpec_Entry.h.

Referenced by TAO_Reverse_FlowSpec_Entry::entry_to_string(), TAO_Forward_FlowSpec_Entry::entry_to_string(), get_local_sec_addr(), parse_address(), and set_local_sec_addr().

int TAO_FlowSpec_Entry::num_local_sec_addrs_ [protected]

Definition at line 247 of file FlowSpec_Entry.h.

Referenced by TAO_Reverse_FlowSpec_Entry::entry_to_string(), TAO_Forward_FlowSpec_Entry::entry_to_string(), num_local_sec_addrs(), parse_address(), and set_local_sec_addr().

int TAO_FlowSpec_Entry::num_peer_sec_addrs_ [protected]

Definition at line 249 of file FlowSpec_Entry.h.

Referenced by TAO_Forward_FlowSpec_Entry::entry_to_string(), num_peer_sec_addrs(), TAO_Forward_FlowSpec_Entry::parse(), and set_peer_sec_addr().

ACE_Addr* TAO_FlowSpec_Entry::peer_addr_ [protected]

Definition at line 245 of file FlowSpec_Entry.h.

Referenced by TAO_Forward_FlowSpec_Entry::entry_to_string(), get_peer_addr(), TAO_Forward_FlowSpec_Entry::parse(), set_peer_addr(), and ~TAO_FlowSpec_Entry().

ACE_CString TAO_FlowSpec_Entry::peer_address_str_ [protected]

Peer Addr in string format i.e hostname:port.

Definition at line 215 of file FlowSpec_Entry.h.

ACE_Addr* TAO_FlowSpec_Entry::peer_control_addr_ [protected]

Definition at line 250 of file FlowSpec_Entry.h.

char** TAO_FlowSpec_Entry::peer_sec_addr_ [protected]

Definition at line 248 of file FlowSpec_Entry.h.

Referenced by TAO_Forward_FlowSpec_Entry::entry_to_string(), get_peer_sec_addr(), TAO_Forward_FlowSpec_Entry::parse(), and set_peer_sec_addr().

TAO_AV_Core::Protocol TAO_FlowSpec_Entry::protocol_ [protected]

name of the protocol used.

Definition at line 230 of file FlowSpec_Entry.h.

Referenced by carrier_protocol(), parse_address(), and set_protocol().

TAO_AV_Protocol_Object* TAO_FlowSpec_Entry::protocol_object_ [protected]

Definition at line 257 of file FlowSpec_Entry.h.

Referenced by protocol_object().

Role TAO_FlowSpec_Entry::role_ [protected]

Definition at line 259 of file FlowSpec_Entry.h.

Referenced by role(), TAO_Reverse_FlowSpec_Entry::role(), and TAO_Forward_FlowSpec_Entry::role().

TAO_AV_Transport* TAO_FlowSpec_Entry::transport_ [protected]

Definition at line 253 of file FlowSpec_Entry.h.

Referenced by transport().

int TAO_FlowSpec_Entry::use_flow_protocol_ [protected]

Definition at line 238 of file FlowSpec_Entry.h.

Referenced by parse_flow_protocol_string().

The documentation for this class was generated from the following files:

Generated on Tue Feb 2 17:48:09 2010 for TAO_AV by

1.4.7

TAO_FlowSpec_Entry Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation