rustdesk/rustdesk-server
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk-server.git synced 2025-08-17 00:45:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename

Browse Source
This commit is contained in:
rustdesk 2021-04-03 22:32:14 +08:00
parent 6a3903df2c
commit a10bb34f6e
5 changed files with 36 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@ -528,7 +528,7 @@ dependencies = [
[[package]] [[package]]
name = "hbbs" name = "hbbs"
version = "1.0.0" version = "1.1.3"
dependencies = [ dependencies = [
"cc", "cc",
"clap", "clap",

2
Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "hbbs" name = "hbbs"
version = "1.0.0" version = "1.1.3"
authors = ["open-trade <info@opentradesolutions.com>"] authors = ["open-trade <info@opentradesolutions.com>"]
edition = "2018" edition = "2018"
build= "build.rs" build= "build.rs"

10
mod.rs
View File

@ -8,12 +8,12 @@ lazy_static::lazy_static! {
static ref STOP: Arc<Mutex<bool>> = Arc::new(Mutex::new(true)); static ref STOP: Arc<Mutex<bool>> = Arc::new(Mutex::new(true));
} }
pub fn bootstrap(license: &str, host: &str) { pub fn bootstrap(key: &str, host: &str) {
let port = rendezvous_server::DEFAULT_PORT; let port = rendezvous_server::DEFAULT_PORT;
let addr = format!("0.0.0.0:{}", port); let addr = format!("0.0.0.0:{}", port);
let addr2 = format!("0.0.0.0:{}", port.parse::<i32>().unwrap_or(0) - 1); let addr2 = format!("0.0.0.0:{}", port.parse::<i32>().unwrap_or(0) - 1);
let relay_servers: Vec<String> = vec![format!("{}:{}", host, relay_server::DEFAULT_PORT)]; let relay_servers: Vec<String> = vec![format!("{}:{}", host, relay_server::DEFAULT_PORT)];
let tmp_license = license.to_owned(); let tmp_key = key.to_owned();
std::thread::spawn(move || { std::thread::spawn(move || {
allow_err!(rendezvous_server::RendezvousServer::start( allow_err!(rendezvous_server::RendezvousServer::start(
&addr, &addr,
@ -22,15 +22,15 @@ pub fn bootstrap(license: &str, host: &str) {
0, 0,
Default::default(), Default::default(),
Default::default(), Default::default(),
&tmp_license, &tmp_key,
STOP.clone(), STOP.clone(),
)); ));
}); });
let tmp_license = license.to_owned(); let tmp_key = key.to_owned();
std::thread::spawn(move || { std::thread::spawn(move || {
allow_err!(relay_server::start( allow_err!(relay_server::start(
relay_server::DEFAULT_PORT, relay_server::DEFAULT_PORT,
&tmp_license, &tmp_key,
STOP.clone() STOP.clone()
)); ));
}); });

17
src/relay_server.rs
View File

@ -24,7 +24,10 @@ lazy_static::lazy_static! {
pub const DEFAULT_PORT: &'static str = "21117"; pub const DEFAULT_PORT: &'static str = "21117";
#[tokio::main(basic_scheduler)] #[tokio::main(basic_scheduler)]
pub async fn start(port: &str, license: &str, stop: Arc<Mutex<bool>>) -> ResultType<()> { pub async fn start(port: &str, key: &str, stop: Arc<Mutex<bool>>) -> ResultType<()> {
if !key.is_empty() {
log::info!("Key: {}", key);
}
let addr = format!("0.0.0.0:{}", port); let addr = format!("0.0.0.0:{}", port);
log::info!("Listening on tcp {}", addr); log::info!("Listening on tcp {}", addr);
let mut listener = new_listener(addr, false).await?; let mut listener = new_listener(addr, false).await?;
@ -34,18 +37,18 @@ pub async fn start(port: &str, license: &str, stop: Arc<Mutex<bool>>) -> ResultT
continue; continue;
} }
log::info!("Start"); log::info!("Start");
io_loop(&mut listener, license, stop.clone()).await; io_loop(&mut listener, key, stop.clone()).await;
} }
} }
async fn io_loop(listener: &mut TcpListener, license: &str, stop: Arc<Mutex<bool>>) { async fn io_loop(listener: &mut TcpListener, key: &str, stop: Arc<Mutex<bool>>) {
let mut timer = interval(Duration::from_millis(100)); let mut timer = interval(Duration::from_millis(100));
loop { loop {
tokio::select! { tokio::select! {
Ok((stream, addr)) = listener.accept() => { Ok((stream, addr)) = listener.accept() => {
let license = license.to_owned(); let key = key.to_owned();
tokio::spawn(async move { tokio::spawn(async move {
make_pair(FramedStream::from(stream), addr, &license).await.ok(); make_pair(FramedStream::from(stream), addr, &key).await.ok();
}); });
} }
_ = timer.tick() => { _ = timer.tick() => {
@ -58,12 +61,12 @@ async fn io_loop(listener: &mut TcpListener, license: &str, stop: Arc<Mutex<bool
} }
} }
async fn make_pair(stream: FramedStream, addr: SocketAddr, license: &str) -> ResultType<()> { async fn make_pair(stream: FramedStream, addr: SocketAddr, key: &str) -> ResultType<()> {
let mut stream = stream; let mut stream = stream;
if let Some(Ok(bytes)) = stream.next_timeout(30_000).await { if let Some(Ok(bytes)) = stream.next_timeout(30_000).await {
if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) { if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
if let Some(rendezvous_message::Union::request_relay(rf)) = msg_in.union { if let Some(rendezvous_message::Union::request_relay(rf)) = msg_in.union {
if !license.is_empty() && rf.licence_key != license { if !key.is_empty() && rf.licence_key != key {
return Ok(()); return Ok(());
} }
if !rf.uuid.is_empty() { if !rf.uuid.is_empty() {

36
src/rendezvous_server.rs
View File

@ -162,9 +162,12 @@ impl RendezvousServer {
serial: i32, serial: i32,
rendezvous_servers: Vec<String>, rendezvous_servers: Vec<String>,
software_url: String, software_url: String,
license: &str, key: &str,
stop: Arc<Mutex<bool>>, stop: Arc<Mutex<bool>>,
) -> ResultType<()> { ) -> ResultType<()> {
if !key.is_empty() {
log::info!("Key: {}", key);
}
log::info!("Listening on tcp/udp {}", addr); log::info!("Listening on tcp/udp {}", addr);
log::info!("Listening on tcp {}, extra port for NAT test", addr2); log::info!("Listening on tcp {}, extra port for NAT test", addr2);
log::info!("relay-servers={:?}", relay_servers); log::info!("relay-servers={:?}", relay_servers);
@ -197,7 +200,7 @@ impl RendezvousServer {
&mut listener, &mut listener,
&mut listener2, &mut listener2,
&mut socket, &mut socket,
license, key,
stop.clone(), stop.clone(),
) )
.await; .await;
@ -210,7 +213,7 @@ impl RendezvousServer {
listener: &mut TcpListener, listener: &mut TcpListener,
listener2: &mut TcpListener, listener2: &mut TcpListener,
socket: &mut FramedSocket, socket: &mut FramedSocket,
license: &str, key: &str,
stop: Arc<Mutex<bool>>, stop: Arc<Mutex<bool>>,
) { ) {
let mut timer = interval(Duration::from_millis(100)); let mut timer = interval(Duration::from_millis(100));
@ -226,7 +229,7 @@ impl RendezvousServer {
allow_err!(socket.send(&msg, addr).await); allow_err!(socket.send(&msg, addr).await);
} }
Some(Ok((bytes, addr))) = socket.next() => { Some(Ok((bytes, addr))) = socket.next() => {
allow_err!(self.handle_msg(&bytes, addr, socket, license).await); allow_err!(self.handle_msg(&bytes, addr, socket, key).await);
} }
Ok((stream, addr)) = listener2.accept() => { Ok((stream, addr)) = listener2.accept() => {
let stream = FramedStream::from(stream); let stream = FramedStream::from(stream);
@ -251,7 +254,7 @@ impl RendezvousServer {
let (a, mut b) = Framed::new(stream, BytesCodec::new()).split(); let (a, mut b) = Framed::new(stream, BytesCodec::new()).split();
let tcp_punch = self.tcp_punch.clone(); let tcp_punch = self.tcp_punch.clone();
let mut rs = self.clone(); let mut rs = self.clone();
let license = license.to_owned(); let key = key.to_owned();
tokio::spawn(async move { tokio::spawn(async move {
let mut sender = Some(a); let mut sender = Some(a);
while let Ok(Some(Ok(bytes))) = timeout(30_000, b.next()).await { while let Ok(Some(Ok(bytes))) = timeout(30_000, b.next()).await {
@ -262,7 +265,7 @@ impl RendezvousServer {
if let Some(sender) = sender.take() { if let Some(sender) = sender.take() {
tcp_punch.lock().unwrap().insert(addr, sender); tcp_punch.lock().unwrap().insert(addr, sender);
} }
allow_err!(rs.handle_tcp_punch_hole_request(addr, ph, &license).await); allow_err!(rs.handle_tcp_punch_hole_request(addr, ph, &key).await);
} }
Some(rendezvous_message::Union::request_relay(mut rf)) => { Some(rendezvous_message::Union::request_relay(mut rf)) => {
// there maybe several attempt, so sender can be none // there maybe several attempt, so sender can be none
@ -342,7 +345,7 @@ impl RendezvousServer {
bytes: &BytesMut, bytes: &BytesMut,
addr: SocketAddr, addr: SocketAddr,
socket: &mut FramedSocket, socket: &mut FramedSocket,
license: &str, key: &str,
) -> ResultType<()> { ) -> ResultType<()> {
if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) { if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
match msg_in.union { match msg_in.union {
@ -392,14 +395,13 @@ impl RendezvousServer {
} }
Some(rendezvous_message::Union::punch_hole_request(ph)) => { Some(rendezvous_message::Union::punch_hole_request(ph)) => {
if self.pm.is_in_memory(&ph.id) { if self.pm.is_in_memory(&ph.id) {
self.handle_udp_punch_hole_request(addr, ph, license) self.handle_udp_punch_hole_request(addr, ph, key).await?;
.await?;
} else { } else {
// not in memory, fetch from db with spawn in case blocking me // not in memory, fetch from db with spawn in case blocking me
let mut me = self.clone(); let mut me = self.clone();
let license = license.to_owned(); let key = key.to_owned();
tokio::spawn(async move { tokio::spawn(async move {
allow_err!(me.handle_udp_punch_hole_request(addr, ph, &license).await); allow_err!(me.handle_udp_punch_hole_request(addr, ph, &key).await);
}); });
} }
} }
@ -572,9 +574,9 @@ impl RendezvousServer {
&mut self, &mut self,
addr: SocketAddr, addr: SocketAddr,
ph: PunchHoleRequest, ph: PunchHoleRequest,
license: &str, key: &str,
) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> { ) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> {
if !license.is_empty() && ph.licence_key != license { if !key.is_empty() && ph.licence_key != key {
let mut msg_out = RendezvousMessage::new(); let mut msg_out = RendezvousMessage::new();
msg_out.set_punch_hole_response(PunchHoleResponse { msg_out.set_punch_hole_response(PunchHoleResponse {
failure: punch_hole_response::Failure::LICENCE_MISMATCH.into(), failure: punch_hole_response::Failure::LICENCE_MISMATCH.into(),
@ -686,9 +688,9 @@ impl RendezvousServer {
&mut self, &mut self,
addr: SocketAddr, addr: SocketAddr,
ph: PunchHoleRequest, ph: PunchHoleRequest,
license: &str, key: &str,
) -> ResultType<()> { ) -> ResultType<()> {
let (msg, to_addr) = self.handle_punch_hole_request(addr, ph, license).await?; let (msg, to_addr) = self.handle_punch_hole_request(addr, ph, key).await?;
if let Some(addr) = to_addr { if let Some(addr) = to_addr {
self.tx.send((msg, addr))?; self.tx.send((msg, addr))?;
} else { } else {
@ -702,9 +704,9 @@ impl RendezvousServer {
&mut self, &mut self,
addr: SocketAddr, addr: SocketAddr,
ph: PunchHoleRequest, ph: PunchHoleRequest,
license: &str, key: &str,
) -> ResultType<()> { ) -> ResultType<()> {
let (msg, to_addr) = self.handle_punch_hole_request(addr, ph, license).await?; let (msg, to_addr) = self.handle_punch_hole_request(addr, ph, key).await?;
self.tx.send(( self.tx.send((
msg, msg,
match to_addr { match to_addr {