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 => break,
  66         }
  67     }
  68
  69     Ok(())
  70 }
  71
  72 fn parse_args() -> (String, String, String) {
  73     let args: Vec<String> = env::args().collect();
  74
  75     let ip_address = match args.get(1) {
  76         Some(addr) => addr,
  77         None => {
  78             error!("Need to pass IP address to connect to as first command line argument");
  79             panic!();
  80         }
  81     };
  82
  83     let cert_path = match args.get(2) {
  84         Some(d) => d,
  85         None => {
  86             error!("Need to pass path to cert file as second command line argument");
  87             panic!();
  88         }
  89     };
  90
  91     let key_path = match args.get(3) {
  92         Some(d) => d,
  93         None => {
  94             error!("Need to pass path to key file as third command line argument");
  95             panic!();
  96         }
  97     };
  98
  99     (
 100         ip_address.to_string(),
 101         cert_path.to_string(),
 102         key_path.to_string(),
 103     )
 104 }