dial: add DialContext function

In order to replace timeouts with contexts in `Connect` instance
creation (go-tarantool), I need a `DialContext` function.
It accepts context, and cancels, if context is canceled by user.

Part of tarantool/go-tarantool#136

Author: DerekBum

net.go

@@ -15,6 +15,7 @@
 package openssl
 
 import (
+	"context"
 	"errors"
 	"net"
 	"time"
@@ -90,7 +91,33 @@ func Dial(network, addr string, ctx *Ctx, flags DialFlags) (*Conn, error) {
 func DialTimeout(network, addr string, timeout time.Duration, ctx *Ctx,
 	flags DialFlags) (*Conn, error) {
 	d := net.Dialer{Timeout: timeout}
-	return dialSession(d, network, addr, ctx, flags, nil)
+	if err := prepareCtx(ctx); err != nil {
+		return nil, err
+	}
+	conn, err := createConnection(d, context.Background(), network, addr)
+	if err != nil {
+		return nil, err
+	}
+	return createSession(conn, flags, addr, ctx, nil)
+}
+
+// DialContext acts like Dial but takes a context for network dial.
+//
+// The context includes only network dial. It does not include OpenSSL calls.
+//
+// See func Dial for a description of the network, addr, ctx and flags
+// parameters.
+func DialContext(context context.Context, network, addr string,
+	ctx *Ctx, flags DialFlags) (*Conn, error) {
+	d := net.Dialer{}
+	if err := prepareCtx(ctx); err != nil {
+		return nil, err
+	}
+	conn, err := createConnection(d, context, network, addr)
+	if err != nil {
+		return nil, err
+	}
+	return createSession(conn, flags, addr, ctx, nil)
 }
 
 // DialSession will connect to network/address and then wrap the corresponding
@@ -109,58 +136,81 @@ func DialTimeout(network, addr string, timeout time.Duration, ctx *Ctx,
 func DialSession(network, addr string, ctx *Ctx, flags DialFlags,
 	session []byte) (*Conn, error) {
 	var d net.Dialer
-	return dialSession(d, network, addr, ctx, flags, session)
-}
-
-func dialSession(d net.Dialer, network, addr string, ctx *Ctx, flags DialFlags,
-	session []byte) (*Conn, error) {
-	host, _, err := net.SplitHostPort(addr)
+	if err := prepareCtx(ctx); err != nil {
+		return nil, err
+	}
+	conn, err := createConnection(d, context.Background(), network, addr)
 	if err != nil {
 		return nil, err
 	}
+	return createSession(conn, flags, addr, ctx, session)
+}
+
+func prepareCtx(ctx *Ctx) error {
 	if ctx == nil {
 		var err error
 		ctx, err = NewCtx()
 		if err != nil {
-			return nil, err
+			return err
 		}
 		// TODO: use operating system default certificate chain?
 	}
+	return nil
+}
 
-	c, err := d.Dial(network, addr)
+func createConnection(d net.Dialer, context context.Context, network,
+	addr string) (net.Conn, error) {
+	c, err := d.DialContext(context, network, addr)
 	if err != nil {
 		return nil, err
 	}
-	conn, err := Client(c, ctx)
-	if err != nil {
-		c.Close()
-		return nil, err
-	}
-	if session != nil {
-		err := conn.setSession(session)
-		if err != nil {
-			c.Close()
-			return nil, err
-		}
-	}
+	return c, nil
+}
+
+func applyFlags(conn *Conn, host string, flags DialFlags) error {
+	var err error
 	if flags&DisableSNI == 0 {
 		err = conn.SetTlsExtHostName(host)
 		if err != nil {
 			conn.Close()
-			return nil, err
+			return err
 		}
 	}
 	err = conn.Handshake()
 	if err != nil {
 		conn.Close()
-		return nil, err
+		return err
 	}
 	if flags&InsecureSkipHostVerification == 0 {
 		err = conn.VerifyHostname(host)
 		if err != nil {
 			conn.Close()
+			return err
+		}
+	}
+	return nil
+}
+
+func createSession(c net.Conn, flags DialFlags, addr string, ctx *Ctx,
+	session []byte) (*Conn, error) {
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := Client(c, ctx)
+	if err != nil {
+		c.Close()
+		return nil, err
+	}
+	if session != nil {
+		err := conn.setSession(session)
+		if err != nil {
+			c.Close()
 			return nil, err
 		}
 	}
+	if err := applyFlags(conn, host, flags); err != nil {
+		return nil, err
+	}
 	return conn, nil
 }

net_test.go

@@ -0,0 +1,37 @@
+package openssl
+
+import (
+	"context"
+	"net"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestDialTimeout(t *testing.T) {
+	tcp_listener, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, _ := NewCtx()
+	_, err = DialTimeout(tcp_listener.Addr().Network(),
+		tcp_listener.Addr().String(), time.Nanosecond, ctx, 0)
+	if err == nil || !strings.Contains(err.Error(), "i/o timeout") {
+		t.Fatalf("unexpected error, got %v", err)
+	}
+}
+
+func TestDialContext(t *testing.T) {
+	tcp_listener, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	cancelCtx, cancel := context.WithCancel(context.Background())
+	ctx, _ := NewCtx()
+	cancel()
+	_, err = DialContext(cancelCtx, tcp_listener.Addr().Network(),
+		tcp_listener.Addr().String(), ctx, 0)
+	if err == nil || !strings.Contains(err.Error(), "operation was canceled") {
+		t.Fatalf("unexpected error, got %v", err)
+	}
+}