Use the log crate.

src/bin/client.rs

 use std::fs::{self, create_dir_all, remove_file};
 use std::sync::Arc;
 
+use env_logger::Env;
 use fslock::LockFile;
+use log::{error, info};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{UnixListener, UnixStream};
+use tokio::signal;
 use tokio::stream::StreamExt;
 use tokio::sync::{mpsc, Mutex};
 
 
 #[tokio::main]
 async fn main() {
+    env_logger::from_env(Env::default().default_filter_or("info")).init();
+
     // Create the data directories if necessary.
     create_dir_all(paths::config_dir()).unwrap();
     create_dir_all(paths::client_data()).unwrap();
     fs::write(&paths::client_lock(), b"").ok();
     let mut lock = LockFile::open(&paths::client_lock()).expect("cannot open lockfile");
     if !lock.try_lock().expect("error while locking the lock file") {
-        eprintln!("Client already running, exiting...");
+        error!("Client already running, exiting...");
         return;
     }
 
         tokio::select! {
             result = &mut ctrl_c => {
                 result.expect("could not listen for Ctrl+C");
-                println!("Ctrl+C pressed, terminating...");
+                info!("Ctrl+C pressed, terminating...");
                 // Ctrl+C was pressed, so we terminate the program.
                 break;
             }
                         };
                     }
                     Some(Err(err)) => {
-                        eprintln!("Error while listening on the local unix socket: {:?}", err);
+                        error!("Error while listening on the local unix socket: {:?}", err);
                         break;
                     }
                     None => {
-                        eprintln!("listening for CLI connections failed");
+                        error!("listening for CLI connections failed");
                         break;
                     }
                 }
             }
             error = errors.next() => {
                 let error = error.unwrap();
-                eprintln!("error: {:?}", error.error);
+                error!("Synchronization error: {:?}", error.error);
                 for directory in directories.iter_mut() {
                     if directory.path == error.directory {
                         // In theory, there could be a race condition here where we pause a
 
     Ok(())
 }
-

src/network/client.rs

 use futures::sink::{Sink, SinkExt};
 use futures::stream::{Stream, StreamExt};
 use futures::task::{Context, Poll};
+use log::error;
 use rmps::Serializer;
 use serde::de::DeserializeOwned;
 use serde::Serialize;
                                         free_ids.free(deserialized.id);
                                         call.send(Ok(deserialized.payload)).ok();
                                     } else {
-                                        // TODO: Use proper logging functionality.
-                                        eprintln!(
+                                        error!(
                                             "Received a reply for an unknown call ({:?})!",
                                             deserialized.id
                                         );
                                 // We received an invalid packet. We cannot determine for which
                                 // call the packet was, so we just ignore it. The corresponding
                                 // call will freeze until the connection is dropped.
-                                // TODO: Use proper logging functionality.
-                                eprintln!("Invalid packet received: {:?}", e);
+                                error!("Invalid packet received: {:?}", e);
                             }
                         };
                     }
                     Some(Err(e)) => {
-                        // TODO: Use proper logging functionality.
-                        eprintln!("Network error: {:?}", e);
+                        error!("Network error: {:?}", e);
                     }
                     None => {
                         // Stream closed. We still need to return errors for any