Dfyjkt

I am wondering whether there is any known best practice/method for parsing mixed type of data packet.

For instance, let's say the data is 10 bytes, and it consists of:

Byte 0-1: manufacturer ID (int)

Byte 2: type (int)

Byte 3-4: device id (ascii char)

I could simply define each data type size and location as #define, and parse it using those defines. But I am wondering if there is any structure to organise this better.

Best practice it to assume all data from outside the program (e.g. from the user, from a file, from a network, from a different process) is potentially incorrect (and potentially unsafe/malicious).

Then, based on the assumption of "potential incorrectness" define types to distinguish between "unchecked, potential incorrect data" and "checked, known correct data". For your example, you could use uint8_t packet[10]; as the data type for unchecked data and a normal structure (with padding and without __attribute__((packed));) for the checked data. This makes it extremely difficult for a programmer to accidentally use unsafe data when they think they're using safe/checked data.

Of course you will also need code to convert between these data types, which needs to do as many sanity checks as possible (and possibly also worry about things like endianess). For your example these checks could be:

• are any of the bytes that are supposed to be ASCII characters >= 0x80, and are any of them invalid (e.g. maybe control characters like backspace are not permitted).


• is the manufacturer ID valid (e.g. maybe there's an enumeration that it needs to match)


• is the type valid (e.g. maybe there's an enumeration that it needs to match)

Note that this function should return some kind of status to indicate if the conversion was successful or not, and in most cases this status should also give an indication of what the problem was if the conversion wasn't successful (so that the caller can inform the user or log the problem or handle the problem in the most suitable way for the problem). For example, maybe "unknown manufacturer ID" means that the program needs to be updated to handle a new manufacturer and that the data was correct, and "invalid manufacturer ID" means that the data was definitely wrong.

Like this:

struct packet 
 uint16_t mfg;
 uint8_t type;
 uint16_t devid;
 __attribute__((packed));

The packed attribute (or your platform's equivalent) is required to avoid implicit padding which doesn't exist in the protocol.

Once you have the above struct, you simply cast (part of) a char array which you received from wherever:

char buf[1000];
(struct packet*)(buf + N);