added INR backup bootstrap and made the TLD lookup follow the same pattern

Author: anewton1998

icann-rdap-cli/src/bootstrap.rs

@@ -39,9 +39,6 @@ pub(crate) enum BootstrapType {
     /// bootstrap registries in the following order: object tags, TLDs, IP addresses,
     /// ASNs.
     Hint(String),
-
-    /// Use IANA.
-    Iana,
 }
 
 pub(crate) async fn get_base_url(
@@ -114,7 +111,6 @@ pub(crate) async fn get_base_url(
                 }
             }
         }
-        BootstrapType::Iana => Ok("https://rdap.iana.org".to_string()),
     }
 }
 

icann-rdap-cli/src/main.rs

@@ -1,12 +1,13 @@
 use bootstrap::BootstrapType;
 use clap::builder::styling::AnsiColor;
 use clap::builder::Styles;
-use icann_rdap_common::check::string::StringCheck;
 use icann_rdap_common::check::CheckClass;
 use icann_rdap_common::client::create_client;
 use icann_rdap_common::client::ClientConfig;
+use query::InrBackupBootstrap;
 use query::ProcessType;
 use query::ProcessingParams;
+use query::TldLookup;
 use std::io::IsTerminal;
 use std::str::FromStr;
 use tracing::error;
@@ -110,17 +111,30 @@ struct Cli {
     #[arg(short = 'B', long, required = false, env = "RDAP_BASE_URL")]
     base_url: Option<String>,
 
-    /// Default to IANA for TLD lookups.
+    /// Specify where to send TLD queries.
     ///
-    /// When querying for TLDs, use IANA as the authoritative server.
+    /// Defaults to IANA.
     #[arg(
         long,
         required = false,
         env = "RDAP_TLD_LOOKUP",
         value_enum,
-        default_value_t = TldLookup::Iana,
+        default_value_t = TldLookupArg::Iana,
     )]
-    tld_lookup: TldLookup,
+    tld_lookup: TldLookupArg,
+
+    /// Specify a backup INR bootstrap.
+    ///
+    /// This is used as a backup when the bootstrapping process cannot find an authoritative
+    /// server for IP addresses and Autonomous System Numbers. Defaults to ARIN.
+    #[arg(
+        long,
+        required = false,
+        env = "RDAP_INR_BACKUP_BOOTSTRAP",
+        value_enum,
+        default_value_t = InrBackupBootstrapArg::Arin,
+    )]
+    inr_backup_bootstrap: InrBackupBootstrapArg,
 
     /// Output format.
     ///
