1berry/rustdesk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove useless files

Browse Source
This commit is contained in:
rustdesk 2025-01-30 13:49:37 +08:00
parent 5fc8e8c428
commit 8b24b195a2
12 changed files with 0 additions and 2912 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
entrypoint.sh
View File

@ -1,36 +0,0 @@
#!/bin/sh
cd "$HOME"/rustdesk || exit 1
# shellcheck source=/dev/null
. "$HOME"/.cargo/env
argv=$*
while test $# -gt 0; do
case "$1" in
--release)
mkdir -p target/release
test -f target/release/libsciter-gtk.so || cp "$HOME"/libsciter-gtk.so target/release/
release=1
shift
;;
--target)
shift
if test $# -gt 0; then
rustup target add "$1"
shift
fi
;;
*)
shift
;;
esac
done
if [ -z $release ]; then
mkdir -p target/debug
test -f target/debug/libsciter-gtk.so || cp "$HOME"/libsciter-gtk.so target/debug/
fi
set -f
#shellcheck disable=2086
VCPKG_ROOT=/vcpkg cargo build $argv

1
vdi/README.md
View File

@ -1 +0,0 @@
# WIP

2
vdi/host/.cargo/config.toml
View File

@ -1,2 +0,0 @@
[registries.crates-io]
protocol = "sparse"

1
vdi/host/.gitignore vendored
View File

@ -1 +0,0 @@
/target

2543
vdi/host/Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

13
vdi/host/Cargo.toml
View File

@ -1,13 +0,0 @@
[package]
name = "qemu-rustdesk"
version = "0.1.0"
authors = ["rustdesk <info@rustdesk.com>"]
edition = "2021"
[dependencies]
qemu-display = { git = "https://github.com/rustdesk/qemu-display" }
hbb_common = { path = "../../libs/hbb_common" }
clap = { version = "4.1", features = ["derive"] }
zbus = { version = "3.14.1" }
image = "0.24"
async-trait = "0.1"

5
vdi/host/README.md
View File

@ -1,5 +0,0 @@
# RustDesk protocol on QEMU D-Bus display
```
sudo apt install libusbredirparser-dev libusbredirhost-dev libusb-1.0-0-dev
```

11
vdi/host/src/connection.rs
View File

@ -1,11 +0,0 @@
use hbb_common::{message_proto::*, tokio, ResultType};
pub use tokio::sync::{mpsc, Mutex};
pub struct Connection {
pub tx: mpsc::UnboundedSender<Message>,
}
impl Connection {
pub async fn on_message(&mut self, message: Message) -> ResultType<bool> {
Ok(true)
}
}

119
vdi/host/src/console.rs
View File

@ -1,119 +0,0 @@
use hbb_common::{tokio, ResultType};
use image::GenericImage;
use qemu_display::{Console, ConsoleListenerHandler, MouseButton};
use std::{collections::HashSet, sync::Arc};
pub use tokio::sync::{mpsc, Mutex};
#[derive(Debug)]
pub enum Event {
ConsoleUpdate((i32, i32, i32, i32)),
Disconnected,
}
const PIXMAN_X8R8G8B8: u32 = 0x20020888;
pub type BgraImage = image::ImageBuffer<image::Rgba<u8>, Vec<u8>>;
#[derive(Debug)]
pub struct ConsoleListener {
pub image: Arc<Mutex<BgraImage>>,
pub tx: mpsc::UnboundedSender<Event>,
}
#[async_trait::async_trait]
impl ConsoleListenerHandler for ConsoleListener {
async fn scanout(&mut self, s: qemu_display::Scanout) {
*self.image.lock().await = image_from_vec(s.format, s.width, s.height, s.stride, s.data);
}
async fn update(&mut self, u: qemu_display::Update) {
let update = image_from_vec(u.format, u.w as _, u.h as _, u.stride, u.data);
let mut image = self.image.lock().await;
if (u.x, u.y) == (0, 0) && update.dimensions() == image.dimensions() {
*image = update;
} else {
image.copy_from(&update, u.x as _, u.y as _).unwrap();
}
self.tx
.send(Event::ConsoleUpdate((u.x, u.y, u.w, u.h)))
.ok();
}
async fn scanout_dmabuf(&mut self, _scanout: qemu_display::ScanoutDMABUF) {
unimplemented!()
}
async fn update_dmabuf(&mut self, _update: qemu_display::UpdateDMABUF) {
unimplemented!()
}
async fn mouse_set(&mut self, set: qemu_display::MouseSet) {
dbg!(set);
}
async fn cursor_define(&mut self, cursor: qemu_display::Cursor) {
dbg!(cursor);
}
fn disconnected(&mut self) {
self.tx.send(Event::Disconnected).ok();
}
}
pub async fn key_event(console: &mut Console, qnum: u32, down: bool) -> ResultType<()> {
if down {
console.keyboard.press(qnum).await?;
} else {
console.keyboard.release(qnum).await?;
}
Ok(())
}
fn image_from_vec(format: u32, width: u32, height: u32, stride: u32, data: Vec<u8>) -> BgraImage {
if format != PIXMAN_X8R8G8B8 {
todo!("unhandled pixman format: {}", format)
}
if cfg!(target_endian = "big") {
todo!("pixman/image in big endian")
}
let layout = image::flat::SampleLayout {
channels: 4,
channel_stride: 1,
width,
width_stride: 4,
height,
height_stride: stride as _,
};
let samples = image::flat::FlatSamples {
samples: data,
layout,
color_hint: None,
};
samples
.try_into_buffer::<image::Rgba<u8>>()
.or_else::<&str, _>(|(_err, samples)| {
let view = samples.as_view::<image::Rgba<u8>>().unwrap();
let mut img = BgraImage::new(width, height);
img.copy_from(&view, 0, 0).unwrap();
Ok(img)
})
.unwrap()
}
fn button_mask_to_set(mask: u8) -> HashSet<MouseButton> {
let mut set = HashSet::new();
if mask & 0b0000_0001 != 0 {
set.insert(MouseButton::Left);
}
if mask & 0b0000_0010 != 0 {
set.insert(MouseButton::Middle);
}
if mask & 0b0000_0100 != 0 {
set.insert(MouseButton::Right);
}
if mask & 0b0000_1000 != 0 {
set.insert(MouseButton::WheelUp);
}
if mask & 0b0001_0000 != 0 {
set.insert(MouseButton::WheelDown);
}
set
}

