hotplace rev.601 grooming

princeb612 · Sep 3, 2024 · 30c02c2 · 30c02c2
1 parent 28c2b2c
commit 30c02c2
Show file tree

Hide file tree

Showing 18 changed files with 379 additions and 86 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # history
 
+* Revision 601
+  * [changed] test/udpserver2 (udp server on network_server, epoll/iocp)
+    * [changed] server_socket (recvfrom, sendto)
+
 * Revision 600
   * [changed] test/udpserver2 (udp server on network_server, epoll)
   * [changed] rename tostring, tobin to bin2str, strtobin

diff --git a/make.sh b/make.sh
@@ -73,7 +73,7 @@ if [ ${#args[@]} -ne 0 ]; then
         elif [ $arg = 'format' ]; then
             do_clangformat=1
         elif [ $arg = 'leaks' ]; then
-            CXXFLAGS="${CXXFLAGS} -fsanitize=address"
+            CXXFLAGS="${CXXFLAGS} -fsanitize=leak"
         elif [ $arg = 'odbc' ]; then
             export SUPPORT_ODBC=1
         elif [ $arg = 'opt' ]; then

diff --git a/sdk/net/basic/server_socket.hpp b/sdk/net/basic/server_socket.hpp
@@ -91,14 +91,26 @@ class server_socket {
      * @param   char*           ptr_data        [OUT]
      * @param   size_t          size_data       [IN]
      * @param   size_t*         cbread          [OUT]
-     * @param   struct sockaddr* addr           [outopt]
-     * @param   socklen_t* addrlen              [inopt]
      * @return  error code (see error.hpp)
      * @remarks
      *          ERROR_CONNECTION_CLOSED
      */
-    virtual return_t read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread, struct sockaddr* addr = nullptr,
-                          socklen_t* addrlen = nullptr) {
+    virtual return_t read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread) { return errorcode_t::success; }
+    /**
+     * @brief   recvfrom
+     * @param   socket_t        sock            [IN]
+     * @param   tls_context_t*  tls_handle      [IN] nullptr
+     * @param   int             mode            [IN] ignore, it defines operation mode. see also transport_layer_security_server.
+     * @param   char*           ptr_data        [OUT]
+     * @param   size_t          size_data       [IN]
+     * @param   size_t*         cbread          [OUT]
+     * @param   struct sockaddr* addr           [out]
+     * @param   socklen_t*      addrlen         [in]
+     * @return  error code (see error.hpp)
+     * @remarks
+     */
+    virtual return_t recvfrom(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread, struct sockaddr* addr,
+                              socklen_t* addrlen) {
         return errorcode_t::success;
     }
     /**
@@ -111,6 +123,21 @@ class server_socket {
      * @return  error code (see error.hpp)
      */
     virtual return_t send(socket_t sock, tls_context_t* tls_handle, const char* ptr_data, size_t size_data, size_t* cbsent) { return errorcode_t::success; }
+    /**
+     * @brief   send
+     * @param   socket_t        sock            [IN]
+     * @param   tls_context_t*  tls_handle      [IN]
+     * @param   const char*     ptr_data        [IN]
+     * @param   size_t          size_data       [IN]
+     * @param   size_t*         cbsent          [OUT]
+     * @param   const struct sockaddr* addr     [in]
+     * @param   socklen_t       addrlen         [in]
+     * @return  error code (see error.hpp)
+     */
+    virtual return_t sendto(socket_t sock, tls_context_t* tls_handle, const char* ptr_data, size_t size_data, size_t* cbsent, const struct sockaddr* addr,
+                            socklen_t addrlen) {
+        return errorcode_t::success;
+    }
 
     virtual bool support_tls() { return false; }
     virtual int socket_type() { return 0; } /* override */

diff --git a/sdk/net/basic/tcp_server_socket.cpp b/sdk/net/basic/tcp_server_socket.cpp
@@ -64,8 +64,7 @@ return_t tcp_server_socket::accept(socket_t sock, socket_t* clisock, struct sock
     return ret;
 }
 
-return_t tcp_server_socket::read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread, struct sockaddr* addr,
-                                 socklen_t* addrlen) {
+return_t tcp_server_socket::read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread) {
     return_t ret = errorcode_t::success;
 
     __try2 {

diff --git a/sdk/net/basic/tcp_server_socket.hpp b/sdk/net/basic/tcp_server_socket.hpp
@@ -50,14 +50,11 @@ class tcp_server_socket : public server_socket {
      * @param   char*           ptr_data        [OUT]
      * @param   size_t          size_data       [IN]
      * @param   size_t*         cbread          [OUT]
-     * @param   struct sockaddr* addr           [outopt]
-     * @param   socklen_t* addrlen              [inopt]
-     * @return  error code (see error.hpp)
+     * @param   struct sockaddr* addr           [out]
      * @remarks
      *          ERROR_CONNECTION_CLOSED
      */
-    virtual return_t read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread, struct sockaddr* addr = nullptr,
-                          socklen_t* addrlen = nullptr);
+    virtual return_t read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread);
     /**
      * @brief   send
      * @param   socket_t        sock            [IN]

diff --git a/sdk/net/basic/udp_server_socket.cpp b/sdk/net/basic/udp_server_socket.cpp
@@ -51,8 +51,8 @@ return_t udp_server_socket::close(socket_t sock, tls_context_t* tls_handle) {
     return ret;
 }
 
-return_t udp_server_socket::read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* size_read, struct sockaddr* addr,
-                                 socklen_t* addrlen) {
+return_t udp_server_socket::recvfrom(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* size_read,
+                                     struct sockaddr* addr, socklen_t* addrlen) {
     return_t ret = errorcode_t::success;
     __try2 {
 #if 0
@@ -64,9 +64,9 @@ return_t udp_server_socket::read(socket_t sock, tls_context_t* tls_handle, int m
 #endif
 
 #if defined __linux__
-        int ret_recv = recvfrom(sock, ptr_data, size_data, 0, addr, addrlen);
+        int ret_recv = ::recvfrom(sock, ptr_data, size_data, 0, addr, addrlen);
 #elif defined _WIN32 || defined _WIN64
-        int ret_recv = recvfrom(sock, ptr_data, (int)size_data, 0, addr, addrlen);
+        int ret_recv = ::recvfrom(sock, ptr_data, (int)size_data, 0, addr, addrlen);
 #endif
         if (-1 == ret_recv) {
             ret = get_lasterror(ret_recv);
@@ -87,8 +87,8 @@ return_t udp_server_socket::read(socket_t sock, tls_context_t* tls_handle, int m
     return ret;
 }
 
-return_t udp_server_socket::send(socket_t sock, tls_context_t* tls_handle, const struct sockaddr* addr, socklen_t addrlen, const char* ptr_data,
-                                 size_t size_data, size_t* cbsent) {
+return_t udp_server_socket::sendto(socket_t sock, tls_context_t* tls_handle, const char* ptr_data, size_t size_data, size_t* cbsent,
+                                   const struct sockaddr* addr, socklen_t addrlen) {
     return_t ret = errorcode_t::success;
     __try2 {
 #if defined __linux__

diff --git a/sdk/net/basic/udp_server_socket.hpp b/sdk/net/basic/udp_server_socket.hpp
@@ -55,27 +55,27 @@ class udp_server_socket : public server_socket {
      * @param   char*           ptr_data        [OUT]
      * @param   size_t          size_data       [IN]
      * @param   size_t*         cbread          [OUT]
-     * @param   struct sockaddr* addr           [in]
+     * @param   struct sockaddr* addr           [out]
      * @param   socklen_t*      addrlen         [in]
      * @return  error code (see error.hpp)
      * @remarks
      *          ERROR_CONNECTION_CLOSED
      */
-    virtual return_t read(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread, struct sockaddr* addr,
-                          socklen_t* addrlen);
+    virtual return_t recvfrom(socket_t sock, tls_context_t* tls_handle, int mode, char* ptr_data, size_t size_data, size_t* cbread, struct sockaddr* addr,
+                              socklen_t* addrlen);
     /**
      * @brief   send
      * @param   socket_t        sock            [IN]
      * @param   tls_context_t*  tls_handle      [IN]
-     * @param   const struct sockaddr* addr     [in]
-     * @param   socklen_t*      addrlen         [in]
      * @param   const char*     ptr_data        [IN]
      * @param   size_t          size_data       [IN]
      * @param   size_t*         cbsent          [OUT]
+     * @param   const struct sockaddr* addr     [in]
+     * @param   socklen_t       addrlen         [in]
      * @return  error code (see error.hpp)
      */
-    virtual return_t send(socket_t sock, tls_context_t* tls_handle, const struct sockaddr* addr, socklen_t addrlen, const char* ptr_data, size_t size_data,
-                          size_t* cbsent);
+    virtual return_t sendto(socket_t sock, tls_context_t* tls_handle, const char* ptr_data, size_t size_data, size_t* cbsent, const struct sockaddr* addr,
+                            socklen_t addrlen);
 
     virtual int socket_type();
 };

diff --git a/sdk/net/server/network_server.cpp b/sdk/net/server/network_server.cpp
@@ -706,14 +706,6 @@ return_t network_server::tls_accept_routine(network_multiplexer_context_t* handl
 
         return_t test = errorcode_t::success;
 
-        // if (is_dgram) {
-        //     test = svr_socket->dtls_listen(listen_sock, (sockaddr*)&accpt_ctx.client_addr, sizeof(accpt_ctx.client_addr), &tls_handle);
-        //     if (errorcode_t::success == test) {
-        //         svr.try_connect(handle, listen_sock, &accpt_ctx.client_addr);
-        //         svr.session_accepted(handle, tls_handle, (handle_t)listen_sock, &accpt_ctx.client_addr);
-        //     }
-        // }
-
         test = svr_socket->tls_accept(accpt_ctx.cli_socket, &tls_handle);
         if (errorcode_t::success == test) {
             svr.session_accepted(handle, tls_handle, (handle_t)accpt_ctx.cli_socket, &accpt_ctx.client_addr);

diff --git a/sdk/net/server/network_session.cpp b/sdk/net/server/network_session.cpp
@@ -75,6 +75,26 @@ return_t network_session::send(const char* data_ptr, size_t size_data) {
 
 return_t network_session::send(const byte_t* data_ptr, size_t size_data) { return send((char*)data_ptr, size_data); }
 
+return_t network_session::sendto(const char* data_ptr, size_t size_data, sockaddr_storage_t* addr) {
+    return_t ret = errorcode_t::success;
+
+    __try2 {
+        if (nullptr == data_ptr) {
+            ret = errorcode_t::invalid_parameter;
+            __leave2;
+        }
+        size_t cbsent = 0;
+        ret = get_server_socket()->sendto((socket_t)_session.netsock.event_socket, _session.tls_handle, data_ptr, size_data, &cbsent, (sockaddr*)addr,
+                                          sizeof(sockaddr_storage_t));
+    }
+    __finally2 {
+        // do nothing
+    }
+    return ret;
+}
+
+return_t network_session::sendto(const byte_t* data_ptr, size_t size_data, sockaddr_storage_t* addr) { return sendto((char*)data_ptr, size_data, addr); }
+
 net_session_socket_t* network_session::socket_info() { return &_session.netsock; }
 
 #if defined _WIN32 || defined _WIN64
@@ -94,6 +114,9 @@ int network_session::addref() { return _shared.addref(); }
 int network_session::release() { return _shared.delref(); }
 
 return_t network_session::produce(t_mlfq<network_session>* q, byte_t* buf_read, size_t size_buf_read, const sockaddr_storage_t* addr) {
+    // const sockaddr_storage_t* addr
+    // (epoll) nullptr
+    // (iocp)  valid
     return_t ret = errorcode_t::success;
     critical_section_guard guard(_lock);
 
@@ -111,7 +134,40 @@ return_t network_session::produce(t_mlfq<network_session>* q, byte_t* buf_read,
         buf_read = (byte_t*)_session.buffer;
 #endif
 
-        // int socktype = get_server_socket()->socket_type();
+        int socktype = get_server_socket()->socket_type();
+        bool is_stream = (SOCK_STREAM == socktype);
+        if (is_stream) {
+            ret = produce_stream(q, buf_read, size_buf_read, addr);
+        } else {
+            ret = produce_dgram(q, buf_read, size_buf_read, addr);
+        }
+    }
+    __finally2 {
+        // do nothing
+    }
+    return ret;
+}
+
+return_t network_session::produce_stream(t_mlfq<network_session>* q, byte_t* buf_read, size_t size_buf_read, const sockaddr_storage_t* addr) {
+    // const sockaddr_storage_t* addr
+    // (epoll) nullptr
+    // (iocp)  valid
+    return_t ret = errorcode_t::success;
+    critical_section_guard guard(_lock);
+
+    __try2 {
+        if (nullptr == q) {
+            ret = errorcode_t::invalid_parameter;
+            __leave2;
+        }
+
+#if defined _WIN32 || defined _WIN64
+        // buf_read, size_buf_read transmitted
+#elif defined __linux__
+        // read
+        size_buf_read = RTL_NUMBER_OF(_session.buffer);
+        buf_read = (byte_t*)_session.buffer;
+#endif
 
         return_t result = errorcode_t::success;
 
@@ -132,6 +188,110 @@ return_t network_session::produce(t_mlfq<network_session>* q, byte_t* buf_read,
             while (true) {
                 result = get_server_socket()->read((socket_t)_session.netsock.event_socket, _session.tls_handle, tls_io_flag_t::read_ssl_read, (char*)buf_read,
                                                    size_buf_read, &cbread); /*SSL_read */
+                if (errorcode_t::success == result || errorcode_t::more_data == result) {
+                    getstream()->produce(buf_read, cbread);
+
+                    data_ready = true;
+
+                    if (_df) {
+                        basic_stream bs;
+                        datetime dt;
+                        datetime_t t;
+                        dt.getlocaltime(&t);
+
+                        bs.printf("%04d-%02d-%02d %02d:%02d:%02d.%03d ", t.year, t.month, t.day, t.hour, t.minute, t.second, t.milliseconds);
+                        bs << "[ns] read " << (socket_t)_session.netsock.event_socket << "\n";
+                        dump_memory(buf_read, cbread, &bs, 16, 2, 0, dump_notrunc);
+                        bs << "\n";
+                        _df(&bs);
+                    }
+
+                } else {
+                    break;
+                }
+            }
+
+            if (data_ready) {
+                q->push(get_priority(), this);
+            }
+        } else { /* wo TLS */
+            size_t cbread = 0;
+#if defined __linux__
+            ret = get_server_socket()->read((socket_t)_session.netsock.event_socket, _session.tls_handle, 0, (char*)buf_read, size_buf_read, &cbread);
+            if (errorcode_t::success == ret) {
+                getstream()->produce(buf_read, cbread);
+                q->push(get_priority(), this);
+            }
+#elif defined _WIN32 || defined _WIN64
+            // udp client address
+            cbread = size_buf_read;
+            getstream()->produce(buf_read, size_buf_read);
+            q->push(get_priority(), this);
+#endif
+
+            if (_df && (errorcode_t::success == ret)) {
+                basic_stream bs;
+                datetime dt;
+                datetime_t t;
+                dt.getlocaltime(&t);
+
+                bs.printf("%04d-%02d-%02d %02d:%02d:%02d.%03d ", t.year, t.month, t.day, t.hour, t.minute, t.second, t.milliseconds);
+                bs << "[ns] read " << (socket_t)_session.netsock.event_socket << "\n";
+                dump_memory(buf_read, cbread, &bs, 16, 2, 0, dump_notrunc);
+                bs << "\n";
+                _df(&bs);
+            }
+        }
+    }
+    __finally2 {
+        // do nothing
+    }
+    return ret;
+}
+
+return_t network_session::produce_dgram(t_mlfq<network_session>* q, byte_t* buf_read, size_t size_buf_read, const sockaddr_storage_t* addr) {
+    // const sockaddr_storage_t* addr
+    // (epoll) nullptr
+    // (iocp)  valid
+    return_t ret = errorcode_t::success;
+    critical_section_guard guard(_lock);
+
+    __try2 {
+        if (nullptr == q) {
+            ret = errorcode_t::invalid_parameter;
+            __leave2;
+        }
+
+#if defined _WIN32 || defined _WIN64
+        // buf_read, size_buf_read transmitted
+#elif defined __linux__
+        // read
+        size_buf_read = RTL_NUMBER_OF(_session.buffer);
+        buf_read = (byte_t*)_session.buffer;
+#endif
+
+        return_t result = errorcode_t::success;
+
+        if (_session.tls_handle) { /* TLS */
+            size_t cbread = 0;
+            bool data_ready = false;
+            int mode = 0;
+#if defined __linux__
+            mode = tls_io_flag_t::read_epoll;
+#elif defined _WIN32 || defined _WIN64
+            mode = tls_io_flag_t::read_iocp;
+#endif
+            sockaddr_storage_t sa;
+            socklen_t sa_size = sizeof(sa);
+            ret = get_server_socket()->recvfrom((socket_t)_session.netsock.event_socket, _session.tls_handle, mode, (char*)buf_read, size_buf_read, nullptr,
+                                                (sockaddr*)&sa, &sa_size);
+            if (errorcode_t::success != ret) {
+                __leave2;
+            }
+
+            while (true) {
+                result = get_server_socket()->recvfrom((socket_t)_session.netsock.event_socket, _session.tls_handle, tls_io_flag_t::read_ssl_read,
+                                                       (char*)buf_read, size_buf_read, &cbread, (sockaddr*)&sa, &sa_size); /*SSL_read */
                 if (errorcode_t::success == result || errorcode_t::more_data == result) {
                     getstream()->produce(buf_read, cbread, addr);
 
@@ -163,8 +323,8 @@ return_t network_session::produce(t_mlfq<network_session>* q, byte_t* buf_read,
 #if defined __linux__
             sockaddr_storage_t sa;
             socklen_t sa_size = sizeof(sa);
-            ret = get_server_socket()->read((socket_t)_session.netsock.event_socket, _session.tls_handle, 0, (char*)buf_read, size_buf_read, &cbread,
-                                            (sockaddr*)&sa, &sa_size);
+            ret = get_server_socket()->recvfrom((socket_t)_session.netsock.event_socket, _session.tls_handle, 0, (char*)buf_read, size_buf_read, &cbread,
+                                                (sockaddr*)&sa, &sa_size);
             if (errorcode_t::success == ret) {
                 getstream()->produce(buf_read, cbread, &sa);
                 q->push(get_priority(), this);