Pour les scripts : c'est ici

Pratique, j’en avais justement besoin ce matin !!!
J’ai refait un peut la coquille :

#!/usr/bin/perl

use strict;
use Net::Ping;

$|++;
print "Scan des ordinateurs :\n";

my $nb = 0;
my $boucle = 0;
my $ping = Net::Ping->new("icmp", 0.3);

foreach my $i ( 1 .. 254 ){
  if ($ping->ping("192.168.1.".$i)){
    ++$nb;
    print "192.168.1.$i\n";
  }else{
        if ($boucle==4) {$boucle=0; }
        if ($boucle==0) {print "|\b";}
        if ($boucle==1) {print "/\b";}
        if ($boucle==2) {print "-\b";}
        if ($boucle==3) {print "\\\b"; }
        ++$boucle;
      }
}
$ping->close();

print "Il y a $nb ordinateurs sur le réseau local.\n";

J’y connais rien en Perl, j’ai improvisé :wink:

#!/usr/bin/perl

use strict;
use Switch;
use Net::Ping;

$|++;
print "Scan des ordinateurs :\n";

my $nb = 0;
my $boucle = 0;
my $ping = Net::Ping->new("icmp", 0.3);

foreach my $i ( 1 .. 254 ){
  if ($ping->ping("192.168.1.".$i)){
    ++$nb;
    print "192.168.1.$i\n";
  }else{
    switch($boucle %= 4){
      case 0 {print "|\b";}
      case 1 {print "/\b";}
      case 2 {print "-\b";}
      case 3 {print "\\\b";}
      case 4 {}
    }
  }
}
$ping->close();

print "Il y a $nb ordinateurs sur le réseau local.\n";

Pas testé mais ça devrais marcher.

[edit par ashgenesis]Il manquait un ; après ++$nb[/edit]

#!/usr/bin/perl

use strict;
use Switch;
use Net::Ping;

# Initialisation

sub sizetot ()
{
  return `stty -a | grep columns | cut -d ' ' -f7 | tr -d ';'` - 7;
}

my $nb = 0;
my $boucle = 0;
my $ping = Net::Ping->new("icmp", 0.3);

my $pourcent = 0;
my $bar = "[]";
my $size = 0;

$|++;

# Déroulement
print "Scan des ordinateurs :\n";

print "$bar";
foreach my $i ( 1 .. 254 ){
  $size=$i/254*sizetot();
  $pourcent=int($size/sizetot()*100);
  my $u = length($bar) + 5;
  if ($pourcent > 9){
    ++$u;
  }

  if ($ping->ping("192.168.1.".$i)){
    ++$nb;
    print "\b" x $u;
    print " " x ($u + 1);
    print "\b" x ($u + 1);
    print "192.168.1.$i\n";
  }

  print "\b" x $u;
  print " " x ($u + 1);
  print "\b" x ($u + 1);
  $bar = ("=" x $size);
  print "[$bar>]$pourcent%";
}
$ping->close();

print "\nIl y a $nb ordinateurs sur le réseau local.\n";

J’avais dans l’idée de montrer un petit exemple d’utilisation de GTKDialog, mais la modification apporté par ash dans mon précédent post m’a donné envie d’améliorer le scanneur. Alors voila le nouveau possède une jolie barre de progression. :slightly_smiling:

#!/bin/sh

function affiche (){
retour=`gtkdialog --program=MAIN_DIALOG | awk -F\" '{ print $2}'` # | grep 'Lire le mail'

if [ "$retour" == 'Lire le mail (web)' ]; then
  iceweasel -new-tab 'http://www.gmail.com'
fi

if [ "$retour" == 'Lire le mail (claws)' ]; then
  sylpheed-claws-gtk2 &
fi
}

export MAIN_DIALOG='
<window title="Nouveau mail" icon-name="help">
<vbox>
  <text>
    <label>Il y a un nouveau mail</label>
  </text>
  <hbox>
  <vbox>
    <button>
      <label>Lire le mail (web)</label>
    </button>
    <button>
      <label>Lire le mail (claws)</label>
    </button>
  </vbox>
  <button>
    <label>Exit</label>
  </button>
  </hbox>