3
vdi/host/src/lib.rs
View File

@ -1,3 +0,0 @@
pub mod server;
mod console;
mod connection;

6
vdi/host/src/main.rs
View File

@ -1,6 +0,0 @@
fn main() {
hbb_common::init_log(false, "");
if let Err(err) = qemu_rustdesk::server::run() {
hbb_common::log::error!("{err}");
}
}

172
vdi/host/src/server.rs
View File

@ -1,172 +0,0 @@
use clap::Parser;
use hbb_common::{
allow_err,
anyhow::{bail, Context},
log,
message_proto::*,
protobuf::Message as _,
tokio,
tokio::net::TcpListener,
ResultType, Stream,
};
use qemu_display::{Console, VMProxy};
use std::{borrow::Borrow, sync::Arc};
use crate::connection::*;
use crate::console::*;
#[derive(Parser, Debug)]
pub struct SocketAddrArgs {
/// IP address
#[clap(short, long, default_value = "0.0.0.0")]
address: std::net::IpAddr,
/// IP port number
#[clap(short, long, default_value = "21116")]
port: u16,
}
impl From<SocketAddrArgs> for std::net::SocketAddr {
fn from(args: SocketAddrArgs) -> Self {
(args.address, args.port).into()
}
}
#[derive(Parser, Debug)]
struct Cli {
#[clap(flatten)]
address: SocketAddrArgs,
#[clap(short, long)]
dbus_address: Option<String>,
}
#[derive(Debug)]
struct Server {
vm_name: String,
rx_console: mpsc::UnboundedReceiver<Event>,
tx_console: mpsc::UnboundedSender<Event>,
rx_conn: mpsc::UnboundedReceiver<Message>,
tx_conn: mpsc::UnboundedSender<Message>,
image: Arc<Mutex<BgraImage>>,
console: Arc<Mutex<Console>>,
}
impl Server {
async fn new(vm_name: String, console: Console) -> ResultType<Server> {
let width = console.width().await?;
let height = console.height().await?;
let image = BgraImage::new(width as _, height as _);
let (tx_console, rx_console) = mpsc::unbounded_channel();
let (tx_conn, rx_conn) = mpsc::unbounded_channel();
Ok(Self {
vm_name,
rx_console,
tx_console,
rx_conn,
tx_conn,
image: Arc::new(Mutex::new(image)),
console: Arc::new(Mutex::new(console)),
})
}
async fn stop_console(&self) -> ResultType<()> {
self.console.lock().await.unregister_listener();
Ok(())
}
async fn run_console(&self) -> ResultType<()> {
self.console
.lock()
.await
.register_listener(ConsoleListener {
image: self.image.clone(),
tx: self.tx_console.clone(),
})
.await?;
Ok(())
}
async fn dimensions(&self) -> (u16, u16) {
let image = self.image.lock().await;
(image.width() as u16, image.height() as u16)
}
async fn handle_connection(&mut self, stream: Stream) -> ResultType<()> {
let mut stream = stream;
self.run_console().await?;
let mut conn = Connection {
tx: self.tx_conn.clone(),
};
loop {
tokio::select! {
Some(evt) = self.rx_console.recv() => {
match evt {
_ => {}
}
}
Some(msg) = self.rx_conn.recv() => {
allow_err!(stream.send(&msg).await);
}
res = stream.next() => {
if let Some(res) = res {
match res {
Err(err) => {
bail!(err);
}
Ok(bytes) => {
if let Ok(msg_in) = Message::parse_from_bytes(&bytes) {
match conn.on_message(msg_in).await {
Ok(false) => {
break;
}
Err(err) => {
log::error!("{err}");
}
_ => {}
}
}
}
}
} else {
bail!("Reset by the peer");
}
}
}
}
self.stop_console().await?;
Ok(())
}
}
#[tokio::main]
pub async fn run() -> ResultType<()> {
let args = Cli::parse();
let listener = TcpListener::bind::<std::net::SocketAddr>(args.address.into())
.await
.unwrap();
let dbus = if let Some(addr) = args.dbus_address {
zbus::ConnectionBuilder::address(addr.borrow())?
.build()
.await
} else {
zbus::Connection::session().await
}
.context("Failed to connect to DBus")?;
let vm_name = VMProxy::new(&dbus).await?.name().await?;
let console = Console::new(&dbus.into(), 0)
.await
.context("Failed to get the console")?;
let mut server = Server::new(format!("qemu-rustdesk ({})", vm_name), console).await?;
loop {
let (stream, addr) = listener.accept().await?;
stream.set_nodelay(true).ok();
let laddr = stream.local_addr()?;
let stream = Stream::from(stream, laddr);
if let Err(err) = server.handle_connection(stream).await {
log::error!("Connection from {addr} closed: {err}");
}
}
}