haprox_rs/protocol_v2/

protocol_parser.rs

/*-
 * haprox-rs - a HaProxy protocol parser.
 * 
 * Copyright 2025 (c) Aleksandr Morozov
 * The scram-rs crate can be redistributed and/or modified
 * under the terms of either of the following licenses:
 *
 *   1. the Mozilla Public License Version 2.0 (the “MPL”) OR
 *
 *   2. The MIT License (MIT)
 *                     
 *   3. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016
 */

use std::mem::offset_of;
use std::{fmt, io::Cursor, marker::PhantomData};
use byteorder::{BigEndian, ReadBytesExt};
use crc32fast::Hasher;

use crate::common::map_io_err;
use crate::{error::{HaProxErr, HaProxRes}, map_error, return_error};

use crate::protocol_raw;

use super::
{
    protocol::
    {
        HdrV2Command, 
        PP2Tlvs, 
        ProtocolVersion, 
        ProxyTransportFam, 
        ProxyV2Addr, 
        ProxyV2AddrType
    }, 
    PP2TlvRestore
};

/// Used with [ProxyV2Parser] its `PAR` generic.
/// 
/// A parser which copies data from external buffer to PP2Tlvs
/// and setting the `'static` lifetime to this enum.
#[derive(Debug)]
pub struct PPV2ParserCopying();

impl fmt::Display for PPV2ParserCopying
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "copying parser")
    }
}

/// Used with [ProxyV2Parser] its `PAR` generic.
/// 
/// A parser which borrows the data from external buffer without
/// copying it. The lifetime is a lifetime of the parser instance.
#[derive(Debug)]
pub struct PPV2ParserZeroCopy<'zc>(PhantomData<&'zc ()>);

impl<'zc> fmt::Display for PPV2ParserZeroCopy<'zc>
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "zerocopy parser")
    }
}

/// A HaProxy V2 parser main instance.
/// 
/// An uppstream code should specify which type of parser is preferable and
/// set the `EXT` if any additional fields is required to parse. If not the
/// [ProxyV2Dummy] can be used.
/// 
/// There are two types of parsers:
/// 
/// * [PPV2ParserCopying] - copies data from source into new location.
/// 
/// * [PPV2ParserZeroCopy] - does not copy data, only borrow.
/// 
/// # Generics
/// 
/// * `PAR` - an internal parser, see above.
/// 
/// * `EXT` - an external parser. If it is required to parse some non-std
///     TLVs in the message, this should be implemented. It is up to you
///     if it will be copying or borrowing.  
///     If it is not required, then the [ProxyV2Dummy] can be used.
#[derive(Debug)]
pub struct ProxyV2Parser<'t, PAR = PPV2ParserZeroCopy<'t>, EXT = ProxyV2Dummy>
where 
    PAR: PP2TlvRestore<'t>,
    EXT: PP2TlvRestore<'t>,
{
    /// A received packed which should contain the proxy pkt.
    buffer: &'t [u8],

    /// Phantom for the extension for the protocol.
    _p1: PhantomData<EXT>,

    /// Phantom for the parser type.
    _p2: PhantomData<PAR>,
}

impl<'t> ProxyV2Parser<'t>
{
    /// Constructs the instance from the temporary reference to the buffer. 
    pub 
    fn try_from_slice(value: &'t [u8]) -> HaProxRes<Self>
    {
        let pkt_size = Self::new_from(value)?;

        let tmp = 
            Self
            { 
                buffer: &value[0..pkt_size], 
                _p1: PhantomData,
                _p2: PhantomData,
            };

        tmp.post_check()?;

        return Ok(tmp);
    }
}

impl<'t, PAR: PP2TlvRestore<'t>, EXT: PP2TlvRestore<'t>> ProxyV2Parser<'t, PAR, EXT>
{
    /// Constructs the instance from the temporary reference to the buffer
    /// with custom extenal TLV parser for custom TLV extensions.
    pub 
    fn try_from_slice_custom(value: &'t [u8]) -> HaProxRes<Self>
    {
        let pkt_size = Self::new_from(value)?;

        let tmp = 
            Self
            { 
                buffer: &value[0..pkt_size], 
                _p1: PhantomData,
                _p2: PhantomData,
            };

        tmp.post_check()?;

        return Ok(tmp);
    }
}

impl<'t, PAR: PP2TlvRestore<'t>, EXT: PP2TlvRestore<'t>> ProxyV2Parser<'t, PAR, EXT>
{
    fn post_check(&self) -> HaProxRes<()>
    {
        let _ = self.get_address_family()?;
        let _ = self.get_transport()?;

        return Ok(());
    }

