Bonjour,

Je souhaite coder un minishell qui serait une pâle copie d'un terminal à ma portée ( sans se prendre la tête a refaire toute les commandes ) ;

Au début cela fonctionnait très bien en utilisant un recouvrement simple ( exec ) mais ne maîtrisant pas encore les tubes j'ai récupérer une fonction et l'est adapté pour mon programme pour gérer les flux de sortie , ici c'est "char *redirection_sortie(char *commande[], int index)"

J'aurai beaucoup de mal a expliquer le problème avec des phrases claire, il y a un bug et je ne vois pas trop comment le résoudre. Par exemple il survient lorsque je test le programme dans cet ordre :

$ ./my_shell

( affichage environement ) - $ echo ok

-------------------------------- ok ( tout vas bien )

---------------------$echo ok > tmp

---------------------$cat tmp

ok

---------------------$echo ok >> tmp

---------------------$cat tmp

ok

ok

---------------------$ echo ok

ok

---------------------$ ls

( c ok )

Jusque la tout à l'air bon

---------------------$ echo ok > tmp

ok

---------------------$ ls

ok

AIE !!!!! Par contre, si je relance ls juste après l'échec ça remarche.

C'est comme si c'était nécessaire de refresh l'affichage entre 2 commandes, l'une qui écrit dans un fichier et l'autre qui affiche sur stdout

Mais bon j'aimerai que ca marche tout le temps :/

Je vous donne le code et le makefile si vous voulez le lancer par vous même ( ou bien récupérer une fonction pour vous ou autre )

donc ./src/shell.c (faite pas ettention aux en tête pour celui la ):

#include <unistd.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <signal.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>

#include <errno.h>

#include "IO.h"
#include "cmd.h"

int main( int argc, char ** argv )
{
  printf("%d\n",getpid());
  (void)argc;
  (void)argv;

  char *input = NULL;
  display_path();
  while((input = scan_cmd())){
    if(strcmp(input,"exit")==0)
      break;
    traiter_commande(input);
    display_path();
  }

  return 0;
}