</vbox>
</window>'

affiche

Voici le script GTKDialog, il me sert en fait pour quand j’ai un mail. Le notifier l’exécute. J’arrive pas à positionner la fenêtre où je veux sur l’écran mais c’est pas grave.

Pour reparler du wiki, si certains sont prêt à m’aider je veux bien me lancer pour en mettre un sur pied. Parce que moi qui débute sous Debian, ça me manque bcp par rapport à Ubuntu.

Avis aux amateurs.

je peux aider de temps en temps et plus une fois que j’aurai récupéré mon nouveau job et fini mes stages de perfectionnement en anglais… :slightly_smiling:

Mieux vaut compléter celui là : wiki.debian.org/PageD’Accueil
Disperser les informations est une mauvaise idée.

Fait longtemps que j’ai pas contribué :s

Aller hop un ch’tit script :slightly_smiling:

#!/bin/bash
##
#
# But : Outil de crytpage/decryptage de fichier
#
##
#set -x
###########################################################
#                      Fonctions                          #
###########################################################

encrypt()
{
    gpg --passphrase-fd coucou --output $2 --symmetric --cipher-algo AES192 $1
}

decrypt() {
    gpg --output $2 --decrypt $1
}

usage() {
    echo "usage : krytpme.sh [-c|-d|-h] <Fichier_De_Entree> <Fichier_De_Sortie>"
    echo ""
    echo "      -h    : Description de la syntaxe"
    echo "      -c    : Permet de crypter un fichier"
    echo "      -d    : Permet de decrypter un fichier"
}

check() {
    if [ $? = 0 ]
    then
        echo "OK :)"
    else
        echo "KO :("
    fi
}

###########################################################
#                      Main                               #
###########################################################

case $1 in
    -c)
        encrypt $2 $3
        check
        ;;
    -d)
        decrypt $2 $3
        check
        ;;
    *)
        usage
        ;;
esac

Bon c’est sur c’est pas un truc de bardu mais je vais le faire évoluer :slightly_smiling:

Bonjour,

J’ai fait mon propre script pour savoir le nombre d’ordinateurs sur le réseau suite à la lecture de vos scripts, mais plutôt que de lancer un seul ping à la fois, je bourrine un peu. :laughing:

#!/bin/sh

# network
IP_PREFIX=192.168.0
# for temporary file
TMP_FILE=/var/tmp/.ping_count

# send $PING_NUMBER "ECHO_REQUEST" packets (-c ping option)
PING_NUMBER=1

# ~500 process for 100
MAX_SIMULTANEUS_PING=130


if [ -e $TMP_FILE ]
then
    echo "abort! file $TMP_DIR/.ping_count exits."
    exit 1
fi
touch $TMP_FILE

# all ip
for i in $(seq 1 254)
do
    if [ $(ping -c$PING_NUMBER $IP_PREFIX.$i \
        | grep -e 'bytes from' | wc -l ) \
        -ne 0 ]
    then
        echo $IP_PREFIX.$i
        echo "1" >> $TMP_FILE
    fi &

    if [ $(jobs | grep ping | wc -l) -gt $MAX_SIMULTANEUS_PING ]
    then
        wait $(jobs -p | head -n1)
    fi
done

while [ $(jobs -p | wc -l) -ne 0 ]
do
        wait $(jobs -p | tail -n1)
done

echo "$(wc -l < $TMP_FILE) computer(s)"
rm $TMP_FILE

La sortie :

$ time ./network\ count.sh
192.168.0.1
192.168.0.2
192.168.0.3
192.168.0.30
192.168.0.104
192.168.0.254
6 computer(s)

real    0m8.307s
user    0m0.680s
sys     0m1.688s

