shell

(2*42+7)/44 ?? et en console

echo $[(2*42+7)/44]

Ca c'est pour les newbies (renvoie la valeur entière)

Pour les crapeaux il y a :

echo "(2*42+7)/44" | bc -l

(Renvoie un nombre a virgule flottante)

Ou par exemple :

echo "scale=1000;4*a(1)"|bc -l

(calcul les 1000 première décimale de pi, cf man)
Avec un peu plus de décimales ça peut faire des trucs sympa avec hot-babe (cf astuce manger du proce)

scale est la variable qui fixe la précision en nombre de décimale.

bc propose également une invite de commande plus intuitive que de faire des echo.

Calendrier dans la console

Utiliser cal du package util-linux

$ cal
     juin 2008      
di lu ma me je ve sa
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30

Convertir format d'image

Un des utilitaire du paquet imagemagick
Pour convertir tous les .gif du répertoire courant en png par exemple :

mogrify -format png *.gif

Il y a aussi convert.

convert *.jpg result.pdf

Créer un pdf nommé result qui contient une image jpg par page, dans l'odre alphanumérique. Pratique pour réaliser des fichiers pdf à partir de scan...

Envoyer un mail en bash (et telnet)

Il y a bien sur la commande mail (du package mailx)

Mais peut mieux faire :D
À partir de maintenant ça pourrait presque se retrouver dans la rubrique lokis (s/lokis/useless/)

Utilisation de telnet et des fifos. Oui il y a plus simple mais ça permet de comprendre comment fonctionne tout ça

Création des fichiers de pile

  1. $ mkfifo in
  2. $ mkfifo out

Premier script bash

  1. (while [ true ]
  2. do
  3. cat in
  4. done)|telnet mail.esiee.fr 25 > out

Oula mais qu'est-ce que ça fait tout ça ?
while [true] <= boucle infinie
cat in <= lit tout ce qu'il y a dans in pour le transmette dans le tube | telnet mail.esiee 25
telnet mail.esiee 25 >out ouvre une connexion sur mail.esiee.fr sur port 25 (smtp) et redirige la sortie dans le tube de sortie.

Jusque là rien de bien méchant.

Il ne reste plus qu'à envoyer ce qu'il faut dans le fichier "in".

  1. HELO MAN
  2. MAIL FROM:<trax@esiee.fr>
  3. RCPT TO:<givernao@esiee.fr>
  4. DATA
  5. le contenu du mail
  6. .
  7.  
  8. QUIT
  • Oui il n'y a qu'un seul et unique "L" à hello.
  • l'adresse de l'expéditeur, qui en l’occurrence n'existe pas mais ça ne dérange pas le serveur mail
  • l'adresse du destinataire, là c'est plus embêtant si elle n'existe pas
  • Balise annonçant le corps du mail
  • Corps du message, pour ajouter un sujet, modifier l'adresse de réponse, changer la date du mail... Voir entête MIME
  • Un point "." entre deux retours à la ligne signifie la fin du mail
  • Ne pas oublier de dire au revoir au serveur ;)

Eviter les rm -fr * désatreux

$ > -i

Crée un fichier nommé "-i"

