* remove debug messages that I added

  for CI debug like it's 1995

Author: lpcvoid

src/client.hpp

@@ -24,7 +24,6 @@ namespace netlib {
           FD_ZERO(&fdset);
           FD_SET(sock, &fdset);
           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;
           std::chrono::time_point<std::chrono::steady_clock> start = std::chrono::steady_clock::now();
@@ -34,28 +33,11 @@ namespace netlib {
           if (select_res == 1)
           {
             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};
           }
         }
@@ -145,7 +127,6 @@ namespace netlib {
         }
         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};
           }
@@ -180,29 +161,22 @@ 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(), reinterpret_cast<char*>(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()};
         }
 
@@ -217,7 +191,6 @@ namespace netlib {
             freeaddrinfo(_endpoint_addr);
           }
 
-          std::cout << "client disconnected" << std::endl;
           return {};
         }
         inline bool is_connected() {

src/server.hpp

@@ -116,7 +116,6 @@ namespace netlib {
               //nothing interesting happened before timeout
             } else {
               //error was returned
-              std::cerr << "server select error: " << socket_get_last_error().message() << std::endl;
             }
           }
         }
@@ -138,7 +137,6 @@ namespace netlib {
                                                greeting.answer.size(),
                                                0);
                   if ((static_cast<std::size_t>(send_result) != greeting.answer.size()) && (_cb_on_error)) {
-                    std::cout << "server error accept" << std::endl;
                     _cb_on_error(new_endpoint, socket_get_last_error());
                   }
                 }
@@ -147,13 +145,11 @@ namespace netlib {
                     _cb_on_error(new_endpoint, std::errc::connection_aborted);
                   }
                   remove_client(new_endpoint);
-                  std::cout << "server kicked client accept" << std::endl;
                   continue;
                 }
               }
               if (new_endpoint.socket.is_valid()) {
                 std::lock_guard<std::mutex> lock(_mutex);
-                std::cout << "server added new client, id " << status << std::endl;
                 _clients.push_back(new_endpoint);
                 _busy_map[status] = false;
               }
@@ -172,9 +168,7 @@ namespace netlib {
               total_buffer.insert(total_buffer.end(), buffer.begin(),
                                   buffer.begin() + recv_res);
             } else if (recv_res == 0) {
-              std::cout << "server recv_res == 0" << std::endl;
               remove_client(endpoint);
-              std::cout << "server kicked client recv 0" << std::endl;
               return std::errc::connection_aborted;
             } else if (recv_res < 0) {
               // error
@@ -195,14 +189,11 @@ namespace netlib {
                   }
                   if (response.terminate) {
                     remove_client(endpoint);
-                    std::cout << "server kicked client because wanted"
-                              << std::endl;
                     return std::errc::connection_aborted;
                   }
                 }
                 return {};
               } else {
-                std::cout << "server recv_res == -1" << std::endl;
                 return recv_error;
               }
             }
@@ -212,15 +203,11 @@ namespace netlib {
         bool remove_client(client_endpoint& ce) {
           //the remove_if-> erase idiom is perhaps my most hated part about std containers
           std::lock_guard<std::mutex> lock(_mutex);
-          std::size_t client_count = _clients.size();
           _busy_map.erase(ce.socket.get_raw().value());
-          std::cout << "remove_client, client count at start " << _clients.size() << std::endl;
           std::erase_if(_clients, [&](const client_endpoint& single_endpoint){
             return (ce.socket.get_raw().value() == single_endpoint.socket.get_raw().value());
           });
-          std::cout << "removed client, id " << ce.socket.get_raw().value() << std::endl;
           ce.socket.close();
-          assert((client_count - _clients.size()) == 1);
           return true;
         }
 
@@ -297,7 +284,6 @@ namespace netlib {
             _listener_sock->close();
             _listener_sock.reset();
           }
-          std::cout << "server stopped" << std::endl;
         }
 
         inline std::size_t get_client_count() {