src/core/coretransfer.cpp

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