fix: properly link check on Windows (#1598)

Author: wolfv

examples/linking/recipe.yaml

@@ -10,9 +10,14 @@ source:
 
 build:
   script:
-    - cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release ${CMAKE_ARGS}
+    - if: win
+      then:
+        - cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release %CMAKE_ARGS%
+    - if: unix
+      then:
+        - cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release ${CMAKE_ARGS}
     - cmake --build build --config Release
-    - cmake --install build --prefix ${PREFIX}
+    - cmake --install build
 
 requirements:
   build:

src/post_process/checks.rs

@@ -4,11 +4,14 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use crate::post_process::{package_nature::PackageNature, relink};
 use crate::{
     metadata::Output,
     post_process::{package_nature::PrefixInfo, relink::RelinkError},
 };
+use crate::{
+    post_process::{package_nature::PackageNature, relink},
+    windows::link::WIN_ALLOWLIST,
+};
 
 use crate::render::resolved_dependencies::RunExportDependency;
 use globset::{Glob, GlobSet, GlobSetBuilder};
@@ -168,6 +171,13 @@ fn find_system_libs(output: &Output) -> Result<GlobSet, globset::Error> {
         return system_libs.build();
     }
 
+    if output.build_configuration.target_platform.is_windows() {
+        for v in WIN_ALLOWLIST {
+            system_libs.add(Glob::new(v)?);
+        }
+        return system_libs.build();
+    }
+
     if let Some(sysroot_package) = output
         .finalized_dependencies
         .clone()
@@ -240,7 +250,10 @@ pub fn perform_linking_checks(
 
                     let lib = resolved.as_ref().unwrap_or(lib);
                     if let Ok(libpath) = lib.strip_prefix(host_prefix) {
-                        if let Some(package) = prefix_info.path_to_package.get(libpath) {
+                        if let Some(package) = prefix_info
+                            .path_to_package
+                            .get(&libpath.to_path_buf().into())
+                        {
                             if let Some(nature) = prefix_info.package_to_nature.get(package) {
                                 // Only take shared libraries into account.
                                 if nature == &PackageNature::DSOLibrary {
@@ -288,7 +301,7 @@ pub fn perform_linking_checks(
                 continue;
             }
 
-            //  Check if the package has the library linked.
+            // Check if the package has the library linked.
             if let Some(package) = package.linked_dsos.get(lib) {
                 link_info.linked_packages.push(LinkedPackage {
                     name: lib.to_path_buf(),

src/post_process/package_nature.rs

@@ -15,6 +15,7 @@
 use rattler_conda_types::{PackageName, PrefixRecord};
 use std::{
     collections::{HashMap, HashSet},
+    hash::Hash,
     ops::Sub,
     path::{Path, PathBuf},
 };
@@ -126,10 +127,43 @@ impl PackageNature {
     }
 }
 
+pub struct CaseInsensitivePathBuf {
+    path: PathBuf,
+}
+
+impl CaseInsensitivePathBuf {
+    fn normalize_path(&self) -> String {
+        self.path
+            .to_string_lossy()
+            .to_lowercase()
+            .replace('\\', "/")
+    }
+}
+
+impl Hash for CaseInsensitivePathBuf {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.normalize_path().hash(state);
+    }
+}
+
+impl From<PathBuf> for CaseInsensitivePathBuf {
+    fn from(path: PathBuf) -> Self {
+        CaseInsensitivePathBuf { path }
+    }
+}
+
+impl PartialEq for CaseInsensitivePathBuf {
+    fn eq(&self, other: &Self) -> bool {
+        self.normalize_path() == other.normalize_path()
+    }
+}
+
+impl Eq for CaseInsensitivePathBuf {}
+
 #[derive(Default)]
 pub(crate) struct PrefixInfo {
     pub package_to_nature: HashMap<PackageName, PackageNature>,
-    pub path_to_package: HashMap<PathBuf, PackageName>,
+    pub path_to_package: HashMap<CaseInsensitivePathBuf, PackageName>,
 }
 
 impl PrefixInfo {
@@ -149,10 +183,12 @@ impl PrefixInfo {
                         record.repodata_record.package_record.name.clone(),
                         package_nature,
                     );
+
                     for file in record.files {
-                        prefix_info
-                            .path_to_package
-                            .insert(file, record.repodata_record.package_record.name.clone());
+                        prefix_info.path_to_package.insert(
+                            file.into(),
+                            record.repodata_record.package_record.name.clone(),
+                        );
                     }
                 }
             }

src/windows/link.rs

@@ -8,6 +8,8 @@ use std::{
 use fs_err::File;
 
 use goblin::pe::{PE, header::DOS_MAGIC};
+use rattler_conda_types::Platform;
+use rattler_shell::activation::prefix_path_entries;
 use scroll::Pread;
 
 use crate::{
@@ -84,8 +86,8 @@ impl Relinker for Dll {
 
     fn resolve_libraries(
         &self,
-        _prefix: &Path,
-        _encoded_prefix: &Path,
+        prefix: &Path,
+        encoded_prefix: &Path,
     ) -> HashMap<PathBuf, Option<PathBuf>> {
         let mut result = HashMap::new();
         for lib in &self.libraries {
@@ -97,7 +99,46 @@ impl Relinker for Dll {
             }) {
                 continue;
             }
-            result.insert(lib.clone(), Some(lib.clone()));
+
+            let dll_name = lib.file_name().unwrap_or_default();
+
+            // 1. Check in the same directory as the original DLL
+            let path_in_prefix = self
+                .path
+                .strip_prefix(prefix)
+                .expect("DLL path should be in prefix");
+            let path = encoded_prefix.join(path_in_prefix);
+            let same_dir = path.parent().map(|p| p.join(dll_name));
+
+            if let Some(path) = same_dir {
+                if path.exists() {
+                    result.insert(lib.clone(), Some(path));
+                    continue;
+                }
+            }
+
+            // 2. Check all directories in the search path
+            let mut found = false;
+            let path_entries = prefix_path_entries(encoded_prefix, &Platform::Win64);
+            let path = std::env::var("PATH").unwrap_or_default();
+            let search_dirs = path_entries
+                .into_iter()
+                .chain(std::env::split_paths(&path))
+                .collect::<Vec<_>>();
+
+            for search_dir in search_dirs {
+                let potential_path = search_dir.join(dll_name);
+                if potential_path.exists() {
+                    result.insert(lib.clone(), Some(potential_path));
+                    found = true;
+                    break;
+                }
+            }
+
+            if !found {
+                // If not found anywhere, keep the original name but mark as None
+                result.insert(lib.clone(), None);
+            }
         }
         result
     }