consumer.hpp

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

#include <map>
#include "../data.hpp"
#include "../face.hpp"
#include "../security/key-chain.hpp"
#include "encrypt-error.hpp"
#include "encrypted-content.hpp"
#include "consumer-db.hpp"

// Give friend access to the tests.
class TestConsumer_DecryptContent_Test;

namespace ndn {

class Consumer {
public:
  Consumer
    (Face* face, KeyChain* keyChain, const Name& groupName,
     const Name& consumerName, const ptr_lib::shared_ptr<ConsumerDb>& database,
     const Link& cKeyLink = getNO_LINK(), const Link& dKeyLink = getNO_LINK())
  : impl_(new Impl
      (face, keyChain, groupName, consumerName, database, cKeyLink, dKeyLink))
  {
  }

  typedef func_lib::function<void
    (const ptr_lib::shared_ptr<Data>& contentData,
     const Blob& result)> OnConsumeComplete;

  typedef func_lib::function<void(const Blob& decryptedBlob)> OnPlainText;

  void
  consume
    (const Name& contentName, const OnConsumeComplete& onConsumeComplete,
     const EncryptError::OnError& onError, const Link& link = getNO_LINK())
  {
    impl_->consume(contentName, onConsumeComplete, onError, link);
  }

  void
  setGroup(const Name& groupName) { impl_->setGroup(groupName); }

  void
  addDecryptionKey(const Name& keyName, const Blob& keyBlob)
  {
    impl_->addDecryptionKey(keyName, keyBlob);
  }

  void
  decryptContent
    (const Data& data, const OnPlainText& onPlainText,
     const EncryptError::OnError& onError)
  {
    impl_-> decryptContent(data, onPlainText, onError);
  }

private:
  // Give friend access to the tests.
  friend TestConsumer_DecryptContent_Test;

  class Impl : public ptr_lib::enable_shared_from_this<Impl> {
  public:
    Impl
      (Face* face, KeyChain* keyChain, const Name& groupName,
       const Name& consumerName, const ptr_lib::shared_ptr<ConsumerDb>& database,
       const Link& cKeyLink, const Link& dKeyLink);

    void
    consume
      (const Name& contentName, const OnConsumeComplete& onConsumeComplete,
       const EncryptError::OnError& onError, const Link& link);

    void
    setGroup(const Name& groupName) { groupName_ = groupName; }

    void
    addDecryptionKey(const Name& keyName, const Blob& keyBlob);

    void
    decryptContent
      (const Data& data, const OnPlainText& onPlainText,
       const EncryptError::OnError& onError);

  private:
    // Give friend access to the tests.
    friend TestConsumer_DecryptContent_Test;

    static void
    decrypt
      (const Blob& encryptedBlob, const Blob& keyBits,
       const OnPlainText& onPlainText, const EncryptError::OnError& onError);

    static void
    decryptEncryptedContent
      (const EncryptedContent& encryptedContent, const Blob& keyBits,
       const OnPlainText& onPlainText, const EncryptError::OnError& onError);

    void
    decryptCKey
      (const Data& cKeyData, const OnPlainText& onPlainText,
       const EncryptError::OnError& onError);

    void
    decryptDKey
      (const Data& dKeyData, const OnPlainText& onPlainText,
       const EncryptError::OnError& onError);

    Blob
    getDecryptionKey(const Name& decryptionKeyName)
    {
      return database_->getKey(decryptionKeyName);
    }

    void
    sendInterest
      (const ptr_lib::shared_ptr<const Interest>& interest, int nRetrials,
       const ptr_lib::shared_ptr<Link>& link, const OnVerified& onVerified,
       const EncryptError::OnError& onError);

    static void
    onValidationFailed
      (const ptr_lib::shared_ptr<Data>& data, const std::string& reason,
       const EncryptError::OnError& onError);

    ptr_lib::shared_ptr<ConsumerDb> database_;
    KeyChain* keyChain_;
    Face* face_;
    Name groupName_;
    Name consumerName_;

    const ptr_lib::shared_ptr<Link> cKeyLink_;
    // The map key is the C-KEY name. The value is the encoded key Blob.
    std::map<Name, Blob> cKeyMap_;
    const ptr_lib::shared_ptr<Link> dKeyLink_;
    // The map key is the D-KEY name. The value is the encoded key Blob.
    std::map<Name, Blob> dKeyMap_;
  };

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

    return *noLink_;
  }

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

}

#endif