lrzsz2 0.3.2

ZMODEM file transfer utilities
Documentation 
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// SPDX-License-Identifier: GPL-3-0-or-later
// Copyright (c) 2017-2020 Alexey Arbuzov
// Copyright (c) 2023-2025 Jarkko Sakkinen

extern crate zmodem2;

use anyhow::{bail, Context};
use argh::FromArgs;
use indicatif::{ProgressBar, ProgressStyle};
use lrzsz2::ReadWrite;
use std::fs::{File, OpenOptions};
use std::path::{Component, Path, PathBuf};

#[derive(FromArgs, Debug)]
/// Receive files using the ZMODEM protocol.
struct Arguments {
    /// device file [default: /dev/ttyS0]
    #[argh(option, short = 'p', default = "String::from(\"/dev/ttyS0\")")]
    port: String,
    /// download directory
    #[argh(positional)]
    path: String,
}

fn main() -> anyhow::Result<()> {
    let args: Arguments = argh::from_env();

    let port_file = OpenOptions::new()
        .read(true)
        .write(true)
        .open(&args.port)
        .with_context(|| format!("'{}'", args.port))?;

    lrzsz2::configure_raw_mode(&port_file).ok();

    let mut port: Box<dyn ReadWrite> = Box::new(port_file);

    let mut state = zmodem2::Transmission::new();
    let dest_dir = PathBuf::from(&args.path);
    if !dest_dir.is_dir() {
        bail!("'{}' is not a directory", dest_dir.display());
    }

    let mut open_files: std::collections::HashMap<Vec<u8>, (File, ProgressBar)> =
        std::collections::HashMap::new();
    let mut current_filename = vec![];
    let mut sink = std::io::sink();

    while state.state() != zmodem2::State::SessionEnd {
        let current_state = state.state();

        if current_state == zmodem2::State::FileBegin
            && state.file_name() != current_filename.as_slice()
        {
            let filename_bytes = state.file_name();
            let received_filename = Path::new(
                std::str::from_utf8(filename_bytes)
                    .with_context(|| "invalid UTF-8 in filename".to_string())?,
            )
            .components()
            .next_back()
            .and_then(|c| match c {
                Component::Normal(name) => Some(name),
                _ => None,
            })
            .with_context(|| {
                format!(
                    "malformed filename: '{}'",
                    std::str::from_utf8(filename_bytes).unwrap_or("<invalid>")
                )
            })?;

            let path = dest_dir.join(received_filename);
            let file = File::create(&path)
                .with_context(|| format!("could not create '{}'", path.display()))?;

            let pb = ProgressBar::new(state.file_size() as u64);
            pb.set_style(
                ProgressStyle::default_bar()
                    .template(
                        "{msg}\n{spinner} [{elapsed_precise}] [{bar:40}] {bytes}/{total_bytes} ({eta})",
                    )?
                    .progress_chars("=>-"),
            );
            pb.set_message(format!("Receiving {}", path.display()));

            open_files.insert(filename_bytes.to_vec(), (file, pb));
            current_filename = filename_bytes.to_vec();
        }

        let has_file = open_files.contains_key(&current_filename);
        let result = if has_file {
            let (file, _pb) = open_files.get_mut(&current_filename).unwrap();
            state.receive(&mut port, file)
        } else {
            state.receive(&mut port, &mut sink)
        };

        match result {
            Ok(Some(())) => {
                let count = state.count();
                let current_state = state.state();

                if let Some((_file, pb)) = open_files.get(&current_filename) {
                    pb.set_position(count as u64);
                }
                if current_state == zmodem2::State::FileEnd {
                    if let Some((_file, pb)) = open_files.remove(&current_filename) {
                        pb.finish_with_message("Done");
                    }
                    current_filename.clear();
                }
            }
            Ok(None) => {
                std::thread::sleep(std::time::Duration::from_millis(10));
            }
            Err(e) => {
                for (_filename, (_file, pb)) in open_files.iter() {
                    pb.finish_with_message("Aborted");
                }
                bail!("ZMODEM error: {:#}", e);
            }
        }
    }

    for (_filename, (_file, pb)) in open_files.iter() {
        if !pb.is_finished() {
            pb.finish_with_message("Done");
        }
    }

    Ok(())
}