Added tests [3] --filter=[core] --verbose

Author: matyhtf

core-tests/src/protocol/ssl.cpp

@@ -23,6 +23,7 @@
 #include <openssl/bio.h>
 #include <openssl/evp.h>
 #include <openssl/buffer.h>
+#include <openssl/err.h>
 
 using swoole::SSLContext;
 using swoole::String;
@@ -34,12 +35,35 @@ TEST(ssl, destroy) {
 }
 
 TEST(ssl, get_error) {
-    ERR_put_error(ERR_LIB_SSL, SSL_F_SSL_SET_SESSION, SSL_R_CERTIFICATE_VERIFY_FAILED, __FILE__, __LINE__);
-    const char *error_str = swoole_ssl_get_error();
-    EXPECT_NE(error_str, nullptr);
-    String str(error_str);
-    DEBUG() << str.to_std_string() << std::endl;
-    ASSERT_TRUE(str.contains("reason(134)"));
+    swoole_ssl_init();
+    {
+        ERR_clear_error();
+        ERR_put_error(ERR_LIB_SSL, SSL_F_SSL_SET_SESSION, SSL_R_CERTIFICATE_VERIFY_FAILED, __FILE__, __LINE__);
+        const char *error_str = swoole_ssl_get_error();
+        EXPECT_NE(error_str, nullptr);
+        String str(error_str);
+        DEBUG() << str.to_std_string() << std::endl;
+        ASSERT_TRUE(str.contains("certificate verify failed"));
+    }
+    {
+        ERR_clear_error();
+
+        ERR_put_error(ERR_LIB_SSL, SSL_F_SSL_SET_SESSION, SSL_R_CERTIFICATE_VERIFY_FAILED, __FILE__, __LINE__);
+        ERR_put_error(ERR_LIB_SSL, SSL_F_SSL_SHUTDOWN, SSL_R_PROTOCOL_IS_SHUTDOWN, __FILE__, __LINE__);
+
+        const char *error_str = swoole_ssl_get_error();
+        EXPECT_NE(error_str, nullptr);
+
+        const char *error_str2 = swoole_ssl_get_error();
+        EXPECT_NE(error_str2, nullptr);
+
+        String str(error_str2);
+        DEBUG() << str.to_std_string() << std::endl;
+        ASSERT_TRUE(str.contains("protocol is shutdown"));
+
+        const char *error_st3 = swoole_ssl_get_error();
+        ASSERT_STREQ(error_st3, "");
+    }
 }
 
 TEST(ssl, password) {

core-tests/src/server/server.cpp

@@ -1990,7 +1990,15 @@ TEST(server, reactor_thread_pipe_writable) {
         EXPECT_TRUE(serv->send(req->info.fd, &len, sizeof(len)));
         EXPECT_TRUE(serv->send(req->info.fd, rdata.str, rdata.length));
         EXPECT_MEMEQ(req->data + 4, rdata.str, rdata.length);
-        EXPECT_NE(serv->get_worker_message_bus()->move_packet(), nullptr);
+
+        /**
+         * After using MessageBus::move_packet(), the data pointer will be out of the control of message_bus,
+         * and this part of the memory must be manually released; otherwise, a memory leak will occur.
+         */
+        char *data = serv->get_worker_message_bus()->move_packet();
+        EXPECT_NE(data, nullptr);
+        sw_free(data);
+
         return SW_OK;
     };
 
@@ -2285,9 +2293,7 @@ static void test_clean_worker(Server::Mode mode) {
         swoole_timer_after(100, [port, _serv, &ac](TIMER_PARAMS) {
             ac.on_connect([&](AsyncClient *ac) { ac->send(SW_STRL(TEST_STR)); });
 
-            ac.on_close([_serv](AsyncClient *ac) {
-                DEBUG() << "client onClose\n";
-            });
+            ac.on_close([_serv](AsyncClient *ac) { DEBUG() << "client onClose\n"; });
 
             ac.on_error([](AsyncClient *ac) { swoole_warning("connect failed, error=%d", swoole_get_last_error()); });
 
@@ -2303,10 +2309,10 @@ static void test_clean_worker(Server::Mode mode) {
     };
 
     ASSERT_EQ(serv.start(), SW_OK);
-    ASSERT_EQ(test::counter_get(0), 0); // Server on_receive
-    ASSERT_EQ(test::counter_get(1), 3); // worker start
-    ASSERT_EQ(test::counter_get(2), 1); // Server on_close
-    ASSERT_EQ(test::counter_get(3), 0); // Client on_receive
+    ASSERT_EQ(test::counter_get(0), 0);  // Server on_receive
+    ASSERT_EQ(test::counter_get(1), 3);  // worker start
+    ASSERT_EQ(test::counter_get(2), 1);  // Server on_close
+    ASSERT_EQ(test::counter_get(3), 0);  // Client on_receive
 }
 
 TEST(server, clean_worker_1) {

src/protocol/ssl.cc

@@ -14,6 +14,7 @@
  +----------------------------------------------------------------------+
  */
 
+#include "php_swoole_cxx.h"
 #include "swoole.h"
 #include "swoole_string.h"
 #include "swoole_socket.h"
@@ -90,14 +91,17 @@ void swoole_ssl_destroy() {
 }
 
 static int ssl_error_cb(const char *str, size_t len, void *buf) {
-    memcpy(buf, str, len);
-
+    auto s = static_cast<swoole::String *>(buf);
+    memcpy(s->str, str, len);
+    s->length = len;
+    s->set_null_terminated();
     return 0;
 }
 
 const char *swoole_ssl_get_error() {
-    ERR_print_errors_cb(ssl_error_cb, sw_tg_buffer()->str);
-
+    sw_tg_buffer()->clear();
+    sw_tg_buffer()->set_null_terminated();
+    ERR_print_errors_cb(ssl_error_cb, sw_tg_buffer());
     return sw_tg_buffer()->str;
 }