./src/cmd.c : ( avec la fonction que j'ai récup )

#include <stdio.h>
#include <stdlib.h>

#include <unistd.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <signal.h>

#include "cmd.h"

char buf, sortie[10000];

void traiter_commande(char *commande){

  char **cmd = decomp_execvp_format(commande);
  if(cmd[0]==NULL)
    return ;
  char *out_file = (char*)malloc(sizeof(char)*MAX_STRING);
  T_WRITE write_type = find_out_file(cmd,&out_file);

  char *result = redirection_sortie(cmd, 0);
  ecrire_sortie(result,out_file,write_type);


}

char *redirection_sortie(char *commande[], int index)
{
           int tube[2];
           pid_t cpid;

           int i=0;

           if (pipe(tube) == -1) {
               perror("Le pipe n'a pas fonctionné");
               exit(EXIT_FAILURE); // quitte le programme si le pipe n'est pas créé
           }

           cpid = fork();
           if (cpid == -1) {
               perror("Le fork n'a pas fonctionné");
               exit(EXIT_FAILURE); // quitte le programme si le fork n'as pas fonctionné
           }

           if (cpid != 0) {    /* Le pere est lecteur sur le tube */
               close(tube[1]);          /* Fermeture du coté écriture non utilisé par le pere */

        /* cette boucle while permet de lire les caractères présent sur le coté lecture du tube et les stocker dans la chaine sortie */
               while (read(tube[0], &buf, 1) > 0){

           sortie[i]=buf; // rempli la chaine sortie caractère par caractère
           i++;
           sortie[i]='\0'; // indique la fin de la chaine de caractère

           }


           close(tube[0]); // fermeture du coté lecture du tube une fois la lecture une fois que la fonction read a renvoyé 0 : EOF, la lecture terminée
           return sortie; // la fonction retourne la chaine qui contient le contenu de la sortie standard
               exit(EXIT_SUCCESS);

           } else {                             /* Le fils écrit dans le tube  */
               close(tube[0]);          /* Fermeture du coté lecture non utilisé par le fil */
               dup2(tube[1],1);     /* */
               execvp(commande[index],commande + index);
               close(tube[1]);          /* Le pere lecteur verra un "EOF" ce qui permet la synchronisation */
               wait(NULL);              /* Attendre que le fils se termine */
               exit(EXIT_SUCCESS);
           }

}

le ./src/cmd.h

#ifndef __CMD_H__
#define __CMD_H__

#include "traitement.h"
#include "IO.h"

void traiter_commande(char *chaine);
char *redirection_sortie(char *commande[], int index);


#endif

le ./src/traitement.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#include "traitement.h"

char ** decomp_execvp_format(char *chaine)
{
  char **formated =NULL;
  formated=(char**)malloc(sizeof(char*) * MAX_ARG);
  assert(formated!=NULL);
  for(int i = 0 ; i < MAX_ARG ; i ++){
      formated[i]=(char*)malloc(sizeof(char) * MAX_STRING);
      assert(formated[i]!=NULL);
  }

  int i = 0 ;

  while(sscanf(chaine,"%s ",formated[i])!=EOF){
    chaine = chaine + strlen(formated[i]) + 1 ;
    i++;
  }

  formated[i]=NULL;

  return formated;
}

T_WRITE find_out_file(char **src,char **dest)
{
  assert(dest!=NULL);
  assert(src[0]!=NULL);

  T_WRITE w_type = T_NONE ;

  int i = 1 ;

  while(src[i]!=NULL){
    if(strcmp(src[i],">")==0){
      if(src[i+1]==NULL){
        *dest=NULL;

        break;
      }
      else{
        *dest=src[i+1];
        src[i]=NULL;
        w_type = T_REPLACE ;
        break;
      }
    }
    if(strcmp(src[i],">>")==0){
      if(src[i+1]==NULL){
        *dest=NULL;

        break;
      }
      else{
        *dest=src[i+1];
        src[i]=NULL;
        w_type = T_CONCAT ;
        break;
      }
    }
    i++;
  }
  return w_type;
}

le ./src/traitement.h

#ifndef __TRAITEMENT_H__
#define __TRAITEMENT_H__

#define MAX_ARG 30
#define MAX_STRING 127

typedef enum {T_NONE,T_REPLACE,T_CONCAT} T_WRITE ;

char ** decomp_execvp_format(char *commande);
T_WRITE find_out_file(char **src,char **dest);


#endif

le ./src/IO.c (si vous voulez les même affichage que l'exemple supprimer la l.31 )

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "IO.h"

extern char **environ;


char * scan_cmd()
{
  char *input = (char*)malloc(sizeof(char)*MAX_INPUT);
  char c;
  int i = 0 ;

  while((c = getchar()) != EOF ){
    if(c=='\n') return input ;
    input[i]=c;
    i++;
  }
  return "exit";
}

void display_path()
{
  printf("[%s:%s]$ ",getenv("USER"),getenv("PWD"));
}

void ecrire_sortie(char *result, char *out_path, T_WRITE write_type)
{
    printf("résult : %s\n",result);
  FILE *out_file = NULL ;
  switch(write_type){
    case T_CONCAT:
      out_file = fopen(out_path,"a");
      break;
    case T_REPLACE :
      out_file = fopen(out_path,"w");
      break;
    case T_NONE:
      fprintf(stdout,"%s",result);
      return ;
  }

  assert(out_file!=NULL);
  fprintf(out_file,"%s",result);
  fclose(out_file);
}

et enfin le ./src/IO.h

#ifndef __IO_H__
#define __IO_H__

#define MAX_INPUT 124

#include "traitement.h"

char * scan_cmd();
void display_path();
void ecrire_sortie(char *result, char *out_path, T_WRITE write_type);


#endif

A oui pour finir le makefile ( pensez a créer le répertoire obj/ ou bien modifié OBJ dans le makefile ) :

#CC Compilateur utilisé
CC = gcc

#COMPILER_FLAGS Options de compilation additionelles 
COMPILER_FLAGS = -W -Wall -pedantic -std=gnu99


#LINKER_FLAGS Librairie linker
LINKER_FLAGS = -lm

#EXEC_NAME Nom de l'executable
EXEC_NAME = my_shell

#DPD Nom du fichier où sont les dépendances sont écrites
DPD = .my-depend.txt

#OBJ Répertoire des objects ( .o )
OBJ = ./obj

#SRC Répertoire des sources ( .h .c ) 
SRC = ./src

#OBJS Liste des objects nécessaires
OBJS = $(OBJ)/shell.o $(OBJ)/IO.o $(OBJ)/cmd.o $(OBJ)/traitement.o

#SRCS Liste des .c nécessaires
SRCS = $(SRC)/shell.c $(SRC)/IO.c $(SRC)/cmd.c $(SRC)/traitement.c


all :: $(EXEC_NAME)

$(EXEC_NAME) : $(OBJS)
	$(CC) $(COMPILER_FLAGS) $^ $(LINKER_FLAGS) -o $(EXEC_NAME)

$(OBJ)/%.o : $(SRC)/%.c
	$(CC) $(COMPILER_FLAGS) -c $(SRC)/$*.c -o $@

clean ::
	rm -f $(OBJ)/*.o $(EXEC_NAME)

depend ::
	gcc -MM -std=gnu99 $(SRCS) >| $(DPD)
-include $(DPD)

Je sais ça fait beaucoup de ligne pour un petit problème mais j'ai du mal à le borner dans le code :/

Merci de votre temps

D'ailleurs si vous des remarques ou optimisations externes au problème je suis preneur

-
Edité par Golgoo 17 mai 2018 à 19:48:35

Dans ta fonction rediredction_sortie, sort la ligne 53 de la boucle.

Ici tu met un \0 a la fin seulement si tu lis, donc quand ta cmd n'écris rien la chaine sortie n'est pas modifiée.

Merci de ta réponse Thetui, mais en mettant :

            while (read(tube[0], &buf, 1) > 0){

           sortie[i]=buf; // rempli la chaine sortie caractère par caractère
           i++;

           }
           sortie[i]='\0';

J'ai exactement le même souci ,

et en mettant :

           while (read(tube[0], &buf, 1) > 0){

           sortie[i]=buf; // rempli la chaine sortie caractère par caractère
           i++;

           }
           //sortie[i]='\0';

Idem :/

Cependant en faisant un affichage au début de la fonction redirection_sortie :

printf("%s\n",commande[0]);

Je me rend compte que lorsque le bug survient par exemple pour ls, il affiche "ls%%" ' les deux %% sont des caractères étranges ( losange blanc avec un point d'interrogation à l'intérieur.

Je ne vois pas d'où ça peut venir, surtout que le problème survient qu'une seule fois si la commande précédente à sa sortie redirigés, et la suivante à sa sortie sur stdout, c'est trop bizare :/

Il y a quand même un truc qui cloche, mais je ne sais pas trop ou :/

donc :

if(c=='\n') {input[i+1]='\0'; printf("commande lu :%s\n",input); return input ;}

Me donne comme résultat dans le bug : ls% comme commande lu ( % <=> losange blanc avec point d'interrogation à l'intérieur ) => erreur lors de l'exec

D'ailleurs j'ai modifié le recouvrement et l'appel d'execvp dans la fonction que j'ai récup, c'était incohérent mais ne règle pas pour autant mon problème :/

Si je met input[i]='\0' à la place il me donne :

commande lu :ls

ls: impossible d'accéder à ''$'\373': Aucun fichier ou dossier de ce type ( erreur lors de l'exec quoi );

Je me demande si le problème ne vient pas au fait qu'en permutant les sortie les unes après les autres il faut réinitialiser un truc mais je ne suis même pas sur que le problème vient de la :/

donc scan_cmd donnerait maintenant :

char * scan_cmd()
{
  char *input = (char*)malloc(sizeof(char)*MAX_INPUT);
  char c;
  int i = 0 ;

  while((c = getchar()) != EOF ){
    if(c=='\n') {input[i+1]='\0'; printf("commande lu :%s\n",input); return input ;} // ou bien input[i]='\0'
    input[i]=c;
    i++;
  }
  return "exit";
}

et la fin de redirection_sortie :

while (read(tube[0], &buf, 1) > 0){

             sortie[i]=buf; // rempli la chaine sortie caractère par caractère
             i++;

           }
           sortie[i]='\0'; // indique la fin de la chaine de caractère

           int status;
           wait(&status);
           status=WEXITSTATUS(status);
           if(status!=0)
            exit(EXIT_FAILURE);

           close(tube[0]); // fermeture du coté lecture du tube une fois la lecture une fois que la fonction read a renvoyé 0 : EOF, la lecture terminée
           return sortie; // la fonction retourne la chaine qui contient le contenu de la sortie standard

           } else {                             /* Le fils écrit dans le tube  */
               close(tube[0]);          /* Fermeture du coté lecture non utilisé par le fil */
               dup2(tube[1],1);     /* */
               execvp(commande[index],commande + index);
               close(tube[1]);          /* Le pere lecteur verra un "EOF" ce qui permet la synchronisation */            /* Attendre que le fils se termine */
               exit(EXIT_FAILURE);
           }

}

