Remove WebRTCPeer.activeTransportMode.

Make "u" mode the assumed default. The WebRTC data channel protocol
contains just the hex clientID.

client/lib/snowflake.go

@@ -331,11 +331,6 @@ func parseIceServers(addresses []string) []webrtc.ICEServer {
 // over. The net.PacketConn successively connects through Snowflake proxies
 // pulled from snowflakes.
 func newSession(snowflakes SnowflakeCollector, clientIDCandid turbotunnel.ClientID) (net.PacketConn, *smux.Session, error) {
-	clientID := turbotunnel.NewClientID()
-	if clientIDCandid != (turbotunnel.ClientID{}) {
-		clientID = clientIDCandid
-	}
-
 	// We build a persistent KCP session on a sequence of ephemeral WebRTC
 	// connections. This dialContext tells RedialPacketConn how to get a new
 	// WebRTC connection when the previous one dies. Inside each WebRTC
@@ -349,26 +344,12 @@ func newSession(snowflakes SnowflakeCollector, clientIDCandid turbotunnel.Client
 			return nil, errors.New("handler: Received invalid Snowflake")
 		}
 		log.Println("---- Handler: snowflake assigned ----")
-		log.Printf("activeTransportMode = %c \n", conn.activeTransportMode)
+		packetConnWrapper := &packetConnWrapper{
-		if conn.activeTransportMode == 'u' {
+			ReadWriter: conn,
-			packetConnWrapper := &packetConnWrapper{
+			remoteAddr: dummyAddr{},
-				ReadWriter: conn,
+			localAddr:  dummyAddr{},
-				remoteAddr: dummyAddr{},
-				localAddr:  dummyAddr{},
-			}
-			return packetConnWrapper, nil
 		}
-		// Send the magic Turbo Tunnel token.
+		return packetConnWrapper, nil
-		_, err := conn.Write(turbotunnel.Token[:])
-		if err != nil {
-			return nil, err
-		}
-		// Send ClientID prefix.
-		_, err = conn.Write(clientID[:])
-		if err != nil {
-			return nil, err
-		}
-		return newEncapsulationPacketConn(dummyAddr{}, dummyAddr{}, conn), nil
 	}
 	pconn := turbotunnel.NewRedialPacketConn(dummyAddr{}, dummyAddr{}, dialContext)
 

client/lib/webrtc.go

@@ -46,8 +46,7 @@ type WebRTCPeer struct {
 	eventsLogger event.SnowflakeEventReceiver
 	proxy        *url.URL
 
-	activeTransportMode byte
+	clientID turbotunnel.ClientID
-	clientID            turbotunnel.ClientID
 }
 
 // Deprecated: Use NewWebRTCPeerWithNatPolicyAndEventsAndProxy Instead.
@@ -212,7 +211,6 @@ func (c *WebRTCPeer) connect(
 ) error {
 	log.Println(c.id, " connecting...")
 
-	c.activeTransportMode = 'u'
 	err := c.preparePeerConnection(config, broker.keepLocalAddresses)
 	localDescription := c.pc.LocalDescription()
 	c.eventsLogger.OnNewSnowflakeEvent(event.EventOnOfferCreated{
@@ -318,18 +316,13 @@ func (c *WebRTCPeer) preparePeerConnection(
 		log.Printf("NewPeerConnection ERROR: %s", err)
 		return err
 	}
-	ordered := true
+	ordered := false
-	var maxRetransmission *uint16
+	var maxRetransmission uint16 = 0
-	if c.activeTransportMode == 'u' {
+	protocol := fmt.Sprintf("%s", c.clientID.String())
-		ordered = false
-		maxRetransmissionVal := uint16(0)
-		maxRetransmission = &maxRetransmissionVal
-	}
-	protocol := fmt.Sprintf("%c %s", c.activeTransportMode, c.clientID.String())
 	dataChannelOptions := &webrtc.DataChannelInit{
 		Ordered:        &ordered,
 		Protocol:       &protocol,
-		MaxRetransmits: maxRetransmission,
+		MaxRetransmits: &maxRetransmission,
 	}
 	// We must create the data channel before creating an offer
 	// https://github.com/pion/webrtc/wiki/Release-WebRTC@v3.0.0#a-data-channel-is-no-longer-implicitly-created-with-a-peerconnection

server/lib/http.go

@@ -2,7 +2,6 @@ package snowflake_server
 
 import (
 	"bufio"
-	"bytes"
 	"crypto/hmac"
 	"crypto/rand"
 	"crypto/sha256"
@@ -13,7 +12,6 @@ import (
 	"log"
 	"net"
 	"net/http"
-	"strings"
 	"sync"
 	"time"
 
@@ -112,45 +110,8 @@ func (handler *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	addr := clientAddr(clientIPParam)
 	protocol := r.URL.Query().Get("protocol")
 
-	clientTransport := "t"
+	err = handler.turboTunnelUDPLikeMode(conn, addr, protocol)
-
+	if err != nil && err != io.EOF {
-	if protocol != "" {
-		clientTransport = fmt.Sprintf("%c", protocol[0])
-	}
-
-	if clientTransport == "u" {
-		err = handler.turboTunnelUDPLikeMode(conn, addr, protocol)
-		if err != nil && err != io.EOF {
-			log.Println(err)
-			return
-		}
-		return
-	}
-
-	var token [len(turbotunnel.Token)]byte
-	_, err = io.ReadFull(conn, token[:])
-	if err != nil {
-		// Don't bother logging EOF: that happens with an unused
-		// connection, which clients make frequently as they maintain a
-		// pool of proxies.
-		if err != io.EOF {
-			log.Printf("reading token: %v", err)
-		}
-		return
-	}
-
-	switch {
-	case bytes.Equal(token[:], turbotunnel.Token[:]):
-		err = handler.turbotunnelMode(conn, addr)
-	default:
-		// We didn't find a matching token, which means that we are
-		// dealing with a client that doesn't know about such things.
-		// Close the conn as we no longer support the old
-		// one-session-per-WebSocket mode.
-		log.Println("Received unsupported oneshot connection")
-		return
-	}
-	if err != nil {
 		log.Println(err)
 		return
 	}
@@ -243,11 +204,7 @@ func (handler *httpHandler) turboTunnelUDPLikeMode(conn net.Conn, addr net.Addr,
 	var packet [1600]byte
 
 	clientID := turbotunnel.ClientID{}
-	compoments := strings.Split(protocol, " ")
+	_, err := hex.Decode(clientID[:], []byte(protocol))
-	if len(compoments) != 2 {
-		return fmt.Errorf("invalid protocol: %s", protocol)
-	}
-	_, err := hex.Decode(clientID[:], []byte(compoments[1]))
 	if err != nil {
 		return fmt.Errorf("reading ClientID: %v", err)
 	}