Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

POSIX C Discussion :

Executer commande dans un processus fils !


Sujet :

POSIX C

  1. #1
    Nouveau Candidat au Club
    Executer commande dans un processus fils !
    Bonjour,
    je dois réaliser un projet et pour ça il me faut une fonction que j'ai nommé "test" qui crée un processus fils dans lequel j'éxecute une commande avec pour entrée une chaine envoyée par le père.
    Je pense que ma fonction "test" est juste car je l'ai testé sur des cas simples.
    Le problème est que la commande "execlp" ne s'execute pas à chaque fois. Je l'appelle dans une boucle, elle s'execute une fois sur deux lors du premier appelle et plus jamais lors des appelles suivants.

  2. #2
    Expert éminent sénior
    Citation Envoyé par jérôme.D
    int test(char* buff, char* accu)
    {
    Merci de lire les regles du forum
    Pas de Wi-Fi à la maison : CPL

  3. #3
    Expert éminent sénior
    Citation Envoyé par jérôme.D
    Bonjour,
    je dois réaliser un projet et pour ça il me faut une fonction que j'ai nommé "test" qui crée un processus fils dans lequel j'éxecute une commande avec pour entrée une chaine envoyée par le père.
    Je pense que ma fonction "test" est juste car je l'ai testé sur des cas simples.
    Le problème est que la commande "execlp" ne s'execute pas à chaque fois. Je l'appelle dans une boucle, elle s'execute une fois sur deux lors du premier appelle et plus jamais lors des appelles suivants.

    Pour vous aidez, je vous donne mon code de la fonction "test" :

    merci de me répondre...
    Alors là, en 1 jour au moins 3 thread sur les pipe, les fork et autres processus père, fils...

    Sont bien synchro dans l'éducation

    Bon désolé de dire ça mais ton code est horrible

    Voici ton code "corrigé" (je sais pas si ça marche j'ai pas testé) :
    A moins que je l'ai cassé plus je suis un peu fatigué

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
     
    int test(char* buff, char* accu)
    {
        /*--sky : déclaration des variables avant toute action */
        char temp[1024];
        char sortie[1024];
        /*
        --sky : Pourquoi une allocation dynamique pour une taille fixe?
        char *temp;
        char *sortie;
        */
        int fd1[2];
        int fd2[2];
        /*
        --sky : tu te sers pas de r et s
        int r,s;
        */
     
        /*
        --sky : Si on avait du laisser l'allocation dynamique
        --sky : Cast inutile en C
        temp = malloc(1024);
        sortie = malloc(1024);
        
        --sky : on vérifie si le malloc a echoué
        if(temp == NULL || sortie == NULL)
        {
            exit(EXIT_FAILURE);
        }
        */
     
        /*--sky : pipe peut echouer */
        //Création des pipes
        if(pipe(fd1) == -1)
        {
            perror("pipe");
            exit(errno);
        }
     
        if(pipe(fd2) == -1)
        {
            perror("pipe");
            exit(errno);
        }
     
        /*--sky : un switch c'est plus pratique */
        switch(fork())
        {
            /*--sky : fork peut echouer */
            case -1 :
            {
                perror("fork");
                exit(errno); /*--sky : #include <errno.h> */
            }
     
            case 0:
            {
                /*--sky : close peut echouer, ainsi que n'importe quel autre appel système */
                if(close(fd1[1]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
                if(close(fd2[0]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
     
                /*--sky : euh les commentaires sont pas bons là, a mois que ce soit les parametres des fonctions */
                if(dup2(fd1[0],0) == -1) //Sortie du pipe 1 sur l'entrée du fils
                {
                    perror("dup2");
                    exit(errno);
                }
     
                if(dup2(fd2[1],1) == -1) //Sortie standard du fils sur entrée du pipe 2
                {
                    perror("dup2");
                    exit(errno);
                }
     
                if(close(fd1[0]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
     
                if(close(fd2[1]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
     
                /*
                --sky : alors la je comprends pas les argument mais alors pas du tout
                read(0,temp,strlen(accu));
                */
                if(read(fd1[0], temp, sizeof temp) == -1)
                {
                    perror("read");
                    exit(errno);
                }
                printf("execution de la commande: %s\n",buff);
                /*--sky : au fait ca sert a quoi ce que tu recois par le pere je comprends pas */
                if(execlp(buff, buff, NULL) == -1)
                {
                    perror("execlp");
                    exit(errno);
                }
                exit(1);
            }
     
            default:
            {
                if(close(fd1[0]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
     
                if(close(fd2[1]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
     
                /*--sky : ou est l'interet d'envoyer une chaine de caractere au fils, alors que cette chaine est passé en argument? */
                if(write(fd1[1], accu, strlen(accu)) == -1)	//envoie de l'argument en entrée du pipe (donc sur l'entrée std du fils)
                {
                    perror("write");
                    exit(errno);
                }
     
                if(close(fd1[1]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
     
                while( r = read(fd2[0], sortie, sizeof sortie) > 0 )
                    printf("%s\n", sortie);
     
                /*--sky : pas vraiment utile */
                if(close(fd2[0]) == -1)
                {
                    perror("close");
                    exit(errno);
                }
            }
        }
     
        /*
        --sky : plus besoin des free
    	free(sortie);
    	free(temp);
        */
     
    	return 0;
    }
    Cette signature n'a pas pu être affichée car elle comporte des erreurs.

  4. #4
    Nouveau Candidat au Club
    merci pour l'aide,
    après correction de quelques petites erreurs, le programme marche bien.
    Je pense en effet, comme vous me l'avez dit, que le code n'était pas assez propre.
    Néanmoins, je ne comprend pas pourquoi les commentaires ne sont pas bon lorsque je fais:

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
                if(dup2(fd1[0],0) == -1) //Sortie du pipe 1 sur l'entrée du fils
                {
                    perror("dup2");
                    exit(1);
                }


    Dans ce cas, le dup2 ne permet-t-il pas de rediriger la sortie du premier tube vers l'entrée standard du fils?

  5. #5
    Expert éminent sénior
    Citation Envoyé par jérôme.D
    merci pour l'aide,
    après correction de quelques petites erreurs, le programme marche bien.
    Je pense en effet, comme vous me l'avez dit, que le code n'était pas assez propre.
    Néanmoins, je ne comprend pas pourquoi les commentaires ne sont pas bon lorsque je fais:

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
                if(dup2(fd1[0],0) == -1) //Sortie du pipe 1 sur l'entrée du fils
                {
                    perror("dup2");
                    exit(1);
                }


    Dans ce cas, le dup2 ne permet-t-il pas de rediriger la sortie du premier tube vers l'entrée standard du fils?
    Ici en fait tu copies connectes le côté de la lecture à stdin.
    Cette signature n'a pas pu être affichée car elle comporte des erreurs.

  6. #6
    Membre à l'essai
    plusieurs facons de faire
    en fait il y a plusieurs facons de resoudre ce petit pbme,


    1- tu cré un nouveau processus carrement pour qu'il execute execlp()
    2- tu utilises execl() au lieu de execlp()
    3- tu utilises la fonction system("commande"), il permet d'executer des commandes systeme
    4- shell#man execl ===> pour plus d'infos et de details

    heuresement jé dépassé ce genre de choses

  7. #7
    Membre éprouvé
    Citation Envoyé par sarihmohamed
    en fait il y a plusieurs facons de resoudre ce petit pbme,

    1- tu cré un nouveau processus carrement pour qu'il execute execlp()
    2- tu utilises execl() au lieu de execlp()
    3- tu utilises la fonction system("commande"), il permet d'executer des commandes systeme
    4- shell#man execl ===> pour plus d'infos et de details

    heuresement jé dépassé ce genre de choses
    1. C'est ce qui est fait dans le post initial.
    2. La différence entre execl et execlp concerne la façon de chercher l'exécutable.
    [alkama] quelqu'un est allé voir la guerre des mondes?
    [@Chrisman] j'espère pour spielberg
    --- bashfr.org