gobwas/ws

For a high-level implementation, use the wsutil package to handle message reading and writing. This approach abstracts the protocol internals while providing a simple interface for common tasks like reading client data and writing server messages.

Use ws.UpgradeHTTP to upgrade an incoming http.Request and wsutil.ReadClientData / wsutil.WriteServerMessage for the I/O loop.

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
				}
			}
		}()
	}))
})

The ws/wsflate package provides support for the Permessage-Deflate Compression Extension. It is compatible with wsutil's reader and writer via the wsflate.MessageState type, which implements wsutil.SendExtension and wsutil.RecvExtension.

To use compression with wsutil:

1. Use ws.Upgrader.Negotiate with wsflate.Extension.Negotiate.
2. Initialize wsflate.Reader and wsflate.Writer with appropriate flate implementations.
3. Use a wsflate.MessageState variable to track compression state.
4. When configuring wsutil.Reader, include ws.StateExtended in the state and add the MessageState to the Extensions slice.
5. When configuring wsutil.Writer, include ws.StateExtended and use wr.SetExtensions(&msg).

// ... (Upgrade and negotiate compression) ...

// Initialize flate reader/writer
fr := wsflate.NewReader(nil, func(r io.Reader) wsflate.Decompressor {
	return flate.NewReader(r)
})
fw := wsflate.NewWriter(nil, func(w io.Writer) wsflate.Compressor {
	f, _ := flate.NewWriter(w, 9)
	return f
})

var msg wsflate.MessageState

rd := &wsutil.Reader{
	Source:     conn,
	State:      ws.StateServerSide | ws.StateExtended,
	Extensions: []wsutil.RecvExtension{
		&msg, 
	},
}

wr := wsutil.NewWriter(conn, ws.StateServerSide|ws.StateExtended, 0)
wr.SetExtensions(&msg)

for {
	h, err := rd.NextFrame()
	// ... handle error ...

	wr.Reset(h.OpCode)

	fr.Reset(rd)
	fw.Reset(wr)

	if _, err := io.Copy(fw, fr); err != nil {
		// handle error
	}
	if err := fw.Close(); err != nil {
		// handle error
	}
	if err := wr.Flush(); err != nil {
		// handle error
	}
}

For better performance and buffer reuse, use wsutil.NewReader and wsutil.NewWriter. This allows you to use io.Copy to stream data between the reader and writer efficiently. You must call writer.Reset for each new frame to ensure the correct OpCode is used.

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
				}
			}
		}()
	}))
}

For maximum control and zero intermediate allocations, use the ws package directly. You are responsible for reading the header with ws.ReadHeader, reading the payload, handling masking with ws.Cipher (if header.Masked is true), and writing the header back with ws.WriteHeader.

Note: Per RFC6455, server frames must not be masked. If you read a masked frame from a client, you must unmask it before processing or re-sending.

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
				}
			}
		}()
	}
}

The ws.Upgrader allows for high-performance, zero-copy HTTP upgrades by processing non-websocket headers in-place via callbacks. This is ideal for high-load services that need to control connection resources (like buffers) at the TCP level.

Key fields in ws.Upgrader:

• OnHost: Callback to validate the Host header. Returning ws.RejectConnectionError allows you to reject connections early.
• OnHeader: Callback to process non-websocket headers in-place. Arguments are only valid until the callback returns.
• OnBeforeUpgrade: Callback to provide the handshake headers to be sent back to the client.
• Negotiate: Callback used to negotiate extensions (like compression).

package main

import (
	"log"
	"net"

	"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
		}
	}
}