add mux slide window

lib/common/netpackager.go

@@ -150,8 +150,9 @@ func (Self *ConnPackager) UnPack(reader io.Reader) (err error) {
 }
 
 type MuxPackager struct {
-	Flag uint8
-	Id   int32
+	Flag   uint8
+	Id     int32
+	Window uint16
 	BasePackager
 }
 
@@ -161,6 +162,15 @@ func (Self *MuxPackager) NewPac(flag uint8, id int32, content ...interface{}) (e
 	if flag == MUX_NEW_MSG {
 		err = Self.BasePackager.NewPac(content...)
 	}
+	if flag == MUX_MSG_SEND_OK {
+		// MUX_MSG_SEND_OK only allows one data
+		switch content[0].(type) {
+		case int:
+			Self.Window = uint16(content[0].(int))
+		case uint16:
+			Self.Window = content[0].(uint16)
+		}
+	}
 	return
 }
 
@@ -176,6 +186,9 @@ func (Self *MuxPackager) Pack(writer io.Writer) (err error) {
 	if Self.Flag == MUX_NEW_MSG {
 		err = Self.BasePackager.Pack(writer)
 	}
+	if Self.Flag == MUX_MSG_SEND_OK {
+		err = binary.Write(writer, binary.LittleEndian, Self.Window)
+	}
 	return
 }
 
@@ -192,5 +205,8 @@ func (Self *MuxPackager) UnPack(reader io.Reader) (err error) {
 	if Self.Flag == MUX_NEW_MSG {
 		err = Self.BasePackager.UnPack(reader)
 	}
+	if Self.Flag == MUX_MSG_SEND_OK {
+		err = binary.Read(reader, binary.LittleEndian, &Self.Window)
+	}
 	return
 }

lib/common/pool.go

@@ -9,6 +9,7 @@ const PoolSize = 64 * 1024
 const PoolSizeSmall = 100
 const PoolSizeUdp = 1472
 const PoolSizeCopy = 32 << 10
