xum1541 0.3.2

Rust driver to access Commodore disk drives using xum1541 USB device
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

//! This is a complete implementation of an xum1541 network server, exposing
//! the xum1541 primitives over IP.
//!
//! It creates the [`UsbDevice`] locally, and accepts and serves up to one
//! connection from remote peers.  Theoretically it would be possible to serve
//! multiple peers, but this would probably require some kind of locking to
//! prevent the peers from interfering with each other's operations.
//!
//! The server listens on the default address and port, which can be
//! overridden.
//!
//! Once a remote peer has connected, no other connections will be accepted
//! until the remote peer disconnects.
//!
//! If any unexpected errors - such as pipes breaking, network errors, etc,
//! this server will exit.
//!
//! All logging is done to stdout and can be controlled via the `RUST_LOG`
//! environment variable.
//!
//! It is expected that in a production environment, this server would be
//! run as a service, and would be managed by a process manager such as
//! systemd, upstart, or supervisord.
use xum1541::device::remoteusb::DEFAULT_PORT;
use xum1541::{Device, Error, UsbDevice, UsbDeviceServer};

#[allow(unused_imports)]
use log::{debug, error, info, trace, warn};
use std::net::{IpAddr, SocketAddr};
use std::str::FromStr;

fn execute() -> Result<(), Error> {
    info!("Create USB Device");
    let device = UsbDevice::new(None)?;

    let addr = "0.0.0.0";
    info!(
        "Create Remote USB Device to listen on {}:{}",
        addr, DEFAULT_PORT
    );
    let ip_addr = IpAddr::from_str(addr).map_err(|e| Error::Args {
        message: format!("Failed to parse address: {e}"),
    })?;
    let bind_addr = SocketAddr::new(ip_addr, DEFAULT_PORT);
    let mut device = UsbDeviceServer::new(device, bind_addr)?;

    info!("Server: Listen for remote connection");
    let result = device.serve();

    info!("Exiting server");

    result
}

fn main() {
    env_logger::builder().init();

    match execute() {
        Ok(()) => std::process::exit(0),
        Err(e) => {
            error!("Error: {e}");
            std::process::exit(1);
        }
    }
}