signing-info.hpp

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

#include "../name.hpp"
#include "../signature.hpp"
#include "pib/pib-identity.hpp"
#include "pib/pib-key.hpp"
#include "security-common.hpp"

namespace ndn {

class SigningInfo {
public:
  enum SignerType {
    SIGNER_TYPE_NULL = 0,
    SIGNER_TYPE_ID = 1,
    SIGNER_TYPE_KEY = 2,
    SIGNER_TYPE_CERT = 3,
    SIGNER_TYPE_SHA256 = 4,
  };

  SigningInfo
    (SignerType signerType = SIGNER_TYPE_NULL, const Name& signerName = Name())
  {
    reset(signerType);
    name_ = signerName;
    digestAlgorithm_ = DIGEST_ALGORITHM_SHA256;
  }

  SigningInfo(const ptr_lib::shared_ptr<PibIdentity>& identity)
  {
    digestAlgorithm_ = DIGEST_ALGORITHM_SHA256;
    setPibIdentity(identity);
  }

  SigningInfo(const ptr_lib::shared_ptr<PibKey>& key)
  {
    digestAlgorithm_ = DIGEST_ALGORITHM_SHA256;
    setPibKey(key);
  }

  SigningInfo(const std::string& signingString);

  SigningInfo&
  setSigningIdentity(const Name& identityName)
  {
    reset(SIGNER_TYPE_ID);
    name_ = identityName;
    return *this;
  }

  SigningInfo&
  setSigningKeyName(const Name& keyName)
  {
    reset(SIGNER_TYPE_KEY);
    name_ = keyName;
    return *this;
  }

  SigningInfo&
  setSigningCertificateName(const Name& certificateName)
  {
    reset(SIGNER_TYPE_CERT);
    name_ = certificateName;
    return *this;
  }

  SigningInfo&
  setSha256Signing()
  {
    reset(SIGNER_TYPE_SHA256);
    digestAlgorithm_ = DIGEST_ALGORITHM_SHA256;
    return *this;
  }

  SigningInfo&
  setPibIdentity(const ptr_lib::shared_ptr<PibIdentity>& identity)
  {
    reset(SIGNER_TYPE_ID);
    name_ = identity ? identity->getName() : Name();
    identity_ = identity;
    return *this;
  }

  SigningInfo&
  setPibKey(const ptr_lib::shared_ptr<PibKey>& key)
  {
    reset(SIGNER_TYPE_KEY);
    name_ = key ? key->getName() : Name();
    key_ = key;
    return *this;
  }

  SignerType
  getSignerType() const { return type_; }

  const Name&
  getSignerName() const { return name_; }

  const ptr_lib::shared_ptr<PibIdentity>&
  getPibIdentity() const;

  const ptr_lib::shared_ptr<PibKey>&
  getPibKey() const;

  SigningInfo&
  setDigestAlgorithm(DigestAlgorithm digestAlgorithm)
  {
    digestAlgorithm_ = digestAlgorithm;
    return *this;
  }

  DigestAlgorithm
  getDigestAlgorithm() const { return digestAlgorithm_; }

  SigningInfo&
  setValidityPeriod(const ValidityPeriod& validityPeriod)
  {
    validityPeriod_ = validityPeriod;
    return *this;
  }

  const ValidityPeriod&
  getValidityPeriod() const { return validityPeriod_; }

  std::string
  toString() const;

  static Name
  getDigestSha256Identity() { return Name("/localhost/identity/digest-sha256"); }

private:
  void
  reset(SignerType signerType);

  SignerType type_;
  Name name_;
  ptr_lib::shared_ptr<PibIdentity> identity_;
  ptr_lib::shared_ptr<PibKey> key_;
  DigestAlgorithm digestAlgorithm_;
  ValidityPeriod validityPeriod_;
};

inline std::ostream&
operator << (std::ostream& os, const SigningInfo& info)
{
  os << info.toString();
  return os;
}


}

#endif