a quick sketch of some ideas

Cargo.toml

@@ -9,9 +9,10 @@ edition = "2018"
 [dependencies]
 qrcode = "0.11"
 base64 = "0.13.0"
+structopt = "0.3.21"
 
 [dev-dependencies]
 rand = "0.8.3"
 assert_cmd = "1.0.3"
 assert_fs = "1.0.1"
-predicates = "1.0.7"
+predicates = "1.0.7"

src/chunk_iterator.rs

@@ -0,0 +1,41 @@
+use std::io::{BufRead, Read};
+
+use std::io;
+
+pub struct ChunkIterator<T>
+where
+    T: Read,
+{
+    reader: T,
+    chunk_size: u64,
+}
+
+impl<T> ChunkIterator<T>
+where
+    T: Read,
+{
+    pub fn new(reader: T, chunk_size: u64) -> Self {
+        Self { reader, chunk_size }
+    }
+}
+
+impl<T> Iterator for ChunkIterator<T>
+where
+    T: BufRead,
+{
+    type Item = io::Result<Vec<u8>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut buf = Vec::default();
+        match self
+            .reader
+            .by_ref()
+            .take(self.chunk_size)
+            .read_to_end(&mut buf)
+        {
+            Ok(0) => None,
+            Ok(_n) => Some(Ok(buf)),
+            Err(e) => Some(Err(e)),
+        }
+    }
+}

src/main.rs

@@ -1,32 +1,40 @@
-use std::env;
-use std::fs;
+#![feature(seek_stream_len)]
+#![warn(clippy::pedantic)]
+#![deny(missing_docs, missing_debug_implementations, clippy::all)]
+
 use std::io::Read;
 use std::io::Write;
+use std::io::{BufRead, BufReader};
+use std::{fs, path::PathBuf};
 // use std::io::{BufRead, BufReader};
 use std::io::{Seek, SeekFrom};
-use std::path::Path;
 use std::process;
 
 extern crate base64;
 
+mod chunk_iterator;
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+pub struct Args {
+    #[structopt(short, long = "input")]
+    pub input_file: PathBuf,
+    #[structopt(short, long = "output")]
+    pub output_directory: PathBuf,
+}
+
 fn main() {
+    let args = Args::from_args();
     // Check arguments for file to open
-    let args: Vec<String> = env::args().collect();
-    if args.len() < 3 {
-        let binary_name = &args[0];
-        println!("Usage: {} FILE_TO_SEND OUTPUT_FOLDER", binary_name);
-        process::exit(1);
-    }
-    let input_filename = &args[1];
-    let output_folder = &args[2];
+    let input_filename = args.input_file;
     let mut file = match fs::File::open(input_filename) {
         Ok(f) => f,
         Err(err) => panic!("File error: {}", err),
     };
 
     // Ensure output folder exists
-    fs::create_dir_all(output_folder).expect("Could not create/check output folder");
-    let output_path = Path::new(output_folder);
+    fs::create_dir_all(&args.output_directory).expect("Could not create/check output folder");
+    let output_path = args.output_directory.join("input_b64.txt");
     // Create a base64 version of our file
     let mut base64_file = match fs::File::create(output_path.join("input_b64.txt")) {
         Ok(f) => f,
@@ -63,18 +71,17 @@ fn main() {
         .sync_all()
         .expect("Error syncing base64 file to disks");
 
-    // let base64_filesize_bytes = base64_file
-    //     .stream_len()
-    //     .expect("Error checking base64 filesize");
+    let base64_filesize_bytes = base64_file
+        .stream_len()
+        .expect("Error checking base64 filesize");
 
-    // let chunk_reader;
-    // let chunk_read;
-    // {
-    //     chunk_reader = BufReader::with_capacity(1024, base64_file);
+    let mut chunk_reader;
+    let chunk_read;
+    {
+        chunk_reader = BufReader::with_capacity(1024, base64_file);
 
-    //     chunk_read = chunk_reader
-    //         .fill_buf()
-    //         .expect("Error reading chunk off base64 file");
-    // }
-    // println!("Read {:?} bytes: {:?}", chunk_read, chunk_reader);
+        chunk_read = chunk_reader
+            .fill_buf()
+            .expect("Error reading chunk off base64 file");
+    }
 }