Initial commit.

.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*.rs]
+indent_style = space
+indent_size = 4

.gitignore

@@ -0,0 +1,8 @@
+# Rust stuff
+/target
+/Cargo.lock
+
+# Misc stuff
+.*
+!.editorconfig
+!.gitignore

Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "boitalettres"
+version = "0.0.1"
+license = "BSD-3-Clause"
+edition = "2021"
+
+[dependencies]
+bytes = "1.1"
+thiserror = "1.0"
+tracing = "0.1"
+
+# IMAP
+imap-codec = "0.5"
+
+# Async
+async-compat = "0.2"
+futures = "0.3"
+pin-project = "1.0"
+tokio = { version = "1.18", features = ["full"] }
+tokio-tower = "0.6"
+tower = { version = "0.4", features = ["full"] }
+
+[dev-dependencies]
+eyre = "0.6"
+tracing-subscriber = "0.3"

LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2022 KokaKiwi <kokakiwi@deuxfleurs.fr>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the author nor the names of its contributors may
+   be used to endorse or promote products derived from this software
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

examples/simple.rs

@@ -0,0 +1,32 @@
+use boitalettres::proto::{Request, Response};
+use boitalettres::server::accept::addr::{AddrIncoming, AddrStream};
+use boitalettres::server::Server;
+
+async fn handle_req(req: Request) -> eyre::Result<Response> {
+    use imap_codec::types::response::Status;
+
+    tracing::debug!("Got request: {:#?}", req);
+
+    Ok(Response::Status(
+        Status::ok(Some(req.tag), None, "Ok").map_err(|e| eyre::eyre!(e))?,
+    ))
+}
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::TRACE)
+        .init();
+
+    let incoming = AddrIncoming::new("127.0.0.1:4567").await?;
+
+    let make_service = tower::service_fn(|addr: &AddrStream| {
+        tracing::debug!("Accept: {} -> {}", addr.remote_addr, addr.local_addr);
+        futures::future::ok::<_, std::convert::Infallible>(tower::service_fn(handle_req))
+    });
+
+    let server = Server::new(incoming).serve(make_service);
+    let _ = server.await;
+
+    Ok(())
+}

rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+components = ["rustc-dev", "rust-src"]

scripts/test_imap.py

@@ -0,0 +1,7 @@
+#!/usr/bin/python
+from imaplib import IMAP4
+
+conn = IMAP4('127.0.0.1', port=4567)
+conn.noop()
+
+conn.logout()

src/lib.rs

@@ -0,0 +1,2 @@
+pub mod proto;
+pub mod server;

src/proto/mod.rs

@@ -0,0 +1,5 @@
+pub use self::req::Request;
+pub use self::res::Response;
+
+pub mod req;
+pub mod res;

src/proto/req.rs

@@ -0,0 +1,3 @@
+use imap_codec::types::command::Command;
+
+pub type Request = Command;

src/proto/res.rs

@@ -0,0 +1 @@
+pub type Response = imap_codec::types::response::Response;

src/server/accept/addr.rs

