ConnectionGtk.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "Connection.h"

#include "ArgumentEncoder.h"

#include "WorkItem.h"

#include <errno.h>

#include <glib.h>

#include <sys/fcntl.h>

using namespace std;

namespace CoreIPC {

static const size_t initialMessageBufferSize = 4096;

static int readBytesFromSocket(int fileDescriptor, uint8_t* ptr, size_t length)

{

    ASSERT(fileDescriptor > 0);

    ASSERT(ptr);

    ASSERT(length > 0);

    ssize_t numberOfBytesRead = 0;

    size_t pendingBytesToRead = length;

    uint8_t* buffer = ptr;

    while (pendingBytesToRead > 0) {

        if ((numberOfBytesRead = read(fileDescriptor, buffer, pendingBytesToRead)) < 0) {

            if (errno == EINTR)

                numberOfBytesRead = 0;

            else if (errno == EAGAIN || errno == EWOULDBLOCK)

                break;

            else

                return 0; 

        } else if (!numberOfBytesRead)

            break;

        buffer += numberOfBytesRead;

        pendingBytesToRead -= numberOfBytesRead;

    }

    return (length - pendingBytesToRead);

}

static bool writeBytesToSocket(int fileDescriptor, uint8_t* ptr, size_t length)

{

    ASSERT(fileDescriptor > 0);

    ASSERT(ptr);

    ASSERT(length > 0);

    ssize_t numberOfBytesWritten = 0;

    size_t pendingBytesToWrite = length;

    uint8_t* buffer = ptr;

    // Keep writing to the socket till the complete message has been written.

    while (pendingBytesToWrite > 0) {

        if ((numberOfBytesWritten = write(fileDescriptor, buffer, pendingBytesToWrite)) < 0) {

            if (errno == EINTR)

                numberOfBytesWritten = 0;

            else

                return false;

        }

        buffer += numberOfBytesWritten;

        pendingBytesToWrite -= numberOfBytesWritten;

    }

    // Write operation failed if complete message is not written.

    return !pendingBytesToWrite;

}

void Connection::platformInitialize(Identifier identifier)

{

    m_currentMessageSize = 0;

    m_pendingBytes = 0;

    m_readBuffer.resize(initialMessageBufferSize);

    m_socket = identifier;

}

void Connection::platformInvalidate()

{

    if (!m_isConnected)

        return;

    m_connectionQueue.unregisterEventSourceHandler(m_socket);

    if (m_socket > 0) {

        close(m_socket);

        m_socket = -1;

    }

    m_isConnected = false;

}

void Connection::processCompletedMessage()

{

    size_t realBufferSize = m_currentMessageSize - sizeof(MessageID);

    unsigned messageID = *reinterpret_cast<unsigned*>(m_readBuffer.data() + realBufferSize);

    processIncomingMessage(MessageID::fromInt(messageID), adoptPtr(new ArgumentDecoder(m_readBuffer.data(), realBufferSize)));

    // Prepare for the next message.

    m_currentMessageSize = 0;

    m_pendingBytes = 0;

}

void Connection::readEventHandler()

{

    if (m_socket < 0)

        return;

    // Handle any previously unprocessed message.

    if (!messageProcessingCompleted()) {

        if ((m_pendingBytes -= readBytesFromSocket(m_socket, (m_readBuffer.data() + (m_currentMessageSize - m_pendingBytes)), m_pendingBytes)) > 0)

            return;

        // Message received completely. Process the message now.

        processCompletedMessage();

    }

    // Prepare to read the next message.

    uint8_t sizeBuffer[sizeof(size_t)];

    memset(sizeBuffer, 0, sizeof(size_t));

    while (messageProcessingCompleted()) {

        if (readBytesFromSocket(m_socket, sizeBuffer, sizeof(size_t)))

            m_currentMessageSize = *reinterpret_cast<size_t*>(sizeBuffer);

        if (!m_currentMessageSize)

            break;

        if (m_readBuffer.size() < m_currentMessageSize)

            m_readBuffer.grow(m_currentMessageSize);

        m_pendingBytes = m_currentMessageSize - readBytesFromSocket(m_socket, m_readBuffer.data(), m_currentMessageSize);

        if (m_pendingBytes > 0) // Message partially received.

            break;

        // Message received completely. Process the message now.

        processCompletedMessage();

        memset(sizeBuffer, 0, sizeof(size_t));

    }

}

bool Connection::open()

{

    int flags = fcntl(m_socket, F_GETFL, 0);

    fcntl(m_socket, F_SETFL, flags | O_NONBLOCK);

    m_isConnected = true;

    // Register callbacks for connection termination and input data on the WorkQueue.

    m_connectionQueue.registerEventSourceHandler(m_socket, (G_IO_HUP | G_IO_ERR), WorkItem::create(this, &Connection::connectionDidClose));

    m_connectionQueue.registerEventSourceHandler(m_socket, G_IO_IN, WorkItem::create(this, &Connection::readEventHandler));

    return true;

}

bool Connection::platformCanSendOutgoingMessages() const

{

    return (m_socket > 0);

}

bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<ArgumentEncoder> arguments)

{

    if (m_socket < 0)

        return false;

    // We put the message ID last.

    arguments->encodeUInt32(messageID.toInt());

    size_t bufferSize = arguments->bufferSize();

    // Send the message size first.

    if (!writeBytesToSocket(m_socket, reinterpret_cast<uint8_t*>(&bufferSize), sizeof(size_t)))

        return false;

    if (!writeBytesToSocket(m_socket, arguments->buffer(), arguments->bufferSize()))

        return false;

    return true;

}

} // namespace CoreIPC

