Split the Transport files for different protocols like UDP and TCP seperate

files. Also added a new Protocol_Factory.{h,cpp} which contains the factory
information. Added new flow protocol classes and remodelled the architecture
with true layering between the Protocol_Object and the Transport class.

31 files changed, 4374 insertions, 4256 deletions

diff --git a/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.cpp b/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.cpp
index 219d4ff5b9b..f12a7b83547 100644
--- a/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.cpp
@@ -1551,31 +1551,15 @@ TAO_Base_StreamEndPoint::set_protocol_object (const char */*flowname*/,
 }
 
 int
-TAO_Base_StreamEndPoint::set_rtcp_info (const char */* flowname */,
-                                        TAO_AV_SourceManager *,
-                                        TAO_AV_RTP_State *)
+TAO_Base_StreamEndPoint::get_callback (const char */*flowname*/,
+                                       TAO_AV_Callback *&/*sfp_callback*/)
 {
   return -1;
 }
 
 int
-TAO_Base_StreamEndPoint::get_rtp_source (TAO_AV_Source *&source,
-                                         const char *flowname,
-                                         ACE_UINT32 srcid,
-                                         ACE_UINT32 ssrc,
-                                         ACE_UINT32 addr)
-{
-  ACE_NEW_RETURN (source,
-                  TAO_AV_Source (srcid,
-                                 ssrc,
-                                 addr),
-                  -1);
-  return 0;
-}
-
-int
-TAO_Base_StreamEndPoint::get_callback (const char */*flowname*/,
-                                       TAO_AV_Callback *&/*sfp_callback*/)
+TAO_Base_StreamEndPoint::get_control_callback (const char */*flowname*/,
+                                               TAO_AV_Callback *&/*sfp_callback*/)
 {
   return -1;
 }
@@ -1689,12 +1673,12 @@ TAO_StreamEndPoint::connect (AVStreams::StreamEndPoint_ptr responder,
                       "TAO_StreamEndPoint::connect:%s\n",
                       flow_spec[i].in ()));
           TAO_Forward_FlowSpec_Entry *entry = 0;
-          if (i >= FLOWSPEC_MAX)
+          //          if (i >= FLOWSPEC_MAX)
               ACE_NEW_RETURN (entry,
                               TAO_Forward_FlowSpec_Entry,
                               0);
-          else
-            entry = &this->forward_entries_[i];
+//           else
+//             entry = &this->forward_entries_[i];
           if (entry->parse (flow_spec[i]) == -1)
             return 0;
           this->forward_flow_spec_set.insert (entry);
@@ -1716,15 +1700,17 @@ TAO_StreamEndPoint::connect (AVStreams::StreamEndPoint_ptr responder,
                                             ACE_TRY_ENV);
 
       ACE_TRY_CHECK;
+      if (retv == 0)
+        return retv;
       for (i=0;i<flow_spec.length ();i++)
         {
           TAO_Reverse_FlowSpec_Entry *entry = 0;
-          if (i >= FLOWSPEC_MAX)
+          //          if (i >= FLOWSPEC_MAX)
               ACE_NEW_RETURN (entry,
                               TAO_Reverse_FlowSpec_Entry,
                               0);
-          else
-            entry = &this->reverse_entries_[i];
+//           else
+//             entry = &this->reverse_entries_[i];
           if (entry->parse (flow_spec[i].in ()) == -1)
             ACE_ERROR_RETURN ((LM_ERROR,"Reverse_Flow_Spec_Set::parse failed\n"),0);
           this->reverse_flow_spec_set.insert (entry);
@@ -1868,7 +1854,7 @@ TAO_StreamEndPoint::destroy (const AVStreams::flowSpec &flow_spec,
               TAO_FlowSpec_Entry *entry = *begin;
               if (ACE_OS::strcmp (entry->flowname (),flow_spec [i]) == 0)
                 {
-                  entry->protocol_object ()->end_stream ();
+                  entry->protocol_object ()->destroy ();
                   break;
                 }
             }
@@ -1881,7 +1867,7 @@ TAO_StreamEndPoint::destroy (const AVStreams::flowSpec &flow_spec,
            begin != end; ++begin)
         {
           TAO_FlowSpec_Entry *entry = *begin;
-          entry->protocol_object ()->end_stream ();
+          entry->protocol_object ()->destroy ();
         }
     }
 
@@ -1928,10 +1914,12 @@ TAO_StreamEndPoint::request_connection (AVStreams::StreamEndPoint_ptr /*initiato
             return 0;
           this->forward_flow_spec_set.insert (entry);
         }
-      TAO_AV_CORE::instance ()->init_forward_flows (this,
-                                                    this->forward_flow_spec_set,
-                                                    TAO_AV_Core::TAO_AV_ENDPOINT_B,
-                                                    flow_spec);
+      result = TAO_AV_CORE::instance ()->init_forward_flows (this,
+                                                             this->forward_flow_spec_set,
+                                                             TAO_AV_Core::TAO_AV_ENDPOINT_B,
+                                                             flow_spec);
+      if (result < 0)
+        return 0;
       // Make the upcall to the app
       result = this->handle_connection_requested (flow_spec,ACE_TRY_ENV);
       ACE_TRY_CHECK;
@@ -2221,22 +2209,22 @@ TAO_StreamEndPoint::~TAO_StreamEndPoint (void)
   // or is it an implementation fact of ACE containers.
   for ( ; begin != end; ++begin,++i)
     {
-      if (i >= FLOWSPEC_MAX)
-        {
+//       if (i >= FLOWSPEC_MAX)
+//         {
           TAO_FlowSpec_Entry *entry = *begin;
           delete entry;
-        }
+          //        }
     }
   begin = this->reverse_flow_spec_set.begin ();
   end = this->reverse_flow_spec_set.end ();
   i = 0;
   for (; begin != end; ++begin)
     {
-      if (i >= FLOWSPEC_MAX)
-        {
+//       if (i >= FLOWSPEC_MAX)
+//         {
           TAO_FlowSpec_Entry *entry = *begin;
           delete entry;
-        }
+          //        }
     }
 }
 
@@ -2270,6 +2258,14 @@ TAO_StreamEndPoint_A::multiconnect (AVStreams::streamQoS &stream_qos,
           forward_entry->parse (flow_spec[i]);
           TAO_String_Hash_Key mcast_key (forward_entry->flowname ());
           AVStreams::FlowEndPoint_ptr flow_endpoint = AVStreams::FlowEndPoint::_nil ();
+          // @@Naga: There is a problem in the full profile case for multiconnect. Since 
+          // multiconnect on sep_a is called everytime a sink is added and if called for
+          // the same flow twice, the following code will just call add producer on the flow connection. 
+          // It is however very hard to find out if the flow producer is already in the flow connection
+          // since comparing object references will not work and the flowproducer reference is 
+          // generated by _narrow. Our only hope is that _narrow on the same fep will return the same
+          // pointer for the flowproducer in which case we can find out if the flowproducer exists in
+          // fep set for that flowconnection.
           if (this->fep_map_.find (mcast_key,flow_endpoint) == 0)
             {
               ACE_TRY_EX (narrow)
@@ -3609,7 +3605,30 @@ TAO_FlowConnection::add_producer (AVStreams::FlowProducer_ptr producer,
     {
           AVStreams::FlowProducer_ptr flow_producer =
             AVStreams::FlowProducer::_duplicate (producer);
-          this->flow_producer_set_.insert (flow_producer);
+          // @@Naga:Sometimes the same producer could be added with a different object reference. 
+          // There's no portable way of comparing obj refs. but we have to do this till we find
+          // a permanent solution.For eg. 2 different flowproducers for the same flow in a 
+          // Multipoint to Multipoint binding will have the same flowname and hence cannot be 
+          // used for resolving ties.
+          FlowProducer_SetItor begin = this->flow_producer_set_.begin ();
+          FlowProducer_SetItor end = this->flow_producer_set_.end ();
+          for (; begin != end; ++begin)
+            {
+              if ((*begin)->_is_equivalent (producer,
+                                            ACE_TRY_ENV))
+              // producer exists in the set, a duplicate.
+              ACE_ERROR_RETURN ((LM_WARNING,"TAO_FlowConnection::add_producer: producer already exists\n"),1);
+            }
+          // We need to check the return value of the insert into the flow producer
+          // set, since multiconnect could be called many times which will lead to
+          // a call to add_producer every time a sink is added. If the producer is already 
+          // present in our list we just return immediately.
+          int result = this->flow_producer_set_.insert (flow_producer);
+          if (result == 1)
+            {
+              // producer exists in the set, a duplicate.
+              ACE_ERROR_RETURN ((LM_WARNING,"TAO_FlowConnection::add_producer: producer already exists\n"),1);
+            }
           CORBA::Boolean met_qos;
           char mcast_address[BUFSIZ];
           if (this->producer_address_.in () == 0)
@@ -3680,12 +3699,28 @@ TAO_FlowConnection::add_consumer (AVStreams::FlowConsumer_ptr consumer,
     {
       AVStreams::FlowConsumer_ptr flow_consumer =
         AVStreams::FlowConsumer::_duplicate (consumer);
-      this->flow_consumer_set_.insert (flow_consumer);
-      FlowProducer_SetItor begin = this->flow_producer_set_.begin ();
+      FlowConsumer_SetItor begin = this->flow_consumer_set_.begin ();
+      FlowConsumer_SetItor end = this->flow_consumer_set_.end ();
+      for (; begin != end; ++begin)
+        {
+          if ((*begin)->_is_equivalent (consumer,
+                                        ACE_TRY_ENV))
+            // Consumer exists in the set, a duplicate.
+            ACE_ERROR_RETURN ((LM_WARNING,"TAO_FlowConnection::add_Consumer: Consumer already exists\n"),1);
+        }
+      int result = this->flow_consumer_set_.insert (flow_consumer);
+      if (result == 1)
+        {
+          // consumer exists in the set, a duplicate.
+          ACE_ERROR_RETURN ((LM_WARNING,"TAO_FlowConnection::add_consumer: consumer already exists\n"),1);
+        }
+
+      FlowProducer_SetItor producer_begin = this->flow_producer_set_.begin ();
       // @@Lets take that the first entry as the only producer. We're
       // not sure if we can have multiple flow producers in a
-      // flowconnection.
-      AVStreams::FlowProducer_ptr flow_producer = (*begin);
+      // flowconnection. We can have multiple producer in the MtM binding, 
+      // in which case the first producer that gets added is the leader.
+      AVStreams::FlowProducer_ptr flow_producer = (*producer_begin);
 
       AVStreams::protocolSpec protocols (1);
       protocols.length (1);
@@ -3778,7 +3813,6 @@ void
 TAO_FlowEndPoint::set_handler (const char *flowname,
                                TAO_AV_Flow_Handler *handler)
 {
-  this->handler_ = handler;
 }
 
 int
@@ -3866,7 +3900,10 @@ TAO_FlowEndPoint::destroy (CORBA::Environment &/*ACE_TRY_ENV*/)
   int result = deactivate_servant (this);
   if (result < 0)
     if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_StreamEndPoint::destroy failed\n"));
-  this->protocol_object_->end_stream ();
+  TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
+  for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
+       begin != end; ++begin)
+    (*begin)->protocol_object ()->destroy ();
 }
 
 AVStreams::StreamEndPoint_ptr
@@ -4134,16 +4171,29 @@ TAO_FlowEndPoint::set_Mcast_peer (AVStreams::FlowConnection_ptr /* the_fc */,
 }
 
 char *
-TAO_FlowEndPoint::go_to_listen (AVStreams::QoS & /*the_qos*/,
-                                CORBA::Boolean is_mcast,
-                                AVStreams::FlowEndPoint_ptr peer_fep,
-                                char *& flowProtocol,
-                                CORBA::Environment &ACE_TRY_ENV)
+TAO_FlowEndPoint::go_to_listen_i (TAO_FlowSpec_Entry::Role role,
+                                  AVStreams::QoS & /*the_qos*/,
+                                  CORBA::Boolean is_mcast,
+                                  AVStreams::FlowEndPoint_ptr peer_fep,
+                                  char *& flowProtocol,
+                                  CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    AVStreams::failedToListen,
                    AVStreams::FPError,
                    AVStreams::QoSRequestFailed))
 {
+  char direction [BUFSIZ];
+  switch (role)
+    {
+    case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
+      ACE_OS::strcpy (direction,"IN");
+      break;
+    case TAO_FlowSpec_Entry::TAO_AV_CONSUMER:
+      ACE_OS::strcpy (direction,"OUT");
+      break;
+    default:
+      break;
+    }
   AVStreams::protocolSpec my_protocol_spec,peer_protocol_spec;
   AVStreams::protocolSpec_ptr temp_protocols;
   CORBA::Any_var AvailableProtocols_ptr =
@@ -4189,18 +4239,17 @@ TAO_FlowEndPoint::go_to_listen (AVStreams::QoS & /*the_qos*/,
         TAO_Forward_FlowSpec_Entry *entry;
         ACE_NEW_RETURN (entry,
                         TAO_Forward_FlowSpec_Entry (this->flowname_.in (),
-                                                    CORBA::string_dup (""),
+                                                    direction,
                                                     this->format_.in (),
                                                     flowProtocol,
                                                     this->protocol_addresses_ [j]),
                         0);
 
         TAO_AV_Acceptor_Registry *acceptor_registry = TAO_AV_CORE::instance ()->acceptor_registry ();
-        TAO_AV_FlowSpecSet flow_spec_set;
-        flow_spec_set.insert (entry);
+        this->flow_spec_set_.insert (entry);
         int result = acceptor_registry->open (this,
                                               TAO_AV_CORE::instance (),
-                                              flow_spec_set);
+                                              this->flow_spec_set_);
         if (result < 0)
           return 0;
         char *listen_address = entry->get_local_addr_str ();
@@ -4216,29 +4265,41 @@ TAO_FlowEndPoint::go_to_listen (AVStreams::QoS & /*the_qos*/,
 
 
 CORBA::Boolean
-TAO_FlowEndPoint::connect_to_peer (AVStreams::QoS & /*the_qos*/,
-                                   const char * address,
-                                   const char * use_flow_protocol,
-                                   CORBA::Environment &/*ACE_TRY_ENV*/)
+TAO_FlowEndPoint::connect_to_peer_i (TAO_FlowSpec_Entry::Role role,
+                                     AVStreams::QoS & /*the_qos*/,
+                                     const char * address,
+                                     const char * use_flow_protocol,
+                                     CORBA::Environment &/*ACE_TRY_ENV*/)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    AVStreams::failedToConnect,
                    AVStreams::FPError,
                    AVStreams::QoSRequestFailed))
 {
+  char direction [BUFSIZ];
+  switch (role)
+    {
+    case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
+      ACE_OS::strcpy (direction,"IN");
+      break;
+    case TAO_FlowSpec_Entry::TAO_AV_CONSUMER:
+      ACE_OS::strcpy (direction,"OUT");
+      break;
+    default:
+      break;
+    }
   TAO_Forward_FlowSpec_Entry *entry;
   ACE_NEW_RETURN (entry,
                   TAO_Forward_FlowSpec_Entry (this->flowname_.in (),
-                                              "OUT",
+                                              direction,
                                               this->format_.in (),
                                               use_flow_protocol,
                                               address),
                   0);
-  TAO_AV_FlowSpecSet flow_spec_set;
-  flow_spec_set.insert (entry);
+  this->flow_spec_set_.insert (entry);
   TAO_AV_Connector_Registry *connector_registry = TAO_AV_CORE::instance ()->connector_registry ();
   int result = connector_registry->open (this,
                                          TAO_AV_CORE::instance (),
-                                         flow_spec_set);
+                                         this->flow_spec_set_);
   if (result < 0)
     ACE_ERROR_RETURN ((LM_ERROR,"TAO_FlowEndPoint::connector_registry::open failed\n"),0);
   this->reverse_channel_ = entry->get_local_addr_str ();
@@ -4246,11 +4307,9 @@ TAO_FlowEndPoint::connect_to_peer (AVStreams::QoS & /*the_qos*/,
 }
 
 int
-TAO_FlowEndPoint::set_protocol_object (const char */*flowname*/,
+TAO_FlowEndPoint::set_protocol_object (const char *flowname,
                                        TAO_AV_Protocol_Object *object)
 {
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_FlowEndPoint::set_protocol_object\n"));
-  this->protocol_object_ = object;
   return 0;
 }
 
@@ -4285,19 +4344,64 @@ void
 TAO_FlowProducer::stop (CORBA::Environment &/*ACE_TRY_ENV*/)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  //  this->protocol_object_->stop ();
-  this->handler_->stop (TAO_FlowSpec_Entry::TAO_AV_PRODUCER);
+  TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
+  for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
+       begin != end; ++begin)
+    {
+      TAO_FlowSpec_Entry *entry = (*begin);
+      entry->handler ()->stop (TAO_FlowSpec_Entry::TAO_AV_PRODUCER);
+    }
 }
 
 void
 TAO_FlowProducer::start (CORBA::Environment &/*ACE_TRY_ENV*/)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  //  this->protocol_object_->start ();
-  this->handler_->start (TAO_FlowSpec_Entry::TAO_AV_PRODUCER);
+  TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
+  for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
+       begin != end; ++begin)
+    {
+      TAO_FlowSpec_Entry *entry = (*begin);
+      entry->handler ()->start (TAO_FlowSpec_Entry::TAO_AV_PRODUCER);
+    }
+}
+
+char *
+TAO_FlowProducer::go_to_listen (AVStreams::QoS & the_qos,
+                                CORBA::Boolean is_mcast,
+                                AVStreams::FlowEndPoint_ptr peer_fep,
+                                char *& flowProtocol,
+                                CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException,
+                   AVStreams::failedToListen,
+                   AVStreams::FPError,
+                   AVStreams::QoSRequestFailed))
+{
+  return this->go_to_listen_i (TAO_FlowSpec_Entry::TAO_AV_PRODUCER,
+                               the_qos,
+                               is_mcast,
+                               peer_fep,
+                               flowProtocol,
+                               ACE_TRY_ENV);
 }
 
-//  multicast is currently not supported
+CORBA::Boolean
+TAO_FlowProducer::connect_to_peer (AVStreams::QoS & the_qos,
+                                   const char * address,
+                                   const char * use_flow_protocol,
+                                   CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException,
+                   AVStreams::failedToConnect,
+                   AVStreams::FPError,
+                   AVStreams::QoSRequestFailed))
+{
+  return this->connect_to_peer_i (TAO_FlowSpec_Entry::TAO_AV_PRODUCER,
+                                  the_qos,
+                                  address,
+                                  use_flow_protocol,
+                                  ACE_TRY_ENV);
+}
+//  Connect to a IP multicast address.
 char *
 TAO_FlowProducer::connect_mcast (AVStreams::QoS & /* the_qos */,
                                  CORBA::Boolean_out /* is_met */,
@@ -4315,23 +4419,26 @@ TAO_FlowProducer::connect_mcast (AVStreams::QoS & /* the_qos */,
     {
       // choose the protocol which supports multicast.
     }
-  TAO_Forward_FlowSpec_Entry  entry (this->flowname_.in (),
-                                     "IN",
-                                     this->format_.in (),
-                                     use_flow_protocol,
-                                     address);
-  TAO_AV_FlowSpecSet mcast_set;
-  mcast_set.insert (&entry);
+  TAO_Forward_FlowSpec_Entry  *entry;
+  ACE_NEW_RETURN (entry,
+                  TAO_Forward_FlowSpec_Entry(this->flowname_.in (),
+                                             "IN",
+                                             this->format_.in (),
+                                             use_flow_protocol,
+                                             address),
+                  0);
+
+  this->flow_spec_set_.insert (entry);
   TAO_AV_Acceptor_Registry *acceptor_registry =
     TAO_AV_CORE::instance ()->acceptor_registry ();
   int result = acceptor_registry->open (this,
                                         TAO_AV_CORE::instance (),
-                                        mcast_set);
+                                        this->flow_spec_set_);
   if (result < 0)
     ACE_ERROR_RETURN ((LM_ERROR,"TAO_FlowProducer::connect_mcast:acceptor_registry open failed\n"),0);
   // Now remove our handler from the reactor since we're a producer and dont want to get called for
   // multicast packets.
-  ACE_Event_Handler *event_handler = entry.handler ()->event_handler ();
+  ACE_Event_Handler *event_handler = entry->handler ()->event_handler ();
   event_handler->reactor ()->remove_handler (event_handler,
                                              ACE_Event_Handler::READ_MASK);
   return CORBA::string_dup (address);
@@ -4391,16 +4498,56 @@ void
 TAO_FlowConsumer::stop (CORBA::Environment &/*ACE_TRY_ENV*/)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  //  this->protocol_object_->stop ();
-  this->handler_->stop (TAO_FlowSpec_Entry::TAO_AV_CONSUMER);
+  TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
+  for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
+       begin != end; ++begin)
+    (*begin)->handler ()->stop (TAO_FlowSpec_Entry::TAO_AV_CONSUMER);
 }
 
 void
 TAO_FlowConsumer::start (CORBA::Environment &/*ACE_TRY_ENV*/)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  //  this->protocol_object_->start ();
-  this->handler_->start (TAO_FlowSpec_Entry::TAO_AV_CONSUMER);
+  TAO_AV_FlowSpecSetItor end = this->flow_spec_set_.end ();
+  for (TAO_AV_FlowSpecSetItor begin = this->flow_spec_set_.begin ();
+       begin != end; ++begin)
+    (*begin)->handler ()->start (TAO_FlowSpec_Entry::TAO_AV_CONSUMER);
+}
+
+char *
+TAO_FlowConsumer::go_to_listen (AVStreams::QoS & the_qos,
+                                CORBA::Boolean is_mcast,
+                                AVStreams::FlowEndPoint_ptr peer_fep,
+                                char *& flowProtocol,
+                                CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException,
+                   AVStreams::failedToListen,
+                   AVStreams::FPError,
+                   AVStreams::QoSRequestFailed))
+{
+  return this->go_to_listen_i (TAO_FlowSpec_Entry::TAO_AV_CONSUMER,
+                               the_qos,
+                               is_mcast,
+                               peer_fep,
+                               flowProtocol,
+                               ACE_TRY_ENV);
+}
+
+CORBA::Boolean
+TAO_FlowConsumer::connect_to_peer (AVStreams::QoS & the_qos,
+                                   const char * address,
+                                   const char * use_flow_protocol,
+                                   CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException,
+                   AVStreams::failedToConnect,
+                   AVStreams::FPError,
+                   AVStreams::QoSRequestFailed))
+{
+  return this->connect_to_peer_i (TAO_FlowSpec_Entry::TAO_AV_CONSUMER,
+                                  the_qos,
+                                  address,
+                                  use_flow_protocol,
+                                  ACE_TRY_ENV);
 }
 
 //------------------------------------------------------------
@@ -4617,15 +4764,23 @@ template class ACE_DLList_Iterator <TAO_FlowConsumer>;
 template class ACE_Node <TAO_FlowSpec_Entry*>;
 template class ACE_Unbounded_Set <TAO_FlowSpec_Entry*>;
 template class ACE_Unbounded_Set_Iterator <TAO_FlowSpec_Entry*>;
-template class ACE_Node <TAO_AV_Protocol_Item*>;
+
+template class ACE_Node <TAO_AV_Transport_Item*>;
+template class ACE_Unbounded_Set<TAO_AV_Transport_Item*>;
+template class ACE_Unbounded_Set_Iterator<TAO_AV_Transport_Item*>;
+
+template class ACE_Node <TAO_AV_Flow_Protocol_Item*>;
+template class ACE_Unbounded_Set<TAO_AV_Flow_Protocol_Item*>;
+template class ACE_Unbounded_Set_Iterator<TAO_AV_Flow_Protocol_Item*>;
+
 template class ACE_Node<AVStreams::FlowProducer *>;
-template class ACE_Node<AVStreams::FlowConsumer *>;
-template class ACE_Unbounded_Set<TAO_AV_Protocol_Item*>;
-template class ACE_Unbounded_Set<AVStreams::FlowConsumer *>;
 template class ACE_Unbounded_Set<AVStreams::FlowProducer *>;
-template class ACE_Unbounded_Set_Iterator<TAO_AV_Protocol_Item*>;
 template class ACE_Unbounded_Set_Iterator<AVStreams::FlowProducer *>;
+
+template class ACE_Node<AVStreams::FlowConsumer *>;
+template class ACE_Unbounded_Set<AVStreams::FlowConsumer *>;
 template class ACE_Unbounded_Set_Iterator<AVStreams::FlowConsumer *>;
+
 template class ACE_Map_Manager<int, ACE_Svc_Tuple<TAO_AV_TCP_Flow_Handler> *, ACE_RW_SYNCH_MUTEX>;
 template class ACE_Svc_Tuple<TAO_AV_TCP_Flow_Handler>;
 
@@ -4743,14 +4898,22 @@ template class ACE_Svc_Tuple<TAO_AV_TCP_Flow_Handler>;
 #pragma instantiate ACE_Node <TAO_FlowSpec_Entry*>
 #pragma instantiate ACE_Unbounded_Set <TAO_FlowSpec_Entry*>
 #pragma instantiate ACE_Unbounded_Set_Iterator <TAO_FlowSpec_Entry*>
-#pragma instantiate ACE_Node <TAO_AV_Protocol_Item*>
+
+#pragma instantiate ACE_Node <TAO_AV_Transport_Item*>
+#pragma instantiate ACE_Unbounded_Set<TAO_AV_Transport_Item*>
+#pragma instantiate ACE_Unbounded_Set_Iterator<TAO_AV_Transport_Item*>
+
+#pragma instantiate ACE_Node <TAO_AV_Flow_Protocol_Item*>
+#pragma instantiate ACE_Unbounded_Set<TAO_AV_Flow_Protocol_Item*>
+#pragma instantiate ACE_Unbounded_Set_Iterator<TAO_AV_Transport_Item*>
+
 #pragma instantiate ACE_Node<AVStreams::FlowProducer *>
+#pragma instantiate ACE_Unbounded_Set<AVStreams::FlowProducer *>
+#pragma instantiate ACE_Unbounded_Set_Iterator<AVStreams::FlowProducer *>
+
 #pragma instantiate ACE_Node<AVStreams::FlowConsumer *>
-#pragma instantiate ACE_Unbounded_Set<TAO_AV_Protocol_Item*>
-#pragma instantiate ACE_Unbounded_Set_Iterator<TAO_AV_Protocol_Item*>
 #pragma instantiate ACE_Unbounded_Set<AVStreams::FlowConsumer *>
-#pragma instantiate ACE_Unbounded_Set<AVStreams::FlowProducer *>
 #pragma instantiate ACE_Unbounded_Set_Iterator<AVStreams::FlowConsumer *>
-#pragma instantiate ACE_Unbounded_Set_Iterator<AVStreams::FlowProducer *>
+
 
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.h b/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.h
index fcffee3852c..ed6a1050f3c 100644
--- a/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.h
+++ b/TAO/orbsvcs/orbsvcs/AV/AVStreams_i.h
@@ -48,6 +48,10 @@
 
 #include "FlowSpec_Entry.h"
 
+#if defined(sun) || defined(__osf__)
+extern "C" int gethostname(char* name, int len);
+#endif
+
 #define FLOWSPEC_MAX 5
 // for the Hash_Map helper classes.
 
@@ -508,18 +512,12 @@ public:
   virtual int get_callback (const char *flowname,
                             TAO_AV_Callback *&callback);
 
+  virtual int get_control_callback (const char *flowname,
+                                    TAO_AV_Callback *&callback);
+
   virtual int set_protocol_object (const char *flowname,
                                    TAO_AV_Protocol_Object *object);
 
-  virtual int set_rtcp_info (const char *flowname,
-                             TAO_AV_SourceManager *source_manager,
-                             TAO_AV_RTP_State *state);
-
-  virtual int get_rtp_source (TAO_AV_Source *&source,
-                              const char *flowname,
-                              ACE_UINT32 srcid,
-                              ACE_UINT32 ssrc,
-                              ACE_UINT32 addr);
   virtual void set_handler (const char *flowname,
                             TAO_AV_Flow_Handler *handler);
 };
@@ -697,8 +695,8 @@ protected:
   AVStreams::StreamEndPoint_var peer_sep_;
   AVStreams::SFPStatus *sfp_status_;
   AVStreams::StreamCtrl_var streamctrl_;
-  TAO_Forward_FlowSpec_Entry forward_entries_ [FLOWSPEC_MAX];
-  TAO_Reverse_FlowSpec_Entry reverse_entries_ [FLOWSPEC_MAX];
+//   TAO_Forward_FlowSpec_Entry forward_entries_ [FLOWSPEC_MAX];
+//   TAO_Reverse_FlowSpec_Entry reverse_entries_ [FLOWSPEC_MAX];
 };
 
 
@@ -1252,6 +1250,20 @@ public:
     ACE_THROW_SPEC ((CORBA::SystemException,
                      AVStreams::failedToConnect,
                      AVStreams::FPError,
+                     AVStreams::QoSRequestFailed)) = 0;
+  // This should be implemented in both the FlowProducer and consumer and hence is
+  // pure virtual since we need to know the role of the flowendpoint to create appropriate
+  // protocol objects. eg. in SFP to create Producer Object/ Consumer Object.
+
+  virtual CORBA::Boolean connect_to_peer_i (TAO_FlowSpec_Entry::Role role,
+                                            AVStreams::QoS & the_qos,
+                                            const char * address,
+                                            const char * use_flow_protocol,
+                                            CORBA::Environment &env =
+                                            CORBA::Environment::default_environment ())
+    ACE_THROW_SPEC ((CORBA::SystemException,
+                     AVStreams::failedToConnect,
+                     AVStreams::FPError,
                      AVStreams::QoSRequestFailed));
   // connect to the peer endpoint.
 
@@ -1264,6 +1276,21 @@ public:
     ACE_THROW_SPEC ((CORBA::SystemException,
                      AVStreams::failedToListen,
                      AVStreams::FPError,
+                     AVStreams::QoSRequestFailed)) = 0;
+  // This should be implemented in both the FlowProducer and consumer and hence is
+  // pure virtual since we need to know the role of the flowendpoint to create appropriate
+  // protocol objects. eg. in SFP to create Producer Object/ Consumer Object.
+
+  virtual char * go_to_listen_i (TAO_FlowSpec_Entry::Role role,
+                                 AVStreams::QoS & the_qos,
+                                 CORBA::Boolean is_mcast,
+                                 AVStreams::FlowEndPoint_ptr peer,
+                                 char *& flowProtocol,
+                                 CORBA::Environment &env =
+                                 CORBA::Environment::default_environment ())
+    ACE_THROW_SPEC ((CORBA::SystemException,
+                     AVStreams::failedToListen,
+                     AVStreams::FPError,
                      AVStreams::QoSRequestFailed));
 
   // listen request from the peer.
@@ -1293,8 +1320,7 @@ protected:
   CORBA::String_var format_;
   CORBA::String_var flowname_;
   CosPropertyService::Properties dev_params_;
-  TAO_AV_Protocol_Object *protocol_object_;
-  TAO_AV_Flow_Handler *handler_;
+  TAO_AV_FlowSpecSet flow_spec_set_;
   CORBA::String_var reverse_channel_;
 };
 
@@ -1330,6 +1356,27 @@ public:
     ACE_THROW_SPEC ((CORBA::SystemException));
   // start this flow, to be overridden by the application.
 
+  virtual char * go_to_listen (AVStreams::QoS & the_qos,
+                               CORBA::Boolean is_mcast,
+                               AVStreams::FlowEndPoint_ptr peer,
+                               char *& flowProtocol,
+                               CORBA::Environment &env =
+                               CORBA::Environment::default_environment ())
+    ACE_THROW_SPEC ((CORBA::SystemException,
+                     AVStreams::failedToListen,
+                     AVStreams::FPError,
+                     AVStreams::QoSRequestFailed));
+
+  virtual CORBA::Boolean connect_to_peer (AVStreams::QoS & the_qos,
+                                          const char * address,
+                                          const char * use_flow_protocol,
+                                          CORBA::Environment &env =
+                                          CORBA::Environment::default_environment ())
+    ACE_THROW_SPEC ((CORBA::SystemException,
+                     AVStreams::failedToConnect,
+                     AVStreams::FPError,
+                     AVStreams::QoSRequestFailed));
+
   virtual char * connect_mcast (AVStreams::QoS & the_qos,
                                 CORBA::Boolean_out is_met,
                                 const char * address,
@@ -1383,6 +1430,27 @@ public:
                       CORBA::Environment::default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
   // start this flow, to be overridden by the application.
+
+  virtual char * go_to_listen (AVStreams::QoS & the_qos,
+                               CORBA::Boolean is_mcast,
+                               AVStreams::FlowEndPoint_ptr peer,
+                               char *& flowProtocol,
+                               CORBA::Environment &env =
+                               CORBA::Environment::default_environment ())
+    ACE_THROW_SPEC ((CORBA::SystemException,
+                     AVStreams::failedToListen,
+                     AVStreams::FPError,
+                     AVStreams::QoSRequestFailed));
+
+  virtual CORBA::Boolean connect_to_peer (AVStreams::QoS & the_qos,
+                                          const char * address,
+                                          const char * use_flow_protocol,
+                                          CORBA::Environment &env =
+                                          CORBA::Environment::default_environment ())
+    ACE_THROW_SPEC ((CORBA::SystemException,
+                     AVStreams::failedToConnect,
+                     AVStreams::FPError,
+                     AVStreams::QoSRequestFailed));
 };
 
 
diff --git a/TAO/orbsvcs/orbsvcs/AV/AV_Core.h b/TAO/orbsvcs/orbsvcs/AV/AV_Core.h
index bc9f7371317..f98863df02a 100644
--- a/TAO/orbsvcs/orbsvcs/AV/AV_Core.h
+++ b/TAO/orbsvcs/orbsvcs/AV/AV_Core.h
@@ -30,41 +30,73 @@ class TAO_AV_Connector;
 class TAO_FlowSpec_Entry;
 
 //forward declaration.
-class TAO_AV_Protocol_Factory;
+class TAO_AV_Transport_Factory;
 
-class TAO_Export TAO_AV_Protocol_Item
+class TAO_Export TAO_AV_Transport_Item
 {
 public:
-  TAO_AV_Protocol_Item (const ACE_CString &name);
-  // creator method, the protocol name can only be set when the
+  TAO_AV_Transport_Item (const ACE_CString &name);
+  // creator method, the Transport name can only be set when the
   // object is created.
 
-  const ACE_CString &protocol_name (void);
-  // return a reference to the character representation of the protocol
+  const ACE_CString &name (void);
+  // return a reference to the character representation of the Transport
   // factories name.
 
-  TAO_AV_Protocol_Factory *factory (void);
-  // return a pointer to the protocol factory.
+  TAO_AV_Transport_Factory *factory (void);
+  // return a pointer to the Transport factory.
 
-  void factory (TAO_AV_Protocol_Factory *factory);
+  void factory (TAO_AV_Transport_Factory *factory);
   // set the factory pointer's valus.
 
 private:
   ACE_CString name_;
-  // protocol factory name.
+  // Transport factory name.
 
-  TAO_AV_Protocol_Factory *factory_;
+  TAO_AV_Transport_Factory *factory_;
   // pointer to factory object.
 };
 
-// typedefs for containers containing the list of loaded protocol
+class TAO_AV_Flow_Protocol_Factory;
+
+class TAO_Export TAO_AV_Flow_Protocol_Item
+{
+public:
+  TAO_AV_Flow_Protocol_Item (const ACE_CString &name);
+  // creator method, the Flow_Protocol name can only be set when the
+  // object is created.
+
+  const ACE_CString &name (void);
+  // return a reference to the character representation of the Flow_Protocol
+  // factories name.
+
+  TAO_AV_Flow_Protocol_Factory *factory (void);
+  // return a pointer to the Flow_Protocol factory.
+
+  void factory (TAO_AV_Flow_Protocol_Factory *factory);
+  // set the factory pointer's valus.
+
+private:
+  ACE_CString name_;
+  // Flow_Protocol factory name.
+
+  TAO_AV_Flow_Protocol_Factory *factory_;
+  // pointer to factory object.
+};
+
+// typedefs for containers containing the list of loaded Flow_Protocol
 // factories.
-typedef ACE_Unbounded_Set<TAO_AV_Protocol_Item*>
-        TAO_AV_ProtocolFactorySet;
+typedef ACE_Unbounded_Set<TAO_AV_Flow_Protocol_Item*>
+        TAO_AV_Flow_ProtocolFactorySet;
+
+typedef ACE_Unbounded_Set_Iterator<TAO_AV_Flow_Protocol_Item*>
+        TAO_AV_Flow_ProtocolFactorySetItor;
 
-typedef ACE_Unbounded_Set_Iterator<TAO_AV_Protocol_Item*>
-        TAO_AV_ProtocolFactorySetItor;
+typedef ACE_Unbounded_Set<TAO_AV_Transport_Item*>
+        TAO_AV_TransportFactorySet;
 
+typedef ACE_Unbounded_Set_Iterator<TAO_AV_Transport_Item*>
+        TAO_AV_TransportFactorySetItor;
 
 typedef ACE_Unbounded_Set <TAO_FlowSpec_Entry*> TAO_AV_FlowSpecSet;
 typedef ACE_Unbounded_Set_Iterator <TAO_FlowSpec_Entry*> TAO_AV_FlowSpecSetItor;
@@ -92,13 +124,13 @@ public:
   };
 
   TAO_AV_Core (void);
-  // = Get the connector registry
+  // Default constructor.
 
   ~TAO_AV_Core (void);
   // Destructor.
 
   int init (int &argc,
-            char **argv,
+            char *argv [],
             CORBA::Environment &env);
   int run (void);
   int stop_run (void);
@@ -110,7 +142,8 @@ public:
                           TAO_AV_FlowSpecSet &forward_flow_spec_set,
                           TAO_AV_FlowSpecSet &reverse_flow_spec_set,
                           EndPoint direction);
-  int init_protocol_factories (void);
+  int init_transport_factories (void);
+  int init_flow_protocol_factories (void);
 
   TAO_AV_Acceptor *get_acceptor (const char *flowname);
   TAO_AV_Connector *get_connector (const char *flowname);
@@ -121,11 +154,13 @@ public:
   TAO_AV_Acceptor_Registry  *acceptor_registry  (void);
 
   // = Get the protocol factories
-  TAO_AV_ProtocolFactorySet *protocol_factories (void);
+  TAO_AV_Flow_ProtocolFactorySet *flow_protocol_factories (void);
+  TAO_AV_TransportFactorySet *transport_factories (void);
   // = Set/get the <ACE_Reactor>.
   void reactor (ACE_Reactor *r);
   ACE_Reactor *reactor (void);
   TAO_ORB_Manager *orb_manager (void);
+
 protected:
   TAO_AV_Connector_Registry *connector_registry_;
   // The connector registry which all active connecters must register
@@ -135,8 +170,11 @@ protected:
   // The registry which maintains a list of acceptor factories for each
   // loaded protocol.
 
-  TAO_AV_ProtocolFactorySet protocol_factories_;
-  // Pointer to the list of protocol loaded into this ORB instance.
+  TAO_AV_TransportFactorySet transport_factories_;
+  // Pointer to the list of transports loaded into this AV_Core instance.
+
+  TAO_AV_Flow_ProtocolFactorySet flow_protocol_factories_;
+  // Pointer to the list of flow protocol loaded into this AV_Core instance.
 
   ACE_Reactor *reactor_;
   CORBA::ORB_var orb_;
diff --git a/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.cpp b/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.cpp
index e2a68cc6afb..b1e2917f794 100644
--- a/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.cpp
@@ -25,7 +25,8 @@ TAO_FlowSpec_Entry::TAO_FlowSpec_Entry (void)
    local_addr_ (0),
    transport_ (0),
    handler_ (0),
-   protocol_object_ (0)
+   protocol_object_ (0),
+   is_multicast_ (0)
 {
 }
 
@@ -49,10 +50,12 @@ TAO_FlowSpec_Entry::TAO_FlowSpec_Entry (const char *flowname,
    local_addr_ (0),
    transport_ (0),
    handler_ (0),
-   protocol_object_ (0)
+   protocol_object_ (0),
+   is_multicast_ (0)
 {
   this->set_protocol ();
   this->set_direction (this->direction_str_);
+  this->parse_flow_protocol_string (this->flow_protocol_);
 }
 
 TAO_FlowSpec_Entry::TAO_FlowSpec_Entry (const char *flowname,
@@ -73,7 +76,8 @@ TAO_FlowSpec_Entry::TAO_FlowSpec_Entry (const char *flowname,
    local_addr_ (0),
    transport_ (0),
    handler_ (0),
-   protocol_object_ (0)
+   protocol_object_ (0),
+   is_multicast_ (0)
 {
   ACE_CString cstring(this->address_str_,0,0);
   int colon_pos = cstring.find (':');
@@ -141,6 +145,7 @@ TAO_FlowSpec_Entry::set_protocol (void)
       if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_FlowSpec_Entry::set_protocol:%s\n",buf));
       if (IN_CLASSD (inet_addr->get_ip_address ()))
         {
+          this->is_multicast_ = 1;
           switch (this->protocol_)
             {
             case TAO_AV_Core::TAO_AV_UDP:
@@ -194,20 +199,23 @@ TAO_FlowSpec_Entry::parse_address (char *address)
                             -1);
             this->address_ = inet_addr;
             if (IN_CLASSD (inet_addr->get_ip_address ()))
-              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;
-                default:
-                  break;
-                }
+              {
+                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;
+                  default:
+                    break;
+                  }
+              }
           }
           break;
         default:
@@ -297,14 +305,14 @@ TAO_Forward_FlowSpec_Entry::parse (const char *flowSpec_entry)
   if (tokenizer [TAO_AV_FORMAT] != 0)
     this->format_ = tokenizer [TAO_AV_FORMAT];
 
-  if (tokenizer [TAO_AV_FLOW_PROTOCOL] != 0)
-    if (this->parse_flow_protocol_string (tokenizer [TAO_AV_FLOW_PROTOCOL]) < 0)
-      return -1;
-
   if (tokenizer [TAO_AV_ADDRESS] != 0)
     if (this->parse_address (tokenizer [TAO_AV_ADDRESS]) < 0)
       return -1;
 
+  if (tokenizer [TAO_AV_FLOW_PROTOCOL] != 0)
+    if (this->parse_flow_protocol_string (tokenizer [TAO_AV_FLOW_PROTOCOL]) < 0)
+      return -1;
+
   return 0;
 }
 
@@ -439,14 +447,14 @@ TAO_Reverse_FlowSpec_Entry::parse (const char *flowSpec_entry)
   TAO_Tokenizer tokenizer (flowSpec_entry,'\\');
   this->flowname_ = tokenizer [TAO_AV_FLOWNAME];
 
-  if (tokenizer [TAO_AV_FLOW_PROTOCOL] != 0)
-    if (this->parse_flow_protocol_string (tokenizer [TAO_AV_FLOW_PROTOCOL]) < 0)
-      return -1;
-
   if (tokenizer [TAO_AV_ADDRESS] != 0)
     if (this->parse_address (tokenizer [TAO_AV_ADDRESS]) < 0)
       return -1;
 
+  if (tokenizer [TAO_AV_FLOW_PROTOCOL] != 0)
+    if (this->parse_flow_protocol_string (tokenizer [TAO_AV_FLOW_PROTOCOL]) < 0)
+      return -1;
+
   if (tokenizer [TAO_AV_DIRECTION] != 0)
     this->set_direction (tokenizer [TAO_AV_DIRECTION]);
 
diff --git a/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.h b/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.h
index 4a2d686f656..3ecff97e0e0 100644
--- a/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.h
+++ b/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.h
@@ -142,7 +142,12 @@ public:
 
   int parse_address (char *format_string);
   // sets the address for this flow.
+
+  int is_multicast (void);
+  // returns true for a multicast address.
+
 protected:
+
   int parse_flow_protocol_string (char *flow_options_string);
   // parses the flow protocol string with tokens separated by :
 
@@ -184,6 +189,7 @@ protected:
   char *entry_;
   // The flowspec entry;
 
+  int is_multicast_;
   ACE_Addr *peer_addr_;
   ACE_Addr *local_addr_;
   TAO_AV_Transport *transport_;
diff --git a/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.i b/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.i
index cf39fb3f7bc..404e58d1f1c 100644
--- a/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.i
+++ b/TAO/orbsvcs/orbsvcs/AV/FlowSpec_Entry.i
@@ -186,3 +186,9 @@ TAO_FlowSpec_Entry::protocol_object (TAO_AV_Protocol_Object *object)
   this->protocol_object_ = object;
 }
 
+ACE_INLINE
+int
+TAO_FlowSpec_Entry::is_multicast (void)
+{
+  return this->is_multicast_;
+}
diff --git a/TAO/orbsvcs/orbsvcs/AV/MCast.cpp b/TAO/orbsvcs/orbsvcs/AV/MCast.cpp
index 28fbfafd541..6deb81ea0af 100644
--- a/TAO/orbsvcs/orbsvcs/AV/MCast.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/MCast.cpp
@@ -5,268 +5,15 @@
 #include "AVStreams_i.h"
 
 //------------------------------------------------------------
-// TAO_AV_UDP_MCast_Acceptor
-//------------------------------------------------------------
-
-TAO_AV_UDP_MCast_Acceptor::TAO_AV_UDP_MCast_Acceptor (void)
-{
-}
-
-TAO_AV_UDP_MCast_Acceptor::~TAO_AV_UDP_MCast_Acceptor (void)
-{
-}
-
-int
-TAO_AV_UDP_MCast_Acceptor::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&mcast_handler)
-{
-  TAO_AV_Callback *callback = 0;
-  if (this->endpoint_ != 0)
-    {
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (mcast_handler,
-                      TAO_AV_UDP_MCast_Flow_Handler (callback),
-                      -1);
-      callback->transport (mcast_handler->transport ());
-      TAO_AV_Protocol_Object *object =0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_UDP_MCast_Object (callback,
-                                               mcast_handler->transport ()),
-                      -1);
-      mcast_handler->protocol_object (object);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),mcast_handler);
-      this->entry_->protocol_object (object);
-      this->entry_->handler (mcast_handler);
-    }
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Acceptor::open_i (ACE_Reactor *reactor,
-                                   ACE_INET_Addr *&mcast_addr,
-                                   TAO_AV_UDP_MCast_Flow_Handler *&handler)
-
-{
-  this->make_svc_handler (handler);
-  int result = handler->get_mcast_socket ()->subscribe (*mcast_addr);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_MCast_connector::open failed\n"),-1);
-  // Now disable Multicast loopback.
-  // @@Should we make this a policy?
-  if (handler->get_mcast_socket ()->set_option (IP_MULTICAST_LOOP,
-                                            0) < 0)
-    if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Acceptor::multicast loop disable failed\n"));
-  // @@ This should also be policies.
-  int bufsize = 80 * 1024;
-  if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
-                                                          SO_RCVBUF,
-                                                          (char *)&bufsize,
-                                                          sizeof(bufsize)) < 0)
-    {
-      bufsize = 32 * 1024;
-      if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
-                                                              SO_RCVBUF,
-                                                              (char *)&bufsize,
-                                                              sizeof(bufsize)) < 0)
-      perror("SO_RCVBUF");
-    }
-
-  result = this->activate_svc_handler (handler);
-  if (result < 0)
-    return result;
-//   ACE_INET_Addr *local_addr = 0;
-//   ACE_NEW_RETURN (local_addr,
-//                   ACE_INET_Addr,
-//                   -1);
-//   handler->get_mcast_socket ()->get_local_addr (*local_addr);
-//   mcast_addr = local_addr;
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
-                                 TAO_AV_Core *av_core,
-                                 TAO_FlowSpec_Entry *entry)
-{
-  this->av_core_ = av_core;
-  this->endpoint_ = endpoint;
-  this->entry_ = entry;
-
-  ACE_INET_Addr *mcast_addr = ACE_dynamic_cast (ACE_INET_Addr*,entry->address ());
-  this->open_i (av_core->reactor (),
-                mcast_addr,
-                this->handler_);
-
-  entry->handler (this->handler_);
-  entry->set_local_addr (mcast_addr);
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Acceptor::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_UDP_MCast_Acceptor::open_default\n"));
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Acceptor::activate_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *handler)
-{
-  ACE_Event_Handler *event_handler = handler;
-  //  ACE_HANDLE fd = event_handler->get_handle ();
-  int result = this->av_core_->reactor ()->register_handler (event_handler,
-                                                 ACE_Event_Handler::READ_MASK);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Acceptor::activate_svc_handler failed\n"),result);
-  event_handler->reactor (this->av_core_->reactor ());
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Acceptor::close (void)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_MCast_Connector
-//------------------------------------------------------------
-TAO_AV_UDP_MCast_Connector::TAO_AV_UDP_MCast_Connector (void)
-{
-}
-
-TAO_AV_UDP_MCast_Connector::~TAO_AV_UDP_MCast_Connector (void)
-{
-}
-
-int
-TAO_AV_UDP_MCast_Connector::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&mcast_handler)
-{
-  TAO_AV_Callback *callback = 0;
-  if (this->endpoint_ != 0)
-    {
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (mcast_handler,
-                      TAO_AV_UDP_MCast_Flow_Handler (callback),
-                      -1);
-      callback->transport (mcast_handler->transport ());
-      TAO_AV_Protocol_Object *object =0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_UDP_MCast_Object (callback,
-                                               mcast_handler->transport ()),
-                      -1);
-      mcast_handler->protocol_object (object);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),mcast_handler);
-      this->entry_->protocol_object (object);
-      this->entry_->handler (mcast_handler);
-    }
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Connector::open (TAO_Base_StreamEndPoint *endpoint,
-                                  TAO_AV_Core *av_core)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Connector::open "));
-  this->endpoint_ = endpoint;
-  this->av_core_ = av_core;
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Connector::connect_i (ACE_Reactor *reactor,
-                                       ACE_INET_Addr *&mcast_addr,
-                                       TAO_AV_UDP_MCast_Flow_Handler *&handler)
-{
-  this->make_svc_handler (handler);
-  int result = handler->get_mcast_socket ()->subscribe (*mcast_addr);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_MCast_connector::open failed\n"),-1);
-  // Now disable Multicast loopback.
-  // @@Should we make this a policy?
-  if (handler->get_mcast_socket ()->set_option (IP_MULTICAST_LOOP,
-                                            0) < 0)
-    if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Acceptor::multicast loop disable failed\n"));
-  int bufsize = 80 * 1024;
-  if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
-                                                          SO_RCVBUF,
-                                                          (char *)&bufsize,
-                                                          sizeof(bufsize)) < 0)
-    {
-      bufsize = 32 * 1024;
-      if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
-                                                              SO_RCVBUF,
-                                                              (char *)&bufsize,
-                                                              sizeof(bufsize)) < 0)
-      perror("SO_RCVBUF");
-    }
-
-  result = this->activate_svc_handler (handler);
-  if (result < 0)
-    return result;
-//   ACE_INET_Addr *local_addr = 0;
-//   ACE_NEW_RETURN (local_addr,
-//                   ACE_INET_Addr,
-//                   -1);
-//   handler->get_mcast_socket ()->get_local_addr (*local_addr);
-//  mcast_addr = local_addr;
-}
-
-int
-TAO_AV_UDP_MCast_Connector::connect (TAO_FlowSpec_Entry *entry,
-                                     TAO_AV_Transport *&transport)
-{
-  this->entry_ = entry;
-  ACE_INET_Addr *mcast_addr = ACE_dynamic_cast (ACE_INET_Addr *,entry->address ());
-  this->connect_i (this->av_core_->reactor (),
-                   mcast_addr,
-                   this->handler_);
-  entry->handler (this->handler_);
-  transport = this->handler_->transport ();
-  entry->set_local_addr (mcast_addr);
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Connector::activate_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *handler)
-{
-  ACE_Event_Handler *event_handler = handler;
-  //  ACE_HANDLE fd = event_handler->get_handle ();
-  int result = this->av_core_->reactor ()->register_handler (event_handler,
-                                                 ACE_Event_Handler::READ_MASK);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Acceptor::activate_svc_handler failed\n"),result);
-  event_handler->reactor (this->av_core_->reactor ());
-  return 0;
-}
-
-int
-TAO_AV_UDP_MCast_Connector::close (void)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
 //TAO_AV_UDP_MCast_Flow_Handler
 //------------------------------------------------------------
 
-TAO_AV_UDP_MCast_Flow_Handler::TAO_AV_UDP_MCast_Flow_Handler (TAO_AV_Callback *callback)
-  :TAO_AV_Flow_Handler (callback)
+TAO_AV_UDP_MCast_Flow_Handler::TAO_AV_UDP_MCast_Flow_Handler (void)
 {
   ACE_NEW (transport_,
            TAO_AV_UDP_MCast_Transport (this));
   ACE_NEW (dgram_mcast_,
            ACE_SOCK_Dgram_Mcast);
-
 }
 
 TAO_AV_UDP_MCast_Flow_Handler::~TAO_AV_UDP_MCast_Flow_Handler (void)
@@ -279,19 +26,7 @@ TAO_AV_UDP_MCast_Flow_Handler::~TAO_AV_UDP_MCast_Flow_Handler (void)
 int
 TAO_AV_UDP_MCast_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
 {
-  size_t size = 2*this->transport_->mtu ();
-  ACE_Message_Block *frame = 0;
-  ACE_NEW_RETURN (frame,
-                  ACE_Message_Block (size),
-                  -1);
-  int n = this->transport_->recv (frame->rd_ptr (),
-                                  frame->size ());
-  if (n == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_MCast_Flow_Handler::handle_input recv failed\n"),-1);
-  if (n == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_MCast_Flow_Handler::handle_input connection closed\n"),-1);
-  frame->wr_ptr (n);
-  this->callback_->receive_frame (frame);
+  this->protocol_object_->handle_input ();
   return 0;
 }
 
@@ -441,17 +176,6 @@ TAO_AV_UDP_MCast_Transport::mtu (void)
 }
 
 
-//ACE_INLINE ssize_t
-//TAO_AV_UDP_MCast_Transport::send (const iovec *iov,
-//                                  int iovcnt,
-//                                  ACE_Time_Value *)
-//{
-//  return this->handler_->get_mcast_socket ()->send (iov,
-//                                                    iovcnt,
-//                                                    0);
-//
-//}
-//
 ACE_INLINE ssize_t
 TAO_AV_UDP_MCast_Transport::recv (char *buf,
                                   size_t len,
@@ -481,45 +205,3 @@ TAO_AV_UDP_MCast_Transport::recv (iovec *iov,
 {
   return handler_->get_mcast_socket ()->recv (iov,this->peer_addr_,0,timeout);
 }
-
-
-//------------------------------------------------------------
-// TAO_AV_UDP_MCast_Protocol_Factory
-//------------------------------------------------------------
-
-TAO_AV_UDP_MCast_Protocol_Factory::TAO_AV_UDP_MCast_Protocol_Factory (void)
-{
-}
-
-TAO_AV_UDP_MCast_Protocol_Factory::~TAO_AV_UDP_MCast_Protocol_Factory (void)
-{
-}
-
-int
-TAO_AV_UDP_MCast_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_UDP_MCAST);
-}
-
-
-TAO_AV_Acceptor*
-TAO_AV_UDP_MCast_Protocol_Factory::make_acceptor (void)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Protocol_Factory::make_acceptor "));
-  TAO_AV_Acceptor *acceptor = 0;
-  ACE_NEW_RETURN (acceptor,
-                  TAO_AV_UDP_MCast_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector*
-TAO_AV_UDP_MCast_Protocol_Factory::make_connector (void)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Protocol_Factory::make_connector "));
-  TAO_AV_Connector *connector = 0;
-  ACE_NEW_RETURN (connector,
-                  TAO_AV_UDP_MCast_Connector,
-                  0);
-  return connector;
-}
diff --git a/TAO/orbsvcs/orbsvcs/AV/MCast.h b/TAO/orbsvcs/orbsvcs/AV/MCast.h
index 3f3a13e465c..530163eaa49 100644
--- a/TAO/orbsvcs/orbsvcs/AV/MCast.h
+++ b/TAO/orbsvcs/orbsvcs/AV/MCast.h
@@ -16,11 +16,11 @@
 //
 // ============================================================================
 
-
 #ifndef TAO_AV_MCAST_H
 #define TAO_AV_MCAST_H
 
 #include "FlowSpec_Entry.h"
+#include "Protocol_Factory.h"
 #include "ace/INET_Addr.h"
 #include "ace/SOCK_Dgram_Mcast.h"
 
@@ -30,10 +30,10 @@ class TAO_AV_UDP_MCast_Transport
   :public TAO_AV_Transport
 {
   // = TITLE
-  //     A transport abstraction for socket streams.
+  //     A transport abstraction for Multicast dgram sockets.
   //
   // = DESCRIPTION
-  //     Uses the ACE_SOCK_Stream to send the data.
+  //     Uses the ACE_SOCK_Dgram_Mcast to send the data.
 public:
   TAO_AV_UDP_MCast_Transport (void);
 
@@ -84,65 +84,12 @@ protected:
   ACE_INET_Addr local_addr_;
 };
 
-class TAO_AV_UDP_MCast_Acceptor
-  :public TAO_AV_Acceptor
-{
-public:
-  TAO_AV_UDP_MCast_Acceptor (void);
-  virtual ~TAO_AV_UDP_MCast_Acceptor (void);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core,
-                    TAO_FlowSpec_Entry *entry);
-  virtual int open_i (ACE_Reactor *reactor,
-                      ACE_INET_Addr *&address,
-                      TAO_AV_UDP_MCast_Flow_Handler *&handler);
-
-  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core,
-                            TAO_FlowSpec_Entry *entry);
-  virtual int close (void);
-  virtual int make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&udp_handler);
-  virtual int activate_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *handler);
-protected:
-  TAO_FlowSpec_Entry *entry_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  TAO_AV_Core *av_core_;
-  TAO_AV_UDP_MCast_Flow_Handler *handler_;
-};
-
-class TAO_AV_UDP_MCast_Connector
-  :public TAO_AV_Connector
-{
-public:
-  TAO_AV_UDP_MCast_Connector (void);
-  virtual ~TAO_AV_UDP_MCast_Connector (void);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core);
-
-  virtual int connect (TAO_FlowSpec_Entry *entry,
-                       TAO_AV_Transport *&transport);
-
-  int connect_i (ACE_Reactor *reactor,
-                 ACE_INET_Addr *&address,
-                 TAO_AV_UDP_MCast_Flow_Handler *&handler);
-
-  virtual int close (void);
-  virtual int make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&udp_handler);
-  virtual int activate_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *handler);
-protected:
-  ACE_CString flowname_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  TAO_AV_Core *av_core_;
-  TAO_FlowSpec_Entry *entry_;
-  TAO_AV_UDP_MCast_Flow_Handler *handler_;
-};
-
 class TAO_AV_UDP_MCast_Flow_Handler
   :public virtual TAO_AV_Flow_Handler,
    public virtual ACE_Event_Handler
 {
 public:
-  TAO_AV_UDP_MCast_Flow_Handler (TAO_AV_Callback *callback);
+  TAO_AV_UDP_MCast_Flow_Handler (void);
   // Ctor
   ~TAO_AV_UDP_MCast_Flow_Handler (void);
   // Dtor
@@ -156,17 +103,6 @@ protected:
   ACE_SOCK_Dgram_Mcast *dgram_mcast_;
 };
 
-class TAO_AV_UDP_MCast_Protocol_Factory
-  :public TAO_AV_Protocol_Factory
-{
-public:
-  TAO_AV_UDP_MCast_Protocol_Factory (void);
-  virtual ~TAO_AV_UDP_MCast_Protocol_Factory (void);
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  virtual TAO_AV_Connector *make_connector (void);
-};
-
 #if defined(__ACE_INLINE__)
 #include "MCast.i"
 #endif /* __ACE_INLINE__ */
diff --git a/TAO/orbsvcs/orbsvcs/AV/Nil.cpp b/TAO/orbsvcs/orbsvcs/AV/Nil.cpp
index 719db950241..d084789c6b3 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Nil.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/Nil.cpp
@@ -3,123 +3,43 @@
 #include "Nil.h"
 #include "FlowSpec_Entry.h"
 
-//------------------------------------------------------------
-// TAO_AV_TCP_Object
-//------------------------------------------------------------
-
-int
-TAO_AV_TCP_Object::send_frame (ACE_Message_Block *frame,
-                               TAO_AV_frame_info *frame_info)
-{
-  int result = this->transport_->send (frame);
-  if (result < 0)
-    return result;
-  return 0;
-}
-
-int 
-TAO_AV_TCP_Object::send_frame (const iovec *iov,
-                               int iovcnt,
-                               TAO_AV_frame_info *frame_info)
-{
-  return this->transport_->send (iov,iovcnt);
-}
-
-TAO_AV_TCP_Object::TAO_AV_TCP_Object (TAO_AV_Callback *callback,
-                                      TAO_AV_Transport *transport)
-  :TAO_AV_Protocol_Object (callback,transport)
-{
-}
-
-TAO_AV_TCP_Object::~TAO_AV_TCP_Object (void)
-{
-  // No-op
-}
-int
-TAO_AV_TCP_Object::end_stream (void)
-{
-  this->callback_->handle_end_stream ();
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_Object
-//------------------------------------------------------------
-
-int
-TAO_AV_UDP_Object::send_frame (ACE_Message_Block *frame,
-                               TAO_AV_frame_info *frame_info)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Object::send_frame\n"));
-  int result = this->transport_->send (frame);
-  if (result < 0)
-    return result;
-  return 0;
-}
-
-int 
-TAO_AV_UDP_Object::send_frame (const iovec *iov,
-                               int iovcnt,
-                               TAO_AV_frame_info *frame_info)
-{
-  return this->transport_->send (iov,iovcnt);
-}
-
-TAO_AV_UDP_Object::TAO_AV_UDP_Object (TAO_AV_Callback *callback,
-                                      TAO_AV_Transport *transport)
-  :TAO_AV_Protocol_Object (callback,transport)
-{
-}
-
-TAO_AV_UDP_Object::~TAO_AV_UDP_Object (void)
-{
-  //no-op
-}
-
-int
-TAO_AV_UDP_Object::end_stream (void)
-{
-  this->callback_->handle_end_stream ();
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_MCast_Object
-//------------------------------------------------------------
-
-
-TAO_AV_UDP_MCast_Object::TAO_AV_UDP_MCast_Object (TAO_AV_Callback *callback,
-                                                  TAO_AV_Transport *transport)
-  :TAO_AV_Protocol_Object (callback,transport)
-{
-}
-
-TAO_AV_UDP_MCast_Object::~TAO_AV_UDP_MCast_Object (void)
-{
-  //no-op
-}
-
-int
-TAO_AV_UDP_MCast_Object::send_frame (ACE_Message_Block *frame,
-                                     TAO_AV_frame_info *frame_info)
-{
-  int result = this->transport_->send (frame);
-  if (result < 0)
-    return result;
-  return 0;
-}
-
-int 
-TAO_AV_UDP_MCast_Object::send_frame (const iovec *iov,
-                                     int iovcnt,
-                                     TAO_AV_frame_info *frame_info)
-{
-  return this->transport_->send (iov,iovcnt);
-}
-
-int
-TAO_AV_UDP_MCast_Object::end_stream (void)
-{
-  this->callback_->handle_end_stream ();
-  return 0;
-}
+// //------------------------------------------------------------
+// // TAO_AV_UDP_MCast_Object
+// //------------------------------------------------------------
+
+
+// TAO_AV_UDP_MCast_Object::TAO_AV_UDP_MCast_Object (TAO_AV_Callback *callback,
+//                                                   TAO_AV_Transport *transport)
+//   :TAO_AV_Protocol_Object (callback,transport)
+// {
+// }
+
+// TAO_AV_UDP_MCast_Object::~TAO_AV_UDP_MCast_Object (void)
+// {
+//   //no-op
+// }
+
+// int
+// TAO_AV_UDP_MCast_Object::send_frame (ACE_Message_Block *frame,
+//                                      TAO_AV_frame_info *frame_info)
+// {
+//   int result = this->transport_->send (frame);
+//   if (result < 0)
+//     return result;
+//   return 0;
+// }
+
+// int 
+// TAO_AV_UDP_MCast_Object::send_frame (const iovec *iov,
+//                                      int iovcnt,
+//                                      TAO_AV_frame_info *frame_info)
+// {
+//   return this->transport_->send (iov,iovcnt);
+// }
+
+// int
+// TAO_AV_UDP_MCast_Object::end_stream (void)
+// {
+//   this->callback_->handle_end_stream ();
+//   return 0;
+// }
diff --git a/TAO/orbsvcs/orbsvcs/AV/Nil.h b/TAO/orbsvcs/orbsvcs/AV/Nil.h
index 7542e42afa7..350b038ad07 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Nil.h
+++ b/TAO/orbsvcs/orbsvcs/AV/Nil.h
@@ -21,67 +21,25 @@
 
 #include "Policy.h"
 
-class TAO_ORBSVCS_Export TAO_AV_TCP_Object : public TAO_AV_Protocol_Object
-{
-public:
-  TAO_AV_TCP_Object (TAO_AV_Callback *callback,
-                     TAO_AV_Transport *transport = 0);
+// class TAO_ORBSVCS_Export TAO_AV_UDP_MCast_Object  : public TAO_AV_Protocol_Object
+// {
+// public:
+//   TAO_AV_UDP_MCast_Object (TAO_AV_Callback *callback,
+//                            TAO_AV_Transport *transport = 0);
 
-  virtual ~TAO_AV_TCP_Object (void);
-  // Dtor
+//   virtual ~TAO_AV_UDP_MCast_Object (void);
+//   // Dtor
 
-  virtual int send_frame (ACE_Message_Block *frame,
-                          TAO_AV_frame_info *frame_info = 0);
-  // send a data frame.
+//   virtual int send_frame (ACE_Message_Block *frame,
+//                           TAO_AV_frame_info *frame_info = 0);
+//   // send a data frame.
 
-  virtual int send_frame (const iovec *iov,
-                          int iovcnt,
-                          TAO_AV_frame_info *frame_info = 0);
+//   virtual int send_frame (const iovec *iov,
+//                           int iovcnt,
+//                           TAO_AV_frame_info *frame_info = 0);
 
-  virtual int end_stream (void);
-  // end the stream.
+//   virtual int end_stream (void);
+//   // end the stream.
+// };
 
-};
-
-class TAO_ORBSVCS_Export TAO_AV_UDP_Object  : public TAO_AV_Protocol_Object
-{
-public:
-  TAO_AV_UDP_Object (TAO_AV_Callback *callback,
-                     TAO_AV_Transport *transport = 0);
-
-  virtual ~TAO_AV_UDP_Object (void);
-  // Dtor
-
-  virtual int send_frame (ACE_Message_Block *frame,
-                          TAO_AV_frame_info *frame_info = 0);
-  // send a data frame.
-
-  virtual int send_frame (const iovec *iov,
-                          int iovcnt,
-                          TAO_AV_frame_info *frame_info = 0);
-
-  virtual int end_stream (void);
-  // end the stream.
-};
-
-class TAO_ORBSVCS_Export TAO_AV_UDP_MCast_Object  : public TAO_AV_Protocol_Object
-{
-public:
-  TAO_AV_UDP_MCast_Object (TAO_AV_Callback *callback,
-                           TAO_AV_Transport *transport = 0);
-
-  virtual ~TAO_AV_UDP_MCast_Object (void);
-  // Dtor
-
-  virtual int send_frame (ACE_Message_Block *frame,
-                          TAO_AV_frame_info *frame_info = 0);
-  // send a data frame.
-
-  virtual int send_frame (const iovec *iov,
-                          int iovcnt,
-                          TAO_AV_frame_info *frame_info = 0);
-
-  virtual int end_stream (void);
-  // end the stream.
-};
 #endif /* TAO_AV_NIL_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/Policy.cpp b/TAO/orbsvcs/orbsvcs/AV/Policy.cpp
index e511082e09c..b024cb15d7a 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Policy.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/Policy.cpp
@@ -1,6 +1,7 @@
 // $Id$
 
 #include "Policy.h"
+#include "FlowSpec_Entry.h"
 
 TAO_AV_Policy::TAO_AV_Policy (TAO_AV_Policy::PolicyType type)
   :type_ (type)
@@ -66,59 +67,24 @@ TAO_AV_Policy_Manager::create_policy (TAO_AV_Policy::PolicyType type,
   return policy;
 }
 
-TAO_AV_Protocol_Object::TAO_AV_Protocol_Object (TAO_AV_Callback *callback,
-                                                TAO_AV_Transport *transport)
-  :transport_ (transport),
-   callback_ (callback)
-{
-}
-
-TAO_AV_Protocol_Object::~TAO_AV_Protocol_Object (void)
-{
-  //no-op
-}
-
-int
-TAO_AV_Protocol_Object::start (void)
-{
-  return this->callback_->handle_start ();
-}
+// TAO_AV_Callback
 
-int
-TAO_AV_Protocol_Object::stop (void)
+TAO_AV_Callback::TAO_AV_Callback (void)
+  //  :transport_ (0),
+   :protocol_object_ (0)
 {
-  return this->callback_->handle_stop ();
 }
 
-// int
-// TAO_AV_Protocol_Object::send_frame (const iovec *iov,
-//                                     int iovcnt,
-//                                     TAO_AV_frame_info *frame_info)
-// {
-//   ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Protocol_Object::send_frame\n"),-1);
-// }
-
 int
-TAO_AV_Protocol_Object::set_policies (const PolicyList &policy_list)
+TAO_AV_Callback::open (TAO_AV_Protocol_Object *object,
+                       TAO_AV_Flow_Handler *handler)
 {
-  this->policy_list_ = policy_list;
+  this->protocol_object_ = object;
+  this->handler_ = handler;
+  handler->callback (this);
   return 0;
 }
 
-PolicyList
-TAO_AV_Protocol_Object::get_policies (void)
-{
-  return this->policy_list_;
-}
-
-// TAO_AV_Callback
-
-TAO_AV_Callback::TAO_AV_Callback (void)
-  :transport_ (0),
-   protocol_object_ (0)
-{
-}
-
 int
 TAO_AV_Callback::handle_start (void)
 {
@@ -135,14 +101,22 @@ TAO_AV_Callback::handle_stop (void)
 
 int
 TAO_AV_Callback::receive_frame (ACE_Message_Block */*frame*/,
-                                TAO_AV_frame_info *)
+                                TAO_AV_frame_info *,
+                                const ACE_Addr &)
 {
   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_Callback::receive_frame\n"));
   return -1;
 }
 
 int
-TAO_AV_Callback::handle_end_stream (void)
+TAO_AV_Callback::receive_control_frame (ACE_Message_Block *,
+                                        const ACE_Addr& )
+{
+  return 0;
+}
+
+int
+TAO_AV_Callback::handle_destroy (void)
 {
   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_Callback::handle_end_stream\n"));
   return -1;
@@ -162,24 +136,17 @@ TAO_AV_Callback::handle_timeout (void *arg)
   return 0;
 }
 
-// int
-// TAO_AV_Callback::get_frame (ACE_Message_Block *&frame,
-//                             TAO_AV_frame_info *&frame_info)
+// TAO_AV_Transport*
+// TAO_AV_Callback::transport (void)
 // {
-//   return -1;
+//   return this->transport_;
 // }
 
-TAO_AV_Transport*
-TAO_AV_Callback::transport (void)
-{
-  return this->transport_;
-}
-
-void
-TAO_AV_Callback::transport (TAO_AV_Transport *transport)
-{
-  this->transport_ = transport;
-}
+// void
+// TAO_AV_Callback::transport (TAO_AV_Transport *transport)
+// {
+//   this->transport_ = transport;
+// }
 
 TAO_AV_Protocol_Object*
 TAO_AV_Callback::protocol_object (void)
@@ -187,10 +154,16 @@ TAO_AV_Callback::protocol_object (void)
   return this->protocol_object_;
 }
 
-void
-TAO_AV_Callback::protocol_object (TAO_AV_Protocol_Object *object)
+// void
+// TAO_AV_Callback::protocol_object (TAO_AV_Protocol_Object *object)
+// {
+//   this->protocol_object_ = object;
+// }
+
+int
+TAO_AV_Callback::schedule_timer (void)
 {
-  this->protocol_object_ = object;
+  return this->handler_->schedule_timer ();
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
diff --git a/TAO/orbsvcs/orbsvcs/AV/Policy.h b/TAO/orbsvcs/orbsvcs/AV/Policy.h
index 7d7997f39c1..926f9c711b1 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Policy.h
+++ b/TAO/orbsvcs/orbsvcs/AV/Policy.h
@@ -19,6 +19,7 @@
 #ifndef TAO_AV_POLICY_H
 #define TAO_AV_POLICY_H
 
+#include "ace/Addr.h"
 #include "tao/TAO.h"
 #include "tao/debug.h"
 #include "orbsvcs/orbsvcs_export.h"
@@ -26,6 +27,8 @@
 struct TAO_AV_frame_info
 {
   CORBA::Boolean boundary_marker;
+  CORBA::Octet format;
+  // @@ Shouldn't this be a string.
   CORBA::ULong timestamp;
   CORBA::ULong ssrc;
   CORBA::ULong sequence_num;
@@ -48,6 +51,7 @@ public:
     TAO_AV_RTCP_SDES_POLICY,
     TAO_AV_TIMESTAMP_POLICY
   };
+
   TAO_AV_Policy (PolicyType type);
   PolicyType type (void);
 protected:
@@ -110,13 +114,20 @@ public:
 
 class TAO_AV_Protocol_Object;
 class TAO_AV_Transport;
+class TAO_AV_Flow_Handler;
 
 class TAO_AV_Callback
 {
-  //@@coryan:Document this class.
-
+  // = TITLE
+  //     Callback class that the user will be implementing for receiving
+  //     frames from the network and also for timer events.
 public:
   TAO_AV_Callback (void);
+
+  int open (TAO_AV_Protocol_Object *object,
+            TAO_AV_Flow_Handler *handler);
+  // Called for opening the callback.
+
   virtual int handle_start (void);
   // Called during Streamctrl->start.
 
@@ -126,67 +137,32 @@ public:
   virtual int handle_timeout (void *arg);
   // Called during timeout for Flow Producers.
 
+  virtual int schedule_timer (void);
+
   virtual int receive_frame (ACE_Message_Block *frame,
-                             TAO_AV_frame_info *frame_info = 0);
+                             TAO_AV_frame_info *frame_info = 0,
+                             const ACE_Addr &address = ACE_Addr::sap_any);
+
   // Called when a frame arrives for a FlowConsumer.
 
-  virtual int handle_end_stream (void);
+  virtual int receive_control_frame (ACE_Message_Block *frame,
+                                     const ACE_Addr &address = ACE_Addr::sap_any);
+  // address from which the frame was received.
+
+  virtual int handle_destroy (void);
   // Called during Streamctrl->destroy i.e tear_down  of the stream
-  // @@coryan:Call it handle_destroy or handle_close.
 
   virtual void get_timeout (ACE_Time_Value *&tv,
                             void *&arg);
   // Called to get the timeout. If tv is 0 then the framework stop
-  // calling this.
+  // calling this. This will be called during the start of the frame
+  // and also if schedule_timer is called to get the timeout.
 
-//   virtual int get_frame (ACE_Message_Block *&frame,
-//                          TAO_AV_frame_info *&frame_info);
-  // @@: Should these be in the open method??
-  TAO_AV_Transport *transport (void);
-  void transport (TAO_AV_Transport *transport);
   TAO_AV_Protocol_Object *protocol_object (void);
-  void protocol_object (TAO_AV_Protocol_Object *object);
+  // Accessor to protocol object.
 protected:
-  TAO_AV_Transport *transport_;
   TAO_AV_Protocol_Object *protocol_object_;
-};
-
-class TAO_AV_Protocol_Object
-{
-public:
-  TAO_AV_Protocol_Object (TAO_AV_Callback *callback,
-                          TAO_AV_Transport *transport = 0);
-  // constructor.
-
-  virtual ~TAO_AV_Protocol_Object (void);
-  // Destructor
-
-  virtual int set_policies (const PolicyList &policy_list);
-  virtual PolicyList get_policies (void);
-  // set/get policies.
-
-  virtual int start (void);
-  virtual int stop (void);
-  // start/stop the flow.
-
-  virtual int send_frame (ACE_Message_Block *frame,
-                          TAO_AV_frame_info *frame_info = 0) = 0;
-  // send a data frame.
-
-  virtual int send_frame (const iovec *iov,
-                          int iovcnt,
-                          TAO_AV_frame_info *frame_info = 0) = 0;
-  // @@Naga: We might need to make this pure virtual
-  void transport (TAO_AV_Transport *transport);
-  TAO_AV_Transport *transport (void);
-  // set/get the transport.
-
-  virtual int end_stream (void) = 0;
-  // end the stream.
-protected:
-  TAO_AV_Transport *transport_;
-  PolicyList policy_list_;
-  TAO_AV_Callback *callback_;
+  TAO_AV_Flow_Handler *handler_;
 };
 
 #if defined(__ACE_INLINE__)
diff --git a/TAO/orbsvcs/orbsvcs/AV/Policy.i b/TAO/orbsvcs/orbsvcs/AV/Policy.i
index fb652bad800..e2dd0de51be 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Policy.i
+++ b/TAO/orbsvcs/orbsvcs/AV/Policy.i
@@ -55,22 +55,6 @@ TAO_AV_Timestamp_Policy::value (void)
   return this->timestamp_;
 }
 
-//--------------------------------------------------
-// TAO_AV_Protocol_Object
-//--------------------------------------------------
-
-ACE_INLINE TAO_AV_Transport*
-TAO_AV_Protocol_Object::transport (void)
-{
-  return this->transport_;
-}
-
-ACE_INLINE void
-TAO_AV_Protocol_Object::transport (TAO_AV_Transport *transport)
-{
-  this->transport_ = transport;
-}
-
 // TAO_AV_RTCP_Sdes_Policy
 ACE_INLINE TAO_AV_Policy::sdes &
 TAO_AV_RTCP_Sdes_Policy::value (void)
diff --git a/TAO/orbsvcs/orbsvcs/AV/Protocol_Factory.cpp b/TAO/orbsvcs/orbsvcs/AV/Protocol_Factory.cpp
new file mode 100644
index 00000000000..5314a9c4f43
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/Protocol_Factory.cpp
@@ -0,0 +1,157 @@
+// $Id$
+
+
+#include "Protocol_Factory.h"
+#include "ace/Dynamic_Service.h"
+
+TAO_AV_Transport_Factory::TAO_AV_Transport_Factory (void)
+{
+}
+
+TAO_AV_Transport_Factory::~TAO_AV_Transport_Factory (void)
+{
+}
+
+int
+TAO_AV_Transport_Factory::init (int /* argc */,
+                                char * /* argv */ [])
+{
+  return -1;
+}
+
+int
+TAO_AV_Transport_Factory::match_protocol (const char * /* protocol_string */)
+{
+  return 0;
+}
+
+TAO_AV_Acceptor *
+TAO_AV_Transport_Factory::make_acceptor (void)
+{
+  return 0;
+}
+
+TAO_AV_Connector *
+TAO_AV_Transport_Factory::make_connector (void)
+{
+  return 0;
+}
+
+// TAO_AV_Flow_Protocol_Factory
+TAO_AV_Flow_Protocol_Factory::TAO_AV_Flow_Protocol_Factory (void)
+{
+}
+
+TAO_AV_Flow_Protocol_Factory::~TAO_AV_Flow_Protocol_Factory (void)
+{
+}
+
+TAO_AV_Flow_Protocol_Factory::init (int /* argc */,
+                                    char * /* argv */ [])
+{
+  return -1;
+}
+
+int
+TAO_AV_Flow_Protocol_Factory::match_protocol (const char * /* protocol_string */)
+{
+  return 0;
+}
+
+TAO_AV_Protocol_Object*
+TAO_AV_Flow_Protocol_Factory::make_protocol_object (TAO_FlowSpec_Entry * /* entry */,
+                                                    TAO_Base_StreamEndPoint * /* endpoint */ ,
+                                                    TAO_AV_Flow_Handler * /* handler */,
+                                                    TAO_AV_Transport * /* transport */)
+{
+  return 0;
+}
+
+const char *
+TAO_AV_Flow_Protocol_Factory::control_flow_factory (void)
+{
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// TAO_AV_Protocol_Object
+//----------------------------------------------------------------------
+TAO_AV_Protocol_Object::TAO_AV_Protocol_Object (TAO_AV_Callback *callback,
+                                                TAO_AV_Transport *transport)
+  :transport_ (transport),
+   callback_ (callback)
+{
+}
+
+int
+TAO_AV_Protocol_Object::open (TAO_AV_Callback *callback,
+                              TAO_AV_Transport *transport)
+{
+  this->callback_ = callback;
+  this->transport_ = transport;
+  return 0;
+}
+
+TAO_AV_Protocol_Object::~TAO_AV_Protocol_Object (void)
+{
+  //no-op
+}
+
+int
+TAO_AV_Protocol_Object::start (void)
+{
+  return this->callback_->handle_start ();
+}
+
+int
+TAO_AV_Protocol_Object::stop (void)
+{
+  return this->callback_->handle_stop ();
+}
+
+int
+TAO_AV_Protocol_Object::set_policies (const PolicyList &policy_list)
+{
+  this->policy_list_ = policy_list;
+  return 0;
+}
+
+PolicyList
+TAO_AV_Protocol_Object::get_policies (void)
+{
+  return this->policy_list_;
+}
+
+TAO_AV_Transport*
+TAO_AV_Protocol_Object::transport (void)
+{
+  return this->transport_;
+}
+
+// void
+// TAO_AV_Protocol_Object::transport (TAO_AV_Transport *transport)
+// {
+//   this->transport_ = transport;
+// }
+
+void
+TAO_AV_Protocol_Object::control_object (TAO_AV_Protocol_Object * /* object */)
+{
+  return;
+}
+
+int
+TAO_AV_Protocol_Object::handle_control_input (ACE_Message_Block *,
+                                              const ACE_Addr &)
+{
+  ACE_DEBUG ((LM_DEBUG,"TAO_AV_Protocol_Object::handle_control_input\n"));
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Dynamic_Service<TAO_AV_Transport_Factory>;
+template class ACE_Dynamic_Service<TAO_AV_Flow_Protocol_Factory>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Dynamic_Service<TAO_AV_Transport_Factory>
+#pragma instantiate ACE_Dynamic_Service<TAO_AV_Flow_Protocol_Factory>
+#endif
diff --git a/TAO/orbsvcs/orbsvcs/AV/Protocol_Factory.h b/TAO/orbsvcs/orbsvcs/AV/Protocol_Factory.h
new file mode 100644
index 00000000000..c837004d757
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/Protocol_Factory.h
@@ -0,0 +1,117 @@
+/* -*- C++ -*- */
+
+// $Id$
+// ============================================================================
+//
+// = LIBRARY
+//   ORBSVCS AVStreams
+//
+// = FILENAME
+//   Protocol_Factory
+//
+// = AUTHOR
+//    Nagarajan Surendran <naga@cs.wustl.edu>
+//
+//
+// ============================================================================
+
+#ifndef TAO_AV_PROTOCOL_FACTORY_T_H
+#define TAO_AV_PROTOCOL_FACTORY_T_H
+
+#include "ace/Service_Object.h"
+#include "Policy.h"
+#include "FlowSpec_Entry.h"
+
+class TAO_ORBSVCS_Export TAO_AV_Transport_Factory : public ACE_Service_Object
+{
+public:
+  TAO_AV_Transport_Factory (void);
+  virtual ~TAO_AV_Transport_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *protocol_string);
+  virtual TAO_AV_Acceptor *make_acceptor (void);
+  virtual TAO_AV_Connector *make_connector (void);
+};
+
+class TAO_AV_Protocol_Object
+{
+public:
+  TAO_AV_Protocol_Object (void);
+
+  TAO_AV_Protocol_Object (TAO_AV_Callback *callback,
+                          TAO_AV_Transport *transport);
+  // constructor.
+
+  virtual ~TAO_AV_Protocol_Object (void);
+  // Destructor
+
+  virtual int open (TAO_AV_Callback *callback,
+                    TAO_AV_Transport *transport);
+
+  void role (TAO_FlowSpec_Entry::Role role);
+  // 0 = Producer, 1 = consumer.
+
+  virtual int handle_input (void) = 0;
+
+  virtual int handle_control_input (ACE_Message_Block *control_frame,
+                                    const ACE_Addr &peer_address);
+  // Called on a control object.
+
+  virtual int set_policies (const PolicyList &policy_list);
+  virtual PolicyList get_policies (void);
+  // set/get policies.
+
+  virtual int start (void);
+  virtual int stop (void);
+  // start/stop the flow.
+
+  virtual int send_frame (ACE_Message_Block *frame,
+                          TAO_AV_frame_info *frame_info = 0) = 0;
+  // send a data frame.
+
+  virtual int send_frame (const iovec *iov,
+                          int iovcnt,
+                          TAO_AV_frame_info *frame_info = 0) = 0;
+  // send a frame in iovecs.
+
+  virtual void control_object (TAO_AV_Protocol_Object *object);
+  virtual int destroy (void) = 0;
+  // end the stream.
+  TAO_AV_Transport *transport (void);
+protected:
+  TAO_AV_Transport *transport_;
+  PolicyList policy_list_;
+  TAO_AV_Callback *callback_;
+};
+
+class TAO_ORBSVCS_Export TAO_AV_Flow_Protocol_Factory : public ACE_Service_Object
+{
+public:
+  TAO_AV_Flow_Protocol_Factory (void);
+  virtual ~TAO_AV_Flow_Protocol_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *flow_string);
+  virtual TAO_AV_Protocol_Object* make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                        TAO_Base_StreamEndPoint *endpoint,
+                                                        TAO_AV_Flow_Handler *handler,
+                                                        TAO_AV_Transport *transport);
+  virtual const char *control_flow_factory (void);
+};
+
+class TAO_ORBSVCS_Export TAO_AV_SFP_Factory : public TAO_AV_Flow_Protocol_Factory
+{
+public:
+  TAO_AV_SFP_Factory (void);
+  virtual ~TAO_AV_SFP_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *flow_string);
+  virtual TAO_AV_Protocol_Object* make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                        TAO_Base_StreamEndPoint *endpoint,
+                                                        TAO_AV_Flow_Handler *handler,
+                                                        TAO_AV_Transport *transport);
+};
+
+#endif /* TAO_AV_PROTOCOL_FACTORY_T_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/RTCP.cpp b/TAO/orbsvcs/orbsvcs/AV/RTCP.cpp
index 199f2ed752b..a90c6c39224 100644
--- a/TAO/orbsvcs/orbsvcs/AV/RTCP.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/RTCP.cpp
@@ -33,15 +33,10 @@
  */
 
 // $Id$
-#include "RTP.h"
 #include "RTCP.h"
 #include "media-timer.h"
 #include "ntp-time.h"
 
-// static hash map of rtcp handlers for all the flows.
-TAO_AV_RTCP::RTCP_MCast_Map TAO_AV_RTCP::rtcp_mcast_map_;
-TAO_AV_RTCP::RTCP_UDP_Map TAO_AV_RTCP::rtcp_udp_map_;
-
 // TAO_AV_RTP_State
 TAO_AV_RTP_State::TAO_AV_RTP_State (void)
   :bad_version_(0),
@@ -322,10 +317,10 @@ TAO_AV_RTCP::parse_bye (rtcphdr* rh,
  */
 void
 TAO_AV_RTCP::send_report (int bye,
-                          TAO_AV_Transport *transport,
+                          TAO_AV_Protocol_Object *protocol_object,
                           TAO_AV_SourceManager *source_manager,
                           TAO_AV_RTP_State *state,
-                          TAO_AV_RTCP_Flow_Handler *handler)
+                          TAO_AV_RTCP_Callback *callback)
 {
   if (source_manager->localsrc () == 0)
     return;
@@ -417,7 +412,9 @@ TAO_AV_RTCP::send_report (int bye,
   else
     len += build_sdes ( (rtcphdr*)rr, s,state);
 
-  transport->send ((char *)state->pktbuf_, len);
+  ACE_Message_Block mb ((char *)state->pktbuf_, len);
+  mb.wr_ptr (len);
+  protocol_object->send_frame (&mb);
 
   state->rtcp_avg_size_ += RTCP_SIZE_GAIN * (double (len + 28) - state->rtcp_avg_size_);
 
@@ -444,37 +441,29 @@ TAO_AV_RTCP::send_report (int bye,
   if (rint < RTCP_MIN_RPT_TIME * 1000.)
     rint = RTCP_MIN_RPT_TIME * 1000.;
   state->rint_ = rint;
-  handler->schedule (int (fmod (double (ACE_OS::rand ()), rint) + rint * .5 + .5));
+  callback->schedule (int (fmod (double (ACE_OS::rand ()), rint) + rint * .5 + .5));
 
   source_manager->CheckActiveSources (rint);
 }
 
 int
-TAO_AV_RTCP::handle_input (TAO_AV_Transport *transport,
+TAO_AV_RTCP::handle_input (ACE_Message_Block *data,
+                           const ACE_Addr &peer_address,
                            rtcphdr &header,
                            TAO_AV_SourceManager *source_manager,
                            TAO_AV_RTP_State *state)
 {
-  ACE_Message_Block *data;
-  size_t bufsiz = 2*transport->mtu ();
-  ACE_NEW_RETURN (data,
-                  ACE_Message_Block (bufsiz),
-                  -1);
-  int cc = transport->recv (data->rd_ptr (),bufsiz);
-  if (cc == 0)
-    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:connection closed\n"),-1);
-  if (cc < 0)
-    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:recv error\n"),-1);
+  int cc = data->length ();
   int size_phdr = ACE_static_cast (int, sizeof (rtcphdr));
   if (cc < size_phdr)
     {
       state->nrunt_++;
       ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:invalid header\n"),-1);
     }
-  ACE_Addr *peer_addr = 0;
-  peer_addr = transport->get_peer_addr ();
-  if (peer_addr == 0)
+  if (peer_address == ACE_Addr::sap_any)
     ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:get_peer_addr failed\n"),-1);
+  // @@ We need to be careful of this.
+  u_long addr = peer_address.hash ();
   header = * (rtcphdr*) (data->rd_ptr ());
   rtcphdr *rh = (rtcphdr *)data->rd_ptr ();
   /*
@@ -505,19 +494,6 @@ TAO_AV_RTCP::handle_input (TAO_AV_Transport *transport,
   double tmp = ACE_static_cast (double, result);
   tmp *= RTCP_SIZE_GAIN;
   state->rtcp_avg_size_ += ACE_static_cast (int, tmp);
-  ACE_UINT32 addr = 0;
-  switch (peer_addr->get_type ())
-    {
-    case AF_INET:
-      {
-        ACE_INET_Addr *inet_addr =
-          ACE_static_cast (ACE_INET_Addr *,peer_addr);
-        addr = inet_addr->get_ip_address ();
-      }
-      break;
-    default:
-      break;
-    }
   /*
    * First record in compound packet must be the ssrc of the
    * sender of the packet.  Pull it out here so we can use
@@ -586,161 +562,361 @@ TAO_AV_RTCP::alloc_srcid (ACE_UINT32 addr)
   return (srcid);
 }
 
-// TAO_AV_RTCP_Flow_Handler
-TAO_AV_RTCP_Flow_Handler::TAO_AV_RTCP_Flow_Handler (ACE_Reactor *reactor,
-                                                    TAO_Base_StreamEndPoint *endpoint,
-                                                    const char *flowname)
-  :reactor_ (reactor),
-   endpoint_ (endpoint),
-   flowname_ (flowname)
+
+// TAO_AV_RTCP_Flow_Factory
+TAO_AV_RTCP_Flow_Factory::TAO_AV_RTCP_Flow_Factory (void)
 {
-  ACE_NEW (this->source_manager_,
-           TAO_AV_SourceManager (flowname,
-                                 endpoint,
-                                 this));
 }
 
-TAO_AV_RTCP_Flow_Handler::~TAO_AV_RTCP_Flow_Handler (void)
+TAO_AV_RTCP_Flow_Factory::~TAO_AV_RTCP_Flow_Factory (void)
 {
-  delete this->source_manager_;
 }
 
-void
-TAO_AV_RTCP_Flow_Handler::init (void)
+int
+TAO_AV_RTCP_Flow_Factory::match_protocol (const char *flow_string)
 {
-  // Schedule a timer.
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_RTCP_Flow_Handler::schedule\n"));
-  /*
-   * schedule a timer for our first report using half the
-   * min rtcp interval.  This gives us some time before
-   * our first report to learn about other sources so our
-   * next report interval will account for them.  The avg
-   * rtcp size was initialized to 128 bytes which is
-   * conservative (it assumes everyone else is generating
-   * SRs instead of RRs).
-   */
-  double rint = this->state_.rtcp_avg_size_ * this->state_.rtcp_inv_bw_;
-  if (rint < RTCP_MIN_RPT_TIME / 2. * 1000.)
-    rint = RTCP_MIN_RPT_TIME / 2. * 1000.;
-  this->state_.rint_ = rint;
-  int msec = int(fmod(double(ACE_OS::rand ()), rint) + rint * .5 + .5);
-  this->schedule (msec);
+  if (ACE_OS::strncasecmp (flow_string,"RTCP",4) == 0)
+    return 1;
+  return 0;
 }
 
-void
-TAO_AV_RTCP_Flow_Handler::schedule (int sched)
+int
+TAO_AV_RTCP_Flow_Factory::init (int /* argc */,
+                                char * /* argv */ [])
+{
+  return 0;
+}
+
+TAO_AV_Protocol_Object* 
+TAO_AV_RTCP_Flow_Factory::make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                TAO_Base_StreamEndPoint *endpoint,
+                                                TAO_AV_Flow_Handler *handler,
+                                                TAO_AV_Transport *transport)
+{
+  TAO_AV_Callback *callback = 0;
+  endpoint->get_control_callback (entry->flowname (),
+                                  callback);
+  if (callback == 0)
+    ACE_NEW_RETURN (callback,
+                    TAO_AV_RTCP_Callback,
+                    0);
+  TAO_AV_Protocol_Object *object = 0;
+  ACE_NEW_RETURN (object,
+                  TAO_AV_RTCP_Object (callback,
+                                      transport),
+                  0);
+  callback->open (object,
+                  handler);
+  return object;
+}
+
+// TAO_AV_RTCP_Object
+int
+TAO_AV_RTCP_Object::handle_input (void)
+{
+  ACE_Message_Block *data;
+  size_t bufsiz = 2*this->transport_->mtu ();
+  ACE_NEW_RETURN (data,
+                  ACE_Message_Block (bufsiz),
+                  -1);
+  int n = this->transport_->recv (data->rd_ptr (),bufsiz);
+  if (n == 0)
+    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:connection closed\n"),-1);
+  if (n < 0)
+    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:recv error\n"),-1);
+  data->wr_ptr (n);
+  this->callback_->receive_control_frame (data);
+  return 0;
+}
+
+int
+TAO_AV_RTCP_Object::send_frame (ACE_Message_Block *frame,
+                                TAO_AV_frame_info *frame_info)
+{
+  return this->transport_->send (frame);
+}
+
+int
+TAO_AV_RTCP_Object::send_frame (const iovec *iov,
+                               int iovcnt,
+                               TAO_AV_frame_info *frame_info)
+{
+  return this->transport_->send (iov,
+                                 iovcnt);
+}
+
+TAO_AV_RTCP_Object::TAO_AV_RTCP_Object (TAO_AV_Callback *callback,
+                                        TAO_AV_Transport *transport)
+  :TAO_AV_Protocol_Object (callback,transport)
+{
+}
+
+TAO_AV_RTCP_Object::~TAO_AV_RTCP_Object (void)
+{
+}
+
+int
+TAO_AV_RTCP_Object::destroy (void)
+{
+  this->callback_->handle_destroy ();
+  return 0;
+}
+
+int
+TAO_AV_RTCP_Object::set_policies (const PolicyList &policy_list)
+{
+  return -1;
+}
+
+int
+TAO_AV_RTCP_Object::start (void)
+{
+  return this->callback_->handle_start ();
+}
+
+int
+TAO_AV_RTCP_Object::stop (void)
+{
+  return this->callback_->handle_stop ();
+}
+
+int
+TAO_AV_RTCP_Object::handle_control_input (ACE_Message_Block *frame,
+                                          const ACE_Addr &peer_address)
+{
+  frame->rd_ptr ((size_t)0);
+  // Since the rd_ptr would have been moved ahead.
+  return this->callback_->receive_frame (frame,
+                                         0,
+                                         peer_address);
+}
+
+// TAO_AV_RTCP_Callback
+TAO_AV_RTCP_Callback::TAO_AV_RTCP_Callback (void)
+{
+  ACE_NEW (source_manager_,
+           TAO_AV_SourceManager (this));
+
+  ACE_NEW (this->state_,
+           TAO_AV_RTP_State);
+}
+
+TAO_AV_RTCP_Callback::~TAO_AV_RTCP_Callback (void)
 {
-  ACE_Time_Value delta (0,sched*ACE_ONE_SECOND_IN_MSECS);
-  int result = this->reactor_->schedule_timer (this->event_handler (),
-                                               0,
-                                               delta);
-  if (result < 0)
-    ACE_ERROR ((LM_ERROR,"TAO_AV_RTCP_Flow_Handler::schedule_timer failed\n"));
 }
 
 TAO_AV_SourceManager*
-TAO_AV_RTCP_Flow_Handler::source_manager (void)
+TAO_AV_RTCP_Callback::source_manager (void)
 {
   return this->source_manager_;
 }
 
 TAO_AV_RTP_State*
-TAO_AV_RTCP_Flow_Handler::state (void)
+TAO_AV_RTCP_Callback::state (void)
 {
-  return &this->state_;
+  return this->state_;
 }
 
-//------------------------------------------------------------
-//TAO_AV_RTCP_UDP_Flow_Handler
-//------------------------------------------------------------
-
-TAO_AV_RTCP_UDP_Flow_Handler::TAO_AV_RTCP_UDP_Flow_Handler (ACE_Reactor *reactor,
-                                                            TAO_Base_StreamEndPoint *endpoint,
-                                                            const char *flowname)
-  :TAO_AV_Flow_Handler (0),
-   TAO_AV_UDP_Flow_Handler (0),
-   TAO_AV_RTCP_Flow_Handler (reactor,endpoint,flowname)
+int
+TAO_AV_RTCP_Callback::get_rtp_source (TAO_AV_Source *&source,
+                                      ACE_UINT32 srcid,
+                                      ACE_UINT32 ssrc,
+                                      ACE_UINT32 addr)
 {
+  ACE_NEW_RETURN (source,
+                  TAO_AV_Source (srcid,
+                                 ssrc,
+                                 addr),
+                  -1);
+  return 0;
 }
 
-TAO_AV_RTCP_UDP_Flow_Handler::~TAO_AV_RTCP_UDP_Flow_Handler (void)
+void
+TAO_AV_RTCP_Callback::schedule (int ms)
 {
+  this->timeout_ = ms;
 }
 
-ACE_Event_Handler*
-TAO_AV_RTCP_UDP_Flow_Handler::event_handler (void)
+
+int
+TAO_AV_RTCP_Callback::handle_start (void)
 {
-  return this;
+  // 
+  /*
+   * schedule a timer for our first report using half the
+   * min rtcp interval.  This gives us some time before
+   * our first report to learn about other sources so our
+   * next report interval will account for them.  The avg
+   * rtcp size was initialized to 128 bytes which is
+   * conservative (it assumes everyone else is generating
+   * SRs instead of RRs).
+   */
+  double rint = this->state_->rtcp_avg_size_ * this->state_->rtcp_inv_bw_;
+  if (rint < RTCP_MIN_RPT_TIME / 2. * 1000.)
+    rint = RTCP_MIN_RPT_TIME / 2. * 1000.;
+  this->state_->rint_ = rint;
+  this->timeout_ = int(fmod(double(ACE_OS::rand ()), rint) + rint * .5 + .5);
+  return 0;
 }
 
 int
-TAO_AV_RTCP_UDP_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
+TAO_AV_RTCP_Callback::handle_stop (void)
 {
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_RTCP_UDP_Flow_Handler::handle_input"));
-  TAO_AV_RTCP::rtcphdr rtcp_header;
-  int result = TAO_AV_RTCP::handle_input (this->transport_,
-                                          rtcp_header,
-                                          this->source_manager_,
-                                          &this->state_);
-  if (result < 0)
-    return result;
   return 0;
 }
 
 int
-TAO_AV_RTCP_UDP_Flow_Handler::handle_timeout (const ACE_Time_Value &/*tv*/,
-                                              const void */*arg*/)
+TAO_AV_RTCP_Callback::handle_timeout (void *arg)
 {
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_RTCP_UDP_Flow_Handler::handle_timeout"));
+  // Here we do the send_report.
   TAO_AV_RTCP::send_report (0,
-                            this->transport_,
+                            this->protocol_object_,
                             this->source_manager_,
-                            &this->state_,
+                            this->state_,
                             this);
   return 0;
 }
 
-// TAO_AV_RTCP_UDP_MCast_Flow_Handler
-TAO_AV_RTCP_UDP_MCast_Flow_Handler::TAO_AV_RTCP_UDP_MCast_Flow_Handler (ACE_Reactor *reactor,
-                                                                        TAO_Base_StreamEndPoint *endpoint,
-                                                                        const char *flowname)
-  :TAO_AV_Flow_Handler (0),
-   TAO_AV_UDP_MCast_Flow_Handler (0),
-   TAO_AV_RTCP_Flow_Handler (reactor,endpoint,flowname)
+void
+TAO_AV_RTCP_Callback::get_timeout (ACE_Time_Value *&tv,
+                                   void *&arg)
 {
+  // Here we do the RTCP timeout calculation.
+  ACE_NEW (tv,
+           ACE_Time_Value (0,this->timeout_*ACE_ONE_SECOND_IN_MSECS));
 }
 
-TAO_AV_RTCP_UDP_MCast_Flow_Handler::~TAO_AV_RTCP_UDP_MCast_Flow_Handler (void)
+int
+TAO_AV_RTCP_Callback::handle_destroy (void)
 {
+  // Here we do the send_bye.
+  TAO_AV_RTCP::send_report (1,
+                            this->protocol_object_,
+                            this->source_manager_,
+                            this->state_,
+                            this);
+  return 0;
 }
 
-ACE_Event_Handler*
-TAO_AV_RTCP_UDP_MCast_Flow_Handler::event_handler (void)
+int
+TAO_AV_RTCP_Callback::receive_frame (ACE_Message_Block *frame,
+                                     TAO_AV_frame_info *,
+                                     const ACE_Addr &peer_address)
 {
-  return this;
+  TAO_AV_RTP::rtphdr *rh = (TAO_AV_RTP::rtphdr *)frame->rd_ptr ();
+  frame->rd_ptr (sizeof (TAO_AV_RTP::rtphdr));
+  this->demux (rh,
+               frame,
+               peer_address);
+  return 0;
 }
 
+
 int
-TAO_AV_RTCP_UDP_MCast_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
+TAO_AV_RTCP_Callback::receive_control_frame (ACE_Message_Block *frame,
+                                             const ACE_Addr &peer_address)
 {
-  TAO_AV_RTCP::rtcphdr rtcp_header;
-  int result = TAO_AV_RTCP::handle_input (this->transport_,
-                                          rtcp_header,
+  // Here we do the processing of the RTCP frames.
+  TAO_AV_RTCP::rtcphdr header;
+  int result = TAO_AV_RTCP::handle_input (frame,
+                                          peer_address,
+                                          header,
                                           this->source_manager_,
-                                          &this->state_);
+                                          this->state_);
   if (result < 0)
-    return result;
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_RTCP::handle_input failed\n"),-1);
   return 0;
 }
 
 int
-TAO_AV_RTCP_UDP_MCast_Flow_Handler::handle_timeout (const ACE_Time_Value &/*tv*/,
-                                                    const void */*arg*/)
+TAO_AV_RTCP_Callback::demux (TAO_AV_RTP::rtphdr* rh,
+                             ACE_Message_Block *data,
+                             const ACE_Addr &address)
 {
-  TAO_AV_RTCP::send_report (0,
-                            this->transport_,
-                            this->source_manager_,
-                            &this->state_,
-                            this);
+  char *bp = data->rd_ptr ();
+  int cc = data->length ();
+  if (cc < 0)
+    {
+      ++this->state_->nrunt_;
+      return -1;
+    }
+  ACE_UINT32 srcid = rh->rh_ssrc;
+  int flags = ntohs (rh->rh_flags);
+  if ( (flags & RTP_X) != 0)
+    {
+      /*
+       * the minimal-control audio/video profile
+       * explicitly forbids extensions
+       */
+      ++this->state_->badext_;
+      return -1;
+    }
+
+  // @@Naga:Maybe the framework itself could check for formats making use of
+  // the property service to query the formats supported for this flow.
+  /*
+   * Check for illegal payload types.  Most likely this is
+   * a session packet arriving on the data port.
+   */
+//   int fmt = flags & 0x7f;
+//   if (!check_format (fmt))
+//     {
+//       ++state->badfmt_;
+//       return;
+//     }
+
+  u_long addr = address.hash ();
+  ACE_UINT16 seqno = ntohs (rh->rh_seqno);
+  TAO_AV_Source* s = this->source_manager_->demux (srcid, addr, seqno);
+  if (s == 0)
+    /*
+     * Takes a pair of validated packets before we will
+     * believe the source.  This prevents a runaway
+     * allocation of Source data structures for a
+     * stream of garbage packets.
+     */
+    return -1;
+
+  ACE_Time_Value now = ACE_OS::gettimeofday ();
+  s->lts_data (now);
+  s->sts_data (rh->rh_ts);
+
+  int cnt = (flags >> 8) & 0xf;
+  if (cnt > 0)
+    {
+      u_char* nh = (u_char*)rh + (cnt << 2);
+      while (--cnt >= 0)
+        {
+          ACE_UINT32 csrc = * (ACE_UINT32*)bp;
+          bp += 4;
+          TAO_AV_Source* cs = this->source_manager_->lookup (csrc, srcid, addr);
+          cs->lts_data (now);
+          cs->action ();
+        }
+      /*XXX move header up so it's contiguous with data*/
+      TAO_AV_RTP::rtphdr hdr = *rh;
+      rh = (TAO_AV_RTP::rtphdr*)nh;
+      *rh = hdr;
+    }
+  else
+    s->action ();
+
   return 0;
+  /*
+   * This is a data packet.  If the source needs activation,
+   * or the packet format has changed, deal with this.
+   * Then, hand the packet off to the packet handler.
+   * XXX might want to be careful about flip-flopping
+   * here when format changes due to misordered packets
+   * (easy solution -- keep rtp seqno of last fmt change).
+   */
 }
+
+ACE_FACTORY_DEFINE (AV, TAO_AV_RTCP_Flow_Factory)
+ACE_STATIC_SVC_DEFINE (TAO_AV_RTCP_Flow_Factory,
+                       ASYS_TEXT ("RTCP_Flow_Factory"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_AV_RTCP_Flow_Factory),
+                       ACE_Service_Type::DELETE_THIS |
+                       ACE_Service_Type::DELETE_OBJ,
+                       0)
diff --git a/TAO/orbsvcs/orbsvcs/AV/RTCP.h b/TAO/orbsvcs/orbsvcs/AV/RTCP.h
index 30bfe48749b..a5f57663280 100644
--- a/TAO/orbsvcs/orbsvcs/AV/RTCP.h
+++ b/TAO/orbsvcs/orbsvcs/AV/RTCP.h
@@ -53,8 +53,10 @@
 
 #include "source.h"
 #include "AVStreams_i.h"
+#include "UDP.h"
 #include <math.h>
 #include <stdlib.h>
+#include "RTP.h"
 
 // TAO_AV_RTP_State
 class TAO_AV_RTP_State
@@ -75,57 +77,8 @@ public:
   u_char* pktbuf_;
 };
 
-class TAO_AV_RTCP_Flow_Handler
-{
-public:
-  TAO_AV_RTCP_Flow_Handler (ACE_Reactor *reactor,
-                            TAO_Base_StreamEndPoint *endpoint,
-                            const char *flowname);
-  virtual ~TAO_AV_RTCP_Flow_Handler (void);
-  void init (void);
-  // initialize the timer.
-  virtual ACE_Event_Handler *event_handler (void) = 0;
-  void schedule (int value);
-  TAO_AV_SourceManager *source_manager (void);
-  TAO_AV_RTP_State *state (void);
-  TAO_Base_StreamEndPoint *endpoint (void);
-protected:
-  TAO_AV_SourceManager *source_manager_;
-  TAO_AV_RTP_State state_;
-  ACE_Reactor *reactor_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  CORBA::String_var flowname_;
-};
-
-class TAO_AV_RTCP_UDP_Flow_Handler
-  :public TAO_AV_RTCP_Flow_Handler,
-   public TAO_AV_UDP_Flow_Handler
-{
-public:
-  TAO_AV_RTCP_UDP_Flow_Handler (ACE_Reactor *reactor,
-                                TAO_Base_StreamEndPoint *endpoint,
-                                const char *flowname);
-  virtual ~TAO_AV_RTCP_UDP_Flow_Handler (void);
-  virtual ACE_Event_Handler *event_handler (void);
-  virtual int handle_input (ACE_HANDLE fd);
-  virtual int handle_timeout (const ACE_Time_Value &tv,
-                              const void *arg = 0);
-};
-
-class TAO_AV_RTCP_UDP_MCast_Flow_Handler
-  :public TAO_AV_RTCP_Flow_Handler,
-   public TAO_AV_UDP_MCast_Flow_Handler
-{
-public:
-  TAO_AV_RTCP_UDP_MCast_Flow_Handler (ACE_Reactor *reactor,
-                                      TAO_Base_StreamEndPoint *endpoint,
-                                      const char *flowname);
-  virtual ~TAO_AV_RTCP_UDP_MCast_Flow_Handler (void);
-  virtual ACE_Event_Handler *event_handler (void);
-  virtual int handle_input (ACE_HANDLE fd);
-  virtual int handle_timeout (const ACE_Time_Value &tv,
-                              const void *arg = 0);
-};
+class TAO_AV_RTCP_Callback;
+class TAO_AV_SourceManager;
 
 class TAO_AV_RTCP
 {
@@ -166,7 +119,8 @@ public:
     ACE_UINT32 rr_dlsr; /* time from recpt of last rr to xmit time */
   };
 
-  static int handle_input (TAO_AV_Transport *transport,
+  static int handle_input (ACE_Message_Block *data,
+                           const ACE_Addr &peer_address,
                            rtcphdr &header,
                            TAO_AV_SourceManager *source_manager,
                            TAO_AV_RTP_State *state);
@@ -224,17 +178,118 @@ public:
                          TAO_AV_SourceManager *source_manager);
 
   static void send_report (int bye,
-                           TAO_AV_Transport *transport,
+                           TAO_AV_Protocol_Object *object,
                            TAO_AV_SourceManager *source_manager,
                            TAO_AV_RTP_State *state,
-                           TAO_AV_RTCP_Flow_Handler *handler);
+                           TAO_AV_RTCP_Callback *callback);
 
   static ACE_UINT32 alloc_srcid (ACE_UINT32 addr);
+};
+
+class TAO_AV_Callback;
+
+class TAO_ORBSVCS_Export TAO_AV_RTCP_Object : public TAO_AV_Protocol_Object
+{
+public:
+  TAO_AV_RTCP_Object (TAO_AV_Callback *callback,
+                      TAO_AV_Transport *transport = 0);
+  // constructor.
+
+  virtual ~TAO_AV_RTCP_Object (void);
+  // Destructor
+
+  virtual int handle_input (void);
+  virtual int handle_control_input (ACE_Message_Block *frame,
+                                    const ACE_Addr &peer_address);
+
+  virtual int set_policies (const PolicyList &policy_list);
+  // set/get policies.
+
+  virtual int start (void);
+  virtual int stop (void);
+  // start/stop the flow.
+
+  virtual int send_frame (ACE_Message_Block *frame,
+                          TAO_AV_frame_info *frame_info = 0);
+  // send a data frame.
 
-  typedef ACE_Hash_Map_Manager <TAO_String_Hash_Key,TAO_AV_RTCP_UDP_MCast_Flow_Handler*,ACE_Null_Mutex> RTCP_MCast_Map;
-  typedef ACE_Hash_Map_Manager <TAO_String_Hash_Key,TAO_AV_RTCP_UDP_Flow_Handler*,ACE_Null_Mutex> RTCP_UDP_Map;
-  static RTCP_MCast_Map rtcp_mcast_map_;
-  static RTCP_UDP_Map rtcp_udp_map_;
+  virtual int send_frame (const iovec *iov,
+                          int iovcnt,
+                          TAO_AV_frame_info *frame_info = 0);
+  // send a frame in iovecs.
+
+  virtual int destroy (void);
+  // end the stream.
 };
 
+
+class TAO_ORBSVCS_Export TAO_AV_RTCP_Flow_Factory
+  :public TAO_AV_Flow_Protocol_Factory
+{
+public:
+  TAO_AV_RTCP_Flow_Factory (void);
+  virtual ~TAO_AV_RTCP_Flow_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  virtual int match_protocol (const char *flow_string);
+  virtual TAO_AV_Protocol_Object* make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                        TAO_Base_StreamEndPoint *endpoint,
+                                                        TAO_AV_Flow_Handler *handler,
+                                                        TAO_AV_Transport *transport);
+};
+
+class TAO_ORBSVCS_Export TAO_AV_RTCP_Callback : public TAO_AV_Callback
+{
+public:
+  TAO_AV_RTCP_Callback (void);
+  // RTCP callback.
+
+  virtual ~TAO_AV_RTCP_Callback (void);
+  // virtual destructor.
+
+  virtual int handle_start (void);
+  // Called during Streamctrl->start.
+
+  virtual int handle_stop (void);
+  // Called during Streamctrl->stop.
+
+  virtual int handle_timeout (void *arg);
+  // Called during timeout for Flow Producers.
+
+  virtual int receive_frame (ACE_Message_Block *frame,
+                             TAO_AV_frame_info *frame_info = 0,
+                             const ACE_Addr &peer_address = ACE_Addr::sap_any);
+  // Called when a frame arrives for a FlowConsumer.
+
+  virtual int receive_control_frame (ACE_Message_Block *frame,
+                                     const ACE_Addr &peer_address = ACE_Addr::sap_any);
+
+  virtual int handle_destroy (void);
+  // Called during Streamctrl->destroy i.e tear_down  of the stream
+  // @@coryan:Call it handle_destroy or handle_close.
+
+  virtual void get_timeout (ACE_Time_Value *&tv,
+                            void *&arg);
+  // Called to get the timeout. If tv is 0 then the framework stop
+  // calling this.
+
+  int demux (TAO_AV_RTP::rtphdr* rh,
+             ACE_Message_Block *data,
+            const ACE_Addr &peer_address);
+
+  virtual int get_rtp_source (TAO_AV_Source *&source,
+                              ACE_UINT32 srcid,
+                              ACE_UINT32 ssrc,
+                              ACE_UINT32 addr);
+  void schedule (int ms);
+  TAO_AV_SourceManager *source_manager (void);
+  TAO_AV_RTP_State *state (void);
+protected:
+  TAO_AV_SourceManager *source_manager_;
+  TAO_AV_RTP_State *state_;
+  int timeout_;
+};
+
+ACE_STATIC_SVC_DECLARE (TAO_AV_RTCP_Flow_Factory)
+ACE_FACTORY_DECLARE (TAO_ORBSVCS, TAO_AV_RTCP_Flow_Factory)
+
 #endif /* TAO_AV_RTCP_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/RTP.cpp b/TAO/orbsvcs/orbsvcs/AV/RTP.cpp
index 3b5e216c42c..f65322d9d1e 100644
--- a/TAO/orbsvcs/orbsvcs/AV/RTP.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/RTP.cpp
@@ -35,73 +35,27 @@
 // $Id$
 
 #include "RTP.h"
+#include "RTCP.h"
 #include "Nil.h"
 
 int
-TAO_AV_RTP::handle_input (TAO_AV_Transport *transport,
-                          ACE_Message_Block *&data,
-                          TAO_AV_frame_info *&frame_info,
-                          ACE_Addr &addr,
-                          TAO_AV_SourceManager *source_manager,
-                          TAO_AV_RTP_State *state)
+TAO_AV_RTP::handle_input (ACE_Message_Block *&data,
+                          TAO_AV_frame_info *&frame_info)
 {
-  size_t bufsiz = 2*transport->mtu ();
-  if (data == 0)
-    {
-      ACE_NEW_RETURN (data,
-                      ACE_Message_Block (bufsiz),
-                      -1);
-    }
-  else
-    if (data->size () < bufsiz)
-      ACE_ERROR_RETURN ( (LM_ERROR,"data block size not enough\n"),-1);
-  int n = transport->recv (data->rd_ptr (),bufsiz);
-  if (n == 0)
-    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:connection closed\n"),-1);
-  if (n < 0)
-    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:recv error\n"),-1);
+  int n = data->length ();
   int size_phdr = ACE_static_cast (int, sizeof (rtphdr));
   if (n < size_phdr)
     ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:invalid header\n"),-1);
-  data->wr_ptr (n);
-  ACE_Addr *addr_ptr = 0;
-  addr_ptr = transport->get_peer_addr ();
-  if (addr_ptr == 0)
-    if (TAO_debug_level > 0) ACE_DEBUG ( (LM_ERROR,"TAO_AV_RTP::handle_input:get_peer_addr failed\n"));
-  addr = *addr_ptr;
   rtphdr* rh = (rtphdr*)data->rd_ptr ();
   int version = * (u_char*)rh >> 6;
   if (version != 2)
     {
-      state->bad_version_++;
+      //      state->bad_version_++;
       ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP:bad version\n"),-1);
     }
   TAO_AV_RTP::rtphdr header;
   header = *rh;
-  ACE_UINT32 ip_addr;
-  switch (addr_ptr->get_type ())
-    {
-    case AF_INET:
-      {
-        ACE_INET_Addr *inet_addr = ACE_static_cast (ACE_INET_Addr *,addr_ptr);
-        ip_addr = inet_addr->get_ip_address ();
-      }
-      break;
-    default:
-      if (TAO_debug_level > 0) ACE_DEBUG ( (LM_DEBUG,"TAO_AV_RTP::Unknown address type\n"));
-      break;
-    }
   data->rd_ptr (sizeof (rtphdr));
-  int result = TAO_AV_RTP::demux (rh,
-                                  data,
-                                  ip_addr,
-                                  source_manager,
-                                  state);
-  if (result < 0)
-    {
-      data->release ();
-      return -1;
-    }
   ACE_NEW_RETURN (frame_info,
                   TAO_AV_frame_info,
                   -1);
@@ -110,128 +64,9 @@ TAO_AV_RTP::handle_input (TAO_AV_Transport *transport,
   frame_info->ssrc = header.rh_ssrc;
   frame_info->sequence_num = header.rh_seqno;
   frame_info->format = header.rh_flags & 0x7f;
-//   ACE_Message_Block *frame_info_mb;
-//   ACE_NEW_RETURN (frame_info_mb,
-//                   ACE_Message_Block ((char *)frame_info,
-//                                      sizeof (TAO_AV_frame_info)),
-//                   -1);
-//   frame_info_mb->wr_ptr (sizeof(TAO_AV_frame_info));
-//   frame_info_mb->cont (data);
-//   data = frame_info_mb;
   return 0;
 }
 
-int
-TAO_AV_RTP::demux (rtphdr* rh,
-                   ACE_Message_Block *data,
-                   ACE_UINT32 addr,
-                   TAO_AV_SourceManager *source_manager,
-                   TAO_AV_RTP_State *state)
-{
-  char *bp = data->rd_ptr ();
-  int cc = data->length ();
-  if (cc < 0)
-    {
-      ++state->nrunt_;
-      return -1;
-    }
-  ACE_UINT32 srcid = rh->rh_ssrc;
-  int flags = ntohs (rh->rh_flags);
-  if ( (flags & RTP_X) != 0)
-    {
-      /*
-       * the minimal-control audio/video profile
-       * explicitly forbids extensions
-       */
-      ++state->badext_;
-      return -1;
-    }
-
-  // @@Naga:Maybe the framework itself could check for formats making use of
-  // the property service  to query the formats supported for this flow.
-  /*
-   * Check for illegal payload types.  Most likely this is
-   * a session packet arriving on the data port.
-   */
-//   int fmt = flags & 0x7f;
-//   if (!check_format (fmt))
-//     {
-//       ++state->badfmt_;
-//       return;
-//     }
-
-  ACE_UINT16 seqno = ntohs (rh->rh_seqno);
-  TAO_AV_Source* s = source_manager->demux (srcid, addr, seqno);
-  if (s == 0)
-    /*
-     * Takes a pair of validated packets before we will
-     * believe the source.  This prevents a runaway
-     * allocation of Source data structures for a
-     * stream of garbage packets.
-     */
-    return -1;
-
-  ACE_Time_Value now = ACE_OS::gettimeofday ();
-  s->lts_data (now);
-  s->sts_data (rh->rh_ts);
-
-  int cnt = (flags >> 8) & 0xf;
-  if (cnt > 0)
-    {
-      u_char* nh = (u_char*)rh + (cnt << 2);
-      while (--cnt >= 0)
-        {
-          ACE_UINT32 csrc = * (ACE_UINT32*)bp;
-          bp += 4;
-          TAO_AV_Source* cs = source_manager->lookup (csrc, srcid, addr);
-          cs->lts_data (now);
-          cs->action ();
-        }
-      /*XXX move header up so it's contiguous with data*/
-      rtphdr hdr = *rh;
-      rh = (rtphdr*)nh;
-      *rh = hdr;
-    }
-  else
-    s->action ();
-
-  return 0;
-  /*
-   * This is a data packet.  If the source needs activation,
-   * or the packet format has changed, deal with this.
-   * Then, hand the packet off to the packet handler.
-   * XXX might want to be careful about flip-flopping
-   * here when format changes due to misordered packets
-   * (easy solution -- keep rtp seqno of last fmt change).
-   */
-//   PacketHandler* h = s->handler ();
-//   if (h == 0)
-//     h = s->activate (fmt);
-//   else if (s->format () != fmt)
-//     h = s->change_format (fmt);
-
-//   /*
-//    * XXX bit rate doesn't include rtpv1 options;
-//    * but v1 is going away anyway.
-//    */
-//   int dup = s->cs (seqno);
-//   s->np (1);
-//   s->nb (cc + sizeof (*rh));
-//   if (dup)
-//     return;
-//   if (flags & RTP_M)
-//     s->nf (1);
-
-//   int hlen = h->hdrlen ();
-//   cc -= hlen;
-//   if (cc < 0)
-//     {
-//       s->runt (1);
-//       return;
-//     }
-//   if (!s->mute ())
-//     h->recv (rh, bp + hlen, cc);
-}
 
 ACE_INLINE
 int
@@ -253,349 +88,37 @@ TAO_AV_RTP::write_header (rtphdr &header,
   return 0;
 }
 
-ACE_INLINE
-int
-TAO_AV_RTP::send_frame (TAO_AV_Transport *transport,
-                        rtphdr &header,
-                        ACE_Message_Block *frame)
-{
-  ACE_Message_Block mb ((char *)&header,
-                        sizeof (header));
-  mb.wr_ptr (sizeof (header));
-  mb.cont (frame);
-  int result = transport->send (&mb);
-  if (result < 0)
-    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::send_frame failed\n"),result);
-  return 0;
-}
-
-//ACE_INLINE
-int
-TAO_AV_RTP::send_frame (TAO_AV_Transport *transport,
-                        rtphdr &header,
-                        const iovec *iov,
-                        int iovcnt)
-{
-  iovec send_iov[IOV_MAX];
-  send_iov [0].iov_base = (char *)&header;
-  send_iov [0].iov_len  = sizeof(header);
-  for (int i=1;i<=iovcnt; i++)
-    send_iov [i] = iov [i-1];
-  int result = transport->send (send_iov,
-                                iovcnt+1);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_RTP::send_frame failed\n"),result);
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_Protocol_Factory
-//------------------------------------------------------------
-
-int
-TAO_AV_RTP_UDP_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_RTP_UDP);
-}
-
-TAO_AV_Acceptor*
-TAO_AV_RTP_UDP_Protocol_Factory::make_acceptor (void)
-{
-  TAO_AV_RTP_UDP_Acceptor *acceptor;
-
-  ACE_NEW_RETURN (acceptor,
-                  TAO_AV_RTP_UDP_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector*
-TAO_AV_RTP_UDP_Protocol_Factory::make_connector (void)
-{
-  TAO_AV_RTP_UDP_Connector *connector;
-
-  ACE_NEW_RETURN (connector,
-                  TAO_AV_RTP_UDP_Connector,
-                  0);
-  return connector;
-}
-
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_Acceptor
-//------------------------------------------------------------
-
-TAO_AV_RTP_UDP_Acceptor::TAO_AV_RTP_UDP_Acceptor (void)
-  :make_rtp_handler_ (1)
-{
-}
-
-TAO_AV_RTP_UDP_Acceptor::~TAO_AV_RTP_UDP_Acceptor (void)
-{
-}
-
-int
-TAO_AV_RTP_UDP_Acceptor::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
-{
-  if (this->make_rtp_handler_)
-    {
-      this->make_rtp_handler_ = 0;
-      TAO_AV_Callback *callback = 0;
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTP_UDP_Flow_Handler (callback),
-                      -1);
-      callback->transport (handler->transport ());
-      TAO_AV_Protocol_Object *object = 0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_RTP_Object (callback,
-                                         handler->transport ()),
-                      -1);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-      this->entry_->protocol_object (object);
-    }
-  else
-    {
-      // Now make rtcp handler.
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTCP_UDP_Flow_Handler (this->reactor_,
-                                                    this->endpoint_,
-                                                    this->entry_->flowname ()),
-                      -1);
-    }
-  return 0;
-}
-
-int
-TAO_AV_RTP_UDP_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
-                               TAO_AV_Core *av_core,
-                               TAO_FlowSpec_Entry *entry)
-{
-  this->reactor_ = av_core->reactor ();
-  int result = TAO_AV_UDP_Acceptor::open (endpoint,
-                                          av_core,
-                                          entry);
-  if (result < 0)
-    return result;
-  TAO_String_Hash_Key handler_key (entry->flowname ());
-  TAO_AV_RTCP::RTCP_UDP_Map::ENTRY *handler_entry = 0;
-  TAO_AV_RTP_UDP_Flow_Handler *rtp_handler = ACE_dynamic_cast (TAO_AV_RTP_UDP_Flow_Handler *,
-                                                               this->handler_);
-  TAO_AV_RTCP_UDP_Flow_Handler *rtcp_handler = 0;
-  if (TAO_AV_RTCP::rtcp_udp_map_.find (handler_key,
-                                       handler_entry) == 0)
-    {
-      if (TAO_debug_level > 0) ACE_DEBUG ((LM_ERROR,"RTCP Object already created for this flow\n"));
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_Flow_Handler*,
-                                       handler_entry->int_id_);
-    }
-  else
-    {
-      // Now do the creation of RTCP handler.
-      // The address of RTCP will always be one port higher than RTP.
-      ACE_INET_Addr *entry_addr = ACE_static_cast (ACE_INET_Addr *,
-                                                   entry->address ());
-      if (entry_addr == 0)
-        return -1;
-      ACE_INET_Addr local_addr (entry_addr->get_port_number ()+1,
-                                entry_addr->get_ip_address ());
-      TAO_AV_UDP_Flow_Handler *handler = 0;
-      result = this->acceptor_.open (this,
-                                     av_core->reactor (),
-                                     local_addr,
-                                     handler);
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_Flow_Handler*,
-                                       handler);
-      result = TAO_AV_RTCP::rtcp_udp_map_.bind (handler_key,rtcp_handler);
-      if (result < 0)
-        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"rtcp_map::bind failed\n"));
-    }
-  rtp_handler->rtcp_handler (rtcp_handler);
-  endpoint->set_rtcp_info (entry->flowname (),
-                           rtcp_handler->source_manager (),
-                           rtcp_handler->state ());
-  return 0;
-}
-
-int
-TAO_AV_RTP_UDP_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
-                                       TAO_AV_Core *av_core,
-                                       TAO_FlowSpec_Entry *entry)
-{
-  this->reactor_ = av_core->reactor ();
-  int result = TAO_AV_UDP_Acceptor::open (endpoint,
-                                          av_core,
-                                          entry);
-  if (result < 0)
-    return result;
-  // Now do the creation of RTCP handler.
-  // Since its a default open we do a default open for rtcp also.
-  ACE_INET_Addr local_addr;
-  TAO_String_Hash_Key handler_key (entry->flowname ());
-  TAO_AV_RTCP::RTCP_UDP_Map::ENTRY *handler_entry = 0;
-  TAO_AV_RTP_UDP_Flow_Handler *rtp_handler = ACE_dynamic_cast (TAO_AV_RTP_UDP_Flow_Handler *,
-                                                               this->handler_);
-  TAO_AV_RTCP_UDP_Flow_Handler *rtcp_handler = 0;
-  if (TAO_AV_RTCP::rtcp_udp_map_.find (handler_key,
-                                   handler_entry) == 0)
-    {
-      if (TAO_debug_level > 0) ACE_DEBUG ((LM_ERROR,"RTCP Object already created for this flow\n"));
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_Flow_Handler*,
-                                       handler_entry->int_id_);
-    }
-  else
-    {
-      TAO_AV_UDP_Flow_Handler *handler = 0;
-      result = this->acceptor_.open (this,
-                                     av_core->reactor (),
-                                     local_addr,
-                                     handler);
-      TAO_AV_RTCP_UDP_Flow_Handler *rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_Flow_Handler*,
-                                                                     handler);
-      result = TAO_AV_RTCP::rtcp_udp_map_.bind (handler_key,rtcp_handler);
-      if (result < 0)
-        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"rtcp_map::bind failed\n"));
-    }
-  rtp_handler->rtcp_handler (rtcp_handler);
-  endpoint->set_rtcp_info (entry->flowname (),
-                           rtcp_handler->source_manager (),
-                           rtcp_handler->state ());
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_Connector
-//------------------------------------------------------------
-
-TAO_AV_RTP_UDP_Connector::TAO_AV_RTP_UDP_Connector (void)
-  :make_rtp_handler_ (1)
-{
-}
-
-TAO_AV_RTP_UDP_Connector::~TAO_AV_RTP_UDP_Connector (void)
-{
-}
-
-int
-TAO_AV_RTP_UDP_Connector::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
-{
-  if (this->make_rtp_handler_)
-    {
-      make_rtp_handler_ = 0;
-      TAO_AV_Callback *callback = 0;
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTP_UDP_Flow_Handler (callback),
-                      -1);
-      callback->transport (handler->transport ());
-      TAO_AV_Protocol_Object *object = 0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_RTP_Object (callback,
-                                         handler->transport ()),
-                      -1);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-      this->entry_->protocol_object (object);
-    }
-  else
-    {
-      // Now make rtcp handler.
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTCP_UDP_Flow_Handler (this->av_core_->reactor (),
-                                                    this->endpoint_,
-                                                    this->entry_->flowname ()),
-                      -1);
-    }
-  return 0;
-}
-
-int
-TAO_AV_RTP_UDP_Connector::connect (TAO_FlowSpec_Entry *entry,
-                                   TAO_AV_Transport *&transport)
-{
-  int result = TAO_AV_UDP_Connector::connect (entry,
-                                              transport);
-  TAO_String_Hash_Key handler_key (entry->flowname ());
-  TAO_AV_RTCP::RTCP_UDP_Map::ENTRY *handler_entry = 0;
-  TAO_AV_RTP_UDP_Flow_Handler *rtp_handler = ACE_dynamic_cast (TAO_AV_RTP_UDP_Flow_Handler *,
-                                                               this->handler_);
-  TAO_AV_RTCP_UDP_Flow_Handler *rtcp_handler = 0;
-  if (TAO_AV_RTCP::rtcp_udp_map_.find (handler_key,
-                                       handler_entry) == 0)
-    {
-      if (TAO_debug_level > 0) ACE_DEBUG ((LM_ERROR,"RTCP Object already created for this flow\n"));
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_Flow_Handler*,
-                                       handler_entry->int_id_);
-    }
-  else
-    {
-
-      // Now do the creation of RTCP handler.
-      // The address of RTCP will always be one port higher than RTP.
-      ACE_INET_Addr *entry_addr = ACE_static_cast (ACE_INET_Addr *,
-                                                   entry->address ());
-      if (entry_addr == 0)
-        return -1;
-      ACE_INET_Addr remote_addr (entry_addr->get_port_number ()+1,
-                                 entry_addr->get_ip_address ());
-
-      ACE_INET_Addr local_addr;
-      TAO_AV_UDP_Flow_Handler *handler;
-      result = this->connector_.connect (handler,
-                                         remote_addr,
-                                         local_addr);
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_Flow_Handler*,
-                                       handler);
-      result = TAO_AV_RTCP::rtcp_udp_map_.bind (handler_key,rtcp_handler);
-      if (result < 0)
-        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"rtcp_map::bind failed\n"));
-
-    }
-  rtp_handler->rtcp_handler (rtcp_handler);
-  this->endpoint_->set_rtcp_info (entry->flowname (),
-                                  rtcp_handler->source_manager (),
-                                  rtcp_handler->state ());
-  return 0;
-}
-
-// TAO_AV_RTP_UDP_Flow_Handler
-TAO_AV_RTP_UDP_Flow_Handler::TAO_AV_RTP_UDP_Flow_Handler (TAO_AV_Callback *callback)
-  :TAO_AV_Flow_Handler (callback),
-   TAO_AV_UDP_Flow_Handler (callback)
-{
-}
-
-void
-TAO_AV_RTP_UDP_Flow_Handler::rtcp_handler (TAO_AV_RTCP_UDP_Flow_Handler *handler)
-{
-  this->rtcp_handler_ = handler;
-  this->source_manager_ = handler->source_manager ();
-  this->state_ = handler->state ();
-}
-
+// TAO_AV_RTP_Object
 int
-TAO_AV_RTP_UDP_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
+TAO_AV_RTP_Object::handle_input (void)
 {
   ACE_Message_Block *data = 0;
-  ACE_INET_Addr addr;
   TAO_AV_frame_info *frame_info = 0;
+
   // Handles the incoming RTP packet input.
-  int result = TAO_AV_RTP::handle_input (this->transport_,
-                                         data,
-                                         frame_info,
-                                         addr,
-                                         this->source_manager_,
-                                         this->state_);
+
+  size_t bufsiz = 2*this->transport_->mtu ();
+  ACE_NEW_RETURN (data,
+                  ACE_Message_Block (bufsiz),
+                  -1);
+  int n = this->transport_->recv (data->rd_ptr (),bufsiz);
+  if (n == 0)
+    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:connection closed\n"),-1);
+  if (n < 0)
+    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::handle_input:recv error\n"),-1);
+  data->wr_ptr (n);
+  ACE_Addr *addr = this->transport_->get_peer_addr ();
+
+  int result = TAO_AV_RTP::handle_input (data,
+                                         frame_info);
   if (result < 0)
     return 0;
   result = this->callback_->receive_frame (data,
-                                           frame_info);
+                                           frame_info,
+                                           *addr);
+
+  this->control_object_->handle_control_input (data->duplicate (),
+                                               *addr);
   return 0;
 }
 
@@ -627,12 +150,14 @@ TAO_AV_RTP_Object::send_frame (ACE_Message_Block *frame,
     }
   if (result < 0)
     return result;
-  result = TAO_AV_RTP::send_frame (this->transport_,
-                                   header,
-                                   frame);
-  if (result < 0)
-    return result;
 
+  ACE_Message_Block mb ((char *)&header,
+                        sizeof (header));
+  mb.wr_ptr (sizeof (header));
+  mb.cont (frame);
+  result = this->transport_->send (&mb);
+  if (result < 0)
+    ACE_ERROR_RETURN ( (LM_ERROR,"TAO_AV_RTP::send_frame failed\n"),result);
   return 0;
 }
 
@@ -665,13 +190,16 @@ TAO_AV_RTP_Object::send_frame (const iovec *iov,
     }
   if (result < 0)
     return result;
-  result = TAO_AV_RTP::send_frame (this->transport_,
-                                   header,
-                                   iov,
-                                   iovcnt);
-  if (result < 0)
-    return result;
 
+  iovec send_iov[IOV_MAX];
+  send_iov [0].iov_base = (char *)&header;
+  send_iov [0].iov_len  = sizeof(header);
+  for (int i=1;i<=iovcnt; i++)
+    send_iov [i] = iov [i-1];
+  result = this->transport_->send (send_iov,
+                                   iovcnt+1);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_RTP::send_frame failed\n"),result);
   return 0;
 }
 
@@ -680,15 +208,18 @@ TAO_AV_RTP_Object::TAO_AV_RTP_Object (TAO_AV_Callback *callback,
   :TAO_AV_Protocol_Object (callback,transport),
    sequence_num_ (0)
 {
-  // @@Naga:We have to initialize the sequence number to a non-zero
-  // random number.
   this->sequence_num_ = ACE_OS::rand ();
 }
 
+TAO_AV_RTP_Object::~TAO_AV_RTP_Object (void)
+{
+}
+
 int
-TAO_AV_RTP_Object::end_stream (void)
+TAO_AV_RTP_Object::destroy (void)
 {
-  this->callback_->handle_end_stream ();
+  this->control_object_->destroy ();
+  this->callback_->handle_destroy ();
   return 0;
 }
 
@@ -727,321 +258,83 @@ TAO_AV_RTP_Object::set_policies (const PolicyList &policy_list)
     }
 }
 
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_MCast_Protocol_Factory
-//------------------------------------------------------------
-
-int
-TAO_AV_RTP_UDP_MCast_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_RTP_UDP_MCAST);
-}
-
-TAO_AV_Acceptor*
-TAO_AV_RTP_UDP_MCast_Protocol_Factory::make_acceptor (void)
-{
-  TAO_AV_RTP_UDP_MCast_Acceptor *acceptor;
-
-  ACE_NEW_RETURN (acceptor,
-                  TAO_AV_RTP_UDP_MCast_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector*
-TAO_AV_RTP_UDP_MCast_Protocol_Factory::make_connector (void)
-{
-  TAO_AV_RTP_UDP_MCast_Connector *connector;
-
-  ACE_NEW_RETURN (connector,
-                  TAO_AV_RTP_UDP_MCast_Connector,
-                  0);
-  return connector;
-}
-
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_MCast_Acceptor
-//------------------------------------------------------------
-
-TAO_AV_RTP_UDP_MCast_Acceptor::TAO_AV_RTP_UDP_MCast_Acceptor (void)
-  :make_rtp_handler_ (1)
-{
-}
-
-TAO_AV_RTP_UDP_MCast_Acceptor::~TAO_AV_RTP_UDP_MCast_Acceptor (void)
+void
+TAO_AV_RTP_Object::control_object (TAO_AV_Protocol_Object *object)
 {
+  this->control_object_ = object;
 }
 
 int
-TAO_AV_RTP_UDP_MCast_Acceptor::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler)
+TAO_AV_RTP_Object::start (void)
 {
-  if (this->make_rtp_handler_)
-    {
-      make_rtp_handler_ = 0;
-      TAO_AV_Callback *callback = 0;
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTP_UDP_MCast_Flow_Handler (callback),
-                      -1);
-      callback->transport (handler->transport ());
-      TAO_AV_Protocol_Object *object = 0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_RTP_Object (callback,
-                                         handler->transport ()),
-                      -1);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-      this->entry_->protocol_object (object);
-    }
-  else
-    {
-      // Now make rtcp handler.
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTCP_UDP_MCast_Flow_Handler (this->reactor_,
-                                                          this->endpoint_,
-                                                          this->entry_->flowname ()),
-                      -1);
-    }
-
-  return 0;
+  this->control_object_->start ();
+  return this->callback_->handle_start ();
 }
 
 int
-TAO_AV_RTP_UDP_MCast_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
-                                     TAO_AV_Core *av_core,
-                                     TAO_FlowSpec_Entry *entry)
+TAO_AV_RTP_Object::stop (void)
 {
-  this->reactor_ = av_core->reactor ();
-  int result = TAO_AV_UDP_MCast_Acceptor::open (endpoint,
-                                                av_core,
-                                                entry);
-  if (result < 0)
-    return result;
-  TAO_String_Hash_Key handler_key (entry->flowname ());
-  TAO_AV_RTCP::RTCP_MCast_Map::ENTRY *handler_entry = 0;
-  TAO_AV_RTP_UDP_MCast_Flow_Handler *rtp_handler = ACE_static_cast (TAO_AV_RTP_UDP_MCast_Flow_Handler *,
-                                                                    this->handler_);
-  TAO_AV_RTCP_UDP_MCast_Flow_Handler *rtcp_handler = 0;
-  if (TAO_AV_RTCP::rtcp_mcast_map_.find (handler_key,
-                                         handler_entry) == 0)
-    {
-      if (TAO_debug_level > 0) ACE_DEBUG ((LM_ERROR,"RTCP Object already created for this flow\n"));
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_MCast_Flow_Handler*,
-                                       handler_entry->int_id_);
-    }
-  else
-    {
-      // Now do the creation of RTCP handler.
-      // The address of RTCP will always be one port higher than RTP.
-      ACE_INET_Addr *entry_addr = ACE_static_cast (ACE_INET_Addr *,
-                                                   entry->address ());
-      if (entry_addr == 0)
-        return -1;
-      ACE_INET_Addr *local_addr = 0;
-      ACE_NEW_RETURN (local_addr,
-                      ACE_INET_Addr (entry_addr->get_port_number ()+1,
-                                     entry_addr->get_ip_address ()),
-                      -1);
-      TAO_AV_UDP_MCast_Flow_Handler *handler = 0;
-      result = this->open_i (av_core->reactor (),
-                             local_addr,
-                             handler);
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_MCast_Flow_Handler*,
-                                       handler);
-      result = TAO_AV_RTCP::rtcp_mcast_map_.bind (handler_key,rtcp_handler);
-      if (result < 0)
-        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"rtcp_map::bind failed\n"));
-    }
-  rtp_handler->rtcp_handler (rtcp_handler);
-  endpoint->set_rtcp_info (entry->flowname (),
-                           rtcp_handler->source_manager (),
-                           rtcp_handler->state ());
+  this->control_object_->stop ();
+  return this->callback_->handle_stop ();
 }
 
-int
-TAO_AV_RTP_UDP_MCast_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
-                                             TAO_AV_Core *av_core,
-                                             TAO_FlowSpec_Entry *entry)
+// TAO_AV_RTP_Flow_Factory
+TAO_AV_RTP_Flow_Factory::TAO_AV_RTP_Flow_Factory (void)
 {
-  this->reactor_ = av_core->reactor ();
-  int result = TAO_AV_UDP_MCast_Acceptor::open (endpoint,
-                                                av_core,
-                                                entry);
-  if (result < 0)
-    return result;
-  TAO_String_Hash_Key handler_key (entry->flowname ());
-  TAO_AV_RTCP::RTCP_MCast_Map::ENTRY *handler_entry = 0;
-  TAO_AV_RTP_UDP_MCast_Flow_Handler *rtp_handler = ACE_static_cast (TAO_AV_RTP_UDP_MCast_Flow_Handler *,
-                                                                    this->handler_);
-  TAO_AV_RTCP_UDP_MCast_Flow_Handler *rtcp_handler = 0;
-  if (TAO_AV_RTCP::rtcp_mcast_map_.find (handler_key,
-                                         handler_entry) == 0)
-    {
-      if (TAO_debug_level > 0) ACE_DEBUG ((LM_ERROR,"RTCP Object already created for this flow\n"));
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_MCast_Flow_Handler*,
-                                       handler_entry->int_id_);
-    }
-  else
-    {
-      // Now do the creation of RTCP handler.
-      // Since its a default open we do a default open for rtcp also.
-      ACE_INET_Addr *local_addr = 0;
-      TAO_AV_UDP_MCast_Flow_Handler *handler = 0;
-      result = this->open_i (av_core->reactor (),
-                             local_addr,
-                             handler);
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_MCast_Flow_Handler*,
-                                       handler);
-      result = TAO_AV_RTCP::rtcp_mcast_map_.bind (handler_key,rtcp_handler);
-      if (result < 0)
-        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"rtcp_map::bind failed\n"));
-    }
-  rtp_handler->rtcp_handler (rtcp_handler);
-  endpoint->set_rtcp_info (entry->flowname (),
-                           rtcp_handler->source_manager (),
-                           rtcp_handler->state ());
 }
 
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_MCast_Connector
-//------------------------------------------------------------
-
-TAO_AV_RTP_UDP_MCast_Connector::TAO_AV_RTP_UDP_MCast_Connector (void)
-  :make_rtp_handler_ (1)
-{
-}
-
-TAO_AV_RTP_UDP_MCast_Connector::~TAO_AV_RTP_UDP_MCast_Connector (void)
+TAO_AV_RTP_Flow_Factory::~TAO_AV_RTP_Flow_Factory (void)
 {
 }
 
 int
-TAO_AV_RTP_UDP_MCast_Connector::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler)
+TAO_AV_RTP_Flow_Factory::init (int /* argc */,
+                                char * /* argv */ [])
 {
-  if (this->make_rtp_handler_)
-    {
-      make_rtp_handler_ = 0;
-
-      TAO_AV_Callback *callback = 0;
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTP_UDP_MCast_Flow_Handler (callback),
-                      -1);
-      callback->transport (handler->transport ());
-      TAO_AV_Protocol_Object *object = 0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_RTP_Object (callback,
-                                         handler->transport ()),
-                      -1);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-      this->entry_->protocol_object (object);
-    }
-  else
-    {
-      // Now make rtcp handler.
-      ACE_NEW_RETURN (handler,
-                      TAO_AV_RTCP_UDP_MCast_Flow_Handler (this->av_core_->reactor (),
-                                                          this->endpoint_,
-                                                          this->entry_->flowname ()),
-                      -1);
-    }
   return 0;
 }
 
-int
-TAO_AV_RTP_UDP_MCast_Connector::connect (TAO_FlowSpec_Entry *entry,
-                                         TAO_AV_Transport *&transport)
+TAO_AV_Protocol_Object* 
+TAO_AV_RTP_Flow_Factory::make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                               TAO_Base_StreamEndPoint *endpoint,
+                                               TAO_AV_Flow_Handler *handler,
+                                               TAO_AV_Transport *transport)
 {
-  int result = TAO_AV_UDP_MCast_Connector::connect (entry,
-                                                    transport);
-  TAO_String_Hash_Key handler_key (entry->flowname ());
-  TAO_AV_RTCP::RTCP_MCast_Map::ENTRY *handler_entry = 0;
-  TAO_AV_RTP_UDP_MCast_Flow_Handler *rtp_handler = ACE_dynamic_cast (TAO_AV_RTP_UDP_MCast_Flow_Handler *,
-                                                                     this->handler_);
-  TAO_AV_RTCP_UDP_MCast_Flow_Handler *rtcp_handler = 0;
-  if (TAO_AV_RTCP::rtcp_mcast_map_.find (handler_key,
-                                   handler_entry) == 0)
-    {
-      if (TAO_debug_level > 0) ACE_DEBUG ((LM_ERROR,"RTCP Object already created for this flow\n"));
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_MCast_Flow_Handler*,
-                                       handler_entry->int_id_);
-    }
-  else
-    {
+  TAO_AV_Callback *callback = 0;
+  endpoint->get_callback (entry->flowname (),
+                          callback);
 
-      // Now do the creation of RTCP handler.
-      // The address of RTCP will always be one port higher than RTP.
-      ACE_INET_Addr *entry_addr = ACE_static_cast (ACE_INET_Addr *,
-                                                   entry->address ());
-      if (entry_addr == 0)
-        return -1;
-      ACE_INET_Addr remote_addr (entry_addr->get_port_number ()+1,
-                                 entry_addr->get_ip_address ());
-
-      ACE_INET_Addr *address = &remote_addr;
-      TAO_AV_UDP_MCast_Flow_Handler *handler = 0;
-      result = this->connect_i (this->av_core_->reactor (),
-                                address,
-                                handler);
-      if (result < 0)
-        return result;
-      rtcp_handler = ACE_dynamic_cast (TAO_AV_RTCP_UDP_MCast_Flow_Handler*,
-                                       handler);
-      result = TAO_AV_RTCP::rtcp_mcast_map_.bind (handler_key,rtcp_handler);
-      if (result < 0)
-        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"rtcp_map::bind failed\n"));
-    }
-  rtp_handler->rtcp_handler (rtcp_handler);
-  this->endpoint_->set_rtcp_info (entry->flowname (),
-                                  rtcp_handler->source_manager (),
-                                  rtcp_handler->state ());
-  return 0;
+  TAO_AV_Protocol_Object *object = 0;
+  ACE_NEW_RETURN (object,
+                  TAO_AV_RTP_Object (callback,
+                                     transport),
+                  0);
+  callback->open (object,
+                  handler);
+  endpoint->set_protocol_object (entry->flowname (),
+                                 object);
+  return object;
 }
 
-// TAO_AV_RTP_UDP_MCast_Flow_Handler
-TAO_AV_RTP_UDP_MCast_Flow_Handler::TAO_AV_RTP_UDP_MCast_Flow_Handler (TAO_AV_Callback *callback)
-  :TAO_AV_Flow_Handler (callback),
-   TAO_AV_UDP_MCast_Flow_Handler (callback),
-   source_manager_ (0),
-   rtcp_handler_ (0),
-   state_ (0)
+int
+TAO_AV_RTP_Flow_Factory::match_protocol (const char *flow_string)
 {
+  if (ACE_OS::strncasecmp (flow_string,"RTP",3) == 0)
+    return 1;
+  return 0;
 }
 
-void
-TAO_AV_RTP_UDP_MCast_Flow_Handler::rtcp_handler (TAO_AV_RTCP_UDP_MCast_Flow_Handler *handler)
+const char *
+TAO_AV_RTP_Flow_Factory::control_flow_factory (void)
 {
-  this->rtcp_handler_ = handler;
-  this->source_manager_ = handler->source_manager ();
-  this->state_ = handler->state ();
+  return "RTCP";
 }
 
-int
-TAO_AV_RTP_UDP_MCast_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  ACE_Message_Block *data = 0;
-  ACE_INET_Addr addr;
-  TAO_AV_frame_info *frame_info = 0;
-  // Handles the incoming RTP packet input.
-  int result = TAO_AV_RTP::handle_input (this->transport_,
-                                         data,
-                                         frame_info,
-                                         addr,
-                                         this->source_manager_,
-                                         this->state_);
-  if (result < 0)
-    return 0;
-  // @@ What should we do with the header.
-  // Answer:Use it for RTCP statistics. But then the
-  // application needs the format of the data to decode it.
-  result = this->callback_->receive_frame (data,
-                                           frame_info);
-  return 0;
-}
+ACE_FACTORY_DEFINE (AV, TAO_AV_RTP_Flow_Factory)
+ACE_STATIC_SVC_DEFINE (TAO_AV_RTP_Flow_Factory,
+                       ASYS_TEXT ("RTP_Flow_Factory"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_AV_RTP_Flow_Factory),
+                       ACE_Service_Type::DELETE_THIS |
+                       ACE_Service_Type::DELETE_OBJ,
+                       0)
diff --git a/TAO/orbsvcs/orbsvcs/AV/RTP.h b/TAO/orbsvcs/orbsvcs/AV/RTP.h
index 6d5795475a5..8c0a03e302d 100644
--- a/TAO/orbsvcs/orbsvcs/AV/RTP.h
+++ b/TAO/orbsvcs/orbsvcs/AV/RTP.h
@@ -53,6 +53,7 @@
 #ifndef TAO_AV_RTP_H
 #define TAO_AV_RTP_H
 
+#include "Protocol_Factory.h"
 
 #define RTP_PT_BVC              22      /* Berkeley video codec */
 
@@ -126,128 +127,14 @@
 #include "Policy.h"
 #include "FlowSpec_Entry.h"
 #include "MCast.h"
-#include "RTCP.h"
 //------------------------------------------------------------
 // TAO_AV_RTP_UDP
 //------------------------------------------------------------
 
-class TAO_AV_RTP_UDP_Acceptor
-  :public TAO_AV_UDP_Acceptor
-{
-public:
-  TAO_AV_RTP_UDP_Acceptor (void);
-  virtual ~TAO_AV_RTP_UDP_Acceptor (void);
-  virtual int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core,
-                    TAO_FlowSpec_Entry *entry);
-  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core,
-                            TAO_FlowSpec_Entry *entry);
-protected:
-  ACE_Hash_Map_Manager <TAO_String_Hash_Key,TAO_AV_RTCP_UDP_Flow_Handler*,ACE_Null_Mutex> rtcp_map_;
-  int make_rtp_handler_;
-  ACE_Reactor *reactor_;
-};
-
-class TAO_AV_RTP_UDP_Connector
-  :public TAO_AV_UDP_Connector
-{
-public:
-  TAO_AV_RTP_UDP_Connector (void);
-  virtual ~TAO_AV_RTP_UDP_Connector (void);
-  virtual int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-  virtual int connect (TAO_FlowSpec_Entry *entry,
-                       TAO_AV_Transport *&transport);
-protected:
-  int make_rtp_handler_;
-  ACE_Reactor *reactor_;
-};
-
-class TAO_AV_RTP_UDP_Protocol_Factory
-  :public TAO_AV_UDP_Protocol_Factory
-{
-public:
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  virtual TAO_AV_Connector *make_connector (void);
-};
 
 class TAO_AV_SourceManager;
 class TAO_AV_RTCP_UDP_Flow_Handler;
 class TAO_AV_RTP_State;
-class TAO_AV_RTP_UDP_Flow_Handler
-  :public TAO_AV_UDP_Flow_Handler
-{
-public:
-  TAO_AV_RTP_UDP_Flow_Handler (TAO_AV_Callback *callback);
-  virtual int handle_input (ACE_HANDLE fd);
-  virtual void rtcp_handler (TAO_AV_RTCP_UDP_Flow_Handler *handler);
-protected:
-  TAO_AV_SourceManager *source_manager_;
-  TAO_AV_RTCP_UDP_Flow_Handler *rtcp_handler_;
-  TAO_AV_RTP_State *state_;
-};
-
-class TAO_AV_UDP_MCast_Flow_Handler;
-//------------------------------------------------------------
-// TAO_AV_RTP_UDP_MCast
-//------------------------------------------------------------
-
-class TAO_AV_RTP_UDP_MCast_Acceptor
-  :public TAO_AV_UDP_MCast_Acceptor
-{
-public:
-  TAO_AV_RTP_UDP_MCast_Acceptor (void);
-  virtual ~TAO_AV_RTP_UDP_MCast_Acceptor (void);
-  virtual int make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core,
-                    TAO_FlowSpec_Entry *entry);
-  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core,
-                            TAO_FlowSpec_Entry *entry);
-protected:
-  int make_rtp_handler_;
-  ACE_Reactor *reactor_;
-};
-
-
-class TAO_AV_RTP_UDP_MCast_Connector
-  :public TAO_AV_UDP_MCast_Connector
-{
-public:
-  TAO_AV_RTP_UDP_MCast_Connector (void);
-  virtual ~TAO_AV_RTP_UDP_MCast_Connector (void);
-  virtual int make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler);
-  virtual int connect (TAO_FlowSpec_Entry *entry,
-                       TAO_AV_Transport *&transport);
-protected:
-  int make_rtp_handler_;
-  ACE_Reactor *reactor_;
-};
-
-class TAO_AV_RTP_UDP_MCast_Protocol_Factory
-  :public TAO_AV_UDP_MCast_Protocol_Factory
-{
-public:
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  virtual TAO_AV_Connector *make_connector (void);
-};
-
-class TAO_AV_RTP_UDP_MCast_Flow_Handler
-  :public TAO_AV_UDP_MCast_Flow_Handler
-{
-public:
-  TAO_AV_RTP_UDP_MCast_Flow_Handler (TAO_AV_Callback *callback);
-  virtual int handle_input (ACE_HANDLE fd);
-  virtual void rtcp_handler (TAO_AV_RTCP_UDP_MCast_Flow_Handler *handler);
-protected:
-  TAO_AV_SourceManager *source_manager_;
-  TAO_AV_RTCP_UDP_MCast_Flow_Handler *rtcp_handler_;
-  TAO_AV_RTP_State *state_;
-};
 
 //------------------------------------------------------------
 // TAO_AV_RTP
@@ -346,13 +233,8 @@ public:
     ACE_UINT16 blkno;
   };
 
-
-  static int handle_input (TAO_AV_Transport *transport,
-                           ACE_Message_Block *&data,
-                           TAO_AV_frame_info *&frame_info,
-                           ACE_Addr &addr,
-                           TAO_AV_SourceManager *source_manager,
-                           TAO_AV_RTP_State *state);
+  static int handle_input (ACE_Message_Block *&data,
+                           TAO_AV_frame_info *&frame_info);
 
   static  int write_header (rtphdr &header,
                             int format,
@@ -361,31 +243,20 @@ public:
                             ACE_UINT32 ssrc,
                             CORBA::Boolean boundary_marker);
 
-  static int send_frame (TAO_AV_Transport *transport,
-                         rtphdr &header,
-                         ACE_Message_Block *frame);
-
-  static int send_frame (TAO_AV_Transport *transport,
-                         rtphdr &header,
-                         const iovec *iov,
-                         int iovcnt);
-
-  static int demux (rtphdr* rh,
-                     ACE_Message_Block *data,
-                     ACE_UINT32 addr,
-                     TAO_AV_SourceManager *sm,
-                     TAO_AV_RTP_State *state);
 };
 
 
-
-class TAO_AV_RTP_Object
-  :public TAO_AV_Protocol_Object
+class TAO_AV_RTP_Object : public TAO_AV_Protocol_Object
 {
 public:
   TAO_AV_RTP_Object (TAO_AV_Callback *callback,
-                     TAO_AV_Transport *transport = 0);
+                     TAO_AV_Transport *transport);
 
+  virtual ~TAO_AV_RTP_Object (void);
+
+  virtual int start (void);
+  virtual int stop (void);
+  virtual int handle_input (void);
   virtual int send_frame (ACE_Message_Block *frame,
                           TAO_AV_frame_info *frame_info = 0);
 
@@ -393,12 +264,32 @@ public:
                           int iovcnt,
                           TAO_AV_frame_info *frame_info = 0);
 
-  int end_stream (void);
+  virtual int destroy (void);
   virtual int set_policies (const PolicyList &policy_list);
+  virtual void control_object (TAO_AV_Protocol_Object *object);
 protected:
   ACE_UINT16 sequence_num_;
   int format_;
   CORBA::ULong ssrc_;
+  TAO_AV_Protocol_Object *control_object_;
+};
+
+class TAO_ORBSVCS_Export TAO_AV_RTP_Flow_Factory : public TAO_AV_Flow_Protocol_Factory
+{
+public:
+  TAO_AV_RTP_Flow_Factory (void);
+  virtual ~TAO_AV_RTP_Flow_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *flow_string);
+  virtual TAO_AV_Protocol_Object* make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                        TAO_Base_StreamEndPoint *endpoint,
+                                                        TAO_AV_Flow_Handler *handler,
+                                                        TAO_AV_Transport *transport);
+  virtual const char*control_flow_factory (void);
 };
 
+ACE_STATIC_SVC_DECLARE (TAO_AV_RTP_Flow_Factory)
+ACE_FACTORY_DECLARE (TAO_ORBSVCS, TAO_AV_RTP_Flow_Factory)
+
 #endif /* TAO_AV_RTP_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/TCP.cpp b/TAO/orbsvcs/orbsvcs/AV/TCP.cpp
new file mode 100644
index 00000000000..54232f6b7cc
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/TCP.cpp
@@ -0,0 +1,664 @@
+// $Id$
+
+#include "TCP.h"
+#include "AVStreams_i.h"
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Transport
+//------------------------------------------------------------
+
+TAO_AV_TCP_Transport::TAO_AV_TCP_Transport (void)
+  :handler_ (0)
+{
+}
+
+TAO_AV_TCP_Transport::TAO_AV_TCP_Transport (TAO_AV_TCP_Flow_Handler *handler)
+  :handler_ (handler)
+{
+}
+
+TAO_AV_TCP_Transport::~TAO_AV_TCP_Transport (void)
+{
+}
+
+int
+TAO_AV_TCP_Transport::open (ACE_Addr */*address*/)
+{
+  return 0;
+}
+
+int
+TAO_AV_TCP_Transport::close (void)
+{
+  return 0;
+}
+
+int
+TAO_AV_TCP_Transport::mtu (void)
+{
+  return -1;
+}
+
+ACE_Addr*
+TAO_AV_TCP_Transport::get_peer_addr (void)
+{
+  return 0;
+}
+
+ssize_t
+TAO_AV_TCP_Transport::send (const ACE_Message_Block *mblk, ACE_Time_Value *)
+{
+  // For the most part this was copied from GIOP::send_request and
+  // friends.
+
+  iovec iov[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  = 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 IOV_MAX to that limit.
+          if (iovcnt == IOV_MAX)
+            {
+              n = this->handler_->peer ().sendv_n ((const iovec *) iov,
+                                                   iovcnt);
+              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_TCP_Transport::send (const char *buf,
+                            size_t len,
+                            ACE_Time_Value *)
+{
+  return this->handler_->peer ().send_n (buf, len);
+}
+
+ssize_t
+TAO_AV_TCP_Transport::send (const iovec *iov,
+                          int iovcnt,
+                          ACE_Time_Value *)
+{
+  return this->handler_->peer ().sendv_n ((const iovec *) iov,
+                                          iovcnt);
+}
+
+ssize_t
+TAO_AV_TCP_Transport::recv (char *buf,
+                          size_t len,
+                          ACE_Time_Value *)
+{
+  return this->handler_->peer ().recv (buf, len);
+}
+
+ssize_t
+TAO_AV_TCP_Transport::recv (char *buf,
+                            size_t len,
+                            int flags,
+                            ACE_Time_Value *)
+{
+  return this->handler_->peer ().recv (buf,
+                                       len,
+                                       flags);
+}
+
+ssize_t
+TAO_AV_TCP_Transport::recv (iovec *iov,
+                            int iovcnt,
+                            ACE_Time_Value *)
+{
+  return handler_->peer ().recvv_n (iov, iovcnt);
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Protocol_Factory
+//------------------------------------------------------------
+
+TAO_AV_TCP_Factory::TAO_AV_TCP_Factory (void)
+{
+}
+
+TAO_AV_TCP_Factory::~TAO_AV_TCP_Factory (void)
+{
+}
+
+int
+TAO_AV_TCP_Factory::init (int /* argc */,
+                          char * /* argv */ [])
+{
+  return 0;
+}
+
+int
+TAO_AV_TCP_Factory::match_protocol (const char *protocol_string)
+{
+  if (ACE_OS::strcasecmp (protocol_string,"TCP") == 0)
+    return 1;
+  return 0;
+}
+
+TAO_AV_Acceptor*
+TAO_AV_TCP_Factory::make_acceptor (void)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Factory::make_acceptor "));
+  TAO_AV_Acceptor *acceptor = 0;
+  ACE_NEW_RETURN (acceptor,
+                  TAO_AV_TCP_Acceptor,
+                  0);
+  return acceptor;
+}
+
+TAO_AV_Connector*
+TAO_AV_TCP_Factory::make_connector (void)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Factory::make_connector "));
+  TAO_AV_Connector *connector = 0;
+  ACE_NEW_RETURN (connector,
+                  TAO_AV_TCP_Connector,
+                  0);
+  return connector;
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Object
+//------------------------------------------------------------
+
+int
+TAO_AV_TCP_Object::handle_input (void)
+{
+  size_t size = BUFSIZ;
+  ACE_Message_Block *frame = 0;
+  ACE_NEW_RETURN (frame,
+                  ACE_Message_Block (size),
+                  -1);
+  int n = this->transport_->recv (frame->rd_ptr (),
+                                  size);
+  if (n == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Flow_Handler::handle_input recv failed\n"),-1);
+  if (n == 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Flow_Handler::handle_input connection closed\n"),-1);
+  frame->wr_ptr (n);
+
+  return this->callback_->receive_frame (frame);
+}
+
+int
+TAO_AV_TCP_Object::send_frame (ACE_Message_Block *frame,
+                               TAO_AV_frame_info *frame_info)
+{
+  int result = this->transport_->send (frame);
+  if (result < 0)
+    return result;
+  return 0;
+}
+
+int 
+TAO_AV_TCP_Object::send_frame (const iovec *iov,
+                               int iovcnt,
+                               TAO_AV_frame_info *frame_info)
+{
+  return this->transport_->send (iov,iovcnt);
+}
+
+TAO_AV_TCP_Object::TAO_AV_TCP_Object (TAO_AV_Callback *callback,
+                                      TAO_AV_Transport *transport)
+  :TAO_AV_Protocol_Object (callback,transport)
+{
+}
+
+TAO_AV_TCP_Object::~TAO_AV_TCP_Object (void)
+{
+  // No-op
+}
+int
+TAO_AV_TCP_Object::destroy (void)
+{
+  this->callback_->handle_destroy ();
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Flow_Factory
+//------------------------------------------------------------
+TAO_AV_TCP_Flow_Factory::TAO_AV_TCP_Flow_Factory (void)
+{
+}
+
+TAO_AV_TCP_Flow_Factory::~TAO_AV_TCP_Flow_Factory (void)
+{
+}
+
+int
+TAO_AV_TCP_Flow_Factory::init (int /* argc */,
+                               char * /* argv */ [])
+{
+  return 0;
+}
+
+int
+TAO_AV_TCP_Flow_Factory::match_protocol (const char *flow_string)
+{
+  if (ACE_OS::strcasecmp (flow_string,"TCP") == 0)
+    return 1;
+  return 0;
+}
+
+TAO_AV_Protocol_Object*
+TAO_AV_TCP_Flow_Factory::make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                               TAO_Base_StreamEndPoint *endpoint,
+                                               TAO_AV_Flow_Handler *handler,
+                                               TAO_AV_Transport *transport)
+{
+  TAO_AV_Callback *callback = 0;
+  endpoint->get_callback (entry->flowname (),
+                          callback);
+
+  TAO_AV_TCP_Object *object = 0;
+  ACE_NEW_RETURN (object,
+                  TAO_AV_TCP_Object (callback,
+                                     transport),
+                  0);
+  callback->open (object,
+                  handler);
+  endpoint->set_protocol_object (entry->flowname (),
+                                 object);
+  return object;
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Base_Connector
+//------------------------------------------------------------
+
+int
+TAO_AV_TCP_Base_Connector::connector_open (TAO_AV_TCP_Connector *connector,
+                                           ACE_Reactor *reactor)
+{
+  this->connector_ = connector;
+  this->reactor_ = reactor;
+
+  int result = ACE_Connector <TAO_AV_TCP_Flow_Handler,ACE_SOCK_CONNECTOR>::open (reactor);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Base_Connector::open failed\n"),-1);
+  return 0;
+}
+
+int
+TAO_AV_TCP_Base_Connector::make_svc_handler (TAO_AV_TCP_Flow_Handler *&tcp_handler)
+{
+  int result =
+    this->connector_->make_svc_handler (tcp_handler);
+  if (result < 0)
+    return result;
+  tcp_handler->reactor (this->reactor_);
+  return 0;
+}
+
+int
+TAO_AV_TCP_Base_Connector::connector_connect (TAO_AV_TCP_Flow_Handler *&handler,
+                                              const ACE_INET_Addr &remote_addr)
+{
+  int result = ACE_Connector <TAO_AV_TCP_Flow_Handler,ACE_SOCK_CONNECTOR>::connect (handler,
+                                                                                    remote_addr);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Base_Connector::connect failed\n"),-1);
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Connector
+//------------------------------------------------------------
+TAO_AV_TCP_Connector::TAO_AV_TCP_Connector (void)
+{
+}
+
+TAO_AV_TCP_Connector::~TAO_AV_TCP_Connector (void)
+{
+}
+
+int
+TAO_AV_TCP_Connector::make_svc_handler (TAO_AV_TCP_Flow_Handler *&tcp_handler)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_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 (tcp_handler,
+                      //                      TAO_AV_TCP_Flow_Handler (callback),
+                      TAO_AV_TCP_Flow_Handler,
+                      -1);
+      TAO_AV_Protocol_Object *object =
+        this->flow_protocol_factory_->make_protocol_object (this->entry_,
+                                                            this->endpoint_,
+                                                            tcp_handler,
+                                                            tcp_handler->transport ());
+      tcp_handler->protocol_object (object);
+      //      callback->protocol_object (object);
+//       this->endpoint_->set_protocol_object (this->flowname_.c_str (),
+//                                             object);
+      this->endpoint_->set_handler (this->flowname_.c_str (),tcp_handler);
+      this->entry_->protocol_object (object);
+      this->entry_->handler (tcp_handler);
+    }
+  return 0;
+}
+
+int
+TAO_AV_TCP_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_TCP_Connector::open "));
+  int result = this->connector_.connector_open(this,
+                                               av_core->reactor ());
+  return result;
+}
+
+int
+TAO_AV_TCP_Connector::connect (TAO_FlowSpec_Entry *entry,
+                               TAO_AV_Transport *&transport)
+{
+  this->entry_ = entry;
+  this->flowname_ = entry->flowname ();
+  ACE_Addr *remote_addr = entry->address ();
+  ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr *,remote_addr);
+  TAO_AV_TCP_Flow_Handler *handler;
+  int result = this->connector_.connector_connect (handler,
+                                                   *inet_addr);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_connector::open failed\n"),-1);
+  entry->handler (handler);
+  transport = handler->transport ();
+  return 0;
+}
+
+int
+TAO_AV_TCP_Connector::close (void)
+{
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Base_Connector
+//------------------------------------------------------------
+
+int
+TAO_AV_TCP_Base_Acceptor::open (TAO_AV_TCP_Acceptor *acceptor,
+                                ACE_Reactor *reactor,
+                                const ACE_INET_Addr &local_addr,
+                                TAO_FlowSpec_Entry *entry)
+{
+  this->acceptor_ = acceptor;
+  this->reactor_ = reactor;
+  this->entry_ = entry;
+
+  int result = ACE_Acceptor <TAO_AV_TCP_Flow_Handler,ACE_SOCK_ACCEPTOR>::open (local_addr,reactor);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Base_Connector::open failed\n"),-1);
+  return 0;
+}
+
+int
+TAO_AV_TCP_Base_Acceptor::make_svc_handler (TAO_AV_TCP_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_TCP_Acceptor
+//------------------------------------------------------------
+
+TAO_AV_TCP_Acceptor::TAO_AV_TCP_Acceptor (void)
+{
+}
+
+TAO_AV_TCP_Acceptor::~TAO_AV_TCP_Acceptor (void)
+{
+}
+
+int
+TAO_AV_TCP_Acceptor::make_svc_handler (TAO_AV_TCP_Flow_Handler *&tcp_handler)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Acceptor::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 (tcp_handler,
+                      //                      TAO_AV_TCP_Flow_Handler (callback),
+                      TAO_AV_TCP_Flow_Handler,
+                      -1);
+      TAO_AV_Protocol_Object *object =
+//         this->flow_protocol_factory_->make_protocol_object (callback,
+//                                                             tcp_handler->transport ());
+        this->flow_protocol_factory_->make_protocol_object (this->entry_,
+                                                            this->endpoint_,
+                                                            tcp_handler,
+                                                            tcp_handler->transport ());
+      tcp_handler->protocol_object (object);
+      //      callback->protocol_object (object);
+//       this->endpoint_->set_protocol_object (this->flowname_.c_str (),
+//                                             object);
+      this->endpoint_->set_handler (this->flowname_.c_str (),tcp_handler);
+      this->entry_->protocol_object (object);      
+      this->entry_->handler (tcp_handler);
+    }
+  return 0;
+}
+
+int
+TAO_AV_TCP_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
+                           TAO_AV_Core *av_core,
+                           TAO_FlowSpec_Entry *entry,
+                           TAO_AV_Flow_Protocol_Factory *factory)
+{
+  this->flow_protocol_factory_ = factory;
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Acceptor::open "));
+  this->av_core_ = av_core;
+  this->endpoint_ = endpoint;
+  this->entry_ = entry;
+  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_TCP_Acceptor::open: %s",
+              buf));
+  int result = this->acceptor_.open (this,
+                                     av_core->reactor (),
+                                     *inet_addr,
+                                     entry);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Acceptor::open failed"),-1);
+  entry->set_local_addr (address);
+  return 0;
+}
+
+int
+TAO_AV_TCP_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
+                                   TAO_AV_Core *av_core,
+                                   TAO_FlowSpec_Entry *entry,
+                                   TAO_AV_Flow_Protocol_Factory *factory)
+{
+  this->flow_protocol_factory_ = factory;
+  this->av_core_ = av_core;
+  this->endpoint_ = endpoint;
+  this->entry_ = entry;
+  this->flowname_ = entry->flowname ();
+  ACE_INET_Addr *address;
+  ACE_NEW_RETURN (address,
+                  ACE_INET_Addr ("0"),
+                  -1);
+  int result = this->acceptor_.open (this,
+                                     av_core->reactor (),
+                                     *address,
+                                     entry);
+
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_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_TCP_Acceptor::open_default: %s\n",buf));
+  entry->set_local_addr (address);
+  return 0;
+}
+
+
+int
+TAO_AV_TCP_Acceptor::close (void)
+{
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_TCP_Flow_Handler
+//------------------------------------------------------------
+
+TAO_AV_TCP_Flow_Handler::TAO_AV_TCP_Flow_Handler (TAO_AV_Callback *callback)
+  //  :TAO_AV_Flow_Handler (callback)
+{
+  ACE_NEW (this->transport_,
+           TAO_AV_TCP_Transport (this));
+}
+
+TAO_AV_Transport *
+TAO_AV_TCP_Flow_Handler::transport (void)
+{
+  return this->transport_;
+}
+
+int
+TAO_AV_TCP_Flow_Handler::open (void *arg)
+{
+
+  int nodelay = 1;
+
+#if defined (TCP_NODELAY)
+  if (this->peer ().set_option (IPPROTO_TCP,
+                                TCP_NODELAY,
+                                (void *) &nodelay,
+                                sizeof (nodelay)) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "NODELAY failed\n"),
+                      -1);
+#endif /* TCP_NODELAY */
+
+  // Called by the <Strategy_Acceptor> when the handler is completely
+  // connected.
+  ACE_INET_Addr addr;
+
+  if (this->peer ().get_remote_addr (addr) == -1)
+    return -1;
+
+  char server[MAXHOSTNAMELEN + 16];
+
+  (void) addr.addr_to_string (server, sizeof (server));
+
+  if (TAO_debug_level > 0)
+    if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,
+                "(%P|%t) connection to server <%s> on %d\n",
+                server, this->peer ().get_handle ()));
+
+  this->peer ().enable (ACE_NONBLOCK);
+  // Register the handler with the reactor.
+  if (this->reactor ()
+      && this->reactor ()->register_handler
+      (this,
+       ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("%p\n"),
+                       ASYS_TEXT ("unable to register client handler")),
+                      -1);
+}
+
+int
+TAO_AV_TCP_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
+{
+  return this->protocol_object_->handle_input ();
+}
+
+int
+TAO_AV_TCP_Flow_Handler::handle_timeout (const ACE_Time_Value &tv, 
+                                               const void *arg)
+{
+  return TAO_AV_Flow_Handler::handle_timeout (tv,arg);
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Acceptor<TAO_AV_TCP_Flow_Handler, ACE_SOCK_ACCEPTOR>;
+template class ACE_Connector<TAO_AV_TCP_Flow_Handler, ACE_SOCK_CONNECTOR>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Acceptor<TAO_AV_TCP_Flow_Handler, ACE_SOCK_Acceptor, ACE_INET_Addr>
+#pragma instantiate ACE_Connector<TAO_AV_TCP_Flow_Handler, ACE_SOCK_Connector, ACE_INET_Addr>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+ACE_STATIC_SVC_DEFINE (TAO_AV_TCP_Flow_Factory,
+                       ASYS_TEXT ("TCP_Flow_Factory"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_AV_TCP_Flow_Factory),
+                       ACE_Service_Type::DELETE_THIS |
+                       ACE_Service_Type::DELETE_OBJ,
+                       0)
+
+ACE_FACTORY_DEFINE (AV, TAO_AV_TCP_Flow_Factory)
+
+ACE_STATIC_SVC_DEFINE (TAO_AV_TCP_Factory,
+                       ASYS_TEXT ("TCP_Factory"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_AV_TCP_Factory),
+                       ACE_Service_Type::DELETE_THIS |
+                       ACE_Service_Type::DELETE_OBJ,
+                       0)
+
+ACE_FACTORY_DEFINE (AV, TAO_AV_TCP_Factory)
diff --git a/TAO/orbsvcs/orbsvcs/AV/TCP.h b/TAO/orbsvcs/orbsvcs/AV/TCP.h
new file mode 100644
index 00000000000..3ddc3e24f20
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/TCP.h
@@ -0,0 +1,233 @@
+/* -*- C++ -*- */
+
+// $Id$
+// ============================================================================
+//
+// = LIBRARY
+//   ORBSVCS AVStreams
+//
+// = FILENAME
+//   TCP.h
+//
+// = AUTHOR
+//    Nagarajan Surendran <naga@cs.wustl.edu>
+//
+//
+// ============================================================================
+
+#if !defined TAO_AV_TCP_H
+#define TAO_AV_TCP_H
+
+#include "ace/OS.h"
+#include "Protocol_Factory.h"
+#include "FlowSpec_Entry.h"
+
+class TAO_ORBSVCS_Export TAO_AV_TCP_Factory : public TAO_AV_Transport_Factory
+{
+public:
+  TAO_AV_TCP_Factory (void);
+  virtual ~TAO_AV_TCP_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *protocol_string);
+  virtual TAO_AV_Acceptor *make_acceptor (void);
+  virtual TAO_AV_Connector *make_connector (void);
+};
+
+class TAO_AV_TCP_Flow_Handler;
+
+class TAO_AV_TCP_Transport
+  :public TAO_AV_Transport
+{
+  // = TITLE
+  //     A transport abstraction for socket streams.
+  //
+  // = DESCRIPTION
+  //     Uses the ACE_SOCK_Stream to send the data.
+public:
+  TAO_AV_TCP_Transport (void);
+
+  TAO_AV_TCP_Transport (TAO_AV_TCP_Flow_Handler *handler);
+
+  virtual ~TAO_AV_TCP_Transport (void);
+
+  virtual int open (ACE_Addr *address);
+
+  virtual int close (void);
+
+  virtual int mtu (void);
+
+  virtual ACE_Addr *get_peer_addr (void);
+
+  virtual ssize_t send (const ACE_Message_Block *mblk,
+                        ACE_Time_Value *s = 0);
+  // Write the complete Message_Block chain to the connection.
+
+  virtual ssize_t send (const char *buf,
+                        size_t len,
+                        ACE_Time_Value *s = 0);
+  // Write the contents of the buffer of length len to the connection.
+
+  virtual ssize_t send (const iovec *iov,
+                        int iovcnt,
+                        ACE_Time_Value *s = 0);
+  // Write the contents of iovcnt iovec's to the connection.
+
+  virtual ssize_t recv (char *buf,
+                        size_t len,
+                        ACE_Time_Value *s = 0);
+  // Read len bytes from into buf.
+
+  virtual ssize_t recv (char *buf,
+                        size_t len,
+                        int flags,
+                        ACE_Time_Value *s = 0);
+  // Read len bytes from into buf using flags.
+
+  virtual ssize_t recv (iovec *iov,
+                        int iovcnt,
+                        ACE_Time_Value *s = 0);
+  //  Read received data into the iovec buffers.
+protected:
+  TAO_AV_TCP_Flow_Handler *handler_;
+};
+
+class TAO_AV_TCP_Flow_Handler
+  :public virtual TAO_AV_Flow_Handler,
+   public ACE_Svc_Handler <ACE_SOCK_STREAM, ACE_NULL_SYNCH>
+{
+public:
+  TAO_AV_TCP_Flow_Handler (TAO_AV_Callback *callback = 0);
+  virtual TAO_AV_Transport *transport (void);
+  virtual int open (void * = 0);
+  virtual int handle_input (ACE_HANDLE fd);
+  virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0);
+  virtual ACE_Event_Handler* event_handler (void){ return this; }
+protected:
+  TAO_AV_Core *av_core_;
+};
+
+class TAO_AV_TCP_Acceptor;
+
+class TAO_AV_TCP_Base_Acceptor  :public ACE_Acceptor <TAO_AV_TCP_Flow_Handler,ACE_SOCK_ACCEPTOR>
+{
+public:
+  virtual int open (TAO_AV_TCP_Acceptor *acceptor,
+                    ACE_Reactor *reactor,
+                    const ACE_INET_Addr &local_addr,
+                    TAO_FlowSpec_Entry *entry);
+  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *& handler);
+protected:
+  TAO_AV_TCP_Acceptor *acceptor_;
+  ACE_Reactor *reactor_;
+  TAO_FlowSpec_Entry *entry_;
+};
+
+class TAO_AV_TCP_Acceptor  :public TAO_AV_Acceptor
+{
+public:
+  TAO_AV_TCP_Acceptor (void);
+  virtual ~TAO_AV_TCP_Acceptor (void);
+
+  virtual int open (TAO_Base_StreamEndPoint *endpoint,
+                    TAO_AV_Core *av_core,
+                    TAO_FlowSpec_Entry *entry,
+                    TAO_AV_Flow_Protocol_Factory *factory);
+
+  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
+                            TAO_AV_Core *av_core,
+                            TAO_FlowSpec_Entry *entry,
+                            TAO_AV_Flow_Protocol_Factory *factory);
+
+  virtual int close (void);
+  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *&handler);
+protected:
+  TAO_AV_TCP_Base_Acceptor acceptor_;
+  TAO_FlowSpec_Entry *entry_;
+  TAO_Base_StreamEndPoint *endpoint_;
+  TAO_AV_Flow_Protocol_Factory *flow_protocol_factory_;
+};
+
+class TAO_AV_TCP_Connector;
+
+class TAO_AV_TCP_Base_Connector  : public ACE_Connector <TAO_AV_TCP_Flow_Handler,ACE_SOCK_CONNECTOR>
+{
+public:
+  // To avoid warnings of open and connect hiding the base class functions these have to renamed.
+  int connector_open (TAO_AV_TCP_Connector *connector,
+                      ACE_Reactor *reactor);
+  int connector_connect (TAO_AV_TCP_Flow_Handler *&handler,
+                         const ACE_INET_Addr &remote_addr);
+  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *& handler);
+protected:
+  TAO_AV_TCP_Connector *connector_;
+  ACE_Reactor *reactor_;
+};
+
+class TAO_AV_TCP_Connector  : public TAO_AV_Connector
+{
+public:
+  TAO_AV_TCP_Connector (void);
+  virtual ~TAO_AV_TCP_Connector (void);
+
+  virtual int open (TAO_Base_StreamEndPoint *endpoint,
+                    TAO_AV_Core *av_core,
+                    TAO_AV_Flow_Protocol_Factory *factory);
+
+  virtual int connect (TAO_FlowSpec_Entry *entry,
+                       TAO_AV_Transport *&transport);
+  virtual int close (void);
+  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *&handler);
+protected:
+  TAO_AV_Core *av_core_;
+  TAO_AV_TCP_Base_Connector connector_;
+  TAO_Base_StreamEndPoint *endpoint_;
+  TAO_FlowSpec_Entry *entry_;
+  TAO_AV_Flow_Protocol_Factory *flow_protocol_factory_;
+};
+
+class TAO_ORBSVCS_Export TAO_AV_TCP_Object : public TAO_AV_Protocol_Object
+{
+public:
+  TAO_AV_TCP_Object (TAO_AV_Callback *callback,
+                     TAO_AV_Transport *transport = 0);
+
+  virtual ~TAO_AV_TCP_Object (void);
+  // Dtor
+
+  virtual int handle_input (void);
+
+  virtual int send_frame (ACE_Message_Block *frame,
+                          TAO_AV_frame_info *frame_info = 0);
+  // send a data frame.
+
+  virtual int send_frame (const iovec *iov,
+                          int iovcnt,
+                          TAO_AV_frame_info *frame_info = 0);
+
+  virtual int destroy (void);
+  // end the stream.
+
+};
+
+class TAO_AV_TCP_Flow_Factory : public TAO_AV_Flow_Protocol_Factory
+{
+public:
+  TAO_AV_TCP_Flow_Factory (void);
+  virtual ~TAO_AV_TCP_Flow_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *flow_string);
+  TAO_AV_Protocol_Object* make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                TAO_Base_StreamEndPoint *endpoint,
+                                                TAO_AV_Flow_Handler *handler,
+                                                TAO_AV_Transport *transport);
+};
+
+ACE_STATIC_SVC_DECLARE (TAO_AV_TCP_Flow_Factory)
+ACE_FACTORY_DECLARE (TAO_ORBSVCS, TAO_AV_TCP_Flow_Factory)
+
+ACE_STATIC_SVC_DECLARE (TAO_AV_TCP_Factory)
+ACE_FACTORY_DECLARE (TAO_ORBSVCS, TAO_AV_TCP_Factory)
+
+#endif /* TAO_AV_TCP_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/Transport.cpp b/TAO/orbsvcs/orbsvcs/AV/Transport.cpp
index d8594c58fd3..5cd7e761daa 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Transport.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/Transport.cpp
@@ -5,82 +5,16 @@
 #include "MCast.h"
 #include "Nil.h"
 #include "RTP.h"
+#include "RTCP.h"
+#include "UDP.h"
+#include "TCP.h"
+#include "FlowSpec_Entry.h"
 
 #if !defined (__ACE_INLINE__)
 #include "Transport.i"
 #endif /* __ACE_INLINE__ */
 
 //------------------------------------------------------------
-// TAO_AV_UDP_Flow_Handler
-//------------------------------------------------------------
-
-TAO_AV_UDP_Flow_Handler::TAO_AV_UDP_Flow_Handler (TAO_AV_Callback *callback)
-
-  :TAO_AV_Flow_Handler(callback)
-{
-  ACE_NEW (this->transport_,
-           TAO_AV_UDP_Transport (this));
-//   ACE_NEW (this->sock_dgram_,
-//            ACE_SOCK_Dgram);
-}
-
-TAO_AV_UDP_Flow_Handler::~TAO_AV_UDP_Flow_Handler (void)
-{
-  delete this->transport_;
-  //  delete this->sock_dgram_;
-}
-
-TAO_AV_Transport *
-TAO_AV_UDP_Flow_Handler::transport (void)
-{
-  return this->transport_;
-}
-
-int
-TAO_AV_UDP_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  size_t size = 2*this->transport_->mtu ();
-  ACE_Message_Block *frame = 0;
-  ACE_NEW_RETURN (frame,
-                  ACE_Message_Block (size),
-                  -1);
-  int n = this->transport_->recv (frame->rd_ptr (),
-                                  frame->size ());
-  if (n == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Flow_Handler::handle_input recv failed\n"),-1);
-  if (n == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Flow_Handler::handle_input connection closed\n"),-1);
-  frame->wr_ptr (n);
-  this->callback_->receive_frame (frame);
-  return 0;
-}
-
-int
-TAO_AV_UDP_Flow_Handler::handle_timeout (const ACE_Time_Value &tv, 
-                                               const void *arg)
-{
-  return TAO_AV_Flow_Handler::handle_timeout (tv,arg);
-}
-
-int
-TAO_AV_UDP_Flow_Handler::set_remote_address (ACE_Addr *address)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Flow_Handler::set_remote_address\n"));
-  ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr*,address);
-  this->peer_addr_ = *inet_addr;
-  TAO_AV_UDP_Transport *transport = ACE_dynamic_cast (TAO_AV_UDP_Transport*,this->transport_);
-  return transport->set_remote_address (*inet_addr);
-}
-
-
-ACE_HANDLE
-TAO_AV_UDP_Flow_Handler::get_handle (void) const
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Flow_Handler::get_handle:%d\n",this->sock_dgram_.get_handle ()));
-  return this->sock_dgram_.get_handle () ;
-}
-
-//------------------------------------------------------------
 // TAO_AV_Core
 //------------------------------------------------------------
 
@@ -98,7 +32,7 @@ TAO_AV_Core::~TAO_AV_Core (void)
 
 int
 TAO_AV_Core::init (int &argc,
-                   char **argv,
+                   char *argv [],
                    CORBA::Environment &env)
 {
   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_Core::init "));
@@ -114,7 +48,8 @@ TAO_AV_Core::init (int &argc,
                   -1);
   this->orb_ = this->orb_manager_.orb ();
   this->reactor (this->orb_->orb_core ()->reactor ());
-  this->init_protocol_factories ();
+  this->init_transport_factories ();
+  this->init_flow_protocol_factories ();
   return 0;
 }
 
@@ -150,6 +85,8 @@ TAO_AV_Core::init_forward_flows (TAO_Base_StreamEndPoint *endpoint,
           result = this->acceptor_registry_->open (endpoint,
                                                    this,
                                                    address_flow_set);
+          if (result < 0)
+            ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Core::init_forward_flows::acceptor_registry::open failed\n"),-1);
           TAO_AV_FlowSpecSetItor end = address_flow_set.end ();
           for (TAO_AV_FlowSpecSetItor start = address_flow_set.begin ();
                start != end; ++start)
@@ -172,6 +109,16 @@ TAO_AV_Core::init_forward_flows (TAO_Base_StreamEndPoint *endpoint,
                 default:
                   break;
                 }
+              // Now if the address_set has been changed due to the addition of a control entry we should
+              // add that to the flow_spec_set also.
+              if (flow_spec_set.find (entry) < 0)
+                {
+                  // entry doesn't exist so add it.
+                  flow_spec_set.insert (entry);
+//                   size_t len = flow_spec.length ();
+//                   flow_spec.length (len+1);
+//                   flow_spec [len] = entry->entry_to_string ();
+                }
             }
         }
       break;
@@ -207,8 +154,14 @@ TAO_AV_Core::init_forward_flows (TAO_Base_StreamEndPoint *endpoint,
                   default:
                     break;
                   }
+              // Now if the address_set has been changed due to the addition of a control entry we should
+              // add that to the flow_spec_set also.
+              if (flow_spec_set.find (entry) < 0)
+                {
+                  // entry doesn't exist so add it.
+                  flow_spec_set.insert (entry);
+                }
               }
-
           }
         if (flow_set.size () > 0)
           {
@@ -239,6 +192,13 @@ TAO_AV_Core::init_forward_flows (TAO_Base_StreamEndPoint *endpoint,
                   default:
                     break;
                   }
+              // Now if the address_set has been changed due to the addition of a control entry we should
+              // add that to the flow_spec_set also.
+              if (flow_spec_set.find (entry) < 0)
+                {
+                  // entry doesn't exist so add it.
+                  flow_spec_set.insert (entry);
+                }
               }
           }
 
@@ -306,8 +266,8 @@ TAO_AV_Core::init_reverse_flows (TAO_Base_StreamEndPoint *endpoint,
   TAO_AV_FlowSpecSet acceptor_flow_set;
   TAO_AV_FlowSpecSet connector_flow_set;
   TAO_AV_FlowSpecSetItor end = reverse_flow_spec_set.end ();
-  for (TAO_AV_FlowSpecSetItor start = reverse_flow_spec_set.begin ();
-       start != end; ++start)
+  TAO_AV_FlowSpecSetItor start = reverse_flow_spec_set.begin ();
+  for (;start != end; ++start)
     {
       TAO_FlowSpec_Entry *entry = (*start);
       ACE_Addr *address = entry->address ();
@@ -321,6 +281,14 @@ TAO_AV_Core::init_reverse_flows (TAO_Base_StreamEndPoint *endpoint,
                                            entry->flowname ());
               if (forward_entry != 0)
                 forward_entry->set_peer_addr (address);
+              // Now we have to match the control and data flow objects.
+              // Check if there's a control object.
+              char control_flowname [BUFSIZ];
+              ACE_OS::sprintf (control_flowname,"%s_control",entry->flowname ());
+              TAO_FlowSpec_Entry *control_entry = this->get_flow_spec_entry (forward_flow_spec_set,
+                                                                             control_flowname);
+              if (control_entry != 0)
+                forward_entry->protocol_object ()->control_object (control_entry->protocol_object ());
             }
           else
             connector_flow_set.insert (entry);
@@ -340,6 +308,12 @@ TAO_AV_Core::init_reverse_flows (TAO_Base_StreamEndPoint *endpoint,
   if (result == -1)
     ACE_ERROR_RETURN ((LM_ERROR,"acceptor_registry::open"),-1);
 
+  start = reverse_flow_spec_set.begin ();
+  for (;start != end; ++start)
+    {
+      TAO_FlowSpec_Entry *entry = (*start);
+
+    }
   return 0;
 }
 
@@ -392,104 +366,180 @@ TAO_AV_Core::get_connector (const char *flowname)
 }
 
 int
-TAO_AV_Core::init_protocol_factories (void)
+TAO_AV_Core::init_transport_factories (void)
 {
-  TAO_AV_ProtocolFactorySetItor end = protocol_factories_.end ();
-  TAO_AV_ProtocolFactorySetItor factory = protocol_factories_.begin ();
+  TAO_AV_TransportFactorySetItor end = this->transport_factories_.end ();
+  TAO_AV_TransportFactorySetItor factory = this->transport_factories_.begin ();
 
   if (factory == end)
     {
-      TAO_AV_Protocol_Factory *udp_protocol_factory = 0;
-      TAO_AV_Protocol_Item *udp_item = 0;
+      TAO_AV_Transport_Factory *udp_factory = 0;
+      TAO_AV_Transport_Item *udp_item = 0;
+
+      udp_factory = 
+        ACE_Dynamic_Service<TAO_AV_Transport_Factory>::instance ("UDP_Factory");
+      if (udp_factory == 0)
+        {
+          if (TAO_debug_level)
+            ACE_ERROR ((LM_WARNING,
+                        "(%P|%t) WARNING - No %s found in Service Repository."
+                        "  Using default instance.\n",
+                        "UDP Factory"));
+
+          ACE_NEW_RETURN (udp_factory,
+                          TAO_AV_UDP_Factory,
+                          -1);
+        }
 
-      ACE_NEW_RETURN (udp_protocol_factory,
-                      TAO_AV_UDP_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (udp_item, TAO_AV_Protocol_Item ("UDP_Factory"), -1);
-      udp_item->factory (udp_protocol_factory);
+      ACE_NEW_RETURN (udp_item, TAO_AV_Transport_Item ("UDP_Factory"), -1);
+      udp_item->factory (udp_factory);
 
-      this->protocol_factories_.insert (udp_item);
+      this->transport_factories_.insert (udp_item);
 
-      TAO_AV_Protocol_Factory *tcp_protocol_factory = 0;
-      TAO_AV_Protocol_Item *tcp_item = 0;
+      TAO_AV_Transport_Factory *tcp_factory = 0;
+      TAO_AV_Transport_Item *tcp_item = 0;
 
-      ACE_NEW_RETURN (tcp_protocol_factory,
-                      TAO_AV_TCP_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (tcp_item, TAO_AV_Protocol_Item ("TCP_Factory"), -1);
-      tcp_item->factory (tcp_protocol_factory);
+      tcp_factory = 
+        ACE_Dynamic_Service<TAO_AV_Transport_Factory>::instance ("TCP_Factory");
+      if (tcp_factory == 0)
+        {
+          if (TAO_debug_level)
+            ACE_ERROR ((LM_WARNING,
+                        "(%P|%t) WARNING - No %s found in Service Repository."
+                        "  Using default instance.\n",
+                        "TCP Factory"));
+
+          ACE_NEW_RETURN (tcp_factory,
+                          TAO_AV_TCP_Factory,
+                          -1);
+        }
 
-      this->protocol_factories_.insert (tcp_item);
+      ACE_NEW_RETURN (tcp_item, TAO_AV_Transport_Item ("TCP_Factory"), -1);
+      tcp_item->factory (tcp_factory);
 
-      TAO_AV_Protocol_Factory *sfp_protocol_factory = 0;
-      TAO_AV_Protocol_Item *sfp_item = 0;
+      this->transport_factories_.insert (tcp_item);
 
-      ACE_NEW_RETURN (sfp_protocol_factory,
-                      TAO_SFP_UDP_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (sfp_item, TAO_AV_Protocol_Item ("SFP_UDP_Factory"), -1);
-      sfp_item->factory (sfp_protocol_factory);
 
-      this->protocol_factories_.insert (sfp_item);
+    }
+  return 0;
+}
+
+int
+TAO_AV_Core::init_flow_protocol_factories (void)
+{
+  TAO_AV_Flow_ProtocolFactorySetItor end = this->flow_protocol_factories_.end ();
+  TAO_AV_Flow_ProtocolFactorySetItor factory = this->flow_protocol_factories_.begin ();
+
+  if (factory == end)
+    {
+      TAO_AV_Flow_Protocol_Factory *udp_flow_factory = 0;
+      TAO_AV_Flow_Protocol_Item *udp_item = 0;
 
-      TAO_AV_Protocol_Factory *udp_mcast_protocol_factory = 0;
-      TAO_AV_Protocol_Item *udp_mcast_item = 0;
+      udp_flow_factory = 
+        ACE_Dynamic_Service<TAO_AV_Flow_Protocol_Factory>::instance ("UDP_Flow_Factory");
+      if (udp_flow_factory == 0)
+        {
+          if (TAO_debug_level)
+            ACE_ERROR ((LM_WARNING,
+                        "(%P|%t) WARNING - No %s found in Service Repository."
+                        "  Using default instance.\n",
+                        "UDP Flow Factory"));
+
+          ACE_NEW_RETURN (udp_flow_factory,
+                          TAO_AV_UDP_Flow_Factory,
+                          -1);
+        }
 
-      ACE_NEW_RETURN (udp_mcast_protocol_factory,
-                      TAO_AV_UDP_MCast_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (udp_mcast_item, TAO_AV_Protocol_Item ("UDP_MCast_Factory"), -1);
-      udp_mcast_item->factory (udp_mcast_protocol_factory);
+      ACE_NEW_RETURN (udp_item, TAO_AV_Flow_Protocol_Item ("UDP_Flow_Factory"), -1);
+      udp_item->factory (udp_flow_factory);
 
-      this->protocol_factories_.insert (udp_mcast_item);
+      this->flow_protocol_factories_.insert (udp_item);
 
-      TAO_AV_Protocol_Factory *rtp_udp_protocol_factory = 0;
-      TAO_AV_Protocol_Item *rtp_udp_item = 0;
+      TAO_AV_Flow_Protocol_Factory *tcp_flow_factory = 0;
+      TAO_AV_Flow_Protocol_Item *tcp_item = 0;
 
-      ACE_NEW_RETURN (rtp_udp_protocol_factory,
-                      TAO_AV_RTP_UDP_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (rtp_udp_item, TAO_AV_Protocol_Item ("RTP_UDP_Factory"), -1);
-      rtp_udp_item->factory (rtp_udp_protocol_factory);
+      tcp_flow_factory = 
+        ACE_Dynamic_Service<TAO_AV_Flow_Protocol_Factory>::instance ("TCP_Flow_Factory");
+      if (tcp_flow_factory == 0)
+        {
+          if (TAO_debug_level)
+            ACE_ERROR ((LM_WARNING,
+                        "(%P|%t) WARNING - No %s found in Service Repository."
+                        "  Using default instance.\n",
+                        "TCP Flow Factory"));
+
+          ACE_NEW_RETURN (tcp_flow_factory,
+                          TAO_AV_TCP_Flow_Factory,
+                          -1);
+        }
 
-      this->protocol_factories_.insert (rtp_udp_item);
+      ACE_NEW_RETURN (tcp_item, TAO_AV_Flow_Protocol_Item ("TCP_Flow_Factory"), -1);
+      tcp_item->factory (tcp_flow_factory);
 
-      TAO_AV_Protocol_Factory *rtp_udp_mcast_protocol_factory = 0;
-      TAO_AV_Protocol_Item *rtp_udp_mcast_item = 0;
+      this->flow_protocol_factories_.insert (tcp_item);
 
-      ACE_NEW_RETURN (rtp_udp_mcast_protocol_factory,
-                      TAO_AV_RTP_UDP_MCast_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (rtp_udp_mcast_item, TAO_AV_Protocol_Item ("RTP_UDP_MCast_Factory"), -1);
-      rtp_udp_mcast_item->factory (rtp_udp_mcast_protocol_factory);
+      TAO_AV_Flow_Protocol_Factory *rtp_flow_factory = 0;
+      TAO_AV_Flow_Protocol_Item *rtp_item = 0;
 
-      this->protocol_factories_.insert (rtp_udp_mcast_item);
+      rtp_flow_factory = 
+        ACE_Dynamic_Service<TAO_AV_Flow_Protocol_Factory>::instance ("RTP_Flow_Factory");
+      if (rtp_flow_factory == 0)
+        {
+          if (TAO_debug_level)
+            ACE_ERROR ((LM_WARNING,
+                        "(%P|%t) WARNING - No %s found in Service Repository."
+                        "  Using default instance.\n",
+                        "RTP Flow Factory"));
+
+          ACE_NEW_RETURN (rtp_flow_factory,
+                          TAO_AV_RTP_Flow_Factory,
+                          -1);
+        }
 
-      TAO_AV_Protocol_Factory *sfp_udp_mcast_protocol_factory = 0;
-      TAO_AV_Protocol_Item *sfp_udp_mcast_item = 0;
+      ACE_NEW_RETURN (rtp_item, TAO_AV_Flow_Protocol_Item ("RTP_Flow_Factory"), -1);
+      rtp_item->factory (rtp_flow_factory);
 
-      ACE_NEW_RETURN (sfp_udp_mcast_protocol_factory,
-                      TAO_SFP_UDP_MCast_Protocol_Factory,
-                      -1);
-      ACE_NEW_RETURN (sfp_udp_mcast_item, TAO_AV_Protocol_Item ("SFP_UDP_MCast_Factory"), -1);
-      sfp_udp_mcast_item->factory (sfp_udp_mcast_protocol_factory);
+      this->flow_protocol_factories_.insert (rtp_item);
 
-      this->protocol_factories_.insert (sfp_udp_mcast_item);
+      TAO_AV_Flow_Protocol_Factory *rtcp_flow_factory = 0;
+      TAO_AV_Flow_Protocol_Item *rtcp_item = 0;
 
-      if (TAO_debug_level > 0)
+      rtcp_flow_factory = 
+        ACE_Dynamic_Service<TAO_AV_Flow_Protocol_Factory>::instance ("RTCP_Flow_Factory");
+      if (rtcp_flow_factory == 0)
         {
-          if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,
-                      "TAO (%P|%t) Loaded default protocol UDP_Factory\n"));
+          if (TAO_debug_level)
+            ACE_ERROR ((LM_WARNING,
+                        "(%P|%t) WARNING - No %s found in Service Repository."
+                        "  Using default instance.\n",
+                        "RTCP Flow Factory"));
+
+          ACE_NEW_RETURN (rtcp_flow_factory,
+                          TAO_AV_RTCP_Flow_Factory,
+                          -1);
         }
+
+      ACE_NEW_RETURN (rtcp_item, TAO_AV_Flow_Protocol_Item ("RTCP_Flow_Factory"), -1);
+      rtcp_item->factory (rtcp_flow_factory);
+
+      this->flow_protocol_factories_.insert (rtcp_item);
     }
   return 0;
 }
 
+//------------------------------------------------------------
+// TAO_AV_Transport_Item
+//------------------------------------------------------------
+TAO_AV_Transport_Item::TAO_AV_Transport_Item (const ACE_CString &name)
+  :   name_ (name),
+      factory_ (0)
+{
+}
 
 //------------------------------------------------------------
-// TAO_AV_Protocol_Item
+// TAO_AV_Transport_Item
 //------------------------------------------------------------
-TAO_AV_Protocol_Item::TAO_AV_Protocol_Item (const ACE_CString &name)
+TAO_AV_Flow_Protocol_Item::TAO_AV_Flow_Protocol_Item (const ACE_CString &name)
   :   name_ (name),
       factory_ (0)
 {
@@ -516,7 +566,10 @@ TAO_AV_Connector_Registry::open (TAO_Base_StreamEndPoint *endpoint,
     {
       TAO_FlowSpec_Entry *entry = (*flow_spec);
       ACE_Addr *address = entry->address ();
-      TAO_AV_Core::Protocol protocol = entry->carrier_protocol ();
+      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
@@ -529,40 +582,138 @@ TAO_AV_Connector_Registry::open (TAO_Base_StreamEndPoint *endpoint,
         }
       else
         {
-          // Now get the list of avaliable protocol factories.
-          TAO_AV_ProtocolFactorySetItor end =
-            av_core->protocol_factories ()->end ();
+          TAO_AV_Flow_ProtocolFactorySetItor flow_factory_end =
+            av_core->flow_protocol_factories ()->end ();
 
-          for (TAO_AV_ProtocolFactorySetItor factory =
-                 av_core->protocol_factories ()->begin ();
-               factory != end;
-               ++factory)
+          for (TAO_AV_Flow_ProtocolFactorySetItor flow_factory =
+                 av_core->flow_protocol_factories ()->begin ();
+               flow_factory != flow_factory_end;
+               ++flow_factory)
             {
-              if ((*factory)->factory ()->match_protocol (protocol))
+              if ((*flow_factory)->factory ()->match_protocol (flow_protocol))
                 {
-                  TAO_AV_Connector *connector =
-                    (*factory)->factory ()->make_connector ();
-                  if (connector != 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_TransportFactorySetItor transport_factory_end =
+                    av_core->transport_factories ()->end ();
+                  for (TAO_AV_TransportFactorySetItor transport_factory =
+                         av_core->transport_factories ()->begin ();
+                       transport_factory != transport_factory_end;
+                       ++transport_factory)
+                    {
+                      if ((*transport_factory)->factory ()->match_protocol (transport_protocol))
+                        {
+                          TAO_AV_Connector *connector =
+                            (*transport_factory)->factory ()->make_connector ();
+                          if (connector != 0)
+                            {
+                              // add connector to list.
+                              this->connectors_.insert (connector);
+
+                              if (connector->open (endpoint,
+                                                   av_core,
+                                                   (*flow_factory)->factory ()) == -1)
+                                return -1;
+                              TAO_AV_Transport *transport = 0;
+                              if (connector->connect (entry,
+                                                      transport) == -1)
+                                return -1;
+                              entry->transport (transport);
+                              break;
+                            }
+                          else
+                            ACE_ERROR_RETURN ((LM_ERROR,
+                                               "(%P|%t) Unable to create an "
+                                               "connector for <%s>\n",
+                                               entry->flowname ()),
+                                              -1);
+                        }
+                      else
+                        continue;
+                    }
+                  // Now check if the flow factory has a control flow factory.
+                  const char *control_factory_name
+                    = (*flow_factory)->factory ()->control_flow_factory ();
+               
+                  if (control_factory_name != 0)
                     {
-                      // add connector to list.
-                      this->connectors_.insert (connector);
-
-                      if (connector->open (endpoint,
-                                           av_core) == -1)
-                        return -1;
-                      TAO_AV_Transport *transport = 0;
-                      if (connector->connect (entry,
-                                              transport) == -1)
-                        return -1;
-                      entry->transport (transport);
-                      break;
+                      TAO_AV_Flow_ProtocolFactorySetItor control_factory_end =
+                        av_core->flow_protocol_factories ()->end ();
+
+                      for (TAO_AV_Flow_ProtocolFactorySetItor control_flow_factory =
+                             av_core->flow_protocol_factories ()->begin ();
+                           control_flow_factory != control_factory_end;
+                           ++control_flow_factory)
+                        {
+                          if ((*control_flow_factory)->factory ()->match_protocol (control_factory_name))
+                            {
+                              char control_flowname [BUFSIZ];
+                              ACE_OS::sprintf (control_flowname,"%s_control",entry->flowname ());
+                              // Address will be one port number above the data port.
+                              // @@ This requires a more generic solution. This is a hack.
+                              TAO_Tokenizer address_str (CORBA::string_dup (entry->address_str ()),':');
+                              int port = ACE_OS::atoi (address_str [1]);
+                              // Increment the port.
+                              port++;
+                              char control_addr [BUFSIZ];
+                              ACE_OS::sprintf (control_addr,"%s=%s:%d",
+                                               entry->carrier_protocol_str (),
+                                               address_str[0],port);
+                              TAO_Forward_FlowSpec_Entry *control_entry = 0;
+                              // We  want to have the control entry as producer
+                              // so timeout events will happen.
+                              ACE_NEW_RETURN (control_entry,
+                                              TAO_Forward_FlowSpec_Entry (control_flowname,
+                                                                          "IN",
+                                                                          entry->format (),
+                                                                          entry->flow_protocol_str (),
+                                                                          control_addr),
+                                              -1);
+                              // Add the control entry to the flow_spec_set that's passed so that the control entry 
+                              // will also be called during flow starts and stops. except that if the user specifies
+                              // a flowspec in start then the control entry may not be in that but it has to be started
+                              // if the flowspec has the associated data flow entry. @@ We'll leave this matter for now.
+                              flow_spec_set.insert (control_entry);
+                              for (TAO_AV_TransportFactorySetItor transport_factory =
+                                     av_core->transport_factories ()->begin ();
+                                   transport_factory != transport_factory_end;
+                                   ++transport_factory)
+                                {
+                                  if ((*transport_factory)->factory ()->match_protocol (transport_protocol))
+                                    {
+                                      TAO_AV_Connector *connector =
+                                        (*transport_factory)->factory ()->make_connector ();
+                                      if (connector != 0)
+                                        {
+                                          // add connector to list.
+                                          this->connectors_.insert (connector);
+
+                                          if (connector->open (endpoint,
+                                                               av_core,
+                                                               (*control_flow_factory)->factory ()) == -1)
+                                            return -1;
+                                          TAO_AV_Transport *transport = 0;
+                                          if (connector->connect (control_entry,
+                                                                  transport) == -1)
+                                            return -1;
+                                          control_entry->transport (transport);
+                                          break;
+                                        }
+                                      else
+                                        ACE_ERROR_RETURN ((LM_ERROR,
+                                                           "(%P|%t) Unable to create an "
+                                                           "connector for <%s>\n",
+                                                           control_entry->flowname ()),
+                                                          -1);
+                                    }
+                                  else
+                                    continue;
+                                }
+                              // Now set the control object on the data flow object.
+                              entry->protocol_object ()->control_object (control_entry->protocol_object ());
+                            }
+                        }
                     }
-                  else
-                    ACE_ERROR_RETURN ((LM_ERROR,
-                                       "(%P|%t) Unable to create an "
-                                       "connector for <%s>\n",
-                                       entry->flowname ()),
-                                      -1);
                 }
               else
                 continue;
@@ -594,38 +745,6 @@ TAO_AV_Connector_Registry::close_all (void)
   return 0;
 }
 
-/*
-int
-TAO_AV_Connector_Registry::connect (TAO_FlowSpec_Entry *flowspec,
-                                    TAO_AV_Transport *&transport)
-{
-  // Find the appropriate connector object
-  TAO_AV_Connector *connector =
-    this->get_connector (flowspec->carrier_protocol ());
-
-  return connector->connect (flowspec, transport);
-}
-
-
-TAO_AV_Connector *
-TAO_AV_Connector_Registry::get_connector (TAO_AV_Core::Protocol protocol)
-{
-  TAO_AV_ConnectorSetItor end =
-    this->connectors_.end ();
-  TAO_AV_ConnectorSetItor connector =
-    this->connectors_.begin ();
-
-  for (;
-       connector != end ;
-       connector++)
-    {
-      if ((*connector)->carrier_protocol () == protocol)
-        return *connector;
-    }
-  return 0;
-}
-*/
-
 TAO_AV_Connector_Registry::~TAO_AV_Connector_Registry (void)
 {
   this->close_all ();
@@ -657,9 +776,12 @@ TAO_AV_Acceptor_Registry::open (TAO_Base_StreamEndPoint *endpoint,
     {
       TAO_FlowSpec_Entry *entry = (*flow_spec);
       ACE_Addr *address = entry->address ();
-      TAO_AV_Core::Protocol protocol = entry->carrier_protocol ();
+      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 %d",
-                  entry->flowname (),protocol));
+                                           entry->flowname (),transport_protocol));
       if (address == 0)
         {
           this->open_default (endpoint,av_core, entry);
@@ -668,35 +790,130 @@ TAO_AV_Acceptor_Registry::open (TAO_Base_StreamEndPoint *endpoint,
       else
         {
           // Now get the list of avaliable protocol factories.
-          TAO_AV_ProtocolFactorySetItor end =
-            av_core->protocol_factories ()->end ();
+          TAO_AV_Flow_ProtocolFactorySetItor flow_factory_end =
+            av_core->flow_protocol_factories ()->end ();
 
-          for (TAO_AV_ProtocolFactorySetItor factory =
-                 av_core->protocol_factories ()->begin ();
-               factory != end;
-               ++factory)
+          for (TAO_AV_Flow_ProtocolFactorySetItor flow_factory =
+                 av_core->flow_protocol_factories ()->begin ();
+               flow_factory != flow_factory_end;
+               ++flow_factory)
             {
-              if ((*factory)->factory ()->match_protocol (protocol))
+              if ((*flow_factory)->factory ()->match_protocol (flow_protocol))
                 {
-                  TAO_AV_Acceptor *acceptor =
-                    (*factory)->factory ()->make_acceptor ();
-                  if (acceptor != 0)
+                  TAO_AV_TransportFactorySetItor transport_factory_end =
+                    av_core->transport_factories ()->end ();
+                  for (TAO_AV_TransportFactorySetItor transport_factory =
+                         av_core->transport_factories ()->begin ();
+                       transport_factory != transport_factory_end;
+                       ++transport_factory)
                     {
-                      // add acceptor to list.
-                      this->acceptors_.insert (acceptor);
-
-                      if (acceptor->open (endpoint,
-                                          av_core,
-                                          entry) == -1)
-                        return -1;
-                      break;
+                      if ((*transport_factory)->factory ()->match_protocol (transport_protocol))
+                        {
+                          TAO_AV_Acceptor *acceptor =
+                            (*transport_factory)->factory ()->make_acceptor ();
+                          if (acceptor != 0)
+                            {
+                              // add acceptor to list.
+                              this->acceptors_.insert (acceptor);
+
+                              if (acceptor->open (endpoint,
+                                                  av_core,
+                                                  entry,
+                                                  (*flow_factory)->factory ()) == -1)
+                                return -1;
+                              break;
+                            }
+                          else
+                            ACE_ERROR_RETURN ((LM_ERROR,
+                                               "(%P|%t) Unable to create an "
+                                               "acceptor for <%s>\n",
+                                               entry->flowname ()),
+                                              -1);
+                        }
+                      else
+                        continue;
+                    }
+                  // Now check if the flow factory has a control flow factory.
+                  const char *control_factory_name
+                    = (*flow_factory)->factory ()->control_flow_factory ();
+
+                  if (control_factory_name != 0)
+                    {
+                      TAO_AV_Flow_ProtocolFactorySetItor control_factory_end =
+                        av_core->flow_protocol_factories ()->end ();
+
+                      for (TAO_AV_Flow_ProtocolFactorySetItor control_flow_factory =
+                             av_core->flow_protocol_factories ()->begin ();
+                           control_flow_factory != control_factory_end;
+                           ++control_flow_factory)
+                        {
+                          if ((*control_flow_factory)->factory ()->match_protocol (control_factory_name))
+                            {
+                              char control_flowname [BUFSIZ];
+                              ACE_OS::sprintf (control_flowname,"%s_control",entry->flowname ());
+                              // Address will be one port number above the data port.
+                              // @@ This requires a more generic solution. This is a hack.
+                              TAO_Tokenizer address_str (CORBA::string_dup (entry->address_str ()),':');
+                              int port = ACE_OS::atoi (address_str [1]);
+                              // Increment the port.
+                              port++;
+                              char control_addr [BUFSIZ];
+                              ACE_OS::sprintf (control_addr,"%s=%s:%d",
+                                               entry->carrier_protocol_str (),
+                                               address_str[0],port);
+                              TAO_Forward_FlowSpec_Entry *control_entry = 0;
+                              // We  want to have the control entry as producer
+                              // so timeout events will happen.
+                              ACE_NEW_RETURN (control_entry,
+                                              TAO_Forward_FlowSpec_Entry (control_flowname,
+                                                                          "IN",
+                                                                          entry->format (),
+                                                                          entry->flow_protocol_str (),
+                                                                          control_addr),
+                                              -1);
+                              // Add the control entry to the flow_spec_set that's passed so that the control entry 
+                              // will also be called during flow starts and stops. except that if the user specifies
+                              // a flowspec in start then the control entry may not be in that but it has to be started
+                              //   if the flowspec has the associated data flow entry. @@ We'll leave this matter for now.
+                              flow_spec_set.insert (control_entry);
+                              TAO_AV_TransportFactorySetItor transport_factory_end =
+                                av_core->transport_factories ()->end ();
+                              for (TAO_AV_TransportFactorySetItor transport_factory =
+                                     av_core->transport_factories ()->begin ();
+                                   transport_factory != transport_factory_end;
+                                   ++transport_factory)
+                                {
+                                  if ((*transport_factory)->factory ()->match_protocol (transport_protocol))
+                                    {
+                                      TAO_AV_Acceptor *acceptor =
+                                        (*transport_factory)->factory ()->make_acceptor ();
+                                      if (acceptor != 0)
+                                        {
+                                          // add acceptor to list.
+                                          this->acceptors_.insert (acceptor);
+
+                                          if (acceptor->open (endpoint,
+                                                              av_core,
+                                                              control_entry,
+                                                              (*control_flow_factory)->factory ()) == -1)
+                                            return -1;
+                                          break;
+                                        }
+                                      else
+                                        ACE_ERROR_RETURN ((LM_ERROR,
+                                                           "(%P|%t) Unable to create an "
+                                                           "acceptor for <%s>\n",
+                                                           entry->flowname ()),
+                                                          -1);
+                                    }
+                                  else
+                                    continue;
+                                }
+                              // Now set the control object on the data flow object.
+                              entry->protocol_object ()->control_object (control_entry->protocol_object ());
+                            }
+                        }
                     }
-                  else
-                    ACE_ERROR_RETURN ((LM_ERROR,
-                                       "(%P|%t) Unable to create an "
-                                       "acceptor for <%s>\n",
-                                       entry->flowname ()),
-                                      -1);
                 }
               else
                 continue;
@@ -715,19 +932,23 @@ TAO_AV_Acceptor_Registry::open_default (TAO_Base_StreamEndPoint *endpoint,
   // No endpoints were specified, we let each protocol pick its own
   // default...
 
-  TAO_AV_ProtocolFactorySetItor end =
-    av_core->protocol_factories ()->end ();
+  TAO_AV_Flow_ProtocolFactorySetItor flow_factory_end =
+    av_core->flow_protocol_factories ()->end ();
+
+  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;
 
   // loop through loaded protocols looking for protocol_prefix
-  for (TAO_AV_ProtocolFactorySetItor i =
-         av_core->protocol_factories ()->begin ();
-       i != end;
-       ++i)
+  TAO_AV_Flow_ProtocolFactorySetItor flow_factory = av_core->flow_protocol_factories ()->begin ();
+  TAO_AV_TransportFactorySetItor transport_factory = av_core->transport_factories ()->begin ();
+  for (;
+       flow_factory != flow_factory_end;
+       ++flow_factory)
     {
-      TAO_AV_Core::Protocol protocol = entry->carrier_protocol ();
-      if (protocol != TAO_AV_Core::TAO_AV_NOPROTOCOL)
-        {
-          if (!(*i)->factory ()->match_protocol (protocol))
+          if (!(*flow_factory)->factory ()->match_protocol (flow_protocol))
             {
               // If we have no matching protocol then keep searching
               // for one until the entire list of protocols has been
@@ -737,40 +958,63 @@ TAO_AV_Acceptor_Registry::open_default (TAO_Base_StreamEndPoint *endpoint,
                 ACE_ERROR ((LM_ERROR,
                             "TAO (%P|%t) Unable to match protocol prefix "
                             "for <%s>\n",
-                            protocol));
+                            flow_protocol));
               continue;
             }
-        }
+          else
+            {
+              TAO_AV_TransportFactorySetItor transport_factory_end =
+                av_core->transport_factories ()->end ();
+              for (;transport_factory != transport_factory_end;
+                   ++transport_factory)
+                {
+                  if (!(*transport_factory)->factory ()->match_protocol (transport_protocol))
+                    {
+                      // If we have no matching protocol then keep searching
+                      // for one until the entire list of protocols has been
+                      // searched.
+
+                      if (TAO_debug_level > 0)
+                        ACE_ERROR ((LM_ERROR,
+                                    "TAO (%P|%t) Unable to match protocol prefix "
+                                    "for <%s>\n",
+                                    flow_protocol));
+                      continue;
+                    }
+            
 
-      // got it, make an acceptor
-      TAO_AV_Acceptor *acceptor =
-        (*i)->factory ()->make_acceptor ();
 
-      if (acceptor == 0)
-        {
-          if (TAO_debug_level > 0)
-            ACE_ERROR ((LM_ERROR,
-                        "TAO (%P|%t) unable to create "
-                        "an acceptor for <%d>\n",
-                        protocol));
-          continue;
-        }
+                  // got it, make an acceptor
+                  TAO_AV_Acceptor *acceptor =
+                    (*transport_factory)->factory ()->make_acceptor ();
 
-      if (acceptor->open_default (endpoint,
-                                  av_core,
-                                  entry) == -1)
-        {
-          if (TAO_debug_level > 0)
-            ACE_ERROR ((LM_ERROR,
-                        "TAO (%P|%t) unable to open "
-                        "default acceptor for <%s>%p\n",
-                        (*i)->protocol_name ().c_str (), ""));
-          continue;
-        }
+                  if (acceptor == 0)
+                    {
+                      if (TAO_debug_level > 0)
+                        ACE_ERROR ((LM_ERROR,
+                                    "TAO (%P|%t) unable to create "
+                                    "an acceptor for <%d>\n",
+                                    transport_protocol));
+                      continue;
+                    }
 
-      this->acceptors_.insert (acceptor);
-    }
+                  if (acceptor->open_default (endpoint,
+                                              av_core,
+                                              entry,
+                                              (*flow_factory)->factory ()) == -1)
+                    {
+                      if (TAO_debug_level > 0)
+                        ACE_ERROR ((LM_ERROR,
+                                    "TAO (%P|%t) unable to open "
+                                    "default acceptor for <%s>%p\n",
+                                    (*transport_factory)->name ().c_str (), ""));
+                      continue;
+                    }
 
+                  this->acceptors_.insert (acceptor);
+                }
+            }
+    }
   if (this->acceptors_.size () == 0)
     {
       if (TAO_debug_level > 0)
@@ -827,9 +1071,10 @@ TAO_AV_Transport::get_local_addr (void)
 // TAO_AV_Flow_Handler
 //----------------------------------------------------------------------
 
-TAO_AV_Flow_Handler::TAO_AV_Flow_Handler (TAO_AV_Callback *callback)
+//TAO_AV_Flow_Handler::TAO_AV_Flow_Handler (TAO_AV_Callback *callback)
+TAO_AV_Flow_Handler::TAO_AV_Flow_Handler (void)
   :transport_ (0),
-   callback_ (callback),
+   callback_ (0),
    protocol_object_ (0)
 {
 }
@@ -849,15 +1094,7 @@ TAO_AV_Flow_Handler::start (TAO_FlowSpec_Entry::Role role)
       // only for producer we register for the timeout.
     case TAO_FlowSpec_Entry::TAO_AV_PRODUCER:
       {
-        ACE_Event_Handler *event_handler = this->event_handler ();
-        ACE_Time_Value *tv = 0;
-        this->callback_->get_timeout (tv,
-                                      this->timeout_arg_);
-        if (tv == 0)
-          return 0;
-        this->timer_id_ =  event_handler->reactor ()->schedule_timer (event_handler,
-                                                                      0,
-                                                                      *tv);
+        this->schedule_timer ();
       }
       break;
     }
@@ -865,6 +1102,22 @@ TAO_AV_Flow_Handler::start (TAO_FlowSpec_Entry::Role role)
 }
 
 int
+TAO_AV_Flow_Handler::schedule_timer (void)
+{
+  ACE_Event_Handler *event_handler = this->event_handler ();
+  ACE_Time_Value *tv = 0;
+  this->callback_->get_timeout (tv,
+                                this->timeout_arg_);
+  if (tv == 0)
+    return 0;
+  this->timer_id_ =  event_handler->reactor ()->schedule_timer (event_handler,
+                                                                0,
+                                                                *tv);
+  if (this->timer_id_ < 0)
+    return -1;
+}
+
+int
 TAO_AV_Flow_Handler::stop (TAO_FlowSpec_Entry::Role role)
 {
   this->callback_->handle_stop ();
@@ -916,6 +1169,12 @@ TAO_AV_Flow_Handler::protocol_object (void)
   return this->protocol_object_;
 }
 
+void
+TAO_AV_Flow_Handler::callback (TAO_AV_Callback *callback)
+{
+  this->callback_ = callback;
+}
+
 // TAO_AV_Connector
 TAO_AV_Connector::TAO_AV_Connector (void)
 {
@@ -934,1058 +1193,6 @@ TAO_AV_Acceptor::~TAO_AV_Acceptor (void)
 {
 }
 
-// TAO_AV_Protocol_Factory
-TAO_AV_Protocol_Factory::TAO_AV_Protocol_Factory (void)
-{
-}
-
-TAO_AV_Protocol_Factory::~TAO_AV_Protocol_Factory (void)
-{
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_Transport
-//------------------------------------------------------------
-
-TAO_AV_UDP_Transport::TAO_AV_UDP_Transport (void)
-  :handler_ (0)
-{
-}
-
-TAO_AV_UDP_Transport::TAO_AV_UDP_Transport (TAO_AV_UDP_Flow_Handler *handler)
-  :handler_ (handler),
-   addr_ (0)
-{
-}
-
-TAO_AV_UDP_Transport::~TAO_AV_UDP_Transport (void)
-{
-}
-
-int
-TAO_AV_UDP_Transport::set_remote_address (const ACE_INET_Addr &address)
-{
-  this->peer_addr_ = address;
-  return 0;
-}
-
-int
-TAO_AV_UDP_Transport::open (ACE_Addr */*address*/)
-{
-  return 0;
-}
-
-int
-TAO_AV_UDP_Transport::close (void)
-{
-  return 0;
-}
-
-int
-TAO_AV_UDP_Transport::mtu (void)
-{
-  return ACE_MAX_DGRAM_SIZE;
-}
-
-ACE_Addr*
-TAO_AV_UDP_Transport::get_peer_addr (void)
-{
-  return &this->peer_addr_;
-}
-
-ssize_t
-TAO_AV_UDP_Transport::send (const ACE_Message_Block *mblk, ACE_Time_Value *)
-{
-  // For the most part this was copied from GIOP::send_request and
-  // friends.
-
-  iovec iov[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  = 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 IOV_MAX to that limit.
-          if (iovcnt == IOV_MAX)
-            {
-              n = this->handler_->get_socket ()->send ((const iovec *) iov,
-                                                        iovcnt,
-                                                        this->peer_addr_);
-
-              if (n < 1)
-                return n;
-
-              nbytes += n;
-              iovcnt = 0;
-            }
-        }
-    }
-
-  // Check for remaining buffers to be sent!
-  if (iovcnt != 0)
-    {
-      n = this->handler_->get_socket ()->send ((const iovec *) iov,
-                                               iovcnt,
-                                               this->peer_addr_);
-
-      if (n < 1)
-        return n;
-
-      nbytes += n;
-    }
-
-  return nbytes;
-}
-
-ssize_t
-TAO_AV_UDP_Transport::send (const char *buf,
-                            size_t len,
-                            ACE_Time_Value *)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Transport::send "));
-  char addr [BUFSIZ];
-  this->peer_addr_.addr_to_string (addr,BUFSIZ);
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"to %s\n",addr));
-
-  return this->handler_->get_socket ()->send (buf, len,this->peer_addr_);
-}
-
-ssize_t
-TAO_AV_UDP_Transport::send (const iovec *iov,
-                          int iovcnt,
-                          ACE_Time_Value *)
-{
-  return this->handler_->get_socket ()->send ((const iovec *) iov,
-                                              iovcnt,
-                                              this->peer_addr_);
-
-}
-
-ssize_t
-TAO_AV_UDP_Transport::recv (char *buf,
-                            size_t len,
-                            ACE_Time_Value *)
-{
-  return this->handler_->get_socket ()->recv (buf, len,this->peer_addr_);
-}
-
-ssize_t
-TAO_AV_UDP_Transport::recv (char *buf,
-                            size_t len,
-                            int flags,
-                            ACE_Time_Value *timeout)
-{
-  return this->handler_->get_socket ()->recv (buf,
-                                              len,
-                                              this->peer_addr_,
-                                              flags,
-                                              timeout);
-}
-
-ssize_t
-TAO_AV_UDP_Transport::recv (iovec *iov,
-                            int /*iovcnt*/,
-                            ACE_Time_Value *timeout)
-{
-  return handler_->get_socket ()->recv (iov,this->peer_addr_,0,timeout);
-}
-
-//------------------------------------------------------------
-// TAO_AV_TCP_Transport
-//------------------------------------------------------------
-
-TAO_AV_TCP_Transport::TAO_AV_TCP_Transport (void)
-  :handler_ (0)
-{
-}
-
-TAO_AV_TCP_Transport::TAO_AV_TCP_Transport (TAO_AV_TCP_Flow_Handler *handler)
-  :handler_ (handler)
-{
-}
-
-TAO_AV_TCP_Transport::~TAO_AV_TCP_Transport (void)
-{
-}
-
-int
-TAO_AV_TCP_Transport::open (ACE_Addr */*address*/)
-{
-  return 0;
-}
-
-int
-TAO_AV_TCP_Transport::close (void)
-{
-  return 0;
-}
-
-int
-TAO_AV_TCP_Transport::mtu (void)
-{
-  return -1;
-}
-
-ACE_Addr*
-TAO_AV_TCP_Transport::get_peer_addr (void)
-{
-  return 0;
-}
-
-ssize_t
-TAO_AV_TCP_Transport::send (const ACE_Message_Block *mblk, ACE_Time_Value *)
-{
-  // For the most part this was copied from GIOP::send_request and
-  // friends.
-
-  iovec iov[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  = 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 IOV_MAX to that limit.
-          if (iovcnt == IOV_MAX)
-            {
-              n = this->handler_->peer ().sendv_n ((const iovec *) iov,
-                                                   iovcnt);
-              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_TCP_Transport::send (const char *buf,
-                            size_t len,
-                            ACE_Time_Value *)
-{
-  return this->handler_->peer ().send_n (buf, len);
-}
-
-ssize_t
-TAO_AV_TCP_Transport::send (const iovec *iov,
-                          int iovcnt,
-                          ACE_Time_Value *)
-{
-  return this->handler_->peer ().sendv_n ((const iovec *) iov,
-                                          iovcnt);
-}
-
-ssize_t
-TAO_AV_TCP_Transport::recv (char *buf,
-                          size_t len,
-                          ACE_Time_Value *)
-{
-  return this->handler_->peer ().recv (buf, len);
-}
-
-ssize_t
-TAO_AV_TCP_Transport::recv (char *buf,
-                            size_t len,
-                            int flags,
-                            ACE_Time_Value *)
-{
-  return this->handler_->peer ().recv (buf,
-                                       len,
-                                       flags);
-}
-
-ssize_t
-TAO_AV_TCP_Transport::recv (iovec *iov,
-                            int iovcnt,
-                            ACE_Time_Value *)
-{
-  return handler_->peer ().recvv_n (iov, iovcnt);
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_Acceptor
-//------------------------------------------------------------
-
-TAO_AV_UDP_Acceptor::TAO_AV_UDP_Acceptor (void)
-{
-}
-
-TAO_AV_UDP_Acceptor::~TAO_AV_UDP_Acceptor (void)
-{
-}
-
-int
-TAO_AV_UDP_Acceptor::make_svc_handler (TAO_AV_UDP_Flow_Handler *&udp_handler)
-{
-  TAO_AV_Callback *callback = 0;
-  if (this->endpoint_ != 0)
-    {
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (udp_handler,
-                      TAO_AV_UDP_Flow_Handler (callback),
-                      -1);
-      callback->transport (udp_handler->transport ());
-      TAO_AV_Protocol_Object *object =0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_UDP_Object (callback,
-                                         udp_handler->transport ()),
-                      -1);
-      // @@: Call open on callback with protocol object and transport.
-      udp_handler->protocol_object (object);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),udp_handler);
-      this->entry_->protocol_object (object);
-    }
-  return 0;
-}
-
-int
-TAO_AV_UDP_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
-                           TAO_AV_Core *av_core,
-                           TAO_FlowSpec_Entry *entry)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Acceptor::open "));
-  this->av_core_ = av_core;
-  this->endpoint_ = endpoint;
-  this->entry_ = entry;
-  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_UDP_Acceptor::open: %s",
-              buf));
-  int result = this->acceptor_.open (this,
-                                     av_core->reactor (),
-                                     *address,
-                                     this->handler_);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Acceptor::open failed"),-1);
-  entry->handler (this->handler_);
-  entry->set_local_addr (address);
-  return 0;
-}
-
-int
-TAO_AV_UDP_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
-                                   TAO_AV_Core *av_core,
-                                   TAO_FlowSpec_Entry *entry)
-{
-  this->av_core_ = av_core;
-  this->endpoint_ = endpoint;
-  this->entry_ = entry;
-  this->flowname_ = entry->flowname ();
-  ACE_INET_Addr *address;
-  ACE_NEW_RETURN (address,
-                  ACE_INET_Addr ("0"),
-                  -1);
-  int result = this->acceptor_.open (this,
-                                     av_core->reactor (),
-                                     *address,
-                                     this->handler_);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Acceptor::open failed"),-1);
-  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_UDP_Acceptor::open_default: %s\n",buf));
-  entry->handler (this->handler_);
-  entry->set_local_addr (address);
-  return 0;
-}
-
-int
-TAO_AV_UDP_Acceptor::close (void)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_Dgram_Acceptor
-//------------------------------------------------------------
-
-int
-TAO_AV_Dgram_Acceptor::open (TAO_AV_UDP_Acceptor *acceptor,
-                             ACE_Reactor *reactor,
-                             ACE_Addr &address,
-                             TAO_AV_UDP_Flow_Handler *&handler)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_Dgram_Acceptor::open "));
-  this->acceptor_ = acceptor;
-  this->reactor_ = reactor;
-  int result = 0;
-  result = this->make_svc_handler (handler);
-  result = handler->open (address);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"SOCK_Dgram::open failed\n"),-1);
-  int sndbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
-  int rcvbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
-
-  if (handler->get_socket ()->set_option (SOL_SOCKET,
-                                          SO_SNDBUF,
-                                          (void *) &sndbufsize,
-                                          sizeof (sndbufsize)) == -1
-      && errno != ENOTSUP)
-    return 0;
-
-  else if (handler->get_socket ()->set_option (SOL_SOCKET,
-                                               SO_RCVBUF,
-                                               (void *) &rcvbufsize,
-                                               sizeof (rcvbufsize)) == -1
-           && errno != ENOTSUP)
-    return 0;
-  result = this->activate_svc_handler (handler);
-  if (result < 0)
-    return result;
-  result = handler->get_socket ()->get_local_addr (address);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"SOCK_Dgram::get_local_addr failed\n"),-1);
-  return 0;
-}
-
-
-int
-TAO_AV_Dgram_Acceptor::activate_svc_handler (TAO_AV_UDP_Flow_Handler *handler)
-{
-  ACE_Event_Handler *event_handler = handler;
-  //  ACE_HANDLE fd = event_handler->get_handle ();
-  int result = this->reactor_->register_handler (event_handler,
-                                                 ACE_Event_Handler::READ_MASK);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Acceptor::activate_svc_handler failed\n"),result);
-  event_handler->reactor (this->reactor_);
-  return 0;
-}
-
-
-int
-TAO_AV_Dgram_Acceptor::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
-{
-  return this->acceptor_->make_svc_handler (handler);
-}
-
-//------------------------------------------------------------
-// TAO_AV_Dgram_Connector
-//------------------------------------------------------------
-
-int
-TAO_AV_Dgram_Connector::open (TAO_AV_UDP_Connector *connector,
-                              ACE_Reactor *reactor)
-{
-  this->connector_ = connector;
-  this->reactor_ = reactor;
-  return 0;
-}
-
-int
-TAO_AV_Dgram_Connector::connect (TAO_AV_UDP_Flow_Handler *&handler,
-                                 ACE_Addr &remote_addr,
-                                 ACE_Addr &local_addr)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_Dgram_Connector::connect "));
-  int result = 0;
-  this->make_svc_handler (handler);
-  result = handler->open (local_addr);
-  // set the socket buffer sizes to 64k.
-  int sndbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
-  int rcvbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
-
-  if (handler->get_socket ()->set_option (SOL_SOCKET,
-                                          SO_SNDBUF,
-                                          (void *) &sndbufsize,
-                                          sizeof (sndbufsize)) == -1
-      && errno != ENOTSUP)
-    return 0;
-
-  else if (handler->get_socket ()->set_option (SOL_SOCKET,
-                                               SO_RCVBUF,
-                                               (void *) &rcvbufsize,
-                                               sizeof (rcvbufsize)) == -1
-           && errno != ENOTSUP)
-    return 0;
-
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"SOCK_Dgram::open failed\n"),-1);
-  result = this->activate_svc_handler (handler);
-  if (result < 0)
-    return result;
-  handler->set_remote_address  (&remote_addr);
-  result = handler->get_socket ()->get_local_addr (local_addr);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Connector::open: get_local_addr failed\n"),result);
-  return 0;
-}
-
-int
-TAO_AV_Dgram_Connector::activate_svc_handler (TAO_AV_UDP_Flow_Handler *handler)
-{
-  int result = this->reactor_->register_handler (handler,
-                                                 ACE_Event_Handler::READ_MASK);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Connector::activate_svc_handler failed\n"),result);
-  handler->reactor (this->reactor_);
-  return 0;
-}
-
-int
-TAO_AV_Dgram_Connector::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
-{
-  return this->connector_->make_svc_handler (handler);
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_Connector
-//------------------------------------------------------------
-TAO_AV_UDP_Connector::TAO_AV_UDP_Connector (void)
-{
-}
-
-TAO_AV_UDP_Connector::~TAO_AV_UDP_Connector (void)
-{
-}
-
-int
-TAO_AV_UDP_Connector::make_svc_handler (TAO_AV_UDP_Flow_Handler *&udp_handler)
-{
-  TAO_AV_Callback *callback = 0;
-  if (this->endpoint_ != 0)
-    {
-      this->endpoint_->get_callback (this->flowname_.c_str (),
-                                     callback);
-      ACE_NEW_RETURN (udp_handler,
-                      TAO_AV_UDP_Flow_Handler (callback),
-                      -1);
-      callback->transport (udp_handler->transport ());
-      TAO_AV_Protocol_Object *object =0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_UDP_Object (callback,
-                                         udp_handler->transport ()),
-                      -1);
-      udp_handler->protocol_object (object);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),udp_handler);
-      this->entry_->protocol_object (object);
-    }
-  return 0;
-}
-
-int
-TAO_AV_UDP_Connector::open (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core)
-
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Connector::open "));
-  this->endpoint_ = endpoint;
-  this->av_core_ = av_core;
-  int result = this->connector_.open (this,av_core->reactor ());
-  return result;
-}
-
-int
-TAO_AV_UDP_Connector::connect (TAO_FlowSpec_Entry *entry,
-                               TAO_AV_Transport *&transport)
-{
-  this->entry_ = entry;
-  ACE_Addr *remote_addr = entry->address ();
-  ACE_INET_Addr *local_addr;
-  ACE_NEW_RETURN (local_addr,
-                  ACE_INET_Addr ("0"),
-                  -1);
-  int result = this->connector_.connect (this->handler_,
-                                         *remote_addr,
-                                         *local_addr);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_connector::open failed\n"),-1);
-  // XXX:hack to set the ip address correctly.
-  local_addr->set (local_addr->get_port_number (),
-                  local_addr->get_host_name ());
-  char buf[BUFSIZ];
-  local_addr->addr_to_string (buf,BUFSIZ);
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_CONNECTOR::connect:%s \n",buf));
-  entry->set_local_addr (local_addr);
-  entry->handler (this->handler_);
-  transport = this->handler_->transport ();
-  return 0;
-}
-
-int
-TAO_AV_UDP_Connector::close (void)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_UDP_Protocol_Factory
-//------------------------------------------------------------
-
-TAO_AV_UDP_Protocol_Factory::TAO_AV_UDP_Protocol_Factory (void)
-{
-}
-
-TAO_AV_UDP_Protocol_Factory::~TAO_AV_UDP_Protocol_Factory (void)
-{
-}
-
-int
-TAO_AV_UDP_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_UDP);
-}
-
-TAO_AV_Acceptor*
-TAO_AV_UDP_Protocol_Factory::make_acceptor (void)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Protocol_Factory::make_acceptor "));
-  TAO_AV_Acceptor *acceptor = 0;
-  ACE_NEW_RETURN (acceptor,
-                  TAO_AV_UDP_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector*
-TAO_AV_UDP_Protocol_Factory::make_connector (void)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Protocol_Factory::make_connector "));
-  TAO_AV_Connector *connector = 0;
-  ACE_NEW_RETURN (connector,
-                  TAO_AV_UDP_Connector,
-                  0);
-  return connector;
-}
-//------------------------------------------------------------
-// TAO_AV_TCP_Protocol_Factory
-//------------------------------------------------------------
-
-TAO_AV_TCP_Protocol_Factory::TAO_AV_TCP_Protocol_Factory (void)
-{
-}
-
-TAO_AV_TCP_Protocol_Factory::~TAO_AV_TCP_Protocol_Factory (void)
-{
-}
-
-int
-TAO_AV_TCP_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_TCP);
-}
-
-TAO_AV_Acceptor*
-TAO_AV_TCP_Protocol_Factory::make_acceptor (void)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Protocol_Factory::make_acceptor "));
-  TAO_AV_Acceptor *acceptor = 0;
-  ACE_NEW_RETURN (acceptor,
-                  TAO_AV_TCP_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector*
-TAO_AV_TCP_Protocol_Factory::make_connector (void)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Protocol_Factory::make_connector "));
-  TAO_AV_Connector *connector = 0;
-  ACE_NEW_RETURN (connector,
-                  TAO_AV_TCP_Connector,
-                  0);
-  return connector;
-}
-
-//------------------------------------------------------------
-// TAO_AV_TCP_Base_Connector
-//------------------------------------------------------------
-
-int
-TAO_AV_TCP_Base_Connector::connector_open (TAO_AV_TCP_Connector *connector,
-                                           ACE_Reactor *reactor)
-{
-  this->connector_ = connector;
-  this->reactor_ = reactor;
-
-  int result = ACE_Connector <TAO_AV_TCP_Flow_Handler,ACE_SOCK_CONNECTOR>::open (reactor);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Base_Connector::open failed\n"),-1);
-  return 0;
-}
-
-int
-TAO_AV_TCP_Base_Connector::make_svc_handler (TAO_AV_TCP_Flow_Handler *&tcp_handler)
-{
-  int result =
-    this->connector_->make_svc_handler (tcp_handler);
-  if (result < 0)
-    return result;
-  tcp_handler->reactor (this->reactor_);
-  return 0;
-}
-
-int
-TAO_AV_TCP_Base_Connector::connector_connect (TAO_AV_TCP_Flow_Handler *&handler,
-                                              const ACE_INET_Addr &remote_addr)
-{
-  int result = ACE_Connector <TAO_AV_TCP_Flow_Handler,ACE_SOCK_CONNECTOR>::connect (handler,
-                                                                                    remote_addr);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Base_Connector::connect failed\n"),-1);
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_TCP_Connector
-//------------------------------------------------------------
-TAO_AV_TCP_Connector::TAO_AV_TCP_Connector (void)
-{
-}
-
-TAO_AV_TCP_Connector::~TAO_AV_TCP_Connector (void)
-{
-}
-
-int
-TAO_AV_TCP_Connector::make_svc_handler (TAO_AV_TCP_Flow_Handler *&tcp_handler)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_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 (tcp_handler,
-                      TAO_AV_TCP_Flow_Handler (callback),
-                      -1);
-      callback->transport (tcp_handler->transport ());
-      TAO_AV_Protocol_Object *object =0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_TCP_Object (callback,
-                                         tcp_handler->transport ()),
-                      -1);
-      tcp_handler->protocol_object (object);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                            object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),tcp_handler);
-      this->entry_->protocol_object (object);
-      this->entry_->handler (tcp_handler);
-    }
-  return 0;
-}
-
-int
-TAO_AV_TCP_Connector::open (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core)
-
-{
-  this->endpoint_ = endpoint;
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Connector::open "));
-  int result = this->connector_.connector_open(this,
-                                               av_core->reactor ());
-  return result;
-}
-
-int
-TAO_AV_TCP_Connector::connect (TAO_FlowSpec_Entry *entry,
-                               TAO_AV_Transport *&transport)
-{
-  this->entry_ = entry;
-  ACE_Addr *remote_addr = entry->address ();
-  ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr *,remote_addr);
-  TAO_AV_TCP_Flow_Handler *handler;
-  int result = this->connector_.connector_connect (handler,
-                                                   *inet_addr);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_connector::open failed\n"),-1);
-  entry->handler (handler);
-  transport = handler->transport ();
-  return 0;
-}
-
-int
-TAO_AV_TCP_Connector::close (void)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_TCP_Base_Connector
-//------------------------------------------------------------
-
-int
-TAO_AV_TCP_Base_Acceptor::open (TAO_AV_TCP_Acceptor *acceptor,
-                                ACE_Reactor *reactor,
-                                const ACE_INET_Addr &local_addr,
-                                TAO_FlowSpec_Entry *entry)
-{
-  this->acceptor_ = acceptor;
-  this->reactor_ = reactor;
-  this->entry_ = entry;
-
-  int result = ACE_Acceptor <TAO_AV_TCP_Flow_Handler,ACE_SOCK_ACCEPTOR>::open (local_addr,reactor);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Base_Connector::open failed\n"),-1);
-  return 0;
-}
-
-int
-TAO_AV_TCP_Base_Acceptor::make_svc_handler (TAO_AV_TCP_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_TCP_Acceptor
-//------------------------------------------------------------
-
-TAO_AV_TCP_Acceptor::TAO_AV_TCP_Acceptor (void)
-{
-}
-
-TAO_AV_TCP_Acceptor::~TAO_AV_TCP_Acceptor (void)
-{
-}
-
-int
-TAO_AV_TCP_Acceptor::make_svc_handler (TAO_AV_TCP_Flow_Handler *&tcp_handler)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Acceptor::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 (tcp_handler,
-                      TAO_AV_TCP_Flow_Handler (callback),
-                      -1);
-      callback->transport (tcp_handler->transport ());
-      TAO_AV_Protocol_Object *object =0;
-      ACE_NEW_RETURN (object,
-                      TAO_AV_TCP_Object (callback,
-                                         tcp_handler->transport ()),
-                      -1);
-      tcp_handler->protocol_object (object);
-      callback->protocol_object (object);
-      this->endpoint_->set_protocol_object (this->flowname_.c_str (),
-                                         object);
-      this->endpoint_->set_handler (this->flowname_.c_str (),tcp_handler);
-      this->entry_->protocol_object (object);      
-      this->entry_->handler (tcp_handler);
-    }
-  return 0;
-}
-
-int
-TAO_AV_TCP_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
-                           TAO_AV_Core *av_core,
-                           TAO_FlowSpec_Entry *entry)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_TCP_Acceptor::open "));
-  this->av_core_ = av_core;
-  this->endpoint_ = endpoint;
-  this->entry_ = entry;
-  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_TCP_Acceptor::open: %s",
-              buf));
-  int result = this->acceptor_.open (this,
-                                     av_core->reactor (),
-                                     *inet_addr,
-                                     entry);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Acceptor::open failed"),-1);
-  entry->set_local_addr (address);
-  return 0;
-}
-
-int
-TAO_AV_TCP_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
-                                   TAO_AV_Core *av_core,
-                                   TAO_FlowSpec_Entry *entry)
-{
-  this->av_core_ = av_core;
-  this->endpoint_ = endpoint;
-  this->entry_ = entry;
-  this->flowname_ = entry->flowname ();
-  ACE_INET_Addr *address;
-  ACE_NEW_RETURN (address,
-                  ACE_INET_Addr ("0"),
-                  -1);
-  int result = this->acceptor_.open (this,
-                                     av_core->reactor (),
-                                     *address,
-                                     entry);
-
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_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_TCP_Acceptor::open_default: %s\n",buf));
-  entry->set_local_addr (address);
-  return 0;
-}
-
-
-int
-TAO_AV_TCP_Acceptor::close (void)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_AV_TCP_Flow_Handler
-//------------------------------------------------------------
-
-TAO_AV_TCP_Flow_Handler::TAO_AV_TCP_Flow_Handler (TAO_AV_Callback *callback)
-  :TAO_AV_Flow_Handler (callback)
-{
-  ACE_NEW (this->transport_,
-           TAO_AV_TCP_Transport (this));
-}
-
-TAO_AV_Transport *
-TAO_AV_TCP_Flow_Handler::transport (void)
-{
-  return this->transport_;
-}
-
-int
-TAO_AV_TCP_Flow_Handler::open (void *arg)
-{
-
-  int nodelay = 1;
-
-#if defined (TCP_NODELAY)
-  if (this->peer ().set_option (IPPROTO_TCP,
-                                TCP_NODELAY,
-                                (void *) &nodelay,
-                                sizeof (nodelay)) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "NODELAY failed\n"),
-                      -1);
-#endif /* TCP_NODELAY */
-
-  // Called by the <Strategy_Acceptor> when the handler is completely
-  // connected.
-  ACE_INET_Addr addr;
-
-  if (this->peer ().get_remote_addr (addr) == -1)
-    return -1;
-
-  char server[MAXHOSTNAMELEN + 16];
-
-  (void) addr.addr_to_string (server, sizeof (server));
-
-  if (TAO_debug_level > 0)
-    if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,
-                "(%P|%t) connection to server <%s> on %d\n",
-                server, this->peer ().get_handle ()));
-
-  this->peer ().enable (ACE_NONBLOCK);
-  // Register the handler with the reactor.
-  if (this->reactor ()
-      && this->reactor ()->register_handler
-      (this,
-       ACE_Event_Handler::READ_MASK) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       ASYS_TEXT ("%p\n"),
-                       ASYS_TEXT ("unable to register client handler")),
-                      -1);
-}
-
-int
-TAO_AV_TCP_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  size_t size = BUFSIZ;
-  ACE_Message_Block *frame = 0;
-  ACE_NEW_RETURN (frame,
-                  ACE_Message_Block (size),
-                  -1);
-  int n = this->transport_->recv (frame->rd_ptr (),
-                                  size);
-  if (n == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Flow_Handler::handle_input recv failed\n"),-1);
-  if (n == 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_TCP_Flow_Handler::handle_input connection closed\n"),-1);
-  frame->wr_ptr (n);
-  this->callback_->receive_frame (frame);
-  return 0;
-}
-
-int
-TAO_AV_TCP_Flow_Handler::handle_timeout (const ACE_Time_Value &tv, 
-                                               const void *arg)
-{
-  return TAO_AV_Flow_Handler::handle_timeout (tv,arg);
-}
-
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 template class ACE_Node <TAO_AV_Connector*>;
 template class ACE_Node <TAO_AV_Acceptor*>;
@@ -1994,8 +1201,6 @@ template class ACE_Unbounded_Set<TAO_AV_Connector*>;
 template class ACE_Unbounded_Set_Iterator<TAO_AV_Acceptor*>;
 template class ACE_Unbounded_Set_Iterator<TAO_AV_Connector*>;
 template class ACE_Singleton<TAO_AV_Core,ACE_Null_Mutex>;
-template class ACE_Acceptor<TAO_AV_TCP_Flow_Handler, ACE_SOCK_ACCEPTOR>;
-template class ACE_Connector<TAO_AV_TCP_Flow_Handler, ACE_SOCK_CONNECTOR>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #pragma instantiate ACE_Node <TAO_AV_Connector*>
 #pragma instantiate ACE_Node <TAO_AV_Acceptor*>
@@ -2004,6 +1209,4 @@ template class ACE_Connector<TAO_AV_TCP_Flow_Handler, ACE_SOCK_CONNECTOR>;
 #pragma instantiate ACE_Unbounded_Set_Iterator<TAO_AV_Connector*>
 #pragma instantiate ACE_Unbounded_Set_Iterator<TAO_AV_Acceptor*>
 #pragma instantiate ACE_Singleton<TAO_AV_Core,ACE_Null_Mutex>
-#pragma instantiate ACE_Acceptor<TAO_AV_TCP_Flow_Handler, ACE_SOCK_Acceptor, ACE_INET_Addr>
-#pragma instantiate ACE_Connector<TAO_AV_TCP_Flow_Handler, ACE_SOCK_Connector, ACE_INET_Addr>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/orbsvcs/orbsvcs/AV/Transport.h b/TAO/orbsvcs/orbsvcs/AV/Transport.h
index 82a5c6f674e..c46fa19e51b 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Transport.h
+++ b/TAO/orbsvcs/orbsvcs/AV/Transport.h
@@ -28,8 +28,53 @@
 #include "AV_Core.h"
 #include "FlowSpec_Entry.h"
 
-//  Transports
+// Forward declarations.
+class TAO_AV_Protocol_Object;
+class TAO_AV_Callback;
+class TAO_AV_Transport;
+
+class TAO_AV_Flow_Handler
+{
+public:
+  TAO_AV_Flow_Handler (void);
+  // Constructor.
+
+  virtual int start (TAO_FlowSpec_Entry::Role role);
+  virtual int stop  (TAO_FlowSpec_Entry::Role role);
+  // Start/stop the flow handler.
+
+  virtual int schedule_timer (void);
+  // Schedule timer. Uses the get_timeout method on the callback.
+
+  TAO_AV_Transport *transport (void);
+  // get the transport.
+
+  TAO_AV_Protocol_Object* protocol_object (void);
+  void protocol_object (TAO_AV_Protocol_Object *protocol_object);
+  // set/get protocol_object.
+
+  void callback (TAO_AV_Callback *callback);
+  // set the callback.
+
+  int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0);
+  // Handle timeout. called from reactor.
+
+  virtual int set_remote_address (ACE_Addr *address);
+  // set the remote address.
+
+  virtual ACE_Event_Handler* event_handler (void) = 0;
+  // get the underlying event handler. To be overridden by the derived clases.
+
+protected:
+  TAO_AV_Transport *transport_;
+  TAO_AV_Callback *callback_;
+  TAO_AV_Protocol_Object *protocol_object_;
+  long timer_id_;
+  ACE_Reactor *reactor_;
+  void *timeout_arg_;
+};
 
+//  Transports
 class TAO_ORBSVCS_Export TAO_AV_Transport
 {
   // TITLE
@@ -82,130 +127,10 @@ public:
 
 };
 
-class TAO_AV_TCP_Flow_Handler;
-
-class TAO_AV_TCP_Transport
-  :public TAO_AV_Transport
-{
-  // = TITLE
-  //     A transport abstraction for socket streams.
-  //
-  // = DESCRIPTION
-  //     Uses the ACE_SOCK_Stream to send the data.
-public:
-  TAO_AV_TCP_Transport (void);
-
-  TAO_AV_TCP_Transport (TAO_AV_TCP_Flow_Handler *handler);
-
-  virtual ~TAO_AV_TCP_Transport (void);
-
-  virtual int open (ACE_Addr *address);
-
-  virtual int close (void);
-
-  virtual int mtu (void);
-
-  virtual ACE_Addr *get_peer_addr (void);
-
-  virtual ssize_t send (const ACE_Message_Block *mblk,
-                        ACE_Time_Value *s = 0);
-  // Write the complete Message_Block chain to the connection.
-
-  virtual ssize_t send (const char *buf,
-                        size_t len,
-                        ACE_Time_Value *s = 0);
-  // Write the contents of the buffer of length len to the connection.
-
-  virtual ssize_t send (const iovec *iov,
-                        int iovcnt,
-                        ACE_Time_Value *s = 0);
-  // Write the contents of iovcnt iovec's to the connection.
-
-  virtual ssize_t recv (char *buf,
-                        size_t len,
-                        ACE_Time_Value *s = 0);
-  // Read len bytes from into buf.
-
-  virtual ssize_t recv (char *buf,
-                        size_t len,
-                        int flags,
-                        ACE_Time_Value *s = 0);
-  // Read len bytes from into buf using flags.
-
-  virtual ssize_t recv (iovec *iov,
-                        int iovcnt,
-                        ACE_Time_Value *s = 0);
-  //  Read received data into the iovec buffers.
-protected:
-  TAO_AV_TCP_Flow_Handler *handler_;
-};
-
-class TAO_AV_UDP_Flow_Handler;
-
-class TAO_AV_UDP_Transport
-  :public TAO_AV_Transport
-{
-  // = TITLE
-  //     A transport abstraction for udp sockets.
-  //
-  // = DESCRIPTION
-  //     Uses the ACE_SOCK_Dgram to send the data.
-public:
-  TAO_AV_UDP_Transport (void);
-
-  TAO_AV_UDP_Transport (TAO_AV_UDP_Flow_Handler *handler);
-
-  virtual  ~TAO_AV_UDP_Transport (void);
-  virtual int open (ACE_Addr *addr);
-
-  virtual int close (void);
-
-  virtual int mtu (void);
-
-  virtual ACE_Addr *get_peer_addr (void);
-
-  virtual int set_remote_address (const ACE_INET_Addr &address);
-
-  virtual ssize_t send (const ACE_Message_Block *mblk,
-                        ACE_Time_Value *s = 0);
-  // Write the complete Message_Block chain to the connection.
-
-  virtual ssize_t send (const char *buf,
-                        size_t len,
-                        ACE_Time_Value *s = 0);
-  // Write the contents of the buffer of length len to the connection.
-
-  virtual ssize_t send (const iovec *iov,
-                        int iovcnt,
-                        ACE_Time_Value *s = 0);
-  // Write the contents of iovcnt iovec's to the connection.
-
-  virtual ssize_t recv (char *buf,
-                        size_t len,
-                        ACE_Time_Value *s = 0);
-  // Read len bytes from into buf.
-
-  virtual ssize_t recv (char *buf,
-                        size_t len,
-                        int flags,
-                        ACE_Time_Value *s = 0);
-  // Read len bytes from into buf using flags.
-
-  virtual ssize_t recv (iovec *iov,
-                        int iovcnt,
-                        ACE_Time_Value *s = 0);
-  //  Read received data into the iovec buffers.
-protected:
-  TAO_AV_UDP_Flow_Handler *handler_;
-  ACE_Addr *addr_;
-  ACE_INET_Addr peer_addr_;
-};
-
 class TAO_Base_StreamEndPoint;
 class TAO_AV_Core;
 class TAO_FlowSpec_Entry;
 
-// Acceptors
 class TAO_AV_Acceptor
 {
 public:
@@ -213,10 +138,14 @@ public:
   virtual ~TAO_AV_Acceptor (void);
   virtual int open (TAO_Base_StreamEndPoint *endpoint,
                     TAO_AV_Core *av_core,
-                    TAO_FlowSpec_Entry *entry) = 0;
+                    TAO_FlowSpec_Entry *entry,
+                    TAO_AV_Flow_Protocol_Factory *factory) = 0;
+
   virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
                             TAO_AV_Core *av_core,
-                            TAO_FlowSpec_Entry *entry) = 0;
+                            TAO_FlowSpec_Entry *entry,
+                            TAO_AV_Flow_Protocol_Factory *factory) = 0;
+
   const char *flowname ();
   virtual int close (void) = 0;
 protected:
@@ -225,101 +154,6 @@ protected:
   ACE_Addr *address_;
 };
 
-class TAO_AV_TCP_Acceptor;
-
-class TAO_AV_TCP_Base_Acceptor
-  :public ACE_Acceptor <TAO_AV_TCP_Flow_Handler,ACE_SOCK_ACCEPTOR>
-{
-public:
-  virtual int open (TAO_AV_TCP_Acceptor *acceptor,
-                    ACE_Reactor *reactor,
-                    const ACE_INET_Addr &local_addr,
-                    TAO_FlowSpec_Entry *entry);
-  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *& handler);
-protected:
-  TAO_AV_TCP_Acceptor *acceptor_;
-  ACE_Reactor *reactor_;
-  TAO_FlowSpec_Entry *entry_;
-};
-
-class TAO_AV_TCP_Acceptor
-  :public TAO_AV_Acceptor
-{
-public:
-  TAO_AV_TCP_Acceptor (void);
-  virtual ~TAO_AV_TCP_Acceptor (void);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core,
-                    TAO_FlowSpec_Entry *entry);
-  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core,
-                            TAO_FlowSpec_Entry *entry);
-  virtual int close (void);
-  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *&handler);
-protected:
-  TAO_AV_TCP_Base_Acceptor acceptor_;
-  TAO_FlowSpec_Entry *entry_;
-  TAO_Base_StreamEndPoint *endpoint_;
-};
-
-class TAO_AV_Flow_Handler;
-
-class TAO_AV_UDP_Acceptor;
-
-class TAO_ORBSVCS_Export TAO_AV_Dgram_Acceptor
-{
-public:
-  virtual int open (TAO_AV_UDP_Acceptor *acceptor,
-                    ACE_Reactor *reactor,
-                    ACE_Addr &address,
-                    TAO_AV_UDP_Flow_Handler *&handler);
-  virtual int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-  virtual int activate_svc_handler (TAO_AV_UDP_Flow_Handler *handler);
-protected:
-  ACE_Reactor *reactor_;
-  TAO_AV_UDP_Acceptor *acceptor_;
-};
-
-class TAO_AV_UDP_Connector;
-
-class TAO_ORBSVCS_Export TAO_AV_Dgram_Connector
-{
-public:
-  virtual int open (TAO_AV_UDP_Connector *connector,
-                    ACE_Reactor *reactor);
-
-  virtual int connect (TAO_AV_UDP_Flow_Handler *&handler,
-                       ACE_Addr &remote_addr,
-                       ACE_Addr &local_addr);
-  virtual int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-  virtual int activate_svc_handler (TAO_AV_UDP_Flow_Handler *handler);
-protected:
-  ACE_Reactor *reactor_;
-  TAO_AV_UDP_Connector *connector_;
-};
-
-class TAO_AV_UDP_Acceptor
-  :public TAO_AV_Acceptor
-{
-public:
-  TAO_AV_UDP_Acceptor (void);
-  virtual ~TAO_AV_UDP_Acceptor (void);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core,
-                    TAO_FlowSpec_Entry *entry);
-  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
-                            TAO_AV_Core *av_core,
-                            TAO_FlowSpec_Entry *entry);
-  virtual int close (void);
-  virtual int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-protected:
-  TAO_AV_Dgram_Acceptor acceptor_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  TAO_FlowSpec_Entry *entry_;
-  TAO_AV_UDP_Flow_Handler *handler_;
-};
-
-// Connectors
 class TAO_AV_Connector
 {
 public:
@@ -328,7 +162,8 @@ public:
   const char *flowname (void);
 
   virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core) = 0;
+                    TAO_AV_Core *av_core,
+                    TAO_AV_Flow_Protocol_Factory *factory) = 0;
 
   virtual int connect (TAO_FlowSpec_Entry *entry,
                        TAO_AV_Transport *&transport) = 0;
@@ -338,163 +173,6 @@ protected:
   ACE_CString flowname_;
 };
 
-class TAO_AV_TCP_Connector;
-
-class TAO_AV_TCP_Base_Connector
-  :public ACE_Connector <TAO_AV_TCP_Flow_Handler,ACE_SOCK_CONNECTOR>
-{
-public:
-  // To avoid warnings of open and connect hiding the base class functions these have to renamed.
-  int connector_open (TAO_AV_TCP_Connector *connector,
-                      ACE_Reactor *reactor);
-  int connector_connect (TAO_AV_TCP_Flow_Handler *&handler,
-                         const ACE_INET_Addr &remote_addr);
-  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *& handler);
-protected:
-  TAO_AV_TCP_Connector *connector_;
-  ACE_Reactor *reactor_;
-};
-
-class TAO_AV_TCP_Connector
-  :public TAO_AV_Connector
-{
-public:
-  TAO_AV_TCP_Connector (void);
-  virtual ~TAO_AV_TCP_Connector (void);
-
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core);
-
-  virtual int connect (TAO_FlowSpec_Entry *entry,
-                       TAO_AV_Transport *&transport);
-  virtual int close (void);
-  virtual int make_svc_handler (TAO_AV_TCP_Flow_Handler *&handler);
-protected:
-  TAO_AV_Core *av_core_;
-  TAO_AV_TCP_Base_Connector connector_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  TAO_FlowSpec_Entry *entry_;
-};
-
-class TAO_AV_UDP_Connector
-  :public TAO_AV_Connector
-{
-public:
-  TAO_AV_UDP_Connector (void);
-  ~TAO_AV_UDP_Connector (void);
-  virtual int open (TAO_Base_StreamEndPoint *endpoint,
-                    TAO_AV_Core *av_core);
-
-  virtual int connect (TAO_FlowSpec_Entry *entry,
-                       TAO_AV_Transport *&transport);
-  virtual int close (void);
-  virtual int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-protected:
-  TAO_AV_Dgram_Connector connector_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  TAO_AV_Core *av_core_;
-  TAO_FlowSpec_Entry *entry_;
-  TAO_AV_UDP_Flow_Handler *handler_;
-};
-
-// Protocol Factories
-class TAO_ORBSVCS_Export TAO_AV_Protocol_Factory
-// @@ Derive from Svc config.
-{
-public:
-  TAO_AV_Protocol_Factory (void);
-  virtual ~TAO_AV_Protocol_Factory (void);
-
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol) = 0;
-  virtual TAO_AV_Acceptor *make_acceptor (void) = 0;
-  virtual TAO_AV_Connector *make_connector (void) = 0;
-};
-
-class TAO_AV_TCP_Protocol_Factory
-  :public TAO_AV_Protocol_Factory
-{
-public:
-  TAO_AV_TCP_Protocol_Factory (void);
-  virtual ~TAO_AV_TCP_Protocol_Factory (void);
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  virtual TAO_AV_Connector *make_connector (void);
-
-};
-
-class TAO_AV_UDP_Protocol_Factory
-  :public TAO_AV_Protocol_Factory
-{
-public:
-  TAO_AV_UDP_Protocol_Factory (void);
-  virtual ~TAO_AV_UDP_Protocol_Factory (void);
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  virtual TAO_AV_Connector *make_connector (void);
-};
-
-// Forward declarations.
-class TAO_AV_Protocol_Object;
-class TAO_AV_Callback;
-
-class TAO_AV_Flow_Handler
-{
-public:
-  TAO_AV_Flow_Handler (TAO_AV_Callback *callback);
-  virtual int start (TAO_FlowSpec_Entry::Role role);
-  virtual int stop  (TAO_FlowSpec_Entry::Role role);
-  TAO_AV_Transport *transport (void);
-  TAO_AV_Protocol_Object* protocol_object (void);
-  void protocol_object (TAO_AV_Protocol_Object *protocol_object);
-  int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0);
-  virtual int set_remote_address (ACE_Addr *address);
-  virtual ACE_Event_Handler* event_handler (void) = 0;
-protected:
-  TAO_AV_Transport *transport_;
-  TAO_AV_Callback *callback_;
-  TAO_AV_Protocol_Object *protocol_object_;
-  long timer_id_;
-  ACE_Reactor *reactor_;
-  void *timeout_arg_;
-};
-
-class TAO_AV_TCP_Flow_Handler
-  :public virtual TAO_AV_Flow_Handler,
-   public ACE_Svc_Handler <ACE_SOCK_STREAM, ACE_NULL_SYNCH>
-{
-public:
-  TAO_AV_TCP_Flow_Handler (TAO_AV_Callback *callback = 0);
-  virtual TAO_AV_Transport *transport (void);
-  virtual int open (void * = 0);
-  virtual int handle_input (ACE_HANDLE fd);
-  virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0);
-  virtual ACE_Event_Handler* event_handler (void){ return this; }
-protected:
-  TAO_AV_Core *av_core_;
-};
-
-class TAO_AV_UDP_Flow_Handler
-  :public virtual TAO_AV_Flow_Handler,
-   public virtual ACE_Event_Handler
-{
-public:
-  TAO_AV_UDP_Flow_Handler (TAO_AV_Callback *callback);
-  //Ctor
-  ~TAO_AV_UDP_Flow_Handler (void);
-  // Dtor
-  int open (ACE_Addr &address);
-  virtual TAO_AV_Transport *transport (void);
-  virtual int set_remote_address (ACE_Addr *address);
-  virtual ACE_HANDLE get_handle (void) const;
-  virtual int handle_input (ACE_HANDLE fd);
-  virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0);
-  const ACE_SOCK_Dgram *get_socket (void) const;
-  virtual ACE_Event_Handler* event_handler (void){ return this; }
-protected:
-  TAO_AV_Core *av_core_;
-  ACE_INET_Addr peer_addr_;
-  ACE_SOCK_Dgram sock_dgram_;
-};
 
 typedef ACE_Unbounded_Set<TAO_AV_Connector*> TAO_AV_ConnectorSet;
 typedef ACE_Unbounded_Set_Iterator<TAO_AV_Connector*> TAO_AV_ConnectorSetItor;
diff --git a/TAO/orbsvcs/orbsvcs/AV/Transport.i b/TAO/orbsvcs/orbsvcs/AV/Transport.i
index a98d961c54e..68db1bcf5f0 100644
--- a/TAO/orbsvcs/orbsvcs/AV/Transport.i
+++ b/TAO/orbsvcs/orbsvcs/AV/Transport.i
@@ -62,38 +62,69 @@ TAO_AV_Core::acceptor_registry (void)
 }
 
 ACE_INLINE
-TAO_AV_ProtocolFactorySet *
-TAO_AV_Core::protocol_factories (void)
+TAO_AV_TransportFactorySet *
+TAO_AV_Core::transport_factories (void)
 {
-  return &this->protocol_factories_;
+  return &this->transport_factories_;
+}
+
+ACE_INLINE
+TAO_AV_Flow_ProtocolFactorySet*
+TAO_AV_Core::flow_protocol_factories (void)
+{
+  return &this->flow_protocol_factories_;
 }
 
 //------------------------------------------------------------
-// TAO_AV_Protocol_Item
+// TAO_AV_Transport_Item
 //------------------------------------------------------------
 ACE_INLINE
 const ACE_CString &
-TAO_AV_Protocol_Item::protocol_name (void)
+TAO_AV_Transport_Item::name (void)
 {
   return this->name_;
 }
 
 ACE_INLINE
-TAO_AV_Protocol_Factory *
-TAO_AV_Protocol_Item::factory (void)
+TAO_AV_Transport_Factory *
+TAO_AV_Transport_Item::factory (void)
 {
   return this->factory_;
 }
 
 ACE_INLINE
 void
-TAO_AV_Protocol_Item::factory (TAO_AV_Protocol_Factory *factory)
+TAO_AV_Transport_Item::factory (TAO_AV_Transport_Factory *factory)
 {
   this->factory_ = factory;
 }
 
 
 //------------------------------------------------------------
+// TAO_AV_Flow_Protocol_Item
+//------------------------------------------------------------
+ACE_INLINE
+const ACE_CString &
+TAO_AV_Flow_Protocol_Item::name (void)
+{
+  return this->name_;
+}
+
+ACE_INLINE
+TAO_AV_Flow_Protocol_Factory *
+TAO_AV_Flow_Protocol_Item::factory (void)
+{
+  return this->factory_;
+}
+
+ACE_INLINE
+void
+TAO_AV_Flow_Protocol_Item::factory (TAO_AV_Flow_Protocol_Factory *factory)
+{
+  this->factory_ = factory;
+}
+
+//------------------------------------------------------------
 // TAO_AV_Connector_Registry
 //------------------------------------------------------------
 
@@ -128,23 +159,6 @@ TAO_AV_Acceptor_Registry::end (void)
   return this->acceptors_.end ();
 }
 
-//----------------------------------------------------------------------
-// TAO_AV_UDP_Flow_Handler
-//----------------------------------------------------------------------
-ACE_INLINE
-const ACE_SOCK_Dgram *
-TAO_AV_UDP_Flow_Handler::get_socket (void) const
-{
-  return &this->sock_dgram_;
-}
-
-ACE_INLINE
-int
-TAO_AV_UDP_Flow_Handler::open (ACE_Addr &address)
-{
-  return this->sock_dgram_.open (address);
-}
-
 //------------------------------------------------------------
 // TAO_AV_Acceptor
 //------------------------------------------------------------
diff --git a/TAO/orbsvcs/orbsvcs/AV/UDP.cpp b/TAO/orbsvcs/orbsvcs/AV/UDP.cpp
new file mode 100644
index 00000000000..c60fc0bb97e
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/UDP.cpp
@@ -0,0 +1,733 @@
+// $Id$
+
+#include "UDP.h"
+#include "AVStreams_i.h"
+#include "MCast.h"
+
+#if !defined (__ACE_INLINE__)
+#include "UDP.i"
+#endif /* __ACE_INLINE__ */
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Flow_Handler
+//------------------------------------------------------------
+
+TAO_AV_UDP_Flow_Handler::TAO_AV_UDP_Flow_Handler (void)
+{
+  ACE_NEW (this->transport_,
+           TAO_AV_UDP_Transport (this));
+}
+
+TAO_AV_UDP_Flow_Handler::~TAO_AV_UDP_Flow_Handler (void)
+{
+  delete this->transport_;
+}
+
+TAO_AV_Transport *
+TAO_AV_UDP_Flow_Handler::transport (void)
+{
+  return this->transport_;
+}
+
+int
+TAO_AV_UDP_Flow_Handler::handle_input (ACE_HANDLE /*fd*/)
+{
+  this->protocol_object_->handle_input ();
+  return 0;
+}
+
+int
+TAO_AV_UDP_Flow_Handler::handle_timeout (const ACE_Time_Value &tv, 
+                                               const void *arg)
+{
+  return TAO_AV_Flow_Handler::handle_timeout (tv,arg);
+}
+
+int
+TAO_AV_UDP_Flow_Handler::set_remote_address (ACE_Addr *address)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Flow_Handler::set_remote_address\n"));
+  ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr*,address);
+  this->peer_addr_ = *inet_addr;
+  TAO_AV_UDP_Transport *transport = ACE_dynamic_cast (TAO_AV_UDP_Transport*,this->transport_);
+  return transport->set_remote_address (*inet_addr);
+}
+
+
+ACE_HANDLE
+TAO_AV_UDP_Flow_Handler::get_handle (void) const
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Flow_Handler::get_handle:%d\n",this->sock_dgram_.get_handle ()));
+  return this->sock_dgram_.get_handle () ;
+}
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Transport
+//------------------------------------------------------------
+
+TAO_AV_UDP_Transport::TAO_AV_UDP_Transport (void)
+  :handler_ (0)
+{
+}
+
+TAO_AV_UDP_Transport::TAO_AV_UDP_Transport (TAO_AV_UDP_Flow_Handler *handler)
+  :handler_ (handler),
+   addr_ (0)
+{
+}
+
+TAO_AV_UDP_Transport::~TAO_AV_UDP_Transport (void)
+{
+}
+
+int
+TAO_AV_UDP_Transport::set_remote_address (const ACE_INET_Addr &address)
+{
+  this->peer_addr_ = address;
+  return 0;
+}
+
+int
+TAO_AV_UDP_Transport::open (ACE_Addr */*address*/)
+{
+  return 0;
+}
+
+int
+TAO_AV_UDP_Transport::close (void)
+{
+  return 0;
+}
+
+int
+TAO_AV_UDP_Transport::mtu (void)
+{
+  return ACE_MAX_DGRAM_SIZE;
+}
+
+ACE_Addr*
+TAO_AV_UDP_Transport::get_peer_addr (void)
+{
+  return &this->peer_addr_;
+}
+
+ssize_t
+TAO_AV_UDP_Transport::send (const ACE_Message_Block *mblk, ACE_Time_Value *)
+{
+  // For the most part this was copied from GIOP::send_request and
+  // friends.
+
+  iovec iov[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  = 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 IOV_MAX to that limit.
+          if (iovcnt == IOV_MAX)
+            {
+              n = this->handler_->get_socket ()->send ((const iovec *) iov,
+                                                        iovcnt,
+                                                        this->peer_addr_);
+
+              if (n < 1)
+                return n;
+
+              nbytes += n;
+              iovcnt = 0;
+            }
+        }
+    }
+
+  // Check for remaining buffers to be sent!
+  if (iovcnt != 0)
+    {
+      n = this->handler_->get_socket ()->send ((const iovec *) iov,
+                                               iovcnt,
+                                               this->peer_addr_);
+
+      if (n < 1)
+        return n;
+
+      nbytes += n;
+    }
+
+  return nbytes;
+}
+
+ssize_t
+TAO_AV_UDP_Transport::send (const char *buf,
+                            size_t len,
+                            ACE_Time_Value *)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Transport::send "));
+  char addr [BUFSIZ];
+  this->peer_addr_.addr_to_string (addr,BUFSIZ);
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"to %s\n",addr));
+
+  return this->handler_->get_socket ()->send (buf, len,this->peer_addr_);
+}
+
+ssize_t
+TAO_AV_UDP_Transport::send (const iovec *iov,
+                          int iovcnt,
+                          ACE_Time_Value *)
+{
+  return this->handler_->get_socket ()->send ((const iovec *) iov,
+                                              iovcnt,
+                                              this->peer_addr_);
+
+}
+
+ssize_t
+TAO_AV_UDP_Transport::recv (char *buf,
+                            size_t len,
+                            ACE_Time_Value *)
+{
+  return this->handler_->get_socket ()->recv (buf, len,this->peer_addr_);
+}
+
+ssize_t
+TAO_AV_UDP_Transport::recv (char *buf,
+                            size_t len,
+                            int flags,
+                            ACE_Time_Value *timeout)
+{
+  return this->handler_->get_socket ()->recv (buf,
+                                              len,
+                                              this->peer_addr_,
+                                              flags,
+                                              timeout);
+}
+
+ssize_t
+TAO_AV_UDP_Transport::recv (iovec *iov,
+                            int /*iovcnt*/,
+                            ACE_Time_Value *timeout)
+{
+  return handler_->get_socket ()->recv (iov,this->peer_addr_,0,timeout);
+}
+
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Acceptor
+//------------------------------------------------------------
+
+TAO_AV_UDP_Acceptor::TAO_AV_UDP_Acceptor (void)
+{
+}
+
+TAO_AV_UDP_Acceptor::~TAO_AV_UDP_Acceptor (void)
+{
+}
+
+int
+TAO_AV_UDP_Acceptor::activate_svc_handler (TAO_AV_Flow_Handler *handler)
+{
+  ACE_Event_Handler *event_handler = handler->event_handler ();
+  int result = this->av_core_->reactor ()->register_handler (event_handler,
+                                                             ACE_Event_Handler::READ_MASK);
+  return result;
+}
+
+int
+TAO_AV_UDP_Acceptor::open (TAO_Base_StreamEndPoint *endpoint,
+                           TAO_AV_Core *av_core,
+                           TAO_FlowSpec_Entry *entry,
+                           TAO_AV_Flow_Protocol_Factory *factory)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Acceptor::open "));
+  this->av_core_ = av_core;
+  this->endpoint_ = endpoint;
+  this->entry_ = entry;
+  this->flow_protocol_factory_ = factory;
+  this->flowname_ = entry->flowname ();
+  ACE_INET_Addr *inet_addr = (ACE_INET_Addr *) entry->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_UDP_Acceptor::open: %s",
+                                       buf));
+  int result = this->open_i (inet_addr);
+  if (result < 0)
+    return result;
+  return 0;
+}
+
+int
+TAO_AV_UDP_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
+                                   TAO_AV_Core *av_core,
+                                   TAO_FlowSpec_Entry *entry,
+                                   TAO_AV_Flow_Protocol_Factory *factory)
+{
+  this->av_core_ = av_core;
+  this->endpoint_ = endpoint;
+  this->entry_ = entry;
+  this->flow_protocol_factory_ = factory;
+  this->flowname_ = entry->flowname ();
+  ACE_INET_Addr *address;
+  ACE_NEW_RETURN (address,
+                  ACE_INET_Addr ("0"),
+                  -1);
+  int result = this->open_i (address);
+  if (result < 0)
+    return result;
+  return 0;
+}
+
+int
+TAO_AV_UDP_Acceptor::open_i (ACE_INET_Addr *inet_addr)
+{
+  int result = -1;
+  //  TAO_AV_Callback *callback = 0;  
+//   this->endpoint_->get_callback (this->flowname_.c_str (),
+//                                  callback);
+  ACE_INET_Addr *local_addr;
+  TAO_AV_Flow_Handler *flow_handler = 0;
+  if (this->entry_->is_multicast ())
+    {
+      TAO_AV_UDP_MCast_Flow_Handler *handler;
+      ACE_NEW_RETURN (handler,
+                      TAO_AV_UDP_MCast_Flow_Handler,
+                      -1);
+      flow_handler = handler;
+      result = handler->get_mcast_socket ()->subscribe (*inet_addr);
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_MCast_connector::subscribe failed\n"),-1);
+      // Now disable Multicast loopback.
+      // @@Should we make this a policy?
+      if (handler->get_mcast_socket ()->set_option (IP_MULTICAST_LOOP,
+                                                    0) < 0)
+        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Acceptor::multicast loop disable failed\n"));
+      // @@ This should also be policies.
+      int bufsize = 80 * 1024;
+      if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
+                                                              SO_RCVBUF,
+                                                              (char *)&bufsize,
+                                                              sizeof(bufsize)) < 0)
+        {
+          bufsize = 32 * 1024;
+          if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
+                                                                  SO_RCVBUF,
+                                                                  (char *)&bufsize,
+                                                                  sizeof(bufsize)) < 0)
+            perror("SO_RCVBUF");
+        }
+      ACE_NEW_RETURN (local_addr,
+                      ACE_INET_Addr (*inet_addr),
+                      -1);
+    }
+  else
+    {
+      TAO_AV_UDP_Flow_Handler *handler;
+      ACE_NEW_RETURN (handler,
+                      TAO_AV_UDP_Flow_Handler,
+                      -1);
+      flow_handler = handler;
+      int result = handler->open (*inet_addr);
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Acceptor::handler_open failed\n"),-1);
+      // set the socket buffer sizes to 64k.
+      int sndbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
+      int rcvbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
+
+      if (handler->get_socket ()->set_option (SOL_SOCKET,
+                                              SO_SNDBUF,
+                                              (void *) &sndbufsize,
+                                              sizeof (sndbufsize)) == -1
+          && errno != ENOTSUP)
+        return 0;
+
+      else if (handler->get_socket ()->set_option (SOL_SOCKET,
+                                                   SO_RCVBUF,
+                                                   (void *) &rcvbufsize,
+                                                   sizeof (rcvbufsize)) == -1
+               && errno != ENOTSUP)
+        return 0;
+
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"SOCK_Dgram::open failed\n"),-1);
+      ACE_NEW_RETURN (local_addr,
+                      ACE_INET_Addr,
+                      -1);
+      result = handler->get_socket ()->get_local_addr (*local_addr);
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Connector::open: get_local_addr failed\n"),result);
+      local_addr->set (local_addr->get_port_number (),
+                       local_addr->get_host_name ());
+    }
+  TAO_AV_Protocol_Object *object =
+    this->flow_protocol_factory_->make_protocol_object (this->entry_,
+                                                        this->endpoint_,
+                                                        flow_handler,
+                                                        flow_handler->transport ());
+  flow_handler->protocol_object (object);
+  //  callback->protocol_object (object);
+//   this->endpoint_->set_protocol_object (this->flowname_.c_str (),
+//                                         object);
+  this->endpoint_->set_handler (this->flowname_.c_str (),flow_handler);
+  this->entry_->protocol_object (object);
+
+  char buf[BUFSIZ];
+  local_addr->addr_to_string (buf,BUFSIZ);
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_CONNECTOR::connect:%s \n",buf));
+  this->entry_->set_local_addr (local_addr);
+  this->entry_->handler (flow_handler);
+  // call activate svc handler.
+  return this->activate_svc_handler (flow_handler);
+}
+
+int
+TAO_AV_UDP_Acceptor::close (void)
+{
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Connector
+//------------------------------------------------------------
+TAO_AV_UDP_Connector::TAO_AV_UDP_Connector (void)
+{
+}
+
+TAO_AV_UDP_Connector::~TAO_AV_UDP_Connector (void)
+{
+}
+
+int
+TAO_AV_UDP_Connector::open (TAO_Base_StreamEndPoint *endpoint,
+                            TAO_AV_Core *av_core,
+                            TAO_AV_Flow_Protocol_Factory *factory)
+
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Connector::open "));
+  this->endpoint_ = endpoint;
+  this->av_core_ = av_core;
+  this->flow_protocol_factory_ = factory;
+  return 0;
+}
+
+int
+TAO_AV_UDP_Connector::connect (TAO_FlowSpec_Entry *entry,
+                               TAO_AV_Transport *&transport)
+{
+  int result = -1;
+  this->entry_ = entry;
+  this->flowname_ = entry->flowname ();
+  ACE_Addr *remote_addr = entry->address ();
+  ACE_INET_Addr *local_addr;
+  ACE_NEW_RETURN (local_addr,
+                  ACE_INET_Addr ("0"),
+                  -1);
+
+  //  TAO_AV_Callback *callback = 0;  
+//   this->endpoint_->get_callback (this->flowname_.c_str (),
+//                                  callback);
+  ACE_INET_Addr *inet_addr = ACE_dynamic_cast (ACE_INET_Addr*,entry->address ());
+  TAO_AV_Flow_Handler *flow_handler = 0;
+  if (entry->is_multicast ())
+    {
+      TAO_AV_UDP_MCast_Flow_Handler *handler;
+      ACE_NEW_RETURN (handler,
+                      //                      TAO_AV_UDP_MCast_Flow_Handler (callback),
+                      TAO_AV_UDP_MCast_Flow_Handler,
+                      -1);
+      flow_handler = handler;
+      result = handler->get_mcast_socket ()->subscribe (*inet_addr);
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_MCast_connector::open failed\n"),-1);
+      // Now disable Multicast loopback.
+      // @@Should we make this a policy?
+      if (handler->get_mcast_socket ()->set_option (IP_MULTICAST_LOOP,
+                                                    0) < 0)
+        if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_MCast_Acceptor::multicast loop disable failed\n"));
+      // @@ This should also be policies.
+      int bufsize = 80 * 1024;
+      if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
+                                                              SO_RCVBUF,
+                                                              (char *)&bufsize,
+                                                              sizeof(bufsize)) < 0)
+        {
+          bufsize = 32 * 1024;
+          if (handler->get_mcast_socket ()->ACE_SOCK::set_option (SOL_SOCKET,
+                                                                  SO_RCVBUF,
+                                                                  (char *)&bufsize,
+                                                                  sizeof(bufsize)) < 0)
+            perror("SO_RCVBUF");
+        }
+      ACE_NEW_RETURN (local_addr,
+                      ACE_INET_Addr (*inet_addr),
+                      -1);
+    }
+  else
+    {
+      TAO_AV_UDP_Flow_Handler *handler;
+      ACE_NEW_RETURN (handler,
+                      //                      TAO_AV_UDP_Flow_Handler (callback),
+                      TAO_AV_UDP_Flow_Handler,
+                      -1);
+      flow_handler = handler;
+      result = handler->open (*local_addr);
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"handler::open failed\n"),-1);
+      // set the socket buffer sizes to 64k.
+      int sndbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
+      int rcvbufsize = ACE_DEFAULT_MAX_SOCKET_BUFSIZ;
+
+      if (handler->get_socket ()->set_option (SOL_SOCKET,
+                                              SO_SNDBUF,
+                                              (void *) &sndbufsize,
+                                              sizeof (sndbufsize)) == -1
+          && errno != ENOTSUP)
+        return 0;
+
+      else if (handler->get_socket ()->set_option (SOL_SOCKET,
+                                                   SO_RCVBUF,
+                                                   (void *) &rcvbufsize,
+                                                   sizeof (rcvbufsize)) == -1
+               && errno != ENOTSUP)
+        return 0;
+
+      handler->set_remote_address  (inet_addr);
+      ACE_NEW_RETURN (local_addr,
+                      ACE_INET_Addr,
+                      -1);
+      result = handler->get_socket ()->get_local_addr (*local_addr);
+      if (result < 0)
+        ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_Dgram_Connector::open: get_local_addr failed\n"),result);
+      local_addr->set (local_addr->get_port_number (),
+                       local_addr->get_host_name ());
+    }
+  TAO_AV_Protocol_Object *object =
+    this->flow_protocol_factory_->make_protocol_object (this->entry_,
+                                                        this->endpoint_,
+                                                        flow_handler,
+                                                        flow_handler->transport ());
+  flow_handler->protocol_object (object);
+  //  callback->protocol_object (object);
+//   this->endpoint_->set_protocol_object (this->flowname_.c_str (),
+//                                         object);
+  this->endpoint_->set_handler (this->flowname_.c_str (),flow_handler);
+  this->entry_->protocol_object (object);
+
+  char buf[BUFSIZ];
+  local_addr->addr_to_string (buf,BUFSIZ);
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_CONNECTOR::connect:%s \n",buf));
+  entry->set_local_addr (local_addr);
+  entry->handler (flow_handler);
+  transport = flow_handler->transport ();
+  // call activate svc handler.
+  return this->activate_svc_handler (flow_handler);
+}
+
+int
+TAO_AV_UDP_Connector::activate_svc_handler (TAO_AV_Flow_Handler *handler)
+{
+  ACE_Event_Handler *event_handler = handler->event_handler ();
+  int result = this->av_core_->reactor ()->register_handler (event_handler,
+                                                             ACE_Event_Handler::READ_MASK);
+  return result;
+}
+
+int
+TAO_AV_UDP_Connector::close (void)
+{
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Protocol_Factory
+//------------------------------------------------------------
+
+TAO_AV_UDP_Factory::TAO_AV_UDP_Factory (void)
+{
+}
+
+TAO_AV_UDP_Factory::~TAO_AV_UDP_Factory (void)
+{
+}
+
+int
+TAO_AV_UDP_Factory::match_protocol (const char *protocol_string)
+{
+  if (ACE_OS::strstr (protocol_string,"UDP") != 0)
+    return 1;
+  return 0;
+}
+
+TAO_AV_Acceptor*
+TAO_AV_UDP_Factory::make_acceptor (void)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Factory::make_acceptor "));
+  TAO_AV_Acceptor *acceptor = 0;
+  ACE_NEW_RETURN (acceptor,
+                  TAO_AV_UDP_Acceptor,
+                  0);
+  return acceptor;
+}
+
+TAO_AV_Connector*
+TAO_AV_UDP_Factory::make_connector (void)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Factory::make_connector "));
+  TAO_AV_Connector *connector = 0;
+  ACE_NEW_RETURN (connector,
+                  TAO_AV_UDP_Connector,
+                  0);
+  return connector;
+}
+
+int
+TAO_AV_UDP_Factory::init (int /* argc */,
+                          char * /* argv */ [])
+{
+  return 0;
+}
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Object
+//------------------------------------------------------------
+
+int
+TAO_AV_UDP_Object::handle_input (void)
+{
+  size_t size = 2*this->transport_->mtu ();
+  ACE_Message_Block *frame = 0;
+  ACE_NEW_RETURN (frame,
+                  ACE_Message_Block (size),
+                  -1);
+  int n = this->transport_->recv (frame->rd_ptr (),
+                                  frame->size ());
+  if (n == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Flow_Handler::handle_input recv failed\n"),-1);
+  if (n == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,"TAO_AV_UDP_Flow_Handler::handle_input connection closed\n"),-1);
+  frame->wr_ptr (n);
+
+  return this->callback_->receive_frame (frame);
+}
+
+int
+TAO_AV_UDP_Object::send_frame (ACE_Message_Block *frame,
+                               TAO_AV_frame_info *frame_info)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_AV_UDP_Object::send_frame\n"));
+  int result = this->transport_->send (frame);
+  if (result < 0)
+    return result;
+  return 0;
+}
+
+int 
+TAO_AV_UDP_Object::send_frame (const iovec *iov,
+                               int iovcnt,
+                               TAO_AV_frame_info *frame_info)
+{
+  return this->transport_->send (iov,iovcnt);
+}
+
+TAO_AV_UDP_Object::TAO_AV_UDP_Object (TAO_AV_Callback *callback,
+                                      TAO_AV_Transport *transport)
+  :TAO_AV_Protocol_Object (callback,transport)
+{
+}
+
+TAO_AV_UDP_Object::~TAO_AV_UDP_Object (void)
+{
+  //no-op
+}
+
+int
+TAO_AV_UDP_Object::destroy (void)
+{
+  this->callback_->handle_destroy ();
+  return 0;
+}
+
+
+//------------------------------------------------------------
+// TAO_AV_UDP_Flow_Factory
+//------------------------------------------------------------
+TAO_AV_UDP_Flow_Factory::TAO_AV_UDP_Flow_Factory (void)
+{
+}
+
+TAO_AV_UDP_Flow_Factory::~TAO_AV_UDP_Flow_Factory (void)
+{
+}
+
+int
+TAO_AV_UDP_Flow_Factory::init (int /* argc */,
+                               char * /* argv */ [])
+{
+  return 0;
+}
+
+int
+TAO_AV_UDP_Flow_Factory::match_protocol (const char *flow_string)
+{
+  if (ACE_OS::strcasecmp (flow_string,"UDP") == 0)
+    return 1;
+  return 0;
+}
+
+TAO_AV_Protocol_Object*
+TAO_AV_UDP_Flow_Factory::make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                               TAO_Base_StreamEndPoint *endpoint,
+                                               TAO_AV_Flow_Handler *handler,
+                                               TAO_AV_Transport *transport)
+{
+  TAO_AV_Callback *callback = 0;
+  endpoint->get_callback (entry->flowname (),
+                          callback);
+
+
+  TAO_AV_UDP_Object *object = 0;
+  ACE_NEW_RETURN (object,
+                  TAO_AV_UDP_Object (callback,
+                                     transport),
+                  0);
+  callback->open (object,
+                  handler);
+  endpoint->set_protocol_object (entry->flowname (),
+                                 object);
+  return object;
+}
+
+ACE_FACTORY_DEFINE (AV, TAO_AV_UDP_Flow_Factory)
+ACE_STATIC_SVC_DEFINE (TAO_AV_UDP_Flow_Factory,
+                       ASYS_TEXT ("UDP_Flow_Factory"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_AV_UDP_Flow_Factory),
+                       ACE_Service_Type::DELETE_THIS |
+                       ACE_Service_Type::DELETE_OBJ,
+                       0)
+
+ACE_FACTORY_DEFINE (AV, TAO_AV_UDP_Factory)
+
+ACE_STATIC_SVC_DEFINE (TAO_AV_UDP_Factory,
+                       ASYS_TEXT ("UDP_Factory"),
+                       ACE_SVC_OBJ_T,
+                       &ACE_SVC_NAME (TAO_AV_UDP_Factory),
+                       ACE_Service_Type::DELETE_THIS |
+                       ACE_Service_Type::DELETE_OBJ,
+                       0)
+
+
diff --git a/TAO/orbsvcs/orbsvcs/AV/UDP.h b/TAO/orbsvcs/orbsvcs/AV/UDP.h
new file mode 100644
index 00000000000..c009779e651
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/UDP.h
@@ -0,0 +1,215 @@
+/* -*- C++ -*- */
+
+// $Id$
+// ============================================================================
+//
+// = LIBRARY
+//   ORBSVCS AVStreams
+//
+// = FILENAME
+//   UDP.h
+//
+// = AUTHOR
+//    Nagarajan Surendran <naga@cs.wustl.edu>
+//
+//
+// ============================================================================
+
+#ifndef TAO_AV_UDP_H
+#define TAO_AV_UDP_H
+
+#include "ace/OS.h"
+#include "Protocol_Factory.h"
+
+class TAO_ORBSVCS_Export TAO_AV_UDP_Factory : public TAO_AV_Transport_Factory
+{
+public:
+  TAO_AV_UDP_Factory (void);
+  virtual ~TAO_AV_UDP_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *protocol_string);
+  virtual TAO_AV_Acceptor *make_acceptor (void);
+  virtual TAO_AV_Connector *make_connector (void);
+};
+
+class TAO_AV_UDP_Flow_Handler;
+
+class TAO_AV_UDP_Transport
+  :public TAO_AV_Transport
+{
+  // = TITLE
+  //     A transport abstraction for udp sockets.
+  //
+  // = DESCRIPTION
+  //     Uses the ACE_SOCK_Dgram to send the data.
+public:
+  TAO_AV_UDP_Transport (void);
+
+  TAO_AV_UDP_Transport (TAO_AV_UDP_Flow_Handler *handler);
+
+  virtual  ~TAO_AV_UDP_Transport (void);
+  virtual int open (ACE_Addr *addr);
+
+  virtual int close (void);
+
+  virtual int mtu (void);
+
+  virtual ACE_Addr *get_peer_addr (void);
+
+  virtual int set_remote_address (const ACE_INET_Addr &address);
+
+  virtual ssize_t send (const ACE_Message_Block *mblk,
+                        ACE_Time_Value *s = 0);
+  // Write the complete Message_Block chain to the connection.
+
+  virtual ssize_t send (const char *buf,
+                        size_t len,
+                        ACE_Time_Value *s = 0);
+  // Write the contents of the buffer of length len to the connection.
+
+  virtual ssize_t send (const iovec *iov,
+                        int iovcnt,
+                        ACE_Time_Value *s = 0);
+  // Write the contents of iovcnt iovec's to the connection.
+
+  virtual ssize_t recv (char *buf,
+                        size_t len,
+                        ACE_Time_Value *s = 0);
+  // Read len bytes from into buf.
+
+  virtual ssize_t recv (char *buf,
+                        size_t len,
+                        int flags,
+                        ACE_Time_Value *s = 0);
+  // Read len bytes from into buf using flags.
+
+  virtual ssize_t recv (iovec *iov,
+                        int iovcnt,
+                        ACE_Time_Value *s = 0);
+  //  Read received data into the iovec buffers.
+protected:
+  TAO_AV_UDP_Flow_Handler *handler_;
+  ACE_Addr *addr_;
+  ACE_INET_Addr peer_addr_;
+};
+
+class TAO_AV_UDP_Flow_Handler
+  :public virtual TAO_AV_Flow_Handler,
+   public virtual ACE_Event_Handler
+{
+public:
+  TAO_AV_UDP_Flow_Handler (void);
+  //Ctor
+  ~TAO_AV_UDP_Flow_Handler (void);
+  // Dtor
+  int open (ACE_Addr &address);
+  virtual TAO_AV_Transport *transport (void);
+  virtual int set_remote_address (ACE_Addr *address);
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE fd);
+  virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0);
+  const ACE_SOCK_Dgram *get_socket (void) const;
+  virtual ACE_Event_Handler* event_handler (void){ return this; }
+protected:
+  TAO_AV_Core *av_core_;
+  ACE_INET_Addr peer_addr_;
+  ACE_SOCK_Dgram sock_dgram_;
+};
+
+class TAO_AV_UDP_Acceptor
+  :public TAO_AV_Acceptor
+{
+public:
+  TAO_AV_UDP_Acceptor (void);
+  virtual ~TAO_AV_UDP_Acceptor (void);
+  virtual int open (TAO_Base_StreamEndPoint *endpoint,
+                    TAO_AV_Core *av_core,
+                    TAO_FlowSpec_Entry *entry,
+                    TAO_AV_Flow_Protocol_Factory *factory);
+
+  virtual int open_default (TAO_Base_StreamEndPoint *endpoint,
+                            TAO_AV_Core *av_core,
+                            TAO_FlowSpec_Entry *entry,
+                            TAO_AV_Flow_Protocol_Factory *factory);
+
+  virtual int open_i (ACE_INET_Addr *address);
+
+  virtual int close (void);
+  virtual int activate_svc_handler (TAO_AV_Flow_Handler *handler);
+protected:
+  TAO_Base_StreamEndPoint *endpoint_;
+  TAO_FlowSpec_Entry *entry_;
+  TAO_AV_Flow_Protocol_Factory *flow_protocol_factory_;
+};
+
+class TAO_AV_UDP_Connector
+  :public TAO_AV_Connector
+{
+public:
+  TAO_AV_UDP_Connector (void);
+  ~TAO_AV_UDP_Connector (void);
+  virtual int open (TAO_Base_StreamEndPoint *endpoint,
+                    TAO_AV_Core *av_core,
+                    TAO_AV_Flow_Protocol_Factory *factory);
+
+  virtual int connect (TAO_FlowSpec_Entry *entry,
+                       TAO_AV_Transport *&transport);
+  virtual int activate_svc_handler (TAO_AV_Flow_Handler *handler);
+  virtual int close (void);
+protected:
+  TAO_Base_StreamEndPoint *endpoint_;
+  TAO_AV_Core *av_core_;
+  TAO_FlowSpec_Entry *entry_;
+  TAO_AV_Flow_Protocol_Factory *flow_protocol_factory_;
+};
+
+class TAO_ORBSVCS_Export TAO_AV_UDP_Object  : public TAO_AV_Protocol_Object
+{
+public:
+  TAO_AV_UDP_Object (TAO_AV_Callback *callback,
+                     TAO_AV_Transport *transport = 0);
+
+  virtual ~TAO_AV_UDP_Object (void);
+  // Dtor
+
+  virtual int handle_input (void);
+
+  virtual int send_frame (ACE_Message_Block *frame,
+                          TAO_AV_frame_info *frame_info = 0);
+  // send a data frame.
+
+  virtual int send_frame (const iovec *iov,
+                          int iovcnt,
+                          TAO_AV_frame_info *frame_info = 0);
+
+  virtual int destroy (void);
+  // end the stream.
+};
+
+class TAO_AV_UDP_Flow_Factory : public TAO_AV_Flow_Protocol_Factory
+{
+public:
+  TAO_AV_UDP_Flow_Factory (void);
+  virtual ~TAO_AV_UDP_Flow_Factory (void);
+  virtual int init (int argc, char *argv[]);
+  // Initialization hook.
+  virtual int match_protocol (const char *flow_string);
+  TAO_AV_Protocol_Object* make_protocol_object (TAO_FlowSpec_Entry *entry,
+                                                TAO_Base_StreamEndPoint *endpoint,
+                                                TAO_AV_Flow_Handler *handler,
+                                                TAO_AV_Transport *transport);
+};
+
+ACE_STATIC_SVC_DECLARE (TAO_AV_UDP_Flow_Factory)
+ACE_FACTORY_DECLARE (TAO_ORBSVCS, TAO_AV_UDP_Flow_Factory)
+
+ACE_STATIC_SVC_DECLARE (TAO_AV_UDP_Factory)
+ACE_FACTORY_DECLARE (TAO_ORBSVCS, TAO_AV_UDP_Factory)
+
+
+#if defined(__ACE_INLINE__)
+#include "UDP.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* TAO_AV_UDP_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/UDP.i b/TAO/orbsvcs/orbsvcs/AV/UDP.i
new file mode 100644
index 00000000000..2406225e417
--- /dev/null
+++ b/TAO/orbsvcs/orbsvcs/AV/UDP.i
@@ -0,0 +1,20 @@
+/* -*- C++ -*- */
+
+// $Id$
+
+//----------------------------------------------------------------------
+// TAO_AV_UDP_Flow_Handler
+//----------------------------------------------------------------------
+ACE_INLINE
+const ACE_SOCK_Dgram *
+TAO_AV_UDP_Flow_Handler::get_socket (void) const
+{
+  return &this->sock_dgram_;
+}
+
+ACE_INLINE
+int
+TAO_AV_UDP_Flow_Handler::open (ACE_Addr &address)
+{
+  return this->sock_dgram_.open (address);
+}
diff --git a/TAO/orbsvcs/orbsvcs/AV/sfp.cpp b/TAO/orbsvcs/orbsvcs/AV/sfp.cpp
index 7e4e02f8067..571970953fd 100644
--- a/TAO/orbsvcs/orbsvcs/AV/sfp.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/sfp.cpp
@@ -988,391 +988,391 @@ TAO_SFP_Base::dump_buf (char *buffer,int size)
   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"\n========================================\n"));
 }
 
-//------------------------------------------------------------
-//TAO_SFP_UDP_Protocol_Factory
-//------------------------------------------------------------
-
-TAO_SFP_UDP_Protocol_Factory::TAO_SFP_UDP_Protocol_Factory (void)
-{
-}
-
-TAO_SFP_UDP_Protocol_Factory::~TAO_SFP_UDP_Protocol_Factory (void)
-{
-}
-
-TAO_AV_Acceptor *
-TAO_SFP_UDP_Protocol_Factory::make_acceptor (void)
-{
-  TAO_SFP_UDP_Acceptor *acceptor = 0;
-  ACE_NEW_RETURN (acceptor,
-                  TAO_SFP_UDP_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector *
-TAO_SFP_UDP_Protocol_Factory::make_connector (void)
-{
-  TAO_SFP_UDP_Connector *connector = 0;
-  ACE_NEW_RETURN (connector,
-                  TAO_SFP_UDP_Connector,
-                  0);
-  return connector;
-}
-
-int
-TAO_SFP_UDP_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_SFP_UDP);
-}
-
-//
-// TAO_SFP_UDP_Acceptor
-TAO_SFP_UDP_Acceptor::TAO_SFP_UDP_Acceptor (void)
-{
-}
-
-TAO_SFP_UDP_Acceptor::~TAO_SFP_UDP_Acceptor (void)
-{
-}
-
-int
-TAO_SFP_UDP_Acceptor::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
-{
-  // @@ We should actually look at the entry and find out if we're a
-  // sink or a source and create the appropriate handler
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Acceptor::make_svc_handler\n"));
-  TAO_SFP_BASE::instance ();
-  TAO_SFP_Object *object;
-  TAO_AV_Callback *callback;
-  this->endpoint_->get_callback (this->entry_->flowname (),callback);
-  ACE_NEW_RETURN (object,
-                  TAO_SFP_Object (callback),
-                  -1);
-  ACE_NEW_RETURN (handler,
-                  TAO_SFP_UDP_Sender_Handler (callback,
-                                              object),
-                  -1);
-  callback->transport (handler->transport ());
-  callback->protocol_object (object);
-  object->transport (handler->transport ());
-  this->endpoint_->set_protocol_object (this->entry_->flowname (),
-                                        object);
-  this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-  this->entry_->protocol_object (object);
-  return 0;
-}
-//------------------------------------------------------------
-// TAO_SFP_UDP_Connector
-//------------------------------------------------------------
-TAO_SFP_UDP_Connector::TAO_SFP_UDP_Connector (void)
-{
-}
-
-TAO_SFP_UDP_Connector::~TAO_SFP_UDP_Connector (void)
-{
-}
-
-int
-TAO_SFP_UDP_Connector::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Connector::make_svc_handler\n"));
-  TAO_SFP_BASE::instance ();
-  // @@ We should actually look at the entry and find out if we're a
-  // sink or a source and create the appropriate handler
-  TAO_AV_Callback *callback = 0;
-  this->endpoint_->get_callback (this->entry_->flowname (),
-                                 callback);
-  ACE_NEW_RETURN (handler,
-                  TAO_SFP_UDP_Receiver_Handler (callback),
-                  -1);
-  TAO_SFP_Object *object;
-  ACE_NEW_RETURN (object,
-                  TAO_SFP_Object (callback),
-                  -1);
-  callback->transport (handler->transport ());
-  callback->protocol_object (object);
-  object->transport (handler->transport ());
-  this->endpoint_->set_protocol_object (this->entry_->flowname (),
-                                        object);
-  this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-  this->entry_->protocol_object (object);
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_SFP_UDP_Sender_Handler
-//------------------------------------------------------------
-TAO_SFP_UDP_Sender_Handler::TAO_SFP_UDP_Sender_Handler (TAO_AV_Callback *callback,
-                                                        TAO_SFP_Object *object)
-  :TAO_AV_Flow_Handler (callback),
-   TAO_AV_UDP_Flow_Handler (callback),
-   sfp_object_ (object)
-{
-}
-
-int
-TAO_SFP_UDP_Sender_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  return -1;
-}
-
-int
-TAO_SFP_UDP_Sender_Handler::handle_close (ACE_HANDLE /*fd*/,
-                                          ACE_Reactor_Mask)
-{
-  return 0;
-}
-
-int
-TAO_SFP_UDP_Sender_Handler::start (TAO_FlowSpec_Entry::Role role)
-{
-  // @@once somehow we figure out that the stream is established we
-  // can start sending the frames.
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Sender_Handler::start\n"));
-  TAO_AV_Flow_Handler::start (role);
-  this->sfp_object_->start ();
-  return 0;
-}
-
-int
-TAO_SFP_UDP_Sender_Handler::stop (TAO_FlowSpec_Entry::Role role)
-{
-  TAO_AV_Flow_Handler::stop (role);
-  this->sfp_object_->stop ();
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_SFP_UDP_Receiver_Handler
-//------------------------------------------------------------
-TAO_SFP_UDP_Receiver_Handler::TAO_SFP_UDP_Receiver_Handler (TAO_AV_Callback *callback)
-  :TAO_AV_Flow_Handler (callback),
-   TAO_AV_UDP_Flow_Handler (callback)
-{
-}
-
-int
-TAO_SFP_UDP_Receiver_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Receiver_Handler::handle_input\n"));
-  // This is the entry point for receiving data.
-  TAO_AV_frame_info *frame_info = 0;
-  int result = TAO_SFP_Base::handle_input (this->transport_,
-                                           this->state_,
-                                           frame_info);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"ERROR in TAO_SFP_UDP_Receiver_Handler::handle_input"),result);
-  if (this->state_.frame_header_.message_type == flowProtocol::EndofStream_Msg)
-    this->callback_->handle_end_stream ();
-  if (this->state_.is_complete ())
-    {
-      this->callback_->receive_frame (this->state_.frame_block_,
-                                      frame_info);
-      this->state_.reset ();
-    }
-  return 0;
-}
-
-int
-TAO_SFP_UDP_Receiver_Handler::handle_close (ACE_HANDLE /*fd*/,
-                                            ACE_Reactor_Mask /*mask*/)
-{
-  return 0;
-}
-
-//------------------------------------------------------------
-//TAO_SFP_UDP_MCast_Protocol_Factory
-//------------------------------------------------------------
-
-TAO_SFP_UDP_MCast_Protocol_Factory::TAO_SFP_UDP_MCast_Protocol_Factory (void)
-{
-}
-
-TAO_SFP_UDP_MCast_Protocol_Factory::~TAO_SFP_UDP_MCast_Protocol_Factory (void)
-{
-}
-
-TAO_AV_Acceptor *
-TAO_SFP_UDP_MCast_Protocol_Factory::make_acceptor (void)
-{
-  TAO_SFP_UDP_MCast_Acceptor *acceptor = 0;
-  ACE_NEW_RETURN (acceptor,
-                  TAO_SFP_UDP_MCast_Acceptor,
-                  0);
-  return acceptor;
-}
-
-TAO_AV_Connector *
-TAO_SFP_UDP_MCast_Protocol_Factory::make_connector (void)
-{
-  TAO_SFP_UDP_MCast_Connector *connector = 0;
-  ACE_NEW_RETURN (connector,
-                  TAO_SFP_UDP_MCast_Connector,
-                  0);
-  return connector;
-}
-
-int
-TAO_SFP_UDP_MCast_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
-{
-  return (protocol == TAO_AV_Core::TAO_AV_SFP_UDP_MCAST);
-}
-
-//
-// TAO_SFP_UDP_MCast_Acceptor
-TAO_SFP_UDP_MCast_Acceptor::TAO_SFP_UDP_MCast_Acceptor (void)
-{
-}
-
-TAO_SFP_UDP_MCast_Acceptor::~TAO_SFP_UDP_MCast_Acceptor (void)
-{
-}
-
-int
-TAO_SFP_UDP_MCast_Acceptor::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler)
-{
-  // @@ We should actually look at the entry and find out if we're a
-  // sink or a source and create the appropriate handler
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Acceptor::make_svc_handler\n"));
-  TAO_SFP_BASE::instance ();
-  TAO_SFP_Object *object;
-  TAO_AV_Callback *callback;
-  this->endpoint_->get_callback (this->entry_->flowname (),callback);
-  ACE_NEW_RETURN (object,
-                  TAO_SFP_Object (callback),
-                  -1);
-  ACE_NEW_RETURN (handler,
-                  TAO_SFP_UDP_MCast_Sender_Handler (callback,
-                                                    object),
-                  -1);
-  callback->transport (handler->transport ());
-  callback->protocol_object (object);
-  object->transport (handler->transport ());
-  this->endpoint_->set_protocol_object (this->entry_->flowname (),
-                                        object);
-  this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-  this->entry_->protocol_object (object);
-  return 0;
-}
-//------------------------------------------------------------
-// TAO_SFP_UDP_MCast_Connector
-//------------------------------------------------------------
-TAO_SFP_UDP_MCast_Connector::TAO_SFP_UDP_MCast_Connector (void)
-{
-}
-
-TAO_SFP_UDP_MCast_Connector::~TAO_SFP_UDP_MCast_Connector (void)
-{
-}
-
-int
-TAO_SFP_UDP_MCast_Connector::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Connector::make_svc_handler\n"));
-  TAO_SFP_BASE::instance ();
-  // @@ We should actually look at the entry and find out if we're a
-  // sink or a source and create the appropriate handler
-  TAO_AV_Callback *callback = 0;
-  this->endpoint_->get_callback (this->entry_->flowname (),
-                                 callback);
-  ACE_NEW_RETURN (handler,
-                  TAO_SFP_UDP_MCast_Receiver_Handler (callback),
-                  -1);
-  TAO_SFP_Object *object;
-  ACE_NEW_RETURN (object,
-                  TAO_SFP_Object (callback),
-                  -1);
-  callback->transport (handler->transport ());
-  callback->protocol_object (object);
-  object->transport (handler->transport ());
-  this->endpoint_->set_protocol_object (this->entry_->flowname (),
-                                        object);
-  this->endpoint_->set_handler (this->flowname_.c_str (),handler);
-  this->entry_->protocol_object (object);
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_SFP_UDP_MCast_Sender_Handler
-//------------------------------------------------------------
-TAO_SFP_UDP_MCast_Sender_Handler::TAO_SFP_UDP_MCast_Sender_Handler (TAO_AV_Callback *callback,
-                                                                    TAO_SFP_Object *object)
-  :TAO_AV_Flow_Handler (callback),
-   TAO_AV_UDP_MCast_Flow_Handler (callback),
-   sfp_object_ (object)
-{
-}
-
-int
-TAO_SFP_UDP_MCast_Sender_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  return -1;
-}
-
-int
-TAO_SFP_UDP_MCast_Sender_Handler::handle_close (ACE_HANDLE /*fd*/,
-                                          ACE_Reactor_Mask)
-{
-  return 0;
-}
-
-int
-TAO_SFP_UDP_MCast_Sender_Handler::start (TAO_FlowSpec_Entry::Role role)
-{
-  // @@once somehow we figure out that the stream is established we
-  // can start sending the frames.
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Sender_Handler::start\n"));
-  TAO_AV_Flow_Handler::start (role);
-  this->sfp_object_->start ();
-  return 0;
-}
-
-int
-TAO_SFP_UDP_MCast_Sender_Handler::stop (TAO_FlowSpec_Entry::Role role)
-{
-  TAO_AV_Flow_Handler::stop (role);
-  this->sfp_object_->stop ();
-  return 0;
-}
-
-//------------------------------------------------------------
-// TAO_SFP_UDP_MCast_Receiver_Handler
-//------------------------------------------------------------
-TAO_SFP_UDP_MCast_Receiver_Handler::TAO_SFP_UDP_MCast_Receiver_Handler (TAO_AV_Callback *callback)
-  :TAO_AV_Flow_Handler (callback),
-   TAO_AV_UDP_MCast_Flow_Handler (callback)
-{
-}
-
-int
-TAO_SFP_UDP_MCast_Receiver_Handler::handle_input (ACE_HANDLE /*fd*/)
-{
-  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Receiver_Handler::handle_input\n"));
-  TAO_AV_frame_info *frame_info = 0;
-  // This is the entry point for receiving data.
-  int result = TAO_SFP_Base::handle_input (this->transport_,
-                                           this->state_,
-                                           frame_info);
-  if (result < 0)
-    ACE_ERROR_RETURN ((LM_ERROR,"ERROR in TAO_SFP_UDP_MCast_Receiver_Handler::handle_input"),result);
-  if (this->state_.frame_header_.message_type == flowProtocol::EndofStream_Msg)
-    this->callback_->handle_end_stream ();
-  if (this->state_.is_complete ())
-    {
-      this->callback_->receive_frame (this->state_.frame_block_,
-                                      frame_info);
-      this->state_.reset ();
-    }
-  return 0;
-}
-
-int
-TAO_SFP_UDP_MCast_Receiver_Handler::handle_close (ACE_HANDLE /*fd*/,
-                                            ACE_Reactor_Mask /*mask*/)
-{
-  return 0;
-}
+// //------------------------------------------------------------
+// //TAO_SFP_UDP_Protocol_Factory
+// //------------------------------------------------------------
+
+// TAO_SFP_UDP_Protocol_Factory::TAO_SFP_UDP_Protocol_Factory (void)
+// {
+// }
+
+// TAO_SFP_UDP_Protocol_Factory::~TAO_SFP_UDP_Protocol_Factory (void)
+// {
+// }
+
+// TAO_AV_Acceptor *
+// TAO_SFP_UDP_Protocol_Factory::make_acceptor (void)
+// {
+//   TAO_SFP_UDP_Acceptor *acceptor = 0;
+//   ACE_NEW_RETURN (acceptor,
+//                   TAO_SFP_UDP_Acceptor,
+//                   0);
+//   return acceptor;
+// }
+
+// TAO_AV_Connector *
+// TAO_SFP_UDP_Protocol_Factory::make_connector (void)
+// {
+//   TAO_SFP_UDP_Connector *connector = 0;
+//   ACE_NEW_RETURN (connector,
+//                   TAO_SFP_UDP_Connector,
+//                   0);
+//   return connector;
+// }
+
+// int
+// TAO_SFP_UDP_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
+// {
+//   return (protocol == TAO_AV_Core::TAO_AV_SFP_UDP);
+// }
+
+// //
+// // TAO_SFP_UDP_Acceptor
+// TAO_SFP_UDP_Acceptor::TAO_SFP_UDP_Acceptor (void)
+// {
+// }
+
+// TAO_SFP_UDP_Acceptor::~TAO_SFP_UDP_Acceptor (void)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_Acceptor::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
+// {
+//   // @@ We should actually look at the entry and find out if we're a
+//   // sink or a source and create the appropriate handler
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Acceptor::make_svc_handler\n"));
+//   TAO_SFP_BASE::instance ();
+//   TAO_SFP_Object *object;
+//   TAO_AV_Callback *callback;
+//   this->endpoint_->get_callback (this->entry_->flowname (),callback);
+//   ACE_NEW_RETURN (object,
+//                   TAO_SFP_Object (callback),
+//                   -1);
+//   ACE_NEW_RETURN (handler,
+//                   TAO_SFP_UDP_Sender_Handler (callback,
+//                                               object),
+//                   -1);
+//   callback->transport (handler->transport ());
+//   callback->protocol_object (object);
+//   object->transport (handler->transport ());
+//   this->endpoint_->set_protocol_object (this->entry_->flowname (),
+//                                         object);
+//   this->endpoint_->set_handler (this->flowname_.c_str (),handler);
+//   this->entry_->protocol_object (object);
+//   return 0;
+// }
+// //------------------------------------------------------------
+// // TAO_SFP_UDP_Connector
+// //------------------------------------------------------------
+// TAO_SFP_UDP_Connector::TAO_SFP_UDP_Connector (void)
+// {
+// }
+
+// TAO_SFP_UDP_Connector::~TAO_SFP_UDP_Connector (void)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_Connector::make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler)
+// {
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Connector::make_svc_handler\n"));
+//   TAO_SFP_BASE::instance ();
+//   // @@ We should actually look at the entry and find out if we're a
+//   // sink or a source and create the appropriate handler
+//   TAO_AV_Callback *callback = 0;
+//   this->endpoint_->get_callback (this->entry_->flowname (),
+//                                  callback);
+//   ACE_NEW_RETURN (handler,
+//                   TAO_SFP_UDP_Receiver_Handler (callback),
+//                   -1);
+//   TAO_SFP_Object *object;
+//   ACE_NEW_RETURN (object,
+//                   TAO_SFP_Object (callback),
+//                   -1);
+//   callback->transport (handler->transport ());
+//   callback->protocol_object (object);
+//   object->transport (handler->transport ());
+//   this->endpoint_->set_protocol_object (this->entry_->flowname (),
+//                                         object);
+//   this->endpoint_->set_handler (this->flowname_.c_str (),handler);
+//   this->entry_->protocol_object (object);
+//   return 0;
+// }
+
+// //------------------------------------------------------------
+// // TAO_SFP_UDP_Sender_Handler
+// //------------------------------------------------------------
+// TAO_SFP_UDP_Sender_Handler::TAO_SFP_UDP_Sender_Handler (TAO_AV_Callback *callback,
+//                                                         TAO_SFP_Object *object)
+//   :TAO_AV_Flow_Handler (callback),
+//    TAO_AV_UDP_Flow_Handler (callback),
+//    sfp_object_ (object)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_Sender_Handler::handle_input (ACE_HANDLE /*fd*/)
+// {
+//   return -1;
+// }
+
+// int
+// TAO_SFP_UDP_Sender_Handler::handle_close (ACE_HANDLE /*fd*/,
+//                                           ACE_Reactor_Mask)
+// {
+//   return 0;
+// }
+
+// int
+// TAO_SFP_UDP_Sender_Handler::start (TAO_FlowSpec_Entry::Role role)
+// {
+//   // @@once somehow we figure out that the stream is established we
+//   // can start sending the frames.
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Sender_Handler::start\n"));
+//   TAO_AV_Flow_Handler::start (role);
+//   this->sfp_object_->start ();
+//   return 0;
+// }
+
+// int
+// TAO_SFP_UDP_Sender_Handler::stop (TAO_FlowSpec_Entry::Role role)
+// {
+//   TAO_AV_Flow_Handler::stop (role);
+//   this->sfp_object_->stop ();
+//   return 0;
+// }
+
+// //------------------------------------------------------------
+// // TAO_SFP_UDP_Receiver_Handler
+// //------------------------------------------------------------
+// TAO_SFP_UDP_Receiver_Handler::TAO_SFP_UDP_Receiver_Handler (TAO_AV_Callback *callback)
+//   :TAO_AV_Flow_Handler (callback),
+//    TAO_AV_UDP_Flow_Handler (callback)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_Receiver_Handler::handle_input (ACE_HANDLE /*fd*/)
+// {
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_Receiver_Handler::handle_input\n"));
+//   // This is the entry point for receiving data.
+//   TAO_AV_frame_info *frame_info = 0;
+//   int result = TAO_SFP_Base::handle_input (this->transport_,
+//                                            this->state_,
+//                                            frame_info);
+//   if (result < 0)
+//     ACE_ERROR_RETURN ((LM_ERROR,"ERROR in TAO_SFP_UDP_Receiver_Handler::handle_input"),result);
+//   if (this->state_.frame_header_.message_type == flowProtocol::EndofStream_Msg)
+//     this->callback_->handle_end_stream ();
+//   if (this->state_.is_complete ())
+//     {
+//       this->callback_->receive_frame (this->state_.frame_block_,
+//                                       frame_info);
+//       this->state_.reset ();
+//     }
+//   return 0;
+// }
+
+// int
+// TAO_SFP_UDP_Receiver_Handler::handle_close (ACE_HANDLE /*fd*/,
+//                                             ACE_Reactor_Mask /*mask*/)
+// {
+//   return 0;
+// }
+
+// //------------------------------------------------------------
+// //TAO_SFP_UDP_MCast_Protocol_Factory
+// //------------------------------------------------------------
+
+// TAO_SFP_UDP_MCast_Protocol_Factory::TAO_SFP_UDP_MCast_Protocol_Factory (void)
+// {
+// }
+
+// TAO_SFP_UDP_MCast_Protocol_Factory::~TAO_SFP_UDP_MCast_Protocol_Factory (void)
+// {
+// }
+
+// TAO_AV_Acceptor *
+// TAO_SFP_UDP_MCast_Protocol_Factory::make_acceptor (void)
+// {
+//   TAO_SFP_UDP_MCast_Acceptor *acceptor = 0;
+//   ACE_NEW_RETURN (acceptor,
+//                   TAO_SFP_UDP_MCast_Acceptor,
+//                   0);
+//   return acceptor;
+// }
+
+// TAO_AV_Connector *
+// TAO_SFP_UDP_MCast_Protocol_Factory::make_connector (void)
+// {
+//   TAO_SFP_UDP_MCast_Connector *connector = 0;
+//   ACE_NEW_RETURN (connector,
+//                   TAO_SFP_UDP_MCast_Connector,
+//                   0);
+//   return connector;
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Protocol_Factory::match_protocol (TAO_AV_Core::Protocol protocol)
+// {
+//   return (protocol == TAO_AV_Core::TAO_AV_SFP_UDP_MCAST);
+// }
+
+// //
+// // TAO_SFP_UDP_MCast_Acceptor
+// TAO_SFP_UDP_MCast_Acceptor::TAO_SFP_UDP_MCast_Acceptor (void)
+// {
+// }
+
+// TAO_SFP_UDP_MCast_Acceptor::~TAO_SFP_UDP_MCast_Acceptor (void)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Acceptor::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler)
+// {
+//   // @@ We should actually look at the entry and find out if we're a
+//   // sink or a source and create the appropriate handler
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Acceptor::make_svc_handler\n"));
+//   TAO_SFP_BASE::instance ();
+//   TAO_SFP_Object *object;
+//   TAO_AV_Callback *callback;
+//   this->endpoint_->get_callback (this->entry_->flowname (),callback);
+//   ACE_NEW_RETURN (object,
+//                   TAO_SFP_Object (callback),
+//                   -1);
+//   ACE_NEW_RETURN (handler,
+//                   TAO_SFP_UDP_MCast_Sender_Handler (callback,
+//                                                     object),
+//                   -1);
+//   callback->transport (handler->transport ());
+//   callback->protocol_object (object);
+//   object->transport (handler->transport ());
+//   this->endpoint_->set_protocol_object (this->entry_->flowname (),
+//                                         object);
+//   this->endpoint_->set_handler (this->flowname_.c_str (),handler);
+//   this->entry_->protocol_object (object);
+//   return 0;
+// }
+// //------------------------------------------------------------
+// // TAO_SFP_UDP_MCast_Connector
+// //------------------------------------------------------------
+// TAO_SFP_UDP_MCast_Connector::TAO_SFP_UDP_MCast_Connector (void)
+// {
+// }
+
+// TAO_SFP_UDP_MCast_Connector::~TAO_SFP_UDP_MCast_Connector (void)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Connector::make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler)
+// {
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Connector::make_svc_handler\n"));
+//   TAO_SFP_BASE::instance ();
+//   // @@ We should actually look at the entry and find out if we're a
+//   // sink or a source and create the appropriate handler
+//   TAO_AV_Callback *callback = 0;
+//   this->endpoint_->get_callback (this->entry_->flowname (),
+//                                  callback);
+//   ACE_NEW_RETURN (handler,
+//                   TAO_SFP_UDP_MCast_Receiver_Handler (callback),
+//                   -1);
+//   TAO_SFP_Object *object;
+//   ACE_NEW_RETURN (object,
+//                   TAO_SFP_Object (callback),
+//                   -1);
+//   callback->transport (handler->transport ());
+//   callback->protocol_object (object);
+//   object->transport (handler->transport ());
+//   this->endpoint_->set_protocol_object (this->entry_->flowname (),
+//                                         object);
+//   this->endpoint_->set_handler (this->flowname_.c_str (),handler);
+//   this->entry_->protocol_object (object);
+//   return 0;
+// }
+
+// //------------------------------------------------------------
+// // TAO_SFP_UDP_MCast_Sender_Handler
+// //------------------------------------------------------------
+// TAO_SFP_UDP_MCast_Sender_Handler::TAO_SFP_UDP_MCast_Sender_Handler (TAO_AV_Callback *callback,
+//                                                                     TAO_SFP_Object *object)
+//   :TAO_AV_Flow_Handler (callback),
+//    TAO_AV_UDP_MCast_Flow_Handler (callback),
+//    sfp_object_ (object)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Sender_Handler::handle_input (ACE_HANDLE /*fd*/)
+// {
+//   return -1;
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Sender_Handler::handle_close (ACE_HANDLE /*fd*/,
+//                                           ACE_Reactor_Mask)
+// {
+//   return 0;
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Sender_Handler::start (TAO_FlowSpec_Entry::Role role)
+// {
+//   // @@once somehow we figure out that the stream is established we
+//   // can start sending the frames.
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Sender_Handler::start\n"));
+//   TAO_AV_Flow_Handler::start (role);
+//   this->sfp_object_->start ();
+//   return 0;
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Sender_Handler::stop (TAO_FlowSpec_Entry::Role role)
+// {
+//   TAO_AV_Flow_Handler::stop (role);
+//   this->sfp_object_->stop ();
+//   return 0;
+// }
+
+// //------------------------------------------------------------
+// // TAO_SFP_UDP_MCast_Receiver_Handler
+// //------------------------------------------------------------
+// TAO_SFP_UDP_MCast_Receiver_Handler::TAO_SFP_UDP_MCast_Receiver_Handler (TAO_AV_Callback *callback)
+//   :TAO_AV_Flow_Handler (callback),
+//    TAO_AV_UDP_MCast_Flow_Handler (callback)
+// {
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Receiver_Handler::handle_input (ACE_HANDLE /*fd*/)
+// {
+//   if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_UDP_MCast_Receiver_Handler::handle_input\n"));
+//   TAO_AV_frame_info *frame_info = 0;
+//   // This is the entry point for receiving data.
+//   int result = TAO_SFP_Base::handle_input (this->transport_,
+//                                            this->state_,
+//                                            frame_info);
+//   if (result < 0)
+//     ACE_ERROR_RETURN ((LM_ERROR,"ERROR in TAO_SFP_UDP_MCast_Receiver_Handler::handle_input"),result);
+//   if (this->state_.frame_header_.message_type == flowProtocol::EndofStream_Msg)
+//     this->callback_->handle_end_stream ();
+//   if (this->state_.is_complete ())
+//     {
+//       this->callback_->receive_frame (this->state_.frame_block_,
+//                                       frame_info);
+//       this->state_.reset ();
+//     }
+//   return 0;
+// }
+
+// int
+// TAO_SFP_UDP_MCast_Receiver_Handler::handle_close (ACE_HANDLE /*fd*/,
+//                                             ACE_Reactor_Mask /*mask*/)
+// {
+//   return 0;
+// }
 
 
 //------------------------------------------------------------
@@ -1420,7 +1420,7 @@ TAO_SFP_Object::send_frame (ACE_Message_Block *frame,
   CORBA::Octet flags = TAO_ENCAP_BYTE_ORDER;
   if (this->transport_ == 0)
     ACE_ERROR_RETURN ((LM_ERROR,"TAO_SFP_Object::send_frame: transport is null\n"),-1);
-   if (this->credit_ > 0)
+   if (this->current_credit_ > 0)
     {
       // if we have enough credit then we send.
       int total_length = 0;
@@ -1553,13 +1553,16 @@ TAO_SFP_Object::send_frame (ACE_Message_Block *frame,
             }
           // Increment the sequence_num after sending the message.
           this->sequence_num_++;
+          // Also reduce the number of credits.
+          this->credit--;
         }
     }
   else
     {
-      // flow controlled so wait.
+      // flow controlled so wait. 
+      // A greater than 0 value indicates that flow control is being exercised.
+      return 1;
     }
-
    return 0;
 }
 
@@ -1614,6 +1617,80 @@ TAO_SFP_Object::get_fragment (ACE_Message_Block *&mb,
   return fragment_mb;
 }
 
+// TAO_SFP_Consumer_Object
+int
+TAO_SFP_Consumer_Object::handle_input (void)
+{
+  if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"TAO_SFP_Consumer_Object::handle_input\n"));
+  // This is the entry point for receiving data.
+  TAO_AV_frame_info *frame_info = 0;
+  int result = TAO_SFP_Base::handle_input (this->transport_,
+                                           this->state_,
+                                           frame_info);
+  if (result < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,"ERROR in TAO_SFP_Consumer_Object::handle_input"),result);
+  if (this->state_.frame_header_.message_type == flowProtocol::EndofStream_Msg)
+    this->callback_->handle_end_stream ();
+  if (this->state_.is_complete ())
+    {
+      this->callback_->receive_frame (this->state_.frame_block_,
+                                      frame_info);
+      this->state_.reset ();
+    }
+  return 0;
+}
+
+TAO_SFP_Producer_Object::TAO_SFP_Producer_Object (void)
+  :credit_sequence_num_ (0)
+{
+}
+
+int
+TAO_SFP_Producer_Object::handle_input (void)
+{
+  // A producer can only receive credit messages.
+  int result;
+  flowProtocol::MsgType msg_type;
+  result = TAO_SFP_Base::peek_message_type (transport,
+                                            msg_type);
+  if (result < 0)
+    return result;
+  switch (msg_type)
+    {
+    case flowProtocol::Credit_Msg:
+      {
+        flowProtocol::credit credit;
+        result = TAO_SFP_Base::read_credit_message (transport,
+                                                    credit,
+                                                    this->state_.cdr);
+        if (result < 0)
+          return result;
+      if (!this->credit_sequence_num_)
+        this->credit_sequence_num_ = credit.cred_num;
+      else
+        {
+          // check that the sequence number is above the last sequence number
+          // else its a duplicate credit message so we can ignore it.
+          if (credit.cred_num <= this->credit_sequence_num_)
+            return 0;
+          else      // Update our credit now.
+            this->current_credit_ = this->max_credit_;
+        }
+      }
+      break;
+    default:
+      {
+        ACE_Message_Block mb (2*this->transport_->mtu ());
+
+      // Ignore the rest of the message by just reading.
+        this->transport_->recv (mb.rd_ptr (),
+                                mb.size ());
+        break;
+      }
+    }
+  return 0;
+}
+
 //------------------------------------------------------------
 // TAO_SFP_Frame_State
 //------------------------------------------------------------
diff --git a/TAO/orbsvcs/orbsvcs/AV/sfp.h b/TAO/orbsvcs/orbsvcs/AV/sfp.h
index a1fa3cd7557..5044d72afa0 100644
--- a/TAO/orbsvcs/orbsvcs/AV/sfp.h
+++ b/TAO/orbsvcs/orbsvcs/AV/sfp.h
@@ -4,13 +4,13 @@
 // ============================================================================
 //
 // = LIBRARY
-//    AVStreams.
+//   ORBSVCS AVStreams.
 //
 // = FILENAME
 //   sfp.h
 //
 // = AUTHOR
-//    Nagarajan Surendran <naga@cs.wustl.edu>
+//   Nagarajan Surendran <naga@cs.wustl.edu>
 //
 // ============================================================================
 
@@ -25,6 +25,7 @@
 #include "Policy.h"
 #include "MCast.h"
 #include "AVStreams_i.h"
+#include "UDP.h"
 
 #define TAO_SFP_MAGIC_NUMBER_LEN 4
 #define TAO_SFP_MESSAGE_TYPE_OFFSET 5
@@ -190,8 +191,8 @@ protected:
 };
 
 typedef ACE_Singleton <TAO_SFP_Base,ACE_SYNCH_MUTEX> TAO_SFP_BASE;
-class TAO_ORBSVCS_Export TAO_SFP_Object
-  :public TAO_AV_Protocol_Object
+
+class TAO_ORBSVCS_Export TAO_SFP_Object  : public TAO_AV_Protocol_Object
 {
 public:
   TAO_SFP_Object (TAO_AV_Callback *callback,
@@ -200,6 +201,7 @@ public:
   virtual ~TAO_SFP_Object (void);
   // Dtor
 
+  virtual int handle_input (void) = 0;
   virtual int send_frame (ACE_Message_Block *frame,
                           TAO_AV_frame_info *frame_info = 0);
 
@@ -215,136 +217,24 @@ protected:
                                    size_t &last_mb_current_len);
   CORBA::ULong sequence_num_;
   CORBA::ULong source_id_;
-  CORBA::ULong credit_;
-};
-
-class TAO_SFP_UDP_Receiver_Handler
-  :public TAO_AV_UDP_Flow_Handler
-{
-public:
-  TAO_SFP_UDP_Receiver_Handler (TAO_AV_Callback *callback);
-  virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
-  virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
-                            ACE_Reactor_Mask = ACE_Event_Handler::NULL_MASK);
-protected:
-  TAO_SFP_Frame_State state_;
-};
-
-class TAO_SFP_UDP_Sender_Handler
-  :public TAO_AV_UDP_Flow_Handler
-{
-public:
-  TAO_SFP_UDP_Sender_Handler (TAO_AV_Callback *callback,
-                              TAO_SFP_Object *sfp_object);
-  virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
-  virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
-                            ACE_Reactor_Mask = ACE_Event_Handler::NULL_MASK);
-  virtual int start (TAO_FlowSpec_Entry::Role role);
-  virtual int stop  (TAO_FlowSpec_Entry::Role role);
-protected:
-  TAO_SFP_Object *sfp_object_;
-};
-
-
-class TAO_ORBSVCS_Export TAO_SFP_UDP_Protocol_Factory
-  :public TAO_AV_Protocol_Factory
-{
-public:
-  TAO_SFP_UDP_Protocol_Factory (void);
-  ~TAO_SFP_UDP_Protocol_Factory (void);
-
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  // verify protocol is a match.
-
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  // create an acceptor.
-
-  virtual TAO_AV_Connector *make_connector (void);
-  // create a connector.
-};
-
-class TAO_SFP_UDP_Acceptor
-  :public TAO_AV_UDP_Acceptor
-{
-public:
-  TAO_SFP_UDP_Acceptor (void);
-  ~TAO_SFP_UDP_Acceptor (void);
-  int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
-};
-
-class TAO_SFP_UDP_Connector
-  :public TAO_AV_UDP_Connector
-{
-public:
-  TAO_SFP_UDP_Connector (void);
-  ~TAO_SFP_UDP_Connector (void);
-  int make_svc_handler (TAO_AV_UDP_Flow_Handler *&handler);
+  CORBA::ULong max_credit_;
+  CORBA::ULong current_credit_;
 };
 
-//----------------------------------------------------------------------
-// SFP_UDP_MCast classes
-//----------------------------------------------------------------------
-class TAO_SFP_UDP_MCast_Receiver_Handler
-  :public TAO_AV_UDP_MCast_Flow_Handler
+class TAO_ORBSVCS_Export TAO_SFP_Producer_Object : public TAO_SFP_Object
 {
 public:
-  TAO_SFP_UDP_MCast_Receiver_Handler (TAO_AV_Callback *callback);
-  virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
-  virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
-                            ACE_Reactor_Mask = ACE_Event_Handler::NULL_MASK);
+  TAO_SFP_Producer_Object (void);
+  virtual int handle_input (void);
 protected:
-  TAO_SFP_Frame_State state_;
-};
-
-class TAO_SFP_UDP_MCast_Sender_Handler
-  :public TAO_AV_UDP_MCast_Flow_Handler
-{
-public:
-  TAO_SFP_UDP_MCast_Sender_Handler (TAO_AV_Callback *callback,
-                                    TAO_SFP_Object *sfp_object);
-  virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
-  virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
-                            ACE_Reactor_Mask = ACE_Event_Handler::NULL_MASK);
-  virtual int start (TAO_FlowSpec_Entry::Role role);
-  virtual int stop  (TAO_FlowSpec_Entry::Role role);
-protected:
-  TAO_SFP_Object *sfp_object_;
-};
-
-
-class TAO_ORBSVCS_Export TAO_SFP_UDP_MCast_Protocol_Factory
-  :public TAO_AV_Protocol_Factory
-{
-public:
-  TAO_SFP_UDP_MCast_Protocol_Factory (void);
-  ~TAO_SFP_UDP_MCast_Protocol_Factory (void);
-
-  virtual int match_protocol (TAO_AV_Core::Protocol protocol);
-  // verify protocol is a match.
-
-  virtual TAO_AV_Acceptor *make_acceptor (void);
-  // create an acceptor.
-
-  virtual TAO_AV_Connector *make_connector (void);
-  // create a connector.
-};
-
-class TAO_SFP_UDP_MCast_Acceptor
-  :public TAO_AV_UDP_MCast_Acceptor
-{
-public:
-  TAO_SFP_UDP_MCast_Acceptor (void);
-  ~TAO_SFP_UDP_MCast_Acceptor (void);
-  int make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler);
+  CORBA::ULong credit_sequence_num_;
 };
 
-class TAO_SFP_UDP_MCast_Connector
-  :public TAO_AV_UDP_MCast_Connector
+class TAO_ORBSVCS_Export TAO_SFP_Consumer_Object : public TAO_SFP_Object
 {
 public:
-  TAO_SFP_UDP_MCast_Connector (void);
-  ~TAO_SFP_UDP_MCast_Connector (void);
-  int make_svc_handler (TAO_AV_UDP_MCast_Flow_Handler *&handler);
+  TAO_SFP_Consumer_Object (void);
+  virtual int handle_input (void);
 };
 
-#endif /* !defined (TAO_SFP_H) */
+#endif /* TAO_SFP_H */
diff --git a/TAO/orbsvcs/orbsvcs/AV/source.cpp b/TAO/orbsvcs/orbsvcs/AV/source.cpp
index 936bf4054eb..730385495a3 100644
--- a/TAO/orbsvcs/orbsvcs/AV/source.cpp
+++ b/TAO/orbsvcs/orbsvcs/AV/source.cpp
@@ -33,7 +33,7 @@
  */
 // $Id$
 #include "ace/OS.h"
-#include "RTP.h"
+#include "RTCP.h"
 #include "source.h"
 
 /* gray out src if no ctrl msgs for this many consecutive update intervals */
@@ -187,18 +187,14 @@ TAO_AV_Source::clear_counters ()
   lts_done_.tv_usec = 0;
 }
 
-TAO_AV_SourceManager::TAO_AV_SourceManager  (const char *flowname,
-                                             TAO_Base_StreamEndPoint *endpoint,
-                                             TAO_AV_RTCP_Flow_Handler *handler)
+TAO_AV_SourceManager::TAO_AV_SourceManager  (TAO_AV_RTCP_Callback *callback)
   :nsources_ (0),
    sources_ (0),
    clock_ (0),
    keep_sites_ (0),
    site_drop_time_ (0),
    localsrc_ (0),
-   flowname_ (flowname),
-   endpoint_ (endpoint),
-   handler_ (handler)
+   callback_ (callback)
 {
   memset ( (char*)hashtab_, 0, sizeof (hashtab_));
 }
@@ -224,13 +220,10 @@ TAO_AV_SourceManager::init (ACE_UINT32 localid, ACE_UINT32 localaddr)
    *  (we special case detection of our own loopbed back packets)
    */
   // Make an upcall to get the source.
-  this->endpoint_->get_rtp_source (localsrc_,
-                                   this->flowname_.in (),
+  this->callback_->get_rtp_source (localsrc_,
                                    localid,
                                    localid,
                                    localaddr);
-  //   ACE_NEW (localsrc_,
-  //            TAO_AV_Source (localid, localid, localaddr));
   enter (localsrc_);
   remove_from_hashtable (localsrc_);
   /*
@@ -239,7 +232,6 @@ TAO_AV_SourceManager::init (ACE_UINT32 localid, ACE_UINT32 localaddr)
          * because they are only created when a packet arrives.
          */
   localsrc_->lts_ctrl (ACE_OS::gettimeofday ());
-  this->handler_->init ();
 }
 
 TAO_AV_Source*
@@ -286,8 +278,7 @@ TAO_AV_SourceManager::lookup (ACE_UINT32 srcid, ACE_UINT32 ssrc, ACE_UINT32 addr
       s = lookup_duplicate (srcid, addr);
 
     if  (s == 0) {
-      this->endpoint_->get_rtp_source (s,
-                                       this->flowname_.in (),
+      this->callback_->get_rtp_source (s,
                                        srcid,
                                        ssrc,
                                        addr);
@@ -315,8 +306,7 @@ TAO_AV_SourceManager::demux (ACE_UINT32 srcid, ACE_UINT32 addr, ACE_UINT16 seq)
     if  (s == 0) {
       /* CSRC=SSRC for data stream */
 
-      this->endpoint_->get_rtp_source (s,
-                                       this->flowname_.in (),
+      this->callback_->get_rtp_source (s,
                                        srcid,
                                        srcid,
                                        addr);
diff --git a/TAO/orbsvcs/orbsvcs/AV/source.h b/TAO/orbsvcs/orbsvcs/AV/source.h
index 65f103c9d9d..5adafbfe2b1 100644
--- a/TAO/orbsvcs/orbsvcs/AV/source.h
+++ b/TAO/orbsvcs/orbsvcs/AV/source.h
@@ -130,7 +130,6 @@ public:
 protected:
   char* stats (char* cp) const;
 
-
   // @@Naga:My additions
   int active_;
   char *name_;
@@ -177,14 +176,12 @@ protected:
 int sdes_atoi (const char* s);
 char* onestat (char* cp, const char* name, u_long v);
 class TAO_Base_StreamEndPoint;
-class TAO_AV_RTCP_Flow_Handler;
+class TAO_AV_RTCP_Callback;
 
 class TAO_AV_SourceManager
 {
 public:
-  TAO_AV_SourceManager (const char *flowname,
-                        TAO_Base_StreamEndPoint *endpoint,
-                        TAO_AV_RTCP_Flow_Handler *handler);
+  TAO_AV_SourceManager (TAO_AV_RTCP_Callback *callback);
   void init (ACE_UINT32 localid, ACE_UINT32 localaddr);
   TAO_AV_Source* lookup (ACE_UINT32 srcid, ACE_UINT32 ssrc, ACE_UINT32 addr);
   TAO_AV_Source* demux (ACE_UINT32 srcid, ACE_UINT32 addr, ACE_UINT16 seq);
@@ -218,10 +215,7 @@ protected:
   TAO_AV_Source* localsrc_;
   TAO_AV_Source* hashtab_[TAO_AV_SOURCE_HASH];
 
-  // flow members.
-  CORBA::String_var flowname_;
-  TAO_Base_StreamEndPoint *endpoint_;
-  TAO_AV_RTCP_Flow_Handler *handler_;
+  TAO_AV_RTCP_Callback *callback_;
 };
 
 #if defined (__ACE_INLINE__)