    /// Internal function.
    /// 
    /// Checks the header for the specific pattern to determine if this is a HaProxy
    /// mesage and if it initial header bits are valid.
    fn new_from(value: &[u8]) -> HaProxRes<usize>
    {
        if value.len() <= protocol_raw::HEADER_MAGIC_V1.len()
        {
            return_error!(IncorrectBanner, "protocol with footprint '{:02X?}' unknown", 
                value);
        }
        else if &value[0..protocol_raw::HEADER_MAGIC_V1.len()] == protocol_raw::HEADER_MAGIC_V1
        {
            return_error!(ProtocolNotSuported, "V1 protocol is not supported");
        }
        else if value.len() < size_of::<protocol_raw::ProxyHdrV2>()
        {
            return_error!(ProtocolMsgIncomplete, "protocol with footprint '{:02X?}' unknown", 
                value);
        }
        else if &value[0..protocol_raw::HEADER_MAGIC_V2.len()] != protocol_raw::HEADER_MAGIC_V2
        {
            return_error!(IncorrectBanner, "protocol with footprint '{:02X?}' unknown", 
                value);
        }
        else if value[offset_of!(protocol_raw::ProxyHdrV2, ver_cmd)] & protocol_raw::ProxyHdrV2::VERSION_MASK != 
            protocol_raw::ProxyHdrV2::VERSION_RAW
        {
            return_error!(MalformedData, "protocol version '{:02X?}' incorrect", 
                value[offset_of!(protocol_raw::ProxyHdrV2, ver_cmd)]);
        }

        let payload_len =  
            [
                value[offset_of!(protocol_raw::ProxyHdrV2, len)],
                value[offset_of!(protocol_raw::ProxyHdrV2, len)+1]
            ];

        let full_size = u16::from_be_bytes(payload_len) + protocol_raw::ProxyHdrV2::HEADER_LEN as u16;

        if value.len() < full_size as usize
        {
            return_error!(ProtocolMsgIncomplete, "fragmented pkt received, declared len + header: {}, received len: {}",
                full_size, value.len());
        }

        return Ok(full_size as usize);
    }

    /// Extracts and decodes the protocol version from the packet.
    pub 
    fn get_proto_version(&self) -> ProtocolVersion
    {
        return ProtocolVersion::decode(self.buffer[offset_of!(protocol_raw::ProxyHdrV2, ver_cmd)]);
    }

    /// Extracts and decodes the protocol command code from the packet.
    pub 
    fn get_proto_command(&self) -> HdrV2Command
    {
        return HdrV2Command::decode(self.buffer[offset_of!(protocol_raw::ProxyHdrV2, ver_cmd)]);
    }

    /// Extracts and decodes the transport type from the packet.
    pub 
    fn get_transport(&self) -> HaProxRes<ProxyTransportFam>
    {
        return ProxyTransportFam::decode(self.buffer[offset_of!(protocol_raw::ProxyHdrV2, fam)]);
    }

    /// Extracts and decodes the address family from the packet. It does not extract address. 
    pub 
    fn get_address_family(&self) -> HaProxRes<ProxyV2AddrType>
    {
        return ProxyV2AddrType::decode(self.buffer[offset_of!(protocol_raw::ProxyHdrV2, fam)]);
    }

    /// Returns the size of the packet (without header len).
    pub 
    fn get_palyload_len(&self) -> u16
    {
        let hi =  
            [
                self
                    .buffer[offset_of!(protocol_raw::ProxyHdrV2, len)],
                self
                    .buffer[offset_of!(protocol_raw::ProxyHdrV2, len)+1]
            ];
            

        return u16::from_be_bytes(hi);
    }

    /// Returns the full size of the packet.
    pub 
    fn get_full_len(&self) -> u16
    {
        let hi =  
            [
                self
                    .buffer[offset_of!(protocol_raw::ProxyHdrV2, len)],
                self
                    .buffer[offset_of!(protocol_raw::ProxyHdrV2, len)+1]
            ];
            

        return u16::from_be_bytes(hi) + protocol_raw::ProxyHdrV2::HEADER_LEN as u16;
    }

