Packing an array and only process when full - c

Question

I'm working on an embedded c app. The app downloads a file and writes to flash memory. The requirements are that I can only write to flash in blocks of 64 bytes (1 page). THe binary firmware file gets downloaded in chunks no bigger than 64 bytes (e.g. 64 or less bytes). However I am getting the data is different lengths. For example:
1st packet size :62 bytes
2nd packet size :64
3rd packet size :64
4th packet size :64
5th packet size :43
6th packet size :64
....
last packet: length: 7
I need to keep track of the bytes, pack the bytes into a buffer until its full (64 bytes) then write to flash.
I am having a heck a time figuring this out. Here is what I have so far, but is not right and my rmdBuff gets thrown off. I am looking for some guidance.
Global vars
uint8_t temp[64]; // buffer to send when full
uint8_t rmdBuff[64]; // buffer to pack
uint8_t temp_indx;
uint8_t rmd_indx;
uint8_t buffer_room_needed; // keep track of how much room in rmdBuff
uint8_t rem_offset;
uint16_t bit_ct; // how many bits processed
uint16_t rowct; // for debugging
Function
void store_file_packet(char *data, uint32_t length)
{
if ((data == NULL) || (length < 1)) {
return;
}
if (!is_state_set(DOWNLOADING)) {
printf("********* Initial Start of Download **************\n\r");
received_file_size = 0;
add_state(DOWNLOADING);
temp_indx = 0;
rmd_indx = 0;
buffer_room_needed = 0;
rem_offset = 0;
bit_ct = 0;
rowct = 1;
}
if (data != NULL) {
memset(temp, 0, sizeof temp); // clear temp
if(rmd_indx > 0){
// figure out how much room we have in rmd array
buffer_room_needed = 64 - rmd_indx;
rem_offset = abs(length - buffer_room_needed);
memcpy(&rmdBuff[rmd_indx],&data[0],buffer_room_needed); // only copy over what we have room for
rmd_indx = rmd_indx + buffer_room_needed;
if(rmd_indx > 63){ // rmd buffer is full
memcpy(temp,&rmdBuff,64); // copy over all 64 bytes
memset(rmdBuff, 0, sizeof rmdBuff); // clear rmdBuff
temp_indx = 63;// full
rmd_indx = 0;
// add anything else to rmdBuff?
memcpy(&rmdBuff[rmd_indx],&data[buffer_room_needed + 1],rem_offset);
rmd_indx += rem_offset;
}
} else {
if(length != 64){
// not enough, copy over to hold array
memcpy(rmdBuff,&data[0],length);
rmd_indx += length;
} else {
memcpy(temp,&data[0],length); // copy over all 64 bytes
temp_indx = 63; // full
}
}
if(temp_indx == 63){
// write temp buffer to memory
}
}
}