+const PoolSizeWindow = 1<<16 - 1
 
 var BufPool = sync.Pool{
 	New: func() interface{} {
@@ -59,11 +60,11 @@ func PutBufPoolMax(buf []byte) {
 	}
 }
 
-type CopyBufferPool struct {
+type copyBufferPool struct {
 	pool sync.Pool
 }
 
-func (Self *CopyBufferPool) New() {
+func (Self *copyBufferPool) New() {
 	Self.pool = sync.Pool{
 		New: func() interface{} {
 			return make([]byte, PoolSizeCopy, PoolSizeCopy)
@@ -71,24 +72,49 @@ func (Self *CopyBufferPool) New() {
 	}
 }
 
-func (Self *CopyBufferPool) Get() []byte {
+func (Self *copyBufferPool) Get() []byte {
 	buf := Self.pool.Get().([]byte)
 	return buf[:PoolSizeCopy] // just like make a new slice, but data may not be 0
 }
 
-func (Self *CopyBufferPool) Put(x []byte) {
+func (Self *copyBufferPool) Put(x []byte) {
 	if len(x) == PoolSizeCopy {
 		Self.pool.Put(x)
 	} else {
-		x = nil // buf is not full, maybe truncated by gc in pool, not allowed
+		x = nil // buf is not full, not allowed, New method returns a full buf
 	}
 }
 
-type BufferPool struct {
+type windowBufferPool struct {
 	pool sync.Pool
 }
 
-func (Self *BufferPool) New() {
+func (Self *windowBufferPool) New() {
+	Self.pool = sync.Pool{
+		New: func() interface{} {
+			return make([]byte, 0, PoolSizeWindow)
+		},
+	}
+}
+
+func (Self *windowBufferPool) Get() (buf []byte) {
+	buf = Self.pool.Get().([]byte)
+	return buf[:0]
+}
+
+func (Self *windowBufferPool) Put(x []byte) {
+	if cap(x) == PoolSizeWindow {
+		Self.pool.Put(x[:PoolSizeWindow]) // make buf to full
+	} else {
+		x = nil
+	}
+}
+
+type bufferPool struct {
+	pool sync.Pool
+}
+
+func (Self *bufferPool) New() {
 	Self.pool = sync.Pool{
 		New: func() interface{} {
 			return new(bytes.Buffer)
@@ -96,20 +122,20 @@ func (Self *BufferPool) New() {
 	}
 }
 
-func (Self *BufferPool) Get() *bytes.Buffer {
+func (Self *bufferPool) Get() *bytes.Buffer {
 	return Self.pool.Get().(*bytes.Buffer)
 }
 
-func (Self *BufferPool) Put(x *bytes.Buffer) {
+func (Self *bufferPool) Put(x *bytes.Buffer) {
 	x.Reset()
 	Self.pool.Put(x)
 }
 
-type MuxPackagerPool struct {
+type muxPackagerPool struct {
 	pool sync.Pool
 }
 
-func (Self *MuxPackagerPool) New() {
+func (Self *muxPackagerPool) New() {
 	Self.pool = sync.Pool{
 		New: func() interface{} {
 			pack := MuxPackager{}
@@ -118,27 +144,29 @@ func (Self *MuxPackagerPool) New() {
 	}
 }
 
-func (Self *MuxPackagerPool) Get() *MuxPackager {
+func (Self *muxPackagerPool) Get() *MuxPackager {
 	pack := Self.pool.Get().(*MuxPackager)
 	buf := CopyBuff.Get()
 	pack.Content = buf
 	return pack
 }
 
-func (Self *MuxPackagerPool) Put(pack *MuxPackager) {
+func (Self *muxPackagerPool) Put(pack *MuxPackager) {
 	CopyBuff.Put(pack.Content)
 	Self.pool.Put(pack)
 }
 
 var once = sync.Once{}
-var BuffPool = BufferPool{}
-var CopyBuff = CopyBufferPool{}
-var MuxPack = MuxPackagerPool{}
+var BuffPool = bufferPool{}
+var CopyBuff = copyBufferPool{}
+var MuxPack = muxPackagerPool{}
+var WindowBuff = windowBufferPool{}
 
 func newPool() {
 	BuffPool.New()
 	CopyBuff.New()
 	MuxPack.New()
+	WindowBuff.New()
 }
 
 func init() {

lib/common/util.go

@@ -4,9 +4,7 @@ import (
 	"bytes"
 	"encoding/base64"
 	"encoding/binary"
-	"errors"
 	"github.com/cnlh/nps/lib/crypt"
-	"github.com/cnlh/nps/vender/github.com/astaxie/beego/logs"
 	"html/template"
 	"io"
 	"io/ioutil"
@@ -264,96 +262,31 @@ func GetPortByAddr(addr string) int {
 	return p
 }
 
-type ConnCopy struct {
-	dst    net.Conn
-	src    net.Conn
-	buf    []byte
-	connId int32
-}
-
-func (Self *ConnCopy) New(dst net.Conn, src net.Conn, connId int32) {
-	Self.dst = dst
-	Self.src = src
-	Self.buf = CopyBuff.Get()
-	Self.connId = connId
-}
-
-func (Self *ConnCopy) copyBufferOnce() (written int64, err error) {
-	nr, er := Self.src.Read(Self.buf)
-	if nr > 0 {
-		//logs.Warn("write", Self.connId, nr, string(buf[0:10]))
-		nw, ew := Self.dst.Write(Self.buf[0:nr])
-		if nw > 0 {
-			written = int64(nw)
-		}
-		if ew != nil {
-			//logs.Warn("write err ew id nw", ew, Self.connId, nw)
-			err = ew
-			return
-		}
-		if nr != nw {
-			err = io.ErrShortWrite
-			return
-		}
-		if nw == 0 {
-			err = errors.New("io: write on closed pipe")
-			//logs.Warn("write buffer", err)
-			return
-		}
-	}
-	if nr == 0 && er == nil {
-		err = errors.New("io: read on closed pipe")
-		//logs.Warn("read buffer", err)
-		return
-	}
-	if er != nil {
-		err = er
-		return
-	}
-	return
-}
-
-func (Self *ConnCopy) copyBuffer() (written int64, err error) {
-	var write int64
-	write, err = Self.copyBufferOnce() // first copy, if written is zero and err is io.EOF
-	// means conn already closed, so need to close all the conn
-	written += write
-	if err == io.EOF && written == 0 {
-		err = errors.New("io: read on closed pipe")
-		return
-	} else if err == io.EOF && written > 0 {
-		err = nil
-		return
-	}
+func CopyBuffer(dst io.Writer, src io.Reader) (written int64, err error) {
+	buf := CopyBuff.Get()
+	defer CopyBuff.Put(buf)
 	for {
-		write, err = Self.copyBufferOnce()
-		written += write
-		if err != nil {
-			if err == io.EOF {
-				err = nil
+		nr, er := src.Read(buf)
+		if nr > 0 {
+			nw, ew := dst.Write(buf[0:nr])
+			if nw > 0 {
+				written += int64(nw)
 			}
-			return
+			if ew != nil {
+				err = ew
+				break
+			}
+			if nr != nw {
+				err = io.ErrShortWrite
+				break
+			}
+		}
+		if er != nil {
+			err = er
+			break
 		}
 	}
-}
-
-func (Self *ConnCopy) CopyConn() (written int64, err error) {
-	defer CopyBuff.Put(Self.buf)
-	if Self.dst != nil && Self.src != nil {
-		written, err = Self.copyBuffer()
-	} else {
-		return 0, errors.New("copy conn nil src or dst")
-	}
-	if err != nil { // copyBuffer do not return io.EOF ,close all conn
-		logs.Warn("close by copy conn ", Self.connId, err)
-		if Self.dst != nil {
-			Self.dst.Close()
-		}
-		if Self.src != nil {
-			Self.src.Close()
-		}
-	}
-	return
+	return written, err
 }
 
 //send this ip forget to get a local udp port