    /// Extracts the address section from the packet. The address family can be obtained from the 
    /// returned instance.
    /// 
    /// # Returns
    /// 
    /// A [HaProxRes] is returned with:
    /// 
    /// * [Result::Ok] - the  [Option] with:
    /// 
    /// * * [Option::Some] - a parsed address is returned in form of [ProxyV2Addr]
    /// 
    /// * * [Option::None] - if address family is unspecified.
    /// 
    /// * [Result::Err] - an error description.
    pub 
    fn get_address(&self) -> HaProxRes<Option<ProxyV2Addr>>
    {
        let addr_fam = self.get_address_family()?;

        let Some(addr_len) = addr_fam.get_size_by_addr_family()
        else { return Ok(None) };

        let buf_len = self.buffer.len() - size_of::<protocol_raw::ProxyHdrV2>();

        if buf_len < addr_len as usize
        {
            return_error!(ProtocolMsgIncomplete, "cannot read address, msg len: '{}', addr len: '{}'", 
                buf_len, addr_len);
        }

        let mut cur = Cursor::new(&self.buffer.as_ref()[offset_of!(protocol_raw::ProxyHdrV2, address)..]);

        return ProxyV2Addr::read(addr_fam, &mut cur);
    }

    /// Creates an iterator over TLVs which could be in the payload of the packer. This is flat iterator i.e if
    /// TLV contains a subcodes, it will be returned as it is just in a 1D array. You should track
    /// if item contains a subcode and a subcode is returned.
    pub 
    fn get_tlvs_iter(&self) -> Option<ProxyV2TlvIter<'t, PAR, EXT>>
    {
        let addr_fam = self.get_address_family().ok()?.get_size_by_addr_family()?;

        if self.get_palyload_len() - addr_fam == 0
        {
            return None;
        }

        let addr_size = self.get_address_family().ok()?.get_size_by_addr_family()? as usize;

        let tlv_offset_start = 
            offset_of!(protocol_raw::ProxyHdrV2, address) + addr_size;

        let itr = 
            ProxyV2TlvIter
            {
                curs: 
                    vec![
                        ProxyV2TlvIterTlv
                        {
                            cur: Cursor::new(&self.buffer.as_ref()[tlv_offset_start..]),
                            parent_tlv_idx: None,
                        },
                    ],
                _p: PhantomData,
                _p2: PhantomData,
            };

        return Some(itr);
    }

    /// Calculates the CRC of message and returns the result.
    pub 
    fn check_crc(&self) -> HaProxRes<bool>
    {
        /*let PP2Tlvs::TypeCrc32c(crcpkt) = crc 
            else { return_error!(ArgumentEinval, "PP2Tlvs type is not TypeCrc32c") };*/

        let mut crc32: Option<u32> = None;

        // init hasher
        let mut hasher = Hasher::new();

        let addr_fam_len = 
            self
                .get_address_family()?
                .get_size_by_addr_family()
                .ok_or_else(||
                    map_error!(ArgumentEinval, "unknown address family")
                )? as usize;

        
        let full_hdr_len = addr_fam_len + protocol_raw::ProxyHdrV2::HEADER_LEN;
        
        // calculate crc header
        hasher.update(&self.buffer[0..full_hdr_len]);

        let payload_len = self.get_palyload_len() as usize - addr_fam_len;

        let mut cur = Cursor::new(&self.buffer[full_hdr_len..]);

        while cur.position() < payload_len as u64
        {
            let s = cur.position() as usize;

            let op = cur.read_u8().map_err(map_io_err)?;
            let len = cur.read_u16::<BigEndian>().map_err(map_io_err)?;

            if op == PP2Tlvs::TYPE_CRC32C
            {
                crc32 = Some(cur.read_u32::<BigEndian>().map_err(map_io_err)?);

                hasher.update(&[op]);
                hasher.update(len.to_be_bytes().as_slice());
                hasher.update(&[0]);
            }
            else
            {
                let last = s+2+len as usize;

                hasher.update(&self.buffer[s..last]);
                cur.set_position(last as u64);
            }
        }

        if let Some(cr) = crc32
        {
            return Ok(cr == hasher.finalize());
        }
        else
        {
            return_error!(ArgumentEinval, "no CRC TLV found!");
        }
    }
}


/// A dummy implementation of the TVL protocol extension.
#[derive(Clone, Debug)]
pub enum ProxyV2Dummy {}

impl fmt::Display for ProxyV2Dummy
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "DUMMY external reader")
    }
}

