Source: generic-signature.js

  1. /**
  2.  * This class represents an NDN Data Signature object.
  3.  * Copyright (C) 2016-2018 Regents of the University of California.
  4.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU Lesser General Public License as published by
  8.  * the Free Software Foundation, either version 3 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  19.  */
  21. /** @ignore */
  22. var Blob = require('./util/blob.js').Blob;
  24. /**
  25.  * A GenericSignature extends Signature and holds the encoding bytes of the
  26.  * SignatureInfo so that the application can process experimental signature
  27.  * types. When decoding a packet, if the type of SignatureInfo is not
  28.  * recognized, the library creates a GenericSignature.
  29.  * Create a new GenericSignature object, possibly copying values from another
  30.  * object.
  31.  *
  32.  * @param {GenericSignature} value (optional) If value is a GenericSignature,
  33.  * copy its values.
  34.  * @constructor
  35.  */
  36. var GenericSignature = function GenericSignature(value)
  37. {
  38.   if (typeof value === 'object' && value instanceof GenericSignature) {
  39.     // Copy the values.
  40.     this.signature_ = value.signature_;
  41.     this.signatureInfoEncoding_ = value.signatureInfoEncoding_;
  42.     this.typeCode_ = value.typeCode_;
  43.   }
  44.   else {
  45.     this.signature_ = new Blob();
  46.     this.signatureInfoEncoding_ = new Blob();
  47.     this.typeCode_ = null;
  48.   }
  50.   this.changeCount_ = 0;
  51. };
  53. exports.GenericSignature = GenericSignature;
  55. /**
  56.  * Create a new GenericSignature which is a copy of this object.
  57.  * @return {GenericSignature} A new object which is a copy of this object.
  58.  */
  59. GenericSignature.prototype.clone = function()
  60. {
  61.   return new GenericSignature(this);
  62. };
  64. /**
  65.  * Get the data packet's signature bytes.
  66.  * @return {Blob} The signature bytes. If not specified, the value isNull().
  67.  */
  68. GenericSignature.prototype.getSignature = function()
  69. {
  70.   return this.signature_;
  71. };
  73. /**
  74.  * @deprecated Use getSignature. This method returns a Buffer which is the former
  75.  * behavior of getSignature, and should only be used while updating your code.
  76.  */
  77. GenericSignature.prototype.getSignatureAsBuffer = function()
  78. {
  79.   return this.signature_.buf();
  80. };
  82. /**
  83.  * Get the bytes of the entire signature info encoding (including the type
  84.  * code).
  85.  * @return {Blob} The encoding bytes. If not specified, the value isNull().
  86.  */
  87. GenericSignature.prototype.getSignatureInfoEncoding = function()
  88. {
  89.   return this.signatureInfoEncoding_;
  90. };
  92. /**
  93.  * Get the type code of the signature type. When wire decode calls
  94.  * setSignatureInfoEncoding, it sets the type code. Note that the type code
  95.  * is ignored during wire encode, which simply uses getSignatureInfoEncoding()
  96.  * where the encoding already has the type code.
  97.  * @return {number} The type code, or null if not known.
  98.  */
  99. GenericSignature.prototype.getTypeCode = function() { return this.typeCode_; };
  101. /**
  102.  * Set the data packet's signature bytes.
  103.  * @param {Blob} signature
  104.  */
  105. GenericSignature.prototype.setSignature = function(signature)
  106. {
  107.   this.signature_ = typeof signature === 'object' && signature instanceof Blob ?
  108.     signature : new Blob(signature);
  109.   ++this.changeCount_;
  110. };
  112. /**
  113.  * Set the bytes of the entire signature info encoding (including the type
  114.  * code).
  115.  * @param {Blob} signatureInfoEncoding A Blob with the encoding bytes.
  116.  * @param {number} (optional) The type code of the signature type, or null if
  117.  * not known. (When a GenericSignature is created by wire decoding, it sets
  118.  * the typeCode.)
  119.  */
  120. GenericSignature.prototype.setSignatureInfoEncoding = function
  121.   (signatureInfoEncoding, typeCode)
  122. {
  123.   this.signatureInfoEncoding_ =
  124.     typeof signatureInfoEncoding === 'object' && signatureInfoEncoding instanceof Blob ?
  125.       signatureInfoEncoding : new Blob(signatureInfoEncoding);
  126.   this.typeCode_ = typeCode;
  127.   ++this.changeCount_;
  128. };
  130. /**
  131.  * Get the change count, which is incremented each time this object (or a child
  132.  * object) is changed.
  133.  * @return {number} The change count.
  134.  */
  135. GenericSignature.prototype.getChangeCount = function()
  136. {
  137.   return this.changeCount_;
  138. };
  140. /**
  141.  * @@deprecated Use getSignature and setSignature.
  142.  */
  143. Object.defineProperty(GenericSignature.prototype, "signature",
  144.   { get: function() { return this.getSignatureAsBuffer(); },
  145.     set: function(val) { this.setSignature(val); } });