open-trade лет назад: 4
Родитель
Сommit
474b8abf18
5 измененных файлов с 26 добавлено и 12 удалено
  1. 2 0
      mod.rs
  2. 1 1
      src/hbbr.rs
  3. 1 0
      src/main.rs
  4. 7 3
      src/relay_server.rs
  5. 15 8
      src/rendezvous_server.rs

+ 2 - 0
mod.rs

@@ -29,12 +29,14 @@ pub fn start() {
29
             0,
29
             0,
30
             Default::default(),
30
             Default::default(),
31
             Default::default(),
31
             Default::default(),
32
+            "",
32
             STOP.clone(),
33
             STOP.clone(),
33
         ));
34
         ));
34
     });
35
     });
35
     std::thread::spawn(|| {
36
     std::thread::spawn(|| {
36
         allow_err!(relay_server::start(
37
         allow_err!(relay_server::start(
37
             relay_server::DEFAULT_PORT,
38
             relay_server::DEFAULT_PORT,
39
+            "",
38
             STOP.clone()
40
             STOP.clone()
39
         ));
41
         ));
40
     });
42
     });

+ 1 - 1
src/hbbr.rs

@@ -17,6 +17,6 @@ fn main() -> ResultType<()> {
17
         .args_from_usage(&args)
17
         .args_from_usage(&args)
18
         .get_matches();
18
         .get_matches();
19
     let stop: Arc<Mutex<bool>> = Default::default();
19
     let stop: Arc<Mutex<bool>> = Default::default();
20
-    start(matches.value_of("port").unwrap_or(DEFAULT_PORT), stop)?;
20
+    start(matches.value_of("port").unwrap_or(DEFAULT_PORT), "", stop)?;
21
     Ok(())
21
     Ok(())
22
 }
22
 }

+ 1 - 0
src/main.rs

@@ -83,6 +83,7 @@ fn main() -> ResultType<()> {
83
         serial,
83
         serial,
84
         rendezvous_servers,
84
         rendezvous_servers,
85
         get_arg("software-url", ""),
85
         get_arg("software-url", ""),
86
+        "",
86
         stop,
87
         stop,
87
     )?;
88
     )?;
88
     Ok(())
89
     Ok(())

+ 7 - 3
src/relay_server.rs

