//!

//! A "router descriptor" is a signed statement that a relay makes

//! about itself, explaining its keys, its capabilities, its location,

//! and its status.

//!

//! Relays upload their router descriptors to authorities, which use

//! them to build consensus documents.  Old clients and relays used to

//! fetch and use router descriptors for all the relays, but nowadays they use

//! microdescriptors instead.

//!

//! Clients still use router descriptors when communicating with

//! bridges: since bridges are not passed through an authority,

//! clients accept their descriptors directly.

//!

//! For full information about the router descriptor format, see

//! [dir-spec.txt](https://spec.torproject.org/dir-spec).

//!

//! # Limitations

//!

//! TODO: This needs to get tested much more!

//!

//! TODO: This implementation can be memory-inefficient.  In practice,

//! it gets really expensive storing policy entries, family

//! descriptions, parsed keys, and things like that.  We will probably want to

//! de-duplicate those.

//!

//! TODO: There should be accessor functions for some or all of the

//! fields in RouterDesc.  I'm deferring those until I know what they

//! should be.

//!

//! # Availability

//!

//! Most of this module is only available when this crate is built with the

//! `routerdesc` feature enabled.

use crate::parse::keyword::Keyword;

use crate::parse::parser::{Section, SectionRules};

use crate::parse::tokenize::{ItemResult, NetDocReader};

use crate::parse2::{ArgumentError, ArgumentStream, ItemArgumentParseable};

use crate::types::family::{RelayFamily, RelayFamilyId};

use crate::types::misc::*;

use crate::types::policy::*;

use crate::types::routerdesc::*;

use crate::types::version::TorVersion;

use crate::util::PeekableIterator;

use crate::{AllowAnnotations, Error, KeywordEncodable, NetdocErrorKind as EK, Result};

use derive_deftly::Deftly;

use ll::pk::ed25519::Ed25519Identity;

use std::sync::Arc;

use std::sync::LazyLock;

use std::{net, time};

use tor_cert::CertType;

use tor_checkable::{Timebound, signed, timed};

use tor_error::{internal, into_internal};

use tor_llcrypto as ll;

use tor_llcrypto::pk::rsa::RsaIdentity;

use digest::Digest;

/// Length of a router descriptor digest

pub const DOC_DIGEST_LEN: usize = 20;

/// The digest of a RouterDesc document, as reported in a NS consensus.

pub type RdDigest = [u8; DOC_DIGEST_LEN];

/// The digest of an ExtraInfo document, as reported in a RouterDesc.

pub type ExtraInfoDigest = [u8; DOC_DIGEST_LEN];

/// A router descriptor, with possible annotations.

#[non_exhaustive]

pub struct AnnotatedRouterDesc {

    /// Annotation for this router descriptor; possibly empty.

    pub ann: RouterAnnotation,

    /// Underlying router descriptor; signatures not checked yet.

    pub router: UncheckedRouterDesc,

}

/// Annotations about a router descriptor, as stored on disc.

#[derive(Default)]

#[non_exhaustive]

pub struct RouterAnnotation {

    /// Description of where we got this router descriptor

    pub source: Option<String>,

    /// When this descriptor was first downloaded.

    pub downloaded: Option<time::SystemTime>,

    /// Description of what we're willing to use this descriptor for.

    pub purpose: Option<String>,

}

/// Information about a relay, parsed from a router descriptor.

///

/// This type does not hold all the information in the router descriptor

///

/// # Limitations

///

/// See module documentation.

///

/// Additionally, some fields that from router descriptors are not yet

/// parsed: see the comments in ROUTER_BODY_RULES for information about those.

///

/// Before using this type to connect to a relay, you MUST check that

/// it is valid, using is_expired_at().

///

/// # Specification

///

/// <https://spec.torproject.org/dir-spec/server-descriptor-format.html>

#[derive(Clone, Debug)]

#[non_exhaustive]

pub struct RouterDesc {

    // === Virtual items ===

    // These items do not correspond to any actual item within the router

    // descriptor from a netdoc point of view.  They cannot persist this way

    // in parse2 and are already grouped together this way to indicate this

    // change.  For example, `family_ids` is computed on the fly and is not

    // present in normal router descriptors.  Although `orport`, `nickname`

    // and other members are present in a router descriptor, they are only