impl<'zc> PP2TlvRestore<'zc> for ProxyV2Dummy
{
    type TlvTblRes = PP2Tlvs<'zc>;

    fn is_in_range(_tlv_type: u8, _tlv_parent_type: Option<u8>) -> bool 
    {
        return false;
    }

    fn contains_subtype(_item: &Self::TlvTblRes) -> bool 
    {
        return false;
    }

    fn restore(_tlv_type: u8, _cur: &mut Cursor<&[u8]>) -> HaProxRes<Self::TlvTblRes>
    {
        return_error!(ArgumentEinval, "assertion trap, DUMMY external decoder");
    } 
}

impl PP2TlvRestore<'static> for PPV2ParserCopying
{
    type TlvTblRes = PP2Tlvs<'static>;

    fn contains_subtype(item: &Self::TlvTblRes) -> bool 
    {
        return item.contains_subtype();    
    }

    fn is_in_range(tlv_type: u8, tlv_parent_type: Option<u8>) -> bool 
    {
        return PP2Tlvs::<'static>::is_in_range(tlv_type, tlv_parent_type);
    }

    fn restore(tlv_type: u8, cur: &mut Cursor<&'static [u8]>) -> HaProxRes<Self::TlvTblRes> 
    {
        return PP2Tlvs::<'static>::restore_copying(tlv_type, cur);
    }
}

impl<'zc> PP2TlvRestore<'zc> for PPV2ParserZeroCopy<'zc>
{
    type TlvTblRes = PP2Tlvs<'zc>;

    fn contains_subtype(item: &Self::TlvTblRes) -> bool 
    {
        return item.contains_subtype();    
    }

    fn is_in_range(tlv_type: u8, tlv_parent_type: Option<u8>) -> bool 
    {
        return PP2Tlvs::<'zc>::is_in_range(tlv_type, tlv_parent_type);
    }
    
    fn restore(tlv_type: u8, cur: &mut Cursor<&'zc [u8]>) -> HaProxRes<Self::TlvTblRes> 
    {
        return PP2Tlvs::<'zc>::restore_zerocopy(tlv_type, cur);
    }
}

/// An `enum` which is returned by the TLV iterator. It may contain either parsed TLV or 
/// error description which occured during parsing. Normally, in case of error, the 
/// parsing should be stopped and connection dropped.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProxyV2TlvSource<'zc, PAR: PP2TlvRestore<'zc>, EXT: PP2TlvRestore<'zc>>
{
    /// A base implementation of the protocl.
    Internal(PAR::TlvTblRes),

    /// A user's extension to the protocol.
    External(EXT::TlvTblRes),
    
    /// Error during parsing.
    Error(HaProxErr),
}

impl<'zc, PAR: PP2TlvRestore<'zc>, EXT: PP2TlvRestore<'zc>> ProxyV2TlvSource<'zc, PAR, EXT>
{
    fn new_internal(pp2: HaProxRes<PAR::TlvTblRes>) -> Self
    {
        return 
            pp2.map_or_else(|e| Self::Error(e), |f| Self::Internal(f));
    }

    fn new_external(pp2: HaProxRes<EXT::TlvTblRes>) -> Self
    {
        return 
            pp2
                .map_or_else(|e| Self::Error(e), |f| Self::External(f));
    }

    fn new_error(err: HaProxErr) -> Self
    {
        return Self::Error(err);
    }

    fn new_io_error(err: std::io::Error) -> Self
    {
        return Self::Error(map_error!(IoError, "while reading TLV, error: {}", err));
    }

    /// Consumes the instance returning the [PP2Tlvs] build-in TLV through [Option]. 
    /// If instance os not `Internal` then instance will be lost.
    pub 
    fn take_internal(self) -> Option<PAR::TlvTblRes>
    {
        let Self::Internal(s) = self else {return None};

        return Some(s);
    }

    /// Consumes the instance returning the [PP2Tlvs] build-in TLV through [Option]. 
    /// If instance os not `External` then instance will be lost.
    pub 
    fn take_external(self) -> Option<EXT::TlvTblRes>
    {
        let Self::External(s) = self else {return None};

        return Some(s);
    }

