`Request::remote_addr()` is always `None` in server

[ensc]

Since 0.11.11 (0.11.10 is ok), the address returned by Request::remote_addr() is always None. Code is like

impl <'a> Service for HttpService<'a> {
    fn call(&self, req: Request) -> Self::Future {
        let addr = req.remote_addr();
        let file = self.env.new_file(path, &addr.unwrap().ip());    // <<<< panics here since 0.11.11

[seanmonstar]

You're right, I forgot about this method. I'll add it back to prevent breaking people, but remote_addr will also be deprecated.

[moderation]

@seanmonstar with remote_addr being removed is there an alternative method or is the capability being removed all together?

[seanmonstar]

The remote address likely won't be part of the Request any other way. However, each Service is created per connection, so the address can be stored in a Service. That should be trivial if managing a TcpListener yourself, but a way to access it when using Http::bind doesn't really exist, and could be explored.

[oa-metaswitch]

+1 for getting some way to access the TcpListener. I'm currently relying on getting access to the remote address, and it would be a shame to have to manage the transport layer manually. Particularly now that support for tokio_proto is going away.

[jedisct1]

+1

[klausi]

My current approach to pass down the IP address to my service (a proxy server use case):

let address: SocketAddr = ([127, 0, 0, 1], port).into();
let mut core = Core::new().unwrap();
let handle = core.handle();

// We can't use Http::new().bind() because we need to pass down the
// remote source IP address to our proxy service. So we need to
// create a TCP listener ourselves and handle each connection to
// have access to the source IP address.
// @todo Simplify this once Hyper has a better API to handle IP
// addresses.
let listener = TcpListener::bind(&address, &handle)
    .chain_err(|| format!("Failed to bind server to address {}", address))?;
let client = Client::new(&handle);
let mut http = Http::<hyper::Chunk>::new();
// Let Hyper swallow IO errors internally to keep the server always
// running.
http.sleep_on_errors(true);

let server = listener.incoming().for_each(move |(socket, source_address)| {
    handle.spawn(
        http.serve_connection(socket, Proxy {
                port,
                upstream_port,
                client: client.clone(),
                source_address,
            })
            .map(|_| ())
            .map_err(|_| ())
    );
    Ok(())
});

println!("Listening on http://{}", address);
core.run(server).chain_err(|| "Tokio core run error")?;
bail!("The Tokio core run ended unexpectedly");

Full source: https://github.com/klausi/rustnish/blob/goal-09/src/lib.rs

[ensc]

@klausi I do not know how, but Http::bind() seems to workaround the 'static lifetime requirements of the inner function while they still exist when calling handel.spawn() manually. E.g. I tried to write this code but failed to implement bar().

[seanmonstar]

If there's interest in getting this information even when hyper manages the listener, we could open a new issue about that. This related comment about an API in the client seems relevant.

[stevedonovan]

With 0.12, @klausi workaround no longer compiles. Anything further on this issue? It becomes important when providing a webhook for little devices that don't bother to fill in referer.

[klausi]

@stevedonovan my TCPListener workaround still works with Hyper 0.12:

let address: SocketAddr = ([127, 0, 0, 1], port).into();
let mut runtime = Runtime::new().unwrap();

let listener = TcpListener::bind(&address)
    .chain_err(|| format!("Failed to bind server to address {}", address))?;
let client = Client::new();
let http = Http::new();

let server = listener
    .incoming()
    .for_each(move |socket| {
        let source_address = socket.peer_addr().unwrap();
        tokio::spawn(
            http.serve_connection(
                socket,
                Proxy {
                    port,
                    upstream_port,
                    client: client.clone(),
                    source_address,
                },
            ).map(|_| ())
            .map_err(|_| ()),
        );
        Ok(())
    }).map_err(|e| panic!("accept error: {}", e));

println!("Listening on http://{}", address);
runtime.spawn(server);

[klausi]

Ah, just found the usual DoS security weakness again with my code from above. If your server needs to handle many requests and runs out of file descriptors then the code from above will panic and your server will exit and stop.

I wrote about this before and Hyper even has a protection against this built in now - but if you are constructing your TCP listener manually then you are on your own again :-(