wavesock.cpp

Go to the documentation of this file.

/*
 * wavesock.cpp
 *
 * Copyright (C) 2007-2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Quick and dirty abstraction layer.  See wavesock.h, and netlib.cpp
 */

// includes --------------------------------------------------------------------
#include "wavesock.h"           // always include our own header first!

// socket-related headers common to Windows and BSD/*nix
#include <fcntl.h>

#ifdef WIN32
#include <winsock2.h>
#include <iphlpapi.h>
//#include <ws2tcpip.h>

#else   // WIN32

// Compiling under *nix: use these headers
#include <netdb.h>
#include <linux/if.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>

#endif  // WIN32


// common headers
#include "common/wave_ex.h"
#include "perf/perf.h"
#include "util/parsing.h"


namespace netlib {


#define ASSERT_SOCK(s) ASSERT( wsIsValidSocket(s) , "Bad socket: %d", s)


// typedefs that depend on the socket API
#ifdef WIN32
typedef int socket_length_t;
#else   // WIN32
typedef socklen_t socket_length_t;
#endif  // WIN32



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

class smart_socket {
public:
        smart_socket(void) throw() : m_s(-1) { }
        ~smart_socket(void) throw() {
                        this->clear();
                }

        void set(IN int s) throw() {
                        this->clear();
                        m_s = s;
                }

        int get(void) throw() { return m_s; }

        operator bool (void) const throw() { return (m_s >= 0); }

private:
        void clear(void) throw() {
                        if (m_s >= 0) {
                                wsCloseSocket(m_s);
                        }
                        m_s = -1;
                }

