Source: encoding/tlv-0_2-wire-format.js

  1. /**
  2.  * Copyright (C) 2013-2018 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  *
  5.  * This program is free software: you can redistribute it and/or modify
  6.  * it under the terms of the GNU Lesser General Public License as published by
  7.  * the Free Software Foundation, either version 3 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU Lesser General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Lesser General Public License
  16.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  18.  */
  20. /** @ignore */
  21. var Crypto = require('../crypto.js'); /** @ignore */
  22. var Blob = require('../util/blob.js').Blob; /** @ignore */
  23. var Name = require('../name.js').Name; /** @ignore */
  24. var ComponentType = require('../name.js').ComponentType; /** @ignore */
  25. var ForwardingFlags = require('../forwarding-flags').ForwardingFlags; /** @ignore */
  26. var Tlv = require('./tlv/tlv.js').Tlv; /** @ignore */
  27. var TlvEncoder = require('./tlv/tlv-encoder.js').TlvEncoder; /** @ignore */
  28. var TlvDecoder = require('./tlv/tlv-decoder.js').TlvDecoder; /** @ignore */
  29. var WireFormat = require('./wire-format.js').WireFormat; /** @ignore */
  30. var Exclude = require('../exclude.js').Exclude; /** @ignore */
  31. var ContentType = require('../meta-info.js').ContentType; /** @ignore */
  32. var KeyLocatorType = require('../key-locator.js').KeyLocatorType; /** @ignore */
  33. var Sha256WithRsaSignature = require('../sha256-with-rsa-signature.js').Sha256WithRsaSignature; /** @ignore */
  34. var Sha256WithEcdsaSignature = require('../sha256-with-ecdsa-signature.js').Sha256WithEcdsaSignature; /** @ignore */
  35. var GenericSignature = require('../generic-signature.js').GenericSignature; /** @ignore */
  36. var HmacWithSha256Signature = require('../hmac-with-sha256-signature.js').HmacWithSha256Signature; /** @ignore */
  37. var DigestSha256Signature = require('../digest-sha256-signature.js').DigestSha256Signature; /** @ignore */
  38. var ControlParameters = require('../control-parameters.js').ControlParameters; /** @ignore */
  39. var ForwardingFlags = require('../forwarding-flags.js').ForwardingFlags; /** @ignore */
  40. var NetworkNack = require('../network-nack.js').NetworkNack; /** @ignore */
  41. var Schedule = require('../encrypt/schedule.js').Schedule; /** @ignore */
  42. var IncomingFaceId = require('../lp/incoming-face-id.js').IncomingFaceId; /** @ignore */
  43. var CongestionMark = require('../lp/congestion-mark.js').CongestionMark; /** @ignore */
  44. var DecodingException = require('./decoding-exception.js').DecodingException;
  46. /**
  47.  * A Tlv0_2WireFormat implements the WireFormat interface for encoding and
  48.  * decoding with the NDN-TLV wire format, version 0.2.
  49.  * @constructor
  50.  */
  51. var Tlv0_2WireFormat = function Tlv0_2WireFormat()
  52. {
  53.   // Inherit from WireFormat.
  54.   WireFormat.call(this);
  55. };
  57. Tlv0_2WireFormat.prototype = new WireFormat();
  58. Tlv0_2WireFormat.prototype.name = "Tlv0_2WireFormat";
  60. exports.Tlv0_2WireFormat = Tlv0_2WireFormat;
  62. // Default object.
  63. Tlv0_2WireFormat.instance = null;
  65. /**
  66.  * Encode name as an NDN-TLV Name and return the encoding.
  67.  * @param {Name} name The Name to encode.
  68.  * @return {Blobl} A Blob containing the encoding.
  69.  */
  70. Tlv0_2WireFormat.prototype.encodeName = function(name)
  71. {
  72.   var encoder = new TlvEncoder();
  73.   Tlv0_2WireFormat.encodeName(name, encoder);
  74.   return new Blob(encoder.getOutput(), false);
  75. };
  77. /**
  78.  * Decode input as a NDN-TLV name and set the fields of the Name object.
  79.  * @param {Name} name The Name object whose fields are updated.
  80.  * @param {Buffer} input The buffer with the bytes to decode.
  81.  * @param {boolean} copy (optional) If true, copy from the input when making new
  82.  * Blob values. If false, then Blob values share memory with the input, which
  83.  * must remain unchanged while the Blob values are used. If omitted, use true.
  84.  */
  85. Tlv0_2WireFormat.prototype.decodeName = function(name, input, copy)
  86. {
  87.   if (copy == null)
  88.     copy = true;
  90.   var decoder = new TlvDecoder(input);
  91.   Tlv0_2WireFormat.decodeName(name, decoder, copy);
  92. };
  94. /**
  95.  * Encode the interest using NDN-TLV and return a Buffer.
  96.  * @param {Interest} interest The Interest object to encode.
  97.  * @return {object} An associative array with fields
  98.  * (encoding, signedPortionBeginOffset, signedPortionEndOffset) where encoding
  99.  * is a Blob containing the encoding, signedPortionBeginOffset is the offset in
  100.  * the encoding of the beginning of the signed portion, and
  101.  * signedPortionEndOffset is the offset in the encoding of the end of the signed
  102.  * portion. The signed portion starts from the first name component and ends
  103.  * just before the final name component (which is assumed to be a signature for
  104.  * a signed interest).
  105.  */
  106. Tlv0_2WireFormat.prototype.encodeInterest = function(interest)
  107. {
  108.   var encoder = new TlvEncoder(256);
  109.   var saveLength = encoder.getLength();
  111.   // Encode backwards.
  112.   if (interest.getForwardingHint().size() > 0) {
  113.     if (interest.getSelectedDelegationIndex() != null)
  114.       throw new Error
  115.         ("An Interest may not have a selected delegation when encoding a forwarding hint");
  116.     if (interest.hasLink())
  117.       throw new Error
  118.         ("An Interest may not have a link object when encoding a forwarding hint");
  120.     var forwardingHintSaveLength = encoder.getLength();
  121.     Tlv0_2WireFormat.encodeDelegationSet_(interest.getForwardingHint(), encoder);
  122.     encoder.writeTypeAndLength(
  123.       Tlv.ForwardingHint, encoder.getLength() - forwardingHintSaveLength);
  124.   }
  126.   encoder.writeOptionalNonNegativeIntegerTlv
  127.     (Tlv.SelectedDelegation, interest.getSelectedDelegationIndex());
  128.   var linkWireEncoding = interest.getLinkWireEncoding(this);
  129.   if (!linkWireEncoding.isNull())
  130.     // Encode the entire link as is.
  131.     encoder.writeBuffer(linkWireEncoding.buf());
  133.   encoder.writeOptionalNonNegativeIntegerTlv
  134.     (Tlv.InterestLifetime, interest.getInterestLifetimeMilliseconds());
  136.   // Encode the Nonce as 4 bytes.
  137.   if (interest.getNonce().isNull() || interest.getNonce().size() == 0)
  138.     // This is the most common case. Generate a nonce.
  139.     encoder.writeBlobTlv(Tlv.Nonce, Crypto.randomBytes(4));
  140.   else if (interest.getNonce().size() < 4) {
  141.     var nonce = Buffer(4);
  142.     // Copy existing nonce bytes.
  143.     interest.getNonce().buf().copy(nonce);
  145.     // Generate random bytes for remaining bytes in the nonce.
  146.     for (var i = interest.getNonce().size(); i < 4; ++i)
  147.       nonce[i] = Crypto.randomBytes(1)[0];
  149.     encoder.writeBlobTlv(Tlv.Nonce, nonce);
  150.   }
  151.   else if (interest.getNonce().size() == 4)
  152.     // Use the nonce as-is.
  153.     encoder.writeBlobTlv(Tlv.Nonce, interest.getNonce().buf());
  154.   else
  155.     // Truncate.
  156.     encoder.writeBlobTlv(Tlv.Nonce, interest.getNonce().buf().slice(0, 4));
  158.   Tlv0_2WireFormat.encodeSelectors(interest, encoder);
  159.   var tempOffsets = Tlv0_2WireFormat.encodeName(interest.getName(), encoder);
  160.   var signedPortionBeginOffsetFromBack =
  161.     encoder.getLength() - tempOffsets.signedPortionBeginOffset;
  162.   var signedPortionEndOffsetFromBack =
  163.     encoder.getLength() - tempOffsets.signedPortionEndOffset;
  165.   encoder.writeTypeAndLength(Tlv.Interest, encoder.getLength() - saveLength);
  166.   var signedPortionBeginOffset =
  167.     encoder.getLength() - signedPortionBeginOffsetFromBack;
  168.   var signedPortionEndOffset =
  169.     encoder.getLength() - signedPortionEndOffsetFromBack;
  171.   return { encoding: new Blob(encoder.getOutput(), false),
  172.            signedPortionBeginOffset: signedPortionBeginOffset,
  173.            signedPortionEndOffset: signedPortionEndOffset };
  174. };
  176. /**
  177.  * Decode input as an NDN-TLV interest and set the fields of the interest
  178.  * object.
  179.  * @param {Interest} interest The Interest object whose fields are updated.
  180.  * @param {Buffer} input The buffer with the bytes to decode.
  181.  * @param {boolean} copy (optional) If true, copy from the input when making new
  182.  * Blob values. If false, then Blob values share memory with the input, which
  183.  * must remain unchanged while the Blob values are used. If omitted, use true.
  184.  * @return {object} An associative array with fields
  185.  * (signedPortionBeginOffset, signedPortionEndOffset) where
  186.  * signedPortionBeginOffset is the offset in the encoding of the beginning of
  187.  * the signed portion, and signedPortionEndOffset is the offset in the encoding
  188.  * of the end of the signed portion. The signed portion starts from the first
  189.  * name component and ends just before the final name component (which is
  190.  * assumed to be a signature for a signed interest).
  191.  */
  192. Tlv0_2WireFormat.prototype.decodeInterest = function(interest, input, copy)
  193. {
  194.   try {
  195.     return this.decodeInterestV02_(interest, input, copy);
  196.   } catch (exceptionV02) {
  197.     try {
  198.       // Failed to decode as format v0.2. Try to decode as v0.3.
  199.       return Tlv0_2WireFormat.decodeInterestV03_(interest, input, copy);
  200.     } catch (ex) {
  201.       // Ignore the exception decoding as format v0.3 and throw the exception
  202.       // from trying to decode as format as format v0.2.
  203.       throw exceptionV02;
  204.     }
  205.   }
  206. };
  208. /**
  209.  * Do the work of decodeInterest to decode strictly as format v0.2.
  210.  */
  211. Tlv0_2WireFormat.prototype.decodeInterestV02_ = function(interest, input, copy)
  212. {
  213.   if (copy == null)
  214.     copy = true;
  216.   var decoder = new TlvDecoder(input);
  218.   var endOffset = decoder.readNestedTlvsStart(Tlv.Interest);
  219.   var offsets = Tlv0_2WireFormat.decodeName(interest.getName(), decoder, copy);
  220.   if (decoder.peekType(Tlv.Selectors, endOffset))
  221.     Tlv0_2WireFormat.decodeSelectors(interest, decoder, copy);
  222.   else {
  223.     // Set selectors to none.
  224.     interest.setMinSuffixComponents(null);
  225.     interest.setMaxSuffixComponents(null);
  226.     interest.getKeyLocator().clear();
  227.     interest.getExclude().clear();
  228.     interest.setChildSelector(null);
  229.     interest.setMustBeFresh(false);
  230.   }
  231.   // Require a Nonce, but don't force it to be 4 bytes.
  232.   var nonce = decoder.readBlobTlv(Tlv.Nonce);
  233.   interest.setInterestLifetimeMilliseconds
  234.     (decoder.readOptionalNonNegativeIntegerTlv(Tlv.InterestLifetime, endOffset));
  236.   if (decoder.peekType(Tlv.ForwardingHint, endOffset)) {
  237.     var forwardingHintEndOffset = decoder.readNestedTlvsStart
  238.       (Tlv.ForwardingHint);
  239.     Tlv0_2WireFormat.decodeDelegationSet_
  240.       (interest.getForwardingHint(), forwardingHintEndOffset, decoder, copy);
  241.     decoder.finishNestedTlvs(forwardingHintEndOffset);
  242.   }
  244.   if (decoder.peekType(Tlv.Data, endOffset)) {
  245.     // Get the bytes of the Link TLV.
  246.     var linkBeginOffset = decoder.getOffset();
  247.     var linkEndOffset = decoder.readNestedTlvsStart(Tlv.Data);
  248.     decoder.seek(linkEndOffset);
  250.     interest.setLinkWireEncoding
  251.       (new Blob(decoder.getSlice(linkBeginOffset, linkEndOffset), copy), this);
  252.   }
  253.   else
  254.     interest.unsetLink();
  255.   interest.setSelectedDelegationIndex
  256.     (decoder.readOptionalNonNegativeIntegerTlv(Tlv.SelectedDelegation, endOffset));
  257.   if (interest.getSelectedDelegationIndex() != null &&
  258.       interest.getSelectedDelegationIndex() >= 0 && !interest.hasLink())
  259.     throw new Error("Interest has a selected delegation, but no link object");
  261.   // Set the nonce last because setting other interest fields clears it.
  262.   interest.setNonce(new Blob(nonce, copy));
  264.   decoder.finishNestedTlvs(endOffset);
  265.   return offsets;
  266. };
  268. /**
  269.  * Encode data as NDN-TLV and return the encoding and signed offsets.
  270.  * @param {Data} data The Data object to encode.
  271.  * @return {object} An associative array with fields
  272.  * (encoding, signedPortionBeginOffset, signedPortionEndOffset) where encoding
  273.  * is a Blob containing the encoding, signedPortionBeginOffset is the offset in
  274.  * the encoding of the beginning of the signed portion, and
  275.  * signedPortionEndOffset is the offset in the encoding of the end of the
  276.  * signed portion.
  277.  */
  278. Tlv0_2WireFormat.prototype.encodeData = function(data)
  279. {
  280.   var encoder = new TlvEncoder(1500);
  281.   var saveLength = encoder.getLength();
  283.   // Encode backwards.
  284.   encoder.writeBlobTlv(Tlv.SignatureValue, data.getSignature().getSignature().buf());
  285.   var signedPortionEndOffsetFromBack = encoder.getLength();
  287.   Tlv0_2WireFormat.encodeSignatureInfo_(data.getSignature(), encoder);
  288.   encoder.writeBlobTlv(Tlv.Content, data.getContent().buf());
  289.   Tlv0_2WireFormat.encodeMetaInfo(data.getMetaInfo(), encoder);
  290.   Tlv0_2WireFormat.encodeName(data.getName(), encoder);
  291.   var signedPortionBeginOffsetFromBack = encoder.getLength();
  293.   encoder.writeTypeAndLength(Tlv.Data, encoder.getLength() - saveLength);
  294.   var signedPortionBeginOffset =
  295.     encoder.getLength() - signedPortionBeginOffsetFromBack;
  296.   var signedPortionEndOffset = encoder.getLength() - signedPortionEndOffsetFromBack;
  298.   return { encoding: new Blob(encoder.getOutput(), false),
  299.            signedPortionBeginOffset: signedPortionBeginOffset,
  300.            signedPortionEndOffset: signedPortionEndOffset };
  301. };
  303. /**
  304.  * Decode input as an NDN-TLV data packet, set the fields in the data object,
  305.  * and return the signed offsets.
  306.  * @param {Data} data The Data object whose fields are updated.
  307.  * @param {Buffer} input The buffer with the bytes to decode.
  308.  * @param {boolean} copy (optional) If true, copy from the input when making new
  309.  * Blob values. If false, then Blob values share memory with the input, which
  310.  * must remain unchanged while the Blob values are used. If omitted, use true.
  311.  * @return {object} An associative array with fields
  312.  * (signedPortionBeginOffset, signedPortionEndOffset) where
  313.  * signedPortionBeginOffset is the offset in the encoding of the beginning of
  314.  * the signed portion, and signedPortionEndOffset is the offset in the encoding
  315.  * of the end of the signed portion.
  316.  */
  317. Tlv0_2WireFormat.prototype.decodeData = function(data, input, copy)
  318. {
  319.   if (copy == null)
  320.     copy = true;
  322.   var decoder = new TlvDecoder(input);
  324.   var endOffset = decoder.readNestedTlvsStart(Tlv.Data);
  325.   var signedPortionBeginOffset = decoder.getOffset();
  327.   Tlv0_2WireFormat.decodeName(data.getName(), decoder, copy);
  328.   Tlv0_2WireFormat.decodeMetaInfo(data.getMetaInfo(), decoder, copy);
  329.   data.setContent(new Blob(decoder.readBlobTlv(Tlv.Content), copy));
  330.   Tlv0_2WireFormat.decodeSignatureInfo(data, decoder, copy);
  332.   var signedPortionEndOffset = decoder.getOffset();
  333.   data.getSignature().setSignature
  334.     (new Blob(decoder.readBlobTlv(Tlv.SignatureValue), copy));
  336.   decoder.finishNestedTlvs(endOffset);
  337.   return { signedPortionBeginOffset: signedPortionBeginOffset,
  338.            signedPortionEndOffset: signedPortionEndOffset };
  339. };
  341. /**
  342.  * Encode controlParameters as NDN-TLV and return the encoding.
  343.  * @param {ControlParameters} controlParameters The ControlParameters object to
  344.  * encode.
  345.  * @return {Blob} A Blob containing the encoding.
  346.  */
  347. Tlv0_2WireFormat.prototype.encodeControlParameters = function(controlParameters)
  348. {
  349.   var encoder = new TlvEncoder(256);
  350.   Tlv0_2WireFormat.encodeControlParameters(controlParameters, encoder);
  351.   return new Blob(encoder.getOutput(), false);
  352. };
  354. /**
  355.  * Decode controlParameters in NDN-TLV and set the fields of the
  356.  * controlParameters object.
  357.  * @param {ControlParameters} controlParameters The ControlParameters object
  358.  * whose fields are updated.
  359.  * @param {Buffer} input The buffer with the bytes to decode.
  360.  * @param {boolean} copy (optional) If true, copy from the input when making new
  361.  * Blob values. If false, then Blob values share memory with the input, which
  362.  * must remain unchanged while the Blob values are used. If omitted, use true.
  363.  * @throws DecodingException For invalid encoding
  364.  */
  365. Tlv0_2WireFormat.prototype.decodeControlParameters = function
  366.   (controlParameters, input, copy)
  367. {
  368.   if (copy == null)
  369.     copy = true;
  371.   var decoder = new TlvDecoder(input);
  372.   Tlv0_2WireFormat.decodeControlParameters(controlParameters, decoder, copy);
  373. };
  375. /**
  376.  * Encode controlResponse as NDN-TLV and return the encoding.
  377.  * @param {ControlResponse} controlResponse The ControlResponse object to
  378.  * encode.
  379.  * @return {Blob} A Blob containing the encoding.
  380.  */
  381. Tlv0_2WireFormat.prototype.encodeControlResponse = function(controlResponse)
  382. {
  383.   var encoder = new TlvEncoder(256);
  384.   var saveLength = encoder.getLength();
  386.   // Encode backwards.
  388.   // Encode the body.
  389.   if (controlResponse.getBodyAsControlParameters() != null)
  390.     Tlv0_2WireFormat.encodeControlParameters
  391.       (controlResponse.getBodyAsControlParameters(), encoder);
  393.   encoder.writeBlobTlv
  394.     (Tlv.NfdCommand_StatusText, new Blob(controlResponse.getStatusText()).buf());
  395.   encoder.writeNonNegativeIntegerTlv
  396.     (Tlv.NfdCommand_StatusCode, controlResponse.getStatusCode());
  398.   encoder.writeTypeAndLength
  399.     (Tlv.NfdCommand_ControlResponse, encoder.getLength() - saveLength);
  401.   return new Blob(encoder.getOutput(), false);
  402. };
  404. /**
  405.  * Decode controlResponse in NDN-TLV and set the fields of the controlResponse
  406.  * object
  407.  * @param {ControlResponse} controlResponse The ControlResponse object whose
  408.  * fields are updated.
  409.  * @param {Buffer} input The buffer with the bytes to decode.
  410.  * @param {boolean} copy (optional) If true, copy from the input when making new
  411.  * Blob values. If false, then Blob values share memory with the input, which
  412.  * must remain unchanged while the Blob values are used. If omitted, use true.
  413.  * @throws DecodingException For invalid encoding
  414.  */
  415. Tlv0_2WireFormat.prototype.decodeControlResponse = function
  416.   (controlResponse, input, copy)
  417. {
  418.   if (copy == null)
  419.     copy = true;
  421.   var decoder = new TlvDecoder(input);
  422.   var endOffset = decoder.readNestedTlvsStart(Tlv.NfdCommand_ControlResponse);
  424.   controlResponse.setStatusCode(decoder.readNonNegativeIntegerTlv
  425.     (Tlv.NfdCommand_StatusCode));
  426.   // Set copy false since we just immediately get a string.
  427.   var statusText = new Blob
  428.     (decoder.readBlobTlv(Tlv.NfdCommand_StatusText), false);
  429.   controlResponse.setStatusText(statusText.toString());
  431.   // Decode the body.
  432.   if (decoder.peekType(Tlv.ControlParameters_ControlParameters, endOffset)) {
  433.     controlResponse.setBodyAsControlParameters(new ControlParameters());
  434.     // Decode into the existing ControlParameters to avoid copying.
  435.     Tlv0_2WireFormat.decodeControlParameters
  436.       (controlResponse.getBodyAsControlParameters(), decoder, copy);
  437.   }
  438.   else
  439.     controlResponse.setBodyAsControlParameters(null);
  441.   decoder.finishNestedTlvs(endOffset);
  442. };
  444. /**
  445.  * Encode signature as an NDN-TLV SignatureInfo and return the encoding.
  446.  * @param {Signature} signature An object of a subclass of Signature to encode.
  447.  * @return {Blob} A Blob containing the encoding.
  448.  */
  449. Tlv0_2WireFormat.prototype.encodeSignatureInfo = function(signature)
  450. {
  451.   var encoder = new TlvEncoder(256);
  452.   Tlv0_2WireFormat.encodeSignatureInfo_(signature, encoder);
  454.   return new Blob(encoder.getOutput(), false);
  455. };
  457. // SignatureHolder is used by decodeSignatureInfoAndValue.
  458. Tlv0_2WireFormat.SignatureHolder = function Tlv0_2WireFormatSignatureHolder()
  459. {
  460. };
  462. Tlv0_2WireFormat.SignatureHolder.prototype.setSignature = function(signature)
  463. {
  464.   this.signature = signature;
  465. };
  467. Tlv0_2WireFormat.SignatureHolder.prototype.getSignature = function()
  468. {
  469.   return this.signature;
  470. };
  472. /**
  473.  * Decode signatureInfo as an NDN-TLV SignatureInfo and signatureValue as the
  474.  * related SignatureValue, and return a new object which is a subclass of Signature.
  475.  * @param {Buffer} signatureInfo The buffer with the signature info bytes to
  476.  * decode.
  477.  * @param {Buffer} signatureValue The buffer with the signature value to decode.
  478.  * @param {boolean} copy (optional) If true, copy from the input when making new
  479.  * Blob values. If false, then Blob values share memory with the input, which
  480.  * must remain unchanged while the Blob values are used. If omitted, use true.
  481.  * @return {Signature} A new object which is a subclass of Signature.
  482.  */
  483. Tlv0_2WireFormat.prototype.decodeSignatureInfoAndValue = function
  484.   (signatureInfo, signatureValue, copy)
  485. {
  486.   if (copy == null)
  487.     copy = true;
  489.   // Use a SignatureHolder to imitate a Data object for decodeSignatureInfo.
  490.   var signatureHolder = new Tlv0_2WireFormat.SignatureHolder();
  491.   var decoder = new TlvDecoder(signatureInfo);
  492.   Tlv0_2WireFormat.decodeSignatureInfo(signatureHolder, decoder, copy);
  494.   decoder = new TlvDecoder(signatureValue);
  495.   signatureHolder.getSignature().setSignature
  496.     (new Blob(decoder.readBlobTlv(Tlv.SignatureValue), copy));
  498.   return signatureHolder.getSignature();
  499. };
  501. /**
  502.  * Encode the signatureValue in the Signature object as an NDN-TLV
  503.  * SignatureValue (the signature bits) and return the encoding.
  504.  * @param {Signature} signature An object of a subclass of Signature with the
  505.  * signature value to encode.
  506.  * @return {Blob} A Blob containing the encoding.
  507.  */
  508. Tlv0_2WireFormat.prototype.encodeSignatureValue = function(signature)
  509. {
  510.   var encoder = new TlvEncoder(256);
  511.   encoder.writeBlobTlv(Tlv.SignatureValue, signature.getSignature().buf());
  513.   return new Blob(encoder.getOutput(), false);
  514. };
  516. /**
  517.  * Decode input as an NDN-TLV LpPacket and set the fields of the lpPacket object.
  518.  * @param {LpPacket} lpPacket The LpPacket object whose fields are updated.
  519.  * @param {Buffer} input The buffer with the bytes to decode.
  520.  * @param {boolean} copy (optional) If true, copy from the input when making new
  521.  * Blob values. If false, then Blob values share memory with the input, which
  522.  * must remain unchanged while the Blob values are used. If omitted, use true.
  523.  */
  524. Tlv0_2WireFormat.prototype.decodeLpPacket = function(lpPacket, input, copy)
  525. {
  526.   if (copy == null)
  527.     copy = true;
  529.   lpPacket.clear();
  531.   var decoder = new TlvDecoder(input);
  532.   var endOffset = decoder.readNestedTlvsStart(Tlv.LpPacket_LpPacket);
  534.   while (decoder.getOffset() < endOffset) {
  535.     // Imitate TlvDecoder.readTypeAndLength.
  536.     var fieldType = decoder.readVarNumber();
  537.     var fieldLength = decoder.readVarNumber();
  538.     var fieldEndOffset = decoder.getOffset() + fieldLength;
  539.     if (fieldEndOffset > input.length)
  540.       throw new DecodingException(new Error("TLV length exceeds the buffer length"));
  542.     if (fieldType == Tlv.LpPacket_Fragment) {
  543.       // Set the fragment to the bytes of the TLV value.
  544.       lpPacket.setFragmentWireEncoding
  545.         (new Blob(decoder.getSlice(decoder.getOffset(), fieldEndOffset), copy));
  546.       decoder.seek(fieldEndOffset);
  548.       // The fragment is supposed to be the last field.
  549.       break;
  550.     }
  551.     else if (fieldType == Tlv.LpPacket_Nack) {
  552.       var networkNack = new NetworkNack();
  553.       var code = decoder.readOptionalNonNegativeIntegerTlv
  554.         (Tlv.LpPacket_NackReason, fieldEndOffset);
  555.       var reason;
  556.       // The enum numeric values are the same as this wire format, so use as is.
  557.       if (code < 0 || code == NetworkNack.Reason.NONE)
  558.         // This includes an omitted NackReason.
  559.         networkNack.setReason(NetworkNack.Reason.NONE);
  560.       else if (code == NetworkNack.Reason.CONGESTION ||
  561.                code == NetworkNack.Reason.DUPLICATE ||
  562.                code == NetworkNack.Reason.NO_ROUTE)
  563.         networkNack.setReason(code);
  564.       else {
  565.         // Unrecognized reason.
  566.         networkNack.setReason(NetworkNack.Reason.OTHER_CODE);
  567.         networkNack.setOtherReasonCode(code);
  568.       }
  570.       lpPacket.addHeaderField(networkNack);
  571.     }
  572.     else if (fieldType == Tlv.LpPacket_IncomingFaceId) {
  573.       var incomingFaceId = new IncomingFaceId();
  574.       incomingFaceId.setFaceId(decoder.readNonNegativeInteger(fieldLength));
  575.       lpPacket.addHeaderField(incomingFaceId);
  576.     }
  577.     else if (fieldType == Tlv.LpPacket_CongestionMark) {
  578.       var congestionMark = new CongestionMark();
  579.       congestionMark.setCongestionMark(decoder.readNonNegativeInteger
  580.         (fieldLength));
  581.       lpPacket.addHeaderField(congestionMark);
  582.     }
  583.     else {
  584.       // Unrecognized field type. The conditions for ignoring are here:
  585.       // http://redmine.named-data.net/projects/nfd/wiki/NDNLPv2
  586.       var canIgnore =
  587.         (fieldType >= Tlv.LpPacket_IGNORE_MIN &&
  588.          fieldType <= Tlv.LpPacket_IGNORE_MAX &&
  589.          (fieldType & 0x03) == 0);
  590.       if  (!canIgnore)
  591.         throw new DecodingException(new Error("Did not get the expected TLV type"));
  593.       // Ignore.
  594.       decoder.seek(fieldEndOffset);
  595.     }
  597.     decoder.finishNestedTlvs(fieldEndOffset);
  598.   }
  600.   decoder.finishNestedTlvs(endOffset);
  601. };
  603. /**
  604.  * Encode delegationSet as a sequence of NDN-TLV Delegation, and return the
  605.  * encoding. Note that the sequence of Delegation does not have an outer TLV
  606.  * type and length because it is intended to use the type and length of a Data
  607.  * packet's Content.
  608.  * @param {DelegationSet} delegationSet The DelegationSet object to encode.
  609.  * @return {Blob} A Blob containing the encoding.
  610.  */
  611. Tlv0_2WireFormat.prototype.encodeDelegationSet = function(delegationSet)
  612. {
  613.   var encoder = new TlvEncoder(256);
  614.   Tlv0_2WireFormat.encodeDelegationSet_(delegationSet, encoder);
  616.   return new Blob(encoder.getOutput(), false);
  617. };
  619. /**
  620.  * Decode input as a sequence of NDN-TLV Delegation and set the fields of the
  621.  * delegationSet object. Note that the sequence of Delegation does not have an
  622.  * outer TLV type and length because it is intended to use the type and length
  623.  * of a Data packet's Content. This ignores any elements after the sequence
  624.  * of Delegation.
  625.  * @param {DelegationSet} delegationSet The DelegationSet object
  626.  * whose fields are updated.
  627.  * @param {Buffer} input The buffer with the bytes to decode.
  628.  * @param {boolean} copy (optional) If true, copy from the input when making new
  629.  * Blob values. If false, then Blob values share memory with the input, which
  630.  * must remain unchanged while the Blob values are used. If omitted, use true.
  631.  */
  632. Tlv0_2WireFormat.prototype.decodeDelegationSet = function
  633.   (delegationSet, input, copy)
  634. {
  635.   if (copy == null)
  636.     copy = true;
  638.   var decoder = new TlvDecoder(input);
  639.   Tlv0_2WireFormat.decodeDelegationSet_
  640.     (delegationSet, input.length, decoder, copy);
  641. };
  643. /**
  644.  * Encode the EncryptedContent in NDN-TLV and return the encoding.
  645.  * @param {EncryptedContent} encryptedContent The EncryptedContent object to
  646.  * encode.
  647.  * @return {Blob} A Blob containing the encoding.
  648.  */
  649. Tlv0_2WireFormat.prototype.encodeEncryptedContent = function(encryptedContent)
  650. {
  651.   var encoder = new TlvEncoder(256);
  652.   var saveLength = encoder.getLength();
  654.   // Encode backwards.
  655.   encoder.writeBlobTlv
  656.     (Tlv.Encrypt_EncryptedPayload, encryptedContent.getPayload().buf());
  657.   encoder.writeOptionalBlobTlv
  658.     (Tlv.Encrypt_InitialVector, encryptedContent.getInitialVector().buf());
  659.   // Assume the algorithmType value is the same as the TLV type.
  660.   encoder.writeNonNegativeIntegerTlv
  661.     (Tlv.Encrypt_EncryptionAlgorithm, encryptedContent.getAlgorithmType());
  662.   Tlv0_2WireFormat.encodeKeyLocator
  663.     (Tlv.KeyLocator, encryptedContent.getKeyLocator(), encoder);
  665.   encoder.writeTypeAndLength
  666.     (Tlv.Encrypt_EncryptedContent, encoder.getLength() - saveLength);
  668.   return new Blob(encoder.getOutput(), false);
  669. };
  671. /**
  672.  * Decode input as an EncryptedContent in NDN-TLV and set the fields of the
  673.  * encryptedContent object.
  674.  * @param {EncryptedContent} encryptedContent The EncryptedContent object
  675.  * whose fields are updated.
  676.  * @param {Buffer} input The buffer with the bytes to decode.
  677.  * @param {boolean} copy (optional) If true, copy from the input when making new
  678.  * Blob values. If false, then Blob values share memory with the input, which
  679.  * must remain unchanged while the Blob values are used. If omitted, use true.
  680.  */
  681. Tlv0_2WireFormat.prototype.decodeEncryptedContent = function
  682.   (encryptedContent, input, copy)
  683. {
  684.   if (copy == null)
  685.     copy = true;
  687.   var decoder = new TlvDecoder(input);
  688.   var endOffset = decoder.
  689.     readNestedTlvsStart(Tlv.Encrypt_EncryptedContent);
  691.   Tlv0_2WireFormat.decodeKeyLocator
  692.     (Tlv.KeyLocator, encryptedContent.getKeyLocator(), decoder, copy);
  693.   encryptedContent.setAlgorithmType
  694.     (decoder.readNonNegativeIntegerTlv(Tlv.Encrypt_EncryptionAlgorithm));
  695.   encryptedContent.setInitialVector
  696.     (new Blob(decoder.readOptionalBlobTlv
  697.      (Tlv.Encrypt_InitialVector, endOffset), copy));
  698.   encryptedContent.setPayload
  699.     (new Blob(decoder.readBlobTlv(Tlv.Encrypt_EncryptedPayload), copy));
  701.   decoder.finishNestedTlvs(endOffset);
  702. };
  704. /**
  705.  * Get a singleton instance of a Tlv0_2WireFormat.  To always use the
  706.  * preferred version NDN-TLV, you should use TlvWireFormat.get().
  707.  * @return {Tlv0_2WireFormat} The singleton instance.
  708.  */
  709. Tlv0_2WireFormat.get = function()
  710. {
  711.   if (Tlv0_2WireFormat.instance === null)
  712.     Tlv0_2WireFormat.instance = new Tlv0_2WireFormat();
  713.   return Tlv0_2WireFormat.instance;
  714. };
  716. /**
  717.  * Encode the name component to the encoder as NDN-TLV. This handles different
  718.  * component types such as ImplicitSha256DigestComponent.
  719.  * @param {Name.Component} component The name component to encode.
  720.  * @param {TlvEncoder} encoder The encoder to receive the encoding.
  721.  */
  722. Tlv0_2WireFormat.encodeNameComponent = function(component, encoder)
  723. {
  724.   var type;
  725.   if (component.getType() === ComponentType.OTHER_CODE)
  726.     type = component.getOtherTypeCode();
  727.   else
  728.     // The enum values are the same as the TLV type codes.
  729.     type = component.getType();
  731.   encoder.writeBlobTlv(type, component.getValue().buf());
  732. };
  734. /**
  735.  * Decode the name component as NDN-TLV and return the component. This handles
  736.  * different component types such as ImplicitSha256DigestComponent.
  737.  * @param {TlvDecoder} decoder The decoder with the input.
  738.  * @param {boolean} copy (optional) If true, copy from the input when making new
  739.  * Blob values. If false, then Blob values share memory with the input, which
  740.  * must remain unchanged while the Blob values are used. If omitted, use true.
  741.  * @return {Name.Component} A new Name.Component.
  742.  */
  743. Tlv0_2WireFormat.decodeNameComponent = function(decoder, copy)
  744. {
  745.   if (copy == null)
  746.     copy = true;
  748.   var savePosition = decoder.getOffset();
  749.   var type = decoder.readVarNumber();
  750.   // Restore the position.
  751.   decoder.seek(savePosition);
  753.   var value = new Blob(decoder.readBlobTlv(type), copy);
  754.   if (type === Tlv.ImplicitSha256DigestComponent)
  755.     return Name.Component.fromImplicitSha256Digest(value);
  756.   else if (type === Tlv.NameComponent)
  757.     return new Name.Component(value);
  758.   else
  759.     // Unrecognized type code.
  760.     return new Name.Component(value, ComponentType.OTHER_CODE, type);
  761. };
  763. /**
  764.  * Encode the name to the encoder.
  765.  * @param {Name} name The name to encode.
  766.  * @param {TlvEncoder} encoder The encoder to receive the encoding.
  767.  * @return {object} An associative array with fields
  768.  * (signedPortionBeginOffset, signedPortionEndOffset) where
  769.  * signedPortionBeginOffset is the offset in the encoding of the beginning of
  770.  * the signed portion, and signedPortionEndOffset is the offset in the encoding
  771.  * of the end of the signed portion. The signed portion starts from the first
  772.  * name component and ends just before the final name component (which is
  773.  * assumed to be a signature for a signed interest).
  774.  */
  775. Tlv0_2WireFormat.encodeName = function(name, encoder)
  776. {
  777.   var saveLength = encoder.getLength();
  779.   // Encode the components backwards.
  780.   var signedPortionEndOffsetFromBack;
  781.   for (var i = name.size() - 1; i >= 0; --i) {
  782.     Tlv0_2WireFormat.encodeNameComponent(name.get(i), encoder);
  783.     if (i == name.size() - 1)
  784.       signedPortionEndOffsetFromBack = encoder.getLength();
  785.   }
  787.   var signedPortionBeginOffsetFromBack = encoder.getLength();
  788.   encoder.writeTypeAndLength(Tlv.Name, encoder.getLength() - saveLength);
  790.   var signedPortionBeginOffset =
  791.     encoder.getLength() - signedPortionBeginOffsetFromBack;
  792.   var signedPortionEndOffset;
  793.   if (name.size() == 0)
  794.     // There is no "final component", so set signedPortionEndOffset arbitrarily.
  795.     signedPortionEndOffset = signedPortionBeginOffset;
  796.   else
  797.     signedPortionEndOffset = encoder.getLength() - signedPortionEndOffsetFromBack;
  799.   return { signedPortionBeginOffset: signedPortionBeginOffset,
  800.            signedPortionEndOffset: signedPortionEndOffset };
  801. };
  803. /**
  804.  * Clear the name, decode a Name from the decoder and set the fields of the name
  805.  * object.
  806.  * @param {Name} name The name object whose fields are updated.
  807.  * @param {TlvDecoder} decoder The decoder with the input.
  808.  * @return {object} An associative array with fields
  809.  * (signedPortionBeginOffset, signedPortionEndOffset) where
  810.  * signedPortionBeginOffset is the offset in the encoding of the beginning of
  811.  * the signed portion, and signedPortionEndOffset is the offset in the encoding
  812.  * of the end of the signed portion. The signed portion starts from the first
  813.  * name component and ends just before the final name component (which is
  814.  * assumed to be a signature for a signed interest).
  815.  */
  816. Tlv0_2WireFormat.decodeName = function(name, decoder, copy)
  817. {
  818.   name.clear();
  820.   var endOffset = decoder.readNestedTlvsStart(Tlv.Name);
  821.   var signedPortionBeginOffset = decoder.getOffset();
  822.   // In case there are no components, set signedPortionEndOffset arbitrarily.
  823.   var signedPortionEndOffset = signedPortionBeginOffset;
  825.   while (decoder.getOffset() < endOffset) {
  826.     signedPortionEndOffset = decoder.getOffset();
  827.     name.append(Tlv0_2WireFormat.decodeNameComponent(decoder, copy));
  828.   }
  830.   decoder.finishNestedTlvs(endOffset);
  832.   return { signedPortionBeginOffset: signedPortionBeginOffset,
  833.            signedPortionEndOffset: signedPortionEndOffset };
  834. };
  836. /**
  837.  * Encode the interest selectors.  If no selectors are written, do not output a
  838.  * Selectors TLV.
  839.  */
  840. Tlv0_2WireFormat.encodeSelectors = function(interest, encoder)
  841. {
  842.   var saveLength = encoder.getLength();
  844.   // Encode backwards.
  845.   if (interest.getMustBeFresh())
  846.     encoder.writeTypeAndLength(Tlv.MustBeFresh, 0);
  847.   encoder.writeOptionalNonNegativeIntegerTlv(
  848.     Tlv.ChildSelector, interest.getChildSelector());
  849.   if (interest.getExclude().size() > 0)
  850.     Tlv0_2WireFormat.encodeExclude(interest.getExclude(), encoder);
  852.   if (interest.getKeyLocator().getType() != null)
  853.     Tlv0_2WireFormat.encodeKeyLocator
  854.       (Tlv.PublisherPublicKeyLocator, interest.getKeyLocator(), encoder);
  856.   encoder.writeOptionalNonNegativeIntegerTlv(
  857.     Tlv.MaxSuffixComponents, interest.getMaxSuffixComponents());
  858.   encoder.writeOptionalNonNegativeIntegerTlv(
  859.     Tlv.MinSuffixComponents, interest.getMinSuffixComponents());
  861.   // Only output the type and length if values were written.
  862.   if (encoder.getLength() != saveLength)
  863.     encoder.writeTypeAndLength(Tlv.Selectors, encoder.getLength() - saveLength);
  864. };
  866. Tlv0_2WireFormat.decodeSelectors = function(interest, decoder, copy)
  867. {
  868.   if (copy == null)
  869.     copy = true;
  871.   var endOffset = decoder.readNestedTlvsStart(Tlv.Selectors);
  873.   interest.setMinSuffixComponents(decoder.readOptionalNonNegativeIntegerTlv
  874.     (Tlv.MinSuffixComponents, endOffset));
  875.   interest.setMaxSuffixComponents(decoder.readOptionalNonNegativeIntegerTlv
  876.     (Tlv.MaxSuffixComponents, endOffset));
  878.   if (decoder.peekType(Tlv.PublisherPublicKeyLocator, endOffset))
  879.     Tlv0_2WireFormat.decodeKeyLocator
  880.       (Tlv.PublisherPublicKeyLocator, interest.getKeyLocator(), decoder, copy);
  881.   else
  882.     interest.getKeyLocator().clear();
  884.   if (decoder.peekType(Tlv.Exclude, endOffset))
  885.     Tlv0_2WireFormat.decodeExclude(interest.getExclude(), decoder, copy);
  886.   else
  887.     interest.getExclude().clear();
  889.   interest.setChildSelector(decoder.readOptionalNonNegativeIntegerTlv
  890.     (Tlv.ChildSelector, endOffset));
  891.   interest.setMustBeFresh(decoder.readBooleanTlv(Tlv.MustBeFresh, endOffset));
  893.   decoder.finishNestedTlvs(endOffset);
  894. };
  896. Tlv0_2WireFormat.encodeExclude = function(exclude, encoder)
  897. {
  898.   var saveLength = encoder.getLength();
  900.   // TODO: Do we want to order the components (except for ANY)?
  901.   // Encode the entries backwards.
  902.   for (var i = exclude.size() - 1; i >= 0; --i) {
  903.     var entry = exclude.get(i);
  905.     if (entry == Exclude.ANY)
  906.       encoder.writeTypeAndLength(Tlv.Any, 0);
  907.     else
  908.       Tlv0_2WireFormat.encodeNameComponent(entry, encoder);
  909.   }
  911.   encoder.writeTypeAndLength(Tlv.Exclude, encoder.getLength() - saveLength);
  912. };
  914. Tlv0_2WireFormat.decodeExclude = function(exclude, decoder, copy)
  915. {
  916.   if (copy == null)
  917.     copy = true;
  919.   var endOffset = decoder.readNestedTlvsStart(Tlv.Exclude);
  921.   exclude.clear();
  922.   while (decoder.getOffset() < endOffset) {
  923.     if (decoder.peekType(Tlv.Any, endOffset)) {
  924.       // Read past the Any TLV.
  925.       decoder.readBooleanTlv(Tlv.Any, endOffset);
  926.       exclude.appendAny();
  927.     }
  928.     else
  929.       exclude.appendComponent(Tlv0_2WireFormat.decodeNameComponent(decoder, copy));
  930.   }
  932.   decoder.finishNestedTlvs(endOffset);
  933. };
  935. Tlv0_2WireFormat.encodeKeyLocator = function(type, keyLocator, encoder)
  936. {
  937.   var saveLength = encoder.getLength();
  939.   // Encode backwards.
  940.   if (keyLocator.getType() != null) {
  941.     if (keyLocator.getType() == KeyLocatorType.KEYNAME)
  942.       Tlv0_2WireFormat.encodeName(keyLocator.getKeyName(), encoder);
  943.     else if (keyLocator.getType() == KeyLocatorType.KEY_LOCATOR_DIGEST &&
  944.              keyLocator.getKeyData().size() > 0)
  945.       encoder.writeBlobTlv(Tlv.KeyLocatorDigest, keyLocator.getKeyData().buf());
  946.     else
  947.       throw new Error("Unrecognized KeyLocatorType " + keyLocator.getType());
  948.   }
  950.   encoder.writeTypeAndLength(type, encoder.getLength() - saveLength);
  951. };
  953. Tlv0_2WireFormat.decodeKeyLocator = function
  954.   (expectedType, keyLocator, decoder, copy)
  955. {
  956.   if (copy == null)
  957.     copy = true;
  959.   var endOffset = decoder.readNestedTlvsStart(expectedType);
  961.   keyLocator.clear();
  963.   if (decoder.getOffset() == endOffset)
  964.     // The KeyLocator is omitted, so leave the fields as none.
  965.     return;
  967.   if (decoder.peekType(Tlv.Name, endOffset)) {
  968.     // KeyLocator is a Name.
  969.     keyLocator.setType(KeyLocatorType.KEYNAME);
  970.     Tlv0_2WireFormat.decodeName(keyLocator.getKeyName(), decoder, copy);
  971.   }
  972.   else if (decoder.peekType(Tlv.KeyLocatorDigest, endOffset)) {
  973.     // KeyLocator is a KeyLocatorDigest.
  974.     keyLocator.setType(KeyLocatorType.KEY_LOCATOR_DIGEST);
  975.     keyLocator.setKeyData
  976.       (new Blob(decoder.readBlobTlv(Tlv.KeyLocatorDigest), copy));
  977.   }
  978.   else
  979.     throw new DecodingException(new Error
  980.       ("decodeKeyLocator: Unrecognized key locator type"));
  982.   decoder.finishNestedTlvs(endOffset);
  983. };
  985. Tlv0_2WireFormat.encodeValidityPeriod_ = function(validityPeriod, encoder)
  986. {
  987.   var saveLength = encoder.getLength();
  989.   // Encode backwards.
  990.   encoder.writeBlobTlv(Tlv.ValidityPeriod_NotAfter,
  991.     new Blob(Schedule.toIsoString(validityPeriod.getNotAfter())).buf());
  992.   encoder.writeBlobTlv(Tlv.ValidityPeriod_NotBefore,
  993.     new Blob(Schedule.toIsoString(validityPeriod.getNotBefore())).buf());
  995.   encoder.writeTypeAndLength
  996.     (Tlv.ValidityPeriod_ValidityPeriod, encoder.getLength() - saveLength);
  997. };
  999. Tlv0_2WireFormat.decodeValidityPeriod_ = function(validityPeriod, decoder)
  1000. {
  1001.   var endOffset = decoder.readNestedTlvsStart(Tlv.ValidityPeriod_ValidityPeriod);
  1003.   validityPeriod.clear();
  1005.   // Set copy false since we just immediately get the string.
  1006.   var isoString = new Blob
  1007.     (decoder.readBlobTlv(Tlv.ValidityPeriod_NotBefore), false);
  1008.   var notBefore = Schedule.fromIsoString(isoString.toString());
  1009.   isoString = new Blob
  1010.     (decoder.readBlobTlv(Tlv.ValidityPeriod_NotAfter), false);
  1011.   var notAfter = Schedule.fromIsoString(isoString.toString());
  1013.   validityPeriod.setPeriod(notBefore, notAfter);
  1015.   decoder.finishNestedTlvs(endOffset);
  1016. };
  1018. /**
  1019.  * An internal method to encode signature as the appropriate form of
  1020.  * SignatureInfo in NDN-TLV.
  1021.  * @param {Signature} signature An object of a subclass of Signature to encode.
  1022.  * @param {TlvEncoder} encoder The encoder.
  1023.  */
  1024. Tlv0_2WireFormat.encodeSignatureInfo_ = function(signature, encoder)
  1025. {
  1026.   if (signature instanceof GenericSignature) {
  1027.     // Handle GenericSignature separately since it has the entire encoding.
  1028.     var encoding = signature.getSignatureInfoEncoding();
  1030.     // Do a test decoding to sanity check that it is valid TLV.
  1031.     try {
  1032.       var decoder = new TlvDecoder(encoding.buf());
  1033.       var endOffset = decoder.readNestedTlvsStart(Tlv.SignatureInfo);
  1034.       decoder.readNonNegativeIntegerTlv(Tlv.SignatureType);
  1035.       // Skip unrecognized TLVs, even if they have a critical type code.
  1036.       decoder.finishNestedTlvs(endOffset, true);
  1037.     } catch (ex) {
  1038.       throw new Error
  1039.         ("The GenericSignature encoding is not a valid NDN-TLV SignatureInfo: " +
  1040.          ex.message);
  1041.     }
  1043.     encoder.writeBuffer(encoding.buf());
  1044.     return;
  1045.   }
  1047.   var saveLength = encoder.getLength();
  1049.   // Encode backwards.
  1050.   if (signature instanceof Sha256WithRsaSignature) {
  1051.     if (signature.getValidityPeriod().hasPeriod())
  1052.       Tlv0_2WireFormat.encodeValidityPeriod_
  1053.         (signature.getValidityPeriod(), encoder);
  1054.     Tlv0_2WireFormat.encodeKeyLocator
  1055.       (Tlv.KeyLocator, signature.getKeyLocator(), encoder);
  1056.     encoder.writeNonNegativeIntegerTlv
  1057.       (Tlv.SignatureType, Tlv.SignatureType_SignatureSha256WithRsa);
  1058.   }
  1059.   else if (signature instanceof Sha256WithEcdsaSignature) {
  1060.     if (signature.getValidityPeriod().hasPeriod())
  1061.       Tlv0_2WireFormat.encodeValidityPeriod_
  1062.         (signature.getValidityPeriod(), encoder);
  1063.     Tlv0_2WireFormat.encodeKeyLocator
  1064.       (Tlv.KeyLocator, signature.getKeyLocator(), encoder);
  1065.     encoder.writeNonNegativeIntegerTlv
  1066.       (Tlv.SignatureType, Tlv.SignatureType_SignatureSha256WithEcdsa);
  1067.   }
  1068.   else if (signature instanceof HmacWithSha256Signature) {
  1069.     Tlv0_2WireFormat.encodeKeyLocator
  1070.       (Tlv.KeyLocator, signature.getKeyLocator(), encoder);
  1071.     encoder.writeNonNegativeIntegerTlv
  1072.       (Tlv.SignatureType, Tlv.SignatureType_SignatureHmacWithSha256);
  1073.   }
  1074.   else if (signature instanceof DigestSha256Signature)
  1075.     encoder.writeNonNegativeIntegerTlv
  1076.       (Tlv.SignatureType, Tlv.SignatureType_DigestSha256);
  1077.   else
  1078.     throw new Error("encodeSignatureInfo: Unrecognized Signature object type");
  1080.   encoder.writeTypeAndLength(Tlv.SignatureInfo, encoder.getLength() - saveLength);
  1081. };
  1083. Tlv0_2WireFormat.decodeSignatureInfo = function(data, decoder, copy)
  1084. {
  1085.   if (copy == null)
  1086.     copy = true;
  1088.   var beginOffset = decoder.getOffset();
  1089.   var endOffset = decoder.readNestedTlvsStart(Tlv.SignatureInfo);
  1091.   var signatureType = decoder.readNonNegativeIntegerTlv(Tlv.SignatureType);
  1092.   if (signatureType == Tlv.SignatureType_SignatureSha256WithRsa) {
  1093.     data.setSignature(new Sha256WithRsaSignature());
  1094.     // Modify data's signature object because if we create an object
  1095.     //   and set it, then data will have to copy all the fields.
  1096.     var signatureInfo = data.getSignature();
  1097.     Tlv0_2WireFormat.decodeKeyLocator
  1098.       (Tlv.KeyLocator, signatureInfo.getKeyLocator(), decoder, copy);
  1099.     if (decoder.peekType(Tlv.ValidityPeriod_ValidityPeriod, endOffset))
  1100.       Tlv0_2WireFormat.decodeValidityPeriod_
  1101.         (signatureInfo.getValidityPeriod(), decoder);
  1102.   }
  1103.   else if (signatureType == Tlv.SignatureType_SignatureSha256WithEcdsa) {
  1104.     data.setSignature(new Sha256WithEcdsaSignature());
  1105.     var signatureInfo = data.getSignature();
  1106.     Tlv0_2WireFormat.decodeKeyLocator
  1107.       (Tlv.KeyLocator, signatureInfo.getKeyLocator(), decoder, copy);
  1108.     if (decoder.peekType(Tlv.ValidityPeriod_ValidityPeriod, endOffset))
  1109.       Tlv0_2WireFormat.decodeValidityPeriod_
  1110.         (signatureInfo.getValidityPeriod(), decoder);
  1111.   }
  1112.   else if (signatureType == Tlv.SignatureType_SignatureHmacWithSha256) {
  1113.     data.setSignature(new HmacWithSha256Signature());
  1114.     var signatureInfo = data.getSignature();
  1115.     Tlv0_2WireFormat.decodeKeyLocator
  1116.       (Tlv.KeyLocator, signatureInfo.getKeyLocator(), decoder, copy);
  1117.   }
  1118.   else if (signatureType == Tlv.SignatureType_DigestSha256)
  1119.     data.setSignature(new DigestSha256Signature());
  1120.   else {
  1121.     data.setSignature(new GenericSignature());
  1122.     var signatureInfo = data.getSignature();
  1124.     // Get the bytes of the SignatureInfo TLV.
  1125.     signatureInfo.setSignatureInfoEncoding
  1126.       (new Blob(decoder.getSlice(beginOffset, endOffset), copy), signatureType);
  1127.     // Skip the remaining TLVs now, allowing unrecognized critical type codes.
  1128.     decoder.finishNestedTlvs(endOffset, true);
  1129.   }
  1131.   decoder.finishNestedTlvs(endOffset);
  1132. };
  1134. Tlv0_2WireFormat.encodeMetaInfo = function(metaInfo, encoder)
  1135. {
  1136.   var saveLength = encoder.getLength();
  1138.   // Encode backwards.
  1139.   var finalBlockIdBuf = metaInfo.getFinalBlockId().getValue().buf();
  1140.   if (finalBlockIdBuf != null && finalBlockIdBuf.length > 0) {
  1141.     // FinalBlockId has an inner NameComponent.
  1142.     var finalBlockIdSaveLength = encoder.getLength();
  1143.     Tlv0_2WireFormat.encodeNameComponent(metaInfo.getFinalBlockId(), encoder);
  1144.     encoder.writeTypeAndLength
  1145.       (Tlv.FinalBlockId, encoder.getLength() - finalBlockIdSaveLength);
  1146.   }
  1148.   encoder.writeOptionalNonNegativeIntegerTlv
  1149.     (Tlv.FreshnessPeriod, metaInfo.getFreshnessPeriod());
  1150.   if (metaInfo.getType() != ContentType.BLOB) {
  1151.     // Not the default, so we need to encode the type.
  1152.     if (metaInfo.getType() == ContentType.LINK ||
  1153.         metaInfo.getType() == ContentType.KEY ||
  1154.         metaInfo.getType() == ContentType.NACK)
  1155.       // The ContentType enum is set up with the correct integer for
  1156.       // each NDN-TLV ContentType.
  1157.       encoder.writeNonNegativeIntegerTlv(Tlv.ContentType, metaInfo.getType());
  1158.     else if (metaInfo.getType() == ContentType.OTHER_CODE)
  1159.       encoder.writeNonNegativeIntegerTlv
  1160.         (Tlv.ContentType, metaInfo.getOtherTypeCode());
  1161.     else
  1162.       // We don't expect this to happen.
  1163.       throw new Error("unrecognized TLV ContentType");
  1164.   }
  1166.   encoder.writeTypeAndLength(Tlv.MetaInfo, encoder.getLength() - saveLength);
  1167. };
  1169. Tlv0_2WireFormat.decodeMetaInfo = function(metaInfo, decoder, copy)
  1170. {
  1171.   if (copy == null)
  1172.     copy = true;
  1174.   var endOffset = decoder.readNestedTlvsStart(Tlv.MetaInfo);
  1176.   var type = decoder.readOptionalNonNegativeIntegerTlv
  1177.     (Tlv.ContentType, endOffset);
  1178.   if (type == null || type < 0 || type === ContentType.BLOB)
  1179.     metaInfo.setType(ContentType.BLOB);
  1180.   else if (type === ContentType.LINK ||
  1181.            type === ContentType.KEY ||
  1182.            type === ContentType.NACK)
  1183.     // The ContentType enum is set up with the correct integer for each NDN-TLV
  1184.     // ContentType.
  1185.     metaInfo.setType(type);
  1186.   else {
  1187.     // Unrecognized content type.
  1188.     metaInfo.setType(ContentType.OTHER_CODE);
  1189.     metaInfo.setOtherTypeCode(type);
  1190.   }
  1192.   metaInfo.setFreshnessPeriod
  1193.     (decoder.readOptionalNonNegativeIntegerTlv(Tlv.FreshnessPeriod, endOffset));
  1194.   if (decoder.peekType(Tlv.FinalBlockId, endOffset)) {
  1195.     var finalBlockIdEndOffset = decoder.readNestedTlvsStart(Tlv.FinalBlockId);
  1196.     metaInfo.setFinalBlockId(Tlv0_2WireFormat.decodeNameComponent(decoder, copy));
  1197.     decoder.finishNestedTlvs(finalBlockIdEndOffset);
  1198.   }
  1199.   else
  1200.     metaInfo.setFinalBlockId(null);
  1202.   decoder.finishNestedTlvs(endOffset);
  1203. };
  1205. Tlv0_2WireFormat.encodeControlParameters = function(controlParameters, encoder)
  1206. {
  1207.   var saveLength = encoder.getLength();
  1209.   // Encode backwards.
  1210.   encoder.writeOptionalNonNegativeIntegerTlv
  1211.     (Tlv.ControlParameters_ExpirationPeriod,
  1212.      controlParameters.getExpirationPeriod());
  1214.   if (controlParameters.getStrategy().size() > 0){
  1215.     var strategySaveLength = encoder.getLength();
  1216.     Tlv0_2WireFormat.encodeName(controlParameters.getStrategy(), encoder);
  1217.     encoder.writeTypeAndLength(Tlv.ControlParameters_Strategy,
  1218.       encoder.getLength() - strategySaveLength);
  1219.   }
  1221.   var flags = controlParameters.getForwardingFlags().getNfdForwardingFlags();
  1222.   if (flags != new ForwardingFlags().getNfdForwardingFlags())
  1223.       // The flags are not the default value.
  1224.       encoder.writeNonNegativeIntegerTlv
  1225.         (Tlv.ControlParameters_Flags, flags);
  1227.   encoder.writeOptionalNonNegativeIntegerTlv
  1228.     (Tlv.ControlParameters_Cost, controlParameters.getCost());
  1229.   encoder.writeOptionalNonNegativeIntegerTlv
  1230.     (Tlv.ControlParameters_Origin, controlParameters.getOrigin());
  1231.   encoder.writeOptionalNonNegativeIntegerTlv
  1232.     (Tlv.ControlParameters_LocalControlFeature,
  1233.      controlParameters.getLocalControlFeature());
  1235.   if (controlParameters.getUri().length != 0)
  1236.     encoder.writeBlobTlv
  1237.       (Tlv.ControlParameters_Uri, new Blob(controlParameters.getUri()).buf());
  1239.   encoder.writeOptionalNonNegativeIntegerTlv
  1240.     (Tlv.ControlParameters_FaceId, controlParameters.getFaceId());
  1241.   if (controlParameters.getName() != null)
  1242.     Tlv0_2WireFormat.encodeName(controlParameters.getName(), encoder);
  1244.   encoder.writeTypeAndLength
  1245.     (Tlv.ControlParameters_ControlParameters, encoder.getLength() - saveLength);
  1246. };
  1248. Tlv0_2WireFormat.decodeControlParameters = function
  1249.   (controlParameters, decoder, copy)
  1250. {
  1251.   if (copy == null)
  1252.     copy = true;
  1254.   controlParameters.clear();
  1255.   var endOffset = decoder.
  1256.     readNestedTlvsStart(Tlv.ControlParameters_ControlParameters);
  1258.   // decode name
  1259.   if (decoder.peekType(Tlv.Name, endOffset)) {
  1260.     var name = new Name();
  1261.     Tlv0_2WireFormat.decodeName(name, decoder, copy);
  1262.     controlParameters.setName(name);
  1263.   }
  1265.   // decode face ID
  1266.   controlParameters.setFaceId(decoder.readOptionalNonNegativeIntegerTlv
  1267.     (Tlv.ControlParameters_FaceId, endOffset));
  1269.   // decode URI
  1270.   if (decoder.peekType(Tlv.ControlParameters_Uri, endOffset)) {
  1271.     // Set copy false since we just immediately get the string.
  1272.     var uri = new Blob
  1273.       (decoder.readOptionalBlobTlv(Tlv.ControlParameters_Uri, endOffset), false);
  1274.     controlParameters.setUri(uri.toString());
  1275.   }
  1277.   // decode integers
  1278.   controlParameters.setLocalControlFeature(decoder.
  1279.     readOptionalNonNegativeIntegerTlv(
  1280.       Tlv.ControlParameters_LocalControlFeature, endOffset));
  1281.   controlParameters.setOrigin(decoder.
  1282.     readOptionalNonNegativeIntegerTlv(Tlv.ControlParameters_Origin,
  1283.       endOffset));
  1284.   controlParameters.setCost(decoder.readOptionalNonNegativeIntegerTlv(
  1285.     Tlv.ControlParameters_Cost, endOffset));
  1287.   // set forwarding flags
  1288.   if (decoder.peekType(Tlv.ControlParameters_Flags, endOffset)) {
  1289.     var flags = new ForwardingFlags();
  1290.     flags.setNfdForwardingFlags(decoder.
  1291.       readNonNegativeIntegerTlv(Tlv.ControlParameters_Flags, endOffset));
  1292.     controlParameters.setForwardingFlags(flags);
  1293.   }
  1295.   // decode strategy
  1296.   if (decoder.peekType(Tlv.ControlParameters_Strategy, endOffset)) {
  1297.     var strategyEndOffset = decoder.readNestedTlvsStart(Tlv.ControlParameters_Strategy);
  1298.     Tlv0_2WireFormat.decodeName(controlParameters.getStrategy(), decoder, copy);
  1299.     decoder.finishNestedTlvs(strategyEndOffset);
  1300.   }
  1302.   // decode expiration period
  1303.   controlParameters.setExpirationPeriod(
  1304.     decoder.readOptionalNonNegativeIntegerTlv(
  1305.       Tlv.ControlParameters_ExpirationPeriod, endOffset));
  1307.   decoder.finishNestedTlvs(endOffset);
  1308. };
  1310. /**
  1311.  * Encode delegationSet to the encoder as a sequence of NDN-TLV Delegation.
  1312.  * Note that the sequence of Delegation does not have an outer TLV type and
  1313.  * length because (when used in a Link object) it is intended to use the type
  1314.  * and length of a Data packet's Content.
  1315.  * @param {DelegationSet} delegationSet The DelegationSet object to encode.
  1316.  * @param {TlvEncoder} encoder The TlvEncoder to receive the encoding.
  1317.  */
  1318. Tlv0_2WireFormat.encodeDelegationSet_ = function(delegationSet, encoder)
  1319. {
  1320.   // Encode backwards.
  1321.   for (var i = delegationSet.size() - 1; i >= 0; --i) {
  1322.     var saveLength = encoder.getLength();
  1324.     Tlv0_2WireFormat.encodeName(delegationSet.get(i).getName(), encoder);
  1325.     encoder.writeNonNegativeIntegerTlv
  1326.       (Tlv.Link_Preference, delegationSet.get(i).getPreference());
  1328.     encoder.writeTypeAndLength
  1329.       (Tlv.Link_Delegation, encoder.getLength() - saveLength);
  1330.   }
  1331. };
  1333. /**
  1334.  * Decode input as a sequence of NDN-TLV Delegation and set the fields of the
  1335.  * delegationSet object. Note that the sequence of Delegation does not have an
  1336.  * outer TLV type and length because (when used in a Link object) it is intended
  1337.  * to use the type and length of a Data packet's Content.
  1338.  * @param {DelegationSet} delegationSet The DelegationSet object whose fields
  1339.  * are updated.
  1340.  * @param {number} endOffset Decode elements up to endOffset in the input. This
  1341.  * does not call finishNestedTlvs.
  1342.  * @param {TlvDecoder} decoder The decoder with the input to decode.
  1343.  * @param {boolean} copy If true, copy from the input when making new Blob
  1344.  * values. If false, then Blob values share memory with the input, which must
  1345.  * remain unchanged while the Blob values are used.
  1346.  */
  1347. Tlv0_2WireFormat.decodeDelegationSet_ = function
  1348.   (delegationSet, endOffset, decoder, copy)
  1349. {
  1350.   delegationSet.clear();
  1351.   while (decoder.getOffset() < endOffset) {
  1352.     decoder.readTypeAndLength(Tlv.Link_Delegation);
  1353.     var preference = decoder.readNonNegativeIntegerTlv(Tlv.Link_Preference);
  1354.     var name = new Name();
  1355.     Tlv0_2WireFormat.decodeName(name, decoder, copy);
  1357.     // Add unsorted to preserve the order so that Interest selected delegation
  1358.     // index will work.
  1359.     delegationSet.addUnsorted(preference, name);
  1360.   }
  1361. };
  1363. /**
  1364.  * Decode input as an Interest in NDN-TLV format v0.3 and set the fields of
  1365.  * the Interest object. This private method is called if the main decodeInterest
  1366.  * fails to decode as v0.2. This ignores HopLimit and Parameters, and interprets
  1367.  * CanBePrefix using MaxSuffixComponents.
  1368.  * @param {Interest} interest The Interest object whose fields are updated.
  1369.  * @param {Buffer} input The buffer with the bytes to decode.
  1370.  * @param {boolean} copy (optional) If true, copy from the input when making new
  1371.  * Blob values. If false, then Blob values share memory with the input, which
  1372.  * must remain unchanged while the Blob values are used. If omitted, use true.
  1373.  * @return {object} An associative array with fields
  1374.  * (signedPortionBeginOffset, signedPortionEndOffset) where
  1375.  * signedPortionBeginOffset is the offset in the encoding of the beginning of
  1376.  * the signed portion, and signedPortionEndOffset is the offset in the encoding
  1377.  * of the end of the signed portion. The signed portion starts from the first
  1378.  * name component and ends just before the final name component (which is
  1379.  * assumed to be a signature for a signed interest).
  1380.  */
  1381. Tlv0_2WireFormat.decodeInterestV03_ = function(interest, input, copy)
  1382. {
  1383.   if (copy == null)
  1384.     copy = true;
  1386.   var decoder = new TlvDecoder(input);
  1388.   var endOffset = decoder.readNestedTlvsStart(Tlv.Interest);
  1389.   var offsets = Tlv0_2WireFormat.decodeName(interest.getName(), decoder, copy);
  1391.   // In v0.2 semantics, this calls setMaxSuffixComponents.
  1392.   interest.setCanBePrefix(decoder.readBooleanTlv(Tlv.CanBePrefix, endOffset));
  1394.   interest.setMustBeFresh(decoder.readBooleanTlv(Tlv.MustBeFresh, endOffset));
  1396.   if (decoder.peekType(Tlv.ForwardingHint, endOffset)) {
  1397.     var forwardingHintEndOffset = decoder.readNestedTlvsStart
  1398.       (Tlv.ForwardingHint);
  1399.     Tlv0_2WireFormat.decodeDelegationSet_
  1400.       (interest.getForwardingHint(), forwardingHintEndOffset, decoder, copy);
  1401.     decoder.finishNestedTlvs(forwardingHintEndOffset);
  1402.   }
  1403.   else
  1404.     interest.getForwardingHint().clear();
  1406.   var nonce = decoder.readOptionalBlobTlv(Tlv.Nonce, endOffset);
  1407.   interest.setInterestLifetimeMilliseconds
  1408.     (decoder.readOptionalNonNegativeIntegerTlv(Tlv.InterestLifetime, endOffset));
  1410.   // Clear the unused fields.
  1411.   interest.setMinSuffixComponents(null);
  1412.   interest.getKeyLocator().clear();
  1413.   interest.getExclude().clear();
  1414.   interest.setChildSelector(null);
  1415.   interest.unsetLink();
  1416.   interest.setSelectedDelegationIndex(null);
  1418.   // Ignore the HopLimit and Parameters.
  1419.   decoder.readOptionalBlobTlv(Tlv.HopLimit, endOffset);
  1420.   decoder.readOptionalBlobTlv(Tlv.Parameters, endOffset);
  1422.   // Set the nonce last because setting other interest fields clears it.
  1423.   interest.setNonce(nonce == null ? new Blob() : new Blob(nonce, copy));
  1425.   decoder.finishNestedTlvs(endOffset);
  1426.   return offsets;
  1427. };