1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
use crate::{
envelope::{DhtMessageFlags, DhtMessageHeader, DhtMessageType, Network, NodeDestination},
outbound::{message_params::FinalSendMessageParams, message_send_state::MessageSendStates},
};
use bytes::Bytes;
use futures::channel::oneshot;
use std::{fmt, fmt::Display, sync::Arc};
use tari_comms::{
message::{MessageTag, MessagingReplyTx},
peer_manager::NodeId,
types::CommsPublicKey,
};
use tari_utilities::hex::Hex;
use thiserror::Error;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OutboundEncryption {
ClearText,
EncryptFor(Box<CommsPublicKey>),
}
impl OutboundEncryption {
pub fn flags(&self) -> DhtMessageFlags {
match self {
OutboundEncryption::EncryptFor(_) => DhtMessageFlags::ENCRYPTED,
_ => DhtMessageFlags::NONE,
}
}
pub fn is_encrypt(&self) -> bool {
use OutboundEncryption::*;
match self {
ClearText => false,
EncryptFor(_) => true,
}
}
}
impl Display for OutboundEncryption {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
match self {
OutboundEncryption::ClearText => write!(f, "ClearText"),
OutboundEncryption::EncryptFor(ref key) => write!(f, "EncryptFor:{}", key.to_hex()),
}
}
}
impl Default for OutboundEncryption {
fn default() -> Self {
OutboundEncryption::ClearText
}
}
#[derive(Debug, Error)]
pub enum SendFailure {
#[error("Attempt to send message to ourselves")]
SendToOurselves,
#[error("Discovery reply channel cancelled")]
SenderCancelled,
#[error("Failure when sending: {0}")]
General(String),
#[error("Discovery failed")]
DiscoveryFailed,
#[error("Failure when generating messages: {0}")]
FailedToGenerateMessages(String),
#[error("No messages were queued for sending")]
NoMessagesQueued,
}
#[derive(Debug)]
pub enum SendMessageResponse {
Queued(MessageSendStates),
Failed(SendFailure),
PendingDiscovery(oneshot::Receiver<SendMessageResponse>),
}
impl SendMessageResponse {
pub async fn resolve(self) -> Result<MessageSendStates, SendFailure> {
use SendMessageResponse::*;
match self {
Queued(send_states) if !send_states.is_empty() => Ok(send_states),
Queued(_) => Err(SendFailure::NoMessagesQueued),
Failed(err) => Err(err),
PendingDiscovery(rx) => rx.await.map_err(|_| SendFailure::SenderCancelled)?.queued_or_failed(),
}
}
fn queued_or_failed(self) -> Result<MessageSendStates, SendFailure> {
use SendMessageResponse::*;
match self {
Queued(send_states) if !send_states.is_empty() => Ok(send_states),
Queued(_) => Err(SendFailure::NoMessagesQueued),
Failed(err) => Err(err),
PendingDiscovery(_) => panic!("ok_or_failed() called on PendingDiscovery"),
}
}
}
#[derive(Debug)]
pub enum DhtOutboundRequest {
SendMessage(Box<FinalSendMessageParams>, Bytes, oneshot::Sender<SendMessageResponse>),
}
impl fmt::Display for DhtOutboundRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
match self {
DhtOutboundRequest::SendMessage(params, body, _) => {
write!(f, "SendMsg({} - <{} bytes>)", params.broadcast_strategy, body.len())
},
}
}
}
#[derive(Debug)]
pub struct DhtOutboundMessage {
pub tag: MessageTag,
pub destination_node_id: NodeId,
pub custom_header: Option<DhtMessageHeader>,
pub body: Bytes,
pub ephemeral_public_key: Option<Arc<CommsPublicKey>>,
pub origin_mac: Option<Bytes>,
pub destination: NodeDestination,
pub dht_message_type: DhtMessageType,
pub reply: MessagingReplyTx,
pub network: Network,
pub dht_flags: DhtMessageFlags,
pub is_broadcast: bool,
}
impl fmt::Display for DhtOutboundMessage {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
let header_str = self
.custom_header
.as_ref()
.map(|h| format!("{} (Propagated)", h))
.unwrap_or_else(|| {
format!(
"Network: {:?}, Flags: {:?}, Destination: {}, Trace: {}",
self.network, self.dht_flags, self.destination, self.tag,
)
});
write!(
f,
"\n---- Outgoing message ---- \nSize: {} byte(s)\nType: {}\nPeer: {}\nHeader: {}\n{}\n----",
self.body.len(),
self.dht_message_type,
self.destination_node_id,
header_str,
self.tag,
)
}
}