Hacktoberfest 2026: as issues que os mantenedores marcaram para outubro, abertas e boas para iniciantes. Ver issues do Hacktoberfest

HeaderName from bytes unchecked support

Aberta
  • Algo errado?
#857 0 comentários 1 reação 0 responsáveis Ver no GitHub

Ninguém assumiu esta issue ainda.

Avaliação

Dificuldade
4/5
Tempo estimado
3-5 dias
Facilidade para iniciantes
45/100
Tipo de issue
Funcionalidade
Clareza
Razoavelmente clara
Status de atividade
Pouca atividade
Stack de tecnologia
rust
Domínio
api, backend-api-design

Direção de pesquisa

Comece localizando as APIs existentes de conversão de bytes e parsing de HeaderName e, em seguida, compare-as com as assinaturas propostas de from_bytes_unchecked e parse_hdr_unchecked. Revise os requisitos de segurança e de lifetime antes de decidir como o caminho unchecked deve ser integrado. O trabalho estará concluído quando a API oferecer suporte a bytes de nomes de cabeçalho validados sem validação redundante, preservando as garantias declaradas para entradas inválidas.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

Hello,

I would like to request support for a function that accepts pre-validated HTTP header name tokens. This would allow parsers to skip redundant validation when bytes have already been validated upstream.

Proposed API

/// Converts a slice of bytes to an HTTP header name.
///
/// # Safety
///
/// The caller must ensure that `src` contains only valid HTTP header name tokens.
/// This allows the parser to skip validation and normalization for improved performance.
/// Passing invalid bytes will result in undefined behavior.
pub unsafe fn from_bytes_unchecked(src: &[u8]) -> Result<HeaderName, InvalidHeaderName> {
    let mut buf = uninit_u8_array();
    // SAFETY: see `from_bytes_unchecked` guarantees
    parse_hdr_unchecked(src, &mut buf)?
}

/// # Safety
///
/// The caller must ensure that `data` contains only valid HTTP header name tokens.
unsafe fn parse_hdr_unchecked<'a>(
    data: &'a [u8],
    b: &'a mut [MaybeUninit<u8>; SCRATCH_BUF_SIZE]
) -> Result<HeaderName, InvalidHeaderName> {
    match data.len() {
        0 => Err(InvalidHeaderName::new()),
        len @ 1..=SCRATCH_BUF_SIZE => {
            // Read from data into the buffer
            data.iter()
                .zip(b.iter_mut())
                .for_each(|(byte, out)| *out = MaybeUninit::new(*byte as usize));
            // SAFETY: len bytes of b were just initialized.
            let name: &'a [u8] = unsafe { slice_assume_init(&b[0..len]) };
            match StandardHeader::from_bytes(name) {
                Some(sh) => Ok(sh.into()),
                None => {
                    let buf = Bytes::copy_from_slice(name);
                    // SAFETY: see `parse_hdr_unchecked` guarantees
                    let val = unsafe { ByteStr::from_utf8_unchecked(buf) };
                    Ok(Custom(val).into())
                }
            }
        },
        SCRATCH_BUF_OVERFLOW..=super::MAX_HEADER_NAME_LEN => {
            use bytes::{BufMut};
            let mut dst = BytesMut::with_capacity(data.len());

            dst.extend_from_slice(data);

            // SAFETY: see `parse_hdr_unchecked` guarantees
            let val = unsafe { ByteStr::from_utf8_unchecked(dst.freeze()) };

            Ok(Custom(val).into())
        },
        _ => Err(InvalidHeaderName::new()),
    }
}

Motivation

Many HTTP parsers already perform validation of header name tokens during parsing. This function would allow those parsers to avoid duplicate validation by reusing the existing validation results. Additionally, the unchecked parser could return HeaderName directly, since the invariant of valid header tokens would be guaranteed by the caller.

Linguagem predominante
Rust
Estrelas
1.4k
Forks
386
Merge médio
1d 5h
PRs com merge (30d)
2

Preparar o ambiente

Este projeto não oferece contêiner de desenvolvimento, Dockerfile nem guia de contribuição, então a configuração fica por sua conta: comece pelo README e veja nosso guia da primeira contribuição para os passos gerais.

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de hyperium/http

Todas as issues de hyperium/http

Issues semelhantes

Mais issues de Rust

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.