Release 2019.6.0

fixes #96.

This change checks the err returned from the StartServer function, and
if it exists, passes a non-zero error code through to the urfave/cli
framework. This should allow processes like launchd to detect if
cloudflared exited gracefully or with an error.

Makefile

@@ -70,7 +70,7 @@ tunnel-deps: tunnelrpc/tunnelrpc.capnp.go
 tunnelrpc/tunnelrpc.capnp.go: tunnelrpc/tunnelrpc.capnp
 	which capnp  # https://capnproto.org/install.html
 	which capnpc-go  # go get zombiezen.com/go/capnproto2/capnpc-go
-	capnp compile -ogo -I ./tunnelrpc tunnelrpc/tunnelrpc.capnp
+	capnp compile -ogo tunnelrpc/tunnelrpc.capnp
 
 .PHONY: vet
 vet:

RELEASE_NOTES

@@ -1,3 +1,10 @@
+2019.6.0
+- 2019-05-17 TUN-1828: Update declarative tunnel config struct
+- 2019-05-29 Handle exit code on err
+- 2019-05-29 AUTH-1802: Fixed ssh-config templating
+- 2019-05-30 TUN-1914: Conflate HTTP and Unix OriginConfig, and add TLS config to WebSocketOriginConfig
+- 2019-06-03 AUTH-1811: ssh-gen config fixes
+
 2019.5.0
 - 2019-04-25 TUN-1781: ServeStream should return early on error
 - 2019-04-30 TUN-1786: Remove low-level Windows service logging

cmd/cloudflared/access/cmd.go

@@ -3,10 +3,10 @@ package access
 import (
 	"errors"
 	"fmt"
-	"html/template"
 	"net/url"
 	"os"
 	"strings"
+	"text/template"
 
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/shell"
 	"github.com/cloudflare/cloudflared/cmd/cloudflared/token"
@@ -27,19 +27,19 @@ const (
 	sshTokenSecretFlag = "service-token-secret"
 	sshGenCertFlag     = "short-lived-cert"
 	sshConfigTemplate  = `
-Add this configuration block to your {{.Home}}/.ssh/config:
+Add to your {{.Home}}/.ssh/config:
 
 Host {{.Hostname}}
 {{- if .ShortLivedCerts}}
-	ProxyCommand bash -c '{{.Cloudflared}} access ssh-gen --hostname %h; ssh -tt cfpipe >&2 <&1' 
+  ProxyCommand bash -c '{{.Cloudflared}} access ssh-gen --hostname %h; ssh -tt %r@cfpipe-{{.Hostname}} >&2 <&1' 
 
 Host cfpipe-{{.Hostname}}
-	HostName {{.Hostname}}
-	ProxyCommand {{.Cloudflared}} access ssh --hostname %h
-	IdentityFile ~/.cloudflared/{{.Hostname}}.me-cf_key
-	CertificateFile ~/.cloudflared/{{.Hostname}}-cf_key-cert.pub
+  HostName {{.Hostname}}
+  ProxyCommand {{.Cloudflared}} access ssh --hostname %h
+  IdentityFile ~/.cloudflared/{{.Hostname}}-cf_key
+  CertificateFile ~/.cloudflared/{{.Hostname}}-cf_key-cert.pub
 {{- else}}
-	ProxyCommand {{.Cloudflared}} access ssh --hostname %h
+  ProxyCommand {{.Cloudflared}} access ssh --hostname %h
 {{end}}
 `
 )

cmd/cloudflared/main.go

@@ -127,10 +127,14 @@ func action(version string, shutdownC, graceShutdownC chan struct{}) cli.ActionF
 		tags["hostname"] = c.String("hostname")
 		raven.SetTagsContext(tags)
 		raven.CapturePanic(func() { err = tunnel.StartServer(c, version, shutdownC, graceShutdownC) }, nil)
+		exitCode := 0
 		if err != nil {
 			handleError(err)
+			exitCode = 1
 		}
-		return err
+		// we already handle error printing, so we pass an empty string so we
+		// don't have to print again.
+		return cli.Exit("", exitCode)
 	}
 }
 

tunnelrpc/pogs/config.go

