source: source/ariba/communication/networkinfo/NetworkInformation.cpp@ 5870

// [License]

// The Ariba-Underlay Copyright

//

// Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH)

//

// Institute of Telematics

// UniversitÀt Karlsruhe (TH)

// Zirkel 2, 76128 Karlsruhe

// Germany

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

// 1. Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// 2. Redistributions in binary form must reproduce the above copyright

// notice, this list of conditions and the following disclaimer in the

// documentation and/or other materials provided with the distribution.

//

// THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND

// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ARIBA PROJECT OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// The views and conclusions contained in the software and documentation

// are those of the authors and should not be interpreted as representing

// official policies, either expressed or implied, of the Institute of

// Telematics.

// [License]



#include "NetworkInformation.h"

#include "ariba/config.h"



#ifdef HAVE_BLUETOOTH_BLUETOOTH_H

  #include <bluetooth/bluetooth.h>

  #include <bluetooth/hci.h>

  #include <bluetooth/hci_lib.h>

#endif



namespace ariba {

namespace communication {



use_logging_cpp(NetworkInformation);



NetworkInformation::NetworkInformation() : infoSocket( -1 ){



        infoSocket = socket( AF_INET, SOCK_DGRAM, 0 );

}



NetworkInformation::~NetworkInformation(){



        close( infoSocket );

}



NetworkInterfaceList NetworkInformation::getInterfaces(){



        NetworkInterfaceList retlist;



        //

        // get all network interfaces with basic information

        // and all addresses configured on the interface

        //



        // TODO: can be optimized using SIOCGIFCOUNT

        // but maybe this way its more robust?

        // TODO: or using if_nameindex() problem is here,

        // that i don't know the number of ifaces returned ...



        struct ifconf ifconf;

        int ifnum = 5;

        int lastlen = 0;



        ifconf.ifc_buf = NULL;

        ifconf.ifc_len = 0;



        while( true ){



                ifconf.ifc_len = sizeof(struct ifreq) * ifnum;

                ifconf.ifc_buf = (char*)realloc( ifconf.ifc_buf, ifconf.ifc_len );



                int ret = ioctl( infoSocket, SIOCGIFCONF, &ifconf );

                if (ret < 0){

                        logging_error( "getting interface list failed with: " <<

                                                strerror(errno));



                        // if the socket is bogus, try to get

                        // a new one for the next call

                        if(errno == EBADF){

                                close( infoSocket );

                                infoSocket = socket( AF_INET, SOCK_DGRAM, 0 );

                        }



                        return retlist;

                }



                if( ifconf.ifc_len > lastlen ){

                        lastlen = ifconf.ifc_len;

                        ifnum += 10;

                        continue;

                }



                break; // length did not change any more, success

        }



        struct ifreq* ifr = ifconf.ifc_req;



        for (int i = 0; i<ifconf.ifc_len; i+=sizeof(struct ifreq), ifr++){

                NetworkInterface interface;

                interface.name = string( ifr->ifr_name );

                retlist.push_back( interface );

        }



        free( ifconf.ifc_buf );



        //

        // SIOCGIFCONF does not return interfaces that are currently

        // not running. therefore we try to complete the list of interfaces now

        // using getifaddrs. but we can't use _only_ getifaddrs, because

        // it only contains an interface it it has an address configured

        //



        struct ifaddrs* ifap;

        getifaddrs( &ifap );



        for( struct ifaddrs* p = ifap; p != NULL; p=p->ifa_next ){

                NetworkInterface interface;

                interface.name = string( p->ifa_name );



                if( find(retlist.begin(), retlist.end(), interface) == retlist.end() )

                        retlist.push_back( interface );

        }



        freeifaddrs( ifap );



        //

        // now we start to complete the interface information.

        // we can't just call al IO ctrls and then get the

        // information, as some vars of the ifreq structure

        // hold several values, depending on the request

        // see /usr/include/net/if.h

        //



        NetworkInterfaceList::iterator i = retlist.begin();

        NetworkInterfaceList::iterator iend = retlist.end();



        for( ; i != iend; i++ ){



                NetworkInterface* interface = &(*i);

                struct ifreq ifr;



                memset( &ifr, 0, sizeof(struct ifreq) );

                strcpy( ifr.ifr_name, i->name.c_str() );





                { // get interface index

                        if( ioctl(infoSocket, SIOCGIFINDEX, &ifr) ){

                                logging_error( "could not get interface index for " <<

                                                i->name << ": " << strerror(errno) );

                                return retlist;

                        }



                        interface->index = ifr.ifr_ifindex;

                }



                { // get interface flags

                        if( ioctl(infoSocket, SIOCGIFFLAGS, &ifr) ){

                                logging_error( "could not get interface flags for " <<

                                                i->name << ": " << strerror(errno) );

                                return retlist;

                        }



                        interface->isRunning   = (ifr.ifr_flags & IFF_RUNNING)   != 0 ? true : false;

                        interface->isUp        = (ifr.ifr_flags & IFF_UP)        != 0 ? true : false;

                        interface->isLoopback  = (ifr.ifr_flags & IFF_LOOPBACK)  != 0 ? true : false;

                        interface->isBroadcast = (ifr.ifr_flags & IFF_BROADCAST) != 0 ? true : false;

                        interface->isMulticast = (ifr.ifr_flags & IFF_MULTICAST) != 0 ? true : false;

                }



                { // get mtu

                        if( ioctl(infoSocket, SIOCGIFMTU, &ifr) ){

                                logging_error( "could not get mtu for " <<

                                                i->name << ": " << strerror(errno) );

                                return retlist;

                        }



                        interface->mtu = ifr.ifr_mtu;

                }



                { // get tx queue length

                        if( ioctl(infoSocket, SIOCGIFTXQLEN, &ifr) ){

                                logging_error( "could not get tx queue length for " <<

                                                i->name << ": " << strerror(errno) );

                                return retlist;

                        }



                        interface->txQueueLen = ifr.ifr_qlen;

                }



        } // for( ; i != iend; i++ )*/



        //

        // not we try to get bluetooth interfaces

        //



#ifdef HAVE_BLUETOOTH_BLUETOOTH_H



        int btsock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);

