terrazzo-terminal 0.2.7

A simple web-based terminal emulator built on Terrazzo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#![cfg(feature = "server")]

use std::collections::HashMap;
use std::ffi::CStr;
use std::fs::Metadata;
use std::os::unix::fs::MetadataExt as _;
use std::path::Path;
use std::sync::Arc;
use std::time::SystemTime;

use libc::getgrgid;
use libc::getpwuid;

use crate::text_editor::fsio::FileMetadata;
use crate::utils::more_path::MorePath as _;

impl FileMetadata {
    pub fn single(path: &Path, metadata: &Metadata) -> Self {
        Self::make(
            path.file_name()
                .map(|n| n.to_owned_string().into())
                .unwrap_or_else(|| "/".into()),
            Ok(metadata),
            &mut HashMap::new(),
            &mut HashMap::new(),
        )
    }

    pub fn of(
        file: std::fs::DirEntry,
        gids: &mut HashMap<u32, Option<Arc<str>>>,
        uids: &mut HashMap<u32, Option<Arc<str>>>,
    ) -> Self {
        Self::make(
            file.file_name().to_string_lossy().to_string().into(),
            file.metadata().as_ref(),
            gids,
            uids,
        )
    }

    fn make(
        name: Arc<str>,
        metadata: Result<&Metadata, &std::io::Error>,
        gids: &mut HashMap<u32, Option<Arc<str>>>,
        uids: &mut HashMap<u32, Option<Arc<str>>>,
    ) -> Self {
        let metadata = metadata.ok();
        let size = metadata.map(|m| m.len());

        FileMetadata {
            name,
            size,
            is_dir: metadata.map(|m| m.is_dir()).unwrap_or_default(),
            created: get_date_since_epoch(|m| m.created(), metadata),
            accessed: get_date_since_epoch(|m| m.accessed(), metadata),
            modified: get_date_since_epoch(|m| m.modified(), metadata),
            mode: metadata.map(|m| m.mode()),
            user: metadata.and_then(|m| {
                uids.entry(m.uid())
                    .or_insert_with(|| uid_to_username(m.uid()))
                    .clone()
            }),
            group: metadata.and_then(|m| {
                gids.entry(m.gid())
                    .or_insert_with(|| gid_to_groupname(m.gid()))
                    .clone()
            }),
        }
    }
}

fn get_date_since_epoch(
    g: impl FnOnce(&Metadata) -> std::io::Result<SystemTime>,
    metadata: Option<&Metadata>,
) -> Option<std::time::Duration> {
    metadata
        .and_then(|m| g(m).ok())
        .and_then(|m| m.duration_since(SystemTime::UNIX_EPOCH).ok())
}

/// Convert UID to username
fn uid_to_username(uid: u32) -> Option<Arc<str>> {
    unsafe {
        let pw = getpwuid(uid);
        if pw.is_null() {
            return None;
        }
        let name = CStr::from_ptr((*pw).pw_name);
        name.to_str().ok().map(|s| s.to_owned().into())
    }
}

/// Convert GID to group name
fn gid_to_groupname(gid: u32) -> Option<Arc<str>> {
    unsafe {
        let gr = getgrgid(gid);
        if gr.is_null() {
            return None;
        }
        let name = CStr::from_ptr((*gr).gr_name);
        name.to_str().ok().map(|s| s.to_owned().into())
    }
}