Source/WebKit2/Platform/CoreIPC/posix/AttachmentPOSIX.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "Attachment.h"

#include <unistd.h>

#include <errno.h>

namespace CoreIPC {

Attachment::Attachment(int fileDescriptor, size_t size)

    : m_type(MappedMemory)

    , m_fileDescriptor(fileDescriptor)

    , m_size(size)

{

    ASSERT(m_fileDescriptor);

    ASSERT(m_size);

}

void Attachment::dispose()

{

    if (m_fileDescriptor != -1)

        while (close(m_fileDescriptor) == -1 && (errno == EINTR)) { }

}

} // namespace CoreIPC

Source/WebKit2/Platform/CoreIPC/qt/AttachmentQt.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "Attachment.h"

#if PLATFORM(QT)

#include <unistd.h>

#include <errno.h>

#endif

namespace CoreIPC {

Attachment::Attachment(int fileDescriptor, size_t size)

    : m_type(MappedMemory)

    , m_fileDescriptor(fileDescriptor)

    , m_size(size)

{

    ASSERT(m_fileDescriptor);

    ASSERT(m_size);

}

void Attachment::dispose()

{

    if (m_fileDescriptor != -1)

        while (close(m_fileDescriptor) == -1 && (errno == EINTR)) { }

}

} // namespace CoreIPC

Source/WebKit2/Platform/CoreIPC/qt/ConnectionQt.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "Connection.h"

#include "ArgumentEncoder.h"

#include "ProcessLauncher.h"

#include "WorkItem.h"

#include "SharedMemory.h"

#include "WebProcessProxy.h"

#include <QApplication>

#include <QSocketNotifier>

#include <sys/socket.h>

#include <unistd.h>

#include <errno.h>

#include <fcntl.h>

#include <wtf/Assertions.h>

using namespace std;

namespace CoreIPC {

static const size_t messageMaxSize = 4096;

static const size_t attachmentMaxAmount = 255;

enum {

    MessageBodyIsOOL = 1 << 31

};

class MessageInfo {

public:

    MessageInfo() { }

    MessageInfo(MessageID messageID, size_t bodySize, size_t initialAttachmentCount)

        : m_messageID(messageID.toInt())

        , m_bodySize(bodySize)

        , m_attachmentCount(initialAttachmentCount)

    {

        ASSERT(!(m_messageID & MessageBodyIsOOL));

    }

    void setMessageBodyOOL()

    {

        ASSERT(!isMessageBodyOOL());

        m_messageID |= MessageBodyIsOOL;

        m_attachmentCount++;

    }

    bool isMessageBodyOOL() const { return m_messageID & MessageBodyIsOOL; }

    size_t bodySize() const { return m_bodySize; }

    MessageID messageID() const { return MessageID::fromInt(m_messageID & ~MessageBodyIsOOL); }

    size_t attachmentCount() const { return m_attachmentCount; }

private:

    uint32_t m_messageID;

    size_t m_bodySize;

    size_t m_attachmentCount;

};

void Connection::platformInitialize(Identifier identifier)

{

    m_socketDescriptor = identifier;

    m_socketNotifier = 0;

    m_readBuffer.resize(messageMaxSize);

    m_currentMessageSize = 0;

}

void Connection::platformInvalidate()

{

    if (m_socketDescriptor != -1)

        while (close(m_socketDescriptor) == -1 && errno == EINTR) { }

    if (!m_isConnected)

        return;

    delete m_socketNotifier;

    m_socketNotifier = 0;

    m_socketDescriptor = -1;

    m_isConnected = false;

}

class SocketNotifierResourceGuard {

public:

    SocketNotifierResourceGuard(QSocketNotifier* socketNotifier)

        : m_socketNotifier(socketNotifier)

    {

        m_socketNotifier->setEnabled(false);

    }

    ~SocketNotifierResourceGuard()

    {

        m_socketNotifier->setEnabled(true);

    }

private:

    QSocketNotifier* const m_socketNotifier;

};

template<class T, class iterator>

class AttachmentResourceGuard {

public:

    AttachmentResourceGuard(T& attachments)

        : m_attachments(attachments)

    {

    }

    ~AttachmentResourceGuard()

    {

        iterator end = m_attachments.end();

        for (iterator i = m_attachments.begin(); i != end; ++i)

            i->dispose();

    }

private:

    T& m_attachments;

};

void Connection::readyReadHandler()

{

    Deque<Attachment> attachments;

    SocketNotifierResourceGuard socketNotifierEnabler(m_socketNotifier);

    AttachmentResourceGuard<Deque<Attachment>, Deque<Attachment>::iterator> attachementDisposer(attachments);

    char attachmentDescriptorBuffer[CMSG_SPACE(sizeof(int) * (attachmentMaxAmount))];

    struct msghdr message;

    memset(&message, 0, sizeof(message));

    struct iovec iov[1];

    memset(&iov, 0, sizeof(iov));

    message.msg_control = attachmentDescriptorBuffer;

    message.msg_controllen = CMSG_SPACE(sizeof(int) * (attachmentMaxAmount));

    iov[0].iov_base = m_readBuffer.data();

    iov[0].iov_len = m_readBuffer.size();

    message.msg_iov = iov;

    message.msg_iovlen = 1;

    int messageLength = 0;

    while ((messageLength = recvmsg(m_socketDescriptor, &message, 0)) == -1) {

        if (errno != EINTR)

            return;

    }

    struct cmsghdr* controlMessage = CMSG_FIRSTHDR(&message);

    MessageInfo messageInfo;

    unsigned char* messageData = m_readBuffer.data();

    memcpy(&messageInfo, messageData, sizeof(messageInfo));

    ASSERT(messageLength == sizeof(messageInfo) + messageInfo.attachmentCount() * sizeof(size_t) + (messageInfo.isMessageBodyOOL() ? 0 : messageInfo.bodySize()));

    messageData += sizeof(messageInfo);

    RefPtr<WebKit::SharedMemory> oolMessageBody;

    if (messageInfo.attachmentCount()) {

        if (controlMessage && controlMessage->cmsg_level == SOL_SOCKET && controlMessage->cmsg_type == SCM_RIGHTS) {

            size_t attachmentSizes[messageInfo.attachmentCount()];

            memcpy(attachmentSizes, messageData, sizeof(attachmentSizes));

            messageData += sizeof(attachmentSizes);

            int fileDescriptors[messageInfo.attachmentCount()];

            memcpy(fileDescriptors, CMSG_DATA(controlMessage), sizeof(fileDescriptors));

            int attachmentCount = messageInfo.attachmentCount();

            if (messageInfo.isMessageBodyOOL())

                attachmentCount--;

            for (int i = 0; i < attachmentCount; ++i) {

                while (fcntl(fileDescriptors[i], F_SETFL, FD_CLOEXEC) == -1) {

                    if (errno != EINTR) {

                        ASSERT_NOT_REACHED();

                        return;

                    }

                }

            }

            for (int i = 0; i < attachmentCount; ++i)

                attachments.append(Attachment(fileDescriptors[i], attachmentSizes[i]));

            if (messageInfo.isMessageBodyOOL()) {

                ASSERT(messageInfo.bodySize());

                WebKit::SharedMemory::Handle handle;

                handle.adoptFromAttachment(fileDescriptors[attachmentCount], attachmentSizes[attachmentCount]);

                if (handle.isNull()) {

                    ASSERT_NOT_REACHED();

                    return;

                }

                oolMessageBody = WebKit::SharedMemory::create(handle, WebKit::SharedMemory::ReadOnly);

                if (!oolMessageBody) {

                    ASSERT_NOT_REACHED();

                    return;

                }

            }

            controlMessage = CMSG_NXTHDR(&message, controlMessage);

        } else {

            ASSERT_NOT_REACHED();

            return;

        }

    }

    ASSERT(attachments.size() == messageInfo.isMessageBodyOOL() ? messageInfo.attachmentCount() - 1 : messageInfo.attachmentCount());

    unsigned char* messageBody = messageData;

    if (messageInfo.isMessageBodyOOL())

        messageBody = reinterpret_cast<unsigned char*>(oolMessageBody->data());

    ArgumentDecoder* argumentDecoder;

    if (attachments.isEmpty())

        argumentDecoder = new ArgumentDecoder(messageBody, messageInfo.bodySize());

    else

        argumentDecoder = new ArgumentDecoder(messageBody, messageInfo.bodySize(), attachments);

    processIncomingMessage(messageInfo.messageID(), adoptPtr(argumentDecoder));

    ASSERT(!controlMessage);

}

bool Connection::open()

{

    ASSERT(!m_socketNotifier);

    int flags = fcntl(m_socketDescriptor, F_GETFL, 0);

    while (fcntl(m_socketDescriptor, F_SETFL, flags | O_NONBLOCK) == -1) {

        if (errno != EINTR) {

            ASSERT_NOT_REACHED();

            return false;

        }

    }

    m_isConnected = true;

    m_socketNotifier = m_connectionQueue.registerSocketEventHandler(m_socketDescriptor, QSocketNotifier::Read, WorkItem::create(this, &Connection::readyReadHandler));

    // Schedule a call to readyReadHandler. Data may have arrived before installation of the signal

    // handler.

    m_connectionQueue.scheduleWork(WorkItem::create(this, &Connection::readyReadHandler));

    return true;

}

bool Connection::platformCanSendOutgoingMessages() const

{

    return m_socketNotifier;

}

bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<ArgumentEncoder> arguments)

