Merge pull request #1 from lpcvoid/testing_windows

Testing other platforms and testing CI

Author: lpcvoid

.github/workflows/cmake.yml

@@ -0,0 +1,50 @@
+name: CMake Build Matrix
+
+on: [push]
+
+env:
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    name: ${{ matrix.config.name }}
+    runs-on: ${{ matrix.config.os }}
+    strategy:
+      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: "Ubuntu gcc",
+            os: ubuntu-latest,
+            build_type: "Release", cc: "gcc", cxx: "g++"
+          }
+          - {
+            name: "Ubuntu clang",
+            os: ubuntu-latest,
+            build_type: "Release", cc: "clang", cxx: "clang++"
+          }
+          - {
+            name: "macOS clang",
+            os: macos-latest,
+            build_type: "Release", cc: "clang", cxx: "clang++"
+          }
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'true'
+
+      - name: Configure CMake
+        run: cmake -B ${{github.workspace}}/build -DBUILD_TESTS=ON
+
+      - name: Build
+        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+      - name: Test
+        working-directory: ${{github.workspace}}/build
+        run: tests/test_libnetcpp

.github/workflows/test_matrix.yml

@@ -2,10 +2,18 @@ cmake_minimum_required(VERSION 3.15)
 project(netlib)
 set(CMAKE_CXX_STANDARD 20)
 
+# we want the maximum amount of compiler bickering
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+endif()
+
+find_package(Threads)
+
 set(NETLIB_SRC
         src/netlib.hpp
         src/socket.hpp
-        src/error.hpp
         src/client.hpp
         src/server.hpp
         src/service_resolver.hpp

CMakeLists.txt

@@ -1,12 +1,10 @@
 # cpp-net-lib
 
-***
-
     This lib is under heavy development and not really ready for use yet.
 
 ![test-status](https://github.com/lpcvoid/cpp-net-lib/actions/workflows/cmake.yml/badge.svg)
 
-Modern, header-only, compact and cross plattform C++ network/sockets library. 
+Modern, header-only, compact and cross-platform C++ network/sockets library. 
 Don't mind the crappy name, I suck at naming things.
 
 ### Why?

README.md

@@ -3,5 +3,5 @@ set(EXAMPLE_SOURCES echo_server.cpp daytime_client.cpp threadpool.cpp time_clien
 foreach (examplesource ${EXAMPLE_SOURCES})
     string(REPLACE ".cpp" "" examplename ${examplesource})
     add_executable(${examplename} ${examplesource})
-    target_link_libraries(${examplename} pthread)
+    target_link_libraries(${examplename} ${CMAKE_THREAD_LIBS_INIT})
 endforeach (examplesource ${EXAMPLE_SOURCES})

examples/CMakeLists.txt

@@ -1,6 +1,7 @@
 #include "../src/netlib.hpp"
 #include <csignal>
 #include <iostream>
+#include <chrono>
 
 using namespace std::chrono_literals;
 

examples/daytime_client.cpp

@@ -4,6 +4,7 @@
 #include "socket.hpp"
 #include "thread_pool.hpp"
 #include <future>
+#include <iostream>
 #include <optional>
 #include <variant>
 #include <vector>
@@ -18,11 +19,12 @@ namespace netlib {
         addrinfo* _endpoint_addr = nullptr;
         netlib::thread_pool _thread_pool = netlib::thread_pool::create<1,1>();
 
-        inline std::pair<std::error_condition, std::chrono::milliseconds>  wait_for_operation(socket_t sock, OperationClass op_class, std::chrono::milliseconds timeout) {
+        static inline std::pair<std::error_condition, std::chrono::milliseconds>  wait_for_operation(socket_t sock, OperationClass op_class, std::chrono::milliseconds timeout) {
           fd_set fdset;
           FD_ZERO(&fdset);
           FD_SET(sock, &fdset);
-          timeval tv{.tv_sec = timeout.count() / 1000, .tv_usec=(timeout.count() % 1000) * 1000 };
+          timeval tv{.tv_sec = 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;
           std::chrono::time_point<std::chrono::steady_clock> start = std::chrono::steady_clock::now();
@@ -31,19 +33,29 @@ namespace netlib {
           std::chrono::milliseconds ms_taken = std::chrono::duration_cast<std::chrono::milliseconds>((end - start));
           if (select_res == 1)
           {
-            int32_t so_error = 0;
-            socklen_t len = sizeof(so_error);
-            getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_error, &len);
-            if (so_error == 0) {
-              //success
-              return {{}, ms_taken};
-            }
-            return {static_cast<std::errc>(so_error), ms_taken};
+            return {{}, ms_taken};
+
+
+
+
+//            int32_t so_error = 0;
+//            socklen_t len = sizeof(so_error);
+//            getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_error, &len);
+//            if (so_error == 0) {
+//              //success
+//              std::cout << "client select no error" << std::endl;
+//              return {{}, ms_taken};
+//            }
+//            std::error_condition error_condition = static_cast<std::errc>(so_error);
+//            std::cout << "client select ret error" << error_condition.message() << std::endl;
+//            return {static_cast<std::errc>(so_error), ms_taken};
           } else if (select_res == 0) {
             //timeout
+            std::cout << "select ret 0 timeout" << std::endl;
             return {std::errc::timed_out, ms_taken};
           } else {
             //error
+            std::cout << "select ret -1" << socket_get_last_error().message() << std::endl;
             return {socket_get_last_error(), ms_taken};
           }
         }
@@ -127,6 +139,8 @@ namespace netlib {
           }, data, timeout);
         }
         inline std::pair<std::size_t, std::error_condition> send(const std::vector<uint8_t> &data, std::optional<std::chrono::milliseconds> timeout) {
+
+          std::cout << "client send: " << data.size() << std::endl;
           if (!is_connected()) {
             return {0, std::errc::not_connected};
           }
@@ -161,22 +175,29 @@ namespace netlib {
           }
 
           if (timeout.has_value() && timeout->count() < 0) {
+            std::cout << "client recv timeout returned" << std::endl;
             return {{}, std::errc::timed_out};
           }
 
           auto wait_res = wait_for_operation(_socket.value().get_raw().value(), OperationClass::read, timeout.value());
           if (wait_res.first) {
+            std::cout << "client recv select timeout returned" << std::endl;
             return {{}, wait_res.first};
           }
 
+          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);
           if (recv_res > 0) {
+            std::cout << "client recv " << recv_res << std::endl;
             data.resize(recv_res);
             return {data, {}};
           } else if (recv_res == 0){
+            std::cout << "client recv 0" << std::endl;
             return {{}, std::errc::connection_aborted};
           }
+          std::cout << "client recv error: " << recv_res << " : " << socket_get_last_error().message() << std::endl;
           return {{}, socket_get_last_error()};
         }
 
@@ -190,10 +211,12 @@ namespace netlib {
           if (_endpoint_addr) {
             freeaddrinfo(_endpoint_addr);
           }
+
+          std::cout << "client disconnected" << std::endl;
           return {};
         }
         inline bool is_connected() {
-          return _socket.has_value();
+          return _socket.has_value() && _socket->is_valid();
         }
         [[nodiscard]] inline std::optional<netlib::socket> get_socket() const {
           return _socket;