Connection Flow

pub trait Sequence: Send {
    fn next_pdu_hint(&self) -> Option<&dyn PduHint>;
    fn state(&self) -> &dyn State;
    fn step(&mut self, input: &[u8], output: &mut WriteBuf) -> ConnectorResult<Written>;
}

use ironrdp_session::{ActiveStage, ActiveStageOutput};

let mut session = connection_activation.into_active_stage();

loop {
    let mut buf = vec![0u8; 8192];
    let bytes_read = stream.read(&mut buf)?;
    
    match session.process(&buf[..bytes_read], &mut output)? {
        ActiveStageOutput::GraphicsUpdate(update) => {
            // Render graphics update
        }
        ActiveStageOutput::PointerUpdate(pointer) => {
            // Update mouse pointer
        }
        ActiveStageOutput::Terminated(reason) => {
            // Handle disconnection
            break;
        }
        // ... other output types
    }
    
    if output.filled_len() > 0 {
        stream.write_all(output.filled())?;
        output.clear();
    }
}

use ironrdp_svc::{SvcClientProcessor, SvcMessage};
use ironrdp_cliprdr::CliprdrClient;

let cliprdr = CliprdrClient::new();
let connector = ClientConnector::new(config, client_addr)
    .with_static_channel(cliprdr);

pub trait SvcClientProcessor: SvcProcessor {}

pub trait SvcProcessor: AsAny + fmt::Debug + Send {
    fn channel_name(&self) -> ChannelName;
    fn start(&mut self) -> PduResult<Vec<SvcMessage>>;
    fn process(&mut self, payload: &[u8]) -> PduResult<Vec<SvcMessage>>;
}

pub type ConnectorResult<T> = Result<T, ConnectorError>;

pub enum ConnectorErrorKind {
    Encode(EncodeError),
    Decode(DecodeError),
    Credssp(sspi::Error),
    Reason(String),
    AccessDenied,
    Negotiation(NegotiationFailure),
    // ...
}

match error.kind() {
    ConnectorErrorKind::Negotiation(failure) => {
        eprintln!("Connection failed: {}", failure);
        // "server requires Enhanced RDP Security with CredSSP"
    }
    // ...
}

use ironrdp_connector::{ClientConnector, Sequence, Written};
use ironrdp_core::WriteBuf;

let mut connector = ClientConnector::new(config, client_addr);
let mut output = WriteBuf::new();
let mut input_buf = vec![0u8; 8192];

loop {
    // Check for external I/O requirements
    if connector.should_perform_security_upgrade() {
        stream = perform_tls_upgrade(stream)?;
        connector.mark_security_upgrade_as_done();
        continue;
    }
    
    if connector.should_perform_credssp() {
        perform_credssp(&mut stream, &config)?;
        connector.mark_credssp_as_done();
        continue;
    }
    
    // Step the state machine
    output.clear();
    let written = connector.step(&[], &mut output)?;
    
    // Send output if any
    if let Written::Size(_) = written {
        stream.write_all(output.filled())?;
    }
    
    // Check if we're done
    if connector.state().is_terminal() {
        break;
    }
    
    // Read response
    let bytes_read = stream.read(&mut input_buf)?;
    connector.step(&input_buf[..bytes_read], &mut output)?;
}

// Extract result
let result = match connector.state {
    ClientConnectorState::Connected { result } => result,
    _ => unreachable!(),
};