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

Converts between IPv6Datagram and binary (network byte order) Ipv6 header. More...

#include <Ipv6HeaderSerializer.h>

Inheritance diagram for inet::Ipv6HeaderSerializer:
inet::FieldsChunkSerializer inet::ChunkSerializer

Public Member Functions

 Ipv6HeaderSerializer ()
 
- 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 IPv6Datagram and binary (network byte order) Ipv6 header.

Constructor & Destructor Documentation

◆ Ipv6HeaderSerializer()

inet::Ipv6HeaderSerializer::Ipv6HeaderSerializer ( )
inline
24 : FieldsChunkSerializer() {}

Member Function Documentation

◆ deserialize()

const Ptr< Chunk > inet::Ipv6HeaderSerializer::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.

100 {
101  auto ipv6Header = makeShared<Ipv6Header>();
102  ipv6Header->setVersion(stream.readUint4());
103  if (ipv6Header->getVersion() != 6)
104  ipv6Header->markIncorrect();
105  ipv6Header->setTrafficClass(stream.readUint8());
106  ipv6Header->setFlowLabel(stream.readNBitsToUint64Be(20));
107  ipv6Header->setPayloadLength(B(stream.readUint16Be()));
108  IpProtocolId nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
109  ipv6Header->setProtocolId(nextHeaderId);
110  ipv6Header->setHopLimit(stream.readByte());
111  ipv6Header->setSrcAddress(stream.readIpv6Address());
112  ipv6Header->setDestAddress(stream.readIpv6Address());
113  bool mbool = true;
114  while (mbool) {
115  switch (nextHeaderId) {
116  case IP_PROT_IPv6EXT_HOP: {
117  Ipv6HopByHopOptionsHeader *extHdr = new Ipv6HopByHopOptionsHeader();
118  extHdr->setExtensionType(nextHeaderId);
119  nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
120  uint8_t hdrExtLen = stream.readByte();
121  uint16_t hdrLen = hdrExtLen * 8 + 8;
122  extHdr->setByteLength(B(hdrLen));
123  stream.readByteRepeatedly(0, hdrLen - 2); // TODO
124  ipv6Header->appendExtensionHeader(extHdr);
125  break;
126  }
127  case IP_PROT_IPv6EXT_DEST: {
128  Ipv6DestinationOptionsHeader *extHdr = new Ipv6DestinationOptionsHeader();
129  extHdr->setExtensionType(nextHeaderId);
130  nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
131  uint8_t hdrExtLen = stream.readByte();
132  uint16_t hdrLen = hdrExtLen * 8 + 8;
133  extHdr->setByteLength(B(hdrLen));
134  stream.readByteRepeatedly(0, hdrLen - 2); // TODO
135  ipv6Header->appendExtensionHeader(extHdr);
136  break;
137  }
138  case IP_PROT_IPv6EXT_ROUTING: {
139  Ipv6RoutingHeader *extHdr = new Ipv6RoutingHeader();
140  extHdr->setExtensionType(nextHeaderId);
141  nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
142  uint8_t hdrExtLen = stream.readByte();
143  uint16_t hdrLen = hdrExtLen * 8 + 8;
144  extHdr->setByteLength(B(hdrLen));
145  extHdr->setRoutingType(stream.readByte());
146  extHdr->setSegmentsLeft(stream.readByte());
147  stream.readByteRepeatedly(0, hdrLen - 2); // TODO
148  ipv6Header->appendExtensionHeader(extHdr);
149  break;
150  }
151  case IP_PROT_IPv6EXT_FRAGMENT: {
152  Ipv6FragmentHeader *extHdr = new Ipv6FragmentHeader();
153  extHdr->setExtensionType(nextHeaderId);
154  nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
155  // hdrExtLen ignored, see RFC2460: it's only a reserved field for fragment header
156  stream.readByte();
157  extHdr->setByteLength(IPv6_FRAGMENT_HEADER_LENGTH);
158  extHdr->setFragmentOffset(stream.readNBitsToUint64Be(13) * 8);
159  extHdr->setReserved(stream.readUint2());
160  extHdr->setMoreFragments(stream.readBit());
161  extHdr->setIdentification(stream.readUint32Be());
162  ipv6Header->appendExtensionHeader(extHdr);
163  break;
164  }
165  case IP_PROT_IPv6EXT_AUTH: {
166  Ipv6AuthenticationHeader *extHdr = new Ipv6AuthenticationHeader();
167  extHdr->setExtensionType(nextHeaderId);
168  nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
169  uint8_t hdrExtLen = stream.readByte();
170  uint16_t hdrLen = hdrExtLen * 8 + 8;
171  extHdr->setByteLength(B(hdrLen));
172  stream.readByteRepeatedly(0, hdrLen - 2); // TODO
173  ipv6Header->appendExtensionHeader(extHdr);
174  break;
175  }
176  case IP_PROT_IPv6EXT_ESP: {
177  Ipv6EncapsulatingSecurityPayloadHeader *extHdr = new Ipv6EncapsulatingSecurityPayloadHeader();
178  extHdr->setExtensionType(nextHeaderId);
179  nextHeaderId = static_cast<IpProtocolId>(stream.readByte());
180  uint8_t hdrExtLen = stream.readByte();
181  uint16_t hdrLen = hdrExtLen * 8 + 8;
182  extHdr->setByteLength(B(hdrLen));
183  stream.readByteRepeatedly(0, hdrLen - 2); // TODO
184  ipv6Header->appendExtensionHeader(extHdr);
185  break;
186  }
187  default: {
188  mbool = false;
189  break;
190  }
191  }
192  }
193  return ipv6Header;
194 }

