Initial commit (upload)

Author: Encritary

.gitignore

@@ -0,0 +1,2 @@
+vendor
+.idea

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 GreenWix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,56 @@
+## packetize
+
+A simple library for creating packetized TCP server using Go.
+
+## Installation
+
+```
+go get github.com/GreenWix/packetize
+```
+
+## Packet Format
+
+Packet is a byte array with maximum length of 65,535 bytes.
+Packets are sent in this format:
+
+```<packet length : uint16> <packet data : bytes>```
+
+## Example
+
+```go
+package main
+
+import (
+	"fmt"
+	pkize "github.com/GreenWix/packetize"
+	"net"
+)
+
+func main() {
+	listener, _ := pkize.Listen("tcp4", "localhost:1337") // open listening socket
+	for {
+		conn, err := listener.Accept() // accept TCP connection from client and create a new socket
+		if err != nil {
+			continue
+		}
+		go handleClient(conn) // handle client connection in a separate goroutine
+	}
+}
+
+func handleClient(conn net.Conn) {
+	defer conn.Close() // close socket after done
+
+	buf := make([]byte, 32) // buffer for reading data from client
+	for {
+		conn.Write([]byte("Hello world!")) // write to the client
+
+		readLen, err := conn.Read(buf) // reading from the socket
+		if err != nil {
+			fmt.Println("error occured during client handling: ", err)
+			break
+		}
+
+		fmt.Println(string(buf[:readLen]))
+	}
+}
+```

conn.go

@@ -0,0 +1,116 @@
+package packetize
+
+import (
+	"context"
+	"encoding/binary"
+	"errors"
+	bufpool "github.com/valyala/bytebufferpool"
+	"io"
+	"net"
+	"time"
+)
+
+type Conn struct {
+	conn         net.Conn
+	readDeadline <-chan time.Time
+	packetChan   chan []byte
+
+	closeCtx context.Context
+	close    context.CancelFunc
+}
+
+func (conn *Conn) Read(b []byte) (n int, err error) {
+	select {
+	case packet := <-conn.packetChan:
+		if len(b) < len(packet) {
+			err = errors.New("message sent on a socket was larger than the buffer used to receive the message into")
+		}
+		return copy(b, packet), err
+	case <-conn.closeCtx.Done():
+		return 0, errors.New("error reading from conn: connection closed")
+	case <-conn.readDeadline:
+		return 0, errors.New("error reading from conn: read timeout")
+	}
+}
+
+func (conn *Conn) Write(b []byte) (n int, err error) {
+	if conn.closeCtx.Err() != nil {
+		return 0, errors.New("error writing to conn: connection closed")
+	}
+
+	pk := bufpool.Get()
+	defer bufpool.Put(pk)
+
+	err = binary.Write(pk, binary.BigEndian, uint16(len(b)))
+	if err != nil {
+		return
+	}
+	_, err = pk.Write(b)
+	if err != nil {
+		return
+	}
+
+	_, err = conn.conn.Write(pk.B)
+	return
+}
+
+func (conn *Conn) Close() error {
+	if conn.closeCtx.Err() != nil {
+		return errors.New("conn is already closed")
+	}
+
+	conn.close()
+	return conn.conn.Close()
+}
+
+func (conn *Conn) LocalAddr() net.Addr {
+	return conn.conn.LocalAddr()
+}
+
+func (conn *Conn) RemoteAddr() net.Addr {
+	return conn.conn.RemoteAddr()
+}
+
+func (conn *Conn) SetDeadline(t time.Time) error {
+	return conn.SetReadDeadline(t)
+}
+
+func (conn *Conn) SetReadDeadline(t time.Time) error {
+	if t.IsZero() {
+		conn.readDeadline = make(chan time.Time)
+		return nil
+	}
+	if t.Before(time.Now()) {
+		return errors.New("read deadline cannot be before now")
+	}
+	conn.readDeadline = time.After(t.Sub(time.Now()))
+	return nil
+}
+
+func (conn *Conn) SetWriteDeadline(time.Time) error {
+	return nil
+}
+
+func (conn *Conn) process() {
+	lenBuf := make([]byte, 2)
+
+	for conn.closeCtx.Err() == nil {
+		length, err := io.ReadFull(conn.conn, lenBuf)
+		if err != nil || length != 2 {
+			_ = conn.Close()
+			break
+		}
+
+		pkLen := int(binary.BigEndian.Uint16(lenBuf))
+
+		pk := make([]byte, pkLen)
+
+		length, err = io.ReadFull(conn.conn, pk)
+		if err != nil || length != pkLen {
+			_ = conn.Close()
+			break
+		}
+
+		conn.packetChan <- pk
+	}
+}

go.mod

@@ -0,0 +1,5 @@
+module github.com/GreenWix/packetize
+
+go 1.14
+
+require github.com/valyala/bytebufferpool v1.0.0

go.sum

@@ -0,0 +1,2 @@
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=

listener.go

@@ -0,0 +1,73 @@
+package packetize
+
+import (
+	"context"
+	"errors"
+	"net"
+	"time"
+)
+
+type Listener struct {
+	listener net.Listener
+	connChan chan *Conn
+
+	closeCtx context.Context
+	close    context.CancelFunc
+}
+
+func Listen(network string, addr string) (*Listener, error) {
+	listener, err := net.Listen(network, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	closeCtx, closeFunc := context.WithCancel(context.Background())
+	lst := &Listener{
+		listener: listener,
+		connChan: make(chan *Conn),
+		closeCtx: closeCtx,
+		close:    closeFunc,
+	}
+
+	go func() {
+		for lst.closeCtx.Err() == nil {
+			conn, err := lst.listener.Accept()
+			if err != nil {
+				continue
+			}
+
+			cloneCtx, closeFunc := context.WithCancel(context.Background())
+			pkConn := &Conn{
+				conn:         conn,
+				readDeadline: make(chan time.Time),
+				packetChan:   make(chan []byte, 32),
+
+				closeCtx: cloneCtx,
+				close:    closeFunc,
+			}
+
+			go pkConn.process()
+
+			lst.connChan <- pkConn
+		}
+	}()
+	return lst, nil
+}
+
+func (lst *Listener) Accept() (net.Conn, error) {
+	select {
+	case conn := <-lst.connChan:
+		return conn, nil
+	case <-lst.closeCtx.Done():
+		return nil, errors.New("accept: listener closed")
+	}
+}
+
+func (lst *Listener) Close() error {
+	lst.close()
+	return lst.listener.Close()
+}
+
+func (lst *Listener) Addr() net.Addr {
+	return lst.listener.Addr()
+}