D:/Programmierung/C/TRTK/src/ClientServer.cpp

/*
    Copyright (C) 2010 - 2017 Christoph Haenisch

    Chair of Medical Engineering (mediTEC)
    RWTH Aachen University
    Pauwelsstr. 20
    52074 Aachen
    Germany

    See license.txt for more information.

    Version 0.1.2 (2017-12-07)
*/

#include <cassert>
#include <cstddef>
#include <iostream>

#include "TRTK/ClientServer.hpp"


#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
    // WINDOWS
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #pragma comment(lib, "Ws2_32.lib") // link with Ws2_32.lib
#else
    // Linux
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <sys/types.h>
    #include <sys/socket.h> // Sometimes sys/socket.h doesn't include sys/types.h, so don't change the order!
    #include <unistd.h>
#endif


namespace TRTK
{


//                               Exceptions                                 //

NetworkError::NetworkError(const std::string & what) : runtime_error(what)
{
}


ConnectionClosed::ConnectionClosed(const std::string & what) : NetworkError(what)
{
}


//                             Helper Functions                             //

enum {DATA_RECEIVED = 1};


void receive_all(int socket_fd, char * & data, size_t & size)
{
    // Each block of data is preceded by a 16 bit word denoting the
    // size of the subsequent block of data.

    char size_LSB = 0; // least significant byte is received first
    char size_MSB = 0; // most significant byte is received second

    int error_code = recv(socket_fd, &size_LSB, 1, 0);

    if (error_code == -1)
    {
        throw NetworkError("Error while receiving data.");
    }
    else if(error_code == 0)
    {
        throw ConnectionClosed("Error: Connection closed."); // EOF can be excluded
    }

    error_code = recv(socket_fd, &size_MSB, 1, 0);

    if (error_code == -1)
    {
        throw NetworkError("Error while receiving data.");
    }
    else if(error_code == 0)
    {
        throw ConnectionClosed("Error: Connection closed."); // EOF can be excluded
    }

    size = ((unsigned short)(reinterpret_cast<unsigned char &>(size_MSB)) << 8) +
            (unsigned short)(reinterpret_cast<unsigned char &>(size_LSB));

    // A transmission can be accidentally disrupted (e.g. due to a kernel
    // interrupt). In that case recv() has to be called several times until
    // the remaining chunks of data are received.

    size_t bytes_left = size;
    data = new char[size];

    while (bytes_left > 0)
    {
        int received_bytes = recv(socket_fd, &data[size - bytes_left], bytes_left, 0); // bytes_left must be of type 'size_t' according to 'The Single UNIX Specification, Version 2'

        if (received_bytes == 0)
        {
            delete[] data;
            throw ConnectionClosed("Error: Connection closed."); // EOF can be excluded since we do not read more bytes than sent
        }

        if (received_bytes == -1)
        {
            delete[] data;
            throw NetworkError("Error while receiving data.");
        }

        bytes_left -= received_bytes;
    }

    // Acknowledge the reception of data.
    // See send_all() for more details why this step is needed.

    char transmission_confirmation = DATA_RECEIVED;

    if (send(socket_fd, &transmission_confirmation, 1, 0) == -1)
    {
        delete[] data;
        throw NetworkError("Error while sending a transmission confirmation.");
    }
}


void send_all(int socket_fd, const char * data, size_t size)
{
    assert(size >= 0 && size < 65536); // 65536 = 2^16
    if (size > 65536) throw NetworkError("Error: Maximum allowed data size is 65536 bytes.");

    // Each block of data is preceded by a 16 bit word denoting the
    // size of the subsequent block of data.

    char size_LSB = size & 0xFF; // least significant byte is send first
    char size_MSB = (size >> 8) & 0xFF; // most significant byte is send second

    if (send(socket_fd, &size_LSB, 1, 0) == -1 || send(socket_fd, &size_MSB, 1, 0) == -1)
    {
        throw NetworkError("Error while sending data.");
    }

    // A transmission can be accidentally disrupted (e.g. due to a kernel
    // interrupt). In that case send() has to be invoked several times
    // until the remaining chunks of data are fully transmitted.

    size_t bytes_left = size;

    while (bytes_left > 0)
    {
        int sent_bytes = send(socket_fd, &data[size - bytes_left], bytes_left, 0); // bytes_left must be of type 'size_T' according to 'The Single UNIX Specification, Version 2'
        if (sent_bytes == -1) throw NetworkError("Error while sending data.");
        bytes_left -= sent_bytes;
    }

    // Receive the transmission confirmation.

    // From [http://bert-hubert.blogspot.de/]:
    //
    // > It turns out that in this case, section 4.2.2.13 of RFC 1122 tells us that a
    // > close() with any pending readable data could lead to an immediate reset being sent.
    // >
    // > "A host MAY implement a 'half-duplex' TCP close sequence, so that an application
    // > that has called CLOSE cannot continue to read data from the connection. If such a
    // > host issues a CLOSE call while received data is still pending in TCP, or if new
    // > data is received after CLOSE is called, its TCP SHOULD send a RST to show that
    // > data was lost."
    //
    // Solution (should always work regardless of the TCP stack implementation):
    //
    // To avoid a potential data loss, a sender can send length information and the receiver
    // actively acknowledges that all data was received.

    char transmission_confirmation = 0;

    int error_code = recv(socket_fd, &transmission_confirmation, 1, 0);

    if (error_code == -1)
    {
        throw NetworkError("Error while getting a transmission confirmation.");
    }
    else if (error_code == 0)
    {
        throw ConnectionClosed("Error: Connection closed."); // EOF can be excluded
    }

    if (transmission_confirmation != DATA_RECEIVED)
    {
        throw NetworkError("Transmission failed.");
    }
}


//                                 Client                                   //

#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
    static int num_winsock_instances = 0;
#endif


Client::Client() : connected(false)
{
    #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
        // Initialize Winsock

        WSADATA wsaData = {0};
        int retval = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if (retval != 0)
        {
            throw(NetworkError("Error: WSAStartup failed."));
        }

        ++num_winsock_instances;
    #endif
}


Client::~Client()
{
    if (connected)
    {
        disconnect();
    }

    #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
        if (num_winsock_instances > 0)
        {
            WSACleanup();
            --num_winsock_instances;
        }
    #endif
}


void Client::connect(std::string host, short port)
{
    // Set up a socket.

    socket_fd = static_cast<int>(socket(AF_INET, SOCK_STREAM, 0)); // returns type 'int' according to 'The Single UNIX Specification, Version 2'

    if (socket_fd == -1)
    {
        throw(NetworkError("Error while setting up the stream socket."));
    }

    // Assign a name to the socket (binding).

    sockaddr_in address = {0};
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr(host.c_str());
    address.sin_port = htons(port);

    socklen_t sockaddr_in_size = sizeof(sockaddr_in);

    if (::connect(socket_fd, reinterpret_cast<sockaddr *>(&address), sockaddr_in_size) == -1)
    {
        throw NetworkError("Error while establishing a connection.");
    }

    connected = true;
}


void Client::disconnect()
{
    if (connected)
    {
        #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
            closesocket(socket_fd);
        #else
            close(socket_fd);
        #endif

        connected = false;
    }
}


void Client::receiveData(char * & data, size_t & size)
{
    receive_all(socket_fd, data, size);
}


std::pair<char *, size_t> Client::request(const char * data, size_t size)
{
    char * received_data = NULL;
    size_t received_data_size = 0;

    sendData(data, size);
    receiveData(received_data, received_data_size);

    return std::pair<char *, size_t>(received_data, received_data_size);
}


void Client::sendData(const char * data, size_t size)
{
    send_all(socket_fd, data, size);
}


//                                 Server                                   //

Server::Server() : close_connection(false), stop_server(false)
{
    #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
        // Initialize Winsock

        WSADATA wsaData = {0};
        int retval = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if (retval != 0)
        {
            throw(NetworkError("Error: WSAStartup failed."));
        }

        ++num_winsock_instances;
    #endif
}


Server::~Server()
{
    #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
        if (num_winsock_instances > 0)
        {
            WSACleanup();
            --num_winsock_instances;
        }
    #endif
}


void Server::closeConnection()
{
    close_connection = true;
}


void Server::receiveData(char * & data, size_t & size)
{
    receive_all(client_fd, data, size);
}


void Server::sendData(const char * data, size_t size)
{
    send_all(client_fd, data, size);
}


void Server::startServer(short port)
{
    // Set up a socket.

    int server_fd = static_cast<int>(socket(AF_INET, SOCK_STREAM, 0)); // returns type 'int' according to 'The Single UNIX Specification, Version 2'

    if (server_fd == -1)
    {
        throw(NetworkError("Error while setting up the stream socket."));
    }

    // Assign a name to the socket (binding).

    sockaddr_in address = {0};
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_ANY);
    address.sin_port = htons(port);

