C Chamada do sistema de função de conexão

No idioma C, estabelecer uma conexão cliente-servidor através de um soquete requer várias etapas e funções. Alguns deles são usados ​​para recuperar dados do servidor para o qual você deseja conectar, outros são usados ​​para criar o soquete ou converter endereços.

Embora não haja ordem específica, esta série de etapas e chamadas de função deve ser feita em uma ordem, porque seus resultados são usados ​​nos argumentos de entrada da função subsequente.

Nisso Linux Dica artigo, você aprenderá a usar o conectar() função e crie um soquete do zero para conectar -se remotamente a um servidor.

Começamos com uma descrição da sintaxe, os argumentos de entrada e saída que compõem essa função e uma explicação teórica de como ela funciona. Em seguida, examinaremos um exemplo que mostre um processo passo a passo sobre como criar e conectar um soquete.

Como o uso dessa função requer um conhecimento das estruturas de dados que compõem seus argumentos de entrada, em uma seção especial, examinaremos sua composição, o tipo de dados de seus membros e os parâmetros que o definem em cada um.

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

int conect (int sockfd, struct sockaddr *serv_addr, int addrlen)

Descrição da função de conexão na linguagem C

A função Connect () estabelece a conexão de um soquete entre um cliente e um servidor.

Esta função conecta o soquete, cujo descritor é Sockfd, ao servidor e cujo endereço é armazenado na estrutura serv_addr, que tem um comprimento de addrlen.

Se a conexão for bem -sucedida, Connect () retorna 0 como resultado e se a conexão não puder ser estabelecida, -1.

Abaixo está uma descrição detalhada de cada argumento de entrada e seu objetivo na função Connect ().

Sockfd: Este é um número inteiro com o descritor de soquete. Este descritor é o resultado retornado pela função Socket () e é usado para conectar, enviar e receber dados do servidor.

serv_addr: Este é o ponteiro de uma estrutura do tipo Sockaddr que armazena o endereço do servidor para se conectar.

addrlen: Este é o tamanho do membro da matriz sa_data da estrutura Sockaddr, onde o endereço, número da porta, etc. são armazenados.

Etapas antes de chamar a função Connect () para conectar -se a um servidor.

A função Call to the Connect () é a última de uma série de etapas necessárias para estabelecer uma conexão bem -sucedida. Essas etapas consistem em definir as variáveis ​​e estruturas que as funções usarão: criar um soquete e obter o endereço IP do servidor que queremos conectar etc. Explicamos em cinco etapas como criar um soquete e conectá -lo a um servidor usando a função Connect ().

Como criar, configurar e conectar um soquete passo a passo do zero na linguagem C

Passo 1: Na primeira etapa, incluiremos os seguintes cabeçalhos e definiremos as seguintes variáveis:

#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
#incluir
int soket_id;
int porta = 80;
Em terror;
buffer de char [1025);

O número inteiro Socket_id é o identificador do soquete através do qual uma conexão é feita e através da qual os dados são enviados e recebidos. A variável porta Especifica o número da porta do soquete. Nesse caso 80 para serviço http e o número inteiro erro é usado para detectar erros nas várias funções.

Então, definiremos o ponteiro para uma estrutura do tipo Hostent nomeado servidor e um do tipo Sockaddr_in nomeado cliente. Essas estruturas armazenam informações como endereços IP, tipo de conexão, etc. Aqueles do tipo Hostent armazenam as informações do servidor, enquanto as do tipo Sockadrr_in Armazene os dados da conexão. Usamos a função memcpy () para limpar todos os dados na estrutura hostent.

Struct hostent *servidor;
cliente sockaddr_in;
memcpy (& server, 0, sizeof (servidor));

Passo 2: Depois que a estrutura hostente é definida, a próxima etapa é determinar o endereço IP do nome do host que queremos nos conectar. Para isso, C fornece várias funções que podem resolver um endereço. Neste exemplo, usaremos GethostbyName (). Esta função retorna um Hostent estrutura com os dados de domínio passados ​​no argumento de entrada como uma string ou um ponteiro para ela. O se condição quebrará a conexão em caso de um erro, por exemplo, um nome de domínio inexistente.

server_id = gethostbyname ("www.Google.com ");
if (server_id == null)

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

Etapa 3: Crie um soquete Sockket_id e obtenha seu identificador. A função Socket () retorna o identificador do soquete criado com base na família de endereços, tipo e protocolo de conexão. Nesse caso, AF _INET, meia _stream para uma conexão IP4 e TCP.

soket_id = soquete (af_inet, sok_stream, 0);

Passo 4: Defina a configuração de conexão no Sockaddr_in estrutura. Para fazer isso, acesse seus membros e atribua valores para especificar o serviço e endereçar a família. O número da porta é especificado no formato binário direto e, portanto, deve ser convertido usando a função htons ().

Neste exemplo, vamos definir af_inet no sin_family campo para endereços IPv4 e em sin_port Atribuímos a porta 80 para o serviço "http".

cliente.sin_family = af_inet;
cliente.sin_port = htons (porta);

