1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
use http::{Request}; use ::types::CallBuilderImpl; use mio::{Poll,Event}; use tls_api::{TlsConnector}; use ::{Result,WebSocket,Call, CallRef, SendState, RecvState}; /// Used to start a call and get a Call for it. pub struct CallBuilder { } impl CallBuilder { /// If req contains body it will be used. /// /// If req contains no body, but has content-length set, /// it will wait for send body to be provided through Httpc::call_send. /// mio_httpc will set headers (if they are not already): /// user-agent, connection, host, auth, content-length /// If you're only executing a one-off call you should set connection: close as default /// is keep-alive. pub fn new(req: Request<Vec<u8>>) -> CallBuilder { CallBuilder{} } /// Consume and execute HTTP call pub fn call(self, httpc: &mut Httpc, poll: &Poll) -> ::Result<Call> { Err(::Error::NoTls) } /// Consume and start a WebSocket pub fn websocket(self, httpc: &mut Httpc, poll: &Poll) -> ::Result<WebSocket> { Err(::Error::NoTls) } /// Add custom root ca in DER format pub fn add_root_ca_der(self, v: Vec<u8>) -> Self { self } /// Default 10MB. /// /// This will limit how big the internal Vec<u8> can grow. /// HTTP response headers are always stored in internal buffer. /// HTTP response body is stored in internal buffer if no external /// buffer is provided. /// /// For WebSockets this will also be a received fragment size limit! pub fn max_response(self, m: usize) -> Self { self } /// Default: 100ms /// /// Starting point of dns packet resends if nothing received. /// Every next resend timeout is 2x the previous one but stops at 1s. /// So for 100ms: 100ms, 200ms, 400ms, 800ms, 1000ms, 1000ms... pub fn dns_retry_ms(self, n: u64) -> Self { self } /// Default true. /// /// Configurable because it entails copying the data stream. pub fn chunked_parse(self, b: bool) -> Self { self } /// Default 32K /// /// Max size of chunk in a chunked transfer. pub fn chunked_max_chunk(self, v: usize) -> Self { self } /// Default 60s /// /// Maximum amount of time a call should last. pub fn timeout_ms(self, d: u64) -> Self { self } } /// Send requests, receive responses. pub struct Httpc { } impl Httpc { /// Httpc will create connections with mio token in range [con_offset..con_offset+0xFFFF] pub fn new(con_offset: usize) -> Httpc { Httpc { } } pub(crate) fn call<C:TlsConnector>(&mut self, b: CallBuilderImpl, poll: &Poll) -> Result<Call> { Err(::Error::NoTls) } pub(crate) fn peek_body(&mut self, id: &::Call, off: &mut usize) -> &[u8] { &[] } pub(crate) fn try_truncate(&mut self, id: &::Call, off: &mut usize) { } /// Number of currently open connections (in active and idle keep-alive state) pub fn open_connections(&self) -> usize { 0 } /// Reuse a response buffer for subsequent calls. pub fn reuse(&mut self, buf: Vec<u8>) { } /// Prematurely finish call. pub fn call_close(&mut self, id: Call) { } /// Call periodically to check for call timeouts and DNS retries. /// Returns list of calls that have timed out. /// You must execute call_close yourself and timeout will return them /// every time until you do. /// (every 100ms for example) pub fn timeout(&mut self) -> Vec<CallRef> { Vec::new() } /// Same as timeout except that timed out calls get appended. /// This way you can reuse old allocations (if you truncated to 0). pub fn timeout_extend<C:TlsConnector>(&mut self, out: &mut Vec<CallRef>) { } /// Get CallRef for ev if token in configured range for Httpc. /// Compare CallRef external call. /// /// First you must call call_send until you get a SendState::Receiving /// after that call is in receive state and you must call call_recv. pub fn event(&mut self, ev: &Event) -> Option<CallRef> { None } /// If request has body it will be either taken from buf, from Request provided to CallBuilder /// or will return SendState::WaitReqBody. /// /// buf slice is assumed to have taken previous SendState::SentBody(usize) into account /// and starts from part of buffer that has not been sent yet. pub fn call_send(&mut self, poll: &Poll, id: &mut Call, buf: Option<&[u8]>) -> SendState { ::SendState::Error(::Error::NoTls) } /// If no buf provided, response body (if any) is stored in an internal buffer. /// If buf provided after some body has been received, it will be copied to it. /// /// Buf will be expanded if required. Bytes are always appended. If you want to receive /// response entirely in buf, you should reserve capacity for entire body before calling call_recv. /// /// If body is only stored in internal buffer it will be limited to CallBuilder::max_response. pub fn call_recv(&mut self, poll: &Poll, id: &mut Call, buf: Option<&mut Vec<u8>>) -> RecvState { ::RecvState::Error(::Error::NoTls) } }