node.hpp

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

#include <ndn-cpp/common.hpp>
#include <ndn-cpp/interest.hpp>
#include <ndn-cpp/data.hpp>
#include <ndn-cpp/forwarding-flags.hpp>
#include <ndn-cpp/interest-filter.hpp>
#include <ndn-cpp/face.hpp>
#include "util/command-interest-generator.hpp"
#include "encoding/element-listener.hpp"

struct ndn_Interest;

namespace ndn {

class KeyChain;

class Node : public ElementListener {
public:
  Node(const ptr_lib::shared_ptr<Transport>& transport, const ptr_lib::shared_ptr<const Transport::ConnectionInfo>& connectionInfo);

  uint64_t
  expressInterest(const Interest& interest, const OnData& onData, const OnTimeout& onTimeout, WireFormat& wireFormat);

  void
  removePendingInterest(uint64_t pendingInterestId);

  void
  makeCommandInterest
    (Interest& interest, KeyChain& keyChain, const Name& certificateName,
     WireFormat& wireFormat)
  {
    commandInterestGenerator_.generate
      (interest, keyChain, certificateName, wireFormat);
  }

  uint64_t
  registerPrefix
    (const Name& prefix, const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed, const ForwardingFlags& flags,
     WireFormat& wireFormat, KeyChain& commandKeyChain,
     const Name& commandCertificateName, Face* face);

  void
  removeRegisteredPrefix(uint64_t registeredPrefixId);

  uint64_t
  setInterestFilter
    (const InterestFilter& filter, const OnInterestCallback& onInterest,
     Face* face)
  {
    uint64_t interestFilterId = InterestFilterEntry::getNextInterestFilterId();
    interestFilterTable_.push_back(ptr_lib::make_shared<InterestFilterEntry>
      (interestFilterId, ptr_lib::make_shared<const InterestFilter>(filter),
       onInterest, face));

    return interestFilterId;
  }

  void
  unsetInterestFilter(uint64_t interestFilterId);

  void
  putData(const Data& data, WireFormat& wireFormat);

  void
  send(const uint8_t *encoding, size_t encodingLength);

  void
  processEvents();

  const ptr_lib::shared_ptr<Transport>&
  getTransport() { return transport_; }

  const ptr_lib::shared_ptr<const Transport::ConnectionInfo>&
  getConnectionInfo() { return connectionInfo_; }

  void
  onReceivedElement(const uint8_t *element, size_t elementLength);

  bool
  isLocal() { return transport_->isLocal(*connectionInfo_); }

  void
  shutdown();

  static size_t
  getMaxNdnPacketSize() { return MAX_NDN_PACKET_SIZE; }

private:
  class PendingInterest {
  public:
    PendingInterest
      (uint64_t pendingInterestId, const ptr_lib::shared_ptr<const Interest>& interest, const OnData& onData,
       const OnTimeout& onTimeout);

    static uint64_t
    getNextPendingInterestId()
    {
      return ++lastPendingInterestId_;
    }

    uint64_t
    getPendingInterestId() { return pendingInterestId_; }

    const ptr_lib::shared_ptr<const Interest>&
    getInterest() { return interest_; }

    const OnData&
    getOnData() { return onData_; }

    bool
    isTimedOut(MillisecondsSince1970 nowMilliseconds)
    {
      return timeoutTimeMilliseconds_ >= 0.0 && nowMilliseconds >= timeoutTimeMilliseconds_;
    }

    void
    callTimeout();

  private:
    ptr_lib::shared_ptr<const Interest> interest_;
    static uint64_t lastPendingInterestId_; 
    uint64_t pendingInterestId_;            
    const OnData onData_;
    const OnTimeout onTimeout_;
    MillisecondsSince1970 timeoutTimeMilliseconds_; 
  };

  class RegisteredPrefix {
  public:
    RegisteredPrefix
      (uint64_t registeredPrefixId, const ptr_lib::shared_ptr<const Name>& prefix,
       uint64_t relatedInterestFilterId)
    : registeredPrefixId_(registeredPrefixId), prefix_(prefix),
      relatedInterestFilterId_(relatedInterestFilterId)
    {
    }

    static uint64_t
    getNextRegisteredPrefixId()
    {
      return ++lastRegisteredPrefixId_;
    }

    uint64_t
    getRegisteredPrefixId() { return registeredPrefixId_; }

    const ptr_lib::shared_ptr<const Name>&
    getPrefix() { return prefix_; }

    uint64_t
    getRelatedInterestFilterId() { return relatedInterestFilterId_; }

  private:
    static uint64_t lastRegisteredPrefixId_; 
    uint64_t registeredPrefixId_;            
    ptr_lib::shared_ptr<const Name> prefix_;
    uint64_t relatedInterestFilterId_;
  };

  class InterestFilterEntry {
  public:
    InterestFilterEntry
      (uint64_t interestFilterId,
       const ptr_lib::shared_ptr<const InterestFilter>& filter,
       const OnInterestCallback& onInterest, Face* face)
    : interestFilterId_(interestFilterId), filter_(filter),
      prefix_(new Name(filter->getPrefix())), onInterest_(onInterest), face_(face)
    {
    }

