diff --git a/src/control.rs b/src/control.rs
index c76e927..48701b0 100644
--- a/src/control.rs
+++ b/src/control.rs
@@ -1,51 +1,23 @@
 // #![allow(dead_code, unused_imports, unused_variables, unused_mut, unreachable_patterns)] // Please be quiet, I'm coding
-use std::{ sync::{ RwLock, Arc }, sync::atomic::Ordering, mem::drop, collections::{ HashMap, VecDeque }, cmp };
-use regex::Regex;
+use std::{ sync::{ RwLock, Arc }, sync::atomic::Ordering, mem::drop, collections::HashMap };
 use tokio::{ fs, sync };
 use petgraph::{ graph, graph::UnGraph, data::FromElements, algo };
-use lazy_static::lazy_static;
 use rand::seq::SliceRandom;
-#[allow(unused_imports)]
-use crate::{ Config, Node, Control, Protocol, LogLevel, unixtime, timestamp, timestamp_from, get_local_interfaces, duration_from };
+use crate::{ Config, Control, Data, IntfStats, LogLevel, Node, Path, PingResult, Protocol, get_local_interfaces, duration_from, unixtime, shorten_ipv6 };
 
 #[cfg(feature = "web")]
-use http_body_util::Full;
+use crate::web::{ run_http, run_https };
 #[cfg(feature = "web")]
-use hyper::{ Request, Response, body::{ Bytes, Incoming }, service::service_fn };
-#[cfg(feature = "web")]
-use hyper_util::rt::TokioIo;
-#[cfg(feature = "web")]
-use hyper_tungstenite::{HyperWebsocket, tungstenite::Message};
-#[cfg(feature = "web")]
-use tokio_stream::wrappers::TcpListenerStream;
-#[cfg(feature = "web")]
-use futures_util::stream::StreamExt;
-#[cfg(feature = "web")]
-use rustls_acme::{ AcmeConfig, AccountCache, CertCache };
-#[cfg(feature = "web")]
-use serde::Serialize;
-#[cfg(feature = "web")]
-use tokio::net::TcpListener;
-#[cfg(feature = "web")]
-use ring::digest::{ Context, SHA256 };
-#[cfg(feature = "web")]
-use async_trait::async_trait;
-#[cfg(feature = "web")]
-use base64::{ Engine as _, engine::general_purpose::STANDARD as base64 };
+use hyper_tungstenite::tungstenite::Message;
 
 #[cfg(feature = "tui")]
-use termion::{ raw::IntoRawMode, screen::IntoAlternateScreen, screen::AlternateScreen, raw::RawTerminal, input::TermRead, event::Key };
+use crate::{ timestamp, timestamp_from, tui::{ draw, start_tui } };
 #[cfg(feature = "tui")]
-use tui::{ Terminal, Frame, backend::{ Backend, TermionBackend }, widgets::{ Block, Borders, List, ListItem, Table, Row }, layout::{ Layout, Constraint, Direction, Corner }, text::{ Span, Spans }, style::{ Style, Color } };
+use termion::{ input::TermRead, event::Key };
 
 
-static HISTSIZE: usize = 1440;
 static THRESHOLD: u16 = 4;
 static MAX_LINGER: u64 = 86400; // Seconds to keep visualising links that are down
-#[cfg(feature = "web")]
-static INDEX_FILE: &str = include_str!("../web/index.html");
-#[cfg(feature = "web")]
-static ICON_FILE: &[u8] = include_bytes!("../web/favicon.ico");
 
 trait GraphExt {
     fn find_node(&self, name: &str) -> Option<graph::NodeIndex>;
@@ -120,192 +92,6 @@ impl GraphExt for UnGraph<String, u32> {
     }
 }
 
