use crate::error::{Aria2Error, Result};
use crate::filesystem::disk_adaptor::DiskAdaptor;
use super::strategies;
pub(crate) fn try_enable_volume_privilege() -> bool {
use windows_sys::Win32::Foundation::CloseHandle;
use windows_sys::Win32::Security::{
AdjustTokenPrivileges, LookupPrivilegeValueW, SE_MANAGE_VOLUME_NAME,
TOKEN_ADJUST_PRIVILEGES, TOKEN_PRIVILEGES, TOKEN_QUERY,
};
use windows_sys::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};
let mut token_handle = std::ptr::null_mut();
let result = unsafe {
OpenProcessToken(
GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&mut token_handle,
)
};
if result == 0 {
return false;
}
let mut luid: windows_sys::Win32::Foundation::LUID = unsafe { std::mem::zeroed() };
if unsafe { LookupPrivilegeValueW(std::ptr::null(), SE_MANAGE_VOLUME_NAME, &mut luid) } == 0 {
unsafe {
CloseHandle(token_handle);
}
return false;
}
let mut tp: TOKEN_PRIVILEGES = unsafe { std::mem::zeroed() };
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
tp.Privileges[0].Attributes = 2;
let ret = unsafe {
AdjustTokenPrivileges(
token_handle,
0,
&tp,
0,
std::ptr::null_mut(),
std::ptr::null_mut(),
)
};
unsafe {
CloseHandle(token_handle);
}
ret != 0
}
pub(crate) async fn fallocate_windows<D: DiskAdaptor>(
adaptor: &mut D,
length: u64,
secure: bool,
) -> Result<()> {
adaptor.truncate(length).await?;
let _ = try_enable_volume_privilege();
let valid_data_succeeded: bool = if let Some(handle) = adaptor.windows_raw_handle() {
if length > i64::MAX as u64 {
return Err(Aria2Error::Io(
"SetFileValidData length exceeds i64 range".into(),
));
}
let ok = unsafe {
windows_sys::Win32::Storage::FileSystem::SetFileValidData(handle, length as i64)
};
if ok == 0 {
let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
if err == windows_sys::Win32::Foundation::ERROR_PRIVILEGE_NOT_HELD {
tracing::warn!(
length,
"SetFileValidData requires SE_MANAGE_VOLUME_PRIVILEGE; \
falling back to sparse file. This causes ~2x I/O on \
first write because each block must be zeroed by the \
writer instead of being pre-allocated."
);
} else {
tracing::warn!(length, err, "SetFileValidData failed; file remains sparse");
}
false
} else {
true
}
} else {
false
};
if valid_data_succeeded {
if secure {
strategies::async_zero_fill(adaptor, length).await
} else {
super::SECURE_FALLOC_WARN_ONCE.call_once(|| {
tracing::warn!(
"SetFileValidData succeeded but does not zero-fill; \
residual disk data may be exposed. \
Enable --secure-falloc=true to zero-fill (at a \
performance cost). This warning is logged once."
);
});
Ok(())
}
} else {
Ok(())
}
}