switch back to nhooyr websocket for browser support

reverting libp2p/go-libp2p#2280

Author: navigaid

cmd/dial/main.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	// We need to import libp2p's libraries that we use in this project.
+	"github.com/libp2p/go-libp2p"
+	"github.com/libp2p/go-libp2p/core/host"
+	"github.com/libp2p/go-libp2p/core/peer"
+
+	"github.com/btwiuse/wsport"
+)
+
+func getEnv(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
+
+var RELAY = getEnv("RELAY", "https://example.com")
+
+// makeRandomHost creates a libp2p host with a randomly generated identity.
+// This step is described in depth in other tutorials.
+func makeRandomHost(port int) host.Host {
+	log.SetFlags(log.LstdFlags | log.Llongfile)
+	addr := fmt.Sprintf(RELAY+"/ws%d", port)
+	log.Println("ListenAddr", addr)
+	host, err := libp2p.New(
+		libp2p.Transport(wsport.New),
+		wsport.ListenAddrStrings(addr),
+	)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	return host
+}
+
+func main() {
+	host := makeRandomHost(1000)
+	fmt.Println("host is ready")
+	fmt.Println("libp2p-peer addresses:")
+	for _, a := range host.Addrs() {
+		fmt.Printf("%s/p2p/%s\n", a, host.ID())
+	}
+
+	addrInfo, err := peer.AddrInfoFromString(os.Args[1])
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	err = host.Connect(context.Background(), *addrInfo)
+	if err != nil {
+		log.Fatalln(err)
+	} else {
+		fmt.Println("Connected to", addrInfo.ID)
+	}
+
+	select {}
+}

cmd/reconnect/main.go

@@ -55,6 +55,12 @@ func Run(args []string) error {
 				time.Sleep(time.Duration(i) * time.Second)
 			}
 		},
+		onConnected: func(n network.Network, c network.Conn) {
+			log.Println("[Connected]", c.ID())
+		},
+		onDisconnected: func(n network.Network, c network.Conn) {
+			log.Println("[Disconnected]", c.ID())
+		},
 	}
 
 	host.Network().Notify(notifiee)

conn.go

@@ -1,158 +1,10 @@
 package wsport
 
 import (
-	"io"
-	"net"
-	"sync"
-	"time"
-
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/transport"
-
-	ws "github.com/gorilla/websocket"
 )
 
-// GracefulCloseTimeout is the time to wait trying to gracefully close a
-// connection before simply cutting it.
-var GracefulCloseTimeout = 100 * time.Millisecond
-
-// Conn implements net.Conn interface for gorilla/websocket.
-type Conn struct {
-	*ws.Conn
-	secure             bool
-	DefaultMessageType int
-	reader             io.Reader
-	closeOnce          sync.Once
-
-	readLock, writeLock sync.Mutex
-}
-
-var _ net.Conn = (*Conn)(nil)
-
-// NewConn creates a Conn given a regular gorilla/websocket Conn.
-func NewConn(raw *ws.Conn, secure bool) *Conn {
-	return &Conn{
-		Conn:               raw,
-		secure:             secure,
-		DefaultMessageType: ws.BinaryMessage,
-	}
-}
-
-func (c *Conn) Read(b []byte) (int, error) {
-	c.readLock.Lock()
-	defer c.readLock.Unlock()
-
-	if c.reader == nil {
-		if err := c.prepNextReader(); err != nil {
-			return 0, err
-		}
-	}
-
-	for {
-		n, err := c.reader.Read(b)
-		switch err {
-		case io.EOF:
-			c.reader = nil
-
-			if n > 0 {
-				return n, nil
-			}
-
-			if err := c.prepNextReader(); err != nil {
-				return 0, err
-			}
-
-			// explicitly looping
-		default:
-			return n, err
-		}
-	}
-}
-
-func (c *Conn) prepNextReader() error {
-	t, r, err := c.Conn.NextReader()
-	if err != nil {
-		if wserr, ok := err.(*ws.CloseError); ok {
-			if wserr.Code == 1000 || wserr.Code == 1005 {
-				return io.EOF
-			}
-		}
-		return err
-	}
-
-	if t == ws.CloseMessage {
-		return io.EOF
-	}
-
-	c.reader = r
-	return nil
-}
-
-func (c *Conn) Write(b []byte) (n int, err error) {
-	c.writeLock.Lock()
-	defer c.writeLock.Unlock()
-
-	if err := c.Conn.WriteMessage(c.DefaultMessageType, b); err != nil {
-		return 0, err
-	}
-
-	return len(b), nil
-}
-
-// Close closes the connection. Only the first call to Close will receive the
-// close error, subsequent and concurrent calls will return nil.
-// This method is thread-safe.
-func (c *Conn) Close() error {
-	var err error
-	c.closeOnce.Do(func() {
-		err1 := c.Conn.WriteControl(
-			ws.CloseMessage,
-			ws.FormatCloseMessage(ws.CloseNormalClosure, "closed"),
-			time.Now().Add(GracefulCloseTimeout),
-		)
-		err2 := c.Conn.Close()
-		switch {
-		case err1 != nil:
-			err = err1
-		case err2 != nil:
-			err = err2
-		}
-	})
-	return err
-}
-
-func (c *Conn) LocalAddr() net.Addr {
-	return NewAddrWithScheme(c.Conn.LocalAddr().String(), c.secure)
-}
-
-func (c *Conn) RemoteAddr() net.Addr {
-	return NewAddrWithScheme(c.Conn.RemoteAddr().String(), c.secure)
-}
-
-func (c *Conn) SetDeadline(t time.Time) error {
-	if err := c.SetReadDeadline(t); err != nil {
-		return err
-	}
-
-	return c.SetWriteDeadline(t)
-}
-
-func (c *Conn) SetReadDeadline(t time.Time) error {
-	// Don't lock when setting the read deadline. That would prevent us from
-	// interrupting an in-progress read.
-	return c.Conn.SetReadDeadline(t)
-}
-
-func (c *Conn) SetWriteDeadline(t time.Time) error {
-	// Unlike the read deadline, we need to lock when setting the write
-	// deadline.
-
-	c.writeLock.Lock()
-	defer c.writeLock.Unlock()
-
-	return c.Conn.SetWriteDeadline(t)
-}
-
 type capableConn struct {
 	transport.CapableConn
 }

