Topic 105: Shells and Shell Scripting

• Topic 105: Shells and Shell Scripting
  • Contenu du Module
  • Affichage des variables du shell
    • Les variables principales
    • Les Variables de Régionalisation et d'Internationalisation
    • Les variables spéciales
  • La Commande env
  • Les Scripts Shell
    • Exécution
    • La commande read
      • Code de retour
      • La variable IFS
    • La commande test
      • Tests de Fichiers
      • Tests de chaînes de caractère
      • Tests sur des nombres
      • Les opérateurs
      • Tests d'environnement utilisateur
    • La commande [[ expression ]]
    • Opérateurs du shell
    • L'arithmétique
      • La commande expr
        • Opérateurs Arithmétiques
        • Opérateurs de Comparaison
        • Opérateurs Logiques
      • La commande let
        • Opérateurs Arithmétiques
        • Opérateurs de comparaison
        • Opérateurs Logiques
        • Opérateurs travaillant sur les bits
      • Structures de contrôle
        • If
        • case
          • Exemple
      • Boucles
        • for
        • while
        • Exemple
    • Scripts de Démarrage
      • LAB #1- Scripts de Démarrage
        • ~/.bash_profile
        • ~/.bashrc

Une variable du shell peut être affichée grâce à la commande :

$ echo $VARIABLE [Entrée]

L'Internationalisation, aussi appelé i18n car il y a 18 lettres entre la lettre I et la lettre n dans le mot Internationalization, consiste à adapter un logiciel aux paramètres variant d'une région à l'autre :

• longueur des mots,
• accents,
• écriture de gauche à droite ou de droite à gauche,
• unité monétaire,
• styles typographiques et modèles rédactionnels,
• unités de mesures,
• affichage des dates et des heures,
• formats d'impression,
• format du clavier,
• etc …

Le Régionalisation, aussi appelé l10n car il y a 10 lettres entre la lettre L et la lettre n du mot Localisation, consiste à modifier l'internalisation en fonction d'une région spécifique.

Le code pays complet prend la forme suivante : langue-PAYS.jeu_de_caractères. Par exemple, pour la langue anglaise les valeurs de langue-PAYS sont :

• en_GB = Great Britain,
• en_US = USA,
• en_AU = Australia,
• en_NZ = New Zealand,
• en_ZA = South Africa,
• en_CA = Canada.

Les variables système les plus importants contenant les informations concernant le régionalisation sont :

Par exemple :

[trainee@centos7 ~]$ echo $LC_ALL
en_GB.UTF-8
[trainee@centos7 ~]$ echo $LC_CTYPE

[trainee@centos7 ~]$ echo $LANG
en_GB.UTF-8 

[trainee@centos7 ~]$ locale
LANG=en_GB.UTF-8
LC_CTYPE="en_GB.UTF-8"
LC_NUMERIC="en_GB.UTF-8"
LC_TIME="en_GB.UTF-8"
LC_COLLATE="en_GB.UTF-8"
LC_MONETARY="en_GB.UTF-8"
LC_MESSAGES="en_GB.UTF-8"
LC_PAPER="en_GB.UTF-8"
LC_NAME="en_GB.UTF-8"
LC_ADDRESS="en_GB.UTF-8"
LC_TELEPHONE="en_GB.UTF-8"
LC_MEASUREMENT="en_GB.UTF-8"
LC_IDENTIFICATION="en_GB.UTF-8"
LC_ALL=en_GB.UTF-8

La commande env envoie sur la sortie standard les valeurs des variables système de l'environnement de l'utilisateur qui l'invoque :

