segment-producer.hpp

Go to the documentation of this file.

#ifndef NDNPH_APP_SEGMENT_PRODUCER_HPP
#define NDNPH_APP_SEGMENT_PRODUCER_HPP
 
#include "../face/packet-handler.hpp"
#include "../keychain/digest.hpp"
 
namespace ndnph {
 
class SegmentProducerBase : public PacketHandler {
public:
  struct Options {
    const PrivateKey& signer = DigestKey::get();
 
    size_t contentLen = 1000;
 
    uint32_t freshnessPeriod = 1000;
 
    int discovery = 2;
  };
  struct Options {…};
 
  explicit SegmentProducerBase(Face& face, Options opts)
    : PacketHandler(face)
    , m_opts(std::move(opts)) {}
  explicit SegmentProducerBase(Face& face, Options opts) {…}
 
  explicit SegmentProducerBase(Face& face)
    : SegmentProducerBase(face, Options()) {}
  explicit SegmentProducerBase(Face& face) {…}
 
  void setContent(Name prefix, const uint8_t* content, size_t size) {
    m_prefix = prefix;
    m_content = content;
    m_size = size;
    m_lastSegment = divCeil(std::max(size, static_cast<size_t>(1)), m_opts.contentLen) - 1;
  }
  void setContent(Name prefix, const uint8_t* content, size_t size) {…}
 
protected:
  Options m_opts;
  Name m_prefix;
  uint64_t m_lastSegment = 0;
  const uint8_t* m_content = nullptr;
  size_t m_size = 0;
};
class SegmentProducerBase : public PacketHandler {…};
 
template<typename SegmentConvention = convention::Segment, size_t regionCap = 2048>
class BasicSegmentProducer : public SegmentProducerBase {
public:
  using SegmentProducerBase::SegmentProducerBase;
 
private:
  bool processInterest(Interest interest) final {
    if (!m_prefix || m_content == nullptr) {
      return false;
    }
 
    const Name& interestName = interest.getName();
    size_t dataNameSize = m_prefix.size() + 1;
    if (interestName.size() == dataNameSize) {
      auto lastComp = interestName[-1];
      if (!m_prefix.isPrefixOf(interestName) || !lastComp.is<SegmentConvention>()) {
        return false;
      }
      return replySegment(lastComp.as<SegmentConvention>());
    }
 
    if (interestName.size() >= dataNameSize - m_opts.discovery &&
        interestName.isPrefixOf(m_prefix) && interest.getCanBePrefix()) {
      return replySegment(0);
    }
    return false;
  }
  bool processInterest(Interest interest) final {…}
 
  bool replySegment(uint64_t segment) {
    if (segment > m_lastSegment) {
      return true;
    }
 
    StaticRegion<regionCap> region;
    Data data = region.template create<Data>();
    NDNPH_ASSERT(!!data);
    data.setName(m_prefix.append(region, SegmentConvention(), segment));
    data.setFreshnessPeriod(m_opts.freshnessPeriod);
    data.setIsFinalBlock(segment == m_lastSegment);
    data.setContent(
      tlv::Value(m_content + m_opts.contentLen * segment,
                 m_content + std::min<size_t>(m_opts.contentLen * (segment + 1), m_size)));
    reply(data.sign(m_opts.signer));
    return true;
  }
};
class BasicSegmentProducer : public SegmentProducerBase {…};
 
using SegmentProducer = BasicSegmentProducer<>;
 
} // namespace ndnph
 
#endif // NDNPH_APP_SEGMENT_PRODUCER_HPP