wsutil

Jul 11, 2021

Changes in this version

+ var ErrFrameTooLarge = errors.New("frame too large")

type Reader

+ Extensions []RecvExtension

+ MaxFrameSize int64

+ type RecvExtension interface

+ UnsetBits func(ws.Header) (ws.Header, error)

+ type RecvExtensionFunc func(ws.Header) (ws.Header, error)

+ func (fn RecvExtensionFunc) UnsetBits(h ws.Header) (ws.Header, error)

+ type SendExtension interface

+ SetBits func(ws.Header) (ws.Header, error)

+ type SendExtensionFunc func(ws.Header) (ws.Header, error)

+ func (fn SendExtensionFunc) SetBits(h ws.Header) (ws.Header, error)

type Writer

+ func (w *Writer) DisableFlush()

+ func (w *Writer) Grow(n int)

+ func (w *Writer) ResetOp(op ws.OpCode)

+ func (w *Writer) SetExtensions(xs ...SendExtension)

Aug 5, 2018

Changes in this version

+ var ErrNotControlFrame = errors.New("not a control frame")

+ func HandleClientControlMessage(conn io.Writer, msg Message) error

+ func HandleControlMessage(conn io.Writer, state ws.State, msg Message) error

+ func HandleServerControlMessage(conn io.Writer, msg Message) error

type ControlHandler

+ DisableSrcCiphering bool

+ Dst io.Writer

+ Src io.Reader

+ State ws.State

+ func (c ControlHandler) Handle(h ws.Header) error

+ func (c ControlHandler) HandleClose(h ws.Header) error

+ func (c ControlHandler) HandlePing(h ws.Header) error

+ func (c ControlHandler) HandlePong(h ws.Header) error

+ type FrameHandlerFunc func(ws.Header, io.Reader) error

+ func ControlFrameHandler(w io.Writer, state ws.State) FrameHandlerFunc

type UTF8Reader

+ func (u *UTF8Reader) Accepted() int

May 5, 2018

Changes in this version

+ var DefaultWriteBuffer = 4096

+ var ErrControlOverflow = fmt.Errorf("control frame payload overflow")

+ var ErrInvalidUTF8 = fmt.Errorf("invalid utf8")

+ var ErrNoFrameAdvance = errors.New("no frame advance")

+ var ErrNotEmpty = fmt.Errorf("writer not empty")

+ func HandleClientControl(conn io.Writer, op ws.OpCode, p []byte) error

+ func HandleServerControl(conn io.Writer, op ws.OpCode, p []byte) error

+ func NextReader(r io.Reader, s ws.State) (ws.Header, io.Reader, error)

+ func PutWriter(w *Writer)

+ func ReadClientBinary(rw io.ReadWriter) ([]byte, error)

+ func ReadClientData(rw io.ReadWriter) ([]byte, ws.OpCode, error)

+ func ReadClientText(rw io.ReadWriter) ([]byte, error)

+ func ReadData(rw io.ReadWriter, s ws.State) ([]byte, ws.OpCode, error)

+ func ReadServerBinary(rw io.ReadWriter) ([]byte, error)

+ func ReadServerData(rw io.ReadWriter) ([]byte, ws.OpCode, error)

+ func ReadServerText(rw io.ReadWriter) ([]byte, error)

+ func WriteClientBinary(w io.Writer, p []byte) error

+ func WriteClientMessage(w io.Writer, op ws.OpCode, p []byte) error

+ func WriteClientText(w io.Writer, p []byte) error

+ func WriteMessage(w io.Writer, s ws.State, op ws.OpCode, p []byte) error

+ func WriteServerBinary(w io.Writer, p []byte) error

+ func WriteServerMessage(w io.Writer, op ws.OpCode, p []byte) error

+ func WriteServerText(w io.Writer, p []byte) error

+ type CipherReader struct

+ func NewCipherReader(r io.Reader, mask [4]byte) *CipherReader

+ func (c *CipherReader) Read(p []byte) (n int, err error)

+ func (c *CipherReader) Reset(r io.Reader, mask [4]byte)

+ type CipherWriter struct

+ func NewCipherWriter(w io.Writer, mask [4]byte) *CipherWriter

+ func (c *CipherWriter) Reset(w io.Writer, mask [4]byte)

+ func (c *CipherWriter) Write(p []byte) (n int, err error)

+ type ClosedError struct

+ func (err ClosedError) Code() ws.StatusCode

+ func (err ClosedError) Error() string

+ func (err ClosedError) Reason() string

+ type ControlWriter struct

+ func NewControlWriter(dest io.Writer, state ws.State, op ws.OpCode) *ControlWriter

+ func NewControlWriterBuffer(dest io.Writer, state ws.State, op ws.OpCode, buf []byte) *ControlWriter

+ func (c *ControlWriter) Flush() error

+ func (c *ControlWriter) Write(p []byte) (n int, err error)

+ type DebugDialer struct

+ Dialer ws.Dialer

+ OnRequest func([]byte)

+ OnResponse func([]byte)

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

+ type DebugUpgrader struct

+ OnRequest func([]byte)

+ OnResponse func([]byte)

+ Upgrader ws.Upgrader

+ func (d *DebugUpgrader) Upgrade(conn io.ReadWriter) (hs ws.Handshake, err error)

+ type FrameHandler func(h ws.Header, r io.Reader) error

+ func CloseHandler(w io.Writer, state ws.State) FrameHandler

+ func ControlHandler(w io.Writer, state ws.State) FrameHandler

+ func PingHandler(w io.Writer, state ws.State) FrameHandler

+ func PongHandler(w io.Writer, state ws.State) FrameHandler

+ type Message struct

+ OpCode ws.OpCode

+ Payload []byte

+ func ReadClientMessage(r io.Reader, m []Message) ([]Message, error)

+ func ReadMessage(r io.Reader, s ws.State, m []Message) ([]Message, error)

+ func ReadServerMessage(r io.Reader, m []Message) ([]Message, error)

+ type Reader struct

+ CheckUTF8 bool

+ OnContinuation FrameHandler

+ OnIntermediate FrameHandler

+ SkipHeaderCheck bool

+ Source io.Reader

+ State ws.State

+ func NewClientSideReader(r io.Reader) *Reader

+ func NewReader(r io.Reader, s ws.State) *Reader

+ func NewServerSideReader(r io.Reader) *Reader

+ func (r *Reader) Discard() (err error)

+ func (r *Reader) NextFrame() (hdr ws.Header, err error)

+ func (r *Reader) Read(p []byte) (n int, err error)

+ type UTF8Reader struct

+ Source io.Reader

+ func NewUTF8Reader(r io.Reader) *UTF8Reader

+ func (u *UTF8Reader) Read(p []byte) (n int, err error)

+ func (u *UTF8Reader) Reset(r io.Reader)

+ func (u *UTF8Reader) Valid() bool

+ type Writer struct

+ func GetWriter(dest io.Writer, state ws.State, op ws.OpCode, n int) *Writer

+ func NewWriter(dest io.Writer, state ws.State, op ws.OpCode) *Writer

+ func NewWriterBuffer(dest io.Writer, state ws.State, op ws.OpCode, buf []byte) *Writer

+ func NewWriterBufferSize(dest io.Writer, state ws.State, op ws.OpCode, n int) *Writer

+ func NewWriterSize(dest io.Writer, state ws.State, op ws.OpCode, n int) *Writer

+ func (w *Writer) Available() int

+ func (w *Writer) Buffered() int

+ func (w *Writer) Flush() error

+ func (w *Writer) FlushFragment() error

+ func (w *Writer) ReadFrom(src io.Reader) (n int64, err error)

+ func (w *Writer) Reset(dest io.Writer, state ws.State, op ws.OpCode)

+ func (w *Writer) Size() int

+ func (w *Writer) Write(p []byte) (n int, err error)

+ func (w *Writer) WriteThrough(p []byte) (n int, err error)