ibrcommon/ibrcommon/net/LinkManager.cpp

Go to the documentation of this file.

/*
 * LinkManager.cpp
 *
 *  Created on: 21.12.2010
 *      Author: morgenro
 */

#include "ibrcommon/config.h"
#include "ibrcommon/net/LinkManager.h"
#include <list>
#include <string>
#include <typeinfo>

#ifdef HAVE_LIBNL
#include "ibrcommon/net/NetLinkManager.h"
#else
#include <sys/types.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#include <stdlib.h>
#include <net/if.h>
#include <ifaddrs.h>
#include <errno.h>
#include <string.h>
#endif

namespace ibrcommon
{
        LinkManager& LinkManager::getInstance()
        {
#ifdef HAVE_LIBNL
                static NetLinkManager lm;
#else
                static DefaultLinkManager lm;
#endif

                return lm;
        }

        void LinkManager::initialize()
        {
#ifdef HAVE_LIBNL
                try {
                        dynamic_cast<NetLinkManager&>(getInstance()).start();
                } catch (const std::bad_cast&) {

                }
#endif
        }

        DefaultLinkManager::DefaultLinkManager()
        {
        }

        DefaultLinkManager::~DefaultLinkManager()
        {
        }

        const std::string DefaultLinkManager::getInterface(int index) const
        {
#ifdef HAVE_LIBNL
                throw ibrcommon::Exception("not implemented - use NetlinkManager instead");
#else
                struct ifaddrs *ifap = NULL;
                int status = getifaddrs(&ifap);
                int i = 0;
                std::string ret;

                if ((status != 0) || (ifap == NULL))
                {
                                // error, return with default address
                                throw ibrcommon::Exception("can not iterate through interfaces");
                }

                for (struct ifaddrs *iter = ifap; iter != NULL; iter = iter->ifa_next, i++)
                {
                        if (index == i)
                        {
                                ret = iter->ifa_name;
                                break;
                        }
                }

                freeifaddrs(ifap);

                return ret;
#endif
        }

#ifndef HAVE_LIBNL
        char *get_ip_str(const struct sockaddr *sa, char *s, size_t maxlen)
        {
                switch(sa->sa_family) {
                        case AF_INET:
                                inet_ntop(AF_INET, &(((struct sockaddr_in *)sa)->sin_addr),
                                                s, maxlen);
                                break;

                        case AF_INET6:
                                inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)sa)->sin6_addr),
                                                s, maxlen);
                                break;

                        default:
                                strncpy(s, "Unknown AF", maxlen);
                                return NULL;
                }

                return s;
        }

        int get_scope_id(struct sockaddr *sa)
        {
                switch(sa->sa_family)
                {
                        case AF_INET6:
                        {
                                struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
                                return sin6->sin6_scope_id;
                        }

                        case AF_INET:
                        {
                                return 0;
                        }

                        default:
                        {
                                return 0;
                        }
                }
        }
#endif

        const std::list<vaddress> DefaultLinkManager::getAddressList(const vinterface &iface, const vaddress::Family f)
        {
                std::list<vaddress> ret;

#ifndef HAVE_LIBNL
                struct ifaddrs *ifap = NULL;
                int status = getifaddrs(&ifap);
                int i = 0;

                if ((status != 0) || (ifap == NULL))
                {
                                // error, return with default address
                                throw ibrcommon::Exception("can not iterate through interfaces");
                }

                for (struct ifaddrs *iter = ifap; iter != NULL; iter = iter->ifa_next, i++)
                {
                                if (iter->ifa_addr == NULL) continue;
                                if ((iter->ifa_flags & IFF_UP) == 0) continue;

                                // cast to a sockaddr
                                sockaddr *addr = iter->ifa_addr;

                                // compare the address family
                                if ((f != vaddress::VADDRESS_UNSPEC) && (addr->sa_family != f)) continue;

                                // check the name of the interface
                                if (string(iter->ifa_name).compare(iface.toString()) != 0) continue;

                                char buf[INET6_ADDRSTRLEN+5];
                                char *name = get_ip_str(iter->ifa_addr, buf, INET6_ADDRSTRLEN+5);

                                if (name != NULL)
                                {
                                        std::string name_str(name);
                                        if (get_scope_id(addr) == 0)
                                        {
                                                ret.push_back(
                                                                vaddress(vaddress::Family(iter->ifa_addr->sa_family), name_str)
                                                                );
                                        }
                                        else
                                        {
                                                ret.push_back(
                                                                vaddress(vaddress::Family(iter->ifa_addr->sa_family), name_str, i)
                                                                );
                                        }
                                }


                }
                freeifaddrs(ifap);
#endif

                return ret;
        }
}