Merge "Use quiche 0.17.1" (1dc98ce0) · Commits · e / os / android_packages_modules_DnsResolver

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();
		}

+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);
		}
		};

+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 {

+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)
		}

+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;