1 // Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
22 // Frame header byte 0 bits from Section 5.2 of RFC 6455
28 // Frame header byte 1 bits from Section 5.2 of RFC 6455
31 maxFrameHeaderSize = 2 + 8 + 4 // Fixed header + length + mask
32 maxControlFramePayloadSize = 125
34 writeWait = time.Second
36 defaultReadBufferSize = 4096
37 defaultWriteBufferSize = 4096
43 // Close codes defined in RFC 6455, section 11.7.
45 CloseNormalClosure = 1000
47 CloseProtocolError = 1002
48 CloseUnsupportedData = 1003
49 CloseNoStatusReceived = 1005
50 CloseAbnormalClosure = 1006
51 CloseInvalidFramePayloadData = 1007
52 ClosePolicyViolation = 1008
53 CloseMessageTooBig = 1009
54 CloseMandatoryExtension = 1010
55 CloseInternalServerErr = 1011
56 CloseServiceRestart = 1012
57 CloseTryAgainLater = 1013
58 CloseTLSHandshake = 1015
61 // The message types are defined in RFC 6455, section 11.8.
63 // TextMessage denotes a text data message. The text message payload is
64 // interpreted as UTF-8 encoded text data.
67 // BinaryMessage denotes a binary data message.
70 // CloseMessage denotes a close control message. The optional message
71 // payload contains a numeric code and text. Use the FormatCloseMessage
72 // function to format a close message payload.
75 // PingMessage denotes a ping control message. The optional message payload
76 // is UTF-8 encoded text.
79 // PongMessage denotes a pong control message. The optional message payload
80 // is UTF-8 encoded text.
84 // ErrCloseSent is returned when the application writes a message to the
85 // connection after sending a close message.
86 var ErrCloseSent = errors.New("websocket: close sent")
88 // ErrReadLimit is returned when reading a message that is larger than the
89 // read limit set for the connection.
90 var ErrReadLimit = errors.New("websocket: read limit exceeded")
92 // netError satisfies the net Error interface.
93 type netError struct {
99 func (e *netError) Error() string { return e.msg }
100 func (e *netError) Temporary() bool { return e.temporary }
101 func (e *netError) Timeout() bool { return e.timeout }
103 // CloseError represents a close message.
104 type CloseError struct {
105 // Code is defined in RFC 6455, section 11.7.
108 // Text is the optional text payload.
112 func (e *CloseError) Error() string {
113 s := []byte("websocket: close ")
114 s = strconv.AppendInt(s, int64(e.Code), 10)
116 case CloseNormalClosure:
117 s = append(s, " (normal)"...)
119 s = append(s, " (going away)"...)
120 case CloseProtocolError:
121 s = append(s, " (protocol error)"...)
122 case CloseUnsupportedData:
123 s = append(s, " (unsupported data)"...)
124 case CloseNoStatusReceived:
125 s = append(s, " (no status)"...)
126 case CloseAbnormalClosure:
127 s = append(s, " (abnormal closure)"...)
128 case CloseInvalidFramePayloadData:
129 s = append(s, " (invalid payload data)"...)
130 case ClosePolicyViolation:
131 s = append(s, " (policy violation)"...)
132 case CloseMessageTooBig:
133 s = append(s, " (message too big)"...)
134 case CloseMandatoryExtension:
135 s = append(s, " (mandatory extension missing)"...)
136 case CloseInternalServerErr:
137 s = append(s, " (internal server error)"...)
138 case CloseTLSHandshake:
139 s = append(s, " (TLS handshake error)"...)
142 s = append(s, ": "...)
143 s = append(s, e.Text...)
148 // IsCloseError returns boolean indicating whether the error is a *CloseError
149 // with one of the specified codes.
150 func IsCloseError(err error, codes ...int) bool {
151 if e, ok := err.(*CloseError); ok {
152 for _, code := range codes {
161 // IsUnexpectedCloseError returns boolean indicating whether the error is a
162 // *CloseError with a code not in the list of expected codes.
163 func IsUnexpectedCloseError(err error, expectedCodes ...int) bool {
164 if e, ok := err.(*CloseError); ok {
165 for _, code := range expectedCodes {
176 errWriteTimeout = &netError{msg: "websocket: write timeout", timeout: true, temporary: true}
177 errUnexpectedEOF = &CloseError{Code: CloseAbnormalClosure, Text: io.ErrUnexpectedEOF.Error()}
178 errBadWriteOpCode = errors.New("websocket: bad write message type")
179 errWriteClosed = errors.New("websocket: write closed")
180 errInvalidControlFrame = errors.New("websocket: invalid control frame")
183 func newMaskKey() [4]byte {
185 return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
188 func hideTempErr(err error) error {
189 if e, ok := err.(net.Error); ok && e.Temporary() {
190 err = &netError{msg: e.Error(), timeout: e.Timeout()}
195 func isControl(frameType int) bool {
196 return frameType == CloseMessage || frameType == PingMessage || frameType == PongMessage
199 func isData(frameType int) bool {
200 return frameType == TextMessage || frameType == BinaryMessage
203 var validReceivedCloseCodes = map[int]bool{
204 // see http://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
206 CloseNormalClosure: true,
207 CloseGoingAway: true,
208 CloseProtocolError: true,
209 CloseUnsupportedData: true,
210 CloseNoStatusReceived: false,
211 CloseAbnormalClosure: false,
212 CloseInvalidFramePayloadData: true,
213 ClosePolicyViolation: true,
214 CloseMessageTooBig: true,
215 CloseMandatoryExtension: true,
216 CloseInternalServerErr: true,
217 CloseServiceRestart: true,
218 CloseTryAgainLater: true,
219 CloseTLSHandshake: false,
222 func isValidReceivedCloseCode(code int) bool {
223 return validReceivedCloseCodes[code] || (code >= 3000 && code <= 4999)
226 // BufferPool represents a pool of buffers. The *sync.Pool type satisfies this
227 // interface. The type of the value stored in a pool is not specified.
228 type BufferPool interface {
229 // Get gets a value from the pool or returns nil if the pool is empty.
231 // Put adds a value to the pool.
235 // writePoolData is the type added to the write buffer pool. This wrapper is
236 // used to prevent applications from peeking at and depending on the values
237 // added to the pool.
238 type writePoolData struct{ buf []byte }
240 // The Conn type represents a WebSocket connection.
247 mu chan bool // used as mutex to protect write to conn
248 writeBuf []byte // frame is constructed in this buffer.
251 writeDeadline time.Time
252 writer io.WriteCloser // the current writer returned to the application
253 isWriting bool // for best-effort concurrent write detection
255 writeErrMu sync.Mutex
258 enableWriteCompression bool
260 newCompressionWriter func(io.WriteCloser, int) io.WriteCloser
263 reader io.ReadCloser // the current reader returned to the application
266 readRemaining int64 // bytes remaining in current frame.
267 readFinal bool // true the current message has more frames.
268 readLength int64 // Message size.
269 readLimit int64 // Maximum message size.
272 handlePong func(string) error
273 handlePing func(string) error
274 handleClose func(int, string) error
276 messageReader *messageReader // the current low-level reader
278 readDecompress bool // whether last read frame had RSV1 set
279 newDecompressionReader func(io.Reader) io.ReadCloser
282 func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int, writeBufferPool BufferPool, br *bufio.Reader, writeBuf []byte) *Conn {
285 if readBufferSize == 0 {
286 readBufferSize = defaultReadBufferSize
287 } else if readBufferSize < maxControlFramePayloadSize {
288 // must be large enough for control frame
289 readBufferSize = maxControlFramePayloadSize
291 br = bufio.NewReaderSize(conn, readBufferSize)
294 if writeBufferSize <= 0 {
295 writeBufferSize = defaultWriteBufferSize
297 writeBufferSize += maxFrameHeaderSize
299 if writeBuf == nil && writeBufferPool == nil {
300 writeBuf = make([]byte, writeBufferSize)
303 mu := make(chan bool, 1)
312 writePool: writeBufferPool,
313 writeBufSize: writeBufferSize,
314 enableWriteCompression: true,
315 compressionLevel: defaultCompressionLevel,
317 c.SetCloseHandler(nil)
318 c.SetPingHandler(nil)
319 c.SetPongHandler(nil)
323 // Subprotocol returns the negotiated protocol for the connection.
324 func (c *Conn) Subprotocol() string {
328 // Close closes the underlying network connection without sending or waiting
329 // for a close message.
330 func (c *Conn) Close() error {
331 return c.conn.Close()
334 // LocalAddr returns the local network address.
335 func (c *Conn) LocalAddr() net.Addr {
336 return c.conn.LocalAddr()
339 // RemoteAddr returns the remote network address.
340 func (c *Conn) RemoteAddr() net.Addr {
341 return c.conn.RemoteAddr()
346 func (c *Conn) writeFatal(err error) error {
347 err = hideTempErr(err)
349 if c.writeErr == nil {
352 c.writeErrMu.Unlock()
356 func (c *Conn) read(n int) ([]byte, error) {
357 p, err := c.br.Peek(n)
359 err = errUnexpectedEOF
365 func (c *Conn) write(frameType int, deadline time.Time, buf0, buf1 []byte) error {
367 defer func() { c.mu <- true }()
371 c.writeErrMu.Unlock()
376 c.conn.SetWriteDeadline(deadline)
378 _, err = c.conn.Write(buf0)
380 err = c.writeBufs(buf0, buf1)
383 return c.writeFatal(err)
385 if frameType == CloseMessage {
386 c.writeFatal(ErrCloseSent)
391 // WriteControl writes a control message with the given deadline. The allowed
392 // message types are CloseMessage, PingMessage and PongMessage.
393 func (c *Conn) WriteControl(messageType int, data []byte, deadline time.Time) error {
394 if !isControl(messageType) {
395 return errBadWriteOpCode
397 if len(data) > maxControlFramePayloadSize {
398 return errInvalidControlFrame
401 b0 := byte(messageType) | finalBit
402 b1 := byte(len(data))
407 buf := make([]byte, 0, maxFrameHeaderSize+maxControlFramePayloadSize)
408 buf = append(buf, b0, b1)
411 buf = append(buf, data...)
414 buf = append(buf, key[:]...)
415 buf = append(buf, data...)
416 maskBytes(key, 0, buf[6:])
419 d := time.Hour * 1000
420 if !deadline.IsZero() {
421 d = deadline.Sub(time.Now())
423 return errWriteTimeout
427 timer := time.NewTimer(d)
432 return errWriteTimeout
434 defer func() { c.mu <- true }()
438 c.writeErrMu.Unlock()
443 c.conn.SetWriteDeadline(deadline)
444 _, err = c.conn.Write(buf)
446 return c.writeFatal(err)
448 if messageType == CloseMessage {
449 c.writeFatal(ErrCloseSent)
454 // beginMessage prepares a connection and message writer for a new message.
455 func (c *Conn) beginMessage(mw *messageWriter, messageType int) error {
456 // Close previous writer if not already closed by the application. It's
457 // probably better to return an error in this situation, but we cannot
458 // change this without breaking existing applications.
464 if !isControl(messageType) && !isData(messageType) {
465 return errBadWriteOpCode
470 c.writeErrMu.Unlock()
476 mw.frameType = messageType
477 mw.pos = maxFrameHeaderSize
479 if c.writeBuf == nil {
480 wpd, ok := c.writePool.Get().(writePoolData)
484 c.writeBuf = make([]byte, c.writeBufSize)
490 // NextWriter returns a writer for the next message to send. The writer's Close
491 // method flushes the complete message to the network.
493 // There can be at most one open writer on a connection. NextWriter closes the
494 // previous writer if the application has not already done so.
496 // All message types (TextMessage, BinaryMessage, CloseMessage, PingMessage and
497 // PongMessage) are supported.
498 func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
500 if err := c.beginMessage(&mw, messageType); err != nil {
504 if c.newCompressionWriter != nil && c.enableWriteCompression && isData(messageType) {
505 w := c.newCompressionWriter(c.writer, c.compressionLevel)
512 type messageWriter struct {
514 compress bool // whether next call to flushFrame should set RSV1
515 pos int // end of data in writeBuf.
516 frameType int // type of the current frame.
520 func (w *messageWriter) endMessage(err error) error {
527 if c.writePool != nil {
528 c.writePool.Put(writePoolData{buf: c.writeBuf})
534 // flushFrame writes buffered data and extra as a frame to the network. The
535 // final argument indicates that this is the last frame in the message.
536 func (w *messageWriter) flushFrame(final bool, extra []byte) error {
538 length := w.pos - maxFrameHeaderSize + len(extra)
540 // Check for invalid control frames.
541 if isControl(w.frameType) &&
542 (!final || length > maxControlFramePayloadSize) {
543 return w.endMessage(errInvalidControlFrame)
546 b0 := byte(w.frameType)
560 // Assume that the frame starts at beginning of c.writeBuf.
563 // Adjust up if mask not included in the header.
568 case length >= 65536:
569 c.writeBuf[framePos] = b0
570 c.writeBuf[framePos+1] = b1 | 127
571 binary.BigEndian.PutUint64(c.writeBuf[framePos+2:], uint64(length))
574 c.writeBuf[framePos] = b0
575 c.writeBuf[framePos+1] = b1 | 126
576 binary.BigEndian.PutUint16(c.writeBuf[framePos+2:], uint16(length))
579 c.writeBuf[framePos] = b0
580 c.writeBuf[framePos+1] = b1 | byte(length)
585 copy(c.writeBuf[maxFrameHeaderSize-4:], key[:])
586 maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:w.pos])
588 return w.endMessage(c.writeFatal(errors.New("websocket: internal error, extra used in client mode")))
592 // Write the buffers to the connection with best-effort detection of
593 // concurrent writes. See the concurrency section in the package
594 // documentation for more info.
597 panic("concurrent write to websocket connection")
601 err := c.write(w.frameType, c.writeDeadline, c.writeBuf[framePos:w.pos], extra)
604 panic("concurrent write to websocket connection")
609 return w.endMessage(err)
613 w.endMessage(errWriteClosed)
617 // Setup for next frame.
618 w.pos = maxFrameHeaderSize
619 w.frameType = continuationFrame
623 func (w *messageWriter) ncopy(max int) (int, error) {
624 n := len(w.c.writeBuf) - w.pos
626 if err := w.flushFrame(false, nil); err != nil {
629 n = len(w.c.writeBuf) - w.pos
637 func (w *messageWriter) Write(p []byte) (int, error) {
642 if len(p) > 2*len(w.c.writeBuf) && w.c.isServer {
643 // Don't buffer large messages.
644 err := w.flushFrame(false, p)
653 n, err := w.ncopy(len(p))
657 copy(w.c.writeBuf[w.pos:], p[:n])
664 func (w *messageWriter) WriteString(p string) (int, error) {
671 n, err := w.ncopy(len(p))
675 copy(w.c.writeBuf[w.pos:], p[:n])
682 func (w *messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
687 if w.pos == len(w.c.writeBuf) {
688 err = w.flushFrame(false, nil)
694 n, err = r.Read(w.c.writeBuf[w.pos:])
707 func (w *messageWriter) Close() error {
711 if err := w.flushFrame(true, nil); err != nil {
717 // WritePreparedMessage writes prepared message into connection.
718 func (c *Conn) WritePreparedMessage(pm *PreparedMessage) error {
719 frameType, frameData, err := pm.frame(prepareKey{
720 isServer: c.isServer,
721 compress: c.newCompressionWriter != nil && c.enableWriteCompression && isData(pm.messageType),
722 compressionLevel: c.compressionLevel,
728 panic("concurrent write to websocket connection")
731 err = c.write(frameType, c.writeDeadline, frameData, nil)
733 panic("concurrent write to websocket connection")
739 // WriteMessage is a helper method for getting a writer using NextWriter,
740 // writing the message and closing the writer.
741 func (c *Conn) WriteMessage(messageType int, data []byte) error {
743 if c.isServer && (c.newCompressionWriter == nil || !c.enableWriteCompression) {
744 // Fast path with no allocations and single frame.
747 if err := c.beginMessage(&mw, messageType); err != nil {
750 n := copy(c.writeBuf[mw.pos:], data)
753 return mw.flushFrame(true, data)
756 w, err := c.NextWriter(messageType)
760 if _, err = w.Write(data); err != nil {
766 // SetWriteDeadline sets the write deadline on the underlying network
767 // connection. After a write has timed out, the websocket state is corrupt and
768 // all future writes will return an error. A zero value for t means writes will
770 func (c *Conn) SetWriteDeadline(t time.Time) error {
777 func (c *Conn) advanceFrame() (int, error) {
778 // 1. Skip remainder of previous frame.
780 if c.readRemaining > 0 {
781 if _, err := io.CopyN(ioutil.Discard, c.br, c.readRemaining); err != nil {
786 // 2. Read and parse first two bytes of frame header.
793 final := p[0]&finalBit != 0
794 frameType := int(p[0] & 0xf)
795 mask := p[1]&maskBit != 0
796 c.readRemaining = int64(p[1] & 0x7f)
798 c.readDecompress = false
799 if c.newDecompressionReader != nil && (p[0]&rsv1Bit) != 0 {
800 c.readDecompress = true
804 if rsv := p[0] & (rsv1Bit | rsv2Bit | rsv3Bit); rsv != 0 {
805 return noFrame, c.handleProtocolError("unexpected reserved bits 0x" + strconv.FormatInt(int64(rsv), 16))
809 case CloseMessage, PingMessage, PongMessage:
810 if c.readRemaining > maxControlFramePayloadSize {
811 return noFrame, c.handleProtocolError("control frame length > 125")
814 return noFrame, c.handleProtocolError("control frame not final")
816 case TextMessage, BinaryMessage:
818 return noFrame, c.handleProtocolError("message start before final message frame")
821 case continuationFrame:
823 return noFrame, c.handleProtocolError("continuation after final message frame")
827 return noFrame, c.handleProtocolError("unknown opcode " + strconv.Itoa(frameType))
830 // 3. Read and parse frame length.
832 switch c.readRemaining {
838 c.readRemaining = int64(binary.BigEndian.Uint16(p))
844 c.readRemaining = int64(binary.BigEndian.Uint64(p))
847 // 4. Handle frame masking.
849 if mask != c.isServer {
850 return noFrame, c.handleProtocolError("incorrect mask flag")
855 p, err := c.read(len(c.readMaskKey))
859 copy(c.readMaskKey[:], p)
862 // 5. For text and binary messages, enforce read limit and return.
864 if frameType == continuationFrame || frameType == TextMessage || frameType == BinaryMessage {
866 c.readLength += c.readRemaining
867 if c.readLimit > 0 && c.readLength > c.readLimit {
868 c.WriteControl(CloseMessage, FormatCloseMessage(CloseMessageTooBig, ""), time.Now().Add(writeWait))
869 return noFrame, ErrReadLimit
872 return frameType, nil
875 // 6. Read control frame payload.
878 if c.readRemaining > 0 {
879 payload, err = c.read(int(c.readRemaining))
885 maskBytes(c.readMaskKey, 0, payload)
889 // 7. Process control frame payload.
893 if err := c.handlePong(string(payload)); err != nil {
897 if err := c.handlePing(string(payload)); err != nil {
901 closeCode := CloseNoStatusReceived
903 if len(payload) >= 2 {
904 closeCode = int(binary.BigEndian.Uint16(payload))
905 if !isValidReceivedCloseCode(closeCode) {
906 return noFrame, c.handleProtocolError("invalid close code")
908 closeText = string(payload[2:])
909 if !utf8.ValidString(closeText) {
910 return noFrame, c.handleProtocolError("invalid utf8 payload in close frame")
913 if err := c.handleClose(closeCode, closeText); err != nil {
916 return noFrame, &CloseError{Code: closeCode, Text: closeText}
919 return frameType, nil
922 func (c *Conn) handleProtocolError(message string) error {
923 c.WriteControl(CloseMessage, FormatCloseMessage(CloseProtocolError, message), time.Now().Add(writeWait))
924 return errors.New("websocket: " + message)
927 // NextReader returns the next data message received from the peer. The
928 // returned messageType is either TextMessage or BinaryMessage.
930 // There can be at most one open reader on a connection. NextReader discards
931 // the previous message if the application has not already consumed it.
933 // Applications must break out of the application's read loop when this method
934 // returns a non-nil error value. Errors returned from this method are
935 // permanent. Once this method returns a non-nil error, all subsequent calls to
936 // this method return the same error.
937 func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
938 // Close previous reader, only relevant for decompression.
944 c.messageReader = nil
947 for c.readErr == nil {
948 frameType, err := c.advanceFrame()
950 c.readErr = hideTempErr(err)
953 if frameType == TextMessage || frameType == BinaryMessage {
954 c.messageReader = &messageReader{c}
955 c.reader = c.messageReader
956 if c.readDecompress {
957 c.reader = c.newDecompressionReader(c.reader)
959 return frameType, c.reader, nil
963 // Applications that do handle the error returned from this method spin in
964 // tight loop on connection failure. To help application developers detect
965 // this error, panic on repeated reads to the failed connection.
967 if c.readErrCount >= 1000 {
968 panic("repeated read on failed websocket connection")
971 return noFrame, nil, c.readErr
974 type messageReader struct{ c *Conn }
976 func (r *messageReader) Read(b []byte) (int, error) {
978 if c.messageReader != r {
982 for c.readErr == nil {
984 if c.readRemaining > 0 {
985 if int64(len(b)) > c.readRemaining {
986 b = b[:c.readRemaining]
988 n, err := c.br.Read(b)
989 c.readErr = hideTempErr(err)
991 c.readMaskPos = maskBytes(c.readMaskKey, c.readMaskPos, b[:n])
993 c.readRemaining -= int64(n)
994 if c.readRemaining > 0 && c.readErr == io.EOF {
995 c.readErr = errUnexpectedEOF
1001 c.messageReader = nil
1005 frameType, err := c.advanceFrame()
1008 c.readErr = hideTempErr(err)
1009 case frameType == TextMessage || frameType == BinaryMessage:
1010 c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
1015 if err == io.EOF && c.messageReader == r {
1016 err = errUnexpectedEOF
1021 func (r *messageReader) Close() error {
1025 // ReadMessage is a helper method for getting a reader using NextReader and
1026 // reading from that reader to a buffer.
1027 func (c *Conn) ReadMessage() (messageType int, p []byte, err error) {
1029 messageType, r, err = c.NextReader()
1031 return messageType, nil, err
1033 p, err = ioutil.ReadAll(r)
1034 return messageType, p, err
1037 // SetReadDeadline sets the read deadline on the underlying network connection.
1038 // After a read has timed out, the websocket connection state is corrupt and
1039 // all future reads will return an error. A zero value for t means reads will
1041 func (c *Conn) SetReadDeadline(t time.Time) error {
1042 return c.conn.SetReadDeadline(t)
1045 // SetReadLimit sets the maximum size in bytes for a message read from the peer. If a
1046 // message exceeds the limit, the connection sends a close message to the peer
1047 // and returns ErrReadLimit to the application.
1048 func (c *Conn) SetReadLimit(limit int64) {
1052 // CloseHandler returns the current close handler
1053 func (c *Conn) CloseHandler() func(code int, text string) error {
1054 return c.handleClose
1057 // SetCloseHandler sets the handler for close messages received from the peer.
1058 // The code argument to h is the received close code or CloseNoStatusReceived
1059 // if the close message is empty. The default close handler sends a close
1060 // message back to the peer.
1062 // The handler function is called from the NextReader, ReadMessage and message
1063 // reader Read methods. The application must read the connection to process
1064 // close messages as described in the section on Control Messages above.
1066 // The connection read methods return a CloseError when a close message is
1067 // received. Most applications should handle close messages as part of their
1068 // normal error handling. Applications should only set a close handler when the
1069 // application must perform some action before sending a close message back to
1071 func (c *Conn) SetCloseHandler(h func(code int, text string) error) {
1073 h = func(code int, text string) error {
1074 message := FormatCloseMessage(code, "")
1075 c.WriteControl(CloseMessage, message, time.Now().Add(writeWait))
1082 // PingHandler returns the current ping handler
1083 func (c *Conn) PingHandler() func(appData string) error {
1087 // SetPingHandler sets the handler for ping messages received from the peer.
1088 // The appData argument to h is the PING message application data. The default
1089 // ping handler sends a pong to the peer.
1091 // The handler function is called from the NextReader, ReadMessage and message
1092 // reader Read methods. The application must read the connection to process
1093 // ping messages as described in the section on Control Messages above.
1094 func (c *Conn) SetPingHandler(h func(appData string) error) {
1096 h = func(message string) error {
1097 err := c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
1098 if err == ErrCloseSent {
1100 } else if e, ok := err.(net.Error); ok && e.Temporary() {
1109 // PongHandler returns the current pong handler
1110 func (c *Conn) PongHandler() func(appData string) error {
1114 // SetPongHandler sets the handler for pong messages received from the peer.
1115 // The appData argument to h is the PONG message application data. The default
1116 // pong handler does nothing.
1118 // The handler function is called from the NextReader, ReadMessage and message
1119 // reader Read methods. The application must read the connection to process
1120 // pong messages as described in the section on Control Messages above.
1121 func (c *Conn) SetPongHandler(h func(appData string) error) {
1123 h = func(string) error { return nil }
1128 // UnderlyingConn returns the internal net.Conn. This can be used to further
1129 // modifications to connection specific flags.
1130 func (c *Conn) UnderlyingConn() net.Conn {
1134 // EnableWriteCompression enables and disables write compression of
1135 // subsequent text and binary messages. This function is a noop if
1136 // compression was not negotiated with the peer.
1137 func (c *Conn) EnableWriteCompression(enable bool) {
1138 c.enableWriteCompression = enable
1141 // SetCompressionLevel sets the flate compression level for subsequent text and
1142 // binary messages. This function is a noop if compression was not negotiated
1143 // with the peer. See the compress/flate package for a description of
1144 // compression levels.
1145 func (c *Conn) SetCompressionLevel(level int) error {
1146 if !isValidCompressionLevel(level) {
1147 return errors.New("websocket: invalid compression level")
1149 c.compressionLevel = level
1153 // FormatCloseMessage formats closeCode and text as a WebSocket close message.
1154 // An empty message is returned for code CloseNoStatusReceived.
1155 func FormatCloseMessage(closeCode int, text string) []byte {
1156 if closeCode == CloseNoStatusReceived {
1157 // Return empty message because it's illegal to send
1158 // CloseNoStatusReceived. Return non-nil value in case application
1162 buf := make([]byte, 2+len(text))
1163 binary.BigEndian.PutUint16(buf, uint16(closeCode))