Corrupt deflate stream while reading from stdin

[darius-sas]

Hello everyone, I'm an absolute beginner who's trying to learn Rust by coding some basic programs. I'm currently writing a utility that compresses or decompresses from the input stream and writes the result on the output stream. I use flate2 to handle the compression and decompression.
Unfortunately, I'm running into the following error when trying to decompress:

Error occurred while reading stdin: corrupt deflate stream

Printed by line 28 from my code (see below).

Any idea on what's causing it? I think I might be misunderstanding the usage of ZlibDecoder.
To reproduce the error, run:

cargo b
cat Cargo.toml | ./target/debug/compressor c | ./target/debug/compressor d

Here's my main.rs:

use std::io::prelude::*;
use flate2::Compression;
use flate2::write::ZlibEncoder;
use flate2::read::ZlibDecoder;
use std::env;

struct Counter(i64, i64);

fn main() {
    let args: Vec<String> = env::args().collect();

    if args[1] == "d" {
        decompress()
    } else if args[1] == "c" {
        compress()
    } else {
        compress()
    }
}

fn decompress() {
    let mut byte_counter = Counter(0, 0);
    let d = ZlibDecoder::new(std::io::stdin());
    for decoded_byte_r in d.bytes() {
        match decoded_byte_r {
            Err(e) => {
                byte_counter.0 += 1;
                eprintln!("Error occurred while reading stdin: {}", e)
            },
            Ok(decoded_byte) => {
                match std::io::stdout().write(&[decoded_byte]) {
                    Err(_) => println!("Cannot write on stdout"),
                    Ok(_) => {byte_counter.1 += 1}
                }
            }
        }
    }

    eprintln!("\nDeompressed: {} bytes", byte_counter.1);
    eprintln!("Errors: {} bytes", byte_counter.0);
}

fn compress() {
    let mut e = ZlibEncoder::new(std::io::stdout(), Compression::default());
    
    let mut byte_counter = Counter(0, 0);
    for input_byte_r in std::io::stdin().bytes() {
        match input_byte_r {
            Err(_) => byte_counter.0 += 1,
            Ok(input_byte) => {
                match e.write(&[input_byte]) {
                    Err(_) => println!("Cannot write on stdout"),
                    Ok(output_byte) => {
                        byte_counter.1 += output_byte as i64;
                    }
                }
            }
        }
    }
    e.flush_finish().expect("Error when finishing buffer");
    eprintln!("\nCompressed: {} bytes", byte_counter.1);
    eprintln!("Errors: {} bytes", byte_counter.0);
}

and Cargo.toml

[dependencies]
flate2 = "1.0"