aria2-protocol 0.3.10

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use std::io;

use super::wire::{
    read_raw, read_string, read_u32, read_u64, write_string, write_string_raw, write_u32, write_u64,
};
use super::*;

#[test]
fn test_init_roundtrip() {
    let pkt = SftpPacket::Init { version: 3 };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_version_with_extensions_roundtrip() {
    let pkt = SftpPacket::Version {
        version: 3,
        extensions: vec![
            ("hardlink@openssh.com".to_string(), "1".to_string()),
            ("fsync@openssh.com".to_string(), "1".to_string()),
        ],
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_open_roundtrip() {
    let pkt = SftpPacket::Open {
        request_id: 42,
        filename: "/tmp/test.dat".to_string(),
        flags: SSH_FXF_READ | SSH_FXF_WRITE,
        attrs: SftpFileAttrs::default(),
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_status_roundtrip() {
    let pkt = SftpPacket::Status {
        request_id: 1,
        code: SSH_FX_OK,
        message: "OK".to_string(),
        language: "en".to_string(),
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_handle_roundtrip() {
    let pkt = SftpPacket::Handle {
        request_id: 5,
        handle: vec![0x01, 0x02, 0x03],
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_data_roundtrip() {
    let pkt = SftpPacket::Data {
        request_id: 10,
        data: b"hello world".to_vec(),
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_name_roundtrip() {
    let pkt = SftpPacket::Name {
        request_id: 20,
        entries: vec![SftpNameEntry {
            filename: "file1.txt".to_string(),
            longname: "-rw-r--r-- 1 user group 1234 Jan 1 00:00 file1.txt".to_string(),
            attrs: SftpFileAttrs::full(1234, 1000, 1000, 0o100644, 1700000000, 1700000100),
        }],
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_attrs_roundtrip() {
    let pkt = SftpPacket::Attrs {
        request_id: 30,
        attrs: SftpFileAttrs::full(4096, 0, 0, 0o040755, 1700000000, 1700000100),
    };
    let encoded = pkt.encode().unwrap();
    let (decoded, consumed) = SftpPacket::decode(&encoded).unwrap();
    assert_eq!(consumed, encoded.len());
    assert_eq!(decoded, pkt);
}

#[test]
fn test_decode_incomplete_returns_error() {
    let buf = [0u8; 3]; // Too short for length prefix
    let result = SftpPacket::decode(&buf);
    assert!(result.is_err());
}

#[test]
fn test_decode_partial_payload_returns_error() {
    let pkt = SftpPacket::Init { version: 3 };
    let encoded = pkt.encode().unwrap();
    let result = SftpPacket::decode(&encoded[..5]); // Only length + 1 byte
    assert!(result.is_err());
}

#[test]
fn malformed_packet_trailing_payload_is_rejected() {
    let packet = SftpPacket::Status {
        request_id: 1,
        code: SSH_FX_OK,
        message: "ok".to_string(),
        language: "en".to_string(),
    };
    let mut encoded = packet.encode().unwrap();
    encoded.push(0xff);
    let payload_length = (encoded.len() - 4) as u32;
    encoded[..4].copy_from_slice(&payload_length.to_be_bytes());

    let error = SftpPacket::decode(&encoded).unwrap_err();
    assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
}

#[test]
fn malformed_string_length_does_not_reserve_declared_size() {
    // Outer packet: DATA, request id 1, string length u32::MAX, no string data.
    let bytes = [
        0, 0, 0, 9,   // packet payload length
        103, // SSH_FXP_DATA
        0, 0, 0, 1, // request id
        0xff, 0xff, 0xff, 0xff, // impossible string length
    ];

    let error = SftpPacket::decode(&bytes).unwrap_err();
    assert_eq!(error.kind(), std::io::ErrorKind::UnexpectedEof);
}

#[test]
fn malformed_name_count_is_rejected_before_reserving_entries() {
    // NAME packet with the maximum entry count and no entry payload.
    let bytes = [
        0, 0, 0, 9,   // packet payload length
        104, // SSH_FXP_NAME
        0, 0, 0, 1, // request id
        0xff, 0xff, 0xff, 0xff, // count
    ];

    let error = SftpPacket::decode(&bytes).unwrap_err();
    assert_eq!(error.kind(), std::io::ErrorKind::UnexpectedEof);
}

#[test]
fn frame_length_addition_rejects_platform_size_overflow() {
    let error = super::codec::checked_frame_length(usize::MAX).unwrap_err();
    assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
}

#[test]
fn maximum_sftp_frame_size_is_inclusive_of_the_length_prefix() {
    assert_eq!(
        super::codec::checked_frame_length(MAX_SFTP_FRAME_SIZE - 4).unwrap(),
        MAX_SFTP_FRAME_SIZE
    );
}

#[test]
fn decoder_rejects_oversized_frame_from_length_prefix_alone() {
    let payload_length = u32::try_from(MAX_SFTP_FRAME_SIZE - 3).unwrap();
    let error = SftpPacket::decode(&payload_length.to_be_bytes()).unwrap_err();

    assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
    assert!(error.to_string().contains("exceeds the maximum"));
}

#[test]
fn encoder_rejects_frame_larger_than_the_protocol_cap() {
    let packet = SftpPacket::Data {
        request_id: 1,
        data: vec![0; MAX_SFTP_FRAME_SIZE],
    };

    let error = packet.encode().unwrap_err();
    assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
    assert!(error.to_string().contains("exceeds the maximum"));
}

#[cfg(target_pointer_width = "64")]
#[test]
fn wire_lengths_reject_values_larger_than_u32() {
    let error = super::wire::checked_u32_length(u32::MAX as usize + 1, "test length").unwrap_err();
    assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
}

#[test]
fn test_packet_type_codes() {
    assert_eq!(SftpPacket::Init { version: 3 }.packet_type(), SSH_FXP_INIT);
    assert_eq!(
        SftpPacket::Version {
            version: 3,
            extensions: vec![]
        }
        .packet_type(),
        SSH_FXP_VERSION
    );
    assert_eq!(
        SftpPacket::Open {
            request_id: 0,
            filename: String::new(),
            flags: 0,
            attrs: SftpFileAttrs::default(),
        }
        .packet_type(),
        SSH_FXP_OPEN
    );
}

#[test]
fn test_request_id_extraction() {
    assert!(SftpPacket::Init { version: 3 }.request_id().is_none());
    assert!(
        SftpPacket::Version {
            version: 3,
            extensions: vec![]
        }
        .request_id()
        .is_none()
    );
    assert_eq!(
        SftpPacket::Open {
            request_id: 42,
            filename: String::new(),
            flags: 0,
            attrs: SftpFileAttrs::default(),
        }
        .request_id(),
        Some(42)
    );
    assert_eq!(
        SftpPacket::Status {
            request_id: 99,
            code: SSH_FX_OK,
            message: String::new(),
            language: String::new(),
        }
        .request_id(),
        Some(99)
    );
}

#[test]
fn test_file_attrs_directory_check() {
    let dir_attrs = SftpFileAttrs::full(4096, 0, 0, 0o040755, 0, 0);
    assert!(dir_attrs.is_directory());
    assert!(!dir_attrs.is_regular_file());

    let file_attrs = SftpFileAttrs::full(100, 0, 0, 0o100644, 0, 0);
    assert!(file_attrs.is_regular_file());
    assert!(!file_attrs.is_directory());

    let link_attrs = SftpFileAttrs::full(10, 0, 0, 0o120777, 0, 0);
    assert!(link_attrs.is_symlink());
}

#[test]
fn test_status_code_descriptions() {
    assert_eq!(status_code_description(SSH_FX_OK), "Operation succeeded");
    assert_eq!(status_code_description(SSH_FX_EOF), "End of file");
    assert_eq!(status_code_description(999), "Unknown status code");
}

#[test]
fn test_write_and_read_roundtrip() {
    let mut buf = Vec::new();
    write_u32(&mut buf, 0xDEADBEEF).unwrap();
    write_u64(&mut buf, 0xCAFEBABE_CAFEBABE).unwrap();
    write_string(&mut buf, "hello").unwrap();
    write_string_raw(&mut buf, &[0x01, 0x02]).unwrap();

    let mut cursor = io::Cursor::new(&buf);
    assert_eq!(read_u32(&mut cursor).unwrap(), 0xDEADBEEF);
    assert_eq!(read_u64(&mut cursor).unwrap(), 0xCAFEBABE_CAFEBABE);
    assert_eq!(read_string(&mut cursor).unwrap(), "hello");
    assert_eq!(read_raw(&mut cursor).unwrap(), vec![0x01, 0x02]);
}