Merge branch 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-1 into master-integration

* 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-1: (28 commits)
  Don't ignore interfaces that cannot multicast when querying the mcast iface
  Fix IPv6 support on Windows
  test that joining invalid group fails, make test data names more verbose
  Fix IPv6 multicast on UNIX
  Test IPv6 multicast
  Add QUdpSocket::setMulticastInterface() and ::multicastInterface()
  Improve multicast test
  add images for multicastsender and multicastreceiver examples
  Add a spinbox to the multicastsender example to change the datagram's TTL
  Add multicastsender and multicastreceiver examples
  Update QUdpSocket's overview docs to include multicast references
  Initial documentation for multicast socket options and API
  Rename doMulticast() to multicastMembershipHelper()
  Don't use WSAIoctl() to get/set the multicast socket options
  Add MulticastTtlOption and MulticastLoopbackOption to QAbstractSocket
  Implement UDP multicast on Windows
  Remove support for single-source multi-cast
  Make ASM work on systems without SSM support
  Set multicast errors correctly
  Don't crash when trying to join/leave a group with not bound
  ...

30 files changed, 1531 insertions, 12 deletions

diff --git a/doc/src/examples/multicastreceiver.qdoc b/doc/src/examples/multicastreceiver.qdoc
new file mode 100644
index 0000000..f769705
--- /dev/null
+++ b/doc/src/examples/multicastreceiver.qdoc
@@ -0,0 +1,36 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in a
+** written agreement between you and Nokia.
+**
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example network/multicastreceiver
+    \title Multicast Receiver Example
+
+    The Multicast Receiever example shows how to receive information that is
+    sent to a multicast group.
+
+    \image multicastreceiver-example.png
+*/
diff --git a/doc/src/examples/multicastsender.qdoc b/doc/src/examples/multicastsender.qdoc
new file mode 100644
index 0000000..271be60
--- /dev/null
+++ b/doc/src/examples/multicastsender.qdoc
@@ -0,0 +1,36 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in a
+** written agreement between you and Nokia.
+**
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example network/multicastsender
+    \title Multicast Sender Example
+
+    The Multicast Sender example shows how to send information to multiple
+    clients in a multicast group.
+
+    \image multicastsender-example.png
+*/
diff --git a/doc/src/getting-started/examples.qdoc b/doc/src/getting-started/examples.qdoc
index e8c85e6..f849bf0 100644
--- a/doc/src/getting-started/examples.qdoc
+++ b/doc/src/getting-started/examples.qdoc
@@ -473,6 +473,8 @@
     \o  \l{network/bearercloud}{Bearer Cloud}\raisedaster
     \o  \l{network/bearermonitor}{Bearer Monitor}
     \o  \l{network/securesocketclient}{Secure Socket Client}
+    \o  \l{network/multicastreceiver}{Multicast Receiver}
+    \o  \l{network/multicastsender}{Multicast Sender}
     \endlist
 
     Examples marked with an asterisk (*) are fully documented.
diff --git a/doc/src/images/multicastreceiver-example.png b/doc/src/images/multicastreceiver-example.png
new file mode 100644
index 0000000..8de11cd
--- /dev/null
+++ b/doc/src/images/multicastreceiver-example.png
diff --git a/doc/src/images/multicastsender-example.png b/doc/src/images/multicastsender-example.png
new file mode 100644
index 0000000..a619b04
--- /dev/null
+++ b/doc/src/images/multicastsender-example.png
diff --git a/doc/src/network-programming/qtnetwork.qdoc b/doc/src/network-programming/qtnetwork.qdoc
index dcee1b8..fce12a7 100644
--- a/doc/src/network-programming/qtnetwork.qdoc
+++ b/doc/src/network-programming/qtnetwork.qdoc
@@ -257,8 +257,13 @@
     QUdpSocket::readDatagram() to read the datagram.
 
     The \l{network/broadcastsender}{Broadcast Sender} and
-    \l{network/broadcastreceiver}{Broadcast Receiver} examples show
-    how to write a UDP sender and a UDP receiver using Qt.
+    \l{network/broadcastreceiver}{Broadcast Receiver} examples show how to
+    write a UDP sender and a UDP receiver using Qt.
+
+    QUdpSocket also supports multicasting. The
+    \l{network/multicastsender}{Multicast Sender} and
+    \l{network/multicastreceiver}{Multicast Receiver} examples show how to use
+    write UDP multicast clients.
 
     \section1 Resolving Host Names using QHostInfo
 
