2016-06-06 23:57:42 +02:00
|
|
|
package test_helpers
|
2015-11-12 21:02:44 +01:00
|
|
|
|
|
|
|
import (
|
2017-05-07 21:01:39 +02:00
|
|
|
"bytes"
|
2015-11-12 21:02:44 +01:00
|
|
|
"crypto/md5"
|
|
|
|
"encoding/hex"
|
2016-11-10 23:32:51 +01:00
|
|
|
"encoding/json"
|
2015-11-14 17:16:17 +01:00
|
|
|
"fmt"
|
2018-02-28 20:03:54 +01:00
|
|
|
"io"
|
2015-11-14 17:16:17 +01:00
|
|
|
"io/ioutil"
|
2017-12-06 23:03:37 +01:00
|
|
|
"log"
|
2016-11-10 23:32:51 +01:00
|
|
|
"net"
|
2015-11-14 17:16:17 +01:00
|
|
|
"os"
|
|
|
|
"os/exec"
|
2016-02-07 13:28:55 +01:00
|
|
|
"path/filepath"
|
2015-12-13 20:10:52 +01:00
|
|
|
"syscall"
|
2015-11-12 21:02:44 +01:00
|
|
|
"testing"
|
2016-11-10 23:32:51 +01:00
|
|
|
"time"
|
2015-11-27 23:34:55 +01:00
|
|
|
|
2016-11-10 23:32:51 +01:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/ctlsock"
|
2016-02-06 19:20:54 +01:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/nametransform"
|
2015-11-12 21:02:44 +01:00
|
|
|
)
|
|
|
|
|
2016-09-24 22:45:25 +02:00
|
|
|
// TmpDir will be created inside this directory
|
2018-03-24 21:37:41 +01:00
|
|
|
var testParentDir = "/tmp/gocryptfs-test-parent"
|
2016-10-02 06:14:18 +02:00
|
|
|
|
|
|
|
// GocryptfsBinary is the assumed path to the gocryptfs build.
|
2016-06-06 23:57:42 +02:00
|
|
|
const GocryptfsBinary = "../../gocryptfs"
|
2015-11-15 13:38:19 +01:00
|
|
|
|
2017-05-07 12:22:15 +02:00
|
|
|
// UnmountScript is the fusermount/umount compatibility wrapper script
|
2017-02-15 23:13:33 +01:00
|
|
|
const UnmountScript = "../fuse-unmount.bash"
|
|
|
|
|
2017-05-07 21:01:39 +02:00
|
|
|
// X255 contains 255 uppercase "X". This can be used as a maximum-length filename.
|
|
|
|
var X255 string
|
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// TmpDir is a unique temporary directory. "go test" runs package tests in parallel. We create a
|
|
|
|
// unique TmpDir in init() so the tests do not interfere.
|
2016-06-30 00:57:14 +02:00
|
|
|
var TmpDir string
|
2016-09-24 22:45:25 +02:00
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// DefaultPlainDir is TmpDir + "/default-plain"
|
2016-06-30 00:57:14 +02:00
|
|
|
var DefaultPlainDir string
|
2016-09-24 22:45:25 +02:00
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// DefaultCipherDir is TmpDir + "/default-cipher"
|
2016-06-30 00:57:14 +02:00
|
|
|
var DefaultCipherDir string
|
|
|
|
|
2018-03-24 21:37:41 +01:00
|
|
|
// SwitchTestParentDir changes testParentDir. This is used when you want
|
|
|
|
// to perform tests on a special filesystem. For example, the xattr tests
|
|
|
|
// cannot run on tmpfs and use /var/tmp instead of /tmp.
|
|
|
|
func SwitchTestParentDir(newDir string) {
|
|
|
|
testParentDir = newDir
|
|
|
|
doInit()
|
|
|
|
}
|
|
|
|
|
2016-06-30 00:57:14 +02:00
|
|
|
func init() {
|
2018-03-24 21:37:41 +01:00
|
|
|
doInit()
|
|
|
|
}
|
|
|
|
|
|
|
|
func doInit() {
|
2017-05-07 21:01:39 +02:00
|
|
|
X255 = string(bytes.Repeat([]byte("X"), 255))
|
|
|
|
|
2016-06-30 00:57:14 +02:00
|
|
|
os.MkdirAll(testParentDir, 0700)
|
|
|
|
var err error
|
|
|
|
TmpDir, err = ioutil.TempDir(testParentDir, "")
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
DefaultPlainDir = TmpDir + "/default-plain"
|
|
|
|
DefaultCipherDir = TmpDir + "/default-cipher"
|
|
|
|
}
|
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// ResetTmpDir deletes TmpDir, create new dir tree:
|
2016-06-16 21:06:03 +02:00
|
|
|
//
|
|
|
|
// TmpDir
|
|
|
|
// |-- DefaultPlainDir
|
|
|
|
// *-- DefaultCipherDir
|
|
|
|
// *-- gocryptfs.diriv
|
2016-10-08 19:22:59 +02:00
|
|
|
func ResetTmpDir(createDirIV bool) {
|
2016-06-30 00:57:14 +02:00
|
|
|
// Try to unmount and delete everything
|
2016-06-06 23:57:42 +02:00
|
|
|
entries, err := ioutil.ReadDir(TmpDir)
|
2016-04-10 19:43:37 +02:00
|
|
|
if err == nil {
|
|
|
|
for _, e := range entries {
|
2016-06-30 00:57:14 +02:00
|
|
|
d := filepath.Join(TmpDir, e.Name())
|
|
|
|
err = os.Remove(d)
|
|
|
|
if err != nil {
|
2016-09-25 14:57:04 +02:00
|
|
|
pe := err.(*os.PathError)
|
|
|
|
if pe.Err == syscall.EBUSY {
|
|
|
|
if testing.Verbose() {
|
|
|
|
fmt.Printf("Remove failed: %v. Maybe still mounted?\n", pe)
|
|
|
|
}
|
|
|
|
err = UnmountErr(d)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
} else if pe.Err != syscall.ENOTEMPTY {
|
|
|
|
panic("Unhandled error: " + pe.Err.Error())
|
2016-07-11 20:40:53 +02:00
|
|
|
}
|
2016-07-11 20:31:36 +02:00
|
|
|
err = os.RemoveAll(d)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
2016-06-30 00:57:14 +02:00
|
|
|
}
|
2016-04-10 19:43:37 +02:00
|
|
|
}
|
|
|
|
}
|
2016-06-30 00:57:14 +02:00
|
|
|
err = os.Mkdir(DefaultPlainDir, 0700)
|
2015-11-15 15:05:15 +01:00
|
|
|
if err != nil {
|
2016-06-30 00:57:14 +02:00
|
|
|
panic(err)
|
2015-11-15 15:05:15 +01:00
|
|
|
}
|
2016-06-30 00:57:14 +02:00
|
|
|
err = os.Mkdir(DefaultCipherDir, 0700)
|
2015-11-12 21:02:44 +01:00
|
|
|
if err != nil {
|
2016-06-30 00:57:14 +02:00
|
|
|
panic(err)
|
2015-11-12 21:02:44 +01:00
|
|
|
}
|
2016-10-08 19:22:59 +02:00
|
|
|
if createDirIV {
|
2017-11-29 13:21:28 +01:00
|
|
|
err = nametransform.WriteDirIV(nil, DefaultCipherDir)
|
2016-02-07 13:28:55 +01:00
|
|
|
if err != nil {
|
2016-06-30 00:57:14 +02:00
|
|
|
panic(err)
|
2016-02-07 13:28:55 +01:00
|
|
|
}
|
2015-11-27 21:50:11 +01:00
|
|
|
}
|
2015-11-12 21:02:44 +01:00
|
|
|
}
|
|
|
|
|
2016-06-16 21:06:03 +02:00
|
|
|
// InitFS calls "gocryptfs -init" on a new directory in TmpDir, passing
|
2016-09-24 22:45:25 +02:00
|
|
|
// "extraArgs" in addition to useful defaults.
|
2016-06-27 21:39:02 +02:00
|
|
|
//
|
|
|
|
// The returned cipherdir has NO trailing slash.
|
2016-06-16 21:06:03 +02:00
|
|
|
func InitFS(t *testing.T, extraArgs ...string) string {
|
|
|
|
dir, err := ioutil.TempDir(TmpDir, "")
|
|
|
|
if err != nil {
|
2017-12-06 23:03:37 +01:00
|
|
|
if t != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
} else {
|
|
|
|
log.Panic(err)
|
|
|
|
}
|
2016-06-16 21:06:03 +02:00
|
|
|
}
|
|
|
|
args := []string{"-q", "-init", "-extpass", "echo test", "-scryptn=10"}
|
|
|
|
args = append(args, extraArgs...)
|
|
|
|
args = append(args, dir)
|
|
|
|
|
|
|
|
cmd := exec.Command(GocryptfsBinary, args...)
|
|
|
|
cmd.Stdout = os.Stdout
|
|
|
|
cmd.Stderr = os.Stderr
|
|
|
|
|
|
|
|
err = cmd.Run()
|
|
|
|
if err != nil {
|
2017-12-06 23:03:37 +01:00
|
|
|
if t != nil {
|
|
|
|
t.Fatalf("InitFS with args %v failed: %v", args, err)
|
|
|
|
} else {
|
|
|
|
log.Panic(err)
|
|
|
|
}
|
2016-06-16 21:06:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return dir
|
|
|
|
}
|
|
|
|
|
2016-06-06 23:57:42 +02:00
|
|
|
// Mount CIPHERDIR "c" on PLAINDIR "p"
|
2016-06-16 21:06:03 +02:00
|
|
|
// Creates "p" if it does not exist.
|
2016-06-23 21:29:00 +02:00
|
|
|
func Mount(c string, p string, showOutput bool, extraArgs ...string) error {
|
2015-11-12 21:02:44 +01:00
|
|
|
var args []string
|
2016-10-08 19:36:26 +02:00
|
|
|
args = append(args, "-q", "-wpanic", "-nosyslog")
|
2016-11-10 23:47:04 +01:00
|
|
|
args = append(args, extraArgs...)
|
2016-02-07 13:28:55 +01:00
|
|
|
//args = append(args, "-fusedebug")
|
|
|
|
//args = append(args, "-d")
|
2015-11-15 15:05:15 +01:00
|
|
|
args = append(args, c)
|
|
|
|
args = append(args, p)
|
2016-06-16 21:06:03 +02:00
|
|
|
|
|
|
|
if _, err := os.Stat(p); err != nil {
|
|
|
|
err = os.Mkdir(p, 0777)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-06 23:57:42 +02:00
|
|
|
cmd := exec.Command(GocryptfsBinary, args...)
|
2016-06-23 21:29:00 +02:00
|
|
|
if showOutput {
|
2018-02-28 20:03:54 +01:00
|
|
|
// The Go test logic waits for our stdout to close, and when we share
|
|
|
|
// it with the subprocess, it will wait for it to close it as well.
|
|
|
|
// Use an intermediate pipe so the tests do not hang when unmouting
|
|
|
|
// fails.
|
|
|
|
pr, pw, err := os.Pipe()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-04-07 15:21:05 +02:00
|
|
|
// We can close the fd after cmd.Run() has executed
|
|
|
|
defer pw.Close()
|
2018-02-28 20:03:54 +01:00
|
|
|
cmd.Stderr = pw
|
|
|
|
cmd.Stdout = pw
|
2018-04-07 15:21:05 +02:00
|
|
|
go func() {
|
|
|
|
io.Copy(os.Stdout, pr)
|
|
|
|
pr.Close()
|
|
|
|
}()
|
2016-06-23 21:29:00 +02:00
|
|
|
}
|
2016-06-19 20:01:29 +02:00
|
|
|
|
2016-06-06 22:30:39 +02:00
|
|
|
return cmd.Run()
|
|
|
|
}
|
|
|
|
|
2016-09-24 22:45:25 +02:00
|
|
|
// MountOrExit calls Mount() and exits on failure.
|
2016-06-06 23:57:42 +02:00
|
|
|
func MountOrExit(c string, p string, extraArgs ...string) {
|
2016-06-23 21:29:00 +02:00
|
|
|
err := Mount(c, p, true, extraArgs...)
|
2015-11-12 21:02:44 +01:00
|
|
|
if err != nil {
|
2018-03-05 23:06:27 +01:00
|
|
|
fmt.Printf("mount failed: %v\n", err)
|
2015-11-12 21:02:44 +01:00
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-24 22:45:25 +02:00
|
|
|
// MountOrFatal calls Mount() and calls t.Fatal() on failure.
|
2016-06-06 23:57:42 +02:00
|
|
|
func MountOrFatal(t *testing.T, c string, p string, extraArgs ...string) {
|
2016-06-23 21:29:00 +02:00
|
|
|
err := Mount(c, p, true, extraArgs...)
|
2016-06-06 22:30:39 +02:00
|
|
|
if err != nil {
|
|
|
|
t.Fatal(fmt.Errorf("mount failed: %v", err))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-11 20:31:36 +02:00
|
|
|
// UnmountPanic tries to umount "dir" and panics on error.
|
|
|
|
func UnmountPanic(dir string) {
|
|
|
|
err := UnmountErr(dir)
|
|
|
|
if err != nil {
|
2018-03-06 21:22:01 +01:00
|
|
|
fmt.Printf("UnmountPanic: %v. Running lsof %s\n", err, dir)
|
|
|
|
cmd := exec.Command("lsof", dir)
|
|
|
|
cmd.Stdout = os.Stdout
|
|
|
|
cmd.Stderr = os.Stderr
|
|
|
|
cmd.Run()
|
|
|
|
panic("UnmountPanic: unmount failed: " + err.Error())
|
2016-07-11 20:31:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-08 20:09:05 +02:00
|
|
|
// UnmountErr tries to unmount "dir", retrying 10 times, and returns the
|
|
|
|
// resulting error.
|
|
|
|
func UnmountErr(dir string) (err error) {
|
|
|
|
max := 10
|
|
|
|
// When a new filesystem is mounted, Gnome tries to read files like
|
|
|
|
// .xdg-volume-info, autorun.inf, .Trash.
|
|
|
|
// If we try to unmount before Gnome is done, the unmount fails with
|
|
|
|
// "Device or resource busy", causing spurious test failures.
|
|
|
|
// Retry a few times to hide that problem.
|
|
|
|
for i := 1; i <= max; i++ {
|
|
|
|
cmd := exec.Command(UnmountScript, "-u", dir)
|
|
|
|
cmd.Stdout = os.Stdout
|
|
|
|
cmd.Stderr = os.Stderr
|
|
|
|
err = cmd.Run()
|
|
|
|
if err == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
code := ExtractCmdExitCode(err)
|
|
|
|
fmt.Printf("UnmountErr: got exit code %d, retrying (%d/%d)\n", code, i, max)
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
}
|
|
|
|
return err
|
2015-11-12 21:02:44 +01:00
|
|
|
}
|
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// Md5fn returns an md5 string for file "filename"
|
2016-06-06 23:57:42 +02:00
|
|
|
func Md5fn(filename string) string {
|
2015-11-12 21:02:44 +01:00
|
|
|
buf, err := ioutil.ReadFile(filename)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("ReadFile: %v\n", err)
|
|
|
|
return ""
|
|
|
|
}
|
2016-06-06 23:57:42 +02:00
|
|
|
return Md5hex(buf)
|
2015-11-12 21:02:44 +01:00
|
|
|
}
|
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// Md5hex returns an md5 string for "buf"
|
2016-06-06 23:57:42 +02:00
|
|
|
func Md5hex(buf []byte) string {
|
2015-11-12 21:02:44 +01:00
|
|
|
rawHash := md5.Sum(buf)
|
|
|
|
hash := hex.EncodeToString(rawHash[:])
|
|
|
|
return hash
|
|
|
|
}
|
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// VerifySize checks that the file size equals "want". This checks:
|
2015-11-12 21:02:44 +01:00
|
|
|
// 1) Size reported by Stat()
|
|
|
|
// 2) Number of bytes returned when reading the whole file
|
2016-06-06 23:57:42 +02:00
|
|
|
func VerifySize(t *testing.T, path string, want int) {
|
2015-11-12 21:02:44 +01:00
|
|
|
buf, err := ioutil.ReadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("ReadFile failed: %v", err)
|
|
|
|
} else if len(buf) != want {
|
|
|
|
t.Errorf("wrong read size: got=%d want=%d", len(buf), want)
|
|
|
|
}
|
|
|
|
|
|
|
|
fi, err := os.Stat(path)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Stat failed: %v", err)
|
|
|
|
} else if fi.Size() != int64(want) {
|
|
|
|
t.Errorf("wrong stat file size, got=%d want=%d", fi.Size(), want)
|
|
|
|
}
|
|
|
|
}
|
2015-12-10 20:02:18 +01:00
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// TestMkdirRmdir creates and deletes a directory
|
2016-06-06 23:57:42 +02:00
|
|
|
func TestMkdirRmdir(t *testing.T, plainDir string) {
|
2016-06-30 00:57:14 +02:00
|
|
|
dir := plainDir + "/dir1"
|
2015-12-10 20:02:18 +01:00
|
|
|
err := os.Mkdir(dir, 0777)
|
|
|
|
if err != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-10 20:02:18 +01:00
|
|
|
}
|
|
|
|
err = syscall.Rmdir(dir)
|
|
|
|
if err != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-10 20:02:18 +01:00
|
|
|
}
|
2015-12-11 19:54:53 +01:00
|
|
|
// Removing a non-empty dir should fail with ENOTEMPTY
|
|
|
|
if os.Mkdir(dir, 0777) != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-11 19:54:53 +01:00
|
|
|
}
|
|
|
|
f, err := os.Create(dir + "/file")
|
|
|
|
if err != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-11 19:54:53 +01:00
|
|
|
}
|
|
|
|
f.Close()
|
|
|
|
err = syscall.Rmdir(dir)
|
|
|
|
errno := err.(syscall.Errno)
|
|
|
|
if errno != syscall.ENOTEMPTY {
|
|
|
|
t.Errorf("Should have gotten ENOTEMPTY, go %v", errno)
|
|
|
|
}
|
2015-12-13 20:10:52 +01:00
|
|
|
if syscall.Unlink(dir+"/file") != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-11 19:54:53 +01:00
|
|
|
}
|
|
|
|
if syscall.Rmdir(dir) != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-11 19:54:53 +01:00
|
|
|
}
|
|
|
|
// We should also be able to remove a directory we do not have permissions to
|
|
|
|
// read or write
|
|
|
|
err = os.Mkdir(dir, 0000)
|
|
|
|
if err != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-11 19:54:53 +01:00
|
|
|
}
|
|
|
|
err = syscall.Rmdir(dir)
|
|
|
|
if err != nil {
|
2016-04-10 19:43:37 +02:00
|
|
|
// Make sure the directory can cleaned up by the next test run
|
|
|
|
os.Chmod(dir, 0700)
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-11 19:54:53 +01:00
|
|
|
}
|
2015-12-10 20:02:18 +01:00
|
|
|
}
|
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// TestRename creates and renames a file
|
2016-06-06 23:57:42 +02:00
|
|
|
func TestRename(t *testing.T, plainDir string) {
|
2016-06-30 00:57:14 +02:00
|
|
|
file1 := plainDir + "/rename1"
|
|
|
|
file2 := plainDir + "/rename2"
|
2015-12-10 20:02:18 +01:00
|
|
|
err := ioutil.WriteFile(file1, []byte("content"), 0777)
|
|
|
|
if err != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-10 20:02:18 +01:00
|
|
|
}
|
|
|
|
err = syscall.Rename(file1, file2)
|
|
|
|
if err != nil {
|
2016-11-26 15:17:15 +01:00
|
|
|
t.Error(err)
|
|
|
|
return
|
2015-12-10 20:02:18 +01:00
|
|
|
}
|
|
|
|
syscall.Unlink(file2)
|
|
|
|
}
|
2016-02-07 10:55:13 +01:00
|
|
|
|
2016-10-02 06:14:18 +02:00
|
|
|
// VerifyExistence checks in 3 ways that "path" exists:
|
2016-02-07 10:55:13 +01:00
|
|
|
// stat, open, readdir
|
2016-06-06 23:57:42 +02:00
|
|
|
func VerifyExistence(path string) bool {
|
2016-02-07 10:55:13 +01:00
|
|
|
// Check that file can be stated
|
|
|
|
_, err := os.Stat(path)
|
|
|
|
if err != nil {
|
|
|
|
//t.Log(err)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
// Check that file can be opened
|
|
|
|
fd, err := os.Open(path)
|
|
|
|
if err != nil {
|
|
|
|
//t.Log(err)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
fd.Close()
|
|
|
|
// Check that file shows up in directory listing
|
|
|
|
dir := filepath.Dir(path)
|
|
|
|
name := filepath.Base(path)
|
|
|
|
fi, err := ioutil.ReadDir(dir)
|
|
|
|
if err != nil {
|
|
|
|
//t.Log(err)
|
|
|
|
return false
|
|
|
|
}
|
2016-02-07 13:28:55 +01:00
|
|
|
for _, i := range fi {
|
2016-02-07 10:55:13 +01:00
|
|
|
if i.Name() == name {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
2016-07-02 19:43:57 +02:00
|
|
|
|
|
|
|
// Du returns the disk usage of the file "fd" points to, in bytes.
|
|
|
|
// Same as "du --block-size=1".
|
2016-10-04 21:48:53 +02:00
|
|
|
func Du(t *testing.T, fd int) (nBytes int64) {
|
2016-07-02 19:43:57 +02:00
|
|
|
var st syscall.Stat_t
|
|
|
|
err := syscall.Fstat(fd, &st)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-10-04 21:48:53 +02:00
|
|
|
// st.Blocks = number of 512-byte blocks
|
|
|
|
return st.Blocks * 512
|
2016-07-02 19:43:57 +02:00
|
|
|
}
|
2016-11-10 23:32:51 +01:00
|
|
|
|
|
|
|
// QueryCtlSock sends a request to the control socket at "socketPath" and
|
|
|
|
// returns the response.
|
|
|
|
func QueryCtlSock(t *testing.T, socketPath string, req ctlsock.RequestStruct) (response ctlsock.ResponseStruct) {
|
|
|
|
conn, err := net.DialTimeout("unix", socketPath, 1*time.Second)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer conn.Close()
|
|
|
|
conn.SetDeadline(time.Now().Add(time.Second))
|
|
|
|
msg, err := json.Marshal(req)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
_, err = conn.Write(msg)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2017-02-16 18:47:04 +01:00
|
|
|
buf := make([]byte, ctlsock.ReadBufSize)
|
2016-11-10 23:32:51 +01:00
|
|
|
n, err := conn.Read(buf)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
buf = buf[:n]
|
|
|
|
json.Unmarshal(buf, &response)
|
|
|
|
return response
|
|
|
|
}
|
2018-04-01 21:23:32 +02:00
|
|
|
|
2018-04-08 20:24:29 +02:00
|
|
|
// ExtractCmdExitCode extracts the exit code from an error value that was
|
|
|
|
// returned from exec / cmd.Run()
|
2018-04-01 21:23:32 +02:00
|
|
|
func ExtractCmdExitCode(err error) int {
|
|
|
|
if err == nil {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
// OMG this is convoluted
|
|
|
|
err2 := err.(*exec.ExitError)
|
|
|
|
code := err2.Sys().(syscall.WaitStatus).ExitStatus()
|
|
|
|
return code
|
|
|
|
}
|
2018-04-07 15:21:05 +02:00
|
|
|
|
|
|
|
// ListFds lists our open file descriptors.
|
|
|
|
// We use /dev/fd because it exists on both Linux and MacOS.
|
|
|
|
func ListFds() []string {
|
|
|
|
f, err := os.Open("/dev/fd")
|
|
|
|
if err != nil {
|
|
|
|
log.Panic(err)
|
|
|
|
}
|
|
|
|
defer f.Close()
|
|
|
|
names, err := f.Readdirnames(0)
|
|
|
|
if err != nil {
|
|
|
|
log.Panic(err)
|
|
|
|
}
|
|
|
|
for i, n := range names {
|
|
|
|
// Note: Readdirnames filters "." and ".."
|
|
|
|
target, _ := os.Readlink("/dev/fd/" + n)
|
|
|
|
names[i] = n + "=" + target
|
|
|
|
}
|
|
|
|
return names
|
|
|
|
}
|