JustSoup321/dtmp - Change YKRSSHFQEP3O6HC7DOF22ATRMG6Y5SZZHKT6A34YGWFIXQDFGSIQC

fix mode setting

Properly parses the mode parsed from the config into a Rust integer with 'o'. Need to clean up the config logic and move code parsing into logical sections, but otherwise works… barely…

Created by h61ZxCB3HwAydygUubemuy7H7MKMb2WXmgC5EzjeUYJ on August 29, 2025

YKRSSHFQEP3O6HC7DOF22ATRMG6Y5SZZHKT6A34YGWFIXQDFGSIQC

Dependencies

[2] F2AETINJDMXEKYXV2F73DBBWZNDIS4IQWTM7XO225V3RYVCW3Y6QC

In channels

main

Change contents

Replacement in tests/test.config at line 5 [2.55]

B:BD[2.257] → [2.257:392]

#type path        mode user group age argument
d     /run/user   0755 root root  10d -
l     /tmp/foobar -    -    -     -   /dev/null

[2.257]

#type path                mode user group age argument
d     /tmp/dtmp/testdir   0755 root root  10d -
f     /tmp/dtmp/testfile  0644 root root  3d  -
f+    /tmp/dtmp/testtfile 0644 root root  5d  -
l     /tmp/dtmp/testlink  -    -    -     -   /dev/null

Replacement in lib/parser.rs at line 30 [2.3485]

