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

**

** 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 QtCore module of the Qt Toolkit.

**

** $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 <qdebug.h>

#include "qplatformdefs.h"

#include "qsettings.h"

#ifndef QT_NO_SETTINGS

#include "qsettings_p.h"

#include "qcache.h"

#include "qfile.h"

#include "qdir.h"

#include "qfileinfo.h"

#include "qmutex.h"

#include "qlibraryinfo.h"

#include "qtemporaryfile.h"

#ifndef QT_NO_TEXTCODEC

#  include "qtextcodec.h"

#endif

#ifndef QT_NO_GEOM_VARIANT

#include "qsize.h"

#include "qpoint.h"

#include "qrect.h"

#endif // !QT_NO_GEOM_VARIANT

#ifndef QT_NO_QOBJECT

#include "qcoreapplication.h"

#ifdef Q_OS_WIN // for homedirpath reading from registry

#include "qt_windows.h"

#include "qlibrary.h"

#endif // Q_OS_WIN

#endif // QT_NO_QOBJECT

#ifdef Q_OS_VXWORKS

#  include <ioLib.h>

#endif

#include <stdlib.h>

#ifndef CSIDL_COMMON_APPDATA

#define CSIDL_COMMON_APPDATA	0x0023  // All Users\Application Data

#endif

#ifndef CSIDL_APPDATA

#define CSIDL_APPDATA		0x001a	// <username>\Application Data

#endif

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

// QConfFile

/*

    QConfFile objects are explicitly shared within the application.

    This ensures that modification to the settings done through one

    QSettings object are immediately reflected in other setting

    objects of the same application.

*/

QT_BEGIN_NAMESPACE

struct QConfFileCustomFormat

{

    QString extension;

    QSettings::ReadFunc readFunc;

    QSettings::WriteFunc writeFunc;

    Qt::CaseSensitivity caseSensitivity;

};

typedef QHash<QString, QConfFile *> ConfFileHash;

typedef QCache<QString, QConfFile> ConfFileCache;

typedef QHash<int, QString> PathHash;

typedef QVector<QConfFileCustomFormat> CustomFormatVector;

Q_GLOBAL_STATIC(ConfFileHash, usedHashFunc)

Q_GLOBAL_STATIC(ConfFileCache, unusedCacheFunc)

Q_GLOBAL_STATIC(PathHash, pathHashFunc)

Q_GLOBAL_STATIC(CustomFormatVector, customFormatVectorFunc)

Q_GLOBAL_STATIC(QMutex, globalMutex)

static QSettings::Format globalDefaultFormat = QSettings::NativeFormat;

#ifndef Q_OS_WIN

inline bool qt_isEvilFsTypeName(const char *name)

{

    return (qstrncmp(name, "nfs", 3) == 0

            || qstrncmp(name, "autofs", 6) == 0

            || qstrncmp(name, "cachefs", 7) == 0);

}

#if defined(Q_OS_BSD4) && !defined(Q_OS_NETBSD)

QT_BEGIN_INCLUDE_NAMESPACE

# include <sys/param.h>

# include <sys/mount.h>

QT_END_INCLUDE_NAMESPACE

static bool isLikelyToBeNfs(int handle)

{

    struct statfs buf;

    if (fstatfs(handle, &buf) != 0)

        return false;

    return qt_isEvilFsTypeName(buf.f_fstypename);

}

#elif defined(Q_OS_LINUX) || defined(Q_OS_HURD)

QT_BEGIN_INCLUDE_NAMESPACE

# include <sys/vfs.h>

# ifdef QT_LINUXBASE

   // LSB 3.2 has fstatfs in sys/statfs.h, sys/vfs.h is just an empty dummy header

#  include <sys/statfs.h>

# endif

QT_END_INCLUDE_NAMESPACE

# ifndef NFS_SUPER_MAGIC

#  define NFS_SUPER_MAGIC       0x00006969

# endif

# ifndef AUTOFS_SUPER_MAGIC

#  define AUTOFS_SUPER_MAGIC    0x00000187

# endif

# ifndef AUTOFSNG_SUPER_MAGIC

#  define AUTOFSNG_SUPER_MAGIC  0x7d92b1a0

# endif

static bool isLikelyToBeNfs(int handle)

{

    struct statfs buf;

    if (fstatfs(handle, &buf) != 0)

        return false;

    return buf.f_type == NFS_SUPER_MAGIC

           || buf.f_type == AUTOFS_SUPER_MAGIC

           || buf.f_type == AUTOFSNG_SUPER_MAGIC;

}

#elif defined(Q_OS_SOLARIS) || defined(Q_OS_IRIX) || defined(Q_OS_AIX) || defined(Q_OS_HPUX) \

      || defined(Q_OS_OSF) || defined(Q_OS_QNX) || defined(Q_OS_SCO) \

      || defined(Q_OS_UNIXWARE) || defined(Q_OS_RELIANT) || defined(Q_OS_NETBSD)

QT_BEGIN_INCLUDE_NAMESPACE

# include <sys/statvfs.h>

