groupes:

u	The user who owns the file (you !)

g	The group the file belongs to

o	The other users

a	All of the above (an abbrevation for ugo)

permissions:

r	Read

w	Write

x	Execute

Exemple:

$ chmod a+rw test.txt

OS: Mandrake 10.0

Commande:

Incluant les sous répertoires:

$ find . -name 'session.xsl'

Incluant les sous répertoires et n'affichant que les fichiers contenant le terme “monTexte”:

$ find . -name '*.xmap' -exec grep monTexte '{}' -H ';'

Ou encore:

$ grep monTexte -H `find . -name '*.xmap' `

Effacer des fichiers selon leurs noms:

$ find . -name '.svn' -exec rm -rf {} \;

Trouver les fichiers créés/modifiés depuis 20 jours:

for i in {0..20}; do find . -ctime $i -type f; done

OS: Mandrake 10.0

Commande:

Affiche les noms de fichiers et la ligne

$ grep 'monTexte' *.txt

N'afficher que les noms de fichiers

$ grep -l 'monTexte' *.txt

En incluant les sous-répertoires

$ grep -r 'monTexte' *.txt

grep récursif sous Unix / Solaris

find . -type f -print | xargs grep monTexte

OS: Mandrake 10.0

Commande:

mv [OPTION]... SOURCE DEST
mv [OPTION]... SOURCE... DIRECTORY

OS: Mandrake 10.0

Créer un lien symbolique, à peu près équivalant à un raccourcis sous windows.

Commande:

ln -s /home/nicolas/applications/realplayer/realplay /usr/bin/realplay

avec /home/nicolas/applications/realplayer/realplay = fichier source et /usr/bin/realplay = lien symbolique

OS: Linux

De temps en temps, sous le shell, il est nécessaire de se déplacer dans un dossier pour faire une action rapide, puis de revenir dans le dossier de départ.

On est tenté par faire:

$ cd /le/nouveau/dossier $ … $ cd /le/dossier/de/depart

Cela oblige à écrire le chemin du dossier de départ.

En fait, il y a plus efficace avec les commandes pushd et popd:

$ pushd /le/nouveau/dossier
$ ...
$ popd

pushd nous déplace dans le dossier, comme cd, mais en même temps, garde le dossier de départ en mémoire pour la commande popd qui nous ramène dans celui-ci.

Note:

Un moyen encore plus simple est d'utiliser

cd -

qui fait revenir dans le dossier précédent

OS: Linux

Commande:

mount -t ntfs /dev/hda1 /mnt/windows/

- Pour Windows XP, le type est ntfs - Le premier disque dur est /dev/hda - Le répertoire monté est /mnt/windows

OS: Linux

Commande:

tar czvf monarchive.tar.gz mondossier

Ex:

tar czvf unigeDB.tar.gz ./unigeDB/

Décompression:

Pour un fichier tar.gz

tar xvzf nom_du_fichier.tar.gz

Pour un fichier tar bz2

tar xvjf nom_du_fichier.tar.bz2

x = extract, z = gzip, j = bzip2

Sous Solaris:

Décompresser une archive tar.gz:

gtar -zxf nom_du_fichier.tar.gz

OS: Linux

Problème:

Comment synchroniser facilement le contenu de deux dossiers, en mettant à jour le deuxième à partir du premier ? En ne tenant compte que des fichiers .class par exemple ?

Commande:

[user@alaxoscom.yourwebhostingmysql.com dossierRacine] rsync -rv --include  "*/" --include="*.class" --exclude="*" ./ ../../../dossierRacine/

• descend dans le répertoire courant: ./
• exclut tous les fichiers, sauf ceux du type *.class

Simuler une mise à jour du balladeur IAUDIO depuis le pc:

rsync -rvtun --modify-window=1 /home/rodn/Musique/MUSIC/ /media/IAUDIO/MUSIC/
rsync -rvtun --modify-window=1 /media/IAUDIO/MUSIC/ /home/rodn/Musique/MUSIC/

Puis réellement faire la mise à jour:

rsync -rvtu --modify-window=1 /home/rodn/Musique/MUSIC/ /media/IAUDIO/MUSIC/
rsync -rvtu --modify-window=1 /media/IAUDIO/MUSIC/ /home/rodn/Musique/MUSIC/

