[Wifi] graduate from Qt.labs.wifi 0.1 to B2Qt.Wifi 1.0

- Make wifi library available from c++
   1) included with "#include <B2QtWifi>", available classes are:
      QWifiDevice, QWifiManager, QWifiConfiguration

- Re-design of API:
   1) connectedSSID -> currentSSID
      get current network from this property instead of networks state change events

   2) networkStateChanaged(QWifiNetwork *) -> networkStateChanged(NetworkState)
      Don't expose QWifiNetwork objects to library users, use data model roles
      instead, no need to pollute API with "read-only" class. The flaws of exposing
      QWifiNetwork become apparent when looking at C++ API.

   3) New BackendState enum for backend state changes events, backendStateChanged(BackendState)
      Initializing backend can be lengthy operation and can block GUI thread,
      same is true for DHCP requests, now these operations are moved into a separate thread
      and backend state change events are delivered asynchronously.

   4) Make WifiManager a Singleton, we don't want several instances starting
      and stopping system processes and it makes global state handling simpler.

   5) Rename Interface -> WifiDevice

   6!) Introducing QWifiConfiguration. This abstraction allows for easy
       way to add new features, whatever we choose to support from:

       http://w1.fi/cgit/hostap/plain/wpa_supplicant/wpa_supplicant.conf

       The idea for it is to be a Qt-style wrapper for "network {}" configurations
       from wpa_supplicant.conf.

       Also this makes life simpler for developers if they know what network they
       will be using, they can omit scanning, listing, selecting parts and do something
       like this instead:

       WifiConfiguration {
          id: config
          ssid: "network name"
          passphrase: "12345678"
       }

       if (!WifiManager.connect(config))
           print("failed to connect: " + WifiManager.lastError)

- Optimizations:
  1) Async. event delivery.

  2) eLinux: Don't use "ifup", it is slow because it starts dhcp
     request even before any network has been configured. Use
     start-stop-daemon and ifconfig directly.

- Bug fixes (many), but most importantly:
  1) Get backend state properly when WifiManager is created.

- Public header cleanup

- Other:
  1) Added categorized logging.
  2) Methods to get/set wifi interface name. Not exposed to qml.

- Missing parts that will be added as a separate patch:
 * [doc] Getting started guide for c++ and qml
 * [doc] Update for qml docs and new docs for c++. The current docs
         are out-of-date.

Task-number: QTEE-649
Task-number: QTEE-810
Change-Id: I7dc8709aed2de622828a119749aef31534a4296d
Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>

1 files changed, 461 insertions, 0 deletions