@@ -3,6 +3,7 @@ package pogs
 import (
 	"context"
 	"fmt"
+	"net/url"
 	"time"
 
 	"github.com/cloudflare/cloudflared/tunnelrpc"
@@ -15,8 +16,8 @@ import (
 /// Structs
 ///
 
-type CloudflaredConfig struct {
-	Timestamp              time.Time
+type ClientConfig struct {
+	Version                uint64
 	AutoUpdateFrequency    time.Duration
 	MetricsUpdateFrequency time.Duration
 	HeartbeatInterval      time.Duration
@@ -24,6 +25,7 @@ type CloudflaredConfig struct {
 	GracePeriod            time.Duration
 	DoHProxyConfigs        []*DoHProxyConfig
 	ReverseProxyConfigs    []*ReverseProxyConfig
+	NumHAConnections       uint8
 }
 
 type UseConfigurationResult struct {
@@ -38,21 +40,39 @@ type DoHProxyConfig struct {
 }
 
 type ReverseProxyConfig struct {
-	TunnelID           string
+	TunnelHostname     string
 	Origin             OriginConfig
 	Retries            uint64
 	ConnectionTimeout  time.Duration
-	ChunkedEncoding    bool
 	CompressionQuality uint64
 }
 
+func NewReverseProxyConfig(
+	tunnelHostname string,
+	originConfig OriginConfig,
+	retries uint64,
+	connectionTimeout time.Duration,
+	compressionQuality uint64,
+) (*ReverseProxyConfig, error) {
+	if originConfig == nil {
+		return nil, fmt.Errorf("NewReverseProxyConfig: originConfig was null")
+	}
+	return &ReverseProxyConfig{
+		TunnelHostname:     tunnelHostname,
+		Origin:             originConfig,
+		Retries:            retries,
+		ConnectionTimeout:  connectionTimeout,
+		CompressionQuality: compressionQuality,
+	}, nil
+}
+
 //go-sumtype:decl OriginConfig
 type OriginConfig interface {
 	isOriginConfig()
 }
 
 type HTTPOriginConfig struct {
-	URL                   string        `capnp:"url"`
+	URL                   OriginAddr    `capnp:"url"`
 	TCPKeepAlive          time.Duration `capnp:"tcpKeepAlive"`
 	DialDualStack         bool
 	TLSHandshakeTimeout   time.Duration `capnp:"tlsHandshakeTimeout"`
@@ -61,18 +81,49 @@ type HTTPOriginConfig struct {
 	OriginServerName      string
 	MaxIdleConnections    uint64
 	IdleConnectionTimeout time.Duration
+	ProxyConnectTimeout   time.Duration
+	ExpectContinueTimeout time.Duration
+	ChunkedEncoding       bool
 }
 
 func (_ *HTTPOriginConfig) isOriginConfig() {}
 
-type UnixSocketOriginConfig struct {
+type OriginAddr interface {
+	Addr() string
+}
+
+type HTTPURL struct {
+	URL *url.URL
+}
+
+func (ha *HTTPURL) Addr() string {
+	return ha.URL.String()
+}
+
+func (ha *HTTPURL) capnpHTTPURL() *CapnpHTTPURL {
+	return &CapnpHTTPURL{
+		URL: ha.URL.String(),
+	}
+}
+
+// URL for a HTTP origin, capnp doesn't have native support for URL, so represent it as string
+type CapnpHTTPURL struct {
+	URL string `capnp:"url"`
+}
+
+type UnixPath struct {
 	Path string
 }
 
-func (_ *UnixSocketOriginConfig) isOriginConfig() {}
+func (up *UnixPath) Addr() string {
+	return up.Path
+}
 
 type WebSocketOriginConfig struct {
-	URL string `capnp:"url"`
+	URL              string `capnp:"url"`
+	TLSVerify        bool   `capnp:"tlsVerify"`
+	OriginCAPool     string
+	OriginServerName string
 }
 
 func (_ *WebSocketOriginConfig) isOriginConfig() {}
@@ -81,29 +132,31 @@ type HelloWorldOriginConfig struct{}
 
 func (_ *HelloWorldOriginConfig) isOriginConfig() {}
 
-///
-/// Boilerplate to convert between these structs and the primitive structs generated by capnp-go
-///
+/*
+ * Boilerplate to convert between these structs and the primitive structs
+ * generated by capnp-go.
+ * Mnemonics for variable names in this section:
+ *   - `p` is for POGS (plain old Go struct)
+ *   - `s` (and `ss`) is for "capnp.Struct", which is the fundamental type
+ *     underlying the capnp-go data structures.
+ */
 
-func MarshalCloudflaredConfig(s tunnelrpc.CloudflaredConfig, p *CloudflaredConfig) error {
-	s.SetTimestamp(p.Timestamp.UnixNano())
+func MarshalClientConfig(s tunnelrpc.ClientConfig, p *ClientConfig) error {
+	s.SetVersion(p.Version)
 	s.SetAutoUpdateFrequency(p.AutoUpdateFrequency.Nanoseconds())
 	s.SetMetricsUpdateFrequency(p.MetricsUpdateFrequency.Nanoseconds())
 	s.SetHeartbeatInterval(p.HeartbeatInterval.Nanoseconds())
 	s.SetMaxFailedHeartbeats(p.MaxFailedHeartbeats)
 	s.SetGracePeriod(p.GracePeriod.Nanoseconds())
+	s.SetNumHAConnections(p.NumHAConnections)
 	err := marshalDoHProxyConfigs(s, p.DoHProxyConfigs)
 	if err != nil {
 		return err
 	}
-	err = marshalReverseProxyConfigs(s, p.ReverseProxyConfigs)
-	if err != nil {
-		return err
-	}
-	return nil
+	return marshalReverseProxyConfigs(s, p.ReverseProxyConfigs)
 }
 
-func marshalDoHProxyConfigs(s tunnelrpc.CloudflaredConfig, dohProxyConfigs []*DoHProxyConfig) error {
+func marshalDoHProxyConfigs(s tunnelrpc.ClientConfig, dohProxyConfigs []*DoHProxyConfig) error {
 	capnpList, err := s.NewDohProxyConfigs(int32(len(dohProxyConfigs)))
 	if err != nil {
 		return err
@@ -117,7 +170,7 @@ func marshalDoHProxyConfigs(s tunnelrpc.CloudflaredConfig, dohProxyConfigs []*Do
 	return nil
 }
 
-func marshalReverseProxyConfigs(s tunnelrpc.CloudflaredConfig, reverseProxyConfigs []*ReverseProxyConfig) error {
+func marshalReverseProxyConfigs(s tunnelrpc.ClientConfig, reverseProxyConfigs []*ReverseProxyConfig) error {
 	capnpList, err := s.NewReverseProxyConfigs(int32(len(reverseProxyConfigs)))
 	if err != nil {
 		return err
@@ -131,14 +184,15 @@ func marshalReverseProxyConfigs(s tunnelrpc.CloudflaredConfig, reverseProxyConfi
 	return nil
 }
 
-func UnmarshalCloudflaredConfig(s tunnelrpc.CloudflaredConfig) (*CloudflaredConfig, error) {
-	p := new(CloudflaredConfig)
-	p.Timestamp = time.Unix(0, s.Timestamp()).UTC()
+func UnmarshalClientConfig(s tunnelrpc.ClientConfig) (*ClientConfig, error) {
+	p := new(ClientConfig)
+	p.Version = s.Version()
 	p.AutoUpdateFrequency = time.Duration(s.AutoUpdateFrequency())
 	p.MetricsUpdateFrequency = time.Duration(s.MetricsUpdateFrequency())
 	p.HeartbeatInterval = time.Duration(s.HeartbeatInterval())
 	p.MaxFailedHeartbeats = s.MaxFailedHeartbeats()
 	p.GracePeriod = time.Duration(s.GracePeriod())
+	p.NumHAConnections = s.NumHAConnections()
 	dohProxyConfigs, err := unmarshalDoHProxyConfigs(s)
 	if err != nil {
 		return nil, err
@@ -152,7 +206,7 @@ func UnmarshalCloudflaredConfig(s tunnelrpc.CloudflaredConfig) (*CloudflaredConf
 	return p, err
 }
 
-func unmarshalDoHProxyConfigs(s tunnelrpc.CloudflaredConfig) ([]*DoHProxyConfig, error) {
+func unmarshalDoHProxyConfigs(s tunnelrpc.ClientConfig) ([]*DoHProxyConfig, error) {
 	var result []*DoHProxyConfig
 	marshalledDoHProxyConfigs, err := s.DohProxyConfigs()
 	if err != nil {
@@ -169,7 +223,7 @@ func unmarshalDoHProxyConfigs(s tunnelrpc.CloudflaredConfig) ([]*DoHProxyConfig,
 	return result, nil
 }
 
-func unmarshalReverseProxyConfigs(s tunnelrpc.CloudflaredConfig) ([]*ReverseProxyConfig, error) {
+func unmarshalReverseProxyConfigs(s tunnelrpc.ClientConfig) ([]*ReverseProxyConfig, error) {
 	var result []*ReverseProxyConfig
 	marshalledReverseProxyConfigs, err := s.ReverseProxyConfigs()
 	if err != nil {
@@ -207,49 +261,48 @@ func UnmarshalDoHProxyConfig(s tunnelrpc.DoHProxyConfig) (*DoHProxyConfig, error
 }
 
 func MarshalReverseProxyConfig(s tunnelrpc.ReverseProxyConfig, p *ReverseProxyConfig) error {
-	s.SetTunnelID(p.TunnelID)
+	s.SetTunnelHostname(p.TunnelHostname)
 	switch config := p.Origin.(type) {
 	case *HTTPOriginConfig:
 		ss, err := s.Origin().NewHttp()
 		if err != nil {
 			return err
 		}
-		MarshalHTTPOriginConfig(ss, config)
-	case *UnixSocketOriginConfig:
-		ss, err := s.Origin().NewSocket()
-		if err != nil {
+		if err := MarshalHTTPOriginConfig(ss, config); err != nil {
 			return err
 		}
-		MarshalUnixSocketOriginConfig(ss, config)
 	case *WebSocketOriginConfig:
 		ss, err := s.Origin().NewWebsocket()
 		if err != nil {
 			return err
 		}
-		MarshalWebSocketOriginConfig(ss, config)
+		if err := MarshalWebSocketOriginConfig(ss, config); err != nil {
+			return err
+		}
 	case *HelloWorldOriginConfig:
 		ss, err := s.Origin().NewHelloWorld()
 		if err != nil {
 			return err
 		}
-		MarshalHelloWorldOriginConfig(ss, config)
+		if err := MarshalHelloWorldOriginConfig(ss, config); err != nil {
+			return err
+		}
 	default:
 		return fmt.Errorf("Unknown type for config: %T", config)
 	}
 	s.SetRetries(p.Retries)
 	s.SetConnectionTimeout(p.ConnectionTimeout.Nanoseconds())
-	s.SetChunkedEncoding(p.ChunkedEncoding)
 	s.SetCompressionQuality(p.CompressionQuality)
 	return nil
 }
 
 func UnmarshalReverseProxyConfig(s tunnelrpc.ReverseProxyConfig) (*ReverseProxyConfig, error) {
 	p := new(ReverseProxyConfig)
-	tunnelID, err := s.TunnelID()
+	tunnelHostname, err := s.TunnelHostname()
 	if err != nil {
 		return nil, err
 	}
-	p.TunnelID = tunnelID
+	p.TunnelHostname = tunnelHostname
 	switch s.Origin().Which() {
 	case tunnelrpc.ReverseProxyConfig_origin_Which_http:
 		ss, err := s.Origin().Http()
@@ -261,16 +314,6 @@ func UnmarshalReverseProxyConfig(s tunnelrpc.ReverseProxyConfig) (*ReverseProxyC
 			return nil, err
 		}
 		p.Origin = config
-	case tunnelrpc.ReverseProxyConfig_origin_Which_socket:
-		ss, err := s.Origin().Socket()
-		if err != nil {
-			return nil, err
-		}
-		config, err := UnmarshalUnixSocketOriginConfig(ss)
-		if err != nil {
-			return nil, err
-		}
-		p.Origin = config
 	case tunnelrpc.ReverseProxyConfig_origin_Which_websocket:
 		ss, err := s.Origin().Websocket()
 		if err != nil {
@@ -294,28 +337,120 @@ func UnmarshalReverseProxyConfig(s tunnelrpc.ReverseProxyConfig) (*ReverseProxyC
 	}
 	p.Retries = s.Retries()
 	p.ConnectionTimeout = time.Duration(s.ConnectionTimeout())
-	p.ChunkedEncoding = s.ChunkedEncoding()
 	p.CompressionQuality = s.CompressionQuality()
 	return p, nil
 }
 
 func MarshalHTTPOriginConfig(s tunnelrpc.HTTPOriginConfig, p *HTTPOriginConfig) error {
-	return pogs.Insert(tunnelrpc.HTTPOriginConfig_TypeID, s.Struct, p)
+	switch originAddr := p.URL.(type) {
+	case *HTTPURL:
+		ss, err := s.OriginAddr().NewHttp()
+		if err != nil {
+			return err
+		}
+		if err := MarshalHTTPURL(ss, originAddr); err != nil {
+			return err
+		}
+	case *UnixPath:
+		ss, err := s.OriginAddr().NewUnix()
+		if err != nil {
+			return err
+		}
+		if err := MarshalUnixPath(ss, originAddr); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("Unknown type for OriginAddr: %T", originAddr)
+	}
+	s.SetTcpKeepAlive(p.TCPKeepAlive.Nanoseconds())
+	s.SetDialDualStack(p.DialDualStack)
+	s.SetTlsHandshakeTimeout(p.TLSHandshakeTimeout.Nanoseconds())
+	s.SetTlsVerify(p.TLSVerify)
+	s.SetOriginCAPool(p.OriginCAPool)
+	s.SetOriginServerName(p.OriginServerName)
+	s.SetMaxIdleConnections(p.MaxIdleConnections)
+	s.SetIdleConnectionTimeout(p.IdleConnectionTimeout.Nanoseconds())
+	s.SetProxyConnectionTimeout(p.ProxyConnectTimeout.Nanoseconds())
+	s.SetExpectContinueTimeout(p.ExpectContinueTimeout.Nanoseconds())
+	s.SetChunkedEncoding(p.ChunkedEncoding)
+	return nil
 }
 
 func UnmarshalHTTPOriginConfig(s tunnelrpc.HTTPOriginConfig) (*HTTPOriginConfig, error) {
 	p := new(HTTPOriginConfig)
-	err := pogs.Extract(p, tunnelrpc.HTTPOriginConfig_TypeID, s.Struct)
-	return p, err
+	switch s.OriginAddr().Which() {
+	case tunnelrpc.HTTPOriginConfig_originAddr_Which_http:
+		ss, err := s.OriginAddr().Http()
+		if err != nil {
+			return nil, err
+		}
+		originAddr, err := UnmarshalCapnpHTTPURL(ss)
+		if err != nil {
+			return nil, err
+		}
+		p.URL = originAddr
+	case tunnelrpc.HTTPOriginConfig_originAddr_Which_unix:
+		ss, err := s.OriginAddr().Unix()
+		if err != nil {
+			return nil, err
+		}
+		originAddr, err := UnmarshalUnixPath(ss)
+		if err != nil {
+			return nil, err
+		}
+		p.URL = originAddr
+	default:
+		return nil, fmt.Errorf("Unknown type for OriginAddr: %T", s.OriginAddr().Which())
+	}
+	p.TCPKeepAlive = time.Duration(s.TcpKeepAlive())
+	p.DialDualStack = s.DialDualStack()
+	p.TLSHandshakeTimeout = time.Duration(s.TlsHandshakeTimeout())
+	p.TLSVerify = s.TlsVerify()
+	originCAPool, err := s.OriginCAPool()
+	if err != nil {
+		return nil, err
+	}
+	p.OriginCAPool = originCAPool
+	originServerName, err := s.OriginServerName()
+	if err != nil {
+		return nil, err
+	}
+	p.OriginServerName = originServerName
+	p.MaxIdleConnections = s.MaxIdleConnections()
+	p.IdleConnectionTimeout = time.Duration(s.IdleConnectionTimeout())
+	p.ProxyConnectTimeout = time.Duration(s.ProxyConnectionTimeout())
+	p.ExpectContinueTimeout = time.Duration(s.ExpectContinueTimeout())
+	p.ChunkedEncoding = s.ChunkedEncoding()
+	return p, nil
 }
 
-func MarshalUnixSocketOriginConfig(s tunnelrpc.UnixSocketOriginConfig, p *UnixSocketOriginConfig) error {
-	return pogs.Insert(tunnelrpc.UnixSocketOriginConfig_TypeID, s.Struct, p)
+func MarshalHTTPURL(s tunnelrpc.CapnpHTTPURL, p *HTTPURL) error {
+	return pogs.Insert(tunnelrpc.CapnpHTTPURL_TypeID, s.Struct, p.capnpHTTPURL())
 }
 
-func UnmarshalUnixSocketOriginConfig(s tunnelrpc.UnixSocketOriginConfig) (*UnixSocketOriginConfig, error) {
-	p := new(UnixSocketOriginConfig)
-	err := pogs.Extract(p, tunnelrpc.UnixSocketOriginConfig_TypeID, s.Struct)
+func UnmarshalCapnpHTTPURL(s tunnelrpc.CapnpHTTPURL) (*HTTPURL, error) {
+	p := new(CapnpHTTPURL)
+	err := pogs.Extract(p, tunnelrpc.CapnpHTTPURL_TypeID, s.Struct)
+	if err != nil {
+		return nil, err
+	}
+	url, err := url.Parse(p.URL)
+	if err != nil {
+		return nil, err
+	}
+	return &HTTPURL{
+		URL: url,
+	}, nil
+}
+
+func MarshalUnixPath(s tunnelrpc.UnixPath, p *UnixPath) error {
+	err := pogs.Insert(tunnelrpc.UnixPath_TypeID, s.Struct, p)
+	return err
+}
+
+func UnmarshalUnixPath(s tunnelrpc.UnixPath) (*UnixPath, error) {
+	p := new(UnixPath)
+	err := pogs.Extract(p, tunnelrpc.UnixPath_TypeID, s.Struct)
 	return p, err
 }
 
@@ -339,31 +474,30 @@ func UnmarshalHelloWorldOriginConfig(s tunnelrpc.HelloWorldOriginConfig) (*Hello
 	return p, err
 }
 
-type CloudflaredServer interface {
-	UseConfiguration(ctx context.Context, config *CloudflaredConfig) (*CloudflaredConfig, error)
-	GetConfiguration(ctx context.Context) (*CloudflaredConfig, error)
+type ClientService interface {
+	UseConfiguration(ctx context.Context, config *ClientConfig) (*UseConfigurationResult, error)
 }
 
-type CloudflaredServer_PogsClient struct {
+type ClientService_PogsClient struct {
 	Client capnp.Client
 	Conn   *rpc.Conn
 }
 
-func (c *CloudflaredServer_PogsClient) Close() error {
+func (c *ClientService_PogsClient) Close() error {
 	return c.Conn.Close()
 }
 
-func (c *CloudflaredServer_PogsClient) UseConfiguration(
+func (c *ClientService_PogsClient) UseConfiguration(
 	ctx context.Context,
-	config *CloudflaredConfig,
+	config *ClientConfig,
 ) (*UseConfigurationResult, error) {
-	client := tunnelrpc.CloudflaredServer{Client: c.Client}
-	promise := client.UseConfiguration(ctx, func(p tunnelrpc.CloudflaredServer_useConfiguration_Params) error {
-		cloudflaredConfig, err := p.NewCloudflaredConfig()
+	client := tunnelrpc.ClientService{Client: c.Client}
+	promise := client.UseConfiguration(ctx, func(p tunnelrpc.ClientService_useConfiguration_Params) error {
+		clientServiceConfig, err := p.NewClientServiceConfig()
 		if err != nil {
 			return err
 		}
-		return MarshalCloudflaredConfig(cloudflaredConfig, config)
+		return MarshalClientConfig(clientServiceConfig, config)
 	})
 	retval, err := promise.Result().Struct()
 	if err != nil {

tunnelrpc/pogs/config_test.go

@@ -1,6 +1,9 @@
 package pogs
 
 import (
+	"fmt"
+	"net/url"
+	"reflect"
 	"testing"
 	"time"
 
@@ -10,20 +13,22 @@ import (
 	capnp "zombiezen.com/go/capnproto2"
 )
 
-func TestCloudflaredConfig(t *testing.T) {
-	addDoHProxyConfigs := func(c *CloudflaredConfig) {
+func TestClientConfig(t *testing.T) {
+	addDoHProxyConfigs := func(c *ClientConfig) {
 		c.DoHProxyConfigs = []*DoHProxyConfig{
 			sampleDoHProxyConfig(),
 		}
 	}
-	addReverseProxyConfigs := func(c *CloudflaredConfig) {
+	addReverseProxyConfigs := func(c *ClientConfig) {
 		c.ReverseProxyConfigs = []*ReverseProxyConfig{
 			sampleReverseProxyConfig(),
+			sampleReverseProxyConfig(func(c *ReverseProxyConfig) {
+			}),
 			sampleReverseProxyConfig(func(c *ReverseProxyConfig) {
 				c.Origin = sampleHTTPOriginConfig()
 			}),
 			sampleReverseProxyConfig(func(c *ReverseProxyConfig) {
-				c.Origin = sampleUnixSocketOriginConfig()
+				c.Origin = sampleHTTPOriginUnixPathConfig()
 			}),
 			sampleReverseProxyConfig(func(c *ReverseProxyConfig) {
 				c.Origin = sampleWebSocketOriginConfig()
@@ -31,23 +36,23 @@ func TestCloudflaredConfig(t *testing.T) {
 		}
 	}
 
-	testCases := []*CloudflaredConfig{
-		sampleCloudflaredConfig(),
-		sampleCloudflaredConfig(addDoHProxyConfigs),
-		sampleCloudflaredConfig(addReverseProxyConfigs),
-		sampleCloudflaredConfig(addDoHProxyConfigs, addReverseProxyConfigs),
+	testCases := []*ClientConfig{
+		sampleClientConfig(),
+		sampleClientConfig(addDoHProxyConfigs),
+		sampleClientConfig(addReverseProxyConfigs),
+		sampleClientConfig(addDoHProxyConfigs, addReverseProxyConfigs),
 	}
 	for i, testCase := range testCases {
 		_, seg, err := capnp.NewMessage(capnp.SingleSegment(nil))
-		capnpEntity, err := tunnelrpc.NewCloudflaredConfig(seg)
+		capnpEntity, err := tunnelrpc.NewClientConfig(seg)
 		if !assert.NoError(t, err) {
 			t.Fatal("Couldn't initialize a new message")
 		}
-		err = MarshalCloudflaredConfig(capnpEntity, testCase)
+		err = MarshalClientConfig(capnpEntity, testCase)
 		if !assert.NoError(t, err, "testCase index %v failed to marshal", i) {
 			continue
 		}
-		result, err := UnmarshalCloudflaredConfig(capnpEntity)
+		result, err := UnmarshalClientConfig(capnpEntity)
 		if !assert.NoError(t, err, "testCase index %v failed to unmarshal", i) {
 			continue
 		}
@@ -115,7 +120,7 @@ func TestReverseProxyConfig(t *testing.T) {
 			c.Origin = sampleHTTPOriginConfig()
 		}),
 		sampleReverseProxyConfig(func(c *ReverseProxyConfig) {
-			c.Origin = sampleUnixSocketOriginConfig()
+			c.Origin = sampleHTTPOriginUnixPathConfig()
 		}),
 		sampleReverseProxyConfig(func(c *ReverseProxyConfig) {
 			c.Origin = sampleWebSocketOriginConfig()
@@ -161,28 +166,6 @@ func TestHTTPOriginConfig(t *testing.T) {
 	}
 }
 
-func TestUnixSocketOriginConfig(t *testing.T) {
-	testCases := []*UnixSocketOriginConfig{
-		sampleUnixSocketOriginConfig(),
-	}
-	for i, testCase := range testCases {
-		_, seg, err := capnp.NewMessage(capnp.SingleSegment(nil))
-		capnpEntity, err := tunnelrpc.NewUnixSocketOriginConfig(seg)
-		if !assert.NoError(t, err) {
-			t.Fatal("Couldn't initialize a new message")
-		}
-		err = MarshalUnixSocketOriginConfig(capnpEntity, testCase)
-		if !assert.NoError(t, err, "testCase index %v failed to marshal", i) {
-			continue
-		}
-		result, err := UnmarshalUnixSocketOriginConfig(capnpEntity)
-		if !assert.NoError(t, err, "testCase index %v failed to unmarshal", i) {
-			continue
-		}
-		assert.Equal(t, testCase, result, "testCase index %v didn't preserve struct through marshalling and unmarshalling", i)
-	}
-}
-
 func TestWebSocketOriginConfig(t *testing.T) {
 	testCases := []*WebSocketOriginConfig{
 		sampleWebSocketOriginConfig(),
@@ -208,18 +191,17 @@ func TestWebSocketOriginConfig(t *testing.T) {
 //////////////////////////////////////////////////////////////////////////////
 // Functions to generate sample data for ease of testing
 
-func sampleCloudflaredConfig(overrides ...func(*CloudflaredConfig)) *CloudflaredConfig {
-	// strip the location and monotonic clock reading so that assert.Equals()
-	// will work correctly
-	now := time.Now().UTC().Round(0)
-	sample := &CloudflaredConfig{
-		Timestamp:              now,
+func sampleClientConfig(overrides ...func(*ClientConfig)) *ClientConfig {
+	sample := &ClientConfig{
+		Version:                uint64(1337),
 		AutoUpdateFrequency:    21 * time.Hour,
 		MetricsUpdateFrequency: 11 * time.Minute,
 		HeartbeatInterval:      5 * time.Second,
 		MaxFailedHeartbeats:    9001,
 		GracePeriod:            31 * time.Second,
+		NumHAConnections:       49,
 	}
+	sample.ensureNoZeroFields()
 	for _, f := range overrides {
 		f(sample)
 	}
@@ -232,6 +214,7 @@ func sampleDoHProxyConfig(overrides ...func(*DoHProxyConfig)) *DoHProxyConfig {
 		ListenPort: 53,
 		Upstreams:  []string{"https://1.example.com", "https://2.example.com"},
 	}
+	sample.ensureNoZeroFields()
 	for _, f := range overrides {
 		f(sample)
 	}
@@ -240,13 +223,13 @@ func sampleDoHProxyConfig(overrides ...func(*DoHProxyConfig)) *DoHProxyConfig {
 
 func sampleReverseProxyConfig(overrides ...func(*ReverseProxyConfig)) *ReverseProxyConfig {
 	sample := &ReverseProxyConfig{
-		TunnelID:           "hijk",
+		TunnelHostname:     "hijk.example.com",
 		Origin:             &HelloWorldOriginConfig{},
 		Retries:            18,
 		ConnectionTimeout:  5 * time.Second,
-		ChunkedEncoding:    false,
 		CompressionQuality: 4,
 	}
+	sample.ensureNoZeroFields()
 	for _, f := range overrides {
 		f(sample)
 	}
@@ -255,7 +238,12 @@ func sampleReverseProxyConfig(overrides ...func(*ReverseProxyConfig)) *ReversePr
 
 func sampleHTTPOriginConfig(overrides ...func(*HTTPOriginConfig)) *HTTPOriginConfig {
 	sample := &HTTPOriginConfig{
-		URL:                   "https://example.com",
+		URL: &HTTPURL{
+			URL: &url.URL{
+				Scheme: "https",
+				Host:   "example.com",
+			},
+		},
 		TCPKeepAlive:          7 * time.Second,
 		DialDualStack:         true,
 		TLSHandshakeTimeout:   11 * time.Second,
@@ -264,17 +252,35 @@ func sampleHTTPOriginConfig(overrides ...func(*HTTPOriginConfig)) *HTTPOriginCon
 		OriginServerName:      "secure.example.com",
 		MaxIdleConnections:    19,
 		IdleConnectionTimeout: 17 * time.Second,
+		ProxyConnectTimeout:   15 * time.Second,
+		ExpectContinueTimeout: 21 * time.Second,
+		ChunkedEncoding:       true,
 	}
+	sample.ensureNoZeroFields()
 	for _, f := range overrides {
 		f(sample)
 	}
 	return sample
 }
 
-func sampleUnixSocketOriginConfig(overrides ...func(*UnixSocketOriginConfig)) *UnixSocketOriginConfig {
-	sample := &UnixSocketOriginConfig{
-		Path: "/var/lib/file.sock",
+func sampleHTTPOriginUnixPathConfig(overrides ...func(*HTTPOriginConfig)) *HTTPOriginConfig {
+	sample := &HTTPOriginConfig{
+		URL: &UnixPath{
+			Path: "/var/lib/file.sock",
+		},
+		TCPKeepAlive:          7 * time.Second,
+		DialDualStack:         true,
+		TLSHandshakeTimeout:   11 * time.Second,
+		TLSVerify:             true,
+		OriginCAPool:          "/etc/cert.pem",
+		OriginServerName:      "secure.example.com",
+		MaxIdleConnections:    19,
+		IdleConnectionTimeout: 17 * time.Second,
+		ProxyConnectTimeout:   15 * time.Second,
+		ExpectContinueTimeout: 21 * time.Second,
+		ChunkedEncoding:       true,
 	}
+	sample.ensureNoZeroFields()
 	for _, f := range overrides {
 		f(sample)
 	}
@@ -283,10 +289,72 @@ func sampleUnixSocketOriginConfig(overrides ...func(*UnixSocketOriginConfig)) *U
 
 func sampleWebSocketOriginConfig(overrides ...func(*WebSocketOriginConfig)) *WebSocketOriginConfig {
 	sample := &WebSocketOriginConfig{
-		URL: "ssh://example.com",
+		URL:              "ssh://example.com",
+		TLSVerify:        true,
+		OriginCAPool:     "/etc/cert.pem",
+		OriginServerName: "secure.example.com",
 	}
+	sample.ensureNoZeroFields()
 	for _, f := range overrides {
 		f(sample)
 	}
 	return sample
 }
+
+func (c *ClientConfig) ensureNoZeroFields() {
+	ensureNoZeroFieldsInSample(reflect.ValueOf(c), []string{"DoHProxyConfigs", "ReverseProxyConfigs"})
+}
+
+func (c *DoHProxyConfig) ensureNoZeroFields() {
+	ensureNoZeroFieldsInSample(reflect.ValueOf(c), []string{})
+}
+
+func (c *ReverseProxyConfig) ensureNoZeroFields() {
+	ensureNoZeroFieldsInSample(reflect.ValueOf(c), []string{})
+}
+
+func (c *HTTPOriginConfig) ensureNoZeroFields() {
+	ensureNoZeroFieldsInSample(reflect.ValueOf(c), []string{})
+}
+
+func (c *WebSocketOriginConfig) ensureNoZeroFields() {
+	ensureNoZeroFieldsInSample(reflect.ValueOf(c), []string{})
+}
+
+// ensureNoZeroFieldsInSample checks that all fields in the sample struct,
+// except those listed in `allowedZeroFieldNames`, are initialized to nonzero
+// values. Note that the value has to be a pointer for reflection to work
+// correctly:
+//     e := &ExampleStruct{ ... }
+//     ensureNoZeroFieldsInSample(reflect.ValueOf(e), []string{})
+//
+// Context:
+// Our tests work by taking a sample struct and marshalling/unmarshalling it.
+// This makes them easy to write, but introduces some risk: if we don't
+// include a field in the sample value, it won't be covered under tests.
+// This check reduces that risk by requiring fields to be either initialized
+// or explicitly uninitialized.
+// https://bitbucket.cfdata.org/projects/TUN/repos/cloudflared/pull-requests/151/overview?commentId=348012
+func ensureNoZeroFieldsInSample(ptrToSampleValue reflect.Value, allowedZeroFieldNames []string) {
+	sampleValue := ptrToSampleValue.Elem()
+	structType := ptrToSampleValue.Type().Elem()
+
+	allowedZeroFieldSet := make(map[string]bool)
+	for _, name := range allowedZeroFieldNames {
+		if _, ok := structType.FieldByName(name); !ok {
+			panic(fmt.Sprintf("struct %v has no field %v", structType.Name(), name))
+		}
+		allowedZeroFieldSet[name] = true
+	}
+
+	for i := 0; i < structType.NumField(); i++ {
+		if allowedZeroFieldSet[structType.Field(i).Name] {
+			continue
+		}
+
+		zeroValue := reflect.Zero(structType.Field(i).Type)
+		if reflect.DeepEqual(zeroValue.Interface(), sampleValue.Field(i).Interface()) {
+			panic(fmt.Sprintf("In the sample value for struct %v, field %v was not initialized", structType.Name(), structType.Field(i).Name))
+		}
+	}
+}

tunnelrpc/tunnelrpc.capnp

@@ -72,10 +72,11 @@ struct ConnectError {
     shouldRetry @2 :Bool;
 }
 
-struct CloudflaredConfig {
-    # Timestamp (in ns) of this configuration. Any configuration supplied to
-    # useConfiguration() with an older timestamp should be ignored.
-    timestamp @0 :Int64;
+struct ClientConfig {
+    # Version of this configuration. This value is opaque, but is guaranteed
+    # to monotonically increase in value. Any configuration supplied to
+    # useConfiguration() with a smaller `version` should be ignored.
+    version @0 :UInt64;
     # Frequency (in ns) to check Equinox for updates.
     # Zero means auto-update is disabled.
     # cloudflared CLI option: `autoupdate-freq`
@@ -101,69 +102,42 @@ struct CloudflaredConfig {
     dohProxyConfigs @6 :List(DoHProxyConfig);
     # Configuration for cloudflared to run as an HTTP reverse proxy.
     reverseProxyConfigs @7 :List(ReverseProxyConfig);
+    # Number of persistent connections to keep open between cloudflared and
+    # the edge.
+    # cloudflared CLI option: `ha-connections`
+    numHAConnections @8 :UInt8;
 }
 
 struct ReverseProxyConfig {
-    tunnelID @0 :Text;
+    tunnelHostname @0 :Text;
     origin :union {
         http @1 :HTTPOriginConfig;
-        socket @2 :UnixSocketOriginConfig;
-        websocket @3 :WebSocketOriginConfig;
-        helloWorld @4 :HelloWorldOriginConfig;
+        websocket @2 :WebSocketOriginConfig;
+        helloWorld @3 :HelloWorldOriginConfig;
     }
     # Maximum number of retries for connection/protocol errors.
     # cloudflared CLI option: `retries`
-    retries @5 :UInt64;
+    retries @4 :UInt64;
     # maximum time (in ns) for cloudflared to wait to establish a connection
     # to the origin. Zero means no timeout.
     # cloudflared CLI option: `proxy-connect-timeout`
-    connectionTimeout @6 :Int64;
-    # Whether cloudflared should allow chunked transfer encoding to the
-    # origin. (This should be disabled for WSGI origins, for example.)
-    # negation of cloudflared CLI option: `no-chunked-encoding`
-    chunkedEncoding @7 :Bool;
+    connectionTimeout @5 :Int64;
     # (beta) Use cross-stream compression instead of HTTP compression.
     # 0=off, 1=low, 2=medium, 3=high.
     # For more context see the mapping here: https://github.com/cloudflare/cloudflared/blob/2019.3.2/h2mux/h2_dictionaries.go#L62
     # cloudflared CLI option: `compression-quality`
-    compressionQuality @8 :UInt64;
+    compressionQuality @6 :UInt64;
 }
 
-struct UnixSocketOriginConfig {
-    # path to the socket file.
-    # cloudflared will send data to this socket via a Unix socket connection.
-    # cloudflared CLI option: `unix-socket`
-    path @0 :Text;
-}
-
-#
 struct WebSocketOriginConfig {
     # URI of the origin service.
     # cloudflared will start a websocket server that forwards data to this URI
     # cloudflared CLI option: `url`
     # cloudflared logic: https://github.com/cloudflare/cloudflared/blob/2019.3.2/cmd/cloudflared/tunnel/cmd.go#L304
     url @0 :Text;
-}
-
-struct HTTPOriginConfig {
-    # HTTP(S) URL of the origin service.
-    # cloudflared CLI option: `url`
-    url @0 :Text;
-    # the TCP keep-alive period (in ns) for an active network connection.
-    # Zero means keep-alives are not enabled.
-    # cloudflared CLI option: `proxy-tcp-keepalive`
-    tcpKeepAlive @1 :Int64;
-    # whether cloudflared should use a "happy eyeballs"-compliant procedure
-    # to connect to origins that resolve to both IPv4 and IPv6 addresses
-    # negation of cloudflared CLI option: `proxy-no-happy-eyeballs`
-    dialDualStack @2 :Bool;
-    # maximum time (in ns) for cloudflared to wait for a TLS handshake
-    # with the origin. Zero means no timeout.
-    # cloudflared CLI option: `proxy-tls-timeout`
-    tlsHandshakeTimeout @3 :Int64;
     # Whether cloudflared should verify TLS connections to the origin.
     # negation of cloudflared CLI option: `no-tls-verify`
-    tlsVerify @4 :Bool;
+    tlsVerify @1 :Bool;
     # originCAPool specifies the root CA that cloudflared should use when
     # verifying TLS connections to the origin.
     #   - if tlsVerify is false, originCAPool will be ignored.
@@ -172,18 +146,75 @@ struct HTTPOriginConfig {
     #   - if tlsVerify is true and originCAPool is non-empty, cloudflared will
     #     treat it as the filepath to the root CA.
     # cloudflared CLI option: `origin-ca-pool`
-    originCAPool @5 :Text;
+    originCAPool @2 :Text;
     # Hostname to use when verifying TLS connections to the origin.
     # cloudflared CLI option: `origin-server-name`
-    originServerName @6 :Text;
+    originServerName @3 :Text;
+}
+
+struct HTTPOriginConfig {
+    # HTTP(S) URL of the origin service.
+    # cloudflared CLI option: `url`
+    originAddr :union {
+        http @0 :CapnpHTTPURL;
+        unix @1 :UnixPath;
+    }
+    # the TCP keep-alive period (in ns) for an active network connection.
+    # Zero means keep-alives are not enabled.
+    # cloudflared CLI option: `proxy-tcp-keepalive`
+    tcpKeepAlive @2 :Int64;
+    # whether cloudflared should use a "happy eyeballs"-compliant procedure
+    # to connect to origins that resolve to both IPv4 and IPv6 addresses
+    # negation of cloudflared CLI option: `proxy-no-happy-eyeballs`
+    dialDualStack @3 :Bool;
+    # maximum time (in ns) for cloudflared to wait for a TLS handshake
+    # with the origin. Zero means no timeout.
+    # cloudflared CLI option: `proxy-tls-timeout`
+    tlsHandshakeTimeout @4 :Int64;
+    # Whether cloudflared should verify TLS connections to the origin.
+    # negation of cloudflared CLI option: `no-tls-verify`
+    tlsVerify @5 :Bool;
+    # originCAPool specifies the root CA that cloudflared should use when
+    # verifying TLS connections to the origin.
+    #   - if tlsVerify is false, originCAPool will be ignored.
+    #   - if tlsVerify is true and originCAPool is empty, the system CA pool
+    #     will be loaded if possible.
+    #   - if tlsVerify is true and originCAPool is non-empty, cloudflared will
+    #     treat it as the filepath to the root CA.
+    # cloudflared CLI option: `origin-ca-pool`
+    originCAPool @6 :Text;
+    # Hostname to use when verifying TLS connections to the origin.
+    # cloudflared CLI option: `origin-server-name`
+    originServerName @7 :Text;
     # maximum number of idle (keep-alive) connections for cloudflared to
     # keep open with the origin. Zero means no limit.
     # cloudflared CLI option: `proxy-keepalive-connections`
-    maxIdleConnections @7 :UInt64;
+    maxIdleConnections @8 :UInt64;
     # maximum time (in ns) for an idle (keep-alive) connection to remain
     # idle before closing itself. Zero means no timeout.
     # cloudflared CLI option: `proxy-keepalive-timeout`
-    idleConnectionTimeout @8 :Int64;
+    idleConnectionTimeout @9 :Int64;
+    # maximum amount of time a dial will wait for a connect to complete.
+    proxyConnectionTimeout @10 :Int64;
+    # The amount of time to wait for origin's first response headers after fully
+    # writing the request headers if the request has an "Expect: 100-continue" header.
+    # Zero means no timeout and causes the body to be sent immediately, without
+    # waiting for the server to approve.
+    expectContinueTimeout @11 :Int64;
+    # Whether cloudflared should allow chunked transfer encoding to the
+    # origin. (This should be disabled for WSGI origins, for example.)
+    # negation of cloudflared CLI option: `no-chunked-encoding`
+	chunkedEncoding @12 :Bool;
+}
+
+# URL for a HTTP origin, capnp doesn't have native support for URL, so represent it as Text
+struct CapnpHTTPURL {
+    url @0: Text;
+}
+
+# Path to a unix socket
+struct UnixPath {
+    path @0: Text;
 }
 
 # configuration for cloudflared to provide a DNS over HTTPS proxy server
@@ -230,6 +261,6 @@ interface TunnelServer {
     connect @3 (parameters :CapnpConnectParameters) -> (result :ConnectResult);
 }
 
-interface CloudflaredServer {
-    useConfiguration @0 (cloudflaredConfig :CloudflaredConfig) -> (result :UseConfigurationResult);
+interface ClientService {
+    useConfiguration @0 (clientServiceConfig :ClientConfig) -> (result :UseConfigurationResult);
 }