    /// Checks if current instance constains the subtype. For `Error` `false` is
    /// always returned.
    pub 
    fn contains_subtype(&self) -> bool
    {
        match self
        {
            Self::Internal(i) => 
                return PAR::contains_subtype(i),
            Self::External(e) => 
                return EXT::contains_subtype(e),
            _ => 
                return false
        }
    }
    
}

/// TLV iterator instance.
#[derive(Debug)]
struct ProxyV2TlvIterTlv<'iter>
{
    /// A cursor to the current data.
    cur: Cursor<&'iter [u8]>,

    /// A parent (previous) TLV's ID.
    parent_tlv_idx: Option<u8>,
}

/// A multilayer iterator instance.
#[derive(Debug)]
pub struct ProxyV2TlvIter<'iter, PAR: PP2TlvRestore<'iter>, EXT>
{
    /// A heap of the cursors. If iterator reaches subtype, the
    /// previous cursor will be pushed to heap.
    curs: Vec<ProxyV2TlvIterTlv<'iter>>,

    /// A phantom.
    _p: PhantomData<EXT>,

    /// A phantom.
    _p2: PhantomData<PAR>,
}

impl<'iter, PAR: PP2TlvRestore<'iter>, EXT: PP2TlvRestore<'iter>> ProxyV2TlvIter<'iter, PAR, EXT>
{
    fn get_last_cur(&self) -> &Cursor<&'iter [u8]>
    {
        return &self.curs.last().unwrap().cur;
    }

    fn get_last_mut_cur(&mut self) -> &mut Cursor<&'iter [u8]>
    {
        return &mut self.curs.last_mut().unwrap().cur;
    }

    fn get_parent_tlv(&self) -> Option<u8>
    {
        return self.curs.last().unwrap().parent_tlv_idx;
    }
}

impl<'iter, PAR: PP2TlvRestore<'iter>, EXT: PP2TlvRestore<'iter>> Iterator for ProxyV2TlvIter<'iter, PAR, EXT>
{
    type Item = ProxyV2TlvSource<'iter, PAR, EXT>;

    fn next(&mut self) -> Option<Self::Item> 
    {
        // check if the end of the section was reached
        if self.get_last_cur().get_ref().len() <= self.get_last_cur().position() as usize
        {
            if self.curs.len() == 1
            {
                // nothing left
                return None;
            }
            else
            {
                // return back on one level
                let _ = self.curs.pop();

                return self.next();
            }
        }

        // read type of the tlv
        let tlv_type = 
            match self.get_last_mut_cur().read_u8()
            {
                Ok(r) => r,
                Err(e) =>
                    return Some(ProxyV2TlvSource::new_io_error(e)),
            };

        // read length of the tlv's payload
        let tlv_len = 
            match self.get_last_mut_cur().read_u16::<BigEndian>()
            {
                Ok(r) => r,
                Err(e) => 
                    return Some(ProxyV2TlvSource::new_io_error(e)),
            };

        let tlv_range = 
            self.get_last_cur().position() as usize .. (self.get_last_cur().position()+ tlv_len as u64) as usize;


        // creating a cursor from slice to prevent parser going out of bounds by the declared size
        let mut cur = 
            Cursor::new(&self.get_last_cur().get_ref()[tlv_range]);

        
        // check in which range it is
        let next_item = 
            if PP2Tlvs::is_in_range(tlv_type, self.get_parent_tlv()) == true
            {
                ProxyV2TlvSource::new_internal(
                    PAR::restore(tlv_type, &mut cur)
                )
            }
            else if EXT::is_in_range(tlv_type, self.get_parent_tlv()) == true
            {
                ProxyV2TlvSource::new_external(
                    EXT::restore(tlv_type, &mut cur)
                )
            }
            else
            {
                ProxyV2TlvSource::new_error(
                    map_error!(ProtocolUnknownData, "TLV tpye: '{}' out of int/ext ranges", tlv_type)
                )
            };

        // move cursor position forward
        let new_pos = self.get_last_cur().position()+ tlv_len as u64;
        self.get_last_mut_cur().set_position(new_pos);

        if next_item.contains_subtype() == true
        {
            // push the current cursor
            self.curs.push(
                ProxyV2TlvIterTlv
                {
                    cur: cur,
                    parent_tlv_idx: Some(tlv_type),
                }
            );
        }

        return Some(next_item);
    }
}

#[cfg(test)]
mod tests
{
    use std::{borrow::Cow, fmt, io::Cursor, mem};