QT_END_INCLUDE_NAMESPACE

static bool isLikelyToBeNfs(int handle)

{

    struct statvfs buf;

    if (fstatvfs(handle, &buf) != 0)

        return false;

#if defined(Q_OS_NETBSD)

    return qt_isEvilFsTypeName(buf.f_fstypename);

#else

    return qt_isEvilFsTypeName(buf.f_basetype);

#endif

}

#else

static inline bool isLikelyToBeNfs(int /* handle */)

{

    return true;

}

#endif

static bool unixLock(int handle, int lockType)

{

    /*

        NFS hangs on the fcntl() call below when statd or lockd isn't

        running. There's no way to detect this. Our work-around for

        now is to disable locking when we detect NFS (or AutoFS or

        CacheFS, which are probably wrapping NFS).

    */

    if (isLikelyToBeNfs(handle))

        return false;

    struct flock fl;

    fl.l_whence = SEEK_SET;

    fl.l_start = 0;

    fl.l_len = 0;

    fl.l_type = lockType;

    return fcntl(handle, F_SETLKW, &fl) == 0;

}

#endif

QConfFile::QConfFile(const QString &fileName, bool _userPerms)

    : name(fileName), size(0), ref(1), userPerms(_userPerms)

{

    usedHashFunc()->insert(name, this);

}

QConfFile::~QConfFile()

{

    if (usedHashFunc())

        usedHashFunc()->remove(name);

}

ParsedSettingsMap QConfFile::mergedKeyMap() const

{

    ParsedSettingsMap result = originalKeys;

    ParsedSettingsMap::const_iterator i;

    for (i = removedKeys.begin(); i != removedKeys.end(); ++i)

        result.remove(i.key());

    for (i = addedKeys.begin(); i != addedKeys.end(); ++i)

        result.insert(i.key(), i.value());

    return result;

}

bool QConfFile::isWritable() const

{

    QFileInfo fileInfo(name);

#ifndef QT_NO_TEMPORARYFILE

    if (fileInfo.exists()) {

#endif

        QFile file(name);

        return file.open(QFile::ReadWrite);

#ifndef QT_NO_TEMPORARYFILE

    } else {

        // Create the directories to the file.

        QDir dir(fileInfo.absolutePath());

        if (dir.exists() && dir.isReadable()) {

            return true;

        } else {

            if (!dir.mkpath(dir.absolutePath()))

                return false;

        }

        // we use a temporary file to avoid race conditions

        QTemporaryFile file(name);

        return file.open();

    }

#endif

}

QConfFile *QConfFile::fromName(const QString &fileName, bool _userPerms)

{

    QString absPath = QFileInfo(fileName).absoluteFilePath();

    ConfFileHash *usedHash = usedHashFunc();

    ConfFileCache *unusedCache = unusedCacheFunc();

    QConfFile *confFile = 0;

    QMutexLocker locker(globalMutex());

    if (!(confFile = usedHash->value(absPath))) {

        if ((confFile = unusedCache->take(absPath)))

            usedHash->insert(absPath, confFile);

    }

    if (confFile) {

        confFile->ref.ref();

        return confFile;

    }

    return new QConfFile(absPath, _userPerms);

}

void QConfFile::clearCache()

{

    QMutexLocker locker(globalMutex());

    unusedCacheFunc()->clear();

}

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

// QSettingsPrivate

QSettingsPrivate::QSettingsPrivate(QSettings::Format format)

    : format(format), scope(QSettings::UserScope /* nothing better to put */), iniCodec(0), spec(0), fallbacks(true),

      pendingChanges(false), status(QSettings::NoError)

{

}

QSettingsPrivate::QSettingsPrivate(QSettings::Format format, QSettings::Scope scope,

                                   const QString &organization, const QString &application)

    : format(format), scope(scope), organizationName(organization), applicationName(application),

      iniCodec(0), spec(0), fallbacks(true), pendingChanges(false), status(QSettings::NoError)

{

}

QSettingsPrivate::~QSettingsPrivate()

{

}

QString QSettingsPrivate::actualKey(const QString &key) const

{

    QString n = normalizedKey(key);

    Q_ASSERT_X(!n.isEmpty(), "QSettings", "empty key");

    n.prepend(groupPrefix);

    return n;

}

/*

    Returns a string that never starts nor ends with a slash (or an

    empty string). Examples:

            "foo"            becomes   "foo"

            "/foo//bar///"   becomes   "foo/bar"

            "///"            becomes   ""

    This function is optimized to avoid a QString deep copy in the

    common case where the key is already normalized.

*/

QString QSettingsPrivate::normalizedKey(const QString &key)

{

    QString result = key;

    int i = 0;

    while (i < result.size()) {

        while (result.at(i) == QLatin1Char('/')) {

            result.remove(i, 1);

            if (i == result.size())

                goto after_loop;

        }

        while (result.at(i) != QLatin1Char('/')) {

            ++i;

            if (i == result.size())

                return result;

        }

        ++i; // leave the slash alone

    }

after_loop:

    if (!result.isEmpty())

        result.truncate(i - 1); // remove the trailing slash

    return result;

}

