checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"

[[package]]

name = "base64"

version = "0.13.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"

dependencies = [

 "generic-array",

]

]

[[package]]

name = "bloomy"

version = "1.2.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "cec318a675afcb6a1ea1d4340e2d377e56e47c266f28043ceccbf4412ddfdd3b"

[[package]]

name = "core-foundation-sys"

version = "0.8.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "ct-codecs"

version = "1.1.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]

name = "cyphernet"

version = "0.1.0"

dependencies = [

 "amplify",

 "multibase",

 "socks",

]

[[package]]

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"

dependencies = [

 "proc-macro2",

 "quote",

 "syn",

]

checksum = "6a3d382e8464107391c8706b4c14b087808ecb909f6c15c34114bc42e53a9e4c"

dependencies = [

 "ct-codecs",

 "getrandom 0.2.8",

]

 "regex",

 "serde",

 "serde_json",

 "thiserror",

 "uint",

]

[[package]]

name = "hmac"

version = "0.12.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"

 "ecdsa",

 "elliptic-curve",

 "sha2 0.10.6",

]

[[package]]

]

[[package]]

dependencies = [

 "libc",

 "socket2",

]

checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"

[[package]]

name = "popol"

dependencies = [

 "libc",

]

name = "radicle-node"

version = "0.2.0"

dependencies = [

 "anyhow",

 "bloomy",

 "byteorder",

 "chrono",

 "colored",

 "crossbeam-channel",

 "fastrand",

 "git-ref-format 0.1.0 (git+https://github.com/radicle-dev/radicle-git?rev=39ce2f934915a563f9420ac9c85480df8a591481)",

 "lexopt",

 "log",

 "nakamoto-net",

 "nonempty 0.8.1",

 "qcheck",

 "qcheck-macros",

 "radicle",

checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb"

dependencies = [

 "crypto-bigint",

 "zeroize",

]

checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"

[[package]]

name = "rustix"

version = "0.36.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9f9e24d2b632954ded8ab2ef9fea0a0c769ea56ea98bddbafbad22caeeadf45d"

dependencies = [

 "pbkdf2",

 "salsa20",

 "sha2 0.10.6",

]

[[package]]

name = "serde"

version = "1.0.149"

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]

name = "sha3"

version = "0.10.6"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9"

 "iri-string",

 "k256",

 "rand 0.8.5",

 "thiserror",

 "time 0.3.17",

]

]

[[package]]

name = "tower"

version = "0.4.13"

source = "registry+https://github.com/rust-lang/crates.io-index"

rev = "90cc3eac67aa5cfd5f42cf7cb1e2b155af3214fb"

version = "0.3.0"

[patch.crates-io.cyphernet]

git = "https://github.com/cyphernet-wg/rust-cyphernet"

version = "0.1.0"

[patch.crates-io.radicle-git-ext]

git = "https://github.com/radicle-dev/radicle-git"

rev = "d3115a22158c8395705babefdc89049f7510d32d"

pub use ed25519::{Error, KeyPair, Seed};

pub mod hash;

#[cfg(feature = "ssh")]

pub mod ssh;

/// Verified (used as type witness).

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

/// Output of a Diffie-Hellman key exchange.

pub type SharedSecret = [u8; 32];

/// Error returned if signing fails, eg. due to an HSM or KMS.

#[derive(Debug, Error)]

#[error(transparent)]

    }

}

/// Cryptographic signature.

#[derive(PartialEq, Eq, Hash, Copy, Clone, Serialize, Deserialize)]

#[serde(into = "String", try_from = "String")]

    }

}

/// The private/signing key.

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

pub struct SecretKey(ed25519::SecretKey);

use thiserror::Error;

use zeroize::Zeroizing;

/// A secret key passphrase.

pub type Passphrase = Zeroizing<String>;

/// so that signing never fails.

///

/// Can be created from a [`Keystore`] with the [`MemorySigner::load`] function.

pub struct MemorySigner {

    public: PublicKey,

