| 'use strict'; |
| |
| const { randomBytes } = require('crypto'); |
| |
| const PerMessageDeflate = require('./permessage-deflate'); |
| const { EMPTY_BUFFER } = require('./constants'); |
| const { isValidStatusCode } = require('./validation'); |
| const { mask: applyMask, toBuffer } = require('./buffer-util'); |
| |
| /** |
| * HyBi Sender implementation. |
| */ |
| class Sender { |
| /** |
| * Creates a Sender instance. |
| * |
| * @param {net.Socket} socket The connection socket |
| * @param {Object} extensions An object containing the negotiated extensions |
| */ |
| constructor(socket, extensions) { |
| this._extensions = extensions || {}; |
| this._socket = socket; |
| |
| this._firstFragment = true; |
| this._compress = false; |
| |
| this._bufferedBytes = 0; |
| this._deflating = false; |
| this._queue = []; |
| } |
| |
| /** |
| * Frames a piece of data according to the HyBi WebSocket protocol. |
| * |
| * @param {Buffer} data The data to frame |
| * @param {Object} options Options object |
| * @param {Number} options.opcode The opcode |
| * @param {Boolean} options.readOnly Specifies whether `data` can be modified |
| * @param {Boolean} options.fin Specifies whether or not to set the FIN bit |
| * @param {Boolean} options.mask Specifies whether or not to mask `data` |
| * @param {Boolean} options.rsv1 Specifies whether or not to set the RSV1 bit |
| * @return {Buffer[]} The framed data as a list of `Buffer` instances |
| * @public |
| */ |
| static frame(data, options) { |
| const merge = options.mask && options.readOnly; |
| var offset = options.mask ? 6 : 2; |
| var payloadLength = data.length; |
| |
| if (data.length >= 65536) { |
| offset += 8; |
| payloadLength = 127; |
| } else if (data.length > 125) { |
| offset += 2; |
| payloadLength = 126; |
| } |
| |
| const target = Buffer.allocUnsafe(merge ? data.length + offset : offset); |
| |
| target[0] = options.fin ? options.opcode | 0x80 : options.opcode; |
| if (options.rsv1) target[0] |= 0x40; |
| |
| target[1] = payloadLength; |
| |
| if (payloadLength === 126) { |
| target.writeUInt16BE(data.length, 2); |
| } else if (payloadLength === 127) { |
| target.writeUInt32BE(0, 2); |
| target.writeUInt32BE(data.length, 6); |
| } |
| |
| if (!options.mask) return [target, data]; |
| |
| const mask = randomBytes(4); |
| |
| target[1] |= 0x80; |
| target[offset - 4] = mask[0]; |
| target[offset - 3] = mask[1]; |
| target[offset - 2] = mask[2]; |
| target[offset - 1] = mask[3]; |
| |
| if (merge) { |
| applyMask(data, mask, target, offset, data.length); |
| return [target]; |
| } |
| |
| applyMask(data, mask, data, 0, data.length); |
| return [target, data]; |
| } |
| |
| /** |
| * Sends a close message to the other peer. |
| * |
| * @param {(Number|undefined)} code The status code component of the body |
| * @param {String} data The message component of the body |
| * @param {Boolean} mask Specifies whether or not to mask the message |
| * @param {Function} cb Callback |
| * @public |
| */ |
| close(code, data, mask, cb) { |
| var buf; |
| |
| if (code === undefined) { |
| buf = EMPTY_BUFFER; |
| } else if (typeof code !== 'number' || !isValidStatusCode(code)) { |
| throw new TypeError('First argument must be a valid error code number'); |
| } else if (data === undefined || data === '') { |
| buf = Buffer.allocUnsafe(2); |
| buf.writeUInt16BE(code, 0); |
| } else { |
| buf = Buffer.allocUnsafe(2 + Buffer.byteLength(data)); |
| buf.writeUInt16BE(code, 0); |
| buf.write(data, 2); |
| } |
| |
| if (this._deflating) { |
| this.enqueue([this.doClose, buf, mask, cb]); |
| } else { |
| this.doClose(buf, mask, cb); |
| } |
| } |
| |
| /** |
| * Frames and sends a close message. |
| * |
| * @param {Buffer} data The message to send |
| * @param {Boolean} mask Specifies whether or not to mask `data` |
| * @param {Function} cb Callback |
| * @private |
| */ |
| doClose(data, mask, cb) { |
| this.sendFrame( |
| Sender.frame(data, { |
| fin: true, |
| rsv1: false, |
| opcode: 0x08, |
| mask, |
| readOnly: false |
| }), |
| cb |
| ); |
| } |
| |
| /** |
| * Sends a ping message to the other peer. |
| * |
| * @param {*} data The message to send |
| * @param {Boolean} mask Specifies whether or not to mask `data` |
| * @param {Function} cb Callback |
| * @public |
| */ |
| ping(data, mask, cb) { |
| const buf = toBuffer(data); |
| |
| if (this._deflating) { |
| this.enqueue([this.doPing, buf, mask, toBuffer.readOnly, cb]); |
| } else { |
| this.doPing(buf, mask, toBuffer.readOnly, cb); |
| } |
| } |
| |
| /** |
| * Frames and sends a ping message. |
| * |
| * @param {*} data The message to send |
| * @param {Boolean} mask Specifies whether or not to mask `data` |
| * @param {Boolean} readOnly Specifies whether `data` can be modified |
| * @param {Function} cb Callback |
| * @private |
| */ |
| doPing(data, mask, readOnly, cb) { |
| this.sendFrame( |
| Sender.frame(data, { |
| fin: true, |
| rsv1: false, |
| opcode: 0x09, |
| mask, |
| readOnly |
| }), |
| cb |
| ); |
| } |
| |
| /** |
| * Sends a pong message to the other peer. |
| * |
| * @param {*} data The message to send |
| * @param {Boolean} mask Specifies whether or not to mask `data` |
| * @param {Function} cb Callback |
| * @public |
| */ |
| pong(data, mask, cb) { |
| const buf = toBuffer(data); |
| |
| if (this._deflating) { |
| this.enqueue([this.doPong, buf, mask, toBuffer.readOnly, cb]); |
| } else { |
| this.doPong(buf, mask, toBuffer.readOnly, cb); |
| } |
| } |
| |
| /** |
| * Frames and sends a pong message. |
| * |
| * @param {*} data The message to send |
| * @param {Boolean} mask Specifies whether or not to mask `data` |
| * @param {Boolean} readOnly Specifies whether `data` can be modified |
| * @param {Function} cb Callback |
| * @private |
| */ |
| doPong(data, mask, readOnly, cb) { |
| this.sendFrame( |
| Sender.frame(data, { |
| fin: true, |
| rsv1: false, |
| opcode: 0x0a, |
| mask, |
| readOnly |
| }), |
| cb |
| ); |
| } |
| |
| /** |
| * Sends a data message to the other peer. |
| * |
| * @param {*} data The message to send |
| * @param {Object} options Options object |
| * @param {Boolean} options.compress Specifies whether or not to compress `data` |
| * @param {Boolean} options.binary Specifies whether `data` is binary or text |
| * @param {Boolean} options.fin Specifies whether the fragment is the last one |
| * @param {Boolean} options.mask Specifies whether or not to mask `data` |
| * @param {Function} cb Callback |
| * @public |
| */ |
| send(data, options, cb) { |
| const buf = toBuffer(data); |
| const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; |
| var opcode = options.binary ? 2 : 1; |
| var rsv1 = options.compress; |
| |
| if (this._firstFragment) { |
| this._firstFragment = false; |
| if (rsv1 && perMessageDeflate) { |
| rsv1 = buf.length >= perMessageDeflate._threshold; |
| } |
| this._compress = rsv1; |
| } else { |
| rsv1 = false; |
| opcode = 0; |
| } |
| |
| if (options.fin) this._firstFragment = true; |
| |
| if (perMessageDeflate) { |
| const opts = { |
| fin: options.fin, |
| rsv1, |
| opcode, |
| mask: options.mask, |
| readOnly: toBuffer.readOnly |
| }; |
| |
| if (this._deflating) { |
| this.enqueue([this.dispatch, buf, this._compress, opts, cb]); |
| } else { |
| this.dispatch(buf, this._compress, opts, cb); |
| } |
| } else { |
| this.sendFrame( |
| Sender.frame(buf, { |
| fin: options.fin, |
| rsv1: false, |
| opcode, |
| mask: options.mask, |
| readOnly: toBuffer.readOnly |
| }), |
| cb |
| ); |
| } |
| } |
| |
| /** |
| * Dispatches a data message. |
| * |
| * @param {Buffer} data The message to send |
| * @param {Boolean} compress Specifies whether or not to compress `data` |
| * @param {Object} options Options object |
| * @param {Number} options.opcode The opcode |
| * @param {Boolean} options.readOnly Specifies whether `data` can be modified |
| * @param {Boolean} options.fin Specifies whether or not to set the FIN bit |
| * @param {Boolean} options.mask Specifies whether or not to mask `data` |
| * @param {Boolean} options.rsv1 Specifies whether or not to set the RSV1 bit |
| * @param {Function} cb Callback |
| * @private |
| */ |
| dispatch(data, compress, options, cb) { |
| if (!compress) { |
| this.sendFrame(Sender.frame(data, options), cb); |
| return; |
| } |
| |
| const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; |
| |
| this._deflating = true; |
| perMessageDeflate.compress(data, options.fin, (_, buf) => { |
| this._deflating = false; |
| options.readOnly = false; |
| this.sendFrame(Sender.frame(buf, options), cb); |
| this.dequeue(); |
| }); |
| } |
| |
| /** |
| * Executes queued send operations. |
| * |
| * @private |
| */ |
| dequeue() { |
| while (!this._deflating && this._queue.length) { |
| const params = this._queue.shift(); |
| |
| this._bufferedBytes -= params[1].length; |
| params[0].apply(this, params.slice(1)); |
| } |
| } |
| |
| /** |
| * Enqueues a send operation. |
| * |
| * @param {Array} params Send operation parameters. |
| * @private |
| */ |
| enqueue(params) { |
| this._bufferedBytes += params[1].length; |
| this._queue.push(params); |
| } |
| |
| /** |
| * Sends a frame. |
| * |
| * @param {Buffer[]} list The frame to send |
| * @param {Function} cb Callback |
| * @private |
| */ |
| sendFrame(list, cb) { |
| if (list.length === 2) { |
| this._socket.cork(); |
| this._socket.write(list[0]); |
| this._socket.write(list[1], cb); |
| this._socket.uncork(); |
| } else { |
| this._socket.write(list[0], cb); |
| } |
| } |
| } |
| |
| module.exports = Sender; |