pteuz Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Commandes Linux ======

Cet article présente des commandes système sous Linux. En général on obtient de l'aide sur une commande en tapant ''man <commande>'' dans un terminal, ou en consultant l'aide située dans le dossier **/usr/share/doc**.

Les commandes réseaux sont décrites ici : [[informatique:linux:reseau|Le réseau sous Linux]]


=====apropos=====

//(ressemble à ''man -k'')//
Permet d'afficher toutes les commandes en rapport avec la commande passée en paramètre.

  apropos who
   apropos who
   at.allow (5)         - determine who can submit jobs via at or batch
   at.deny (5)          - determine who can submit jobs via at or batch
   from (1)             - print names of those who have sent mail
   ftpusers (5)         - file which lists users who are not allowed to use ftp
   ftpwho (1)           - show current process information for each FTP session
   w (1)                - Show who is logged on and what they are doing.
   w.procps (1)         - Show who is logged on and what they are doing.
   who (1)              - show who is logged on
   who-uploads (1)      - identify the uploaders of Debian source packages
   whoami (1)           - print effective userid
   whodepends (1)       - check which maintainers' packages depend on a package
   whois (1)            - client for the whois directory service
   xfce4_setup (1)      - creates local .xsession file for the user who calls the script


=====apt=====

C'est le gestionnaire de paquet sous les distributions Debian & dérivées.

Le fichier de configuration des dépôts (main, contrib, universe, multiverse, etc) est ''/etc/apt/sources.list''. Les paquets téléchargés sont stocké dans un cache situé dans ''/var/cache/apt/''.

Les commandes utiles :
  * ''apt-get update'' pour màj la liste des paquets
  * ''apt-get upgrade'' pour installer les dernières màj ; les recommandations préconisent d'utiliser ''apt-get safe-upgrade'', ''apt-get dist-upgrade'' ou  ''apt-get full-upgrade'' (selon les distributions et l'action désirée).
  * ''apt-get install <paquet>'' pour installer le paquet
  * ''apt-get remove [--purge] <paquet>'' pour désinstaller le paquet [et aussi ses fichiers de config]
  * ''apt-get clean'' supprime des paquets téléchargés du cache
  * ''apt-get autoclean'' supprime les archive obsolètes

  * ''apt-cache show <paquet>'' pour afficher les informations relatives au paquet
  * ''apt-cache show <chaine>'' pour rechercher la chaine dans la liste des tous les paquets

''aptitude'' est un dérivé plus récent d' ''apt'', qui fonctionne de manière similaire avec la plupart du temps le même argument (e.g. ''aptitude install'' ; ''aptitude search'', etc).

Liens :
  * http://ubunteros.tuxfamily.org/spip.php?article177


=====arp=====

C'est une commande qui permet de voir la table de correspondance @IP/@MAC.

Pour avoir toutes les entrées ARP de la table
  arp -a

Pour supprimer une entrée de la table
  arp -d <nom_de_la_machine>

Pour ajouter une nouvelle entrée dans la table
  arp -s <nom_de_la_machine adresses_mac>


=====arping=====

Détecter une adresse IP usurpée / duplicate :
<code bash>
arping -D -q -I eth0 -c 2 192.168.0.5
</code>
=====aspell=====
Vérificateur d'orthographe interactif en ligne de commande.

<code>
aspell check toto.txt
</code>

Pour l'utiliser de façon non-interactive :
<code>
aspell list < toto.txt
</code>

Pour rechercher un mot rapidement dans le dictionnaire, on utilise la commande look.


=====at=====

Permet de programmer l'exécution d'une tâche à une heure donnée (une seule exécution, à la différence [[cron]]). La syntaxe est ''at heure jour'' ; puis on saisi une commande par ligne ; et enfin on quitte l'outil par un ''ctrl+d'' (''<EOT>''). Le jour n'est pas obligatoire ; par défaut on utilise la date du jour courant (''at 14:45 10/19/06'' équivaut à ''at 14:45'' si on est le 19 octobre 2006). Il est possible de compter par rapport à l'heure/la date courante : ''at 15:00 + 3 days'' programme une commande pour 15h00 dans 2 jours (marche aussi avec l'heure).

On peut spécifier l'heure d'exécution en chiffres au format : ''at -t "YYMMDDmmHH"''.

  * ''at'' : créer une tâche
  * ''atq'' : lister les tâches programmées et affiche leur ID
  * ''at -c <ID>'' : afficher le contenu de la tâche n°<ID>
  * ''atrm <ID>'' : supprimer la tâche <ID>

<code bash>
date
 jeudi 19 octobre 2006, 14:50:41 (UTC+0200)

# programmer une tâche à 14h52
at 14:52
# on aurait pu utiliser la syntaxe plus complète : at -t "200610191452"
 warning: commands will be executed using /bin/sh
at> echo 'toto'
at> echo 'tata'
at> <EOT>
 job 1 at Thu Oct 19 14:52:00 2006

# lister les tâches programmées
atq
 1       Thu Oct 19 14:52:00 2006 a dude

# supprimer l'entrée #1
atrm 1
</code>
Comme on peut le deviner, ''atq'' permet d'afficher la queue des commandes programmées. Chacune est déposée dans un fichier dans le répertoire ''/var/spool/at''.

On peut utiliser les fichier ''/etc/at.allow'' et ''/etc/at.deny'' pour gérer des permissions d'accès à la commande ''at''.

On peut consulter les journaux d'exécution du processus **atd** par défaut dans le fichier ''/var/log/messages'' :
<code bash>
Jul 19 02:30:00 bast2 atd[221981]: Starting job 17 (a0001101a5b44a) for user 'admin' (2006)
</code>

=====auditd=====

Permet d'auditer / debugguer des comportements bas niveau du système, comme par exemple déterminer quel processus réalise des requêtes :
<code bash>
apt install auditd

