PacketMonitor.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/
#ifdef USE_PACKET_MONITOR
#include "Qt.h"
#include "PacketMonitor.h"
#include "Gnutella/LocalPeer.h"
#include "Protocols/Transports/Properties.h"

using Gnutella::PacketProcessing::PacketMonitor;
using Gnutella::Packets::Packet;
using Gnutella::Packets::MaximalPayloadLength;

PacketMonitor::PacketMonitor (LocalPeer *lp)
{
    log = 0;
    logFile.setFileName (tr ("packets.log"));
    /*if (logFile.open (QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) {
        log = new QTextStream (&logFile);
        log->setCodec ("ISO 8859-1");
    }
*/
    localPeer = lp;
}

PacketMonitor::~PacketMonitor()
{
}

void PacketMonitor::addConnection (ConnectionId id, const NodeInfo &)
{
    connectionInputStats.addConnection (id);
    connectionInputPacketStats.addConnection (id);
    connectionOutputStats.addConnection (id);
    connectionOutputPacketStats.addConnection (id);
}

void PacketMonitor::removeConnection (ConnectionId id)
{
    connectionInputStats.removeConnection (id);
    connectionInputPacketStats.removeConnection (id);
    connectionOutputStats.removeConnection (id);
    connectionOutputPacketStats.removeConnection (id);
}

static QString toHexString (const QByteArray &data)
{
    int dataSize = data.size();
    QString res;
    QTextStream stream (&res);
    hex (stream);
    stream.setFieldWidth (2);
    stream.setPadChar ('0');
    for (int i = 0; i < dataSize; i++)
        stream << " 0x" << static_cast <uchar> (data[i]);
    stream.flush();
    return res;
}

bool PacketMonitor::filter (ConnectionStats *connectionStats, PacketStats *packetStats, const Packet &packet)
{
    bool forward = true;
    bool isValid = packet.isValid();

    if (isValid && packet.payloadLength() > MaximalPayloadLength)
        isValid = false;

    // <pd_todo> if ttl + hops has an excessive value try to reduce the ttl => need a no-const Packet &
    // \todo Shareaza may return hits with excessive hops.
    //if (isValid && packet.ttl() > MaximalTtl || packet.hops() > MaximalTtl || packet.ttl() + packet.hops() > MaximalTtl)
    //  isValid = false;

    if (log)
        (*log)  << QTime::currentTime().toString ("hh:mm:ss:zzz") << "\t"
                << packet.name() << "\t"
                << packet.ttl() << "\t"
                << packet.hops() << "\t"
                << packet.descriptorId().toString() << "\t"
                << toHexString (packet.rawPayload()) << endl;

    quint32 packetLength = packet.packetLength();

    connectionStats->totalCount++;
    connectionStats->totalBytes += packetLength;

    if (packetStats) {
        packetStats->count++;
        packetStats->bytes += packetLength;
        if (!isValid) {
            connectionStats->badCount++;
            connectionStats->badBytes += packetLength;
            packetStats->badCount++;
            packetStats->badBytes += packetLength;
            // <pd_todo> If the number / bandwidth of bad packets reaches
            // a threshold (percent of total traffic), drop the connection.
            // if ()
            //  localPeer->disconnectFromPeer (id, TooManyInvalidPackets);
            forward = false;
        }
        forward = isValid;
/*qDebug() << "\tPacket stats: count(" << statsPacket->count
         << "), bytes(" << statsPacket->bytes
         << "), badCount(" << statsPacket->badCount
         << "), badBytes(" << statsPacket->badBytes
         << ")";*/
    } else {
        connectionStats->unknownCount++;
        connectionStats->unknownBytes += packet.packetLength();
        forward = false;
    }
/*qDebug() << "\tConnection stats: totalCount(" << statsConnection->totalCount
         << "), totalBytes(" << statsConnection->totalBytes
         << "), badCount(" << statsConnection->badCount
         << "), badBytes(" << statsConnection->badBytes
         << "), unknownCount(" << statsConnection->unknownCount
         << "), unknownBytes(" << statsConnection->unknownBytes
         << ")";*/
    return forward;
}

bool PacketMonitor::filterInput (ConnectionId connectionId, const Packet &packet)
{
    Q_ASSERT (connectionInputStats.contains (connectionId));
    Q_ASSERT (connectionInputPacketStats.contains (connectionId));

    ConnectionStats *connectionStats = connectionInputStats [connectionId];
    PacketStats *packetStats = connectionInputPacketStats.packetData (connectionId, packet.payloadDescriptor());

    localPeer->packetModel.insertPacket (&packet, PacketModel::Incomming);
    return filter (connectionStats, packetStats, packet);
}

bool PacketMonitor::filterOutput (ConnectionId connectionId, const Packet &packet)
{
    Q_ASSERT (connectionOutputStats.contains (connectionId));
    Q_ASSERT (connectionOutputPacketStats.contains (connectionId));

    ConnectionStats *connectionStats = connectionOutputStats [connectionId];
    PacketStats *packetStats = connectionOutputPacketStats.packetData (connectionId, packet.payloadDescriptor());

    localPeer->packetModel.insertPacket (&packet, PacketModel::Outgoing);
    return filter (connectionStats, packetStats, packet);
}
#endif

Copyright © 2006 Peter Dimov.
Powered by Doxygen.