using glide

vendor/github.com/xtaci/kcp-go/crypt_test.go

@@ -0,0 +1,222 @@
+package kcp
+
+import (
+	"bytes"
+	"crypto/rand"
+	"hash/crc32"
+	"io"
+	"testing"
+)
+
+func TestAES(t *testing.T) {
+	bc, err := NewAESBlockCrypt(pass[:32])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestTEA(t *testing.T) {
+	bc, err := NewTEABlockCrypt(pass[:16])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestXOR(t *testing.T) {
+	bc, err := NewSimpleXORBlockCrypt(pass[:32])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestBlowfish(t *testing.T) {
+	bc, err := NewBlowfishBlockCrypt(pass[:32])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestNone(t *testing.T) {
+	bc, err := NewNoneBlockCrypt(pass[:32])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestCast5(t *testing.T) {
+	bc, err := NewCast5BlockCrypt(pass[:16])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func Test3DES(t *testing.T) {
+	bc, err := NewTripleDESBlockCrypt(pass[:24])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestTwofish(t *testing.T) {
+	bc, err := NewTwofishBlockCrypt(pass[:32])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestXTEA(t *testing.T) {
+	bc, err := NewXTEABlockCrypt(pass[:16])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func TestSalsa20(t *testing.T) {
+	bc, err := NewSalsa20BlockCrypt(pass[:32])
+	if err != nil {
+		t.Fatal(err)
+	}
+	cryptTest(t, bc)
+}
+
+func cryptTest(t *testing.T, bc BlockCrypt) {
+	data := make([]byte, mtuLimit)
+	io.ReadFull(rand.Reader, data)
+	dec := make([]byte, mtuLimit)
+	enc := make([]byte, mtuLimit)
+	bc.Encrypt(enc, data)
+	bc.Decrypt(dec, enc)
+	if !bytes.Equal(data, dec) {
+		t.Fail()
+	}
+}
+
+func BenchmarkAES128(b *testing.B) {
+	bc, err := NewAESBlockCrypt(pass[:16])
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	benchCrypt(b, bc)
+}
+
+func BenchmarkAES192(b *testing.B) {
+	bc, err := NewAESBlockCrypt(pass[:24])
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	benchCrypt(b, bc)
+}
+
+func BenchmarkAES256(b *testing.B) {
+	bc, err := NewAESBlockCrypt(pass[:32])
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	benchCrypt(b, bc)
+}
+
+func BenchmarkTEA(b *testing.B) {
+	bc, err := NewTEABlockCrypt(pass[:16])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkXOR(b *testing.B) {
+	bc, err := NewSimpleXORBlockCrypt(pass[:32])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkBlowfish(b *testing.B) {
+	bc, err := NewBlowfishBlockCrypt(pass[:32])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkNone(b *testing.B) {
+	bc, err := NewNoneBlockCrypt(pass[:32])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkCast5(b *testing.B) {
+	bc, err := NewCast5BlockCrypt(pass[:16])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func Benchmark3DES(b *testing.B) {
+	bc, err := NewTripleDESBlockCrypt(pass[:24])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkTwofish(b *testing.B) {
+	bc, err := NewTwofishBlockCrypt(pass[:32])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkXTEA(b *testing.B) {
+	bc, err := NewXTEABlockCrypt(pass[:16])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func BenchmarkSalsa20(b *testing.B) {
+	bc, err := NewSalsa20BlockCrypt(pass[:32])
+	if err != nil {
+		b.Fatal(err)
+	}
+	benchCrypt(b, bc)
+}
+
+func benchCrypt(b *testing.B, bc BlockCrypt) {
+	b.ReportAllocs()
+	data := make([]byte, mtuLimit)
+	io.ReadFull(rand.Reader, data)
+	dec := make([]byte, mtuLimit)
+	enc := make([]byte, mtuLimit)
+
+	for i := 0; i < b.N; i++ {
+		bc.Encrypt(enc, data)
+		bc.Decrypt(dec, enc)
+	}
+	b.SetBytes(int64(len(enc) * 2))
+}
+
+func BenchmarkCRC32(b *testing.B) {
+	content := make([]byte, 1024)
+	b.SetBytes(int64(len(content)))
+	for i := 0; i < b.N; i++ {
+		crc32.ChecksumIEEE(content)
+	}
+}

vendor/github.com/xtaci/kcp-go/kcp_test.go

@@ -0,0 +1,303 @@
+package kcp
+
+import (
+	"bytes"
+	"container/list"
+	"encoding/binary"
+	"fmt"
+	"math/rand"
+	"sync"
+	"testing"
+	"time"
+)
+
+func iclock() int32 {
+	return int32((time.Now().UnixNano() / 1000000) & 0xffffffff)
+}
+
+type DelayPacket struct {
+	_ptr  []byte
+	_size int
+	_ts   int32
+}
+
+func (p *DelayPacket) Init(size int, src []byte) {
+	p._ptr = make([]byte, size)
+	p._size = size
+	copy(p._ptr, src[:size])
+}
+
+func (p *DelayPacket) ptr() []byte    { return p._ptr }
+func (p *DelayPacket) size() int      { return p._size }
+func (p *DelayPacket) ts() int32      { return p._ts }
+func (p *DelayPacket) setts(ts int32) { p._ts = ts }
+
+type DelayTunnel struct{ *list.List }
+type Random *rand.Rand
+type LatencySimulator struct {
+	current                        int32
+	lostrate, rttmin, rttmax, nmax int
+	p12                            DelayTunnel
+	p21                            DelayTunnel
+	r12                            *rand.Rand
+	r21                            *rand.Rand
+}
+
+// lostrate: 往返一周丢包率的百分比，默认 10%
+// rttmin：rtt最小值，默认 60
+// rttmax：rtt最大值，默认 125
+//func (p *LatencySimulator)Init(int lostrate = 10, int rttmin = 60, int rttmax = 125, int nmax = 1000):
+func (p *LatencySimulator) Init(lostrate, rttmin, rttmax, nmax int) {
+	p.r12 = rand.New(rand.NewSource(9))
+	p.r21 = rand.New(rand.NewSource(99))
+	p.p12 = DelayTunnel{list.New()}
+	p.p21 = DelayTunnel{list.New()}
+	p.current = iclock()
+	p.lostrate = lostrate / 2 // 上面数据是往返丢包率，单程除以2
+	p.rttmin = rttmin / 2
+	p.rttmax = rttmax / 2
+	p.nmax = nmax
+}
+
+// 发送数据
+// peer - 端点0/1，从0发送，从1接收；从1发送从0接收
+func (p *LatencySimulator) send(peer int, data []byte, size int) int {
+	rnd := 0
+	if peer == 0 {
+		rnd = p.r12.Intn(100)
+	} else {
+		rnd = p.r21.Intn(100)
+	}
+	//println("!!!!!!!!!!!!!!!!!!!!", rnd, p.lostrate, peer)
+	if rnd < p.lostrate {
+		return 0
+	}
+	pkt := &DelayPacket{}
+	pkt.Init(size, data)
+	p.current = iclock()
+	delay := p.rttmin
+	if p.rttmax > p.rttmin {
+		delay += rand.Int() % (p.rttmax - p.rttmin)
+	}
+	pkt.setts(p.current + int32(delay))
+	if peer == 0 {
+		p.p12.PushBack(pkt)
+	} else {
+		p.p21.PushBack(pkt)
+	}
+	return 1
+}
+
+// 接收数据
+func (p *LatencySimulator) recv(peer int, data []byte, maxsize int) int32 {
+	var it *list.Element
+	if peer == 0 {
+		it = p.p21.Front()
+		if p.p21.Len() == 0 {
+			return -1
+		}
+	} else {
+		it = p.p12.Front()
+		if p.p12.Len() == 0 {
+			return -1
+		}
+	}
+	pkt := it.Value.(*DelayPacket)
+	p.current = iclock()
+	if p.current < pkt.ts() {
+		return -2
+	}
+	if maxsize < pkt.size() {
+		return -3
+	}
+	if peer == 0 {
+		p.p21.Remove(it)
+	} else {
+		p.p12.Remove(it)
+	}
+	maxsize = pkt.size()
+	copy(data, pkt.ptr()[:maxsize])
+	return int32(maxsize)
+}
+
+//=====================================================================
+//=====================================================================
+
+// 模拟网络
+var vnet *LatencySimulator
+
+// 测试用例
+func test(mode int) {
+	// 创建模拟网络：丢包率10%，Rtt 60ms~125ms
+	vnet = &LatencySimulator{}
+	vnet.Init(10, 60, 125, 1000)
+
+	// 创建两个端点的 kcp对象，第一个参数 conv是会话编号，同一个会话需要相同
+	// 最后一个是 user参数，用来传递标识
+	output1 := func(buf []byte, size int) {
+		if vnet.send(0, buf, size) != 1 {
+		}
+	}
+	output2 := func(buf []byte, size int) {
+		if vnet.send(1, buf, size) != 1 {
+		}
+	}
+	kcp1 := NewKCP(0x11223344, output1)
+	kcp2 := NewKCP(0x11223344, output2)
+
+	current := uint32(iclock())
+	slap := current + 20
+	index := 0
+	next := 0
+	var sumrtt uint32
+	count := 0
+	maxrtt := 0
+
+	// 配置窗口大小：平均延迟200ms，每20ms发送一个包，
+	// 而考虑到丢包重发，设置最大收发窗口为128
+	kcp1.WndSize(128, 128)
+	kcp2.WndSize(128, 128)
+
+	// 判断测试用例的模式
+	if mode == 0 {
+		// 默认模式
+		kcp1.NoDelay(0, 10, 0, 0)
+		kcp2.NoDelay(0, 10, 0, 0)
+	} else if mode == 1 {
+		// 普通模式，关闭流控等
+		kcp1.NoDelay(0, 10, 0, 1)
+		kcp2.NoDelay(0, 10, 0, 1)
+	} else {
+		// 启动快速模式
+		// 第二个参数 nodelay-启用以后若干常规加速将启动
+		// 第三个参数 interval为内部处理时钟，默认设置为 10ms
+		// 第四个参数 resend为快速重传指标，设置为2
+		// 第五个参数 为是否禁用常规流控，这里禁止
+		kcp1.NoDelay(1, 10, 2, 1)
+		kcp2.NoDelay(1, 10, 2, 1)
+	}
+
+	buffer := make([]byte, 2000)
+	var hr int32
+
+	ts1 := iclock()
+
+	for {
+		time.Sleep(1 * time.Millisecond)
+		current = uint32(iclock())
+		kcp1.Update()
+		kcp2.Update()
+
+		// 每隔 20ms，kcp1发送数据
+		for ; current >= slap; slap += 20 {
+			buf := new(bytes.Buffer)
+			binary.Write(buf, binary.LittleEndian, uint32(index))
+			index++
+			binary.Write(buf, binary.LittleEndian, uint32(current))
+			// 发送上层协议包
+			kcp1.Send(buf.Bytes())
+			//println("now", iclock())
+		}
+
+		// 处理虚拟网络：检测是否有udp包从p1->p2
+		for {
+			hr = vnet.recv(1, buffer, 2000)
+			if hr < 0 {
+				break
+			}
+			// 如果 p2收到udp，则作为下层协议输入到kcp2
+			kcp2.Input(buffer[:hr], true, false)
+		}
+
+		// 处理虚拟网络：检测是否有udp包从p2->p1
+		for {
+			hr = vnet.recv(0, buffer, 2000)
+			if hr < 0 {
+				break
+			}
+			// 如果 p1收到udp，则作为下层协议输入到kcp1
+			kcp1.Input(buffer[:hr], true, false)
+			//println("@@@@", hr, r)
+		}
+
+		// kcp2接收到任何包都返回回去
+		for {
+			hr = int32(kcp2.Recv(buffer[:10]))
+			// 没有收到包就退出
+			if hr < 0 {
+				break
+			}
+			// 如果收到包就回射
+			buf := bytes.NewReader(buffer)
+			var sn uint32
+			binary.Read(buf, binary.LittleEndian, &sn)
+			kcp2.Send(buffer[:hr])
+		}
+
+		// kcp1收到kcp2的回射数据
+		for {
+			hr = int32(kcp1.Recv(buffer[:10]))
+			buf := bytes.NewReader(buffer)
+			// 没有收到包就退出
+			if hr < 0 {
+				break
+			}
+			var sn uint32
+			var ts, rtt uint32
+			binary.Read(buf, binary.LittleEndian, &sn)
+			binary.Read(buf, binary.LittleEndian, &ts)
+			rtt = uint32(current) - ts
+
+			if sn != uint32(next) {
+				// 如果收到的包不连续
+				//for i:=0;i<8 ;i++ {
+				//println("---", i, buffer[i])
+				//}
+				println("ERROR sn ", count, "<->", next, sn)
+				return
+			}
+
+			next++
+			sumrtt += rtt
+			count++
+			if rtt > uint32(maxrtt) {
+				maxrtt = int(rtt)
+			}
+
+			//println("[RECV] mode=", mode, " sn=", sn, " rtt=", rtt)
+		}
+
+		if next > 100 {
+			break
+		}
+	}
+
+	ts1 = iclock() - ts1
+
+	names := []string{"default", "normal", "fast"}
+	fmt.Printf("%s mode result (%dms):\n", names[mode], ts1)
+	fmt.Printf("avgrtt=%d maxrtt=%d\n", int(sumrtt/uint32(count)), maxrtt)
+}
+
+func TestNetwork(t *testing.T) {
+	test(0) // 默认模式，类似 TCP：正常模式，无快速重传，常规流控
+	test(1) // 普通模式，关闭流控等
+	test(2) // 快速模式，所有开关都打开，且关闭流控
+}
+
+func BenchmarkFlush(b *testing.B) {
+	kcp := NewKCP(1, func(buf []byte, size int) {})
+	kcp.snd_buf = make([]segment, 32)
+	for k := range kcp.snd_buf {
+		kcp.snd_buf[k].xmit = 1
+		kcp.snd_buf[k].resendts = currentMs() + 10000
+	}
+	b.ResetTimer()
+	b.ReportAllocs()
+	var mu sync.Mutex
+	for i := 0; i < b.N; i++ {
+		mu.Lock()
+		kcp.flush(false)
+		mu.Unlock()
+	}
+}

vendor/github.com/xtaci/kcp-go/sess_test.go

@@ -0,0 +1,476 @@
+package kcp
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	_ "net/http/pprof"
+	"sync"
+	"testing"
+	"time"
+
+	"golang.org/x/crypto/pbkdf2"
+)
+
+const portEcho = "127.0.0.1:9999"
+const portSink = "127.0.0.1:19999"
+const portTinyBufferEcho = "127.0.0.1:29999"
+const portListerner = "127.0.0.1:9998"
+const salt = "kcptest"
+
+var key = []byte("testkey")
+var fec = 4
+var pass = pbkdf2.Key(key, []byte(portSink), 4096, 32, sha1.New)
+
+func init() {
+	go func() {
+		log.Println(http.ListenAndServe("localhost:6060", nil))
+	}()
+
+	go echoServer()
+	go sinkServer()
+	go tinyBufferEchoServer()
+	println("beginning tests, encryption:salsa20, fec:10/3")
+}
+
+func dialEcho() (*UDPSession, error) {
+	//block, _ := NewNoneBlockCrypt(pass)
+	//block, _ := NewSimpleXORBlockCrypt(pass)
+	//block, _ := NewTEABlockCrypt(pass[:16])
+	//block, _ := NewAESBlockCrypt(pass)
+	block, _ := NewSalsa20BlockCrypt(pass)
+	sess, err := DialWithOptions(portEcho, block, 10, 3)
+	if err != nil {
+		panic(err)
+	}
+
+	sess.SetStreamMode(true)
+	sess.SetStreamMode(false)
+	sess.SetStreamMode(true)
+	sess.SetWindowSize(4096, 4096)
+	sess.SetReadBuffer(4 * 1024 * 1024)
+	sess.SetWriteBuffer(4 * 1024 * 1024)
+	sess.SetStreamMode(true)
+	sess.SetNoDelay(1, 10, 2, 1)
+	sess.SetMtu(1400)
+	sess.SetMtu(1600)
+	sess.SetMtu(1400)
+	sess.SetACKNoDelay(true)
+	sess.SetDeadline(time.Now().Add(time.Minute))
+	return sess, err
+}
+
+func dialSink() (*UDPSession, error) {
+	sess, err := DialWithOptions(portSink, nil, 0, 0)
+	if err != nil {
+		panic(err)
+	}
+
+	sess.SetStreamMode(true)
+	sess.SetWindowSize(4096, 4096)
+	sess.SetReadBuffer(4 * 1024 * 1024)
+	sess.SetWriteBuffer(4 * 1024 * 1024)
+	sess.SetStreamMode(true)
+	sess.SetNoDelay(1, 10, 2, 1)
+	sess.SetMtu(1400)
+	sess.SetACKNoDelay(true)
+	sess.SetDeadline(time.Now().Add(time.Minute))
+	return sess, err
+}
+
+func dialTinyBufferEcho() (*UDPSession, error) {
+	//block, _ := NewNoneBlockCrypt(pass)
+	//block, _ := NewSimpleXORBlockCrypt(pass)
+	//block, _ := NewTEABlockCrypt(pass[:16])
+	//block, _ := NewAESBlockCrypt(pass)
+	block, _ := NewSalsa20BlockCrypt(pass)
+	sess, err := DialWithOptions(portTinyBufferEcho, block, 10, 3)
+	if err != nil {
+		panic(err)
+	}
+	return sess, err
+}
+
+//////////////////////////
+func listenEcho() (net.Listener, error) {
+	//block, _ := NewNoneBlockCrypt(pass)
+	//block, _ := NewSimpleXORBlockCrypt(pass)
+	//block, _ := NewTEABlockCrypt(pass[:16])
+	//block, _ := NewAESBlockCrypt(pass)
+	block, _ := NewSalsa20BlockCrypt(pass)
+	return ListenWithOptions(portEcho, block, 10, 3)
+}
+func listenTinyBufferEcho() (net.Listener, error) {
+	//block, _ := NewNoneBlockCrypt(pass)
+	//block, _ := NewSimpleXORBlockCrypt(pass)
+	//block, _ := NewTEABlockCrypt(pass[:16])
+	//block, _ := NewAESBlockCrypt(pass)
+	block, _ := NewSalsa20BlockCrypt(pass)
+	return ListenWithOptions(portTinyBufferEcho, block, 10, 3)
+}
+
+func listenSink() (net.Listener, error) {
+	return ListenWithOptions(portSink, nil, 0, 0)
+}
+
+func echoServer() {
+	l, err := listenEcho()
+	if err != nil {
+		panic(err)
+	}
+
+	go func() {
+		kcplistener := l.(*Listener)
+		kcplistener.SetReadBuffer(4 * 1024 * 1024)
+		kcplistener.SetWriteBuffer(4 * 1024 * 1024)
+		kcplistener.SetDSCP(46)
+		for {
+			s, err := l.Accept()
+			if err != nil {
+				return
+			}
+
+			// coverage test
+			s.(*UDPSession).SetReadBuffer(4 * 1024 * 1024)
+			s.(*UDPSession).SetWriteBuffer(4 * 1024 * 1024)
+			go handleEcho(s.(*UDPSession))
+		}
+	}()
+}
+
+func sinkServer() {
+	l, err := listenSink()
+	if err != nil {
+		panic(err)
+	}
+
+	go func() {
+		kcplistener := l.(*Listener)
+		kcplistener.SetReadBuffer(4 * 1024 * 1024)
+		kcplistener.SetWriteBuffer(4 * 1024 * 1024)
+		kcplistener.SetDSCP(46)
+		for {
+			s, err := l.Accept()
+			if err != nil {
+				return
+			}
+
+			go handleSink(s.(*UDPSession))
+		}
+	}()
+}
+
+func tinyBufferEchoServer() {
+	l, err := listenTinyBufferEcho()
+	if err != nil {
+		panic(err)
+	}
+
+	go func() {
+		for {
+			s, err := l.Accept()
+			if err != nil {
+				return
+			}
+			go handleTinyBufferEcho(s.(*UDPSession))
+		}
+	}()
+}
+
+///////////////////////////
+
+func handleEcho(conn *UDPSession) {
+	conn.SetStreamMode(true)
+	conn.SetWindowSize(4096, 4096)
+	conn.SetNoDelay(1, 10, 2, 1)
+	conn.SetDSCP(46)
+	conn.SetMtu(1400)
+	conn.SetACKNoDelay(false)
+	conn.SetReadDeadline(time.Now().Add(time.Hour))
+	conn.SetWriteDeadline(time.Now().Add(time.Hour))
+	buf := make([]byte, 65536)
+	for {
+		n, err := conn.Read(buf)
+		if err != nil {
+			panic(err)
+		}
+		conn.Write(buf[:n])
+	}
+}
+
+func handleSink(conn *UDPSession) {
+	conn.SetStreamMode(true)
+	conn.SetWindowSize(4096, 4096)
+	conn.SetNoDelay(1, 10, 2, 1)
+	conn.SetDSCP(46)
+	conn.SetMtu(1400)
+	conn.SetACKNoDelay(false)
+	conn.SetReadDeadline(time.Now().Add(time.Hour))
+	conn.SetWriteDeadline(time.Now().Add(time.Hour))
+	buf := make([]byte, 65536)
+	for {
+		_, err := conn.Read(buf)
+		if err != nil {
+			panic(err)
+		}
+	}
+}
+
+func handleTinyBufferEcho(conn *UDPSession) {
+	conn.SetStreamMode(true)
+	buf := make([]byte, 2)
+	for {
+		n, err := conn.Read(buf)
+		if err != nil {
+			panic(err)
+		}
+		conn.Write(buf[:n])
+	}
+}
+
+///////////////////////////
+
+func TestTimeout(t *testing.T) {
+	cli, err := dialEcho()
+	if err != nil {
+		panic(err)
+	}
+	buf := make([]byte, 10)
+
+	//timeout
+	cli.SetDeadline(time.Now().Add(time.Second))
+	<-time.After(2 * time.Second)
+	n, err := cli.Read(buf)
+	if n != 0 || err == nil {
+		t.Fail()
+	}
+	cli.Close()
+}
+
+func TestSendRecv(t *testing.T) {
+	cli, err := dialEcho()
+	if err != nil {
+		panic(err)
+	}
+	cli.SetWriteDelay(true)
+	cli.SetDUP(1)
+	const N = 100
+	buf := make([]byte, 10)
+	for i := 0; i < N; i++ {
+		msg := fmt.Sprintf("hello%v", i)
+		cli.Write([]byte(msg))
+		if n, err := cli.Read(buf); err == nil {
+			if string(buf[:n]) != msg {
+				t.Fail()
+			}
+		} else {
+			panic(err)
+		}
+	}
+	cli.Close()
+}
+
+func TestTinyBufferReceiver(t *testing.T) {
+	cli, err := dialTinyBufferEcho()
+	if err != nil {
+		panic(err)
+	}
+	const N = 100
+	snd := byte(0)
+	fillBuffer := func(buf []byte) {
+		for i := 0; i < len(buf); i++ {
+			buf[i] = snd
+			snd++
+		}
+	}
+
+	rcv := byte(0)
+	check := func(buf []byte) bool {
+		for i := 0; i < len(buf); i++ {
+			if buf[i] != rcv {
+				return false
+			}
+			rcv++
+		}
+		return true
+	}
+	sndbuf := make([]byte, 7)
+	rcvbuf := make([]byte, 7)
+	for i := 0; i < N; i++ {
+		fillBuffer(sndbuf)
+		cli.Write(sndbuf)
+		if n, err := io.ReadFull(cli, rcvbuf); err == nil {
+			if !check(rcvbuf[:n]) {
+				t.Fail()
+			}
+		} else {
+			panic(err)
+		}
+	}
+	cli.Close()
+}
+
+func TestClose(t *testing.T) {
+	cli, err := dialEcho()
+	if err != nil {
+		panic(err)
+	}
+	buf := make([]byte, 10)
+
+	cli.Close()
+	if cli.Close() == nil {
+		t.Fail()
+	}
+	n, err := cli.Write(buf)
+	if n != 0 || err == nil {
+		t.Fail()
+	}
+	n, err = cli.Read(buf)
+	if n != 0 || err == nil {
+		t.Fail()
+	}
+	cli.Close()
+}
+
+func TestParallel1024CLIENT_64BMSG_64CNT(t *testing.T) {
+	var wg sync.WaitGroup
+	wg.Add(1024)
+	for i := 0; i < 1024; i++ {
+		go parallel_client(&wg)
+	}
+	wg.Wait()
+}
+
+func parallel_client(wg *sync.WaitGroup) (err error) {
+	cli, err := dialEcho()
+	if err != nil {
+		panic(err)
+	}
+
+	err = echo_tester(cli, 64, 64)
+	wg.Done()
+	return
+}
+
+func BenchmarkEchoSpeed4K(b *testing.B) {
+	speedclient(b, 4096)
+}
+
+func BenchmarkEchoSpeed64K(b *testing.B) {
+	speedclient(b, 65536)
+}
+
+func BenchmarkEchoSpeed512K(b *testing.B) {
+	speedclient(b, 524288)
+}
+
+func BenchmarkEchoSpeed1M(b *testing.B) {
+	speedclient(b, 1048576)
+}
+
+func speedclient(b *testing.B, nbytes int) {
+	b.ReportAllocs()
+	cli, err := dialEcho()
+	if err != nil {
+		panic(err)
+	}
+
+	if err := echo_tester(cli, nbytes, b.N); err != nil {
+		b.Fail()
+	}
+	b.SetBytes(int64(nbytes))
+}
+
+func BenchmarkSinkSpeed4K(b *testing.B) {
+	sinkclient(b, 4096)
+}
+
+func BenchmarkSinkSpeed64K(b *testing.B) {
+	sinkclient(b, 65536)
+}
+
+func BenchmarkSinkSpeed256K(b *testing.B) {
+	sinkclient(b, 524288)
+}
+
+func BenchmarkSinkSpeed1M(b *testing.B) {
+	sinkclient(b, 1048576)
+}
+
+func sinkclient(b *testing.B, nbytes int) {
+	b.ReportAllocs()
+	cli, err := dialSink()
+	if err != nil {
+		panic(err)
+	}
+
+	sink_tester(cli, nbytes, b.N)
+	b.SetBytes(int64(nbytes))
+}
+
+func echo_tester(cli net.Conn, msglen, msgcount int) error {
+	buf := make([]byte, msglen)
+	for i := 0; i < msgcount; i++ {
+		// send packet
+		if _, err := cli.Write(buf); err != nil {
+			return err
+		}
+
+		// receive packet
+		nrecv := 0
+		for {
+			n, err := cli.Read(buf)
+			if err != nil {
+				return err
+			} else {
+				nrecv += n
+				if nrecv == msglen {
+					break
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func sink_tester(cli *UDPSession, msglen, msgcount int) error {
+	// sender
+	buf := make([]byte, msglen)
+	for i := 0; i < msgcount; i++ {
+		if _, err := cli.Write(buf); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func TestSNMP(t *testing.T) {
+	t.Log(DefaultSnmp.Copy())
+	t.Log(DefaultSnmp.Header())
+	t.Log(DefaultSnmp.ToSlice())
+	DefaultSnmp.Reset()
+	t.Log(DefaultSnmp.ToSlice())
+}
+
+func TestListenerClose(t *testing.T) {
+	l, err := ListenWithOptions(portListerner, nil, 10, 3)
+	if err != nil {
+		t.Fail()
+	}
+	l.SetReadDeadline(time.Now().Add(time.Second))
+	l.SetWriteDeadline(time.Now().Add(time.Second))
+	l.SetDeadline(time.Now().Add(time.Second))
+	time.Sleep(2 * time.Second)
+	if _, err := l.Accept(); err == nil {
+		t.Fail()
+	}
+
+	l.Close()
+	fakeaddr, _ := net.ResolveUDPAddr("udp6", "127.0.0.1:1111")
+	if l.closeSession(fakeaddr) {
+		t.Fail()
+	}
+}

vendor/github.com/xtaci/kcp-go/xor_test.go

@@ -0,0 +1,28 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package kcp
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestXORBytes(t *testing.T) {
+	for alignP := 0; alignP < 2; alignP++ {
+		for alignQ := 0; alignQ < 2; alignQ++ {
+			for alignD := 0; alignD < 2; alignD++ {
+				p := make([]byte, 1024)[alignP:]
+				q := make([]byte, 1024)[alignQ:]
+				d1 := make([]byte, 1024+alignD)[alignD:]
+				d2 := make([]byte, 1024+alignD)[alignD:]
+				xorBytes(d1, p, q)
+				safeXORBytes(d2, p, q)
+				if !bytes.Equal(d1, d2) {
+					t.Error("not equal")
+				}
+			}
+		}
+	}
+}

vendor/github.com/xtaci/smux/mux_test.go

@@ -0,0 +1,69 @@
+package smux
+
+import (
+	"bytes"
+	"testing"
+)
+
+type buffer struct {
+	bytes.Buffer
+}
+
+func (b *buffer) Close() error {
+	b.Buffer.Reset()
+	return nil
+}
+
+func TestConfig(t *testing.T) {
+	VerifyConfig(DefaultConfig())
+
+	config := DefaultConfig()
+	config.KeepAliveInterval = 0
+	err := VerifyConfig(config)
+	t.Log(err)
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	config = DefaultConfig()
+	config.KeepAliveInterval = 10
+	config.KeepAliveTimeout = 5
+	err = VerifyConfig(config)
+	t.Log(err)
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	config = DefaultConfig()
+	config.MaxFrameSize = 0
+	err = VerifyConfig(config)
+	t.Log(err)
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	config = DefaultConfig()
+	config.MaxFrameSize = 65536
+	err = VerifyConfig(config)
+	t.Log(err)
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	config = DefaultConfig()
+	config.MaxReceiveBuffer = 0
+	err = VerifyConfig(config)
+	t.Log(err)
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	var bts buffer
+	if _, err := Server(&bts, config); err == nil {
+		t.Fatal("server started with wrong config")
+	}
+
+	if _, err := Client(&bts, config); err == nil {
+		t.Fatal("client started with wrong config")
+	}
+}

vendor/github.com/xtaci/smux/session_test.go

@@ -0,0 +1,667 @@
+package smux
+
+import (
+	crand "crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"net"
+	"net/http"
+	_ "net/http/pprof"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+func init() {
+	go func() {
+		log.Println(http.ListenAndServe("localhost:6060", nil))
+	}()
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	ln, err := net.Listen("tcp", "127.0.0.1:19999")
+	if err != nil {
+		// handle error
+		panic(err)
+	}
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				// handle error
+			}
+			go handleConnection(conn)
+		}
+	}()
+}
+
+func handleConnection(conn net.Conn) {
+	session, _ := Server(conn, nil)
+	for {
+		if stream, err := session.AcceptStream(); err == nil {
+			go func(s io.ReadWriteCloser) {
+				buf := make([]byte, 65536)
+				for {
+					n, err := s.Read(buf)
+					if err != nil {
+						return
+					}
+					s.Write(buf[:n])
+				}
+			}(stream)
+		} else {
+			return
+		}
+	}
+}
+
+func TestEcho(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	const N = 100
+	buf := make([]byte, 10)
+	var sent string
+	var received string
+	for i := 0; i < N; i++ {
+		msg := fmt.Sprintf("hello%v", i)
+		stream.Write([]byte(msg))
+		sent += msg
+		if n, err := stream.Read(buf); err != nil {
+			t.Fatal(err)
+		} else {
+			received += string(buf[:n])
+		}
+	}
+	if sent != received {
+		t.Fatal("data mimatch")
+	}
+	session.Close()
+}
+
+func TestSpeed(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	t.Log(stream.LocalAddr(), stream.RemoteAddr())
+
+	start := time.Now()
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		buf := make([]byte, 1024*1024)
+		nrecv := 0
+		for {
+			n, err := stream.Read(buf)
+			if err != nil {
+				t.Fatal(err)
+				break
+			} else {
+				nrecv += n
+				if nrecv == 4096*4096 {
+					break
+				}
+			}
+		}
+		stream.Close()
+		t.Log("time for 16MB rtt", time.Since(start))
+		wg.Done()
+	}()
+	msg := make([]byte, 8192)
+	for i := 0; i < 2048; i++ {
+		stream.Write(msg)
+	}
+	wg.Wait()
+	session.Close()
+}
+
+func TestParallel(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+
+	par := 1000
+	messages := 100
+	var wg sync.WaitGroup
+	wg.Add(par)
+	for i := 0; i < par; i++ {
+		stream, _ := session.OpenStream()
+		go func(s *Stream) {
+			buf := make([]byte, 20)
+			for j := 0; j < messages; j++ {
+				msg := fmt.Sprintf("hello%v", j)
+				s.Write([]byte(msg))
+				if _, err := s.Read(buf); err != nil {
+					break
+				}
+			}
+			s.Close()
+			wg.Done()
+		}(stream)
+	}
+	t.Log("created", session.NumStreams(), "streams")
+	wg.Wait()
+	session.Close()
+}
+
+func TestCloseThenOpen(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	session.Close()
+	if _, err := session.OpenStream(); err == nil {
+		t.Fatal("opened after close")
+	}
+}
+
+func TestStreamDoubleClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	stream.Close()
+	if err := stream.Close(); err == nil {
+		t.Log("double close doesn't return error")
+	}
+	session.Close()
+}
+
+func TestConcurrentClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	numStreams := 100
+	streams := make([]*Stream, 0, numStreams)
+	var wg sync.WaitGroup
+	wg.Add(numStreams)
+	for i := 0; i < 100; i++ {
+		stream, _ := session.OpenStream()
+		streams = append(streams, stream)
+	}
+	for _, s := range streams {
+		stream := s
+		go func() {
+			stream.Close()
+			wg.Done()
+		}()
+	}
+	session.Close()
+	wg.Wait()
+}
+
+func TestTinyReadBuffer(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	const N = 100
+	tinybuf := make([]byte, 6)
+	var sent string
+	var received string
+	for i := 0; i < N; i++ {
+		msg := fmt.Sprintf("hello%v", i)
+		sent += msg
+		nsent, err := stream.Write([]byte(msg))
+		if err != nil {
+			t.Fatal("cannot write")
+		}
+		nrecv := 0
+		for nrecv < nsent {
+			if n, err := stream.Read(tinybuf); err == nil {
+				nrecv += n
+				received += string(tinybuf[:n])
+			} else {
+				t.Fatal("cannot read with tiny buffer")
+			}
+		}
+	}
+
+	if sent != received {
+		t.Fatal("data mimatch")
+	}
+	session.Close()
+}
+
+func TestIsClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	session.Close()
+	if session.IsClosed() != true {
+		t.Fatal("still open after close")
+	}
+}
+
+func TestKeepAliveTimeout(t *testing.T) {
+	ln, err := net.Listen("tcp", "127.0.0.1:29999")
+	if err != nil {
+		// handle error
+		panic(err)
+	}
+	go func() {
+		ln.Accept()
+	}()
+
+	cli, err := net.Dial("tcp", "127.0.0.1:29999")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	config := DefaultConfig()
+	config.KeepAliveInterval = time.Second
+	config.KeepAliveTimeout = 2 * time.Second
+	session, _ := Client(cli, config)
+	<-time.After(3 * time.Second)
+	if session.IsClosed() != true {
+		t.Fatal("keepalive-timeout failed")
+	}
+}
+
+func TestServerEcho(t *testing.T) {
+	ln, err := net.Listen("tcp", "127.0.0.1:39999")
+	if err != nil {
+		// handle error
+		panic(err)
+	}
+	go func() {
+		if conn, err := ln.Accept(); err == nil {
+			session, _ := Server(conn, nil)
+			if stream, err := session.OpenStream(); err == nil {
+				const N = 100
+				buf := make([]byte, 10)
+				for i := 0; i < N; i++ {
+					msg := fmt.Sprintf("hello%v", i)
+					stream.Write([]byte(msg))
+					if n, err := stream.Read(buf); err != nil {
+						t.Fatal(err)
+					} else if string(buf[:n]) != msg {
+						t.Fatal(err)
+					}
+				}
+				stream.Close()
+			} else {
+				t.Fatal(err)
+			}
+		} else {
+			t.Fatal(err)
+		}
+	}()
+
+	cli, err := net.Dial("tcp", "127.0.0.1:39999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if session, err := Client(cli, nil); err == nil {
+		if stream, err := session.AcceptStream(); err == nil {
+			buf := make([]byte, 65536)
+			for {
+				n, err := stream.Read(buf)
+				if err != nil {
+					break
+				}
+				stream.Write(buf[:n])
+			}
+		} else {
+			t.Fatal(err)
+		}
+	} else {
+		t.Fatal(err)
+	}
+}
+
+func TestSendWithoutRecv(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	const N = 100
+	for i := 0; i < N; i++ {
+		msg := fmt.Sprintf("hello%v", i)
+		stream.Write([]byte(msg))
+	}
+	buf := make([]byte, 1)
+	if _, err := stream.Read(buf); err != nil {
+		t.Fatal(err)
+	}
+	stream.Close()
+}
+
+func TestWriteAfterClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	stream.Close()
+	if _, err := stream.Write([]byte("write after close")); err == nil {
+		t.Fatal("write after close failed")
+	}
+}
+
+func TestReadStreamAfterSessionClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	session.Close()
+	buf := make([]byte, 10)
+	if _, err := stream.Read(buf); err != nil {
+		t.Log(err)
+	} else {
+		t.Fatal("read stream after session close succeeded")
+	}
+}
+
+func TestWriteStreamAfterConnectionClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	session.conn.Close()
+	if _, err := stream.Write([]byte("write after connection close")); err == nil {
+		t.Fatal("write after connection close failed")
+	}
+}
+
+func TestNumStreamAfterClose(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	if _, err := session.OpenStream(); err == nil {
+		if session.NumStreams() != 1 {
+			t.Fatal("wrong number of streams after opened")
+		}
+		session.Close()
+		if session.NumStreams() != 0 {
+			t.Fatal("wrong number of streams after session closed")
+		}
+	} else {
+		t.Fatal(err)
+	}
+	cli.Close()
+}
+
+func TestRandomFrame(t *testing.T) {
+	// pure random
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	for i := 0; i < 100; i++ {
+		rnd := make([]byte, rand.Uint32()%1024)
+		io.ReadFull(crand.Reader, rnd)
+		session.conn.Write(rnd)
+	}
+	cli.Close()
+
+	// double syn
+	cli, err = net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ = Client(cli, nil)
+	for i := 0; i < 100; i++ {
+		f := newFrame(cmdSYN, 1000)
+		session.writeFrame(f)
+	}
+	cli.Close()
+
+	// random cmds
+	cli, err = net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	allcmds := []byte{cmdSYN, cmdFIN, cmdPSH, cmdNOP}
+	session, _ = Client(cli, nil)
+	for i := 0; i < 100; i++ {
+		f := newFrame(allcmds[rand.Int()%len(allcmds)], rand.Uint32())
+		session.writeFrame(f)
+	}
+	cli.Close()
+
+	// random cmds & sids
+	cli, err = net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ = Client(cli, nil)
+	for i := 0; i < 100; i++ {
+		f := newFrame(byte(rand.Uint32()), rand.Uint32())
+		session.writeFrame(f)
+	}
+	cli.Close()
+
+	// random version
+	cli, err = net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ = Client(cli, nil)
+	for i := 0; i < 100; i++ {
+		f := newFrame(byte(rand.Uint32()), rand.Uint32())
+		f.ver = byte(rand.Uint32())
+		session.writeFrame(f)
+	}
+	cli.Close()
+
+	// incorrect size
+	cli, err = net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ = Client(cli, nil)
+
+	f := newFrame(byte(rand.Uint32()), rand.Uint32())
+	rnd := make([]byte, rand.Uint32()%1024)
+	io.ReadFull(crand.Reader, rnd)
+	f.data = rnd
+
+	buf := make([]byte, headerSize+len(f.data))
+	buf[0] = f.ver
+	buf[1] = f.cmd
+	binary.LittleEndian.PutUint16(buf[2:], uint16(len(rnd)+1)) /// incorrect size
+	binary.LittleEndian.PutUint32(buf[4:], f.sid)
+	copy(buf[headerSize:], f.data)
+
+	session.conn.Write(buf)
+	t.Log(rawHeader(buf))
+	cli.Close()
+}
+
+func TestReadDeadline(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	const N = 100
+	buf := make([]byte, 10)
+	var readErr error
+	for i := 0; i < N; i++ {
+		msg := fmt.Sprintf("hello%v", i)
+		stream.Write([]byte(msg))
+		stream.SetReadDeadline(time.Now().Add(-1 * time.Minute))
+		if _, readErr = stream.Read(buf); readErr != nil {
+			break
+		}
+	}
+	if readErr != nil {
+		if !strings.Contains(readErr.Error(), "i/o timeout") {
+			t.Fatalf("Wrong error: %v", readErr)
+		}
+	} else {
+		t.Fatal("No error when reading with past deadline")
+	}
+	session.Close()
+}
+
+func TestWriteDeadline(t *testing.T) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		t.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	stream, _ := session.OpenStream()
+	buf := make([]byte, 10)
+	var writeErr error
+	for {
+		stream.SetWriteDeadline(time.Now().Add(-1 * time.Minute))
+		if _, writeErr = stream.Write(buf); writeErr != nil {
+			if !strings.Contains(writeErr.Error(), "i/o timeout") {
+				t.Fatalf("Wrong error: %v", writeErr)
+			}
+			break
+		}
+	}
+	session.Close()
+}
+
+func BenchmarkAcceptClose(b *testing.B) {
+	cli, err := net.Dial("tcp", "127.0.0.1:19999")
+	if err != nil {
+		b.Fatal(err)
+	}
+	session, _ := Client(cli, nil)
+	for i := 0; i < b.N; i++ {
+		if stream, err := session.OpenStream(); err == nil {
+			stream.Close()
+		} else {
+			b.Fatal(err)
+		}
+	}
+}
+func BenchmarkConnSmux(b *testing.B) {
+	cs, ss, err := getSmuxStreamPair()
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer cs.Close()
+	defer ss.Close()
+	bench(b, cs, ss)
+}
+
+func BenchmarkConnTCP(b *testing.B) {
+	cs, ss, err := getTCPConnectionPair()
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer cs.Close()
+	defer ss.Close()
+	bench(b, cs, ss)
+}
+
+func getSmuxStreamPair() (*Stream, *Stream, error) {
+	c1, c2, err := getTCPConnectionPair()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	s, err := Server(c2, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	c, err := Client(c1, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	var ss *Stream
+	done := make(chan error)
+	go func() {
+		var rerr error
+		ss, rerr = s.AcceptStream()
+		done <- rerr
+		close(done)
+	}()
+	cs, err := c.OpenStream()
+	if err != nil {
+		return nil, nil, err
+	}
+	err = <-done
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return cs, ss, nil
+}
+
+func getTCPConnectionPair() (net.Conn, net.Conn, error) {
+	lst, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var conn0 net.Conn
+	var err0 error
+	done := make(chan struct{})
+	go func() {
+		conn0, err0 = lst.Accept()
+		close(done)
+	}()
+
+	conn1, err := net.Dial("tcp", lst.Addr().String())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	<-done
+	if err0 != nil {
+		return nil, nil, err0
+	}
+	return conn0, conn1, nil
+}
+
+func bench(b *testing.B, rd io.Reader, wr io.Writer) {
+	buf := make([]byte, 128*1024)
+	buf2 := make([]byte, 128*1024)
+	b.SetBytes(128 * 1024)
+	b.ResetTimer()
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		count := 0
+		for {
+			n, _ := rd.Read(buf2)
+			count += n
+			if count == 128*1024*b.N {
+				return
+			}
+		}
+	}()
+	for i := 0; i < b.N; i++ {
+		wr.Write(buf)
+	}
+	wg.Wait()
+}