Funzione recv in lingua c

La lingua C offre diverse possibilità e l'uso di diverse funzioni per l'invio e la ricezione dei dati su una presa. Ognuno di essi fornisce una proprietà o un vincolo diverso. Tuttavia, la "presa.L'intestazione h "definisce la funzione recv () che è specificamente progettata per leggere i file socket e fornisce opzioni per ricevere la modalità, l'attesa, ecc., rendendolo più adatto per l'uso in connessioni.

In questo Suggerimento Linux Articolo, imparerai come usare il recv () funzione. Una delle due funzioni viene utilizzata per inviare e ricevere i dati su una presa in lingua C.

Esamineremo la sintassi di questa funzione e la sua descrizione teorica di come funziona, gli argomenti di input e output e il tipo di dati accettati da ciascuno di essi.

Quindi, implementeremo ciò che abbiamo appreso in un esempio pratico con frammenti di codice e immagini in cui creiamo un'applicazione di console per inviare i comandi al server e ricevere la risposta con il recv () funzione.

Sintassi della funzione recv () in lingua C

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

Descrizione della funzione recv () in lingua c

IL recv () La funzione riceve i dati inviati tramite una presa. Questa funzione riceve i dati dalla presa il cui identificatore è impostato su Sockfd. I dati ricevuti sono archiviati nel buffer a cui è indicato buf la cui dimensione deve essere specificata in len argomento input. L'input bandiere sono flag di controllo che sono raggruppati in un numero intero che configura come questa funzione riceve i dati tramite la presa.

Quando recv () è chiamato e non ci sono dati in attesa in coda, il programma attende fino all'arrivo di un nuovo pacchetto e quindi riprende l'esecuzione della riga di codice successiva. Questo tempo morto può essere soppresso usando la funzione pool () per interrogare se i dati sono in attesa di essere ricevuti o meno, evitando così chiamate inutili alla funzione recv ().

Un'altra possibilità è quella di consentire al flag msg _dontwait di impostare un ricevimento non bloccante. Se la recv () La funzione restituisce correttamente, restituisce il numero di byte che vengono ricevuti come risultato. Se si verifica un errore al ricevimento, recv () restituisce -1 e il codice specifico per quell'errore può essere recuperato tramite il errno variabile globale.

Successivamente, esaminiamo in dettaglio i singoli argomenti di input di questa funzione:

Sockfd: Questo argomento è un numero intero che deve contenere l'identificatore della presa attraverso il quale vengono ricevuti i dati. Questo identificatore è assegnato dal sistema durante la creazione di socket e il risultato restituito dalla funzione socket ().

buf: Questa voce è un puntatore al buffer dove recv () memorizza i dati ricevuti. Il buffer deve essere dimensionato in base alle dimensioni dei pacchetti da ricevere. I buffer di 1025 byte sono sufficienti per le connessioni TCP.

Len: Questo argomento è di tipo size_t e racconta la funzione della dimensione del buf Ricevi buffer.

Flag: Questo intero contiene un insieme di flag di controllo che forniscono alla funzione proprietà molto utili. I valori di questi flag sono specificati da una maschera tra questo numero intero e il flag selezionato, applicando l'operazione o logica tra di loro. I valori che rappresentano queste flag e le loro definizioni possono essere trovati nella presa.H ”intestazione. Vediamo ognuna di queste bandiere e una breve descrizione di loro nella seguente:

Msg_oob = 0x01 elabora i dati fuori banda.

MSG_PEEK = 0x02 PEEKS AT IL Messaggi in arrivo.

Msg_ctrunc = 0x08 controlla i dati persi prima della consegna.

Msg_proxy = 0x10 forniture o chiede il secondo indirizzo.

Msg_trunc = 0x20 restituisce la dimensione del datagramma ricevuto. Solo UDP.

MSG_DONTWAIT = 0x40 Rifiuto non bloccante.

Msg_waitall = 0x100 attende una richiesta completa.

La funzione recvc () è definita nella cartella "sys" nella "presa.H ”intestazione. Dobbiamo includerlo nel nostro file come segue:

#includere

Come ricevere dati tramite una presa con la funzione recv () nella lingua C

In questo esempio, colleghiamo una presa a www.Google.com, Invia i comandi HTTP al server, ricevi la sua risposta utilizzando il recv () funzione e quindi visualizzarlo nella console di comando.

La prima parte di questo esempio è il connect_to () Funzione ... crea una presa TCP per il servizio HTTP, lo collega al “www.Google.com "dominio e restituisce il Socket_id Identificatore socket. Dal momento che questo è tutto ciò di cui abbiamo bisogno per mostrare come recv () lavori, non andremo oltre in questa parte.

La seconda parte è la funzione principale in cui, con la presa connessa, inviamo il comando al server con la funzione Send () e quindi otteniamo la risposta nel buffer BUF con il recv () funzione.

Puoi vedere il codice "principale" per questa applicazione e una spiegazione di ogni passaggio mostrato nella seguente illustrazione:

//Passo 1
#includere
#includere
#includere
#includere
#includere
#includere
#includere
#includere
int connect_to ();
int main ()
int socket_id;
Char Buffer [1025];
//Passo 2
Socket_id = connect_to ();
// Passaggio 3
while (1)
printf ("Invia comando http. Per uscire da premere ctrl+c \ n ");
fgets (buffer, 1025, stdin);
inviare (socket_id, buffer, 1025, 0);
memset (& buffer, '\ 0', 1025);
// Passaggio 4
recv (socket_id, buffer, 1025, 0);
// Passaggio 5
printf ("%s \ n", buffer);
memset (& buffer, '\ 0', 1025);

// end main

