/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $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 "qsystemreadwritelock_p.h"
#include <QFile>
#include <sys/sem.h>
#include <fcntl.h>
#include <errno.h>
#include <QRegExp>
#include <QCryptographicHash>
#include <QDir>

QTM_BEGIN_NAMESPACE

class QSystemReadWriteLockPrivate
{
public:
    enum SemIndex {
        ActiveReaders = 0,
        TotalWriters,
        ActiveWriterSem,
        NumInstances
    };

    QSystemReadWriteLockPrivate():id(-1),semId(-1),
                    key(QString()),keyFileName(QString()),
                    error(QSystemReadWriteLock::NoError),
                    errorString(QString()){};
    void setError(const QString &errorString);

    key_t id;
    int semId;
    QString key;
    QString keyFileName;

    QSystemReadWriteLock::SystemReadWriteLockError error;
    QString errorString;
};

void QSystemReadWriteLockPrivate::setError(const QString &_errorString)
{
    errorString = _errorString;
    switch (errno) {
        case EPERM:
        case EACCES:
            error = QSystemReadWriteLock::PermissionDenied;
            break;
        case ERANGE:
        case ENOMEM:
        case ENOSPC:
            error = QSystemReadWriteLock::OutOfResources;
            break;
        case EIDRM:
            error = QSystemReadWriteLock::NotFound;
            break;
        default:
            error = QSystemReadWriteLock::UnknownError;
     }
}

/*
    This function is taken from qcore_unix_p.h(qt_safe_open)
    If/when QSystemReadWriteLock is integrated into Qt,
    this function defintion may replaced by the sharedmemory
    definition.
 */
static inline int safe_open(const char *pathname, int flags, mode_t mode = 0777)
{
#ifdef O_CLOEXEC
    flags |= O_CLOEXEC;
#endif
    register int fd;

    do {
        fd = ::open(pathname, flags, mode);
    } while (fd == -1 && errno == EINTR);

    // unknown flags are ignored, so we have no way of verifying if
    // O_CLOEXEC was accepted
    if (fd != -1)
        ::fcntl(fd, F_SETFD, FD_CLOEXEC);
    return fd;
}

/*
    This function is taken from qsharedmemory_unix.cpp.
    If/when QSystemReadWriteLock is integrated into Qt,
    this function defintion may replaced by the sharedmemory
    definition.
 */
int createUnixKeyFile(const QString &fileName)
{
    if (QFile::exists(fileName)) {
        return 0;
    }

    int fd = safe_open(QFile::encodeName(fileName).constData(),
            O_EXCL | O_CREAT | O_RDWR, 0640);

    if (-1 == fd) {
        if (errno == EEXIST)
            return 0;
        return -1;
    } else {
        close(fd);
    }
    return 1;
}

/*
    This function is taken from qsharedmemory_unix.cpp.
    If/when QSystemReadWriteLock is integrated into Qt,
    the function definition may replaced by the sharedmemory
    definition.
 */
QString makePlatformSafeKey(const QString &key,
        const QString &prefix)
{
    if (key.isEmpty())
        return QString();

    QString result = prefix;

    QString part1 = key;
    part1.replace(QRegExp(QLatin1String("[^A-Za-z]")), QString());
    result.append(part1);

    QByteArray hex = QCryptographicHash::hash(key.toUtf8(), QCryptographicHash::Sha1).toHex();
    result.append(QLatin1String(hex));
    return QDir::tempPath() + QLatin1Char('/') + result;
}

/*
   \class QSystemReadWriteLock

   \brief The QSystemReadWriteLock class provides read-write locking between
   processes.

   A read-write lock is a synchronization tool for protecting resources that can
   be accessed for reading and writing. This type of lock is useful if you want
   to allow multiple processes/threads to have simultaneous read-only access, but as soon
   as one thread wants to write to the resource, all other threads must be
   blocked until the writing is complete.

   QSystemReadWriteLock behaves much like the QReadWriteLock class, but it also
   works across multiple processes (although it also works perfectly well,
   albeit slightly less efficiently, in a single process).  The system
   resources are cleaned up when the last QSystemReadWriteLock instance
   is destroyed.

   The behaviour of QSystemReadWriteLock is such that writers will
   take precedence over readers.  When writers are waiting, any new
   readers must wait until all writers complete.  That is, writers
   can starve readers.
 */