diff --git a/examples/network/multicastreceiver/main.cpp b/examples/network/multicastreceiver/main.cpp
new file mode 100644
index 0000000..8483271
--- /dev/null
+++ b/examples/network/multicastreceiver/main.cpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QApplication>
+
+#include "receiver.h"
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    Receiver receiver;
+    receiver.show();
+    return receiver.exec();
+}
diff --git a/examples/network/multicastreceiver/multicastreceiver.pro b/examples/network/multicastreceiver/multicastreceiver.pro
new file mode 100644
index 0000000..400c92e
--- /dev/null
+++ b/examples/network/multicastreceiver/multicastreceiver.pro
@@ -0,0 +1,12 @@
+HEADERS       = receiver.h
+SOURCES       = receiver.cpp \
+                main.cpp
+QT           += network
+
+# install
+target.path = $$[QT_INSTALL_EXAMPLES]/network/multicastreceiver
+sources.files = $$SOURCES $$HEADERS $$RESOURCES $$FORMS multicastreceiver.pro
+sources.path = $$[QT_INSTALL_EXAMPLES]/network/multicastreceiver
+INSTALLS += target sources
+
+symbian: include($$QT_SOURCE_TREE/examples/symbianpkgrules.pri)
diff --git a/examples/network/multicastreceiver/receiver.cpp b/examples/network/multicastreceiver/receiver.cpp
new file mode 100644
index 0000000..073fdce
--- /dev/null
+++ b/examples/network/multicastreceiver/receiver.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui>
+#include <QtNetwork>
+
+#include "receiver.h"
+
+Receiver::Receiver(QWidget *parent)
+    : QDialog(parent)
+{
+    groupAddress = QHostAddress("239.255.43.21");
+
+    statusLabel = new QLabel(tr("Listening for multicasted messages"));
+    quitButton = new QPushButton(tr("&Quit"));
+
+    udpSocket = new QUdpSocket(this);
+    udpSocket->bind(45454, QUdpSocket::ShareAddress);
+    udpSocket->joinMulticastGroup(groupAddress);
+
+    connect(udpSocket, SIGNAL(readyRead()),
+            this, SLOT(processPendingDatagrams()));
+    connect(quitButton, SIGNAL(clicked()), this, SLOT(close()));
+
+    QHBoxLayout *buttonLayout = new QHBoxLayout;
+    buttonLayout->addStretch(1);
+    buttonLayout->addWidget(quitButton);
+    buttonLayout->addStretch(1);
+
+    QVBoxLayout *mainLayout = new QVBoxLayout;
+    mainLayout->addWidget(statusLabel);
+    mainLayout->addLayout(buttonLayout);
+    setLayout(mainLayout);
+
+    setWindowTitle(tr("Multicast Receiver"));
+}
+
+void Receiver::processPendingDatagrams()
+{
+    while (udpSocket->hasPendingDatagrams()) {
+        QByteArray datagram;
+        datagram.resize(udpSocket->pendingDatagramSize());
+        udpSocket->readDatagram(datagram.data(), datagram.size());
+        statusLabel->setText(tr("Received datagram: \"%1\"")
+                             .arg(datagram.data()));
+    }
+}
diff --git a/examples/network/multicastreceiver/receiver.h b/examples/network/multicastreceiver/receiver.h
new file mode 100644
index 0000000..e226028
--- /dev/null
+++ b/examples/network/multicastreceiver/receiver.h
@@ -0,0 +1,70 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef RECEIVER_H
+#define RECEIVER_H
+
+#include <QDialog>
+#include <QHostAddress>
+
+QT_BEGIN_NAMESPACE
+class QLabel;
+class QPushButton;
+class QUdpSocket;
+QT_END_NAMESPACE
+
+class Receiver : public QDialog
+{
+    Q_OBJECT
+
+public:
+    Receiver(QWidget *parent = 0);
+
+private slots:
+    void processPendingDatagrams();
+
+private:
+    QLabel *statusLabel;
+    QPushButton *quitButton;
+    QUdpSocket *udpSocket;
+    QHostAddress groupAddress;
+};
+
+#endif
diff --git a/examples/network/multicastsender/main.cpp b/examples/network/multicastsender/main.cpp
new file mode 100644
index 0000000..9309322
--- /dev/null
+++ b/examples/network/multicastsender/main.cpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QApplication>
+
+#include "sender.h"
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    Sender sender;
+    sender.show();
+    return sender.exec();
+}
diff --git a/examples/network/multicastsender/multicastsender.pro b/examples/network/multicastsender/multicastsender.pro
new file mode 100644
index 0000000..7543f00
--- /dev/null
+++ b/examples/network/multicastsender/multicastsender.pro
@@ -0,0 +1,12 @@
+HEADERS       = sender.h
+SOURCES       = sender.cpp \
+                main.cpp
+QT           += network
+
+# install
+target.path = $$[QT_INSTALL_EXAMPLES]/network/multicastsender
+sources.files = $$SOURCES $$HEADERS $$RESOURCES $$FORMS multicastsender.pro
+sources.path = $$[QT_INSTALL_EXAMPLES]/network/multicastsender
+INSTALLS += target sources
+
+symbian: include($$QT_SOURCE_TREE/examples/symbianpkgrules.pri)
diff --git a/examples/network/multicastsender/sender.cpp b/examples/network/multicastsender/sender.cpp
new file mode 100644
index 0000000..7fa9750
--- /dev/null
+++ b/examples/network/multicastsender/sender.cpp
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui>
+#include <QtNetwork>
+
+#include "sender.h"
+
+Sender::Sender(QWidget *parent)
+    : QDialog(parent)
+{
+    groupAddress = QHostAddress("239.255.43.21");
+
+    statusLabel = new QLabel(tr("Ready to multicast datagrams to group %1 on port 45454").arg(groupAddress.toString()));
+
+    ttlLabel = new QLabel(tr("TTL for multicast datagrams:"));
+    ttlSpinBox = new QSpinBox;
+    ttlSpinBox->setRange(0, 255);
+
+    QHBoxLayout *ttlLayout = new QHBoxLayout;
+    ttlLayout->addWidget(ttlLabel);
+    ttlLayout->addWidget(ttlSpinBox);
+
+    startButton = new QPushButton(tr("&Start"));
+    quitButton = new QPushButton(tr("&Quit"));
+
+    buttonBox = new QDialogButtonBox;
+    buttonBox->addButton(startButton, QDialogButtonBox::ActionRole);
+    buttonBox->addButton(quitButton, QDialogButtonBox::RejectRole);
+
+    timer = new QTimer(this);
+    udpSocket = new QUdpSocket(this);
+    messageNo = 1;
+
+    connect(ttlSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ttlChanged(int)));
+    connect(startButton, SIGNAL(clicked()), this, SLOT(startSending()));
+    connect(quitButton, SIGNAL(clicked()), this, SLOT(close()));
+    connect(timer, SIGNAL(timeout()), this, SLOT(sendDatagram()));
+
+    QVBoxLayout *mainLayout = new QVBoxLayout;
+    mainLayout->addWidget(statusLabel);
+    mainLayout->addLayout(ttlLayout);
+    mainLayout->addWidget(buttonBox);
+    setLayout(mainLayout);
+
+    setWindowTitle(tr("Multicast Sender"));
+    ttlSpinBox->setValue(1);
+}
+
+void Sender::ttlChanged(int newTtl)
+{
+    udpSocket->setSocketOption(QAbstractSocket::MulticastTtlOption, newTtl);
+}
+
+void Sender::startSending()
+{
+    startButton->setEnabled(false);
+    timer->start(1000);
+}
+
+void Sender::sendDatagram()
+{
+    statusLabel->setText(tr("Now sending datagram %1").arg(messageNo));
+    QByteArray datagram = "Multicast message " + QByteArray::number(messageNo);
+    udpSocket->writeDatagram(datagram.data(), datagram.size(),
+                             groupAddress, 45454);
+    ++messageNo;
+}
diff --git a/examples/network/multicastsender/sender.h b/examples/network/multicastsender/sender.h
new file mode 100644
index 0000000..f119883
--- /dev/null
+++ b/examples/network/multicastsender/sender.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+**     the names of its contributors may be used to endorse or promote
+**     products derived from this software without specific prior written
+**     permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SENDER_H
+#define SENDER_H
+
+#include <QDialog>
+#include <QHostAddress>
+
+QT_BEGIN_NAMESPACE
+class QDialogButtonBox;
+class QLabel;
+class QPushButton;
+class QTimer;
+class QUdpSocket;
+class QSpinBox;
+QT_END_NAMESPACE
+
+class Sender : public QDialog
+{
+    Q_OBJECT
+
+public:
+    Sender(QWidget *parent = 0);
+
+private slots:
+    void ttlChanged(int newTtl);
+    void startSending();
+    void sendDatagram();
+
+private:
+    QLabel *statusLabel;
+    QLabel *ttlLabel;
+    QSpinBox *ttlSpinBox;
+    QPushButton *startButton;
+    QPushButton *quitButton;
+    QDialogButtonBox *buttonBox;
+    QUdpSocket *udpSocket;
+    QTimer *timer;
+    QHostAddress groupAddress;
+    int messageNo;
+};
+
+#endif
diff --git a/examples/network/network.pro b/examples/network/network.pro
index 458561a..0012a97 100644
--- a/examples/network/network.pro
+++ b/examples/network/network.pro
@@ -16,7 +16,9 @@ SUBDIRS       = \
                 threadedfortuneserver \
                 googlesuggest \
                 torrent \
-                bearermonitor
+                bearermonitor \
+                multicastreceiver \
+                multicastsender
 
     contains(QT_CONFIG, svg) {
         SUBDIRS += bearercloud
diff --git a/src/gui/widgets/qtoolbutton.cpp b/src/gui/widgets/qtoolbutton.cpp
index 1822db8..c18f660 100644
--- a/src/gui/widgets/qtoolbutton.cpp
+++ b/src/gui/widgets/qtoolbutton.cpp
@@ -394,9 +394,6 @@ void QToolButton::initStyleOption(QStyleOptionToolButton *option) const
             option->toolButtonStyle = Qt::ToolButtonTextOnly;
         else if (option->toolButtonStyle != Qt::ToolButtonTextOnly)
             option->toolButtonStyle = Qt::ToolButtonIconOnly;
-    } else {
-        if (d->text.isEmpty() && option->toolButtonStyle != Qt::ToolButtonIconOnly)
-            option->toolButtonStyle = Qt::ToolButtonIconOnly;
     }
 
     option->pos = pos();
diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
index 3218662..66cdffb 100644
--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
@@ -356,6 +356,10 @@
     to enable.
     \value KeepAliveOption Set this to 1 to enable the SO_KEEPALIVE socket option
 
+    \value MulticastTtlOption Set this to an integer value to set IP_MULTICAST_TTL (TTL for multicast datagrams) socket option.
+
+    \value MulticastLoopbackOption Set this to 1 to enable the IP_MULTICAST_LOOP (multicast loopback) socket option.
+
     \sa QAbstractSocket::setSocketOption(), QAbstractSocket::socketOption()
 */
 
@@ -1627,6 +1631,14 @@ void QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, cons
         case KeepAliveOption:
             d_func()->socketEngine->setOption(QAbstractSocketEngine::KeepAliveOption, value.toInt());
             break;
+
+        case MulticastTtlOption:
+                d_func()->socketEngine->setOption(QAbstractSocketEngine::MulticastTtlOption, value.toInt());
+                break;
+
+        case MulticastLoopbackOption:
+                d_func()->socketEngine->setOption(QAbstractSocketEngine::MulticastLoopbackOption, value.toInt());
+                break;
     }
 }
 
@@ -1656,6 +1668,13 @@ QVariant QAbstractSocket::socketOption(QAbstractSocket::SocketOption option)
         case KeepAliveOption:
             ret = d_func()->socketEngine->option(QAbstractSocketEngine::KeepAliveOption);
             break;
+
+        case MulticastTtlOption:
+                ret = d_func()->socketEngine->option(QAbstractSocketEngine::MulticastTtlOption);
+                break;
+        case MulticastLoopbackOption:
+                ret = d_func()->socketEngine->option(QAbstractSocketEngine::MulticastLoopbackOption);
+                break;
     }
     if (ret == -1)
         return QVariant();
