rax25 0.1.22

AX.25 connected mode implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Example server using the synchronous API.
use std::io::Write;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};

use anyhow::Result;
use clap::Parser;
use log::debug;

use rax25::sync::Client;
use rax25::{Addr, BusHub, BusKiss};

#[derive(Parser, Debug)]
struct Opt {
    #[clap(short = 'p', default_value = "/dev/null")]
    port: String,

    #[clap(short = 's')]
    src: String,

    #[clap(short = 'r')]
    cr: bool,

    #[clap(short = 'e')]
    ext: bool,

    #[clap(short = 'v', default_value = "0")]
    v: usize,
}

fn main() -> Result<()> {
    let opt = Opt::parse();
    let done = Arc::new(AtomicBool::new(false));
    stderrlog::new()
        .module("rax25")
        .verbosity(opt.v)
        .init()
        .unwrap();
    let bus = Arc::new(Mutex::new(bus::Bus::<rax25::BusMessage>::new(10)));
    let mut bk = BusKiss::new(&opt.port, bus.clone())?;
    std::thread::spawn(move || {
        bk.run();
    });
    let k = BusHub::new(bus);
    let mut listener = Client::new(Addr::new(&opt.src)?, Box::new(k));

    let d = done.clone();
    ctrlc::set_handler(move || {
        println!("Received SIGINT signal, shutting down...");
        d.store(true, Ordering::SeqCst);
    })
    .expect("Error setting Ctrl-C handler");

    eprintln!("==== Awaiting connection");
    let mut c = listener
        .accept(std::time::Instant::now() + std::time::Duration::from_secs(60))?
        .expect("connection timeout");
    drop(listener);
    eprintln!("==== Connected");
    c.write("You are connected!\n".as_bytes())?; // TODO: cr
    while !done.load(Ordering::SeqCst) && !c.eof() {
        match c.read_until(done.clone()) {
            Ok(Some(data)) => {
                // eprintln!("====> {data:?}");
                let s = match String::from_utf8(data.clone()) {
                    Ok(s) => s,
                    Err(_) => String::from_utf8(data.iter().map(|&b| b & 0x7F).collect())?,
                };
                println!("Got data: {s}");
                std::io::stdout().flush()?;
                let reply = format!("Got <{s}>\n");
                let reply = if opt.cr {
                    reply.replace("\r", "\n")
                } else {
                    reply
                };
                c.write(reply.as_bytes())?;
            }
            Ok(None) => break,
            Err(e) => {
                if false {
                    // probably timeout
                    debug!("Error reading: {e:?}");
                }
            }
        }
    }
    eprintln!("Main loop exit");

    // TODO: wait only until the outgoing packets have all been
    // sent, namely UA.
    std::thread::sleep(std::time::Duration::from_secs(1));
    done.store(true, Ordering::SeqCst);
    Ok(())
}