mirror of https://github.com/ethereum/go-ethereum
rpc, p2p/simulations: use github.com/gorilla/websocket (#20289)
* rpc: improve codec abstraction rpc.ServerCodec is an opaque interface. There was only one way to get a codec using existing APIs: rpc.NewJSONCodec. This change exports newCodec (as NewFuncCodec) and NewJSONCodec (as NewCodec). It also makes all codec methods non-public to avoid showing internals in godoc. While here, remove codec options in tests because they are not supported anymore. * p2p/simulations: use github.com/gorilla/websocket This package was the last remaining user of golang.org/x/net/websocket. Migrating to the new library wasn't straightforward because it is no longer possible to treat WebSocket connections as a net.Conn. * vendor: delete golang.org/x/net/websocket * rpc: fix godoc comments and run gofmtpull/20309/head
Felix Lange
5 years ago
committed by
Péter Szilágyi
parent
9e71f55bfa
commit
7c4a4eb58a
@ -1,106 +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" |
||||
"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) |
||||
err = hybiClientHandshake(config, br, bw) |
||||
if err != nil { |
||||
return |
||||
} |
||||
buf := bufio.NewReadWriter(br, bw) |
||||
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) |
||||
} |
||||
|
||||
var portMap = map[string]string{ |
||||
"ws": "80", |
||||
"wss": "443", |
||||
} |
||||
|
||||
func parseAuthority(location *url.URL) string { |
||||
if _, ok := portMap[location.Scheme]; ok { |
||||
if _, _, err := net.SplitHostPort(location.Host); err != nil { |
||||
return net.JoinHostPort(location.Host, portMap[location.Scheme]) |
||||
} |
||||
} |
||||
return location.Host |
||||
} |
||||
|
||||
// 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} |
||||
} |
||||
dialer := config.Dialer |
||||
if dialer == nil { |
||||
dialer = &net.Dialer{} |
||||
} |
||||
client, err = dialWithDialer(dialer, config) |
||||
if err != nil { |
||||
goto Error |
||||
} |
||||
ws, err = NewClient(config, client) |
||||
if err != nil { |
||||
client.Close() |
||||
goto Error |
||||
} |
||||
return |
||||
|
||||
Error: |
||||
return nil, &DialError{config, err} |
||||
} |
||||
@ -1,24 +0,0 @@ |
||||
// Copyright 2015 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 ( |
||||
"crypto/tls" |
||||
"net" |
||||
) |
||||
|
||||
func dialWithDialer(dialer *net.Dialer, config *Config) (conn net.Conn, err error) { |
||||
switch config.Location.Scheme { |
||||
case "ws": |
||||
conn, err = dialer.Dial("tcp", parseAuthority(config.Location)) |
||||
|
||||
case "wss": |
||||
conn, err = tls.DialWithDialer(dialer, "tcp", parseAuthority(config.Location), config.TlsConfig) |
||||
|
||||
default: |
||||
err = ErrBadScheme |
||||
} |
||||
return |
||||
} |
||||
@ -1,583 +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 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 |
||||
} |
||||
if lengthFields == 8 && i == 0 { // MSB must be zero when 7+64 bits
|
||||
b &= 0x7f |
||||
} |
||||
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) (frameReader, 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, PongFrame: |
||||
b := make([]byte, maxControlFramePayloadLength) |
||||
n, err := io.ReadFull(frame, b) |
||||
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { |
||||
return nil, err |
||||
} |
||||
io.Copy(ioutil.Discard, frame) |
||||
if frame.PayloadType() == PingFrame { |
||||
if _, err := handler.WritePong(b[:n]); err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
return nil, nil |
||||
} |
||||
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 |
||||
} |
||||
|
||||
// removeZone removes IPv6 zone identifer from host.
|
||||
// E.g., "[fe80::1%en0]:8080" to "[fe80::1]:8080"
|
||||
func removeZone(host string) string { |
||||
if !strings.HasPrefix(host, "[") { |
||||
return host |
||||
} |
||||
i := strings.LastIndex(host, "]") |
||||
if i < 0 { |
||||
return host |
||||
} |
||||
j := strings.LastIndex(host[:i], "%") |
||||
if j < 0 { |
||||
return host |
||||
} |
||||
return host[:j] + host[i:] |
||||
} |
||||
|
||||
// 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 |
||||
} |
||||
|
||||
// Client handshake described in draft-ietf-hybi-thewebsocket-protocol-17
|
||||
func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) { |
||||
bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n") |
||||
|
||||
// According to RFC 6874, an HTTP client, proxy, or other
|
||||
// intermediary must remove any IPv6 zone identifier attached
|
||||
// to an outgoing URI.
|
||||
bw.WriteString("Host: " + removeZone(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") |
||||
bw.WriteString("Origin: " + strings.ToLower(config.Origin.String()) + "\r\n") |
||||
|
||||
if config.Version != ProtocolVersionHybi13 { |
||||
return ErrBadProtocolVersion |
||||
} |
||||
|
||||
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 |
||||
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 the Origin header in req.
|
||||
// If the Origin header is not set, it returns nil and nil.
|
||||
func Origin(config *Config, req *http.Request) (*url.URL, error) { |
||||
var origin string |
||||
switch config.Version { |
||||
case ProtocolVersionHybi13: |
||||
origin = req.Header.Get("Origin") |
||||
} |
||||
if origin == "" { |
||||
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,113 +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 { |
||||
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()) |
||||
} |
||||
// 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 clients, which do not send an Origin header, set a
|
||||
// Server.Handshake that does not check the origin.
|
||||
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) |
||||
} |
||||
@ -1,451 +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.
|
||||
//
|
||||
// This package currently lacks some features found in an alternative
|
||||
// and more actively maintained WebSocket package:
|
||||
//
|
||||
// https://godoc.org/github.com/gorilla/websocket
|
||||
//
|
||||
package websocket // import "golang.org/x/net/websocket"
|
||||
|
||||
import ( |
||||
"bufio" |
||||
"crypto/tls" |
||||
"encoding/json" |
||||
"errors" |
||||
"io" |
||||
"io/ioutil" |
||||
"net" |
||||
"net/http" |
||||
"net/url" |
||||
"sync" |
||||
"time" |
||||
) |
||||
|
||||
const ( |
||||
ProtocolVersionHybi13 = 13 |
||||
ProtocolVersionHybi = ProtocolVersionHybi13 |
||||
SupportedProtocolVersion = "13" |
||||
|
||||
ContinuationFrame = 0 |
||||
TextFrame = 1 |
||||
BinaryFrame = 2 |
||||
CloseFrame = 8 |
||||
PingFrame = 9 |
||||
PongFrame = 10 |
||||
UnknownFrame = 255 |
||||
|
||||
DefaultMaxPayloadBytes = 32 << 20 // 32MB
|
||||
) |
||||
|
||||
// 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"} |
||||
) |
||||
|
||||
// ErrFrameTooLarge is returned by Codec's Receive method if payload size
|
||||
// exceeds limit set by Conn.MaxPayloadBytes
|
||||
var ErrFrameTooLarge = errors.New("websocket: frame payload size exceeds limit") |
||||
|
||||
// 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 |
||||
|
||||
// Dialer used when opening websocket connections.
|
||||
Dialer *net.Dialer |
||||
|
||||
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 payload 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.
|
||||
//
|
||||
// Multiple goroutines may invoke methods on a Conn simultaneously.
|
||||
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 |
||||
|
||||
// MaxPayloadBytes limits the size of frame payload received over Conn
|
||||
// by Codec's Receive method. If zero, DefaultMaxPayloadBytes is used.
|
||||
MaxPayloadBytes 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() |
||||
return n, err |
||||
} |
||||
|
||||
// Close implements the io.Closer interface.
|
||||
func (ws *Conn) Close() error { |
||||
err := ws.frameHandler.WriteClose(ws.defaultCloseStatus) |
||||
err1 := ws.rwc.Close() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return err1 |
||||
} |
||||
|
||||
// IsClientConn reports whether ws is a client-side connection.
|
||||
func (ws *Conn) IsClientConn() bool { return ws.request == nil } |
||||
|
||||
// IsServerConn reports whether ws is a server-side connection.
|
||||
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. The whole frame payload is read to an in-memory buffer; max size of
|
||||
// payload is defined by ws.MaxPayloadBytes. If frame payload size exceeds
|
||||
// limit, ErrFrameTooLarge is returned; in this case frame is not read off wire
|
||||
// completely. The next call to Receive would read and discard leftover data of
|
||||
// previous oversized frame before processing next frame.
|
||||
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 |
||||
} |
||||
maxPayloadBytes := ws.MaxPayloadBytes |
||||
if maxPayloadBytes == 0 { |
||||
maxPayloadBytes = DefaultMaxPayloadBytes |
||||
} |
||||
if hf, ok := frame.(*hybiFrameReader); ok && hf.header.Length > int64(maxPayloadBytes) { |
||||
// payload size exceeds limit, no need to call Unmarshal
|
||||
//
|
||||
// set frameReader to current oversized frame so that
|
||||
// the next call to this function can drain leftover
|
||||
// data before processing the next frame
|
||||
ws.frameReader = frame |
||||
return ErrFrameTooLarge |
||||
} |
||||
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} |
||||
Loading…
Reference in new issue