Divers/mkdocs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1er commit

Browse Source 
De la docs au format Mkdocs
This commit is contained in:
Bruno 21
2018-09-16 14:48:15 +02:00
commit e82296ba06
140 changed files with 17082 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
docs/Linux/.DS_Store vendored Normal file
View File

Binary file not shown.

8
docs/Linux/Editeurs/index.md Normal file
View File

@@ -0,0 +1,8 @@
# Editeurs
[nano](nano.md)
[vi](vi.md)

161
docs/Linux/Editeurs/nano.md Normal file
View File

@@ -0,0 +1,161 @@
# Editeurs
[ss64.com](http://ss64.com/vi.html)
### Nano ([https://www.nano-editor.org/](https://www.nano-editor.org/))
CTRL + A : Permet d'aller au début de la ligne
CTRL + E : Permet d'aller à la fin de la ligne
CTRL + Y : Permet de remonter de page en page
CTRL + V : Permet de descendre de page en page
CTRL + _ : Permet de se rendre au n° de ligne indiqué
CTRL + C : Permet de savoir à quel n° de ligne / colonne / caractère se trouve votre curseur
CTRL + W : Permet de faire une [recherche](https://korben.info/recherche-2)
CTRL + D : Permet de supprimer le caractère sous le curseur
Meta - T : Coupe le texte depuis le curseur jusqu'à la fin du fichier
CTRL + K : Permet de supprimer une ligne complète (comme la commande dd sous Vi)
CTRL + U : Coller
CTRL + O : Permet de sauvegarder votre fichier
CTRL + X : Permet de quitter nano
CTRL + G : Affiche l'aide
Meta - X : Masquer / afficher l'aide-mémoire
CTRL + P : déplace le curseur vers le haut
CTRL + N : déplace le curseur vers le bas
CTRL + F : déplace le curseur vers la droite
CTRL + B : déplace le curseur vers la gauche
CTRL + Space : se déplace d'un mot en avant
Meta - Space : se déplace d'un mot en arrière
Meta - ( : saute au début du paragraphe
Meta - ) : saute à la fin du paragraphe
Meta - \ : saute au début du fichier
Meta - / : saute à la fin du fichier
Meta - U : annuler
Meta - E : redo
Meta - A : marquer (début)
Meta - 6 (shift) : copier
Meta - flèche haut : précédent
Meta - flèche bas : suivant
CTRL + B : en arrière
CTRL + F : en avant
CTRL + J : Justifier
CTRL + T : correcteur orthographique
CTRL + _ : aller à la ligne xx
*CTRL + \ : Remplacer**
**Meta - ] : Parenthèse*
Meta sur macOS: ESC puis <touche>
#### Copier / couper / coller sous nano
Se placer devant la ligne:
CTRL + K pour couper la ligne courante
CTRL + U pour la recoller
puis
CTRL + U pour la coller ailleurs
#### Pour sélectionner plusieurs lignes:
Placer une marque:
CTRL + ^ (ou Meta - A)
et se déplacer avec les flèches pour surligner le texte.
puis
CTRL + K pour couper le bloc
Meta - ^ pour copier le bloc
puis
CTRL + U pour le coller
#### Recherche
CTRL + W <recherche>
Occurence suivante:
CTRL + W puis Retour
CTRL + C pour sortir du mode recherche

48
docs/Linux/Editeurs/vi.md Normal file
View File

@@ -0,0 +1,48 @@
# vi
https://ss64.com/vi.html
![vi modes](vimodes.png
vi est éditeur de texte disponible sur tous les linux.
Très puissant, son fonctionnement en 3 modes insertion, commande et ligne de commande est déroutante pour le débutant.
![vimodes](vimodes.png)
(c) [ss64.com](https://ss64.com/vi.html)
Au lancement, vi est en **mode commande**.
- ***:w*** sauver les changements dans le buffer
- ***ZZ*** ou ***:wp*** sauver les changements et quitter vi
- ***:q!*** quitter sans sauver
- ***:w file*** sauver dans un nouveau fichier
- ***:10,15w* file** sauver les lignes dans un nouveau fichier
- ***:10,15w* file** sauver les lignes dans un nouveau fichier
Pour passer en **mode insertion**, taper:
- i
- I
- o
- O
- a
- A
Pour repasser en **mode commande**, taper *ESC*

BIN
docs/Linux/Editeurs/vimodes.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 34 KiB

299
docs/Linux/archiver.md Normal file
View File

@@ -0,0 +1,299 @@
# Archiver et compresser
#### tar
Créer une archive tar: **tar -cvf**
```bash
root@DiskStation:~ # tar -cvf archive.tar .profile .bashrc test-dossier/
```
Afficher le contenu de l'archive sans l'extraire: **tar -tf**
```bash
root@DiskStation:~ # tar -tf archive.tar
.profile
.bashrc
test-dossier/
test-dossier/test-copy-scp.txt
```
Ajouter un fichier à l'archive: **tar -rvf**
```bash
root@DiskStation:~ # tar -rvf archive.tar .bash_history
root@DiskStation:~ # tar -tf archive.tar
.profile
.bashrc
test-dossier/
test-dossier/test-copy-scp.txt
.bash_history
```
Extraire les fichiers de l'archive: **tar -xvf**
```bash
root@DiskStation:~ # tar -xvf archive.tar
```
#### gzip
Compresser avec gzip:
```bash
root@DiskStation:~ # gzip archive.tar
root@DiskStation:~ # ls
archive.tar.gz
```
Decompresser avec gunzip:
```bash
root@DiskStation:~ # gunzip archive.tar.gz
root@DiskStation:~ # ls
archive.tar
```
Voir le contenu de l'archive avec zcat:
#### bzip2
Compresser avec bzip2:
```bash
root@DiskStation:~ # bzip2 archive.tar
root@DiskStation:~ # ls
archive.tar.bz2
```
Decompresser avec bunzip2:
```bash
root@DiskStation:~ # bunzip2 archive.tar.bz2
root@DiskStation:~ # ls archive.tar
```
#### zip
Compresser avec zip:
```bash
bruno@DS916:~ $ zip -r scripts.zip scripts/
adding: scripts/ (stored 0%)
adding: scripts/@eaDir/ (stored 0%)
adding: scripts/@eaDir/ffmpeg@SynoResource (deflated 84%)
adding: scripts/@eaDir/ffmpeg@SynoEAStream (deflated 35%)
adding: scripts/ffmpeg (deflated 64%)
adding: scripts/ffmpeg-convertMP4v3.sh (deflated 50%)
adding: scripts/running3.sh (deflated 48%)
adding: scripts/ffmpeg-convertMP4v4.sh (deflated 49%)
adding: scripts/ffmpeg-convertMP4v5.sh (deflated 56%)
```
Exclure les fichiers ressources invisibles (“*MACOSX” “.*Filename” “.ds store”):
```bash
bruno@DS916:~ $ zip -r -X scripts.zip scripts/
```
Décompresser avec zip:
```bash
bruno@DS916:~/test $ unzip scripts.zip
Archive: scripts.zip
creating: scripts/
creating: scripts/@eaDir/
inflating: scripts/@eaDir/ffmpeg@SynoResource
inflating: scripts/@eaDir/ffmpeg@SynoEAStream
inflating: scripts/ffmpeg
inflating: scripts/ffmpeg-convertMP4v3.sh
inflating: scripts/running3.sh
inflating: scripts/ffmpeg-convertMP4v4.sh
inflating: scripts/ffmpeg-convertMP4v5.sh
```
#### dmg (macOS)
Créer:
```bash
bruno@SilverBook:~$ hdiutil create -format UDZO -srcfolder hubiC/ hubic.dmg
.........
created: /Users/bruno/hubic.dmg
```
Différents formats d'image:
- UDZO – Compressed image (default)
- UDRO – Read only image
- UDBZ – Better compressed image
- UDRW – Read/Write image
- UDTO – DVD disk image
Monter:
```bash
bruno@SilverBook:~$ hdiutil attach hubic.dmg
Calcul de la somme de contrôle de Protective Master Boot Record (MBR : 0)…
Protective Master Boot Record (MBR : : vérifiée CRC32 $DC586CEA
Calcul de la somme de contrôle de GPT Header (Primary GPT Header : 1)…
GPT Header (Primary GPT Header : 1) : vérifiée CRC32 $4EE88DC7
Calcul de la somme de contrôle de GPT Partition Data (Primary GPT Table : 2)…
GPT Partition Data (Primary GPT Tabl : vérifiée CRC32 $42D33ACB
Calcul de la somme de contrôle de (Apple_Free : 3)…
(Apple_Free : 3) : vérifiée CRC32 $00000000
Calcul de la somme de contrôle de disk image (Apple_HFS : 4)…
.........................................................................................................................
disk image (Apple_HFS : 4) : vérifiée CRC32 $D4406A43
Calcul de la somme de contrôle de (Apple_Free : 5)…
(Apple_Free : 5) : vérifiée CRC32 $00000000
Calcul de la somme de contrôle de GPT Partition Data (Backup GPT Table : 6)…
GPT Partition Data (Backup GPT Table : vérifiée CRC32 $42D33ACB
Calcul de la somme de contrôle de GPT Header (Backup GPT Header : 7)…
GPT Header (Backup GPT Header : 7) : vérifiée CRC32 $16D559B6
vérifiée CRC32 $BE421D06
/dev/disk3 GUID_partition_scheme
/dev/disk3s1 Apple_HFS /Volumes/hubiC
```
Voir:
```bash
bruno@SilverBook:~$ ls -lah /Volumes/hubiC/
total 8
drwxr-xr-x 11 bruno staff 442B 12 aoû 12:05 .
drwxr-xr-x@ 6 root wheel 204B 12 aoû 12:07 ..
drwxr-xr-x 2 bruno staff 68B 6 aoû 17:39 Documents
drwxr-xr-x 3 bruno staff 102B 6 aoû 17:39 HubiC
-rw-r--r-- 1 bruno staff 669B 6 aoû 17:39 HubiC readme.txt
drwxr-xr-x 2 bruno staff 68B 6 aoû 17:39 Images
drwxr-xr-x 2 bruno staff 68B 6 aoû 17:39 Videos
drwxr-xr-x 9 bruno staff 306B 6 aoû 17:39 scripts plex 0.9xx
drwxr-xr-x 9 bruno staff 306B 6 aoû 17:39 scripts plex 1.0xx
```
Ejecter:
```bash
bruno@SilverBook:~$ hdiutil eject /Volumes/hubiC/
"disk3" unmounted.
"disk3" ejected.
```
#### Archiver et compresser en même temps (gzip)
Archiver et compresser en gzip: **tar -zcvf**
```bash
root@DiskStation:~ # tar -zcvf archive.tar.gz .bashrc .profile test-dossier/
.bashrc
.profile
test-dossier/
test-dossier/test-copy-scp.txt
root@DiskStation:~ # ls
archive.tar.gz
```
Voir le contenu de l'archive gzip: **tar -ztf**
```bash
root@DiskStation:~ # tar -ztf archive.tar.bz2
```
Décompresser: **tar -xzvf**
```bash
root@DiskStation:~ # tar -xzvf archive.tar.gz
.bashrc
.profile
test-dossier/
test-dossier/test-copy-scp.txt
root@DiskStation:~ # ls -la
drwxr-xr-x 3 root root 4096 Aug 6 07:45 .
drwx—— 8 root root 4096 Aug 6 07:18 ..
-rw-r–r– 1 root root 953 Aug 5 11:04 .bashrc
-rw-r–r– 1 root root 497 Aug 5 10:15 .profile
-rw-r–r– 1 root root 925 Aug 6 07:42 archive.tar.gz
drwxr-xr-x 2 root root 4096 Aug 6 07:04 test-dossier
# décompresser dans un dossier cible
root@DiskStation:~ # tar -xzvf archive.tar.gz -C /tmp/
```
#### Archiver et compresser en même temps (bz2)
Décompresser: **tar -xf (+ v pour mode verbose)**
```bash
root@DS916:/volume1/web/_archives# tar -xf nextcloud-11.0.2.tar.bz2
root@DS916:/volume1/web/_archives# ls -la
total 137156
d---------+ 1 root root 308 Apr 15 16:58 .
d---------+ 1 root root 306 Apr 15 16:57 ..
----------+ 1 bruno users 3045723 Oct 20 07:07 gitlist-0.5.0.tar.gz
drwxr-xr-x 1 nobody 65534 414 Feb 26 20:44 nextcloud
----------+ 1 bruno users 38598274 Apr 15 09:48 nextcloud-11.0.2.tar.bz2
```
#### Extraire un seul fichier d'une archive tar.gz
Extrait le fichier README de l'archive automysqlbackup-v3.0_rc6.tar.gz
```bash
bruno@SilverBook:~/Downloads$ tar --extract --file=automysqlbackup-v3.0_rc6.tar.gz README
```
Extrait le fichier book.enchant.html du dossier php-chunked-xhtml de l'archive php*manual*fr.tar.gz
```bash
bruno@SilverBook:~/Downloads$ tar --extract --file=php_manual_fr.tar.gz php-chunked-xhtml/book.enchant.html
```
Extraire plusieurs fichiers d'archive:
```bash
bruno@SilverBook:~/Downloads$ tar xvf php_manual_fr.tar.gz php-chunked-xhtml/book.enchant.html php-chunked-xhtml/function.mysql-connect.html
```
#### Extraire un seul fichier d'une archive zip
Connaitre la liste des fichiers de l'archive:
```bash
bruno@SilverBook:~/Downloads$ unzip -l zenphoto-zenphoto-1.4.14.zip
```
Extraire des fichiers de l'archive:
```bash
bruno@SilverBook:~/Downloads$ unzip zenphoto-zenphoto-1.4.14.zip zenphoto-zenphoto-1.4.14/zp-core/zp-extensions/zenpage/zenpage.css zenphoto-zenphoto-1.4.14/zp-core/zp-extensions/tinymce4/skins/lightgray/img/anchor.gif
Archive: zenphoto-zenphoto-1.4.14.zip
4c21854e7a7950ec8d9644a959da019d9781d36c
inflating: zenphoto-zenphoto-1.4.14/zp-core/zp-extensions/tinymce4/skins/lightgray/img/anchor.gif
inflating: zenphoto-zenphoto-1.4.14/zp-core/zp-extensions/zenpage/zenpage.css
```

119
docs/Linux/commandes.md Normal file
View File

@@ -0,0 +1,119 @@
# Commandes
### Supprimer le contenu d’un repertoire Linux:
On se place dans le répertoire puis:
`bruno@macbook-pro:~/Desktop/folder$ rm -rf *`
ou alors:
`bruno@macbook-pro:~/Desktop/folder$ rm -rf ton_repertoire/*`
### Copier tous les fichiers .zip dans un autre dossier:
```bash
$ cp *.zip /volume1/Backup/
```
### Déplacer un fichier vers un dossier parent:
```bash
$ mv plex.zip ../../..
```
### Connaitre le SHELL utilisé:
```bash
$ echo $SHELL
/opt/bin/bash
```
### Aller au répertoire utilisateur:
```bash
$ cd $HOME
```
### Afficher les numéros de ligne avec cat:
```bash
$ cat --number foo.c | more
$ cat -n foo.c | less
```
### Commentaire multi-lignes:
```bash
#!/bin/bash
echo "Say Something"
<<COMMENT1
your comment 1
comment 2
blah
COMMENT1
echo "Do something else"
: '
COMMENT2
your comments here
'
```
### Connaitre la version installé:
```bash
$ cat /etc/linuxmint/info
$ cat /etc/lsb-release
```
Liste des utilisateurs et groupes:
```bash
$ cat /etc/passwd | awk -F: '{print $ 1}'
$ cat /etc/group | awk -F: '{print $ 1}'
```
### Sudo:
Crée un nouvel utilisateur avec privilèges super-utilisateur (sudo):
```bash
$ adduser <newuser>
$ usermod -aG sudo <newuser>
# ou
$ sudo gpasswd -a <newuser> sudo
Adding user <newuser> to group sudo
```
Retirer les privilèges super-utilisateur (sudo) à un utilisateur:
```bash
$ sudo deluser <username> sudo
$ sudo gpasswd -d <username> sudo
# retire <username> de tous les groups sauf de son groupe individuel
$ usermod -G "" <username>
```

402
docs/Linux/conditions.md Normal file
View File

@@ -0,0 +1,402 @@
# Conditions
## IF
### if
```bash
if [ $foo -ge 3 ]; then
... (si $foo >= 3)
elif [ $foo -lt 3 ]; then
... (si $foo < 3)
else
...
fi
if [ $foo -ge 3 ]
then
... (si $foo >= 3)
elif [ $foo -lt 3 ]
then
... (si $foo < 3)
else
...
fi
```
### if imbriqué
```bash
if [ $value -ge 1 ]
then
if [ $foo -eq 1 ]
then
echo "One"
elif [ $foo -eq 2 ]
then
echo "Two"
else
echo "Bigger than two"
fi
fi
```
### AND & OR
```bash
if [[ -n $1 ]] && [[ -r $1 ]]
then
echo "File exists and is readable"
fi
if [[ -z $1 ]] || [[ ! -r $1 ]]
then
echo "Either you didn't give me a value or file is unreadable"
exit 2
fi
```
### Conditions:
#### -fichier
Si le fichier *<u>existingfile</u>* existe
```bash
if [ -a existingfile ]; then
ou
if [ -e existingfile ]; then
if [ -a tmp.tmp ]; then
```
Si le fichier *<u>blockspecialfile</u> (/dev/fd0)* existe
```bash
if [ -b blockspecialfile ]; then
if [ -b /dev/fd0 ]; then
```
Si le fichier *<u>characterspecialfile</u> (/dev/null tty)* existe
```bash
if [ -c characterspecialfile ]; then
if [ -c /dev/dsp ]; then
```
Si le répertoire *<u>directory</u>* existe
```bash
if [ -d directory ]; then
if [ -d ~/.kde ]; then
```
Si le fichier *<u>regularfile</u> (ni un blockspecialfile, ni un characterspecialfile, ni un directory)* existe
```bash
if [ -f regularfile ]; then
if [ -f ~/.bashrc ]; then
```
Si le fichier *<u>sgidfile</u> (set-group-ID)* existe
```bash
if [ -g sgidfile ]; then
if [ -g . ]; then
```
Si le fichier *<u>fileownedbyeffectivegroup</u>* existe
```
if [ -G fileownedbyeffectivegroup ]; then
if [ ! -G file ]; then
```
Si le fichier *<u>symboliclink</u> (symbolic link)* existe
```bash
if [ -h symboliclink ]; then
ou
if [ -L symboliclink ]; then
if [ -h $pathtofile ]; then
```
Si le fichier *<u>stickyfile</u> (sticky bit set)* existe
```bash
if [ -k stickyfile ]; then
if [ ! -k /tmp ]; then
```
Si le fichier *<u>modifiedsincelastread</u>* *(a été modifié aprèès la dernière lecture)* existe
```bash
if [ -N modifiedsincelastread ]; then
if [ -N /etc/crontab ]; then
```
Si le fichier *<u>fileownedbyeffectiveuser</u>* *(si l'utilisateur exécutant le script le possède)* existe
```bash
if [ -O fileownedbyeffectiveuser ]; then
if [ -O file ]; then
```
Si le fichier *<u>namedpipe</u>* existe
```bash
if [ -p namedpipe ]; then
if [ -p $file ]; then
```
Si le fichier *<u>readablefile</u> (droit lecture)* existe
```bash
if [ -r readablefile]; then
if [-r file ]; then
```
Si le fichier *<u>noemptyfile</u> (taille > 0 octet)* existe
```bash
if [ -s nonemptyfile ]; then
if [ -s logfile ]; then
```
Si le fichier *<u>socket</u>* existe
```bash
if [ -S socket ]; then
if [ -S /var/lib/mysql/mysql.sock ]; then
```
Si le fichier *<u>openterminal</u>* existe
```bash
if [ -t openterminal ]; then
if [ -t /dev/pts/3 ]; then
```
Si le fichier *<u>suidfile</u> (set-user-ID)* existe
```bash
if [ -u suidfile ]; then
if [ -u executable ];
```
Si le fichier *<u>writeablefile</u> (droit écriture)* existe
```bash
if [ -w writeablefile ]; then
if [ -w /dev/hda ]; then
```
Si le fichier *<u>executablefile</u> (droit exécutable)* existe
```bash
if [ -x executablefile ]; then
if [ -x /root ];
```
Si le fichier *<u>newerfile a été modifié après olderfile</u>*, ou *<u>si newerfile existe et pas olderfile</u>.*
```bash
if [ newerfile -nt olderfile ]; then
if [ story.txt1 -nt story.txt ];
```
Si le fichier *<u>olderfile a été modifié avant newerfile</u>*, ou <u>*si newerfile existe et pas olderfile.*</u>
```bash
if [ olderfile -ot newerfile ]; then
if [ /mnt/remote/remotefile -ot localfile ]; then
```
Si les fichiers <u>*same et file font référence au même device / inode*</u>
```bash
if [ same -ef file ]; then
if [ /dev/cdrom -ef /dev/dvd ]; then
```
#### -chaine
Si les chaines sont <u>*identiques*</u> [ STRING1 == STRING2 ]
```bash
if [ “$1” == “moo” ]; then
```
Si les chaines sont <u>*différentes*</u> [ STRING1 != STRING2 ]
```bash
if [ “$userinput” != “$password” ];
```
Si la chaine 1 <u>*est triée après*</u> la chaine 2 [ STRING1 > STRING2 ]
```bash
if [ “$userinput” > “$password” ];
```
Si la chaine 1 <u>*est triée avant*</u> la chaine 2 [ STRING1 < STRING2 ]
```bash
if [ “$userinput” < “$password” ];
```
Si la chaine <u>*NONEMPTYSTRING a une longueur > 0*</u> (contient 1 ou plusieurs caractères)
```bash
if [ -n NONEMPTYSTRING ]; then
if [ -n “$userinput” ]; then
```
Si la chaine <u>*EMPTYSTRING est vide*</u> (NULL)
```bash
if [ -z EMPTYSTRING ]; then
if [ -z $uninitializedvar ]; then
```
Si la chaine réussie la REGEX [[ STRING1 =~ REGEXPATTERN ]]
```bash
if [[ “$email” =~ “b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,4}b” ]]; then
```
#### -nombre
Si deux nombres sont <u>égaux</u> (EQual) [ NUM1 -eq NUM2 ]
```bash
if [ $NUM1 -eq $NUM2 ]; then
```
Si deux nombres sont <u>différents</u> (Not Equal) [ NUM1 -ne NUM2 ]
```bash
if [ $NUM1 -ne $NUM2 ]; then
```
Si NUM 1 est <u>supérieur à</u> NUM 2 (Greater Than) [ NUM1 -gt NUM2 ]
```bash
if [ $NUM1 -gt $NUM2 ]; then
```
Si NUM 1 est <u>supérieur ou égal à</u> NUM 2 (Greater than or Equal) [ NUM1 -ge NUM2 ]
```bash
if [ $NUM1 -ge $NUM2 ]; then
```
Si NUM 1 est <u>inférieur à</u> NUM 2 (Less Than) [ NUM1 -lt NUM2 ]
```bash
if [ $NUM1 -lt $NUM2 ]; then
```
Si NUM 1 est <u>inférieur ou égal à</u> NUM 2 (Less than or Equal) [ NUM1 -le NUM2 ]
```bash
if [ $NUM1 -le $NUM2 ]; then
```
Exemples:
```bash
if [ $? -eq 0 ]; then # $? returns the exit status of the previous command
echo “Previous command ran succesfully.”
fi
if [ $(ps -p $pid -o ni=) -ne $(nice) ]; then
echo “Process $pid is running with a non-default nice value”
fi
if [ $num -lt 0 ]; then
echo “Negative numbers not allowed; exiting…”
exit 1
fi
```
#### -double parenthèses
Si deux nombres sont <u>égaux</u> (( NUM1 == NUM2 ))
```bash
if (( NUM1 == NUM2 )); then
```
Si deux nombres sont <u>différents</u> (( NUM1 != NUM2 ))
```bash
if (( NUM1 != NUM2 )); then
```
Si NUM 1 est <u>supérieur à</u> NUM 2 (( NUM1 > NUM2 ))
```bash
if (( NUM1 > NUM2 )); then
```
Si NUM 1 est <u>supérieur ou égal à</u> NUM 2 (( NUM1 >= NUM2 ))
```bash
if (( NUM1 >= NUM2 )); then
```
Si NUM 1 est <u>inférieur à</u> NUM 2 (( NUM1 < NUM2 ))
```bash
if (( NUM1 < NUM2 )); then
```
Si NUM 1 est <u>inférieur ou égal à</u> (( NUM1 <= NUM2 ))
```bash
if (( NUM1 <= NUM2 )); then
```

308
docs/Linux/executer.md Normal file
View File

@@ -0,0 +1,308 @@
# Excecuter une application en root
### A) Sudo
Avec sudo, on prend les droits root pour exécuter une commande.
```bash
$ sudo opkg update
```
Le mot de passe est mémorisé pendant x minutes, pendant les lesquelles pour les commandes lancées avec sudo, le mot-de-passe n'est pas demandé.
On peut "oublier" le mot de passe mémorisé.
```bash
$ sudo -k
```
On peut ouvrir une "session root" avec sudo.
```bash
$ sudo -i
```
Avec **sudo -i**, le mot de passe **utilisateur** est demandé.
Avec **su -**, le mot de passe **root** est demandé.
Obtenir la listes des commandes dispos:
```bash
$ sudo -l
Password:
Matching Defaults entries for bruno on DS916:
syslog=authpriv
User bruno may run the following commands on DS916:
(ALL) ALL
```
### B) sudoers
Plutot que d'éditer `sudoers`, on peut créer des fichiers de personnalisation dans `/etc/sudoer.d/`
```bash
/etc/sudoers.d$ ls -la
total 28
drwxr-xr-x 2 root root 4096 sept. 11 20:02 .
drwxr-xr-x 144 root root 12288 sept. 11 19:52 ..
-r--r----- 1 root root 180 mars 22 2017 mintupdate
-r--r----- 1 root root 958 janv. 18 2018 README
-r--r----- 1 root root 51 août 26 10:20 vagrant
```
`chmod 440` sur ces fichier.
#### options
<u>Reduire le temps de grâce:</u>
Ajouter `timestamp_timeout=X` à la ligne `Defaults`
```bash
Defaults env_reset,timestamp_timeout=X
```
#### Cmnd alias
Il faut éditer `/etc/sudoers` avec visudo:
```bash
$ sudo visudo -s
```
ou avec nano:
```bash
$ sudo nano /etc/sudoers
```
```bash
# /etc/sudoers
#
# This file MUST be edited with the 'visudo' command as root.
#
# See the man page for details on how to write a sudoers file.
# Host alias specification
# User alias specification
# Cmnd alias specification
Cmnd_Alias NETWORK=/sbin/ifconfig, /sbin/iwconfig, /sbin/dhclient
# Defaults
Defaults !lecture,tty_tickets,!fqdn,insults
# User privilege specification
root ALL=(ALL) ALL
# Members of the admin group may gain root privileges
%admin ALL=(ALL) ALL, NOPASSWD:NETWORK
```
root a tous les droits.
le groupe (%) admin peut lancer `ifconfig` avec un sudo mais SANS mot-de-passe, et tout le reste avec sudo Et mot-de-passe.
```bash
$ sudo ifconfig
```
username n'a le droit d'exécuter sudo que pour le seul script.sh (et sans mot-de-passe)
```
username ALL=NOPASSWD: /mon/script.sh
```
```bash
$ sudo /mon/script.sh
```
autres exemples:
```bash
nano vagrant
```
```bash
# add vagrant user
vagrant ALL=(ALL) NOPASSWD:ALL
```
```bash
nano mintupdate
```
```bash
# Allow any user to check for new system updates without
# requiring user autentification
Cmnd_Alias UPDATE = /usr/lib/linuxmint/mintUpdate/checkAPT.py
ALL ALL = NOPASSWD:UPDATE
```
[https://doc.ubuntu-fr.org/sudoers](https://doc.ubuntu-fr.org/sudoers)
### C) Setuid
### suid
Lorsque l’on place un suid sur un fichier, n’importe quel utilisateur peut l’exécuter en héritant des permissions du propriétaire, comme s’il était lui-même le propriétaire.
Exemple: quand un fichier exécutable est propriété de l'[utilisateur root](https://fr.wikipedia.org/wiki/Utilisateur_root), et est rendu *setuid*, tout processus exécutant ce fichier peut effectuer ses tâches avec les permissions associées à root
Le *suid* ne s’active que sur des fichiers. La valeur de *suid* est 4 sur le chiffre octal de poids fort, son flag est s ou S (s si le droit d'exécution est présent, S sinon).
Pour activer le *suid* :
```bash
$ chmod u+s fichier
$ chmod 4755 fichier
```
Pour supprimer le *suid*:
```bash
$ sudo chmod u-s fichier
$ chmod 0755 fichier
```
```bash
$ ls -la
-rwxr-xr-x 1 bruno users 2264 Sep 11 17:02 _npm.sh
# on met le suid (exécutable + suid -> s)
$ chmod u+s _npm.sh
$ ls -la
-rwsr-xr-x 1 bruno users 2264 Sep 11 17:02 _npm.sh
# on retire le suid
$ chmod u-s _npm.sh
$ ls -la
-rwxr-xr-x 1 bruno users 2264 Sep 11 17:02 _npm.sh
# le script n'est pas exécutable
$ chmod 644 _npm.sh
$ ls -la
$ -rw-r--r-- 1 bruno users 2264 Sep 11 17:02 _npm.sh
#on met le suid (non exécutable + suid -> S)
$ chmod u+s _npm.sh
$ ls -la
-rwSr--r-- 1 bruno users 2264 Sep 11 17:02 _npm.sh
```
~~Un script ne peut pas être set-uid.~~
~~c'est pas au niveau du script mais du binaire appelé qu'il faut le faire~~
Rendre root possesseur du script.
```bash
$ chown root:root /path/to/root-script.sh`
```
#### sgid
**Sur un fichier**: ce droit fonctionne comme le droit *suid*, mais appliqué aux groupes.
Il donne à un utilisateur les droits du groupe auquel appartient le propriétaire de l’exécutable et non plus les droits du propriétaire.
La valeur de *sgid* est 2 sur le chiffre octal de poids fort, son flag est s ou S (s si le droit d'exécution est présent, S sinon).
Pour activer le *sgid*:
```bash
$ chmod g+s fichier
$ chmod 2755 fichier
```
Pour activer le *suid* et le *sgid*:
```bash
$ chmod ug+s fichier
# le poids fort vaut 6 (4+2)
$ chmod 6755 fichier
```
Pour supprimer le *sgid*:
```bash
$ chmod u-s fichier
$ chmod 0755 fichier
```
**Sur un répertoire**: ce droit a une tout autre utilisation s’il est appliqué à un répertoire.
Normalement, lorsqu’un fichier est créé par un utilisateur, il en est propriétaire, et un groupe par défaut lui est appliqué (généralement *users* si le fichier a été créé par un utilisateur, et *root* ou *wheel* s’il a été créé par *root*).
Cependant, lorsqu’un fichier est créé dans un répertoire portant le droit SGID, alors ce fichier se verra attribuer par défaut le groupe du répertoire. De plus, si c’est un autre répertoire qui est créé dans le répertoire portant le droit *sgid*, ce sous-répertoire portera également ce droit. En revanche, si des sous-répertoires existent déjà au moment de l'ajout du *Setgid*, ils ne sont pas affectés par celui-ci.
```bash
$ chmod g+s repertoire
$ chmod 2755 repertoire
```
#### sticky bit
Le droit d’écriture signifie que l’on peut créer et supprimer les fichiers de ce répertoire. Le sticky bit permet de faire la différence entre les deux droits.
**Sur un fichier,** Gnu/Linux n’en tient pas compte contrairement aux vieux systèmes Unix. Ainsi le sticky bit activé indique à l’OS que le fichier sera utilisé fréquemment et sera ainsi stocké dans un fichier d’échange pour avoir la main dessus rapidement.
La valeur du *sticky bit* est 1 sur le chiffre octal de poids fort, son flag est t ou T.
```bash
$ sudo chmod +t fichier*
$chmod 1750 /path/to/root-script.sh
```
**Sur un répertoire** le sticky bit aura pour effet d’interdire à quiconque n’étant pas le propriétaire du fichier sa suppression. Cependant, il sera toujours possible de modifier le fichier d’un autre si l’on possède les droits nécessaires. La création de nouveaux fichiers est toujours possible pour tous les utilisateurs possédant le droit d'écriture sur ce répertoire
```bash
$ sudo chmod +t repertoire*
```
Sur certains systèmes UNIX, le sticky bit est utilisé pour le répertoire /tmp
### D) gksu & gksudo
Ce sont simplement des front-end graphiques pour *su* et *sudo*.

45
docs/Linux/filtres.md Normal file
View File

@@ -0,0 +1,45 @@
# Filtres
#### sort
Sorts standard input then outputs the sorted result on standard output.
#### uniq
Given a sorted stream of data from standard input, it removes duplicate lines of data (i.e., it makes sure that every line is unique).
#### grep
Examines each line of data it receives from standard input and outputs every line that contains a specified pattern of characters.
#### fmt
Reads text from standard input, then outputs formatted text on standard output.
#### pr
Takes text input from standard input and splits the data into pages with page breaks, headers and footers in preparation for printing.
#### head
Outputs the first few lines of its input. Useful for getting the header of a file.
#### tail
Outputs the last few lines of its input. Useful for things like getting the most recent entries from a log file.
#### tr
Translates characters. Can be used to perform tasks such as upper/lowercase conversions or changing line termination characters from one type to another (for example, converting DOS text files into Unix style text files).
#### sed
Stream editor. Can perform more sophisticated text translations than tr.
#### awk
An entire programming language designed for constructing filters. Extremely powerful.
`-rw-r–r– 1 root root 0 avril 24 22:49 security.ubuntu.com*ubuntu*dists*xenial-security*restricted*binary-i386*Packages`

118
docs/Linux/find.md Normal file
View File

@@ -0,0 +1,118 @@
# find
La commande **find** permet de retrouver des fichiers à partir de certains critères. Elle doit être utilisé avec l'option **-print**
Les <u>critères de recherche</u> sont les suivants :
- **-name** recherche sur le nom du fichier,
- **-perm** recherche sur les droits d'accès du fichier,
- **-links** recherche sur le nombre de liens du fichier,
- **-user** recherche sur le propriétaire du fichier,
- **-group** recherche sur le groupe auquel appartient le fichier,
- **-type** recherche sur le type (d=répertoire, c=caractère, f=fichier normal),
- **-size** recherche sur la taille du fichier en nombre de blocs (1 bloc=512octets),
- **-atime** recherche par date de dernier accès en lecture du fichier,
- **-mtime** recherche par date de dernière modification du fichier,
- **-ctime** recherche par date de création du fichier.
<u>Options:</u>
Recherche par <u>nom de fichier</u>:
```bash
find /usr -name toto -print
find /usr -name " *.c " -print
# commence par un a ou A, suivi de quelque chose, et se termine par un chiffre compris entre 3 et 6
find . -name '[aA]*[3-6]' -print
```
Recherche suivant la <u>date de dernière modification</u>:
```bash
# modifiés il y a 30 jours
find / -mtime 30 -print
# modifiés il y a 30 jours ou plus
find / -mtime +30 -print
# modifiés il y a 30 jours ou moins
find / -mtime 30 -print
```
Recherche suivant la <u>taille</u>:
```bash
# fichiers dont la taille dépasse 30ko
find / -size +30k -print
```
Recherche en utilisant les <u>opérateurs logiques</u>:
```bash
# les fichiers n'appartenant pas à l'utilisateur olivierles fichiers n'appartenant pas à l'utilisateur olivier
find . ! -user olivier -print
# Recherche les fichiers dont le nom est a.out ou les fichiers se terminant par *.c (une condition OU l'autre).
find . \ ( -name a.out -o -name " *.c " \ ) -print
# Recherche des fichiers dont le nom est core et d'une taille supérieure à 1Mo (une condition ET l'autre).
find . \ (-name core -a size +2000 \ ) -print
```
Recherche <u>combinée</u>:
```bash
# les fichiers de l'utilisateur bruno dont les permissions sont 755
find / -type f -user bruno -perm 755 -print
```
Commandes en option:
```bash
# Recherche les fichiers toto et les efface.
find . -name toto -exec rm {}\ ;
# Pour avoir une demande de confirmation avant l'exécution de rm
find . -name toto -ok rm {}\ ;
```
Utilisation avec d'autres commandes:'
```bash
# Recherche les fichiers normaux dans le répertoire courant, puis chercher le chaine toto dans ces fichiers.
find . -type f -print | xargs grep toto
# Recherche les fichiers toto et les efface après confimation (-p).
# idem -exec, " | xargs " ne crée qu'un seim processus.
find . -name toto | xargs -p rm
```
Redirection des messages d'erreur:
```bash
find / -name toto -print 2>/dev/null
```

88
docs/Linux/grep.md Normal file
View File

@@ -0,0 +1,88 @@
# grep
La commande **grep** permet de rechercher une chaîne de caractères dans un fichier.
Options:
```bash
-i (ignore case) insensible à la casse
-v affiche les lignes ne contenant pas la chaîne
-c (count) compte le nombre de lignes contenant la chaîne
-n (number) chaque ligne contenant la chaîne est numérotée
-x ligne correspondant exactement à la chaîne
-l affiche le nom des fichiers qui contiennent la chaîne
-C (context) fait figurer les deux lignes qui précèdent et suivent la ligne où figure le mot recherché
-Ax (after) affiche les x lignes qui suivent la ligne où figure le mot recherché
-Bx (before) affiche les x lignes qui précèdent la ligne où figure le mot recherché
-r (recursif)
-w mot exact
```
<u>Chercher dans un dossier (récursif)</u>:
```bash
grep -r "brew" ./docs/
./docs//Divers/plex.md: $ brew install mono
# N'affiche que les fichiers (-l):
grep -l -r "brew" ./docs/
./docs//Divers/plex.md
./docs//macos/node-js.md
```
<u>Regex:</u>
```bash
grep -E ^a toto.txt
```
L'option -E est optionnelle (compatibilité).
| Caractère spécial | Signification |
| ----------------- | ------------------------------------------------------------ |
| `.` | Caractère quelconque |
| `^` | Début de ligne |
| `$` | Fin de ligne |
| `[]` | Un des caractères entre les crochets |
| `?` | L'élément précédent est optionnel (peut être présent 0 ou 1 fois) |
| `*` | L'élément précédent peut être présent 0, 1 ou plusieurs fois |
| `+` | L'élément précédent doit être présent 1 ou plusieurs fois |
| `|` | Ou |
| `()` | Groupement d'expressions |
Lignes commençant par les caractères compris entre a et d:
```bash
grep ^[a-d] fichier.txt
```
Rechercher plusieurs chaines:
```bash
grep -E 'tata|toto' fichier.txt
```
ou passer un fichier de motifs à grep:
```bash
cat motif.txt
grep -f "motif.txt" fichier.txt
```
Afficher les 5 lignes qui suivent le motif recherché:
```bash
grep 'toto' -A5 fichier.txt
```

31
docs/Linux/index.md Normal file
View File

@@ -0,0 +1,31 @@
# Linux
[Authentification automatique par SSH sans mot de passe](../macos/ssh/ssh-passwordless.md)
[Archiver / compresser](archiver.md)
[Commande scp](scp.md)
[Commande sftp](sftp.md)
[Commande ssh](ssh.md)
[Commandes tail/head](tail-head.md)
[Commandes apt-get & apt-cache](../Raspberry/apt-get.md)
[Editeurs](index.md) (vi, nano…)
[Shells](shell.md)
[Permissions](permissions.md)
[I/O Redirections](redirections.md)
[Pipelines](pipeline.md)
[Filtres](filtres.md)
[Mises-à-jour sans connection internet](maj.md)
[Quelques commandes sympas](commandes.md)

39
docs/Linux/maj.md Normal file
View File

@@ -0,0 +1,39 @@
# Faire les mises-à-jour sans connection internet
[apt-offline (ubuntu.fr)](https://doc.ubuntu-fr.org/apt-offline)
[Scripts (ubuntu.fr)](https://doc.ubuntu-fr.org/tutoriel/scripts_de_mise_a_jour_sans_internet)
[LinuxMint](https://community.linuxmint.com/tutorial/view/1059)
#### 1ere méthode (exemple pour Wine):
Sur **la machine reliée à internet,** ajouter le dépôt et mettre à jour:
```bash
$ sudo add-apt-repository ppa:wine/wine-builds
$ sudo apt-get update
```
Mettre en cache les paquets sans les extraire:
```bash
$ sudo apt-get clean
$ sudo apt-get --download-only install winehq-devel
$ sudo apt-get --download-only dist-upgrade
```
Copier tous les fichiers .deb contenus dans le dossier /var/cache/apt/archive sur une clé USB:
```bash
$ cp -R /var/cache/apt/archives/ /media/usb-drive/deb-pkgs/
```
Sur **la machine sans internet**, installer les paquets depuis la clé USB:
```bash
$ cd /media/usb-drive/deb-pkgs
$ sudo dpkg -i *.deb
```

135
docs/Linux/permissions.md Normal file
View File

@@ -0,0 +1,135 @@
# Permissions
#### Quelques commandes:
- su - temporarily become the superuser
- sudo - temporarily become the superuser
- chmod - modify file access rights
- chown - change file ownership
- chgrp - change a file's group ownership
```
-rwxrwxrwx
[- (fichier) ou d (dossier)] [rwx (possesseur) - rwx (groupe) - rwx (autres)]
```
#### chmod: change les permissions pour un fichier ou un dossier
```
rwx rwx rwx = 111 111 111
rw- rw- rw- = 110 110 110
rwx —–- -–— = 111 000 000
```
et
```
rwx = 111 in binary = 7
rw- = 110 in binary = 6
r-x = 101 in binary = 5
r–- = 100 in binary = 4
```
**Les réglages les plus courants:**
*-applications:*
```
777 (rwxrwxrwx)
755 (rwxr-xr-x)
700 (rwx——)
```
*-fichiers:*
```
666 (rw-rw-rw-)
644 (rw-r–r–)
600 (rw——-)
```
**Permissions pour les dossiers:**
- r: permet de lister le contenu d'un répertoire si l'attribut x est mis
- w: les fichiers à l'intérieur du répertoire peuvent être crées, effacés ou renommer si l'attribut x est mis
- x: permet d'entrer dans le répertoire (cd dir)
```
777 (rwxrwxrwx)
755 (rwxr-xr-x)
700 (rwx——)
```
```bash
bruno@macbook-pro:~$ ls -la
-rw-r--r--@ 1 bruno staff 848 6 aoû 09:20 backup-syno.tar.gz
bruno@macbook-pro:~/test-dossier-2$ chmod 777 backup-syno.tar.gz
bruno@macbook-pro:~$ ls -la
-rwxrwxrwx@ 1 bruno staff 848 6 aoû 09:20 backup-syno.tar.gz
```
#### chown: change le possesseur d'un fichier ou dossier (superuser)
```bash
bruno@macbook-pro:~$ ls -la
-rwxrwxrwx@ 1 bruno staff 848 6 aoû 09:20 backup-syno.tar.gz
bruno@macbook-pro:~$ sudo chown root backup-syno.tar.gz
Password:
bruno@macbook-pro:~$ ls -la
-rwxrwxrwx@ 1 root staff 848 6 aoû 09:20 backup-syno.tar.gz
```
#### chgrp: change le groupe d'un fichier ou dossier (superuser)
```bash
bruno@macbook-pro:~$ ls -la
-rwxrwxrwx@ 1 root staff 848 6 aoû 09:20 backup-syno.tar.gz
bruno@macbook-pro:~$ sudo chgrp admin backup-syno.tar.gz
bruno@macbook-pro:~$ ls -la
-rwxrwxrwx@ 1 root admin 848 6 aoû 09:20 backup-syno.tar.gz
```
#### setuid:
```
# chown root:root monshell.sh
# chmod 4755 monshell.sh
# exit
$ ./monshell.sh
```
#### Voir les autorisations au format octal:
**-Linux:**
```bash
stat -c '%n %a' *
```
**-OSX**:
```bash
bruno@Parallels-VM ~ $ stat -c '%n %a' *
apt-off.sh 755
Bureau 755
Documents 755
Images 755
```

37
docs/Linux/pipeline.md Normal file
View File

@@ -0,0 +1,37 @@
# Pipelines
Connecte plusieurs commandes ensembles (la sortie standart d'une commande est l'entrée standart
de la suivante)
Affiche les fichiers du répertoire par page:
```bash
bruno@macbook-pro:~$ ls -l | less
```
Affiche les 10 plus récents fichiers du répertoire:
```bash
bruno@macbook-pro:~$ ls -lt | head
```
Affiche une liste de répertoires et leur taille, triée du plus grand au plus petit:
```bash
bruno@macbook-pro:~$ du | sort -nr
```
Affiche le nombre total de fichiers du répertoire courant et dans tous ses sous-répertoire:
```bash
find . -type f -print | wc -l
```

35
docs/Linux/redirections.md Normal file
View File

@@ -0,0 +1,35 @@
# I/O Redirections
#### Standard Output
Redirige la sortie standart vers un nouveau fichier:
```bash
bruno@macbook-pro:~$ ls > liste.txt
```
Redirige la sortie standart vers un fichier (ajoute à la suite):
```bash
bruno@macbook-pro:~$ ls >> liste.txt
```
#### Standard Input
Considère liste.txt comme entrée standart (au lieu du clavier):
```bash
bruno@macbook-pro:~$ sort < liste.txt
```
#### On peut combiner les 2
```bash
bruno@macbook-pro:~$ sort < liste.txt > liste_triee.txt
```

103
docs/Linux/scp.md Normal file
View File

@@ -0,0 +1,103 @@
# Commande scp (copie sécurisée)
#### Serveur 1 -> Serveur 2
Copie d'un fichier d'une machine serveur1 vers une autre machine serveur2:
```bash
$ scp Login1@Serveur1:Chemin1/NomFichier1 Login2@Serveur2:Chemin2/NomFichier2
macbook-pro:~ bruno $ scp root@192.168.1.8:/root/test-copy-scp.txt
funnymac@ssh funnymac@ftp.cluster011.ovh.net:/www/backup/
```
#### Client -> Serveur
Copie d'un fichier depuis le répertoire courant vers un répertoire du serveur:
```bash
~ scp Fichier login@serveur:Chemin
~ scp /home/mickael/data/Ficher2 root@192.168.10.131:/var/www/
~ scp /Users/bruno/test-copy-scp-2.txt root@192.168.1.8:/root/
root@DiskStation:~ # scp /root/.profile funnymac@ftp.cluster011.ovh.net:www/backup/.profile_syno_root
.profile 100% 497 0.5KB/s 0.5KB/s 00:00
```
Copie d'un répertoire, avec éventuellement ses sous-répertoires, vers un répertoire du serveur:
```bash
~ scp -r Repertoire login@serveur:Chemin
~ scp -r /home/mickael/data/ root@192.168.10.131:/var/www/
```
Si pas port 22
```bash
~ scp -r -P 7256 /home/mickael/data/ root@192.168.10.131:/var/www/
~ scp -r -P 7256 /Users/bruno/test-dossier-2/ root@192.168.1.8:/root/
bruno@SilverBook:~/Downloads$ scp -P 7256 IPTV.bundle-master.zip bruno@clicclac.synology.me:/volume1/web
bruno@clicclac.synology.me's password:
IPTV.bundle-master.zip 100% 673KB 84.0KB/s 00:08
```
#### Serveur -> Client
Copie d'un fichier du serveur vers le répertoire courant:
```bash
~ scp login@serveur:Chemin/Fichier .
~ scp root@192.168.10.131:/var/www/Fichier2 /home/mickael/data/
~ macbook-pro:~ bruno$ scp root@192.168.1.8:/root/test-copy-scp.txt /Users/bruno/Documents
```
Copie d'un répertoire du serveur vers le répertoire courant:
```bash
~ scp -r login@serveur:Chemin/Repertoire .
~ macbook-pro:~ bruno$ scp -r root@192.168.1.8:/root/test /Users/bruno/Documents
~ macbook-pro:~ bruno$ scp -r root@192.168.1.8:/root/test-dossier . (home)
```
<http://www.it-connect.fr/chapitres/transfert-de-fichier-via-ssh/>
#### Autres exemples
Archive et compresse une liste de fichiers, puis envoie l'archive sur le ftp OVH.
```bash
root@DiskStation:~ # tar -zcvf backup-syno.tar.gz -T .liste-backup.txt | scp backup-syno.tar.gz funnymac@ftp.cluster011.ovh.net:www/backup
```
Envoie un fichier du Macbook sur le ftp OVH.
```bash
macbook-pro:~ bruno$ scp .bash_profile funnymac@ftp.cluster011.ovh.net:www/backup
```
#### Éditer un fichier à distance en SSH
```bash
nano scp://root@192.168.240.132//etc/fichier.cnf
```
<http://www.it-connect.fr/chapitres/transfert-de-fichier-via-ssh/>
#### Envoyer un fichier sur le NAS:
```bash
$ scp -P 72566 vendor.zip bruno@clicclac.synology.me:/volume1/web/gitlist/
```

68
docs/Linux/sftp.md Normal file
View File

@@ -0,0 +1,68 @@
# Commande sftp (ftp sécurisée)
#### Se connecter au serveur:
```bash
admin@DiskStation:~ $ sftp funnymac@ftp.cluster011.ovh.net:www
Connected to ftp.cluster011.ovh.net.
Changing to: /home/funnymac/www
```
#### Changer de dossier:
```bash
sftp> cd backup
```
#### Connaitre le chemin distant:
```bash
sftp> pwd
Remote working directory: /home/funnymac/www/backup
```
#### Lire le répertoire courant:
```bash
sftp> ls
backup-syno.tar.gz
```
#### Connaitre le chemin sur le client:
```bash
sftp> !pwd
/volume1/homes/admin
```
#### Télécharger un fichier:
```bash
sftp> get backup-syno.tar.gz
Fetching /home/funnymac/www/backup/backup-syno.tar.gz to backup-syno.tar.gz
/home/funnymac/www/backup/backup-syno.tar.gz 100% 933 0.9KB/s 0.9KB/s 00:00
```
#### Envoyer un fichier:
```bash
sftp> put .liste-backup.txt
Uploading .liste-backup.txt to /home/funnymac/www/backup/.liste-backup.txt
.liste-backup.txt 100% 119 0.1KB/s 0.1KB/s 00:00
sftp> ls
backup-syno.tar.gz
sftp> ls -la
drwx---r-x 2 funnymac users 6 Aug 6 13:13 .
drwx---r-x 18 funnymac users 34 Jul 27 06:54 ..
-rw-r--r-- 1 funnymac users 119 Aug 6 13:13 .liste-backup.txt
-rw-r--r-- 1 funnymac users 933 Aug 6 10:21 backup-syno.tar.gz
```
#### Se déconnecter:
```bash
sftp> quit
```

41
docs/Linux/shell.md Normal file
View File

@@ -0,0 +1,41 @@
# Shells
### ASH
#### Préférences:
- System: `/etc/profile`
- User: `~/.profile`
### BASH:
#### Préférences:
Il cherche les fichiers dans l'ordre suivant:
1. BASH comme login SHELL (une session où on se loggue dans le système, une connexion ssh):
1. `/etc/profile`
2. `~/.bash_profile`
3. `~/.bash_login`
4. `~/.profile`
2. BASH comme application (après s'être loggué avec un autre SHELL)
1. `/etc/bash.bashrc`
2. `~/.bashrc`
### Recharger la configuration:
```bash
$ source ~/.profile
ou
$ . ~/.profile
```
On peut aussi créer un alias: `alias rload=". ~/.profile"`

101
docs/Linux/ssh.md Normal file
View File

@@ -0,0 +1,101 @@
# Commande ssh
#### Se connecter à un serveur par un autre port que 22:
```bash
bruno@macbook-pro:~$ ssh bruno@192.168.1.7 -p 42666
bruno@192.168.1.7's password:
bruno@DS916:/var/services/homes/bruno $
```
#### Fixer le message WARNING: UNPROTECTED PRIVATE KEY FILE!
On réinitilalise les permissions des clés:
```bash
bruno@macbook-pro:~$ sudo chmod 600 ~/.ssh/id_rsa
bruno@macbook-pro:~$ sudo chmod 600 ~/.ssh/id_rsa
```
Si cela ne suffit pas:
```bash
bruno@macbook-pro:~$ sudo chmod 600 ~/.ssh/known_hosts
bruno@macbook-pro:~$ sudo chmod 755 ~/.ssh
```
#### Copier un fichier:
```bash
macbook-pro:~ bruno$ ssh root@192.168.1.8 "cat prefs.tar.gz"> prefs.tar.gz
```
#### Exécuter une (ou plusieurs) commande sur un serveur distant:
```bash
macbook-pro:~ bruno$ ssh root@192.168.1.8 hostname
DiskStation
bruno@SilverBook:~$ ssh -p34987 bruno@xxxxxxx.synology.me 'hostname ; uptime'
bruno@xxxxxxx.synology.me's password:
DS916
07:56:40 up 2 days, 19:50, 0 users, load average: 1.13, 1.15, 1.14
bruno@SilverBook:~$ ssh -p34987 bruno@xxxxxxx.synology.me << EOF
> uname -a
> lscpu | grep "^CPU(s)"
> grep -i memtotal /proc/meminfo
> EOF
Pseudo-terminal will not be allocated because stdin is not a terminal.
bruno@clicclac.synology.me's password:
Linux DS916 3.10.102 #15266 SMP Mon Mar 26 15:12:32 CST 2018 x86_64 GNU/Linux synology_braswell_916+
/bin/bash: line 2: lscpu: command not found
MemTotal: 1963472 kB
```
#### Exécuter un script distant sur un serveur distant:
```bash
bruno@SilverBook:~$ ssh -p34987 bruno@xxxxxxx.synology.me ./test.sh
bruno@clicclac.synology.me's password:
09:55:03 up 2 days, 21:49, 0 users, load average: 1.14, 1.25, 1.23
DS916
```
#### Exécuter un script local sur un serveur distant:
```bash
bruno@SilverBook:~$ ssh -p34987 bruno@xxxxxxx.synology.me 'bash -s' < test.sh
bruno@xxxxxxx.synology.me's password:
toto
```
#### Mode verbose
```bash
bruno@macbook-pro:~$ ssh -vvv dsm916
OpenSSH_6.9p1, LibreSSL 2.1.8
debug1: Reading configuration data /Users/bruno/.ssh/config
debug1: /Users/bruno/.ssh/config line 3: Applying options for dsm916
debug1: Reading configuration data /etc/ssh/ssh_config
debug1: /etc/ssh/ssh_config line 20: Applying options for *
debug1: /etc/ssh/ssh_config line 102: Applying options for *
debug2: ssh_connect: needpriv 0
debug1: Connecting to 192.168.1.7 [192.168.1.7] port 22.
debug1: Connection established.
debug1: identity file /Users/bruno/.ssh/id_dsa type 2
.../...
bruno@DS916:/var/services/homes/bruno $
```

91
docs/Linux/tail-head.md Normal file
View File

@@ -0,0 +1,91 @@
# Commandes tail - head
### Tail
#### Par défaut, tail affiche les 10 dernières lignes du fichier.
```bash
$ tail /var/log/messages
```
#### Afficher les 15 dernières lignes du fichier.
```bash
$ tail -n15 /var/log/messages
$ tail -15 /var/log/messages
$ tail -n 15 /var/log/messages
```
#### L'option -f affiche le fichier au fil de l'eau
```bash
$ tail -f /var/log/messages
```
### MultiTail
Permet d'afficher plusieurs fichiers en meme temps:
```bash
$ multitail error_log access_log
```
Permet d'afficher 2 fichiers côte à côte:
```bash
$ multitail -s 2 error_log access_log
```
ou 'v' en cours d'exécution
Faire défiler (sur 100 lignes): 'b' ('q' pour quitter le mode défilement')
Pour changer le nb de lignes:
-m <valeur> pour le prochain fichier
-M <valeur> pour tous les fichiers
Fusionner 2 fichiers (ils s'affichent ensemble dans une seul fenêtre):
```bash
$ multitail error_log -I access_log
```
Visualiser la sortie de programmes externes:
```bash
$ multitail -l "ping localhost"
```
Filtrer à l'aide de regexp (grep):
```bash
$ multitail -e '200' access_log
```
```bash
$ multitail -v -e "ssh" -v -e "gnu-pop3d" -e "localhost" /var/log/messages
```
-e 'test': n'affiche que les lignes qui contiennent 'test'
-v -e 'test': n'affiche que les autres lignes
### Head
#### Afficher les 5 premères lignes du fichier.
```bash
$ head -5 /var/log/messages
$ head -n5 /var/log/messages
$ head -n 5 /var/log/messages
```

22
docs/Linux/variables.md Normal file
View File

@@ -0,0 +1,22 @@
Incrémenter une variable:
```bash
i=$((i+1)) user 0m0.992s
i=$((i++)) user 0m0.964s
((i=i+1)) user 0m0.760s
((i+=1)) user 0m0.700s
((i++)) user 0m0.644s
((++i)) user 0m0.556s
let "i=i+1" user 0m1.116s
let "i+=1" user 0m1.100s
let "i++" user 0m1.008s
let i=i+1 user 0m0.952s
let i+=1 user 0m1.040s
let i++ user 0m0.820s
declare -i i; i=i+1 user 0m0.528s
declare -i i; i+=1 user 0m0.492s
i=0; i=$(expr $i + 1) user 0m5.464s
```