src/core/coretransfer.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2016 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 quint64 CoreTransfer::transferred() const
  43 {
  44     return _pos;
  45 }
  46
  47
  48 void CoreTransfer::cleanUp()
  49 {
  50     if (_socket) {
  51         _socket->close();
  52         _socket->deleteLater();
  53         _socket = 0;
  54     }
  55
  56     _buffer.clear();
  57     _reading = false;
  58 }
  59
  60
  61 void CoreTransfer::onSocketDisconnected()
  62 {
  63     if (status() == Status::Connecting || status() == Status::Transferring) {
  64         setError(tr("Socket closed while still transferring!"));
  65     }
  66     else
  67         cleanUp();
  68 }
  69
  70
  71 void CoreTransfer::onSocketError(QAbstractSocket::SocketError error)
  72 {
  73     Q_UNUSED(error)
  74
  75     if (status() == Status::Connecting || status() == Status::Transferring) {
  76         setError(tr("DCC connection error: %1").arg(_socket->errorString()));
  77     }
  78 }
  79
  80
  81 void CoreTransfer::requestAccepted(PeerPtr peer)
  82 {
  83     if (_peer || !peer || status() != Status::New)
  84         return; // transfer was already accepted
  85
  86     _peer = peer;
  87     setStatus(Status::Pending);
  88
  89     emit accepted(peer);
  90
  91     // FIXME temporary until we have queueing
  92     start();
  93 }
  94
  95
  96 void CoreTransfer::requestRejected(PeerPtr peer)
  97 {
  98     if (_peer || status() != Status::New)
  99         return;
 100
 101     _peer = peer;
 102     setStatus(Status::Rejected);
 103
 104     emit rejected(peer);
 105 }
 106
 107
 108 void CoreTransfer::start()
 109 {
 110     if (!_peer || status() != Status::Pending || direction() != Direction::Receive)
 111         return;
 112
 113     setupConnectionForReceive();
 114 }
 115
 116
 117 void CoreTransfer::setupConnectionForReceive()
 118 {
 119     if (port() == 0) {
 120         setError(tr("Reverse DCC not supported yet!"));
 121         return;
 122     }
 123
 124     setStatus(Status::Connecting);
 125
 126     _socket = new QTcpSocket(this);
 127     connect(_socket, SIGNAL(connected()), SLOT(startReceiving()));
 128     connect(_socket, SIGNAL(disconnected()), SLOT(onSocketDisconnected()));
 129     connect(_socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(onSocketError(QAbstractSocket::SocketError)));
 130     connect(_socket, SIGNAL(readyRead()), SLOT(onDataReceived()));
 131
 132     _socket->connectToHost(address(), port());
 133 }
 134
 135
 136 void CoreTransfer::startReceiving()
 137 {
 138     setStatus(Status::Transferring);
 139 }
 140
 141
 142 void CoreTransfer::onDataReceived()
 143 {
 144     if (_reading) // since we're spinning the event loop, we may get another readyRead() and thus reentrancy
 145         return;
 146     _reading = true;
 147
 148     while (_socket->bytesAvailable()) {
 149         QByteArray data = _socket->read(chunkSize);
 150         _pos += data.size();
 151         emit transferredChanged(transferred());
 152         if (!relayData(data, true))
 153             return;
 154
 155         QCoreApplication::processEvents();  // don't block the rest of the core/client communication
 156         if (!_socket)  // just in case something happened during spinning the event loop that killed our socket
 157             return;
 158     }
 159
 160     // Send ack to sender. The DCC protocol only specifies 32 bit values, but modern clients (i.e. those who can send files
 161     // larger than 4 GB) will ignore this anyway...
 162     quint32 ack = qToBigEndian((quint32)_pos);// qDebug() << Q_FUNC_INFO << _pos;
 163     _socket->write((char *)&ack, 4);
 164
 165     if (_pos > fileSize()) {
 166         qWarning() << "DCC Receive: Got more data than expected!";
 167         setError(tr("DCC Receive: Got more data than expected!"));
 168     }
 169     else if (_pos == fileSize()) {
 170         qDebug() << "DCC Receive: Transfer finished";
 171         if (relayData(QByteArray(), false)) // empty buffer
 172             setStatus(Status::Completed);
 173     }
 174
 175     _reading = false;
 176 }
 177
 178
 179 bool CoreTransfer::relayData(const QByteArray &data, bool requireChunkSize)
 180 {
 181     // safeguard against a disconnecting quasselclient
 182     if (!_peer) {
 183         setError(tr("DCC Receive: Quassel Client disconnected during transfer!"));
 184         return false;
 185     }
 186     _buffer.append(data);
 187
 188     // we only want to send data to the client once we have reached the chunksize
 189     if (_buffer.size() > 0 && (_buffer.size() >= chunkSize || !requireChunkSize)) {
 190         Peer *p = _peer.data();
 191         SYNC_OTHER(dataReceived, ARG(p), ARG(_buffer));
 192         _buffer.clear();
 193     }
 194
 195     return true;
 196 }