J’ai fait un script pour créer un utilisateur limité au sftp et chrooté.
Ca me permet de partager facilement des fichiers…
Le chroot est fait manuellement, l’utilisateur se logue via un shell limité au sftp (rssh)
Dans mon cas je ne permets que l’authentification par clé, que je rajoutes après.

Il faut avoir installé les paquets openssh-server et rssh.
J’ai créé un groupe “ftp” aussi, pour qu’ils soient dans le même groupe, et j’ai mis mon compte dedans, pour pouvoir écrire directement dans le dossier sans être root.

#!/bin/sh
#
# addftpuser - Ajoute un utilisateur sftp chrooté dans son home

if [ "$#" != 1 ] ; then
	echo "Usage : addftpuser [USER]"
	exit 0 ;
fi

user=$1
local=kna # mon login, pour me connecter en local

# Création du compte
adduser $user --ingroup ftp --shell /usr/bin/rssh
cd /home/$user
rm .bash* # à modifier selon votre /etc/skel

# Copie de sftp-server et de ses dépendances
mkdir -p usr/lib/openssh
mkdir -p lib/i686/cmov
mkdir -p usr/lib/i686/cmov

cp /usr/lib/openssh/sftp-server usr/lib/openssh/

# Faites un ldd /usr/lib/openssh/sftp-server
# pour être sûr que c'est les mêmes fichiers chez vous !
cp /lib/i686/cmov/libresolv.so.2 lib/i686/cmov/
cp /usr/lib/i686/cmov/libcrypto.so.0.9.8 usr/lib/i686/cmov/
cp /lib/i686/cmov/libutil.so.1 lib/i686/cmov/
cp /usr/lib/libz.so.1 usr/lib/
cp /lib/i686/cmov/libnsl.so.1 lib/i686/cmov/
cp /lib/i686/cmov/libcrypt.so.1 lib/i686/cmov/
cp /usr/lib/libgssapi_krb5.so.2 usr/lib/
cp /usr/lib/libkrb5.so.3 usr/lib/
cp /usr/lib/libk5crypto.so.3 usr/lib/
cp /lib/libcom_err.so.2 lib/
cp /lib/i686/cmov/libc.so.6 lib/i686/cmov/
cp /lib/i686/cmov/libdl.so.2 lib/i686/cmov/
cp /usr/lib/libkrb5support.so.0 usr/lib/
cp /lib/libkeyutils.so.1 lib/
cp /lib/ld-linux.so.2 lib/

# n'apparait pas dans le ldd, mais nécessaire :
# (j'ai galéré pour la trouver)
cp /lib/libnss_files.so.2 lib/ 

# Copie des fichiers de conf
mkdir etc
cat /etc/passwd | grep $user > etc/passwd
cat /etc/group | grep ftp > etc/group

# Création de /dev/null
mkdir dev
mknod dev/null c 1 3 -m 666

# Ajout de l'entrée dans /etc/rssh.conf
echo -e "user=$user:002:00010:\"/home/$user\"" >> /etc/rssh.conf
# umask=002, limité au sftp, chrooté dans son home

# Ajout d'une clé pour se connecter en local
mkdir .ssh
echo "# localhost" > .ssh/authorized_keys
cat /home/$local/.ssh/id_dsa.pub >> .ssh/authorized_keys
echo -e "\n" >> .ssh/authorized_keys
echo "# $user" >> .ssh/authorized_keys 
# Comme ca j'ai plus qu'a faire un :
# cat /chemin/vers/la/clé >> /home/$user/.ssh/authorized_keys
# quand je récupères la clé publique du client

chown -R $user:ftp .ssh
chmod 500 .ssh
chmod 400 .ssh/authorized_keys

# Création d'un dossier "files"
mkdir files

# là je fais une liste de cp vers le dossier files
# à adapter selon l'usage
# On peut aussi faire un mount --bind :
# echo "dossier_à_monter /home/$user/files none bind,defaults,auto,ro 0 0" >> /etc/fstab
# à vérifier tout de même (pas testé)