◆ serialize()

void inet::Ipv6HeaderSerializer::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.

30 {
31  const auto& ipv6Header = staticPtrCast<const Ipv6Header>(chunk);
32  stream.writeUint4(ipv6Header->getVersion());
33  stream.writeUint8(ipv6Header->getTrafficClass());
34  stream.writeNBitsOfUint64Be(ipv6Header->getFlowLabel(), 20);
35  stream.writeUint16Be(B(ipv6Header->getPayloadLength()).get());
36  stream.writeByte(ipv6Header->getExtensionHeaderArraySize() != 0 ? ipv6Header->getExtensionHeader(0)->getExtensionType() : ipv6Header->getProtocolId());
37  stream.writeByte(ipv6Header->getHopLimit());
38  stream.writeIpv6Address(ipv6Header->getSrcAddress());
39  stream.writeIpv6Address(ipv6Header->getDestAddress());
40  B nextHdrCodePos = stream.getLength() + B(6);
41 
42  // FIXME serialize extension headers
43  for (size_t i = 0; i < ipv6Header->getExtensionHeaderArraySize(); i++) {
44  const Ipv6ExtensionHeader *extHdr = ipv6Header->getExtensionHeader(i);
45  stream.writeByte(i + 1 < ipv6Header->getExtensionHeaderArraySize() ? ipv6Header->getExtensionHeader(i + 1)->getExtensionType() : ipv6Header->getProtocolId());
46  ASSERT((B(extHdr->getByteLength()).get() & 7) == 0);
47  ASSERT(extHdr->getByteLength() <= B(255 * 8 + 8));
48  stream.writeByte((B(extHdr->getByteLength()).get() - 8) / 8);
49  switch (extHdr->getExtensionType()) {
50  case IP_PROT_IPv6EXT_HOP: {
51  const Ipv6HopByHopOptionsHeader *hdr = check_and_cast<const Ipv6HopByHopOptionsHeader *>(extHdr);
52  stream.writeByteRepeatedly(0, B(hdr->getByteLength()).get() - 2); // TODO
53  break;
54  }
55  case IP_PROT_IPv6EXT_DEST: {
56  const Ipv6DestinationOptionsHeader *hdr = check_and_cast<const Ipv6DestinationOptionsHeader *>(extHdr);
57  stream.writeByteRepeatedly(0, B(hdr->getByteLength()).get() - 2); // TODO
58  break;
59  }
60  case IP_PROT_IPv6EXT_ROUTING: {
61  const Ipv6RoutingHeader *hdr = check_and_cast<const Ipv6RoutingHeader *>(extHdr);
62  stream.writeByte(hdr->getRoutingType());
63  stream.writeByte(hdr->getSegmentsLeft());
64  for (unsigned int j = 0; j < hdr->getAddressArraySize(); j++) {
65  stream.writeIpv6Address(hdr->getAddress(j));
66  }
67  stream.writeByteRepeatedly(0, 4);
68  break;
69  }
70  case IP_PROT_IPv6EXT_FRAGMENT: {
71  const Ipv6FragmentHeader *hdr = check_and_cast<const Ipv6FragmentHeader *>(extHdr);
72  ASSERT(hdr->getByteLength() == IPv6_FRAGMENT_HEADER_LENGTH);
73  ASSERT((hdr->getFragmentOffset() & 7) == 0);
74  stream.writeNBitsOfUint64Be(hdr->getFragmentOffset() / 8, 13);
75  stream.writeUint2(hdr->getReserved());
76  stream.writeBit(hdr->getMoreFragments());
77  stream.writeUint32Be(hdr->getIdentification());
78  break;
79  }
80  case IP_PROT_IPv6EXT_AUTH: {
81  const Ipv6AuthenticationHeader *hdr = check_and_cast<const Ipv6AuthenticationHeader *>(extHdr);
82  stream.writeByteRepeatedly(0, B(hdr->getByteLength()).get() - 2); // TODO
83  break;
84  }
85  case IP_PROT_IPv6EXT_ESP: {
86  const Ipv6EncapsulatingSecurityPayloadHeader *hdr = check_and_cast<const Ipv6EncapsulatingSecurityPayloadHeader *>(extHdr);
87  stream.writeByteRepeatedly(0, B(hdr->getByteLength()).get() - 2); // TODO
88  break;
89  }
90  default: {
91  throw cRuntimeError("Unknown Ipv6 extension header %d (%s)%s", extHdr->getExtensionType(), extHdr->getClassName(), extHdr->getFullName());
92  break;
93  }
94  }
95  ASSERT(nextHdrCodePos + extHdr->getByteLength() == stream.getLength());
96  }
97 }
The documentation for this class was generated from the following files:
inet::IP_PROT_IPv6EXT_HOP
@ IP_PROT_IPv6EXT_HOP
Definition: IpProtocolId_m.h:111
inet::IP_PROT_IPv6EXT_AUTH
@ IP_PROT_IPv6EXT_AUTH
Definition: IpProtocolId_m.h:115
inet::IP_PROT_IPv6EXT_ESP
@ IP_PROT_IPv6EXT_ESP
Definition: IpProtocolId_m.h:116
inet::IP_PROT_IPv6EXT_DEST
@ IP_PROT_IPv6EXT_DEST
Definition: IpProtocolId_m.h:112
inet::IP_PROT_IPv6EXT_FRAGMENT
@ IP_PROT_IPv6EXT_FRAGMENT
Definition: IpProtocolId_m.h:114
inet::units::units::B
intscale< b, 1, 8 > B
Definition: Units.h:1168
inet::IP_PROT_IPv6EXT_ROUTING
@ IP_PROT_IPv6EXT_ROUTING
Definition: IpProtocolId_m.h:113
inet::IpProtocolId
IpProtocolId
Enum generated from inet/networklayer/common/IpProtocolId.msg:17 by opp_msgtool.
Definition: IpProtocolId_m.h:90
inet::IPv6_FRAGMENT_HEADER_LENGTH
const B IPv6_FRAGMENT_HEADER_LENGTH
Definition: Ipv6ExtensionHeaders_m.h:62