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

**

** 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.h"

#include "qsysteminfo_win_p.h"

#include <qt_windows.h>

#include <QtCore/qmutex.h>

#include <QStringList>

#include <QSize>

#include <QFile>

#include <QTextStream>

#include <QLocale>

#include <QLibraryInfo>

#include <QApplication>

#include <QDesktopWidget>

#include <QDebug>

#include <QSettings>

#include <QSysInfo>

#include <QNetworkInterface>

#include <QList>

#include <QSettings>

#include <QDir>

#include <QNetworkInterface>

#include <QString>

#include <QTimer>

#include <QBasicTimer>

#include <QtCore/qlibrary.h>

#include <QUuid>

#include <QSysInfo>

#include <qabstracteventdispatcher.h>

#include <locale.h>

#ifdef Q_OS_WINCE

#include <simmgr.h>

#include <Winbase.h>

#include <Winuser.h>

#include <Pm.h>

#endif

#if !defined( Q_CC_MINGW)

#ifndef Q_OS_WINCE

#include "qwmihelper_win_p.h"

enum NDIS_MEDIUM {

    NdisMedium802_3 = 0,

    NdisMediumWirelessWan = 9,

};

enum NDIS_PHYSICAL_MEDIUM {

    NdisPhysicalMediumUnspecified = 0,

    NdisPhysicalMediumWirelessLan = 1,

    NdisPhysicalMediumBluetooth = 10,

    NdisPhysicalMediumWiMax = 12,

};

#define OID_GEN_MEDIA_SUPPORTED 0x00010103

#define OID_GEN_PHYSICAL_MEDIUM 0x00010202

#define IOCTL_NDIS_QUERY_GLOBAL_STATS \

    CTL_CODE(FILE_DEVICE_PHYSICAL_NETCARD, 0, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)

#endif

#endif

#define WLAN_MAX_NAME_LENGTH 256

#define DOT11_SSID_MAX_LENGTH 32

#define WLAN_NOTIFICATION_SOURCE_ALL 0x0000ffff

enum WLAN_INTF_OPCODE {

    wlan_intf_opcode_autoconf_start = 0x000000000,

    wlan_intf_opcode_autoconf_enabled,

    wlan_intf_opcode_background_scan_enabled,

    wlan_intf_opcode_media_streaming_mode,

    wlan_intf_opcode_radio_state,

    wlan_intf_opcode_bss_type,

    wlan_intf_opcode_interface_state,

    wlan_intf_opcode_current_connection,

    wlan_intf_opcode_channel_number,

    wlan_intf_opcode_supported_infrastructure_auth_cipher_pairs,

    wlan_intf_opcode_supported_adhoc_auth_cipher_pairs,

    wlan_intf_opcode_supported_country_or_region_string_list,

    wlan_intf_opcode_current_operation_mode,

    wlan_intf_opcode_supported_safe_mode,

    wlan_intf_opcode_certified_safe_mode,

    wlan_intf_opcode_autoconf_end = 0x0fffffff,

    wlan_intf_opcode_msm_start = 0x10000100,

    wlan_intf_opcode_statistics,

    wlan_intf_opcode_rssi,

    wlan_intf_opcode_msm_end = 0x1fffffff,

    wlan_intf_opcode_security_start = 0x20010000,

    wlan_intf_opcode_security_end = 0x2fffffff,

    wlan_intf_opcode_ihv_start = 0x30000000,

    wlan_intf_opcode_ihv_end = 0x3fffffff

};

enum WLAN_OPCODE_VALUE_TYPE {

    wlan_opcode_value_type_query_only = 0,

    wlan_opcode_value_type_set_by_group_policy,

    wlan_opcode_value_type_set_by_user,

    wlan_opcode_value_type_invalid

};

enum WLAN_INTERFACE_STATE {

    wlan_interface_state_not_ready = 0,

    wlan_interface_state_connected,

    wlan_interface_state_ad_hoc_network_formed,

