refactor: post review discussion, move http proxy handling to a sample app to keep the library simple

refactor: revert SNI handling and add a pre connect hook instead to keep the library clean and to allow the clients to customize the final tls config that will be in use for connecting

Signed-off-by: amir-khassaia <amir.khassaia@gmail.com>

Author: Amir Khassaia

client.go

@@ -379,8 +379,13 @@ func (c *client) attemptConnection() (net.Conn, byte, bool, error) {
 		cm := newConnectMsgFromOptions(&c.options, broker)
 		DEBUG.Println(CLI, "about to write new connect msg")
 	CONN:
+		tlsCfg := c.options.TLSConfig
+		if c.options.OnConnectAttempt != nil {
+			DEBUG.Println(CLI, "using custom onConnectAttempt handler...")
+			tlsCfg = c.options.OnConnectAttempt(broker, c.options.TLSConfig)
+		}
 		// Start by opening the network connection (tcp, tls, ws) etc
-		conn, err = openConnection(broker, c.options.TLSConfig, c.options.ConnectTimeout, c.options.HTTPHeaders, c.options.WebsocketOptions)
+		conn, err = openConnection(broker, tlsCfg, c.options.ConnectTimeout, c.options.HTTPHeaders, c.options.WebsocketOptions)
 		if err != nil {
 			ERROR.Println(CLI, err.Error())
 			WARN.Println(CLI, "failed to connect to broker, trying next")
@@ -397,7 +402,7 @@ func (c *client) attemptConnection() (net.Conn, byte, bool, error) {
 
 		// We may be have to attempt the connection with MQTT 3.1
 		if conn != nil {
-			conn.Close()
+			_ = conn.Close()
 		}
 		if !c.options.protocolVersionExplicit && protocolVersion == 4 { // try falling back to 3.1?
 			DEBUG.Println(CLI, "Trying reconnect using MQTT 3.1 protocol")
@@ -504,8 +509,8 @@ func (c *client) internalConnLost(err error) {
 	}
 }
 
-// startCommsWorkers is called when the connection is up. It starts off all of the routines needed to process incoming and
-// outgoing messages.
+// startCommsWorkers is called when the connection is up.
+// It starts off all of the routines needed to process incoming and outgoing messages.
 // Returns true if the comms workers were started (i.e. they were not already running)
 func (c *client) startCommsWorkers(conn net.Conn, inboundFromStore <-chan packets.ControlPacket) bool {
 	DEBUG.Println(CLI, "startCommsWorkers called")

http_proxy.go cmd/httpproxy/httpproxy.go

@@ -1,4 +1,4 @@
-package mqtt
+package main
 
 import (
 	"bufio"
@@ -77,8 +77,3 @@ func (s *httpProxy) Dial(_, addr string) (net.Conn, error) {
 
 	return c, nil
 }
-
-func init() {
-	proxy.RegisterDialerType("http", newHTTPProxy)
-	proxy.RegisterDialerType("https", newHTTPProxy)
-}

cmd/httpproxy/main.go

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2013 IBM Corp.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Seth Hoenig
+ *    Allan Stockdill-Mander
+ *    Mike Robertson
+ */
+
+package main
+
+import (
+	"crypto/tls"
+	"flag"
+	"fmt"
+	"golang.org/x/net/proxy"
+	"log"
+	"net/url"
+
+	// "log"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	MQTT "github.com/eclipse/paho.mqtt.golang"
+)
+
+func onMessageReceived(_ MQTT.Client, message MQTT.Message) {
+	fmt.Printf("Received message on topic: %s\nMessage: %s\n", message.Topic(), message.Payload())
+}
+
+func init() {
+	// Pre-register custom HTTP proxy dialers for use with proxy.FromEnvironment
+	proxy.RegisterDialerType("http", newHTTPProxy)
+	proxy.RegisterDialerType("https", newHTTPProxy)
+}
+
+/**
+ * Illustrates how to make an MQTT connection with HTTP proxy CONNECT support.
+ * Specify proxy via environment variable: eg: ALL_PROXY=https://proxy_host:port
+ */
+func main() {
+	MQTT.DEBUG = log.New(os.Stdout, "", 0)
+	MQTT.ERROR = log.New(os.Stderr, "", 0)
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+	hostname, _ := os.Hostname()
+
+	server := flag.String("server", "tcp://127.0.0.1:1883", "The full URL of the MQTT server to "+
+		"connect to ex: tcp://127.0.0.1:1883")
+	topic := flag.String("topic", "#", "Topic to subscribe to")
+	qos := flag.Int("qos", 0, "The QoS to subscribe to messages at")
+	clientid := flag.String("clientid", hostname+strconv.Itoa(time.Now().Second()), "A clientid for the connection")
+	username := flag.String("username", "", "A username to authenticate to the MQTT server")
+	password := flag.String("password", "", "Password to match username")
+	token := flag.String("token", "", "An optional token credential to authenticate with")
+	skipVerify := flag.Bool("skipVerify", false, "Controls whether TLS certificate is verified")
+	flag.Parse()
+
+	connOpts := MQTT.NewClientOptions().AddBroker(*server).
+		SetClientID(*clientid).
+		SetCleanSession(true).
+		SetProtocolVersion(4)
+
+	if *username != "" {
+		connOpts.SetUsername(*username)
+		if *password != "" {
+			connOpts.SetPassword(*password)
+		}
+	} else if *token != "" {
+		connOpts.SetCredentialsProvider(func() (string, string) {
+			return "unused", *token
+		})
+	}
+
+	connOpts.SetTLSConfig(&tls.Config{InsecureSkipVerify: *skipVerify, ClientAuth: tls.NoClientCert})
+
+	connOpts.OnConnect = func(c MQTT.Client) {
+		if token := c.Subscribe(*topic, byte(*qos), onMessageReceived); token.Wait() && token.Error() != nil {
+			panic(token.Error())
+		}
+	}
+
+	// Illustrates customized TLS configuration prior to connection attempt
+	connOpts.OnConnectAttempt = func(broker *url.URL, tlsCfg *tls.Config) *tls.Config {
+		cfg := tlsCfg.Clone()
+		cfg.ServerName = broker.Hostname()
+		return cfg
+	}
+
+	client := MQTT.NewClient(connOpts)
+	if token := client.Connect(); token.Wait() && token.Error() != nil {
+		panic(token.Error())
+	} else {
+		fmt.Printf("Connected to %s\n", *server)
+	}
+
+	<-c
+}

netconn.go

@@ -30,7 +30,8 @@ import (
 // This just establishes the network connection; once established the type of connection should be irrelevant
 //
 
-// openConnection opens a network connection using the protocol indicated in the URL. Does not carry out any MQTT specific handshakes
+// openConnection opens a network connection using the protocol indicated in the URL.
+// Does not carry out any MQTT specific handshakes.
 func openConnection(uri *url.URL, tlsc *tls.Config, timeout time.Duration, headers http.Header, websocketOptions *WebsocketOptions) (net.Conn, error) {
 	switch uri.Scheme {
 	case "ws":
@@ -77,26 +78,15 @@ func openConnection(uri *url.URL, tlsc *tls.Config, timeout time.Duration, heade
 			return nil, err
 		}
 
-		tlsConn := tls.Client(conn, tlsConfigWithSni(uri, tlsc))
+		tlsConn := tls.Client(conn, tlsc)
 
 		err = tlsConn.Handshake()
 		if err != nil {
-			conn.Close()
+			_ = conn.Close()
 			return nil, err
 		}
 
 		return tlsConn, nil
 	}
 	return nil, errors.New("unknown protocol")
 }
-
-func tlsConfigWithSni(uri *url.URL, conf *tls.Config) *tls.Config {
-	tlsConfig := conf
-	if tlsConfig.ServerName == "" {
-		// Ensure SNI is set appropriately - make a copy to avoid polluting argument or default.
-		c := tlsConfig.Clone()
-		c.ServerName = uri.Hostname()
-		tlsConfig = c
-	}
-	return tlsConfig
-}

options.go

@@ -49,6 +49,9 @@ type OnConnectHandler func(Client)
 // the initial connection is lost
 type ReconnectHandler func(Client, *ClientOptions)
 
+// ConnectionAttemptHandler is invoked prior to making the initial connection.
+type ConnectionAttemptHandler func(broker *url.URL, tlsCfg *tls.Config) *tls.Config
+
 // ClientOptions contains configurable options for an Client. Note that these should be set using the
 // relevant methods (e.g. AddBroker) rather than directly. See those functions for information on usage.
 type ClientOptions struct {
@@ -79,6 +82,7 @@ type ClientOptions struct {
 	OnConnect               OnConnectHandler
 	OnConnectionLost        ConnectionLostHandler
 	OnReconnecting          ReconnectHandler
+	OnConnectAttempt        ConnectionAttemptHandler
 	WriteTimeout            time.Duration
 	MessageChannelDepth     uint
 	ResumeSubs              bool
@@ -120,6 +124,7 @@ func NewClientOptions() *ClientOptions {
 		Store:                   nil,
 		OnConnect:               nil,
 		OnConnectionLost:        DefaultConnectionLostHandler,
+		OnConnectAttempt:        nil,
 		WriteTimeout:            0, // 0 represents timeout disabled
 		ResumeSubs:              false,
 		HTTPHeaders:             make(map[string][]string),
@@ -321,6 +326,13 @@ func (o *ClientOptions) SetReconnectingHandler(cb ReconnectHandler) *ClientOptio
 	return o
 }
 
+// SetConnectionAttemptHandler sets the ConnectionAttemptHandler callback to be executed prior
+// to the client attempting initial connection to the MQTT broker.
+func (o *ClientOptions) SetConnectionAttemptHandler(onConnectAttempt ConnectionAttemptHandler) *ClientOptions {
+	o.OnConnectAttempt = onConnectAttempt
+	return o
+}
+
 // SetWriteTimeout puts a limit on how long a mqtt publish should block until it unblocks with a
 // timeout error. A duration of 0 never times out. Default never times out
 func (o *ClientOptions) SetWriteTimeout(t time.Duration) *ClientOptions {