From 79851bf6cc391f1150be387631159d553d5426f3 Mon Sep 17 00:00:00 2001
From: Jakob Unterwurzacher
Date: Sun, 3 Jul 2016 20:05:32 +0200
Subject: syscallcompat: OSX: add Renamat wrapper

Adds a poor man's renameat implementation for OSX.
---
 internal/syscallcompat/sys_darwin.go | 91 ++++++++++++++++++++++++++----------
 internal/syscallcompat/sys_linux.go  |  8 +++-
 2 files changed, 73 insertions(+), 26 deletions(-)

(limited to 'internal/syscallcompat')

diff --git a/internal/syscallcompat/sys_darwin.go b/internal/syscallcompat/sys_darwin.go
index 81e1b15..7d39484 100644
--- a/internal/syscallcompat/sys_darwin.go
+++ b/internal/syscallcompat/sys_darwin.go
@@ -2,44 +2,87 @@ package syscallcompat
 
 import (
 	"os"
+	"path/filepath"
 	"sync"
 	"syscall"
 )
 
-// prealloc - preallocate space without changing the file size. This prevents
-// us from running out of space in the middle of an operation.
-func Prealloc(fd int, off int64, len int64) (err error) {
-	//
-	// Sorry, fallocate is not available on OSX at all and
-	// fcntl F_PREALLOCATE is not accessible from Go.
-	//
-	// See https://github.com/rfjakob/gocryptfs/issues/18 if you want to help.
+// Sorry, fallocate is not available on OSX at all and
+// fcntl F_PREALLOCATE is not accessible from Go.
+// See https://github.com/rfjakob/gocryptfs/issues/18 if you want to help.
+func EnospcPrealloc(fd int, off int64, len int64) (err error) {
 	return nil
 }
 
-var openatLock sync.Mutex
+// See above.
+func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
+	return syscall.EOPNOTSUPP
+}
 
-// Poor man's Openat:
-// 1) fchdir to the dirfd
-// 2) open the file
-// 3) chdir back.
+var chdirMutex sync.Mutex
+
+// Poor man's Openat
 func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
-	openatLock.Lock()
-	defer openatLock.Unlock()
+	chdirMutex.Lock()
+	defer chdirMutex.Unlock()
+	if !filepath.IsAbs(path) {
+		// Save the old working directory
+		oldWd, err := os.Getwd()
+		if err != nil {
+			return -1, err
+		}
+		// Chdir to target directory
+		err = syscall.Fchdir(dirfd)
+		if err != nil {
+			return -1, err
+		}
+		// Chdir back at the end
+		defer os.Chdir(oldWd)
+	}
+	return syscall.Open(path, flags, mode)
+}
 
-	oldWd, err := os.Getwd()
+// Poor man's Renameat
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
+	chdirMutex.Lock()
+	defer chdirMutex.Unlock()
+	// Unless both paths are absolute we have to save the old working dir and
+	// Chdir(oldWd) back to it in the end. If we error out before the first
+	// chdir, Chdir(oldWd) is unneccassary but does no harm.
+	if !filepath.IsAbs(oldpath) || !filepath.IsAbs(newpath) {
+		oldWd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+		defer os.Chdir(oldWd)
+	}
+	// Make oldpath absolute
+	oldpath, err = dirfdAbs(olddirfd, oldpath)
 	if err != nil {
-		return -1, err
+		return err
 	}
-	err = syscall.Fchdir(dirfd)
+	// Make newpath absolute
+	newpath, err = dirfdAbs(newdirfd, newpath)
 	if err != nil {
-		return -1, err
+		return err
 	}
-	defer os.Chdir(oldWd)
-
-	return syscall.Open(path, flags, mode)
+	return syscall.Rename(oldpath, newpath)
 }
 
-func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
-	return syscall.EOPNOTSUPP
+// dirfdAbs transforms the dirfd-relative "path" to an absolute one. If the
+// path is not already absolute, this function will change the working
+// directory. The caller has to chdir back.
+func dirfdAbs(dirfd int, path string) (absPath string, err error) {
+	if filepath.IsAbs(path) {
+		return path, nil
+	}
+	err = syscall.Fchdir(dirfd)
+	if err != nil {
+		return "", err
+	}
+	wd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(wd, path), nil
 }
diff --git a/internal/syscallcompat/sys_linux.go b/internal/syscallcompat/sys_linux.go
index ca6df95..e12d100 100644
--- a/internal/syscallcompat/sys_linux.go
+++ b/internal/syscallcompat/sys_linux.go
@@ -37,10 +37,14 @@ func EnospcPrealloc(fd int, off int64, len int64) (err error) {
 	}
 }
 
+func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
+	return syscall.Fallocate(fd, mode, off, len)
+}
+
 func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
 	return syscall.Openat(dirfd, path, flags, mode)
 }
 
-func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
-	return syscall.Fallocate(fd, mode, off, len)
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
+	return syscall.Renameat(olddirfd, oldpath, newdirfd, newpath)
 }
-- 
cgit v1.2.3