qtipccommon.cpp

Go to the documentation of this file.

// Copyright (C) 2022 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtipccommon.h"
#include "qtipccommon_p.h"
 
#include <qcryptographichash.h>
#include <qstandardpaths.h>
#include <qstringconverter.h>
#include <qurl.h>
 
#if defined(Q_OS_DARWIN)
#  include "private/qcore_mac_p.h"
#  if !defined(SHM_NAME_MAX)
     // Based on PSEMNAMLEN in XNU's posix_sem.c, which would
     // indicate the max length is 31, _excluding_ the zero
     // terminator. But in practice (possibly due to an off-
     // by-one bug in the kernel) the usable bytes are only 30.
#    define SHM_NAME_MAX 30
#  endif
#endif
 
#if QT_CONFIG(sharedmemory) || QT_CONFIG(systemsemaphore)
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static QStringView staticTypeToString(QNativeIpcKey::Type type)
{
    switch (type) {
    case QNativeIpcKey::Type::SystemV:
        return u"systemv";
    case QNativeIpcKey::Type::PosixRealtime:
        return u"posix";
    case QNativeIpcKey::Type::Windows:
        return u"windows";
    }
    return {};
}
 
static QString typeToString(QNativeIpcKey::Type type)
{
    QStringView typeString = staticTypeToString(type);
    switch (type) {
    case QNativeIpcKey::Type::SystemV:
    case QNativeIpcKey::Type::PosixRealtime:
    case QNativeIpcKey::Type::Windows:
        return QString::fromRawData(typeString.constData(), typeString.size());
    }
 
    int value = int(type);
    if (value >= 1 && value <= 0xff) {
        // System V key with id different from 'Q'
        typeString = staticTypeToString(QNativeIpcKey::Type::SystemV);
        return typeString + QString::number(-value);   // negative so it prepends a dash
    }
 
    return QString();       // invalid!
}
 
static QNativeIpcKey::Type stringToType(QStringView typeString)
{
    if (typeString == staticTypeToString(QNativeIpcKey::Type::PosixRealtime))
        return QNativeIpcKey::Type::PosixRealtime;
    if (typeString == staticTypeToString(QNativeIpcKey::Type::Windows))
        return QNativeIpcKey::Type::Windows;
 
    auto fromNumber = [](QStringView number, int low, int high) {
        bool ok;
        int n = -number.toInt(&ok, 10);
        if (!ok || n < low || n > high)
            return QNativeIpcKey::Type{};
        return QNativeIpcKey::Type(n);
    };
 
    QStringView sysv = staticTypeToString(QNativeIpcKey::Type::SystemV);
    if (typeString.startsWith(sysv)) {
        if (typeString.size() == sysv.size())
            return QNativeIpcKey::Type::SystemV;
        return fromNumber(typeString.sliced(sysv.size()), 1, 0xff);
    }
 
    // invalid!
    return QNativeIpcKey::Type{};
}
 
QString QtIpcCommon::legacyPlatformSafeKey(const QString &key, QtIpcCommon::IpcType ipcType,
                                           QNativeIpcKey::Type type)
{
    if (key.isEmpty())
        return QString();
 
    QByteArray hex = QCryptographicHash::hash(key.toUtf8(), QCryptographicHash::Sha1).toHex();
 
    if (type == QNativeIpcKey::Type::PosixRealtime) {
#if defined(Q_OS_DARWIN)
        if (qt_apple_isSandboxed()) {
            // Sandboxed applications on Apple platforms require the shared memory name
            // to be in the form <application group identifier>/<custom identifier>.
            // Since we don't know which application group identifier the user wants
            // to apply, we instead document that requirement, and use the key directly.
            return key;
        }
        // The shared memory name limit on Apple platforms is very low (30 characters),
        // so we can't use the logic below of combining the prefix, key, and a hash,
        // to ensure a unique and valid name. Instead we use the first part of the
        // hash, which should still long enough to avoid collisions in practice.
        return u'/' + QLatin1StringView(hex).left(SHM_NAME_MAX - 1);
#endif
    }
 
    QString result;
    result.reserve(1 + 18 + key.size() + 40);
    switch (ipcType) {
    case IpcType::SharedMemory:
        result += "qipc_sharedmemory_"_L1;
        break;
    case IpcType::SystemSemaphore:
        result += "qipc_systemsem_"_L1;
        break;
    }
 
    for (QChar ch : key) {
        if ((ch >= u'a' && ch <= u'z') ||
           (ch >= u'A' && ch <= u'Z'))
           result += ch;
    }
    result.append(QLatin1StringView(hex));
 
    switch (type) {
    case QNativeIpcKey::Type::Windows:
        if (!isIpcSupported(ipcType, QNativeIpcKey::Type::Windows))
            return QString();
        return result;
    case QNativeIpcKey::Type::PosixRealtime:
        if (!isIpcSupported(ipcType, QNativeIpcKey::Type::PosixRealtime))
            return QString();
        return result.prepend(u'/');
    case QNativeIpcKey::Type::SystemV:
        break;
    }
    if (!isIpcSupported(ipcType, QNativeIpcKey::Type::SystemV))
        return QString();
    return QStandardPaths::writableLocation(QStandardPaths::TempLocation) + u'/' + result;
}
 