-struct PingResult {
-    node: String,
-    intf: String,
-    port: String,
-    min: u16,
-    losspct: f32,
-    last: Option<u16>,
-    hist: VecDeque<u16>,
-    statesince: u64 // Unix timestamp
-}
-impl PingResult {
-    fn new(node: String, intf: String, port: String) -> PingResult {
-        PingResult { node, intf, port, min: u16::MAX, losspct: 0.0, last: None, hist: VecDeque::with_capacity(HISTSIZE), statesince: unixtime() }
-    }
-    fn push_hist(&mut self, result: u16) {
-        if self.hist.len() >= HISTSIZE { self.hist.pop_back().unwrap(); }
-        self.hist.push_front(result);
-    }
-}
-impl Ord for PingResult {
-    fn cmp(&self, other: &Self) -> cmp::Ordering {
-        match self.node.cmp(&other.node) {
-            cmp::Ordering::Equal => {
-                match self.port.cmp(&other.port) { // TODO: better comparison for ip addresses
-                    cmp::Ordering::Equal => self.intf.cmp(&other.intf),
-                    ord => ord
-                }
-            },
-            ord => ord
-        }
-    }
-}
-impl Eq for PingResult {}
-impl PartialOrd for PingResult {
-    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-impl PartialEq for PingResult {
-    fn eq(&self, other: &Self) -> bool {
-        self.node == other.node && self.port == other.port && self.intf == other.intf
-    }
-}
-
-#[derive(Default)]
-struct Data {
-    log: RwLock<VecDeque<(u64, String)>>,
-    ping: RwLock<VecDeque<String>>,
-    intf: RwLock<HashMap<String, IntfStats>>,
-    results: RwLock<Vec<PingResult>>,
-    pathcache: RwLock<Vec<Path>>
-}
-impl Data {
-    fn push_log(&self, ts: u64, line: String) {
-        let mut log = self.log.write().unwrap();
-        if log.len() >= 50 { log.pop_back().unwrap(); }
-        log.push_front((ts, line));
-    }
-    fn push_ping(&self, line: String) {
-        let mut ping = self.ping.write().unwrap();
-        if ping.len() >= 50 { ping.pop_back().unwrap(); }
-        ping.push_front(line);
-    }
-}
-struct IntfStats {
-    #[allow(dead_code)]
-    symbol: char,
-    min: u16,
-    lag: u16
-}
-
-#[derive(Debug)]
-struct Path {
-    from: String,
-    to: String,
-    fromintf: String,
-    tointf: String,
-    losspct: u8,
-    since: u64
-}
-impl Path {
-    fn new(from: String, to: String, fromintf: String, tointf: String, losspct: u8) -> Path {
-        Path { from, to, fromintf, tointf, losspct, since: unixtime() }
-    }
-}
-impl PartialEq for Path {
-    fn eq(&self, other: &Self) -> bool {
-        self.from == other.from && self.to == other.to && self.fromintf == other.fromintf && self.tointf == other.tointf
-    }
-}
-
-#[cfg(feature = "web")]
-struct ConfigCache {
-    config: Arc<RwLock<Config>>
-}
-#[cfg(feature = "web")]
-impl ConfigCache {
-    fn new(config: &Arc<RwLock<Config>>) -> ConfigCache {
-        ConfigCache {
-            config: config.clone()
-        }
-    }
-    fn cached_account_key(&self, contact: &[String], directory_url: impl AsRef<str>) -> String {
-        let mut ctx = Context::new(&SHA256);
-        for el in contact {
-            ctx.update(el.as_ref());
-            ctx.update(&[0])
-        }
-        ctx.update(directory_url.as_ref().as_bytes());
-        let hash = base64.encode(ctx.finish());
-        format!("cached_account_{}", hash)
-    }
-    fn cached_cert_key(&self, domains: &[String], directory_url: impl AsRef<str>) -> String {
-        let mut ctx = Context::new(&SHA256);
-        for domain in domains {
-            ctx.update(domain.as_ref());
-            ctx.update(&[0])
-        }
-        ctx.update(directory_url.as_ref().as_bytes());
-        let hash = base64.encode(ctx.finish());
-        format!("cached_cert_{}", hash)
-    }
-}
-#[async_trait]
-#[cfg(feature = "web")]
-impl CertCache for ConfigCache {
-    type EC = std::io::Error;
-    async fn load_cert(
-        &self,
-        domains: &[String],
-        directory_url: &str,
-    ) -> Result<Option<Vec<u8>>, Self::EC> {
-        let key = self.cached_cert_key(&domains, directory_url);
-        Ok(self.config.read().unwrap().cache.get(&key).map(|v| base64.decode(v).unwrap()))
-    }
-    async fn store_cert(
-        &self,
-        domains: &[String],
-        directory_url: &str,
-        cert: &[u8],
-    ) -> Result<(), Self::EC> {
-        let key = self.cached_cert_key(&domains, directory_url);
-        let mut config = self.config.write().unwrap();
-        config.cache.insert(key, base64.encode(cert));
-        config.modified.store(true, Ordering::Relaxed);
-        Ok(())
-    }
-}
-#[async_trait]
-#[cfg(feature = "web")]
-impl AccountCache for ConfigCache {
-    type EA = std::io::Error;
-    async fn load_account(
-        &self,
-        contact: &[String],
-        directory_url: &str,
-    ) -> Result<Option<Vec<u8>>, Self::EA> {
-        let key = self.cached_account_key(&contact, directory_url);
-        Ok(self.config.read().unwrap().cache.get(&key).map(|v| base64.decode(v).unwrap()))
-    }
-
-    async fn store_account(
-        &self,
-        contact: &[String],
-        directory_url: &str,
-        account: &[u8],
-    ) -> Result<(), Self::EA> {
-        let key = self.cached_account_key(&contact, directory_url);
-        let mut config = self.config.write().unwrap();
-        config.cache.insert(key, base64.encode(account));
-        config.modified.store(true, Ordering::Relaxed);
-        Ok(())
-    }
-}
-
-#[cfg(feature = "tui")]
-fn start_tui(data: Arc<Data>) -> Option<Terminal<TermionBackend<AlternateScreen<RawTerminal<std::io::Stdout>>>>> {
-    let stdout = std::io::stdout().into_raw_mode().unwrap();
-    let stdout = stdout.into_alternate_screen().unwrap();
-    let backend = TermionBackend::new(stdout);
-    let mut term = Terminal::new(backend).unwrap();
-    term.clear().unwrap();
-    term.draw(|f| draw(f, data)).unwrap();
-    Some(term)
-}
-
 pub async fn run(aconfig: Arc<RwLock<Config>>, mut rx: sync::mpsc::Receiver<Control>, ctrltx: sync::mpsc::Sender<Control>, udptx: sync::mpsc::Sender<Control>) {
     let mut peers = HashMap::new();
     let mynode = graph::NodeIndex::new(0);
@@ -327,69 +113,14 @@ pub async fn run(aconfig: Arc<RwLock<Config>>, mut rx: sync::mpsc::Receiver<Cont
         let config = aconfig.clone();
         let data = data.clone();
         let ctrltx = ctrltx.clone();
-        tokio::spawn(async move {
-            let http = hyper::server::conn::http1::Builder::new();
-            let service = service_fn(move |req| {
-                // if debug { println!("{} Received HTTP request {} {}", timestamp(), req.method(), req.uri()); }
-                handle_http(req, config.clone(), data.clone())
-            });
-            let tcp_listener = match TcpListener::bind(&arg).await {
-                Ok(x) => x,
-                Err(e) => {
-                    ctrltx.send(Control::Log(LogLevel::Error, format!("Failed to start http server on {arg}: {e}"))).await.unwrap();
-                    return;
-                }
-            };
-            ctrltx.send(Control::Log(LogLevel::Info, format!("Started HTTP server on {}", arg))).await.unwrap();
-            while let Ok((stream, addr)) = tcp_listener.accept().await {
-                if debug { ctrltx.send(Control::Log(LogLevel::Debug, format!("Incoming HTTP connection from {}", addr))).await.unwrap(); }
-                let conn = http.serve_connection(TokioIo::new(stream), service.clone()).with_upgrades();
-                if let Err(e) = tokio::spawn(async move { conn.await }).await {
-                    ctrltx.send(Control::Log(LogLevel::Error, format!("Error: {e}"))).await.unwrap();
-                }
-            }
-        });
+        run_http(config, data, ctrltx, arg, debug);
     }
     #[cfg(feature = "web")]
     if let Some(arg) = https {
         let config = aconfig.clone();
         let data = data.clone();
         let ctrltx = ctrltx.clone();
-        tokio::spawn(async move {
-            let http = hyper::server::conn::http1::Builder::new();
-            let aconfig = config.clone();
-            let service = service_fn(move |req| {
-                // if debug { println!("{} Received HTTPS request {} {}", timestamp(), req.method(), req.uri()); }
-                handle_http(req, aconfig.clone(), data.clone())
-            });
-            let tcp_listener = match TcpListener::bind(&arg).await {
-                Ok(x) => x,
-                Err(e) => {
-                    ctrltx.send(Control::Log(LogLevel::Error, format!("Failed to start https server on {arg}: {e}"))).await.unwrap();
-                    return;
-                }
-            };
-            let domain = arg.rsplit_once(':').expect("No colon found in --https argument").0;
-            if domain.contains(':') || domain.find(char::is_alphabetic).is_none() {
-                ctrltx.send(Control::Log(LogLevel::Error, format!("Cannot use bare IP address with --https; use a fully qualified domain name"))).await.unwrap();
-                return;
-            }
-            let tcp_incoming = TcpListenerStream::new(tcp_listener);
-            let mut tls_incoming = AcmeConfig::new([ &domain ])
-                .contact_push(format!("mailto:{}", letsencrypt.unwrap()))
-                .cache(ConfigCache::new(&config))
-                .directory_lets_encrypt(true)
-                .tokio_incoming(tcp_incoming, Vec::new());
-            ctrltx.send(Control::Log(LogLevel::Info, format!("Started HTTPS server on {}", arg))).await.unwrap();
-            while let Some(tls) = tls_incoming.next().await {
-                let stream = tls.unwrap();
-                if debug { ctrltx.send(Control::Log(LogLevel::Debug, format!("Incoming HTTPS connection from {}", stream.get_ref().get_ref().0.get_ref().peer_addr().unwrap_or("0.0.0.0:0".parse().unwrap())))).await.unwrap(); }
-                let conn = http.serve_connection(TokioIo::new(stream), service.clone()).with_upgrades();
-                if let Err(e) = tokio::spawn(async move { conn.await }).await {
-                    ctrltx.send(Control::Log(LogLevel::Error, format!("Error: {e}"))).await.unwrap();
-                }
-            }
-        });
+        run_https(config, data, ctrltx, arg, letsencrypt, debug);
     }
 
     #[cfg(feature = "tui")]
@@ -1021,262 +752,3 @@ fn check_loss_port(result: &mut PingResult) {
         result.losspct = 0.0;
     }
 }
-
-#[cfg(feature = "tui")]
-fn draw<B: Backend>(f: &mut Frame<B>, data: Arc<Data>) {
-    let resultssize = match data.results.read().unwrap().len() { 0 => 3, n => n+2 } as u16;
-    let vert1 = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Min(12), Constraint::Length(resultssize) ].as_ref())
-        .split(f.size());
-    let hori = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Max(105), Constraint::Percentage(50)].as_ref())
-        .split(vert1[0]);
-    let vert2 = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Min(6), Constraint::Length((data.intf.read().unwrap().len()+3) as u16)].as_ref())
-        .split(hori[1]);
-
-    let block = Block::default()
-            .title(" Ping results ")
-            .borders(Borders::ALL);
-    let mut content: Vec<ListItem> = vec![];
-    for line in data.ping.read().unwrap().iter().take(hori[0].height.into()) {
-        content.push(ListItem::new(Span::from(line.clone())));
-    }
-    let list = List::new(content).block(block).start_corner(Corner::BottomLeft);
-    f.render_widget(list, hori[0]);
-
-    let block = Block::default()
-            .title(" Network log ")
-            .borders(Borders::ALL);
-    let mut content: Vec<ListItem> = vec![];
-    for (ts, line) in data.log.read().unwrap().iter().take(vert2[0].height.into()) {
-        content.push(ListItem::new(Span::from(format!("{} {}", timestamp_from(*ts), line))));
-    }
-    let list = List::new(content).block(block).start_corner(Corner::BottomLeft);
-    f.render_widget(list, vert2[0]);
-
-    let block = Block::default()
-            .title(" Local interface stats ")
-            .borders(Borders::ALL);
-    let mut content: Vec<Row> = vec![];
-    {
-        let intf = data.intf.read().unwrap();
-        let mut rows: Vec<_> = intf.iter().collect();
-        rows.sort_by(|a, b| a.1.symbol.cmp(&b.1.symbol));
-        for (intf, stats) in rows {
-            content.push(Row::new(vec![ format!(" {} ", stats.symbol), shorten_ipv6(intf.clone()), format!("{:^5}", stats.min), format!("{:^5}", stats.lag) ]));
-        }
-    }
-    let table = Table::new(content)
-        .block(block)
-        .column_spacing(1)
-        .header(Row::new(vec![ "Sym", "Interface", "Best", "Lag" ]))
-        .widths(&[Constraint::Length(3), Constraint::Length(26), Constraint::Length(5), Constraint::Length(5)]);
-    f.render_widget(table, vert2[1]);
-
-    let block = Block::default()
-        .title(" Results grid ")
-        .borders(Borders::ALL);
-    let mut content: Vec<ListItem> = vec![];
-    let mut prev = String::new();
-    let mut mark;
-    for result in data.results.read().unwrap().iter() {
-        if prev != result.node {
-            prev = result.node.clone();
-            mark = "▔";
-        }
-        else { mark = " "; }
-        let symbol = match data.intf.read().unwrap().get(&result.intf) {
-            Some(i) => i.symbol,
-            None => ' '
-        };
-        let header = format!("{:10} {:26} {} ", result.node, shorten_ipv6(result.port.to_string()), symbol);
-        let mut line = Vec::with_capacity((vert1[1].width).into());
-        line.push(Span::from(header));
-        if let Some(rtt) = result.last {
-            line.push(draw_mark(rtt, result.min, mark));
-        }
-        else { line.push(Span::raw(" ")); }
-        for rtt in result.hist.iter().take((vert1[1].width-43).into()) {
-            line.push(draw_mark(*rtt, result.min, mark));
-        }
-        content.push(ListItem::new(Spans::from(line)));
-    }
-    if content.is_empty() { content.push(ListItem::new("No results yet")); }
-    let list = List::new(content).block(block).start_corner(Corner::TopLeft);
-    f.render_widget(list, vert1[1]);
-}
-
-#[cfg(feature = "tui")]
-fn draw_mark(rtt: u16, min: u16, mark: &'static str) -> Span<'static> {
-    lazy_static!{
-        static ref STYLES: Vec<Style> = vec![
-            // Indexed colors overview: https://jonasjacek.github.io/colors/
-            Style::default().fg(Color::Black).bg(Color::Indexed(46)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(82)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(118)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(154)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(190)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(226)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(220)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(214)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(208)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(202)),
-            Style::default().fg(Color::Black).bg(Color::Indexed(196))
-        ];
-    }
-    if rtt == 0 { return Span::styled("•", Style::default().fg(Color::Black).bg(Color::Indexed(196))); }
-    if rtt == u16::MAX { return Span::raw(" "); }
-    let delaycat = match rtt-min {
-      n if n > THRESHOLD => ((n-THRESHOLD) as f32).sqrt() as usize,
-      _ => 0
-    };
-    if delaycat < STYLES.len() { return Span::styled(mark, STYLES[delaycat]); }
-    return Span::styled("^", (*STYLES.last().unwrap()).fg(Color::Black));
-}
-
-// async fn upgrade_websocket(ws: warp::ws::Ws, addr: Option<SocketAddr>, config: Arc<RwLock<Config>>, data: Arc<Data>) -> Result<impl warp::Reply, warp::Rejection> {
-//     if addr.is_none() { return Err(warp::reject::reject()); }
-//     Ok(ws.on_upgrade(move |socket| handle_websocket(socket, config, data)))
-// }
-
-#[cfg(feature = "web")]
-async fn handle_http(mut request: Request<Incoming>, config: Arc<RwLock<Config>>, data: Arc<Data>) -> Result<Response<Full<Bytes>>, Box<dyn std::error::Error + Send + Sync + 'static>> {
-    if hyper_tungstenite::is_upgrade_request(&request) {
-        let (response, websocket) = hyper_tungstenite::upgrade(&mut request, None)?;
-        tokio::spawn(async move {
-            let _ = handle_websocket(websocket, config, data).await;
-        });
-        Ok(response)
-    } else {
-        match request.uri().path() {
-            "/" => Ok(Response::new(Full::<Bytes>::from(INDEX_FILE))),
-            "/favicon.ico" => Ok(Response::new(Full::<Bytes>::from(ICON_FILE))),
-            _ => Ok(Response::builder().status(hyper::StatusCode::NOT_FOUND).body(Full::<Bytes>::from("")).unwrap())
-        }
-    }
-
-}
-
-#[cfg(feature = "web")]
-async fn handle_websocket(ws: HyperWebsocket, config: Arc<RwLock<Config>>, data: Arc<Data>) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    #[derive(Default, Serialize)]
-    struct JsonGraph {
-        msg: &'static str,
-        nodes: Vec<JsonNode>,
-        edges: Vec<JsonEdge>,
-        paths: Vec<JsonPath>,
-        log: Vec<JsonLog>
-    }
-    #[derive(Serialize)]
-    struct JsonNode {
-        name: String
-    }
-    #[derive(Serialize)]
-    struct JsonEdge {
-        from: String,
-        to: String,
-        mode: &'static str
-    }
-    #[derive(Serialize)]
-    struct JsonPath {
-        fromname: String,
-        fromintf: String,
-        toname: String,
-        tointf: String,
-        losspct: u8
-    }
-    #[derive(Serialize)]
-    struct JsonLog {
-        ts: u64,
-        text: String
-    }
-
-    let (ws_tx, mut ws_rx) = ws.await?.split();
-    let (tx, rx) = sync::mpsc::unbounded_channel();
-    let rx = tokio_stream::wrappers::UnboundedReceiverStream::new(rx);
-    tokio::spawn(rx.forward(ws_tx));
-
-    let mut res = JsonGraph { msg: "init", ..Default::default() };
-    {
-        let config = config.read().unwrap();
-        let mut runtime = config.runtime.write().unwrap();
-        runtime.wsclients.push(tx.clone());
-
-        let nodes = runtime.graph.raw_nodes();
-        for node in nodes.iter() {
-            res.nodes.push(JsonNode { name: node.weight.clone() });
-        }
-        for edge in runtime.graph.raw_edges() {
-            let mode = match runtime.msp.contains_edge(edge.source(), edge.target()) {
-                true => "active",
-                false => "standby"
-            };
-            res.edges.push(JsonEdge { from: runtime.graph[edge.source()].clone(), to: runtime.graph[edge.target()].clone(), mode });
-        }
-        drop(runtime);
-        let log = data.log.read().unwrap();
-        for (ts, msg) in log.iter().rev() {
-            res.log.push(JsonLog { ts: *ts, text: msg.clone() });
-        }
-        let results = data.results.read().unwrap();
-        for result in results.iter() {
-            res.paths.push(JsonPath { fromname: config.name.clone(), fromintf: result.intf.clone(), toname: result.node.clone(), tointf: result.port.clone(), losspct: result.losspct.round() as u8 });
-        }
-        let pathcache = data.pathcache.read().unwrap();
-        for path in pathcache.iter() {
-            res.paths.push(JsonPath { fromname: path.from.clone(), fromintf: path.fromintf.clone(), toname: path.to.clone(), tointf: path.tointf.clone(), losspct: path.losspct });
-        }
-    }
-    tx.send(Ok(Message::text(serde_json::to_string(&res).unwrap())))?;
-
-    while let Some(message) = ws_rx.next().await {
-        match message? {
-            Message::Text(msg) => {
-                println!("Received text message: {}", msg);
-            },
-            Message::Binary(msg) => {
-                println!("Received binary message: {:02X?}", msg);
-            },
-            Message::Ping(msg) => {
-                println!("Received websocket ping message: {:02X?}", msg);
-            },
-            Message::Pong(msg) => {
-                println!("Received websocket pong message: {:02X?}", msg);
-            }
-            Message::Close(_) => {},
-            Message::Frame(_) => {}
-        }
-    }
-
-    Ok(())
-}
-
-fn shorten_ipv6(ip: String) -> String {
-    lazy_static!{
-        static ref LONGIPV6: Regex = Regex::new(r"(?i)^([0-9a-f]+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+:)[0-9a-f]+:[0-9a-f]+:[0-9a-f]+(:[0-9a-f]+)$").unwrap();
-    }
-    if let Some(caps) = LONGIPV6.captures(&ip) { format!("{}*{}", &caps[1], &caps[2]) }
-    else { ip }
-}
-
-// async fn handle_websocket(ws: warp::ws::WebSocket, config: Arc<RwLock<Config>>, data: Arc<Data>) {
-//     let (ws_tx, mut ws_rx) = ws.split();
-//     let (tx, rx) = sync::mpsc::unbounded_channel();
-//     let rx = tokio_stream::wrappers::UnboundedReceiverStream::new(rx);
-//     tokio::spawn(rx.forward(ws_tx));
-
-//     tokio::task::spawn(async move {
-//         while let Some(result) = ws_rx.next().await {
-//             let msg = match result {
-//                 Ok(msg) => msg,
-//                 Err(_) => break
-//             };
-//             if msg.is_close() { break; }
-//             println!("Received websocket message: {:?}", msg);
-//         }
-//     });
-// }
diff --git a/src/main.rs b/src/main.rs
index 37afa5d..0c80b1e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,5 @@
 // #![allow(dead_code, unused_imports, unused_variables, unused_mut, unreachable_patterns)] // Please be quiet, I'm coding
