Recv -Funktion in der C -Sprache

Die C -Sprache bietet mehrere Möglichkeiten und die Verwendung verschiedener Funktionen zum Senden und Empfangen der Daten über einen Socket. Jeder von ihnen bietet eine andere Eigenschaft oder Einschränkung. Allerdings die „Steckdose.H ”Header definiert die Recv () -Funktion, die speziell zum Lesen der Socket -Dateien entwickelt wurde und Optionen zum Empfangen des Modus, des Wartens usw. bietet., Machen Sie es am besten für die Verwendung in Verbindungen geeignet.

In diesem Linux -Hinweis Artikel, Sie werden lernen, wie man das benutzt recv () Funktion. Eine der beiden Funktionen wird verwendet, um die Daten über einen Socket in der C -Sprache zu senden und zu empfangen.

Wir werden die Syntax dieser Funktion und ihre theoretische Beschreibung der Funktionsweise, der Eingabe- und Ausgabeargumente und des Datentyps betrachten, der von jedem von ihnen akzeptiert wird.

Anschließend werden wir das implementieren, was wir in einem praktischen Beispiel mit Code -Ausschnitten und Bildern gelernt haben, in denen wir eine Konsolenanwendung erstellen, um die Befehle an den Server zu senden und die Antwort mit dem zu empfangen recv () Funktion.

Syntax der Recv () -Funktion in der C -Sprache

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

Beschreibung der Recv () -Funktion in der C -Sprache

Der recv () Die Funktion empfängt die Daten, die über einen Socket gesendet werden. Diese Funktion empfängt die Daten aus der Socket, deren Kennung auf eingestellt ist Sockfd. Die empfangenen Daten werden in dem Puffer gespeichert, auf den durch buf deren Größe muss in der angegeben werden Len Eingabeargument. Die Eingabe Flaggen sind Steuerflags, die in einer Ganzzahl gruppiert sind, die konfiguriert, wie diese Funktion die Daten über den Socket empfängt.

Wenn recv () wird aufgerufen und es gibt keine Daten, die in der Warteschlange warten, das Programm wartet, bis ein neues Paket eintrifft und dann die Ausführung der nächsten Codezeile wieder aufnimmt. Diese Totzeit kann mithilfe der Funktion pool () unterdrückt werden, um abzufreten, ob die Daten darauf warten, empfangen zu werden oder nicht, so.

Eine andere Möglichkeit besteht darin, das MSG _dontwait-Flag zu ermöglichen, einen nicht blockierenden Empfang festzulegen. Wenn der recv () Die Funktion gibt erfolgreich zurück. Es gibt die Anzahl der Bytes zurück, die als Ergebnis empfangen werden. Wenn ein Fehler am Empfang auftritt, recv () Gibt -1 zurück und der spezifische Code für diesen Fehler kann über die abgerufen werden Errno Globale Variable.

Lassen Sie uns als nächstes die individuellen Eingabeargumente dieser Funktion im Detail betrachten:

Sockfd: Dieses Argument ist eine Ganzzahl, die die Kennung des Sockets enthalten muss, durch den die Daten empfangen werden. Diese Kennung wird vom System während der Socket -Erstellung und des Ergebniss, das von der Socket () -Funktion zurückgegeben wird, zugewiesen.

buf: Dieser Eintrag ist ein Zeiger auf den Puffer, wo recv () Speichert die empfangenen Daten. Der Puffer sollte gemäß der Größe der zu empfangenen Pakete dimensioniert werden. Puffer von 1025 Bytes reichen für TCP -Verbindungen aus.

Len: Dieses Argument ist vom Typ size_t und erzählt die Funktion der Größe der buf Puffer erhalten.

Flaggen: Diese Ganzzahl enthält eine Reihe von Steuerflags, die der Funktion sehr nützliche Eigenschaften verleihen. Die Werte dieser Flags werden durch eine Maske zwischen dieser Ganzzahl und dem ausgewählten Flag angegeben, wobei der oder logische Betrieb zwischen ihnen angewendet wird. Die Werte, die diese Flags darstellen und ihre Definitionen in der „Socket.H ”Kopfball. Wir sehen jede dieser Flaggen und eine kurze Beschreibung von ihnen im Folgenden:

Msg_oob = 0x01 verarbeitet die außergewöhnlichen Daten.

Msg_peek = 0x02 peeks auf eingehende Nachrichten.

MSG_CTRUNC = 0x08 steuert Daten vor der Lieferung verloren.