diff --git a/src/network/socket/qabstractsocket.h b/src/network/socket/qabstractsocket.h
index 9e487d2..f610db3 100644
--- a/src/network/socket/qabstractsocket.h
+++ b/src/network/socket/qabstractsocket.h
@@ -118,7 +118,9 @@ public:
     };
     enum SocketOption {
         LowDelayOption, // TCP_NODELAY
-        KeepAliveOption // SO_KEEPALIVE
+        KeepAliveOption, // SO_KEEPALIVE
+        MulticastTtlOption, // IP_MULTICAST_TTL
+        MulticastLoopbackOption // IP_MULTICAST_LOOPBACK
     };
 
     QAbstractSocket(SocketType socketType, QObject *parent);
diff --git a/src/network/socket/qabstractsocketengine_p.h b/src/network/socket/qabstractsocketengine_p.h
index 3669852..ec5fbd3 100644
--- a/src/network/socket/qabstractsocketengine_p.h
+++ b/src/network/socket/qabstractsocketengine_p.h
@@ -61,6 +61,7 @@ QT_BEGIN_NAMESPACE
 
 class QAuthenticator;
 class QAbstractSocketEnginePrivate;
+class QNetworkInterface;
 class QNetworkProxy;
 
 class QAbstractSocketEngineReceiver {
@@ -94,7 +95,9 @@ public:
         BindExclusively,
         ReceiveOutOfBandData,
         LowDelayOption,
-        KeepAliveOption
+        KeepAliveOption,
+        MulticastTtlOption,
+        MulticastLoopbackOption
     };
 
     virtual bool initialize(QAbstractSocket::SocketType type, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::IPv4Protocol) = 0;
@@ -118,6 +121,13 @@ public:
     virtual qint64 write(const char *data, qint64 len) = 0;
 
 #ifndef QT_NO_UDPSOCKET
+    virtual bool joinMulticastGroup(const QHostAddress &groupAddress,
+                                    const QNetworkInterface &iface) = 0;
+    virtual bool leaveMulticastGroup(const QHostAddress &groupAddress,
+                                     const QNetworkInterface &iface) = 0;
+    virtual QNetworkInterface multicastInterface() const = 0;
+    virtual bool setMulticastInterface(const QNetworkInterface &iface) = 0;
+
     virtual qint64 readDatagram(char *data, qint64 maxlen, QHostAddress *addr = 0,
                                 quint16 *port = 0) = 0;
     virtual qint64 writeDatagram(const char *data, qint64 len, const QHostAddress &addr,
diff --git a/src/network/socket/qhttpsocketengine.cpp b/src/network/socket/qhttpsocketengine.cpp
index dfda257..cb0e296 100644
--- a/src/network/socket/qhttpsocketengine.cpp
+++ b/src/network/socket/qhttpsocketengine.cpp
@@ -45,6 +45,7 @@
 #include "qurl.h"
 #include "qhttp.h"
 #include "qelapsedtimer.h"
+#include "qnetworkinterface.h"
 
 #if !defined(QT_NO_NETWORKPROXY) && !defined(QT_NO_HTTP)
 #include <qdebug.h>
@@ -239,6 +240,34 @@ qint64 QHttpSocketEngine::write(const char *data, qint64 len)
 }
 
 #ifndef QT_NO_UDPSOCKET