{

    ASSERT(m_socketNotifier);

    COMPILE_ASSERT(sizeof(MessageInfo) + attachmentMaxAmount * sizeof(size_t) <= messageMaxSize, AttachmentsFitToMessageInline);

    Vector<Attachment> attachments = arguments->releaseAttachments();

    AttachmentResourceGuard<Vector<Attachment>, Vector<Attachment>::iterator> attachementDisposer(attachments);

    if (attachments.size() > (attachmentMaxAmount - 1)) {

        ASSERT_NOT_REACHED();

        return false;

    }

    MessageInfo messageInfo(messageID, arguments->bufferSize(), attachments.size());

    size_t messageSizeWithBodyInline = sizeof(messageInfo) + (attachments.size() * sizeof(size_t)) + arguments->bufferSize();

    if (messageSizeWithBodyInline > messageMaxSize && arguments->bufferSize()) {

        RefPtr<WebKit::SharedMemory> oolMessageBody = WebKit::SharedMemory::create(arguments->bufferSize());

        if (!oolMessageBody)

            return false;

        WebKit::SharedMemory::Handle handle;

        if (!oolMessageBody->createHandle(handle, WebKit::SharedMemory::ReadOnly))

            return false;

        messageInfo.setMessageBodyOOL();

        memcpy(oolMessageBody->data(), arguments->buffer(), arguments->bufferSize());

        attachments.append(handle.releaseToAttachment());

    }

    struct msghdr message;

    memset(&message, 0, sizeof(message));

    struct iovec iov[3];

    memset(&iov, 0, sizeof(iov));

    message.msg_iov = iov;

    int iovLength = 1;

    iov[0].iov_base = reinterpret_cast<void*>(&messageInfo);

    iov[0].iov_len = sizeof(messageInfo);

    char attachmentFDBuffer[CMSG_SPACE(sizeof(int) * (attachments.size()))];

    size_t attachmentSizes[attachments.size()];

    if (!attachments.isEmpty()) {

        message.msg_control = attachmentFDBuffer;

        message.msg_controllen = sizeof(attachmentFDBuffer);

        struct cmsghdr* cmsg = CMSG_FIRSTHDR(&message);

        cmsg->cmsg_level = SOL_SOCKET;

        cmsg->cmsg_type = SCM_RIGHTS;

        cmsg->cmsg_len = CMSG_LEN(sizeof(int) * attachments.size());

        int* fdptr = reinterpret_cast<int*>(CMSG_DATA(cmsg));

        for (int i = 0; i < attachments.size(); ++i) {

            attachmentSizes[i] = attachments[i].size();

            fdptr[i] = attachments[i].fileDescriptor();

        }

        message.msg_controllen = cmsg->cmsg_len;

        iov[iovLength].iov_base = attachmentSizes;

        iov[iovLength].iov_len = sizeof(attachmentSizes);

        ++iovLength;

    }

    if (!messageInfo.isMessageBodyOOL() && arguments->bufferSize()) {

        iov[iovLength].iov_base = reinterpret_cast<void*>(arguments->buffer());

        iov[iovLength].iov_len = arguments->bufferSize();

        ++iovLength;

    }

    message.msg_iovlen = iovLength;

    int bytesSent = 0;

    while ((bytesSent = sendmsg(m_socketDescriptor, &message, 0)) == -1) {

        if (errno != EINTR)

            return false;

    }

    return true;

}

void Connection::setShouldCloseConnectionOnProcessTermination(WebKit::PlatformProcessIdentifier process)

{

    m_connectionQueue.scheduleWorkOnTermination(process, WorkItem::create(this, &Connection::connectionDidClose));

}

} // namespace CoreIPC

Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "Connection.h"

#include "ArgumentEncoder.h"

#include "ProcessLauncher.h"

#include "WorkItem.h"

#include "SharedMemory.h"

#include "WebProcessProxy.h"

#include <sys/socket.h>

#include <unistd.h>

#include <errno.h>

#include <fcntl.h>

#include <wtf/Assertions.h>

#if PLATFORM(QT)

#include <QApplication>

#include <QSocketNotifier>

#elif PLATFORM(GTK)

#include <glib.h>

#endif

using namespace std;

namespace CoreIPC {

static const size_t messageMaxSize = 4096;

static const size_t attachmentMaxAmount = 255;

enum {

    MessageBodyIsOOL = 1 << 31

};

class MessageInfo {

public:

    MessageInfo() { }

    MessageInfo(MessageID messageID, size_t bodySize, size_t initialAttachmentCount)

        : m_messageID(messageID.toInt())

        , m_bodySize(bodySize)

        , m_attachmentCount(initialAttachmentCount)

    {

        ASSERT(!(m_messageID & MessageBodyIsOOL));

    }

    void setMessageBodyOOL()

    {

        ASSERT(!isMessageBodyOOL());

        m_messageID |= MessageBodyIsOOL;

        m_attachmentCount++;

    }

    bool isMessageBodyOOL() const { return m_messageID & MessageBodyIsOOL; }

    size_t bodySize() const { return m_bodySize; }

    MessageID messageID() const { return MessageID::fromInt(m_messageID & ~MessageBodyIsOOL); }

    size_t attachmentCount() const { return m_attachmentCount; }

private:

    uint32_t m_messageID;

    size_t m_bodySize;

    size_t m_attachmentCount;

};

void Connection::platformInitialize(Identifier identifier)

{

    m_socketDescriptor = identifier;

    m_readBuffer.resize(messageMaxSize);

    m_currentMessageSize = 0;

#if PLATFORM(QT)

    m_socketNotifier = 0;

#endif

}

void Connection::platformInvalidate()

{

    if (m_socketDescriptor != -1)

        while (close(m_socketDescriptor) == -1 && errno == EINTR) { }

    if (!m_isConnected)

        return;

    m_socketDescriptor = -1;

    m_isConnected = false;

#if PLATFORM(QT)

    delete m_socketNotifier;

    m_socketNotifier = 0;

#endif

#if PLATFORM(GTK)

    m_connectionQueue.unregisterEventSourceHandler(m_socketDescriptor);

#endif

}

#if PLATFORM(QT)

class SocketNotifierResourceGuard {

public:

    SocketNotifierResourceGuard(QSocketNotifier* socketNotifier)

        : m_socketNotifier(socketNotifier)

    {

        m_socketNotifier->setEnabled(false);

    }

    ~SocketNotifierResourceGuard()

    {

        m_socketNotifier->setEnabled(true);

    }

private:

    QSocketNotifier* const m_socketNotifier;

};

#endif

template<class T, class iterator>

class AttachmentResourceGuard {

public:

    AttachmentResourceGuard(T& attachments)

        : m_attachments(attachments)

    {

    }

    ~AttachmentResourceGuard()

    {

        iterator end = m_attachments.end();

        for (iterator i = m_attachments.begin(); i != end; ++i)

            i->dispose();

    }

private:

