1#[cfg(not(feature = "devtools"))]
6pub(crate) use disabled::{
7 send_early_httprequest_to_devtools, send_response_to_devtools, send_security_info_to_devtools,
8};
9#[cfg(feature = "devtools")]
10pub(crate) use enabled::{
11 DevtoolsBodyBuffer, body_for_devtools, prepare_devtools_request,
12 send_early_httprequest_to_devtools, send_request_to_devtools, send_response_to_devtools,
13 send_response_values_to_devtools, send_security_info_to_devtools,
14};
15
16#[cfg(not(feature = "devtools"))]
17mod disabled {
18 use net_traits::request::Request;
19 use net_traits::response::Response;
20
21 use crate::fetch::methods::FetchContext;
22
23 pub(crate) struct DevtoolsHttpResponseBody;
24
25 #[inline]
26 pub(crate) fn send_early_httprequest_to_devtools(_request: &Request, _context: &FetchContext) {}
27
28 #[inline]
29 pub(crate) fn send_response_to_devtools(
30 _request: &Request,
31 _context: &FetchContext,
32 _response: &Response,
33 _body: Option<DevtoolsHttpResponseBody>,
34 ) {
35 }
36
37 #[inline]
38 pub(crate) fn send_security_info_to_devtools(
39 _request: &Request,
40 _context: &FetchContext,
41 _response: &Response,
42 ) {
43 }
44}
45
46#[cfg(feature = "devtools")]
47mod enabled {
48 use std::time::{Duration, SystemTime, UNIX_EPOCH};
49
50 use bytes::Bytes;
51 use crossbeam_channel::Sender;
52 use devtools_traits::{
53 ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest,
54 HttpResponse as DevtoolsHttpResponse, HttpResponseBody as DevtoolsHttpResponseBody,
55 NetworkEvent, SecurityInfoUpdate,
56 };
57 use http::{HeaderMap, Method};
58 use hyper_serde::Serde;
59 use log::error;
60 use net_traits::Metadata;
61 use net_traits::http_status::HttpStatus;
62 use net_traits::request::{Destination, Request};
63 use net_traits::response::{CacheState, Response};
64 use servo_base::id::{BrowsingContextId, PipelineId};
65 use servo_config::pref;
66 use servo_url::ServoUrl;
67 use uuid::Uuid;
68
69 use crate::fetch::methods::FetchContext;
70
71 #[derive(Default)]
72 pub(crate) struct DevtoolsBodyBuffer {
73 data: Vec<u8>,
74 truncated: bool,
75 total_size: usize,
76 }
77
78 impl DevtoolsBodyBuffer {
79 pub(crate) fn append_chunk(&mut self, chunk: &[u8]) {
80 self.total_size += chunk.len();
81 let limit = pref!(devtools_network_response_body_limit);
82 if limit < 0 {
83 self.data.extend_from_slice(chunk);
84 return;
85 }
86 let remaining = (limit as usize).saturating_sub(self.data.len());
87 if chunk.len() > remaining {
88 self.truncated = true;
89 }
90 self.data
91 .extend_from_slice(&chunk[..chunk.len().min(remaining)]);
92 }
93
94 pub(crate) fn into_response_body(self) -> DevtoolsHttpResponseBody {
95 DevtoolsHttpResponseBody {
96 data: Bytes::from(self.data),
97 truncated: self.truncated,
98 content_size: self.total_size,
99 }
100 }
101 }
102
103 pub(crate) fn body_for_devtools(body: &[u8]) -> (Vec<u8>, bool, usize) {
104 let content_size = body.len();
105 let limit = pref!(devtools_network_response_body_limit);
106 if limit < 0 || body.len() <= limit as usize {
107 return (body.to_vec(), false, content_size);
108 }
109 (body[..limit as usize].to_vec(), true, content_size)
110 }
111
112 #[allow(clippy::too_many_arguments)]
113 pub(crate) fn prepare_devtools_request(
114 request_id: Uuid,
115 url: ServoUrl,
116 method: Method,
117 headers: HeaderMap,
118 body: Option<Vec<u8>>,
119 pipeline_id: PipelineId,
120 connect_time: Duration,
121 send_time: Duration,
122 destination: Destination,
123 is_xhr: bool,
124 browsing_context_id: BrowsingContextId,
125 ) -> ChromeToDevtoolsControlMsg {
126 let started_date_time = SystemTime::now();
127 let request = DevtoolsHttpRequest {
128 url,
129 method,
130 headers,
131 body: body.map(Bytes::from),
132 pipeline_id,
133 started_date_time,
134 time_stamp: started_date_time
135 .duration_since(UNIX_EPOCH)
136 .unwrap_or_default()
137 .as_secs() as i64,
138 connect_time,
139 send_time,
140 destination,
141 is_xhr,
142 browsing_context_id,
143 };
144 let net_event = NetworkEvent::HttpRequestUpdate(request);
145
146 ChromeToDevtoolsControlMsg::NetworkEvent(request_id, net_event)
147 }
148
149 pub(crate) fn send_request_to_devtools(
150 msg: ChromeToDevtoolsControlMsg,
151 devtools_chan: &Sender<DevtoolsControlMsg>,
152 ) {
153 if matches!(msg, ChromeToDevtoolsControlMsg::NetworkEvent(_, ref network_event) if !network_event.forward_to_devtools())
154 {
155 return;
156 }
157 if let Err(e) = devtools_chan.send(DevtoolsControlMsg::FromChrome(msg)) {
158 error!("DevTools send failed: {e}");
159 }
160 }
161
162 pub(crate) fn send_response_to_devtools(
163 request: &Request,
164 context: &FetchContext,
165 response: &Response,
166 body: Option<DevtoolsHttpResponseBody>,
167 ) {
168 let Ok(metadata): Result<Metadata, _> = response.metadata().map(Into::into) else {
169 log::warn!("No metadata available, skipping devtools response.");
170 return;
171 };
172 send_response_values_to_devtools(
173 metadata.headers.map(Serde::into_inner),
174 metadata.status,
175 body,
176 response.cache_state,
177 request,
178 context.devtools_chan.clone(),
179 );
180 }
181
182 pub(crate) fn send_response_values_to_devtools(
183 headers: Option<HeaderMap>,
184 status: HttpStatus,
185 body: Option<DevtoolsHttpResponseBody>,
186 cache_state: CacheState,
187 request: &Request,
188 devtools_chan: Option<Sender<DevtoolsControlMsg>>,
189 ) {
190 if let (Some(devtools_chan), Some(pipeline_id), Some(webview_id)) = (
191 devtools_chan,
192 request.pipeline_id,
193 request.target_webview_id,
194 ) {
195 let browsing_context_id = webview_id.into();
196 let from_cache = matches!(cache_state, CacheState::Local | CacheState::Validated);
197
198 let devtoolsresponse = DevtoolsHttpResponse {
199 headers,
200 status,
201 body,
202 from_cache,
203 pipeline_id,
204 browsing_context_id,
205 };
206 let net_event_response = NetworkEvent::HttpResponse(devtoolsresponse);
207
208 let msg = ChromeToDevtoolsControlMsg::NetworkEvent(request.id.0, net_event_response);
209
210 let _ = devtools_chan.send(DevtoolsControlMsg::FromChrome(msg));
211 }
212 }
213
214 pub(crate) fn send_security_info_to_devtools(
215 request: &Request,
216 context: &FetchContext,
217 response: &Response,
218 ) {
219 let Ok(metadata): Result<Metadata, _> = response.metadata().map(Into::into) else {
220 log::warn!("No metadata available, skipping devtools security info.");
221 return;
222 };
223
224 if let (Some(devtools_chan), Some(security_info), Some(webview_id)) = (
225 context.devtools_chan.clone(),
226 metadata.tls_security_info,
227 request.target_webview_id,
228 ) {
229 let update = NetworkEvent::SecurityInfo(SecurityInfoUpdate {
230 browsing_context_id: webview_id.into(),
231 security_info: Some(security_info),
232 });
233
234 let msg = ChromeToDevtoolsControlMsg::NetworkEvent(request.id.0, update);
235
236 let _ = devtools_chan.send(DevtoolsControlMsg::FromChrome(msg));
237 }
238 }
239
240 pub(crate) fn send_early_httprequest_to_devtools(request: &Request, context: &FetchContext) {
241 if request.url().scheme() == "data" {
243 return;
244 }
245 if let (Some(devtools_chan), Some(browsing_context_id), Some(pipeline_id)) = (
246 context.devtools_chan.as_ref(),
247 request.target_webview_id.map(|id| id.into()),
248 request.pipeline_id,
249 ) {
250 let devtools_request = DevtoolsHttpRequest {
252 url: request.current_url(),
253 method: request.method.clone(),
254 headers: request.headers.clone(),
255 body: None,
256 pipeline_id,
257 started_date_time: SystemTime::now(),
258 time_stamp: 0,
259 connect_time: Duration::from_millis(0),
260 send_time: Duration::from_millis(0),
261 destination: request.destination,
262 is_xhr: false,
263 browsing_context_id,
264 };
265
266 let msg = ChromeToDevtoolsControlMsg::NetworkEvent(
267 request.id.0,
268 NetworkEvent::HttpRequest(devtools_request),
269 );
270
271 send_request_to_devtools(msg, devtools_chan);
272 }
273 }
274}