27 #include <ndn-cxx/lp/tags.hpp>
35 : nReassembling(reassembler)
40 : allowLocalFields(false)
41 , allowFragmentation(false)
42 , allowReassembly(false)
49 , m_fragmenter(m_options.fragmenterOptions, this)
50 , m_reassembler(m_options.reassemblerOptions, this)
57 GenericLinkService::doSendInterest(
const Interest& interest)
59 lp::Packet lpPacket(interest.wireEncode());
61 encodeLpFields(interest, lpPacket);
63 this->sendNetPacket(std::move(lpPacket));
67 GenericLinkService::doSendData(
const Data& data)
69 lp::Packet lpPacket(data.wireEncode());
71 encodeLpFields(data, lpPacket);
73 this->sendNetPacket(std::move(lpPacket));
77 GenericLinkService::doSendNack(
const lp::Nack& nack)
79 lp::Packet lpPacket(nack.getInterest().wireEncode());
80 lpPacket.add<lp::NackField>(nack.getHeader());
82 encodeLpFields(nack, lpPacket);
84 this->sendNetPacket(std::move(lpPacket));
88 GenericLinkService::encodeLpFields(
const ndn::TagHost& netPkt, lp::Packet& lpPacket)
91 shared_ptr<lp::IncomingFaceIdTag> incomingFaceIdTag = netPkt.getTag<lp::IncomingFaceIdTag>();
92 if (incomingFaceIdTag !=
nullptr) {
93 lpPacket.add<lp::IncomingFaceIdField>(*incomingFaceIdTag);
97 shared_ptr<lp::CongestionMarkTag> congestionMarkTag = netPkt.getTag<lp::CongestionMarkTag>();
98 if (congestionMarkTag !=
nullptr) {
99 lpPacket.add<lp::CongestionMarkField>(*congestionMarkTag);
104 GenericLinkService::sendNetPacket(lp::Packet&& pkt)
106 std::vector<lp::Packet> frags;
118 frags.push_back(pkt);
121 if (frags.size() > 1) {
123 this->assignSequences(frags);
128 BOOST_ASSERT(frags.size() > 0);
129 BOOST_ASSERT(!frags.front().has<lp::FragIndexField>());
130 BOOST_ASSERT(!frags.front().has<lp::FragCountField>());
133 for (
const lp::Packet& frag : frags) {
134 Transport::Packet tp(frag.wireEncode());
135 if (mtu !=
MTU_UNLIMITED && tp.packet.size() >
static_cast<size_t>(mtu)) {
145 GenericLinkService::assignSequence(lp::Packet& pkt)
147 pkt.set<lp::SequenceField>(++m_lastSeqNo);
151 GenericLinkService::assignSequences(std::vector<lp::Packet>& pkts)
153 std::for_each(pkts.begin(), pkts.end(), bind(&GenericLinkService::assignSequence,
this, _1));
157 GenericLinkService::doReceivePacket(Transport::Packet&& packet)
160 lp::Packet pkt(packet.packet);
162 if (!pkt.has<lp::FragmentField>()) {
167 if ((pkt.has<lp::FragIndexField>() || pkt.has<lp::FragCountField>()) &&
173 bool isReassembled =
false;
176 std::tie(isReassembled, netPkt, firstPkt) = m_reassembler.
receiveFragment(packet.remoteEndpoint,
179 this->decodeNetPacket(netPkt, firstPkt);
182 catch (
const tlv::Error& e) {
189 GenericLinkService::decodeNetPacket(
const Block& netPkt,
const lp::Packet& firstPkt)
192 switch (netPkt.type()) {
194 if (firstPkt.has<lp::NackField>()) {
195 this->decodeNack(netPkt, firstPkt);
198 this->decodeInterest(netPkt, firstPkt);
202 this->decodeData(netPkt, firstPkt);
206 NFD_LOG_FACE_WARN(
"unrecognized network-layer packet TLV-TYPE " << netPkt.type() <<
": DROP");
210 catch (
const tlv::Error& e) {
217 GenericLinkService::decodeInterest(
const Block& netPkt,
const lp::Packet& firstPkt)
219 BOOST_ASSERT(netPkt.type() == tlv::Interest);
220 BOOST_ASSERT(!firstPkt.has<lp::NackField>());
223 auto interest = make_shared<Interest>(netPkt);
225 if (firstPkt.has<lp::NextHopFaceIdField>()) {
227 interest->setTag(make_shared<lp::NextHopFaceIdTag>(firstPkt.get<lp::NextHopFaceIdField>()));
235 if (firstPkt.has<lp::CachePolicyField>()) {
241 if (firstPkt.has<lp::IncomingFaceIdField>()) {
245 if (firstPkt.has<lp::CongestionMarkField>()) {
246 interest->setTag(make_shared<lp::CongestionMarkTag>(firstPkt.get<lp::CongestionMarkField>()));
253 GenericLinkService::decodeData(
const Block& netPkt,
const lp::Packet& firstPkt)
255 BOOST_ASSERT(netPkt.type() == tlv::Data);
258 auto data = make_shared<Data>(netPkt);
260 if (firstPkt.has<lp::NackField>()) {
266 if (firstPkt.has<lp::NextHopFaceIdField>()) {
272 if (firstPkt.has<lp::CachePolicyField>()) {
276 data->setTag(make_shared<lp::CachePolicyTag>(firstPkt.get<lp::CachePolicyField>()));
283 if (firstPkt.has<lp::IncomingFaceIdField>()) {
287 if (firstPkt.has<lp::CongestionMarkField>()) {
288 data->setTag(make_shared<lp::CongestionMarkTag>(firstPkt.get<lp::CongestionMarkField>()));
295 GenericLinkService::decodeNack(
const Block& netPkt,
const lp::Packet& firstPkt)
297 BOOST_ASSERT(netPkt.type() == tlv::Interest);
298 BOOST_ASSERT(firstPkt.has<lp::NackField>());
300 lp::Nack nack((Interest(netPkt)));
301 nack.setHeader(firstPkt.get<lp::NackField>());
303 if (firstPkt.has<lp::NextHopFaceIdField>()) {
309 if (firstPkt.has<lp::CachePolicyField>()) {
315 if (firstPkt.has<lp::IncomingFaceIdField>()) {
319 if (firstPkt.has<lp::CongestionMarkField>()) {
320 nack.setTag(make_shared<lp::CongestionMarkTag>(firstPkt.get<lp::CongestionMarkField>()));
#define NFD_LOG_FACE_TRACE(msg)
Log a message at TRACE level.
counters provided by GenericLinkService
void receiveData(const Data &data)
delivers received Data to forwarding
PacketCounter nInLpInvalid
count of invalid LpPackets dropped before reassembly
const ssize_t MTU_UNLIMITED
indicates the transport has no limit on payload size
PacketCounter nFragmentationErrors
count of failed fragmentations
bool allowFragmentation
enables fragmentation
PacketCounter nInNetInvalid
count of invalid reassembled network-layer packets dropped
#define NFD_LOG_FACE_WARN(msg)
Log a message at WARN level.
const Transport * getTransport() const
Copyright (c) 2014-2015, Regents of the University of California, Arizona Board of Regents...
signal::Signal< LpReassembler, Transport::EndpointId, size_t > beforeTimeout
signals before a partial packet is dropped due to timeout
void sendPacket(Transport::Packet &&packet)
sends a lower-layer packet via Transport
std::tuple< bool, std::vector< lp::Packet > > fragmentPacket(const lp::Packet &packet, size_t mtu)
fragments a network-layer packet into link-layer packets
reassembles fragmented network-layer packets
void receiveNack(const lp::Nack &nack)
delivers received Nack to forwarding
PacketCounter nOutOverMtu
count of outgoing LpPackets dropped due to exceeding MTU limit
Options that control the behavior of GenericLinkService.
GenericLinkService(const Options &options=Options())
GenericLinkServiceCounters(const LpReassembler &reassembler)
#define NFD_LOG_INIT(name)
std::tuple< bool, Block, lp::Packet > receiveFragment(Transport::EndpointId remoteEndpoint, const lp::Packet &packet)
adds received fragment to buffer
bool allowLocalFields
enables encoding of IncomingFaceId, and decoding of NextHopFaceId and CachePolicy ...
void receiveInterest(const Interest &interest)
delivers received Interest to forwarding
bool allowReassembly
enables reassembly
PacketCounter nReassemblyTimeouts
count of dropped partial network-layer packets due to reassembly timeout