Simple TCP server

[simao]

Hello,

I am trying to start a TCP listener using the following code:

use std::rt::io::net::tcp::TcpListener;
use std::rt::io::{Reader, Writer, Listener, Acceptor};
use std::rt::io::net::ip::{SocketAddr, Ipv4Addr};
use std::vec;
use std::str;

fn main() {
    let addr = SocketAddr {
        ip: Ipv4Addr(0, 0, 0, 0),
        port: 9090
    };

    let mut acceptor = TcpListener::bind(addr).listen().unwrap();

    println("Listener is ready");

    loop {
        let mut stream = acceptor.accept().unwrap();
        let mut buf = vec::from_elem(1, 0u8); // Use just 1 byte to debug

        loop {
            match stream.read(buf) {
                Some(count) => {
                    if count > 0 {
                        print(str::from_utf8(buf));
                    } else {
                        println("GOT NOTHING");
                        break;
                    }
                }
                None => { println("Finished"); break }
            }
        }

        stream.write(bytes!("Hello World\r\n"));

        //        println(str::from_utf8(buf));

    }
}

So the problem here is that after the server reads all the data from
the client and then it blocks on the next read waiting for more
data, while the client, in this case curl will not send any more
data.

I tried to use stream.eof but this function is not implemented and
just throws an exception.

What is the recommended way to do this while stream.eof is not
implemented?

Thank you

[bmaxa]

Here is example of simple TCP server that will give you idea how to write
yours. Server spawns lightweight thread on new connection
and handles read/write in there so you could handle xxx connections
simultaneously. Eof is when stream.read() functions return None.
This server closes connection after single read, so you can
test eg with a(pache)b(ench) or something.

use std::rt::io::net::tcp::TcpListener;
use std::rt::io::{Reader, Writer, Listener, Acceptor};
use std::rt::io::net::ip::{SocketAddr, Ipv4Addr};
use std::str;
use std::cell::Cell;

fn main() {
    let addr = SocketAddr {
        ip: Ipv4Addr(0, 0, 0, 0),
        port: 9090
    };

    let mut acceptor = TcpListener::bind(addr).listen().unwrap();

    println("Listener is ready");

    loop {
        let stream = acceptor.accept().unwrap();
        let stream = Cell::new(stream);
        do spawn{
            let mut buf = [0,..512];
            let mut stream = stream.take();
            loop {
                match stream.read(buf) {
                    Some(count) => {
                        print("read "+count.to_str()+" bytes: "+str::from_utf8(buf));
                        stream.write(bytes!("Hello World\r\n"));
                        break; // close connection after read
                    }
                    None => { println("Finished"); break } // connection is closed by client
                }
            }

        }

    }
}

[simao]

Hello,

This code has the same problem as mine.

If you change the size of the buffer to a small value, like [0,..1], emulating a big request from the client, the server needs to loop in order to call .read multiple times before closing the connection.

On the last .read, when the client already sent the complete request, the server will block forever waiting for more data from the client, and never close the connection. This could be avoided if we could call .eof before calling .read again, but .eof is not yet implemented in tcp.rs.

Thanks!

[bmaxa]

Eof will not help, as it will never trigger if client does not closes connection (and we know
already if client closes, read returns None).
So problem is that you have to know when to stop reading and start writing,
and that's a matter of protocol.

[simao]

Ah I see! Thank you for your help!

[alexcrichton]

Closing because I agree that this is a protocol thing and not a rt::io thing.