EtherSocket.h

/*
** libutil++
** $Id: EtherSocket.h 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
*/

#ifndef __libutilxx__sella__net__EtherSocket_H__
#define __libutilxx__sella__net__EtherSocket_H__

#include "../../common.h"
#include "Socket.h"

#include <sys/socket.h>

#include <linux/if_ether.h>
#include <linux/if_packet.h>

namespace sella {
        namespace net {
                class EtherSocket;
        }
}

class sella::net::EtherSocket : public Socket {
        public:
                typedef std::shared_ptr<EtherSocket> shared;
                typedef EtherSocket *ptr;

                /* NOTE: Full list in <linux/if_ether.h> */
                static const int EthAll         = ETH_P_ALL;            /* 0x0003 */
                static const int EthIP          = ETH_P_IP;                     /* 0x8000 */
                static const int EthARP         = ETH_P_ARP;            /* 0x0806 */
                static const int EthRARP        = ETH_P_RARP;           /* 0x8035 */
                static const int Eth8021Q       = ETH_P_8021Q;          /* 0x8100 */
                static const int EthMPLSUC      = ETH_P_MPLS_UC;        /* 0x8847 */
                static const int EthMPLSMC      = ETH_P_MPLS_MC;        /* 0x8848 */

                static const unsigned char BroadcastMAC[];

        public:
                EtherSocket(int etherType, const std::string &interface, bool raw = false) throw (SocketException);
                EtherSocket(int etherType, int ifIndex, bool raw = false) throw (SocketException);
                EtherSocket(int etherType, bool raw = false) throw (SocketException);
                EtherSocket(const EtherSocket &sock) = delete;
                virtual ~EtherSocket();
                void operator=(const EtherSocket &sock) = delete;

                static const EtherSocket::shared shared_ptr(int etherType) throw (SocketException);

                EtherSocket& setInterface(const std::string &interface) throw (SocketException);
                EtherSocket& setIfIndex(int index) throw ();

                int getEtherType(void) const throw ();
                std::string getInterface(void) const throw (SocketException);
                int getIfIndex(void) const throw ();
                bool isRaw(void) const throw ();

                void bindInterface(void) throw (SocketException); /* Applies to incoming traffic. Works with recv(), but not recvfrom(). */
                void setSoBindToDevice(const std::string &interface) throw (SocketException); /* Applies to outgoing traffic */
                void setSoBindToDevice(void) throw (SocketException); /* Applies to outgoing traffic. */
                void setPromiscous(bool on = true) throw (SocketException);

                ssize_t sendto(const void *data, size_t len, const std::string &dst_mac, int flags = 0) throw (SocketException);
                ssize_t sendto(const void *data, size_t len, const unsigned char *dst_mac = BroadcastMAC, int flags = 0) throw (SocketException);
                ssize_t sendto(const void *data, size_t len, int flags, const struct sockaddr_ll *dst_addr, socklen_t addrlen) throw (SocketException);
                ssize_t recvfrom(void *data, size_t len, int flags = 0, struct sockaddr_ll *src_addr = NULL, socklen_t *addrlen = NULL) throw (SocketException);
                ssize_t recvfrom(void *data, size_t len, std::string &src_mac, int flags = 0) throw (SocketException);

                void bind(const IPAddressPort &addressport) throw (SocketException) = delete;
                void bind(const IPAddress &address, const Port &port) throw (SocketException) = delete;
                void bind(const std::string &address = std::string(), const unsigned short port = 0) throw (SocketException) = delete;
                void connect(const IPAddressPort &addressport) throw (SocketException) = delete;
                void connect(const IPAddress &address, const Port &port) throw (SocketException) = delete;
                void connect(const std::string &address, const unsigned short port) throw (SocketException) = delete;

                virtual ssize_t send(const void *data, size_t len, int flags = 0) throw (SocketException) {
                        THROW(SocketException, "Not supported with EtherSocket");
                }

                virtual ssize_t recv(void *data, size_t len, int flags = 0) throw (SocketException) {
                        THROW(SocketException, "Not supported with EtherSocket");
                }

        protected:
        private:
                int etherType;
                int ifIndex;
                bool raw;
};

#endif

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