Neater way to handle errors from multiple fread calls - c

Question

I have the following method in C to load a binary file, it seems rather long and tedious having to check the error value from each and every fread call, is there a neater way to handle this?
I'm aware that some of the calls could be reduced by reading in a struct in one go, but due to how C can add padding bytes in between struct members, I'd prefer to avoid this.
some_type_t *load_something(FILE *file) {
some_type_t *something = (some_type_t *)malloc(sizeof(some_type_t));
if (something == NULL) {
return NULL;
}
if (fread(&something->field1, sizeof(something->field1), 1, file) == 0) {
free(something);
return NULL;
}
if (fread(&something->field2, sizeof(something->field2), 1, file) == 0) {
free(something);
return NULL;
}
if (fread(&something->field3, sizeof(something->field3), 1, file) == 0) {
free(something);
return NULL;
}
uint16_t some_var1, some_var2, some_var3;
some_other_type_t *something_else1 = (some_other_type_t *)malloc(sizeof(some_other_type_t));
if (fread(&some_var1, sizeof(some_var1), 1, file) == 0) {
free(something);
free(something_else1);
return NULL;
}
some_other_type_t *something_else2 = (some_other_type_t *)malloc(sizeof(some_other_type_t));
if (fread(&some_var2, sizeof(some_var2), 1, file) == 0) {
free(something);
free(something_else1);
free(something_else2);
return NULL;
}
some_other_type_t *something_else3 = (some_other_type_t *)malloc(sizeof(some_other_type_t));
if (fread(&some_var3, sizeof(some_var3), 1, file) == 0) {
free(something);
free(something_else1);
free(something_else2);
free(something_else3);
return NULL;
}
// Do something with the vars and allocated something elses.
// ...
return something;
}

Answer 1

Why not creating a macro:
#define READ_FIELD(data) \
do { if (fread(&data, sizeof(data), 1, file) == 0) { \
free(something); \
free(something_else1);
free(something_else2);
return NULL; \
} } while(0)
then call it like a function call:
READ_FIELD(something->field1);
READ_FIELD(something->field2);
READ_FIELD(some_var1);
READ_FIELD(some_var2);
the code will be the same but at least it is now generated and not copied/pasted (with possible errors).
The macro has to call free on all possible memory blocks, even the ones that aren't allocated yet. The only constraint is to set the unallocated ones to NULL so free doesn't crash. And to be super safe change as:
free(something); something = NULL;
(of course if something is the copy of an allocated pointer, setting to NULL doesn't protect against double free, it has limits)
you can apply this technique to the write side as well, and since M Oehm suggested that, you could make a list of what you want to read/write in a wrapper macro:
#define DO_ALL \
DO_FIELD(something->field1); \
DO_FIELD(something->field2); \
DO_FIELD(some_var1); \
DO_FIELD(some_var2)
then define DO_FIELD as READ_FIELD or WRITE_FIELD:
#define DO_FIELD READ_FIELD
DO_ALL;
#undef DO_FIELD

Answer 2

There's nothing that could save you to check the success of each and every call, but you can improve on the code structure using goto (this is in fact one idiomatic use of goto in C, pseudo-code to follow):
if (first_call() < 0) goto error;
if (second_call() < 0) goto error;
// [...]
// when everything succeeded:
return result;
error:
// free resources
// return error-indicator, e.g.
return 0;
If the resources to free accumulate over the course of your function, make sure to first initialize them all to NULL/0 (assuming they are pointers). Then, calling free() on them in your error part has no effect when they're not allocated yet. If you use own "destructor functions", make sure to design them the same way free() is designed -- when passed a NULL value, it should be a no-op.

Answer 3

You need to initialize all something pointers to NULL and centralise the cleaning up at one place.
...
something = something_else1 = something_else2 = something_else3 = NULL;
...
some_other_type_t *something_else3 = (some_other_type_t *)malloc(sizeof(some_other_type_t));
if (fread(&some_var3, sizeof(some_var3), 1, file) == 0) {
goto error;
}
// Do something with the vars and allocated something elses.
// ...
return something;
error:
free(something);
free(something_else1);
free(something_else2);
free(something_else3);
return NULL;
}
Freeing a NULL pointer is OK, it does nothing, therefore you don't need to check if the someting pointers are NULL before calling free.
Sidenote: in C you don't cast the return value of malloc.

Answer 4

Here is a simple way to group the malloc and fread operations and check just once for proper completion:
some_type_t *load_something(FILE *file) {
uint16_t some_var1, some_var2, some_var3;
some_type_t *something = malloc(sizeof(*something));
some_other_type_t *something_else1 = malloc(sizeof(*something_else1));
some_other_type_t *something_else2 = malloc(sizeof(*something_else2));
some_other_type_t *something_else3 = malloc(sizeof(*something_else3));
if (!something || !something_else1 || !something_else2 || !something_else3 ||
!fread(&something->field1, sizeof(something->field1), 1, file) ||
!fread(&something->field2, sizeof(something->field2), 1, file) ||
!fread(&something->field3, sizeof(something->field3), 1, file) ||
!fread(&some_var1, sizeof(some_var1), 1, file) ||
!fread(&some_var2, sizeof(some_var2), 1, file) ||
!fread(&some_var3, sizeof(some_var3), 1, file))
{
free(something);
free(something_else1);
free(something_else2);
free(something_else3);
return NULL;
}
// Do something with the vars and allocated something elses.
// ...
return something;
}
Note that passing a null pointer to free() is OK.