JavaScript 65.5%
Python 17.8%
CSS 13%
HTML 3.7%
1/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */23'use strict';45const EventEmitter = require('events');6const http = require('http');7const { Duplex } = require('stream');8const { createHash } = require('crypto');910const extension = require('./extension');11const PerMessageDeflate = require('./permessage-deflate');12const subprotocol = require('./subprotocol');13const WebSocket = require('./websocket');14const { CLOSE_TIMEOUT, GUID, kWebSocket } = require('./constants');1516const keyRegex = /^[+/0-9A-Za-z]{22}==$/;1718const RUNNING = 0;19const CLOSING = 1;20const CLOSED = 2;2122/**23 * Class representing a WebSocket server.24 *25 * @extends EventEmitter26 */27class WebSocketServer extends EventEmitter {28 /**29 * Create a `WebSocketServer` instance.30 *31 * @param {Object} options Configuration options32 * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether33 * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted34 * multiple times in the same tick35 * @param {Boolean} [options.autoPong=true] Specifies whether or not to36 * automatically send a pong in response to a ping37 * @param {Number} [options.backlog=511] The maximum length of the queue of38 * pending connections39 * @param {Boolean} [options.clientTracking=true] Specifies whether or not to40 * track clients41 * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to42 * wait for the closing handshake to finish after `websocket.close()` is43 * called44 * @param {Function} [options.handleProtocols] A hook to handle protocols45 * @param {String} [options.host] The hostname where to bind the server46 * @param {Number} [options.maxBufferedChunks=262144] The maximum number of47 * buffered data chunks48 * @param {Number} [options.maxFragments=16384] The maximum number of message49 * fragments50 * @param {Number} [options.maxPayload=104857600] The maximum allowed message51 * size52 * @param {Boolean} [options.noServer=false] Enable no server mode53 * @param {String} [options.path] Accept only connections matching this path54 * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable55 * permessage-deflate56 * @param {Number} [options.port] The port where to bind the server57 * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S58 * server to use59 * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or60 * not to skip UTF-8 validation for text and close messages61 * @param {Function} [options.verifyClient] A hook to reject connections62 * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`63 * class to use. It must be the `WebSocket` class or class that extends it64 * @param {Function} [callback] A listener for the `listening` event65 */66 constructor(options, callback) {67 super();6869 options = {70 allowSynchronousEvents: true,71 autoPong: true,72 maxBufferedChunks: 256 * 1024,73 maxFragments: 16 * 1024,74 maxPayload: 100 * 1024 * 1024,75 skipUTF8Validation: false,76 perMessageDeflate: false,77 handleProtocols: null,78 clientTracking: true,79 closeTimeout: CLOSE_TIMEOUT,80 verifyClient: null,81 noServer: false,82 backlog: null, // use default (511 as implemented in net.js)83 server: null,84 host: null,85 path: null,86 port: null,87 WebSocket,88 ...options89 };9091 if (92 (options.port == null && !options.server && !options.noServer) ||93 (options.port != null && (options.server || options.noServer)) ||94 (options.server && options.noServer)95 ) {96 throw new TypeError(97 'One and only one of the "port", "server", or "noServer" options ' +98 'must be specified'99 );100 }101102 if (options.port != null) {103 this._server = http.createServer((req, res) => {104 const body = http.STATUS_CODES[426];105106 res.writeHead(426, {107 'Content-Length': body.length,108 'Content-Type': 'text/plain'109 });110 res.end(body);111 });112 this._server.listen(113 options.port,114 options.host,115 options.backlog,116 callback117 );118 } else if (options.server) {119 this._server = options.server;120 }121122 if (this._server) {123 const emitConnection = this.emit.bind(this, 'connection');124125 this._removeListeners = addListeners(this._server, {126 listening: this.emit.bind(this, 'listening'),127 error: this.emit.bind(this, 'error'),128 upgrade: (req, socket, head) => {129 this.handleUpgrade(req, socket, head, emitConnection);130 }131 });132 }133134 if (options.perMessageDeflate === true) options.perMessageDeflate = {};135 if (options.clientTracking) {136 this.clients = new Set();137 this._shouldEmitClose = false;138 }139140 this.options = options;141 this._state = RUNNING;142 }143144 /**145 * Returns the bound address, the address family name, and port of the server146 * as reported by the operating system if listening on an IP socket.147 * If the server is listening on a pipe or UNIX domain socket, the name is148 * returned as a string.149 *150 * @return {(Object|String|null)} The address of the server151 * @public152 */153 address() {154 if (this.options.noServer) {155 throw new Error('The server is operating in "noServer" mode');156 }157158 if (!this._server) return null;159 return this._server.address();160 }161162 /**163 * Stop the server from accepting new connections and emit the `'close'` event164 * when all existing connections are closed.165 *166 * @param {Function} [cb] A one-time listener for the `'close'` event167 * @public168 */169 close(cb) {170 if (this._state === CLOSED) {171 if (cb) {172 this.once('close', () => {173 cb(new Error('The server is not running'));174 });175 }176177 process.nextTick(emitClose, this);178 return;179 }180181 if (cb) this.once('close', cb);182183 if (this._state === CLOSING) return;184 this._state = CLOSING;185186 if (this.options.noServer || this.options.server) {187 if (this._server) {188 this._removeListeners();189 this._removeListeners = this._server = null;190 }191192 if (this.clients) {193 if (!this.clients.size) {194 process.nextTick(emitClose, this);195 } else {196 this._shouldEmitClose = true;197 }198 } else {199 process.nextTick(emitClose, this);200 }201 } else {202 const server = this._server;203204 this._removeListeners();205 this._removeListeners = this._server = null;206207 //208 // The HTTP/S server was created internally. Close it, and rely on its209 // `'close'` event.210 //211 server.close(() => {212 emitClose(this);213 });214 }215 }216217 /**218 * See if a given request should be handled by this server instance.219 *220 * @param {http.IncomingMessage} req Request object to inspect221 * @return {Boolean} `true` if the request is valid, else `false`222 * @public223 */224 shouldHandle(req) {225 if (this.options.path) {226 const index = req.url.indexOf('?');227 const pathname = index !== -1 ? req.url.slice(0, index) : req.url;228229 if (pathname !== this.options.path) return false;230 }231232 return true;233 }234235 /**236 * Handle a HTTP Upgrade request.237 *238 * @param {http.IncomingMessage} req The request object239 * @param {Duplex} socket The network socket between the server and client240 * @param {Buffer} head The first packet of the upgraded stream241 * @param {Function} cb Callback242 * @public243 */244 handleUpgrade(req, socket, head, cb) {245 socket.on('error', socketOnError);246247 const key = req.headers['sec-websocket-key'];248 const upgrade = req.headers.upgrade;249 const version = +req.headers['sec-websocket-version'];250251 if (req.method !== 'GET') {252 const message = 'Invalid HTTP method';253 abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);254 return;255 }256257 if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {258 const message = 'Invalid Upgrade header';259 abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);260 return;261 }262263 if (key === undefined || !keyRegex.test(key)) {264 const message = 'Missing or invalid Sec-WebSocket-Key header';265 abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);266 return;267 }268269 if (version !== 13 && version !== 8) {270 const message = 'Missing or invalid Sec-WebSocket-Version header';271 abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {272 'Sec-WebSocket-Version': '13, 8'273 });274 return;275 }276277 if (!this.shouldHandle(req)) {278 abortHandshake(socket, 400);279 return;280 }281282 const secWebSocketProtocol = req.headers['sec-websocket-protocol'];283 let protocols = new Set();284285 if (secWebSocketProtocol !== undefined) {286 try {287 protocols = subprotocol.parse(secWebSocketProtocol);288 } catch (err) {289 const message = 'Invalid Sec-WebSocket-Protocol header';290 abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);291 return;292 }293 }294295 const secWebSocketExtensions = req.headers['sec-websocket-extensions'];296 const extensions = {};297298 if (299 this.options.perMessageDeflate &&300 secWebSocketExtensions !== undefined301 ) {302 const perMessageDeflate = new PerMessageDeflate({303 ...this.options.perMessageDeflate,304 isServer: true,305 maxPayload: this.options.maxPayload306 });307308 try {309 const offers = extension.parse(secWebSocketExtensions);310311 if (offers[PerMessageDeflate.extensionName]) {312 perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);313 extensions[PerMessageDeflate.extensionName] = perMessageDeflate;314 }315 } catch (err) {316 const message =317 'Invalid or unacceptable Sec-WebSocket-Extensions header';318 abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);319 return;320 }321 }322323 //324 // Optionally call external client verification handler.325 //326 if (this.options.verifyClient) {327 const info = {328 origin:329 req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],330 secure: !!(req.socket.authorized || req.socket.encrypted),331 req332 };333334 if (this.options.verifyClient.length === 2) {335 this.options.verifyClient(info, (verified, code, message, headers) => {336 if (!verified) {337 return abortHandshake(socket, code || 401, message, headers);338 }339340 this.completeUpgrade(341 extensions,342 key,343 protocols,344 req,345 socket,346 head,347 cb348 );349 });350 return;351 }352353 if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);354 }355356 this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);357 }358359 /**360 * Upgrade the connection to WebSocket.361 *362 * @param {Object} extensions The accepted extensions363 * @param {String} key The value of the `Sec-WebSocket-Key` header364 * @param {Set} protocols The subprotocols365 * @param {http.IncomingMessage} req The request object366 * @param {Duplex} socket The network socket between the server and client367 * @param {Buffer} head The first packet of the upgraded stream368 * @param {Function} cb Callback369 * @throws {Error} If called more than once with the same socket370 * @private371 */372 completeUpgrade(extensions, key, protocols, req, socket, head, cb) {373 //374 // Destroy the socket if the client has already sent a FIN packet.375 //376 if (!socket.readable || !socket.writable) return socket.destroy();377378 if (socket[kWebSocket]) {379 throw new Error(380 'server.handleUpgrade() was called more than once with the same ' +381 'socket, possibly due to a misconfiguration'382 );383 }384385 if (this._state > RUNNING) return abortHandshake(socket, 503);386387 const digest = createHash('sha1')388 .update(key + GUID)389 .digest('base64');390391 const headers = [392 'HTTP/1.1 101 Switching Protocols',393 'Upgrade: websocket',394 'Connection: Upgrade',395 `Sec-WebSocket-Accept: ${digest}`396 ];397398 const ws = new this.options.WebSocket(null, undefined, this.options);399400 if (protocols.size) {401 //402 // Optionally call external protocol selection handler.403 //404 const protocol = this.options.handleProtocols405 ? this.options.handleProtocols(protocols, req)406 : protocols.values().next().value;407408 if (protocol) {409 headers.push(`Sec-WebSocket-Protocol: ${protocol}`);410 ws._protocol = protocol;411 }412 }413414 if (extensions[PerMessageDeflate.extensionName]) {415 const params = extensions[PerMessageDeflate.extensionName].params;416 const value = extension.format({417 [PerMessageDeflate.extensionName]: [params]418 });419 headers.push(`Sec-WebSocket-Extensions: ${value}`);420 ws._extensions = extensions;421 }422423 //424 // Allow external modification/inspection of handshake headers.425 //426 this.emit('headers', headers, req);427428 socket.write(headers.concat('\r\n').join('\r\n'));429 socket.removeListener('error', socketOnError);430431 ws.setSocket(socket, head, {432 allowSynchronousEvents: this.options.allowSynchronousEvents,433 maxBufferedChunks: this.options.maxBufferedChunks,434 maxFragments: this.options.maxFragments,435 maxPayload: this.options.maxPayload,436 skipUTF8Validation: this.options.skipUTF8Validation437 });438439 if (this.clients) {440 this.clients.add(ws);441 ws.on('close', () => {442 this.clients.delete(ws);443444 if (this._shouldEmitClose && !this.clients.size) {445 process.nextTick(emitClose, this);446 }447 });448 }449450 cb(ws, req);451 }452}453454module.exports = WebSocketServer;455456/**457 * Add event listeners on an `EventEmitter` using a map of <event, listener>458 * pairs.459 *460 * @param {EventEmitter} server The event emitter461 * @param {Object.<String, Function>} map The listeners to add462 * @return {Function} A function that will remove the added listeners when463 * called464 * @private465 */466function addListeners(server, map) {467 for (const event of Object.keys(map)) server.on(event, map[event]);468469 return function removeListeners() {470 for (const event of Object.keys(map)) {471 server.removeListener(event, map[event]);472 }473 };474}475476/**477 * Emit a `'close'` event on an `EventEmitter`.478 *479 * @param {EventEmitter} server The event emitter480 * @private481 */482function emitClose(server) {483 server._state = CLOSED;484 server.emit('close');485}486487/**488 * Handle socket errors.489 *490 * @private491 */492function socketOnError() {493 this.destroy();494}495496/**497 * Close the connection when preconditions are not fulfilled.498 *499 * @param {Duplex} socket The socket of the upgrade request500 * @param {Number} code The HTTP response status code501 * @param {String} [message] The HTTP response body502 * @param {Object} [headers] Additional HTTP response headers503 * @private504 */505function abortHandshake(socket, code, message, headers) {506 //507 // The socket is writable unless the user destroyed or ended it before calling508 // `server.handleUpgrade()` or in the `verifyClient` function, which is a user509 // error. Handling this does not make much sense as the worst that can happen510 // is that some of the data written by the user might be discarded due to the511 // call to `socket.end()` below, which triggers an `'error'` event that in512 // turn causes the socket to be destroyed.513 //514 message = message || http.STATUS_CODES[code];515 headers = {516 Connection: 'close',517 'Content-Type': 'text/html',518 'Content-Length': Buffer.byteLength(message),519 ...headers520 };521522 socket.once('finish', socket.destroy);523524 socket.end(525 `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +526 Object.keys(headers)527 .map((h) => `${h}: ${headers[h]}`)528 .join('\r\n') +529 '\r\n\r\n' +530 message531 );532}533534/**535 * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least536 * one listener for it, otherwise call `abortHandshake()`.537 *538 * @param {WebSocketServer} server The WebSocket server539 * @param {http.IncomingMessage} req The request object540 * @param {Duplex} socket The socket of the upgrade request541 * @param {Number} code The HTTP response status code542 * @param {String} message The HTTP response body543 * @param {Object} [headers] The HTTP response headers544 * @private545 */546function abortHandshakeOrEmitwsClientError(547 server,548 req,549 socket,550 code,551 message,552 headers553) {554 if (server.listenerCount('wsClientError')) {555 const err = new Error(message);556 Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);557558 server.emit('wsClientError', err, socket, req);559 } else {560 abortHandshake(socket, code, message, headers);561 }562}563