[trainee@centos7 ~]$ env
XDG_SESSION_ID=1
HOSTNAME=centos7.fenestros.loc
SELINUX_ROLE_REQUESTED=
TERM=xterm-256color
SHELL=/bin/bash
HISTSIZE=1000
SSH_CLIENT=10.0.2.2 33896 22
SELINUX_USE_CURRENT_RANGE=
SSH_TTY=/dev/pts/0
LC_ALL=en_GB.UTF-8
USER=trainee
LS_COLORS=rs=0:di=38;5;27:ln=38;5;51:mh=44;38;5;15:pi=40;38;5;11:so=38;5;13:do=38;5;5:bd=48;5;232;38;5;11:cd=48;5;232;38;5;3:or=48;5;232;38;5;9:mi=05;48;5;232;38;5;15:su=48;5;196;38;5;15:sg=48;5;11;38;5;16:ca=48;5;196;38;5;226:tw=48;5;10;38;5;16:ow=48;5;10;38;5;21:st=48;5;21;38;5;15:ex=38;5;34:*.tar=38;5;9:*.tgz=38;5;9:*.arc=38;5;9:*.arj=38;5;9:*.taz=38;5;9:*.lha=38;5;9:*.lz4=38;5;9:*.lzh=38;5;9:*.lzma=38;5;9:*.tlz=38;5;9:*.txz=38;5;9:*.tzo=38;5;9:*.t7z=38;5;9:*.zip=38;5;9:*.z=38;5;9:*.Z=38;5;9:*.dz=38;5;9:*.gz=38;5;9:*.lrz=38;5;9:*.lz=38;5;9:*.lzo=38;5;9:*.xz=38;5;9:*.bz2=38;5;9:*.bz=38;5;9:*.tbz=38;5;9:*.tbz2=38;5;9:*.tz=38;5;9:*.deb=38;5;9:*.rpm=38;5;9:*.jar=38;5;9:*.war=38;5;9:*.ear=38;5;9:*.sar=38;5;9:*.rar=38;5;9:*.alz=38;5;9:*.ace=38;5;9:*.zoo=38;5;9:*.cpio=38;5;9:*.7z=38;5;9:*.rz=38;5;9:*.cab=38;5;9:*.jpg=38;5;13:*.jpeg=38;5;13:*.gif=38;5;13:*.bmp=38;5;13:*.pbm=38;5;13:*.pgm=38;5;13:*.ppm=38;5;13:*.tga=38;5;13:*.xbm=38;5;13:*.xpm=38;5;13:*.tif=38;5;13:*.tiff=38;5;13:*.png=38;5;13:*.svg=38;5;13:*.svgz=38;5;13:*.mng=38;5;13:*.pcx=38;5;13:*.mov=38;5;13:*.mpg=38;5;13:*.mpeg=38;5;13:*.m2v=38;5;13:*.mkv=38;5;13:*.webm=38;5;13:*.ogm=38;5;13:*.mp4=38;5;13:*.m4v=38;5;13:*.mp4v=38;5;13:*.vob=38;5;13:*.qt=38;5;13:*.nuv=38;5;13:*.wmv=38;5;13:*.asf=38;5;13:*.rm=38;5;13:*.rmvb=38;5;13:*.flc=38;5;13:*.avi=38;5;13:*.fli=38;5;13:*.flv=38;5;13:*.gl=38;5;13:*.dl=38;5;13:*.xcf=38;5;13:*.xwd=38;5;13:*.yuv=38;5;13:*.cgm=38;5;13:*.emf=38;5;13:*.axv=38;5;13:*.anx=38;5;13:*.ogv=38;5;13:*.ogx=38;5;13:*.aac=38;5;45:*.au=38;5;45:*.flac=38;5;45:*.mid=38;5;45:*.midi=38;5;45:*.mka=38;5;45:*.mp3=38;5;45:*.mpc=38;5;45:*.ogg=38;5;45:*.ra=38;5;45:*.wav=38;5;45:*.axa=38;5;45:*.oga=38;5;45:*.spx=38;5;45:*.xspf=38;5;45:
MAIL=/var/spool/mail/trainee
PATH=/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/trainee/.local/bin:/home/trainee/bin
PWD=/home/trainee
LANG=fr_FR.UTF-8
SELINUX_LEVEL_REQUESTED=
HISTCONTROL=ignoredups
SHLVL=1
HOME=/home/trainee
LOGNAME=trainee
SSH_CONNECTION=10.0.2.2 33896 192.168.1.99 22
LESSOPEN=||/usr/bin/lesspipe.sh %s
XDG_RUNTIME_DIR=/run/user/1000
_=/usr/bin/env
OLDPWD=/home/trainee/training

La commande peut aussi être utilisée pour fixer une variable lors de l'exécution d'une commande. Par exemple, pour lancer xterm avec la variable EDITOR fixée à vi :

$ env EDITOR=vim xterm

Le but de la suite de cette unité est de vous amener au point où vous êtes capable de comprendre et de déchiffrer les scripts, notamment les scripts de démarrage ainsi que les scripts de contrôle des services.

