local-face.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NFD_DAEMON_FACE_LOCAL_FACE_HPP
#define NFD_DAEMON_FACE_LOCAL_FACE_HPP

#include "face.hpp"
#include <ndn-cxx/management/nfd-control-parameters.hpp>

namespace nfd {

using ndn::nfd::LocalControlFeature;
using ndn::nfd::LOCAL_CONTROL_FEATURE_INCOMING_FACE_ID;
using ndn::nfd::LOCAL_CONTROL_FEATURE_NEXT_HOP_FACE_ID;

class LocalFace : public Face
{
public:
  LocalFace(const FaceUri& remoteUri, const FaceUri& localUri);

  bool
  isLocalControlHeaderEnabled() const;

  bool
  isLocalControlHeaderEnabled(LocalControlFeature feature) const;

  void
  setLocalControlHeaderFeature(LocalControlFeature feature, bool enabled = true);

public:

  static const size_t LOCAL_CONTROL_FEATURE_MAX = 3; 
  static const size_t LOCAL_CONTROL_FEATURE_ANY = 0; 

protected:
  // statically overridden from Face

  bool
  decodeAndDispatchInput(const Block& element);

  // LocalFace-specific methods

  bool
  isEmptyFilteredLocalControlHeader(const ndn::nfd::LocalControlHeader& header) const;

  template<class Packet>
  Block
  filterAndEncodeLocalControlHeader(const Packet& packet);

private:
  std::vector<bool> m_localControlHeaderFeatures;
};

inline
LocalFace::LocalFace(const FaceUri& remoteUri, const FaceUri& localUri)
  : Face(remoteUri, localUri, true)
  , m_localControlHeaderFeatures(LocalFace::LOCAL_CONTROL_FEATURE_MAX)
{
}

inline bool
LocalFace::isLocalControlHeaderEnabled() const
{
  return m_localControlHeaderFeatures[LOCAL_CONTROL_FEATURE_ANY];
}

inline bool
LocalFace::isLocalControlHeaderEnabled(LocalControlFeature feature) const
{
  BOOST_ASSERT(0 < feature &&
               static_cast<size_t>(feature) < m_localControlHeaderFeatures.size());
  return m_localControlHeaderFeatures[feature];
}

inline void
LocalFace::setLocalControlHeaderFeature(LocalControlFeature feature, bool enabled/* = true*/)
{
  BOOST_ASSERT(0 < feature &&
               static_cast<size_t>(feature) < m_localControlHeaderFeatures.size());

  m_localControlHeaderFeatures[feature] = enabled;

  m_localControlHeaderFeatures[LOCAL_CONTROL_FEATURE_ANY] =
    std::find(m_localControlHeaderFeatures.begin() + 1,
              m_localControlHeaderFeatures.end(), true) <
              m_localControlHeaderFeatures.end();
  // 'find(..) < .end()' instead of 'find(..) != .end()' due to LLVM Bug 16816
}

inline bool
LocalFace::decodeAndDispatchInput(const Block& element)
{
  try {
    const Block& payload = ndn::nfd::LocalControlHeader::getPayload(element);

    // If received LocalControlHeader, but it is not enabled on the face
    if ((&payload != &element) && !this->isLocalControlHeaderEnabled())
      return false;

    if (payload.type() == tlv::Interest)
      {
        shared_ptr<Interest> i = make_shared<Interest>();
        i->wireDecode(payload);
        if (&payload != &element)
          {
            uint8_t mask = 0;
            if (this->isLocalControlHeaderEnabled(LOCAL_CONTROL_FEATURE_NEXT_HOP_FACE_ID)) {
              mask |= ndn::nfd::LocalControlHeader::ENCODE_NEXT_HOP;
            }
            i->getLocalControlHeader().wireDecode(element, mask);
          }

        this->emitSignal(onReceiveInterest, *i);
      }
    else if (payload.type() == tlv::Data)
      {
        shared_ptr<Data> d = make_shared<Data>();
        d->wireDecode(payload);

        // if (&payload != &element)
        //   {
        //
        //     d->getLocalControlHeader().wireDecode(element,
        //       false,
        //       false);
        //   }

        this->emitSignal(onReceiveData, *d);
      }
    else
      return false;

    return true;
  }
  catch (const tlv::Error&) {
    return false;
  }
}

inline bool
LocalFace::isEmptyFilteredLocalControlHeader(const ndn::nfd::LocalControlHeader& header) const
{
  if (!this->isLocalControlHeaderEnabled())
    return true;

  uint8_t mask = 0;
  if (this->isLocalControlHeaderEnabled(LOCAL_CONTROL_FEATURE_INCOMING_FACE_ID)) {
    mask |= ndn::nfd::LocalControlHeader::ENCODE_INCOMING_FACE_ID;
  }
  return header.empty(mask);
}

template<class Packet>
inline Block
LocalFace::filterAndEncodeLocalControlHeader(const Packet& packet)
{
  uint8_t mask = 0;
  if (this->isLocalControlHeaderEnabled(LOCAL_CONTROL_FEATURE_INCOMING_FACE_ID)) {
    mask |= ndn::nfd::LocalControlHeader::ENCODE_INCOMING_FACE_ID;
  }
  return packet.getLocalControlHeader().wireEncode(packet, mask);
}

} // namespace nfd

#endif // NFD_DAEMON_FACE_LOCAL_FACE_HPP