Source: encoding/tlv/tlv-structure-decoder.js

  1. /**
  2.  * Copyright (C) 2014-2016 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 TlvDecoder = require('./tlv-decoder.js').TlvDecoder;
  23. /**
  24.  * Create and initialize a TlvStructureDecoder.
  25.  * @constructor
  26.  */
  27. var TlvStructureDecoder = function TlvStructureDecoder()
  28. {
  29.   this.gotElementEnd = false;
  30.   this.offset = 0;
  31.   this.state = TlvStructureDecoder.READ_TYPE;
  32.   this.headerLength = 0;
  33.   this.useHeaderBuffer = false;
  34.   // 8 bytes is enough to hold the extended bytes in the length encoding
  35.   // where it is an 8-byte number.
  36.   this.headerBuffer = new Buffer(8);
  37.   this.nBytesToRead = 0;
  38. };
  40. exports.TlvStructureDecoder = TlvStructureDecoder;
  42. TlvStructureDecoder.READ_TYPE =         0;
  43. TlvStructureDecoder.READ_TYPE_BYTES =   1;
  44. TlvStructureDecoder.READ_LENGTH =       2;
  45. TlvStructureDecoder.READ_LENGTH_BYTES = 3;
  46. TlvStructureDecoder.READ_VALUE_BYTES =  4;
  48. /**
  49.  * Continue scanning input starting from this.offset to find the element end.
  50.  * If the end of the element which started at offset 0 is found, this returns
  51.  * true and getOffset() is the length of the element.  Otherwise, this returns
  52.  * false which means you should read more into input and call again.
  53.  * @param {Buffer} input The input buffer. You have to pass in input each time
  54.  * because the buffer could be reallocated.
  55.  * @returns {boolean} true if found the element end, false if not.
  56.  */
  57. TlvStructureDecoder.prototype.findElementEnd = function(input)
  58. {
  59.   if (this.gotElementEnd)
  60.     // Someone is calling when we already got the end.
  61.     return true;
  63.   var decoder = new TlvDecoder(input);
  65.   while (true) {
  66.     if (this.offset >= input.length)
  67.       // All the cases assume we have some input. Return and wait for more.
  68.       return false;
  70.     if (this.state == TlvStructureDecoder.READ_TYPE) {
  71.       var firstOctet = input[this.offset];
  72.       this.offset += 1;
  73.       if (firstOctet < 253)
  74.         // The value is simple, so we can skip straight to reading the length.
  75.         this.state = TlvStructureDecoder.READ_LENGTH;
  76.       else {
  77.         // Set up to skip the type bytes.
  78.         if (firstOctet == 253)
  79.           this.nBytesToRead = 2;
  80.         else if (firstOctet == 254)
  81.           this.nBytesToRead = 4;
  82.         else
  83.           // value == 255.
  84.           this.nBytesToRead = 8;
  86.         this.state = TlvStructureDecoder.READ_TYPE_BYTES;
  87.       }
  88.     }
  89.     else if (this.state == TlvStructureDecoder.READ_TYPE_BYTES) {
  90.       var nRemainingBytes = input.length - this.offset;
  91.       if (nRemainingBytes < this.nBytesToRead) {
  92.         // Need more.
  93.         this.offset += nRemainingBytes;
  94.         this.nBytesToRead -= nRemainingBytes;
  95.         return false;
  96.       }
  98.       // Got the type bytes. Move on to read the length.
  99.       this.offset += this.nBytesToRead;
  100.       this.state = TlvStructureDecoder.READ_LENGTH;
  101.     }
  102.     else if (this.state == TlvStructureDecoder.READ_LENGTH) {
  103.       var firstOctet = input[this.offset];
  104.       this.offset += 1;
  105.       if (firstOctet < 253) {
  106.         // The value is simple, so we can skip straight to reading
  107.         //  the value bytes.
  108.         this.nBytesToRead = firstOctet;
  109.         if (this.nBytesToRead == 0) {
  110.           // No value bytes to read. We're finished.
  111.           this.gotElementEnd = true;
  112.           return true;
  113.         }
  115.         this.state = TlvStructureDecoder.READ_VALUE_BYTES;
  116.       }
  117.       else {
  118.         // We need to read the bytes in the extended encoding of
  119.         //  the length.
  120.         if (firstOctet == 253)
  121.           this.nBytesToRead = 2;
  122.         else if (firstOctet == 254)
  123.           this.nBytesToRead = 4;
  124.         else
  125.           // value == 255.
  126.           this.nBytesToRead = 8;
  128.         // We need to use firstOctet in the next state.
  129.         this.firstOctet = firstOctet;
  130.         this.state = TlvStructureDecoder.READ_LENGTH_BYTES;
  131.       }
  132.     }
  133.     else if (this.state == TlvStructureDecoder.READ_LENGTH_BYTES) {
  134.       var nRemainingBytes = input.length - this.offset;
  135.       if (!this.useHeaderBuffer && nRemainingBytes >= this.nBytesToRead) {
  136.         // We don't have to use the headerBuffer. Set nBytesToRead.
  137.         decoder.seek(this.offset);
  139.         this.nBytesToRead = decoder.readExtendedVarNumber(this.firstOctet);
  140.         // Update this.offset to the decoder's offset after reading.
  141.         this.offset = decoder.getOffset();
  142.       }
  143.       else {
  144.         this.useHeaderBuffer = true;
  146.         var nNeededBytes = this.nBytesToRead - this.headerLength;
  147.         if (nNeededBytes > nRemainingBytes) {
  148.           // We can't get all of the header bytes from this input.
  149.           // Save in headerBuffer.
  150.           if (this.headerLength + nRemainingBytes > this.headerBuffer.length)
  151.             // We don't expect this to happen.
  152.             throw new Error
  153.               ("Cannot store more header bytes than the size of headerBuffer");
  154.           input.slice(this.offset, this.offset + nRemainingBytes).copy
  155.             (this.headerBuffer, this.headerLength);
  156.           this.offset += nRemainingBytes;
  157.           this.headerLength += nRemainingBytes;
  159.           return false;
  160.         }
  162.         // Copy the remaining bytes into headerBuffer, read the
  163.         //   length and set nBytesToRead.
  164.         if (this.headerLength + nNeededBytes > this.headerBuffer.length)
  165.           // We don't expect this to happen.
  166.           throw new Error
  167.             ("Cannot store more header bytes than the size of headerBuffer");
  168.         input.slice(this.offset, this.offset + nNeededBytes).copy
  169.           (this.headerBuffer, this.headerLength);
  170.         this.offset += nNeededBytes;
  172.         // Use a local decoder just for the headerBuffer.
  173.         var bufferDecoder = new TlvDecoder(this.headerBuffer);
  174.         // Replace nBytesToRead with the length of the value.
  175.         this.nBytesToRead = bufferDecoder.readExtendedVarNumber(this.firstOctet);
  176.       }
  178.       if (this.nBytesToRead == 0) {
  179.         // No value bytes to read. We're finished.
  180.         this.gotElementEnd = true;
  181.         return true;
  182.       }
  184.       // Get ready to read the value bytes.
  185.       this.state = TlvStructureDecoder.READ_VALUE_BYTES;
  186.     }
  187.     else if (this.state == TlvStructureDecoder.READ_VALUE_BYTES) {
  188.       nRemainingBytes = input.length - this.offset;
  189.       if (nRemainingBytes < this.nBytesToRead) {
  190.         // Need more.
  191.         this.offset += nRemainingBytes;
  192.         this.nBytesToRead -= nRemainingBytes;
  193.         return false;
  194.       }
  196.       // Got the bytes. We're finished.
  197.       this.offset += this.nBytesToRead;
  198.       this.gotElementEnd = true;
  199.       return true;
  200.     }
  201.     else
  202.       // We don't expect this to happen.
  203.       throw new Error("findElementEnd: unrecognized state");
  204.   }
  205. };
  207. /**
  208.  * Get the current offset into the input buffer.
  209.  * @returns {number} The offset.
  210.  */
  211. TlvStructureDecoder.prototype.getOffset = function()
  212. {
  213.   return this.offset;
  214. };
  216. /**
  217.  * Set the offset into the input, used for the next read.
  218.  * @param {number} offset The new offset.
  219.  */
  220. TlvStructureDecoder.prototype.seek = function(offset)
  221. {
  222.   this.offset = offset;
  223. };