595 lines
17 KiB
C++
595 lines
17 KiB
C++
/*
|
|
Copyright (C) 2010 Srivats P.
|
|
|
|
This file is part of "Ostinato"
|
|
|
|
This 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
|
|
#include "icmp.h"
|
|
|
|
#include <QSet>
|
|
#include <qendian.h>
|
|
|
|
enum IcmpType
|
|
{
|
|
kIcmpEchoReply = 0,
|
|
kIcmpDestinationUnreachable = 3,
|
|
kIcmpSourceQuench = 4,
|
|
kIcmpRedirect = 5,
|
|
kIcmpEchoRequest = 8,
|
|
kIcmpTimeExceeded = 11,
|
|
kIcmpParameterProblem = 12,
|
|
kIcmpTimestampRequest = 13,
|
|
kIcmpTimestampReply = 14,
|
|
kIcmpInformationRequest = 15,
|
|
kIcmpInformationReply = 16,
|
|
kIcmpAddressMaskRequest = 17,
|
|
kIcmpAddressMaskReply = 18
|
|
};
|
|
|
|
enum Icmp6Type
|
|
{
|
|
kIcmp6DestinationUnreachable = 1,
|
|
kIcmp6PacketTooBig = 2,
|
|
kIcmp6TimeExceeded = 3,
|
|
kIcmp6ParameterProblem = 4,
|
|
kIcmp6EchoRequest = 128,
|
|
kIcmp6EchoReply = 129,
|
|
kIcmp6RouterSolicitation = 133,
|
|
kIcmp6RouterAdvertisement = 134,
|
|
kIcmp6NeighbourSolicitation = 135,
|
|
kIcmp6NeighbourAdvertisement = 136,
|
|
kIcmp6Redirect = 137,
|
|
kIcmp6InformationQuery = 139,
|
|
kIcmp6InformationResponse = 140
|
|
};
|
|
|
|
static QSet<int> icmpIdSeqSet = QSet<int>()
|
|
<< kIcmpEchoRequest
|
|
<< kIcmpEchoReply
|
|
<< kIcmpInformationRequest
|
|
<< kIcmpInformationReply;
|
|
|
|
static QSet<int> icmp6IdSeqSet = QSet<int>()
|
|
<< kIcmp6EchoRequest
|
|
<< kIcmp6EchoReply;
|
|
|
|
static bool isIdSeqType(OstProto::Icmp::Version ver, int type)
|
|
{
|
|
//qDebug("%s: ver = %d, type = %d", __FUNCTION__, ver, type);
|
|
switch(ver)
|
|
{
|
|
case OstProto::Icmp::kIcmp4:
|
|
return icmpIdSeqSet.contains(type);
|
|
case OstProto::Icmp::kIcmp6:
|
|
return icmp6IdSeqSet.contains(type);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
Q_ASSERT(false); // unreachable
|
|
return false;
|
|
}
|
|
|
|
IcmpConfigForm::IcmpConfigForm(QWidget *parent)
|
|
: QWidget(parent)
|
|
{
|
|
versionGroup = new QButtonGroup(this);
|
|
setupUi(this);
|
|
|
|
// auto-connect's not working, for some reason I can't figure out!
|
|
// slot name changed to when_ instead of on_ so that connectSlotsByName()
|
|
// doesn't complain
|
|
connect(versionGroup,
|
|
SIGNAL(buttonClicked(int)),
|
|
SLOT(when_versionGroup_buttonClicked(int)));
|
|
|
|
versionGroup->addButton(icmp4Button, OstProto::Icmp::kIcmp4);
|
|
versionGroup->addButton(icmp6Button, OstProto::Icmp::kIcmp6);
|
|
|
|
typeCombo->setValidator(new QIntValidator(0, 0xFF, this));
|
|
|
|
icmp4Button->click();
|
|
|
|
idEdit->setValidator(new QIntValidator(0, 0xFFFF, this));
|
|
seqEdit->setValidator(new QIntValidator(0, 0xFFFF, this));
|
|
}
|
|
|
|
void IcmpConfigForm::on_typeCombo_currentIndexChanged(int /*index*/)
|
|
{
|
|
idSeqFrame->setVisible(
|
|
isIdSeqType(
|
|
OstProto::Icmp::Version(versionGroup->checkedId()),
|
|
typeCombo->currentValue()));
|
|
}
|
|
|
|
void IcmpConfigForm::when_versionGroup_buttonClicked(int id)
|
|
{
|
|
int value = typeCombo->currentValue();
|
|
|
|
typeCombo->clear();
|
|
|
|
switch(id)
|
|
{
|
|
case OstProto::Icmp::kIcmp4:
|
|
typeCombo->addItem(kIcmpEchoReply, "Echo Reply");
|
|
typeCombo->addItem(kIcmpDestinationUnreachable,
|
|
"Destination Unreachable");
|
|
typeCombo->addItem(kIcmpSourceQuench, "Source Quench");
|
|
typeCombo->addItem(kIcmpRedirect, "Redirect");
|
|
typeCombo->addItem(kIcmpEchoRequest, "Echo Request");
|
|
typeCombo->addItem(kIcmpTimeExceeded, "Time Exceeded");
|
|
typeCombo->addItem(kIcmpParameterProblem, "Parameter Problem");
|
|
typeCombo->addItem(kIcmpTimestampRequest, "Timestamp Request");
|
|
typeCombo->addItem(kIcmpTimestampReply, "Timestamp Reply");
|
|
typeCombo->addItem(kIcmpInformationRequest, "Information Request");
|
|
typeCombo->addItem(kIcmpInformationReply, "Information Reply");
|
|
typeCombo->addItem(kIcmpAddressMaskRequest, "Address Mask Request");
|
|
typeCombo->addItem(kIcmpAddressMaskReply, "Address Mask Reply");
|
|
break;
|
|
|
|
case OstProto::Icmp::kIcmp6:
|
|
typeCombo->addItem(kIcmp6DestinationUnreachable,
|
|
"Destination Unreachable");
|
|
typeCombo->addItem(kIcmp6PacketTooBig, "Packet Too Big");
|
|
typeCombo->addItem(kIcmp6TimeExceeded, "Time Exceeded");
|
|
typeCombo->addItem(kIcmp6ParameterProblem, "Parameter Problem");
|
|
|
|
typeCombo->addItem(kIcmp6EchoRequest, "Echo Request");
|
|
typeCombo->addItem(kIcmp6EchoReply, "Echo Reply");
|
|
typeCombo->addItem(kIcmp6RouterSolicitation, "Router Solicitation");
|
|
typeCombo->addItem(kIcmp6RouterAdvertisement, "Router Advertisement");
|
|
typeCombo->addItem(kIcmp6NeighbourSolicitation,
|
|
"Neighbour Solicitation");
|
|
typeCombo->addItem(kIcmp6NeighbourAdvertisement,
|
|
"Neighbour Advertisement");
|
|
typeCombo->addItem(kIcmp6Redirect, "Redirect");
|
|
typeCombo->addItem(kIcmp6InformationQuery, "Information Query");
|
|
typeCombo->addItem(kIcmp6InformationResponse, "Information Response");
|
|
break;
|
|
default:
|
|
Q_ASSERT(false);
|
|
}
|
|
|
|
typeCombo->setValue(value);
|
|
}
|
|
|
|
IcmpProtocol::IcmpProtocol(StreamBase *stream, AbstractProtocol *parent)
|
|
: AbstractProtocol(stream, parent)
|
|
{
|
|
configForm = NULL;
|
|
}
|
|
|
|
IcmpProtocol::~IcmpProtocol()
|
|
{
|
|
delete configForm;
|
|
}
|
|
|
|
AbstractProtocol* IcmpProtocol::createInstance(StreamBase *stream,
|
|
AbstractProtocol *parent)
|
|
{
|
|
return new IcmpProtocol(stream, parent);
|
|
}
|
|
|
|
quint32 IcmpProtocol::protocolNumber() const
|
|
{
|
|
return OstProto::Protocol::kIcmpFieldNumber;
|
|
}
|
|
|
|
void IcmpProtocol::protoDataCopyInto(OstProto::Protocol &protocol) const
|
|
{
|
|
protocol.MutableExtension(OstProto::icmp)->CopyFrom(data);
|
|
protocol.mutable_protocol_id()->set_id(protocolNumber());
|
|
}
|
|
|
|
void IcmpProtocol::protoDataCopyFrom(const OstProto::Protocol &protocol)
|
|
{
|
|
if (protocol.protocol_id().id() == protocolNumber() &&
|
|
protocol.HasExtension(OstProto::icmp))
|
|
data.MergeFrom(protocol.GetExtension(OstProto::icmp));
|
|
}
|
|
|
|
QString IcmpProtocol::name() const
|
|
{
|
|
return QString("Internet Control Message Protocol");
|
|
}
|
|
|
|
QString IcmpProtocol::shortName() const
|
|
{
|
|
return QString("ICMP");
|
|
}
|
|
|
|
quint32 IcmpProtocol::protocolId(ProtocolIdType type) const
|
|
{
|
|
switch(type)
|
|
{
|
|
case ProtocolIdIp:
|
|
switch(icmpVersion())
|
|
{
|
|
case OstProto::Icmp::kIcmp4: return 0x1;
|
|
case OstProto::Icmp::kIcmp6: return 0x3A;
|
|
default:break;
|
|
}
|
|
default:break;
|
|
}
|
|
|
|
return AbstractProtocol::protocolId(type);
|
|
}
|
|
|
|
int IcmpProtocol::fieldCount() const
|
|
{
|
|
return icmp_fieldCount;
|
|
}
|
|
|
|
int IcmpProtocol::frameFieldCount() const
|
|
{
|
|
int count;
|
|
|
|
if (isIdSeqType(icmpVersion(), icmpType()))
|
|
count = icmp_idSeqFrameFieldCount;
|
|
else
|
|
count = icmp_commonFrameFieldCount;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
AbstractProtocol::FieldFlags IcmpProtocol::fieldFlags(int index) const
|
|
{
|
|
AbstractProtocol::FieldFlags flags;
|
|
|
|
flags = AbstractProtocol::fieldFlags(index);
|
|
|
|
switch (index)
|
|
{
|
|
case icmp_type:
|
|
case icmp_code:
|
|
break;
|
|
|
|
case icmp_checksum:
|
|
flags |= CksumField;
|
|
break;
|
|
|
|
case icmp_identifier:
|
|
case icmp_sequence:
|
|
if (!isIdSeqType(icmpVersion(), icmpType()))
|
|
flags &= ~FrameField;
|
|
break;
|
|
|
|
case icmp_version:
|
|
case icmp_is_override_checksum:
|
|
flags &= ~FrameField;
|
|
flags |= MetaField;
|
|
break;
|
|
|
|
default:
|
|
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
|
|
index);
|
|
break;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
QVariant IcmpProtocol::fieldData(int index, FieldAttrib attrib,
|
|
int streamIndex) const
|
|
{
|
|
switch (index)
|
|
{
|
|
case icmp_type:
|
|
{
|
|
unsigned char type = data.type() & 0xFF;
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Type");
|
|
case FieldValue:
|
|
return type;
|
|
case FieldTextValue:
|
|
return QString("%1").arg((uint) type);
|
|
case FieldFrameValue:
|
|
return QByteArray(1, type);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
}
|
|
case icmp_code:
|
|
{
|
|
unsigned char code = data.code() & 0xFF;
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Code");
|
|
case FieldValue:
|
|
return code;
|
|
case FieldTextValue:
|
|
return QString("%1").arg((uint)code);
|
|
case FieldFrameValue:
|
|
return QByteArray(1, code);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
}
|
|
case icmp_checksum:
|
|
{
|
|
quint16 cksum;
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldValue:
|
|
case FieldFrameValue:
|
|
case FieldTextValue:
|
|
if (data.is_override_checksum())
|
|
{
|
|
cksum = data.checksum();
|
|
}
|
|
else
|
|
{
|
|
quint16 cks;
|
|
quint32 sum = 0;
|
|
|
|
cks = protocolFrameCksum(streamIndex, CksumIp);
|
|
sum += (quint16) ~cks;
|
|
cks = protocolFramePayloadCksum(streamIndex, CksumIp);
|
|
sum += (quint16) ~cks;
|
|
if (icmpVersion() == OstProto::Icmp::kIcmp6)
|
|
{
|
|
cks = protocolFrameHeaderCksum(streamIndex,
|
|
CksumIpPseudo);
|
|
sum += (quint16) ~cks;
|
|
}
|
|
|
|
while(sum>>16)
|
|
sum = (sum & 0xFFFF) + (sum >> 16);
|
|
|
|
cksum = (~sum) & 0xFFFF;
|
|
}
|
|
break;
|
|
default:
|
|
cksum = 0; // avoid the 'maybe used unitialized' warning
|
|
break;
|
|
}
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Checksum");
|
|
case FieldValue:
|
|
return cksum;
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
|
|
fv.resize(2);
|
|
qToBigEndian(cksum, (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
case FieldTextValue:
|
|
return QString("0x%1").arg(
|
|
cksum, 4, BASE_HEX, QChar('0'));;
|
|
case FieldBitSize:
|
|
return 16;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case icmp_identifier:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Identifier");
|
|
case FieldValue:
|
|
return data.identifier();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.identifier());
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(2);
|
|
qToBigEndian((quint16) data.identifier(),
|
|
(uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case icmp_sequence:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sequence");
|
|
case FieldValue:
|
|
return data.sequence();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.sequence());
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(2);
|
|
qToBigEndian((quint16) data.sequence(), (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
// Meta fields
|
|
case icmp_version:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldValue:
|
|
return data.icmp_version();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case icmp_is_override_checksum:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldValue:
|
|
return data.is_override_checksum();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
|
|
index);
|
|
break;
|
|
}
|
|
|
|
return AbstractProtocol::fieldData(index, attrib, streamIndex);
|
|
}
|
|
|
|
bool IcmpProtocol::setFieldData(int index, const QVariant &value,
|
|
FieldAttrib attrib)
|
|
{
|
|
bool isOk = false;
|
|
|
|
if (attrib != FieldValue)
|
|
goto _exit;
|
|
|
|
switch (index)
|
|
{
|
|
case icmp_type:
|
|
{
|
|
uint type = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_type(type & 0xFF);
|
|
break;
|
|
}
|
|
case icmp_code:
|
|
{
|
|
uint code = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_code(code & 0xFF);
|
|
break;
|
|
}
|
|
case icmp_checksum:
|
|
{
|
|
uint csum = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_checksum(csum);
|
|
break;
|
|
}
|
|
case icmp_identifier:
|
|
{
|
|
uint id = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_identifier(id);
|
|
break;
|
|
}
|
|
case icmp_sequence:
|
|
{
|
|
uint seq = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_sequence(seq);
|
|
break;
|
|
}
|
|
case icmp_version:
|
|
{
|
|
int ver = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_icmp_version(OstProto::Icmp::Version(ver));
|
|
break;
|
|
}
|
|
case icmp_is_override_checksum:
|
|
{
|
|
bool ovr = value.toBool();
|
|
data.set_is_override_checksum(ovr);
|
|
isOk = true;
|
|
break;
|
|
}
|
|
default:
|
|
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
|
|
index);
|
|
break;
|
|
}
|
|
|
|
_exit:
|
|
return isOk;
|
|
}
|
|
|
|
QWidget* IcmpProtocol::configWidget()
|
|
{
|
|
if (configForm == NULL)
|
|
{
|
|
configForm = new IcmpConfigForm;
|
|
loadConfigWidget();
|
|
}
|
|
|
|
return configForm;
|
|
}
|
|
|
|
void IcmpProtocol::loadConfigWidget()
|
|
{
|
|
configWidget();
|
|
|
|
configForm->versionGroup->button(icmpVersion())->click();
|
|
|
|
configForm->typeCombo->setValue(fieldData(icmp_type, FieldValue).toUInt());
|
|
configForm->codeEdit->setText(fieldData(icmp_code, FieldValue).toString());
|
|
|
|
configForm->overrideCksum->setChecked(
|
|
fieldData(icmp_is_override_checksum, FieldValue).toBool());
|
|
configForm->cksumEdit->setText(uintToHexStr(
|
|
fieldData(icmp_checksum, FieldValue).toUInt(), 2));
|
|
|
|
configForm->idEdit->setText(
|
|
fieldData(icmp_identifier, FieldValue).toString());
|
|
configForm->seqEdit->setText(
|
|
fieldData(icmp_sequence, FieldValue).toString());
|
|
|
|
}
|
|
|
|
void IcmpProtocol::storeConfigWidget()
|
|
{
|
|
bool isOk;
|
|
|
|
configWidget();
|
|
|
|
setFieldData(icmp_version, configForm->versionGroup->checkedId());
|
|
|
|
setFieldData(icmp_type, configForm->typeCombo->currentValue());
|
|
setFieldData(icmp_code, configForm->codeEdit->text());
|
|
|
|
setFieldData(icmp_is_override_checksum,
|
|
configForm->overrideCksum->isChecked());
|
|
setFieldData(icmp_checksum, configForm->cksumEdit->text().toUInt(&isOk, BASE_HEX));
|
|
|
|
setFieldData(icmp_identifier, configForm->idEdit->text());
|
|
setFieldData(icmp_sequence, configForm->seqEdit->text());
|
|
}
|
|
|