EtherSocket.cpp

/*
** libutil++
** $Id: EtherSocket.cpp 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 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: EtherSocket.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "EtherSocket.h"
#include "../util/Interface.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <net/if.h>
#include <net/ethernet.h>

using namespace sella::net;
using namespace sella::util;

const unsigned char EtherSocket::BroadcastMAC[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

EtherSocket::EtherSocket(int etherType, const std::string &interface, bool raw) throw (SocketException) :
        Socket(AF_PACKET, (raw) ? SOCK_RAW : SOCK_DGRAM, htons(etherType)),
        etherType(etherType),
        raw(raw)
{
        try {
                ifIndex = Interface::getIndex(interface);

        } catch (InterfaceException &e) {
                RETHROW(SocketException, e);
        }
}

EtherSocket::EtherSocket(int etherType, int ifIndex, bool raw) throw (SocketException) :
        Socket(AF_PACKET, (raw) ? SOCK_RAW : SOCK_DGRAM, htons(etherType)),
        etherType(etherType),
        ifIndex(ifIndex),
        raw(raw)
{ }

EtherSocket::EtherSocket(int etherType, bool raw) throw (SocketException) :
        Socket(AF_PACKET, (raw) ? SOCK_RAW : SOCK_DGRAM, htons(etherType)),
        etherType(etherType),
        ifIndex(-1),
        raw(raw)
{ }

EtherSocket::~EtherSocket() {
}

const EtherSocket::shared EtherSocket::shared_ptr(int etherType) throw (SocketException) {
        return std::make_shared<EtherSocket>(etherType);
}

EtherSocket& EtherSocket::setInterface(const std::string &interface) throw (SocketException) {
        if ((ifIndex = if_nametoindex(interface.c_str())) == 0) {
                THROW2(SocketException, "if_nametoindex()");
        }

        return *this;
}

EtherSocket& EtherSocket::setIfIndex(int ifIndex) throw () {
        this->ifIndex = ifIndex;

        return *this;
}

int EtherSocket::getEtherType(void) const throw () {
        return etherType;
}

std::string EtherSocket::getInterface(void) const throw (SocketException) {
        char buf[IF_NAMESIZE];

        if (ifIndex == -1) {
                THROW(SocketException, "Interface or index must be set prior to getInterface()");
        }

        if (if_indextoname(ifIndex, buf) == NULL) {
                THROW2(SocketException, "if_indextoname()");
        }

        return buf;
}

int EtherSocket::getIfIndex(void) const throw () {
        return ifIndex;
}

bool EtherSocket::isRaw(void) const throw () {
        return raw;
}

void EtherSocket::bindInterface(void) throw (SocketException) {
        sockaddr_ll sll;
        socklen_t addrlen = sizeof(sockaddr_ll);

        if (ifIndex == -1) {
                THROW(SocketException, "Interface or index must be set prior to bindInterface()");
        }

        sll.sll_family = AF_PACKET;
        sll.sll_ifindex = ifIndex;
        sll.sll_protocol = htons(etherType);

        if (::bind(s, (sockaddr*) &sll, addrlen) < 0) {
                THROW2(SocketException, "bind()");
        }
}

void EtherSocket::setSoBindToDevice(const std::string &interface) throw (SocketException) {
        Socket::setSoBindToDevice(interface);
}

void EtherSocket::setSoBindToDevice(void) throw (SocketException) {
        Socket::setSoBindToDevice(getInterface());
}

void EtherSocket::setPromiscous(bool on) throw (SocketException) {
        struct ifreq ifr;

        if (ifIndex == -1) {
                THROW(SocketException, "Interface or index must be set prior to setPromiscous()");
        }

        const std::string &name = getInterface();
        memset(&ifr, 0, sizeof(ifr));

        strncpy(ifr.ifr_name, name.c_str(), name.size());

        if (ioctl(s, SIOCGIFFLAGS, &ifr) < 0) {
                THROW2(SocketException, "ioctl()");
        }

        if (on) {
                ifr.ifr_flags |= IFF_PROMISC;
        } else {
                ifr.ifr_flags &= ~IFF_PROMISC;
        }

        if (ioctl(s, SIOCSIFFLAGS, &ifr) < 0) {
                THROW2(SocketException, "ioctl()");
        }
}

ssize_t EtherSocket::sendto(const void *data, size_t len, const std::string &dst_mac, int flags) throw (SocketException) {
        unsigned char addr[6] = { 0, 0, 0, 0, 0, 0 };

        try {
                Interface::convertMAC(addr, dst_mac);
        } catch (InterfaceException &e) {
                RETHROW(SocketException, e);
        }

        return sendto(data, len, addr, flags);
}

ssize_t EtherSocket::sendto(const void *data, size_t len, const unsigned char *dst_mac, int flags) throw (SocketException) {
        sockaddr_ll dest_addr = { 0 };
        socklen_t addrlen = sizeof(sockaddr_ll);

        if (ifIndex == -1) {
                THROW(SocketException, "Interface must be set prior to sendto()");
        }

        dest_addr.sll_family = AF_PACKET;
        dest_addr.sll_ifindex = ifIndex;
        dest_addr.sll_halen = ETHER_ADDR_LEN;
        dest_addr.sll_protocol = htons(etherType);
        memcpy(dest_addr.sll_addr, dst_mac, ETHER_ADDR_LEN);

        return sendto(data, len, flags, (const struct sockaddr_ll*) &dest_addr, addrlen);
}

ssize_t EtherSocket::sendto(const void *data, size_t len, int flags, const sockaddr_ll *dest_addr, socklen_t addrlen) throw (SocketException) {
        ssize_t c, r = len;

        do {
                if ((c = ::sendto(s, data, len, flags, (const struct sockaddr*) dest_addr, addrlen)) < 0) {
                        switch (errno) {
                                case EINTR:
                                case EAGAIN:
                                case EMSGSIZE:
                                case ENOBUFS:
                                        break;

                                default:
                                        usable = false;
                        }

                        THROW2(SocketException, "sendto()");
                } else if (c == 0) {
                        usable = false;
                }
        } while ((r -= c) > 0);

        write = false;

        return len;
}

ssize_t EtherSocket::recvfrom(void *data, size_t len, int flags, sockaddr_ll *src_addr, socklen_t *addrlen) throw (SocketException) {
        ssize_t c;

        if ((c = ::recvfrom(s, data, len, flags, (sockaddr*) src_addr, addrlen)) < 0) {
                switch (errno) {
                        case EINTR:
                        case EAGAIN:
                                break;

                        default:
                                usable = false;
                }

                THROW2(SocketException, "recv()");
        } else if (c == 0) {
                usable = false;
        }

        read = except = false;

        return c;
}

ssize_t EtherSocket::recvfrom(void *data, size_t len, std::string &src_mac, int flags) throw (SocketException) {
        sockaddr_ll src_addr;
        socklen_t addrlen = sizeof(sockaddr_ll);
        ssize_t c;

        if ((c = recvfrom(data, len, flags, (sockaddr_ll*) &src_addr, &addrlen)) > 0) {
                Interface::convertMAC(src_mac, (const unsigned char*) src_addr.sll_addr);
        } else {
                src_mac.clear();
        }

        return c;
}

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