From 45df4d0d9b577fecee798d672695fe24ff57fb1b Mon Sep 17 00:00:00 2001 From: mo khan Date: Tue, 15 Jul 2025 16:37:08 -0600 Subject: feat: migrate from Cedar to SpiceDB authorization system This is a major architectural change that replaces the Cedar policy-based authorization system with SpiceDB's relation-based authorization. Key changes: - Migrate from Rust to Go implementation - Replace Cedar policies with SpiceDB schema and relationships - Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks - Update build system and dependencies for Go ecosystem - Maintain Envoy integration for external authorization This change enables more flexible permission modeling through SpiceDB's Google Zanzibar inspired relation-based system, supporting complex hierarchical permissions that were difficult to express in Cedar. Breaking change: Existing Cedar policies and Rust-based configuration will no longer work and need to be migrated to SpiceDB schema. --- vendor/hyper/src/ffi/body.rs | 302 ---------------- vendor/hyper/src/ffi/client.rs | 274 --------------- vendor/hyper/src/ffi/error.rs | 96 ----- vendor/hyper/src/ffi/http_types.rs | 703 ------------------------------------- vendor/hyper/src/ffi/io.rs | 198 ----------- vendor/hyper/src/ffi/macros.rs | 53 --- vendor/hyper/src/ffi/mod.rs | 99 ------ vendor/hyper/src/ffi/task.rs | 549 ----------------------------- 8 files changed, 2274 deletions(-) delete mode 100644 vendor/hyper/src/ffi/body.rs delete mode 100644 vendor/hyper/src/ffi/client.rs delete mode 100644 vendor/hyper/src/ffi/error.rs delete mode 100644 vendor/hyper/src/ffi/http_types.rs delete mode 100644 vendor/hyper/src/ffi/io.rs delete mode 100644 vendor/hyper/src/ffi/macros.rs delete mode 100644 vendor/hyper/src/ffi/mod.rs delete mode 100644 vendor/hyper/src/ffi/task.rs (limited to 'vendor/hyper/src/ffi') diff --git a/vendor/hyper/src/ffi/body.rs b/vendor/hyper/src/ffi/body.rs deleted file mode 100644 index e5a09e57..00000000 --- a/vendor/hyper/src/ffi/body.rs +++ /dev/null @@ -1,302 +0,0 @@ -use std::ffi::{c_int, c_void}; -use std::mem::ManuallyDrop; -use std::ptr; -use std::task::{Context, Poll}; - -use http_body_util::BodyExt as _; - -use super::task::{hyper_context, hyper_task, hyper_task_return_type, AsTaskType}; -use super::{UserDataPointer, HYPER_ITER_CONTINUE}; -use crate::body::{Bytes, Frame, Incoming as IncomingBody}; -use crate::ffi::size_t; - -/// A streaming HTTP body. -/// -/// This is used both for sending requests (with `hyper_request_set_body`) and -/// for receiving responses (with `hyper_response_body`). -/// -/// For outgoing request bodies, call `hyper_body_set_data_func` to provide the -/// data. -/// -/// For incoming response bodies, call `hyper_body_data` to get a task that will -/// yield a chunk of data each time it is polled. That task must be then be -/// added to the executor with `hyper_executor_push`. -/// -/// Methods: -/// -/// - hyper_body_new: Create a new “empty” body. -/// - hyper_body_set_userdata: Set userdata on this body, which will be passed to callback functions. -/// - hyper_body_set_data_func: Set the data callback for this body. -/// - hyper_body_data: Creates a task that will poll a response body for the next buffer of data. -/// - hyper_body_foreach: Creates a task to execute the callback with each body chunk received. -/// - hyper_body_free: Free a body. -pub struct hyper_body(pub(super) IncomingBody); - -/// A buffer of bytes that is sent or received on a `hyper_body`. -/// -/// Obtain one of these in the callback of `hyper_body_foreach` or by receiving -/// a task of type `HYPER_TASK_BUF` from `hyper_executor_poll` (after calling -/// `hyper_body_data` and pushing the resulting task). -/// -/// Methods: -/// -/// - hyper_buf_bytes: Get a pointer to the bytes in this buffer. -/// - hyper_buf_copy: Create a new hyper_buf * by copying the provided bytes. -/// - hyper_buf_free: Free this buffer. -/// - hyper_buf_len: Get the length of the bytes this buffer contains. -pub struct hyper_buf(pub(crate) Bytes); - -pub(crate) struct UserBody { - data_func: hyper_body_data_callback, - userdata: *mut c_void, -} - -// ===== Body ===== - -type hyper_body_foreach_callback = extern "C" fn(*mut c_void, *const hyper_buf) -> c_int; - -type hyper_body_data_callback = - extern "C" fn(*mut c_void, *mut hyper_context<'_>, *mut *mut hyper_buf) -> c_int; - -ffi_fn! { - /// Creates a new "empty" body. - /// - /// If not configured, this body acts as an empty payload. - /// - /// To avoid a memory leak, the body must eventually be consumed by - /// `hyper_body_free`, `hyper_body_foreach`, or `hyper_request_set_body`. - fn hyper_body_new() -> *mut hyper_body { - Box::into_raw(Box::new(hyper_body(IncomingBody::ffi()))) - } ?= ptr::null_mut() -} - -ffi_fn! { - /// Free a body. - /// - /// This should only be used if the request isn't consumed by - /// `hyper_body_foreach` or `hyper_request_set_body`. - fn hyper_body_free(body: *mut hyper_body) { - drop(non_null!(Box::from_raw(body) ?= ())); - } -} - -ffi_fn! { - /// Creates a task that will poll a response body for the next buffer of data. - /// - /// The task may have different types depending on the outcome: - /// - /// - `HYPER_TASK_BUF`: Success, and more data was received. - /// - `HYPER_TASK_ERROR`: An error retrieving the data. - /// - `HYPER_TASK_EMPTY`: The body has finished streaming data. - /// - /// When the application receives the task from `hyper_executor_poll`, - /// if the task type is `HYPER_TASK_BUF`, it should cast the task to - /// `hyper_buf *` and consume all the bytes in the buffer. Then - /// the application should call `hyper_body_data` again for the same - /// `hyper_body *`, to create a task for the next buffer of data. - /// Repeat until the polled task type is `HYPER_TASK_ERROR` or - /// `HYPER_TASK_EMPTY`. - /// - /// To avoid a memory leak, the task must eventually be consumed by - /// `hyper_task_free`, or taken ownership of by `hyper_executor_push` - /// without subsequently being given back by `hyper_executor_poll`. - /// - /// This does not consume the `hyper_body *`, so it may be used again. - /// However, the `hyper_body *` MUST NOT be used or freed until the - /// related task is returned from `hyper_executor_poll`. - /// - /// For a more convenient method, see also `hyper_body_foreach`. - fn hyper_body_data(body: *mut hyper_body) -> *mut hyper_task { - // This doesn't take ownership of the Body, so don't allow destructor - let mut body = ManuallyDrop::new(non_null!(Box::from_raw(body) ?= ptr::null_mut())); - - Box::into_raw(hyper_task::boxed(async move { - loop { - match body.0.frame().await { - Some(Ok(frame)) => { - if let Ok(data) = frame.into_data() { - return Ok(Some(hyper_buf(data))); - } else { - continue; - } - }, - Some(Err(e)) => return Err(e), - None => return Ok(None), - } - } - })) - } ?= ptr::null_mut() -} - -ffi_fn! { - /// Creates a task to execute the callback with each body chunk received. - /// - /// To avoid a memory leak, the task must eventually be consumed by - /// `hyper_task_free`, or taken ownership of by `hyper_executor_push` - /// without subsequently being given back by `hyper_executor_poll`. - /// - /// The `hyper_buf` pointer is only a borrowed reference. It cannot live outside - /// the execution of the callback. You must make a copy of the bytes to retain them. - /// - /// The callback should return `HYPER_ITER_CONTINUE` to continue iterating - /// chunks as they are received, or `HYPER_ITER_BREAK` to cancel. Each - /// invocation of the callback must consume all the bytes it is provided. - /// There is no mechanism to signal to Hyper that only a subset of bytes were - /// consumed. - /// - /// This will consume the `hyper_body *`, you shouldn't use it anymore or free it. - fn hyper_body_foreach(body: *mut hyper_body, func: hyper_body_foreach_callback, userdata: *mut c_void) -> *mut hyper_task { - let mut body = non_null!(Box::from_raw(body) ?= ptr::null_mut()); - let userdata = UserDataPointer(userdata); - - Box::into_raw(hyper_task::boxed(async move { - let _ = &userdata; - while let Some(item) = body.0.frame().await { - let frame = item?; - if let Ok(chunk) = frame.into_data() { - if HYPER_ITER_CONTINUE != func(userdata.0, &hyper_buf(chunk)) { - return Err(crate::Error::new_user_aborted_by_callback()); - } - } - } - Ok(()) - })) - } ?= ptr::null_mut() -} - -ffi_fn! { - /// Set userdata on this body, which will be passed to callback functions. - fn hyper_body_set_userdata(body: *mut hyper_body, userdata: *mut c_void) { - let b = non_null!(&mut *body ?= ()); - b.0.as_ffi_mut().userdata = userdata; - } -} - -ffi_fn! { - /// Set the outgoing data callback for this body. - /// - /// The callback is called each time hyper needs to send more data for the - /// body. It is passed the value from `hyper_body_set_userdata`. - /// - /// If there is data available, the `hyper_buf **` argument should be set - /// to a `hyper_buf *` containing the data, and `HYPER_POLL_READY` should - /// be returned. - /// - /// Returning `HYPER_POLL_READY` while the `hyper_buf **` argument points - /// to `NULL` will indicate the body has completed all data. - /// - /// If there is more data to send, but it isn't yet available, a - /// `hyper_waker` should be saved from the `hyper_context *` argument, and - /// `HYPER_POLL_PENDING` should be returned. You must wake the saved waker - /// to signal the task when data is available. - /// - /// If some error has occurred, you can return `HYPER_POLL_ERROR` to abort - /// the body. - fn hyper_body_set_data_func(body: *mut hyper_body, func: hyper_body_data_callback) { - let b = non_null!{ &mut *body ?= () }; - b.0.as_ffi_mut().data_func = func; - } -} - -// ===== impl UserBody ===== - -impl UserBody { - pub(crate) fn new() -> UserBody { - UserBody { - data_func: data_noop, - userdata: std::ptr::null_mut(), - } - } - - pub(crate) fn poll_data( - &mut self, - cx: &mut Context<'_>, - ) -> Poll>>> { - let mut out = std::ptr::null_mut(); - match (self.data_func)(self.userdata, hyper_context::wrap(cx), &mut out) { - super::task::HYPER_POLL_READY => { - if out.is_null() { - Poll::Ready(None) - } else { - let buf = unsafe { Box::from_raw(out) }; - Poll::Ready(Some(Ok(Frame::data(buf.0)))) - } - } - super::task::HYPER_POLL_PENDING => Poll::Pending, - super::task::HYPER_POLL_ERROR => { - Poll::Ready(Some(Err(crate::Error::new_body_write_aborted()))) - } - unexpected => Poll::Ready(Some(Err(crate::Error::new_body_write(format!( - "unexpected hyper_body_data_func return code {}", - unexpected - ))))), - } - } -} - -/// cbindgen:ignore -extern "C" fn data_noop( - _userdata: *mut c_void, - _: *mut hyper_context<'_>, - _: *mut *mut hyper_buf, -) -> c_int { - super::task::HYPER_POLL_READY -} - -unsafe impl Send for UserBody {} -unsafe impl Sync for UserBody {} - -// ===== Bytes ===== - -ffi_fn! { - /// Create a new `hyper_buf *` by copying the provided bytes. - /// - /// This makes an owned copy of the bytes, so the `buf` argument can be - /// freed (with `hyper_buf_free`) or changed afterwards. - /// - /// To avoid a memory leak, the copy must eventually be consumed by - /// `hyper_buf_free`. - /// - /// This returns `NULL` if allocating a new buffer fails. - fn hyper_buf_copy(buf: *const u8, len: size_t) -> *mut hyper_buf { - let slice = unsafe { - std::slice::from_raw_parts(buf, len) - }; - Box::into_raw(Box::new(hyper_buf(Bytes::copy_from_slice(slice)))) - } ?= ptr::null_mut() -} - -ffi_fn! { - /// Get a pointer to the bytes in this buffer. - /// - /// This should be used in conjunction with `hyper_buf_len` to get the length - /// of the bytes data. - /// - /// This pointer is borrowed data, and not valid once the `hyper_buf` is - /// consumed/freed. - fn hyper_buf_bytes(buf: *const hyper_buf) -> *const u8 { - unsafe { (*buf).0.as_ptr() } - } ?= ptr::null() -} - -ffi_fn! { - /// Get the length of the bytes this buffer contains. - fn hyper_buf_len(buf: *const hyper_buf) -> size_t { - unsafe { (*buf).0.len() } - } -} - -ffi_fn! { - /// Free this buffer. - /// - /// This should be used for any buffer once it is no longer needed. - fn hyper_buf_free(buf: *mut hyper_buf) { - drop(unsafe { Box::from_raw(buf) }); - } -} - -unsafe impl AsTaskType for hyper_buf { - fn as_task_type(&self) -> hyper_task_return_type { - hyper_task_return_type::HYPER_TASK_BUF - } -} diff --git a/vendor/hyper/src/ffi/client.rs b/vendor/hyper/src/ffi/client.rs deleted file mode 100644 index 63b03d87..00000000 --- a/vendor/hyper/src/ffi/client.rs +++ /dev/null @@ -1,274 +0,0 @@ -use std::ffi::c_int; -use std::ptr; -use std::sync::Arc; - -use crate::client::conn; -use crate::rt::Executor as _; - -use super::error::hyper_code; -use super::http_types::{hyper_request, hyper_response}; -use super::io::hyper_io; -use super::task::{hyper_executor, hyper_task, hyper_task_return_type, AsTaskType, WeakExec}; - -/// An options builder to configure an HTTP client connection. -/// -/// Methods: -/// -/// - hyper_clientconn_options_new: Creates a new set of HTTP clientconn options to be used in a handshake. -/// - hyper_clientconn_options_exec: Set the client background task executor. -/// - hyper_clientconn_options_http2: Set whether to use HTTP2. -/// - hyper_clientconn_options_set_preserve_header_case: Set whether header case is preserved. -/// - hyper_clientconn_options_set_preserve_header_order: Set whether header order is preserved. -/// - hyper_clientconn_options_http1_allow_multiline_headers: Set whether HTTP/1 connections accept obsolete line folding for header values. -/// - hyper_clientconn_options_free: Free a set of HTTP clientconn options. -pub struct hyper_clientconn_options { - http1_allow_obsolete_multiline_headers_in_responses: bool, - http1_preserve_header_case: bool, - http1_preserve_header_order: bool, - http2: bool, - /// Use a `Weak` to prevent cycles. - exec: WeakExec, -} - -/// An HTTP client connection handle. -/// -/// These are used to send one or more requests on a single connection. -/// -/// It's possible to send multiple requests on a single connection, such -/// as when HTTP/1 keep-alive or HTTP/2 is used. -/// -/// To create a `hyper_clientconn`: -/// -/// 1. Create a `hyper_io` with `hyper_io_new`. -/// 2. Create a `hyper_clientconn_options` with `hyper_clientconn_options_new`. -/// 3. Call `hyper_clientconn_handshake` with the `hyper_io` and `hyper_clientconn_options`. -/// This creates a `hyper_task`. -/// 5. Call `hyper_task_set_userdata` to assign an application-specific pointer to the task. -/// This allows keeping track of multiple connections that may be handshaking -/// simultaneously. -/// 4. Add the `hyper_task` to an executor with `hyper_executor_push`. -/// 5. Poll that executor until it yields a task of type `HYPER_TASK_CLIENTCONN`. -/// 6. Extract the `hyper_clientconn` from the task with `hyper_task_value`. -/// This will require a cast from `void *` to `hyper_clientconn *`. -/// -/// This process results in a `hyper_clientconn` that permanently owns the -/// `hyper_io`. Because the `hyper_io` in turn owns a TCP or TLS connection, that means -/// the `hyper_clientconn` owns the connection for both the clientconn's lifetime -/// and the connection's lifetime. -/// -/// In other words, each connection (`hyper_io`) must have exactly one `hyper_clientconn` -/// associated with it. That's because `hyper_clientconn_handshake` sends the -/// [HTTP/2 Connection Preface] (for HTTP/2 connections). Since that preface can't -/// be sent twice, handshake can't be called twice. -/// -/// [HTTP/2 Connection Preface]: https://datatracker.ietf.org/doc/html/rfc9113#name-http-2-connection-preface -/// -/// Methods: -/// -/// - hyper_clientconn_handshake: Creates an HTTP client handshake task. -/// - hyper_clientconn_send: Creates a task to send a request on the client connection. -/// - hyper_clientconn_free: Free a hyper_clientconn *. -pub struct hyper_clientconn { - tx: Tx, -} - -enum Tx { - #[cfg(feature = "http1")] - Http1(conn::http1::SendRequest), - #[cfg(feature = "http2")] - Http2(conn::http2::SendRequest), -} - -// ===== impl hyper_clientconn ===== - -ffi_fn! { - /// Creates an HTTP client handshake task. - /// - /// Both the `io` and the `options` are consumed in this function call. - /// They should not be used or freed afterwards. - /// - /// The returned task must be polled with an executor until the handshake - /// completes, at which point the value can be taken. - /// - /// To avoid a memory leak, the task must eventually be consumed by - /// `hyper_task_free`, or taken ownership of by `hyper_executor_push` - /// without subsequently being given back by `hyper_executor_poll`. - fn hyper_clientconn_handshake(io: *mut hyper_io, options: *mut hyper_clientconn_options) -> *mut hyper_task { - let options = non_null! { Box::from_raw(options) ?= ptr::null_mut() }; - let io = non_null! { Box::from_raw(io) ?= ptr::null_mut() }; - - Box::into_raw(hyper_task::boxed(async move { - #[cfg(feature = "http2")] - { - if options.http2 { - return conn::http2::Builder::new(options.exec.clone()) - .handshake::<_, crate::body::Incoming>(io) - .await - .map(|(tx, conn)| { - options.exec.execute(Box::pin(async move { - let _ = conn.await; - })); - hyper_clientconn { tx: Tx::Http2(tx) } - }); - } - } - - conn::http1::Builder::new() - .allow_obsolete_multiline_headers_in_responses(options.http1_allow_obsolete_multiline_headers_in_responses) - .preserve_header_case(options.http1_preserve_header_case) - .preserve_header_order(options.http1_preserve_header_order) - .handshake::<_, crate::body::Incoming>(io) - .await - .map(|(tx, conn)| { - options.exec.execute(Box::pin(async move { - let _ = conn.await; - })); - hyper_clientconn { tx: Tx::Http1(tx) } - }) - })) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Creates a task to send a request on the client connection. - /// - /// This consumes the request. You should not use or free the request - /// afterwards. - /// - /// Returns a task that needs to be polled until it is ready. When ready, the - /// task yields a `hyper_response *`. - /// - /// To avoid a memory leak, the task must eventually be consumed by - /// `hyper_task_free`, or taken ownership of by `hyper_executor_push` - /// without subsequently being given back by `hyper_executor_poll`. - fn hyper_clientconn_send(conn: *mut hyper_clientconn, req: *mut hyper_request) -> *mut hyper_task { - let mut req = non_null! { Box::from_raw(req) ?= ptr::null_mut() }; - - // Update request with original-case map of headers - req.finalize_request(); - - let fut = match non_null! { &mut *conn ?= ptr::null_mut() }.tx { - Tx::Http1(ref mut tx) => futures_util::future::Either::Left(tx.send_request(req.0)), - Tx::Http2(ref mut tx) => futures_util::future::Either::Right(tx.send_request(req.0)), - }; - - let fut = async move { - fut.await.map(hyper_response::wrap) - }; - - Box::into_raw(hyper_task::boxed(fut)) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Free a `hyper_clientconn *`. - /// - /// This should be used for any connection once it is no longer needed. - fn hyper_clientconn_free(conn: *mut hyper_clientconn) { - drop(non_null! { Box::from_raw(conn) ?= () }); - } -} - -unsafe impl AsTaskType for hyper_clientconn { - fn as_task_type(&self) -> hyper_task_return_type { - hyper_task_return_type::HYPER_TASK_CLIENTCONN - } -} - -// ===== impl hyper_clientconn_options ===== - -ffi_fn! { - /// Creates a new set of HTTP clientconn options to be used in a handshake. - /// - /// To avoid a memory leak, the options must eventually be consumed by - /// `hyper_clientconn_options_free` or `hyper_clientconn_handshake`. - fn hyper_clientconn_options_new() -> *mut hyper_clientconn_options { - Box::into_raw(Box::new(hyper_clientconn_options { - http1_allow_obsolete_multiline_headers_in_responses: false, - http1_preserve_header_case: false, - http1_preserve_header_order: false, - http2: false, - exec: WeakExec::new(), - })) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Set whether header case is preserved. - /// - /// Pass `0` to allow lowercase normalization (default), `1` to retain original case. - fn hyper_clientconn_options_set_preserve_header_case(opts: *mut hyper_clientconn_options, enabled: c_int) { - let opts = non_null! { &mut *opts ?= () }; - opts.http1_preserve_header_case = enabled != 0; - } -} - -ffi_fn! { - /// Set whether header order is preserved. - /// - /// Pass `0` to allow reordering (default), `1` to retain original ordering. - fn hyper_clientconn_options_set_preserve_header_order(opts: *mut hyper_clientconn_options, enabled: c_int) { - let opts = non_null! { &mut *opts ?= () }; - opts.http1_preserve_header_order = enabled != 0; - } -} - -ffi_fn! { - /// Free a set of HTTP clientconn options. - /// - /// This should only be used if the options aren't consumed by - /// `hyper_clientconn_handshake`. - fn hyper_clientconn_options_free(opts: *mut hyper_clientconn_options) { - drop(non_null! { Box::from_raw(opts) ?= () }); - } -} - -ffi_fn! { - /// Set the client background task executor. - /// - /// This does not consume the `options` or the `exec`. - fn hyper_clientconn_options_exec(opts: *mut hyper_clientconn_options, exec: *const hyper_executor) { - let opts = non_null! { &mut *opts ?= () }; - - let exec = non_null! { Arc::from_raw(exec) ?= () }; - let weak_exec = hyper_executor::downgrade(&exec); - std::mem::forget(exec); - - opts.exec = weak_exec; - } -} - -ffi_fn! { - /// Set whether to use HTTP2. - /// - /// Pass `0` to disable, `1` to enable. - fn hyper_clientconn_options_http2(opts: *mut hyper_clientconn_options, enabled: c_int) -> hyper_code { - #[cfg(feature = "http2")] - { - let opts = non_null! { &mut *opts ?= hyper_code::HYPERE_INVALID_ARG }; - opts.http2 = enabled != 0; - hyper_code::HYPERE_OK - } - - #[cfg(not(feature = "http2"))] - { - drop(opts); - drop(enabled); - hyper_code::HYPERE_FEATURE_NOT_ENABLED - } - } -} - -ffi_fn! { - /// Set whether HTTP/1 connections accept obsolete line folding for header values. - /// - /// Newline codepoints (\r and \n) will be transformed to spaces when parsing. - /// - /// Pass `0` to disable, `1` to enable. - /// - fn hyper_clientconn_options_http1_allow_multiline_headers(opts: *mut hyper_clientconn_options, enabled: c_int) -> hyper_code { - let opts = non_null! { &mut *opts ?= hyper_code::HYPERE_INVALID_ARG }; - opts.http1_allow_obsolete_multiline_headers_in_responses = enabled != 0; - hyper_code::HYPERE_OK - } -} diff --git a/vendor/hyper/src/ffi/error.rs b/vendor/hyper/src/ffi/error.rs deleted file mode 100644 index cc289ed7..00000000 --- a/vendor/hyper/src/ffi/error.rs +++ /dev/null @@ -1,96 +0,0 @@ -use crate::ffi::size_t; - -/// A more detailed error object returned by some hyper functions. -/// -/// Compare with `hyper_code`, which is a simpler error returned from -/// some hyper functions. -/// -/// Methods: -/// -/// - hyper_error_code: Get an equivalent hyper_code from this error. -/// - hyper_error_print: Print the details of this error to a buffer. -/// - hyper_error_free: Frees a hyper_error. -pub struct hyper_error(crate::Error); - -/// A return code for many of hyper's methods. -#[repr(C)] -pub enum hyper_code { - /// All is well. - HYPERE_OK, - /// General error, details in the `hyper_error *`. - HYPERE_ERROR, - /// A function argument was invalid. - HYPERE_INVALID_ARG, - /// The IO transport returned an EOF when one wasn't expected. - /// - /// This typically means an HTTP request or response was expected, but the - /// connection closed cleanly without sending (all of) it. - HYPERE_UNEXPECTED_EOF, - /// Aborted by a user supplied callback. - HYPERE_ABORTED_BY_CALLBACK, - /// An optional hyper feature was not enabled. - #[cfg_attr(feature = "http2", allow(unused))] - HYPERE_FEATURE_NOT_ENABLED, - /// The peer sent an HTTP message that could not be parsed. - HYPERE_INVALID_PEER_MESSAGE, -} - -// ===== impl hyper_error ===== - -impl hyper_error { - fn code(&self) -> hyper_code { - use crate::error::Kind as ErrorKind; - use crate::error::User; - - match self.0.kind() { - ErrorKind::Parse(_) => hyper_code::HYPERE_INVALID_PEER_MESSAGE, - ErrorKind::IncompleteMessage => hyper_code::HYPERE_UNEXPECTED_EOF, - ErrorKind::User(User::AbortedByCallback) => hyper_code::HYPERE_ABORTED_BY_CALLBACK, - // TODO: add more variants - _ => hyper_code::HYPERE_ERROR, - } - } - - fn print_to(&self, dst: &mut [u8]) -> usize { - use std::io::Write; - - let mut dst = std::io::Cursor::new(dst); - - // A write! error doesn't matter. As much as possible will have been - // written, and the Cursor position will know how far that is (even - // if that is zero). - let _ = write!(dst, "{}", &self.0); - dst.position() as usize - } -} - -ffi_fn! { - /// Frees a `hyper_error`. - /// - /// This should be used for any error once it is no longer needed. - fn hyper_error_free(err: *mut hyper_error) { - drop(non_null!(Box::from_raw(err) ?= ())); - } -} - -ffi_fn! { - /// Get an equivalent `hyper_code` from this error. - fn hyper_error_code(err: *const hyper_error) -> hyper_code { - non_null!(&*err ?= hyper_code::HYPERE_INVALID_ARG).code() - } -} - -ffi_fn! { - /// Print the details of this error to a buffer. - /// - /// The `dst_len` value must be the maximum length that the buffer can - /// store. - /// - /// The return value is number of bytes that were written to `dst`. - fn hyper_error_print(err: *const hyper_error, dst: *mut u8, dst_len: size_t) -> size_t { - let dst = unsafe { - std::slice::from_raw_parts_mut(dst, dst_len) - }; - non_null!(&*err ?= 0).print_to(dst) - } -} diff --git a/vendor/hyper/src/ffi/http_types.rs b/vendor/hyper/src/ffi/http_types.rs deleted file mode 100644 index 3dc4a254..00000000 --- a/vendor/hyper/src/ffi/http_types.rs +++ /dev/null @@ -1,703 +0,0 @@ -use std::ffi::{c_int, c_void}; - -use bytes::Bytes; - -use super::body::hyper_body; -use super::error::hyper_code; -use super::task::{hyper_task_return_type, AsTaskType}; -use super::{UserDataPointer, HYPER_ITER_CONTINUE}; -use crate::body::Incoming as IncomingBody; -use crate::ext::{HeaderCaseMap, OriginalHeaderOrder, ReasonPhrase}; -use crate::ffi::size_t; -use crate::header::{HeaderName, HeaderValue}; -use crate::{HeaderMap, Method, Request, Response, Uri}; - -/// An HTTP request. -/// -/// Once you've finished constructing a request, you can send it with -/// `hyper_clientconn_send`. -/// -/// Methods: -/// -/// - hyper_request_new: Construct a new HTTP request. -/// - hyper_request_headers: Gets a mutable reference to the HTTP headers of this request -/// - hyper_request_set_body: Set the body of the request. -/// - hyper_request_set_method: Set the HTTP Method of the request. -/// - hyper_request_set_uri: Set the URI of the request. -/// - hyper_request_set_uri_parts: Set the URI of the request with separate scheme, authority, and path/query strings. -/// - hyper_request_set_version: Set the preferred HTTP version of the request. -/// - hyper_request_on_informational: Set an informational (1xx) response callback. -/// - hyper_request_free: Free an HTTP request. -pub struct hyper_request(pub(super) Request); - -/// An HTTP response. -/// -/// Obtain one of these by making a request with `hyper_clientconn_send`, then -/// polling the executor unntil you get a `hyper_task` of type -/// `HYPER_TASK_RESPONSE`. To figure out which request this response -/// corresponds to, check the userdata of the task, which you should -/// previously have set to an application-specific identifier for the -/// request. -/// -/// Methods: -/// -/// - hyper_response_status: Get the HTTP-Status code of this response. -/// - hyper_response_version: Get the HTTP version used by this response. -/// - hyper_response_reason_phrase: Get a pointer to the reason-phrase of this response. -/// - hyper_response_reason_phrase_len: Get the length of the reason-phrase of this response. -/// - hyper_response_headers: Gets a reference to the HTTP headers of this response. -/// - hyper_response_body: Take ownership of the body of this response. -/// - hyper_response_free: Free an HTTP response. -pub struct hyper_response(pub(super) Response); - -/// An HTTP header map. -/// -/// These can be part of a request or response. -/// -/// Obtain a pointer to read or modify these from `hyper_request_headers` -/// or `hyper_response_headers`. -/// -/// Methods: -/// -/// - hyper_headers_add: Adds the provided value to the list of the provided name. -/// - hyper_headers_foreach: Iterates the headers passing each name and value pair to the callback. -/// - hyper_headers_set: Sets the header with the provided name to the provided value. -#[derive(Clone)] -pub struct hyper_headers { - pub(super) headers: HeaderMap, - orig_casing: HeaderCaseMap, - orig_order: OriginalHeaderOrder, -} - -#[derive(Clone)] -struct OnInformational { - func: hyper_request_on_informational_callback, - data: UserDataPointer, -} - -type hyper_request_on_informational_callback = extern "C" fn(*mut c_void, *mut hyper_response); - -// ===== impl hyper_request ===== - -ffi_fn! { - /// Construct a new HTTP request. - /// - /// The default request has an empty body. To send a body, call `hyper_request_set_body`. - /// - /// - /// To avoid a memory leak, the request must eventually be consumed by - /// `hyper_request_free` or `hyper_clientconn_send`. - fn hyper_request_new() -> *mut hyper_request { - Box::into_raw(Box::new(hyper_request(Request::new(IncomingBody::empty())))) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Free an HTTP request. - /// - /// This should only be used if the request isn't consumed by - /// `hyper_clientconn_send`. - fn hyper_request_free(req: *mut hyper_request) { - drop(non_null!(Box::from_raw(req) ?= ())); - } -} - -ffi_fn! { - /// Set the HTTP Method of the request. - fn hyper_request_set_method(req: *mut hyper_request, method: *const u8, method_len: size_t) -> hyper_code { - let bytes = unsafe { - std::slice::from_raw_parts(method, method_len as usize) - }; - let req = non_null!(&mut *req ?= hyper_code::HYPERE_INVALID_ARG); - match Method::from_bytes(bytes) { - Ok(m) => { - *req.0.method_mut() = m; - hyper_code::HYPERE_OK - }, - Err(_) => { - hyper_code::HYPERE_INVALID_ARG - } - } - } -} - -ffi_fn! { - /// Set the URI of the request. - /// - /// The request's URI is best described as the `request-target` from the RFCs. So in HTTP/1, - /// whatever is set will get sent as-is in the first line (GET $uri HTTP/1.1). It - /// supports the 4 defined variants, origin-form, absolute-form, authority-form, and - /// asterisk-form. - /// - /// The underlying type was built to efficiently support HTTP/2 where the request-target is - /// split over :scheme, :authority, and :path. As such, each part can be set explicitly, or the - /// type can parse a single contiguous string and if a scheme is found, that slot is "set". If - /// the string just starts with a path, only the path portion is set. All pseudo headers that - /// have been parsed/set are sent when the connection type is HTTP/2. - /// - /// To set each slot explicitly, use `hyper_request_set_uri_parts`. - fn hyper_request_set_uri(req: *mut hyper_request, uri: *const u8, uri_len: size_t) -> hyper_code { - let bytes = unsafe { - std::slice::from_raw_parts(uri, uri_len as usize) - }; - let req = non_null!(&mut *req ?= hyper_code::HYPERE_INVALID_ARG); - match Uri::from_maybe_shared(bytes) { - Ok(u) => { - *req.0.uri_mut() = u; - hyper_code::HYPERE_OK - }, - Err(_) => { - hyper_code::HYPERE_INVALID_ARG - } - } - } -} - -ffi_fn! { - /// Set the URI of the request with separate scheme, authority, and - /// path/query strings. - /// - /// Each of `scheme`, `authority`, and `path_and_query` should either be - /// null, to skip providing a component, or point to a UTF-8 encoded - /// string. If any string pointer argument is non-null, its corresponding - /// `len` parameter must be set to the string's length. - fn hyper_request_set_uri_parts( - req: *mut hyper_request, - scheme: *const u8, - scheme_len: size_t, - authority: *const u8, - authority_len: size_t, - path_and_query: *const u8, - path_and_query_len: size_t - ) -> hyper_code { - let mut builder = Uri::builder(); - if !scheme.is_null() { - let scheme_bytes = unsafe { - std::slice::from_raw_parts(scheme, scheme_len as usize) - }; - builder = builder.scheme(scheme_bytes); - } - if !authority.is_null() { - let authority_bytes = unsafe { - std::slice::from_raw_parts(authority, authority_len as usize) - }; - builder = builder.authority(authority_bytes); - } - if !path_and_query.is_null() { - let path_and_query_bytes = unsafe { - std::slice::from_raw_parts(path_and_query, path_and_query_len as usize) - }; - builder = builder.path_and_query(path_and_query_bytes); - } - match builder.build() { - Ok(u) => { - *unsafe { &mut *req }.0.uri_mut() = u; - hyper_code::HYPERE_OK - }, - Err(_) => { - hyper_code::HYPERE_INVALID_ARG - } - } - } -} - -ffi_fn! { - /// Set the preferred HTTP version of the request. - /// - /// The version value should be one of the `HYPER_HTTP_VERSION_` constants. - /// - /// Note that this won't change the major HTTP version of the connection, - /// since that is determined at the handshake step. - fn hyper_request_set_version(req: *mut hyper_request, version: c_int) -> hyper_code { - use http::Version; - - let req = non_null!(&mut *req ?= hyper_code::HYPERE_INVALID_ARG); - *req.0.version_mut() = match version { - super::HYPER_HTTP_VERSION_NONE => Version::HTTP_11, - super::HYPER_HTTP_VERSION_1_0 => Version::HTTP_10, - super::HYPER_HTTP_VERSION_1_1 => Version::HTTP_11, - super::HYPER_HTTP_VERSION_2 => Version::HTTP_2, - _ => { - // We don't know this version - return hyper_code::HYPERE_INVALID_ARG; - } - }; - hyper_code::HYPERE_OK - } -} - -ffi_fn! { - /// Gets a mutable reference to the HTTP headers of this request - /// - /// This is not an owned reference, so it should not be accessed after the - /// `hyper_request` has been consumed. - fn hyper_request_headers(req: *mut hyper_request) -> *mut hyper_headers { - hyper_headers::get_or_default(unsafe { &mut *req }.0.extensions_mut()) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Set the body of the request. - /// - /// You can get a `hyper_body` by calling `hyper_body_new`. - /// - /// This takes ownership of the `hyper_body *`, you must not use it or - /// free it after setting it on the request. - fn hyper_request_set_body(req: *mut hyper_request, body: *mut hyper_body) -> hyper_code { - let body = non_null!(Box::from_raw(body) ?= hyper_code::HYPERE_INVALID_ARG); - let req = non_null!(&mut *req ?= hyper_code::HYPERE_INVALID_ARG); - *req.0.body_mut() = body.0; - hyper_code::HYPERE_OK - } -} - -ffi_fn! { - /// Set an informational (1xx) response callback. - /// - /// The callback is called each time hyper receives an informational (1xx) - /// response for this request. - /// - /// The third argument is an opaque user data pointer, which is passed to - /// the callback each time. - /// - /// The callback is passed the `void *` data pointer, and a - /// `hyper_response *` which can be inspected as any other response. The - /// body of the response will always be empty. - /// - /// NOTE: The `hyper_response *` is just borrowed data, and will not - /// be valid after the callback finishes. You must copy any data you wish - /// to persist. - fn hyper_request_on_informational(req: *mut hyper_request, callback: hyper_request_on_informational_callback, data: *mut c_void) -> hyper_code { - #[cfg(feature = "client")] - { - let ext = OnInformational { - func: callback, - data: UserDataPointer(data), - }; - let req = non_null!(&mut *req ?= hyper_code::HYPERE_INVALID_ARG); - crate::ext::on_informational_raw(&mut req.0, ext); - hyper_code::HYPERE_OK - } - #[cfg(not(feature = "client"))] - { - drop((req, callback, data)); - hyper_code::HYPERE_FEATURE_NOT_ENABLED - } - } -} - -impl hyper_request { - pub(super) fn finalize_request(&mut self) { - if let Some(headers) = self.0.extensions_mut().remove::() { - *self.0.headers_mut() = headers.headers; - self.0.extensions_mut().insert(headers.orig_casing); - self.0.extensions_mut().insert(headers.orig_order); - } - } -} - -// ===== impl hyper_response ===== - -ffi_fn! { - /// Free an HTTP response. - /// - /// This should be used for any response once it is no longer needed. - fn hyper_response_free(resp: *mut hyper_response) { - drop(non_null!(Box::from_raw(resp) ?= ())); - } -} - -ffi_fn! { - /// Get the HTTP-Status code of this response. - /// - /// It will always be within the range of 100-599. - fn hyper_response_status(resp: *const hyper_response) -> u16 { - non_null!(&*resp ?= 0).0.status().as_u16() - } -} - -ffi_fn! { - /// Get a pointer to the reason-phrase of this response. - /// - /// This buffer is not null-terminated. - /// - /// This buffer is owned by the response, and should not be used after - /// the response has been freed. - /// - /// Use `hyper_response_reason_phrase_len()` to get the length of this - /// buffer. - fn hyper_response_reason_phrase(resp: *const hyper_response) -> *const u8 { - non_null!(&*resp ?= std::ptr::null()).reason_phrase().as_ptr() - } ?= std::ptr::null() -} - -ffi_fn! { - /// Get the length of the reason-phrase of this response. - /// - /// Use `hyper_response_reason_phrase()` to get the buffer pointer. - fn hyper_response_reason_phrase_len(resp: *const hyper_response) -> size_t { - non_null!(&*resp ?= 0).reason_phrase().len() - } -} - -ffi_fn! { - /// Get the HTTP version used by this response. - /// - /// The returned value could be: - /// - /// - `HYPER_HTTP_VERSION_1_0` - /// - `HYPER_HTTP_VERSION_1_1` - /// - `HYPER_HTTP_VERSION_2` - /// - `HYPER_HTTP_VERSION_NONE` if newer (or older). - fn hyper_response_version(resp: *const hyper_response) -> c_int { - use http::Version; - - match non_null!(&*resp ?= 0).0.version() { - Version::HTTP_10 => super::HYPER_HTTP_VERSION_1_0, - Version::HTTP_11 => super::HYPER_HTTP_VERSION_1_1, - Version::HTTP_2 => super::HYPER_HTTP_VERSION_2, - _ => super::HYPER_HTTP_VERSION_NONE, - } - } -} - -ffi_fn! { - /// Gets a reference to the HTTP headers of this response. - /// - /// This is not an owned reference, so it should not be accessed after the - /// `hyper_response` has been freed. - fn hyper_response_headers(resp: *mut hyper_response) -> *mut hyper_headers { - hyper_headers::get_or_default(unsafe { &mut *resp }.0.extensions_mut()) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Take ownership of the body of this response. - /// - /// It is safe to free the response even after taking ownership of its body. - /// - /// To avoid a memory leak, the body must eventually be consumed by - /// `hyper_body_free`, `hyper_body_foreach`, or `hyper_request_set_body`. - fn hyper_response_body(resp: *mut hyper_response) -> *mut hyper_body { - let body = std::mem::replace(non_null!(&mut *resp ?= std::ptr::null_mut()).0.body_mut(), IncomingBody::empty()); - Box::into_raw(Box::new(hyper_body(body))) - } ?= std::ptr::null_mut() -} - -impl hyper_response { - pub(super) fn wrap(mut resp: Response) -> hyper_response { - let headers = std::mem::take(resp.headers_mut()); - let orig_casing = resp - .extensions_mut() - .remove::() - .unwrap_or_else(HeaderCaseMap::default); - let orig_order = resp - .extensions_mut() - .remove::() - .unwrap_or_else(OriginalHeaderOrder::default); - resp.extensions_mut().insert(hyper_headers { - headers, - orig_casing, - orig_order, - }); - - hyper_response(resp) - } - - fn reason_phrase(&self) -> &[u8] { - if let Some(reason) = self.0.extensions().get::() { - return reason.as_bytes(); - } - - if let Some(reason) = self.0.status().canonical_reason() { - return reason.as_bytes(); - } - - &[] - } -} - -unsafe impl AsTaskType for hyper_response { - fn as_task_type(&self) -> hyper_task_return_type { - hyper_task_return_type::HYPER_TASK_RESPONSE - } -} - -// ===== impl Headers ===== - -type hyper_headers_foreach_callback = - extern "C" fn(*mut c_void, *const u8, size_t, *const u8, size_t) -> c_int; - -impl hyper_headers { - pub(super) fn get_or_default(ext: &mut http::Extensions) -> &mut hyper_headers { - if let None = ext.get_mut::() { - ext.insert(hyper_headers::default()); - } - - ext.get_mut::().unwrap() - } -} - -ffi_fn! { - /// Iterates the headers passing each name and value pair to the callback. - /// - /// The `userdata` pointer is also passed to the callback. - /// - /// The callback should return `HYPER_ITER_CONTINUE` to keep iterating, or - /// `HYPER_ITER_BREAK` to stop. - fn hyper_headers_foreach(headers: *const hyper_headers, func: hyper_headers_foreach_callback, userdata: *mut c_void) { - let headers = non_null!(&*headers ?= ()); - // For each header name/value pair, there may be a value in the casemap - // that corresponds to the HeaderValue. So, we iterator all the keys, - // and for each one, try to pair the originally cased name with the value. - // - // TODO: consider adding http::HeaderMap::entries() iterator - let mut ordered_iter = headers.orig_order.get_in_order().peekable(); - if ordered_iter.peek().is_some() { - for (name, idx) in ordered_iter { - let (name_ptr, name_len) = if let Some(orig_name) = headers.orig_casing.get_all(name).nth(*idx) { - (orig_name.as_ref().as_ptr(), orig_name.as_ref().len()) - } else { - ( - name.as_str().as_bytes().as_ptr(), - name.as_str().as_bytes().len(), - ) - }; - - let val_ptr; - let val_len; - if let Some(value) = headers.headers.get_all(name).iter().nth(*idx) { - val_ptr = value.as_bytes().as_ptr(); - val_len = value.as_bytes().len(); - } else { - // Stop iterating, something has gone wrong. - return; - } - - if HYPER_ITER_CONTINUE != func(userdata, name_ptr, name_len, val_ptr, val_len) { - return; - } - } - } else { - for name in headers.headers.keys() { - let mut names = headers.orig_casing.get_all(name); - - for value in headers.headers.get_all(name) { - let (name_ptr, name_len) = if let Some(orig_name) = names.next() { - (orig_name.as_ref().as_ptr(), orig_name.as_ref().len()) - } else { - ( - name.as_str().as_bytes().as_ptr(), - name.as_str().as_bytes().len(), - ) - }; - - let val_ptr = value.as_bytes().as_ptr(); - let val_len = value.as_bytes().len(); - - if HYPER_ITER_CONTINUE != func(userdata, name_ptr, name_len, val_ptr, val_len) { - return; - } - } - } - } - } -} - -ffi_fn! { - /// Sets the header with the provided name to the provided value. - /// - /// This overwrites any previous value set for the header. - fn hyper_headers_set(headers: *mut hyper_headers, name: *const u8, name_len: size_t, value: *const u8, value_len: size_t) -> hyper_code { - let headers = non_null!(&mut *headers ?= hyper_code::HYPERE_INVALID_ARG); - match unsafe { raw_name_value(name, name_len, value, value_len) } { - Ok((name, value, orig_name)) => { - headers.headers.insert(&name, value); - headers.orig_casing.insert(name.clone(), orig_name.clone()); - headers.orig_order.insert(name); - hyper_code::HYPERE_OK - } - Err(code) => code, - } - } -} - -ffi_fn! { - /// Adds the provided value to the list of the provided name. - /// - /// If there were already existing values for the name, this will append the - /// new value to the internal list. - fn hyper_headers_add(headers: *mut hyper_headers, name: *const u8, name_len: size_t, value: *const u8, value_len: size_t) -> hyper_code { - let headers = non_null!(&mut *headers ?= hyper_code::HYPERE_INVALID_ARG); - - match unsafe { raw_name_value(name, name_len, value, value_len) } { - Ok((name, value, orig_name)) => { - headers.headers.append(&name, value); - headers.orig_casing.append(&name, orig_name.clone()); - headers.orig_order.append(name); - hyper_code::HYPERE_OK - } - Err(code) => code, - } - } -} - -impl Default for hyper_headers { - fn default() -> Self { - Self { - headers: Default::default(), - orig_casing: HeaderCaseMap::default(), - orig_order: OriginalHeaderOrder::default(), - } - } -} - -unsafe fn raw_name_value( - name: *const u8, - name_len: size_t, - value: *const u8, - value_len: size_t, -) -> Result<(HeaderName, HeaderValue, Bytes), hyper_code> { - let name = std::slice::from_raw_parts(name, name_len); - let orig_name = Bytes::copy_from_slice(name); - let name = match HeaderName::from_bytes(name) { - Ok(name) => name, - Err(_) => return Err(hyper_code::HYPERE_INVALID_ARG), - }; - let value = std::slice::from_raw_parts(value, value_len); - let value = match HeaderValue::from_bytes(value) { - Ok(val) => val, - Err(_) => return Err(hyper_code::HYPERE_INVALID_ARG), - }; - - Ok((name, value, orig_name)) -} - -// ===== impl OnInformational ===== - -#[cfg(feature = "client")] -impl crate::ext::OnInformationalCallback for OnInformational { - fn on_informational(&self, res: http::Response<()>) { - let res = res.map(|()| IncomingBody::empty()); - let mut res = hyper_response::wrap(res); - (self.func)(self.data.0, &mut res); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_headers_foreach_cases_preserved() { - let mut headers = hyper_headers::default(); - - let name1 = b"Set-CookiE"; - let value1 = b"a=b"; - hyper_headers_add( - &mut headers, - name1.as_ptr(), - name1.len(), - value1.as_ptr(), - value1.len(), - ); - - let name2 = b"SET-COOKIE"; - let value2 = b"c=d"; - hyper_headers_add( - &mut headers, - name2.as_ptr(), - name2.len(), - value2.as_ptr(), - value2.len(), - ); - - let mut vec = Vec::::new(); - hyper_headers_foreach(&headers, concat, &mut vec as *mut _ as *mut c_void); - - assert_eq!(vec, b"Set-CookiE: a=b\r\nSET-COOKIE: c=d\r\n"); - - extern "C" fn concat( - vec: *mut c_void, - name: *const u8, - name_len: usize, - value: *const u8, - value_len: usize, - ) -> c_int { - unsafe { - let vec = &mut *(vec as *mut Vec); - let name = std::slice::from_raw_parts(name, name_len); - let value = std::slice::from_raw_parts(value, value_len); - vec.extend(name); - vec.extend(b": "); - vec.extend(value); - vec.extend(b"\r\n"); - } - HYPER_ITER_CONTINUE - } - } - - #[cfg(all(feature = "http1", feature = "ffi"))] - #[test] - fn test_headers_foreach_order_preserved() { - let mut headers = hyper_headers::default(); - - let name1 = b"Set-CookiE"; - let value1 = b"a=b"; - hyper_headers_add( - &mut headers, - name1.as_ptr(), - name1.len(), - value1.as_ptr(), - value1.len(), - ); - - let name2 = b"Content-Encoding"; - let value2 = b"gzip"; - hyper_headers_add( - &mut headers, - name2.as_ptr(), - name2.len(), - value2.as_ptr(), - value2.len(), - ); - - let name3 = b"SET-COOKIE"; - let value3 = b"c=d"; - hyper_headers_add( - &mut headers, - name3.as_ptr(), - name3.len(), - value3.as_ptr(), - value3.len(), - ); - - let mut vec = Vec::::new(); - hyper_headers_foreach(&headers, concat, &mut vec as *mut _ as *mut c_void); - - println!("{}", std::str::from_utf8(&vec).unwrap()); - assert_eq!( - vec, - b"Set-CookiE: a=b\r\nContent-Encoding: gzip\r\nSET-COOKIE: c=d\r\n" - ); - - extern "C" fn concat( - vec: *mut c_void, - name: *const u8, - name_len: usize, - value: *const u8, - value_len: usize, - ) -> c_int { - unsafe { - let vec = &mut *(vec as *mut Vec); - let name = std::slice::from_raw_parts(name, name_len); - let value = std::slice::from_raw_parts(value, value_len); - vec.extend(name); - vec.extend(b": "); - vec.extend(value); - vec.extend(b"\r\n"); - } - HYPER_ITER_CONTINUE - } - } -} diff --git a/vendor/hyper/src/ffi/io.rs b/vendor/hyper/src/ffi/io.rs deleted file mode 100644 index 89978b9e..00000000 --- a/vendor/hyper/src/ffi/io.rs +++ /dev/null @@ -1,198 +0,0 @@ -use std::ffi::c_void; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use super::task::hyper_context; -use crate::ffi::size_t; -use crate::rt::{Read, Write}; - -/// Sentinel value to return from a read or write callback that the operation -/// is pending. -pub const HYPER_IO_PENDING: size_t = 0xFFFFFFFF; -/// Sentinel value to return from a read or write callback that the operation -/// has errored. -pub const HYPER_IO_ERROR: size_t = 0xFFFFFFFE; - -type hyper_io_read_callback = - extern "C" fn(*mut c_void, *mut hyper_context<'_>, *mut u8, size_t) -> size_t; -type hyper_io_write_callback = - extern "C" fn(*mut c_void, *mut hyper_context<'_>, *const u8, size_t) -> size_t; - -/// A read/write handle for a specific connection. -/// -/// This owns a specific TCP or TLS connection for the lifetime of -/// that connection. It contains a read and write callback, as well as a -/// void *userdata. Typically the userdata will point to a struct -/// containing a file descriptor and a TLS context. -/// -/// Methods: -/// -/// - hyper_io_new: Create a new IO type used to represent a transport. -/// - hyper_io_set_read: Set the read function for this IO transport. -/// - hyper_io_set_write: Set the write function for this IO transport. -/// - hyper_io_set_userdata: Set the user data pointer for this IO to some value. -/// - hyper_io_free: Free an IO handle. -pub struct hyper_io { - read: hyper_io_read_callback, - write: hyper_io_write_callback, - userdata: *mut c_void, -} - -ffi_fn! { - /// Create a new IO type used to represent a transport. - /// - /// The read and write functions of this transport should be set with - /// `hyper_io_set_read` and `hyper_io_set_write`. - /// - /// It is expected that the underlying transport is non-blocking. When - /// a read or write callback can't make progress because there is no - /// data available yet, it should use the `hyper_waker` mechanism to - /// arrange to be called again when data is available. - /// - /// To avoid a memory leak, the IO handle must eventually be consumed by - /// `hyper_io_free` or `hyper_clientconn_handshake`. - fn hyper_io_new() -> *mut hyper_io { - Box::into_raw(Box::new(hyper_io { - read: read_noop, - write: write_noop, - userdata: std::ptr::null_mut(), - })) - } ?= std::ptr::null_mut() -} - -ffi_fn! { - /// Free an IO handle. - /// - /// This should only be used if the request isn't consumed by - /// `hyper_clientconn_handshake`. - fn hyper_io_free(io: *mut hyper_io) { - drop(non_null!(Box::from_raw(io) ?= ())); - } -} - -ffi_fn! { - /// Set the user data pointer for this IO to some value. - /// - /// This value is passed as an argument to the read and write callbacks. - fn hyper_io_set_userdata(io: *mut hyper_io, data: *mut c_void) { - non_null!(&mut *io ?= ()).userdata = data; - } -} - -ffi_fn! { - /// Set the read function for this IO transport. - /// - /// Data that is read from the transport should be put in the `buf` pointer, - /// up to `buf_len` bytes. The number of bytes read should be the return value. - /// - /// It is undefined behavior to try to access the bytes in the `buf` pointer, - /// unless you have already written them yourself. It is also undefined behavior - /// to return that more bytes have been written than actually set on the `buf`. - /// - /// If there is no data currently available, the callback should create a - /// `hyper_waker` from its `hyper_context` argument and register the waker - /// with whatever polling mechanism is used to signal when data is available - /// later on. The return value should be `HYPER_IO_PENDING`. See the - /// documentation for `hyper_waker`. - /// - /// If there is an irrecoverable error reading data, then `HYPER_IO_ERROR` - /// should be the return value. - fn hyper_io_set_read(io: *mut hyper_io, func: hyper_io_read_callback) { - non_null!(&mut *io ?= ()).read = func; - } -} - -ffi_fn! { - /// Set the write function for this IO transport. - /// - /// Data from the `buf` pointer should be written to the transport, up to - /// `buf_len` bytes. The number of bytes written should be the return value. - /// - /// If there is no data currently available, the callback should create a - /// `hyper_waker` from its `hyper_context` argument and register the waker - /// with whatever polling mechanism is used to signal when data is available - /// later on. The return value should be `HYPER_IO_PENDING`. See the documentation - /// for `hyper_waker`. - /// - /// If there is an irrecoverable error reading data, then `HYPER_IO_ERROR` - /// should be the return value. - fn hyper_io_set_write(io: *mut hyper_io, func: hyper_io_write_callback) { - non_null!(&mut *io ?= ()).write = func; - } -} - -/// cbindgen:ignore -extern "C" fn read_noop( - _userdata: *mut c_void, - _: *mut hyper_context<'_>, - _buf: *mut u8, - _buf_len: size_t, -) -> size_t { - 0 -} - -/// cbindgen:ignore -extern "C" fn write_noop( - _userdata: *mut c_void, - _: *mut hyper_context<'_>, - _buf: *const u8, - _buf_len: size_t, -) -> size_t { - 0 -} - -impl Read for hyper_io { - fn poll_read( - self: Pin<&mut Self>, - cx: &mut Context<'_>, - mut buf: crate::rt::ReadBufCursor<'_>, - ) -> Poll> { - let buf_ptr = unsafe { buf.as_mut() }.as_mut_ptr() as *mut u8; - let buf_len = buf.remaining(); - - match (self.read)(self.userdata, hyper_context::wrap(cx), buf_ptr, buf_len) { - HYPER_IO_PENDING => Poll::Pending, - HYPER_IO_ERROR => Poll::Ready(Err(std::io::Error::new( - std::io::ErrorKind::Other, - "io error", - ))), - ok => { - // We have to trust that the user's read callback actually - // filled in that many bytes... :( - unsafe { buf.advance(ok) }; - Poll::Ready(Ok(())) - } - } - } -} - -impl Write for hyper_io { - fn poll_write( - self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll> { - let buf_ptr = buf.as_ptr(); - let buf_len = buf.len(); - - match (self.write)(self.userdata, hyper_context::wrap(cx), buf_ptr, buf_len) { - HYPER_IO_PENDING => Poll::Pending, - HYPER_IO_ERROR => Poll::Ready(Err(std::io::Error::new( - std::io::ErrorKind::Other, - "io error", - ))), - ok => Poll::Ready(Ok(ok)), - } - } - - fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } -} - -unsafe impl Send for hyper_io {} -unsafe impl Sync for hyper_io {} diff --git a/vendor/hyper/src/ffi/macros.rs b/vendor/hyper/src/ffi/macros.rs deleted file mode 100644 index 022711ba..00000000 --- a/vendor/hyper/src/ffi/macros.rs +++ /dev/null @@ -1,53 +0,0 @@ -macro_rules! ffi_fn { - ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) -> $ret:ty $body:block ?= $default:expr) => { - $(#[$doc])* - #[no_mangle] - pub extern fn $name($($arg: $arg_ty),*) -> $ret { - use std::panic::{self, AssertUnwindSafe}; - - match panic::catch_unwind(AssertUnwindSafe(move || $body)) { - Ok(v) => v, - Err(_) => { - $default - } - } - } - }; - - ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) -> $ret:ty $body:block) => { - ffi_fn!($(#[$doc])* fn $name($($arg: $arg_ty),*) -> $ret $body ?= { - eprintln!("panic unwind caught, aborting"); - std::process::abort() - }); - }; - - ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) $body:block ?= $default:expr) => { - ffi_fn!($(#[$doc])* fn $name($($arg: $arg_ty),*) -> () $body ?= $default); - }; - - ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) $body:block) => { - ffi_fn!($(#[$doc])* fn $name($($arg: $arg_ty),*) -> () $body); - }; -} - -macro_rules! non_null { - ($ptr:ident, $eval:expr, $err:expr) => {{ - debug_assert!(!$ptr.is_null(), "{:?} must not be null", stringify!($ptr)); - if $ptr.is_null() { - return $err; - } - unsafe { $eval } - }}; - (&*$ptr:ident ?= $err:expr) => {{ - non_null!($ptr, &*$ptr, $err) - }}; - (&mut *$ptr:ident ?= $err:expr) => {{ - non_null!($ptr, &mut *$ptr, $err) - }}; - (Box::from_raw($ptr:ident) ?= $err:expr) => {{ - non_null!($ptr, Box::from_raw($ptr), $err) - }}; - (Arc::from_raw($ptr:ident) ?= $err:expr) => {{ - non_null!($ptr, Arc::from_raw($ptr), $err) - }}; -} diff --git a/vendor/hyper/src/ffi/mod.rs b/vendor/hyper/src/ffi/mod.rs deleted file mode 100644 index cdcbc482..00000000 --- a/vendor/hyper/src/ffi/mod.rs +++ /dev/null @@ -1,99 +0,0 @@ -// We have a lot of c-types in here, stop warning about their names! -#![allow(non_camel_case_types)] -// fmt::Debug isn't helpful on FFI types -#![allow(missing_debug_implementations)] -// unreachable_pub warns `#[no_mangle] pub extern fn` in private mod. -#![allow(unreachable_pub)] - -//! # hyper C API -//! -//! This part of the documentation describes the C API for hyper. That is, how -//! to *use* the hyper library in C code. This is **not** a regular Rust -//! module, and thus it is not accessible in Rust. -//! -//! ## Unstable -//! -//! The C API of hyper is currently **unstable**, which means it's not part of -//! the semver contract as the rest of the Rust API is. Because of that, it's -//! only accessible if `--cfg hyper_unstable_ffi` is passed to `rustc` when -//! compiling. The easiest way to do that is setting the `RUSTFLAGS` -//! environment variable. -//! -//! ## Building -//! -//! The C API is part of the Rust library, but isn't compiled by default. Using -//! `cargo`, staring with `1.64.0`, it can be compiled with the following command: -//! -//! ```notrust -//! RUSTFLAGS="--cfg hyper_unstable_ffi" cargo rustc --crate-type cdylib --features client,http1,http2,ffi -//! ``` - -// We may eventually allow the FFI to be enabled without `client` or `http1`, -// that is why we don't auto enable them as `ffi = ["client", "http1"]` in -// the `Cargo.toml`. -// -// But for now, give a clear message that this compile error is expected. -#[cfg(not(all(feature = "client", feature = "http1")))] -compile_error!("The `ffi` feature currently requires the `client` and `http1` features."); - -#[cfg(not(hyper_unstable_ffi))] -compile_error!( - "\ - The `ffi` feature is unstable, and requires the \ - `RUSTFLAGS='--cfg hyper_unstable_ffi'` environment variable to be set.\ -" -); - -#[macro_use] -mod macros; - -mod body; -mod client; -mod error; -mod http_types; -mod io; -mod task; - -pub use self::body::*; -pub use self::client::*; -pub use self::error::*; -pub use self::http_types::*; -pub use self::io::*; -pub use self::task::*; - -/// Return in iter functions to continue iterating. -pub const HYPER_ITER_CONTINUE: std::ffi::c_int = 0; -/// Return in iter functions to stop iterating. -#[allow(unused)] -pub const HYPER_ITER_BREAK: std::ffi::c_int = 1; - -/// An HTTP Version that is unspecified. -pub const HYPER_HTTP_VERSION_NONE: std::ffi::c_int = 0; -/// The HTTP/1.0 version. -pub const HYPER_HTTP_VERSION_1_0: std::ffi::c_int = 10; -/// The HTTP/1.1 version. -pub const HYPER_HTTP_VERSION_1_1: std::ffi::c_int = 11; -/// The HTTP/2 version. -pub const HYPER_HTTP_VERSION_2: std::ffi::c_int = 20; - -#[derive(Clone)] -struct UserDataPointer(*mut std::ffi::c_void); - -// We don't actually know anything about this pointer, it's up to the user -// to do the right thing. -unsafe impl Send for UserDataPointer {} -unsafe impl Sync for UserDataPointer {} - -/// cbindgen:ignore -static VERSION_CSTR: &str = concat!(env!("CARGO_PKG_VERSION"), "\0"); - -// `core::ffi::c_size_t` is a nightly-only experimental API. -// https://github.com/rust-lang/rust/issues/88345 -type size_t = usize; - -ffi_fn! { - /// Returns a static ASCII (null terminated) string of the hyper version. - fn hyper_version() -> *const std::ffi::c_char { - VERSION_CSTR.as_ptr() as _ - } ?= std::ptr::null() -} diff --git a/vendor/hyper/src/ffi/task.rs b/vendor/hyper/src/ffi/task.rs deleted file mode 100644 index 5b33d42b..00000000 --- a/vendor/hyper/src/ffi/task.rs +++ /dev/null @@ -1,549 +0,0 @@ -use std::ffi::{c_int, c_void}; -use std::future::Future; -use std::pin::Pin; -use std::ptr; -use std::sync::{ - atomic::{AtomicBool, Ordering}, - Arc, Mutex, Weak, -}; -use std::task::{Context, Poll}; - -use futures_util::stream::{FuturesUnordered, Stream}; - -use super::error::hyper_code; -use super::UserDataPointer; - -type BoxFuture = Pin + Send>>; -type BoxAny = Box; - -/// Return in a poll function to indicate it was ready. -pub const HYPER_POLL_READY: c_int = 0; -/// Return in a poll function to indicate it is still pending. -/// -/// The passed in `hyper_waker` should be registered to wake up the task at -/// some later point. -pub const HYPER_POLL_PENDING: c_int = 1; -/// Return in a poll function indicate an error. -pub const HYPER_POLL_ERROR: c_int = 3; - -/// A task executor for `hyper_task`s. -/// -/// A task is a unit of work that may be blocked on IO, and can be polled to -/// make progress on that work. -/// -/// An executor can hold many tasks, included from unrelated HTTP connections. -/// An executor is single threaded. Typically you might have one executor per -/// thread. Or, for simplicity, you may choose one executor per connection. -/// -/// Progress on tasks happens only when `hyper_executor_poll` is called, and only -/// on tasks whose corresponding `hyper_waker` has been called to indicate they -/// are ready to make progress (for instance, because the OS has indicated there -/// is more data to read or more buffer space available to write). -/// -/// Deadlock potential: `hyper_executor_poll` must not be called from within a task's -/// callback. Doing so will result in a deadlock. -/// -/// Methods: -/// -/// - hyper_executor_new: Creates a new task executor. -/// - hyper_executor_push: Push a task onto the executor. -/// - hyper_executor_poll: Polls the executor, trying to make progress on any tasks that have notified that they are ready again. -/// - hyper_executor_free: Frees an executor and any incomplete tasks still part of it. -pub struct hyper_executor { - /// The executor of all task futures. - /// - /// There should never be contention on the mutex, as it is only locked - /// to drive the futures. However, we cannot guarantee proper usage from - /// `hyper_executor_poll()`, which in C could potentially be called inside - /// one of the stored futures. The mutex isn't re-entrant, so doing so - /// would result in a deadlock, but that's better than data corruption. - driver: Mutex>, - - /// The queue of futures that need to be pushed into the `driver`. - /// - /// This is has a separate mutex since `spawn` could be called from inside - /// a future, which would mean the driver's mutex is already locked. - spawn_queue: Mutex>, - - /// This is used to track when a future calls `wake` while we are within - /// `hyper_executor::poll_next`. - is_woken: Arc, -} - -#[derive(Clone)] -pub(crate) struct WeakExec(Weak); - -struct ExecWaker(AtomicBool); - -/// An async task. -/// -/// A task represents a chunk of work that will eventually yield exactly one -/// `hyper_task_value`. Tasks are pushed onto an executor, and that executor is -/// responsible for calling the necessary private functions on the task to make -/// progress. In most cases those private functions will eventually cause read -/// or write callbacks on a `hyper_io` object to be called. -/// -/// Tasks are created by various functions: -/// -/// - hyper_clientconn_handshake: Creates an HTTP client handshake task. -/// - hyper_clientconn_send: Creates a task to send a request on the client connection. -/// - hyper_body_data: Creates a task that will poll a response body for the next buffer of data. -/// - hyper_body_foreach: Creates a task to execute the callback with each body chunk received. -/// -/// Tasks then have a userdata associated with them using `hyper_task_set_userdata``. This -/// is important, for instance, to associate a request id with a given request. When multiple -/// tasks are running on the same executor, this allows distinguishing tasks for different -/// requests. -/// -/// Tasks are then pushed onto an executor, and eventually yielded from hyper_executor_poll: -/// -/// - hyper_executor_push: Push a task onto the executor. -/// - hyper_executor_poll: Polls the executor, trying to make progress on any tasks that have notified that they are ready again. -/// -/// Once a task is yielded from poll, retrieve its userdata, check its type, -/// and extract its value. This will require a case from void* to the appropriate type. -/// -/// Methods on hyper_task: -/// -/// - hyper_task_type: Query the return type of this task. -/// - hyper_task_value: Takes the output value of this task. -/// - hyper_task_set_userdata: Set a user data pointer to be associated with this task. -/// - hyper_task_userdata: Retrieve the userdata that has been set via hyper_task_set_userdata. -/// - hyper_task_free: Free a task. -pub struct hyper_task { - future: BoxFuture, - output: Option, - userdata: UserDataPointer, -} - -struct TaskFuture { - task: Option>, -} - -/// An async context for a task that contains the related waker. -/// -/// This is provided to `hyper_io`'s read and write callbacks. Currently -/// its only purpose is to provide access to the waker. See `hyper_waker`. -/// -/// Corresponding Rust type: -pub struct hyper_context<'a>(Context<'a>); - -/// A waker that is saved and used to waken a pending task. -/// -/// This is provided to `hyper_io`'s read and write callbacks via `hyper_context` -/// and `hyper_context_waker`. -/// -/// When nonblocking I/O in one of those callbacks can't make progress (returns -/// `EAGAIN` or `EWOULDBLOCK`), the callback has to return to avoid blocking the -/// executor. But it also has to arrange to get called in the future when more -/// data is available. That's the role of the async context and the waker. The -/// waker can be used to tell the executor "this task is ready to make progress." -/// -/// The read or write callback, upon finding it can't make progress, must get a -/// waker from the context (`hyper_context_waker`), arrange for that waker to be -/// called in the future, and then return `HYPER_POLL_PENDING`. -/// -/// The arrangements for the waker to be called in the future are up to the -/// application, but usually it will involve one big `select(2)` loop that checks which -/// FDs are ready, and a correspondence between FDs and waker objects. For each -/// FD that is ready, the corresponding waker must be called. Then `hyper_executor_poll` -/// must be called. That will cause the executor to attempt to make progress on each -/// woken task. -/// -/// Corresponding Rust type: -pub struct hyper_waker { - waker: std::task::Waker, -} - -/// A descriptor for what type a `hyper_task` value is. -#[repr(C)] -pub enum hyper_task_return_type { - /// The value of this task is null (does not imply an error). - HYPER_TASK_EMPTY, - /// The value of this task is `hyper_error *`. - HYPER_TASK_ERROR, - /// The value of this task is `hyper_clientconn *`. - HYPER_TASK_CLIENTCONN, - /// The value of this task is `hyper_response *`. - HYPER_TASK_RESPONSE, - /// The value of this task is `hyper_buf *`. - HYPER_TASK_BUF, -} - -pub(crate) unsafe trait AsTaskType { - fn as_task_type(&self) -> hyper_task_return_type; -} - -pub(crate) trait IntoDynTaskType { - fn into_dyn_task_type(self) -> BoxAny; -} - -// ===== impl hyper_executor ===== - -impl hyper_executor { - fn new() -> Arc { - Arc::new(hyper_executor { - driver: Mutex::new(FuturesUnordered::new()), - spawn_queue: Mutex::new(Vec::new()), - is_woken: Arc::new(ExecWaker(AtomicBool::new(false))), - }) - } - - pub(crate) fn downgrade(exec: &Arc) -> WeakExec { - WeakExec(Arc::downgrade(exec)) - } - - fn spawn(&self, task: Box) { - self.spawn_queue - .lock() - .unwrap() - .push(TaskFuture { task: Some(task) }); - } - - fn poll_next(&self) -> Option> { - // Drain the queue first. - self.drain_queue(); - - let waker = futures_util::task::waker_ref(&self.is_woken); - let mut cx = Context::from_waker(&waker); - - loop { - { - // Scope the lock on the driver to ensure it is dropped before - // calling drain_queue below. - let mut driver = self.driver.lock().unwrap(); - match Pin::new(&mut *driver).poll_next(&mut cx) { - Poll::Ready(val) => return val, - Poll::Pending => {} - }; - } - - // poll_next returned Pending. - // Check if any of the pending tasks tried to spawn - // some new tasks. If so, drain into the driver and loop. - if self.drain_queue() { - continue; - } - - // If the driver called `wake` while we were polling, - // we should poll again immediately! - if self.is_woken.0.swap(false, Ordering::SeqCst) { - continue; - } - - return None; - } - } - - /// drain_queue locks both self.spawn_queue and self.driver, so it requires - /// that neither of them be locked already. - fn drain_queue(&self) -> bool { - let mut queue = self.spawn_queue.lock().unwrap(); - if queue.is_empty() { - return false; - } - - let driver = self.driver.lock().unwrap(); - - for task in queue.drain(..) { - driver.push(task); - } - - true - } -} - -impl futures_util::task::ArcWake for ExecWaker { - fn wake_by_ref(me: &Arc) { - me.0.store(true, Ordering::SeqCst); - } -} - -// ===== impl WeakExec ===== - -impl WeakExec { - pub(crate) fn new() -> Self { - WeakExec(Weak::new()) - } -} - -impl crate::rt::Executor for WeakExec -where - F: Future + Send + 'static, - F::Output: Send + Sync + AsTaskType, -{ - fn execute(&self, fut: F) { - if let Some(exec) = self.0.upgrade() { - exec.spawn(hyper_task::boxed(fut)); - } - } -} - -ffi_fn! { - /// Creates a new task executor. - /// - /// To avoid a memory leak, the executor must eventually be consumed by - /// `hyper_executor_free`. - fn hyper_executor_new() -> *const hyper_executor { - Arc::into_raw(hyper_executor::new()) - } ?= ptr::null() -} - -ffi_fn! { - /// Frees an executor and any incomplete tasks still part of it. - /// - /// This should be used for any executor once it is no longer needed. - fn hyper_executor_free(exec: *const hyper_executor) { - drop(non_null!(Arc::from_raw(exec) ?= ())); - } -} - -ffi_fn! { - /// Push a task onto the executor. - /// - /// The executor takes ownership of the task, which must not be accessed - /// again. - /// - /// Ownership of the task will eventually be returned to the user from - /// `hyper_executor_poll`. - /// - /// To distinguish multiple tasks running on the same executor, use - /// hyper_task_set_userdata. - fn hyper_executor_push(exec: *const hyper_executor, task: *mut hyper_task) -> hyper_code { - let exec = non_null!(&*exec ?= hyper_code::HYPERE_INVALID_ARG); - let task = non_null!(Box::from_raw(task) ?= hyper_code::HYPERE_INVALID_ARG); - exec.spawn(task); - hyper_code::HYPERE_OK - } -} - -ffi_fn! { - /// Polls the executor, trying to make progress on any tasks that can do so. - /// - /// If any task from the executor is ready, returns one of them. The way - /// tasks signal being finished is internal to Hyper. The order in which tasks - /// are returned is not guaranteed. Use userdata to distinguish between tasks. - /// - /// To avoid a memory leak, the task must eventually be consumed by - /// `hyper_task_free`. - /// - /// If there are no ready tasks, this returns `NULL`. - fn hyper_executor_poll(exec: *const hyper_executor) -> *mut hyper_task { - let exec = non_null!(&*exec ?= ptr::null_mut()); - match exec.poll_next() { - Some(task) => Box::into_raw(task), - None => ptr::null_mut(), - } - } ?= ptr::null_mut() -} - -// ===== impl hyper_task ===== - -impl hyper_task { - pub(crate) fn boxed(fut: F) -> Box - where - F: Future + Send + 'static, - F::Output: IntoDynTaskType + Send + Sync + 'static, - { - Box::new(hyper_task { - future: Box::pin(async move { fut.await.into_dyn_task_type() }), - output: None, - userdata: UserDataPointer(ptr::null_mut()), - }) - } - - fn output_type(&self) -> hyper_task_return_type { - match self.output { - None => hyper_task_return_type::HYPER_TASK_EMPTY, - Some(ref val) => val.as_task_type(), - } - } -} - -impl Future for TaskFuture { - type Output = Box; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - match Pin::new(&mut self.task.as_mut().unwrap().future).poll(cx) { - Poll::Ready(val) => { - let mut task = self.task.take().unwrap(); - task.output = Some(val); - Poll::Ready(task) - } - Poll::Pending => Poll::Pending, - } - } -} - -ffi_fn! { - /// Free a task. - /// - /// This should only be used if the task isn't consumed by - /// `hyper_clientconn_handshake` or taken ownership of by - /// `hyper_executor_push`. - fn hyper_task_free(task: *mut hyper_task) { - drop(non_null!(Box::from_raw(task) ?= ())); - } -} - -ffi_fn! { - /// Takes the output value of this task. - /// - /// This must only be called once polling the task on an executor has finished - /// this task. - /// - /// Use `hyper_task_type` to determine the type of the `void *` return value. - /// - /// To avoid a memory leak, a non-empty return value must eventually be - /// consumed by a function appropriate for its type, one of - /// `hyper_error_free`, `hyper_clientconn_free`, `hyper_response_free`, or - /// `hyper_buf_free`. - fn hyper_task_value(task: *mut hyper_task) -> *mut c_void { - let task = non_null!(&mut *task ?= ptr::null_mut()); - - if let Some(val) = task.output.take() { - let p = Box::into_raw(val) as *mut c_void; - // protect from returning fake pointers to empty types - if p == std::ptr::NonNull::::dangling().as_ptr() { - ptr::null_mut() - } else { - p - } - } else { - ptr::null_mut() - } - } ?= ptr::null_mut() -} - -ffi_fn! { - /// Query the return type of this task. - fn hyper_task_type(task: *mut hyper_task) -> hyper_task_return_type { - // instead of blowing up spectacularly, just say this null task - // doesn't have a value to retrieve. - non_null!(&*task ?= hyper_task_return_type::HYPER_TASK_EMPTY).output_type() - } -} - -ffi_fn! { - /// Set a user data pointer to be associated with this task. - /// - /// This value will be passed to task callbacks, and can be checked later - /// with `hyper_task_userdata`. - /// - /// This is useful for telling apart tasks for different requests that are - /// running on the same executor. - fn hyper_task_set_userdata(task: *mut hyper_task, userdata: *mut c_void) { - if task.is_null() { - return; - } - - unsafe { (*task).userdata = UserDataPointer(userdata) }; - } -} - -ffi_fn! { - /// Retrieve the userdata that has been set via `hyper_task_set_userdata`. - fn hyper_task_userdata(task: *mut hyper_task) -> *mut c_void { - non_null!(&*task ?= ptr::null_mut()).userdata.0 - } ?= ptr::null_mut() -} - -// ===== impl AsTaskType ===== - -unsafe impl AsTaskType for () { - fn as_task_type(&self) -> hyper_task_return_type { - hyper_task_return_type::HYPER_TASK_EMPTY - } -} - -unsafe impl AsTaskType for crate::Error { - fn as_task_type(&self) -> hyper_task_return_type { - hyper_task_return_type::HYPER_TASK_ERROR - } -} - -impl IntoDynTaskType for T -where - T: AsTaskType + Send + Sync + 'static, -{ - fn into_dyn_task_type(self) -> BoxAny { - Box::new(self) - } -} - -impl IntoDynTaskType for crate::Result -where - T: IntoDynTaskType + Send + Sync + 'static, -{ - fn into_dyn_task_type(self) -> BoxAny { - match self { - Ok(val) => val.into_dyn_task_type(), - Err(err) => Box::new(err), - } - } -} - -impl IntoDynTaskType for Option -where - T: IntoDynTaskType + Send + Sync + 'static, -{ - fn into_dyn_task_type(self) -> BoxAny { - match self { - Some(val) => val.into_dyn_task_type(), - None => ().into_dyn_task_type(), - } - } -} - -// ===== impl hyper_context ===== - -impl hyper_context<'_> { - pub(crate) fn wrap<'a, 'b>(cx: &'a mut Context<'b>) -> &'a mut hyper_context<'b> { - // A struct with only one field has the same layout as that field. - unsafe { std::mem::transmute::<&mut Context<'_>, &mut hyper_context<'_>>(cx) } - } -} - -ffi_fn! { - /// Creates a waker associated with the task context. - /// - /// The waker can be used to inform the task's executor that the task is - /// ready to make progress (using `hyper_waker_wake``). - /// - /// Typically this only needs to be called once, but it can be called - /// multiple times, returning a new waker each time. - /// - /// To avoid a memory leak, the waker must eventually be consumed by - /// `hyper_waker_free` or `hyper_waker_wake`. - fn hyper_context_waker(cx: *mut hyper_context<'_>) -> *mut hyper_waker { - let waker = non_null!(&mut *cx ?= ptr::null_mut()).0.waker().clone(); - Box::into_raw(Box::new(hyper_waker { waker })) - } ?= ptr::null_mut() -} - -// ===== impl hyper_waker ===== - -ffi_fn! { - /// Free a waker. - /// - /// This should only be used if the request isn't consumed by - /// `hyper_waker_wake`. - fn hyper_waker_free(waker: *mut hyper_waker) { - drop(non_null!(Box::from_raw(waker) ?= ())); - } -} - -ffi_fn! { - /// Wake up the task associated with a waker. - /// - /// This does not do work towards associated task. Instead, it signals - /// to the task's executor that the task is ready to make progress. The - /// application is responsible for calling hyper_executor_poll, which - /// will in turn do work on all tasks that are ready to make progress. - /// - /// NOTE: This consumes the waker. You should not use or free the waker afterwards. - fn hyper_waker_wake(waker: *mut hyper_waker) { - let waker = non_null!(Box::from_raw(waker) ?= ()); - waker.waker.wake(); - } -} -- cgit v1.2.3