Writing members from struct passed to function gives unexpected result - c

Question

First things first - my header (.h) file looks like this:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
typedef struct riff_list {
char id[4];
uint32_t cksize;
char subid[4];
uint8_t *buf;
} list_t;
void write_u32_le(uint32_t n, FILE *f)
{
uint8_t i, buf[4];
for (i = 0; i < 4; i++)
{
buf[i] = n & 0xFF;
n >>= 8;
}
fwrite(buf, 1, 4, f);
}
void init_list_chunk(list_t list, char *cktype)
{
memcpy(list.id, "LIST", 4);
list.cksize = 0;
memcpy(list.subid, cktype, 4);
}
void write_list_chunk(list_t list, FILE *f)
{
fwrite(list.id, 1, 4, f);
write_u32_le(4 + list.cksize, f);
fwrite(list.subid, 1, 4, f);
fwrite(list.buf, 1, list.cksize, f);
}
Now, the problem is with a basic test program trying to write something to a file. This comes out as expected:
int main()
{
FILE *f;
list_t list;
memcpy(list.id, "LIST", 4);
list.cksize = 0;
memcpy(list.subid, "TEST", 4);
f = fopen("C:\\listtest.bin", "wb");
fwrite(list.id, 1, 4, f);
write_u32_le(4+list.cksize, f);
fwrite(list.subid, 1, 4, f);
list.buf = malloc(4);
fwrite(list.buf, 1, 4, f);
free(list.buf);
fclose(f);
}
While this just produces a 4096-byte file with junk, with no recognizable parts of what is expected (not even "LIST"):
int main()
{
FILE *f;
list_t list;
init_list_chunk(list, "TEST");
list.buf = malloc(4);
list.cksize += 4;
f = fopen("C:\\listtest.bin", "wb");
write_list_chunk(list, f);
free(list.buf);
fclose(f);
}
Why is this? Why does the latter approach not work as expected?
The expected output should be something like:
LIST
ssss
TEST
xxxx
Where "ssss" is the size and "xxxx" is any random data (4 bytes).
I have seen approaches that instead passes structs as pointers to them (&my_struct_var) and accesses the members in a function by deferencing them as my_struct_var->member, but can I pass the struct as it is?

Answer 1

Calling a function with out = func(in); means that if the function modifies the contents of in those modifications will only be visible within the function. When the function returns the calling function will still have the same contents in the variable in. Doing a call by value could be described as the called function gets its own copy of the variable.
You have two options to solve your problem:
1) As you already suggested yourself, your function init_list_chunk could take a pointer to your structure. By then modifying the structure the pointer points to those modifications will be usable also for the calling function.
2) Instead of returning void your init_list_chunk could return the modified structure. Something like: list = init_list_chunk(list, "TEST"); or even list = init_list_chunk("TEST"); as there is no useful input information within list at the time of the function call.