client: Add CLI status codes and implement list-directories.

src/bin/client.rs

 use std::ffi::{OsStr, OsString};
 use std::fs::{self, create_dir_all, remove_file};
+use std::io::Write;
 use std::sync::Arc;
 
 use env_logger::Env;
     client_side_sync: ClientSideSync,
     file_system_watcher: FileSystemWatcher,
     last_error: Option<Error>,
+    paused: bool,
 }
 
 impl SynchronizedDirectory {
             client_side_sync,
             file_system_watcher,
             last_error: None,
+            paused: true,
         })
     }
 
     async fn unpause(&mut self) {
         self.client_side_sync.unpause().await;
         self.file_system_watcher.unpause().await;
+        self.paused = false;
     }
 
     async fn pause(&mut self) {
         self.client_side_sync.pause().await;
         self.file_system_watcher.pause().await;
+        self.paused = true;
     }
 }
 
                 match stream {
                     Some(Ok(stream)) => {
                         let mut stream = stream;
-                        match handle_cli_client(&mut stream, &mut directories, db.clone()).await {
-                            Ok(()) => {}
+                        let mut output = Vec::new();
+                        match handle_cli_client(&mut stream, &mut output, &mut directories, db.clone()).await {
+                            Ok(()) => {
+                                stream.write_all(&0i32.to_be_bytes()).await.ok();
+                                stream.write_all(&output).await.ok();
+                            }
                             Err(e) => {
                                 // Log error and try to send it to the stream.
-                                // TODO: We want to send a return code as well.
+                                error!("CLI command failed: {:?}", e);
+                                stream.write_all(&(-1i32).to_be_bytes()).await.ok();
+                                stream.write_all(&output).await.ok();
                                 stream
                                     .write_all(format!("Error: {:?}", e).as_bytes())
                                     .await
 
 async fn handle_cli_client(
     stream: &mut UnixStream,
+    output: &mut Vec<u8>,
     directories: &mut Vec<SynchronizedDirectory>,
     _db: Arc<Mutex<Database>>,
 ) -> Result<(), Error> {
     let mut request = String::new();
     stream.read_to_string(&mut request).await?;
+    // We must not write to the stream here, as we need to prepend the status code to any other
+    // output.
+    drop(stream);
 
     let options: cli::Options = serde_json::from_str(&request)?;
     let verbose = options.verbose;
     match options.command {
         _cmd @ cli::Command::ListDirectories { .. } => {
-            // TODO
+            write!(output, "{} directories\n", directories.len()).ok();
+            for directory in directories.iter() {
+                write!(
+                    output,
+                    "\nDirectory: {}\nActive: {}\nLast error: {}\n",
+                    directory.path.to_string_lossy(),
+                    !directory.paused,
+                    if directory.last_error.is_some() {
+                        format!("{:?}", directory.last_error.as_ref().unwrap())
+                    } else {
+                        "None".to_owned()
+                    }
+                )
+                .ok();
+            }
         }
         _cmd @ cli::Command::AddDirectory { .. } => {
             // TODO
             for directory in directories.iter_mut() {
                 directory.pause().await;
                 if verbose {
-                    stream
-                        .write_all(
-                            format!("Paused {}.\n", directory.path.to_string_lossy()).as_bytes(),
-                        )
-                        .await
-                        .ok();
+                    write!(output, "Paused {}.\n", directory.path.to_string_lossy()).ok();
                 }
             }
-            stream
-                .write_all("Synchronization paused.\n".as_bytes())
-                .await
-                .ok();
+            write!(output, "Synchronization paused.\n").ok();
         }
         cli::Command::Resume => {
             for directory in directories.iter_mut() {
                 directory.unpause().await;
                 if verbose {
-                    stream
-                        .write_all(
-                            format!("Resumed {}.\n", directory.path.to_string_lossy()).as_bytes(),
-                        )
-                        .await
-                        .ok();
+                    write!(output, "Resumed {}.\n", directory.path.to_string_lossy()).ok();
                 }
             }
-            stream
-                .write_all("Synchronization resumed.\n".as_bytes())
-                .await
-                .ok();
+            write!(output, "Synchronization resumed.\n").ok();
         }
     }