rascul
/
mkroot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

move some functions out of the impl that don't need to be in there

Browse Source
master
rascul 5 years ago
parent c6c1e271b1
commit f9900daeef
3 changed files with 139 additions and 139 deletions
Show Stats Download Patch File Download Diff File

268
src/files/mkroot_files.rs
Unescape View File

@ -30,13 +30,13 @@ impl Files {
println!("Checking {}", &file.display());
}
Files::open(&file)?;
open(&file)?;
let (libs, lib64s) = Files::libs_from_ldd(&file, &config)?;
let (libs, lib64s) = libs_from_ldd(&file, &config)?;
myfiles.libs.extend(libs);
myfiles.lib64s.extend(lib64s);
if Files::check_sbin(&file) {
if check_sbin(&file) {
myfiles.sbins.push(file.to_owned());
} else {
myfiles.bins.push(file.to_owned());
@ -55,174 +55,174 @@ impl Files {
Ok(myfiles)
}
fn open(p: &PathBuf) -> MkrootResult<()> {
if let Err(e) = File::open(&p) {
return Err(MkrootError::from(format!(
"Error opening file ({}): {}",
&p.display(),
e
)));
}
Ok(())
}
fn libs_from_ldd(
file: &PathBuf,
config: &Config,
) -> MkrootResult<(Vec<PathBuf>, Vec<PathBuf>)> {
let ldd = Files::ldd(&file, &config)?;
let mut libs: Vec<PathBuf> = Vec::new();
let mut lib64s: Vec<PathBuf> = Vec::new();
pub fn copy(&self, config: &Config) -> MkrootResult<()> {
let mut target = PathBuf::from(&config.root_dir);
target.push("bin");
copy_files(&self.bins, &target, 0o755, config.verbose)?;
if ldd.is_empty() {
return Ok((libs, lib64s));
}
let mut target = PathBuf::from(&config.root_dir);
target.push("sbin");
copy_files(&self.sbins, &target, 0o755, config.verbose)?;
let re = Regex::new(r"(^|.* )(?P<path>/.*) \(0x[[:xdigit:]]{16}\)$")?;
let mut target = PathBuf::from(&config.root_dir);
target.push("libs");
copy_files(&self.libs, &target, 0o644, config.verbose)?;
for line in ldd.lines() {
let line = String::from(line.trim());
let mut target = PathBuf::from(&config.root_dir);
target.push("lib64");
copy_files(&self.lib64s, &target, 0o644, config.verbose)?;
if let Some(caps) = re.captures(&line) {
if let Some(rematch) = caps.name("path") {
let match_path = PathBuf::from(rematch.as_str());
Ok(())
}
}
if config.verbose {
println!("Adding {}", &match_path.display());
pub fn set_linker_permissions(
libs: &[PathBuf],
dir: &PathBuf,
verbose: bool,
) -> MkrootResult<()> {
for lib in libs {
if let Some(fn_osstr) = &lib.file_name() {
if let Some(fn_str) = fn_osstr.to_str() {
if fn_str.starts_with("ld-linux") {
let mut lib = PathBuf::from(&dir);
lib.push(&fn_str);
if verbose {
println!("Setting linker {} to mode 0o755", &lib.display());
}
if Files::check_lib64(&match_path) {
lib64s.push(match_path);
} else {
libs.push(match_path);
}
set_perms(&lib, Permissions::from_mode(0o755))?;
}
}
}
Ok((libs, lib64s))
}
fn check_lib64(path: &PathBuf) -> bool {
for c in path.components() {
if c.as_os_str() == "lib64" {
return true;
}
}
Ok(())
}
false
fn open(p: &PathBuf) -> MkrootResult<()> {
if let Err(e) = File::open(&p) {
return Err(MkrootError::from(format!(
"Error opening file ({}): {}",
&p.display(),
e
)));
}
Ok(())
}
fn check_sbin(path: &PathBuf) -> bool {
for c in path.components() {
if c.as_os_str() == "sbin" {
return true;
}
}
fn libs_from_ldd(
file: &PathBuf,
config: &Config,
) -> MkrootResult<(Vec<PathBuf>, Vec<PathBuf>)> {
let ldd = ldd(&file, &config)?;
false
let mut libs: Vec<PathBuf> = Vec::new();
let mut lib64s: Vec<PathBuf> = Vec::new();
if ldd.is_empty() {
return Ok((libs, lib64s));
}
fn ldd(file: &PathBuf, config: &Config) -> MkrootResult<String> {
match Command::new(&config.ldd).arg(file).output() {
Ok(output) => {
if output.status.success() {
Ok(String::from_utf8(output.stdout).unwrap_or_default())
} else if config.verbose {
let mut out = String::from("ldd failed: ");
let stdout = String::from_utf8(output.stdout).unwrap_or_default();
let stderr = String::from_utf8(output.stderr).unwrap_or_default();
if !stdout.is_empty() {
out = out + "stdout: " + &stdout + " ";
}
if !stderr.is_empty() {
out = out + "stderr: " + &stderr;
}
let re = Regex::new(r"(^|.* )(?P<path>/.*) \(0x[[:xdigit:]]{16}\)$")?;
for line in ldd.lines() {
let line = String::from(line.trim());
println!("{}", out.trim());
if let Some(caps) = re.captures(&line) {
if let Some(rematch) = caps.name("path") {
let match_path = PathBuf::from(rematch.as_str());
if config.verbose {
println!("Adding {}", &match_path.display());
}
Ok(String::new())
if check_lib64(&match_path) {
lib64s.push(match_path);
} else {
Ok(String::new())
libs.push(match_path);
}
}
Err(e) => Err(MkrootError::from(format!(
"Error running ldd ({}): {}",
&config.ldd.display(),
e
))),
}
}
pub fn copy(&self, config: &Config) -> MkrootResult<()> {
let mut target = PathBuf::from(&config.root_dir);
target.push("bin");
Files::copy_files(&self.bins, &target, 0o755, config.verbose)?;
let mut target = PathBuf::from(&config.root_dir);
target.push("sbin");
Files::copy_files(&self.sbins, &target, 0o755, config.verbose)?;
let mut target = PathBuf::from(&config.root_dir);
target.push("libs");
Files::copy_files(&self.libs, &target, 0o644, config.verbose)?;
Ok((libs, lib64s))
}
let mut target = PathBuf::from(&config.root_dir);
target.push("lib64");
Files::copy_files(&self.lib64s, &target, 0o644, config.verbose)?;
fn copy_files(
files: &[PathBuf],
target: &PathBuf,
mode: u32,
verbose: bool,
) -> MkrootResult<()> {
for f in files {
let mut t = PathBuf::from(&target);
if let Some(filename) = &f.file_name() {
t.push(filename);
if verbose {
println!("Copying {} to {}", &f.display(), &t.display());
}
Ok(())
copy_file(&f, &t)?;
set_perms(&t, Permissions::from_mode(mode))?;
} else if verbose {
println!("Skipping {}", &f.display());
}
}
pub fn set_linker_permissions(
libs: &[PathBuf],
dir: &PathBuf,
verbose: bool,
) -> MkrootResult<()> {
for lib in libs {
if let Some(fn_osstr) = &lib.file_name() {
if let Some(fn_str) = fn_osstr.to_str() {
if fn_str.starts_with("ld-linux") {
let mut lib = PathBuf::from(&dir);
lib.push(&fn_str);
if verbose {
println!("Setting linker {} to mode 0o755", &lib.display());
}
set_perms(&lib, Permissions::from_mode(0o755))?;
}
Ok(())
}
fn ldd(file: &PathBuf, config: &Config) -> MkrootResult<String> {
match Command::new(&config.ldd).arg(file).output() {
Ok(output) => {
if output.status.success() {
Ok(String::from_utf8(output.stdout).unwrap_or_default())
} else if config.verbose {
let mut out = String::from("ldd failed: ");
let stdout = String::from_utf8(output.stdout).unwrap_or_default();
let stderr = String::from_utf8(output.stderr).unwrap_or_default();
if !stdout.is_empty() {
out = out + "stdout: " + &stdout + " ";
}
if !stderr.is_empty() {
out = out + "stderr: " + &stderr;
}
println!("{}", out.trim());
Ok(String::new())
} else {
Ok(String::new())
}
}
Err(e) => Err(MkrootError::from(format!(
"Error running ldd ({}): {}",
&config.ldd.display(),
e
))),
}
}
Ok(())
fn check_lib64(path: &PathBuf) -> bool {
for c in path.components() {
if c.as_os_str() == "lib64" {
return true;
}
}
fn copy_files(
files: &[PathBuf],
target: &PathBuf,
mode: u32,
verbose: bool,
) -> MkrootResult<()> {
for f in files {
let mut t = PathBuf::from(&target);
if let Some(filename) = &f.file_name() {
t.push(filename);
if verbose {
println!("Copying {} to {}", &f.display(), &t.display());
}
false
}
copy_file(&f, &t)?;
set_perms(&t, Permissions::from_mode(mode))?;
} else if verbose {
println!("Skipping {}", &f.display());
}
fn check_sbin(path: &PathBuf) -> bool {
for c in path.components() {
if c.as_os_str() == "sbin" {
return true;
}
Ok(())
}
false
}

2
src/files/mod.rs
Unescape View File

@ -1,3 +1,3 @@
mod mkroot_files;
pub use mkroot_files::Files;
pub use mkroot_files::*;

8
src/main.rs
Unescape View File

@ -27,17 +27,17 @@ fn main() -> error::MkrootResult<()> {
}
dirs::check(&config)?;
let files = files::Files::gather(&config)?;
let mkrootfiles = files::Files::gather(&config)?;
dirs::create(&config)?;
files.copy(&config)?;
mkrootfiles.copy(&config)?;
let mut d = PathBuf::from(&config.root_dir);
d.push("lib");
files::Files::set_linker_permissions(&files.libs, &d, config.verbose)?;
files::set_linker_permissions(&mkrootfiles.libs, &d, config.verbose)?;
let mut d = PathBuf::from(&config.root_dir);
d.push("lib64");
files::Files::set_linker_permissions(&files.lib64s, &d, config.verbose)?;
files::set_linker_permissions(&mkrootfiles.lib64s, &d, config.verbose)?;
if let Err(e) = os_release::os_release(&config) {
return Err(error::MkrootError::from(format!(

Write Preview
Loading…
Cancel
Save