summaryrefslogtreecommitdiff
path: root/runtime/errors.rs
diff options
context:
space:
mode:
Diffstat (limited to 'runtime/errors.rs')
-rw-r--r--runtime/errors.rs147
1 files changed, 118 insertions, 29 deletions
diff --git a/runtime/errors.rs b/runtime/errors.rs
index ada26ec35..5051150f2 100644
--- a/runtime/errors.rs
+++ b/runtime/errors.rs
@@ -12,6 +12,8 @@
use crate::ops::fs_events::FsEventsError;
use crate::ops::http::HttpStartError;
use crate::ops::os::OsError;
+use crate::ops::permissions::PermissionError;
+use crate::ops::process::CheckRunPermissionError;
use crate::ops::process::ProcessError;
use crate::ops::signal::SignalError;
use crate::ops::tty::TtyError;
@@ -48,6 +50,12 @@ use deno_kv::KvError;
use deno_kv::KvMutationError;
use deno_napi::NApiError;
use deno_net::ops::NetError;
+use deno_permissions::ChildPermissionError;
+use deno_permissions::NetDescriptorFromUrlParseError;
+use deno_permissions::PathResolveError;
+use deno_permissions::PermissionCheckError;
+use deno_permissions::RunDescriptorParseError;
+use deno_permissions::SysDescriptorParseError;
use deno_tls::TlsError;
use deno_web::BlobError;
use deno_web::CompressionError;
@@ -63,6 +71,54 @@ use std::error::Error;
use std::io;
use std::sync::Arc;
+fn get_run_descriptor_parse_error(e: &RunDescriptorParseError) -> &'static str {
+ match e {
+ RunDescriptorParseError::Which(_) => "Error",
+ RunDescriptorParseError::PathResolve(e) => get_path_resolve_error(e),
+ RunDescriptorParseError::EmptyRunQuery => "Error",
+ }
+}
+
+fn get_sys_descriptor_parse_error(e: &SysDescriptorParseError) -> &'static str {
+ match e {
+ SysDescriptorParseError::InvalidKind(_) => "TypeError",
+ SysDescriptorParseError::Empty => "Error",
+ }
+}
+
+fn get_path_resolve_error(e: &PathResolveError) -> &'static str {
+ match e {
+ PathResolveError::CwdResolve(e) => get_io_error_class(e),
+ PathResolveError::EmptyPath => "Error",
+ }
+}
+
+fn get_permission_error_class(e: &PermissionError) -> &'static str {
+ match e {
+ PermissionError::InvalidPermissionName(_) => "ReferenceError",
+ PermissionError::PathResolve(e) => get_path_resolve_error(e),
+ PermissionError::NetDescriptorParse(_) => "URIError",
+ PermissionError::SysDescriptorParse(e) => get_sys_descriptor_parse_error(e),
+ PermissionError::RunDescriptorParse(e) => get_run_descriptor_parse_error(e),
+ }
+}
+
+fn get_permission_check_error_class(e: &PermissionCheckError) -> &'static str {
+ match e {
+ PermissionCheckError::PermissionDenied(_) => "NotCapable",
+ PermissionCheckError::InvalidFilePath(_) => "URIError",
+ PermissionCheckError::NetDescriptorForUrlParse(e) => match e {
+ NetDescriptorFromUrlParseError::MissingHost(_) => "TypeError",
+ NetDescriptorFromUrlParseError::Host(_) => "URIError",
+ },
+ PermissionCheckError::SysDescriptorParse(e) => {
+ get_sys_descriptor_parse_error(e)
+ }
+ PermissionCheckError::PathResolve(e) => get_path_resolve_error(e),
+ PermissionCheckError::HostParse(_) => "URIError",
+ }
+}
+
fn get_dlopen_error_class(error: &dlopen2::Error) -> &'static str {
use dlopen2::Error::*;
match error {
@@ -445,7 +501,7 @@ fn get_napi_error_class(e: &NApiError) -> &'static str {
NApiError::InvalidPath
| NApiError::LibLoading(_)
| NApiError::ModuleNotFound(_) => "TypeError",
- NApiError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ NApiError::Permission(e) => get_permission_check_error_class(e),
}
}
@@ -523,7 +579,7 @@ fn get_ffi_repr_error_class(e: &ReprError) -> &'static str {
ReprError::InvalidF32 => "TypeError",
ReprError::InvalidF64 => "TypeError",
ReprError::InvalidPointer => "TypeError",
- ReprError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ ReprError::Permission(e) => get_permission_check_error_class(e),
}
}
@@ -531,7 +587,7 @@ fn get_ffi_dlfcn_error_class(e: &DlfcnError) -> &'static str {
match e {
DlfcnError::RegisterSymbol { .. } => "Error",
DlfcnError::Dlopen(_) => "Error",
- DlfcnError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ DlfcnError::Permission(e) => get_permission_check_error_class(e),
DlfcnError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
}
}
@@ -549,7 +605,7 @@ fn get_ffi_callback_error_class(e: &CallbackError) -> &'static str {
match e {
CallbackError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
CallbackError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
- CallbackError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ CallbackError::Permission(e) => get_permission_check_error_class(e),
}
}
@@ -558,8 +614,9 @@ fn get_ffi_call_error_class(e: &CallError) -> &'static str {
CallError::IR(_) => "TypeError",
CallError::NonblockingCallFailure(_) => "Error",
CallError::InvalidSymbol(_) => "TypeError",
- CallError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ CallError::Permission(e) => get_permission_check_error_class(e),
CallError::Callback(e) => get_ffi_callback_error_class(e),
+ CallError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
}
}
@@ -633,9 +690,8 @@ fn get_broadcast_channel_error(error: &BroadcastChannelError) -> &'static str {
fn get_fetch_error(error: &FetchError) -> &'static str {
match error {
- FetchError::Resource(e) | FetchError::Permission(e) => {
- get_error_class_name(e).unwrap_or("Error")
- }
+ FetchError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+ FetchError::Permission(e) => get_permission_check_error_class(e),
FetchError::NetworkError => "TypeError",
FetchError::FsNotGet(_) => "TypeError",
FetchError::InvalidUrl(_) => "TypeError",
@@ -669,9 +725,8 @@ fn get_http_client_create_error(error: &HttpClientCreateError) -> &'static str {
fn get_websocket_error(error: &WebsocketError) -> &'static str {
match error {
- WebsocketError::Permission(e) | WebsocketError::Resource(e) => {
- get_error_class_name(e).unwrap_or("Error")
- }
+ WebsocketError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+ WebsocketError::Permission(e) => get_permission_check_error_class(e),
WebsocketError::Url(e) => get_url_parse_error_class(e),
WebsocketError::Io(e) => get_io_error_class(e),
WebsocketError::WebSocket(_) => "TypeError",
@@ -708,9 +763,10 @@ fn get_fs_ops_error(error: &FsOpsError) -> &'static str {
match error {
FsOpsError::Io(e) => get_io_error_class(e),
FsOpsError::OperationError(e) => get_fs_error(&e.err),
- FsOpsError::Permission(e)
- | FsOpsError::Resource(e)
- | FsOpsError::Other(e) => get_error_class_name(e).unwrap_or("Error"),
+ FsOpsError::Permission(e) => get_permission_check_error_class(e),
+ FsOpsError::Resource(e) | FsOpsError::Other(e) => {
+ get_error_class_name(e).unwrap_or("Error")
+ }
FsOpsError::InvalidUtf8(_) => "InvalidData",
FsOpsError::StripPrefix(_) => "Error",
FsOpsError::Canceled(e) => {
@@ -777,9 +833,10 @@ fn get_net_error(error: &NetError) -> &'static str {
NetError::SocketBusy => "Busy",
NetError::Io(e) => get_io_error_class(e),
NetError::AcceptTaskOngoing => "Busy",
- NetError::RootCertStore(e)
- | NetError::Permission(e)
- | NetError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+ NetError::RootCertStore(e) | NetError::Resource(e) => {
+ get_error_class_name(e).unwrap_or("Error")
+ }
+ NetError::Permission(e) => get_permission_check_error_class(e),
NetError::NoResolvedAddress => "Error",
NetError::AddrParse(_) => "Error",
NetError::Map(e) => get_net_map_error(e),
@@ -810,12 +867,25 @@ fn get_net_map_error(error: &deno_net::io::MapError) -> &'static str {
}
}
+fn get_child_permission_error(e: &ChildPermissionError) -> &'static str {
+ match e {
+ ChildPermissionError::Escalation => "NotCapable",
+ ChildPermissionError::PathResolve(e) => get_path_resolve_error(e),
+ ChildPermissionError::NetDescriptorParse(_) => "URIError",
+ ChildPermissionError::EnvDescriptorParse(_) => "Error",
+ ChildPermissionError::SysDescriptorParse(e) => {
+ get_sys_descriptor_parse_error(e)
+ }
+ ChildPermissionError::RunDescriptorParse(e) => {
+ get_run_descriptor_parse_error(e)
+ }
+ }
+}
+
fn get_create_worker_error(error: &CreateWorkerError) -> &'static str {
match error {
CreateWorkerError::ClassicWorkers => "DOMExceptionNotSupportedError",
- CreateWorkerError::Permission(e) => {
- get_error_class_name(e).unwrap_or("Error")
- }
+ CreateWorkerError::Permission(e) => get_child_permission_error(e),
CreateWorkerError::ModuleResolution(e) => {
get_module_resolution_error_class(e)
}
@@ -862,9 +932,8 @@ fn get_signal_error(error: &SignalError) -> &'static str {
fn get_fs_events_error(error: &FsEventsError) -> &'static str {
match error {
- FsEventsError::Resource(e) | FsEventsError::Permission(e) => {
- get_error_class_name(e).unwrap_or("Error")
- }
+ FsEventsError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+ FsEventsError::Permission(e) => get_permission_check_error_class(e),
FsEventsError::Notify(e) => get_notify_error_class(e),
FsEventsError::Canceled(e) => {
let io_err: io::Error = e.to_owned().into();
@@ -892,9 +961,8 @@ fn get_process_error(error: &ProcessError) -> &'static str {
ProcessError::FailedResolvingCwd(e) | ProcessError::Io(e) => {
get_io_error_class(e)
}
- ProcessError::Permission(e) | ProcessError::Resource(e) => {
- get_error_class_name(e).unwrap_or("Error")
- }
+ ProcessError::Permission(e) => get_permission_check_error_class(e),
+ ProcessError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
ProcessError::BorrowMut(_) => "Error",
ProcessError::Which(_) => "Error",
ProcessError::ChildProcessAlreadyTerminated => "TypeError",
@@ -903,6 +971,14 @@ fn get_process_error(error: &ProcessError) -> &'static str {
ProcessError::InvalidPid => "TypeError",
#[cfg(unix)]
ProcessError::Nix(e) => get_nix_error_class(e),
+ ProcessError::RunPermission(e) => match e {
+ CheckRunPermissionError::Permission(e) => {
+ get_permission_check_error_class(e)
+ }
+ CheckRunPermissionError::Other(e) => {
+ get_error_class_name(e).unwrap_or("Error")
+ }
+ },
}
}
@@ -971,6 +1047,7 @@ fn get_fs_error(e: &FsError) -> &'static str {
mod node {
use super::get_error_class_name;
use super::get_io_error_class;
+ use super::get_permission_check_error_class;
use super::get_serde_json_error_class;
use super::get_url_parse_error_class;
pub use deno_node::ops::blocklist::BlocklistError;
@@ -998,7 +1075,7 @@ mod node {
pub fn get_fs_error(error: &FsError) -> &'static str {
match error {
- FsError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ FsError::Permission(e) => get_permission_check_error_class(e),
FsError::Io(e) => get_io_error_class(e),
#[cfg(windows)]
FsError::PathHasNoRoot => "Error",
@@ -1084,7 +1161,7 @@ mod node {
#[cfg(windows)]
PriorityError::InvalidPriority => "TypeError",
},
- OsError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ OsError::Permission(e) => get_permission_check_error_class(e),
OsError::FailedToGetCpuInfo => "TypeError",
OsError::FailedToGetUserInfo(e) => get_io_error_class(e),
}
@@ -1116,7 +1193,7 @@ mod node {
fn get_os_error(error: &OsError) -> &'static str {
match error {
- OsError::Permission(e) => get_error_class_name(e).unwrap_or("Error"),
+ OsError::Permission(e) => get_permission_check_error_class(e),
OsError::InvalidUtf8(_) => "InvalidData",
OsError::EnvEmptyKey => "TypeError",
OsError::EnvInvalidKey(_) => "TypeError",
@@ -1144,6 +1221,18 @@ fn get_sync_fetch_error(error: &SyncFetchError) -> &'static str {
pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
deno_core::error::get_custom_error_class(e)
+ .or_else(|| {
+ e.downcast_ref::<ChildPermissionError>()
+ .map(get_child_permission_error)
+ })
+ .or_else(|| {
+ e.downcast_ref::<PermissionCheckError>()
+ .map(get_permission_check_error_class)
+ })
+ .or_else(|| {
+ e.downcast_ref::<PermissionError>()
+ .map(get_permission_error_class)
+ })
.or_else(|| e.downcast_ref::<FsError>().map(get_fs_error))
.or_else(|| {
e.downcast_ref::<node::BlocklistError>()
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 01:19:55 +0000