821 lines
25 KiB
C++
821 lines
25 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 "arp.h"
|
|
|
|
#include <QHostAddress>
|
|
#include <QRegExp>
|
|
|
|
#define uintToMacStr(num) \
|
|
QString("%1").arg(num, 6*2, BASE_HEX, QChar('0')) \
|
|
.replace(QRegExp("([0-9a-fA-F]{2}\\B)"), "\\1:").toUpper()
|
|
|
|
ArpProtocol::ArpProtocol(StreamBase *stream, AbstractProtocol *parent)
|
|
: AbstractProtocol(stream, parent)
|
|
{
|
|
_hasPayload = false;
|
|
}
|
|
|
|
ArpProtocol::~ArpProtocol()
|
|
{
|
|
}
|
|
|
|
AbstractProtocol* ArpProtocol::createInstance(StreamBase *stream,
|
|
AbstractProtocol *parent)
|
|
{
|
|
return new ArpProtocol(stream, parent);
|
|
}
|
|
|
|
quint32 ArpProtocol::protocolNumber() const
|
|
{
|
|
return OstProto::Protocol::kArpFieldNumber;
|
|
}
|
|
|
|
void ArpProtocol::protoDataCopyInto(OstProto::Protocol &protocol) const
|
|
{
|
|
protocol.MutableExtension(OstProto::arp)->CopyFrom(data);
|
|
protocol.mutable_protocol_id()->set_id(protocolNumber());
|
|
}
|
|
|
|
void ArpProtocol::protoDataCopyFrom(const OstProto::Protocol &protocol)
|
|
{
|
|
if (protocol.protocol_id().id() == protocolNumber() &&
|
|
protocol.HasExtension(OstProto::arp))
|
|
data.MergeFrom(protocol.GetExtension(OstProto::arp));
|
|
}
|
|
|
|
QString ArpProtocol::name() const
|
|
{
|
|
return isRarp() ?
|
|
QString("Reverse Address Resolution Protocol") :
|
|
QString("Address Resolution Protocol");
|
|
}
|
|
|
|
QString ArpProtocol::shortName() const
|
|
{
|
|
return isRarp() ? QString("RARP") : QString("ARP");
|
|
}
|
|
|
|
/*!
|
|
Return the ProtocolIdType for your protocol \n
|
|
|
|
If your protocol doesn't have a protocolId field, you don't need to
|
|
reimplement this method - the base class implementation will do the
|
|
right thing
|
|
*/
|
|
#if 0
|
|
AbstractProtocol::ProtocolIdType ArpProtocol::protocolIdType() const
|
|
{
|
|
return ProtocolIdIp;
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
Return the protocolId for your protocol based on the 'type' requested \n
|
|
|
|
If not all types are valid for your protocol, handle the valid type(s)
|
|
and for the remaining fallback to the base class implementation; if your
|
|
protocol doesn't have a protocolId at all, you don't need to reimplement
|
|
this method - the base class will do the right thing
|
|
*/
|
|
quint32 ArpProtocol::protocolId(ProtocolIdType type) const
|
|
{
|
|
switch(type)
|
|
{
|
|
case ProtocolIdEth: return isRarp() ? 0x8035 : 0x0806;
|
|
default:break;
|
|
}
|
|
|
|
return AbstractProtocol::protocolId(type);
|
|
}
|
|
|
|
int ArpProtocol::fieldCount() const
|
|
{
|
|
return arp_fieldCount;
|
|
}
|
|
|
|
AbstractProtocol::FieldFlags ArpProtocol::fieldFlags(int index) const
|
|
{
|
|
AbstractProtocol::FieldFlags flags;
|
|
|
|
flags = AbstractProtocol::fieldFlags(index);
|
|
|
|
switch (index)
|
|
{
|
|
case arp_hwType:
|
|
case arp_protoType:
|
|
|
|
case arp_hwAddrLen:
|
|
case arp_protoAddrLen:
|
|
|
|
case arp_opCode:
|
|
|
|
case arp_senderHwAddr:
|
|
case arp_senderProtoAddr:
|
|
case arp_targetHwAddr:
|
|
case arp_targetProtoAddr:
|
|
break;
|
|
|
|
case arp_senderHwAddrMode:
|
|
case arp_senderHwAddrCount:
|
|
|
|
case arp_senderProtoAddrMode:
|
|
case arp_senderProtoAddrCount:
|
|
case arp_senderProtoAddrMask:
|
|
|
|
case arp_targetHwAddrMode:
|
|
case arp_targetHwAddrCount:
|
|
|
|
case arp_targetProtoAddrMode:
|
|
case arp_targetProtoAddrCount:
|
|
case arp_targetProtoAddrMask:
|
|
flags &= ~FrameField;
|
|
flags |= MetaField;
|
|
break;
|
|
|
|
default:
|
|
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
|
|
index);
|
|
break;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
QVariant ArpProtocol::fieldData(int index, FieldAttrib attrib,
|
|
int streamIndex) const
|
|
{
|
|
switch (index)
|
|
{
|
|
case arp_hwType:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Hardware Type");
|
|
case FieldValue:
|
|
return data.hw_type();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.hw_type());
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(2);
|
|
qToBigEndian((quint16) data.hw_type(), (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_protoType:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Protocol Type");
|
|
case FieldValue:
|
|
return data.proto_type();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.proto_type(), 4, BASE_HEX,
|
|
QChar('0'));
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(2);
|
|
qToBigEndian((quint16) data.proto_type(), (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_hwAddrLen:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Hardware Address Length");
|
|
case FieldValue:
|
|
return data.hw_addr_len();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.hw_addr_len());
|
|
case FieldFrameValue:
|
|
return QByteArray(1, (char) data.hw_addr_len());
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_protoAddrLen:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Protocol Address Length");
|
|
case FieldValue:
|
|
return data.proto_addr_len();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.proto_addr_len());
|
|
case FieldFrameValue:
|
|
return QByteArray(1, (char) data.proto_addr_len());
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_opCode:
|
|
{
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Operation Code");
|
|
case FieldValue:
|
|
return data.op_code();
|
|
case FieldTextValue:
|
|
return QString("%1").arg(data.op_code());
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(2);
|
|
qToBigEndian((quint16) data.op_code(), (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_senderHwAddr:
|
|
{
|
|
int u;
|
|
const int hwAddrStep = 1;
|
|
quint64 hwAddr = 0;
|
|
|
|
switch (data.sender_hw_addr_mode())
|
|
{
|
|
case OstProto::Arp::kFixed:
|
|
hwAddr = data.sender_hw_addr();
|
|
break;
|
|
case OstProto::Arp::kIncrement:
|
|
u = (streamIndex % data.sender_hw_addr_count()) *
|
|
hwAddrStep;
|
|
hwAddr = data.sender_hw_addr() + u;
|
|
break;
|
|
case OstProto::Arp::kDecrement:
|
|
u = (streamIndex % data.sender_hw_addr_count()) *
|
|
hwAddrStep;
|
|
hwAddr = data.sender_hw_addr() - u;
|
|
break;
|
|
default:
|
|
qWarning("Unhandled hw_addr_mode %d",
|
|
data.sender_hw_addr_mode());
|
|
}
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Hardware Address");
|
|
case FieldValue:
|
|
return hwAddr;
|
|
case FieldTextValue:
|
|
return uintToMacStr(hwAddr);
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(8);
|
|
qToBigEndian((quint64) hwAddr, (uchar*) fv.data());
|
|
fv.remove(0, 2);
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_senderProtoAddr:
|
|
{
|
|
int u;
|
|
quint32 subnet, host, protoAddr = 0;
|
|
|
|
switch(data.sender_proto_addr_mode())
|
|
{
|
|
case OstProto::Arp::kFixedHost:
|
|
protoAddr = data.sender_proto_addr();
|
|
break;
|
|
case OstProto::Arp::kIncrementHost:
|
|
u = streamIndex % data.sender_proto_addr_count();
|
|
subnet = data.sender_proto_addr()
|
|
& data.sender_proto_addr_mask();
|
|
host = (((data.sender_proto_addr()
|
|
& ~data.sender_proto_addr_mask()) + u)
|
|
& ~data.sender_proto_addr_mask());
|
|
protoAddr = subnet | host;
|
|
break;
|
|
case OstProto::Arp::kDecrementHost:
|
|
u = streamIndex % data.sender_proto_addr_count();
|
|
subnet = data.sender_proto_addr()
|
|
& data.sender_proto_addr_mask();
|
|
host = (((data.sender_proto_addr()
|
|
& ~data.sender_proto_addr_mask()) - u)
|
|
& ~data.sender_proto_addr_mask());
|
|
protoAddr = subnet | host;
|
|
break;
|
|
case OstProto::Arp::kRandomHost:
|
|
subnet = data.sender_proto_addr()
|
|
& data.sender_proto_addr_mask();
|
|
host = (qrand() & ~data.sender_proto_addr_mask());
|
|
protoAddr = subnet | host;
|
|
break;
|
|
default:
|
|
qWarning("Unhandled sender_proto_addr_mode = %d",
|
|
data.sender_proto_addr_mode());
|
|
}
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Protocol Address");
|
|
case FieldValue:
|
|
return protoAddr;
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(4);
|
|
qToBigEndian((quint32) protoAddr, (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
case FieldTextValue:
|
|
return QHostAddress(protoAddr).toString();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_targetHwAddr:
|
|
{
|
|
int u;
|
|
const int hwAddrStep = 1;
|
|
quint64 hwAddr = 0;
|
|
|
|
switch (data.target_hw_addr_mode())
|
|
{
|
|
case OstProto::Arp::kFixed:
|
|
hwAddr = data.target_hw_addr();
|
|
break;
|
|
case OstProto::Arp::kIncrement:
|
|
u = (streamIndex % data.target_hw_addr_count()) *
|
|
hwAddrStep;
|
|
hwAddr = data.target_hw_addr() + u;
|
|
break;
|
|
case OstProto::Arp::kDecrement:
|
|
u = (streamIndex % data.target_hw_addr_count()) *
|
|
hwAddrStep;
|
|
hwAddr = data.target_hw_addr() - u;
|
|
break;
|
|
default:
|
|
qWarning("Unhandled hw_addr_mode %d",
|
|
data.target_hw_addr_mode());
|
|
}
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Hardware Address");
|
|
case FieldValue:
|
|
return hwAddr;
|
|
case FieldTextValue:
|
|
return uintToMacStr(hwAddr);
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(8);
|
|
qToBigEndian((quint64) hwAddr, (uchar*) fv.data());
|
|
fv.remove(0, 2);
|
|
return fv;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case arp_targetProtoAddr:
|
|
{
|
|
int u;
|
|
quint32 subnet, host, protoAddr = 0;
|
|
|
|
switch(data.target_proto_addr_mode())
|
|
{
|
|
case OstProto::Arp::kFixedHost:
|
|
protoAddr = data.target_proto_addr();
|
|
break;
|
|
case OstProto::Arp::kIncrementHost:
|
|
u = streamIndex % data.target_proto_addr_count();
|
|
subnet = data.target_proto_addr()
|
|
& data.target_proto_addr_mask();
|
|
host = (((data.target_proto_addr()
|
|
& ~data.target_proto_addr_mask()) + u)
|
|
& ~data.target_proto_addr_mask());
|
|
protoAddr = subnet | host;
|
|
break;
|
|
case OstProto::Arp::kDecrementHost:
|
|
u = streamIndex % data.target_proto_addr_count();
|
|
subnet = data.target_proto_addr()
|
|
& data.target_proto_addr_mask();
|
|
host = (((data.target_proto_addr()
|
|
& ~data.target_proto_addr_mask()) - u)
|
|
& ~data.target_proto_addr_mask());
|
|
protoAddr = subnet | host;
|
|
break;
|
|
case OstProto::Arp::kRandomHost:
|
|
subnet = data.target_proto_addr()
|
|
& data.target_proto_addr_mask();
|
|
host = (qrand() & ~data.target_proto_addr_mask());
|
|
protoAddr = subnet | host;
|
|
break;
|
|
default:
|
|
qWarning("Unhandled target_proto_addr_mode = %d",
|
|
data.target_proto_addr_mode());
|
|
}
|
|
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Protocol Address");
|
|
case FieldValue:
|
|
return protoAddr;
|
|
case FieldFrameValue:
|
|
{
|
|
QByteArray fv;
|
|
fv.resize(4);
|
|
qToBigEndian((quint32) protoAddr, (uchar*) fv.data());
|
|
return fv;
|
|
}
|
|
case FieldTextValue:
|
|
return QHostAddress(protoAddr).toString();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Meta fields
|
|
case arp_senderHwAddrMode:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Hardware Address Mode");
|
|
case FieldValue:
|
|
return data.sender_hw_addr_mode();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_senderHwAddrCount:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Hardware Address Count");
|
|
case FieldValue:
|
|
return data.sender_hw_addr_count();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_senderProtoAddrMode:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Protocol Address Mode");
|
|
case FieldValue:
|
|
return data.sender_proto_addr_mode();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_senderProtoAddrCount:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Protocol Address Count");
|
|
case FieldValue:
|
|
return data.sender_proto_addr_count();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_senderProtoAddrMask:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Sender Protocol Address Mask");
|
|
case FieldValue:
|
|
return data.sender_proto_addr_mask();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case arp_targetHwAddrMode:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Hardware Address Mode");
|
|
case FieldValue:
|
|
return data.target_hw_addr_mode();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_targetHwAddrCount:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Hardware Address Count");
|
|
case FieldValue:
|
|
return data.target_hw_addr_count();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_targetProtoAddrMode:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Protocol Address Mode");
|
|
case FieldValue:
|
|
return data.target_proto_addr_mode();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_targetProtoAddrCount:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Protocol Address Count");
|
|
case FieldValue:
|
|
return data.target_proto_addr_count();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case arp_targetProtoAddrMask:
|
|
switch(attrib)
|
|
{
|
|
case FieldName:
|
|
return QString("Target Protocol Address Mask");
|
|
case FieldValue:
|
|
return data.target_proto_addr_mask();
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
|
|
index);
|
|
break;
|
|
}
|
|
|
|
return AbstractProtocol::fieldData(index, attrib, streamIndex);
|
|
}
|
|
|
|
bool ArpProtocol::setFieldData(int index, const QVariant &value,
|
|
FieldAttrib attrib)
|
|
{
|
|
bool isOk = false;
|
|
|
|
if (attrib != FieldValue)
|
|
goto _exit;
|
|
|
|
switch (index)
|
|
{
|
|
case arp_hwType:
|
|
{
|
|
uint hwType = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_hw_type(hwType);
|
|
break;
|
|
}
|
|
case arp_protoType:
|
|
{
|
|
uint protoType = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_proto_type(protoType);
|
|
break;
|
|
}
|
|
case arp_hwAddrLen:
|
|
{
|
|
uint hwAddrLen = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_hw_addr_len(hwAddrLen);
|
|
break;
|
|
}
|
|
case arp_protoAddrLen:
|
|
{
|
|
uint protoAddrLen = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_proto_addr_len(protoAddrLen);
|
|
break;
|
|
}
|
|
case arp_opCode:
|
|
{
|
|
uint opCode = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_op_code(opCode);
|
|
break;
|
|
}
|
|
|
|
case arp_senderHwAddr:
|
|
{
|
|
quint64 hwAddr = value.toULongLong(&isOk);
|
|
if (isOk)
|
|
data.set_sender_hw_addr(hwAddr);
|
|
break;
|
|
}
|
|
case arp_senderHwAddrMode:
|
|
{
|
|
uint mode = value.toUInt(&isOk);
|
|
if (isOk && data.HwAddrMode_IsValid(mode))
|
|
data.set_sender_hw_addr_mode((OstProto::Arp::HwAddrMode) mode);
|
|
else
|
|
isOk = false;
|
|
break;
|
|
}
|
|
case arp_senderHwAddrCount:
|
|
{
|
|
uint count = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_sender_hw_addr_count(count);
|
|
break;
|
|
}
|
|
|
|
case arp_senderProtoAddr:
|
|
{
|
|
uint protoAddr = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_sender_proto_addr(protoAddr);
|
|
break;
|
|
}
|
|
case arp_senderProtoAddrMode:
|
|
{
|
|
uint mode = value.toUInt(&isOk);
|
|
if (isOk && data.ProtoAddrMode_IsValid(mode))
|
|
data.set_sender_proto_addr_mode(
|
|
(OstProto::Arp::ProtoAddrMode)mode);
|
|
else
|
|
isOk = false;
|
|
break;
|
|
}
|
|
case arp_senderProtoAddrCount:
|
|
{
|
|
uint count = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_sender_proto_addr_count(count);
|
|
break;
|
|
}
|
|
case arp_senderProtoAddrMask:
|
|
{
|
|
uint mask = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_sender_proto_addr_mask(mask);
|
|
break;
|
|
}
|
|
|
|
case arp_targetHwAddr:
|
|
{
|
|
quint64 hwAddr = value.toULongLong(&isOk);
|
|
if (isOk)
|
|
data.set_target_hw_addr(hwAddr);
|
|
break;
|
|
}
|
|
case arp_targetHwAddrMode:
|
|
{
|
|
uint mode = value.toUInt(&isOk);
|
|
if (isOk && data.HwAddrMode_IsValid(mode))
|
|
data.set_target_hw_addr_mode((OstProto::Arp::HwAddrMode)mode);
|
|
else
|
|
isOk = false;
|
|
break;
|
|
}
|
|
case arp_targetHwAddrCount:
|
|
{
|
|
uint count = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_target_hw_addr_count(count);
|
|
break;
|
|
}
|
|
|
|
case arp_targetProtoAddr:
|
|
{
|
|
uint protoAddr = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_target_proto_addr(protoAddr);
|
|
break;
|
|
}
|
|
case arp_targetProtoAddrMode:
|
|
{
|
|
uint mode = value.toUInt(&isOk);
|
|
if (isOk && data.ProtoAddrMode_IsValid(mode))
|
|
data.set_target_proto_addr_mode(
|
|
(OstProto::Arp::ProtoAddrMode)mode);
|
|
else
|
|
isOk = false;
|
|
break;
|
|
}
|
|
case arp_targetProtoAddrCount:
|
|
{
|
|
uint count = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_target_proto_addr_count(count);
|
|
break;
|
|
}
|
|
case arp_targetProtoAddrMask:
|
|
{
|
|
uint mask = value.toUInt(&isOk);
|
|
if (isOk)
|
|
data.set_target_proto_addr_mask(mask);
|
|
break;
|
|
}
|
|
|
|
|
|
default:
|
|
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
|
|
index);
|
|
break;
|
|
}
|
|
|
|
_exit:
|
|
return isOk;
|
|
}
|
|
|
|
int ArpProtocol::protocolFrameVariableCount() const
|
|
{
|
|
int count = AbstractProtocol::protocolFrameVariableCount();
|
|
|
|
if (fieldData(arp_senderHwAddrMode, FieldValue).toUInt()
|
|
!= uint(OstProto::Arp::kFixed))
|
|
{
|
|
count = AbstractProtocol::lcm(count,
|
|
fieldData(arp_senderHwAddrCount, FieldValue).toUInt());
|
|
}
|
|
|
|
if (fieldData(arp_senderProtoAddrMode, FieldValue).toUInt()
|
|
!= uint(OstProto::Arp::kFixedHost))
|
|
{
|
|
count = AbstractProtocol::lcm(count,
|
|
fieldData(arp_senderProtoAddrCount, FieldValue).toUInt());
|
|
}
|
|
|
|
if (fieldData(arp_targetHwAddrMode, FieldValue).toUInt()
|
|
!= uint(OstProto::Arp::kFixed))
|
|
{
|
|
count = AbstractProtocol::lcm(count,
|
|
fieldData(arp_targetHwAddrCount, FieldValue).toUInt());
|
|
}
|
|
|
|
if (fieldData(arp_targetProtoAddrMode, FieldValue).toUInt()
|
|
!= uint(OstProto::Arp::kFixedHost))
|
|
{
|
|
count = AbstractProtocol::lcm(count,
|
|
fieldData(arp_targetProtoAddrCount, FieldValue).toUInt());
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
bool ArpProtocol::isRarp() const
|
|
{
|
|
if ((data.op_code() == 3)
|
|
|| (data.op_code() ==4))
|
|
return true;
|
|
return false;
|
|
}
|