dial.go

@@ -0,0 +1,22 @@
+package wsport
+
+import (
+	"context"
+	"net"
+	"net/http"
+
+	"nhooyr.io/websocket"
+)
+
+func DialConn(ctx context.Context, addr string, hdr http.Header) (conn net.Conn, err error) {
+	wsconn, _, err := websocket.Dial(
+		ctx,
+		addr,
+		dialOptions(hdr),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return websocket.NetConn(context.Background(), wsconn, websocket.MessageBinary), nil
+}

dial_js.go

@@ -0,0 +1,13 @@
+//go:build js
+
+package wsport
+
+import (
+	"net/http"
+
+	"nhooyr.io/websocket"
+)
+
+func dialOptions(http.Header) *websocket.DialOptions {
+	return &websocket.DialOptions{}
+}

dial_nojs.go

@@ -0,0 +1,24 @@
+//go:build !js
+
+package wsport
+
+import (
+	"crypto/tls"
+	"net/http"
+
+	"nhooyr.io/websocket"
+)
+
+func dialOptions(hdr http.Header) *websocket.DialOptions {
+	return &websocket.DialOptions{
+		HTTPClient: &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+				TLSClientConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
+			},
+		},
+		HTTPHeader: hdr,
+	}
+}

go.mod

@@ -5,19 +5,19 @@ go 1.22.2
 replace github.com/libp2p/go-libp2p => github.com/btwiuse/go-libp2p v0.33.1-0.20240506191734-9e95b7cfe073
 
 require (
+	github.com/btwiuse/wsconn v0.0.2
 	github.com/btwiuse/x-parity-wss v0.0.2
-	github.com/gorilla/websocket v1.5.1
 	github.com/libp2p/go-libp2p v0.33.2
 	github.com/multiformats/go-multiaddr v0.12.3
 	github.com/multiformats/go-multiaddr-fmt v0.1.0
 	github.com/stretchr/testify v1.8.4
 	github.com/webteleport/webteleport v0.5.28
+	nhooyr.io/websocket v1.8.11
 )
 
 require (
 	github.com/benbjohnson/clock v1.3.5 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/btwiuse/wsconn v0.0.2 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/containerd/cgroups v1.1.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
@@ -36,6 +36,7 @@ require (
 	github.com/google/pprof v0.0.0-20240207164012-fb44976bdcd5 // indirect
 	github.com/google/uuid v1.4.0 // indirect
 	github.com/gorilla/handlers v1.5.2 // indirect
+	github.com/gorilla/websocket v1.5.1 // indirect
 	github.com/hashicorp/yamux v0.1.1 // indirect
 	github.com/huin/goupnp v1.3.0 // indirect
 	github.com/ipfs/go-cid v0.4.1 // indirect
@@ -117,5 +118,4 @@ require (
 	google.golang.org/protobuf v1.32.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	lukechampine.com/blake3 v1.2.1 // indirect
-	nhooyr.io/websocket v1.8.11 // indirect
 )

listener.go

@@ -12,6 +12,7 @@ import (
 	"github.com/libp2p/go-libp2p/core/transport"
 	"github.com/webteleport/webteleport/transport/websocket"
 
+	"github.com/btwiuse/wsconn"
 	ma "github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
 )
@@ -25,7 +26,7 @@ type listener struct {
 	laddr ma.Multiaddr
 
 	closed   chan struct{}
-	incoming chan *Conn
+	incoming chan net.Conn
 }
 
 func (pwma *parsedWebsocketMultiaddr) toMultiaddr() ma.Multiaddr {
@@ -97,7 +98,7 @@ func newListener(a ma.Multiaddr, tlsConf *tls.Config) (*listener, error) {
 		nl:       nl,
 		isWss:    parsed.isWSS,
 		laddr:    laddr,
-		incoming: make(chan *Conn),
+		incoming: make(chan net.Conn),
 		closed:   make(chan struct{}),
 	}
 	return ln, nil
@@ -121,14 +122,14 @@ func (l *listener) serve() {
 }
 
 func (l *listener) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	c, err := upgrader.Upgrade(w, r, nil)
+	c, err := wsconn.Wrconn(w, r)
 	if err != nil {
 		// The upgrader writes a response for us.
 		return
 	}
 
 	select {
-	case l.incoming <- NewConn(c, l.isWss):
+	case l.incoming <- c:
 	case <-l.closed:
 		c.Close()
 	}