language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-08-31 07:47:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

refactor(ext/net): use concrete error type (#26227)

Browse source
This commit is contained in:
Leo Kettmeir 2024-10-17 09:43:04 -07:00 • committed by GitHub
parent 3b62e05062
commit ed13efc4ac
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 317 additions and 191 deletions
Download patch file Download diff file Expand all files Collapse all files

67
ext/net/ops_unix.rs
View file

@ -1,11 +1,9 @@
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
use crate::io::UnixStreamResource;
use crate::ops::NetError;
use crate::raw::NetworkListenerResource;
use crate::NetPermissions;
use deno_core::error::bad_resource;
use deno_core::error::custom_error;
use deno_core::error::AnyError;
use deno_core::op2;
use deno_core::AsyncRefCell;
use deno_core::CancelHandle;
@ -26,11 +24,8 @@ use tokio::net::UnixListener;
pub use tokio::net::UnixStream;
/// A utility function to map OsStrings to Strings
pub fn into_string(s: std::ffi::OsString) -> Result<String, AnyError> {
s.into_string().map_err(|s| {
let message = format!("File name or path {s:?} is not valid UTF-8");
custom_error("InvalidData", message)
})
pub fn into_string(s: std::ffi::OsString) -> Result<String, NetError> {
s.into_string().map_err(NetError::InvalidUtf8)
}
pub struct UnixDatagramResource {
@ -63,15 +58,15 @@ pub struct UnixListenArgs {
pub async fn op_net_accept_unix(
state: Rc<RefCell<OpState>>,
#[smi] rid: ResourceId,
) -> Result<(ResourceId, Option<String>, Option<String>), AnyError> {
) -> Result<(ResourceId, Option<String>, Option<String>), NetError> {
let resource = state
.borrow()
.resource_table
.get::<NetworkListenerResource<UnixListener>>(rid)
.map_err(|_| bad_resource("Listener has been closed"))?;
.map_err(|_| NetError::ListenerClosed)?;
let listener = RcRef::map(&resource, |r| &r.listener)
.try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Listener already in use"))?;
.ok_or(NetError::ListenerBusy)?;
let cancel = RcRef::map(resource, |r| &r.cancel);
let (unix_stream, _socket_addr) = listener
.accept()
@ -95,7 +90,7 @@ pub async fn op_net_accept_unix(
pub async fn op_net_connect_unix<NP>(
state: Rc<RefCell<OpState>>,
#[string] address_path: String,
) -> Result<(ResourceId, Option<String>, Option<String>), AnyError>
) -> Result<(ResourceId, Option<String>, Option<String>), NetError>
where
NP: NetPermissions + 'static,
{
@ -103,10 +98,12 @@ where
let mut state_ = state.borrow_mut();
let address_path = state_
.borrow_mut::<NP>()
.check_read(&address_path, "Deno.connect()")?;
.check_read(&address_path, "Deno.connect()")
.map_err(NetError::Permission)?;
_ = state_
.borrow_mut::<NP>()
.check_write_path(&address_path, "Deno.connect()")?;
.check_write_path(&address_path, "Deno.connect()")
.map_err(NetError::Permission)?;
address_path
};
let unix_stream = UnixStream::connect(&address_path).await?;
@ -127,15 +124,15 @@ pub async fn op_net_recv_unixpacket(
state: Rc<RefCell<OpState>>,
#[smi] rid: ResourceId,
#[buffer] mut buf: JsBuffer,
) -> Result<(usize, Option<String>), AnyError> {
) -> Result<(usize, Option<String>), NetError> {
let resource = state
.borrow()
.resource_table
.get::<UnixDatagramResource>(rid)
.map_err(|_| bad_resource("Socket has been closed"))?;
.map_err(|_| NetError::SocketClosed)?;
let socket = RcRef::map(&resource, |r| &r.socket)
.try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Socket already in use"))?;
.ok_or(NetError::SocketBusy)?;
let cancel = RcRef::map(resource, |r| &r.cancel);
let (nread, remote_addr) =
socket.recv_from(&mut buf).try_or_cancel(cancel).await?;
@ -150,24 +147,25 @@ pub async fn op_net_send_unixpacket<NP>(
#[smi] rid: ResourceId,
#[string] address_path: String,
#[buffer] zero_copy: JsBuffer,
) -> Result<usize, AnyError>
) -> Result<usize, NetError>
where
NP: NetPermissions + 'static,
{
let address_path = {
let mut s = state.borrow_mut();
s.borrow_mut::<NP>()
.check_write(&address_path, "Deno.DatagramConn.send()")?
.check_write(&address_path, "Deno.DatagramConn.send()")
.map_err(NetError::Permission)?
};
let resource = state
.borrow()
.resource_table
.get::<UnixDatagramResource>(rid)
.map_err(|_| custom_error("NotConnected", "Socket has been closed"))?;
.map_err(|_| NetError::SocketClosedNotConnected)?;
let socket = RcRef::map(&resource, |r| &r.socket)
.try_borrow_mut()
.ok_or_else(|| custom_error("Busy", "Socket already in use"))?;
.ok_or(NetError::SocketBusy)?;
let nwritten = socket.send_to(&zero_copy, address_path).await?;
Ok(nwritten)
@ -179,14 +177,18 @@ pub fn op_net_listen_unix<NP>(
state: &mut OpState,
#[string] address_path: String,
#[string] api_name: String,
) -> Result<(ResourceId, Option<String>), AnyError>
) -> Result<(ResourceId, Option<String>), NetError>
where
NP: NetPermissions + 'static,
{
let permissions = state.borrow_mut::<NP>();
let api_call_expr = format!("{}()", api_name);
let address_path = permissions.check_read(&address_path, &api_call_expr)?;
_ = permissions.check_write_path(&address_path, &api_call_expr)?;
let address_path = permissions
.check_read(&address_path, &api_call_expr)
.map_err(NetError::Permission)?;
_ = permissions
.check_write_path(&address_path, &api_call_expr)
.map_err(NetError::Permission)?;
let listener = UnixListener::bind(address_path)?;
let local_addr = listener.local_addr()?;
let pathname = local_addr.as_pathname().map(pathstring).transpose()?;
@ -198,14 +200,17 @@ where
pub fn net_listen_unixpacket<NP>(
state: &mut OpState,
address_path: String,
) -> Result<(ResourceId, Option<String>), AnyError>
) -> Result<(ResourceId, Option<String>), NetError>
where
NP: NetPermissions + 'static,
{
let permissions = state.borrow_mut::<NP>();
let address_path =
permissions.check_read(&address_path, "Deno.listenDatagram()")?;
_ = permissions.check_write_path(&address_path, "Deno.listenDatagram()")?;
let address_path = permissions
.check_read(&address_path, "Deno.listenDatagram()")
.map_err(NetError::Permission)?;
_ = permissions
.check_write_path(&address_path, "Deno.listenDatagram()")
.map_err(NetError::Permission)?;
let socket = UnixDatagram::bind(address_path)?;
let local_addr = socket.local_addr()?;
let pathname = local_addr.as_pathname().map(pathstring).transpose()?;
@ -222,7 +227,7 @@ where
pub fn op_net_listen_unixpacket<NP>(
state: &mut OpState,
#[string] path: String,
) -> Result<(ResourceId, Option<String>), AnyError>
) -> Result<(ResourceId, Option<String>), NetError>
where
NP: NetPermissions + 'static,
{
@ -235,13 +240,13 @@ where
pub fn op_node_unstable_net_listen_unixpacket<NP>(
state: &mut OpState,
#[string] path: String,
) -> Result<(ResourceId, Option<String>), AnyError>
) -> Result<(ResourceId, Option<String>), NetError>
where
NP: NetPermissions + 'static,
{
net_listen_unixpacket::<NP>(state, path)
}
pub fn pathstring(pathname: &Path) -> Result<String, AnyError> {
pub fn pathstring(pathname: &Path) -> Result<String, NetError> {
into_string(pathname.into())
}