    static uint64_t
    getNextInterestFilterId()
    {
      return RegisteredPrefix::getNextRegisteredPrefixId();
    }

    uint64_t
    getInterestFilterId() { return interestFilterId_; }

    const ptr_lib::shared_ptr<const InterestFilter>&
    getFilter() { return filter_; }

    const ptr_lib::shared_ptr<const Name>&
    getPrefix() { return prefix_; }

    const OnInterestCallback&
    getOnInterest() { return onInterest_; }

    Face&
    getFace() { return *face_; }

  private:
    uint64_t interestFilterId_;  
    ptr_lib::shared_ptr<const InterestFilter> filter_;
    ptr_lib::shared_ptr<const Name> prefix_;
    const OnInterestCallback onInterest_;
    Face* face_;
  };

  class NdndIdFetcher {
  public:
    class Info;
    NdndIdFetcher(ptr_lib::shared_ptr<NdndIdFetcher::Info> info)
    : info_(info)
    {
    }

    void
    operator()(const ptr_lib::shared_ptr<const Interest>& interest, const ptr_lib::shared_ptr<Data>& ndndIdData);

    void
    operator()(const ptr_lib::shared_ptr<const Interest>& timedOutInterest);

    class Info {
    public:
      Info(Node *node, uint64_t registeredPrefixId, const Name& prefix,
           const OnInterestCallback& onInterest,
           const OnRegisterFailed& onRegisterFailed, const ForwardingFlags& flags,
           WireFormat& wireFormat, Face* face)
      : node_(*node), registeredPrefixId_(registeredPrefixId),
        prefix_(new Name(prefix)), onInterest_(onInterest),
        onRegisterFailed_(onRegisterFailed), flags_(flags),
        wireFormat_(wireFormat), face_(face)
      {
      }

      Node& node_;
      uint64_t registeredPrefixId_;
      ptr_lib::shared_ptr<const Name> prefix_;
      const OnInterestCallback onInterest_;
      const OnRegisterFailed onRegisterFailed_;
      ForwardingFlags flags_;
      WireFormat& wireFormat_;
      Face* face_;
    };

  private:
    ptr_lib::shared_ptr<Info> info_;
  };


  class RegisterResponse {
  public:
    class Info;
    RegisterResponse(ptr_lib::shared_ptr<RegisterResponse::Info> info)
    : info_(info)
    {
    }

    void
    operator()(const ptr_lib::shared_ptr<const Interest>& interest,
               const ptr_lib::shared_ptr<Data>& responseData);

    void
    operator()(const ptr_lib::shared_ptr<const Interest>& timedOutInterest);

    class Info {
    public:
      Info(Node* node, const ptr_lib::shared_ptr<const Name>& prefix,
           const OnInterestCallback& onInterest,
           const OnRegisterFailed& onRegisterFailed,
           const ForwardingFlags& flags, WireFormat& wireFormat,
           bool isNfdCommand, Face* face)
      : node_(*node), prefix_(prefix), onInterest_(onInterest),
        onRegisterFailed_(onRegisterFailed), flags_(flags),
        wireFormat_(wireFormat), isNfdCommand_(isNfdCommand), face_(face)
      {
      }

      Node& node_;
      ptr_lib::shared_ptr<const Name> prefix_;
      const OnInterestCallback onInterest_;
      const OnRegisterFailed onRegisterFailed_;
      ForwardingFlags flags_;
      WireFormat& wireFormat_;
      bool isNfdCommand_;
      Face* face_;
    };

  private:
    ptr_lib::shared_ptr<Info> info_;
  };

  void
  extractEntriesForExpressedInterest
    (const Name& name,
     std::vector<ptr_lib::shared_ptr<PendingInterest> > &entries);

  void
  registerPrefixHelper
    (uint64_t registeredPrefixId, const ptr_lib::shared_ptr<const Name>& prefix,
     const OnInterestCallback& onInterest, const OnRegisterFailed& onRegisterFailed,
     const ForwardingFlags& flags, WireFormat& wireFormat, Face* face);

  void
  nfdRegisterPrefix
    (uint64_t registeredPrefixId, const ptr_lib::shared_ptr<const Name>& prefix,
     const OnInterestCallback& onInterest, const OnRegisterFailed& onRegisterFailed,
     const ForwardingFlags& flags, KeyChain& commandKeyChain,
     const Name& commandCertificateName, WireFormat& wireFormat, Face* face);

  ptr_lib::shared_ptr<Transport> transport_;
  ptr_lib::shared_ptr<const Transport::ConnectionInfo> connectionInfo_;
  std::vector<ptr_lib::shared_ptr<PendingInterest> > pendingInterestTable_;
  std::vector<ptr_lib::shared_ptr<RegisteredPrefix> > registeredPrefixTable_;
  std::vector<ptr_lib::shared_ptr<InterestFilterEntry> > interestFilterTable_;
  Interest ndndIdFetcherInterest_;
  Blob ndndId_;
  CommandInterestGenerator commandInterestGenerator_;
  Name timeoutPrefix_;
};

}

#endif