fix symlink test on windows

Author: Qelxiros

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

@@ -1204,53 +1204,56 @@ impl Dir {
             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;
+        opts.create(true);
+        opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS);
+        opts.attributes(c::FILE_ATTRIBUTE_REPARSE_POINT);
+        let linkfile = self.open_with(link, &opts)?;
+        let original_name_byte_len =
+            u16::try_from(size_of::<u16>() * original.len()).or(Err(TOO_LONG_ERR))?;
+        let layout = Layout::from_size_align(
+            size_of::<c::REPARSE_DATA_BUFFER>()
+                + size_of::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
+                + size_of::<u16>() * (original.len() - 1),
+            align_of::<c::REPARSE_DATA_BUFFER>()
+                .max(align_of::<c::SYMBOLIC_LINK_REPARSE_BUFFER>())
+                .max(align_of::<u16>()),
+        )
+        .or(Err(TOO_LONG_ERR))?;
         let buffer = unsafe { alloc(layout) }.cast::<c::REPARSE_DATA_BUFFER>();
+        if buffer.is_null() {
+            return Err(io::ErrorKind::OutOfMemory.into());
+        }
         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,
+            (&raw mut (*buffer).ReparseTag).write(c::IO_REPARSE_TAG_SYMLINK);
+            (&raw mut (*buffer).ReparseDataLength).write(
+                u16::try_from(
+                    size_of::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
+                        + size_of::<u16>() * (original.len() - 1),
+                )
+                .or(Err(TOO_LONG_ERR))?,
             );
+            (&raw mut (*buffer).Reserved).write(0);
+            let rest = (&raw mut (*buffer).rest).cast::<c::SYMBOLIC_LINK_REPARSE_BUFFER>();
+
+            (&raw mut (*rest).SubstituteNameOffset).write(0);
+            (&raw mut (*rest).SubstituteNameLength).write(original_name_byte_len);
+            (&raw mut (*rest).PrintNameOffset).write(0);
+            (&raw mut (*rest).PrintNameLength).write(original_name_byte_len);
+            (&raw mut (*rest).Flags).write(if relative { c::SYMLINK_FLAG_RELATIVE } else { 0 });
+
+            original.as_ptr().copy_to_nonoverlapping(&raw mut (*rest).PathBuffer, original.len());
         };
         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))?,
+                buffer as *mut c_void as *const c_void,
+                u32::try_from(
+                    size_of::<c::REPARSE_DATA_BUFFER>()
+                        + size_of::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
+                        + size_of::<u16>() * (original.len() - 1),
+                )
+                .or(Err(TOO_LONG_ERR))?,
                 ptr::null_mut(),
                 0,
                 ptr::null_mut(),