/builddir/build/BUILD/libutil++-1.4.0/src/sella/net/Socket.cpp

/*
** libutil++
** $Id: Socket.cpp 1197 2014-10-14 22:26:11Z 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: Socket.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "Socket.h"

#include <stdio.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <errno.h>
#include <sys/mman.h>

using namespace sella::net;

/* Global Variables */
extern int errno;

union __sockaddr_union {
        struct sockaddr_storage         *ss;
        struct sockaddr                         *sa;
        struct sockaddr_in                      *sa_in;
        struct sockaddr_in6                     *sa_in6;
        struct sockaddr_un                      *sa_un;
};

Socket::Socket(int s) throw (SocketException) : usable(false), mux(false), read(false), write(false), except(false) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (s < 0 || s > FD_SETSIZE) {
                THROW(SocketException, "Passed invalid socket (%d)", s);
        }

        if (getsockname(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getsockname()");
        }

        if (addr.ss_family < 1 || addr.ss_family >= AF_MAX) {
                THROW(SocketException, "Family (%d) is invalid", addr.ss_family);
        }

        if (addr.ss_family != AF_INET && addr.ss_family != AF_INET6 && addr.ss_family != AF_PACKET && addr.ss_family != AF_UNIX) {
                THROW(SocketException, "Only addr.ss_family AF_INET, AF_INET6, AF_PACKET and AF_UNIX are implemented");
        }

        this->family = addr.ss_family;
        this->s = s;
}

Socket::Socket(int family, int type, int protocol) throw (SocketException) : s(-1), family(family), usable(false), mux(false), read(false), write(false), except(false) {
        if (family < 1 || family >= AF_MAX) {
                THROW(SocketException, "Family (%d) is invalid", family);
        }

        if (family != AF_INET && family != AF_INET6 && family != AF_PACKET && family != AF_UNIX) {
                THROW(SocketException, "Only family AF_INET, AF_INET6, AF_PACKET and AF_UNIX are implemented");
        }

        if (type < 0) {
                THROW(SocketException, "Socket type (%d) is invalid", type);
        }

        if (protocol < 0) {
                THROW(SocketException, "Protocol (%d) is invalid", protocol);
        }

        if ((this->s = ::socket(family, type, protocol)) < 0) {
                THROW2(SocketException, "socket()");
        }
}

Socket::~Socket() {
        read = write = except = false;
        close();
}

void Socket::bind(const IPAddressPort &addressport) throw (SocketException) {
        bind(addressport.getIPAddress().str(), addressport.getPort().get());
}

void Socket::bind(const IPAddress &address, const Port &port) throw (SocketException) {
        bind(address.str(), port.get());
}

void Socket::bind(const std::string &address, const unsigned short port) throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        initAddr(family, address, port, addr, addrlen);

        addr.ss_family = family;

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

        usable = true;
}

void Socket::connect(const IPAddressPort &addressport) throw (SocketException) {
        connect(addressport.getIPAddress().str(), addressport.getPort().get());
}

void Socket::connect(const IPAddress &address, const Port &port) throw (SocketException) {
        connect(address.str(), port.get());
}

void Socket::connect(const std::string &address, const unsigned short port) throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);
        
        initAddr(family, address, port, addr, addrlen);

        if (::connect(s, (sockaddr *) &addr, addrlen) < 0) {
                usable = false;

                THROW2(SocketException, "connect()");
        }

        usable = true;
}

void Socket::close(void) throw (SocketException) {
        usable = false;

        if (s >= 0) {
                if (::close(s) < 0) {
                        THROW2(SocketException, "close()");
                }

                s = -1;
        }
}

