← Back to branch summary

~ubuntu-branches/ubuntu/saucy/minitube/saucy

« back to all changes in this revision

Viewing changes to .pc/gcc-4.7.patch/src/qtsingleapplication/qtlocalpeer.cpp

  • Committer: Package Import Robot
  • Author(s): Jakob Haufe
  • Date: 2013-05-23 13:54:01 UTC
  • mfrom: (1.1.15 sid)
  • Revision ID: package-import@ubuntu.com-20130523135401-wsbh1xtf71nkfvkt
Tags: 2.0-1
* New upstream version
* Switch from hardening-wrapper to buildflags.mk
* Refresh patches:
  - Drop gcc-4.7.patch, fixed upstream
  - Rebuild assure-quit-keybinding
  - Rebuild disable-update-check
* Update Standards-Version to 3.9.4
  - Add Vcs-* control fields
  - No further changes needed

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/gcc-4.7.patch/src/qtsingleapplication/qtlocalpeer.cpp
1
 
/****************************************************************************
2
 
**
3
 
** This file is part of a Qt Solutions component.
4
 
** 
5
 
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
6
 
** 
7
 
** Contact:  Qt Software Information (qt-info@nokia.com)
8
 
** 
9
 
** Commercial Usage  
10
 
** Licensees holding valid Qt Commercial licenses may use this file in
11
 
** accordance with the Qt Solutions Commercial License Agreement provided
12
 
** with the Software or, alternatively, in accordance with the terms
13
 
** contained in a written agreement between you and Nokia.
14
 
** 
15
 
** GNU Lesser General Public License Usage
16
 
** Alternatively, this file may be used under the terms of the GNU Lesser
17
 
** General Public License version 2.1 as published by the Free Software
18
 
** Foundation and appearing in the file LICENSE.LGPL included in the
19
 
** packaging of this file.  Please review the following information to
20
 
** ensure the GNU Lesser General Public License version 2.1 requirements
21
 
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22
 
** 
23
 
** In addition, as a special exception, Nokia gives you certain
24
 
** additional rights. These rights are described in the Nokia Qt LGPL
25
 
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26
 
** package.
27
 
** 
28
 
** GNU General Public License Usage 
29
 
** Alternatively, this file may be used under the terms of the GNU
30
 
** General Public License version 3.0 as published by the Free Software
31
 
** Foundation and appearing in the file LICENSE.GPL included in the
32
 
** packaging of this file.  Please review the following information to
33
 
** ensure the GNU General Public License version 3.0 requirements will be
34
 
** met: http://www.gnu.org/copyleft/gpl.html.
35
 
** 
36
 
** Please note Third Party Software included with Qt Solutions may impose
37
 
** additional restrictions and it is the user's responsibility to ensure
38
 
** that they have met the licensing requirements of the GPL, LGPL, or Qt
39
 
** Solutions Commercial license and the relevant license of the Third
40
 
** Party Software they are using.
41
 
** 
42
 
** If you are unsure which license is appropriate for your use, please
43
 
** contact the sales department at qt-sales@nokia.com.
44
 
** 
45
 
****************************************************************************/
46
 
 
47
 
 
48
 
#include "qtlocalpeer.h"
49
 
#include <QtCore/QCoreApplication>
50
 
#include <QtCore/QTime>
51
 
#include <QDebug>
52
 
 
53
 
#if defined(Q_OS_WIN)
54
 
#include <QtCore/QLibrary>
55
 
#include <QtCore/qt_windows.h>
56
 
typedef BOOL(WINAPI*PProcessIdToSessionId)(DWORD,DWORD*);
57
 
static PProcessIdToSessionId pProcessIdToSessionId = 0;
58
 
#endif
59
 
#if defined(Q_OS_UNIX)
60
 
#include <time.h>
61
 
#endif
62
 
 
63
 
namespace QtLP_Private {
64
 
#include "qtlockedfile.cpp"
65
 
#if defined(Q_OS_WIN)
66
 
#include "qtlockedfile_win.cpp"
67
 
#else
68
 
#include "qtlockedfile_unix.cpp"
69
 
#endif
70
 
}
71
 
 
72
 
const char* QtLocalPeer::ack = "ack";
73
 
 
74
 
QtLocalPeer::QtLocalPeer(QObject* parent, const QString &appId)
75
 
    : QObject(parent), id(appId)
76
 
