#![cfg_attr(docsrs, feature(doc_cfg))]

#![doc = include_str!("../README.md")]

// @@ begin lint list maintained by maint/add_warning @@

#![allow(renamed_and_removed_lints)] // @@REMOVE_WHEN(ci_arti_stable)

#![allow(unknown_lints)] // @@REMOVE_WHEN(ci_arti_nightly)

#![warn(missing_docs)]

#![warn(noop_method_call)]

#![warn(unreachable_pub)]

#![warn(clippy::all)]

#![deny(clippy::await_holding_lock)]

#![deny(clippy::cargo_common_metadata)]

#![deny(clippy::cast_lossless)]

#![deny(clippy::checked_conversions)]

#![warn(clippy::cognitive_complexity)]

#![deny(clippy::debug_assert_with_mut_call)]

#![deny(clippy::exhaustive_enums)]

#![deny(clippy::exhaustive_structs)]

#![deny(clippy::expl_impl_clone_on_copy)]

#![deny(clippy::fallible_impl_from)]

#![deny(clippy::implicit_clone)]

#![deny(clippy::large_stack_arrays)]

#![warn(clippy::manual_ok_or)]

#![deny(clippy::missing_docs_in_private_items)]

#![warn(clippy::needless_borrow)]

#![warn(clippy::needless_pass_by_value)]

#![warn(clippy::option_option)]

#![deny(clippy::print_stderr)]

#![deny(clippy::print_stdout)]

#![warn(clippy::rc_buffer)]

#![deny(clippy::ref_option_ref)]

#![warn(clippy::semicolon_if_nothing_returned)]

#![warn(clippy::trait_duplication_in_bounds)]

#![deny(clippy::unchecked_time_subtraction)]

#![deny(clippy::unnecessary_wraps)]

#![warn(clippy::unseparated_literal_suffix)]

#![deny(clippy::unwrap_used)]

#![deny(clippy::mod_module_files)]

#![allow(clippy::let_unit_value)] // This can reasonably be done for explicitness

#![allow(clippy::uninlined_format_args)]

#![allow(clippy::significant_drop_in_scrutinee)] // arti/-/merge_requests/588/#note_2812945

#![allow(clippy::result_large_err)] // temporary workaround for arti#587

#![allow(clippy::needless_raw_string_hashes)] // complained-about code is fine, often best

#![allow(clippy::needless_lifetimes)] // See arti#1765

#![allow(mismatched_lifetime_syntaxes)] // temporary workaround for arti#2060

#![allow(clippy::collapsible_if)] // See arti#2342

#![deny(clippy::unused_async)]

//! <!-- @@ end lint list maintained by maint/add_warning @@ -->

// TODO #1645 (either remove this, or decide to have it everywhere)

#![cfg_attr(not(all(feature = "full")), allow(unused))]

pub mod auth;

#[cfg(feature = "rpc-client")]

pub mod client;

mod connpt;

pub mod load;

#[cfg(feature = "rpc-server")]

pub mod server;

#[cfg(test)]

mod testing;

use std::{io, sync::Arc};

pub use connpt::{ParsedConnectPoint, ResolveError, ResolvedConnectPoint};

use tor_general_addr::general;

/// An action that an RPC client should take when a connect point fails.

///

/// (This terminology is taken from the spec.)

#[derive(Clone, Copy, Debug, Eq, PartialEq)]

#[allow(clippy::exhaustive_enums)]

pub enum ClientErrorAction {

    /// The client must stop, and must not make any more connect attempts.

    Abort,

    /// The connect point has failed; the client can continue to the next connect point.

    Decline,

}

/// An error that has a [`ClientErrorAction`].

pub trait HasClientErrorAction {

    /// Return the action that an RPC client should take based on this error.

    fn client_action(&self) -> ClientErrorAction;

}

impl HasClientErrorAction for tor_config_path::CfgPathError {

        // Every variant of this means a configuration error

        // or an ill-formed TOML file.

}

impl HasClientErrorAction for tor_config_path::addr::CfgAddrError {

        use ClientErrorAction as A;

        use tor_config_path::addr::CfgAddrError as CAE;

            // No variants are currently captured in this pattern, but they _could_ be in the future.

        }

}

impl HasClientErrorAction for tor_general_addr::general::AddrParseError {

        use ClientErrorAction as A;

        use tor_general_addr::general::AddrParseError as E;

            // We might want to turn this into an Abort in the future, but I think that we might

            // want to allow "auto" as a port format in CfgAddr.

            // No variants are currently captured in this pattern, but they _could_ be in the future.

        }

}

/// Return the ClientErrorAction for an IO error encountered

/// while accessing the filesystem.

///

/// Note that this is not an implementation of `HasClientErrorAction`:

/// We want to decline on a different set of errors for network operation.

    use ClientErrorAction as A;

    use std::io::ErrorKind as EK;

    }

/// Return the ClientErrorAction for an IO error encountered

