use crate::addr::{addr_peer, one_circuit_per_relay, parse_addrs, shareable};
use crate::exchange::{Answer, Derived, Offer, Token};
use crate::{Keypair, Message, Multiaddr, NetError, Node, PeerId, Profile, now_ms, short_peer_id};
use libp2p::multiaddr::Protocol;
use serde::Serialize;
use serde_json::{Value, json};
use zeroize::Zeroizing;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Status {
Offered,
Incoming,
Complete,
Verified,
Revoked,
}
impl Status {
pub fn as_str(self) -> &'static str {
match self {
Status::Offered => "offered",
Status::Incoming => "incoming",
Status::Complete => "complete",
Status::Verified => "verified",
Status::Revoked => "revoked",
}
}
pub fn active(self) -> bool {
matches!(self, Status::Complete | Status::Verified)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Role {
Offerer,
Answerer,
}
impl Role {
pub fn as_str(self) -> &'static str {
match self {
Role::Offerer => "offerer",
Role::Answerer => "answerer",
}
}
}
pub trait Rec: Clone {
fn id(&self) -> &str;
fn role(&self) -> Role;
fn status(&self) -> Status;
fn peer_id(&self) -> Option<&str>;
fn label(&self) -> &str;
fn peer_label(&self) -> &str;
fn scope(&self) -> &Value;
fn offer(&self) -> &str;
fn answer(&self) -> Option<&str>;
fn expires_at(&self) -> Option<i64>;
fn revoked_by(&self) -> Option<&str>;
fn fingerprint(&self) -> Option<&str>;
fn title(&self) -> String;
fn purpose(&self) -> String {
crate::profile::scope_kind(self.scope()).to_string()
}
}
pub struct NewRec<'a> {
pub id: &'a str,
pub label: &'a str,
pub role: Role,
pub status: Status,
pub peer_id: &'a str,
pub peer_label: &'a str,
pub scope: &'a Value,
pub offer: &'a str,
pub expires_at: i64,
}
pub trait Host {
type Error: From<NetError> + std::fmt::Display;
type Rec: Rec;
fn records(&self) -> Result<Vec<Self::Rec>, Self::Error>;
fn get(&self, id: &str) -> Result<Option<Self::Rec>, Self::Error>;
fn insert(&self, n: &NewRec, secret: Option<&[u8]>) -> Result<Self::Rec, Self::Error>;
fn complete(&self, id: &str, peer: &str, peer_label: &str, answer: &str, d: &Derived) -> Result<Self::Rec, Self::Error>;
fn secret(&self, id: &str) -> Result<Option<Zeroizing<Vec<u8>>>, Self::Error>;
fn set_status(&self, id: &str, status: Status, by: &str) -> Result<Self::Rec, Self::Error>;
fn relabel(&self, id: &str, label: &str) -> Result<(), Self::Error>;
fn answer_delivered(&self, id: &str) -> Result<(), Self::Error>;
fn undelivered(&self) -> Result<Vec<Self::Rec>, Self::Error>;
fn saw(&self, peer: &str, label: Option<&str>, addrs: &[String], agent: Option<&str>, source: &str) -> Result<(), Self::Error>;
fn sightings(&self, peer: &str) -> Vec<String>;
fn peer_label(&self, peer: &str) -> Option<String>;
fn named(&self, label: &str) -> Vec<String>;
fn find_peer(&self, key: &str) -> Result<String, Self::Error>;
fn note(&self, origin: &str, kind: &str, summary: String, params: Value);
fn admit(&self, _offer: &Offer) -> Result<(), Self::Error> {
Ok(())
}
fn kept(&self, _offer: &Offer, _rec: &Self::Rec) -> Result<Option<String>, Self::Error> {
Ok(None)
}
fn completed(&self, _rec: &Self::Rec) -> Result<(), Self::Error> {
Ok(())
}
fn poll(&self, _rec: &Self::Rec, _from: &PeerId) -> Option<Result<Polled, Self::Error>> {
None
}
fn max_incoming(&self) -> usize {
50
}
fn not_ours(&self) -> String {
"that node does not speak this protocol".into()
}
}
pub trait Ask: Message {
fn hello() -> Self;
fn connect(token: String) -> Self;
fn offer(token: String) -> Self;
fn answer(token: String) -> Self;
fn poll(exchange: String) -> Self;
}
pub enum Said {
Hello { label: String, agent: String },
Ok(String),
Answered(String),
Poll { status: String, answer: Option<String> },
Error(String),
Other,
}
pub trait Say: Message {
fn said(self) -> Said;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum LinkStatus {
Pending,
Requested,
Connected,
Ended,
Failed,
}
impl LinkStatus {
pub fn as_str(self) -> &'static str {
match self {
LinkStatus::Pending => "pending",
LinkStatus::Requested => "requested",
LinkStatus::Connected => "connected",
LinkStatus::Ended => "ended",
LinkStatus::Failed => "failed",
}
}
}
pub fn status_of<X: Rec>(x: &X) -> LinkStatus {
match x.status() {
Status::Offered => {
if x.expires_at().is_some_and(|e| e < now_ms()) {
LinkStatus::Ended
} else {
LinkStatus::Pending
}
}
Status::Incoming => LinkStatus::Requested,
Status::Complete | Status::Verified => LinkStatus::Connected,
Status::Revoked => LinkStatus::Ended,
}
}
#[derive(Debug, Clone, Serialize)]
pub struct Link<X> {
pub status: LinkStatus,
pub peer: String,
pub peer_id: Option<String>,
pub exchange: Option<X>,
pub detail: String,
pub warning: Option<String>,
}
impl<X> Link<X> {
pub fn lines(&self) -> Vec<String> {
let mut v = vec![format!("{}: {}", self.status.as_str(), self.detail)];
if let Some(w) = &self.warning {
v.push(format!("warning: {w}"));
}
v
}
}
pub enum Delivered<X> {
Answered(X),
Kept(String),
}
pub struct Accepted<X> {
pub exchange: X,
pub answer: Option<String>,
pub delivered: Option<std::result::Result<String, String>>,
}
type R<T, H> = std::result::Result<T, <H as Host>::Error>;
pub type Polled = (String, Option<String>);
fn bad(what: &'static str, msg: impl Into<String>) -> NetError {
NetError::invalid(what, msg)
}
pub fn known<H: Host>(h: &H, peer: &str) -> bool {
h.records().map(|xs| xs.iter().any(|x| x.peer_id() == Some(peer) && x.answer().is_some() && x.revoked_by() != Some("me"))).unwrap_or(false)
}
pub fn pinned<H: Host>(h: &H, peer: &str) -> bool {
h.records().map(|xs| xs.iter().any(|x| x.peer_id() == Some(peer) && x.answer().is_some())).unwrap_or(false)
}
pub fn impostor<H: Host>(h: &H, peer: &str, label: &str) -> Option<String> {
let l = label.trim();
if l.is_empty() || pinned(h, peer) {
return None;
}
let xs = h.records().ok()?;
let other = xs.iter().find(|x| {
x.answer().is_some()
&& x.peer_id().is_some_and(|p| p != peer)
&& (x.peer_label().eq_ignore_ascii_case(l) || x.label().eq_ignore_ascii_case(l))
})?;
Some(format!(
"this node calls itself {l}, but its key is not the one of the {l} you know ({}); it is a different node",
short_peer_id(&other.peer_id().unwrap_or_default().parse().unwrap_or(PeerId::random()))
))
}
pub fn peer_addrs<H: Host>(p: &Profile, h: &H, peer: &str, relays: &[String]) -> Vec<Multiaddr> {
let mut v: Vec<String> = h.sightings(peer);
if let Ok(xs) = h.records() {
for x in xs.into_iter().filter(|x| x.peer_id() == Some(peer)) {
let tokens = [Some(x.offer().to_string()), x.answer().map(str::to_string)];
for t in tokens.into_iter().flatten() {
match p.parse_token(&t) {
Ok(Token::Offer(o)) if o.peer == peer => v.extend(o.addrs),
Ok(Token::Answer(a)) if a.peer == peer => v.extend(a.addrs),
_ => {}
}
}
}
}
let Ok(pid) = peer.parse::<PeerId>() else { return vec![] };
let mut out: Vec<Multiaddr> = vec![];
for a in parse_addrs(&v) {
let a = match addr_peer(&a) {
Some(p) if p == pid => {
let mut a = a;
a.pop();
a
}
Some(_) if !a.iter().any(|p| p == Protocol::P2pCircuit) => continue,
_ => a,
};
if !out.contains(&a) {
out.push(a);
}
}
let configured: Vec<Multiaddr> = parse_addrs(relays).into_iter().filter(|r| addr_peer(r).is_some()).collect();
for r in &configured {
let c = r.clone().with(Protocol::P2pCircuit);
if !out.contains(&c) {
out.push(c);
}
}
one_circuit_per_relay(out.into_iter().filter(shareable).collect(), &configured)
}
pub fn resolve_addr<H: Host>(p: &Profile, h: &H, target: &str, relays: &[String]) -> R<(PeerId, Vec<Multiaddr>), H> {
let t = target.trim();
if t.starts_with('/') {
let a: Multiaddr = t.parse().map_err(|e| bad("address", format!("{t}: {e}")))?;
let pid = addr_peer(&a).ok_or_else(|| bad("address", "needs the peer id at the end (…/p2p/12D3Koo…)"))?;
let mut v = vec![a];
v.extend(peer_addrs(p, h, &pid.to_string(), relays));
return Ok((pid, v));
}
let peer = match t.parse::<PeerId>() {
Ok(x) => x.to_string(),
Err(_) => h.find_peer(t)?,
};
let pid: PeerId = peer.parse().map_err(|_| bad("peer", "bad peer id"))?;
Ok((pid, peer_addrs(p, h, &peer, relays)))
}
pub fn resolve<H: Host>(p: &Profile, h: &H, target: &str, relays: &[String]) -> R<(PeerId, Vec<Multiaddr>), H> {
let t = target.trim();
if !t.starts_with('/') && t.parse::<PeerId>().is_err() {
let named = h.named(t);
if named.len() > 1
&& let Some(peer) = named.iter().find(|x| pinned(h, x))
{
let pid: PeerId = peer.parse().map_err(|_| bad("peer", "bad peer id"))?;
return Ok((pid, peer_addrs(p, h, peer, relays)));
}
}
resolve_addr(p, h, target, relays)
}
pub fn kind_link<H: Host>(h: &H, peer: &str, kind: &str) -> R<Option<H::Rec>, H> {
let xs: Vec<H::Rec> = h.records()?.into_iter().filter(|x| x.peer_id() == Some(peer) && crate::profile::scope_kind(x.scope()) == kind).collect();
let pick = |f: &dyn Fn(&H::Rec) -> bool| xs.iter().find(|x| f(x)).cloned();
Ok(pick(&|x| x.status().active())
.or_else(|| pick(&|x| x.status() == Status::Incoming))
.or_else(|| pick(&|x| status_of(x) == LinkStatus::Pending)))
}
fn title_of<H: Host>(h: &H, peer: &PeerId) -> String {
h.peer_label(&peer.to_string()).filter(|l| !l.is_empty()).unwrap_or_else(|| short_peer_id(peer))
}
pub fn plain(e: &str) -> String {
let l = e.to_ascii_lowercase();
if l.contains("timeout") || l.contains("timed out") {
"the node did not answer in time (is it running and reachable?)".into()
} else if l.contains("dial") || l.contains("unreachable") || l.contains("no addresses") || l.contains("connection refused") {
"could not reach the node (is it running? check the address, or add a relay)".into()
} else {
e.trim_start_matches("network: ").to_string()
}
}
#[allow(clippy::too_many_arguments)]
pub fn offer_to<H: Host>(
p: &Profile,
h: &H,
kp: &Keypair,
peer: &str,
scope: Value,
label: &str,
my_label: &str,
addrs: Vec<String>,
ttl_ms: i64,
origin: &str,
) -> R<H::Rec, H> {
let (offer, secret) = p.offer(kp, my_label, addrs, scope, now_ms(), ttl_ms)?;
let token = p.offer_token(&offer)?;
let x = h.insert(
&NewRec {
id: &offer.id,
label,
role: Role::Offerer,
status: Status::Offered,
peer_id: peer,
peer_label: "",
scope: &offer.scope,
offer: &token,
expires_at: offer.expires,
},
Some(&secret[..]),
)?;
h.note(origin, "net.exchange.create", "key exchange requested".to_string(), json!({ "exchange": x.id(), "peer": peer, "auto": true }));
Ok(x)
}
pub fn complete_offer<H: Host>(p: &Profile, h: &H, a: &Answer, token: &str) -> R<H::Rec, H> {
let x = h.get(&a.offer)?.ok_or_else(|| bad("exchange", "this answer is for an offer this node did not make"))?;
if x.role() != Role::Offerer {
return Err(bad("exchange", "this answer is for an offer this node did not make").into());
}
if x.status() != Status::Offered {
return Err(bad("exchange", format!("the exchange is already {}", x.status().as_str())).into());
}
let Token::Offer(o) = p.parse_token(x.offer())? else {
return Err(NetError::Other("stored offer is damaged".into()).into());
};
let secret = h.secret(x.id())?.ok_or_else(|| NetError::Other("the offer's secret is gone".into()))?;
let d = p.complete(a, &o, &secret)?;
let x = h.complete(x.id(), &a.peer, &a.label, &token.split_whitespace().collect::<String>(), &d)?;
h.saw(&a.peer, Some(&a.label), &a.addrs, None, "exchange")?;
h.completed(&x)?;
Ok(x)
}
pub fn deliver<H: Host, Q: Ask, S: Say>(
p: &Profile,
h: &H,
node: &Node<Q, S>,
peer: PeerId,
addrs: &[Multiaddr],
token: &str,
) -> std::result::Result<Delivered<H::Rec>, String> {
let r = match node.request(peer, addrs, Q::connect(token.to_string())).map(Say::said) {
Ok(Said::Error(msg)) if msg.contains("unknown variant") || msg.contains("Connect") => {
node.request(peer, addrs, Q::offer(token.to_string())).map(Say::said)
}
Err(e) if e.to_string().contains("decode") || e.to_string().contains("variant") => {
node.request(peer, addrs, Q::offer(token.to_string())).map(Say::said)
}
r => r,
};
match r {
Ok(Said::Answered(t)) => {
let Ok(Token::Answer(a)) = p.parse_token(&t) else { return Err("the peer sent back something that is not an answer".into()) };
if a.peer != peer.to_string() {
return Err("the answer was signed by a different node".into());
}
match complete_offer(p, h, &a, &t) {
Ok(x) => {
h.note(
"network",
"net.exchange.complete",
format!("key exchange with {} complete", x.title()),
json!({ "exchange": x.id(), "peer": x.peer_id(), "auto": true }),
);
Ok(Delivered::Answered(x))
}
Err(e) => Err(e.to_string()),
}
}
Ok(Said::Ok(msg)) => Ok(Delivered::Kept(msg)),
Ok(Said::Error(msg)) => Err(msg),
Ok(_) => Err("unexpected answer".into()),
Err(e) => Err(plain(&e.to_string())),
}
}
#[allow(clippy::too_many_arguments)]
pub fn connect<H: Host, Q: Ask, S: Say>(
p: &Profile,
h: &H,
node: &Node<Q, S>,
kp: &Keypair,
target: &str,
label: Option<&str>,
my_label: &str,
addrs: Vec<String>,
relays: &[String],
origin: &str,
scope: Value,
ttl_ms: i64,
accept: impl FnOnce(&H::Rec, Vec<String>) -> R<Link<H::Rec>, H>,
) -> R<Link<H::Rec>, H> {
let kind = crate::profile::scope_kind(&scope).to_string();
let (pid, dial) = resolve(p, h, target, relays)?;
let peer_id = pid.to_string();
let fail = |detail: String| Link {
status: LinkStatus::Failed,
peer: title_of(h, &pid),
peer_id: Some(peer_id.clone()),
exchange: None,
detail,
warning: None,
};
let warning = match node.request(pid, &dial, Q::hello()).map(Say::said) {
Ok(Said::Hello { label: l, agent }) => {
let reach: Vec<String> = dial.iter().filter(|a| !a.iter().any(|x| x == Protocol::P2pCircuit)).map(|a| a.to_string()).collect();
let name = label.map(str::to_string).filter(|x| !x.is_empty());
let warning = impostor(h, &peer_id, &l);
h.saw(&peer_id, name.as_deref().or(Some(&l)), &reach, Some(&agent), "manual")?;
warning
}
Ok(Said::Error(msg)) => return Ok(fail(msg)),
Ok(_) => return Ok(fail(h.not_ours())),
Err(e) => return Ok(fail(plain(&e.to_string()))),
};
let peer = title_of(h, &pid);
let link = |status, exchange: Option<H::Rec>, detail: String| Link {
status,
peer: peer.clone(),
peer_id: Some(peer_id.clone()),
exchange,
detail,
warning: warning.clone(),
};
match kind_link(h, &peer_id, &kind)? {
Some(x) if x.status().active() => return Ok(link(LinkStatus::Connected, Some(x), format!("already connected to {peer}"))),
Some(x) if x.status() == Status::Incoming => return accept(&x, addrs),
Some(x) => {
return Ok(match deliver(p, h, node, pid, &dial, x.offer()) {
Ok(Delivered::Answered(x)) => link(LinkStatus::Connected, Some(x), format!("connected to {peer}")),
Ok(Delivered::Kept(_)) => link(LinkStatus::Pending, Some(x), format!("waiting for {peer} to accept")),
Err(e) => link(LinkStatus::Failed, Some(x), e),
});
}
None => {}
}
let x = offer_to(p, h, kp, &peer_id, scope, label.unwrap_or(""), my_label, addrs, ttl_ms, origin)?;
Ok(match deliver(p, h, node, pid, &dial, x.offer()) {
Ok(Delivered::Answered(x)) => link(LinkStatus::Connected, Some(x), format!("connected to {peer}")),
Ok(Delivered::Kept(_)) => link(LinkStatus::Pending, Some(x), format!("waiting for {peer} to accept")),
Err(e) => {
let _ = h.set_status(x.id(), Status::Revoked, "me");
link(LinkStatus::Failed, Some(x), e)
}
})
}
#[allow(clippy::too_many_arguments)]
pub fn accept_token<H: Host, Q: Ask, S: Say>(
p: &Profile,
h: &H,
node: Option<&Node<Q, S>>,
kp: &Keypair,
token: &str,
label: &str,
my_label: &str,
addrs: Vec<String>,
origin: &str,
) -> R<Accepted<H::Rec>, H> {
match p.parse_token(token)? {
Token::Answer(a) => {
let x = complete_offer(p, h, &a, token)?;
if !label.is_empty() {
h.relabel(x.id(), label)?;
}
let x = h.get(x.id())?.unwrap_or(x);
h.note(
origin,
"net.exchange.complete",
format!("key exchange with {} complete", x.title()),
json!({ "exchange": x.id(), "peer": x.peer_id(), "fingerprint": x.fingerprint() }),
);
Ok(Accepted { exchange: x, answer: None, delivered: None })
}
Token::Offer(o) => {
let from = p.verify_offer(&o, now_ms())?;
if let Some(x) = h.get(&o.id)?
&& x.status() != Status::Incoming
{
return Err(bad("exchange", format!("this offer was already {}", x.status().as_str())).into());
}
let (a, d) = p.answer(kp, &o, my_label, addrs, now_ms())?;
let atoken = p.answer_token(&a)?;
if h.get(&o.id)?.is_none() {
h.insert(
&NewRec {
id: &o.id,
label,
role: Role::Answerer,
status: Status::Incoming,
peer_id: &o.peer,
peer_label: &o.label,
scope: &o.scope,
offer: token,
expires_at: o.expires,
},
None,
)?;
} else if !label.is_empty() {
h.relabel(&o.id, label)?;
}
let x = h.complete(&o.id, &o.peer, &o.label, &atoken, &d)?;
h.saw(&o.peer, Some(&o.label), &o.addrs, None, "exchange")?;
h.completed(&x)?;
let mut refused: Option<String> = None;
let delivered = node.map(|n| {
let addrs = peer_addrs(p, h, &from.to_string(), &[]);
match n.request(from, &addrs, Q::answer(atoken.clone())).map(Say::said) {
Ok(Said::Ok(msg)) => Ok(msg),
Ok(Said::Error(msg)) => {
refused = Some(msg.clone());
Err(msg)
}
Ok(_) => Err("unexpected answer".into()),
Err(e) => Err(plain(&e.to_string())),
}
});
if matches!(delivered, Some(Ok(_))) {
h.answer_delivered(x.id())?;
}
h.note(
origin,
"net.exchange.accept",
format!("key exchange with {} accepted", x.title()),
json!({ "exchange": x.id(), "peer": x.peer_id(), "fingerprint": x.fingerprint(), "delivered": delivered.as_ref().map(|d| d.is_ok()) }),
);
let x = match refused {
Some(_) => {
let x = h.set_status(x.id(), Status::Revoked, "peer")?;
h.note(
origin,
"net.exchange.revoke",
format!("{} turned the invite down", x.title()),
json!({ "exchange": x.id(), "peer": x.peer_id(), "by": "peer" }),
);
x
}
None => x,
};
Ok(Accepted { exchange: x, answer: Some(atoken), delivered })
}
}
}
pub fn incoming_offer<H: Host>(p: &Profile, h: &H, from: &PeerId, token: &str) -> R<String, H> {
let Token::Offer(o) = p.parse_token(token)? else {
return Err(bad("token", "expected an offer").into());
};
let signer = p.verify_offer(&o, now_ms())?;
if signer != *from {
return Err(bad("exchange", "the offer was sent by a different node than the one that signed it").into());
}
if let Some(x) = h.get(&o.id)? {
return Ok(format!("already known ({})", x.status().as_str()));
}
h.admit(&o)?;
let incoming = h.records()?.into_iter().filter(|x| x.status() == Status::Incoming).count();
if incoming >= h.max_incoming() {
return Err(bad("exchange", "too many pending offers on this node").into());
}
let offer: String = token.split_whitespace().collect();
let x = h.insert(
&NewRec {
id: &o.id,
label: "",
role: Role::Answerer,
status: Status::Incoming,
peer_id: &o.peer,
peer_label: &o.label,
scope: &o.scope,
offer: &offer,
expires_at: o.expires,
},
None,
)?;
h.saw(&o.peer, Some(&o.label), &o.addrs, None, "exchange")?;
if let Some(msg) = h.kept(&o, &x)? {
return Ok(msg);
}
h.note(
"network",
"net.exchange.incoming",
format!("key exchange offered by {} ({})", x.title(), short_peer_id(from)),
json!({ "exchange": x.id(), "peer": o.peer, "label": o.label }),
);
Ok("offer received; it waits to be accepted".into())
}
pub fn incoming_answer<H: Host>(p: &Profile, h: &H, from: &PeerId, token: &str) -> R<String, H> {
let Token::Answer(a) = p.parse_token(token)? else {
return Err(bad("token", "expected an answer").into());
};
if a.peer != from.to_string() {
return Err(bad("exchange", "the answer was sent by a different node than the one that signed it").into());
}
let x = complete_offer(p, h, &a, token)?;
h.note(
"network",
"net.exchange.complete",
format!("key exchange with {} complete", x.title()),
json!({ "exchange": x.id(), "peer": x.peer_id(), "fingerprint": x.fingerprint() }),
);
Ok("exchange complete".into())
}
#[derive(Debug, Clone)]
pub struct Facts {
pub kind: String,
pub known: bool,
pub crossing: usize,
pub already: bool,
}
pub fn connect_in<H: Host>(
p: &Profile,
h: &H,
from: &PeerId,
token: &str,
my_label: &str,
me: impl FnOnce() -> R<(Keypair, Vec<String>), H>,
decide: impl FnOnce(&Facts) -> bool,
) -> R<Said, H> {
let msg = incoming_offer(p, h, from, token)?;
let Token::Offer(o) = p.parse_token(token)? else { return Err(bad("token", "expected an offer").into()) };
let Some(x) = h.get(&o.id)? else { return Ok(Said::Ok(msg)) };
if x.status().active() && x.role() == Role::Answerer {
if let Some(a) = x.answer() {
h.answer_delivered(x.id())?;
return Ok(Said::Answered(a.to_string()));
}
}
if x.status() != Status::Incoming {
return Ok(Said::Ok(msg));
}
let peer = from.to_string();
let kind = crate::profile::scope_kind(&o.scope).to_string();
let same = |y: &H::Rec| crate::profile::scope_kind(y.scope()) == kind;
let all = h.records()?;
let ours: Vec<&H::Rec> =
all.iter().filter(|y| y.id() != x.id() && y.peer_id() == Some(&peer) && y.status() == Status::Offered && same(y)).collect();
let already = all.iter().any(|y| y.peer_id() == Some(&peer) && y.status().active() && same(y));
let facts = Facts { kind, known: known(h, &peer), crossing: ours.len(), already };
if !decide(&facts) {
return Ok(Said::Ok("request received; it waits for the owner to accept".into()));
}
let (kp, addrs) = me()?;
let a = accept_token::<H, (), ()>(p, h, None, &kp, x.offer(), "", my_label, addrs, "network")?;
h.answer_delivered(x.id())?;
for y in ours {
let _ = h.set_status(y.id(), Status::Revoked, "me");
}
h.note("network", "net.exchange.auto", format!("connected to {} automatically", a.exchange.title()), json!({ "exchange": x.id(), "peer": peer }));
Ok(match a.answer {
Some(t) => Said::Answered(t),
None => Said::Ok(msg),
})
}
pub fn poll_in<H: Host>(h: &H, from: &PeerId, exchange: &str) -> R<Polled, H> {
let x = h.get(exchange)?.ok_or_else(|| bad("exchange", "unknown request"))?;
if x.peer_id() != Some(&from.to_string()) || x.role() != Role::Answerer {
return Err(bad("exchange", "unknown request").into());
}
if let Some(r) = h.poll(&x, from) {
let r = r?;
if r.1.is_some() {
h.answer_delivered(x.id())?;
}
return Ok(r);
}
Ok(match x.status() {
st if st.active() => {
h.answer_delivered(x.id())?;
("connected".into(), x.answer().map(str::to_string))
}
Status::Revoked => ("declined".into(), None),
_ => ("pending".into(), None),
})
}
pub fn settle_offers<H: Host, Q: Ask, S: Say>(
p: &Profile,
h: &H,
node: &Node<Q, S>,
relays: &[String],
origin: &str,
mut own: impl FnMut(&H::Rec) -> Option<Vec<String>>,
) -> Vec<String> {
let mut out = vec![];
let now = now_ms();
let Ok(xs) = h.records() else { return out };
for x in xs.iter().filter(|x| x.status() == Status::Offered && x.expires_at().is_none_or(|e| e > now)) {
let Some(peer) = x.peer_id().and_then(|p| p.parse::<PeerId>().ok()) else { continue };
if let Some(lines) = own(x) {
out.extend(lines);
continue;
}
let addrs = peer_addrs(p, h, &peer.to_string(), relays);
match node.request(peer, &addrs, Q::poll(x.id().to_string())).map(Say::said) {
Ok(Said::Poll { answer: Some(t), .. }) => {
if let Ok(Token::Answer(a)) = p.parse_token(&t)
&& a.peer == peer.to_string()
&& let Ok(x) = complete_offer(p, h, &a, &t)
{
h.note(
origin,
"net.exchange.complete",
format!("key exchange with {} complete", x.title()),
json!({ "exchange": x.id(), "peer": x.peer_id(), "auto": true }),
);
out.push(format!("connected: {} ({})", x.title(), x.purpose()));
}
}
Ok(Said::Poll { status, .. })
if (status == "declined" || status == "rejected") && h.set_status(x.id(), Status::Revoked, "peer").is_ok() =>
{
out.push(format!("declined: {} ({})", x.title(), x.purpose()));
}
_ => {}
}
}
out
}
pub fn deliver_answers<H: Host, Q: Ask, S: Say>(p: &Profile, h: &H, node: &Node<Q, S>, relays: &[String]) -> Vec<String> {
let mut out = vec![];
if let Ok(xs) = h.undelivered() {
for x in xs {
let Some(peer) = x.peer_id().and_then(|p| p.parse::<PeerId>().ok()) else { continue };
let Some(t) = x.answer().map(str::to_string) else { continue };
let addrs = peer_addrs(p, h, &peer.to_string(), relays);
match node.request(peer, &addrs, Q::answer(t)).map(Say::said) {
Ok(Said::Ok(_)) => {
let _ = h.answer_delivered(x.id());
out.push(format!("{} got our answer ({})", x.title(), x.purpose()));
}
Ok(Said::Error(msg)) if msg.contains("already") => {
let _ = h.answer_delivered(x.id());
}
_ => {}
}
}
}
out
}
pub fn handle<H: Host>(
p: &Profile,
h: &H,
from: &PeerId,
req: Asked,
my_label: &str,
me: impl FnOnce() -> R<(Keypair, Vec<String>), H>,
decide: impl FnOnce(&Facts) -> bool,
) -> R<Said, H> {
match req {
Asked::Connect(t) => connect_in(p, h, from, &t, my_label, me, decide),
Asked::Offer(t) => incoming_offer(p, h, from, &t).map(Said::Ok),
Asked::Answer(t) => incoming_answer(p, h, from, &t).map(Said::Ok),
Asked::Poll(x) => poll_in(h, from, &x).map(|(status, answer)| Said::Poll { status, answer }),
}
}
pub enum Asked {
Connect(String),
Offer(String),
Answer(String),
Poll(String),
}
impl Ask for () {
fn hello() -> Self {}
fn connect(_: String) -> Self {}
fn offer(_: String) -> Self {}
fn answer(_: String) -> Self {}
fn poll(_: String) -> Self {}
}
impl Say for () {
fn said(self) -> Said {
Said::Other
}
}
pub fn offer_addrs(all: &[String]) -> Vec<String> {
let keep: Vec<Multiaddr> = parse_addrs(all).into_iter().filter(shareable).collect();
let mut v: Vec<String> = one_circuit_per_relay(keep, &[]).iter().map(|a| a.to_string()).collect();
v.retain(|a| !crate::addr::link_local(a) && !crate::addr::docker_bridge(a));
v
}