# mise en place de l'audit
auditctl -a exit,always -F arch=b64 -F a0=2 -F a1\&=2 -S socket -k SOCKET
# lister les logs de l'audit
ausearch -i -ts today -k SOCKET
# supprimer l'audit
auditctl -d exit,always -F arch=b64 -F a0=2 -F a1\&=2 -S socket -k SOCKET
</code>
src: [[https://serverfault.com/questions/192893/how-can-i-identify-which-processes-are-generating-udp-traffic-on-linux|how-can-i-identify-which-processes-are-generating-udp-traffic]]

=====awk=====

C'est une commande (un langage) de manipulation de chaînes de caractères d'un fichier ou d'un flux en entrée. Voir la page dédiée : [[informatique:linux:awk|awk]]


=====badblocks=====
badblocks permet de rechercher les blocks défectueux sur un périphérique.

  badblocks -s -v /dev/hda

Si badblocks trouve un bloc défectueux déjà utilisé, e2fsck essaie de déplacer celui-ci à un autre emplacement. Si le bloc est vraiment abîmé, le contenu du fichier peut être corrompu.

  e2fsck -c ?

Liens utiles :

  * http://smartmontools.sourceforge.net/badblockhowto.html

=====basename=====

**basename** retourne le nom du fichier fourni en paramètre, sans son chemin.

Un équivalent moins coûteux de la fonction ''basename $FIC'' est : ''${FIC##*/}''
=====batch=====

Permet de lancer une commande quand le système n'est pas trop chargé (charge CPU < 1.5).


=====bg=====

(**b**ack**g**round) Placer un job en arrière-plan
(voir ''jobs'')

=====blkid=====

Affiche les attributs des disques/partitions :
<code bash>
/dev/sda1: UUID="b0ab5b55-45e9-1cf9-3017-a5a8c86610be" TYPE="linux_raid_member" PARTUUID="5f04e8c2-ff94-4ab2-a129-3be865a326e1"
/dev/sda2: UUID="0a4130a8-429a-d46f-3017-a5a8c86610be" TYPE="linux_raid_member" PARTUUID="97ac67bb-ce66-475b-9e62-3e67fd0b1132"
/dev/sdb1: UUID="b0ab5b55-45e9-1cf9-3017-a5a8c86610be" TYPE="linux_raid_member" PARTUUID="bd37f026-6d63-4757-957d-d3eaef8666ea"
/dev/sdb2: UUID="0a4130a8-429a-d46f-3017-a5a8c86610be" TYPE="linux_raid_member" PARTUUID="8bc69d02-11a2-4616-9b2a-751f995076ea"
/dev/md0: LABEL="sys" UUID="381c49fe-1b04-47d4-8b0a-e55e1d68a4fb" TYPE="btrfs"
/dev/md1: UUID="58833cb6-9a9f-4991-a121-99e64bc8d3e5" TYPE="swap"
</code>
=====cal=====

Permet d'afficher le calendrier en console ; par défaut le mois courant
  * ''cal -y'' affiche l'année courante
  * ''cal 2000'' affiche l'année 2000
  * ''cal 01 2001'' affiche janvier 2001


=====cat=====

Permet d'afficher sur STDOUT un flux d'entrée ou un fichier spécifié en paramètre ( on peut en spécifier plusieurs) :
<code bash>
cat fichier.txt
</code>

On peut notamment afficher les numéros de lignes ''-n'', afficher l'entrée standard ''-'' (ou lancer ''cat'' sans paramètre), afficher les caractères invisibles ''-A'' (les tabulations et les fins de lignes)

====Tips====

  * Écrire des notes dans un fichier : pour simuler un notepad/bloc-note dans un shell (marche seulement pour créer un nouveau fichier) :
<code bash>
cat > list -
</code>
Utiliser ^C (''ctrl+c'') pour sortir.

  * Envoyer des paramètres à un programme sans que cela n'apparaisse dans le bash_history :
<code bash>
# équivalent d'un "echo blabla"
cat | xargs echo
 blabla
 ^D
blabla
</code>
... seule la commande ''cat | xargs echo'' apparaitra dans l'historique des commandes ; ''^D'' (ou ''Ctrl+D'') permet de quitter le cat et envoyer le texte à la commande suivante. C'est utile lorsqu'on doit saisir un mot de passe, par exemple.

=====cd=====
**c**hange **d**irectory ; commande utiliser pour changer de répertoire (équivalent de ''dir'' sous Windows).
A tout moment on peut savoir dans quel répertoire on est (chemin absolu) grâce à la commande **pwd**.

Utilisation :
  * ''cd /tmp'' : aller dans le répertoire "/tmp"
  * ''cd .'' : le "." désigne le répertoire courant. Donc cette commande va dans le répertoire courant (donc dans l'absolu, cette commande ne sert à rien !)
  * ''cd ..'' pour aller dans le répertoire racine du répertoire courant. On peut enchainer plusieurs fois cette séquence (cf exemples).
  * ''cd'' la commande seule permet de se rendre dans sa HOMEDIR c'est à dire son répertoire personnel (souvent dans /home/<nom d'utilisateur> ; pour le connaitre : ''echo $HOME''.)
  * ''cd -'' permet de retourner dans le précédent répertoire de travail

**chemin absolu** = chemin depuis la racine du sytème, par exemple "/home/toto". Il est donc invariable et commence toujours par "/".
**chemin relatif** = chemin par rapport au répertoire courant. Par exemple si on  veut définir le chemin relatif de "/home/toto" :
  * ça sera "./toto" (= à la notation raccourcie "toto/" ou même "toto") si on est dans /home
  * ça sera "../" si on est dans /home/toto/test
  * ça sera "./home/toto" si on est dans /

Exemple :
<code>
pwd
 /mnt/data

cd /tmp
pwd
 /tmp

cd
pwd
 /home/toto

cd -
pwd
 /tmp

cd -
pwd
 /home/toto

cd ..
pwd
 /home

cd
pwd
 /home/toto

cd ../..
pwd
 /

cd /home/toto
(dans ce contexte, équivaut à "cd home/toto" ou "cd ./home/toto")
pwd
 /home/toto
</code>

=====chage=====

Permet de lister et modifier la date d'expiration d'un compte utilisateur.

Pour afficher les information d'un compte :
<code bash>
chage -l <login_user>
Last password change                                    : Jan 15, 2013
Password expires                                        : Oct 11, 2016
Password inactive                                       : Oct 31, 2016
Account expires                                         : never
Minimum number of days between password change          : 15
Maximum number of days between password change          : 1365
Number of days of warning before password expires       : 7
</code>

Pour modifier la date d'expiration :
<code bash>
 chage -E YYYY-MM-DD <login_user>
</code>


=====chattr/lsattr=====

Permet de changer et lister les attributs de fichiers sur une partition ext2-3

  * protéger un fichier avec ''chattr +i /etc/services''
  * bit ajout-seul (pour les logs) : ''chattr +a /var/log/messages''
  * effacement total : ''chattr +s fichier''


=====chkconfig=====

Commande pour configurer les services activer au démarrage du système.
<code bash>
# lister les états de tous les services
chkconfig --list

# activer le service toto (resp. désactiver avec "off")
# optionnel : préciser les runlevels concernés, par défaut 2345)
chkconfig toto on [--level 35]

# lister l'état du service toto (pour chaque runlevel)
chkconfig --list toto
toto        	0:arrêt	1:arrêt	2:marche	3:marche	4:marche	5:marche	6:arrêt
</code>

=====chmod=====
Change les permissions sur un fichier. Syntaxe simplifiée : chmod [-R] DROITS FICHIERS

====Théorie des droits sous Linux====

Les droits d'un fichiers sont de la forme : [d]rwxrwxrwx qu'il faut lire en séparant les champs : [d] rwx rwx rwx. ("d" s'il s'agit d'un répertoire ; puis 3 séquences de 3 caractères qui représentent les droits (r (read), w (write), x (execute) ou - (pas le droit)) affectés respectivement au propriétaire du fichier, au groupe du fichier et aux autres (others).
On obtient les droits d'un fichier avec la commande ls -l :
<code>
ls -l /home/toto/secret.txt
 -rwxr-xr--  1 toto smbusers 1,2K sep 16 09:34 secret.sh
</code>

Dans cet exemple :
  * (-) => c'est un fichier et non un répertoire
  * (rwx) => le propriétaire de ce fichier est toto ; il a les droits de lecture, écriture et exécution sur ce fichier
  * (r-x) => le fichier appartient au groupe smbusers ; les utilisateurs appartenant à ce groupe auront les droits en lecture et exécution sur ce fichier, mais pas en écriture.
  * (r--) => les autres utilisateurs n'ont que le droit de lire le fichier, mais pas de l'exécuter ni de le modifier. 

====Méthode numérique====

Ces permissions peuvent se coder avec des valeurs binaires : on considère chaque champ "rwx" indépendamment. Pour faire simple : r vaut 4, w vaut 2 et x vaut 1.
L'explication technique est que chaque droit vaut la valeur de la puissance de 2 du bit qui lui correspond : Par exemple "r-x" => 101 en binaire, ce qui donne en décimal 2^2 (+ 0 * 2^1) + 2^0 = 4 (+ 0) + 1 = 5

Les permissions du fichier secret.sh ci-dessus se codent donc ainsi (on ne tient pas compte du premier tiret qui détermine s'il s'agit d'un dossier ou non) :
<code>
rwx r-x r--
 7   5   4

=> 754
</code>

Pour ajouter le droit d'écriture au membres du groupe smbusers, il faut transformer les droits en : rwxr**W**xr--, soit 774 :
<code>
chmod 774 secret.sh
ls -l secret.sh
 -rwxrwxr--  1 toto smbusers 1,2K sep 16 09:34 secret.sh
</code>

====Méthode symbolique====

On peut simplifier la méthode numérique en se disant : "je veux ajouter le droit en écriture au groupe" ce qui se traduit par cette notation alternative :
<code>
chmod g+w secret.sh
</code>
"g" pour "group", "+" pour "ajouter", "w" pour "write".

La syntaxe est la suivante :
  * ''+'', ''-'' ou ''='' pour ajouter, enlever ou appliquer la valeur exacte d'une permission.
  * ''u'', ''g'', ou ''o'' pour les champs user, group ou other.
  * ''r'', ''w'' ou ''x'' pour les droit read, write ou execute.

On peut "factoriser" les changements : par exemple pour ajouter le droit de lecture et écriture d'un fichier à tout le monde
<code>
chmod ugo+rw un_fichier.txt
</code>

On peut lister des modifications :
<code>
chmod u+rw,g+x un_fichier.txt
</code>

=====chsh=====

Cette commande permet de changer le shell par défaut de l'utilisateur courant.
  chsh
   Enter the new value, or press return for the default
   Login Shell [/bin/bash]:/bin/zsh

Pour changer le shell par default des utilisateurs :
  vim /etc/adduser.conf
   DSHELL=/bin/bash -> DSHELL=/bin/zsh


=====clear=====

**clear** permet d'effacer le contenu du terminal (raccourci clavier : ''ctrl+c''.

=====cmp=====

**cmp** permet de comparer deux fichiers octet par octet. A la différence (..) de ''diff'', il n'affiche pas les lignes différentes mais les "endroits" des fichiers qui diffèrent.

''-l'' permet d'afficher tous les octets qui diffèrent, ''-s'' (silence) ne renvoie rien d'autre que le code de retour de la commande.
=====comm=====

Permet de comparer les fichiers triés GAUCHE et DROITE ligne par ligne.
<code>
comm fichier1 fichier2
</code>

Sans option, la sortie se fait sur 3 colonnes.  La première colonne contient les lignes uniques au FICHIER1, la seconde contient les lignes uniques au FICHIER2, et la troisième contient les lignes communes aux deux fichiers.
Options :
  * ''-1'' : supprimer les lignes uniques du fichier de gauche
  * ''-2'' : supprimer les lignes uniques du fichier de droite
  * ''-3'' : supprimer les lignes uniques des 2 fichiers

=====command=====

Permet de lancer la commande fournie en paramètre en ne la recherchant que dans les commandes système ou dans le PATH. Invoquée avec ''-v'' ou ''-V'', affiche une description de la commande ; invoquée avec ''-p'' elle recherchera la commande spécifiée dans le PATH par défaut.

<code bash>
command -V cd
 cd est une primitive du shell
</code>
=====cp=====
**c**o**p**y ; copier de fichier.

Paramètres :
  * ''-i'' affiche une demande de confirmation avant chaque écrasement de fichier.
  * ''-r'' recursive = on copie aussi toute la sous-arborescence avec les répertoires.
  * ''-p'' **p**ermission = permet de conserver les permissions
  * ''-a'' **a**rchive = équivalent à -rp

=====cron=====

[[cron]] est un utilitaire qui permet de planifier des taches à un moment donné.


=====cut=====
Permet de sélectionner une ou des colonne(s) dans un flux ou un fichier.

Par exemple pour récupérer la liste des utilisateurs d'un système ainsi que le chemin de leur home, on sélectionne la 1ère et la 6ème colonne (**f**ield) du fichier ''/etc/passwd'' en délimitant avec '':'' (**d**elimiter) :

  cut -d":" -f1,6 /etc/passwd

cut n'accepte qu'un seul caractère comme délimiteur ; si on veut utiliser le caractère tabulation, ''\t'' ne fonctionne donc pas. Pour cela il faut utiliser la séquence ''ctrl+v <tab>''.

=====date=====

L'heure Unix, ou **timestamp**, est un compteur qui affiche le nombre de seconde depuis le 1er janvier 1970 à 00h00 UTC/GMT. Il est codé sur 32 bits donc il prendra fin à 2^32-1, soit le 19 janvier 2038 à 3 h 14 min 7 s, en provoquant le [[https://fr.wikipedia.org/wiki/Bug_de_l'an_2038|bug de l'an 2038]] :).

**date** est un outil pour manipuler ce compteur : renvoyer la date courante, convertir la date en différents formats, faire des calculs de date (les options et les formats sont très nombreux, il faut voir le man). Voici quelques exemples usuels quand même :

<code bash>
# Pour afficher la date au format YYYY/MM/JJ-HH:MM:SS :
date "+%Y/%m/%d %H:%M:%S"
2009/06/25 15:07:56

# afficher le compteur (timestamp) de l'heure actuelle :
date "+%s"
1441816670

# afficher la date correspondant à un timestamp donné :
date -d @1441816670
mer. sept.  9 18:37:50 CEST 2015
# ou la version plus verbeuse : date -d "1970-01-01 UTC + 1441816670 seconds"

# afficher la date d'il y a 2 jours :
date --date='2 days ago'
# afficher la date dans 5 mois et 4 jours (regarde, on peut même faire des fautes, c'est pris en compte !) :
date --date='5 month 4 day'
# afficher la date, 89 jours après le 26 mai 2022 :
date -d "26 may 2022 +89 days"
 Tue Aug 23 00:00:00 UTC 2022

# mettre à jour la date et l'heure du système :
date --set="2016-6-30 4:59 PM"
</code>

Pour comparer des dates, on les convertit au format ''%s'' (nombre de secondes depuis 1970) :
<code bash>
date=$(date -d 2020-12-15 +%s)
now=$(date +%s)

if [ $date -lt $now ]; then
    echo "date est dans le passé !"
fi
</code>
=====dd=====

Copy and convert a file.

Permet de copier une source vers une destination en binaire ; par ex générer un fichier d'une certaine taille de 50 Mo :
<code bash>
dd if=/dev/zero of=500meg bs=1k count=500000
</code>

Légende :
  * if : input file
  * of : output file
  * bs : block size (50 000 x 1024 = 50 mégas)

En envoyant un SIGUSR1 à dd, il renvoie des informations comme la quantité de données copiées, la vitesse, etc..
<code bash>
pkill -USR1 dd
</code>


=====declare=====

Permet de déclarer des variables en bash et leur affecter des attributs ; il équivaut à la commande ''typeset'' (les options sont les mêmes) à partir de bash v2+, alors que ''typeset'' est compatible ksh. Invoqué sans paramètre, ''declare'' affiche la liste des variables existantes dans l'environnement. Pour ne lister que les fonctions, utiliser le flag ''-f''.

Liste des attributs existants :
  * ''-a'' : tableau indexé (//array//)
  * ''-A'' : tableau associatif
  * ''-i'' : entier (//integer//)
  * ''-l'' : la variable ne peut contenir que des caractères en minuscules ; les majuscules sont converties (//lowercase//)
  * ''-u'' : la variable ne peut contenir que des caractères en majuscules ; les minuscules sont converties (//uppercase//)
  * ''-r'' : constante (//readonly//)
  * ''-x'' : exporter la variable (//export//)
  * ''-p'' : affiche le contenu de la variable qui suit
  * ''-f'' : lister le contenu de la fonction qui suit

Utiliser ''+'' à la place de ''-'' permet de désactiver l'attribut d'une variable (ne fonctionne pas pour l'attribut ''+a'' (tableaux indexés)).

<code bash>
# exemple d'utilisation d'un entier
declare -i int=2
echo "int vaut $int"      # "int vaut 2"
let "int += 1"
echo "int vaut $int"      # "int vaut 3"
unset int

# exemple d'utilisation d'une constante
declare -r const=pierre
echo "const vaut $const"  # "const vaut pierre"
const=sable               # "-bash: const : variable en lecture seule"
echo "const vaut $const"  # "const vaut pierre"
</code>

=====diff=====

diff permet d'afficher les différence entre 2 fichiers :
<code>
cd /tmp ; echo "toto" > toto ; echo "titi" > titi
diff toto titi
 1c1
 < toto
 ---
 > titi
</code>

Un patchfile c'est un fichier qui contient la sortie d'un diff :
<code>
diff -u toto titi > toto_titi.patch
</code>
Pour patcher toto avec les modifications de titi on utilise la commande **patch** avec le patchfile :
<code>
patch -b toto toto_titi.patch
 patching file toto
</code>

=====dig=====

A l'instar de ''nslookup'', **dig** est un outil d'interrogation de DNS (beaucoup plus fin cependant). Quelques //use case// :
<code bash>
dig +short www.free.fr        # résoudre le nom google.fr avec une sortie au format court (affichage uniquement des IPs)
212.27.48.10

dig +search toto              # va rechercher toto en recherchant aussi dans les domaines déclarés dans /etc/resolv.conf

dig +short -x 212.27.48.10    # résolution inverse avec un résultat au format court (affiche uniquement les noms)
www.free.fr

dig +trace google.fr          # mode debug pour analyser la résolution DNS

dig txt pteu.fr               # requêter les champs TXT du domaine
dig mx pteu.fr                # MX (serveur de mail) du domaine
dig pteu.fr @9.9.9.9	      # interroger le @serveurDNS spécifié
dig pteu.fr @127.0.0.1 -p5353      # interroger le @serveurDNS spécifié sur un port perso (non standard)
dig +noall +answer pteu.fr    # permet de n'afficher que la ligne le résultat (ANSWER) de la requête
</code>

Récupérer le numéro de série (serial number) d'une zone (enlever //+short// pour un résultat plus verbeux) :
<code bash>
dig +short SOA pteu.fr
dns105.ovh.net. tech.ovh.net. 2018110900 86400 3600 3600000 300
</code>

Interroger tous les serveurs faisant autorité d'une zone :
<code bash>
dig +nssearch pteu.fr
SOA dns105.ovh.net. tech.ovh.net. 2018110900 86400 3600 3600000 300 from server 213.251.188.149 in 0 ms.
SOA dns105.ovh.net. tech.ovh.net. 2018110900 86400 3600 3600000 300 from server 2001:41d0:1:4a95::1 in 0 ms.
SOA dns105.ovh.net. tech.ovh.net. 2018110900 86400 3600 3600000 300 from server 2001:41d0:1:1995::1 in 2 ms.
SOA dns105.ovh.net. tech.ovh.net. 2018110900 86400 3600 3600000 300 from server 213.251.128.149 in 2 ms.
</code>
=====dirname=====

**dirname** permet de renvoyer le path (chemin) du nom de fichier absolu passé en paramètre.

<code bash>
FIC=/home/dude/.bashrc
dirname $FIC
 /home/dude

# équivalent moins coûteux :
echo ${FIC%/*}
 /home/dude
</code>

Pour obtenir le chemin absolu du fichier, utiliser [[informatique:linux:commandes_linux#readlink|readlink]].
=====disown=====

Permet de désolidariser un processus du shell qui l'a lancé. Si aucun processus n'est spécifié, il prend le dernier lancé.


=====dmesg=====

Affiche les messages émis par le noyau depuis le dernier démarrage.

<code bash>
dmesg | head -1
[    0.000000] Linux version 4.9.0-8-amd64 (debian-kernel@lists.debian.org) (gcc version 6.3.0 20170516 
(Debian 6.3.0-18+deb9u1) ) #1 SMP Debian 4.9.130-2 (2018-10-27)
[..]

# pour convertir les temps en date
dmesg -T
[mer. janv.  2 18:18:44 2019] Linux version 4.9.0-8-amd64 (debian-kernel@lists.debian.org) (gcc version
6.3.0 20170516 (Debian 6.3.0-18+deb9u1) ) #1 SMP Debian 4.9.130-2 (2018-10-27)
[..]
</code>
=====df=====

Permet d'afficher l'espace disque restant sur tous les disques montés ;
  * ''-h'' permet d'utiliser un affichage compréhensible (il adapte l'unité en fonction de la taille (Ko, Mo, etc)).
  * ''-T'' affiche le type de sytème de fichier (ntfs, fat, ext3, ...)

  df -hT
   Sys. de fich. Type     Tail. Occ. Disp. %Occ. Monté sur
   /dev/sda1     ext3    3,9G  1,5G  2,2G  41% /
   tmpfs        tmpfs    474M     0  474M   0% /lib/init/rw
   udev         tmpfs     10M   32K   10M   1% /dev
   tmpfs        tmpfs    474M  4,0K  474M   1% /dev/shm
   /dev/sda3     ext3    913G  840G   26G  98% /mnt/data



=====dpkg=====

Permet de gérer les packages :
  * ''dpkg -L <paquet>'' liste les fichiers contenus dans le paquet
  * ''dpkg-reconfigure <paquet>'' reconfigurer le paquet
  * ''dpkg -i <paquet>'' installer un paquet
  * ''dpkg -S <fichier>'' donne le paquet auquel se rapporte le fichier
  * ''dpkg-query -W'' affiche la listed e tous les paquets installés sur la machine


=====du=====

Permet d'afficher la taille des fichiers d'un répertoire
  * ''-h'' permet d'utiliser l'unité appropriée en fonction de la taille du fichier (kilo, mégas, gigas, etc..)
  * ''-s'' (//summurize//) permet de n'afficher la taille que du dossier courant.
<code bash>
du -sh
 437M    .
</code>

Pour limiter l'affichage des répertoires du dossier courant :
<code bash>
du -h --max-depth=1
 4,0K    ./.aptitude
 239M    ./income
 4,0K    ./.w3m
 4,0K    ./Mail
 16K     ./test-gen-rsa
 16K     ./.ssh
 776K    ./save_tiga
 307M    .
</code>

[[https://dev.yorhel.nl/ncdu|ncdu]] est une alternative en ncurses (interface pseudo-graphique en CLI)
=====echo=====

''echo'' permet d'afficher une ligne
<code bash>
echo toto
toto
</code>

Options :
  * ''-n'' : ne va pas à la ligne après le texte
  * ''-e'' : interprète les caractères spéciaux du genre ''\n'' ou ''\t''
<code bash>
echo -e "to\tto\ntiti"
to      to
titi
</code>

=====env=====

**env** affiche les variables d'environnement et leur contenu.
<code bash>
HOST=hel
TERM=xterm
SHELL=/bin/bash
SSH_TTY=/dev/pts/2
USER=dude
MAIL=/var/mail/dude
PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/pkg/sbin:/usr/pkg/bin:/usr/X11R6/bin:/usr/local/sbin:/usr/local/bin
BLOCKSIZE=1k
PWD=/home/dude
EDITOR=vim
LANG=fr_FR.UTF-8
PS1=\[\e[0;30;47m\]$(date +"%H:%M")\[\e[0;32m\] \u\[\e[m\]@\[\e[0;31m\]\h\[\e[0m\]:\[\e[0;32m\]\W \[\e[0m\]
SHLVL=1
HOME=/home/dude
LOGNAME=dude
_=/usr/bin/env
OLDPWD=/home/dude/Mail
</code>
=====ethtool=====

Permet d'obtenir/modifier des informations sur la connectivité niveau 1 et 2 de la carte réseau.

Quelques exemples de commandes :

  ethtool -i eth0
   driver: r8169
   version: 2.2LK
   firmware-version:
   bus-info: 0000:00:09.0

  ethtool eth0
   Settings for eth0:
           Supported ports: [ MII ]
           Supported link modes:   10baseT/Half 10baseT/Full
                                   100baseT/Half 100baseT/Full
                                   1000baseT/Half 1000baseT/Full
           Supports auto-negotiation: Yes
           Advertised link modes:  10baseT/Half 10baseT/Full
                                   100baseT/Half 100baseT/Full
                                   1000baseT/Half 1000baseT/Full
           Advertised auto-negotiation: Yes
           Speed: 100Mb/s
           Duplex: Full
           Port: Twisted Pair
           PHYAD: 1
           Transceiver: internal
           Auto-negotiation: off
           Supports Wake-on: g
           Wake-on: d
           Current message level: 0x000000ff (255)
           Link detected: yes

Pour passer en 1 giga full dupleix et autonégatiation :
  ethtool -s eth0 speed 1000 duplex full autoneg on

Afficher les statistiques de la carte eth0: ''ethtool -S eth0''. Plus d'informations pour le diagnostique réseau ici : [[informatique:linux:reseau#diagnostique|Diagnostique réseau sous Linux]]

=====exit=====

ou ''ctrl+d'', permet de fermer un terminal graphique.


=====expr=====

Évaluer des expressions :

  * tronquer la taille de la chaine ''$MSG'' à 40 caractères

  expr "$MSG" : "\(.\{40\}\)"

  * expressions arithmétiques

  expr $z + 1

=====for=====

Permet de faire une boucle "pour" ; voir [[informatique:linux:programmation_shell]].


=====fg=====

(**f**or**g**round) Placer un job en avant-plan.
(voir ''jobs'')


=====file=====

Affiche le type d'un fichier (ne tient pas compte de son extension mais regarde les headers dudit fichier)
  file toto
   toto: ASCII text


=====find=====

Permet de rechercher un fichier dans une arborenscence
<code bash>
# recherche d'un fichier "toto.txt" dans le répertoire courant "."
find . -name toto.txt
</code>

Liste des options les plus utilisées (totalement subjectif) :
  * ''-type d'' pour spécifier le type du fichier recherché (notamment **d**irectory, regular **f**ile, symbolic **l**ink)
  * ''-name nom'' permet de spécifier un nom de fichier ou un motif. Si motif, il est recommandé de le saisir entre "" ou d'échapper proprement les caractères interprétés (ex : ''-name \*.txt'' ou ''-name "*.txt"'') sous peine de rencontrer l'erreur suivante : //find: les chemins doivent précéder l'expression : <un fichier texte>//
  * ''-perm 664'' permet de chercher les fichiers qui ont exactement les droits du masque (ici 664 soit ''<nowiki>-rw-rw-r--</nowiki>''). On peut rechercher tous les fichiers qui ont le droit d'écriture pour le groupe par ''-perm -020''.
  * ''-type f -executable'' permet d'afficher les fichiers exécutables. Fonctionne aussi avec ''-readable'' et ''-writable''.
  * ''-regex 'expr_reg''' permet d'utiliser une expression régulière comme critère de recherche
  * ''-exec'' permet d'exécuter une commande pour chaque résultat de la commande ''find'' (voir exemples)
  * ''-size +1000M'' ne valide que les fichiers dont la taille est supérieure à 1000 Mo.
  * ''-printf'' pour contrôler la sortie et n'afficher que des champs spécifiques du fichier ; voir la partie exemples plus bas.
  * ''-maxdepth n'' ne pas descendre en dessous de n niveaux dans les répertoires parcourus (existe aussi en ''-mindepth n'')
  * ''-mount'' ne pas faire la recherche dans les répertoires situés sur d'autres systèmes de fichiers

On peut moduler les options avec :
  * ''!'' pour exclure une condition ; par exemple rechercher les fichiers qui ne sont pas nommés toto.titi : ''! -name toto.titi''. Equivalent de ''-not'' (''-not -name toto.titi'').
  * ''-a'' (AND) et ''-o'' (OR) pour additionner plusieurs conditions de recherche
==== Exemples ====

<code bash>
# fichiers en écriture pour tout le monde
find / perm 0002 ! type l

# fichiers en lecture pour tout le monde
find / perm 0004 ! type l
find / ( -perm -a+r -o -perm -a+w ) ! -type l

# afficher les fichiers modifier il y a moins de 1 jour (-1)
find . -mtime -1 -print | more
# supprimer les fichiers modifiés il y a plus de 2 jours (+2)
find . -mtime +2 -exec rm -f {} \;

# copier tous les fichiers ''.jpg'' dans /tmp ("-regex" permet de rechercher dans le path complet du fichier)
find . -regex ".*\/([a-z]|[A-Z]|[0-9])+\.jpg$" -exec cp {} /tmp \;

# rechercher ses films de vacances et afficher leurs noms triés par ordre alphabétiques
# NB : le type posix-egrep permet d'utiliser des | dans le motif, ce qui n'est pas possible par défaut
find . -regextype posix-egrep -iregex '.*.avi|.*.mkv|.*.mp4|.*.m4v|.*.m2ts' | sed 's/.*\///g' | sort

# supprimer toutes ces maudites miniatures Windows :
find . -name Thumbs.db -exec rm {} \;

# attribuer des permissions à tous les sous-répertoires contenus dans le répertoire pics :
find ./pics -type d -exec chmod g+rwx {} \;

# rechercher tous les fichiers exécutables en excluant les dossiers
find . -type f -perm -100

# trouver et compter les doublons dans le répertoire courant (et les sous-répertoires) :
find . -type f | sed "s#.*/##g" | sort | uniq -c -d

# supprimer les dossiers vides
find . -type d -empty -delete

# lister récursivement les 10 fichiers les plus récents d'un répertoire :
find /mnt/data -type f -printf "%TY-%Tm-%Td %TT %f\n" | sort | tail -10

# afficher les fichiers de plus de 10 Go (''-size +10G'') contenus dans le dossier courant,
# triés par ordre décroissant de taille :
# (On affiche la taille du fichier en Ko (''%k''), et le nom du fichier sans le path (''%f'').
# Le reste des commandes sert à classer et ne retenir que les 10 plus récents.)
find . -type f -size +10G -printf "%k %f\n" | sort -rn | tail -10

# on peut additionner les conditions de recherches avec -a (AND) et -o (OR)
find . \( -name '*.avi' -o -name '*.mkv' \) -print

Pour trier les résultats par date de modification :
find . \( -name '*.avi' -o -name '*.mkv' \) -exec ls -rt {} \;
</code>
=====flock=====

flock est une commande de gestion de verrou. La syntaxe est :
<code>flock <fichier de verrou> commande</code>

Le concept global du verrou permet de vérifier que l'on n'a pas 2 commandes qui se lancent simultanément.\\
La commande ne se lance que si aucun autre programme n'a bloqué le verrou ; si elle obtient le verrou, elle le bloque pour le temps de son exécution, et le débloque à la fin. Par défaut si le verrou ne peut être acquis, **flock** attend qu'il se débloque sans lancer la commande.

Paramètres :
  * ''-w 10'' : annuler la commande si l'on n'acquière pas le verrou avec 10 secondes
  * ''-s'' (**s**hared) : créer un verrou partager (verrou de lecture)
  * ''-e'' ou ''-x'' (**ex**clusive) : pour obtenir un verrou exclusif (verrou d'écriture)

=====finger=====

C'est un service qui permet d'obtenir des informations sur les comptes utilisateurs :
<code bash>
finger -l dude
</code>


=====fmt=====

Utilitaire pour formater du texte.

Exemple :
<code bash>
# afficher du texte en colonnes de max 4 caractères
echo "toto titi tata tutu" | fmt -w10
toto titi
tata tutu
</code>

=====free=====

Affiche des informations sur la mémoire (utilisée, libre, totale) :
  free 
               total       used       free     shared    buffers     cached
  Mem:        452052     382144      69908          0     145688      53744
  -/+ buffers/cache:     182712     269340
  Swap:       497972        424     497548


=====ftp=====

Permet d'échanger des fichiers avec un hôte distant par protocole **FTP**.

Quelques commandes en vrac : ''dir cd get mget put mput binary exit''.


=====fuser=====

Identifier les processus qui utilisent un fichier.
(voir mount)


=====getent=====

//Obtient des entrées de la base de données administrative//

Par exemple pour récupérer la ligne de l'utilisateur "dude" :
<code bash>
getent passwd dude
dude:x:10000:10000:dude,,,:/home/dude:/bin/bash
</code>
=====getopts=====

Cette commande permet de récupérer facilement les options (paramètres) avec lesquels a été lancé un script. Une option est un caractère précédé d'un + ou d'un - (à la différence d'un argument qui est "juste" une chaîne de caractère) ; getopts analyse les options une par une, et doit donc être utilisée dans une boucle.

[[informatique:linux:programmation_shell#getoptsanalyse_des_arguments_d_un_script|Explications approfondies disponibles ici.]]
=====grep=====

**grep** est un outil de recherche de motifs, soit dans son flux d'entrée soit dans un fichier (les 2 commandes suivantes sont équivalentes) :
<code bash>
cat toto.txt | grep titi
grep titi toto.txt
</code>

Les options possibles sont :
  * ''-c'' (**c**ount) pour avoir uniquement le nombre de lignes satisfaisantes 
  * ''-i'' (**i**nsensible à la casse) : pour ne pas différencier minuscules et majuscules 
  * ''-n'' (**n**umber)pour afficher les numéros de lignes
  * ''-v'' pour obtenir les lignes où le motif n'existe pas
  * ''-A <nb>'' pour afficher <nb> lignes après celles qui matchent
  * ''-B <nb>'' pour afficher <nb> lignes avant celles qui matchent
  * ''-R'' mode **r**écursif (recherche dans tous les fichiers de tous les sous-répertoires)
  * ''--color=auto'' pour afficher en rouge le motif dans les résultats
  * ''-q'' (**q**uiet) n'affiche rien, se contente de retourner le code d'erreur 0 s'il trouve le motif, 1 sinon
  * ''-o'' (**o**nly-matching) : n'affiche que les résultats matchant le motif (et pas la ligne entière)
  * ''-f FILE'' : fournit à grep une liste de patterns listées une par ligne dans le fichier FILE
  * ''-H'' affiche le nom de fichier pour chaque ligne qui matche (option par défaut)
  * ''-h'' inverse de -H : supprime l'affichage des noms des fichiers

Il est possible d'utiliser les expressions régulières dans le motif, par exemple :
<code bash>
grep '^d' toto.txt
</code>

Pour utiliser des filtres multiples il faut utiliser ''egrep'' :
<code bash>
egrep "toto|titi" tata.txt
</code>

====*grep====

Les dérivés de grep :
  * ''egrep'' : permet d'utiliser des expressions régulières étendues (ERE) dans les patterns ; il vaut mieux utiliser ''grep -E'' car egrep est désuet. Exemple : pour afficher un fichier purgé des lignes vides et des commentaires :
<code bash>
grep -vE '^$|^#' file
</code>
  * ''zgrep'' : permet de dézipper automatiquement les archives (*.gz) pour faire une recherche dedans

====Tips====

  * filtrer la liste des processus sans inclure le processus grep : ''ps aux | grep [p]rocess-name''
En temps normal si on recherche le processus ssh avec grep on obtient une ligne incluant le processus de recherche grep :
<code bash>
ps axu | grep ssh
dude      1777  0.0  0.0   3324   824 pts/4    S+   12:29   0:00 grep ssh
root      5332  0.0  0.1   5500   988 ?        Ss   Jan06   0:00 /usr/sbin/sshd
</code>

En effet les ''[]'' ne sont interprétés que par grep, et ne matchent plus la recherche.

Pour supprimer cette ligne parasite :
<code bash>
ps axu | grep [s]sh
root      5332  0.0  0.1   5500   988 ?        Ss   Jan06   0:00 /usr/sbin/sshd
</code>

source : [[http://www.commandlinefu.com/commands/view/2997/find-the-process-you-are-looking-for-minus-the-grepped-one|commandlinefu]]

  * compter le nombre de lignes d'un fichier : ''grep  -c ^ FIC'' (marche aussi avec ''$'' ou ''""'')
=====grpck=====

**grpck** vérifie la cohérence et l'intégrité des données des groupes (c'est le pendant de ''pwck'').


=====gunzip=====

Permet de décompresser un fichier compressé avec la commande ''gzip'' (''.gz'').

<code bash>
gunzip -d fichier.gz

# pour extraire le contenu du fichier et l'afficher sur la sortie standard : 2 façons
cat toto.gz | gunzip
gunzip -cd fichier.gz
</code>

''gzcat'' est un alias souvent utilisé :
<code bash>
alias gzcat='gunzip -cd'
</code>

=====gzip=====

Est un outil de compression. il transforme un fichier en fichier archive ayant l'extension ''.gz'', par exemple ici on compresse toto.tar :
  gzip -9 toto.tar
  ls
   toto.tar.gz

On obtient automatiquement un ''.tar.gz'' (le fichier .tar sera compressé et renommé) ; l'option ''-9'' indique le degré de compression.

Pour décompresser un fichier, voir ''gunzip''.


=====head=====

Affiche les 10 premières lignes d'un fichier.
  head ~/.bash_history

''-n <nb>'' spécifie le nombre de lignes à afficher


=====help=====

Affiche la liste des commandes internes et leur syntaxe.
''help <cmd>'' affiche l'aide d'une <cmd> particulière.


=====history=====

Permet d'afficher l'historique des commandes saisies lors de la session dans un terminal :
<code bash>
history
 64  ls -la
 65  pwd
 66  cd /
 67  cd etc
 68  echo 'toto'
 69  history
</code>

Lors de la fermeture de session, cette liste est ajoutée au fichier indiqué dans la variable ''$HISTFILE''. On peut contrôler :
  * le format de timestamp de chaque commande avec la variable ''HISTTIMEFORMAT'' (même format que la commande date)
  * la taille de l'historique, en nombre de ligne
    * ''HISTSIZE'' défini la taille de l'historique de la session courante (en mémoire)
    * ''HISTFILESIZE'' défini la taille du fichier d'historique (celui défini dans ''$HISTFILE'')
  * ''HISTCONTROL'' permet d'ignorer les doublons (ignoredups), les commandes précédées par un espace (ignorespace) ou les deux (ignoreboth)
Exemple :
<file bash .bashrc>
HISTCONTROL=ignoredups:ignorespace
HISTTIMEFORMAT="%Y%m%d_%H%M%S "
HISTSIZE=10000
HISTFILESIZE=20000
</file>

On peut relancer une commande de l'historique en saisissant //!// suivi de son numéro :
<code bash>
!65
 pwd
 /etc
</code>

On peut également relancer la dernière commande avec ''!!'' :
<code bash>
!!
 pwd
 /etc
</code>

Pour relancer la dernière commande commençant par //p//, on utilise :
<code bash>
!p
 pwd
 /etc
</code>

On efface l'historique de session : ''history -c'' ; forcer l'écriture du buffer dans le fichier ''history -a''.

On peut loguer (dans ''/var/log/messages'') l'historique des commandes saisies par un utilisateur en ajoutant dans son .bashrc cette ligne :
<code bash>
PROMPT_COMMAND='history -a >(logger -t "$SHELL: $USER[$PWD] $SSH_CONNECTION")'

# vérification
tail -1 /var/log/messages
Feb  7 18:22:45 vdeb7 /bin/bash: dude[/home/dude]: history
</code>
=====host=====
Renvoie l'IP d'un nom d'hôte en paramètre :
<code>host toto
toto has address 192.168.0.1</code>

Pour lister les IPs d'une liste de machines située dans un fichier liste.txt :
<code>while read n; do host $n; done < liste.txt
toto has address 192.168.0.1
titi has address 192.168.0.2</code>


=====hostname=====
Cette commande sans paramètre renvoie le nom de la machine ; suivi d'une chaine de caractère elle modifie le nom de la machine.

  toto:$ hostname
   toto
  toto:$ hostname titi
  titi:$
  
Il faut éditer ''/etc/hostname'' pour changer le nom de la machine pour le prochain reboot.

Pour prendre en compte le changement :

  /etc/init.d/hostname.sh
  /etc/init.d/sysklogd restart

puis se reloger.

Avec le paramètre ''-i'', la commande renvoie l'adresse IP de la machine :
<code>
hostname -i
 ymir
</code>

=====iconv=====

iconv est un utilitaire de conversion et d'encodage de texte.
<code bash>
# Supprimer les caractères accentués:
echo "éèï" | iconv -f utf8 -t ascii//TRANSLIT//IGNORE
 eei
</code>


=====id=====
Affiche l'**uid** (user id) ainsi que le **gid** (group id) et la liste des groupes auxquels appartiennet l'utilisateur courant.

Si elle est suivi d'un nom d'utilisateur, la commande affiche ces information sur l'utilisateur en question.

<code>
id root
 uid=0(root) gid=0(root) groupes=0(root)
</code>


=====ifup/ifdown=====

''ifup'' et ''ifdown'' sont des script dépendant de la distribution, qui servent à activer/désactiver une interface :
<code>
ifup eth0
</code>

équivaut (normalement) à :
<code>
ifconfig eth0 up
</code>

Pour relancer le service réseau sous Debian :
<code>
/etc/init.d/networking restart
</code>

et sous Redhat :
<code>
service network restart
</code>


=====ifconfig=====

Sert à contrôler et diagnostiquer le réseau sur la machine.

  * configurer l'adresse IP static de la carte réseau
<code bash>
ifconfig eth0 192.168.0.2 netmask 255.255.255.0 broadcast 192.168.0.255
</code>

Pour activer le DHCP (adressage automatique) :
<code bash>
dhclient eth0
</code>

Pour le prendre en compte au prochain démarrage, éditer le fichier :

  * ''/etc/network/interfaces'' sous Debian
  * ''/etc/sysconfig/network'' et/ou ''/etc/sysconfig/network-script/ifcfg.eth0'' sous Redhat
  * ''/etc/sysconfig/network-script/ifcfg-eth0'' sous NetBSD

et mettre quelque chose qui ressemble à ça, c'est assez parlant :
<code bash>
iface eth0 inet static
 address 192.168.0.2
 netmask 255.255.255.0
 network  192.168.0.0
 gateway 192.168.0.2
 post-up /usr/bin/ethtool eth0 -s speed 100 duplex full autoneg off
</code>

(pour le DHCP il suffit de saisir ''iface eth0 inet dhcp'' à la place)

Pour ajouter automatiquement des routes lorsque une interface réseau devient active ou inactive, on utilise la règle ''post-up'' du fichier ''/etc/network/interfaces'' :
<code bash>
allow-hotplug eth1
iface eth1 inet dhcp
 post-up route add -net 42.42.42.0 netmask 255.255.255.0 gw 192.168.1.1
 down route del -net 42.42.42.0 netmask 255.255.255.0 gw 192.168.1.1
</code>

(source : http://www.noplay.net/Ajouter-des-routes-au-chargement-d.html)

  * pour supprimer l'adresse IP d'une interface :
<code bash>
ip address del w.x.y.z dev ethX
</code>
Cela fait la modif à chaud, sans redémarrer l'interface.

  * pour restaurer la configuration par défaut d'une interface :
<code bash>
ifconfig ethX default
</code>

====Diagnostique====
On lance la commande ifconfig seule (ou avec -a) pour lister, toutes les interfaces, ou suivi d'un nom d'interface particulier :
<code bash>
ifconfig eth0
eth0      Link encap:Ethernet  HWaddr AA:BB:CC:DD:EE:FF  
          inet adr:10.1.2.201  Bcast:10.1.255.255  Masque:255.255.0.0
          adr inet6: fe80::aabb:ccff:fedd:eeff/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:110602292 errors:0 dropped:0 overruns:0 frame:0
          TX packets:75188627 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:1000 
          RX bytes:34256601697 (31.9 GiB)  TX bytes:78967426849 (73.5 GiB)
          Interruption:17 
</code>

Le retour indique, par ligne :
  * le type de lien (Link encap) et l'adresse MAC de l'interface (HWaddr)
  * l'adresse IP (inet adr), de broadcast et le masque réseau
  * l'adresse IPv6 et son domaine de validité (scope)
  * l'état de l'interface (ici UP, qui indique que l'interface est activée et possède le couche réseau (3)), {BROAD|MULTI}CAST pour indiquer que le lien accepte le {broad|multi}cast, RUNNING (le driver de l'interface est chargé et a initialisé l'interface), et la taille de la MTU (Maximim Transmission Unit = la taille max des paquets __transportés__ par la couche 2 (accès réseau), à savoir Ethernet)
  * les compteurs de paquets de l'interface en réception et transmission (RX et TX) ainsi que les fails de type :
    * errors : somme de tous les paquet en erreurs (erreurs CRC, paquets trop petits ou trop grands (runts/giants en terminologie Cisco), trame non alignée, etc... )
    * dropped : paquets droppés (cause = un mauvais tag de VLAN ou un paquet IPv6 quand le système ne le gère pas)
    * overruns : dépassement du buffer de l'interface
    * frame : trame non alignée = paquets dont la taille n'est pas divisible par 8, qui sont donc rejetés
    * carrier : perte du signal pendant l'émission d'une trame
    * collision : nombre de collision détectées (voir [[https://fr.wikipedia.org/wiki/Carrier_Sense_Multiple_Access_with_Collision_Detection|fonctionnement du CSMA/CD]])
  * le volume de données reçues et envoyées (RX et TX bytes), exprimé en bytes puis en gibibit ([[informatique:linux:raid0_sous_linux#rappel_sur_les_unites|oui gibi, voir ici]])
  * Le numéro d'interruption de la carte réseau, attribué par le système

source : http://blog.hyfather.com/blog/2013/03/04/ifconfig/
=====info=====

Affiche les informations sur une commande (relativement similaire à la commande ''man'') :
  info ls


=====ip=====

Couteau suisse réseau, il permet de configurer les paramètres ip d'une interface réseau. Dans de plus en plus de distributions, il semble supplanter les tradditionnels ifconfig, arp, route, etc...
<code bash>
# afficher les interfaces
ip addr show
 1: lo: <LOOPBACK,UP> mtu 16436 qdisc noqueue
     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
     inet 127.0.0.1/8 brd 127.255.255.255 scope host lo
     inet6 ::1/128 scope host
        valid_lft forever preferred_lft forever
 2: eth0: <BROADCAST,MULTICAST,UP> mtu 1500 qdisc pfifo_fast qlen 1000
     link/ether 00:0b:cd:0a:ad:31 brd ff:ff:ff:ff:ff:ff
     inet 132.166.99.1/24 brd 132.166.99.255 scope global eth0
 3: eth1: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast qlen 1000
     link/ether 00:0b:cd:0a:ad:30 brd ff:ff:ff:ff:ff:ff

# afficher la table de routage
ip route
default via 10.10.22.249 dev ens3 onlink
10.10.22.0/24 dev ens3 proto kernel scope link src 10.10.22.65

# affecter ou supprimer une adresse IP à une interface
ip addr add 10.0.0.1 255.255.255.0 dev eth0
ip addr del 10.0.0.1 255.255.255.0 dev eth0

# afficher les voisins
ip neigh
</code>

Équivalence anciennes/nouvelles commandes:
^ anciennes commandes ^ équivalent ip ^
| ifconfig -a | ip a |
| ifconfig enp6s0 down | ip link set enp6s0 down |
| ifconfig enp6s0 up | ip link set enp6s0 up |
| ifconfig enp6s0 10.0.0.24 netmask 255.255.255.0 dev enp6s0 | ip addr add 10.0.0.24/24 dev enp6s0 |
| ifconfig enp6s0 mtu 9000 | ip link set enp6s0 mtu 9000 |
| ifconfig enp6s0:0 10.0.0.25 | ip addr add 10.0.0.25/24 dev enp6s0 |
| netstat | ss |
| netstat -tulpn | ss -tulpn |
| netstat -neopa | ss -neopa |
| netstat -g | ip maddr |
| route | ip r |
| route add -net 10.0.0.0 netmask 255.255.255.0 dev enp6s0 | ip route add 10.0.0.0/24 dev enp6s0 |
| route add default gw 10.0.0.254 | ip route add default via 10.0.0.254 |
| arp -a  | ip neigh |
| arp -v | ip -s neigh |
| arp -s 10.0.0.33 1:2:3:4:5:6 | ip neigh add 10.0.1.33 lladdr 1:2:3:4:5:6 dev enp6s0 |
| arp -i enp6s0 -d 10.0.0.254 | ip neigh del 10.0.0.254 dev wlp7s0 |

=====ipcs=====

ipcs affiche les information sur l'usage des ressources IPC.
<code bash>
# afficher la liste des sémaphores
ipcs -s
</code>

=====ipcrm=====

ipcrm permet de supprimer une file de messages, un jeu de sémaphore ou un segment de mémoire partagée.
<code bash>
ipcrm -s <id_sem>
</code>
=====iptables=====

====Principe====

{{http://upload.wikimedia.org/wikipedia/fr/thumb/3/3e/Netfilter_schema.png/411px-Netfilter_schema.png|Netfilter_principe}}


====Les options====

  Option : 	Description :
  -A 	Append (ajoute)
  -D 	Delete (efface)
  -I 	Insert (insère)
  -R 	Replace (remplace)
  -L 	List (liste)
  -F 	Efface toutes les règles dans la ou les chaînes
  -Z 	Remet les compteurs à zéro dans une ou plusieurs chaînes
  -C 	Teste ce paquet sur une chaîne
  -N 	Crée une chaîne définie par l'utilisateur
  -X 	Efface une chaîne définie par l'utilisateur
  -P 	Change le comportement d'une chaîne sur une cible
  -E 	Change le nom d'une chaîne
  -p 	Protocole
  -s 	Adresse/masque de source
  -d 	Adresse/masque de destination
  -i 	Nom d'entrée (nom ethernet)
  -o 	Nom de sortie (nom ethernet)
  -j 	Saute (cible de règle)
  -m 	Correspondance étendue (peut utiliser des extensions)
  -n 	Sortie numérique de ports et d'adresses
  -t 	Table à manipuler
  -v 	Mode bavard
  -x 	Vérifications étendues (affiche les valeurs exactes)
  -f 	Prends uniquement en compte le second fragment ou ceux d'après
  -V 	Version du paquet
  --line-numbers 	Affiche les numéros de ligne


====Les extensions====

  Module  	Description  	Options étendues
  mac 	Vérifie que l'extension correspond pour les paquets entrants sur une adresse mac. 	--mac-source
  state 	Active l'inspection des états 	--state (les états sont ESTABLISHED,RELATED, INVALID, NEW)
  limit 	Définit une limite sur le flux 	--limit, --limit-burst
  owner 	Essaie de trouver des correspondances dans le créateur du paquet 	--uid-owner userid --gid-owner groupid --pid-owner processid --sid-owner sessionid
  unclean 	Plusieurs tests de vérification aléatoires du bon état des paquets


====Redirection====

Exemple de redirection du trafic HTTP vers un serveur mandataire (port 3128) :
  iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to proxyhost:3128
  iptables -t nat -A PREROUTING -p tcp --dport 443 -j DNAT --to proxyhost:3128


====Exemples====

Ajoute en première position de la table INPUT :
  iptables -I INPUT 1 -p tcp --dport 1165 -j ACCEPT
On accepte les paquets TCP à destination du port 1165

Lister les règles en place [dans la table INPUT uniquement] :
  iptables -L [INPUT] -n
On peut utiliser l'option -v pour un mode plus verbeux (affiche les connexions actives).


====Liens====

  * http://www.linutop.com/wiki/index.php/Tutorials/Debootstrap


=====jobs=====

Affiche la liste des jobs du terminal (voir aussi bg et fg).

Exemple : je lance 2 ''sleep'' (sans jeu de mot) que j'interrompe avec un ''ctrl+z'', et je liste les jobs du terminal :

  sleep 10
  
   [1]+  Stopped                 sleep 10
  sleep 12
  
   [2]+  Stopped                 sleep 12

Les 2 commandes sont interrompues ; si je veux continuer le //sleep 12// en le plaçant en avant-plan grâce à son "numéro de job" :

  jobs
   [1]-  Stopped                 sleep 10
   [2]+  Stopped                 sleep 12
  fg %2
   sleep 12

Il ne reste plus que le //sleep 10// dans la liste des jobs ; je peux le relancer en arrière-plan sans préciser son numéro de job car c'est le seul dans la liste :
  jobs
   [1]+  Stopped                 sleep 10
  bg
   [1]+ sleep 10 &


=====kill=====

Permet d'envoyer un //signal// à un //processus//, défini par son //PID// :
  kill -signal <PID>

//signal// peut être sous forme numérique ou alphabétique ; la liste des signaux peut être affichée avec l'option ''-l'' :
  kill -l
   1) SIGHUP        2) SIGINT       3) SIGQUIT      4) SIGILL
   5) SIGTRAP       6) SIGABRT      7) SIGEMT       8) SIGFPE
   9) SIGKILL      10) SIGBUS      11) SIGSEGV     12) SIGSYS
   13) SIGPIPE     14) SIGALRM     15) SIGTERM     16) SIGURG
   17) SIGSTOP     18) SIGTSTP     19) SIGCONT     20) SIGCHLD
   21) SIGTTIN     22) SIGTTOU     23) SIGIO       24) SIGXCPU
   25) SIGXFSZ     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH
   29) SIGINFO     30) SIGUSR1     31) SIGUSR2     32) SIGPWR