Passo 1: Qui, aggiungiamo le intestazioni richieste, creiamo la funzione principale e definiamo il Socket_id intero che è l'identificatore della presa e l'elemento 1025 respingente[] Array di caratteri in cui le funzioni Send () e Recv () archiviano i dati che inviano e ricevono dal server.

Passo 2: Dopo che le variabili sono state definite, chiamiamo il connect_to () funzione e passare il Socket_id identificatore come argomento di output. La funzione ritorna con una presa connessa e il suo identificatore in Socket_id.

Passaggio 3: Con la presa e la sua maniglia è connessa, creiamo a mentre (1) Loop in cui la funzione FGETS () attende che l'utente inserisca un comando HTTP nella console di comando.

Quando si inserisce il comando, viene inviato al server tramite la presa identificata da Socket_id Utilizzando la funzione Send ().

Passaggio 4: Chiama il recv () funzione per ottenere la risposta del server. Quando si chiamano la funzione recv (), inviamo l'identificatore di socket, Socket_id, Come il primo argomento di input. Come secondo e terzo argomenti, inviamo il respingente[] puntatore buffer e le sue dimensioni nei byte nel qual caso impostiamo le dimensioni dei pacchetti su 1025. In questo caso, abbiamo impostato la voce dei flag su 0.

Passaggio 5: IL recv () La funzione ritorna quando finisce di ricevere il pacchetto. I dati ricevuti dal server vengono visualizzati sulla console di comando stampando il respingente[] Contenuto con la funzione printf (). La funzione Memset () viene utilizzata per cancellare il buffer dopo che è stato utilizzato dalle funzioni Send () e Recv ().

Successivamente, vediamo il codice principale e la funzione connect_to ().

//Passo 1
#includere
#includere
#includere
#includere
#includere
#includere
#includere
#includere
int connect_to ();
int main ()

int socket_id;
Char Buffer [1025];
//Passo 2
Socket_id = connect_to ();
// Passaggio 3
while (1)
printf ("Invia comando http. Per uscire da premere ctrl+c \ n ");
fgets (buffer, 1025, stdin);
inviare (socket_id, buffer, 1025, 0);
memset (& buffer, '\ 0', 1025);
// Passaggio 4
recv (socket_id, buffer, 1025, 0);
// Passaggio 5
printf ("%s \ n", buffer);
memset (& buffer, '\ 0', 1025);

// end main
/*********************************************** **************/
/* Connect_ Function*/
int connect_to ()
int port = 80;
Errore int;
int socket_id;
Char Buffer [1025];
struct hostent *server;
Struct Sockaddr_in Client;
memset (& server, 0, sizeof (server));
server = gethostbyname ("www.Google.com ");
if (server == null)

printf ("\ nerror ottenendo dati di dominio.\N");
Ritorno 1;

socket_id = socket (af_inet, Sock_stream, 0);
cliente.sin_family = af_inet;
cliente.sin_port = htons (porta);
bcopy ((char *) server-> h_addr,
(char *) e client.sin_addr.s_addr,
sizeof (server-> h_length));
errore = connect (socket_id, (struct sockaddr *) & client, sizeof (client));
if (errore < 0)
printf ("\ nco non potrebbe stabilire la connessione al server \ n");
chiudere (socket_id);
Ritorno 1;

printf ("\ nconnect to: %s \ n", inet_ntoa (client.sin_addr));
return socket_id;

Crea un file denominato "Esempio.c "e salvalo in" documenti ". Copia il codice e incollalo lì. Salvalo e compila il codice in GCC con il seguente comando:

~ $ GCC documenti/esempio.C -o Esempio

Quindi, esegui il programma con il seguente comando:

~ $ ./esempio

L'applicazione si collega a "www.Google.com "e ci aspetta che introduciamo un comando HTTP.

Nella figura seguente, vediamo il comando HTTP Get che viene inviato e la risposta del server che viene recuperata dal recv () funzione in respingente[].

Come identificare gli errori che la funzione recv () può generare in lingua c

Gli errori che possono verificarsi quando si utilizzano la funzione recv () sono vari, che vanno dagli errori di rete a dimensioni del buffer errate. Le definizioni di questi codici e la loro rappresentazione numerica possono essere trovate nel "Errno.Intestazione H "nella cartella" ASM-GENERICH "e può essere recuperata accedendo al errno numero intero.

Con il seguente snippet al passaggio 4 del codice precedente, chiamiamo il recv () funzione da una condizione if. Quando si verifica un errore, viene stampato un messaggio seguito dal numero predefinito che identifica l'errore che viene archiviato nel errno numero intero:

// Passaggio 4
if (recv (socket_id, buffer, 1025, 0) < 0)
printf ("errore:%i", errno);

Le seguenti sono le definizioni degli errori che possono essere generati dalla funzione recv () e una breve descrizione di ciascun errore:

La figura seguente mostra l'errore che si verifica quando si tenta di ricevere i dati tramite un identificatore di socket inesistente. L'errore risultante in errno è uguale a 88 "Funzionamento socket su non Socket".

Conclusione

In questo Suggerimento Linux Articolo, abbiamo spiegato come utilizzare la funzione recv () per ricevere i dati su una presa. Abbiamo esaminato la sintassi di questa funzione e una descrizione di come funziona, gli argomenti di input e output e i tipi di dati che accettano.

Per vedere come funziona questa funzione, abbiamo creato un'applicazione console in cui abbiamo utilizzato la funzione recv () per ricevere la risposta da un server tramite una presa che è collegata ad essa. Ti abbiamo anche mostrato come identificare e classificare alcuni degli errori più comuni quando si utilizza questa funzione.

Speriamo che tu abbia trovato questo articolo utile. Per ulteriori articoli sulla lingua C e sui suggerimenti Linux, utilizzare il motore di ricerca sul nostro sito Web.