Bourne-Again shell — Wikipédia

Wiki Loves Monuments : photographiez un monument historique, aidez Wikipédia et gagnez !

# Bourne-Again shell

Un article de Wikipédia, l'encyclopédie libre.
Pour les articles homonymes, voir Born Again.
Ne doit pas être confondu avec batch ni bâche.

Bourne-Again shell
Logo

Session de travail avec Bash.

Dernière version | 4.3 (27 février 2014) [+/-]
Écrit en | C
Environnement | Multiplate-forme
Type | Shell Unix
Licence | GNU GPL
Site web | Page officielle

Bash (acronyme de Bourne-Again shell) est un interpréteur en ligne de commande de type script. C'est le shell Unix du projet GNU.

Fondé sur le Bourne shell, Bash lui apporte de nombreuses améliorations, provenant notamment du Korn shell et du C shell. Bash est un logiciel libre publié sous licence publique générale GNU. Il est l'interprète par défaut sur de nombreux Unix libres, notamment sur les systèmes GNU/Linux. C'est aussi le shell par défaut de Mac OS X et il a été porté sous Microsoft Windows par le projet Cygwin.

## Histoire[ modifier | modifier le code]

« Bourne again » est un jeu de mots sur le Bourne shell. Littéralement, Bourne again signifie « Bourne encore », mais se prononce également presque comme born again, signifiant « né de nouveau » ou encore « réincarné ». Également, to bash signifie « frapper violemment » en anglais.

Brian Fox, a publié en 1988 la première implémentation de Bash pour le compte de la Free Software Foundation. Il a été relayé plus tard par Chet Ramey. Le Bourne shell originel, dont s'inspire Bash, fut écrit par Stephen Bourne en 1977. La version 3.0 date de juillet 2004, et la version 4.0 de février 2009.

Le 24 septembre 2014, une faille de sécurité majeure est rendue publique, permettant le piratage du Bash via des scripts Common Gateway Interface. Ses utilisateurs sont alors invités à le patcher pour s'en prémunir[1].

## Usage[ modifier | modifier le code]

Comme tous les interpréteurs en ligne de commande de type script, Bash exécute quatre opérations fondamentales :

1. Il fournit une liste de commandes permettant d'opérer sur l'ordinateur (lancement de programmes, copie de fichiers, etc.) ;
2. Il permet de regrouper ces commandes dans un fichier unique appelé script ;
3. Il vérifie la ligne de commande lors de son exécution ou lors d'une éventuelle procédure de vérification et renvoie un message d'erreur en cas d'erreur de syntaxe ;
4. En cas de validation, chaque ligne de commande est interprétée, c'est-à-dire traduite dans un langage compréhensible par le système d'exploitation, qui l'exécute alors.

Les scripts sont de courts programmes généralement faciles à construire. Bash offre un service de gestion de flux, c'est-à-dire qu'il permet que le résultat d'un script (la sortie) soit transmis à un autre script (l'entrée). De cette façon, les scripts peuvent être « chaînés », chacun effectuant une seule tâche bien délimitée.

Les scripts peuvent être exécutés manuellement par l'utilisateur ou automatiquement par le système. Par exemple, dans la distribution GNU/Linux Ubuntu, le répertoire `resume.d` contient un certain nombre de scripts qui s'exécutent automatiquement lors du redémarrage du système, c'est-à-dire après la fin de la mise en veille de celui-ci. Ces scripts servent à relancer les différents programmes interrompus par la mise en veille.

## Fonctionnement[ modifier | modifier le code]

Bash est un shell qui peut-être utilisé soit en mode interactif, soit en mode batch :

- mode interactif : Bash attend les commandes saisies par un utilisateur puis renvoie le résultat de ces commandes et se place à nouveau en situation d'attente.
- mode batch : Bash interprète un fichier texte contenant les commandes à exécuter.

### Session en mode interactif[ modifier | modifier le code]