ssize_t Socket::send(const void *data, size_t len, int flags) throw (SocketException) {
        ssize_t c, r = len;
        int flg;

        do {
                if ((c = ::send(s, data, len, flags)) < 0) {
                        switch (errno) {
                                case EINTR:
                                case EMSGSIZE:
                                case ENOBUFS:
                                        break;

#if ((EAGAIN) != (EWOULDBLOCK)) /* Same value in Linux, but both are checked for completeness. */
                                case EAGAIN:
#endif
                                case EWOULDBLOCK:
                                        if ((flags & MSG_DONTWAIT) || ((flg = fcntl(s, F_GETFL)) != -1 && (flg & O_NONBLOCK))) {
                                                THROW_CODE(SocketException, EWOULDBLOCK, "Nonblocking socket would have blocked");
                                        }

                                        THROW_CODE(SocketException, EWOULDBLOCK, "Send timed out");

                                default:
                                        usable = false;
                        }

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

        write = false;

        return len;
}

ssize_t Socket::send(const std::string &data, int flags) throw (SocketException) {
        return send((const void*) data.c_str(), data.size(), flags);
}

ssize_t Socket::send(const std::vector<uint8_t> &data, int flags) throw (SocketException) {
        return send((const void*) data.data(), data.size(), flags);
}

ssize_t Socket::recv(void *buf, size_t len, int flags) throw (SocketException) {
        ssize_t c;
        int flg;

        if ((c = ::recv(s, buf, len, flags)) < 0) {
                switch (errno) {
                        case EINTR:
                                break;

#if ((EAGAIN) != (EWOULDBLOCK)) /* Same value in Linux, but both are checked for completeness. */
                        case EAGAIN:
#endif
                        case EWOULDBLOCK:
                                read = except = false;

                                if ((flags & MSG_DONTWAIT) || ((flg = fcntl(s, F_GETFL)) != -1 && (flg & O_NONBLOCK))) {
                                        THROW_CODE(SocketException, EWOULDBLOCK, "Nonblocking socket would have blocked");
                                }

                                THROW_CODE(SocketException, EWOULDBLOCK, "Receive timed out");

                        default:
                                usable = false;
                }

                THROW2(SocketException, "recv()");
        } else if (c == 0) { /* Orderly socket shutdown detected */
                usable = false;
        }

        read = except = false;

        return c;
}

ssize_t Socket::recv(std::string &data, size_t len, int flags) throw (SocketException) {
        uint8_t buf[len];
        ssize_t size = recv(buf, len, flags);

        std::string(buf, buf + len).swap(data);

        return size;
}

ssize_t Socket::recv(std::vector<uint8_t> &data, size_t len, int flags) throw (SocketException) {
        uint8_t buf[len];
        ssize_t size = recv(buf, len, flags);

        std::vector<uint8_t>(buf, buf + len).swap(data);

        return size;
}

int Socket::getFD(void) const {
        return s;
}

bool Socket::isRead(void) const {
        return read;
}

bool Socket::isWrite(void) const {
        return write;
}

bool Socket::isExcept(void) const {
        return except;
}

bool Socket::hasData(void) const throw (SocketException) {
        return (getQueuedBytes() > 0);
}

int Socket::getQueuedBytes(void) const throw (SocketException) {
        int count;

        if (ioctl(s, FIONREAD, &count) == -1) {
                THROW2(SocketException, "ioctl()");
        }

        return count;
}

IPAddressPort Socket::getLocalIPAddressPort(void) const throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (getsockname(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getsockname()");
        }

        return IPAddressPort(&addr);
}

IPAddress Socket::getLocalIPAddress(void) const throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (getsockname(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getsockname()");
        }

        return IPAddress(&addr);
}

Port Socket::getLocalPort(void) const throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (getsockname(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getsockname()");
        }

        return Port(&addr);
}

IPAddressPort Socket::getRemoteIPAddressPort(void) const throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (getpeername(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getpeername()");
        }

        return IPAddressPort(&addr);
}

IPAddress Socket::getRemoteIPAddress(void) const throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (getpeername(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getpeername()");
        }

        return IPAddress(&addr);
}

Port Socket::getRemotePort(void) const throw (SocketException) {
        sockaddr_storage addr;
        socklen_t addrlen = sizeof(sockaddr_storage);

        if (getpeername(s, (sockaddr *) &addr, &addrlen) < 0) {
                THROW2(SocketException, "getpeername()");
        }

        return Port(&addr);
}

int Socket::getFamily(void) const throw () {
        return family;
}

bool Socket::isUsable(void) const throw () {
        if (s < 0 || !(fcntl(s, F_GETFD) != -1 || errno != EBADF)) {
                return false;
        }

        return usable;
}

bool Socket::hasMux(void) const throw () {
        return mux;
}

void Socket::setBlock(bool on) throw (SocketException) {
        int flags;

        if ((flags = fcntl(s, F_GETFL)) < 0) {
                THROW2(SocketException, "fcntl()");
        }

        if (on) {
                flags &= ~O_NONBLOCK;
        } else {
                flags |= O_NONBLOCK;
        }

        if (fcntl(s, F_SETFL, flags) < 0) {
                THROW2(SocketException, "fcntl()");
        }
}

bool Socket::isBlock(void) throw (SocketException) {
        int flags;

        if ((flags = fcntl(s, F_GETFL)) < 0) {
                THROW2(SocketException, "fcntl()");
        }

        return (flags & O_NONBLOCK);
}

void Socket::setIpOptions(const void *optval, socklen_t len) throw (SocketException) {
#ifdef IP_OPTIONS
        if (setsockopt(s, IPPROTO_IP, IP_OPTIONS, (void*) optval, len) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_OPTIONS not defined");
#endif
}

void Socket::setIpPktInfo(bool on) throw (SocketException) {
#ifdef IP_PKTINFO
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_PKTINFO, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_PKTINFO not defined");
#endif
}

void Socket::setIpRecvTOS(bool on) throw (SocketException) {
#ifdef IP_RECVTOS
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_RECVTOS, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_RECVTOS not defined");
#endif
}

void Socket::setIpRecvTTL(bool on) throw (SocketException) {
#ifdef IP_RECVTTL
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_RECVTTL, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_RECVTTL not defined");
#endif
}

void Socket::setIpRecvOpts(bool on) throw (SocketException) {
#ifdef IP_RECVOPTS
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_RECVOPTS, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_RECVOPTS not defined");
#endif
}

void Socket::setIpRetOpts(bool on) throw (SocketException) {
#ifdef IP_RETOPTS
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_RETOPTS, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_RETOPTS not defined");
#endif
}

void Socket::setIpTOS(unsigned char tos) throw (SocketException) {
#ifdef IP_TOS
        if (setsockopt(s, IPPROTO_IP, IP_TOS, (void*) &tos, sizeof(tos)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_TOS not defined");
#endif
}

unsigned char Socket::getIpTOS(void) const throw (SocketException) {
        unsigned char tos = 0;

#ifdef IP_TOS
        socklen_t len = sizeof(tos);

        if (getsockopt(s, IPPROTO_IP, IP_TOS, (void*) &tos, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "IP_TOS not defined");
#endif

        return tos;
}

void Socket::setIpTTL(int ttl) throw (SocketException) {
#ifdef IP_TTL
        if (setsockopt(s, IPPROTO_IP, IP_TTL, (void*) &ttl, sizeof(ttl)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_TTL not defined");
#endif
}

int Socket::getIpTTL(void) const throw (SocketException) {
        int ttl = 0;
#ifdef IP_TTL
        socklen_t len = sizeof(ttl);

        if (getsockopt(s, IPPROTO_IP, IP_TTL, (void*) &ttl, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "IP_TTL not defined");
#endif

        return ttl;
}

void Socket::setIpHdrIncl(bool on) throw (SocketException) {
#ifdef IP_HDRINCL
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_HDRINCL not defined");
#endif
}

void Socket::setIpRecvErr(bool on) throw (SocketException) {
#ifdef IP_RECVERR
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_RECVERR, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_RECVERR not defined");
#endif
}

void Socket::setIpMtuDiscover(bool on) throw (SocketException) {
#ifdef IP_MTU_DISCOVER
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_MTU_DISCOVER, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_MTU_DISCOVER not defined");
#endif
}

int Socket::getIpMtu(void) const throw (SocketException) {
        int mtu = 0;

#ifdef IP_MTU
        socklen_t len = sizeof(mtu);

        if (getsockopt(s, IPPROTO_IP, IP_MTU, (void*) &mtu, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "IP_MTU not defined");
#endif

        return mtu;
}

void Socket::setIpRouterAlert(bool on) throw (SocketException) {
#ifdef IP_ROUTER_ALERT
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_ROUTER_ALERT, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_ROUTER_ALERT not defined");
#endif
}

void Socket::setIpMulticastTTL(int ttl) throw (SocketException) {
#ifdef IP_MULTICAST_TTL
        if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (void*) &ttl, sizeof(ttl)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_MULTICAST_TTL not defined");
#endif
}

int Socket::getIpMulticastTTL(void) const throw (SocketException) {
        int ttl = 0;

#ifdef MULTICAST_TTL
        socklen_t len = sizeof(ttl);

        if (getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (void*) &ttl, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "IP_MULTICAST_TTL not defined");
#endif

        return ttl;
}

void Socket::setIpMulticastLoop(bool on) throw (SocketException) {
#ifdef IP_MULTICAST_LOOP
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_MULTICAST_LOOP not defined");
#endif
}

void Socket::setIpAddMembership(struct ip_mreqn& m) throw (SocketException) {
#ifdef IP_ADD_MEMBERSHIP
        if (setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*) &m, sizeof(struct ip_mreqn)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_ADD_MEMBERSHIP not defined");
#endif
}

void Socket::setIpDropMembership(struct ip_mreqn& m) throw (SocketException) {
#ifdef IP_DROP_MEMBERSHIP
        if (setsockopt(s, IPPROTO_IP, IP_DROP_MEMBERSHIP, (void*) &m, sizeof(struct ip_mreqn)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IP_DROP_MEMBERSHIP not defined");
#endif
}

void Socket::setSoReuseAddr(bool on) throw (SocketException) {
#ifdef SO_REUSEADDR
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_REUSEADDR not defined");
#endif
}

void Socket::setSoKeepAlive(bool on) throw (SocketException) {
#ifdef SO_KEEPALIVE
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_KEEPALIVE not defined");
#endif
}

void Socket::setSoNoSigPipe(bool on) throw (SocketException) {
#ifdef SO_NOSIGPIPE
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_NOSIGPIPE not defined");
#endif
}

bool Socket::getSoAcceptConn(void) const throw (SocketException) {
        int accept = 0;
#ifdef SO_ACCEPTCONN
        socklen_t len = sizeof(accept);

        if (getsockopt(s, SOL_SOCKET, SO_ACCEPTCONN, (void*) &accept, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "SO_ACCEPTCONN not defined");
#endif

        return (accept) ? true : false;
}

void Socket::setSoBindToDevice(const std::string &interface) throw (SocketException) {
#ifdef SO_BINDTODEVICE
#if 0
        struct ifreq ifr;

        memset(&ifr, 0, sizeof(ifr));
        strncpy(ifr.ifr_name, interface.c_str(), sizeof(ifr.ifr_name));

        if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, (void*) &ifr, sizeof(ifr)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        size_t len = (interface.size() > IFNAMSIZ - 1) ? IFNAMSIZ - 1 : interface.size();

        if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, interface.c_str(), len) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#endif
#else
        THROW(SocketException, "SO_BINDTODEVICE not defined");
#endif
}

void Socket::setSoBroadcast(bool on) throw (SocketException) {
#ifdef SO_BROADCAST
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_BROADCAST not defined");
#endif
}

void Socket::setSoDebug(bool on) throw (SocketException) {
#ifdef SO_DEBUG
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_DEBUG, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_DEBUG not defined");
#endif
}

int Socket::getSoError(void) const throw (SocketException) {
        int error = 0;
#ifdef SO_ERROR
        socklen_t len = sizeof(error);

        if (getsockopt(s, SOL_SOCKET, SO_ERROR, (void*) &error, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "SO_ERROR not defined");
#endif

        return error;
}

void Socket::setSoDontRoute(bool on) throw (SocketException) {
#ifdef SO_DONTROUTE
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_DONTROUTE not defined");
#endif
}

void Socket::setSoLinger(int onoff, int linger) throw (SocketException) {
#ifdef SO_LINGER
        struct linger l;
        l.l_onoff = onoff;
        l.l_linger = linger;
        
        if (setsockopt(s, SOL_SOCKET, SO_LINGER, (void*) &l, sizeof(struct linger)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_LINGER not defined");
#endif
}

void Socket::setSoPriority(int pri) throw (SocketException) {
#ifdef SO_PRIORITY
        if (setsockopt(s, SOL_SOCKET, SO_PRIORITY, (void*) &pri, sizeof(pri)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_DONTROUTE not defined");
#endif
}

void Socket::setSoRcvTimeo(struct timeval &tv) throw (SocketException) {
#ifdef SO_RCVTIMEO
        if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (void*) &tv, sizeof(struct timeval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_RCVTIMEO not defined");
#endif
}

void Socket::setSoSndTimeo(struct timeval &tv) throw (SocketException) {
#ifdef SO_SNDTIMEO
        if (setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (void*) &tv, sizeof(struct timeval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_SNDTIMEO not defined");
#endif
}

void Socket::setSoRcvBuf(int bytes) throw (SocketException) {
#ifdef SO_RCVBUF
        if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, (void*) &bytes, sizeof(bytes)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_RCVBUF not defined");
#endif
}

void Socket::setSoRcvBufForce(int bytes) throw (SocketException) {
#ifdef SO_RCVBUFFORCE
        if (setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, (void*) &bytes, sizeof(bytes)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_RCVBUFFORCE not defined");
#endif
}

int Socket::getSoRcvBuf(void) const throw (SocketException) {
        int bytes = 0;
#ifdef SO_RCVBUF
        socklen_t len = sizeof(bytes);

        if (getsockopt(s, SOL_SOCKET, SO_RCVBUF, (void*) &bytes, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "SO_RCVBUF not defined");
#endif

        return bytes;
}

void Socket::setSoSndBuf(int bytes) throw (SocketException) {
#ifdef SO_SNDBUF
        if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, (void*) &bytes, sizeof(bytes)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_SNDBUF not defined");
#endif
}

void Socket::setSoSndBufForce(int bytes) throw (SocketException) {
#ifdef SO_SNDBUFFORCE
        if (setsockopt(s, SOL_SOCKET, SO_SNDBUFFORCE, (void*) &bytes, sizeof(bytes)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_SNDBUFFORCE not defined");
#endif
}

int Socket::getSoSndBuf(void) const throw (SocketException) {
        int bytes = 0;
#ifdef SO_SNDBUF
        socklen_t len = sizeof(bytes);

        if (getsockopt(s, SOL_SOCKET, SO_SNDBUF, (void*) &bytes, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "SO_SNDBUF not defined");
#endif

        return bytes;
}

void Socket::setSoTimestamp(bool on) throw (SocketException) {
#ifdef SO_TIMESTAMP
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, SOL_SOCKET, SO_TIMESTAMP, (void*)optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "SO_TIMESTAMP not defined");
#endif
}

int Socket::getSoType(void) throw (SocketException) {
        int type = 0;
#ifdef SO_TYPE
        socklen_t len = sizeof(type);

        if (getsockopt(s, SOL_SOCKET, SO_TYPE, (void*) &type, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "SO_TYPE not defined");
#endif

        return type;
}

/* Socket Options (IPv6) - man 7 ipv6 */
void Socket::setIpv6V6Only(bool on) throw (SocketException) {
#ifdef IPV6_V6ONLY
        int optval = (on) ? 1 : 0;

        if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (void*) &optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "IPV6_V6ONLY not defined");
#endif
}

bool Socket::getIpv6V6Only(void) const throw (SocketException) {
        int optval = 0;
#ifdef IPV6_V6ONLY
        socklen_t len = sizeof(optval);

        if (getsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (void*) &optval, &len) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "IPV6_V6ONLY not defined");
#endif

        return (optval) ? true : false;
}

/* Packet Options - man 7 packet */
void Socket::mmapRingBuffer(unsigned char **ring, struct tpacket_req &req) throw (SocketException) {
        if ((*ring = (unsigned char*) mmap(0, req.tp_block_size * req.tp_block_nr, PROT_READ | PROT_WRITE, MAP_SHARED, s, 0)) == NULL) {
                THROW2(SocketException, "mmap()");
        }
}

void Socket::munmapRingBuffer(unsigned char **ring, struct tpacket_req &req) throw (SocketException) {
        if (munmap(*ring, req.tp_block_size) > 0) {
                THROW2(SocketException, "munmap()");
        }

        ring = NULL;
}

void Socket::setPacketRxRing(struct tpacket_req &req, int version) throw (SocketException) {
#ifdef PACKET_VERSION
        if (setsockopt(s, SOL_PACKET, PACKET_VERSION, (void*) &version, sizeof(version)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "PACKET_VERSION not defined");
#endif

#ifdef PACKET_RX_RING
        if (setsockopt(s, SOL_PACKET, PACKET_RX_RING, (void*) &req, sizeof(req)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "PACKET_RX_RING not defined");
#endif
}

void Socket::setPacketTxRing(struct tpacket_req &req, int version) throw (SocketException) {
#ifdef PACKET_VERSION
        if (setsockopt(s, SOL_PACKET, PACKET_VERSION, (void*) &version, sizeof(version)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "PACKET_VERSION not defined");
#endif

#ifdef PACKET_TX_RING
        if (setsockopt(s, SOL_PACKET, PACKET_TX_RING, (void*) &req, sizeof(req)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "PACKET_TX_RING not defined");
#endif
}

void Socket::setPacketLoss(bool drop) throw (SocketException) {
        int optval = (drop) ? 1 : 0;

#ifdef PACKET_LOSS
        if (setsockopt(s, SOL_PACKET, PACKET_LOSS, (void*) optval, sizeof(optval)) < 0) {
                THROW2(SocketException, "setsockopt()");
        }
#else
        THROW(SocketException, "PACKET_TX_RING not defined");
#endif
}

int Socket::getPacketHdrLen(int version) throw (SocketException) {
        int ret;
        socklen_t len = sizeof(version);

#ifdef PACKET_LOSS
        if ((ret = getsockopt(s, SOL_PACKET, PACKET_HDRLEN, (void*) &version, &len)) < 0) {
                THROW2(SocketException, "getsockopt()");
        }
#else
        THROW(SocketException, "PACKET_HDRLEN not defined");
#endif

        return ret;
}

void Socket::initAddr(int family, const std::string &address, unsigned short port, sockaddr_storage &addr, socklen_t addrlen) throw (SocketException) {
        union __sockaddr_union u;
        u.ss = (struct sockaddr_storage*) &addr;

        memset(&addr, 0, addrlen);
        u.ss->ss_family = family;

        if (family != AF_INET && family != AF_INET6) {
                THROW(SocketException, "Only family AF_INET and AF_INET6 and AF_PACKET are implemented");
        }

        if (address.empty()) {
                if (family == AF_INET) {
                        u.sa_in->sin_addr.s_addr = htonl(INADDR_ANY);
                } else {
                        u.sa_in6->sin6_addr = in6addr_any;
                }
        } else {
                int s;
                struct addrinfo hints, *result, *rp;

                memset(&hints, 0, sizeof(struct addrinfo));
                hints.ai_family = family;
                hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
                hints.ai_flags = AI_PASSIVE;            /* For wildcard IP address */
                hints.ai_protocol = 0;                          /* Any protocol */
                hints.ai_canonname = NULL;
                hints.ai_addr = NULL;
                hints.ai_next = NULL;

                if ((s = getaddrinfo(address.c_str(), NULL, &hints, &result)) != 0) {
                        THROW(SocketException, "getaddrinfo() failed: %s", gai_strerror(s));
                }

                for (rp = result; rp != NULL; rp = rp->ai_next) {
                        if (family == rp->ai_family) {
                                if (rp->ai_family == AF_INET) {
                                        memcpy(u.sa_in, rp->ai_addr, rp->ai_addrlen);
                                } else if (rp->ai_family == AF_INET6) {
                                        memcpy(u.sa_in6, rp->ai_addr, rp->ai_addrlen);
                                }

                                break;
                        }

                        if (rp->ai_next == NULL) {
                                THROW(SocketException, "Failed to locate an IPv4 or IPv6 address for %s", address.c_str());
                        }
                }
        }

        IPAddress x(u.ss);

        if (family == AF_INET) {
                u.sa_in->sin_port = htons(port);
        } else {
                u.sa_in6->sin6_port = htons(port);
        }
}

unsigned short Socket::resolveService(const std::string &service, const std::string &protocol) throw (SocketException) {
        struct servent serv, *result = NULL;
        char buf[1024];
        long int ret;

        if (getservbyname_r(service.c_str(), protocol.c_str(), &serv, buf, sizeof(buf), &result) != 0) {
                THROW2(SocketException, "getservbyname()");
        }

        if (result != NULL) {
                return ntohs(result->s_port);
        } else if (!isdigit(service.c_str()[0])) {
                THROW(SocketException, "unresolveable service");
        }

        ret = strtol(service.c_str(), (char **) NULL, 10);
        if (ret < 1 || ret > 65535) {
                THROW2(SocketException, "port out of range");
        }

        return ret;
}

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

---