Decoding enums based on remaining length

[enbyted]

I have a protocol where packets of the same type may have different lengths and thus have different meanings.
In theory most cases could be solved by just compounding Option<T>, but that will quickly get unmanageable and won't cover cases where longer packet may have slightly different decoding of previous fields.

For example:

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite)]
struct DatagramHeader {
    crc: u8,
    #[deku(bits = "1")]
    query: bool,
    #[deku(bits = "3")]
    _reserved: u8,
    /// Currently always set to 1
    #[deku(bits = "4")]
    version: u8,
    recipient: Address,
    sender: Address,
    sequence_number: u8,
    // Technically the header also has the packet type field here, but I shift it onto the enum
    // since different enums need to be used depending on the version field
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite)]
#[deku(id_type = "u8")]
pub enum Packet {
    #[deku(id = "0x20")]
    DeviceInfo(DeviceInfo),

    #[deku(id = "0xF0")]
    Ack,
}

// Device info can be 0 (technically only used when query=true in header), 2 or 4 bytes 

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite)]
struct DeviceInfo {
    data: Option<DeviceInfoData>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite)]
struct DeviceInfoData {
    value: u16,
    version2_data: Option<DeviceInfoDataV2>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite)]
struct DeviceInfoDataV2 {
    value: u16,
}

I would prefer to have it as such:

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite)]
#[deku(id_type = "u8")]
pub enum Packet {
    #[deku(id = "0x20", ...)]
    DeviceInfoQuery,

    #[deku(id = "0x20", ...)]
    DeviceInfoV1(DeviceInfoV1),

    #[deku(id = "0x20", ...)]
    DeviceInfoV2(DeviceInfoV2),

    #[deku(id = "0xF0")]
    Ack,
}

Note that the header does not contain the payload length - it is known by the virtue of knowing the total packet length (as it is given by higher layer) and the header length (as it is constant). I.e. This will always be used to decode data from pre-allocated buffers, not streams.

I suppose I could pass the payload length via context.
When deserializing the packet I first read the header then based on the fields in it (here the version field) I decode the rest accordingly (just the Packet enum for simplicity here).

BTW, any good ideas on how to update the crc field in this scenario?

For completeness I then pack this into structs and enum like this:

struct DatagramV1 {
  header: DatagramHeader,
  packet: Packet
}

enum Datagram {
  V1(DatagramV1)
}

Though for now, I do the packing/unpacking to/from the buffer of those manually.