ainsi ''kill -9 1000'' et ''kill -SIGKILL 1000'' auront le même impact.

**NB** : sur certains OS, les signaux ne sont pas définis par SIGxx mais xx tout court (SIGKILL -> KILL)


=====killall=====

Envoyer un signal aux processus dont le nom contient //<motif>//. Il faut faire attention à l'impact d'une telle commande si mal écrite.
  killall rsh

Les options sont les mêmes que la commande ''kill''.

Sur les *BSD, ''pkill'' remplace ''killall''.


=====last=====

Affiche les dernières connexions (ici les 12 dernières)
  last -n 12


=====lastb=====

**lastb** (last bad logins) affiche les derniers logins en échec (mauvais nom d'utilisateur ou mot de passe).

<code bash>
# lastb
toto     ssh:notty    10.0.57.26    Wed Jan  9 22:13 - 22:13  (00:00)
titi     ssh:notty    10.0.128.23   Mon Jan  7 09:38 - 09:38  (00:00)
toto     ssh:notty    10.0.57.26    Fri Jan  4 20:16 - 20:16  (00:00)
tata     ssh:notty    10.0.128.23   Thu Jan  3 09:11 - 09:11  (00:00)
tatoo    ssh:notty    10.0.128.23   Thu Jan  3 09:11 - 09:11  (00:00)
</code>
=====lastlog=====

Affiche la liste des utilisateurs du système suivis de la date et l'heure de leur dernière connexion.
<code bash>
lastlog
Utilisateur      Port     Venant de        Dernière
dude             pts/1    is110853.intra.c ven déc 14 15:55:51 +0100 2007
ftp                                        **Jamais connecté**
people           tty6                      mar déc 19 17:40:45 +0100 2006
roro             pts/4    calata           mer sep 12 20:55:57 +0200 2007
</code>

=====ldd=====

**ldd** affiche les bibliothèques partagées nécessaires à un exécutable. Exemple pour Firefox :
<code bash>
which firefox
/usr/local/bin/firefox

ldd /usr/local/bin/firefox
	linux-gate.so.1 =>  (0x00c14000)
	libpthread.so.0 => /lib/libpthread.so.0 (0x007fe000)
	libdl.so.2 => /lib/libdl.so.2 (0x007ec000)
	librt.so.1 => /lib/librt.so.1 (0x007f3000)
	libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x0015b000)
	libm.so.6 => /lib/libm.so.6 (0x00996000)
	libgcc_s.so.1 => /lib/libgcc_s.so.1 (0x00aea000)
	libc.so.6 => /lib/libc.so.6 (0x00653000)
	/lib/ld-linux.so.2 (0x00631000)
