README

ws

GoDoc Travis

RFC6455 WebSocket implementation in Go.

Features

  • Zero-copy upgrade
  • No intermediate allocations during I/O
  • Low-level API which allows to build your own logic of packet handling and buffers reuse
  • High-level wrappers and helpers around API in wsutil package, which allow to start fast without digging the protocol internals

Documentation

GoDoc.

Why

Existing WebSocket implementations do not allow users to reuse I/O buffers between connections in clear way. This library aims to export efficient low-level interface for working with the protocol without forcing only one way it could be used.

By the way, if you want get the higher-level tools, you can use wsutil package.

Status

Library is tagged as v1* so its API must not be broken during some improvements or refactoring.

This implementation of RFC6455 passes Autobahn Test Suite and currently has about 78% coverage.

Examples

Example applications using ws are developed in separate repository ws-examples.

Usage

The higher-level example of WebSocket echo server:

package main

import (
	"net/http"

	"github.com/gobwas/ws"
	"github.com/gobwas/ws/wsutil"
)

func main() {
	http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		conn, _, _, err := ws.UpgradeHTTP(r, w)
		if err != nil {
			// handle error
		}
		go func() {
			defer conn.Close()

			for {
				msg, op, err := wsutil.ReadClientData(conn)
				if err != nil {
					// handle error
				}
				err = wsutil.WriteServerMessage(conn, op, msg)
				if err != nil {
					// handle error
				}
			}
		}()
	}))
}

Lower-level, but still high-level example:

import (
	"net/http"
	"io"

	"github.com/gobwas/ws"
	"github.com/gobwas/ws/wsutil"
)

func main() {
	http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		conn, _, _, err := ws.UpgradeHTTP(r, w)
		if err != nil {
			// handle error
		}
		go func() {
			defer conn.Close()

			var (
				state  = ws.StateServerSide
				reader = wsutil.NewReader(conn, state)
				writer = wsutil.NewWriter(conn, state, ws.OpText)
			)
			for {
				header, err := reader.NextFrame()
				if err != nil {
					// handle error
				}

				// Reset writer to write frame with right operation code.
				writer.Reset(conn, state, header.OpCode)

				if _, err = io.Copy(writer, reader); err != nil {
					// handle error
				}
				if err = writer.Flush(); err != nil {
					// handle error
				}
			}
		}()
	}))
}

We can apply the same pattern to read and write structured responses through a JSON encoder and decoder.:

	...
	var (
		r = wsutil.NewReader(conn, ws.StateServerSide)
		w = wsutil.NewWriter(conn, ws.StateServerSide, ws.OpText)
		decoder = json.NewDecoder(r)
		encoder = json.NewEncoder(w)
	)
	for {
		hdr, err = r.NextFrame()
		if err != nil {
			return err
		}
		if hdr.OpCode == ws.OpClose {
			return io.EOF
		}
		var req Request
		if err := decoder.Decode(&req); err != nil {
			return err
		}
		var resp Response
		if err := encoder.Encode(&resp); err != nil {
			return err
		}
		if err = w.Flush(); err != nil {
			return err
		}
	}
	...

The lower-level example without wsutil:

package main

import (
	"net"
	"io"

	"github.com/gobwas/ws"
)

func main() {
	ln, err := net.Listen("tcp", "localhost:8080")
	if err != nil {
		log.Fatal(err)
	}

	for {
		conn, err := ln.Accept()
		if err != nil {
			// handle error
		}
		_, err = ws.Upgrade(conn)
		if err != nil {
			// handle error
		}

		go func() {
			defer conn.Close()

			for {
				header, err := ws.ReadHeader(conn)
				if err != nil {
					// handle error
				}

				payload := make([]byte, header.Length)
				_, err = io.ReadFull(conn, payload)
				if err != nil {
					// handle error
				}
				if header.Masked {
					ws.Cipher(payload, header.Mask, 0)
				}

				// Reset the Masked flag, server frames must not be masked as
				// RFC6455 says.
				header.Masked = false

				if err := ws.WriteHeader(conn, header); err != nil {
					// handle error
				}
				if _, err := conn.Write(payload); err != nil {
					// handle error
				}

				if header.OpCode == ws.OpClose {
					return
				}
			}
		}()
	}
}

Zero-copy upgrade

Zero-copy upgrade helps to avoid unnecessary allocations and copying while handling HTTP Upgrade request.

Processing of all non-websocket headers is made in place with use of registered user callbacks whose arguments are only valid until callback returns.

The simple example looks like this:

package main

import (
	"net"
	"log"

	"github.com/gobwas/ws"
)

func main() {
	ln, err := net.Listen("tcp", "localhost:8080")
	if err != nil {
		log.Fatal(err)
	}
	u := ws.Upgrader{
		OnHeader: func(key, value []byte) (err error) {
			log.Printf("non-websocket header: %q=%q", key, value)
			return
		},
	}
	for {
		conn, err := ln.Accept()
		if err != nil {
			// handle error
		}

		_, err = u.Upgrade(conn)
		if err != nil {
			// handle error
		}
	}
}

Usage of ws.Upgrader here brings ability to control incoming connections on tcp level and simply not to accept them by some logic.

Zero-copy upgrade is for high-load services which have to control many resources such as connections buffers.

The real life example could be like this:

package main

import (
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	"runtime"

	"github.com/gobwas/httphead"
	"github.com/gobwas/ws"
)

func main() {
	ln, err := net.Listen("tcp", "localhost:8080")
	if err != nil {
		// handle error
	}

	// Prepare handshake header writer from http.Header mapping.
	header := ws.HandshakeHeaderHTTP(http.Header{
		"X-Go-Version": []string{runtime.Version()},
	})

	u := ws.Upgrader{
		OnHost: func(host []byte) error {
			if string(host) == "github.com" {
				return nil
			}
			return ws.RejectConnectionError(
				ws.RejectionStatus(403),
				ws.RejectionHeader(ws.HandshakeHeaderString(
					"X-Want-Host: github.com\r\n",
				)),
			)
		},
		OnHeader: func(key, value []byte) error {
			if string(key) != "Cookie" {
				return nil
			}
			ok := httphead.ScanCookie(value, func(key, value []byte) bool {
				// Check session here or do some other stuff with cookies.
				// Maybe copy some values for future use.
				return true
			})
			if ok {
				return nil
			}
			return ws.RejectConnectionError(
				ws.RejectionReason("bad cookie"),
				ws.RejectionStatus(400),
			)
		},
		OnBeforeUpgrade: func() (ws.HandshakeHeader, error) {
			return header, nil
		},
	}
	for {
		conn, err := ln.Accept()
		if err != nil {
			log.Fatal(err)
		}
		_, err = u.Upgrade(conn)
		if err != nil {
			log.Printf("upgrade error: %s", err)
		}
	}
}
Expand ▾ Collapse ▴

