websocket掩码处理方式

最新推荐文章于 2024-09-19 21:45:42 发布
最新推荐文章于 2024-09-19 21:45:42 发布
阅读量7.2k 收藏 24
点赞数 4
分类专栏： websocket

1、数据帧格式概览

下面给出了WebSocket数据帧的统一格式。熟悉TCP/IP协议的同学对这样的图应该不陌生。

  1. 从左到右，单位是比特。比如FIN、RSV1各占据1比特，opcode占据4比特。
  2. 内容包括了标识、操作代码、掩码、数据、数据长度等。（下一小节会展开） 
     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 ...                |
 +---------------------------------------------------------------+

    2、数据帧格式详解

    针对前面的格式概览图，这里逐个字段进行讲解，如有不清楚之处，可参考协议规范，或留言交流。

    FIN：1个比特。

    如果是1，表示这是消息（message）的最后一个分片（fragment），如果是0，表示不是是消息（message）的最后一个分片（fragment）。

    RSV1, RSV2, RSV3：各占1个比特。

    一般情况下全为0。当客户端、服务端协商采用WebSocket扩展时，这三个标志位可以非0，且值的含义由扩展进行定义。如果出现非零的值，且并没有采用WebSocket扩展，连接出错。

    Opcode: 4个比特。

    操作代码，Opcode的值决定了应该如何解析后续的数据载荷（data payload）。如果操作代码是不认识的，那么接收端应该断开连接（fail the connection）。可选的操作代码如下：

    %x0：表示一个延续帧。当Opcode为0时，表示本次数据传输采用了数据分片，当前收到的数据帧为其中一个数据分片。
%x1：表示这是一个文本帧（frame）
%x2：表示这是一个二进制帧（frame）
%x3-7：保留的操作代码，用于后续定义的非控制帧。
%x8：表示连接断开。
%x9：表示这是一个ping操作。
%xA：表示这是一个pong操作。
%xB-F：保留的操作代码，用于后续定义的控制帧。

    Mask: 1个比特。

    表示是否要对数据载荷进行掩码操作。从客户端向服务端发送数据时，需要对数据进行掩码操作；从服务端向客户端发送数据时，不需要对数据进行掩码操作。

    如果服务端接收到的数据没有进行过掩码操作，服务端需要断开连接。

    如果Mask是1，那么在Masking-key中会定义一个掩码键（masking key），并用这个掩码键来对数据载荷进行反掩码。所有客户端发送到服务端的数据帧，Mask都是1。

    掩码的算法、用途在下一小节讲解。

    Payload length：数据载荷的长度，单位是字节。为7位，或7+16位，或1+64位。

    假设数Payload length === x，如果

    x为0~126：数据的长度为x字节。
x为126：后续2个字节代表一个16位的无符号整数，该无符号整数的值为数据的长度。
x为127：后续8个字节代表一个64位的无符号整数（最高位为0），该无符号整数的值为数据的长度。

    此外，如果payload length占用了多个字节的话，payload length的二进制表达采用网络序（big endian，重要的位在前）。

    Masking-key：0或4字节（32位）

    所有从客户端传送到服务端的数据帧，数据载荷都进行了掩码操作，Mask为1，且携带了4字节的Masking-key。如果Mask为0，则没有Masking-key。

    备注：载荷数据的长度，不包括mask key的长度。

    Payload data：(x+y) 字节

    载荷数据：包括了扩展数据、应用数据。其中，扩展数据x字节，应用数据y字节。

    扩展数据：如果没有协商使用扩展的话，扩展数据数据为0字节。所有的扩展都必须声明扩展数据的长度，或者可以如何计算出扩展数据的长度。此外，扩展如何使用必须在握手阶段就协商好。如果扩展数据存在，那么载荷数据长度必须将扩展数据的长度包含在内。

    应用数据：任意的应用数据，在扩展数据之后（如果存在扩展数据），占据了数据帧剩余的位置。载荷数据长度 减去 扩展数据长度，就得到应用数据的长度。

    3、掩码算法

    掩码键（Masking-key）是由客户端挑选出来的32位的随机数。掩码操作不会影响数据载荷的长度。掩码、反掩码操作都采用如下算法：

    首先，假设：

    original-octet-i：为原始数据的第i字节。