    T& m_attachments;

};

void Connection::readyReadHandler()

{

    Deque<Attachment> attachments;

#if PLATFORM(QT)

    SocketNotifierResourceGuard socketNotifierEnabler(m_socketNotifier);

#endif

    AttachmentResourceGuard<Deque<Attachment>, Deque<Attachment>::iterator> attachementDisposer(attachments);

    char attachmentDescriptorBuffer[CMSG_SPACE(sizeof(int) * (attachmentMaxAmount))];

    struct msghdr message;

    memset(&message, 0, sizeof(message));

    struct iovec iov[1];

    memset(&iov, 0, sizeof(iov));

    message.msg_control = attachmentDescriptorBuffer;

    message.msg_controllen = CMSG_SPACE(sizeof(int) * (attachmentMaxAmount));

    iov[0].iov_base = m_readBuffer.data();

    iov[0].iov_len = m_readBuffer.size();

    message.msg_iov = iov;

    message.msg_iovlen = 1;

    int messageLength = 0;

    while ((messageLength = recvmsg(m_socketDescriptor, &message, 0)) == -1) {

        if (errno != EINTR)

            return;

    }

    struct cmsghdr* controlMessage = CMSG_FIRSTHDR(&message);

    MessageInfo messageInfo;

    unsigned char* messageData = m_readBuffer.data();

    memcpy(&messageInfo, messageData, sizeof(messageInfo));

    ASSERT(messageLength == sizeof(messageInfo) + messageInfo.attachmentCount() * sizeof(size_t) + (messageInfo.isMessageBodyOOL() ? 0 : messageInfo.bodySize()));

    messageData += sizeof(messageInfo);

    RefPtr<WebKit::SharedMemory> oolMessageBody;

    if (messageInfo.attachmentCount()) {

        if (controlMessage && controlMessage->cmsg_level == SOL_SOCKET && controlMessage->cmsg_type == SCM_RIGHTS) {

            size_t attachmentSizes[messageInfo.attachmentCount()];

            memcpy(attachmentSizes, messageData, sizeof(attachmentSizes));

            messageData += sizeof(attachmentSizes);

            int fileDescriptors[messageInfo.attachmentCount()];

            memcpy(fileDescriptors, CMSG_DATA(controlMessage), sizeof(fileDescriptors));

            int attachmentCount = messageInfo.attachmentCount();

            if (messageInfo.isMessageBodyOOL())

                attachmentCount--;

            for (int i = 0; i < attachmentCount; ++i) {

                while (fcntl(fileDescriptors[i], F_SETFL, FD_CLOEXEC) == -1) {

                    if (errno != EINTR) {

                        ASSERT_NOT_REACHED();

                        return;

                    }

                }

            }

            for (int i = 0; i < attachmentCount; ++i)

                attachments.append(Attachment(fileDescriptors[i], attachmentSizes[i]));

            if (messageInfo.isMessageBodyOOL()) {

                ASSERT(messageInfo.bodySize());

                WebKit::SharedMemory::Handle handle;

                handle.adoptFromAttachment(fileDescriptors[attachmentCount], attachmentSizes[attachmentCount]);

                if (handle.isNull()) {

                    ASSERT_NOT_REACHED();

                    return;

                }

                oolMessageBody = WebKit::SharedMemory::create(handle, WebKit::SharedMemory::ReadOnly);

                if (!oolMessageBody) {

                    ASSERT_NOT_REACHED();

                    return;

                }

            }

            controlMessage = CMSG_NXTHDR(&message, controlMessage);

        } else {

            ASSERT_NOT_REACHED();

            return;

        }

    }

    ASSERT(attachments.size() == messageInfo.isMessageBodyOOL() ? messageInfo.attachmentCount() - 1 : messageInfo.attachmentCount());

    unsigned char* messageBody = messageData;

    if (messageInfo.isMessageBodyOOL())

        messageBody = reinterpret_cast<unsigned char*>(oolMessageBody->data());

    ArgumentDecoder* argumentDecoder;

    if (attachments.isEmpty())

        argumentDecoder = new ArgumentDecoder(messageBody, messageInfo.bodySize());

    else

        argumentDecoder = new ArgumentDecoder(messageBody, messageInfo.bodySize(), attachments);

    processIncomingMessage(messageInfo.messageID(), adoptPtr(argumentDecoder));

    ASSERT(!controlMessage);

}

bool Connection::open()

{

#if PLATFORM(QT)

    ASSERT(!m_socketNotifier);

#endif

    int flags = fcntl(m_socketDescriptor, F_GETFL, 0);

    while (fcntl(m_socketDescriptor, F_SETFL, flags | O_NONBLOCK) == -1) {

        if (errno != EINTR) {

            ASSERT_NOT_REACHED();

            return false;

        }

    }

    m_isConnected = true;

#if PLATFORM(QT)

    m_socketNotifier = m_connectionQueue.registerSocketEventHandler(m_socketDescriptor, QSocketNotifier::Read, WorkItem::create(this, &Connection::readyReadHandler));

#elif PLATFORM(GTK)

    m_connectionQueue.registerEventSourceHandler(m_socketDescriptor, (G_IO_HUP | G_IO_ERR), WorkItem::create(this, &Connection::connectionDidClose));

    m_connectionQueue.registerEventSourceHandler(m_socketDescriptor, G_IO_IN, WorkItem::create(this, &Connection::readyReadHandler));

#endif

    // Schedule a call to readyReadHandler. Data may have arrived before installation of the signal

    // handler.

    m_connectionQueue.scheduleWork(WorkItem::create(this, &Connection::readyReadHandler));

    return true;

}

bool Connection::platformCanSendOutgoingMessages() const

{

    return m_isConnected;

}

bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<ArgumentEncoder> arguments)

