Building an RDP Client

use ironrdp_tokio::TokioFramed;
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tcp_stream = TcpStream::connect(("server.example.com", 3389)).await?;
    let client_addr = tcp_stream.local_addr()?;

    let mut framed = TokioFramed::new(tcp_stream);
    let mut connector = connector::ClientConnector::new(config, client_addr);

    let should_upgrade = ironrdp_async::connect_begin(&mut framed, &mut connector).await?;

    // TLS upgrade...
    let upgraded = ironrdp_async::mark_as_upgraded(should_upgrade, &mut connector);

    let connection_result = ironrdp_async::connect_finalize(
        upgraded,
        connector,
        &mut upgraded_framed,
        &mut network_client,
        server_name,
        server_public_key,
        None,
    ).await?;

    // Active session processing is similar but uses async read/write
    Ok(())
}

use ironrdp_pdu::rdp::client_info::PerformanceFlags;

config.performance_flags = PerformanceFlags::default()
    .with_desktop_composition(true)
    .with_font_smoothing(true);

use ironrdp_pdu::rdp::client_info::CompressionType;

config.compression_type = Some(CompressionType::Rdp61); // Best compression

config.desktop_size = DesktopSize {
    width: 1920,
    height: 1080,
};

use ironrdp::connector::{ConnectorError, ConnectorErrorKind};

match connector_result {
    Err(ConnectorError { kind: ConnectorErrorKind::Credssp(e), .. }) => {
        eprintln!("Authentication failed: {}", e);
    }
    Err(e) => {
        eprintln!("Connection error: {}", e);
    }
    Ok(_) => {}
}