examples/tls-echo-server/src/main.rs

   1 mod schema;
   2
   3 use crate::schema::hello_world::HelloWorld;
   4 use async_std::{io, task};
   5 use connect::tls::rustls::internal::pemfile::{certs, rsa_private_keys};
   6 use connect::tls::rustls::{NoClientAuth, ServerConfig};
   7 use connect::tls::TlsServer;
   8 use connect::{SinkExt, StreamExt};
   9 use log::*;
  10 use std::env;
  11 use std::fs::File;
  12 use std::io::BufReader;
  13
  14 #[async_std::main]
  15 async fn main() -> anyhow::Result<()> {
  16     env_logger::init();
  17
  18     // Get ip address from cmd line args
  19     let (ip_address, cert_path, key_path) = parse_args();
  20
  21     let certs = certs(&mut BufReader::new(File::open(cert_path)?))
  22         .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid cert"))?;
  23
  24     let mut keys = rsa_private_keys(&mut BufReader::new(File::open(key_path)?))
  25         .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid key"))?;
  26
  27     let mut config = ServerConfig::new(NoClientAuth::new());
  28     config
  29         .set_single_cert(certs, keys.remove(0))
  30         .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
  31
  32     // create a server
  33     let mut server = TlsServer::new(ip_address, config.into()).await?;
  34
  35     // handle server connections
  36     // wait for a connection to come in and be accepted
  37     loop {
  38         match server.next().await {
  39             Some(mut conn) => {
  40                 info!("Handling connection from {}", conn.peer_addr());
  41
  42                 task::spawn(async move {
  43                     while let Some(msg) = conn.reader().next().await {
  44                         if msg.is::<HelloWorld>() {
  45                             if let Ok(Some(contents)) = msg.unpack::<HelloWorld>() {
  46                                 info!(
  47                                     "Received a message \"{}\" from {}",
  48                                     contents.get_message(),
  49                                     conn.peer_addr()
  50                                 );
  51
  52                                 conn.writer()
  53                                     .send(contents)
  54                                     .await
  55                                     .expect("Could not send message back to source connection");
  56                                 info!("Sent message back to original sender");
  57                             }
  58                         } else {
  59                             error!("Received a message of unknown type")
  60                         }
  61                     }
  62                 });
  63             }
  64
  65             None => {
  66                 break
  67             }
  68         }
  69     }
  70
  71     Ok(())
  72 }
  73
  74 fn parse_args() -> (String, String, String) {
  75     let args: Vec<String> = env::args().collect();
  76
  77     let ip_address = match args.get(1) {
  78         Some(addr) => addr,
  79         None => {
  80             error!("Need to pass IP address to connect to as first command line argument");
  81             panic!();
  82         }
  83     };
  84
  85     let cert_path = match args.get(2) {
  86         Some(d) => d,
  87         None => {
  88             error!("Need to pass path to cert file as second command line argument");
  89             panic!();
  90         }
  91     };
  92
  93     let key_path = match args.get(3) {
  94         Some(d) => d,
  95         None => {
  96             error!("Need to pass path to key file as third command line argument");
  97             panic!();
  98         }
  99     };
 100
 101     (
 102         ip_address.to_string(),
 103         cert_path.to_string(),
 104         key_path.to_string(),
 105     )
 106 }