Etapa 5: O próximo passo é copiar o endereço do servidor estrutura para o cliente estrutura a ser usada como endereço de conexão para o soquete. Uma maneira de fazer isso é usar a função bcopy () da seguinte forma:

bcopy ((char *) servidor-> h_addr,
(char *) e cliente.sin_addr.s_addr,
sizeof (servidor-> h_length));

Copie o endereço na estrutura Sockaddr, que é usado pela função Connect () como argumento de entrada para serv_addr.

Nós fazemos isso por um elenco de estruturas e salvar linhas de código. Faremos isso na função de chamada para o Connect () no argumento de entrada serv_addr.

Abaixo, você pode ver como converter corretamente as informações do cliente estrutura:

(Struct Sockaddr *) e cliente, sizeof (cliente))

Em seguida, ligue para a função Connect () e passe o identificador Socket_id Como o primeiro argumento. Como o segundo argumento, o Sockaddr estrutura e finalmente o tamanho da estrutura.

O número inteiro erro é passado como o argumento de entrada, que usamos para verificar se a conexão foi bem -sucedida. O snippet a seguir mostra como chamar a função Connect () e verificar se foi bem -sucedido:

error = Connect (Socket_Id, (Struct Sockaddr *) & Client, sizeof (cliente));
Se (erro 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 ("\ nconnectTo: %s \ n", INT_NTOA (cliente.sin_addr));

A imagem mostra a compilação e a execução do código em que se conecta ao "www.Google.com "servidor. Este código estabelece a conexão e depois fecha o aplicativo desconectando.

O snippet a seguir usa as funções fgets () para inserir strings através do console de comando e as funções send () e recv () para enviar comandos HTTP para o servidor e receber a resposta:

enquanto (1)
printf ("Para sair, pressione Ctrl+C \ NSEND HTTP Command:");
fgets (buffer, 1025, stdin);
send (soket_id, buffer, 1025, 0);
Memset (& Buffer, '\ 0', 1025);
RECV (SOCKET_ID, BUFFER, 1025, 0);
printf ("%s", buffer);
Memset (& Buffer, '\ 0', 1025);

A imagem que vemos abaixo mostra a execução do código completo com o envio do comando http "get" e a resposta do servidor:

A estrutura da soja

Estruturas do tipo Sockaddr_in Armazene a configuração do tipo de conexão e endereço. Seus membros são usados ​​para especificar a família, o endereço a ser usado e o número da porta.

Abaixo, você pode ver esse tipo de estrutura junto com uma lista detalhada de cada membro:

Struct Sockaddr_in

curto int sin_family;
curto não assinado int sin_port;
struct in_addr sin_addr;
Char sin_Zero não assinado [8];
;

sin_family: Este número inteiro especifica uma das opções familiares a serem devolvidas pelo servidor. As opções da família de endereço são:

AF_INET para endereços IPv4.

AF_INET6 para endereços IPv6.

sin_port: Define o número da porta do serviço para usar.

sin_addr: Esta é a abreviação de endereço da Internet. Esta é uma estrutura do tipo in_addr, onde o endereço da Internet é armazenado.

sin_zero: Esta é uma matriz de 8 caracteres não assinados com o valor 0, que servem como preenchimento para compensar o tamanho de 14 bytes da estrutura de Sockaddr.

A estrutura hospedeira

Esse tipo de estrutura armazena dados úteis fornecidos pelo servidor quando uma consulta é feita com funções como Gethostbynam (). Essas pré -intervalos de conexão de soquete resolvem endereços e informações de devolução, como nome de domínio, família de endereços e uma lista de endereços se mais de um existir. Abaixo, você pode ver esta estrutura junto com uma descrição detalhada de cada elemento:

estrutura hostent

char *h_name;
char ** h_aliases;
int h_addrtype;
int h_length;
char ** h_addr_list;
#Define h_addr h_addr_list [0]
;

h_name: Este é um ponteiro para uma corda com o nome de domínio para o qual foi consultado.

h_aliases: Esta é uma lista de nomes alternativos.

h_addrtype: Este membro especifica a família de endereços para a qual foi consultada.

h_length: Isso especifica o tamanho do endereço.

h_addr_list: Este é o ponteiro de uma lista de ponteiros de endereço. Se o servidor retornar mais de um endereço para o nome consultado, cada um será acessado através deste ponteiro da lista.

h_addr : Esta estrutura define h_addr como um ponteiro para o primeiro endereço no h_addr_list, Portanto, o acesso é através desta definição.

Conclusão

Nisso Linux Dica artigo, explicamos tudo sobre o conectar() função na linguagem C.

Observamos a sintaxe dessa função, bem como os tipos de argumentos e estruturas que ele usa em suas entradas. Além disso, explicamos passo a passo como criar um soquete e conectar -se a um servidor remoto usando esta função.

Para que você tenha um conhecimento mais profundo dos soquetes nesse idioma, criamos uma seção especial que explica as estruturas usadas pelas funções do soquete, detalhando cada um de seus membros a função que eles desempenham nos argumentos de entrada das diferentes funções.