Update libuv to 1.41.0

.ci/bindcov.sh

@@ -39,9 +39,9 @@ for fn in `grep -oP "UV_EXTERN [^\(]+ uv_[^\(]+\(" deps/libuv/include/uv.h | sed
 		continue
 	fi
 	# count all uses
-	count=`grep -o "$fn" src/*.c | wc -l`
+	count=`grep -o "\b$fn\b" src/*.c | wc -l`
 	# check if a luv_ version exists
-	grep -Fq "l$fn" src/*.c
+	grep -q "\bl$fn\b" src/*.c
 	bound=$?
 	# not bound
 	if [ ! $bound -eq 0 ] ; then

docs.md

@@ -1765,6 +1765,42 @@ where `r` is `READABLE` and `w` is `WRITABLE`. This function is blocking.
 
 **Returns:** `0` or `fail`
 
+### `uv.pipe(read_flags, write_flags)`
+
+**Parameters:**
+- `read_flags`: `table` or `nil`
+  - `nonblock`: `boolean` (default: `false`)
+- `write_flags`: `table` or `nil`
+  - `nonblock`: `boolean` (default: `false`)
+
+Create a pair of connected pipe handles. Data may be written to the `write` fd and read from the `read` fd. The resulting handles can be passed to `pipe_open`, used with `spawn`, or for any other purpose.
+
+Flags:
+ - `nonblock`: Opens the specified socket handle for `OVERLAPPED` or `FIONBIO`/`O_NONBLOCK` I/O usage. This is recommended for handles that will be used by libuv, and not usually recommended otherwise.
+
+Equivalent to `pipe(2)` with the `O_CLOEXEC` flag set.
+
+**Returns:** `table` or `fail`
+- `read` : `integer` (file descriptor)
+- `write` : `integer` (file descriptor)
+
+```lua
+-- Simple read/write with pipe_open
+local fds = uv.pipe({nonblock=true}, {nonblock=true})
+
+local read_pipe = uv.new_pipe()
+read_pipe:open(fds.read)
+
+local write_pipe = uv.new_pipe()
+write_pipe:open(fds.write)
+
+write_pipe:write("hello")
+read_pipe:read_start(function(err, chunk)
+  assert(not err, err)
+  print(chunk)
+end)
+```
+
 ## `uv_tty_t` — TTY handle
 
 [`uv_tty_t`]: #uv_tty_t--tty-handle

src/luv.c

@@ -185,6 +185,9 @@ static const luaL_Reg luv_functions[] = {
   {"pipe_pending_instances", luv_pipe_pending_instances},
   {"pipe_pending_count", luv_pipe_pending_count},
   {"pipe_pending_type", luv_pipe_pending_type},
+#if LUV_UV_VERSION_GEQ(1, 41, 0)
+  {"pipe", luv_pipe},
+#endif
 
   // tty.c
   {"new_tty", luv_new_tty},

src/pipe.c

@@ -130,3 +130,35 @@ static int luv_pipe_chmod(lua_State* L) {
   return luv_result(L, ret);
 }
 #endif
+
+#if LUV_UV_VERSION_GEQ(1,41,0)
+static int luv_pipe(lua_State* L) {
+  luv_ctx_t* ctx = luv_context(L);
+  int read_flags = 0, write_flags = 0;
+  uv_file fds[2];
+  int ret;
+  if (lua_type(L, 3) == LUA_TTABLE) {
+    lua_getfield(L, 3, "nonblock");
+    if (lua_toboolean(L, -1)) read_flags |= UV_NONBLOCK_PIPE;
+    lua_pop(L, 1);
+  } else if (!lua_isnoneornil(L, 3)) {
+    luv_arg_type_error(L, 3, "table or nil expected, got %s");
+  }
+  if (lua_type(L, 4) == LUA_TTABLE) {
+    lua_getfield(L, 4, "nonblock");
+    if (lua_toboolean(L, -1)) write_flags |= UV_NONBLOCK_PIPE;
+    lua_pop(L, 1);
+  } else if (!lua_isnoneornil(L, 4)) {
+    luv_arg_type_error(L, 4, "table or nil expected, got %s");
+  }
+  ret = uv_pipe(fds, read_flags, write_flags);
+  if (ret < 0) return luv_error(L, ret);
+  // return as a table with 'read' and 'write' keys containing the corresponding fds
+  lua_createtable(L, 0, 2);
+  lua_pushinteger(L, fds[0]);
+  lua_setfield(L, -2, "read");
+  lua_pushinteger(L, fds[1]);
+  lua_setfield(L, -2, "write");
+  return 1;
+}
+#endif

tests/test-pipe.lua

@@ -20,4 +20,79 @@ return require('lib/tap')(function (test)
 
     pipe:close()
   end, "1.16.0")
+
+  test("pipe ping pong", function(print, p, expect, uv)
+    local PING = "PING\n"
+    local NUM_PINGS = 4
+
+    local fds = assert(uv.pipe({nonblock=true}, {nonblock=true}))
+    assert(uv.guess_handle(fds.read) == "pipe")
+    assert(uv.guess_handle(fds.write) == "pipe")
+
+    local ponger = assert(uv.new_pipe())
+    assert(ponger:open(fds.read))
+
+    local pinger = assert(uv.new_pipe())
+    assert(pinger:open(fds.write))
+
+    local ping = function()
+      assert(pinger:write(PING, expect(function(err)
+        assert(not err, err)
+      end)))
+    end
+
+    local pongs = 0
+    ping()
+
+    assert(ponger:read_start(function(err, chunk)
+      assert(not err, err)
+      if chunk == nil then
+        return
+      end
+      assert(chunk == PING)
+      pongs = pongs + 1
+      if pongs == NUM_PINGS then
+        ponger:close()
+        pinger:close()
+      else
+        ping()
+      end
+    end))
+  end, "1.41.0")
+
+  test("pipe close fd", function(print, p, expect, uv)
+    local fds = assert(uv.pipe())
+
+    local pipe_handle = assert(uv.new_pipe())
+    assert(pipe_handle:open(fds.read))
+    -- pipe_open takes ownership of the file descriptor
+    fds.read = nil
+
+    assert(uv.fs_write(fds.write, "PING"))
+    assert(uv.fs_close(fds.write))
+    fds.write = nil
+
+    local read_cb_called = 0
+    local read_cb = expect(function(err, chunk)
+      assert(not err, err)
+      read_cb_called = read_cb_called + 1
+      if read_cb_called == 1 then
+        assert(chunk == "PING")
+        pipe_handle:read_stop()
+      elseif read_cb_called == 2 then
+        assert(chunk == nil)
+        pipe_handle:close()
+      end
+    end, 2)
+
+    assert(pipe_handle:read_start(read_cb))
+    uv.run()
+    assert(read_cb_called == 1)
+
+    assert(pipe_handle:read_start(read_cb))
+    uv.run()
+    assert(read_cb_called == 2)
+
+    assert(pipe_handle:is_closing())
+  end, "1.41.0")
 end)