NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.5: NDN, CCN, CCNx, content centric networks
API Documentation
lp-reassembler.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014-2022, Regents of the University of California,
4  * Arizona Board of Regents,
5  * Colorado State University,
6  * University Pierre & Marie Curie, Sorbonne University,
7  * Washington University in St. Louis,
8  * Beijing Institute of Technology,
9  * The University of Memphis.
10  *
11  * This file is part of NFD (Named Data Networking Forwarding Daemon).
12  * See AUTHORS.md for complete list of NFD authors and contributors.
13  *
14  * NFD is free software: you can redistribute it and/or modify it under the terms
15  * of the GNU General Public License as published by the Free Software Foundation,
16  * either version 3 of the License, or (at your option) any later version.
17  *
18  * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
19  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
20  * PURPOSE. See the GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License along with
23  * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
24  */
25 
26 #include "lp-reassembler.hpp"
27 #include "link-service.hpp"
28 #include "common/global.hpp"
29 
30 #include <numeric>
31 
32 namespace nfd {
33 namespace face {
34 
36 
38  : m_options(options)
39  , m_linkService(linkService)
40 {
41 }
42 
43 std::tuple<bool, Block, lp::Packet>
45 {
46  BOOST_ASSERT(packet.has<lp::FragmentField>());
47 
48  static auto FALSE_RETURN = std::make_tuple(false, Block(), lp::Packet());
49 
50  // read and check FragIndex and FragCount
51  uint64_t fragIndex = 0;
52  uint64_t fragCount = 1;
53  if (packet.has<lp::FragIndexField>()) {
54  fragIndex = packet.get<lp::FragIndexField>();
55  }
56  if (packet.has<lp::FragCountField>()) {
57  fragCount = packet.get<lp::FragCountField>();
58  }
59 
60  if (fragIndex >= fragCount) {
61  NFD_LOG_FACE_WARN("reassembly error, FragIndex>=FragCount: DROP");
62  return FALSE_RETURN;
63  }
64 
65  if (fragCount > m_options.nMaxFragments) {
66  NFD_LOG_FACE_WARN("reassembly error, FragCount over limit: DROP");
67  return FALSE_RETURN;
68  }
69 
70  // check for fast path
71  if (fragIndex == 0 && fragCount == 1) {
72  auto frag = packet.get<lp::FragmentField>();
73  Block netPkt({frag.first, frag.second});
74  return {true, netPkt, packet};
75  }
76 
77  // check Sequence and compute message identifier
78  if (!packet.has<lp::SequenceField>()) {
79  NFD_LOG_FACE_WARN("reassembly error, Sequence missing: DROP");
80  return FALSE_RETURN;
81  }
82  lp::Sequence messageIdentifier = packet.get<lp::SequenceField>() - fragIndex;
83  Key key = std::make_tuple(remoteEndpoint, messageIdentifier);
84 
85  // add to PartialPacket
86  PartialPacket& pp = m_partialPackets[key];
87  if (pp.fragCount == 0) { // new PartialPacket
88  pp.fragCount = fragCount;
89  pp.nReceivedFragments = 0;
90  pp.fragments.resize(fragCount);
91  }
92  else {
93  if (fragCount != pp.fragCount) {
94  NFD_LOG_FACE_WARN("reassembly error, FragCount changed: DROP");
95  return FALSE_RETURN;
96  }
97  }
98 
99  if (pp.fragments[fragIndex].has<lp::SequenceField>()) {
100  NFD_LOG_FACE_TRACE("fragment already received: DROP");
101  return FALSE_RETURN;
102  }
103 
104  pp.fragments[fragIndex] = packet;
105  ++pp.nReceivedFragments;
106 
107  // check complete condition
108  if (pp.nReceivedFragments == pp.fragCount) {
109  Block reassembled = doReassembly(key);
110  lp::Packet firstFrag(std::move(pp.fragments[0]));
111  m_partialPackets.erase(key);
112  return std::make_tuple(true, reassembled, firstFrag);
113  }
114 
115  // set drop timer
116  pp.dropTimer = getScheduler().schedule(m_options.reassemblyTimeout, [=] { timeoutPartialPacket(key); });
117 
118  return FALSE_RETURN;
119 }
120 
121 Block
122 LpReassembler::doReassembly(const Key& key)
123 {
124  PartialPacket& pp = m_partialPackets[key];
125 
126  size_t payloadSize = std::accumulate(pp.fragments.begin(), pp.fragments.end(), 0U,
127  [&] (size_t sum, const lp::Packet& pkt) -> size_t {
128  ndn::Buffer::const_iterator fragBegin, fragEnd;
129  std::tie(fragBegin, fragEnd) = pkt.get<lp::FragmentField>();
130  return sum + std::distance(fragBegin, fragEnd);
131  });
132 
133  ndn::Buffer fragBuffer(payloadSize);
134  auto it = fragBuffer.begin();
135 
136  for (const lp::Packet& frag : pp.fragments) {
137  ndn::Buffer::const_iterator fragBegin, fragEnd;
138  std::tie(fragBegin, fragEnd) = frag.get<lp::FragmentField>();
139  it = std::copy(fragBegin, fragEnd, it);
140  }
141 
142  return Block(fragBuffer);
143 }
144 
145 void
146 LpReassembler::timeoutPartialPacket(const Key& key)
147 {
148  auto it = m_partialPackets.find(key);
149  if (it == m_partialPackets.end()) {
150  return;
151  }
152 
153  this->beforeTimeout(std::get<0>(key), it->second.nReceivedFragments);
154  m_partialPackets.erase(it);
155 }
156 
157 std::ostream&
158 operator<<(std::ostream& os, const FaceLogHelper<LpReassembler>& flh)
159 {
160  if (flh.obj.getLinkService() == nullptr) {
161  os << "[id=0,local=unknown,remote=unknown] ";
162  }
163  else {
164  os << FaceLogHelper<LinkService>(*flh.obj.getLinkService());
165  }
166  return os;
167 }
168 
169 } // namespace face
170 } // namespace nfd
NDN_CXX_NODISCARD bool has() const
Definition: packet.hpp:74
the upper part of a Face
Options that control the behavior of LpReassembler.
#define NFD_LOG_INIT(name)
Definition: logger.hpp:31
#define NFD_LOG_FACE_TRACE(msg)
Log a message at TRACE level.
signal::Signal< LpReassembler, EndpointId, size_t > beforeTimeout
signals before a partial packet is dropped due to timeout
Represents a TLV element of the NDN packet format.
Definition: block.hpp:44
uint64_t EndpointId
Identifies a remote endpoint on the link.
Definition: face-common.hpp:71
uint64_t Sequence
represents a sequence number
Definition: sequence.hpp:35
Scheduler & getScheduler()
Returns the global Scheduler instance for the calling thread.
Definition: global.cpp:70
Declare a field.
Definition: field-decl.hpp:176
FIELD::ValueType get(size_t index=0) const
Definition: packet.hpp:96
std::tuple< bool, Block, lp::Packet > receiveFragment(EndpointId remoteEndpoint, const lp::Packet &packet)
adds received fragment to the buffer
Copyright (c) 2011-2015 Regents of the University of California.
Definition: ndn-common.hpp:39
reassembles fragmented network-layer packets
LpReassembler(const Options &options, const LinkService *linkService=nullptr)
time::nanoseconds reassemblyTimeout
timeout before a partially reassembled packet is dropped
General-purpose automatically managed/resized buffer.
Definition: buffer.hpp:41
#define NFD_LOG_FACE_WARN(msg)
Log a message at WARN level.
size_t nMaxFragments
maximum number of fragments in a packet