An Overlay-based
Virtual Network Substrate
SpoVNet

source: source/ariba/communication/BaseCommunication.cpp @ 5636

Last change on this file since 5636 was 5636, checked in by mies, 14 years ago
File size: 21.5 KB
Line 
1// [License]
2// The Ariba-Underlay Copyright
3//
4// Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH)
5//
6// Institute of Telematics
7// UniversitÀt Karlsruhe (TH)
8// Zirkel 2, 76128 Karlsruhe
9// Germany
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND
22// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ARIBA PROJECT OR
25// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32//
33// The views and conclusions contained in the software and documentation
34// are those of the authors and should not be interpreted as representing
35// official policies, either expressed or implied, of the Institute of
36// Telematics.
37// [License]
38
39#include "BaseCommunication.h"
40
41#ifdef UNDERLAY_OMNET
42  #include "ariba/communication/modules/transport/omnet/AribaOmnetModule.h"
43  #include "ariba/communication/modules/network/omnet/OmnetNetworkProtocol.h"
44  #include "ariba/utility/system/StartupWrapper.h"
45
46  using ariba::communication::AribaOmnetModule;
47  using ariba::communication::OmnetNetworkProtocol;
48  using ariba::utility::StartupWrapper;
49#endif
50
51namespace ariba {
52namespace communication {
53
54#include "networkinfo/AddressDiscovery.hpp"
55
56use_logging_cpp(BaseCommunication);
57
58/// adds an endpoint to the list
59void BaseCommunication::add_endpoint( const address_v* endpoint ) {
60        if (endpoint==NULL) return;
61        BOOST_FOREACH( endpoint_reference& ref, remote_endpoints ) {
62                if (ref.endpoint->type_id() == endpoint->type_id() && *ref.endpoint == *endpoint) {
63                        ref.count++;
64                        return;
65                }
66        }
67        endpoint_reference ref;
68        ref.endpoint = endpoint->clone();
69        ref.count = 1;
70        remote_endpoints.push_back(ref);
71}
72
73/// removes an endpoint from the list
74void BaseCommunication::remove_endpoint( const address_v* endpoint ) {
75        if (endpoint==NULL) return;
76        for (vector<endpoint_reference>::iterator i = remote_endpoints.begin();
77                i != remote_endpoints.end(); i++) {
78                if (*i->endpoint == *endpoint) {
79                        i->count--;
80                        if (i->count==0) {
81                                logging_info("No more links to " << i->endpoint->to_string() << ": terminating transports!");
82                                transport->terminate(i->endpoint);
83                                delete i->endpoint;
84                                remote_endpoints.erase(i);
85                        }
86                        return;
87                }
88        }
89}
90
91BaseCommunication::BaseCommunication() {
92        this->transport = NULL;
93        this->started = false;
94}
95
96BaseCommunication::~BaseCommunication(){
97}
98
99void BaseCommunication::start() {
100        logging_info( "Starting up ..." );
101        currentSeqnum = 0;
102
103        // creating transports
104        logging_info( "Creating transports ..." );
105
106#ifdef UNDERLAY_OMNET
107        AribaOmnetModule* module = StartupWrapper::getCurrentModule();
108        module->setServerPort( listenport );
109
110        transport = module;
111        network = new OmnetNetworkProtocol( module );
112#else
113        transport = new transport_peer( localDescriptor.getEndpoints() );
114#endif
115
116        logging_info( "Searching for local locators ..." );
117        discover_endpoints(localDescriptor.getEndpoints());
118        logging_info( "Done. Local endpoints = " << localDescriptor.toString() );
119
120        transport->register_listener( this );
121        transport->start();
122
123#ifndef UNDERLAY_OMNET
124        // bind to the network change detection
125        networkMonitor.registerNotification( this );
126#endif
127
128        // base comm startup done
129        started = true;
130        logging_info( "Started up." );
131}
132
133void BaseCommunication::stop() {
134        logging_info( "Stopping transports ..." );
135
136        transport->stop();
137        delete transport;
138        started = false;
139
140        logging_info( "Stopped." );
141}
142
143bool BaseCommunication::isStarted(){
144        return started;
145}
146
147/// Sets the endpoints
148void BaseCommunication::setEndpoints( string& _endpoints ) {
149        localDescriptor.getEndpoints().assign(_endpoints);
150        logging_info("Setting local end-points: "
151                << localDescriptor.getEndpoints().to_string());
152}
153
154const LinkID BaseCommunication::establishLink(
155        const EndpointDescriptor& descriptor,
156        const LinkID& link_id,
157        const QoSParameterSet& qos,
158        const SecurityParameterSet& sec) {
159
160        // copy link id
161        LinkID linkid = link_id;
162
163        // debug
164        logging_debug( "Request to establish link" );
165
166        // create link identifier
167        if (linkid.isUnspecified())     linkid = LinkID::create();
168
169        // create link descriptor
170        logging_debug( "Creating new descriptor entry with local link id=" << linkid.toString() );
171        LinkDescriptor* ld = new LinkDescriptor();
172        ld->localLink = linkid;
173        addLink( ld );
174
175        // send a message to request new link to remote
176        logging_debug( "Send messages with request to open link to " << descriptor.toString() );
177        AribaBaseMsg baseMsg( AribaBaseMsg::typeLinkRequest, linkid );
178        baseMsg.getLocalDescriptor() = localDescriptor;
179
180        // serialize and send message
181        send( &baseMsg, descriptor );
182
183        return linkid;
184}
185
186void BaseCommunication::dropLink(const LinkID link) {
187
188        logging_debug( "Starting to drop link " + link.toString() );
189
190        // see if we have the link
191        LinkDescriptor& ld = queryLocalLink( link );
192        if( ld.isUnspecified() ) {
193                logging_error( "Don't know the link you want to drop "+ link.toString() );
194                return;
195        }
196
197        // tell the registered listeners
198        BOOST_FOREACH( CommunicationEvents* i, eventListener ) {
199                i->onLinkDown( link, ld.localLocator, ld.remoteLocator );
200        }
201
202        // create message to drop the link
203        logging_debug( "Sending out link close request. for us, the link is closed now" );
204        AribaBaseMsg msg( AribaBaseMsg::typeLinkClose, ld.localLink, ld.remoteLink );
205
206        // send message to drop the link
207        send( &msg, ld );
208
209        // remove from map
210        removeLink(link);
211}
212
213seqnum_t BaseCommunication::sendMessage( const LinkID lid, const Message* message) {
214
215        logging_debug( "Sending out message to link " << lid.toString() );
216
217        // query local link info
218        LinkDescriptor& ld = queryLocalLink(lid);
219        if( ld.isUnspecified() ){
220                logging_error( "Don't know the link with id " << lid.toString() );
221                return -1;
222        }
223
224        // link not up-> error
225        if( !ld.up ) {
226                logging_error("Can not send on link " << lid.toString() << ": link not up");
227                return -1;
228        }
229
230        // create message
231        AribaBaseMsg msg( AribaBaseMsg::typeData, ld.localLink, ld.remoteLink );
232
233        // encapsulate the payload message
234        msg.encapsulate( const_cast<Message*>(message) );
235
236        // send message
237        send( &msg, ld );
238
239        // return sequence number
240        return ++currentSeqnum;
241}
242
243const EndpointDescriptor& BaseCommunication::getEndpointDescriptor(const LinkID link) const {
244        if( link == LinkID::UNSPECIFIED){
245                return localDescriptor;
246        } else {
247                LinkDescriptor& linkDesc = queryLocalLink(link);
248                if (linkDesc.isUnspecified()) return EndpointDescriptor::UNSPECIFIED();
249                return linkDesc.remoteEndpoint;
250        }
251}
252
253void BaseCommunication::registerEventListener(CommunicationEvents* _events){
254        if( eventListener.find( _events ) == eventListener.end() )
255                eventListener.insert( _events );
256}
257
258void BaseCommunication::unregisterEventListener(CommunicationEvents* _events){
259        EventListenerSet::iterator i = eventListener.find( _events );
260        if( i != eventListener.end() )
261                eventListener.erase( i );
262}
263
264SystemEventType TransportEvent("Transport");
265SystemEventType MessageDispatchEvent("MessageDispatchEvent", TransportEvent );
266
267class DispatchMsg {
268public:
269        address_v* local;
270        address_v* remote;
271        Message* message;
272};
273
274/// called when a system event is emitted by system queue
275void BaseCommunication::handleSystemEvent(const SystemEvent& event) {
276
277        // dispatch received messages
278        if ( event.getType() == MessageDispatchEvent ){
279                logging_debug( "Forwarding message receiver" );
280                DispatchMsg* dmsg = event.getData<DispatchMsg>();
281                Message* msg = dmsg->message;
282                receiveMessage(msg, dmsg->local, dmsg->remote);
283                msg->dropPayload();
284                delete dmsg;
285                delete msg;
286        }
287}
288
289/// called when a message is received from transport_peer
290void BaseCommunication::receive_message(transport_protocol* transport,
291        const address_vf local, const address_vf remote, const uint8_t* data,
292        size_t size) {
293
294//      logging_debug( "Dispatching message" );
295
296        // convert data
297        Data data_( const_cast<uint8_t*>(data), size * 8 );
298        DispatchMsg* dmsg = new DispatchMsg();
299
300        Message* msg = new Message(data_);
301        dmsg->local = local->clone();
302        dmsg->remote = remote->clone();
303        dmsg->message = msg;
304
305        SystemQueue::instance().scheduleEvent(
306                SystemEvent( this, MessageDispatchEvent, dmsg )
307        );
308}
309
310/// handles a message from the underlay transport
311void BaseCommunication::receiveMessage(const Message* message,
312        const address_v* local, const address_v* remote ){
313
314        /// decapsulate message
315        AribaBaseMsg* msg = ((Message*)message)->decapsulate<AribaBaseMsg>();
316        logging_debug( "Receiving message of type " << msg->getTypeString() );
317
318        // handle message
319        switch (msg->getType()) {
320
321                // ---------------------------------------------------------------------
322                // data message
323                // ---------------------------------------------------------------------
324                case AribaBaseMsg::typeData: {
325                        logging_debug( "Received data message, forwarding to overlay" );
326                        if( messageReceiver != NULL ) {
327                                messageReceiver->receiveMessage(
328                                        msg, msg->getRemoteLink(), NodeID::UNSPECIFIED
329                                );
330                        }
331                        break;
332                }
333
334                // ---------------------------------------------------------------------
335                // handle link request from remote
336                // ---------------------------------------------------------------------
337                case AribaBaseMsg::typeLinkRequest: {
338                        logging_debug( "Received link open request" );
339
340                        /// only answer the first request
341                        if (!queryRemoteLink(msg->getLocalLink()).isUnspecified()) {
342                                logging_debug("Link request already received. Ignore!");
343                                break;
344                        }
345
346                        /// create link ids
347                        LinkID localLink  = LinkID::create();
348                        LinkID remoteLink = msg->getLocalLink();
349                        logging_debug( "local=" << local->to_string()
350                                << " remote=" << remote->to_string()
351                        );
352
353                        // check if link creation is allowed by ALL listeners
354                        bool allowlink = true;
355                        BOOST_FOREACH( CommunicationEvents* i, eventListener ){
356                                allowlink &= i->onLinkRequest( localLink, local, remote );
357                        }
358
359                        // not allowed-> warn
360                        if( !allowlink ){
361                                logging_warn( "Overlay denied creation of link" );
362                                return;
363                        }
364
365                        // create descriptor
366                        LinkDescriptor* ld = new LinkDescriptor();
367                        ld->localLink = localLink;
368                        ld->remoteLink = remoteLink;
369                        ld->localLocator = local->clone();
370                        ld->remoteLocator = remote->clone();
371                        ld->remoteEndpoint = msg->getLocalDescriptor();
372                        add_endpoint(ld->remoteLocator);
373
374                        // add layer 1-3 addresses
375                        ld->remoteEndpoint.getEndpoints().add(
376                                ld->remoteLocator, endpoint_set::Layer1_3);
377                        localDescriptor.getEndpoints().add(
378                                local, endpoint_set::Layer1_3
379                        );
380
381                        // link is now up-> add it
382                        ld->up = true;
383                        addLink(ld);
384
385                        // link is up!
386                        logging_debug( "Link (initiated from remote) is up with "
387                                << "local(id=" << ld->localLink.toString() << ","
388                                << "locator=" << ld->localLocator->to_string() << ") "
389                                << "remote(id=" << ld->remoteLink.toString() << ", "
390                                << "locator=" << ld->remoteLocator->to_string() << ")"
391                        );
392
393                        // sending link request reply
394                        logging_debug( "Sending link request reply with ids "
395                                << "local=" << localLink.toString() << ", "
396                                << "remote=" << remoteLink.toString() );
397                        AribaBaseMsg reply( AribaBaseMsg::typeLinkReply, localLink, remoteLink );
398                        reply.getLocalDescriptor() = localDescriptor;
399                        reply.getRemoteDescriptor() = ld->remoteEndpoint;
400
401                        send( &reply, *ld );
402
403                        // inform listeners about new open link
404                        BOOST_FOREACH( CommunicationEvents* i, eventListener ) {
405                                i->onLinkUp( localLink, ld->localLocator, ld->remoteLocator);
406                        }
407
408                        // done
409                        break;
410                }
411
412                // ---------------------------------------------------------------------
413                // handle link request reply
414                // ---------------------------------------------------------------------
415                case AribaBaseMsg::typeLinkReply: {
416                        logging_debug( "Received link open reply for a link we initiated" );
417
418                        // this is a reply to a link open request, so we have already
419                        // a link mapping and can now set the remote link to valid
420                        LinkDescriptor& ld = queryLocalLink( msg->getRemoteLink() );
421
422                        // no link found-> warn!
423                        if (ld.isUnspecified()) {
424                                logging_warn("Failed to find local link " << msg->getRemoteLink().toString());
425                                return;
426                        }
427
428                        // set remote locator and link id
429                        ld.remoteLink = msg->getLocalLink();
430                        ld.remoteLocator = remote->clone();
431                        localDescriptor.getEndpoints().add(
432                                msg->getRemoteDescriptor().getEndpoints(),
433                                endpoint_set::Layer1_3
434                        );
435                        ld.up = true;
436                        add_endpoint(ld.remoteLocator);
437
438                        logging_debug( "Link is now up with local id "
439                                << ld.localLink.toString() << " and remote id "
440                                << ld.remoteLink.toString() );
441
442
443                        // inform lisneters about link up event
444                        BOOST_FOREACH( CommunicationEvents* i, eventListener ){
445                                i->onLinkUp( ld.localLink, ld.localLocator, ld.remoteLocator );
446                        }
447
448                        // done
449                        break;
450                }
451
452                // ---------------------------------------------------------------------
453                // handle link close requests
454                // ---------------------------------------------------------------------
455                case AribaBaseMsg::typeLinkClose: {
456                        // get remote link
457                        const LinkID& localLink = msg->getRemoteLink();
458                        logging_debug( "Received link close request for link " << localLink.toString() );
459
460                        // searching for link, not found-> warn
461                        LinkDescriptor& linkDesc = queryLocalLink( localLink );
462                        if (linkDesc.isUnspecified()) {
463                                logging_warn("Failed to find local link " << localLink.toString());
464                                return;
465                        }
466
467                        // inform listeners
468                        BOOST_FOREACH( CommunicationEvents* i, eventListener ){
469                                i->onLinkDown( linkDesc.localLink,
470                                                linkDesc.localLocator, linkDesc.remoteLocator );
471                        }
472
473                        // remove the link descriptor
474                        removeLink( localLink );
475
476                        // done
477                        break;
478                }
479
480                // ---------------------------------------------------------------------
481                // handle link locator changes
482                // ---------------------------------------------------------------------
483                case AribaBaseMsg::typeLinkUpdate: {
484                        const LinkID& localLink = msg->getRemoteLink();
485                        logging_debug( "Received link update for link "
486                                << localLink.toString() );
487
488                        // find the link description
489                        LinkDescriptor& linkDesc = queryLocalLink( localLink );
490                        if (linkDesc.isUnspecified()) {
491                                logging_warn("Failed to update local link "
492                                        << localLink.toString());
493                                return;
494                        }
495
496                        // update the remote locator
497                        const address_v* oldremote = linkDesc.remoteLocator;
498                        linkDesc.remoteLocator = remote->clone();
499
500                        // inform the listeners (local link has _not_ changed!)
501                        BOOST_FOREACH( CommunicationEvents* i, eventListener ){
502                                i->onLinkChanged(
503                                        linkDesc.localLink,     // linkid
504                                        linkDesc.localLocator,  // old local
505                                        linkDesc.localLocator,  // new local
506                                        oldremote,              // old remote
507                                        linkDesc.remoteLocator  // new remote
508                                );
509                        }
510
511                        // done
512                        break;
513                }
514        }
515}
516
517/// add a newly allocated link to the set of links
518void BaseCommunication::addLink( LinkDescriptor* link ) {
519        linkSet.push_back( link );
520}
521
522/// remove a link from set
523void BaseCommunication::removeLink( const LinkID& localLink ) {
524        for(LinkSet::iterator i=linkSet.begin(); i != linkSet.end(); i++){
525                if( (*i)->localLink != localLink) continue;
526                remove_endpoint((*i)->remoteLocator);
527                delete *i;
528                linkSet.erase( i );
529                break;
530        }
531}
532
533/// query a descriptor by local link id
534BaseCommunication::LinkDescriptor& BaseCommunication::queryLocalLink( const LinkID& link ) const {
535        for (int i=0; i<linkSet.size();i++)
536                if (linkSet[i]->localLink == link) return (LinkDescriptor&)*linkSet[i];
537
538        return LinkDescriptor::UNSPECIFIED();
539}
540
541/// query a descriptor by remote link id
542BaseCommunication::LinkDescriptor& BaseCommunication::queryRemoteLink( const LinkID& link ) const {
543        for (int i=0; i<linkSet.size();i++)
544                if (linkSet[i]->remoteLink == link) return (LinkDescriptor&)*linkSet[i];
545
546        return LinkDescriptor::UNSPECIFIED();
547}
548
549LinkIDs BaseCommunication::getLocalLinks( const address_v* addr ) const {
550        LinkIDs ids;
551        for (int i=0; i<linkSet.size(); i++){
552                if( addr == NULL ){
553                        ids.push_back( linkSet[i]->localLink );
554                } else {
555                        if ( *linkSet[i]->remoteLocator == *addr )
556                                ids.push_back( linkSet[i]->localLink );
557                }
558        }
559        return ids;
560}
561
562void BaseCommunication::onNetworkChange(const NetworkChangeInterface::NetworkChangeInfo& info){
563
564#ifdef UNDERLAY_OMNET
565
566        // we have no mobility support for simulations
567        return
568
569#endif // UNDERLAY_OMNET
570
571/*- disabled!
572
573        // we only care about address changes, not about interface changes
574        // as address changes are triggered by interface changes, we are safe here
575        if( info.type != NetworkChangeInterface::EventTypeAddressNew &&
576                info.type != NetworkChangeInterface::EventTypeAddressDelete ) return;
577
578        logging_info( "base communication is handling network address changes" );
579
580        // get all now available addresses
581        NetworkInformation networkInformation;
582        AddressInformation addressInformation;
583
584        NetworkInterfaceList interfaces = networkInformation.getInterfaces();
585        AddressList addresses;
586
587        for( NetworkInterfaceList::iterator i = interfaces.begin(); i != interfaces.end(); i++ ){
588                AddressList newaddr = addressInformation.getAddresses(*i);
589                addresses.insert( addresses.end(), newaddr.begin(), newaddr.end() );
590        }
591
592        //
593        // get current locators for the local endpoint
594        // TODO: this code is dublicate of the ctor code!!! cleanup!
595        //
596
597        NetworkProtocol::NetworkLocatorSet locators = network->getAddresses();
598        NetworkProtocol::NetworkLocatorSet::iterator i = locators.begin();
599        NetworkProtocol::NetworkLocatorSet::iterator iend = locators.end();
600
601        //
602        // remember the old local endpoint, in case it changes
603        //
604
605        EndpointDescriptor oldLocalDescriptor( localDescriptor );
606
607        //
608        // look for local locators that we can use in communication
609        //
610        // choose the first locator that is not localhost
611        //
612
613        bool foundLocator = false;
614        bool changedLocator = false;
615
616        for( ; i != iend; i++){
617                logging_debug( "local locator found " << (*i)->toString() );
618                IPv4Locator* ipv4locator = dynamic_cast<IPv4Locator*>(*i);
619
620                if( *ipv4locator != IPv4Locator::LOCALHOST &&
621                    *ipv4locator != IPv4Locator::ANY       &&
622                    *ipv4locator != IPv4Locator::BROADCAST  ){
623
624                        ipv4locator->setPort( listenport );
625                        changedLocator = *localDescriptor.locator != *ipv4locator;
626                        localDescriptor.locator = ipv4locator;
627                        logging_info( "binding to addr = " << ipv4locator->toString() );
628                        foundLocator = true;
629                        break;
630                }
631        } // for( ; i != iend; i++)
632
633        //
634        // if we found no locator, bind to localhost
635        //
636
637        if( !foundLocator ){
638                changedLocator = *localDescriptor.locator != IPv4Locator::LOCALHOST;
639                localDescriptor.locator = new IPv4Locator( IPv4Locator::LOCALHOST );
640                ((IPv4Locator*)(localDescriptor.locator))->setPort( listenport );
641                logging_info( "found no good local lcoator, binding to addr = " <<
642                                                localDescriptor.locator->toString() );
643        }
644
645        //
646        // if we have connections that have no more longer endpoints
647        // close these. they will be automatically built up again.
648        // also update the local locator in the linkset mapping
649        //
650
651        if( changedLocator ){
652
653                logging_debug( "local endp locator has changed to " << localDescriptor.toString() <<
654                                ", resettings connections that end at old locator " <<
655                                        oldLocalDescriptor.toString());
656
657                LinkSet::iterator i = linkSet.begin();
658                LinkSet::iterator iend = linkSet.end();
659
660                for( ; i != iend; i++ ){
661
662                        logging_debug( "checking connection for locator change: " <<
663                                        " local " << (*i).localLocator->toString() <<
664                                        " old " << oldLocalDescriptor.locator->toString() );
665
666                        if( *((*i).localLocator) == *(oldLocalDescriptor.locator) ){
667
668                                logging_debug("terminating connection to " << (*i).remoteLocator->toString() );
669                                transport->terminate( oldLocalDescriptor.locator, (*i).remoteLocator );
670
671                                (*i).localLocator = localDescriptor.locator;
672                        }
673                } // for( ; i != iend; i++ )
674
675                // wait 500ms to give the sockets time to shut down
676                usleep( 500000 );
677
678        } else {
679
680                logging_debug( "locator has not changed, not resetting connections" );
681
682        }
683
684        //
685        // handle the connections that have no longer any
686        // valid locator. send update messages with the new
687        // locator,  so the remote node updates its locator/link mapping
688        //
689
690        LinkSet::iterator iAffected = linkSet.begin();
691        LinkSet::iterator endAffected = linkSet.end();
692
693        for( ; iAffected != endAffected; iAffected++ ){
694                LinkDescriptor descr = *iAffected;
695                logging_debug( "sending out link locator update to " << descr.remoteLocator->toString() );
696
697                AribaBaseMsg updateMsg(         descr.remoteLocator,
698                                                AribaBaseMsg::LINK_STATE_UPDATE,
699                                                descr.localLink, descr.remoteLink );
700
701                transport->sendMessage( &updateMsg );
702        }
703*/
704}
705
706/// sends a message to all end-points in the end-point descriptor
707void BaseCommunication::send(Message* message, const EndpointDescriptor& endpoint) {
708        Data data = data_serialize( message, DEFAULT_V );
709        transport->send( endpoint.getEndpoints(), data.getBuffer(), data.getLength() / 8);
710}
711
712/// sends a message to the remote locator inside the link descriptor
713void BaseCommunication::send(Message* message, const LinkDescriptor& desc) {
714        Data data = data_serialize( message, DEFAULT_V );
715        transport->send( desc.remoteLocator, data.getBuffer(), data.getLength() / 8);
716}
717
718}} // namespace ariba, communication
Note: See TracBrowser for help on using the repository browser.