Complex struct organization (network/packet-related)

Quick little structure organization problem. Basically revolves around how do you define a set of structures with optimal memory layout for networking purposes; set as in, dynamic fields in a struct.

Constructing a transaction structure which holds a header and optional TLV (Type/Length/Value (networking term)) structs. Though, say, there are 6 different TLV structs and they are only to be included if necessary. So, how do I create a dynamic transaction struct that holds different combinations of TLVs that are contiguous in memory?

The following is an example if I want to include all the TLVs.

**NOTE: tlv_artist has a array ptr field. So when malloc'ing the transaction structure I'd do a "sizeof(transaction_t) + artist_name_length)", then memcpy into artist_name[0] so that the memory is all contiguous (no pointers to more data, etc...).

**Also note that tlv_artist is at the bottom of the transaction struct. This is so that you can properly index after malloc'ing. Otherwise, you couldn't index to fields defined below tlv_artist.

Code:

typedef struct tlv_song_size_ {
    int type;
    int length;
    int song_size;
} tlv_song_size_t;

typedef struct tlv_song_len_ {
    int type;
    int length;
    int song_length;
} tlv_song_len_t;

typedef struct tlv_artist {
    int type;
    int length;
    char artist_name[0];
} tlv_artist_t;

typedef struct header_ {
    int version;
    int blah;
} header_t;

typedef struct transaction_ {
    header_t header;
    tlv_song_size;
    tlv_song_len;
    tlv_artist_t artist;
} transaction_t;

Note this works fine. Though, what if I don't need to include a tlv_song_size? What if I don't want to include a tlv_song_len? I could always malloc that structure and fill it, but the memory wouldn't be contiguous then...

So how do I avoid defining multiple transaction structures that holds different combinations of header + TLVs?

I sincerely thank you for your advice.

Did you try realloc()? Idea would be to allocate buffer (to hold header initialy), see what needs to be added, realloc() buffer (increase it's size), append data, repeat as necessary, send...

Looks like I'll have to end up with that implementation. Wish C allowed dynamic structures like described above.

Originally Posted by brooksbp

Looks like I'll have to end up with that implementation. Wish C allowed dynamic structures like described above.

But it's easy to make a function that will do that (append structure) if (and it seems so) every struct has type/size info, so it's enough to pass just a pointer to function and it will detect struct easily (no explicit type/size info required to pass along).

EDIT: you can also go fancy and use va_args to handle all stuff in one call

Would a union help?

A union has a fixed size and would not help. A buffer with realloc would be the best solution IMO

Well it would make it a little smaller. Instead of having those 3 structs (tlv_song_size, tlv_song_len, tlv_artist_t artist) in the transaction_t struct you'd have a union of structs which should take up as much space as whichever one of those structs is largest.
Obviously in some cases there would be some wasted space, but it might be easier and less error prone in the long run.