wip: message passing

src/fetcher.rs

@@ -1,21 +1,39 @@
-use hyper::rt::{self, lazy, Future};
-use hyper::{Client, StatusCode};
+use hyper::{
+    Client, StatusCode,
+    rt::{self, Future}
+};
 use futures::Stream;
+use std::sync::mpsc::Sender;
+
+#[derive(Debug)]
+pub enum FetcherMessage {
+    Response(String),
+    Log(String)
+}
 
 fn _fetch_url(
+    tx: Sender<FetcherMessage>,
     client: &hyper::Client<hyper::client::HttpConnector>,
     url: hyper::Uri,
 ) -> impl Future<Item = (), Error = ()> {
     client
         // Fetch the url...
         .get(url)
         // And then, if we get a response back...
-        .and_then(|res| {
+        .and_then(move |res| {
             if res.status() == StatusCode::OK {
                 println!("Response: {}", res.status());
                 println!("Headers: {:#?}", res.headers());
+
+                tx.send(
+                    FetcherMessage::Log(String::from("Status != 200"))
+                ).unwrap();
             }
 
+            tx.send(
+                FetcherMessage::Response(String::from("Response received!"))
+            ).unwrap();
+
             Ok(())
         })
         // If there was an error, let the user know...
@@ -24,13 +42,13 @@ fn _fetch_url(
         })
 }
 
-pub fn _run(urls: Vec<hyper::Uri>) {
+pub fn _run(tx: Sender<FetcherMessage>, urls: Vec<hyper::Uri>) {
     let client = Client::new();
 
     let stream = futures::stream::iter_ok(urls)
-        .map(move |url| _fetch_url(&client, url))
+        .map(move |url| _fetch_url(tx.clone(), &client, url))
         .buffer_unordered(1)
-        .for_each(|_| Ok(()))
+        .for_each(Ok)
         .map_err(|_| eprintln!("Err"));
 
     rt::run(stream);

src/main.rs

@@ -1,13 +1,13 @@
-extern crate clap;
-extern crate hyper;
-extern crate pretty_env_logger;
-
-#[macro_use]
-extern crate log;
+#[macro_use] extern crate log;
 
 use clap::{App, Arg};
-use std::fs;
-use std::str;
+
+use std::{
+    fs, str, thread,
+    sync::mpsc::channel
+};
+
+use crate::fetcher::FetcherMessage;
 
 mod fetcher;
 
@@ -96,7 +96,28 @@ fn main() {
             debug!("using mode: dir");
             let urls = load_wordlist_and_build_urls(wordlist_path, url, extensions);
             debug!("urls: {:#?}", urls);
-            fetcher::_run(urls);
+
+            let (tx, rx) = channel();
+
+            thread::spawn(move || {
+                fetcher::_run(tx, urls);
+            });
+
+            loop {
+                let msg = match rx.recv() {
+                    Ok(msg) => msg,
+                    Err(_err) => continue
+                };
+
+                match msg {
+                    FetcherMessage::Response(res) => {
+                        println!("{:?}", res);
+                    }
+                    FetcherMessage::Log(log) => {
+                        println!("{:?}", log);
+                    }
+                }
+            }
         }
         _ => (),
     }