mxaccess/rust/crates/mxaccess/examples/asb-preamble-probe.rs

//! `asb-preamble-probe` — diagnostic for the F20 NMF preamble vs what
//! AVEVA's NetTcpPortSharing (SMSvcHost) actually accepts.
//!
//! Connects to the configured ASB endpoint, sends the canonical
//! preamble that F25's `AsbClient::send_preamble` would send, then
//! reads up to 256 bytes from the peer and prints both sides as
//! hex. Useful for diffing against a Wireshark / pktmon capture of
//! the .NET reference probe.

use std::time::Duration;

use mxaccess_asb::{SoapEnvelope, actions, build_connect_request_body, encode_envelope};
use mxaccess_asb_nettcp::nbfx::DynamicDictionary;
use mxaccess_asb_nettcp::nmf::{self, NmfRecord};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let host = std::env::var("MX_ASB_HOST")?;
    let via = std::env::var("MX_ASB_VIA")?;
    let addr = parse_host_port(&host, 808)?;
    eprintln!("connecting {addr} (via={via})");

    let mut stream = TcpStream::connect(addr).await?;
    let mut buf = Vec::new();
    nmf::encode_preamble(&via, &mut buf)?;
    eprintln!("sending {} preamble bytes:", buf.len());
    print_hex("OUT", &buf);

    stream.write_all(&buf).await?;
    stream.flush().await?;

    // Read the PreambleAck (single 0x0b byte) before pushing further.
    let mut ack = [0u8; 1];
    tokio::time::timeout(Duration::from_secs(5), stream.read_exact(&mut ack)).await??;
    eprintln!("preamble-ack byte: 0x{:02x}", ack[0]);
    if ack[0] != 0x0b {
        eprintln!("expected PreambleAck (0x0b); aborting");
        return Ok(());
    }

    // Build a synthetic ConnectRequest with a placeholder public key
    // (32 bytes, not a real DH public key — SMSvcHost dispatches by
    // the wire URL but WCF inside it will eventually decode the
    // envelope and may reject the body. That rejection is what we
    // want to observe.)
    let connection_id = [0xAAu8; 16];
    let public_key = vec![0xBBu8; 32];
    let body = build_connect_request_body(connection_id, &public_key);
    let envelope = SoapEnvelope::new(actions::CONNECT)
        .with_to(&via)
        .with_body_tokens(body);
    let mut dynamic = DynamicDictionary::new();
    let payload = encode_envelope(&envelope, &mut dynamic)?;
    eprintln!("envelope NBFX bytes: {}", payload.len());
    print_hex("ENV", &payload);

    let mut framed = Vec::new();
    NmfRecord::SizedEnvelope(payload).encode_into(&mut framed)?;
    eprintln!(
        "framed SizedEnvelope: {} bytes (1 type + varint len + body)",
        framed.len()
    );
    print_hex("OUT", &framed);
    stream.write_all(&framed).await?;
    stream.flush().await?;

    // Read up to 4096 bytes back — Fault would be small, ConnectResponse
    // would be larger (~200-400 bytes typically).
    let mut reply = vec![0u8; 4096];
    let read = tokio::time::timeout(Duration::from_secs(10), stream.read(&mut reply)).await;
    match read {
        Ok(Ok(0)) => eprintln!("peer closed cleanly (0 bytes)"),
        Ok(Ok(n)) => {
            eprintln!("got {n} bytes back:");
            if let Some(slice) = reply.get(..n) {
                print_hex("IN ", slice);
            }
            // First byte tells us the record type.
            match reply.first().copied().unwrap_or(0) {
                0x06 => eprintln!("response = SizedEnvelope (good — WCF accepted the request)"),
                0x07 => eprintln!("response = End (peer drained cleanly)"),
                0x08 => eprintln!("response = Fault (peer rejected; check the message text)"),
                other => eprintln!("response = unknown record type 0x{other:02x}"),
            }
        }
        Ok(Err(e)) => eprintln!("read error: {e}"),
        Err(_) => eprintln!("read timed out after 10s"),
    }
    Ok(())
}

fn print_hex(tag: &str, bytes: &[u8]) {
    for chunk in bytes.chunks(16) {
        let hex: Vec<String> = chunk.iter().map(|b| format!("{b:02x}")).collect();
        let ascii: String = chunk
            .iter()
            .map(|b| {
                if b.is_ascii_graphic() || *b == b' ' {
                    *b as char
                } else {
                    '.'
                }
            })
            .collect();
        eprintln!("{tag}  {:<48}  {}", hex.join(" "), ascii);
    }
}

fn parse_host_port(
    s: &str,
    default_port: u16,
) -> Result<std::net::SocketAddr, Box<dyn std::error::Error>> {
    if let Ok(addr) = s.parse() {
        return Ok(addr);
    }
    let with_port = if s.contains(':') {
        s.to_string()
    } else {
        format!("{s}:{default_port}")
    };
    Ok(
        std::net::ToSocketAddrs::to_socket_addrs(&with_port.as_str())?
            .next()
            .ok_or("no addrs resolved")?,
    )
}