{

#if PLATFORM(QT)

    ASSERT(m_socketNotifier);

#endif

    COMPILE_ASSERT(sizeof(MessageInfo) + attachmentMaxAmount * sizeof(size_t) <= messageMaxSize, AttachmentsFitToMessageInline);

    Vector<Attachment> attachments = arguments->releaseAttachments();

    AttachmentResourceGuard<Vector<Attachment>, Vector<Attachment>::iterator> attachementDisposer(attachments);

    if (attachments.size() > (attachmentMaxAmount - 1)) {

        ASSERT_NOT_REACHED();

        return false;

    }

    MessageInfo messageInfo(messageID, arguments->bufferSize(), attachments.size());

    size_t messageSizeWithBodyInline = sizeof(messageInfo) + (attachments.size() * sizeof(size_t)) + arguments->bufferSize();

    if (messageSizeWithBodyInline > messageMaxSize && arguments->bufferSize()) {

        RefPtr<WebKit::SharedMemory> oolMessageBody = WebKit::SharedMemory::create(arguments->bufferSize());

        if (!oolMessageBody)

            return false;

        WebKit::SharedMemory::Handle handle;

        if (!oolMessageBody->createHandle(handle, WebKit::SharedMemory::ReadOnly))

            return false;

        messageInfo.setMessageBodyOOL();

        memcpy(oolMessageBody->data(), arguments->buffer(), arguments->bufferSize());

        attachments.append(handle.releaseToAttachment());

    }

    struct msghdr message;

    memset(&message, 0, sizeof(message));

    struct iovec iov[3];

    memset(&iov, 0, sizeof(iov));

    message.msg_iov = iov;

    int iovLength = 1;

    iov[0].iov_base = reinterpret_cast<void*>(&messageInfo);

    iov[0].iov_len = sizeof(messageInfo);

    char attachmentFDBuffer[CMSG_SPACE(sizeof(int) * (attachments.size()))];

    size_t attachmentSizes[attachments.size()];

    if (!attachments.isEmpty()) {

        message.msg_control = attachmentFDBuffer;

        message.msg_controllen = sizeof(attachmentFDBuffer);

        struct cmsghdr* cmsg = CMSG_FIRSTHDR(&message);

        cmsg->cmsg_level = SOL_SOCKET;

        cmsg->cmsg_type = SCM_RIGHTS;

        cmsg->cmsg_len = CMSG_LEN(sizeof(int) * attachments.size());

        int* fdptr = reinterpret_cast<int*>(CMSG_DATA(cmsg));

        for (size_t i = 0; i < attachments.size(); ++i) {

            attachmentSizes[i] = attachments[i].size();

            fdptr[i] = attachments[i].fileDescriptor();

        }

        message.msg_controllen = cmsg->cmsg_len;

        iov[iovLength].iov_base = attachmentSizes;

        iov[iovLength].iov_len = sizeof(attachmentSizes);

        ++iovLength;

    }

    if (!messageInfo.isMessageBodyOOL() && arguments->bufferSize()) {

        iov[iovLength].iov_base = reinterpret_cast<void*>(arguments->buffer());

        iov[iovLength].iov_len = arguments->bufferSize();

        ++iovLength;

    }

    message.msg_iovlen = iovLength;

    int bytesSent = 0;

    while ((bytesSent = sendmsg(m_socketDescriptor, &message, 0)) == -1) {

        if (errno != EINTR)

            return false;

    }

    return true;

}

#if PLATFORM(QT)

void Connection::setShouldCloseConnectionOnProcessTermination(WebKit::PlatformProcessIdentifier process)

{

    m_connectionQueue.scheduleWorkOnTermination(process, WorkItem::create(this, &Connection::connectionDidClose));

}

#endif

} // namespace CoreIPC

Source/WebKit2/Platform/SharedMemory.h

#include <wtf/PassRefPtr.h>

#include <wtf/RefCounted.h>

33 #if PLATFORM(QT)

33#if PLATFORM(QT) || PLATFORM(GTK)

#include "Attachment.h"

#include <wtf/text/WTFString.h>

#endif

@@public:

        void encode(CoreIPC::ArgumentEncoder*) const;

        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);

63 #if PLATFORM(QT)

63#if PLATFORM(QT) || PLATFORM(GTK)

        CoreIPC::Attachment releaseToAttachment() const;

        void adoptFromAttachment(int fileDescriptor, size_t);

#endif

@@public:

        mutable mach_port_t m_port;

#elif PLATFORM(WIN)

        mutable HANDLE m_handle;

73 #elif PLATFORM(QT)

73#elif PLATFORM(QT) || PLATFORM(GTK)

        mutable int m_fileDescriptor;

#endif

        size_t m_size;

@@private:

    mach_port_t m_port;

#elif PLATFORM(WIN)

    HANDLE m_handle;

102 #elif PLATFORM(QT)

102#elif PLATFORM(QT) || PLATFORM(GTK)

    int m_fileDescriptor;

#endif

};

Source/WebKit2/Platform/posix/SharedMemoryPOSIX.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (c) 2010 University of Szeged

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "SharedMemory.h"

#include "ArgumentDecoder.h"

#include "ArgumentEncoder.h"

#include "WebCoreArgumentCoders.h"

#include <errno.h>

#include <fcntl.h>

#include <stdlib.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include <wtf/Assertions.h>

#include <wtf/CurrentTime.h>

#if PLATFORM(QT)

#include <QDir>

#elif PLATFORM(GTK)

#include <wtf/gobject/GOwnPtr.h>

#endif

namespace WebKit {

SharedMemory::Handle::Handle()

    : m_fileDescriptor(-1)

    , m_size(0)

{

}

SharedMemory::Handle::~Handle()

{

    if (!isNull())

        while (close(m_fileDescriptor) == -1 && errno == EINTR) { }

}

bool SharedMemory::Handle::isNull() const

{

    return m_fileDescriptor == -1;

}

void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder* encoder) const

