C++ Win IP-Header UDP-Header

// UDP
 
struct PseudoHeader
{
    uint32_t sender_IP;
    uint32_t recipient_IP;
    uint8_t zero;
    uint8_t protocol;
    uint16_t udp_length;
};
 
struct UDP_Header
{
    uint16_t sender_port;
    uint16_t recipient_port;
    uint16_t total_length;
    uint16_t checksum;
};
 
uint16_t Protocol_UDP::get_checksum(const std::string& data)
{
    header.checksum = 0;
 
    uint32_t sum = 0;
 
    const uint16_t* pseudo_header_words = reinterpret_cast<const uint16_t*>(&pseudo_header);
    for (size_t i = 0; i < sizeof(PseudoHeader) / 2; ++i) {
        sum += pseudo_header_words[i];
    }
 
    const uint16_t* udp_header_words = reinterpret_cast<const uint16_t*>(&header);
    for (size_t i = 0; i < sizeof(UDP_Header) / 2; ++i) {
        sum += udp_header_words[i];
    }
 
    const char* data_bytes = data.c_str();
    for (size_t i = 0; i < data.size(); i += 2) {
        uint16_t word = (data_bytes[i] << 8) + (i + 1 < data.size() ? data_bytes[i + 1] : 0);
        sum += word;
    }
 
    while (sum > 0xFFFF) {
        sum = (sum >> 16) + (sum & 0xFFFF);
    }
 
    return ~sum;
}
 
void Protocol_UDP::create_UDP_header(uint16_t sender_port, uint16_t recipient_port, uint32_t sender_IP, uint32_t recipient_IP, const std::string& data)
{
    header.sender_port = htons(sender_port);
    header.recipient_port = htons(recipient_port);
    header.total_length = htons(8 + data.size());
    header.checksum = 0;
 
    pseudo_header.sender_IP = htonl(sender_IP);
    pseudo_header.recipient_IP = htonl(recipient_IP);
    pseudo_header.zero = 0;
    pseudo_header.protocol = 17;
    pseudo_header.udp_length = header.total_length;
 
    header.checksum = get_checksum(data);
}
 
// IP
 
struct IP_Header
{
    uint8_t version_length;
    uint8_t type_of_service;
    uint16_t total_length;
    uint16_t package_ID;
    uint16_t flags_offsets;
    uint8_t ttl;
    uint8_t protocol;
    uint16_t checksum;
    uint32_t sender_IP;
    uint32_t recipient_IP;
};
 
uint16_t Protocol_IP::get_checksum() {
    header.checksum = 0;
 
    uint32_t sum = 0;
    uint16_t* header_ptr = reinterpret_cast<uint16_t*>(&header);
 
    for (size_t i = 0; i < sizeof(IP_Header) / 2; ++i) {
        sum += header_ptr[i];
    }
 
    while (sum >> 16) {
        sum = (sum & 0xFFFF) + (sum >> 16);
    }
 
    return static_cast<uint16_t>(~sum);
}
 
void Protocol_IP::create_IPv4_header(uint32_t sender_IP, uint32_t recipient_IP, Protocol_UDP udp)
{
    header.version_length = (4 << 4) | 5;
    header.type_of_service = 0;
    header.total_length = htons(sizeof(IP_Header) + ntohs(udp.header.total_length));
    header.package_ID = htons(777);
    header.flags_offsets = htons(0x4000);
    header.ttl = 64;
    header.protocol = 17;
    header.checksum = get_checksum();
    header.sender_IP = htonl(sender_IP);
    header.recipient_IP = htonl(recipient_IP);
}
 
// socket
 
void NetworkStack::send_message(uint32_t sender_IP, uint32_t recipient_IP, uint16_t sender_port, uint16_t recipient_port, const std::string& data)
{
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed" << std::endl;
        return;
    }
 
    SOCKET udp_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
    if (udp_socket == INVALID_SOCKET) {
        std::cerr << "Socket creation failed" << std::endl;
        WSACleanup();
        return;
    }
 
    int optval = 1;
    if (setsockopt(udp_socket, IPPROTO_IP, IP_HDRINCL, (char*)&optval, sizeof(optval)) == SOCKET_ERROR) {
        std::cerr << "setsockopt failed" << std::endl;
        closesocket(udp_socket);
        WSACleanup();
        return;
    }
 
    udp.create_UDP_header(sender_port, recipient_port, sender_IP, recipient_IP, data);
    packet.create_IPv4_header(sender_IP, recipient_IP, udp);
 
    char buffer[6536];
    memcpy(buffer, &packet.header, sizeof(IP_Header));
    memcpy(buffer + sizeof(IP_Header), &udp.header, sizeof(UDP_Header));
    memcpy(buffer + sizeof(IP_Header) + sizeof(UDP_Header), data.c_str(), data.size());
 
    sockaddr_in recipient_addr;
    recipient_addr.sin_family = AF_INET;
    recipient_addr.sin_port = htons(recipient_port);
    recipient_addr.sin_addr.s_addr = recipient_IP;
 
 
    int packet_size = sizeof(IP_Header) + sizeof(UDP_Header) + data.size();
    if (sendto(udp_socket, buffer, packet_size, 0, (sockaddr*)&recipient_addr, sizeof(recipient_addr)) == SOCKET_ERROR) {
        std::cerr << "sendto failed" << std::endl;
    }
    else {
        std::cout << "Packet sent successfully" << std::endl;
    }
 
    closesocket(udp_socket);
    WSACleanup();
 
    std::cout << std::endl;
    udp.get_information_udp();
    std::cout << std::endl;
    packet.get_information_ip_packet();
}