source code

.gitignore

+/target
+.idea
+.DS_Store
+src/ui/inline.rs
+extractor
+__pycache__
+src/version.rs
+*dmg

Cargo.toml

+[package]
+name = "rustdesk"
+version = "1.1.2"
+authors = ["rustdesk <info@rustdesk.com>"]
+edition = "2018"
+build= "build.rs"
+description = "A remote control software."
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"] 
+
+[features]
+inline = []
+cli = []
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+whoami = "0.9"
+scrap = { path = "libs/scrap" }
+hbb_common = { path = "libs/hbb_common" }
+enigo = { path = "libs/enigo" }
+serde_derive = "1.0"
+serde = "1.0"
+serde_json = "1.0"
+cfg-if = "1.0"
+lazy_static = "1.4"
+sha2 = "0.9"
+repng = "0.2"
+libc = "0.2"
+parity-tokio-ipc = { path = "libs/parity-tokio-ipc" }
+flexi_logger = "0.16"
+runas = "0.2"
+magnum-opus = { path = "libs/magnum-opus" }
+dasp = { version = "0.11", features = ["signal", "interpolate-linear", "interpolate"] }
+async-trait = "0.1"
+crc32fast = "1.2"
+uuid = { version = "0.8", features = ["v4"] }
+copypasta = "0.7"
+clap = "2.33"
+rpassword = "5.0"
+
+[target.'cfg(not(any(target_os = "android")))'.dependencies]
+cpal = { git = "https://github.com/rustaudio/cpal" }
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+machine-uid = "0.2"
+mac_address = "1.1"
+sciter-rs = { git = "https://github.com/sciter-sdk/rust-sciter" }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+systray = { path = "libs/systray-rs" }
+winapi = { version = "0.3", features = ["winuser"] }
+winreg = "0.7"
+windows-service = { git = 'https://github.com/mullvad/windows-service-rs.git' }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+objc = "0.2"
+cocoa = "0.24"
+dispatch = "0.2"
+core-foundation = "0.9"
+core-graphics = "0.22"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+libpulse-simple-binding = "2.16"
+libpulse-binding = "2.16"
+rust-pulsectl = { path = "libs/pulsectl" }
+ctrlc = "3.1"
+
+[target.'cfg(not(any(target_os = "windows", target_os = "android", target_os = "ios")))'.dependencies]
+psutil = "3.2"
+
+[target.'cfg(target_os = "android")'.dependencies]
+android_logger = "0.9"
+
+[workspace]
+members = ["libs/scrap", "libs/hbb_common", "libs/enigo"]
+
+[package.metadata.winres]
+LegalCopyright = "Copyright © 2020"
+# this FileDescription overrides package.description
+FileDescription = "RustDesk"
+
+[target.'cfg(target_os="windows")'.build-dependencies]
+winres = "0.1"
+winapi = { version = "0.3", features = [ "winnt" ] }
+
+[build-dependencies]
+cc = "1.0"
+hbb_common = { path = "libs/hbb_common" }
+
+[dev-dependencies]
+hound = "3.4"
+
+[package.metadata.bundle]
+name = "RustDesk"
+identifier = "com.carriez.rustdesk"
+icon = ["32x32.png", "128x128.png", "128x128@2x.png"]
+deb_depends = ["libgtk-3-0", "libxcb-randr0", "libxdo3", "libxfixes3", "libxcb-shape0", "libxcb-xfixes0", "libasound2", "libsystemd0", "pulseaudio"]
+osx_minimum_system_version = "10.14"
+
+#https://github.com/johnthagen/min-sized-rust
+#!!! rembember call "strip target/release/rustdesk"
+# which reduce binary size a lot
+[profile.release]
+#lto = true
+#codegen-units = 1
+#panic = 'abort'
+#opt-level = 'z' # only have smaller size after strip

README.md

 ### RustDesk | Your Remote Desktop Software
 
-This is a repository used to release RustDesk software and track issues.
+The best open source remote desktop software written with Rust.
 