{

    ASSERT(!isNull());

    encoder->encode(releaseToAttachment());

}

bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)

{

    ASSERT_ARG(handle, !handle.m_size);

    ASSERT_ARG(handle, handle.isNull());

    CoreIPC::Attachment attachment;

    if (!decoder->decode(attachment))

        return false;

    handle.adoptFromAttachment(attachment.releaseFileDescriptor(), attachment.size());

    return true;

}

CoreIPC::Attachment SharedMemory::Handle::releaseToAttachment() const

{

    ASSERT(!isNull());

    int temp = m_fileDescriptor;

    m_fileDescriptor = -1;

    return CoreIPC::Attachment(temp, m_size);

}

void SharedMemory::Handle::adoptFromAttachment(int fileDescriptor, size_t size)

{

    ASSERT(!m_size);

    ASSERT(isNull());

    m_fileDescriptor = fileDescriptor;

    m_size = size;

}

PassRefPtr<SharedMemory> SharedMemory::create(size_t size)

{

#if PLATFORM(QT)

    QString tempName = QDir::temp().filePath(QLatin1String("qwkshm.XXXXXX"));

    QByteArray tempNameCSTR = tempName.toLocal8Bit();

    char* tempNameC = tempNameCSTR.data();

#elif PLATFORM(GTK)

    GOwnPtr<gchar> tempName(g_build_filename(g_get_tmp_dir(), "WK2SharedMemoryXXXXXX", NULL));

    gchar* tempNameC = tempName.get();

#endif

    int fileDescriptor;

    while ((fileDescriptor = mkstemp(tempNameC)) == -1) {

        if (errno != EINTR)

            return 0;

    }

    while (fcntl(fileDescriptor, F_SETFD, FD_CLOEXEC) == -1) {

        if (errno != EINTR) {

            while (close(fileDescriptor) == -1 && errno == EINTR) { }

            unlink(tempNameC);

            return 0;

        }

    }

    while (ftruncate(fileDescriptor, size) == -1) {

        if (errno != EINTR) {

            while (close(fileDescriptor) == -1 && errno == EINTR) { }

            unlink(tempNameC);

            return 0;

        }

    }

    void* data = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor, 0);

    if (data == MAP_FAILED) {

        while (close(fileDescriptor) == -1 && errno == EINTR) { }

        unlink(tempNameC);

        return 0;

    }

    unlink(tempNameC);

    RefPtr<SharedMemory> instance = adoptRef(new SharedMemory());

    instance->m_data = data;

    instance->m_fileDescriptor = fileDescriptor;

    instance->m_size = size;

    return instance.release();

}

static inline int accessModeMMap(SharedMemory::Protection protection)

{

    switch (protection) {

    case SharedMemory::ReadOnly:

        return PROT_READ;

    case SharedMemory::ReadWrite:

        return PROT_READ | PROT_WRITE;

    }

    ASSERT_NOT_REACHED();

    return PROT_READ | PROT_WRITE;

}

PassRefPtr<SharedMemory> SharedMemory::create(const Handle& handle, Protection protection)

{

    ASSERT(!handle.isNull());

    void* data = mmap(0, handle.m_size, accessModeMMap(protection), MAP_SHARED, handle.m_fileDescriptor, 0);

    if (data == MAP_FAILED)

        return 0;

    RefPtr<SharedMemory> instance = adoptRef(new SharedMemory());

    instance->m_data = data;

    instance->m_fileDescriptor = handle.m_fileDescriptor;

    instance->m_size = handle.m_size;

    handle.m_fileDescriptor = -1;

    return instance;

}

SharedMemory::~SharedMemory()

{

    munmap(m_data, m_size);

    while (close(m_fileDescriptor) == -1 && errno == EINTR) { }

}

static inline int accessModeFile(SharedMemory::Protection protection)

{

    switch (protection) {

    case SharedMemory::ReadOnly:

        return O_RDONLY;

    case SharedMemory::ReadWrite:

        return O_RDWR;

    }

    ASSERT_NOT_REACHED();

    return O_RDWR;

}

bool SharedMemory::createHandle(Handle& handle, Protection protection)

{

    ASSERT_ARG(handle, !handle.m_size);

    ASSERT_ARG(handle, handle.isNull());

    int duplicatedHandle;

    while ((duplicatedHandle = dup(m_fileDescriptor)) == -1) {

        if (errno != EINTR) {

            ASSERT_NOT_REACHED();

            return false;

        }

    }

    while ((fcntl(duplicatedHandle, F_SETFD, FD_CLOEXEC | accessModeFile(protection)) == -1)) {

        if (errno != EINTR) {

            ASSERT_NOT_REACHED();

            while (close(duplicatedHandle) == -1 && errno == EINTR) { }

            return false;

        }

    }

    handle.m_fileDescriptor = duplicatedHandle;

    handle.m_size = m_size;

    return true;

}

unsigned SharedMemory::systemPageSize()

{

    static unsigned pageSize = 0;

    if (!pageSize)

        pageSize = getpagesize();

    return pageSize;

}

} // namespace WebKit

Source/WebKit2/Platform/qt/SharedMemoryQt.cpp

/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (c) 2010 University of Szeged

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "SharedMemory.h"

#include "ArgumentDecoder.h"

#include "ArgumentEncoder.h"

#include "WebCoreArgumentCoders.h"

#include <QDir>

#include <errno.h>

#include <fcntl.h>

#include <stdlib.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include <wtf/Assertions.h>

#include <wtf/CurrentTime.h>