Écrire des scripts compliqués est en dehors de la portée de cette unité car il nécessite une approche programmation qui ne peut être adressée que lors d'une formation dédiée à l'écriture des scripts.

Un script shell est un fichier dont le contenu est lu en entrée standard par le shell. Le contenu du fichier est lu et exécuté d'une manière séquentielle. Afin qu'un script soit exécuté, il suffit qu'il puisse être lu au quel cas le script est exécuté par un shell fils soit en l'appelant en argument à l'appel du shell :

/bin/bash myscript

soit en redirigeant son entrée standard :

/bin/bash < myscript

Dans le cas où le droit d'exécution est positionné sur le fichier script et à condition que celui-ci se trouve dans un répertoire spécifié dans le PATH de l'utilisateur qui le lance, le script peut être lancé en l'appelant simplement par son nom :

myscript

Pour lancer le script sans qu'il soit dans un répertoire du PATH, il convient de se placer dans le répertoire contenant le script et de le lancer ainsi :

./myscript

Dans le cas où le script doit être exécuté par le shell courant, dans les mêmes conditions que l'exemple précédent, et non par un shell fils, il convient de le lancer ainsi :

. myscript

Dans un script il est fortement conseillé d'inclure des commentaires. Les commentaires permettent à d'autres personnes de comprendre le script. Toute ligne de commentaire commence avec le caractère #.

Il existe aussi un pseudo commentaire qui est placé au début du script. Ce pseudo commentaire permet de stipuler quel shell doit être utilisé pour l'exécution du script. L'exécution du script est ainsi rendu indépendant du shell de l'utilisateur qui le lance. Le pseudo commentaire commence avec les caractères #!. Chaque script commence donc par une ligne similaire à celle-ci :

#!/bin/sh

Puisque un script contient des lignes de commandes qui peuvent être saisies en shell intéractif, il est souvent issu d'une procédure manuelle. Afin de faciliter la création d'un script il existe une commande, script, qui permet d'enregistrer les textes sortis sur la sortie standard, y compris le prompt dans un fichier dénommé typescript. Afin d'illustrer l'utilisation de cette commande, saisissez la suite de commandes suivante :

[trainee@centos7 ~]$ script
Script started, file is typescript
[trainee@centos7 ~]$ pwd
/home/trainee
[trainee@centos7 ~]$ ls
aac  bca    Desktop    Downloads  fichier1  file   Music     Public     training    Videos  xyz
abc  codes  Documents  errorlog   fichier2  file1  Pictures  Templates  typescript  vitext
[trainee@centos7 ~]$ exit
exit
Script done, file is typescript
[trainee@centos7 ~]$ cat typescript 
Script started on Tue 29 Nov 2016 03:58:33 CET
[trainee@centos7 ~]$ pwd
/home/trainee
[trainee@centos7 ~]$ ls
aac  bca    Desktop    Downloads  fichier1  file   Music     Public     training    Videos  xyz
abc  codes  Documents  errorlog   fichier2  file1  Pictures  Templates  typescript  vitext
[trainee@centos7 ~]$ exit
exit

Script done on Tue 29 Nov 2016 03:58:40 CET

Cette procédure peut être utilisée pour enregistrer une suite de commandes longues et compliquées afin d'écrire un script.

Pour illustrer l'écriture et l'exécution d'un script, éditez le fichier myscript avec vi :

$ vi myscript [Entrée]

Éditez votre fichier ainsi :

pwd
ls

Sauvegardez votre fichier. Lancez ensuite votre script en passant le nom du fichier en argument à /bin/bash :

[trainee@centos7 ~]$ vi myscript
[trainee@centos7 ~]$ /bin/bash myscript
/home/trainee
aac  codes	Downloads  fichier2  myscript	Public	   typescript  xyz
abc  Desktop	errorlog   file      Music	Templates  Videos
bca  Documents	fichier1   file1     Pictures	training   vitext

Lancez ensuite le script en redirigeant son entrée standard :

[trainee@centos7 ~]$ /bin/bash < myscript
/home/trainee
aac  codes	Downloads  fichier2  myscript	Public	   typescript  xyz
abc  Desktop	errorlog   file      Music	Templates  Videos
bca  Documents	fichier1   file1     Pictures	training   vitext

