Linux

Introduction

Fedora/Red Hat, CentOs, Suse, Mandrake/Mandriva, Slackware, Ubuntu, Debian

Distribution Linux = noyau Linux + Commandes et outils GNU+outil d'admin+doc+outils propres a la distribution

Role admin = Gerer, Surveiller, Déclarer/Installer/Administrer

. Executer les commandes d'admin
. Editer les fichiers d'admin
. Executer les scripts d'admin
. Utiliser les outils intégrés d'admin (webmin)

root = user dont uid = 0

su / id / pwd / $PATH

HowTo / FAQ / man -k

4 étapes: - chargement d'un mini système et lancement de l'outil d'admin - préparation des disques (partitionnement / formatage / création de FS/swap) - Installation des paquetages - Configuration du système

Installation minimaliste puis ajout des paquetages a la main

Minimum 2 partitions: système et swap

tailles recommandées:

. / 1 Go (si le reste est séparé)
. /usr 2 Go sur un serveur sinon 4 Go
. /var 1 Go
. /tmp 500 Mo
. /home 500Mo à X Go
. /boot 20Mo
. /var/log éviter la saturation des logs
. /var/spool éviter la saturation des mails, news, etc
. /opt (séparer de /usr)
. /usr/src (sources du noyau 200Mo)

kickstart -> automatisation

paquetages

fichier rpm = fichiers a installer + infos du paquets (dépendances, provenance, version) + scripts pré/post install ou désinstall

Red Hat

rpm -iv toto.arch.rpm (install)
rpm -qa (liste tous les rpms installés)
rpm -e toto.arch.rpm (erase)
rpm -q toto.arch.rpm (check installation)
rpm -qpi toto.arch.rpm (caractéristiques sur rpm)
rpm -qpl toto.arch.rpm (composants du rpm)
rpm -qi toto (caractéristiques sur rpm)
rpm -ql toto (composants du rpm)
rpm -qf fichier.dans.quel.rpm
rpm -U toto.arch.rpm (Update)

Debian

dbpkg -i toto.version.deb (install)
dbpkg -r toto (remove partiel)
dbpkg -P toto (Prune desinstallation totale)
dbpkg-reconfigure toto
dbpkg –get-selections \* (liste des paquetages installés)
apt-get

apt-get gestion des sources

cat /etc/apt/sources.list

apt-setup (init de sources.list)
apt-cdrom add (ajout cdrom)

apt-file update (mise a jour catalogue (base))
apt-get update (mise a jour des paquetages)
apt-get upgrade (-u) (Update des paquetages)
apt-get dist-upgrade (-u) (Update du système (tout))

apt-get install toto (install paquetage)
apt-get remove (–purge) toto

recherche de paqutages:
apt-cache search toto

apt-cache show toto (détail du paquetage)

auto-apt run commande
apt-file search fichier

synaptic = frontal de apt-get

up2date = outil mise a jour de red hat

yum

