Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 53788ddc authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Use quiche 0.17.1" am: 1dc98ce0 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/DnsResolver/+/2535586



Change-Id: Ie3ec82a0ebc9a8ace92beba75aeb8f4bf5d95b0e
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 617f7d5f 1dc98ce0

doh/config.rs

+4 −2
Original line number Diff line number Diff line
@@ -292,7 +292,9 @@ async fn quiche_connect() { 
    let mut config =

        Config::from_key(&Key { cert_path: None, max_idle_timeout: 10, enable_early_data: true })

            .unwrap();

    let socket_addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 42));

    let local = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 42));

    let peer = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 41));

    let conn_id = quiche::ConnectionId::from_ref(&[]);

    quiche::connect(None, &conn_id, socket_addr, config.take().await.deref_mut()).unwrap();



    quiche::connect(None, &conn_id, local, peer, config.take().await.deref_mut()).unwrap();

}

doh/connection/driver.rs

+5 −2
Original line number Diff line number Diff line
@@ -217,7 +217,8 @@ impl Driver { 
            }

            // If we got packets from our peer, pass them to quiche

            Ok((size, from)) = self.socket.recv_from(self.buffer.as_mut()) => {

                self.quiche_conn.recv(&mut self.buffer[..size], quiche::RecvInfo { from })?;

                let local = self.socket.local_addr()?;

                self.quiche_conn.recv(&mut self.buffer[..size], quiche::RecvInfo { from, to: local })?;

                debug!("Received {} bytes on network {}", size, self.net_id);

            }

        };
@@ -299,7 +300,9 @@ impl H3Driver { 
            }

            // If we got packets from our peer, pass them to quiche

            Ok((size, from)) = self.driver.socket.recv_from(self.driver.buffer.as_mut()) => {

                self.driver.quiche_conn.recv(&mut self.driver.buffer[..size], quiche::RecvInfo { from }).map(|_| ())?;

                let local = self.driver.socket.local_addr()?;

                self.driver.quiche_conn.recv(&mut self.driver.buffer[..size], quiche::RecvInfo { from, to: local }).map(|_| ())?;



                debug!("Received {} bytes on network {}", size, self.driver.net_id);

            }

        };

doh/connection/mod.rs

+4 −2
Original line number Diff line number Diff line
@@ -140,8 +140,11 @@ impl Connection { 
        let (request_tx, request_rx) = mpsc::channel(Self::MAX_PENDING_REQUESTS);

        let (status_tx, status_rx) = watch::channel(Status::QUIC);

        let scid = new_scid();

        let socket = build_socket(to, socket_mark, tag_socket).await?;

        let from = socket.local_addr()?;



        let mut quiche_conn =

            quiche::connect(server_name, &quiche::ConnectionId::from_ref(&scid), to, config)?;

            quiche::connect(server_name, &quiche::ConnectionId::from_ref(&scid), from, to, config)?;



        // We will fall back to a full handshake if the session is expired.

        if let Some(session) = session {
@@ -149,7 +152,6 @@ impl Connection { 
            quiche_conn.set_session(&session)?;

        }



        let socket = build_socket(to, socket_mark, tag_socket).await?;

        let driver = async move {

            let result = drive(request_rx, status_tx, quiche_conn, socket, net_id).await;

            if let Err(ref e) = result {

doh/tests/doh_frontend/src/client.rs

+11 −5
Original line number Diff line number Diff line
@@ -202,8 +202,12 @@ impl Client { 


    // Processes the packet received from the frontend socket. If |data| is a DoH query,

    // the function returns the wire format DNS query; otherwise, it returns empty vector.

    pub fn handle_frontend_message(&mut self, data: &mut [u8]) -> Result<Vec<u8>> {

        let recv_info = quiche::RecvInfo { from: self.addr };

    pub fn handle_frontend_message(

        &mut self,

        data: &mut [u8],

        local: &SocketAddr,

    ) -> Result<Vec<u8>> {

        let recv_info = quiche::RecvInfo { from: self.addr, to: *local };

        self.conn.recv(data, recv_info)?;



        if (self.conn.is_in_early_data() || self.conn.is_established()) && self.h3_conn.is_none() {
@@ -282,7 +286,8 @@ impl ClientMap { 
    pub fn get_or_create(

        &mut self,

        hdr: &quiche::Header,

        addr: &SocketAddr,

        peer: &SocketAddr,

        local: &SocketAddr,

    ) -> Result<&mut Client> {

        let conn_id = get_conn_id(hdr)?;

        let client = match self.clients.entry(conn_id.clone()) {
@@ -296,10 +301,11 @@ impl ClientMap { 
                let conn = quiche::accept(

                    &quiche::ConnectionId::from_ref(&conn_id),

                    None, /* odcid */

                    *addr,

                    *local,

                    *peer,

                    &mut self.config,

                )?;

                let client = Client::new(conn, addr, conn_id.clone());

                let client = Client::new(conn, peer, conn_id.clone());

                info!("New client: {:?}", client);

                vacant.insert(client)

            }

doh/tests/doh_frontend/src/dns_https_frontend.rs

+5 −4
Original line number Diff line number Diff line
@@ -309,8 +309,8 @@ async fn worker_thread(params: WorkerParams) -> Result<()> { 
                }

            }



            Ok((len, src)) = frontend_socket.recv_from(&mut frontend_buf) => {

                debug!("Got {} bytes from {}", len, src);

            Ok((len, peer)) = frontend_socket.recv_from(&mut frontend_buf) => {

                debug!("Got {} bytes from {}", len, peer);



                // Parse QUIC packet.

                let pkt_buf = &mut frontend_buf[..len];
@@ -323,7 +323,8 @@ async fn worker_thread(params: WorkerParams) -> Result<()> { 
                };

                debug!("Got QUIC packet: {:?}", hdr);



                let client = match clients.get_or_create(&hdr, &src) {

                let local = frontend_socket.local_addr()?;

                let client = match clients.get_or_create(&hdr, &peer, &local) {

                    Ok(v) => v,

                    Err(e) => {

                        error!("Failed to get the client by the hdr {:?}: {}", hdr, e);
@@ -332,7 +333,7 @@ async fn worker_thread(params: WorkerParams) -> Result<()> { 
                };

                debug!("Got client: {:?}", client);



                match client.handle_frontend_message(pkt_buf) {

                match client.handle_frontend_message(pkt_buf, &local) {

                    Ok(v) if !v.is_empty() => {

                        delay_queries_buffer.push(v);

                        queries_received += 1;