(= sans l'option n)

l'option –modify-window=1 permet de détecter les différence de temps des fichiers de manière moins précise (defaut = 0), ce qui permet de gérer certains problèmes entre les différents systèmes de fichier

Faire ensuite de même en inversant les chemins (balladeur –> pc)

Copier un dossier contenant des liens symboliques

utiliser l'option -a qui copie le dossier en temps qu'archive

rsync -avz /path/to/folder1 /path/to/folder2

Problème de l'heure d'été/hiver:

En fonction du type de filesystem, il peut arriver que certains disques montrent des différences d'une heure entre des fichiers synchronisés après un passage à l'heure d'hiver/d'été. Dans ce cas, la synchronisation en fonction du temps ne peut plus se faire.

Une manière de régler le problème est de mettre à jour les heures des fichiers en utilisant le script suivant:

#!/usr/bin/perl
use strict;
 
my $offset = shift() + 0;
die "Usage: $0 OFFSET_SECONDS\n" unless $offset;
 
while (<>) {
    chomp;
    my $mtime = (stat $_)[9];
    next unless $mtime;
    $mtime += $offset;
    utime $mtime, $mtime, $_;
}

qui se lance de cette manière:

find . -type f ! -newer /tmp/cmpfile | shifttime.pl 3600

A noter que la mise à jour du temps peut être faite dans l'autre sens avec -3600

OS: Mandrake 10.1

Commande:

mount -t vfat /dev/sda /mnt/cleusb/

• La majorité des clés USB utilise le système de fichier fat
• La clé est reconnue comme un périphérique SCSI, et est donc accessible sous /dev/sda

OS: Linux

Problème:

Après création d'une nouvelle partition, comment savoir à quel “fichier” elle correspond, de manière à la monter ?

Commande:

fdisk -l /dev/hda

Ce qui donne par exemple:

Disk /dev/hda: 40.0 GB, 40020664320 bytes
255 heads, 63 sectors/track, 4865 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
 
   Device Boot      Start         End      Blocks   Id  System
/dev/hda1   *           1        1095     8795556    7  HPFS/NTFS
/dev/hda2            1096        4865    30282525    f  W95 Ext'd (LBA)
/dev/hda5            3061        4865    14498631   83  Linux
/dev/hda6            1096        1217      979902   82  Linux swap / Solaris
/dev/hda7            1218        2190     7815591   83  Linux
/dev/hda8            2191        3060     6988243+  83  Linux
 
Partition table entries are not in disk order

OS: Linux Problème:

Comment lire un string encodé un base64 ?

Solution:

Une commande existe sous Linux pour encoder un fichier binaire de manière à ce que le résultat ne contienne que des caractères ASCII imprimables. Cela permet par exemple d'envoyer un fichier binaire par email. (il ne peut y avoir que des caractères ASCII dans le contenu d'un mail)

Il s'agit de:

uuencode -m file_to_encode.txt

A l'inverse, pour décoder une chaîne de caractères encodée en base64, on peut utiliser:

uudecode file_to_decode.txt

Astuce:

uuencode -m rajoute avant le résultat codé un signal de début d'encodage et des signes '=' après le résultat. Pour décoder une chaîne de caractères base64, on peut:

1. créer un fichier to_decode.txt
2. coller les caractères encodés
3. ajouter une ligne signal en début
4. ajouter une ligne avec les signes '=' à la fin
5. utiliser uudecode

Ex de fichier to_decode.txt

begin-base64 644 to_decode.txt
Q2UgdGV4dGUgZXN0IGVuY29k6SBlbiBiYXNlNjQK

—

$uudecode to_decode.txt
$less to_decode.txt

Solution alternative en Python:

python -c "print __import__('base64').b64decode('c2FsdXQ=')"

OS: Linux

Problème:

Comment modifier l'encodage d'un fichier, par exemple modifier index.php encodé en UTF-8 vers index_iso.php encodé en ISO 8859-1

Commande:

user@alaxoscom.yourwebhostingmysql.com:~$ iconv -f UTF-8 -t ISO8859-1 -o index_iso.php index.php

-f 'from' -t 'to'

Modification récursive du contenu d'un dossier:

Au moyen d'un script:

#!/bin/bash
 
