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<()> {
let existing_length = adaptor.size().await?.min(length);
adaptor.truncate(length).await?;
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(),
));
}
use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
use windows_sys::Win32::Foundation::{
DUPLICATE_SAME_ACCESS, DuplicateHandle, GetLastError, HANDLE,
};
use windows_sys::Win32::System::Threading::GetCurrentProcess;
let duplicate_result: std::result::Result<usize, u32> = {
let current_process = unsafe { GetCurrentProcess() };
let mut duplicated_handle: HANDLE = std::ptr::null_mut();
let duplicated = unsafe {
DuplicateHandle(
current_process,
handle,
current_process,
&mut duplicated_handle,
0,
0,
DUPLICATE_SAME_ACCESS,
)
};
if duplicated == 0 {
Err(unsafe { GetLastError() })
} else {
Ok(duplicated_handle as usize)
}
};
let allocation_result = match duplicate_result {
Err(error) => Err(error),
Ok(handle_value) => tokio::task::spawn_blocking(move || {
let owned_handle = unsafe { OwnedHandle::from_raw_handle(handle_value as HANDLE) };
let _ = try_enable_volume_privilege();
let handle = owned_handle.as_raw_handle() as HANDLE;
let ok = unsafe {
windows_sys::Win32::Storage::FileSystem::SetFileValidData(handle, length as i64)
};
if ok == 0 {
let error = unsafe { windows_sys::Win32::Foundation::GetLastError() };
Err(error)
} else {
Ok(())
}
})
.await
.map_err(|error| Aria2Error::Io(format!("SetFileValidData task failed: {error}")))?,
};
if let Err(err) = allocation_result {
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_from(adaptor, existing_length, 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(())
}
}