TcpSocket.h

Go to the documentation of this file.

/*
 * clockUtils
 * Copyright (2015) Michael Baer, Daniel Bonrath, All rights reserved.
 *
 * This file is part of clockUtils; clockUtils is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __CLOCKUTILS_SOCKETS_TCPSOCKET_H__
#define __CLOCKUTILS_SOCKETS_TCPSOCKET_H__

#include <condition_variable>
#include <cstdint>
#include <functional>
#include <mutex>
#include <queue>
#include <sstream>
#include <string>
#include <vector>

#include "clockUtils/errors.h"

#include "clockUtils/sockets/socketsParameters.h"
#include "clockUtils/sockets/Commons.h"

#if CLOCKUTILS_PLATFORM == CLOCKUTILS_PLATFORM_WIN32
        #include <WinSock2.h>

        typedef int32_t socklen_t;
#elif CLOCKUTILS_PLATFORM == CLOCKUTILS_PLATFORM_LINUX
        #include <arpa/inet.h>
        #include <cstring>
        #include <fcntl.h>
        #include <netdb.h>
        #include <netinet/in.h>
        #include <sys/socket.h>
        #include <sys/types.h>
        #include <unistd.h>

        typedef int SOCKET;
        #define INVALID_SOCKET -1
#endif

namespace std {
        class thread;
} /* namespace std */
namespace clockUtils {
        enum class ClockError;
namespace sockets {

        class CLOCK_SOCKETS_API TcpSocket {
        public:
                typedef std::function<void(TcpSocket *, ClockError)> acceptCallback;

                typedef std::function<void(std::vector<uint8_t> packet, TcpSocket * socket, ClockError err)> packetCallback;

                TcpSocket();

                ~TcpSocket();

                ClockError listen(uint16_t listenPort, int maxParallelConnections, bool acceptMultiple, const acceptCallback acb);

                ClockError connectToIP(const std::string & remoteIP, uint16_t remotePort, unsigned int timeout) {
                        IPv4 ip = convertIP(remoteIP);
                        if (ip == NO_IP) {
                                // not a valid hostname
                                return ClockError::INVALID_IP;
                        }
                        return connect(ip, remotePort, timeout);
                }

                ClockError connectToHostname(const std::string & remoteHostname, uint16_t remotePort, unsigned int timeout) {
                        IPv4 ip = resolveHostname(remoteHostname);
                        if (ip == NO_IP) {
                                // not a valid hostname
                                return ClockError::INVALID_IP;
                        }
                        return connect(ip, remotePort, timeout);
                }

                ClockError connect(const IPv4 remoteIP, uint16_t remotePort, unsigned int timeout);

                void close();

                std::string getRemoteIP() const;

                uint16_t getRemotePort() const;

                static std::vector<std::pair<std::string, std::string>> enumerateLocalIPs();

                std::string getLocalIP() const;

                std::string getPublicIP() const;

                uint16_t getLocalPort() const;

                ClockError writePacket(const void * str, const size_t length);

                ClockError writePacket(const std::vector<uint8_t> & vec);

                ClockError writePacket(const std::string & str) {
                        return writePacket(str.c_str(), str.size());
                }

                ClockError writePacketAsync(const void * str, const size_t length);

                ClockError writePacketAsync(const std::vector<uint8_t> & vec);

                ClockError writePacketAsync(const std::string & str) {
                        return writePacketAsync(std::vector<uint8_t>(str.begin(), str.end()));
                }

                ClockError receivePacket(std::vector<uint8_t> & buffer);

                ClockError receivePacket(std::string & buffer);

                ClockError receiveCallback(packetCallback pcb);

                ClockError write(const void * str, size_t length);

                ClockError write(const std::vector<uint8_t> & vec);

                ClockError write(const std::string & str) {
                        return write(str.c_str(), str.length());
                }

                ClockError writeAsync(const void * str, const size_t length);

                ClockError writeAsync(const std::vector<uint8_t> & vec);

                ClockError writeAsync(const std::string & str) {
                        return writeAsync(std::vector<uint8_t>(str.begin(), str.end()));
                }

                template<class Container>
                ClockError read(Container & buffer) {
                        if (_status != SocketStatus::CONNECTED) {
                                return ClockError::NOT_READY;
                        }

                        buffer.resize(260);
                        int rc = -1;

                        do {
#if CLOCKUTILS_PLATFORM == CLOCKUTILS_PLATFORM_LINUX
                                rc = recv(_sock, &buffer[0], 256, 0);
#elif CLOCKUTILS_PLATFORM == CLOCKUTILS_PLATFORM_WIN32
                                rc = recv(_sock, reinterpret_cast<char *>(&buffer[0]), 256, 0);
#endif

                                if (rc == -1) {
                                        ClockError error = getLastError();

                                        if (error == ClockError::IN_PROGRESS) {
                                                continue;
                                        }

                                        return error;
                                } else if (rc == 0) {
                                        return ClockError::NOT_CONNECTED;
                                }
                                break;
                        } while (true);

                        buffer.resize(size_t(rc));

                        return ClockError::SUCCESS;
                }

                template<typename T>
                typename std::enable_if<std::is_enum<T>::value, TcpSocket &>::type operator<<(const T & a) {
                        std::stringstream ss;
                        ss << uint32_t(a);
                        writePacket(ss.str());
                        return *this;
                }

                template<typename T>
                typename std::enable_if<!std::is_enum<T>::value, TcpSocket &>::type operator<<(const T & a) {
                        std::stringstream ss;
                        ss << a;
                        writePacket(ss.str());
                        return *this;
                }

                template<typename T>
                typename std::enable_if<std::is_enum<T>::value, TcpSocket &>::type operator>>(T & a) {
                        std::string buffer;
                        receivePacket(buffer);
                        std::stringstream ss(buffer);
                        uint32_t e;
                        ss >> e;
                        a = T(e);
                        return *this;
                }

                template<typename T>
                typename std::enable_if<!std::is_enum<T>::value, TcpSocket &>::type operator>>(T & a) {
                        std::string buffer;
                        receivePacket(buffer);
                        std::stringstream ss(buffer);
                        ss >> a;
                        return *this;
                }

        private:
                enum class SocketStatus {
                        INACTIVE,       //<! socket was only created, but is neither listening nor connected
                        LISTENING,      //<! socket is listening on connections
                        CONNECTED       //<! socket is connected to another socket
                };

                SOCKET _sock;

                SocketStatus _status;

                std::mutex _writePacketAsyncLock;
                std::mutex _writeAsyncLock;

                std::queue<std::vector<uint8_t>> _writePacketAsyncQueue;
                std::queue<std::vector<uint8_t>> _writeAsyncQueue;

                std::vector<uint8_t> _buffer;

                bool _terminate;

                std::thread * _worker;
                std::thread * _listenThread;

                std::condition_variable _condVar;
                std::mutex _condMutex;

                std::thread * _callbackThread;

                TcpSocket(SOCKET fd);

                ClockError getLastError();

                void work();

                void closeSocket();

                void listenFunc(SOCKET sock, bool acceptMultiple, const acceptCallback acb);

                TcpSocket(const TcpSocket &) = delete;
                TcpSocket & operator=(const TcpSocket &) = delete;
        };

        template<>
        CLOCK_SOCKETS_API TcpSocket & TcpSocket::operator<< <std::string>(const std::string & s);

        template<>
        CLOCK_SOCKETS_API TcpSocket & TcpSocket::operator>> <std::string>(std::string & s);

} /* namespace sockets */
} /* namespace clockUtils */

#endif /* __CLOCKUTILS_SOCKETS_TCPSOCKET_H__ */