projet-multitaches/src/server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>

#include "server.h"
#include "common.h"


/* booléen pour la boucle d'acceptation */
int RUN = 1;

int main(void) {
    int serv_sock_fd, child_sock_fd; // socket id = file descriptor
    struct sockaddr_in server_socket;
    struct sockaddr_in child_socket; // on définit juste, les valeurs seront récuperées dans accept()
    pid_t pid;
    long addr_len; // pour récuperer la longueur de l'adresse dans accept()

    /* Gestion des signaux */
    signal(SIGCHLD, interrupt);
    signal(SIGINT, interrupt);
    signal(SIGTERM, interrupt);

    /* Initialisation des valeurs par défaut du socket */
    server_socket.sin_family = AF_INET;
    #ifdef PORT
    server_socket.sin_port = htons(PORT); // port dans l'ordre des octets réseau
    #else
    server_socket.sin_port = 0;
    #endif
    server_socket.sin_addr.s_addr = makeip4(127, 0, 0, 1);
    // server_socket.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    /* Définition du socket */
    if ((serv_sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
        perror("socket");
        return EXIT_FAILURE;
    }

    /* bind() avec un cast d'un struct générique, le type de struct sera découvert dans sa_family */
    if (bind(serv_sock_fd, (struct sockaddr *) &server_socket, sizeof(server_socket)) == -1) {
        perror("bind");
        return EXIT_FAILURE;
    }

    /* On récupere le port d'attache */
    addr_len = sizeof(server_socket);
    if (getsockname(serv_sock_fd, (struct sockaddr *) &server_socket, (socklen_t *) &addr_len) < 0) {
        perror("getsockname");
        return EXIT_FAILURE;
    } else {
        printf("Connexion de %s !\n", ip4tostring(ntohl(makeip4(127, 0, 0, 1))));
        printf("Le serveur est attaché au port %d\n", ntohs(server_socket.sin_port));
    }

    /* On définit le nombre d'écoutes simultanées */
    if (listen(serv_sock_fd, 10) == -1) {
        perror("listen");
        return EXIT_FAILURE;
    }

    /* On laisse le serveur accepter des connexions
     * A chaque connexion établie, le serveur crée un fils pour gérer celle-ci. */
    while (RUN) {
        if ((child_sock_fd = accept(serv_sock_fd, (struct sockaddr *) &child_socket, (socklen_t *) &addr_len)) < 0) {
            perror("accept");
        } else {
            printf("Connexion de %s !\n", ip4tostring(ntohl(child_socket.sin_addr.s_addr)));

            /* Création d'un processus dédié au client */
            if ((pid = fork()) == -1) {
                perror("fork");
                write(child_sock_fd, "Erreur serveur !\n", 18);
            } else {
                if (pid == 0) { // code du fils
                    service(child_sock_fd); // Regroupe le code pour le fils
                    return 0;
                }
            }
            close(child_sock_fd); // On ferme le file descriptor qu'on vient de créer puisque c'est le fils qui s'en occupe
        }
    }

    return EXIT_SUCCESS;
}

void service(int fd) {
    int i, n, t;
    pid_t pid2;
    char buf[BUF_LEN], buf2[BUF_LEN], eot = EOT;
    void *memory = NULL;
    char **command_line;
    char delim[4];
    char *token, *text;

    delim[0] = ' ';
    delim[1] = '\t';
    delim[2] = '\n';
    delim[3] = '\0';

    while (1) {
        /* Lecture du répertoire */
        if ((n = readline(fd, buf, BUF_LEN)) == -1) {
            sprintf(buf, "Erreur réception message : sans doute trop long !\n");
            write(fd, buf, strlen(buf) + 1);
        } else {
            /* Exécution de ls vers le pipe */
            if ((pid2 = fork()) == -1) {
                sprintf(buf, "Erreur système ! Revenez plus tard !\n");
                write(fd, buf, strlen(buf) + 1);
                close(fd);
                return;
            } else {
                if (pid2 == 0) { // code du fils qui execute la commande
                    /* Il a dans buf la commande a executer */

                    /* Redirection de stdout et stderr vers le socket */
                    dup2(fd, STDOUT_FILENO);
                    dup2(fd, STDERR_FILENO);

                    strcpy(buf2, buf);
                    text = buf;
                    t = 0;
                    while ((token = strtok_r(text, delim, &text)) != NULL) {
                        t++;
                    }
                    t++; // Pour ajouter le NULL à la fin

                    if ((memory = malloc(t * sizeof(memory))) == NULL) {
                        sprintf(buf, "Erreur mémoire ! Revenez plus tard !\n");
                        write(fd, buf, strlen(buf) + 1);
                        close(fd);
                        return;
                    }
                    command_line = (char**) memory;

                    text = buf2;
                    for (i = 0; ((token = strtok_r(text, delim, &text)) != NULL); i++) {
                        command_line[i] = token;
                    }
                    command_line[i] = NULL;

                    execvp(command_line[0], command_line);

                    /* Si le execvp a marché le code suivant ne sera jamais executé.
                     * Pas besoin donc de faire un test */
                    perror("execvp");
                    exit(1);
                }
                /* Suite du pere */
                wait(NULL); // Attend la fin du fils
                write(fd, &eot, 1);
            }
        }
    }
    close(fd);
}

void interrupt(int signal) {
    switch (signal) {
        case SIGCHLD:
            while (waitpid(-1, NULL, WNOHANG) != -1);
            break;
        case SIGINT:
            RUN = 0;
            exit(EXIT_FAILURE);
            break;
        case SIGTERM:
            fprintf(stderr, "Arret du serveur !\n");
            exit(0);
            break;
        default:
            fprintf(stderr, "Reçu signal %d !?!\n", signal);
            break;
    }
}