-use std::{ str, time::{ Duration, Instant, SystemTime, UNIX_EPOCH }, default::Default, sync::{ RwLock, atomic::AtomicBool }, error::Error, sync::Arc, convert::TryInto, collections::HashMap };
+use std::{ str, cmp, time::{ Duration, Instant, SystemTime, UNIX_EPOCH }, default::Default, sync::{ RwLock, atomic::AtomicBool }, error::Error, sync::Arc, convert::TryInto, collections::{ HashMap, VecDeque } };
 use serde::{ Deserialize, Serialize };
 use tokio::{ fs, net, sync::mpsc };
 use crypto_box::{ aead::Aead, aead::{AeadCore, generic_array::GenericArray}, PublicKey, SecretKey, SalsaBox};
@@ -9,6 +9,9 @@ use pnet_datalink::interfaces;
 use chrono::{ TimeZone, offset::Local };
 use git_version::git_version;
 use base64::{ Engine as _, engine::general_purpose::STANDARD as base64 };
+use lazy_static::lazy_static;
+use regex::Regex;
+
 
 #[cfg(feature = "web")]
 use hyper_tungstenite::tungstenite;
@@ -19,6 +22,10 @@ use termion::event::Key;
 mod control;
 mod tcp;
 mod udp;
+mod web;
+mod tui;
+
+static HISTSIZE: usize = 1440;
 
 #[derive(Serialize, Deserialize)]
 pub struct Config {
@@ -156,6 +163,98 @@ impl Protocol {
     }
 }
 
