Então eu li muitas informações sobre dados auxiliares unix-stream, mas uma coisa faltando em toda a documentação é o que deveria acontecer quando há uma leitura parcial?
Suponha que eu esteja recebendo as seguintes mensagens em um buffer de 24 bytes
msg1 [20 byes] (no ancillary data)
msg2 [7 bytes] (2 file descriptors)
msg3 [7 bytes] (1 file descriptor)
msg4 [10 bytes] (no ancillary data)
msg5 [7 bytes] (5 file descriptors)
A primeira chamada para recvmsg, recebo todas as msg1 (e parte da msg2? O sistema operacional fará isso?) Se eu obtiver parte da msg2, recebo os dados auxiliares imediatamente e preciso salvá-los para a próxima é lida quando sei o que a mensagem realmente estava me dizendo para fazer com os dados? Se eu liberar os 20 bytes do msg1 e depois chamar o recvmsg novamente, ele entregará msg3 e msg4 ao mesmo tempo? Os dados auxiliares de msg3 e msg4 são concatenados na estrutura da mensagem de controle?
Embora eu pudesse escrever programas de teste para descobrir isso experimentalmente, estou procurando uma documentação sobre como os dados auxiliares se comportam em um contexto de streaming. Parece estranho que eu não consiga encontrar nada de oficial nisso.
Vou adicionar minhas descobertas experimentais aqui, que recebi deste programa de teste:
Parece que o Linux irá anexar porções de mensagens auxiliares ao final de outras mensagens, desde que nenhuma carga auxiliar anterior tenha sido enviada durante essa chamada para recvmsg. Uma vez que os dados auxiliares de uma mensagem estão sendo entregues, ela retornará uma leitura curta em vez de iniciar a próxima mensagem de dados auxiliares. Então, no exemplo acima, as leituras que recebo são:
recv1: [24 bytes] (msg1 + partial msg2 with msg2's 2 file descriptors)
recv2: [10 bytes] (remainder of msg2 + msg3 with msg3's 1 file descriptor)
recv3: [17 bytes] (msg4 + msg5 with msg5's 5 file descriptors)
recv4: [0 bytes]
O BSD fornece mais alinhamento do que o Linux e fornece uma breve leitura imediatamente antes do início de uma mensagem com dados auxiliares. Mas, com satisfação, acrescentará uma mensagem não auxiliar ao final de uma mensagem auxiliar. Então, para o BSD, parece que se o seu buffer é maior do que a mensagem de suporte auxiliar, você obtém um comportamento quase parecido com um pacote. As leituras que recebo são:
recv1: [20 bytes] (msg1)
recv2: [7 bytes] (msg2, with msg2's 2 file descriptors)
recv3: [17 bytes] (msg3, and msg4, with msg3's 1 file descriptor)
recv4: [7 bytes] (msg5 with 5 file descriptors)
recv5: [0 bytes]
Ainda gostaria de saber como isso acontece no Linux antigo, no iOS, no Solaris, etc., e como pode ser esperado para acontecer no futuro.
Tags unix-sockets