copy-paste rendezvous works again, but with new interface allowing seamless recovery for the first time

client/rendezvous.go

@@ -1,15 +1,26 @@
-// WebRTC Rendezvous requires the exchange of SessionDescriptions between
-// peers. This file contains the domain-fronted HTTP signaling mechanism
-// between the client and a desired Broker.
+// WebRTC rendezvous requires the exchange of SessionDescriptions between
+// peers in order to establish a PeerConnection.
+//
+// This file contains the two methods currently available to Snowflake:
+//
+// - Domain-fronted HTTP signaling. The Broker automatically exchange offers
+//   and answers between this client and some remote WebRTC proxy.
+//   (This is the recommended default, enabled via the flags in "torrc".)
+//
+// - Manual copy-paste signaling. User must create a signaling pipe.
+//   (The flags in torrc-manual allow this)
 package main
 
 import (
+	"bufio"
 	"bytes"
 	"errors"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
+	"os"
+	"syscall"
 
 	"github.com/keroserene/go-webrtc"
 )
@@ -100,3 +111,98 @@ func (bc *BrokerChannel) Negotiate(offer *webrtc.SessionDescription) (
 		return nil, errors.New(BrokerErrorUnexpected)
 	}
 }
+
+// Implements the |Tongue| interface to catch snowflakes, using BrokerChannel.
+type WebRTCDialer struct {
+	*BrokerChannel
+	webrtcConfig *webrtc.Configuration
+}
+
+func NewWebRTCDialer(
+	broker *BrokerChannel, iceServers IceServerList) *WebRTCDialer {
+	config := webrtc.NewConfiguration(iceServers...)
+	return &WebRTCDialer{
+		BrokerChannel: broker,
+		webrtcConfig:  config,
+	}
+}
+
+// Initialize a WebRTC Connection by signaling through the broker.
+func (w WebRTCDialer) Catch() (*webRTCConn, error) {
+	if nil == w.BrokerChannel {
+		return nil, errors.New("Cannot Dial WebRTC without a BrokerChannel.")
+	}
+	// TODO: [#3] Fetch ICE server information from Broker.
+	// TODO: [#18] Consider TURN servers here too.
+	connection := NewWebRTCConnection(w.webrtcConfig, w.BrokerChannel)
+	err := connection.Connect()
+	return connection, err
+}
+
+// CopyPasteDialer handles the interaction required to copy-paste the
+// offers and answers.
+// Implements |Tongue| interface to catch snowflakes manually.
+// Supports recovery of connections.
+type CopyPasteDialer struct {
+	webrtcConfig *webrtc.Configuration
+	signal       *os.File
+	current      *webRTCConn
+}
+
+func NewCopyPasteDialer(iceServers IceServerList) *CopyPasteDialer {
+	log.Println("No HTTP signaling detected. Using manual copy-paste signaling.")
+	log.Println("Waiting for a \"signal\" pipe...")
+	// This FIFO receives signaling messages.
+	err := syscall.Mkfifo("signal", 0600)
+	if err != nil {
+		if syscall.EEXIST != err.(syscall.Errno) {
+			log.Fatal(err)
+		}
+	}
+	signalFile, err := os.OpenFile("signal", os.O_RDONLY, 0600)
+	if nil != err {
+		log.Fatal(err)
+		return nil
+	}
+	config := webrtc.NewConfiguration(iceServers...)
+	dialer := &CopyPasteDialer{
+		webrtcConfig: config,
+		signal:       signalFile,
+	}
+	go dialer.readSignals()
+	return dialer
+}
+
+// Initialize a WebRTC connection via manual copy-paste.
+func (d *CopyPasteDialer) Catch() (*webRTCConn, error) {
+	if nil == d.signal {
+		return nil, errors.New("Cannot copy-paste dial without signal pipe.")
+	}
+	connection := NewWebRTCConnection(d.webrtcConfig, nil)
+	// Must keep track of pending new connection until copy-paste completes.
+	d.current = connection
+	// Outputs SDP offer to log, expecting user to copy-paste to the remote Peer.
+	// Blocks until user pastes back the answer.
+	err := connection.Connect()
+	d.current = nil
+	return connection, err
+}
+
+// Manual copy-paste signalling.
+func (d *CopyPasteDialer) readSignals() {
+	defer d.signal.Close()
+	log.Printf("CopyPasteDialer: reading messages from signal pipe.")
+	s := bufio.NewScanner(d.signal)
+	for s.Scan() {
+		msg := s.Text()
+		sdp := webrtc.DeserializeSessionDescription(msg)
+		if sdp == nil {
+			log.Printf("CopyPasteDialer: ignoring invalid signal message %+q", msg)
+			continue
+		}
+		d.current.answerChannel <- sdp
+	}
+	if err := s.Err(); err != nil {
+		log.Printf("signal FIFO: %s", err)
+	}
+}

client/snowflake.go

