portspoof-ng/src/main.rs

extern crate mio;
#[macro_use]
extern crate log;

use std::io::Write;
//use std::net::SocketAddr;
use mio::*;
use mio::tcp::TcpListener;
use log::*;


const LISTENADDR : &'static str = "127.0.0.1:13265";


struct StderrLogger;
impl StderrLogger {
    fn init() -> Result<(), SetLoggerError> {
        log::set_logger(|max_log_level| {
            max_log_level.set(LogLevelFilter::Info);
            Box::new(StderrLogger)
        })
    }
}

impl log::Log for StderrLogger {
    fn enabled(&self, metadata: &LogMetadata) -> bool {
        metadata.level() <= LogLevel::Info
    }

    fn log(&self, record: &LogRecord) {
        if self.enabled(record.metadata()) {
            writeln!(&mut std::io::stderr(), "{} {}", record.level(), record.args()).
                expect("Can't log.")
        }
    }
}


fn malformed_packet(err: std::io::Error) {
    info!("Somebody sent an invalid tcp packet: {}", err.to_string());
}

fn handle(mut stream: tcp::TcpStream) {
    let _ = stream.write(&"go fuck you kthxbye".as_bytes());
    let _ = stream.local_addr()
        .map(|addr|
             info!("somebody opened a tcp connection to {}:{}", addr.ip(), addr.port()))
        .map_err(malformed_packet);
}

fn main() {
    StderrLogger::init().expect("can't set up logger.");

    info!("Starting up!");


    // Setup some tokens to allow us to identify which event is
    // for which socket.
    const SERVER: Token = Token(0);

    // Setup the server socket
    let addr = LISTENADDR.parse().unwrap();
    let server = TcpListener::bind(&addr)
        .expect(&format!("Can't bind to address {}", LISTENADDR));

    // Create an poll instance
    let poll = Poll::new().unwrap();

    // Start listening for incoming connections
    poll.register(&server, SERVER, Ready::all(), PollOpt::edge())
        .expect("Cannot register server");


    // Create storage for events
    let mut events = Events::with_capacity(1024);

    loop {
        poll.poll(&mut events, None).unwrap();

        for event in events.iter() {
            match (event.token(), event.kind().is_readable()) {
                (SERVER, true) => {
                    let (stream, _) = server.accept().unwrap();
                    handle(stream);
                }

                _ => {
                    info!("something happened: {:?}", event.kind());
                    // unreachable!(),
                }
            }
        }
    }
}