关于VB版之前已经写了,有需要可以进传送门《VB封装的WebSocket模块,拿来即用》，两个使用都差不多,这里简单概述一下:
连接完成后,没有握手就用Handshake()先完成握手
之后接收数据,先用AnalyzeHeader()得到数据帧结构(DataFrame)
然后再用PickDataV()或PickData()得到源数据,对于掩码数据是在这里反掩码
关于发送数据,则是:
服务端发送无需掩码用PackData()将数据组装一下就可以发送
而模拟客户端向服务器的发送需要加掩码,用PackMaskData()
相关资料下载：《WebSocket协议中文版.pdf》
*等有时间我再做个demo供下载吧,这个类使用还算简单
WebSocketProtocol10.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
/*
* 详见<5.2 基本帧协议>和<11.8.WebSocket 操作码注册>
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
*/
//2017-06-17
//By: 悠悠然
//QQ: 2860898817
//E-mail: ur1986@foxmail.com
namespace WebSocketProtocol10
{
/// <summary>
/// Opcode操作码是一个在 0 到 15（包括）之间的整数数字。
/// </summary>
public enum OpcodeType:byte
{
Contin = 0x0, //表示连续消息片断
Text = 0x1, //表示文本消息片断
Binary = 0x2, //表未二进制消息片断
// 0x3 - 0x7 非控制帧保留
Close = 0x8, //表示连接关闭
Ping = 0x9, //表示心跳检查的ping
Pong = 0xA, //表示心跳检查的pong
// 0xB - 0xF 控制帧保留
Unkown
};
/// <summary>
/// 数据帧头,就是包头结构
/// </summary>
public struct DataFrame
{
/// <summary>0表示不是当前消息的最后一帧，后面还有消息,1表示这是当前消息的最后一帧；</summary>
public bool FIN;
/// <summary>1位，若没有自定义协议,必须为0,否则必须断开.</summary>
public bool RSV1;
/// <summary>1位，若没有自定义协议,必须为0,否则必须断开.</summary>
public bool RSV2;
/// <summary>1位，若没有自定义协议,必须为0,否则必须断开.</summary>
public bool RSV3;
/// <summary>4位操作码，定义有效负载数据，如果收到了一个未知的操作码，连接必须断开.</summary>
public OpcodeType Opcode;
/// <summary>1位，定义传输的数据是否有加掩码,如果有掩码则存放在MaskingKey</summary>
public bool MASK;
/// <summary>0或4个字节，客户端发送给服务端的数据，都是通过内嵌的一个32位值作为掩码的；掩码键只有在掩码位设置为1的时候存在。</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = )]
public byte[] MaskingKey;
/// <summary>传输数据的长度</summary>
public int Payloadlen;
/// <summary>数据起始位</summary>
public int DataOffset;
} public class WSProtocol
{
#region 握手
/// <summary>
/// 获取连接请求附带的参数
/// </summary>
public static NameValueCollection QueryString(byte[] recv)
{
//前端js如: ws = new WebSocket("ws://127.0.0.1:8899/ws?id=1&session=a1b2c3")
//该函数相当于ASP.NET中的Request.QueryString,就是取得参数 id 和 session 的
NameValueCollection NV = new NameValueCollection();
string n = string.Empty;
string v = string.Empty;
bool tf1 = false;
bool tf2 = false;
foreach (byte b in recv)
{
if (tf1)
{
if (b == )
break;
else if (b == && tf2 == false)//=
tf2 = true;
else if (b == )//&
{
tf2 = false;
if (!string.IsNullOrEmpty(n) && !string.IsNullOrEmpty(v))
NV.Add(n, v);
n = string.Empty;
v = string.Empty;
}
else
{
if (tf2)
v += (char)b;
else
n += (char)b;
}
}
else if (b == )//?
tf1 = true;
else if (b == || b == ) break;
}
if (!string.IsNullOrEmpty(n) && !string.IsNullOrEmpty(v))
NV.Add(n, v);
return NV;
}
public static byte[] Handshake(string request)
{
string webSocketKey = getCilentWSKey(request, "Sec-WebSocket-Key:");
string acceptKey = produceAcceptKey(webSocketKey);
StringBuilder response = new StringBuilder(); //响应串
response.Append("HTTP/1.1 101 Web Socket Protocol Handshake\r\n");
response.Append("Upgrade: WebSocket\r\n");
response.Append("Connection: Upgrade\r\n");
response.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", acceptKey);
response.AppendFormat("WebSocket-Origin: {0}\r\n", getCilentWSKey(request, "Sec-WebSocket-Origin"));
response.AppendFormat("WebSocket-Location: {0}\r\n", getCilentWSKey(request, "Host"));
response.Append("\r\n");
return Encoding.UTF8.GetBytes(response.ToString());
}
private static string getCilentWSKey(string request, string kname)
{
int i = CultureInfo.InvariantCulture.CompareInfo.IndexOf(request, kname, CompareOptions.IgnoreCase);
if (i > )
{
i += kname.Length;
int j = request.IndexOf("\r\n", i);
if (j > )
return request.Substring(i, j - i).Trim();
}
return string.Empty;
}
// 根据Sec-WebSocket-Key和MagicKey生成AcceptKey
private static string produceAcceptKey(string webSocketKey)
{
string MagicKey = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
Byte[] acceptKey = SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(webSocketKey + MagicKey));
return Convert.ToBase64String(acceptKey);
}
#endregion
#region 数据帧解析
/// <summary>
/// 数据帧头的解析
/// </summary>
public static DataFrame AnalyzeHeader(byte[] data)
{
DataFrame df;
df.FIN = (data[] & 0x80) == 0x80 ? true : false;
df.RSV1 = (data[] & 0x40) == 0x40 ? true : false;
df.RSV2 = (data[] & 0x40) == 0x20 ? true : false;
df.RSV3 = (data[] & 0x40) == 0x10 ? true : false;
byte[] b = { data[] };
BitArray bit = new BitArray(b);
bit.Set(, false);
bit.Set(, false);
bit.Set(, false);
bit.Set(, false);
bit.CopyTo(b, );
df.Opcode = (OpcodeType)b[]; df.MASK = (data[] & 0x80) == 0x80 ? true : false;
df.MaskingKey = new Byte[];
int len = data[] & 0x7F;
/// 0-125 表示传输数据的长度；
/// 126 表示随后的两个字节是一个16进制无符号数，用来表示传输数据的长度；
/// 127 表示随后的是8个字节是一个64位无符合数，这个数用来表示传输数据的长度。
/// 多字节长度的数量是以网络字节的顺序表示。负载数据的长度为扩展数据及应用数据之和，扩展数据的长度可能为0,因而此时负载数据的长度就为应用数据的长度。
switch (len)
{
case :
df.Payloadlen = (UInt16)(data[] << | data[]);
if(df.MASK)
{
Buffer.BlockCopy(data, , df.MaskingKey, , );
df.DataOffset = ;
}else
df.DataOffset = ;
break;
case :
Byte[] byteLen = new Byte[];
Buffer.BlockCopy(data, , byteLen, , );
df.Payloadlen = (int)BitConverter.ToUInt64(byteLen, );
if (df.MASK)
{
Buffer.BlockCopy(data, , df.MaskingKey, , );
df.DataOffset = ;
}
else
df.DataOffset = ;
break;
default:
if (len < )
{
df.Payloadlen = len;
if (df.MASK)
{
Buffer.BlockCopy(data, , df.MaskingKey, , );
df.DataOffset = ;
}
else
df.DataOffset = ;
}
else
{
df.Payloadlen = ;
df.DataOffset = ;
}
break;
}
return df;
}
#endregion
#region 处理数据--接收
/*
* PickDataV 方法是出于性能的考虑,用于有时数据只是为了接收,做一些逻辑判断,并不需要对数据块进行单独提炼
* PickData 有两个重载就不赘述了...
*/
/// <summary>
/// 如果数据存在掩码就反掩码,具体的使用数据就
/// </summary>
public static void PickDataV(byte[] data, DataFrame dtype)
{
if (dtype.MASK)
{
int j = ;
for (int i = dtype.DataOffset; i < dtype.DataOffset + dtype.Payloadlen; i++)
{
data[i] ^= dtype.MaskingKey[j++];
if (j == )
j = ;
}
}
}
public static byte[] PickData(byte[] data, DataFrame dtype)
{
byte[] byt = new byte[dtype.Payloadlen];
PickDataV(data, dtype);
Buffer.BlockCopy(data, dtype.DataOffset, byt, , dtpye.Payloadlen);
return byt;
}
public static string PickData(byte[] data,DataFrame dtype,Encoding encode)
{
PickDataV(data, dtype);
return encode.GetString(data, dtype.DataOffset, dtype.Payloadlen);
}
#endregion
#region 处理数据--发送
/*
* PackData 两个重载,用于组装无掩码数据
* PackMaskData 两个重载,用于将数据掩码后组装
*/
/// <summary>
/// 组装无掩码数据,一般用于服务端向客户端发送
/// </summary>
public static byte[] PackData(string data, Encoding encode, OpcodeType dwOpcode = OpcodeType.Text)
{
//字符默认用UTF8编码处理,如果有别的编码需求,自行处理后用下面的重载函数
byte[] buff = encode.GetBytes(data);
return PackData(buff, dwOpcode);
}
public static byte[] PackData(byte[] buff, OpcodeType dwOpcode = OpcodeType.Text)
{
List<byte> byt = new List<byte>();
byt.Add((byte)(0x80 | (byte)dwOpcode));
if (buff.Length < )
byt.Add((byte)buff.Length);
else if (buff.Length <= ushort.MaxValue)
{
ushort l = (ushort)buff.Length;
byte[] bl = BitConverter.GetBytes(l);
byt.Add(0x7e);
byt.Add(bl[]);
byt.Add(bl[]);
}
else
{
//由于用不到,未做测试
ulong l = (ulong)buff.Length;
byt.Add(0x7f);
byt.AddRange(BitConverter.GetBytes(l));
}
byt.AddRange(buff);
return byt.ToArray();
} /// <summary>
/// 将数据掩码后组装,一般是客户端向服务端发送
/// </summary>
public static byte[] PackMaskData(string str, Encoding encode, OpcodeType dwOpcode = OpcodeType.Text)
{
byte[] byt = encode.GetBytes(str);
return PackMaskData(byt, dwOpcode);
}
public static byte[] PackMaskData(byte[] byt, OpcodeType dwOpcode = OpcodeType.Text)
{
List<byte> data = new List<byte>();
//掩码我用的是固定值,有需要也可以自己做成随机的
byte[] maskey ={ , , , };
int j = ;
for (int i = ; i < byt.Length; i++)
{
data[i] ^= maskey[j++];
if (j > ) j = ;
}
data.Add((byte)(0x80 | (byte)OpcodeType.Text));//第一字节,FIN+RSV1+RSV2+RSV3+opcode
if (byt.Length < )
{
data.Add((Byte)(0x80 | (Byte)byt.Length));
}
else if (byt.Length <= ushort.MaxValue)//
{
data.Add();//固定 掩码位+126
byte[] b=BitConverter.GetBytes((ushort)byt.Length);
data.Add(b[]);//反转
data.Add(b[]);
}
else
{
//这部分没有经过实际测试,依靠协议文档推写出来的
//我的需求只是聊天通信,若有传送文件等需求,请自行测试
data.Add();//固定 掩码位+127
byte[] b = BitConverter.GetBytes((ulong)byt.Length);
Array.Reverse(b);//反转
data.AddRange(b);
}
data.AddRange(byt);
data.AddRange(maskey);
return data.ToArray();
}
#endregion
#region 常用控制帧
/*
下面的 Ping、Pong、Close 是非掩码信号,用于服务端向客户端发送,如果客户端想服务端发送就需要掩码
使用的时候直接 socket.Send(WSProtocol.PingFrame, 0, WSProtocol.PingFrame.Length);
我用的0长度,其实是可以包含数据的,但是附带数据客户端处理又麻烦了 * 如果有附带信息的需求,也可以用上面[发送]里的函数,可选参数指定OpcodeType
* 特别注意:收到ping的时候,回应pong.而收到pong的时候,回应还是pong
* 在协议里,ping是最为要求应答信号的,而pong是作为单向心跳检测的
*/
private static byte[] dwPing = { 0x89, 0x0 };
private static byte[] dwPong = { 0x8a, 0x0 };
private static byte[] dwClose = { 0x88, 0x0 };
public static byte[] PingFrame { get { return dwPing; } }
public static byte[] PongFrame { get { return dwPong; } }
public static byte[] CloseFrame { get { return dwClose; } }
#endregion
}
}