* add windows support

lpcvoid · lpcvoid · commit 61d884372669 · 2021-11-24T21:02:56.000+01:00
* fix some minor bugs with empty select set
* fix proper error code handling under windows
diff --git a/.github/workflows/test_matrix.yml b/.github/workflows/test_matrix.yml
@@ -13,12 +13,13 @@ jobs:
       fail-fast: false
       matrix:
         config:
-#          - {
-#            name: "Windows MSVC",
-#            os: windows-latest,
-#            build_type: "Release", cc: "cl", cxx: "cl",
-#            environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat"
-#          }
+          - {
+            name: "Windows MSVC",
+            os: windows-latest,
+            build_type: "Release", cc: "cl", cxx: "cl",
+            #this path will change at some point when VC2022 is released I guess
+            environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat"
+          }
           - {
             name: "Ubuntu gcc",
             os: ubuntu-latest,
@@ -45,6 +46,12 @@ jobs:
       - name: Build
         run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
 
-      - name: Test
+      - name: Test on Windows
+        if: startsWith(matrix.config.os, 'windows')
+        working-directory: ${{github.workspace}}/build
+        run: tests/${{env.BUILD_TYPE}}/test_libnetcpp.exe
+
+      - name: Test on Linux/MacOS
+        if: (!startsWith(matrix.config.os, 'windows'))
         working-directory: ${{github.workspace}}/build
-        run: tests/test_libnetcpp
+        run: tests/test_libnetcpp
diff --git a/examples/daytime_client.cpp b/examples/daytime_client.cpp
@@ -24,7 +24,7 @@ int main(int argc, char** argv) {
   std::cout << "Connecting to " << time_host << " on port " << port << std::endl;
   netlib::client client;
 
-  std::error_condition client_create_res =
+  std::error_condition client_create_res = 
       client.connect(time_host, port, netlib::AddressFamily::IPv4,
                      netlib::AddressProtocol::TCP, 1000ms);
 
diff --git a/src/client.hpp b/src/client.hpp
@@ -23,7 +23,7 @@ namespace netlib {
           fd_set fdset;
           FD_ZERO(&fdset);
           FD_SET(sock, &fdset);
-          timeval tv{.tv_sec = timeout.count() / 1000, .tv_usec=static_cast<int32_t>((timeout.count() % 1000) * 1000)};
+          timeval tv{.tv_sec = static_cast<int32_t>(timeout.count() / 1000), .tv_usec=static_cast<int32_t>((timeout.count() % 1000) * 1000)};
           std::cout << "tv.tv_sec = " << tv.tv_sec << ", usec=" << tv.tv_usec << std::endl;
           fd_set* fdset_ptr_read = ((op_class == OperationClass::read) || (op_class == OperationClass::both)) ? &fdset : nullptr;
           fd_set* fdset_ptr_write = ((op_class == OperationClass::write) || (op_class == OperationClass::both)) ? &fdset : nullptr;
@@ -61,10 +61,13 @@ namespace netlib {
         }
 
       public:
-        client() = default;
+        client(){
+          netlib::socket::initialize_system();
+        }
         client(netlib::socket sock, addrinfo* endpoint){
           _socket = sock;
           _endpoint_addr = endpoint;
+          netlib::socket::initialize_system();
         }
         virtual ~client() {
           disconnect();
@@ -97,7 +100,9 @@ namespace netlib {
             int32_t connect_result = ::connect(sock.get_raw().value(), res_addrinfo->ai_addr, res_addrinfo->ai_addrlen);
             if (connect_result == -1) {
               std::error_condition error_condition = socket_get_last_error();
-              if (error_condition != std::errc::operation_in_progress) {
+              if ((error_condition != std::errc::operation_in_progress) &&
+                  (error_condition != std::errc::operation_would_block))
+              {
                 freeaddrinfo(addrinfo_result.first);
                 return error_condition;
               }
@@ -153,10 +158,10 @@ namespace netlib {
           if (wait_res.first) {
             return {0, wait_res.first};
           }
-          ssize_t send_res = ::send(_socket.value().get_raw().value(), data.data(), data.size(), 0);
+          ssize_t send_res = ::send(_socket.value().get_raw().value(), reinterpret_cast<const char*>(data.data()), data.size(), 0);
           if (send_res >= 0) {
             if (send_res == data.size()) {
-              return {send_res, {}};
+              return {static_cast<std::size_t>(send_res), {}};
             }
             return {send_res, std::errc::message_size};
           }
@@ -188,7 +193,7 @@ namespace netlib {
           std::cout << "client recv after wait" << std::endl;
 
           std::vector<uint8_t> data(byte_count, 0);
-          ssize_t recv_res = ::recv(_socket.value().get_raw().value(), data.data(), byte_count, 0);
+          ssize_t recv_res = ::recv(_socket.value().get_raw().value(), reinterpret_cast<char*>(data.data()), byte_count, 0);
           if (recv_res > 0) {
             std::cout << "client recv " << recv_res << std::endl;
             data.resize(recv_res);
diff --git a/src/endpoint_accessor.hpp b/src/endpoint_accessor.hpp
@@ -1,12 +1,10 @@
 #pragma once
-#include <arpa/inet.h>
 #include <array>
 #include <cstring>
-#include <netdb.h>
-#include <netinet/in.h>
 #include <optional>
 #include <string>
-#include <sys/socket.h>
+#include "socket.hpp"
+
 
 namespace netlib {
   class endpoint_accessor {
diff --git a/src/server.hpp b/src/server.hpp
@@ -9,6 +9,7 @@
 #include <iostream>
 #include <map>
 #include <mutex>
+#include <array>
 #include <optional>
 #include <thread>
 #include <utility>
@@ -69,6 +70,13 @@ namespace netlib {
                 FD_SET(fd, &fdset);
               }
             }
+
+            //windows returns WSAEINVAL if we have nothing to pass to select, so we
+            //need to filter this previously and elmulate the sleeping
+            if (!highest_fd) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(50));
+                continue;
+            }
             //we want the timeout to be fairly low, so that we avoid situations where
             //we have a new client in _clients, but are not monitoring it yet - that
             //would mean we have a "hardcoded" delay in servicing a new clients packets
@@ -119,14 +127,14 @@ namespace netlib {
             std::this_thread::sleep_for(std::chrono::milliseconds(10));
             new_endpoint.addr_len = sizeof(addrinfo);
             socket_t status = ::accept(_listener_sock->get_raw().value(), &new_endpoint.addr, &new_endpoint.addr_len);
-            if (status > 0) {
+            if (status != INVALID_SOCKET) {
               new_endpoint.socket.set_raw(status);
               new_endpoint.socket.set_nonblocking(true);
               if (_cb_onconnect) {
                 netlib::server_response greeting = _cb_onconnect(new_endpoint);
                 if (!greeting.answer.empty()) {
                   ssize_t send_result = ::send(new_endpoint.socket.get_raw().value(),
-                                               greeting.answer.data(),
+                                               reinterpret_cast<const char*>(greeting.answer.data()),
                                                greeting.answer.size(),
                                                0);
                   if ((send_result != greeting.answer.size()) && (_cb_on_error)) {
@@ -159,7 +167,7 @@ namespace netlib {
           ssize_t recv_res = 0;
           while (true) {
             recv_res = ::recv(endpoint.socket.get_raw().value(),
-                                    buffer.data(), buffer.size(), 0);
+                                    reinterpret_cast<char*>(buffer.data()), buffer.size(), 0);
             if (recv_res > 0) {
               total_buffer.insert(total_buffer.end(), buffer.begin(),
                                   buffer.begin() + recv_res);
@@ -180,7 +188,7 @@ namespace netlib {
                   if (!response.answer.empty()) {
                     ssize_t send_result = ::send(
                         endpoint.socket.get_raw().value(),
-                        response.answer.data(), response.answer.size(), 0);
+                        reinterpret_cast<const char*>(response.answer.data()), response.answer.size(), 0);
                     if (send_result != response.answer.size()) {
                       return socket_get_last_error();
                     }
@@ -217,7 +225,9 @@ namespace netlib {
         }
 
       public:
-        server() = default;
+        server() {
+          netlib::socket::initialize_system();
+        }
         virtual ~server() { stop();
         }
         inline std::error_condition create(const std::string& bind_host,
diff --git a/src/service_resolver.hpp b/src/service_resolver.hpp
@@ -38,7 +38,6 @@ namespace netlib {
       case EAI_ADDRFAMILY:
 #endif
       case EAI_NODATA:
-      case EAI_NONAME:
       case EAI_FAIL: {
         return { nullptr, std::errc::network_unreachable};
       }
diff --git a/src/socket.hpp b/src/socket.hpp
@@ -9,12 +9,13 @@
 #pragma comment(lib, "Ws2_32.lib")
 #pragma comment(lib, "AdvApi32.lib")
 
-    //headers
-    #include <winsock2.h>
-    #include <iphlpapi.h>
-    #include <windows.h>
-    #include <ws2tcpip.h>
-  #include <stdint.h>
+//headers
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#include <Windows.h>
+#include <iphlpapi.h>
+#include <ws2tcpip.h>
+#include <stdint.h>
 
 //defines
 using socket_t = SOCKET;
@@ -39,11 +40,13 @@ using socket_t = int32_t;
 namespace netlib {
 
     static std::error_condition socket_get_last_error(){
+        std::error_code ec;
 #ifdef _WIN32
-      return std::make_error_condition(static_cast<std::errc>(WASGetLastError()));
+        ec = std::error_code(::GetLastError(), std::system_category());
 #else
-      return std::make_error_condition(static_cast<std::errc>(errno));
+        ec = std::error_code(errno, std::system_category());
 #endif
+        return ec.default_error_condition();
 }
 
     enum class AddressFamily {IPv4 = AF_INET, IPv6 = AF_INET6, unspecified = AF_UNSPEC};
@@ -53,21 +56,20 @@ namespace netlib {
     class socket {
     private:
         std::optional<socket_t> _socket = std::nullopt;
+    public:
+      socket() = default;
 
-        static bool initialize_system() {
+      static bool initialize_system() {
 #ifdef _WIN32
-            static bool initialized = false;
-            if (!initialized) {
-                WSADATA wsaData;
-                WSAStartup(MAKEWORD(2,2), &wsaData);
-                initialized = true;
-            }
-#else
-            return true;
+          static bool initialized = false;
+          if (!initialized) {
+              WSADATA wsaData;
+              WSAStartup(MAKEWORD(2, 2), &wsaData);
+              initialized = true;
+          }
 #endif
-        }
-    public:
-      socket() = default;
+          return true;
+      }
 
         bool is_valid() {
             return _socket.has_value() && _socket.value() != INVALID_SOCKET;
diff --git a/src/thread_pool.hpp b/src/thread_pool.hpp
@@ -86,8 +86,7 @@ namespace netlib {
     }
     //https://stackoverflow.com/a/31078143
     template <typename FUNCTION, typename... FUNCARGS>
-    std::future<typename std::result_of<FUNCTION(FUNCARGS...)>::type>
-    add_task(FUNCTION&& function, FUNCARGS&&... args) {
+    auto add_task(FUNCTION&& function, FUNCARGS&&... args) {
       // first, check if we even have a free thread
       // if not, we add one up to a max allowed
       std::size_t free_threads = (get_thread_count() - get_task_count());
diff --git a/tests/test_client_server.cpp b/tests/test_client_server.cpp
@@ -31,8 +31,6 @@ TEST_CASE("Test server with callbacks") {
   bool client_was_connected = false;
   bool client_has_sent = false;
 
-
-
   std::cout << "****Starting failing test" << std::endl;
 
   server.register_callback_on_connect(

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,6 @@ namespace netlib {`
`38`	`38`	`case EAI_ADDRFAMILY:`
`39`	`39`	`#endif`
`40`	`40`	`case EAI_NODATA:`
`41`		`- case EAI_NONAME:`
`42`	`41`	`case EAI_FAIL: {`
`43`	`42`	`return { nullptr, std::errc::network_unreachable};`
`44`	`43`	`}`