Removed a couple TODOs that were actually already complete.

src/kermit.rs

@@ -158,14 +158,14 @@ fn make_generic_packet(seq: &mut u32, ptype: char) -> Vec<u8> {
 // do with how we read the packet (3 bytes then rest of packet).
 fn read_packet(port: &mut Box<dyn serialport::SerialPort>) -> Result<KermitPacket, String> {
  // have to sleep, probably because the calculator is slow
- std::thread::sleep(std::time::Duration::from_millis(300));
+ std::thread::sleep(std::time::Duration::from_millis(400));
  // it seems we have to read 3 bytes, then the rest of the packet
  let mut header: [u8; 3] = [0; 3];
  match port.read(header.as_mut_slice()) {
  Ok(_) => {},
  Err(e) => return Err("failed to read header of packet: ".to_owned() + &e.to_string()),
  }
-
+ //println!("header is {:x?}", header);
  if header[0] != SOH {
  return Err("malformed Kermit packet (SOH missing)".to_owned());
  }
@@ -174,12 +174,12 @@ fn read_packet(port: &mut Box<dyn serialport::SerialPort>) -> Result<KermitPacke
  let len = unchar(header[1]);
  // this would be len - 1, but we want to also read the CR at the end of the packet.
  let mut rest_of_packet = vec![0 as u8; len as usize];
-
+ 
  match port.read(rest_of_packet.as_mut_slice()) {
  Ok(_) => {},
  Err(e) => return Err("failed to read packet data: ".to_owned() + &e.to_string()),
  }
-
+ //println!("rest of packet is {:x?}", rest_of_packet);
  // subtract 2 to drop 0x0d and check field, to isolate just data
  // portion and assemble KermitPacket struct.
  let data_field = rest_of_packet[1..(len as usize - 2)].to_vec();
@@ -210,7 +210,7 @@ fn send_packet(p: KermitPacket, bar: &ProgressBar, port: &mut Box<dyn serialport
  Ok(_) => {},
  Err(e) => {
  bar.abandon();
- crate::helpers::error_handler(format!("Error: failed to write data packet: {:?}", e));
+ crate::helpers::error_handler(format!("Error: failed to write data packet: {}", e));
  },
  }
  match read_packet(port) {
@@ -223,7 +223,7 @@ fn send_packet(p: KermitPacket, bar: &ProgressBar, port: &mut Box<dyn serialport
  },
  Err(e) => {
  bar.abandon();
- crate::helpers::error_handler(format!("Error: bad \"D\" packet response: {:?}.", e));
+ crate::helpers::error_handler(format!("Error: bad \"D\" packet response: {}.", e));
  },
  }
 }
@@ -286,6 +286,29 @@ fn make_packet_list(f: Vec<u8>, seq: &mut u32) -> Vec<KermitPacket> {
  return packet_list;
 }
 
+fn finish_server(port: &mut Box<dyn serialport::SerialPort>) {
+ // "I" packet is identical to "S" except for the packet type.
+
+ // seq can and probably should be 0, and Rust lets you do `&mut 0`
+ // legally. Funky, for sure.
+ let i_packet = make_init_packet(&mut 0, 'I');
+ match port.write(&i_packet) {
+ Ok(_) => {},
+ Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"I\" packet: {}", e)),
+ }
+ // could wait for ack but probably don't need to.
+ std::thread::sleep(std::time::Duration::from_millis(300));
+
+ // we are sending a 'G' packet with 'F' in the data field,
+ // which tells the server to finish.
+ // we use 0 as the seq number even though the I packet was also 0.
+ let f_packet = vec![SOH, 0x24, tochar(0), 'G' as u8, 'F' as u8, 0x34, CR]; // hardcoded CRC
+ match port.write(&f_packet) {
+ Ok(_) => {},
+ Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"GF\" packet: {}", e)),
+ }
+}
+
 // TODO: this is pretty unreliable and doesn't work with x48 at full
 // speed. It has to do with the read_packet() function.
 