@@ -388,14 +402,23 @@ enum PagerType {
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
-enum TldLookup {
+enum TldLookupArg {
     /// Use IANA for TLD lookups.
     Iana,
 
     /// No TLD specific lookups.
     None,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+enum InrBackupBootstrapArg {
+    /// Use ARIN when no INR bootstrap can be found.
+    Arin,
+
+    /// No backup for INR bootstraps.
+    None,
+}
+
 impl From<&LogLevel> for LevelFilter {
     fn from(log_level: &LogLevel) -> Self {
         match log_level {
@@ -431,24 +454,7 @@ pub async fn wrapped_main() -> Result<(), CliError> {
 
     let level = LevelFilter::from(&cli.log_level);
 
-    let mut bootstrap_type = if let Some(ref tag) = cli.base {
-        BootstrapType::Hint(tag.to_string())
-    } else if let Some(ref base_url) = cli.base_url {
-        BootstrapType::Url(base_url.to_string())
-    } else {
-        BootstrapType::Rfc9224
-    };
-
-    let mut query_type = query_type_from_cli(&cli);
-    // if using IANA for tld queries, adjust the domain name to not start with '.'
-    if let TldLookup::Iana = cli.tld_lookup {
-        if let QueryType::Domain(ref domain) = query_type {
-            if domain.is_tld() {
-                query_type = QueryType::Domain(domain.trim_start_matches('.').to_string());
-                bootstrap_type = BootstrapType::Iana;
-            }
-        }
-    }
+    let query_type = query_type_from_cli(&cli);
 
     let use_pager = match cli.page_output {
         PagerType::Embedded => true,
@@ -499,11 +505,31 @@ pub async fn wrapped_main() -> Result<(), CliError> {
             .collect::<Vec<CheckClass>>()
     };
 
+    let bootstrap_type = if let Some(ref tag) = cli.base {
+        BootstrapType::Hint(tag.to_string())
+    } else if let Some(ref base_url) = cli.base_url {
+        BootstrapType::Url(base_url.to_string())
+    } else {
+        BootstrapType::Rfc9224
+    };
+
+    let tld_lookup = match cli.tld_lookup {
+        TldLookupArg::Iana => TldLookup::Iana,
+        TldLookupArg::None => TldLookup::None,
+    };
+
+    let inr_backup_bootstrap = match cli.inr_backup_bootstrap {
+        InrBackupBootstrapArg::Arin => InrBackupBootstrap::Arin,
+        InrBackupBootstrapArg::None => InrBackupBootstrap::None,
+    };
+
     let processing_params = ProcessingParams {
         bootstrap_type,
         output_type,
         check_types,
         process_type,
+        tld_lookup,
+        inr_backup_bootstrap,
         error_on_checks: cli.error_on_checks,
         no_cache: cli.no_cache,
         max_cache_age: cli.max_cache_age,

icann-rdap-cli/src/query.rs

@@ -1,3 +1,4 @@
+use icann_rdap_common::check::string::StringCheck;
 use icann_rdap_common::check::traverse_checks;
 use icann_rdap_common::check::CheckClass;
 use icann_rdap_common::check::CheckParams;
@@ -55,11 +56,33 @@ pub(crate) enum ProcessType {
     Registry,
 }
 
+/// Used for doing TLD Lookups.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum TldLookup {
+    /// Use IANA for TLD lookups.
+    Iana,
+
+    /// No TLD specific lookups.
+    None,
+}
+
+/// Used for doing TLD Lookups.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum InrBackupBootstrap {
+    /// Use ARIN if no bootstraps can be found for INR queries.
+    Arin,
+
+    /// No INR bootstrap backup.
+    None,
+}
+
 pub(crate) struct ProcessingParams {
     pub bootstrap_type: BootstrapType,
     pub output_type: OutputType,
     pub check_types: Vec<CheckClass>,
     pub process_type: ProcessType,
+    pub tld_lookup: TldLookup,
+    pub inr_backup_bootstrap: InrBackupBootstrap,
     pub error_on_checks: bool,
     pub no_cache: bool,
     pub max_cache_age: u32,
@@ -93,7 +116,26 @@ async fn do_domain_query<'a, W: std::io::Write>(
     write: &mut W,
 ) -> Result<(), CliError> {
     let mut transactions = RequestResponses::new();
-    let base_url = get_base_url(&processing_params.bootstrap_type, client, query_type).await?;
+
+    // special processing for TLD Lookups
+    let temp_query_type;
+    let (base_url, query_type) = if let QueryType::Domain(ref domain) = query_type {
+        if domain.is_tld() && matches!(processing_params.tld_lookup, TldLookup::Iana) {
+            temp_query_type = QueryType::Domain(domain.trim_start_matches('.').to_string());
+            ("https://rdap.iana.org".to_string(), &temp_query_type)
+        } else {
+            (
+                get_base_url(&processing_params.bootstrap_type, client, query_type).await?,
+                query_type,
+            )
+        }
+    } else {
+        (
+            get_base_url(&processing_params.bootstrap_type, client, query_type).await?,
+            query_type,
+        )
+    };
+
     let response = do_request(&base_url, query_type, processing_params, client).await;
     let registrar_response;
     match response {
@@ -183,8 +225,16 @@ async fn do_inr_query<'a, W: std::io::Write>(
     write: &mut W,
 ) -> Result<(), CliError> {
     let mut transactions = RequestResponses::new();
-    let base_url = get_base_url(&processing_params.bootstrap_type, client, query_type).await?;
-    let response = do_request(&base_url, query_type, processing_params, client).await;
+    let mut base_url = get_base_url(&processing_params.bootstrap_type, client, query_type).await;
+    if base_url.is_err()
+        && matches!(
+            processing_params.inr_backup_bootstrap,
+            InrBackupBootstrap::Arin
+        )
+    {
+        base_url = Ok("https://rdap.arin.net/registry".to_string());
+    };
+    let response = do_request(&base_url?, query_type, processing_params, client).await;
     match response {
         Ok(response) => {
             let source_host = response.http_data.host.to_owned();

icann-rdap-cli/src/rdap.env

@@ -21,6 +21,9 @@
 # Where to lookup TLDs
 #RDAP_TLD_LOOKUP=iana
 
+# Which base URL to use if no IP address or autnum bootstrap can be found.
+#RDAP_INR_BACKUP_BOOTSTRAP=arin
+
 # Do not use cache.
 #RDAP_NO_CACHE=true