Pour lancer le script en l'appelant simplement par son nom, son chemin doit être inclus dans votre PATH:

[trainee@centos7 ~]$ echo $PATH
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/trainee/.local/bin:/home/trainee/bin

Dans le cas de RHEL/CentOS, même si PATH contient $HOME/bin, le répertoire n'existe pas :

[trainee@centos7 ~]$ ls
aac  codes      Downloads  fichier2  myscript  Public     typescript  xyz
abc  Desktop    errorlog   file      Music      Templates  Videos
bca  Documents  fichier1   file1     Pictures   training   vitext

Créez donc ce répertoire :

[trainee@centos7 ~]$ mkdir bin

Ensuite déplacez votre script dans ce répertoire et rendez-le exécutable pour votre utilisateur :

[trainee@centos7 ~]$ mv myscript ~/bin
[trainee@centos7 ~]$ chmod u+x ~/bin/myscript

Exécutez maintenant votre script en l'appelant par son nom à partir du répertoire /tmp :

[trainee@centos7 tmp]$ myscript
/tmp
hsperfdata_root  systemd-private-e526abcf335b40949dfc725f28456502-cups.service-u0xGiL

Placez-vous dans le répertoire contenant le script et saisissez les commandes suivantes :

• ./myscript
• . myscript

[trainee@centos7 tmp]$ cd ~/bin
[trainee@centos7 bin]$ ./myscript 
/home/trainee/bin
myscript
[trainee@centos7 bin]$ . myscript 
/home/trainee/bin
myscript

La commande read lit son entrée standard et affecte les mots saisis dans la ou les variable(s) passée(s) en argument. La séparation entre le contenu des variables est l'espace. Par conséquent il est intéressant de noter les exemples suivants :

[trainee@centos7 bin]$ read var1 var2 var3 var4
fenestros edu is great!
[trainee@centos7 bin]$ echo $var1
fenestros
[trainee@centos7 bin]$ echo $var2
edu
[trainee@centos7 bin]$ echo $var3
is
[trainee@centos7 bin]$ echo $var4
great!

[trainee@centos7 bin]$ read var1 var2
fenestros edu is great!
[trainee@centos7 bin]$ echo $var1
fenestros
[trainee@centos7 bin]$ echo $var2
edu is great!

La commande read renvoie un code de retour de 0 dans le cas où elle ne reçoit pas l'information fin de fichier matérialisée par les touches Ctrl+D. Le contenu de la variable var peut être vide et la valeur du code de retour 0 grâce à l'utilisation de la touche Entrée :

[trainee@centos7 bin]$ read var

↵ Entrée

[trainee@centos7 bin]$ echo $?
0
[trainee@centos7 bin]$ echo $var

[trainee@centos7 bin]$ 

Le contenu de la variable var peut être vide et la valeur du code de retour autre que 0 grâce à l'utilisation des touches Ctrl+D :

[trainee@centos7 bin]$ read var

Ctrl+D

[trainee@centos7 bin]$ echo $?
1
[trainee@centos7 bin]$ echo $var

[trainee@centos7 bin]$ 

La variable IFS contient par défaut les caractères Espace, Tab et Entrée :

[trainee@centos7 bin]$ echo "$IFS" | od -c
0000000      \t  \n  \n
0000004

La valeur de cette variable définit donc le séparateur de mots lors de la saisie des contenus des variables avec la commande read. La valeur de la variable IFS peut être modifiée :

[trainee@centos7 bin]$ OLDIFS="$IFS"
[trainee@centos7 bin]$ IFS=":"
[trainee@centos7 bin]$ echo "$IFS" | od -c
0000000   :  \n
0000002

De cette façon l'espace redevient un caractère normal :

[trainee@centos7 bin]$ read var1 var2 var3
fenestros:edu is:great!
[trainee@centos7 bin]$ echo $var1
fenestros
[trainee@centos7 bin]$ echo $var2
edu is
[trainee@centos7 bin]$ echo $var3
great!

Restaurez l'ancienne valeur de IFS avec la commande IFS=“$OLDIFS”

[trainee@centos7 bin]$ IFS="$OLDIFS"
[trainee@centos7 bin]$ echo "$IFS" | od -c
0000000      \t  \n  \n
0000004

