Qual é o caminho de remontagem de uma resposta HTTP?

Estou tentando entender como os sistemas operacionais geralmente implementam a remontagem de solicitações de rede. Do meu melhor entendimento, o seguinte é verdadeiro:

Uma solicitação HTTP é feita na camada de aplicativo usando alguma biblioteca HTTP. Essa biblioteca HTTP é realmente um invólucro para alguma implementação de soquete pelo sistema operacional.

Um soquete "de transmissão" é instanciado usando o destino e a origem da solicitação HTTP.

Um soquete "de recebimento" é instanciado usando o endereço IP do dispositivo e uma porta aleatória (livre).

A mensagem HTTP é "enviada" usando o descritor de arquivo do soquete "transmissor".

O método "send" do soquete envia a mensagem para a implementação TCP do sistema operacional.

A implementação do TCP segmenta a mensagem HTTP, precedendo a porta de destino (fornecida ao instanciar o soquete) e a porta de origem. (Suponho que isso seja repassado de alguma forma, dependendo da implementação.) Depois que a mensagem HTTP foi segmentada e os cabeçalhos TCP anexados, os segmentos TCP são passados ​​para a implementação IP do sistema operacional.

Os segmentos TCP são anexados com cabeçalhos IP. O endereço de destino IP foi fornecido ao instanciar o soquete. (Mais uma vez, presumo que o endereço IP de origem seja passado dependendo da implementação.)

Os pacotes IP são então agrupados com cabeçalhos Ethernet, enviados ao roteador, enviados ao servidor, o servidor processa a solicitação e envia de volta a resposta.

É aqui que meu entendimento se divide sobre o que exatamente acontece no processo de remontagem.

Como a resposta retorna ao buffer de recebimento do soquete "receptor", mais uma vez que o pacote IP retorna ao dispositivo?

Obviamente, os cabeçalhos caem, mas que medidas são tomadas para voltar especificamente ao buffer de recebimento do soquete "receptor" e depois do soquete de volta ao Aplicativo?

PS: Espero obter mais detalhes técnicos de implementação do que apenas "IP remontar" ou "TCP remontar" e passá-lo para a próxima camada. Espero entender exatamente como isso ocorre, em vez de apenas teoricamente (embora eu entenda que é específico do SO).

Editar:

Para trazer mais clareza ao assunto, gostaria de observar minhas referências a socket e qualquer método de socket referir-se ao sistema operacional Linux.

Boa descoberta por Mike Penningtion (nos comentários ), encontrando uma descrição técnica detalhada do caminho de uma solicitação na pilha de rede e backup (específico para o Linux OS 2005).

Uma visão mais detalhada, da qual foram extraídas as seguintes etapas :

Observe que, embora as etapas listadas não sejam tão detalhadas quanto o documento mencionado acima, aproximadamente as etapas são:

O sistema operacional possui um descritor de arquivo dedicado para a porta ethernet rx,

The rx ring is a ring in the kernel memory where the network card transfers the incoming packet through DMA. The raw data which is stored in the rx ring structure is either copied into a sk buff structure.

Isso então dispara um ISR para mover o pacote para a camada de rede. Observe que isso escolhe processar ou encaminhar o pacote (o que foi interessante, como eu imagino, talvez seja assim que a ativação do encaminhamento funciona, como para VPNs)

Se válido, ele será movido para a camada IP. Ele verifica seu protocolo (a partir do cabeçalho IP) e, se o protocolo for TCP, chama a função tcp v4 rcv, passando para a camada TCP.

E esta parte é crucial:

The next step for this function is to find an open socket for this incoming packet,

isso é feito chamando o tcp v4 lookup, no seguinte segmento de código:

sk = __tcp_v4_lookup(skb->nh.iph->saddr, th->source,
skb->nh.iph->daddr, ntohs(th->dest),
tcp_v4_iif(skb));

Basicamente, acho que há um LUT mapeando o soquete TCP para o endereço / portas de origem e destino da conexão do soquete, conforme indicado por essa chamada de função.

Se houver um soquete válido, os dados serão colocados tcp_data_queuepara continuar a pilha para consumo do aplicativo.

(dos comentários )

Eu recebo encapsulamento. Digamos que o sistema operacional tenha um descritor de arquivo dedicado aberto na porta Ethernet dedicada Rx. Ele retira o cabeçalho Ethernet de um quadro e o passa para alguma função de análise de IP, para remover o IP de destino. Ele coloca isso em alguma estrutura, depois a envia e a estrutura para a camada TCP. Aqui, retira-o da porta de destino e coloca-o na mesma estrutura. Aqui, deve haver algum mapeamento para o descritor de arquivo de soquetes com base na porta e ip para colocar os dados em um buffer atribuído ao descritor de arquivo. Esse é o meu melhor. Mas eu gostaria de saber o que realmente acontece.

Uma versão bastante antiga do que você está procurando está aqui: pilha de rede Linux . Estou tentando encontrar algo mais novo do que uma descrição de 2005, porque algumas das tripas do linux mudaram desde então. A maioria das informações de buffer do soquete é mantida em uma estrutura chamada an sk_buff, que é uma estrutura linux que contém ponteiros para o identificador do soquete TCP, bem como todos os buffers de leitura / gravação do soquete.

Como o driver da NIC do linux recebe informações da NIC em um determinado soquete, ele pesquisa o espaço do buffer da sk_buffinstância (nomeada skb) e despeja os dados nos buffers apontados pelo skb.