transformed-octet-i：为转换后的数据的第i字节。
j：为i mod 4的结果。
masking-key-octet-j：为mask key第j字节。

    算法描述为： original-octet-i 与 masking-key-octet-j 异或后，得到 transformed-octet-i。

    j = i MOD 4
transformed-octet-i = original-octet-i XOR masking-key-octet-j

    4、掩码样例     

场景:          

    客户端：发送语音文件到服务端，先发送txt消息文件名称"tts"；再读物文件，发送bin消息二进制流数据(多帧发送)。

    服务端：先接收txt消息，需要接收的文件名称并创建打开；再接收bin消息语音流消息，并写入文件；当接收到最后一帧二进制后，关闭打开的文件。

   txt消息生成的 掩码KEY：

the key is 14,51,172,208.

客服端处理消息："tts" =》122，71，-33

 

    1.客户端生成原始4位掩码

    2.将需要发送字符与掩码异或运算，获取计算后的值，用于网络传输。

        116（t）与掩码14异或处理，得到异或值：122

        116（t）与掩码51异或处理，得到异或值：71

        116（s）与掩码172：10101101异或处理，得到异或值：-33

         （208：11010000）

     3.生成待发送消息：121，71，-33

unsigned char maskKey[4] = {0};    // 掩码

测试：

算法处理：

int webSocket_enPackage(unsigned char *data, unsigned int dataLen, unsigned char *package, unsigned int packageMaxLen, bool isMask, WebsocketData_Type type)
{
    unsigned char maskKey[4] = {0};    // 掩码
    unsigned char temp1, temp2;
    int count;
    unsigned int i, len = 0;
    
    if(packageMaxLen < 2)
        return -1;
    
    if(type == WDT_MINDATA)
        *package++ = 0x00;
    else if(type == WDT_TXTDATA)
        *package++ = 0x81;
    else if(type == WDT_BINDATA)
        *package++ = 0x82;
    else if(type == WDT_DISCONN)
        *package++ = 0x88;
    else if(type == WDT_PING)
        *package++ = 0x89;
    else if(type == WDT_PONG)
        *package++ = 0x8A;
    else if(type == 100)
        *package++ = 0x02;//add by cheyang//return -1;
	else if(type == 99)
        *package++ = 0x80;//add by cheyang//return -1;
		
    //
    if(isMask)
        *package = 0x80;
    len += 1;
    //
    if(dataLen < 126)
    {
        *package++ |= (dataLen&0x7F);
        len += 1;
    }
    else if(dataLen < 65536)
    {
        if(packageMaxLen < 4)
            return -1;
        *package++ |= 0x7E;
        *package++ = (char)((dataLen >> 8) & 0xFF);
        *package++ = (unsigned char)((dataLen >> 0) & 0xFF);
        len += 3;
    }
    else if(dataLen < 0xFFFFFFFF)
    {
        if(packageMaxLen < 10)
            return -1;
        *package++ |= 0x7F;
        *package++ = 0; //(char)((dataLen >> 56) & 0xFF);   // 数据长度变量是 unsigned int dataLen, 暂时没有那么多数据
        *package++ = 0; //(char)((dataLen >> 48) & 0xFF);
        *package++ = 0; //(char)((dataLen >> 40) & 0xFF);
        *package++ = 0; //(char)((dataLen >> 32) & 0xFF);
        *package++ = (char)((dataLen >> 24) & 0xFF);        // 到这里就够传4GB数据了
        *package++ = (char)((dataLen >> 16) & 0xFF);
        *package++ = (char)((dataLen >> 8) & 0xFF);
        *package++ = (char)((dataLen >> 0) & 0xFF);
        len += 9;
    }
    //
    if(isMask)    // 数据使用掩码时, 使用异或解码, maskKey[4]依次和数据异或运算, 逻辑如下
    {
        if(packageMaxLen < len + dataLen + 4)
            return -1;
        webSocket_getRandomString(maskKey, sizeof(maskKey));    // 随机生成掩码
        *package++ = maskKey[0];
        *package++ = maskKey[1];
        *package++ = maskKey[2];
        *package++ = maskKey[3];
        len += 4;
		if(type == WDT_TXTDATA){
				printf("the key is %d,%d,%d,%d.\n",maskKey[0],maskKey[1],maskKey[2],maskKey[3]);
		}
        for(i = 0, count = 0; i < dataLen; i++)
        {
            temp1 = maskKey[count];
            temp2 = data[i];
			if(type == WDT_TXTDATA){
				printf("the file name is %d,key:%d,\n",temp2,maskKey[count]);
			}
            *package++ = (char)(((~temp1)&temp2) | (temp1&(~temp2)));  // 异或运算后得到数据
			if(type == WDT_TXTDATA){
				printf("after key name is %d,\n",(char)(((~temp1)&temp2) | (temp1&(~temp2))));
			}
            count += 1;
            if(count >= sizeof(maskKey))    // maskKey[4]循环使用
                count = 0;
        }
        len += i;
        *package = '\0';
    }
    else    // 数据没使用掩码, 直接复制数据段
    {
        if(packageMaxLen < len + dataLen)
            return -1;
        memcpy(package, data, dataLen);
        package[dataLen] = '\0';
        len += dataLen;
    }
    //
    return len;
}

