Update vendored go.net to use golang.org/x/net canonical path
Signed-off-by: Tibor Vass <tibor@docker.com> Upstream-commit: d820e00aac2376d4e01721557b9af5e482ec89cd Component: engine
This commit is contained in:
@@ -1,112 +0,0 @@
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/tls"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
)
|
||||
|
||||
// DialError is an error that occurs while dialling a websocket server.
|
||||
type DialError struct {
|
||||
*Config
|
||||
Err error
|
||||
}
|
||||
|
||||
func (e *DialError) Error() string {
|
||||
return "websocket.Dial " + e.Config.Location.String() + ": " + e.Err.Error()
|
||||
}
|
||||
|
||||
// NewConfig creates a new WebSocket config for client connection.
|
||||
func NewConfig(server, origin string) (config *Config, err error) {
|
||||
config = new(Config)
|
||||
config.Version = ProtocolVersionHybi13
|
||||
config.Location, err = url.ParseRequestURI(server)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
config.Origin, err = url.ParseRequestURI(origin)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
config.Header = http.Header(make(map[string][]string))
|
||||
return
|
||||
}
|
||||
|
||||
// NewClient creates a new WebSocket client connection over rwc.
|
||||
func NewClient(config *Config, rwc io.ReadWriteCloser) (ws *Conn, err error) {
|
||||
br := bufio.NewReader(rwc)
|
||||
bw := bufio.NewWriter(rwc)
|
||||
switch config.Version {
|
||||
case ProtocolVersionHixie75:
|
||||
err = hixie75ClientHandshake(config, br, bw)
|
||||
case ProtocolVersionHixie76, ProtocolVersionHybi00:
|
||||
err = hixie76ClientHandshake(config, br, bw)
|
||||
case ProtocolVersionHybi08, ProtocolVersionHybi13:
|
||||
err = hybiClientHandshake(config, br, bw)
|
||||
default:
|
||||
err = ErrBadProtocolVersion
|
||||
}
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
buf := bufio.NewReadWriter(br, bw)
|
||||
switch config.Version {
|
||||
case ProtocolVersionHixie75, ProtocolVersionHixie76, ProtocolVersionHybi00:
|
||||
ws = newHixieClientConn(config, buf, rwc)
|
||||
case ProtocolVersionHybi08, ProtocolVersionHybi13:
|
||||
ws = newHybiClientConn(config, buf, rwc)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Dial opens a new client connection to a WebSocket.
|
||||
func Dial(url_, protocol, origin string) (ws *Conn, err error) {
|
||||
config, err := NewConfig(url_, origin)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if protocol != "" {
|
||||
config.Protocol = []string{protocol}
|
||||
}
|
||||
return DialConfig(config)
|
||||
}
|
||||
|
||||
// DialConfig opens a new client connection to a WebSocket with a config.
|
||||
func DialConfig(config *Config) (ws *Conn, err error) {
|
||||
var client net.Conn
|
||||
if config.Location == nil {
|
||||
return nil, &DialError{config, ErrBadWebSocketLocation}
|
||||
}
|
||||
if config.Origin == nil {
|
||||
return nil, &DialError{config, ErrBadWebSocketOrigin}
|
||||
}
|
||||
switch config.Location.Scheme {
|
||||
case "ws":
|
||||
client, err = net.Dial("tcp", config.Location.Host)
|
||||
|
||||
case "wss":
|
||||
client, err = tls.Dial("tcp", config.Location.Host, config.TlsConfig)
|
||||
|
||||
default:
|
||||
err = ErrBadScheme
|
||||
}
|
||||
if err != nil {
|
||||
goto Error
|
||||
}
|
||||
|
||||
ws, err = NewClient(config, client)
|
||||
if err != nil {
|
||||
goto Error
|
||||
}
|
||||
return
|
||||
|
||||
Error:
|
||||
return nil, &DialError{config, err}
|
||||
}
|
||||
@@ -1,695 +0,0 @@
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package websocket
|
||||
|
||||
// This file implements a protocol of Hixie draft version 75 and 76
|
||||
// (draft 76 equals to hybi 00)
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"crypto/md5"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// An array of characters to be randomly inserted to construct Sec-WebSocket-Key
|
||||
// value. It holds characters from ranges U+0021 to U+002F and U+003A to U+007E.
|
||||
// See Step 21 in Section 4.1 Opening handshake.
|
||||
// http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00#page-22
|
||||
var secKeyRandomChars [0x30 - 0x21 + 0x7F - 0x3A]byte
|
||||
|
||||
func init() {
|
||||
i := 0
|
||||
for ch := byte(0x21); ch < 0x30; ch++ {
|
||||
secKeyRandomChars[i] = ch
|
||||
i++
|
||||
}
|
||||
for ch := byte(0x3a); ch < 0x7F; ch++ {
|
||||
secKeyRandomChars[i] = ch
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
type byteReader interface {
|
||||
ReadByte() (byte, error)
|
||||
}
|
||||
|
||||
// readHixieLength reads frame length for frame type 0x80-0xFF
|
||||
// as defined in Hixie draft.
|
||||
// See section 4.2 Data framing.
|
||||
// http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00#section-4.2
|
||||
func readHixieLength(r byteReader) (length int64, lengthFields []byte, err error) {
|
||||
for {
|
||||
c, err := r.ReadByte()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
lengthFields = append(lengthFields, c)
|
||||
length = length*128 + int64(c&0x7f)
|
||||
if c&0x80 == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// A hixieLengthFrameReader is a reader for frame type 0x80-0xFF
|
||||
// as defined in hixie draft.
|
||||
type hixieLengthFrameReader struct {
|
||||
reader io.Reader
|
||||
FrameType byte
|
||||
Length int64
|
||||
header *bytes.Buffer
|
||||
length int
|
||||
}
|
||||
|
||||
func (frame *hixieLengthFrameReader) Read(msg []byte) (n int, err error) {
|
||||
return frame.reader.Read(msg)
|
||||
}
|
||||
|
||||
func (frame *hixieLengthFrameReader) PayloadType() byte {
|
||||
if frame.FrameType == '\xff' && frame.Length == 0 {
|
||||
return CloseFrame
|
||||
}
|
||||
return UnknownFrame
|
||||
}
|
||||
|
||||
func (frame *hixieLengthFrameReader) HeaderReader() io.Reader {
|
||||
if frame.header == nil {
|
||||
return nil
|
||||
}
|
||||
if frame.header.Len() == 0 {
|
||||
frame.header = nil
|
||||
return nil
|
||||
}
|
||||
return frame.header
|
||||
}
|
||||
|
||||
func (frame *hixieLengthFrameReader) TrailerReader() io.Reader { return nil }
|
||||
|
||||
func (frame *hixieLengthFrameReader) Len() (n int) { return frame.length }
|
||||
|
||||
// A HixieSentinelFrameReader is a reader for frame type 0x00-0x7F
|
||||
// as defined in hixie draft.
|
||||
type hixieSentinelFrameReader struct {
|
||||
reader *bufio.Reader
|
||||
FrameType byte
|
||||
header *bytes.Buffer
|
||||
data []byte
|
||||
seenTrailer bool
|
||||
trailer *bytes.Buffer
|
||||
}
|
||||
|
||||
func (frame *hixieSentinelFrameReader) Read(msg []byte) (n int, err error) {
|
||||
if len(frame.data) == 0 {
|
||||
if frame.seenTrailer {
|
||||
return 0, io.EOF
|
||||
}
|
||||
frame.data, err = frame.reader.ReadSlice('\xff')
|
||||
if err == nil {
|
||||
frame.seenTrailer = true
|
||||
frame.data = frame.data[:len(frame.data)-1] // trim \xff
|
||||
frame.trailer = bytes.NewBuffer([]byte{0xff})
|
||||
}
|
||||
}
|
||||
n = copy(msg, frame.data)
|
||||
frame.data = frame.data[n:]
|
||||
return n, err
|
||||
}
|
||||
|
||||
func (frame *hixieSentinelFrameReader) PayloadType() byte {
|
||||
if frame.FrameType == 0 {
|
||||
return TextFrame
|
||||
}
|
||||
return UnknownFrame
|
||||
}
|
||||
|
||||
func (frame *hixieSentinelFrameReader) HeaderReader() io.Reader {
|
||||
if frame.header == nil {
|
||||
return nil
|
||||
}
|
||||
if frame.header.Len() == 0 {
|
||||
frame.header = nil
|
||||
return nil
|
||||
}
|
||||
return frame.header
|
||||
}
|
||||
|
||||
func (frame *hixieSentinelFrameReader) TrailerReader() io.Reader {
|
||||
if frame.trailer == nil {
|
||||
return nil
|
||||
}
|
||||
if frame.trailer.Len() == 0 {
|
||||
frame.trailer = nil
|
||||
return nil
|
||||
}
|
||||
return frame.trailer
|
||||
}
|
||||
|
||||
func (frame *hixieSentinelFrameReader) Len() int { return -1 }
|
||||
|
||||
// A HixieFrameReaderFactory creates new frame reader based on its frame type.
|
||||
type hixieFrameReaderFactory struct {
|
||||
*bufio.Reader
|
||||
}
|
||||
|
||||
func (buf hixieFrameReaderFactory) NewFrameReader() (r frameReader, err error) {
|
||||
var header []byte
|
||||
var b byte
|
||||
b, err = buf.ReadByte()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
header = append(header, b)
|
||||
if b&0x80 == 0x80 {
|
||||
length, lengthFields, err := readHixieLength(buf.Reader)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if length == 0 {
|
||||
return nil, io.EOF
|
||||
}
|
||||
header = append(header, lengthFields...)
|
||||
return &hixieLengthFrameReader{
|
||||
reader: io.LimitReader(buf.Reader, length),
|
||||
FrameType: b,
|
||||
Length: length,
|
||||
header: bytes.NewBuffer(header)}, err
|
||||
}
|
||||
return &hixieSentinelFrameReader{
|
||||
reader: buf.Reader,
|
||||
FrameType: b,
|
||||
header: bytes.NewBuffer(header)}, err
|
||||
}
|
||||
|
||||
type hixiFrameWriter struct {
|
||||
writer *bufio.Writer
|
||||
}
|
||||
|
||||
func (frame *hixiFrameWriter) Write(msg []byte) (n int, err error) {
|
||||
frame.writer.WriteByte(0)
|
||||
frame.writer.Write(msg)
|
||||
frame.writer.WriteByte(0xff)
|
||||
err = frame.writer.Flush()
|
||||
return len(msg), err
|
||||
}
|
||||
|
||||
func (frame *hixiFrameWriter) Close() error { return nil }
|
||||
|
||||
type hixiFrameWriterFactory struct {
|
||||
*bufio.Writer
|
||||
}
|
||||
|
||||
func (buf hixiFrameWriterFactory) NewFrameWriter(payloadType byte) (frame frameWriter, err error) {
|
||||
if payloadType != TextFrame {
|
||||
return nil, ErrNotSupported
|
||||
}
|
||||
return &hixiFrameWriter{writer: buf.Writer}, nil
|
||||
}
|
||||
|
||||
type hixiFrameHandler struct {
|
||||
conn *Conn
|
||||
}
|
||||
|
||||
func (handler *hixiFrameHandler) HandleFrame(frame frameReader) (r frameReader, err error) {
|
||||
if header := frame.HeaderReader(); header != nil {
|
||||
io.Copy(ioutil.Discard, header)
|
||||
}
|
||||
if frame.PayloadType() != TextFrame {
|
||||
io.Copy(ioutil.Discard, frame)
|
||||
return nil, nil
|
||||
}
|
||||
return frame, nil
|
||||
}
|
||||
|
||||
func (handler *hixiFrameHandler) WriteClose(_ int) (err error) {
|
||||
handler.conn.wio.Lock()
|
||||
defer handler.conn.wio.Unlock()
|
||||
closingFrame := []byte{'\xff', '\x00'}
|
||||
handler.conn.buf.Write(closingFrame)
|
||||
return handler.conn.buf.Flush()
|
||||
}
|
||||
|
||||
// newHixiConn creates a new WebSocket connection speaking hixie draft protocol.
|
||||
func newHixieConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
|
||||
if buf == nil {
|
||||
br := bufio.NewReader(rwc)
|
||||
bw := bufio.NewWriter(rwc)
|
||||
buf = bufio.NewReadWriter(br, bw)
|
||||
}
|
||||
ws := &Conn{config: config, request: request, buf: buf, rwc: rwc,
|
||||
frameReaderFactory: hixieFrameReaderFactory{buf.Reader},
|
||||
frameWriterFactory: hixiFrameWriterFactory{buf.Writer},
|
||||
PayloadType: TextFrame}
|
||||
ws.frameHandler = &hixiFrameHandler{ws}
|
||||
return ws
|
||||
}
|
||||
|
||||
// getChallengeResponse computes the expected response from the
|
||||
// challenge as described in section 5.1 Opening Handshake steps 42 to
|
||||
// 43 of http://www.whatwg.org/specs/web-socket-protocol/
|
||||
func getChallengeResponse(number1, number2 uint32, key3 []byte) (expected []byte, err error) {
|
||||
// 41. Let /challenge/ be the concatenation of /number_1/, expressed
|
||||
// a big-endian 32 bit integer, /number_2/, expressed in a big-
|
||||
// endian 32 bit integer, and the eight bytes of /key_3/ in the
|
||||
// order they were sent to the wire.
|
||||
challenge := make([]byte, 16)
|
||||
binary.BigEndian.PutUint32(challenge[0:], number1)
|
||||
binary.BigEndian.PutUint32(challenge[4:], number2)
|
||||
copy(challenge[8:], key3)
|
||||
|
||||
// 42. Let /expected/ be the MD5 fingerprint of /challenge/ as a big-
|
||||
// endian 128 bit string.
|
||||
h := md5.New()
|
||||
if _, err = h.Write(challenge); err != nil {
|
||||
return
|
||||
}
|
||||
expected = h.Sum(nil)
|
||||
return
|
||||
}
|
||||
|
||||
// Generates handshake key as described in 4.1 Opening handshake step 16 to 22.
|
||||
// cf. http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00
|
||||
func generateKeyNumber() (key string, number uint32) {
|
||||
// 16. Let /spaces_n/ be a random integer from 1 to 12 inclusive.
|
||||
spaces := rand.Intn(12) + 1
|
||||
|
||||
// 17. Let /max_n/ be the largest integer not greater than
|
||||
// 4,294,967,295 divided by /spaces_n/
|
||||
max := int(4294967295 / uint32(spaces))
|
||||
|
||||
// 18. Let /number_n/ be a random integer from 0 to /max_n/ inclusive.
|
||||
number = uint32(rand.Intn(max + 1))
|
||||
|
||||
// 19. Let /product_n/ be the result of multiplying /number_n/ and
|
||||
// /spaces_n/ together.
|
||||
product := number * uint32(spaces)
|
||||
|
||||
// 20. Let /key_n/ be a string consisting of /product_n/, expressed
|
||||
// in base ten using the numerals in the range U+0030 DIGIT ZERO (0)
|
||||
// to U+0039 DIGIT NINE (9).
|
||||
key = fmt.Sprintf("%d", product)
|
||||
|
||||
// 21. Insert between one and twelve random characters from the ranges
|
||||
// U+0021 to U+002F and U+003A to U+007E into /key_n/ at random
|
||||
// positions.
|
||||
n := rand.Intn(12) + 1
|
||||
for i := 0; i < n; i++ {
|
||||
pos := rand.Intn(len(key)) + 1
|
||||
ch := secKeyRandomChars[rand.Intn(len(secKeyRandomChars))]
|
||||
key = key[0:pos] + string(ch) + key[pos:]
|
||||
}
|
||||
|
||||
// 22. Insert /spaces_n/ U+0020 SPACE characters into /key_n/ at random
|
||||
// positions other than the start or end of the string.
|
||||
for i := 0; i < spaces; i++ {
|
||||
pos := rand.Intn(len(key)-1) + 1
|
||||
key = key[0:pos] + " " + key[pos:]
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Generates handshake key_3 as described in 4.1 Opening handshake step 26.
|
||||
// cf. http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00
|
||||
func generateKey3() (key []byte) {
|
||||
// 26. Let /key3/ be a string consisting of eight random bytes (or
|
||||
// equivalently, a random 64 bit integer encoded in big-endian order).
|
||||
key = make([]byte, 8)
|
||||
for i := 0; i < 8; i++ {
|
||||
key[i] = byte(rand.Intn(256))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Client handshake described in (soon obsolete)
|
||||
// draft-ietf-hybi-thewebsocket-protocol-00
|
||||
// (draft-hixie-thewebsocket-protocol-76)
|
||||
func hixie76ClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
|
||||
switch config.Version {
|
||||
case ProtocolVersionHixie76, ProtocolVersionHybi00:
|
||||
default:
|
||||
panic("wrong protocol version.")
|
||||
}
|
||||
// 4.1. Opening handshake.
|
||||
// Step 5. send a request line.
|
||||
bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")
|
||||
|
||||
// Step 6-14. push request headers in fields.
|
||||
fields := []string{
|
||||
"Upgrade: WebSocket\r\n",
|
||||
"Connection: Upgrade\r\n",
|
||||
"Host: " + config.Location.Host + "\r\n",
|
||||
"Origin: " + config.Origin.String() + "\r\n",
|
||||
}
|
||||
if len(config.Protocol) > 0 {
|
||||
if len(config.Protocol) != 1 {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
fields = append(fields, "Sec-WebSocket-Protocol: "+config.Protocol[0]+"\r\n")
|
||||
}
|
||||
// TODO(ukai): Step 15. send cookie if any.
|
||||
|
||||
// Step 16-23. generate keys and push Sec-WebSocket-Key<n> in fields.
|
||||
key1, number1 := generateKeyNumber()
|
||||
key2, number2 := generateKeyNumber()
|
||||
if config.handshakeData != nil {
|
||||
key1 = config.handshakeData["key1"]
|
||||
n, err := strconv.ParseUint(config.handshakeData["number1"], 10, 32)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
number1 = uint32(n)
|
||||
key2 = config.handshakeData["key2"]
|
||||
n, err = strconv.ParseUint(config.handshakeData["number2"], 10, 32)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
number2 = uint32(n)
|
||||
}
|
||||
fields = append(fields, "Sec-WebSocket-Key1: "+key1+"\r\n")
|
||||
fields = append(fields, "Sec-WebSocket-Key2: "+key2+"\r\n")
|
||||
|
||||
// Step 24. shuffle fields and send them out.
|
||||
for i := 1; i < len(fields); i++ {
|
||||
j := rand.Intn(i)
|
||||
fields[i], fields[j] = fields[j], fields[i]
|
||||
}
|
||||
for i := 0; i < len(fields); i++ {
|
||||
bw.WriteString(fields[i])
|
||||
}
|
||||
// Step 25. send CRLF.
|
||||
bw.WriteString("\r\n")
|
||||
|
||||
// Step 26. generate 8 bytes random key.
|
||||
key3 := generateKey3()
|
||||
if config.handshakeData != nil {
|
||||
key3 = []byte(config.handshakeData["key3"])
|
||||
}
|
||||
// Step 27. send it out.
|
||||
bw.Write(key3)
|
||||
if err = bw.Flush(); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Step 28-29, 32-40. read response from server.
|
||||
resp, err := http.ReadResponse(br, &http.Request{Method: "GET"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Step 30. check response code is 101.
|
||||
if resp.StatusCode != 101 {
|
||||
return ErrBadStatus
|
||||
}
|
||||
|
||||
// Step 41. check websocket headers.
|
||||
if resp.Header.Get("Upgrade") != "WebSocket" ||
|
||||
strings.ToLower(resp.Header.Get("Connection")) != "upgrade" {
|
||||
return ErrBadUpgrade
|
||||
}
|
||||
|
||||
if resp.Header.Get("Sec-Websocket-Origin") != config.Origin.String() {
|
||||
return ErrBadWebSocketOrigin
|
||||
}
|
||||
|
||||
if resp.Header.Get("Sec-Websocket-Location") != config.Location.String() {
|
||||
return ErrBadWebSocketLocation
|
||||
}
|
||||
|
||||
if len(config.Protocol) > 0 && resp.Header.Get("Sec-Websocket-Protocol") != config.Protocol[0] {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
|
||||
// Step 42-43. get expected data from challenge data.
|
||||
expected, err := getChallengeResponse(number1, number2, key3)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Step 44. read 16 bytes from server.
|
||||
reply := make([]byte, 16)
|
||||
if _, err = io.ReadFull(br, reply); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Step 45. check the reply equals to expected data.
|
||||
if !bytes.Equal(expected, reply) {
|
||||
return ErrChallengeResponse
|
||||
}
|
||||
// WebSocket connection is established.
|
||||
return
|
||||
}
|
||||
|
||||
// Client Handshake described in (soon obsolete)
|
||||
// draft-hixie-thewebsocket-protocol-75.
|
||||
func hixie75ClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
|
||||
if config.Version != ProtocolVersionHixie75 {
|
||||
panic("wrong protocol version.")
|
||||
}
|
||||
bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")
|
||||
bw.WriteString("Upgrade: WebSocket\r\n")
|
||||
bw.WriteString("Connection: Upgrade\r\n")
|
||||
bw.WriteString("Host: " + config.Location.Host + "\r\n")
|
||||
bw.WriteString("Origin: " + config.Origin.String() + "\r\n")
|
||||
if len(config.Protocol) > 0 {
|
||||
if len(config.Protocol) != 1 {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
bw.WriteString("WebSocket-Protocol: " + config.Protocol[0] + "\r\n")
|
||||
}
|
||||
bw.WriteString("\r\n")
|
||||
bw.Flush()
|
||||
resp, err := http.ReadResponse(br, &http.Request{Method: "GET"})
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if resp.Status != "101 Web Socket Protocol Handshake" {
|
||||
return ErrBadStatus
|
||||
}
|
||||
if resp.Header.Get("Upgrade") != "WebSocket" ||
|
||||
resp.Header.Get("Connection") != "Upgrade" {
|
||||
return ErrBadUpgrade
|
||||
}
|
||||
if resp.Header.Get("Websocket-Origin") != config.Origin.String() {
|
||||
return ErrBadWebSocketOrigin
|
||||
}
|
||||
if resp.Header.Get("Websocket-Location") != config.Location.String() {
|
||||
return ErrBadWebSocketLocation
|
||||
}
|
||||
if len(config.Protocol) > 0 && resp.Header.Get("Websocket-Protocol") != config.Protocol[0] {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// newHixieClientConn returns new WebSocket connection speaking hixie draft protocol.
|
||||
func newHixieClientConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser) *Conn {
|
||||
return newHixieConn(config, buf, rwc, nil)
|
||||
}
|
||||
|
||||
// Gets key number from Sec-WebSocket-Key<n>: field as described
|
||||
// in 5.2 Sending the server's opening handshake, 4.
|
||||
func getKeyNumber(s string) (r uint32) {
|
||||
// 4. Let /key-number_n/ be the digits (characters in the range
|
||||
// U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9)) in /key_1/,
|
||||
// interpreted as a base ten integer, ignoring all other characters
|
||||
// in /key_n/.
|
||||
r = 0
|
||||
for i := 0; i < len(s); i++ {
|
||||
if s[i] >= '0' && s[i] <= '9' {
|
||||
r = r*10 + uint32(s[i]) - '0'
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// A Hixie76ServerHandshaker performs a server handshake using
|
||||
// hixie draft 76 protocol.
|
||||
type hixie76ServerHandshaker struct {
|
||||
*Config
|
||||
challengeResponse []byte
|
||||
}
|
||||
|
||||
func (c *hixie76ServerHandshaker) ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error) {
|
||||
c.Version = ProtocolVersionHybi00
|
||||
if req.Method != "GET" {
|
||||
return http.StatusMethodNotAllowed, ErrBadRequestMethod
|
||||
}
|
||||
// HTTP version can be safely ignored.
|
||||
|
||||
if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
|
||||
strings.ToLower(req.Header.Get("Connection")) != "upgrade" {
|
||||
return http.StatusBadRequest, ErrNotWebSocket
|
||||
}
|
||||
|
||||
// TODO(ukai): check Host
|
||||
c.Origin, err = url.ParseRequestURI(req.Header.Get("Origin"))
|
||||
if err != nil {
|
||||
return http.StatusBadRequest, err
|
||||
}
|
||||
|
||||
key1 := req.Header.Get("Sec-Websocket-Key1")
|
||||
if key1 == "" {
|
||||
return http.StatusBadRequest, ErrChallengeResponse
|
||||
}
|
||||
key2 := req.Header.Get("Sec-Websocket-Key2")
|
||||
if key2 == "" {
|
||||
return http.StatusBadRequest, ErrChallengeResponse
|
||||
}
|
||||
key3 := make([]byte, 8)
|
||||
if _, err := io.ReadFull(buf, key3); err != nil {
|
||||
return http.StatusBadRequest, ErrChallengeResponse
|
||||
}
|
||||
|
||||
var scheme string
|
||||
if req.TLS != nil {
|
||||
scheme = "wss"
|
||||
} else {
|
||||
scheme = "ws"
|
||||
}
|
||||
c.Location, err = url.ParseRequestURI(scheme + "://" + req.Host + req.URL.RequestURI())
|
||||
if err != nil {
|
||||
return http.StatusBadRequest, err
|
||||
}
|
||||
|
||||
// Step 4. get key number in Sec-WebSocket-Key<n> fields.
|
||||
keyNumber1 := getKeyNumber(key1)
|
||||
keyNumber2 := getKeyNumber(key2)
|
||||
|
||||
// Step 5. get number of spaces in Sec-WebSocket-Key<n> fields.
|
||||
space1 := uint32(strings.Count(key1, " "))
|
||||
space2 := uint32(strings.Count(key2, " "))
|
||||
if space1 == 0 || space2 == 0 {
|
||||
return http.StatusBadRequest, ErrChallengeResponse
|
||||
}
|
||||
|
||||
// Step 6. key number must be an integral multiple of spaces.
|
||||
if keyNumber1%space1 != 0 || keyNumber2%space2 != 0 {
|
||||
return http.StatusBadRequest, ErrChallengeResponse
|
||||
}
|
||||
|
||||
// Step 7. let part be key number divided by spaces.
|
||||
part1 := keyNumber1 / space1
|
||||
part2 := keyNumber2 / space2
|
||||
|
||||
// Step 8. let challenge be concatenation of part1, part2 and key3.
|
||||
// Step 9. get MD5 fingerprint of challenge.
|
||||
c.challengeResponse, err = getChallengeResponse(part1, part2, key3)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
protocol := strings.TrimSpace(req.Header.Get("Sec-Websocket-Protocol"))
|
||||
protocols := strings.Split(protocol, ",")
|
||||
for i := 0; i < len(protocols); i++ {
|
||||
c.Protocol = append(c.Protocol, strings.TrimSpace(protocols[i]))
|
||||
}
|
||||
|
||||
return http.StatusSwitchingProtocols, nil
|
||||
}
|
||||
|
||||
func (c *hixie76ServerHandshaker) AcceptHandshake(buf *bufio.Writer) (err error) {
|
||||
if len(c.Protocol) > 0 {
|
||||
if len(c.Protocol) != 1 {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
}
|
||||
|
||||
// Step 10. send response status line.
|
||||
buf.WriteString("HTTP/1.1 101 WebSocket Protocol Handshake\r\n")
|
||||
// Step 11. send response headers.
|
||||
buf.WriteString("Upgrade: WebSocket\r\n")
|
||||
buf.WriteString("Connection: Upgrade\r\n")
|
||||
buf.WriteString("Sec-WebSocket-Origin: " + c.Origin.String() + "\r\n")
|
||||
buf.WriteString("Sec-WebSocket-Location: " + c.Location.String() + "\r\n")
|
||||
if len(c.Protocol) > 0 {
|
||||
buf.WriteString("Sec-WebSocket-Protocol: " + c.Protocol[0] + "\r\n")
|
||||
}
|
||||
// Step 12. send CRLF.
|
||||
buf.WriteString("\r\n")
|
||||
// Step 13. send response data.
|
||||
buf.Write(c.challengeResponse)
|
||||
return buf.Flush()
|
||||
}
|
||||
|
||||
func (c *hixie76ServerHandshaker) NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) (conn *Conn) {
|
||||
return newHixieServerConn(c.Config, buf, rwc, request)
|
||||
}
|
||||
|
||||
// A hixie75ServerHandshaker performs a server handshake using
|
||||
// hixie draft 75 protocol.
|
||||
type hixie75ServerHandshaker struct {
|
||||
*Config
|
||||
}
|
||||
|
||||
func (c *hixie75ServerHandshaker) ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error) {
|
||||
c.Version = ProtocolVersionHixie75
|
||||
if req.Method != "GET" || req.Proto != "HTTP/1.1" {
|
||||
return http.StatusMethodNotAllowed, ErrBadRequestMethod
|
||||
}
|
||||
if req.Header.Get("Upgrade") != "WebSocket" {
|
||||
return http.StatusBadRequest, ErrNotWebSocket
|
||||
}
|
||||
if req.Header.Get("Connection") != "Upgrade" {
|
||||
return http.StatusBadRequest, ErrNotWebSocket
|
||||
}
|
||||
c.Origin, err = url.ParseRequestURI(strings.TrimSpace(req.Header.Get("Origin")))
|
||||
if err != nil {
|
||||
return http.StatusBadRequest, err
|
||||
}
|
||||
|
||||
var scheme string
|
||||
if req.TLS != nil {
|
||||
scheme = "wss"
|
||||
} else {
|
||||
scheme = "ws"
|
||||
}
|
||||
c.Location, err = url.ParseRequestURI(scheme + "://" + req.Host + req.URL.RequestURI())
|
||||
if err != nil {
|
||||
return http.StatusBadRequest, err
|
||||
}
|
||||
protocol := strings.TrimSpace(req.Header.Get("Websocket-Protocol"))
|
||||
protocols := strings.Split(protocol, ",")
|
||||
for i := 0; i < len(protocols); i++ {
|
||||
c.Protocol = append(c.Protocol, strings.TrimSpace(protocols[i]))
|
||||
}
|
||||
|
||||
return http.StatusSwitchingProtocols, nil
|
||||
}
|
||||
|
||||
func (c *hixie75ServerHandshaker) AcceptHandshake(buf *bufio.Writer) (err error) {
|
||||
if len(c.Protocol) > 0 {
|
||||
if len(c.Protocol) != 1 {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
}
|
||||
|
||||
buf.WriteString("HTTP/1.1 101 Web Socket Protocol Handshake\r\n")
|
||||
buf.WriteString("Upgrade: WebSocket\r\n")
|
||||
buf.WriteString("Connection: Upgrade\r\n")
|
||||
buf.WriteString("WebSocket-Origin: " + c.Origin.String() + "\r\n")
|
||||
buf.WriteString("WebSocket-Location: " + c.Location.String() + "\r\n")
|
||||
if len(c.Protocol) > 0 {
|
||||
buf.WriteString("WebSocket-Protocol: " + c.Protocol[0] + "\r\n")
|
||||
}
|
||||
buf.WriteString("\r\n")
|
||||
return buf.Flush()
|
||||
}
|
||||
|
||||
func (c *hixie75ServerHandshaker) NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) (conn *Conn) {
|
||||
return newHixieServerConn(c.Config, buf, rwc, request)
|
||||
}
|
||||
|
||||
// newHixieServerConn returns a new WebSocket connection speaking hixie draft protocol.
|
||||
func newHixieServerConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
|
||||
return newHixieConn(config, buf, rwc, request)
|
||||
}
|
||||
@@ -1,580 +0,0 @@
|
||||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package websocket
|
||||
|
||||
// This file implements a protocol of hybi draft.
|
||||
// http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"crypto/rand"
|
||||
"crypto/sha1"
|
||||
"encoding/base64"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
websocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||||
|
||||
closeStatusNormal = 1000
|
||||
closeStatusGoingAway = 1001
|
||||
closeStatusProtocolError = 1002
|
||||
closeStatusUnsupportedData = 1003
|
||||
closeStatusFrameTooLarge = 1004
|
||||
closeStatusNoStatusRcvd = 1005
|
||||
closeStatusAbnormalClosure = 1006
|
||||
closeStatusBadMessageData = 1007
|
||||
closeStatusPolicyViolation = 1008
|
||||
closeStatusTooBigData = 1009
|
||||
closeStatusExtensionMismatch = 1010
|
||||
|
||||
maxControlFramePayloadLength = 125
|
||||
)
|
||||
|
||||
var (
|
||||
ErrBadMaskingKey = &ProtocolError{"bad masking key"}
|
||||
ErrBadPongMessage = &ProtocolError{"bad pong message"}
|
||||
ErrBadClosingStatus = &ProtocolError{"bad closing status"}
|
||||
ErrUnsupportedExtensions = &ProtocolError{"unsupported extensions"}
|
||||
ErrNotImplemented = &ProtocolError{"not implemented"}
|
||||
|
||||
handshakeHeader = map[string]bool{
|
||||
"Host": true,
|
||||
"Upgrade": true,
|
||||
"Connection": true,
|
||||
"Sec-Websocket-Key": true,
|
||||
"Sec-Websocket-Origin": true,
|
||||
"Sec-Websocket-Version": true,
|
||||
"Sec-Websocket-Protocol": true,
|
||||
"Sec-Websocket-Accept": true,
|
||||
}
|
||||
)
|
||||
|
||||
// A hybiFrameHeader is a frame header as defined in hybi draft.
|
||||
type hybiFrameHeader struct {
|
||||
Fin bool
|
||||
Rsv [3]bool
|
||||
OpCode byte
|
||||
Length int64
|
||||
MaskingKey []byte
|
||||
|
||||
data *bytes.Buffer
|
||||
}
|
||||
|
||||
// A hybiFrameReader is a reader for hybi frame.
|
||||
type hybiFrameReader struct {
|
||||
reader io.Reader
|
||||
|
||||
header hybiFrameHeader
|
||||
pos int64
|
||||
length int
|
||||
}
|
||||
|
||||
func (frame *hybiFrameReader) Read(msg []byte) (n int, err error) {
|
||||
n, err = frame.reader.Read(msg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if frame.header.MaskingKey != nil {
|
||||
for i := 0; i < n; i++ {
|
||||
msg[i] = msg[i] ^ frame.header.MaskingKey[frame.pos%4]
|
||||
frame.pos++
|
||||
}
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
|
||||
func (frame *hybiFrameReader) PayloadType() byte { return frame.header.OpCode }
|
||||
|
||||
func (frame *hybiFrameReader) HeaderReader() io.Reader {
|
||||
if frame.header.data == nil {
|
||||
return nil
|
||||
}
|
||||
if frame.header.data.Len() == 0 {
|
||||
return nil
|
||||
}
|
||||
return frame.header.data
|
||||
}
|
||||
|
||||
func (frame *hybiFrameReader) TrailerReader() io.Reader { return nil }
|
||||
|
||||
func (frame *hybiFrameReader) Len() (n int) { return frame.length }
|
||||
|
||||
// A hybiFrameReaderFactory creates new frame reader based on its frame type.
|
||||
type hybiFrameReaderFactory struct {
|
||||
*bufio.Reader
|
||||
}
|
||||
|
||||
// NewFrameReader reads a frame header from the connection, and creates new reader for the frame.
|
||||
// See Section 5.2 Base Framing protocol for detail.
|
||||
// http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17#section-5.2
|
||||
func (buf hybiFrameReaderFactory) NewFrameReader() (frame frameReader, err error) {
|
||||
hybiFrame := new(hybiFrameReader)
|
||||
frame = hybiFrame
|
||||
var header []byte
|
||||
var b byte
|
||||
// First byte. FIN/RSV1/RSV2/RSV3/OpCode(4bits)
|
||||
b, err = buf.ReadByte()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
header = append(header, b)
|
||||
hybiFrame.header.Fin = ((header[0] >> 7) & 1) != 0
|
||||
for i := 0; i < 3; i++ {
|
||||
j := uint(6 - i)
|
||||
hybiFrame.header.Rsv[i] = ((header[0] >> j) & 1) != 0
|
||||
}
|
||||
hybiFrame.header.OpCode = header[0] & 0x0f
|
||||
|
||||
// Second byte. Mask/Payload len(7bits)
|
||||
b, err = buf.ReadByte()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
header = append(header, b)
|
||||
mask := (b & 0x80) != 0
|
||||
b &= 0x7f
|
||||
lengthFields := 0
|
||||
switch {
|
||||
case b <= 125: // Payload length 7bits.
|
||||
hybiFrame.header.Length = int64(b)
|
||||
case b == 126: // Payload length 7+16bits
|
||||
lengthFields = 2
|
||||
case b == 127: // Payload length 7+64bits
|
||||
lengthFields = 8
|
||||
}
|
||||
for i := 0; i < lengthFields; i++ {
|
||||
b, err = buf.ReadByte()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
header = append(header, b)
|
||||
hybiFrame.header.Length = hybiFrame.header.Length*256 + int64(b)
|
||||
}
|
||||
if mask {
|
||||
// Masking key. 4 bytes.
|
||||
for i := 0; i < 4; i++ {
|
||||
b, err = buf.ReadByte()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
header = append(header, b)
|
||||
hybiFrame.header.MaskingKey = append(hybiFrame.header.MaskingKey, b)
|
||||
}
|
||||
}
|
||||
hybiFrame.reader = io.LimitReader(buf.Reader, hybiFrame.header.Length)
|
||||
hybiFrame.header.data = bytes.NewBuffer(header)
|
||||
hybiFrame.length = len(header) + int(hybiFrame.header.Length)
|
||||
return
|
||||
}
|
||||
|
||||
// A HybiFrameWriter is a writer for hybi frame.
|
||||
type hybiFrameWriter struct {
|
||||
writer *bufio.Writer
|
||||
|
||||
header *hybiFrameHeader
|
||||
}
|
||||
|
||||
func (frame *hybiFrameWriter) Write(msg []byte) (n int, err error) {
|
||||
var header []byte
|
||||
var b byte
|
||||
if frame.header.Fin {
|
||||
b |= 0x80
|
||||
}
|
||||
for i := 0; i < 3; i++ {
|
||||
if frame.header.Rsv[i] {
|
||||
j := uint(6 - i)
|
||||
b |= 1 << j
|
||||
}
|
||||
}
|
||||
b |= frame.header.OpCode
|
||||
header = append(header, b)
|
||||
if frame.header.MaskingKey != nil {
|
||||
b = 0x80
|
||||
} else {
|
||||
b = 0
|
||||
}
|
||||
lengthFields := 0
|
||||
length := len(msg)
|
||||
switch {
|
||||
case length <= 125:
|
||||
b |= byte(length)
|
||||
case length < 65536:
|
||||
b |= 126
|
||||
lengthFields = 2
|
||||
default:
|
||||
b |= 127
|
||||
lengthFields = 8
|
||||
}
|
||||
header = append(header, b)
|
||||
for i := 0; i < lengthFields; i++ {
|
||||
j := uint((lengthFields - i - 1) * 8)
|
||||
b = byte((length >> j) & 0xff)
|
||||
header = append(header, b)
|
||||
}
|
||||
if frame.header.MaskingKey != nil {
|
||||
if len(frame.header.MaskingKey) != 4 {
|
||||
return 0, ErrBadMaskingKey
|
||||
}
|
||||
header = append(header, frame.header.MaskingKey...)
|
||||
frame.writer.Write(header)
|
||||
data := make([]byte, length)
|
||||
for i := range data {
|
||||
data[i] = msg[i] ^ frame.header.MaskingKey[i%4]
|
||||
}
|
||||
frame.writer.Write(data)
|
||||
err = frame.writer.Flush()
|
||||
return length, err
|
||||
}
|
||||
frame.writer.Write(header)
|
||||
frame.writer.Write(msg)
|
||||
err = frame.writer.Flush()
|
||||
return length, err
|
||||
}
|
||||
|
||||
func (frame *hybiFrameWriter) Close() error { return nil }
|
||||
|
||||
type hybiFrameWriterFactory struct {
|
||||
*bufio.Writer
|
||||
needMaskingKey bool
|
||||
}
|
||||
|
||||
func (buf hybiFrameWriterFactory) NewFrameWriter(payloadType byte) (frame frameWriter, err error) {
|
||||
frameHeader := &hybiFrameHeader{Fin: true, OpCode: payloadType}
|
||||
if buf.needMaskingKey {
|
||||
frameHeader.MaskingKey, err = generateMaskingKey()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return &hybiFrameWriter{writer: buf.Writer, header: frameHeader}, nil
|
||||
}
|
||||
|
||||
type hybiFrameHandler struct {
|
||||
conn *Conn
|
||||
payloadType byte
|
||||
}
|
||||
|
||||
func (handler *hybiFrameHandler) HandleFrame(frame frameReader) (r frameReader, err error) {
|
||||
if handler.conn.IsServerConn() {
|
||||
// The client MUST mask all frames sent to the server.
|
||||
if frame.(*hybiFrameReader).header.MaskingKey == nil {
|
||||
handler.WriteClose(closeStatusProtocolError)
|
||||
return nil, io.EOF
|
||||
}
|
||||
} else {
|
||||
// The server MUST NOT mask all frames.
|
||||
if frame.(*hybiFrameReader).header.MaskingKey != nil {
|
||||
handler.WriteClose(closeStatusProtocolError)
|
||||
return nil, io.EOF
|
||||
}
|
||||
}
|
||||
if header := frame.HeaderReader(); header != nil {
|
||||
io.Copy(ioutil.Discard, header)
|
||||
}
|
||||
switch frame.PayloadType() {
|
||||
case ContinuationFrame:
|
||||
frame.(*hybiFrameReader).header.OpCode = handler.payloadType
|
||||
case TextFrame, BinaryFrame:
|
||||
handler.payloadType = frame.PayloadType()
|
||||
case CloseFrame:
|
||||
return nil, io.EOF
|
||||
case PingFrame:
|
||||
pingMsg := make([]byte, maxControlFramePayloadLength)
|
||||
n, err := io.ReadFull(frame, pingMsg)
|
||||
if err != nil && err != io.ErrUnexpectedEOF {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, frame)
|
||||
n, err = handler.WritePong(pingMsg[:n])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return nil, nil
|
||||
case PongFrame:
|
||||
return nil, ErrNotImplemented
|
||||
}
|
||||
return frame, nil
|
||||
}
|
||||
|
||||
func (handler *hybiFrameHandler) WriteClose(status int) (err error) {
|
||||
handler.conn.wio.Lock()
|
||||
defer handler.conn.wio.Unlock()
|
||||
w, err := handler.conn.frameWriterFactory.NewFrameWriter(CloseFrame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
msg := make([]byte, 2)
|
||||
binary.BigEndian.PutUint16(msg, uint16(status))
|
||||
_, err = w.Write(msg)
|
||||
w.Close()
|
||||
return err
|
||||
}
|
||||
|
||||
func (handler *hybiFrameHandler) WritePong(msg []byte) (n int, err error) {
|
||||
handler.conn.wio.Lock()
|
||||
defer handler.conn.wio.Unlock()
|
||||
w, err := handler.conn.frameWriterFactory.NewFrameWriter(PongFrame)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
n, err = w.Write(msg)
|
||||
w.Close()
|
||||
return n, err
|
||||
}
|
||||
|
||||
// newHybiConn creates a new WebSocket connection speaking hybi draft protocol.
|
||||
func newHybiConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
|
||||
if buf == nil {
|
||||
br := bufio.NewReader(rwc)
|
||||
bw := bufio.NewWriter(rwc)
|
||||
buf = bufio.NewReadWriter(br, bw)
|
||||
}
|
||||
ws := &Conn{config: config, request: request, buf: buf, rwc: rwc,
|
||||
frameReaderFactory: hybiFrameReaderFactory{buf.Reader},
|
||||
frameWriterFactory: hybiFrameWriterFactory{
|
||||
buf.Writer, request == nil},
|
||||
PayloadType: TextFrame,
|
||||
defaultCloseStatus: closeStatusNormal}
|
||||
ws.frameHandler = &hybiFrameHandler{conn: ws}
|
||||
return ws
|
||||
}
|
||||
|
||||
// generateMaskingKey generates a masking key for a frame.
|
||||
func generateMaskingKey() (maskingKey []byte, err error) {
|
||||
maskingKey = make([]byte, 4)
|
||||
if _, err = io.ReadFull(rand.Reader, maskingKey); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// generateNonce generates a nonce consisting of a randomly selected 16-byte
|
||||
// value that has been base64-encoded.
|
||||
func generateNonce() (nonce []byte) {
|
||||
key := make([]byte, 16)
|
||||
if _, err := io.ReadFull(rand.Reader, key); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
nonce = make([]byte, 24)
|
||||
base64.StdEncoding.Encode(nonce, key)
|
||||
return
|
||||
}
|
||||
|
||||
// getNonceAccept computes the base64-encoded SHA-1 of the concatenation of
|
||||
// the nonce ("Sec-WebSocket-Key" value) with the websocket GUID string.
|
||||
func getNonceAccept(nonce []byte) (expected []byte, err error) {
|
||||
h := sha1.New()
|
||||
if _, err = h.Write(nonce); err != nil {
|
||||
return
|
||||
}
|
||||
if _, err = h.Write([]byte(websocketGUID)); err != nil {
|
||||
return
|
||||
}
|
||||
expected = make([]byte, 28)
|
||||
base64.StdEncoding.Encode(expected, h.Sum(nil))
|
||||
return
|
||||
}
|
||||
|
||||
func isHybiVersion(version int) bool {
|
||||
switch version {
|
||||
case ProtocolVersionHybi08, ProtocolVersionHybi13:
|
||||
return true
|
||||
default:
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Client handshake described in draft-ietf-hybi-thewebsocket-protocol-17
|
||||
func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
|
||||
if !isHybiVersion(config.Version) {
|
||||
panic("wrong protocol version.")
|
||||
}
|
||||
|
||||
bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")
|
||||
|
||||
bw.WriteString("Host: " + config.Location.Host + "\r\n")
|
||||
bw.WriteString("Upgrade: websocket\r\n")
|
||||
bw.WriteString("Connection: Upgrade\r\n")
|
||||
nonce := generateNonce()
|
||||
if config.handshakeData != nil {
|
||||
nonce = []byte(config.handshakeData["key"])
|
||||
}
|
||||
bw.WriteString("Sec-WebSocket-Key: " + string(nonce) + "\r\n")
|
||||
if config.Version == ProtocolVersionHybi13 {
|
||||
bw.WriteString("Origin: " + strings.ToLower(config.Origin.String()) + "\r\n")
|
||||
} else if config.Version == ProtocolVersionHybi08 {
|
||||
bw.WriteString("Sec-WebSocket-Origin: " + strings.ToLower(config.Origin.String()) + "\r\n")
|
||||
}
|
||||
bw.WriteString("Sec-WebSocket-Version: " + fmt.Sprintf("%d", config.Version) + "\r\n")
|
||||
if len(config.Protocol) > 0 {
|
||||
bw.WriteString("Sec-WebSocket-Protocol: " + strings.Join(config.Protocol, ", ") + "\r\n")
|
||||
}
|
||||
// TODO(ukai): send Sec-WebSocket-Extensions.
|
||||
err = config.Header.WriteSubset(bw, handshakeHeader)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
bw.WriteString("\r\n")
|
||||
if err = bw.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
resp, err := http.ReadResponse(br, &http.Request{Method: "GET"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if resp.StatusCode != 101 {
|
||||
return ErrBadStatus
|
||||
}
|
||||
if strings.ToLower(resp.Header.Get("Upgrade")) != "websocket" ||
|
||||
strings.ToLower(resp.Header.Get("Connection")) != "upgrade" {
|
||||
return ErrBadUpgrade
|
||||
}
|
||||
expectedAccept, err := getNonceAccept(nonce)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if resp.Header.Get("Sec-WebSocket-Accept") != string(expectedAccept) {
|
||||
return ErrChallengeResponse
|
||||
}
|
||||
if resp.Header.Get("Sec-WebSocket-Extensions") != "" {
|
||||
return ErrUnsupportedExtensions
|
||||
}
|
||||
offeredProtocol := resp.Header.Get("Sec-WebSocket-Protocol")
|
||||
if offeredProtocol != "" {
|
||||
protocolMatched := false
|
||||
for i := 0; i < len(config.Protocol); i++ {
|
||||
if config.Protocol[i] == offeredProtocol {
|
||||
protocolMatched = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !protocolMatched {
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
config.Protocol = []string{offeredProtocol}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// newHybiClientConn creates a client WebSocket connection after handshake.
|
||||
func newHybiClientConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser) *Conn {
|
||||
return newHybiConn(config, buf, rwc, nil)
|
||||
}
|
||||
|
||||
// A HybiServerHandshaker performs a server handshake using hybi draft protocol.
|
||||
type hybiServerHandshaker struct {
|
||||
*Config
|
||||
accept []byte
|
||||
}
|
||||
|
||||
func (c *hybiServerHandshaker) ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error) {
|
||||
c.Version = ProtocolVersionHybi13
|
||||
if req.Method != "GET" {
|
||||
return http.StatusMethodNotAllowed, ErrBadRequestMethod
|
||||
}
|
||||
// HTTP version can be safely ignored.
|
||||
|
||||
if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
|
||||
!strings.Contains(strings.ToLower(req.Header.Get("Connection")), "upgrade") {
|
||||
return http.StatusBadRequest, ErrNotWebSocket
|
||||
}
|
||||
|
||||
key := req.Header.Get("Sec-Websocket-Key")
|
||||
if key == "" {
|
||||
return http.StatusBadRequest, ErrChallengeResponse
|
||||
}
|
||||
version := req.Header.Get("Sec-Websocket-Version")
|
||||
switch version {
|
||||
case "13":
|
||||
c.Version = ProtocolVersionHybi13
|
||||
case "8":
|
||||
c.Version = ProtocolVersionHybi08
|
||||
default:
|
||||
return http.StatusBadRequest, ErrBadWebSocketVersion
|
||||
}
|
||||
var scheme string
|
||||
if req.TLS != nil {
|
||||
scheme = "wss"
|
||||
} else {
|
||||
scheme = "ws"
|
||||
}
|
||||
c.Location, err = url.ParseRequestURI(scheme + "://" + req.Host + req.URL.RequestURI())
|
||||
if err != nil {
|
||||
return http.StatusBadRequest, err
|
||||
}
|
||||
protocol := strings.TrimSpace(req.Header.Get("Sec-Websocket-Protocol"))
|
||||
if protocol != "" {
|
||||
protocols := strings.Split(protocol, ",")
|
||||
for i := 0; i < len(protocols); i++ {
|
||||
c.Protocol = append(c.Protocol, strings.TrimSpace(protocols[i]))
|
||||
}
|
||||
}
|
||||
c.accept, err = getNonceAccept([]byte(key))
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
return http.StatusSwitchingProtocols, nil
|
||||
}
|
||||
|
||||
// Origin parses Origin header in "req".
|
||||
// If origin is "null", returns (nil, nil).
|
||||
func Origin(config *Config, req *http.Request) (*url.URL, error) {
|
||||
var origin string
|
||||
switch config.Version {
|
||||
case ProtocolVersionHybi13:
|
||||
origin = req.Header.Get("Origin")
|
||||
case ProtocolVersionHybi08:
|
||||
origin = req.Header.Get("Sec-Websocket-Origin")
|
||||
}
|
||||
if origin == "null" {
|
||||
return nil, nil
|
||||
}
|
||||
return url.ParseRequestURI(origin)
|
||||
}
|
||||
|
||||
func (c *hybiServerHandshaker) AcceptHandshake(buf *bufio.Writer) (err error) {
|
||||
if len(c.Protocol) > 0 {
|
||||
if len(c.Protocol) != 1 {
|
||||
// You need choose a Protocol in Handshake func in Server.
|
||||
return ErrBadWebSocketProtocol
|
||||
}
|
||||
}
|
||||
buf.WriteString("HTTP/1.1 101 Switching Protocols\r\n")
|
||||
buf.WriteString("Upgrade: websocket\r\n")
|
||||
buf.WriteString("Connection: Upgrade\r\n")
|
||||
buf.WriteString("Sec-WebSocket-Accept: " + string(c.accept) + "\r\n")
|
||||
if len(c.Protocol) > 0 {
|
||||
buf.WriteString("Sec-WebSocket-Protocol: " + c.Protocol[0] + "\r\n")
|
||||
}
|
||||
// TODO(ukai): send Sec-WebSocket-Extensions.
|
||||
if c.Header != nil {
|
||||
err := c.Header.WriteSubset(buf, handshakeHeader)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
buf.WriteString("\r\n")
|
||||
return buf.Flush()
|
||||
}
|
||||
|
||||
func (c *hybiServerHandshaker) NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
|
||||
return newHybiServerConn(c.Config, buf, rwc, request)
|
||||
}
|
||||
|
||||
// newHybiServerConn returns a new WebSocket connection speaking hybi draft protocol.
|
||||
func newHybiServerConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
|
||||
return newHybiConn(config, buf, rwc, request)
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
func newServerConn(rwc io.ReadWriteCloser, buf *bufio.ReadWriter, req *http.Request, config *Config, handshake func(*Config, *http.Request) error) (conn *Conn, err error) {
|
||||
var hs serverHandshaker = &hybiServerHandshaker{Config: config}
|
||||
code, err := hs.ReadHandshake(buf.Reader, req)
|
||||
if err == ErrBadWebSocketVersion {
|
||||
fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
|
||||
fmt.Fprintf(buf, "Sec-WebSocket-Version: %s\r\n", SupportedProtocolVersion)
|
||||
buf.WriteString("\r\n")
|
||||
buf.WriteString(err.Error())
|
||||
buf.Flush()
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
hs = &hixie76ServerHandshaker{Config: config}
|
||||
code, err = hs.ReadHandshake(buf.Reader, req)
|
||||
}
|
||||
if err != nil {
|
||||
hs = &hixie75ServerHandshaker{Config: config}
|
||||
code, err = hs.ReadHandshake(buf.Reader, req)
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
|
||||
buf.WriteString("\r\n")
|
||||
buf.WriteString(err.Error())
|
||||
buf.Flush()
|
||||
return
|
||||
}
|
||||
if handshake != nil {
|
||||
err = handshake(config, req)
|
||||
if err != nil {
|
||||
code = http.StatusForbidden
|
||||
fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
|
||||
buf.WriteString("\r\n")
|
||||
buf.Flush()
|
||||
return
|
||||
}
|
||||
}
|
||||
err = hs.AcceptHandshake(buf.Writer)
|
||||
if err != nil {
|
||||
code = http.StatusBadRequest
|
||||
fmt.Fprintf(buf, "HTTP/1.1 %03d %s\r\n", code, http.StatusText(code))
|
||||
buf.WriteString("\r\n")
|
||||
buf.Flush()
|
||||
return
|
||||
}
|
||||
conn = hs.NewServerConn(buf, rwc, req)
|
||||
return
|
||||
}
|
||||
|
||||
// Server represents a server of a WebSocket.
|
||||
type Server struct {
|
||||
// Config is a WebSocket configuration for new WebSocket connection.
|
||||
Config
|
||||
|
||||
// Handshake is an optional function in WebSocket handshake.
|
||||
// For example, you can check, or don't check Origin header.
|
||||
// Another example, you can select config.Protocol.
|
||||
Handshake func(*Config, *http.Request) error
|
||||
|
||||
// Handler handles a WebSocket connection.
|
||||
Handler
|
||||
}
|
||||
|
||||
// ServeHTTP implements the http.Handler interface for a WebSocket
|
||||
func (s Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
||||
s.serveWebSocket(w, req)
|
||||
}
|
||||
|
||||
func (s Server) serveWebSocket(w http.ResponseWriter, req *http.Request) {
|
||||
rwc, buf, err := w.(http.Hijacker).Hijack()
|
||||
if err != nil {
|
||||
panic("Hijack failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
// The server should abort the WebSocket connection if it finds
|
||||
// the client did not send a handshake that matches with protocol
|
||||
// specification.
|
||||
defer rwc.Close()
|
||||
conn, err := newServerConn(rwc, buf, req, &s.Config, s.Handshake)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if conn == nil {
|
||||
panic("unexpected nil conn")
|
||||
}
|
||||
s.Handler(conn)
|
||||
}
|
||||
|
||||
// Handler is a simple interface to a WebSocket browser client.
|
||||
// It checks if Origin header is valid URL by default.
|
||||
// You might want to verify websocket.Conn.Config().Origin in the func.
|
||||
// If you use Server instead of Handler, you could call websocket.Origin and
|
||||
// check the origin in your Handshake func. So, if you want to accept
|
||||
// non-browser client, which doesn't send Origin header, you could use Server
|
||||
//. that doesn't check origin in its Handshake.
|
||||
type Handler func(*Conn)
|
||||
|
||||
func checkOrigin(config *Config, req *http.Request) (err error) {
|
||||
config.Origin, err = Origin(config, req)
|
||||
if err == nil && config.Origin == nil {
|
||||
return fmt.Errorf("null origin")
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// ServeHTTP implements the http.Handler interface for a WebSocket
|
||||
func (h Handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
||||
s := Server{Handler: h, Handshake: checkOrigin}
|
||||
s.serveWebSocket(w, req)
|
||||
}
|
||||
-415
@@ -1,415 +0,0 @@
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package websocket implements a client and server for the WebSocket protocol
|
||||
// as specified in RFC 6455.
|
||||
package websocket
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/tls"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
ProtocolVersionHixie75 = -75
|
||||
ProtocolVersionHixie76 = -76
|
||||
ProtocolVersionHybi00 = 0
|
||||
ProtocolVersionHybi08 = 8
|
||||
ProtocolVersionHybi13 = 13
|
||||
ProtocolVersionHybi = ProtocolVersionHybi13
|
||||
SupportedProtocolVersion = "13, 8"
|
||||
|
||||
ContinuationFrame = 0
|
||||
TextFrame = 1
|
||||
BinaryFrame = 2
|
||||
CloseFrame = 8
|
||||
PingFrame = 9
|
||||
PongFrame = 10
|
||||
UnknownFrame = 255
|
||||
)
|
||||
|
||||
// ProtocolError represents WebSocket protocol errors.
|
||||
type ProtocolError struct {
|
||||
ErrorString string
|
||||
}
|
||||
|
||||
func (err *ProtocolError) Error() string { return err.ErrorString }
|
||||
|
||||
var (
|
||||
ErrBadProtocolVersion = &ProtocolError{"bad protocol version"}
|
||||
ErrBadScheme = &ProtocolError{"bad scheme"}
|
||||
ErrBadStatus = &ProtocolError{"bad status"}
|
||||
ErrBadUpgrade = &ProtocolError{"missing or bad upgrade"}
|
||||
ErrBadWebSocketOrigin = &ProtocolError{"missing or bad WebSocket-Origin"}
|
||||
ErrBadWebSocketLocation = &ProtocolError{"missing or bad WebSocket-Location"}
|
||||
ErrBadWebSocketProtocol = &ProtocolError{"missing or bad WebSocket-Protocol"}
|
||||
ErrBadWebSocketVersion = &ProtocolError{"missing or bad WebSocket Version"}
|
||||
ErrChallengeResponse = &ProtocolError{"mismatch challenge/response"}
|
||||
ErrBadFrame = &ProtocolError{"bad frame"}
|
||||
ErrBadFrameBoundary = &ProtocolError{"not on frame boundary"}
|
||||
ErrNotWebSocket = &ProtocolError{"not websocket protocol"}
|
||||
ErrBadRequestMethod = &ProtocolError{"bad method"}
|
||||
ErrNotSupported = &ProtocolError{"not supported"}
|
||||
)
|
||||
|
||||
// Addr is an implementation of net.Addr for WebSocket.
|
||||
type Addr struct {
|
||||
*url.URL
|
||||
}
|
||||
|
||||
// Network returns the network type for a WebSocket, "websocket".
|
||||
func (addr *Addr) Network() string { return "websocket" }
|
||||
|
||||
// Config is a WebSocket configuration
|
||||
type Config struct {
|
||||
// A WebSocket server address.
|
||||
Location *url.URL
|
||||
|
||||
// A Websocket client origin.
|
||||
Origin *url.URL
|
||||
|
||||
// WebSocket subprotocols.
|
||||
Protocol []string
|
||||
|
||||
// WebSocket protocol version.
|
||||
Version int
|
||||
|
||||
// TLS config for secure WebSocket (wss).
|
||||
TlsConfig *tls.Config
|
||||
|
||||
// Additional header fields to be sent in WebSocket opening handshake.
|
||||
Header http.Header
|
||||
|
||||
handshakeData map[string]string
|
||||
}
|
||||
|
||||
// serverHandshaker is an interface to handle WebSocket server side handshake.
|
||||
type serverHandshaker interface {
|
||||
// ReadHandshake reads handshake request message from client.
|
||||
// Returns http response code and error if any.
|
||||
ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error)
|
||||
|
||||
// AcceptHandshake accepts the client handshake request and sends
|
||||
// handshake response back to client.
|
||||
AcceptHandshake(buf *bufio.Writer) (err error)
|
||||
|
||||
// NewServerConn creates a new WebSocket connection.
|
||||
NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) (conn *Conn)
|
||||
}
|
||||
|
||||
// frameReader is an interface to read a WebSocket frame.
|
||||
type frameReader interface {
|
||||
// Reader is to read payload of the frame.
|
||||
io.Reader
|
||||
|
||||
// PayloadType returns payload type.
|
||||
PayloadType() byte
|
||||
|
||||
// HeaderReader returns a reader to read header of the frame.
|
||||
HeaderReader() io.Reader
|
||||
|
||||
// TrailerReader returns a reader to read trailer of the frame.
|
||||
// If it returns nil, there is no trailer in the frame.
|
||||
TrailerReader() io.Reader
|
||||
|
||||
// Len returns total length of the frame, including header and trailer.
|
||||
Len() int
|
||||
}
|
||||
|
||||
// frameReaderFactory is an interface to creates new frame reader.
|
||||
type frameReaderFactory interface {
|
||||
NewFrameReader() (r frameReader, err error)
|
||||
}
|
||||
|
||||
// frameWriter is an interface to write a WebSocket frame.
|
||||
type frameWriter interface {
|
||||
// Writer is to write playload of the frame.
|
||||
io.WriteCloser
|
||||
}
|
||||
|
||||
// frameWriterFactory is an interface to create new frame writer.
|
||||
type frameWriterFactory interface {
|
||||
NewFrameWriter(payloadType byte) (w frameWriter, err error)
|
||||
}
|
||||
|
||||
type frameHandler interface {
|
||||
HandleFrame(frame frameReader) (r frameReader, err error)
|
||||
WriteClose(status int) (err error)
|
||||
}
|
||||
|
||||
// Conn represents a WebSocket connection.
|
||||
type Conn struct {
|
||||
config *Config
|
||||
request *http.Request
|
||||
|
||||
buf *bufio.ReadWriter
|
||||
rwc io.ReadWriteCloser
|
||||
|
||||
rio sync.Mutex
|
||||
frameReaderFactory
|
||||
frameReader
|
||||
|
||||
wio sync.Mutex
|
||||
frameWriterFactory
|
||||
|
||||
frameHandler
|
||||
PayloadType byte
|
||||
defaultCloseStatus int
|
||||
}
|
||||
|
||||
// Read implements the io.Reader interface:
|
||||
// it reads data of a frame from the WebSocket connection.
|
||||
// if msg is not large enough for the frame data, it fills the msg and next Read
|
||||
// will read the rest of the frame data.
|
||||
// it reads Text frame or Binary frame.
|
||||
func (ws *Conn) Read(msg []byte) (n int, err error) {
|
||||
ws.rio.Lock()
|
||||
defer ws.rio.Unlock()
|
||||
again:
|
||||
if ws.frameReader == nil {
|
||||
frame, err := ws.frameReaderFactory.NewFrameReader()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
ws.frameReader, err = ws.frameHandler.HandleFrame(frame)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if ws.frameReader == nil {
|
||||
goto again
|
||||
}
|
||||
}
|
||||
n, err = ws.frameReader.Read(msg)
|
||||
if err == io.EOF {
|
||||
if trailer := ws.frameReader.TrailerReader(); trailer != nil {
|
||||
io.Copy(ioutil.Discard, trailer)
|
||||
}
|
||||
ws.frameReader = nil
|
||||
goto again
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
|
||||
// Write implements the io.Writer interface:
|
||||
// it writes data as a frame to the WebSocket connection.
|
||||
func (ws *Conn) Write(msg []byte) (n int, err error) {
|
||||
ws.wio.Lock()
|
||||
defer ws.wio.Unlock()
|
||||
w, err := ws.frameWriterFactory.NewFrameWriter(ws.PayloadType)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
n, err = w.Write(msg)
|
||||
w.Close()
|
||||
if err != nil {
|
||||
return n, err
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
|
||||
// Close implements the io.Closer interface.
|
||||
func (ws *Conn) Close() error {
|
||||
err := ws.frameHandler.WriteClose(ws.defaultCloseStatus)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return ws.rwc.Close()
|
||||
}
|
||||
|
||||
func (ws *Conn) IsClientConn() bool { return ws.request == nil }
|
||||
func (ws *Conn) IsServerConn() bool { return ws.request != nil }
|
||||
|
||||
// LocalAddr returns the WebSocket Origin for the connection for client, or
|
||||
// the WebSocket location for server.
|
||||
func (ws *Conn) LocalAddr() net.Addr {
|
||||
if ws.IsClientConn() {
|
||||
return &Addr{ws.config.Origin}
|
||||
}
|
||||
return &Addr{ws.config.Location}
|
||||
}
|
||||
|
||||
// RemoteAddr returns the WebSocket location for the connection for client, or
|
||||
// the Websocket Origin for server.
|
||||
func (ws *Conn) RemoteAddr() net.Addr {
|
||||
if ws.IsClientConn() {
|
||||
return &Addr{ws.config.Location}
|
||||
}
|
||||
return &Addr{ws.config.Origin}
|
||||
}
|
||||
|
||||
var errSetDeadline = errors.New("websocket: cannot set deadline: not using a net.Conn")
|
||||
|
||||
// SetDeadline sets the connection's network read & write deadlines.
|
||||
func (ws *Conn) SetDeadline(t time.Time) error {
|
||||
if conn, ok := ws.rwc.(net.Conn); ok {
|
||||
return conn.SetDeadline(t)
|
||||
}
|
||||
return errSetDeadline
|
||||
}
|
||||
|
||||
// SetReadDeadline sets the connection's network read deadline.
|
||||
func (ws *Conn) SetReadDeadline(t time.Time) error {
|
||||
if conn, ok := ws.rwc.(net.Conn); ok {
|
||||
return conn.SetReadDeadline(t)
|
||||
}
|
||||
return errSetDeadline
|
||||
}
|
||||
|
||||
// SetWriteDeadline sets the connection's network write deadline.
|
||||
func (ws *Conn) SetWriteDeadline(t time.Time) error {
|
||||
if conn, ok := ws.rwc.(net.Conn); ok {
|
||||
return conn.SetWriteDeadline(t)
|
||||
}
|
||||
return errSetDeadline
|
||||
}
|
||||
|
||||
// Config returns the WebSocket config.
|
||||
func (ws *Conn) Config() *Config { return ws.config }
|
||||
|
||||
// Request returns the http request upgraded to the WebSocket.
|
||||
// It is nil for client side.
|
||||
func (ws *Conn) Request() *http.Request { return ws.request }
|
||||
|
||||
// Codec represents a symmetric pair of functions that implement a codec.
|
||||
type Codec struct {
|
||||
Marshal func(v interface{}) (data []byte, payloadType byte, err error)
|
||||
Unmarshal func(data []byte, payloadType byte, v interface{}) (err error)
|
||||
}
|
||||
|
||||
// Send sends v marshaled by cd.Marshal as single frame to ws.
|
||||
func (cd Codec) Send(ws *Conn, v interface{}) (err error) {
|
||||
data, payloadType, err := cd.Marshal(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ws.wio.Lock()
|
||||
defer ws.wio.Unlock()
|
||||
w, err := ws.frameWriterFactory.NewFrameWriter(payloadType)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = w.Write(data)
|
||||
w.Close()
|
||||
return err
|
||||
}
|
||||
|
||||
// Receive receives single frame from ws, unmarshaled by cd.Unmarshal and stores in v.
|
||||
func (cd Codec) Receive(ws *Conn, v interface{}) (err error) {
|
||||
ws.rio.Lock()
|
||||
defer ws.rio.Unlock()
|
||||
if ws.frameReader != nil {
|
||||
_, err = io.Copy(ioutil.Discard, ws.frameReader)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ws.frameReader = nil
|
||||
}
|
||||
again:
|
||||
frame, err := ws.frameReaderFactory.NewFrameReader()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
frame, err = ws.frameHandler.HandleFrame(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if frame == nil {
|
||||
goto again
|
||||
}
|
||||
payloadType := frame.PayloadType()
|
||||
data, err := ioutil.ReadAll(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return cd.Unmarshal(data, payloadType, v)
|
||||
}
|
||||
|
||||
func marshal(v interface{}) (msg []byte, payloadType byte, err error) {
|
||||
switch data := v.(type) {
|
||||
case string:
|
||||
return []byte(data), TextFrame, nil
|
||||
case []byte:
|
||||
return data, BinaryFrame, nil
|
||||
}
|
||||
return nil, UnknownFrame, ErrNotSupported
|
||||
}
|
||||
|
||||
func unmarshal(msg []byte, payloadType byte, v interface{}) (err error) {
|
||||
switch data := v.(type) {
|
||||
case *string:
|
||||
*data = string(msg)
|
||||
return nil
|
||||
case *[]byte:
|
||||
*data = msg
|
||||
return nil
|
||||
}
|
||||
return ErrNotSupported
|
||||
}
|
||||
|
||||
/*
|
||||
Message is a codec to send/receive text/binary data in a frame on WebSocket connection.
|
||||
To send/receive text frame, use string type.
|
||||
To send/receive binary frame, use []byte type.
|
||||
|
||||
Trivial usage:
|
||||
|
||||
import "websocket"
|
||||
|
||||
// receive text frame
|
||||
var message string
|
||||
websocket.Message.Receive(ws, &message)
|
||||
|
||||
// send text frame
|
||||
message = "hello"
|
||||
websocket.Message.Send(ws, message)
|
||||
|
||||
// receive binary frame
|
||||
var data []byte
|
||||
websocket.Message.Receive(ws, &data)
|
||||
|
||||
// send binary frame
|
||||
data = []byte{0, 1, 2}
|
||||
websocket.Message.Send(ws, data)
|
||||
|
||||
*/
|
||||
var Message = Codec{marshal, unmarshal}
|
||||
|
||||
func jsonMarshal(v interface{}) (msg []byte, payloadType byte, err error) {
|
||||
msg, err = json.Marshal(v)
|
||||
return msg, TextFrame, err
|
||||
}
|
||||
|
||||
func jsonUnmarshal(msg []byte, payloadType byte, v interface{}) (err error) {
|
||||
return json.Unmarshal(msg, v)
|
||||
}
|
||||
|
||||
/*
|
||||
JSON is a codec to send/receive JSON data in a frame from a WebSocket connection.
|
||||
|
||||
Trivial usage:
|
||||
|
||||
import "websocket"
|
||||
|
||||
type T struct {
|
||||
Msg string
|
||||
Count int
|
||||
}
|
||||
|
||||
// receive JSON type T
|
||||
var data T
|
||||
websocket.JSON.Receive(ws, &data)
|
||||
|
||||
// send JSON type T
|
||||
websocket.JSON.Send(ws, data)
|
||||
*/
|
||||
var JSON = Codec{jsonMarshal, jsonUnmarshal}
|
||||
Reference in New Issue
Block a user