@@ -0,0 +1,83 @@
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::task::{self, Poll};
+
+use async_compat::Compat as AsyncCompat;
+use futures::io::{AsyncRead, AsyncWrite};
+use tokio::net::{TcpListener, TcpStream, ToSocketAddrs};
+
+use super::Accept;
+
+#[pin_project::pin_project]
+pub struct AddrIncoming {
+    pub local_addr: SocketAddr,
+    #[pin]
+    listener: TcpListener,
+}
+
+impl AddrIncoming {
+    pub async fn new(addr: impl ToSocketAddrs) -> std::io::Result<Self> {
+        let listener = TcpListener::bind(addr).await?;
+        let local_addr = listener.local_addr()?;
+
+        Ok(Self {
+            local_addr,
+            listener,
+        })
+    }
+}
+
+impl Accept for AddrIncoming {
+    type Conn = AddrStream;
+    type Error = std::io::Error;
+
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context,
+    ) -> task::Poll<Option<Result<Self::Conn, Self::Error>>> {
+        let this = self.project();
+
+        let (stream, remote_addr) = futures::ready!(this.listener.poll_accept(cx))?;
+        Poll::Ready(Some(Ok(AddrStream {
+            local_addr: *this.local_addr,
+            remote_addr,
+            stream: AsyncCompat::new(stream),
+        })))
+    }
+}
+
+#[pin_project::pin_project]
+pub struct AddrStream {
+    pub local_addr: SocketAddr,
+    pub remote_addr: SocketAddr,
+    #[pin]
+    stream: AsyncCompat<TcpStream>,
+}
+
+impl AsyncRead for AddrStream {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<std::io::Result<usize>> {
+        self.project().stream.poll_read(cx, buf)
+    }
+}
+
+impl AsyncWrite for AddrStream {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        self.project().stream.poll_write(cx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<std::io::Result<()>> {
+        self.project().stream.poll_flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<std::io::Result<()>> {
+        self.project().stream.poll_close(cx)
+    }
+}

src/server/accept/mod.rs

@@ -0,0 +1,79 @@
+use std::error::Error as StdError;
+use std::pin::Pin;
+use std::task;
+
+use futures::io;
+use futures::Stream;
+
+pub mod addr;
+
+pub trait Accept {
+    type Conn: io::AsyncRead + io::AsyncWrite;
+    type Error: StdError;
+
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context,
+    ) -> task::Poll<Option<Result<Self::Conn, Self::Error>>>;
+}
+
+pub fn poll_fn<F, IO, E>(f: F) -> impl Accept<Conn = IO, Error = E>
+where
+    F: FnMut(&mut task::Context) -> task::Poll<Option<Result<IO, E>>>,
+    IO: io::AsyncRead + io::AsyncWrite,
+    E: StdError,
+{
+    struct PollFn<F>(F);
+
+    impl<F> Unpin for PollFn<F> {}
+
+    impl<F, IO, E> Accept for PollFn<F>
+    where
+        F: FnMut(&mut task::Context) -> task::Poll<Option<Result<IO, E>>>,
+        IO: io::AsyncRead + io::AsyncWrite,
+        E: StdError,
+    {
+        type Conn = IO;
+        type Error = E;
+
+        fn poll_accept(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context,
+        ) -> task::Poll<Option<Result<Self::Conn, Self::Error>>> {
+            (self.get_mut().0)(cx)
+        }
+    }
+
+    PollFn(f)
+}
+
+pub fn from_stream<S, IO, E>(stream: S) -> impl Accept<Conn = IO, Error = E>
+where
+    S: Stream<Item = Result<IO, E>>,
+    IO: io::AsyncRead + io::AsyncWrite,
+    E: StdError,
+{
+    use pin_project::pin_project;
+
+    #[pin_project]
+    struct FromStream<S>(#[pin] S);
+
+    impl<S, IO, E> Accept for FromStream<S>
+    where
+        S: Stream<Item = Result<IO, E>>,
+        IO: io::AsyncRead + io::AsyncWrite,
+        E: StdError,
+    {
+        type Conn = IO;
+        type Error = E;
+
+        fn poll_accept(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context,
+        ) -> task::Poll<Option<Result<Self::Conn, Self::Error>>> {
+            self.project().0.poll_next(cx)
+        }
+    }
+
+    FromStream(stream)
+}

src/server/mod.rs

@@ -0,0 +1,168 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{self, Poll};
+
+use futures::io::{AsyncRead, AsyncWrite};
+use imap_codec::types::response::Capability;
+use tower::Service;
+
+use crate::proto::{Request, Response};
+use accept::Accept;
+pub use service::MakeServiceRef;
+
+pub mod accept;
+mod pipeline;
+mod service;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error<A> {
+    Accept(#[source] A),
+    MakeService(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Imap {
+    pub capabilities: Vec<Capability>,
+}
+
+#[pin_project::pin_project]
+pub struct Server<I, S> {
+    #[pin]
+    incoming: I,
+    make_service: S,
+    protocol: Imap,
+}
+
+impl<I> Server<I, ()>
+where
+    I: Accept,
+{
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new(incoming: I) -> Builder<I> {
+        Builder::new(incoming)
+    }
+}
+
+impl<I, S> Future for Server<I, S>
+where
+    I: Accept,
+    I::Conn: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    S: MakeServiceRef<I::Conn, Request, Response = Response>,
+    S::MakeError: Into<Box<dyn std::error::Error + Send + Sync + 'static>> + std::fmt::Display,
+    S::Error: std::fmt::Display,
+    S::Future: Send + 'static,
+{
+    type Output = Result<(), Error<I::Error>>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        loop {
+            let this = self.as_mut().project();
+
+            if let Some(conn) = futures::ready!(this.incoming.poll_accept(cx)) {
+                let conn = conn.map_err(Error::Accept)?;
+
+                futures::ready!(this.make_service.poll_ready_ref(cx))
+                    .map_err(Into::into)
+                    .map_err(Error::MakeService)?;
+
+                let service_fut = this.make_service.make_service_ref(&conn);
+
+                tokio::task::spawn(Connecting {
+                    conn,
+                    service_fut,
+                    protocol: this.protocol.clone(),
+                });
+            } else {
+                return Poll::Ready(Ok(()));
+            }
+        }
+    }
+}
+
+pub struct Builder<I: Accept> {
+    incoming: I,
+    protocol: Imap,
+}
+
+#[allow(clippy::needless_update)]
+impl<I: Accept> Builder<I> {
+    pub fn new(incoming: I) -> Self {
+        Self {
+            incoming,
+            protocol: Default::default(),
+        }
+    }
+
+    pub fn capabilities(self, capabilities: impl IntoIterator<Item = Capability>) -> Self {
+        let protocol = Imap {
+            capabilities: capabilities.into_iter().collect(),
+            ..self.protocol
+        };
+
+        Self { protocol, ..self }
+    }
+
+    pub fn serve<S>(self, make_service: S) -> Server<I, S>
+    where
+        S: MakeServiceRef<I::Conn, Request, Response = Response>,
+    {
+        Server {
+            incoming: self.incoming,
+            make_service,
+            protocol: self.protocol,
+        }
+    }
+}
+
+#[pin_project::pin_project]
+struct Connecting<C, F> {
+    conn: C,
+    #[pin]
+    service_fut: F,
+    protocol: Imap,
+}
+
+impl<C, F, ME, S> Future for Connecting<C, F>
+where
+    C: AsyncRead + AsyncWrite + Unpin,
+    F: Future<Output = std::result::Result<S, ME>>,
+    ME: std::fmt::Display,
+    S: Service<Request, Response = Response>,
+    S::Error: std::fmt::Display,
+{
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        use tokio_tower::pipeline::Server as PipelineServer;
+
+        use pipeline::Connection;
+
+        let this = self.project();
+
+        let service = match futures::ready!(this.service_fut.poll(cx)) {
+            Ok(service) => service,
+            Err(err) => {
+                tracing::debug!("Connection error: {}", err);
+                return Poll::Ready(());
+            }
+        };
+        let mut conn = Connection::new(this.conn);
+
+        // TODO: Properly handle server greeting
+        {
+            use imap_codec::types::response::{Response, Status};
+
+            let status = Status::ok(None, None, "Hello").unwrap();
+            let res = Response::Status(status);
+
+            conn.send(res).unwrap();
+        }
+
+        let mut server = PipelineServer::new(conn, service);
+        if let Err(err) = futures::ready!(Future::poll(Pin::new(&mut server), cx)) {
+            tracing::debug!("Connection error: {}", err);
+        }
+
+        Poll::Ready(())
+    }
+}

src/server/pipeline.rs

@@ -0,0 +1,136 @@
+use std::pin::Pin;
+use std::task::{self, Poll};
+
+use bytes::BytesMut;
+use futures::io::{AsyncRead, AsyncWrite};
+use futures::sink::Sink;
+use futures::stream::Stream;
+
+use crate::proto::{Request, Response};
+
+type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
+
+#[pin_project::pin_project]
+pub struct Connection<C> {
+    #[pin]
+    conn: C,
+    read_buf: BytesMut,
+    write_buf: BytesMut,
+}
+
+impl<C> Connection<C> {
+    pub fn new(conn: C) -> Self {
+        Self {
+            conn,
+            read_buf: BytesMut::new(),
+            write_buf: BytesMut::new(),
+        }
+    }
+}
+
+impl<C> Stream for Connection<C>
+where
+    C: AsyncRead + Unpin,
+{
+    type Item = Result<Request, Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
+        use imap_codec::parse::command::command as parse_command;
+
+        let mut this = self.project();
+
+        loop {
+            let (input, command) = match parse_command(this.read_buf) {
+                Ok(res) => res,
+                Err(e) if e.is_incomplete() => {
+                    let mut buf = [0u8; 256];
+                    let read = futures::ready!(this.conn.as_mut().poll_read(cx, &mut buf))?;
+
+                    let data = &buf[..read];
+                    this.read_buf.extend(data);
+
+                    continue;
+                }
+                Err(e) => {
+                    return Poll::Ready(Some(Err(format!("Error: {:?}", e).into())));
+                }
+            };
+            tracing::debug!("Received: {:#?}", command);
+
+            *this.read_buf = input.into();
+
+            let req = command;
+            return Poll::Ready(Some(Ok(req)));
+        }
+    }
+}
+
+impl<C> Connection<C>
+where
+    C: AsyncWrite,
+{
+    fn poll_flush_buffer(self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<Result<(), Error>> {
+        use bytes::Buf;
+
+        let mut this = self.project();
+
+        while !this.write_buf.is_empty() {
+            let written = futures::ready!(this.conn.as_mut().poll_write(cx, this.write_buf))?;
+            this.write_buf.advance(written);
+        }
+
+        Poll::Ready(Ok(()))
+    }
+
+    pub(crate) fn send(&mut self, item: Response) -> Result<(), Error> {
+        use bytes::BufMut;
+        use imap_codec::codec::Encode;
+
+        let mut writer = BufMut::writer(&mut self.write_buf);
+
+        tracing::debug!("Sending: {:#?}", item);
+        item.encode(&mut writer)?;
+
+        Ok(())
+    }
+}
+
+impl<C> Sink<Response> for Connection<C>
+where
+    C: AsyncWrite + Unpin,
+{
+    type Error = Error;
+
+    fn poll_ready(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        futures::ready!(self.poll_flush_buffer(cx))?;
+        Poll::Ready(Ok(()))
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: Response) -> Result<(), Self::Error> {
+        debug_assert!(self.write_buf.is_empty());
+        self.get_mut().send(item)?;
+
+        Ok(())
+    }
+
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        futures::ready!(self.as_mut().poll_flush_buffer(cx))?;
+        futures::ready!(self.project().conn.poll_flush(cx))?;
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_close(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        futures::ready!(self.as_mut().poll_flush_buffer(cx))?;
+        futures::ready!(self.project().conn.poll_close(cx))?;
+        Poll::Ready(Ok(()))
+    }
+}

src/server/service.rs

@@ -0,0 +1,50 @@
+use std::future::Future;
+use std::task::Context;
+use std::task::Poll;
+
+use tower::Service;
+
+pub trait MakeServiceRef<Target, Request>: self::sealed::Sealed<(Target, Request)> {
+    type Response;
+    type Error;
+    type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
+
+    type MakeError;
+    type Future: Future<Output = Result<Self::Service, Self::MakeError>>;
+
+    fn poll_ready_ref(&mut self, cx: &mut Context) -> Poll<Result<(), Self::MakeError>>;
+    fn make_service_ref(&mut self, target: &Target) -> Self::Future;
+}
+
+impl<M, S, Target, Request> self::sealed::Sealed<(Target, Request)> for M
+where
+    M: for<'a> Service<&'a Target, Response = S>,
+    S: Service<Request>,
+{
+}
+
+impl<M, ME, MF, S, Target, Request> MakeServiceRef<Target, Request> for M
+where
+    M: for<'a> Service<&'a Target, Response = S, Future = MF, Error = ME>,
+    MF: Future<Output = Result<S, ME>>,
+    S: Service<Request>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type MakeError = ME;
+    type Future = MF;
+
+    fn poll_ready_ref(&mut self, cx: &mut Context) -> Poll<Result<(), Self::MakeError>> {
+        self.poll_ready(cx)
+    }
+
+    fn make_service_ref(&mut self, target: &Target) -> Self::Future {
+        self.call(target)
+    }
+}
+
+mod sealed {
+    pub trait Sealed<T> {}
+}