trying to get username and password frrom stdin and remove \r\n

Question

I am looking at examples but they all work with only one line piped/input into my rust program, but I need 2 lines or more as Strings so I can remove the \r\n or \n or \r and the last . line, so basically I need them in Strings so I can work on them. so here is some of my snips.

 let mut buffer = "".to_string();

    io::stdin().read_to_string(&mut buffer)?;
    print!("{}",remove(buffer));
// remove() is  the fn where I am trying to work with the Strings
...

Above I am reading everything I pipe to my program from stdin. cat test.txt > cargo run that works.. but I am pipping this input:

ClientAuthname: user\r\n
ClientPassword: pass\r\n
.\r\n

so I have made and change like 20 something functions under remove() and cant seem to get it right, rust complainsts about it one way or another, I have tested many examples but they are for u* types or str types etc. when using String mutable or not I always get issues. Some of the solutions I been trying for example this ones Remove single trailing newline from String without cloning

I can't get anything to work with my case. I will appreciate if someone can give me a hand and give a explanation so I learn this since I do a lot of unix systems programming on C/Go and moving my programs to rust.

Thanks [edit] Since people wants me to waste text and post examples of what I tried this are 3 of like 14 or so examples I have tried so far

/*
fn remove(arg: String) -> String {
    let newarg = arg.trim_end().to_string();
    return newarg;
}
*/
/*
fn parse(s: &mut String) -> String {
    if s.ends_with('\n') {
        s.pop();
        if s.ends_with('\r') {
            s.pop();
        }
    }
    return s.to_string();
}
*/

fn parse(s: &mut String) -> String {
    s.strip_suffix("\r\n").or(s.strip_suffix("\n")).unwrap_or(s);
    return s.to_string();
}

none works. they all fail to remove \r\n or \n :(

so what I have as stdin? I tried everything I see! all of this! https://doc.rust-lang.org/stable/std/io/struct.Stdin.html#method.read_line also I tried all of this! How to capture the output of a process piped into a Rust program?

I can keep going! this is C is super simple to do. dont know why I cant get the output from another program the native unix way wit ha simple pipe, like echo "Password\r\n" | cargo run and remove the "\r\n" nothing works if it comes from stdin from another program.

use std::io;

let lines = io::stdin().lines();
for line in lines {
    println!("got a line: {}", line.unwrap());
}

WHY I cant add parse() to the line!!! String and get the \r\n remove with ANY of the examples I find! I change both, the stdin ways and the function to remove, I tried .trim() I tried .pop() I tried .truncate() I tried .strip_suffix("\r\n") !!! everything ! cant someone just write a small snipped that will do exactly what I need since there does not exists any thing that works. ? or at least tell me how I should do it so I do not keep trying and trying and trying everything I see. I am so close to ditch all 1000+ of working code because of something so simple as grabbing and manipulating String from another unix program, that I have done in C thousands of times since Unix works based on pipes.

Answer 1

I will focus on this part first:

dont know why I cant get the output from another program the native unix way wit ha simple pipe, like echo "Password\r\n" | cargo run and remove the "\r\n"

When you run echo "Password\r\n", the \r and \n are not interpreted as a carriage return and a line feed. They are interpreted as a literal \, and then a r, and then a \, and then a n. This is four ASCII characters: \x5c\x72\x5c\x6e.

See: Echo newline in Bash prints literal \n for details.

When you write "\r\n" in your Rust code, they are interpreted as a carriage return and line feed. This is two ASCII characters: \x0d\x0a.

They are not the same.

To get your Rust code to match that echo output, you would need to escape the escape character \ like "\\r\\n". Here's a demonstration:

fn main() {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();

    // show the raw debug output for the line
    let line = &line;
    dbg!(line);

    // remove the newline character preserved from `.read_line()`
    let line = line.trim_end();
    dbg!(line);

    // remove the trailing literal "\r\n" you're expecting
    let line = line.trim_end_matches("\\r\\n");
    dbg!(line);
}

> echo "Password\r\n" | cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/temp`
[src/main.rs:7] line = "Password\\r\\n\n"
[src/main.rs:11] line = "Password\\r\\n"
[src/main.rs:15] line = "Password"

The same applies with your cat example, your file does not have the CR (\r) and LF (\n) control characters, you are sending literal \, r, \, and n (and then probably a real \n because there's a newline).

---

That all being said, you have either misinterpreted the documentation or misunderstood your tools. You linked the spec you're following (in a comment) as: https://www.eyrie.org/~eagle/software/inn/docs-2.7/external-auth.html. Within it, it says:

[...] it passes information on standard input as a sequence of key: value lines. Each line ends with CRLF [...]

So simulating this via echo "Password\r\n" is incorrect and not following the spec. To do the correct thing using echo, you can pass -e (shown in the SO link above) and you'll see the behavior is quite different:

> echo -e "Password\r\n" | cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/temp`
[src/main.rs:7] line = "Password\r\n"
[src/main.rs:11] line = "Password"
[src/main.rs:15] line = "Password"

So a simple .trim()/.trim_end() is enough to do the job.

Answer 2

I have been testing this solution. That only calls once to read. This will read full output and will delete all \r and \n and put all the strings in a Vec

use std::io::Read;

fn parse() -> std::io::Result<Vec<String>> {
    let mut line = String::new();
    std::io::stdin().read_to_string(&mut line)?;

    // show the raw debug output for the line
    let line = &line;
    dbg!(line);

    // remove the newline character preserved from `.read_line()`
    let line = line.trim_end();
    dbg!(line);

    // remove the trailing literal "\r\n" you're expecting
    let lines: Vec<String> = line.split("\r\n").map(|str| str.to_string()).collect();
    dbg!(&lines);

    Ok(lines)
}

fn main() {
    let lines = match parse() {
        Ok(val) => val,
        Err(err) => panic!("Some input error : {}", err),
    };

    print!("Lines : {lines:?}");
    // use them here
}

% meaning in the shell means End of file therefore it is not taking \r or \n char.

Edit : Some changes to make it work with multiple lines and put it in a Vec.