Ported remaining proxy modes (UDP, STUN, SOCKS) to PT 2.0 Go API

3 files changed, 151 insertions, 224 deletions

diff --git a/modes/pt_socks5/pt_socks5.go b/modes/pt_socks5/pt_socks5.go
index 736f5e5..b6bda12 100644
--- a/modes/pt_socks5/pt_socks5.go
+++ b/modes/pt_socks5/pt_socks5.go
@@ -32,18 +32,14 @@ package pt_socks5
 import (
 	"fmt"
 	"io"
-	golog "log"
 	"net"
 	"net/url"
 	"sync"
 
-	"golang.org/x/net/proxy"
-
-	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/log"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/socks5"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/termmon"
-	"github.com/OperatorFoundation/shapeshifter-dispatcher/transports"
+	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/base"
 )
 
@@ -53,7 +49,7 @@ const (
 
 var stateDir string
 
-func ClientSetup(termMon *termmon.TermMonitor, ptClientProxy *url.URL, factories map[string]base.ClientFactory) (launched bool, listeners []net.Listener) {
+func ClientSetup(termMon *termmon.TermMonitor, target string, ptClientProxy *url.URL, factories map[string]base.ClientFactory) (launched bool, listeners []net.Listener) {
 	// Launch each of the client listeners.
 	for name, f := range factories {
 		ln, err := net.Listen("tcp", socksAddr)
@@ -62,7 +58,7 @@ func ClientSetup(termMon *termmon.TermMonitor, ptClientProxy *url.URL, factories
 			continue
 		}
 
-		go clientAcceptLoop(termMon, f, ln, ptClientProxy)
+		go clientAcceptLoop(target, termMon, name, f, ln, ptClientProxy)
 		pt.Cmethod(name, socks5.Version(), ln.Addr())
 
 		log.Infof("%s - registered listener: %s", name, ln.Addr())
@@ -75,7 +71,7 @@ func ClientSetup(termMon *termmon.TermMonitor, ptClientProxy *url.URL, factories
 	return
 }
 
-func clientAcceptLoop(termMon *termmon.TermMonitor, f base.ClientFactory, ln net.Listener, proxyURI *url.URL) error {
+func clientAcceptLoop(target string, termMon *termmon.TermMonitor, name string, f base.ClientFactory, ln net.Listener, proxyURI *url.URL) error {
 	defer ln.Close()
 	for {
 		conn, err := ln.Accept()
@@ -85,17 +81,15 @@ func clientAcceptLoop(termMon *termmon.TermMonitor, f base.ClientFactory, ln net
 			}
 			continue
 		}
-		go clientHandler(termMon, f, conn, proxyURI)
+		go clientHandler(target, termMon, name, f, conn, proxyURI)
 	}
 }
 
-func clientHandler(termMon *termmon.TermMonitor, f base.ClientFactory, conn net.Conn, proxyURI *url.URL) {
+func clientHandler(target string, termMon *termmon.TermMonitor, name string, f base.ClientFactory, conn net.Conn, proxyURI *url.URL) {
 	defer conn.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
-	name := f.Transport().Name()
-
 	// Read the client's SOCKS handshake.
 	socksReq, err := socks5.Handshake(conn)
 	if err != nil {
@@ -105,30 +99,30 @@ func clientHandler(termMon *termmon.TermMonitor, f base.ClientFactory, conn net.
 	addrStr := log.ElideAddr(socksReq.Target)
 
 	// Deal with arguments.
-	args, err := f.ParseArgs(&socksReq.Args)
-	if err != nil {
-		log.Errorf("%s(%s) - invalid arguments: %s", name, addrStr, err)
-		socksReq.Reply(socks5.ReplyGeneralFailure)
-		return
-	}
+	// args, err := f.ParseArgs(&socksReq.Args)
+	// if err != nil {
+	// 	log.Errorf("%s(%s) - invalid arguments: %s", name, addrStr, err)
+	// 	socksReq.Reply(socks5.ReplyGeneralFailure)
+	// 	return
+	// }
 
 	// Obtain the proxy dialer if any, and create the outgoing TCP connection.
-	dialFn := proxy.Direct.Dial
-	if proxyURI != nil {
-		dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
-		if err != nil {
-			// This should basically never happen, since config protocol
-			// verifies this.
-			log.Errorf("%s(%s) - failed to obtain proxy dialer: %s", name, addrStr, log.ElideError(err))
-			socksReq.Reply(socks5.ReplyGeneralFailure)
-			return
-		}
-		dialFn = dialer.Dial
-	}
-
-	fmt.Println("Got dialer", dialFn, proxyURI, proxy.Direct)
-
-	remote, err := f.Dial("tcp", socksReq.Target, dialFn, args)
+	// dialFn := proxy.Direct.Dial
+	// if proxyURI != nil {
+	// 	dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
+	// 	if err != nil {
+	// 		// This should basically never happen, since config protocol
+	// 		// verifies this.
+	// 		log.Errorf("%s(%s) - failed to obtain proxy dialer: %s", name, addrStr, log.ElideError(err))
+	// 		socksReq.Reply(socks5.ReplyGeneralFailure)
+	// 		return
+	// 	}
+	// 	dialFn = dialer.Dial
+	// }
+	//
+	// fmt.Println("Got dialer", dialFn, proxyURI, proxy.Direct)
+
+	remote := f(socksReq.Target)
 	if err != nil {
 		log.Errorf("%s(%s) - outgoing connection failed: %s", name, addrStr, log.ElideError(err))
 		socksReq.Reply(socks5.ErrorToReplyCode(err))
@@ -150,42 +144,28 @@ func clientHandler(termMon *termmon.TermMonitor, f base.ClientFactory, conn net.
 	return
 }
 
-func ServerSetup(termMon *termmon.TermMonitor) (launched bool, listeners []net.Listener) {
-	ptServerInfo, err := pt.ServerSetup(transports.Transports())
-	if err != nil {
-		golog.Fatal(err)
-	}
-
+func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, factories map[string]base.ServerFactory, ptServerInfo pt.ServerInfo) (launched bool, listeners []base.TransportListener) {
 	for _, bindaddr := range ptServerInfo.Bindaddrs {
 		name := bindaddr.MethodName
-		t := transports.Get(name)
-		if t == nil {
-			pt.SmethodError(name, "no such transport is supported")
+		f := factories[name]
+		if f == nil {
+			fmt.Println(name, "no such transport is supported")
 			continue
 		}
 
-		f, err := t.ServerFactory(stateDir, &bindaddr.Options)
-		if err != nil {
-			pt.SmethodError(name, err.Error())
-			continue
-		}
+		transportLn := f(bindaddr.Addr.String())
 
-		ln, err := net.ListenTCP("tcp", bindaddr.Addr)
-		if err != nil {
-			pt.SmethodError(name, err.Error())
-			continue
-		}
+		go serverAcceptLoop(termMon, name, transportLn, &ptServerInfo)
 
-		go serverAcceptLoop(termMon, f, ln, &ptServerInfo)
-		if args := f.Args(); args != nil {
-			pt.SmethodArgs(name, ln.Addr(), *args)
-		} else {
-			pt.SmethodArgs(name, ln.Addr(), nil)
-		}
+		// if args := f.Args(); args != nil {
+		// 	pt.SmethodArgs(name, ln.Addr(), *args)
+		// } else {
+		// 	pt.SmethodArgs(name, ln.Addr(), nil)
+		// }
 
-		log.Infof("%s - registered listener: %s", name, log.ElideAddr(ln.Addr().String()))
+		log.Infof("%s - registered listener: %s", name, log.ElideAddr(bindaddr.Addr.String()))
 
-		listeners = append(listeners, ln)
+		listeners = append(listeners, transportLn)
 		launched = true
 	}
 	pt.SmethodsDone()
@@ -193,38 +173,30 @@ func ServerSetup(termMon *termmon.TermMonitor) (launched bool, listeners []net.L
 	return
 }
 
-func serverAcceptLoop(termMon *termmon.TermMonitor, f base.ServerFactory, ln net.Listener, info *pt.ServerInfo) error {
+func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln base.TransportListener, info *pt.ServerInfo) error {
 	defer ln.Close()
 	for {
-		conn, err := ln.Accept()
+		conn, err := ln.TransportAccept()
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
 				return err
 			}
 			continue
 		}
-		go serverHandler(termMon, f, conn, info)
+		go serverHandler(termMon, name, conn, info)
 	}
 }
 
-func serverHandler(termMon *termmon.TermMonitor, f base.ServerFactory, conn net.Conn, info *pt.ServerInfo) {
-	defer conn.Close()
+func serverHandler(termMon *termmon.TermMonitor, name string, remote base.TransportConn, info *pt.ServerInfo) {
+	defer remote.NetworkConn().Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
-	name := f.Transport().Name()
-	addrStr := log.ElideAddr(conn.RemoteAddr().String())
+	addrStr := log.ElideAddr(remote.NetworkConn().RemoteAddr().String())
 	log.Infof("%s(%s) - new connection", name, addrStr)
 
-	// Instantiate the server transport method and handshake.
-	remote, err := f.WrapConn(conn)
-	if err != nil {
-		log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
-		return
-	}
-
 	// Connect to the orport.
-	orConn, err := pt.DialOr(info, conn.RemoteAddr().String(), name)
+	orConn, err := pt.DialOr(info, remote.NetworkConn().RemoteAddr().String(), name)
 	if err != nil {
 		log.Errorf("%s(%s) - failed to connect to ORPort: %s", name, addrStr, log.ElideError(err))
 		return
diff --git a/modes/stun_udp/stun_udp.go b/modes/stun_udp/stun_udp.go
index 12a4c39..d1cff6f 100644
--- a/modes/stun_udp/stun_udp.go
+++ b/modes/stun_udp/stun_udp.go
@@ -38,16 +38,13 @@ import (
 	"strconv"
 	"strings"
 
-	"golang.org/x/net/proxy"
-
 	common "github.com/willscott/goturn/common"
 
 	"github.com/willscott/goturn"
 
-	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/log"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/termmon"
-	"github.com/OperatorFoundation/shapeshifter-dispatcher/transports"
+	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/base"
 )
 
@@ -58,7 +55,7 @@ const (
 var stateDir string
 
 type ConnState struct {
-	Conn    *net.Conn
+	Conn    net.Conn
 	Waiting bool
 }
 
@@ -83,7 +80,7 @@ func ClientSetup(termMon *termmon.TermMonitor, target string, ptClientProxy *url
 			continue
 		}
 
-		go clientHandler(target, termMon, f, ln, ptClientProxy)
+		go clientHandler(target, termMon, name, f, ln, ptClientProxy)
 
 		log.Infof("%s - registered listener: %s", name, ln)
 	}
@@ -91,7 +88,7 @@ func ClientSetup(termMon *termmon.TermMonitor, target string, ptClientProxy *url
 	return true
 }
 
-func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFactory, conn *net.UDPConn, proxyURI *url.URL) {
+func clientHandler(target string, termMon *termmon.TermMonitor, name string, f base.ClientFactory, conn *net.UDPConn, proxyURI *url.URL) {
 	defer conn.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
@@ -100,8 +97,6 @@ func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFac
 
 	tracker := make(ConnTracker)
 
-	name := f.Transport().Name()
-
 	fmt.Println("Transport is", name)
 
 	buf := make([]byte, 1024)
@@ -128,8 +123,7 @@ func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFac
 				// There is an open transport connection.
 				// Send the packet through the transport.
 				fmt.Println("recv: write")
-				fmt.Println("writing...")
-				(*state.Conn).Write(buf)
+				state.Conn.Write(buf)
 			}
 		} else {
 			// There is not an open transport connection and a connection attempt is not in progress.
@@ -156,77 +150,69 @@ func openConnection(tracker *ConnTracker, addr string, target string, termMon *t
 
 func dialConn(tracker *ConnTracker, addr string, target string, f base.ClientFactory, proxyURI *url.URL) {
 	// Obtain the proxy dialer if any, and create the outgoing TCP connection.
-	dialFn := proxy.Direct.Dial
-	if proxyURI != nil {
-		dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
-		if err != nil {
-			// This should basically never happen, since config protocol
-			// verifies this.
-			fmt.Println("failed to obtain dialer", proxyURI, proxy.Direct)
-			log.Errorf("(%s) - failed to obtain proxy dialer: %s", target, log.ElideError(err))
-			return
-		}
-		dialFn = dialer.Dial
-	}
+	// dialFn := proxy.Direct.Dial
+	// if proxyURI != nil {
+	// 	dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
+	// 	if err != nil {
+	// 		// This should basically never happen, since config protocol
+	// 		// verifies this.
+	// 		fmt.Println("failed to obtain dialer", proxyURI, proxy.Direct)
+	// 		log.Errorf("(%s) - failed to obtain proxy dialer: %s", target, log.ElideError(err))
+	// 		return
+	// 	}
+	// 	dialFn = dialer.Dial
+	// }
 
 	fmt.Println("Dialing....")
 
 	// Deal with arguments.
-	args, err := f.ParseArgs(&pt.Args{})
-	if err != nil {
-		fmt.Println("Invalid arguments")
-		log.Errorf("(%s) - invalid arguments: %s", target, err)
-		delete(*tracker, addr)
-		return
-	}
+	// args, err := f.ParseArgs(&pt.Args{})
+	// if err != nil {
+	// 	fmt.Println("Invalid arguments")
+	// 	log.Errorf("(%s) - invalid arguments: %s", target, err)
+	// 	delete(*tracker, addr)
+	// 	return
+	// }
 
 	fmt.Println("Dialing ", target)
-	remote, err := f.Dial("tcp", target, dialFn, args)
-	if err != nil {
-		fmt.Println("outgoing connection failed", err)
-		log.Errorf("(%s) - outgoing connection failed: %s", target, log.ElideError(err))
-		fmt.Println("Failed")
-		delete(*tracker, addr)
-		return
-	}
+	remote := f(target)
+	// if err != nil {
+	// 	fmt.Println("outgoing connection failed", err)
+	// 	log.Errorf("(%s) - outgoing connection failed: %s", target, log.ElideError(err))
+	// 	fmt.Println("Failed")
+	// 	delete(*tracker, addr)
+	// 	return
+	// }
 
 	fmt.Println("Success")
 
-	(*tracker)[addr] = ConnState{&remote, false}
+	(*tracker)[addr] = ConnState{remote, false}
 }
 
-func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, target string) bool {
+func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, factories map[string]base.ServerFactory, ptServerInfo pt.ServerInfo) (launched bool, listeners []base.TransportListener) {
 	fmt.Println("ServerSetup")
 
-	bindaddrs, _ := getServerBindaddrs(bindaddrString)
-
-	for _, bindaddr := range bindaddrs {
+	// Launch each of the server listeners.
+	for _, bindaddr := range ptServerInfo.Bindaddrs {
 		name := bindaddr.MethodName
 		fmt.Println("bindaddr", bindaddr)
-		t := transports.Get(name)
-		if t == nil {
+		f := factories[name]
+		if f == nil {
 			fmt.Println(name, "no such transport is supported")
 			continue
 		}
 
-		f, err := t.ServerFactory(stateDir, &bindaddr.Options)
-		if err != nil {
-			fmt.Println(name, err.Error())
-			continue
-		}
+		transportLn := f(bindaddr.Addr.String())
 
-		ln, err := net.ListenTCP("tcp", bindaddr.Addr)
-		if err != nil {
-			fmt.Println(name, err.Error())
-			continue
-		}
+		go serverAcceptLoop(termMon, name, transportLn, &ptServerInfo)
 
-		go serverAcceptLoop(termMon, f, ln, target)
+		log.Infof("%s - registered listener: %s", name, log.ElideAddr(bindaddr.Addr.String()))
 
-		log.Infof("%s - registered listener: %s", name, log.ElideAddr(ln.Addr().String()))
+		listeners = append(listeners, transportLn)
+		launched = true
 	}
 
-	return true
+	return
 }
 
 func getServerBindaddrs(serverBindaddr string) ([]pt.Bindaddr, error) {
@@ -295,10 +281,10 @@ func parsePort(portStr string) (int, error) {
 	return int(port), err
 }
 
-func serverAcceptLoop(termMon *termmon.TermMonitor, f base.ServerFactory, ln net.Listener, target string) error {
+func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln base.TransportListener, info *pt.ServerInfo) error {
 	defer ln.Close()
 	for {
-		conn, err := ln.Accept()
+		conn, err := ln.TransportAccept()
 		fmt.Println("accepted")
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
@@ -306,31 +292,22 @@ func serverAcceptLoop(termMon *termmon.TermMonitor, f base.ServerFactory, ln net
 			}
 			continue
 		}
-		go serverHandler(termMon, f, conn, target)
+		go serverHandler(termMon, name, conn, info)
 	}
 }
 
-func serverHandler(termMon *termmon.TermMonitor, f base.ServerFactory, conn net.Conn, target string) {
+func serverHandler(termMon *termmon.TermMonitor, name string, remote base.TransportConn, info *pt.ServerInfo) {
 	var header *common.Message
 
-	defer conn.Close()
+	defer remote.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
-	name := f.Transport().Name()
-	addrStr := log.ElideAddr(conn.RemoteAddr().String())
+	addrStr := log.ElideAddr(remote.RemoteAddr().String())
 	fmt.Println("### handling", name)
 	log.Infof("%s(%s) - new connection", name, addrStr)
 
-	// Instantiate the server transport method and handshake.
-	remote, err := f.WrapConn(conn)
-	if err != nil {
-		fmt.Println("handshake failed", err)
-		log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
-		return
-	}
-
-	serverAddr, err := net.ResolveUDPAddr("udp", target)
+	serverAddr, err := net.ResolveUDPAddr("udp", info.OrAddr.String())
 	if err != nil {
 		golog.Fatal(err)
 	}
diff --git a/modes/transparent_udp/transparent_udp.go b/modes/transparent_udp/transparent_udp.go
index ec12b14..f993b5e 100644
--- a/modes/transparent_udp/transparent_udp.go
+++ b/modes/transparent_udp/transparent_udp.go
@@ -40,12 +40,9 @@ import (
 	"strconv"
 	"strings"
 
-	"golang.org/x/net/proxy"
-
-	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/log"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/termmon"
-	"github.com/OperatorFoundation/shapeshifter-dispatcher/transports"
+	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/base"
 )
 
@@ -56,7 +53,7 @@ const (
 var stateDir string
 
 type ConnState struct {
-	Conn    *net.Conn
+	Conn    net.Conn
 	Waiting bool
 }
 
@@ -81,7 +78,7 @@ func ClientSetup(termMon *termmon.TermMonitor, target string, ptClientProxy *url
 			continue
 		}
 
-		go clientHandler(target, termMon, f, ln, ptClientProxy)
+		go clientHandler(target, termMon, name, f, ln, ptClientProxy)
 
 		log.Infof("%s - registered listener: %s", name, ln)
 	}
@@ -89,7 +86,7 @@ func ClientSetup(termMon *termmon.TermMonitor, target string, ptClientProxy *url
 	return true
 }
 
-func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFactory, conn *net.UDPConn, proxyURI *url.URL) {
+func clientHandler(target string, termMon *termmon.TermMonitor, name string, f base.ClientFactory, conn *net.UDPConn, proxyURI *url.URL) {
 	var length16 uint16
 
 	defer conn.Close()
@@ -100,8 +97,6 @@ func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFac
 
 	tracker := make(ConnTracker)
 
-	name := f.Transport().Name()
-
 	fmt.Println("Transport is", name)
 
 	buf := make([]byte, 1024)
@@ -137,8 +132,8 @@ func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFac
 					fmt.Println("writing...")
 					fmt.Println(length16)
 					fmt.Println(lengthBuf.Bytes())
-					(*state.Conn).Write(lengthBuf.Bytes())
-					(*state.Conn).Write(buf)
+					state.Conn.Write(lengthBuf.Bytes())
+					state.Conn.Write(buf)
 				}
 			}
 		} else {
@@ -166,77 +161,69 @@ func openConnection(tracker *ConnTracker, addr string, target string, termMon *t
 
 func dialConn(tracker *ConnTracker, addr string, target string, f base.ClientFactory, proxyURI *url.URL) {
 	// Obtain the proxy dialer if any, and create the outgoing TCP connection.
-	dialFn := proxy.Direct.Dial
-	if proxyURI != nil {
-		dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
-		if err != nil {
-			// This should basically never happen, since config protocol
-			// verifies this.
-			fmt.Println("failed to obtain dialer", proxyURI, proxy.Direct)
-			log.Errorf("(%s) - failed to obtain proxy dialer: %s", target, log.ElideError(err))
-			return
-		}
-		dialFn = dialer.Dial
-	}
+	// dialFn := proxy.Direct.Dial
+	// if proxyURI != nil {
+	// 	dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
+	// 	if err != nil {
+	// 		// This should basically never happen, since config protocol
+	// 		// verifies this.
+	// 		fmt.Println("failed to obtain dialer", proxyURI, proxy.Direct)
+	// 		log.Errorf("(%s) - failed to obtain proxy dialer: %s", target, log.ElideError(err))
+	// 		return
+	// 	}
+	// 	dialFn = dialer.Dial
+	// }
 
 	fmt.Println("Dialing....")
 
 	// Deal with arguments.
-	args, err := f.ParseArgs(&pt.Args{})
-	if err != nil {
-		fmt.Println("Invalid arguments")
-		log.Errorf("(%s) - invalid arguments: %s", target, err)
-		delete(*tracker, addr)
-		return
-	}
+	// args, err := f.ParseArgs(&pt.Args{})
+	// if err != nil {
+	// 	fmt.Println("Invalid arguments")
+	// 	log.Errorf("(%s) - invalid arguments: %s", target, err)
+	// 	delete(*tracker, addr)
+	// 	return
+	// }
 
 	fmt.Println("Dialing ", target)
-	remote, err := f.Dial("tcp", target, dialFn, args)
-	if err != nil {
-		fmt.Println("outgoing connection failed", err)
-		log.Errorf("(%s) - outgoing connection failed: %s", target, log.ElideError(err))
-		fmt.Println("Failed")
-		delete(*tracker, addr)
-		return
-	}
+	remote := f(target)
+	// if err != nil {
+	// 	fmt.Println("outgoing connection failed", err)
+	// 	log.Errorf("(%s) - outgoing connection failed: %s", target, log.ElideError(err))
+	// 	fmt.Println("Failed")
+	// 	delete(*tracker, addr)
+	// 	return
+	// }
 
 	fmt.Println("Success")
 
-	(*tracker)[addr] = ConnState{&remote, false}
+	(*tracker)[addr] = ConnState{remote, false}
 }
 
-func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, target string) bool {
+func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, factories map[string]base.ServerFactory, ptServerInfo pt.ServerInfo) (launched bool, listeners []base.TransportListener) {
 	fmt.Println("ServerSetup")
 
-	bindaddrs, _ := getServerBindaddrs(bindaddrString)
-
-	for _, bindaddr := range bindaddrs {
+	// Launch each of the server listeners.
+	for _, bindaddr := range ptServerInfo.Bindaddrs {
 		name := bindaddr.MethodName
 		fmt.Println("bindaddr", bindaddr)
-		t := transports.Get(name)
-		if t == nil {
+		f := factories[name]
+		if f == nil {
 			fmt.Println(name, "no such transport is supported")
 			continue
 		}
 
-		f, err := t.ServerFactory(stateDir, &bindaddr.Options)
-		if err != nil {
-			fmt.Println(name, err.Error())
-			continue
-		}
+		transportLn := f(bindaddr.Addr.String())
 
-		ln, err := net.ListenTCP("tcp", bindaddr.Addr)
-		if err != nil {
-			fmt.Println(name, err.Error())
-			continue
-		}
+		go serverAcceptLoop(termMon, name, transportLn, &ptServerInfo)
 
-		go serverAcceptLoop(termMon, f, ln, target)
+		log.Infof("%s - registered listener: %s", name, log.ElideAddr(bindaddr.Addr.String()))
 
-		log.Infof("%s - registered listener: %s", name, log.ElideAddr(ln.Addr().String()))
+		listeners = append(listeners, transportLn)
+		launched = true
 	}
 
-	return true
+	return
 }
 
 func getServerBindaddrs(serverBindaddr string) ([]pt.Bindaddr, error) {
@@ -305,10 +292,10 @@ func parsePort(portStr string) (int, error) {
 	return int(port), err
 }
 
-func serverAcceptLoop(termMon *termmon.TermMonitor, f base.ServerFactory, ln net.Listener, target string) error {
+func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln base.TransportListener, info *pt.ServerInfo) error {
 	defer ln.Close()
 	for {
-		conn, err := ln.Accept()
+		conn, err := ln.TransportAccept()
 		fmt.Println("accepted")
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
@@ -316,31 +303,22 @@ func serverAcceptLoop(termMon *termmon.TermMonitor, f base.ServerFactory, ln net
 			}
 			continue
 		}
-		go serverHandler(termMon, f, conn, target)
+		go serverHandler(termMon, name, conn, info)
 	}
 }
 
-func serverHandler(termMon *termmon.TermMonitor, f base.ServerFactory, conn net.Conn, target string) {
+func serverHandler(termMon *termmon.TermMonitor, name string, remote base.TransportConn, info *pt.ServerInfo) {
 	var length16 uint16
 
-	defer conn.Close()
+	defer remote.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
-	name := f.Transport().Name()
-	addrStr := log.ElideAddr(conn.RemoteAddr().String())
+	addrStr := log.ElideAddr(remote.RemoteAddr().String())
 	fmt.Println("### handling", name)
 	log.Infof("%s(%s) - new connection", name, addrStr)
 
-	// Instantiate the server transport method and handshake.
-	remote, err := f.WrapConn(conn)
-	if err != nil {
-		fmt.Println("handshake failed", err)
-		log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
-		return
-	}
-
-	serverAddr, err := net.ResolveUDPAddr("udp", target)
+	serverAddr, err := net.ResolveUDPAddr("udp", info.OrAddr.String())
 	if err != nil {
 		golog.Fatal(err)
 	}