/* Explicitly define each type, so that omissions
 * and changes are forwards and backwards compatible.
*/
enum data_type {
    UNKNOWN = 0,
    FOO = 1,
    BAR = 2,
    BAZ = 3,
    /* ... */
};

struct data_foo {
    uint32_t     id;    /* = FOO */
    uint32_t     size;  /* = sizeof(struct data_foo) */
    /* .. foo payload follows .. */
};

struct data_bar {
    uint32_t     id;    /* = BAR */
    uint32_t     size;  /* = sizeof(struct data_bar) */
    /* .. bar payload follows .. */
};

struct data_baz {
    uint32_t     id;    /* = BAZ */
    uint32_t     size;  /* = sizeof(struct data_baz) */
    /* .. baz payload follows .. */
};

struct data_unknown {
    uint32_t     id;
    uint32_t     size;
    /* Payload structure is unknown, and therefore undefined. */
};

#define DATA_UNKNOWN  0
#define DATA_FOO      1
#define DATA_BAR      2
#define DATA_BAZ      3

struct payload_foo {
    /* ... the foo payload ... */
};

struct payload_bar {
    /* ... the bar payload ... */
};

struct payload_baz {
    /* ... the baz payload ... */
};

/* Common data header */
struct data_header {
    uint32_t   type;
    uint32_t   size;
};

/* The container data structure: */
struct data {
    struct data_header  header;
    union {
        struct foo        foo;
        struct bar        bar;
        struct baz        baz;
    }                   payload;
};

#include <stdlib.h>
#include <errno.h>

struct data *new_data(uint32_t const type)
{
    struct data *ptr;
    uint32_t     size;

    switch (payload_type) {
    case TYPE_FOO: size = sizeof(struct foo); break;
    case TYPE_BAR: size = sizeof(struct bar); break;
    case TYPE_BAZ: size = sizeof(struct baz); break;
    default:
        /* Unknown data type; fail. */
        errno = ENOENT;
        return NULL;
    };

    ptr = malloc(sizeof(struct data_header) + (size_t)size);
    if (!ptr) {
        /* Some malloc()s do not set errno at failure. */
        errno = ENOMEM;
        return NULL;
    }

    /* Note: This implementation sets size to the payload size.
     *       The other possibility is to include the header size too.
    */
    ptr->header.type = type;
    ptr->header.size = size;

    return ptr;
}

/** write_data() - Write the data to a socket or a file.
 * @descriptor     Socket or file descriptor
 * @ptr            Pointer to the struct data structure
 * If the write is successful, zero is returned.
 * Otherwise a nonzero error code (see errno) is returned.
*/
int write_data(int const descriptor, struct data const *const ptr)
{
    if (descriptor == -1 || !ptr)
        return EINVAL; /* Invalid parameters */

    {
        char const       *p = (char const *)ptr;
        char const *const q = p + ptr->header->size + sizeof(struct data_header);
        ssize_t           n;

        while (p < q) {
            n = write(descriptor, p, (size_t)(q - p));

            if (n > (ssize_t)0)
                p += (size_t)n;

            else
            if (n != (ssize_t)-1)
                return EIO; /* A library bug; this should never happen. */

            else
            if (errno == EINTR)
                continue; /* A signal was delivered, interrupting the write. */

            else
            if (errno == EWOULDBLOCK || errno == EAGAIN)
                continue; /* Socket is nonblocking, but the other end blocks. */

            else
                return errno; /* Any error condition. */
        }
    }

    return 0;
}

int write_data(int const descriptor,
               uint32_t const type,
               uint32_t const size,
               void const *const data);

int read_data(int const descriptor,
              uint32_t *const typeptr,
              uint32_t *const sizeptr,
              void **const dataptr);