add server::AsyncAcceptor with take_io function

[jacott]

This is a handle on a server-side connection before configuration is available. This is a replacement for LazyConfigAcceptor which has no way to retrieve the client IO stream after an error.

AsyncAcceptor has a function take_io which can be used take back ownership of the client IO stream.

An example of this is when a client tries to connect to an TLS socket expecting it to be plain text connection. In this case take_io can be used to send a 400 response, "The plain HTTP request was sent to HTTPS port", back to the client.

The reason for a new struct is not break the API of LazyConfigAcceptor.

[djc]

I don't see why we can't add a take_io() method to the LazyConfigAcceptor? I don't think adding a new type is the right direction here.

[jacott]

I didn't know how to deal with fact that the new function works like an async function. I guess I can add a take_io method even so? I didn't try that (I'm a brand new rust programmer).

[jacott]

I just gave it a go but the problem is that the acceptor.await takes ownership of acceptor so I can't call the take_io method 🤔

[quininer]

You can try

tokio::pin!(acceptor);
let ret = futures::future::poll_fn(|cx| acceptor.as_mut().poll(cx)).await;

[jacott]

That worked! I didn't need to call poll_fn

           let mut acceptor = LazyConfigAcceptor::new(rustls::server::Acceptor::default(), stream);
            pin_mut!(acceptor);

            match acceptor.as_mut().await {
            ...
                Err(err) => {
                    if let Some(mut stream) = acceptor.take_io() {
                        stream
                            .write_all(
                                format!("HTTP/1.1 500 Internal Server Error\r\n\r\n\r\n{:?}\n", err) /*        */
                                    .as_bytes(),
                            )
                            .await
                            .unwrap();
                    }
                }

            }

I'll close this and make another PR.