close Warning: Can't use blame annotator: 
No changeset 2259 in the repository

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

Last change on this file since 6924 was 6919, checked in by mies, 15 years ago

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