license

Cargo.toml

@@ -13,13 +13,13 @@ path = "src/hbbr/main.rs"
 
 [dependencies]
 hbb_common = { path = "libs/hbb_common" }
-sled = "0.31"
+sled = "0.34"
 serde_derive = "1.0"
 serde = "1.0"
 serde_json = "1.0"
 lazy_static = "1.4"
 clap = "2.33"
-rust-ini = "0.15"
+rust-ini = "0.16"
 
 [build-dependencies]
 cc = "1.0"

libs/hbb_common

@@ -1 +1 @@
-Subproject commit 3f862eaa423823b6a4c9a62e6b36f3b692cfd06f
+Subproject commit 9a236b24483f3215a911a8f6e6171972467ccd24

src/main.rs

@@ -16,8 +16,14 @@ async fn main() -> ResultType<()> {
         -s, --serial=[NUMBER(default=0)] 'Sets configure update serial number'
         -R, --rendezvous-servers=[HOSTS] 'Sets rendezvous servers, seperated by colon'
         -u, --software-url=[URL] 'Sets download url of RustDesk software of newest version'
-    -r, --relay-server=[HOST] 'Sets the default relay server'",
+        -r, --relay-server{}=[HOST] 'Sets the default relay server{}'",
-        DEFAULT_PORT
+        DEFAULT_PORT,
+        if LICENSE_KEY.is_empty() { "" } else { "s" },
+        if LICENSE_KEY.is_empty() {
+            ""
+        } else {
+            "s, seperated by colon, only available for licensed users"
+        }
     );
     let matches = App::new("hbbs")
         .version(crate::VERSION)
@@ -44,28 +50,38 @@ async fn main() -> ResultType<()> {
         return default.to_owned();
     };
     let port = get_arg("port", DEFAULT_PORT);