chown -R $user:ftp files
chmod 775 files
chmod 665 files/*

J’ai rajouté quelques commentaires pour le “portage”

Dans les différents tutos que j’ai lu, ils copiaient aussi scp et sftp (ainsi que leurs libs). Mais apparement pas besoin.
En même temps c’est logique, c’est chez le client…

Et puis pour bien faire, il faut pouvoir supprimer l’utilisateur :

#!/bin/sh
#
# delftpuser - Supprime un utilisateur sftp

if [ "$#" != 1 ] ; then
	echo "Usage : delftpuser [USER]"
	exit 0 ;
fi

user=$1


# Suppression du compte
deluser $user
rm -r /home/$user


# Suppression de l'entrée dans /etc/rssh.conf
sed -e "/$user/d" /etc/rssh.conf > /etc/rssh.new
mv /etc/rssh.new /etc/rssh.conf

Voici un petit script permettant de récupérer une vidéo sur Youtube et la visionner sans avoir quelconque besoin de Flash/Gnash.
Nécessite mplayer ou n’importe quel player permettant de lire les .flv

#!/bin/bash

filename=$(date +%s)
vars=$(wget -qO- "$1" | grep -F watch_fullscreen | cut -d \? -f2 | cut -d \" -f1)
wget -O$filename "http://youtube.com/get_video?$vars"
mplayer $filename

exit 0[/code]
Utilisation: [code]scriptname http://www.youtube.com/watch?v=_RyodnisVvU

La vidéo est téléchargée dans le ~ (/home/user) et s’appellera $(unixtime)
Enjoy!

Un petit script pour Nautilus, cette fois-ci.
Permet de créer des liens http prêts à coller dans un texte/messenger/chan IRC par 2 clics sur un fichier.
Ce script marchera chez vous au cas par cas.
Nécessite un server web, xsel et zenity.
Je prends l’exemple de mon cas personnel pour vous expliquer au mieux comment modifier le script chez vous.
Sur mon bureau, j’ai un dossier ‘downloads’ dans lequel je mets des documents accessible au public via l’adresse mondomainname.org/downloads
Quand j’ai besoin de montrer ou envoyer un document à quelqu’un, plutôt que de taper mondo…. fichier.zip, je clique sur le document en question dans ‘downloads’, puis Script -> File2link (nom de mon script). l’adresse http est créée par le script, et envoyée dans le clipboard; je n’ai plus qu’à coller l’adresse où j’en ai besoin.
Script en question:

#!/bin/bash

	for F in $NAUTILUS_SCRIPT_SELECTED_URIS; do
		if [[ $(echo $F | cut -d'/' -f7) = 'downloads' ]]; then
			text="${text}"'http://mondomaine.org/'$(echo $F | cut -d'/' -f7-)$'\n'
		fi
	done	
	echo "$text" | xsel -ib && zenity --info --text='Ce qui suit vient d'\''etre placé dans le presse-papier:'$'\n'$'\n'"${text}"

exit 0[/code]
Ce script est à placer dans .gnome2/nautilus-script, il sera alors accessible dans clic-droit sur fichier -> Scripts.
Pour le modifier à votre sauce, vous devez changer les occurences à 'downloads' et à '-f7' dans les 'cut'
Quand je clique sur un fichier, la variable $F prend la valeur
[code]file:///home/tukuyomi/Desktop/downloads/fichier.zip[/code]
Le bloc suivant devra être modifié:
[code]if [[ $(echo $F | cut -d'/' -f7) = 'downloads' ]]; then
	text="${text}"'http://mondomaine.org/'$(echo $F | cut -d'/' -f7-)$'\n'
fi

‘downloads’ parce que mon dossier public s’appelle comme ça
-f7 et -f7- parce que ‘downloads’ est en septième position dans $F, en prenant ‘/’ comme séparateur. Adaptez selon vos besoins!

Un petit script “pas fini” qui m’a permis d’installer zattoo_tv sur ma machine amd64.
Ce script permet de rappatrier depuis le pool, puis de déployer salement dans /emul/ia32-linux/ les libs 32 bits qui manquent au paquet ia32-lib pour faire tourner certaines applications.

[code]#!/usr/bin/perl -w
use strict;
use warnings;

use constant DEBIAN_MIRROR_ROOT_URI => “http://mirror.home-dn.net/debian-multimedia/”;
#use constant DEBIAN_MIRROR_ROOT_URI => “http://ftp.fr.debian.org/debian/”;
use constant DBG=>undef;

#use AptPkg;
use AptPkg::Config ‘$_config’;
use AptPkg::System ‘$_system’;
use AptPkg::Cache;

#use Net::FTP;

use File::Basename;

(my $self = $0) =~ s#.*/##;

