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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
use crate::{redirect::EffectiveUri, Metrics};
use futures_lite::io::AsyncRead;
use http::{Response, Uri};
use std::{
fs::File,
io::{self, Read, Write},
net::SocketAddr,
path::Path,
};
/// Provides extension methods for working with HTTP responses.
pub trait ResponseExt<T> {
/// Get the effective URI of this response. This value differs from the
/// original URI provided when making the request if at least one redirect
/// was followed.
///
/// This information is only available if populated by the HTTP client that
/// produced the response.
fn effective_uri(&self) -> Option<&Uri>;
/// Get the local socket address of the last-used connection involved in
/// this request, if known.
///
/// Multiple connections may be involved in a request, such as with
/// redirects.
///
/// This method only makes sense with a normal Internet request. If some
/// other kind of transport is used to perform the request, such as a Unix
/// socket, then this method will return `None`.
fn local_addr(&self) -> Option<SocketAddr>;
/// Get the remote socket address of the last-used connection involved in
/// this request, if known.
///
/// Multiple connections may be involved in a request, such as with
/// redirects.
///
/// This method only makes sense with a normal Internet request. If some
/// other kind of transport is used to perform the request, such as a Unix
/// socket, then this method will return `None`.
///
/// # Addresses and proxies
///
/// The address returned by this method is the IP address and port that the
/// client _connected to_ and not necessarily the real address of the origin
/// server. Forward and reverse proxies between the caller and the server
/// can cause the address to be returned to reflect the address of the
/// nearest proxy rather than the server.
fn remote_addr(&self) -> Option<SocketAddr>;
/// Get the configured cookie jar used for persisting cookies from this
/// response, if any.
///
/// # Availability
///
/// This method is only available when the [`cookies`](index.html#cookies)
/// feature is enabled.
#[cfg(feature = "cookies")]
fn cookie_jar(&self) -> Option<&crate::cookies::CookieJar>;
/// If request metrics are enabled for this particular transfer, return a
/// metrics object containing a live view of currently available data.
///
/// By default metrics are disabled and `None` will be returned. To enable
/// metrics you can use
/// [`Configurable::metrics`](crate::config::Configurable::metrics).
fn metrics(&self) -> Option<&Metrics>;
/// Copy the response body into a writer.
///
/// Returns the number of bytes that were written.
fn copy_to(&mut self, writer: impl Write) -> io::Result<u64>
where
T: Read;
/// Write the response body to a file.
///
/// This method makes it convenient to download a file using a GET request
/// and write it to a file synchronously in a single chain of calls.
///
/// Returns the number of bytes that were written.
///
/// # Examples
///
/// ```no_run
/// use isahc::prelude::*;
///
/// isahc::get("https://httpbin.org/image/jpeg")?
/// .copy_to_file("myimage.jpg")?;
/// # Ok::<(), isahc::Error>(())
/// ```
fn copy_to_file(&mut self, path: impl AsRef<Path>) -> io::Result<u64>
where
T: Read,
{
File::create(path).and_then(|f| self.copy_to(f))
}
/// Read the response body as a string.
///
/// The encoding used to decode the response body into a string depends on
/// the response. If the body begins with a [Byte Order Mark
/// (BOM)](https://en.wikipedia.org/wiki/Byte_order_mark), then UTF-8,
/// UTF-16LE or UTF-16BE is used as indicated by the BOM. If no BOM is
/// present, the encoding specified in the `charset` parameter of the
/// `Content-Type` header is used if present. Otherwise UTF-8 is assumed.
///
/// If the response body contains any malformed characters or characters not
/// representable in UTF-8, the offending bytes will be replaced with
/// `U+FFFD REPLACEMENT CHARACTER`, which looks like this: �.
///
/// This method consumes the entire response body stream and can only be
/// called once.
///
/// # Availability
///
/// This method is only available when the
/// [`text-decoding`](index.html#text-decoding) feature is enabled, which it
/// is by default.
///
/// # Examples
///
/// ```no_run
/// use isahc::prelude::*;
///
/// let text = isahc::get("https://example.org")?.text()?;
/// println!("{}", text);
/// # Ok::<(), isahc::Error>(())
/// ```
#[cfg(feature = "text-decoding")]
fn text(&mut self) -> io::Result<String>
where
T: Read;
/// Read the response body as a string asynchronously.
///
/// This method consumes the entire response body stream and can only be
/// called once.
///
/// # Availability
///
/// This method is only available when the
/// [`text-decoding`](index.html#text-decoding) feature is enabled, which it
/// is by default.
#[cfg(feature = "text-decoding")]
fn text_async(&mut self) -> crate::text::TextFuture<'_, &mut T>
where
T: AsyncRead + Unpin;
/// Deserialize the response body as JSON into a given type.
///
/// # Availability
///
/// This method is only available when the [`json`](index.html#json) feature
/// is enabled.
///
/// # Examples
///
/// ```no_run
/// use isahc::prelude::*;
/// use serde_json::Value;
///
/// let json: Value = isahc::get("https://httpbin.org/json")?.json()?;
/// println!("author: {}", json["slideshow"]["author"]);
/// # Ok::<(), Box<dyn std::error::Error>>(())
/// ```
#[cfg(feature = "json")]
fn json<D>(&mut self) -> Result<D, serde_json::Error>
where
D: serde::de::DeserializeOwned,
T: Read;
}
impl<T> ResponseExt<T> for Response<T> {
fn effective_uri(&self) -> Option<&Uri> {
self.extensions().get::<EffectiveUri>().map(|v| &v.0)
}
fn local_addr(&self) -> Option<SocketAddr> {
self.extensions().get::<LocalAddr>().map(|v| v.0)
}
fn remote_addr(&self) -> Option<SocketAddr> {
self.extensions().get::<RemoteAddr>().map(|v| v.0)
}
#[cfg(feature = "cookies")]
fn cookie_jar(&self) -> Option<&crate::cookies::CookieJar> {
self.extensions().get()
}
fn metrics(&self) -> Option<&Metrics> {
self.extensions().get()
}
fn copy_to(&mut self, mut writer: impl Write) -> io::Result<u64>
where
T: Read,
{
io::copy(self.body_mut(), &mut writer)
}
#[cfg(feature = "text-decoding")]
fn text(&mut self) -> io::Result<String>
where
T: Read,
{
crate::text::Decoder::for_response(&self).decode_reader(self.body_mut())
}
#[cfg(feature = "text-decoding")]
fn text_async(&mut self) -> crate::text::TextFuture<'_, &mut T>
where
T: AsyncRead + Unpin,
{
crate::text::Decoder::for_response(&self).decode_reader_async(self.body_mut())
}
#[cfg(feature = "json")]
fn json<D>(&mut self) -> Result<D, serde_json::Error>
where
D: serde::de::DeserializeOwned,
T: Read,
{
serde_json::from_reader(self.body_mut())
}
}
pub(crate) struct LocalAddr(pub(crate) SocketAddr);
pub(crate) struct RemoteAddr(pub(crate) SocketAddr);