    secret: Zeroizing<SecretKey>,

    }

}

    fn ecdh(&self, other: &PublicKey) -> Result<SharedSecret, ed25519_compact::Error> {

        let pk = ed25519_compact::x25519::PublicKey::from_ed25519(other)?;

        let sk = ed25519_compact::x25519::SecretKey::from_ed25519(&self.secret)?;

test = ["radicle/test", "radicle-crypto/test", "qcheck"]

[dependencies]

anyhow = { version = "1" }

bloomy = { version = "1.2" }

byteorder = { version = "1" }

chrono = { version = "0.4.0" }

colored = { version = "1.9.0" }

crossbeam-channel = { version = "0.5.6" }

fastrand = { version = "1.8.0" }

git-ref-format = { version = "0", features = ["serde", "macro"] }

lexopt = { version = "0.2.1" }

log = { version = "0.4.17", features = ["std"] }

nakamoto-net = { version = "0.3.0" }

nonempty = { version = "0.8.1", features = ["serialize"] }

qcheck = { version = "1", default-features = false, optional = true }

sqlite = { version = "0.30.3" }

sqlite3-src = { version = "0.4.0", features = ["bundled"] } # Ensures static linking

use crate::prelude::Address;

use crate::service::NodeId;

use crate::sql::transaction;

#[derive(Error, Debug)]

pub enum Error {

use thiserror::Error;

use crate::service::{routing, tracking};

pub mod handle;

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

    Net(#[from] nakamoto_net::error::Error),

}

use std::sync::Arc;

use crossbeam_channel as chan;

use thiserror::Error;

use crate::identity::Id;

    }

}

}

    fn command(&self, cmd: service::Command) -> Result<(), Error> {

        Ok(())

    }

}

    type Session = Session;

    type FetchLookup = FetchLookup;

    type Error = Error;

    fn fetch(&mut self, id: Id) -> Result<Self::FetchLookup, Error> {

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

    fn track_node(&mut self, id: NodeId, alias: Option<String>) -> Result<bool, Error> {

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

    fn untrack_node(&mut self, id: NodeId) -> Result<bool, Error> {

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

    fn track_repo(&mut self, id: Id) -> Result<bool, Error> {

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

    fn untrack_repo(&mut self, id: Id) -> Result<bool, Error> {

        let (sender, receiver) = chan::bounded(1);

        receiver.recv().map_err(Error::from)

    }

    }

    fn shutdown(self) -> Result<(), Error> {

    }

}

pub mod address;

pub mod bounded;

pub mod client;

use std::{env, net, process, thread};

use anyhow::Context as _;

use radicle::profile;

use radicle_node::crypto::ssh::keystore::MemorySigner;

#[derive(Debug)]

struct Options {

    external_addresses: Vec<Address>,

    limits: service::config::Limits,

    listen: Vec<net::SocketAddr>,

}

        while let Some(arg) = parser.next()? {

            match arg {

                Long("connect") => {

                }

                Long("external-address") => {

                    let addr = parser.value()?.parse()?;

    let options = Options::from_env()?;

    let profile = radicle::Profile::load().context("Failed to load node profile")?;

    let node = profile.node();

    };

    Ok(())

}

/// Default radicle protocol port.

pub const DEFAULT_PORT: u16 = 8776;

/// Target number of peers to maintain connections to.

pub const TARGET_OUTBOUND_PEERS: usize = 8;

/// How often to run the "idle" task.

pub enum FetchLookup {

    /// Found seeds for the given project.

    Found {

        results: chan::Receiver<FetchResult>,

    },

    /// Can't fetch because no seeds were found for this project.

pub enum FetchResult {

    /// Successful fetch from a seed.

    Fetched {

        updated: Vec<RefUpdate>,

    },

    /// Error fetching the resource from a seed.

}

/// Function used to query internal service state.

    /// Announce repository references for given project id to peers.

    AnnounceRefs(Id),

    /// Connect to node with the given address.

    /// Fetch the given project from the network.

    Fetch(Id, chan::Sender<FetchLookup>),

    /// Track the given project.

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Self::AnnounceRefs(id) => write!(f, "AnnounceRefs({})", id),

            Self::Fetch(id, _) => write!(f, "Fetch({})", id),

            Self::TrackRepo(id, _) => write!(f, "TrackRepo({})", id),

            Self::UntrackRepo(id, _) => write!(f, "UntrackRepo({})", id),

        // Connect to configured peers.

        let addrs = self.config.connect.clone();

        }

    }

        debug!("Command {:?}", cmd);

        match cmd {

            Command::Fetch(id, resp) => {

                if !self

                    .tracking

                let (results_, results) = chan::bounded(seeds.len());

                resp.send(FetchLookup::Found {

                    results,

                })

                .ok();

                        Ok(updated) => {

                            results_

                                .send(FetchResult::Fetched {

                                    updated,

                                })

                                .ok();

                        Err(err) => {

                            results_

                                .send(FetchResult::Error {

                                    error: err.into(),

                                })

                                .ok();

        }

    }

        let peer = self

            .sessions

        peer.attempted();

    }

        // For outbound connections, we are the first to say "Hello".

        // For inbound connections, we wait for the remote to say "Hello" first.

        // TODO: How should we deal with multiple peers connecting from the same IP address?

        if link.is_outbound() {

                if link.is_outbound() {

                    self.reactor.write_all(

                        gossip::handshake(

                            self.clock.as_secs(),

                            &self.storage,

            }

        } else {

            self.sessions.insert(

                Session::new(

                    Link::Inbound,

                    self.rng.clone(),

                ),

            );

    pub fn disconnected(

        &mut self,

        reason: &nakamoto::DisconnectReason<DisconnectReason>,

    ) {

        let since = self.local_time();

            session.state = session::State::Disconnected { since };

            // Attempt to re-connect to persistent peers.

                        return;

                    }

            } else {

                self.maintain_connections();

            }

        }

    }

            }

            Err(err) => {

                // If there's an error, stop processing messages from this peer.

                // However, we still relay messages returned up to this point.

                // FIXME: The peer should be set in a state such that we don'that

                // process further messages.

    pub fn handle_message(

        &mut self,

        message: Message,

    ) -> Result<(), session::Error> {

        let Some(peer) = self.sessions.get_mut(remote) else {

        };

        peer.last_active = self.clock;

        match (&mut peer.state, message) {

                // Nb. This is a very primitive handshake. Eventually we should have anyhow

                // extra "acknowledgment" message sent when the `Initialize` is well received.

                if peer.link.is_inbound() {

                    self.reactor.write_all(

                        gossip::handshake(

                            self.clock.as_secs(),

                            &self.storage,

                // set after the first message is received only. Setting it here would

                // mean that messages received right after the handshake could be ignored.

                peer.state = session::State::Negotiated {

                    since: self.clock,

                    ping: Default::default(),

                };

            }

            (session::State::Initial, _) => {

                debug!(

                    "Disconnecting peer {} for sending us a message before handshake",

                );

                return Err(session::Error::Misbehavior);

            }

                    let relay_to = self

                        .sessions

                        .negotiated()

                    return Ok(());

                }

                    .gossip

                    .filtered(&subscribe.filter, subscribe.since, subscribe.until)

                {

                }

                peer.subscribe = Some(subscribe);

            }

            (session::State::Negotiated { .. }, Message::Initialize { .. }) => {

                debug!(

                    "Disconnecting peer {} for sending us a redundant handshake message",

                );

                return Err(session::Error::Misbehavior);

            }

                    return Ok(());

                }

                self.reactor.write(

                    Message::Pong {

                        zeroes: ZeroBytes::new(ponglen),

                    },

                }

            }

            (session::State::Disconnected { .. }, msg) => {

            }

        }

        Ok(())

        let node = self.node_id();

        let repo = self.storage.repository(id)?;

        let remote = repo.remote(&node)?;

        let timestamp = self.clock.as_secs();

        if remote.refs.len() > Refs::max() {

            );

        }

        let refs = BoundedVec::collect_from(&mut remote.refs.iter().map(|(a, b)| (a.clone(), *b)));

        let msg = AnnouncementMessage::from(RefsAnnouncement {

            id,

            refs,

            &self.signer,

        );

        }

        Ok(())

    }

        let stale = self

            .sessions

            .negotiated()

        }

    }

        }

    }

        let mut negotiated: HashMap<NodeId, &Session> = HashMap::new();

        for s in self.sessions.values() {

            if !s.link.is_outbound() {

                continue;

            }

            match s.state {

                session::State::Initial => {

                }

                session::State::Negotiated { id, .. } => {

                    negotiated.insert(id, s);

        self.addresses

            .entries()

            .unwrap()

            })

            .take(wanted)

            .collect()

    }

        if addrs.is_empty() {

            debug!("No eligible peers available to connect to");

        }

        }

    }

}

