Função RECV na linguagem C

O idioma C oferece várias possibilidades e o uso de diferentes funções para enviar e receber os dados sobre um soquete. Cada um deles fornece uma propriedade ou restrição diferente. No entanto, o “soquete.H ”Cabeçalho define a função RECV () que é projetada especificamente para ler os arquivos de soquete e oferece opções para receber o modo, esperando etc., tornando -o mais adequado para uso em conexões.

Nisso Linux Dica artigo, você aprenderá a usar o recv () função. Uma das duas funções é usada para enviar e receber os dados sobre um soquete no idioma C.

Veremos a sintaxe desta função e sua descrição teórica de como ela funciona, os argumentos de entrada e saída e o tipo de dados que é aceito por cada um deles.

Em seguida, implementaremos o que aprendemos em um exemplo prático com trechos de código e imagens onde criamos um aplicativo de console para enviar os comandos para o servidor e receber a resposta com o recv () função.

Sintaxe da função recv () na linguagem C

ssize_t recv (int sockfd, void *buf, size_t len, int sinalizadores);

Descrição da função recv () na linguagem C

O recv () A função recebe os dados que são enviados através de um soquete. Esta função recebe os dados do soquete cujo identificador está definido como Sockfd. Os dados recebidos são armazenados no buffer que é apontado por BUF cujo tamanho deve ser especificado no Len argumento de entrada. A entrada bandeiras São sinalizadores de controle que são agrupados em um número inteiro que configura como essa função recebe os dados através do soquete.

Quando recv () é chamado e não há dados que estejam esperando na fila, o programa aguarda até que um novo pacote chegue e depois retoma a execução da próxima linha de código. Esse tempo morto pode ser suprimido usando a função Pool () para consultar se os dados estão esperando ou não para serem recebidos, evitando assim chamadas desnecessárias para a função recv ().

Outra possibilidade é ativar a bandeira MSG _DONTWAIT para definir uma recepção sem bloqueio. Se o recv () A função retorna com sucesso, retorna o número de bytes que são recebidos como resultado. Se ocorrer um erro na recepção, recv () retorna -1 e o código específico para esse erro pode ser recuperado através do errno variável global.

Em seguida, vejamos os argumentos de entrada individuais desta função em detalhes:

Sockfd: Este argumento é um número inteiro que deve conter o identificador do soquete através do qual os dados são recebidos. Este identificador é atribuído pelo sistema durante a criação do soquete e o resultado que é retornado pela função Socket ().

BUF: Esta entrada é um ponteiro para o buffer onde recv () armazena os dados recebidos. O buffer deve ser dimensionado de acordo com o tamanho dos pacotes a serem recebidos. Buffers de 1025 bytes são suficientes para conexões TCP.

Len: Este argumento é do tipo size_t e diz a função do tamanho do BUF Receber buffer.

bandeiras: Este número inteiro contém um conjunto de sinalizadores de controle que dão à função propriedades muito úteis. Os valores desses sinalizadores são especificados por uma máscara entre esse número inteiro e a bandeira selecionada, aplicando a operação lógica entre eles. Os valores que essas bandeiras representam e suas definições podem ser encontradas no “soquete.H ”cabeçalho. Vemos cada uma dessas bandeiras e uma breve descrição deles no seguinte:

Msg_oob = 0x01 processa os dados fora da banda.

Msg_peek = 0x02 espia as mensagens recebidas.

Msg_ctrunc = 0x08 controla os dados perdidos antes da entrega.

Msg_proxy = 0x10 fornece ou pede o segundo endereço.

Msg_trunc = 0x20 retorna o tamanho do datagrama recebido. Apenas UDP.

Msg_dontwait = 0x40 rejeição não bloqueadora.

Msg_waitall = 0x100 aguarda uma solicitação completa.

A função recvc () é definida na pasta "SYS" no "soquete.H ”cabeçalho. Precisamos incluí -lo em nosso arquivo da seguinte maneira:

#incluir

Como receber dados através de um soquete com a função RECV () na linguagem C

Neste exemplo, conectamos um soquete a www.Google.com, Envie os comandos HTTP para o servidor, receba sua resposta usando o recv () função e depois exibi -lo no console de comando.

A primeira parte deste exemplo é o conectar a() Função ... cria um soquete TCP para o serviço HTTP, conecta -o ao “www.Google.com ”domínio e retorna o Socket_id identificador de soquete. Já que isso é tudo o que precisamos para mostrar como recv () obras, não iremos mais longe nesta parte.

A segunda parte é a principal função em que, com o soquete conectado, enviamos o comando para o servidor com a função send () e depois obtemos a resposta no buffer BUF com o recv () função.

Você pode ver o código "principal" para este aplicativo e uma explicação de cada etapa mostrada nele na seguinte ilustração:

//Passo 1
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
int conect_to ();
int main ()
int soket_id;
buffer de char [1025];
//Passo 2
soket_id = connect_to ();
//Etapa 3
enquanto (1)
printf ("Enviar comando http. Para sair da pressão ctrl+c \ n ");
fgets (buffer, 1025, stdin);
send (soket_id, buffer, 1025, 0);
Memset (& Buffer, '\ 0', 1025);
//Passo 4
RECV (SOCKET_ID, BUFFER, 1025, 0);
// Etapa 5
printf ("%s \ n", buffer);
Memset (& Buffer, '\ 0', 1025);

// End Main