    wlan_interface_state_disconnecting,

    wlan_interface_state_disconnected,

    wlan_interface_state_associating,

    wlan_interface_state_discovering,

    wlan_interface_state_authenticating

};

struct WLAN_INTERFACE_INFO {

    GUID InterfaceGuid;

    WCHAR strInterfaceDescription[WLAN_MAX_NAME_LENGTH];

    WLAN_INTERFACE_STATE isState;

};

struct WLAN_INTERFACE_INFO_LIST {

    DWORD dwNumberOfItems;

    DWORD dwIndex;

    WLAN_INTERFACE_INFO InterfaceInfo[1];

};

struct WLAN_NOTIFICATION_DATA {

    DWORD NotificationSource;

    DWORD NotificationCode;

    GUID InterfaceGuid;

    DWORD dwDataSize;

    PVOID pData;

};

enum WLAN_CONNECTION_MODE {

    wlan_connection_mode_profile = 0,

    wlan_connection_mode_temporary_profile,

    wlan_connection_mode_discovery_secure,

    wlan_connection_mode_discovery_unsecure,

    wlan_connection_mode_auto,

    wlan_connection_mode_invalid

};

enum DOT11_PHY_TYPE {

        dot11_phy_type_unknown = 0,

        dot11_phy_type_any = dot11_phy_type_unknown,

        dot11_phy_type_fhss = 1,

        dot11_phy_type_dsss = 2,

        dot11_phy_type_irbaseband = 3,

        dot11_phy_type_ofdm = 4,

        dot11_phy_type_hrdsss = 5,

        dot11_phy_type_erp = 6,

        dot11_phy_type_ht = 7,

        dot11_phy_type_IHV_start = 0x80000000,

        dot11_phy_type_IHV_end = 0xffffffff

    };

enum DOT11_AUTH_ALGORITHM {

    DOT11_AUTH_ALGO_80211_OPEN = 1,

    DOT11_AUTH_ALGO_80211_SHARED_KEY = 2,

    DOT11_AUTH_ALGO_WPA = 3,

    DOT11_AUTH_ALGO_WPA_PSK = 4,

    DOT11_AUTH_ALGO_WPA_NONE = 5,

    DOT11_AUTH_ALGO_RSNA = 6,

    DOT11_AUTH_ALGO_RSNA_PSK = 7,

    DOT11_AUTH_ALGO_IHV_START = 0x80000000,

    DOT11_AUTH_ALGO_IHV_END = 0xffffffff

};

enum DOT11_CIPHER_ALGORITHM {

    DOT11_CIPHER_ALGO_NONE = 0x00,

    DOT11_CIPHER_ALGO_WEP40 = 0x01,

    DOT11_CIPHER_ALGO_TKIP = 0x02,

    DOT11_CIPHER_ALGO_CCMP = 0x04,

    DOT11_CIPHER_ALGO_WEP104 = 0x05,

    DOT11_CIPHER_ALGO_WPA_USE_GROUP = 0x100,

    DOT11_CIPHER_ALGO_RSN_USE_GROUP = 0x100,

    DOT11_CIPHER_ALGO_WEP = 0x101,

    DOT11_CIPHER_ALGO_IHV_START = 0x80000000,

    DOT11_CIPHER_ALGO_IHV_END = 0xffffffff

};

enum DOT11_BSS_TYPE {

    dot11_BSS_type_infrastructure = 1,

    dot11_BSS_type_independent = 2,

    dot11_BSS_type_any = 3

};

struct DOT11_SSID {

    ULONG uSSIDLength;

    UCHAR ucSSID[DOT11_SSID_MAX_LENGTH];

};

typedef UCHAR DOT11_MAC_ADDRESS[6];

struct WLAN_ASSOCIATION_ATTRIBUTES {

    DOT11_SSID dot11Ssid;

    DOT11_BSS_TYPE dot11BssType;

    DOT11_MAC_ADDRESS dot11Bssid;

