Configurer un serveur en langage C

Il est difficile de mettre en place un serveur en langage c. Le but de cet article est de permettre aux nouveaux arrivants et aux personnes qui n'ont jamais écrit de serveur de le déplacer pour le moment et de répondre dans une certaine mesure à quelques questions. Si vous devez créer un serveur et travaillez actuellement, vous pouvez gagner du temps en copiant le code ci-dessous et en le réécrivant selon les spécifications de votre entreprise. Cette fois, ce sera très simple en UDP. Je pense que cela peut ne pas être suffisant pour les besoins réels. Cependant, il est plus facile d'avancer lorsque vous êtes connecté que lorsque vous n'avez ni mains ni jambes. À partir de là, jouez avec le code qui correspond à vos besoins. Il n'y a aucune explication dans cet article sur ce qu'est UDP. Il y a tellement d'explications sur Internet qu'elles sont pourries, alors veuillez les utiliser. Pour les livres, «Computer Network 5th Edition» est bon, mais le prix et l'épaisseur sont si ...

environnement

Je vais mettre l'environnement que j'ai essayé pour le moment, mais je pense qu'il fonctionnera avec des linux relativement récents.

Ubuntu 18.04.2 LTS
gcc 7.4.0

Serveur UDP simple

Du point de vue de la mise en œuvre, UDP peut être considéré comme un simple TCP.

En tant que simple serveur

Les données sont reçues de localhost`` 9002 --Afficher les données reçues

Pour le moment, le code qui fonctionne si vous le copiez et le collez ressemble à ceci.

#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <errno.h>

#include <stdio.h>
#include <string.h>

int main ()
{
  //1.Créer une adresse de réception
  struct addrinfo hints;
  memset (&hints, 0, sizeof (hints));
  hints.ai_socktype = SOCK_DGRAM;

  struct addrinfo *bind_address;
  getaddrinfo ("localhost", "9002", &hints, &bind_address);


  //2.Créer une prise
  int  socket_listen;
  socket_listen = socket (bind_address->ai_family,
              bind_address->ai_socktype,
              bind_address->ai_protocol);
  if (socket_listen < 0)
  {
      fprintf (stderr, "socket() failed. (%d)\n", errno);
      return 1;
  }


  //3.Liez l'adresse locale au socket
  if (bind (socket_listen, bind_address->ai_addr, bind_address->ai_addrlen))
  {
      fprintf (stderr, "bind() failed. (%d)\n", errno);
      return 1;
  }
  freeaddrinfo (bind_address);


  //4.Attendez la connexion client
  while (1)
  {
      struct sockaddr_storage client_address;
      socklen_t client_len = sizeof (client_address);

      char read[4096];
      memset(read, 0, sizeof(read));
      int bytes_received = recvfrom (socket_listen, read, 4096, 0,
                     (struct sockaddr *) &client_address,
                     &client_len);
      if (bytes_received < 1)
      {
        fprintf (stderr, "connection closed. (%d)\n", errno);
        return 1;
      }
      printf("receiving: %s", read);
  }

  //5.Fermer la prise
  close(socket_listen);
  printf ("Finished.\n");

  return 0;
}

Un petit commentaire

1. Créez une adresse de réception

Il existe plusieurs façons de créer une structure de connexion.

Comment définir manuellement les membres un par un --Comment utiliser la fonction gethostbyname --Comment utiliser la fonction getaddrinfo

Cette fois, je l'ai construit par la troisième méthode.

Il y a trois tâches pour utiliser la fonction getaddrinfo.

Décidez de l'adresse de réception
Décidez du numéro de port de réception
Définissez un indice ʻaddrinfo structure`

La «structure addrinfo» en 3 définit généralement ip4 ou ip6, TCP ou UDP. Si ip vaut 0, il devient ip4. SOCK_DGRAM est un datagramme, et lorsqu'il est défini, il devient UDP. Je ne l'ai pas utilisé cette fois, mais la valeur de retour de la fonction getaddrinfo est errno, donc si vous le faites correctement, vous devriez la recevoir.

2. Créez un socket

C'est celui qui écrit avec une habitude aussi complète, peu importe qui le fait. Un socket est un terminal de communication (sur un programme), et le système d'exploitation envoie et reçoit via le socket. La fonction socket crée un descripteur de socket. Un descripteur de socket est un type de descripteur de fichier. Un descripteur de fichier est un numéro unique qui permet au système d'exploitation de gérer les fichiers. linux traite diverses choses comme des fichiers. Fichiers texte, périphériques (comme une clé USB), etc. Pour pouvoir lire et écrire sur le réseau de la même manière que des fichiers C'est le rôle du descripteur de socket. La valeur de retour de la fonction socket est le descripteur de socket.

3. Liez l'adresse locale au socket

C'est aussi une habitude. Associez l'adresse reçue par la fonction de liaison au socket. Vous êtes maintenant prêt à recevoir.

4. Attendez que le client se connecte

Le processus le plus important. Je suis sûr que nous allons faire diverses choses ici dans ce chan. Normalement, le serveur n'est pas abandonné, donc il boucle indéfiniment. Utilisez la fonction recvfrom pour recevoir. La fonction recvfrom reçoit les informations source. La structure sockaddr_storage est une structure qui peut être représentée par ip4 ou ip6.

5. Fermez la prise

Comme la mémoire et les threads, les sockets fuient, vous devez donc les ouvrir. La fonction de fermeture est utilisée pour fermer le fichier. Puisque le socket peut également être traité comme un fichier, il peut être ouvert avec la même «fonction de fermeture» que le fichier.

Pour le moment, le client

J'ai l'impression que je n'en ai pas besoin. Je lis la fonction de connexion même si c'est UDP. En fait, vous pouvez utiliser la fonction de connexion dans UDP. Vous pouvez également écrire à l'aide de la fonction de connexion sur le serveur. Lorsque vous utilisez la fonction de connexion dans UDP, elle se comporte différemment lorsque vous l'utilisez dans TCP. L'explication ici est ... eh bien.

#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <errno.h>

#include <stdio.h>
#include <string.h>

int main(void)
{
    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_DGRAM;
    struct addrinfo *peer_addr;

    if(getaddrinfo("localhost","9002",&hints, &peer_addr))
    {
        fprintf(stderr, "getaddrinfo() failed. (%d)\n", GETSOCKETERRNO());
        return 1;
    }

    char addrbuf[100];
    char servbuf[100];
    getnameinfo(peer_addr->ai_addr, peer_addr->ai_addrlen, addrbuf, sizeof(addrbuf), servbuf, sizeof(servbuf), NI_NUMERICHOST);
    printf("%s %s\n", addrbuf, servbuf);

    puts("Creating socket");
    int socket_peer;
    socket_peer = socket(peer_addr->ai_family, peer_addr->ai_socktype, peer_addr->ai_protocol);
    if(!ISVALIDSOCKET(socket_peer))
    {
        fprintf(stderr, "socket() failed. (%d)\n", GETSOCKETERRNO());
        return 1;
    }

    if(connect(socket_peer,peer_addr->ai_addr, peer_addr->ai_addrlen))
    {
        fprintf(stderr,"connect() failed. (%d).\n", GETSOCKETERRNO());
        return 1;
    }

    freeaddrinfo(peer_addr);

    puts("Connected");

    while(1)
    {

        {
            char read[4096];
            if(!fgets(read, 4096, stdin)) break;

            int bytes = send(socket_peer, read, strlen(read), 0);
            printf("send %d bytes\n", bytes);
        }

    }
    puts("Closing socket");
    CLOSESOCKET(socket_peer);
    return 0;
}

Configurer un serveur UDP en langage C