服务端处理消息：122，71，-33  =》 "tts"

1.获取客户端发送的4位掩码和数据消息

2.将收到的字符消息与掩码异或运算，获取源字符值

        122与掩码（14）异或处理，得到原字符值：116（t）

        71与掩码（51）异或处理，得到原字符值：116（t）

        -33与掩码（-84：10101101）异或处理，得到原字符值：115（s）

          （-48：11010000）

  3.解码获取文件名：116，116，115；及字符：tts

char masking_key[4];  有符号变量，

算法处理：

int Websocket_Handler::recv_request()
{
    printf("Websocket_Handler::recv_request: recv request logic.\n");
	
	char readCache[1024*4] = {0};        
	int recvsize;
	int head_len = 0;
	
	do{
		recvsize = 0;
        recvsize = read(fd_,readCache,BUFFLEN);
		printf("read:size:%d,curslot:%d.\n",recvsize,m_nOffset);
		
        if (recvsize < 0)
        {
			memset(readCache, 0, sizeof(readCache));
			printf("read failure,wait next frame websocket.\n");
			return 0;
		}else if( 0 == recvsize ){
			if( NULL != handle ){
				fclose(handle);
			}
			channel->setDeleted(true);
        	channel->getLoop().lock()->addTimer(channel,0);
			return 0;
		}
		
      
		
		memcpy(buff_+m_nOffset, readCache, recvsize);
		m_nOffset = m_nOffset + recvsize;//set offset

		//获取消息头
		if( 0 > (head_len = getFrameHeaderInfo(buff_,&header_msg,m_nOffset)) )
		{
			printf("error is not full frame.\n");
			continue;
			
		}
		printf("read frame head\tFIN: %d\tOPCODE: %d\tMASK: %d\tPAYLOADLEN: %d\tHeadlen:%d\n.",
				header_msg.fin, header_msg.opcode, header_msg.mask, header_msg.payload_length,head_len);
		//读取满帧数据校验
		if(header_msg.payload_length > m_nOffset- head_len || header_msg.payload_length <= 0 )
		{		
			continue;
		}
		
		if( 1 ==header_msg.mask){
			umask(buff_+head_len,header_msg.payload_length,header_msg.masking_key);
		}

		switch(header_msg.opcode){
			case 0x00:
					printf("recv mid frame.\n");
					break;
			case 0x01: 
					{
						printf("recv text frame.\n\t%s\n",(buff_+head_len));
						if( handle == NULL && header_msg.payload_length <= 1000){
							char filename[1024];
							sprintf(filename,"./snOfflineVoice_%s.snv",buff_+head_len);
		 					handle = fopen(filename,"a+");
						}
						
						m_nOffset = m_nOffset - header_msg.payload_length - head_len;
						
						char buffer[2048*2] = {0};
						memcpy(buffer, buff_+header_msg.payload_length+head_len,m_nOffset);
						memset(buff_,0,BUFFLEN*2);
						memcpy(buff_, buffer,m_nOffset);
						
						return 0;
					}
			case 0x02: 
					printf("recv bin frame.\n");
					if( handle == NULL){
						char filename[1024];
						sprintf(filename,"./snOfflineVoice_%02d.snv",header_msg.payload_length);
	 					handle = fopen(filename,"a+");
					}
					break;
			case 0x08: 
					channel->setDeleted(true);
		        	channel->getLoop().lock()->addTimer(channel,0);
					return 0;
			case 0x09: 
					printf("recv ping frame,need send pong frame.\n");
					//webSocket_send(fd, (char *)webSocketPackage, retLen, true, WDT_PONG);//自动 ping-pong
					return 0;
			case 0x0A: 
					printf("recv pong frame.\n");
					return 0;
			default:
				printf("recv unknow frame.\n");
				
		}
		
		//just one frame or frist of mutl_frame
		/*if( (1 ==header_msg.fin && 0 < header_msg.opcode &&  3 > header_msg.opcode && handle != NULL )
				|| (0 ==header_msg.fin && 0 !=header_msg.opcode && 3 > header_msg.opcode  ) ){
			char filename[1024];
			sprintf(filename,"./snOfflineVoice_%02d.snv",header_msg.payload_length);

	 		handle = fopen(filename,"a+");
			if(NULL != handle){
				fwrite(buff_+head_len, sizeof(char), header_msg.payload_length, handle);
				fflush(handle);
				printf("fwrite:size:%d,payload_len:%d.\n",header_msg.payload_length,header_msg.payload_length);

				m_nOffset = m_nOffset - header_msg.payload_length - head_len;
				char swap[2048] = {0};
				memcpy(swap, buff_+header_msg.payload_length+head_len,m_nOffset);
				memset(buff_,0,BUFFLEN*2);
				memcpy(buff_, swap,m_nOffset);	
				return 0;//break function
			}
		}*/
		
		
		if( NULL != handle){

			
			fwrite(buff_+head_len, sizeof(char), header_msg.payload_length, handle);
			fflush(handle);
			m_nOffset = m_nOffset - header_msg.payload_length - head_len;
			char swap[2048*2] = {0};
			memcpy(swap, buff_+header_msg.payload_length+head_len,m_nOffset);
			memset(buff_,0,BUFFLEN*2);
			memcpy(buff_, swap,m_nOffset);
			printf("fwrite:size:%d,m_nOffset:%d.\n",header_msg.payload_length, m_nOffset);
		}

		if(m_nOffset > 4){
			memset(&header_msg,0,sizeof(header_msg));
			printf(">>>>>>>>>>check Incomming data frame<<<<<<<<<.\n");
			if( 0 > (head_len = getFrameHeaderInfo(buff_,&header_msg,m_nOffset)) )
			{
				printf("error is not full frame.\n");
				continue;
				
			}
			
			if(header_msg.payload_length <= m_nOffset- head_len&& header_msg.payload_length > 0 )
			{
				printf("read frame head\tFIN: %d\tOPCODE: %d\tMASK: %d\tPAYLOADLEN: %d\tHeadlen:%d.\n",
						header_msg.fin, header_msg.opcode, header_msg.mask, header_msg.payload_length,head_len);

				if( 1 ==header_msg.mask){
					umask(buff_+head_len,header_msg.payload_length,header_msg.masking_key);
				}
				
				fwrite(buff_+head_len, sizeof(char), header_msg.payload_length, handle);
				fflush(handle);
				printf("fwrite more frame:size:%d,m_nOffset:%d.\n",header_msg.payload_length, m_nOffset);
				m_nOffset = m_nOffset -header_msg.payload_length-head_len;
				char swap[2018] = {0};
				memcpy(swap, buff_+header_msg.payload_length+head_len,m_nOffset);
				memset(buff_,0,BUFFLEN*2);
				memcpy(buff_, swap,m_nOffset);
				
			}
			else{
				printf(" Lack of data, need read more data.\n");
				continue;
			}

		}
				
	    

		if(1 == header_msg.fin && NULL != handle &&
				( 0 == header_msg.opcode ||  2 == header_msg.opcode) ){
			fclose(handle);
			handle = NULL;
			m_nOffset = 0;
			memset(buff_,0,BUFFLEN*2);
			printf("is last frame, need close file.\n");
			return 0;
		}
		
		printf("read data again.\n");
	}while(1);

	printf("wait next request websocket .\n");
	
	return 0;
}