    DOT11_PHY_TYPE dot11PhyType;

    ULONG uDot11PhyIndex;

    ULONG wlanSignalQuality;

    ULONG ulRxRate;

    ULONG ulTxRate;

};

struct WLAN_SECURITY_ATTRIBUTES {

    BOOL bSecurityEnabled;

    BOOL bOneXEnabled;

    DOT11_AUTH_ALGORITHM dot11AuthAlgorithm;

    DOT11_CIPHER_ALGORITHM dot11CipherAlgorithm;

};

struct WLAN_CONNECTION_ATTRIBUTES {

    WLAN_INTERFACE_STATE isState;

    WLAN_CONNECTION_MODE wlanConnectionMode;

    WCHAR strProfileName[WLAN_MAX_NAME_LENGTH];

    WLAN_ASSOCIATION_ATTRIBUTES wlanAssociationAttributes;

    WLAN_SECURITY_ATTRIBUTES wlanSecurityAttributes;

};

enum WLAN_NOTIFICATION_ACM {

    wlan_notification_acm_start = 0,

    wlan_notification_acm_autoconf_enabled,

    wlan_notification_acm_autoconf_disabled,

    wlan_notification_acm_background_scan_enabled,

    wlan_notification_acm_background_scan_disabled,

    wlan_notification_acm_bss_type_change,

    wlan_notification_acm_power_setting_change,

    wlan_notification_acm_scan_complete,

    wlan_notification_acm_scan_fail,

    wlan_notification_acm_connection_start,

    wlan_notification_acm_connection_complete,

    wlan_notification_acm_connection_attempt_fail,

    wlan_notification_acm_filter_list_change,

    wlan_notification_acm_interface_arrival,

    wlan_notification_acm_interface_removal,

    wlan_notification_acm_profile_change,

    wlan_notification_acm_profile_name_change,

    wlan_notification_acm_profiles_exhausted,

    wlan_notification_acm_network_not_available,

    wlan_notification_acm_network_available,

    wlan_notification_acm_disconnecting,

    wlan_notification_acm_disconnected,

    wlan_notification_acm_adhoc_network_state_change,

    wlan_notification_acm_end

};

enum _WLAN_NOTIFICATION_MSM {

    wlan_notification_msm_start = 0,

    wlan_notification_msm_associating,

    wlan_notification_msm_associated,

    wlan_notification_msm_authenticating,

    wlan_notification_msm_connected,

    wlan_notification_msm_roaming_start,

    wlan_notification_msm_roaming_end,

    wlan_notification_msm_radio_state_change,

    wlan_notification_msm_signal_quality_change,

    wlan_notification_msm_disassociating,

    wlan_notification_msm_disconnected,

    wlan_notification_msm_peer_join,

    wlan_notification_msm_peer_leave,

    wlan_notification_msm_adapter_removal,

    wlan_notification_msm_adapter_operation_mode_change,

    wlan_notification_msm_end

};

typedef void (WINAPI *WLAN_NOTIFICATION_CALLBACK) (WLAN_NOTIFICATION_DATA *, PVOID);

#define _WCHAR_T_DEFINED

#define _TIME64_T_DEFINED

typedef struct _BLUETOOTH_FIND_RADIO_PARAMS {

    DWORD   dwSize;             //  IN  sizeof this structure

} BLUETOOTH_FIND_RADIO_PARAMS;

typedef DWORD (WINAPI *WlanOpenHandleProto)

    (DWORD dwClientVersion, PVOID pReserved, PDWORD pdwNegotiatedVersion, PHANDLE phClientHandle);

static WlanOpenHandleProto local_WlanOpenHandle = 0;

typedef DWORD (WINAPI *WlanCloseHandleProto)(HANDLE hClientHandle, PVOID pReserved);

static WlanCloseHandleProto local_WlanCloseHandle = 0;

#if !defined(Q_OS_WINCE)