    // present as arguments, not as independent items.

    //

    //

    /// Human-readable nickname for this relay.

    ///

    /// This is not secure, and not guaranteed to be unique.

    pub nickname: Nickname,

    /// IPv4 address for this relay.

    pub ipv4addr: Option<net::Ipv4Addr>,

    /// IPv4 ORPort for this relay.

    pub orport: u16,

    /// Directory port for contacting this relay for direct HTTP

    /// directory downloads.

    pub dirport: u16,

    /// Declared (and proven) family IDs for this relay. If two relays

    /// share a family ID, they shouldn't be used in the same circuit.

    family_ids: Vec<RelayFamilyId>,

    // === Real items ===

    // These items are real and correspond to actual items found in router

    // descriptors, although potentially not under the same name.

    //

    //

    /// `identity-ed25519` --- Specify the router's ed25519 identity.

    ///

    /// * `identity-ed25519\n<certificate object>`

    /// * Exactly once, in second position in document.

    pub identity_ed25519: tor_cert::Ed25519Cert,

    /// `platform` --- Describe the platform on which this relay is running.

    ///

    /// * `platform <rest of line>`

    /// * At most once.

    pub platform: Option<RelayPlatform>,

    /// `published` --- Time this descriptor (and extra-info) was generated.

    ///

    /// * `published <date> <time>`

    /// * Exactly once.

    pub published: time::SystemTime,

    /// `fingerprint` --- Redundant hash of ASN-1 encoding of router identity key.

    ///

    /// * `fingerprint <spaced fingerprint>`

    /// * At most once.

    pub fingerprint: Option<SpFingerprint>,

    /// `uptime` --- How long this relay has been continously running

    ///

    /// * `uptime <number>`

    /// * At most once.

    pub uptime: Option<u64>,

    /// `onion-key` --- Relay's obsolete RSA tap key.

    ///

    /// * `onion-key\n<rsa public key>`

    /// * At most once.

    /// * No extra arguments.

    pub onion_key: Option<ll::pk::rsa::PublicKey>,

    /// `ntor-onion-key` --- The circuit extension key.

    ///

    /// * `ntor-onion-key <base64 padded key>`

    /// * Exactly once.

    pub ntor_onion_key: ll::pk::curve25519::PublicKey,

    /// `signing-key` --- Obsolete RSA identity key.

    ///

    /// * `signing-key\n<rsa public key>`

    pub signing_key: ll::pk::rsa::PublicKey,

    /// `accept, reject` --- Exit policy.

    ///

    /// * `accept exitpattern`

    /// * `reject exitpattern`

    /// * Any number of times.

    // TODO: these polices can get bulky too. Perhaps we should

    // de-duplicate them too.

    pub ipv4_policy: AddrPolicy,

    /// `ipv6-policy` --- Exit plicy summary for IPv6

    ///

    /// * `ipv6-policy <accept/reject> PortList`

    /// * At most once.

    pub ipv6_policy: Arc<PortPolicy>,

    /// `family` --- Group relays for the purpose of path selection.

    ///

    /// * `family <LongIdent> ...`

    /// * One or more `LongIdent` arguments.

    /// * At most once.

    pub family: Arc<RelayFamily>,

    /// `caches-extra-info` --- Router provides extra-info as a dirmirror.

    ///

    /// * `caches-extra-info`

    /// * At most once.

    /// * No extra arguments.

    pub caches_extra_info: bool,

    /// `or-address` --- Alternative ORport address and port

    ///

    /// * `or-address <address>:<port>`.

    /// * Any number of times.

    // TODO: we don't use a socketaddrv6 because we don't care about

    // the flow and scope fields.  We should decide whether that's a

    // good idea.

    pub or_address: Option<(net::Ipv6Addr, u16)>,

    /// `tunnelled-dir-server` --- Accepts a `BEGIN_DIR` relay message.

    ///

    /// * `tunnelled-dir-server`

    /// * At most once.

    /// * No extra arguments.

    pub tunnelled_dir_server: bool,

    /// `proto` --- Subprotocol capabilities supported.

    ///

    /// * `proto <entries>`

    /// * Exactly once.

    pub proto: tor_protover::Protocols,

}

/// Signatures of a [`RouterDesc`].

///

/// <https://spec.torproject.org/dir-spec/server-descriptor-format.html#item:router-sig-ed25519>

