Сырые (RAW) сокеты под виндой

#ifndef FMMAIN_H
#define FMMAIN_H
 
#include <QWidget>
#include "Libs.h"
#include "sockWrapper.h"
 
QT_BEGIN_NAMESPACE
namespace Ui { class fmMain; }
QT_END_NAMESPACE
 
class fmMain : public QWidget
{
    Q_OBJECT
 
private:
    Ui::fmMain *ui;
    sockWrapper *conn;
 
public:
    fmMain(QWidget *parent = nullptr);
    ~fmMain();
 
private:
    void objOptions();
    void printNewMessage(QByteArray data);
 
private slots:
    void on_pushButton_connect_clicked();
    void on_pushButton_unConnect_clicked();
    void on_pushButton_listen_clicked();
    void on_pushButton_unListen_clicked();
    void on_pushButton_sendMessage_clicked();
 
 
 
};
#endif // FMMAIN_H

#include "fmMain.h"
#include "ui_fmMain.h"
 
fmMain::fmMain(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::fmMain)
{
    ui->setupUi(this);
    objOptions();
}
 
fmMain::~fmMain()
{
    delete ui;
}
 
void fmMain::objOptions()
{
    ui->lineEdit_sendIP->setText("127.0.0.1");
    ui->lineEdit_listenIP->setText("127.0.0.1");
    ui->lineEdit_sendPort->setText("2019");
    ui->lineEdit_listenPort->setText("2019");
    conn = new sockWrapper;
    conn->saveChannelOpt(QHostAddress(ui->lineEdit_sendIP->text()),QHostAddress(ui->lineEdit_listenIP->text()),ui->lineEdit_sendPort->text().toUInt(),ui->lineEdit_listenPort->text().toUInt());
    QObject::connect(conn, &sockWrapper::newMessage, this, &fmMain::printNewMessage);
}
 
void fmMain::printNewMessage(QByteArray data)
{
    ui->plainTextEdit_reciveMessage->appendPlainText(QString::fromStdString(data.toStdString()));
}
 
 
void fmMain::on_pushButton_connect_clicked()
{
    conn->connectTo();
}
 
void fmMain::on_pushButton_unConnect_clicked()
{
    conn->unconnectTo();
}
 
void fmMain::on_pushButton_listen_clicked()
{
    conn->listenTo();
}
 
void fmMain::on_pushButton_unListen_clicked()
{
    conn->unlistenTo();
}
 
void fmMain::on_pushButton_sendMessage_clicked()
{
    QByteArray msgData;
    msgData.append(ui->lineEdit_message->text());
    conn->sendTo(msgData);
}

#ifndef SOCKWRAPPER_H
#define SOCKWRAPPER_H
 
#include <QObject>
#include "Libs.h"
 
class sockWrapper : public QObject
{
    Q_OBJECT
 
private:
    struct iphdr
    {
        uint ihl : 4;
        uint version : 4;
        quint8 tos;
        quint16 tot_len;
        quint16 id;
        quint16 frag_off;
        quint8 ttl;
        quint8 protocol;
        quint16 check;
        quint32 saddr;
        quint32 daddr;
    };
    struct udphdr
    {
        quint16 source;
        quint16 dest;
        quint16 len;
        quint16 check;
    };
 
private:
    WSAData wData;
    SOCKET sockSend;
    SOCKET sockListen;
    sockaddr_in forSend;
    sockaddr_in forListen;
    QSocketNotifier *sockNotif;
    iphdr ip;
    udphdr udp;
 
public:
    explicit sockWrapper(QObject *parent = nullptr);
    ~sockWrapper();
    void saveChannelOpt(QHostAddress sendAddr, QHostAddress listenAddr, quint16 sendPort, quint16 listenPort);
    void connectTo();
    void unconnectTo();
    void listenTo();
    void unlistenTo();
    void sendTo(QByteArray data);
 
private:
    void WSAStart();
    void WSAClean();
    void reciveNewMessage();
 
signals:
    void newMessage(QByteArray data);
 
};
 
#endif // SOCKWRAPPER_H

#include "sockWrapper.h"
 
static unsigned long crc32 ( char *buff, unsigned long len)
{
    unsigned long crc_table[256];
    unsigned long crc;
    for (int i = 0; i < 256; ++i)
    {
        crc = i;
        for (int j = 0; j < 8; ++j)
        {
            crc = crc & 1 ? (crc >> 1) ^ 0xEDB88320UL : crc >> 1;
        }
        crc_table[i] = crc;
    }
    crc = 0xFFFFFFFFUL;
    while (--len)
    {
        crc = crc_table[(crc ^ *buff++) & 0xFF] ^ (crc >> 8);
    }
    return crc ^ 0xFFFFFFFFUL;
}
 
sockWrapper::sockWrapper(QObject *parent) : QObject(parent)
{
    WSAStart();
}
 
sockWrapper::~sockWrapper()
{
    WSAClean();
}
 
