/****************************************************************************

**

** 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 Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qsysteminfo_linux_common_p.h"

#include <QTimer>

#include <QFile>

#include <QDir>

#if !defined(QT_NO_DBUS)

#include "qhalservice_linux_p.h"

#include <QtDBus/QtDBus>

#include <QtDBus/QDBusConnection>

#include <QtDBus/QDBusError>

#include <QtDBus/QDBusInterface>

#include <QtDBus/QDBusMessage>

#include <QtDBus/QDBusReply>

#include <QtDBus/QDBusPendingCallWatcher>

#include <QtDBus/QDBusObjectPath>

#include <QtDBus/QDBusPendingCall>

#endif

#include <QDesktopWidget>

#include <locale.h>

#include <sys/types.h>

#include <unistd.h>

#include <sys/vfs.h>

#include <mntent.h>

#include <sys/stat.h>

#ifdef Q_WS_X11

#include <QX11Info>

#include <X11/Xlib.h>

#endif

#include <bluetooth/bluetooth.h>

#include <bluetooth/bnep.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <unistd.h>

//we cannot include iwlib.h as the platform may not have it installed

//there we have to go via the kernel's wireless.h

//#include <iwlib.h>

//must be defined to be able to include kernel includes

#ifndef __user

#define __user

#endif

#include <linux/types.h>    /* required for wireless.h */

#include <sys/socket.h>     /* required for wireless.h */

#include <net/if.h>         /* required for wireless.h */

/* A lot of wireless.h have kernel includes which should be protected by

   #ifdef __KERNEL__. They course include errors due to redefinitions of types.

   This prevents those kernel headers being included by Qtopia.

   */

#ifndef _LINUX_IF_H

#define _LINUX_IF_H

#endif

#ifndef _LINUX_SOCKET_H

#define _LINUX_SOCKET_H

#endif

#include <linux/wireless.h>

#include <sys/ioctl.h>

static bool halAvailable()

{

#if !defined(QT_NO_DBUS)

    QDBusConnection dbusConnection = QDBusConnection::systemBus();

    if (dbusConnection.isConnected()) {

        QDBusConnectionInterface *dbiface = dbusConnection.interface();

        QDBusReply<bool> reply = dbiface->isServiceRegistered("org.freedesktop.Hal");

        if (reply.isValid() && reply.value()) {

            return reply.value();

        }

    }

#endif

    return false;

}

bool halIsAvailable;

QTM_BEGIN_NAMESPACE

QSystemInfoLinuxCommonPrivate::QSystemInfoLinuxCommonPrivate(QObject *parent) : QObject(parent)

{

    halIsAvailable = halAvailable();

    langCached = currentLanguage();

}

QSystemInfoLinuxCommonPrivate::~QSystemInfoLinuxCommonPrivate()

{

}

void QSystemInfoLinuxCommonPrivate::startLanguagePolling()

{

    QString checkLang = QString::fromLocal8Bit(qgetenv("LANG"));

    if(langCached.isEmpty()) {

        currentLanguage();

    }

    checkLang = checkLang.left(2);

    if(checkLang != langCached) {

        emit currentLanguageChanged(checkLang);

        langCached = checkLang;

    }

    langTimer = new QTimer(this);

    QTimer::singleShot(1000, this, SLOT(startLanguagePolling()));

}

QString QSystemInfoLinuxCommonPrivate::currentLanguage() const

{

    QString lang;

    if(langCached.isEmpty()) {

        lang  = QLocale::system().name().left(2);

        if(lang.isEmpty() || lang == QLatin1String("C")) {

            lang = QLatin1String("en");

        }

    } else {

        lang = langCached;

    }

    return lang;

}

bool QSystemInfoLinuxCommonPrivate::hasFeatureSupported(QSystemInfo::Feature feature)

