INET Framework for OMNeT++/OMNEST
Public Member Functions | Protected Member Functions | List of all members
inet::aodv::AodvControlPacketsSerializer Class Reference

Converts between AodvControlPackets and binary (network byte order) Aodv control packets. More...

#include <AodvControlPacketsSerializer.h>

Inheritance diagram for inet::aodv::AodvControlPacketsSerializer:
inet::FieldsChunkSerializer inet::ChunkSerializer

Public Member Functions

 AodvControlPacketsSerializer ()
 
- Public Member Functions inherited from inet::FieldsChunkSerializer
virtual void serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk, b offset, b length) const override
 Serializes a chunk into a stream by writing the bytes representing the chunk at the end of the stream. More...
 
virtual const Ptr< Chunk > deserialize (MemoryInputStream &stream, const std::type_info &typeInfo) const override
 Deserializes a chunk from a stream by reading the bytes at the current position of the stream. More...
 

Protected Member Functions

virtual void serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk) const override
 Serializes a chunk into a stream by writing all bytes representing the chunk at the end of the stream. More...
 
virtual const Ptr< Chunk > deserialize (MemoryInputStream &stream) const override
 Deserializes a chunk from a stream by reading the bytes at the current position of the stream. More...
 

Additional Inherited Members

- Static Public Attributes inherited from inet::ChunkSerializer
static b totalSerializedLength = b(0)
 
static b totalDeserializedLength = b(0)
 

Detailed Description

Converts between AodvControlPackets and binary (network byte order) Aodv control packets.

Constructor & Destructor Documentation

◆ AodvControlPacketsSerializer()

inet::aodv::AodvControlPacketsSerializer::AodvControlPacketsSerializer ( )
inline
26 : FieldsChunkSerializer() {}

Member Function Documentation

◆ deserialize()

const Ptr< Chunk > inet::aodv::AodvControlPacketsSerializer::deserialize ( MemoryInputStream &  stream) const
overrideprotectedvirtual

Deserializes a chunk from a stream by reading the bytes at the current position of the stream.

The current stream position is updated according to the length of the returned chunk.

Implements inet::FieldsChunkSerializer.

