qsystemsemaphore.cpp

Go to the documentation of this file.

// 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
 
#include "qsystemsemaphore.h"
#include "qsystemsemaphore_p.h"
 
#if QT_CONFIG(systemsemaphore)
#include <QtCore/q20memory.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QtIpcCommon;
using namespace Qt::StringLiterals;
 
inline void QSystemSemaphorePrivate::constructBackend()
{
    visit([](auto p) { q20::construct_at(p); });
}
 
inline void QSystemSemaphorePrivate::destructBackend()
{
    visit([](auto p) { std::destroy_at(p); });
}
 
#if QT_DEPRECATED_SINCE(6, 10)
QSystemSemaphore::QSystemSemaphore(const QString &key, int initialValue, AccessMode mode)
    : QSystemSemaphore(legacyNativeKey(key), initialValue, mode)
{
    d->legacyKey = key;
}
#endif
 
QSystemSemaphore::QSystemSemaphore(const QNativeIpcKey &key, int initialValue, AccessMode mode)
    : d(new QSystemSemaphorePrivate(key.type()))
{
    setNativeKey(key, initialValue, mode);
}
 
QSystemSemaphore::~QSystemSemaphore()
{
    d->cleanHandle();
}
 
void QSystemSemaphore::setNativeKey(const QNativeIpcKey &key, int initialValue, AccessMode mode)
{
    if (key == d->nativeKey && mode == Open)
        return;
    if (!isKeyTypeSupported(key.type())) {
        d->setError(KeyError, tr("%1: unsupported key type")
                    .arg("QSystemSemaphore::setNativeKey"_L1));
        return;
    }
 
    d->clearError();
    d->cleanHandle();
    if (key.type() == d->nativeKey.type()) {
        // we can reuse the backend
        d->nativeKey = key;
    } else {
        // we must recreate the backend
        d->destructBackend();
        d->nativeKey = key;
        d->constructBackend();
    }
    d->initialValue = initialValue;
    d->handle(mode);
 
    d->legacyKey.clear();
}
 
QNativeIpcKey QSystemSemaphore::nativeIpcKey() const
{
    return d->nativeKey;
}
 
#if QT_DEPRECATED_SINCE(6, 10)
void QSystemSemaphore::setKey(const QString &key, int initialValue, AccessMode mode)
{
    setNativeKey(legacyNativeKey(key), initialValue, mode);
    d->legacyKey = key;
}
 
QString QSystemSemaphore::key() const
{
    return d->legacyKey;
}
#endif
 
bool QSystemSemaphore::acquire()
{
    return d->modifySemaphore(-1);
}
 
bool QSystemSemaphore::release(int n)
{
    if (n == 0)
        return true;
    if (n < 0) {
        qWarning("QSystemSemaphore::release: n is negative.");
        return false;
    }
    return d->modifySemaphore(n);
}
 
QSystemSemaphore::SystemSemaphoreError QSystemSemaphore::error() const
{
    return d->error;
}
 
QString QSystemSemaphore::errorString() const
{
    return d->errorString;
}
 
void QSystemSemaphorePrivate::setUnixErrorString(QLatin1StringView function)
{
    // EINVAL is handled in functions so they can give better error strings
    switch (errno) {
    case EPERM:
    case EACCES:
        errorString = QSystemSemaphore::tr("%1: permission denied").arg(function);
        error = QSystemSemaphore::PermissionDenied;
        break;
    case EEXIST:
        errorString = QSystemSemaphore::tr("%1: already exists").arg(function);
        error = QSystemSemaphore::AlreadyExists;
        break;
    case ENOENT:
        errorString = QSystemSemaphore::tr("%1: does not exist").arg(function);
        error = QSystemSemaphore::NotFound;
        break;
    case ERANGE:
    case ENOSPC:
    case EMFILE:
        errorString = QSystemSemaphore::tr("%1: out of resources").arg(function);
        error = QSystemSemaphore::OutOfResources;
        break;
    case ENAMETOOLONG:
        errorString = QSystemSemaphore::tr("%1: key too long").arg(function);
        error = QSystemSemaphore::KeyError;
        break;
    default:
        errorString = QSystemSemaphore::tr("%1: unknown error: %2")
                .arg(function, qt_error_string(errno));
        error = QSystemSemaphore::UnknownError;
#if defined QSYSTEMSEMAPHORE_DEBUG
        qDebug() << errorString << "key" << key << "errno" << errno << EINVAL;
#endif
    }
}
 
bool QSystemSemaphore::isKeyTypeSupported(QNativeIpcKey::Type type)
{
    if (!isIpcSupported(IpcType::SystemSemaphore, type))
        return false;
    using Variant = decltype(QSystemSemaphorePrivate::backend);
    return Variant::staticVisit(type, [](auto ptr) {
        using Impl = std::decay_t<decltype(*ptr)>;
        return Impl::runtimeSupportCheck();
    });
}
 
QNativeIpcKey QSystemSemaphore::platformSafeKey(const QString &key, QNativeIpcKey::Type type)
{
    return { QtIpcCommon::platformSafeKey(key, IpcType::SystemSemaphore, type), type };
}
 
QNativeIpcKey QSystemSemaphore::legacyNativeKey(const QString &key, QNativeIpcKey::Type type)
{
    return { legacyPlatformSafeKey(key, IpcType::SystemSemaphore, type), type };
}
 
QT_END_NAMESPACE
 
#include "moc_qsystemsemaphore.cpp"
 
#endif // QT_CONFIG(systemsemaphore)