        int     m_s;
};


#ifndef WIN32
// these functions only used in *nix

static void
dumpErrorInfo
(
IN const char * msg
)
{
        const int s_bufsize = 256;
        char buffer[s_bufsize];
        int error = wsGetError();
        wsGetErrorMessage(buffer, s_bufsize);

        DPRINTF("%s", msg);
        DPRINTF("Error: %d", error);
        DPRINTF("%s", buffer);
}



static void
verify
(
IN bool isOK,
IN const char * msg
)
{
        if (isOK)
                return;         // no problem!

        // if we're here, there is a big problem!
        dumpErrorInfo(msg);
        ASSERT(false, "halting");
}
#endif  // WIN32



static void
setNonBlocking
(
IN int s
)
{
        ASSERT_SOCK(s);

#ifdef WIN32
        // do nothing
#else   // WIN32
        int flags = fcntl(s, F_GETFL, 0);
        verify(flags >= 0, "Failed to get socket descriptor flags");
        verify(fcntl(s, F_SETFL, flags | O_NONBLOCK) >= 0,
            "Failed to set nonblocking flag on socket");
#endif  // WIN32
}



static void
getAddressFromSockaddr
(
IN const struct sockaddr_storage * psa,
OUT address_t& address
)
throw()
{
        ASSERT(psa, "null");

        const struct sockaddr_in * psi = (const struct sockaddr_in *) psa;

        address.port = ntohs(psi->sin_port);
        address.ip.setIPv4((byte_t *) &psi->sin_addr);
//      memcpy(address.ip.bytes, &psi->sin_addr, 4 * sizeof(byte_t)); 
}



static void
getSockaddrFromAddress
(
IN const address_t& address,
OUT struct sockaddr_in& sa
)
throw()
{
        ASSERT(address.ip.isValid(), "invalid");
        memset(&sa, 0, sizeof(sa));
        sa.sin_family = AF_INET;
        sa.sin_port = htons(address.port);
        memcpy(&sa.sin_addr, address.ip.addr, 4 * sizeof(byte_t));
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

bool
getLocalInterfaces
(
OUT map_ip_addr_t& map
)
{
        map.clear();            // reset
        std::vector<char> vecbytes;

#ifdef WIN32
        // Windows: use GetIfTable
        DWORD bufsize = sizeof(MIB_IFTABLE);
        vecbytes.resize(bufsize);
        dword_t retval =
            GetIfTable((PMIB_IFTABLE) &vecbytes[0], &bufsize, TRUE);

        // if error was insufficient buffer, buff up and try again
        if (ERROR_INSUFFICIENT_BUFFER == retval) {
                // bufsize has already been modified
                vecbytes.resize(bufsize);
                retval =
                    GetIfTable((PMIB_IFTABLE) &vecbytes[0], &bufsize, TRUE);
        }

        ASSERT_THROW(NO_ERROR == retval,
            "Failed to acquire local interfaces");

        // loop through discovered interfaces
        PMIB_IFTABLE pTable = (PMIB_IFTABLE) &vecbytes[0];
        int nInterfaces = (int) pTable->dwNumEntries;
        DPRINTF("Found %d interfaces...", nInterfaces);
        for (int i = 0; i < nInterfaces; ++i) {
                MIB_IFROW& ifr = pTable->table[i];
                if (!ifr.wszName[0])
                        continue;       // skip empty names

                // Windows returns a UTF-16 string, we use UTF-8 consistently
                // So we translate to UTF-8
                // First, get required buffer size
                int strSize =
                    WideCharToMultiByte(CP_UTF8, 0, ifr.wszName, -1,
                        NULL, 0, NULL, NULL);
                ASSERT_THROW(strSize > 0,
                    "error attempting to determine UTF-8 string size");
                vecbytes.resize(strSize + 1);

                // now actually translate
                if (strSize != WideCharToMultiByte(CP_UTF8, 0, ifr.wszName, -1,
                        (char *) &vecbytes[0], strSize + 1, NULL, NULL)) {
                        ASSERT_THROW(false,
                            "Error translating UTF-16 name to UTF-8");
                }
                const char * name = (const char *) &vecbytes[0];
                DPRINTF("Interface name: '%s'", name);

                // ASSERT(false, "halting");
        }

#else   // WIN32
        // linux (freebsd sockets): use ioctl
        // see: http://stackoverflow.com/questions/212528/linux-c-get-the-ip-address-of-local-computer

        // create a UDP socket
        smart_socket s;
        s.set(socket(AF_INET, SOCK_DGRAM, 0));
        if (!s) {
                DPRINTF("Failed to create UDP socket?");
                return false;
        }

        // call ioctl() to retrieve local interfaces
        // weird loop here: we have to keep calling until we're
        //      sure that adding more buffer space won't result in
        //      more interfaces being returned.
        struct ifconf ifconf;
        int bufSize = sizeof(struct ifreq);
        int lastIfcReturned = -1;
        while (true) {
                vecbytes.resize(bufSize);
                ifconf.ifc_len = bufSize;
                ifconf.ifc_buf = &vecbytes[0];
                int retval = ioctl(s.get(), SIOCGIFCONF, &ifconf);

                if (retval < 0) {
                        DPRINTF("Error calling ioctl(SIOCGIFCONF)");
                        return false;
                }

                //DPRINTF("retval: %d", retval);
                //DPRINTF("ifc_len: %d", ifconf.ifc_len);

                if (ifconf.ifc_len == lastIfcReturned) {
                        // no change in interfaces returned!  all done
                        break;
                }

                //DPRINTF("Need more buffer for ioctl(SIOCGIFCONF)");
                bufSize *= 4;
                //DPRINTF("  expanding to %d bytes", bufSize);
                lastIfcReturned = ifconf.ifc_len;
        }

        // odd iteration method, but this is apparently how to do it...
        for (int n = 0; n < ifconf.ifc_len; n += sizeof(struct ifreq)) {
                struct ifreq * ifreq = (struct ifreq *) (&vecbytes[0] + n);
//              DPRINTF("Found interface: %s", ifreq->ifr_ifrn.ifrn_name);
                address_t address;
                getAddressFromSockaddr(
                    (const struct sockaddr_storage *) &ifreq->ifr_ifru.ifru_addr,
                    address);
//              address.dump("  Address");

                map[ifreq->ifr_ifrn.ifrn_name] = address.ip;
        }
#endif  // WIN32

        // all done!
        return true;
}



bool
ip_addr_t::lookupHostname
(
IN const char * hostname
)
{
        ASSERT(hostname, "null");

        struct hostent * h = gethostbyname(hostname);
        ASSERT_THROW(h, "Failed to get host by name: " << hostname);

        // debug only
        {
                DPRINTF("Asked to look up server: '%s'", hostname);
                DPRINTF("  official name: '%s'", h->h_name);
                DPRINTF("  Aliases:");
                for (char ** p = h->h_aliases; *p; ++p) {
                        DPRINTF("    '%s'", *p);
                }
                DPRINTF("  address type: %s", (AF_INET == h->h_addrtype) ?
                    "AF_INET" : "unknown?");
                DPRINTF("  address length: %d", h->h_length);
                DPRINTF("  addresses:");
                for (char ** p = h->h_addr_list; *p; ++p) {
                        const byte_t * ip = (const byte_t *) *p;
                        if (4 == h->h_length) {
                                DPRINTF("    %d.%d.%d.%d",
                                    ip[0], ip[1], ip[2], ip[3]);
                        } else {
                                DPRINTF("    (don't know how to print)");
                        }
                }
        }

        // only understand IPv4 for now
        if (4 != h->h_length) {
                DPRINTF("  Unknown address length: %d", h->h_length);
                DPRINTF("  Failing address lookup for host: %s", hostname);
                return false;
        }

        // succeeded, so set!
        ASSERT(4 == h->h_length, "Only allow IPv4 for now");

        // set the first non-localhost value
        for (char ** p = h->h_addr_list; *p; ++p) {
                const byte_t * ip = (const byte_t *) *p;
                if (127 == ip[0] &&
                    0 == ip[1] &&
                    0 == ip[2] &&
                    1 == ip[3]) {
                        DPRINTF("skipping localhost!");
                        continue;
                }

                // found a non-localhost IPv4 address!
                DPRINTF("    Using: %d.%d.%d.%d",
                    ip[0], ip[1], ip[2], ip[3]);
                this->setIPv4(ip);
                return true;
        }

        // got here?  Then we've only got a localhost address...
        DPRINTF("Only have a local host address for host: %s", hostname);
        this->setIPv4((byte_t *) h->h_addr_list[0]);
        return true;
}



bool
ip_addr_t::isLoopback
(
void
)
const
throw()
{
        if (eType_IPv4 == flags) {
                return (127 == addr[0] &&
                        0 == addr[1] &&
                        0 == addr[2] &&
                        1 == addr[3]);
        }

        DPRINTF("Invalid ip address--not loopback!");
        return false;
}



void
ip_addr_t::setLoopback
(
void
)
throw()
{
        byte_t ip[4] = { 127, 0, 0, 1 };
        this->setIPv4(ip);
}



bool
ip_addr_t::setBroadcast
(
void
)
throw()
{
        if (eType_IPv4 != flags) {
                DPRINTF("Attempting setBroadcast() on invalid IP address");
                return false;
        }

        // not very clever...
        addr[3] = 255;
        return true;
}



bool
address_t::set
(
IN const char * servername,
IN int remotePort
)
{
        ASSERT(servername, "null");
        ASSERT(remotePort > 0, "Bad port: %d", remotePort);

        if (!this->ip.lookupHostname(servername)) {
                DPRINTF("Failed to look up host: %s", servername);
                return false;
        }
        port = remotePort;
        return true;
}



static bool
tryInterface
(
IN const map_ip_addr_t& map,
IN const char * name,
OUT ip_addr_t& ip
)
throw()
{
        ASSERT(name, "null");

        DPRINTF("Looking for interface '%s'...", name);
        map_ip_addr_t::const_iterator i = map.find(name);
        if (i == map.end()) {
                return false;           // not found
        }

        DPRINTF("Found interface '%s'", name);
        ip = i->second;
        ip.dump(name);
        return true;
}



bool
address_t::setlocal
(
IN int remotePort
)
{
        ASSERT(remotePort > 0, "Bad port: %d", remotePort);

        map_ip_addr_t map;
        getLocalInterfaces(map);

        // debugging
        {
                DPRINTF("Found local interfaces:");
                for (map_ip_addr_t::const_iterator i = map.begin();
                     i != map.end(); ++i) {
                        const char * name = i->first.c_str();
                        const ip_addr_t& ip = i->second;
                        ip.dump(name);
                }
        }

        // set our port
        port = remotePort;

        // now try to figure out correct interface
        if (tryInterface(map, "eth0", ip)) {
                return true;
        }
        if (tryInterface(map, "wlan0", ip)) {
                return true;
        }

        DPRINTF("Couldn't find a preconfigured interface, guessing...");
        for (map_ip_addr_t::const_iterator i = map.begin();
             i != map.end(); ++i) {
                const char * name = i->first.c_str();

                if (!strcmp("lo", name))
                        continue;       // skip loopback

                DPRINTF("  Using interface '%s'", name);
                ip = i->second;
                ip.dump(name);
                return true;
        }

        return tryInterface(map, "lo", ip);
}



bool
wsIsValidSocket
(
IN int s
)
throw()
{
        return (s >= 0);
}



eWSError
wsGetError
(
void
)
throw()
{
        switch (errno) {
        case 0:                 return eWS_Okay;

#ifdef WIN32
        // Winsock-specific errors
        case WSAEACCES:         return eWS_Denied;
        case WSAEWOULDBLOCK:    return eWS_Again;
        case WSAEADDRINUSE:     return eWS_InUse;
        case WSAECONNREFUSED:   return eWS_ConnectionRefused;

#else   // WIN32
        // BSD-specific errors
        case EAGAIN:            return eWS_Again;
        case EACCES:            return eWS_Denied;
        case EADDRINUSE:        return eWS_InUse;
        case ECONNREFUSED:      return eWS_ConnectionRefused;
#endif  // WIN32

        default:
                return eWS_Unknown;
        }
}



void
wsGetErrorMessage
(
IO char * buffer,
IN int bufferSize
)
throw()
{
        ASSERT(buffer, "null");
        ASSERT(bufferSize > 0, "Bad buffer size: %d", bufferSize);

        const int localBufSize = 256;
        char local[localBufSize];

        int error = errno;
        strncpy(local, strerror(error), localBufSize);
        local[localBufSize - 1] = 0;    // null-terminate

        eWSError wserr  = wsGetError();
        snprintf(buffer, bufferSize, "%d(%d): %s", wserr, error, local);
        buffer[bufferSize - 1] = 0;     // null-terminate
}



int
wsCreateTcpSocket
(
void
)
throw()
{
        return socket(PF_INET, SOCK_STREAM, 0);
}



int
wsCreateUdpSocket
(
IN bool broadcast
)
throw()
{
        int s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (s >= 0 && broadcast) {
#ifdef WIN32
                BOOL b = 1;
#else   // WIN32
                int b = 1;
#endif  // WIN32
                const char * optval = (const char *) &b;
                if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, optval, sizeof(b)) < 0)
                {
                        wsCloseSocket(s);
                        s = -1;
                }
        }
        return s;
}