-[**DOWNLOAD**](https://github.com/rustdesk/rustdesk/releases)
+[**BINARY DOWNLOAD**](https://github.com/rustdesk/rustdesk/releases)
+
+## Dependence
+
+Desktop versions use [sciter](https://sciter.com/) for GUI, please download sciter dynamic library yourself.
+
+[Windows](https://github.com/c-smile/sciter-sdk/blob/dc65744b66389cd5a0ff6bdb7c63a8b7b05a708b/bin.win/x64/sciter.dll)
+[Linux](https://github.com/c-smile/sciter-sdk/raw/dc65744b66389cd5a0ff6bdb7c63a8b7b05a708b/bin.lnx/x64/libsciter-gtk.so)
+[Osx](https://github.com/c-smile/sciter-sdk/raw/dc65744b66389cd5a0ff6bdb7c63a8b7b05a708b/bin.osx/sciter-osx-64.dylib)
+
+## How To Build
+
+* Prepare your Rust development env and C++ build env
+
+* Install [vcpkg](https://github.com/microsoft/vcpkg), and set VCPKG_ROOT env variable correctly
+
+   - Windows: vcpkg install libvpx:x64-windows-static libyuv:x64-windows-static opus:x64-windows-static
+   - Linux/Osx: vcpkg install libvpx libyuv opus
+   
+* cargo run
+
+## File Structure
+
+- **[libs/hbb_common](https://github.com/rustdesk/rustdesk/tree/master/libs/hbb_common)**: video codec, config, tcp/udp wrapper, protobuf, fs functions for file transfer, and some other utility functions
+- **[libs/scrap](https://github.com/rustdesk/rustdesk/tree/master/libs/scrap)**: screen capture
+- **[libs/enigo](https://github.com/rustdesk/rustdesk/tree/master/libs/enigo)**: platform specific keyboard/mouse control
+- **[src/ui](https://github.com/rustdesk/rustdesk/tree/master/src/ui)**: GUI
+- **[src/server](https://github.com/rustdesk/rustdesk/tree/master/src/server)**: audio/clipboard/input/video services, and network connections
+- **[src/client.rs](https://github.com/rustdesk/rustdesk/tree/master/src/client.rs)**: start a peer connection
+- **[src/rendezvous_mediator.rs](https://github.com/rustdesk/rustdesk/tree/master/src/rendezvous_mediator.rs)**: Communicate with [rustdesk-server](https://github.com/rustdesk/rustdesk-server), wait for remote direct (TCP hole punching) or relayed connection
+- **[src/platform](https://github.com/rustdesk/rustdesk/tree/master/src/platform)**: platform specific code

build.rs

+#[cfg(windows)]
+fn build_windows() {
+    cc::Build::new().file("src/windows.cc").compile("windows");
+    // println!("cargo:rustc-link-lib=WtsApi32");
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=windows.cc");
+}
+
+#[cfg(all(windows, feature = "inline"))]
+fn build_manifest() {
+    use std::io::Write;
+    if std::env::var("PROFILE").unwrap() == "release" {
+        let mut res = winres::WindowsResource::new();
+        res.set_icon("icon.ico")
+            .set_language(winapi::um::winnt::MAKELANGID(
+                winapi::um::winnt::LANG_ENGLISH,
+                winapi::um::winnt::SUBLANG_ENGLISH_US,
+            ))
+            .set_manifest_file("manifest.xml");
+        match res.compile() {
+            Err(e) => {
+                write!(std::io::stderr(), "{}", e).unwrap();
+                std::process::exit(1);
+            }
+            Ok(_) => {}
+        }
+    }
+}
+
+fn install_oboe() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    if target_os != "android" {
+        return;
+    }
+    let mut target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    if target_arch == "x86_64" {
+        target_arch = "x64".to_owned();
+    } else if target_arch == "aarch64" {
+        target_arch = "arm64".to_owned();
+    } else {
+        target_arch = "arm".to_owned();
+    }
+    let target = format!("{}-android-static", target_arch);
+    let vcpkg_root = std::env::var("VCPKG_ROOT").unwrap();
+    let mut path: std::path::PathBuf = vcpkg_root.into();
+    path.push("installed");
+    path.push(target);
+    println!(
+        "{}",
+        format!(
+            "cargo:rustc-link-search={}",
+            path.join("lib").to_str().unwrap()
+        )
+    );
+    println!("cargo:rustc-link-lib=oboe");
+    println!("cargo:rustc-link-lib=c++");
+    println!("cargo:rustc-link-lib=OpenSLES");
+    // I always got some strange link error with oboe, so as workaround, put oboe.cc into oboe src: src/common/AudioStreamBuilder.cpp
+    // also to avoid libc++_shared not found issue, cp ndk's libc++_shared.so to jniLibs, e.g.
+    // ./flutter_hbb/android/app/src/main/jniLibs/arm64-v8a/libc++_shared.so
+    // let include = path.join("include");
+    //cc::Build::new().file("oboe.cc").include(include).compile("oboe_wrapper");
+}
+
+fn main() {
+    #[cfg(all(windows, feature = "inline"))]
+    build_manifest();
+    #[cfg(windows)]
+    build_windows();
+    #[cfg(target_os = "macos")]
+    println!("cargo:rustc-link-lib=framework=ApplicationServices");
+    hbb_common::gen_version();
+    install_oboe();
+}

libs/enigo/.github/ISSUE_TEMPLATE/bug_report.md

+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug, needs investigation
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps or a minimal code example to reproduce the behavior.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Environment (please complete the following information):**
+ - OS: [e.g. Linux, Windows, macOS ..]
+ - Rust [e.g. rustc --version]
+ - Library Version [e.g. enigo 0.0.13 or commit hash fa448be ]
+
+**Additional context**
+Add any other context about the problem here.

libs/enigo/.github/ISSUE_TEMPLATE/feature_request.md

+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement, needs investigation
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

libs/enigo/.github/ISSUE_TEMPLATE/question.md

+---
+name: Question
+about: Ask your Question here
+title: ''
+labels: question
+assignees: ''
+
+---
+
+**Describe your Question**
+A clear and concise description of what you want to know.
+
+**Describe your Goal**
+A clear and concise description of what you want to achieve. Consider the [XYProblem](http://xyproblem.info/)
+
+**Environment (please complete the following information):**
+ - OS: [e.g. Linux, Windows, macOS ..]
+ - Rust [e.g. rustc --version]
+ - Library Version [e.g. enigo 0.0.13 or commit hash fa448be ]

libs/enigo/.gitignore

+.DS_Store
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock
+
+# RustFmt files
+**/*.rs.bk
+
+# intellij
+.idea
\ No newline at end of file

libs/enigo/.travis.yml

+language: rust
+rust:
+  - stable
+  - beta
+  - nightly
+matrix:
+  allow_failures:
+    - rust: nightly
+before_install:
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get -qq update; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y libxdo-dev; fi
+os:
+  - linux
+  - osx
+

libs/enigo/.vscode/launch.json

+{
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "name": "Debug",
+            "type": "gdb",
+            "request": "launch",
+            "target": "./target/debug/examples/keyboard",
+            "cwd": "${workspaceRoot}"
+        }
+    ]
+}
\ No newline at end of file

libs/enigo/Cargo.toml

+[package]
+name = "enigo"
+version = "0.0.14"
+authors = ["Dustin Bensing <dustin.bensing@googlemail.com>"]
+edition = "2018"
+build = "build.rs"
+
+description = "Enigo lets you control your mouse and keyboard in an abstract way on different operating systems (currently only Linux, macOS, Win – Redox and *BSD planned)"
+documentation = "https://docs.rs/enigo/"
+homepage = "https://github.com/enigo-rs/enigo"
+repository = "https://github.com/enigo-rs/enigo"
+readme = "README.md"
+keywords = ["input", "mouse", "testing", "keyboard", "automation"]
+categories = ["development-tools::testing", "api-bindings", "hardware-support"]
+license = "MIT"
+
+[badges]
+travis-ci = { repository = "enigo-rs/enigo" }
+appveyor = { repository = "pythoneer/enigo-85xiy" }
+
+[dependencies]
+serde = { version = "1.0", optional = true }
+serde_derive = { version = "1.0", optional = true }
+log = "0.4"
+
+[features]
+with_serde = ["serde", "serde_derive"]
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["winuser", "winbase"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-graphics = "0.22"
+objc = "0.2"
+unicode-segmentation = "1.6"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+libc = "0.2"
+
+[build-dependencies]
+pkg-config = "0.3"

libs/enigo/LICENSE

+MIT License
+
+Copyright (c) 2017 pythoneer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libs/enigo/README.md

+[![Build Status](https://travis-ci.org/enigo-rs/enigo.svg?branch=master)](https://travis-ci.org/enigo-rs/enigo)
+[![Build status](https://ci.appveyor.com/api/projects/status/6cd00pajx4tvvl3e?svg=true)](https://ci.appveyor.com/project/pythoneer/enigo-85xiy)
+[![Dependency Status](https://dependencyci.com/github/pythoneer/enigo/badge)](https://dependencyci.com/github/pythoneer/enigo)
+[![Docs](https://docs.rs/enigo/badge.svg)](https://docs.rs/enigo)
+[![Crates.io](https://img.shields.io/crates/v/enigo.svg)](https://crates.io/crates/enigo)
+[![Discord chat](https://img.shields.io/discord/315925376486342657.svg)](https://discord.gg/Eb8CsnN)
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/enigo-rs/Lobby)
+
+
+# enigo
+Cross platform input simulation in Rust!
+
+- [x] Linux (X11) mouse
+- [x] Linux (X11) text
+- [ ] Linux (Wayland) mouse
+- [ ] Linux (Wayland) text
+- [x] MacOS mouse
+- [x] MacOS text
+- [x] Win mouse
+- [x] Win text
+- [x] Custom Parser
+
+
+```Rust
+let mut enigo = Enigo::new();
+
+enigo.mouse_move_to(500, 200);
+enigo.mouse_click(MouseButton::Left);
+enigo.key_sequence_parse("{+CTRL}a{-CTRL}{+SHIFT}Hello World{-SHIFT}");
+```
+
+for more look at examples
+
+Runtime dependencies
+--------------------
+
+Linux users may have to install libxdo-dev. For example, on Ubuntu:
+
+```Bash
+apt install libxdo-dev
+```
+On Arch: 
+
+```Bash
+pacman -S xdotool
+```

libs/enigo/appveyor.yml

+# Appveyor configuration template for Rust using rustup for Rust installation
+# https://github.com/starkat99/appveyor-rust
+
+## Operating System (VM environment) ##
+
+# Rust needs at least Visual Studio 2013 Appveyor OS for MSVC targets.
+os: Visual Studio 2015
+
+## Build Matrix ##
+
+# This configuration will setup a build for each channel & target combination (12 windows
+# combinations in all).
+#
+# There are 3 channels: stable, beta, and nightly.
+#
+# Alternatively, the full version may be specified for the channel to build using that specific
+# version (e.g. channel: 1.5.0)
+#
+# The values for target are the set of windows Rust build targets. Each value is of the form
+#
+# ARCH-pc-windows-TOOLCHAIN
+#
+# Where ARCH is the target architecture, either x86_64 or i686, and TOOLCHAIN is the linker
+# toolchain to use, either msvc or gnu. See https://www.rust-lang.org/downloads.html#win-foot for
+# a description of the toolchain differences.
+# See https://github.com/rust-lang-nursery/rustup.rs/#toolchain-specification for description of
+# toolchains and host triples.
+#
+# Comment out channel/target combos you do not wish to build in CI.
+#
+# You may use the `cargoflags` and `RUSTFLAGS` variables to set additional flags for cargo commands
+# and rustc, respectively. For instance, you can uncomment the cargoflags lines in the nightly
+# channels to enable unstable features when building for nightly. Or you could add additional
+# matrix entries to test different combinations of features.
+environment:
+  matrix:
+
+### MSVC Toolchains ###
+
+  # Stable 64-bit MSVC
+    - channel: stable
+      target: x86_64-pc-windows-msvc
+  # Stable 32-bit MSVC
+    - channel: stable
+      target: i686-pc-windows-msvc
+  # Beta 64-bit MSVC
+    - channel: beta
+      target: x86_64-pc-windows-msvc
+  # Beta 32-bit MSVC
+    - channel: beta
+      target: i686-pc-windows-msvc
+  # Nightly 64-bit MSVC
+    - channel: nightly
+      target: x86_64-pc-windows-msvc
+      #cargoflags: --features "unstable"
+  # Nightly 32-bit MSVC
+    - channel: nightly
+      target: i686-pc-windows-msvc
+      #cargoflags: --features "unstable"
+
+### GNU Toolchains ###
+
+  # Stable 64-bit GNU
+    - channel: stable
+      target: x86_64-pc-windows-gnu
+  # Stable 32-bit GNU
+    - channel: stable
+      target: i686-pc-windows-gnu
+  # Beta 64-bit GNU
+    - channel: beta
+      target: x86_64-pc-windows-gnu
+  # Beta 32-bit GNU
+    - channel: beta
+      target: i686-pc-windows-gnu
+  # Nightly 64-bit GNU
+    - channel: nightly
+      target: x86_64-pc-windows-gnu
+      #cargoflags: --features "unstable"
+  # Nightly 32-bit GNU
+    - channel: nightly
+      target: i686-pc-windows-gnu
+      #cargoflags: --features "unstable"
+
+### Allowed failures ###
+
+# See Appveyor documentation for specific details. In short, place any channel or targets you wish
+# to allow build failures on (usually nightly at least is a wise choice). This will prevent a build
+# or test failure in the matching channels/targets from failing the entire build.
+matrix:
+  allow_failures:
+    - channel: nightly
+
+# If you only care about stable channel build failures, uncomment the following line:
+    #- channel: beta
+
+## Install Script ##
+
+# This is the most important part of the Appveyor configuration. This installs the version of Rust
+# specified by the 'channel' and 'target' environment variables from the build matrix. This uses
+# rustup to install Rust.
+#
+# For simple configurations, instead of using the build matrix, you can simply set the
+# default-toolchain and default-host manually here.
+install:
+  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - rustup-init -yv --default-toolchain %channel% --default-host %target%
+  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+  - rustc -vV
+  - cargo -vV
+
+## Build Script ##
+
+# 'cargo test' takes care of building for us, so disable Appveyor's build stage. This prevents
+# the "directory does not contain a project or solution file" error.
+build: false
+
+# Uses 'cargo test' to run tests and build. Alternatively, the project may call compiled programs
+#directly or perform other testing commands. Rust will automatically be placed in the PATH
+# environment variable.
+test_script:
+  - cargo test --verbose %cargoflags%

libs/enigo/build.rs

+#[cfg(target_os = "windows")]
+fn main() {}
+
+#[cfg(target_os = "macos")]
+fn main() {}
+
+#[cfg(target_os = "linux")]
+use pkg_config;
+#[cfg(target_os = "linux")]
+use std::env;
+#[cfg(target_os = "linux")]
+use std::fs::File;
+#[cfg(target_os = "linux")]
+use std::io::Write;
+#[cfg(target_os = "linux")]
+use std::path::Path;
+
+#[cfg(target_os = "linux")]
+fn main() {
+    let libraries = [
+        "xext",
+        "gl",
+        "xcursor",
+        "xxf86vm",
+        "xft",
+        "xinerama",
+        "xi",
+        "x11",
+        "xlib_xcb",
+        "xmu",
+        "xrandr",
+        "xtst",
+        "xrender",
+        "xscrnsaver",
+        "xt",
+    ];
+
+    let mut config = String::new();
+    for lib in libraries.iter() {
+        let libdir = match pkg_config::get_variable(lib, "libdir") {
+            Ok(libdir) => format!("Some(\"{}\")", libdir),
+            Err(_) => "None".to_string(),
+        };
+        config.push_str(&format!(
+            "pub const {}: Option<&'static str> = {};\n",
+            lib, libdir
+        ));
+    }
+    let config = format!("pub mod config {{ pub mod libdir {{\n{}}}\n}}", config);
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("config.rs");
+    let mut f = File::create(&dest_path).unwrap();
+    f.write_all(&config.into_bytes()).unwrap();
+
+    let target = env::var("TARGET").unwrap();
+    if target.contains("linux") {
+        println!("cargo:rustc-link-lib=dl");
+    } else if target.contains("freebsd") || target.contains("dragonfly") {
+        println!("cargo:rustc-link-lib=c");
+    }
+}

libs/enigo/examples/dsl.rs

+use enigo::{Enigo, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    // write text and select all
+    enigo.key_sequence_parse("{+UNICODE}{{Hello World!}} ❤️{-UNICODE}{+CTRL}a{-CTRL}");
+}

libs/enigo/examples/key.rs

+use enigo::{Enigo, Key, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    enigo.key_down(Key::Layout('a'));
+    thread::sleep(Duration::from_secs(1));
+    enigo.key_up(Key::Layout('a'));
+}

libs/enigo/examples/keyboard.rs

+use enigo::{Enigo, Key, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    // write text
+    enigo.key_sequence("Hello World! here is a lot of text  ❤️");
+
+    // select all
+    enigo.key_down(Key::Control);
+    enigo.key_click(Key::Layout('a'));
+    enigo.key_up(Key::Control);
+}

libs/enigo/examples/mouse.rs

+use enigo::{Enigo, MouseButton, MouseControllable};
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    let wait_time = Duration::from_secs(2);
+    let mut enigo = Enigo::new();
+
+    thread::sleep(wait_time);
+
+    enigo.mouse_move_to(500, 200);
+    thread::sleep(wait_time);
+
+    enigo.mouse_down(MouseButton::Left);
+    thread::sleep(wait_time);
+
+    enigo.mouse_move_relative(100, 100);
+    thread::sleep(wait_time);
+
+    enigo.mouse_up(MouseButton::Left);
+    thread::sleep(wait_time);
+
+    enigo.mouse_click(MouseButton::Left);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_x(2);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_x(-2);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_y(2);
+    thread::sleep(wait_time);
+
+    enigo.mouse_scroll_y(-2);
+    thread::sleep(wait_time);
+}

libs/enigo/examples/timer.rs

+use enigo::{Enigo, Key, KeyboardControllable};
+use std::thread;
+use std::time::Duration;
+use std::time::Instant;
+
+fn main() {
+    thread::sleep(Duration::from_secs(2));
+    let mut enigo = Enigo::new();
+
+    let now = Instant::now();
+
+    // write text
+    enigo.key_sequence("Hello World! ❤️");
+
+    let time = now.elapsed();
+    println!("{:?}", time);
+
+    // select all
+    enigo.key_down(Key::Control);
+    enigo.key_click(Key::Layout('a'));
+    enigo.key_up(Key::Control);
+}

libs/enigo/rustfmt.toml

+wrap_comments = true

libs/enigo/src/dsl.rs

+use crate::{Key, KeyboardControllable};
+use std::error::Error;
+use std::fmt;
+
+/// An error that can occur when parsing DSL
+#[derive(Debug, PartialEq, Eq)]
+pub enum ParseError {
+    /// When a tag doesn't exist.
+    /// Example: {+TEST}{-TEST}
+    ///            ^^^^   ^^^^
+    UnknownTag(String),
+
+    /// When a { is encountered inside a {TAG}.
+    /// Example: {+HELLO{WORLD}
+    ///                 ^
+    UnexpectedOpen,
+
+    /// When a { is never matched with a }.
+    /// Example: {+SHIFT}Hello{-SHIFT
+    ///                              ^
+    UnmatchedOpen,
+
+    /// Opposite of UnmatchedOpen.
+    /// Example: +SHIFT}Hello{-SHIFT}
+    ///         ^
+    UnmatchedClose,
+}
+impl Error for ParseError {
+    fn description(&self) -> &str {
+        match *self {
+            ParseError::UnknownTag(_) => "Unknown tag",
+            ParseError::UnexpectedOpen => "Unescaped open bracket ({) found inside tag name",
+            ParseError::UnmatchedOpen => "Unmatched open bracket ({). No matching close (})",
+            ParseError::UnmatchedClose => "Unmatched close bracket (}). No previous open ({)",
+        }
+    }
+}
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.to_string())
+    }
+}
+
+/// Evaluate the DSL. This tokenizes the input and presses the keys.
+pub fn eval<K>(enigo: &mut K, input: &str) -> Result<(), ParseError>
+where
+    K: KeyboardControllable,
+{
+    for token in tokenize(input)? {
+        match token {
+            Token::Sequence(buffer) => {
+                for key in buffer.chars() {
+                    enigo.key_click(Key::Layout(key));
+                }
+            }
+            Token::Unicode(buffer) => enigo.key_sequence(&buffer),
+            Token::KeyUp(key) => enigo.key_up(key),
+            Token::KeyDown(key) => enigo.key_down(key).unwrap_or(()),
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum Token {
+    Sequence(String),
+    Unicode(String),
+    KeyUp(Key),
+    KeyDown(Key),
+}
+
+fn tokenize(input: &str) -> Result<Vec<Token>, ParseError> {
+    let mut unicode = false;
+
+    let mut tokens = Vec::new();
+    let mut buffer = String::new();
+    let mut iter = input.chars().peekable();
+
+    fn flush(tokens: &mut Vec<Token>, buffer: String, unicode: bool) {
+        if !buffer.is_empty() {
+            if unicode {
+                tokens.push(Token::Unicode(buffer));
+            } else {
+                tokens.push(Token::Sequence(buffer));
+            }
+        }
+    }
+
+    while let Some(c) = iter.next() {
+        if c == '{' {
+            match iter.next() {
+                Some('{') => buffer.push('{'),
+                Some(mut c) => {
+                    flush(&mut tokens, buffer, unicode);
+                    buffer = String::new();
+
+                    let mut tag = String::new();
+                    loop {
+                        tag.push(c);
+                        match iter.next() {
+                            Some('{') => match iter.peek() {
+                                Some(&'{') => {
+                                    iter.next();
+                                    c = '{'
+                                }
+                                _ => return Err(ParseError::UnexpectedOpen),
+                            },
+                            Some('}') => match iter.peek() {
+                                Some(&'}') => {
+                                    iter.next();
+                                    c = '}'
+                                }
+                                _ => break,
+                            },
+                            Some(new) => c = new,
+                            None => return Err(ParseError::UnmatchedOpen),
+                        }
+                    }
+                    match &*tag {
+                        "+UNICODE" => unicode = true,
+                        "-UNICODE" => unicode = false,
+                        "+SHIFT" => tokens.push(Token::KeyDown(Key::Shift)),
+                        "-SHIFT" => tokens.push(Token::KeyUp(Key::Shift)),
+                        "+CTRL" => tokens.push(Token::KeyDown(Key::Control)),
+                        "-CTRL" => tokens.push(Token::KeyUp(Key::Control)),
+                        "+META" => tokens.push(Token::KeyDown(Key::Meta)),
+                        "-META" => tokens.push(Token::KeyUp(Key::Meta)),
+                        "+ALT" => tokens.push(Token::KeyDown(Key::Alt)),
+                        "-ALT" => tokens.push(Token::KeyUp(Key::Alt)),
+                        _ => return Err(ParseError::UnknownTag(tag)),
+                    }
+                }
+                None => return Err(ParseError::UnmatchedOpen),
+            }
+        } else if c == '}' {
+            match iter.next() {
+                Some('}') => buffer.push('}'),
+                _ => return Err(ParseError::UnmatchedClose),
+            }
+        } else {
+            buffer.push(c);
+        }
+    }
+
+    flush(&mut tokens, buffer, unicode);
+
+    Ok(tokens)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn success() {
+        assert_eq!(
+            tokenize("{{Hello World!}} {+CTRL}hi{-CTRL}"),
+            Ok(vec![
+                Token::Sequence("{Hello World!} ".into()),
+                Token::KeyDown(Key::Control),
+                Token::Sequence("hi".into()),
+                Token::KeyUp(Key::Control)
+            ])
+        );
+    }
+    #[test]
+    fn unexpected_open() {
+        assert_eq!(tokenize("{hello{}world}"), Err(ParseError::UnexpectedOpen));
+    }
+    #[test]
+    fn unmatched_open() {
+        assert_eq!(
+            tokenize("{this is going to fail"),
+            Err(ParseError::UnmatchedOpen)
+        );
+    }
+    #[test]
+    fn unmatched_close() {
+        assert_eq!(
+            tokenize("{+CTRL}{{this}} is going to fail}"),
+            Err(ParseError::UnmatchedClose)
+        );
+    }
+}

libs/enigo/src/macos/keycodes.rs

+// https://stackoverflow.com/questions/3202629/where-can-i-find-a-list-of-mac-virtual-key-codes
+
+/* keycodes for keys that are independent of keyboard layout */
+
+#![allow(non_upper_case_globals)]
+#![allow(dead_code)]
+
+pub const kVK_Return: u16 = 0x24;
+pub const kVK_Tab: u16 = 0x30;
+pub const kVK_Space: u16 = 0x31;
+pub const kVK_Delete: u16 = 0x33;
+pub const kVK_Escape: u16 = 0x35;
+pub const kVK_Command: u16 = 0x37;
+pub const kVK_Shift: u16 = 0x38;
+pub const kVK_CapsLock: u16 = 0x39;
+pub const kVK_Option: u16 = 0x3A;
+pub const kVK_Control: u16 = 0x3B;
+pub const kVK_RightShift: u16 = 0x3C;
+pub const kVK_RightOption: u16 = 0x3D;
+pub const kVK_RightControl: u16 = 0x3E;
+pub const kVK_Function: u16 = 0x3F;
+pub const kVK_F17: u16 = 0x40;
+pub const kVK_VolumeUp: u16 = 0x48;
+pub const kVK_VolumeDown: u16 = 0x49;
+pub const kVK_Mute: u16 = 0x4A;
+pub const kVK_F18: u16 = 0x4F;
+pub const kVK_F19: u16 = 0x50;
+pub const kVK_F20: u16 = 0x5A;
+pub const kVK_F5: u16 = 0x60;
+pub const kVK_F6: u16 = 0x61;
+pub const kVK_F7: u16 = 0x62;
+pub const kVK_F3: u16 = 0x63;
+pub const kVK_F8: u16 = 0x64;
+pub const kVK_F9: u16 = 0x65;
+pub const kVK_F11: u16 = 0x67;
+pub const kVK_F13: u16 = 0x69;
+pub const kVK_F16: u16 = 0x6A;
+pub const kVK_F14: u16 = 0x6B;
+pub const kVK_F10: u16 = 0x6D;
+pub const kVK_F12: u16 = 0x6F;
+pub const kVK_F15: u16 = 0x71;
+pub const kVK_Help: u16 = 0x72;
+pub const kVK_Home: u16 = 0x73;
+pub const kVK_PageUp: u16 = 0x74;
+pub const kVK_ForwardDelete: u16 = 0x75;
+pub const kVK_F4: u16 = 0x76;
+pub const kVK_End: u16 = 0x77;
+pub const kVK_F2: u16 = 0x78;
+pub const kVK_PageDown: u16 = 0x79;
+pub const kVK_F1: u16 = 0x7A;
+pub const kVK_LeftArrow: u16 = 0x7B;
+pub const kVK_RightArrow: u16 = 0x7C;
+pub const kVK_DownArrow: u16 = 0x7D;
+pub const kVK_UpArrow: u16 = 0x7E;
+pub const kVK_ANSI_Keypad0: u16 = 0x52;
+pub const kVK_ANSI_Keypad1: u16 = 0x53;
+pub const kVK_ANSI_Keypad2: u16 = 0x54;
+pub const kVK_ANSI_Keypad3: u16 = 0x55;
+pub const kVK_ANSI_Keypad4: u16 = 0x56;
+pub const kVK_ANSI_Keypad5: u16 = 0x57;
+pub const kVK_ANSI_Keypad6: u16 = 0x58;
+pub const kVK_ANSI_Keypad7: u16 = 0x59;
+pub const kVK_ANSI_Keypad8: u16 = 0x5B;
+pub const kVK_ANSI_Keypad9: u16 = 0x5C;
+pub const kVK_ANSI_KeypadClear: u16 = 0x47;
+pub const kVK_ANSI_KeypadDecimal: u16 = 0x41;
+pub const kVK_ANSI_KeypadMultiply: u16 = 0x43;
+pub const kVK_ANSI_KeypadPlus: u16 = 0x45;
+pub const kVK_ANSI_KeypadDivide: u16 = 0x4B;
+pub const kVK_ANSI_KeypadEnter: u16 = 0x4C;
+pub const kVK_ANSI_KeypadMinus: u16 = 0x4E;
+pub const kVK_ANSI_KeypadEquals: u16 = 0x51;

libs/enigo/src/macos/mod.rs

+mod macos_impl;
+
+pub mod keycodes;
+pub use self::macos_impl::Enigo;

libs/enigo/src/win/keycodes.rs

+// https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731
+
+pub const EVK_RETURN: u16 = 0x0D;
+pub const EVK_TAB: u16 = 0x09;
+pub const EVK_SPACE: u16 = 0x20;
+pub const EVK_BACK: u16 = 0x08;
+pub const EVK_ESCAPE: u16 = 0x1b;
+pub const EVK_LWIN: u16 = 0x5b;
+pub const EVK_SHIFT: u16 = 0x10;
+pub const EVK_CAPITAL: u16 = 0x14;
+pub const EVK_MENU: u16 = 0x12;
+pub const EVK_LCONTROL: u16 = 0xa2;
+pub const EVK_HOME: u16 = 0x24;
+pub const EVK_PRIOR: u16 = 0x21;
+pub const EVK_NEXT: u16 = 0x22;
+pub const EVK_END: u16 = 0x23;
+pub const EVK_LEFT: u16 = 0x25;
+pub const EVK_RIGHT: u16 = 0x27;
+pub const EVK_UP: u16 = 0x26;
+pub const EVK_DOWN: u16 = 0x28;
+pub const EVK_DELETE: u16 = 0x2E;
+pub const EVK_F1: u16 = 0x70;
+pub const EVK_F2: u16 = 0x71;
+pub const EVK_F3: u16 = 0x72;
+pub const EVK_F4: u16 = 0x73;
+pub const EVK_F5: u16 = 0x74;
+pub const EVK_F6: u16 = 0x75;
+pub const EVK_F7: u16 = 0x76;
+pub const EVK_F8: u16 = 0x77;
+pub const EVK_F9: u16 = 0x78;
+pub const EVK_F10: u16 = 0x79;
+pub const EVK_F11: u16 = 0x7a;
+pub const EVK_F12: u16 = 0x7b;
+pub const EVK_NUMPAD0: u16 = 0x60;
+pub const EVK_NUMPAD1: u16 = 0x61;
+pub const EVK_NUMPAD2: u16 = 0x62;
+pub const EVK_NUMPAD3: u16 = 0x63;
+pub const EVK_NUMPAD4: u16 = 0x64;
+pub const EVK_NUMPAD5: u16 = 0x65;
+pub const EVK_NUMPAD6: u16 = 0x66;
+pub const EVK_NUMPAD7: u16 = 0x67;
+pub const EVK_NUMPAD8: u16 = 0x68;
+pub const EVK_NUMPAD9: u16 = 0x69;
+pub const EVK_CANCEL: u16 = 0x03;
+pub const EVK_CLEAR: u16 = 0x0C;
+pub const EVK_PAUSE: u16 = 0x13;
+pub const EVK_KANA: u16 = 0x15;
+pub const EVK_HANGUL: u16 = 0x15;
+pub const EVK_JUNJA: u16 = 0x17;
+pub const EVK_FINAL: u16 = 0x18;
+pub const EVK_HANJA: u16 = 0x19;
+pub const EVK_KANJI: u16 = 0x19;
+pub const EVK_CONVERT: u16 = 0x1C;
+pub const EVK_SELECT: u16 = 0x29;
+pub const EVK_PRINT: u16 = 0x2A;
+pub const EVK_EXECUTE: u16 = 0x2B;
+pub const EVK_SNAPSHOT: u16 = 0x2C;
+pub const EVK_INSERT: u16 = 0x2D;
+pub const EVK_HELP: u16 = 0x2F;
+pub const EVK_SLEEP: u16 = 0x5F;
+pub const EVK_SEPARATOR: u16 = 0x6C;
+pub const EVK_VOLUME_MUTE: u16 = 0xAD;
+pub const EVK_VOLUME_DOWN: u16 = 0xAE;
+pub const EVK_VOLUME_UP: u16 = 0xAF;
+pub const EVK_NUMLOCK: u16 = 0x90;
+pub const EVK_SCROLL: u16 = 0x91;
+pub const EVK_RWIN: u16 = 0x5C;
+pub const EVK_APPS: u16 = 0x5D;
+pub const EVK_ADD: u16 = 0x6B;
+pub const EVK_MULTIPLY: u16 = 0x6A;
+pub const EVK_SUBTRACT: u16 = 0x6D;
+pub const EVK_DECIMAL: u16 = 0x6E;
+pub const EVK_DIVIDE: u16 = 0x6F;

libs/enigo/src/win/mod.rs

+mod win_impl;
+
+pub mod keycodes;
+pub use self::win_impl::Enigo;

libs/hbb_common/.gitignore

+/target
+**/*.rs.bk
+Cargo.lock
+src/protos/

libs/hbb_common/Cargo.toml

+[package]
+name = "hbb_common"
+version = "0.1.0"
+authors = ["rustdesk<info@rustdesk.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+protobuf = { version = "3.0.0-pre", git = "https://github.com/stepancheg/rust-protobuf" }
+tokio = { version = "0.2", features = ["full"] }
+tokio-util = { version = "0.3", features = ["full"] }
+futures = "0.3"
+bytes = "0.5"
+log = "0.4"
+env_logger = "0.8"
+socket2 = { version = "0.3", features = ["reuseport"] }
+zstd = "0.5"
+quinn = {version = "0.6", optional = true }
+anyhow = "1.0"
+futures-util = "0.3"
+directories-next = "2.0"
+rand = "0.7"
+serde_derive = "1.0"
+serde = "1.0"
+lazy_static = "1.4"
+confy = { git = "https://github.com/open-trade/confy" }
+dirs-next = "2.0"
+filetime = "0.2"
+sodiumoxide = "0.2"
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+mac_address = "1.1"
+
+[features]
+quic = ["quinn"]
+
+[build-dependencies]
+protobuf-codegen-pure = { version = "3.0.0-pre", git = "https://github.com/stepancheg/rust-protobuf" }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["winuser"] }
+
+[dev-dependencies]
+toml = "0.5"
+serde_json = "1.0"

libs/hbb_common/build.rs

+fn main() {
+    std::fs::create_dir_all("src/protos").unwrap();
+    protobuf_codegen_pure::Codegen::new()
+        .out_dir("src/protos")
+        .inputs(&["protos/rendezvous.proto", "protos/message.proto"])
+        .include("protos")
+        .run()
+        .expect("Codegen failed.");
+}

libs/hbb_common/protos/message.proto

+syntax = "proto3";
+package hbb;
+
+message VP9 {
+  bytes data = 1;
+  bool key = 2;
+  int64 pts = 3;
+}
+
+message VP9s { repeated VP9 frames = 1; }
+
+message RGB { bool compress = 1; }
+
+// planes data send directly in binary for better use arraybuffer on web
+message YUV {
+  bool compress = 1;
+  int32 stride = 2;
+}
+
+message VideoFrame {
+  oneof union {
+    VP9s vp9s = 6;
+    RGB rgb = 7;
+    YUV yuv = 8;
+  }
+}
+
+message DisplayInfo {
+  sint32 x = 1;
+  sint32 y = 2;
+  int32 width = 3;
+  int32 height = 4;
+  string name = 5;
+  bool online = 6;
+}
+
+message PortForward {
+  string host = 1;
+  int32 port = 2;
+}
+
+message FileTransfer {
+  string dir = 1;
+  bool show_hidden = 2;
+}
+
+message LoginRequest {
+  string username = 1;
+  bytes password = 2;
+  string my_id = 4;
+  string my_name = 5;
+  OptionMessage option = 6;
+  oneof union {
+    FileTransfer file_transfer = 7;
+    PortForward port_forward = 8;
+  }
+}
+
+message ChatMessage { string text = 1; }
+
+message PeerInfo {
+  string username = 1;
+  string hostname = 2;
+  string platform = 3;
+  repeated DisplayInfo displays = 4;
+  int32 current_display = 5;
+  bool sas_enabled = 6;
+  string version = 7;
+}
+
+message LoginResponse {
+  oneof union {
+    string error = 1;
+    PeerInfo peer_info = 2;
+  }
+}
+
+message MouseEvent {
+  int32 mask = 1;
+  sint32 x = 2;
+  sint32 y = 3;
+  repeated ControlKey modifiers = 4;
+}
+
+enum ControlKey {
+  Alt = 1;
+  Backspace = 2;
+  CapsLock = 3;
+  Control = 4;
+  Delete = 5;
+  DownArrow = 6;
+  End = 7;
+  Escape = 8;
+  F1 = 9;
+  F10 = 10;
+  F11 = 11;
+  F12 = 12;
+  F2 = 13;
+  F3 = 14;
+  F4 = 15;
+  F5 = 16;
+  F6 = 17;
+  F7 = 18;
+  F8 = 19;
+  F9 = 20;
+  Home = 21;
+  LeftArrow = 22;
+  /// meta key (also known as "windows"; "super"; and "command")
+  Meta = 23;
+  /// option key on macOS (alt key on Linux and Windows)
+  Option = 24;
+  PageDown = 25;
+  PageUp = 26;
+  Return = 27;
+  RightArrow = 28;
+  Shift = 29;
+  Space = 30;
+  Tab = 31;
+  UpArrow = 32;
+  Numpad0 = 33;
+  Numpad1 = 34;
+  Numpad2 = 35;
+  Numpad3 = 36;
+  Numpad4 = 37;
+  Numpad5 = 38;
+  Numpad6 = 39;
+  Numpad7 = 40;
+  Numpad8 = 41;
+  Numpad9 = 42;
+  Cancel = 43;
+  Clear = 44;
+  Menu = 45;
+  Pause = 46;
+  Kana = 47;
+  Hangul = 48;
+  Junja = 49;
+  Final = 50;
+  Hanja = 51;
+  Kanji = 52;
+  Convert = 53;
+  Select = 54;
+  Print = 55;
+  Execute = 56;
+  Snapshot = 57;
+  Insert = 58;
+  Help = 59;
+  Sleep = 60;
+  Separator = 61;
+  Scroll = 62;
+  NumLock = 63;
+  RWin = 64;
+  Apps = 65;
+  Multiply = 66;
+  Add = 67;
+  Subtract = 68;
+  Decimal = 69;
+  Divide = 70;
+  Equals = 71;
+  NumpadEnter = 72;
+  CtrlAltDel = 100;
+  LockScreen = 101;
+}
+
+message KeyEvent {
+  bool down = 1;
+  bool press = 2;
+  oneof union {
+    ControlKey control_key = 3;
+    uint32 chr = 4;
+    uint32 unicode = 5;
+    string seq = 6;
+  }
+  repeated ControlKey modifiers = 8;
+}
+
+message CursorData {
+  uint64 id = 1;
+  sint32 hotx = 2;
+  sint32 hoty = 3;
+  int32 width = 4;
+  int32 height = 5;
+  bytes colors = 6;
+}
+
+message CursorPosition {
+  sint32 x = 1;
+  sint32 y = 2;
+}
+
+message Hash {
+  string salt = 1;
+  string challenge = 2;
+};
+
+message Clipboard {
+  bool compress = 1;
+  bytes content = 2;
+};
+
+enum FileType {
+  Dir = 1;
+  DirLink = 2;
+  DirDrive = 3;
+  File = 4;
+  FileLink = 5;
+}
+
+message FileEntry {
+  FileType entry_type = 1;
+  string name = 2;
+  bool is_hidden = 3;
+  uint64 size = 4;
+  uint64 modified_time = 5;
+}
+
+message FileDirectory {
+  int32 id = 1;
+  string path = 2;
+  repeated FileEntry entries = 3;
+}
+
+message ReadDir {
+  string path = 1;
+  bool include_hidden = 2;
+}
+
+message ReadAllFiles {
+  int32 id = 1;
+  string path = 2;
+  bool include_hidden = 3;
+}
+
+message FileAction {
+  oneof union {
+    ReadDir read_dir = 1;
+    FileTransferSendRequest send = 2;
+    FileTransferReceiveRequest receive = 3;
+    FileDirCreate create = 4;
+    FileRemoveDir remove_dir = 5;
+    FileRemoveFile remove_file = 6;
+    ReadAllFiles all_files = 7;
+    FileTransferCancel cancel = 8;
+  }
+}
+
+message FileTransferCancel { int32 id = 1; }
+
+message FileResponse {
+  oneof union {
+    FileDirectory dir = 1;
+    FileTransferBlock block = 2;
+    FileTransferError error = 3;
+    FileTransferDone done = 4;
+  }
+}
+
+message FileTransferBlock {
+  int32 id = 1;
+  sint32 file_num = 2;
+  bytes data = 3;
+  bool compressed = 4;
+}
+
+message FileTransferError {
+  int32 id = 1;
+  string error = 2;
+  sint32 file_num = 3;
+}
+
+message FileTransferSendRequest {
+  int32 id = 1;
+  string path = 2;
+  bool include_hidden = 3;
+}
+
+message FileTransferDone {
+  int32 id = 1;
+  sint32 file_num = 2;
+}
+
+message FileTransferReceiveRequest {
+  int32 id = 1;
+  string path = 2; // path written to
+  repeated FileEntry files = 3;
+}
+
+message FileRemoveDir {
+  int32 id = 1;
+  string path = 2;
+  bool recursive = 3;
+}
+
+message FileRemoveFile {
+  int32 id = 1;
+  string path = 2;
+  sint32 file_num = 3;
+}
+
+message FileDirCreate {
+  int32 id = 1;
+  string path = 2;
+}
+
+message SwitchDisplay {
+  int32 display = 1;
+  sint32 x = 2;
+  sint32 y = 3;
+  int32 width = 4;
+  int32 height = 5;
+}
+
+enum Permission {
+  Keyboard = 1;
+  Clipboard = 2;
+  Audio = 3;
+}
+
+message PermissionInfo {
+  Permission permission = 1;
+  bool enabled = 2;
+}
+
+enum ImageQuality {
+  NotSet = 0;
+  Low = 2;
+  Balanced = 3;
+  Best = 4;
+}
+
+enum BoolOption {
+  NotSet = 0;
+  No = 1;
+  Yes = 2;
+}
+
+message OptionMessage {
+  ImageQuality image_quality = 1;
+  BoolOption lock_after_session_end = 2;
+  BoolOption show_remote_cursor = 3;
+  BoolOption privacy_mode = 4;
+  BoolOption block_input = 5;
+  int32 custom_image_quality = 6;
+  BoolOption disable_audio = 7;
+  BoolOption disable_clipboard = 8;
+}
+
+message TestDelay {
+  int64 time = 1;
+  bool from_client = 2;
+}
+
+message PublicKey {
+  bytes asymmetric_value = 1;
+  bytes symmetric_value = 2;
+}
+
+message SignedId {
+  bytes id = 1;
+  bytes pk = 2;
+}
+
+message AudioFormat {
+  uint32 sample_rate = 1;
+  uint32 channels = 2;
+}
+
+message AudioFrame { bytes data = 1; }
+
+message Misc {
+  oneof union {
+    ChatMessage chat_message = 4;
+    SwitchDisplay switch_display = 5;
+    PermissionInfo permission_info = 6;
+    OptionMessage option = 7;
+    AudioFormat audio_format = 8;
+    string close_reason = 9;
+    bool refresh_video = 10;
+  }
+}
+
+message Message {
+  oneof union {
+    SignedId signed_id = 3;
+    PublicKey public_key = 4;
+    TestDelay test_delay = 5;
+    VideoFrame video_frame = 6;
+    LoginRequest login_request = 7;
+    LoginResponse login_response = 8;
+    Hash hash = 9;
+    MouseEvent mouse_event = 10;
+    AudioFrame audio_frame = 11;
+    CursorData cursor_data = 12;
+    CursorPosition cursor_position = 13;
+    uint64 cursor_id = 14;
+    KeyEvent key_event = 15;
+    Clipboard clipboard = 16;
+    FileAction file_action = 17;
+    FileResponse file_response = 18;
+    Misc misc = 19;
+  }
+}

libs/hbb_common/protos/rendezvous.proto

+syntax = "proto3";
+package hbb;
+
+message RegisterPeer {
+  string id = 1;
+  int32 serial = 2;
+}
+
+message RegisterPeerResponse { bool request_pk = 2; }
+
+message PunchHoleRequest { 
+  string id = 1; 
+  NatType nat_type = 2;
+}
+
+message PunchHole { 
+  bytes socket_addr = 1;
+  string relay_server = 2;
+  NatType nat_type = 3;
+}
+
+message TestNatRequest {
+  int32 serial = 1;
+}
+
+// per my test, uint/int has no difference in encoding, int not good for negative, use sint for negative
+message TestNatResponse {
+  int32 port = 1; 
+  ConfigUpdate cu = 2; // for mobile
+}
+
+enum NatType {
+  UNKNOWN_NAT = 0;
+  ASYMMETRIC = 1;
+  SYMMETRIC = 2;
+}
+
+message PunchHoleSent {
+  bytes socket_addr = 1;
+  string id = 2;
+  string relay_server = 3;
+  NatType nat_type = 4;
+}
+
+message RegisterPk {
+  string id = 1;
+  bytes uuid = 2;
+  bytes pk = 3;
+}
+
+message RegisterPkResponse {
+  enum Result {
+    OK = 1;
+    UUID_MISMATCH = 2;
+  }
+  Result result = 1;
+}
+
+message PunchHoleResponse {
+  bytes socket_addr = 1;
+  bytes pk = 2;
+  enum Failure {
+    ID_NOT_EXIST = 1;
+    OFFLINE = 2;
+  }
+  Failure failure = 3;
+  string relay_server = 4;
+  oneof union {
+    NatType nat_type = 5;
+    bool is_local = 6;
+  }
+}
+
+message ConfigUpdate {
+  int32 serial = 1;
+  repeated string rendezvous_servers = 2;
+}
+
+message RequestRelay {
+  string id = 1;
+  string uuid = 2;
+  bytes socket_addr = 3;
+  string relay_server = 4;
+  bool secure = 5;
+}
+
+message RelayResponse {
+  bytes socket_addr = 1;
+  string uuid = 2;
+  string relay_server = 3;
+  oneof union {
+    string id = 4;
+    bytes pk = 5;
+  }
+}
+
+message SoftwareUpdate { string url = 1; }
+
+// if in same intranet, punch hole won't work both for udp and tcp,
+// even some router has below connection error if we connect itself,
+//  { kind: Other, error: "could not resolve to any address" },
+// so we request local address to connect.
+message FetchLocalAddr { 
+  bytes socket_addr = 1; 
+  string relay_server = 2;
+}
+
+message LocalAddr {
+  bytes socket_addr = 1;
+  bytes local_addr = 2;
+  string relay_server = 3;
+}
+
+message RendezvousMessage {
+  oneof union {
+    RegisterPeer register_peer = 6;
+    RegisterPeerResponse register_peer_response = 7;
+    PunchHoleRequest punch_hole_request = 8;
+    PunchHole punch_hole = 9;
+    PunchHoleSent punch_hole_sent = 10;
+    PunchHoleResponse punch_hole_response = 11;
+    FetchLocalAddr fetch_local_addr = 12;
+    LocalAddr local_addr = 13;
+    ConfigUpdate configure_update = 14;
+    RegisterPk register_pk = 15;
+    RegisterPkResponse register_pk_response = 16;
+    SoftwareUpdate software_update = 17;
+    RequestRelay request_relay = 18;
+    RelayResponse relay_response = 19;
+    TestNatRequest test_nat_request = 20;
+    TestNatResponse test_nat_response = 21;
+  }
+}

libs/hbb_common/src/bytes_codec.rs

+use bytes::{Buf, BufMut, Bytes, BytesMut};
+use std::io;
+use tokio_util::codec::{Decoder, Encoder};
+
+#[derive(Debug, Clone, Copy)]
+pub struct BytesCodec {
+    state: DecodeState,
+    raw: bool,
+    max_packet_length: usize,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum DecodeState {
+    Head,
+    Data(usize),
+}
+
+impl BytesCodec {
+    pub fn new() -> Self {
+        Self {
+            state: DecodeState::Head,
+            raw: false,
+            max_packet_length: usize::MAX,
+        }
+    }
+
+    pub fn set_raw(&mut self) {
+        self.raw = true;
+    }
+
+    pub fn set_max_packet_length(&mut self, n: usize) {
+        self.max_packet_length = n;
+    }
+
+    fn decode_head(&mut self, src: &mut BytesMut) -> io::Result<Option<usize>> {
+        if src.is_empty() {
+            return Ok(None);
+        }
+        let head_len = ((src[0] & 0x3) + 1) as usize;
+        if src.len() < head_len {
+            return Ok(None);
+        }
+        let mut n = src[0] as usize;
+        if head_len > 1 {
+            n |= (src[1] as usize) << 8;
+        }
+        if head_len > 2 {
+            n |= (src[2] as usize) << 16;
+        }
+        if head_len > 3 {
+            n |= (src[3] as usize) << 24;
+        }
+        n >>= 2;
+        if n > self.max_packet_length {
+            return Err(io::Error::new(io::ErrorKind::InvalidData, "Too big packet"));
+        }
+        src.advance(head_len);
+        src.reserve(n);
+        return Ok(Some(n));
+    }
+
+    fn decode_data(&self, n: usize, src: &mut BytesMut) -> io::Result<Option<BytesMut>> {
+        if src.len() < n {
+            return Ok(None);
+        }
+        Ok(Some(src.split_to(n)))
+    }
+}
+
+impl Decoder for BytesCodec {
+    type Item = BytesMut;
+    type Error = io::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<BytesMut>, io::Error> {
+        if self.raw {
+            if !src.is_empty() {
+                let len = src.len();
+                return Ok(Some(src.split_to(len)));
+            } else {
+                return Ok(None);
+            }
+        }
+        let n = match self.state {
+            DecodeState::Head => match self.decode_head(src)? {
+                Some(n) => {
+                    self.state = DecodeState::Data(n);
+                    n
+                }
+                None => return Ok(None),
+            },
+            DecodeState::Data(n) => n,
+        };
+
+        match self.decode_data(n, src)? {
+            Some(data) => {
+                self.state = DecodeState::Head;
+                Ok(Some(data))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
+impl Encoder<Bytes> for BytesCodec {
+    type Error = io::Error;
+
+    fn encode(&mut self, data: Bytes, buf: &mut BytesMut) -> Result<(), io::Error> {
+        if self.raw {
+            buf.reserve(data.len());
+            buf.put(data);
+            return Ok(());
+        }
+        if data.len() <= 0x3F {
+            buf.put_u8((data.len() << 2) as u8);
+        } else if data.len() <= 0x3FFF {
+            buf.put_u16_le((data.len() << 2) as u16 | 0x1);
+        } else if data.len() <= 0x3FFFFF {
+            let h = (data.len() << 2) as u32 | 0x2;
+            buf.put_u16_le((h & 0xFFFF) as u16);
+            buf.put_u8((h >> 16) as u8);
+        } else if data.len() <= 0x3FFFFFFF {
+            buf.put_u32_le((data.len() << 2) as u32 | 0x3);
+        } else {
+            return Err(io::Error::new(io::ErrorKind::InvalidInput, "Overflow"));
+        }
+        buf.extend(data);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_codec1() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3F, 1);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        let buf_saved = buf.clone();
+        assert_eq!(buf.len(), 0x3F + 1);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3F);
+            assert_eq!(res[0], 1);
+        } else {
+            assert!(false);
+        }
+        let mut codec2 = BytesCodec::new();
+        let mut buf2 = BytesMut::new();
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[0..1]);
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[1..]);
+        if let Ok(Some(res)) = codec2.decode(&mut buf2) {
+            assert_eq!(res.len(), 0x3F);
+            assert_eq!(res[0], 1);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec2() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        assert!(!codec.encode("".into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 1);
+        bytes.resize(0x3F + 1, 2);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3F + 2 + 2);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0);
+        } else {
+            assert!(false);
+        }
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3F + 1);
+            assert_eq!(res[0], 2);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec3() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3F - 1, 3);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3F + 1 - 1);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3F - 1);
+            assert_eq!(res[0], 3);
+        } else {
+            assert!(false);
+        }
+    }
+    #[test]
+    fn test_codec4() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3FFF, 4);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3FFF + 2);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3FFF);
+            assert_eq!(res[0], 4);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec5() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3FFFFF, 5);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        assert_eq!(buf.len(), 0x3FFFFF + 3);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3FFFFF);
+            assert_eq!(res[0], 5);
+        } else {
+            assert!(false);
+        }
+    }
+
+    #[test]
+    fn test_codec6() {
+        let mut codec = BytesCodec::new();
+        let mut buf = BytesMut::new();
+        let mut bytes: Vec<u8> = Vec::new();
+        bytes.resize(0x3FFFFF + 1, 6);
+        assert!(!codec.encode(bytes.into(), &mut buf).is_err());
+        let buf_saved = buf.clone();
+        assert_eq!(buf.len(), 0x3FFFFF + 4 + 1);
+        if let Ok(Some(res)) = codec.decode(&mut buf) {
+            assert_eq!(res.len(), 0x3FFFFF + 1);
+            assert_eq!(res[0], 6);
+        } else {
+            assert!(false);
+        }
+        let mut codec2 = BytesCodec::new();
+        let mut buf2 = BytesMut::new();
+        buf2.extend(&buf_saved[0..1]);
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[1..6]);
+        if let Ok(None) = codec2.decode(&mut buf2) {
+        } else {
+            assert!(false);
+        }
+        buf2.extend(&buf_saved[6..]);
+        if let Ok(Some(res)) = codec2.decode(&mut buf2) {
+            assert_eq!(res.len(), 0x3FFFFF + 1);
+            assert_eq!(res[0], 6);
+        } else {
+            assert!(false);
+        }
+    }
+}

libs/hbb_common/src/compress.rs

+use std::cell::RefCell;
+use zstd::block::{Compressor, Decompressor};
+
+thread_local! {
+    static COMPRESSOR: RefCell<Compressor> = RefCell::new(Compressor::new());
+    static DECOMPRESSOR: RefCell<Decompressor> = RefCell::new(Decompressor::new());
+}
+
+/// The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),
+/// which is currently 22. Levels >= 20
+/// Default level is ZSTD_CLEVEL_DEFAULT==3.
+/// value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT
+pub fn compress(data: &[u8], level: i32) -> Vec<u8> {
+    let mut out = Vec::new();
+    COMPRESSOR.with(|c| {
+        if let Ok(mut c) = c.try_borrow_mut() {
+            match c.compress(data, level) {
+                Ok(res) => out = res,
+                Err(err) => {
+                    crate::log::debug!("Failed to compress: {}", err);
+                }
+            }
+        }
+    });
+    out
+}
+
+pub fn decompress(data: &[u8]) -> Vec<u8> {
+    let mut out = Vec::new();
+    DECOMPRESSOR.with(|d| {
+        if let Ok(mut d) = d.try_borrow_mut() {
+            const MAX: usize = 1024 * 1024 * 64;
+            const MIN: usize = 1024 * 1024;
+            let mut n = 30 * data.len();
+            if n > MAX {
+                n = MAX;
+            }
+            if n < MIN {
+                n = MIN;
+            }
+            match d.decompress(data, n) {
+                Ok(res) => out = res,
+                Err(err) => {
+                    crate::log::debug!("Failed to decompress: {}", err);
+                }
+            }
+        }
+    });
+    out
+}

libs/hbb_common/src/lib.rs

+pub mod compress;
+#[path = "./protos/message.rs"]
+pub mod message_proto;
+#[path = "./protos/rendezvous.rs"]
+pub mod rendezvous_proto;
+pub use bytes;
+pub use futures;
+pub use protobuf;
+use socket2::{Domain, Socket, Type};
+use std::{
+    fs::File,
+    io::{self, BufRead},
+    net::{Ipv4Addr, SocketAddr, SocketAddrV4, ToSocketAddrs},
+    path::Path,
+    time::{self, SystemTime, UNIX_EPOCH},
+};
+pub use tokio;
+pub use tokio_util;
+pub mod tcp;
+pub mod udp;
+pub use env_logger;
+pub use log;
+pub mod bytes_codec;
+#[cfg(feature = "quic")]
+pub mod quic;
+pub use anyhow::{self, bail};
+pub use futures_util;
+pub mod config;
+pub mod fs;
+pub use sodiumoxide;
+
+#[cfg(feature = "quic")]
+pub type Stream = quic::Connection;
+#[cfg(not(feature = "quic"))]
+pub type Stream = tcp::FramedStream;
+
+#[inline]
+pub async fn sleep(sec: f32) {
+    tokio::time::delay_for(time::Duration::from_secs_f32(sec)).await;
+}
+
+#[macro_export]
+macro_rules! allow_err {
+    ($e:expr) => {
+        if let Err(err) = $e {
+            log::debug!(
+                "{:?}, {}:{}:{}:{}",
+                err,
+                module_path!(),
+                file!(),
+                line!(),
+                column!()
+            );
+        } else {
+        }
+    };
+}
+
+#[inline]
+pub fn timeout<T: std::future::Future>(ms: u64, future: T) -> tokio::time::Timeout<T> {
+    tokio::time::timeout(std::time::Duration::from_millis(ms), future)
+}
+
+fn new_socket(addr: SocketAddr, tcp: bool, reuse: bool) -> Result<Socket, std::io::Error> {
+    let stype = {
+        if tcp {
+            Type::stream()
+        } else {
+            Type::dgram()
+        }
+    };
+    let socket = match addr {
+        SocketAddr::V4(..) => Socket::new(Domain::ipv4(), stype, None),
+        SocketAddr::V6(..) => Socket::new(Domain::ipv6(), stype, None),
+    }?;
+    if reuse {
+        // windows has no reuse_port, but it's reuse_address
+        // almost equals to unix's reuse_port + reuse_address,
+        // though may introduce nondeterministic bahavior
+        #[cfg(unix)]
+        socket.set_reuse_port(true)?;
+        socket.set_reuse_address(true)?;
+    }
+    socket.bind(&addr.into())?;
+    Ok(socket)
+}
+
+pub type ResultType<F, E = anyhow::Error> = anyhow::Result<F, E>;
+
+/// Certain router and firewalls scan the packet and if they
+/// find an IP address belonging to their pool that they use to do the NAT mapping/translation, so here we mangle the ip address
+
+pub struct AddrMangle();
+
+impl AddrMangle {
+    pub fn encode(addr: SocketAddr) -> Vec<u8> {
+        match addr {
+            SocketAddr::V4(addr_v4) => {
+                let tm = (SystemTime::now()
+                    .duration_since(UNIX_EPOCH)
+                    .unwrap()
+                    .as_micros() as u32) as u128;
+                let ip = u32::from_ne_bytes(addr_v4.ip().octets()) as u128;
+                let port = addr.port() as u128;
+                let v = ((ip + tm) << 49) | (tm << 17) | (port + (tm & 0xFFFF));
+                let bytes = v.to_ne_bytes();
+                let mut n_padding = 0;
+                for i in bytes.iter().rev() {
+                    if i == &0u8 {
+                        n_padding += 1;
+                    } else {
+                        break;
+                    }
+                }
+                bytes[..(16 - n_padding)].to_vec()
+            }
+            _ => {
+                panic!("Only support ipv4");
+            }
+        }
+    }
+
+    pub fn decode(bytes: &[u8]) -> SocketAddr {
+        let mut padded = [0u8; 16];
+        padded[..bytes.len()].copy_from_slice(&bytes);
+        let number = u128::from_ne_bytes(padded);
+        let tm = (number >> 17) & (u32::max_value() as u128);
+        let ip = (((number >> 49) - tm) as u32).to_ne_bytes();
+        let port = (number & 0xFFFFFF) - (tm & 0xFFFF);
+        SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::new(ip[0], ip[1], ip[2], ip[3]),
+            port as u16,
+        ))
+    }
+}
+
+pub fn get_version_from_url(url: &str) -> String {
+    let n = url.chars().count();
+    let a = url
+        .chars()
+        .rev()
+        .enumerate()
+        .filter(|(_, x)| x == &'-')
+        .next()
+        .map(|(i, _)| i);
+    if let Some(a) = a {
+        let b = url
+            .chars()
+            .rev()
+            .enumerate()
+            .filter(|(_, x)| x == &'.')
+            .next()
+            .map(|(i, _)| i);
+        if let Some(b) = b {
+            if a > b {
+                if url
+                    .chars()
+                    .skip(n - b)
+                    .collect::<String>()
+                    .parse::<i32>()
+                    .is_ok()
+                {
+                    return url.chars().skip(n - a).collect();
+                } else {
+                    return url.chars().skip(n - a).take(a - b - 1).collect();
+                }
+            } else {
+                return url.chars().skip(n - a).collect();
+            }
+        }
+    }
+    "".to_owned()
+}
+
+pub fn to_socket_addr(host: &str) -> ResultType<SocketAddr> {
+    let addrs: Vec<SocketAddr> = host.to_socket_addrs()?.collect();
+    if addrs.is_empty() {
+        bail!("Failed to solve {}", host);
+    }
+    Ok(addrs[0])
+}
+
+pub fn gen_version() {
+    let mut file = File::create("./src/version.rs").unwrap();
+    for line in read_lines("Cargo.toml").unwrap() {
+        if let Ok(line) = line {
+            let ab: Vec<&str> = line.split("=").map(|x| x.trim()).collect();
+            if ab.len() == 2 && ab[0] == "version" {
+                use std::io::prelude::*;
+                file.write_all(format!("pub const VERSION: &str = {};", ab[1]).as_bytes())
+                    .ok();
+                file.sync_all().ok();
+                break;
+            }
+        }
+    }
+}
+
+fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
+where
+    P: AsRef<Path>,
+{
+    let file = File::open(filename)?;
+    Ok(io::BufReader::new(file).lines())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_mangle() {
+        let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 168, 16, 32), 21116));
+        assert_eq!(addr, AddrMangle::decode(&AddrMangle::encode(addr)));
+    }
+}

libs/hbb_common/src/quic.rs

+use crate::{allow_err, anyhow::anyhow, ResultType};
+use protobuf::Message;
+use std::{net::SocketAddr, sync::Arc};
+use tokio::{self, stream::StreamExt, sync::mpsc};
+
+const QUIC_HBB: &[&[u8]] = &[b"hbb"];
+const SERVER_NAME: &str = "hbb";
+
+type Sender = mpsc::UnboundedSender<Value>;
+type Receiver = mpsc::UnboundedReceiver<Value>;
+
+pub fn new_server(socket: std::net::UdpSocket) -> ResultType<(Server, SocketAddr)> {
+    let mut transport_config = quinn::TransportConfig::default();
+    transport_config.stream_window_uni(0);
+    let mut server_config = quinn::ServerConfig::default();
+    server_config.transport = Arc::new(transport_config);
+    let mut server_config = quinn::ServerConfigBuilder::new(server_config);
+    server_config.protocols(QUIC_HBB);
+    // server_config.enable_keylog();
+    // server_config.use_stateless_retry(true);
+    let mut endpoint = quinn::Endpoint::builder();
+    endpoint.listen(server_config.build());
+    let (end, incoming) = endpoint.with_socket(socket)?;
+    Ok((Server { incoming }, end.local_addr()?))
+}
+
+pub async fn new_client(local_addr: &SocketAddr, peer: &SocketAddr) -> ResultType<Connection> {
+    let mut endpoint = quinn::Endpoint::builder();
+    let mut client_config = quinn::ClientConfigBuilder::default();
+    client_config.protocols(QUIC_HBB);
+    //client_config.enable_keylog();
+    endpoint.default_client_config(client_config.build());
+    let (endpoint, _) = endpoint.bind(local_addr)?;
+    let new_conn = endpoint.connect(peer, SERVER_NAME)?.await?;
+    Connection::new_for_client(new_conn.connection).await
+}
+
+pub struct Server {
+    incoming: quinn::Incoming,
+}
+
+impl Server {
+    #[inline]
+    pub async fn next(&mut self) -> ResultType<Option<Connection>> {
+        Connection::new_for_server(&mut self.incoming).await
+    }
+}
+
+pub struct Connection {
+    conn: quinn::Connection,
+    tx: quinn::SendStream,
+    rx: Receiver,
+}
+
+type Value = ResultType<Vec<u8>>;
+
+impl Connection {
+    async fn new_for_server(incoming: &mut quinn::Incoming) -> ResultType<Option<Self>> {
+        if let Some(conn) = incoming.next().await {
+            let quinn::NewConnection {
+                connection: conn,
+                // uni_streams,
+                mut bi_streams,
+                ..
+            } = conn.await?;
+            let (tx, rx) = mpsc::unbounded_channel::<Value>();
+            tokio::spawn(async move {
+                loop {
+                    let stream = bi_streams.next().await;
+                    if let Some(stream) = stream {
+                        let stream = match stream {
+                            Err(e) => {
+                                tx.send(Err(e.into())).ok();
+                                break;
+                            }
+                            Ok(s) => s,
+                        };
+                        let cloned = tx.clone();
+                        tokio::spawn(async move {
+                            allow_err!(handle_request(stream.1, cloned).await);
+                        });
+                    } else {
+                        tx.send(Err(anyhow!("Reset by the peer"))).ok();
+                        break;
+                    }
+                }
+                log::info!("Exit connection outer loop");
+            });
+            let tx = conn.open_uni().await?;
+            Ok(Some(Self { conn, tx, rx }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn new_for_client(conn: quinn::Connection) -> ResultType<Self> {
+        let (tx, rx_quic) = conn.open_bi().await?;
+        let (tx_mpsc, rx) = mpsc::unbounded_channel::<Value>();
+        tokio::spawn(async move {
+            allow_err!(handle_request(rx_quic, tx_mpsc).await);
+        });
+        Ok(Self { conn, tx, rx })
+    }
+
+    #[inline]
+    pub async fn next(&mut self) -> Option<Value> {
+        // None is returned when all Sender halves have dropped,
+        // indicating that no further values can be sent on the channel.
+        self.rx.recv().await
+    }
+
+    #[inline]
+    pub fn remote_address(&self) -> SocketAddr {
+        self.conn.remote_address()
+    }
+
+    #[inline]
+    pub async fn send_raw(&mut self, bytes: &[u8]) -> ResultType<()> {
+        self.tx.write_all(bytes).await?;
+        Ok(())
+    }
+
+    #[inline]
+    pub async fn send(&mut self, msg: &dyn Message) -> ResultType<()> {
+        match msg.write_to_bytes() {
+            Ok(bytes) => self.send_raw(&bytes).await?,
+            err => allow_err!(err),
+        }
+        Ok(())
+    }
+}
+
+async fn handle_request(rx: quinn::RecvStream, tx: Sender) -> ResultType<()> {
+    Ok(())
+}

libs/magnum-opus/.gitignore

+target
+Cargo.lock

libs/magnum-opus/Cargo.toml

+[package]
+name = "magnum-opus"
+version = "0.3.4"
+authors = ["Tad Hardesty <tad@platymuus.com>", "Sergey Duck <sergeypechnikov326@gmail.com>"]
+edition = "2018"
+description = "Safe Rust bindings for libopus"
+readme = "README.md"
+license = "MIT/Apache-2.0"
+keywords = ["opus", "codec", "voice", "sound", "audio"]
+categories = ["api-bindings", "encoding", "compression",
+	"multimedia::audio", "multimedia::encoding"]
+
+repository = "https://github.com/DuckerMan/magnum-opus"
+documentation = "https://docs.rs/magnum-opus"
+
+[build-dependencies]
+target_build_utils = "0.3"
+bindgen = "0.53"

libs/magnum-opus/LICENSE-MIT

+Copyright (c) 2016 Tad Hardesty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

libs/magnum-opus/README.md

+# magnum-opus [![](https://meritbadge.herokuapp.com/magnum-opus)](https://crates.io/crates/magnum-opus) [![](https://img.shields.io/badge/docs-online-2020ff.svg)](https://docs.rs/magnum-opus)
+
+### This is the fork of @SpaceManiac repo, which now is abandoned
+
+Safe Rust bindings for libopus. The rustdoc (available through `cargo doc`)
+includes brief descriptions for methods, and detailed API information can be
+found at the [libopus documentation](https://opus-codec.org/docs/opus_api-1.1.2/).
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.

libs/magnum-opus/opus_ffi.h

+#include <opus/opus_multistream.h>