FM / socket.io-parser

/var/www/myprog.com.ua/server/node/node_modules/socket.io-parser/

/var/www/myprog.com.ua/server/node/node_modules/socket.io-parser

Name	Size	Mode	Actions
bench/	-	0755	rm
node_modules/	-	0755	rm
.npmignore	36	0644	edit dl rm
.travis.yml	471	0644	edit dl rm
.zuul.yml	298	0644	edit dl rm
binary.js	4203	0644	edit dl rm
History.md	1468	0644	edit dl rm
index.js	7481	0644	edit dl rm
Makefile	165	0644	edit dl rm
package.json	520	0644	edit dl rm
Readme.md	2090	0644	edit dl rm

Edit: /var/www/myprog.com.ua/server/node/node_modules/socket.io-parser/binary.js (4203B)

/**
 * Modle requirements
 */

var isArray = require('isarray');

/**
 * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.
 * Anything with blobs or files should be fed through removeBlobs before coming
 * here.
 *
 * @param {Object} packet - socket.io event packet
 * @return {Object} with deconstructed packet and list of buffers
 * @api public
 */

exports.deconstructPacket = function(packet) {
    var buffers = [];
    var packetData = packet.data;

function _deconstructPacket(data) {
      if (!data) return data;

if ((global.Buffer && Buffer.isBuffer(data)) ||
        (global.ArrayBuffer && data instanceof ArrayBuffer)) { // replace binary
        var placeholder = {_placeholder: true, num: buffers.length};
        buffers.push(data);
        return placeholder;
      } else if (isArray(data)) {
        var newData = new Array(data.length);
        for (var i = 0; i < data.length; i++) {
          newData[i] = _deconstructPacket(data[i]);
        }
        return newData;
      } else if ('object' == typeof data && !(data instanceof Date)) {
        var newData = {};
        for (var key in data) {
          newData[key] = _deconstructPacket(data[key]);
        }
        return newData;
      }
      return data;
    }

var pack = packet;
    pack.data = _deconstructPacket(packetData);
    pack.attachments = buffers.length; // number of binary 'attachments'
    return {packet: pack, buffers: buffers};
}

/**
 * Reconstructs a binary packet from its placeholder packet and buffers
 *
 * @param {Object} packet - event packet with placeholders
 * @param {Array} buffers - binary buffers to put in placeholder positions
 * @return {Object} reconstructed packet
 * @api public
 */

exports.reconstructPacket = function(packet, buffers) {
    var curPlaceHolder = 0;

packet.data = _reconstructPacket(packet.data);
    packet.attachments = undefined; // no longer useful
    return packet;
 }

/**
 * Asynchronously removes Blobs or Files from data via
 * FileReader's readAsArrayBuffer method. Used before encoding
 * data as msgpack. Calls callback with the blobless data.
 *
 * @param {Object} data
 * @param {Function} callback
 * @api private
 */

exports.removeBlobs = function(data, callback) {

function _removeBlobs(obj, curKey, containingObject) {
    if (!obj) return obj;

// convert any blob
    if ((global.Blob && obj instanceof Blob) ||
        (global.File && obj instanceof File)) {
      pendingBlobs++;

// async filereader
      var fileReader = new FileReader();
      fileReader.onload = function() { // this.result == arraybuffer
        if (containingObject) {
          containingObject[curKey] = this.result;
        }
        else {
          bloblessData = this.result;
        }

// if nothing pending its callback time
        if(! --pendingBlobs) {
          callback(bloblessData);
        }
      };

fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer
    } else if (isArray(obj)) { // handle array
      for (var i = 0; i < obj.length; i++) {
        _removeBlobs(obj[i], i, obj);
      }
    } else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object
      for (var key in obj) {
        _removeBlobs(obj[key], key, obj);
      }
    }
  }

var pendingBlobs = 0;
  var bloblessData = data;
  _removeBlobs(bloblessData);
  if (!pendingBlobs) {
    callback(bloblessData);
  }
}

/**
 * Returns true if obj is a buffer or an arraybuffer.
 *
 * @api private
 */
function isBuf(obj) {
  return (global.Buffer && Buffer.isBuffer(obj)) ||
         (global.ArrayBuffer && obj instanceof ArrayBuffer);
}

cmd: