init

.gitignore

+dist/
+.idea
+echo-cli
\ No newline at end of file

.goreleaser.yml

+project_name: echocli
+before:
+  hooks:
+    # You may remove this if you don't use go modules.
+    - go mod tidy
+    # you may remove this if you don't need go generate
+    - go generate ./...
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+      - darwin
+      - netbsd
+      - openbsd
+
+    goarch:
+      - amd64
+      - arm
+      - arm64
+    goarm:
+      - 6
+      - 7
+
+    binary: majora-cli
+
+    asmflags:
+      - all=-trimpath={{.Env.GOPATH}}
+    gcflags:
+      - all=-trimpath={{.Env.GOPATH}}
+    ldflags:
+      - -s -w -X app.Version={{.Version}}
+#    tags:
+#      - osusergo
+#      - netgo
+#      - static_build
+
+archives:
+  - replacements:
+      darwin: Darwin
+      linux: Linux
+      windows: Windows
+      amd64: x86_64
+checksum:
+  name_template: 'checksums.txt'
+snapshot:
+  name_template: "{{ incpatch .Version }}-next"
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'

Makefile

+
+build:
+	flags="-w -s -X majora.BuildDate=`date -u '+%Y-%m-%d_%I:%M:%S%p'` -X majora.Version=`git describe --long --dirty --abbrev=14`"
+	go build -ldflags "$flags" -o majora-cli
+
+release:
+	goreleaser build --rm-dist  --snapshot --single-target
+
+releaseall:
+	goreleaser build --rm-dist  --snapshot
+
+
+clean:
+	rm -fr dist
+	rm -fr echo-cli
\ No newline at end of file

README.md

+# 本地编译 
+
+```
+make build
+```
+

client.go

+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+const (
+	DefNatServerHost = "majora.virjar.com"
+	DefPort          = 5879
+	BufSize          = 1000
+)
+
+func NewOptions() *Options {
+	return &Options{
+		natHostPort: fmt.Sprintf("%s:%d", DefNatServerHost, DefPort),
+		clientID:    uuid.New().String(),
+		bufSize:     BufSize,
+	}
+}
+
+type Client struct {
+	options *Options
+
+	natTunnel atomic.Value
+	codec     ICodec
+	connStore sync.Map
+}
+
+func NewClient(opts ...Option) *Client {
+	options := NewOptions()
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	return &Client{options: options, codec: NewDefCodec()}
+}
+
+func NewDefClient() *Client {
+	options := NewOptions()
+	return &Client{options: options, codec: NewDefCodec()}
+}
+
+func (client *Client) StartUp() {
+	if client.options == nil {
+		client.options = NewOptions()
+		logger.Warn().Msgf("use default nat host %s port %d", DefNatServerHost, DefPort)
+	}
+	client.connect()
+	client.register()
+	client.handleNatEvent()
+}
+
+func (client *Client) register() {
+	packet := TypeRegister.CreatePacket()
+	packet.Extra = client.options.clientID
+	encode, _ := client.codec.Encode(packet)
+	if err := client.WriteAndFlush(encode); err != nil {
+		logger.Error().Msgf("register to nat server with error %s", err.Error())
+	} else {
+		logger.Info().Msg("register to nat server success")
+	}
+}
+
+func (client *Client) handleNatEvent() {
+	go func() {
+		for {
+			reader := bufio.NewReader(client.natTunnel.Load().(net.Conn))
+			majoraPacket, err := client.codec.Decode(reader)
+			if errors.Is(err, io.EOF) {
+				logger.Error().Msgf("*********disconnect******")
+				client.reConnect()
+				continue
+			}
+
+			if majoraPacket == nil || err != nil {
+				logger.Error().Msgf("decode error %+v", err)
+				continue
+			}
+
+			logger.Debug().Msgf("receive packet type %s", majoraPacket.Ttype.ToString())
+			switch majoraPacket.Ttype {
+			case TypeHeartbeat:
+				client.handleHeartbeatMessage()
+			case TypeConnect:
+				go client.handleConnect(majoraPacket)
+			case TypeTransfer:
+				go client.handleTransfer(majoraPacket)
+			case TypeDisconnect:
+				go client.handleDisconnectMessage(majoraPacket)
+			case TypeControl:
+				go client.handleControlMessage(majoraPacket)
+			case TypeDestroy:
+				go client.handleDestroyMessage()
+			}
+		}
+	}()
+}
+
+func (client *Client) reConnect() {
+	// 已经check 过
+	hostPort := client.options.natHostPort
+
+	var (
+		conn net.Conn
+		err  error
+	)
+	for {
+		conn, err = net.DialTimeout(TCP, hostPort, connTimeout)
+		if err != nil || conn == nil {
+			// 不断重试
+			logger.Info().Msgf("reconnect to nathost with error %+v ...", err)
+			time.Sleep(reConnInterval)
+		} else {
+			break
+		}
+	}
+
+	logger.Info().Msgf("reconnect to nathost %s success ...", hostPort)
+	client.natTunnel.Store(conn)
+	client.register()
+}
+
+func (client *Client) connect() {
+	hostPort := client.options.natHostPort
+
+	if len(hostPort) == 0 {
+		panic("invalid nat host/port info")
+	}
+
+	conn, err := net.DialTimeout(TCP, hostPort, connTimeout)
+	if err != nil || conn == nil {
+		panic(fmt.Sprintf("connect to nathost %s with err %s", hostPort, err.Error()))
+	}
+
+	logger.Info().Msgf("connect to nathost %s success ...", hostPort)
+	client.natTunnel.Store(conn)
+}

codec.go

+package main
+
+import (
+	"bufio"
+)
+
+type (
+	ICodec interface {
+		Encode(packet *MajoraPacket) ([]byte, error)
+		Decode(reader *bufio.Reader) (*MajoraPacket, error)
+	}
+
+	DefCodec struct {
+		Encoder Encoder
+		Decoder Decoder
+	}
+)
+
+func NewDefCodec() *DefCodec {
+	return &DefCodec{
+		Encoder: &MajoraPacketEncoder{},
+		Decoder: &MajoraPacketDecoder{},
+	}
+}
+
+func (d *DefCodec) Encode(packet *MajoraPacket) ([]byte, error) {
+	return d.Encoder.Encode(packet)
+}
+
+func (d *DefCodec) Decode(reader *bufio.Reader) (*MajoraPacket, error) {
+	return d.Decoder.Decode(reader)
+}

common.go

+package main
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"time"
+)
+
+const (
+	MagicSize        = 8
+	HeaderSize       = 12
+	BodySize         = 4
+	TypeSize         = 1
+	ExtraSize        = 1
+	SerialNumberSize = 8
+	HeaderSizeSize   = 1
+	KeyLenSize       = 1
+	ValueLenSize     = 1
+	MaxFrameLength   = 8 * 1024
+
+	MAGIC = int64(0x6D616A6F72613031)
+)
+
+const (
+	TCP = "tcp"
+)
+
+const (
+	connTimeout    = time.Second * 10
+	reConnInterval = time.Second * 5
+)
+
+var (
+	NilPacketError    = errors.New("packet is nil")
+	InvalidSizeError  = errors.New("invalid size")
+	InvalidMagicError = errors.New("invalid magic")
+)
+
+func ConvertInt32ToBytes(input int32) []byte {
+	buf := make([]byte, 4)
+	binary.BigEndian.PutUint32(buf, uint32(input))
+	return buf
+}
+
+func ConvertInt64ToBytes(input int64) []byte {
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, uint64(input))
+	return buf
+}
+
+func ReadInt32(conn io.Reader) (int32, error) {
+	buf := make([]byte, 4)
+	readSize, err := conn.Read(buf)
+
+	if readSize != 4 || err != nil {
+		return 0, err
+	}
+	return int32(binary.BigEndian.Uint32(buf)), nil
+}
+
+func ReadInt64(conn io.Reader) (int64, error) {
+	buf := make([]byte, 8)
+	readSize, err := conn.Read(buf)
+
+	if readSize != 8 || err != nil {
+		return 0, err
+	}
+	return int64(binary.BigEndian.Uint64(buf)), nil
+}
+
+func ReadByte(conn io.Reader) (byte, error) {
+	buf := make([]byte, 1)
+	readSize, err := conn.Read(buf)
+
+	if readSize != 1 || err != nil {
+		return 0, err
+	}
+	oneByte := uint8(0)
+	err = binary.Read(bytes.NewBuffer(buf), binary.BigEndian, &oneByte)
+	return oneByte, err
+}
+
+func ReadN(size int, conn io.Reader) ([]byte, error) {
+	buf := make([]byte, size)
+	readSize, err := conn.Read(buf)
+
+	if readSize != size || err != nil {
+		return nil, err
+	}
+	return buf, nil
+}
+
+func ReadMagic(buf []byte) bool {
+	return int64(binary.BigEndian.Uint64(buf)) == MAGIC
+}

decoder.go

+package main
+
+import (
+	"bufio"
+)
+
+type Decoder interface {
+	Decode(reader *bufio.Reader) (*MajoraPacket, error)
+}
+
+type MajoraPacketDecoder struct {
+	consumeHeader bool
+}
+
+func (mpd *MajoraPacketDecoder) Decode(reader *bufio.Reader) (pack *MajoraPacket, err error) {
+	magicbs := make([]byte, MagicSize)
+	_, err = reader.Read(magicbs)
+	if err != nil {
+		return nil, err
+	}
+
+	if !ReadMagic(magicbs) {
+		return nil, InvalidMagicError
+	}
+
+	frameLen, err := ReadInt32(reader)
+	if err != nil {
+		return nil, InvalidSizeError
+	}
+
+	// type
+	msgType, err := ReadByte(reader)
+	if err != nil {
+		logger.Error().Msgf("read type error  %+v", err)
+		return nil, InvalidSizeError
+	}
+	pack = &MajoraPacket{}
+	pack.Ttype = MajoraPacketType(msgType)
+
+	// num
+	pack.SerialNumber, err = ReadInt64(reader)
+	if err != nil {
+		logger.Error().Msgf("read type error  %+v", err)
+		return nil, InvalidSizeError
+	}
+
+	// extra size
+	extraSize, err := ReadByte(reader)
+	if err != nil {
+		logger.Error().Msgf("read type error  %+v", err)
+		return nil, InvalidSizeError
+	}
+
+	extra, err := ReadN(int(extraSize), reader)
+	if err != nil {
+		logger.Error().Msgf("read type error  %+v", err)
+		return nil, InvalidSizeError
+	}
+	pack.Extra = string(extra)
+
+	// dataFrame
+	dataSize := int(frameLen) - TypeSize - SerialNumberSize - ExtraSize - int(extraSize)
+	if dataSize < 0 {
+		logger.Error().Msgf("read type error  %+v", err)
+		return nil, InvalidSizeError
+	}
+
+	if dataSize > 0 {
+		data, err := ReadN(dataSize, reader)
+		if err != nil {
+			logger.Error().Msgf("read type error  %+v", err)
+		}
+		pack.Data = data
+	}
+	return pack, nil
+}

encoder.go

+package main
+
+import (
+	"bytes"
+)
+
+type Encoder interface {
+	Encode(*MajoraPacket) ([]byte, error)
+}
+
+type MajoraPacketEncoder struct {
+}
+
+func (s *MajoraPacketEncoder) Encode(packet *MajoraPacket) ([]byte, error) {
+	if packet == nil {
+		return nil, NilPacketError
+	}
+	bodyLength := TypeSize + SerialNumberSize + ExtraSize
+
+	bodyLength += len(packet.Data)
+
+	bodyLength += len([]byte(packet.Extra))
+
+	var (
+		innerBuf = make([]byte, 0, bodyLength+8+4)
+		// todo 池化提高性能
+		buffer = bytes.NewBuffer(innerBuf)
+		err    error
+	)
+
+	// magic 8byte
+	buffer.Write(ConvertInt64ToBytes(MAGIC))
+	// body length 4byte
+	buffer.Write(ConvertInt32ToBytes(int32(bodyLength)))
+	// type 1byte
+	buffer.WriteByte(byte(packet.Ttype))
+	// serial num 4byte
+	buffer.Write(ConvertInt64ToBytes(packet.SerialNumber))
+
+	// extra
+	if len(packet.Extra) > 0 {
+		extraBs := []byte(packet.Extra)
+		buffer.WriteByte(byte(len(extraBs)))
+		buffer.Write(extraBs)
+	} else {
+		buffer.WriteByte(0x00)
+	}
+
+	if len(packet.Data) > 0 {
+		buffer.Write(packet.Data)
+	}
+	return buffer.Bytes(), err
+}

event.go

+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+)
+
+func (client *Client) handleHeartbeatMessage() {
+	go func() {
+		logger.Debug().Msg("receive heartbeat message from nat server")
+		packet := TypeHeartbeat.CreatePacket()
+		encode, _ := client.codec.Encode(packet)
+		if err := client.WriteAndFlush(encode); err != nil {
+			logger.Error().Msgf("flush heart beat message error %s", err.Error())
+		}
+	}()
+}
+
+func (client *Client) handleConnect(packet *MajoraPacket) {
+	if len(packet.Extra) == 0 {
+		client.disconnect(packet, "empty extra")
+		client.connStore.Delete(packet.SerialNumber)
+		return
+	}
+
+	hostPort := strings.Split(packet.Extra, ":")
+
+	if len(hostPort) != 2 {
+		client.disconnect(packet, "invalid extra "+packet.Extra)
+		return
+	}
+	logger.Info().Msgf("handleConnect to %s", hostPort)
+
+	var (
+		conn net.Conn
+		err  error
+	)
+
+	addr := fmt.Sprintf("%s:%s", hostPort[0], hostPort[1])
+	conn, err = net.DialTimeout(TCP, addr, connTimeout)
+	if err != nil {
+		client.disconnect(packet, "connect to target host error "+err.Error())
+		return
+	}
+
+	client.connStore.Store(packet.SerialNumber, conn)
+	majoraPacket := TypeConnectReady.CreatePacket()
+	majoraPacket.SerialNumber = packet.SerialNumber
+	majoraPacket.Extra = client.options.clientID
+
+	encode, _ := client.codec.Encode(majoraPacket)
+	if err := client.WriteAndFlush(encode); err != nil {
+		logger.Error().Msgf("handleConnect message error %s", err.Error())
+		_ = conn.Close()
+		return
+	}
+
+	client.handleConnection(conn, packet)
+}
+
+func (client *Client) WriteAndFlush(packet []byte) error {
+	writer := bufio.NewWriter(client.natTunnel.Load().(net.Conn))
+	if _, err := writer.Write(packet); err != nil {
+		logger.Warn().Msgf("write to nat server error err:%+v", err)
+		return err
+	}
+	return writer.Flush()
+}
+
+func (client *Client) handleTransfer(packet *MajoraPacket) {
+	load, ok := client.connStore.Load(packet.SerialNumber)
+
+	if !ok || load == nil {
+		logger.Warn().Msgf("can not find connection for %d", packet.SerialNumber)
+		return
+	}
+
+	conn := load.(net.Conn)
+
+	if !ok || load == nil {
+		logger.Warn().Msgf("can not find connection for %d", packet.SerialNumber)
+		return
+	}
+	if cnt, err := conn.Write(packet.Data); err != nil {
+		logger.Warn().Msgf("write with error cnt=%d|err=%+v", cnt, err)
+	}
+}
+
+func (client *Client) handleConnection(conn net.Conn, packet *MajoraPacket) {
+	logger.Debug().Msg("handleConnection start...")
+	reader := bufio.NewReader(conn)
+	for {
+		if _, err := reader.Peek(1); err != nil {
+			if !errors.Is(err, net.ErrClosed) {
+				logger.Error().Msgf("handleConnection peek with error:%+v", err)
+			}
+			client.connStore.Delete(packet.SerialNumber)
+			break
+		}
+		bufsize := reader.Buffered()
+		buf := make([]byte, bufsize)
+		_, err := reader.Read(buf)
+		if err != nil {
+			logger.Error().Msgf("handleConnection read with error:%+v", err)
+			break
+		}
+
+		pack := TypeTransfer.CreatePacket()
+		pack.Data = buf
+		pack.SerialNumber = packet.SerialNumber
+		encode, _ := client.codec.Encode(pack)
+		if err = client.WriteAndFlush(encode); err != nil {
+			logger.Error().Msgf("write to nat server error %+v", err)
+		}
+	}
+}
+
+func (client *Client) handleDisconnectMessage(packet *MajoraPacket) {
+	go func() {
+		// delete from local cache
+		load, ok := client.connStore.Load(packet.SerialNumber)
+		if ok {
+			client.connStore.Delete(packet.SerialNumber)
+			conn := load.(net.Conn)
+			// 直接关闭是否就可以  主动断开 是否有剩余数据已经意义不大了
+			_ = conn.Close()
+		}
+	}()
+}
+
+func (client *Client) handleControlMessage(packet *MajoraPacket) {
+	logger.Debug().Msgf("handleControlMessage %s", string(packet.Data))
+}
+
+func (client *Client) handleDestroyMessage() {
+
+}
+
+func (client *Client) disconnect(packet *MajoraPacket, msg string) {
+	logger.Info().Msgf("disconnect to server %s", msg)
+	disconnectCmd := TypeDisconnect.CreatePacket()
+	disconnectCmd.SerialNumber = packet.SerialNumber
+	disconnectCmd.Data = []byte(msg)
+	encode, _ := client.codec.Encode(disconnectCmd)
+	_ = client.WriteAndFlush(encode)
+}

go.mod

+module ints.com/goecho
+
+go 1.17
+
+require (
+	github.com/google/uuid v1.3.0
+	github.com/rs/zerolog v1.24.0
+)

go.sum

+github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/rs/xid v1.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.24.0 h1:76ivFxmVSRs1u2wUwJVg5VZDYQgeH1JpoS6ndgr9Wy8=
+github.com/rs/zerolog v1.24.0/go.mod h1:7KHcEGe0QZPOm2IE4Kpb5rTh6n1h2hIgS5OOnu1rUaI=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

log.go

+package main
+
+import (
+	"os"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+var (
+	logger zerolog.Logger
+)
+
+func InitLogger(level int) {
+	zerolog.SetGlobalLevel(zerolog.Level(level))
+	output := zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: time.RFC3339, NoColor: true}
+	logger = zerolog.New(output).With().Caller().Timestamp().Logger()
+}

majora.go

+package main
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	_ "net/http/pprof" //nolint:gosec
+)
+
+var (
+	Version   string
+	BuildDate string
+)
+
+var (
+	logLevel  int
+	pprof     bool
+	debugAddr string
+	natServer string
+)
+
+func init() {
+	flag.IntVar(&logLevel, "log", 1, "log logLevel")
+	flag.BoolVar(&pprof, "pprof", false, "pprof")
+	flag.StringVar(&debugAddr, "debugPort", "127.0.0.1:6060", "debugPort")
+	flag.StringVar(&natServer, "natServer", fmt.Sprintf("%s:%d", DefNatServerHost, DefPort), "natServer")
+
+	flag.Parse()
+}
+
+func initPprof() {
+	if !pprof {
+		return
+	}
+	go func() {
+		logger.Fatal().Err(http.ListenAndServe(debugAddr, nil))
+	}()
+}
+
+func main() {
+	InitLogger(logLevel)
+	initPprof()
+	logger.Info().Msgf("build in %s, version %s", BuildDate, Version)
+	NewClient(WithNatServerAddr(natServer)).StartUp()
+
+	select {}
+}

option.go

+package main
+
+type (
+	Options struct {
+		natHostPort string
+		clientID      string
+		bufSize       int
+	}
+
+	Option func(*Options)
+)
+
+func WithNatServerAddr(natHostPort string) Option {
+	return func(options *Options) {
+		options.natHostPort = natHostPort
+	}
+}
+
+func WithClientID(clientID string) Option {
+	return func(options *Options) {
+		options.clientID = clientID
+	}
+}

packet.go

+package main
+
+type MajoraPacket struct {
+	Ttype        MajoraPacketType // 消息类型
+	SerialNumber int64            // 流水号
+	Data         []byte           // 核心数据
+	Extra        string
+}
+
+type (
+	MajoraPacketType byte
+)
+
+const (
+	TypeRegister     MajoraPacketType = 0x01
+	TypeHeartbeat    MajoraPacketType = 0x02
+	TypeConnect      MajoraPacketType = 0x03
+	TypeDisconnect   MajoraPacketType = 0x04
+	TypeTransfer     MajoraPacketType = 0x05
+	TypeControl      MajoraPacketType = 0x06
+	TypeConnectReady MajoraPacketType = 0x07
+	TypeDestroy      MajoraPacketType = 0x08
+)
+
+func (mpt MajoraPacketType) CreatePacket() *MajoraPacket {
+	return &MajoraPacket{Ttype: mpt}
+}
+
+func (mpt MajoraPacketType) ToString() string {
+	switch mpt {
+	case TypeHeartbeat:
+		return "Heartbeat"
+	case TypeRegister:
+		return "TypeRegister"
+	case TypeConnect:
+		return "TypeConnect"
+	case TypeDisconnect:
+		return "TypeDisconnect"
+	case TypeTransfer:
+		return "TypeTransfer"
+	case TypeControl:
+		return "TypeControl"
+	case TypeConnectReady:
+		return "TypeConnectReady"
+	case TypeDestroy:
+		return "TypeDestroy"
+	}
+	return "Unknown"
+}