int Websocket_Handler::getFrameHeaderInfo(char *buff,frame_head* head,int curSize)
{
    char one_char;
	int  head_len = 0;
	
    one_char = buff[0];
    head->fin = (one_char & 0x80) == 0x80;
    head->opcode = one_char & 0x0F;
    

	one_char = buff[1];
    head->mask = (one_char & 0x80) == 0X80;

    /*get payload length*/
    head->payload_length = one_char & 0x7F;

    if (head->payload_length == 126)
    {
        char extern_len[2];
        extern_len[0] = buff[2];
		extern_len[1] = buff[3];
		
        head->payload_length = (extern_len[0]&0xFF) << 8 | (extern_len[1]&0xFF);
		head_len = 4;
    }
    else if (head->payload_length == 127)
    {
        char extern_len[8];
        //wait to doing
        //...
        inverted_string(extern_len,8);
        memcpy(&(head->payload_length),extern_len,8);
		head_len = 10;
    }
	else if(head->payload_length == 0)
	{
		printf("read payload_length is 0,close connect.");
        return -1;
	}
	else if(head->payload_length < 126)
	{
		printf("read payload_length is less 126, is little frame.\n");
        head_len = 2;
	}

	
	
	if(head->mask  ==1 ){

		if(curSize <= 7 )
		{
			printf("check buff size error.\n");
			return -1;
		}
		head->masking_key[0] = buff[head_len+0];
		head->masking_key[1] = buff[head_len+1];
		head->masking_key[2] = buff[head_len+2];
		head->masking_key[3] = buff[head_len+3];
		
		return head_len +4;
	}
    return head_len;
}


