server_integration_test.go - third_party/pkg/sftp - Git at Google

 package sftp

 // sftp server integration tests
 // enable with -integration
 // example invokation (darwin): gofmt -w `find . -name \*.go` && (cd server_standalone/ ; go build -tags debug) && go test -tags debug github.com/pkg/sftp -integration -v -sftp /usr/libexec/sftp-server -run ServerCompareSubsystems

 import (
 	"bytes"
 	"encoding/hex"
 	"flag"
 	"fmt"
 	"io/ioutil"
 	"math/rand"
 	"net"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 	"testing"
 	"time"

 	"github.com/kr/fs"
 	"golang.org/x/crypto/ssh"
 )

 var testSftpClientBin = flag.String("sftp_client", "/usr/bin/sftp", "location of the sftp client binary")
 var sshServerDebugStream = ioutil.Discard
 var sftpServerDebugStream = ioutil.Discard
 var sftpClientDebugStream = ioutil.Discard

 const (
 	GOLANG_SFTP  = true
 	OPENSSH_SFTP = false
 )

 var (
 	hostPrivateKeySigner ssh.Signer
 	privKey              = []byte(`
 -----BEGIN RSA PRIVATE KEY-----
 MIIEowIBAAKCAQEArhp7SqFnXVZAgWREL9Ogs+miy4IU/m0vmdkoK6M97G9NX/Pj
 wf8I/3/ynxmcArbt8Rc4JgkjT2uxx/NqR0yN42N1PjO5Czu0dms1PSqcKIJdeUBV
 7gdrKSm9Co4d2vwfQp5mg47eG4w63pz7Drk9+VIyi9YiYH4bve7WnGDswn4ycvYZ
 slV5kKnjlfCdPig+g5P7yQYud0cDWVwyA0+kxvL6H3Ip+Fu8rLDZn4/P1WlFAIuc
 PAf4uEKDGGmC2URowi5eesYR7f6GN/HnBs2776laNlAVXZUmYTUfOGagwLsEkx8x
 XdNqntfbs2MOOoK+myJrNtcB9pCrM0H6um19uQIDAQABAoIBABkWr9WdVKvalgkP
 TdQmhu3mKRNyd1wCl+1voZ5IM9Ayac/98UAvZDiNU4Uhx52MhtVLJ0gz4Oa8+i16
 IkKMAZZW6ro/8dZwkBzQbieWUFJ2Fso2PyvB3etcnGU8/Yhk9IxBDzy+BbuqhYE2
 1ebVQtz+v1HvVZzaD11bYYm/Xd7Y28QREVfFen30Q/v3dv7dOteDE/RgDS8Czz7w
 jMW32Q8JL5grz7zPkMK39BLXsTcSYcaasT2ParROhGJZDmbgd3l33zKCVc1zcj9B
 SA47QljGd09Tys958WWHgtj2o7bp9v1Ufs4LnyKgzrB80WX1ovaSQKvd5THTLchO
 kLIhUAECgYEA2doGXy9wMBmTn/hjiVvggR1aKiBwUpnB87Hn5xCMgoECVhFZlT6l
 WmZe7R2klbtG1aYlw+y+uzHhoVDAJW9AUSV8qoDUwbRXvBVlp+In5wIqJ+VjfivK
 zgIfzomL5NvDz37cvPmzqIeySTowEfbQyq7CUQSoDtE9H97E2wWZhDkCgYEAzJdJ
 k+NSFoTkHhfD3L0xCDHpRV3gvaOeew8524fVtVUq53X8m91ng4AX1r74dCUYwwiF
 gqTtSSJfx2iH1xKnNq28M9uKg7wOrCKrRqNPnYUO3LehZEC7rwUr26z4iJDHjjoB
 uBcS7nw0LJ+0Zeg1IF+aIdZGV3MrAKnrzWPixYECgYBsffX6ZWebrMEmQ89eUtFF
 u9ZxcGI/4K8ErC7vlgBD5ffB4TYZ627xzFWuBLs4jmHCeNIJ9tct5rOVYN+wRO1k
 /CRPzYUnSqb+1jEgILL6istvvv+DkE+ZtNkeRMXUndWwel94BWsBnUKe0UmrSJ3G
 sq23J3iCmJW2T3z+DpXbkQKBgQCK+LUVDNPE0i42NsRnm+fDfkvLP7Kafpr3Umdl
 tMY474o+QYn+wg0/aPJIf9463rwMNyyhirBX/k57IIktUdFdtfPicd2MEGETElWv
 nN1GzYxD50Rs2f/jKisZhEwqT9YNyV9DkgDdGGdEbJNYqbv0qpwDIg8T9foe8E1p
 bdErgQKBgAt290I3L316cdxIQTkJh1DlScN/unFffITwu127WMr28Jt3mq3cZpuM
 Aecey/eEKCj+Rlas5NDYKsB18QIuAw+qqWyq0LAKLiAvP1965Rkc4PLScl3MgJtO
 QYa37FK0p8NcDeUuF86zXBVutwS5nJLchHhKfd590ks57OROtm29
 -----END RSA PRIVATE KEY-----
 `)
 )

 func init() {
 	var err error
 	hostPrivateKeySigner, err = ssh.ParsePrivateKey(privKey)
 	if err != nil {
 		panic(err)
 	}
 }

 func keyAuth(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
 	permissions := &ssh.Permissions{
 		CriticalOptions: map[string]string{},
 		Extensions:      map[string]string{},
 	}
 	return permissions, nil
 }

 func pwAuth(conn ssh.ConnMetadata, pw []byte) (*ssh.Permissions, error) {
 	permissions := &ssh.Permissions{
 		CriticalOptions: map[string]string{},
 		Extensions:      map[string]string{},
 	}
 	return permissions, nil
 }

 func basicServerConfig() *ssh.ServerConfig {
 	config := ssh.ServerConfig{
 		Config: ssh.Config{
 			MACs: []string{"hmac-sha1"},
 		},
 		PasswordCallback:  pwAuth,
 		PublicKeyCallback: keyAuth,
 	}
 	config.AddHostKey(hostPrivateKeySigner)
 	return &config
 }

 type sshServer struct {
 	useSubsystem bool
 	conn         net.Conn
 	config       *ssh.ServerConfig
 	sshConn      *ssh.ServerConn
 	newChans     <-chan ssh.NewChannel
 	newReqs      <-chan *ssh.Request
 }

 func sshServerFromConn(conn net.Conn, useSubsystem bool, config *ssh.ServerConfig) (*sshServer, error) {
 	// From a standard TCP connection to an encrypted SSH connection
 	sshConn, newChans, newReqs, err := ssh.NewServerConn(conn, config)
 	if err != nil {
 		return nil, err
 	}

 	svr := &sshServer{useSubsystem, conn, config, sshConn, newChans, newReqs}
 	svr.listenChannels()
 	return svr, nil
 }

 func (svr *sshServer) Wait() error {
 	return svr.sshConn.Wait()
 }

 func (svr *sshServer) Close() error {
 	return svr.sshConn.Close()
 }

 func (svr *sshServer) listenChannels() {
 	go func() {
 		for chanReq := range svr.newChans {
 			go svr.handleChanReq(chanReq)
 		}
 	}()
 	go func() {
 		for req := range svr.newReqs {
 			go svr.handleReq(req)
 		}
 	}()
 }

 func (svr *sshServer) handleReq(req *ssh.Request) {
 	switch req.Type {
 	default:
 		rejectRequest(req)
 	}
 }

 type sshChannelServer struct {
 	svr     *sshServer
 	chanReq ssh.NewChannel
 	ch      ssh.Channel
 	newReqs <-chan *ssh.Request
 }

 type sshSessionChannelServer struct {
 	*sshChannelServer
 	env []string
 }

 func (svr *sshServer) handleChanReq(chanReq ssh.NewChannel) {
 	fmt.Fprintf(sshServerDebugStream, "channel request: %v, extra: '%v'\n", chanReq.ChannelType(), hex.EncodeToString(chanReq.ExtraData()))
 	switch chanReq.ChannelType() {
 	case "session":
 		if ch, reqs, err := chanReq.Accept(); err != nil {
 			fmt.Fprintf(sshServerDebugStream, "fail to accept channel request: %v\n", err)
 			chanReq.Reject(ssh.ResourceShortage, "channel accept failure")
 		} else {
 			chsvr := &sshSessionChannelServer{
 				sshChannelServer: &sshChannelServer{svr, chanReq, ch, reqs},
 				env:              append([]string{}, os.Environ()...),
 			}
 			chsvr.handle()
 		}
 	default:
 		chanReq.Reject(ssh.UnknownChannelType, "channel type is not a session")
 	}
 }

 func (chsvr *sshSessionChannelServer) handle() {
 	// should maybe do something here...
 	go chsvr.handleReqs()
 }

 func (chsvr *sshSessionChannelServer) handleReqs() {
 	for req := range chsvr.newReqs {
 		chsvr.handleReq(req)
 	}
 	fmt.Fprintf(sshServerDebugStream, "ssh server session channel complete\n")
 }

 func (chsvr *sshSessionChannelServer) handleReq(req *ssh.Request) {
 	switch req.Type {
 	case "env":
 		chsvr.handleEnv(req)
 	case "subsystem":
 		chsvr.handleSubsystem(req)
 	default:
 		rejectRequest(req)
 	}
 }

 func rejectRequest(req *ssh.Request) error {
 	fmt.Fprintf(sshServerDebugStream, "ssh rejecting request, type: %s\n", req.Type)
 	err := req.Reply(false, []byte{})
 	if err != nil {
 		fmt.Fprintf(sshServerDebugStream, "ssh request reply had error: %v\n", err)
 	}
 	return err
 }

 func rejectRequestUnmarshalError(req *ssh.Request, s interface{}, err error) error {
 	fmt.Fprintf(sshServerDebugStream, "ssh request unmarshaling error, type '%T': %v\n", s, err)
 	rejectRequest(req)
 	return err
 }

 // env request form:
 type sshEnvRequest struct {
 	Envvar string
 	Value  string
 }

 func (chsvr *sshSessionChannelServer) handleEnv(req *ssh.Request) error {
 	envReq := &sshEnvRequest{}
 	if err := ssh.Unmarshal(req.Payload, envReq); err != nil {
 		return rejectRequestUnmarshalError(req, envReq, err)
 	}
 	req.Reply(true, nil)

 	found := false
 	for i, envstr := range chsvr.env {
 		if strings.HasPrefix(envstr, envReq.Envvar+"=") {
 			found = true
 			chsvr.env[i] = envReq.Envvar + "=" + envReq.Value
 		}
 	}
 	if !found {
 		chsvr.env = append(chsvr.env, envReq.Envvar+"="+envReq.Value)
 	}

 	return nil
 }

 // Payload: int: command size, string: command
 type sshSubsystemRequest struct {
 	Name string
 }

 type sshSubsystemExitStatus struct {
 	Status uint32
 }

 func (chsvr *sshSessionChannelServer) handleSubsystem(req *ssh.Request) error {
 	defer func() {
 		err1 := chsvr.ch.CloseWrite()
 		err2 := chsvr.ch.Close()
 		fmt.Fprintf(sshServerDebugStream, "ssh server subsystem request complete, err: %v %v\n", err1, err2)
 	}()

 	subsystemReq := &sshSubsystemRequest{}
 	if err := ssh.Unmarshal(req.Payload, subsystemReq); err != nil {
 		return rejectRequestUnmarshalError(req, subsystemReq, err)
 	}

 	// reply to the ssh client

 	// no idea if this is actually correct spec-wise.
 	// just enough for an sftp server to start.
 	if subsystemReq.Name != "sftp" {
 		return req.Reply(false, nil)
 	}

 	req.Reply(true, nil)

 	if !chsvr.svr.useSubsystem {
 		// use the openssh sftp server backend; this is to test the ssh code, not the sftp code,
 		// or is used for comparison between our sftp subsystem and the openssh sftp subsystem
 		cmd := exec.Command(*testSftp, "-e", "-l", "DEBUG") // log to stderr
 		cmd.Stdin = chsvr.ch
 		cmd.Stdout = chsvr.ch
 		cmd.Stderr = sftpServerDebugStream
 		if err := cmd.Start(); err != nil {
 			return err
 		}
 		return cmd.Wait()
 	}

 	sftpServer, err := NewServer(
 		chsvr.ch,
 		WithDebug(sftpServerDebugStream),
 	)
 	if err != nil {
 		return err
 	}

 	// wait for the session to close
 	runErr := sftpServer.Serve()
 	exitStatus := uint32(1)
 	if runErr == nil {
 		exitStatus = uint32(0)
 	}

 	_, exitStatusErr := chsvr.ch.SendRequest("exit-status", false, ssh.Marshal(sshSubsystemExitStatus{exitStatus}))
 	return exitStatusErr
 }

 // starts an ssh server to test. returns: host string and port
 func testServer(t *testing.T, useSubsystem bool, readonly bool) (net.Listener, string, int) {
 	if !*testIntegration {
 		t.Skip("skipping intergration test")
 	}

 	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatal(err)
 	}

 	host, portStr, err := net.SplitHostPort(listener.Addr().String())
 	if err != nil {
 		t.Fatal(err)
 	}
 	port, err := strconv.Atoi(portStr)
 	if err != nil {
 		t.Fatal(err)
 	}

 	go func() {
 		for {
 			conn, err := listener.Accept()
 			if err != nil {
 				fmt.Fprintf(sshServerDebugStream, "ssh server socket closed: %v\n", err)
 				break
 			}

 			go func() {
 				defer conn.Close()
 				sshSvr, err := sshServerFromConn(conn, useSubsystem, basicServerConfig())
 				if err != nil {
 					t.Error(err)
 					return
 				}
 				err = sshSvr.Wait()
 				fmt.Fprintf(sshServerDebugStream, "ssh server finished, err: %v\n", err)
 			}()
 		}
 	}()

 	return listener, host, port
 }

 func runSftpClient(t *testing.T, script string, path string, host string, port int) (string, error) {
 	// if sftp client binary is unavailable, skip test
 	if _, err := os.Stat(*testSftpClientBin); err != nil {
 		t.Skip("sftp client binary unavailable")
 	}
 	args := []string{
 		// "-vvvv",
 		"-b", "-",
 		"-o", "StrictHostKeyChecking=no",
 		"-o", "LogLevel=ERROR",
 		"-o", "UserKnownHostsFile /dev/null",
 		"-P", fmt.Sprintf("%d", port), fmt.Sprintf("%s:%s", host, path),
 	}
 	cmd := exec.Command(*testSftpClientBin, args...)
 	var stdout bytes.Buffer
 	cmd.Stdin = bytes.NewBufferString(script)
 	cmd.Stdout = &stdout
 	cmd.Stderr = sftpClientDebugStream
 	if err := cmd.Start(); err != nil {
 		return "", err
 	}
 	err := cmd.Wait()
 	return string(stdout.Bytes()), err
 }

 func TestServerCompareSubsystems(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	listenerOp, hostOp, portOp := testServer(t, OPENSSH_SFTP, READONLY)
 	defer listenerGo.Close()
 	defer listenerOp.Close()

 	script := `
 ls /
 ls -l /
 ls /dev/
 ls -l /dev/
 ls -l /etc/
 ls -l /bin/
 ls -l /usr/bin/
 `
 	outputGo, err := runSftpClient(t, script, "/", hostGo, portGo)
 	if err != nil {
 		t.Fatal(err)
 	}

 	outputOp, err := runSftpClient(t, script, "/", hostOp, portOp)
 	if err != nil {
 		t.Fatal(err)
 	}

 	newlineRegex := regexp.MustCompile(`\r*\n`)
 	spaceRegex := regexp.MustCompile(`\s+`)
 	outputGoLines := newlineRegex.Split(outputGo, -1)
 	outputOpLines := newlineRegex.Split(outputOp, -1)

 	for i, goLine := range outputGoLines {
 		if i > len(outputOpLines) {
 			t.Fatalf("output line count differs")
 		}
 		opLine := outputOpLines[i]
 		bad := false
 		if goLine != opLine {
 			goWords := spaceRegex.Split(goLine, -1)
 			opWords := spaceRegex.Split(opLine, -1)
 			// allow words[2] and [3] to be different as these are users & groups
 			// also allow words[1] to differ as the link count for directories like
 			// proc is unstable during testing as processes are created/destroyed.
 			for j, goWord := range goWords {
 				if j > len(opWords) {
 					bad = true
 				}
 				opWord := opWords[j]
 				if goWord != opWord && j != 1 && j != 2 && j != 3 {
 					bad = true
 				}
 			}
 		}

 		if bad {
 			t.Errorf("outputs differ, go:\n%v\nopenssh:\n%v\n", goLine, opLine)
 		}
 	}
 }

 var rng = rand.New(rand.NewSource(time.Now().Unix()))

 func randData(length int) []byte {
 	data := make([]byte, length)
 	for i := 0; i < length; i++ {
 		data[i] = byte(rng.Uint32())
 	}
 	return data
 }

 func randName() string {
 	return "sftp." + hex.EncodeToString(randData(16))
 }

 func TestServerMkdirRmdir(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	defer listenerGo.Close()

 	tmpDir := "/tmp/" + randName()
 	defer os.RemoveAll(tmpDir)

 	// mkdir remote
 	if _, err := runSftpClient(t, "mkdir "+tmpDir, "/", hostGo, portGo); err != nil {
 		t.Fatal(err)
 	}

 	// directory should now exist
 	if _, err := os.Stat(tmpDir); err != nil {
 		t.Fatal(err)
 	}

 	// now remove the directory
 	if _, err := runSftpClient(t, "rmdir "+tmpDir, "/", hostGo, portGo); err != nil {
 		t.Fatal(err)
 	}

 	if _, err := os.Stat(tmpDir); err == nil {
 		t.Fatal("should have error after deleting the directory")
 	}
 }

 func TestServerSymlink(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	defer listenerGo.Close()

 	link := "/tmp/" + randName()
 	defer os.RemoveAll(link)

 	// now create a symbolic link within the new directory
 	if output, err := runSftpClient(t, "symlink /bin/sh "+link, "/", hostGo, portGo); err != nil {
 		t.Fatalf("failed: %v %v", err, string(output))
 	}

 	// symlink should now exist
 	if stat, err := os.Lstat(link); err != nil {
 		t.Fatal(err)
 	} else if (stat.Mode() & os.ModeSymlink) != os.ModeSymlink {
 		t.Fatalf("is not a symlink: %v", stat.Mode())
 	}
 }

 func TestServerPut(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	defer listenerGo.Close()

 	tmpFileLocal := "/tmp/" + randName()
 	tmpFileRemote := "/tmp/" + randName()
 	defer os.RemoveAll(tmpFileLocal)
 	defer os.RemoveAll(tmpFileRemote)

 	t.Logf("put: local %v remote %v", tmpFileLocal, tmpFileRemote)

 	// create a file with random contents. This will be the local file pushed to the server
 	tmpFileLocalData := randData(10 * 1024 * 1024)
 	if err := ioutil.WriteFile(tmpFileLocal, tmpFileLocalData, 0644); err != nil {
 		t.Fatal(err)
 	}

 	// sftp the file to the server
 	if output, err := runSftpClient(t, "put "+tmpFileLocal+" "+tmpFileRemote, "/", hostGo, portGo); err != nil {
 		t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
 	}

 	// tmpFile2 should now exist, with the same contents
 	if tmpFileRemoteData, err := ioutil.ReadFile(tmpFileRemote); err != nil {
 		t.Fatal(err)
 	} else if string(tmpFileLocalData) != string(tmpFileRemoteData) {
 		t.Fatal("contents of file incorrect after put")
 	}
 }

 func TestServerGet(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	defer listenerGo.Close()

 	tmpFileLocal := "/tmp/" + randName()
 	tmpFileRemote := "/tmp/" + randName()
 	defer os.RemoveAll(tmpFileLocal)
 	defer os.RemoveAll(tmpFileRemote)

 	t.Logf("get: local %v remote %v", tmpFileLocal, tmpFileRemote)

 	// create a file with random contents. This will be the remote file pulled from the server
 	tmpFileRemoteData := randData(10 * 1024 * 1024)
 	if err := ioutil.WriteFile(tmpFileRemote, tmpFileRemoteData, 0644); err != nil {
 		t.Fatal(err)
 	}

 	// sftp the file to the server
 	if output, err := runSftpClient(t, "get "+tmpFileRemote+" "+tmpFileLocal, "/", hostGo, portGo); err != nil {
 		t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
 	}

 	// tmpFile2 should now exist, with the same contents
 	if tmpFileLocalData, err := ioutil.ReadFile(tmpFileLocal); err != nil {
 		t.Fatal(err)
 	} else if string(tmpFileLocalData) != string(tmpFileRemoteData) {
 		t.Fatal("contents of file incorrect after put")
 	}
 }

 func compareDirectoriesRecursive(t *testing.T, aroot, broot string) {
 	walker := fs.Walk(aroot)
 	for walker.Step() {
 		if err := walker.Err(); err != nil {
 			t.Fatal(err)
 		}
 		// find paths
 		aPath := walker.Path()
 		aRel, err := filepath.Rel(aroot, aPath)
 		if err != nil {
 			t.Fatalf("could not find relative path for %v: %v", aPath, err)
 		}
 		bPath := path.Join(broot, aRel)

 		if aRel == "." {
 			continue
 		}

 		//t.Logf("comparing: %v a: %v b %v", aRel, aPath, bPath)

 		// if a is a link, the sftp recursive copy won't have copied it. ignore
 		aLink, err := os.Lstat(aPath)
 		if err != nil {
 			t.Fatalf("could not lstat %v: %v", aPath, err)
 		}
 		if aLink.Mode()&os.ModeSymlink != 0 {
 			continue
 		}

 		// stat the files
 		aFile, err := os.Stat(aPath)
 		if err != nil {
 			t.Fatalf("could not stat %v: %v", aPath, err)
 		}
 		bFile, err := os.Stat(bPath)
 		if err != nil {
 			t.Fatalf("could not stat %v: %v", bPath, err)
 		}

 		// compare stats, with some leniency for the timestamp
 		if aFile.Mode() != bFile.Mode() {
 			t.Fatalf("modes different for %v: %v vs %v", aRel, aFile.Mode(), bFile.Mode())
 		}
 		if !aFile.IsDir() {
 			if aFile.Size() != bFile.Size() {
 				t.Fatalf("sizes different for %v: %v vs %v", aRel, aFile.Size(), bFile.Size())
 			}
 		}
 		timeDiff := aFile.ModTime().Sub(bFile.ModTime())
 		if timeDiff > time.Second || timeDiff < -time.Second {
 			t.Fatalf("mtimes different for %v: %v vs %v", aRel, aFile.ModTime(), bFile.ModTime())
 		}

 		// compare contents
 		if !aFile.IsDir() {
 			if aContents, err := ioutil.ReadFile(aPath); err != nil {
 				t.Fatal(err)
 			} else if bContents, err := ioutil.ReadFile(bPath); err != nil {
 				t.Fatal(err)
 			} else if string(aContents) != string(bContents) {
 				t.Fatalf("contents different for %v", aRel)
 			}
 		}
 	}
 }

 func TestServerPutRecursive(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	defer listenerGo.Close()

 	dirLocal, err := os.Getwd()
 	if err != nil {
 		t.Fatal(err)
 	}
 	tmpDirRemote := "/tmp/" + randName()
 	defer os.RemoveAll(tmpDirRemote)

 	t.Logf("put recursive: local %v remote %v", dirLocal, tmpDirRemote)

 	// push this directory (source code etc) recursively to the server
 	if output, err := runSftpClient(t, "mkdir "+tmpDirRemote+"\r\nput -r -P "+dirLocal+"/ "+tmpDirRemote+"/", "/", hostGo, portGo); err != nil {
 		t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
 	}

 	compareDirectoriesRecursive(t, dirLocal, path.Join(tmpDirRemote, path.Base(dirLocal)))
 }

 func TestServerGetRecursive(t *testing.T) {
 	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
 	defer listenerGo.Close()

 	dirRemote, err := os.Getwd()
 	if err != nil {
 		t.Fatal(err)
 	}
 	tmpDirLocal := "/tmp/" + randName()
 	defer os.RemoveAll(tmpDirLocal)

 	t.Logf("get recursive: local %v remote %v", tmpDirLocal, dirRemote)

 	// pull this directory (source code etc) recursively from the server
 	if output, err := runSftpClient(t, "lmkdir "+tmpDirLocal+"\r\nget -r -P "+dirRemote+"/ "+tmpDirLocal+"/", "/", hostGo, portGo); err != nil {
 		t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
 	}

 	compareDirectoriesRecursive(t, dirRemote, path.Join(tmpDirLocal, path.Base(dirRemote)))
 }
	package sftp

	// sftp server integration tests
	// enable with -integration
	// example invokation (darwin): gofmt -w `find . -name \*.go` && (cd server_standalone/ ; go build -tags debug) && go test -tags debug github.com/pkg/sftp -integration -v -sftp /usr/libexec/sftp-server -run ServerCompareSubsystems

	import (
	"bytes"
	"encoding/hex"
	"flag"
	"fmt"
	"io/ioutil"
	"math/rand"
	"net"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/kr/fs"
	"golang.org/x/crypto/ssh"
	)

	var testSftpClientBin = flag.String("sftp_client", "/usr/bin/sftp", "location of the sftp client binary")
	var sshServerDebugStream = ioutil.Discard
	var sftpServerDebugStream = ioutil.Discard
	var sftpClientDebugStream = ioutil.Discard

	const (
	GOLANG_SFTP = true
	OPENSSH_SFTP = false
	)

	var (
	hostPrivateKeySigner ssh.Signer
	privKey = []byte(`
	-----BEGIN RSA PRIVATE KEY-----
	MIIEowIBAAKCAQEArhp7SqFnXVZAgWREL9Ogs+miy4IU/m0vmdkoK6M97G9NX/Pj
	wf8I/3/ynxmcArbt8Rc4JgkjT2uxx/NqR0yN42N1PjO5Czu0dms1PSqcKIJdeUBV
	7gdrKSm9Co4d2vwfQp5mg47eG4w63pz7Drk9+VIyi9YiYH4bve7WnGDswn4ycvYZ
	slV5kKnjlfCdPig+g5P7yQYud0cDWVwyA0+kxvL6H3Ip+Fu8rLDZn4/P1WlFAIuc
	PAf4uEKDGGmC2URowi5eesYR7f6GN/HnBs2776laNlAVXZUmYTUfOGagwLsEkx8x
	XdNqntfbs2MOOoK+myJrNtcB9pCrM0H6um19uQIDAQABAoIBABkWr9WdVKvalgkP
	TdQmhu3mKRNyd1wCl+1voZ5IM9Ayac/98UAvZDiNU4Uhx52MhtVLJ0gz4Oa8+i16
	IkKMAZZW6ro/8dZwkBzQbieWUFJ2Fso2PyvB3etcnGU8/Yhk9IxBDzy+BbuqhYE2
	1ebVQtz+v1HvVZzaD11bYYm/Xd7Y28QREVfFen30Q/v3dv7dOteDE/RgDS8Czz7w
	jMW32Q8JL5grz7zPkMK39BLXsTcSYcaasT2ParROhGJZDmbgd3l33zKCVc1zcj9B
	SA47QljGd09Tys958WWHgtj2o7bp9v1Ufs4LnyKgzrB80WX1ovaSQKvd5THTLchO
	kLIhUAECgYEA2doGXy9wMBmTn/hjiVvggR1aKiBwUpnB87Hn5xCMgoECVhFZlT6l
	WmZe7R2klbtG1aYlw+y+uzHhoVDAJW9AUSV8qoDUwbRXvBVlp+In5wIqJ+VjfivK
	zgIfzomL5NvDz37cvPmzqIeySTowEfbQyq7CUQSoDtE9H97E2wWZhDkCgYEAzJdJ
	k+NSFoTkHhfD3L0xCDHpRV3gvaOeew8524fVtVUq53X8m91ng4AX1r74dCUYwwiF
	gqTtSSJfx2iH1xKnNq28M9uKg7wOrCKrRqNPnYUO3LehZEC7rwUr26z4iJDHjjoB
	uBcS7nw0LJ+0Zeg1IF+aIdZGV3MrAKnrzWPixYECgYBsffX6ZWebrMEmQ89eUtFF
	u9ZxcGI/4K8ErC7vlgBD5ffB4TYZ627xzFWuBLs4jmHCeNIJ9tct5rOVYN+wRO1k
	/CRPzYUnSqb+1jEgILL6istvvv+DkE+ZtNkeRMXUndWwel94BWsBnUKe0UmrSJ3G
	sq23J3iCmJW2T3z+DpXbkQKBgQCK+LUVDNPE0i42NsRnm+fDfkvLP7Kafpr3Umdl
	tMY474o+QYn+wg0/aPJIf9463rwMNyyhirBX/k57IIktUdFdtfPicd2MEGETElWv
	nN1GzYxD50Rs2f/jKisZhEwqT9YNyV9DkgDdGGdEbJNYqbv0qpwDIg8T9foe8E1p
	bdErgQKBgAt290I3L316cdxIQTkJh1DlScN/unFffITwu127WMr28Jt3mq3cZpuM
	Aecey/eEKCj+Rlas5NDYKsB18QIuAw+qqWyq0LAKLiAvP1965Rkc4PLScl3MgJtO
	QYa37FK0p8NcDeUuF86zXBVutwS5nJLchHhKfd590ks57OROtm29
	-----END RSA PRIVATE KEY-----
	`)
	)

	func init() {
	var err error
	hostPrivateKeySigner, err = ssh.ParsePrivateKey(privKey)
	if err != nil {
	panic(err)
	}
	}

	func keyAuth(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
	permissions := &ssh.Permissions{
	CriticalOptions: map[string]string{},
	Extensions: map[string]string{},
	}
	return permissions, nil
	}

	func pwAuth(conn ssh.ConnMetadata, pw []byte) (*ssh.Permissions, error) {
	permissions := &ssh.Permissions{
	CriticalOptions: map[string]string{},
	Extensions: map[string]string{},
	}
	return permissions, nil
	}

	func basicServerConfig() *ssh.ServerConfig {
	config := ssh.ServerConfig{
	Config: ssh.Config{
	MACs: []string{"hmac-sha1"},
	},
	PasswordCallback: pwAuth,
	PublicKeyCallback: keyAuth,
	}
	config.AddHostKey(hostPrivateKeySigner)
	return &config
	}

	type sshServer struct {
	useSubsystem bool
	conn net.Conn
	config *ssh.ServerConfig
	sshConn *ssh.ServerConn
	newChans <-chan ssh.NewChannel
	newReqs <-chan *ssh.Request
	}

	func sshServerFromConn(conn net.Conn, useSubsystem bool, config ssh.ServerConfig) (sshServer, error) {
	// From a standard TCP connection to an encrypted SSH connection
	sshConn, newChans, newReqs, err := ssh.NewServerConn(conn, config)
	if err != nil {
	return nil, err
	}

	svr := &sshServer{useSubsystem, conn, config, sshConn, newChans, newReqs}
	svr.listenChannels()
	return svr, nil
	}

	func (svr *sshServer) Wait() error {
	return svr.sshConn.Wait()
	}

	func (svr *sshServer) Close() error {
	return svr.sshConn.Close()
	}

	func (svr *sshServer) listenChannels() {
	go func() {
	for chanReq := range svr.newChans {
	go svr.handleChanReq(chanReq)
	}
	}()
	go func() {
	for req := range svr.newReqs {
	go svr.handleReq(req)
	}
	}()
	}

	func (svr sshServer) handleReq(req ssh.Request) {
	switch req.Type {
	default:
	rejectRequest(req)
	}
	}

	type sshChannelServer struct {
	svr *sshServer
	chanReq ssh.NewChannel
	ch ssh.Channel
	newReqs <-chan *ssh.Request
	}

	type sshSessionChannelServer struct {
	*sshChannelServer
	env []string
	}

	func (svr *sshServer) handleChanReq(chanReq ssh.NewChannel) {
	fmt.Fprintf(sshServerDebugStream, "channel request: %v, extra: '%v'\n", chanReq.ChannelType(), hex.EncodeToString(chanReq.ExtraData()))
	switch chanReq.ChannelType() {
	case "session":
	if ch, reqs, err := chanReq.Accept(); err != nil {
	fmt.Fprintf(sshServerDebugStream, "fail to accept channel request: %v\n", err)
	chanReq.Reject(ssh.ResourceShortage, "channel accept failure")
	} else {
	chsvr := &sshSessionChannelServer{
	sshChannelServer: &sshChannelServer{svr, chanReq, ch, reqs},
	env: append([]string{}, os.Environ()...),
	}
	chsvr.handle()
	}
	default:
	chanReq.Reject(ssh.UnknownChannelType, "channel type is not a session")
	}
	}

	func (chsvr *sshSessionChannelServer) handle() {
	// should maybe do something here...
	go chsvr.handleReqs()
	}

	func (chsvr *sshSessionChannelServer) handleReqs() {
	for req := range chsvr.newReqs {
	chsvr.handleReq(req)
	}
	fmt.Fprintf(sshServerDebugStream, "ssh server session channel complete\n")
	}

	func (chsvr sshSessionChannelServer) handleReq(req ssh.Request) {
	switch req.Type {
	case "env":
	chsvr.handleEnv(req)
	case "subsystem":
	chsvr.handleSubsystem(req)
	default:
	rejectRequest(req)
	}
	}

	func rejectRequest(req *ssh.Request) error {
	fmt.Fprintf(sshServerDebugStream, "ssh rejecting request, type: %s\n", req.Type)
	err := req.Reply(false, []byte{})
	if err != nil {
	fmt.Fprintf(sshServerDebugStream, "ssh request reply had error: %v\n", err)
	}
	return err
	}

	func rejectRequestUnmarshalError(req *ssh.Request, s interface{}, err error) error {
	fmt.Fprintf(sshServerDebugStream, "ssh request unmarshaling error, type '%T': %v\n", s, err)
	rejectRequest(req)
	return err
	}

	// env request form:
	type sshEnvRequest struct {
	Envvar string
	Value string
	}

	func (chsvr sshSessionChannelServer) handleEnv(req ssh.Request) error {
	envReq := &sshEnvRequest{}
	if err := ssh.Unmarshal(req.Payload, envReq); err != nil {
	return rejectRequestUnmarshalError(req, envReq, err)
	}
	req.Reply(true, nil)

	found := false
	for i, envstr := range chsvr.env {
	if strings.HasPrefix(envstr, envReq.Envvar+"=") {
	found = true
	chsvr.env[i] = envReq.Envvar + "=" + envReq.Value
	}
	}
	if !found {
	chsvr.env = append(chsvr.env, envReq.Envvar+"="+envReq.Value)
	}

	return nil
	}

	// Payload: int: command size, string: command
	type sshSubsystemRequest struct {
	Name string
	}

	type sshSubsystemExitStatus struct {
	Status uint32
	}

	func (chsvr sshSessionChannelServer) handleSubsystem(req ssh.Request) error {
	defer func() {
	err1 := chsvr.ch.CloseWrite()
	err2 := chsvr.ch.Close()
	fmt.Fprintf(sshServerDebugStream, "ssh server subsystem request complete, err: %v %v\n", err1, err2)
	}()

	subsystemReq := &sshSubsystemRequest{}
	if err := ssh.Unmarshal(req.Payload, subsystemReq); err != nil {
	return rejectRequestUnmarshalError(req, subsystemReq, err)
	}

	// reply to the ssh client

	// no idea if this is actually correct spec-wise.
	// just enough for an sftp server to start.
	if subsystemReq.Name != "sftp" {
	return req.Reply(false, nil)
	}

	req.Reply(true, nil)

	if !chsvr.svr.useSubsystem {
	// use the openssh sftp server backend; this is to test the ssh code, not the sftp code,
	// or is used for comparison between our sftp subsystem and the openssh sftp subsystem
	cmd := exec.Command(*testSftp, "-e", "-l", "DEBUG") // log to stderr
	cmd.Stdin = chsvr.ch
	cmd.Stdout = chsvr.ch
	cmd.Stderr = sftpServerDebugStream
	if err := cmd.Start(); err != nil {
	return err
	}
	return cmd.Wait()
	}

	sftpServer, err := NewServer(
	chsvr.ch,
	WithDebug(sftpServerDebugStream),
	)
	if err != nil {
	return err
	}

	// wait for the session to close
	runErr := sftpServer.Serve()
	exitStatus := uint32(1)
	if runErr == nil {
	exitStatus = uint32(0)
	}

	_, exitStatusErr := chsvr.ch.SendRequest("exit-status", false, ssh.Marshal(sshSubsystemExitStatus{exitStatus}))
	return exitStatusErr
	}

	// starts an ssh server to test. returns: host string and port
	func testServer(t *testing.T, useSubsystem bool, readonly bool) (net.Listener, string, int) {
	if !*testIntegration {
	t.Skip("skipping intergration test")
	}

	listener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
	t.Fatal(err)
	}

	host, portStr, err := net.SplitHostPort(listener.Addr().String())
	if err != nil {
	t.Fatal(err)
	}
	port, err := strconv.Atoi(portStr)
	if err != nil {
	t.Fatal(err)
	}

	go func() {
	for {
	conn, err := listener.Accept()
	if err != nil {
	fmt.Fprintf(sshServerDebugStream, "ssh server socket closed: %v\n", err)
	break
	}

	go func() {
	defer conn.Close()
	sshSvr, err := sshServerFromConn(conn, useSubsystem, basicServerConfig())
	if err != nil {
	t.Error(err)
	return
	}
	err = sshSvr.Wait()
	fmt.Fprintf(sshServerDebugStream, "ssh server finished, err: %v\n", err)
	}()
	}
	}()

	return listener, host, port
	}

	func runSftpClient(t *testing.T, script string, path string, host string, port int) (string, error) {
	// if sftp client binary is unavailable, skip test
	if _, err := os.Stat(*testSftpClientBin); err != nil {
	t.Skip("sftp client binary unavailable")
	}
	args := []string{
	// "-vvvv",
	"-b", "-",
	"-o", "StrictHostKeyChecking=no",
	"-o", "LogLevel=ERROR",
	"-o", "UserKnownHostsFile /dev/null",
	"-P", fmt.Sprintf("%d", port), fmt.Sprintf("%s:%s", host, path),
	}
	cmd := exec.Command(*testSftpClientBin, args...)
	var stdout bytes.Buffer
	cmd.Stdin = bytes.NewBufferString(script)
	cmd.Stdout = &stdout
	cmd.Stderr = sftpClientDebugStream
	if err := cmd.Start(); err != nil {
	return "", err
	}
	err := cmd.Wait()
	return string(stdout.Bytes()), err
	}

	func TestServerCompareSubsystems(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	listenerOp, hostOp, portOp := testServer(t, OPENSSH_SFTP, READONLY)
	defer listenerGo.Close()
	defer listenerOp.Close()

	script := `
	ls /
	ls -l /
	ls /dev/
	ls -l /dev/
	ls -l /etc/
	ls -l /bin/
	ls -l /usr/bin/
	`
	outputGo, err := runSftpClient(t, script, "/", hostGo, portGo)
	if err != nil {
	t.Fatal(err)
	}

	outputOp, err := runSftpClient(t, script, "/", hostOp, portOp)
	if err != nil {
	t.Fatal(err)
	}

	newlineRegex := regexp.MustCompile(`\r*\n`)
	spaceRegex := regexp.MustCompile(`\s+`)
	outputGoLines := newlineRegex.Split(outputGo, -1)
	outputOpLines := newlineRegex.Split(outputOp, -1)

	for i, goLine := range outputGoLines {
	if i > len(outputOpLines) {
	t.Fatalf("output line count differs")
	}
	opLine := outputOpLines[i]
	bad := false
	if goLine != opLine {
	goWords := spaceRegex.Split(goLine, -1)
	opWords := spaceRegex.Split(opLine, -1)
	// allow words[2] and [3] to be different as these are users & groups
	// also allow words[1] to differ as the link count for directories like
	// proc is unstable during testing as processes are created/destroyed.
	for j, goWord := range goWords {
	if j > len(opWords) {
	bad = true
	}
	opWord := opWords[j]
	if goWord != opWord && j != 1 && j != 2 && j != 3 {
	bad = true
	}
	}
	}

	if bad {
	t.Errorf("outputs differ, go:\n%v\nopenssh:\n%v\n", goLine, opLine)
	}
	}
	}

	var rng = rand.New(rand.NewSource(time.Now().Unix()))

	func randData(length int) []byte {
	data := make([]byte, length)
	for i := 0; i < length; i++ {
	data[i] = byte(rng.Uint32())
	}
	return data
	}

	func randName() string {
	return "sftp." + hex.EncodeToString(randData(16))
	}

	func TestServerMkdirRmdir(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	defer listenerGo.Close()

	tmpDir := "/tmp/" + randName()
	defer os.RemoveAll(tmpDir)

	// mkdir remote
	if _, err := runSftpClient(t, "mkdir "+tmpDir, "/", hostGo, portGo); err != nil {
	t.Fatal(err)
	}

	// directory should now exist
	if _, err := os.Stat(tmpDir); err != nil {
	t.Fatal(err)
	}

	// now remove the directory
	if _, err := runSftpClient(t, "rmdir "+tmpDir, "/", hostGo, portGo); err != nil {
	t.Fatal(err)
	}

	if _, err := os.Stat(tmpDir); err == nil {
	t.Fatal("should have error after deleting the directory")
	}
	}

	func TestServerSymlink(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	defer listenerGo.Close()

	link := "/tmp/" + randName()
	defer os.RemoveAll(link)

	// now create a symbolic link within the new directory
	if output, err := runSftpClient(t, "symlink /bin/sh "+link, "/", hostGo, portGo); err != nil {
	t.Fatalf("failed: %v %v", err, string(output))
	}

	// symlink should now exist
	if stat, err := os.Lstat(link); err != nil {
	t.Fatal(err)
	} else if (stat.Mode() & os.ModeSymlink) != os.ModeSymlink {
	t.Fatalf("is not a symlink: %v", stat.Mode())
	}
	}

	func TestServerPut(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	defer listenerGo.Close()

	tmpFileLocal := "/tmp/" + randName()
	tmpFileRemote := "/tmp/" + randName()
	defer os.RemoveAll(tmpFileLocal)
	defer os.RemoveAll(tmpFileRemote)

	t.Logf("put: local %v remote %v", tmpFileLocal, tmpFileRemote)

	// create a file with random contents. This will be the local file pushed to the server
	tmpFileLocalData := randData(10 * 1024 * 1024)
	if err := ioutil.WriteFile(tmpFileLocal, tmpFileLocalData, 0644); err != nil {
	t.Fatal(err)
	}

	// sftp the file to the server
	if output, err := runSftpClient(t, "put "+tmpFileLocal+" "+tmpFileRemote, "/", hostGo, portGo); err != nil {
	t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
	}

	// tmpFile2 should now exist, with the same contents
	if tmpFileRemoteData, err := ioutil.ReadFile(tmpFileRemote); err != nil {
	t.Fatal(err)
	} else if string(tmpFileLocalData) != string(tmpFileRemoteData) {
	t.Fatal("contents of file incorrect after put")
	}
	}

	func TestServerGet(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	defer listenerGo.Close()

	tmpFileLocal := "/tmp/" + randName()
	tmpFileRemote := "/tmp/" + randName()
	defer os.RemoveAll(tmpFileLocal)
	defer os.RemoveAll(tmpFileRemote)

	t.Logf("get: local %v remote %v", tmpFileLocal, tmpFileRemote)

	// create a file with random contents. This will be the remote file pulled from the server
	tmpFileRemoteData := randData(10 * 1024 * 1024)
	if err := ioutil.WriteFile(tmpFileRemote, tmpFileRemoteData, 0644); err != nil {
	t.Fatal(err)
	}

	// sftp the file to the server
	if output, err := runSftpClient(t, "get "+tmpFileRemote+" "+tmpFileLocal, "/", hostGo, portGo); err != nil {
	t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
	}

	// tmpFile2 should now exist, with the same contents
	if tmpFileLocalData, err := ioutil.ReadFile(tmpFileLocal); err != nil {
	t.Fatal(err)
	} else if string(tmpFileLocalData) != string(tmpFileRemoteData) {
	t.Fatal("contents of file incorrect after put")
	}
	}

	func compareDirectoriesRecursive(t *testing.T, aroot, broot string) {
	walker := fs.Walk(aroot)
	for walker.Step() {
	if err := walker.Err(); err != nil {
	t.Fatal(err)
	}
	// find paths
	aPath := walker.Path()
	aRel, err := filepath.Rel(aroot, aPath)
	if err != nil {
	t.Fatalf("could not find relative path for %v: %v", aPath, err)
	}
	bPath := path.Join(broot, aRel)

	if aRel == "." {
	continue
	}

	//t.Logf("comparing: %v a: %v b %v", aRel, aPath, bPath)

	// if a is a link, the sftp recursive copy won't have copied it. ignore
	aLink, err := os.Lstat(aPath)
	if err != nil {
	t.Fatalf("could not lstat %v: %v", aPath, err)
	}
	if aLink.Mode()&os.ModeSymlink != 0 {
	continue
	}

	// stat the files
	aFile, err := os.Stat(aPath)
	if err != nil {
	t.Fatalf("could not stat %v: %v", aPath, err)
	}
	bFile, err := os.Stat(bPath)
	if err != nil {
	t.Fatalf("could not stat %v: %v", bPath, err)
	}

	// compare stats, with some leniency for the timestamp
	if aFile.Mode() != bFile.Mode() {
	t.Fatalf("modes different for %v: %v vs %v", aRel, aFile.Mode(), bFile.Mode())
	}
	if !aFile.IsDir() {
	if aFile.Size() != bFile.Size() {
	t.Fatalf("sizes different for %v: %v vs %v", aRel, aFile.Size(), bFile.Size())
	}
	}
	timeDiff := aFile.ModTime().Sub(bFile.ModTime())
	if timeDiff > time.Second \|\| timeDiff < -time.Second {
	t.Fatalf("mtimes different for %v: %v vs %v", aRel, aFile.ModTime(), bFile.ModTime())
	}

	// compare contents
	if !aFile.IsDir() {
	if aContents, err := ioutil.ReadFile(aPath); err != nil {
	t.Fatal(err)
	} else if bContents, err := ioutil.ReadFile(bPath); err != nil {
	t.Fatal(err)
	} else if string(aContents) != string(bContents) {
	t.Fatalf("contents different for %v", aRel)
	}
	}
	}
	}

	func TestServerPutRecursive(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	defer listenerGo.Close()

	dirLocal, err := os.Getwd()
	if err != nil {
	t.Fatal(err)
	}
	tmpDirRemote := "/tmp/" + randName()
	defer os.RemoveAll(tmpDirRemote)

	t.Logf("put recursive: local %v remote %v", dirLocal, tmpDirRemote)

	// push this directory (source code etc) recursively to the server
	if output, err := runSftpClient(t, "mkdir "+tmpDirRemote+"\r\nput -r -P "+dirLocal+"/ "+tmpDirRemote+"/", "/", hostGo, portGo); err != nil {
	t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
	}

	compareDirectoriesRecursive(t, dirLocal, path.Join(tmpDirRemote, path.Base(dirLocal)))
	}

	func TestServerGetRecursive(t *testing.T) {
	listenerGo, hostGo, portGo := testServer(t, GOLANG_SFTP, READONLY)
	defer listenerGo.Close()

	dirRemote, err := os.Getwd()
	if err != nil {
	t.Fatal(err)
	}
	tmpDirLocal := "/tmp/" + randName()
	defer os.RemoveAll(tmpDirLocal)

	t.Logf("get recursive: local %v remote %v", tmpDirLocal, dirRemote)

	// pull this directory (source code etc) recursively from the server
	if output, err := runSftpClient(t, "lmkdir "+tmpDirLocal+"\r\nget -r -P "+dirRemote+"/ "+tmpDirLocal+"/", "/", hostGo, portGo); err != nil {
	t.Fatalf("runSftpClient failed: %v, output\n%v\n", err, output)
	}

	compareDirectoriesRecursive(t, dirRemote, path.Join(tmpDirLocal, path.Base(dirRemote)))
	}