How should I collect a large file in C when it arrives in chunks?

Use a growable buffer. Track the number of bytes stored separately from the allocated capacity. Start with a reasonable capacity, append each chunk, and double the capacity when the next chunk won't fit. Keep doubling until it's large enough for the incoming data.

realloc can extend the allocation or move the data to a new block for you. Assign its result to a temporary pointer first. If it returns NULL for a nonzero size, the original allocation is still yours and can be freed or otherwise handled.

Check for size_t overflow when adding the incoming length and when increasing capacity. Also consider a maximum image size so an unexpectedly large transfer can't consume unlimited memory.

Before assembling the whole file, check what the next step needs. If you're saving it, you can write each chunk to a file and reuse the same receive buffer. An image decoder that supports incremental input may let you feed it chunks too.

For a scrolling gallery, you could load the visible images and decide how much to cache as the user moves around. Decoded images can take substantially more memory than the compressed files, so that choice matters too.

Separate allocations are fine if your consumer can work with a sequence of chunks. Keep their pointers and lengths, then free them when you're done. If an image API needs one contiguous buffer, allocate that once after you've received everything and copy the chunks into it.

That avoids repeated resizing, but it adds bookkeeping and temporarily needs space for both the chunks and the final buffer during the copy.

Check the library's completion and size rules before writing the receive loop. Use the number of bytes actually returned, and stop according to the API's documented end condition rather than assuming every short read means the image is complete. Handle errors separately from successful completion.