initialise the global config object with the default values and

setup the $_system object

$_config->init;
$_system = $_config->system;

supress cache building messages

$_config->{quiet} = 2;

set up the cache

my $cache = AptPkg::Cache->new;
my $packages = $cache->packages;

die “Usage: $self PACKAGE …\n” unless @ARGV;

for my $packname (@ARGV) {
print “Paquet: $packname\n”;
my $pkgrec = ${packages}->lookup($packname);
if ($pkgrec) {

my ($filename,$filepath) = fileparse($pkgrec->{FileName});
$filename =~ s/amd64/i386/;
print "FileName: $filename\n";

my $uri = DEBIAN_MIRROR_ROOT_URI."${filepath}${filename}";
print "File URI: $uri\n";
if (!system("wget -c $uri".(DBG ? "" : " 2>&1 >/dev/null")))  {

if ( $ftp->get("${filepath}${filename}",${filename},-s ${filename}) ) {

  print "Telechargement termine.\n";
  print "Deploiement de $filename dans le chroot:\n";
  print "dpkg -X ${filename} /emul/ia32-linux) ->\n" if DBG;
  if ( system("dpkg -X ${filename} /emul/ia32-linux".(DBG ? "" : " 2>&1 >/dev/null")) ) {
    die "Echec du deploiement de $packname !\n";
  } else {
    print "Succes.\n";
  };
} else { warn "Echec du telechargement sur $packname.\n"};

} else { print “$packname est un paquet virtuel.\n”; }
print “\n”;
}

1;[/code]Bon, vous le verrez à l’usage, c’est crade.
Par exemple, pour installer zatootv, mon script s’appelant chez moi prep32.pl, j’ai du commencer par faire:

sudo ../prep32.pl libgtkglext1 libbonoboui2-0 libavahi-glib1 libavformat1d librsvg2-common libssl0.9.8 libavahi-common3 libcurl3 libgnome2-0 libdbus-1-3 libavahi-client3 libgnome-keyring0 libgnomeui-0 libdbus-glib-1-2 libfaad0 libcomerr2 libgnomevfs2-0 libkrb53 libmozjs0d libidn11 libkeyutils1 libnspr4-0d libxul0d libssh2-1puis comme certains paquets echouaient parcequ’ils ne venaient pas du dépot principal, j’ai dû aller modifier dans le script la valeur de DEBIAN_MIRROR_ROOT_URI , avant de faire un:

sudo ../prep32.pl libgnomeui-0 libmozjs0d libxul0dpour les rappatrier depuis un deuxiême dépot.

Par contre, aprés, je n’ai plus eu qu’a faire un dpkg -i --force-arch du paquet propriétaire 32bits de zattoo, et maintenant, j’ai la télé sur le net sur ma 64 bits.
Et ça peut marcher pour d’autres trucs, sans se casser la tête avec un chroot 32.

Un script pour convertir tous les wma d’un dossier en mp3, en préservant les tags :
(nécessite mplayer, lame, python-hachoir-metadata et mp3info)

#!/bin/sh

# Put extension in lower characters, if needed
[ -f *.WMA ] && rename 's/WMA/wma/g' *.wma

for i in *.wma ; do
    # Get metadata
    TITLE=`hachoir-metadata "$i" | grep 'Title' | sed 's/^-[[:blank:]]Title:[[:blank:]]//'`
    ARTIST=`hachoir-metadata "$i" | grep 'Author' | grep -v 'inconnu' | sed 's/^-[[:blank:]]Author:[[:blank:]]//'`
    ALBUM=`hachoir-metadata "$i" | grep 'Album' | sed 's/^-[[:blank:]]Album:[[:blank:]]//'`
    TRACK=`hachoir-metadata "$i" | grep 'Track[[:blank:]]total' | sed 's/^-[[:blank:]]Track[[:blank:]]total:[[:blank:]]//'`
    [ `echo $TRACK | wc -c -eq 2` ] && TRACK=0$TRACK
    GENRE=`hachoir-metadata "$i" | grep 'Comment:[[:blank:]]Genre' | sed 's/^-[[:blank:]]Comment:[[:blank:]]Genre=[[:blank:]]*//'`

    # Convert to mp3
    file=`echo "$i" | sed 's/\.wma$//'`
    echo $file
    mplayer -ao pcm:file="${file}.wav" "${file}.wma"
    lame -h "${file}.wav" "${file}.mp3"
    rm "${file}.wav"

    # Put metadata in mp3
    mp3info -t "$TITLE" "${file}.mp3" 2>>mp3info.log
    mp3info -a "$ARTIST" "${file}.mp3" 2>>mp3info.log
    mp3info -l "$ALBUM" "${file}.mp3" 2>>mp3info.log
    mp3info -n "$TRACK" "${file}.mp3" 2>>mp3info.log
    mp3info -g "$GENRE" "${file}.mp3" 2>>mp3info.log
    mp3info -c "" "${file}.mp3" 2>>mp3info.log

    # If mp3info returns errors, put the name of the file with the errors in log
    if [ "`cat mp3info.log`" != "" ]; then
        echo "* ${file}.mp3 :" >> error.log
        cat mp3info.log >> error.log
    fi
    rm mp3info.log

done

# If there are errors, display them
if [ -f error.log ]; then
    echo "----------------------------------------------------------"
    echo "Des erreurs ont été rencontrées pendant l'opération :"
    cat error.log
    rm error.log
fi

# Ask to delete original files
echo "Supprimer les .wma originaux ? (o/N)"
read suppr
if [ "`echo "$suppr" | tr '[:upper:]' '[:lower:]'`" = "o" ]; then
    rm *.wma
fi

Attention tout de même :

  • mplayer pose problème avec certains caractères dans les noms de fichier, comme la virgule (,), malgré les guillemets…
  • mp3info est très limité, il ne gère que les tags ID3v1, dans lesquels seulement certains genres sont permis (mp3info -G pour avoir la liste). D’où la récupération des erreurs dans mon script. De plus, il pose des problèmes de localisation (accents)
    Donc il faut parfois repasser un coup d’easytag derrière, mais ça mâche quand même pas mal le travail… :smt002

PS : je sais le ogg, c’est mieux, mais tous les appareils de le supportent pas… :unamused:

Pas besoin de lancer une usine à gaz pour graver un cd :

#!/bin/sh

CDROM=/dev/hdc
GRAVEUR=/dev/hdd

[ -f /tmp/image.iso ] && rm -f /tmp/image.iso
umount $GRAVEUR

if [ -d $1 ]; then
   echo -n "Entrer le nom de volume: "
   read label
   echo "*** Création de l'image ***"
   genisoimage -R -r -J --hide-rr-moved -V "$label" -o /tmp/image.iso $1
   echo "*** Lancement de la gravure ***"
   wodim -overburn -v dev=$GRAVEUR -data /tmp/image.iso
   rm -f /tmp/image.iso
   exit 1
fi

case $1 in
    clear)
        wodim -v dev=$GRAVEUR blank=fast 
        exit 1
        ;;
    cdrom)
        wodim -overburn -v  dev=$GRAVEUR -isosize $CDROM
        exit 1
        ;;
    *.iso)
        wodim -overburn -v dev=$GRAVEUR -data $1
        exit 1
        ;;
    *)
        echo "Usage: graver (cdrom|clear|<répertoire>|<image iso>)"
        exit 0
        ;;
