websocket

1 import socket
2 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
3 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
4 sock.bind((‘127.0.0.1‘, 8002))
5 sock.listen(5)
6 # 等待用户连接
7 conn, address = sock.accept()

1 <script type="text/javascript">
2     var socket = new WebSocket("ws://127.0.0.1:8002/xxoo");
3     ...
4 </script>

 1 import socket
 2  
 3 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 4 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 5 sock.bind((‘127.0.0.1‘, 8002))
 6 sock.listen(5)
 7 # 获取客户端socket对象
 8 conn, address = sock.accept()
 9 # 获取客户端的【握手】信息
10 data = conn.recv(1024)
11 ...
12 ...
13 ...
14 conn.send(‘响应【握手】信息‘)

 1 GET /chatsocket HTTP/1.1
 2 Host: 127.0.0.1:8002
 3 Connection: Upgrade
 4 Pragma: no-cache
 5 Cache-Control: no-cache
 6 Upgrade: websocket
 7 Origin: http://localhost:63342
 8 Sec-WebSocket-Version: 13
 9 Sec-WebSocket-Key: mnwFxiOlctXFN/DeMt1Amg==
10 Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
11 ...
12 ...

 1 import socket
 2 import base64
 3 import hashlib
 4  
 5 def get_headers(data):
 6     """
 7     将请求头格式化成字典
 8     :param data:
 9     :return:
10     """
11     header_dict = {}
12     data = str(data, encoding=‘utf-8‘)
13  
14     for i in data.split(‘\r\n‘):
15         print(i)
16     header, body = data.split(‘\r\n\r\n‘, 1)
17     header_list = header.split(‘\r\n‘)
18     for i in range(0, len(header_list)):
19         if i == 0:
20             if len(header_list[i].split(‘ ‘)) == 3:
21                 header_dict[‘method‘], header_dict[‘url‘], header_dict[‘protocol‘] = header_list[i].split(‘ ‘)
22         else:
23             k, v = header_list[i].split(‘:‘, 1)
24             header_dict[k] = v.strip()
25     return header_dict
26  
27  
28 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
29 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
30 sock.bind((‘127.0.0.1‘, 8002))
31 sock.listen(5)
32  
33 conn, address = sock.accept()
34 data = conn.recv(1024)
35 headers = get_headers(data) # 提取请求头信息
36 # 对请求头中的sec-websocket-key进行加密
37 response_tpl = "HTTP/1.1 101 Switching Protocols\r\n" 38       "Upgrade:websocket\r\n" 39       "Connection: Upgrade\r\n" 40       "Sec-WebSocket-Accept: %s\r\n" 41       "WebSocket-Location: ws://%s%s\r\n\r\n"
42 magic_string = ‘258EAFA5-E914-47DA-95CA-C5AB0DC85B11‘
43 value = headers[‘Sec-WebSocket-Key‘] + magic_string
44 ac = base64.b64encode(hashlib.sha1(value.encode(‘utf-8‘)).digest())
45 response_str = response_tpl % (ac.decode(‘utf-8‘), headers[‘Host‘], headers[‘url‘])
46 # 响应【握手】信息
47 conn.send(bytes(response_str, encoding=‘utf-8‘))
48 ...

 1 info = conn.recv(8096)
 2 
 3     payload_len = info[1] & 127
 4     if payload_len == 126:
 5         extend_payload_len = info[2:4]
 6         mask = info[4:8]
 7         decoded = info[8:]
 8     elif payload_len == 127:
 9         extend_payload_len = info[2:10]
10         mask = info[10:14]
11         decoded = info[14:]
12     else:
13         extend_payload_len = None
14         mask = info[2:6]
15         decoded = info[6:]
16 
17     bytes_list = bytearray()
18     for i in range(len(decoded)):
19         chunk = decoded[i] ^ mask[i % 4]
20         bytes_list.append(chunk)
21     body = str(bytes_list, encoding=‘utf-8‘)
22     print(body)
23 
24 基于Python实现解包过程（未实现长内容）

 1 0                   1                   2                   3
 2  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
 3 +-+-+-+-+-------+-+-------------+-------------------------------+
 4 |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
 5 |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
 6 |N|V|V|V|       |S|             |   (if payload len==126/127)   |
 7 | |1|2|3|       |K|             |                               |
 8 +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
 9 |     Extended payload length continued, if payload len == 127  |
10 + - - - - - - - - - - - - - - - +-------------------------------+
11 |                               |Masking-key, if MASK set to 1  |
12 +-------------------------------+-------------------------------+
13 | Masking-key (continued)       |          Payload Data         |
14 +-------------------------------- - - - - - - - - - - - - - - - +
15 :                     Payload Data continued ...                :
16 + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
17 |                     Payload Data continued ...                |
18 +---------------------------------------------------------------+

The MASK bit simply tells whether the message is encoded. Messages from the client must be masked, so your server should expect this to be 1. (In fact, section 5.1 of the spec says that your server must disconnect from a client if that client sends an unmasked message.) When sending a frame back to the client, do not mask it and do not set the mask bit. We‘ll explain masking later. Note: You have to mask messages even when using a secure socket.RSV1-3 can be ignored, they are for extensions.

The opcode field defines how to interpret the payload data: 0x0 for continuation, 0x1 for text (which is always encoded in UTF-8), 0x2 for binary, and other so-called "control codes" that will be discussed later. In this version of WebSockets, 0x3 to 0x7 and 0xB to 0xF have no meaning.

The FIN bit tells whether this is the last message in a series. If it‘s 0, then the server will keep listening for more parts of the message; otherwise, the server should consider the message delivered. More on this later.

Decoding Payload Length

To read the payload data, you must know when to stop reading. That‘s why the payload length is important to know. Unfortunately, this is somewhat complicated. To read it, follow these steps:

Read bits 9-15 (inclusive) and interpret that as an unsigned integer. If it‘s 125 or less, then that‘s the length; you‘re done. If it‘s 126, go to step 2. If it‘s 127, go to step 3.
Read the next 16 bits and interpret those as an unsigned integer. You‘re done.
Read the next 64 bits and interpret those as an unsigned integer (The most significant bit MUST be 0). You‘re done.
Reading and Unmasking the Data

If the MASK bit was set (and it should be, for client-to-server messages), read the next 4 octets (32 bits); this is the masking key. Once the payload length and masking key is decoded, you can go ahead and read that number of bytes from the socket. Let‘s call the data ENCODED, and the key MASK. To get DECODED, loop through the octets (bytes a.k.a. characters for text data) of ENCODED and XOR the octet with the (i modulo 4)th octet of MASK. In pseudo-code (that happens to be valid JavaScript):

 

var DECODED = "";
for (var i = 0; i < ENCODED.length; i++) {
    DECODED[i] = ENCODED[i] ^ MASK[i % 4];
}

 

Now you can figure out what DECODED means depending on your application.

 1 def send_msg(conn, msg_bytes):
 2     """
 3     WebSocket服务端向客户端发送消息
 4     :param conn: 客户端连接到服务器端的socket对象,即： conn,address = socket.accept()
 5     :param msg_bytes: 向客户端发送的字节
 6     :return: 
 7     """
 8     import struct
 9 
10     token = b"\x81"
11     length = len(msg_bytes)
12     if length < 126:
13         token += struct.pack("B", length)
14     elif length <= 0xFFFF:
15         token += struct.pack("!BH", 126, length)
16     else:
17         token += struct.pack("!BQ", 127, length)
18 
19     msg = token + msg_bytes
20     conn.send(msg)
21     return True