worked on quic implementation

Author: phifty

Gopkg.lock

@@ -29,10 +29,6 @@
   branch = "master"
   name = "github.com/golang/protobuf"
 
-[[constraint]]
-  name = "github.com/lucas-clemente/quic-go"
-  branch = "master"
-
 [[constraint]]
   branch = "master"
   name = "github.com/miekg/dns"

Gopkg.toml

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/pem"
+	"fmt"
+	"log"
+	"math/big"
+	"net"
+	"time"
+
+	"github.com/simia-tech/netx"
+	"github.com/simia-tech/netx/filter/blacklist"
+	_ "github.com/simia-tech/netx/network/quic"
+	"github.com/simia-tech/netx/provider/static"
+	"github.com/simia-tech/netx/selector/roundrobin"
+	"github.com/simia-tech/netx/value"
+)
+
+func main() {
+	addrOneChan := runEchoServer("127.0.0.1:0")
+	addrTwoChan := runEchoServer("127.0.0.1:0")
+
+	provider := static.NewProvider()
+	provider.Add("test", value.NewEndpointFromAddr(<-addrOneChan, value.TLS(&tls.Config{InsecureSkipVerify: true})))
+	provider.Add("test", value.NewEndpointFromAddr(<-addrTwoChan, value.TLS(&tls.Config{InsecureSkipVerify: true})))
+
+	md, err := netx.NewMultiDialer(provider, blacklist.NewFilter(blacklist.ConstantBackoff(100*time.Millisecond)), roundrobin.NewSelector())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	conn, err := md.Dial("test")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Fprintln(conn, "hello")
+
+	buffer := make([]byte, 6)
+	conn.Read(buffer)
+	fmt.Print(string(buffer))
+}
+
+func runEchoServer(address string) chan net.Addr {
+	ch := make(chan net.Addr)
+	go func() {
+		listener, err := netx.Listen("quic", address, value.TLS(generateTLSConfig()))
+		if err != nil {
+			log.Fatal(err)
+		}
+		ch <- listener.Addr()
+
+		conn, err := listener.Accept()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		buffer := make([]byte, 6)
+		conn.Read(buffer)
+		conn.Write(buffer)
+	}()
+	return ch
+}
+
+func generateTLSConfig() *tls.Config {
+	key, err := rsa.GenerateKey(rand.Reader, 1024)
+	if err != nil {
+		panic(err)
+	}
+	template := x509.Certificate{SerialNumber: big.NewInt(1)}
+	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
+	if err != nil {
+		panic(err)
+	}
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
+	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
+
+	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
+	if err != nil {
+		panic(err)
+	}
+	return &tls.Config{Certificates: []tls.Certificate{tlsCert}}
+}

example/static-quic/main.go

@@ -0,0 +1,13 @@
+package quic
+
+type addr struct {
+	address string
+}
+
+func (a *addr) Network() string {
+	return "quic"
+}
+
+func (a addr) String() string {
+	return a.address
+}

network/quic/addr.go

@@ -23,7 +23,7 @@ func init() {
 
 // Dial opens a connection to the provided address.
 func Dial(address string, options *value.Options) (net.Conn, error) {
-	session, err := quic.DialAddr(address, options.TLSConfig, &quic.Config{})
+	session, err := quic.DialAddr(address, options.TLSConfig, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -56,8 +56,7 @@ func (c *conn) Read(data []byte) (int, error) {
 }
 
 func (c *conn) Write(data []byte) (int, error) {
-	n, err := c.stream.Write(data)
-	return n, err
+	return c.stream.Write(data)
 }
 
 func (c *conn) Close() error {
@@ -77,10 +76,16 @@ func (c *conn) Close() error {
 }
 
 func (c *conn) LocalAddr() net.Addr {
+	if c.session == nil {
+		return nil
+	}
 	return c.session.LocalAddr()
 }
 
 func (c *conn) RemoteAddr() net.Addr {
+	if c.session == nil {
+		return nil
+	}
 	return c.session.RemoteAddr()
 }
 

network/quic/conn.go

@@ -18,7 +18,7 @@ func init() {
 
 // Listen starts a listener at the provided address.
 func Listen(address string, options *value.Options) (net.Listener, error) {
-	l, err := quic.ListenAddr(address, options.TLSConfig, &quic.Config{})
+	l, err := quic.ListenAddr(address, options.TLSConfig, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -40,12 +40,13 @@ func (l *listener) Accept() (net.Conn, error) {
 	}
 
 	return &conn{
-		stream: stream,
+		session: session,
+		stream:  stream,
 	}, nil
 }
 
 func (l *listener) Addr() net.Addr {
-	return l.listener.Addr()
+	return &addr{address: l.listener.Addr().String()}
 }
 
 func (l *listener) Close() error {