B:BD[2.4255] → [2.4255:4444]

                let line: Vec<&str> = line.iter().map(|item| item.as_str()).collect();
                if line[0].chars().next().unwrap().to_string() == "#" {
                    continue;

[2.4255]

[2.4444]

                if line.len() >= 1 {
                    let line: Vec<&str> = line.iter().map(|item| item.as_str()).collect();
                    if line[0].chars().next().unwrap().to_string() == "#" {
                        continue;
                    }
                    return_config.push(Config {
                        file_type: String::from(line[0]),
                        path: line[1].into(),
                        mode: String::from(line[2]),
                        user: String::from(line[3]),
                        group: String::from(line[4]),
                        age: String::from(line[5]),
                        argument: String::from(line[6]),
                    });

Deletion in lib/parser.rs at line 45 [2.3485]

B:BD[2.4462] → [2.4462:4871]

                return_config.push(Config {
                    file_type: String::from(line[0]),
                    path: line[1].into(),
                    mode: String::from(line[2]),
                    user: String::from(line[3]),
                    group: String::from(line[4]),
                    age: String::from(line[5]),
                    argument: String::from(line[6]),
                });

Insertion in lib/lib.rs at line 7 [2.5590]
[2.5828]
[2.5828]
```
pub mod fs;
```

Replacement in lib/actions.rs at line 5 [2.7663]

B:BD[2.7868] → [2.7868:7903]

use crate::parser::{self, Config};

[2.7868]

[2.7903]

use crate::{
    fs::{build_dir, build_file},
    parser::{self, Config},
};

Replacement in lib/actions.rs at line 10 [2.7663]

B:BD[2.7904] → [2.7904:7960]

use std::{fs::DirBuilder, os::unix::fs::DirBuilderExt};

[2.7904]

[2.7960]

use std::{
    fs::{DirBuilder, OpenOptions},
    os::unix::fs::{DirBuilderExt, OpenOptionsExt},
};

Replacement in lib/actions.rs at line 17 [2.7663]

B:BD[2.8043] → [2.8043:8295]

    if let config_files = std::fs::read_dir("/usr/lib/tmpfiles.d").unwrap() {
        for file in config_files {
            match file {
                Ok(f) => match parser::parse(&f.path()) {
                    Ok(config) => configs.push(config),

[2.8043]

[2.8295]

    let config_files = std::fs::read_dir("/usr/lib/tmpfiles.d");
    match config_files {
        Ok(config_list) => {
            for file in config_list {
                match file {
                    Ok(f) => match parser::parse(&f.path()) {
                        Ok(config) => configs.push(config),
                        Err(e) => return Err(e),
                    },

Replacement in lib/actions.rs at line 27 [2.7663]

B:BD[2.8340] → [2.8340:8400]

                },
                Err(e) => return Err(e),

[2.8340]

[2.8400]

Insertion in lib/actions.rs at line 30 [2.7663]
[2.8424]
[2.8424]
```
        Err(e) => return Err(e)
```
Replacement in lib/actions.rs at line 32 [2.7663]
B:BD[2.8430] → [2.8430:8472]
```
    let mut builder = DirBuilder::new();
```
[2.8430]
[2.8472]
```
    
```

Replacement in lib/actions.rs at line 35 [2.7663]

B:BD[2.8530] → [2.8530:9077]

            // println!("{:#?}", config);
            if &line.file_type == "d" {
                // println!("{:#?}", line);
                match builder
                    .recursive(true)
                    .mode(line.mode.parse::<u32>().unwrap())
                    .create(&line.path.as_os_str())
                {
                    Ok(k) => println!("Created path: {:#?}", &line.path.as_os_str()),
                    Err(e) => {
                        println!("Failed");
                        return Err(e)
                    },

[2.8530]

[2.9077]

            let mut mode: u32;
            match line.mode.as_str() {
                "0755" => mode = 0o755,
                "755" => mode = 0o755,
                "1755" => mode = 1755,
                "0644" => mode = 0o644,
                "644" => mode = 0o644,
                "1644" => mode = 1644,
                _ => todo!(),
            }
            match line.file_type.as_str() {
                "f" => {
                    match OpenOptions::new()
                        .create(true)
                        .mode(mode) // .mode(line.mode.parse::<u32>().unwrap())
                        .open(&line.path.as_os_str())
                    {
                        Ok(k) => println!("Created file: {:#?}", &line.path.as_os_str()),
                        Err(e) => {
                            println!(
                                "Failed to create {:#?} with reason {}!",
                                &line.path.as_os_str(),
                                e
                            );
                            println!("Mode: {}", line.mode.parse::<u32>().unwrap());
                            return Err(e);
                        }
                    }
                }
                "f+" => {
                    match OpenOptions::new()
                        .create(true)
                        .truncate(true)
                        .mode(mode)
                        .open(&line.path.as_os_str())
                    {
                        Ok(k) => println!(
                            "Created file: {:#?} with truncation",
                            &line.path.as_os_str()
                        ),
                        Err(e) => {
                            println!("Failed to create {:#?}!", &line.path.as_os_str());
                            return Err(e);
                        }
                    }

Insertion in lib/actions.rs at line 81 [2.7663]

[2.9095]

                "d" => match build_dir(&line.path, mode) {
                    Ok(k) => println!(
                        "Created path {:#?} with mode {}",
                        &line.path.as_os_str(),
                        mode
                    ),
                    Err(e) => {
                        println!(
                            "Failed to create {:#?} with mode {} with error {}!",
                            &line.path.as_os_str(),
                            mode,
                            e
                        );
                        return Err(e.into());
                    }
                },
                _ => eprintln!(
                    "ERROR: File type \"{}\" is not implemented.",
                    line.file_type
                ),

Insertion in Cargo.toml at line 12 [2.61389]

[2.61563]

nix = { version = "0.30.1", features = ["fs"], default-features = false }

Insertion in Cargo.lock at line 54 [2.61599]

[2.62959]


[[package]]
name = "bitflags"
version = "2.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"

Insertion in Cargo.lock at line 62 [2.61599]

[2.62972]

name = "cfg-if"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
[[package]]
name = "cfg_aliases"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
[[package]]

Insertion in Cargo.lock at line 124 [2.61599]
[2.64181]
[2.64181]
```
 "nix",
```

Insertion in Cargo.lock at line 140 [2.61599]

[2.64589]

name = "libc"
version = "0.2.174"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
[[package]]
name = "nix"
version = "0.30.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
dependencies = [
 "bitflags",
 "cfg-if",
 "cfg_aliases",
 "libc",
]
[[package]]