der-node.hpp

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

#include <ndn-cpp/util/blob.hpp>
#include <ndn-cpp/encoding/oid.hpp>
#include "../../util/dynamic-uint8-vector.hpp"
#include "der-node-type.hpp"

namespace ndn {

class DerNode {
public:
  virtual size_t
  getSize();

  virtual Blob
  encode();

  static ptr_lib::shared_ptr<DerNode>
  parse(const uint8_t* inputBuf, size_t startIdx = 0);

  virtual Blob
  toVal();

  virtual const std::vector<ptr_lib::shared_ptr<DerNode> >&
  getChildren();

  class DerStructure;

  // Now for all the node types...
  // Class definitions are after the definition of DerNode.

  class DerByteString;
  class DerBoolean;
  class DerInteger;
  class DerBitString;
  class DerOctetString;
  class DerNull;
  class DerOid;
  class DerSequence;
  class DerPrintableString;
  class DerGeneralizedTime;

  static DerNode::DerSequence&
  getSequence
    (const std::vector<ptr_lib::shared_ptr<DerNode> >&children, size_t index);

protected:
  DerNode(DerNodeType nodeType)
  : nodeType_(nodeType),
    parent_(0),
    payload_(0),
    payloadPosition_(0)
  {
  }

  void
  encodeHeader(size_t size);

  size_t
  decodeHeader(const uint8_t* inputBuf, size_t startIdx);

  virtual void
  decode(const uint8_t* inputBuf, size_t startIdx);

  void
  payloadAppend(const uint8_t *value, size_t valueLength)
  {
    payloadPosition_ = payload_.copy(value, valueLength, payloadPosition_);
  }

  DerStructure* parent_;
  DerNodeType nodeType_;
  std::vector<uint8_t> header_;
  DynamicUInt8Vector payload_;
  size_t payloadPosition_;
};

class DerNode::DerStructure : public DerNode {
public:
  virtual size_t
  getSize();

  virtual const std::vector<ptr_lib::shared_ptr<DerNode> >&
  getChildren();

  void
  addChild(const ptr_lib::shared_ptr<DerNode>& node, bool notifyParent = false)
  {
    node->parent_ = this;
    nodeList_.push_back(node);

    if (notifyParent) {
      if (parent_)
        parent_->setChildChanged();
    }

    childChanged_ = true;
  }

  virtual Blob
  encode();

protected:
  DerStructure(DerNodeType nodeType)
  : DerNode(nodeType),
    childChanged_(false),
    size_(0)
  {
  }

  virtual void
  decode(const uint8_t* inputBuf, size_t startIdx);

private:
  void
  updateSize();

  void
  setChildChanged()
  {
    if (parent_)
      parent_->setChildChanged();
    childChanged_ = true;
  }

  bool childChanged_;
  std::vector<ptr_lib::shared_ptr<DerNode> > nodeList_;
  size_t size_;
};

class DerNode::DerByteString : public DerNode {
public:
  virtual Blob
  toVal();

protected:
  DerByteString
    (const uint8_t* inputData, size_t inputDataLength, DerNodeType nodeType)
  : DerNode(nodeType)
  {
    if (inputData) {
      payloadAppend(inputData, inputDataLength);
      encodeHeader(inputDataLength);
    }
  }
};

class DerNode::DerBoolean : public DerNode {
public:
  DerBoolean(bool value)
  : DerNode(DerNodeType_Boolean)
  {
    uint8_t val = value ? 0xff : 0x00;
    payloadAppend(&val, 1);
    encodeHeader(1);
  }

  DerBoolean()
  : DerNode(DerNodeType_Boolean)
  {
  }
};

class DerNode::DerInteger : public DerNode {
public:
  DerInteger(int integer);

  DerInteger();

  int
  toIntegerVal() const;
};

class DerNode::DerBitString : public DerNode {
public:
  DerBitString(const uint8_t* inputBuf, size_t inputBufLength, int paddingLen)
  : DerNode(DerNodeType_BitString)
  {
    uint8_t pad = paddingLen & 0xff;
    payloadAppend(&pad, 1);
    payloadAppend(inputBuf, inputBufLength);
    encodeHeader(payloadPosition_);
  }

  DerBitString()
  : DerNode(DerNodeType_BitString)
  {
  }
};

class DerNode::DerOctetString : public DerByteString {
public:
  DerOctetString(const uint8_t* inputData, size_t inputDataLength)
  : DerByteString(inputData, inputDataLength, DerNodeType_OctetString)
  {
  }

  DerOctetString()
  : DerByteString(0, 0, DerNodeType_OctetString)
  {
  }
};

class DerNode::DerNull : public DerNode {
public:
  DerNull()
  : DerNode(DerNodeType_Null)
  {
    encodeHeader(0);
  }
};

class DerNode::DerOid : public DerNode {
public:
  DerOid(const std::string& oidStr)
  : DerNode(DerNodeType_ObjectIdentifier)
  {
    // Use OID to construct the integer list.
    OID tempOid(oidStr);
    prepareEncoding(tempOid.getIntegerList());
  }

  DerOid(const OID& oid)
  : DerNode(DerNodeType_ObjectIdentifier)
  {
    prepareEncoding(oid.getIntegerList());
  }

  DerOid()
  : DerNode(DerNodeType_ObjectIdentifier)
  {
  }

  virtual Blob
  toVal();

private:
  void
  prepareEncoding(const std::vector<int>& value);

  static std::vector<uint8_t>
  encode128(int value);

  int
  decode128(size_t offset, size_t& skip);
};

class DerNode::DerSequence : public DerStructure {
public:
  DerSequence()
  : DerStructure(DerNodeType_Sequence)
  {
  }
};

class DerNode::DerPrintableString : public DerByteString {
public:
  DerPrintableString(const uint8_t* inputData, size_t inputDataLength)
  : DerByteString(inputData, inputDataLength, DerNodeType_PrintableString)
  {
  }

  DerPrintableString()
  : DerByteString(0, 0, DerNodeType_PrintableString)
  {
  }
};

class DerNode::DerGeneralizedTime : public DerNode {
public:
  DerGeneralizedTime(MillisecondsSince1970 msSince1970)
  : DerNode(DerNodeType_GeneralizedTime)
  {
    std::string derTime = toDerTimeString(msSince1970);
    payloadAppend((const uint8_t*)&derTime[0], derTime.size());
    encodeHeader(payloadPosition_);
  }

  DerGeneralizedTime()
  : DerNode(DerNodeType_GeneralizedTime)
  {
  }

  MillisecondsSince1970
  toMillisecondsSince1970();

  static std::string
  toIsoString(const MillisecondsSince1970& time);

  static MillisecondsSince1970
  fromIsoString(const std::string& isoString);

private:
  static std::string
  toDerTimeString(MillisecondsSince1970 msSince1970);
};

}

#endif