ibrcommon/ibrcommon/net/NetInterface.cpp

Go to the documentation of this file.

/*
 * File:   NetInterface.cpp
 * Author: morgenro
 *
 * Created on 12. November 2009, 14:57
 */

#include "ibrcommon/config.h"
#include "ibrcommon/net/NetInterface.h"

#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 <unistd.h>

using namespace std;

namespace ibrcommon
{
        NetInterface::NetInterface(std::string interface)
        : _interface(interface)
        {
        }

        NetInterface::~NetInterface()
        {

        }

        bool NetInterface::operator<(const NetInterface &other) const
        {
                if (_interface < other._interface) return true;
                return false;
        }

        bool NetInterface::operator==(const NetInterface &other) const
        {
                if (_interface == other._interface) return true;
                return false;
        }

        std::string NetInterface::getInterface() const
        {
                return _interface;
        }

        std::string NetInterface::getAddress() const
        {
                return NetInterface::getAddress(_interface);
        }

        std::string NetInterface::getBroadcast() const
        {
                return NetInterface::getBroadcast(_interface);
        }

        void NetInterface::getAddress(struct in_addr *ret) const
        {
                NetInterface::getAddress(_interface, ret);
        }

        void NetInterface::getBroadcast(struct in_addr *ret) const
        {
                NetInterface::getBroadcast(_interface, ret);
        }

        void NetInterface::getAddress(std::string interface, struct in_addr *ret)
        {
                // define the return value
                ret->s_addr = htonl(INADDR_ANY);

                struct ifaddrs *ifap = NULL;
                int status = getifaddrs(&ifap);

                if ((status != 0) || (ifap == NULL))
                {
                                // error, return with default address
                                return;
                }

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

                                sockaddr *addr = iter->ifa_addr;

                                // currently only IPv4 is supported
                                if (addr->sa_family != AF_INET) continue;

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

                                sockaddr_in *ip = (sockaddr_in*)iter->ifa_addr;

                                ret->s_addr = ip->sin_addr.s_addr;
                                break;
                }

                freeifaddrs(ifap);
        }

        void NetInterface::getBroadcast(std::string interface, struct in_addr *ret)
        {
                // define the return value
                ret->s_addr = htonl(INADDR_BROADCAST);

                struct ifaddrs *ifap = NULL;
                int status = getifaddrs(&ifap);

                if ((status != 0) || (ifap == NULL))
                {
                                // error, return with default address
                                return;
                }

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

                                sockaddr *addr = iter->ifa_addr;

                                // currently only IPv4 is supported
                                if (addr->sa_family != AF_INET) continue;

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

                                if (iter->ifa_flags & IFF_BROADCAST)
                                {
                                                sockaddr_in *broadcast = (sockaddr_in*)iter->ifa_broadaddr;
                                                ret->s_addr = broadcast->sin_addr.s_addr;
                                                break;
                                }
                }

                freeifaddrs(ifap);
        }

        std::string NetInterface::getAddress(std::string interface)
        {
                struct in_addr addr;
                NetInterface::getAddress(interface, &addr);
                return string(inet_ntoa(addr));
        }

        std::string NetInterface::getBroadcast(std::string interface)
        {
                struct in_addr addr;
                NetInterface::getBroadcast(interface, &addr);
                return string(inet_ntoa(addr));
        }
}

---