From dcb73fea4b95e25e868c00775db486d1cbda647f Mon Sep 17 00:00:00 2001
From: 4lDO2 <4lDO2@protonmail.com>
Date: Tue, 26 Dec 2023 11:21:01 +0100
Subject: [PATCH] Move scheme API to redox-scheme.

---
 Cargo.toml |   1 -
 src/lib.rs | 119 -----------------------------------------------------
 2 files changed, 120 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 487c66330e..b169fc8e68 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,6 @@ exclude = ["target"]
 
 [features]
 default = ["call"]
-scheme = ["call"]
 call = []
 
 [dependencies]
diff --git a/src/lib.rs b/src/lib.rs
index 9b416a864b..d29d1b7ac7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -409,122 +409,3 @@ pub mod call {
         Error::demux(redox_munmap_v1(addr, length)).map(|_| ())
     }
 }
-
-#[cfg(feature = "scheme")]
-pub mod scheme {
-    use super::*;
-
-    use core::mem::size_of;
-
-    use syscall::Packet;
-    pub use syscall::{Scheme, SchemeBlock, SchemeBlockMut, SchemeMut};
-
-    #[repr(transparent)]
-    #[derive(Clone, Copy, Default)]
-    pub struct Request(Packet);
-
-    impl Request {
-        pub fn handle_scheme(mut self, scheme: &impl Scheme) -> Response {
-            scheme.handle(&mut self.0);
-            Response(self.0)
-        }
-        pub fn handle_scheme_mut(mut self, scheme: &mut impl SchemeMut) -> Response {
-            scheme.handle(&mut self.0);
-            Response(self.0)
-        }
-        pub fn handle_scheme_block(
-            mut self,
-            scheme: &mut impl SchemeBlock,
-        ) -> Result<Response, Request> {
-            match scheme.handle(&mut self.0) {
-                Some(code) => Ok(Response(Packet { a: code, ..self.0 })),
-                None => Err(self),
-            }
-        }
-        pub fn handle_scheme_block_mut(
-            mut self,
-            scheme: &mut impl SchemeBlockMut,
-        ) -> Result<Response, Request> {
-            match scheme.handle(&mut self.0) {
-                Some(code) => Ok(Response(Packet { a: code, ..self.0 })),
-                None => Err(self),
-            }
-        }
-    }
-
-    #[repr(transparent)]
-    #[derive(Clone, Copy, Default)]
-    pub struct Response(Packet);
-
-    impl Response {
-        pub fn new(req: &Request, status: Result<usize>) -> Self {
-            Self(Packet {
-                a: Error::mux(status),
-                ..req.0
-            })
-        }
-    }
-
-    pub enum SignalBehavior {
-        Interrupt,
-        Restart,
-    }
-
-    // TODO: Support uninitialized memory
-    #[inline]
-    pub fn read_requests(
-        socket: usize,
-        buf: &mut [Request],
-        behavior: SignalBehavior,
-    ) -> Result<usize> {
-        let len = buf.len().checked_mul(size_of::<Request>()).unwrap();
-
-        let bytes_read = loop {
-            match call::read(socket, unsafe {
-                core::slice::from_raw_parts_mut(buf.as_mut_ptr().cast(), len)
-            }) {
-                Ok(n) => break n,
-                error @ Err(Error {
-                    errno: errno::EINTR,
-                }) => match behavior {
-                    SignalBehavior::Restart => continue,
-                    SignalBehavior::Interrupt => return error,
-                },
-                Err(err) => return Err(err),
-            }
-        };
-
-        debug_assert_eq!(bytes_read % size_of::<Request>(), 0);
-
-        Ok(bytes_read / size_of::<Request>())
-    }
-
-    #[inline]
-    pub fn write_responses(
-        socket: usize,
-        buf: &[Response],
-        behavior: SignalBehavior,
-    ) -> Result<usize> {
-        let bytes = unsafe {
-            core::slice::from_raw_parts(
-                buf.as_ptr().cast(),
-                buf.len().checked_mul(size_of::<Response>()).unwrap(),
-            )
-        };
-
-        let bytes_written = loop {
-            match call::write(socket, bytes) {
-                Ok(n) => break n,
-                error @ Err(Error {
-                    errno: errno::EINTR,
-                }) => match behavior {
-                    SignalBehavior::Restart => continue,
-                    SignalBehavior::Interrupt => return error,
-                },
-                Err(err) => return Err(err),
-            }
-        };
-        debug_assert_eq!(bytes_written % size_of::<Response>(), 0);
-        Ok(bytes_written / size_of::<Response>())
-    }
-}