Merge pull request #376 from michaelwilner/master

Socks proxy dialer

Author: cbusbey

Gopkg.lock

@@ -23,6 +23,11 @@ const (
 	SocketMinimumTLSVersion      string = "SocketMinimumTLSVersion"
 	SocketTimeout                string = "SocketTimeout"
 	SocketUseSSL                 string = "SocketUseSSL"
+	ProxyType                    string = "ProxyType"
+	ProxyHost                    string = "ProxyHost"
+	ProxyPort                    string = "ProxyPort"
+	ProxyUser                    string = "ProxyUser"
+	ProxyPassword                string = "ProxyPassword"
 	DefaultApplVerID             string = "DefaultApplVerID"
 	StartTime                    string = "StartTime"
 	EndTime                      string = "EndTime"

config/configuration.go

@@ -288,6 +288,27 @@ SocketUseSSL
 
 Use SSL for initiators even if client certificates are not present. If set to N or omitted, TLS will not be used if SocketPrivateKeyFile or SocketCertificateFile are not supplied.
 
+ProxyType
+
+Proxy type. Valid Values:
+ socks
+
+ProxyHost
+
+Proxy server IP address in the format of x.x.x.x or a domain name
+
+ProxyPort
+
+Proxy server port
+
+ProxyUser
+
+Proxy user
+
+ProxyPassword
+
+Proxy password
+
 PersistMessages
 
 If set to N, no messages will be persisted. This will force QuickFIX/Go to always send GapFills instead of resending messages. Use this if you know you never want to resend a message. Useful for market data streams.  Valid Values:

config/doc.go

@@ -0,0 +1,55 @@
+package quickfix
+
+import (
+	"fmt"
+	"github.com/quickfixgo/quickfix/config"
+	"golang.org/x/net/proxy"
+	"net"
+)
+
+func loadDialerConfig(settings *SessionSettings) (dialer proxy.Dialer, err error) {
+	stdDialer := &net.Dialer{}
+	if settings.HasSetting(config.SocketTimeout) {
+		if stdDialer.Timeout, err = settings.DurationSetting(config.SocketTimeout); err != nil {
+			return
+		}
+	}
+	dialer = stdDialer
+
+	if !settings.HasSetting(config.ProxyType) {
+		return
+	}
+
+	var proxyType string
+	if proxyType, err = settings.Setting(config.ProxyType); err != nil {
+		return
+	}
+
+	switch proxyType {
+	case "socks":
+		var proxyHost string
+		var proxyPort int
+		if proxyHost, err = settings.Setting(config.ProxyHost); err != nil {
+			return
+		} else if proxyPort, err = settings.IntSetting(config.ProxyPort); err != nil {
+			return
+		}
+
+		proxyAuth := new(proxy.Auth)
+		if settings.HasSetting(config.ProxyUser) {
+			if proxyAuth.User, err = settings.Setting(config.ProxyUser); err != nil {
+				return
+			}
+		}
+		if settings.HasSetting(config.ProxyPassword) {
+			if proxyAuth.Password, err = settings.Setting(config.ProxyPassword); err != nil {
+				return
+			}
+		}
+
+		dialer, err = proxy.SOCKS5("tcp", fmt.Sprintf("%s:%d", proxyHost, proxyPort), proxyAuth, dialer)
+	default:
+		err = fmt.Errorf("unsupported proxy type %s", proxyType)
+	}
+	return
+}

dialer.go

@@ -0,0 +1,75 @@
+package quickfix
+
+import (
+	"github.com/quickfixgo/quickfix/config"
+	"github.com/stretchr/testify/suite"
+	"net"
+	"testing"
+	"time"
+)
+
+type DialerTestSuite struct {
+	suite.Suite
+	settings *Settings
+}
+
+func TestDialerTestSuite(t *testing.T) {
+	suite.Run(t, new(DialerTestSuite))
+}
+
+func (s *DialerTestSuite) SetupTest() {
+	s.settings = NewSettings()
+}
+
+func (s *DialerTestSuite) TestLoadDialerNoSettings() {
+	dialer, err := loadDialerConfig(s.settings.GlobalSettings())
+	s.Require().Nil(err)
+
+	stdDialer, ok := dialer.(*net.Dialer)
+	s.Require().True(ok)
+	s.Require().NotNil(stdDialer)
+	s.Zero(stdDialer.Timeout)
+}
+
+func (s *DialerTestSuite) TestLoadDialerWithTimeout() {
+	s.settings.GlobalSettings().Set(config.SocketTimeout, "10s")
+	dialer, err := loadDialerConfig(s.settings.GlobalSettings())
+	s.Require().Nil(err)
+
+	stdDialer, ok := dialer.(*net.Dialer)
+	s.Require().True(ok)
+	s.Require().NotNil(stdDialer)
+	s.EqualValues(10*time.Second, stdDialer.Timeout)
+}
+
+func (s *DialerTestSuite) TestLoadDialerInvalidProxy() {
+	s.settings.GlobalSettings().Set(config.ProxyType, "totallyinvalidproxytype")
+	_, err := loadDialerConfig(s.settings.GlobalSettings())
+	s.Require().NotNil(err)
+}
+
+func (s *DialerTestSuite) TestLoadDialerSocksProxy() {
+	s.settings.GlobalSettings().Set(config.ProxyType, "socks")
+	s.settings.GlobalSettings().Set(config.ProxyHost, "localhost")
+	s.settings.GlobalSettings().Set(config.ProxyPort, "31337")
+	dialer, err := loadDialerConfig(s.settings.GlobalSettings())
+	s.Require().Nil(err)
+	s.Require().NotNil(dialer)
+
+	_, ok := dialer.(*net.Dialer)
+	s.Require().False(ok)
+}
+
+func (s *DialerTestSuite) TestLoadDialerSocksProxyInvalidHost() {
+	s.settings.GlobalSettings().Set(config.ProxyType, "socks")
+	s.settings.GlobalSettings().Set(config.ProxyPort, "31337")
+	_, err := loadDialerConfig(s.settings.GlobalSettings())
+	s.Require().NotNil(err)
+}
+
+func (s *DialerTestSuite) TestLoadDialerSocksProxyInvalidPort() {
+	s.settings.GlobalSettings().Set(config.ProxyType, "socks")
+	s.settings.GlobalSettings().Set(config.ProxyHost, "localhost")
+	_, err := loadDialerConfig(s.settings.GlobalSettings())
+	s.Require().NotNil(err)
+}

dialer_test.go

@@ -3,11 +3,9 @@ package quickfix
 import (
 	"bufio"
 	"crypto/tls"
-	"net"
+	"golang.org/x/net/proxy"
 	"sync"
 	"time"
-
-	"github.com/quickfixgo/quickfix/config"
 )
 
 //Initiator initiates connections and processes messages for all sessions.
@@ -35,15 +33,14 @@ func (i *Initiator) Start() (err error) {
 			return
 		}
 
-		dialTimeout := time.Duration(0)
-		if settings.HasSetting(config.SocketTimeout) {
-			if dialTimeout, err = settings.DurationSetting(config.SocketTimeout); err != nil {
-				return
-			}
+		var dialer proxy.Dialer
+		if dialer, err = loadDialerConfig(settings); err != nil {
+			return
 		}
+
 		i.wg.Add(1)
 		go func(sessID SessionID) {
-			i.handleConnection(i.sessions[sessID], tlsConfig, dialTimeout)
+			i.handleConnection(i.sessions[sessID], tlsConfig, dialer)
 			i.wg.Done()
 		}(sessionID)
 	}
@@ -121,7 +118,7 @@ func (i *Initiator) waitForReconnectInterval(reconnectInterval time.Duration) bo
 	return true
 }
 