Une « session » est l'ensemble des actions effectuées par l'utilisateur d'un système informatique, entre le moment où il se connecte à celui-ci et le moment où il s'en déconnecte.

Bash est le plus souvent utilisé par défaut pour les ouvertures de sessions dans les distributions GNU/Linux. On le retrouve également comme shell par défaut sous Mac OS X.

### Fermeture en mode interactif[ modifier | modifier le code]

La fermeture de session se fera par la commande `exit` ou `Ctrl+D` (la marque de fin de fichier sous Unix : l'utilisateur ferme le flux de lecture de l'interpréteur).

### scripts exécutés lors du lancement de bash[ modifier | modifier le code]

- Scripts exécutés quand bash est utilisé pour une ouverture de session :
  - communs à tous les utilisateurs :
    - `/etc/profile`
  - spécifiques à chaque utilisateur
    - `.bash_profile`
    - `.bash_login`
    - `.profile`
    - `.bash_logout` : Script exécuté lors de la déconnexion

- Scripts exécutés quand bash n'est pas utilisé pour une ouverture de session :
  - spécifiques à chaque utilisateur :
    - `.bashrc`.

### `readline` et l'édition de la ligne de commande[ modifier | modifier le code]

Bash utilise la bibliothèque `readline` ce qui lui permet, comme le C shell, de compléter automatiquement (autocomplétion) les noms de commandes et de fichiers lors d'une frappe sur la touche Tabulation et d’accélérer considérablement le travail. Les touches Haut et Bas permettent de naviguer avec facilité dans l'historique des commandes.

#### Édition de la ligne de commande en mode vi ou Emacs[ modifier | modifier le code]

Il est également possible de choisir pour l'édition de la ligne de commande un comportement similaire à celui de l'éditeur de texte vi ou à celui de Emacs. Il faut alors utiliser les commandes `set -o` et `set +o` qui modifient les options du shell. Leur comportement est contre-intuitif car `set -o` active une option, tandis que `set +o` la désactive.

`set -o emacs` lance l'édition de ligne de commande en mode emacs et `set -o vi` en mode vi. Depuis la version 2.0, une nouvelle commande interne a été ajoutée pour la configuration du comportement du shell : `shopt`. Elle est destinée à remplacer la configuration des options par `set`. Le fonctionnement de `shopt -o` est semblable à `set -o` et celui de `shopt +o` à celui de `set +o` pour assurer la continuité avec `set`.

## Interprétation et exécution des commandes[ modifier | modifier le code]

Pour interpréter une ligne, Bash la segmente en mots. Le premier mot d'une ligne est considéré comme un nom de commande. On place ensuite les « arguments », qu'on nomme aussi les « paramètres » de la commande, c'est-à-dire les données qu'elle va traiter, un fichier par exemple. Enfin on peut ajouter des « options » qui vont modifier le comportement standard de la commande. Ces options sont introduites par « - », le tiret court, puis par le nom de l'option, ou une simple lettre en guise de raccourci. On ne place pas d'espace entre le tiret et le nom de l'option.

### Interprétation[ modifier | modifier le code]

Chaque interprétation d'une ligne respecte les contraintes suivantes :

