source: source/ariba/communication/networkinfo/NetworkChangeDetection.cpp@ 3057

// [Licence]

// 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.

// [Licence]



#include "NetworkChangeDetection.h"



namespace ariba {

namespace communication {



use_logging_cpp(NetworkChangeDetection);

SystemEventType NetworkChangeDetectionEventType("NetworkChangeDetectionEventType");



NetworkChangeDetection::NetworkChangeDetection()

        : running( false ), monitoringThread( NULL ), routingSocket( -1 ){

        startMonitoring();

}



NetworkChangeDetection::~NetworkChangeDetection(){

        stopMonitoring();

}



void NetworkChangeDetection::registerNotification(NetworkChangeInterface* callback){



        RegistrationList::iterator i = find(

                registrations.begin(), registrations.end(), callback );



        if( i == registrations.end() )

                registrations.push_back( callback );

}



void NetworkChangeDetection::unregisterNotification(NetworkChangeInterface* callback){



        RegistrationList::iterator i = find(

                registrations.begin(), registrations.end(), callback );



        if( i != registrations.end() )

                registrations.erase( i );

}



void NetworkChangeDetection::startMonitoring(){



        logging_debug( "starting network change monitoring ..." );



        running = true;

        monitoringThread = new boost::thread(

                boost::bind(&NetworkChangeDetection::monitoringThreadFunc, this) );

}



void NetworkChangeDetection::stopMonitoring(){



        logging_debug( "stopping network change monitoring ..." );



        // trigger the blocking read to end

        running = false;



        shutdown( routingSocket, SHUT_RDWR );

        close( routingSocket );



        // end the monitoring thread

        monitoringThread->join();



        delete monitoringThread;

        monitoringThread = NULL;

}



void NetworkChangeDetection::monitoringThreadFunc(NetworkChangeDetection* obj){



        //

        // Most information about this routing socket interface is available

        // when searching for NETLINK_ROUTE and in http://www.faqs.org/rfcs/rfc3549.html

        // A small program that uses this stuff is ifplugd, nice reference for

        // getting network interface notifications using routing sockets

        // (e.g. http://ifplugd.sourcearchive.com/documentation/0.26/ifmonitor_8c-source.html)

        // And the best resource is the linux code ... http://www.srcdoc.com/linux_2.2.26/rtnetlink_8h-source.html

        // More:

        //      http://m.linuxjournal.com/article/8498

        //      http://lkml.indiana.edu/hypermail/linux/net/0508.2/0016.html

        //      http://infrahip.hiit.fi/hipl/release/1.0.1/hipl.1.0.1/hipd/netdev.c

        //      http://www.google.de/codesearch?hl=de&q=rtmsg_ifinfo+show:Ndy7Mq7IdCw:aylASy5mtF0:ClfaxlLp-PU&source=universal&cs_p=ftp://ftp.kernel.org/pub/linux/kernel/v2.4/linux-2.4.18.tar.gz&cs_f=linux/net/core/rtnetlink.c#l490

        //      http://www.google.com/codesearch?hl=en&q=RTM_NEWADDR+NETLINK_ROUTE+show:eUekvGbF94M:iCwmLwtnVbU:38qoeYp--0A&sa=N&cd=1&ct=rc&cs_p=ftp://ftp.stacken.kth.se/pub/arla/arla-0.42.tar.gz&cs_f=arla-0.42/lib/roken/getifaddrs.c

        //      http://www.google.com/codesearch?hl=en&q=RTMGRP_LINK+rtm_newaddr+nl_groups+show:sUV8mV--Lb4:gk0jx_xv0Yg:ZB9MN7Fgkgg&sa=N&cd=1&ct=rc&cs_p=http://freshmeat.net/redir/strongswan/60428/url_bz2/strongswan-4.1.2.tar.bz2&cs_f=strongswan-4.1.4/src/charon/kernel/kernel_interface.c#l689

        //



        //

        // open the netlink routing socket, don't need raw sockets here!

        //



        obj->routingSocket = socket( PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE );

        if( obj->routingSocket < 0 ){

                logging_error("could not connect to routing socket: " +

                                        string(strerror(errno)));

                return;

        }



        //

        // set a socket read timeout. this is actually bad, but closing

        // the blocking socket using shutdown, close, or writing EOF to

        // the socket did not work. this seems to be a bug related to

        // routing sockets that will not close when in blocking mode

        //



        struct timeval tv;

        tv.tv_sec = 1;

        tv.tv_usec = 0;



        setsockopt( obj->routingSocket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv) );



        //

        // bind the netlink routing socket to our local address

        // for the nl_groups, see http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/include/linux/rtnetlink.h#L520

        // we listen on ipv4/6 new/delete address and link up/down notifications

        //



        struct sockaddr_nl addr;

        memset( &addr, 0, sizeof(addr) );

        addr.nl_family = AF_NETLINK;

        addr.nl_groups = RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_LINK;

        addr.nl_pid    = getpid();



        int ret = bind( obj->routingSocket, (struct sockaddr*)&addr, sizeof(addr) );

        if( ret < 0 ){

                close( obj->routingSocket );

                logging_error( "could not bind routing socket: " + string(strerror(errno)) );

                return;

        }



        //

        // read from the netlink routing socket

        //



        logging_debug( "network change monitoring started" );