$ rm -fr *
rm: détruire fichier régulier vide `plop'?

Tout bêtement ça fait :

rm -fr -i plop

Kicker quelqu'un d'une machine

Bien évidement il faut avoir les droits pour (rien de mieux qu'être root pour ça)

pkill -5 -u lokis

pkill envoie le signal donnée au processus choisis

  • -5 : envoie le signal 5 (on peut faire plus brutale avec le signal 9)
  • -u lokis : sélectionne l'utilisateur lokis

En somme ça envoie le signal 5 à tous les processus de lokis
Tous ses programme se ferme y compris sa session :)

Le shell en couleur c'est plus plus mieux

Voici une petite fonction bash qui permet d'afficher les principales couleurs de base à savoir noir, rouge, vert, jaune, violet, cyan et blanc.

Mais il faut comprendre comment il est possible de mettre des couleurs en bash.
on commence toujours par une séquence d'échappement : \e[ (ou \033[); il faut aussi indiquer qu'on termine la séquence avec le caractère "m" (sans les quotes).
Exemple :

echo -e "\e[0;33m blabla"

devrait afficher blabla en jaune (enfin jaune c'est approximatif). Ici 0;33 correspond à la couleur jaune justement.

Sans plus attendre le script qui affiche les couleurs de base :

black='\e[0;30m' # Black - Regular
red='\e[0;31m' # Red
green='\e[0;32m' # Green
yellow='\e[0;33m' # Yellow
blue='\e[0;34m' # Blue
purple='\e[0;35m' # Purple
cyan='\e[0;36m' # Cyan
white='\e[0;37m' # White
bldblack='\e[1;30m' # Black - Bold
bldred='\e[1;31m' # Red
bldgreen='\e[1;32m' # Green
bldyellow='\e[1;33m' # Yellow
bldblue='\e[1;34m' # Blue
bldpurple='\e[1;35m' # Purple
bldcyan='\e[1;36m' # Cyan
bldwhite='\e[1;37m' # White
ublack='\e[4;30m' # Black - Underline
ured='\e[4;31m' # Red
ugreen='\e[4;32m' # Green
uyellow='\e[4;33m' # Yellow
ublue='\e[4;34m' # Blue
upurple='\e[4;35m' # Purple
ucyan='\e[4;36m' # Cyan
uwhite='\e[4;37m' # White
bblack='\e[40m'   # Black - Background
bred='\e[41m'   # Red
bgreen='\e[42m'   # Green
byellow='\e[43m'   # Yellow
bblue='\e[44m'   # Blue
bpurple='\e[45m'   # Purple
bcyan='\e[46m'   # Cyan
bwhite='\e[47m'   # White
rst='\e[0m'    # Text Reset
 
function colors
{
    echo -e "\t 0\t 1\t 4\t"
    echo -e "30\t ${black}black${rst}\t ${bldblack}black${rst}\t\
${ublack}black${rst}\t ${bblack}black${rst}"
    echo -e "31\t ${red}red${rst}\t ${bldred}red${rst}\t\
${ured}red${rst}\t  ${bred}red${rst}"
    echo -e "32\t ${green}green${rst}\t ${bldgreen}green${rst}\t\
${ugreen}green${rst}\t  ${bgreen}green${rst}"
    echo -e "33\t ${yellow}yellow${rst}\t ${bldyellow}yellow${rst}\t\
${uyellow}yellow${rst}\t  ${byellow}yellow${rst}"
    echo -e "34\t ${blue}blue${rst}\t ${bldblue}blue${rst}\t\
${ublue}blue${rst}\t  ${bblue}blue${rst}"
    echo -e "35\t ${purple}purple${rst}\t ${bldpurple}purple${rst}\t\
${upurple}purple${rst}\t  ${bpurple}purple${rst}"
    echo -e "36\t ${cyan}cyan${rst}\t ${bldcyan}cyan${rst}\t\
${ucyan}cyan${rst}\t  ${bcyan}cyan${rst}"
    echo -e "37\t ${withe}white${rst}\t ${bldwhite}white${rst}\t\
${uwhite}white${rst}\t  ${bwhite}white${rst}"
}

On peut le mettre dans son .bashrc et taper colors au prompt pour voir la liste des couleurs.
Évidemment j'aurais plus faire une fonction plus jolie, mais bon pas envie.

Comment lire le "tableau" :
En haut nous avons la fonte utilisée : 0 pour normal, 1 pour gras, 4 pour souligné et rien pour la couleur de fond.
Au début de chaque ligne le numéro correspondant à la couleur.
Enfin la séquence "\e[0m" permet de remmettre le formatage du texte à zéro.

Lister les id existants

getent passwd |cut -f3 -d: | sort -n

Qui est loggé sur la machine

Trois commandes au choix

finger
who
users
w 

J'ai une petite préférence pour finger (package netkit-fingerd)
"w" permet de savoir qui fait quoi

Remplacer dans des fichiers

Utiliser

replace plop bonjour plip salut -- lefichier

qui remplacera plop par bonjour et plip par salut.
Bien sur il n'est pas obligé de mettre deux paires ; il est également possible d'en mettre plus que deux.

Combiné avec la commande find ça peut donner un truc intéressant :)

find . -iname "*\.[ch]" -exec replace furet trax -- '{}' \; 

Mais replace c'est quand même pour les petits joueurs : les presque crapeaux utiliseront sed qui accepte les expressions régulière

find . -iname "*\.[ch]" -exec sed -i"s/furet/trax" -- '{}' \; 
  • -i :remplace directement dans le fichier
  • "s/furet/trax/" : remplace furet par trax

Se reveiller en musique

TUUUUUUUUUUUUTE TUUUUUUUUUUUUUUUTE TUUUUUUUUUUUUTE

Qu'est ce que ça peut être désagréable de se faire reveiller par le son argneux du reveil offert par votre maman (histoire que vous soyez en cours le matin), Par contre se faire reveiller par Korn ça permet de commencer une bonne journée :

Solutiion :
Utiliser cron (gentoo conseil vixie-cron)

Il faut savoir que cron a un accès très réduit au variables d'environnement

Utiliser

crontab -e

Pour se reveiller a 10h tous les matins

#min | hour | (jour du mois) | mois | (jour de la semaine)
0 10 * * * /usr/bin/playsound /home/trax/Desktop/zikC/era/era1/01_-_Ameno_remix.flac

Verrouiller un tty ou un terminal graphique

On utilise vlock, qui a beaucoup d'avantages par rapport à ses concurents.
On verrouille donc sont tty avec la commande suivante :

0 furet@woodstock ~ $ vlock
This TTY is now locked.
 
Please press [ENTER] to unlock.
furet's Password:
vlock: Authentication failure
root's Password:

Pour déverrouiller le tty il suffit d'entrer son password et le tour est joué.
Note :

  • Le root peut déverrouiller le tty
  • Cette astusce marche aussi avec des terminaux graphiques comme xterm, gnome-term, konsole… mais présente un intérêt moindre, à moins d'être fan des openroot xterm…
  • rm sans faire de bêtises

    Effacer un fichier n'est pas un gros soucis depuis une interface graphique. Par contre depuis la console c'est une autre histoire puisque les fichiers sont définitivement perdus, sans passer par la case cobeille. Je vous propose donc une commande rm un peu plus sûre, qui va déplacer les éléments dans le /tmp/ (ou tout autre dossier considéré comme dossion “poubelle”) plutôt que de les supprimer sans merci, de façon journalisée.

    Le script

    Le bash c'est pas mon truc. Cette fois, ce sera du perl. Pour cela il faut vérifier que perl soit bien installé (pas forcément besoin d'une version récente). On peut le vérifier par la commande suivante :

    $ perl -v

    Le script est fourni en pièce jointe.
    Personnellement, redéfinir la commande rm ne me plaît pas trop, j'ai donc nommé le script “rl”, qui est tout aussi facile à tapper que rm et qui a le mérite de conserver ma commande rm en cas de bug caché de rl.

    Par défaut rl déplace les éléments dans /tmp, qui se vide à chaque démarrage. Pour changer ce dossier, il faut modifier la ligne 5 du script :

    my $trash="/tmp";

    Pour faire référence à la home de l'utilisateur pour changer le dossier de destination (le dossier poubelle), je conseille de préférer l'écriture “/home/vulpo/Trash” plutôt que “~/vulpo/Trash”, cette syntaxe n'étant pas géré par le script. Exemple :

    my $trash=”/home/vulpo/Trash”

    Bien sûr, il faut posséder les droits d'accès en écriture sur ce dossier.

    Utilisation

    Le script se lance comme un programme ordinaire. Cependant, pour pouvoir lancer le script seulement en tappant :

    $ rl dossiersaeffacer

    Il faut que le PATH sache où trouver le script (normal, me direz-vous). La commande suivante indique les dossiers connus du PATH, séparés par ':' :

    $ echo $PATH

    Si un des dossiers connus du PATH vous est accessible, par exemple si vous avez les droits root pour écrire dans le dossier /usr/bin, c'est là qu'il faudra déplacer le script rl.
    Si aucun des dossiers n'est accessible, vous devez étendre le PATH sur un autre dossier. On peut par exemple ajouter le dossier ~/Scripts au PATH, où seront déposés tous vos scripts.

    $ mkdir ~/Scripts
    $ export PATH=~/Scripts:$PATH

    Puis déplacer rl dans le dossier ~/Scripts.
    Ne pas oublier de disposer des bons droits pour le script :

    $ chmod /usr/bin/rl 755 #dans le cas où rl est dans /usr/bin

    Sans quoi bash peut ne pas réussir à exécuter le script.

    Exemples

    L'exécution du script est tout à fait banale. Exemples :

    $ rl fichier #fonctionne aussi avec sudo
    $ rl test/* #le script accepte les wildcards
    $ rl -v test/fichier #l'option -v pour activer le mode verbose (affichage)
    $ rl -h #affiche l'aide

    Conclusion

    Rl est plus sécurisé que rm parce qu'il ne supprime pas les dossiers, et qu'il propose une gestion des fichiers journalisée. Si le dossier de destination n'est pas le /tmp, ou que le système n'est pas destiné à être redémarré régulièrement, il peut être judicieux d'archiver automatiquement le dossier poubelle, en couplant le script avec un cron par exemple.
    Si jamais vous trouvez des bugs ou si vous avez des conseils sur le design du code, je suis tout à fait intéressé !

    Domaine: 
    Fichier attachéTaille
    Icône texte brut Script perl rl. A renommer en "rl".1.73 Ko