Fixed some issues with zmodem upload.

Not 100% sure about the full duplex thing but made the zmodem implementation work on some more systems.

Author: mkrueger

src/data/addresses.rs

@@ -368,7 +368,7 @@ impl AddressBook {
         match input_text.parse::<Value>() {
             Ok(value) => self.parse_addresses(&value),
             Err(err) => {
-                return Err(format!("Error parsing dialing_directory: {err}").into());
+                return Err(anyhow::anyhow!("Error parsing dialing_directory: {err}"));
             }
         }
         Ok(())

src/features/auto_login.rs

@@ -3,10 +3,7 @@ use web_time::Instant;
 use crate::{
     ui::connection::Connection, util::PatternRecognizer, Address, Options, TerminalResult,
 };
-use std::{
-    io::{self, ErrorKind},
-    time::Duration,
-};
+use std::time::Duration;
 
 use super::iemsi_com::IEmsi;
 
@@ -181,13 +178,10 @@ impl AutoLogin {
                             }
                             ch => {
                                 self.cur_expr_idx += 1; // escape
-                                return Err(Box::new(io::Error::new(
-                                    ErrorKind::InvalidData,
-                                    format!(
-                                        "invalid escape sequence in autologin string: {:?}",
-                                        char::from_u32(u32::from(*ch))
-                                    ),
-                                )));
+                                return Err(anyhow::anyhow!(
+                                    "invalid escape sequence in autologin string: {:?}",
+                                    *ch as char
+                                ));
                             }
                         }
                         self.cur_expr_idx += 1; // escape

src/features/iemsi_com.rs

@@ -1,10 +1,7 @@
 #![allow(dead_code, clippy::wildcard_imports, clippy::needless_range_loop)]
 
 // IEMSI autologin implementation http://ftsc.org/docs/fsc-0056.001
-use std::{
-    fmt,
-    io::{self, ErrorKind},
-};
+use std::fmt;
 
 use icy_engine::{get_crc16, get_crc32, update_crc32};
 
@@ -304,10 +301,7 @@ impl EmsiICI {
         ])?;
 
         if data.len() > EmsiICI::MAX_SIZE {
-            return Err(Box::new(io::Error::new(
-                ErrorKind::OutOfMemory,
-                "maximum size exceeded",
-            )));
+            return Err(anyhow::anyhow!("maximum size exceeded"));
         }
         let mut result = Vec::new();
         result.extend_from_slice(b"**EMSI_ICI");
@@ -651,10 +645,7 @@ fn parse_emsi_blocks(data: &[u8]) -> TerminalResult<Vec<String>> {
                 i += 3;
                 continue;
             }
-            return Err(Box::new(io::Error::new(
-                ErrorKind::InvalidData,
-                "Escape char in emsi string invalid.",
-            )));
+            return Err(anyhow::anyhow!("Escape char in emsi string invalid."));
         }
 
         str.push(char::from_u32(u32::from(data[i])).unwrap());
