websocket分爲握手和數據傳輸階段，即進行了HTTP握手 + 雙工的TCP連接
RFC協議文檔在：http://tools.ietf.org/html/rfc6455
握手階段
握手階段就是普通的HTTP
客戶端發送消息：
|
1
2
3
4
5
6
7
|
GET /chat HTTP/1.1 Host: server.example.com Upgrade: websocket Connection: Upgrade Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ== Origin: http://example.com Sec-WebSocket-Version: 13 |
服務端返回消息：
|
1
2
3
4
|
HTTP/1.1 101 Switching ProtocolsUpgrade: websocketConnection: UpgradeSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo= |
這裏的Sec-WebSocket-Accept的計算方法是：
base64(hsa1(sec-websocket-key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11))
如果這個Sec-WebSocket-Accept計算錯誤瀏覽器會提示：
Sec-WebSocket-Accept dismatch
如果返回成功，Websocket就會回調onopen事件
數據傳輸
websocket的數據傳輸使用的協議是：
參數的具體說明在這：
FIN：1位，用來表明這是一個消息的最後的消息片斷，當然第一個消息片斷也可能是最後的一個消息片斷；
RSV1, RSV2, RSV3: 分別都是1位，如果雙方之間沒有約定自定義協議，那麼這幾位的值都必須爲0,否則必須斷掉WebSocket連接；
Opcode:4位操作碼，定義有效負載數據，如果收到了一個未知的操作碼，連接也必須斷掉，以下是定義的操作碼：
* %x0 表示連續消息片斷
* %x1 表示文本消息片斷
* %x2 表未二進制消息片斷
* %x3-7 爲將來的非控制消息片斷保留的操作碼
* %x8 表示連接關閉
* %x9 表示心跳檢查的ping
* %xA 表示心跳檢查的pong
* %xB-F 爲將來的控制消息片斷的保留操作碼
Mask:1位，定義傳輸的數據是否有加掩碼,如果設置爲1,掩碼鍵必須放在masking-key區域，客戶端發送給服務端的所有消息，此位的值都是1；
Payload length: 傳輸數據的長度，以字節的形式表示：7位、7+16位、或者7+64位。如果這個值以字節表示是0-125這個範圍，那這個值就表示傳輸數據的長度；如果這個值是126，則隨後的兩個字節表示的是一個16進制無符號數，用來表示傳輸數據的長度；如果這個值是127,則隨後的是8個字節表示的一個64位無符合數，這個數用來表示傳輸數據的長度。多字節長度的數量是以網絡字節的順序表示。負載數據的長度爲擴展數據及應用數據之和，擴展數據的長度可能爲0,因而此時負載數據的長度就爲應用數據的長度。
Masking-key:0或4個字節，客戶端發送給服務端的數據，都是通過內嵌的一個32位值作爲掩碼的；掩碼鍵只有在掩碼位設置爲1的時候存在。
Payload data: (x+y)位，負載數據爲擴展數據及應用數據長度之和。
Extension data:x位，如果客戶端與服務端之間沒有特殊約定，那麼擴展數據的長度始終爲0，任何的擴展都必須指定擴展數據的長度，或者長度的計算方式，以及在握手時如何確定正確的握手方式。如果存在擴展數據，則擴展數據就會包括在負載數據的長度之內。
Application data:y位，任意的應用數據，放在擴展數據之後，應用數據的長度=負載數據的長度-擴展數據的長度。
參考自http://blog.csdn.net/fenglibing/article/details/6852497
實例
具體使用go的實現例子：
客戶端：
html：
|
1
2
3
4
5
6
7
8
9
10
11
|
<html> <head> <script type="text/javascript"
src="./jquery.min.js"></script> </head> <body> <input type="button"
id="connect"
value="websocket connect"
/> <input type="button"
id="send"
value="websocket send"
/> <input type="button"
id="close"
value="websocket close"
/> </body> <script type="text/javascript"
src="./websocket.js"></script></html> |
js：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
var
socket;$("#connect").click(function(event){ socket.onopen =
function(){ alert("Socket has been opened"); } socket.onmessage =
function(msg){ alert(msg.data); } socket.onclose =
function() { alert("Socket has been closed"); }});$("#send").click(function(event){ socket.send("send from client");});$("#close").click(function(event){ socket.close();}) |
服務端：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
package mainimport( "net" "log" "strings" "crypto/sha1" "io" "encoding/base64" "errors")func main() { ln, err := net.Listen("tcp",
":8000") if
err != nil { log.Panic(err) } for
{ conn, err := ln.Accept() if
err != nil { log.Println("Accept err:", err) } for
{ handleConnection(conn) } }}func handleConnection(conn net.Conn) { content := make([]byte, 1024) _, err := conn.Read(content) log.Println(string(content)) if
err != nil { log.Println(err) } isHttp := false // 先暫時這麼判斷 if
string(content[0:3]) == "GET"
{ isHttp = true; } log.Println("isHttp:", isHttp) if
isHttp { headers := parseHandshake(string(content)) log.Println("headers", headers) secWebsocketKey := headers["Sec-WebSocket-Key"] // NOTE：這裏省略其他的驗證 guid :=
"258EAFA5-E914-47DA-95CA-C5AB0DC85B11" // 計算Sec-WebSocket-Accept h := sha1.New() log.Println("accept raw:", secWebsocketKey + guid) io.WriteString(h, secWebsocketKey + guid) accept := make([]byte, 28) base64.StdEncoding.Encode(accept, h.Sum(nil)) log.Println(string(accept)) response :=
"HTTP/1.1 101 Switching Protocols\r\n" response = response +
"Sec-WebSocket-Accept: "
+ string(accept) + "\r\n" response = response +
"Connection: Upgrade\r\n" response = response +
"Upgrade: websocket\r\n\r\n" log.Println("response:", response) if
lenth, err := conn.Write([]byte(response)); err != nil { log.Println(err) }
else { log.Println("send len:", lenth) } wssocket := NewWsSocket(conn) for
{ data, err := wssocket.ReadIframe() if
err != nil { log.Println("readIframe err:"
, err) } log.Println("read data:", string(data)) err = wssocket.SendIframe([]byte("good")) if
err != nil { log.Println("sendIframe err:"
, err) } log.Println("send data") } }
else { log.Println(string(content)) // 直接讀取 }}type WsSocket struct { MaskingKey []byte Conn net.Conn}func NewWsSocket(conn net.Conn) *WsSocket { return
&WsSocket{Conn: conn}}func (this *WsSocket)SendIframe(data []byte) error { // 這裏只處理data長度<125的 if
len(data) >= 125 { return
errors.New("send iframe data error") } lenth := len(data) maskedData := make([]byte, lenth) for
i := 0; i < lenth; i++ { if
this.MaskingKey != nil { maskedData[i] = data[i] ^ this.MaskingKey[i % 4] }
else { maskedData[i] = data[i] } } this.Conn.Write([]byte{0x81}) var
payLenByte byte if
this.MaskingKey != nil && len(this.MaskingKey) != 4 { payLenByte = byte(0x80) | byte(lenth) this.Conn.Write([]byte{payLenByte}) this.Conn.Write(this.MaskingKey) }
else { payLenByte = byte(0x00) | byte(lenth) this.Conn.Write([]byte{payLenByte}) } this.Conn.Write(data) return
nil}func (this *WsSocket)ReadIframe() (data []byte, err error){ err = nil //第一個字節：FIN + RSV1-3 + OPCODE opcodeByte := make([]byte, 1) this.Conn.Read(opcodeByte) FIN := opcodeByte[0] >> 7 RSV1 := opcodeByte[0] >> 6 & 1 RSV2 := opcodeByte[0] >> 5 & 1 RSV3 := opcodeByte[0] >> 4 & 1 OPCODE := opcodeByte[0] & 15 log.Println(RSV1,RSV2,RSV3,OPCODE) payloadLenByte := make([]byte, 1) this.Conn.Read(payloadLenByte) payloadLen := int(payloadLenByte[0] & 0x7F) mask := payloadLenByte[0] >> 7 if
payloadLen == 127 { extendedByte := make([]byte, 8) this.Conn.Read(extendedByte) } maskingByte := make([]byte, 4) if
mask == 1 { this.Conn.Read(maskingByte) this.MaskingKey = maskingByte } payloadDataByte := make([]byte, payloadLen) this.Conn.Read(payloadDataByte) log.Println("data:", payloadDataByte) dataByte := make([]byte, payloadLen) for
i := 0; i < payloadLen; i++ { if
mask == 1 { dataByte[i] = payloadDataByte[i] ^ maskingByte[i % 4] }
else { dataByte[i] = payloadDataByte[i] } } if
FIN == 1 { data = dataByte return } nextData, err := this.ReadIframe() if
err != nil { return } data = append(data, nextData…) return}func parseHandshake(content string) map[string]string { headers := make(map[string]string, 10) lines := strings.Split(content,
"\r\n") for
_,line := range lines { if
len(line) >= 0 { words := strings.Split(line,
":") if
len(words) == 2 { headers[strings.Trim(words[0]," ")] = strings.Trim(words[1],
" ") } } } return
headers} |
後話
PS：後來發現官方也有實現了websocket，只是它不是在pkg下，而是在net的branch下
強烈建議使用官方的websocket，不要自己寫
https://code.google.com/p/go.net/
當然如果自己實現了一遍協議，看官方的包自然會更清晰了。
轉載地址：http://www.cnblogs.com/yjf512/archive/2013/02/18/2915171.html