yum install toto
yum update
yum search toto
yum provides mkfs.xfs
yum list
/etc/yum.conf
/etc/yum.repos.d/*.repo

Users and groups

useradd, usermod, userdel, /etc/passwd, /etc/shadow, chsh, chfn, passwd, su
groupadd , groupmod, groupdel, /etc/group /etc/gshadow

/etc/skel = modéle pour le user
Voir /etc/default/useradd

vipw
login:pwd:uid:gid:finger:home:shell
vigr
grpname:pwd:gid:members

Pour bash au login:
Si existe /etc/profile
Si existe $HOME/.bash_profile sinon $HOME/.bash_login sinon $HOME/.profile

shell bash (pas login): $HOME/.bashrc

Déconnexion: $HOME/.bash_logout

export PS1="\[\033[35m\][\$(date +%H:%M)]\u@\h:\w\n:>"

mail, write, wall, talk

/etc/issue, /etc/motd

useradd -u 0 -o -g 0 admin
useradd -G admin,dev usera
useradd -g groupsan usera (default group)

NUMLOCK
setleds -D +num

Backups - Sauvegardes

What, When, where, what size, what frequency, what support, how to restore, Is it automatic

Simplicité de restauration, fiabilité, rapidité de sauvegarde

compress/uncompress
gzip/gunzip
bzip2/gunzip2

cd /home; tar cZvf usera.tgZ usera (compress)
cd /home; tar -T listOfContent -czvf usera.tgz usera (gzip)
cd /home; tar -cjvf usera.tbz -C destinationDirectory usera  (bzip2)
tar -cjf - . | ssh titi@hostlointain cd /home2 \; tar -xjvf -


find /home/user[a-z] | cpio -ova | bzip2 > backup.cpio.bz2
cat backup.cpio.bz2 |bunzip2 | cpio -i 

rsync -avu -e ssh root@hostlointan .
rsync -u (mise à jour)


dd if=fichierIn of=fichierOut bs=tailleDesBlocs count=NombreDeBlocsCopiés

dd if=/dev/hda of=backup.mbr bs=446 count=1
dd if=/dev/hda of=backup.bootsector bs=512 count=1

dump/restore = incrémentale

mt ; lecteur de bande /dev/?stXY

Disques IDE/PATA /dev/hda /dev/hdb, SerialATA /dev/sda, SCSI /dev/sda
Par disque:
Partitions primaires (max 4 dont une pour étendue)
Partitions étendues (15 SCSI , 63 IDE (32))

fdisk/cfdisk, parted, sfdisk

Ajout d'un disque: - connecter le disque - ajout eventuel d'un module (insmod, modprobe) (recompilation noyau) - partitionnement fdisk - creer un FS (mkfs.*) - Créer un point d'accueil (mkdir) - Monter le FS (mount) - automatiser le montage /etc/fstab

Raid: mdadm (avant raidtools)

mdadm –zero-superblock /dev/XXX

mdrun

/etc/mdadm/mdadm.conf
mdadm –assemble –scan -a

mdadm –create –help
mdadm –grow
mdadm –stop /dev/md0
mdadm –remove /dev/md0

LVM

vgscan

pvcreate /dev/hdb1
pvcreate /dev/hdc1
vgcreate myvg /dev/hdb1 /dev/hdc1

activate
vgchange -a y myvg 

desactivate
vgchange -a n myvg 

vgdisplay myvg

vgreduce myvg /dev/hdc1

vgremove myvg 

lvcreate -L 1500 -n lv1 myvg
mkfs.ext3 /dev/myvg/lv1
mount /dev/myvg/lv1 /toto

lvextend -L10G /dev/myvg/lv1
lvextend -L +4G /dev/myvg/lv1

umount /dev/myvg/lv1
lvremove /dev/myvg/lv1

SWAP:
Par FS ou par fichier

Par fichier:
dd if=/dev/zero of=/var/my.swap bs=1024 count=1000
chmod 600 /var/my.swap
mkswap /var/my.swap
sync
swapon /var/my.swap
cat /proc/swaps
/etc/swapd.conf
(non journalisé)
swapoff /var/my.swap

Arborescence de fichiers = file system

User voit 1 seule arborescence
FS stocké sur partition logique ou physique ou sur volume logique ou multiple (raid).
FS doit etre monté. FS de base sur /. Point de montage unique a un instant T.
ext3 = ext2 + journalisation
ext2 = bloc variable 1k, 2k, 4k. plusieurs copies du super bloc. Lien symbolique rapide (ne consomme pas de blocs de données). 2To max fichier.

df -k → kilos
df -t → Quel FS
df -i → inodes
df -h .
mount
cat /etc/mtab

du -ks (kilo la totale)

badblocks

mkfs
fsck
mke2fs = mkfs.ext2
mkf.ext2 -j = ext3

tune2fs change a posteriori le fs
resize2fs → redimensionnement
e2label → label de partition

/etc/fstab
/dev/hda3 /mnt/toto ext3 defaults 0 0 
/dev/hda4 /mnt/swap swap defaults 0 0 
/dev/hda5 /dev/shm tmpfs defaults 0 0

Par defaut 1k sous linux

quota:
usrquota, grpquota
racine du FS Monté: aquota.user et aquota.group
quotaon -a
quotaoff
edquota

Boot Loader

lilo/grub MBR 446 octets
64 octets table de partition
2 derniers = magic number
1er processus = /sbin/init

cat /etc/inittab
id:3:initdefault:
l0:0:wait:/etc/rc.d/rc 0
l1:1:wait:/etc/rc.d/rc 1
etc…

Scripts d'arrêt /etc/rc?.d/K*
Scripts de démarrages /etc/rc?.d/S*

Sur Red Hat

chkconfig –add service
chkconfig –level xyz service on
chkconfig –level xyz service off
chkconfig –list
chkconfig –del service

service httpd restart

dmesg

runlevel

. 0 arret
. 1 s et S single user
. 2 multi user de base
. 3 multi user + RPC
. 4 user define de 3
. 5 multi user +XDM (X11)
. 6 reboot

shutdown -h (halt)
shutdown -r (reboot)
arret propre sig term puis sig kill, sync, umount, wall

xmodmap keysym keyboard AltGr altgr alt gr
http://forums.nekochan.net/viewtopic.php?f=10&t=5117
http://wiki.archlinux.fr/Xmodmap

Soft pour linux

ClamAV : Anti Virus
FireStarter : Pare Feu Intuitif
SpamAssassin : AntiSpam
Nmap : analyseur de ports
Samba: Partage de dossier Windows et imprimantes

BASH = Bourne Again SHell

http://fr.wikipedia.org/wiki/Bourne-Again_shell
http://aral.iut-rodez.fr/fr/sanchis/enseignement/bash/index.html

Attention! Pas d'espace dans les affectations: export toto=pwd
Pas: export toto = pwd

——————————————–
READ
read a b
Bonjour Monsieur
echo $b
Monsieur

READ -p 
$ read -p "Entrez votre prenom : " prenom
Entrez votre prenom : Eric
$
$ echo $prenom
Eric
$

READ dernier bloc
$ read a b c
un bon jour coucou
$
$ echo $a
un
$ echo $c
jour coucou
$

——————————————–
CONST
constante mess:
$ declare -r mess=bonjour


SET
Ca commence a 1 pour les parametres
$ set ab be ga  ⇒ numérotation des mots ab, be et ga
$
$ echo $3 $2
ga be
$
$ echo $4

$
set – $a (Si a commence par -)


——————————————–
SHIFT
Une fois le décalage effectué, le paramètre spécial # est mis à jour.

$ set a b c d e
   ⇒ 1 2 3 4 5
$ echo $1 $2 $#
a b 5
$
$ shift 2
   ⇒ a b c d e  les mots a et b sont devenus inaccessibles
   ⇒     1 2 3
$ echo $1 $3
c e
$ echo $#
3
$
La commande interne shift sans argument est équivalente à shift 1.

Remarque : shift ne modifie pas la valeur du paramètre de position 0 qui possède une signification particulière.

2.2.4. Paramètres de position et fichiers shell


——————————————–$0 $#
#!/bin/bash
# @(#) copie

echo "Nom du programme : $0"
echo "Nb d'arguments : $#"
echo "Source : $1"
echo "Destination : $2"
cp $1 $2


——————————————– $* $@

$ set un deux trois quatre
$
$ echo $*
un deux trois quatre
$
$ echo $@
un deux trois quatre
$
"$*" est remplacée par "$1 $2 … "

"$@" est remplacée par "$1" "$2" …
——————————————–
SUPPRESSION DES AMBIGUITES ${ }
$ set un deux trois quatre cinq six sept huit neuf dix onze douze
$ echo $11
un1
$
$ echo ${11}   ⇒ pour obtenir la valeur du onzième paramètre de position
onze
$

——————————————–
VALEUR PAR DEFAUT
$ set -o nounset
$
$ ut1=root       ⇒ ut1 définie et non vide
$ ut2=           ⇒ ut2 définie et vide
$
$ echo $ut1
root
$
$ echo $ut2

$ echo $1
-bash: $1: unbound variable     ⇒ paramètre de position 1 non défini
$
Avec la syntaxe mentionnée ci-dessus, il est possible d’associer temporairement une valeur par défaut aux trois paramètres.

$ echo ${ut1:-sanchis}
root                     ⇒ ut1 étant définie non vide, elle conserve sa valeur
$
$ echo ${ut2:-sanchis}   ⇒ ut2 est définie et vide, la valeur de remplacement est
sanchis                  ⇒ utilisée
$
$ echo ${1:-sanchis}
sanchis                  ⇒ le premier paramètre de position est non défini
$
——————————————–
UNSET et SET -o nounset →erreur si pas défini / SET +o nounset→vide partout
$ unset a            ⇒ la variable a est supprimée
$
$ set -o nounset     ⇒ pour afficher le message d’erreur
$ echo $a
-bash: a: unbound variable

——————————————–
Syntaxe : $( cmd )
——————————————–
$ ls .gnome
application-info gnome-vfs mime-info
$
$ set $( ls $(pwd)/.gnome )
$
$ echo $#      ⇒ nombre d'entrées du répertoire .gnome
3
$

——————————————–
DATE NON REGIONALE
$ LC_ALL=C date
Fri Nov 3 18:47:41 CET 2006
set $(LC_ALL=C date) ; echo $4
18:47:41
——————————————–
set -o Pour voir les options de bash
* fonctionne si noglob=off

——————————————–
$ echo ?[ame]*
_a ami émirat zaza

——————————————–
$ echo ?[!n]*    ⇒ noms d'entrées ne comportant pas le caractère n en 2ème position
_a ami Arbre émirat état minuit zaza Zoulou
——————————————–
L’interprétation du modèle [a-z] est conditionnée par la valeur des paramètres régionaux : cette syntaxe est donc non portable et il est déconseillé de l’employer car elle peut avoir des effets néfastes lorsqu’elle est utilisée avec la commande unix rm.
——————————————–
[:upper:] (majuscules)

[:lower:] (minuscules)

[:digit:] (chiffres, 0 à 9)

[:alnum:] (caractères alphanumériques).

$ echo upper*
A Arbre En Zoulou

http://aral.iut-rodez.fr/fr/sanchis/enseignement/bash/ar01s04.html
——————————————–
shopt –s extglob

——————————————–
Un processus Unix possède par défaut trois voies d’interaction avec l’extérieur appelées entrées / sorties standard identifiées par un entier positif ou nul appelé descripteur de fichier.

Ces entrées / sorties standard sont :

une entrée standard, de descripteur (notée 0 sur la figure ci-dessous)

une sortie standard, de descripteur (notée 1 sur la figure ci-dessous)


——————————————–
RECREATION DE FICHIER
$ >f     ⇒ crée ou remet à zéro le fichier f
$
$ ls -l f
-rw-r–r– 1 sanchis users 0 oct 22 11:34 f
$
une sortie standard pour les messages d’erreurs, de descripteur (notée 2 sur la figure ci-dessous).

——————————————–
REDIRECTION de TOUT 2>&1
$ ls
Mail err public_html tmp
_.forward fic_noms t
$
$ ls vi err >trace 2>&1
$
$ cat trace
ls: vi: Aucun fichier ou répertoire de ce type
err
$
——————————————–
La syntaxe &> fichier est équivalente à la syntaxe > fichier 2>&1

——————————————–
$ wc -l <fic_noms >fic_nblignes 2>err

——————————————–
Une substitution de commande associée à une redirection de l’entrée standard permet d’affecter à une variable le contenu d’un fichier. En effet, la substitution de commande $(cat fichier) peut être avantageusement remplacée par la syntaxe $(< fichier). Cette deuxième forme est plus rapide.
——————————————–
La plupart des commandes affichent leurs résultats sous la même forme, suivant que l’on passe en argument le nom d’un fichier ou que l’on redirige son entrée standard avec ce fichier.
Il n’en est pas ainsi avec la commande wc : celle-ci n’écrit pas les résultats de la même manière.
$ wc -l fic_noms
3 fic_noms
$
$ wc -l < fic_noms
3
$
——————————————–
NOMBRE DE LIGNES <
$ nblignes=$( wc -l < fic_noms )


——————————————–
Syntaxe : cmd «mot
              texte
              mot
PAS d'espace entre « et mot
——————————————–
Fermeture de l’entrée standard : <&-

Fermeture de la sortie standard : >&-

Fermeture de la sortie standard pour les messages d’erreur : 2>&-
——————————————–
TEE et PIPE |
La commande unix tee écrit le contenu de son entrée standard sur sa sortie standard tout en gardant une copie dans le ou les fichiers dont on a passé le nom en argument.

——————————————–
{ suite_cmds ; }

Insérée entre une paire d’accolades, la suite de commandes est exécutée dans le shell courant. Cela a pour effet de préserver les modifications apportées par la suite de commandes sur l’environnement du processus.  Toutefois, lancée en arrière-plan, la suite de commandes n’est plus exécutée par le shell courant mais par un sous-shell.
$ pwd
/home/sanchis            ⇒ répertoire initial
$
$ { cd /bin ; pwd ; }    ⇒ changement du répertoire courant
/bin
$
$ pwd
/bin                     ⇒ répertoire final (le changement a été préservé !)
$


ATTENTION ERREUR:
 De plus, suite_cmds ne doit pas « coller » l’accolade ouvrante {
$ { cd /bin }      ⇒ l’accolade } n’est pas le premier mot d’une commande
>               ⇒ le shell ne détecte pas la fin du groupement
> ^C            ⇒ control-C
$
$ {cd /bin ;}      ⇒ il manque un espace ou une tabulation entre { et cd
-bash: syntax error near unexpected token `}'
$

——————————————–
$ cat fich
premiere ligne
deuxieme ligne
troisieme ligne
quatrieme ligne
$
$ { read ligne1 ; read ligne2
> } < fich     ⇒ le caractère > est affiché par le shell, indiquant que l’accolade } est manquante
$                    
$ echo $ligne1
premiere ligne
$ echo $ligne2
deuxieme ligne
$

L’entrée standard des deux commandes read ligne1 et read ligne2 est globalement redirigée : elles liront séquentiellement le contenu du fichier fich.

Si les commandes de lecture n’avaient pas été groupées, seule la première ligne de fich aurait été lue.

$ read ligne1 < fich ; read ligne2 < fich
$
$ echo $ligne1
premiere ligne
$
$ echo $ligne2
premiere ligne
$

——————————————–
( suite_cmds ; )

Insérée entre une paire de parenthèses, la suite de commandes est exécutée dans un sous-shell. L’environnement du processus n’est pas modifié après exécution de la suite de commandes.

——————————————–
$ pwd
/home/sanchis    ⇒ répertoire initial
$
$ (cd /bin ; pwd)
/bin
$
$ pwd
/home/sanchis    ⇒ le répertoire initial n’a pas été modifié
$
$ b=bonjour
$
$ ( b=coucou ; echo $b )
coucou
$
$ echo $b
bonjour          ⇒ la valeur de la variable b n’a pas été modifiée
$

——————————————–
Ce type de groupement de commandes peut être aussi utilisé pour effectuer une redirection globale.

$ ( pwd ; date ; echo FIN ) > fin
$
$ cat fin
/home/sanchis
lundi 20 novembre 2006, 15:47:45 (UTC+0100)
FIN
$

——————————————–
CODE DE RETOUR $?
Un code de retour[3] (exit status) est fourni par le shell après exécution d'une commande.

Le code de retour est un entier positif ou nul, compris entre 0 et 255, indiquant si l'exécution de la commande s'est bien déroulée ou s'il y a eu un problème quelconque.

Par convention, un code de retour égal à 0 signifie que la commande s'est exécutée correctement. Un code différent de 0 signifie une erreur syntaxique ou d'exécution.

Lorsque une commande est exécutée en arrière-plan (exécution asynchrone), son code de retour n'est pas mémorisé dans le paramètre spécial ?.

$ pwd
/home/sanchis
$ echo $?
0           ⇒ la commande pwd s'est exécutée correctement
$ ls -l vi
ls: vi: Aucun fichier ou répertoire de ce type
$ echo $?
2           ⇒ une erreur s’est produite !
$

——————————————–
Si l’on souhaite la chaîne cherchée en début de ligne, on utilisera la syntaxe ″^chaîne_cherchée″. Si on la veut en fin de ligne : ″chaîne_cherchée$″

$ grep ″^bert″ pass
bertrand:x:101:100::/home/bertrand:/bin/bash
$

——————————————–
La commande unix grep positionne un code de retour

égal à 0 pour indiquer qu'une ou plusieurs lignes ont été trouvées

égal à 1 pour indiquer qu'aucune ligne n'a été trouvée

égal à 2 pour indiquer la présence d'une erreur de syntaxe ou qu'un fichier mentionné en argument est inaccessible.
——————————————–
#!/bin/bash
# @(#) lvi2

ls vi
exit 23
——————————————–
Il est possible d'obtenir la négation d'un code de retour d'un pipeline en plaçant le mot-clé ! devant celui-ci. Cela signifie que si le code de retour de pipeline est égal à 0, alors le code de retour de ! pipeline est égal à 1.
$ ! grep sanchis turlututu
——————————————–
Les opérateurs && et || autorisent l’exécution conditionnelle d’une commande cmd suivant la valeur du code de retour de la dernière commande précédemment exécutée.

Opérateur : &&

Syntaxe : cmd1 && cmd2

Le fonctionnement est le suivant : cmd1 est exécutée et si son code de retour est égal à 0, alors cmd2 est également exécutée.
——————————————–
Opérateur : ||

Syntaxe : cmd1 || cmd2

cmd1 est exécutée et si son code de retour est différent de 0, alors cmd2 est également exécutée.
$ ls pass toto
ls: toto: Aucun fichier ou répertoire de ce type
pass
$
$ rm toto || echo toto non efface
rm: ne peut enlever `toto': Aucun fichier ou répertoire de ce type
toto non efface
$
——————————————–

Les deux règles mentionnées ci-dessus sont appliquées par le shell lorsqu'une suite de commandes contient plusieurs opérateurs && et ||. Ces deux opérateurs ont même priorité et leur évaluation s’effectue de gauche à droite.
——————————————–
#!/bin/bash

#@(#)oui

read –p ″Entrez votre réponse : ″  rep
case $rep in
o|O ) echo OUI ;;
*)    echo Indefini
esac

——————————————–

#!/bin/bash

#@(#)nombre

shopt -s extglob
case $1 in
+(digit) ) echo ″$1 est une suite de chiffres″ ;;
esac

——————————————–
La suite de commandes suite_cmd1 est exécutée; si son code de retour est égal à 0, alors la suite de commandes suite_cmd2 est exécutée, puis suite_cmd1 est re-exécutée. Si son code de retour est différent de 0, alors l’itération se termine.
        while suite_cmd1

             do

                suite_cmd2

             done
             
——————————————–
$ while :                           ⇒ boucle infinie
——————————————–
La commande interne while est parfois utilisée pour lire le contenu d’un fichier texte. La lecture s’effectue alors ligne par ligne. Il suffit pour cela :

de placer une commande interne read dans suite_cmd1

de placer les commandes de traitement de la ligne courante dans suite_cmd2

de rediriger l’entrée standard de la commande while avec le fichier à lire.
#!/bin/bash

#@(#)wh

who > tmp
while read nom reste
  do
    echo $nom
  done < tmp
rm tmp


——————————————–
Lorsque le fichier à lire est créé par une commande cmd, comme dans le programme wh, on peut utiliser la syntaxe :

          cmd | while read [ var1 … ]

             do

                commande(s) de traitement de la ligne courante

             done

Exemple : wh1

#!/bin/bash

#@(#)wh1
# Attention creation de pocessus!
who | while read nom reste
        do
          echo $nom
        done
        
——————————————–
RECUPERER LE PREMIER CHAMPS DE WHO AVEC CUT -d ' ' -f1
who | cut -d ' ' -f1
——————————————–
longueur de chaine ${#chaine}
Suppression de la plus courte sous-chaîne à gauche

Syntaxe : ${paramètre#modèle}

$ echo $PWD
/home/sanchis
$
$ echo ${PWD#*/}
home/sanchis      ⇒ le premier caractère / a été supprimé
$
$ set "12a34a"
$
$ echo ${1#*a}
34a               ⇒ suppression de la sous-chaîne 12a
$
Suppression de la plus longue sous-chaîne à gauche

Syntaxe : ${paramètre##modèle}

$ echo $PWD
/home/sanchis
$
$ echo ${PWD##*/}
sanchis   ⇒ suppression de la plus longue sous-chaîne à gauche se terminant par le caractère /
$    
$ set 12a34ab
$
$ echo ${1##*a}
b
$
Suppression de la plus courte sous-chaîne à droite

Syntaxe : ${paramètre%modèle}

$ echo $PWD
/home/sanchis
$ echo ${PWD%/*}
/home
$
Suppression de la plus longue sous-chaîne à droite

Syntaxe : ${paramètremodèle}

$ eleve="Pierre Dupont::12:10::15:9"
$
$ echo ${eleve:*}
Pierre Dupont
$

${paramètre:ind:nb} : extrait nb caractères à partir de l'indice ind.
${paramètre:ind} : extrait de la valeur de paramètre la sous-chaîne débutant à l'indice ind. La valeur de paramètre n’est pas modifiée.

Attention : l'indice du premier caractère d'une chaîne est 0
Remplacement de sous-chaînes
${paramètre/mod/ch} 
http://aral.iut-rodez.fr/fr/sanchis/enseignement/bash/ar01s09.html

${paramètremod/ch} 

Contrairement à la syntaxe précédente, toutes les occurrences (et non seulement la première) satisfaisant le modèle mod sont remplacées par la chaîne ch

${paramètremod/} 

Lorsque la chaîne ch est absente, la première ou toutes les occurrences (suivant la syntaxe utilisée) sont supprimées




——————————————–
FOR
          for var

          do

             suite_de_commandes

          done

Lorsque cette syntaxe est utilisée, la variable var prend successivement la valeur de chaque paramètre de position initialisé.

Exemple : programme for_arg

- - - - - - - - - - - - - - - - -
#!/bin/bash

for i
do
  echo $i
  echo "Passage a l'argument suivant …"
done
- - - - - - - - - - - - - - - - -
$ for_arg un deux ⇒ deux paramètres de position initialisés
un
Passage a l'argument suivant …
deux
Passage a l'argument suivant …
$

——————————————–
FOR i in liste
Deuxième forme :

          for var in liste_mots

          do

             suites_de_commandes

          done

La variable var prend successivement la valeur de chaque mot de liste_mots.

Exemple : programme for_liste

- - - - - - - - - - - - - - - - - - - - -
#!/bin/bash

for a in toto tata
do
  echo $a
done
- - - - - - - - - - - - - - - - - - - - -
$ for_liste
toto
tata
$

——————————————–
IF 

La commande interne if implante le choix alternatif.

Syntaxe :

          if suite_de_commandes1

             then

                suite_de_commandes2

          [ elif suite_de_commandes ; then suite_de_commandes ] …

          [ else suite_de_commandes ]

          fi

Le fonctionnement est le suivant : suite_de_commandes1 est exécutée ; si son code de retour est égal à 0, alors suite_de_commandes2 est exécutée sinon c'est la branche elif ou la branche else qui est exécutée, si elle existe.
#!/bin/bash

if rm $1 2>/dev/null
then echo $1 a ete supprime
else echo $1 n\'a pas ete supprime
fi

# Comme en C
if suite_de_commandes1 ; then

             suite_de_commandes2

          else

             suite_de_commandes]

          fi
          
La structure de contrôle doit comporter autant de mots-clés fi que de if (une branche elif ne doit pas se terminer par un fi).

——————————————–

Syntaxe : expr_cond

Les deux caractères crochets doivent être collés et un caractère séparateur doit être présent de part et d’autre de expr_cond. Les mots et sont des mots-clé.

Le fonctionnement de cette commande interne est le suivant : l’expression conditionnelle expr_cond est évaluée et si sa valeur est Vrai, alors le code de retour de la commande interne  grep noglob
noglob off
$
$ if [[ -o noglob ; then echo ON
> else echo OFF
> fi
OFF
$
Attention : on prendra soin de séparer les différents opérateurs et symboles par des espaces

——————————————–
VARIABLE ENTIERE
declare -i x=35   ⇒ définition et initialisation de la variable entière x
——————————————–
$ date
jeudi 21 décembre 2006, 19:41:42 (UTC+0100)
$
$ set $(date)
$
$ ¹⁾   ⇒ incrémentation du jour courant
$
$ echo $b
22
$
——————————————–
#!/bin/bash

declare -i i=0

while ²⁾
do
  echo $i
  ³⁾ # ou⁴⁾
done
——————————————–
La commande interne ⁵⁾ n'affiche pas sur la sortie standard la valeur de l'expression arithmétique expr_arith.

Pour obtenir la valeur de l'expression arithmétique, on utilise la syntaxe : $⁶⁾
——————————————–
$ declare -i x=35
$
$ z=x+5          ⇒ affectation de la chaîne x+5 à la variable z
$ echo $z
x+5              ⇒ non évaluée car z de type chaîne de caractères par défaut
$
$ echo $⁷⁾    ⇒ par le contexte, z est évaluée comme une variable de type entier
40
$ ⁸⁾
$ echo $z
41
$
——————————————–
 echo $⁹⁾   ⇒ reste et addition
——————————————–
declare -i x
for ¹⁰⁾
do
  echo $¹¹⁾
done
——————————————–
Pour désigner un élément d'un tableau, on utilise la syntaxe : nomtab[indice]

$ declare -a tab ⇒ définition du tableau tab
$
$ read tab[1] tab[3]
coucou bonjour
$
$ tab[0]=hello
$

Le nombre d'éléments d'un tableau est désigné par : ${#nomtab[*]}

Seuls les éléments initialisés sont comptés.

$ echo ${#arr[*]}
2
$
Tous les éléments d'un tableau sont accessibles à l’aide de la notation : ${nomtab[*]}

Seuls les éléments initialisés sont affichés.

$ echo ${arr[*]}
coucou hello
$
——————————————–
alias c='cat '
unalias c

Attention : on ne doit pas définir un alias et utiliser cet alias dans la même ligne mais sur deux lignes différentes.

Les noms de toutes les fonctions définies peuvent être listés à l'aide de la commande : declare -F

——————————————–
function 


$ c=Coucou
$
$ function f1
> {
> echo $c    ⇒ utilisation dans la fonction d’une variable externe c
> }
$
$ f1
Coucou
$

$ declare -F
declare -f f0
declare -f f1
$
Les noms et corps de toutes les fonctions définies sont affichés à l’aide de la commande : declare -f

$ declare -f
f0 ()
{
  echo Bonjour tout le monde !
}
f1 ()
{
  echo $c
}
$
——————————————–
	# !/bin/bash

	echo Appel Avant definition de fct
	fct        # fct non definie

	function fct
	{
	echo Execution de : fct
	sleep 2
	echo Fin Execution de : fct
	}
	echo Appel Apres definition de fct
	fct        # fct definie
——————————————–
unset -f f1
——————————————–
traceAppels
- - - - - - - - - – - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	function f2
	{
	echo " —— Dans f2 :"
	echo " —— FUNCNAME : $FUNCNAME"
	echo " —— tableau FUNCNAME[] : ${FUNCNAME[*]}"
	}

	function f1
	{
	echo " — Dans f1 :"
	echo " — FUNCNAME : $FUNCNAME"
	echo " — tableau FUNCNAME[] : ${FUNCNAME[*]}"
	echo " — - Appel a f2 "
	echo

	f2
	}

	echo "Debut :"
	echo "FUNCNAME : $FUNCNAME"
	echo "tableau FUNCNAME[] : ${FUNCNAME[*]}"
	echo

	f1

——————————————–
args
- - - - - - - - - – - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash
	
	function f
	{
	echo " — Dans f : \$0 : $0"
	echo " — Dans f : \$# : $#"
	echo " — Dans f : \$1 : $1"   ⇒ affichage du 1er argument de la fonction f
	}
	
	echo "Avant f : \$0 : $0"
	echo "Avant f : \$# : $#"
	echo "Avant f : \$1 : $1"    ⇒ affichage du 1er argument du programme args
	f pierre paul jacques
	echo "Apres f : \$1 : $1"    ⇒ affichage du 1er argument du programme args

——————————————–
Par défaut, une variable définie à l’intérieur d’une fonction est globale ; cela signifie qu’elle est directement modifiable par les autres fonctions du programme shell.
glob
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	function fUn
	{
	var=Un             # creation de la variable var
	}

	function fDeux
	{
	var=${var}Deux     # premiere modification de var
	}

	fUn
	fDeux
	var=${var}Princ    # deuxieme modification de var

	echo $var
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
$ glob
UnDeuxPrinc    ⇒ trace des modifications successives de la variable globale var

——————————————–
VARIABLE LOCAL
#!/bin/bash

	function f1
	{
	local -i a=12               ⇒ a est une variable locale à f1
	¹²⁾
	echo "– Dans f1 : a  ⇒ $a"
	}

	f1
	echo "Dans main : a  ⇒ $a" ⇒ tentative d’accès à la valeur de a
ATTENTION!
La portée d'une variable locale inclut la fonction qui l'a définie ainsi que les fonctions qu'elle appelle (directement ou indirectement).
——————————————–
	#!/bin/bash

	function bonj
	{
	echo bonj : Bonjour $1
	}

	export -f bonj ⇒ la fonction bonj est exportée

	bonj Madame

	autreProgShell
——————————————–
	#!/bin/bash

	function f
	{
	echo coucou
	return 1
	echo a demain # jamais execute
	}

	f
	echo code de retour de f : $?

 commande interne return ne peut retourner qu’un code de retour. Pour récupérer la valeur modifiée par une fonction, on peut :

enregistrer la nouvelle valeur dans une variable globale, ou
faire écrire la valeur modifiée sur la sortie standard, ce qui permet à la fonction ou programme appelant de capter cette valeur grâce à une substitution de fonction : $( fct [ arg … ] ).

recupres
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	function ajouteCoucou
	{
	echo $1 coucou
	}

	echo la chaine est : $( ajouteCoucou bonjour )
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
——————————————–
fctfactr
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#!/bin/bash

	shopt -s extglob

	if ¹³⁾ || $1 != +([0-9])
	  then
	    echo "syntaxe : fctfactr n" >&2
	    exit 1
	fi

	function f
	{
	declare -i n
	if ¹⁴⁾
	  then echo 1
	  else
	    ¹⁵⁾
	    n=$( f $n ) ⇒ appel récursif
	    echo $¹⁶⁾
	fi
	}

	f $1

date +"%d/%m/%Y %H:%M:%S" 13/01/2014 11:23:01

serveurs unix

1 Service de messagerie : Messagerie Interne, Carnet d'adresses commun, Annuaire d'entreprise. LDAP http://www.howtoforge.com/install-and-configure-openldap-on-centos-5

2. Service mail : Mise en place d'un serveur de mail. un serveur SMTP pour le transport des mails : Postfix un serveur POP3/IMAP pour la récupération et gestion des mails depuis un client : Dovecot un Webmail pour la gestion de ses mails en ligne : l'application RoundCube

3. Service Web : Mise en place d'un serveur Web. lamp apache/mysql/php

4. Service de connexion au réseau interne du site depuis l'extérieur pour les utilisateurs nomades. cisco anyconnect → OpenConnect

5. Service de gestion de données. Mise en place d'un serveur de données pour votre site (gestion du personnel, du parc de véhicules….)

¹⁾ b = $2 +1

²⁾ i < 10

³⁾ i = i + 1

⁴⁾ i++

⁵⁾ , ⁶⁾ expr_arith

⁷⁾ z

⁸⁾ z = z+1

⁹⁾ RANDOM%49 +1

¹⁰⁾ x=0 ; x<5 ; x++

¹¹⁾ x*2

¹²⁾ a++

¹³⁾ $# != 1

¹⁴⁾ $1 == 0

¹⁵⁾ n=$1-1

¹⁶⁾ $1 * $n