    socklen_t sockaddr_in_size = sizeof(sockaddr_in);

    if (bind(server_fd, reinterpret_cast<sockaddr*>(&address), sockaddr_in_size) == -1)
    {
        throw NetworkError("Error while binding the stream socket.");
    }

    while (!stop_server)
    {
        // Listen to a client.

        if (listen(server_fd, 5) == -1)
        {
            throw NetworkError("Error while listening for connections.");
        }

        // Accecpt a connection.

        sockaddr_in client_address;
        client_fd = static_cast<int>(accept(server_fd, reinterpret_cast<sockaddr*>(&client_address), &sockaddr_in_size)); // returns type 'int' according to 'The Single UNIX Specification, Version 2'

        if (client_fd == -1)
        {
            throw NetworkError("Error while accepting the connection.");
        }

        close_connection = false;

        try
        {
            while (!close_connection)
            {
                // Read the data/request.

                char * data = NULL;
                size_t data_size = 0;

                try
                {
                    receiveData(data, data_size);
                }
                catch (ConnectionClosed)
                {
                    delete[] data;
                    break;
                }

                // Hand the data on to the derived class.

                std::pair<char *, size_t> reply = handleRequest(data, data_size);

                // Send the server's answer to the client.

                try
                {
                    sendData(reply.first, reply.second);
                }
                catch (ConnectionClosed)
                {
                    delete[] reply.first;
                    delete[] data;
                    break;
                }
                catch(...)
                {
                    delete[] reply.first;
                    delete[] data;
                    throw;
                }

                // Clean up.

                delete[] reply.first;
                delete[] data;
            }
        }
        catch (NetworkError)
        {
            // There seems to be a connection problem so close the
            // current connection and listen to new clients.

            std::cerr << "Server error: Client connection died..." << std::endl;
        }

        // Close the connection.

        #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
            closesocket(client_fd);
        #else
            close(client_fd);
        #endif
    }

    #if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
        closesocket(server_fd);
    #else
        close(server_fd);
    #endif

    stop_server = false;
}


void Server::stopServer()
{
    stop_server = true;
}


} // namespace TRTK