diff --git a/src/wifi/qwificontroller.cpp b/src/wifi/qwificontroller.cpp
new file mode 100644
index 0000000..ea49764
--- /dev/null
+++ b/src/wifi/qwificontroller.cpp
@@ -0,0 +1,461 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use the contact form at
+** http://www.qt.io
+**
+** This file is part of Qt Enterprise Embedded.
+**
+** Licensees holding valid Qt Enterprise licenses may use this file in
+** accordance with the Qt Enterprise License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** the contact form at http://www.qt.io
+**
+****************************************************************************/
+#include "qwificontroller_p.h"
+#include "qwifimanager_p.h"
+#include "qwifidevice.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QProcess>
+#include <QtCore/QByteArray>
+#include <QtCore/QFile>
+
+#ifdef Q_OS_ANDROID_NO_SDK
+#include <QtNetwork/QLocalSocket>
+#include <cutils/sockets.h>
+#include <unistd.h>
+#endif
+
+#ifdef Q_OS_ANDROID_NO_SDK
+/*
+ * Work API differences between Android versions
+ */
+int q_wifi_start_supplicant()
+{
+#if Q_ANDROID_VERSION_MAJOR == 4 && Q_ANDROID_VERSION_MINOR < 1
+    return wifi_start_supplicant();
+#else
+    return wifi_start_supplicant(0);
+#endif
+}
+
+int q_wifi_stop_supplicant()
+{
+#if Q_ANDROID_VERSION_MAJOR == 4 && Q_ANDROID_VERSION_MINOR < 1
+    return wifi_stop_supplicant();
+#else
+    return wifi_stop_supplicant(0);
+#endif
+}
+
+int q_wifi_connect_to_supplicant(const char *ifname)
+{
+#if Q_ANDROID_VERSION_MAJOR == 4 && (Q_ANDROID_VERSION_MINOR < 4 && Q_ANDROID_VERSION_MINOR >= 1)
+    return wifi_connect_to_supplicant(ifname);
+#else
+    Q_UNUSED(ifname);
+    return wifi_connect_to_supplicant();
+#endif
+}
+
+void q_wifi_close_supplicant_connection(const char *ifname)
+{
+#if Q_ANDROID_VERSION_MAJOR == 4 && (Q_ANDROID_VERSION_MINOR < 4 && Q_ANDROID_VERSION_MINOR >= 1)
+    wifi_close_supplicant_connection(ifname);
+#else
+    Q_UNUSED(ifname);
+    wifi_close_supplicant_connection();
+#endif
+}
+
+int q_wifi_wait_for_event(const char *ifname, char *buf, size_t len)
+{
+#if Q_ANDROID_VERSION_MAJOR == 4 && (Q_ANDROID_VERSION_MINOR < 4 && Q_ANDROID_VERSION_MINOR >= 1)
+    return wifi_wait_for_event(ifname, buf, len);
+#else
+    Q_UNUSED(ifname);
+    return wifi_wait_for_event(buf, len);
+#endif
+}
+
+int q_wifi_command(const char *ifname, const char *command, char *reply, size_t *reply_len)
+{
+#if Q_ANDROID_VERSION_MAJOR == 4 && (Q_ANDROID_VERSION_MINOR < 4 && Q_ANDROID_VERSION_MINOR >= 1)
+    return wifi_command(ifname, command, reply, reply_len);
+#else
+    Q_UNUSED(ifname);
+    return wifi_command(command, reply, reply_len);
+#endif
+}
+
+/*
+ * This function is borrowed from /system/core/libnetutils/dhcp_utils.c
+ *
+ * Wait for a system property to be assigned a specified value.
+ * If desired_value is NULL, then just wait for the property to
+ * be created with any value. maxwait is the maximum amount of
+ * time in seconds to wait before giving up.
+ */
+const int NAP_TIME = 200; // wait for 200ms at a time when polling for property values
+int wait_for_property(const char *name, const char *desired_value, int maxwait)
+{
+    char value[PROPERTY_VALUE_MAX] = {'\0'};
+    int maxnaps = (maxwait * 1000) / NAP_TIME;
+
+    if (maxnaps < 1) {
+        maxnaps = 1;
+    }
+
+    while (maxnaps-- > 0) {
+        usleep(NAP_TIME * 1000);
+        if (property_get(name, value, NULL)) {
+            if (desired_value == NULL ||
+                    strcmp(value, desired_value) == 0) {
+                return 0;
+            }
+        }
+    }
+    return -1; /* failure */
+}
+
+#endif // Q_OS_ANDROID_NO_SDK
+
+QT_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(B2QT_WIFI, "qt.b2qt.wifi")
+
+class QWifiManagerEvent : public QEvent
+{
+public:
+    QWifiManagerEvent(QEvent::Type type, const QByteArray &data = QByteArray())
+        : QEvent(type)
+        , m_data(data)
+    {
+    }
+
+    QByteArray data() const { return m_data; }
+
+private:
+    QByteArray m_data;
+};
+
+class QWifiEventThread : public QThread
+{
+public:
+    QWifiEventThread(QWifiController *controller)
+        : m_controller(controller)
+    {
+        m_interface = QWifiDevice::wifiInterfaceName();
+    }
+
+    void run() {
+        qCDebug(B2QT_WIFI) << "running wifi event thread";
+        QWifiManagerEvent *event = 0;
+        char buffer[2048];
+        forever {
+            int size = q_wifi_wait_for_event(m_interface, buffer, sizeof(buffer) - 1);
+            if (size > 0) {
+                buffer[size] = 0;
+                event = 0;
+                qCDebug(B2QT_WIFI) << "[event]: " << buffer;
+                if (m_controller->isWifiThreadExitRequested()) {
+                    qCDebug(B2QT_WIFI) << "exit wifi event thread";
+                    return;
+                }
+                if (strstr(buffer, "SCAN-RESULTS")) {
+                    event = new QWifiManagerEvent(WIFI_SCAN_RESULTS);
+                } else if (strstr(buffer, "CTRL-EVENT-CONNECTED")) {
+                    event = new QWifiManagerEvent(WIFI_CONNECTED);
+                } else if (strstr(buffer, "CTRL-EVENT-DISCONNECTED")) {
+                    event = new QWifiManagerEvent(WIFI_DISCONNECTED);
+                } else if (strstr(buffer, "Trying to associate")) {
+                    event = new QWifiManagerEvent(WIFI_AUTHENTICATING);
+                } else if (strstr(buffer, "Handshake failed")) {
+                    event = new QWifiManagerEvent(WIFI_HANDSHAKE_FAILED);
+                }
+                if (event)
+                    QCoreApplication::postEvent(m_controller->wifiManager(), event);
+            }
+        }
+    }
+
+private:
+    QWifiController *m_controller;
+    QByteArray m_interface;
+};
+
+
+QWifiController::QWifiController(QWifiManager *manager, QWifiManagerPrivate *managerPrivate) :
+    m_manager(manager),
+    m_managerPrivate(managerPrivate),
+    m_exitEventThread(false),
+#ifdef Q_OS_ANDROID_NO_SDK
+    m_qcSocket(0),
+#endif
+    m_eventThread(0)
+{
+    m_interface = QWifiDevice::wifiInterfaceName();
+    m_eventThread = new QWifiEventThread(this);
+
+    qRegisterMetaType<QWifiManager::BackendState>("QWifiManager::BackendState");
+#ifdef Q_OS_ANDROID_NO_SDK
+    qRegisterMetaType<QAbstractSocket::SocketState>("QAbstractSocket::SocketState");
+#endif
+}
+
+QWifiController::~QWifiController()
+{
+    exitWifiEventThread();
+    delete m_eventThread;
+#ifdef Q_OS_ANDROID_NO_SDK
+    delete m_qcSocket;
+#endif
+}
+
+void QWifiController::allocateOnThisThread()
+{
+#ifdef Q_OS_ANDROID_NO_SDK
+    m_qcSocket = new QLocalSocket;
+    int qcFd = socket_local_client("qconnectivity", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
+    if (qcFd != -1) {
+        m_qcSocket->setSocketDescriptor(qcFd);
+    } else {
+        qCWarning(B2QT_WIFI) << "failed to get file descriptor of a qconnectivity socket!";
+    }
+#endif
+}
+
+void QWifiController::run()
+{
+    qCDebug(B2QT_WIFI) << "running wifi backend controller thread";
+    allocateOnThisThread();
+    Method method;
+    forever {
+        m_methodsMutex.lock();
+        if (m_methods.isEmpty())
+            methodCallRequested.wait(&m_methodsMutex);
+        method = m_methods.takeFirst();
+        m_methodsMutex.unlock();
+        switch (method) {
+        case InitializeBackend:
+            initializeBackend();
+            break;
+        case TerminateBackend:
+            terminateBackend();
+            break;
+        case AcquireIPAddress:
+            acquireIPAddress();
+            break;
+        case StopDhcp:
+            stopDhcp();
+            break;
+        case ExitEventLoop:
+            qCDebug(B2QT_WIFI) << "exit wifi backend controller thread";
+            return;
+        }
+    }
+}
+
+void QWifiController::call(Method method)
+{
+    QMutexLocker locker(&m_methodsMutex);
+    m_methods.append(method);
+    methodCallRequested.wakeOne();
+}
+
+void QWifiController::initializeBackend()
+{
+    qCDebug(B2QT_WIFI) << "initializing wifi backend";
+    emit backendStateChanged(QWifiManager::Initializing);
+
+#ifdef Q_OS_ANDROID_NO_SDK
+    qCDebug(B2QT_WIFI) << "initialize driver";
+    if (!(is_wifi_driver_loaded() || wifi_load_driver() == 0)) {
+        qCWarning(B2QT_WIFI) << "failed to load a driver";
+        return;
+    }
+#else
+    qCDebug(B2QT_WIFI) << "run ifconfig (up)";
+    QProcess ifconfig;
+    ifconfig.start(QStringLiteral("ifconfig"), QStringList() << QLatin1String(m_interface) << QStringLiteral("up"));
+    ifconfig.waitForFinished();
+    if (ifconfig.exitStatus() != QProcess::NormalExit && ifconfig.exitCode() != 0) {
+        qCWarning(B2QT_WIFI) << "failed to bring up wifi interface!";
+        return;
+    }
+#endif
+    resetSupplicantSocket();
+    startWifiEventThread();
+    qCDebug(B2QT_WIFI) << "wifi backend started successfully";
+    emit backendStateChanged(QWifiManager::Running);
+}
+
+void QWifiController::resetSupplicantSocket() const
+{
+    qCDebug(B2QT_WIFI) << "reset supplicant socket";
+    // close down the previous connection to supplicant if
+    // one exists before re-connecting.
+    if (q_wifi_stop_supplicant() < 0)
+        qCWarning(B2QT_WIFI) << "failed to stop supplicant!";
+    q_wifi_close_supplicant_connection(m_interface);
+    qCDebug(B2QT_WIFI) << "start supplicant";
+    if (q_wifi_start_supplicant() != 0) {
+        qCWarning(B2QT_WIFI) << "failed to start a supplicant!";
+        return;
+    }
+#ifdef Q_OS_ANDROID_NO_SDK
+    if (wait_for_property("init.svc.wpa_supplicant", "running", 5) < 0) {
+        qCWarning(B2QT_WIFI) << "timed out waiting for supplicant to start!";
+        return;
+    }
+#endif
+    qCDebug(B2QT_WIFI) << "connect to supplicant";
+    if (q_wifi_connect_to_supplicant(m_interface) != 0) {
+        qCWarning(B2QT_WIFI) << "failed to connect to a supplicant!";
+        return;
+    }
+}
+
+void QWifiController::terminateBackend()
+{
+    qCDebug(B2QT_WIFI) << "terminating wifi backend";
+    emit backendStateChanged(QWifiManager::Terminating);
+    exitWifiEventThread();
+    if (q_wifi_stop_supplicant() < 0)
+        qCWarning(B2QT_WIFI) << "failed to stop supplicant!";
+    q_wifi_close_supplicant_connection(m_interface);
+#ifndef Q_OS_ANDROID_NO_SDK
+    qCDebug(B2QT_WIFI) << "run ifconfig (down)";
+    QProcess ifconfig;
+    ifconfig.start(QStringLiteral("ifconfig"), QStringList() << QLatin1String(m_interface) << QStringLiteral("down"));
+    ifconfig.waitForFinished();
+    if (ifconfig.exitStatus() != QProcess::NormalExit && ifconfig.exitCode() != 0) {
+        qCWarning(B2QT_WIFI) << "failed to bring down wifi interface!";
+        return;
+    }
+#endif
+    stopDhcp();
+    qCDebug(B2QT_WIFI) << "wifi backend stopped successfully";
+    emit backendStateChanged(QWifiManager::NotRunning);
+}
+
+void QWifiController::startWifiEventThread()
+{
+    m_exitEventThread = false;
+    m_eventThread->start();
+}
+
+void QWifiController::exitWifiEventThread()
+{
+    if (m_eventThread->isRunning()) {
+        m_exitEventThread = true;
+        m_managerPrivate->call(QStringLiteral("SCAN"));
+        m_eventThread->wait();
+    }
+}
+
+#ifdef Q_OS_ANDROID_NO_SDK
+bool QWifiController::getQConnectivityReply()
+{
+    bool arrived = false;
+    if (m_qcSocket->canReadLine()) {
+        arrived = true;
+        QByteArray received = m_qcSocket->readLine(m_qcSocket->bytesAvailable());
+        if (received != "success" && received != "failed") {
+            qCWarning(B2QT_WIFI) << "unknown message: " << received;
+            received = "failed";
+        }
+        emit dhcpRequestFinished(QLatin1String(received));
+    }
+    return arrived;
+}
+#else
+void QWifiController::killDhcpProcess(const QString &path) const
+{
+    QFile pidFile(path);
+    if (pidFile.exists()) {
+        pidFile.open(QIODevice::ReadOnly);
+        QByteArray pid = pidFile.readAll();
+        QProcess kill;
+        kill.start(QStringLiteral("kill"), QStringList() << QLatin1String(pid.trimmed()));
+        kill.waitForFinished();
+        if (kill.exitStatus() != QProcess::NormalExit && kill.exitCode() != 0)
+            qCWarning(B2QT_WIFI) << "killing dhcp process failed!";
+    }
+    pidFile.close();
+}
+#endif
+
+void QWifiController::acquireIPAddress()
+{
+    qCDebug(B2QT_WIFI, "acquireIPAddress");
+#ifdef Q_OS_ANDROID_NO_SDK
+    QByteArray request = m_interface + " connect\n";
+    m_qcSocket->abort();
+    m_qcSocket->connectToServer(QStringLiteral(ANDROID_SOCKET_DIR "/qconnectivity"));
+    bool timeout = false;
+    if (m_qcSocket->waitForConnected()) {
+        m_qcSocket->write(request, request.length());
+        m_qcSocket->flush();
+        do {
+            if (m_qcSocket->waitForReadyRead()) {
+                if (getQConnectivityReply())
+                    break;
+            } else {
+                timeout = true;
+                qCWarning(B2QT_WIFI) << "waiting a message from qconnectivity timed out!";
+                break;
+            }
+        } while (true);
+    } else {
+        timeout = true;
+        qCWarning(B2QT_WIFI) << "connecting to qconnectivity server socket timed out!";
+    }
+    if (timeout)
+        emit dhcpRequestFinished(QStringLiteral("failed"));
+#else
+    QString filePath = QLatin1String("/var/run/udhcpc." + m_interface + ".pid");
+    killDhcpProcess(filePath);
+    QStringList args;
+    args << QStringLiteral("-R") << QStringLiteral("-n") << QStringLiteral("-p")
+         << filePath << QStringLiteral("-i") << QLatin1String(m_interface);
+
+    QProcess udhcpc;
+    udhcpc.start(QStringLiteral("udhcpc"), args);
+    udhcpc.waitForFinished();
+    if (udhcpc.exitStatus() != QProcess::NormalExit && udhcpc.exitCode() != 0)
+        qCWarning(B2QT_WIFI) << "udhcpc process failed!";
+
+    QString status = QLatin1String("success");
+    if (udhcpc.readAll().contains("No lease"))
+        status = QLatin1String("failed");
+
+    emit dhcpRequestFinished(status);
+#endif
+}
+
+void QWifiController::stopDhcp() const
+{
+    qCDebug(B2QT_WIFI, "stopDhcp");
+#ifdef Q_OS_ANDROID_NO_SDK
+    QByteArray request = m_interface + " disconnect\n";
+    m_qcSocket->abort();
+    m_qcSocket->connectToServer(QStringLiteral(ANDROID_SOCKET_DIR "/qconnectivity"));
+    if (m_qcSocket->waitForConnected()) {
+        m_qcSocket->write(request, request.length());
+        m_qcSocket->flush();
+    } else {
+        qCWarning(B2QT_WIFI) << "connecting to qconnectivity server socket timed out!";
+    }
+#else
+    QString filePath = QLatin1String("/var/run/udhcpc." + m_interface + ".pid");
+    killDhcpProcess(filePath);
+#endif
+}
+
+QT_END_NAMESPACE