int
wsBindToPort
(
IN int s,
IN int port
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(port > 0, "Bad port: %d", port);

        struct sockaddr_in sa;
        memset(&sa, 0, sizeof(sa));
        sa.sin_family = AF_INET;
        sa.sin_port = htons(port);
        sa.sin_addr.s_addr = htonl(INADDR_ANY);

        int retval = bind(s, (struct sockaddr *) &sa, sizeof(sa));
        if (!retval) {
                setNonBlocking(s);
        }
        return retval;
}



int
wsListen
(
IN int s,
IN int maxBacklog
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(maxBacklog >= 0, "Bad max backlog: %d", maxBacklog);

        return listen(s, maxBacklog);
}



int
wsConnect
(
IN int s,
IN const address_t& address
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(address.port > 0, "bad port: %d", address.port);

        struct sockaddr_in sa;
        getSockaddrFromAddress(address, sa);
        int retval = connect(s, (struct sockaddr *) &sa, sizeof(sa));
        if (!retval) {
                setNonBlocking(s);
        }
        return retval;
}



int
wsReceive
(
IN int s,
IN char * buffer,
IN int bufferSize
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(buffer, "null");
        ASSERT(bufferSize > 0, "Bad buffer size: %d", bufferSize);

        int flags = 0;
        return recv(s, buffer, bufferSize, flags);
}