{

     bool featureSupported = false;

     switch (feature) {

     case QSystemInfo::BluetoothFeature :

         {

             const QString sysPath = "/sys/class/bluetooth/";

             const QDir sysDir(sysPath);

             QStringList filters;

             filters << "*";

             const QStringList sysList = sysDir.entryList( filters ,QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);

             foreach(const QString dir, sysList) {

                 const QFileInfo btFile(sysPath + dir+"/address");

                 if(btFile.exists()) {

                     return true;

                 }

             }

         }

     break;

     case QSystemInfo::CameraFeature :

         {

 #if !defined(QT_NO_DBUS)

             featureSupported = hasHalUsbFeature(0x06); // image

             if(featureSupported)

                 return featureSupported;

 #endif

             featureSupported = hasSysFeature("video");

         }

         break;

     case QSystemInfo::FmradioFeature :

         {

             featureSupported = !(QDir("/sys/class/video4linux/").entryList(QStringList("radio*")).empty());

         }

         break;

     case QSystemInfo::IrFeature :

         {

 #if !defined(QT_NO_DBUS)

         featureSupported = hasHalUsbFeature(0xFE);

         if(featureSupported)

             return featureSupported;

 #endif

         featureSupported = hasSysFeature("irda"); //?

     }

         break;

     case QSystemInfo::LedFeature :

         {

             featureSupported = hasSysFeature("led"); //?

         }

         break;

     case QSystemInfo::MemcardFeature :

         {

 #if !defined(QT_NO_DBUS)

             QHalInterface iface;

             if (iface.isValid()) {

                 QHalInterface halIface;

                 const QStringList halDevices = halIface.getAllDevices();

                 foreach(const QString device, halDevices) {

                     QHalDeviceInterface ifaceDevice(device);

                     if (ifaceDevice.isValid()) {

                         if(ifaceDevice.getPropertyString("info.subsystem") == "mmc_host") {

                             return true;

                         }

                         if(ifaceDevice.getPropertyBool("storage.removable")) {

                             return true;

                         }

                     }

                 }

             }

 #endif

         }

         break;

     case QSystemInfo::UsbFeature :

         {

 #if !defined(QT_NO_DBUS)

         featureSupported = hasHalDeviceFeature("usb");

         if(featureSupported)

             return featureSupported;

 #endif

             featureSupported = hasSysFeature("usb_host");

         }

         break;

     case QSystemInfo::VibFeature :

 #if !defined(QT_NO_DBUS)

         if(hasHalDeviceFeature("vibrator") || hasHalDeviceFeature("vib")) {

             return true;

     }

#endif

         break;

     case QSystemInfo::WlanFeature :

         {

 #if !defined(QT_NO_DBUS)

             QHalInterface iface;

             if (iface.isValid()) {

                 const QStringList list = iface.findDeviceByCapability("net.80211");

                 if(!list.isEmpty()) {

                     featureSupported = true;

                     break;

                 }

             }

 #endif

             featureSupported = hasSysFeature("80211");

         }

         break;

     case QSystemInfo::SimFeature :

         break;

     case QSystemInfo::LocationFeature :

 #if !defined(QT_NO_DBUS)

         featureSupported = hasHalDeviceFeature("gps"); //might not always be true

         if(featureSupported)

             return featureSupported;

 #endif

         break;

     case QSystemInfo::VideoOutFeature :

         {

             featureSupported = !(QDir("/sys/class/video4linux/").entryList(QStringList("video*")).empty());

         }

         break;

     case QSystemInfo::HapticsFeature:

         break;

     default:

         featureSupported = false;

         break;

     };

     return featureSupported;

 }

 #if !defined(QT_NO_DBUS)

 bool QSystemInfoLinuxCommonPrivate::hasHalDeviceFeature(const QString &param)

 {

     QHalInterface halIface;

     const QStringList halDevices = halIface.getAllDevices();

     foreach(const QString device, halDevices) {

         if(device.contains(param)) {

             return true;

         }

     }

     return false;

 }

 bool QSystemInfoLinuxCommonPrivate::hasHalUsbFeature(qint32 usbClass)

 {

     QHalInterface halIface;

     const QStringList halDevices = halIface.getAllDevices();

     foreach(const QString device, halDevices) {

         QHalDeviceInterface ifaceDevice(device);

         if (ifaceDevice.isValid()) {

             if(ifaceDevice.getPropertyString("info.subsystem") == "usb_device") {

                 if(ifaceDevice.getPropertyInt("usb.interface.class") == usbClass) {

                     return true;

                 }

             }

         }

     }

     return false;

 }

 #endif

QString QSystemInfoLinuxCommonPrivate::version(QSystemInfo::Version type,

                                               const QString &parameter)

{

    Q_UNUSED(parameter);

    QString errorStr = QLatin1String("Not Available");

    switch(type) {

        case QSystemInfo::Os :

        {

#if !defined(QT_NO_DBUS)

            QHalDeviceInterface iface(QLatin1String("/org/freedesktop/Hal/devices/computer"));

            QString str;

            if (iface.isValid()) {

                str = iface.getPropertyString(QLatin1String("system.kernel.version"));

                if(!str.isEmpty()) {

                    return str;

                }

            }

#endif

            const QString versionPath = QLatin1String("/proc/version");

            QFile versionFile(versionPath);

            if(!versionFile.open(QIODevice::ReadOnly | QIODevice::Text)) {

                qDebug() << "File not opened";

            } else {

                QString  strvalue;

                strvalue = QLatin1String(versionFile.readAll().trimmed());

                strvalue = strvalue.split(QLatin1String(" ")).at(2);

                versionFile.close();

                return strvalue;

            }

            break;

        }

        case QSystemInfo::QtCore :

            return QLatin1String(qVersion());

            break;

        default:

            break;

    };

    return errorStr;

}

QString QSystemInfoLinuxCommonPrivate::currentCountryCode() const

{

    return QLocale::system().name().mid(3,2);

}

bool QSystemInfoLinuxCommonPrivate::hasSysFeature(const QString &featureStr)

{

    const QString sysPath = QLatin1String("/sys/class/");

    const QDir sysDir(sysPath);

    QStringList filters;

    filters << QLatin1String("*");

    const QStringList sysList = sysDir.entryList( filters ,QDir::Dirs, QDir::Name);

    foreach(const QString dir, sysList) {

        const QDir sysDir2(sysPath + dir);

        if(dir.contains(featureStr)) {

            const QStringList sysList2 = sysDir2.entryList( filters ,QDir::Dirs, QDir::Name);

            if(!sysList2.isEmpty()) {

                return true;

            }

        }

    }

    return false;

}

