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

Ecrire un programme C multiprocessus utilisant les sockets UDP envoyant chaque seconde…

  1. User

    Ecrire un programme C multiprocessus utilisant les sockets UDP envoyant chaque seconde une chaine de caractères passée en argument à l'adresse 255.255.255.255 sur le port 2346. Ce programme attend également des chaines sur le port 2346 et lorsqu'une chaine reçue est identique à la chaine passée en argument il met dans un tableau l'adresse IP et le numéro de port de l'envoyeur. Ce tableau sera visualisé toutes les 30 secondes.

  2. Assistant
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <stdbool.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <strings.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <sys/types.h>
    #include <time.h>
    
    #define SERVER_PORT 2346
    #define BUFSIZE 1024
    #define MAX_PEERS 16
    #define SHOW_PEERS_INTERVAL 30
    
    typedef struct {
        struct sockaddr_in addr;
        time_t timestamp;
    } Peer;
    
    static Peer peers[MAX_PEERS];
    static int num_peers = 0;
    
    bool find_peer(struct sockaddr_in addr) {
        for (int i = 0; i < num_peers; i++) {
            if (peers[i].addr.sin_addr.s_addr == addr.sin_addr.s_addr &&
                peers[i].addr.sin_port == addr.sin_port) {
                peers[i].timestamp = time(NULL);
                return true;
            }
        }
        return false;
    }
    
    void add_peer(struct sockaddr_in addr) {
        if (num_peers >= MAX_PEERS) {
            printf("Erreur: nombre maximum de pairs atteint (%d)\n", MAX_PEERS);
            return;
        }
        peers[num_peers].addr = addr;
        peers[num_peers].timestamp = time(NULL);
        num_peers++;
    }
    
    void show_peers() {
        printf("\nPairs connectés:\n");
        for (int i = 0; i < num_peers; i++) {
            printf("%s:%d\n", inet_ntoa(peers[i].addr.sin_addr), ntohs(peers[i].addr.sin_port));
        }
        printf("\n");
    }
    
    int main(int argc, char **argv) {
        if (argc != 2) {
            fprintf(stderr, "Usage: %s <chaine>\n", argv[0]);
            exit(EXIT_FAILURE);
        }
    
        char *message = argv[1];
    
        int sockfd;
        struct sockaddr_in serveraddr, clientaddr;
    
        sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (sockfd < 0) {
            perror("Erreur: ouverture de socket");
            exit(EXIT_FAILURE);
        }
    
        int optval = 1;
        setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval));
    
        bzero(&serveraddr, sizeof(serveraddr));
        serveraddr.sin_family = AF_INET;
        serveraddr.sin_addr.s_addr = htons(INADDR_ANY);
        serveraddr.sin_port = htons(SERVER_PORT);
    
        if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0) {
            perror("Erreur: bind");
            exit(EXIT_FAILURE);
        }
    
        socklen_t clientlen = sizeof(clientaddr);
        char buf[BUFSIZE];
    
        time_t last_show_peers = time(NULL);
    
        while (true) {
            fd_set read_fds;
            FD_ZERO(&read_fds);
            FD_SET(sockfd, &read_fds);
    
            struct timeval timeout;
            timeout.tv_sec = 1;
            timeout.tv_usec = 0;
    
            int ready = select(sockfd + 1, &read_fds, NULL, NULL, &timeout);
            if (ready < 0) {
                perror("Erreur: select");
                exit(EXIT_FAILURE);
            } else if (ready == 0) {
                // Envoi du message toutes les secondes
                bzero(&clientaddr, clientlen);
                clientaddr.sin_family = AF_INET;
                clientaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
                clientaddr.sin_port = htons(SERVER_PORT);
                sendto(sockfd, message, strlen(message) + 1, 0, (struct sockaddr *)&clientaddr, clientlen);
            } else {
                // Réception d'un message
                bzero(buf, BUFSIZE);
                recvfrom(sockfd, buf, BUFSIZE, 0, (struct sockaddr *)&clientaddr, &clientlen);
    
                if (strcmp(buf, message) == 0) {
                    if (!find_peer(clientaddr)) {
                        add_peer(clientaddr);
                    }
                }
            }
    
            // Affichage des pairs toutes les 30 secondes
            if (difftime(time(NULL), last_show_peers) >= SHOW_PEERS_INTERVAL) {
                show_peers();
                last_show_peers = time(NULL);
            }
        }
    
        close(sockfd);
        return 0;
    }