Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

Ecrire un programme C prenant en argument une chaine de caracteres. Ce programme utilise…

  1. User

    Ecrire un programme C prenant en argument une chaine de caracteres. Ce programme utilise les sockets UDP. Il crée 2 processus/ Un des processus envoie chaque seconde la chaine de caractères passée en argument à l'adresse 255.255.255.255 sur le port 2346. L'autre processus attend les chaines sur le port 2346 et lorsqu'une chaine reçue est identique à celle passée en argument il met dans un tableau l'adresse IP et le numéro de port de l'envoyeur. Il visualise ce tableau toutes les 30 secondes.

  2. Assistant

    Voici un exemple de programme qui effectue les opérations demandées:

    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <stdbool.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    #define PORT 2346
    #define BUFFER_SIZE 1024
    #define IP_TABLE_SIZE 32
    
    typedef struct {
        char ip[INET_ADDRSTRLEN];
        int port;
    } TableRow;
    
    void sender(char *message) {
        int sockfd;
        struct sockaddr_in dest_addr;
    
        if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
            perror("socket error");
            exit(1);
        }
    
        int broadcast = 1;
        setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
    
        memset(&dest_addr, 0, sizeof(dest_addr));
        dest_addr.sin_family = AF_INET;
        dest_addr.sin_port = htons(PORT);
        dest_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    
        while (true) {
            sendto(sockfd, message, strlen(message), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
            sleep(1);
        }
    }
    
    void receiver(char *message) {
        int sockfd;
        struct sockaddr_in local_addr, remote_addr;
    
        if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
            perror("socket error");
            exit(1);
        }
    
        memset(&local_addr, 0, sizeof(local_addr));
        local_addr.sin_family = AF_INET;
        local_addr.sin_port = htons(PORT);
        local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
        if (bind(sockfd, (const struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
            perror("bind error");
            exit(1);
        }
    
        TableRow ip_table[IP_TABLE_SIZE] = {0};
        int table_index = 0;
    
        while (true) {
            socklen_t addr_len = sizeof(remote_addr);
            char buffer[BUFFER_SIZE];
            ssize_t msg_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, (struct sockaddr *)&remote_addr, &addr_len);
            buffer[msg_len] = '\0';
    
            if (strcmp(buffer, message) == 0) {
                inet_ntop(AF_INET, &(remote_addr.sin_addr), ip_table[table_index].ip, INET_ADDRSTRLEN);
                ip_table[table_index].port = ntohs(remote_addr.sin_port);
                table_index = (table_index + 1) % IP_TABLE_SIZE;
            }
    
            sleep(30);
            for (int i = 0; i < IP_TABLE_SIZE; i++) {
                if (ip_table[i].port != 0) {
                    printf("%s:%d\n", ip_table[i].ip, ip_table[i].port);
                }
            }
        }
    }
    
    int main(int argc, char *argv[]) {
        if (argc < 2) {
            printf("Usage: %s <message>\n", argv[0]);
            exit(1);
        }
    
        pid_t pid = fork();
    
        if (pid < 0) {
            perror("fork error");
            exit(1);
        } else if (pid == 0) {
            sender(argv[1]);
            exit(0);
        } else {
            receiver(argv[1]);
        }
    
        return 0;
    }
    

    Ce programme crée deux processus distincts à l'aide de l'appel système fork(). L'un des processus est responsable de l'envoi du message, tandis que l'autre est responsable de la réception. Chaque processus utilise les sockets UDP pour envoyer et recevoir des messages.

    Le processus d'envoi envoie le message entré en argument au programme à l'aide de l'adresse de diffusion 255.255.255.255 et du port 2346. Le message est envoyé toutes les secondes.

    Le processus de réception attend les messages sur le port 2346. Lorsqu'il reçoit un message, il vérifie si le message est identique à celui passé en argument. Si c'est le cas, il ajoute l'adresse IP et le numéro de port de l'expéditeur au tableau et l'affiche toutes les 30 secondes.