Merge pull request #274 from haboustak/273-rust-parse-octal-umask

Parse SCUBAINIT_UMASK as an octal-encoded string

Author: JonathonReinhart

scubainit/src/main.rs

@@ -10,7 +10,7 @@ use std::process::{Command, ExitCode};
 use stderrlog::{self, LogLevelNum};
 
 use scubainit::util::{libc_result, make_executable, open_read_append};
-use scubainit::util::{pop_env_bool, pop_env_str, pop_env_uint};
+use scubainit::util::{pop_env_bool, pop_env_octal, pop_env_str, pop_env_uint};
 use scubainit::{groups, passwd, shadow};
 
 const SCUBAINIT_EXIT_FAIL: u8 = 99;
@@ -346,7 +346,7 @@ fn process_envvars() -> Result<Context> {
         user_info: process_envvars_user_info()?,
 
         // Optional vars
-        umask: pop_env_uint(SCUBAINIT_UMASK)?,
+        umask: pop_env_octal(SCUBAINIT_UMASK)?,
 
         // SCUBAINIT_VERBOSE is popped in setup_logging().
 

scubainit/src/util.rs

@@ -59,7 +59,7 @@ pub fn pop_env_bool(name: &str) -> bool {
     result
 }
 
-/// Gets and unsets a uint environment variable `name`, or Ok(None) if it is not set.
+/// Gets and unsets a decimal uint environment variable `name`, or Ok(None) if it is not set.
 ///
 /// # Errors
 ///
@@ -71,10 +71,24 @@ pub fn pop_env_uint(name: &str) -> Result<Option<u32>> {
     };
     let value: u32 = value_str
         .parse()
-        .context(format!("Parsing integer variable {name}=\"{value_str}\""))?;
+        .with_context(|| format!("Parsing decimal integer variable {name}=\"{value_str}\""))?;
     Ok(Some(value))
 }
 
+/// Gets and unsets an octal uint environment variable `name`, or Ok(None) if it is not set.
+///
+/// # Errors
+///
+/// This function will return an error if the variable is set, but is not a valid integer string.
+pub fn pop_env_octal(name: &str) -> Result<Option<u32>> {
+    let value_str = match pop_env_str(name) {
+        None => return Ok(None),
+        Some(s) => s,
+    };
+    let value = u32::from_str_radix(&value_str, 8)
+        .with_context(|| format!("Parsing octal integer variable {name}=\"{value_str}\""))?;
+    Ok(Some(value))
+}
 pub fn make_executable(path: &str) -> std::io::Result<()> {
     let mut perms = fs::metadata(path)?.permissions();
     let mut mode = perms.mode();
@@ -177,4 +191,32 @@ mod tests {
             assert!(not_set(VAR_NAME));
         });
     }
+
+    #[test]
+    fn pop_env_octal_handles_unset() {
+        temp_env::with_var_unset(VAR_NAME, || {
+            assert!(not_set(VAR_NAME));
+            assert_eq!(pop_env_octal(VAR_NAME).unwrap(), None);
+        });
+    }
+
+    #[test]
+    fn pop_env_octal_handles_invalid() {
+        temp_env::with_var(VAR_NAME, Some("99"), || {
+            assert!(pop_env_octal(VAR_NAME).is_err());
+            assert!(not_set(VAR_NAME));
+        });
+    }
+
+    #[test]
+    fn pop_env_octal_works() {
+        temp_env::with_var(VAR_NAME, Some("0777"), || {
+            assert_eq!(pop_env_octal(VAR_NAME).unwrap(), Some(511));
+            assert!(not_set(VAR_NAME));
+        });
+        temp_env::with_var(VAR_NAME, Some("0022"), || {
+            assert_eq!(pop_env_octal(VAR_NAME).unwrap(), Some(18));
+            assert!(not_set(VAR_NAME));
+        });
+    }
 }

tests/test_main.py

@@ -16,6 +16,7 @@
 
 import scuba.__main__ as main
 import scuba.dockerutil
+import scuba.utils
 
 from .const import DOCKER_IMAGE
 from .utils import (
@@ -1186,3 +1187,26 @@ def test_volumes_named(self) -> None:
         # Invoke scuba again: Verify the file is still there
         out, _ = run_scuba(["/bin/sh", "-c", f"cat {test_path}"])
         assert_str_equalish(out, test_str)
+
+
+class TestMainUmask(MainTest):
+    def test_umask(self) -> None:
+        """Verify umask is set properly"""
+        SCUBA_YML.write_text(f"image: {DOCKER_IMAGE}")
+
+        FAKE_UMASK = 0o123  # unlikely
+
+        def mocked_get_umask() -> int:
+            return FAKE_UMASK
+
+        # http://alexmarandon.com/articles/python_mock_gotchas/#patching-in-the-wrong-place
+        # http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch
+        with mock.patch("scuba.scuba.get_umask", side_effect=mocked_get_umask) as m:
+            args = ["/bin/sh", "-c", "umask"]
+            out, _ = run_scuba(args)
+
+        m.assert_called_once()
+
+        assert out.startswith("0")
+        result_umask = int(out, 8)
+        assert result_umask == FAKE_UMASK