Comment écrire un client / serveur TCP simple en C

La réponse est que l'écriture d'un client et serveur TCP simples nécessite l'interface de programmation de socket fournie par le système d'exploitation. Le serveur termine la communication en créant des prises, des adresses de liaison, en écoutant les ports, en acceptant les connexions et en envoyant et recevant des données. Le client réalise l'interaction en créant des sockets, en se connectant aux serveurs, en envoyant des demandes et en recevant des réponses. L'exemple de code montre l'implémentation de base de l'utilisation de l'API Socket Berkeley sur Linux ou MacOS, y compris les fichiers d'en-tête nécessaires, les paramètres du port, la gestion des erreurs et la version des ressources. Après la compilation, exécutez d'abord le serveur, puis exécutez le client pour obtenir une communication bidirectionnelle. La plate-forme Windows doit initialiser la bibliothèque WinSock. Cet exemple est un modèle d'E / S de blocage, adapté à l'apprentissage de la programmation de base de socket.

L'écriture d'un client et serveur TCP simples en C implique l'utilisation de l'interface de programmation Socket fournie par le système d'exploitation (généralement l'API Berkeley Sockets sur les systèmes de type UNIX, ou WinSock sur Windows). Vous trouverez ci-dessous un exemple de base qui fonctionne sur Linux ou MacOS. Pour Windows, de légères modifications sont nécessaires (comme initialiser Winsock).

Serveur TCP de base en C

Le serveur écoute un port, accepte une connexion client, reçoit un message et envoie une réponse.

 // server.cpp
#include <iostream>
#include <cstring>
#include <sys / socket.h>
#include <netinet / in.h>
#include <unistd.h>

int main () {
    int server_fd, new_socket;
    struct sockaddr_in adresse;
    int addRlen = sizeof (adresse);
    tampon char [1024] = {0};
    const char * hello = "Hello from Server";

    // Créer un descripteur de fichiers de socket
    if ((server_fd = socket (af_inet, sock_stream, 0)) == 0) {
        perror ("socket a échoué");
        exit (exit_failure);
    }

    // Définir l&#39;adresse du serveur
    adresse.sin_family = af_inet;
    adresse.sin_addr.s_addr = inaddr_any;
    adresse.sin_port = htons (8080);

    // lier la prise
    if (bind (server_fd, (struct sockaddr *) & adresse, sizeof (adresse)) <0) {
        perror ("Bind a échoué");
        close (server_fd);
        exit (exit_failure);
    }

    // écoute les connexions entrantes
    if (écouter (server_fd, 3) <0) {
        Perror ("écouter");
        close (server_fd);
        exit (exit_failure);
    }

    std :: cout << "Écoute du serveur sur le port 8080 ... \ n";

    // accepte une connexion
    if ((new_socket = accepter (server_fd, (struct sockaddr *) & adresse, (socklen_t *) & addrlen)) <0) {
        Perror ("accepter");
        close (server_fd);
        exit (exit_failure);
    }

    // Lire les données du client
    lire (new_socket, tampon, 1024);
    std :: cout << "Client:" << Buffer << std :: endl;

    // Envoyez la réponse
    envoyer (new_socket, bonjour, strlen (bonjour), 0);
    std :: cout << "bonjour message envoyé \ n";

    // nettoyage
    close (new_socket);
    close (server_fd);
    retour 0;
}

Client TCP de base en C

Le client se connecte au serveur, envoie un message et lit la réponse.

 // client.cpp
#include <iostream>
#include <cstring>
#include <sys / socket.h>
#include <arpa / inet.h>
#include <unistd.h>

int main () {
    Int sock = 0;
    struct sockaddr_in sert_addr;
    const char * hello = "Hello from client";
    tampon char [1024] = {0};

    // Créer une prise
    if ((sock = socket (af_inet, sock_stream, 0)) <0) {
        Perror ("Erreur de création de socket");
        retour -1;
    }

    serv_addr.sin_family = af_inet;
    serv_addr.sin_port = htons (8080);

    // convertir l&#39;adresse IPv4 du texte en binaire
    if (inet_pton (af_inet, "127.0.0.1", & serv_addr.sin_addr) <= 0) {
        perror ("adresse / adresse non valide non prise en charge");
        Fermer (chaussette);
        retour -1;
    }

    // Connectez-vous au serveur
    if (connect (sock, (struct sockaddr *) & serv_addr, sizeof (serv_addr)) <0) {
        perror ("Connexion a échoué");
        Fermer (chaussette);
        retour -1;
    }

    // Envoyer un message au serveur
    Envoyer (Sock, bonjour, strlen (bonjour), 0);
    std :: cout << "bonjour message envoyé \ n";

    // Lire la réponse
    lire (chaussette, tampon, 1024);
    std :: cout << "Server:" << buffer << std :: endl;

    // nettoyage
    Fermer (chaussette);
    retour 0;
}

Comment compiler et courir

Sur Linux / macOS:

 G serveur.
g client.cpp -o client

# Terminal 1
./serveur

# Terminal 2 (après l'exécution du serveur)
./client

Sortie attendue:

• Impressions du serveur: Server listening on port 8080... , puis le message client, puis Hello message sent .
• Imprimés du client: Hello message sent , puis Server: Hello from server .

Points clés

• En-têtes : sys/socket.h , netinet/in.h , arpa/inet.h , unistd.h sont essentiels pour la programmation de socket sur Unix.
• Port : Le serveur se lie au port 8080. Assurez-vous qu'il est gratuit.
• Adresse IP : le client utilise 127.0.0.1 (LocalHost). Modifier si vous connectez à un serveur distant.
• Blocage E / S : Ces exemples utilisent des prises de blocage. Les applications réelles peuvent utiliser des E / S non bloquantes ou plusieurs threads.
• Gestion des erreurs : vérifiez toujours les valeurs de retour des fonctions de socket.

Notes pour Windows

Sur Windows, vous devez:

• Inclure <winsock2.h> et lien avec ws2_32.lib .
• Appelez WSAStartup() avant d'utiliser des sockets.
• Appelez WSACleanup() à la fin.

Exemple d'extrait:

 Wsadata Wsadata;
Wsastartup (makeword (2,2), & wsadata);
// ... code de prise ...
Wsacleanup ();

Il s'agit d'un exemple de travail minimal. En production, vous ajouteriez une récupération d'erreur, une prise en charge de plusieurs clients (en utilisant fork , les threads ou les E / S asynchrones) et une meilleure cadrage de données.

Fondamentalement, les éléments essentiels pour faire parler une paire de douilles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!