add symlinkat, fix(?) windows errors

Author: Qelxiros

library/std/src/fs.rs

@@ -1786,6 +1786,15 @@ impl Dir {
     ) -> io::Result<()> {
         self.inner.rename(from, &to_dir.inner, to)
     }
+
+    /// Attempts to create a new symbolic link on the filesystem.
+    ///
+    /// If `original` is a relative path, it is interpreted relative to the created link.
+    /// If `link` is a relative path, it is interpreted relative to `self`.
+    #[unstable(feature = "dirfd", issue = "120426")]
+    pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(&self, original: P, link: Q) -> io::Result<()> {
+        self.inner.symlink(original, link)
+    }
 }
 
 #[unstable(feature = "dirfd", issue = "120426")]

library/std/src/sys/fs/common.rs

@@ -4,7 +4,7 @@ use crate::fmt;
 use crate::fs::{self, create_dir, remove_dir, remove_file, rename};
 use crate::io::{self, Error, ErrorKind};
 use crate::path::{Path, PathBuf};
-use crate::sys::fs::{File, OpenOptions};
+use crate::sys::fs::{File, OpenOptions, symlink};
 use crate::sys_common::ignore_notfound;
 
 pub(crate) const NOT_FILE_ERROR: Error = io::const_error!(
@@ -116,6 +116,10 @@ impl Dir {
     ) -> io::Result<()> {
         rename(self.path.join(from), to_dir.path.join(to))
     }
+
+    pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(&self, original: P, link: Q) -> io::Result<()> {
+        symlink(original.as_ref(), link.as_ref())
+    }
 }
 
 impl fmt::Debug for Dir {

library/std/src/sys/fs/uefi.rs

@@ -166,6 +166,14 @@ impl Dir {
     ) -> io::Result<()> {
         self.0
     }
+
+    pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(
+        &self,
+        _original: P,
+        _link: Q,
+    ) -> io::Result<()> {
+        self.0
+    }
 }
 
 impl fmt::Debug for Dir {

library/std/src/sys/fs/unix.rs

@@ -79,7 +79,7 @@ use libc::{dirent64, fstat64, ftruncate64, lseek64, lstat64, off64_t, open64, st
     target_os = "solaris",
     target_vendor = "apple",
 ))]
-use libc::{mkdirat, openat as openat64, renameat, unlinkat};
+use libc::{mkdirat, openat as openat64, renameat, symlinkat, unlinkat};
 #[cfg(not(any(
     target_os = "redox",
     target_os = "espidf",
@@ -94,7 +94,7 @@ use libc::{mkdirat, openat as openat64, renameat, unlinkat};
     target_vendor = "apple",
     miri
 )))]
-use libc::{mkdirat, openat64, renameat, unlinkat};
+use libc::{mkdirat, openat64, renameat, symlinkat, unlinkat};
 
 #[cfg(any(target_os = "freebsd", target_os = "aix"))]
 const TRAVERSE_DIRECTORY: i32 = libc::O_EXEC;
@@ -400,6 +400,12 @@ impl Dir {
         })
     }
 
+    pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(&self, original: P, link: Q) -> io::Result<()> {
+        run_path_with_cstr(original.as_ref(), &|original| {
+            run_path_with_cstr(link.as_ref(), &|link| self.symlink_c(original, link))
+        })
+    }
+
     pub fn open_c(&self, path: &CStr, opts: &OpenOptions) -> io::Result<File> {
         let flags = libc::O_CLOEXEC
             | opts.get_access_mode()?
@@ -460,6 +466,10 @@ impl Dir {
         })
         .map(|_| ())
     }
