Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

protocol

package

Go to main page

Versions in this module

v0

v0.4.0

Oct 21, 2025

v0.3.0

Apr 25, 2024

v0.2.2

Feb 23, 2023

v0.2.1

Sep 26, 2022

v0.2.0

Jun 27, 2022

v0.1.1

Feb 3, 2022

v0.1.0

Feb 3, 2022

Changes in this version

+ const MsgTypeHelo

+ const MsgTypePing

+ const MsgTypePong

+ const OptChunk

+ const OptCompressed

+ const OptSize

+ const OptValGZIP

+ func GetChunk(b []byte) (string, error)

+ func ValidatePingDigest(p *Ping, key, nonce []byte) error

+ func ValidatePongDigest(p *Pong, key, nonce, salt []byte) error

+ type AckMessage struct

+ Ack string

+ func (z *AckMessage) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *AckMessage) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z AckMessage) EncodeMsg(en *msgp.Writer) (err error)

+ func (z AckMessage) MarshalMsg(b []byte) (o []byte, err error)

+ func (z AckMessage) Msgsize() (s int)

+ type ChunkEncoder interface

+ Chunk func() (string, error)

+ EncodeMsg func(*msgp.Writer) error

+ type ChunkReader struct

+ R *msgp.Reader

+ func (cr *ChunkReader) Reset(b []byte)

+ type Entry struct

+ Record interface{}

+ Timestamp int64

+ func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Entry) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z Entry) EncodeMsg(en *msgp.Writer) (err error)

+ func (z Entry) MarshalMsg(b []byte) (o []byte, err error)

+ func (z Entry) Msgsize() (s int)

+ type EntryExt struct

+ Record interface{}

+ Timestamp EventTime

+ func (z *EntryExt) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *EntryExt) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z EntryExt) EncodeMsg(en *msgp.Writer) (err error)

+ func (z EntryExt) MarshalMsg(b []byte) (o []byte, err error)

+ func (z EntryExt) Msgsize() (s int)

+ type EntryList []EntryExt

+ func (el *EntryList) UnmarshalPacked(bits []byte) ([]byte, error)

+ func (el EntryList) Equal(e2 EntryList) bool

+ func (el EntryList) MarshalPacked() ([]byte, error)

+ func (z *EntryList) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *EntryList) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z EntryList) EncodeMsg(en *msgp.Writer) (err error)

+ func (z EntryList) MarshalMsg(b []byte) (o []byte, err error)

+ func (z EntryList) Msgsize() (s int)

+ type EventTime struct

+ func EventTimeNow() EventTime

+ func (et *EventTime) ExtensionType() int8

+ func (et *EventTime) Len() int

+ func (et *EventTime) MarshalBinaryTo(b []byte) error

+ func (et *EventTime) UnmarshalBinary(timeBytes []byte) error

+ func (z *EventTime) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *EventTime) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z EventTime) EncodeMsg(en *msgp.Writer) (err error)

+ func (z EventTime) MarshalMsg(b []byte) (o []byte, err error)

+ func (z EventTime) Msgsize() (s int)

+ type ForwardMessage struct

+ Entries EntryList

+ Options *MessageOptions

+ Tag string

+ func NewForwardMessage(tag string, entries EntryList) *ForwardMessage

+ func (fm *ForwardMessage) Chunk() (string, error)

+ func (fm *ForwardMessage) DecodeMsg(dc *msgp.Reader) error

+ func (fm *ForwardMessage) EncodeMsg(dc *msgp.Writer) error

+ func (fm *ForwardMessage) MarshalMsg(bits []byte) ([]byte, error)

+ func (fm *ForwardMessage) Msgsize() (s int)

+ func (fm *ForwardMessage) UnmarshalMsg(bits []byte) ([]byte, error)

+ type GzipCompressor struct

+ Buffer *bytes.Buffer

+ GzipWriter *gzip.Writer

+ func (mc *GzipCompressor) Bytes() []byte

+ func (mc *GzipCompressor) Reset()

+ func (mc *GzipCompressor) Write(bits []byte) error

+ type Helo struct

+ MessageType string

+ Options *HeloOpts