La commande test peut être utilisée avec deux syntaxes :

test expression

ou

[EspaceexpressionEspace]

Testez si le fichier a100 est un fichier ordinaire :

[trainee@centos7 bin]$ cd ../training/
[trainee@centos7 training]$ test -f a100
[trainee@centos7 training]$ echo $? 
0
[trainee@centos7 training]$ [ -f a100 ]
[trainee@centos7 training]$ echo $? 
0

Testez si le fichier a101 existe :

[trainee@centos7 training]$ [ -f a101 ]
[trainee@centos7 training]$ echo $?
1

Testez si /home/trainee/training est un répertoire :

[trainee@centos7 training]$ [ -d /home/trainee/training ]
[trainee@centos7 training]$ echo $?
0

Testez si les deux chaînes sont égales :

[trainee@centos7 training]$ string1="root"
[trainee@centos7 training]$ string2="fenestros"
[trainee@centos7 training]$ [ $string1 = $string2 ]
[trainee@centos7 training]$ echo $?
1

Testez si la string1 n'a pas de longueur 0 :

[trainee@centos7 training]$ [ -n $string1 ]
[trainee@centos7 training]$ echo $?
0

Testez si la string1 a une longueur de 0 :

[trainee@centos7 training]$ [ -z $string1 ]
[trainee@centos7 training]$ echo $?
1

Comparez les deux nombres value1 et value2 :

[trainee@centos7 training]$ read value1
35
[trainee@centos7 training]$ read value2
23
[trainee@centos7 training]$ [ $value1 -lt $value2 ]
[trainee@centos7 training]$ echo $?
1
[trainee@centos7 training]$ [ $value2 -lt $value1 ]
[trainee@centos7 training]$ echo $?
0
[trainee@centos7 training]$ [ $value2 -eq $value1 ]
[trainee@centos7 training]$ echo $?
1

Testez si $file n'est pas un répertoire :

[trainee@centos7 training]$ file=a1OO
[trainee@centos7 training]$ [ ! -d $file ]
[trainee@centos7 training]$ echo $?
0

Testez si $directory est un répertoire et si l'utilisateur à le droit de le traverser :

[trainee@centos7 training]$ directory=/usr
[trainee@centos7 training]$ [ -d $directory -a -x $directory ]
[trainee@centos7 training]$ echo $?
0

Testez si l'utilisateur peut écrire dans le fichier a100 et /usr est un répertoire ou /tmp est un répertoire :

[trainee@centos7 training]$ [ -w a100 -a \( -d /usr -o -d /tmp \) ]
[trainee@centos7 training]$ echo $?
0

[trainee@centos7 training]$ [ -o allexport ]
[trainee@centos7 training]$ echo $?
1

La commande [[EspaceexpressionEspace]] est une amélioration de la commande test. Les opérateurs de la commande test sont compatibles avec la commande [[ expression ]] sauf -a et -o qui sont remplacés par && et || respectivement :

D'autres opérateurs ont été ajoutés :

Testez si l'utilisateur peut écrire dans le fichier a100 et /usr est un répertoire ou /tmp est un répertoire :

[trainee@centos7 training]$ [[ -w a100 && ( -d /usr || -d /tmp ) ]]
[trainee@centos7 training]$ echo $?
0

[trainee@centos7 training]$ [[ -d /root ]] && echo "The root directory exists"
The root directory exists
[trainee@centos7 training]$ [[ -d /root ]] || echo "The root directory exists"
[trainee@centos7 training]$  

La commande expr prend la forme :

expr Espace value1 Espace opérateur Espace value2 Entrée

ou

expr Tab value1 Tab opérateur Tab value2 Entrée

ou

expr Espace chaîne Espace : Espace expression_régulière Entrée

ou

expr Tab chaîne Tab : Tab expression_régulière Entrée

Ajoutez 2 à la valeur de $x :

[trainee@centos7 training]$ x=2
[trainee@centos7 training]$ expr $x + 2
4

Si les espaces sont retirés, le résultat est tout autre :

[trainee@centos7 training]$ expr $x+2
2+2

Les opérateurs doivent être protégés :

[trainee@centos7 training]$ expr $x * 2
expr: syntax error
[trainee@centos7 training]$ expr $x \* 2
4

Mettez le résultat d'un calcul dans une variable :

