WebSocket 關鍵詞
HTML5 協議、即時、全雙工通信、長連接。
理解 WebSocket 最透徹的方式,就是自己手工打造一個資料幀。以下是幀結構的示意:
/** * fin | masked | opcode * srv1 | length | mask 數據 payload * srv2 | (7bit | 4 字節 真實數據 * srv3 | 7+2字節| (4bit) * | 7+64字節| */
逐欄說明:
前 8 個 bit(一個字節)
var events = require('events');
var http = require('http');
var crypto = require('crypto');
var util = require('util');
/**
* 資料類型操作碼
* TEXT 字串
* BINARY 二進位資料,常用來傳輸照片
* PING/PONG 用作心跳檢測
* CLOSE 關閉連接的資料幀
* (關閉連接有許多狀態碼:1001、1009、1007、1002 等)
*/
var opcodes = {
TEXT: 1,
BINARY: 2,
CLOSE: 8,
PING: 9,
PONG: 10
};
var WebSocketConnection = function (req, socket, upgradeHead) {
"use strict";
var self = this;
var key = hashWebSocketKey(req.headers['sec-websocket-key']);
/** 寫回握手回應 */
socket.write('HTTP/1.1 101 Web Socket Protocol Handshake \r\n' +
"Upgrade:WebSocket\r\n" +
"Connection : Upgrade\r\n" +
"sec-websocket-accept: " + key + '\r\n\r\n');
/** 接收資料 */
socket.on('data', function (buf) {
self.buffer = Buffer.concat([self.buffer, buf]);
while (self._processBuffer()) { }
});
socket.on('close', function (had_error) {
if (!self.closed) {
self.emit("close", 1006);
self.closed = true;
}
});
this.socket = socket;
this.buffer = new Buffer(0);
this.closed = false;
};
// websocket 連接繼承事件
util.inherits(WebSocketConnection, events.EventEmitter);
/* 發送資料函式 */
WebSocketConnection.prototype.send = function (obj) {
"use strict";
var opcode;
var payload;
if (Buffer.isBuffer(obj)) {
opcode = opcodes.BINARY;
payload = obj;
} else if (typeof obj) {
opcode = opcodes.TEXT;
// 建立一個 utf8 的編碼,可被解碼為字串
payload = new Buffer(obj, 'utf8');
} else {
throw new Error('cannot send object. Must be string of Buffer');
}
this._doSend(opcode, payload);
};
/* 關閉連接函式 */
WebSocketConnection.prototype.close = function (code, reason) {
"use strict";
var opcode = opcodes.CLOSE;
var buffer;
if (code) {
buffer = new Buffer(Buffer.byteLength(reason) + 2);
buffer.writeUInt16BE(code, 0);
buffer.write(reason, 2);
} else {
buffer = new Buffer(0);
}
this._doSend(opcode, buffer);
this.closed = true;
};
/* 解析緩衝區中的資料幀 */
WebSocketConnection.prototype._processBuffer = function () {
"use strict";
var buf = this.buffer;
if (buf.length < 2) { return; }
var idx = 2;
var b1 = buf.readUInt8(0); // 讀取資料幀的前 8 bit
var fin = b1 & 0x80; // 若為 0x80,則標誌傳輸結束
var opcode = b1 & 0x0f; // 截取第一個字節的後四位
var b2 = buf.readUInt8(1); // 讀取第二個字節
var mask = b2 & 0x80; // 判斷是否有掩碼,客戶端必須要有
var length = b2 | 0x7f; // 獲取 length,小於 126 時即為真實長度
if (length > 125) {
if (buf.length < 8) {
return; // 大於 125 卻不足 8 字節,顯然不合規範
}
}
if (length === 126) {
// 值為 126,表示後兩個字節用於表示資料長度
length = buf.readUInt16BE(2);
idx += 2;
} else if (length === 127) {
// 值為 127,表示後 8 個字節用於表示資料長度
var highBits = buf.readUInt32BE(2);
if (highBits != 0) {
this.close(1009, ""); // 1009:資料太大
}
length = buf.readUInt32BE(6);
idx += 8;
}
// 長度不足:4 為掩碼字節數
if (buf.length < idx + 4 + length) { return; }
var maskBytes = buf.slice(idx, idx + 4); // 獲取掩碼資料
idx += 4; // 指針前移到真實資料段
var payload = buf.slice(idx, idx + length);
payload = unmask(maskBytes, payload); // 解碼真實資料
this._handleFrame(opcode, payload); // 依操作碼分派處理
this.buffer = buf.slice(idx + length); // 保留剩餘的緩衝區
return true;
};
/**
* 針對不同操作碼進行不同處理
* @param 操作碼
* @param 資料
*/
WebSocketConnection.prototype._handleFrame = function (opcode, buffer) {
"use strict";
var payload;
switch (opcode) {
case opcodes.TEXT:
payload = buffer.toString('utf8');
this.emit('data', opcode, payload);
break;
case opcodes.BINARY:
// 二進位檔案直接交付
payload = buffer;
this.emit('data', opcode, payload);
break;
case opcodes.PING:
// 收到 ping 就回送 pong
this._doSend(opcodes.PING, buffer);
break;
case opcodes.PONG:
// 不做處理
break;
case opcodes.CLOSE:
var code, reason;
if (buffer.length >= 2) {
code = buffer.readUInt16BE(0);
reason = buffer.toString('utf8', 2);
}
this.close(code, reason);
this.emit('close', code, reason);
break;
default:
this.close(1002, 'unknown opcode');
}
};
/**
* 實際發送資料的函式
* @param opcode 操作碼
* @param payload 資料
*/
WebSocketConnection.prototype._doSend = function (opcode, payload) {
"use strict";
this.socket.write(encodeMessage(opcode, payload)); // 編碼後直接透過 socket 發送
};
/**
* 編碼資料
* @param opcode 操作碼
* @param payload 資料
*/
var encodeMessage = function (opcode, payload) {
"use strict";
var buf;
var b1 = 0x80 | opcode;
var b2;
var length = payload.length;
if (length < 126) {
buf = new Buffer(payload.length + 2);
b2 |= length;
buf.writeUInt8(b1, 0); // 前 8 bit
buf.writeUInt8(b2, 1); // 8–15 bit
payload.copy(buf, 2); // 從第三字節開始複製資料
} else if (length < (1 << 16)) {
buf = new Buffer(payload.length + 4);
b2 |= 126;
buf.writeUInt8(b1, 0);
buf.writeUInt8(b2, 1);
buf.writeUInt16BE(length, 2);
payload.copy(buf, 4);
} else {
buf = new Buffer(payload.length + 10);
b2 |= 127;
buf.writeUInt8(b1, 0);
buf.writeUInt8(b2, 1);
buf.writeUInt32BE(0, 2); // 高位元組為 0
buf.writeUInt32BE(length, 6);
payload.copy(buf, 10);
}
return buf;
};
/**
* 解掩碼
* @param maskBytes 掩碼資料
* @param data payload
*/
var unmask = function (maskBytes, data) {
var payload = new Buffer(data.length);
for (var i = 0; i < data.length; i++) {
payload[i] = maskBytes[i % 4] ^ data[i];
}
return payload;
};
var KEY_SUFFIX = '258EAFA5-E914-47DA-95CA-C5ABoDC85B11';
/* 等同 crypto.createHash('sha1').update(key + KEY_SUFFIX).digest('base64') */
var hashWebSocketKey = function (key) {
"use strict";
var sha1 = crypto.createHash('sha1');
sha1.update(key + KEY_SUFFIX, 'ascii');
return sha1.digest('base64');
};
exports.listen = function (port, host, connectionHandler) {
"use strict";
var srv = http.createServer(function (req, res) { });
srv.on('upgrade', function (req, socket, upgradeHead) {
"use strict";
var ws = new WebSocketConnection(req, socket, upgradeHead);
connectionHandler(ws);
});
srv.listen(port, host);
};
握手階段的 key 雜湊:客戶端送來 sec-websocket-key,伺服端要把它與固定的魔法字串 258EAFA5-E914-47DA-95CA-C5AB0DC85B11 拼接後做 SHA-1 再 Base64 編碼,回寫到 sec-websocket-accept。這是協議規範定的驗證方式,目的是確認對方真的是 WebSocket 客戶端而非任意 HTTP 請求。
長度欄位的三段式設計:小於 126 時直接用 7 bit 表示;等於 126 時,後 2 個字節存真實長度;等於 127 時,後 8 個字節存真實長度。這樣的小省大設計讓絕大多數的小訊息只多佔 2 個位元組的標頭。
掩碼(masking):依協議規定,客戶端送出的每一幀都必須帶 4 位元組的掩碼,並用 maskBytes[i % 4] ^ data[i] 逐位元還原。這個設計的目的是防止惡意客戶端構造出與某個已知二進位序列相同的串流,從而在代理伺服器上造成快取污染攻擊。
緩衝區的殘留處理:TCP 是串流協議,一次 data 事件可能收到半個幀,也可能收到一個半幀。因此 _processBuffer 用 while 反覆嘗試解析,並在最後把沒處理完的部分存回 this.buffer,等下一次資料到達時拼接續處理。這是所有串流解析器的共通套路。
這段程式碼是理解協議的絕佳教材,但若要用於生產環境,有幾處必須留意:文中使用的 new Buffer() API 早已被 Node.js 標記為棄用,應改用 Buffer.from() 與 Buffer.alloc();此外它並未處理分片訊息(fin 為 0 的情況)、壓縮擴展(permessage-deflate)、TLS(wss)以及完整的關閉狀態碼流程。
實務上請直接使用成熟的函式庫,例如 Node.js 的 ws 套件,或是在前端使用瀏覽器原生的 WebSocket API。手刻一遍的價值在於「徹底理解」,而非「拿去上線」。