+bool QHttpSocketEngine::joinMulticastGroup(const QHostAddress &,
+                                           const QNetworkInterface &)
+{
+    setError(QAbstractSocket::UnsupportedSocketOperationError,
+             QLatin1String("Operation on socket is not supported"));
+    return false;
+}
+
+bool QHttpSocketEngine::leaveMulticastGroup(const QHostAddress &,
+                                            const QNetworkInterface &)
+{
+    setError(QAbstractSocket::UnsupportedSocketOperationError,
+             QLatin1String("Operation on socket is not supported"));
+    return false;
+}
+
+QNetworkInterface QHttpSocketEngine::multicastInterface() const
+{
+    return QNetworkInterface();
+}
+
+bool QHttpSocketEngine::setMulticastInterface(const QNetworkInterface &)
+{
+    setError(QAbstractSocket::UnsupportedSocketOperationError,
+             QLatin1String("Operation on socket is not supported"));
+    return false;
+}
+
 qint64 QHttpSocketEngine::readDatagram(char *, qint64, QHostAddress *,
                                        quint16 *)
 {
diff --git a/src/network/socket/qhttpsocketengine_p.h b/src/network/socket/qhttpsocketengine_p.h
index 5051def..b68b7117 100644
--- a/src/network/socket/qhttpsocketengine_p.h
+++ b/src/network/socket/qhttpsocketengine_p.h
@@ -102,6 +102,13 @@ public:
     qint64 write(const char *data, qint64 len);
 
 #ifndef QT_NO_UDPSOCKET
+    bool joinMulticastGroup(const QHostAddress &groupAddress,
+                            const QNetworkInterface &interface);
+    bool leaveMulticastGroup(const QHostAddress &groupAddress,
+                             const QNetworkInterface &interface);
+    QNetworkInterface multicastInterface() const;
+    bool setMulticastInterface(const QNetworkInterface &iface);
+
     qint64 readDatagram(char *data, qint64 maxlen, QHostAddress *addr = 0,
         quint16 *port = 0);
     qint64 writeDatagram(const char *data, qint64 len, const QHostAddress &addr,
diff --git a/src/network/socket/qnativesocketengine.cpp b/src/network/socket/qnativesocketengine.cpp
index a169ca0..df73b9c 100644
--- a/src/network/socket/qnativesocketengine.cpp
+++ b/src/network/socket/qnativesocketengine.cpp
@@ -98,6 +98,7 @@
 
 #include <qabstracteventdispatcher.h>
 #include <qsocketnotifier.h>
+#include <qnetworkinterface.h>
 
 #include "qnativesocketengine_p.h"
 #include <private/qthread_p.h>
@@ -647,6 +648,51 @@ int QNativeSocketEngine::accept()
 }
 
 /*!
+    \since 4.8
+*/
+bool QNativeSocketEngine::joinMulticastGroup(const QHostAddress &groupAddress,
+                                             const QNetworkInterface &iface)
+{
+    Q_D(QNativeSocketEngine);
+    Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::joinMulticastGroup(), false);
+    Q_CHECK_STATE(QNativeSocketEngine::joinMulticastGroup(), QAbstractSocket::BoundState, false);
+    Q_CHECK_TYPE(QNativeSocketEngine::joinMulticastGroup(), QAbstractSocket::UdpSocket, false);
+    return d->nativeJoinMulticastGroup(groupAddress, iface);
+}
+
+/*!
+    \since 4.8
+*/
+bool QNativeSocketEngine::leaveMulticastGroup(const QHostAddress &groupAddress,
+                                              const QNetworkInterface &iface)
+{
+    Q_D(QNativeSocketEngine);
+    Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::leaveMulticastGroup(), false);
+    Q_CHECK_STATE(QNativeSocketEngine::leaveMulticastGroup(), QAbstractSocket::BoundState, false);
+    Q_CHECK_TYPE(QNativeSocketEngine::leaveMulticastGroup(), QAbstractSocket::UdpSocket, false);
+    return d->nativeLeaveMulticastGroup(groupAddress, iface);
+}
+
+/*! \since 4.8 */
+QNetworkInterface QNativeSocketEngine::multicastInterface() const
+{
+    Q_D(const QNativeSocketEngine);
+    Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::multicastInterface(), QNetworkInterface());
+    Q_CHECK_TYPE(QNativeSocketEngine::multicastInterface(), QAbstractSocket::UdpSocket, QNetworkInterface());
+    return d->nativeMulticastInterface();
+}
+
+
+/*! \since 4.8 */
+bool QNativeSocketEngine::setMulticastInterface(const QNetworkInterface &iface)
+{
+    Q_D(QNativeSocketEngine);
+    Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::setMulticastInterface(), false);
+    Q_CHECK_TYPE(QNativeSocketEngine::setMulticastInterface(), QAbstractSocket::UdpSocket, false);
+    return d->nativeSetMulticastInterface(iface);
+}
+
+/*!
     Returns the number of bytes that are currently available for
     reading. On error, -1 is returned.
 
diff --git a/src/network/socket/qnativesocketengine_p.h b/src/network/socket/qnativesocketengine_p.h
index eca16f6..9baacf0 100644
--- a/src/network/socket/qnativesocketengine_p.h
+++ b/src/network/socket/qnativesocketengine_p.h
@@ -101,6 +101,7 @@ union qt_sockaddr {
 };
 
 class QNativeSocketEnginePrivate;
+class QNetworkInterface;
 
 class Q_AUTOTEST_EXPORT QNativeSocketEngine : public QAbstractSocketEngine
 {
@@ -123,6 +124,13 @@ public:
     int accept();
     void close();
 
+    bool joinMulticastGroup(const QHostAddress &groupAddress,
+                            const QNetworkInterface &iface);
+    bool leaveMulticastGroup(const QHostAddress &groupAddress,
+                             const QNetworkInterface &iface);
+    QNetworkInterface multicastInterface() const;
+    bool setMulticastInterface(const QNetworkInterface &iface);
+
     qint64 bytesAvailable() const;
 
     qint64 read(char *data, qint64 maxlen);
@@ -237,6 +245,12 @@ public:
     bool nativeBind(const QHostAddress &address, quint16 port);
     bool nativeListen(int backlog);
     int nativeAccept();
+    bool nativeJoinMulticastGroup(const QHostAddress &groupAddress,
+                                  const QNetworkInterface &iface);
+    bool nativeLeaveMulticastGroup(const QHostAddress &groupAddress,
+                                   const QNetworkInterface &iface);
+    QNetworkInterface nativeMulticastInterface() const;
+    bool nativeSetMulticastInterface(const QNetworkInterface &iface);
     qint64 nativeBytesAvailable() const;
 
     bool nativeHasPendingDatagrams() const;
diff --git a/src/network/socket/qnativesocketengine_unix.cpp b/src/network/socket/qnativesocketengine_unix.cpp
index a9f6921..aa55009 100644
--- a/src/network/socket/qnativesocketengine_unix.cpp
+++ b/src/network/socket/qnativesocketengine_unix.cpp
@@ -46,6 +46,7 @@
 #include "qhostaddress.h"
 #include "qelapsedtimer.h"
 #include "qvarlengtharray.h"
+#include "qnetworkinterface.h"
 #include <time.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -247,6 +248,30 @@ int QNativeSocketEnginePrivate::option(QNativeSocketEngine::SocketOption opt) co
     case QNativeSocketEngine::KeepAliveOption:
         n = SO_KEEPALIVE;
         break;
+    case QNativeSocketEngine::MulticastTtlOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_HOPS;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_TTL;
+        }
+        break;
+    case QNativeSocketEngine::MulticastLoopbackOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_LOOP;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_LOOP;
+        }
+        break;
     }
 
     int v = -1;
@@ -330,6 +355,30 @@ bool QNativeSocketEnginePrivate::setOption(QNativeSocketEngine::SocketOption opt
     case QNativeSocketEngine::KeepAliveOption:
         n = SO_KEEPALIVE;
         break;
+    case QNativeSocketEngine::MulticastTtlOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_HOPS;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_TTL;
+        }
+        break;
+    case QNativeSocketEngine::MulticastLoopbackOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_LOOP;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_LOOP;
+        }
+        break;
     }
 
     return ::setsockopt(socketDescriptor, level, n, (char *) &v, sizeof(v)) == 0;
@@ -579,6 +628,171 @@ int QNativeSocketEnginePrivate::nativeAccept()
     return acceptedDescriptor;
 }
 
+
+static bool multicastMembershipHelper(QNativeSocketEnginePrivate *d,
+                                      int how6,
+                                      int how4,
+                                      const QHostAddress &groupAddress,
+                                      const QNetworkInterface &interface)
+{
+    int level = 0;
+    int sockOpt = 0;
+    void *sockArg;
+    int sockArgSize;
+
+    ip_mreq mreq4;
+#ifndef QT_NO_IPV6
+    ipv6_mreq mreq6;
+
+    if (groupAddress.protocol() == QAbstractSocket::IPv6Protocol) {
+        level = IPPROTO_IPV6;
+        sockOpt = how6;
+        sockArg = &mreq6;
+        sockArgSize = sizeof(mreq6);
+        memset(&mreq6, 0, sizeof(mreq6));
+        Q_IPV6ADDR ip6 = groupAddress.toIPv6Address();
+        memcpy(&mreq6.ipv6mr_multiaddr, &ip6, sizeof(ip6));
+        mreq6.ipv6mr_interface = interface.index();
+    } else
+#endif
+    if (groupAddress.protocol() == QAbstractSocket::IPv4Protocol) {
+        level = IPPROTO_IP;
+        sockOpt = how4;
+        sockArg = &mreq4;
+        sockArgSize = sizeof(mreq4);
+        memset(&mreq4, 0, sizeof(mreq4));
+        mreq4.imr_multiaddr.s_addr = htonl(groupAddress.toIPv4Address());
+
+        if (interface.isValid()) {
+            QList<QNetworkAddressEntry> addressEntries = interface.addressEntries();
+            if (!addressEntries.isEmpty()) {
+                QHostAddress firstIP = addressEntries.first().ip();
+                mreq4.imr_interface.s_addr = htonl(firstIP.toIPv4Address());
+            } else {
+                d->setError(QAbstractSocket::NetworkError,
+                            QNativeSocketEnginePrivate::NetworkUnreachableErrorString);
+                return false;
+            }
+        } else {
+            mreq4.imr_interface.s_addr = INADDR_ANY;
+        }
+    } else {
+        // unreachable
+        d->setError(QAbstractSocket::UnsupportedSocketOperationError,
+                    QNativeSocketEnginePrivate::ProtocolUnsupportedErrorString);
+        return false;
+    }
+
+    int res = setsockopt(d->socketDescriptor, level, sockOpt, sockArg, sockArgSize);
+    if (res == -1) {
+        switch (errno) {
+        case ENOPROTOOPT:
+            d->setError(QAbstractSocket::UnsupportedSocketOperationError,
+                        QNativeSocketEnginePrivate::OperationUnsupportedErrorString);
+            break;
+        case EADDRNOTAVAIL:
+            d->setError(QAbstractSocket::SocketAddressNotAvailableError,
+                        QNativeSocketEnginePrivate::AddressNotAvailableErrorString);
+            break;
+        default:
+            d->setError(QAbstractSocket::UnknownSocketError,
+                        QNativeSocketEnginePrivate::UnknownSocketErrorString);
+            break;
+        }
+        return false;
+    }
+    return true;
+}
+
+bool QNativeSocketEnginePrivate::nativeJoinMulticastGroup(const QHostAddress &groupAddress,
+                                                          const QNetworkInterface &interface)
+{
+    return multicastMembershipHelper(this,
+#ifndef QT_NO_IPV6
+                                     IPV6_JOIN_GROUP,
+#else
+                                     0,
+#endif
+                                     IP_ADD_MEMBERSHIP,
+                                     groupAddress,
+                                     interface);
+}
+
+bool QNativeSocketEnginePrivate::nativeLeaveMulticastGroup(const QHostAddress &groupAddress,
+                                                           const QNetworkInterface &interface)
+{
+    return multicastMembershipHelper(this,
+#ifndef QT_NO_IPV6
+                                     IPV6_LEAVE_GROUP,
+#else
+                                     0,
+#endif
+                                     IP_DROP_MEMBERSHIP,
+                                     groupAddress,
+                                     interface);
+}
+
+QNetworkInterface QNativeSocketEnginePrivate::nativeMulticastInterface() const
+{
+#ifndef QT_NO_IPV6
+    if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+        uint v;
+        QT_SOCKOPTLEN_T sizeofv = sizeof(v);
+        if (::getsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_MULTICAST_IF, &v, &sizeofv) == -1)
+            return QNetworkInterface();
+        return QNetworkInterface::interfaceFromIndex(v);
+    }
+#endif
+
+    struct in_addr v = { 0 };
+    QT_SOCKOPTLEN_T sizeofv = sizeof(v);
+    if (::getsockopt(socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, &v, &sizeofv) == -1)
+        return QNetworkInterface();
+    if (v.s_addr != 0 && sizeofv >= sizeof(v)) {
+        QHostAddress ipv4(ntohl(v.s_addr));
+        QList<QNetworkInterface> ifaces = QNetworkInterface::allInterfaces();
+        for (int i = 0; i < ifaces.count(); ++i) {
+            const QNetworkInterface &iface = ifaces.at(i);
+            QList<QNetworkAddressEntry> entries = iface.addressEntries();
+            for (int j = 0; j < entries.count(); ++j) {
+                const QNetworkAddressEntry &entry = entries.at(j);
+                if (entry.ip() == ipv4)
+                    return iface;
+            }
+        }
+    }
+    return QNetworkInterface();
+}
+
+bool QNativeSocketEnginePrivate::nativeSetMulticastInterface(const QNetworkInterface &iface)
+{
+#ifndef QT_NO_IPV6
+    if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+        uint v = iface.index();
+        return (::setsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_MULTICAST_IF, &v, sizeof(v)) != -1);
+    }
+#endif
+
+    struct in_addr v;
+    if (iface.isValid()) {
+        QList<QNetworkAddressEntry> entries = iface.addressEntries();
+        for (int i = 0; i < entries.count(); ++i) {
+            const QNetworkAddressEntry &entry = entries.at(i);
+            const QHostAddress &ip = entry.ip();
+            if (ip.protocol() == QAbstractSocket::IPv4Protocol) {
+                v.s_addr = htonl(ip.toIPv4Address());
+                int r = ::setsockopt(socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, &v, sizeof(v));
+                if (r != -1)
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    v.s_addr = INADDR_ANY;
+    return (::setsockopt(socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, &v, sizeof(v)) != -1);
+}
+
 qint64 QNativeSocketEnginePrivate::nativeBytesAvailable() const
 {
     int nbytes = 0;
diff --git a/src/network/socket/qnativesocketengine_win.cpp b/src/network/socket/qnativesocketengine_win.cpp
index 477ef45..f952cee 100644
--- a/src/network/socket/qnativesocketengine_win.cpp
+++ b/src/network/socket/qnativesocketengine_win.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include <winsock2.h>
+#include <ws2tcpip.h>
 
 #include "qnativesocketengine_p.h"
 
@@ -47,6 +48,7 @@
 #include <qsocketnotifier.h>
 #include <qdebug.h>
 #include <qdatetime.h>
+#include <qnetworkinterface.h>
 
 //#define QNATIVESOCKETENGINE_DEBUG
 #if defined(QNATIVESOCKETENGINE_DEBUG)
@@ -399,6 +401,30 @@ int QNativeSocketEnginePrivate::option(QNativeSocketEngine::SocketOption opt) co
     case QNativeSocketEngine::KeepAliveOption:
         n = SO_KEEPALIVE;
         break;
+    case QNativeSocketEngine::MulticastTtlOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_HOPS;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_TTL;
+        }
+        break;
+    case QNativeSocketEngine::MulticastLoopbackOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_LOOP;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_LOOP;
+        }
+        break;
     }
 
     int v = -1;
@@ -459,6 +485,30 @@ bool QNativeSocketEnginePrivate::setOption(QNativeSocketEngine::SocketOption opt
     case QNativeSocketEngine::KeepAliveOption:
         n = SO_KEEPALIVE;
         break;
+    case QNativeSocketEngine::MulticastTtlOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_HOPS;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_TTL;
+        }
+        break;
+    case QNativeSocketEngine::MulticastLoopbackOption:
+#ifndef QT_NO_IPV6
+        if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+            level = IPPROTO_IPV6;
+            n = IPV6_MULTICAST_LOOP;
+        } else
+#endif
+        {
+            level = IPPROTO_IP;
+            n = IP_MULTICAST_LOOP;
+        }
+        break;
     }
 
     if (::setsockopt(socketDescriptor, level, n, (char*)&v, sizeof(v)) != 0) {
@@ -648,8 +698,24 @@ bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &address, quin
 }
 
 
-bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &address, quint16 port)
+bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &a, quint16 port)
 {
+    QHostAddress address = a;
+    switch (address.protocol()) {
+    case QAbstractSocket::IPv6Protocol:
+        if (address.toIPv6Address()[0] == 0xff) {
+            // binding to a multicast address
+            address = QHostAddress(QHostAddress::AnyIPv6);
+        }
+        break;
+    case QAbstractSocket::IPv4Protocol:
+        if ((address.toIPv4Address() & 0xffff0000) == 0xefff0000) {
+            // binding to a multicast address
+            address = QHostAddress(QHostAddress::Any);
+        }
+        break;
+    }
+
     struct sockaddr_in sockAddrIPv4;
     qt_sockaddr_in6 sockAddrIPv6;
     struct sockaddr *sockAddrPtr = 0;
@@ -747,6 +813,159 @@ int QNativeSocketEnginePrivate::nativeAccept()
     return acceptedDescriptor;
 }
 
+static bool multicastMembershipHelper(QNativeSocketEnginePrivate *d,
+                                      int how6,
+                                      int how4,
+                                      const QHostAddress &groupAddress,
+                                      const QNetworkInterface &iface)
+{
+    int level = 0;
+    int sockOpt = 0;
+    char *sockArg;
+    int sockArgSize;
+
+    struct ip_mreq mreq4;
+#ifndef QT_NO_IPV6
+    struct ipv6_mreq mreq6;
+
+    if (groupAddress.protocol() == QAbstractSocket::IPv6Protocol) {
+        level = IPPROTO_IPV6;
+        sockOpt = how6;
+        sockArg = reinterpret_cast<char *>(&mreq6);
+        sockArgSize = sizeof(mreq6);
+        memset(&mreq6, 0, sizeof(mreq6));
+        Q_IPV6ADDR ip6 = groupAddress.toIPv6Address();
+        memcpy(&mreq6.ipv6mr_multiaddr, &ip6, sizeof(ip6));
+        mreq6.ipv6mr_interface = iface.index();
+    } else
+#endif
+    if (groupAddress.protocol() == QAbstractSocket::IPv4Protocol) {
+        level = IPPROTO_IP;
+        sockOpt = how4;
+        sockArg = reinterpret_cast<char *>(&mreq4);
+        sockArgSize = sizeof(mreq4);
+        memset(&mreq4, 0, sizeof(mreq4));
+        mreq4.imr_multiaddr.s_addr = htonl(groupAddress.toIPv4Address());
+
+        if (iface.isValid()) {
+            QList<QNetworkAddressEntry> addressEntries = iface.addressEntries();
+            if (!addressEntries.isEmpty()) {
+                QHostAddress firstIP = addressEntries.first().ip();
+                mreq4.imr_interface.s_addr = htonl(firstIP.toIPv4Address());
+            } else {
+                d->setError(QAbstractSocket::NetworkError,
+                            QNativeSocketEnginePrivate::NetworkUnreachableErrorString);
+                return false;
+            }
+        } else {
+            mreq4.imr_interface.s_addr = INADDR_ANY;
+        }
+    } else {
+        // unreachable
+        d->setError(QAbstractSocket::UnsupportedSocketOperationError,
+                    QNativeSocketEnginePrivate::ProtocolUnsupportedErrorString);
+        return false;
+    }
+
+    int res = setsockopt(d->socketDescriptor, level, sockOpt, sockArg, sockArgSize);
+    if (res == -1) {
+        d->setError(QAbstractSocket::UnsupportedSocketOperationError,
+                    QNativeSocketEnginePrivate::OperationUnsupportedErrorString);
+        return false;
+    }
+    return true;
+}
+
+bool QNativeSocketEnginePrivate::nativeJoinMulticastGroup(const QHostAddress &groupAddress,
+                                                          const QNetworkInterface &iface)
+{
+    return multicastMembershipHelper(this,
+#ifndef QT_NO_IPV6
+                                     IPV6_JOIN_GROUP,
+#else
+                                     0,
+#endif
+                                     IP_ADD_MEMBERSHIP,
+                                     groupAddress,
+                                     iface);
+}
+
+bool QNativeSocketEnginePrivate::nativeLeaveMulticastGroup(const QHostAddress &groupAddress,
+                                                           const QNetworkInterface &iface)
+{
+    return multicastMembershipHelper(this,
+#ifndef QT_NO_IPV6
+                                     IPV6_LEAVE_GROUP,
+#else
+                                     0,
+#endif
+                                     IP_DROP_MEMBERSHIP,
+                                     groupAddress,
+                                     iface);
+}
+
+QNetworkInterface QNativeSocketEnginePrivate::nativeMulticastInterface() const
+{
+#ifndef QT_NO_IPV6
+    if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+        uint v;
+        QT_SOCKOPTLEN_T sizeofv = sizeof(v);
+        if (::getsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *) &v, &sizeofv) == -1)
+            return QNetworkInterface();
+        return QNetworkInterface::interfaceFromIndex(v);
+    }
+#endif
+
+    struct in_addr v = { 0 };
+    QT_SOCKOPTLEN_T sizeofv = sizeof(v);
+    if (::getsockopt(socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, (char *) &v, &sizeofv) == -1)
+        return QNetworkInterface();
+    if (v.s_addr != 0 && sizeofv >= sizeof(v)) {
+        QHostAddress ipv4(ntohl(v.s_addr));
+        QList<QNetworkInterface> ifaces = QNetworkInterface::allInterfaces();
+        for (int i = 0; i < ifaces.count(); ++i) {
+            const QNetworkInterface &iface = ifaces.at(i);
+            if (!(iface.flags() & QNetworkInterface::CanMulticast))
+                continue;
+            QList<QNetworkAddressEntry> entries = iface.addressEntries();
+            for (int j = 0; j < entries.count(); ++j) {
+                const QNetworkAddressEntry &entry = entries.at(j);
+                if (entry.ip() == ipv4)
+                    return iface;
+            }
+        }
+    }
+    return QNetworkInterface();
+}
+
+bool QNativeSocketEnginePrivate::nativeSetMulticastInterface(const QNetworkInterface &iface)
+{
+#ifndef QT_NO_IPV6
+    if (socketProtocol == QAbstractSocket::IPv6Protocol) {
+        uint v = iface.isValid() ? iface.index() : 0;
+        return (::setsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *) &v, sizeof(v)) != -1);
+    }
+#endif
+
+    struct in_addr v;
+    if (iface.isValid()) {
+        QList<QNetworkAddressEntry> entries = iface.addressEntries();
+        for (int i = 0; i < entries.count(); ++i) {
+            const QNetworkAddressEntry &entry = entries.at(i);
+            const QHostAddress &ip = entry.ip();
+            if (ip.protocol() == QAbstractSocket::IPv4Protocol) {
+                v.s_addr = htonl(ip.toIPv4Address());
+                int r = ::setsockopt(socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, (char *) &v, sizeof(v));
+                if (r != -1)
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    v.s_addr = INADDR_ANY;
+    return (::setsockopt(socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, (char *) &v, sizeof(v)) != -1);
+}
 
 qint64 QNativeSocketEnginePrivate::nativeBytesAvailable() const
 {
diff --git a/src/network/socket/qsocks5socketengine.cpp b/src/network/socket/qsocks5socketengine.cpp
index f68edfe..17cf5b1 100644
--- a/src/network/socket/qsocks5socketengine.cpp
+++ b/src/network/socket/qsocks5socketengine.cpp
@@ -56,6 +56,7 @@
 #include "qurl.h"
 #include "qauthenticator.h"
 #include <qendian.h>
+#include <qnetworkinterface.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -1544,6 +1545,35 @@ qint64 QSocks5SocketEngine::write(const char *data, qint64 len)
 }
 
 #ifndef QT_NO_UDPSOCKET
+bool QSocks5SocketEngine::joinMulticastGroup(const QHostAddress &,
+                                             const QNetworkInterface &)
+{
+    setError(QAbstractSocket::UnsupportedSocketOperationError,
+             QLatin1String("Operation on socket is not supported"));
+    return false;
+}
+
+bool QSocks5SocketEngine::leaveMulticastGroup(const QHostAddress &,
+                                              const QNetworkInterface &)
+{
+    setError(QAbstractSocket::UnsupportedSocketOperationError,
+             QLatin1String("Operation on socket is not supported"));
+    return false;
+}
+
+
+QNetworkInterface QSocks5SocketEngine::multicastInterface() const
+{
+    return QNetworkInterface();
+}
+
+bool QSocks5SocketEngine::setMulticastInterface(const QNetworkInterface &)
+{
+    setError(QAbstractSocket::UnsupportedSocketOperationError,
+             QLatin1String("Operation on socket is not supported"));
+    return false;
+}
+
 qint64 QSocks5SocketEngine::readDatagram(char *data, qint64 maxlen, QHostAddress *addr,
                                         quint16 *port)
 {
diff --git a/src/network/socket/qsocks5socketengine_p.h b/src/network/socket/qsocks5socketengine_p.h
index 3d35b57..06fcad2 100644
--- a/src/network/socket/qsocks5socketengine_p.h
+++ b/src/network/socket/qsocks5socketengine_p.h
@@ -92,6 +92,13 @@ public:
     qint64 write(const char *data, qint64 len);
 
 #ifndef QT_NO_UDPSOCKET
+    bool joinMulticastGroup(const QHostAddress &groupAddress,
+                            const QNetworkInterface &interface);
+    bool leaveMulticastGroup(const QHostAddress &groupAddress,
+                             const QNetworkInterface &interface);
+    QNetworkInterface multicastInterface() const;
+    bool setMulticastInterface(const QNetworkInterface &iface);
+
     qint64 readDatagram(char *data, qint64 maxlen, QHostAddress *addr = 0,
         quint16 *port = 0);
     qint64 writeDatagram(const char *data, qint64 len, const QHostAddress &addr,
diff --git a/src/network/socket/qudpsocket.cpp b/src/network/socket/qudpsocket.cpp
index d5366d3..5d8f4c0 100644
--- a/src/network/socket/qudpsocket.cpp
+++ b/src/network/socket/qudpsocket.cpp
@@ -77,14 +77,23 @@
 
     \snippet doc/src/snippets/code/src_network_socket_qudpsocket.cpp 0
 
+    QUdpSocket also supports UDP multicast. Use joinMulticastGroup() and
+    leaveMulticastGroup() to control group membership, and
+    QAbstractSocket::MulticastTtlOption and
+    QAbstractSocket::MulticastLoopbackOption to set the TTL and loopback socket
+    options. Use setMulticastInterface() to control the outgoing interface for
+    multicast datagrams, and multicastInterface() to query it.
+
     With QUdpSocket, you can also establish a virtual connection to a
     UDP server using connectToHost() and then use read() and write()
     to exchange datagrams without specifying the receiver for each
     datagram.
 
-    The \l{network/broadcastsender}{Broadcast Sender} and
-    \l{network/broadcastreceiver}{Broadcast Receiver} examples
-    illustrate how to use QUdpSocket in applications.
+    The \l{network/broadcastsender}{Broadcast Sender},
+    \l{network/broadcastreceiver}{Broadcast Receiver},
+    \l{network/multicastsender}{Multicast Sender}, and
+    \l{network/multicastreceiver}{Multicast Receiver} examples illustrate how
+    to use QUdpSocket in applications.
 
     \section1 Symbian Platform Security Requirements
 
@@ -145,6 +154,7 @@
 */
 
 #include "qhostaddress.h"
