1 | /*************************************************************************** |
2 | * Copyright (C) 2005-2014 by the Quassel Project * |
3 | * devel@quassel-irc.org * |
4 | * * |
5 | * This program is free software; you can redistribute it and/or modify * |
6 | * it under the terms of the GNU General Public License as published by * |
7 | * the Free Software Foundation; either version 2 of the License, or * |
8 | * (at your option) version 3. * |
9 | * * |
10 | * This program is distributed in the hope that it will be useful, * |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
13 | * GNU General Public License for more details. * |
14 | * * |
15 | * You should have received a copy of the GNU General Public License * |
16 | * along with this program; if not, write to the * |
17 | * Free Software Foundation, Inc., * |
18 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * |
19 | ***************************************************************************/ |
20 | |
21 | #include <QtEndian> |
22 | |
23 | #include <QCoreApplication> |
24 | #include <QTcpSocket> |
25 | |
26 | #include "coretransfer.h" |
27 | |
28 | const qint64 chunkSize = 16 * 1024; |
29 | |
30 | INIT_SYNCABLE_OBJECT(CoreTransfer) |
31 | |
32 | CoreTransfer::CoreTransfer(Direction direction, const QString &nick, const QString &fileName, const QHostAddress &address, quint16 port, quint64 fileSize, QObject *parent) |
33 | : Transfer(direction, nick, fileName, address, port, fileSize, parent), |
34 | _socket(0), |
35 | _pos(0), |
36 | _reading(false) |
37 | { |
38 | |
39 | } |
40 | |
41 | |
42 | void CoreTransfer::cleanUp() |
43 | { |
44 | if (_socket) { |
45 | _socket->close(); |
46 | _socket->deleteLater(); |
47 | _socket = 0; |
48 | } |
49 | |
50 | _buffer.clear(); |
51 | _reading = false; |
52 | } |
53 | |
54 | |
55 | void CoreTransfer::onSocketDisconnected() |
56 | { |
57 | if (state() == Connecting || state() == Transferring) { |
58 | setError(tr("Socket closed while still transferring!" )); |
59 | } |
60 | else |
61 | cleanUp(); |
62 | } |
63 | |
64 | |
65 | void CoreTransfer::onSocketError(QAbstractSocket::SocketError error) |
66 | { |
67 | Q_UNUSED(error) |
68 | |
69 | if (state() == Connecting || state() == Transferring) { |
70 | setError(tr("DCC connection error: %1" ).arg(_socket->errorString())); |
71 | } |
72 | } |
73 | |
74 | |
75 | void CoreTransfer::requestAccepted(PeerPtr peer) |
76 | { |
77 | if (_peer || !peer || state() != New) |
78 | return; // transfer was already accepted |
79 | |
80 | _peer = peer; |
81 | setState(Pending); |
82 | |
83 | emit accepted(peer); |
84 | |
85 | // FIXME temporary until we have queueing |
86 | start(); |
87 | } |
88 | |
89 | |
90 | void CoreTransfer::requestRejected(PeerPtr peer) |
91 | { |
92 | if (_peer || state() != New) |
93 | return; |
94 | |
95 | _peer = peer; |
96 | setState(Rejected); |
97 | |
98 | emit rejected(peer); |
99 | } |
100 | |
101 | |
102 | void CoreTransfer::start() |
103 | { |
104 | if (!_peer || state() != Pending || direction() != Receive) |
105 | return; |
106 | |
107 | setupConnectionForReceive(); |
108 | } |
109 | |
110 | |
111 | void CoreTransfer::setupConnectionForReceive() |
112 | { |
113 | if (port() == 0) { |
114 | setError(tr("Reverse DCC not supported yet!" )); |
115 | return; |
116 | } |
117 | |
118 | setState(Connecting); |
119 | |
120 | _socket = new QTcpSocket(this); |
121 | connect(_socket, SIGNAL(connected()), SLOT(startReceiving())); |
122 | connect(_socket, SIGNAL(disconnected()), SLOT(onSocketDisconnected())); |
123 | connect(_socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(onSocketError(QAbstractSocket::SocketError))); |
124 | connect(_socket, SIGNAL(readyRead()), SLOT(onDataReceived())); |
125 | |
126 | _socket->connectToHost(address(), port()); |
127 | } |
128 | |
129 | |
130 | void CoreTransfer::startReceiving() |
131 | { |
132 | setState(Transferring); |
133 | } |
134 | |
135 | |
136 | void CoreTransfer::onDataReceived() |
137 | { |
138 | if (_reading) // since we're spinning the event loop, we may get another readyRead() and thus reentrancy |
139 | return; |
140 | _reading = true; |
141 | |
142 | while (_socket->bytesAvailable()) { |
143 | QByteArray data = _socket->read(chunkSize); |
144 | _pos += data.size(); |
145 | if (!relayData(data, true)) |
146 | return; |
147 | |
148 | QCoreApplication::processEvents(); // don't block the rest of the core/client communication |
149 | if (!_socket) // just in case something happened during spinning the event loop that killed our socket |
150 | return; |
151 | } |
152 | |
153 | // Send ack to sender. The DCC protocol only specifies 32 bit values, but modern clients (i.e. those who can send files |
154 | // larger than 4 GB) will ignore this anyway... |
155 | quint32 ack = qToBigEndian((quint32)_pos);// qDebug() << Q_FUNC_INFO << _pos; |
156 | _socket->write((char *)&ack, 4); |
157 | |
158 | if (_pos > fileSize()) { |
159 | qWarning() << "DCC Receive: Got more data than expected!" ; |
160 | setError(tr("DCC Receive: Got more data than expected!" )); |
161 | } |
162 | else if (_pos == fileSize()) { |
163 | qDebug() << "DCC Receive: Transfer finished" ; |
164 | if (relayData(QByteArray(), false)) // empty buffer |
165 | setState(Completed); |
166 | } |
167 | |
168 | _reading = false; |
169 | } |
170 | |
171 | |
172 | bool CoreTransfer::relayData(const QByteArray &data, bool requireChunkSize) |
173 | { |
174 | // safeguard against a disconnecting quasselclient |
175 | if (!_peer) { |
176 | setError(tr("DCC Receive: Quassel Client disconnected during transfer!" )); |
177 | return false; |
178 | } |
179 | _buffer.append(data); |
180 | |
181 | // we only want to send data to the client once we have reached the chunksize |
182 | if (_buffer.size() > 0 && (_buffer.size() >= chunkSize || !requireChunkSize)) { |
183 | SYNC_OTHER(dataReceived, ARG(_peer), ARG(_buffer)); |
184 | _buffer.clear(); |
185 | } |
186 | |
187 | return true; |
188 | } |
189 | |