/*
   Implementation Details:

   The QSystemReadWriteLock class uses Linux kernel semaphores to synchronize
   access between readers and writers.

   4 semaphores are used in total.
   activeReaders - number of active readers
   TotalWriters - number of active and pending writers

   ActiveWriterSem - indicates whether a writer is active

   NumInstances - counts the number of instances of QSystemReadWriteLock
                  objects there for a given key.  This is needed
                  to determine whether system resources are
                  safe to clean up during an instance's destruction.

  activeReaders, TotalWriters and NumInstance are used as counters and
  not in the way typical semaphores are used.  e.g.a value of 5 for
  activeReaders indicates that there are currently 5 readers.

  ActiveWriterSem is used as a typical semaphore.  A value of 1
  means there's an free slot for a writer to become active.
 */

/*
  Construct a system read write lock from the provided \a key.

  The \a mode parameter is only used in Unix systems to handle the case
  where underlying system resources such as semaphores survive a process
  crash.  In this case, the next process to instatiate a lock will
  get the resources that survived the crash, and unless \mode is
  Create, the resources will not be reset.
 */
QSystemReadWriteLock::QSystemReadWriteLock(const QString &key, AccessMode mode)
{
    d = new QSystemReadWriteLockPrivate;
    d->key = key;
    d->keyFileName = makePlatformSafeKey(key, QLatin1String("qipc_systemsem_"));

    int built = createUnixKeyFile(d->keyFileName);
    if (built == -1) {
        d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
                    "unable to make key file for key: %1(%2)")
                    .arg(key).arg(strerror(errno)));
        return;
    }

    // Get the unix key for the created file
    d->id = ftok(QFile::encodeName(d->keyFileName).constData(), 'Q');
    if (d->id == -1) {
        d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
                        "ftok failed for key %1(%2)")
                        .arg(key).arg(strerror(errno)));
        return;
    }

    d->semId = ::semget(d->id, 4, IPC_CREAT | IPC_EXCL | 0666);
    bool created = false;
    if (d->semId == -1) {
        if (errno == EEXIST) {
            d->semId = ::semget(d->id, 4,
                    (mode == QSystemReadWriteLock::Create)?IPC_CREAT|0666:0);
            if (d->semId == -1) {
                d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
                                    "Unable to access semaphore set for key %1(%2)")
                                    .arg(key).arg(::strerror(errno)));
                return;
            }
        } else {
            d->setError(QObject::tr("QSystemReadWriteLock:QSystemReadWriteLock: "
                        "Unable to access semaphore set for key %1(%2)")
                        .arg(key).arg(::strerror(errno)));
            return;
        }
    } else {
        created = true;
    }

    Q_ASSERT(d->semId != -1);
    if (created || mode == QSystemReadWriteLock::Create) {
        typedef union {
            int val;
            struct semid_ds *buf;
            ushort *array;
        }semun;

        semun counterInitVal; //initial value for a "counter" semaphores
        counterInitVal.val = 0;

        semun activeWriterInitVal;//initial value for the "active writer" semaphore
        activeWriterInitVal.val = 1;

        if (-1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::ActiveReaders,
                    SETVAL, counterInitVal) ||
                -1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::TotalWriters,
                    SETVAL, counterInitVal) ||
                -1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::ActiveWriterSem,
                    SETVAL, activeWriterInitVal) ||
                -1 == ::semctl(d->semId, QSystemReadWriteLockPrivate::NumInstances,
                    SETVAL, counterInitVal))
        {
            d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
                        "Unable to reset semaphore set for key %1(%2)")
                        .arg(key).arg(::strerror(errno)));
            QFile::remove(d->keyFileName);
            ::semctl(d->semId, 0, IPC_RMID);
            d->semId = -1;
            return;
        }
    }

    struct sembuf op;
    op.sem_num = QSystemReadWriteLockPrivate::NumInstances;
    op.sem_op = 1;
    op.sem_flg = SEM_UNDO;
    int semoprv = ::semop(d->semId, &op, 1);
    if (semoprv == -1) {
        d->setError(QObject::tr("QSystemReadWriteLock::QSystemReadWriteLock: "
                            "Unable to increment NumInstances semaphore "
                            "for key%1(%2)").arg(key).arg(::strerror(errno)));
        d->semId = -1;
        return;
    }
}