QSystemNetworkInfoLinuxCommonPrivate::QSystemNetworkInfoLinuxCommonPrivate(QObject *parent) : QObject(parent)

{

}

QSystemNetworkInfoLinuxCommonPrivate::~QSystemNetworkInfoLinuxCommonPrivate()

{

}

QSystemNetworkInfo::NetworkStatus QSystemNetworkInfoLinuxCommonPrivate::networkStatus(QSystemNetworkInfo::NetworkMode mode)

{

    switch(mode) {

    case QSystemNetworkInfo::WlanMode:

        {

            const QString baseSysDir = "/sys/class/net/";

            const QDir wDir(baseSysDir);

            const QStringList dirs = wDir.entryList(QStringList() << "*", QDir::AllDirs | QDir::NoDotAndDotDot);

            foreach(const QString dir, dirs) {

                const QString devFile = baseSysDir + dir;

                const QFileInfo wiFi(devFile + "/wireless");

                const QFileInfo fi("/proc/net/route");

                if(wiFi.exists() && fi.exists()) {

                    QFile rx(fi.absoluteFilePath());

                    if(rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {

                        const QString result = rx.readAll();

                        if(result.contains(dir)) {

                            return QSystemNetworkInfo::Connected;

                        } else {

                            return QSystemNetworkInfo::NoNetworkAvailable;

                        }

                    }

                }

            }

        }

        break;

    case QSystemNetworkInfo::EthernetMode:

        {

            const QString baseSysDir = "/sys/class/net/";

            const QDir eDir(baseSysDir);

            const QString dir = QSystemNetworkInfoLinuxCommonPrivate::interfaceForMode(mode).name();

            const QString devFile = baseSysDir + dir;

            const QFileInfo fi("/proc/net/route");

            if(fi.exists()) {

                QFile rx(fi.absoluteFilePath());

                if(rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {

                    const QString result = rx.readAll();

                    if(result.contains(dir)) {

                        return QSystemNetworkInfo::Connected;

                    } else {

                        return QSystemNetworkInfo::NoNetworkAvailable;

                    }

                }

            }

        }

        break;

        case QSystemNetworkInfo::BluetoothMode:

        {

            return getBluetoothNetStatus();

       }

        break;

    default:

        break;

    };

    return QSystemNetworkInfo::UndefinedStatus;

}

QString QSystemNetworkInfoLinuxCommonPrivate::networkName(QSystemNetworkInfo::NetworkMode mode)

{

    QString netname = "";

    switch(mode) {

    case QSystemNetworkInfo::WlanMode:

        {

            if(networkStatus(mode) != QSystemNetworkInfo::Connected) {

                return netname;

            }

            QString wlanInterface;

            const QString baseSysDir = "/sys/class/net/";

            const QDir wDir(baseSysDir);

            const QStringList dirs = wDir.entryList(QStringList() << "*", QDir::AllDirs | QDir::NoDotAndDotDot);

            foreach(const QString dir, dirs) {

                const QString devFile = baseSysDir + dir;

                const QFileInfo fi(devFile + "/wireless");

                if(fi.exists()) {

                    wlanInterface = dir;

                }

            }

            int sock = socket(PF_INET, SOCK_DGRAM, 0);

            if (sock > 0) {

                const char* someRandomBuffer[IW_ESSID_MAX_SIZE + 1];

                struct iwreq wifiExchange;

                memset(&wifiExchange, 0, sizeof(wifiExchange));

                memset(someRandomBuffer, 0, sizeof(someRandomBuffer));

                wifiExchange.u.essid.pointer = (caddr_t) someRandomBuffer;

                wifiExchange.u.essid.length = IW_ESSID_MAX_SIZE;

                wifiExchange.u.essid.flags = 0;

                const char* interfaceName = wlanInterface.toLatin1();

                strncpy(wifiExchange.ifr_name, interfaceName, IFNAMSIZ);

                wifiExchange.u.essid.length = IW_ESSID_MAX_SIZE + 1;

                if (ioctl(sock, SIOCGIWESSID, &wifiExchange) == 0) {

                    const char *ssid = (const char *)wifiExchange.u.essid.pointer;

                    netname = ssid;

                }

            } else {

                qDebug() << "no socket";

            }

            close(sock);

        }

        break;

    case QSystemNetworkInfo::EthernetMode:

        {

            QFile resFile("/etc/resolv.conf");

            if(resFile.exists()) {

                if(resFile.exists() && resFile.open(QIODevice::ReadOnly | QIODevice::Text)) {

                    QString line;

                    QTextStream in(&resFile);

                    do {

                        line = in.readLine();

                        if(line.contains("domain")) {

                            netname = line.section(" ",1,1); //guessing here

                        }

                } while (!line.isNull());

                resFile.close();

            }

        }

    }

    break;

        case QSystemNetworkInfo::BluetoothMode:

            {

    #if !defined(QT_NO_DBUS)

        netname = getBluetoothInfo("name");

#endif

    }

        break;

    default: