Add tests [5] --filter=[core] --asan

Author: matyhtf

core-tests/src/core/base.cpp

@@ -189,7 +189,7 @@ TEST(base, set_task_tmpdir) {
     ASSERT_FALSE(swoole_set_task_tmpdir("aaa"));
 
     size_t length = SW_TASK_TMP_PATH_SIZE + 1;
-    char too_long_dir[length] = {};
+    char too_long_dir[length + 1] = {};
     swoole_random_string(too_long_dir + 1, length - 1);
     too_long_dir[0] = '/';
     ASSERT_FALSE(swoole_set_task_tmpdir(too_long_dir));

core-tests/src/coroutine/system.cpp

@@ -246,6 +246,24 @@ TEST(coroutine_system, wait_event_writable) {
     });
 }
 
+TEST(coroutine_system, wait_event_fail) {
+    test::coroutine::run([&](void *arg) {
+        ASSERT_EQ(System::wait_event(9999, 0, 1), SW_ERR);
+        ASSERT_ERREQ(EINVAL);
+
+        ASSERT_EQ(System::wait_event(fileno(stdin), SW_EVENT_READ, 0), SW_ERR);
+        ASSERT_ERREQ(ETIMEDOUT);
+
+        ASSERT_EQ(System::wait_event(fileno(stdout), SW_EVENT_WRITE, 0), SW_EVENT_WRITE);
+
+        ASSERT_EQ(System::wait_event(9999, SW_EVENT_WRITE, 0), -1);
+        ASSERT_ERREQ(EBADF);
+
+        ASSERT_EQ(System::wait_event(9999, SW_EVENT_WRITE, 1.0), -1);
+        ASSERT_ERREQ(EBADF);
+    });
+}
+
 TEST(coroutine_system, swoole_stream_select) {
     UnixSocket p(true, SOCK_STREAM);
     std::unordered_map<int, swoole::coroutine::PollSocket> fds;

ext-src/swoole_http_client_coro.cc

@@ -1152,13 +1152,13 @@ bool Client::send_request() {
     // ============ multipart/form-data ============
     if ((has_upload_files = (php_swoole_array_length_safe(zupload_files) > 0))) {
         char header_buf[2048];
-        char boundary_str[SW_HTTP_CLIENT_BOUNDARY_TOTAL_SIZE];
+        char boundary_str[SW_HTTP_CLIENT_BOUNDARY_TOTAL_SIZE + 1];
         int n;
 
         // ============ content-type ============
         memcpy(boundary_str, SW_HTTP_CLIENT_BOUNDARY_PREKEY, sizeof(SW_HTTP_CLIENT_BOUNDARY_PREKEY) - 1);
         swoole_random_string(boundary_str + sizeof(SW_HTTP_CLIENT_BOUNDARY_PREKEY) - 1,
-                             sizeof(boundary_str) - sizeof(SW_HTTP_CLIENT_BOUNDARY_PREKEY));
+                             sizeof(boundary_str) - sizeof(SW_HTTP_CLIENT_BOUNDARY_PREKEY) - 1);
         n = sw_snprintf(header_buf,
                         sizeof(header_buf),
                         "Content-Type: multipart/form-data; boundary=%.*s\r\n",

include/swoole.h

@@ -491,8 +491,12 @@ typedef unsigned char uchar;
 #define swoole_tolower(c) (uchar)((c >= 'A' && c <= 'Z') ? (c | 0x20) : c)
 #define swoole_toupper(c) (uchar)((c >= 'a' && c <= 'z') ? (c & ~0x20) : c)
 
-void swoole_random_string(char *buf, size_t size);
-void swoole_random_string(std::string &str, size_t size);
+/**
+ * This function appends a '\0' at the end of the string,
+ * so the allocated memory buffer must be len + 1.
+ */
+void swoole_random_string(char *buf, size_t len);
+void swoole_random_string(std::string &str, size_t len);
 uint64_t swoole_random_int();
 size_t swoole_random_bytes(char *buf, size_t size);
 

src/core/base.cc

@@ -797,17 +797,17 @@ static constexpr char characters[] = {
     'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 };
 
-void swoole_random_string(char *buf, size_t size) {
+void swoole_random_string(char *buf, size_t len) {
     size_t i = 0;
-    for (; i < size; i++) {
+    for (; i < len; i++) {
         buf[i] = characters[swoole_rand(0, sizeof(characters) - 1)];
     }
     buf[i] = '\0';
 }
 
-void swoole_random_string(std::string &str, size_t size) {
+void swoole_random_string(std::string &str, size_t len) {
     size_t i = 0;
-    for (; i < size; i++) {
+    for (; i < len; i++) {
         str.append(1, characters[swoole_rand(0, sizeof(characters) - 1)]);
     }
 }

src/coroutine/system.cc

@@ -546,26 +546,27 @@ static int event_waiter_error_callback(Reactor *reactor, Event *event) {
  * @errror: errno & swoole_get_last_error()
  */
 int System::wait_event(int fd, int events, double timeout) {
-    events &= SW_EVENT_READ | SW_EVENT_WRITE;
     if (events == 0) {
         swoole_set_last_error(EINVAL);
-        return 0;
+        return -1;
     }
 
     if (timeout == 0) {
-        struct pollfd pfd;
+        pollfd pfd;
         pfd.fd = fd;
         pfd.events = translate_events_to_poll(events);
         pfd.revents = 0;
 
         int retval = ::poll(&pfd, 1, 0);
         if (retval == 1) {
+            if (pfd.revents & POLLNVAL) {
+                swoole_set_last_error(EBADF);
+                return -1;
+            }
             return translate_events_from_poll(pfd.revents);
         }
-        if (retval < 0) {
-            swoole_set_last_error(errno);
-        }
-        return 0;
+        swoole_set_last_error(retval < 0 ? errno : ETIMEDOUT);
+        return -1;
     }
 
     EventWaiter waiter(fd, events, timeout);