ironrdp-acceptor

[dependencies]
ironrdp-acceptor = "0.8"

use ironrdp_acceptor::{Acceptor, AcceptorState, AcceptorResult};
use ironrdp_pdu::nego::SecurityProtocol;
use ironrdp_connector::DesktopSize;

let mut acceptor = Acceptor::new(
    SecurityProtocol::HYBRID | SecurityProtocol::HYBRID_EX,
    DesktopSize { width: 1920, height: 1080 },
    capabilities,  // Vec<CapabilitySet>
    Some(credentials),  // Optional<Credentials>
);

use ironrdp_acceptor::{Acceptor, AcceptorResult, accept_begin, accept_finalize};
use ironrdp_async::Framed;
use ironrdp_tokio::TokioFramed;

// Create acceptor
let mut acceptor = Acceptor::new(
    security_protocol,
    desktop_size,
    server_capabilities,
    Some(credentials),
);

// Begin acceptance (before TLS upgrade)
let framed = TokioFramed::new(tcp_stream);
let begin_result = accept_begin(framed, &mut acceptor).await?;

match begin_result {
    BeginResult::ShouldUpgrade(stream) => {
        // Perform TLS upgrade
        let tls_stream = tls_acceptor.accept(stream).await?;
        let framed = TokioFramed::new(tls_stream);
        
        // Mark upgrade complete
        acceptor.mark_security_upgrade_as_done();
        
        // Continue with CredSSP if needed
        if acceptor.should_perform_credssp() {
            accept_credssp(
                &mut framed,
                &mut acceptor,
                &mut network_client,
                client_computer_name,
                public_key,
                kerberos_config,
            ).await?;
        }
        
        // Finalize connection
        let (framed, result) = accept_finalize(framed, &mut acceptor).await?;
        
        // Connection established
        handle_connection(framed, result).await?;
    }
    BeginResult::Continue(framed) => {
        // No TLS upgrade needed
        let (framed, result) = accept_finalize(framed, &mut acceptor).await?;
        handle_connection(framed, result).await?;
    }
}

pub struct AcceptorResult {
    pub static_channels: StaticChannelSet,
    pub capabilities: Vec<CapabilitySet>,
    pub input_events: Vec<Vec<u8>>,
    pub user_channel_id: u16,
    pub io_channel_id: u16,
    pub reactivation: bool,
}

let acceptor = Acceptor::new(
    SecurityProtocol::empty(),  // No security
    desktop_size,
    capabilities,
    Some(credentials),  // Credentials in Client Info PDU
);

let acceptor = Acceptor::new(
    SecurityProtocol::SSL,
    desktop_size,
    capabilities,
    None,  // No CredSSP
);

let acceptor = Acceptor::new(
    SecurityProtocol::HYBRID | SecurityProtocol::HYBRID_EX,
    desktop_size,
    capabilities,
    Some(credentials),
);

// After TLS upgrade, perform CredSSP
accept_credssp(
    &mut framed,
    &mut acceptor,
    &mut network_client,
    client_computer_name,
    public_key,
    kerberos_config,
).await?;

use ironrdp_svc::SvcServerProcessor;

struct MyChannelProcessor;

impl SvcServerProcessor for MyChannelProcessor {
    fn channel_name(&self) -> &str {
        "MYCHANNEL"
    }
    
    fn process_message(&mut self, message: &[u8]) -> Result<Vec<u8>> {
        // Process channel data
        Ok(response)
    }
}

acceptor.attach_static_channel(MyChannelProcessor);

use ironrdp_acceptor::Acceptor;

// After initial connection
let initial_result = acceptor.get_result().unwrap();

// Later, to resize:
let new_size = DesktopSize { width: 2560, height: 1440 };

let mut reactivation_acceptor = Acceptor::new_deactivation_reactivation(
    consumed_acceptor,
    initial_result.static_channels,
    new_size,
)?;

// Send Server Deactivate All PDU
send_deactivate_all(framed, user_channel_id, io_channel_id).await?;

// Re-run acceptance sequence
let (framed, result) = accept_finalize(framed, &mut reactivation_acceptor).await?;

use ironrdp_connector::sspi::{AuthIdentity, Username, KerberosServerConfig};

let credentials = Credentials {
    username: "admin".to_string(),
    password: "password".to_string(),
    domain: Some("CONTOSO".to_string()),
};

let kerberos_config = Some(KerberosServerConfig {
    // Kerberos configuration
});

accept_credssp(
    &mut framed,
    &mut acceptor,
    &mut network_client,
    ServerName::new("server.contoso.com")?,
    server_public_key,  // TLS certificate public key
    kerberos_config,
).await?;

if acceptor.reached_security_upgrade().is_some() {
    // Ready for TLS upgrade
}

if acceptor.should_perform_credssp() {
    // Need to perform CredSSP
}

if let Some(result) = acceptor.get_result() {
    // Connection established
}

use ironrdp_connector::{Sequence, State};

let state_name = acceptor.state().name();
let is_terminal = acceptor.state().is_terminal();

if let Some(hint) = acceptor.next_pdu_hint() {
    // Read next PDU based on hint
    let pdu = framed.read_by_hint(hint).await?;
}

use ironrdp_acceptor::{Acceptor, accept_begin, accept_finalize};
use ironrdp_async::single_sequence_step;
use ironrdp_core::WriteBuf;

// Manual step-by-step processing
let mut buf = WriteBuf::new();

loop {
    // Process one step
    single_sequence_step(&mut framed, &mut acceptor, &mut buf).await?;
    
    if let Some(result) = acceptor.get_result() {
        // Connection established
        break;
    }
}

use ironrdp_connector::{ConnectorError, ConnectorResult};

match accept_finalize(framed, &mut acceptor).await {
    Ok((framed, result)) => {
        // Success
    }
    Err(ConnectorError::Reason(reason)) => {
        // Connection failed with reason
        eprintln!("Connection failed: {}", reason);
    }
    Err(e) => {
        // Other error
        eprintln!("Error: {}", e);
    }
}

// Automatically detected from client early capability flags
// The acceptor handles this internally

// The acceptor automatically sends monitor layout if supported
// Based on desktop_size provided to Acceptor::new()