use std::fs::{self, File, OpenOptions};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use crate::error::{MinixError, Result};
use crate::fs::{CreateImageOptions, CreateNodeOptions, MinixFileSystem};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DeviceNodeKind {
Block,
Character,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ImageSpec {
pub output: PathBuf,
pub image_size: u64,
pub inode_count: u16,
pub default_uid: u16,
pub default_gid: u8,
pub default_mtime: u32,
pub default_file_mode: u16,
pub default_dir_mode: u16,
pub overwrite_output: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct BuildRequest {
pub image: ImageSpec,
pub entries: Vec<BuildEntry>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum BuildEntry {
File(FileMapping),
Tree(TreeMapping),
Directory(DirectoryMapping),
Device(DeviceMapping),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FileMapping {
pub source: PathBuf,
pub target: String,
pub mode: Option<u16>,
pub uid: Option<u16>,
pub gid: Option<u8>,
pub mtime: Option<u32>,
pub overwrite: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TreeMapping {
pub source: PathBuf,
pub target: String,
pub file_mode: Option<u16>,
pub dir_mode: Option<u16>,
pub uid: Option<u16>,
pub gid: Option<u8>,
pub mtime: Option<u32>,
pub overwrite: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DirectoryMapping {
pub target: String,
pub mode: Option<u16>,
pub uid: Option<u16>,
pub gid: Option<u8>,
pub mtime: Option<u32>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DeviceMapping {
pub target: String,
pub device_kind: DeviceNodeKind,
pub major: u8,
pub minor: u8,
pub mode: Option<u16>,
pub uid: Option<u16>,
pub gid: Option<u8>,
pub mtime: Option<u32>,
}
pub fn build_image(request: &BuildRequest) -> Result<()> {
if let Some(parent) = request.image.output.parent()
&& !parent.as_os_str().is_empty()
{
fs::create_dir_all(parent).map_err(|source| {
MinixError::io(
Some(parent.to_path_buf()),
"failed to create parent directories for the image output",
source,
)
})?;
}
let mut open_options = OpenOptions::new();
open_options
.read(true)
.write(true)
.create(true)
.truncate(true);
if !request.image.overwrite_output && request.image.output.exists() {
return Err(MinixError::AlreadyExists(format!(
"output image `{}` already exists; use `--force` to overwrite it",
request.image.output.display()
)));
}
let file = open_options.open(&request.image.output).map_err(|source| {
MinixError::io(
Some(request.image.output.clone()),
"failed to create output image",
source,
)
})?;
let mut image = MinixFileSystem::create(
file,
CreateImageOptions {
image_size: request.image.image_size,
inode_count: request.image.inode_count,
root_mode: request.image.default_dir_mode,
default_uid: request.image.default_uid,
default_gid: request.image.default_gid,
default_mtime: request.image.default_mtime,
},
)?;
for entry in &request.entries {
match entry {
BuildEntry::File(mapping) => apply_file_mapping(&mut image, &request.image, mapping)?,
BuildEntry::Tree(mapping) => apply_tree_mapping(&mut image, &request.image, mapping)?,
BuildEntry::Directory(mapping) => {
apply_directory_mapping(&mut image, &request.image, mapping)?
}
BuildEntry::Device(mapping) => {
apply_device_mapping(&mut image, &request.image, mapping)?
}
}
}
image.flush()?;
let mut file = image.into_inner()?;
file.flush().map_err(|source| {
MinixError::io(
Some(request.image.output.clone()),
"failed to flush output image",
source,
)
})
}
fn apply_file_mapping(
image: &mut MinixFileSystem<File>,
image_spec: &ImageSpec,
mapping: &FileMapping,
) -> Result<()> {
let metadata = fs::symlink_metadata(&mapping.source).map_err(|source| {
MinixError::io(
Some(mapping.source.clone()),
"failed to read source file metadata",
source,
)
})?;
if metadata.file_type().is_symlink() {
return Err(MinixError::Unsupported(format!(
"symbolic links are not supported by build mappings (`{}`)",
mapping.source.display()
)));
}
if !metadata.is_file() {
return Err(MinixError::InvalidArgument(format!(
"file mapping source `{}` is not a regular file",
mapping.source.display()
)));
}
let data = fs::read(&mapping.source).map_err(|source| {
MinixError::io(
Some(mapping.source.clone()),
"failed to read source file",
source,
)
})?;
let file_options = create_file_options(
image_spec,
mapping.mode,
mapping.uid,
mapping.gid,
mapping.mtime,
Some(&metadata),
);
let parent_options = default_directory_options(image_spec);
image.write_file_at_path(
&mapping.target,
&data,
&file_options,
mapping.overwrite,
&parent_options,
)
}
fn apply_tree_mapping(
image: &mut MinixFileSystem<File>,
image_spec: &ImageSpec,
mapping: &TreeMapping,
) -> Result<()> {
let metadata = fs::symlink_metadata(&mapping.source).map_err(|source| {
MinixError::io(
Some(mapping.source.clone()),
"failed to read source directory metadata",
source,
)
})?;
if metadata.file_type().is_symlink() {
return Err(MinixError::Unsupported(format!(
"symbolic links are not supported by build mappings (`{}`)",
mapping.source.display()
)));
}
if !metadata.is_dir() {
return Err(MinixError::InvalidArgument(format!(
"tree mapping source `{}` is not a directory",
mapping.source.display()
)));
}
let directory_options = create_directory_options(
image_spec,
mapping.dir_mode,
mapping.uid,
mapping.gid,
mapping.mtime,
);
image.mkdir_all(&mapping.target, &directory_options)?;
apply_tree_directory(
image,
image_spec,
mapping,
&mapping.source,
Path::new(""),
&directory_options,
)
}
fn apply_tree_directory(
image: &mut MinixFileSystem<File>,
image_spec: &ImageSpec,
mapping: &TreeMapping,
source_root: &Path,
relative: &Path,
directory_options: &CreateNodeOptions,
) -> Result<()> {
let host_directory = source_root.join(relative);
let mut entries = fs::read_dir(&host_directory)
.map_err(|source| {
MinixError::io(
Some(host_directory.clone()),
"failed to read source directory",
source,
)
})?
.collect::<std::result::Result<Vec<_>, _>>()
.map_err(|source| {
MinixError::io(
Some(host_directory.clone()),
"failed to enumerate source directory",
source,
)
})?;
entries.sort_by_key(|entry| entry.file_name());
for entry in entries {
let path = entry.path();
let file_name = entry.file_name();
let file_name = file_name.to_string_lossy().into_owned();
let child_relative = relative.join(&file_name);
let target_path = if mapping.target == "/" {
format!("/{}", child_relative.display())
} else {
format!(
"{}/{}",
mapping.target.trim_end_matches('/'),
child_relative.display()
)
};
let metadata = fs::symlink_metadata(&path).map_err(|source| {
MinixError::io(
Some(path.clone()),
"failed to read source entry metadata",
source,
)
})?;
if metadata.file_type().is_symlink() {
return Err(MinixError::Unsupported(format!(
"symbolic links are not supported by build mappings (`{}`)",
path.display()
)));
}
if metadata.is_dir() {
let child_directory_options = create_directory_options(
image_spec,
mapping.dir_mode,
mapping.uid,
mapping.gid,
mapping.mtime,
);
image.mkdir_all(&target_path, &child_directory_options)?;
apply_tree_directory(
image,
image_spec,
mapping,
source_root,
&child_relative,
&child_directory_options,
)?;
continue;
}
if !metadata.is_file() {
return Err(MinixError::Unsupported(format!(
"unsupported source entry kind at `{}`",
path.display()
)));
}
let mut file = File::open(&path).map_err(|source| {
MinixError::io(Some(path.clone()), "failed to open source file", source)
})?;
let mut data = Vec::new();
file.read_to_end(&mut data).map_err(|source| {
MinixError::io(Some(path.clone()), "failed to read source file", source)
})?;
let file_options = create_file_options(
image_spec,
mapping.file_mode,
mapping.uid,
mapping.gid,
mapping.mtime,
Some(&metadata),
);
image.write_file_at_path(
&target_path,
&data,
&file_options,
mapping.overwrite,
directory_options,
)?;
}
Ok(())
}
fn apply_directory_mapping(
image: &mut MinixFileSystem<File>,
image_spec: &ImageSpec,
mapping: &DirectoryMapping,
) -> Result<()> {
let options = create_directory_options(
image_spec,
mapping.mode,
mapping.uid,
mapping.gid,
mapping.mtime,
);
image.mkdir_all(&mapping.target, &options)
}
fn apply_device_mapping(
image: &mut MinixFileSystem<File>,
image_spec: &ImageSpec,
mapping: &DeviceMapping,
) -> Result<()> {
let options = create_device_options(
image_spec,
mapping.mode,
mapping.uid,
mapping.gid,
mapping.mtime,
);
let parent_options = default_directory_options(image_spec);
image.create_device_at_path(
&mapping.target,
mapping.device_kind,
device_number(mapping.major, mapping.minor),
&options,
&parent_options,
)
}
fn create_directory_options(
image_spec: &ImageSpec,
mode: Option<u16>,
uid: Option<u16>,
gid: Option<u8>,
mtime: Option<u32>,
) -> CreateNodeOptions {
CreateNodeOptions {
mode: mode.unwrap_or(image_spec.default_dir_mode),
uid: uid.unwrap_or(image_spec.default_uid),
gid: gid.unwrap_or(image_spec.default_gid),
mtime: mtime.unwrap_or(image_spec.default_mtime),
}
}
fn create_device_options(
image_spec: &ImageSpec,
mode: Option<u16>,
uid: Option<u16>,
gid: Option<u8>,
mtime: Option<u32>,
) -> CreateNodeOptions {
CreateNodeOptions {
mode: mode.unwrap_or(0o644),
uid: uid.unwrap_or(image_spec.default_uid),
gid: gid.unwrap_or(image_spec.default_gid),
mtime: mtime.unwrap_or(image_spec.default_mtime),
}
}
fn default_directory_options(image_spec: &ImageSpec) -> CreateNodeOptions {
CreateNodeOptions {
mode: image_spec.default_dir_mode,
uid: image_spec.default_uid,
gid: image_spec.default_gid,
mtime: image_spec.default_mtime,
}
}
fn create_file_options(
image_spec: &ImageSpec,
mode: Option<u16>,
uid: Option<u16>,
gid: Option<u8>,
mtime: Option<u32>,
metadata: Option<&fs::Metadata>,
) -> CreateNodeOptions {
let mode = mode.unwrap_or_else(|| {
let mut resolved = image_spec.default_file_mode;
if let Some(metadata) = metadata
&& host_file_is_executable(metadata)
{
resolved |= 0o111;
}
resolved
});
let mtime = mtime
.or_else(|| metadata.and_then(host_modified_time))
.unwrap_or(image_spec.default_mtime);
CreateNodeOptions {
mode,
uid: uid.unwrap_or(image_spec.default_uid),
gid: gid.unwrap_or(image_spec.default_gid),
mtime,
}
}
#[cfg(unix)]
fn host_file_is_executable(metadata: &fs::Metadata) -> bool {
use std::os::unix::fs::PermissionsExt;
metadata.permissions().mode() & 0o111 != 0
}
#[cfg(not(unix))]
fn host_file_is_executable(_metadata: &fs::Metadata) -> bool {
false
}
fn host_modified_time(metadata: &fs::Metadata) -> Option<u32> {
let modified = metadata.modified().ok()?;
let duration = modified.duration_since(UNIX_EPOCH).ok()?;
u32::try_from(duration.as_secs()).ok()
}
pub fn current_unix_time() -> u32 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|duration| duration.as_secs())
.ok()
.and_then(|seconds| u32::try_from(seconds).ok())
.unwrap_or(0)
}
pub const fn device_number(major: u8, minor: u8) -> u16 {
((major as u16) << 8) | minor as u16
}