Skip to content
The Chat Archive
gpt-4-0314· OpenAI 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. Le processus pere crée un socket et envoie sur ce socket chaque seconde la chaine de caractères passée en argument à l’adresse 255.255.255.255 sur le port 2346. Le processus fils crée un autre socket, 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 tb l’adresse IP et le numéro de port de l’envoyeur. Après avoir reçu le message il se remet en attente. Toutes les 30 secondes le processus fils visualise le tableau tb.

  2. Assistant
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <sys/types.h>
    
    #define PORT 2346
    #define BUFSIZE 1024
    #define TIMEOUT 30
    #define IP "255.255.255.255"
    
    typedef struct {
        struct sockaddr_in addr;
        int count;
    } Entry;
    
    int main(int argc, char *argv[]) {
        if (argc != 2) {
            printf("Usage: %s <message>\n", argv[0]);
            return 1;
        }
    
        char *message = argv[1];
        int s1, s2, opt;
        struct sockaddr_in s1_addr, s2_addr, cli_addr;
        socklen_t addrlen = sizeof(cli_addr);
        char buffer[BUFSIZE];
        Entry tb[100];
        int tb_index = 0, tb_count = 0;
        pid_t pid;
    
        // Create sockets
        if ((s1 = socket(PF_INET, SOCK_DGRAM, 0)) == -1 ||
            (s2 = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
            perror("socket");
            return 2;
        }
    
        // Allow broadcast
        opt = 1;
        if (setsockopt(s1, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(int)) == -1) {
            perror("setsockopt");
            return 3;
        }
    
        // Bind s2 to listen for datagrams
        memset(&s2_addr, 0, sizeof(s2_addr));
        s2_addr.sin_family = AF_INET;
        s2_addr.sin_port = htons(PORT);
        s2_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        if (bind(s2, (struct sockaddr *)&s2_addr, sizeof(s2_addr)) == -1) {
            perror("bind");
            return 4;
        }
    
        pid = fork();
        if (pid == -1) {
            perror("fork");
            return 5;
        }
    
        if (pid > 0) { // parent process: sender
            // Set up destination address
            struct sockaddr_in dest_addr;
            memset(&dest_addr, 0, sizeof(dest_addr));
            dest_addr.sin_family = AF_INET;
            dest_addr.sin_port = htons(PORT);
            inet_pton(AF_INET, IP, &dest_addr.sin_addr);
    
            // Send message every second
            while (1) {
                sendto(s1, message, strlen(message), 0,
                       (struct sockaddr *)&dest_addr, sizeof(dest_addr));
                sleep(1);
            }
        } else { // child process: receiver
            while (1) {
                // Receive messages
                memset(buffer, 0, BUFSIZE);
                recvfrom(s2, buffer, BUFSIZE, 0, (struct sockaddr *)&cli_addr, &addrlen);
    
                // Check if message matches
                if (strcmp(buffer, message) == 0) {
                    int i;
                    for (i = 0; i < tb_count; i++) {
                        if (tb[i].addr.sin_addr.s_addr == cli_addr.sin_addr.s_addr &&
                            tb[i].addr.sin_port == cli_addr.sin_port) {
                            break;
                        }
                    }
                    // Update or add to tb
                    if (i < tb_count) {
                        tb[i].count++;
                    } else {
                        tb[tb_index].addr = cli_addr;
                        tb[tb_index].count = 1;
                        tb_index = (tb_index + 1) % 100;
                        if (tb_count < 100) {
                            tb_count++;
                        }
                    }
                }
                // Show tb every TIMEOUT seconds
                static int timer = 0;
                if (++timer == TIMEOUT) {
                    timer = 0;
                    printf("Counters:\n");
                    for (int i = 0; i < tb_count; i++) {
                        char ip[INET_ADDRSTRLEN];
                        inet_ntop(AF_INET, &tb[i].addr.sin_addr, ip, INET_ADDRSTRLEN);
                        printf("%s:%d - %d\n",
                               ip, ntohs(tb[i].addr.sin_port), tb[i].count);
                    }
                }
    
                usleep(1000000); // sleep 1 second
            }
        }
    
        return 0;
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.