        while( obj->running ){



                char buffer[1024];

                struct nlmsghdr* header = (struct nlmsghdr*)buffer;



                int bytesRead = recv( obj->routingSocket, &buffer, sizeof(buffer), 0 );



                if( bytesRead < 0 ){



                        // socket timeout, just continue

                        if( errno == EWOULDBLOCK ) continue;



                        // triggered by shutdown() function in stopMonitoring

                        if( errno == EBADF ) return;



                        // gracefull exit by signals

                        if( errno == EAGAIN || errno == EINTR ) return;



                        // all others are some kind of error

                        logging_error( "could not read from routing socket: " +

                                                        string(strerror(errno)) );

                        break;

                }



                for( ; bytesRead > 0; header = NLMSG_NEXT(header, bytesRead)) {

                        if (    !NLMSG_OK(header, bytesRead) ||

                                (size_t) bytesRead < sizeof(struct nlmsghdr) ||

                                (size_t) bytesRead < header->nlmsg_len) {

                                continue;

                        }



                        //

                        // here we evaluate the routing netlink message. for, the following

                        // messages are of interest:

                        //      RTM_NEWLINK, RTM_DELLINK -> interface up/down

                        //      RTM_NEWADDR, RTM_DELADDR -> new address on iface, address deleted from iface

                        // not interesting are:

                        //      RTM_GETLINK, RTM_GETADDR

                        //      RTM_NEWROUTE, RTM_DELROUTE, RTM_GETROUTE

                        //



                        NetworkChangeInterface::NetworkChangeInfo changeInfo;



                        switch( header->nlmsg_type ){



                                //

                                // handle network interface up/down notifications

                                // --> link layer notifications

                                //



                                case RTM_NEWLINK:

                                case RTM_DELLINK:



                                        changeInfo = obj->extractInterfaceEvent( header );

                                        break;



                                //

                                // handle network address configuration changes

                                // --> network layer notifications

                                //



                                case RTM_NEWADDR:

                                case RTM_DELADDR:



                                        changeInfo = obj->extractAddressEvent( header );

                                        break;



                                //

                                // other RTM message are ignored in case

                                // we did subscribe using nl_groups (see above)

                                //



                                default: break;



                        } // switch( header->nlmsg_type )



                        logging_info( "network change detected: [" << changeInfo << "]" );



                        // put noficiation event into the system queue for main

                        // thread synchronization. will be handled in NetworkChangeDetection::handleSystemEvent()

                        // that will run synchronized with the main thread



                        SystemQueue::instance().scheduleEvent(

                                SystemEvent( obj, NetworkChangeDetectionEventType,

                                        new NetworkChangeInterface::NetworkChangeInfo(changeInfo)));



                } // for( ; bytesRead > 0; header = NLMSG_NEXT(header, bytesRead))

        } // while( running )



        logging_debug( "network change monitoring stopped" );

}



NetworkChangeInterface::NetworkChangeInfo NetworkChangeDetection::extractInterfaceEvent(struct nlmsghdr* header){

        NetworkChangeInterface::NetworkChangeInfo changeInfo;



        //

        // handle network interface up/down notifications

        // the differentiation between up/down is _not_

        // made using new/del-link in the message!

        //



        if( header->nlmsg_type == RTM_NEWLINK ){

                logging_debug("network change message RTM_NEWLINK");

        }else if( header->nlmsg_type == RTM_DELLINK ){

                logging_debug("network change message RTM_DELLINK");

        }



        if( header->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg)) ){

                logging_error( "netlink packet soo small for ifinfomsg" );

                return changeInfo;

        }



        //

        // get the interface index and through this

        // further information about the interface

        //



        struct ifinfomsg* detailIface = (struct ifinfomsg*)NLMSG_DATA(header);

        changeInfo.interface = networkInformation.getInterface( detailIface->ifi_index );



        //

        // check whether device is now up or down

        //



        if( changeInfo.interface.isUp && changeInfo.interface.isRunning )

                changeInfo.type = NetworkChangeInterface::EventTypeInterfaceUp;

        else

                changeInfo.type = NetworkChangeInterface::EventTypeInterfaceDown;





        return changeInfo;

}



NetworkChangeInterface::NetworkChangeInfo NetworkChangeDetection::extractAddressEvent(struct nlmsghdr* header){

        NetworkChangeInterface::NetworkChangeInfo changeInfo;



        //

        // handle network address configuration changes

        // addresses are added/removed from an interface

        //



        if( header->nlmsg_type == RTM_NEWADDR ){

                logging_debug("network change message RTM_NEWADDR");

                changeInfo.type = NetworkChangeInterface::EventTypeAddressNew;

        }else if( header->nlmsg_type == RTM_DELADDR ){

                logging_debug("network change message RTM_DELADDR");

                changeInfo.type = NetworkChangeInterface::EventTypeAddressDelete;

        }



        struct ifaddrmsg* detailAddr = (struct ifaddrmsg*)NLMSG_DATA(header);

        changeInfo.interface = networkInformation.getInterface( detailAddr->ifa_index );



        return changeInfo;

}



void NetworkChangeDetection::handleSystemEvent(const SystemEvent& event){



        NetworkChangeInterface::NetworkChangeInfo* changeInfo = event.getData<NetworkChangeInterface::NetworkChangeInfo>();

        const NetworkChangeDetection* obj = (const NetworkChangeDetection*)event.getListener();



        RegistrationList::const_iterator i = obj->registrations.begin();

        RegistrationList::const_iterator iend = obj->registrations.end();



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

                (*i)->onNetworkChange(*changeInfo);



        delete changeInfo;

}



}} // namespace ariba, communication