Documentation

Overview

    Package ws implements a client and server for the WebSocket protocol as specified in RFC 6455.

    The main purpose of this package is to provide simple low-level API for efficient work with protocol.

    Overview.

    Upgrade to WebSocket (or WebSocket handshake) can be done in two ways.

    The first way is to use `net/http` server:

      http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    	  conn, _, _, err := ws.UpgradeHTTP(r, w)
      })
    

    The second and much more efficient way is so-called "zero-copy upgrade". It avoids redundant allocations and copying of not used headers or other request data. User decides by himself which data should be copied.

      ln, err := net.Listen("tcp", ":8080")
      if err != nil {
    	  // handle error
      }
    
      conn, err := ln.Accept()
      if err != nil {
    	  // handle error
      }
    
      handshake, err := ws.Upgrade(conn)
      if err != nil {
    	  // handle error
      }
    

    For customization details see `ws.Upgrader` documentation.

    After WebSocket handshake you can work with connection in multiple ways. That is, `ws` does not force the only one way of how to work with WebSocket:

      header, err := ws.ReadHeader(conn)
      if err != nil {
    	  // handle err
      }
    
      buf := make([]byte, header.Length)
      _, err := io.ReadFull(conn, buf)
      if err != nil {
    	  // handle err
      }
    
      resp := ws.NewBinaryFrame([]byte("hello, world!"))
      if err := ws.WriteFrame(conn, frame); err != nil {
          // handle err
      }
    

    As you can see, it stream friendly:

      const N = 42
    
      ws.WriteHeader(ws.Header{
    	  Fin:    true,
    	  Length: N,
    	  OpCode: ws.OpBinary,
      })
    
      io.CopyN(conn, rand.Reader, N)
    

    Or:

      header, err := ws.ReadHeader(conn)
      if err != nil {
    	  // handle err
      }
    
      io.CopyN(ioutil.Discard, conn, header.Length)
    

    For more info see the documentation.

    Index

    Constants

    View Source
    const (
    	DefaultClientReadBufferSize  = 4096
    	DefaultClientWriteBufferSize = 4096
    )

      Constants used by Dialer.

      View Source
      const (
      	DefaultServerReadBufferSize  = 4096
      	DefaultServerWriteBufferSize = 512
      )

        Constants used by ConnUpgrader.

        View Source
        const (
        	MaxHeaderSize = 14
        	MinHeaderSize = 2
        )

          Header size length bounds in bytes.

          View Source
          const (
          	// All control frames MUST have a payload length of 125 bytes or less and MUST NOT be fragmented.
          	MaxControlFramePayloadSize = 125
          )

            Constants defined by specification.

            Variables

            View Source
            var (
            	ErrProtocolOpCodeReserved             = ProtocolError("use of reserved op code")
            	ErrProtocolControlPayloadOverflow     = ProtocolError("control frame payload limit exceeded")
            	ErrProtocolControlNotFinal            = ProtocolError("control frame is not final")
            	ErrProtocolNonZeroRsv                 = ProtocolError("non-zero rsv bits with no extension negotiated")
            	ErrProtocolMaskRequired               = ProtocolError("frames from client to server must be masked")
            	ErrProtocolMaskUnexpected             = ProtocolError("frames from server to client must be not masked")
            	ErrProtocolContinuationExpected       = ProtocolError("unexpected non-continuation data frame")
            	ErrProtocolContinuationUnexpected     = ProtocolError("unexpected continuation data frame")
            	ErrProtocolStatusCodeNotInUse         = ProtocolError("status code is not in use")
            	ErrProtocolStatusCodeApplicationLevel = ProtocolError("status code is only application level")
            	ErrProtocolStatusCodeNoMeaning        = ProtocolError("status code has no meaning yet")
            	ErrProtocolStatusCodeUnknown          = ProtocolError("status code is not defined in spec")
            	ErrProtocolInvalidUTF8                = ProtocolError("invalid utf8 sequence in close reason")
            )

              Errors used by the protocol checkers.

              View Source
              var (
              	ErrHandshakeBadStatus      = fmt.Errorf("unexpected http status")
              	ErrHandshakeBadSubProtocol = fmt.Errorf("unexpected protocol in %q header", headerSecProtocol)
              	ErrHandshakeBadExtensions  = fmt.Errorf("unexpected extensions in %q header", headerSecProtocol)
              )

                Errors used by the websocket client.

                View Source
                var (
                	StatusRangeNotInUse    = StatusCodeRange{0, 999}
                	StatusRangeProtocol    = StatusCodeRange{1000, 2999}
                	StatusRangeApplication = StatusCodeRange{3000, 3999}
                	StatusRangePrivate     = StatusCodeRange{4000, 4999}
                )

                  Status code ranges defined by specification. See https://tools.ietf.org/html/rfc6455#section-7.4.2

                  View Source
                  var (
                  	CompiledPing  = MustCompileFrame(NewPingFrame(nil))
                  	CompiledPong  = MustCompileFrame(NewPongFrame(nil))
                  	CompiledClose = MustCompileFrame(NewCloseFrame(nil))
                  
                  	CompiledCloseNormalClosure           = MustCompileFrame(closeFrameNormalClosure)
                  	CompiledCloseGoingAway               = MustCompileFrame(closeFrameGoingAway)
                  	CompiledCloseProtocolError           = MustCompileFrame(closeFrameProtocolError)
                  	CompiledCloseUnsupportedData         = MustCompileFrame(closeFrameUnsupportedData)
                  	CompiledCloseNoMeaningYet            = MustCompileFrame(closeFrameNoMeaningYet)
                  	CompiledCloseInvalidFramePayloadData = MustCompileFrame(closeFrameInvalidFramePayloadData)
                  	CompiledClosePolicyViolation         = MustCompileFrame(closeFramePolicyViolation)
                  	CompiledCloseMessageTooBig           = MustCompileFrame(closeFrameMessageTooBig)
                  	CompiledCloseMandatoryExt            = MustCompileFrame(closeFrameMandatoryExt)
                  	CompiledCloseInternalServerError     = MustCompileFrame(closeFrameInternalServerError)
                  	CompiledCloseTLSHandshake            = MustCompileFrame(closeFrameTLSHandshake)
                  )

                    Compiled control frames for common use cases. For construct-serialize optimizations.

                    View Source
                    var (
                    	ErrHeaderLengthMSB        = fmt.Errorf("header error: the most significant bit must be 0")
                    	ErrHeaderLengthUnexpected = fmt.Errorf("header error: unexpected payload length bits")
                    )

                      Errors used by frame reader.

                      View Source
                      var (
                      	ErrHandshakeBadProtocol = RejectConnectionError(
                      		RejectionStatus(http.StatusHTTPVersionNotSupported),
                      		RejectionReason(fmt.Sprintf("handshake error: bad HTTP protocol version")),
                      	)
                      	ErrHandshakeBadMethod = RejectConnectionError(
                      		RejectionStatus(http.StatusMethodNotAllowed),
                      		RejectionReason(fmt.Sprintf("handshake error: bad HTTP request method")),
                      	)
                      	ErrHandshakeBadHost = RejectConnectionError(
                      		RejectionStatus(http.StatusBadRequest),
                      		RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerHost)),
                      	)
                      	ErrHandshakeBadUpgrade = RejectConnectionError(
                      		RejectionStatus(http.StatusBadRequest),
                      		RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerUpgrade)),
                      	)
                      	ErrHandshakeBadConnection = RejectConnectionError(
                      		RejectionStatus(http.StatusBadRequest),
                      		RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerConnection)),
                      	)
                      	ErrHandshakeBadSecAccept = RejectConnectionError(
                      		RejectionStatus(http.StatusBadRequest),
                      		RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerSecAccept)),
                      	)
                      	ErrHandshakeBadSecKey = RejectConnectionError(
                      		RejectionStatus(http.StatusBadRequest),
                      		RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerSecKey)),
                      	)
                      	ErrHandshakeBadSecVersion = RejectConnectionError(
                      		RejectionStatus(http.StatusBadRequest),
                      		RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerSecVersion)),
                      	)
                      )

                        Errors used by both client and server when preparing WebSocket handshake.

                        View Source
                        var ErrHandshakeUpgradeRequired = RejectConnectionError(
                        	RejectionStatus(http.StatusUpgradeRequired),
                        	RejectionHeader(HandshakeHeaderString(headerSecVersion+": 13\r\n")),
                        	RejectionReason(fmt.Sprintf("handshake error: bad %q header", headerSecVersion)),
                        )

                          ErrHandshakeUpgradeRequired is returned by Upgrader to indicate that connection is rejected because given WebSocket version is malformed.

                          According to RFC6455: If this version does not match a version understood by the server, the server MUST abort the WebSocket handshake described in this section and instead send an appropriate HTTP error code (such as 426 Upgrade Required) and a |Sec-WebSocket-Version| header field indicating the version(s) the server is capable of understanding.

                          View Source
                          var ErrMalformedRequest = RejectConnectionError(
                          	RejectionStatus(http.StatusBadRequest),
                          	RejectionReason("malformed HTTP request"),
                          )

                            ErrMalformedRequest is returned when HTTP request can not be parsed.

                            View Source
                            var ErrMalformedResponse = fmt.Errorf("malformed HTTP response")

                              ErrMalformedResponse is returned by Dialer to indicate that server response can not be parsed.

                              View Source
                              var ErrNotHijacker = RejectConnectionError(
                              	RejectionStatus(http.StatusInternalServerError),
                              	RejectionReason("given http.ResponseWriter is not a http.Hijacker"),
                              )

                                ErrNotHijacker is an error returned when http.ResponseWriter does not implement http.Hijacker interface.

                                Functions

                                func CheckCloseFrameData

                                func CheckCloseFrameData(code StatusCode, reason string) error

                                  CheckCloseFrameData checks received close information to be valid RFC6455 compatible close info.

                                  Note that code.Empty() or code.IsAppLevel() will raise error.

                                  If endpoint sends close frame without status code (with frame.Length = 0), application should not check its payload.

                                  func CheckHeader

                                  func CheckHeader(h Header, s State) error

                                    CheckHeader checks h to contain valid header data for given state s.

                                    Note that zero state (0) means that state is clean, neither server or client side, nor fragmented, nor extended.

                                    func Cipher

                                    func Cipher(payload []byte, mask [4]byte, offset int)

                                      Cipher applies XOR cipher to the payload using mask. Offset is used to cipher chunked data (e.g. in io.Reader implementations).

                                      To convert masked data into unmasked data, or vice versa, the following algorithm is applied. The same algorithm applies regardless of the direction of the translation, e.g., the same steps are applied to mask the data as to unmask the data.

                                      func CompileFrame

                                      func CompileFrame(f Frame) (bts []byte, err error)

                                        CompileFrame returns byte representation of given frame. In terms of memory consumption it is useful to precompile static frames which are often used.

                                        func HeaderSize

                                        func HeaderSize(h Header) (n int)

                                          HeaderSize returns number of bytes that are needed to encode given header. It returns -1 if header is malformed.

                                          func MustCompileFrame

                                          func MustCompileFrame(f Frame) []byte

                                            MustCompileFrame is like CompileFrame but panics if frame can not be encoded.

                                            func MustWriteFrame

                                            func MustWriteFrame(w io.Writer, f Frame)

                                              MustWriteFrame is like WriteFrame but panics if frame can not be read.

                                              func NewCloseFrameBody

                                              func NewCloseFrameBody(code StatusCode, reason string) []byte

                                                NewCloseFrameBody encodes a closure code and a reason into a binary representation.

                                                It returns slice which is at most MaxControlFramePayloadSize bytes length. If the reason is too big it will be cropped to fit the limit defined by the spec.

                                                See https://tools.ietf.org/html/rfc6455#section-5.5

                                                func NewMask

                                                func NewMask() (ret [4]byte)

                                                  NewMask creates new random mask.

                                                  func PutCloseFrameBody

                                                  func PutCloseFrameBody(p []byte, code StatusCode, reason string)

                                                    PutCloseFrameBody encodes code and reason into buf.

                                                    It will panic if the buffer is too small to accommodate a code or a reason.

                                                    PutCloseFrameBody does not check buffer to be RFC compliant, but note that by RFC it must be at most MaxControlFramePayloadSize.

                                                    func PutReader

                                                    func PutReader(br *bufio.Reader)

                                                      PutReader returns bufio.Reader instance to the inner reuse pool. It is useful in rare cases, when Dialer.Dial() returns non-nil buffer which contains unprocessed buffered data, that was sent by the server quickly right after handshake.

                                                      func RejectConnectionError

                                                      func RejectConnectionError(options ...RejectOption) error

                                                        RejectConnectionError constructs an error that could be used to control the way handshake is rejected by Upgrader.

                                                        func Rsv

                                                        func Rsv(r1, r2, r3 bool) (rsv byte)

                                                          Rsv creates rsv byte representation.

                                                          func SelectEqual

                                                          func SelectEqual(v string) func(string) bool

                                                            SelectEqual creates accept function that could be used as Protocol/Extension select during upgrade.

                                                            func SelectFromSlice

                                                            func SelectFromSlice(accept []string) func(string) bool

                                                              SelectFromSlice creates accept function that could be used as Protocol/Extension select during upgrade.

                                                              func WriteFrame

                                                              func WriteFrame(w io.Writer, f Frame) error

                                                                WriteFrame writes frame binary representation into w.

                                                                func WriteHeader

                                                                func WriteHeader(w io.Writer, h Header) error

                                                                  WriteHeader writes header binary representation into w.

                                                                  Types

                                                                  type Dialer

                                                                  type Dialer struct {
                                                                  	// ReadBufferSize and WriteBufferSize is an I/O buffer sizes.
                                                                  	// They used to read and write http data while upgrading to WebSocket.
                                                                  	// Allocated buffers are pooled with sync.Pool to avoid extra allocations.
                                                                  	//
                                                                  	// If a size is zero then default value is used.
                                                                  	ReadBufferSize, WriteBufferSize int
                                                                  
                                                                  	// Timeout is the maximum amount of time a Dial() will wait for a connect
                                                                  	// and an handshake to complete.
                                                                  	//
                                                                  	// The default is no timeout.
                                                                  	Timeout time.Duration
                                                                  
                                                                  	// Protocols is the list of subprotocols that the client wants to speak,
                                                                  	// ordered by preference.
                                                                  	//
                                                                  	// See https://tools.ietf.org/html/rfc6455#section-4.1
                                                                  	Protocols []string
                                                                  
                                                                  	// Extensions is the list of extensions that client wants to speak.
                                                                  	//
                                                                  	// Note that if server decides to use some of this extensions, Dial() will
                                                                  	// return Handshake struct containing a slice of items, which are the
                                                                  	// shallow copies of the items from this list. That is, internals of
                                                                  	// Extensions items are shared during Dial().
                                                                  	//
                                                                  	// See https://tools.ietf.org/html/rfc6455#section-4.1
                                                                  	// See https://tools.ietf.org/html/rfc6455#section-9.1
                                                                  	Extensions []httphead.Option
                                                                  
                                                                  	// Header is an optional HandshakeHeader instance that could be used to
                                                                  	// write additional headers to the handshake request.
                                                                  	//
                                                                  	// It used instead of any key-value mappings to avoid allocations in user
                                                                  	// land.
                                                                  	Header HandshakeHeader
                                                                  
                                                                  	// OnStatusError is the callback that will be called after receiving non
                                                                  	// "101 Continue" HTTP response status. It receives an io.Reader object
                                                                  	// representing server response bytes. That is, it gives ability to parse
                                                                  	// HTTP response somehow (probably with http.ReadResponse call) and make a
                                                                  	// decision of further logic.
                                                                  	//
                                                                  	// The arguments are only valid until the callback returns.
                                                                  	OnStatusError func(status int, reason []byte, resp io.Reader)
                                                                  
                                                                  	// OnHeader is the callback that will be called after successful parsing of
                                                                  	// header, that is not used during WebSocket handshake procedure. That is,
                                                                  	// it will be called with non-websocket headers, which could be relevant
                                                                  	// for application-level logic.
                                                                  	//
                                                                  	// The arguments are only valid until the callback returns.
                                                                  	//
                                                                  	// Returned value could be used to prevent processing response.
                                                                  	OnHeader func(key, value []byte) (err error)
                                                                  
                                                                  	// NetDial is the function that is used to get plain tcp connection.
                                                                  	// If it is not nil, then it is used instead of net.Dialer.
                                                                  	NetDial func(ctx context.Context, network, addr string) (net.Conn, error)
                                                                  
                                                                  	// TLSClient is the callback that will be called after successful dial with
                                                                  	// received connection and its remote host name. If it is nil, then the
                                                                  	// default tls.Client() will be used.
                                                                  	// If it is not nil, then TLSConfig field is ignored.
                                                                  	TLSClient func(conn net.Conn, hostname string) net.Conn
                                                                  
                                                                  	// TLSConfig is passed to tls.Client() to start TLS over established
                                                                  	// connection. If TLSClient is not nil, then it is ignored. If TLSConfig is
                                                                  	// non-nil and its ServerName is empty, then for every Dial() it will be
                                                                  	// cloned and appropriate ServerName will be set.
                                                                  	TLSConfig *tls.Config
                                                                  
                                                                  	// WrapConn is the optional callback that will be called when connection is
                                                                  	// ready for an i/o. That is, it will be called after successful dial and
                                                                  	// TLS initialization (for "wss" schemes). It may be helpful for different
                                                                  	// user land purposes such as end to end encryption.
                                                                  	//
                                                                  	// Note that for debugging purposes of an http handshake (e.g. sent request
                                                                  	// and received response), there is an wsutil.DebugDialer struct.
                                                                  	WrapConn func(conn net.Conn) net.Conn
                                                                  }

                                                                    Dialer contains options for establishing websocket connection to an url.

                                                                    var DefaultDialer Dialer

                                                                      DefaultDialer is dialer that holds no options and is used by Dial function.

                                                                      func (Dialer) Dial

                                                                      func (d Dialer) Dial(ctx context.Context, urlstr string) (conn net.Conn, br *bufio.Reader, hs Handshake, err error)

                                                                        Dial connects to the url host and upgrades connection to WebSocket.

                                                                        If server has sent frames right after successful handshake then returned buffer will be non-nil. In other cases buffer is always nil. For better memory efficiency received non-nil bufio.Reader should be returned to the inner pool with PutReader() function after use.

                                                                        Note that Dialer does not implement IDNA (RFC5895) logic as net/http does. If you want to dial non-ascii host name, take care of its name serialization avoiding bad request issues. For more info see net/http Request.Write() implementation, especially cleanHost() function.

                                                                        func (Dialer) Upgrade

                                                                        func (d Dialer) Upgrade(conn io.ReadWriter, u *url.URL) (br *bufio.Reader, hs Handshake, err error)

                                                                          Upgrade writes an upgrade request to the given io.ReadWriter conn at given url u and reads a response from it.

                                                                          It is a caller responsibility to manage I/O deadlines on conn.

                                                                          It returns handshake info and some bytes which could be written by the peer right after response and be caught by us during buffered read.

                                                                          type Frame

                                                                          type Frame struct {
                                                                          	Header  Header
                                                                          	Payload []byte
                                                                          }

                                                                            Frame represents websocket frame. See https://tools.ietf.org/html/rfc6455#section-5.2

                                                                            func MaskFrame

                                                                            func MaskFrame(f Frame) Frame

                                                                              MaskFrame masks frame and returns frame with masked payload and Mask header's field set. Note that it copies f payload to prevent collisions. For less allocations you could use MaskFrameInPlace or construct frame manually.

                                                                              func MaskFrameInPlace

                                                                              func MaskFrameInPlace(f Frame) Frame

                                                                                MaskFrameInPlace masks frame and returns frame with masked payload and Mask header's field set. Note that it applies xor cipher to f.Payload without copying, that is, it modifies f.Payload inplace.

                                                                                func MaskFrameInPlaceWith

                                                                                func MaskFrameInPlaceWith(f Frame, m [4]byte) Frame

                                                                                  MaskFrameInPlaceWith masks frame with given mask and returns frame with masked payload and Mask header's field set. Note that it applies xor cipher to f.Payload without copying, that is, it modifies f.Payload inplace.

                                                                                  func MaskFrameWith

                                                                                  func MaskFrameWith(f Frame, mask [4]byte) Frame

                                                                                    MaskFrameWith masks frame with given mask and returns frame with masked payload and Mask header's field set. Note that it copies f payload to prevent collisions. For less allocations you could use MaskFrameInPlaceWith or construct frame manually.

                                                                                    func MustReadFrame

                                                                                    func MustReadFrame(r io.Reader) Frame

                                                                                      MustReadFrame is like ReadFrame but panics if frame can not be read.

                                                                                      func NewBinaryFrame

                                                                                      func NewBinaryFrame(p []byte) Frame

                                                                                        NewBinaryFrame creates binary frame with p as payload. Note that p is not copied.

                                                                                        func NewCloseFrame

                                                                                        func NewCloseFrame(p []byte) Frame

                                                                                          NewCloseFrame creates close frame with given close body. Note that p is not copied. Note that p must have length of MaxControlFramePayloadSize bytes or less due to RFC.

                                                                                          func NewFrame

                                                                                          func NewFrame(op OpCode, fin bool, p []byte) Frame

                                                                                            NewFrame creates frame with given operation code, flag of completeness and payload bytes.

                                                                                            func NewPingFrame

                                                                                            func NewPingFrame(p []byte) Frame

                                                                                              NewPingFrame creates ping frame with p as payload. Note that p is not copied. Note that p must have length of MaxControlFramePayloadSize bytes or less due to RFC.

                                                                                              func NewPongFrame

                                                                                              func NewPongFrame(p []byte) Frame

                                                                                                NewPongFrame creates pong frame with p as payload. Note that p is not copied. Note that p must have length of MaxControlFramePayloadSize bytes or less due to RFC.

                                                                                                func NewTextFrame

                                                                                                func NewTextFrame(p []byte) Frame

                                                                                                  NewTextFrame creates text frame with p as payload. Note that p is not copied.

                                                                                                  func ReadFrame

                                                                                                  func ReadFrame(r io.Reader) (f Frame, err error)

                                                                                                    ReadFrame reads a frame from r. It is not designed for high optimized use case cause it makes allocation for frame.Header.Length size inside to read frame payload into.

                                                                                                    Note that ReadFrame does not unmask payload.

                                                                                                    type HTTPUpgrader

                                                                                                    type HTTPUpgrader struct {
                                                                                                    	// Timeout is the maximum amount of time an Upgrade() will spent while
                                                                                                    	// writing handshake response.
                                                                                                    	//
                                                                                                    	// The default is no timeout.
                                                                                                    	Timeout time.Duration
                                                                                                    
                                                                                                    	// Header is an optional http.Header mapping that could be used to
                                                                                                    	// write additional headers to the handshake response.
                                                                                                    	//
                                                                                                    	// Note that if present, it will be written in any result of handshake.
                                                                                                    	Header http.Header
                                                                                                    
                                                                                                    	// Protocol is the select function that is used to select subprotocol from
                                                                                                    	// list requested by client. If this field is set, then the first matched
                                                                                                    	// protocol is sent to a client as negotiated.
                                                                                                    	Protocol func(string) bool
                                                                                                    
                                                                                                    	// Extension is the select function that is used to select extensions from
                                                                                                    	// list requested by client. If this field is set, then the all matched
                                                                                                    	// extensions are sent to a client as negotiated.
                                                                                                    	Extension func(httphead.Option) bool
                                                                                                    }

                                                                                                      HTTPUpgrader contains options for upgrading connection to websocket from net/http Handler arguments.

                                                                                                      var DefaultHTTPUpgrader HTTPUpgrader

                                                                                                        DefaultHTTPUpgrader is an HTTPUpgrader that holds no options and is used by UpgradeHTTP function.

                                                                                                        func (HTTPUpgrader) Upgrade

                                                                                                        func (u HTTPUpgrader) Upgrade(r *http.Request, w http.ResponseWriter) (conn net.Conn, rw *bufio.ReadWriter, hs Handshake, err error)

                                                                                                          Upgrade upgrades http connection to the websocket connection.

                                                                                                          It hijacks net.Conn from w and returns received net.Conn and bufio.ReadWriter. On successful handshake it returns Handshake struct describing handshake info.

                                                                                                          type Handshake

                                                                                                          type Handshake struct {
                                                                                                          	// Protocol is the subprotocol selected during handshake.
                                                                                                          	Protocol string
                                                                                                          
                                                                                                          	// Extensions is the list of negotiated extensions.
                                                                                                          	Extensions []httphead.Option
                                                                                                          }

                                                                                                            Handshake represents handshake result.

                                                                                                            func Dial

                                                                                                            func Dial(ctx context.Context, urlstr string) (net.Conn, *bufio.Reader, Handshake, error)

                                                                                                              Dial is like Dialer{}.Dial().

                                                                                                              func Upgrade

                                                                                                              func Upgrade(conn io.ReadWriter) (Handshake, error)

                                                                                                                Upgrade is like Upgrader{}.Upgrade().

                                                                                                                func UpgradeHTTP

                                                                                                                  UpgradeHTTP is like HTTPUpgrader{}.Upgrade().

                                                                                                                  type HandshakeHeader

                                                                                                                  type HandshakeHeader interface {
                                                                                                                  	io.WriterTo
                                                                                                                  }

                                                                                                                    HandshakeHeader is the interface that writes both upgrade request or response headers into a given io.Writer.

                                                                                                                    type HandshakeHeaderBytes

                                                                                                                    type HandshakeHeaderBytes []byte

                                                                                                                      HandshakeHeaderBytes is an adapter to allow the use of headers represented by ordinary slice of bytes as HandshakeHeader.

                                                                                                                      func (HandshakeHeaderBytes) WriteTo

                                                                                                                      func (b HandshakeHeaderBytes) WriteTo(w io.Writer) (int64, error)

                                                                                                                        WriteTo implements HandshakeHeader (and io.WriterTo) interface.

                                                                                                                        type HandshakeHeaderFunc

                                                                                                                        type HandshakeHeaderFunc func(io.Writer) (int64, error)

                                                                                                                          HandshakeHeaderFunc is an adapter to allow the use of headers represented by ordinary function as HandshakeHeader.

                                                                                                                          func (HandshakeHeaderFunc) WriteTo

                                                                                                                          func (f HandshakeHeaderFunc) WriteTo(w io.Writer) (int64, error)

                                                                                                                            WriteTo implements HandshakeHeader (and io.WriterTo) interface.

                                                                                                                            type HandshakeHeaderHTTP

                                                                                                                            type HandshakeHeaderHTTP http.Header

                                                                                                                              HandshakeHeaderHTTP is an adapter to allow the use of http.Header as HandshakeHeader.

                                                                                                                              func (HandshakeHeaderHTTP) WriteTo

                                                                                                                              func (h HandshakeHeaderHTTP) WriteTo(w io.Writer) (int64, error)

                                                                                                                                WriteTo implements HandshakeHeader (and io.WriterTo) interface.

                                                                                                                                type HandshakeHeaderString

                                                                                                                                type HandshakeHeaderString string

                                                                                                                                  HandshakeHeaderString is an adapter to allow the use of headers represented by ordinary string as HandshakeHeader.

                                                                                                                                  func (HandshakeHeaderString) WriteTo

                                                                                                                                  func (s HandshakeHeaderString) WriteTo(w io.Writer) (int64, error)

                                                                                                                                    WriteTo implements HandshakeHeader (and io.WriterTo) interface.

                                                                                                                                    type Header struct {
                                                                                                                                    	Fin    bool
                                                                                                                                    	Rsv    byte
                                                                                                                                    	OpCode OpCode
                                                                                                                                    	Masked bool
                                                                                                                                    	Mask   [4]byte
                                                                                                                                    	Length int64
                                                                                                                                    }

                                                                                                                                      Header represents websocket frame header. See https://tools.ietf.org/html/rfc6455#section-5.2

                                                                                                                                      func ReadHeader

                                                                                                                                      func ReadHeader(r io.Reader) (h Header, err error)

                                                                                                                                        ReadHeader reads a frame header from r.

                                                                                                                                        func (Header) Rsv1

                                                                                                                                        func (h Header) Rsv1() bool

                                                                                                                                          Rsv1 reports whether the header has first rsv bit set.

                                                                                                                                          func (Header) Rsv2

                                                                                                                                          func (h Header) Rsv2() bool

                                                                                                                                            Rsv2 reports whether the header has second rsv bit set.

                                                                                                                                            func (Header) Rsv3

                                                                                                                                            func (h Header) Rsv3() bool

                                                                                                                                              Rsv3 reports whether the header has third rsv bit set.

                                                                                                                                              type OpCode

                                                                                                                                              type OpCode byte

                                                                                                                                                OpCode represents operation code.

                                                                                                                                                const (
                                                                                                                                                	OpContinuation OpCode = 0x0
                                                                                                                                                	OpText         OpCode = 0x1
                                                                                                                                                	OpBinary       OpCode = 0x2
                                                                                                                                                	OpClose        OpCode = 0x8
                                                                                                                                                	OpPing         OpCode = 0x9
                                                                                                                                                	OpPong         OpCode = 0xa
                                                                                                                                                )

                                                                                                                                                  Operation codes defined by specification. See https://tools.ietf.org/html/rfc6455#section-5.2

                                                                                                                                                  func (OpCode) IsControl

                                                                                                                                                  func (c OpCode) IsControl() bool

                                                                                                                                                    IsControl checks whether the c is control operation code. See https://tools.ietf.org/html/rfc6455#section-5.5

                                                                                                                                                    func (OpCode) IsData

                                                                                                                                                    func (c OpCode) IsData() bool

                                                                                                                                                      IsData checks whether the c is data operation code. See https://tools.ietf.org/html/rfc6455#section-5.6

                                                                                                                                                      func (OpCode) IsReserved

                                                                                                                                                      func (c OpCode) IsReserved() bool

                                                                                                                                                        IsReserved checks whether the c is reserved operation code. See https://tools.ietf.org/html/rfc6455#section-5.2

                                                                                                                                                        type ProtocolError

                                                                                                                                                        type ProtocolError string

                                                                                                                                                          ProtocolError describes error during checking/parsing websocket frames or headers.

                                                                                                                                                          func (ProtocolError) Error

                                                                                                                                                          func (p ProtocolError) Error() string

                                                                                                                                                            Error implements error interface.

                                                                                                                                                            type RejectOption

                                                                                                                                                            type RejectOption func(*rejectConnectionError)

                                                                                                                                                              RejectOption represents an option used to control the way connection is rejected.

                                                                                                                                                              func RejectionHeader

                                                                                                                                                              func RejectionHeader(h HandshakeHeader) RejectOption

                                                                                                                                                                RejectionHeader returns an option that makes connection to be rejected with given HTTP headers.

                                                                                                                                                                func RejectionReason

                                                                                                                                                                func RejectionReason(reason string) RejectOption

                                                                                                                                                                  RejectionReason returns an option that makes connection to be rejected with given reason.

                                                                                                                                                                  func RejectionStatus

                                                                                                                                                                  func RejectionStatus(code int) RejectOption

                                                                                                                                                                    RejectionStatus returns an option that makes connection to be rejected with given HTTP status code.

                                                                                                                                                                    type State

                                                                                                                                                                    type State uint8

                                                                                                                                                                      State represents state of websocket endpoint. It used by some functions to be more strict when checking compatibility with RFC6455.

                                                                                                                                                                      const (
                                                                                                                                                                      	// StateServerSide means that endpoint (caller) is a server.
                                                                                                                                                                      	StateServerSide State = 0x1 << iota
                                                                                                                                                                      	// StateClientSide means that endpoint (caller) is a client.
                                                                                                                                                                      	StateClientSide
                                                                                                                                                                      	// StateExtended means that extension was negotiated during handshake.
                                                                                                                                                                      	StateExtended
                                                                                                                                                                      	// StateFragmented means that endpoint (caller) has received fragmented
                                                                                                                                                                      	// frame and waits for continuation parts.
                                                                                                                                                                      	StateFragmented
                                                                                                                                                                      )

                                                                                                                                                                      func (State) Clear

                                                                                                                                                                      func (s State) Clear(v State) State

                                                                                                                                                                        Clear disables v state on s.

                                                                                                                                                                        func (State) ClientSide

                                                                                                                                                                        func (s State) ClientSide() bool

                                                                                                                                                                          ClientSide reports whether state represents client side.

                                                                                                                                                                          func (State) Extended

                                                                                                                                                                          func (s State) Extended() bool

                                                                                                                                                                            Extended reports whether state is extended.

                                                                                                                                                                            func (State) Fragmented

                                                                                                                                                                            func (s State) Fragmented() bool

                                                                                                                                                                              Fragmented reports whether state is fragmented.

                                                                                                                                                                              func (State) Is

                                                                                                                                                                              func (s State) Is(v State) bool

                                                                                                                                                                                Is checks whether the s has v enabled.

                                                                                                                                                                                func (State) ServerSide

                                                                                                                                                                                func (s State) ServerSide() bool

                                                                                                                                                                                  ServerSide reports whether states represents server side.

                                                                                                                                                                                  func (State) Set

                                                                                                                                                                                  func (s State) Set(v State) State

                                                                                                                                                                                    Set enables v state on s.

                                                                                                                                                                                    type StatusCode

                                                                                                                                                                                    type StatusCode uint16

                                                                                                                                                                                      StatusCode represents the encoded reason for closure of websocket connection.

                                                                                                                                                                                      There are few helper methods on StatusCode that helps to define a range in which given code is lay in. accordingly to ranges defined in specification.

                                                                                                                                                                                      See https://tools.ietf.org/html/rfc6455#section-7.4

                                                                                                                                                                                      const (
                                                                                                                                                                                      	StatusNormalClosure           StatusCode = 1000
                                                                                                                                                                                      	StatusGoingAway               StatusCode = 1001
                                                                                                                                                                                      	StatusProtocolError           StatusCode = 1002
                                                                                                                                                                                      	StatusUnsupportedData         StatusCode = 1003
                                                                                                                                                                                      	StatusNoMeaningYet            StatusCode = 1004
                                                                                                                                                                                      	StatusInvalidFramePayloadData StatusCode = 1007
                                                                                                                                                                                      	StatusPolicyViolation         StatusCode = 1008
                                                                                                                                                                                      	StatusMessageTooBig           StatusCode = 1009
                                                                                                                                                                                      	StatusMandatoryExt            StatusCode = 1010
                                                                                                                                                                                      	StatusInternalServerError     StatusCode = 1011
                                                                                                                                                                                      	StatusTLSHandshake            StatusCode = 1015
                                                                                                                                                                                      
                                                                                                                                                                                      	// StatusAbnormalClosure is a special code designated for use in
                                                                                                                                                                                      	// applications.
                                                                                                                                                                                      	StatusAbnormalClosure StatusCode = 1006
                                                                                                                                                                                      
                                                                                                                                                                                      	// StatusNoStatusRcvd is a special code designated for use in applications.
                                                                                                                                                                                      	StatusNoStatusRcvd StatusCode = 1005
                                                                                                                                                                                      )

                                                                                                                                                                                        Status codes defined by specification. See https://tools.ietf.org/html/rfc6455#section-7.4.1

                                                                                                                                                                                        func ParseCloseFrameData

                                                                                                                                                                                        func ParseCloseFrameData(payload []byte) (code StatusCode, reason string)

                                                                                                                                                                                          ParseCloseFrameData parses close frame status code and closure reason if any provided. If there is no status code in the payload the empty status code is returned (code.Empty()) with empty string as a reason.

                                                                                                                                                                                          func ParseCloseFrameDataUnsafe

                                                                                                                                                                                          func ParseCloseFrameDataUnsafe(payload []byte) (code StatusCode, reason string)

                                                                                                                                                                                            ParseCloseFrameDataUnsafe is like ParseCloseFrameData except the thing that it does not copies payload bytes into reason, but prepares unsafe cast.

                                                                                                                                                                                            func (StatusCode) Empty

                                                                                                                                                                                            func (s StatusCode) Empty() bool

                                                                                                                                                                                              Empty reports whether the code is empty. Empty code has no any meaning neither app level codes nor other. This method is useful just to check that code is golang default value 0.

                                                                                                                                                                                              func (StatusCode) In

                                                                                                                                                                                                In reports whether the code is defined in given range.

                                                                                                                                                                                                func (StatusCode) IsApplicationSpec

                                                                                                                                                                                                func (s StatusCode) IsApplicationSpec() bool

                                                                                                                                                                                                  IsApplicationSpec reports whether the code should be defined by application, framework or libraries specification.

                                                                                                                                                                                                  func (StatusCode) IsNotUsed

                                                                                                                                                                                                  func (s StatusCode) IsNotUsed() bool

                                                                                                                                                                                                    IsNotUsed reports whether the code is predefined in not used range.

                                                                                                                                                                                                    func (StatusCode) IsPrivateSpec

                                                                                                                                                                                                    func (s StatusCode) IsPrivateSpec() bool

                                                                                                                                                                                                      IsPrivateSpec reports whether the code should be defined privately.

                                                                                                                                                                                                      func (StatusCode) IsProtocolDefined

                                                                                                                                                                                                      func (s StatusCode) IsProtocolDefined() bool

                                                                                                                                                                                                        IsProtocolDefined reports whether the code is already defined by protocol specification.

                                                                                                                                                                                                        func (StatusCode) IsProtocolReserved

                                                                                                                                                                                                        func (s StatusCode) IsProtocolReserved() bool

                                                                                                                                                                                                          IsProtocolReserved reports whether the code is defined by protocol specification to be reserved only for application usage purpose.

                                                                                                                                                                                                          func (StatusCode) IsProtocolSpec

                                                                                                                                                                                                          func (s StatusCode) IsProtocolSpec() bool

                                                                                                                                                                                                            IsProtocolSpec reports whether the code should be defined by protocol specification.

                                                                                                                                                                                                            type StatusCodeRange

                                                                                                                                                                                                            type StatusCodeRange struct {
                                                                                                                                                                                                            	Min, Max StatusCode
                                                                                                                                                                                                            }

                                                                                                                                                                                                              StatusCodeRange describes range of StatusCode values.

                                                                                                                                                                                                              type StatusError

                                                                                                                                                                                                              type StatusError int

                                                                                                                                                                                                                StatusError contains an unexpected status-line code from the server.

                                                                                                                                                                                                                func (StatusError) Error

                                                                                                                                                                                                                func (s StatusError) Error() string

                                                                                                                                                                                                                type Upgrader

                                                                                                                                                                                                                type Upgrader struct {
                                                                                                                                                                                                                	// ReadBufferSize and WriteBufferSize is an I/O buffer sizes.
                                                                                                                                                                                                                	// They used to read and write http data while upgrading to WebSocket.
                                                                                                                                                                                                                	// Allocated buffers are pooled with sync.Pool to avoid extra allocations.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// If a size is zero then default value is used.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// Usually it is useful to set read buffer size bigger than write buffer
                                                                                                                                                                                                                	// size because incoming request could contain long header values, such as
                                                                                                                                                                                                                	// Cookie. Response, in other way, could be big only if user write multiple
                                                                                                                                                                                                                	// custom headers. Usually response takes less than 256 bytes.
                                                                                                                                                                                                                	ReadBufferSize, WriteBufferSize int
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Protocol is a select function that is used to select subprotocol
                                                                                                                                                                                                                	// from list requested by client. If this field is set, then the first matched
                                                                                                                                                                                                                	// protocol is sent to a client as negotiated.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// The argument is only valid until the callback returns.
                                                                                                                                                                                                                	Protocol func([]byte) bool
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// ProtocolCustrom allow user to parse Sec-WebSocket-Protocol header manually.
                                                                                                                                                                                                                	// Note that returned bytes must be valid until Upgrade returns.
                                                                                                                                                                                                                	// If ProtocolCustom is set, it used instead of Protocol function.
                                                                                                                                                                                                                	ProtocolCustom func([]byte) (string, bool)
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Extension is a select function that is used to select extensions
                                                                                                                                                                                                                	// from list requested by client. If this field is set, then the all matched
                                                                                                                                                                                                                	// extensions are sent to a client as negotiated.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// The argument is only valid until the callback returns.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// According to the RFC6455 order of extensions passed by a client is
                                                                                                                                                                                                                	// significant. That is, returning true from this function means that no
                                                                                                                                                                                                                	// other extension with the same name should be checked because server
                                                                                                                                                                                                                	// accepted the most preferable extension right now:
                                                                                                                                                                                                                	// "Note that the order of extensions is significant.  Any interactions between
                                                                                                                                                                                                                	// multiple extensions MAY be defined in the documents defining the extensions.
                                                                                                                                                                                                                	// In the absence of such definitions, the interpretation is that the header
                                                                                                                                                                                                                	// fields listed by the client in its request represent a preference of the
                                                                                                                                                                                                                	// header fields it wishes to use, with the first options listed being most
                                                                                                                                                                                                                	// preferable."
                                                                                                                                                                                                                	Extension func(httphead.Option) bool
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// ExtensionCustom allow user to parse Sec-WebSocket-Extensions header manually.
                                                                                                                                                                                                                	// Note that returned options should be valid until Upgrade returns.
                                                                                                                                                                                                                	// If ExtensionCustom is set, it used instead of Extension function.
                                                                                                                                                                                                                	ExtensionCustom func([]byte, []httphead.Option) ([]httphead.Option, bool)
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Header is an optional HandshakeHeader instance that could be used to
                                                                                                                                                                                                                	// write additional headers to the handshake response.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// It used instead of any key-value mappings to avoid allocations in user
                                                                                                                                                                                                                	// land.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// Note that if present, it will be written in any result of handshake.
                                                                                                                                                                                                                	Header HandshakeHeader
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// OnRequest is a callback that will be called after request line
                                                                                                                                                                                                                	// successful parsing.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// The arguments are only valid until the callback returns.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// If returned error is non-nil then connection is rejected and response is
                                                                                                                                                                                                                	// sent with appropriate HTTP error code and body set to error message.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// RejectConnectionError could be used to get more control on response.
                                                                                                                                                                                                                	OnRequest func(uri []byte) error
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// OnHost is a callback that will be called after "Host" header successful
                                                                                                                                                                                                                	// parsing.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// It is separated from OnHeader callback because the Host header must be
                                                                                                                                                                                                                	// present in each request since HTTP/1.1. Thus Host header is non-optional
                                                                                                                                                                                                                	// and required for every WebSocket handshake.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// The arguments are only valid until the callback returns.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// If returned error is non-nil then connection is rejected and response is
                                                                                                                                                                                                                	// sent with appropriate HTTP error code and body set to error message.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// RejectConnectionError could be used to get more control on response.
                                                                                                                                                                                                                	OnHost func(host []byte) error
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// OnHeader is a callback that will be called after successful parsing of
                                                                                                                                                                                                                	// header, that is not used during WebSocket handshake procedure. That is,
                                                                                                                                                                                                                	// it will be called with non-websocket headers, which could be relevant
                                                                                                                                                                                                                	// for application-level logic.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// The arguments are only valid until the callback returns.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// If returned error is non-nil then connection is rejected and response is
                                                                                                                                                                                                                	// sent with appropriate HTTP error code and body set to error message.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// RejectConnectionError could be used to get more control on response.
                                                                                                                                                                                                                	OnHeader func(key, value []byte) error
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// OnBeforeUpgrade is a callback that will be called before sending
                                                                                                                                                                                                                	// successful upgrade response.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// Setting OnBeforeUpgrade allows user to make final application-level
                                                                                                                                                                                                                	// checks and decide whether this connection is allowed to successfully
                                                                                                                                                                                                                	// upgrade to WebSocket.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// It must return non-nil either HandshakeHeader or error and never both.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// If returned error is non-nil then connection is rejected and response is
                                                                                                                                                                                                                	// sent with appropriate HTTP error code and body set to error message.
                                                                                                                                                                                                                	//
                                                                                                                                                                                                                	// RejectConnectionError could be used to get more control on response.
                                                                                                                                                                                                                	OnBeforeUpgrade func() (header HandshakeHeader, err error)
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  Upgrader contains options for upgrading connection to websocket.

                                                                                                                                                                                                                  var DefaultUpgrader Upgrader

                                                                                                                                                                                                                    DefaultUpgrader is an Upgrader that holds no options and is used by Upgrade function.

                                                                                                                                                                                                                    func (Upgrader) Upgrade

                                                                                                                                                                                                                    func (u Upgrader) Upgrade(conn io.ReadWriter) (hs Handshake, err error)

                                                                                                                                                                                                                      Upgrade zero-copy upgrades connection to WebSocket. It interprets given conn as connection with incoming HTTP Upgrade request.

                                                                                                                                                                                                                      It is a caller responsibility to manage i/o timeouts on conn.

                                                                                                                                                                                                                      Non-nil error means that request for the WebSocket upgrade is invalid or malformed and usually connection should be closed. Even when error is non-nil Upgrade will write appropriate response into connection in compliance with RFC.

                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                      example
                                                                                                                                                                                                                      Package wsutil provides utilities for working with WebSocket protocol.
                                                                                                                                                                                                                      Package wsutil provides utilities for working with WebSocket protocol.