better error reporting on Dial, Listen, Accept, and Write

transports/Dust/v2/Dust.go

@@ -90,20 +90,20 @@ func (transport *dustClient) Dial(address string) (net.Conn, error) {
 }
 
 // Create listener for incoming transport connection
-func (transport *dustServer) Listen(address string) net.Listener {
+func (transport *dustServer) Listen(address string) (net.Listener, error) {
 	addr, resolveErr := pt.ResolveAddr(address)
 	if resolveErr != nil {
 		fmt.Println(resolveErr.Error())
-		return nil
+		return nil, resolveErr
 	}
 
 	ln, err := net.ListenTCP("tcp", addr)
 	if err != nil {
 		fmt.Println(err.Error())
-		return nil
+		return nil, err
 	}
 
-	return newDustTransportListener(ln, transport)
+	return newDustTransportListener(ln, transport), nil
 }
 
 func (listener *dustTransportListener) Addr() net.Addr {

transports/Replicant/v2/pt21.go

@@ -7,36 +7,36 @@ import (
 )
 
 // Create outgoing transport connection
-func (config ClientConfig) Dial(address string) net.Conn {
+func (config ClientConfig) Dial(address string) (net.Conn, error) {
 	conn, dialErr := net.Dial("tcp", address)
 	if dialErr != nil {
-		return nil
+		return nil, dialErr
 	}
 
 	transportConn, err := NewClientConnection(conn, config)
 	if err != nil {
 		if conn != nil {
 			_ = conn.Close()
 		}
-		return nil
+		return nil, err
 	}
 
-	return transportConn
+	return transportConn, nil
 }
 
 // Create listener for incoming transport connection
-func (config ServerConfig) Listen(address string) net.Listener {
+func (config ServerConfig) Listen(address string) (net.Listener, error) {
 	addr, resolveErr := pt.ResolveAddr(address)
 	if resolveErr != nil {
-		return nil
+		return nil, resolveErr
 	}
 
 	ln, err := net.ListenTCP("tcp", addr)
 	if err != nil {
-		return nil
+		return nil, err
 	}
 
-	return newReplicantTransportListener(ln, config)
+	return newReplicantTransportListener(ln, config), nil
 }
 
 func (listener *replicantTransportListener) Addr() net.Addr {

transports/meeklite/v2/meeklite.go

@@ -95,19 +95,19 @@ func (transport *MeekTransport) NetworkDialer() proxy.Dialer {
 }
 
 // Dial creates outgoing transport connection
-func (transport *MeekTransport) Dial() net.Conn {
+func (transport *MeekTransport) Dial() (net.Conn, error) {
 	// FIXME - should use dialer
 	transportConn, err := newMeekClientConn(transport.clientArgs)
 	if err != nil {
-		return nil
+		return nil, err
 	}
 
-	return transportConn
+	return transportConn, nil
 }
 
 // Listen for the meek transport does not have a corresponding server, only a client
-func (transport *MeekTransport) Listen() net.Listener {
-	return nil
+func (transport *MeekTransport) Listen() (net.Listener, error) {
+	return nil, nil
 }
 
 // End methods that implement the base.Transport interface
@@ -138,8 +138,12 @@ type Config struct {
 // Dial creates outgoing transport connection
 func (transport Transport) Dial() (net.Conn, error) {
 	meekTransport := NewMeekTransportWithFront(transport.URL.String(), transport.Front, transport.Dialer)
-	conn := meekTransport.Dial()
-	return conn, nil
+	conn, dialErr := meekTransport.Dial()
+	if dialErr != nil {
+		return nil, errors.New("failed to dial")
+	} else {
+		return conn, nil
+	}
 }
 
 func (ca *meekClientArgs) String() string {

transports/meekserver/v2/pt21.go

@@ -188,13 +188,13 @@ func NewMeekTransportServer(disableTLS bool, acmeEmail string, acmeHostnamesComm
 // Methods that implement the base.Transport interface
 
 // Listen on the meek transport does not have a corresponding server, only a client
-func (transport *MeekServer) Listen(address string) net.Listener {
+func (transport *MeekServer) Listen(address string) (net.Listener, error) {
 	var ln net.Listener
 	var state *State
 	var err error
 	addr, resolverr := net.ResolveTCPAddr("tcp", address)
 	if resolverr != nil {
-		return ln
+		return ln, resolverr
 	}
 	acmeAddr := net.TCPAddr{
 		IP:   addr.IP,
@@ -206,7 +206,7 @@ func (transport *MeekServer) Listen(address string) net.Listener {
 	lnHTTP01, err := net.ListenTCP("tcp", &acmeAddr)
 	if err != nil {
 		log.Printf("error opening HTTP-01 ACME listener: %s", err)
-		return nil
+		return nil, err
 	}
 	go func() {
 		log.Fatal(http.Serve(lnHTTP01, transport.CertManager.HTTPHandler(nil)))
@@ -219,7 +219,7 @@ func (transport *MeekServer) Listen(address string) net.Listener {
 	}
 	if err != nil {
 
-		return nil
+		return nil, err
 	}
-	return meekListener{server, state}
+	return meekListener{server, state}, nil
 }

transports/obfs2/v2/obfs2.go

@@ -147,20 +147,20 @@ func (transport *Transport) Dial(address string) (net.Conn, error) {
 }
 
 // Listen creates listener for incoming transport connection
-func (transport *Transport) Listen(address string) net.Listener {
+func (transport *Transport) Listen(address string) (net.Listener, error) {
 	addr, resolveErr := pt.ResolveAddr(address)
 	if resolveErr != nil {
 		fmt.Println(resolveErr.Error())
-		return nil
+		return nil, resolveErr
 	}
 
 	ln, err := net.ListenTCP("tcp", addr)
 	if err != nil {
 		fmt.Println(err.Error())
-		return nil
+		return nil, err
 	}
 
-	return newObfs2TransportListener(ln)
+	return newObfs2TransportListener(ln), nil
 }
 
 // Methods that implement the net.Conn interface

transports/obfs4/v2/obfs4.go

@@ -229,20 +229,20 @@ func (transport OptimizerTransport) Dial() (net.Conn, error) {
 }
 
 // Listen creates listener for incoming transport connection
-func (transport *Transport) Listen(address string) net.Listener {
+func (transport *Transport) Listen(address string) (net.Listener, error) {
 	addr, resolveErr := pt.ResolveAddr(address)
 	if resolveErr != nil {
 		fmt.Println(resolveErr.Error())
-		return nil
+		return nil, resolveErr
 	}
 
 	ln, err := net.ListenTCP("tcp", addr)
 	if err != nil {
 		fmt.Println(err.Error())
-		return nil
+		return nil, err
 	}
 
-	return newObfs4TransportListener(transport.serverFactory, ln)
+	return newObfs4TransportListener(transport.serverFactory, ln), nil
 }
 
 // Close closes the transport listener.

transports/shadow/v2/shadow.go

@@ -63,19 +63,19 @@ func NewTransport(password string, cipherName string, address string) Transport
 }
 
 //Listen checks for a working connection
-func (config Config) Listen(address string) net.Listener {
+func (config Config) Listen(address string) (net.Listener, error) {
 	cipher, err := shadowsocks.PickCipher(config.CipherName, nil, config.Password)
 	if err != nil {
 		log.Fatal("Failed generating ciphers:", err)
-		return nil
+		return nil, err
 	}
 
 	listener, listenerErr := shadowsocks.Listen("tcp", address, cipher)
 	if listenerErr != nil {
 		log.Fatal("Failed to start listener:", listenerErr)
-		return nil
+		return nil, listenerErr
 	}
-	return listener
+	return listener, nil
 }
 
 //Dial connects to the address on the named network