/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/Interface.cpp

/*
** libutil++
** $Id: Interface.cpp 1230 2014-11-16 02:32:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Interface.cpp 1230 2014-11-16 02:32:01Z sella $";

#include "Interface.h"
#include "../net/IPAddress.h"
#include "CommonMacro.h"

#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <sys/types.h>
#include <netpacket/packet.h>


#include <string>

#define inaddrr(x) (*(struct in_addr *) &ifr->x[sizeof(sa.sin_port)])
#define IFRSIZE ((int)(size * sizeof(struct ifreq)))

namespace sn = sella::net;
using namespace sella::util;

void Interface::setPromiscous(const std::string &interface, bool on) throw (InterfaceException) {
        int s;
        struct ifreq ifr;
        size_t len = interface.size();
        struct packet_mreq mr;

        if (len < sizeof(ifr.ifr_name)) {
                memcpy(ifr.ifr_name, interface.c_str(), len);
                ifr.ifr_name[len] = 0;
        } else {
                THROW(InterfaceException, "Interface name '%s' is too long", interface.c_str());
        }

        if ((s = socket(AF_PACKET, SOCK_DGRAM, IPPROTO_IP)) == -1) {
                THROW2(InterfaceException, "socket()");
        }

        if (ioctl(s, SIOCGIFINDEX, &ifr) == -1) {
                close(s);

                THROW2(InterfaceException, "ioctl()");
        }

        memset(&mr, 0, sizeof(mr));
        mr.mr_ifindex = ifr.ifr_ifindex;
        mr.mr_type = PACKET_MR_PROMISC;

        if (setsockopt(s, SOL_PACKET, (on) ? PACKET_ADD_MEMBERSHIP : PACKET_DROP_MEMBERSHIP, &mr, sizeof(mr)) < 0) {
                close(s);

                THROW2(InterfaceException, "setsockopt()");
        }

        close(s);
}

sn::IPAddress::shared_list Interface::getIPAddresses(const std::string &interface, const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        struct ifaddrs *ifas, *ifa = NULL;
        sn::IPAddress::shared_list addresses;
        sn::IPAddress::shared address;
        int family;

        if (getifaddrs(&ifas) == -1) {
                THROW(InterfaceException, "Failed to retrieve interfaces");
        }

        for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {
                if (((ifa->ifa_flags & ifrFlagMatch) == 0 && ifrFlagMatch != 0) || (ifa->ifa_flags & ifrFlagReject) != 0) {
                        continue;
                }

                if (ifa->ifa_addr != NULL) {
                        if (!interface.empty() && interface.compare(ifa->ifa_name)) {
                                continue;
                        }

                        family = ifa->ifa_addr->sa_family;
                        if (family == AF_INET || family == AF_INET6) {
                                address = sn::IPAddress::shared_ptr(ifa->ifa_addr);
                                addresses.push_back(address);
                        }
                }
        }
        freeifaddrs(ifas);

        addresses.sort();
        addresses.unique();

        return addresses;
}

sn::IPAddress::shared_list Interface::getInterfaceIPAddresses(const std::string &interface, const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        return getIPAddresses(interface, ifrFlagMatch, ifrFlagReject);
}

sella::net::IPAddress Interface::getIPAddress(const std::string &interface, int family) throw (InterfaceException) {
        struct ifaddrs *ifas, *ifa = NULL;
        sn::IPAddress address;

        if (getifaddrs(&ifas) == -1) {
                THROW(InterfaceException, "Failed to retrieve interfaces");
        }

        for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {
                if (ifa->ifa_addr != NULL) {
                        if (!interface.empty() && interface.compare(ifa->ifa_name)) {
                                continue;
                        }

                        if (ifa->ifa_addr->sa_family == family) {
                                address = sn::IPAddress(ifa->ifa_addr);

                                break;
                        }
                }
        }
        freeifaddrs(ifas);

        return address;
}

std::list<std::string> Interface::getNames(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        struct ifaddrs *ifas, *ifa = NULL;
        std::list<std::string> interfaces;
        std::list<std::string>::iterator it;

        if (getifaddrs(&ifas) == -1) {
                THROW2(InterfaceException, "getifaddrs()");
        }

        for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {
                if (((ifa->ifa_flags & ifrFlagMatch) == 0 && ifrFlagMatch != 0) || (ifa->ifa_flags & ifrFlagReject) != 0) {
                        continue;
                }

//              if (ifa->ifa_addr != NULL) {
                        interfaces.push_back(ifa->ifa_name);
//              }
        }
        freeifaddrs(ifas);

        interfaces.sort();
        interfaces.unique();

        return interfaces;
}

std::list<std::string> Interface::getInterfaceNames(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        return getNames(ifrFlagMatch, ifrFlagReject);
}

std::list<std::string> Interface::getEthernetNames(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        struct ifaddrs *ifas, *ifa = NULL;
        std::list<std::string> interfaces;
        std::list<std::string>::iterator it;

        if (getifaddrs(&ifas) == -1) {
                THROW2(InterfaceException, "getifaddrs()");
        }

        for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {
                if (((ifa->ifa_flags & ifrFlagMatch) == 0 && ifrFlagMatch != 0) || (ifa->ifa_flags & ifrFlagReject) != 0) {
                        continue;
                } else if (!isEthernet(ifa->ifa_name)) {
                        continue;
                }

                interfaces.push_back(ifa->ifa_name);
        }
        freeifaddrs(ifas);

        interfaces.sort();
        interfaces.unique();

        return interfaces;
}

std::string Interface::getMAC(const std::string &interface) throw (InterfaceException) {
        int s;
        struct ifreq ifr;
        unsigned char none[6] = { 0, 0, 0, 0, 0, 0 };
        char mac[19];

        if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1) {
                THROW2(InterfaceException, "socket()");
        }

        strcpy(ifr.ifr_name, interface.c_str());

        if (ioctl(s, SIOCGIFHWADDR, &ifr) == -1) {
                THROW2(InterfaceException, "ioctl()");
        }

        if (memcmp(ifr.ifr_hwaddr.sa_data, none, sizeof(none)) == 0) {
                THROW(InterfaceException, "Interface %s has no MAC", interface.c_str());
        }

        unsigned char *m = (unsigned char*) ifr.ifr_hwaddr.sa_data;
        snprintf(mac, sizeof(mac), "%02X:%02X:%02X:%02X:%02X:%02X", m[0], m[1], m[2], m[3], m[4], m[5]);

        return mac;
}

std::string Interface::getInterfaceMAC(const std::string &interface) throw (InterfaceException) {
        return getMAC(interface);
}

std::list<std::string> Interface::getMACs(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        int s;
        struct ifreq ifr;
        unsigned char none[6] = { 0, 0, 0, 0, 0, 0 };
        char mac[19];
        std::list<std::string> macs;
        auto interfaces = getNames(ifrFlagMatch, (ifrFlagReject | IFF_LOOPBACK));

        if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1) {
                THROW2(InterfaceException, "socket()");
        }

        for (auto it = interfaces.begin(); it != interfaces.end(); ++it) {
                strcpy(ifr.ifr_name, it->c_str());

                if (ioctl(s, SIOCGIFHWADDR, &ifr) == -1) {
                        THROW2(InterfaceException, "ioctl()");
                }

                if (memcmp(ifr.ifr_hwaddr.sa_data, none, sizeof(none)) == 0) {
                        continue;
                }

                unsigned char *m = (unsigned char*) ifr.ifr_hwaddr.sa_data;
                snprintf(mac, sizeof(mac), "%02X:%02X:%02X:%02X:%02X:%02X", m[0], m[1], m[2], m[3], m[4], m[5]);

                macs.push_back(mac);
        }

        macs.sort();
        macs.unique();

        return macs;
}

std::list<std::string> Interface::getInterfaceMACs(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        return getMACs(ifrFlagMatch, ifrFlagReject);
}

void Interface::getInterfaceAddr(const std::string &interface, struct in_addr *ip) throw (InterfaceException) {
        getAddr(interface, ip);
}

// Adapted from newsgroup example by Floyd Davidson (floyd@ptialaska.net) on 2002-07-16 04:50:07 PST
struct in_addr* Interface::getAddr(const std::string &interface, struct in_addr *ip) throw (InterfaceException) {
        int s, size = 1;
        struct ifreq *ifr;
        struct ifconf ifc;
        struct sockaddr_in sa;
        struct ifreq *tmp;

        if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1) {
                THROW2(InterfaceException, "socket()");
        }

        ifc.ifc_len = IFRSIZE;
        ifc.ifc_req = NULL;

        do {
                ++size;
                /* realloc buffer size until no overflow occurs  */
                if (NULL == (tmp = (struct ifreq*) realloc(ifc.ifc_req, IFRSIZE))) {
                        SAFE_FREE(ifc.ifc_req); /* Free memory. */
                        close(s);

                        THROW(InterfaceException, "Failed to realloc");
                }

                ifc.ifc_req = tmp;
                ifc.ifc_len = IFRSIZE;

                if (ioctl(s, SIOCGIFCONF, &ifc)) {
                        SAFE_FREE(ifc.ifc_req); /* Free memory. */
                        close(s);

                        THROW2(InterfaceException, "ioctl()");
                }
        } while (IFRSIZE <= ifc.ifc_len);

        ifr = ifc.ifc_req;
        for (;(char *) ifr < (char *) ifc.ifc_req + ifc.ifc_len; ++ifr) {

                if (ifr->ifr_addr.sa_data == (ifr + 1)->ifr_addr.sa_data) {
                        continue;  /* duplicate, skip it */
                }

                if (ioctl(s, SIOCGIFFLAGS, ifr)) {
                        continue;  /* failed to get flags, skip it */
                }

                if (strncmp(ifr->ifr_name, "lo", 2) && (interface.empty() || !strcmp(ifr->ifr_name, interface.c_str()))) {
#ifndef USE_ORIGINAL /* Work around for: "warning: dereferencing type-punned pointer will break strict-aliasing rules" */
                        union {
                                char c;
                                struct in_addr addr;
                        } u;

                        u.c = ifr->ifr_addr.sa_data[sizeof(sa.sin_port)];
                        *ip = u.addr;
#else
                        *ip = inaddrr(ifr_addr.sa_data);
#endif

#if 0
                        fprintf(stderr, "Interface: %s\n", ifr->ifr_name);
                        fprintf(stderr, "IP Address: %s\n", inet_ntoa(*ip));
#endif

                        break;
                }
        }

        SAFE_FREE(ifc.ifc_req); /* Free memory. */
        close(s);

        return ip;
}