</code>
=====let=====

ex : Pour incrémenter z :
  let z=z+1
  let "z += 1"

=====ln=====

Commande pour créer des liens.

Pour créer un lien dur :
  ln <fichier_source> <lien>

Pour créer un lien symbolique (~raccourci) :
  ln -s <fichier_source> <lien>


=====locate=====

[[http://fr.wikipedia.org/wiki/Locate_%28commande_Unix%29|Locate]] est une commande Unix permettant d'indexer et de retrouver facilement des fichiers sur un disque. Alors que la commande ''find'' recherche en parcourant le disque, ''locate'' utilise une base de données permettant une recherche beaucoup plus rapide ; l'inconvéniant (mineur) étant qu'il faille régulièrement mettre à jour cette base.

La syntaxe est la suivante :
  locate fichier

Pour affiner la recherche, on peut utiliser des paramètres :
  * ''-d chemin'' pour spécifier une location
  * ''-i'' pour ignorer la casse
  * ''-r regex'' pour utiliser une expression régulière //regex//
  * ''-S'' affiche des statistiques

Pour mettre à jour la base (sous Debian) :
  updatedb


=====logout=====

Est la commande pour fermer sa session, dans un terminal login. Le raccourci est ''ctrl+d''.


=====look=====
Pour rechercher un mot rapidement dans le dictionnaire (cf aspell), on utilise la commande look.

<code>
look jap
 japonais
 japonaise
 japonaises
 jappement
 jappements
 japper
</code>


=====ls=====

Affiche le contenu d'un dossier ou les infos d'un fichier.

La commande regorge d'options utiles et combinables :
  * ''-l'' (long format) : affiche des informations détaillées des fichiers contenus dans le dossier en paramètre.
  * ''--color'' : affiche le résultat en couleur
  * ''-a'' : affiche les fichiers cachés
  * ''-p'' affiche un "/" après les noms de répertoires afin de mieux les identifier
  * ''-t'' (//time//) classe les résultats par date de dernière modification
  * ''-r'' (//reverse//) inverse le classement des résultats
  * ''-1'' (tiret un, et non tiret L) pour formater le résultat sur une seule colonne

<code bash>
ls -lp
total 1728
-rw-r--r--  1 dude dude        4930 2006-11-08 11:34 buf_stag.txt
drwxr-xr-x  2 dude dude        4096 2006-02-17 18:58 Desktop/
drwxr-xr-x  3 dude dude        4096 2006-10-21 21:08 dl/
drwx------  2 dude dude        4096 2006-10-19 14:53 Mail/
-rw-------  1 dude dude       91952 2006-11-07 14:38 mbox
drwxr-xr-x  2 dude dude        4096 2006-09-25 11:43 public_html/
-rw-------  1 dude dude         354 2006-10-20 10:27 sent
-rw-r--r--  1 dude dude         140 2006-09-12 02:00 uptime_tiga.txt
drwxr-xr-x 20 dude dude        4096 2006-02-22 02:52 vlc-0.8.4a/##
</code>

Il est conseillé de faire des alias pour ne pas avoir à saisir les options les plus utilisées. Par exemple si on utilise bash, on édite le fichier de préférence ''~/.bashrc'' et on ajoute :

<code bash>
alias ll='ls -l --color'
alias la='ls -a --color'
alias l='ls -p --color'
</code>
(ces alias sont souvent déjà présents dans la plupart des distributions Linux).

Puis on relance le terminal.


=====lsblk=====

**lsblk**  permet de lister les périphériques de type bloc, c'est-à-dire les supports de stockage.

<code bash>
lsblk
NAME                 MAJ:MIN RM  SIZE RO TYPE  MOUNTPOINT
sda                    8:0    0  2,7T  0 disk  
└─sda1                 8:1    0  2,7T  0 part  
  └─md127              9:127  0  8,2T  0 raid5 
    └─vgmd1-lvmd1    252:3    0  8,2T  0 lvm   /m/d
sdb                    8:16   0  2,7T  0 disk  
└─sdb1                 8:17   0  2,7T  0 part  
  └─md127              9:127  0  8,2T  0 raid5 
    └─vgmd1-lvmd1    252:3    0  8,2T  0 lvm   /m/d
sdc                    8:32   0  2,7T  0 disk  
└─sdc1                 8:33   0  2,7T  0 part  
  └─md127              9:127  0  8,2T  0 raid5 
    └─vgmd1-lvmd1    252:3    0  8,2T  0 lvm   /m/d
sdd                    8:48   0  2,7T  0 disk  
└─sdd1                 8:49   0  2,7T  0 part  
  └─md127              9:127  0  8,2T  0 raid5 
    └─vgmd1-lvmd1    252:3    0  8,2T  0 lvm   /m/d
sde                    8:64   0 59,6G  0 disk  
├─sde1                 8:65   0  487M  0 part  /boot
├─sde2                 8:66   0    1K  0 part  
└─sde5                 8:69   0 59,2G  0 part  
  ├─ymir2--vg-root   252:0    0 57,2G  0 lvm   /
  └─ymir2--vg-swap_1 252:1    0    2G  0 lvm   
    └─cryptswap1     252:2    0    2G  0 crypt [SWAP]
</code>
=====lshw=====

Pour lister le hardware de la machine.


=====lsmod=====

Affiche le statut des modules du noyau Linux.


=====lsof=====

//List open files// ; permet de lister tous les fichiers ouverts sur le système avec différentes informations dessus (ouverts par quel processus, quel utilisateur, etc).

  * ''lsof -i'' indique les processus de type internet
  * ''lsof -ni tcp:25'' liste les processus de type internet utilisant du TCP sur le port 25
  * ''lsof /dev/hda1'' liste les fichiers ouvert sur /dev/hda1
  * ''lsof -p 1102,1103'' liste les fichiers ouverts par les processus de PID 1102 ou 1103

=====lspci=====

Permet de lister les matériels connecté sur l'ordinateur :
  lspci
   0000:00:00.0 Host bridge: nVidia Corporation nForce2 AGP (different version?) (rev a2)
   0000:00:00.1 RAM memory: nVidia Corporation nForce2 Memory Controller 1 (rev a2)
   0000:00:00.2 RAM memory: nVidia Corporation nForce2 Memory Controller 4 (rev a2)
   0000:00:00.3 RAM memory: nVidia Corporation nForce2 Memory Controller 3 (rev a2)
   0000:00:00.4 RAM memory: nVidia Corporation nForce2 Memory Controller 2 (rev a2)
   0000:00:00.5 RAM memory: nVidia Corporation nForce2 Memory Controller 5 (rev a2)
   0000:00:01.0 ISA bridge: nVidia Corporation nForce2 ISA Bridge (rev a3)
   0000:00:01.1 SMBus: nVidia Corporation nForce2 SMBus (MCP) (rev a2)
   0000:00:02.0 USB Controller: nVidia Corporation nForce2 USB Controller (rev a3)
   0000:00:02.1 USB Controller: nVidia Corporation nForce2 USB Controller (rev a3)
   0000:00:02.2 USB Controller: nVidia Corporation nForce2 USB Controller (rev a3)
   0000:00:04.0 Ethernet controller: nVidia Corporation nForce2 Ethernet Controller (rev a1)
   0000:00:06.0 Multimedia audio controller: nVidia Corporation nForce2 AC97 Audio Controler (MCP) (rev a1)
   0000:00:08.0 PCI bridge: nVidia Corporation nForce2 External PCI Bridge (rev a3)
   0000:00:09.0 IDE interface: nVidia Corporation nForce2 IDE (rev a2)
   0000:00:1e.0 PCI bridge: nVidia Corporation nForce2 AGP (rev a2)
   0000:01:07.0 Ethernet controller: 3Com Corporation 3c905C-TX/TX-M [Tornado] (rev 6c)
   0000:02:00.0 VGA compatible controller: nVidia Corporation NV18 [GeForce4 MX - nForce GPU] (rev a3)

Pour avoir plus d'infos sur un matériel (certaines options ne sont visibles que par le root) :
  lspci -v -s 02:00.0
   0000:02:00.0 VGA compatible controller: nVidia Corporation NV18 [GeForce4 MX - nForce GPU] (rev a3) (prog-if 00 [VGA])
        Subsystem: Micro-Star International Co., Ltd.: Unknown device 5710
        Flags: bus master, 66MHz, medium devsel, latency 32, IRQ 12
        Memory at e0000000 (32-bit, non-prefetchable) [size=16M]
        Memory at d8000000 (32-bit, prefetchable) [size=64M]
        Memory at dc000000 (32-bit, prefetchable) [size=512K]
        Expansion ROM at dc080000 [disabled] [size=128K]
        Capabilities: [60] Power Management version 2
        Capabilities: [44] AGP version 2.0

(voir aussi //setpci//)


=====mail=====
Pour envoyer des mails en mode texte.

Exemple:
<code>
mail -s "Objet du mail" toto@titi.com <<END
>salut,
>
>test de mail
>sur plusieurs lignes
>END
</code>

Ou non interactif (en utilisant un fichier source) :
<code>
mail -s "Test de mail" toto@titi.com < mail.txt -- -f tutu@tata.fr -F 'Monsieur tutu'
</code>

Ici on utilise les options :
  * ''-f'' (**f**rom) pour donner spécifier l'adresse de l'expéditeur du mail.
  * ''-F'' pour spécifier le nom de la personne qui envoie le mail.

=====man=====

Commande permettant d'accéder à l'aide des commandes.
Par exemple ''man ls'' permet d'afficher la page de **man**uel concernant la commande ''ls''.

On utilise les flèches haut/bas pour changer de ligne, page up/page down (ou espace) pour changer de page, et ''q'' pour **q**uitter.

Les paramètres :
  * ''-k <texte>'' permet d'afficher toutes les pages de l'aide qui contiennent <texte> dans leur nom ou leur description.
  * ''-K <texte>'' affiche les pages qui contienne <texte>

ex :
  man -k fat
   apropos fat
   fs (5)               - Linux filesystem types: minix, ext, ext2, ext3, xia, msdos, umsdos, vfat, proc, nfs, iso9660, hpfs, sysv, smb, ncpfs
   mbadblocks (1)       - tests a floppy disk, and marks the bad blocks in the FAT
   mshowfat (1)         - shows FAT clusters allocated to file

Les chiffres entre paranthèses indiquent les sections du manuel qui nous concernent. Pour consulter une section, par exemple la 5 de //fs// :
  man 5 fs


=====mii-tool=====

Utilitaire qui ressemble à ethtool

  mii-tool
   eth0: negotiated 100baseTx-FD flow-control, link ok
   eth1: negotiated 100baseTx-FD flow-control, link ok


=====mkfifo=====

Permet de créer un tube nommé (un "pipe"). On peut préciser les permissions avec l'option **-m** suivi des droits en décimal (comme chmod) :
<code bash>
mkfifo -m 600 toto.fifo

ll toto.fifo
prw------- 1 gaspard writer 0  5 janv. 14:31 toto.fifo
</code>

Les pipes apparaissent avec le flag "p" dans un ls.

=====mktemp=====

Permet de générer un fichier temporaire avec un nom aléatoire. Par défaut le fichier est créé dans le répertoire temporaire du système ($TMPDIR ou, à défaut, ''/tmp''), et la commande renvoie le chemin absolu du fichier créé sur la sortie standard :
<code bash>
mktemp
/tmp/tmp.XAmxhsyFzl
</code>

On peut forcer le format du nom de fichier en donnant le nom incluant au moins 3 "XXX", qui seront remplacés par une chaine aléatoire :
<code bash>
mktemp toto.XXX
/tmp/toto.XAm
</code>

Autres paramètres :
  * ''-p'' permet de spécifier le répertoire dans lequel créer le fichier temporaire
  * ''-d'' permet de créer un répertoire à la place d'un fichier
=====modconf=====

Outil permettant de configurer les modules matériels (drivers) utilisés par le noyau de votre système.


===== mount =====

mount permet de monter des systèmes de fichier dans l'arborescence. Le fichier ''/etc/fstab'' contient les déclaration des montage habituels et nécessaires au système d'exploitation :
<code bash>
cat /etc/fstab
# Périphérique   Point de montage FS type    Options
 /dev/hda8       /                ext3       defaults,errors=remount-ro 0 1
 /dev/hda6       /sav             ext3       defaults,user   0 2
 /dev/hda7       none             swap       sw              0 0
 /dev/hdc        /mnt/cdrom       iso9660    ro,user,noauto  0 0
 /dev/hda5       /mnt/e           vfat       defaults,user,uid=1000  0 0
 /dev/hdb2       /mnt/i80         ext3       defaults,user   0 2
 //dude/g        /mnt/dude_g      smbfs      username=<user>,password=<pwd>,gid=ftpusers,dmask=755 0 0
</code>

Il faut noter que le dmask (**d**irectory mask) et le fmask (**f**ile mask) remplace le u**n**mask traditionnel (utilisé pour gérer les droits des fichiers samba).
''umask=022'' correspond à ''unmask=755''

Quelques équivalents en ligne de commande :
  * ''mount -t vfat /dev/hda5 /mnt/e''
  * ''%%mount -t smbfs -o username=rezo,password=rez0 //dude/g /mnt/dude_g%%''

Pour démonter une partition :
  * ''umount /mnt/e'' ou ''umount /dev/hda5''

En cas de problème au démontage (''umount: /mnt/cdrom: device is busy'' par exemple) voici quelques pistes :
  * ''lsof | grep /mnt/cdrom'' pour lister les applications bloquant la ressource
  * ''fuser /mnt/cdrom'' fait la même chose (l'option ''-k'' permet de killer directement le(s) processus)
  * ''umount -f /mnt/cdrom'' ou ''umount -l /mnt/cdrom'' pour, respectivement, forcer le démontage ou faire un //démontage paresseux//.

Pour monter une sous-arborescence d'une partition déjà montée (c'est utile par exemple pour émuler des liens symboliques, invisibles par ftp, ou pour ne pas modifier le système de fichiers) on utilise l'option ''<nowiki>--</nowiki>bind'' :
  * ''mount <nowiki>--</nowiki>bind /mnt/dude_g/dl/mp3 /sav/mp3''
(le dossier ''/sav/mp3'' doit exister)

Pour automatiser le montage d'une sous arborescence au démarrage, on va écrire un script :
<code bash>
vi /etc/init.d/mount_mp3
 #!/bin/bash
 echo Montage de www sur /home/votreutilisateur/www
 mount --bind /var/www /home/votreutilisateur/www
</code>

et le lancer au démarrage :
<code bash>
chmod +x mount_mp3
update-rc.d mount_mp3 defaults
</code>

NB : Si la machine qui partage des fichiers redémarre, le point de montage devient invalide. Il faudra le détecter automatiquement, démonter puis remonter le partage.


=====netcat=====

Netcat (nc) est un couteau-suisse réseau qui permet de créer des sockets comme client (''netcat mon_serveur.fr 200'') ou comme serveur (''netcat -l -p 80'') :
  * ''netcat -t ns213.186.xx.xx 23'' Se comporte comme un client telnet
  * ''netcat -l -p 23 > espionne.log'' Ecoute sur le port 23 (telnet) et enregistre dans espionne.log tout ce qui est tapé par le client.
  * ''netcat -l -p 23 < mes_commandes'' Exécute les commandes qui sont dans mes_commandes.
  * ''netcat -l -p 23 -e ma_commande'' Exécute la commande après connexion.
  * ''netcat -vv la_machine_a_scanner 1-100'' Permet de lancer un scan sur des machines distantes.
  * ''netcat -vv -z -i 10000 -r 127.0.0.1 1-200'' Permet de scanner aléatoirement les ports de 1 à 100 avec un time out. On évite la détection.

  * pour tester si des ports sont ouverts sur une machine distante:
<code bash>
# -z = on n'envoie pas de données
# -v = mode verbeux
# -t = TCP (-u pour UDP)
# 80: numéro de port à tester
$ nc -zvt 10.0.0.1 80
Connection to 10.0.0.1 80 port [tcp/ssh] succeeded!

# On peut remplacer un port par une liste de port (séparés par des espaces : "80 443")
#   ou une plage de ports ("80-89")
# Par défaut on teste en TCP ; pour utiliser UDP, ajouter le paramètre -u
#   (ex ici pour tester le DNS et le SYSLOG) :
$ nc -zv 10.0.0.1 -u 53 514
</code>

  * Créer un automate qui renvoie au client tout ce que ce dernier envoie dans la socket :
côté serveur :
<code bash>
mkfifo /tmp/backpipe
nc -l 3333 < /tmp/backpipe | cat 1> /tmp/backpipe
</code>

côté client (ici le client tape la commande, puis "écho" dans son prompt) :
<code bash>
nc 127.0.0.1 3333
écho
écho
</code>

... et, pour afficher un compteur d'octets transitant par notre socket (côté serveur dans cet exemple), on peut utiliser l'utilitaire **Pipe viewer** (il faut l'installer via aptitude) :
<code bash>
aptitude install pv
[..]

mkfifo /tmp/backpipe
nc -l 3333 < /tmp/backpipe | pv -b | cat 1> /tmp/backpipe
</code>

  * autre exemple d'utilisation de netcat : "émuler" un serveur web
côté client :
<code bash>
echo -n "GET / HTTP/1.0\r\n\r\n" | nc host.example.com 80
</code>

côté serveur
<code bash>
{ echo -ne "HTTP/1.0 200 OK\r\nContent-Length: $(wc -c <some.file)\r\n\r\n"; cat some.file; } | nc -l 8080
</code>
=====netstat=====

Couteau suisse de l'administrateur réseau : affiche les connexions réseau, la table de routage, les statistiques des interfaces, les connexions masquées, les messages netlink, et les membres multicast.

Quelques exemples d'utilisation :
  * ''netstat -rn'' affiche la table de routage (''-r''), sans résolution de nom (numérique, ''-n'')
  * ''netstat -natp'' affiche toutes les connexions (''-a'') tcp (''-t'') en numérique (''-n'') en indiquant le processus qui utilise chaque socket (''-p'')
  * ''netstat -ntl'' liste les ports ouverts (**l**isten)
  * ''netstat -s'' permet d'afficher les statistiques réseau de la machine (les compteurs IP, de connections TCP ou UDP)

=====NetworkManager=====

Utilitaire de configuration réseau utilisé par défaut sous Redhat/RockyLinux/feu CentOS.

src: https://docs.rockylinux.org/fr/guides/network/basic_network_configuration/
<code bash>
# Etat du service
systemctl status NetworkManager

# Editer fichier de conf
vim /etc/sysconfig/network-scripts/ifcfg-ens18
TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
BOOTPROTO=none
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=no
NAME=ens18
UUID=xxxx-xx
DEVICE=ens18
ONBOOT=yes
IPADDR=192.168.0.1
PREFIX=24
GATEWAY=192.168.0.254
DNS1=192.168.0.254
DNS2=1.1.1.1
IPV6_DISABLED=yes

# Appliquer la conf réseau
nmcli connection up ens18

# Vérifier bonne application de la conf :
nmcli device show ens18
ip a
ip route
</code>
=====nslookup=====

Permet d'interroger un serveur DNS afin d'obtenir des informations sur un domaine ou sur une machine :
<code bash>
nslookup google.fr
 Server:         127.0.0.1
 Address:        127.0.0.1#53

 Non-authoritative answer:
 Name:   google.fr
 Address: 216.239.59.104
 Name:   google.fr
 Address: 66.249.93.104
 Name:   google.fr
 Address: 72.14.221.104

# pour interroger un serveur (ici 10.1.1.24) en particulier :
nslookup google.fr 10.1.1.24

# utiliser nslookup en mode interactif
nslookup
> server 10.1.1.24
Default server: 10.1.1.24
Address: 10.1.1.24#53
> google.fr
Server:		10.1.1.24
Address:	10.1.1.24#53

Non-authoritative answer:
Name:	google.fr
Address: 216.58.209.227
</code>

Cet outil est "désuet" car plus maintenu sous Linux (mais pas sous Windows) ; ''dig'' le remplace et est plus complet.


=====NTP=====

NTP est le protocole de synchronisation d'horloge d'équipements informatique ; le démon NTPd permet à une machine Linux de se synchroniser régulièrement pour conserver une date/heure fiable sur le long terme.

/etc/ntp.conf
<code bash>
# spécification des serveurs sur lesquels se synchroniser
pool 0.fr.pool.ntp.org iburst
pool 0.ch.pool.ntp.org iburst
pool 0.debian.pool.ntp.org iburst
pool 1.debian.pool.ntp.org iburst
pool 2.debian.pool.ntp.org iburst
pool 3.debian.pool.ntp.org iburst

# si besoin, préciser les clients qui peuvent se synchroniser sur nous
restrict 127.0.0.1
restrict ::1
</code>

Forcer la mise à jour de la date sur un serveur en particulier : ''ntpdate 1.2.3.4''

Vérifier le bon fonctionnement :
<code bash>
ntpq -p
     remote           refid      st t when poll reach   delay   offset  jitter
==============================================================================
 0.fr.pool.ntp.o .POOL.          16 p    -   64    0    0.000    0.000   0.000
 0.ch.pool.ntp.o .POOL.          16 p    -   64    0    0.000    0.000   0.000
 0.debian.pool.n .POOL.          16 p    -   64    0    0.000    0.000   0.000
 1.debian.pool.n .POOL.          16 p    -   64    0    0.000    0.000   0.000
 2.debian.pool.n .POOL.          16 p    -   64    0    0.000    0.000   0.000
 3.debian.pool.n .POOL.          16 p    -   64    0    0.000    0.000   0.000
#ntp-2.arkena.ne 193.190.230.65   2 u   34   64  177   14.795   -2.333   0.212
-178.249.167.0 ( 195.66.241.2     2 u   30   64  177    9.682   -0.016   0.152
*eudyptula.init7 162.23.41.10     2 u   37   64  177   13.736   -0.070   0.152
-smtp1.xipalia.c 193.190.230.65   2 u   33   64  177    2.047   -0.552   0.292
-bart.nexellent. 194.242.34.149   2 u   41   64  177   19.428   -0.173   0.256
#pob01.aplu.fr   193.204.114.232  2 u   34   64  177    1.974   -2.490   0.213
#nsa.priv.pw     85.199.214.102   2 u   29   64  177    5.035   -1.964   0.192
#enterprise.frmu 241.73.83.127    3 u   33   64  177    5.173   -0.099   0.106
-tick.ntp.infoma .GPS.            1 u   25   64  177   15.019    0.280   0.182
+sunflower.spide 145.238.203.14   2 u   28   64  177    2.087   -0.193   0.200
-ip139.ip-5-196- 145.238.203.14   2 u   34   64  177    1.841    0.178   0.176
+cluster009.lino 193.190.230.66   2 u   24   64  177    1.967    0.308   0.187
#skarabrae.draxi 131.188.3.222    2 u   32   64  177   17.052   -2.525   0.231
-2001:41d0:b:816 124.216.164.14   2 u   32   64  177   10.852   -0.471   0.171
+2001:41d0:1:8da 193.190.230.66   2 u   29   64  177    2.073   -0.147   0.147
x78.192.0.158 (c .DCFa.           1 u   30   64  177    5.231   20.499   0.273
#eva.aplu.fr     37.187.106.108   3 u   27   64  177   15.125    0.178   0.114
#lotor.mcl.gg    237.17.204.95    2 u   30   64  177   20.259   -4.050   0.217
</code>
=====passwd=====

(ou ''yppasswd'') permet de changer le mot de passe du login courant. Il faut connaitre l'ancien mot de passe pour en définir un nouveau.

Le root peut changer le mot de passe de n'importe quel utilisateur :
  passwd user


=====paste=====

Coller séquentiellement les lignes correspondantes de chaque fichier fourni en paramètre, séparé par des tabulations, vers la sortie standard.
<code>paste toto titi</code>

=====ping=====

Permet d'envoyer une requête ''ICMP echo-request'' vers la machine spécifiée en argument, afin de vérifier la connectivité.
Le ping permet également de connaître le RTT (délais aller-retour du paquet). Sous Linux la commande se répète à l'infini (par défaut), il faut sortir avec un ''^C'' (''ctrl+c'').

  ping google.com
   PING google.com (74.125.127.100) 56(84) bytes of data.
   64 bytes from pz-in-f100.google.com (74.125.127.100): icmp_seq=1 ttl=44 time=177 ms
   64 bytes from pz-in-f100.google.com (74.125.127.100): icmp_seq=2 ttl=44 time=176 ms
   64 bytes from pz-in-f100.google.com (74.125.127.100): icmp_seq=3 ttl=44 time=174 ms
   ^C
   --- google.com ping statistics ---
   3 packets transmitted, 3 received, 0% packet loss, time 2010ms
   rtt min/avg/max/mdev = 174.353/176.162/177.575/1.429 ms

====Options avancées====

  * ''ping -c 5'' (**c**ount) : permet de limiter le nombre de ping envoyé(s) (ici 5)
  * ''ping -i 2'' (**i**nterval) : pour spécifier l'intervalle de temps (en seconde) entre 2 pings successifs. Par défaut c'est 1 seconde ; seul le root peut descendre en dessous de 200ms (0.2), pour éviter le flood. 
  * ''ping -I eth1'' (**I**nterface) : permet de spécifier l'interface de sortie du ping (ici l'interface eth1, mais on peut aussi préciser une adresse IP source de la machine, la table de routage fera le reste)
  * ''ping -M do -s 1472'' : l'option ''-M'' permet de préciser la stratégie de découverte de la MTU ; **do** pour empêcher la fragmentation du paquet (bit DF=1), **want** pour activer la MTU-path-discovery et **dont** pour ne pas spécifier le flag DF (=0). Cette commande permet donc de vérifier la taille de la MTU entre la source et la destination du PING.
  * ''ping -n'' (**n**umeric) = pas de résolution de nom dans les résultats de la commande (plus rapide)
  * ''ping -q'' (**q**uiet) : seul la ligne de résumé est affichée, pas les pings successifs
  * ''ping -s 1472'' (packet**s**ize) : permet de spécifier la taille du payload (en octet) du paquet (auquel il faut ajouter 8 octets d'entête ICMP, 20 d'entête IP et 18 d'entête Ethernet. 1472 + 8 + 20 + 18 = 1518, la taille maximum d'un segment TCP). Cela sert souvent à tester la fragmentation des paquets.
  * ''ping -t 1'' (**t**tl) permet de spécifier le TTL (Time To Live) des paquets envoyés. Un TTL=1 comme ici permet de s'arrêter au premier hop (=routeur) (on rester dans le réseau commuté)
  * ''ping -v'' (**v**erbose) ping verbeux
  * ''ping -w 2 -c 3'' (deadline)) détermine le temps au bout duquel la commande ping rend la main, indifféremment du nombre de pings envoyés. dans cet exemple la commande va rendre la main au bout de 2 secondes, sans avoir envoyer les 3 pings demandés.
  * ''ping -W'' (timeout) : permet de spécifier, en seconde, le temps d'attente maximum d'une réponse à un ping (si la machine d'en face met trop de temps à répondre). Par défaut, il vaut 2 RTTs.

====fping====

[[https://fping.org|fping]] est une alternative à ping, ayant comme différence de pouvoir spécifier de multiples destinations à PINGer.
<code bash>
# va PINGer 5 fois (-c5) le réseau 10.1.2.200/29 (-g), soit de l'adresse 10.1.2.201 à 10.1.2.206,
# va faire une résolution DNS inversée des IPs (-n) et n'afficher que le résumé des 5 PINGs/adresse (-q).
fping -c5 -g 10.1.2.200/29 -nq
test201.local       : xmt/rcv/%loss = 1/1/0%, min/avg/max = 0.04/0.04/0.04
test202.local       : xmt/rcv/%loss = 1/1/0%, min/avg/max = 0.23/0.23/0.23
test203.local       : xmt/rcv/%loss = 1/0/100%
test204.local       : xmt/rcv/%loss = 1/0/100%
test205.local       : xmt/rcv/%loss = 1/1/0%, min/avg/max = 0.31/0.31/0.31
test206.local       : xmt/rcv/%loss = 1/0/100%

# ici les IPs .203, .204 et .206 ne répondent pas
</code>
=====pmap=====

Affiche la consommation mémoire et les fichiers ouverts par le processus de PID 30213 :
<code>pmap -d 30213
30213:   bash
Address   Kbytes Mode  Offset           Device    Mapping
08048000     664 r-x-- 0000000000000000 009:00000 bash
080ee000      20 rw--- 00000000000a6000 009:00000 bash
080f3000      20 rw--- 00000000080f3000 000:00000   [ anon ]
08177000    1096 rw--- 0000000008177000 000:00000   [ anon ]
b7c4d000      28 r--s- 0000000000000000 009:00000 gconv-modules.cache
b7c54000      40 r-x-- 0000000000000000 009:00000 libnss_files-2.7.so
b7c5e000       8 rw--- 0000000000009000 009:00000 libnss_files-2.7.so
b7c60000      36 r-x-- 0000000000000000 009:00000 libnss_nis-2.7.so
b7c69000       8 rw--- 0000000000008000 009:00000 libnss_nis-2.7.so
b7c6b000      84 r-x-- 0000000000000000 009:00000 libnsl-2.7.so
b7c80000       8 rw--- 0000000000014000 009:00000 libnsl-2.7.so
b7c82000       8 rw--- 00000000b7c82000 000:00000   [ anon ]
b7c84000      28 r-x-- 0000000000000000 009:00000 libnss_compat-2.7.so
b7c8b000       8 rw--- 0000000000006000 009:00000 libnss_compat-2.7.so
b7c8d000    1256 r---- 0000000000000000 009:00000 locale-archive
b7dc7000       4 rw--- 00000000b7dc7000 000:00000   [ anon ]
b7dc8000    1364 r-x-- 0000000000000000 009:00000 libc-2.7.so
b7f1d000       4 r---- 0000000000155000 009:00000 libc-2.7.so
b7f1e000       8 rw--- 0000000000156000 009:00000 libc-2.7.so
b7f20000      16 rw--- 00000000b7f20000 000:00000   [ anon ]
b7f24000       8 r-x-- 0000000000000000 009:00000 libdl-2.7.so
b7f26000       8 rw--- 0000000000001000 009:00000 libdl-2.7.so
b7f28000     188 r-x-- 0000000000000000 009:00000 libncurses.so.5.7
b7f57000      12 rw--- 000000000002f000 009:00000 libncurses.so.5.7
b7f5e000       8 rw--- 00000000b7f5e000 000:00000   [ anon ]
b7f60000       4 r-x-- 00000000b7f60000 000:00000   [ anon ]
b7f61000     104 r-x-- 0000000000000000 009:00000 ld-2.7.so
b7f7b000       8 rw--- 000000000001a000 009:00000 ld-2.7.so
bf968000      84 rw--- 00000000bffeb000 000:00000   [ stack ]
mapped: 5132K    writeable/private: 1324K    shared: 28K
</code>

=====pr=====

**pr** permet de mettre en forme des fichiers texte pour l'impression.

Paramètres principaux :
  * ''<nowiki>--</nowiki>columns=<NB>'' : définir le nombre de colonne en sortie
  * ''-h <TITRE>'' : affiche un titre en tête de page, à la place du nom de fichier
  * ''-l <NB_LIGNE>'' : définit le nombre de lignes de la page (par défaut 66)
  * ''-n'' : affiche les numéros de ligne
  * ''-w <NB_CAR>'' : définit le nombre de caractère de chaque ligne (par défaut 72)

Exemple :
<code bash>
ls | pr -n
</code>

=====printf=====

Comme [[informatique:linux:commandes_linux#echo|echo]], **printf** permet d'afficher du texte mais de façon plus léchée. Le premier argument défini le formatage de l'affichage, puis on fournit les variables dans les arguments suivants.
<code bash>
a=12; b=34; c='toto'
printf 'a=%i, b=%i, c=%s\n' $a $b $c
a=12, b=34, c=toto
</code>
''%i'' désigne les variables entière (integer), pour les variables chaîne (strings).

Pour formater l'affichage, on peut délimiter le nombre de colonne que prend chaque variable en suivant le "'%' par le nombre de colonne souhaité (et un ''-'' pour aligner à droite) :
<code bash>
a=12; b=34; c='toto'
# on aligne $a et $b à droite sur 5 colonnes, et $c à gauche sur 20 colonnes
printf 'a=%5i, b=%5i, c=%-20s\n' $a $b $c
a=   12, b=   34, c=toto
</code>

====Afficher x fois le même caractère====

Pour afficher 10 fois le caractère "=" :
<code bash>
printf '%.0s=' {1..10}
==========
</code>

=====ps=====

Affiche la liste des processus :
  * ''ps aux'' : afficher tous les processus
  * ''ps -ef'' : à peu près pareil
  * ''ps U <user>'' afficher tous les processus lancés par <user>

Les options annexes :
  * ''-w'' permet un affichage long (**w**ide) afin que l'affichage des noms des processus ne soient pas coupés
  * ''-C <nom du processus>'' pour n'afficher que les lignes qui match ledit processus
  * ''-l'' affichage en long format

Pour afficher des champs personnalisés, on utilise le paramètre ''o'' puis on liste les colonnes à afficher ; on peut définir leur taille en les suffixant par '':<taille>'' :
<code bash>
ps -o "%p %r %y %x %n %c %a"                                                                                       
  PID  PGID TTY          TIME  NI COMMAND         COMMAND
20406 20406 pts/13   00:00:00  19 burn.sh         /bin/sh ./burn.sh 2 1000000

ps axo ruser:8,euser:8,pid,comm,%cpu,%mem,state,tty,nice
RUSER        EUSER          PID COMMAND         %CPU %MEM S TT        NI
root         root             1 systemd          0.0  0.0 S ?          0
</code>

Afficher les processus les plus consommateurs de mémoire/de CPU :
<code bash>
ps -eo pmem,pcpu,pid,args --sort=-rss   | head
ps -eo pmem,pcpu,pid,args --sort=-stime | head
</code>

=====pstree=====

**pstree** permet d'afficher l'arborescence, à la façon de tree pour les répertoires, des processus en cours d'exécution.

=====pushd/popd/dirs=====

**pushd**, **popd** et **dirs** sont des commandes spécifiques à bash ; elles permettent de contrôler une pile de noms de répertoires successifs, afin d'y revenir plus facilement (fonctionnement LIFO, Last In First Out) :
  * ''pushd <REPERTOIRE>'' permet de se rendre dans REPERTOIRE et de l'empiler
  * ''popd'' permet de revenir au dernier répertoire enregistré par pushd ; puis le dépile.
  * ''dirs'' permet de lister le contenu de la pile de répertoires

Exemple d'utilisation :
<code bash>
# état initial : on est dans notre home
# et la pile est vide (elle ne contient que le répertoire courant)
$ pwd
/home/toto
$ dirs
~

# on change de répertoire (et on l'empile)
$ pushd /tmp
/tmp ~

# on change encore de répertoire (et on l'empile à nouveau)
$ pushd /var/log
/var/log /tmp ~

# on retourne dans le précédent répertoire, et on le dépile
$ popd
/tmp ~

# on retourne à la case départ
$ popd
~
</code>
=====pwck=====

**pwck** vérifie l´intégrité des fichiers de mots de passe. Il vaut mieux le lancer en root car il doit accéder notamment à ''/etc/passwd'' et ''/etc/shadow''.

=====readarray=====

Créer un tableau à partir d'un flux ou d'un fichier, d'une case par ligne.
<code bash>
readarray -t T_LINES < fichier.txt

cat fichier.txt | readarray -t T_LINES
</code>


=====readlink=====

Affiche la valeur d'un lien symbolique ou le nom canonique d'un fichier (c'est-à-dire son chemin absolu + son nom de fichier).
<code bash>
readlink -f toto.sh
/tmp/toto.sh
</code>

C'est l'équivalent (en plus compatible) de la commande bash ''realpath''.

Dans un script, pour n'afficher que son chemin absolu, utiliser ''dirname $(readlink -f $0)'' (ou, en bash, ''dirname $(realpath $0)'' )

=====reset=====

Permet de réinitialiser le terminal, notamment quand on affiche un binaire qui provoque des affichages bizarres.


=====rev=====

Permet d'inverser l'ordre des caractères des lignes d'un fichier ou d'un flux.
  echo 'tito' | rev
   otit


=====route=====

Permet de contrôler la table de routage de la machine.

  * Pour voir la table de routage actuelle :
<code bash>
route -n
</code>
... qui équivaut à ''netstat -rn'', commande plus universelle.

  * Ajouter l'adresse de la passerelle (gw ou gateway cela dépend)
<code bash>
route add default gw 192.168.0.1
</code>

  * Ajouter un host :
<code bash>
route add -host 195.98.246.28 gateway 192.168.0.1
</code>

  * Ajouter un réseau :
<code bash>
route add -net 195.98.246.0 netmask 255.255.0.0 gateway 192.168.0.1
route add -net 192.168.100.0/24 gw 192.168.0.253
</code>

  * Pour supprimer une route :
<code bash>
route del default
route del -net 192.56.76.0 netmask 255.255.255.0 dev eth0
route del -net 192.168.100.0/24 -gw 192.168.0.253
</code>

  * Pour ajouter un DNS, il faut agir sur le fichier ''/etc/resolv.conf'' :
<code bash>
echo "nameserver 193.252.19.3" >> /etc/resolv.conf
</code>

Pour ajouter des routes persistantes, cela dépend de la distribution Linux utilisée. Par exemple pour créer une route pour le réseau 10.0.211.0/24 en passant par le next-hop 10.0.32.2, accessible via l'interface réseau eth0 :
  * __sous Redhat/centOS__ il faut créer ou éditer le fichier :
<code bash /etc/sysconfig/network-scripts/route-eth0>
10.0.211.0/24 via 10.0.32.2
</code>
  * sous Debian, il faut ajouter une ligne dans le fichier :
<code bash /etc/network/interfaces>
up route add -net 10.0.211.0/24 gw 10.0.32.2 dev eth0
</code>


=====runlevel=====

Commande qui affiche le runlevel courant et précédent. S'il n'y a pas de précédent, affiche "N".
<code bash>
runlevel
 N 3
</code>

.. à peu près similaire à la commande ''who -r''.


=====scp=====

**Ssh CoPy** (SCP) est une commande qui permet de transférer des fichiers par une connexion SSH.

Sous Windows il existe les programmes ''pscp'' (en ligne de commande) et l'excellent [[http://fr.wikipedia.org/wiki/WinSCP|WinSCP]]. Sous Linux, il est possible d'utiliser [[http://fr.wikipedia.org/wiki/GFTP|gFTP]] si l'on veut un interface graphique. Sous Mac j'utilise [[http://rsug.itd.umich.edu/software/fugu/|Fugu]].

La syntaxe en CLI est la suivante :
<code bash>
scp fichier_local user@serveur.com:/path
</code>
Il faut noter qu'un //path// relatif (sans le "/") est par défaut la home de l'utilisateur sous lequel on s'est connecté.

Exemples
<code bash>
# uploader le fichier local test.txt vers la home de l'utilisateur toto sur serveur.com :
scp test.txt toto@serveur.com:

# télécharger dans le répertoire courant (.) test.txt, qui se trouve sur serveur.com
scp toto@serveur.com:test.txt .

# uploader tout le dossier test vers le sous répertoire incoming :
scp -r test toto@serveur.com:incoming

# 3 façon d'uploader 2 fichiers vers un serveur
scp 1.zip 2.zip serveur.com:
scp {1,2}.zip serveur.com:
scp *.zip serveur.com:

# télécharger plusieurs fichiers en une même commande SCP (ici 1.zip et 2.zip)
scp serveur.com:/tmp/\{1,2\}.zip .

# copier un fichier entre 2 serveurs distants (remote to remote)
scp toto@serveur1.com:test.txt titi@serveur2.com:
</code>

Les paramètres possibles sont :
  * ''-P port'' pour préciser un port spécifique
  * ''-r'' pour les transfert récursifs (copier le contenu d'un dossier par exemple)
  * ''-o ssh_option'' : permet de passer des options SSH pour le transfert (ce sont les même que la commande ssh)

=====script=====

**script** permet d'enregistrer dans un fichier tout ce qui s'affiche sur un terminal. Par défaut il lance le shell indiqué dans la variable d'environnement $SHELL, et enregistre dans le fichier ./typescript. On quitte donc script quand on quitte le shell (''exit'' ou ''Ctrl+D'').

On peut spécifier les paramètres suivants :
<code bash>
-a (append) : ajouter les données à la fin du fichier (sans l'écraser)
-c <COMMAND> : précise la commande à lancer à la place de $SHELL. Cela peut servir à lancer
    un autre terminal que celui par défaut, ou une session SSH par exemple.
-f (fifo) permet d'écrire en temps réel la sortie du terminal dans le fichier. On peut ainsi
    récupérer la session en temps réel avec un ''tail -f <fichier_de_log>''
-q (quiet) : mode moins verbeux
-t : ajout des informations de timestamp sur la sortie d'erreur standard
</code>
=====sed=====

**S**tream **ED**itor est une commande qui permet d'appliquer différentes transformations prédéfinies à un flux séquentiel de données textuelles. Sed peut travailler sur un flux (pipé derrière une autre commande) ou à partir d'un fichier :
<code bash>
# afficher le contenu du fichier en remplaçant toto par titi
cat fichier.txt | sed 's/toto/titi'

# même chose en plus simple
sed 's/toto/titi' fichier.txt
</code>

Par défaut le résultat est affiché dans le terminal ; si on précise un fichier on peut choisir d'enregistrer les modifications dans celui-ci, en ajoutant l'option ''-i'' :
<code bash>
# remplacer toto par titi dans le fichier (sans afficher le résultat)
sed -i 's/toto/titi' fichier.txt
# idem, mais en sauvegardant le fichier original avec l'extension .bck
# cela créra 2 fichiers : fichier.txt (modifié) et fichier.txt.bck (l'original)
sed -i".bck" 's/toto/titi' fichier.txt
</code>

<WRAP center round important 60%>
Les caractères suivants doivent être échappés (préfixés par un ''\'') car ils ont une signification spéciales : ''$.*[\^'' sauf s'il sont entre [...] ; en revanche les autres (lettres, chiffres et ''(){}+?|'') ne doivent pas être échappés pour représenter le caractère.
</WRAP>

  * Afficher la 3ème ligne d'un fichier (plusieurs méthodes) :
Afficher la 3ème ligne d'un fichier :
<code bash>
sed -n '3p' <fichier>
sed '3!d'   <fichier>
sed '52q;d' <fichier>   # arrête la lecture dès qu'elle a matché, pour la performance
</code>

  * Afficher un fichier à partir de la 3ème ligne :
<code bash>
sed -n '3,$p' <fichier>
</code>

  * Afficher les lignes de 2 à 5 d'un fichier ; alternative : afficher les lignes de 2 jusqu'à ce qu'une expression régulière matche (dans cet exemple : /sys/)
<code bash>
sed -n '2,5p' <fichier>
sed -n '2,/sys/p' <fichier>
</code>

  * Ajouter une ligne en début de fichier :
<code bash>
sed -i '1iPremièreLigne' toto.txt
</code>
(il s'agit d'un "un" i suivi du texte à insérer)

  * Afficher les lignes sauf celles situées entre "toto" et "titi" :
<code bash>
sed '/toto/,/titi/d'
</code>

  * Supprimer la 5eme ligne du fichier toto.txt
<code bash>
sed -i '5d' toto.txt
</code>

  * Supprimer les lignes contenant toto dans le fichier toto.txt :
<code bash>sed -i '/toto/d' toto.txt</code>

  * Supprimer les lignes __ne contenant pas__ toto dans le fichier toto.txt :
<code bash>sed -i '/toto/!d' toto.txt</code>

  * Supprimer les lignes vides
<code bash>sed '/^$/d' toto.txt</code>

  * supprimer (''d'') les première lignes du début d'un fichier (''0,'') jusqu'à un motif (''^begin'' dans cet exemple), et supprimer les dernières lignes depuis un motif (''/^end/'') jusqu'à la fin du fichier ('',$'') :
<code bash>
sed -e '0,/^begin/d' -e '/^end/,$d' fichier.txt
</code>

  * Remplacer les adresses IP par X.X.X.X
<code bash>
sed "s/\([0-9]\{1,3\}\.\)\{3\}[0-9]\{1,3\}/X.X.X.X/g"
</code>

  * Convertir les minuscules en majuscules (ou inversement)
<code bash>
echo "La PhraSe avec Des LeTTres n'iMpoRte comMEnt" | sed 's/.*/\L&/'
la phrase avec des lettres n'importe comment
# et respectivement 's/.*/\U&/' pour convertir le texte en majuscules
</code>
(Le "&" représente le motif qui matche)

  * On peut réutiliser des patterns entre () qui ont matchées avec \1, \2. Par exemple, pour inverser les 3 termes séparés par des virgules :
<code bash>echo "tata,toto,tutu" | sed 's/\(.*\),\(.*\),\(.*\)/\3,\2,\1/'
   tutu,toto,tata</code>
\1 représente la première pattern entre parenthèses, \2 la seconde et \3 la troisième.

  * Substitution multi-lignes : avec les buffers de sed on peut faire des substitutions de chaines même si elles sont réparties sur plusieurs lignes ; par exemple on veut remplacer la chaine "je pense" par "nous pensons", même si le "je" et le "pense" sont séparés par plus d'un espace ou par un saut de ligne.
<code bash>
cat fichier.txt
je pense qu'il bluff
je    pense
je
pense

sed -e '
N
s/je\([ \n]\{1,\}\)pense/nous\1pensons/g
P
D' fichier.txt
nous pensons qu'il bluff
nous    pensons
nous
pensons
</code>
Ici : N indique à sed de lire la ligne d'après, P affiche le résultat, et D supprime la 2nde ligne puisqu'elle a déjà été traitée. On notera qu'on va à la ligne pour chaque commande ; on aurait pu aussi les séparer par un ";" : ''sed -e 'N;s/je\([ \n]\{1,\}\)pense/nous\1pensons/g;P;D' fichier/txt'', mais on perd un peu en lisibilité.

  * Substituer les fins de lignes par un espace
<code bash>
sed '
:s		# étiquette
N		# on ajoute la ligne suivante
s/\n/ /		# on substitue les fins de lignes par un espace
b s		# on se branche à l'étiquette
' fichier.txt
</code>

  * Utiliser les variables du shell : sed peut utiliser le contenu de variables du shell dans ses comparaisons ; pour cela on doit les entourer de double quotes et les sortir du simple quote de l'expression régulière du sed. Voyez plutôt : je veux remplacer le texte "titi" par le contenu de ma variable VAR déclarée au préalable :
<code bash>
VAR=test
echo -e "toto\ntiti" | sed s/titi/"$VAR"/
toto
test
</code>

# Dans certains cas, on est obligé de conserver les quotes qui entourent l'expression sed ; dans ce cas on procèdera de la sorte :
<code bash>
echo -e "toto\ntiti" | sed 's/titi/'"$VAR"'/'
</code>

====Insérer de la couleur====
Pour mettre de la couleur dans le résultat de la recherche, on utilise le caractère d'échappement ''\x1b'' :
<code bash>
echo "toto titi tata" | sed -e 's/titi/\x1b[0;30;47m&\x1b[0m/'
# va surligner titi en gris.
</code>

====Supprimer le formatage====
L'effet inverse du précédente filtre : permet de supprimer le formatage (l'emphase, la couleur du texte ou du background) :
<code bash>
ls --color=y | sed 's/\x1b\[[0-9;]*m//g'
</code>

====Supprimer les lignes paires====

<code bash>
sed '2~2d' file.txt
</code>
(en commençant à la ligne 2, puis toutes les 2 lignes (''2~2''), on supprime la ligne (''d''))

Équivalent : en partant de la première ligne, puis toutes les 2 lignes (''1~2''), on n'affiche pas la ligne (''!p'')
<code bash>
sed -n '1~2!p' file.txt
</code>

Autres équivalents :
<code bash>
sed -n '2~2p' file.txt
sed -n 'p;n'  file.txt
</code>

====Liens utiles====

  * [[http://www.commentcamarche.net/faq/9559-sed-introduction-a-sed-part-ii|Sed - Introduction à SED]] sur ccc
  * [[https://openclassrooms.com/courses/la-commande-sed|la commande sed]] sur openclassrooms
  * [[http://sed.sourceforge.net/sed1line_fr.html|Script d'une ligne utiles pour sed]]
=====seq=====

Affiche une séquence de nombres ; syntaxe = ''seq [OPTION]... FIRST INCREMENT LAST''

Options :
  * ''-f, --format=FORMAT'' use printf style floating-point FORMAT
  * ''-s, --separator=STRING'', --separator=STRING ; use STRING to separate numbers (default: \n)
  * ''-w, --equal-width'' equalize width by padding with leading zeroes

  seq 3
   1
   2
   3

  seq -s" " -2 0.5 -1
   -2,0 -1,5 -1,0


=====set=====

''set -o vi'' permet de pouvoir utiliser les commandes vi dans le shell.

Dans un script bash, ''set <nowiki>--</nowiki> $VAR'' découpe le contenu de la variable $VAR en série d'argument $1, $2, etc... ; comme pour une ligne de commande.
<code bash>
VAR="un deux trois"
set -- $VAR
echo "$3 $2 $1"
 trois deux un
</code>
=====shuf=====

**shuf** (et non pas snuff) permet d'afficher une permutation aléatoire des lignes de son flux d'entrée (pas nécessairement des nombres).

Paramètres :
  * ''-n X'' : permet de n'afficher que les X premières lignes du tirage
  * ''-i X-Y'' : permet de spécifier un intervalle de nombres qui seront permutés (X la borne inférieure et Y la borne supérieure)
  * ''-e'' : permet de traiter chaque paramètre comme un flux d'entrée

Exemple :

  * faire un tirage de 1-2-3 (les 2 lignes sont équivalentes) :
<code>echo -e "1\n2\n3" | shuf</code>
<code>shuf -e 1 2 3</code>
<code>shuf -i 1-3</code>

  * simuler un tirage de l'euro-million :
<code>echo $(shuf -i 1-49 -n 5) - $(shuf -i 1-10 -n 1)</code>

=====shutdown=====

Permet d'éteindre le système à un instant donné, à condition d'être root.
  * ''# shutdown -r now'' permet de redémarrer (**r**eboot) le système (alias : ''reboot'')
  * ''# shutdown -h now'' permet d'arreter (**h**alt) le sytème (alias : ''halt'')

Pour commander un reboot ou un arrêt dans 12 minutes :
  shutdown -h +12

ou à heure fixe :
  shutdown -h 01:00

Pour annuler (**c**ancel) la planification d'une commande :
  shutdown -c

Pour redémarrer et forcer un fsck lors du démarrage :
  shutdown -r -F now

=====sort=====

**sort** permet de classer par ordre alphabétique les lignes d'un fichier texte. Si aucun fichier n'est spécifié, sort lit l'entrée standard.

<code bash>
sort fichier.txt
 abc
 def
 ghi
</code>

Ceci pose un problème lorsqu'on veut classer des nombres :
<code bash>
echo -e "11\n3" | sort
 11
 3
</code>

On aurait voulu qu'il les classe dans l'ordre croissant et non alphabétique. Pour trier les nombres, on utilise le paramètre ''-n'' qui précise qu'on veut un tri numérique :
<code bash>
echo -e "11\n3" | sort -n
 3
 11
</code>

Paramètres utiles :
  * ''-n'' (numeric) : pour trier des nombre dans l'ordre croissant
  * ''-r'' (reverse) : pour inverser le tri
  * ''-u'' (uniq) : pour supprimer les doublons
  * ''-i'' (ignore nonprinting) : ne tient pas compte des espaces, tabulations, ...
  * ''-f'' (ignore case) : ne tient pas compte de la casse (majuscules/minuscules)
  * ''-k n'' trier selon la n-ième colonne. On peut faire suivre par d'autre paramètres (ex : ''-k2r'' pour trier selon la 2nde colonne en mode renverse)
  * ''-t'' précise le séparateur de colonne (par défaut un espace blanc)
  * ''-V'' tri par numéro de version ; peut servir d'alternative à -n
  * ''-o <OUTPUT_FILE>'' copie le résultat dans un fichier plutôt que sur la sortie standard

Exemple :

  * Trier des adresses IP (le ''-n'' ne suffit pas car il ne tient compte que du premier nombre de chaque ligne) :
<code bash>
sort -n -t . -k 1,1 -k 2,2 -k 3,3 -k 4,4 adresses.txt
</code>

  * trier selon la 2nde colonne
<code bash>
echo -e "toto aa\ntota bb\ntiti cc\n" | sort -k2
 toto aa
 tota bb
 titi cc
</code>

=====split=====

**split** permet de séparer un fichier en plusieurs plus petits (par exemple ici en fichiers de 10 Mo):

<code bash>
split -b 10m toto
</code>

Les fichiers ainsi créés seront nommés xaa, xab, xac et ainsi de suite autant que nécessaire.

Pour les rassembler il suffit d'utiliser cat :
<code bash>
cat xaa xab xac xad xae > 50meg
</code>

=====ss=====

**ss** est un outil pour afficher les statistiques des sockets (connexions réseau) qui ressemble pas mal à [[informatique:linux:commandes_linux#netstat|netstat]].

<code bash>
ss -s
Total: 157 (kernel 750)
TCP:   97 (estab 50, closed 29, orphaned 1, synrecv 0, timewait 28/0), ports 3328

Transport Total     IP        IPv6
*         750       -         -
RAW       0         0         0
UDP       6         4         2
TCP       68        63        5
INET      74        67        7
FRAG      0         0         0
</code>

Options :
  * ''-n'' ne résout pas les numéros de port
  * ''-l'' affiche tous les ports en écoute
  * ''-o state FILTER'' filtrer sur l'état de la connexion TCP ; avec filter parmis : established, syn-sent, syn-recv, fin-wait-1, fin-wait-2, time-wait, closed, close-wait, last-ack, listen, closing, all, connected, synchronized, bucket, et big

Exemples :
<code bash>
# afficher toutes les connexions HTTP ouvertes
ss -o state established '( dport = :http or sport = :http )'

# afficher toutes les connexions HTTP établies avec l'IP destination 10.0.0.1
ss dst 10.0.0.1:80

# afficher les connexions dont le port destination est supérieur à 1024
ss dport \> 1024
</code>
=====stat=====

Commande permettant d'afficher des informations sur un système de fichier ou juste un fichier.

<code bash>
# Affichage des informations du fichier toto.txt
$ stat toto.txt
  Fichier : « toto.txt »
   Taille : 0           Blocs : 0          Blocs d'E/S : 1048576 fichier vide
Périphérique : 37h/55d  Inœud : 36311392    Liens : 1
Accès : (0644/-rw-r--r--)  UID : (1515/dude)   GID : ( 1515/     dsi)
 Accès : 2018-08-30 17:16:35.295782414 +0200
Modif. : 2018-08-30 18:15:02.295782414 +0200
Changt : 2018-08-30 17:16:35.295782414 +0200
  Créé : -
</code>

On peut filtrer le résultat par type d'information recherchée avec l'option ''-c'' ; par exemple :
<code bash>
#  N'afficher que la date de dernière modification du fichier (au format //human-readable//) : ''%y''
$ stat -c "%y" toto.txt
2018-08-30 18:15:02.295782414 +0200

# Afficher la taille du fichier (ici il est vide)
$ stat -c "%s" toto.txt
0
</code>

=====strings=====

Affiche les chaines de caractères imprimable dans le fichier spécifié (c'est donc peu utile sur les fichiers texte).
<code bash>
strings toto.exe
</code>

=====su=====

Permet de lancer un shell sous un autre nom d'utilisateur. Par défaut (si on ne fourni pas de paramètre) il s'agit de root.

  su toto
pour devenir toto (cela prompt le mot de passe root)

  su
pour devenir root.

  su -
pour devenir root avec avec la séquence de login complete (héritage des chemins vers les commandes, l'environement de l'utilisateur...)

  su -c 'find / -name *.c'
permet d'executer la une seule fois en root (su -c 'command' <nom d'utilisateur> pour l'exécuter une fois sous un utilisateur particulier).

  su laurent
pour devenir l'utilisateur laurent

=====tac=====

Comme [[informatique:linux:commandes_linux|cat]], mais à l'envers :) **tac** affiche le fichier de la dernière à la première ligne.
=====tail=====

Affiche les 10 dernières lignes d'un fichier ou d"un flux en entrée :
<code bash>
tail ~/.bash_history
 su
 vim /mnt/dude_e/save/defs.txt
 su
 vim buf_stag.txt
 pwd
 cd
 /usr/pkg/bin/lpr -P Black sncf-confirmation
 man cvs
 w
 man calc
</code>

Options :
  * ''-n <nb>'' : affiche les <nb> dernières lignes (au lieu des 10 par défaut) : ''tail -n2 toto.txt'' (d'ailleurs le "n" est facultatif, ''tail -2 toto.txt'' fonctionne aussi bien)
  * ''-n +<nb>'' affiche toutes les lignes après la <nb>-ième : ''tail -n +2 toto.txt'' affichera toutes les lignes à partir de la 2ème.
  * ''-f'' : la commande ''tail'' ne se termine jamais et affiche à l'écran toute ligne ajoutée au fichier en paramètre (par exemple ''tail -f /var/log/auth.log'' permet de suivre en temps réel les logs d'authentification de la machine)


=====tar=====

Un outil d'archivage de données qui permet de créer une archive à partir de fichiers/arborescence. On peut utiliser le flag ''-v'' (verbose) pour afficher les fichiers/dossier ajoutés à l'archive.

<code bash>
# pour archiver le répertoire ./toto/ et tout son contenu (répertoires et fichiers normaux).
# (toto.tar désigne le nom de l'archive qu'on veut créer, il doit avoir l'extension ''.tar'')
tar cf toto.tar ./toto

# archiver ET compresser le fichier grâce à gunzip (-z) ou bunzip (-y) :
# -c pour compresser, -v pour un affichage verbeux, -f pour préciser le fichier de sortie
tar cvzf toto.tar.gz ./toto

# extraire (-x) le contenu d'une archive gunzip (-z) :
tar zxf toto.tar

# exclure le répertoire "dir" et le fichier titi.txt de l'archive
tar cfz toto.tar --exclude=./toto/titi.txt --exclude=./toto/dir ./toto

# équivalent en listant les fichiers à exclure dans un fichier externe
cat exclude-fic.txt
./toto/titi.txt
./toto/dir

tar cfz toto.tar --exclude-from exclude-fic.txt ./toto
</code>

=====tee=====

Permet de copier l'entrée standard dans un fichier en plus de l'afficher sur la sortie standard. L'option ''-a'' permet d'ajouter à la fin du fichier indiqué.
<code bash>
$ echo toto | tee fic.log
toto

$ echo titi | tee -a fic.log
titi

$ cat fic.log
toto
titi
</code>

=====telnet=====

Permet de se connecter à un serveur distant avec le protocole telnet.
  telnet google.fr [80]

Le port (ici 80) est facultatif (par défaut 23).

====Envoi d'un mail====

Pour envoyer un mail en SMTP via l'outil telnet :
<code bash>
# lancer l'invite telnet
$ telnet

telnet> open 10.1.1.55 25
Trying 10.1.1.55...
Connected to 10.1.1.55.
Escape character is '^]'.
220 exemple.fr ESMTP Server Ready. Tue, 9 Apr 2019 14:39:14 +0200

EHLO toto
250-exemple.fr Hello client.exemple.fr [10.1.2.201], pleased to meet you
250-ENHANCEDSTATUSCODES
250-PIPELINING
250-EXPN
250-VERB
250-8BITMIME
250-SIZE 25000000
250-DSN
250-ETRN
250-DELIVERBY
250 HELP

MAIL from:toto@exemple.fr
250 2.1.0 toto@exemple.fr... Sender ok

RCPT to:dest@domaine.fr notify=success,failure
250 2.1.5 dest@domaine.fr... Recipient ok

DATA
354 Enter mail, end with "." on a line by itself

Subject: Test de mail
Ceci est un test de msg
.
250 2.0.0 x39CdEPw012136 Message accepted for delivery

QUIT
221 2.0.0 exemple.fr closing connection
Connection closed by foreign host.
</code>

Pour fermer une connexion telnet qui ne répond plus ou dont on n'arrive plus à sortir, il faut utiliser la séquence d'échappement suivante : ''^]'' (''Ctrl + ]'').

=====time=====

Permet de calculer le temps d'exécution d'une commande :
<code bash>
time sleep 3
 real    0m3.015s
 user    0m0.000s
 sys     0m0.000s
</code>

La commande retourne le temps réel (//real//), le temps en mode utilisateur (//user//) et le temps en mode système (//sys//).

Pour mesurer le temps de plusieurs commandes pipées (chainées avec un pipe ''|''), utiliser plutôt la formulation :
<code bash>
time -f "%es" bash -c "ls | wc"
</code>


=====timeout=====

**timeout** permet de lancer une commande et de la killer si elle n'est pas terminée dans le laps de temps indiqué. Syntaxe : ''timeout <durée> <commande>'', avec durée un chiffre dont on peut préciser l'unité (**s**/seconde par défaut, ou **m**/**h**/**d** (minute/heure/jour).

<code bash>
timeout 10s ping google.fr
</code>

=====top=====

Affiche la liste des processus et permet d'observer en temps réel l'activité de la mémoire et du processeur.


=====tr=====

Translate or delete characters.

Exemples :
<code bash>
# remplacer les sauts de ligne en espaces
cat "$FIC" | tr "\n" " "

# convertir toutes les majuscules d'une chaine en minuscules :
echo "La PhraSe avec Des LeTTres n'iMpoRte comMEnt" | tr '[:upper:]' '[:lower:]'
la phrase avec des lettres n'importe comment
# qui équivaut à :
echo "La PhraSe avec Des LeTTres n'iMpoRte comMEnt" | tr A-Z a-z
</code>
=====traceroute=====

[[http://fr.wikipedia.org/wiki/Traceroute|Traceroute]] permet de déterminer la route prise par un paquet pour atteindre une adresse IP cible.
L'outil envoie un paquet à ''IP'' avec un TTL de 1. Le paquet n'ira pas plus loin que le premier routeur qui enverra un paquet ''ICMP TTL Exceeded'' avec sa propre adresse IP. En incrémentant le TTL ainsi de suite jusqu'à atteindre la destination, on obtient les IPs de tous les routeurs intermédiaires.

Certains routeurs ne communiquent pas d'information et affichent %%???%% ou %%* * *%%.
<code bash>
traceroute google.fr
traceroute: Warning: google.fr has multiple addresses; using 66.102.9.104
traceroute to google.fr (66.102.9.104), 30 hops max, 40 byte packets
 1  smc (192.168.0.254)  0.346 ms  0.315 ms  0.305 ms
 2  82.234.75.224 (82.234.74.254)  28.637 ms  28.650 ms  28.549 ms
 3  * * *
 4  * * *
 5  th1-6k-2-po20.intf.routers.proxad.net (212.27.50.158)  29.221 ms * *
 6  ldc-6k-1-v806.intf.routers.proxad.net (212.27.57.178)  29.470 ms  28.995 ms *
 7  google.freeix.net (213.228.3.136)  31.056 ms  29.233 ms  29.521 ms
 8  216.239.43.39 (216.239.43.39)  46.563 ms  46.859 ms  46.318 ms
 9  64.233.174.113 (64.233.174.113)  46.504 ms 72.14.232.233 (72.14.232.233)  46.352 ms  46.461 ms
 10  64.233.174.187 (64.233.174.187)  46.557 ms  52.380 ms 72.14.232.239 (72.14.232.239)  46.765 ms
 11  64.233.174.18 (64.233.174.18)  48.761 ms  49.411 ms  48.771 ms
 12  66.102.9.104 (66.102.9.104)  46.767 ms  46.974 ms  46.572 ms
</code>

Par défaut le protocole UDP/33434-5 est utilisé mais il peut être filtré. On peut donc demander au traceroute de changer de port (''-p 53'' par ex.), d'utiliser de l'ICMP (''-I'') ou du TCP (''-T'').

=====trap=====

**trap** permet d'exécuter une commande lorsqu'il rencontre un signal.
  * ''-l'' permet de lister les signaux et leurs numéros associés
<code bash>
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX
</code>
Le code ''0'', non listé ci-dessus, correspond à un EXIT.
  * ''-p'' permet d'afficher les commandes associées à chaque signal

Par exemple, pour afficher un message lors d'une erreur provoquant un EXIT, ainsi que la ligne qui la génère :
<code bash>
trap "echo Erreur à la ligne $LINENO" 0
</code>

C'est utile pour effacer les fichiers temporaires en cas d'erreur interrompant le script par exemple :
<code bash>
trap "rm -f $TMPFIC1 $TMPFIC2 $TMPFIC3" 0 2 15
</code>
=====type=====

**type** est une commande interne de bash qui permet de savoir à quoi correspond un "nom" si on l'utilise en tant que commande. Utilisée avec l'option ''-t'', il permet de savoir si la commande est un alias, une fonction, une commande externe (//file//) ou une fonction interne (une primitive) du shell (//builtin//). Utilisée sans option ou avec l'option ''-a'', **type** affiche le type et le contenu de la commande en paramètre.

<code bash>
type -t ls
 builtin

type -t l
 alias

type l
 l is aliased to 'ls -p --color'

type -t ssh
 file
type ssh
 ssh is hashed (/usr/bin/ssh)

type -a titreterm
 titreterm is a function
 titreterm ()
 {
    if [[ $# -eq 1 && -n $1 ]]; then
        echo -ne "\033]0;$1\007";
    fi
 }
</code>

Voir aussi : [[informatique:linux:commandes_linux#declare|declare]].

=====update-rc.d=====

Les scripts (potentiellement) lancés au démarrage sont placés par convention dans ''/etc/init.d/''. Lorsque Linux démarre en runlevel X, il lance automatiquement au démarrage les exécutables situés dans le répertoire ''/etc/rc**X**.d'', avec 0 <= X <= 6, ceux-ci étant des liens symboliques vers les scripts de ''/etc/init.d/''. Pour ajouter ou retirer un script du démarrage de la machine, il faut donc créer le script dans ''/etc/init.d/'' et placer un lien symbolique dans le répertoire associé au runlevel voulu.

Par convention ces liens symboliques sont de la forme <S|K><nombre><nom du script> : par exemple **S23ntp**.
  * **S** si on veut lancer le script ; **K** pour ne pas le lancer.
  * **<nombre>** va déterminer l'ordre de lancement (croissant) des scripts du répertoire, de 00 à 99 (00 étant lancé en premier).

Quand on veut ajouter un programme au démarrage c'est donc assez fastidieux ; heureusement il existe une commande qui le fait à votre place, c'est ''update-rc.d''.

Pour retirer le démon //cupd// de tous les runlevel (cela supprimera les liens symboliques des répertoires /etc/rcX.d) :
<code bash>
update-rc.d -f cupsys remove
 Removing any system startup links for /etc/init.d/cupsys ...
  /etc/rc1.d/K19cupsys
  /etc/rc2.d/S19cupsys
  /etc/rc3.d/S19cupsys
  /etc/rc4.d/S19cupsys
  /etc/rc5.d/S19cupsys
</code>

On voit qu'il se lançait au démarrage de la machine en runlevel 2 (démarrage normal), 3, 4 et 5, mais pas en runlevel 1 (single user).

Pour ajouter un script au démarrage de la machine :
<code bash>
update-rc.d mount_mp3 defaults
</code>
Cela va placer des liens pour les runlevel 2 à 5.

====Liens====

  * [[http://www.debian.org/doc/manuals/securing-debian-howto/ch3.fr.html#s-disableserv|Securing Debian howto : Désactivation de services démon]]

=====umount=====

Démonter une partition (cf mount).


=====uname=====

Affiche des informations sur le système.

  uname -a
   NetBSD stag-12-11 3.99.17 NetBSD 3.99.17 (GENERIC_MOD) #0: Fri Apr 21 15:32:24 CEST 2006  dude@stag-12-11:/usr/obj/sys/arch/i386/compile/GENERIC_MOD i386

ou encore
  uname -a
   Linux tiga 2.6.16-2-k7 #1 Fri Aug 18 19:48:42 UTC 2006 i686 GNU/Linux

On peut sélectionner la colonne de sortie :
  * ''-i'' nom de la plateforme matérielle (unknown)
  * ''-m'' nom de l'architecture de la machine (i686)
  * ''-n'' nom d'hôte (tiga)
  * ''-o'' nom du sytème d'exploitation (GNU/Linux)
  * ''-p'' type de processeur (unknown)
  * ''-r'' version du noyau (2.6.16-2-k7)
  * ''-s'' nom du noyau (Linux)
  * ''-v'' version du noyau (#1 Fri Aug 18 19:48:42 UTC 2006)


On peut obtenir des informations encore plus détaillées avec la commande :
  # cat /proc/version
   Linux version 2.6.26-1-686 (Debian 2.6.26-13) (waldi@debian.org) (gcc version 4.1.3 20080704 (prerelease) (Debian 4.1.2-24)) #1 SMP Sat Jan 10 18:29:31 UTC 2009

=====uniq=====

Évite la répétition de lignes adjacentes identiques ; prend en paramètre un fichier ou son entrée standart.
  * ''-u'' seules les lignes existant en un seul exemplaire sont fournies
  * ''-n'' le nombre d'occurrences de chaque ligne est affiché


=====uptime=====

Indique depuis quand le système à été mis en route.
  uptime 
   15:00:52 up 1 day,  1:35,  2 users,  load average: 0.00, 0.00, 0.00

Dans l'ordre, cela affiche :
  * l'heure
  * l'uptime (temps écoulé depuis le dernier démarrage de la machine)

  * le nombre d'utilisateur(s) loggués sur la machine
  * la charge CPU instantanée, depuis 5 minutes et depuis 15 minutes


=====useradd/userdel=====

Pour créer ou supprimer un utilisateur sur le système.

Exemple de création de l'utilisateur **toto** en précisant l'UID que l'on souhaite (''-u''), la création d'un groupe éponyme (''-U''), la création du répertoire home (''-m''), l'emplacement de sa home (''-d /home/toto''), son shell (''-s /bin/bash'').
<code bash>
useradd -u 59211 -U -m -d /home/toto -s /bin/bash toto
</code>
=====usermod=====

Pour modifier les paramètres d'un utilisateur (par exemple pour user1) : changer son groupe initial (-g), son shell par défaut (-s), et l'ajouter aux groupes secondaires supplémentaires ftpusers et smbusers (-a -G) :
<code bash>
usermod -g user1_grp -s /bin/bash -a -G ftpusers,smbusers user1
</code>

Pour supprimer tous les groupes supplémentaires d'un utilisateur :
<code bash>
usermod -G "" user1
</code>
=====vi=====

Vi (abréviation de **vi**sual) est un éditeur de texte en mode console présent par défaut sur la plupart des distributions Linux (d'où l'intérêt de la maîtriser). Il existe différentes versions plus ou moins légères (vi, vim.basic, vim.tiny, gvim, etc) ; [[informatique:logiciels:vim|plus d'info ici]].


=====vi*=====

Composés du préfixe **vi** (comme d'éditeur de texte) suivi de la commande à configurer, **vipw**, **vigr** ou **visudo** sont des "mots-valise" permettant d'éditer proprement des parties critiques d'un système Linux.
  * ''vipw'' pour éditer les utilisateurs (fichier /etc/passwd)
  * ''vigr'' pour éditer les groupes (fichier /etc/group)
  * ''visudo'' pour éditer la configuration de la commande ''sudo'' (fichier /etc/sudoers)

Leur utilisation est vivement recommandée dans la mesure où, souvent, leur action ne se limite pas à l'édition du fichier de conf mais permet également :
  * de mettre à jour d'autres fichiers liés, comme dans le cas de **vipw** ou **vigr** (pour MAJ respectivement /etc/shadow et /etc/gshadow)
  * de vérifier la syntaxe pour ne pas bloquer le système en cas d'erreur (**visudo** par exemple)

L'éditeur de texte lancé est celui renseigné dans la variable d'environnement $VISUAL, sinon celui de $EDITOR ; et seulement si aucun n'est spécifié, **vi** sera utilisé par défaut.

Au passage, pour configurer l'éditeur de texte par défaut, il existe plusieurs manières :
  * **update-alternatives --config editor** sous Debian
  * **select-editor** (utilise la variable $SELECTED_EDITOR, préemptée par $VISUAL et $EDITOR)
  * éditer le fichier ~/.bashrc pour y ajouter l'une des lignes suivantes :
<code bash>
export VISUAL=vi
export EDITOR=vi
</code>
=====vmstat=====

Affiche des statistiques sur la mémoire virtuelle.

  vmstat
   procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
   r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
   0  0    424  69556 145732  53768    0    0   157   106  163  186  1  1 98  1
bi et bo sont les IOs du système.


=====w=====

Affiche le résultat de la commande ''uptime'' ainsi que la liste des utilisateur loggués sur la machine.

<code bash>
w
 14:58:52 up 1 day,  1:33,  2 users,  load average: 0,00, 0,00, 0,00
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
dude     pts/0    stag-12-11.ipv6. 14:20    0.00s  0.13s  0.00s w
dude     pts/1    dude             Mon18    4:51   0.07s  0.07s -bash
</code>


=====wall=====

Permet d'envoyer un message aux utilisateurs du système : soit en précisant un fichier en argument, soit en éditant directement le message.

<code bash>
wall
*** test : coucou tlm ! ***
<Ctrl+D>                # pour sortir de l'édition du message
</code>
=====watch=====

''watch <commande>'' permet de relancer automatiquement <commande> toutes les 2s par défaut, en plein écran
On peut spécifier l'intervalle de temps pour relancer la commande (''-n <temps>''), et surligner les différences (''-d'').

Par exemple, pour lancer la commande ''free'' toutes les secondes et surligner les différences :
  watch -n 1 -d free


=====wc=====

Est un utilitaire qui permet d'afficher (respectivement) le nombre de lignes, mots, et caractères (en fait il s'agit du nombre d'octets) du fichier :
<code bash>
wc /etc/passwd          
 32   39 1380 /etc/passwd
</code>

On peut ne sélectionner que certaines colonnes de la sortie, en n'affichant que les **l**ignes (''-l''), les mots (''-w''), les octets (''-c'').


=====wget=====

wget est un outil permettant de récupérer des pages web en CLI.

<code bash>
wget http://www.exemple.com
</code>

Pour utiliser un proxy : ajouter les lignes suivantes au fichier ''~/.wgetrc'' :
<code bash>
use_proxy=yes
http_proxy=10.0.0.1:8080
https_proxy=10.0.0.2:8043
</code>

... ou utiliser, en CLI :
<code bash>
wget -e use_proxy=yes -e http_proxy=10.0.0.1:8080 http://www.exemple.com
wget -e use_proxy=yes -e https_proxy=10.0.0.2:8043 https://www.exemple.com
</code>
=====whatis=====

Affiche une brève description d'une commande.

  whatis cat
   cat (1)              - concatenate files and print on the standard output


=====whereis=====

Affiche le nom d'une commande, l'emplacement de celle-ci ainsi que de sa page de manuel.

  whereis cat
   cat: /bin/cat /usr/share/man/man1/cat.1.gz


=====which=====

Permet de localiser le binaire d'une commande

  which ls
   /bin/ls


=====who=====

Affiche les utilisateurs connectés à la machine, et depuis quand.
<code bash>
who
 root     pts/0        Jun  9 10:15 (10.0.0.20)
 dude     pts/1        2021-04-07 08:12 (10.0.16.1)
 toto     pts/2        2021-03-02 14:32 (10.0.0.1)

# afficher le runlevel précédent et courant (comme la commande ''runlevel'') :
who -r
 run-level 3  May 31 11:36                   last=S

# afficher uniquement l'utilisateur courant
who -m
 dude     pts/0        2021-04-07 08:12 (10.0.16.1)
</code>
=====xargs=====

Redirige son entrée sur les paramètres d'une autre fonction, donnée en paramètre :

  echo "toto" | xargs echo
enverra "toto" dans les paramètres du deuxième //echo//. Mais j'avoue, l'intérêt reste limité.

en revanche :

  ps auxw | grep serveur.php | grep -v grep | awk '{print $2}' | xargs kill -15
permet de récupérer le pid de //serveur.php// pour envoyer lui envoyer un //SIGTERM// ; car ''kill'' ne lit pas son entrée standart ; il est donc impossible de le "piper" (''|'') avec d'autres commandes.

Autre use case, en utilisant les paramètres ''-L'' pour limiter le nombre de paramètre en entrée et ''-P'' pour lancer les commandes en parallèle:
<code bash>
echo -ne '1\n2\n3\n4' > toto
cat toto | xargs -L3 -P2 echo
1 2 3
4
</code>
C'est utile pour des opérations plus CPUvore comme le calcul de hash MD5 par ex:
<code bash>
ls
tata  toto

find . -maxdepth 1 -type f -print0 | xargs -L1 -P4 -0 md5sum >> md5sums

cat md5sums
b4af4c692f2a8c7dda9abc8ee657997d  ./tata
257cde944bf50d4fe05001bc33dd0ca4  ./toto
e5084550439c3c39e1b0e53b47018058  ./md5sums
</code>
=====yum=====

<code bash>
# lister les fichiers installés par un package :
# (cette cmd est installée par le package yum-utils)
repoquery -l package

# activer tous les repos pour une recherche :
yum --enablerepo=* search pdsh

# installer un rpm local :
yum localinstall pdsh-rcmd-rsh-2.31-1.el7.x86_64.rpm pdsh-rcmd-ssh-2.31-1.el7.x86_64.rpm pdsh-2.31-1.el7.x86_64.rpm
</code>
===== Liens externes =====

  * http://www.ac-creteil.fr/reseaux/systemes/linux/debian/deb-tp-reseau.html
  * http://www.linux-france.org/prj/inetdoc/securite/