[trainee@centos7 training]$ resultat=`expr $x + 10`
[trainee@centos7 training]$ echo $resultat
12

La commande let est l'équivalent de la commande ((expression)). La commande ((expression)) est une amélioration de la commande expr :

• plus grand nombre d'opérateurs
• pas besoin d'espaces ou de tabulations entre les arguments
• pas besoin de préfixer les variables d'un $
• les caractères spéciaux du shell n'ont pas besoin d'être protégés
• les affectations se font dans la commande
• exécution plus rapide

[trainee@centos7 training]$ x=2
[trainee@centos7 training]$ ((x=$x+10))
[trainee@centos7 training]$ echo $x
12
[trainee@centos7 training]$ ((x=$x+20))
[trainee@centos7 training]$ echo $x
32

La syntaxe de la commande If est la suivante :

if condition
then
    commande(s)
else 
    commande(s)
fi

ou :

if condition
then
    commande(s)
    commande(s)
fi

ou encore :

if condition
then
     commande(s)
elif condition
then
     commande(s)
elif condition
then
     commande(s)
else 
    commande(s)

fi

Créez le script user_check suivant :

#!/bin/bash
if [ $# -ne 1 ] ; then
  echo "Mauvais nombre d'arguments"
  echo "Usage : $0 nom_utilisateur"
  exit 1
fi
if grep "^$1:" /etc/passwd > /dev/null
then
  echo "Utilisateur $1 est défini sur ce système"
else
  echo "Utilisateur $1 n'est pas défini sur ce système"
fi
exit 0

Testez-le :

[trainee@centos7 training]$ chmod 770 user_check
[trainee@centos7 training]$ ./user_check
Mauvais nombre d'arguments
Usage : ./user_check nom_utilisateur
[trainee@centos7 training]$ ./user_check root
Utilisateur root est défini sur ce système
[trainee@centos7 training]$ ./user_check mickey mouse
Mauvais nombre d'arguments
Usage : ./user_check nom_utilisateur
[trainee@centos7 training]$ ./user_check "mickey mouse"
Utilisateur mickey mouse n'est pas défini sur ce système

La syntaxe de la commande case est la suivante :

case $variable in
modele1) commande
   ...
   ;;
modele2) commande
   ...
   ;;
modele3 | modele4 | modele5 ) commande
   ...
   ;;
esac

  case "$1" in
      start)
          start
          ;;
      stop)
          stop
          ;;
      restart|reload)
          stop
          start
          ;;
      status)
          status
          ;;
      *)
          echo $"Usage: $0 {start|stop|restart|status}"
          exit 1
esac

La syntaxe de la commande for est la suivante :

for variable in liste_variables
do
    commande(s)
done

La syntaxe de la commande while est la suivante :

while condition
do
    commande(s)
done

U=1
while [ $U -lt $MAX_ACCOUNTS ]
do
useradd fenestros"$U" -c fenestros"$U" -d /home/fenestros"$U" -g staff -G audio,fuse -s /bin/bash 2>/dev/null
useradd fenestros"$U"$ -g machines -s /dev/false -d /dev/null 2>/dev/null
echo "Compte fenestros$U créé"
let U=U+1
done

Quand Bash est appelé en tant que shell de connexion, il exécute des scripts de démarrage dans l'ordre suivant :

• /etc/profile,
• ~/.bash_profile ou ~/.bash_login ou ~/.profile selon la distribution,

Dans le cas de RHEL/CentOS, le système exécute le fichier ~/.bash_profile.

Quand un shell de login se termine, Bash exécute le fichier ~/.bash_logout si celui-ci existe.

Quand bash est appelé en tant que shell interactif qui n'est pas un shell de connexion, il exécute le script ~/.bashrc.

[trainee@centos7 training]$ cat ~/.bash_profile
# .bash_profile

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
	. ~/.bashrc
fi

# User specific environment and startup programs

PATH=$PATH:$HOME/.local/bin:$HOME/bin

export PATH

[trainee@centos7 training]$ cat ~/.bashrc
# .bashrc

# Source global definitions
if [ -f /etc/bashrc ]; then
	. /etc/bashrc
fi

# Uncomment the following line if you don't like systemctl's auto-paging feature:
# export SYSTEMD_PAGER=

# User specific aliases and functions

Copyright © 2023 Hugh Norris.