+#include "qnetworkinterface.h"
 #include "qabstractsocket_p.h"
 #include "qudpsocket.h"
 
@@ -329,6 +339,112 @@ bool QUdpSocket::bind(quint16 port, BindMode mode)
 }
 
 /*!
+    \since 4.8
+
+    Joins the the multicast group specified by \a groupAddress on the default
+    interface chosen by the operating system. The socket must be in BoundState,
+    otherwise an error occurs.
+
+    This function returns true if successful; otherwise it returns false
+    and sets the socket error accordingly.
+
+    \sa leaveMulticastGroup()
+*/
+bool QUdpSocket::joinMulticastGroup(const QHostAddress &groupAddress)
+{
+    return joinMulticastGroup(groupAddress, QNetworkInterface());
+}
+
+/*!
+    \since 4.8
+    \overload
+
+    Joins the multicast group address \a groupAddress on the interface \a
+    iface.
+
+    \sa leaveMulticastGroup()
+*/
+bool QUdpSocket::joinMulticastGroup(const QHostAddress &groupAddress,
+                                    const QNetworkInterface &iface)
+{
+    Q_D(QUdpSocket);
+    QT_CHECK_BOUND("QUdpSocket::joinMulticastGroup()", false);
+    return d->socketEngine->joinMulticastGroup(groupAddress, iface);
+}
+
+/*!
+    \since 4.8
+
+    Leaves the multicast group specified by \a groupAddress on the default
+    interface chosen by the operating system. The socket must be in BoundState,
+    otherwise an error occurs.
+
+   This function returns true if successful; otherwise it returns false and
+   sets the socket error accordingly.
+
+   \sa joinMulticastGroup()
+*/
+bool QUdpSocket::leaveMulticastGroup(const QHostAddress &groupAddress)
+{
+    return leaveMulticastGroup(groupAddress, QNetworkInterface());
+}
+
+/*!
+    \since 4.8
+    \overload
+
+    Leaves the multicast group specified by \a groupAddress on the interface \a
+    iface.
+
+    \sa joinMulticastGroup()
+*/
+bool QUdpSocket::leaveMulticastGroup(const QHostAddress &groupAddress,
+                                     const QNetworkInterface &iface)
+{
+    QT_CHECK_BOUND("QUdpSocket::leaveMulticastGroup()", false);
+    return d_func()->socketEngine->leaveMulticastGroup(groupAddress, iface);
+}
+
+/*!
+    \since 4.8
+
+    Returns the interface for the outgoing interface for multicast datagrams.
+    This corresponds to the IP_MULTICAST_IF socket option for IPv4 sockets and
+    the IPV6_MULTICAST_IF socket option for IPv6 sockets. If no interface has
+    been previously set, this function returns an invalid QNetworkInterface.
+    The socket must be in BoundState, otherwise an invalid QNetworkInterface is
+    returned.
+
+    \sa setMulticastInterface()
+*/
+QNetworkInterface QUdpSocket::multicastInterface() const
+{
+    Q_D(const QUdpSocket);
+    QT_CHECK_BOUND("QUdpSocket::multicastInterface()", QNetworkInterface());
+    return d->socketEngine->multicastInterface();
+}
+
+/*!
+    \since 4.8
+
+    Sets the outgoing interface for multicast datagrams to the interface \a
+    iface. This corresponds to the IP_MULTICAST_IF socket option for IPv4
+    sockets and the IPV6_MULTICAST_IF socket option for IPv6 sockets. The
+    socket must be in BoundState, otherwise this function does nothing.
+
+    \sa multicastInterface(), joinMulticastGroup(), leaveMulticastGroup()
+*/
+void QUdpSocket::setMulticastInterface(const QNetworkInterface &iface)
+{
+    Q_D(QUdpSocket);
+    if (!isValid()) {
+        qWarning("QUdpSocket::setMulticastInterface() called on a QUdpSocket when not in QUdpSocket::BoundState");
+        return;
+    }
+    d->socketEngine->setMulticastInterface(iface);
+}
+
+/*!
     Returns true if at least one datagram is waiting to be read;
     otherwise returns false.
 
diff --git a/src/network/socket/qudpsocket.h b/src/network/socket/qudpsocket.h
index f477306..b277d3f 100644
--- a/src/network/socket/qudpsocket.h
+++ b/src/network/socket/qudpsocket.h
@@ -53,6 +53,7 @@ QT_MODULE(Network)
 
 #ifndef QT_NO_UDPSOCKET
 
+class QNetworkInterface;
 class QUdpSocketPrivate;
 
 class Q_NETWORK_EXPORT QUdpSocket : public QAbstractSocket
@@ -76,6 +77,16 @@ public:
     bool bind(quint16 port, BindMode mode);
     // ### Qt 5: Merge the bind functions
 
+    bool joinMulticastGroup(const QHostAddress &groupAddress);
+    bool joinMulticastGroup(const QHostAddress &groupAddress,
+                            const QNetworkInterface &iface);
+    bool leaveMulticastGroup(const QHostAddress &groupAddress);
+    bool leaveMulticastGroup(const QHostAddress &groupAddress,
+                             const QNetworkInterface &iface);
+
+    QNetworkInterface multicastInterface() const;
+    void setMulticastInterface(const QNetworkInterface &iface);
+
     bool hasPendingDatagrams() const;
     qint64 pendingDatagramSize() const;
     qint64 readDatagram(char *data, qint64 maxlen, QHostAddress *host = 0, quint16 *port = 0);
diff --git a/tests/auto/qudpsocket/tst_qudpsocket.cpp b/tests/auto/qudpsocket/tst_qudpsocket.cpp
index abed55c..32fab6b 100644
--- a/tests/auto/qudpsocket/tst_qudpsocket.cpp
+++ b/tests/auto/qudpsocket/tst_qudpsocket.cpp
@@ -50,11 +50,13 @@
 #include <qhostinfo.h>
 #include <qmap.h>
 #include <QNetworkProxy>
+#include <QNetworkInterface>
 
 #include <qstringlist.h>
 #include "../network-settings.h"
 
 Q_DECLARE_METATYPE(QHostAddress)
+Q_DECLARE_METATYPE(QNetworkInterface)
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -94,6 +96,18 @@ private slots:
     void outOfProcessConnectedClientServerTest();
     void outOfProcessUnconnectedClientServerTest();
     void zeroLengthDatagram();
+    void multicastTtlOption_data();
+    void multicastTtlOption();
+    void multicastLoopbackOption_data();
+    void multicastLoopbackOption();
+    void multicastJoinBeforeBind_data();
+    void multicastJoinBeforeBind();
+    void multicastLeaveAfterClose_data();
+    void multicastLeaveAfterClose();
+    void setMulticastInterface_data();
+    void setMulticastInterface();
+    void multicast_data();
+    void multicast();
 
 protected slots:
     void empty_readyReadSlot();
@@ -844,5 +858,242 @@ void tst_QUdpSocket::zeroLengthDatagram()
     QCOMPARE(receiver.readDatagram(&buf, 1), qint64(0));
 }
 
+void tst_QUdpSocket::multicastTtlOption_data()
+{
+    QTest::addColumn<QHostAddress>("bindAddress");
+    QTest::addColumn<int>("ttl");
+    QTest::addColumn<int>("expected");
+
+    QList<QHostAddress> addresses;
+    addresses += QHostAddress(QHostAddress::Any);
+    addresses += QHostAddress(QHostAddress::AnyIPv6);
+
+    foreach (const QHostAddress &address, addresses) {
+        QTest::newRow(QString("%1 0").arg(address.toString()).toAscii()) << address << 0 << 0;
+        QTest::newRow(QString("%1 1").arg(address.toString()).toAscii()) << address << 1 << 1;
+        QTest::newRow(QString("%1 2").arg(address.toString()).toAscii()) << address << 2 << 2;
+        QTest::newRow(QString("%1 128").arg(address.toString()).toAscii()) << address << 128 << 128;
+        QTest::newRow(QString("%1 255").arg(address.toString()).toAscii()) << address << 255 << 255;
+        QTest::newRow(QString("%1 1024").arg(address.toString()).toAscii()) << address << 1024 << 1;
+    }
+}
+
+void tst_QUdpSocket::multicastTtlOption()
+{
+    QFETCH_GLOBAL(bool, setProxy);
+    QFETCH(QHostAddress, bindAddress);
+    QFETCH(int, ttl);
+    QFETCH(int, expected);
+    if (setProxy) {
+        // UDP multicast does not work with proxies
+        expected = 0;
+    }
+
+    QUdpSocket udpSocket;
+    // bind, but ignore the result, we are only interested in initializing the socket
+    (void) udpSocket.bind(bindAddress, 0);
+    udpSocket.setSocketOption(QUdpSocket::MulticastTtlOption, ttl);
+    QCOMPARE(udpSocket.socketOption(QUdpSocket::MulticastTtlOption).toInt(), expected);
+}
+
+void tst_QUdpSocket::multicastLoopbackOption_data()
+{
+    QTest::addColumn<QHostAddress>("bindAddress");
+    QTest::addColumn<int>("loopback");
+    QTest::addColumn<int>("expected");
+
+    QList<QHostAddress> addresses;
+    addresses += QHostAddress(QHostAddress::Any);
+    addresses += QHostAddress(QHostAddress::AnyIPv6);
+
+    foreach (const QHostAddress &address, addresses) {
+        QTest::newRow(QString("%1 0").arg(address.toString()).toAscii()) << address << 0 << 0;
+        QTest::newRow(QString("%1 1").arg(address.toString()).toAscii()) << address << 1 << 1;
+        QTest::newRow(QString("%1 2").arg(address.toString()).toAscii()) << address << 2 << 1;
+        QTest::newRow(QString("%1 0 again").arg(address.toString()).toAscii()) << address << 0 << 0;
+        QTest::newRow(QString("%1 2 again").arg(address.toString()).toAscii()) << address << 2 << 1;
+        QTest::newRow(QString("%1 0 last time").arg(address.toString()).toAscii()) << address << 0 << 0;
+        QTest::newRow(QString("%1 1 again").arg(address.toString()).toAscii()) << address << 1 << 1;
+    }
+}
+
+void tst_QUdpSocket::multicastLoopbackOption()
+{
+    QFETCH_GLOBAL(bool, setProxy);
+    QFETCH(QHostAddress, bindAddress);
+    QFETCH(int, loopback);
+    QFETCH(int, expected);
+    if (setProxy) {
+        // UDP multicast does not work with proxies
+        expected = 0;
+    }
+
+    QUdpSocket udpSocket;
+    // bind, but ignore the result, we are only interested in initializing the socket
+    (void) udpSocket.bind(bindAddress, 0);
+    udpSocket.setSocketOption(QUdpSocket::MulticastLoopbackOption, loopback);
+    QCOMPARE(udpSocket.socketOption(QUdpSocket::MulticastLoopbackOption).toInt(), expected);
+}
+
+void tst_QUdpSocket::multicastJoinBeforeBind_data()
+{
+    QTest::addColumn<QHostAddress>("groupAddress");
+    QTest::newRow("valid ipv4 group address") << QHostAddress("239.255.118.62");
+    QTest::newRow("invalid ipv4 group address") << QHostAddress(QHostAddress::Broadcast);
+    QTest::newRow("valid ipv6 group address") << QHostAddress("FF01::114");
+    QTest::newRow("invalid ipv6 group address") << QHostAddress(QHostAddress::AnyIPv6);
+}
+
+void tst_QUdpSocket::multicastJoinBeforeBind()
+{
+    QFETCH(QHostAddress, groupAddress);
+
+    QUdpSocket udpSocket;
+    // cannot join group before binding
+    QTest::ignoreMessage(QtWarningMsg, "QUdpSocket::joinMulticastGroup() called on a QUdpSocket when not in QUdpSocket::BoundState");
+    QVERIFY(!udpSocket.joinMulticastGroup(groupAddress));
+}
+
+void tst_QUdpSocket::multicastLeaveAfterClose_data()
+{
+    QTest::addColumn<QHostAddress>("groupAddress");
+    QTest::newRow("valid ipv4 group address") << QHostAddress("239.255.118.62");
+    QTest::newRow("valid ipv6 group address") << QHostAddress("FF01::114");
+}
+
+void tst_QUdpSocket::multicastLeaveAfterClose()
+{
+    QFETCH_GLOBAL(bool, setProxy);
+    QFETCH(QHostAddress, groupAddress);
+    if (setProxy) {
+        QSKIP("UDP Multicast does not work with proxies", SkipAll);
+    }
+
+    QUdpSocket udpSocket;
+    QVERIFY2(udpSocket.bind(groupAddress, 0),
+             qPrintable(udpSocket.errorString()));
+    QVERIFY2(udpSocket.joinMulticastGroup(groupAddress),
+             qPrintable(udpSocket.errorString()));
+    udpSocket.close();
+    QTest::ignoreMessage(QtWarningMsg, "QUdpSocket::leaveMulticastGroup() called on a QUdpSocket when not in QUdpSocket::BoundState");
+    QVERIFY(!udpSocket.leaveMulticastGroup(groupAddress));
+}
+
+void tst_QUdpSocket::setMulticastInterface_data()
+{
+    QTest::addColumn<QNetworkInterface>("iface");
+    QTest::addColumn<QHostAddress>("address");
+    QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
+    foreach (const QNetworkInterface &iface, interfaces) {
+        foreach (const QNetworkAddressEntry &entry, iface.addressEntries()) {
+            QTest::newRow(QString("%1:%2").arg(iface.name()).arg(entry.ip().toString()).toAscii())
+                    << iface
+                    << entry.ip();
+        }
+    }
+}
+
+void tst_QUdpSocket::setMulticastInterface()
+{
+    QFETCH_GLOBAL(bool, setProxy);
+    QFETCH(QNetworkInterface, iface);
+    QFETCH(QHostAddress, address);
+
+    QUdpSocket udpSocket;
+    // bind initializes the socket
+    bool bound = udpSocket.bind((address.protocol() == QAbstractSocket::IPv6Protocol
+                                 ? QHostAddress(QHostAddress::AnyIPv6)
+                                 : QHostAddress(QHostAddress::Any)),
+                                0);
+    if (!bound)
+        QTest::ignoreMessage(QtWarningMsg, "QUdpSocket::setMulticastInterface() called on a QUdpSocket when not in QUdpSocket::BoundState");
+    udpSocket.setMulticastInterface(iface);
+    if (!bound)
+        QTest::ignoreMessage(QtWarningMsg, "QUdpSocket::multicastInterface() called on a QUdpSocket when not in QUdpSocket::BoundState");
+    QNetworkInterface iface2 = udpSocket.multicastInterface();
+    if (!setProxy) {
+        QVERIFY(iface2.isValid());
+        QCOMPARE(iface.name(), iface2.name());
+    } else {
+        QVERIFY(!iface2.isValid());
+    }
+}
+
+void tst_QUdpSocket::multicast_data()
+{
+    QHostAddress anyAddress = QHostAddress(QHostAddress::Any);
+    QHostAddress groupAddress = QHostAddress("239.255.118.62");
+    QHostAddress any6Address = QHostAddress(QHostAddress::AnyIPv6);
+    QHostAddress group6Address = QHostAddress("FF01::114");
+
+    QTest::addColumn<QHostAddress>("bindAddress");
+    QTest::addColumn<bool>("bindResult");
+    QTest::addColumn<QHostAddress>("groupAddress");
+    QTest::addColumn<bool>("joinResult");
+    QTest::newRow("valid bind, group ipv4 address") << anyAddress << true << groupAddress << true;
+    QTest::newRow("valid bind, invalid group ipv4 address") << anyAddress << true << anyAddress << false;
+    QTest::newRow("same bind, group ipv4 address") << groupAddress << true << groupAddress << true;
+    QTest::newRow("valid bind, group ipv6 address") << any6Address << true << group6Address << true;
+    QTest::newRow("valid bind, invalid group ipv6 address") << any6Address << true << any6Address << false;
+    QTest::newRow("same bind, group ipv6 address") << group6Address << true << group6Address << true;
+}
+
+void tst_QUdpSocket::multicast()
+{
+    QFETCH_GLOBAL(bool, setProxy);
+    QFETCH(QHostAddress, bindAddress);
+    QFETCH(bool, bindResult);
+    QFETCH(QHostAddress, groupAddress);
+    QFETCH(bool, joinResult);
+    if (setProxy) {
+        // UDP multicast does not work with proxies
+        if ((bindAddress.protocol() == QAbstractSocket::IPv4Protocol && (bindAddress.toIPv4Address() & 0xffff0000) == 0xefff0000)
+            || bindAddress.protocol() == QAbstractSocket::IPv6Protocol) {
+            // proxy cannot bind to IPv6 or multicast addresses
+            bindResult = false;
+        }
+        joinResult = false;
+    }
+
+    QUdpSocket receiver;
+
+    // bind first, then verify that we can join the multicast group
+    QVERIFY2(receiver.bind(bindAddress, 0) == bindResult,
+             qPrintable(receiver.errorString()));
+    if (!bindResult)
+        return;
+
+    QVERIFY2(receiver.joinMulticastGroup(groupAddress) == joinResult,
+             qPrintable(receiver.errorString()));
+    if (!joinResult)
+        return;
+
+    QList<QByteArray> datagrams = QList<QByteArray>()
+                                  << QByteArray("0123")
+                                  << QByteArray("4567")
+                                  << QByteArray("89ab")
+                                  << QByteArray("cdef");
+
+    QUdpSocket sender;
+    foreach (const QByteArray &datagram, datagrams) {
+        QCOMPARE(int(sender.writeDatagram(datagram, groupAddress, receiver.localPort())),
+                 int(datagram.size()));
+    }
+
+    QVERIFY2(receiver.waitForReadyRead(),
+             qPrintable(receiver.errorString()));
+    QVERIFY(receiver.hasPendingDatagrams());
+    QList<QByteArray> receivedDatagrams;
+    while (receiver.hasPendingDatagrams()) {
+        QByteArray datagram;
+        datagram.resize(receiver.pendingDatagramSize());
+        receiver.readDatagram(datagram.data(), datagram.size(), 0, 0);
+        receivedDatagrams << datagram;
+    }
+    QCOMPARE(receivedDatagrams, datagrams);
+
+    QVERIFY2(receiver.leaveMulticastGroup(groupAddress), qPrintable(receiver.errorString()));
+}
+
 QTEST_MAIN(tst_QUdpSocket)
 #include "tst_qudpsocket.moc"