How do I read a single packet from TcpStream using Tokio? - rust

Question

I'm trying to receive a single data packet using tokio:
extern crate tokio;
extern crate tokio_io;
use tokio::net::{TcpListener};
use tokio::prelude::*;
use std::net::SocketAddr;
fn main() {
let addr = "0.0.0.0:8080".parse::<SocketAddr>().unwrap();
let socket = TcpListener::bind(&addr).unwrap();
println!("Listening on: {}", addr);
let done = socket
.incoming()
.map_err(|e| println!("failed to accept socket; error = {:?}", e))
.for_each(move |mut socket| {
let mut bytes = vec![];
bytes.reserve(1024);
let processor = socket.read_buf(&mut bytes).into_future()
.and_then(move |_size| {
println!("bytes: {:?}", bytes);
Ok(())
})
.map_err(|_| ());;
tokio::spawn(processor)
});
tokio::run(done);
}
This code prints an empty packet. How do I change this code to print the received packet with data?

Answer 1

For myself, I almost found the answer. Very helpful Similar question.
struct AsWeGetIt<R>(R);
impl<R> Stream for AsWeGetIt<R>
where
R: AsyncRead,
{
type Item = BytesMut;
type Error = std::io::Error;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
let mut buf = BytesMut::with_capacity(1000);
self.0
.read_buf(&mut buf)
.map(|async| async.map(|_| Some(buf)))
}
}
....
let processor = AsWeGetIt(socket).into_future()
.and_then(|(bytes,_)| {
println!("bytes: {:?}", bytes);
Ok(())
}).map_err(|_| ());
But for a better understanding how to do without a separate structure ...
And why and what is the map using?

Answer 2

If your goal is really to receive one packet, I think you've succeeded!
I've tested the program a few times, and I get a response. I'm testing with:
nc 127.0.0.1 8080 <<< hello
After running that a few times, I get the following output:
Listening on: 0.0.0.0:8080
bytes: [104, 101, 108, 108, 111, 10]
bytes: []
bytes: [104, 101, 108, 108, 111, 10]
bytes: []
bytes: [104, 101, 108, 108, 111, 10]
bytes: []
bytes: [104, 101, 108, 108, 111, 10]
bytes: [104, 101, 108, 108, 111, 10]
As you can see, sometimes we have data ready, and sometimes we don't. I think in your testing you've just been unlucky and only gotten TCP responses before any data has been sent?
I'm about 90% sure that TCP streams can include empty packets, and this is what we're seeing. (if someone has more knowledge here, feel free to edit the answer or comment).
To fix your program you might want to reconsider your goal.
Reading one TCP packet seems rarely helpful. Instead, generally, you want to read some amount of bytes and process the data as it comes. My understanding of TCP is as a stream of bytes, not really a stream of packets. The packets are just a way to get bytes from one place to another, and they could be any length without breaking compatibility. "One packet" is a fairly nebulous concept.
Here's an example reading the first 16 bytes of the stream using the tokio::io::read_exact function:
extern crate tokio;
use tokio::net::TcpListener;
use tokio::prelude::*;
use std::net::SocketAddr;
fn main() {
let addr = "0.0.0.0:8080".parse::<SocketAddr>().unwrap();
let socket = TcpListener::bind(&addr).unwrap();
println!("Listening on: {}", addr);
let done = socket
.incoming()
.map_err(|e| println!("failed to accept socket; error = {:?}", e))
.for_each(move |mut socket| {
// this function deals with bytes a bit differently and will just fill the
// buffer exactly rather than adding onto the end.
let mut bytes = vec![0; 16];
let processor = tokio::io::read_exact(socket, bytes)
.and_then(move |(socket, bytes)| {
println!("bytes: {:?}", bytes);
Ok(())
})
.map_err(|_| ());
tokio::spawn(processor)
});
tokio::run(done);
}