From a5a3cf9715f96be1edf3836952564a7e0fa33030 Mon Sep 17 00:00:00 2001 From: QuantumEntangledAndy Date: Mon, 27 Feb 2023 15:57:29 +0700 Subject: [PATCH] Restructure discovery --- crates/core/src/bc_protocol.rs | 22 +- .../src/bc_protocol/connection/discovery.rs | 706 ++++++++++-------- crates/core/src/bc_protocol/credentials.rs | 52 ++ crates/core/src/bc_protocol/resolution.rs | 9 +- crates/core/src/bcudp/xml.rs | 2 + src/config.rs | 3 +- src/utils.rs | 1 + 7 files changed, 490 insertions(+), 305 deletions(-) create mode 100644 crates/core/src/bc_protocol/credentials.rs diff --git a/crates/core/src/bc_protocol.rs b/crates/core/src/bc_protocol.rs index 97952d8..10811ce 100644 --- a/crates/core/src/bc_protocol.rs +++ b/crates/core/src/bc_protocol.rs @@ -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 { diff --git a/crates/core/src/bc_protocol/connection/discovery.rs b/crates/core/src/bc_protocol/connection/discovery.rs index 55c96e9..4125304 100644 --- a/crates/core/src/bc_protocol/connection/discovery.rs +++ b/crates/core/src/bc_protocol/connection/discovery.rs @@ -33,8 +33,9 @@ use tokio_util::udp::UdpFramed; #[derive(Debug, Clone)] struct RegisterResult { reg: SocketAddr, - dmap: Option, - dev: Option, + 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 { 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 { - 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 { - 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 { + 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 { + 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 { + 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 { + 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 { - let mut discoverer = Discoverer::new().await?; - let client_id = generate_cid(); + pub(crate) async fn map(uid: &str) -> Result { + 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 { + 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 { ``` + # Thread 4: Observed when behind a NAT on both ends of the connection + + - C->R + ``` + + + 526020041 + relay + 38000 + 1350 + + + ``` + + - R->C + ```xml + + + 526020041 + relay + 0 + 38000 + 32 + 0 + + + ``` + */ diff --git a/crates/core/src/bc_protocol/credentials.rs b/crates/core/src/bc_protocol/credentials.rs new file mode 100644 index 0000000..6a0c1e8 --- /dev/null +++ b/crates/core/src/bc_protocol/credentials.rs @@ -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, +} + +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, U: Into>(username: T, password: Option) -> 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>(&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() + } +} diff --git a/crates/core/src/bc_protocol/resolution.rs b/crates/core/src/bc_protocol/resolution.rs index 66a02b5..aec46f6 100644 --- a/crates/core/src/bc_protocol/resolution.rs +++ b/crates/core/src/bc_protocol/resolution.rs @@ -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, } diff --git a/crates/core/src/bcudp/xml.rs b/crates/core/src/bcudp/xml.rs index d65d13e..cfa2acc 100644 --- a/crates/core/src/bcudp/xml.rs +++ b/crates/core/src/bcudp/xml.rs @@ -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 diff --git a/src/config.rs b/src/config.rs index b947a91..bfae643 100644 --- a/src/config.rs +++ b/src/config.rs @@ -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(); } diff --git a/src/utils.rs b/src/utils.rs index 92952c8..f232a50 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -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);