int
wsReceiveFrom
(
IN int s,
IN char * buffer,
IN int bufferSize,
OUT address_t& from
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(buffer, "null");
        ASSERT(bufferSize > 0, "Bad buffer size: %d", bufferSize);
        from.clear();

        struct sockaddr_storage sa;
        socket_length_t bytes = sizeof(sa);
        int flags = 0;
        int retval = recvfrom(s, buffer, bufferSize, flags,
            (struct sockaddr *) &sa, &bytes);

        // copy address
        if (retval > 0) {
                getAddressFromSockaddr(&sa, from);
                // from.dump("Received UDP packet");
        }

        // all done
        return retval;
}



int
wsSend
(
IN int s,
IN const char * buffer,
IN int bufferSize
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(buffer, "null");
        ASSERT(bufferSize >= 0, "bad buffer size: %d", bufferSize);

        int flags = 0;

#ifdef WIN32
#else   // WIN32
        flags |= MSG_NOSIGNAL;  // in *nix, don't wan't signals
#endif  // WIN32

        return send(s, buffer, bufferSize, flags);
}



int
wsSendTo
(
IN int s,
IN const char * buffer,
IN int bufferSize,
IN const address_t& address
)
throw()
{
        ASSERT_SOCK(s);
        ASSERT(buffer, "null");
        ASSERT(bufferSize > 0, "Bad buffer size: %d", bufferSize);

        struct sockaddr_in sa;
        getSockaddrFromAddress(address, sa);

        int flags = 0;
#ifdef WIN32
#else   // WIN32
        flags |= MSG_NOSIGNAL;  // in *nix, don't want signals
#endif  // WIN32

        return sendto(s, buffer, bufferSize, flags,
            (struct sockaddr *) &sa, sizeof(sa));
}



