Skip to main content

net/
devtools.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5#[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        // Do not forward data requests to devtools
242        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            // Build the partial DevtoolsHttpRequest
251            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}