typedef DWORD (WINAPI *WlanEnumInterfacesProto)

    (HANDLE hClientHandle, PVOID pReserved, WLAN_INTERFACE_INFO_LIST **ppInterfaceList);

static WlanEnumInterfacesProto local_WlanEnumInterfaces = 0;

typedef DWORD (WINAPI *WlanQueryInterfaceProto)

    (HANDLE hClientHandle, const GUID *pInterfaceGuid, WLAN_INTF_OPCODE OpCode, PVOID pReserved,

     PDWORD pdwDataSize, PVOID *ppData, WLAN_OPCODE_VALUE_TYPE *pWlanOpcodeValueType);

static WlanQueryInterfaceProto local_WlanQueryInterface = 0;

typedef DWORD (WINAPI *WlanRegisterNotificationProto)

    (HANDLE hClientHandle, DWORD dwNotifSource, BOOL bIgnoreDuplicate,

     WLAN_NOTIFICATION_CALLBACK funcCallback, PVOID pCallbackContext,

     PVOID pReserved, PDWORD pdwPrevNotifSource);

static WlanRegisterNotificationProto local_WlanRegisterNotification = 0;

#endif

typedef VOID (WINAPI *WlanFreeMemoryProto)(PVOID pMemory);

static WlanFreeMemoryProto local_WlanFreeMemory = 0;

typedef BOOL (WINAPI *BluetoothFindRadioClose)(HANDLE hFind);

static BluetoothFindRadioClose local_BluetoothFindRadioClose=0;

typedef HANDLE (WINAPI *BluetoothFindFirstRadio)(const BLUETOOTH_FIND_RADIO_PARAMS * pbtfrp,HANDLE * phRadio);

static BluetoothFindFirstRadio local_BluetoothFindFirstRadio=0;

QTM_BEGIN_NAMESPACE

Q_GLOBAL_STATIC_WITH_ARGS(QMutex, dynamicLoadMutex, (QMutex::Recursive));

static void resolveLibrary()

{

#if !defined( Q_OS_WINCE)

            static volatile bool triedResolve = false;

    if (!triedResolve) {

#ifndef QT_NO_THREAD

        QMutexLocker locker(dynamicLoadMutex());

#endif

        if (!triedResolve) {

            local_WlanOpenHandle = (WlanOpenHandleProto)

                                   QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanOpenHandle");

            local_WlanRegisterNotification = (WlanRegisterNotificationProto)

                                             QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanRegisterNotification");

            local_WlanEnumInterfaces = (WlanEnumInterfacesProto)

                                       QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanEnumInterfaces");

            local_WlanQueryInterface = (WlanQueryInterfaceProto)

                                       QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanQueryInterface");

            local_WlanFreeMemory = (WlanFreeMemoryProto)

                                   QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanFreeMemory");

            local_WlanCloseHandle = (WlanCloseHandleProto)

                                    QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanCloseHandle");

            local_BluetoothFindFirstRadio = (BluetoothFindFirstRadio)

                                            QLibrary::resolve(QLatin1String("Bthprops.cpl"), "BluetoothFindFirstRadio");

            local_BluetoothFindRadioClose = (BluetoothFindRadioClose)

                                            QLibrary::resolve(QLatin1String("Bthprops.cpl"), "BluetoothFindRadioClose");

            triedResolve = true;

        }

    }

#endif

}

Q_GLOBAL_STATIC(QSystemNetworkInfoPrivate, qsystemNetworkInfoPrivate)

typedef struct _DISPLAY_BRIGHTNESS {

    UCHAR ucDisplayPolicy;

    UCHAR ucACBrightness;

    UCHAR ucDCBrightness;

} DISPLAY_BRIGHTNESS, *PDISPLAY_BRIGHTNESS;

#if !defined( Q_CC_MINGW) && !defined( Q_OS_WINCE)

static WLAN_CONNECTION_ATTRIBUTES *getWifiConnectionAttributes()

