From 8e3f825c921b38141afa7a69a0664881c5c94461 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 25 Oct 2022 20:32:51 +0200 Subject: [PATCH] Revert "refactor(ext/net): clean up variadic network ops (#16392)" (#16417) Should fix https://github.com/denoland/deno_std/issues/2807 --- ext/net/01_net.js | 244 ++++++----------- ext/net/02_tls.js | 69 ++--- ext/net/04_net_unstable.js | 60 +++++ ext/net/README.md | 23 +- ext/net/lib.rs | 1 + ext/net/ops.rs | 519 ++++++++++++++++++++++++++++--------- ext/net/ops_tls.rs | 99 +++++-- ext/net/ops_unix.rs | 157 ++++------- runtime/js/40_testing.js | 16 +- runtime/js/90_deno_ns.js | 5 +- runtime/js/99_main.js | 5 - 11 files changed, 727 insertions(+), 471 deletions(-) create mode 100644 ext/net/04_net_unstable.js diff --git a/ext/net/01_net.js b/ext/net/01_net.js index acd8ee179f..d7a093ba6c 100644 --- a/ext/net/01_net.js +++ b/ext/net/01_net.js @@ -10,10 +10,10 @@ Error, ObjectPrototypeIsPrototypeOf, PromiseResolve, + Symbol, SymbolAsyncIterator, SymbolFor, TypedArrayPrototypeSubarray, - TypeError, Uint8Array, } = window.__bootstrap.primordials; @@ -38,6 +38,30 @@ return core.shutdown(rid); } + function opAccept(rid, transport) { + return core.opAsync("op_net_accept", { rid, transport }); + } + + function opListen(args) { + return ops.op_net_listen(args); + } + + function opConnect(args) { + return core.opAsync("op_net_connect", args); + } + + function opReceive(rid, transport, zeroCopy) { + return core.opAsync( + "op_dgram_recv", + { rid, transport }, + zeroCopy, + ); + } + + function opSend(args, zeroCopy) { + return core.opAsync("op_dgram_send", args, zeroCopy); + } + function resolveDns(query, recordType, options) { return core.opAsync("op_dns_resolve", { query, recordType, options }); } @@ -111,6 +135,11 @@ class UnixConn extends Conn {} + // Use symbols for method names to hide these in stable API. + // TODO(kt3k): Remove these symbols when ref/unref become stable. + const listenerRef = Symbol("listenerRef"); + const listenerUnref = Symbol("listenerUnref"); + class Listener { #rid = 0; #addr = null; @@ -130,35 +159,21 @@ return this.#addr; } - async accept() { - let promise; - switch (this.addr.transport) { - case "tcp": - promise = core.opAsync("op_net_accept_tcp", this.rid); - break; - case "unix": - promise = core.opAsync("op_net_accept_unix", this.rid); - break; - default: - throw new Error(`Unsupported transport: ${this.addr.transport}`); - } + accept() { + const promise = opAccept(this.rid, this.addr.transport); this.#promiseId = promise[promiseIdSymbol]; - if (this.#unref) core.unrefOp(this.#promiseId); - const [rid, localAddr, remoteAddr] = await promise; - this.#promiseId = null; - if (this.addr.transport == "tcp") { - localAddr.transport = "tcp"; - remoteAddr.transport = "tcp"; - return new TcpConn(rid, remoteAddr, localAddr); - } else if (this.addr.transport == "unix") { - return new UnixConn( - rid, - { transport: "unix", path: remoteAddr }, - { transport: "unix", path: localAddr }, - ); - } else { - throw new Error("unreachable"); + if (this.#unref) { + this.#unrefOpAccept(); } + return promise.then((res) => { + if (this.addr.transport == "tcp") { + return new TcpConn(res.rid, res.remoteAddr, res.localAddr); + } else if (this.addr.transport == "unix") { + return new UnixConn(res.rid, res.remoteAddr, res.localAddr); + } else { + throw new Error("unreachable"); + } + }); } async next() { @@ -190,15 +205,22 @@ return this; } - ref() { + [listenerRef]() { this.#unref = false; + this.#refOpAccept(); + } + + [listenerUnref]() { + this.#unref = true; + this.#unrefOpAccept(); + } + + #refOpAccept() { if (typeof this.#promiseId === "number") { core.refOp(this.#promiseId); } } - - unref() { - this.#unref = true; + #unrefOpAccept() { if (typeof this.#promiseId === "number") { core.unrefOp(this.#promiseId); } @@ -225,54 +247,18 @@ async receive(p) { const buf = p || new Uint8Array(this.bufSize); - let nread; - let remoteAddr; - switch (this.addr.transport) { - case "udp": { - [nread, remoteAddr] = await core.opAsync( - "op_net_recv_udp", - this.rid, - buf, - ); - remoteAddr.transport = "udp"; - break; - } - case "unixpacket": { - let path; - [nread, path] = await core.opAsync( - "op_net_recv_unixpacket", - this.rid, - buf, - ); - remoteAddr = { transport: "unixpacket", path }; - break; - } - default: - throw new Error(`Unsupported transport: ${this.addr.transport}`); - } - const sub = TypedArrayPrototypeSubarray(buf, 0, nread); + const { size, remoteAddr } = await opReceive( + this.rid, + this.addr.transport, + buf, + ); + const sub = TypedArrayPrototypeSubarray(buf, 0, size); return [sub, remoteAddr]; } - async send(p, opts) { - switch (this.addr.transport) { - case "udp": - return await core.opAsync( - "op_net_send_udp", - this.rid, - { hostname: opts.hostname ?? "127.0.0.1", port: opts.port }, - p, - ); - case "unixpacket": - return await core.opAsync( - "op_net_send_unixpacket", - this.rid, - opts.path, - p, - ); - default: - throw new Error(`Unsupported transport: ${this.addr.transport}`); - } + send(p, addr) { + const args = { hostname: "127.0.0.1", ...addr, rid: this.rid }; + return opSend(args, p); } close() { @@ -296,100 +282,40 @@ } } - function listen(args) { - switch (args.transport ?? "tcp") { - case "tcp": { - const [rid, addr] = ops.op_net_listen_tcp({ - hostname: args.hostname ?? "0.0.0.0", - port: args.port, - }); - addr.transport = "tcp"; - return new Listener(rid, addr); - } - case "unix": { - const [rid, path] = ops.op_net_listen_unix(args.path); - const addr = { - transport: "unix", - path, - }; - return new Listener(rid, addr); - } - default: - throw new TypeError(`Unsupported transport: '${transport}'`); - } + function listen({ hostname, ...options }, constructor = Listener) { + const res = opListen({ + transport: "tcp", + hostname: typeof hostname === "undefined" ? "0.0.0.0" : hostname, + ...options, + }); + + return new constructor(res.rid, res.localAddr); } - function listenDatagram(args) { - switch (args.transport) { - case "udp": { - const [rid, addr] = ops.op_net_listen_udp( - { - hostname: args.hostname ?? "127.0.0.1", - port: args.port, - }, - args.reuseAddress ?? false, - ); - addr.transport = "udp"; - return new Datagram(rid, addr); - } - case "unixpacket": { - const [rid, path] = ops.op_net_listen_unixpacket(args.path); - const addr = { - transport: "unixpacket", - path, - }; - return new Datagram(rid, addr); - } - default: - throw new TypeError(`Unsupported transport: '${transport}'`); + async function connect(options) { + if (options.transport === "unix") { + const res = await opConnect(options); + return new UnixConn(res.rid, res.remoteAddr, res.localAddr); } - } - async function connect(args) { - switch (args.transport ?? "tcp") { - case "tcp": { - const [rid, localAddr, remoteAddr] = await core.opAsync( - "op_net_connect_tcp", - { - hostname: args.hostname ?? "127.0.0.1", - port: args.port, - }, - ); - localAddr.transport = "tcp"; - remoteAddr.transport = "tcp"; - return new TcpConn(rid, remoteAddr, localAddr); - } - case "unix": { - const [rid, localAddr, remoteAddr] = await core.opAsync( - "op_net_connect_unix", - args.path, - ); - return new UnixConn( - rid, - { transport: "unix", path: remoteAddr }, - { transport: "unix", path: localAddr }, - ); - } - default: - throw new TypeError(`Unsupported transport: '${transport}'`); - } - } - - function setup(unstable) { - if (!unstable) { - delete Listener.prototype.ref; - delete Listener.prototype.unref; - } + const res = await opConnect({ + transport: "tcp", + hostname: "127.0.0.1", + ...options, + }); + return new TcpConn(res.rid, res.remoteAddr, res.localAddr); } window.__bootstrap.net = { - setup, connect, Conn, TcpConn, UnixConn, + opConnect, listen, - listenDatagram, + listenerRef, + listenerUnref, + opListen, Listener, shutdown, Datagram, diff --git a/ext/net/02_tls.js b/ext/net/02_tls.js index d3f906dbd9..04b25caf97 100644 --- a/ext/net/02_tls.js +++ b/ext/net/02_tls.js @@ -5,7 +5,20 @@ const core = window.Deno.core; const ops = core.ops; const { Listener, Conn } = window.__bootstrap.net; - const { TypeError } = window.__bootstrap.primordials; + + function opConnectTls( + args, + ) { + return core.opAsync("op_tls_connect", args); + } + + function opAcceptTLS(rid) { + return core.opAsync("op_tls_accept", rid); + } + + function opListenTls(args) { + return ops.op_tls_listen(args); + } function opStartTls(args) { return core.opAsync("op_tls_start", args); @@ -31,28 +44,23 @@ privateKey = undefined, alpnProtocols = undefined, }) { - if (transport !== "tcp") { - throw new TypeError(`Unsupported transport: '${transport}'`); - } - const [rid, localAddr, remoteAddr] = await core.opAsync( - "op_net_connect_tls", - { hostname, port }, - { certFile, caCerts, certChain, privateKey, alpnProtocols }, - ); - localAddr.transport = "tcp"; - remoteAddr.transport = "tcp"; - return new TlsConn(rid, remoteAddr, localAddr); + const res = await opConnectTls({ + port, + hostname, + transport, + certFile, + caCerts, + certChain, + privateKey, + alpnProtocols, + }); + return new TlsConn(res.rid, res.remoteAddr, res.localAddr); } class TlsListener extends Listener { async accept() { - const [rid, localAddr, remoteAddr] = await core.opAsync( - "op_net_accept_tls", - this.rid, - ); - localAddr.transport = "tcp"; - remoteAddr.transport = "tcp"; - return new TlsConn(rid, remoteAddr, localAddr); + const res = await opAcceptTLS(this.rid); + return new TlsConn(res.rid, res.remoteAddr, res.localAddr); } } @@ -66,14 +74,17 @@ transport = "tcp", alpnProtocols = undefined, }) { - if (transport !== "tcp") { - throw new TypeError(`Unsupported transport: '${transport}'`); - } - const [rid, localAddr] = ops.op_net_listen_tls( - { hostname, port }, - { cert, certFile, key, keyFile, alpnProtocols }, - ); - return new TlsListener(rid, localAddr); + const res = opListenTls({ + port, + cert, + certFile, + key, + keyFile, + hostname, + transport, + alpnProtocols, + }); + return new TlsListener(res.rid, res.localAddr); } async function startTls( @@ -85,14 +96,14 @@ alpnProtocols = undefined, } = {}, ) { - const [rid, localAddr, remoteAddr] = await opStartTls({ + const res = await opStartTls({ rid: conn.rid, hostname, certFile, caCerts, alpnProtocols, }); - return new TlsConn(rid, remoteAddr, localAddr); + return new TlsConn(res.rid, res.remoteAddr, res.localAddr); } window.__bootstrap.tls = { diff --git a/ext/net/04_net_unstable.js b/ext/net/04_net_unstable.js new file mode 100644 index 0000000000..fcdb3c547c --- /dev/null +++ b/ext/net/04_net_unstable.js @@ -0,0 +1,60 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +"use strict"; + +((window) => { + const net = window.__bootstrap.net; + + function listen(options) { + if (options.transport === "unix") { + const res = net.opListen(options); + return new Listener(res.rid, res.localAddr); + } else { + return net.listen(options, Listener); + } + } + + function listenDatagram( + options, + ) { + let res; + if (options.transport === "unixpacket") { + res = net.opListen(options); + } else { + res = net.opListen({ + transport: "udp", + hostname: "127.0.0.1", + ...options, + }); + } + + return new net.Datagram(res.rid, res.localAddr); + } + + async function connect( + options, + ) { + if (options.transport === "unix") { + const res = await net.opConnect(options); + return new net.Conn(res.rid, res.remoteAddr, res.localAddr); + } else { + return net.connect(options); + } + } + + class Listener extends net.Listener { + ref() { + this[net.listenerRef](); + } + + unref() { + this[net.listenerUnref](); + } + } + + window.__bootstrap.netUnstable = { + connect, + listenDatagram, + listen, + Listener, + }; +})(this); diff --git a/ext/net/README.md b/ext/net/README.md index 1f9301a2d8..1928fc375b 100644 --- a/ext/net/README.md +++ b/ext/net/README.md @@ -9,21 +9,14 @@ This crate depends on following extensions: Following ops are provided: -- "op_net_accept_tcp" -- "op_net_accept_unix" -- "op_net_connect_tcp" -- "op_net_connect_unix" -- "op_net_listen_tcp" -- "op_net_listen_udp" -- "op_net_listen_unix" -- "op_net_listen_unixpacket" -- "op_net_recv_udp" -- "op_net_recv_unixpacket" -- "op_net_send_udp" -- "op_net_send_unixpacket" +- "op_net_accept" +- "op_net_connect" +- "op_net_listen" +- "op_dgram_recv" +- "op_dgram_send" - "op_dns_resolve" -- "op_net_connect_tls" -- "op_net_listen_tls" -- "op_net_accept_tls" - "op_tls_start" +- "op_tls_connect" +- "op_tls_listen" +- "op_tls_accept" - "op_tls_handshake" diff --git a/ext/net/lib.rs b/ext/net/lib.rs index ddeeeb1a8e..35d6125988 100644 --- a/ext/net/lib.rs +++ b/ext/net/lib.rs @@ -90,6 +90,7 @@ pub fn init( prefix "deno:ext/net", "01_net.js", "02_tls.js", + "04_net_unstable.js", )) .ops(ops) .state(move |state| { diff --git a/ext/net/ops.rs b/ext/net/ops.rs index 9a6d955861..399baa4fde 100644 --- a/ext/net/ops.rs +++ b/ext/net/ops.rs @@ -7,6 +7,7 @@ use crate::NetPermissions; use deno_core::error::bad_resource; use deno_core::error::custom_error; use deno_core::error::generic_error; +use deno_core::error::type_error; use deno_core::error::AnyError; use deno_core::op; @@ -20,6 +21,7 @@ use deno_core::RcRef; use deno_core::Resource; use deno_core::ResourceId; use deno_core::ZeroCopyBuf; +use log::debug; use serde::Deserialize; use serde::Serialize; use socket2::Domain; @@ -43,51 +45,69 @@ use trust_dns_resolver::error::ResolveErrorKind; use trust_dns_resolver::system_conf; use trust_dns_resolver::AsyncResolver; +#[cfg(unix)] +use super::ops_unix as net_unix; +#[cfg(unix)] +use crate::io::UnixStreamResource; +#[cfg(unix)] +use std::path::Path; + pub fn init() -> Vec { vec![ - op_net_accept_tcp::decl(), - #[cfg(unix)] - crate::ops_unix::op_net_accept_unix::decl(), - op_net_connect_tcp::decl::

(), - #[cfg(unix)] - crate::ops_unix::op_net_connect_unix::decl::

(), - op_net_listen_tcp::decl::

(), - op_net_listen_udp::decl::

(), - #[cfg(unix)] - crate::ops_unix::op_net_listen_unix::decl::

(), - #[cfg(unix)] - crate::ops_unix::op_net_listen_unixpacket::decl::

(), - op_net_recv_udp::decl(), - #[cfg(unix)] - crate::ops_unix::op_net_recv_unixpacket::decl(), - op_net_send_udp::decl::

(), - #[cfg(unix)] - crate::ops_unix::op_net_send_unixpacket::decl::

(), + op_net_accept::decl(), + op_net_connect::decl::

(), + op_net_listen::decl::

(), + op_dgram_recv::decl(), + op_dgram_send::decl::

(), op_dns_resolve::decl::

(), op_set_nodelay::decl::

(), op_set_keepalive::decl::

(), ] } +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct OpConn { + pub rid: ResourceId, + pub remote_addr: Option, + pub local_addr: Option, +} + +#[derive(Serialize)] +#[serde(tag = "transport", rename_all = "lowercase")] +pub enum OpAddr { + Tcp(IpAddr), + Udp(IpAddr), + #[cfg(unix)] + Unix(net_unix::UnixAddr), + #[cfg(unix)] + UnixPacket(net_unix::UnixAddr), +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +/// A received datagram packet (from udp or unixpacket) +pub struct OpPacket { + pub size: usize, + pub remote_addr: OpAddr, +} + #[derive(Serialize, Clone, Debug)] #[serde(rename_all = "camelCase")] pub struct TlsHandshakeInfo { pub alpn_protocol: Option, } -#[derive(Deserialize, Serialize)] +#[derive(Serialize)] pub struct IpAddr { pub hostname: String, pub port: u16, } -impl From for IpAddr { - fn from(addr: SocketAddr) -> Self { - Self { - hostname: addr.ip().to_string(), - port: addr.port(), - } - } +#[derive(Deserialize)] +pub(crate) struct AcceptArgs { + pub rid: ResourceId, + pub transport: String, } pub(crate) fn accept_err(e: std::io::Error) -> AnyError { @@ -99,11 +119,13 @@ pub(crate) fn accept_err(e: std::io::Error) -> AnyError { } } -#[op] -async fn op_net_accept_tcp( +async fn accept_tcp( state: Rc>, - rid: ResourceId, -) -> Result<(ResourceId, IpAddr, IpAddr), AnyError> { + args: AcceptArgs, + _: (), +) -> Result { + let rid = args.rid; + let resource = state .borrow() .resource_table @@ -125,15 +147,51 @@ async fn op_net_accept_tcp( let rid = state .resource_table .add(TcpStreamResource::new(tcp_stream.into_split())); - Ok((rid, IpAddr::from(local_addr), IpAddr::from(remote_addr))) + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Tcp(IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + })), + remote_addr: Some(OpAddr::Tcp(IpAddr { + hostname: remote_addr.ip().to_string(), + port: remote_addr.port(), + })), + }) } #[op] -async fn op_net_recv_udp( +async fn op_net_accept( state: Rc>, - rid: ResourceId, - mut buf: ZeroCopyBuf, -) -> Result<(usize, IpAddr), AnyError> { + args: AcceptArgs, +) -> Result { + match args.transport.as_str() { + "tcp" => accept_tcp(state, args, ()).await, + #[cfg(unix)] + "unix" => net_unix::accept_unix(state, args, ()).await, + other => Err(bad_transport(other)), + } +} + +fn bad_transport(transport: &str) -> AnyError { + generic_error(format!("Unsupported transport protocol {}", transport)) +} + +#[derive(Deserialize)] +pub(crate) struct ReceiveArgs { + pub rid: ResourceId, + pub transport: String, +} + +async fn receive_udp( + state: Rc>, + args: ReceiveArgs, + zero_copy: ZeroCopyBuf, +) -> Result { + let mut zero_copy = zero_copy.clone(); + + let rid = args.rid; + let resource = state .borrow_mut() .resource_table @@ -141,75 +199,192 @@ async fn op_net_recv_udp( .map_err(|_| bad_resource("Socket has been closed"))?; let socket = RcRef::map(&resource, |r| &r.socket).borrow().await; let cancel_handle = RcRef::map(&resource, |r| &r.cancel); - let (nread, remote_addr) = socket - .recv_from(&mut buf) + let (size, remote_addr) = socket + .recv_from(&mut zero_copy) .try_or_cancel(cancel_handle) .await?; - Ok((nread, IpAddr::from(remote_addr))) + Ok(OpPacket { + size, + remote_addr: OpAddr::Udp(IpAddr { + hostname: remote_addr.ip().to_string(), + port: remote_addr.port(), + }), + }) } #[op] -async fn op_net_send_udp( +async fn op_dgram_recv( state: Rc>, + args: ReceiveArgs, + zero_copy: ZeroCopyBuf, +) -> Result { + match args.transport.as_str() { + "udp" => receive_udp(state, args, zero_copy).await, + #[cfg(unix)] + "unixpacket" => net_unix::receive_unix_packet(state, args, zero_copy).await, + other => Err(bad_transport(other)), + } +} + +#[derive(Deserialize)] +struct SendArgs { rid: ResourceId, - addr: IpAddr, + transport: String, + #[serde(flatten)] + transport_args: ArgsEnum, +} + +#[op] +async fn op_dgram_send( + state: Rc>, + args: SendArgs, zero_copy: ZeroCopyBuf, ) -> Result where NP: NetPermissions + 'static, { - { - let mut s = state.borrow_mut(); - s.borrow_mut::().check_net( - &(&addr.hostname, Some(addr.port)), - "Deno.DatagramConn.send()", - )?; + let zero_copy = zero_copy.clone(); + + match args { + SendArgs { + rid, + transport, + transport_args: ArgsEnum::Ip(args), + } if transport == "udp" => { + { + let mut s = state.borrow_mut(); + s.borrow_mut::().check_net( + &(&args.hostname, Some(args.port)), + "Deno.DatagramConn.send()", + )?; + } + let addr = resolve_addr(&args.hostname, args.port) + .await? + .next() + .ok_or_else(|| generic_error("No resolved address found"))?; + + let resource = state + .borrow_mut() + .resource_table + .get::(rid) + .map_err(|_| bad_resource("Socket has been closed"))?; + let socket = RcRef::map(&resource, |r| &r.socket).borrow().await; + let byte_length = socket.send_to(&zero_copy, &addr).await?; + Ok(byte_length) + } + #[cfg(unix)] + SendArgs { + rid, + transport, + transport_args: ArgsEnum::Unix(args), + } if transport == "unixpacket" => { + let address_path = Path::new(&args.path); + { + let mut s = state.borrow_mut(); + s.borrow_mut::() + .check_write(address_path, "Deno.DatagramConn.send()")?; + } + let resource = state + .borrow() + .resource_table + .get::(rid) + .map_err(|_| custom_error("NotConnected", "Socket has been closed"))?; + let socket = RcRef::map(&resource, |r| &r.socket) + .try_borrow_mut() + .ok_or_else(|| custom_error("Busy", "Socket already in use"))?; + let byte_length = socket.send_to(&zero_copy, address_path).await?; + Ok(byte_length) + } + _ => Err(type_error("Wrong argument format!")), } - let addr = resolve_addr(&addr.hostname, addr.port) - .await? - .next() - .ok_or_else(|| generic_error("No resolved address found"))?; +} - let resource = state - .borrow_mut() - .resource_table - .get::(rid) - .map_err(|_| bad_resource("Socket has been closed"))?; - let socket = RcRef::map(&resource, |r| &r.socket).borrow().await; - let nwritten = socket.send_to(&zero_copy, &addr).await?; - - Ok(nwritten) +#[derive(Deserialize)] +pub struct ConnectArgs { + transport: String, + #[serde(flatten)] + transport_args: ArgsEnum, } #[op] -pub async fn op_net_connect_tcp( +pub async fn op_net_connect( state: Rc>, - addr: IpAddr, -) -> Result<(ResourceId, IpAddr, IpAddr), AnyError> + args: ConnectArgs, +) -> Result where NP: NetPermissions + 'static, { - { - let mut state_ = state.borrow_mut(); - state_ - .borrow_mut::() - .check_net(&(&addr.hostname, Some(addr.port)), "Deno.connect()")?; + match args { + ConnectArgs { + transport, + transport_args: ArgsEnum::Ip(args), + } if transport == "tcp" => { + { + let mut state_ = state.borrow_mut(); + state_ + .borrow_mut::() + .check_net(&(&args.hostname, Some(args.port)), "Deno.connect()")?; + } + let addr = resolve_addr(&args.hostname, args.port) + .await? + .next() + .ok_or_else(|| generic_error("No resolved address found"))?; + let tcp_stream = TcpStream::connect(&addr).await?; + let local_addr = tcp_stream.local_addr()?; + let remote_addr = tcp_stream.peer_addr()?; + + let mut state_ = state.borrow_mut(); + let rid = state_ + .resource_table + .add(TcpStreamResource::new(tcp_stream.into_split())); + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Tcp(IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + })), + remote_addr: Some(OpAddr::Tcp(IpAddr { + hostname: remote_addr.ip().to_string(), + port: remote_addr.port(), + })), + }) + } + #[cfg(unix)] + ConnectArgs { + transport, + transport_args: ArgsEnum::Unix(args), + } if transport == "unix" => { + let address_path = Path::new(&args.path); + super::check_unstable2(&state, "Deno.connect"); + { + let mut state_ = state.borrow_mut(); + state_ + .borrow_mut::() + .check_read(address_path, "Deno.connect()")?; + state_ + .borrow_mut::() + .check_write(address_path, "Deno.connect()")?; + } + let path = args.path; + let unix_stream = net_unix::UnixStream::connect(Path::new(&path)).await?; + let local_addr = unix_stream.local_addr()?; + let remote_addr = unix_stream.peer_addr()?; + + let mut state_ = state.borrow_mut(); + let resource = UnixStreamResource::new(unix_stream.into_split()); + let rid = state_.resource_table.add(resource); + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Unix(net_unix::UnixAddr { + path: local_addr.as_pathname().and_then(net_unix::pathstring), + })), + remote_addr: Some(OpAddr::Unix(net_unix::UnixAddr { + path: remote_addr.as_pathname().and_then(net_unix::pathstring), + })), + }) + } + _ => Err(type_error("Wrong argument format!")), } - - let addr = resolve_addr(&addr.hostname, addr.port) - .await? - .next() - .ok_or_else(|| generic_error("No resolved address found"))?; - let tcp_stream = TcpStream::connect(&addr).await?; - let local_addr = tcp_stream.local_addr()?; - let remote_addr = tcp_stream.peer_addr()?; - - let mut state_ = state.borrow_mut(); - let rid = state_ - .resource_table - .add(TcpStreamResource::new(tcp_stream.into_split())); - - Ok((rid, IpAddr::from(local_addr), IpAddr::from(remote_addr))) } pub struct TcpListenerResource { @@ -242,20 +417,33 @@ impl Resource for UdpSocketResource { } } -#[op] -fn op_net_listen_tcp( +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct IpListenArgs { + hostname: String, + port: u16, + reuse_address: Option, +} + +#[derive(Deserialize)] +#[serde(untagged)] +enum ArgsEnum { + Ip(IpListenArgs), + #[cfg(unix)] + Unix(net_unix::UnixListenArgs), +} + +#[derive(Deserialize)] +struct ListenArgs { + transport: String, + #[serde(flatten)] + transport_args: ArgsEnum, +} + +fn listen_tcp( state: &mut OpState, - addr: IpAddr, -) -> Result<(ResourceId, IpAddr), AnyError> -where - NP: NetPermissions + 'static, -{ - state - .borrow_mut::() - .check_net(&(&addr.hostname, Some(addr.port)), "Deno.listen()")?; - let addr = resolve_addr_sync(&addr.hostname, addr.port)? - .next() - .ok_or_else(|| generic_error("No resolved address found"))?; + addr: SocketAddr, +) -> Result<(u32, SocketAddr), AnyError> { let domain = if addr.is_ipv4() { Domain::IPV4 } else { @@ -277,33 +465,21 @@ where }; let rid = state.resource_table.add(listener_resource); - Ok((rid, IpAddr::from(local_addr))) + Ok((rid, local_addr)) } -#[op] -fn op_net_listen_udp( +fn listen_udp( state: &mut OpState, - addr: IpAddr, - reuse_address: bool, -) -> Result<(ResourceId, IpAddr), AnyError> -where - NP: NetPermissions + 'static, -{ - super::check_unstable(state, "Deno.listenDatagram"); - state - .borrow_mut::() - .check_net(&(&addr.hostname, Some(addr.port)), "Deno.listenDatagram()")?; - let addr = resolve_addr_sync(&addr.hostname, addr.port)? - .next() - .ok_or_else(|| generic_error("No resolved address found"))?; - + addr: SocketAddr, + reuse_address: Option, +) -> Result<(u32, SocketAddr), AnyError> { let domain = if addr.is_ipv4() { Domain::IPV4 } else { Domain::IPV6 }; let socket_tmp = Socket::new(domain, Type::DGRAM, Some(Protocol::UDP))?; - if reuse_address { + if reuse_address.unwrap_or(false) { // This logic is taken from libuv: // // On the BSDs, SO_REUSEPORT implies SO_REUSEADDR but with some additional @@ -332,7 +508,110 @@ where }; let rid = state.resource_table.add(socket_resource); - Ok((rid, IpAddr::from(local_addr))) + Ok((rid, local_addr)) +} + +#[op] +fn op_net_listen( + state: &mut OpState, + args: ListenArgs, +) -> Result +where + NP: NetPermissions + 'static, +{ + match args { + ListenArgs { + transport, + transport_args: ArgsEnum::Ip(args), + } => { + { + if transport == "udp" { + super::check_unstable(state, "Deno.listenDatagram"); + } + state.borrow_mut::().check_net( + &(&args.hostname, Some(args.port)), + "Deno.listenDatagram()", + )?; + } + let addr = resolve_addr_sync(&args.hostname, args.port)? + .next() + .ok_or_else(|| generic_error("No resolved address found"))?; + let (rid, local_addr) = if transport == "tcp" { + if args.reuse_address.is_some() { + return Err(generic_error( + "The reuseAddress option is not supported for TCP", + )); + } + listen_tcp(state, addr)? + } else { + listen_udp(state, addr, args.reuse_address)? + }; + debug!( + "New listener {} {}:{}", + rid, + local_addr.ip().to_string(), + local_addr.port() + ); + let ip_addr = IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + }; + Ok(OpConn { + rid, + local_addr: Some(match transport.as_str() { + "udp" => OpAddr::Udp(ip_addr), + "tcp" => OpAddr::Tcp(ip_addr), + // NOTE: This could be unreachable!() + other => return Err(bad_transport(other)), + }), + remote_addr: None, + }) + } + #[cfg(unix)] + ListenArgs { + transport, + transport_args: ArgsEnum::Unix(args), + } if transport == "unix" || transport == "unixpacket" => { + let address_path = Path::new(&args.path); + { + if transport == "unix" { + super::check_unstable(state, "Deno.listen"); + } + if transport == "unixpacket" { + super::check_unstable(state, "Deno.listenDatagram"); + } + let api_name = if transport == "unix" { + "Deno.listen()" + } else { + "Deno.listenDatagram()" + }; + let permissions = state.borrow_mut::(); + permissions.check_read(address_path, api_name)?; + permissions.check_write(address_path, api_name)?; + } + let (rid, local_addr) = if transport == "unix" { + net_unix::listen_unix(state, address_path)? + } else { + net_unix::listen_unix_packet(state, address_path)? + }; + debug!("New listener {} {:?}", rid, local_addr); + let unix_addr = net_unix::UnixAddr { + path: local_addr.as_pathname().and_then(net_unix::pathstring), + }; + + Ok(OpConn { + rid, + local_addr: Some(match transport.as_str() { + "unix" => OpAddr::Unix(unix_addr), + "unixpacket" => OpAddr::UnixPacket(unix_addr), + other => return Err(bad_transport(other)), + }), + remote_addr: None, + }) + } + #[cfg(unix)] + _ => Err(type_error("Wrong argument format!")), + } } #[derive(Serialize, Eq, PartialEq, Debug)] @@ -849,15 +1128,21 @@ mod tests { let conn_state = runtime.op_state(); let server_addr: Vec<&str> = clone_addr.split(':').collect(); - let ip_addr = IpAddr { + let ip_args = IpListenArgs { hostname: String::from(server_addr[0]), port: server_addr[1].parse().unwrap(), + reuse_address: None, + }; + let connect_args = ConnectArgs { + transport: String::from("tcp"), + transport_args: ArgsEnum::Ip(ip_args), }; let connect_fut = - op_net_connect_tcp::call::(conn_state, ip_addr); - let (rid, _, _) = connect_fut.await.unwrap(); + op_net_connect::call::(conn_state, connect_args); + let conn = connect_fut.await.unwrap(); + let rid = conn.rid; let state = runtime.op_state(); set_sockopt_fn(&mut state.borrow_mut(), rid); diff --git a/ext/net/ops_tls.rs b/ext/net/ops_tls.rs index b274268948..a59cd747ed 100644 --- a/ext/net/ops_tls.rs +++ b/ext/net/ops_tls.rs @@ -2,6 +2,8 @@ use crate::io::TcpStreamResource; use crate::ops::IpAddr; +use crate::ops::OpAddr; +use crate::ops::OpConn; use crate::ops::TlsHandshakeInfo; use crate::resolve_addr::resolve_addr; use crate::resolve_addr::resolve_addr_sync; @@ -656,9 +658,9 @@ impl Write for ImplementWriteTrait<'_, TcpStream> { pub fn init() -> Vec { vec![ op_tls_start::decl::