@@ -2,7 +2,6 @@
 package main
 
 import (
-	"bufio"
 	"errors"
 	"flag"
 	"io"
@@ -110,45 +109,6 @@ func handler(socks SocksConnector, snowflakes SnowflakeCollector) error {
 	return nil
 }
 
-func setupCopyPaste() {
-	log.Println("No HTTP signaling detected. Waiting for a \"signal\" pipe...")
-	// This FIFO receives signaling messages.
-	err := syscall.Mkfifo("signal", 0600)
-	if err != nil {
-		if syscall.EEXIST != err.(syscall.Errno) {
-			log.Fatal(err)
-		}
-	}
-	signalFile, err := os.OpenFile("signal", os.O_RDONLY, 0600)
-	if nil != err {
-		log.Fatal(err)
-	}
-	defer signalFile.Close()
-	go readSignalingMessages(signalFile)
-}
-
-// Manual copy-paste signalling.
-// TODO: Needs fix since multiplexing changes access to the remotes.
-func readSignalingMessages(f *os.File) {
-	log.Printf("readSignalingMessages")
-	s := bufio.NewScanner(f)
-	for s.Scan() {
-		msg := s.Text()
-		log.Printf("readSignalingMessages loop %+q", msg)
-		sdp := webrtc.DeserializeSessionDescription(msg)
-		if sdp == nil {
-			log.Printf("ignoring invalid signal message %+q", msg)
-			continue
-		}
-		// webrtcRemotes[0].answerChannel <- sdp
-	}
-	log.Printf("close answerChannel")
-	// close(webrtcRemotes[0].answerChannel)
-	if err := s.Err(); err != nil {
-		log.Printf("signal FIFO: %s", err)
-	}
-}
-
 func main() {
 	webrtc.SetLoggingVerbosity(1)
 	logFile, err := os.OpenFile("snowflake.log",
@@ -169,24 +129,24 @@ func main() {
 		"capacity for number of multiplexed WebRTC peers")
 	flag.Parse()
 
-	// TODO: Maybe just get rid of copy-paste option entirely.
-	if "" == *brokerURL {
-		setupCopyPaste()
-	}
-
-	// Prepare WebRTC SnowflakeCollector, Broker, then accumulate connections.
+	// Prepare to collect remote WebRTC peers.
 	snowflakes := NewPeers(*max)
-	broker := NewBrokerChannel(*brokerURL, *frontDomain, CreateBrokerTransport())
-	snowflakes.Tongue = NewWebRTCDialer(broker, iceServers)
-
-	// Use a real logger for traffic.
+	if "" != *brokerURL {
+		// Use potentially domain-fronting broker to rendezvous.
+		broker := NewBrokerChannel(*brokerURL, *frontDomain, CreateBrokerTransport())
+		snowflakes.Tongue = NewWebRTCDialer(broker, iceServers)
+	} else {
+		// Otherwise, use manual copy and pasting of SDP messages.
+		snowflakes.Tongue = NewCopyPasteDialer(iceServers)
+	}
+	// Use a real logger to periodically output how much traffic is happening.
 	snowflakes.BytesLogger = &BytesSyncLogger{
 		inboundChan: make(chan int, 5), outboundChan: make(chan int, 5),
 		inbound: 0, outbound: 0, inEvents: 0, outEvents: 0,
 	}
+	go snowflakes.BytesLogger.Log()
 
 	go ConnectLoop(snowflakes)
-	go snowflakes.BytesLogger.Log()
 
 	// Begin goptlib client process.
 	ptInfo, err := pt.ClientSetup(nil)
@@ -197,7 +157,6 @@ func main() {
 		pt.ProxyError("proxy is not supported")
 		os.Exit(1)
 	}
-
 	listeners := make([]net.Listener, 0)
 	for _, methodName := range ptInfo.MethodNames {
 		switch methodName {
@@ -234,9 +193,7 @@ func main() {
 	for _, ln := range listeners {
 		ln.Close()
 	}
-
 	snowflakes.End()
-
 	// wait for second signal or no more handlers
 	sig = nil
 	for sig == nil && numHandlers != 0 {

client/webrtc.go

@@ -11,34 +11,6 @@ import (
 	"time"
 )
 
-// Implements the |Tongue| interface to catch snowflakes, using a BrokerChannel.
-type WebRTCDialer struct {
-	*BrokerChannel
-	webrtcConfig *webrtc.Configuration
-}
-
-func NewWebRTCDialer(
-	broker *BrokerChannel, iceServers IceServerList) *WebRTCDialer {
-
-	config := webrtc.NewConfiguration(iceServers...)
-	return &WebRTCDialer{
-		BrokerChannel: broker,
-		webrtcConfig:  config,
-	}
-}
-
-// Initialize a WebRTC Connection by signaling through the broker.
-func (w WebRTCDialer) Catch() (*webRTCConn, error) {
-	if nil == w.BrokerChannel {
-		return nil, errors.New("Cannot Dial WebRTC without a BrokerChannel.")
-	}
-	// TODO: [#3] Fetch ICE server information from Broker.
-	// TODO: [#18] Consider TURN servers here too.
-	connection := NewWebRTCConnection(w.webrtcConfig, w.BrokerChannel)
-	err := connection.Connect()
-	return connection, err
-}
-
 // Remote WebRTC peer.  Implements the |net.Conn| interface.
 type webRTCConn struct {
 	config    *webrtc.Configuration
@@ -282,11 +254,11 @@ func (c *webRTCConn) sendOfferToBroker() {
 func (c *webRTCConn) exchangeSDP() error {
 	select {
 	case offer := <-c.offerChannel:
-		// Display for copy-paste, when no broker available.
+		// Display for copy-paste when no broker available.
 		if nil == c.broker {
 			log.Printf("Please Copy & Paste the following to the peer:")
 			log.Printf("----------------")
-			log.Printf("\n" + offer.Serialize() + "\n")
+			log.Printf("\n\n" + offer.Serialize() + "\n\n")
 			log.Printf("----------------")
 		}
 	case err := <-c.errorChannel: