Function proxy_websocket_inner

packages/server/src/devtools.rs:347–398

(socket: WebSocket, upstream_url: String)

}

async fn proxy_websocket_inner(socket: WebSocket, upstream_url: String) -> Result<(), String> {
    let mut request = upstream_url
        .as_str()
        .into_client_request()
        .map_err(|error| format!("Invalid DevTools upstream URL: {error}"))?;
    // Metro's React Native dev-middleware rejects inspector WebSocket upgrades
    // whose Origin does not match the dev server itself (HTTP 401). Present the
    // upstream's own origin so the proxied connection is accepted.
    if let Some(origin) = upstream_websocket_origin(&upstream_url) {
        if let Ok(value) = HeaderValue::from_str(&origin) {
            request.headers_mut().insert(header::ORIGIN, value);
        }
    }
    let (upstream, _) = tokio_tungstenite::connect_async(request)
        .await
        .map_err(|error| format!("Unable to connect to DevTools socket: {error}"))?;
    let (mut downstream_writer, mut downstream_reader) = socket.split();
    let (mut upstream_writer, mut upstream_reader) = upstream.split();

    loop {
        tokio::select! {
            downstream = downstream_reader.next() => {
                let Some(message) = downstream else {
                    break;
                };
                let message = message.map_err(|error| format!("Browser WebSocket error: {error}"))?;
                let Some(message) = to_upstream_message(message) else {
                    break;
                };
                upstream_writer
                    .send(message)
                    .await
                    .map_err(|error| format!("Unable to forward browser message to DevTools: {error}"))?;
            }
            upstream = upstream_reader.next() => {
                let Some(message) = upstream else {
                    break;
                };
                let message = message.map_err(|error| format!("DevTools WebSocket error: {error}"))?;
                let Some(message) = to_downstream_message(message) else {
                    break;
                };
                downstream_writer
                    .send(message)
                    .await
                    .map_err(|error| format!("Unable to forward DevTools message to browser: {error}"))?;
            }
        }
    }

    Ok(())
}

fn upstream_websocket_origin(url: &str) -> Option<String> {
    let (scheme, rest) = url