@@ -686,10 +677,7 @@ fn encode_emsi(data: &[&str]) -> TerminalResult<Vec<u8>> {
             }
             let val = ch as u32;
             if val > 255 {
-                return Err(Box::new(io::Error::new(
-                    ErrorKind::InvalidData,
-                    "Unicode chars not supported",
-                )));
+                return Err(anyhow::anyhow!("Unicode chars not supported"));
             }
             // control codes.
             if val < 32 || val == 127 {

src/main.rs

@@ -12,14 +12,14 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
 mod ui;
-use std::{error::Error, path::PathBuf};
+use std::path::PathBuf;
 
 use directories::ProjectDirs;
 use eframe::egui;
 use lazy_static::lazy_static;
 use ui::MainWindow;
 use web_time::Instant;
-pub type TerminalResult<T> = Result<T, Box<dyn Error>>;
+pub type TerminalResult<T> = anyhow::Result<T>;
 use i18n_embed::fluent::{fluent_language_loader, FluentLanguageLoader};
 use log::LevelFilter;
 use log4rs::{

src/protocol/file_storage_handler.rs

@@ -102,10 +102,10 @@ impl DiskStorageHandler {
     #[cfg(not(target_arch = "wasm32"))]
     pub fn new() -> TerminalResult<Self> {
         let Some(user_dirs) = directories::UserDirs::new() else {
-            return Err("Failed to get user directories".into());
+            return Err(anyhow::anyhow!("Failed to get user directories"));
         };
         let Some(output_path) = user_dirs.download_dir() else {
-            return Err("Failed to get user directories".into());
+            return Err(anyhow::anyhow!("Failed to get user directories"));
         };
 
         Ok(Self {
@@ -122,15 +122,17 @@ impl DiskStorageHandler {
 impl FileStorageHandler for DiskStorageHandler {
     fn open_unnamed_file(&mut self) {
         let mut num = 0;
-        let f = "no_name_file.0".to_string();
+        let f = "x_modem_transferred_file.0".to_string();
         let mut file_name: PathBuf = self.output_path.join(f.clone());
 
         while file_name.exists() {
-            file_name = self.output_path.join(format!("no_name_file.{num}"));
+            file_name = self
+                .output_path
+                .join(format!("x_modem_transferred_file.{num}"));
             num += 1;
         }
 
-        self.open_file(&format!("no_name_file.{num}"), 0);
+        self.open_file(&format!("x_modem_transferred_file.{num}"), 0);
     }
 
     fn open_file(&mut self, file_name: &str, total_size: usize) {

src/protocol/xymodem/mod.rs

@@ -75,7 +75,7 @@ impl super::Protocol for XYmodem {
         transfer_state: &mut TransferState,
     ) -> TerminalResult<()> {
         if !self.config.is_ymodem() && files.len() != 1 {
-            return Err(Box::new(TransmissionError::XModem1File));
+            return Err(TransmissionError::XModem1File.into());
         }
 
         let mut sy = sy::Sy::new(self.config);

src/protocol/xymodem/ry.rs

@@ -1,7 +1,5 @@
 use icy_engine::get_crc16;
-use log4rs::append::file;
 use std::{
-    io::{self, ErrorKind},
     sync::{Arc, Mutex},
     thread,
 };
@@ -86,10 +84,9 @@ impl Ry {
                         com.send(vec![NAK])?;
                     } else {
                         self.cancel(com)?;
-                        return Err(Box::new(io::Error::new(
-                            ErrorKind::ConnectionAborted,
-                            "too many retries starting the communication",
-                        )));
+                        return Err(anyhow::anyhow!(
+                            "too many retries starting the communication"
+                        ));
                     }
                     self.errors += 1;
                     self.recv_state = RecvState::StartReceive(retries + 1);
@@ -183,10 +180,7 @@ impl Ry {
                             com.send(vec![NAK])?;
                         } else {
                             self.cancel(com)?;
-                            return Err(Box::new(io::Error::new(
-                                ErrorKind::ConnectionAborted,
-                                "too many retries",
-                            )));
+                            return Err(anyhow::anyhow!("too many retries"));
                         }
                         self.errors += 1;
                         self.recv_state = RecvState::ReadBlockStart(0, retries + 1);
@@ -227,10 +221,7 @@ impl Ry {
                         self.recv_state = RecvState::ReadBlock(EXT_BLOCK_LENGTH, retries + 1);
                     } else {
                         self.cancel(com)?;
-                        return Err(Box::new(io::Error::new(
-                            ErrorKind::ConnectionAborted,
-                            "too many retries",
-                        )));
+                        return Err(anyhow::anyhow!("too many retries"));
                     }
                     self.recv_state = RecvState::ReadBlock(EXT_BLOCK_LENGTH, retries + 1);
                     return Ok(());

src/protocol/xymodem/sy.rs

@@ -123,7 +123,7 @@ impl Sy {
                     self.errors += 1;
                     if retries > 5 {
                         self.send_state = SendState::None;
-                        return Err(Box::new(TransmissionError::TooManyRetriesSendingHeader));
+                        return Err(TransmissionError::TooManyRetriesSendingHeader.into());
                     }
                     self.send_state = SendState::SendYModemHeader(retries + 1);
                     return Ok(());
@@ -175,7 +175,7 @@ impl Sy {
                     if can2 == CAN {
                         self.send_state = SendState::None;
                         //transfer_info.write("Got cancel ...".to_string());
-                        return Err(Box::new(TransmissionError::Cancel));
+                        return Err(TransmissionError::Cancel.into());
                     }
                 }
 
@@ -191,7 +191,7 @@ impl Sy {
 
                     if retries > 5 {
                         self.eot(com)?;
-                        return Err(Box::new(TransmissionError::TooManyRetriesSendingHeader));
+                        return Err(TransmissionError::TooManyRetriesSendingHeader.into());
                     }
                     self.send_state = SendState::SendData(cur_offset, retries + 1);
                     return Ok(());
@@ -291,8 +291,8 @@ impl Sy {
                 };
                 Ok(())
             }
-            CAN => Err(Box::new(TransmissionError::Cancel)),
-            _ => Err(Box::new(TransmissionError::InvalidMode(ch))),
+            CAN => Err(TransmissionError::Cancel.into()),
+            _ => Err(TransmissionError::InvalidMode(ch).into()),
         }
     }