#[derive(Debug)]

pub enum DisconnectReason {

    User,

    Error(session::Error),

}

    fn is_transient(&self) -> bool {

        match self {

            Self::User => false,

            Self::Error(..) => false,

        }

    }

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Self::User => write!(f, "user"),

            Self::Error(err) => write!(f, "error: {}", err),

        }

    }

#[derive(Debug)]

/// Holds currently (or recently) connected peers.

impl Sessions {

    pub fn new(rng: Rng) -> Self {

    }

    /// Iterator over fully negotiated peers.

        self.0

            .iter()

                _ => None,

            })

    }

    /// Iterator over mutable fully negotiated peers.

        self.0.iter_mut().filter(move |(_, p)| p.is_negotiated())

    }

}

impl Deref for Sessions {

    fn deref(&self) -> &Self::Target {

        &self.0

        };

        let mut msgs = vec![

            Message::inventory(gossip::inventory(timestamp, inventory), signer),

            Message::subscribe(filter, timestamp, Timestamp::MAX),

        ];

use super::nakamoto::LocalDuration;

use crate::service::message::Address;

/// Peer-to-peer network.

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

pub struct Config {

    /// Peers to connect to on startup.

    /// Connections to these peers will be maintained.

    /// Specify the node's public addresses

    pub external_addresses: Vec<Address>,

    /// Peer-to-peer network.

    fn default() -> Self {

        Self {

            connect: Vec::default(),

            network: Network::default(),

            relay: true,

            listen: vec![],

        }

    }

    }

    pub fn alias(&self) -> [u8; 32] {

use crate::crypto;

use crate::git;

use crate::node;

use crate::prelude::BoundedVec;

use crate::service::filter::Filter;

use crate::wire;

/// Maximum number of addresses which can be announced to other nodes.

}

/// Peer public protocol address.

    }

}

    }

}

    }

}

#[derive(Clone, PartialEq, Eq)]

pub enum Message {

    /// The first message sent to a peer after connection.

    /// Subscribe to gossip messages matching the filter and time range.

    Subscribe(Subscribe),

}

impl Message {

    }

    pub fn announcement(

impl fmt::Debug for Message {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Self::Subscribe(Subscribe { since, until, .. }) => {

                write!(f, "Subscribe({}..{})", since, until)

            }

use std::collections::VecDeque;

use log::*;

#[derive(Debug)]

pub enum Io {

    /// There are some messages ready to be sent to a peer.