node.hpp

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

#include <map>
#include <ndn-cpp/ndn-cpp-config.h>
#ifdef NDN_CPP_HAVE_BOOST_ASIO
#include <boost/atomic.hpp>
#endif
#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 "impl/delayed-call-table.hpp"
#include "impl/interest-filter-table.hpp"
#include "impl/pending-interest-table.hpp"
#include "impl/registered-prefix-table.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);

  void
  expressInterest
    (uint64_t pendingInterestId,
     const ptr_lib::shared_ptr<const Interest>& interestCopy,
     const OnData& onData, const OnTimeout& onTimeout, 
     const OnNetworkNack& onNetworkNack, WireFormat& wireFormat, Face* face);

  void
  removePendingInterest(uint64_t pendingInterestId)
  {
    pendingInterestTable_.removePendingInterest(pendingInterestId);
  }

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

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

  void
  registerPrefix
    (uint64_t registeredPrefixId,
     const ptr_lib::shared_ptr<const Name>& prefixCopy,
     const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed,
     const OnRegisterSuccess& onRegisterSuccess, const ForwardingFlags& flags,
     WireFormat& wireFormat, Face* face)
  {
    registerPrefix
      (registeredPrefixId, prefixCopy, onInterest, onRegisterFailed,
       onRegisterSuccess, flags, wireFormat, *face->getCommandKeyChain(),
       face->getCommandCertificateName(), face);
  }

  void
  removeRegisteredPrefix(uint64_t registeredPrefixId)
  {
    registeredPrefixTable_.removeRegisteredPrefix(registeredPrefixId);
  }

  void
  setInterestFilter
    (uint64_t interestFilterId,
     const ptr_lib::shared_ptr<const InterestFilter>& filterCopy,
     const OnInterestCallback& onInterest, Face* face)
  {
    interestFilterTable_.setInterestFilter
      (interestFilterId, filterCopy, onInterest, face);
  }

  void
  unsetInterestFilter(uint64_t interestFilterId)
  {
    interestFilterTable_.unsetInterestFilter(interestFilterId);
  }

  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; }

  void
  callLater(Milliseconds delayMilliseconds, const Face::Callback& callback)
  {
    delayedCallTable_.callLater(delayMilliseconds, callback);
  }

  uint64_t
  getNextEntryId();

private:
  enum ConnectStatus {
    ConnectStatus_UNCONNECTED = 1,
    ConnectStatus_CONNECT_REQUESTED = 2,
    ConnectStatus_CONNECT_COMPLETE = 3
  };

  class RegisterResponse {
  public:
    class Info;
    RegisterResponse
      (ptr_lib::shared_ptr<RegisterResponse::Info> info, Node& parent)
    : info_(info), parent_(parent)
    {
    }

    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(const ptr_lib::shared_ptr<const Name>& prefix,
           const OnRegisterFailed& onRegisterFailed,
           const OnRegisterSuccess& onRegisterSuccess,
           uint64_t registeredPrefixId, const OnInterestCallback& onInterest,
           Face* face)
      : prefix_(prefix), onRegisterFailed_(onRegisterFailed),
        onRegisterSuccess_(onRegisterSuccess),
        registeredPrefixId_(registeredPrefixId), onInterest_(onInterest),
        face_(face)
      {
      }

      ptr_lib::shared_ptr<const Name> prefix_;
      const OnRegisterFailed onRegisterFailed_;
      const OnRegisterSuccess onRegisterSuccess_;
      uint64_t registeredPrefixId_;
      const OnInterestCallback onInterest_;
      Face* face_;
    };

  private:
    ptr_lib::shared_ptr<Info> info_;
    Node& parent_;
  };

  void
  expressInterestHelper
    (uint64_t pendingInterestId,
     const ptr_lib::shared_ptr<const Interest>& interestCopy,
     const OnData& onData, const OnTimeout& onTimeout, 
     const OnNetworkNack& onNetworkNack, WireFormat* wireFormat, Face* face);

  void
  processInterestTimeout(ptr_lib::shared_ptr<PendingInterestTable::Entry> pendingInterest);

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

  void
  onConnected();

  ptr_lib::shared_ptr<Transport> transport_;
  ptr_lib::shared_ptr<const Transport::ConnectionInfo> connectionInfo_;
  PendingInterestTable pendingInterestTable_;
  RegisteredPrefixTable registeredPrefixTable_;
  InterestFilterTable interestFilterTable_;
  DelayedCallTable delayedCallTable_;
  std::vector<Face::Callback> onConnectedCallbacks_;
  CommandInterestGenerator commandInterestGenerator_;
  Name timeoutPrefix_;
  ConnectStatus connectStatus_;
  Blob nonceTemplate_;
#ifdef NDN_CPP_HAVE_BOOST_ASIO
  // ThreadsafeFace accesses lastEntryId_ outside of a thread safe dispatch, so
  // use atomic_uint64_t to be thread safe.
  boost::atomic_uint64_t lastEntryId_;
#else
  // Not using Boost asio to dispatch, so we can use a normal uint64_t.
  uint64_t lastEntryId_;
#endif
};

}

#endif