    use byteorder::{BigEndian, ReadBytesExt};

    use crate::{PPV2ParserCopying, PPV2ParserZeroCopy, ProxyV2Dummy, common, error::HaProxRes, protocol_raw, protocol_v2::{PP2TlvDump, PP2TlvRestore, protocol::{HdrV2Command, PP2_TYPE_MIN_CUSTOM, PP2TlvClient, PP2Tlvs, ProtocolVersion, ProxyTransportFam, ProxyV2Addr, ProxyV2AddrType}}, return_error};

    use super::ProxyV2Parser;

    #[test]
    fn test_0_zerocopy()
    {
        let pkt_ssl = 
b"\x0d\x0a\x0d\x0a\x00\x0d\x0a\x51\x55\x49\x54\x0a\x21\x11\x00\x2a\
\x7f\x00\x00\x01\x7f\x00\x00\x43\x9d\xd2\x2e\x6b\x20\x00\x1b\x07\
\x00\x00\x00\x00\x21\x00\x07\x54\x4c\x53\x76\x31\x2e\x32\x22\x00\
\x09\x6d\x71\x74\x74\x75\x73\x65\x72\x31";

        let dec = ProxyV2Parser::try_from_slice(pkt_ssl.as_slice()).unwrap();

        assert_eq!(dec.get_transport().is_ok(), true);
        assert_eq!(dec.get_transport().unwrap(), ProxyTransportFam::STREAM);

        assert_eq!(dec.get_proto_version(), ProtocolVersion::V2);
        assert_eq!(dec.get_proto_command(), HdrV2Command::PROXY);

        assert_eq!(dec.get_address_family().is_ok(), true);
        assert_eq!(dec.get_address_family().unwrap(), ProxyV2AddrType::AfInet);

        assert_eq!(dec.get_palyload_len() as usize, pkt_ssl.len() - size_of::<protocol_raw::ProxyHdrV2>());
        
        let addr = dec.get_address().unwrap();

        assert_eq!(addr.is_some(), true);

        let addr = addr.unwrap();
        let maddr = ProxyV2Addr::try_from(("127.0.0.1:40402", "127.0.0.67:11883")).unwrap();

        assert_eq!(addr, maddr);

        let tlv_iter = dec.get_tlvs_iter();

        assert_eq!(tlv_iter.is_some(), true);

        let mut tlv_iter = tlv_iter.unwrap();

        let type_ssl = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl.get_type(), PP2Tlvs::TYPE_SSL);
        let PP2Tlvs::TypeSsl { client, verify } = type_ssl else {panic!("wrong")};

        assert_eq!(client, PP2TlvClient::all());
        assert_eq!(verify, 0);

        let type_ssl_version = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl_version.get_type(), PP2Tlvs::TYPE_SUBTYPE_SSL_VERSION);

        let PP2Tlvs::TypeSubtypeSslVersion(ssl_version) = type_ssl_version else { panic!("wrong") };
        
        assert_eq!(mem::discriminant(&ssl_version), mem::discriminant(&Cow::Borrowed("TLSv1.2")));
        assert_eq!(ssl_version, "TLSv1.2");

        let type_ssl_cn = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl_cn.get_type(), PP2Tlvs::TYPE_SUBTYPE_SSL_CN);

        let PP2Tlvs::TypeSubtypeSslCn(ssl_cn) = type_ssl_cn else { panic!("wrong") };