142 {
143  auto aodvControlPacket = makeShared<AodvControlPacket>();
144  AodvControlPacketType packetType = static_cast<AodvControlPacketType>(stream.readByte());
145  switch (packetType) {
146  case RREQ: {
147  auto aodvRreq = makeShared<Rreq>();
148  aodvRreq->setPacketType(packetType);
149  aodvRreq->setJoinFlag(stream.readBit());
150  aodvRreq->setRepairFlag(stream.readBit());
151  aodvRreq->setGratuitousRREPFlag(stream.readBit());
152  aodvRreq->setDestOnlyFlag(stream.readBit());
153  aodvRreq->setUnknownSeqNumFlag(stream.readBit());
154  aodvRreq->setReserved(stream.readNBitsToUint64Be(11));
155  aodvRreq->setHopCount(stream.readByte());
156  aodvRreq->setRreqId(stream.readUint32Be());
157  aodvRreq->setDestAddr(L3Address(stream.readIpv4Address()));
158  aodvRreq->setDestSeqNum(stream.readUint32Be());
159  aodvRreq->setOriginatorAddr(L3Address(stream.readIpv4Address()));
160  aodvRreq->setOriginatorSeqNum(stream.readUint32Be());
161  aodvRreq->setChunkLength(B(24));
162  return aodvRreq;
163  }
164  case RREQ_IPv6: {
165  auto aodvRreq = makeShared<Rreq>();
166  aodvRreq->setPacketType(packetType);
167  aodvRreq->setJoinFlag(stream.readBit());
168  aodvRreq->setRepairFlag(stream.readBit());
169  aodvRreq->setGratuitousRREPFlag(stream.readBit());
170  aodvRreq->setDestOnlyFlag(stream.readBit());
171  aodvRreq->setUnknownSeqNumFlag(stream.readBit());
172  aodvRreq->setReserved(stream.readNBitsToUint64Be(11));
173  aodvRreq->setHopCount(stream.readByte());
174  aodvRreq->setRreqId(stream.readUint32Be());
175  aodvRreq->setDestSeqNum(stream.readUint32Be());
176  aodvRreq->setOriginatorSeqNum(stream.readUint32Be());
177  aodvRreq->setDestAddr(L3Address(stream.readIpv6Address()));
178  aodvRreq->setOriginatorAddr(L3Address(stream.readIpv6Address()));
179  aodvRreq->setChunkLength(B(48));
180  return aodvRreq;
181  }
182  case RREP: {
183  auto aodvRrep = makeShared<Rrep>();
184  aodvRrep->setPacketType(packetType);
185  aodvRrep->setRepairFlag(stream.readBit());
186  aodvRrep->setAckRequiredFlag(stream.readBit());
187  aodvRrep->setReserved(stream.readNBitsToUint64Be(9));
188  aodvRrep->setPrefixSize(stream.readNBitsToUint64Be(5));
189  aodvRrep->setHopCount(stream.readByte());
190  aodvRrep->setDestAddr(L3Address(stream.readIpv4Address()));
191  aodvRrep->setDestSeqNum(stream.readUint32Be());
192  aodvRrep->setOriginatorAddr(L3Address(stream.readIpv4Address()));
193  aodvRrep->setLifeTime(SimTime(stream.readUint32Be(), SIMTIME_MS));
194  aodvRrep->setChunkLength(B(20));
195  return aodvRrep;
196  }
197  case RREP_IPv6: {
198  auto aodvRrep = makeShared<Rrep>();
199  aodvRrep->setPacketType(packetType);
200  aodvRrep->setRepairFlag(stream.readBit());
201  aodvRrep->setAckRequiredFlag(stream.readBit());
202  aodvRrep->setReserved(stream.readNBitsToUint64Be(7));
203  aodvRrep->setPrefixSize(stream.readNBitsToUint64Be(7));
204  aodvRrep->setHopCount(stream.readByte());
205  aodvRrep->setDestSeqNum(stream.readUint32Be());
206  aodvRrep->setDestAddr(L3Address(stream.readIpv6Address()));
207  aodvRrep->setOriginatorAddr(L3Address(stream.readIpv6Address()));
208  aodvRrep->setLifeTime(SimTime(stream.readUint32Be(), SIMTIME_MS));
209  aodvRrep->setChunkLength(B(44));
210  return aodvRrep;
211  }
212  case RERR: {
213  const auto& aodvRerr = makeShared<Rerr>();
214  aodvRerr->setPacketType(packetType);
215  aodvRerr->setNoDeleteFlag(stream.readBit());
216  aodvRerr->setReserved(stream.readNBitsToUint64Be(15));
217  aodvRerr->setUnreachableNodesArraySize(stream.readByte());
218  if (aodvRerr->getUnreachableNodesArraySize() == 0)
219  aodvRerr->markIncorrect();
220  UnreachableNode node = UnreachableNode();
221  for (uint8_t index = 0; index < aodvRerr->getUnreachableNodesArraySize(); ++index) {
222  node.addr = L3Address(stream.readIpv4Address());
223  node.seqNum = stream.readUint32Be();
224  aodvRerr->setUnreachableNodes(aodvRerr->getUnreachableNodesArraySize() - (index + 1), node);
225  }
226  aodvRerr->setChunkLength(B(4 + aodvRerr->getUnreachableNodesArraySize() * 8));
227  return aodvRerr;
228  }
229  case RERR_IPv6: {
230  const auto& aodvRerr = makeShared<Rerr>();
231  aodvRerr->setPacketType(packetType);
232  aodvRerr->setNoDeleteFlag(stream.readBit());
233  aodvRerr->setReserved(stream.readNBitsToUint64Be(15));
234  aodvRerr->setUnreachableNodesArraySize(stream.readByte());
235  if (aodvRerr->getUnreachableNodesArraySize() == 0)
236  aodvRerr->markIncorrect();
237  UnreachableNode node = UnreachableNode();
238  for (uint8_t index = 0; index < aodvRerr->getUnreachableNodesArraySize(); ++index) {
239  node.seqNum = stream.readUint32Be();
240  node.addr = L3Address(stream.readIpv6Address());
241  aodvRerr->setUnreachableNodes(aodvRerr->getUnreachableNodesArraySize() - (index + 1), node);
242  }
243  aodvRerr->setChunkLength(B(4 + aodvRerr->getUnreachableNodesArraySize() * (4 + 16)));
244  return aodvRerr;
245  }
246  case RREPACK:
247  case RREPACK_IPv6: {
248  const auto& aodvRrepAck = makeShared<RrepAck>();
249  aodvRrepAck->setPacketType(packetType);
250  aodvRrepAck->setReserved(stream.readByte());
251  return aodvRrepAck;
252  }
253  default: {
254  aodvControlPacket->setChunkLength(B(1));
255  aodvControlPacket->markIncorrect();
256  return aodvControlPacket;
257  }
258  }
259 }

◆ serialize()

void inet::aodv::AodvControlPacketsSerializer::serialize ( MemoryOutputStream &  stream,
const Ptr< const Chunk > &  chunk 
) const
overrideprotectedvirtual