-func (i *Initiator) handleConnection(session *session, tlsConfig *tls.Config, dialTimeout time.Duration) {
+func (i *Initiator) handleConnection(session *session, tlsConfig *tls.Config, dialer proxy.Dialer) {
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
@@ -148,27 +145,17 @@ func (i *Initiator) handleConnection(session *session, tlsConfig *tls.Config, di
 		address := session.SocketConnectAddress[connectionAttempt%len(session.SocketConnectAddress)]
 		session.log.OnEventf("Connecting to: %v", address)
 
-		var netConn net.Conn
-		if tlsConfig != nil {
-			tlsConn, err := tls.DialWithDialer(&net.Dialer{Timeout: dialTimeout}, "tcp", address, tlsConfig)
-			if err != nil {
-				session.log.OnEventf("Failed to connect: %v", err)
-				goto reconnect
-			}
-
-			err = tlsConn.Handshake()
-			if err != nil {
-				session.log.OnEventf("Failed handshake:%v", err)
+		netConn, err := dialer.Dial("tcp", address)
+		if err != nil {
+			session.log.OnEventf("Failed to connect: %v", err)
+			goto reconnect
+		} else if tlsConfig != nil {
+			tlsConn := tls.Client(netConn, tlsConfig)
+			if err = tlsConn.Handshake(); err != nil {
+				session.log.OnEventf("Failed handshake: %v", err)
 				goto reconnect
 			}
 			netConn = tlsConn
-		} else {
-			var err error
-			netConn, err = net.Dial("tcp", address)
-			if err != nil {
-				session.log.OnEventf("Failed to connect: %v", err)
-				goto reconnect
-			}
 		}
 
 		msgIn = make(chan fixIn)