In reply to @kaiyou:tedomum.net

Here is an excerpt from real code (not published, sorry) :

    #[br(temp, restore_position)]
    #[bw(ignore)]
    op: Operation,
    data: Payload

The field is simply not written. When reading, I read the opcode, makes decisions based on it, then parse a Payload which is an enum using magics. When writing, it simply writes the enum and prepends the magic bytes.

In reply to @snover:matrix.org
got it. i think the best thing right now that you can do is to write a member function on the enum that returns the correct id for each enum variant. binrw does not have any thing right now that does this automatically. there are some other crates that you could use to derive. either case ends up requiring specifying variants twice, which is unfortunate. you can also use import and pre_assert to pick an enum variant instead, but i do not think that any of this will avoid the current requirement to duplicate something—either you will have one unit enum with the magic numbers and then a second data enum with the same variants, using pre_assert, or you will have two things with the same magic numbers, using magic.

In reply to @snover:matrix.org
i suppose you could write a macro to try to avoid duplicating the values

https://github.com/Krensi/binrw-datapoints

Maybe someone could benefit from this example of how I control writing and reading only via the enum. I also played around with generics to support different types for the encoding format
size - id - value

value is the only item of actual interest which is the enum

with your tipp to use macro_rules it was actually very easy to get the ID - thanks again :-)

Hello! Is it possible to use both a calc directive and an assert? This is complaining that *u_ack_vector_size doesn't exist

    /// A 16-bit unsigned value that specifies the size of the AckVector field
    /// in bytes. The maximum size of the ACK Vector is 2048 bytes.
    #[br(assert(u_ack_vector_size >= 2048, "u_ack_vector_size maximum size is 2048"))]
    #[bw(assert(*u_ack_vector_size >= 2048, "u_ack_vector_size maximum size is 2048"))]
    #[bw(calc = (ack_vector.len()) as u16)]
    pub u_ack_vector_size: u16,

Thanks! :)

And another question. I'm parsing packets. All of them have a header, which specifies the packet type:

/// UDP_PACKET_HEADER
/// This structure describes a UDP packet.
#[binrw]
#[brw(little)]
pub struct UdpPacketHeader {
    /// The packet type information, which can be one of the enumerations
    /// specified in 2.2.5.4.1.
    pub pkt_id: UdpPktType,

    /// Specifies the packet length excluding the length of UDP_PACKET_HEADER
    pub pkt_len: u16,
}

The UdpPktType is an enum:

#[binrw]
#[brw(repr(u16))]
pub enum UdpPktType {
    /// PKT_TYPE_CONNECT_REQ
    /// This constant is used to represent the CONNECT packet type sent by
    /// the client during the Connection Setup Phase (section 1.3.1.1.1).
    PktTypeConnectReq = 1,
...

And then, there's each packet, which has its own structure.

Is it possible to make a "generalized parser"? E.g. have a Packet union, which reads the header type and, depending on the packet type read one packet or another. Also, I'd like to have the header "embeded" in each packet, since there are some that depend on it for lenghts:

#[binrw]
#[brw(little)]
pub struct DataPkt {
    // HEADER HERE TO BE ABLE TO `count` the length of data 
    /// An array of BYTE containing the RDP UDP data.
    pub data: Vec<u8>,
}

I'd be nice to be able to simply write a packet and automatically get the header, so:

1. Packet type is set
2. Length is also set

In reply to @nefix:matrix.org

Hello! Is it possible to use both a calc directive and an assert? This is complaining that *u_ack_vector_size doesn't exist

    /// A 16-bit unsigned value that specifies the size of the AckVector field
    /// in bytes. The maximum size of the ACK Vector is 2048 bytes.
    #[br(assert(u_ack_vector_size >= 2048, "u_ack_vector_size maximum size is 2048"))]
    #[bw(assert(*u_ack_vector_size >= 2048, "u_ack_vector_size maximum size is 2048"))]
    #[bw(calc = (ack_vector.len()) as u16)]
    pub u_ack_vector_size: u16,

Thanks! :)

When you use calc there is no actual field, so assert on ack_vector.len() instead. From the docs:

Since the field is treated as a temporary variable instead of an actual field, when deriving BinRead, the field should also be annotated with #[br(temp)].

In reply to @nefix:matrix.org

And another question. I'm parsing packets. All of them have a header, which specifies the packet type:

/// UDP_PACKET_HEADER
/// This structure describes a UDP packet.
#[binrw]
#[brw(little)]
pub struct UdpPacketHeader {
    /// The packet type information, which can be one of the enumerations
    /// specified in 2.2.5.4.1.
    pub pkt_id: UdpPktType,

