1 files changed, 207 insertions, 0 deletions
diff --git a/src/corelib/io/qlockfile_unix.cpp b/src/corelib/io/qlockfile_unix.cpp
new file mode 100644
index 0000000000..ed3b399fbf
--- /dev/null
+++ b/src/corelib/io/qlockfile_unix.cpp
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qlockfile_p.h"
+
+#include "QtCore/qtemporaryfile.h"
+#include "QtCore/qcoreapplication.h"
+#include "QtCore/qfileinfo.h"
+#include "QtCore/qdebug.h"
+
+#include "private/qcore_unix_p.h" // qt_safe_open
+#include "private/qabstractfileengine_p.h"
+#include "private/qtemporaryfile_p.h"
+
+#include <sys/file.h>  // flock
+#include <sys/types.h> // kill
+#include <signal.h>    // kill
+
+QT_BEGIN_NAMESPACE
+
+static QString localHostName() // from QHostInfo::localHostName()
+{
+    char hostName[512];
+    if (gethostname(hostName, sizeof(hostName)) == -1)
+        return QString();
+    hostName[sizeof(hostName) - 1] = '\0';
+    return QString::fromLocal8Bit(hostName);
+}
+
+// ### merge into qt_safe_write?
+static qint64 qt_write_loop(int fd, const char *data, qint64 len)
+{
+    qint64 pos = 0;
+    while (pos < len) {
+        const qint64 ret = qt_safe_write(fd, data + pos, len - pos);
+        if (ret == -1) // e.g. partition full
+            return pos;
+        pos += ret;
+    }
+    return pos;
+}
+
+int QLockFilePrivate::checkFcntlWorksAfterFlock()
+{
+    QTemporaryFile file;
+    if (!file.open())
+        return -2;
+    const int fd = file.d_func()->engine()->handle();
+    if (flock(fd, LOCK_EX | LOCK_NB) == -1) // other threads, and other processes on a local fs
+        return -3;
+    struct flock flockData;
+    flockData.l_type = F_WRLCK;
+    flockData.l_whence = SEEK_SET;
+    flockData.l_start = 0;
+    flockData.l_len = 0; // 0 = entire file
+    flockData.l_pid = getpid();
+    if (fcntl(fd, F_SETLK, &flockData) == -1) // for networked filesystems
+        return 0;
+    return 1;
+}
+
+static QBasicAtomicInt fcntlOK = Q_BASIC_ATOMIC_INITIALIZER(-1);
+
+/*!
+  \internal
+  Checks that the OS isn't using POSIX locks to emulate flock().
+  Mac OS X is one of those.
+*/
+static bool fcntlWorksAfterFlock()
+{
+    int value = fcntlOK.load();
+    if (Q_UNLIKELY(value == -1)) {
+        value = QLockFilePrivate::checkFcntlWorksAfterFlock();
+        fcntlOK.store(value);
+    }
+    return value == 1;
+}
+
+static bool setNativeLocks(int fd)
+{
+    if (flock(fd, LOCK_EX | LOCK_NB) == -1) // other threads, and other processes on a local fs
+        return false;
+    struct flock flockData;
+    flockData.l_type = F_WRLCK;
+    flockData.l_whence = SEEK_SET;
+    flockData.l_start = 0;
+    flockData.l_len = 0; // 0 = entire file
+    flockData.l_pid = getpid();
+    if (fcntlWorksAfterFlock() && fcntl(fd, F_SETLK, &flockData) == -1) // for networked filesystems
+        return false;
+    return true;
+}
+
+QLockFile::LockError QLockFilePrivate::tryLock_sys()
+{
+    const QByteArray lockFileName = QFile::encodeName(fileName);
+    const int fd = qt_safe_open(lockFileName.constData(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+    if (fd < 0) {
+        switch (errno) {
+        case EEXIST:
+            return QLockFile::LockFailedError;
+        case EACCES:
+        case EROFS:
+            return QLockFile::PermissionError;
+        default:
+            return QLockFile::UnknownError;
+        }
+    }
+    // Ensure nobody else can delete the file while we have it
+    if (!setNativeLocks(fd))
+        qWarning() << "setNativeLocks failed:" << strerror(errno);
+
+    // We hold the lock, continue.
+    fileHandle = fd;
+
+    // Assemble data, to write in a single call to write
+    // (otherwise we'd have to check every write call)
+    QByteArray fileData;
+    fileData += QByteArray::number(QCoreApplication::applicationPid());
+    fileData += '\n';
+    fileData += qAppName().toUtf8();
+    fileData += '\n';
+    fileData += localHostName().toUtf8();
+    fileData += '\n';
+
+    QLockFile::LockError error = QLockFile::NoError;
+    if (qt_write_loop(fd, fileData.constData(), fileData.size()) < fileData.size())
+        error = QLockFile::UnknownError; // partition full
+    return error;
+}
+
+bool QLockFilePrivate::removeStaleLock()
+{
+    const QByteArray lockFileName = QFile::encodeName(fileName);
+    const int fd = qt_safe_open(lockFileName.constData(), O_WRONLY, 0644);
+    if (fd < 0) // gone already?
+        return false;
+    bool success = setNativeLocks(fd) && (::unlink(lockFileName) == 0);
+    close(fd);
+    return success;
+}
+
+bool QLockFilePrivate::isApparentlyStale() const
+{
+    qint64 pid;
+    QString hostname, appname;
+    if (!getLockInfo(&pid, &hostname, &appname))
+        return false;
+    if (hostname == localHostName()) {
+        if (::kill(pid, 0) == -1 && errno == ESRCH)
+            return true; // PID doesn't exist anymore
+    }
+    const qint64 age = QFileInfo(fileName).lastModified().msecsTo(QDateTime::currentDateTime());
+    return staleLockTime > 0 && age > staleLockTime;
+}
+
+void QLockFile::unlock()
+{
+    Q_D(QLockFile);
+    if (!d->isLocked)
+        return;
+    close(d->fileHandle);
+    d->fileHandle = -1;
+    QFile::remove(d->fileName);
+    d->lockError = QLockFile::NoError;
+    d->isLocked = false;
+}
+
+QT_END_NAMESPACE