producer.hpp

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

#include <map>
#include "../face.hpp"
#include "../security/key-chain.hpp"
#include "encrypt-error.hpp"
#include "producer-db.hpp"

namespace ndn {

class Producer {
public:
  typedef func_lib::function<
    void(const std::vector<ptr_lib::shared_ptr<Data> >& keys)> OnEncryptedKeys;

  Producer
    (const Name& prefix, const Name& dataType, Face* face, KeyChain* keyChain,
     const ptr_lib::shared_ptr<ProducerDb>& database, int repeatAttempts = 3,
     const Link& keyRetrievalLink = getNO_LINK())
  : impl_(new Impl
      (prefix, dataType, face, keyChain, database, repeatAttempts,
       keyRetrievalLink))
  {
  }

  Name
  createContentKey
    (MillisecondsSince1970 timeSlot, const OnEncryptedKeys& onEncryptedKeys,
     const EncryptError::OnError& onError = defaultOnError)
  {
    return impl_->createContentKey(timeSlot, onEncryptedKeys, onError);
  }

  void
  produce
    (Data& data, MillisecondsSince1970 timeSlot, const Blob& content,
     const EncryptError::OnError& onError = defaultOnError)
  {
    impl_->produce(data, timeSlot, content, onError);
  }

  static void
  defaultOnError(EncryptError::ErrorCode errorCode, const std::string& message);

private:
  class Impl : public ptr_lib::enable_shared_from_this<Impl> {
  public:
    Impl
      (const Name& prefix, const Name& dataType, Face* face, KeyChain* keyChain,
       const ptr_lib::shared_ptr<ProducerDb>& database, int repeatAttempts,
       const Link& keyRetrievalLink);

    Name
    createContentKey
      (MillisecondsSince1970 timeSlot, const OnEncryptedKeys& onEncryptedKeys,
       const EncryptError::OnError& onError);

    void
    produce
      (Data& data, MillisecondsSince1970 timeSlot, const Blob& content,
       const EncryptError::OnError& onError);

  private:
    class KeyInfo {
    public:
      KeyInfo() : beginTimeSlot(0), endTimeSlot(0) {}

      MillisecondsSince1970 beginTimeSlot;
      MillisecondsSince1970 endTimeSlot;
      Blob keyBits;
    };

    class KeyRequest {
    public:
      KeyRequest(int interests)
      {
        interestCount = interests;
      }

      int interestCount;
      std::map<Name, int> repeatAttempts;
      std::vector<ptr_lib::shared_ptr<Data> > encryptedKeys;
    };

    static MillisecondsSince1970
    getRoundedTimeSlot(MillisecondsSince1970 timeSlot);

    void
    sendKeyInterest
      (const Interest& interest, MillisecondsSince1970 timeSlot,
       const OnEncryptedKeys& onEncryptedKeys,
       const EncryptError::OnError& onError);

    void
    handleTimeout
      (const ptr_lib::shared_ptr<const Interest>& interest,
       MillisecondsSince1970 timeSlot, const OnEncryptedKeys& onEncryptedKeys,
       const EncryptError::OnError& onError);

    void
    handleNetworkNack
      (const ptr_lib::shared_ptr<const Interest>& interest,
       const ptr_lib::shared_ptr<NetworkNack>& networkNack,
       MillisecondsSince1970 timeSlot,
       const OnEncryptedKeys& onEncryptedKeys,
       const EncryptError::OnError& onError);

    void
    updateKeyRequest
      (const ptr_lib::shared_ptr<KeyRequest>& keyRequest,
       MillisecondsSince1970 timeCount, const OnEncryptedKeys& onEncryptedKeys);

    void
    handleCoveringKey
      (const ptr_lib::shared_ptr<const Interest>& interest,
       const ptr_lib::shared_ptr<Data>& data, MillisecondsSince1970 timeSlot,
       const OnEncryptedKeys& onEncryptedKeys,
       const EncryptError::OnError& onError);

    bool
    encryptContentKey
      (const Blob& encryptionKey, const Name& eKeyName,
       MillisecondsSince1970 timeSlot, const OnEncryptedKeys& onEncryptedKeys,
       const EncryptError::OnError& onError);

    // TODO: Move this to be the main representation inside the Exclude object.
    class ExcludeEntry {
    public:
      ExcludeEntry(const Name::Component& component, bool anyFollowsComponent)
      : component_(component), anyFollowsComponent_(anyFollowsComponent)
      {
      }

      Name::Component component_;
      bool anyFollowsComponent_;
    };

    static void
    getExcludeEntries(const Exclude& exclude, std::vector<ExcludeEntry>& entries);

    static void
    setExcludeEntries(Exclude& exclude, const std::vector<ExcludeEntry>& entries);

    static int
    findEntryBeforeOrAt
      (const std::vector<ExcludeEntry>& entries,
       const Name::Component& component);

    static void
    excludeAfter(Exclude& exclude, const Name::Component& from);

    static void
    excludeBefore(Exclude& exclude, const Name::Component& to)
    {
      excludeRange(exclude, Name::Component(), to);
    }

    static void
    excludeRange
      (Exclude& exclude, const Name::Component& from, const Name::Component& to);

    Face* face_;
    Name namespace_;
    KeyChain* keyChain_;
    std::map<Name, ptr_lib::shared_ptr<KeyInfo> > eKeyInfo_;
    std::map<MillisecondsSince1970, ptr_lib::shared_ptr<KeyRequest> > keyRequests_;
    ptr_lib::shared_ptr<ProducerDb> database_;
    int maxRepeatAttempts_;

    Link keyRetrievalLink_;

    static const int START_TIME_STAMP_INDEX = -2;
    static const int END_TIME_STAMP_INDEX = -1;
  };

  static Link&
  getNO_LINK()
  {
    if (!noLink_)
      noLink_ = new Link();

    return *noLink_;
  }

  ptr_lib::shared_ptr<Impl> impl_;
  static Link* noLink_;
};

}

#endif