namespace WebKit {

SharedMemory::Handle::Handle()

    : m_fileDescriptor(-1)

    , m_size(0)

{

}

SharedMemory::Handle::~Handle()

{

    if (!isNull())

        while (close(m_fileDescriptor) == -1 && errno == EINTR) { }

}

bool SharedMemory::Handle::isNull() const

{

    return m_fileDescriptor == -1;

}

void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder* encoder) const

{

    ASSERT(!isNull());

    encoder->encode(releaseToAttachment());

}

bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)

{

    ASSERT_ARG(handle, !handle.m_size);

    ASSERT_ARG(handle, handle.isNull());

    CoreIPC::Attachment attachment;

    if (!decoder->decode(attachment))

        return false;

    handle.adoptFromAttachment(attachment.releaseFileDescriptor(), attachment.size());

    return true;

}

CoreIPC::Attachment SharedMemory::Handle::releaseToAttachment() const

{

    ASSERT(!isNull());

    int temp = m_fileDescriptor;

    m_fileDescriptor = -1;

    return CoreIPC::Attachment(temp, m_size);

}

void SharedMemory::Handle::adoptFromAttachment(int fileDescriptor, size_t size)

{

    ASSERT(!m_size);

    ASSERT(isNull());

    m_fileDescriptor = fileDescriptor;

    m_size = size;

}

PassRefPtr<SharedMemory> SharedMemory::create(size_t size)

{

    QString tempName = QDir::temp().filePath(QLatin1String("qwkshm.XXXXXX"));

    QByteArray tempNameCSTR = tempName.toLocal8Bit();

    char* tempNameC = tempNameCSTR.data();

    int fileDescriptor;

    while ((fileDescriptor = mkstemp(tempNameC)) == -1) {

        if (errno != EINTR)

            return 0;

    }

    while (fcntl(fileDescriptor, F_SETFD, FD_CLOEXEC) == -1) {

        if (errno != EINTR) {

            while (close(fileDescriptor) == -1 && errno == EINTR) { }

            unlink(tempNameC);

            return 0;

        }

    }

    while (ftruncate(fileDescriptor, size) == -1) {

        if (errno != EINTR) {

            while (close(fileDescriptor) == -1 && errno == EINTR) { }

            unlink(tempNameC);

            return 0;

        }

    }

    void* data = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor, 0);

    if (data == MAP_FAILED) {

        while (close(fileDescriptor) == -1 && errno == EINTR) { }

        unlink(tempNameC);

        return 0;

    }

    unlink(tempNameC);

    RefPtr<SharedMemory> instance = adoptRef(new SharedMemory());

    instance->m_data = data;

    instance->m_fileDescriptor = fileDescriptor;

    instance->m_size = size;

    return instance.release();

}

static inline int accessModeMMap(SharedMemory::Protection protection)

{

    switch (protection) {

    case SharedMemory::ReadOnly:

        return PROT_READ;

    case SharedMemory::ReadWrite:

        return PROT_READ | PROT_WRITE;

    }

    ASSERT_NOT_REACHED();

    return PROT_READ | PROT_WRITE;

}

PassRefPtr<SharedMemory> SharedMemory::create(const Handle& handle, Protection protection)

{

    ASSERT(!handle.isNull());

    void* data = mmap(0, handle.m_size, accessModeMMap(protection), MAP_SHARED, handle.m_fileDescriptor, 0);

    if (data == MAP_FAILED)

        return 0;

    RefPtr<SharedMemory> instance = adoptRef(new SharedMemory());

    instance->m_data = data;

    instance->m_fileDescriptor = handle.m_fileDescriptor;

    instance->m_size = handle.m_size;

    handle.m_fileDescriptor = -1;

    return instance;

}

SharedMemory::~SharedMemory()

{

    munmap(m_data, m_size);

    while (close(m_fileDescriptor) == -1 && errno == EINTR) { }

}

static inline int accessModeFile(SharedMemory::Protection protection)

{

    switch (protection) {

    case SharedMemory::ReadOnly:

        return O_RDONLY;

    case SharedMemory::ReadWrite:

        return O_RDWR;

    }

    ASSERT_NOT_REACHED();

    return O_RDWR;

}

bool SharedMemory::createHandle(Handle& handle, Protection protection)

{

    ASSERT_ARG(handle, !handle.m_size);

    ASSERT_ARG(handle, handle.isNull());

    int duplicatedHandle;

    while ((duplicatedHandle = dup(m_fileDescriptor)) == -1) {

        if (errno != EINTR) {

            ASSERT_NOT_REACHED();

            return false;

        }

    }

    while ((fcntl(duplicatedHandle, F_SETFD, FD_CLOEXEC | accessModeFile(protection)) == -1)) {

        if (errno != EINTR) {

            ASSERT_NOT_REACHED();

            while (close(duplicatedHandle) == -1 && errno == EINTR) { }

            return false;

        }

    }

    handle.m_fileDescriptor = duplicatedHandle;

    handle.m_size = m_size;

    return true;

}

unsigned SharedMemory::systemPageSize()

{

    static unsigned pageSize = 0;

    if (!pageSize)

        pageSize = getpagesize();

    return pageSize;

}

} // namespace WebKit

COMMIT_MESSAGE

Source/WebKit2/ChangeLog

Source/WebKit2/GNUmakefile.am

Source/WebKit2/Platform/CoreIPC/ArgumentDecoder.cpp

Source/WebKit2/Platform/CoreIPC/ArgumentEncoder.cpp

Source/WebKit2/Platform/CoreIPC/Attachment.h

Source/WebKit2/Platform/CoreIPC/Connection.h