README
¶
binproto
binproto implements low-level support for binary-based two-way communication protocols. You can use it to create your own low-latency binary protocols for things like game networking or file transfer.
Documentation
¶
Overview ¶
Package binproto implements low-level support for binary-based two-way communication protocols.
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ( ErrMessageSizeExceeded = errors.New("binproto: message too big") ErrMessageMalformed = errors.New("binproto: message malformed") )
Functions ¶
This section is empty.
Types ¶
type Conn ¶
A Conn represents a binary network protocol connection. It consists of a Reader and Writer to manage I/O and a Pipeline (which is borrowed from textproto) to sequence concurrent requests on the connection.
func Dial ¶
Dial connects to the given address on the given network using net.Dial and then returns a new Conn for the connection.
Example ¶
package main
import (
"fmt"
"log"
"net"
"time"
"github.com/onur1/binproto"
)
func main() {
s := &server{}
time.AfterFunc(time.Millisecond*1, func() {
c, err := binproto.Dial("tcp", ":4242")
if err != nil {
log.Fatal(err)
}
go func() {
for {
msg, err := c.ReadMessage()
if err != nil {
log.Fatal(err)
return
}
fmt.Printf("%d %d %s\n", msg.ID, msg.Channel, msg.Data)
s.close()
}
}()
_, err = c.Send(binproto.NewMessage(42, 3, []byte("hi")))
if err != nil {
log.Fatal(err)
}
})
if err := s.serve("tcp", ":4242"); err != nil {
log.Fatal(err)
}
}
type server struct {
listener net.Listener
}
func (s *server) handle(conn net.Conn) {
defer conn.Close()
c := binproto.NewConn(conn)
for {
msg, err := c.ReadMessage()
if err != nil {
fmt.Printf("error: %v", err)
return
}
fmt.Printf("%d %d %s\n", msg.ID, msg.Channel, msg.Data)
_, err = c.Send(binproto.NewMessage(112, 5, []byte("hey")))
if err != nil {
log.Fatal(err)
}
}
}
func (s *server) serve(network, address string) error {
l, err := net.Listen(network, address)
if err != nil {
return err
}
s.listener = l
for {
if s.listener == nil {
break
}
c, err := l.Accept()
if err != nil {
continue
}
go s.handle(c)
}
return nil
}
func (s *server) close() error {
err := s.listener.Close()
s.listener = nil
return err
}
Output: 42 3 hi 112 5 hey
func NewConn ¶
func NewConn(conn io.ReadWriteCloser) *Conn
NewConn returns a new Conn using conn for I/O.
type Message ¶
A Message represents a single binproto message.
Each message starts with an header which is a varint encoded unsigned 64-bit integer which consists of an ID (first 60-bits) and a Channel number (last 4-bits), the rest of the message is payload.
type Reader ¶
type Reader struct {
// contains filtered or unexported fields
}
A Reader implements convenience methods for reading requests or responses from a binary protocol network connection.
func NewReader ¶
NewReader returns a new Reader reading from r.
By default, a Reader allocates `4096` bytes for its internal buffer, and will process what's inside the buffer as long as its size is greater than this limit.
func NewReaderSize ¶
NewReaderSize returns a new Reader with the specified buffer size.
func (*Reader) ReadMessage ¶
ReadMessage reads a single message from r.
type Writer ¶
type Writer struct {
// contains filtered or unexported fields
}
A Writer implements convenience methods for writing requests or responses to a binary protocol network connection.
func (*Writer) WriteMessage ¶
WriteMessage writes a variable number of messages to w.
Source Files