-    let mut relay_server = get_arg("relay-server", "");
+    let mut relay_servers: Vec<String> = get_arg(
-    if let Err(err) = test_if_valid_server(&relay_server) {
+        &format!(
-        relay_server = "".to_owned();
+            "relay-server{}",
-        log::error!("Invalid relay-server: {}", err);
+            if LICENSE_KEY.is_empty() { "" } else { "s" }
+        ),
+        "",
+    )
+    .split(",")
+    .filter(|x| !x.is_empty() && test_if_valid_server(x, "relay-server").is_ok())
+    .map(|x| x.to_owned())
+    .collect();
+    if relay_servers.len() > 1 && LICENSE_KEY.is_empty() {
+        log::error!("Only support multiple relay servers for licenced users");
+        relay_servers = vec![relay_servers[0].clone()];
     }
     let serial: i32 = get_arg("serial", "").parse().unwrap_or(0);
     let rendezvous_servers: Vec<String> = get_arg("rendezvous-servers", "")
         .split(",")
-        .filter(|x| test_if_valid_server(x).is_ok())
+        .filter(|x| !x.is_empty() && test_if_valid_server(x, "rendezvous-server").is_ok())
         .map(|x| x.to_owned())
         .collect();
     let addr = format!("0.0.0.0:{}", port);
     log::info!("Listening on {}", addr);
     let addr2 = format!("0.0.0.0:{}", port.parse::<i32>().unwrap_or(0) - 1);
     log::info!("Listening on {}, extra port for NAT test", addr2);
-    log::info!("relay-server={}", relay_server);
+    log::info!("relay-servers={:?}", relay_servers);
     log::info!("serial={}", serial);
     log::info!("rendezvous-servers={:?}", rendezvous_servers);
     RendezvousServer::start(
         &addr,
         &addr2,
-        relay_server,
+        relay_servers,
         serial,
         rendezvous_servers,
         get_arg("software-url", ""),

src/rendezvous_server.rs

@@ -117,15 +117,17 @@ impl PeerMap {
 }
 
 const REG_TIMEOUT: i32 = 30_000;
+pub const LICENSE_KEY: &'static str = "";
 type Sink = SplitSink<Framed<TcpStream, BytesCodec>, Bytes>;
 type Sender = mpsc::UnboundedSender<(RendezvousMessage, SocketAddr)>;
+static mut ROTATION_RELAY_SERVER: usize = 0;
 
 #[derive(Clone)]
 pub struct RendezvousServer {
     tcp_punch: Arc<Mutex<HashMap<SocketAddr, Sink>>>,
     pm: PeerMap,
     tx: Sender,
-    relay_server: String,
+    relay_servers: Vec<String>,
     serial: i32,
     rendezvous_servers: Vec<String>,
     version: String,
@@ -136,7 +138,7 @@ impl RendezvousServer {
     pub async fn start(
         addr: &str,
         addr2: &str,
-        relay_server: String,
+        relay_servers: Vec<String>,
         serial: i32,
         rendezvous_servers: Vec<String>,
         software_url: String,
@@ -151,7 +153,7 @@ impl RendezvousServer {
             tcp_punch: Arc::new(Mutex::new(HashMap::new())),
             pm: PeerMap::new()?,
             tx: tx.clone(),
-            relay_server,
+            relay_servers,
             serial,
             rendezvous_servers,
             version,
@@ -241,7 +243,7 @@ impl RendezvousServer {
                                         let mut res = TestNatResponse {
                                             port: addr.port() as _,
                                             ..Default::default()
-                                        }
+                                        };
                                         if rs.serial > tar.serial {
                                             let mut cu = ConfigUpdate::new();
                                             cu.serial = rs.serial;
@@ -352,7 +354,10 @@ impl RendezvousServer {
                         self.rendezvous_servers = cu
                             .rendezvous_servers
                             .drain(..)
-                            .filter(|x| test_if_valid_server(x).is_ok())
+                            .filter(|x| {
+                                !x.is_empty()
+                                    && test_if_valid_server(x, "rendezvous-server").is_ok()
+                            })
                             .collect();
                         log::info!(
                             "configure updated: serial={} rendezvous-servers={:?}",
@@ -505,6 +510,14 @@ impl RendezvousServer {
         addr: SocketAddr,
         ph: PunchHoleRequest,
     ) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> {
+        if ph.licence_key != LICENSE_KEY {
+            let mut msg_out = RendezvousMessage::new();
+            msg_out.set_punch_hole_response(PunchHoleResponse {
+                failure: punch_hole_response::Failure::LICENCE_MISMATCH.into(),
+                ..Default::default()
+            });
+            return Ok((msg_out, None));
+        }
         let id = ph.id;
         // punch hole request from A, relay to B,
         // check if in same intranet first,
@@ -539,9 +552,13 @@ impl RendezvousServer {
                     &peer.socket_addr,
                     &addr
                 );
+                let i = unsafe {
+                    ROTATION_RELAY_SERVER += 1;
+                    ROTATION_RELAY_SERVER % self.relay_servers.len()
+                };
                 msg_out.set_fetch_local_addr(FetchLocalAddr {
                     socket_addr,
-                    relay_server: self.relay_server.clone(),
+                    relay_server: self.relay_servers[i].clone(),
                     ..Default::default()
                 });
             } else {
@@ -551,10 +568,14 @@ impl RendezvousServer {
                     &peer.socket_addr,
                     &addr
                 );
+                let i = unsafe {
+                    ROTATION_RELAY_SERVER += 1;
+                    ROTATION_RELAY_SERVER % self.relay_servers.len()
+                };
                 msg_out.set_punch_hole(PunchHole {
                     socket_addr,
                     nat_type: ph.nat_type,
-                    relay_server: self.relay_server.clone(),
+                    relay_server: self.relay_servers[i].clone(),
                     ..Default::default()
                 });
             }
@@ -629,10 +650,14 @@ impl RendezvousServer {
     }
 }
 
-pub fn test_if_valid_server(host: &str) -> ResultType<SocketAddr> {
+pub fn test_if_valid_server(host: &str, name: &str) -> ResultType<SocketAddr> {
-    if host.contains(":") {
+    let res = if host.contains(":") {
         hbb_common::to_socket_addr(host)
     } else {
         hbb_common::to_socket_addr(&format!("{}:{}", host, 0))
+    };
+    if res.is_err() {
+        log::error!("Invalid {} {}: {:?}", name, host, res);
     }
+    res
 }