        assert_eq!(ssl_cn, "mqttuser1");
    }

    #[test]
    fn test_0_copy()
    {
        let pkt_ssl = 
b"\x0d\x0a\x0d\x0a\x00\x0d\x0a\x51\x55\x49\x54\x0a\x21\x11\x00\x2a\
\x7f\x00\x00\x01\x7f\x00\x00\x43\x9d\xd2\x2e\x6b\x20\x00\x1b\x07\
\x00\x00\x00\x00\x21\x00\x07\x54\x4c\x53\x76\x31\x2e\x32\x22\x00\
\x09\x6d\x71\x74\x74\x75\x73\x65\x72\x31";


        let dec = 
            ProxyV2Parser
                ::<PPV2ParserCopying, ProxyV2Dummy>
                ::try_from_slice_custom(pkt_ssl.as_slice())
                    .unwrap();

        assert_eq!(dec.get_transport().is_ok(), true);
        assert_eq!(dec.get_transport().unwrap(), ProxyTransportFam::STREAM);

        assert_eq!(dec.get_proto_version(), ProtocolVersion::V2);
        assert_eq!(dec.get_proto_command(), HdrV2Command::PROXY);

        assert_eq!(dec.get_address_family().is_ok(), true);
        assert_eq!(dec.get_address_family().unwrap(), ProxyV2AddrType::AfInet);

        assert_eq!(dec.get_palyload_len() as usize, pkt_ssl.len() - size_of::<protocol_raw::ProxyHdrV2>());
        
        let addr = dec.get_address().unwrap();

        assert_eq!(addr.is_some(), true);

        let addr = addr.unwrap();
        let maddr = ProxyV2Addr::try_from(("127.0.0.1:40402", "127.0.0.67:11883")).unwrap();

        assert_eq!(addr, maddr);

        let tlv_iter = dec.get_tlvs_iter();

        assert_eq!(tlv_iter.is_some(), true);

        let mut tlv_iter = tlv_iter.unwrap();

        let type_ssl = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl.get_type(), PP2Tlvs::TYPE_SSL);
        let PP2Tlvs::TypeSsl { client, verify } = type_ssl else {panic!("wrong")};

        assert_eq!(client, PP2TlvClient::all());
        assert_eq!(verify, 0);

        let type_ssl_version = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl_version.get_type(), PP2Tlvs::TYPE_SUBTYPE_SSL_VERSION);

        let PP2Tlvs::TypeSubtypeSslVersion(ssl_version) = type_ssl_version else { panic!("wrong") };

        assert_eq!(mem::discriminant(&ssl_version), mem::discriminant(&Cow::Owned("TLSv1.2".into())));
        assert_eq!(ssl_version, "TLSv1.2");

        let type_ssl_cn = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl_cn.get_type(), PP2Tlvs::TYPE_SUBTYPE_SSL_CN);

        let PP2Tlvs::TypeSubtypeSslCn(ssl_cn) = type_ssl_cn else { panic!("wrong") };

        assert_eq!(ssl_cn, "mqttuser1");
    }

    #[test]
    fn test_1()
    {

        #[derive(Clone, Debug)]
        pub enum ProxyV2Dummy2 
        {
            SomeTlvName(u32, u32),
            OtherTlv,
        }

        impl fmt::Display for ProxyV2Dummy2
        {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
            {
                write!(f, "DUMMY external reader")
            }
        }

        impl PP2TlvRestore<'static> for ProxyV2Dummy2
        {
            type TlvTblRes = Self;

            fn restore(tlv_type: u8, cur: &mut Cursor<&[u8]>) -> HaProxRes<Self> where Self: Sized 
            {
                match tlv_type
                {
                    0xE0 =>
                    {
                        let arg0 = cur.read_u32::<BigEndian>().map_err(common::map_io_err)?;
                        let arg1 = cur.read_u32::<BigEndian>().map_err(common::map_io_err)?;

                        return Ok(Self::SomeTlvName(arg0, arg1));
                    },
                    _ => 
                        return_error!(ProtocolUnknownData, "unknown tlv_type: {}", tlv_type)
                }
                
            }
            
            fn is_in_range(tlv_type: u8, _tlv_parent_type: Option<u8>) -> bool 
            {
                return tlv_type == PP2_TYPE_MIN_CUSTOM;
            }
            
            fn contains_subtype(_item: &Self::TlvTblRes) -> bool 
            {
                return false;
            }
        }

        impl PP2TlvDump for ProxyV2Dummy2
        {
            fn get_type(&self) -> u8 
            {
                let Self::SomeTlvName(..) = self else { panic!("wrong") };

                return 0xE0;
            }

            fn dump(&self, _cur: &mut Cursor<Vec<u8>>) -> HaProxRes<()> 
            {
                todo!()
            }
        }

        let pkt_ssl = 
b"\x0d\x0a\x0d\x0a\x00\x0d\x0a\x51\x55\x49\x54\x0a\x21\x11\x00\x29\
\x7f\x00\x00\x01\x7f\x00\x00\x43\x9b\x4a\x2e\x6b\x20\x00\x0f\x01\
\x00\x00\x00\x00\x21\x00\x07\x54\x4c\x53\x76\x31\x2e\x32\xE0\x00\
\x08\x01\x02\x03\x04\x05\x06\x07\x08";

        let dec = ProxyV2Parser::<PPV2ParserZeroCopy, ProxyV2Dummy2>::try_from_slice_custom(pkt_ssl.as_slice()).unwrap();

        assert_eq!(dec.get_transport().is_ok(), true);
        assert_eq!(dec.get_transport().unwrap(), ProxyTransportFam::STREAM);

        assert_eq!(dec.get_proto_version(), ProtocolVersion::V2);
        assert_eq!(dec.get_proto_command(), HdrV2Command::PROXY);

        assert_eq!(dec.get_address_family().is_ok(), true);
        assert_eq!(dec.get_address_family().unwrap(), ProxyV2AddrType::AfInet);
        
        assert_eq!(dec.get_palyload_len() as usize, pkt_ssl.len() - size_of::<protocol_raw::ProxyHdrV2>());

        let addr = dec.get_address().unwrap();

        assert_eq!(addr.is_some(), true);

        let addr = addr.unwrap();
        let maddr = ProxyV2Addr::try_from(("127.0.0.1:39754", "127.0.0.67:11883")).unwrap();

        assert_eq!(addr, maddr);

        let tlv_iter = dec.get_tlvs_iter();

        assert_eq!(tlv_iter.is_some(), true);

        let mut tlv_iter = tlv_iter.unwrap();

        let type_ssl = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl.get_type(), PP2Tlvs::TYPE_SSL);
        let PP2Tlvs::TypeSsl { client, verify } = type_ssl else {panic!("wrong")};

        assert_eq!(client, PP2TlvClient::PP2_CLIENT_SSL);
        assert_eq!(verify, 0);

        // --
        let type_ssl_version = tlv_iter.next().unwrap().take_internal().unwrap();

        assert_eq!(type_ssl_version.get_type(), PP2Tlvs::TYPE_SUBTYPE_SSL_VERSION);

        let PP2Tlvs::TypeSubtypeSslVersion(ssl_version) = type_ssl_version else { panic!("wrong") };

        assert_eq!(ssl_version, "TLSv1.2");

        // ---
        let ext_type_e0 = tlv_iter.next().unwrap().take_external().unwrap();

        assert_eq!(ext_type_e0.get_type(), 0xE0);

        let ProxyV2Dummy2::SomeTlvName(arg0, arg1) = ext_type_e0 else {panic!("wrong")};

        assert_eq!(arg0, 0x01020304);
        assert_eq!(arg1, 0x05060708);


    }

    #[test]
    fn test_3()
    {
        let pkt_ssl = 
b"\x0d\x0a\x0d\x0a\x00\x0d\x0a\x51\x55\x49\x54\x0a\x21\x11\x00\x0c\
\x7f\x00\x00\x01\x7f\x00\x00\x01\x8c\x76\x00\x50";


        let dec = ProxyV2Parser::try_from_slice(pkt_ssl.as_slice()).unwrap();

        assert_eq!(dec.get_transport().is_ok(), true);
        assert_eq!(dec.get_transport().unwrap(), ProxyTransportFam::STREAM);

        assert_eq!(dec.get_proto_version(), ProtocolVersion::V2);
        assert_eq!(dec.get_proto_command(), HdrV2Command::PROXY);

        assert_eq!(dec.get_address_family().is_ok(), true);
        assert_eq!(dec.get_address_family().unwrap(), ProxyV2AddrType::AfInet);

        assert_eq!(dec.get_palyload_len() as usize, pkt_ssl.len() - size_of::<protocol_raw::ProxyHdrV2>());
        
        let addr = dec.get_address().unwrap();

        assert_eq!(addr.is_some(), true);

        let addr = addr.unwrap();
        let maddr = ProxyV2Addr::try_from(("127.0.0.1:35958", "127.0.0.1:80")).unwrap();

        assert_eq!(addr, maddr);

        let tlv_iter = dec.get_tlvs_iter();

        assert_eq!(tlv_iter.is_some(), false);

    }

}