UdpSocket.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_UDPSOCKET_H__
#define __CLOCKUTILS_SOCKETS_UDPSOCKET_H__

#include <condition_variable>
#include <cstdint>
#include <functional>
#include <map>
#include <mutex>
#include <queue>
#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;

        // already defined by MSVC
        // #define INVALID_SOCKET -1
#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 UdpSocket {
        public:
                typedef std::function<void(std::vector<uint8_t> packet, std::string ip, uint16_t port, ClockError err)> packetCallback;

                const size_t MAX_PACKET_SIZE = 32 * 1024;

                UdpSocket();

                ~UdpSocket();

                ClockError bind(uint16_t port);

                void close();

                ClockError writePacket(IPv4 ip, uint16_t port, const void * str, const size_t length);

                ClockError writePacket(IPv4 ip, uint16_t port, const std::vector<uint8_t> & vec);

                ClockError writePacket(IPv4 ip, uint16_t port, const std::string & str) {
                        return writePacket(ip, port, str.c_str(), str.length());
                }

                ClockError writePacketAsync(IPv4 ip, uint16_t port, const void * str, const size_t length);

                ClockError writePacketAsync(IPv4 ip, uint16_t port, const std::vector<uint8_t> & vec);

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

                ClockError write(IPv4 ip, uint16_t port, const void * str, size_t length);

                ClockError write(IPv4 ip, uint16_t port, const std::vector<uint8_t> & vec) {
                        return write(ip, port, const_cast<const unsigned char *>(&vec[0]), vec.size());
                }

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

                ClockError writeAsync(IPv4 ip, uint16_t port, const void * str, size_t length);

                ClockError writeAsync(IPv4 ip, uint16_t port, const std::vector<uint8_t> & vec);

                ClockError writeAsync(IPv4 ip, uint16_t port, const std::string & str) {
                        return writeAsync(ip, port, std::vector<uint8_t>(str.begin(), str.end()));
                }
                template<typename... T>
                ClockError writePacketToIP(const std::string & ip, uint16_t port, T... data) {
                        return writePacket(convertIP(ip), port, data...);
                }

                template<typename... T>
                ClockError writePacketToIPAsync(const std::string & ip, uint16_t port, T... data) {
                        return writePacketAsync(convertIP(ip), port, data...);
                }

                template<typename... T>
                ClockError writeToIP(const std::string & ip, uint16_t port, T... data) {
                        return write(convertIP(ip), port, data...);
                }

                template<typename... T>
                ClockError writeToIPAsync(const std::string & ip, uint16_t port, T... data) {
                        return writeAsync(convertIP(ip), port, data...);
                }

                template<typename... T>
                ClockError writePacketToHostname(const std::string & hostname, uint16_t port, T... data) {
                        return writePacket(resolveHostname(hostname), port, data...);
                }

                template<typename... T>
                ClockError writePacketToHostnameAsync(const std::string & hostname, uint16_t port, T... data) {
                        return writePacketAsync(resolveHostname(hostname), port, data...);
                }

                template<typename... T>
                ClockError writeToHostname(const std::string & hostname, uint16_t port, T... data) {
                        return write(resolveHostname(hostname), port, data...);
                }

                template<typename... T>
                ClockError writeToHostnameAsync(const std::string & hostname, uint16_t port, T... data) {
                        return writeAsync(resolveHostname(hostname), port, data...);
                }

                ClockError receivePacket(std::vector<uint8_t> & buffer, std::string & ip, uint16_t & port);

                ClockError receivePacket(std::string & buffer, std::string & ip, uint16_t & port);

                ClockError receiveCallback(packetCallback pcb);

                template<class Container>
                ClockError read(Container & buffer, std::string & ip, uint16_t & port) {
                        if (_sock == INVALID_SOCKET) {
                                return ClockError::NOT_READY;
                        }

                        buffer.resize(MAX_PACKET_SIZE + 4);
                        int rc = -1;
                        struct sockaddr_in remaddr;
                        remaddr.sin_family = 0;
                        remaddr.sin_port = 0;
                        memset(&remaddr.sin_addr, 0, sizeof(remaddr.sin_addr));
                        memset(remaddr.sin_zero, 0, 8);
                        socklen_t addrlen = sizeof(remaddr);

                        do {
#if CLOCKUTILS_PLATFORM == CLOCKUTILS_PLATFORM_LINUX
                                rc = recvfrom(_sock, &buffer[0], MAX_PACKET_SIZE, 0, (struct sockaddr *) &remaddr, &addrlen);
#elif CLOCKUTILS_PLATFORM == CLOCKUTILS_PLATFORM_WIN32
                                rc = recvfrom(_sock, reinterpret_cast<char *>(&buffer[0]), int(MAX_PACKET_SIZE), 0, (struct sockaddr *) &remaddr, &addrlen);
#endif

                                port = static_cast<uint16_t>(ntohs(remaddr.sin_port));
                                ip = inet_ntoa(remaddr.sin_addr);

                                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;
                }

        private:
                SOCKET _sock;

                std::map<std::pair<std::string, uint16_t>, std::vector<uint8_t>> _buffer;

                std::thread * _callbackThread;

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

                enum AsyncQueueInfo {
                        Message,
                        IP,
                        Port
                };
                std::queue<std::tuple<std::vector<uint8_t>, IPv4, uint16_t>> _writePacketAsyncQueue;
                std::queue<std::tuple<std::vector<uint8_t>, IPv4, uint16_t>> _writeAsyncQueue;

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

                std::thread * _worker;

                bool _terminate;

                ClockError getLastError();

                void work();

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

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

#endif /* __CLOCKUTILS_SOCKETS_UDPSOCKET_H__ */