// see also qsettings_win.cpp and qsettings_mac.cpp

#if !defined(Q_OS_WIN) && !defined(Q_OS_MAC)

QSettingsPrivate *QSettingsPrivate::create(QSettings::Format format, QSettings::Scope scope,

                                           const QString &organization, const QString &application)

{

    return new QConfFileSettingsPrivate(format, scope, organization, application);

}

#endif

#if !defined(Q_OS_WIN)

QSettingsPrivate *QSettingsPrivate::create(const QString &fileName, QSettings::Format format)

{

    return new QConfFileSettingsPrivate(fileName, format);

}

#endif

void QSettingsPrivate::processChild(QString key, ChildSpec spec, QMap<QString, QString> &result)

{

    if (spec != AllKeys) {

        int slashPos = key.indexOf(QLatin1Char('/'));

        if (slashPos == -1) {

            if (spec != ChildKeys)

                return;

        } else {

            if (spec != ChildGroups)

                return;

            key.truncate(slashPos);

        }

    }

    result.insert(key, QString());

}

void QSettingsPrivate::beginGroupOrArray(const QSettingsGroup &group)

{

    groupStack.push(group);

    if (!group.name().isEmpty()) {

        groupPrefix += group.name();

        groupPrefix += QLatin1Char('/');

    }

}

/*

    We only set an error if there isn't one set already. This way the user always gets the

    first error that occurred. We always allow clearing errors.

*/

void QSettingsPrivate::setStatus(QSettings::Status status) const

{

    if (status == QSettings::NoError || this->status == QSettings::NoError)

        this->status = status;

}

void QSettingsPrivate::update()

{

    flush();

    pendingChanges = false;

}

void QSettingsPrivate::requestUpdate()

{

    if (!pendingChanges) {

        pendingChanges = true;

#ifndef QT_NO_QOBJECT

        Q_Q(QSettings);

        QCoreApplication::postEvent(q, new QEvent(QEvent::UpdateRequest));

#else

        update();

#endif

    }

}

QStringList QSettingsPrivate::variantListToStringList(const QVariantList &l)

{

    QStringList result;

    QVariantList::const_iterator it = l.constBegin();

    for (; it != l.constEnd(); ++it)

        result.append(variantToString(*it));

    return result;

}

QVariant QSettingsPrivate::stringListToVariantList(const QStringList &l)

{

    QStringList outStringList = l;

    for (int i = 0; i < outStringList.count(); ++i) {

        const QString &str = outStringList.at(i);

        if (str.startsWith(QLatin1Char('@'))) {

            if (str.length() >= 2 && str.at(1) == QLatin1Char('@')) {

                outStringList[i].remove(0, 1);

            } else {

                QVariantList variantList;

                for (int j = 0; j < l.count(); ++j)

                    variantList.append(stringToVariant(l.at(j)));

                return variantList;

            }

        }

    }

    return outStringList;

}

QString QSettingsPrivate::variantToString(const QVariant &v)

{

    QString result;

    switch (v.type()) {

        case QVariant::Invalid:

            result = QLatin1String("@Invalid()");

            break;

        case QVariant::ByteArray: {

            QByteArray a = v.toByteArray();

            result = QLatin1String("@ByteArray(");

            result += QString::fromLatin1(a.constData(), a.size());

            result += QLatin1Char(')');

            break;

        }

        case QVariant::String:

        case QVariant::LongLong:

        case QVariant::ULongLong:

        case QVariant::Int:

        case QVariant::UInt:

        case QVariant::Bool:

        case QVariant::Double:

        case QVariant::KeySequence: {

            result = v.toString();

            if (result.startsWith(QLatin1Char('@')))

                result.prepend(QLatin1Char('@'));

            break;

        }

#ifndef QT_NO_GEOM_VARIANT

        case QVariant::Rect: {

            QRect r = qvariant_cast<QRect>(v);

            result += QLatin1String("@Rect(");

            result += QString::number(r.x());

            result += QLatin1Char(' ');

            result += QString::number(r.y());

            result += QLatin1Char(' ');

            result += QString::number(r.width());

            result += QLatin1Char(' ');

            result += QString::number(r.height());

            result += QLatin1Char(')');

            break;

        }

        case QVariant::Size: {

            QSize s = qvariant_cast<QSize>(v);

            result += QLatin1String("@Size(");

            result += QString::number(s.width());

            result += QLatin1Char(' ');

            result += QString::number(s.height());

            result += QLatin1Char(')');

            break;

        }

        case QVariant::Point: {

            QPoint p = qvariant_cast<QPoint>(v);

            result += QLatin1String("@Point(");

            result += QString::number(p.x());

            result += QLatin1Char(' ');

            result += QString::number(p.y());

            result += QLatin1Char(')');

            break;

        }

#endif // !QT_NO_GEOM_VARIANT

        default: {

#ifndef QT_NO_DATASTREAM

            QByteArray a;

            {