/*!
* parser.js - packet parser for bcoin
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
* https://github.com/bcoin-org/bcoin
*/
/* eslint nonblock-statement-body-position: "off" */
'use strict';
const assert = require('bsert');
const EventEmitter = require('events');
const {format} = require('util');
const Network = require('../protocol/network');
const hash256 = require('bcrypto/lib/hash256');
const common = require('./common');
const packets = require('./packets');
/**
* Protocol Message Parser
* @alias module:net.Parser
* @extends EventEmitter
* @emits Parser#error
* @emits Parser#packet
*/
class Parser extends EventEmitter {
/**
* Create a parser.
* @constructor
* @param {Network} network
*/
constructor(network) {
super();
this.network = Network.get(network);
this.pending = [];
this.total = 0;
this.waiting = 24;
this.header = null;
}
/**
* Emit an error.
* @private
* @param {...String} msg
*/
error() {
const msg = format.apply(null, arguments);
this.emit('error', new Error(msg));
}
/**
* Feed data to the parser.
* @param {Buffer} data
*/
feed(data) {
this.total += data.length;
this.pending.push(data);
while (this.total >= this.waiting) {
const chunk = Buffer.allocUnsafe(this.waiting);
let off = 0;
while (off < chunk.length) {
const len = this.pending[0].copy(chunk, off);
if (len === this.pending[0].length)
this.pending.shift();
else
this.pending[0] = this.pending[0].slice(len);
off += len;
}
assert.strictEqual(off, chunk.length);
this.total -= chunk.length;
this.parse(chunk);
}
}
/**
* Parse a fully-buffered chunk.
* @param {Buffer} chunk
*/
parse(data) {
assert(data.length <= common.MAX_MESSAGE);
if (!this.header) {
this.header = this.parseHeader(data);
return;
}
const hash = hash256.digest(data);
const checksum = hash.readUInt32LE(0, true);
if (checksum !== this.header.checksum) {
this.waiting = 24;
this.header = null;
this.error('Invalid checksum: %s.', checksum.toString(16));
return;
}
let payload;
try {
payload = this.parsePayload(this.header.cmd, data);
} catch (e) {
this.waiting = 24;
this.header = null;
this.emit('error', e);
return;
}
this.waiting = 24;
this.header = null;
this.emit('packet', payload);
}
/**
* Parse buffered packet header.
* @param {Buffer} data - Header.
* @returns {Header}
*/
parseHeader(data) {
const magic = data.readUInt32LE(0, true);
if (magic !== this.network.magic) {
this.error('Invalid magic value: %s.', magic.toString(16));
return null;
}
// Count length of the cmd.
let i = 0;
for (; data[i + 4] !== 0 && i < 12; i++);
if (i === 12) {
this.error('Non NULL-terminated command.');
return null;
}
const cmd = data.toString('ascii', 4, 4 + i);
const size = data.readUInt32LE(16, true);
if (size > common.MAX_MESSAGE) {
this.waiting = 24;
this.error('Packet length too large: %d.', size);
return null;
}
this.waiting = size;
const checksum = data.readUInt32LE(20, true);
return new Header(cmd, size, checksum);
}
/**
* Parse a payload.
* @param {String} cmd - Packet type.
* @param {Buffer} data - Payload.
* @returns {Object}
*/
parsePayload(cmd, data) {
return packets.fromRaw(cmd, data);
}
}
/**
* Packet Header
* @ignore
*/
class Header {
/**
* Create a header.
* @constructor
*/
constructor(cmd, size, checksum) {
this.cmd = cmd;
this.size = size;
this.checksum = checksum;
}
}
/*
* Expose
*/
module.exports = Parser;