unsigned int Interface::getIndex(const std::string &interface) throw (InterfaceException) {
#define USE_NAMETOINDEX
#ifdef USE_NAMETOINDEX
        unsigned int index;

        if ((index = if_nametoindex(interface.c_str())) > 0) {
                return index;
        }

        THROW2(InterfaceException, "if_nametoindex()");
#else
        int s;
        struct ifreq ifr;
        size_t len = interface.size();

        if (len < sizeof(ifr.ifr_name)) {
                memcpy(ifr.ifr_name, interface.c_str(), len);
                ifr.ifr_name[len] = 0;
        } else {
                THROW(InterfaceException, "Interface name '%s' is too long", interface.c_str());
        }

        if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1) {
                THROW2(InterfaceException, "socket()");
        }

        if (ioctl(s, SIOCGIFINDEX, &ifr) == -1) {
                close(s);

                THROW2(InterfaceException, "ioctl()");
        }

        close(s);

        return ifr.ifr_ifindex;
#endif
}

std::string Interface::getName(unsigned int index) throw (InterfaceException) {
        char buf[IF_NAMESIZE];

        if (if_indextoname(index, buf) != NULL) {
                return std::string(buf);
        }

        THROW2(InterfaceException, "if_indextoname()");
}

unsigned char* Interface::convertMAC(unsigned char dst[6], const std::string &mac) throw (InterfaceException) {
        if (mac.size() == 17) {
                if ((mac[2] != ':' && mac[2] != '-') || (mac[5] != ':' && mac[5] != '-') || (mac[8] != ':' && mac[8] != '-') || (mac[11] != ':' && mac[11] != '-') || (mac[14] != ':' && mac[14] != '-')) {
                        THROW(InterfaceException, "Invalid MAC address '%s'", mac.c_str());
                }

                if (sscanf(mac.c_str(), "%2hhx%*[-:]%2hhx%*[-:]%2hhx%*[-:]%2hhx%*[-:]%2hhx%*[-:]%2hhx", &dst[0], &dst[1], &dst[2], &dst[3], &dst[4], &dst[5]) == 6) {
                        return dst;
                }
        } else if (mac.size() == 12) {
                if (sscanf(mac.c_str(), "%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx", &dst[0], &dst[1], &dst[2], &dst[3], &dst[4], &dst[5]) == 6) {
                        return dst;
                }
        }

        THROW(InterfaceException, "Invalid MAC address '%s'", mac.c_str());
}

std::string& Interface::convertMAC(std::string &dst, const unsigned char mac[6], char delim) throw (InterfaceException) {
        char buf[4];

        if (delim > 0 && delim < 32 && delim > 127) {
                THROW(InterfaceException, "Invalid MAC delim");
        }

        dst.clear();

        for (size_t i = 0; i < 6; i++) {
                if (delim > 0 && i > 0) {
                        dst.push_back(delim);
                }

                snprintf(buf, sizeof(buf), "%02X", mac[i]);

                dst += buf;
        }

        return dst;
}

unsigned char* Interface::convertMAC(unsigned char dst[6], const uint64_t mac) throw (InterfaceException) {
        dst[0] = 0x000000ff & (mac >> 40);
        dst[1] = 0x000000ff & (mac >> 32);
        dst[2] = 0x000000ff & (mac >> 24);
        dst[3] = 0x000000ff & (mac >> 16);
        dst[4] = 0x000000ff & (mac >> 8);
        dst[5] = 0x000000ff & mac;

        return dst;
}

uint64_t& Interface::convertMAC(uint64_t &dst, const unsigned char mac[6]) throw (InterfaceException) {
        dst = uint64_t(mac[0]) << 40 | uint64_t(mac[1]) << 32 | uint64_t(mac[2]) << 24 | uint64_t(mac[3]) << 16 | uint64_t(mac[4]) << 8 | uint64_t(mac[5]);

        return dst;
}

