tor-browser

index.js (6028B)

---

/*
* A socket.io encoder and decoder written in JavaScript complying with version 4
* of socket.io-protocol. Used by socket.io and socket.io-client.
*
* Copyright (c) 2014 Guillermo Rauch <guillermo@learnboost.com>
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of the library source tree.
*
* https://github.com/socketio/socket.io-parser
*/

/* eslint-disable no-unused-vars */

"use strict";

const Emitter = require("resource://devtools/client/netmonitor/src/components/messages/parsers/socket-io/component-emitter.js");
const binary = require("resource://devtools/client/netmonitor/src/components/messages/parsers/socket-io/binary.js");
const isBuf = require("resource://devtools/client/netmonitor/src/components/messages/parsers/socket-io/is-buffer.js");

/**
* Packet types
*/

const TYPES = [
 "CONNECT",
 "DISCONNECT",
 "EVENT",
 "ACK",
 "ERROR",
 "BINARY_EVENT",
 "BINARY_ACK",
];

/**
* Packet type `connect`
*/

const CONNECT = 0;

/**
* Packet type `disconnect`
*/

const DISCONNECT = 1;

/**
* Packet type `event`
*/

const EVENT = 2;

/**
* Packet type `ack`
*/

const ACK = 3;

/**
* Packet type `error`
*/

const ERROR = 4;

/**
* Packet type 'binary event'
*/
const BINARY_EVENT = 5;

/**
* Packet type `binary ack`. For acks with binary arguments
*/

const BINARY_ACK = 6;

/**
* A socket.io Decoder instance
*
* @return {object} decoder
* @public
*/

function Decoder() {
 this.reconstructor = null;
}

/**
* Mix in `Emitter` with Decoder.
*/

Emitter(Decoder.prototype);

/**
* A manager of a binary event's 'buffer sequence'. Should
* be constructed whenever a packet of type BINARY_EVENT is
* decoded.
*
* @param {object} packet
* @return {BinaryReconstructor} initialized reconstructor
* @private
*/

function BinaryReconstructor(packet) {
 this.reconPack = packet;
 this.buffers = [];
}

/**
* Method to be called when binary data received from connection
* after a BINARY_EVENT packet.
*
* @param {Buffer | ArrayBuffer} binData - the raw binary data received
* @return {null | object} returns null if more binary data is expected or
*   a reconstructed packet object if all buffers have been received.
* @private
*/

BinaryReconstructor.prototype.takeBinaryData = function (binData) {
 this.buffers.push(binData);
 if (this.buffers.length === this.reconPack.attachments) {
   // done with buffer list
   const packet = binary.reconstructPacket(this.reconPack, this.buffers);
   this.finishedReconstruction();
   return packet;
 }
 return null;
};

/**
* Cleans up binary packet reconstruction variables.
*
* @private
*/

BinaryReconstructor.prototype.finishedReconstruction = function () {
 this.reconPack = null;
 this.buffers = [];
};

/**
* Decodes an encoded packet string into packet JSON.
*
* @param {string} obj - encoded packet
* @return {object} packet
* @public
*/

Decoder.prototype.add = function (obj) {
 let packet;
 if (typeof obj === "string") {
   packet = decodeString(obj);
   if (BINARY_EVENT === packet.type || BINARY_ACK === packet.type) {
     // binary packet's json
     this.reconstructor = new BinaryReconstructor(packet);

     // no attachments, labeled binary but no binary data to follow
     if (this.reconstructor.reconPack.attachments === 0) {
       this.emit("decoded", packet);
     }
   } else {
     // non-binary full packet
     this.emit("decoded", packet);
   }
 } else if (isBuf(obj) || obj.base64) {
   // raw binary data
   if (!this.reconstructor) {
     throw new Error("got binary data when not reconstructing a packet");
   } else {
     packet = this.reconstructor.takeBinaryData(obj);
     if (packet) {
       // received final buffer
       this.reconstructor = null;
       this.emit("decoded", packet);
     }
   }
 } else {
   throw new Error("Unknown type: " + obj);
 }
};

/**
* Decode a packet String (JSON data)
*
* @param {string} str
* @return {object} packet
* @private
*/
// eslint-disable-next-line complexity
function decodeString(str) {
 let i = 0;
 // look up type
 const p = {
   type: Number(str.charAt(0)),
 };

 if (TYPES[p.type] == null) {
   return error("unknown packet type " + p.type);
 }

 // look up attachments if type binary
 if (BINARY_EVENT === p.type || BINARY_ACK === p.type) {
   let buf = "";
   while (str.charAt(++i) !== "-") {
     buf += str.charAt(i);
     if (i === str.length) {
       break;
     }
   }
   if (buf != Number(buf) || str.charAt(i) !== "-") {
     throw new Error("Illegal attachments");
   }
   p.attachments = Number(buf);
 }

 // look up namespace (if any)
 if (str.charAt(i + 1) === "/") {
   p.nsp = "";
   while (++i) {
     const c = str.charAt(i);
     if (c === ",") {
       break;
     }
     p.nsp += c;
     if (i === str.length) {
       break;
     }
   }
 } else {
   p.nsp = "/";
 }

 // look up id
 const next = str.charAt(i + 1);
 if (next !== "" && Number(next) == next) {
   p.id = "";
   while (++i) {
     const c = str.charAt(i);
     if (c == null || Number(c) != c) {
       --i;
       break;
     }
     p.id += str.charAt(i);
     if (i === str.length) {
       break;
     }
   }
   p.id = Number(p.id);
 }

 // look up json data
 if (str.charAt(++i)) {
   const payload = tryParse(str.substr(i));
   const isPayloadValid =
     payload !== false && (p.type === ERROR || Array.isArray(payload));
   if (isPayloadValid) {
     p.data = payload;
   } else {
     return error("invalid payload");
   }
 }

 return p;
}

function tryParse(str) {
 try {
   return JSON.parse(str);
 } catch (e) {
   return false;
 }
}

/**
* Deallocates a parser's resources
*
* @public
*/

Decoder.prototype.destroy = function () {
 if (this.reconstructor) {
   this.reconstructor.finishedReconstruction();
 }
};

function error(msg) {
 return {
   type: ERROR,
   data: "parser error: " + msg,
 };
}

module.exports = Decoder;