/*
  Destroy the lock instance.  The last QSystemReadWriteLock instance
  for a particular key will destroy the underlying system resources.
 */
QSystemReadWriteLock::~QSystemReadWriteLock()
{
    if (d->semId != -1) {
        //decrement and check that there are 0 instances
        //be aware these 2 operations occur together atomically
        struct sembuf ops[2];
        ops[0].sem_num = QSystemReadWriteLockPrivate::NumInstances;
        ops[0].sem_op = -1;
        ops[0].sem_flg = SEM_UNDO | IPC_NOWAIT;

        ops[1].sem_num = QSystemReadWriteLockPrivate::NumInstances;
        ops[1].sem_op = 0;
        ops[1].sem_flg = IPC_NOWAIT;

        //if successful, then delete the semaphore set
        int semoprv  = ::semop(d->semId, ops, 2);
        if (semoprv == 0) {
            if(::semctl(d->semId, 0, IPC_RMID) == -1) {
                qWarning(QObject::tr("QSystemReadWriteLock::~QSystemReadWriteLock: "
                            "Unable to remove semaphore %1(%2)")
                            .arg(d->key).arg(::strerror(errno)).toLatin1());
            }
            QFile::remove(d->keyFileName);
        } else {
            if (errno == EAGAIN) {
                //wasn't 0 instances so just decrement the NumInstances semaphore
                if (::semop(d->semId, ops, 1) == -1) {
                    qWarning(QObject::tr("QSystemReadWriteLock::~QSystemReadWriteLock: unable "
                                "to decrement NumInstances semaphore for key %1(%2)")
                                .arg(d->key).arg(::strerror(errno)).toLatin1());
                }
            } else {
                qWarning(QObject::tr("QSystemReadWriteLock::~QSystemReadWriteLock: unable "
                            "to decrement and check NumInstances semaphore for key %1(%2)")
                            .arg(d->key).arg(::strerror(errno)).toLatin1());
                ::semop(d->semId, ops, 1);//try decrement anyway
            }
        }

    }

    Q_ASSERT(d);
    delete d;
    d = 0;
}

/*
  Return the key of the lock as passed to the constructor.
 */
QString QSystemReadWriteLock::key() const
{
    return d->key;
}

/*
  Locks the lock for reading.  The function will block if any thread/process
  has locked for writing.
 */
bool QSystemReadWriteLock::lockForRead()
{
    if (d->semId == -1) {
        d->errorString = QObject::tr("QSystemReadWriteLock::lockForRead: unable to lock for read for key %1(%2)")
                .arg(d->key).arg("Lock had not been correctly initialized");
        d->error = UnknownError;
        return false;
    }

    struct sembuf ops[2];

    ops[0].sem_num = QSystemReadWriteLockPrivate::ActiveReaders;
    ops[0].sem_op = 1;
    ops[0].sem_flg = SEM_UNDO;

    ops[1].sem_num = QSystemReadWriteLockPrivate::TotalWriters;
    ops[1].sem_op = 0;
    ops[1].sem_flg = 0;

    if (-1 == ::semop(d->semId, ops, 2)) {
        d->setError(QObject::tr("QSystemReadWriteLock::lockForRead: unable to lock for read for key %1(%2)")
                .arg(d->key).arg(::strerror(errno)));
        return false;
    } else {
        d->errorString = "";
        d->error = NoError;
        return true;
    }
}

/*
   Locks the lock for writing.  This function will block if another thread/process
   has locked for reading or writing.
 */
