//! strings -- find printable ASCII strings in binary data use std::ffi::OsString;use std::fs::File;use std::io::{self, Read, Write}; const READ_BUFFER_BYTES: usize = 8 * 1024;const MAX_MIN_LENGTH: usize = 1024 * 1024; pub fn main(args: Vec<OsString>) -> i32 {    let str_args: Vec<String> = args        .iter()        .skip(1)        .map(|a| a.to_string_lossy().to_string())        .collect();     let mut min_len: usize = 4;    let mut offset_format: Option<char> = None; // 'd', 'o', or 'x'    let mut filenames: Vec<String> = Vec::new();     let mut i = 0;    while i < str_args.len() {        match str_args[i].as_str() {            "-n" => {                i += 1;                if i >= str_args.len() {                    eprintln!("strings: option '-n' requires an argument");                    return 1;                }                match str_args[i].parse::<usize>() {                    Ok(n) if (1..=MAX_MIN_LENGTH).contains(&n) => min_len = n,                    _ => {                        eprintln!("strings: invalid minimum string length '{}'", str_args[i]);                        return 1;                    }                }            }            s if s.starts_with("-n") => {                let val = &s[2..];                match val.parse::<usize>() {                    Ok(n) if (1..=MAX_MIN_LENGTH).contains(&n) => min_len = n,                    _ => {                        eprintln!("strings: invalid minimum string length '{}'", val);                        return 1;                    }                }            }            "-t" => {                i += 1;                if i >= str_args.len() {                    eprintln!("strings: option '-t' requires an argument");                    return 1;                }                match str_args[i].as_str() {                    "d" | "o" | "x" => offset_format = Some(str_args[i].chars().next().unwrap()),                    _ => {                        eprintln!("strings: invalid radix for -t: '{}'", str_args[i]);                        return 1;                    }                }            }            s if s.starts_with('-') && s.len() > 1 => {                // Try parsing as -N (numeric min length, GNU extension)                if let Ok(n) = s[1..].parse::<usize>() {                    if (1..=MAX_MIN_LENGTH).contains(&n) {                        min_len = n;                    } else {                        eprintln!("strings: invalid minimum string length '{}'", &s[1..]);                        return 1;                    }                } else {                    eprintln!("strings: unknown option '{}'", s);                    return 1;                }            }            _ => filenames.push(str_args[i].clone()),        }        i += 1;    }     let stdout = io::stdout();    let mut out = stdout.lock();     if filenames.is_empty() {        if let Err(e) = extract_strings(io::stdin().lock(), min_len, offset_format, &mut out) {            eprintln!("strings: stdin: {}", e);            return 1;        }    } else {        for filename in &filenames {            match File::open(filename)                .and_then(|f| extract_strings(f, min_len, offset_format, &mut out))            {                Ok(()) => {}                Err(e) => {                    eprintln!("strings: {}: {}", filename, e);                    return 1;                }            };        }    }     match out.flush() {        Ok(()) => 0,        Err(e) => {            eprintln!("strings: stdout: {}", e);            1        }    }} fn extract_strings<R: Read, W: Write>(    mut reader: R,    min_len: usize,    offset_fmt: Option<char>,    out: &mut W,) -> io::Result<()> {    let mut run_start: Option<usize> = None;    let mut run = Vec::new();    let mut emitted = false;    let mut offset = 0;    let mut buffer = [0; READ_BUFFER_BYTES];     loop {        let bytes_read = reader.read(&mut buffer)?;        if bytes_read == 0 {            break;        }         for &b in &buffer[..bytes_read] {            if is_printable_ascii(b) {                if run_start.is_none() {                    run_start = Some(offset);                }                if emitted {                    out.write_all(&[b])?;                } else {                    run.push(b);                    if run.len() == min_len {                        emit_prefix(out, run_start.unwrap_or(0), offset_fmt)?;                        out.write_all(&run)?;                        run.clear();                        emitted = true;                    }                }            } else {                if emitted {                    writeln!(out)?;                }                run.clear();                run_start = None;                emitted = false;            }            offset += 1;        }    }     if emitted {        writeln!(out)?;    }    Ok(())} fn emit_prefix<W: Write>(out: &mut W, offset: usize, offset_fmt: Option<char>) -> io::Result<()> {    if let Some(fmt) = offset_fmt {        match fmt {            'd' => {                write!(out, "{:7} ", offset)?;            }            'o' => {                write!(out, "{:7o} ", offset)?;            }            'x' => {                write!(out, "{:7x} ", offset)?;            }            _ => {}        }    }    Ok(())} fn is_printable_ascii(b: u8) -> bool {    // Printable ASCII: space (0x20) through tilde (0x7E), plus tab (0x09)    b == b'\t' || (b >= 0x20 && b <= 0x7E)}