void sockWrapper::saveChannelOpt(QHostAddress sendAddr, QHostAddress listenAddr, quint16 sendPort, quint16 listenPort)
{
    forSend.sin_family = AF_INET;
    forSend.sin_addr.s_addr = htonl(sendAddr.toIPv4Address());
    forSend.sin_port = htons(sendPort);
    forListen.sin_family = AF_INET;
    forListen.sin_addr.s_addr = htonl(listenAddr.toIPv4Address());
    forListen.sin_port = htons(listenPort);
}
 
void sockWrapper::connectTo()
{
    shutdown(sockSend,2);
    sockSend = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
    if (sockSend < 0)
    {
        perror("socket");
        return;
    }
    else
    {
        if (::connect(sockSend,(struct sockaddr*) &forSend, sizeof(forSend)) < 0)
        {
            perror("connect");
        }
        else
        {
            return;
        }
    }
}
 
void sockWrapper::unconnectTo()
{
    shutdown(sockSend,2);
}
 
void sockWrapper::listenTo()
{
    shutdown(sockListen,2);
    sockListen = socket(PF_INET, SOCK_RAW, IPPROTO_UDP);
    if (sockListen < 0)
    {
        perror("socket");
        return;
    }
    else
    {
        if (::bind(sockListen,(struct sockaddr*) &forListen, sizeof(forListen)) < 0)
        {
            perror("bind");
            return;
        }
        else
        {
            sockNotif = new QSocketNotifier(sockListen,QSocketNotifier::Read,this);
            QObject::connect(sockNotif, &QSocketNotifier::activated, this, &sockWrapper::reciveNewMessage);
            return;
        }
    }
}
 
void sockWrapper::unlistenTo()
{
    shutdown(sockListen,2);
    QObject::disconnect(sockNotif, &QSocketNotifier::activated, this, &sockWrapper::reciveNewMessage);
}
 
void sockWrapper::sendTo(QByteArray data)
{
    ip.version = 4;
    ip.frag_off = 0;
    ip.ttl = 64;
    ip.protocol = IPPROTO_UDP;
    ip.saddr = forListen.sin_addr.s_addr;
    ip.daddr = forSend.sin_addr.s_addr;
    ip.tos = 10;
    ip.tot_len = sizeof(iphdr) + sizeof(udphdr) + data.size();
    ip.ihl = 5;
    ip.check = crc32(data.data(),data.size());
    udp.len = htons(sizeof(udphdr) + data.size());
    udp.dest = forSend.sin_port;
    udp.source = forListen.sin_port;
    udp.check = 1;
    char Packet[ip.tot_len];
    uint lastPos = 0;
    for (uint i = 0; i < sizeof(ip); ++i)
    {
        Packet[lastPos] = (*((char*)(&ip)+i));
        ++lastPos;
    }
    for (uint i = 0; i < sizeof(udp); ++i)
    {
        Packet[lastPos] = (*((char*)(&udp)+i));
        ++lastPos;
    }
    for (uint i = 0; i < data.size(); ++i)
    {
        Packet[lastPos] = data.at(i);
        ++lastPos;
    }
    int one = 1;
    const int *val = &one;
    if (::setsockopt(sockSend,IPPROTO_IP,IP_HDRINCL,(char*)val,sizeof(one)) < 0)
    {
        perror("setsockopt");
    }
    else
    {
        if (::sendto(sockSend, Packet, ip.tot_len, 0, (struct sockaddr *) &forSend, sizeof(forSend)) < 0)
        {
            perror("sendto");
            return;
        }
    }
    QByteArray test;
    test.append("Message send");
    emit newMessage(test);
 
}
 
void sockWrapper::WSAStart()
{
 
    if (WSAStartup(MAKEWORD(2, 2), &wData) == 0)
    {
        QMessageBox::information(NULL,"WSA","WSA success");
    }
}
 
void sockWrapper::WSAClean()
{
    WSACleanup();
}
 
void sockWrapper::reciveNewMessage()
{
    char dataBuffer[4096];
    ssize_t bytesNumber = 0;
    QByteArray result;
    int size = sizeof(forListen);
    if ((bytesNumber = ::recvfrom(sockListen, dataBuffer ,4096 ,0 ,(sockaddr*)&forListen, &size)) < 0)
    {
        perror("recv");
        return;
    }
    else
    {
        result.append(dataBuffer,bytesNumber);
        emit newMessage(result);
    }
}

#ifndef LIBS_H
#define LIBS_H
 
///Для сокетов
#include <winsock2.h>
#include <ws2tcpip.h> // для IP_HDRINCL
#include <QSocketNotifier>
#include <QHostAddress>
///Общее
#include <QByteArray>
#include <QMessageBox>
#include <QDebug>
 
 
#endif // LIBS_H

QT       += core gui network
 
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
CONFIG += c++11
 
DEFINES += QT_DEPRECATED_WARNINGS
 
SOURCES += \
    main.cpp \
    fmMain.cpp \
    sockWrapper.cpp
 
HEADERS += \
    Libs.h \
    fmMain.h \
    sockWrapper.h
 
FORMS += \
    fmMain.ui
 
# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target
 
LIBS += -lws2_32

ip.check = crc32(data.data(),data.size());

ip.check = ip_fast_csum(&ip, ip.ihl);