// Listing 1: Client-side modification to send every mutation to the server [1]
int send_data(char* data, uint32_t size) {
    // Initialize Winsock library
    WSADATA wsa;
    // Socket descriptor
    SOCKET s;
    // Server address structure
    struct sockaddr_in server;
    // Remote server IP address (example: 192.168.1.1)
    wchar_t ip_address[] = L"192.168.1.1";
    // Set server address family and port
    server.sin_family = AF_INET;
    server.sin_port = htons(4444); // Port 4444 for communication
    // Initialize Winsock
    if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
        // Return error if Winsock initialization fails
        return 1;
    }
    // Create a socket
    if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
        // Clean up Winsock and return error if socket creation fails
        WSACleanup();
        return 1;
    }
    // Convert IP address from wide character string to network address structure
    if (InetPton(AF_INET, ip_address, &(server.sin_addr)) != 1) {
        // Close socket, clean up Winsock, and return error if IP conversion fails
        closesocket(s);
        WSACleanup();
        return 1;
    }
    // Connect to the remote server
    if (connect(s, (struct sockaddr*)&server, sizeof(server)) < 0) {
        // Close socket, clean up Winsock, and return error if connection fails
        closesocket(s);
        WSACleanup();
        return 1;
    }
    // Convert data size to network byte order and send it
    uint32_t size_header = htonl(size);
    if (send(s, (char*)&size_header, sizeof(size_header), 0) < 0) {
        // Close socket, clean up Winsock, and return error if sending size fails
        closesocket(s);
        WSACleanup();
        return 1;
    }
    // Send the actual data
    if (send(s, data, size, 0) < 0) {
        // Close socket, clean up Winsock, and return error if sending data fails
        closesocket(s);
        WSACleanup();
        return 1;
    }
    // Close the socket and clean up Winsock
    closesocket(s);
    WSACleanup();
    return 0;
}

# Listing 2: Server-side Python script to receive and store fuzzed samples [1]
#!/usr/bin/env python3
import os
import socket
import zipfile
import threading
from concurrent.futures import ThreadPoolExecutor
# Global counters for files and zip archives, protected by a lock
file_counter = 0
file_counter_lock = threading.Lock()
zip_counter = 1
def handle_client(client_socket, address):
    global file_counter, zip_counter
    try:
        # Receive data size (4 bytes, big-endian)
        data_size_bytes = client_socket.recv(4)
        if not data_size_bytes:
            return
        data_size = int.from_bytes(data_size_bytes, byteorder='big')
        # Receive the actual data in chunks
        data = bytearray()
        while len(data) < data_size:
            packet = client_socket.recv(min(1024, data_size - len(data)))
            if not packet:
                break
            data.extend(packet)
        # Ensure all data is received
        if len(data) != data_size:
            print(f"[!] Incomplete data received from {address}")
            return
        with file_counter_lock:
            file_counter += 1
            file_name = f"id_{file_counter:06d}"
            print(f"Received {file_counter} from {address}")
        # Save the received data to a file
        with open(file_name, "wb") as file:
            file.write(data)
        # Periodically zip files and clean up old ones
        if file_counter % 5000 == 0:
            zip_name = f"archive_{zip_counter:03d}.zip"
            with zipfile.ZipFile(zip_name, 'w') as zipf:
                # Zip the last 5000 files
                for i in range(file_counter - 4999, file_counter + 1):
                    file_to_zip = f"id_{i:06d}"
                    if os.path.exists(file_to_zip):
                        zipf.write(file_to_zip)
                        os.remove(file_to_zip) # Delete original after zipping
            zip_counter += 1
            print(f"[*] Created {zip_name} and cleaned up files.")
    except Exception as e:
        print(f"[!] Error handling client {address}: {e}")
    finally:
        client_socket.close()
def main():
    server_ip = "0.0.0.0"  # Listen on all available interfaces
    server_port = 4444     # Listen on port 4444
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reusing the address
    server.bind((server_ip, server_port))
    server.listen(5) # Max 5 pending connections
    print(f"[*] Listening on {server_ip}:{server_port}")
    # Use a thread pool to handle multiple client connections concurrently
    with ThreadPoolExecutor(max_workers=20) as executor:
        while True:
            client_socket, addr = server.accept()
            print(f"[*] Accepted connection from {addr[0]}:{addr[1]}")
            executor.submit(handle_client, client_socket, addr)
if __name__ == "__main__":
    main()