(), - op_net_connect_tls::decl::

(), - op_net_listen_tls::decl::

(), - op_net_accept_tls::decl(), + op_tls_connect::decl::

(), + op_tls_listen::decl::

(), + op_tls_accept::decl(), op_tls_handshake::decl(), ] } @@ -749,6 +751,9 @@ impl Resource for TlsStreamResource { #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct ConnectTlsArgs { + transport: String, + hostname: String, + port: u16, cert_file: Option, ca_certs: Vec, cert_chain: Option, @@ -769,7 +774,7 @@ pub struct StartTlsArgs { pub async fn op_tls_start( state: Rc>, args: StartTlsArgs, -) -> Result<(ResourceId, IpAddr, IpAddr), AnyError> +) -> Result where NP: NetPermissions + 'static, { @@ -848,18 +853,33 @@ where .add(TlsStreamResource::new(tls_stream.into_split())) }; - Ok((rid, IpAddr::from(local_addr), IpAddr::from(remote_addr))) + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Tcp(IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + })), + remote_addr: Some(OpAddr::Tcp(IpAddr { + hostname: remote_addr.ip().to_string(), + port: remote_addr.port(), + })), + }) } #[op] -pub async fn op_net_connect_tls( +pub async fn op_tls_connect( state: Rc>, - addr: IpAddr, args: ConnectTlsArgs, -) -> Result<(ResourceId, IpAddr, IpAddr), AnyError> +) -> Result where NP: NetPermissions + 'static, { + assert_eq!(args.transport, "tcp"); + let hostname = match &*args.hostname { + "" => "localhost", + n => n, + }; + let port = args.port; let cert_file = args.cert_file.as_deref(); let unsafely_ignore_certificate_errors = state .borrow() @@ -876,8 +896,7 @@ where { let mut s = state.borrow_mut(); let permissions = s.borrow_mut::(); - permissions - .check_net(&(&addr.hostname, Some(addr.port)), "Deno.connectTls()")?; + permissions.check_net(&(hostname, Some(port)), "Deno.connectTls()")?; if let Some(path) = cert_file { permissions.check_read(Path::new(path), "Deno.connectTls()")?; } @@ -900,9 +919,10 @@ where .borrow::() .root_cert_store .clone(); - let hostname_dns = ServerName::try_from(&*addr.hostname) - .map_err(|_| invalid_hostname(&addr.hostname))?; - let connect_addr = resolve_addr(&addr.hostname, addr.port) + let hostname_dns = + ServerName::try_from(hostname).map_err(|_| invalid_hostname(hostname))?; + + let connect_addr = resolve_addr(hostname, port) .await? .next() .ok_or_else(|| generic_error("No resolved address found"))?; @@ -948,7 +968,17 @@ where .add(TlsStreamResource::new(tls_stream.into_split())) }; - Ok((rid, IpAddr::from(local_addr), IpAddr::from(remote_addr))) + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Tcp(IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + })), + remote_addr: Some(OpAddr::Tcp(IpAddr { + hostname: remote_addr.ip().to_string(), + port: remote_addr.port(), + })), + }) } fn load_certs_from_file(path: &str) -> Result, AnyError> { @@ -983,6 +1013,9 @@ impl Resource for TlsListenerResource { #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct ListenTlsArgs { + transport: String, + hostname: String, + port: u16, cert: Option, // TODO(kt3k): Remove this option at v2.0. cert_file: Option, @@ -993,14 +1026,16 @@ pub struct ListenTlsArgs { } #[op] -pub fn op_net_listen_tls( +pub fn op_tls_listen( state: &mut OpState, - addr: IpAddr, args: ListenTlsArgs, -) -> Result<(ResourceId, IpAddr), AnyError> +) -> Result where NP: NetPermissions + 'static, { + assert_eq!(args.transport, "tcp"); + let hostname = &*args.hostname; + let port = args.port; let cert_file = args.cert_file.as_deref(); let key_file = args.key_file.as_deref(); let cert = args.cert.as_deref(); @@ -1008,8 +1043,7 @@ where { let permissions = state.borrow_mut::(); - permissions - .check_net(&(&addr.hostname, Some(addr.port)), "Deno.listenTls()")?; + permissions.check_net(&(hostname, Some(port)), "Deno.listenTls()")?; if let Some(path) = cert_file { permissions.check_read(Path::new(path), "Deno.listenTls()")?; } @@ -1050,7 +1084,7 @@ where alpn_protocols.into_iter().map(|s| s.into_bytes()).collect(); } - let bind_addr = resolve_addr_sync(&addr.hostname, addr.port)? + let bind_addr = resolve_addr_sync(hostname, port)? .next() .ok_or_else(|| generic_error("No resolved address found"))?; let domain = if bind_addr.is_ipv4() { @@ -1077,14 +1111,21 @@ where let rid = state.resource_table.add(tls_listener_resource); - Ok((rid, IpAddr::from(local_addr))) + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Tcp(IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + })), + remote_addr: None, + }) } #[op] -pub async fn op_net_accept_tls( +pub async fn op_tls_accept( state: Rc>, rid: ResourceId, -) -> Result<(ResourceId, IpAddr, IpAddr), AnyError> { +) -> Result { let resource = state .borrow() .resource_table @@ -1118,7 +1159,17 @@ pub async fn op_net_accept_tls( .add(TlsStreamResource::new(tls_stream.into_split())) }; - Ok((rid, IpAddr::from(local_addr), IpAddr::from(remote_addr))) + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Tcp(IpAddr { + hostname: local_addr.ip().to_string(), + port: local_addr.port(), + })), + remote_addr: Some(OpAddr::Tcp(IpAddr { + hostname: remote_addr.ip().to_string(), + port: remote_addr.port(), + })), + }) } #[op] diff --git a/ext/net/ops_unix.rs b/ext/net/ops_unix.rs index b45b023432..181dcacec3 100644 --- a/ext/net/ops_unix.rs +++ b/ext/net/ops_unix.rs @@ -1,18 +1,20 @@ // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. use crate::io::UnixStreamResource; -use crate::NetPermissions; +use crate::ops::AcceptArgs; +use crate::ops::OpAddr; +use crate::ops::OpConn; +use crate::ops::OpPacket; +use crate::ops::ReceiveArgs; use deno_core::error::bad_resource; use deno_core::error::custom_error; use deno_core::error::AnyError; -use deno_core::op; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::CancelTryFuture; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; -use deno_core::ResourceId; use deno_core::ZeroCopyBuf; use serde::Deserialize; use serde::Serialize; @@ -72,11 +74,13 @@ pub struct UnixListenArgs { pub path: String, } -#[op] -pub async fn op_net_accept_unix( +pub(crate) async fn accept_unix( state: Rc>, - rid: ResourceId, -) -> Result<(ResourceId, Option, Option), AnyError> { + args: AcceptArgs, + _: (), +) -> Result { + let rid = args.rid; + let resource = state .borrow() .resource_table @@ -94,52 +98,27 @@ pub async fn op_net_accept_unix( let local_addr = unix_stream.local_addr()?; let remote_addr = unix_stream.peer_addr()?; - let local_addr_path = local_addr.as_pathname().map(pathstring).transpose()?; - let remote_addr_path = - remote_addr.as_pathname().map(pathstring).transpose()?; let resource = UnixStreamResource::new(unix_stream.into_split()); let mut state = state.borrow_mut(); let rid = state.resource_table.add(resource); - Ok((rid, local_addr_path, remote_addr_path)) + Ok(OpConn { + rid, + local_addr: Some(OpAddr::Unix(UnixAddr { + path: local_addr.as_pathname().and_then(pathstring), + })), + remote_addr: Some(OpAddr::Unix(UnixAddr { + path: remote_addr.as_pathname().and_then(pathstring), + })), + }) } -#[op] -pub async fn op_net_connect_unix( +pub(crate) async fn receive_unix_packet( state: Rc>, - path: String, -) -> Result<(ResourceId, Option, Option), AnyError> -where - NP: NetPermissions + 'static, -{ - let address_path = Path::new(&path); - super::check_unstable2(&state, "Deno.connect"); - { - let mut state_ = state.borrow_mut(); - state_ - .borrow_mut::() - .check_read(address_path, "Deno.connect()")?; - state_ - .borrow_mut::() - .check_write(address_path, "Deno.connect()")?; - } - let unix_stream = UnixStream::connect(Path::new(&path)).await?; - let local_addr = unix_stream.local_addr()?; - let remote_addr = unix_stream.peer_addr()?; - let local_addr_path = local_addr.as_pathname().map(pathstring).transpose()?; - let remote_addr_path = - remote_addr.as_pathname().map(pathstring).transpose()?; - let mut state_ = state.borrow_mut(); - let resource = UnixStreamResource::new(unix_stream.into_split()); - let rid = state_.resource_table.add(resource); - Ok((rid, local_addr_path, remote_addr_path)) -} - -#[op] -pub async fn op_net_recv_unixpacket( - state: Rc>, - rid: ResourceId, + args: ReceiveArgs, mut buf: ZeroCopyBuf, -) -> Result<(usize, Option), AnyError> { +) -> Result { + let rid = args.rid; + let resource = state .borrow() .resource_table @@ -149,90 +128,46 @@ pub async fn op_net_recv_unixpacket( .try_borrow_mut() .ok_or_else(|| custom_error("Busy", "Socket already in use"))?; let cancel = RcRef::map(resource, |r| &r.cancel); - let (nread, remote_addr) = + let (size, remote_addr) = socket.recv_from(&mut buf).try_or_cancel(cancel).await?; - let path = remote_addr.as_pathname().map(pathstring).transpose()?; - Ok((nread, path)) + Ok(OpPacket { + size, + remote_addr: OpAddr::UnixPacket(UnixAddr { + path: remote_addr.as_pathname().and_then(pathstring), + }), + }) } -#[op] -async fn op_net_send_unixpacket( - state: Rc>, - rid: ResourceId, - path: String, - zero_copy: ZeroCopyBuf, -) -> Result -where - NP: NetPermissions + 'static, -{ - let address_path = Path::new(&path); - { - let mut s = state.borrow_mut(); - s.borrow_mut::() - .check_write(address_path, "Deno.DatagramConn.send()")?; - } - - let resource = state - .borrow() - .resource_table - .get::(rid) - .map_err(|_| custom_error("NotConnected", "Socket has been closed"))?; - let socket = RcRef::map(&resource, |r| &r.socket) - .try_borrow_mut() - .ok_or_else(|| custom_error("Busy", "Socket already in use"))?; - let nwritten = socket.send_to(&zero_copy, address_path).await?; - - Ok(nwritten) -} - -#[op] -pub fn op_net_listen_unix( +pub fn listen_unix( state: &mut OpState, - path: String, -) -> Result<(ResourceId, Option), AnyError> -where - NP: NetPermissions + 'static, -{ - let address_path = Path::new(&path); - super::check_unstable(state, "Deno.listen"); - let permissions = state.borrow_mut::(); - permissions.check_read(address_path, "Deno.listen()")?; - permissions.check_write(address_path, "Deno.listen()")?; - let listener = UnixListener::bind(&address_path)?; + addr: &Path, +) -> Result<(u32, tokio::net::unix::SocketAddr), AnyError> { + let listener = UnixListener::bind(&addr)?; let local_addr = listener.local_addr()?; - let pathname = local_addr.as_pathname().map(pathstring).transpose()?; let listener_resource = UnixListenerResource { listener: AsyncRefCell::new(listener), cancel: Default::default(), }; let rid = state.resource_table.add(listener_resource); - Ok((rid, pathname)) + + Ok((rid, local_addr)) } -#[op] -pub fn op_net_listen_unixpacket( +pub fn listen_unix_packet( state: &mut OpState, - path: String, -) -> Result<(ResourceId, Option), AnyError> -where - NP: NetPermissions + 'static, -{ - let address_path = Path::new(&path); - super::check_unstable(state, "Deno.listenDatagram"); - let permissions = state.borrow_mut::(); - permissions.check_read(address_path, "Deno.listenDatagram()")?; - permissions.check_write(address_path, "Deno.listenDatagram()")?; - let socket = UnixDatagram::bind(&address_path)?; + addr: &Path, +) -> Result<(u32, tokio::net::unix::SocketAddr), AnyError> { + let socket = UnixDatagram::bind(&addr)?; let local_addr = socket.local_addr()?; - let pathname = local_addr.as_pathname().map(pathstring).transpose()?; let datagram_resource = UnixDatagramResource { socket: AsyncRefCell::new(socket), cancel: Default::default(), }; let rid = state.resource_table.add(datagram_resource); - Ok((rid, pathname)) + + Ok((rid, local_addr)) } -pub fn pathstring(pathname: &Path) -> Result { - into_string(pathname.into()) +pub fn pathstring(pathname: &Path) -> Option { + into_string(pathname.into()).ok() } diff --git a/runtime/js/40_testing.js b/runtime/js/40_testing.js index d013d651cd..069b27957a 100644 --- a/runtime/js/40_testing.js +++ b/runtime/js/40_testing.js @@ -75,10 +75,8 @@ "op_crypto_sign_key": ["sign data", "awaiting the result of a `crypto.subtle.sign` call"], "op_crypto_subtle_digest": ["digest data", "awaiting the result of a `crypto.subtle.digest` call"], "op_crypto_verify_key": ["verify data", "awaiting the result of a `crypto.subtle.verify` call"], - "op_net_recv_udp": ["receive a datagram message via UDP", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"], - "op_net_recv_unixpacket": ["receive a datagram message via Unixpacket", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"], - "op_net_send_udp": ["send a datagram message via UDP", "awaiting the result of `Deno.DatagramConn#send` call"], - "op_net_send_unixpacket": ["send a datagram message via Unixpacket", "awaiting the result of `Deno.DatagramConn#send` call"], + "op_dgram_recv": ["receive a datagram message", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"], + "op_dgram_send": ["send a datagram message", "awaiting the result of `Deno.DatagramConn#send` call"], "op_dns_resolve": ["resolve a DNS name", "awaiting the result of a `Deno.resolveDns` call"], "op_fdatasync_async": ["flush pending data operations for a file to disk", "awaiting the result of a `Deno.fdatasync` call"], "op_fetch_send": ["send a HTTP request", "awaiting the result of a `fetch` call"], @@ -101,10 +99,8 @@ "op_make_temp_file_async": ["create a temporary file", "awaiting the result of a `Deno.makeTempFile` call"], "op_message_port_recv_message": ["receive a message from a MessagePort", "awaiting the result of not closing a `MessagePort`"], "op_mkdir_async": ["create a directory", "awaiting the result of a `Deno.mkdir` call"], - "op_net_accept_tcp": ["accept a TCP stream", "closing a `Deno.Listener`"], - "op_net_accept_unix": ["accept a Unix stream", "closing a `Deno.Listener`"], - "op_net_connect_tcp": ["connect to a TCP server", "awaiting a `Deno.connect` call"], - "op_net_connect_unix": ["connect to a Unix server", "awaiting a `Deno.connect` call"], + "op_net_accept": ["accept a TCP connection", "closing a `Deno.Listener`"], + "op_net_connect": ["connect to a TCP or UDP server", "awaiting a `Deno.connect` call"], "op_open_async": ["open a file", "awaiting the result of a `Deno.open` call"], "op_read_dir_async": ["read a directory", "collecting all items in the async iterable returned from a `Deno.readDir` call"], "op_read_link_async": ["read a symlink", "awaiting the result of a `Deno.readLink` call"], @@ -117,8 +113,8 @@ "op_sleep": ["sleep for a duration", "cancelling a `setTimeout` or `setInterval` call"], "op_stat_async": ["get file metadata", "awaiting the result of a `Deno.stat` call"], "op_symlink_async": ["create a symlink", "awaiting the result of a `Deno.symlink` call"], - "op_net_accept_tls": ["accept a TLS stream", "closing a `Deno.TlsListener`"], - "op_net_connect_tls": ["connect to a TLS server", "awaiting a `Deno.connectTls` call"], + "op_tls_accept": ["accept a TLS connection", "closing a `Deno.TlsListener`"], + "op_tls_connect": ["connect to a TLS server", "awaiting a `Deno.connectTls` call"], "op_tls_handshake": ["perform a TLS handshake", "awaiting a `Deno.TlsConn#handshake` call"], "op_tls_start": ["start a TLS connection", "awaiting a `Deno.startTls` call"], "op_truncate_async": ["truncate a file", "awaiting the result of a `Deno.truncate` call"], diff --git a/runtime/js/90_deno_ns.js b/runtime/js/90_deno_ns.js index b9e361ae4d..ef5edffc9c 100644 --- a/runtime/js/90_deno_ns.js +++ b/runtime/js/90_deno_ns.js @@ -128,7 +128,10 @@ networkInterfaces: __bootstrap.os.networkInterfaces, getGid: __bootstrap.os.getGid, getUid: __bootstrap.os.getUid, - listenDatagram: __bootstrap.net.listenDatagram, + listen: __bootstrap.netUnstable.listen, + connect: __bootstrap.netUnstable.connect, + listenDatagram: __bootstrap.netUnstable.listenDatagram, + Listener: __bootstrap.netUnstable.Listener, umask: __bootstrap.fs.umask, utime: __bootstrap.fs.utime, utimeSync: __bootstrap.fs.utimeSync, diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js index afacd9b34a..1ac1153f8b 100644 --- a/runtime/js/99_main.js +++ b/runtime/js/99_main.js @@ -58,7 +58,6 @@ delete Intl.v8BreakIterator; const worker = window.__bootstrap.worker; const internals = window.__bootstrap.internals; const performance = window.__bootstrap.performance; - const net = window.__bootstrap.net; const crypto = window.__bootstrap.crypto; const url = window.__bootstrap.url; const urlPattern = window.__bootstrap.urlPattern; @@ -693,8 +692,6 @@ delete Intl.v8BreakIterator; } performance.setTimeOrigin(DateNow()); - net.setup(runtimeOptions.unstableFlag); - const consoleFromV8 = window.console; const wrapConsole = window.__bootstrap.console.wrapConsole; @@ -792,8 +789,6 @@ delete Intl.v8BreakIterator; } performance.setTimeOrigin(DateNow()); - net.setup(runtimeOptions.unstableFlag); - const consoleFromV8 = window.console; const wrapConsole = window.__bootstrap.console.wrapConsole;