Msg_proxy = 0x10 liefert oder fragt die zweite Adresse.

MSG_TRUNC = 0x20 gibt die Größe des empfangenen Datagramms zurück. Nur UDP.

Msg_dontwait = 0x40 nicht blockierende Ablehnung.

Msg_waitall = 0x100 wartet auf eine vollständige Anfrage.

Die Funktion recvc () ist im Ordner „sys“ in der „Socket“ definiert.H ”Kopfball. Wir müssen es wie folgt in unsere Datei aufnehmen:

#enthalten

So empfangen Sie Daten über eine Socket mit der Funktion recv () in der C -Sprache

In diesem Beispiel verbinden wir einen Socket mit www.Google.com, Senden Sie die HTTP -Befehle an den Server und empfangen Sie die Antwort mit dem recv () Funktion und dann in der Befehlskonsole anzeigen.

Der erste Teil dieses Beispiels ist der verbunden mit() Funktion… es erstellt einen TCP -Socket für den HTTP -Dienst, verbindet ihn mit dem „www.Google.com ”Domain und gibt die zurück socket_id Socket -Kennung. Da dies alles ist, müssen wir zeigen, wie recv () Arbeiten, wir werden nicht weiter in diesen Teil eingehen.

Der zweite Teil ist die Hauptfunktion, bei der wir den Befehl mit der Funktion "send () an den Server senden und dann die Antwort in den BUF -Puffer mit dem erhalten recv () Funktion.

Sie können den Hauptcode für diese Anwendung und eine Erläuterung jedes darin enthaltenen Schritts in der folgenden Abbildung sehen:

//Schritt 1
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int Connect_to ();
int main ()
int socket_id;
Zeichenpuffer [1025];
//Schritt 2
socket_id = connect_to ();
//Schritt 3
während (1)
printf ("HTTP -Befehl senden. Zum Beenden drücken Sie Strg+c \ n ");
FGets (Buffer, 1025, Stdin);
send (socket_id, puffer, 1025, 0);
memset (& buffer, '\ 0', 1025);
//Schritt 4
recv (socket_id, puffer, 1025, 0);
// Schritt 5
printf ("%S \ n", Puffer);
memset (& buffer, '\ 0', 1025);

// Ende des Haupts

Schritt 1: Hier fügen wir die erforderlichen Header hinzu, erstellen die Hauptfunktion und definieren die socket_id Ganzzahl, die die Socket-Kennung und die 1025-Elemente ist Puffer[] Zeichenarray, bei dem die Funktionen send () und recv () die Daten speichern, die sie senden und vom Server empfangen.

Schritt 2: Nachdem die Variablen definiert sind, nennen wir die verbunden mit() funktionieren und übergeben die socket_id Kennung als Ausgabeargument. Die Funktion kehrt mit einem angeschlossenen Socket und ihrer Kennung in in die zurück socket_id.

Schritt 3: Wenn der Sockel und sein Griff verbunden sind, erstellen wir a während (1) Schleife, in der die Funktion fGets () darauf wartet, dass der Benutzer einen HTTP -Befehl an der Befehlskonsole eingibt.

Wenn Sie den Befehl eingeben, wird er über den Socket an den Server gesendet, der von identifiziert wird, socket_id Verwenden der Funktion "send ()).

Schritt 4: Ruf den recv () Funktion, um die Antwort des Servers zu erhalten. Wenn wir die Funktion recv () aufrufen, senden wir die Socket -Kennung, socket_id, Als erstes Eingabargument. Als zweite und dritte Argumente senden wir die Puffer[] Pufferzeiger und seine Größe in Bytes In diesem Fall setzen wir die Größe der Pakete auf 1025. In diesem Fall setzen wir den Flags -Eintrag auf 0.

Schritt 5: Der recv () Funktion kehrt zurück, wenn das Paket fertig wird. Die empfangenen Daten aus dem Server werden auf der Befehlskonsole angezeigt, indem die drucken Puffer[] Inhalt mit der Printf () -Funktion. Die Funktion memset () wird verwendet, um den Puffer zu löschen, nachdem er von den Funktionen send () und recv () verwendet wurde.

Als nächstes sehen wir den Hauptcode und die Funktion Connect_to ().

//Schritt 1
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int Connect_to ();
int main ()