+ func NewHelo(opts *HeloOpts) *Helo

+ func (z *Helo) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Helo) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Helo) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *Helo) Msgsize() (s int)

+ func (z *Helo) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type HeloOpts struct

+ Auth []byte

+ Keepalive bool

+ Nonce []byte

+ func (z *HeloOpts) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *HeloOpts) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *HeloOpts) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *HeloOpts) Msgsize() (s int)

+ func (z *HeloOpts) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type Message struct

+ Options *MessageOptions

+ Record interface{}

+ Tag string

+ Timestamp int64

+ func NewMessage(tag string, record interface{}) *Message

+ func (msg *Message) Chunk() (string, error)

+ func (msg *Message) DecodeMsg(dc *msgp.Reader) error

+ func (msg *Message) Msgsize() (s int)

+ func (msg *Message) UnmarshalMsg(bits []byte) ([]byte, error)

+ func (z *Message) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Message) MarshalMsg(b []byte) (o []byte, err error)

+ type MessageExt struct

+ Options *MessageOptions

+ Record interface{}

+ Tag string

+ Timestamp EventTime

+ func NewMessageExt(tag string, record interface{}) *MessageExt

+ func (msg *MessageExt) Chunk() (string, error)

+ func (msg *MessageExt) DecodeMsg(dc *msgp.Reader) error

+ func (msg *MessageExt) Msgsize() (s int)

+ func (msg *MessageExt) UnmarshalMsg(bits []byte) ([]byte, error)

+ func (z *MessageExt) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *MessageExt) MarshalMsg(b []byte) (o []byte, err error)

+ type MessageOptions struct

+ Chunk string

+ Compressed string

+ Size *int

+ func (z *MessageOptions) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *MessageOptions) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *MessageOptions) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *MessageOptions) Msgsize() (s int)

+ func (z *MessageOptions) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PackedForwardMessage struct

+ EventStream []byte

+ Options *MessageOptions

+ Tag string

+ func NewCompressedPackedForwardMessage(tag string, entries []EntryExt) (*PackedForwardMessage, error)

+ func NewCompressedPackedForwardMessageFromBytes(tag string, entries []byte) (*PackedForwardMessage, error)

+ func NewPackedForwardMessage(tag string, entries EntryList) (*PackedForwardMessage, error)

+ func NewPackedForwardMessageFromBytes(tag string, entries []byte) *PackedForwardMessage

+ func (msg *PackedForwardMessage) Chunk() (string, error)

+ func (msg *PackedForwardMessage) DecodeMsg(dc *msgp.Reader) error

+ func (msg *PackedForwardMessage) Msgsize() (s int)

+ func (msg *PackedForwardMessage) UnmarshalMsg(bits []byte) ([]byte, error)

+ func (z *PackedForwardMessage) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PackedForwardMessage) MarshalMsg(b []byte) (o []byte, err error)

+ type Ping struct

+ ClientHostname string

+ MessageType string

+ Password string

+ SharedKeyHexDigest []byte

+ SharedKeySalt []byte

+ Username string

+ func NewPing(hostname string, sharedKey, salt, nonce []byte) (*Ping, error)

+ func NewPingWithAuth(hostname string, sharedKey, salt, nonce []byte, username, password string) (*Ping, error)

+ func (z *Ping) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Ping) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Ping) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *Ping) Msgsize() (s int)

+ func (z *Ping) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type Pong struct

+ AuthResult bool

+ MessageType string

+ Reason string

+ ServerHostname string

+ SharedKeyHexDigest []byte

+ func NewPong(authResult bool, reason string, hostname string, sharedKey []byte, helo *Helo, ...) (*Pong, error)

+ func (z *Pong) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Pong) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Pong) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *Pong) Msgsize() (s int)

+ func (z *Pong) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type RawMessage []byte

+ func (rm RawMessage) Chunk() (string, error)

+ func (rm RawMessage) EncodeMsg(w *msgp.Writer) error

+ func (z *RawMessage) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *RawMessage) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z RawMessage) MarshalMsg(b []byte) (o []byte, err error)

+ func (z RawMessage) Msgsize() (s int)