int Websocket_Handler::handlerconn(){

	if(status_ == WEBSOCKET_UNCONNECT){
		int len = read(fd_,buff_,BUFFLEN*2);
        if (len<=0)
            return -1;
		
		return handshark();
	}
	printf("Websocket_Handler::handlerconn: begin handlerconn logic.\n");

	recv_request();

	return 0;
	
	
	//int ilenData = 0;
	//request_->getReqData(buff_out,buff_len);
	snprintf(buff_out,2048,"%s",buff_);

	//send_frame_head();
	//request_->print();
	//respond client
	channel->setRevents(EPOLLOUT|EPOLLET);
	channel->getLoop().lock()->updatePoller(channel);
	
	channel->setWritehandler(bind(&Websocket_Handler::send_respond,this));

	printf("process logic end.\n");
	memset(buff_, 0, sizeof(buff_));
	return 0;
}
void Websocket_Handler::umask(char *data,int len,char *mask)
{
	int i;    
	for (i=0;i<len;++i){    
		*(data+i) ^= *(mask+(i%4));
	}
}

 

other：

异或的特性及应用：

1.使特定位翻转
　　假设有01111010，想使其低4位翻转，即1变为0，0变为1。可以将它与00001111进行^运算，即
　　结果值的低4位正好是原数低4位的翻转。要使哪几位翻转就将与其^运算的该几位置为1即可。这是因为原数中值为1的位与1进行^运算得0，原数中的位值0与1进行^运算的结果得1

