Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:critical reason:data-parser
++
++ #include "qsettings.h"
++
++ #include "qsettings_p.h"
++ #include "qdatetime.h"
++ #include "qdir.h"
++ #include "qvarlengtharray.h"
++ #include "private/qcore_mac_p.h"
++ #ifndef QT_NO_QOBJECT
++ #include "qcoreapplication.h"
++ #endif // QT_NO_QOBJECT
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ static const CFStringRef hostNames[2] = { kCFPreferencesCurrentHost, kCFPreferencesAnyHost };
++ static const int numHostNames = 2;
++
++ /*
++ On the Mac, it is more natural to use '.' as the key separator
++ than '/'. Therefore, it makes sense to replace '/' with '.' in
++ keys. Then we replace '.' with middle dots (which we can't show
++ here) and middle dots with '/'. A key like "4.0/BrowserCommand"
++ becomes "4<middot>0.BrowserCommand".
++ */
++
++ enum RotateShift { Macify = 1, Qtify = 2 };
++
++ static QString rotateSlashesDotsAndMiddots(const QString &key, int shift)
++ {
++ static const int NumKnights = 3;
++ static const char knightsOfTheRoundTable[NumKnights] = { '/', '.', '\xb7' };
++ QString result = key;
++
++ for (int i = 0; i < result.size(); ++i) {
++ for (int j = 0; j < NumKnights; ++j) {
++ if (result.at(i) == QLatin1Char(knightsOfTheRoundTable[j])) {
++ result[i] = QLatin1Char(knightsOfTheRoundTable[(j + shift) % NumKnights]).unicode();
++ break;
++ }
++ }
++ }
++ return result;
++ }
++
++ static QCFType<CFStringRef> macKey(const QString &key)
++ {
++ return rotateSlashesDotsAndMiddots(key, Macify).toCFString();
++ }
++
++ static QString qtKey(CFStringRef cfkey)
++ {
++ return rotateSlashesDotsAndMiddots(QString::fromCFString(cfkey), Qtify);
++ }
++
++ static QCFType<CFPropertyListRef> macValue(const QVariant &value);
++
++ static CFArrayRef macList(const QList<QVariant> &list)
++ {
++ int n = list.size();
++ QVarLengthArray<QCFType<CFPropertyListRef>> cfvalues(n);
++ for (int i = 0; i < n; ++i)
++ cfvalues[i] = macValue(list.at(i));
++ return CFArrayCreate(kCFAllocatorDefault, reinterpret_cast<const void **>(cfvalues.data()),
++ CFIndex(n), &kCFTypeArrayCallBacks);
++ }
++
++ static QCFType<CFPropertyListRef> macValue(const QVariant &value)
++ {
++ CFPropertyListRef result = 0;
++
++ switch (value.metaType().id()) {
++ case QMetaType::QByteArray:
++ {
++ QByteArray ba = value.toByteArray();
++ result = CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(ba.data()),
++ CFIndex(ba.size()));
++ }
++ break;
++ // should be same as below (look for LIST)
++ case QMetaType::QVariantList:
++ case QMetaType::QStringList:
++ case QMetaType::QPolygon:
++ result = macList(value.toList());
++ break;
++ case QMetaType::QVariantMap:
++ {
++ const QVariantMap &map = value.toMap();
++ const int mapSize = map.size();
++
++ QVarLengthArray<QCFType<CFPropertyListRef>> cfkeys;
++ cfkeys.reserve(mapSize);
++ std::transform(map.keyBegin(), map.keyEnd(),
++ std::back_inserter(cfkeys),
++ [](const auto &key) { return key.toCFString(); });
++
++ QVarLengthArray<QCFType<CFPropertyListRef>> cfvalues;
++ cfvalues.reserve(mapSize);
++ std::transform(map.begin(), map.end(),
++ std::back_inserter(cfvalues),
++ [](const auto &value) { return macValue(value); });
++
++ result = CFDictionaryCreate(kCFAllocatorDefault,
++ reinterpret_cast<const void **>(cfkeys.data()),
++ reinterpret_cast<const void **>(cfvalues.data()),
++ CFIndex(mapSize),
++ &kCFTypeDictionaryKeyCallBacks,
++ &kCFTypeDictionaryValueCallBacks);
++ }
++ break;
++ case QMetaType::QDateTime:
++ {
++ QDateTime dateTime = value.toDateTime();
++ // CFDate, unlike QDateTime, doesn't store timezone information
++ if (dateTime.timeSpec() == Qt::LocalTime)
++ result = dateTime.toCFDate();
++ else
++ goto string_case;
++ }
++ break;
++ case QMetaType::Bool:
++ result = value.toBool() ? kCFBooleanTrue : kCFBooleanFalse;
++ break;
++ case QMetaType::Int:
++ case QMetaType::UInt:
++ {
++ int n = value.toInt();
++ result = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &n);
++ }
++ break;
++ case QMetaType::Double:
++ {
++ double n = value.toDouble();
++ result = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &n);
++ }
++ break;
++ case QMetaType::LongLong:
++ case QMetaType::ULongLong:
++ {
++ qint64 n = value.toLongLong();
++ result = CFNumberCreate(0, kCFNumberLongLongType, &n);
++ }
++ break;
++ case QMetaType::QString:
++ string_case:
++ default:
++ QString string = QSettingsPrivate::variantToString(value);
++ if (string.contains(QChar::Null))
++ result = std::move(string).toUtf8().toCFData();
++ else
++ result = string.toCFString();
++ }
++ return result;
++ }
++
++ static QVariant qtValue(CFPropertyListRef cfvalue)
++ {
++ if (!cfvalue)
++ return QVariant();
++
++ CFTypeID typeId = CFGetTypeID(cfvalue);
++
++ /*
++ Sorted grossly from most to least frequent type.
++ */
++ if (typeId == CFStringGetTypeID()) {
++ return QSettingsPrivate::stringToVariant(QString::fromCFString(static_cast<CFStringRef>(cfvalue)));
++ } else if (typeId == CFNumberGetTypeID()) {
++ CFNumberRef cfnumber = static_cast<CFNumberRef>(cfvalue);
++ if (CFNumberIsFloatType(cfnumber)) {
++ double d;
++ CFNumberGetValue(cfnumber, kCFNumberDoubleType, &d);
++ return d;
++ } else {
++ int i;
++ qint64 ll;
++
++ if (CFNumberGetType(cfnumber) == kCFNumberIntType) {
++ CFNumberGetValue(cfnumber, kCFNumberIntType, &i);
++ return i;
++ }
++ CFNumberGetValue(cfnumber, kCFNumberLongLongType, &ll);
++ return ll;
++ }
++ } else if (typeId == CFArrayGetTypeID()) {
++ CFArrayRef cfarray = static_cast<CFArrayRef>(cfvalue);
++ QList<QVariant> list;
++ CFIndex size = CFArrayGetCount(cfarray);
++ bool metNonString = false;
++ for (CFIndex i = 0; i < size; ++i) {
++ QVariant value = qtValue(CFArrayGetValueAtIndex(cfarray, i));
++ if (value.typeId() != QMetaType::QString)
++ metNonString = true;
++ list << value;
++ }
++ if (metNonString)
++ return list;
++ else
++ return QVariant(list).toStringList();
++ } else if (typeId == CFBooleanGetTypeID()) {
++ return (bool)CFBooleanGetValue(static_cast<CFBooleanRef>(cfvalue));
++ } else if (typeId == CFDataGetTypeID()) {
++ QByteArray byteArray = QByteArray::fromRawCFData(static_cast<CFDataRef>(cfvalue));
++
++ // Fast-path for QByteArray, so that we don't have to go
++ // though the expensive and lossy conversion via UTF-8.
++ if (!byteArray.startsWith('@')) {
++ byteArray.detach();
++ return byteArray;
++ }
++
++ const QString str = QString::fromUtf8(byteArray.constData(), byteArray.size());
++ QVariant variant = QSettingsPrivate::stringToVariant(str);
++ if (variant == QVariant(str)) {
++ // We did not find an encoded variant in the string,
++ // so return the raw byte array instead.
++ byteArray.detach();
++ return byteArray;
++ }
++
++ return variant;
++ } else if (typeId == CFDictionaryGetTypeID()) {
++ CFDictionaryRef cfdict = static_cast<CFDictionaryRef>(cfvalue);
++ CFTypeID arrayTypeId = CFArrayGetTypeID();
++ int size = (int)CFDictionaryGetCount(cfdict);
++ QVarLengthArray<CFPropertyListRef> keys(size);
++ QVarLengthArray<CFPropertyListRef> values(size);
++ CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
++
++ QVariantMap map;
++ for (int i = 0; i < size; ++i) {
++ QString key = QString::fromCFString(static_cast<CFStringRef>(keys[i]));
++
++ if (CFGetTypeID(values[i]) == arrayTypeId) {
++ CFArrayRef cfarray = static_cast<CFArrayRef>(values[i]);
++ CFIndex arraySize = CFArrayGetCount(cfarray);
++ QVariantList list;
++ list.reserve(arraySize);
++ for (CFIndex j = 0; j < arraySize; ++j)
++ list.append(qtValue(CFArrayGetValueAtIndex(cfarray, j)));
++ map.insert(key, list);
++ } else {
++ map.insert(key, qtValue(values[i]));
++ }
++ }
++ return map;
++ } else if (typeId == CFDateGetTypeID()) {
++ return QDateTime::fromCFDate(static_cast<CFDateRef>(cfvalue));
++ }
++ return QVariant();
++ }
++
++ static QString comify(const QString &organization)
++ {
++ for (int i = organization.size() - 1; i >= 0; --i) {
++ QChar ch = organization.at(i);
++ if (ch == u'.' || ch == QChar(0x3002) || ch == QChar(0xff0e)
++ || ch == QChar(0xff61)) {
++ QString suffix = organization.mid(i + 1).toLower();
++ if (suffix.size() == 2 || suffix == "com"_L1 || suffix == "org"_L1
++ || suffix == "net"_L1 || suffix == "edu"_L1 || suffix == "gov"_L1
++ || suffix == "mil"_L1 || suffix == "biz"_L1 || suffix == "info"_L1
++ || suffix == "name"_L1 || suffix == "pro"_L1 || suffix == "aero"_L1
++ || suffix == "coop"_L1 || suffix == "museum"_L1) {
++ QString result = organization;
++ result.replace(u'/', u' ');
++ return result;
++ }
++ break;
++ }
++ int uc = ch.unicode();
++ if ((uc < 'a' || uc > 'z') && (uc < 'A' || uc > 'Z'))
++ break;
++ }
++
++ QString domain;
++ for (int i = 0; i < organization.size(); ++i) {
++ QChar ch = organization.at(i);
++ int uc = ch.unicode();
++ if ((uc >= 'a' && uc <= 'z') || (uc >= '0' && uc <= '9')) {
++ domain += ch;
++ } else if (uc >= 'A' && uc <= 'Z') {
++ domain += ch.toLower();
++ } else {
++ domain += u' ';
++ }
++ }
++ domain = domain.simplified();
++ domain.replace(u' ', u'-');
++ if (!domain.isEmpty())
++ domain.append(".com"_L1);
++ return domain;
++ }
++
++ class QMacSettingsPrivate : public QSettingsPrivate
++ {
++ public:
++ QMacSettingsPrivate(QSettings::Scope scope, const QString &organization,
++ const QString &application);
++ ~QMacSettingsPrivate();
++
++ void remove(const QString &key) override;
++ void set(const QString &key, const QVariant &value) override;
++ std::optional<QVariant> get(const QString &key) const override;
++ QStringList children(const QString &prefix, ChildSpec spec) const override;
++ void clear() override;
++ void sync() override;
++ void flush() override;
++ bool isWritable() const override;
++ QString fileName() const override;
++
++ private:
++ struct SearchDomain
++ {
++ CFStringRef userName;
++ CFStringRef applicationOrSuiteId;
++ };
++
++ QCFString applicationId;
++ QCFString suiteId;
++ QCFString hostName;
++ SearchDomain domains[6];
++ int numDomains;
++ };
++
++ QMacSettingsPrivate::QMacSettingsPrivate(QSettings::Scope scope, const QString &organization,
++ const QString &application)
++ : QSettingsPrivate(QSettings::NativeFormat, scope, organization, application)
++ {
++ QString javaPackageName;
++ int curPos = 0;
++ int nextDot;
++
++ // attempt to use the organization parameter
++ QString domainName = comify(organization);
++ // if not found, attempt to use the bundle identifier.
++ if (domainName.isEmpty()) {
++ CFBundleRef main_bundle = CFBundleGetMainBundle();
++ if (main_bundle != NULL) {
++ CFStringRef main_bundle_identifier = CFBundleGetIdentifier(main_bundle);
++ if (main_bundle_identifier != NULL) {
++ QString bundle_identifier(qtKey(main_bundle_identifier));
++ // CFBundleGetIdentifier returns identifier separated by slashes rather than periods.
++ QStringList bundle_identifier_components = bundle_identifier.split(u'/');
++ // pre-reverse them so that when they get reversed again below, they are in the com.company.product format.
++ QStringList bundle_identifier_components_reversed;
++ for (int i=0; i<bundle_identifier_components.size(); ++i) {
++ const QString &bundle_identifier_component = bundle_identifier_components.at(i);
++ bundle_identifier_components_reversed.push_front(bundle_identifier_component);
++ }
++ domainName = bundle_identifier_components_reversed.join(u'.');
++ }
++ }
++ }
++ // if no bundle identifier yet. use a hard coded string.
++ if (domainName.isEmpty())
++ domainName = "unknown-organization.trolltech.com"_L1;
++
++ while ((nextDot = domainName.indexOf(u'.', curPos)) != -1) {
++ javaPackageName.prepend(QStringView{domainName}.mid(curPos, nextDot - curPos));
++ javaPackageName.prepend(u'.');
++ curPos = nextDot + 1;
++ }
++ javaPackageName.prepend(QStringView{domainName}.mid(curPos));
++ javaPackageName = std::move(javaPackageName).toLower();
++ if (curPos == 0)
++ javaPackageName.prepend("com."_L1);
++ suiteId = javaPackageName;
++
++ if (!application.isEmpty()) {
++ javaPackageName += u'.' + application;
++ applicationId = javaPackageName;
++ }
++
++ numDomains = 0;
++ for (int i = (scope == QSettings::SystemScope) ? 1 : 0; i < 2; ++i) {
++ for (int j = (application.isEmpty()) ? 1 : 0; j < 3; ++j) {
++ SearchDomain &domain = domains[numDomains++];
++ domain.userName = (i == 0) ? kCFPreferencesCurrentUser : kCFPreferencesAnyUser;
++ if (j == 0)
++ domain.applicationOrSuiteId = applicationId;
++ else if (j == 1)
++ domain.applicationOrSuiteId = suiteId;
++ else
++ domain.applicationOrSuiteId = kCFPreferencesAnyApplication;
++ }
++ }
++
++ hostName = (scope == QSettings::SystemScope) ? kCFPreferencesCurrentHost : kCFPreferencesAnyHost;
++ sync();
++ }
++
++ QMacSettingsPrivate::~QMacSettingsPrivate()
++ {
++ }
++
++ void QMacSettingsPrivate::remove(const QString &key)
++ {
++ QStringList keys = children(key + u'/', AllKeys);
++
++ // If i == -1, then delete "key" itself.
++ for (int i = -1; i < keys.size(); ++i) {
++ QString subKey = key;
++ if (i >= 0) {
++ subKey += u'/';
++ subKey += keys.at(i);
++ }
++ CFPreferencesSetValue(macKey(subKey), 0, domains[0].applicationOrSuiteId,
++ domains[0].userName, hostName);
++ }
++ }
++
++ void QMacSettingsPrivate::set(const QString &key, const QVariant &value)
++ {
++ CFPreferencesSetValue(macKey(key), macValue(value), domains[0].applicationOrSuiteId,
++ domains[0].userName, hostName);
++ }
++
++ std::optional<QVariant> QMacSettingsPrivate::get(const QString &key) const
++ {
++ QCFString k = macKey(key);
++ for (int i = 0; i < numDomains; ++i) {
++ for (int j = 0; j < numHostNames; ++j) {
++ QCFType<CFPropertyListRef> ret =
++ CFPreferencesCopyValue(k, domains[i].applicationOrSuiteId, domains[i].userName,
++ hostNames[j]);
++ if (ret)
++ return qtValue(ret);
++ }
++
++ if (!fallbacks)
++ break;
++ }
++ return std::nullopt;
++ }
++
++ QStringList QMacSettingsPrivate::children(const QString &prefix, ChildSpec spec) const
++ {
++ QStringList result;
++ int startPos = prefix.size();
++
++ for (int i = 0; i < numDomains; ++i) {
++ for (int j = 0; j < numHostNames; ++j) {
++ QCFType<CFArrayRef> cfarray = CFPreferencesCopyKeyList(domains[i].applicationOrSuiteId,
++ domains[i].userName,
++ hostNames[j]);
++ if (cfarray) {
++ CFIndex size = CFArrayGetCount(cfarray);
++ for (CFIndex k = 0; k < size; ++k) {
++ QString currentKey =
++ qtKey(static_cast<CFStringRef>(CFArrayGetValueAtIndex(cfarray, k)));
++ if (currentKey.startsWith(prefix))
++ processChild(QStringView{currentKey}.mid(startPos), spec, result);
++ }
++ }
++ }
++
++ if (!fallbacks)
++ break;
++ }
++ std::sort(result.begin(), result.end());
++ result.erase(std::unique(result.begin(), result.end()),
++ result.end());
++ return result;
++ }
++
++ void QMacSettingsPrivate::clear()
++ {
++ QCFType<CFArrayRef> cfarray = CFPreferencesCopyKeyList(domains[0].applicationOrSuiteId,
++ domains[0].userName, hostName);
++ CFPreferencesSetMultiple(0, cfarray, domains[0].applicationOrSuiteId, domains[0].userName,
++ hostName);
++ }
++
++ void QMacSettingsPrivate::sync()
++ {
++ for (int i = 0; i < numDomains; ++i) {
++ for (int j = 0; j < numHostNames; ++j) {
++ Boolean ok = CFPreferencesSynchronize(domains[i].applicationOrSuiteId,
++ domains[i].userName, hostNames[j]);
++ // only report failures for the primary file (the one we write to)
++ if (!ok && i == 0 && hostNames[j] == hostName && status == QSettings::NoError) {
++ setStatus(QSettings::AccessError);
++ }
++ }
++ }
++ }
++
++ void QMacSettingsPrivate::flush()
++ {
++ sync();
++ }
++
++ bool QMacSettingsPrivate::isWritable() const
++ {
++ QMacSettingsPrivate *that = const_cast<QMacSettingsPrivate *>(this);
++ QString impossibleKey("qt_internal/"_L1);
++
++ QSettings::Status oldStatus = that->status;
++ that->status = QSettings::NoError;
++
++ that->set(impossibleKey, QVariant());
++ that->sync();
++ bool writable = (status == QSettings::NoError) && that->get(impossibleKey).has_value();
++ that->remove(impossibleKey);
++ that->sync();
++
++ that->status = oldStatus;
++ return writable;
++ }
++
++ QString QMacSettingsPrivate::fileName() const
++ {
++ QString result;
++ if (scope == QSettings::UserScope)
++ result = QDir::homePath();
++ result += "/Library/Preferences/"_L1;
++ result += QString::fromCFString(domains[0].applicationOrSuiteId);
++ result += ".plist"_L1;
++ return result;
++ }
++
++ QSettingsPrivate *QSettingsPrivate::create(QSettings::Format format,
++ QSettings::Scope scope,
++ const QString &organization,
++ const QString &application)
++ {
++ #ifndef QT_BOOTSTRAPPED
++ if (organization == "Qt"_L1)
++ {
++ QString organizationDomain = QCoreApplication::organizationDomain();
++ QString applicationName = QCoreApplication::applicationName();
++
++ QSettingsPrivate *newSettings;
++ if (format == QSettings::NativeFormat) {
++ newSettings = new QMacSettingsPrivate(scope, organizationDomain, applicationName);
++ } else {
++ newSettings = new QConfFileSettingsPrivate(format, scope, organizationDomain, applicationName);
++ }
++
++ newSettings->beginGroupOrArray(QSettingsGroup(normalizedKey(organization)));
++ if (!application.isEmpty())
++ newSettings->beginGroupOrArray(QSettingsGroup(normalizedKey(application)));
++
++ return newSettings;
++ }
++ #endif
++ if (format == QSettings::NativeFormat) {
++ return new QMacSettingsPrivate(scope, organization, application);
++ } else {
++ return new QConfFileSettingsPrivate(format, scope, organization, application);
++ }
++ }
++
++ bool QConfFileSettingsPrivate::readPlistFile(const QByteArray &data, ParsedSettingsMap *map) const
++ {
++ QCFType<CFDataRef> cfData = data.toRawCFData();
++ QCFType<CFPropertyListRef> propertyList =
++ CFPropertyListCreateWithData(kCFAllocatorDefault, cfData, kCFPropertyListImmutable, nullptr, nullptr);
++
++ if (!propertyList)
++ return true;
++ if (CFGetTypeID(propertyList) != CFDictionaryGetTypeID())
++ return false;
++
++ CFDictionaryRef cfdict =
++ static_cast<CFDictionaryRef>(static_cast<CFPropertyListRef>(propertyList));
++ int size = (int)CFDictionaryGetCount(cfdict);
++ QVarLengthArray<CFPropertyListRef> keys(size);
++ QVarLengthArray<CFPropertyListRef> values(size);
++ CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
++
++ for (int i = 0; i < size; ++i) {
++ QString key = qtKey(static_cast<CFStringRef>(keys[i]));
++ map->insert(QSettingsKey(key, Qt::CaseSensitive), qtValue(values[i]));
++ }
++ return true;
++ }
++
++ bool QConfFileSettingsPrivate::writePlistFile(QIODevice &file, const ParsedSettingsMap &map) const
++ {
++ QVarLengthArray<QCFType<CFStringRef> > cfkeys(map.size());
++ QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(map.size());
++ int i = 0;
++ ParsedSettingsMap::const_iterator j;
++ for (j = map.constBegin(); j != map.constEnd(); ++j) {
++ cfkeys[i] = macKey(j.key());
++ cfvalues[i] = macValue(j.value());
++ ++i;
++ }
++
++ QCFType<CFDictionaryRef> propertyList =
++ CFDictionaryCreate(kCFAllocatorDefault,
++ reinterpret_cast<const void **>(cfkeys.data()),
++ reinterpret_cast<const void **>(cfvalues.data()),
++ CFIndex(map.size()),
++ &kCFTypeDictionaryKeyCallBacks,
++ &kCFTypeDictionaryValueCallBacks);
++
++ QCFType<CFDataRef> xmlData = CFPropertyListCreateData(
++ kCFAllocatorDefault, propertyList, kCFPropertyListXMLFormat_v1_0, 0, 0);
++
++ return file.write(QByteArray::fromRawCFData(xmlData)) == CFDataGetLength(xmlData);
++ }
++
++ QT_END_NAMESPACE