Changeset 12060 for source/ariba/communication/networkinfo/AddressDiscovery.cpp

Timestamp:

Jun 19, 2013, 11:05:49 AM (11 years ago)

Author:

hock@…

Message:

Reintegrate branch: 20130111-hock-message_classes

improvements:

• new message classes (reboost, zero-copy)
• "fast path" for direct links (skip overlay layer)
• link-properties accessible from the application
• SystemQueue can call boost::bind functions
• protlib compatibility removed (32bit overhead saved in every message)
• addressing2
• AddressDiscovery discoveres only addresses on which we're actually listening
• ariba serialization usage reduced (sill used in OverlayMsg)
• Node::connect, easier and cleaner interface to start-up ariba from the application
• ariba configs via JSON, XML, etc (boost::property_tree)
• keep-alive overhead greatly reduced
• (relayed) overlay links can actually be closed now
• lost messages are detected in most cases
• notification to the application when link is transformed into direct-link
• overlay routing: send message to second best hop if it would be dropped otherwise
• SequenceNumbers (only mechanisms, so for: upward compatibility)
• various small fixes

regressions:

• bluetooth is not yet working again
• bootstrap modules deactivated
• liblog4xx is not working (use cout-logging)

This patch brings great performance and stability improvements at cost of backward compatibility.
Also bluetooth and the bootstrap modules have not been ported to the new interfaces, yet.

File:

• source/ariba/communication/networkinfo/AddressDiscovery.cpp (modified) (3 diffs)

source/ariba/communication/networkinfo/AddressDiscovery.cpp

@@ -49 +49 @@
 #include <ifaddrs.h>
 
+#include <string>
+#include <boost/asio/ip/address.hpp>
+#include <boost/foreach.hpp>
+
+#include "ariba/utility/addressing2/tcpip_endpoint.hpp"
+#include "ariba/utility/addressing/mac_address.hpp"
+
 #ifdef HAVE_LIBBLUETOOTH
   #include <bluetooth/bluetooth.h>
