added dialer to the modes and removed unneccessary code

4 files changed, 298 insertions, 313 deletions

diff --git a/modes/pt_socks5/pt_socks5.go b/modes/pt_socks5/pt_socks5.go
index 90bf7fc..c3a8c45 100644
--- a/modes/pt_socks5/pt_socks5.go
+++ b/modes/pt_socks5/pt_socks5.go
@@ -37,6 +37,7 @@ import (
 	replicant "github.com/OperatorFoundation/shapeshifter-transports/transports/Replicant"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/meeklite"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/shadow"
+	"golang.org/x/net/proxy"
 	"io"
 	"net"
 	"net/url"
@@ -51,8 +52,6 @@ import (
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs4"
 )
 
-var stateDir string
-
 func ClientSetup(termMon *termmon.TermMonitor, socksAddr string, target string, ptClientProxy *url.URL, names []string, options string) (launched bool, listeners []net.Listener) {
 	// Launch each of the client listeners.
 	for _, name := range names {
@@ -74,14 +73,15 @@ func ClientSetup(termMon *termmon.TermMonitor, socksAddr string, target string,
 
 	return
 }
-
-func clientAcceptLoop(target string, termMon *termmon.TermMonitor, name string, ln net.Listener, proxyURI *url.URL, options string) error {
-	defer ln.Close()
+//FIXME figure out how to make this function match the other modes
+func clientAcceptLoop(target string, termMon *termmon.TermMonitor, name string, ln net.Listener, proxyURI *url.URL, options string){
 	for {
 		conn, err := ln.Accept()
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
-				return err
+				log.Errorf("serverAcceptLoop failed")
+				_ = ln.Close()
+				return
 			}
 			continue
 		}
@@ -90,7 +90,6 @@ func clientAcceptLoop(target string, termMon *termmon.TermMonitor, name string,
 }
 
 func clientHandler(target string, termMon *termmon.TermMonitor, name string, conn net.Conn, proxyURI *url.URL, options string) {
-	defer conn.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
@@ -120,36 +119,33 @@ func clientHandler(target string, termMon *termmon.TermMonitor, name string, con
 		return
 	}
 
-	var dialer func() (net.Conn, error)
+	var dialer proxy.Dialer
 
 	// Deal with arguments.
-	transport, _ := pt_extras.ArgsToDialer(socksReq.Target, name, args)
-	dialer = transport.Dial
-	f := dialer
+	transport, _ := pt_extras.ArgsToDialer(socksReq.Target, name, args,dialer)
 
 	// 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, _ := f()
+	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, _ := transport.Dial()
 	if err != nil {
 		log.Errorf("%s(%s) - outgoing connection failed: %s", name, addrStr, log.ElideError(err))
 		socksReq.Reply(socks5.ErrorToReplyCode(err))
 		return
 	}
-	defer remote.Close()
 	err = socksReq.Reply(socks5.ReplySucceeded)
 	if err != nil {
 		log.Errorf("%s(%s) - SOCKS reply failed: %s", name, addrStr, log.ElideError(err))
@@ -165,7 +161,7 @@ func clientHandler(target string, termMon *termmon.TermMonitor, name string, con
 	return
 }
 
-func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerInfo pt.ServerInfo, options string) (launched bool, listeners []net.Listener) {
+func ServerSetup(termMon *termmon.TermMonitor, ptServerInfo pt.ServerInfo, options string) (launched bool, listeners []net.Listener) {
 	for _, bindaddr := range ptServerInfo.Bindaddrs {
 		name := bindaddr.MethodName
 
@@ -183,11 +179,12 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 			transport := obfs2.NewObfs2Transport()
 			listen = transport.Listen
 		case "obfs4":
+			var dialer proxy.Dialer
 			if cert, ok := args["cert"]; ok {
 				if iatModeStr, ok2 := args["iat-mode"]; ok2 {
 					iatMode, err := strconv.Atoi(iatModeStr[0])
 					if err != nil {
-						transport := obfs4.NewObfs4Client(cert[0], iatMode)
+						transport := obfs4.NewObfs4Client(cert[0], iatMode, dialer)
 						listen = transport.Listen
 					} else {
 						log.Errorf("obfs4 transport bad iat-mode value: %s", iatModeStr)
@@ -271,13 +268,12 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 	return
 }
 
-func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo) error {
-	defer ln.Close()
+func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo){
 	for {
 		conn, err := ln.Accept()
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
-				return err
+				return
 			}
 			continue
 		}
@@ -286,7 +282,6 @@ func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener
 }
 
 func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, info *pt.ServerInfo) {
-	defer remote.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
@@ -299,7 +294,6 @@ func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, i
 		log.Errorf("%s(%s) - failed to connect to ORPort: %s", name, addrStr, log.ElideError(err))
 		return
 	}
-	defer orConn.Close()
 
 	if err = copyLoop(orConn, remote); err != nil {
 		log.Warnf("%s(%s) - closed connection: %s", name, addrStr, log.ElideError(err))
@@ -319,15 +313,11 @@ func copyLoop(a net.Conn, b net.Conn) error {
 
 	go func() {
 		defer wg.Done()
-		defer b.Close()
-		defer a.Close()
 		_, err := io.Copy(b, a)
 		errChan <- err
 	}()
 	go func() {
 		defer wg.Done()
-		defer a.Close()
-		defer b.Close()
 		_, err := io.Copy(a, b)
 		errChan <- err
 	}()
diff --git a/modes/stun_udp/stun_udp.go b/modes/stun_udp/stun_udp.go
index cba7132..4abe433 100644
--- a/modes/stun_udp/stun_udp.go
+++ b/modes/stun_udp/stun_udp.go
@@ -37,14 +37,12 @@ import (
 	replicant "github.com/OperatorFoundation/shapeshifter-transports/transports/Replicant"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/meeklite"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/shadow"
+	common "github.com/willscott/goturn/common"
+	"golang.org/x/net/proxy"
 	"io"
 	golog "log"
 	"net"
 	"net/url"
-	"strconv"
-	"strings"
-
-	common "github.com/willscott/goturn/common"
 
 	"github.com/willscott/goturn"
 
@@ -55,8 +53,6 @@ import (
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs4"
 )
 
-var stateDir string
-
 type ConnState struct {
 	Conn    net.Conn
 	Waiting bool
@@ -92,9 +88,11 @@ func ClientSetup(termMon *termmon.TermMonitor, socksAddr string, target string,
 }
 
 func clientHandler(target string, termMon *termmon.TermMonitor, name string, options string, conn *net.UDPConn, proxyURI *url.URL) {
-	defer conn.Close()
+
 	termMon.OnHandlerStart()
-	defer termMon.OnHandlerFinish()
+	//defers are never called due to infinite loop
+	//defer termMon.OnHandlerFinish()
+	//defer  conn.Close()
 
 	fmt.Println("@@@ handling...")
 
@@ -126,7 +124,8 @@ func clientHandler(target string, termMon *termmon.TermMonitor, name string, opt
 				// There is an open transport connection.
 				// Send the packet through the transport.
 				fmt.Println("recv: write")
-				state.Conn.Write(buf)
+				//ignoring failed writes because packets can be dropped
+				_, _ = state.Conn.Write(buf)
 			}
 		} else {
 			// There is not an open transport connection and a connection attempt is not in progress.
@@ -152,19 +151,21 @@ func openConnection(tracker *ConnTracker, addr string, target string, termMon *t
 }
 
 func dialConn(tracker *ConnTracker, addr string, target string, name string, options string, 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
-	// }
+	//Obtain the proxy dialer if any, and create the outgoing TCP connection.
+	var dialer proxy.Dialer
+	dialer = proxy.Direct
+	if proxyURI != nil {
+		var err error
+		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
+		}
+
+	}
 
 	fmt.Println("Dialing....")
 
@@ -175,7 +176,7 @@ func dialConn(tracker *ConnTracker, addr string, target string, name string, opt
 	}
 
 	// Deal with arguments.
-	transport, _ := pt_extras.ArgsToDialer(target, name, args)
+	transport, _ := pt_extras.ArgsToDialer(target, name, args, dialer)
 
 	fmt.Println("Dialing ", target)
 	remote, _ := transport.Dial()
@@ -192,7 +193,7 @@ func dialConn(tracker *ConnTracker, addr string, target string, name string, opt
 	(*tracker)[addr] = ConnState{remote, false}
 }
 
-func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerInfo pt.ServerInfo, options string) (launched bool, listeners []net.Listener) {
+func ServerSetup(termMon *termmon.TermMonitor, ptServerInfo pt.ServerInfo, options string, stateDir string) (launched bool, listeners []net.Listener) {
 	fmt.Println("ServerSetup")
 
 	// Launch each of the server listeners.
@@ -212,26 +213,10 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 		switch name {
 		case "obfs2":
 			transport := obfs2.NewObfs2Transport()
-			listen=transport.Listen
+			listen = transport.Listen
 		case "obfs4":
-			if cert, ok := args["cert"]; ok {
-				if iatModeStr, ok2 := args["iat-mode"]; ok2 {
-					iatMode, err := strconv.Atoi(iatModeStr[0])
-					if err != nil {
-						transport := obfs4.NewObfs4Client(cert[0], iatMode)
-						listen=transport.Listen
-					} else {
-						log.Errorf("obfs4 transport bad iat-mode value: %s", iatModeStr)
-						return
-					}
-				} else {
-					log.Errorf("obfs4 transport missing cert argument: %s", args)
-					return
-				}
-			} else {
-				log.Errorf("obfs4 transport missing cert argument: %s", args)
-				return
-			}
+			transport := obfs4.NewObfs4Server(stateDir)
+			listen = transport.Listen
 		case "meeklite":
 			if Url, ok := args["Url"]; ok {
 				if Front, ok2 := args["Front"]; ok2 {
@@ -256,25 +241,25 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 			}
 		case "Dust":
 			if idPath, ok := args["idPath"]; ok {
-					transport := Dust.NewDustServer(idPath[0])
-					listen = transport.Listen
+				transport := Dust.NewDustServer(idPath[0])
+				listen = transport.Listen
 			} else {
 				log.Errorf("Dust transport missing idPath argument: %s", args)
 				return
 			}
-			case "shadow":
-				if password, ok := args["password"]; ok {
-					if cipher, ok2 := args["cipherName"]; ok2 {
-			transport := shadow.NewShadowClient(password[0], cipher[0])
-			listen = transport.Listen
+		case "shadow":
+			if password, ok := args["password"]; ok {
+				if cipher, ok2 := args["cipherName"]; ok2 {
+					transport := shadow.NewShadowClient(password[0], cipher[0])
+					listen = transport.Listen
+				} else {
+					log.Errorf("shadow transport missing cipher argument: %s", args)
+					return
+				}
 			} else {
-				log.Errorf("shadow transport missing cipher argument: %s", args)
+				log.Errorf("shadow transport missing password argument: %s", args)
 				return
 			}
-		} else {
-			log.Errorf("shadow transport missing password argument: %s", args)
-			return
-		}
 
 		default:
 			log.Errorf("Unknown transport: %s", name)
@@ -294,80 +279,81 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 	return
 }
 
-func getServerBindaddrs(serverBindaddr string) ([]pt.Bindaddr, error) {
-	var result []pt.Bindaddr
-
-	for _, spec := range strings.Split(serverBindaddr, ",") {
-		var bindaddr pt.Bindaddr
-
-		parts := strings.SplitN(spec, "-", 2)
-		if len(parts) != 2 {
-			fmt.Println("TOR_PT_SERVER_BINDADDR: doesn't contain \"-\"", spec)
-			return nil, nil
-		}
-		bindaddr.MethodName = parts[0]
-		addr, err := resolveAddr(parts[1])
-		if err != nil {
-			fmt.Println("TOR_PT_SERVER_BINDADDR: ", spec, err.Error())
-			return nil, nil
-		}
-		bindaddr.Addr = addr
-		//		bindaddr.Options = optionsMap[bindaddr.MethodName]
-		result = append(result, bindaddr)
-	}
-
-	return result, nil
-}
+//func getServerBindaddrs(serverBindaddr string) ([]pt.Bindaddr, error) {
+//	var result []pt.Bindaddr
+//
+//	for _, spec := range strings.Split(serverBindaddr, ",") {
+//		var bindaddr pt.Bindaddr
+//
+//		parts := strings.SplitN(spec, "-", 2)
+//		if len(parts) != 2 {
+//			fmt.Println("TOR_PT_SERVER_BINDADDR: doesn't contain \"-\"", spec)
+//			return nil, nil
+//		}
+//		bindaddr.MethodName = parts[0]
+//		addr, err := resolveAddr(parts[1])
+//		if err != nil {
+//			fmt.Println("TOR_PT_SERVER_BINDADDR: ", spec, err.Error())
+//			return nil, nil
+//		}
+//		bindaddr.Addr = addr
+//		//		bindaddr.Options = optionsMap[bindaddr.MethodName]
+//		result = append(result, bindaddr)
+//	}
+//
+//	return result, nil
+//}
 
 // Resolve an address string into a net.TCPAddr. We are a bit more strict than
 // net.ResolveTCPAddr; we don't allow an empty host or port, and the host part
 // must be a literal IP address.
-func resolveAddr(addrStr string) (*net.TCPAddr, error) {
-	ipStr, portStr, err := net.SplitHostPort(addrStr)
-	if err != nil {
-		// Before the fixing of bug #7011, tor doesn't put brackets around IPv6
-		// addresses. Split after the last colon, assuming it is a port
-		// separator, and try adding the brackets.
-		parts := strings.Split(addrStr, ":")
-		if len(parts) <= 2 {
-			return nil, err
-		}
-		addrStr := "[" + strings.Join(parts[:len(parts)-1], ":") + "]:" + parts[len(parts)-1]
-		ipStr, portStr, err = net.SplitHostPort(addrStr)
-	}
-	if err != nil {
-		return nil, err
-	}
-	if ipStr == "" {
-		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a host part", addrStr))
-	}
-	if portStr == "" {
-		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a port part", addrStr))
-	}
-	ip := net.ParseIP(ipStr)
-	if ip == nil {
-		return nil, net.InvalidAddrError(fmt.Sprintf("not an IP string: %q", ipStr))
-	}
-	port, err := parsePort(portStr)
-	if err != nil {
-		return nil, err
-	}
-	return &net.TCPAddr{IP: ip, Port: port}, nil
-}
-
-func parsePort(portStr string) (int, error) {
-	port, err := strconv.ParseUint(portStr, 10, 16)
-	return int(port), err
-}
-
-func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo) error {
-	defer ln.Close()
+////func resolveAddr(addrStr string) (*net.TCPAddr, error) {
+////	ipStr, portStr, err := net.SplitHostPort(addrStr)
+////	if err != nil {
+////		// Before the fixing of bug #7011, tor doesn't put brackets around IPv6
+////		// addresses. Split after the last colon, assuming it is a port
+////		// separator, and try adding the brackets.
+////		parts := strings.Split(addrStr, ":")
+////		if len(parts) <= 2 {
+////			return nil, err
+////		}
+////		addrStr := "[" + strings.Join(parts[:len(parts)-1], ":") + "]:" + parts[len(parts)-1]
+////		ipStr, portStr, err = net.SplitHostPort(addrStr)
+////	}
+////	if err != nil {
+////		return nil, err
+////	}
+////	if ipStr == "" {
+////		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a host part", addrStr))
+////	}
+////	if portStr == "" {
+////		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a port part", addrStr))
+////	}
+////	ip := net.ParseIP(ipStr)
+////	if ip == nil {
+////		return nil, net.InvalidAddrError(fmt.Sprintf("not an IP string: %q", ipStr))
+////	}
+////	port, err := parsePort(portStr)
+////	if err != nil {
+////		return nil, err
+////	}
+////	return &net.TCPAddr{IP: ip, Port: port}, nil
+////}
+//
+//func parsePort(portStr string) (int, error) {
+//	port, err := strconv.ParseUint(portStr, 10, 16)
+//	return int(port), err
+//}
+
+func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo){
 	for {
 		conn, err := ln.Accept()
 		fmt.Println("accepted")
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
-				return err
+				log.Errorf("serverAcceptLoop failed")
+				_ = ln.Close()
+				return
 			}
 			continue
 		}
@@ -378,9 +364,7 @@ func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener
 func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, info *pt.ServerInfo) {
 	var header *common.Message
 
-	defer remote.Close()
 	termMon.OnHandlerStart()
-	defer termMon.OnHandlerFinish()
 
 	addrStr := log.ElideAddr(remote.RemoteAddr().String())
 	fmt.Println("### handling", name)
@@ -388,16 +372,22 @@ func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, i
 
 	serverAddr, err := net.ResolveUDPAddr("udp", info.OrAddr.String())
 	if err != nil {
+		_ = remote.Close()
+		termMon.OnHandlerFinish()
 		golog.Fatal(err)
 	}
 
 	localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
 	if err != nil {
+		_ = remote.Close()
+		termMon.OnHandlerFinish()
 		golog.Fatal(err)
 	}
 
 	dest, err := net.DialUDP("udp", localAddr, serverAddr)
 	if err != nil {
+		_ = remote.Close()
+		termMon.OnHandlerFinish()
 		golog.Fatal(err)
 	}
 
@@ -435,6 +425,9 @@ func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, i
 
 		writeBuffer := append(headerBuffer, readBuffer...)
 
-		dest.Write(writeBuffer)
+		_, _ = dest.Write(writeBuffer)
 	}
-}
\ No newline at end of file
+
+	_ = remote.Close()
+	termMon.OnHandlerFinish()
+}
diff --git a/modes/transparent_tcp/transparent_tcp.go b/modes/transparent_tcp/transparent_tcp.go
index 8fc2f08..0bdfe75 100644
--- a/modes/transparent_tcp/transparent_tcp.go
+++ b/modes/transparent_tcp/transparent_tcp.go
@@ -30,16 +30,16 @@
 package transparent_tcp
 
 import (
+	"fmt"
 	options2 "github.com/OperatorFoundation/shapeshifter-dispatcher/common"
-
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/pt_extras"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/Dust"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/meeklite"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs2"
+	"golang.org/x/net/proxy"
 	"io"
 	"net"
 	"net/url"
-	"strings"
 	"sync"
 
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/log"
@@ -50,8 +50,6 @@ import (
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/shadow"
 )
 
-var stateDir string
-
 func ClientSetup(termMon *termmon.TermMonitor, socksAddr string, target string, ptClientProxy *url.URL, names []string, options string) (launched bool, listeners []net.Listener) {
 	// Launch each of the client listeners.
 	for _, name := range names {
@@ -73,7 +71,6 @@ func ClientSetup(termMon *termmon.TermMonitor, socksAddr string, target string,
 }
 
 func clientAcceptLoop(target string, termMon *termmon.TermMonitor, name string, options string, ln net.Listener, proxyURI *url.URL) {
-	defer ln.Close()
 	for {
 		conn, err := ln.Accept()
 		if err != nil {
@@ -89,11 +86,23 @@ func clientAcceptLoop(target string, termMon *termmon.TermMonitor, name string,
 }
 
 func clientHandler(target string, termMon *termmon.TermMonitor, name string, options string, conn net.Conn, proxyURI *url.URL) {
-	defer conn.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
-	var dialer func() (net.Conn, error)
+	var dialer proxy.Dialer
+	dialer = proxy.Direct
+	if proxyURI != nil {
+		var err error
+		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
+		}
+
+	}
 //this is where the refactoring begins
 	args, argsErr := options2.ParseOptions(options)
 	if argsErr != nil {
@@ -103,39 +112,10 @@ func clientHandler(target string, termMon *termmon.TermMonitor, name string, opt
 
 	// Deal with arguments.
 
-	transport, dialerErr := pt_extras.ArgsToDialer(target, name, args)
-	if dialerErr != nil {
-		log.Errorf("Error parsing transport-specific options: %s (%s)", args, dialerErr)
-		return
-	}
-	dialer = transport.Dial
-	f := dialer
-
-	// 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, target, log.ElideError(err))
-	// 		return
-	// 	}
-	// 	dialFn = dialer.Dial
-	// }
-
-	// FIXME - use dialFn if a proxy is needed to connect to the network
-	remote, err := f()
-	// if err != nil {
-	// 	log.Errorf("%s(%s) - outgoing connection failed: %s", name, target, log.ElideError(err))
-	// 	return
-	// }
-	if err != nil {
-		log.Errorf("outgoing connection failed %q", target)
-		return
-	}
+	transport, _ := pt_extras.ArgsToDialer(target, name, args, dialer)
 
-	defer remote.Close()
+	fmt.Println("Dialing ", target)
+	remote, _ := transport.Dial()
 
 	if err := copyLoop(conn, remote); err != nil {
 		log.Warnf("%s(%s) - closed connection: %s", name, target, log.ElideError(err))
@@ -144,14 +124,14 @@ func clientHandler(target string, termMon *termmon.TermMonitor, name string, opt
 	}
 }
 
-func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerInfo pt.ServerInfo, statedir string, options string) (launched bool, listeners []net.Listener) {
+func ServerSetup(termMon *termmon.TermMonitor, ptServerInfo pt.ServerInfo, statedir string, options string) (launched bool, listeners []net.Listener) {
 	// Launch each of the server listeners.
 	for _, bindaddr := range ptServerInfo.Bindaddrs {
 		name := bindaddr.MethodName
 
 		var listen func(address string) net.Listener
 
-		args, argsErr := pt.ParsePT2ServerParameters(options)
+		args, argsErr := options2.ParseServerOptions(options)
 		if argsErr != nil {
 			log.Errorf("Error parsing transport options: %s", options)
 			return
@@ -188,46 +168,73 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 				return false, nil
 			}
 
-			idPath, ok := shargs.Get("Url")
+			untypedIdPath, ok := shargs["Url"]
 			if !ok {
 				return false, nil
 			}
-			transport := Dust.NewDustServer(idPath)
+			idPath, err := options2.CoerceToString(untypedIdPath)
+			if err != nil {
+				log.Errorf("could not coerce Dust Url to string")
+				return false, nil
+			}
+			transport := Dust.NewDustServer(*idPath)
 			listen = transport.Listen
 		case "meeklite":
-			shargs, aok := args["meeklite"]
+			args, aok := args["meeklite"]
 			if !aok {
 				return false, nil
 			}
 
-			Url, ok := shargs.Get("Url")
+			untypedUrl, ok := args["Url"]
 			if !ok {
 				return false, nil
 			}
 
-			Front, ok2 := shargs.Get("Front")
-			if !ok2 {
+
+			Url, err := options2.CoerceToString(untypedUrl)
+			if err != nil {
+				log.Errorf("could not coerce meeklite Url to string")
+			}
+
+			untypedFront, ok := args["Front"]
+			if !ok {
 				return false, nil
 			}
-			transport := meeklite.NewMeekTransportWithFront(Url, Front)
+
+			Front, err := options2.CoerceToString(untypedFront)
+			if err != nil {
+				log.Errorf("could not coerce meeklite Front to string")
+			}
+			transport := meeklite.NewMeekTransportWithFront(*Url, *Front)
 			listen = transport.Listen
 		case "shadow":
-			shargs, aok := args["shadow"]
+			args, aok := args["shadow"]
 			if !aok {
 				return false, nil
 			}
 
-			password, ok := shargs.Get("password")
+			untypedPassword, ok := args["password"]
 			if !ok {
 				return false, nil
 			}
 
-			cipherName, ok2 := shargs.Get("cipherName")
-			if !ok2 {
+			Password, err := options2.CoerceToString(untypedPassword)
+			if err != nil {
+				log.Errorf("could not coerce meeklite Url to string")
+			}
+
+			untypedCertString, ok := args["Url"]
+			if !ok {
 				return false, nil
 			}
 
-			transport := shadow.NewShadowServer(password, cipherName)
+
+			certString, err := options2.CoerceToString(untypedCertString)
+			if err != nil {
+				log.Errorf("could not coerce meeklite Url to string")
+			}
+
+			transport := shadow.NewShadowServer(*Password, *certString)
 			listen = transport.Listen
 		default:
 			log.Errorf("Unknown transport: %s", name)
@@ -249,33 +256,32 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 	return
 }
 
-func getServerBindaddrs(serverBindaddr string) ([]pt.Bindaddr, error) {
-	var result []pt.Bindaddr
-
-	for _, spec := range strings.Split(serverBindaddr, ",") {
-		var bindaddr pt.Bindaddr
-
-		parts := strings.SplitN(spec, "-", 2)
-		if len(parts) != 2 {
-			log.Errorf("TOR_PT_SERVER_BINDADDR: doesn't contain \"-\" %q", spec)
-			return nil, nil
-		}
-		bindaddr.MethodName = parts[0]
-		addr, err := pt.ResolveAddr(parts[1])
-		if err != nil {
-			log.Errorf("TOR_PT_SERVER_BINDADDR: %q %q", spec, err.Error())
-			return nil, nil
-		}
-		bindaddr.Addr = addr
-		//		bindaddr.Options = optionsMap[bindaddr.MethodName]
-		result = append(result, bindaddr)
-	}
-
-	return result, nil
-}
+//func getServerBindaddrs(serverBindaddr string) ([]pt.Bindaddr, error) {
+//	var result []pt.Bindaddr
+//
+//	for _, spec := range strings.Split(serverBindaddr, ",") {
+//		var bindaddr pt.Bindaddr
+//
+//		parts := strings.SplitN(spec, "-", 2)
+//		if len(parts) != 2 {
+//			log.Errorf("TOR_PT_SERVER_BINDADDR: doesn't contain \"-\" %q", spec)
+//			return nil, nil
+//		}
+//		bindaddr.MethodName = parts[0]
+//		addr, err := pt.ResolveAddr(parts[1])
+//		if err != nil {
+//			log.Errorf("TOR_PT_SERVER_BINDADDR: %q %q", spec, err.Error())
+//			return nil, nil
+//		}
+//		bindaddr.Addr = addr
+//		//		bindaddr.Options = optionsMap[bindaddr.MethodName]
+//		result = append(result, bindaddr)
+//	}
+//
+//	return result, nil
+//}
 
 func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo) {
-	defer ln.Close()
 	for {
 		conn, err := ln.Accept()
 		if err != nil {
@@ -300,7 +306,6 @@ func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, i
 		log.Errorf("%s - failed to connect to ORPort: %s", name, log.ElideError(err))
 		return
 	}
-	defer orConn.Close()
 
 	if err = copyLoop(orConn, remote); err != nil {
 		log.Warnf("%s - closed connection: %s", name, log.ElideError(err))
@@ -318,15 +323,11 @@ func copyLoop(a net.Conn, b net.Conn) error {
 
 	go func() {
 		defer wg.Done()
-		defer b.Close()
-		defer a.Close()
 		_, err := io.Copy(b, a)
 		errChan <- err
 	}()
 	go func() {
 		defer wg.Done()
-		defer a.Close()
-		defer b.Close()
 		_, err := io.Copy(a, b)
 		errChan <- err
 	}()
diff --git a/modes/transparent_udp/transparent_udp.go b/modes/transparent_udp/transparent_udp.go
index d69059d..64bc711 100644
--- a/modes/transparent_udp/transparent_udp.go
+++ b/modes/transparent_udp/transparent_udp.go
@@ -34,23 +34,22 @@ import (
 	"encoding/binary"
 	"fmt"
 	options2 "github.com/OperatorFoundation/shapeshifter-dispatcher/common"
+	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/log"
 	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/pt_extras"
+	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/termmon"
+	"github.com/OperatorFoundation/shapeshifter-ipc"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/Dust"
 	replicant "github.com/OperatorFoundation/shapeshifter-transports/transports/Replicant"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/meeklite"
+	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs2"
+	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs4"
 	"github.com/OperatorFoundation/shapeshifter-transports/transports/shadow"
+	"golang.org/x/net/proxy"
 	"io"
 	golog "log"
 	"net"
 	"net/url"
 	"strconv"
-	"strings"
-
-	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/log"
-	"github.com/OperatorFoundation/shapeshifter-dispatcher/common/termmon"
-	"github.com/OperatorFoundation/shapeshifter-ipc"
-	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs2"
-	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs4"
 	//"github.com/OperatorFoundation/shapeshifter-transports/transports/Optimizer"
 	//"github.com/OperatorFoundation/shapeshifter-transports/transports/shadow"
 )
@@ -139,7 +138,7 @@ func clientHandler(target string, termMon *termmon.TermMonitor, name string, opt
 					if writErr != nil {
 						continue
 					} else {
-						_, writeBufErr :=state.Conn.Write(buf)
+						_, writeBufErr := state.Conn.Write(buf)
 						if writeBufErr != nil {
 							_ = state.Conn.Close()
 							_ = conn.Close()
@@ -173,18 +172,20 @@ func openConnection(tracker *ConnTracker, addr string, target string, termMon *t
 
 func dialConn(tracker *ConnTracker, addr string, target string, name string, options string, 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
-	// }
+	var dialer proxy.Dialer
+	dialer = proxy.Direct
+	if proxyURI != nil {
+		var err error
+		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
+		}
+
+	}
 
 	fmt.Println("Dialing....")
 
@@ -193,9 +194,8 @@ func dialConn(tracker *ConnTracker, addr string, target string, name string, opt
 		log.Errorf("Error parsing transport options: %s", options)
 		return
 	}
-
 	// Deal with arguments.
-	transport, _ := pt_extras.ArgsToDialer(target, name, args)
+	transport, _ := pt_extras.ArgsToDialer(target, name, args, dialer)
 	fmt.Println("Dialing ", target)
 	remote, _ := transport.Dial()
 	// if err != nil {
@@ -211,7 +211,7 @@ func dialConn(tracker *ConnTracker, addr string, target string, name string, opt
 	(*tracker)[addr] = ConnState{remote, false}
 }
 
-func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerInfo pt.ServerInfo, options string) (launched bool, listeners []net.Listener) {
+func ServerSetup(termMon *termmon.TermMonitor, ptServerInfo pt.ServerInfo, options string) (launched bool, listeners []net.Listener) {
 	fmt.Println("ServerSetup")
 
 	// Launch each of the server listeners.
@@ -233,11 +233,12 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 			transport := obfs2.NewObfs2Transport()
 			listen = transport.Listen
 		case "obfs4":
+			var dialer proxy.Dialer
 			if cert, ok := args["cert"]; ok {
 				if iatModeStr, ok2 := args["iat-mode"]; ok2 {
 					iatMode, err := strconv.Atoi(iatModeStr[0])
 					if err != nil {
-						transport := obfs4.NewObfs4Client(cert[0], iatMode)
+						transport := obfs4.NewObfs4Client(cert[0], iatMode, dialer)
 						listen = transport.Listen
 					} else {
 						log.Errorf("obfs4 transport bad iat-mode value: %s", iatModeStr)
@@ -317,52 +318,53 @@ func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, ptServerIn
 // Resolve an address string into a net.TCPAddr. We are a bit more strict than
 // net.ResolveTCPAddr; we don't allow an empty host or port, and the host part
 // must be a literal IP address.
-func resolveAddr(addrStr string) (*net.TCPAddr, error) {
-	ipStr, portStr, err := net.SplitHostPort(addrStr)
-	if err != nil {
-		// Before the fixing of bug #7011, tor doesn't put brackets around IPv6
-		// addresses. Split after the last colon, assuming it is a port
-		// separator, and try adding the brackets.
-		parts := strings.Split(addrStr, ":")
-		if len(parts) <= 2 {
-			return nil, err
-		}
-		addrStr := "[" + strings.Join(parts[:len(parts)-1], ":") + "]:" + parts[len(parts)-1]
-		ipStr, portStr, err = net.SplitHostPort(addrStr)
-	}
-	if err != nil {
-		return nil, err
-	}
-	if ipStr == "" {
-		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a host part", addrStr))
-	}
-	if portStr == "" {
-		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a port part", addrStr))
-	}
-	ip := net.ParseIP(ipStr)
-	if ip == nil {
-		return nil, net.InvalidAddrError(fmt.Sprintf("not an IP string: %q", ipStr))
-	}
-	port, err := parsePort(portStr)
-	if err != nil {
-		return nil, err
-	}
-	return &net.TCPAddr{IP: ip, Port: port}, nil
-}
-
-func parsePort(portStr string) (int, error) {
-	port, err := strconv.ParseUint(portStr, 10, 16)
-	return int(port), err
-}
-
-func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo) error {
-	defer ln.Close()
+//func resolveAddr(addrStr string) (*net.TCPAddr, error) {
+//	ipStr, portStr, err := net.SplitHostPort(addrStr)
+//	if err != nil {
+//		// Before the fixing of bug #7011, tor doesn't put brackets around IPv6
+//		// addresses. Split after the last colon, assuming it is a port
+//		// separator, and try adding the brackets.
+//		parts := strings.Split(addrStr, ":")
+//		if len(parts) <= 2 {
+//			return nil, err
+//		}
+//		addrStr := "[" + strings.Join(parts[:len(parts)-1], ":") + "]:" + parts[len(parts)-1]
+//		ipStr, portStr, err = net.SplitHostPort(addrStr)
+//	}
+//	if err != nil {
+//		return nil, err
+//	}
+//	if ipStr == "" {
+//		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a host part", addrStr))
+//	}
+//	if portStr == "" {
+//		return nil, net.InvalidAddrError(fmt.Sprintf("address string %q lacks a port part", addrStr))
+//	}
+//	ip := net.ParseIP(ipStr)
+//	if ip == nil {
+//		return nil, net.InvalidAddrError(fmt.Sprintf("not an IP string: %q", ipStr))
+//	}
+//	port, err := parsePort(portStr)
+//	if err != nil {
+//		return nil, err
+//	}
+//	return &net.TCPAddr{IP: ip, Port: port}, nil
+//}
+//
+//func parsePort(portStr string) (int, error) {
+//	port, err := strconv.ParseUint(portStr, 10, 16)
+//	return int(port), err
+//}
+
+func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener, info *pt.ServerInfo) {
 	for {
 		conn, err := ln.Accept()
 		fmt.Println("accepted")
 		if err != nil {
 			if e, ok := err.(net.Error); ok && !e.Temporary() {
-				return err
+				log.Errorf("serverAcceptLoop failed")
+				_ = ln.Close()
+				return
 			}
 			continue
 		}
@@ -373,7 +375,6 @@ func serverAcceptLoop(termMon *termmon.TermMonitor, name string, ln net.Listener
 func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, info *pt.ServerInfo) {
 	var length16 uint16
 
-	defer remote.Close()
 	termMon.OnHandlerStart()
 	defer termMon.OnHandlerFinish()
 
@@ -428,6 +429,6 @@ func serverHandler(termMon *termmon.TermMonitor, name string, remote net.Conn, i
 			break
 		}
 
-		dest.Write(readBuffer)
+		_, _ = dest.Write(readBuffer)
 	}
 }