websocket协议的服务端Nodejs实现

WebSocket协议的服务端Node.js实现

尽管有许多成熟的WebSocket框架，但自己从底层的Socket层面实现一个WebSocket服务端仍然非常有趣。在这个过程中，我们需要处理以下几个关键问题：

1. 握手协议：客户端发送握手请求时，服务器需要验证并返回握手响应。
2. 数据帧头处理：解析WebSocket数据帧的头部信息，包括数据长度、掩码等。
3. 数据实际长度和长数据：处理不同长度的数据，包括短数据和长数据的传输。
4. 编码问题：确保数据在传输过程中的正确编码。

下面是基于Node.js的WebSocket服务端实现代码：

var net = require('net');
var crypto = require('crypto');
var events = require('events');

exports.createServer = function(onConnect) {
    var server = net.createServer(function(con) {
        var client = new WsClient(con);
        onConnect(client);
    });

    this.listen = function(port, onlisten) {
        server.listen(port, onlisten);
    };

    return this;
};

function WsClient(con) {
    var _t = this;
    var registered = false;
    var dataLength = 0;
    var recevBuf = null;
    var mask = null;
    var recevHead = null;

    var eve = new events.EventEmitter();

    this.on = function(_event, _listener) {
        eve.on(_event, _listener);
        return this;
    };

    con.on('data', function(data) {
        if (!registered) {
            _shakeHand(data, con);
            registered = true;
            eve.emit('connect', con);
        } else {
            _readData(data);
        }
    });

    con.on('end', function() {
        eve.emit('close');
    });

    function _shakeHand(data) {
        var headers = parseHeaders(data);
        var key = headers['Sec-WebSocket-Key'];
        var shasum = crypto.createHash('sha1');
        var magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
        shasum.update(key + magic, 'ascii');

        var response = 'HTTP/1.1 101 Switching Protocols\r\n';
        response += 'Upgrade: websocket\r\n';
        response += 'Connection: Upgrade\r\n';
        response += 'Sec-WebSocket-Accept: ' + shasum.digest('base64') + '\r\n';
        response += '\r\n';

        con.write(response, 'ascii');
    }

    function parseHeaders(data) {
        var lines = data.toString().split('\r\n');
        var headers = {};
        for (var i = 0; i < lines.length; i++) {
            var line = lines[i];
            if (line.indexOf(':') > 0) {
                var [key, value] = line.split(':').map(s => s.trim());
                headers[key] = value;
            }
        }
        return headers;
    }

    function _readFrameHead(data) {
        if (dataLength === 0) {
            recevHead = data[0];

            var length = data[1] & 0x7F;
            var hasMask = (data[1] & 0x80) === 0x80;

            var maskIndex = 2;
            var dataIndex = 6;
            if (length === 126) {
                maskIndex = 4;
                dataIndex = 8;
                length = data.readUInt16BE(2);
            } else if (length === 127) {
                maskIndex = 10;
                dataIndex = 14;
                length = data.readUInt32BE(6);
            }
            dataLength = length;

            if (hasMask) {
                recevBuf = new Buffer(length);
                mask = data.slice(maskIndex, maskIndex + 4);
            } else {
                recevBuf = '';
                mask = null;
            }
            return dataIndex;
        } else {
            return 0;
        }
    }

    function _readData(data) {
        var dataIndex = _readFrameHead(data);

        if (mask) {
            var i = recevBuf.length - dataLength;
            var l = Math.min(recevBuf.length, data.length - dataIndex + i);
            dataLength -= data.length - dataIndex;

            for (; i < l; i++) {
                recevBuf[i] = data[dataIndex++] ^ mask[i % 4];
            }
        } else {
            recevBuf += data.toString('utf8', dataIndex);
            dataLength -= data.length - dataIndex;
        }

        if (dataLength === 0) {
            if (recevBuf.length > 0) {
                var out = recevBuf.toString();
                eve.emit('data', out);
            } else {
                eve.emit('close');
            }
        }
    }

    this.send = function(message) {
        var length = Buffer.byteLength(message);
        var dataIndex = length > 65535 ? 10 : length > 125 ? 4 : 2;

        var buf = new Buffer(dataIndex + length);
        buf[0] = recevHead;
        if (length > 65535) {
            buf[1] = 127;
            buf.writeUInt32BE(0, 2);
            buf.writeUInt32BE(length, 6);
        } else if (length > 125) {
            buf[1] = 126;
            buf.writeUInt16BE(length, 2);
        } else {
            buf.writeUInt8(length, 1);
        }

        buf.write(message, dataIndex);

        con.write(buf, 'utf8', function() {});
    };
}

const OpCode = {
    Text: 1,
    Binary: 2,
    Close: 8,
    Ping: 9,
    Pong: 10
};

解释

1. 握手协议：

   • 服务器接收到客户端的握手请求后，会解析请求中的Sec-WebSocket-Key，并生成对应的SHA1哈希值。
   • 然后构造握手响应，并发送给客户端。

2. 数据帧头处理：

   • 数据帧头包含控制位（如FIN、RSV1-3）和操作码（如文本、二进制等）。
   • 还包括数据长度字段，用于标识实际数据的长度。
   • 如果数据被掩码，则需要解密数据。

3. 数据实际长度和长数据：

   • 处理不同长度的数据，包括短数据（小于等于125字节）、中等长度数据（126字节）和长数据（大于65535字节）。

4. 编码问题：

   • 确保数据在传输过程中正确编码，例如将字符串转换为Buffer，或进行掩码处理。

以上代码实现了WebSocket服务端的基本功能，可以根据具体需求进一步扩展和完善。