# à lancer dans le répertoire dans lequel on veux modifier l'encodage des fichiers
# Eventuellement, rajouter l'option -name "*.extension" à la commande find
 
for i in `find . -type f`
do
    iconv -f ISO8859-1 -t UTF-8 $i > temp.tmp && cat temp.tmp > $i && rm temp.tmp
done

OS: Linux

Problème:

Comment repérer dans un fichier les caractères qui ne sont pas des caractères ASCII ?

Solution:

En utilisant une option de cat:

cat -v my_file.txt | grep "M-"

OS: Linux

Problème:

Comment remplacer des caractères UTF-8 affichés en ISO-8859-1 dans un fichier ?

C'est à dire comment retrouver les caractères accentués dans un fichier contenant des caractères tels que à , é, è et autres ê ?

Solution:

En utilisant le script suivant:

#!/bin/bash
 
#two chars to replace
sed -i 's/Ã /à/g' $1 # this one may be confused with a word ending by í
sed -i 's/á/á/g' $1
sed -i 's/â/â/g' $1
sed -i 's/ä/ä/g' $1
sed -i 's/ã/ã/g' $1
sed -i 's/é/é/g' $1
sed -i 's/è/è/g' $1
sed -i 's/ê/ê/g' $1
sed -i 's/ë/ë/g' $1
sed -i 's/ẽ/ẽ/g' $1
sed -i 's/ì/ì/g' $1
sed -i 's/î/î/g' $1
sed -i 's/ï/ï/g' $1
sed -i 's/Ä©/ã/g' $1
sed -i 's/ò/ò/g' $1
sed -i 's/ó/ó/g' $1
sed -i 's/ô/ô/g' $1
sed -i 's/ö/ö/g' $1
sed -i 's/õ/õ/g' $1
sed -i 's/ù/ù/g' $1
sed -i 's/ú/ú/g' $1
sed -i 's/û/û/g' $1
sed -i 's/ü/ü/g' $1
sed -i 's/Å©/ũ/g' $1
 
#one char to replace
sed -i 's/Ã/í/g' $1

OS: Linux, Solaris

Problème:

Comment faire une sauvegarde rapide et conserver les versions d'un fichier que l'on modifie régulièrement ?

Commande:

user@alaxoscom.yourwebhostingmysql.com:~$ saveback fichier.txt

→ crée une copie fichier.txt.01, puis fichier.txt.02, etc…

Script 'saveback':

#!/bin/csh -f
 
# script to backup a file.
# foo -> foo.dd where dd are two decimal digits
 
# Author: Dominique Petitpierre, University of geneva
 
# History:
# 1999.08.25: created
 
# To do:
# - see if it is not better to use "mv" than "cp -p"
# - should we check on writeability of the directory?
 
set Cmd=$0
set Cmd=$Cmd:t
if ($#argv != 1) then
   echo Usage: $Cmd:q file
   exit 1
endif
set f=$1:q
set i=1
set Suffix=0$i
set Lastsuffix="00"
while (-e $f:q.$Suffix )
  set Lastsuffix=$Suffix
  @ i++
  if ($i < 10 ) then
    set Suffix=0$i
  else
    set Suffix=$i
  endif
end
if ($Lastsuffix == "00" || ! { cmp -s $f:q $f:q.$Lastsuffix } ) then
  cp -p $f:q $f:q.$Suffix
endif

OS: Linux, Solaris

Problème:

Comment surveiller si de nouvelles lignes apparaissent dans un fichier (ex: fichier de logs)

Commande:

~$ tail -f /path/to/file

ou

~$ less /path/to/file

et faire “Shift + f”

Autre solution pour surveiller plusieurs fichiers dans le même terminal, installer le programme multitail:

~$ multitail /path/to/file1 /path/to/file2

OS: Linux

Problème:

Comment indenter correctement un fichier XML mal formaté ?

Commande:

~$ xmlindent -w bad_formatted_file.xml

OS: Linux

Problème:

Comment remplacer l'ensemble des tabulations par 4 espaces dans un fichier ?

Commande:

~$ expand -t 4 my_file.txt > _tmp_ && mv _tmp_ my_file.txt

et de manière récursive:

~$ find . ! -type d ! -name _tmp_ -exec sh -c 'expand -t 4 {} > _tmp_ && mv _tmp_ {}' \;