esac

Un script particulièrement utile sur un serveur, il surveille les démons et les relance en cas d’absence. Ça m’a bien servi lors d’écroulement de serveur NFS, de pbm mémoire avec des taches tuées, de crashs de démons. Très pratique donc:

#!/bin/sh
#DELAI=120
PATH="/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/sbin:/sbin"
present()
{
#echo recherche de $1
CMD='ps ax | grep -E "^'$1' "'
#echo $CMD
LIGNE=`ps ax | grep -E "^ *$1 "`
# echo +$LIGNE+
[ ! -z "$LIGNE" ]
}
# bizarre ce qui suit coince des fois...
#present()
#{
#  ps $1 > /dev/null
#}

LISTE=`find /var/run -name "*.pid"`
#while /bin/true ; do
for f in $LISTE ; do
PID=`cat $f`
for p in $PID ; do
if ! present $p ; then
echo $p "("$f")" absent
LANCEUR=`grep $f /var/processus | awk '{print $2}'`
date
echo Relance de $LANCEUR
if [ -z $LANCEUR ] ; then 
    echo "Pas de moyen de lancer $f"
    rm $f
else
    logger Relance de $LANCEUR
    /etc/init.d/$LANCEUR stop
    /etc/init.d/$LANCEUR start
fi
#else
#echo $f pr<E9>sent
fi
done
done
LISTE2=`cat /var/nomprocessus | awk '{print $1}'`
for p in $LISTE2 ; do
if ! pidof -x $p > /dev/null ; then
echo $p  absent
LANCEUR=`grep $p /var/nomprocessus | awk '{print $2}'`
date
echo Relance de $LANCEUR
if [ -z $LANCEUR ] ; then 
    echo "Pas de moyen de lancer $f"
    rm $f
