Browse Source

https://github.com/rustdesk/rustdesk-server/issues/24

rustdesk 3 years ago
parent
commit
acaee5b7a4
1 changed files with 30 additions and 47 deletions
  1. 30 47
      src/rendezvous_server.rs

+ 30 - 47
src/rendezvous_server.rs

@@ -89,12 +89,7 @@ enum LoopFailure {
89
 
89
 
90
 impl RendezvousServer {
90
 impl RendezvousServer {
91
     #[tokio::main(flavor = "multi_thread")]
91
     #[tokio::main(flavor = "multi_thread")]
92
-    pub async fn start(
93
-        port: i32,
94
-        serial: i32,
95
-        key: &str,
96
-        rmem: usize,
97
-    ) -> ResultType<()> {
92
+    pub async fn start(port: i32, serial: i32, key: &str, rmem: usize) -> ResultType<()> {
98
         let (key, sk) = Self::get_server_sk(key);
93
         let (key, sk) = Self::get_server_sk(key);
99
         let addr = format!("0.0.0.0:{}", port);
94
         let addr = format!("0.0.0.0:{}", port);
100
         let addr2 = format!("0.0.0.0:{}", port - 1);
95
         let addr2 = format!("0.0.0.0:{}", port - 1);
@@ -112,6 +107,17 @@ impl RendezvousServer {
112
         if !version.is_empty() {
107
         if !version.is_empty() {
113
             log::info!("software_url: {}, version: {}", software_url, version);
108
             log::info!("software_url: {}, version: {}", software_url, version);
114
         }
109
         }
110
+        let mask = get_arg("mask").parse().ok();
111
+        let local_ip = if mask.is_none() {
112
+            "".to_owned()
113
+        } else {
114
+            get_arg_or(
115
+                "local-ip",
116
+                local_ip_address::local_ip()
117
+                    .map(|x| x.to_string())
118
+                    .unwrap_or_default(),
119
+            )
120
+        };
115
         let mut rs = Self {
121
         let mut rs = Self {
116
             tcp_punch: Arc::new(Mutex::new(HashMap::new())),
122
             tcp_punch: Arc::new(Mutex::new(HashMap::new())),
117
             pm,
123
             pm,
@@ -124,13 +130,8 @@ impl RendezvousServer {
124
                 version,
130
                 version,
125
                 software_url,
131
                 software_url,
126
                 sk,
132
                 sk,
127
-                mask: get_arg("mask").parse().ok(),
128
-                local_ip: get_arg_or(
129
-                    "local-ip",
130
-                    local_ip_address::local_ip()
131
-                        .map(|x| x.to_string())
132
-                        .unwrap_or_default(),
133
-                ),
133
+                mask,
134
+                local_ip,
134
             }),
135
             }),
135
         };
136
         };
136
         log::info!("mask: {:?}", rs.inner.mask);
137
         log::info!("mask: {:?}", rs.inner.mask);
@@ -498,9 +499,13 @@ impl RendezvousServer {
498
                         rr.set_pk(pk);
499
                         rr.set_pk(pk);
499
                     }
500
                     }
500
                     let mut msg_out = RendezvousMessage::new();
501
                     let mut msg_out = RendezvousMessage::new();
501
-                    if self.is_lan(addr_b) {
502
-                        // https://github.com/rustdesk/rustdesk-server/issues/24
503
-                        rr.relay_server = self.inner.local_ip.clone();
502
+                    if !rr.relay_server.is_empty() {
503
+                        if self.is_lan(addr_b) {
504
+                            // https://github.com/rustdesk/rustdesk-server/issues/24
505
+                            rr.relay_server = self.inner.local_ip.clone();
506
+                        } else if rr.relay_server == self.inner.local_ip {
507
+                            rr.relay_server = self.get_relay_server(addr.ip(), addr_b.ip());
508
+                        }
504
                     }
509
                     }
505
                     msg_out.set_relay_response(rr);
510
                     msg_out.set_relay_response(rr);
506
                     allow_err!(self.send_to_tcp_sync(msg_out, addr_b).await);
511
                     allow_err!(self.send_to_tcp_sync(msg_out, addr_b).await);
@@ -659,6 +664,7 @@ impl RendezvousServer {
659
         key: &str,
664
         key: &str,
660
         ws: bool,
665
         ws: bool,
661
     ) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> {
666
     ) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> {
667
+        let mut ph = ph;
662
         if !key.is_empty() && ph.licence_key != key {
668
         if !key.is_empty() && ph.licence_key != key {
663
             let mut msg_out = RendezvousMessage::new();
669
             let mut msg_out = RendezvousMessage::new();
664
             msg_out.set_punch_hole_response(PunchHoleResponse {
670
             msg_out.set_punch_hole_response(PunchHoleResponse {
@@ -689,20 +695,13 @@ impl RendezvousServer {
689
             let mut msg_out = RendezvousMessage::new();
695
             let mut msg_out = RendezvousMessage::new();
690
             let peer_is_lan = self.is_lan(peer_addr);
696
             let peer_is_lan = self.is_lan(peer_addr);
691
             let is_lan = self.is_lan(addr);
697
             let is_lan = self.is_lan(addr);
698
+            let mut relay_server = self.get_relay_server(addr.ip(), peer_addr.ip());
692
             if unsafe { ALWAYS_USE_RELAY } || (peer_is_lan ^ is_lan) {
699
             if unsafe { ALWAYS_USE_RELAY } || (peer_is_lan ^ is_lan) {
693
-                let relay_server = if peer_is_lan {
700
+                if peer_is_lan {
694
                     // https://github.com/rustdesk/rustdesk-server/issues/24
701
                     // https://github.com/rustdesk/rustdesk-server/issues/24
695
-                    self.inner.local_ip.clone()
696
-                } else {
697
-                    self.get_relay_server(addr.ip(), peer_addr.ip())
698
-                };
699
-                if !relay_server.is_empty() {
700
-                    msg_out.set_request_relay(RequestRelay {
701
-                        relay_server,
702
-                        ..Default::default()
703
-                    });
704
-                    return Ok((msg_out, Some(peer_addr)));
702
+                    relay_server = self.inner.local_ip.clone()
705
                 }
703
                 }
704
+                ph.nat_type = NatType::SYMMETRIC.into(); // will force relay
706
             }
705
             }
707
             let same_intranet = !ws
706
             let same_intranet = !ws
708
                 && match peer_addr {
707
                 && match peer_addr {
@@ -716,7 +715,6 @@ impl RendezvousServer {
716
                     },
715
                     },
717
                 };
716
                 };
718
             let socket_addr = AddrMangle::encode(addr);
717
             let socket_addr = AddrMangle::encode(addr);
719
-            let relay_server = self.get_relay_server(addr.ip(), peer_addr.ip());
720
             if same_intranet {
718
             if same_intranet {
721
                 log::debug!(
719
                 log::debug!(
722
                     "Fetch local addr {:?} {:?} request from {:?}",
720
                     "Fetch local addr {:?} {:?} request from {:?}",
@@ -1044,21 +1042,12 @@ impl RendezvousServer {
1044
         });
1042
         });
1045
     }
1043
     }
1046
 
1044
 
1047
-    async fn handle_listener(
1048
-        &self,
1049
-        stream: TcpStream,
1050
-        addr: SocketAddr,
1051
-        key: &str,
1052
-        ws: bool,
1053
-    ) {
1045
+    async fn handle_listener(&self, stream: TcpStream, addr: SocketAddr, key: &str, ws: bool) {
1054
         log::debug!("Tcp connection from {:?}, ws: {}", addr, ws);
1046
         log::debug!("Tcp connection from {:?}, ws: {}", addr, ws);
1055
         let mut rs = self.clone();
1047
         let mut rs = self.clone();
1056
         let key = key.to_owned();
1048
         let key = key.to_owned();
1057
         tokio::spawn(async move {
1049
         tokio::spawn(async move {
1058
-            allow_err!(
1059
-                rs.handle_listener_inner(stream, addr, &key, ws)
1060
-                    .await
1061
-            );
1050
+            allow_err!(rs.handle_listener_inner(stream, addr, &key, ws).await);
1062
         });
1051
         });
1063
     }
1052
     }
1064
 
1053
 
@@ -1078,10 +1067,7 @@ impl RendezvousServer {
1078
             while let Ok(Some(Ok(msg))) = timeout(30_000, b.next()).await {
1067
             while let Ok(Some(Ok(msg))) = timeout(30_000, b.next()).await {
1079
                 match msg {
1068
                 match msg {
1080
                     tungstenite::Message::Binary(bytes) => {
1069
                     tungstenite::Message::Binary(bytes) => {
1081
-                        if !self
1082
-                            .handle_tcp(&bytes, &mut sink, addr, key, ws)
1083
-                            .await
1084
-                        {
1070
+                        if !self.handle_tcp(&bytes, &mut sink, addr, key, ws).await {
1085
                             break;
1071
                             break;
1086
                         }
1072
                         }
1087
                     }
1073
                     }
@@ -1092,10 +1078,7 @@ impl RendezvousServer {
1092
             let (a, mut b) = Framed::new(stream, BytesCodec::new()).split();
1078
             let (a, mut b) = Framed::new(stream, BytesCodec::new()).split();
1093
             sink = Some(Sink::TcpStream(a));
1079
             sink = Some(Sink::TcpStream(a));
1094
             while let Ok(Some(Ok(bytes))) = timeout(30_000, b.next()).await {
1080
             while let Ok(Some(Ok(bytes))) = timeout(30_000, b.next()).await {
1095
-                if !self
1096
-                    .handle_tcp(&bytes, &mut sink, addr, key, ws)
1097
-                    .await
1098
-                {
1081
+                if !self.handle_tcp(&bytes, &mut sink, addr, key, ws).await {
1099
                     break;
1082
                     break;
1100
                 }
1083
                 }
1101
             }
1084
             }