mirror of
https://github.com/rustdesk/rustdesk.git
synced 2025-05-10 18:06:01 +02:00
remove useless files
This commit is contained in:
rustdesk
parent
5fc8e8c428
commit
8b24b195a2
12 changed files with 0 additions and 2912 deletions
|
|
@ -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 +0,0 @@
|
|||
# WIP
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
[registries.crates-io]
|
||||
protocol = "sparse"
|
||||
1
vdi/host/.gitignore
vendored
1
vdi/host/.gitignore
vendored
|
|
@ -1 +0,0 @@
|
|||
/target
|
||||
2543
vdi/host/Cargo.lock
generated
2543
vdi/host/Cargo.lock
generated
File diff suppressed because it is too large
Load diff
|
|
@ -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"
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
# RustDesk protocol on QEMU D-Bus display
|
||||
|
||||
```
|
||||
sudo apt install libusbredirparser-dev libusbredirhost-dev libusb-1.0-0-dev
|
||||
```
|
||||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
pub mod server;
|
||||
mod console;
|
||||
mod connection;
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
fn main() {
|
||||
hbb_common::init_log(false, "");
|
||||
if let Err(err) = qemu_rustdesk::server::run() {
|
||||
hbb_common::log::error!("{err}");
|
||||
}
|
||||
}
|
||||
|
|
@ -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}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue