dlib C++ Library - sockets_kernel_1.cpp

    // Copyright (C) 2003  Davis E. King (davis@dlib.net), Miguel Grinberg
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_SOCKETS_KERNEL_1_CPp_
    #define DLIB_SOCKETS_KERNEL_1_CPp_
    #include "../platform.h"

    #ifdef WIN32

    #include <winsock2.h>

    #ifndef _WINSOCKAPI_
    #define _WINSOCKAPI_   /* Prevent inclusion of winsock.h in windows.h */
    #endif

    #include "../windows_magic.h"

    #include "sockets_kernel_1.h"

    #include <windows.h>

    #ifndef NI_MAXHOST
    #define NI_MAXHOST 1025
    #endif

    // tell visual studio to link to the libraries we need if we are
    // in fact using visual studio
    #ifdef _MSC_VER
    #pragma comment (lib, "ws2_32.lib")
    #endif

    #include "../assert.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        class SOCKET_container
        {
            /*!
                This object is just a wrapper around the SOCKET type.  It exists
                so that we can #include the windows.h and Winsock2.h header files
                in this cpp file and not at all in the header file.
            !*/
        public:
            SOCKET_container (
                SOCKET s = INVALID_SOCKET
            ) : val(s) {}

            SOCKET val;
            operator SOCKET&() { return val; }

            SOCKET_container& operator= (
                const SOCKET& s
            ) { val = s; return *this; }

            bool operator== (
                const SOCKET& s
            ) const { return s == val; }
        };

    // ----------------------------------------------------------------------------------------
    // stuff to ensure that WSAStartup() is always called before any sockets stuff is needed

        namespace sockets_kernel_1_mutex
        {
            mutex startup_lock;
        }

        class sockets_startupdown
        {
        public:
            sockets_startupdown();
            ~sockets_startupdown() { WSACleanup( ); }

        };
        sockets_startupdown::sockets_startupdown (
        )
        {
            WSADATA wsaData;
            WSAStartup (MAKEWORD(2,0), &wsaData);
        }

        void sockets_startup()
        {
            // mutex crap to make this function thread-safe
            sockets_kernel_1_mutex::startup_lock.lock();
            static sockets_startupdown a;
            sockets_kernel_1_mutex::startup_lock.unlock();
        }

    // ----------------------------------------------------------------------------------------

        // lookup functions

        int
        get_local_hostname (
            std::string& hostname
        )
        {
            // ensure that WSAStartup has been called and WSACleanup will eventually
            // be called when program ends
            sockets_startup();

            try
            {

                char temp[NI_MAXHOST];
                if (gethostname(temp,NI_MAXHOST) == SOCKET_ERROR )
                {
                    return OTHER_ERROR;
                }

                hostname = temp;
            }
            catch (...)
            {
                return OTHER_ERROR;
            }

            return 0;
        }

    // -----------------

        int
        hostname_to_ip (
            const std::string& hostname,
            std::string& ip,
            int n
        )
        {
            // ensure that WSAStartup has been called and WSACleanup will eventually
            // be called when program ends
            sockets_startup();

            try
            {
                // lock this mutex since gethostbyname isn't really thread safe
                auto_mutex M(sockets_kernel_1_mutex::startup_lock);

                // if no hostname was given then return error
                if ( hostname.empty())
                    return OTHER_ERROR;

                hostent* address;
                address = gethostbyname(hostname.c_str());

                if (address == 0)
                {
                    return OTHER_ERROR;
                }

                // find the nth address
                in_addr* addr = reinterpret_cast<in_addr*>(address->h_addr_list[0]);
                for (int i = 1; i <= n; ++i)
                {
                    addr = reinterpret_cast<in_addr*>(address->h_addr_list[i]);

                    // if there is no nth address then return error
                    if (addr == 0)
                        return OTHER_ERROR;
                }

                char* resolved_ip = inet_ntoa(*addr);

                // check if inet_ntoa returned an error
                if (resolved_ip == NULL)
                {
                    return OTHER_ERROR;
                }

                ip.assign(resolved_ip);

            }
            catch(...)
            {
                return OTHER_ERROR;
            }

            return 0;
        }

    // -----------------

        int
        ip_to_hostname (
            const std::string& ip,
            std::string& hostname
        )
        {
            // ensure that WSAStartup has been called and WSACleanup will eventually
            // be called when program ends
            sockets_startup();

            try
            {
                // lock this mutex since gethostbyaddr isn't really thread safe
                auto_mutex M(sockets_kernel_1_mutex::startup_lock);

                // if no ip was given then return error
                if (ip.empty())
                    return OTHER_ERROR;

                hostent* address;
                unsigned long ipnum = inet_addr(ip.c_str());

                // if inet_addr couldn't convert ip then return an error
                if (ipnum == INADDR_NONE)
                {
                    return OTHER_ERROR;
                }
                address = gethostbyaddr(reinterpret_cast<char*>(&ipnum),4,AF_INET);

                // check if gethostbyaddr returned an error
                if (address == 0)
                {
                    return OTHER_ERROR;
                }
                hostname.assign(address->h_name);

            }
            catch (...)
            {
                return OTHER_ERROR;
            }
            return 0;

        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
        // connection object
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        connection::
        connection(
            SOCKET_container sock,
            unsigned short foreign_port,
            const std::string& foreign_ip,
            unsigned short local_port,
            const std::string& local_ip
        ) :
            user_data(0),
            connection_socket(*(new SOCKET_container())),
            connection_foreign_port(foreign_port),
            connection_foreign_ip(foreign_ip),
            connection_local_port(local_port),
            connection_local_ip(local_ip),
            sd(false),
            sdo(false),
            sdr(0)
        {
           connection_socket = sock;
        }

    // ----------------------------------------------------------------------------------------

        connection::
        ~connection (
        )
        {
            if (connection_socket != INVALID_SOCKET)
                closesocket(connection_socket);
            delete &connection_socket;
        }

    // ----------------------------------------------------------------------------------------

        int connection::
        disable_nagle()
        {
            int flag = 1;
            int status = setsockopt( connection_socket, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(flag) );

            if (status == SOCKET_ERROR)
                return OTHER_ERROR;
            else
                return 0;
        }

    // ----------------------------------------------------------------------------------------

        long connection::
        write (
            const char* buf,
            long num
        )
        {
            const long old_num = num;
            long status;
            const long max_send_length = 1024*1024*100;
            while (num > 0)
            {
                // Make sure to cap the max value num can take on so that if it is
                // really large (it might be big on 64bit platforms) so that the OS
                // can't possibly get upset about it being large.
                const long length = std::min(max_send_length, num);
                if ( (status = send(connection_socket,buf,length,0)) == SOCKET_ERROR)
                {
                    if (sdo_called())
                        return SHUTDOWN;
                    else
                        return OTHER_ERROR;
                }
                num -= status;
                buf += status;
            }
            return old_num;
        }

    // ----------------------------------------------------------------------------------------

        long connection::
        read (
            char* buf,
            long num
        )
        {
            const long max_recv_length = 1024*1024*100;
            // Make sure to cap the max value num can take on so that if it is
            // really large (it might be big on 64bit platforms) so that the OS
            // can't possibly get upset about it being large.
            const long length = std::min(max_recv_length, num);
            long status = recv(connection_socket,buf,length,0);
            if (status == SOCKET_ERROR)
            {
                // if this error is the result of a shutdown call then return SHUTDOWN
                if (sd_called())
                    return SHUTDOWN;
                else
                    return OTHER_ERROR;
            }
            else if (status == 0 && sd_called())
            {
                return SHUTDOWN;
            }
            return status;
        }

    // ----------------------------------------------------------------------------------------

        long connection::
        read (
            char* buf,
            long num,
            unsigned long timeout
        )
        {
            if (readable(timeout) == false)
                return TIMEOUT;

            const long max_recv_length = 1024*1024*100;
            // Make sure to cap the max value num can take on so that if it is
            // really large (it might be big on 64bit platforms) so that the OS
            // can't possibly get upset about it being large.
            const long length = std::min(max_recv_length, num);
            long status = recv(connection_socket,buf,length,0);
            if (status == SOCKET_ERROR)
            {
                // if this error is the result of a shutdown call then return SHUTDOWN
                if (sd_called())
                    return SHUTDOWN;
                else
                    return OTHER_ERROR;
            }
            else if (status == 0 && sd_called())
            {
                return SHUTDOWN;
            }
            return status;
        }

    // ----------------------------------------------------------------------------------------

        bool connection::
        readable (
            unsigned long timeout
        ) const
        {
            fd_set read_set;
            // initialize read_set
            FD_ZERO(&read_set);

            // add the listening socket to read_set
            FD_SET(connection_socket, &read_set);

            // setup a timeval structure
            timeval time_to_wait;
            time_to_wait.tv_sec = static_cast<long>(timeout/1000);
            time_to_wait.tv_usec = static_cast<long>((timeout%1000)*1000);

            // wait on select
            int status = select(0,&read_set,0,0,&time_to_wait);

            // if select timed out or there was an error
            if (status <= 0)
                return false;

            // data is ready to be read
            return true;
        }

    // ----------------------------------------------------------------------------------------

        int connection::
        shutdown_outgoing (
        )
        {
            sd_mutex.lock();
            if (sdo || sd)
            {
                sd_mutex.unlock();
                return sdr;
            }
            sdo = true;
            sdr = ::shutdown(connection_socket,SD_SEND);

            // convert -1 error code into the OTHER_ERROR error code
            if (sdr == -1)
                sdr = OTHER_ERROR;

            int temp = sdr;

            sd_mutex.unlock();
            return temp;
        }

    // ----------------------------------------------------------------------------------------

        int connection::
        shutdown (
        )
        {
            sd_mutex.lock();
            if (sd)
            {
                sd_mutex.unlock();
                return sdr;
            }
            sd = true;
            SOCKET stemp = connection_socket;
            connection_socket = INVALID_SOCKET;
            sdr = closesocket(stemp);

            // convert SOCKET_ERROR error code into the OTHER_ERROR error code
            if (sdr == SOCKET_ERROR)
                sdr = OTHER_ERROR;

            int temp = sdr;

            sd_mutex.unlock();
            return temp;
        }

    // ----------------------------------------------------------------------------------------

        connection::socket_descriptor_type connection::
        get_socket_descriptor (
        ) const
        {
            return connection_socket.val;
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
        // listener object
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        listener::
        listener(
            SOCKET_container sock,
            unsigned short port,
            const std::string& ip
        ) :
            listening_socket(*(new SOCKET_container)),
            listening_port(port),
            listening_ip(ip),
            inaddr_any(listening_ip.empty())
        {
            listening_socket = sock;
        }

    // ----------------------------------------------------------------------------------------

        listener::
        ~listener (
        )
        {
            closesocket(listening_socket);
            delete &listening_socket;
        }

    // ----------------------------------------------------------------------------------------

        int listener::
        accept (
            std::unique_ptr<connection>& new_connection,
            unsigned long timeout
        )
        {
            new_connection.reset(0);
            connection* con;
            int status = this->accept(con, timeout);

            if (status == 0)
                new_connection.reset(con);

            return status;
        }

    // ----------------------------------------------------------------------------------------

        int listener::
        accept (
            connection*& new_connection,
            unsigned long timeout
        )
        {
            SOCKET incoming;
            sockaddr_in incomingAddr;
            int length = sizeof(sockaddr_in);

            // implement timeout with select if timeout is > 0
            if (timeout > 0)
            {
                fd_set read_set;
                // initialize read_set
                FD_ZERO(&read_set);

                // add the listening socket to read_set
                FD_SET(listening_socket, &read_set);

                // setup a timeval structure
                timeval time_to_wait;
                time_to_wait.tv_sec = static_cast<long>(timeout/1000);
                time_to_wait.tv_usec = static_cast<long>((timeout%1000)*1000);

                // wait on select
                int status = select(0,&read_set,0,0,&time_to_wait);

                // if select timed out
                if (status == 0)
                    return TIMEOUT;

                // if select returned an error
                if (status == SOCKET_ERROR)
                    return OTHER_ERROR;

            }

            // call accept to get a new connection
            incoming=::accept(listening_socket,reinterpret_cast<sockaddr*>(&incomingAddr),&length);

            // if there was an error return OTHER_ERROR
            if ( incoming == INVALID_SOCKET )
                return OTHER_ERROR;

            // get the port of the foreign host into foreign_port
            int foreign_port = ntohs(incomingAddr.sin_port);

            // get the IP of the foreign host into foreign_ip
            std::string foreign_ip;
            {
                char* foreign_ip_temp = inet_ntoa(incomingAddr.sin_addr);

                // check if inet_ntoa() returned an error
                if (foreign_ip_temp == NULL)
                {
                    closesocket(incoming);
                    return OTHER_ERROR;
                }

                foreign_ip.assign(foreign_ip_temp);
            }

            // get the local ip
            std::string local_ip;
            if (inaddr_any == true)
            {
                sockaddr_in local_info;
                length = sizeof(sockaddr_in);
                // get the local sockaddr_in structure associated with this new connection
                if ( getsockname (
                        incoming,
                        reinterpret_cast<sockaddr*>(&local_info),
                        &length
                     ) == SOCKET_ERROR
                )
                {   // an error occurred
                    closesocket(incoming);
                    return OTHER_ERROR;
                }
                char* temp = inet_ntoa(local_info.sin_addr);

                // check if inet_ntoa() returned an error
                if (temp == NULL)
                {
                    closesocket(incoming);
                    return OTHER_ERROR;
                }
                local_ip.assign(temp);
            }
            else
            {
                local_ip = listening_ip;
            }

            // set the SO_OOBINLINE option
            int flag_value = 1;
            if (setsockopt(incoming,SOL_SOCKET,SO_OOBINLINE,reinterpret_cast<const char*>(&flag_value),sizeof(int)) == SOCKET_ERROR )
            {
                closesocket(incoming);
                return OTHER_ERROR;
            }

            // make a new connection object for this new connection
            try
            {
                new_connection = new connection (
                                        incoming,
                                        foreign_port,
                                        foreign_ip,
                                        listening_port,
                                        local_ip
                                    );
            }
            catch (...) { closesocket(incoming); return OTHER_ERROR; }

            return 0;
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
        // socket creation functions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        int create_listener (
            std::unique_ptr<listener>& new_listener,
            unsigned short port,
            const std::string& ip
        )
        {
            new_listener.reset();
            listener* temp;
            int status = create_listener(temp,port,ip);

            if (status == 0)
                new_listener.reset(temp);

            return status;
        }

        int create_listener (
            listener*& new_listener,
            unsigned short port,
            const std::string& ip
        )
        {
            // ensure that WSAStartup has been called and WSACleanup will eventually
            // be called when program ends
            sockets_startup();

            sockaddr_in sa;  // local socket structure
            ZeroMemory(&sa,sizeof(sockaddr_in)); // initialize sa

            SOCKET sock = socket (AF_INET, SOCK_STREAM, 0);  // get a new socket

            // if socket() returned an error then return OTHER_ERROR
            if (sock == INVALID_SOCKET )
            {
                return OTHER_ERROR;
            }

            // set the local socket structure
            sa.sin_family = AF_INET;
            sa.sin_port = htons(port);
            if (ip.empty())
            {
                // if the listener should listen on any IP
                sa.sin_addr.S_un.S_addr = htons(INADDR_ANY);
            }
            else
            {
                // if there is a specific ip to listen on
                sa.sin_addr.S_un.S_addr = inet_addr(ip.c_str());
                // if inet_addr couldn't convert the ip then return an error
                if ( sa.sin_addr.S_un.S_addr == INADDR_NONE )
                {
                    closesocket(sock);
                    return OTHER_ERROR;
                }
            }

            // set the SO_REUSEADDR option
            int flag_value = 1;
            setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,reinterpret_cast<const char*>(&flag_value),sizeof(int));

            // bind the new socket to the requested port and ip
            if (bind(sock,reinterpret_cast<sockaddr*>(&sa),sizeof(sockaddr_in))==SOCKET_ERROR)
            {
                const int err = WSAGetLastError();
                // if there was an error
                closesocket(sock);

                // if the port is already bound then return PORTINUSE
                if (err == WSAEADDRINUSE)
                    return PORTINUSE;
                else
                    return OTHER_ERROR;
            }

            // tell the new socket to listen
            if ( listen(sock,SOMAXCONN) == SOCKET_ERROR)
            {
                const int err = WSAGetLastError();
                // if there was an error return OTHER_ERROR
                closesocket(sock);

                // if the port is already bound then return PORTINUSE
                if (err == WSAEADDRINUSE)
                    return PORTINUSE;
                else
                    return OTHER_ERROR;
            }

            // determine the port used if necessary
            if (port == 0)
            {
                sockaddr_in local_info;
                int length = sizeof(sockaddr_in);
                if ( getsockname (
                            sock,
                            reinterpret_cast<sockaddr*>(&local_info),
                            &length
                     ) == SOCKET_ERROR
                )
                {
                    closesocket(sock);
                    return OTHER_ERROR;
                }
                port = ntohs(local_info.sin_port);
            }

            // initialize a listener object on the heap with the new socket
            try { new_listener = new listener(sock,port,ip); }
            catch(...) { closesocket(sock); return OTHER_ERROR; }

            return 0;
        }

    // ----------------------------------------------------------------------------------------

        int create_connection (
            std::unique_ptr<connection>& new_connection,
            unsigned short foreign_port,
            const std::string& foreign_ip,
            unsigned short local_port,
            const std::string& local_ip
        )
        {
            new_connection.reset();
            connection* temp;
            int status = create_connection(temp,foreign_port, foreign_ip, local_port, local_ip);

            if (status == 0)
                new_connection.reset(temp);

            return status;
        }

        int create_connection (
            connection*& new_connection,
            unsigned short foreign_port,
            const std::string& foreign_ip,
            unsigned short local_port,
            const std::string& local_ip
        )
        {
            // ensure that WSAStartup has been called and WSACleanup
            // will eventually be called when program ends
            sockets_startup();

            sockaddr_in local_sa;  // local socket structure
            sockaddr_in foreign_sa;  // foreign socket structure
            ZeroMemory(&local_sa,sizeof(sockaddr_in)); // initialize local_sa
            ZeroMemory(&foreign_sa,sizeof(sockaddr_in)); // initialize foreign_sa

            int length;

            SOCKET sock = socket (AF_INET, SOCK_STREAM, 0);  // get a new socket

            // if socket() returned an error then return OTHER_ERROR
            if (sock == INVALID_SOCKET )
            {
                return OTHER_ERROR;
            }

            // set the foreign socket structure
            foreign_sa.sin_family = AF_INET;
            foreign_sa.sin_port = htons(foreign_port);
            foreign_sa.sin_addr.S_un.S_addr = inet_addr(foreign_ip.c_str());

            // if inet_addr couldn't convert the ip then return an error
            if ( foreign_sa.sin_addr.S_un.S_addr == INADDR_NONE )
            {
                closesocket(sock);
                return OTHER_ERROR;
            }

            // set up the local socket structure
            local_sa.sin_family = AF_INET;

            // set the local ip
            if (local_ip.empty())
            {
                // if the listener should listen on any IP
                local_sa.sin_addr.S_un.S_addr = htons(INADDR_ANY);
            }
            else
            {
                // if there is a specific ip to listen on
                local_sa.sin_addr.S_un.S_addr = inet_addr(local_ip.c_str());

                // if inet_addr couldn't convert the ip then return an error
                if (local_sa.sin_addr.S_un.S_addr == INADDR_NONE)
                {
                    closesocket(sock);
                    return OTHER_ERROR;
                }
            }

            // set the local port
            local_sa.sin_port = htons(local_port);

            // bind the new socket to the requested local port and local ip
            if ( bind (
                    sock,
                    reinterpret_cast<sockaddr*>(&local_sa),
                    sizeof(sockaddr_in)
                ) == SOCKET_ERROR
            )
            {
                const int err = WSAGetLastError();
                // if there was an error
                closesocket(sock);

                // if the port is already bound then return PORTINUSE
                if (err == WSAEADDRINUSE)
                    return PORTINUSE;
                else
                    return OTHER_ERROR;
            }

            // connect the socket
            if (connect (
                    sock,
                    reinterpret_cast<sockaddr*>(&foreign_sa),
                    sizeof(sockaddr_in)
                ) == SOCKET_ERROR
            )
            {
                const int err = WSAGetLastError();
                closesocket(sock);
                // if the port is already bound then return PORTINUSE
                if (err == WSAEADDRINUSE)
                    return PORTINUSE;
                else
                    return OTHER_ERROR;
            }

            // determine the local port and IP and store them in used_local_ip
            // and used_local_port
            int used_local_port;
            std::string used_local_ip;
            sockaddr_in local_info;
            if (local_port == 0)
            {
                length = sizeof(sockaddr_in);
                if (getsockname (
                        sock,
                        reinterpret_cast<sockaddr*>(&local_info),
                        &length
                    ) == SOCKET_ERROR
                )
                {
                    closesocket(sock);
                    return OTHER_ERROR;
                }
                used_local_port = ntohs(local_info.sin_port);
            }
            else
            {
                used_local_port = local_port;
            }

            // determine real local ip
            if (local_ip.empty())
            {
                // if local_port is not 0 then we must fill the local_info structure
                if (local_port != 0)
                {
                    length = sizeof(sockaddr_in);
                    if ( getsockname (
                            sock,
                            reinterpret_cast<sockaddr*>(&local_info),
                            &length
                        ) == SOCKET_ERROR
                    )
                    {
                        closesocket(sock);
                        return OTHER_ERROR;
                    }
                }
                char* temp = inet_ntoa(local_info.sin_addr);

                // check if inet_ntoa returned an error
                if (temp == NULL)
                {
                    closesocket(sock);
                    return OTHER_ERROR;
                }
                used_local_ip.assign(temp);
            }
            else
            {
                used_local_ip = local_ip;
            }

            // set the SO_OOBINLINE option
            int flag_value = 1;
            if (setsockopt(sock,SOL_SOCKET,SO_OOBINLINE,reinterpret_cast<const char*>(&flag_value),sizeof(int)) == SOCKET_ERROR )
            {
                closesocket(sock);
                return OTHER_ERROR;
            }

            // initialize a connection object on the heap with the new socket
            try
            {
                new_connection = new connection (
                                        sock,
                                        foreign_port,
                                        foreign_ip,
                                        used_local_port,
                                        used_local_ip
                                    );
            }
            catch(...) {closesocket(sock);  return OTHER_ERROR; }

            return 0;
        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // WIN32

    #endif // DLIB_SOCKETS_KERNEL_1_CPp_