23 #include "../lp/packet.hpp"
24 #include "../lp/tags.hpp"
25 #include "../mgmt/nfd/controller.hpp"
26 #include "../mgmt/nfd/control-response.hpp"
27 #include "../transport/transport.hpp"
29 #include <boost/asio/io_service.hpp>
72 encoder.appendByteArray(payload.
wire(), payload.
size());
74 this->
send(encoder.block());
77 boost::asio::io_service&
90 , m_keyChain(*m_internalKeyChain)
92 this->construct(options);
98 , m_keyChain(keyChain)
100 this->construct(options);
107 , m_keyChain(*m_internalKeyChain)
109 this->construct(options);
115 , m_keyChain(keyChain)
117 this->construct(options);
121 DummyClientFace::construct(
const Options& options)
124 Block packet(blockFromDaemon);
126 lp::Packet lpPacket(packet);
128 Buffer::const_iterator begin, end;
129 std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
130 Block block(&*begin, std::distance(begin, end));
132 if (block.type() == tlv::Interest) {
133 shared_ptr<Interest> interest = make_shared<Interest>(block);
134 if (lpPacket.has<lp::NackField>()) {
135 shared_ptr<lp::Nack> nack = make_shared<lp::Nack>(std::move(*interest));
136 nack->setHeader(lpPacket.get<lp::NackField>());
137 if (lpPacket.has<lp::NextHopFaceIdField>()) {
138 nack->setTag(make_shared<lp::NextHopFaceIdTag>(lpPacket.get<lp::NextHopFaceIdField>()));
140 if (lpPacket.has<lp::CongestionMarkField>()) {
141 nack->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
146 if (lpPacket.has<lp::NextHopFaceIdField>()) {
147 interest->setTag(make_shared<lp::NextHopFaceIdTag>(lpPacket.get<lp::NextHopFaceIdField>()));
149 if (lpPacket.has<lp::CongestionMarkField>()) {
150 interest->setTag(make_shared<lp::CongestionMarkTag>(lpPacket.get<lp::CongestionMarkField>()));
152 onSendInterest(*interest);
156 shared_ptr<Data> data = make_shared<Data>(block);
169 if (options.enablePacketLogging)
170 this->enablePacketLogging();
172 if (options.enableRegistrationReply)
173 this->enableRegistrationReply();
175 m_processEventsOverride = options.processEventsOverride;
179 DummyClientFace::enablePacketLogging()
181 onSendInterest.connect([
this] (
const Interest& interest) {
182 this->sentInterests.push_back(interest);
184 onSendData.connect([
this] (
const Data& data) {
185 this->sentData.push_back(data);
187 onSendNack.connect([
this] (
const lp::Nack& nack) {
188 this->sentNacks.push_back(nack);
193 DummyClientFace::enableRegistrationReply()
195 onSendInterest.connect([
this] (
const Interest& interest) {
196 static const Name localhostRegistration(
"/localhost/nfd/rib");
197 if (!localhostRegistration.isPrefixOf(interest.getName()))
203 if (interest.getName().get(3) == name::Component(
"register")) {
209 resp.
setBody(params.wireEncode());
211 shared_ptr<Data> data = make_shared<Data>(interest.getName());
212 data->setContent(resp.wireEncode());
216 this->getIoService().post([
this, data] { this->receive(*data); });
220 template<
typename Field,
typename Tag,
typename Packet>
224 shared_ptr<Tag> tag =
static_cast<const TagHost&
>(packet).getTag<Tag>();
225 if (tag !=
nullptr) {
226 lpPacket.
add<Field>(*tag);
235 addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, interest);
236 addFieldFromTag<lp::NextHopFaceIdField, lp::NextHopFaceIdTag>(lpPacket, interest);
237 addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, interest);
239 static_pointer_cast<
Transport>(getTransport())->receive(lpPacket.wireEncode());
243 DummyClientFace::receive(
const Data& data)
247 addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, data);
248 addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, data);
250 static_pointer_cast<
Transport>(getTransport())->receive(lpPacket.wireEncode());
261 addFieldFromTag<lp::IncomingFaceIdField, lp::IncomingFaceIdTag>(lpPacket, nack);
262 addFieldFromTag<lp::CongestionMarkField, lp::CongestionMarkTag>(lpPacket, nack);
264 static_pointer_cast<
Transport>(getTransport())->receive(lpPacket.wireEncode());
268 DummyClientFace::doProcessEvents(
const time::milliseconds& timeout,
bool keepThread)
270 if (m_processEventsOverride !=
nullptr) {
271 m_processEventsOverride(timeout);
Copyright (c) 2013-2016 Regents of the University of California.
const NackHeader & getHeader() const
static void addFieldFromTag(lp::Packet &lpPacket, const Packet &packet)
void resume() override
resume the transport
Base class to store tag information (e.g., inside Interest and Data packets)
Packet & add(const typename FIELD::ValueType &value)
add a FIELD with value
void receive(Block block) const
const Interest & getInterest() const
Class representing a wire element of NDN-TLV packet format.
represents an Interest packet
use sha256 digest, no signer needs to be specified
ReceiveCallback m_receiveCallback
virtual void doProcessEvents(const time::milliseconds &timeout, bool keepThread)
boost::asio::io_service & getIoService()
represents a Network Nack
options for DummyClientFace
void pause() override
pause the transport
size_t wireEncode(EncodingImpl< TAG > &encoder, bool wantUnsignedPortionOnly=false) const
Fast encoding or block size estimation.
ndn::mgmt::ControlResponse ControlResponse
EncodingImpl< EncoderTag > EncodingBuffer
DummyClientFace(const Options &options=Options())
Create a dummy face with internal IO service.
shared_ptr< Transport > getTransport()
Provide a communication channel with local or remote NDN forwarder.
size_t wireEncode(EncodingImpl< TAG > &encoder) const
Fast encoding or block size estimation.
boost::asio::io_service * m_ioService
Signal< DummyClientFace, Data > onSendData
emits whenever a Data packet is sent
provides TLV-block delivery service
size_t appendByteArray(const uint8_t *array, size_t length)
Append a byte array array of length length.
a client-side face for unit testing
ControlResponse & setBody(const Block &body)
void send(const Block &wire) override
send a TLV block through the transport
void encode()
Encode subblocks into wire buffer.
The packet signing interface.
const uint8_t * wire() const
void close() override
Close the connection.
void send(const Block &header, const Block &payload) override
send two memory blocks through the transport
ControlResponse & setCode(uint32_t code)
Signal< Transport, Block > onSendBlock
virtual void connect(boost::asio::io_service &ioService, const ReceiveCallback &receiveCallback)
asynchronously open the connection