2.与自身异或为0，与0异或不变

假设3^3,即011^011，结果为000.

3^0,011^000,结果为011，还是3.

用此特性可完成两个数a，b的交换且不需要临时变量

a = a^b  //此时给a赋值a^b

b = a^b  //此时a = a^b 则 b = a^b^b.  得b = a

a = a^b  //此时a = a^b, b = a. 则 a = a^b^a. 得a = b.完成交换

websocket简介：https://www.cnblogs.com/cyblogs/p/11099193.html

yangzai77
关注
专栏目录
websocket客户端和服务端
03-18
在Web应用程序中，WebSocket为开发者提供了低延迟、高效率的交互方式，特别适用于在线游戏、股票交易、实时聊天等场景。 在WebSocket协议中，客户端和服务端的角色至关重要。`WebSocketClient.java`和`WebSocket...
webSocket掩码
nidiyi的博客
06-30 569
websocket的通讯协议中：客户端发出的数据帧需要进行掩码处理。服务器发送的数据帧则未经过掩码处理。所以如果服务器收到客户端发送的未经掩码处理的数据包，则会自动断开连接；反之，如果客户端收到了服务端发送的经过掩码处理的数据包，也会自动断开连接...
WebSocket协议分析及实现
Peng的专栏
08-13 867
前言    Webscoket是Web浏览器和服务器之间的一种全双工通信协议，WebSocket协议由IETF定义标准，WebSocket API则由W3C定义标准。 一、通信流程    Web客户端与服务器通过http协议建立起连接，然后在接下来的通信过程中，通过websocket协议可互相发送JSON、XML、HTML或图片等任意格式的数据。    如此一来服务器可以直接向客户端推送消息。相...
图像处理-掩码
最新发布
2301_77698138的博客
09-19 2304
在图像处理中，掩码（Mask）是一种特殊的图像，用于指定对原始图像进行操作的区域。掩码通常是二值图像（即图像上的每个像素只有两个可能的值，通常是0和255，分别代表黑色和白色），但也可以是灰度图像或多通道图像，尽管二值掩码最为常见。
WebSocket协议和实现
KwinWei的博客
07-24 173
在WebSocket协议中，数据是通过帧序列来传输的。为了数据安全原因，客户端必须掩码(mask)它发送到服务器的所有帧，当它收到一个 没有掩码的帧时，服务器必须关闭连接。不过服务器端给客户端发送的所有帧都不是掩码的，如果客户端检测到掩码的帧时，也一样必须关闭连接。 当帧被关闭的时候，可能发送状态码1002(协议错误)。 基本帧协议如下： 1 2 3 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
c#-OpenCvSharp-掩码操作（附源码）
m0_55074196的博客
08-01 1415
掩码操作是指在图像处理过程中，根据掩码的像素值来控制图像的处理或选取感兴趣的区域。在掩码操作中，对于掩码中像素值为非零的位置，对应原始图像中的像素将被处理或选取，而对于掩码中像素值为零的位置，对应原始图像中的像素将被忽略或遮蔽。
websocket 中掩码的相关代码
draracle的巢穴
04-02 150
代码很简单，就是不断循环的用掩码异或一次原始数据。
websocket_websocket客户端_websocket_
10-03
在给定的压缩包文件中，很可能是包含了一个简单的WebSocket客户端示例代码，你可以通过学习和理解这些代码来了解WebSocket的工作原理和实现方式。这个示例可能会涵盖上述提到的关键点，如握手、数据传输、事件处理等...
WebSocket Demo
08-07
在传统的HTTP协议中，每次请求-响应交互都需要重新建立连接，而WebSocket则提供了一种更高效的方式，降低了延迟，使得实时数据传输成为可能，特别适合于需要频繁交互的应用，如在线游戏、股票交易、聊天室、协作编辑...
WEBSOCKET.rar
07-08
为了深入理解并使用这个WebSocket代理服务，你需要熟悉WebSocket的基本概念和工作原理，了解代理服务器的架构和实现方式，以及可能涉及的网络和安全知识。同时，对于压缩包中的具体代码，需要具备相应的编程语言基础...
c语言 websocket
01-26
4. **WebSocket事件处理**：注册一个WebSocket事件处理函数，例如`on_message()`，该函数将在接收到WebSocket消息时被调用。使用`mg_websocket_read()`和`mg_websocket_write()`函数读写WebSocket数据。 5. **处理...
掩码处理
weixin_40446764的博客
07-31 476
WebSocket协议理解-数据包格式解析
weixin_46777373的博客
08-30 1105
做客户端开发时，接触最多的应用层网络协议，就是 HTTP 协议，而今天介绍的 WebSocket，下层和 HTTP 一样也是基于 TCP 协议，这是一种轻量级网络通信协议，也属于应用层协议。WebSocket 与 HTTP/2 一样，其实都是为了解决 HTTP/1.1 的一些缺陷而诞生的，而 WebSocket 针对的就是「请求-应答」这种"半双工"的模式的通信缺陷。「请求-应答」是"半双工"的通信模式，数据的传输必须经过一次请求应答，这个完整的通信过程，通信的同一时刻数据只能在一个方向上传递。它最大的问题
WebSocket协议与java实现
weixin_41670928的博客
12-19 807
一、webSocket协议研究： 研究源码发现有些域和方法的算法看不懂，不知道是什么含义。于是回来看看协议。网址：webSocket协议 该协议的帧结构： FIN：判断这一帧数据是不是这一消息的最后一帧。 RSV1、RSV2、RSV3: 必须是0，除非通信双方做了特别的协商 Opcode: 4 bits 占有4位，定义了PayLoad Data的含义 我理解是代表帧的类型 ...
【numpy操作】掩码处理
weixin_53063763的博客
06-30 2006
数组掩码处理
WebSocket 协议介绍
dashalen的博客
08-04 1285
websocket协议介绍 netty中的使用
WebSocket入门和帧协议详解
xmcy001122的专栏
05-24 3625
WebSocket学习笔记 简介 WebSocket 是一种基于 TCP 的网络协议。在 2009 年诞生，于 2011 年被 IETF 定为标准 RFC 6455 通信标准，并由 RFC7936 补充规范。WebSocket API 也被 W3C 定为标准。 WebSocket 也是一种 全双工通信 的协议，既允许客户端向服务器主动发送消息，也允许服务器主动向客户端发送消息。在 WebSocket 中，浏览器和服务器只需要完成一次握手，两者之间就可以建立持久性的连接，进行双向数据传输。 该协议的特点是：
【译】WebSocket协议第五章——数据帧(Data Framing)
weixin_34044273的博客
01-07 340
概述 本文为WebSocket协议的第五章，本文翻译的主要内容为WebSocket传输的数据相关内容。 有兴趣了解该文档之前几张内容的同学可以见： 【译】WebSocket协议第一章——介绍(Introduction) 【译】WebSocket协议第二章——一致性要求(Conformance Requirements) 【译】WebSo...
WebSocket协议：5分钟入门到精通
Lamb的博客
08-04 2024
HTML5开始提供的一种浏览器与服务器进行全双工通讯的网络技术，属于应用层协议。它基于TCP传输协议，并复用HTTP的握手通道。WebSocket可以在浏览器里使用支持双向通信使用很简单。
WebSocket数据传输详解：分片传输与掩码机制
掩码处理的目的是保护数据的隐私，确保只有接收端能够正确解码。如果服务器接收到未掩码的数据帧，或者客户端接收到掩码的数据帧，它们都应该关闭连接，并发送一个带有状态码1002的Close帧，表明存在协议错误。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值