====== 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
===== Installer =====
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_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 <&-
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ètre%%modè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ètre//mod/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ètre//mod/}
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 [[ est égal à 0. Si sa valeur est Faux, le code de retour est égal à 1. Si expr_cond est mal formée ou si les caractères crochets ne sont pas collés, une valeur différente est retournée.
La commande interne [[ offre de nombreuses expressions conditionnelles ; c’est pourquoi, seules les principales formes de expr_cond seront présentées, regroupées par catégories.
Permissions :
-r entrée vraie si entrée existe et est accessible en lecture par le processus courant.
-w entrée vraie si entrée existe et est accessible en écriture par le processus courant.
-x entrée vraie si le fichier entrée existe et est exécutable par le processus courant ou si le répertoire entrée existe et le processus courant possède la permission de passage.
Types d'une entrée :
-f entrée vraie si entrée existe et est un fichier ordinaire.
-d entrée vraie si entrée existe et est un répertoire.
Comparaisons de chaînes de caractères :
ch1 < ch2 vraie si ch1 précède ch2.
ch1 > ch2 vraie si ch1 suit ch2.
L’ordre des chaînes ch1 et ch2 est commandé par la valeur des paramètres régionaux.
ch == mod vraie si la chaîne ch correspond au modèle mod.
ch != mod vraie si la chaîne ch ne correspond pas au modèle mod.
mod est un modèle de chaînes pouvant contenir caractères et expressions génériques.
$ set -o | 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)
$
$ (( b = $2 +1 )) => incrémentation du jour courant
$
$ echo $b
22
$
--------------------------------------------
#!/bin/bash
declare -i i=0
while (( i < 10 ))
do
echo $i
(( i = i + 1 )) # ou(( i++ ))
done
--------------------------------------------
La commande interne (( expr_arith )) 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 : $(( expr_arith ))
--------------------------------------------
$ 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 $((z)) => par le contexte, z est évaluée comme une variable de type entier
40
$ (( z = z+1))
$ echo $z
41
$
--------------------------------------------
echo $(( RANDOM%49 +1 )) => reste et addition
--------------------------------------------
declare -i x
for (( x=0 ; x<5 ; x++ ))
do
echo $(( x*2 ))
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
(( a++ ))
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 )) || [[ $1 != +([0-9]) ]]
then
echo "syntaxe : fctfactr n" >&2
exit 1
fi
function f
{
declare -i n
if (( $1 == 0 ))
then echo 1
else
(( n=$1-1 ))
n=$( f $n ) => appel récursif
echo $(( $1 * $n ))
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....)