Table of Contents

Devoir 2 - Rustyshell

Le but de ce thème est de créer un shell simple, compatible avec sh ;

Informations générales

Date limite: Le 16 avril, 23h59
Note: 2 points de la note
Lien: Devoir 2
Télécharger en retard: 1 points / jour (maximum 4 jours)

Connaissances précieuses

Règles

  1. Le devoir doit contenir un fichier Readme expliquant comment vous avez créé le devoir (-0.1p)
  2. Vous pouvez utiliser seulement les fonctions de lea biblioteques std et nix.
  3. Un devoir qui passe tous les tests automatisés obtiendra 10 sur 10 si vouz ne trichez pas en utilisant un API interdit.

Copier

Le devoir doit etre résolu individuellement. Toute tentative de tricher entraînera 0p pour ce devoir. Nous utiliserons également des systèmes de détection de trichage automatique. Si nous avons des doutes, nous vous poserons des questions supplémentaires concernant le devoir.

Questions

Si vous avez des questions concernant le devoir, posez-les en publiant un issue sur le github https://github.com/UPB-FILS-SdE2/questions avec le format [busybox] <le titre de votre question> . Vous aurez besoin d'un compte github pour publier des questions.

NE PUBLIEZ PAS DE CODE SOURCE. Cela est considéré comme copiage et vous aller recevoir 0p pour le devoir.

Si vous voulez recevoir un e-mail lorsque des problèmes sont signalés ou lorsqu'il y a de nouveaux messages, accédez au site github repository et cliquez sur Watch.

Rusty Shell

Implémentez un shell simple qui prend en charge l'exécution de commandes externes avec plusieurs arguments, commandes internes, redirections, canaux. Le shell doit gérer l'exécution de commandes composées avec plusieurs opérateurs.

Commandes internes: commandes que le shell exécute: cd , pwd , exit

Commandes externes: Les commandes qui sont en fait des exécutables séparés: ls , vim , arbre , nano , …

La règle est la suivante: vérifiez si la commande interne est, sinon, on suppose qu'elle est une commande externe.

Le shell doit prendre en charge les opérateurs d'exécution suivants:

La priorité des opérateurs d'exécution est, de la priorité la plus grande à la plus petite:

  1. opérateur pipe
  2. opérateurs d'exécution conditionnelle
  3. opérateur de parallélisme (pas utilise)
  4. opérateur de séquençage

Le shell doit également prendre en charge les redirecteurs suivants:

Finalement, le shell doit accepter les commandes internes suivantes:

Le shell doit aussi supporter les sous-commandes:

Remarques générales

Suggestions

Le devoir est relativement complexe par rapport au précédent. Un modèle pour le commencement du devoir est disponible sur le repository dans le répertoire tema3 . Nous vous recommandons de résoudre et de tester toujours le devoir, étape par étape:

  1. Lancer des commandes simples ( ls , ls -l )
  2. Exécuter des commandes internes ( cd , exit , quit)
  3. mise en place de redirections (opérateurs < , > , 2> , &> , » , )
  4. séquencement des commandes (opérateurs &&, ||, ;)
  5. implémentation des opérateurs & (parallèle, pas utilise)
  6. |
 $ ls
 Makefile	  README.checker  mini-shell	mini-shell.o  parser
 Makefile.checker  inputs	  mini-shell.c	outputs       tags
 
 $ cat /etc/services | grep telnet
 telnet		23/tcp
 rtelnet	107/tcp				# Remote Telnet
 rtelnet	107/udp
 telnets	992/tcp				# Telnet over SSL
 telnets	992/udp
 tfido		60177/tcp			# fidonet EMSI over telnet
 
 $ uname -a ; ps 
 Linux bogdan-desktop 2.6.31-19-generic #56-Ubuntu SMP Thu Jan 28 02:39:34 UTC 2010 x86_64 GNU/Linux
   PID TTY          TIME CMD
  6078 pts/0    00:00:00 bash
  6190 pts/0    00:00:00 mini-shell
  6200 pts/0    00:00:00 ps
 
 $ date && sleep 1 ; echo date
 Mon Feb  8 13:40:25 EET 2010
 date
 
 $ date && sleep 1; date
 Mon Feb  8 13:40:49 EET 2010
 Mon Feb  8 13:40:50 EET 2010
 
 $ true && date
 Mon Feb  8 13:41:16 EET 2010
 
 $ false && cat mini-shell.c
 
 $ false || date
 Mon Feb  8 13:42:36 EET 2010
 
 $ cat /et/services
 cat: /et/services: No such file or directory
 
 $ gcc > tmp; echo sep; cat tmp
 gcc: no input files
 sep
 
 $ strace -e trace=read ls 2> strace.out   
 Makefile	  README.checker  mini-shell	mini-shell.o  parser	  tags
 Makefile.checker  inputs	  mini-shell.c	outputs       strace.out  tmp
 
 $ head -1 strace.out
 read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0@#\0\0\0\0\0\0@"..., 832) = 832
 
 $ pwd; cd Teme; pwd
 /home/bogdan/Documents/SO/Solutii
 /home/bogdan/Documents/SO/Solutii/Teme
 
 $ LETTER=alfa && echo $LETTER
 alfa
 
 > echo a > test ; echo b >> test && cat test
 a
 b
 
 > exit

Documents d'aide

Cours utiles:

Laboratoires utiles:

Traitement de la ligne de commande

Pour traiter la ligne de commande, nous avons déjà écrit un analyseur que vous pouvez utiliser.

Pour voir à quoi ressemble la structure de données à partir de l'analyseur, exécutez le modèle et apres introduisez une commande du clavier.

$ cargo run
 
$ ls
Command "ls"
SimpleCommand {
    assignments: [],
    parameters: [
        [
            Word(
                "ls",
            ),
        ],
    ],
    redirects: [],
}
 
$ ls && echo "folder exists"
Command "ls && echo \"folder exists\""
AndCommand(
    SimpleCommand {
        assignments: [],
        parameters: [
            [
                Word(
                    "ls",
                ),
            ],
        ],
        redirects: [],
    },
    SimpleCommand {
        assignments: [],
        parameters: [
            [
                Word(
                    "echo",
                ),
            ],
            [
                Quotes(
                    [
                        [
                            Word(
                                "folder",
                            ),
                        ],
                        [
                            Word(
                                " ",
                            ),
                        ],
                        [
                            Word(
                                "exists",
                            ),
                        ],
                    ],
                ),
            ],
        ],
        redirects: [],
    },
)

La structure afichee en rustyshell

Pour comprendre comment utiliser la structure renvoyée par l'analyseur, exécutez la commande cargo doc –open et examinez le module parser::ast.