bool QSystemReadWriteLock::lockForWrite()
{
    if (d->semId == -1) {
        d->errorString = QObject::tr("QSystemReadWriteLock::lockForWrite: "
                                    "unable to lock for write for key %1(%2)")
                                    .arg(d->key).arg("Lock had not been correctly initialized");
        d->error = UnknownError;
        return false;
    }

    struct sembuf op;
    op.sem_num = QSystemReadWriteLockPrivate::TotalWriters;
    op.sem_op = 1;
    op.sem_flg = SEM_UNDO;

    int semoprv = ::semop(d->semId, &op, 1);
    if (semoprv == -1) {
        d->setError(QObject::tr("QSystemReadWriteLock::lockForWrite: "
                    "Could not increment TotalWriters semaphore for key %1(%2)")
                    .arg(d->key).arg(::strerror(errno)));
        return false;
    }

    op.sem_num = QSystemReadWriteLockPrivate::ActiveReaders;
    op.sem_op = 0;
    op.sem_flg = 0;
    semoprv = ::semop(d->semId, &op, 1);
    if (semoprv == -1) {
        d->setError(QObject::tr("QSystemReadWriteLock::lockForWrite: "
                    "Could not detect if all readers were finished for key %1(%2)")
                    .arg(d->key).arg(::strerror(errno)));

        // Decrement our write lock
        op.sem_num = QSystemReadWriteLockPrivate::TotalWriters;
        op.sem_op = -1;
        op.sem_flg = SEM_UNDO;
        ::semop(d->semId, &op, 1);
        return false;
    } else {
        op.sem_num = QSystemReadWriteLockPrivate::ActiveWriterSem;
        op.sem_op = -1;
        op.sem_flg =SEM_UNDO;
        semoprv = ::semop(d->semId, &op, 1);

        if (semoprv == -1) {
            d->setError(QObject::tr("QSystemReadWriteLock::lockForWrite: "
                            "Could not decrement ActiveWriterSem semaphore for key %1(%2)")
                        .arg(d->key).arg(::strerror(errno)));

            op.sem_num = QSystemReadWriteLockPrivate::TotalWriters;
            op.sem_op = -1;
            op.sem_flg = 0;
            ::semop(d->semId, &op, 1);
            return false;
        }
        d->errorString ="";
        d->error = NoError;
        return true;
    }
}

/*
  Release the lock.
 */
void QSystemReadWriteLock::unlock()
{
    if (d->semId == -1) {
        d->errorString = QObject::tr("QSystemReadWriteLock::unlock: unable to unlock for key %1(%2)")
                                    .arg(d->key).arg("Lock had not been correctly initialized");
        d->error = UnknownError;
        return;
    }

    struct sembuf op;
    op.sem_num = QSystemReadWriteLockPrivate::ActiveReaders;
    op.sem_op = -1;
    op.sem_flg = SEM_UNDO | IPC_NOWAIT;
    if (::semop(d->semId, &op, 1) == 0) {
        //do nothing, succeeded in decrementing number of readers
    } else if (errno == EAGAIN){ //no readers, so check for writers
            struct sembuf ops[3];
            ops[0].sem_num = QSystemReadWriteLockPrivate::ActiveWriterSem;
            ops[0].sem_op = 0;
            ops[0].sem_flg = IPC_NOWAIT;

            ops[1].sem_num = QSystemReadWriteLockPrivate::ActiveWriterSem;
            ops[1].sem_op = 1;
            ops[1].sem_flg = SEM_UNDO;

            ops[2].sem_num = QSystemReadWriteLockPrivate::TotalWriters;
            ops[2].sem_op = -1;
            ops[2].sem_flg = SEM_UNDO;

            if (::semop(d->semId, ops, 3) == -1) {
                if (errno != EAGAIN) {
                    d->setError(QObject::tr("QSystemSemaphoreWriteLock::unlock: unable to check and "
                                "update writer semaphores for key %1(%2)")
                            .arg(d->key).arg(::strerror(errno)));
                    return;
                } //Note: EAGAIN indicates that ActiveWriterSem is has a non zero value
                  //indicating there is no current writer, so nothing needs to be done
            }
    } else {
        //error in decrementing readers
        d->setError(QObject::tr("QSystemReadWriteLock::unlock: unable to decrement "
                    "ActiveReaders semaphore for key %1(%2)")
                .arg(d->key).arg(::strerror(errno)));
        return;
    }
    d->errorString="";
    d->error = NoError;
}

/*
  Returns the error code of the last encountered error
 */
QSystemReadWriteLock::SystemReadWriteLockError QSystemReadWriteLock::error() const {
    return d->error;
}

/*
  Returns a string describing the last encountered error
 */
QString QSystemReadWriteLock::errorString() const
{
    return d->errorString;
}

QTM_END_NAMESPACE