else
    logger Relance de $LANCEUR
    /etc/init.d/$LANCEUR stop
    /etc/init.d/$LANCEUR start
fi
fi
done
#sleep $DELAI
#done

On peut le faire tourner en permanence en décommentant la boucle while /bin/true ou en le mettant dans la crontab. À noter que la commande ps ne fonctionne pas toujours très bien, la fonction

present()
{
  ps $1 > /dev/null
}

ne marche pas avec le processsus identd. Pourquoi? Je n’en sais rien.
Chez moi, le fichier /var/processus contient

/var/run/bind/run/lwresd.pid    bind9
/var/run/bind/run/named.pid     bind9
/var/run/ypserv.pid     nis
/var/run/yppasswdd.pid  nis
/var/run/ypbind.pid     nis
/var/run/inetd.pid      openbsd-inetd
/var/run/spamd.pid      spamassassin
/var/run/sshd.pid       ssh
/var/run/atd.pid        atd
/var/run/crond.pid      cron
/var/run/mysqld/mysqld.pid      mysql
/var/run/apache2.pid    apache2
/var/run/clamav/freshclam.pid   clamav-freshclam
/var/run/cups/cupsd.pid         cups

et /var/nomprocessus

/usr/sbin/rsyslogd      sysklogd
/usr/sbin/named bind
/sbin/rpc.statd portmap
/usr/sbin/spamd spamassassin
/usr/sbin/sshd  ssh
/usr/sbin/ntpd  ntp
nfsd    nfs-kernel-server
/usr/sbin/rpc.mountd    portmap
/usr/local/bin/raquette raquette
/usr/sbin/cron  cron
/usr/sbin/apache2       apache2
/usr/sbin/rpc.yppasswdd nis
/usr/sbin/ypserv        nis
/usr/sbin/rpc.ypxfrd    nis
/usr/sbin/inetd openbsd-inetd
/var/bb17b4/bin/bbd     bigbrother