{

    if(!local_WlanOpenHandle)

        return NULL;

    DWORD version =  0;

    HANDLE clientHandle = NULL;

    DWORD result;

    WLAN_CONNECTION_ATTRIBUTES  *connAtts = NULL;

    WLAN_INTERFACE_INFO_LIST *interfacesInfoList = NULL;

    result = local_WlanOpenHandle( 2, NULL, &version, &clientHandle );

    if( result != ERROR_SUCCESS) {

        local_WlanFreeMemory(connAtts);

        local_WlanCloseHandle(clientHandle,  0);

        return NULL;

    }

    result = local_WlanEnumInterfaces(clientHandle, NULL, &interfacesInfoList);

    if( result != ERROR_SUCCESS) {

        local_WlanCloseHandle(clientHandle, NULL);

        local_WlanFreeMemory(connAtts);

        return NULL;

    }

    for( uint i = 0; i < interfacesInfoList->dwNumberOfItems; i++ ) {

        WLAN_INTERFACE_INFO *interfaceInfo = &interfacesInfoList->InterfaceInfo[i];

        GUID& guid = interfaceInfo->InterfaceGuid;

        WLAN_INTERFACE_STATE wlanInterfaceState = interfaceInfo->isState;

        if( wlanInterfaceState == wlan_interface_state_not_ready ) {

            continue;

        }

        ULONG size = 0;

        result = local_WlanQueryInterface( clientHandle, &guid,  wlan_intf_opcode_current_connection, NULL, &size, (PVOID*) &connAtts, NULL );

        if( result != ERROR_SUCCESS ) {

            continue;

        }

    }

    local_WlanCloseHandle(clientHandle, NULL);

    return connAtts;

}

#endif

QSystemInfoPrivate::QSystemInfoPrivate(QObject *parent)

 : QObject(parent)

{

    currentLanguageStr = currentLanguage();

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

}

QSystemInfoPrivate::~QSystemInfoPrivate()

{

}

void QSystemInfoPrivate::currentLanguageTimeout()

{

    const QString tmpLang = currentLanguage();

    if(currentLanguageStr != tmpLang) {

        currentLanguageStr = tmpLang;

        emit currentLanguageChanged(currentLanguageStr);

    }

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

}

QString QSystemInfoPrivate::currentLanguage() const

{

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

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

        lang = "en";

    }

    return lang;

}

QStringList QSystemInfoPrivate::availableLanguages() const

{

    QDir transDir(QLibraryInfo::location (QLibraryInfo::TranslationsPath));

    QStringList langList;

    if(transDir.exists()) {

        QStringList localeList = transDir.entryList( QStringList() << "qt_*.qm" ,QDir::Files

                                                     | QDir::NoDotAndDotDot, QDir::Name);

        foreach(const QString localeName, localeList) {

            const QString lang = localeName.mid(3,2);

            if(!langList.contains(lang) && !lang.isEmpty() && !lang.contains("help")) {

                langList << lang;

            }

        }

        if(!langList.isEmpty()) {

            return langList;

        }

    }

    return QStringList() << currentLanguage();

}

QString QSystemInfoPrivate::version(QSystemInfo::Version type,  const QString &parameter)

{

    Q_UNUSED(parameter);

    QString errorStr = "Not Available";

    bool useDate = false;

    if(parameter == "versionDate") {

        useDate = true;

    }

    switch(type) {

    case QSystemInfo::Os :

        {

#if !defined(Q_OS_WINCE)

            OSVERSIONINFOEX versionInfo;

            versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

            GetVersionEx((OSVERSIONINFO *) &versionInfo);

            return QString::number(versionInfo.dwMajorVersion) +"."

                    +QString::number(versionInfo.dwMinorVersion)+"."

                    +QString::number(versionInfo.dwBuildNumber)+"."

                    +QString::number(versionInfo.wServicePackMajor)+"."

                    +QString::number(versionInfo.wServicePackMinor);

#else