Add an isolate_client() function to create an isolated TorClient.

pub struct TorClient<R: Runtime> {

    /// Asynchronous runtime object.

    runtime: R,

    /// Default isolation token for streams through this client.

    client_isolation: IsolationToken,

    /// Circuit manager for keeping our circuits up to date and building

    /// them on-demand.

    circmgr: Arc<tor_circmgr::CircMgr<R>>,

}

/// Preferences for how to route a stream over the Tor network.

#[derive(Debug, Clone)]

#[derive(Debug, Clone, Default)]

pub struct ConnectPrefs {

    /// What kind of IPv6/IPv4 we'd prefer, and how strongly.

    ip_ver_pref: IpVersionPreference,

    /// Id of the isolation group the connection should be part of

    isolation_group: IsolationToken,

    isolation_group: Option<IsolationToken>,

}

impl ConnectPrefs {

    /// Indicate which other connections might use the same circuit

    /// as this one.

    pub fn set_isolation_group(&mut self, isolation_group: IsolationToken) -> &mut Self {

        self.isolation_group = isolation_group;

        self.isolation_group = Some(isolation_group);

        self

    }

    /// Return a u64 to describe which connections might use

    /// Return a token to describe which connections might use

    /// the same circuit as this one.

    fn isolation_group(&self) -> IsolationToken {

    fn isolation_group(&self) -> Option<IsolationToken> {

        self.isolation_group

    }

    // TODO: Add some way to be IPFlexible, and require exit to support both.

}

impl Default for ConnectPrefs {

    fn default() -> Self {

        ConnectPrefs {

            ip_ver_pref: Default::default(),

            isolation_group: IsolationToken::no_isolation(),

        }

    }

}

impl<R: Runtime> TorClient<R> {

    /// Bootstrap a network connection configured by `dir_cfg` and `circ_cfg`.

    ///

            Arc::downgrade(&dirmgr),

        ))?;

        let client_isolation = IsolationToken::new();

        Ok(TorClient {

            runtime,

            client_isolation,

            circmgr,

            dirmgr,

            addrcfg: addr_cfg,

        })

    }

    /// Return a new isolated `TorClient` instance.

    ///

    /// The two `TorClient`s will share some internal state, but their

    /// streams will haver share circuits with one another.

    ///

    /// Use this function when you want separate parts of your program to

    /// each have a TorClient handle, but where you don't want their

    /// activities to be linkable to one another over the Tor network.

    ///

    /// Calling this function is usually preferable to creating a

    /// completely separate TorClient instance, since it can share its

    /// internals with the existing `TorClient`.

    pub fn isolated_client(&self) -> TorClient<R> {

        let mut result = self.clone();

        result.client_isolation = IsolationToken::new();

        result

    }

    /// Launch an anonymized connection to the provided address and

    /// port over the Tor network.

    ///

        flags: &ConnectPrefs,

    ) -> Result<Arc<ClientCirc>> {

        let dir = self.dirmgr.netdir();

        // XXXX: this isn't what we really want.  We'd like to have _both_

        // of these tokens considered.

        let isolation = flags.isolation_group().unwrap_or(self.client_isolation);

        let circ = self

            .circmgr

            .get_or_launch_exit(dir.as_ref().into(), exit_ports, flags.isolation_group())

            .get_or_launch_exit(dir.as_ref().into(), exit_ports, isolation)

            .await

            .map_err(|_| Error::Internal("Unable to launch circuit"))?;

        drop(dir); // This decreases the refcount on the netdir.