Implement symlink and symlinkat

Author: oblique

src/unistd.rs

@@ -506,6 +506,45 @@ pub fn mkfifo<P: ?Sized + NixPath>(path: &P, mode: Mode) -> Result<()> {
     Errno::result(res).map(drop)
 }
 
+/// Creates a symbolic link at `path2` which points to `path1`.
+///
+/// If `dirfd` has a value, then `path2` is relative to directory associated
+/// with the file descriptor.
+///
+/// If `dirfd` is `None`, then `path2` is relative to the current working directory.
+/// This is identical to `symlink(path1, path2)`.
+///
+/// See also [symlinkat(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlinkat.html).
+pub fn symlinkat<P1: ?Sized + NixPath, P2: ?Sized + NixPath>(
+    path1: &P1,
+    dirfd: Option<RawFd>,
+    path2: &P2) -> Result<()> {
+    let res =
+        path1.with_nix_path(|path1| {
+            path2.with_nix_path(|path2| {
+                unsafe {
+                    libc::symlinkat(
+                        path1.as_ptr(),
+                        dirfd.unwrap_or(libc::AT_FDCWD),
+                        path2.as_ptr()
+                    )
+                }
+            })
+        })??;
+    Errno::result(res).map(drop)
+}
+
+/// Creates a symbolic link at `path2` which points to `path1`.
+///
+/// This is same as calling `symlinkat(path1, None, path2)`.
+///
+/// See also [symlink(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html)
+pub fn symlink<P1: ?Sized + NixPath, P2: ?Sized + NixPath>(
+    path1: &P1,
+    path2: &P2) -> Result<()> {
+    symlinkat(path1, None, path2)
+}
+
 /// Returns the current directory as a `PathBuf`
 ///
 /// Err is returned if the current user doesn't have the permission to read or search a component

test/test_unistd.rs

@@ -1,4 +1,4 @@
-use nix::fcntl::{fcntl, FcntlArg, FdFlag, open, OFlag};
+use nix::fcntl::{fcntl, FcntlArg, FdFlag, open, OFlag, readlink};
 use nix::unistd::*;
 use nix::unistd::ForkResult::*;
 use nix::sys::signal::{SaFlags, SigAction, SigHandler, SigSet, Signal, sigaction};
@@ -543,3 +543,29 @@ fn test_canceling_alarm() {
     assert_eq!(alarm::set(60), None);
     assert_eq!(alarm::cancel(), Some(60));
 }
+
+#[test]
+fn test_symlink() {
+    let mut buf = [0; 1024];
+    let tempdir = TempDir::new("nix-test_symlinkat")
+        .unwrap_or_else(|e| panic!("tempdir failed: {}", e));
+
+    let target = tempdir.path().join("a");
+    let linkpath = tempdir.path().join("b");
+    symlink(&target, &linkpath).unwrap();
+    assert_eq!(readlink(&linkpath, &mut buf).unwrap().to_str().unwrap(),
+               target.to_str().unwrap());
+
+    let target = tempdir.path().join("c");
+    let linkpath = tempdir.path().join("d");
+    symlinkat(&target, None, &linkpath).unwrap();
+    assert_eq!(readlink(&linkpath, &mut buf).unwrap().to_str().unwrap(),
+               target.to_str().unwrap());
+
+    let dirfd = open(tempdir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let target = "e";
+    let linkpath = "f";
+    symlinkat(target, Some(dirfd), linkpath).unwrap();
+    assert_eq!(readlink(&tempdir.path().join(linkpath), &mut buf).unwrap().to_str().unwrap(),
+               target);
+}