WIP: rust: Add sysusers code

See #49

Author: cgwalters

Makefile-rpm-ostree.am

@@ -39,6 +39,7 @@ rpm_ostree_SOURCES = src/app/main.c \
 	src/app/rpmostree-pkg-builtins.c \
 	src/app/rpmostree-builtin-status.c \
 	src/app/rpmostree-builtin-ex.c \
+	src/app/rpmostree-builtin-testimpl.c \
 	src/app/rpmostree-builtin-container.c \
 	src/app/rpmostree-ex-builtin-commit2rojig.c \
 	src/app/rpmostree-ex-builtin-rojig2commit.c \

docs/manual/treefile.md

@@ -88,6 +88,10 @@ It supports the following parameters:
 
    Note this does not alter the RPM database, so `rpm -V` will complain.
 
+ * `sysusers`: boolean, optional: Defaults to `false`. Enable generation of
+   systemd sysusers.d entries based on `useradd` invocations.  If enabled,
+   this overrides `preserve-passwd`.  It also obsoletes `check-passwd`.
+
  * `preserve-passwd`: boolean, optional: Defaults to `true`.  If enabled,
    and `check-passwd` has a type other than file, copy the `/etc/passwd` (and
    `/usr/lib/passwd`) files from the previous commit if they exist. If

rust/Cargo.lock

@@ -14,6 +14,7 @@ glib-sys = "0.7.0"
 gio-sys = "0.7.0"
 glib = "0.6.1"
 tempfile = "3.0.3"
+clap = "~2.28"
 openat = "0.1.15"
 curl = "0.4.14"
 rayon = "1.0"

rust/Cargo.toml

@@ -67,6 +67,13 @@ pub fn ffi_view_nullable_str<'a>(s: *const libc::c_char) -> Option<&'a str> {
     }
 }
 
+/// Like ffi_view_nullable_str(), but also panics if value is NULL
+#[allow(dead_code)]
+pub fn ffi_view_str<'a>(s: *const libc::c_char) -> &'a str {
+    ffi_view_nullable_str(s).expect("ffi_view_str: non-NULL value")
+}
+
+
 /// Given a NUL-terminated C string, copy it to an owned
 /// String.  Will panic if the C string is not valid UTF-8.
 pub fn ffi_new_string(s: *const libc::c_char) -> String {

rust/src/ffiutil.rs

@@ -17,6 +17,7 @@
  */
 
 extern crate c_utf8;
+extern crate clap;
 extern crate curl;
 #[macro_use]
 extern crate failure;
@@ -50,3 +51,47 @@ pub use journal::*;
 mod utils;
 pub use utils::*;
 mod openat_utils;
+mod sysusers;
+pub use sysusers::*;
+
+fn testimpl_run(argv: &Vec<String>) -> failure::Fallible<()> {
+    use clap;
+    use openat;
+    let app = clap::App::new("rpmostree-testimpl")
+        .subcommand(clap::SubCommand::with_name("sysusers-post")
+                    .arg(clap::Arg::with_name("treefile").help("Treefile").required(true).takes_value(true))
+                    .arg(clap::Arg::with_name("dir").help("Directory").required(true).takes_value(true)));
+    let matches = app.get_matches_from(argv);
+    if let Some(matches) = matches.subcommand_matches("sysusers-post") {
+        let d = openat::Dir::open(matches.value_of("dir").unwrap())?;
+        use tempfile;
+        let workdir = tempfile::tempdir()?;
+        // Hack opening the treefile here
+        let tf =
+            Treefile::new_boxed(std::path::Path::new(matches.value_of("treefile").unwrap()), None, openat::Dir::open(workdir.path())?)?;
+        sysusers::post_useradd(&d, &tf)?;
+    }
+    Ok(())
+}
+
+/// Entrypoint for testing internal functions; not a stable API.
+fn testimpl_main(argv: &Vec<String>) {
+    if let Err(ref e) = testimpl_run(argv) {
+        eprintln!("error: {}", e);
+        std::process::exit(1)
+    }
+}
+
+mod ffi {
+    use super::*;
+    use glib;
+    use libc;
+
+    #[no_mangle]
+    pub extern "C" fn ror_testimpl_main(argv: *mut *mut libc::c_char) -> libc::c_int {
+        let v: Vec<String> = unsafe { glib::translate::FromGlibPtrContainer::from_glib_none(argv) };
+        testimpl_main(&v);
+        0
+    }
+}
+pub use self::ffi::*;

rust/src/lib.rs

@@ -26,6 +26,10 @@ pub(crate) trait OpenatDirExt {
     // and Rust has an elegant way to map that with Option<>.  Every other
     // error I usually just want to propagate back up.
     fn open_file_optional<P: openat::AsPath>(&self, p: P) -> io::Result<Option<fs::File>>;
+
+    // On modern filesystems the directory entry contains the type; if available,
+    // return it.  Otherwise invoke stat().
+    fn get_file_type(&self, e: &openat::Entry) -> io::Result<openat::SimpleType>;
 }
 
 impl OpenatDirExt for openat::Dir {
@@ -41,5 +45,13 @@ impl OpenatDirExt for openat::Dir {
             }
         }
     }
+
+    fn get_file_type(&self, e: &openat::Entry) -> io::Result<openat::SimpleType> {
+        if let Some(ftype) = e.simple_type() {
+            Ok(ftype)
+        } else {
+            Ok(self.metadata(e.file_name())?.simple_type())
+        }
+    }
 }