Fully switch to libredox

2023-11-04 20:04:59 +01:00
parent ae3c0037d7
commit 8ab925eb65
7 changed files with 135 additions and 114 deletions
@@ -165,7 +165,18 @@ checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8"
 dependencies = [
 "bitflags 2.4.1",
 "libc",
- "redox_syscall 0.4.1",
+ "redox_syscall",
+]
+
+[[package]]
+name = "libredox"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
+dependencies = [
+ "bitflags 2.4.1",
+ "libc",
+ "redox_syscall",
 ]

 [[package]]
@@ -176,12 +187,12 @@ checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"

 [[package]]
 name = "orbclient"
-version = "0.3.46"
+version = "0.3.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8378ac0dfbd4e7895f2d2c1f1345cab3836910baf3a300b000d04250f0c8428f"
+checksum = "52f0d54bde9774d3a51dcf281a5def240c71996bc6ca05d2c847ec8b2b216166"
 dependencies = [
 "libc",
- "redox_syscall 0.3.5",
+ "libredox 0.0.2",
 "sdl2",
 "sdl2-sys",
 ]
@@ -211,39 +222,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "353178b5771a301b9d2b318914ab5dfeb21dd6e65930faedde19248cfceca5a7"
 dependencies = [
 "libc",
- "libredox",
+ "libredox 0.0.1",
+]
+
+[[package]]
+name = "redox_event"
+version = "0.1.0"
+source = "git+https://gitlab.redox-os.org/redox-os/event.git#7df16e700d1f72adac8ed23c2a56a9b366ea1102"
+dependencies = [
+ "bitflags 2.4.1",
+ "libredox 0.0.1",
+ "redox_syscall",
 ]

 [[package]]
 name = "redox_liner"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f014f6b014591f45bdd86377ab2f01b840ddd9e33421222b84d06e244b111327"
+checksum = "63c3dc5996de1508c9dad60461f6a5b9611d9c31610c29d3ff4ec97df408671c"
 dependencies = [
 "bytecount",
 "itertools",
+ "strip-ansi-escapes",
 "termion",
 "unicode-width",
 ]

-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags 1.3.2",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -255,20 +259,18 @@ dependencies = [

 [[package]]
 name = "redox_termios"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8440d8acb4fd3d277125b4bd01a6f38aee8d814b3b5fc09b3f2b825d37d3fe8f"
-dependencies = [
- "redox_syscall 0.2.16",
-]
+checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"

 [[package]]
 name = "redox_users"