- le premier mot de la ligne est interprété comme le nom de la commande, les autres mots en sont les paramètres ou options ;
- chaque mot est séparé par un ou plusieurs caractères de séparation. Par défaut, ces caractères sont l'espace et la tabulation (modifiable grâce à la variable Internal Field Separator (IFS) ;
- la fin de la commande est marquée, soit par un « ; » (si l'on veut placer plusieurs commandes sur la même ligne), soit par un saut de ligne.

Il existe plusieurs types de noms de commande associés à différents degrés de priorité. En suivant l'ordre décroissant des priorités, lors de l'interprétation de ce premier mot, on trouve :

- les alias : ce sont des mots définis comme synonymes d'un autre (groupe de) mot(s). Dans ce cas, l'interpréteur commence par remplacer le mot par son équivalent. Un exemple d'alias commun est `alias ll='ls -alh'` qui permet d'appeler `ls -alh` en n'entrant que `ll` ;
- les commandes internes : ce sont des commandes qui ont été définies dans l'interpréteur. Elles ne font pas l'objet d'un programme séparé. Par exemple, `cd` (change directory) ou `set` sont des commandes internes du shell. Ainsi `which set` ne retourne pas l'emplacement d'un fichier binaire correspondant à cette commande, car elle fait partie du programme de Bash ;
- les commandes externes, c'est-à-dire les programmes (ou un fichier de commande, en général appelé « script ») stockés sur le disque de la machine. Par exemple, `ls` est la commande qui permet de lister les fichiers contenus dans un répertoire donné ; `which ls` donne l'emplacement du binaire de `ls`.

Si Bash ne trouve aucune correspondance dans les alias, les commandes internes ou les commandes externes avec le premier mot de la ligne, il renvoie un message d'erreur en faisant précéder `command not found` du mot tapé en tête de ligne.

### Exécution[ modifier | modifier le code]

Dans le cas d'une commande externe, le shell doit retrouver le programme correspondant à cette commande avant de pouvoir l'exécuter. Une recherche exhaustive, pour chaque commande, dans tout le système de fichiers prendrait beaucoup trop de temps et rendrait le système inutilisable dans la pratique. Seul un petit ensemble de répertoires est en fait consulté lors de la recherche du programme permettant l'exécution de la commande. Ces répertoires sont définis dans une variable d'environnement appelée « $PATH ». Si la commande n'est pas trouvée dans l'un des répertoires listés dans cette variable, « le PATH », l'exécution se solde par un message d'erreur du type `command not found`.

Contrairement à ce qui se passe sous Windows, pour des raisons de sécurité, les shells Unix, dont Bash, n'incluent pas implicitement le répertoire courant dans le PATH, mais il peut y être placé explicitement. Cela permet d'éviter qu'un individu n'installe dans le répertoire courant un programme malveillant qui, portant le même nom qu'une commande externe, pourrait s'exécuter à sa place si un utilisateur tapait cette commande.

## Syntaxe[ modifier | modifier le code]

### Les métacaractères du shell[ modifier | modifier le code]

Un métacaractère est un caractère qui possède une signification autre que sa signification littérale. « * » ne représente pas pour Bash le caractère étoile, il le lit comme représentant n'importe quelle suite de caractère ou une absence de caractère. Les métacaractères se divisent en deux classes, ceux qui se substituent à d'autres caractères et ceux qui permettent de protéger des caractères. Ces derniers, employés seuls comme dans le cas de l'anti-slash, ou par paires, forcent Bash à lire des caractères de façon littérale, c'est-à-dire que s'il est protégé, le caractère « * » perd son statut de métacaractère pour redevenir une « étoile ».

Il y a deux métacaractères de substitution :

1. * : correspond à aucun caractère, n'importe quel caractère ou un ensemble de caractères ;
2. ? : est équivalent à un caractère quelconque.

Il y a trois moyens pour protéger un caractère ou une chaîne de caractères :

1. \ : empêche l'interprétation spéciale d'un métacaractère ;
2. ` : les guillemets inversés (backquotes, touches `AltGr+7` sur un clavier français) provoquent une interprétation de la chaîne de caractères incluse entre deux de ces caractères comme une commande. Exemple : `for file in `ls`` ;
3. ' : tous les caractères inclus entre deux de ces caractères sont interprétés comme du texte.

### Le caractère d'échappement : anti-slash « \ »[ modifier | modifier le code]

#### Anti-slash en fin de ligne[ modifier | modifier le code]

À la fin d'une ligne, un anti-slash indique que la commande continue à la ligne suivante. Cette fonction est particulièrement utile pour les grandes commandes afin de les rendre plus facilement lisibles.

#### Anti-slash pour former un des caractères spéciaux du C[ modifier | modifier le code]

Les chaînes ayant un format analogue à `$'\n'`, dans lesquelles on note la présence de l'anti-slash, sont interprétées d'une façon particulière par Bash. On remarque que l'anti-slash est suivi d'une lettre et que le groupe est encadré par des apostrophes. Dans ce cas, il ne s'agit pas d'échapper la signification d'un métacaractère. C'est une façon d'indiquer à Bash que la combinaison de l'anti-slash et de la lettre représente un caractère spécial du langage C à interpréter selon les règles édictées par l'ANSI. Ainsi `'echo $'\a'` provoquera un « bip ».

Le tableau qui suit donne la liste de ces caractères spéciaux :

Échappement par antislash | Transformation par Bash
--- | ---
`\a` | Bip
`\b` | Espacement arrière
`\e` | Échappement
`\f` | Saut de page (le nom anglais de ce caractère est form feed)[note 1]
`\n` | Saut de ligne
`\r` | Retour chariot
`\t` | Caractère de tabulation horizontale
`\v` | Caractère de tabulation verticale
`\\` | Anti-slash
`\'` | Une apostrophe (le nom anglais de ce caractère est quote)
`\nnn` | Le caractère 8 bits dont la valeur en octal est nnn
`\xHH` | Le caractère 8 bits dont la valeur en hexadécimal est HH
`\cx` | Le caractère contrôle-X

Voir ASCII

#### Anti-slash avant un des méta-caractères de Bash[ modifier | modifier le code]

Les méta-caractères, notamment « * » (étoile), ne sont pas interprétés par Bash en tant que littéraux, ce qui est gênant dans certains cas. Les commandes find[note 2], sed exemplifient ce point délicat. Si à l'aide de la commande `find` on souhaitait chercher dans le répertoire courant, représenté par « . », et ses sous-répertoires, tous les fichiers dont le nom commence par « my », on serait tenté d'écrire la ligne de commande suivante `find . -name my*` Mais la commande renverra `Find: Les chemins doivent précéder l'expression`.

En effet Bash va substituer à la chaîne « my* » la liste des fichiers contenus dans le répertoire courant, ce que `find` considère comme étant une liste de chemins, qui doivent être spécifiés en premier lieu, et non comme le nom des fichiers à rechercher.

Une des solutions consiste à utiliser un anti-slash avant le caractère « * » pour l'échapper et forcer Bash à l'interpréter comme un littéral. Ce qui donne `cd /etc;find . -name my\*`.

Une autre solution serait d'utiliser les guillemets. On pourrait par exemple écrire `cd /etc;find . -name "my*"`

### Gestion de processus[2][ modifier | modifier le code]

Commandes | Opérations | Explications
--- | --- | ---

    A &

Crée un nouveau processus en lançant
la commande A (indépendante de la console).

    A && B

ET logique (&&)

Exécute B, si A réussit.

    A || B

OR (||)

Exécute B uniquement si A échoue.

    A `B`

paramètres dynamiques

A utilise les résultats de l'exécution de B

    A $(B)

### Gestion de flux[ modifier | modifier le code]

Chaque commande est associée à trois flux :

1. l'entrée (ou « input » ou encore `stdin`) standard (entrée 0) ;
2. la sortie (ou « output » ou encore `stdout`) standard (entrée 1) ;
3. la sortie d'erreur standard (`stderr`) (entrée 2)

Éventuellement, des descripteurs de fichier supplémentaires peuvent être associés à une commande.

Méthode d'utilisation :

Commandes | Opérations | Explications
--- | --- | ---

    A > fichier

sortie (>)

Exécute la commande A et redirige sa sortie standard (`stdout`) dans fichier en écrasant son contenu ou en créant fichier si celui-ci n'existe pas

    A >> fichier

sortie (>>)

Exécute la commande A et redirige sa sortie standard à la fin de fichier

    A 2> fichier

sortie (2>)

Exécute la commande A et redirige sa sortie standard des erreurs (`stderr`) dans fichier en écrasant son contenu ou en créant fichier si celui-ci n'existe pas

    A 2>> fichier

sortie (2>>)

Exécute la commande A et redirige sa sortie standard des erreurs à la fin de fichier

    A 2>&1

sortie (2>&1)

Exécute la commande A et redirige sa sortie standard des erreurs dans sa sortie standard

    A < fichier

entrée (<)

Exécute la commande A en lui passant le contenu de fichier dans son entrée standard (`stdin`)

    A | B

sortie, entrée(|)

Exécute A et envoie le contenu de sa sortie standard dans l'entrée standard de B

### Redirection de l'entrée et des deux sorties[ modifier | modifier le code]

Utiliser

- > pour faire la redirection de la sortie standard (`stdout`) d'une commande ;
- 2> pour la redirection de la sortie des erreurs (`stderr`) ;
- n> permet la redirection du nième descripteur de fichier ;
- &> pour rediriger en même temps la sortie standard et la sortie erreur.

### Variables du shell[ modifier | modifier le code]

Les variables sont référencées en les faisant précéder par le signe `$` (exemple `echo $HOME`).

Quelques variables d'environnement : `USER`, `PID`, `HOME`, `PATH` et `SHELL`.

### Substitution de commandes[ modifier | modifier le code]

Dans une ligne de commande, on remplace comme argument une commande par son résultat (au `stdout`) en l'entourant d'apostrophes inversées ``nom commande`` ou encore en utilisant `$()` (`$(nom commande)`).

### Expression rationnelle[ modifier | modifier le code]

Les expressions rationnelles ou expressions régulières permettent de décrire des chaînes de caractères. On peut discerner deux catégories parmi ces derniers. Les littéraux, qui sont des caractères normaux traités comme tels, et les métacaractères qui sont des symboles ayant un sens pour une recherche. Il a déjà été question au-dessus des caractères `*` et `?`. Il est possible d'affiner la description du motif que l'on recherche et de préciser son emplacement.

Ainsi `^` représente le début d'une ligne et `$` la fin. Par exemple `^ter` représente toutes les lignes commençant par `ter` et `ter$` toutes celles se terminant par `ter`.

Des métacaractères représentent aussi des classes de caractères. Par exemple dans `sci[ea]nce` le contenu des crochets représente un OU logique. Sont représentées `science` et `sciance`. À l'aide des crochets, il est aussi possible de définir des intervalles, il faut ajouter un tiret. Il s'ensuit que `[0-9]` équivaut à tous les chiffres de 0 à 9, `[a-z]` à toutes les lettres minuscules et `[A-Z]` à toutes les lettres majuscules. À l'intérieur des crochets, plusieurs classes de caractères peuvent être combinées : par exemple, `epsilon[0-9A-Z]` spécifie que `epsilon` peut être suivi d'un chiffre entre 0 et 9 ou d'une lettre majuscule.

Le `^` à l'intérieur des crochets signifie la négation. De la sorte `[^eo]` (`^` est le deuxième caractère) définit ni « e » ni « o ».

Les expressions entre crochets ne permettent pas de décrire une chaîne de caractères, elles ne correspondent qu'à un seul caractère. Pour décrire une chaîne, il faut utiliser les parenthèses, lesquelles constituent une sous-expression régulière. Le tube `|` indique alors les alternatives. `lou(p|ch)er` décrit aussi bien `louper` que `loucher`.

### Raccourcis clavier en mode Emacs[ modifier | modifier le code]

- `TAB` : auto-complète un mot à partir de la position du curseur.
- `CTRL + a` : déplace le curseur en début de ligne (équivalent à la touche `début`).
- `CTRL + c` : envoie le signal `SIGINT` à la tâche au premier plan, ce qui a pour effet de l'interrompre.
- `CTRL + d` : en début de ligne ferme le shell courant (équivalent de la commande `exit`). Si un début de commande a été saisi, détruit (delete) le caractère suivant le curseur.
- `CTRL + e` : (end) déplace le curseur en fin de ligne (équivalent à la touche `fin`).
- `CTRL + p` : (previous) rappelle la commande précédente (équivalent à la touche flèche du haut).
- `CTRL + n` : (next) rappelle la commande suivante (équivalent à la touche flèche du bas).
- `CTRL + r` : (research) rappelle la dernière commande contenant les caractères spécifiés (équivalent à `vim ~/.bash_history`). Un 2e `CTRL + r` rappelle la prochaine commande antérieure correspondant à la recherche. `CTRL + s` : rappelle la commande suivante de la recherche (attention à ne pas l'exécuter depuis un terminal car cette commande déclencherait son XOFF). `CTRL + o` : exécute la commande trouvée dans la recherche.
- `CTRL + l` : efface le contenu de l'écran (équivalent à la commande `clear`).
- `CTRL + u` : efface le contenu de la ligne avant le curseur et le place dans le presse-papier.
- `CTRL + k` : efface le contenu de la ligne après le curseur et le place dans le presse-papier.
- `CTRL + w` : efface le contenu du curseur au début de mot le précédent et le place dans le presse papier.
- `CTRL + y` : (yank) ajoute le contenu du presse-papier à partir de la position du curseur.
- `CTRL + z` : envoie le signal `SIGTSTP` à la tâche au premier plan ce qui a pour effet de la suspendre. Pour la réafficher on peut entrer `fg 'nom du processus'`.
- `CTRL + x CTRL + x` : (car x est en forme de croisement) alterne le curseur avec son ancienne position.
- `CTRL + x CTRL + e` : (editor car reprend la variable $EDITOR du shell) édite la ligne courante dans votre éditeur de texte.
- `CTRL + _` : annule la dernière modification.
- `ALT + f` ou `ESC + f` : (forward) avance le curseur jusqu'à la fin du un mot le suivant.
- `ALT + b` ou `ESC + b` : (backward) recule le curseur jusqu'au début du mot le précédent.
- `ALT + BS` ou `ESC + BS` : coupe le texte jusqu'au début de mot précédent le curseur.
- `ALT + d` ou `ESC + d` : coupe le texte jusqu'à la fin de mot suivant le curseur.
- `ALT + u` ou `ESC + u` : transforme les lettres en majuscules jusqu'à la fin de mot suivant le curseur.
- `ALT + l` ou `ESC + l` : transforme les lettres en minuscules jusqu'à la fin de mot suivant le curseur.
- `ALT + c` ou `ESC + c` : en partant du curseur, met la première lettre rencontrée en majuscule et les suivantes en minuscule jusqu'à la fin de mot trouvée.
- `ALT + r` ou `ESC + r` : annule les changements et remet la ligne telle qu'elle était dans l'historique.

### Raccourcis clavier en mode vi[ modifier | modifier le code]

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue !

Le mode vi s'active par la commande `set -o vi` et se désactive par `set +o vi`. Au début d'une ligne on est en mode insertion, pour passer en mode commande il faut appuyer sur la touche échap.

Voici un résumé des commandes, pour un descriptif complet rendez-vous sur la page vi.

Déplacement :

- $ : pour aller en fin de ligne
- ^ : pour aller en début de ligne
- j et k : pour afficher la commande suivante et précédente
- h et l : pour déplacer le curseur vers la gauche et la droite
- w : place le curseur sur le premier caractère du mot suivant

Action :

- D : supprime la fin de la ligne à partir du curseur
- dd : supprime la ligne courante (et la copie dans le buffer)
- p : Coller
- :s : remplace une chaîne de caractère par une autre. Par exemple, :s/avant/après/ remplace le mot « avant » par le mot « après » sur la ligne courante
- / : recherche une chaîne de caractères après le curseur. Une pression sur la touche "n" permet d'aller directement à l'occurrence suivante.
- :33 : déplace le curseur à la ligne 33.
- :wq : quitte et sauvegarde.
- :q! : quitter sans sauvegarder

## Voir aussi[ modifier | modifier le code]

Sur les autres projets Wikimedia :

- Programmation Bash, sur Wikibooks

### Articles connexes[ modifier | modifier le code]

- Shell
- GNU Rush

### Liens externes[ modifier | modifier le code]

- (en) Page de l'auteur
- (en) Page sur le site du projet GNU
- (en) Tutoriel Bash
- (fr) Page du manuel
- (fr) Introduction à la programmation en Bash
- (fr) Utiliser Bash
- (fr) Guide avancé d'écriture de scripts en Bash

## Notes et références[ modifier | modifier le code]

Notes

1. ↑ Pour le saut de page, voir (en) Page break
2. ↑ (en) find

Références

1. ↑ Patch Bash NOW: 'Shell Shock' bug blasts Linux, OS X systems wide open [archive], The Register, 24 Sep 2014
2. ↑ Quick Reference Bash [archive]

[afficher] v · m Shell Unix
ash · bash · bsh · csh · dash · tcsh · ksh · zsh · fish

[afficher] v · m Commandes Unix

Aide

- arch
- apropos
- help
- file
- history
- info
- man
- type
- uname
- whatis

Environnement utilisateur

- env
- dmesg
- finger
- halt
- id
- init
- logname
- mesg
- passwd
- reboot
- shutdown
- su
- sudo
- talk
- uptime
- w
- wall
- who
- whoami
- write

Gestion de processus

- at
- bg
- chroot
- crontab
- exit
- fg
- kill
- nice
- nohup
- pkill
- ps
- pstree
- sleep
- time
- top

Manipulation de texte

- awk (gawk)
- banner
- bash
- cat
- clear
- cut
- ed
- head
- join
- nl
- read
- sed
- sort
- strings
- tail
- tee
- tr
- uniq
- vi
- vim
- wc

Programmation shell

- alias
- basename
- dirname
- echo
- expr
- false
- printf
- set
- test
- true
- unset
- wait

Recherche

- find
- grep
- locate
- whereis
- which

Réseau

- ethtool
- ftp
- host
- ifconfig
- mail
- mailx
- mii-tool
- nc
- netstat
- ping
- rlogin
- ssh
- sftp
- telnet
- traceroute

Système de fichiers

- cd
- chgrp
- chmod
- chown
- cp
- dd
- dir
- du
- df
- file
- less
- ln
- ls
- lsof
- mkdir
- more
- mount
- mv
- pwd
- rm
- rmdir
- split
- touch
- umask
- umount

Divers

- bc
- dc
- cal
- date
- lp
- lpr

[afficher] v · m Projet GNU
Histoire | Manifeste GNU · Free Software Foundation (FSF) · Histoire du logiciel libre |
Licences | GNU General Public License (GPL) · GNU Lesser General Public License (LGPL) · GNU Affero General Public License (AGPL) · GNU Free Documentation License (GFDL)
Logiciels | Système d'exploitation GNU · Bash · GCC · GDB · Emacs · Glibc · Guile · Guix · Coreutils · Autotools · Liste des paquets GNU
Personnalités | Ludovic Courtès (auteur de GNU Guix) · Werner Koch · Christian Grothoff (auteur de GNUnet) · Simon Josefsson · Matt Lee · Stefan Monnier · Alexandre Oliva · Rob Savoye · Thomas Schwinge · Richard Stallman · Brian Fox · Roland McGrath · John Gilmore · Mark H. Weaver · Andy Wingo

- Portail des logiciels libres

Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Bourne-Again_shell&oldid=118003896 ».
Catégories :

- Langage de script
- Logiciel libre sous licence GPL
- Shell Unix
- Logiciel du projet GNU

| [+]
Catégories cachées :

- Portail:Logiciels libres/Articles liés
- Portail:Logiciel/Articles liés
- Portail:Informatique/Articles liés