Restructure discovery

This commit is contained in:
QuantumEntangledAndy authored and Andrew King committed 2023-02-28 12:41:04 +07:00
1 parent ac0703dbfd
commit a5a3cf9715
7 files changed
+490 -305

No files matched your search

+17 -5
View File
@@ -199,11 +199,12 @@ impl BcCamera {
SocketAddrOrUid::Uid(uid, method) => {
trace!("Trying uid {}", uid);
// TODO Make configurable
let (allow_local, allow_remote, allow_relay) = match method {
DiscoveryMethods::None => (false, false, false),
DiscoveryMethods::Local => (true, false, false),
DiscoveryMethods::Remote => (true, true, false),
DiscoveryMethods::Relay => (true, true, true),
let (allow_local, allow_remote, allow_map, allow_relay) = match method {
DiscoveryMethods::None => (false, false, false, false),
DiscoveryMethods::Local => (true, false, false, false),
DiscoveryMethods::Remote => (true, true, false, false),
DiscoveryMethods::Map => (true, true, true, false),
DiscoveryMethods::Relay => (true, true, true, true),
};
let discovery = {
@@ -238,6 +239,17 @@ impl BcCamera {
result
});
}
if allow_map {
let uid_relay = uid.clone();
set.spawn(async move {
trace!("Starting Map");
let result = Discovery::map(&uid_relay).await;
if let Ok(disc) = &result {
info!("Mao success {} at {}", uid_relay, disc.get_addr());
}
result
});
}
if allow_relay {
let uid_relay = uid.clone();
set.spawn(async move {
@@ -33,8 +33,9 @@ use tokio_util::udp::UdpFramed;
#[derive(Debug, Clone)]
struct RegisterResult {
reg: SocketAddr,
dmap: Option<SocketAddr>,
dev: Option<SocketAddr>,
dev: SocketAddr,
dmap: SocketAddr,
relay: SocketAddr,
client_id: i32,
sid: u32,
}
@@ -53,12 +54,6 @@ struct UidLookupResults {
relay: SocketAddr,
}
#[derive(Debug, Clone, Copy)]
enum ConnectionKind {
Local,
Relay,
}
pub(crate) struct Discovery {}
const MTU: u32 = 1030;
@@ -275,12 +270,30 @@ impl Discoverer {
result
}
// This function will contact the p2p relay servers
//
// It will ask each of the servers for details on a specific UID
//
// On success it returns the M2cQr that the p2p relay
// server has about the UID
async fn send_and_forget(&self, mut disc: UdpDiscovery, dest: SocketAddr) -> Result<()> {
if disc.tid == 0 {
// If 0 make a random one
let target_tid = generate_tid();
disc.tid = target_tid;
}
let mut inter = interval(Duration::from_millis(50));
let msg = BcUdp::Discovery(disc);
for _i in 0..5 {
inter.tick().await;
self.send(msg.clone(), dest).await?;
}
Ok(())
}
/// This function will contact the p2p relay servers
///
/// It will ask each of the servers for details on a specific UID
///
/// On success it returns the M2cQr that the p2p relay
/// server has about the UID
async fn uid_loopup(&self, uid: &str) -> Result<UidLookupResults> {
let mut addrs = vec![];
for p2p_relay in P2P_RELAY_HOSTNAMES.iter() {
@@ -321,185 +334,6 @@ impl Discoverer {
})
}
async fn send_and_forget(&self, mut disc: UdpDiscovery, dest: SocketAddr) -> Result<()> {
if disc.tid == 0 {
// If 0 make a random one
let target_tid = generate_tid();
disc.tid = target_tid;
}
let mut inter = interval(Duration::from_millis(50));
let msg = BcUdp::Discovery(disc);
for _i in 0..5 {
inter.tick().await;
self.send(msg.clone(), dest).await?;
}
Ok(())
}
async fn device_initiated_connect(
&self,
client_id: i32,
register_result: &RegisterResult,
) -> Result<ConnectResult> {
let (addr, local_tid, local_did, conn_kind) = self
.handle_incoming(|bc, addr| {
trace!("bc: {:?}", bc);
match (bc, register_result) {
(
UdpDiscovery {
tid,
payload:
UdpXml {
d2c_t: Some(D2cT { sid, cid, did, .. }),
..
},
},
RegisterResult {
dmap: Some(register_dmap),
sid: register_sid,
..
},
) if cid == client_id && &sid == register_sid && &addr == register_dmap => {
Some((addr, tid, did, ConnectionKind::Relay))
}
(
UdpDiscovery {
tid,
payload:
UdpXml {
d2c_t: Some(D2cT { sid, cid, did, .. }),
..
},
},
RegisterResult {
dev: Some(register_dev),
sid: register_sid,
..
},
) if cid == client_id && &sid == register_sid && &addr == register_dev => {
Some((addr, tid, did, ConnectionKind::Local))
}
_ => None,
}
})
.await?;
let conn = match conn_kind {
ConnectionKind::Local => "local",
ConnectionKind::Relay => "map",
}
.to_string();
let msg = UdpDiscovery {
tid: local_tid,
payload: UdpXml {
c2d_a: Some(C2dA {
sid: register_result.sid,
conn,
cid: client_id,
did: local_did,
mtu: MTU,
}),
..Default::default()
},
};
// Send and await confirm
self.retry_send(msg, addr, |bc, _| {
trace!("msg: {:?}", &bc);
match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm: Some(D2cCfm { sid, cid, did, .. }),
..
},
} if sid == register_result.sid && did == local_did && cid == client_id => Some(()),
_ => None,
}
})
.await?;
let result = ConnectResult {
addr,
client_id,
sid: register_result.sid,
camera_id: local_did,
};
match conn_kind {
ConnectionKind::Local => {
self.confirm_map(&result, register_result.reg, result.addr)
.await?;
}
ConnectionKind::Relay => {
self.confirm_relay(&result, register_result.reg).await?;
}
}
Ok(result)
}
async fn client_initiated_connect(
&self,
register_result: &RegisterResult,
) -> Result<ConnectResult> {
let tid = generate_tid();
if let RegisterResult {
dev: Some(dev_addr),
..
} = &register_result
{
let msg = UdpDiscovery {
tid,
payload: UdpXml {
c2d_t: Some(C2dT {
sid: register_result.sid,
cid: register_result.client_id,
mtu: MTU,
conn: "local".to_string(),
}),
..Default::default()
},
};
let (final_addr, local_did) = self
.retry_send(msg, *dev_addr, |bc, addr| match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm: Some(D2cCfm { cid, did, sid, .. }),
..
},
} if cid == register_result.client_id && sid == register_result.sid => {
Some((addr, did))
}
_ => None,
})
.await?;
let result = ConnectResult {
addr: final_addr,
client_id: register_result.client_id,
sid: register_result.sid,
camera_id: local_did,
};
self.confirm_map(&result, register_result.reg, *dev_addr)
.await?;
Ok(result)
} else {
Err(Error::NoDev)
}
}
/// Register our local ip address with the reolink servers
/// This will be used for the device to contact us
async fn register_address(
@@ -538,79 +372,34 @@ impl Discoverer {
};
// Send and await acceptance
let (sid, dmap, dev) = self
let (sid, dev, dmap, relay) = self
.retry_send(msg, lookup.reg, |bc, _| match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_t:
Some(R2cT {
dmap: Some(dmap),
r2c_c_r:
Some(R2cCr {
dmap,
dev,
relay,
sid,
cid,
dev: Some(dev),
rsp,
..
}),
..
},
} if !dmap.ip.is_empty()
&& dmap.port > 0
&& !dev.ip.is_empty()
&& dev.port > 0
&& cid == client_id =>
{
Some(Ok((sid, Some(dmap), Some(dev))))
} if !dev.ip.is_empty() && dev.port > 0 && rsp != -1 => {
Some(Ok((sid, dev, dmap, relay)))
}
UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_t:
Some(R2cT {
dmap: Some(dmap),
sid,
cid,
dev: None,
}),
r2c_c_r: Some(R2cCr { dev, rsp, .. }),
..
},
} if !dmap.ip.is_empty() && dmap.port > 0 && cid == client_id => {
Some(Ok((sid, Some(dmap), None)))
}
UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_t:
Some(R2cT {
dmap: None,
sid,
cid,
dev: Some(dev),
}),
..
},
} if !dev.ip.is_empty() && dev.port > 0 && cid == client_id => {
Some(Ok((sid, None, Some(dev))))
}
UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_c_r: Some(R2cCr { dmap, sid, rsp, .. }),
..
},
} if !dmap.ip.is_empty() && dmap.port > 0 && rsp != -1 => {
Some(Ok((sid, Some(dmap), None)))
}
UdpDiscovery {
tid: _,
payload:
UdpXml {
r2c_c_r: Some(R2cCr { dmap, rsp, .. }),
..
},
} if !dmap.ip.is_empty() && dmap.port > 0 && rsp == -1 => {
} if !dev.ip.is_empty() && dev.port > 0 && rsp == -1 => {
Some(Err(Error::RegisterError))
}
_ => None,
@@ -621,25 +410,224 @@ impl Discoverer {
reg: lookup.reg,
sid,
client_id,
dmap: dmap.map(|dmap| {
SocketAddr::new(dmap.ip.parse().expect("Could not read ip addr"), dmap.port)
}),
dev: dev.map(|dev| {
SocketAddr::new(dev.ip.parse().expect("Could not read ip addr"), dev.port)
}),
dev: SocketAddr::new(dev.ip.parse()?, dev.port),
dmap: SocketAddr::new(dmap.ip.parse()?, dmap.port),
relay: SocketAddr::new(relay.ip.parse()?, relay.port),
})
}
/// Confirm connection with relay
/// This is sent once all data has been found
async fn confirm_relay(&self, conn_result: &ConnectResult, reg_addr: SocketAddr) -> Result<()> {
async fn device_initiated_dev(
&self,
register_result: &RegisterResult,
) -> Result<ConnectResult> {
let (addr, local_tid, local_did) = self
.handle_incoming(|bc, addr| {
trace!("bc: {:?}", bc);
match (bc, register_result) {
(
UdpDiscovery {
tid,
payload:
UdpXml {
d2c_t:
Some(D2cT {
sid,
cid,
did,
conn,
..
}),
..
},
},
RegisterResult {
dmap: register_dmap,
sid: register_sid,
..
},
) if cid == register_result.client_id
&& &sid == register_sid
&& &addr == register_dmap
&& &conn == "local" =>
{
Some((addr, tid, did))
}
_ => None,
}
})
.await?;
let msg = UdpDiscovery {
tid: local_tid,
payload: UdpXml {
c2d_a: Some(C2dA {
sid: register_result.sid,
conn: "local".to_string(),
cid: register_result.client_id,
did: local_did,
mtu: MTU,
}),
..Default::default()
},
};
// Send and await confirm
self.retry_send(msg, addr, |bc, _| {
trace!("msg: {:?}", &bc);
match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm:
Some(D2cCfm {
sid,
cid,
did,
conn,
..
}),
..
},
} if sid == register_result.sid
&& did == local_did
&& cid == register_result.client_id
&& &conn == "local" =>
{
Some(())
}
_ => None,
}
})
.await?;
let result = ConnectResult {
addr,
client_id: register_result.client_id,
sid: register_result.sid,
camera_id: local_did,
};
// Confirm local to register
let msg = UdpDiscovery {
tid: 0,
payload: UdpXml {
c2r_cfm: Some(C2rCfm {
sid: conn_result.sid,
cid: conn_result.client_id,
did: conn_result.camera_id,
sid: result.sid,
cid: result.client_id,
did: result.camera_id,
rsp: 0,
conn: "local".to_string(),
}),
..Default::default()
},
};
self.send_and_forget(msg, register_result.reg).await?;
Ok(result)
}
async fn device_initiated_map(
&self,
register_result: &RegisterResult,
) -> Result<ConnectResult> {
let (addr, local_tid, local_did) = self
.handle_incoming(|bc, addr| {
trace!("bc: {:?}", bc);
match (bc, register_result) {
(
UdpDiscovery {
tid,
payload:
UdpXml {
d2c_t:
Some(D2cT {
sid,
cid,
did,
conn,
..
}),
..
},
},
RegisterResult {
dmap: register_dmap,
sid: register_sid,
..
},
) if cid == register_result.client_id
&& &sid == register_sid
&& &addr == register_dmap
&& &conn == "map" =>
{
Some((addr, tid, did))
}
_ => None,
}
})
.await?;
let msg = UdpDiscovery {
tid: local_tid,
payload: UdpXml {
c2d_a: Some(C2dA {
sid: register_result.sid,
conn: "map".to_string(),
cid: register_result.client_id,
did: local_did,
mtu: MTU,
}),
..Default::default()
},
};
// Send and await confirm
self.retry_send(msg, addr, |bc, _| {
trace!("msg: {:?}", &bc);
match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm:
Some(D2cCfm {
sid,
cid,
did,
conn,
..
}),
..
},
} if sid == register_result.sid
&& did == local_did
&& cid == register_result.client_id
&& &conn == "map" =>
{
Some(())
}
_ => None,
}
})
.await?;
let result = ConnectResult {
addr,
client_id: register_result.client_id,
sid: register_result.sid,
camera_id: local_did,
};
// Confirm map to register
let msg = UdpDiscovery {
tid: 0,
payload: UdpXml {
c2r_cfm: Some(C2rCfm {
sid: result.sid,
cid: result.client_id,
did: result.camera_id,
rsp: 0,
conn: "map".to_string(),
}),
@@ -647,27 +635,62 @@ impl Discoverer {
},
};
self.send_and_forget(msg, reg_addr).await?;
self.send_and_forget(msg, register_result.reg).await?;
Ok(())
Ok(result)
}
/// Confirm Map. This is sent if we learned the IP via the relay
/// then connected locally. We tell the relay they we are establishing
/// a local then tell the camera to connect to us via map
async fn confirm_map(
async fn client_initiated_dev(
&self,
conn_result: &ConnectResult,
reg_addr: SocketAddr,
dev_addr: SocketAddr,
) -> Result<()> {
register_result: &RegisterResult,
) -> Result<ConnectResult> {
let tid = generate_tid();
let dev_addr = register_result.dev;
let msg = UdpDiscovery {
tid,
payload: UdpXml {
c2d_t: Some(C2dT {
sid: register_result.sid,
cid: register_result.client_id,
mtu: MTU,
conn: "local".to_string(),
}),
..Default::default()
},
};
let (final_addr, local_did) = self
.retry_send(msg, dev_addr, |bc, addr| match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm: Some(D2cCfm { cid, did, sid, .. }),
..
},
} if cid == register_result.client_id && sid == register_result.sid => {
Some((addr, did))
}
_ => None,
})
.await?;
let result = ConnectResult {
addr: final_addr,
client_id: register_result.client_id,
sid: register_result.sid,
camera_id: local_did,
};
// Confirm local to register
let msg = UdpDiscovery {
tid: 0,
payload: UdpXml {
c2r_cfm: Some(C2rCfm {
sid: conn_result.sid,
cid: conn_result.client_id,
did: conn_result.camera_id,
sid: result.sid,
cid: result.client_id,
did: result.camera_id,
conn: "local".to_string(),
rsp: 0,
}),
@@ -675,24 +698,64 @@ impl Discoverer {
},
};
self.send_and_forget(msg, reg_addr).await?;
self.send_and_forget(msg, register_result.reg).await?;
Ok(result)
}
async fn client_initiated_relay(
&self,
register_result: &RegisterResult,
) -> Result<ConnectResult> {
let tid = generate_tid();
let msg = UdpDiscovery {
tid: 0,
tid,
payload: UdpXml {
c2d_t: Some(C2dT {
sid: conn_result.sid,
cid: conn_result.client_id,
sid: register_result.sid,
cid: register_result.client_id,
mtu: MTU,
conn: "map".to_string(),
conn: "relay".to_string(),
}),
..Default::default()
},
};
self.send_and_forget(msg, dev_addr).await?;
let (final_addr, local_did) = self
.retry_send(msg, register_result.relay, |bc, addr| match bc {
UdpDiscovery {
tid: _,
payload:
UdpXml {
d2c_cfm:
Some(D2cCfm {
cid,
did,
sid,
conn,
..
}),
..
},
} if cid == register_result.client_id
&& sid == register_result.sid
&& &conn == "relay" =>
{
Some((addr, did))
}
_ => None,
})
.await?;
Ok(())
let result = ConnectResult {
addr: final_addr,
client_id: register_result.client_id,
sid: register_result.sid,
camera_id: local_did,
};
Ok(result)
}
}
@@ -764,9 +827,11 @@ impl Discovery {
let relay_addr = lookup.relay;
let reg_result = discoverer.register_address(uid, client_id, &lookup).await?;
let dev_addr = reg_result.dev.ok_or(Error::NoDev)?;
let connect_result = discoverer.client_initiated_connect(&reg_result).await?;
let connect_result = tokio::select! {
v = discoverer.client_initiated_dev(&reg_result) => {v},
v = discoverer.device_initiated_dev(&reg_result) => {v},
}?;
Ok(DiscoveryResult {
socket: discoverer.into_socket().await,
@@ -776,34 +841,53 @@ impl Discovery {
})
}
// This is similar to remote, except that a relay (map) will be established.
// This is similar to remote, except that a map will be established.
//
// All future connections will go VIA the relink servers, this is for
// cellular cameras that do not support local connections
//
// It is possible that this will also establish a local if the camera attempts that
//
#[allow(unused)]
pub(crate) async fn relay(uid: &str) -> Result<DiscoveryResult> {
let mut discoverer = Discoverer::new().await?;
let client_id = generate_cid();
pub(crate) async fn map(uid: &str) -> Result<DiscoveryResult> {
let discoverer = Discoverer::new().await?;
let client_id = generate_cid();
trace!("client_id: {}", client_id);
let lookup = discoverer.uid_loopup(uid).await?;
trace!("lookup: {:?}", lookup);
let reg_addr = lookup.reg;
let relay_addr = lookup.relay;
let reg_result = discoverer.register_address(uid, client_id, &lookup).await?;
trace!("reg_result: {:?}", reg_result);
let dmap_addr = reg_result.dmap.ok_or(Error::NoDmap)?;
let connect_result = discoverer
.device_initiated_connect(client_id, &reg_result)
.await?;
.device_initiated_map(&reg_result).await?;
trace!("connect_result: {:?}", connect_result);
Ok(DiscoveryResult {
socket: discoverer.into_socket().await,
addr: connect_result.addr,
client_id,
camera_id: connect_result.camera_id,
})
}
// This is similar to remote, except that a relay will be established.
//
// All future connections will go VIA the relink servers, this is for
// cellular cameras that do not support local connections
//
pub(crate) async fn relay(uid: &str) -> Result<DiscoveryResult> {
let discoverer = Discoverer::new().await?;
let client_id = generate_cid();
trace!("client_id: {}", client_id);
let lookup = discoverer.uid_loopup(uid).await?;
trace!("lookup: {:?}", lookup);
let reg_result = discoverer.register_address(uid, client_id, &lookup).await?;
trace!("reg_result: {:?}", reg_result);
let connect_result = discoverer.client_initiated_relay(&reg_result).await?;
trace!("connect_result: {:?}", connect_result);
Ok(DiscoveryResult {
@@ -1109,4 +1193,32 @@ async fn connect() -> Result<UdpSocket> {
</P2P>
```
# Thread 4: Observed when behind a NAT on both ends of the connection
- C->R
```
<P2P>
<C2D_T>
<sid>526020041</sid>
<conn>relay</conn>
<cid>38000</cid>
<mtu>1350</mtu>
</C2D_T>
</P2P>
```
- R->C
```xml
<P2P>
<D2C_CFM>
<sid>526020041</sid>
<conn>relay</conn>
<rsp>0</rsp>
<cid>38000</cid>
<did>32</did>
<time_r>0</time_r>
</D2C_CFM>
</P2P>
```
*/
@@ -0,0 +1,52 @@
//! Handles credentials for camera including default reolink password
use std::convert::TryInto;
/// Used for caching the credentials
#[derive(Clone)]
pub(crate) struct Credentials {
pub(crate) username: String,
pub(crate) password: Option<String>,
}
impl Default for Credentials {
/// Default credentials for some reolink cameras
fn default() -> Self {
Self {
username: "admin".to_string(),
password: Some("123456".to_string()),
}
}
}
impl std::fmt::Debug for Credentials {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_map()
.entry(&"username", &self.username)
.entry(&"password", &"******")
.finish()
}
}
impl Credentials {
pub(crate) fn new<T: Into<String>, U: Into<String>>(username: T, password: Option<U>) -> Self {
Self {
username: username.into(),
password: password.map(|t| t.into()),
}
}
/// This is a convience function to make an AES key from the login password and the NONCE
/// negotiated during login
pub(crate) fn make_aeskey<T: AsRef<str>>(&self, nonce: T) -> [u8; 16] {
let key_phrase = format!(
"{}-{}",
nonce.as_ref(),
self.password.clone().unwrap_or_default()
);
let key_phrase_hash = format!("{:X}\0", md5::compute(key_phrase))
.to_uppercase()
.into_bytes();
key_phrase_hash[0..16].try_into().unwrap()
}
}
+7 -2
View File
@@ -22,10 +22,15 @@ pub enum DiscoveryMethods {
///
/// **This also enabled `Local` discovery**
Remote,
/// Allow contact with the reolink servers to learn the ip address and relay the connection
/// through those servers.
/// Allow contact with the reolink servers to learn the ip address and map the connection
/// from dev to client through those servers.
///
/// **This also enabled `Local` and `Remote` discovery**
Map,
/// Allow contact with the reolink servers to learn the ip address and relay the connection
/// client to dev through those servers.
///
/// **This also enabled `Local`, `Map` and `Remote` discovery**
Relay,
}
+2
View File
@@ -283,6 +283,8 @@ pub struct R2cT {
///
#[derive(PartialEq, Eq, Default, Debug, YaDeserialize, YaSerialize, Clone)]
pub struct R2cCr {
/// Dev camera location (actual local ip)
pub dev: IpPort,
/// Dmap camera location
pub dmap: IpPort,
/// The location of the relay
+2 -1
View File
@@ -10,7 +10,8 @@ lazy_static! {
Regex::new(r"^(mainStream|subStream|externStream|both|all)$").unwrap();
static ref RE_TLS_CLIENT_AUTH: Regex = Regex::new(r"^(none|request|require)$").unwrap();
static ref RE_PAUSE_MODE: Regex = Regex::new(r"^(black|still|test|none)$").unwrap();
static ref RE_DISC_SRC: Regex = Regex::new(r"^([nN]one|[lL]ocal|[rR]emote|[rR]elay)$").unwrap();
static ref RE_DISC_SRC: Regex =
Regex::new(r"^([nN]one|[lL]ocal|[rR]emote|[Mm]ap|[rR]elay)$").unwrap();
static ref RE_MAXENC_SRC: Regex =
Regex::new(r"^([nN]one|[Aa][Ee][Ss]|[Bb][Cc][Ee][Nn][Cc][Rr][Yy][Pp][Tt])$").unwrap();
}
+1
View File
@@ -37,6 +37,7 @@ impl AddressOrUid {
"none" => DiscoveryMethods::None,
"local" => DiscoveryMethods::Local,
"remote" => DiscoveryMethods::Remote,
"map" => DiscoveryMethods::Map,
"relay" => DiscoveryMethods::Relay,
n => {
warn!("Unrecognised discovery method: {}. Using Local", n);