std::string& Interface::convertMAC(std::string &dst, const uint64_t mac) throw (InterfaceException) {
        unsigned char addr[6];

        convertMAC(addr, mac);

        return convertMAC(dst, addr);
}

uint64_t& Interface::convertMAC(uint64_t &dst, const std::string &mac) throw (InterfaceException) {
        unsigned char addr[6];

        convertMAC(addr, mac);

        return convertMAC(dst, addr);
}

bool Interface::isEthernet(const std::string &interface) throw (InterfaceException) {
        int s;
        struct ifreq ifr;
        unsigned char none[6] = { 0, 0, 0, 0, 0, 0 };

        if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1) {
                THROW2(InterfaceException, "socket()");
        }

        strcpy(ifr.ifr_name, interface.c_str());

        if (ioctl(s, SIOCGIFHWADDR, &ifr) == -1) {
                THROW2(InterfaceException, "ioctl()");
        }

        if (memcmp(ifr.ifr_hwaddr.sa_data, none, sizeof(none)) == 0) {
                return false;
        }

        return true;
}

unsigned char* Interface::parseMAC(const std::string &mac, unsigned char addr[6]) throw (InterfaceException) {
        if (mac.size() == 17) {
                if ((mac[2] != ':' && mac[2] != '-') || (mac[5] != ':' && mac[5] != '-') || (mac[8] != ':' && mac[8] != '-') || (mac[11] != ':' && mac[11] != '-') || (mac[14] != ':' && mac[14] != '-')) {
                        THROW(InterfaceException, "Invalid MAC address '%s'", mac.c_str());
                }

                if (sscanf(mac.c_str(), "%2hhx%*[-:]%2hhx%*[-:]%2hhx%*[-:]%2hhx%*[-:]%2hhx%*[-:]%2hhx", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]) == 6) {
                        return addr;
                }
        } else if (mac.size() == 12) {
                if (sscanf(mac.c_str(), "%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]) == 6) {
                        return addr;
                }
        }

        THROW(InterfaceException, "Invalid MAC address '%s'", mac.c_str());
}

sn::IPAddress::shared_list Interface::interfaceIPAddressList(const std::string &interface, const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        return getIPAddresses(interface, ifrFlagMatch, ifrFlagReject);
}

std::list<std::string> Interface::interfaceNameList(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        return getNames(ifrFlagMatch, ifrFlagReject);
}

std::list<std::string> Interface::interfaceMACList(const unsigned int ifrFlagMatch, const unsigned int ifrFlagReject) throw (InterfaceException) {
        return getMACs(ifrFlagMatch, ifrFlagReject);
}

void Interface::source_ip(char *interface, struct in_addr *ip) throw (InterfaceException) {
        getAddr(interface, ip);
}

/*
** vim: noet ts=3 sw=3
*/

---