void
DummyClientFace::construct(const Options& options)
{
static_pointer_cast<Transport>(getTransport())->onSendBlock.connect([this] (const Block& blockFromDaemon) {
Block packet(blockFromDaemon);
packet.encode();
lp::Packet lpPacket(packet);
Buffer::const_iterator begin, end;
std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
Block block(&*begin, std::distance(begin, end));
if (block.type() == tlv::Interest) {
shared_ptr<Interest> interest = make_shared<Interest>(block);
if (lpPacket.has<lp::NackField>()) {
shared_ptr<lp::Nack> nack = make_shared<lp::Nack>(std::move(*interest));
nack->setHeader(lpPacket.get<lp::NackField>());
if (lpPacket.has<lp::NextHopFaceIdField>()) {
nack->setTag(make_shared<lp::NextHopFaceIdTag>(lpPacket.get<lp::NextHopFaceIdField>()));
}
if (lpPacket.has<lp::CongestionMarkField>()) {
nack->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
}
onSendNack(*nack);
}
else {
if (lpPacket.has<lp::NextHopFaceIdField>()) {
interest->setTag(make_shared<lp::NextHopFaceIdTag>(lpPacket.get<lp::NextHopFaceIdField>()));
}
if (lpPacket.has<lp::CongestionMarkField>()) {
interest->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
}
onSendInterest(*interest);
}
}
else if (block.type() == tlv::Data) {
shared_ptr<Data> data = make_shared<Data>(block);
if (lpPacket.has<lp::CachePolicyField>()) {
data->setTag(make_shared<lp::CachePolicyTag>(lpPacket.get<lp::CachePolicyField>()));
}
if (lpPacket.has<lp::CongestionMarkField>()) {
data->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
}
onSendData(*data);
}
});
if (options.enablePacketLogging)
this->enablePacketLogging();
if (options.enableRegistrationReply)
this->enableRegistrationReply();
m_processEventsOverride = options.processEventsOverride;
}
void
GenericLinkService::doSendInterest(const Interest& interest, const EndpointId& endpointId)
{
lp::Packet lpPacket(interest.wireEncode());
encodeLpFields(interest, lpPacket);
this->sendNetPacket(std::move(lpPacket), endpointId, true);
}
void
GenericLinkService::doSendData(const Data& data, const EndpointId& endpointId)
{
lp::Packet lpPacket(data.wireEncode());
encodeLpFields(data, lpPacket);
this->sendNetPacket(std::move(lpPacket), endpointId, false);
}
void
DummyClientFace::receive(const Data& data)
{
lp::Packet lpPacket(data.wireEncode());
addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, data);
addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, data);
static_pointer_cast<Transport>(getTransport())->receive(lpPacket.wireEncode());
}
void
GenericLinkService::doSendNack(const lp::Nack& nack, const EndpointId& endpointId)
{
lp::Packet lpPacket(nack.getInterest().wireEncode());
lpPacket.add<lp::NackField>(nack.getHeader());
encodeLpFields(nack, lpPacket);
this->sendNetPacket(std::move(lpPacket), endpointId, false);
}
void
DummyClientFace::receive(const Interest& interest)
{
lp::Packet lpPacket(interest.wireEncode());
addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, interest);
addFieldFromTag<lp::NextHopFaceIdField, lp::NextHopFaceIdTag>(lpPacket, interest);
addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, interest);
static_pointer_cast<Transport>(getTransport())->receive(lpPacket.wireEncode());
}
void
DummyClientFace::construct(const Options& options)
{
m_transport->onSendBlock.connect([this] (const Block& blockFromDaemon) {
try {
Block packet(blockFromDaemon);
packet.encode();
lp::Packet lpPacket(packet);
Buffer::const_iterator begin, end;
std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
Block block(&*begin, std::distance(begin, end));
if (block.type() == tlv::Interest) {
shared_ptr<Interest> interest = make_shared<Interest>(block);
if (lpPacket.has<lp::NackField>()) {
shared_ptr<lp::Nack> nack = make_shared<lp::Nack>(std::move(*interest));
nack->setHeader(lpPacket.get<lp::NackField>());
if (lpPacket.has<lp::NextHopFaceIdField>()) {
nack->getLocalControlHeader().setNextHopFaceId(lpPacket.get<lp::NextHopFaceIdField>());
}
onSendNack(*nack);
}
else {
if (lpPacket.has<lp::NextHopFaceIdField>()) {
interest->getLocalControlHeader().
setNextHopFaceId(lpPacket.get<lp::NextHopFaceIdField>());
}
onSendInterest(*interest);
}
}
else if (block.type() == tlv::Data) {
shared_ptr<Data> data = make_shared<Data>(block);
if (lpPacket.has<lp::CachePolicyField>()) {
if (lpPacket.get<lp::CachePolicyField>().getPolicy() == lp::CachePolicyType::NO_CACHE) {
data->getLocalControlHeader().setCachingPolicy(nfd::LocalControlHeader::CachingPolicy::NO_CACHE);
}
}
onSendData(*data);
}
}
catch (tlv::Error& e) {
throw tlv::Error("Error decoding NDNLPv2 packet");
}
});
if (options.enablePacketLogging)
this->enablePacketLogging();
if (options.enableRegistrationReply)
this->enableRegistrationReply();
}
void
DummyClientFace::receive(const Packet& packet)
{
lp::Packet lpPacket(packet.wireEncode());
nfd::LocalControlHeader localControlHeader = packet.getLocalControlHeader();
if (localControlHeader.hasIncomingFaceId()) {
lpPacket.add<lp::IncomingFaceIdField>(localControlHeader.getIncomingFaceId());
}
if (localControlHeader.hasNextHopFaceId()) {
lpPacket.add<lp::NextHopFaceIdField>(localControlHeader.getNextHopFaceId());
}
m_transport->receive(lpPacket.wireEncode());
}
