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,43 @@ 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)
+	ctx, err := prepareCtx(ctx)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := createConnection(context.Background(), d, network, addr)
+	if err != nil {
+		return nil, err
+	}
+	client, err := createSession(conn, flags, addr, ctx, nil)
+	if err != nil {
+		conn.Close()
+	}
+	return client, err
+}
+
+// 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{}
+	ctx, err := prepareCtx(ctx)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := createConnection(context, d, network, addr)
+	if err != nil {
+		return nil, err
+	}
+	client, err := createSession(conn, flags, addr, ctx, nil)
+	if err != nil {
+		conn.Close()
+	}
+	return client, err
 }
 
 // DialSession will connect to network/address and then wrap the corresponding
@@ -109,15 +146,22 @@ 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)
+	ctx, err := prepareCtx(ctx)
 	if err != nil {
 		return nil, err
 	}
+	conn, err := createConnection(context.Background(), d, network, addr)
+	if err != nil {
+		return nil, err
+	}
+	client, err := createSession(conn, flags, addr, ctx, session)
+	if err != nil {
+		conn.Close()
+	}
+	return client, err
+}
+
+func prepareCtx(ctx *Ctx) (*Ctx, error) {
 	if ctx == nil {
 		var err error
 		ctx, err = NewCtx()
@@ -126,41 +170,59 @@ func dialSession(d net.Dialer, network, addr string, ctx *Ctx, flags DialFlags,
 		}
 		// TODO: use operating system default certificate chain?
 	}
+	return ctx, nil
+}
 
-	c, err := d.Dial(network, addr)
+func createConnection(context context.Context, d net.Dialer, 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 {
+			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 {
+		return nil, err
+	}
+	if session != nil {
+		err := conn.setSession(session)
 		if err != nil {
 			conn.Close()
 			return nil, err
 		}
 	}
+	if err := applyFlags(conn, host, flags); err != nil {
+		conn.Close()
+		return nil, err
+	}
 	return conn, nil
 }

net_test.go

@@ -0,0 +1,77 @@
+package openssl
+
+import (
+	"context"
+	"io"
+	"io/ioutil"
+	"net"
+	"testing"
+	"time"
+)
+
+func sslConnect(t *testing.T, ssl_listener net.Listener) {
+	for {
+		conn, err := ssl_listener.Accept()
+		if err != nil {
+			t.Errorf("failed accept: %s", err)
+			continue
+		}
+		go func() {
+			io.Copy(ioutil.Discard, io.LimitReader(conn, 1024))
+		}()
+	}
+}
+
+func TestDial(t *testing.T) {
+	ctx := getCtx(t)
+	if err := ctx.SetCipherList("AES128-SHA"); err != nil {
+		t.Fatal(err)
+	}
+	ssl_listener, err := Listen("tcp", "localhost:0", ctx)
+
+	go sslConnect(t, ssl_listener)
+
+	client, err := Dial(ssl_listener.Addr().Network(),
+		ssl_listener.Addr().String(), ctx, InsecureSkipHostVerification)
+
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if client.is_shutdown {
+		t.Fatal("client is closed after creation")
+	}
+}
+
+func TestDialTimeout(t *testing.T) {
+	ctx := getCtx(t)
+	if err := ctx.SetCipherList("AES128-SHA"); err != nil {
+		t.Fatal(err)
+	}
+	ssl_listener, err := Listen("tcp", "localhost:0", ctx)
+
+	go sslConnect(t, ssl_listener)
+
+	client, err := DialTimeout(ssl_listener.Addr().Network(),
+		ssl_listener.Addr().String(), time.Nanosecond, ctx, 0)
+	if client != nil || err == nil {
+		t.Fatalf("expected error")
+	}
+}
+
+func TestDialContext(t *testing.T) {
+	ctx := getCtx(t)
+	if err := ctx.SetCipherList("AES128-SHA"); err != nil {
+		t.Fatal(err)
+	}
+	ssl_listener, err := Listen("tcp", "localhost:0", ctx)
+
+	go sslConnect(t, ssl_listener)
+
+	cancelCtx, cancel := context.WithCancel(context.Background())
+	cancel()
+	client, err := DialContext(cancelCtx, ssl_listener.Addr().Network(),
+		ssl_listener.Addr().String(), ctx, 0)
+	if client != nil || err == nil {
+		t.Fatalf("expected error")
+	}
+}