Programming language: Go
License: MIT License
Tags: Networking    

xtcp alternatives and similar packages

Based on the "Networking" category.
Alternatively, view xtcp alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of xtcp or a related project?

Add another 'Networking' Package



A TCP Server Framework with graceful shutdown,custom protocol.

Build Status Go Report Card GoDoc


Define your protocol format:

Before create server and client, you need define the protocol format first.

// Packet is the unit of data.
type Packet interface {

// Protocol use to pack/unpack Packet.
type Protocol interface {
    // return the size need for pack the Packet.
    PackSize(p Packet) int
    // PackTo pack the Packet to w.
    // The return value n is the number of bytes written;
    // Any error encountered during the write is also returned.
    PackTo(p Packet, w io.Writer) (int, error)
    // Pack pack the Packet to new created buf.
    Pack(p Packet) ([]byte, error)
    // try to unpack the buf to Packet. If return len > 0, then buf[:len] will be discard.
    // The following return conditions must be implement:
    // (nil, 0, nil) : buf size not enough for unpack one Packet.
    // (nil, len, err) : buf size enough but error encountered.
    // (p, len, nil) : unpack succeed.
    Unpack(buf []byte) (Packet, int, error)

Set your logger(optional):

func SetLogger(l Logger)

Note: xtcp will not output any log by default unless you implement your own logger.

Provide event handler:

In xtcp, there are some events to notify the state of net conn, you can handle them according your need:

const (
    // EventAccept mean server accept a new connect.
    EventAccept EventType = iota
    // EventConnected mean client connected to a server.
    // EventRecv mean conn recv a packet.
    // EventClosed mean conn is closed.

To handle the event, just implement the OnEvent interface.

// Handler is the event callback.
// p will be nil when event is EventAccept/EventConnected/EventClosed
type Handler interface {
    OnEvent(et EventType, c *Conn, p Packet)

Create server:

// 1. create protocol and handler.
// ...

// 2. create opts.
opts := xtcp.NewOpts(handler, protocol)

// 3. create server.
server := xtcp.NewServer(opts)

// 4. start.
go server.ListenAndServe("addr")

Create client:

// 1. create protocol and handler.
// ...

// 2. create opts.
opts := xtcp.NewOpts(handler, protocol)

// 3. create client.
client := NewConn(opts)

// 4. start
go client.DialAndServe("addr")

Send and recv packet.

To send data, just call the 'Send' function of Conn. You can safe call it in any goroutines.

func (c *Conn) Send(buf []byte) error

To recv a packet, implement your handler function:

func (h *myhandler) OnEvent(et EventType, c *Conn, p Packet) {
    switch et {
        case EventRecv:


xtcp have three stop modes, stop gracefully mean conn will stop until all cached data sended.

// StopMode define the stop mode of server and conn.
type StopMode uint8

const (
    // StopImmediately mean stop directly, the cached data maybe will not send.
    StopImmediately StopMode = iota
    // StopGracefullyButNotWait stop and flush cached data.
    // StopGracefullyAndWait stop and block until cached data sended.


The example define a protocol format which use protobuf inner. You can see how to define the protocol and how to create server and client.