socket recv() returns weird value - c

Question

I have a weird problem when writing a simple socket server and client in C.
The logic is very simple, the client sends 2 messages every time:
The data size (like a header indicating the data size it will send).
the data itself.
The server can successfully receive the first couple of messages, but after a while the data size message becomes some weird value.
This is the code and output.
server.c
uint32_t toUInt32(uint8_t *buf) {
return ((uint32_t) buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}
int recvall(int fd, uint8_t *data, int size) {
int BUFF_SIZE = 1024;
int cur_size = 0;
while(cur_size < size) {
int size_to_recv = BUFF_SIZE;
if (size - cur_size < BUFF_SIZE) {
size_to_recv = size - cur_size;
}
char *temp = malloc(size_to_recv);
int recv_size = recv(fd, temp, size_to_recv, 0);
memcpy(data + cur_size, temp, size_to_recv);
cur_size += size_to_recv;
free(temp);
}
return cur_size;
}
while(1)
{
uint8_t size_message[4];
memset(size_message, 0 , 4);
read_size = recv(client_sock , size_message, 4 , 0);
if (read_size == 0) {
return 0;
}
printf("bytes are %d %d %d %d\n", size_message[0], size_message[1], size_message[2], size_message[3]);
uint32_t size = toUInt32(size_message);
printf("size is %d\n", size);
uint8_t *data = malloc(size);
read_size = recvall(client_sock , data , size);
free(data);
}
server output:
bytes are 0 1 83 91
size is 86875
bytes are 0 1 130 117
size is 98933
bytes are 0 1 208 101
size is 118885
bytes are 0 2 141 253
size is 167421
bytes are 43 244 25 88
size is 737417560
client.c
static inline void
buffer_write32be(uint8_t *buf, uint32_t value) {
buf[0] = value >> 24;
buf[1] = value >> 16;
buf[2] = value >> 8;
buf[3] = value;
}
while(1) {
uint32_t size = (uint32_t)packet->size;
uint8_t *buf = malloc(sizeof(uint32_t));
buffer_write32be(buf, size);
if (send(sock , buf , sizeof(uint32_t) , 0 ) < 0)
{
return false;
}
if (send(sock , packet->data , packet->size, 0 ) < 0)
{
return false;
}
free(buf);
sleep(1);
}
client output:
packet size is 86875, header size 4
packet size is 98933, header size 4
packet size is 118885, header size 4
packet size is 167421, header size 4
packet size is 167847, header size 4
packet size is 169004, header size 4
packet size is 169811, header size 4
You can see that the data size that the server receives suddenly becomes a weird large value, but the client sent out the right value.
What is going on here?