à adapter bien sûr.

Un script pour appliquer un fond d’écran aléatoire, basé sur celui du Wiki, mais utilisant xloadimage plutôt que feh (question de légèreté) et simplifié au maximum.
Utilisé à la main il n’est pas débordant d’utilité, mais ajouté à la fin du script de lancement du session manager, il permet d’obtenir un fond d’écran aléatoire à chaque lancement de la session graphique.[code]WALLPAPERS="$HOME/images/wallpapers"
ALIST=(ls -1 $WALLPAPERS)

xsetbg -fullscreen -border black $WALLPAPERS/${ALIST[$RANDOM % ${#ALIST[@]}]}[/code]‘WALLPAPERS’ doit bien entendu définir le chemin d’accès au répertoire contenant les fonds d’écran…
La commande ‘xsetbg’ peut être remplacée sans problème par n’importe quelle commande permettant d’afficher une image en fond d’écran.
L’option ‘-border black’ est adaptée à mon thème graphique personnel, mais devra peut-être être modifiée selon le vôtre…

/!\ : Ce script ne gère pas les espaces dans les noms des images, probablement à cause de l’option ‘-1’ appliquée à ‘ls’, mais je ne sais pas comment passer outre ce problème…
En attendant que quelqu’un puisse m’éclairer, les espaces sont utilisables dans le chemin d’accès au dossier, mais pas dans le nom des images.

Bjr,
Ok xloadimage est plus léger, mais malgré toutes les options passées à xsetbg, les images ne se justifient à l’écran qu’en hauteur. Une soluce ?
Ton script fait malgré tout 5 lignes de moins, je prends.

L’option -fullscreen conserve les proportions de l’image d’origine et n’en coupe aucune partie, c’est pour ça que seule la dimension la plus grande de l’image d’origine est adaptée à la résolution du bureau.
Un autre paquet peut sûrement faire le même travail soit en étirant l’image (déformation) soit en zoomant dessus (troncage), mais je n’ai pas encore vraiment cherché…

Peut-être avec le paquet nitrogen ?
Je ne l’ai pas testé en profondeur…

Voici un petit script qui ajoute les utilisateurs dans Samba et sur linux.
il vérifie si l’utilisateur se trouve en root pour lancer le script et si oui alors il demande le nom de login à créer dans linux mais aussi dans Samba il vérifie si l’utilisateur n’existe pas déja, le compte se trouve sans mot de passe (plus facile pour acceder à un partage), puis il ajoute la personne au groupe sambafic

[code]#! /bin/sh
#creation de compte pour le SRV_Fichier Samba

créer le 04/05/09 par Olivier aliase zyriuse

login=$1
t_tty=tty
choix=$choix
userid=id -u

clear
echo " ###################################"
echo "#### Ajout d’utilisateur à SAMBA ####"
echo " ###################################"
echo “”

if [ $userid != 0 ];
then
echo "Il vous faut passer en root pour exécuter le script"
sleep 2
clear
exit
fi

echo "sélectionner le nom de l’utilisateur à ajouter"
read login

grep “^$login:” /etc/passwd > /dev/null

une commande Unix prend 0 quand son résultat est positif

while [ $? -eq 0 ]
do
echo "l’utilisteur éxiste déja"
echo "saisir un autre nom"
read login
grep “^$login:” /etc/passwd >/dev/null
done

until [ “$choix” = “o” ]; do
echo " Etes-vous sûr de vouloir crée l’utilisateur o/n:"
read choix < $t_tty #il écoute la sorti
if [ “$choix” = “o” ];then
useradd $login -g sambafic -b /home/Samba/$login
passwd -d -l $login
echo "création du compte Samba"
smbpasswd -a -n $login
echo " le compte à bien était créer "
sleep 5
clear
elif [ “$choix” != “o” ]; then
echo " il n’y a pas eu de création de compte"
sleep 2
clear
fi
break
done[/code]