+pub struct IntfStats {
+    #[allow(dead_code)]
+    symbol: char,
+    min: u16,
+    lag: u16
+}
+
+pub struct PingResult {
+    pub node: String,
+    pub intf: String,
+    pub port: String,
+    min: u16,
+    pub losspct: f32,
+    last: Option<u16>,
+    hist: VecDeque<u16>,
+    statesince: u64 // Unix timestamp
+}
+impl PingResult {
+    fn new(node: String, intf: String, port: String) -> PingResult {
+        PingResult { node, intf, port, min: u16::MAX, losspct: 0.0, last: None, hist: VecDeque::with_capacity(HISTSIZE), statesince: unixtime() }
+    }
+    fn push_hist(&mut self, result: u16) {
+        if self.hist.len() >= HISTSIZE { self.hist.pop_back().unwrap(); }
+        self.hist.push_front(result);
+    }
+}
+impl Ord for PingResult {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        match self.node.cmp(&other.node) {
+            cmp::Ordering::Equal => {
+                match self.port.cmp(&other.port) { // TODO: better comparison for ip addresses
+                    cmp::Ordering::Equal => self.intf.cmp(&other.intf),
+                    ord => ord
+                }
+            },
+            ord => ord
+        }
+    }
+}
+impl Eq for PingResult {}
+impl PartialOrd for PingResult {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialEq for PingResult {
+    fn eq(&self, other: &Self) -> bool {
+        self.node == other.node && self.port == other.port && self.intf == other.intf
+    }
+}
+
+#[derive(Debug)]
+pub struct Path {
+    pub from: String,
+    pub to: String,
+    pub fromintf: String,
+    pub tointf: String,
+    pub losspct: u8,
+    since: u64
+}
+impl Path {
+    fn new(from: String, to: String, fromintf: String, tointf: String, losspct: u8) -> Path {
+        Path { from, to, fromintf, tointf, losspct, since: unixtime() }
+    }
+}
+impl PartialEq for Path {
+    fn eq(&self, other: &Self) -> bool {
+        self.from == other.from && self.to == other.to && self.fromintf == other.fromintf && self.tointf == other.tointf
+    }
+}
+
+#[derive(Default)]
+struct Data {
+    log: RwLock<VecDeque<(u64, String)>>,
+    ping: RwLock<VecDeque<String>>,
+    intf: RwLock<HashMap<String, IntfStats>>,
+    results: RwLock<Vec<PingResult>>,
+    pathcache: RwLock<Vec<Path>>
+}
+impl Data {
+    fn push_log(&self, ts: u64, line: String) {
+        let mut log = self.log.write().unwrap();
+        if log.len() >= 50 { log.pop_back().unwrap(); }
+        log.push_front((ts, line));
+    }
+    fn push_ping(&self, line: String) {
+        let mut ping = self.ping.write().unwrap();
+        if ping.len() >= 50 { ping.pop_back().unwrap(); }
+        ping.push_front(line);
+    }
+}
+
 const VERSION: &str = git_version!(args = ["--always", "--dirty=-modified", "--tags"]);
 // const VERSION: &str = git_version!();
 
@@ -388,6 +487,13 @@ pub fn duration_from(mut secs: u64) -> String {
     }
     result
 }
+pub fn shorten_ipv6(ip: String) -> String {
+    lazy_static!{
+        static ref LONGIPV6: Regex = Regex::new(r"(?i)^([0-9a-f]+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+:)[0-9a-f]+:[0-9a-f]+:[0-9a-f]+(:[0-9a-f]+)$").unwrap();
+    }
+    if let Some(caps) = LONGIPV6.captures(&ip) { format!("{}*{}", &caps[1], &caps[2]) }
+    else { ip }
+}
 
 fn variant_eq<T>(a: &T, b: &T) -> bool {
     std::mem::discriminant(a) == std::mem::discriminant(b)
diff --git a/src/tui.rs b/src/tui.rs
new file mode 100644
index 0000000..ed29ab8
--- /dev/null
+++ b/src/tui.rs
@@ -0,0 +1,134 @@
+#![cfg(feature = "tui")]
+use std::sync::Arc;
+use lazy_static::lazy_static;
+use termion::{ raw::IntoRawMode, screen::IntoAlternateScreen, screen::AlternateScreen, raw::RawTerminal };
+use tui::{ Terminal, Frame, backend::{ Backend, TermionBackend }, widgets::{ Block, Borders, List, ListItem, Table, Row }, layout::{ Layout, Constraint, Direction, Corner }, text::{ Span, Spans }, style::{ Style, Color } };
+use crate::{ Data, shorten_ipv6, timestamp_from };
+
+
+static THRESHOLD: u16 = 4;
+
+
+pub fn start_tui(data: Arc<Data>) -> Option<Terminal<TermionBackend<AlternateScreen<RawTerminal<std::io::Stdout>>>>> {
+    let stdout = std::io::stdout().into_raw_mode().unwrap();
+    let stdout = stdout.into_alternate_screen().unwrap();
+    let backend = TermionBackend::new(stdout);
+    let mut term = Terminal::new(backend).unwrap();
+    term.clear().unwrap();
+    term.draw(|f| draw(f, data)).unwrap();
+    Some(term)
+}
+
+pub fn draw<B: Backend>(f: &mut Frame<B>, data: Arc<Data>) {
+    let resultssize = match data.results.read().unwrap().len() { 0 => 3, n => n+2 } as u16;
+    let vert1 = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Min(12), Constraint::Length(resultssize) ].as_ref())
+        .split(f.size());
+    let hori = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Max(105), Constraint::Percentage(50)].as_ref())
+        .split(vert1[0]);
+    let vert2 = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Min(6), Constraint::Length((data.intf.read().unwrap().len()+3) as u16)].as_ref())
+        .split(hori[1]);
+
+    let block = Block::default()
+            .title(" Ping results ")
+            .borders(Borders::ALL);
+    let mut content: Vec<ListItem> = vec![];
+    for line in data.ping.read().unwrap().iter().take(hori[0].height.into()) {
+        content.push(ListItem::new(Span::from(line.clone())));
+    }
+    let list = List::new(content).block(block).start_corner(Corner::BottomLeft);
+    f.render_widget(list, hori[0]);
+
+    let block = Block::default()
+            .title(" Network log ")
+            .borders(Borders::ALL);
+    let mut content: Vec<ListItem> = vec![];
+    for (ts, line) in data.log.read().unwrap().iter().take(vert2[0].height.into()) {
+        content.push(ListItem::new(Span::from(format!("{} {}", timestamp_from(*ts), line))));
+    }
+    let list = List::new(content).block(block).start_corner(Corner::BottomLeft);
+    f.render_widget(list, vert2[0]);
+
+    let block = Block::default()
+            .title(" Local interface stats ")
+            .borders(Borders::ALL);
+    let mut content: Vec<Row> = vec![];
+    {
+        let intf = data.intf.read().unwrap();
+        let mut rows: Vec<_> = intf.iter().collect();
+        rows.sort_by(|a, b| a.1.symbol.cmp(&b.1.symbol));
+        for (intf, stats) in rows {
+            content.push(Row::new(vec![ format!(" {} ", stats.symbol), shorten_ipv6(intf.clone()), format!("{:^5}", stats.min), format!("{:^5}", stats.lag) ]));
+        }
+    }
+    let table = Table::new(content)
+        .block(block)
+        .column_spacing(1)
+        .header(Row::new(vec![ "Sym", "Interface", "Best", "Lag" ]))
+        .widths(&[Constraint::Length(3), Constraint::Length(26), Constraint::Length(5), Constraint::Length(5)]);
+    f.render_widget(table, vert2[1]);
+
+    let block = Block::default()
+        .title(" Results grid ")
+        .borders(Borders::ALL);
+    let mut content: Vec<ListItem> = vec![];
+    let mut prev = String::new();
+    let mut mark;
+    for result in data.results.read().unwrap().iter() {
+        if prev != result.node {
+            prev = result.node.clone();
+            mark = "▔";
+        }
+        else { mark = " "; }
+        let symbol = match data.intf.read().unwrap().get(&result.intf) {
+            Some(i) => i.symbol,
+            None => ' '
+        };
+        let header = format!("{:10} {:26} {} ", result.node, shorten_ipv6(result.port.to_string()), symbol);
+        let mut line = Vec::with_capacity((vert1[1].width).into());
+        line.push(Span::from(header));
+        if let Some(rtt) = result.last {
+            line.push(draw_mark(rtt, result.min, mark));
+        }
+        else { line.push(Span::raw(" ")); }
+        for rtt in result.hist.iter().take((vert1[1].width-43).into()) {
+            line.push(draw_mark(*rtt, result.min, mark));
+        }
+        content.push(ListItem::new(Spans::from(line)));
+    }
+    if content.is_empty() { content.push(ListItem::new("No results yet")); }
+    let list = List::new(content).block(block).start_corner(Corner::TopLeft);
+    f.render_widget(list, vert1[1]);
+}
+
+fn draw_mark(rtt: u16, min: u16, mark: &'static str) -> Span<'static> {
+    lazy_static!{
+        static ref STYLES: Vec<Style> = vec![
+            // Indexed colors overview: https://jonasjacek.github.io/colors/
+            Style::default().fg(Color::Black).bg(Color::Indexed(46)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(82)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(118)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(154)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(190)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(226)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(220)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(214)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(208)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(202)),
+            Style::default().fg(Color::Black).bg(Color::Indexed(196))
+        ];
+    }
+    if rtt == 0 { return Span::styled("•", Style::default().fg(Color::Black).bg(Color::Indexed(196))); }
+    if rtt == u16::MAX { return Span::raw(" "); }
+    let delaycat = match rtt-min {
+      n if n > THRESHOLD => ((n-THRESHOLD) as f32).sqrt() as usize,
+      _ => 0
+    };
+    if delaycat < STYLES.len() { return Span::styled(mark, STYLES[delaycat]); }
+    return Span::styled("^", (*STYLES.last().unwrap()).fg(Color::Black));
+}
diff --git a/src/web.rs b/src/web.rs
new file mode 100644
index 0000000..a6e99e3
--- /dev/null
+++ b/src/web.rs
@@ -0,0 +1,277 @@
+#![cfg(feature = "web")]
+use std::sync::{ Arc, RwLock, atomic::Ordering };
+use tokio::sync;
+use http_body_util::Full;
+use hyper::{ Request, Response, body::{ Bytes, Incoming }, service::service_fn };
+use hyper_util::rt::TokioIo;
+use hyper_tungstenite::{HyperWebsocket, tungstenite::Message};
+use tokio_stream::wrappers::TcpListenerStream;
+use futures_util::stream::StreamExt;
+use rustls_acme::{ AcmeConfig, AccountCache, CertCache };
+use serde::Serialize;
+use tokio::net::TcpListener;
+use ring::digest::{ Context, SHA256 };
+use async_trait::async_trait;
+use base64::{ Engine as _, engine::general_purpose::STANDARD as base64 };
+
+use crate::{ Config, Control, Data, LogLevel };
+
+
+static INDEX_FILE: &str = include_str!("../web/index.html");
+static ICON_FILE: &[u8] = include_bytes!("../web/favicon.ico");
+
+struct ConfigCache {
+    config: Arc<RwLock<Config>>
+}
+impl ConfigCache {
+    fn new(config: &Arc<RwLock<Config>>) -> ConfigCache {
+        ConfigCache {
+            config: config.clone()
+        }
+    }
+    fn cached_account_key(&self, contact: &[String], directory_url: impl AsRef<str>) -> String {
+        let mut ctx = Context::new(&SHA256);
+        for el in contact {
+            ctx.update(el.as_ref());
+            ctx.update(&[0])
+        }
+        ctx.update(directory_url.as_ref().as_bytes());
+        let hash = base64.encode(ctx.finish());
+        format!("cached_account_{}", hash)
+    }
+    fn cached_cert_key(&self, domains: &[String], directory_url: impl AsRef<str>) -> String {
+        let mut ctx = Context::new(&SHA256);
+        for domain in domains {
+            ctx.update(domain.as_ref());
+            ctx.update(&[0])
+        }
+        ctx.update(directory_url.as_ref().as_bytes());
+        let hash = base64.encode(ctx.finish());
+        format!("cached_cert_{}", hash)
+    }
+}
+
+#[async_trait]
+#[cfg(feature = "web")]
+impl CertCache for ConfigCache {
+    type EC = std::io::Error;
+    async fn load_cert(
+        &self,
+        domains: &[String],
+        directory_url: &str,
+    ) -> Result<Option<Vec<u8>>, Self::EC> {
+        let key = self.cached_cert_key(&domains, directory_url);
+        Ok(self.config.read().unwrap().cache.get(&key).map(|v| base64.decode(v).unwrap()))
+    }
+    async fn store_cert(
+        &self,
+        domains: &[String],
+        directory_url: &str,
+        cert: &[u8],
+    ) -> Result<(), Self::EC> {
+        let key = self.cached_cert_key(&domains, directory_url);
+        let mut config = self.config.write().unwrap();
+        config.cache.insert(key, base64.encode(cert));
+        config.modified.store(true, Ordering::Relaxed);
+        Ok(())
+    }
+}
+#[async_trait]
+#[cfg(feature = "web")]
+impl AccountCache for ConfigCache {
+    type EA = std::io::Error;
+    async fn load_account(
+        &self,
+        contact: &[String],
+        directory_url: &str,
+    ) -> Result<Option<Vec<u8>>, Self::EA> {
+        let key = self.cached_account_key(&contact, directory_url);
+        Ok(self.config.read().unwrap().cache.get(&key).map(|v| base64.decode(v).unwrap()))
+    }
+
+    async fn store_account(
+        &self,
+        contact: &[String],
+        directory_url: &str,
+        account: &[u8],
+    ) -> Result<(), Self::EA> {
+        let key = self.cached_account_key(&contact, directory_url);
+        let mut config = self.config.write().unwrap();
+        config.cache.insert(key, base64.encode(account));
+        config.modified.store(true, Ordering::Relaxed);
+        Ok(())
+    }
+}
+
+pub fn run_http(config: Arc<RwLock<Config>>, data: Arc<Data>, ctrltx: sync::mpsc::Sender<Control>, arg: String, debug: bool) {
+    tokio::spawn(async move {
+        let http = hyper::server::conn::http1::Builder::new();
+        let service = service_fn(move |req| {
+            // if debug { println!("{} Received HTTP request {} {}", timestamp(), req.method(), req.uri()); }
+            handle_http(req, config.clone(), data.clone())
+        });
+        let tcp_listener = match TcpListener::bind(&arg).await {
+            Ok(x) => x,
+            Err(e) => {
+                ctrltx.send(Control::Log(LogLevel::Error, format!("Failed to start http server on {arg}: {e}"))).await.unwrap();
+                return;
+            }
+        };
+        ctrltx.send(Control::Log(LogLevel::Info, format!("Started HTTP server on {}", arg))).await.unwrap();
+        while let Ok((stream, addr)) = tcp_listener.accept().await {
+            if debug { ctrltx.send(Control::Log(LogLevel::Debug, format!("Incoming HTTP connection from {}", addr))).await.unwrap(); }
+            let conn = http.serve_connection(TokioIo::new(stream), service.clone()).with_upgrades();
+            if let Err(e) = tokio::spawn(async move { conn.await }).await {
+                ctrltx.send(Control::Log(LogLevel::Error, format!("Error: {e}"))).await.unwrap();
+            }
+        }
+    });
+}
+
+pub fn run_https(config: Arc<RwLock<Config>>, data: Arc<Data>, ctrltx: sync::mpsc::Sender<Control>, arg: String, letsencrypt: Option<String>, debug: bool) {
+    tokio::spawn(async move {
+        let http = hyper::server::conn::http1::Builder::new();
+        let aconfig = config.clone();
+        let service = service_fn(move |req| {
+            // if debug { println!("{} Received HTTPS request {} {}", timestamp(), req.method(), req.uri()); }
+            handle_http(req, aconfig.clone(), data.clone())
+        });
+        let tcp_listener = match TcpListener::bind(&arg).await {
+            Ok(x) => x,
+            Err(e) => {
+                ctrltx.send(Control::Log(LogLevel::Error, format!("Failed to start https server on {arg}: {e}"))).await.unwrap();
+                return;
+            }
+        };
+        let domain = arg.rsplit_once(':').expect("No colon found in --https argument").0;
+        if domain.contains(':') || domain.find(char::is_alphabetic).is_none() {
+            ctrltx.send(Control::Log(LogLevel::Error, format!("Cannot use bare IP address with --https; use a fully qualified domain name"))).await.unwrap();
+            return;
+        }
+        let tcp_incoming = TcpListenerStream::new(tcp_listener);
+        let mut tls_incoming = AcmeConfig::new([ &domain ])
+            .contact_push(format!("mailto:{}", letsencrypt.unwrap()))
+            .cache(ConfigCache::new(&config))
+            .directory_lets_encrypt(true)
+            .tokio_incoming(tcp_incoming, Vec::new());
+        ctrltx.send(Control::Log(LogLevel::Info, format!("Started HTTPS server on {}", arg))).await.unwrap();
+        while let Some(tls) = tls_incoming.next().await {
+            let stream = tls.unwrap();
+            if debug { ctrltx.send(Control::Log(LogLevel::Debug, format!("Incoming HTTPS connection from {}", stream.get_ref().get_ref().0.get_ref().peer_addr().unwrap_or("0.0.0.0:0".parse().unwrap())))).await.unwrap(); }
+            let conn = http.serve_connection(TokioIo::new(stream), service.clone()).with_upgrades();
+            if let Err(e) = tokio::spawn(async move { conn.await }).await {
+                ctrltx.send(Control::Log(LogLevel::Error, format!("Error: {e}"))).await.unwrap();
+            }
+        }
+    });
+}
+
+pub async fn handle_http(mut request: Request<Incoming>, config: Arc<RwLock<Config>>, data: Arc<Data>) -> Result<Response<Full<Bytes>>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    if hyper_tungstenite::is_upgrade_request(&request) {
+        let (response, websocket) = hyper_tungstenite::upgrade(&mut request, None)?;
+        tokio::spawn(async move {
+            let _ = handle_websocket(websocket, config, data).await;
+        });
+        Ok(response)
+    } else {
+        match request.uri().path() {
+            "/" => Ok(Response::new(Full::<Bytes>::from(INDEX_FILE))),
+            "/favicon.ico" => Ok(Response::new(Full::<Bytes>::from(ICON_FILE))),
+            _ => Ok(Response::builder().status(hyper::StatusCode::NOT_FOUND).body(Full::<Bytes>::from("")).unwrap())
+        }
+    }
+
+}
+
+pub async fn handle_websocket(ws: HyperWebsocket, config: Arc<RwLock<Config>>, data: Arc<Data>) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    #[derive(Default, Serialize)]
+    struct JsonGraph {
+        msg: &'static str,
+        nodes: Vec<JsonNode>,
+        edges: Vec<JsonEdge>,
+        paths: Vec<JsonPath>,
+        log: Vec<JsonLog>
+    }
+    #[derive(Serialize)]
+    struct JsonNode {
+        name: String
+    }
+    #[derive(Serialize)]
+    struct JsonEdge {
+        from: String,
+        to: String,
+        mode: &'static str
+    }
+    #[derive(Serialize)]
+    struct JsonPath {
+        fromname: String,
+        fromintf: String,
+        toname: String,
+        tointf: String,
+        losspct: u8
+    }
+    #[derive(Serialize)]
+    struct JsonLog {
+        ts: u64,
+        text: String
+    }
+
+    let (ws_tx, mut ws_rx) = ws.await?.split();
+    let (tx, rx) = sync::mpsc::unbounded_channel();
+    let rx = tokio_stream::wrappers::UnboundedReceiverStream::new(rx);
+    tokio::spawn(rx.forward(ws_tx));
+
+    let mut res = JsonGraph { msg: "init", ..Default::default() };
+    {
+        let config = config.read().unwrap();
+        let mut runtime = config.runtime.write().unwrap();
+        runtime.wsclients.push(tx.clone());
+
+        let nodes = runtime.graph.raw_nodes();
+        for node in nodes.iter() {
+            res.nodes.push(JsonNode { name: node.weight.clone() });
+        }
+        for edge in runtime.graph.raw_edges() {
+            let mode = match runtime.msp.contains_edge(edge.source(), edge.target()) {
+                true => "active",
+                false => "standby"
+            };
+            res.edges.push(JsonEdge { from: runtime.graph[edge.source()].clone(), to: runtime.graph[edge.target()].clone(), mode });
+        }
+        drop(runtime);
+        let log = data.log.read().unwrap();
+        for (ts, msg) in log.iter().rev() {
+            res.log.push(JsonLog { ts: *ts, text: msg.clone() });
+        }
+        let results = data.results.read().unwrap();
+        for result in results.iter() {
+            res.paths.push(JsonPath { fromname: config.name.clone(), fromintf: result.intf.clone(), toname: result.node.clone(), tointf: result.port.clone(), losspct: result.losspct.round() as u8 });
+        }
+        let pathcache = data.pathcache.read().unwrap();
+        for path in pathcache.iter() {
+            res.paths.push(JsonPath { fromname: path.from.clone(), fromintf: path.fromintf.clone(), toname: path.to.clone(), tointf: path.tointf.clone(), losspct: path.losspct });
+        }
+    }
+    tx.send(Ok(Message::text(serde_json::to_string(&res).unwrap())))?;
+
+    while let Some(message) = ws_rx.next().await {
+        match message? {
+            Message::Text(msg) => {
+                println!("Received text message: {}", msg);
+            },
+            Message::Binary(msg) => {
+                println!("Received binary message: {:02X?}", msg);
+            },
+            Message::Ping(msg) => {
+                println!("Received websocket ping message: {:02X?}", msg);
+            },
+            Message::Pong(msg) => {
+                println!("Received websocket pong message: {:02X?}", msg);
+            }
+            Message::Close(_) => {},
+            Message::Frame(_) => {}
+        }
+    }
+
+    Ok(())
+}