#[derive(Clone, Debug, Deftly)]

#[derive_deftly(NetdocParseableSignatures)]

#[deftly(netdoc(signatures(hashes_accu = "RouterHashAccu")))]

#[non_exhaustive]

pub struct RouterDescSignatures {

    /// `router-sig-ed25519` --- Ed25519 signature

    ///

    /// Ed25519 signature by the Ed25519 signing key on the SHA-256 digest of

    /// the document prefixed by a magic up until and including the

    /// `router-sig-ed25519` keyword plus space.

    pub router_sig_ed25519: RouterSigEd25519,

    /// `router-signature` --- RSA signature

    ///

    /// * At end, exactly once.

    /// * RSA signature of the document, including `router-sig-ed25519`.

    pub router_signature: RouterSignature,

}

/// Description of the software a relay is running.

// TODO: Move this to types/misc.rs.

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

#[non_exhaustive]

pub enum RelayPlatform {

    /// Software advertised to be some version of Tor, on some platform.

    Tor(TorVersion, String),

    /// Software not advertised to be Tor.

    Other(String),

}

impl std::str::FromStr for RelayPlatform {

    type Err = Error;

            }

        } else {

        }

}

impl ItemArgumentParseable for RelayPlatform {

}

decl_keyword! {

    /// RouterKwd is an instance of Keyword, used to denote the different

    /// Items that are recognized as appearing in a router descriptor.

    RouterKwd {

        annotation "@source" => ANN_SOURCE,

        annotation "@downloaded-at" => ANN_DOWNLOADED_AT,

        annotation "@purpose" => ANN_PURPOSE,

        "accept" | "reject" => POLICY,

        "bandwidth" => BANDWIDTH,

        "bridge-distribution-request" => BRIDGE_DISTRIBUTION_REQUEST,

        "caches-extra-info" => CACHES_EXTRA_INFO,

        "contact" => CONTACT,

        "extra-info-digest" => EXTRA_INFO_DIGEST,

        "family" => FAMILY,

        "family-cert" => FAMILY_CERT,

        "fingerprint" => FINGERPRINT,

        "hibernating" => HIBERNATING,

        "identity-ed25519" => IDENTITY_ED25519,

        "ipv6-policy" => IPV6_POLICY,

        "master-key-ed25519" => MASTER_KEY_ED25519,

        "ntor-onion-key" => NTOR_ONION_KEY,

        "ntor-onion-key-crosscert" => NTOR_ONION_KEY_CROSSCERT,

        "onion-key" => ONION_KEY,

        "onion-key-crosscert" => ONION_KEY_CROSSCERT,

        "or-address" => OR_ADDRESS,

        "platform" => PLATFORM,

        "proto" => PROTO,

        "published" => PUBLISHED,

        "router" => ROUTER,

        "router-sig-ed25519" => ROUTER_SIG_ED25519,

        "router-signature" => ROUTER_SIGNATURE,

        "signing-key" => SIGNING_KEY,

        "tunnelled_dir_server" => TUNNELLED_DIR_SERVER,

        "uptime" => UPTIME,

        // "protocols" once existed, but is obsolete

        // "eventdns" once existed, but is obsolete

        // "allow-single-hop-exits" is also obsolete.

    }

}

/// Rules for parsing a set of router descriptor annotations.

    use RouterKwd::*;

    // Unrecognized annotations are fine; anything else is an error in this

    // context.

/// Rules for tokens that are allowed in the first part of a

/// router descriptor.

    use RouterKwd::*;

    // No other intervening tokens are permitted in the header.

/// Rules for  tokens that are allowed in the first part of a

/// router descriptor.

    use RouterKwd::*;

    );

    // TODO: these aren't parsed yet.  Only authorities use them.

    // TODO: this is ignored for now.

/// Rules for items that appear at the end of a router descriptor.

    use RouterKwd::*;

    // No intervening tokens are allowed in the footer.

impl RouterAnnotation {

    /// Extract a single RouterAnnotation (possibly empty) from a reader.

        use RouterKwd::*;

}

/// A parsed router descriptor whose signatures and/or validity times

/// may or may not be invalid.

pub type UncheckedRouterDesc = signed::SignatureGated<timed::TimerangeBound<RouterDesc>>;

/// How long after its published time is a router descriptor officially

/// supposed to be usable?

const ROUTER_EXPIRY_SECONDS: u64 = 5 * 86400;

/// How long before its published time is a router descriptor usable?

// TODO(nickm): This valid doesn't match C tor, which only enforces this rule

// ("routers should not some from the future") at directory authorities, and

// there only enforces a 12-hour limit (`ROUTER_ALLOW_SKEW`).  Eventually we

// should probably harmonize these cutoffs.

const ROUTER_PRE_VALIDITY_SECONDS: u64 = 86400;

impl RouterDesc {

    /// Return a reference to this relay's RSA identity.

    /// Return a reference to this relay's Ed25519 identity.

    /// Return a reference to the list of subprotocol versions supported by this

    /// relay.

    /// Return a reference to this relay's Ntor onion key.

    /// Return the publication

    /// Return an iterator of every `SocketAddr` at which this descriptor says

    /// its relay can be reached.

    /// Return the declared family of this descriptor.

    /// Return the authenticated family IDs of this descriptor.

    /// Helper: tokenize `s`, and divide it into three validated sections.

        use RouterKwd::*;

        // Parse everything up through the header.

        // Parse everything up to but not including the signature.

        // Parse the signature.

    /// Try to parse `s` as a router descriptor.

    ///

    /// Does not actually check liveness or signatures; you need to do that

    /// yourself before you can do the output.

        // We permit empty lines at the end of router descriptors, since there's

        // a known issue in Tor relays that causes them to return them this way.

    /// Helper: parse a router descriptor from `s`.

    ///

    /// This function does the same as parse(), but returns errors based on

    /// byte-wise positions.  The parse() function converts such errors

    /// into line-and-byte positions.

        // TODO: This function is too long!  The little "paragraphs" here

        // that parse one item at a time should be made into sub-functions.

        use RouterKwd::*;

        // Unwrap should be safe because inline `required` call should return

        // `Error::MissingToken` if `ROUTER` is not `Ok`

        #[allow(clippy::unwrap_used)]

        // ed25519 identity and signing key.

            // Unwrap should be safe because above `required` call should

            // return `Error::MissingToken` if `IDENTITY_ED25519` is not `Ok`

            #[allow(clippy::unwrap_used)]

        };

        // master-key-ed25519: required, and should match certificate.

        #[allow(unexpected_cfgs)]

        {

                #[cfg(not(fuzzing))] // No feature here; never omit in production.

        }

        // Legacy RSA identity

        // Unwrap should be safe because above `required` calls should return

        // an `Error::MissingToken` if `ROUTER_...` is not `Ok`

        #[allow(clippy::unwrap_used)]

        #[allow(clippy::unwrap_used)]

        // Extract ed25519 signature.

        };

        // Extract legacy RSA signature.

            // TODO: we need to accept prefixes here. COMPAT BLOCKER.

        };

        // router nickname ipv4addr orport socksport dirport

            (

                // Skipping socksport.

            )

        };

        // uptime

        // published time.

        // ntor key

        // ntor crosscert

        };

        // TAP key

            Some(

            )

        } else {

        };

        // TAP crosscert

            ))

        } else {

        };

        // List of subprotocol versions

        };

        // tunneled-dir-server

        // caches-extra-info

        // fingerprint: check for consistency with RSA identity.

        // Family

        };

        // Family ids (for "happy families")

        // or-address

        // Extract at most one ipv6 address from the list.  It's not great,

        // but it's what Tor does.

            // We skip over unparsable addresses. Is that right?

        }

        // platform

        // ipv4_policy

                    _ => {

                    }

                };

            }

        };

        // ipv6 policy

            // Unwrap is safe here because str is not empty

            #[allow(clippy::unwrap_used)]

        };

        // Now we're going to collect signatures and expiration times.

        ];

        ];

                "Missing a public key that was previously there."

        }

        // Unwrap is safe here because `expirations` array is not empty

        #[allow(clippy::unwrap_used)]

}

/// An iterator that parses one or more (possibly annotated

/// router descriptors from a string.

//

// TODO: This is largely copy-pasted from MicrodescReader. Can/should they

// be merged?

pub struct RouterReader<'a> {

    /// True iff we accept annotations

    annotated: bool,

    /// Reader that we're extracting items from.

    reader: NetDocReader<'a, RouterKwd>,

}

/// Skip this reader forward until the next thing it reads looks like the

/// start of a router descriptor.

///

/// Used to recover from errors.

    use RouterKwd::*;

    loop {

            }

            None => {

            }

        }

    }

impl<'a> RouterReader<'a> {

    /// Construct a RouterReader to take router descriptors from a string.

    /// Extract an annotation from this reader.

        } else {

        }

    /// Extract an annotated router descriptor from this reader

    ///

    /// (internal helper; does not clean up on failures.)

    /// Extract an annotated router descriptor from this reader

    ///

    /// Ensure that at least one token is consumed

}

impl<'a> Iterator for RouterReader<'a> {

    type Item = Result<AnnotatedRouterDesc>;

        // Is there a next token? If not, we're done.

        Some(

        )

}

#[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::*;

    const TESTDATA: &str = include_str!("../../testdata/routerdesc1.txt");

    const TESTDATA2: &str = include_str!("../../testdata/routerdesc2.txt");

    // Generated with a patched C tor to include "happy family" IDs.

    const TESTDATA3: &str = include_str!("../../testdata/routerdesc3.txt");

    fn read_bad(fname: &str) -> String {

        use std::fs;

        use std::path::PathBuf;

        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));

        path.push("testdata");

        path.push("bad-routerdesc");

        path.push(fname);

        fs::read_to_string(path).unwrap()

    }

    #[test]

    fn parse_arbitrary() -> Result<()> {

        use std::str::FromStr;

        use tor_checkable::{SelfSigned, Timebound};

        let rd = RouterDesc::parse(TESTDATA)?

            .check_signature()?

            .dangerously_assume_timely();

        assert_eq!(rd.nickname.as_str(), "Akka");

        assert_eq!(rd.orport, 443);

        assert_eq!(rd.dirport, 0);

        assert_eq!(rd.uptime, Some(1036923));

        assert_eq!(

            rd.family.as_ref(),

            &RelayFamily::from_str(

                "$303509ab910ef207b7438c27435c4a2fd579f1b1 \

                 $56927e61b51e6f363fb55498150a6ddfcf7077f2"

            )

            .unwrap()

        );

        assert_eq!(

            rd.rsa_identity().to_string(),

            "$56927e61b51e6f363fb55498150a6ddfcf7077f2"

        );

        assert_eq!(

            rd.ed_identity().to_string(),

            "CVTjf1oeaL616hH+1+UvYZ8OgkwF3z7UMITvJzm5r7A"

        );

        assert_eq!(

            rd.protocols().to_string(),

            "Cons=1-2 Desc=1-2 DirCache=2 FlowCtrl=1-2 HSDir=2 \

             HSIntro=4-5 HSRend=1-2 Link=1-5 LinkAuth=1,3 Microdesc=1-2 \

             Padding=2 Relay=1-4"

        );

        assert_eq!(

            hex::encode(rd.ntor_onion_key().to_bytes()),

            "329b3b52991613392e35d1a821dd6753e1210458ecc3337f7b7d39bfcf5da273"

        );

        assert_eq!(

            rd.published(),

            humantime::parse_rfc3339("2022-11-14T19:58:52Z").unwrap()

        );

        assert_eq!(

            rd.or_ports().collect::<Vec<_>>(),

            vec![

                "95.216.33.58:443".parse().unwrap(),

                "[2a01:4f9:2a:2145::2]:443".parse().unwrap(),

            ]

        );

        assert!(rd.onion_key.is_some());

        Ok(())

    }

    #[test]

    fn parse_no_tap_key() -> Result<()> {

        use tor_checkable::{SelfSigned, Timebound};

        let rd = RouterDesc::parse(TESTDATA2)?

            .check_signature()?

            .dangerously_assume_timely();

        assert!(rd.onion_key.is_none());

        Ok(())

    }

    #[test]

    fn test_bad() {

        use crate::Pos;

        use crate::types::policy::PolicyError;

        fn check(fname: &str, e: &Error) {

            let text = read_bad(fname);

            let rd = RouterDesc::parse(&text);

            assert!(rd.is_err());

            assert_eq!(&rd.err().unwrap(), e);

        }

        check(

            "bad-sig-order",

            &EK::UnexpectedToken

                .with_msg("router-sig-ed25519")

                .at_pos(Pos::from_line(50, 1)),

        );

        check(

            "bad-start1",

            &EK::MisplacedToken

                .with_msg("identity-ed25519")

                .at_pos(Pos::from_line(1, 1)),

        );

        check("bad-start2", &EK::MissingToken.with_msg("identity-ed25519"));

        check(

            "mismatched-fp",

            &EK::BadArgument

                .at_pos(Pos::from_line(12, 1))

                .with_msg("fingerprint does not match RSA identity"),

        );

        check("no-ed-sk", &EK::MissingToken.with_msg("identity-ed25519"));

        check(

            "bad-cc-sign",

            &EK::BadArgument

                .at_pos(Pos::from_line(34, 26))

                .with_msg("not 0 or 1"),

        );

        check(

            "bad-ipv6policy",

            &EK::BadPolicy

                .at_pos(Pos::from_line(43, 1))

                .with_source(PolicyError::InvalidPolicy),

        );

        check(

            "no-ed-id-key-in-cert",

            &EK::BadObjectVal

                .at_pos(Pos::from_line(2, 1))

                .with_source(tor_cert::CertError::MissingPubKey),

        );

        check(

            "non-ed-sk-in-cert",

            &EK::BadObjectVal

                .at_pos(Pos::from_line(2, 1))

                .with_msg("wrong type for signing key in cert"),

        );

        check(

            "bad-ed-sk-in-cert",

            &EK::BadObjectVal

                .at_pos(Pos::from_line(2, 1))

                .with_msg("invalid ed25519 signing key"),

        );

        check(

            "mismatched-ed-sk-in-cert",

            &EK::BadObjectVal

                .at_pos(Pos::from_line(8, 1))

                .with_msg("master-key-ed25519 does not match key in identity-ed25519"),

        );

    }

    #[test]

    fn parse_multiple_annotated() {

        use crate::AllowAnnotations;

        let mut s = read_bad("bad-cc-sign");

        s += "\

@uploaded-at 2020-09-26 18:15:41

@source \"127.0.0.1\"

";

        s += TESTDATA;

        s += "\

@uploaded-at 2020-09-26 18:15:41

@source \"127.0.0.1\"

";

        s += &read_bad("mismatched-fp");

        let rd = RouterReader::new(&s, &AllowAnnotations::AnnotationsAllowed).unwrap();

        let v: Vec<_> = rd.collect();

        assert!(v[0].is_err());

        assert!(v[1].is_ok());

        assert_eq!(

            v[1].as_ref().unwrap().ann.source,

            Some("\"127.0.0.1\"".to_string())

        );

        assert!(v[2].is_err());

    }

    #[test]

    fn test_platform() {

        let p = "Tor 0.4.4.4-alpha on a flying bison".parse::<RelayPlatform>();

        assert!(p.is_ok());

        assert_eq!(

            p.unwrap(),

            RelayPlatform::Tor(

                "0.4.4.4-alpha".parse().unwrap(),

                "a flying bison".to_string()

            )

        );

        let p = "Tor 0.4.4.4-alpha on".parse::<RelayPlatform>();

        assert!(p.is_ok());

        let p = "Tor 0.4.4.4-alpha ".parse::<RelayPlatform>();

        assert!(p.is_ok());

        let p = "Tor 0.4.4.4-alpha".parse::<RelayPlatform>();

        assert!(p.is_ok());

        let p = "arti 0.0.0".parse::<RelayPlatform>();

        assert!(p.is_ok());

        assert_eq!(p.unwrap(), RelayPlatform::Other("arti 0.0.0".to_string()));

    }

    #[test]

    fn test_family_ids() -> Result<()> {

        use tor_checkable::{SelfSigned, Timebound};

        let rd = RouterDesc::parse(TESTDATA3)?

            .check_signature()?

            .dangerously_assume_timely();

        assert_eq!(

            rd.family_ids(),

            &[

                "ed25519:7sToQRuge1bU2hS0CG0ViMndc4m82JhO4B4kdrQey80"

                    .parse()

                    .unwrap(),

                "ed25519:szHUS3ItRd9uk85b1UVnOZx1gg4B0266jCpbuIMNjcM"

                    .parse()

                    .unwrap(),

            ]

        );

        Ok(())

    }

}