Passo 1: Aqui, adicionamos os cabeçalhos necessários, criamos a função principal e definimos o Socket_id Inteiro, que é o identificador de soquete e o elemento 1025 amortecedor[] matriz de caracteres onde as funções send () e recv () armazenam os dados que eles enviam e recebem do servidor.

Passo 2: Depois que as variáveis ​​são definidas, chamamos o conectar a() função e passar o Socket_id Identificador como o argumento de saída. A função retorna com um soquete conectado e seu identificador em Socket_id.

Etapa 3: Com o soquete e sua alça sendo conectada, criamos um enquanto (1) Loop no qual a função fgets () aguarda o usuário entrar em um comando http no console de comando.

Quando você entra no comando, ele é enviado ao servidor através do soquete que é identificado por Socket_id usando a função send ().

Passo 4: Ligar para recv () função para obter a resposta do servidor. Ao chamar a função recv (), enviamos o identificador de soquete, Socket_id, Como o primeiro argumento de entrada. Como o segundo e o terceiro argumentos, enviamos o amortecedor[] ponteiro de buffer e seu tamanho em bytes, caso em que definimos o tamanho dos pacotes como 1025. Nesse caso, definimos a entrada dos sinalizadores para 0.

Etapa 5: O recv () A função retorna quando terminar de receber o pacote. Os dados recebidos do servidor são exibidos no console de comando imprimindo o amortecedor[] Conteúdo com a função printf (). A função MEMSET () é usada para limpar o buffer depois de ser usado pelas funções send () e recv ().

Em seguida, vemos o código principal e a função Connect_to ().

//Passo 1
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
int conect_to ();
int main ()

int soket_id;
buffer de char [1025];
//Passo 2
soket_id = connect_to ();
//Etapa 3
enquanto (1)
printf ("Enviar comando http. Para sair da pressão ctrl+c \ n ");
fgets (buffer, 1025, stdin);
send (soket_id, buffer, 1025, 0);
Memset (& Buffer, '\ 0', 1025);
//Passo 4
RECV (SOCKET_ID, BUFFER, 1025, 0);
// Etapa 5
printf ("%s \ n", buffer);
Memset (& Buffer, '\ 0', 1025);

// End Main
/***************************************************** **************/
/* Connect_to função*/
int conect_to ()
int porta = 80;
em terror;
int soket_id;
buffer de char [1025];
struct hostent *servidor;
cliente sockaddr_in;
MEMSET (& servidor, 0, sizeof (servidor));
servidor = gethostbyname ("www.Google.com ");
if (servidor == null)

printf ("\ Nerror obtendo dados de domínio.\ n ");
retornar 1;

soket_id = soquete (af_inet, sok_stream, 0);
cliente.sin_family = af_inet;
cliente.sin_port = htons (porta);
bcopy ((char *) servidor-> h_addr,
(char *) e cliente.sin_addr.s_addr,
sizeof (servidor-> h_length));
error = Connect (Socket_Id, (Struct Sockaddr *) & Client, sizeof (cliente));
if (erro < 0)
printf ("não pode estabelecer conexão com o servidor \ n");
fechar (soket_id);
retornar 1;

printf ("\ nconnect para: %s \ n", INT_NTOA (cliente.sin_addr));
return socket_id;

Crie um arquivo chamado “Exemplo.C "e salve -o em" Documentos ". Copie o código e coloque -o lá. Salve e compilar o código no GCC com o seguinte comando:

~ $ gcc documentos/exemplo.C -O Exemplo

Em seguida, execute o programa com o seguinte comando:

~ $ ./exemplo

O aplicativo se conecta a “www.Google.com ”e espera que introduzmos um comando http.

Na figura a seguir, vemos o comando http obter que é enviado e a resposta do servidor que é recuperada pelo recv () função em amortecedor[].

Como identificar os erros que a função RECV () pode gerar na linguagem C

Os erros que podem ocorrer ao usar a função recv () são variados, variando de erros de rede a tamanhos de buffer incorretos. As definições desses códigos e sua representação numérica podem ser encontradas no “errno.h ”cabeçalho na pasta“ Asm-Generic ”e pode ser recuperado acessando o errno Inteiro.

Com o snippet seguinte na etapa 4 do código anterior, chamamos o recv () função de uma condição if. Quando ocorre um erro, uma mensagem é impressa seguida pelo número predefinido que identifica o erro que é armazenado no errno Inteiro:

//Passo 4
if (recv (soket_id, buffer, 1025, 0) < 0)
printf ("erro:%i", errno);

A seguir, são apresentadas as definições dos erros que podem ser gerados pela função recv () e uma breve descrição de cada erro:

A figura a seguir mostra o erro que ocorre ao tentar receber os dados por meio de um identificador de soquete inexistente. O erro resultante em errno é igual a 88 “operação de soquete no não soquete”.

Conclusão

Nisso Linux Dica Artigo, explicamos como usar a função recv () para receber os dados sobre um soquete. Observamos a sintaxe dessa função, bem como uma descrição de como ela funciona, os argumentos de entrada e saída e os tipos de dados que eles aceitam.

Para ver como essa função funciona, criamos um aplicativo de console no qual usamos a função recv () para receber a resposta de um servidor através de um soquete que está conectado a ele. Também mostramos como identificar e classificar alguns dos erros mais comuns ao usar esta função.

Esperamos que você tenha achado este artigo útil. Para obter mais artigos sobre as dicas de idioma C e Linux, use o mecanismo de pesquisa em nosso site.