setup-python/node_modules/bser/index.js

587 lines
15 KiB
JavaScript
Raw Normal View History

2019-06-27 08:12:00 +07:00
/* Copyright 2015-present Facebook, Inc.
* Licensed under the Apache License, Version 2.0 */
var EE = require('events').EventEmitter;
var util = require('util');
var os = require('os');
var assert = require('assert');
var Int64 = require('node-int64');
// BSER uses the local endianness to reduce byte swapping overheads
// (the protocol is expressly local IPC only). We need to tell node
// to use the native endianness when reading various native values.
var isBigEndian = os.endianness() == 'BE';
// Find the next power-of-2 >= size
function nextPow2(size) {
return Math.pow(2, Math.ceil(Math.log(size) / Math.LN2));
}
// Expandable buffer that we can provide a size hint for
function Accumulator(initsize) {
this.buf = Buffer.alloc(nextPow2(initsize || 8192));
this.readOffset = 0;
this.writeOffset = 0;
}
// For testing
exports.Accumulator = Accumulator
// How much we can write into this buffer without allocating
Accumulator.prototype.writeAvail = function() {
return this.buf.length - this.writeOffset;
}
// How much we can read
Accumulator.prototype.readAvail = function() {
return this.writeOffset - this.readOffset;
}
// Ensure that we have enough space for size bytes
Accumulator.prototype.reserve = function(size) {
if (size < this.writeAvail()) {
return;
}
// If we can make room by shunting down, do so
if (this.readOffset > 0) {
this.buf.copy(this.buf, 0, this.readOffset, this.writeOffset);
this.writeOffset -= this.readOffset;
this.readOffset = 0;
}
// If we made enough room, no need to allocate more
if (size < this.writeAvail()) {
return;
}
// Allocate a replacement and copy it in
var buf = Buffer.alloc(nextPow2(this.buf.length + size - this.writeAvail()));
this.buf.copy(buf);
this.buf = buf;
}
// Append buffer or string. Will resize as needed
Accumulator.prototype.append = function(buf) {
if (Buffer.isBuffer(buf)) {
this.reserve(buf.length);
buf.copy(this.buf, this.writeOffset, 0, buf.length);
this.writeOffset += buf.length;
} else {
var size = Buffer.byteLength(buf);
this.reserve(size);
this.buf.write(buf, this.writeOffset);
this.writeOffset += size;
}
}
Accumulator.prototype.assertReadableSize = function(size) {
if (this.readAvail() < size) {
throw new Error("wanted to read " + size +
" bytes but only have " + this.readAvail());
}
}
Accumulator.prototype.peekString = function(size) {
this.assertReadableSize(size);
return this.buf.toString('utf-8', this.readOffset, this.readOffset + size);
}
Accumulator.prototype.readString = function(size) {
var str = this.peekString(size);
this.readOffset += size;
return str;
}
Accumulator.prototype.peekInt = function(size) {
this.assertReadableSize(size);
switch (size) {
case 1:
return this.buf.readInt8(this.readOffset, size);
case 2:
return isBigEndian ?
this.buf.readInt16BE(this.readOffset, size) :
this.buf.readInt16LE(this.readOffset, size);
case 4:
return isBigEndian ?
this.buf.readInt32BE(this.readOffset, size) :
this.buf.readInt32LE(this.readOffset, size);
case 8:
var big = this.buf.slice(this.readOffset, this.readOffset + 8);
if (isBigEndian) {
// On a big endian system we can simply pass the buffer directly
return new Int64(big);
}
// Otherwise we need to byteswap
return new Int64(byteswap64(big));
default:
throw new Error("invalid integer size " + size);
}
}
Accumulator.prototype.readInt = function(bytes) {
var ival = this.peekInt(bytes);
if (ival instanceof Int64 && isFinite(ival.valueOf())) {
ival = ival.valueOf();
}
this.readOffset += bytes;
return ival;
}
Accumulator.prototype.peekDouble = function() {
this.assertReadableSize(8);
return isBigEndian ?
this.buf.readDoubleBE(this.readOffset) :
this.buf.readDoubleLE(this.readOffset);
}
Accumulator.prototype.readDouble = function() {
var dval = this.peekDouble();
this.readOffset += 8;
return dval;
}
Accumulator.prototype.readAdvance = function(size) {
if (size > 0) {
this.assertReadableSize(size);
} else if (size < 0 && this.readOffset + size < 0) {
throw new Error("advance with negative offset " + size +
" would seek off the start of the buffer");
}
this.readOffset += size;
}
Accumulator.prototype.writeByte = function(value) {
this.reserve(1);
this.buf.writeInt8(value, this.writeOffset);
++this.writeOffset;
}
Accumulator.prototype.writeInt = function(value, size) {
this.reserve(size);
switch (size) {
case 1:
this.buf.writeInt8(value, this.writeOffset);
break;
case 2:
if (isBigEndian) {
this.buf.writeInt16BE(value, this.writeOffset);
} else {
this.buf.writeInt16LE(value, this.writeOffset);
}
break;
case 4:
if (isBigEndian) {
this.buf.writeInt32BE(value, this.writeOffset);
} else {
this.buf.writeInt32LE(value, this.writeOffset);
}
break;
default:
throw new Error("unsupported integer size " + size);
}
this.writeOffset += size;
}
Accumulator.prototype.writeDouble = function(value) {
this.reserve(8);
if (isBigEndian) {
this.buf.writeDoubleBE(value, this.writeOffset);
} else {
this.buf.writeDoubleLE(value, this.writeOffset);
}
this.writeOffset += 8;
}
var BSER_ARRAY = 0x00;
var BSER_OBJECT = 0x01;
var BSER_STRING = 0x02;
var BSER_INT8 = 0x03;
var BSER_INT16 = 0x04;
var BSER_INT32 = 0x05;
var BSER_INT64 = 0x06;
var BSER_REAL = 0x07;
var BSER_TRUE = 0x08;
var BSER_FALSE = 0x09;
var BSER_NULL = 0x0a;
var BSER_TEMPLATE = 0x0b;
var BSER_SKIP = 0x0c;
var ST_NEED_PDU = 0; // Need to read and decode PDU length
var ST_FILL_PDU = 1; // Know the length, need to read whole content
var MAX_INT8 = 127;
var MAX_INT16 = 32767;
var MAX_INT32 = 2147483647;
function BunserBuf() {
EE.call(this);
this.buf = new Accumulator();
this.state = ST_NEED_PDU;
}
util.inherits(BunserBuf, EE);
exports.BunserBuf = BunserBuf;
BunserBuf.prototype.append = function(buf, synchronous) {
if (synchronous) {
this.buf.append(buf);
return this.process(synchronous);
}
try {
this.buf.append(buf);
} catch (err) {
this.emit('error', err);
return;
}
// Arrange to decode later. This allows the consuming
// application to make progress with other work in the
// case that we have a lot of subscription updates coming
// in from a large tree.
this.processLater();
}
BunserBuf.prototype.processLater = function() {
var self = this;
process.nextTick(function() {
try {
self.process(false);
} catch (err) {
self.emit('error', err);
}
});
}
// Do something with the buffer to advance our state.
// If we're running synchronously we'll return either
// the value we've decoded or undefined if we don't
// yet have enought data.
// If we're running asynchronously, we'll emit the value
// when it becomes ready and schedule another invocation
// of process on the next tick if we still have data we
// can process.
BunserBuf.prototype.process = function(synchronous) {
if (this.state == ST_NEED_PDU) {
if (this.buf.readAvail() < 2) {
return;
}
// Validate BSER header
this.expectCode(0);
this.expectCode(1);
this.pduLen = this.decodeInt(true /* relaxed */);
if (this.pduLen === false) {
// Need more data, walk backwards
this.buf.readAdvance(-2);
return;
}
// Ensure that we have a big enough buffer to read the rest of the PDU
this.buf.reserve(this.pduLen);
this.state = ST_FILL_PDU;
}
if (this.state == ST_FILL_PDU) {
if (this.buf.readAvail() < this.pduLen) {
// Need more data
return;
}
// We have enough to decode it
var val = this.decodeAny();
if (synchronous) {
return val;
}
this.emit('value', val);
this.state = ST_NEED_PDU;
}
if (!synchronous && this.buf.readAvail() > 0) {
this.processLater();
}
}
BunserBuf.prototype.raise = function(reason) {
throw new Error(reason + ", in Buffer of length " +
this.buf.buf.length + " (" + this.buf.readAvail() +
" readable) at offset " + this.buf.readOffset + " buffer: " +
JSON.stringify(this.buf.buf.slice(
this.buf.readOffset, this.buf.readOffset + 32).toJSON()));
}
BunserBuf.prototype.expectCode = function(expected) {
var code = this.buf.readInt(1);
if (code != expected) {
this.raise("expected bser opcode " + expected + " but got " + code);
}
}
BunserBuf.prototype.decodeAny = function() {
var code = this.buf.peekInt(1);
switch (code) {
case BSER_INT8:
case BSER_INT16:
case BSER_INT32:
case BSER_INT64:
return this.decodeInt();
case BSER_REAL:
this.buf.readAdvance(1);
return this.buf.readDouble();
case BSER_TRUE:
this.buf.readAdvance(1);
return true;
case BSER_FALSE:
this.buf.readAdvance(1);
return false;
case BSER_NULL:
this.buf.readAdvance(1);
return null;
case BSER_STRING:
return this.decodeString();
case BSER_ARRAY:
return this.decodeArray();
case BSER_OBJECT:
return this.decodeObject();
case BSER_TEMPLATE:
return this.decodeTemplate();
default:
this.raise("unhandled bser opcode " + code);
}
}
BunserBuf.prototype.decodeArray = function() {
this.expectCode(BSER_ARRAY);
var nitems = this.decodeInt();
var arr = [];
for (var i = 0; i < nitems; ++i) {
arr.push(this.decodeAny());
}
return arr;
}
BunserBuf.prototype.decodeObject = function() {
this.expectCode(BSER_OBJECT);
var nitems = this.decodeInt();
var res = {};
for (var i = 0; i < nitems; ++i) {
var key = this.decodeString();
var val = this.decodeAny();
res[key] = val;
}
return res;
}
BunserBuf.prototype.decodeTemplate = function() {
this.expectCode(BSER_TEMPLATE);
var keys = this.decodeArray();
var nitems = this.decodeInt();
var arr = [];
for (var i = 0; i < nitems; ++i) {
var obj = {};
for (var keyidx = 0; keyidx < keys.length; ++keyidx) {
if (this.buf.peekInt(1) == BSER_SKIP) {
this.buf.readAdvance(1);
continue;
}
var val = this.decodeAny();
obj[keys[keyidx]] = val;
}
arr.push(obj);
}
return arr;
}
BunserBuf.prototype.decodeString = function() {
this.expectCode(BSER_STRING);
var len = this.decodeInt();
return this.buf.readString(len);
}
// This is unusual compared to the other decode functions in that
// we may not have enough data available to satisfy the read, and
// we don't want to throw. This is only true when we're reading
// the PDU length from the PDU header; we'll set relaxSizeAsserts
// in that case.
BunserBuf.prototype.decodeInt = function(relaxSizeAsserts) {
if (relaxSizeAsserts && !this.buf.readAvail(1)) {
return false;
} else {
this.buf.assertReadableSize(1);
}
var code = this.buf.peekInt(1);
var size = 0;
switch (code) {
case BSER_INT8:
size = 1;
break;
case BSER_INT16:
size = 2;
break;
case BSER_INT32:
size = 4;
break;
case BSER_INT64:
size = 8;
break;
default:
this.raise("invalid bser int encoding " + code);
}
if (relaxSizeAsserts && !this.buf.readAvail(1 + size)) {
return false;
}
this.buf.readAdvance(1);
return this.buf.readInt(size);
}
// synchronously BSER decode a string and return the value
function loadFromBuffer(input) {
var buf = new BunserBuf();
var result = buf.append(input, true);
if (buf.buf.readAvail()) {
throw Error(
'excess data found after input buffer, use BunserBuf instead');
}
if (typeof result === 'undefined') {
throw Error(
'no bser found in string and no error raised!?');
}
return result;
}
exports.loadFromBuffer = loadFromBuffer
// Byteswap an arbitrary buffer, flipping from one endian
// to the other, returning a new buffer with the resultant data
function byteswap64(buf) {
var swap = Buffer.alloc(buf.length);
for (var i = 0; i < buf.length; i++) {
swap[i] = buf[buf.length -1 - i];
}
return swap;
}
function dump_int64(buf, val) {
// Get the raw bytes. The Int64 buffer is big endian
var be = val.toBuffer();
if (isBigEndian) {
// We're a big endian system, so the buffer is exactly how we
// want it to be
buf.writeByte(BSER_INT64);
buf.append(be);
return;
}
// We need to byte swap to get the correct representation
var le = byteswap64(be);
buf.writeByte(BSER_INT64);
buf.append(le);
}
function dump_int(buf, val) {
var abs = Math.abs(val);
if (abs <= MAX_INT8) {
buf.writeByte(BSER_INT8);
buf.writeInt(val, 1);
} else if (abs <= MAX_INT16) {
buf.writeByte(BSER_INT16);
buf.writeInt(val, 2);
} else if (abs <= MAX_INT32) {
buf.writeByte(BSER_INT32);
buf.writeInt(val, 4);
} else {
dump_int64(buf, new Int64(val));
}
}
function dump_any(buf, val) {
switch (typeof(val)) {
case 'number':
// check if it is an integer or a float
if (isFinite(val) && Math.floor(val) === val) {
dump_int(buf, val);
} else {
buf.writeByte(BSER_REAL);
buf.writeDouble(val);
}
return;
case 'string':
buf.writeByte(BSER_STRING);
dump_int(buf, Buffer.byteLength(val));
buf.append(val);
return;
case 'boolean':
buf.writeByte(val ? BSER_TRUE : BSER_FALSE);
return;
case 'object':
if (val === null) {
buf.writeByte(BSER_NULL);
return;
}
if (val instanceof Int64) {
dump_int64(buf, val);
return;
}
if (Array.isArray(val)) {
buf.writeByte(BSER_ARRAY);
dump_int(buf, val.length);
for (var i = 0; i < val.length; ++i) {
dump_any(buf, val[i]);
}
return;
}
buf.writeByte(BSER_OBJECT);
var keys = Object.keys(val);
// First pass to compute number of defined keys
var num_keys = keys.length;
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
var v = val[key];
if (typeof(v) == 'undefined') {
num_keys--;
}
}
dump_int(buf, num_keys);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
var v = val[key];
if (typeof(v) == 'undefined') {
// Don't include it
continue;
}
dump_any(buf, key);
try {
dump_any(buf, v);
} catch (e) {
throw new Error(
e.message + ' (while serializing object property with name `' +
key + "')");
}
}
return;
default:
throw new Error('cannot serialize type ' + typeof(val) + ' to BSER');
}
}
// BSER encode value and return a buffer of the contents
function dumpToBuffer(val) {
var buf = new Accumulator();
// Build out the header
buf.writeByte(0);
buf.writeByte(1);
// Reserve room for an int32 to hold our PDU length
buf.writeByte(BSER_INT32);
buf.writeInt(0, 4); // We'll come back and fill this in at the end
dump_any(buf, val);
// Compute PDU length
var off = buf.writeOffset;
var len = off - 7 /* the header length */;
buf.writeOffset = 3; // The length value to fill in
buf.writeInt(len, 4); // write the length in the space we reserved
buf.writeOffset = off;
return buf.buf.slice(0, off);
}
exports.dumpToBuffer = dumpToBuffer