+
+    pub fn symlink_c(&self, original: &CStr, link: &CStr) -> io::Result<()> {
+        cvt(unsafe { symlinkat(original.as_ptr(), self.0.as_raw_fd(), link.as_ptr()) }).map(|_| ())
+    }
 }
 
 fn get_path_from_fd(fd: c_int) -> Option<PathBuf> {

library/std/src/sys/fs/unsupported.rs

@@ -202,6 +202,14 @@ impl Dir {
     ) -> io::Result<()> {
         self.0
     }
+
+    pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(
+        &self,
+        _original: P,
+        _link: Q,
+    ) -> io::Result<()> {
+        self.0
+    }
 }
 
 impl fmt::Debug for Dir {

library/std/src/sys/fs/windows.rs

@@ -974,15 +974,15 @@ fn run_path_with_utf16<T, P: AsRef<Path>>(
 impl Dir {
     pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Self> {
         let opts = OpenOptions::new();
-        Self::new_with_native(path.as_ref(), &opts).map(|handle| Self { handle })
+        run_path_with_wcstr(path.as_ref(), &|path| Self::new_with_native(path, &opts))
     }
 
     pub fn new_with<P: AsRef<Path>>(path: P, opts: &OpenOptions) -> io::Result<Self> {
-        Self::new_with_native(path.as_ref(), &opts).map(|handle| Self { handle })
+        run_path_with_wcstr(path.as_ref(), &|path| Self::new_with_native(path, &opts))
     }
 
     pub fn new_for_traversal<P: AsRef<Path>>(path: P) -> io::Result<Self> {
-        Self::new_native(path.as_ref()).map(|handle| Self { handle })
+        run_path_with_wcstr(path.as_ref(), &|path| Self::new_native(path))
     }
 
     pub fn open<P: AsRef<Path>>(&self, path: P) -> io::Result<File> {
@@ -1032,14 +1032,35 @@ impl Dir {
         run_path_with_wcstr(to.as_ref(), &|to| self.rename_native(from.as_ref(), to_dir, to))
     }
 
-    fn new_native(path: &Path) -> io::Result<Handle> {
+    pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(&self, original: P, link: Q) -> io::Result<()> {
+        run_path_with_utf16(original.as_ref(), &|orig| {
+            self.symlink_native(orig, link.as_ref(), original.as_ref().is_relative())
+        })
+    }
+
+    fn new_native(path: &WCStr) -> io::Result<Self> {
         let mut opts = OpenOptions::new();
         opts.access_mode(c::FILE_TRAVERSE);
-        File::open(path, &opts).map(|file| file.into_inner())
+        Self::new_with_native(path, &opts)
     }
 
-    fn new_with_native(path: &Path, opts: &OpenOptions) -> io::Result<Handle> {
-        File::open(path, opts).map(|file| file.into_inner())
+    fn new_with_native(path: &WCStr, opts: &OpenOptions) -> io::Result<Self> {
+        let creation = opts.get_creation_mode()?;
+        let handle = unsafe {
+            c::CreateFileW(
+                path.as_ptr(),
+                opts.get_access_mode()?,
+                opts.share_mode,
+                opts.security_attributes,
+                creation,
+                opts.get_flags_and_attributes() | c::FILE_FLAG_BACKUP_SEMANTICS,
+                ptr::null_mut(),
+            )
+        };
+        match OwnedHandle::try_from(unsafe { HandleOrInvalid::from_raw_handle(handle) }) {
+            Ok(handle) => Ok(Self { handle: Handle::from_inner(handle) }),
+            Err(_) => Err(Error::last_os_error()),
+        }
     }
 
     fn open_native(&self, path: &[u16], opts: &OpenOptions) -> io::Result<Handle> {
@@ -1165,6 +1186,71 @@ impl Dir {
         unsafe { dealloc(file_rename_info.cast::<u8>(), layout) };
         if result == 0 { Err(api::get_last_error()).io_result() } else { Ok(()) }
     }
+
+    fn symlink_native(&self, original: &[u16], link: &Path, relative: bool) -> io::Result<()> {
+        const TOO_LONG_ERR: io::Error =
+            io::const_error!(io::ErrorKind::InvalidFilename, "File name is too long");
+        let mut opts = OpenOptions::new();
+        opts.write(true);
+        let linkfile = File::open(link, &opts)?;
+        let utf16: Vec<u16> = original.iter().chain(original).copied().collect();
+        let file_name_len = u16::try_from(original.len()).or(Err(TOO_LONG_ERR))?;
+        let sym_buffer = c::SYMBOLIC_LINK_REPARSE_BUFFER {
+            SubstituteNameOffset: 0,
+            SubstituteNameLength: file_name_len,
+            PrintNameOffset: file_name_len,
+            PrintNameLength: file_name_len,
+            Flags: if relative { c::SYMLINK_FLAG_RELATIVE } else { 0 },
+            PathBuffer: 0,
+        };
+        let layout = Layout::new::<c::REPARSE_DATA_BUFFER>();
+        let layout = layout
+            .extend(Layout::new::<c::SYMBOLIC_LINK_REPARSE_BUFFER>())
+            .or(Err(TOO_LONG_ERR))?
+            .0;
+        let layout = Layout::array::<u16>(original.len() * 2)
+            .and_then(|arr| layout.extend(arr))
+            .or(Err(TOO_LONG_ERR))?
+            .0;
+        let buffer = unsafe { alloc(layout) }.cast::<c::REPARSE_DATA_BUFFER>();
+        unsafe {
+            buffer.write(c::REPARSE_DATA_BUFFER {
+                ReparseTag: c::IO_REPARSE_TAG_SYMLINK,
+                ReparseDataLength: u16::try_from(size_of_val(&sym_buffer)).or(Err(TOO_LONG_ERR))?,
+                Reserved: 0,
+                rest: (),
+            });
+            buffer
+                .add(offset_of!(c::REPARSE_DATA_BUFFER, rest))
+                .cast::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
+                .write(sym_buffer);
+            ptr::copy_nonoverlapping(
+                utf16.as_ptr(),
+                buffer
+                    .add(offset_of!(c::REPARSE_DATA_BUFFER, rest))
+                    .add(offset_of!(c::SYMBOLIC_LINK_REPARSE_BUFFER, PathBuffer))
+                    .cast::<u16>(),
+                original.len() * 2,
+            );
+        };
+        let result = unsafe {
+            c::DeviceIoControl(
+                linkfile.handle.as_raw_handle(),
+                c::FSCTL_SET_REPARSE_POINT,
+                &raw const buffer as *const c_void,
+                u32::try_from(size_of_val(&buffer)).or(Err(TOO_LONG_ERR))?,
+                ptr::null_mut(),
+                0,
+                ptr::null_mut(),
+                ptr::null_mut(),
+            )
+        };
+        unsafe {
+            dealloc(buffer.cast(), layout);
+        }
+
+        if result == 0 { Err(api::get_last_error()).io_result() } else { Ok(()) }
+    }
 }
 
 impl fmt::Debug for Dir {