NetInterface.cpp

Go to the documentation of this file.

#include <ifaddrs.h>

#include "NetInterface.h"

namespace castor { namespace net {

        NetInterface::NetInterface(const std::string name) :
                name(name), addresses(), addressesb()
        {
        }

        NetInterface::NetInterface(const NetInterface &copy) :
                name(copy.name), addresses(copy.addresses), addressesb(copy.addressesb)
        {
        }

        std::string NetInterface::getName() const {
                return this->name;
        }

        NetAddressPtrSet NetInterface::getAddresses() const {
                return this->addresses;
        }

        NetAddressPtrSet NetInterface::getBroadcastAddresses() const {
                return this->addressesb;
        }

        void NetInterface::addAddress(const NetAddress &address) {

                NetAddressPtr copy(new NetAddress(address));

                if (this->addresses.find(copy) == this->addresses.end()) {
                        this->addresses.insert(copy);
                }
        }

        void NetInterface::addBroadcastAddress(const NetAddress &address) {

                NetAddressPtr copy(new NetAddress(address));

                if (this->addressesb.find(copy) == this->addressesb.end()) {
                        this->addressesb.insert(copy);
                }
        }

        bool NetInterface::contains(const NetAddress &address) {

                NetAddressPtr copy(new NetAddress(address));

                return (this->addresses.find(copy) != this->addresses.end());
        }

        bool NetInterface::matches(const NetAddress &address) {

                for (NetAddressPtrSet::iterator itr = this->addresses.begin();
                         itr != this->addresses.end(); itr++)
                {
                        if ((*itr)->sameScope(address)) {
                                return true;
                        }
                }

                return false;
        }

        typedef std::map<std::string, NetInterfacePtr> InterfaceMap;

        NetInterfacePtrList NetInterface::getInterfaces() {

                NetInterfacePtrList result;

                ifaddrs *myaddrs;
                ifaddrs *ifa;

                int status = getifaddrs(&myaddrs);

                if (status) {
                        throw Exception("error getting local interface addresses: %s", strerror(status));
                }

                InterfaceMap ifaces;

                for (ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next) {

                        if (ifa->ifa_addr == NULL) continue;

                        if ((ifa->ifa_flags & IFF_UP) == 0) continue;

                        std::string ifaceName(ifa->ifa_name);

                        NetInterfacePtr iface;

                        InterfaceMap::iterator itr = ifaces.find(ifaceName);

                        if (itr == ifaces.end()) {
                                iface = NetInterfacePtr(new NetInterface(ifaceName));
                                ifaces[ifaceName] = iface;
                        } else {
                                iface = itr->second;
                        }

                        NetAddress address;
                        NetAddress addressb_;

                        if (ifa->ifa_addr->sa_family == AF_INET) {

                                sockaddr_in *sa = (sockaddr_in *)(ifa->ifa_addr);
                                sockaddr_in *sab = (sockaddr_in *)(ifa->ifa_broadaddr);

                                boost::array<unsigned char, 4> buffer;
                                for (int i = 0; i < 4; i++) buffer[i] = ((unsigned char *)&sa->sin_addr)[i];

                                boost::array<unsigned char, 4> bufferb;
                                for (int i = 0; i < 4; i++) bufferb[i] = ((unsigned char *)&sab->sin_addr)[i];

                                address = NetAddress(asio::ip::address_v4(buffer));
                                NetAddress addressb = NetAddress(asio::ip::address_v4(bufferb));
                                addressb_ = addressb;

                                iface->addBroadcastAddress(addressb);

                        } else if (ifa->ifa_addr->sa_family == AF_INET6) {

                                sockaddr_in6 *sa = (sockaddr_in6 *)(ifa->ifa_addr);
                                sockaddr_in6 *sab = (sockaddr_in6 *)(ifa->ifa_broadaddr);

                                boost::array<unsigned char, 16> buffer;
                                for (int i = 0; i < 16; i++) buffer[i] = ((unsigned char *)&sa->sin6_addr)[i];

                                boost::array<unsigned char, 16> bufferb;
                                for (int i = 0; i < 16; i++) bufferb[i] = ((unsigned char *)&sab->sin6_addr)[i];

                                address = NetAddress(asio::ip::address_v6(buffer, sa->sin6_scope_id));

                        } else {
                                continue;
                        }

                        iface->addAddress(address);

                }

                for (InterfaceMap::iterator itr = ifaces.begin();
                         itr != ifaces.end(); itr++)
                {
                        result.push_back(itr->second);
                }

                freeifaddrs(myaddrs);

                return result;
        }

        NetInterfacePtr NetInterface::getDefaultRoute() {
                char buf[256];
                FILE *fp = fopen("/proc/net/route", "r");

                if (!fp) {
                        return NetInterfacePtr();
                }

                if (fgets(buf, sizeof(buf), fp)) {
                        // do nothing
                }

                while (fgets(buf, sizeof(buf), fp)) {
                        char iface[256];
                        unsigned int dest;
                        unsigned int gateway;
                        unsigned int flags;
                        unsigned int refcnt;
                        unsigned int use;
                        unsigned int metric;
                        unsigned int mask;
                        unsigned int mtu;
                        unsigned int window;
                        unsigned int irtt;

                        if (sscanf(buf, "%s%08x%08x%04x%d%d%d%08x%d%d%d", iface,
                                           &dest, &gateway, &flags, &refcnt, &use,
                                           &metric, &mask, &mtu, &window, &irtt) != 11)
                        {
                                continue;
                        }

                        if (dest != 0) {
                                continue;
                        }
                
                        std::string ifaceStr(iface);
                        NetInterfacePtrList ifaces = getInterfaces();

                        for (NetInterfacePtrList::iterator itr = ifaces.begin();
                                 itr != ifaces.end(); itr++)
                        {
                                if ((*itr)->getName() == ifaceStr) {
                                        return *itr;
                                }
                        }
                }

                return NetInterfacePtr();
        }

        NetInterfacePtr NetInterface::getDefaultRoute6() {
                std::cout << "NetInterface::getDefaultRoute6() not implemented!" << std::endl;
                return NetInterfacePtr();
        }

        std::string NetInterface::str() const {

                std::ostringstream ss;

                ss << this->name << ":";

                for (NetAddressPtrSet::iterator itr = this->addresses.begin();
                         itr != this->addresses.end(); itr++)
                {
                        ss << " " << **itr;
                }

                return ss.str();
        }

        bool operator<(const NetInterface &one, const NetInterface &other) {
                return (one.name < other.name);
        }

} }