Building an RDP Server

let server_builder = RdpServer::builder()
    .with_addr(bind_addr)
    .with_no_security();

let identity = TlsIdentityCtx::init_from_paths("cert.pem", "key.pem")?;
let acceptor = identity.make_acceptor()?;

let server_builder = RdpServer::builder()
    .with_addr(bind_addr)
    .with_tls(acceptor);

let identity = TlsIdentityCtx::init_from_paths("cert.pem", "key.pem")?;
let acceptor = identity.make_acceptor()?;

let server_builder = RdpServer::builder()
    .with_addr(bind_addr)
    .with_hybrid(acceptor, identity.pub_key);

use ironrdp::cliprdr::backend::{CliprdrBackend, CliprdrBackendFactory};
use ironrdp::server::{CliprdrServerFactory, ServerEventSender, ServerEvent};
use ironrdp::server::tokio::sync::mpsc::UnboundedSender;
use ironrdp_cliprdr_native::StubCliprdrBackend;

struct MyCliprdrFactory;

impl CliprdrBackendFactory for MyCliprdrFactory {
    fn build_cliprdr_backend(&self) -> Box<dyn CliprdrBackend> {
        Box::new(StubCliprdrBackend::new())
    }
}

impl ServerEventSender for MyCliprdrFactory {
    fn set_sender(&mut self, _sender: UnboundedSender<ServerEvent>) {}
}

impl CliprdrServerFactory for MyCliprdrFactory {}

let cliprdr = Box::new(MyCliprdrFactory);

let server = server_builder
    .with_input_handler(handler.clone())
    .with_display_handler(handler)
    .with_cliprdr_factory(Some(cliprdr))
    .build();

use ironrdp::rdpsnd::pdu::{AudioFormat, WaveFormat};
use ironrdp::rdpsnd::server::{RdpsndServerHandler, RdpsndServerMessage};
use ironrdp::server::SoundServerFactory;

struct AudioHandler;

impl RdpsndServerHandler for AudioHandler {
    fn get_formats(&self) -> &[AudioFormat] {
        &[
            AudioFormat {
                format: WaveFormat::PCM,
                n_channels: 2,
                n_samples_per_sec: 44100,
                n_avg_bytes_per_sec: 176400,
                n_block_align: 4,
                bits_per_sample: 16,
                data: None,
            },
        ]
    }

    fn start(&mut self, client_format: &ClientAudioFormatPdu) -> Option<u16> {
        // Start audio streaming
        Some(0) // Format index
    }

    fn stop(&mut self) {
        // Stop audio streaming
    }
}

struct AudioFactory;

impl SoundServerFactory for AudioFactory {
    fn build_backend(&self) -> Box<dyn RdpsndServerHandler> {
        Box::new(AudioHandler)
    }
}

impl ServerEventSender for AudioFactory {
    fn set_sender(&mut self, sender: UnboundedSender<ServerEvent>) {
        // Store sender to push audio frames
    }
}

let sound = Box::new(AudioFactory);

let server = server_builder
    .with_sound_factory(Some(sound))
    .build();

impl RdpServerDisplayUpdates for MyDisplayUpdates {
    async fn next_update(&mut self) -> anyhow::Result<Option<DisplayUpdate>> {
        // Wait for next frame from screen capture
        let frame = self.screen_capture.next_frame().await?;

        // Only send changed regions (dirty rectangles)
        if let Some(dirty_rect) = frame.changed_region {
            let bitmap = BitmapUpdate {
                x: dirty_rect.x,
                y: dirty_rect.y,
                width: dirty_rect.width,
                height: dirty_rect.height,
                format: PixelFormat::BgrA32,
                data: frame.pixels.into(),
                stride: frame.stride,
            };
            Ok(Some(DisplayUpdate::Bitmap(bitmap)))
        } else {
            // No changes, wait a bit
            tokio::time::sleep(Duration::from_millis(16)).await;
            Ok(None)
        }
    }
}

server.set_credentials(Some(Credentials {
    username: "admin".to_owned(),
    password: "secure_password".to_owned(),
    domain: Some("WORKGROUP".to_owned()),
}));

# Self-signed certificate (testing)
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

# Production: use certificates from a trusted CA

let bind_addr = std::env::var("RDP_BIND_ADDR")
    .unwrap_or_else(|_| "0.0.0.0:3389".to_owned())
    .parse()?;

let cert_path = std::env::var("RDP_TLS_CERT")?;
let key_path = std::env::var("RDP_TLS_KEY")?;

use tracing_subscriber::EnvFilter;

tracing_subscriber::fmt()
    .with_env_filter(EnvFilter::from_env("IRONRDP_LOG"))
    .init();

IRONRDP_LOG=info cargo run --release