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

doh/config.rs

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -292,7 +292,9 @@ async fn quiche_connect() {
	let mut config =		let mut config =
	Config::from_key(&Key { cert_path: None, max_idle_timeout: 10, enable_early_data: true })		Config::from_key(&Key { cert_path: None, max_idle_timeout: 10, enable_early_data: true })
	.unwrap();		.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(&[]);		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	Original line	Diff line number	Diff line
	@@ -217,7 +217,8 @@ impl Driver {
	}		}
	// If we got packets from our peer, pass them to quiche		// If we got packets from our peer, pass them to quiche
	Ok((size, from)) = self.socket.recv_from(self.buffer.as_mut()) => {		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);		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		// If we got packets from our peer, pass them to quiche
	Ok((size, from)) = self.driver.socket.recv_from(self.driver.buffer.as_mut()) => {		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);		debug!("Received {} bytes on network {}", size, self.driver.net_id);
	}		}
	};		};

doh/connection/mod.rs

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -140,8 +140,11 @@ impl Connection {
	let (request_tx, request_rx) = mpsc::channel(Self::MAX_PENDING_REQUESTS);		let (request_tx, request_rx) = mpsc::channel(Self::MAX_PENDING_REQUESTS);
	let (status_tx, status_rx) = watch::channel(Status::QUIC);		let (status_tx, status_rx) = watch::channel(Status::QUIC);
	let scid = new_scid();		let scid = new_scid();
			let socket = build_socket(to, socket_mark, tag_socket).await?;
			let from = socket.local_addr()?;

	let mut quiche_conn =		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.		// We will fall back to a full handshake if the session is expired.
	if let Some(session) = session {		if let Some(session) = session {
	@@ -149,7 +152,6 @@ impl Connection {
	quiche_conn.set_session(&session)?;		quiche_conn.set_session(&session)?;
	}		}

	let socket = build_socket(to, socket_mark, tag_socket).await?;
	let driver = async move {		let driver = async move {
	let result = drive(request_rx, status_tx, quiche_conn, socket, net_id).await;		let result = drive(request_rx, status_tx, quiche_conn, socket, net_id).await;
	if let Err(ref e) = result {		if let Err(ref e) = result {

doh/tests/doh_frontend/src/client.rs

+11 −5

Original line number	Original line	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,		// 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.		// 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>> {		pub fn handle_frontend_message(
	let recv_info = quiche::RecvInfo { from: self.addr };		&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)?;		self.conn.recv(data, recv_info)?;

	if (self.conn.is_in_early_data() \|\| self.conn.is_established()) && self.h3_conn.is_none() {		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(		pub fn get_or_create(
	&mut self,		&mut self,
	hdr: &quiche::Header,		hdr: &quiche::Header,
	addr: &SocketAddr,		peer: &SocketAddr,
			local: &SocketAddr,
	) -> Result<&mut Client> {		) -> Result<&mut Client> {
	let conn_id = get_conn_id(hdr)?;		let conn_id = get_conn_id(hdr)?;
	let client = match self.clients.entry(conn_id.clone()) {		let client = match self.clients.entry(conn_id.clone()) {
	@@ -296,10 +301,11 @@ impl ClientMap {
	let conn = quiche::accept(		let conn = quiche::accept(
	&quiche::ConnectionId::from_ref(&conn_id),		&quiche::ConnectionId::from_ref(&conn_id),
	None, /* odcid */		None, /* odcid */
	*addr,		*local,
			*peer,
	&mut self.config,		&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);		info!("New client: {:?}", client);
	vacant.insert(client)		vacant.insert(client)
	}		}

doh/tests/doh_frontend/src/dns_https_frontend.rs

+5 −4

Original line number	Original line	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) => {		Ok((len, peer)) = frontend_socket.recv_from(&mut frontend_buf) => {
	debug!("Got {} bytes from {}", len, src);		debug!("Got {} bytes from {}", len, peer);

	// Parse QUIC packet.		// Parse QUIC packet.
	let pkt_buf = &mut frontend_buf[..len];		let pkt_buf = &mut frontend_buf[..len];
	@@ -323,7 +323,8 @@ async fn worker_thread(params: WorkerParams) -> Result<()> {
	};		};
	debug!("Got QUIC packet: {:?}", hdr);		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,		Ok(v) => v,
	Err(e) => {		Err(e) => {
	error!("Failed to get the client by the hdr {:?}: {}", hdr, 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);		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() => {		Ok(v) if !v.is_empty() => {
	delay_queries_buffer.push(v);		delay_queries_buffer.push(v);
	queries_received += 1;		queries_received += 1;