117 lines
3.4 KiB
Rust
117 lines
3.4 KiB
Rust
mod db;
|
|
mod parser;
|
|
|
|
use crate::db::*;
|
|
use crate::parser::*;
|
|
|
|
use std::io;
|
|
|
|
use tokio::net::TcpListener;
|
|
|
|
const ADDR: &'static str = "0.0.0.0:7700";
|
|
const BUFSIZE: usize = 1024;
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
//test();
|
|
let conn = connectdb().unwrap();
|
|
initdb(&conn).unwrap();
|
|
apiserver().await.unwrap();
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn test() {
|
|
use bcd_convert::BcdNumber;
|
|
let data: Vec<u8> = vec![0x36, 0x31, 0x33, 0x32, 0x31, 0x31, 0x38];
|
|
let code = BcdNumber::try_from(&data as &[u8]).unwrap();
|
|
println!("{code}");
|
|
std::process::exit(0);
|
|
}
|
|
|
|
async fn apiserver() -> io::Result<()> {
|
|
let listener = match TcpListener::bind(ADDR).await {
|
|
Ok(o) => o,
|
|
Err(e) => {
|
|
println!("error: {e}");
|
|
std::process::exit(1);
|
|
}
|
|
};
|
|
|
|
loop {
|
|
let (socket, _remote_addr) = listener.accept().await?;
|
|
tokio::spawn(async move {
|
|
let mut buf = vec![0; BUFSIZE];
|
|
loop {
|
|
let mut terminal_id = 0;
|
|
match socket.readable().await {
|
|
Ok(_) => {
|
|
match socket.try_read(&mut buf) {
|
|
Ok(_) => match handle(&buf) {
|
|
Some(o) => match socket.try_write(&o) {
|
|
Ok(_) => {}
|
|
Err(ref e) if e.kind() == io::ErrorKind::BrokenPipe => {
|
|
println!("broken pipe: {e}");
|
|
break;
|
|
}
|
|
Err(e) => {
|
|
println!("error: {e}");
|
|
break;
|
|
}
|
|
},
|
|
None => {
|
|
break;
|
|
}
|
|
},
|
|
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
|
|
continue;
|
|
}
|
|
Err(e) => {
|
|
println!("error read: {e}");
|
|
}
|
|
};
|
|
}
|
|
Err(e) => {
|
|
println!("error socket readable: {e}");
|
|
}
|
|
}
|
|
match socket.writable().await {
|
|
Ok(_) => {
|
|
let msg = Message::default();
|
|
}
|
|
Err(e) => {
|
|
println!("error socket writable: {e}")
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
fn handle(buf: &Vec<u8>) -> Option<Vec<u8>> {
|
|
let mut rawdata = InboundDataWrapper::new(buf.to_vec());
|
|
let reply = match parse_inbound_msg(&mut rawdata) {
|
|
Ok(o) => {
|
|
println!("query: {}", o);
|
|
//println!("raw query: {:X?}", o.to_raw());
|
|
Message::store(&o);
|
|
Message::set_reply(o)
|
|
}
|
|
Err(e) => {
|
|
println!("parse inbound message error: {}", e);
|
|
return None;
|
|
}
|
|
};
|
|
|
|
match reply {
|
|
Some(o) => {
|
|
println!("reply: {}", o);
|
|
//println!("raw reply {:X?}", o.to_raw());
|
|
println!("--------------");
|
|
return Some(o.to_raw().into());
|
|
}
|
|
None => {
|
|
return None;
|
|
}
|
|
}
|
|
}
|