CNetworkConnection::CNetworkConnection(QObject* parent)
:QTcpSocket(parent)
{
static bool bMetaRegistered = false;
if( !bMetaRegistered )
{
qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
qRegisterMetaType<QAbstractSocket::SocketState>("QAbstractSocket::SocketState");
bMetaRegistered = true;
}
//qDebug() << "CNetworkConnection constructor";
m_pSocket = 0;
m_pInput = 0;
m_pOutput = 0;
m_nInputSize = 8 * 1024;
m_bInitiated = false;
m_bConnected = false;
m_tConnected = 0;
m_tLastRotate = time(0);
m_nTotalInput = m_nTotalOutput = 0;
memset(&m_nInput, 0, sizeof(m_nInput));
memset(&m_nOutput, 0, sizeof(m_nOutput));
connect(this, SIGNAL(readyRead()), this, SIGNAL(readyToTransfer()), Qt::QueuedConnection);
connect(this, SIGNAL(connected()), this, SIGNAL(readyToTransfer()));
connect(this, SIGNAL(aboutToClose()), this, SLOT(OnAboutToClose()));
}
// Constructs an unconnected PeerWire client and starts the connect timer.
PeerWireClient::PeerWireClient(const QByteArray &peerId, QObject *parent)
: QTcpSocket(parent), pendingBlockSizes(0),
pwState(ChokingPeer | ChokedByPeer), receivedHandShake(false), gotPeerId(false),
sentHandShake(false), nextPacketLength(-1), pendingRequestTimer(0), invalidateTimeout(false),
keepAliveTimer(0), torrentPeer(0)
{
memset(uploadSpeedData, 0, sizeof(uploadSpeedData));
memset(downloadSpeedData, 0, sizeof(downloadSpeedData));
transferSpeedTimer = startTimer(RateControlTimerDelay);
timeoutTimer = startTimer(ConnectTimeout);
peerIdString = peerId;
connect(this, SIGNAL(readyRead()), this, SIGNAL(readyToTransfer()));
connect(this, SIGNAL(connected()), this, SIGNAL(readyToTransfer()));
connect(&socket, SIGNAL(connected()),
this, SIGNAL(connected()));
connect(&socket, SIGNAL(readyRead()),
this, SIGNAL(readyRead()));
connect(&socket, SIGNAL(disconnected()),
this, SIGNAL(disconnected()));
connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)),
this, SIGNAL(error(QAbstractSocket::SocketError)));
connect(&socket, SIGNAL(bytesWritten(qint64)),
this, SIGNAL(bytesWritten(qint64)));
connect(&socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
this, SLOT(socketStateChanged(QAbstractSocket::SocketState)));
}
void CG2Node::FlushSendQueue(bool bFullFlush)
{
QByteArray* pOutput = GetOutputBuffer();
while( bytesToWrite() == 0 && m_lSendQueue.size() )
{
while( pOutput->size() < 4096 && m_lSendQueue.size() )
{
G2Packet* pPacket = m_lSendQueue.dequeue();
pPacket->ToBuffer(pOutput);
pPacket->Release();
}
emit readyToTransfer();
}
if( bFullFlush )
{
if( m_bCompressedOutput && pOutput->size() )
m_bOutputPending = true;
}
if( pOutput->size() )
emit readyToTransfer();
}
void CNetworkConnection::initializeSocket()
{
m_pSocket->disconnect();
connect(m_pSocket, SIGNAL(connected()),
this, SIGNAL(connected()));
connect(m_pSocket, SIGNAL(connected()),
this, SIGNAL(readyToTransfer()));
connect(m_pSocket, SIGNAL(readyRead()),
this, SIGNAL(readyToTransfer()));
connect(m_pSocket, SIGNAL(disconnected()),
this, SIGNAL(disconnected()));
connect(m_pSocket, SIGNAL(error(QAbstractSocket::SocketError)),
this, SIGNAL(error(QAbstractSocket::SocketError)));
connect(m_pSocket, SIGNAL(bytesWritten(qint64)),
this, SIGNAL(bytesWritten(qint64)));
connect(m_pSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
this, SIGNAL(stateChanged(QAbstractSocket::SocketState)));
connect(m_pSocket, SIGNAL(aboutToClose()),
this, SLOT(OnAboutToClose()));
connect(this, SIGNAL(connected()), this, SLOT(OnConnect()), Qt::QueuedConnection);
connect(this, SIGNAL(disconnected()), this, SLOT(OnDisconnect()), Qt::QueuedConnection);
connect(this, SIGNAL(readyRead()), this, SLOT(OnRead()), Qt::QueuedConnection);
connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(OnError(QAbstractSocket::SocketError)), Qt::QueuedConnection);
connect(this, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(OnStateChange(QAbstractSocket::SocketState)), Qt::QueuedConnection);
}
// Sends a block to the peer.
void PeerWireClient::sendBlock(int piece, int offset, const QByteArray &data)
{
QByteArray block;
char message[] = {0, 0, 0, 1, 7};
toNetworkData(9 + data.size(), &message[0]);
block += QByteArray(message, sizeof(message));
char numbers[4 * 2];
toNetworkData(piece, &numbers[0]);
toNetworkData(offset, &numbers[4]);
block += QByteArray(numbers, sizeof(numbers));
block += data;
BlockInfo blockInfo;
blockInfo.pieceIndex = piece;
blockInfo.offset = offset;
blockInfo.length = data.size();
blockInfo.block = block;
pendingBlocks << blockInfo;
pendingBlockSizes += block.size();
if (pendingBlockSizes > 32 * 16384) {
chokePeer();
unchokePeer();
return;
}
emit readyToTransfer();
}
void RateController::addSocket(PeerWireClient *socket)
{
connect(socket, SIGNAL(readyToTransfer()), this, SLOT(scheduleTransfer()));
socket->setReadBufferSize(downLimit * 4);
sockets << socket;
scheduleTransfer();
}
void CNetworkConnection::AcceptFrom(int nHandle)
{
Q_ASSERT(m_pSocket == 0);
m_pSocket = new QTcpSocket();
initializeSocket();
m_bInitiated = false;
m_bConnected = true;
m_tConnected = time(0);
Q_ASSERT(m_pInput == 0);
Q_ASSERT(m_pOutput == 0);
m_pInput = new CBuffer(8192);
m_pOutput = new CBuffer(8192);
m_pSocket->setSocketDescriptor(nHandle);
if( m_pSocket->peerAddress().protocol() == 0 )
{
m_oAddress.setAddress(m_pSocket->peerAddress().toIPv4Address());
}
else
{
m_oAddress.setAddress(m_pSocket->peerAddress().toIPv6Address());
}
m_oAddress.setPort(m_pSocket->peerPort());
emit readyToTransfer();
}
qint64 PeerWireClient::writeData(const char *data, qint64 size)
{
int oldSize = outgoingBuffer.size();
outgoingBuffer.resize(oldSize + size);
memcpy(outgoingBuffer.data() + oldSize, data, size);
emit readyToTransfer();
return size;
}
void CChatSessionG2::SendPacket(G2Packet *pPacket, bool bRelease)
{
qDebug() << "Sending packet" << pPacket->GetType();
pPacket->ToBuffer(GetOutputBuffer());
if(bRelease)
pPacket->Release();
emit readyToTransfer();
}
void CRateController::AddSocket(CNetworkConnection* pSock)
{
connect(pSock, SIGNAL(readyToTransfer()), this, SLOT(sheduleTransfer()));
pSock->setReadBufferSize(8192);
m_lSockets.insert(pSock);
QMetaObject::invokeMethod(this, "sheduleTransfer", Qt::QueuedConnection);
}
qint64 CNetworkConnection::writeData(const char* data, qint64 len)
{
Q_ASSERT(m_pOutput != 0);
int nOldSize = m_pOutput->size();
m_pOutput->resize(nOldSize + len);
memcpy(m_pOutput->data() + nOldSize, data, len);
emit readyToTransfer();
return len;
}
void RateController::removeSocket(PeerWireClient *socket)
{
disconnect(socket, SIGNAL(readyToTransfer()), this, SLOT(scheduleTransfer()));
socket->setReadBufferSize(0);
sockets.remove(socket);
}
void CRateController::RemoveSocket(CNetworkConnection* pSock)
{
disconnect(pSock, SIGNAL(readyToTransfer()), this, SLOT(sheduleTransfer()));
pSock->setReadBufferSize(0);
m_lSockets.remove(pSock);
}