Serializes a chunk into a stream by writing all bytes representing the chunk at the end of the stream.

Implements inet::FieldsChunkSerializer.

24 {
25  const auto& aodvControlPacket = staticPtrCast<const AodvControlPacket>(chunk);
26  switch (aodvControlPacket->getPacketType()) {
27  case RREQ: {
28  const auto& aodvRreq = CHK(dynamicPtrCast<const Rreq>(chunk));
29  stream.writeByte(aodvRreq->getPacketType());
30  stream.writeBit(aodvRreq->getJoinFlag());
31  stream.writeBit(aodvRreq->getRepairFlag());
32  stream.writeBit(aodvRreq->getGratuitousRREPFlag());
33  stream.writeBit(aodvRreq->getDestOnlyFlag());
34  stream.writeBit(aodvRreq->getUnknownSeqNumFlag());
35  stream.writeNBitsOfUint64Be(aodvRreq->getReserved(), 11);
36  stream.writeByte(aodvRreq->getHopCount());
37  stream.writeUint32Be(aodvRreq->getRreqId());
38  stream.writeIpv4Address(aodvRreq->getDestAddr().toIpv4());
39  stream.writeUint32Be(aodvRreq->getDestSeqNum());
40  stream.writeIpv4Address(aodvRreq->getOriginatorAddr().toIpv4());
41  stream.writeUint32Be(aodvRreq->getOriginatorSeqNum());
42  ASSERT(aodvRreq->getChunkLength() == B(24));
43  break;
44  }
45  case RREQ_IPv6: {
46  const auto& aodvRreq = CHK(dynamicPtrCast<const Rreq>(chunk));
47  stream.writeByte(aodvRreq->getPacketType());
48  stream.writeBit(aodvRreq->getJoinFlag());
49  stream.writeBit(aodvRreq->getRepairFlag());
50  stream.writeBit(aodvRreq->getGratuitousRREPFlag());
51  stream.writeBit(aodvRreq->getDestOnlyFlag());
52  stream.writeBit(aodvRreq->getUnknownSeqNumFlag());
53  stream.writeNBitsOfUint64Be(aodvRreq->getReserved(), 11);
54  stream.writeByte(aodvRreq->getHopCount());
55  stream.writeUint32Be(aodvRreq->getRreqId());
56  stream.writeUint32Be(aodvRreq->getDestSeqNum());
57  stream.writeUint32Be(aodvRreq->getOriginatorSeqNum());
58  stream.writeIpv6Address(aodvRreq->getDestAddr().toIpv6());
59  stream.writeIpv6Address(aodvRreq->getOriginatorAddr().toIpv6());
60  ASSERT(aodvRreq->getChunkLength() == B(48));
61  break;
62  }
63  case RREP: {
64  const auto& aodvRrep = CHK(dynamicPtrCast<const Rrep>(chunk));
65  stream.writeByte(aodvRrep->getPacketType());
66  stream.writeBit(aodvRrep->getRepairFlag());
67  stream.writeBit(aodvRrep->getAckRequiredFlag());
68  stream.writeNBitsOfUint64Be(aodvRrep->getReserved(), 9);
69  stream.writeNBitsOfUint64Be(aodvRrep->getPrefixSize(), 5);
70  stream.writeByte(aodvRrep->getHopCount());
71  stream.writeIpv4Address(aodvRrep->getDestAddr().toIpv4());
72  stream.writeUint32Be(aodvRrep->getDestSeqNum());
73  stream.writeIpv4Address(aodvRrep->getOriginatorAddr().toIpv4());
74  stream.writeUint32Be(aodvRrep->getLifeTime().inUnit(SIMTIME_MS));
75  ASSERT(aodvRrep->getChunkLength() == B(20));
76  break;
77  }
78  case RREP_IPv6: {
79  const auto& aodvRrep = CHK(dynamicPtrCast<const Rrep>(chunk));
80  stream.writeByte(aodvRrep->getPacketType());
81  stream.writeBit(aodvRrep->getRepairFlag());
82  stream.writeBit(aodvRrep->getAckRequiredFlag());
83  stream.writeNBitsOfUint64Be(aodvRrep->getReserved(), 7);
84  stream.writeNBitsOfUint64Be(aodvRrep->getPrefixSize(), 7);
85  stream.writeByte(aodvRrep->getHopCount());
86  stream.writeUint32Be(aodvRrep->getDestSeqNum());
87  stream.writeIpv6Address(aodvRrep->getDestAddr().toIpv6());
88  stream.writeIpv6Address(aodvRrep->getOriginatorAddr().toIpv6());
89  stream.writeUint32Be(aodvRrep->getLifeTime().inUnit(SIMTIME_MS));
90  ASSERT(aodvRrep->getChunkLength() == B(44));
91  break;
92  }
93  case RERR: {
94  const auto& aodvRerr = CHK(dynamicPtrCast<const Rerr>(chunk));
95  stream.writeByte(aodvRerr->getPacketType());
96  stream.writeBit(aodvRerr->getNoDeleteFlag());
97  stream.writeNBitsOfUint64Be(aodvRerr->getReserved(), 15);
98  if (aodvRerr->getUnreachableNodesArraySize() == 0) {
99  throw cRuntimeError("Cannot serialize AODV control packet of type %d: DestCount must be at least 1.", aodvControlPacket->getPacketType());
100  }
101 
102  stream.writeByte(aodvRerr->getUnreachableNodesArraySize());
103  for (uint8_t index = 0; index < aodvRerr->getUnreachableNodesArraySize(); ++index) {
104  stream.writeIpv4Address(aodvRerr->getUnreachableNodes(aodvRerr->getUnreachableNodesArraySize() - (index + 1)).addr.toIpv4());
105  stream.writeUint32Be(aodvRerr->getUnreachableNodes(aodvRerr->getUnreachableNodesArraySize() - (index + 1)).seqNum);
106  }
107  ASSERT(aodvRerr->getChunkLength() == B(4 + aodvRerr->getUnreachableNodesArraySize() * 8));
108  break;
109  }
110  case RERR_IPv6: {
111  const auto& aodvRerr = CHK(dynamicPtrCast<const Rerr>(chunk));
112  stream.writeByte(aodvRerr->getPacketType());
113  stream.writeBit(aodvRerr->getNoDeleteFlag());
114  stream.writeNBitsOfUint64Be(aodvRerr->getReserved(), 15);
115  if (aodvRerr->getUnreachableNodesArraySize() == 0) {
116  throw cRuntimeError("Cannot serialize AODV control packet of type %d: DestCount must be at least 1.", aodvControlPacket->getPacketType());
117  }
118 
119  stream.writeByte(aodvRerr->getUnreachableNodesArraySize());
120  for (uint8_t index = 0; index < aodvRerr->getUnreachableNodesArraySize(); ++index) {
121  stream.writeUint32Be(aodvRerr->getUnreachableNodes(aodvRerr->getUnreachableNodesArraySize() - (index + 1)).seqNum);
122  stream.writeIpv6Address(aodvRerr->getUnreachableNodes(aodvRerr->getUnreachableNodesArraySize() - (index + 1)).addr.toIpv6());
123  }
124  ASSERT(aodvRerr->getChunkLength() == B(4 + aodvRerr->getUnreachableNodesArraySize() * (4 + 16)));
125  break;
126  }
127  case RREPACK:
128  case RREPACK_IPv6: {
129  const auto& aodvRrepAck = CHK(dynamicPtrCast<const RrepAck>(chunk));
130  stream.writeByte(aodvRrepAck->getPacketType());
131  stream.writeByte(aodvRrepAck->getReserved());
132  ASSERT(aodvRrepAck->getChunkLength() == B(2));
133  break;
134  }
135  default: {
136  throw cRuntimeError("Cannot serialize AODV control packet: type %d not supported.", aodvControlPacket->getPacketType());
137  }
138  }
139 }
The documentation for this class was generated from the following files:
CHK
#define CHK(x)
Definition: INETDefs.h:87
inet::aodv::RERR
@ RERR
Definition: AodvControlPackets_m.h:77
inet::aodv::AodvControlPacketType
AodvControlPacketType
Enum generated from inet/routing/aodv/AodvControlPackets.msg:15 by opp_msgtool.
Definition: AodvControlPackets_m.h:74
inet::aodv::RREQ
@ RREQ
Definition: AodvControlPackets_m.h:75
inet::aodv::RREP_IPv6
@ RREP_IPv6
Definition: AodvControlPackets_m.h:80
inet::aodv::RREQ_IPv6
@ RREQ_IPv6
Definition: AodvControlPackets_m.h:79
inet::units::units::B
intscale< b, 1, 8 > B
Definition: Units.h:1168
inet::aodv::RREP
@ RREP
Definition: AodvControlPackets_m.h:76
inet::aodv::RERR_IPv6
@ RERR_IPv6
Definition: AodvControlPackets_m.h:81
inet::aodv::RREPACK_IPv6
@ RREPACK_IPv6
Definition: AodvControlPackets_m.h:82
inet::aodv::RREPACK
@ RREPACK
Definition: AodvControlPackets_m.h:78