xrootd/{client,protocol}: add protocol request

xrootd/client/client.go

@@ -35,10 +35,11 @@ import (
 // Concurrent requests are supported.
 // Zero value is invalid, Client should be instantiated using NewClient.
 type Client struct {
-	cancel          context.CancelFunc
-	conn            net.Conn
-	mux             *mux.Mux
-	protocolVersion int32
+	cancel           context.CancelFunc
+	conn             net.Conn
+	mux              *mux.Mux
+	protocolVersion  int32
+	signRequirements protocol.SignRequirements
 }
 
 // NewClient creates a new xrootd client that connects to the given address.
@@ -54,7 +55,7 @@ func NewClient(ctx context.Context, address string) (*Client, error) {
 		return nil, err
 	}
 
-	client := &Client{cancel, conn, mux.New(), 0}
+	client := &Client{cancel: cancel, conn: conn, mux: mux.New()}
 
 	go client.consume(ctx)
 
@@ -63,6 +64,14 @@ func NewClient(ctx context.Context, address string) (*Client, error) {
 		return nil, err
 	}
 
+	protocolInfo, err := client.Protocol(ctx)
+	if err != nil {
+		client.Close()
+		return nil, err
+	}
+
+	client.signRequirements = protocol.NewSignRequirements(protocolInfo.SecurityLevel, protocolInfo.SecurityOverrides)
+
 	return client, nil
 }
 

xrootd/client/main_mock_test.go

@@ -0,0 +1,91 @@
+// Copyright 2018 The go-hep Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package client // import "go-hep.org/x/hep/xrootd/client"
+
+import (
+	"context"
+	"encoding/binary"
+	"io"
+	"net"
+
+	"github.com/pkg/errors"
+	"go-hep.org/x/hep/xrootd/internal/mux"
+	"go-hep.org/x/hep/xrootd/protocol"
+)
+
+func testClientWithMockServer(serverFunc func(cancel func(), conn net.Conn), clientFunc func(cancel func(), client *Client)) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	server, conn := net.Pipe()
+	defer server.Close()
+	defer conn.Close()
+
+	client := &Client{cancel: cancel, conn: conn, mux: mux.New(), signRequirements: protocol.DefaultSignRequirements()}
+	defer client.Close()
+
+	go serverFunc(func() { client.Close() }, server)
+	go client.consume(ctx)
+
+	clientFunc(cancel, client)
+}
+
+func readRequest(conn net.Conn) ([]byte, error) {
+	// 16 is for the request options and 4 is for the data length
+	const requestSize = protocol.RequestHeaderLength + 16 + 4
+	var request = make([]byte, requestSize)
+	if _, err := io.ReadFull(conn, request); err != nil {
+		return nil, err
+	}
+
+	dataLength := binary.BigEndian.Uint32(request[protocol.RequestHeaderLength+16:])
+	if dataLength == 0 {
+		return request, nil
+	}
+
+	var data = make([]byte, dataLength)
+	if _, err := io.ReadFull(conn, data); err != nil {
+		return nil, err
+	}
+
+	return append(request, data...), nil
+}
+
+func writeResponse(conn net.Conn, data []byte) error {
+	n, err := conn.Write(data)
+	if err != nil {
+		return err
+	}
+	if n != len(data) {
+		return errors.Errorf("could not write all %d bytes: wrote %d", len(data), n)
+	}
+	return nil
+}
+
+// TODO: move marshalResponse outside of main_mock_test.go and use it for server implementation.
+func marshalResponse(responseParts ...interface{}) ([]byte, error) {
+	var data []byte
+	for _, p := range responseParts {
+		pData, err := protocol.Marshal(p)
+		if err != nil {
+			return nil, err
+		}
+		data = append(data, pData...)
+	}
+	return data, nil
+}
+
+// TODO: move unmarshalRequest outside of main_mock_test.go and use it for server implementation.
+func unmarshalRequest(data []byte, request interface{}) (protocol.RequestHeader, error) {
+	var header protocol.RequestHeader
+	if err := protocol.Unmarshal(data[:protocol.RequestHeaderLength], &header); err != nil {
+		return protocol.RequestHeader{}, err
+	}
+	if err := protocol.Unmarshal(data[protocol.RequestHeaderLength:], request); err != nil {
+		return protocol.RequestHeader{}, err
+	}
+
+	return header, nil
+}

xrootd/client/protocol.go

@@ -0,0 +1,93 @@
+// Copyright 2018 The go-hep Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package client // import "go-hep.org/x/hep/xrootd/client"
+
+import (
+	"context"
+
+	xrdproto "go-hep.org/x/hep/xrootd/protocol"
+	"go-hep.org/x/hep/xrootd/protocol/protocol"
+)
+
+// ProtocolInfo is a response for the `Protocol` request. See details in the xrootd protocol specification.
+type ProtocolInfo struct {
+	BinaryProtocolVersion int32
+	ServerType            xrdproto.ServerType
+	IsManager             bool
+	IsServer              bool
+	IsMeta                bool
+	IsProxy               bool
+	IsSupervisor          bool
+	SecurityVersion       byte
+	ForceSecurity         bool
+	SecurityLevel         protocol.SecurityLevel
+	SecurityOverrides     []protocol.SecurityOverride
+}
+
+// Protocol obtains the protocol version number, type of the server and security information, such as:
+// the security version, the security options, the security level, and the list of alterations
+// needed to the specified predefined security level.
+func (client *Client) Protocol(ctx context.Context) (ProtocolInfo, error) {
+	resp, err := client.call(ctx, protocol.RequestID, protocol.NewRequest(client.protocolVersion, true))
+	if err != nil {
+		return ProtocolInfo{}, err
+	}
+
+	var generalResp protocol.GeneralResponse
+
+	if err = xrdproto.Unmarshal(resp, &generalResp); err != nil {
+		return ProtocolInfo{}, err
+	}
+
+	var securityInfo *protocol.SecurityInfo
+	if len(resp) > protocol.GeneralResponseLength {
+		securityInfo = &protocol.SecurityInfo{}
+		err = xrdproto.Unmarshal(resp[protocol.GeneralResponseLength:], securityInfo)
+		if err != nil {
+			return ProtocolInfo{}, err
+		}
+	}
+
+	var info = ProtocolInfo{
+		BinaryProtocolVersion: generalResp.BinaryProtocolVersion,
+		ServerType:            extractServerType(generalResp.Flags),
+
+		// TODO: implement bit-encoded fields support in Unmarshal.
+		IsManager:    generalResp.Flags&protocol.IsManager != 0,
+		IsServer:     generalResp.Flags&protocol.IsServer != 0,
+		IsMeta:       generalResp.Flags&protocol.IsMeta != 0,
+		IsProxy:      generalResp.Flags&protocol.IsProxy != 0,
+		IsSupervisor: generalResp.Flags&protocol.IsSupervisor != 0,
+	}
+
+	if securityInfo != nil {
+		info.SecurityVersion = securityInfo.SecurityVersion
+		info.ForceSecurity = securityInfo.SecurityOptions&protocol.ForceSecurity != 0
+		info.SecurityLevel = securityInfo.SecurityLevel
+
+		if securityInfo.SecurityOverridesSize > 0 {
+			info.SecurityOverrides = make([]protocol.SecurityOverride, securityInfo.SecurityOverridesSize)
+
+			const offset = protocol.GeneralResponseLength + protocol.SecurityInfoLength
+			const elementSize = protocol.SecurityOverrideLength
+
+			for i := byte(0); i < securityInfo.SecurityOverridesSize; i++ {
+				err = xrdproto.Unmarshal(resp[offset+elementSize*int(i):], &info.SecurityOverrides[i])
+				if err != nil {
+					return ProtocolInfo{}, err
+				}
+			}
+		}
+	}
+
+	return info, nil
+}
+
+func extractServerType(flags protocol.Flags) xrdproto.ServerType {
+	if int32(flags)&int32(xrdproto.DataServer) != 0 {
+		return xrdproto.DataServer
+	}
+	return xrdproto.LoadBalancingServer
+}

xrootd/client/protocol_mock_test.go

@@ -0,0 +1,93 @@
+// Copyright 2018 The go-hep Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package client
+
+import (
+	"context"
+	"net"
+	"reflect"
+	"testing"
+
+	xrdproto "go-hep.org/x/hep/xrootd/protocol"
+	"go-hep.org/x/hep/xrootd/protocol/protocol"
+)
+
+func TestClient_Protocol_WithSecurityInfo(t *testing.T) {
+	var protocolVersion int32 = 0x310
+
+	serverFunc := func(cancel func(), conn net.Conn) {
+		defer cancel()
+
+		data, err := readRequest(conn)
+		if err != nil {
+			t.Fatalf("could not read request: %v", err)
+		}
+
+		var gotRequest protocol.Request
+		gotHeader, err := unmarshalRequest(data, &gotRequest)
+		if err != nil {
+			t.Fatalf("could not unmarshal request: %v", err)
+		}
+
+		if gotHeader.RequestID != protocol.RequestID {
+			t.Fatalf("invalid request id was specified:\nwant = %d\ngot = %d\n", protocol.RequestID, gotHeader.RequestID)
+		}
+
+		if gotRequest.ClientProtocolVersion != protocolVersion {
+			t.Fatalf("invalid client protocol version was specified:\nwant = %d\ngot = %d\n", protocolVersion, gotRequest.ClientProtocolVersion)
+		}
+
+		flags := protocol.IsManager | protocol.IsServer | protocol.IsMeta | protocol.IsProxy | protocol.IsSupervisor
+
+		responseHeader := xrdproto.ResponseHeader{
+			StreamID:   gotHeader.StreamID,
+			DataLength: protocol.GeneralResponseLength + protocol.SecurityInfoLength + protocol.SecurityOverrideLength,
+		}
+
+		protocolResponse := protocol.GeneralResponse{protocolVersion, flags}
+
+		protocolSecurityInfo := protocol.SecurityInfo{
+			SecurityOptions:       protocol.None,
+			SecurityLevel:         protocol.Pedantic,
+			SecurityOverridesSize: 1,
+		}
+
+		securityOverride := protocol.SecurityOverride{1, protocol.SignNeeded}
+
+		response, err := marshalResponse(responseHeader, protocolResponse, protocolSecurityInfo, securityOverride)
+		if err != nil {
+			t.Fatalf("could not marshal response: %v", err)
+		}
+
+		if err := writeResponse(conn, response); err != nil {
+			t.Fatalf("invalid write: %s", err)
+		}
+	}
+
+	var want = ProtocolInfo{
+		BinaryProtocolVersion: protocolVersion,
+		ServerType:            xrdproto.DataServer,
+		IsManager:             true,
+		IsServer:              true,
+		IsMeta:                true,
+		IsProxy:               true,
+		IsSupervisor:          true,
+		SecurityLevel:         protocol.Pedantic,
+		SecurityOverrides:     []protocol.SecurityOverride{{1, protocol.SignNeeded}},
+	}
+
+	clientFunc := func(cancel func(), client *Client) {
+		client.protocolVersion = protocolVersion
+		got, err := client.Protocol(context.Background())
+		if err != nil {
+			t.Fatalf("invalid protocol call: %v", err)
+		}
+		if !reflect.DeepEqual(got, want) {
+			t.Fatalf("protocol info does not match:\ngot = %v\nwant = %v", got, want)
+		}
+	}
+
+	testClientWithMockServer(serverFunc, clientFunc)
+}

xrootd/client/protocol_test.go

@@ -0,0 +1,46 @@
+// Copyright 2018 The go-hep Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build xrootd_test_with_server
+
+package client
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-hep.org/x/hep/xrootd/protocol"
+)
+
+func testClient_Protocol(t *testing.T, addr string) {
+	var want = ProtocolInfo{
+		BinaryProtocolVersion: 784,
+		ServerType:            protocol.DataServer,
+		IsServer:              true,
+	}
+
+	client, err := NewClient(context.Background(), addr)
+	if err != nil {
+		t.Fatalf("could not create client: %v", err)
+	}
+
+	got, err := client.Protocol(context.Background())
+	if err != nil {
+		t.Fatalf("invalid protocol call: %v", err)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("Client.Protocol()\ngot = %v\nwant = %v", got, want)
+	}
+
+	client.Close()
+}
+
+func TestClient_Protocol(t *testing.T) {
+	for _, addr := range testClientAddrs {
+		t.Run(addr, func(t *testing.T) {
+			testClient_Protocol(t, addr)
+		})
+	}
+}

xrootd/protocol/handshake/handshake.go

@@ -6,22 +6,13 @@
 // for handshake request (see XRootD specification).
 package handshake // import "go-hep.org/x/hep/xrootd/protocol/handshake"
 
-// ServerType is the general server type kept for compatibility
-// with 2.0 protocol version (see xrootd protocol specification v3.1.0, p. 5).
-type ServerType int32
-
-const (
-	// LoadBalancingServer indicates whether this is a load-balancing server.
-	LoadBalancingServer ServerType = iota
-	// DataServer indicates whether this is a data server.
-	DataServer ServerType = iota
-)
+import "go-hep.org/x/hep/xrootd/protocol"
 
 // Response is a response for the handshake request,
 // which contains protocol version and server type.
 type Response struct {
 	ProtocolVersion int32
-	ServerType      ServerType
+	ServerType      protocol.ServerType
 }
 
 // Request holds the handshake request parameters.