int socket_id;
Zeichenpuffer [1025];
//Schritt 2
socket_id = connect_to ();
//Schritt 3
während (1)
printf ("HTTP -Befehl senden. Zum Beenden drücken Sie Strg+c \ n ");
FGets (Buffer, 1025, Stdin);
send (socket_id, puffer, 1025, 0);
memset (& buffer, '\ 0', 1025);
//Schritt 4
recv (socket_id, puffer, 1025, 0);
// Schritt 5
printf ("%S \ n", Puffer);
memset (& buffer, '\ 0', 1025);

// Ende des Haupts
/************************************************************** **************//
/* Connect_to Funktion*/
int Connect_to ()
int port = 80;
im Terror;
int socket_id;
Zeichenpuffer [1025];
struct hostent *server;
struct sockaddr_in client;
memset (& server, 0, sizeof (server));
Server = GetHostByName ("www.Google.com ");
if (server == null)

printf ("\ nError erhalten Domänendaten.\N");
Rückkehr 1;

SOCKKET_ID = SOCKKET (AF_INET, SOCK_STREAM, 0);
Klient.sin_family = af_inet;
Klient.sin_port = htons (port);
bcopy ((char *) server-> h_addr,
(Char *) & Kunde.SIN_ADDR.S_ADDR,
sizeof (server-> h_length));
error = connect (socket_id, (struct sockaddr *) & client, sizeof (client));
if (Fehler < 0)
printf ("\ n kann nicht eine Verbindung zum Server \ n" herstellen);
close (socket_id);
Rückkehr 1;

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

Erstellen Sie eine Datei mit dem Namen „Beispiel.c ”und speichern Sie es in„ Dokumenten “. Kopieren Sie den Code und fügen Sie ihn dort ein. Speichern Sie es und kompilieren Sie den Code in GCC mit dem folgenden Befehl:

~ $ GCC -Dokumente/Beispiel.C -o Beispiel

Führen Sie dann das Programm mit dem folgenden Befehl aus:

~ $ ./Beispiel

Die Anwendung stellt eine Verbindung zu „www her.Google.com “und wartet darauf, dass wir einen HTTP -Befehl vorstellen.

In der folgenden Abbildung sehen wir den Befehl HTTP GET, der gesendet wird, und die Antwort des Servers, die von der abgerufen wird recv () Funktion in Puffer[].

So identifizieren Sie die Fehler, die die Recv () -Funktion in der C -Sprache erzeugen kann

Die Fehler, die bei der Verwendung der Funktion recv () auftreten können, sind variiert und reichen von Netzwerkfehlern bis hin zu falschen Puffergrößen. Die Definitionen dieser Codes und ihre numerische Darstellung finden Sie im „Errno.H ”-Header im Ordner„ ASM-Generic “und kann durch den Zugriff auf die auf die Zugriffe abgerufen werden Errno ganze Zahl.

Mit dem folgenden Snippet in Schritt 4 des vorherigen Codes rufen wir das auf recv () Funktion von einem IF -Zustand. Wenn ein Fehler auftritt, wird eine Nachricht gedruckt, gefolgt von der vordefinierten Nummer, die den in der gespeicherten Fehler identifiziert Errno ganze Zahl:

//Schritt 4
if (recv (socket_id, puffer, 1025, 0) < 0)
printf ("Fehler:%i", errno);

Im Folgenden finden Sie die Definitionen der Fehler, die durch die Funktion recv () und eine kurze Beschreibung jedes Fehlers generiert werden können:

Die folgende Abbildung zeigt den Fehler, der auftritt, wenn versucht wird, die Daten über eine nicht existierende Socket-Kennung zu empfangen. Der resultierende Fehler in Errno entspricht 88 „Sockelbetrieb auf Nicht-Socket“.

Abschluss

In diesem Linux -Hinweis Artikel, wir haben erklärt, wie die Funktion recv () verwendet wird, um die Daten über einen Socket zu empfangen. Wir haben uns die Syntax dieser Funktion sowie eine Beschreibung der Funktionsweise, der Eingabe- und Ausgabeargumente und der Datentypen angesehen, die sie akzeptieren.

Um zu sehen, wie diese Funktion funktioniert, haben wir eine Konsolenanwendung erstellt, in der wir die Funktion recv () verwendet haben, um die Antwort von einem Server über einen mit ihr verbundenen Socket zu erhalten. Wir haben Ihnen auch gezeigt, wie Sie einige der häufigsten Fehler identifizieren und klassifizieren, wenn Sie diese Funktion verwenden.

Wir hoffen, dass Sie diesen Artikel nützlich gefunden haben. Weitere Artikel über die C -Sprache und Linux -Tipps finden Sie die Suchmaschine auf unserer Website.