Use OS socket API instead of Qt's socket API.

Author: Mysticial

Common/Cpp/Sockets/AbstractClientSocket.h

@@ -0,0 +1,75 @@
+/*  Abstract Client Socket
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#ifndef PokemonAutomation_Sockets_AbstractClientSocket_H
+#define PokemonAutomation_Sockets_AbstractClientSocket_H
+
+#include <string>
+#include "Common/Compiler.h"
+#include "Common/Cpp/ListenerSet.h"
+
+namespace PokemonAutomation{
+
+
+
+class AbstractClientSocket{
+public:
+    enum class State{
+        NOT_RUNNING,
+        CONNECTING,
+        CONNECTED,
+        DESTRUCTING,
+    };
+
+    struct Listener{
+        //  Called at the start of the receiver thread. This can be used to set
+        //  the thread priority of the thread.
+        virtual void on_thread_start(){}
+
+        //  Called when a connection attempt finishes.
+        //  If successful, "error_message" is empty.
+        //  Otherwise, it contains the error message.
+        virtual void on_connect_finished(const std::string& error_message){}
+
+        //  Called when the socket receives data from the server.
+        virtual void on_receive_data(const void* data, size_t bytes){}
+    };
+
+    void add_listener(Listener& listener){
+        m_listeners.add(listener);
+    }
+    void remove_listener(Listener& listener){
+        m_listeners.add(listener);
+    }
+
+
+public:
+    AbstractClientSocket()
+        : m_state(State::NOT_RUNNING)
+    {}
+    virtual ~AbstractClientSocket() = default;
+
+    State state() const{
+        return m_state.load(std::memory_order_relaxed);
+    }
+
+    virtual void close() noexcept = 0;
+    virtual void connect(const std::string& address, uint16_t port) = 0;
+
+    virtual size_t blocking_send(const void* data, size_t bytes) = 0;
+
+
+protected:
+    std::atomic<State> m_state;
+    ListenerSet<Listener> m_listeners;
+};
+
+
+
+
+
+}
+#endif

Common/Cpp/Sockets/ClientSocket.cpp

@@ -0,0 +1,14 @@
+/*  Client Socket
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#include "ClientSocket.h"
+
+namespace PokemonAutomation{
+
+
+
+
+}

Common/Cpp/Sockets/ClientSocket.h

@@ -0,0 +1,26 @@
+/*  Client Socket
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#ifndef PokemonAutomation_ClientSocket_H
+#define PokemonAutomation_ClientSocket_H
+
+
+
+#ifdef _WIN32
+#include "ClientSocket_WinSocket.h"
+namespace PokemonAutomation{
+    using ClientSocket = ClientSocket_WinSocket;
+}
+#else
+#include "ClientSocket_POSIX.h"
+namespace PokemonAutomation{
+    using ClientSocket = ClientSocket_POSIX;
+}
+#endif
+
+
+
+#endif

Common/Cpp/Sockets/ClientSocket_POSIX.h

@@ -0,0 +1,233 @@
+/*  Client Socket (POSIX)
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ *      This file is completely untested!
+ *
+ */
+
+#ifndef PokemonAutomation_ClientSocket_POSIX_H
+#define PokemonAutomation_ClientSocket_POSIX_H
+
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+#include <sys/socket.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include "AbstractClientSocket.h"
+
+namespace PokemonAutomation{
+
+
+
+class ClientSocket_POSIX final : public AbstractClientSocket{
+public:
+    ClientSocket_POSIX()
+        : m_socket(-1)
+    {}
+
+    virtual ~ClientSocket_POSIX(){
+        close();
+        if (m_thread.joinable()){
+            m_thread.join();
+        }
+        if (m_socket != -1){
+            ::close(m_socket);
+        }
+    }
+    virtual void close() noexcept override{
+        {
+            std::lock_guard<std::mutex> lg1(m_lock);
+            m_state.store(State::DESTRUCTING, std::memory_order_relaxed);
+            m_cv.notify_all();
+        }
+    }
+
+    virtual void connect(const std::string& address, uint16_t port) override{
+        std::lock_guard<std::mutex> lg1(m_lock);
+        if (m_state.load(std::memory_order_relaxed) != State::NOT_RUNNING){
+            return;
+        }
+        try{
+            m_socket = socket(AF_INET, SOCK_STREAM, 0);
+            fcntl(m_socket, F_SETFL, O_NONBLOCK);
+            m_state.store(State::CONNECTING, std::memory_order_relaxed);
+            m_thread = std::thread(
+                &ClientSocket_POSIX::thread_loop,
+                this, address, port
+            );
+        }catch (...){
+            ::close(m_socket);
+            m_socket = -1;
+            m_state.store(State::NOT_RUNNING, std::memory_order_relaxed);
+            throw;
+        }
+    }
+
+
+    virtual size_t blocking_send(const void* data, size_t bytes) override{
+        std::unique_lock<std::mutex> lg(m_lock);
+        constexpr int BLOCK_SIZE = (int)1 << 30;
+        const char* ptr = (const char*)data;
+        size_t sent = 0;
+        if (m_socket == -1){
+            return 0;
+        }
+        bool skip_wait = true;
+        while (bytes > 0){
+            if (!skip_wait){
+                m_cv.wait_for(lg, std::chrono::milliseconds(1));
+            }
+            skip_wait = true;
+
+            size_t current = std::min<size_t>(bytes, BLOCK_SIZE);
+            int current_sent = ::send(m_socket, ptr, (int)current, MSG_DONTWAIT);
+            if (current_sent != -1){
+                sent += current;
+                if ((size_t)current_sent < current){
+                    return sent;
+                }
+                ptr += current;
+                bytes -= current;
+                continue;
+            }
+
+            int error = errno;
+//            cout << "error = " << error << endl;
+            switch (error){
+            case EAGAIN:
+//            case EWOULDBLOCK:
+                break;
+            default:
+                m_error = "POSIX Error Code: " + std::to_string(error);
+                return sent;
+            }
+        }
+        return sent;
+    }
+
+
+private:
+    void thread_loop(const std::string& address, uint16_t port){
+        try{
+            thread_loop_internal(address, port);
+        }catch (...){
+            try{
+                std::cout << "ClientSocket_POSIX(): An exception was thrown from the receive thread." << std::endl;
+            }catch (...){}
+        }
+    }
+
+    void thread_loop_internal(const std::string& address, uint16_t port){
+        m_listeners.run_method_unique(&Listener::on_thread_start);
+
+        {
+            std::unique_lock<std::mutex> lg(m_lock);
+
+            sockaddr_in server;
+            server.sin_family = AF_INET;
+            server.sin_port = htons(port);
+            server.sin_addr.s_addr = inet_addr(address.c_str());
+
+            //  Connect
+            while (true){
+                State state = m_state.load(std::memory_order_relaxed);
+                if (state == State::DESTRUCTING){
+                    return;
+                }
+
+                if (::connect(m_socket, (struct sockaddr*)&server, sizeof(server)) != -1){
+                    break;
+                }
+
+                int error = errno;
+//                cout << "error = " << error << endl;
+
+                switch (error){
+                case EISCONN:
+                    goto Connected;
+                case EAGAIN:
+                case EALREADY:
+                case EINPROGRESS:
+                    break;
+                case ETIMEDOUT:
+                    m_state.store(State::NOT_RUNNING, std::memory_order_relaxed);
+                    m_error = "Connection timed out.";
+                    m_lock.unlock();
+                    m_listeners.run_method_unique(&Listener::on_connect_finished, m_error);
+                    return;
+                default:
+                    m_state.store(State::NOT_RUNNING, std::memory_order_relaxed);
+                    m_error = "WSA Error Code: " + std::to_string(error);
+                    m_lock.unlock();
+                    m_listeners.run_method_unique(&Listener::on_connect_finished, m_error);
+                    return;
+                }
+
+                m_cv.wait_for(lg, std::chrono::milliseconds(10));
+
+            }
+
+Connected:
+            m_state.store(State::CONNECTED, std::memory_order_relaxed);
+        }
+
+        m_listeners.run_method_unique(&Listener::on_connect_finished, "");
+
+
+        constexpr size_t BUFFER_SIZE = 4096;
+        char buffer[BUFFER_SIZE];
+
+        while (true){
+            int bytes;
+            int error = 0;
+            {
+                std::unique_lock<std::mutex> lg(m_lock);
+                State state = m_state.load(std::memory_order_relaxed);
+                if (state == State::DESTRUCTING){
+                    return;
+                }
+                bytes = ::recv(m_socket, buffer, BUFFER_SIZE, 0);
+                if (bytes < 0){
+                    error = errno;
+                }
+            }
+
+            if (bytes > 0){
+                m_listeners.run_method_unique(&Listener::on_receive_data, buffer, bytes);
+            }else if (bytes < 0){
+//                cout << "error = " << error << endl;
+                switch (error){
+                case EAGAIN:
+//                case EWOULDBLOCK:
+                    break;
+                default:
+                    std::unique_lock<std::mutex> lg(m_lock);
+                    m_error = "POSIX Error Code: " + std::to_string(error);
+                    return;
+                }
+            }
+
+            std::unique_lock<std::mutex> lg(m_lock);
+            m_cv.wait_for(lg, std::chrono::milliseconds(1));
+        }
+
+    }
+
+
+private:
+    int m_socket;
+
+    std::string m_error;
+
+    mutable std::mutex m_lock;
+    std::condition_variable m_cv;
+    std::thread m_thread;
+};
+
+
+}
+#endif