Function handle_client_query

src/main.rs:168–257

(
    globals: Arc<Globals>,
    client_ctx: ClientCtx,
    encrypted_packet: Vec<u8>,
)

}

async fn handle_client_query(
    globals: Arc<Globals>,
    client_ctx: ClientCtx,
    encrypted_packet: Vec<u8>,
) -> Result<(), Error> {
    let original_packet_size = encrypted_packet.len();
    ensure!(original_packet_size >= DNS_HEADER_SIZE, "Short packet");
    debug_assert!(DNSCRYPT_QUERY_MIN_OVERHEAD > ANONYMIZED_DNSCRYPT_QUERY_MAGIC.len());
    if globals.anonymized_dns_enabled
        && original_packet_size >= ANONYMIZED_DNSCRYPT_QUERY_MAGIC.len() + DNS_HEADER_SIZE
        && encrypted_packet[..ANONYMIZED_DNSCRYPT_QUERY_MAGIC.len()]
            == ANONYMIZED_DNSCRYPT_QUERY_MAGIC
    {
        return handle_anonymized_dns(
            globals,
            client_ctx,
            &encrypted_packet[ANONYMIZED_DNSCRYPT_QUERY_MAGIC.len()..],
        )
        .await;
    }
    if !globals.dnscrypt_enabled {
        return Ok(());
    }
    let mut dnscrypt_encryption_params_set = vec![];
    for params in &**globals.dnscrypt_encryption_params_set.read() {
        dnscrypt_encryption_params_set.push((*params).clone())
    }
    let over_udp = matches!(&client_ctx, ClientCtx::Udp(_));
    let (enc_params, mut packet) =
        match dnscrypt::decrypt(
            &encrypted_packet,
            &dnscrypt_encryption_params_set,
            &globals.pq_ticket_key,
            globals.pq_enabled,
        ) {
            Ok(x) => x,
            Err(_) => {
                let packet = encrypted_packet;
                match serve_certificates(
                    &packet,
                    &globals.provider_name,
                    &dnscrypt_encryption_params_set,
                    globals.pq_enabled,
                    over_udp,
                ) {
                    Ok(Some(synth_packet)) => {
                        return encrypt_and_respond_to_query(
                            globals,
                            client_ctx,
                            packet,
                            synth_packet,
                            original_packet_size,
                            None,
                        )
                        .await
                    }
                    Ok(None) => return Ok(()),
                    Err(_) => {