Multicast über WLAN empfangen

[Max G. (l0wside)]

Für eine Anwendung (auf Basis von KNXNet/IP) versuche ich, Multicast 
über WLAN zu empfangen. Aktuell verwende ich einen kommerziellen Treiber 
(Falcon), mit dem das auch prima funktioniert. Aus Lizenzgründen muss 
ich den aber durch eine eigene Lösung ersetzen.

Ich verwende Qt und habe das Beispiel 
http://doc.qt.io/qt-5/qtnetwork-multicastreceiver-example.html 
verwendet.

Mein Problem ist nun: die Multicast-Pakete kommen an, wenn der 
kommerzielle Treiber parallel aktiv ist. Ist er nicht aktiv, kommen sie 
nicht an. Auch im Wireshark sind sie nicht zu sehen.

Irgendwo fehlt hier eine Zutat zur Secret Sauce, aber welche? Was macht 
der kommerzielle Treiber anders? Google lieferte nur, dass man bind() 
und joinMulticastGroup() braucht, aber das ist ja drin. Die IP-Adresse 
ist natürlich angepasst. Der bind() geht auch auf das richtige 
Netzwerk-Interface, da habe ich den Code angepasst.

Max

Setup: Der Multicast-Sender hängt am Ethernet, Switch ist ein 
ungemanagter Netgear, Access Point ist ein Unifi.

[max (Gast)]

vielleicht aktiviert der treiber den promiscuous mode?

[Peter II (Gast)]

WLAN und Multicast sind sehr speziell. Da alles Clients die Nachricht 
empfangen müssen, darf die Nachricht nur mit einer sehr geringen 
Bandbreite gesendet werden ( ich glaube sogar weniger als 11Mbit). Das 
wiederum führ bei vielen Nachrichten dafür das die "Luft" sehr voll ist. 
Also der Datendurchsatz sinkt extrem auch für anderen Teilnehmer

Es gibt einige AP die wandeln Multicast in Unicast um, um das Problem zu 
umgehen.

[Max G. (l0wside)]

@max: Das klingt plausibel. Allerdings irritiert mich, dass die Pakete 
im Wireshark auch nicht auftauchen - der müsste doch als erstes den 
promiscuous mode aktivieren, um überhaupt mitlesen zu können.

@Peter II: Bandbreite ist nicht das Thema, wir reden über einzelne 
Nachrichten von je 17 Byte Länge. Es werden auch nicht einzelne 
verschluckt, sondern es taucht gar nichts auf.

[temp (Gast)]

Mich hat ein Problem mit Multicasts unter W10 letzte Woche auch zur 
Weißglut gebracht. Verursacher war der Virtualbox-Host Only Netzwerk 
Adapter. Der wird meistens mit Installiert. Wenn man VMs im Bridge-Mode 
betreibt braucht man den aber nicht. Wohlgemerkt es geht nicht um 
Multicasts in VMs. Allein das Vorhandensein dieses Treibers verhinderte 
dass W10 Multicast-Packete empfangen konnte. Meine Tests dazu liefen 
unter nodejs. Ziel war das Absetzen von Multicast-Packeten von eiem 
ESP32 aus.

[Max G. (l0wside)]

Guter Hinweis, ich habe tatsächlich auch den VirtualBox-Adapter unter 
Windows 10. Ich werfe ihn mal runter, auf der schwachbrüstigen Kiste 
läuft VirtualBox sowieso nicht.
Seltsam ist es trotzdem, mit dem Falcon-Treiber geht es ja.

[temp (Gast)]

Deaktivieren hat bei mir gereicht.

[Max G. (l0wside)]

Das hat bei mir tatsächlich auch geholfen. Verstehe das, wer will.

Vielen Dank für den Tipp!

Max

[Alex W. (a20q90)]

Und was macht der Treiber jetzt? Deaktiviert er den VB-Adapter?

[Max G. (l0wside)]

Das manuelle Deaktivieren hat geholfen. Wobei das Deaktivieren nicht der 
Punkt war, es geht auch anders. Wichtig war, joinMulticastGroup() nicht 
auf dem VM-Adapter auszuführen.

KNXNet/IP-spezifisch: geplant ist, erst das Gateway zu suchen (dafür 
muss man der Multicast Group nicht beitreten, weil man es zwar per 
Multicast anspricht, die Antwort dann aber über direkt adressiertes UDP 
kommt). Auf den Interfaces, auf denen eine Antwort kam, wird dann 
Multicast aktiviert.

Die Lösung ist eher hässlich, aber wenn sie funktioniert...

Aktueller Code (noch ohne den geplanten Teil, sondern einfach WLAN hart 
eincodiert) anbei. Schönheit war kein Kriterium beim Schreiben.
main.cpp

#include "mainwindow.h"
#include <QApplication>
#include <QUdpSocket>
#include <QNetworkInterface>
#include <QList>
#include <QDebug>
#include <QThread>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;

    QList<QNetworkInterface> mListIfaces = QNetworkInterface::allInterfaces();
    QHostAddress groupAddress = QHostAddress("224.0.23.12");

    for (QList<QNetworkInterface>::iterator iter_if = mListIfaces.begin(); iter_if != mListIfaces.end(); iter_if++) {
       qDebug() << "======" << iter_if->humanReadableName();// << (mListIfaces.at(i).flags() & QNetworkInterface::CanMulticast) << (mListIfaces.at(i).flags() & QNetworkInterface::IsLoopBack << mListIfaces.at(i).isValid()?"ja":"nein");
        if ((iter_if->flags() & QNetworkInterface::CanMulticast) == 0) {
            continue;
        }
        if ((iter_if->flags() & QNetworkInterface::IsLoopBack) > 0) {
            continue;
        }

        QList<QNetworkAddressEntry> ha_all = iter_if->addressEntries();
        for (QList<QNetworkAddressEntry>::iterator ha_iter = ha_all.begin(); ha_iter != ha_all.end(); ha_iter++) {
            if (ha_iter->ip().protocol() != QAbstractSocket::NetworkLayerProtocol::IPv4Protocol) {
                continue;
            }
            qDebug() << ha_iter->ip().toString();

            QUdpSocket *sock_rx;
            sock_rx = new QUdpSocket();
            bool rez = sock_rx->bind(ha_iter->ip(), 3671, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint);

            qDebug() << "bind" << rez;
            if (!rez) {
                continue;
            }
            if (iter_if->humanReadableName() != "WLAN") {
                continue;
            }
            rez = sock_rx->joinMulticastGroup(groupAddress, *iter_if);
            QObject::connect(sock_rx,SIGNAL(channelReadyRead(int)),&w,SLOT(onUdpRx(int)));
            QUdpSocket *sock_tx = new QUdpSocket();
            sock_tx->bind(ha_iter->ip());
            QByteArray ss = QByteArrayLiteral("\x06\x10\x02\x01\x00\x0e\x08\x01");
            uint32_t ip = ha_iter->ip().toIPv4Address();
            ss.append((unsigned char)((ip >> 24) & 0xFF));
            ss.append((unsigned char)((ip >> 16) & 0xFF));
            ss.append((unsigned char)((ip >> 8) & 0xFF));
            ss.append((unsigned char)(ip & 0xFF));
            ss.append((uint8_t)((sock_rx->localPort() >> 8) & 0xFF));
            ss.append((uint8_t)((sock_rx->localPort()) & 0xFF));
            sock_tx->writeDatagram((const char*)ss.data(),ss.length(),QHostAddress("224.0.23.12"),3671);

            qDebug() << iter_if->humanReadableName() << rez << sock_rx->errorString();
        }
    }

    w.show();

    return a.exec();
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

public slots:
    void onUdpRx(int);

private:
    Ui::MainWindow *ui;
};


#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QUdpSocket>
#include <QNetworkDatagram>


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::onUdpRx(int len) {
    printf("RX %i\n",len); fflush(stdout);
    QUdpSocket *sock = (QUdpSocket*)(QObject::sender());
    qDebug() << "avail" << sock->bytesAvailable() << sock->hasPendingDatagrams();
    QNetworkDatagram dg = sock->receiveDatagram();
    QByteArray data = dg.data().toHex();
    ui->bla->append(dg.senderAddress().toString()+":"+QString::number(dg.senderPort())+" ");
    ui->bla->append(dg.destinationAddress().toString()+":"+QString::number(dg.destinationPort())+" ");
    ui->bla->append(data);

    qDebug() << data;
    ui->bla->append("\n");
}