QString QtIpcCommon::platformSafeKey(const QString &key, QtIpcCommon::IpcType ipcType,
                                     QNativeIpcKey::Type type)
{
    if (key.isEmpty())
        return key;
 
    switch (type) {
    case QNativeIpcKey::Type::PosixRealtime:
        if (!isIpcSupported(ipcType, QNativeIpcKey::Type::PosixRealtime))
            return QString();
#ifdef SHM_NAME_MAX
        // The shared memory name limit on Apple platforms is very low (30
        // characters), so we have to cut it down to avoid ENAMETOOLONG. We
        // hope that there won't be too many collisions...
        return u'/' + QStringView(key).left(SHM_NAME_MAX - 1);
#endif
        return u'/' + key;
 
    case QNativeIpcKey::Type::Windows:
        if (isIpcSupported(ipcType, QNativeIpcKey::Type::Windows)) {
            QStringView prefix;
            QStringView payload = key;
            // see https://learn.microsoft.com/en-us/windows/win32/termserv/kernel-object-namespaces
            for (QStringView candidate : { u"Local\\", u"Global\\" }) {
                if (!key.startsWith(candidate))
                    continue;
                prefix = candidate;
                payload = payload.sliced(prefix.size());
                break;
            }
 
            QStringView mid;
            switch (ipcType) {
            case IpcType::SharedMemory:     mid = u"shm_"; break;
            case IpcType::SystemSemaphore:  mid = u"sem_"; break;
            }
 
            QString result = prefix + mid + payload;
#ifdef MAX_PATH
            result.truncate(MAX_PATH);
#endif
            return result;
        }
        return QString();
 
    case QNativeIpcKey::Type::SystemV:
        break;
    }
 
    // System V
    if (!isIpcSupported(ipcType, QNativeIpcKey::Type::SystemV))
        return QString();
    if (key.startsWith(u'/'))
        return key;
 
    QString baseDir = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
    return baseDir + u'/' + key;
}
 
#if defined(Q_OS_DARWIN)
QNativeIpcKey::Type QNativeIpcKey::defaultTypeForOs_internal() noexcept
{
    if (qt_apple_isSandboxed())
        return Type::PosixRealtime;
    return Type::SystemV;
}
#endif
 
void QNativeIpcKey::copy_internal(const QNativeIpcKey &other)
{
    auto copy = new QNativeIpcKeyPrivate(*other.d_func());
    d = quintptr(copy) & 1;
}
 
void QNativeIpcKey::move_internal(QNativeIpcKey &&) noexcept
{
    // inline code already moved properly, nothing for us to do here
}
 
QNativeIpcKey &QNativeIpcKey::assign_internal(const QNativeIpcKey &other)
{
    QNativeIpcKeyPrivate *us = (d & 1) ? d_func() : nullptr;
    const QNativeIpcKeyPrivate *them = (other.d & 1) ? other.d_func() : nullptr;
    if (us && !them) {
        // don't need the extra info, reset to skinny object
        typeAndFlags = {};
        typeAndFlags.type = us->type;
        delete us;
    } else {
        // do need the extra info, so create if necessary
        if (us)
            *us = *them;
        else
            us = new QNativeIpcKeyPrivate(*them);
        d = quintptr(us) | 1;
    }
    return *this;
}
 
void QNativeIpcKey::destroy_internal() noexcept
{
    Q_D(QNativeIpcKey);
    delete d;
}
 
QNativeIpcKey::Type QNativeIpcKey::type_internal() const noexcept
{
    Q_D(const QNativeIpcKey);
    return d->type;
}
 
void QNativeIpcKey::setType_internal(Type type)
{
    Q_D(QNativeIpcKey);
    d->type = type;
}
 
void QNativeIpcKey::setNativeKey_internal(const QString &)
{
}
 
int QNativeIpcKey::compare_internal(const QNativeIpcKey &lhs, const QNativeIpcKey &rhs) noexcept
{
    return *lhs.d_func() == *rhs.d_func() ? 0 : 1;
}
 
QString QNativeIpcKey::toString() const
{
    QString prefix = typeToString(type());
    if (prefix.isEmpty()) {
        Q_ASSERT(prefix.isNull());
        return prefix;
    }
 
    QString copy = nativeKey();
    copy.replace(u'%', "%25"_L1);
    if (copy.startsWith("//"_L1))
        copy.replace(0, 2, u"/%2F"_s);  // ensure it's parsed as a URL path
 
    QUrl u;
    u.setScheme(prefix);
    u.setPath(copy, QUrl::TolerantMode);
    return u.toString(QUrl::DecodeReserved);
}
 
QNativeIpcKey QNativeIpcKey::fromString(const QString &text)
{
    QUrl u(text, QUrl::TolerantMode);
    Type invalidType = {};
    Type type = stringToType(u.scheme());
    if (type == invalidType || !u.isValid() || !u.userInfo().isEmpty() || !u.host().isEmpty()
            || u.port() != -1)
        return QNativeIpcKey(invalidType);
 
    QNativeIpcKey result(QString(), type);
    if (result.type() != type)      // range check, just in case
        return QNativeIpcKey(invalidType);
 
    // decode the payload
    result.setNativeKey(u.path());
    return result;
}
 
QT_END_NAMESPACE
 
#include "moc_qtipccommon.cpp"
 
#endif // QT_CONFIG(sharedmemory) || QT_CONFIG(systemsemaphore)