Restructure discovery
This commit is contained in:
1 parent
ac0703dbfd
commit
a5a3cf9715
7 files changed
+490
-305
No files matched your search
@@ -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),
|
||||
..
|
||||
} = ®ister_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(®_result).await?;
|
||||
let connect_result = tokio::select! {
|
||||
v = discoverer.client_initiated_dev(®_result) => {v},
|
||||
v = discoverer.device_initiated_dev(®_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, ®_result)
|
||||
.await?;
|
||||
.device_initiated_map(®_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(®_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()
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -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
@@ -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();
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user