diff options
Diffstat (limited to 'src/gui/embedded/qwscommand_qws_p.h')
| -rw-r--r-- | src/gui/embedded/qwscommand_qws_p.h | 851 |
1 files changed, 851 insertions, 0 deletions
diff --git a/src/gui/embedded/qwscommand_qws_p.h b/src/gui/embedded/qwscommand_qws_p.h new file mode 100644 index 0000000000..70ecc6be6d --- /dev/null +++ b/src/gui/embedded/qwscommand_qws_p.h @@ -0,0 +1,851 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $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$ +** +****************************************************************************/ + +#ifndef QWSCOMMAND_QWS_P_H +#define QWSCOMMAND_QWS_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +// When reading commands "off the wire" in the server, the rawLen is read +// and then that many bytes are allocated. If the rawLen is corrupted (or +// the protocol is being attacked) too many bytes can be allocated. Set +// a hard limit here for security. +#define MAX_COMMAND_SIZE (16 * 1024) + +#include <QtCore/qbytearray.h> +#include <QtGui/qwsutils_qws.h> +#include <QtGui/qfont.h> +#include <QtCore/qdatastream.h> +#include <QtCore/qvariant.h> +#include <QtCore/qrect.h> +#include <QtGui/qregion.h> +#include <QtCore/qvector.h> +#include <QtCore/qvarlengtharray.h> +#include <QtGui/qwsevent_qws.h> +#include "qwsprotocolitem_qws.h" + +QT_BEGIN_NAMESPACE + +QT_MODULE(Gui) + +class QRect; + +/********************************************************************* + * + * Functions to read/write commands on/from a socket + * + *********************************************************************/ +#ifndef QT_NO_QWS_MULTIPROCESS +void qws_write_command(QIODevice *socket, int type, char *simpleData, int simpleLen, char *rawData, int rawLen); +bool qws_read_command(QIODevice *socket, char *&simpleData, int &simpleLen, char *&rawData, int &rawLen, int &bytesRead); +#endif + +struct QWSCommand : QWSProtocolItem +{ + QWSCommand(int t, int len, char *ptr) : QWSProtocolItem(t,len,ptr) {} + + enum Type { + Unknown = 0, + Create, + Shutdown, + Region, + RegionMove, + RegionDestroy, + SetProperty, + AddProperty, + RemoveProperty, + GetProperty, + SetSelectionOwner, + ConvertSelection, + RequestFocus, + ChangeAltitude, + SetOpacity, + DefineCursor, + SelectCursor, + PositionCursor, + GrabMouse, + PlaySound, + QCopRegisterChannel, + QCopSend, + RegionName, + Identify, + GrabKeyboard, + RepaintRegion, + IMMouse, + IMUpdate, + IMResponse, + Embed, + Font, + ScreenTransform + }; + static QWSCommand *factory(int type); +}; + +const char *qws_getCommandTypeString( QWSCommand::Type tp ); + +#ifndef QT_NO_DEBUG +class QDebug; +QDebug &operator<<(QDebug &dbg, QWSCommand::Type tp); +#endif // QT_NO_DEBUG + +/********************************************************************* + * + * Commands + * + *********************************************************************/ + +struct QWSIdentifyCommand : public QWSCommand +{ + QWSIdentifyCommand() : + QWSCommand(QWSCommand::Identify, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) + { + simpleData.idLen = 0; + simpleData.idLock = -1; + } + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + if ( simpleData.idLen > MAX_COMMAND_SIZE ) + { + qWarning( "Identify command - name length %d - too big!", simpleData.idLen ); + simpleData.idLen = MAX_COMMAND_SIZE; + } + if ( simpleData.idLen * int(sizeof(QChar)) > len ) + { + qWarning( "Identify command - name length %d - buffer size %d - buffer overrun!", simpleData.idLen, len ); + } + else + { + id = QString(reinterpret_cast<const QChar*>(d), simpleData.idLen); + } + } + + void setId(const QString& i, int lock) + { + id = i; + simpleData.idLen = id.length(); + simpleData.idLock = lock; + setData(reinterpret_cast<const char*>(id.unicode()), simpleData.idLen*2, true); + } + + struct SimpleData { + int idLen; + int idLock; + } simpleData; + QString id; +}; + +struct QWSCreateCommand : public QWSCommand +{ + QWSCreateCommand(int n = 1) : + QWSCommand(QWSCommand::Create, sizeof(count), + reinterpret_cast<char *>(&count)), count(n) {} + int count; +}; + +struct QWSRegionNameCommand : public QWSCommand +{ + QWSRegionNameCommand() : + QWSCommand(QWSCommand::RegionName, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + if ( simpleData.nameLen > MAX_COMMAND_SIZE ) + { + qWarning( "region name command - name length too big!" ); + simpleData.nameLen = MAX_COMMAND_SIZE; + } + if ( simpleData.captionLen > MAX_COMMAND_SIZE ) + { + qWarning( "region name command - caption length too big!" ); + simpleData.captionLen = MAX_COMMAND_SIZE; + } + if ( simpleData.nameLen + simpleData.captionLen > len ) + { + qWarning( "region name command - name length %d - caption length %d - buffer size %d - buffer overrun!", + simpleData.nameLen, simpleData.captionLen, len ); + + } + else + { + name = QString(reinterpret_cast<const QChar*>(d), simpleData.nameLen/2); + d += simpleData.nameLen; + caption = QString(reinterpret_cast<const QChar*>(d), simpleData.captionLen/2); + } + } + + void setName(const QString& n, const QString &c) + { + name = n; + caption = c; + int l = simpleData.nameLen = name.length()*2; + l += simpleData.captionLen = caption.length()*2; + char *d = new char[l]; + memcpy(d, name.unicode(), simpleData.nameLen); + memcpy(d+simpleData.nameLen, caption.unicode(), simpleData.captionLen); + setData(d, l, true); + delete[] d; + } + + struct SimpleData { + int windowid; + int nameLen; + int captionLen; + } simpleData; + QString name; + QString caption; +}; + +struct QWSRegionCommand : public QWSCommand +{ + QWSRegionCommand() : + QWSCommand(QWSCommand::Region, sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem = true) { + QWSCommand::setData(d, len, allocateMem); + + if( simpleData.nrectangles * int(sizeof(QRect)) + simpleData.surfacekeylength * int(sizeof(QChar)) + simpleData.surfacedatalength * int(sizeof(char)) > len ) + { + qWarning( "region command - rectangle count %d - surface key length %d - region data size %d - buffer size %d - buffer overrun!", + simpleData.nrectangles, simpleData.surfacekeylength, simpleData.surfacedatalength, len ); + } + else + { + char *ptr = rawDataPtr; + + region.setRects(reinterpret_cast<QRect*>(ptr), simpleData.nrectangles); + ptr += simpleData.nrectangles * sizeof(QRect); + + surfaceKey = QString(reinterpret_cast<QChar*>(ptr), + simpleData.surfacekeylength); + ptr += simpleData.surfacekeylength * sizeof(QChar); + + surfaceData = QByteArray(ptr, simpleData.surfacedatalength); + } + } + + void setData(int id, const QString &key, const QByteArray &data, + const QRegion ®) + { + surfaceKey = key; + surfaceData = data; + region = reg; + + const QVector<QRect> rects = reg.rects(); + + simpleData.windowid = id; + simpleData.surfacekeylength = key.size(); + simpleData.surfacedatalength = data.size(); + simpleData.nrectangles = rects.count(); + + QVarLengthArray<char, 256> buffer; + buffer.append(reinterpret_cast<const char*>(rects.constData()), + rects.count() * sizeof(QRect)); + buffer.append(reinterpret_cast<const char*>(key.constData()), + key.size() * sizeof(QChar)); + buffer.append(data, data.size()); + + QWSCommand::setData(buffer.constData(), buffer.size(), true); + } + + /* XXX this will pad out in a compiler dependent way, + should move nrectangles to before windowtype, and + add reserved bytes. + Symptom will be valgrind reported uninitialized memory usage + */ + struct SimpleData { + int windowid; + int surfacekeylength; + int surfacedatalength; + int nrectangles; + } simpleData; + + QString surfaceKey; + QByteArray surfaceData; + QRegion region; +}; + +struct QWSSetOpacityCommand : public QWSCommand +{ + QWSSetOpacityCommand() : + QWSCommand(QWSCommand::SetOpacity, sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid; + uchar opacity; + } simpleData; +}; + +struct QWSRegionMoveCommand : public QWSCommand +{ + QWSRegionMoveCommand() : + QWSCommand(QWSCommand::RegionMove, sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid; + int dx; + int dy; + } simpleData; + +}; + +struct QWSRegionDestroyCommand : public QWSCommand +{ + QWSRegionDestroyCommand() : + QWSCommand(QWSCommand::RegionDestroy, sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid; + } simpleData; + +}; + +struct QWSRequestFocusCommand : public QWSCommand +{ + QWSRequestFocusCommand() : + QWSCommand(QWSCommand::RequestFocus, sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid; + int flag; + } simpleData; +}; + +struct QWSChangeAltitudeCommand : public QWSCommand +{ + QWSChangeAltitudeCommand() : + QWSCommand(QWSCommand::ChangeAltitude, sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + enum Altitude { + Lower = -1, + Raise = 0, + StaysOnTop = 1 + }; + + struct SimpleData { + int windowid; + Altitude altitude; + bool fixed; + } simpleData; + +}; + + +struct QWSAddPropertyCommand : public QWSCommand +{ + QWSAddPropertyCommand() : + QWSCommand(QWSCommand::AddProperty, sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid, property; + } simpleData; + +}; + +struct QWSSetPropertyCommand : public QWSCommand +{ + QWSSetPropertyCommand() : + QWSCommand(QWSCommand::SetProperty, sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) { data = 0; } + + void setData(const char *d, int len, bool allocateMem = true) { + QWSCommand::setData(d, len, allocateMem); + data = rawDataPtr; + } + + struct SimpleData { + int windowid, property, mode; + } simpleData; + + char *data; +}; + +struct QWSRepaintRegionCommand : public QWSCommand +{ + QWSRepaintRegionCommand() : + QWSCommand(QWSCommand::RepaintRegion, sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem = true) { + QWSCommand::setData(d, len, allocateMem); + + if( simpleData.nrectangles * int(sizeof(QRect)) > len ) + { + qWarning( "repaint region command - region rectangle count %d - buffer size %d - buffer overrun", + simpleData.nrectangles, len ); + + simpleData.nrectangles = len / sizeof(QRect); + } + rectangles = reinterpret_cast<QRect *>(rawDataPtr); + } + + struct SimpleData { + int windowid; + int windowFlags; + bool opaque; + int nrectangles; + } simpleData; + + QRect * rectangles; + +}; + +struct QWSRemovePropertyCommand : public QWSCommand +{ + QWSRemovePropertyCommand() : + QWSCommand(QWSCommand::RemoveProperty, sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid, property; + } simpleData; + +}; + +struct QWSGetPropertyCommand : public QWSCommand +{ + QWSGetPropertyCommand() : + QWSCommand(QWSCommand::GetProperty, sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid, property; + } simpleData; + +}; + +struct QWSSetSelectionOwnerCommand : public QWSCommand +{ + QWSSetSelectionOwnerCommand() : + QWSCommand(QWSCommand::SetSelectionOwner, + sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int windowid; + int hour, minute, sec, ms; // time + } simpleData; + +}; + +struct QWSConvertSelectionCommand : public QWSCommand +{ + QWSConvertSelectionCommand() : + QWSCommand(QWSCommand::ConvertSelection, + sizeof(simpleData), reinterpret_cast<char*>(&simpleData)) {} + + struct SimpleData { + int requestor; // requestor window of the selection + int selection; // property on requestor into which the selection should be stored + int mimeTypes; // property ion requestor in which the mimetypes, in which the selection may be, are stored + } simpleData; + +}; + +struct QWSDefineCursorCommand : public QWSCommand +{ + QWSDefineCursorCommand() : + QWSCommand(QWSCommand::DefineCursor, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem = true) { + QWSCommand::setData(d, len, allocateMem); + data = reinterpret_cast<unsigned char *>(rawDataPtr); + if (simpleData.height * ((simpleData.width+7) / 8) > len) { + qWarning("define cursor command - width %d height %d- buffer size %d - buffer overrun", + simpleData.width, simpleData.height, len ); + simpleData.width = simpleData.height = 0; + } + } + + struct SimpleData { + int width; + int height; + int hotX; + int hotY; + int id; + } simpleData; + + unsigned char *data; +}; + +struct QWSSelectCursorCommand : public QWSCommand +{ + QWSSelectCursorCommand() : + QWSCommand(QWSCommand::SelectCursor, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + struct SimpleData { + int windowid; + int id; + } simpleData; +}; + +struct QWSPositionCursorCommand : public QWSCommand +{ + QWSPositionCursorCommand() : + QWSCommand(QWSCommand::PositionCursor, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + struct SimpleData { + int newX; + int newY; + } simpleData; +}; + +struct QWSGrabMouseCommand : public QWSCommand +{ + QWSGrabMouseCommand() : + QWSCommand(QWSCommand::GrabMouse, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + struct SimpleData { + int windowid; + bool grab; // grab or ungrab? + } simpleData; +}; + +struct QWSGrabKeyboardCommand : public QWSCommand +{ + QWSGrabKeyboardCommand() : + QWSCommand(QWSCommand::GrabKeyboard, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + struct SimpleData { + int windowid; + bool grab; // grab or ungrab? + } simpleData; +}; + +#ifndef QT_NO_SOUND +struct QWSPlaySoundCommand : public QWSCommand +{ + QWSPlaySoundCommand() : + QWSCommand(QWSCommand::PlaySound, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + filename = QString(reinterpret_cast<QChar*>(rawDataPtr),len/2); + } + void setFileName(const QString& n) + { + setData(reinterpret_cast<const char*>(n.unicode()), n.length()*2, true); + } + + struct SimpleData { + int windowid; + } simpleData; + QString filename; +}; +#endif + + +#ifndef QT_NO_COP +struct QWSQCopRegisterChannelCommand : public QWSCommand +{ + QWSQCopRegisterChannelCommand() : + QWSCommand(QWSCommand::QCopRegisterChannel, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + if ( simpleData.chLen > MAX_COMMAND_SIZE ) + { + qWarning( "Command channel name too large!" ); + simpleData.chLen = MAX_COMMAND_SIZE; + } + if( simpleData.chLen * int(sizeof(QChar)) > len ) + { + qWarning( "register qcop channel command - channel name length %d - buffer size %d - buffer overrun!", simpleData.chLen, len ); + } + else + { + channel = QString(reinterpret_cast<const QChar*>(d), simpleData.chLen); + } + } + + void setChannel(const QString& n) + { + channel = n; + simpleData.chLen = channel.length(); + setData(reinterpret_cast<const char*>(channel.unicode()), simpleData.chLen*2, true); + } + + struct SimpleData { + int chLen; + } simpleData; + QString channel; +}; + +struct QWSQCopSendCommand : public QWSCommand +{ + QWSQCopSendCommand() : + QWSCommand(QWSCommand::QCopSend, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + + if( simpleData.clen * int(sizeof(QChar)) + simpleData.mlen * int(sizeof(QChar)) + simpleData.dlen * int(sizeof(char)) > len ) + { + qWarning( "qcop send command - channel name length %d - message name length %d - data size %d - buffer size %d - buffer overrun!", + simpleData.clen, simpleData.mlen, simpleData.dlen, len ); + } + else + { + const QChar *cd = reinterpret_cast<const QChar*>(d); + channel = QString(cd,simpleData.clen); cd += simpleData.clen; + message = QString(cd,simpleData.mlen); + d += simpleData.clen*sizeof(QChar) + simpleData.mlen*sizeof(QChar); + data = QByteArray(d, simpleData.dlen); + } + } + + void setMessage(const QString &c, const QString &m, + const QByteArray &data) + { + this->channel = c; + this->message = m; + this->data = data; + simpleData.clen = c.length(); + simpleData.mlen = m.length(); + simpleData.dlen = data.size(); + int l = simpleData.clen*sizeof(QChar); + l += simpleData.mlen*sizeof(QChar); + l += simpleData.dlen; + char *tmp = new char[l]; + char *d = tmp; + memcpy(d, c.unicode(), simpleData.clen*sizeof(QChar)); + d += simpleData.clen*sizeof(QChar); + memcpy(d, m.unicode(), simpleData.mlen*sizeof(QChar)); + d += simpleData.mlen*sizeof(QChar); + memcpy(d, data.data(), simpleData.dlen); + QWSCommand::setData(tmp, l, false); + deleteRaw = true; + } + + struct SimpleData { + int clen; + int mlen; + int dlen; + } simpleData; + QString channel; + QString message; + QByteArray data; +}; + +#endif + + +#ifndef QT_NO_QWS_INPUTMETHODS + +struct QWSIMMouseCommand : public QWSCommand +{ + QWSIMMouseCommand() : + QWSCommand(QWSCommand::IMMouse, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + struct SimpleData { + int windowid; + int state; + int index; + } simpleData; +}; + + +struct QWSIMResponseCommand : public QWSCommand +{ + QWSIMResponseCommand() : + QWSCommand(QWSCommand::IMResponse, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + + QByteArray tmp = QByteArray::fromRawData(d, len); + QDataStream s(tmp); + s >> result; + } + + void setResult(const QVariant & v) + { + QByteArray tmp; + QDataStream s(&tmp, QIODevice::WriteOnly); + s << v; + setData(tmp.data(), tmp.size(), true); + } + + struct SimpleData { + int windowid; + int property; + } simpleData; + + QVariant result; +}; + +struct QWSIMUpdateCommand: public QWSCommand +{ + QWSIMUpdateCommand() : + QWSCommand(QWSCommand::IMUpdate, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + struct SimpleData { + int windowid; + int type; + int widgetid; + } simpleData; +}; + +#endif + +#ifndef QT_NO_QWSEMBEDWIDGET +struct QWSEmbedCommand : public QWSCommand +{ + QWSEmbedCommand() : QWSCommand(QWSCommand::Embed, + sizeof(simpleData), + reinterpret_cast<char*>(&simpleData)) + {} + + void setData(const char *d, int len, bool allocateMem = true) + { + QWSCommand::setData(d, len, allocateMem); + + if( simpleData.rects * int(sizeof(QRect)) > len ) + { + qWarning( "embed command - region rectangle count %d - buffer size %d - buffer overrun!", + simpleData.rects, len ); + } + else + { + region.setRects(reinterpret_cast<QRect*>(rawDataPtr), + simpleData.rects); + } + } + + void setData(WId embedder, WId embedded, QWSEmbedEvent::Type type, + const QRegion reg = QRegion()) + { + simpleData.embedder = embedder; + simpleData.embedded = embedded; + simpleData.type = type; + + region = reg; + const QVector<QRect> rects = reg.rects(); + simpleData.rects = rects.count(); + + QWSCommand::setData(reinterpret_cast<const char*>(rects.constData()), + rects.count() * sizeof(QRect)); + } + + struct { + WId embedder; + WId embedded; + QWSEmbedEvent::Type type; + int rects; + } simpleData; + + QRegion region; +}; +#endif // QT_NO_QWSEMBEDWIDGET + +struct QWSFontCommand : public QWSCommand +{ + enum CommandType { + StartedUsingFont, + StoppedUsingFont + }; + + QWSFontCommand() : + QWSCommand(QWSCommand::Font, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setData(const char *d, int len, bool allocateMem) { + QWSCommand::setData(d, len, allocateMem); + + fontName = QByteArray(d, len); + } + + void setFontName(const QByteArray &name) + { + setData(name.constData(), name.size(), true); + } + + struct SimpleData { + int type; + } simpleData; + + QByteArray fontName; +}; + +struct QWSScreenTransformCommand : public QWSCommand +{ + QWSScreenTransformCommand() : + QWSCommand(QWSCommand::ScreenTransform, + sizeof(simpleData), reinterpret_cast<char *>(&simpleData)) {} + + void setTransformation(int screen, int transformation) + { + simpleData.screen = screen; + simpleData.transformation = transformation; + } + + struct SimpleData { + int screen; + int transformation; + } simpleData; +}; + +QT_END_NAMESPACE + +#endif // QWSCOMMAND_QWS_P_H |