{
77
 
    QString prefix = id;
78
 
    if (id.isEmpty()) {
79
 
        id = QCoreApplication::applicationFilePath();
80
 
#if defined(Q_OS_WIN)
81
 
        id = id.toLower();
82
 
#endif
83
 
        prefix = id.section(QLatin1Char('/'), -1);
84
 
    }
85
 
    prefix.remove(QRegExp("[^a-zA-Z]"));
86
 
    prefix.truncate(6);
87
 
 
88
 
    QByteArray idc = id.toUtf8();
89
 
    quint16 idNum = qChecksum(idc.constData(), idc.size());
90
 
    socketName = QLatin1String("qtsingleapp-") + prefix
91
 
                 + QLatin1Char('-') + QString::number(idNum, 16);
92
 
 
93
 
#if defined(Q_OS_WIN)
94
 
    if (!pProcessIdToSessionId) {
95
 
        QLibrary lib("kernel32");
96
 
        pProcessIdToSessionId = (PProcessIdToSessionId)lib.resolve("ProcessIdToSessionId");
97
 
    }
98
 
    if (pProcessIdToSessionId) {
99
 
        DWORD sessionId = 0;
100
 
        pProcessIdToSessionId(GetCurrentProcessId(), &sessionId);
101
 
        socketName += QLatin1Char('-') + QString::number(sessionId, 16);
102
 
    }
103
 
#else
104
 
    socketName += QLatin1Char('-') + QString::number(::getuid(), 16);
105
 
#endif
106
 
 
107
 
    server = new QLocalServer(this);
108
 
    QString lockName = QDir(QDir::tempPath()).absolutePath()
109
 
                       + QLatin1Char('/') + socketName
110
 
                       + QLatin1String("-lockfile");
111
 
    lockFile.setFileName(lockName);
112
 
    lockFile.open(QIODevice::ReadWrite);
113
 
}
114
 
 
115
 
 
116
 
 
117
 
bool QtLocalPeer::isClient()
118
 
{
119
 
    if (lockFile.isLocked())
120
 
        return false;
121
 
 
122
 
    if (!lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
123
 
        return true;
124
 
 
125
 
    bool res = server->listen(socketName);
126
 
#if defined(Q_OS_UNIX) && (QT_VERSION >= QT_VERSION_CHECK(4,5,0))
127
 
    // ### Workaround
128
 
    if (!res && server->serverError() == QAbstractSocket::AddressInUseError) {
129
 
        QFile::remove(QDir::cleanPath(QDir::tempPath())+QLatin1Char('/')+socketName);
130
 
        res = server->listen(socketName);
131
 
    }
132
 
#endif
133
 
    if (!res)
134
 
        qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qPrintable(server->errorString()));
135
 
    QObject::connect(server, SIGNAL(newConnection()), SLOT(receiveConnection()));
136
 
    return false;
137
 
}
138
 
 
139
 
 
140
 
bool QtLocalPeer::sendMessage(const QString &message, int timeout)
141
 
{
142
 
    if (!isClient())
143
 
        return false;
144
 
 
145
 
    QLocalSocket socket;
146
 
    bool connOk = false;
147
 
    for(int i = 0; i < 2; i++) {
148
 
        // Try twice, in case the other instance is just starting up
149
 
        socket.connectToServer(socketName);
150
 
        connOk = socket.waitForConnected(timeout/2);
151
 
        if (connOk || i)
152
 
            break;
153
 
        int ms = 250;
154
 
#if defined(Q_OS_WIN)
155
 
        Sleep(DWORD(ms));
156
 
#else
157
 
        struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
158
 
        nanosleep(&ts, NULL);
159
 
#endif
160
 
    }
161
 
    if (!connOk)
162
 
        return false;
163
 
 
164
 
    QByteArray uMsg(message.toUtf8());
165
 
    QDataStream ds(&socket);
166
 
    ds.writeBytes(uMsg.constData(), uMsg.size());
167
 
    bool res = socket.waitForBytesWritten(timeout);
168
 
    res &= socket.waitForReadyRead(timeout);   // wait for ack
169
 
    res &= (socket.read(qstrlen(ack)) == ack);
170
 
    return res;
171
 
}
172
 
 
173
 
 
174
 
void QtLocalPeer::receiveConnection()
175
 
{
176
 
    QLocalSocket* socket = server->nextPendingConnection();
177
 
    if (!socket)
178
 
        return;
179
 
 
180
 
    while (socket->bytesAvailable() < (int)sizeof(quint32))
181
 
        socket->waitForReadyRead();
182
 
    QDataStream ds(socket);
183
 
    QByteArray uMsg;
184
 
    quint32 remaining;
185
 
    ds >> remaining;
186
 
    uMsg.resize(remaining);
187
 
    int got = 0;
188
 
    char* uMsgBuf = uMsg.data();
189
 
    do {
190
 
        got = ds.readRawData(uMsgBuf, remaining);
191
 
        remaining -= got;
192
 
        uMsgBuf += got;
193
 
    } while (remaining && got >= 0 && socket->waitForReadyRead(2000));
194
 
    if (got < 0) {
195
 
        qWarning() << "QtLocalPeer: Message reception failed" << socket->errorString();
196
 
        delete socket;
197
 
        return;
198
 
    }
199
 
    QString message(QString::fromUtf8(uMsg));
200
 
    socket->write(ack, qstrlen(ack));
201
 
    socket->waitForBytesWritten(1000);
202
 
    delete socket;
203
 
    emit messageReceived(message); //### (might take a long time to return)
204
 
}