feat: support stampinf version override

.cargo/config.toml

@@ -9,4 +9,5 @@ rustflags = [
 
   # Unstable cfg options:
   # "--cfg", "skip_umdf_static_crt_check",
+  # "--cfg", "allow_stampinf_version_env_override"
 ]

crates/cargo-wdk/Cargo.toml

@@ -36,6 +36,13 @@ sha2.workspace = true
 missing_docs = "warn"
 unsafe_op_in_unsafe_fn = "forbid"
 
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+  "cfg(wdk_build_unstable)",
+  "cfg(allow_stampinf_version_env_override)",
+]
+
 [lints.clippy]
 # Lint Groups
 all = "deny"

crates/cargo-wdk/src/actions/build/package_task.rs

@@ -313,9 +313,31 @@ impl<'a> PackageTask<'a> {
             &arch,
             "-c",
             &cat_file_path,
-            "-v",
-            "*",
         ];
+
+        // DriverVer handling:
+        // 1. When BOTH cfg flags (wdk_build_unstable +
+        //    allow_stampinf_version_env_override) are enabled, allow an external
+        //    override via STAMPINF_VERSION env var. If the env var is absent we fall
+        //    back to auto-generation (-v *).
+        // 2. Otherwise (stable / default builds) always request auto-generation (-v *).
+        #[cfg(all(wdk_build_unstable, allow_stampinf_version_env_override))]
+        {
+            if let Ok(version) = std::env::var("STAMPINF_VERSION") {
+                // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it
+                // and populates DriverVer.
+                info!("Using STAMPINF_VERSION env var to set DriverVer: {version}");
+            } else {
+                args.push("-v");
+                args.push("*");
+            }
+        }
+        #[cfg(not(all(wdk_build_unstable, allow_stampinf_version_env_override)))]
+        {
+            args.push("-v");
+            args.push("*");
+        }
+
         if !wdf_version_flags.is_empty() {
             args.append(&mut wdf_version_flags.iter().map(String::as_str).collect());
         }
@@ -631,4 +653,77 @@ mod tests {
 
         PackageTask::new(package_task_params, &wdk_build, &command_exec, &fs);
     }
+
+    // Parameterized test for run_stampinf covering env present/absent.
+    // Compile-time cfgs determine expectation via cfg! so a single test body
+    // suffices.
+    #[test]
+    fn run_stampinf_parameterized_env_overrides() {
+        use std::process::{ExitStatus, Output};
+
+        let scenarios = [("env_set", Some("1.2.3.4")), ("env_unset", None)];
+
+        let both_cfgs = cfg!(all(wdk_build_unstable, allow_stampinf_version_env_override));
+
+        for (name, env_val) in scenarios {
+            if let Some(v) = env_val {
+                std::env::set_var("STAMPINF_VERSION", v);
+            } else {
+                std::env::remove_var("STAMPINF_VERSION");
+            }
+
+            let package_name = "driver"; // reuse
+            let working_dir = PathBuf::from("C:/abs/driver");
+            let target_dir = PathBuf::from("C:/abs/target/debug");
+            let arch = CpuArchitecture::Amd64;
+
+            let params = PackageTaskParams {
+                package_name,
+                working_dir: &working_dir,
+                target_dir: &target_dir,
+                target_arch: &arch,
+                driver_model: DriverConfig::Kmdf(KmdfConfig::default()),
+                sample_class: false,
+                verify_signature: false,
+            };
+
+            let wdk_build = WdkBuild::default();
+            let fs = Fs::default();
+            let mut command_exec = CommandExec::default();
+
+            let expect_skip_v = env_val.is_some() && both_cfgs; // skip -v only in override path
+
+            command_exec
+                .expect_run()
+                .withf(move |cmd: &str, args: &[&str], _, _| {
+                    if cmd != "stampinf" {
+                        return false;
+                    }
+                    let has_v = args.contains(&"-v");
+                    if expect_skip_v {
+                        !has_v
+                    } else {
+                        args.windows(2).any(|w| w == ["-v", "*"])
+                    }
+                })
+                .once()
+                .return_once(|_, _, _, _| {
+                    Ok(Output {
+                        status: ExitStatus::default(),
+                        stdout: vec![],
+                        stderr: vec![],
+                    })
+                });
+
+            let task = PackageTask::new(params, &wdk_build, &command_exec, &fs);
+            let result = task.run_stampinf();
+            assert!(
+                result.is_ok(),
+                "scenario {name} failed (cfgs_override_enabled={both_cfgs}, env_set={env_val:?})"
+            );
+        }
+
+        // Cleanup
+        std::env::remove_var("STAMPINF_VERSION");
+    }
 }