RECV -funksjon på C -språk
C -språket tilbyr flere muligheter og bruk av forskjellige funksjoner for å sende og motta dataene over en stikkontakt. Hver av dem gir en annen eiendom eller begrensning. Imidlertid "stikkontakten.H ”-overskrift definerer RECV () -funksjonen som er spesielt designet for å lese sokkelfilene og gir alternativer for å motta modus, vente osv., Gjør det mest egnet for bruk i tilkoblinger.
I dette Linux hint artikkel, du lærer hvordan du bruker recv () funksjon. En av de to funksjonene brukes til å sende og motta dataene over en stikkontakt på C -språket.
Vi vil se på syntaks for denne funksjonen og dens teoretiske beskrivelse av hvordan den fungerer, inngangs- og utgangsargumentene og datatypen som blir akseptert av hver av dem.
Deretter vil vi implementere det vi lærte i et praktisk eksempel med kodebiter og bilder der vi oppretter en konsollapplikasjon for å sende kommandoene til serveren og motta svaret med recv () funksjon.
Syntaks av recv () -funksjonen på C -språk
ssize_t recv (int sockfd, void *buf, size_t len, int flagg);
Beskrivelse av recv () -funksjonen på C -språk
De recv () Funksjon mottar dataene som sendes gjennom en stikkontakt. Denne funksjonen mottar dataene fra kontakten hvis identifikator er satt til SOCKFD. De mottatte dataene lagres i bufferen som er pekt på av buf hvis størrelse må spesifiseres i Len Input Argument. Inngangen flagg er kontrollflagg som er gruppert i et heltall som konfigurerer hvordan denne funksjonen mottar dataene gjennom kontakten.
Når recv () kalles og det er ingen data som venter i køen, programmet venter til en ny pakke kommer og deretter gjenopptar utførelsen av neste kodeinje. Denne døde tiden kan undertrykkes ved hjelp av bassenget () -funksjonen for å spørre om dataene venter på å bli mottatt eller ikke, og dermed unngå unødvendige anrop til RECV () -funksjonen.
En annen mulighet er å aktivere MSG _dontwait-flagget for å sette en ikke-blokkerende mottak. Hvis recv () Funksjonen returnerer vellykket, den returnerer antall byte som mottas som resultat. Hvis det oppstår en feil i resepsjonen, recv () returnerer -1 og den spesifikke koden for den feilen kan hentes via errno Global variabel.
La oss deretter se på de individuelle inngangsargumentene til denne funksjonen i detalj:
SOCKFD: Dette argumentet er et heltall som må inneholde identifikatoren til kontakten som dataene mottas. Denne identifikatoren tildeles av systemet under sokkelskaping og resultatet som returneres av socket () -funksjonen.
buf: Denne oppføringen er en peker til bufferen der recv () lagrer mottatte data. Bufferen skal størrelse i henhold til størrelsen på pakkene som skal mottas. Buffere på 1025 byte er tilstrekkelige for TCP -tilkoblinger.
Len: Dette argumentet er av typen størrelse_t og forteller funksjonen til størrelsen på buf motta buffer.
flagg: Dette heltallet inneholder et sett med kontrollflagg som gir funksjonen veldig nyttige egenskaper. Verdiene til disse flaggene er spesifisert av en maske mellom dette heltallet og det valgte flagget, og bruker den eller logiske operasjonen mellom dem. Verdiene som disse flaggene representerer og deres definisjoner kan bli funnet i “kontakten.h ”header. Vi ser hvert av disse flaggene og en kort beskrivelse av dem i følgende:
MSG_OOB = 0x01 behandler ut-av-band-dataene.
Msg_peek = 0x02 kikk på innkommende meldinger.
Msg_ctrunc = 0x08 kontrollerer data tapt før levering.
Msg_proxy = 0x10 forsyninger eller spør den andre adressen.
Msg_trunc = 0x20 returnerer størrelsen på det mottatte datagrammet. Bare UDP.
Msg_dontwait = 0x40 ikke-blokkerende avvisning.
Msg_waitall = 0x100 venter på en full forespørsel.
RECVC () -funksjonen er definert i "SYS" -mappen i “Kontakten.h ”header. Vi må inkludere den i filen vår som følger:
#inkludere
Hvordan motta data gjennom en stikkontakt med RECV () -funksjonen på C -språket
I dette eksemplet kobler vi en stikkontakt til www.Google.com, Send HTTP -kommandoene til serveren, motta svaret ved å bruke recv () funksjon, og vis den deretter i kommandokonsollen.
Den første delen av dette eksemplet er koble til() Funksjon ... det oppretter en TCP -stikkontakt for HTTP -tjenesten, kobler den til “www.Google.com ”-domenet, og returnerer socket_id sokkelidentifikator. Siden dette er alt vi trenger for å vise hvordan recv () fungerer, vi vil ikke gå lenger inn i denne delen.
Den andre delen er hovedfunksjonen der vi, med kontakten tilkoblet, sender kommandoen til serveren med Send () -funksjonen og deretter får responsen i BUF -bufferen med recv () funksjon.
Du kan se "hoved" -koden for denne applikasjonen og en forklaring av hvert trinn som vises i den i følgende illustrasjon:
//Trinn 1
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
int connect_to ();
int main ()
int socket_id;
Char Buffer [1025];
//Steg 2
socket_id = connect_to ();
// Trinn 3
mens (1)
printf ("Send http -kommando. Å avslutte trykk Ctrl+c \ n ");
fgets (buffer, 1025, stdin);
send (socket_id, buffer, 1025, 0);
memset (& buffer, '\ 0', 1025);
// Trinn 4
RECV (socket_id, buffer, 1025, 0);
// Trinn 5
printf ("%s \ n", buffer);
memset (& buffer, '\ 0', 1025);
// End Main
Trinn 1: Her legger vi til de nødvendige overskriftene, lager hovedfunksjonen og definerer socket_id Heltall som er socketidentifikatoren og 1025-elementet buffer[] Karakterarray der Send () og Recv () -funksjonene lagrer dataene de sender og mottar fra serveren.
Steg 2: Etter at variablene er definert, kaller vi koble til() funksjon og passere socket_id Identifikator som utgangsargument. Funksjonen kommer tilbake med en tilkoblet stikkontakt og dens identifikator i socket_id.
Trinn 3: Når kontakten og håndtaket blir koblet sammen, oppretter vi en mens (1) Loop der Fets () -funksjonen venter på at brukeren skal oppgi en HTTP -kommando på kommandokonsollen.
Når du oppgir kommandoen, blir den sendt til serveren gjennom kontakten som er identifisert av socket_id Bruke Send () -funksjonen.
Trinn 4: Ring recv () Funksjon for å få serverens svar. Når vi kaller RECV () -funksjonen, sender vi socketidentifikatoren, socket_id, Som det første inngangsargumentet. Som andre og tredje argumenter sender vi buffer[] bufferpeker og størrelsen i byte, i så fall setter vi størrelsen på pakkene til 1025. I dette tilfellet satte vi flaggoppføringen til 0.
Trinn 5: De recv () Funksjonen returnerer når den er ferdig med å motta pakken. Mottatte data fra serveren vises på kommandokonsollen ved å skrive ut buffer[] Innhold med printf () -funksjonen. Memset () -funksjonen brukes til å tømme bufferen etter at den er brukt av Send () og Recv () -funksjonene.
Deretter ser vi hovedkoden og Connect_to () -funksjonen.
//Trinn 1
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
int connect_to ();
int main ()
int socket_id;
Char Buffer [1025];
//Steg 2
socket_id = connect_to ();
// Trinn 3
mens (1)
printf ("Send http -kommando. Å avslutte trykk Ctrl+c \ n ");
fgets (buffer, 1025, stdin);
send (socket_id, buffer, 1025, 0);
memset (& buffer, '\ 0', 1025);
// Trinn 4
RECV (socket_id, buffer, 1025, 0);
// Trinn 5
printf ("%s \ n", buffer);
memset (& buffer, '\ 0', 1025);
// End Main
/******************************************************** **************/
/* Connect_to -funksjonen*/
int connect_to ()
int port = 80;
int feil;
int socket_id;
Char Buffer [1025];
struktur Hostent *Server;
struct Sockaddr_in Client;
memset (& server, 0, sizeof (server));
server = gethostbyName ("www.Google.com ");
if (server == null)
printf ("\ nerror får domenedata.\ n ");
retur 1;
socket_id = socket (af_inet, sock_stream, 0);
klient.sin_family = af_inet;
klient.SIN_PORT = HTONS (port);
bcopy ((char *) server-> h_addr,
(char *) & klient.Sin_addr.S_addr,
sizeof (server-> h_length));
Feil = Connect (Socket_id, (struct Sockaddr *) & Client, sizeof (client));
hvis (feil < 0)
printf ("\ ncould ikke etablere forbindelse til serveren \ n");
lukk (socket_id);
retur 1;
printf ("\ nconnect to: %s \ n", inet_ntoa (klient.sin_addr));
retur socket_id;
Lag en fil som heter “Eksempel.C ”og lagre det i“ Dokumenter ”. Kopier koden og lim den der. Lagre den og kompiler koden i GCC med følgende kommando:
~ $ GCC -dokumenter/eksempel.c -o eksempel
Kjør deretter programmet med følgende kommando:
~ $ ./eksempel
Applikasjonen kobles til “www.Google.com ”og venter på at vi skal introdusere en HTTP -kommando.
I den følgende figuren ser vi HTTP få kommandoen som blir sendt og serverens svar som blir hentet av recv () funksjon i buffer[].
Hvordan identifisere feilene som Recv () -funksjonen kan generere på C -språk
Feilene som kan oppstå når du bruker RECV () -funksjonen, varieres, alt fra nettverksfeil til feil bufferstørrelser. Definisjonene av disse kodene og deres numeriske representasjon finner du i “Errno.H ”header i“ ASM-Generic ”-mappen og kan hentes ved å få tilgang til errno heltall.
Med følgende utdrag i trinn 4 i forrige kode, ringer vi recv () funksjon fra en IF -tilstand. Når en feil oppstår, skrives en melding etterfulgt av det forhåndsdefinerte nummeret som identifiserer feilen som er lagret i errno Heltall:
// Trinn 4
if (recv (socket_id, buffer, 1025, 0) < 0)
printf ("Feil:%i", errno);
Følgende er definisjonene av feilene som kan genereres av RECV () -funksjonen og en kort beskrivelse av hver feil:
Følgende figur viser feilen som oppstår når du prøver å motta dataene via en ikke-eksisterende socketidentifikator. Den resulterende feilen i errno er lik 88 “Socket Operation on Non-Socket”.
Konklusjon
I dette Linux hint Artikkel, vi forklarte hvordan du bruker RECV () -funksjonen til å motta dataene over en stikkontakt. Vi så på syntaks for denne funksjonen, så vel som en beskrivelse av hvordan den fungerer, inngangs- og utgangsargumentene og datatypene de godtar.
For å se hvordan denne funksjonen fungerer, opprettet vi en konsollapplikasjon der vi brukte RECV () -funksjonen for å motta responsen fra en server gjennom en stikkontakt som er koblet til den. Vi viste deg også hvordan du kan identifisere og klassifisere noen av de vanligste feilene når du bruker denne funksjonen.
Vi håper at du fant denne artikkelen nyttig. For flere artikler om C -språket og Linux -tipsene, bruk søkemotoren på nettstedet vårt.