@@ -23,7 +23,7 @@ lazy_static::lazy_static! {
23
 pub const DEFAULT_PORT: &'static str = "21117";
23
 pub const DEFAULT_PORT: &'static str = "21117";
24
 
24
 
25
 #[tokio::main(basic_scheduler)]
25
 #[tokio::main(basic_scheduler)]
26
-pub async fn start(port: &str, stop: Arc<Mutex<bool>>) -> ResultType<()> {
26
+pub async fn start(port: &str, license: &str, stop: Arc<Mutex<bool>>) -> ResultType<()> {
27
     let addr = format!("0.0.0.0:{}", port);
27
     let addr = format!("0.0.0.0:{}", port);
28
     log::info!("Listening on {}", addr);
28
     log::info!("Listening on {}", addr);
29
     let mut timer = interval(Duration::from_millis(300));
29
     let mut timer = interval(Duration::from_millis(300));
@@ -31,8 +31,9 @@ pub async fn start(port: &str, stop: Arc<Mutex<bool>>) -> ResultType<()> {
31
     loop {
31
     loop {
32
         tokio::select! {
32
         tokio::select! {
33
             Ok((stream, addr)) = listener.accept() => {
33
             Ok((stream, addr)) = listener.accept() => {
34
+                let license = license.to_owned();
34
                 tokio::spawn(async move {
35
                 tokio::spawn(async move {
35
-                    make_pair(FramedStream::from(stream), addr).await.ok();
36
+                    make_pair(FramedStream::from(stream), addr, &license).await.ok();
36
                 });
37
                 });
37
             }
38
             }
38
             _ = timer.tick() => {
39
             _ = timer.tick() => {
@@ -46,11 +47,14 @@ pub async fn start(port: &str, stop: Arc<Mutex<bool>>) -> ResultType<()> {
46
     Ok(())
47
     Ok(())
47
 }
48
 }
48
 
49
 
49
-async fn make_pair(stream: FramedStream, addr: SocketAddr) -> ResultType<()> {
50
+async fn make_pair(stream: FramedStream, addr: SocketAddr, license: &str) -> ResultType<()> {
50
     let mut stream = stream;
51
     let mut stream = stream;
51
     if let Some(Ok(bytes)) = stream.next_timeout(30_000).await {
52
     if let Some(Ok(bytes)) = stream.next_timeout(30_000).await {
52
         if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
53
         if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
53
             if let Some(rendezvous_message::Union::request_relay(rf)) = msg_in.union {
54
             if let Some(rendezvous_message::Union::request_relay(rf)) = msg_in.union {
55
+                if !license.is_empty() && rf.licence_key != license {
56
+                    return Ok(());
57
+                }
54
                 if !rf.uuid.is_empty() {
58
                 if !rf.uuid.is_empty() {
55
                     let peer = PEERS.lock().unwrap().remove(&rf.uuid);
59
                     let peer = PEERS.lock().unwrap().remove(&rf.uuid);
56
                     if let Some(peer) = peer {
60
                     if let Some(peer) = peer {

+ 15 - 8
src/rendezvous_server.rs

@@ -124,7 +124,6 @@ impl PeerMap {
124
 }
124
 }
125
 
125
 
126
 const REG_TIMEOUT: i32 = 30_000;
126
 const REG_TIMEOUT: i32 = 30_000;
127
-pub const LICENSE_KEY: &'static str = "";
128
 type Sink = SplitSink<Framed<TcpStream, BytesCodec>, Bytes>;
127
 type Sink = SplitSink<Framed<TcpStream, BytesCodec>, Bytes>;
129
 type Sender = mpsc::UnboundedSender<(RendezvousMessage, SocketAddr)>;
128
 type Sender = mpsc::UnboundedSender<(RendezvousMessage, SocketAddr)>;
130
 static mut ROTATION_RELAY_SERVER: usize = 0;
129
 static mut ROTATION_RELAY_SERVER: usize = 0;
@@ -150,6 +149,7 @@ impl RendezvousServer {
150
         serial: i32,
149
         serial: i32,
151
         rendezvous_servers: Vec<String>,
150
         rendezvous_servers: Vec<String>,
152
         software_url: String,
151
         software_url: String,
152
+        license: &str,
153
         stop: Arc<Mutex<bool>>,
153
         stop: Arc<Mutex<bool>>,
154
     ) -> ResultType<()> {
154
     ) -> ResultType<()> {
155
         let mut socket = FramedSocket::new(addr).await?;
155
         let mut socket = FramedSocket::new(addr).await?;
@@ -183,7 +183,7 @@ impl RendezvousServer {
183
                     allow_err!(socket.send(&msg, addr).await);
183
                     allow_err!(socket.send(&msg, addr).await);
184
                 }
184
                 }
185
                 Some(Ok((bytes, addr))) = socket.next() => {
185
                 Some(Ok((bytes, addr))) = socket.next() => {
186
-                    allow_err!(rs.handle_msg(&bytes, addr, &mut socket).await);
186
+                    allow_err!(rs.handle_msg(&bytes, addr, &mut socket, license).await);
187
                 }
187
                 }
188
                 Ok((stream, addr)) = listener2.accept() => {
188
                 Ok((stream, addr)) = listener2.accept() => {
189
                     let stream = FramedStream::from(stream);
189
                     let stream = FramedStream::from(stream);
@@ -208,6 +208,7 @@ impl RendezvousServer {
208
                     let (a, mut b) = Framed::new(stream, BytesCodec::new()).split();
208
                     let (a, mut b) = Framed::new(stream, BytesCodec::new()).split();
209
                     let tcp_punch = rs.tcp_punch.clone();
209
                     let tcp_punch = rs.tcp_punch.clone();
210
                     let mut rs = rs.clone();
210
                     let mut rs = rs.clone();
211
+                    let license = license.to_owned();
211
                     tokio::spawn(async move {
212
                     tokio::spawn(async move {
212
                         let mut sender = Some(a);
213
                         let mut sender = Some(a);
213
                         while let Ok(Some(Ok(bytes))) = timeout(30_000, b.next()).await {
214
                         while let Ok(Some(Ok(bytes))) = timeout(30_000, b.next()).await {
@@ -218,7 +219,7 @@ impl RendezvousServer {
218
                                         if let Some(sender) = sender.take() {
219
                                         if let Some(sender) = sender.take() {
219
                                             tcp_punch.lock().unwrap().insert(addr, sender);
220
                                             tcp_punch.lock().unwrap().insert(addr, sender);
220
                                         }
221
                                         }
221
-                                        allow_err!(rs.handle_tcp_punch_hole_request(addr, ph).await);
222
+                                        allow_err!(rs.handle_tcp_punch_hole_request(addr, ph, &license).await);
222
                                     }
223
                                     }
223
                                     Some(rendezvous_message::Union::request_relay(mut rf)) => {
224
                                     Some(rendezvous_message::Union::request_relay(mut rf)) => {
224
                                         // there maybe several attempt, so sender can be none
225
                                         // there maybe several attempt, so sender can be none
@@ -299,6 +300,7 @@ impl RendezvousServer {
299
         bytes: &BytesMut,
300
         bytes: &BytesMut,
300
         addr: SocketAddr,
301
         addr: SocketAddr,
301
         socket: &mut FramedSocket,
302
         socket: &mut FramedSocket,
303
+        license: &str,
302
     ) -> ResultType<()> {
304
     ) -> ResultType<()> {
303
         if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
305
         if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
304
             match msg_in.union {
306
             match msg_in.union {
@@ -348,12 +350,14 @@ impl RendezvousServer {
348
                 }
350
                 }
349
                 Some(rendezvous_message::Union::punch_hole_request(ph)) => {
351
                 Some(rendezvous_message::Union::punch_hole_request(ph)) => {
350
                     if self.pm.is_in_memory(&ph.id) {
352
                     if self.pm.is_in_memory(&ph.id) {
351
-                        self.handle_udp_punch_hole_request(addr, ph).await?;
353
+                        self.handle_udp_punch_hole_request(addr, ph, license)
354
+                            .await?;
352
                     } else {
355
                     } else {
353
                         // not in memory, fetch from db with spawn in case blocking me
356
                         // not in memory, fetch from db with spawn in case blocking me
354
                         let mut me = self.clone();
357
                         let mut me = self.clone();
358
+                        let license = license.to_owned();
355
                         tokio::spawn(async move {
359
                         tokio::spawn(async move {
356
-                            allow_err!(me.handle_udp_punch_hole_request(addr, ph).await);
360
+                            allow_err!(me.handle_udp_punch_hole_request(addr, ph, &license).await);
357
                         });
361
                         });
358
                     }
362
                     }
359
                 }
363
                 }
@@ -526,8 +530,9 @@ impl RendezvousServer {
526
         &mut self,
530
         &mut self,
527
         addr: SocketAddr,
531
         addr: SocketAddr,
528
         ph: PunchHoleRequest,
532
         ph: PunchHoleRequest,
533
+        license: &str,
529
     ) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> {
534
     ) -> ResultType<(RendezvousMessage, Option<SocketAddr>)> {
530
-        if ph.licence_key != LICENSE_KEY {
535
+        if !license.is_empty() && ph.licence_key != license {
531
             let mut msg_out = RendezvousMessage::new();
536
             let mut msg_out = RendezvousMessage::new();
532
             msg_out.set_punch_hole_response(PunchHoleResponse {
537
             msg_out.set_punch_hole_response(PunchHoleResponse {
533
                 failure: punch_hole_response::Failure::LICENCE_MISMATCH.into(),
538
                 failure: punch_hole_response::Failure::LICENCE_MISMATCH.into(),
@@ -639,8 +644,9 @@ impl RendezvousServer {
639
         &mut self,
644
         &mut self,
640
         addr: SocketAddr,
645
         addr: SocketAddr,
641
         ph: PunchHoleRequest,
646
         ph: PunchHoleRequest,
647
+        license: &str,
642
     ) -> ResultType<()> {
648
     ) -> ResultType<()> {
643
-        let (msg, to_addr) = self.handle_punch_hole_request(addr, ph).await?;
649
+        let (msg, to_addr) = self.handle_punch_hole_request(addr, ph, license).await?;
644
         if let Some(addr) = to_addr {
650
         if let Some(addr) = to_addr {
645
             self.tx.send((msg, addr))?;
651
             self.tx.send((msg, addr))?;
646
         } else {
652
         } else {
@@ -654,8 +660,9 @@ impl RendezvousServer {
654
         &mut self,
660
         &mut self,
655
         addr: SocketAddr,
661
         addr: SocketAddr,
656
         ph: PunchHoleRequest,
662
         ph: PunchHoleRequest,
663
+        license: &str,
657
     ) -> ResultType<()> {
664
     ) -> ResultType<()> {
658
-        let (msg, to_addr) = self.handle_punch_hole_request(addr, ph).await?;
665
+        let (msg, to_addr) = self.handle_punch_hole_request(addr, ph, license).await?;
659
         self.tx.send((
666
         self.tx.send((
660
             msg,
667
             msg,
661
             match to_addr {
668
             match to_addr {