En tout cas merci de ton aide thetui, même si on a pas encore trouver d'où ça venait.

Par contre détail : lors qu'on fait ls > tmp, suivit de echo ok ; ca marche très bien

Le bug doit aussi se produire plus spécialement lorsque la commande suivante ( en plus d'être redirigé vers la sortie standard après une commande redirigée vers un fichier ) est plus courte en caractère que la précédente. Je suis pommé pour le coup je ne vois pas du tout comment régler ça.

-
Edité par Golgoo 18 mai 2018 à 15:47:39

Désolé du délai, je n'ai pas eu accès a mon ordi ce w-e.

Concernant le changement que je t'ai demandé de faire sur scan_cmd, je me suis apercu en relisant que tu avais un probleme d'indice. Si tu pouvais changer avec ça stp.

char * scan_cmd()
{
  char *input = (char*)malloc(sizeof(char)*MAX_INPUT);
  char c;
  int i = 0 ;
 
  while((c = getchar()) != EOF ){
    if(c=='\n'){
      input[i] = '\0';
    }
    input[i]=c;
    i++;
  }
  return "exit";
}

Peux-tu reposter l'intégralité de ton code actualisé et réexpliquer en détail ton souci et dans quelles conditions il survient.

Yo thetui, tout d'abord merci de ton aide et désolé de répondre aussi-tard, je faisais du css pour me changer les idées ^^.

Oui j'ai changé lors de ta première réponse ; mais en regardant l'exemple que tu viens de me donner, j'ai revu la fonction au lieu de :

char * scan_cmd()
{
  char *input = (char*)malloc(sizeof(char)*MAX_INPUT);
  char c;
  int i = 0 ;

  while((c = getchar()) != EOF ){
    if(c=='\n') {
      input[i]='\0';
      printf("commande lu :%s\n",input);
      return input ;
    }
    input[i]=c;
    i++;
  }
  return "exit";
}

Je l'ai adapter comme ça

char * scan_cmd()
{
  char *input = (char*)malloc(sizeof(char)*MAX_INPUT);
  char c;
  int i = 0 ;

  while((c = getchar()) != EOF ){
    if(c=='\n') {
      input[i]='\0';
      printf("commande lu :%s\n",input);
      break;
    }
    input[i]=c;
    i++;
  }
  return input;
}

Mais rien à faire :/

$ls > tmp.tmp

commande lu : ls > tmp.tmp

$echo ok

commande lu : echo ok

=> Fonctionne

$echo ok > tmp.tmp

commande lu : echo ok > tmp.tmp

$echo okok

commande lu : echo okok

=>Fonctionne

$echo ok > tmp.tmp

commande lu : echo ok > tmp.tmp

$ls

commande lu : ls

impossible d'accéder à ''$'\373': Aucun fichier ou dossier de ce type

=>Bug

si j'avais mis à la ligne 9 :

input[i+1]='\0';

 J'aurai eu :

$echo ok > tmp.tmp

commande lu : echo ok > tmp.tmp

$ls

commande lu : ls# ( # <=> symbole bizare )

=> Bug toujours :/

Voici le code actuel :

Peu être que le problème viens de la fonction que j'ai piquée à un malheureux poster je ne la comprend pas en détails.

Alors shell.c :

#include <stdlib.h>
#include <string.h>

#include "IO.h"
#include "cmd.h"

int main( int argc, char ** argv )
{
  (void)argc;
  (void)argv;

  char *input = NULL;
  display_path();
  while((input = scan_cmd())){
    if(strcmp(input,"exit")==0)
      break;
    traiter_commande(input);
    display_path();
  }

  return 0;
}

le cmd.c :

#include <stdio.h>
#include <stdlib.h>

#include <unistd.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <signal.h>

#include "cmd.h"

char buf, sortie[10000];

void traiter_commande(char *commande){

  char **cmd = decomp_execvp_format(commande);
  if(cmd[0]==NULL)
    return ;
  char *out_file = (char*)malloc(sizeof(char)*MAX_STRING);
  T_WRITE write_type = find_out_file(cmd,&out_file);

  char *result = redirection_sortie(cmd, 0);
  ecrire_sortie(result,out_file,write_type);


}

char *redirection_sortie(char *commande[], int index)
{
           int tube[2];
           pid_t cpid;
           sortie[0]='\0';

           int i=0;

           if (pipe(tube) == -1) {
               perror("Le pipe n'a pas fonctionné");
               exit(EXIT_FAILURE); // quitte le programme si le pipe n'est pas créé
           }

           cpid = fork();
           if (cpid == -1) {
               perror("Le fork n'a pas fonctionné");
               exit(EXIT_FAILURE); // quitte le programme si le fork n'as pas fonctionné
           }

           if (cpid != 0) {    /* Le pere est lecteur sur le tube */
             close(tube[1]);          /* Fermeture du coté écriture non utilisé par le pere */

          /* cette boucle while permet de lire les caractères présent sur le coté lecture du tube et les stocker dans la chaine sortie */
             while (read(tube[0], &buf, 1) > 0){

               sortie[i]=buf; // rempli la chaine sortie caractère par caractère
               i++;

             }
             sortie[i]='\0'; // indique la fin de la chaine de caractère

             int status;
             wait(&status);
             status=WEXITSTATUS(status);
             if(status!=0)
              exit(EXIT_FAILURE);

             close(tube[0]); // fermeture du coté lecture du tube une fois la lecture une fois que la fonction read a renvoyé 0 : EOF, la lecture terminée
             return sortie; // la fonction retourne la chaine qui contient le contenu de la sortie standard

           } else {                             /* Le fils écrit dans le tube  */
               close(tube[0]);          /* Fermeture du coté lecture non utilisé par le fil */
               dup2(tube[1],1);     /* */
               execvp(commande[index],commande + index);
               close(tube[1]);          /* Le pere lecteur verra un "EOF" ce qui permet la synchronisation */            /* Attendre que le fils se termine */
               exit(EXIT_FAILURE);
           }

}

le cmd.h :

#ifndef __CMD_H__
#define __CMD_H__

#include "traitement.h"
#include "IO.h"

void traiter_commande(char *chaine);
char *redirection_sortie(char *commande[], int index);


#endif

IO.c :

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "IO.h"

extern char **environ;


char * scan_cmd()
{
  char *input = (char*)malloc(sizeof(char)*MAX_INPUT);
  char c;
  int i = 0 ;

  while((c = getchar()) != EOF ){
    if(c=='\n') {
      input[i]='\0';
      printf("commande lu :%s\n",input);
      break;
    }
    input[i]=c;
    i++;
  }
  return input;
}

void display_path()
{
  printf("[%s:%s]$ ",getenv("USER"),getenv("PWD"));
}

void ecrire_sortie(char *result, char *out_path, T_WRITE write_type)
{
  FILE *out_file = NULL ;
  switch(write_type){
    case T_CONCAT:
      out_file = fopen(out_path,"a");
      break;
    case T_REPLACE :
      out_file = fopen(out_path,"w");
      break;
    case T_NONE:
      fprintf(stdout,"%s",result);
      return ;
  }

  assert(out_file!=NULL);
  fprintf(out_file,"%s",result);
  fclose(out_file);
}

IO.h :

#ifndef __IO_H__
#define __IO_H__

#define MAX_INPUT 124

#include "traitement.h"

char * scan_cmd();
void display_path();
void ecrire_sortie(char *result, char *out_path, T_WRITE write_type);


#endif

traitement.c :

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#include "traitement.h"

char ** decomp_execvp_format(char *chaine)
{
  char **formated =NULL;
  formated=(char**)malloc(sizeof(char*) * MAX_ARG);
  assert(formated!=NULL);
  for(int i = 0 ; i < MAX_ARG ; i ++){
      formated[i]=(char*)malloc(sizeof(char) * MAX_STRING);
      assert(formated[i]!=NULL);
  }

  int i = 0 ;

  while(sscanf(chaine,"%s",formated[i])!=EOF){
    chaine = chaine + strlen(formated[i]) + 1 ;
    i++;
  }

  formated[i]=NULL;

  return formated;
}

T_WRITE find_out_file(char **src,char **dest)
{
  assert(dest!=NULL);
  assert(src[0]!=NULL);

  T_WRITE w_type = T_NONE ;

  int i = 1 ;

  while(src[i]!=NULL){
    if(strcmp(src[i],">")==0){
      if(src[i+1]==NULL){
        *dest=NULL;

        break;
      }
      else{
        *dest=src[i+1];
        src[i]=NULL;
        w_type = T_REPLACE ;
        break;
      }
    }
    if(strcmp(src[i],">>")==0){
      if(src[i+1]==NULL){
        *dest=NULL;

        break;
      }
      else{
        *dest=src[i+1];
        src[i]=NULL;
        w_type = T_CONCAT ;
        break;
      }
    }
    i++;
  }
  return w_type;
}

traitement.h :

#ifndef __TRAITEMENT_H__
#define __TRAITEMENT_H__

#define MAX_ARG 30
#define MAX_STRING 127

typedef enum {T_NONE,T_REPLACE,T_CONCAT} T_WRITE ;

char ** decomp_execvp_format(char *commande);
T_WRITE find_out_file(char **src,char **dest);


#endif

THX

-
Edité par Golgoo 23 mai 2018 à 23:51:50

Dans redirection_sortie() tu ne déclare jamais la variable buf, mais je doute que ca ai un lien.

Sinon je suis vraiment paumé.

Et si tu essaie avec:

$ls .

ça donne quoi?

$ls . donne le même fonctionnement que $ls

Et non même sans utiliser la variable buf même souci, il faudra que je me penche sur les tubes pour comprendre ce qui se passe.

Mais je pense qu'à un moment du programme il y a quelque chose en entrée ou sortie qui foire, je ferais des tests, je te tiendrais au courant si jamais je met le doigt sur quelque chose d'intéressant, en tout cas merci quand même.