PacketModel.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

*/

#include "Qt.h"
#include "PacketModel.h"
// \todo
#include "Gnutella/Packets/Packet.h"

PacketModel::PacketModel()
 :  packetList(), inIcon(), outIcon(), packetFlags(), flagValues()
{
    inIcon = QIcon ("Icons/inArrow.png");
    outIcon = QIcon ("Icons/outArrow.png");

    /*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");
    }*/

    flagValues.insert (tr ("Ping"), 0);
    flagValues.insert (tr ("Pong"), 2);
    flagValues.insert (tr ("Query"), 4);
    flagValues.insert (tr ("QueryHits"), 8);
    flagValues.insert (tr ("QueryRoutingReset"), 16);
    flagValues.insert (tr ("QueryRoutingPatch"), 32);

    packetFlags = ~packetFlags;
}

PacketModel::~PacketModel()
{
    foreach (PacketInfo *info, packetList)
        delete info;
    packetList.clear();
}

int PacketModel::rowCount (const QModelIndex &) const
{
    return packetList.count();
}

int PacketModel::columnCount (const QModelIndex &) const
{
    return 7; // timestamp, direction, name, ttl, hops, descriptorId, rawPayload
}

QVariant PacketModel::data (const QModelIndex &index, int role) const
{
    PacketInfo *packetInfo;
//  if (role != Qt::DisplayRole && role != Qt::DecorationRole)
//      return QVariant();

    packetInfo = packetList.value (index.row());

    if (role == Qt::DisplayRole) {
        switch (index.column())
        {
        case 0:     return (packetInfo->direction == Incomming) ? inIcon : outIcon;   // tr ("  -->") : tr ("  <--");
    //  case 1:     return packetInfo->timestamp.toString ("hh:mm:ss:zzz");
        case 1:     return packetInfo->timestamp;
        case 2:     return packetInfo->packetName; // rename to typeName() ??
        case 3:     return static_cast <uint> (packetInfo->packetTtl);
        case 4:     return static_cast <uint> (packetInfo->packetHops);
        case 5:     return packetInfo->packetDescriptorId;
        case 6:     return packetInfo->packetRawPayload;
        default:    return QVariant();
        }
    }

    if (role == Qt::TextColorRole)
        return (packetInfo->direction == Incomming) ? QColor(8, 28, 194) : QColor(26, 138, 19);   // tr ("  -->") : tr ("  <--");

    if (role == Qt::DecorationRole && index.column() == 0)
        return (packetInfo->direction == Incomming) ? inIcon : outIcon;   // tr ("  -->") : tr ("  <--");

    if (role == Qt::TextAlignmentRole && index.column() != 6)
        return static_cast <uint> (Qt::AlignHCenter);

    return QVariant();
}

QVariant PacketModel::headerData (int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Vertical || role != Qt::DisplayRole)
        return QVariant();

    switch (section)
    {
    case 0:     return tr ("Dir");
    case 1:     return tr ("Timestamp");
    case 2:     return tr ("Type");
    case 3:     return tr ("TTL");
    case 4:     return tr ("Hops");
    case 5:     return tr ("Descriptor ID          ");
    case 6:     return tr ("Payload");
    default:    return QVariant();
    }
}

// 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 <uint> (data[i]);
//  stream.flush();
//  return res;
// }

static QString toString (const QByteArray &ba)
{
    int len = ba.count();
    QString result;

    for (int i=0; i<len; i++) {
        result.append (ba.at (i));
    }

    return result;
}

bool PacketModel::insertPacket (const Packet *packet, Direction direction)
{
//  if (packet->payloadDescriptor() != PingDescriptor && packet->payloadDescriptor() != PongDescriptor)
//      return false;

    QString name = packet->name();
    int i = flagValues.value (name);
    if (!((packetFlags & PacketFlags (i)) && (packetFlags & PacketFlags (1<<(direction + 6))))) {
        return 0;
    }

    PacketInfo *packetInfo = new PacketInfo;
//  packetInfo->packet = packet->copy();
//  packetInfo->packet = packet;
    packetInfo->packetName  = packet->name(); // rename to typeName() ??
    packetInfo->packetTtl   = packet->ttl();
    packetInfo->packetHops  = packet->hops();
    packetInfo->packetDescriptorId  = packet->descriptorId().toString();
//  packetInfo->packetRawPayload    = toHexString (packet->rawPayload());
    packetInfo->packetRawPayload    = toString (packet->rawPayload());
    packetInfo->timestamp = QTime::currentTime().toString ("hh:mm:ss:zzz");
    packetInfo->direction = direction;

    /*if (log)
        (*log)  << packetInfo->timestamp << "\t"
                << packetInfo->packetName << "\t"
                << packetInfo->packetTtl << "\t"
                << packetInfo->packetHops << "\t"
                << packetInfo->packetDescriptorId << "\t"
                << packetInfo->packetRawPayload << endl;
    */
    if (packetList.count() > MAX_ITEMS_TO_HOLD) {
//      beginRemoveRows (QModelIndex(), 0, 0);
        delete packetList.takeFirst();
        packetList.append (packetInfo);
        dataChanged (index (0, 0), index (packetList.count(), packetList.count()));
//      endRemoveRows();
    } else {
        beginInsertRows (QModelIndex(), packetList.count(), packetList.count());
        packetList.append (packetInfo);
        endInsertRows();
    }

    return true;
}

void PacketModel::setFlags (PacketFlags &flags)
{
    packetFlags = flags;

    return;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.