int
wsAccept
(
IN int s,
OUT address_t& address
)
throw()
{
        ASSERT_SOCK(s);

        struct sockaddr_storage sa;
        socket_length_t bytes = sizeof(sa);
        int c = accept(s, (struct sockaddr *) &sa, &bytes);
        if (wsIsValidSocket(c)) {
                getAddressFromSockaddr(&sa, address);
                setNonBlocking(c);
        }

        return c;
}



ws_set_t
wsCreateSet
(
void
)
{
        fd_set * pf = new fd_set;
        ASSERT_THROW(pf, "out of memory");

        return (ws_set_t) pf;
}



void
wsClearSet
(
IN ws_set_t set
)
throw()
{
        fd_set * pf = (fd_set *) set;
        ASSERT(pf, "null");

        FD_ZERO(pf);
}



void
wsAddSocketToSet
(
IN ws_set_t set,
IN int s
)
throw()
{
        ASSERT_SOCK(s);
        fd_set * pf = (fd_set *) set;
        ASSERT(pf, "null");

        // cast to unsigned is necessary to avoid warnings in WIN32
        FD_SET((word_t) s, pf);
}



bool
wsIsSocketInSet
(
IN ws_set_t set,
IN int s
)
throw()
{
        ASSERT_SOCK(s);
        fd_set * pf = (fd_set *) set;
        ASSERT(pf, "null");

        return (FD_ISSET(s, pf) != 0);
}



void
wsDestroySet
(
IN ws_set_t set
)
throw()
{
        fd_set * pf = (fd_set *) set;
        // ASSERT(pf) -- can be null!

        delete pf;
}



int
wsSelect
(
IN int maxSockets,
IN ws_set_t readers,
IN ws_set_t writers,
IN long wait_microseconds
)
throw()
{
        ASSERT_SOCK(maxSockets);
        ASSERT(readers, "null");
        ASSERT(writers, "null");
        ASSERT(wait_microseconds >= 0, "Bad wait time: %ld", wait_microseconds);

        struct timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = wait_microseconds;

        return select(maxSockets, (fd_set *) readers, (fd_set *) writers,
            NULL, &timeout);
}



void
wsCloseSocket
(
IN int s
)
throw()
{
        int ops = 0;

#ifdef WIN32
        ops = SD_BOTH;
#else   // WIN32
        ops = SHUT_RDWR;
#endif  // WIN32

        shutdown(s, ops);

#ifdef WIN32
        closesocket(s);
#else   // WIN32
        close(s);
#endif  // WIN32
}



};      // netlib namespace