Harness::Harness(QObject *parent) : QObject(parent)
{
settingsManager.loadSavedSettings();
gui = new MainWindow;
serialManager = new SerialManager;
packetReceiver = new PacketReceiver;
windDataAnalyzer = new WindDataAnalyzer;
dataLogger = new DataLogger;
systemTimer = new QTimer;
batteryChargeCalculator = new BatteryChargeCalculator;
loggingData = false;
connect(serialManager, SIGNAL(onNewDataReady(QByteArray)), packetReceiver, SLOT(onNewDataReceived(QByteArray)));
connect(serialManager, SIGNAL(serialPortError(QString)), this, SLOT(onSerialPortError(QString)));
connect(packetReceiver, SIGNAL(validPacketReceived()), this, SLOT(onValidPacketReceived()));
connect(packetReceiver, SIGNAL(invalidPacketReceived()), this, SLOT(onInvalidPacketReceived()));
connect(gui, SIGNAL(connectSerialButtonClicked(QString)), this, SLOT(onConnectSerialButtonClicked(QString)));
connect(gui, SIGNAL(saveDataLogButtonClicked()), this, SLOT(onSaveDataLogButtonClicked()));
connect(gui, SIGNAL(startLoggingButtonClicked()), this, SLOT(onStartLoggingButtonClicked()));
connect(gui, SIGNAL(clearLogButtonClicked()), this, SLOT(onClearLogButtonClicked()));
connect(gui, SIGNAL(settingsChanged()), this, SLOT(onSettingsChanged()));
connect(systemTimer, SIGNAL(timeout()), this, SLOT(onSystemTimerTimeout()));
compassOffset = settingsManager.getSettings().compassOffset;
loadGUIDefaultValues();
gui->show();
systemTimer->start(SYSTEM_TIMER_INTERVAL_MS);
}
void Dispatcher::parseArrivedSearchResult(QByteArray &datagram, QHostAddress senderHost)
{
if (datagram.length() <= 40)
{
emit invalidPacketReceived();
return;
}
datagram.remove(0, 2);
QHostAddress allegedSenderHost(getQuint32FromByteArray(&datagram));
//if (senderHost != allegedSenderHost)
// return;
quint64 searchID = getQuint64FromByteArray(&datagram);
QByteArray senderCID = datagram.mid(0, 24);
datagram.remove(0, 24);
int searchResultLength = getQuint16FromByteArray(&datagram);
QByteArray searchResult = datagram.mid(0, searchResultLength);
QByteArray bucket = datagram.mid(searchResultLength);
if (searchResult.length() > 0)
emit searchResultsReceived(senderHost, senderCID, searchID, searchResult);
if (bucket.length() > 0)
emit bucketContentsArrived(bucket, senderHost);
}
void Dispatcher::receiveP2PData()
{
while (receiverUdpSocket->hasPendingDatagrams())
{
QByteArray datagram;
QHostAddress senderHost;
quint16 senderPort; // ignoreer
datagram.resize(receiverUdpSocket->pendingDatagramSize());
receiverUdpSocket->readDatagram(datagram.data(), datagram.size(), &senderHost, &senderPort);
//receiverUdpSocket->readDatagram(datagram.data(), datagram.size(), &senderHost, &senderPort);
//QByteArray datagramType(datagram.left(1));
//QByteArray protocolInstruction(datagram.mid(1,1));
//quint8 quint8DatagramType = datagramType.at(0); // hy wil graag mooi gevra wees om by die rou byte uit te kom...
//quint8 quint8ProtocolInstruction = protocolInstruction.at(0);
quint8 quint8DatagramType = datagram.at(0);
quint8 quint8ProtocolInstruction = datagram.at(1);
switch(quint8DatagramType)
{
case DirectDataPacket:
dispatchDirectDataPacket(datagram);
break;
case DataPacket:
emit incomingDataPacket(quint8ProtocolInstruction, senderHost, datagram);
break;
case MulticastPacket:
handleProtocolInstruction(quint8DatagramType, quint8ProtocolInstruction, datagram, senderHost);
emit multicastPacketReceived();
break;
case BroadcastPacket:
handleProtocolInstruction(quint8DatagramType, quint8ProtocolInstruction, datagram, senderHost);
emit broadcastPacketReceived();
break;
case UnicastPacket:
handleProtocolInstruction(quint8DatagramType, quint8ProtocolInstruction, datagram, senderHost);
emit unicastPacketReceiced();
break;
default:
emit invalidPacketReceived();
}
}
}
void Dispatcher::handleReceivedAnnounce(quint8 datagramType, QHostAddress &senderHost, QByteArray &datagram)
{
if (datagram.length() == 50)
{
QByteArray cid = datagram.mid(2, 24);
QByteArray bucket = datagram.mid(26);
switch(datagramType)
{
case MulticastPacket:
emit announceReplyArrived(true, senderHost, cid, bucket);
break;
case BroadcastPacket:
emit announceReplyArrived(false, senderHost, cid, bucket);
break;
case UnicastPacket:
emit announceForwardArrived(senderHost, cid, bucket);
break;
default:
emit invalidPacketReceived();
}
}
}
void Dispatcher::handleProtocolInstruction(quint8 &quint8DatagramType, quint8 &quint8ProtocolInstruction, QByteArray &datagram,
QHostAddress &senderHost)
{
// try to sort this from most frequently used to less frequently used
switch(quint8ProtocolInstruction)
{
case TTHSearchRequestPacket:
handleReceivedTTHSearchQuestion(senderHost, datagram);
break;
case TTHSearchResultPacket:
handleArrivedTTHSearchResult(senderHost, datagram);
break;
case TTHSearchForwardRequestPacket:
handleReceivedTTHSearchForwardRequest(senderHost, datagram);
break;
case SearchResultPacket:
parseArrivedSearchResult(datagram, senderHost);
break;
case BucketExchangePacket:
emit bucketContentsArrived(datagram.mid(2), senderHost);
break;
case RequestBucketPacket:
sendLocalBucket(senderHost);
break;
case RequestAllBucketsPacket:
sendAllBuckets(senderHost);
break;
// incoming announcement, send to buckets, reply with AnnounceReply
case AnnouncePacket:
switch (quint8DatagramType)
{
case MulticastPacket:
sendMulticastAnnounceReply();
break;
case BroadcastPacket:
sendBroadcastAnnounceReply();
}
handleReceivedAnnounce(quint8DatagramType, senderHost, datagram);
break;
// same as announce, just from different container, so alleged address and fromaddress may not match
case AnnounceForwardedPacket:
sendUnicastAnnounceReply(senderHost);
break;
// incoming keepalive ping or responses on container wide announces, just send to buckets
case AnnounceReplyPacket:
handleReceivedAnnounce(quint8DatagramType, senderHost, datagram);
break;
case SearchRequestPacket:
handleReceivedSearchQuestion(senderHost, datagram);
break;
case DownloadRequestPacket:
handleIncomingUploadRequest(senderHost, datagram);
break;
case SearchForwardRequestPacket:
handleReceivedSearchForwardRequest(senderHost, datagram);
break;
case AnnounceForwardRequestPacket:
handleReceivedAnnounceForwardRequest(senderHost, datagram);
break;
case TransferErrorPacket:
handleReceivedTransferError(senderHost, datagram);
break;
case ProtocolCapabilityQueryPacket:
handleReceivedProtocolCapabilityQuery(senderHost);
break;
case ProtocolCapabilityResponsePacket:
handleReceivedProtocolCapabilityResponse(senderHost, datagram);
break;
case CIDPingPacket:
handleCIDPingReply(datagram, senderHost);
break;
case CIDPingForwardRequestPacket:
handleReceivedCIDPingForwardRequest(senderHost, datagram);
break;
case CIDPingForwardedPacket:
handleCIDPingForwardedReply(datagram);
break;
case CIDPingReplyPacket:
handleReceivedCIDReply(senderHost, datagram);
break;
case TTHTreeRequestPacket:
handleReceivedTTHTreeRequest(senderHost, datagram);
break;
case TTHTreeReplyPacket:
handleReceivedTTHTree(datagram);
break;
// NAT traversal
case RevConnectPacket:
break;
case RevConnectReplyPacket:
break;
default:
emit invalidPacketReceived();
}
}
