fn create_runtime() -> std::io::Result<impl ToplevelRuntime> {

    ChosenRuntime::create()

}

fn list_enabled_features() -> &'static [&'static str] {

    // HACK(eta): We can't get this directly, so we just do this awful hack instead.

    // Note that we only list features that aren't about the runtime used, since that already

    // gets printed separately.

    &[

        #[cfg(feature = "journald")]

        "journald",

        #[cfg(any(feature = "static-sqlite", feature = "static"))]

        "static-sqlite",

        #[cfg(any(feature = "static-native-tls", feature = "static"))]

        "static-native-tls",

    ]

}

#[cfg_attr(feature = "experimental-api", visibility::make(pub))]

#[allow(clippy::cognitive_complexity)]

fn main_main<I, T>(cli_args: I) -> Result<()>

where

    I: IntoIterator<Item = T>,

    T: Into<std::ffi::OsString> + Clone,

{

    // We describe a default here, rather than using `default()`, because the

    // correct behavior is different depending on whether the filename is given

    // explicitly or not.

    let mut config_file_help = "Specify which config file(s) to read.".to_string();

    if let Ok(default) = default_config_files() {

        // If we couldn't resolve the default config file, then too bad.  If something

        // actually tries to use it, it will produce an error, but don't fail here

        // just for that reason.

        write!(config_file_help, " Defaults to {:?}", default).expect("Can't write to string");

    }

    let runtime = create_runtime()?;

    let features = list_enabled_features();

    let long_version = format!(

        "{}\nusing runtime: {:?}\noptional features: {}",

        env!("CARGO_PKG_VERSION"),

        runtime,

        if features.is_empty() {

            features.join(", ")

    let clap_app = Command::new("Arti")

            .version(env!("CARGO_PKG_VERSION"))

            .long_version(long_version)

            .author("The Tor Project Developers")

            .about("A Rust Tor implementation.")

            // HACK(eta): clap generates "arti [OPTIONS] <SUBCOMMAND>" for this usage string by

            //            default, but then fails to parse options properly if you do put them

            //            before the subcommand.

            //            We just declare all options as `global` and then require them to be

            //            put after the subcommand, hence this new usage string.

            .override_usage("arti <SUBCOMMAND> [OPTIONS]")

            .arg(

                Arg::new("config-files")

                    .short('c')

                    .long("config")

                    .action(ArgAction::Set)

                    .value_name("FILE")

                    .value_parser(value_parser!(OsString))

                    .action(ArgAction::Append)

                    // NOTE: don't forget the `global` flag on all arguments declared at this level!

                    .global(true)

                    .help(config_file_help),

            )

            .arg(

                Arg::new("option")

                    .short('o')

                    .action(ArgAction::Set)

                    .value_name("KEY=VALUE")

                    .action(ArgAction::Append)

                    .global(true)

                    .help("Override config file parameters, using TOML-like syntax."),

            )

            .arg(

                Arg::new("loglevel")

                    .short('l')

                    .long("log-level")

                    .global(true)

                    .action(ArgAction::Set)

                    .value_name("LEVEL")

                    .help("Override the log level (usually one of 'trace', 'debug', 'info', 'warn', 'error')."),

            )

            .arg(

                Arg::new("disable-fs-permission-checks")

                    .long("disable-fs-permission-checks")

                    .global(true)

                    .action(ArgAction::SetTrue)

                    .help("Don't check permissions on the files we use."),

            )

            .subcommand(

                Command::new("proxy")

                    .about(

                        "Run Arti in SOCKS proxy mode, proxying connections through the Tor network.",

                    )

                    .arg(

                        Arg::new("socks-port")

                            .short('p')

                            .action(ArgAction::Set)

                            .value_name("PORT")

                            .help("Port to listen on for SOCKS connections (overrides the port in the config if specified).")

                    )

                    .arg(

                        Arg::new("dns-port")

                            .short('d')

                            .action(ArgAction::Set)

                            .value_name("PORT")

                            .help("Port to listen on for DNS request (overrides the port in the config if specified).")

                    )

            )

            .subcommand_required(true)

            .arg_required_else_help(true);

    // When adding a subcommand, it may be necessary to add an entry in

    // `maint/check-cli-help`, to the function `help_arg`.

    cfg_if::cfg_if! {

        if #[cfg(feature = "onion-service-service")] {

            let clap_app = subcommands::hss::HssSubcommands::augment_subcommands(clap_app);

        }

    }

    cfg_if::cfg_if! {

        if #[cfg(feature = "hsc")] {

            let clap_app = subcommands::hsc::HscSubcommands::augment_subcommands(clap_app);

        }

    }

    // Tracing doesn't log anything when there is no subscriber set.  But we want to see

    // logging messages from config parsing etc.  We can't set the global default subscriber

    // because we can only set it once.  The other ways involve a closure.  So we have a

    // closure for all the startup code which runs *before* we set the logging properly.

    //

    // There is no cooked way to print our program name, so we do it like this.  This

    // closure is called to "make" a "Writer" for each message, so it runs at the right time:

    // before each message.

    let pre_config_logging_writer = || {

    let pre_config_logging = tracing_subscriber::fmt()

        .without_time()

        .with_writer(pre_config_logging_writer)

        .finish();

    let pre_config_logging = tracing::Dispatch::new(pre_config_logging);

    let pre_config_logging_ret = tracing::dispatcher::with_default(&pre_config_logging, || {

        let matches = clap_app.try_get_matches_from(cli_args)?;

        let fs_mistrust_disabled = matches.get_flag("disable-fs-permission-checks");

        let cfg_mistrust = if fs_mistrust_disabled {

            fs_mistrust::MistrustBuilder::default()

                .build_for_arti()

                .expect("Could not construct default fs-mistrust")

        let mut override_options: Vec<String> = matches

            .get_many::<String>("option")

            .unwrap_or_default()

            .cloned()

            .collect();

        if fs_mistrust_disabled {

        }

        let cfg_sources = {

            let mut cfg_sources = ConfigurationSources::try_from_cmdline(

                || default_config_files().context("identify default config file locations"),

                matches

                    .get_many::<OsString>("config-files")

                    .unwrap_or_default(),

                override_options,

            )?;

            cfg_sources.set_mistrust(cfg_mistrust);

            cfg_sources

        let cfg = cfg_sources.load()?;

        let (config, client_config) =

            tor_config::resolve::<ArtiCombinedConfig>(cfg).context("read configuration")?;

        let log_mistrust = client_config.fs_mistrust().clone();

        Ok::<_, Error>((matches, cfg_sources, config, client_config, log_mistrust))

    })?;

    let (matches, cfg_sources, config, client_config, log_mistrust) = pre_config_logging_ret;

    let _log_guards = logging::setup_logging(

        config.logging(),

        &log_mistrust,

        client_config.as_ref(),

        matches.get_one::<String>("loglevel").map(|s| s.as_str()),

    )?;

    if !config.application().allow_running_as_root {

    }

    if !config.application().permit_debugging {

        if let Err(e) = process::enable_process_hardening() {

        }

    if let Some(proxy_matches) = matches.subcommand_matches("proxy") {

    }

            if let Some(hss_matches) = matches.subcommand_matches("hss") {

                return subcommands::hss::run(hss_matches, &config, &client_config);

            }

            if let Some(hsc_matches) = matches.subcommand_matches("hsc") {

                return subcommands::hsc::run(runtime, hsc_matches, &client_config);

}

pub fn main() {

    match main_main(std::env::args_os()) {

        Ok(()) => {}

        Err(e) => {

            if let Some(hint) = e.hint() {

            }

            match e.downcast_ref::<clap::Error>() {

                Some(clap_err) => clap_err.exit(),

                None => with_safe_logging_suppressed(|| tor_error::report_and_exit(e)),

}