@@ -300,29 +323,29 @@ pub fn send_file(path: &PathBuf, port: &mut Box<dyn serialport::SerialPort>, fin
  let s_packet = make_init_packet(&mut seq, 'S');
  match port.write(&s_packet) {
  Ok(_) => {},
- Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"S\" packet: {:?}", e)),
+ Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"S\" packet: {}", e)),
  }
  match read_packet(port) {
  Ok(packet) => {
  if packet.ptype != 'Y' as u8 {
  crate::helpers::error_handler("Error: no ACK for \"S\" packet. Try sending again.".to_string());
  }
  },
- Err(e) => crate::helpers::error_handler(format!("Error: bad \"S\" packet response: {:?}.", e)),
+ Err(e) => crate::helpers::error_handler(format!("Error: bad \"S\" packet response: {}.", e)),
  }
 
  let f_packet = make_f_packet(&mut seq, path.file_name().unwrap());
  match port.write(&f_packet) {
  Ok(_) => {},
- Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"F\" packet: {:?}", e)),
+ Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"F\" packet: {}", e)),
  }
  match read_packet(port) {
  Ok(packet) => {
  if packet.ptype != 'Y' as u8 {
  crate::helpers::error_handler("Error: no ACK for \"F\" packet. Try sending again.".to_string());
  }
  },
- Err(e) => crate::helpers::error_handler(format!("Error: bad \"F\" packet response: {:?}", e)),
+ Err(e) => crate::helpers::error_handler(format!("Error: bad \"F\" packet response: {}", e)),
  }
 
  let packet_list = make_packet_list(file_contents, &mut seq);
@@ -340,7 +363,7 @@ pub fn send_file(path: &PathBuf, port: &mut Box<dyn serialport::SerialPort>, fin
  // abondon() leaves the progress bar in place, finish() clears it.
  bar.abandon();
  crate::helpers::error_handler(
- format!("Error: failed to write \"Z\" (end-of-file) packet: {:?}", e));
+ format!("Error: failed to write \"Z\" (end-of-file) packet: {}", e));
  },
  }
 
@@ -353,29 +376,12 @@ pub fn send_file(path: &PathBuf, port: &mut Box<dyn serialport::SerialPort>, fin
  Err(e) => {
  bar.abandon();
  crate::helpers::error_handler(
- format!("Error: failed to write \"B\" (end-of-transmission) packet: {:?}", e));
+ format!("Error: failed to write \"B\" (end-of-transmission) packet: {}", e));
  },
  }
  bar.finish();
 
  if finish {
- // "I" packet is identical to "S" except for the packet type.
- let i_packet = make_init_packet(&mut seq, 'I');
- match port.write(&i_packet) {
- Ok(_) => {},
- Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"I\" packet: {:?}", e)),
- }
- // could wait for ack but probably don't need to.
- std::thread::sleep(std::time::Duration::from_millis(300));
- // note: sending the I packet resets the seq number.
-
- // we are sending a 'G' packet with 'F' in the data field,
- // which tells the server to finish.
- let f_packet = vec![SOH, 0x24, tochar(0), 'G' as u8, 'F' as u8, 0x34, CR]; // hardcoded CRC
- match port.write(&f_packet) {
- Ok(_) => {},
- Err(e) => crate::helpers::error_handler(format!("Error: failed to write \"GF\" packet: {:?}", e)),
- }
-
+ finish_server(port);
  }
 }

src/main.rs

@@ -93,15 +93,14 @@ enum Commands {
 }
 
 
-// TODO: this needs to find USB serial ports, because other ports
-// might be present. On Windows, I think they're generated by Intel ME
-// or other hardware.
 fn get_serial_port(cli_port: Option<PathBuf>, cli_baud: Option<u32>) -> Box<dyn serialport::SerialPort> {
  let discovered_ports = serialport::available_ports().expect("No ports found!");
 
  let mut usb_serial_ports: Vec<serialport::SerialPortInfo> = Vec::new();
 
- // Sort through the ports and find only USB serial ports.
+ // Sort through the ports and find only USB serial
+ // ports. Sometimes other ports are present, and it's quite
+ // unlikely that they would be for the calculator
  for p in &discovered_ports {
  match p.port_type {
  serialport::SerialPortType::UsbPort(..) => {
@@ -172,7 +171,7 @@ fn main() {
  // send file directly to XRECV
  if cli.finish {
  println!("{}: {}{}{}",
- style("warning").on_yellow().bold(),
+ style("warning").yellow().bright(),
  "ignoring flag ", style("-f").green(),
  " (finish) used in XModem direct mode");
  }

src/xmodem.rs

@@ -409,7 +409,6 @@ pub fn get_file(path: &PathBuf, port: &mut Box<dyn serialport::SerialPort>, dire
  }
 
  let pb = crate::helpers::get_spinner(
- // TODO: this should say the actual file being written to
  format!("Receiving {} as {} on {}...",
  style(original_fname).yellow().bright(),
  style(final_fname).yellow().bright(),