group-manager.hpp

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

#include "../security/certificate/identity-certificate.hpp"
#include "group-manager-db.hpp"

// Give friend access to the tests.
class TestGroupManager_CreateDKeyData_Test;
class TestGroupManager_CreateEKeyData_Test;
class TestGroupManager_CalculateInterval_Test;

namespace ndn {

class KeyChain;

class GroupManager {
public:
  GroupManager
    (const Name& prefix, const Name& dataType,
     const ptr_lib::shared_ptr<GroupManagerDb>& database, uint32_t keySize,
     int freshnessHours, KeyChain* keyChain);

  void
  getGroupKey
    (MillisecondsSince1970 timeSlot,
     std::vector<ptr_lib::shared_ptr<Data> >& result,
     bool needRegenerate = true);

  void
  addSchedule(const std::string& scheduleName, const Schedule& schedule)
  {
    database_->addSchedule(scheduleName, schedule);
  }

  void
  deleteSchedule(const std::string& scheduleName)
  {
    database_->deleteSchedule(scheduleName);
  }

  void
  updateSchedule(const std::string& scheduleName, const Schedule& schedule)
  {
    database_->updateSchedule(scheduleName, schedule);
  }

  void
  addMember(const std::string& scheduleName, const Data& memberCertificate)
  {
    IdentityCertificate cert(memberCertificate);
    database_->addMember
      (scheduleName, cert.getPublicKeyName(), cert.getPublicKeyInfo().getKeyDer());
  }

  void
  removeMember(const Name& identity)
  {
    database_->deleteMember(identity);
  }

  void
  updateMemberSchedule(const Name& identity, const std::string& scheduleName)
  {
    database_->updateMemberSchedule(identity, scheduleName);
  }

  void
  cleanEKeys() { database_->cleanEKeys(); }

private:
  // Give friend access to the tests.
  friend TestGroupManager_CreateDKeyData_Test;
  friend TestGroupManager_CreateEKeyData_Test;
  friend TestGroupManager_CalculateInterval_Test;

  Interval
  calculateInterval
    (MillisecondsSince1970 timeSlot, std::map<Name, Blob>& memberKeys);

  void
  generateKeyPair(Blob& privateKeyBlob, Blob& publicKeyBlob);

  ptr_lib::shared_ptr<Data>
  createEKeyData
    (const std::string& startTimeStamp, const std::string& endTimeStamp,
     const Blob& publicKeyBlob);

  ptr_lib::shared_ptr<Data>
  createDKeyData
    (const std::string& startTimeStamp, const std::string& endTimeStamp,
     const Name& keyName, const Blob& privateKeyBlob, const Blob& certificateKey);

  void
  addEKey(const Name& eKeyName, const Blob& publicKey, const Blob& privateKey)
  {
    database_->addEKey(eKeyName, publicKey, privateKey);
  }

  void
  getEKey(const Name& eKeyName, Blob& publicKey, Blob& privateKey)
  {
    database_->getEKey(eKeyName, publicKey, privateKey);
  }

  void
  deleteEKey(const Name& eKeyName)
  {
    database_-> deleteEKey(eKeyName);
  }

  Name namespace_;
  ptr_lib::shared_ptr<GroupManagerDb> database_;
  uint32_t keySize_;
  int freshnessHours_;
  KeyChain* keyChain_;
  static const uint64_t MILLISECONDS_IN_HOUR = 3600 * 1000;
};

}

#endif