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

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

Last change on this file since 5641 was 5638, checked in by Christoph Mayer, 15 years ago

adress detection aufgeräumt, network info für bleutooth, data stream (hopeful crash fix), logging auf maemo nur warn, ...

File size: 21.5 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 == *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);
376 localDescriptor.getEndpoints().add(
377 local, endpoint_set::Layer1_3
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 localDescriptor.getEndpoints().add(
431 msg->getRemoteDescriptor().getEndpoints(),
432 endpoint_set::Layer1_3
433 );
434 ld.up = true;
435 add_endpoint(ld.remoteLocator);
436
437 logging_debug( "Link is now up with local id "
438 << ld.localLink.toString() << " and remote id "
439 << ld.remoteLink.toString() );
440
441
442 // inform lisneters about link up event
443 BOOST_FOREACH( CommunicationEvents* i, eventListener ){
444 i->onLinkUp( ld.localLink, ld.localLocator, ld.remoteLocator );
445 }
446
447 // done
448 break;
449 }
450
451 // ---------------------------------------------------------------------
452 // handle link close requests
453 // ---------------------------------------------------------------------
454 case AribaBaseMsg::typeLinkClose: {
455 // get remote link
456 const LinkID& localLink = msg->getRemoteLink();
457 logging_debug( "Received link close request for link " << localLink.toString() );
458
459 // searching for link, not found-> warn
460 LinkDescriptor& linkDesc = queryLocalLink( localLink );
461 if (linkDesc.isUnspecified()) {
462 logging_warn("Failed to find local link " << localLink.toString());
463 return;
464 }
465
466 // inform listeners
467 BOOST_FOREACH( CommunicationEvents* i, eventListener ){
468 i->onLinkDown( linkDesc.localLink,
469 linkDesc.localLocator, linkDesc.remoteLocator );
470 }
471
472 // remove the link descriptor
473 removeLink( localLink );
474
475 // done
476 break;
477 }
478
479 // ---------------------------------------------------------------------
480 // handle link locator changes
481 // ---------------------------------------------------------------------
482 case AribaBaseMsg::typeLinkUpdate: {
483 const LinkID& localLink = msg->getRemoteLink();
484 logging_debug( "Received link update for link "
485 << localLink.toString() );
486
487 // find the link description
488 LinkDescriptor& linkDesc = queryLocalLink( localLink );
489 if (linkDesc.isUnspecified()) {
490 logging_warn("Failed to update local link "
491 << localLink.toString());
492 return;
493 }
494
495 // update the remote locator
496 const address_v* oldremote = linkDesc.remoteLocator;
497 linkDesc.remoteLocator = remote->clone();
498
499 // inform the listeners (local link has _not_ changed!)
500 BOOST_FOREACH( CommunicationEvents* i, eventListener ){
501 i->onLinkChanged(
502 linkDesc.localLink, // linkid
503 linkDesc.localLocator, // old local
504 linkDesc.localLocator, // new local
505 oldremote, // old remote
506 linkDesc.remoteLocator // new remote
507 );
508 }
509
510 // done
511 break;
512 }
513 }
514}
515
516/// add a newly allocated link to the set of links
517void BaseCommunication::addLink( LinkDescriptor* link ) {
518 linkSet.push_back( link );
519}
520
521/// remove a link from set
522void BaseCommunication::removeLink( const LinkID& localLink ) {
523 for(LinkSet::iterator i=linkSet.begin(); i != linkSet.end(); i++){
524 if( (*i)->localLink != localLink) continue;
525 remove_endpoint((*i)->remoteLocator);
526 delete *i;
527 linkSet.erase( i );
528 break;
529 }
530}
531
532/// query a descriptor by local link id
533BaseCommunication::LinkDescriptor& BaseCommunication::queryLocalLink( const LinkID& link ) const {
534 for (int i=0; i<linkSet.size();i++)
535 if (linkSet[i]->localLink == link) return (LinkDescriptor&)*linkSet[i];
536
537 return LinkDescriptor::UNSPECIFIED();
538}
539
540/// query a descriptor by remote link id
541BaseCommunication::LinkDescriptor& BaseCommunication::queryRemoteLink( const LinkID& link ) const {
542 for (int i=0; i<linkSet.size();i++)
543 if (linkSet[i]->remoteLink == link) return (LinkDescriptor&)*linkSet[i];
544
545 return LinkDescriptor::UNSPECIFIED();
546}
547
548LinkIDs BaseCommunication::getLocalLinks( const address_v* addr ) const {
549 LinkIDs ids;
550 for (int i=0; i<linkSet.size(); i++){
551 if( addr == NULL ){
552 ids.push_back( linkSet[i]->localLink );
553 } else {
554 if ( *linkSet[i]->remoteLocator == *addr )
555 ids.push_back( linkSet[i]->localLink );
556 }
557 }
558 return ids;
559}
560
561void BaseCommunication::onNetworkChange(const NetworkChangeInterface::NetworkChangeInfo& info){
562
563#ifdef UNDERLAY_OMNET
564
565 // we have no mobility support for simulations
566 return
567
568#endif // UNDERLAY_OMNET
569
570/*- disabled!
571
572 // we only care about address changes, not about interface changes
573 // as address changes are triggered by interface changes, we are safe here
574 if( info.type != NetworkChangeInterface::EventTypeAddressNew &&
575 info.type != NetworkChangeInterface::EventTypeAddressDelete ) return;
576
577 logging_info( "base communication is handling network address changes" );
578
579 // get all now available addresses
580 NetworkInformation networkInformation;
581 AddressInformation addressInformation;
582
583 NetworkInterfaceList interfaces = networkInformation.getInterfaces();
584 AddressList addresses;
585
586 for( NetworkInterfaceList::iterator i = interfaces.begin(); i != interfaces.end(); i++ ){
587 AddressList newaddr = addressInformation.getAddresses(*i);
588 addresses.insert( addresses.end(), newaddr.begin(), newaddr.end() );
589 }
590
591 //
592 // get current locators for the local endpoint
593 // TODO: this code is dublicate of the ctor code!!! cleanup!
594 //
595
596 NetworkProtocol::NetworkLocatorSet locators = network->getAddresses();
597 NetworkProtocol::NetworkLocatorSet::iterator i = locators.begin();
598 NetworkProtocol::NetworkLocatorSet::iterator iend = locators.end();
599
600 //
601 // remember the old local endpoint, in case it changes
602 //
603
604 EndpointDescriptor oldLocalDescriptor( localDescriptor );
605
606 //
607 // look for local locators that we can use in communication
608 //
609 // choose the first locator that is not localhost
610 //
611
612 bool foundLocator = false;
613 bool changedLocator = false;
614
615 for( ; i != iend; i++){
616 logging_debug( "local locator found " << (*i)->toString() );
617 IPv4Locator* ipv4locator = dynamic_cast<IPv4Locator*>(*i);
618
619 if( *ipv4locator != IPv4Locator::LOCALHOST &&
620 *ipv4locator != IPv4Locator::ANY &&
621 *ipv4locator != IPv4Locator::BROADCAST ){
622
623 ipv4locator->setPort( listenport );
624 changedLocator = *localDescriptor.locator != *ipv4locator;
625 localDescriptor.locator = ipv4locator;
626 logging_info( "binding to addr = " << ipv4locator->toString() );
627 foundLocator = true;
628 break;
629 }
630 } // for( ; i != iend; i++)
631
632 //
633 // if we found no locator, bind to localhost
634 //
635
636 if( !foundLocator ){
637 changedLocator = *localDescriptor.locator != IPv4Locator::LOCALHOST;
638 localDescriptor.locator = new IPv4Locator( IPv4Locator::LOCALHOST );
639 ((IPv4Locator*)(localDescriptor.locator))->setPort( listenport );
640 logging_info( "found no good local lcoator, binding to addr = " <<
641 localDescriptor.locator->toString() );
642 }
643
644 //
645 // if we have connections that have no more longer endpoints
646 // close these. they will be automatically built up again.
647 // also update the local locator in the linkset mapping
648 //
649
650 if( changedLocator ){
651
652 logging_debug( "local endp locator has changed to " << localDescriptor.toString() <<
653 ", resettings connections that end at old locator " <<
654 oldLocalDescriptor.toString());
655
656 LinkSet::iterator i = linkSet.begin();
657 LinkSet::iterator iend = linkSet.end();
658
659 for( ; i != iend; i++ ){
660
661 logging_debug( "checking connection for locator change: " <<
662 " local " << (*i).localLocator->toString() <<
663 " old " << oldLocalDescriptor.locator->toString() );
664
665 if( *((*i).localLocator) == *(oldLocalDescriptor.locator) ){
666
667 logging_debug("terminating connection to " << (*i).remoteLocator->toString() );
668 transport->terminate( oldLocalDescriptor.locator, (*i).remoteLocator );
669
670 (*i).localLocator = localDescriptor.locator;
671 }
672 } // for( ; i != iend; i++ )
673
674 // wait 500ms to give the sockets time to shut down
675 usleep( 500000 );
676
677 } else {
678
679 logging_debug( "locator has not changed, not resetting connections" );
680
681 }
682
683 //
684 // handle the connections that have no longer any
685 // valid locator. send update messages with the new
686 // locator, so the remote node updates its locator/link mapping
687 //
688
689 LinkSet::iterator iAffected = linkSet.begin();
690 LinkSet::iterator endAffected = linkSet.end();
691
692 for( ; iAffected != endAffected; iAffected++ ){
693 LinkDescriptor descr = *iAffected;
694 logging_debug( "sending out link locator update to " << descr.remoteLocator->toString() );
695
696 AribaBaseMsg updateMsg( descr.remoteLocator,
697 AribaBaseMsg::LINK_STATE_UPDATE,
698 descr.localLink, descr.remoteLink );
699
700 transport->sendMessage( &updateMsg );
701 }
702*/
703}
704
705/// sends a message to all end-points in the end-point descriptor
706void BaseCommunication::send(Message* message, const EndpointDescriptor& endpoint) {
707 Data data = data_serialize( message, DEFAULT_V );
708 transport->send( endpoint.getEndpoints(), data.getBuffer(), data.getLength() / 8);
709}
710
711/// sends a message to the remote locator inside the link descriptor
712void BaseCommunication::send(Message* message, const LinkDescriptor& desc) {
713 Data data = data_serialize( message, DEFAULT_V );
714 transport->send( desc.remoteLocator, data.getBuffer(), data.getLength() / 8);
715}
716
717}} // namespace ariba, communication
Note: See TracBrowser for help on using the repository browser.