@@ -58 +65 @@
 namespace communication {
 
-mac_address AddressDiscovery::getMacFromIF( const char* name ) {
+
+using namespace std;
+using namespace addressing2;
+using namespace boost::asio::ip;
+
+using ariba::addressing::mac_address;
+
+mac_address getMacFromIF( const char* name )
+{
         mac_address addr;
 #ifdef HAVE_LIBBLUETOOTH
@@ -73 +88 @@
 }
 
-int AddressDiscovery::dev_info(int s, int dev_id, long arg) {
-#ifdef HAVE_LIBBLUETOOTH
-        endpoint_set* set = (endpoint_set*)arg;
-        struct hci_dev_info di;
-        memset(&di, 0, sizeof(struct hci_dev_info));
-        di.dev_id = dev_id;
-        if (ioctl(s, HCIGETDEVINFO, (void *) &di)) return 0;
-        mac_address mac;
-        mac.bluetooth( di.bdaddr );
-        address_vf vf = mac;
-        set->add(vf);
+int dev_info(int s, int dev_id, long arg)
+{
+#ifdef HAVE_LIBBLUETOOTH
+//      endpoint_set* set = (endpoint_set*)arg;
+//      struct hci_dev_info di;
+//      memset(&di, 0, sizeof(struct hci_dev_info));
+//      di.dev_id = dev_id;
+//      if (ioctl(s, HCIGETDEVINFO, (void *) &di)) return 0;
+//      mac_address mac;
+//      mac.bluetooth( di.bdaddr );
+//      address_vf vf = mac;
+//      set->add(vf);
 #endif
         return 0;
 }
 
-void AddressDiscovery::discover_bluetooth( endpoint_set& endpoints ) {
-#ifdef HAVE_LIBBLUETOOTH
-        hci_for_each_dev(HCI_UP, &AddressDiscovery::dev_info, (long)&endpoints );
-#endif
-}
-
-void AddressDiscovery::discover_ip_addresses( endpoint_set& endpoints ) {
-        struct ifaddrs* ifaceBuffer = NULL;
-        void*           tmpAddrPtr  = NULL;
-
-        int ret = getifaddrs( &ifaceBuffer );
-        if( ret != 0 ) return;
-
-        for( struct ifaddrs* i=ifaceBuffer; i != NULL; i=i->ifa_next ) {
-
-                // ignore devices that are disabled or have no ip
-                if(i == NULL) continue;
-                struct sockaddr* addr = i->ifa_addr;
-                if (addr==NULL) continue;
-
-                // ignore tun devices
-                string device = string(i->ifa_name);
-                if(device.find_first_of("tun") == 0) continue;
-
-                if (addr->sa_family == AF_INET) {
-                        // look for ipv4
-                        char straddr[INET_ADDRSTRLEN];
-                        tmpAddrPtr= &((struct sockaddr_in*)addr)->sin_addr;
-                        inet_ntop( i->ifa_addr->sa_family, tmpAddrPtr, straddr, sizeof(straddr) );
-                        ip_address ip = straddr;
-                        if (ip.is_loopback()) continue;
-                        address_vf vf = ip;
-                        endpoints.add( vf );
-                } else
-                if (addr->sa_family == AF_INET6) {
-                        // look for ipv6
-                        char straddr[INET6_ADDRSTRLEN];
-                        tmpAddrPtr= &((struct sockaddr_in6*)addr)->sin6_addr;
-                        inet_ntop( i->ifa_addr->sa_family, tmpAddrPtr, straddr, sizeof(straddr) );
-                        ip_address ip = straddr;
-                        if (ip.is_loopback()) continue;
-//                      if (ip.is_link_local()) continue;
-                        address_vf vf = ip;
-                        endpoints.add( vf );
-                }
-        }
-
-        freeifaddrs(ifaceBuffer);
-}
-
-void AddressDiscovery::discover_endpoints( endpoint_set& endpoints ) {
-        discover_ip_addresses( endpoints );
-        discover_bluetooth( endpoints );
+void discover_bluetooth(
+        EndpointSetPtr listenOn_endpoints,
+        EndpointSetPtr discovered_endpoints )
+{
+#ifdef HAVE_LIBBLUETOOTH
+    // FIXME aktuell bluetooth
+//      hci_for_each_dev(HCI_UP, &AddressDiscovery::dev_info, (long)&endpoints );
+#endif
+}
+
+void discover_ip_addresses(
+        EndpointSetPtr listenOn_endpoints,
+        EndpointSetPtr discovered_endpoints )
+{
+    bool discover_ipv4 = false;
+    bool discover_ipv6 = false;
+    vector<uint16_t> ipv4_ports;
+    vector<uint16_t> ipv6_ports;
+    
+    /* analyze listenOn_endpoints */
+    BOOST_FOREACH( TcpIP_EndpointPtr endp, listenOn_endpoints->get_tcpip_endpoints() )
+    {
+        // BRANCH: IPv4 any [0.0.0.0]
+        if ( endp->to_asio().address() == address_v4::any() )
+        {
+            // add port
+            ipv4_ports.push_back(endp->to_asio().port());
+            
+            discover_ipv4 = true;
+        }
+
+        // BRANCH: IPv6 any [::]
+        else if ( endp->to_asio().address() == address_v6::any() )
+        {
+            // add port
+            ipv6_ports.push_back(endp->to_asio().port());
+            
+            discover_ipv6 = true;
+
+            
+            // NOTE: on linux the ipv6-any address [::] catches ipv4 as well
+            ipv4_ports.push_back(endp->to_asio().port());
+            discover_ipv4 = true;
+        }
+        
+        // BRANCH: explicit ip address
+        else
+        {
+            // ---> don't discover anything, just add it directly
+            discovered_endpoints->add_endpoint(endp);
+        }
+    }
+    
+    
+    /* discover addresses */
+    if ( discover_ipv4 || discover_ipv6 )
+    {
+        struct ifaddrs* ifaceBuffer = NULL;
+        void*           tmpAddrPtr  = NULL;
+    
+        int ret = getifaddrs( &ifaceBuffer );
+        if( ret != 0 ) return;
+    
+        for( struct ifaddrs* i=ifaceBuffer; i != NULL; i=i->ifa_next )
+        {
+            // ignore devices that are disabled or have no ip
+            if(i == NULL) continue;
+            struct sockaddr* addr = i->ifa_addr;
+            if (addr==NULL) continue;
+    
+    //          // ignore tun devices  // XXX why?
+    //          string device = string(i->ifa_name);
+    //          if(device.find_first_of("tun") == 0) continue;
+
+            // IPv4
+            if ( discover_ipv4 && addr->sa_family == AF_INET )
+            {
+                char straddr[INET_ADDRSTRLEN];
+                tmpAddrPtr= &((struct sockaddr_in*)addr)->sin_addr;
+                inet_ntop( i->ifa_addr->sa_family, tmpAddrPtr, straddr, sizeof(straddr) );
+                
+                address ip_addr = address::from_string(straddr);
+    
+                // skip loopback address
+                if ( ip_addr.to_v4() == address_v4::loopback() )
+                    continue;
+
+                // add endpoint for this address and every given ipv4 port
+                BOOST_FOREACH( uint16_t port, ipv4_ports )
+                {
+                    tcp::endpoint tcpip_endp(ip_addr, port);
+                    TcpIP_EndpointPtr endp(new tcpip_endpoint(tcpip_endp));
+                    
+                    discovered_endpoints->add_endpoint(endp);
+                }
+            }
+            
+            // IPv6
+            else if ( discover_ipv6 && addr->sa_family == AF_INET6 )
+            {
+                // look for ipv6
+                char straddr[INET6_ADDRSTRLEN];
+                tmpAddrPtr= &((struct sockaddr_in6*)addr)->sin6_addr;
+                inet_ntop( i->ifa_addr->sa_family, tmpAddrPtr, straddr, sizeof(straddr) );
+                
+                address ip_addr = address::from_string(straddr);
+                
+                // skip loopback address
+                if ( ip_addr.to_v6() == address_v6::loopback() )
+                    continue;
+
+                // add endpoint for this address and every given ipv4 port
+                BOOST_FOREACH( uint16_t port, ipv6_ports )
+                {
+                    tcp::endpoint tcpip_endp(ip_addr, port);
+                    TcpIP_EndpointPtr endp(new tcpip_endpoint(tcpip_endp));
+                    
+                    discovered_endpoints->add_endpoint(endp);
+                }
+            }
+        }
+    
+        freeifaddrs(ifaceBuffer);
+    }
+}
+
+
+
+EndpointSetPtr AddressDiscovery::discover_endpoints(EndpointSetPtr listenOn_endpoints)
+{
+    EndpointSetPtr discovered_endpoints(new addressing2::endpoint_set());
+    
+        discover_ip_addresses( listenOn_endpoints, discovered_endpoints );
+        discover_bluetooth( listenOn_endpoints, discovered_endpoints );
+        
+        return discovered_endpoints;
 }