/// while opening a socket.

///

/// Note that this is not an implementation of `HasClientErrorAction`:

/// We want to decline on a different set of errors for fs operation.

    use ClientErrorAction as A;

    use std::io::ErrorKind as EK;

    }

impl HasClientErrorAction for fs_mistrust::Error {

        use ClientErrorAction as A;

        use fs_mistrust::Error as E;

                } else {

                }

            }

            // These should be impossible for clients given how we use fs_mistrust in this crate.

            E::CreatingDir(_)

            | E::Content(_)

            | E::NoSuchGroup(_)

            | E::NoSuchUser(_)

            | E::MissingField(_)

        }

}

/// A failure to connect or bind to a [`ResolvedConnectPoint`].

#[derive(Clone, Debug, thiserror::Error)]

#[non_exhaustive]

pub enum ConnectError {

    /// We encountered an IO error while actually opening our socket.

    #[error("IO error while connecting")]

    Io(#[source] Arc<io::Error>),

    /// The connect point told us to abort explicitly.

    #[error("Encountered an explicit \"abort\"")]

    ExplicitAbort,

    /// We couldn't load the cookie file for cookie authentication.

    #[error("Unable to load cookie file")]

    LoadCookie(#[from] auth::cookie::CookieAccessError),

    /// We were told to connect to a socket type that we don't support.

    #[error("Unsupported socket type")]

    UnsupportedSocketType,

    /// We were told to connect using an auth type that we don't support.

    #[error("Unsupported authentication type")]

    UnsupportedAuthType,

    /// Unable to access the location of an AF\_UNIX socket.

    #[error("Unix domain socket path access")]

    AfUnixSocketPathAccess(#[from] fs_mistrust::Error),

    /// Unable to access the location of `socket_address_file`.

    #[error("Problem accessing socket address file")]

    SocketAddressFileAccess(#[source] fs_mistrust::Error),

    /// We couldn't parse the JSON contents of a socket address file.

    #[error("Invalid JSON contents in socket address file")]

    SocketAddressFileJson(#[source] Arc<serde_json::Error>),

    /// We couldn't parse the address in a socket address file.

    #[error("Invalid address in socket address file")]

    SocketAddressFileContent(#[source] general::AddrParseError),

    /// We found an address in the socket address file that didn't match the connect point.

    #[error("Socket address file contents didn't match connect point")]

    SocketAddressFileMismatch,

    /// Another process was holding a lock for this connect point,

    /// so we couldn't bind to it.

    #[error("Could not acquire lock: Another process is listening on this connect point")]

    AlreadyLocked,

    /// We encountered an internal logic error.

    //

    // (We're not using tor_error::Bug here because we want this code to work properly in rpc-client-core.)

    #[error("Internal error: {0}")]

    Internal(String),

}

impl From<io::Error> for ConnectError {

}

impl crate::HasClientErrorAction for ConnectError {

        use crate::ClientErrorAction as A;

        use ConnectError as E;

        }

}

#[cfg(any(feature = "rpc-client", feature = "rpc-server"))]

/// Given a `general::SocketAddr`, try to return the path of its parent directory (if any).

/// Default connect point for a user-owned Arti instance.

pub const USER_DEFAULT_CONNECT_POINT: &str = {

    cfg_if::cfg_if! {

        if #[cfg(unix)] {

r#"

[connect]

socket = "unix:${ARTI_LOCAL_DATA}/rpc/arti_rpc_socket"

auth = "none"

"#

        } else {

r#"

[connect]

socket = "inet:127.0.0.1:9180"

auth = { cookie = { path = "${ARTI_LOCAL_DATA}/rpc/arti_rpc_cookie" } }

"#

        }

    }

};

/// Default connect point for a system-wide Arti instance.

///

/// This is `None` if, on this platform, there is no such default connect point.

pub const SYSTEM_DEFAULT_CONNECT_POINT: Option<&str> = {

    cfg_if::cfg_if! {

        if #[cfg(unix)] {

            Some(

r#"

[connect]

socket = "unix:/var/run/arti-rpc/arti_rpc_socket"

auth = "none"

"#

            )

        } else {

            None

        }

    }

};

/// An enum to reflect whether an authenticated connection to a connect point is allowed to acquire

/// superuser (admin) capabilities.

#[derive(Copy, Clone, Debug, PartialEq, Eq)]

#[non_exhaustive]

pub enum SuperuserPermission {

    /// The connection may acquire superuser capabilities.

    Allowed,

    /// The connection may not acquire superuser capabilities.

    NotAllowed,

}

#[cfg(test)]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_time_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    #[test]

    fn parse_defaults() {

        let _parsed: ParsedConnectPoint = USER_DEFAULT_CONNECT_POINT.parse().unwrap();

        if let Some(s) = SYSTEM_DEFAULT_CONNECT_POINT {

            let _parsed: ParsedConnectPoint = s.parse().unwrap();

        }

    }

}