    /// Specifies the packet length excluding the length of UDP_PACKET_HEADER
    pub pkt_len: u16,
}

The UdpPktType is an enum:

#[binrw]
#[brw(repr(u16))]
pub enum UdpPktType {
    /// PKT_TYPE_CONNECT_REQ
    /// This constant is used to represent the CONNECT packet type sent by
    /// the client during the Connection Setup Phase (section 1.3.1.1.1).
    PktTypeConnectReq = 1,
...

And then, there's each packet, which has its own structure.

Is it possible to make a "generalized parser"? E.g. have a Packet union, which reads the header type and, depending on the packet type read one packet or another. Also, I'd like to have the header "embeded" in each packet, since there are some that depend on it for lenghts:

#[binrw]
#[brw(little)]
pub struct DataPkt {
    // HEADER HERE TO BE ABLE TO `count` the length of data 
    /// An array of BYTE containing the RDP UDP data.
    pub data: Vec<u8>,
}

I'd be nice to be able to simply write a packet and automatically get the header, so:

1. Packet type is set
2. Length is also set

In reply to @nefix:matrix.org

And another question. I'm parsing packets. All of them have a header, which specifies the packet type:

/// UDP_PACKET_HEADER
/// This structure describes a UDP packet.
#[binrw]
#[brw(little)]
pub struct UdpPacketHeader {
    /// The packet type information, which can be one of the enumerations
    /// specified in 2.2.5.4.1.
    pub pkt_id: UdpPktType,

    /// Specifies the packet length excluding the length of UDP_PACKET_HEADER
    pub pkt_len: u16,
}

The UdpPktType is an enum:

#[binrw]
#[brw(repr(u16))]
pub enum UdpPktType {
    /// PKT_TYPE_CONNECT_REQ
    /// This constant is used to represent the CONNECT packet type sent by
    /// the client during the Connection Setup Phase (section 1.3.1.1.1).
    PktTypeConnectReq = 1,
...

And then, there's each packet, which has its own structure.

Is it possible to make a "generalized parser"? E.g. have a Packet union, which reads the header type and, depending on the packet type read one packet or another. Also, I'd like to have the header "embeded" in each packet, since there are some that depend on it for lenghts:

#[binrw]
#[brw(little)]
pub struct DataPkt {
    // HEADER HERE TO BE ABLE TO `count` the length of data 
    /// An array of BYTE containing the RDP UDP data.
    pub data: Vec<u8>,
}

I'd be nice to be able to simply write a packet and automatically get the header, so:

1. Packet type is set
2. Length is also set

In reply to @snover:matrix.org

When you use calc there is no actual field, so assert on ack_vector.len() instead. From the docs:

Since the field is treated as a temporary variable instead of an actual field, when deriving BinRead, the field should also be annotated with #[br(temp)].

In reply to @snover:matrix.org
Use a data enum with magic attribute on the variants.

#[binrw]
enum DataPkt {
  #[brw(magic(1u16))]
  UdpPktType { len : u16 }, 
  #[brw(magic(2u16)]
  PktType2 { len: u16 },
  ...
}

In reply to @snover:matrix.org

#[binrw]
enum DataPkt {
  #[brw(magic(1u16))]
  UdpPktType { len : u16 }, 
  #[brw(magic(2u16)]
  PktType2 { len: u16 },
  ...
}

Right now it's looking as follows:

#[binrw]
#[brw(little)]
pub enum Packet {
    /// PKT_TYPE_HANDSHAKE_REQUEST
    /// This constant represents that the packet type is handshake request.
    #[brw(magic(0x1u16))]
    HandshakeRequest(HandshakeRequestPacket),

    /// PKT_TYPE_HANDSHAKE_RESPONSE
    /// This constant represents that the packet type is handshake
    /// response.
    #[brw(magic(0x2u16))]
    HandshakeResponse(HandshakeResponsePacket),

    /// PKT_TYPE_EXTENDED_AUTH_MSG
    /// This constant represents that the packet type is an extended
    /// authentication message.
    #[brw(magic(0x3u16))]
    ExtendedAuthMsg(ExtendedAuthPacket),
}

pub struct DataPkt { 
  id: u16,
   len: u16, #\[br(args(id, len))\] data: Packet } #\[br(import(id: u16, len: u16)\] enum Packet { #\[br(pre\_assert(id == 1))\] HandshakeRequest(#\[br(args(len))\] HandshakeRequestPacket), … }

pub struct DataPkt { 
  id: u16,
  len: u16,
  #[br(args(id, len))] data: Packet
} 


#[br(import(id: u16, len: u16)]
enum Packet { 
  #[br(pre_assert(id == 1))] HandshakeRequest(#[br(args(len))] HandshakeRequestPacket), 
  …
 }