        if(btsock <  0){

                logging_error("failed getting bluetooth raw socket");

                return retlist;

        }



        struct hci_dev_list_req* btlist = NULL;

        struct hci_dev_req* btdev = NULL;



        btlist = (hci_dev_list_req*)malloc(HCI_MAX_DEV *

                        sizeof(struct hci_dev_list_req) + sizeof(struct hci_dev_req));



        btlist->dev_num = HCI_MAX_DEV;

        btdev = btlist->dev_req;



        if(ioctl(btsock, HCIGETDEVLIST, btlist) < 0){

                logging_error("failed getting requesting bluetooth devices");

                free(btlist);

                close(btsock);

                return retlist;

        }



        btdev = btlist->dev_req;



        for(int i=0; i<btlist->dev_num; i++, btdev++){

                struct hci_dev_info di;

                NetworkInterface interface;



                if(hci_devinfo(btdev->dev_id, &di) < 0) continue;

                if(hci_test_bit(HCI_RAW, &di.flags)) continue;



                interface.name = string(di.name);

                interface.index = di.dev_id;

                interface.mtu = di.sco_mtu;

                interface.isBroadcast = false;

                interface.isLoopback = false;

                interface.isMulticast = false;

                interface.isUp = hci_test_bit(HCI_UP, &di.flags);

                interface.isRunning = hci_test_bit(HCI_RUNNING, &di.flags);



                retlist.push_back( interface );

        }



        free(btlist);

        close(btsock);

#endif



        return retlist;

}



NetworkInterface NetworkInformation::getInterface(int index){



        NetworkInterfaceList ifaces = getInterfaces();

        NetworkInterfaceList::iterator i = ifaces.begin();

        NetworkInterfaceList::iterator iend = ifaces.end();



        for( ; i != iend; i++ ){

                if( i->index == index ) return *i;

        }



        return NetworkInterface::UNDEFINED;

}



NetworkInterface NetworkInformation::getInterface(string name){



        NetworkInterfaceList ifaces = getInterfaces();

        NetworkInterfaceList::iterator i = ifaces.begin();

        NetworkInterfaceList::iterator iend = ifaces.end();



        for( ; i != iend; i++ ){

                if( i->name.compare(name) == 0 ) return *i;

        }



        return NetworkInterface::UNDEFINED;

}



}} // namespace ariba, communication