-version = "0.4.3"
-source = "git+https://gitlab.redox-os.org/redox-os/users.git#06755b3ca678043d76c784c8e0659669ff3045c7"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4"
 dependencies = [
 "getrandom",
- "libredox",
+ "libredox 0.0.1",
 "rust-argon2",
 "thiserror",
 "zeroize",
@@ -309,6 +311,15 @@ dependencies = [
 "version-compare",
 ]

+[[package]]
+name = "strip-ansi-escapes"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "011cbb39cf7c1f62871aea3cc46e5817b0937b49e9447370c93cacbe93a766d8"
+dependencies = [
+ "vte",
+]
+
 [[package]]
 name = "strsim"
 version = "0.8.0"
@@ -328,13 +339,13 @@ dependencies = [

 [[package]]
 name = "termion"
-version = "1.5.6"
+version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "077185e2eac69c3f8379a4298e1e07cd36beb962290d4a51199acf0fdc10607e"
+checksum = "c4648c7def6f2043b2568617b9f9b75eae88ca185dbc1f1fda30e95a85d49d7d"
 dependencies = [
 "libc",
+ "libredox 0.0.2",
 "numtoa",
- "redox_syscall 0.2.16",
 "redox_termios",
 ]

@@ -385,15 +396,22 @@ version = "0.1.0"
 dependencies = [
 "clap",
 "extra",
+ "libredox 0.0.2",
 "orbclient",
 "redox-daemon",
+ "redox_event",
 "redox_liner",
- "redox_syscall 0.4.1",
 "redox_termios",
 "redox_users",
 "termion",
 ]

+[[package]]
+name = "utf8parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -406,6 +424,27 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"

+[[package]]
+name = "vte"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cbce692ab4ca2f1f3047fcf732430249c0e971bfdd2b234cf2c47ad93af5983"
+dependencies = [
+ "arrayvec",
+ "utf8parse",
+ "vte_generate_state_changes",
+]
+
+[[package]]
+name = "vte_generate_state_changes"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
@@ -53,13 +53,14 @@ path = "src/bin/usermod.rs"
 [dependencies]
 clap = "2.33.0"
 extra = { git = "https://gitlab.redox-os.org/redox-os/libextra.git" }
-orbclient = "0.3.45"
+orbclient = "0.3.47"
 redox-daemon = "0.1.2"
-redox_liner = "0.5.1"
-redox_syscall = "0.4"
-redox_termios = "0.1.2"
-redox_users = { git = "https://gitlab.redox-os.org/redox-os/users.git" }
-termion = "1.5.6"
+redox_liner = "0.5.2"
+libredox = "0.0.2"
+redox_termios = "0.1.3"
+redox_event = { git = "https://gitlab.redox-os.org/redox-os/event.git" }
+redox_users = "0.4.4"
+termion = "2.0.3"

 [profile.release]
 lto = true
@@ -1,21 +1,24 @@
 #[macro_use]
 extern crate clap;
 extern crate extra;
+extern crate libredox;
 extern crate orbclient;
 extern crate redox_termios;
-extern crate syscall;
+extern crate event;

-use std::fs::{File, OpenOptions};
-use std::io::{self, ErrorKind, Read, Stderr, Write};
+use std::io::{self, ErrorKind, Stderr};
 use std::process::{Child, Command, Stdio};
 use std::str;

 use std::os::unix::io::{FromRawFd, RawFd};

+use event::{EventFlags, RawEventQueue};
+use libredox::errno::EAGAIN;
 use orbclient::{Event, EventOption};

 use extra::io::fail;
-use syscall::O_RDONLY;
+use libredox::flag::{O_RDONLY, self};
+use libredox::call as redox;

 const _MAN_PAGE: &'static str = /* @MANSTART{getty} */
    r#"
@@ -119,7 +122,7 @@ fn process_events(ctrl: &mut bool, events: &[Event]) -> Vec<u8> {
 }

 pub fn handle(
-    event_file: &mut File,
+    event_queue: &mut RawEventQueue,
    tty_fd: RawFd,
    consumer_fd: Option<RawFd>,
    master_fd: RawFd,
@@ -134,28 +137,28 @@ pub fn handle(
        if event_id as RawFd == tty_fd {
            let mut packet = [0; 4096];
            loop {
-                let count = match syscall::read(tty_fd as usize, &mut packet) {
+                let count = match redox::read(tty_fd as usize, &mut packet) {
                    Ok(0) => return,
                    Ok(count) => count,
-                    Err(ref err) if err.errno == syscall::EAGAIN => break,
+                    Err(ref err) if err.errno == EAGAIN => break,
                    Err(_) => panic!("getty: failed to read from TTY"),
                };
-                syscall::write(master_fd as usize, &packet[..count])
+                redox::write(master_fd as usize, &packet[..count])
                    .expect("getty: failed to write master PTY");
            }
        } else if event_id as RawFd == master_fd {
            let mut packet = [0; 4096];
            loop {
-                let count = match syscall::read(master_fd as usize, &mut packet) {
+                let count = match redox::read(master_fd as usize, &mut packet) {
                    Ok(0) => return,
                    Ok(count) => count,
-                    Err(ref err) if err.errno == syscall::EAGAIN => break,
+                    Err(ref err) if err.errno == EAGAIN => break,
                    Err(_) => panic!("getty: failed to read from master TTY"),
                };
-                syscall::write(tty_fd as usize, &packet[1..count])
+                redox::write(tty_fd as usize, &packet[1..count])
                    .expect("getty: failed to write to TTY");
                if packet[0] & 1 == 1 {
-                    let _ = syscall::fsync(tty_fd as usize);
+                    let _ = redox::fsync(tty_fd as usize);
                }
            }
        } else {
@@ -166,10 +169,10 @@ pub fn handle(

                let mut packet = [0; 4096];
                loop {
-                    let count = match syscall::read(consumer_fd as usize, &mut packet) {
+                    let count = match redox::read(consumer_fd as usize, &mut packet) {
                        Ok(0) => return,
                        Ok(count) => count,
-                        Err(ref err) if err.errno == syscall::EAGAIN => break,
+                        Err(ref err) if err.errno == EAGAIN => break,
                        Err(_) => panic!("getty: failed to read from master TTY"),
                    };

@@ -181,11 +184,11 @@ pub fn handle(
                    };

                    let buf = process_events(&mut ctrl, events);
-                    syscall::write(master_fd as usize, buf.as_slice())
+                    redox::write(master_fd as usize, buf.as_slice())
                        .expect("getty: failed to write to TTY");

                    if packet[0] & 1 == 1 {
-                        let _ = syscall::fsync(tty_fd as usize);
+                        let _ = redox::fsync(tty_fd as usize);
                    }
                }
            } else {
@@ -202,11 +205,10 @@ pub fn handle(
    }

    'events: loop {
-        let mut sys_event = syscall::Event::default();
-        event_file
-            .read(&mut sys_event)
+        let sys_event = event_queue
+            .next().expect("getty: event queue stopped")
            .expect("getty: failed to read event file");
-        handle_event(sys_event.id);
+        handle_event(sys_event.fd);

        match process.try_wait() {
            Ok(status) => match status {
@@ -225,25 +227,26 @@ pub fn handle(
 }

 pub fn getpty(columns: u32, lines: u32) -> (RawFd, String) {
-    let master = syscall::open(
+    let master = redox::open(
        "pty:",
-        syscall::O_CLOEXEC | syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK,
+        flag::O_CLOEXEC | flag::O_RDWR | flag::O_CREAT | flag::O_NONBLOCK,
+        0,
    )
    .expect("getty: failed to create PTY");

-    if let Ok(winsize_fd) = syscall::dup(master, b"winsize") {
-        let _ = syscall::write(
+    if let Ok(winsize_fd) = redox::dup(master, b"winsize") {
+        let _ = redox::write(
            winsize_fd,
            &redox_termios::Winsize {
                ws_row: lines as u16,
                ws_col: columns as u16,
            },
        );
-        let _ = syscall::close(winsize_fd);
+        let _ = redox::close(winsize_fd);
    }

    let mut buf: [u8; 4096] = [0; 4096];
-    let count = syscall::fpath(master, &mut buf).unwrap();
+    let count = redox::fpath(master, &mut buf).unwrap();
    (master as RawFd, unsafe {
        String::from_utf8_unchecked(Vec::from(&buf[..count]))
    })
@@ -252,7 +255,7 @@ pub fn getpty(columns: u32, lines: u32) -> (RawFd, String) {
 fn daemon(tty_fd: RawFd, consumer_fd: Option<RawFd>, clear: bool, stderr: &mut Stderr) {
    let (columns, lines) = {
        let mut path = [0; 4096];
-        if let Ok(count) = syscall::fpath(tty_fd as usize, &mut path) {
+        if let Ok(count) = redox::fpath(tty_fd as usize, &mut path) {
            let path_str = str::from_utf8(&path[..count]).unwrap_or("");
            let reference = path_str.split(':').nth(1).unwrap_or("");
            let mut parts = reference.split('/').skip(1);
@@ -266,49 +269,29 @@ fn daemon(tty_fd: RawFd, consumer_fd: Option<RawFd>, clear: bool, stderr: &mut S

    let (master_fd, pty) = getpty(columns, lines);

-    let mut event_file = OpenOptions::new()
-        .read(true)
-        .write(true)
-        .open("event:")
-        .expect("getty: failed to open event file");
+    let mut event_queue = event::RawEventQueue::new().expect("getty: failed to open event queue");

    if let Some(consumer_fd) = consumer_fd {
-        event_file
-            .write(&syscall::Event {
-                id: consumer_fd as usize,
-                flags: syscall::flag::EVENT_READ,
-                data: 0,
-            })
-            .expect("getty: failed to fevent TTY");
+        event_queue.subscribe(consumer_fd as usize, 0, EventFlags::READ).expect("getty: failed to fevent TTY");
    }

-    event_file
-        .write(&syscall::Event {
-            id: tty_fd as usize,
-            flags: syscall::flag::EVENT_READ,
-            data: 0,
-        })
-        .expect("getty: failed to fevent TTY");
+    event_queue.subscribe(tty_fd as usize, 0, EventFlags::READ).expect("getty: failed to fevent TTY");

-    event_file
-        .write(&syscall::Event {
-            id: master_fd as usize,
-            flags: syscall::flag::EVENT_READ,
-            data: 0,
-        })
+    event_queue
+        .subscribe(master_fd as usize, 0, EventFlags::READ)
        .expect("getty: failed to fevent master PTY");

    loop {
        if clear {
-            let _ = syscall::write(tty_fd as usize, b"\x1Bc");
+            let _ = redox::write(tty_fd as usize, b"\x1Bc");
        }
-        let _ = syscall::fsync(tty_fd as usize);
+        let _ = redox::fsync(tty_fd as usize);

-        let slave_stdin = syscall::open(&pty, syscall::O_CLOEXEC | syscall::O_RDONLY)
+        let slave_stdin = redox::open(&pty, flag::O_CLOEXEC | flag::O_RDONLY, 0)
            .expect("getty: failed to open slave stdin");
-        let slave_stdout = syscall::open(&pty, syscall::O_CLOEXEC | syscall::O_WRONLY)
+        let slave_stdout = redox::open(&pty, flag::O_CLOEXEC | flag::O_WRONLY, 0)
            .expect("getty: failed to open slave stdout");
-        let slave_stderr = syscall::open(&pty, syscall::O_CLOEXEC | syscall::O_WRONLY)
+        let slave_stderr = redox::open(&pty, flag::O_CLOEXEC | flag::O_WRONLY, 0)
            .expect("getty: failed to open slave stderr");

        let mut command = Command::new("login");
@@ -326,7 +309,7 @@ fn daemon(tty_fd: RawFd, consumer_fd: Option<RawFd>, clear: bool, stderr: &mut S
        match command.spawn() {
            Ok(mut process) => {
                handle(
-                    &mut event_file,
+                    &mut event_queue,
                    tty_fd,
                    consumer_fd,
                    master_fd,
@@ -355,10 +338,10 @@ pub fn main() {

    let mut buf = [0; 1024];
    let (vt_path, consumer) = if vt.parse::<usize>().is_ok() {
-        let consumer = syscall::open(format!("input:consumer/{vt}"), O_RDONLY)
+        let consumer = redox::open(format!("input:consumer/{vt}"), O_RDONLY, 0)
            .expect("getty: failed to open consumer");

-        let written = syscall::fpath(consumer, &mut buf).expect("getty: failed to get the display");
+        let written = redox::fpath(consumer, &mut buf).expect("getty: failed to get the display");
        assert!(written <= buf.len());

        (
@@ -370,9 +353,10 @@ pub fn main() {
        (vt, None)
    };

-    let tty_fd = match syscall::open(
+    let tty_fd = match redox::open(
        vt_path,
-        syscall::O_CLOEXEC | syscall::flag::O_RDWR | syscall::flag::O_NONBLOCK,
+        flag::O_CLOEXEC | flag::O_RDWR | flag::O_NONBLOCK,
+        0,
    ) {
        Ok(fd) => fd,
        Err(err) => fail(
@@ -54,7 +54,7 @@ pub fn main() {
    loop {
        let user = liner::Context::new()
            .read_line(
-                "\x1B[1mredox login:\x1B[0m ",
+                liner::Prompt::from("\x1B[1mredox login:\x1B[0m "),
                None,
                &mut liner::BasicCompleter::new(Vec::<String>::new())
            )
@@ -1,5 +1,4 @@
 extern crate extra;
-extern crate syscall;
 extern crate termion;
 extern crate redox_users;

@@ -1,7 +1,6 @@
 #[macro_use]
 extern crate clap;
 extern crate extra;
-extern crate syscall;
 extern crate redox_users;
 extern crate userutils;

@@ -17,14 +17,14 @@
 //! - `whoami`: Display effective user ID.

 extern crate redox_users;
-extern crate syscall;
+extern crate libredox;

 use std::io::Result as IoResult;

 use redox_users::{auth, All, AllGroups, Result, User, Error};
-use syscall::call::{open, fchmod, fchown};
-use syscall::error::Result as SysResult;
-use syscall::flag::{O_CREAT, O_DIRECTORY, O_CLOEXEC};
+use libredox::call::{open, fchown};
+use libredox::error::Result as SysResult;
+use libredox::flag::{O_CREAT, O_DIRECTORY, O_CLOEXEC};

 const DEFAULT_MODE: u16 = 0o700;

@@ -89,8 +89,7 @@ pub fn spawn_shell(user: &User<auth::Full>) -> IoResult<i32> {
 pub fn create_user_dir<T>(user: &User<auth::Full>, dir: T) -> SysResult<()>
    where T: AsRef<str> + std::convert::AsRef<[u8]>
 {
-    let fd = open(dir, O_CREAT | O_DIRECTORY | O_CLOEXEC)?;
-    fchmod(fd, DEFAULT_MODE)?;
+    let fd = open(dir, O_CREAT | O_DIRECTORY | O_CLOEXEC, DEFAULT_MODE)?;
    fchown(fd, user.uid as u32, user.gid as u32)?;
    Ok(())
 }