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

4 files changed, 213 insertions, 278 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)
 	}
diff --git a/shapeshifter-dispatcher/shapeshifter-dispatcher.go b/shapeshifter-dispatcher/shapeshifter-dispatcher.go
index 1e57c7a..ef03484 100644
--- a/shapeshifter-dispatcher/shapeshifter-dispatcher.go
+++ b/shapeshifter-dispatcher/shapeshifter-dispatcher.go
@@ -49,8 +49,9 @@ import (
 	//	"github.com/OperatorFoundation/shapeshifter-dispatcher/modes/pt_socks5"
 	//	"github.com/OperatorFoundation/shapeshifter-dispatcher/modes/stun_udp"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/modes/transparent_tcp"
-	//	"github.com/OperatorFoundation/shapeshifter-dispatcher/modes/transparent_udp"
+	"github.com/OperatorFoundation/shapeshifter-dispatcher/modes/transparent_udp"
 
+	"github.com/OperatorFoundation/obfs4/modes/stun_udp"
 	_ "github.com/OperatorFoundation/obfs4/proxy_dialers/proxy_http"
 	_ "github.com/OperatorFoundation/obfs4/proxy_dialers/proxy_socks4"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/transports"
@@ -155,26 +156,30 @@ func main() {
 		// Do the transparent proxy configuration.
 		log.Infof("%s - initializing transparent proxy", execName)
 		if *udp {
-			// log.Infof("%s - initializing UDP transparent proxy", execName)
-			// if isClient {
-			// 	log.Infof("%s - initializing client transport listeners", execName)
-			// 	if *target == "" {
-			// 		log.Errorf("%s - transparent mode requires a target", execName)
-			// 	} else {
-			// 		fmt.Println("transparent udp client")
-			// 		factories, ptClientProxy := getClientFactories(ptversion, transportsList, proxy)
-			// 		launched = transparent_udp.ClientSetup(termMon, *target, factories, ptClientProxy)
-			// 	}
-			// } else {
-			// 	log.Infof("%s - initializing server transport listeners", execName)
-			// 	if *bindAddr == "" {
-			// 		fmt.Println("%s - transparent mode requires a bindaddr", execName)
-			// 	} else {
-			// 		fmt.Println("transparent udp server")
-			// 		launched = transparent_udp.ServerSetup(termMon, *bindAddr, *target)
-			// 		fmt.Println("launched", launched, ptListeners)
-			// 	}
-			// }
+			log.Infof("%s - initializing UDP transparent proxy", execName)
+			if isClient {
+				log.Infof("%s - initializing client transport listeners", execName)
+				if *target == "" {
+					log.Errorf("%s - transparent mode requires a target", execName)
+				} else {
+					fmt.Println("transparent udp client")
+					factories, ptClientProxy := getClientFactories(ptversion, transportsList, proxy)
+					launched = transparent_udp.ClientSetup(termMon, *target, factories, ptClientProxy)
+				}
+			} else {
+				log.Infof("%s - initializing server transport listeners", execName)
+				if *bindAddr == "" {
+					fmt.Println("%s - transparent mode requires a bindaddr", execName)
+				} else {
+					fmt.Println("transparent udp server")
+					// launched = transparent_udp.ServerSetup(termMon, *bindAddr, *target)
+					// fmt.Println("launched", launched, ptListeners)
+
+					factories, ptServerInfo := getServerFactories(ptversion, bindAddr, options, transportsList, orport)
+					launched, serverListeners = transparent_udp.ServerSetup(termMon, *bindAddr, factories, ptServerInfo)
+					fmt.Println("launched", launched, serverListeners)
+				}
+			}
 		} else {
 			log.Infof("%s - initializing TCP transparent proxy", execName)
 			if isClient {
@@ -197,39 +202,42 @@ func main() {
 			}
 		}
 	} else {
-		// if *udp {
-		// 	log.Infof("%s - initializing STUN UDP proxy", execName)
-		// 	if isClient {
-		// 		log.Infof("%s - initializing client transport listeners", execName)
-		// 		if *target == "" {
-		// 			log.Errorf("%s - STUN mode requires a target", execName)
-		// 		} else {
-		// 			fmt.Println("STUN udp client")
-		// 			factories, ptClientProxy := getClientFactories(ptversion, transportsList, proxy)
-		// 			launched = stun_udp.ClientSetup(termMon, *target, factories, ptClientProxy)
-		// 		}
-		// 	} else {
-		// 		log.Infof("%s - initializing server transport listeners", execName)
-		// 		if *bindAddr == "" {
-		// 			fmt.Println("%s - STUN mode requires a bindaddr", execName)
-		// 		} else {
-		// 			fmt.Println("STUN udp server")
-		// 			launched = stun_udp.ServerSetup(termMon, *bindAddr, *target)
-		// 			fmt.Println("launched", launched, ptListeners)
-		// 		}
-		// 	}
-		// } else {
-		// 	// Do the managed pluggable transport protocol configuration.
-		// 	log.Infof("%s - initializing PT 1.0 proxy", execName)
-		// 	if isClient {
-		// 		log.Infof("%s - initializing client transport listeners", execName)
-		// 		factories, ptClientProxy := getClientFactories(ptversion, transportsList, proxy)
-		// 		launched, ptListeners = pt_socks5.ClientSetup(termMon, factories, ptClientProxy)
-		// 	} else {
-		// 		log.Infof("%s - initializing server transport listeners", execName)
-		// 		launched, ptListeners = pt_socks5.ServerSetup(termMon)
-		// 	}
-		// }
+		if *udp {
+			log.Infof("%s - initializing STUN UDP proxy", execName)
+			if isClient {
+				log.Infof("%s - initializing client transport listeners", execName)
+				if *target == "" {
+					log.Errorf("%s - STUN mode requires a target", execName)
+				} else {
+					fmt.Println("STUN udp client")
+					factories, ptClientProxy := getClientFactories(ptversion, transportsList, proxy)
+					launched = stun_udp.ClientSetup(termMon, *target, factories, ptClientProxy)
+				}
+			} else {
+				log.Infof("%s - initializing server transport listeners", execName)
+				if *bindAddr == "" {
+					fmt.Println("%s - STUN mode requires a bindaddr", execName)
+				} else {
+					fmt.Println("STUN udp server")
+					factories, ptServerInfo := getServerFactories(ptversion, bindAddr, options, transportsList, orport)
+					launched, serverListeners = stun_udp.ServerSetup(termMon, *bindAddr, factories, ptServerInfo)
+					fmt.Println("launched", launched, serverListeners)
+				}
+			}
+		} else {
+			// Do the managed pluggable transport protocol configuration.
+			log.Infof("%s - initializing PT 1.0 proxy", execName)
+			if isClient {
+				log.Infof("%s - initializing client transport listeners", execName)
+				factories, ptClientProxy := getClientFactories(ptversion, transportsList, proxy)
+				launched, clientListeners = transparent_tcp.ClientSetup(termMon, *target, factories, ptClientProxy)
+			} else {
+				log.Infof("%s - initializing server transport listeners", execName)
+				factories, ptServerInfo := getServerFactories(ptversion, bindAddr, options, transportsList, orport)
+				launched, serverListeners = transparent_tcp.ServerSetup(termMon, *bindAddr, factories, ptServerInfo)
+				fmt.Println("launched", launched, serverListeners)
+			}
+		}
 	}
 
 	if !launched {