Merge 050fc94 into d087834

Author: Guest0x0

src/internal/event_loop/poll.c

@@ -52,6 +52,7 @@ int moonbitlang_async_poll_register(
     events |= EPOLLONESHOT;
 
   events |= EPOLLET;
+  events |= EPOLLRDHUP;
 
   epoll_data_t data;
   data.u64 = fd;

src/tls/bio.mbt

@@ -213,7 +213,8 @@ fn Endpoint::try_write(ep : Endpoint, src : C_Buffer, len : Int) -> Int {
 async fn Endpoint::wait(ep : Endpoint) -> Unit raise {
   match ep.state {
     Error(err) => raise err
-    Closed | Idle | Blocked => ()
+    Closed => return
+    Idle | Blocked => ()
   }
   let coro = @coroutine.current_coroutine()
   ep.waiters.add(coro)

src/tls/moon.pkg.json

@@ -6,7 +6,8 @@
   ],
   "test-import": [
     "moonbitlang/async",
-    "moonbitlang/async/pipe"
+    "moonbitlang/async/pipe",
+    "moonbitlang/async/socket"
   ],
   "native-stub": [ "stub.c" ]
 }

src/tls/shutdown_test.mbt

@@ -0,0 +1,49 @@
+// Copyright 2025 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "peer close connection" {
+  let port = 4208
+  @async.with_event_loop(fn(root) {
+    // server
+    root.spawn_bg(fn() {
+      let server = @socket.TCPServer::new(
+        @socket.Addr::parse("127.0.0.1:\{port}"),
+      )
+      defer server.close()
+      let (conn, _) = server.accept()
+      defer conn.close()
+      let server = @tls.TLS::server(
+        conn,
+        private_key_file="test_keys/key.pem",
+        private_key_type=PEM,
+        certificate_file="test_keys/cert.pem",
+        certificate_type=PEM,
+      )
+      defer server.close()
+      @async.sleep(100)
+      // the server already closed the connection
+      server.shutdown()
+    })
+    // client
+    root.spawn_bg(fn() {
+      let conn = @socket.TCP::connect(@socket.Addr::parse("127.0.0.1:\{port}"))
+      defer conn.close()
+      let client = @tls.TLS::client(conn, verify=false)
+      defer client.close()
+      @async.sleep(50)
+      // close the underlying connection directly
+    })
+  })
+}

src/tls/tls.mbt

@@ -250,15 +250,16 @@ pub fn TLS::close(self : TLS) -> Unit {
 /// to prevent the program from haning indefinitely.
 pub async fn TLS::shutdown(self : TLS) -> Unit raise {
   while self.ssl.shutdown() is ret && ret <= 0 {
-    if ret == 0 {
-      self.read_end.wait()
+    let err = if ret == 0 {
+      SSL_ERROR_WANT_READ
     } else {
-      let err = self.ssl.get_error(ret)
-      if err is SSL_ERROR_ZERO_RETURN {
-        // do not raise error on non-compilant peer
-        break
-      }
-      self.handle_error(err)
+      self.ssl.get_error(ret)
+    }
+    self.handle_error(err)
+    match err {
+      SSL_ERROR_WANT_READ if self.read_end.state is Closed => break
+      SSL_ERROR_WANT_WRITE if self.write_end.state is Closed => break
+      _ => ()
     }
   }
 }