Petit logiciel maison de gestion des utilisateurs Linux

Salut à tous!

Hier après-midi, j’ai commencé à coder un petit logiciel en C qui permet d’ajouter facilement une masse conséquente d’utilisateurs sous Linux, et de leur appliquer des quotas au passage.

Le code source en C:
http://bluelambda.free.fr/etuadmin-src.tar.gz

Ce logiciel commence par charger son fichier de configuration (etuadmin.cfg) et traite les données du fichier.
Ensuite il va lire un fichier (etudiants) dans lequel il y a le Nom Prénom de chaque utilisateur. Un utilisateur par ligne.
Il va écrire le fichier de sortie (comptes etudiants) qui contient l’UID attribué, le Nom Prénom, le login et le passe en clair généré aléatoirement.
Il crypte le mot de passe, et il utilise la commande useradd pour créer l’utilisateur.

Tout cela marche bien, je peux ensuite me logguer sans souci sur les comptes créés.

Pour finir, le programme est censé (mais alors censé hein) appliquer les quotas disque pour chaque utilisateur nouvellement créé, via la fonction quotactl (voir ‘man quotactl’).

(Voir lignes 210 à 257 de mon programme).

Seulement, au moment de l’application des quotas, il me renvoie l’erreur ‘EINVAL’: “‘type’ n’est pas un type de quota supporté. Ou bien ‘special’ n’a pas pu être trouvé.” (définition de l’erreur d’après man).

Dans mon programme, ces variables sont aux valeurs:
type: USRQUOTA, comme indiqué dans les pages de man.
special: le système de fichiers concerné.

Je précise que mes quotas sont bien configurés sur le système de fichiers en question. Je les gère via Webmin sans aucun souci.
Le fichier aquota.user est présent à la racine.
aquota.group ne l’est pas car je n’utilise pas les quotas de groupe.

C’est tout, c’est la première fois que j’utilise cette fonction, donc si il y a des personnes expérimentées là dedans, ou des pros du quota disque, ce serai simpa de me donner un petit coup de pouce, car là je bloque.

PS: j’ai examiné quelques codes source sur Internet qui utilisent cette commande, mais aucun de ceux que j’ai trouvé ne fait ce que je veux faire, ils ne m’ont pas éclairé.

Je vous remercie, bye!

Merci, je n’en ai pas vraiment l’utilité, en plus je ne programme pas non plus en C, mais ton code est clair, bien documenté, ca fait plaisir ! :stuck_out_tongue:

Quelques petites questions : Est-ce que ca n’existait pas déjà, car nombres universités (FAC, IUT, Lycée), doivent chaque année supprimer et recréer une bonne partie de compte utilisateur ?

Sinon, il y a moyen de pousser l’idée jusqu’au bout en ajoutant pas mal d’option avec (peut-être) une GUI en GTK/QT à la clé. Pourquoi pas pas un petit site.

moi je vois ca:

et ca:

C’est assez clair, non?

LoneWolf
Bien lire les manpage…

Non mais sans déconner… Un programme en C pour faire ça, alors que ça se fait en 10 lignes de Bash ? :stuck_out_tongue:

Hahahah, oh mon dieu ton code est sale :stuck_out_tongue:

Morceaux choisis :

system("zenity --error --text=\"Erreur dans le fichier de configuration etuadmin.cfg : passage à la ligne avant la fin de la clé\"");

if (quotactl (qcmd, "/dev/hdc1", *min_uid, (caddr_t) &quota_addr) == -1) ← oui oui, le disque codé en dur dans le code.

system("cat \'comptes etudiants\'|zenity --text-info --title=\"Comptes étudiants créés\" --width=600 --height=300");

To unreal…

Heu, je veux pas dire mais au niveau courtoisie on peut mieux faire non ?
On a ici quelqu’un qui demande conseil sur un problème dans son code. Qui prends le temps d’expliquer son problème, file les sources de son petit programme, ce qui peut intérresser quelqu’un.

Je trouve pas qu’il mérite qu’on se foutte de sa gueule… (Ou alors, on prends la peine de lui expliquer pourquoi). Enfin, je dis cela, je dis rien, pas la peine d’en faire tout un fromage (ni de lancer un débat), y a pas mort d’homme non plus. [désolé pour la dérive possible de ce post]

J’ai pas trop compris ce que fait le programme, il créé des utilisateurs en boucle ? en leur ajoutant leurs quota en meme temps. (j’ai parcouru en diagonales le code mais les fonctions sont pas documentés donc …)

Si c’est juste ça, un script bash avec une boucle ferrait aussi l’affaire.

ZGoblin > je n’ai pas trouvé de programme déjà existant pour faire ce que je veux faire.
Et je pense effectivement pousser l’idée jusqu’au bout, avec à terme une interface graphique tout joli et avec et bien plus d’options :stuck_out_tongue:

LoneWolf > j’ai exactement la même chose dans mes pages de man mais ça ne m’aide pas beaucoup.

[quote]The second argument special is the block special device these quota apply to. It must be mounted.[/quote]Les deux conditions me semblent réunies. Je lui donne le chemin vers un périphérique type bloc et il est bien monté.

[quote]EINVAL type is not a known quota type. Or, special could not be found.[/quote]La valeur de ‹ type › je l’ai prise dans les pages de man, il n’y a que deux possibilités, et j’ai mis celle qui est appropriée dans ce cas (USRQUOTA), étant donné que je travaille avec les quotas utilisateurs.

Donc c’est bien l’objet de ma question: pourquoi cette erreur?

unreal > tu n’as qu’à me proposer une solution pour gérer les quotas en BASH (en 10 lignes) au lieu de parler, je n’ai pas réussi. Moi je prend sans problèmes si tu me proposes ça, car je n’ai pas réussi à le faire. Mais dans ta grande supériorité intellectuelle, tu as certainement la solution :stuck_out_tongue: ?

[quote]- oui oui, le disque codé en dur dans le code.[/quote]C’est ce qui est marqué dans les pages de man à propos de ce paramètre.
Et puis je ne vois pas le souci, c’est pas la première fois que je met le chemin vers une partition dans le code d’un programme.
Mais peut être j’ai mal compris comment ça marche. Que devrais-je mettre à la place?

Pour l’utilisation de Zenity c’est temporaire, juste pour que si j’ai pas le temps de finir ce soit présentable.

majinboo >

[quote]J’ai pas trop compris ce que fait le programme, il créé des utilisateurs en boucle ? en leur ajoutant leurs quota en meme temps. (j’ai parcouru en diagonales le code mais les fonctions sont pas documentés donc …)

Si c’est juste ça, un script bash avec une boucle ferrait aussi l’affaire.[/quote]Le programme crée des comptes utilisateurs à partir de « noms prénoms » stockés dans un fichier texte. Il crée des logins à partir de ces infos.
Il génère ensuite un mot de passe aléatoirement et le crypte.
Et ensuite il applique les quotas à chaque utilisateur (enfin pas pour l’instant).

J’aurais bien aimé faire un script en BASH, mais je sais assez peu programmer en BASH, et je n’ai pas trouvé de bonne solution à deux problèmes:

  • mettre les quotas pour les utilisateurs
  • crypter les mots de passe pour les refiler ensuite à ‹ useradd ›

Je vous remercie de vos réponses, bye!

J’ai fait ca rapidement tout a l’heure (ca gere pas encore les quotas parce que j’ai la flemme).

[codebox]#!/bin/sh

##############################
home_dir=/home/etudiants
min_uid=1001
prim_grp=etudiants
grp_quota=100000
passwd_len=8
##############################

[ « whoami » != « root » ] && echo « You’re not root! » 1>&2 && exit 1

[[ ! -f $1 || « $1 » == «  » ]] && echo « Syntax: $0 user_file > user_list » 1>&2 && exit 1

[ « cat /etc/group | grep ^$prim_grp: » == «  » ] && echo « Adding user group. » 1>&2 && echo « groupadd $prim_grp »

[ ! -d $home_dir ] && mkdir $home_dir

Start parsing file.

user_file=cat $1

lastnames=echo "$user_file" | awk '{ print $1 }'
firstnames=( echo "$user_file" | awk '{ print $2 }' )

index=0
matrix=« 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz »

for one_user in $lastnames; do
account="echo "$one_user${firstnames[$index]}" | tr '[:upper:]' '[:lower:]' | sed -e 's/[éèêë]/e/g' -e 's/[àâä]/a/g' -e 's/[îï]/i/g' -e 's/[ôö]/o/g' -e 's/ù/u/g' -e 's/ç/c/g'"

    if [ "`cat /etc/passwd | grep ^$account: /etc/passwd`" == "" ]; then
            # Random password.
            unset n pass
            while [ "${n:=1}" -le "$passwd_len" ]; do
                    pass="$pass${matrix:$(($RANDOM%${#matrix})):1}"
                    (( n += 1 ))
            done

            #useradd -u $(( $min_uid+$index )) -g $prim_grp -d $home_dir/$account -p `openssl passwd $pass` $account
            echo -e "$(( $min_uid+$index))\t$one_user\t\t${firstnames[$index]}\t\t$account\t\t$pass"
    fi

    (( index += 1 ))

done

exit 0[/codebox]

Petit edit pour crypter le mot de passe utilisé par useradd.

Le bash c’est puissant ! :stuck_out_tongue:

popen() ça vous dit quelque chose ?

unreal > simpa le script en BASH :stuck_out_tongue:

Il faut encore trouver une solution pour gérer les quotas.
Il me semble qu’avec la commande ‹ edquota › c’est pas possible à partir d’un script (du moins je sais pas faire), etant donné qu’il ouvre vim (il me semble, je n’ai pas de quoi vérifier ici) dans un mode assez space pour éditer aquota.user et aquota.group (qui sont des fichiers un peu spéciaux aussi).

Ensuite, si j’ai bien compris ton script (je ne suis pas bon en BASH, je le rappelle :stuck_out_tongue: ), il balance à ‹ useradd › le mot de passe en clair. Cependant d’après les pages de man ‹ useradd › attend un mot de passe crypté (avec la fonction C ‹ crypt › par exemple).
A la limite on peu toujours faire un petit programme en C qui crypte le mot de passe généré, mais ça serait mieux de pouvoir tout faire en BASH sans avoir des binaires qui trainent avec.

popen() je connaissais pas, ça a l’air pas mal si je continue la version C du programme. Je me pencherai sur ça plus tard, chuis creuvé! Bonne nuit.

Je continue ma version en C, j’aimerai bien faire un petit logiciel assez complet sur le sujet, avec peut être une interface graphique à la fin :stuck_out_tongue:

Si quelqu’un a une idée pour la fonction quotactl qui refuse de marcher, ça me serait très utile! Je bloque sur cette erreur.

J’ai édité (oh la la que c’etait difficile…).

Pas mal du tout, je savais pas que l’on pouvait utiliser OpenSSL pour crypter les mots de passe :stuck_out_tongue:
En tout cas il faut que j’apprenne le BASH, c’est fichtrement intéressant comme truc.

Pour les quotas j’ai trouvé une solution utilisable dans un script BASH, j’avais pas du tout capté une option dans les pages de man: l’option -p
Elle permet de dupliquer les quotas d’un utilisateur, il suffit donc que je crée un utilisateur ‹ quota › avec les quotas pré-définis.

Bref j’ai mis tout ça en place dans ton script, j’ai ajouté l’appartenance aux groupes secondaires aussi, de même que des commentaires.

Il faut que j’ajoute la suppression de tous les utilisateurs qui ont prim_grp pour groupe primaire (j’ai commencé).

Voici pour info le code modifié:

[code]#!/bin/sh

Configuration

##################################
home_dir=/public/etudiants # Répertoire parent des répertoires utilisateurs
min_uid=1001 # Les UID des utilisateurs à créer sont croissants à partir de cette valeur
prim_grp=etudiants # Groupe primaire
sec_grp=audio,cdrom,floppy,plugdev # Groupes secondaires
grp_quota=100000 # Quotas disque en koctets
passwd_len=8 # Longueur des mots de passe
quota_prototype=quota # Les quotas disque de l’utilisateur ‹ quota › seront
# les mêmes pours les utilisateurs ajoutés
##################################

Vérifie si on est bien le super-utilisateur

[ « whoami » != « root » ] && echo « Vous n’êtes pas super-utilisateur » 1>&2 && exit 1

On vérifie que la syntaxe des paramètres est correcte

[[ ! -f $1 || « $1 » == «  » && ! -f $2 || « $2 » == «  » ]] && echo « Syntaxe: $0 fichier_noms > fichier_sortie add/rem » 1>&2 && exit 1

Ajout du groupe promaire si il n’existe pas

[ « cat /etc/group | grep ^$prim_grp: » == «  » ] && echo « Adding user group. » 1>&2 && echo « groupadd $prim_grp »

On crée le répertoire parent des répertoires utilisateurs si il n’existe pas

[ ! -d $home_dir ] && mkdir $home_dir

On commence à parcourir le fichier contenant les noms

user_file=cat $1
lastnames=echo "$user_file" | awk '{ print $1 }'
firstnames=( echo "$user_file" | awk '{ print $2 }' )

index=0

Caractères possibles dans les mots de passe

matrix=« 0123456789abcdefghijklmnopqrstuvwxyz »

Si l’on souhaite ajouter des utilisateurs

if [ « $2 » == « add » ]; then
for one_user in $lastnames; do
# Génération du login à partir du Nom Prénom
account="echo "$one_user${firstnames[$index]}" | tr '[:upper:]' '[:lower:]' | sed -e 's/[éèêë]/e/g' -e 's/[àâä]/a/g' -e 's/[îï]/i/g' -e 's/[ôö]/o/g' -e 's/ù/u/g' -e 's/ç/c/g'"

	# On crée l'utilisateur si il n'existe pas
	if [ "`cat /etc/passwd | grep ^$account: /etc/passwd`" == "" ]; then
		# Mot de passe aléatoire
		unset n pass
		while [ "${n:=1}" -le "$passwd_len" ]; do
			pass="$pass${matrix:$(($RANDOM%${#matrix})):1}"
			(( n += 1 ))
		done

		# Ajout de l'utilisateur
		useradd -u $(( $min_uid+$index )) -g $prim_grp -G $sec_grp -m -d $home_dir/$account -p `openssl passwd $pass` $account
		echo -e "$(( $min_uid+$index))\t$one_user\t\t${firstnames[$index]}\t\t$account\t\t$pass"

		# Mise en place des quotas
		edquota -p $quota_prototype $account
	fi

	(( index += 1 ))
done

fi

Si l’on souhaite supprimer des utilisateurs

if [ « $2 » == « rem » ]; then
fi

exit 0[/code]

Bonjour à tous,

Après m’être aidé de diverses docs à propos de BASH sur Internet, j’ai pu ajouter et faire fonctionner la suppression de tous les utilisateurs appartenant à un groupe donné.

Voici le code modifié:

[code]#!/bin/sh

Configuration

##################################
home_dir=/public/etudiants # Répertoire parent des répertoires utilisateurs
min_uid=1001 # Les UID des utilisateurs à créer sont croissants à partir de cette valeur
prim_grp=etudiants # Groupe primaire
sec_grp=audio,cdrom,floppy,plugdev # Groupes secondaires
grp_quota=100000 # Quotas disque en koctets
passwd_len=8 # Longueur des mots de passe
quota_prototype=quota # Les quotas disque de l’utilisateur ‹ quota › seront
# les mêmes pours les utilisateurs ajoutés
##################################

Vérifie si on est bien le super-utilisateur

[ « whoami » != « root » ] && echo « Vous n’êtes pas super-utilisateur » 1>&2 && exit 1

On vérifie que la syntaxe des paramètres est correcte

(on doit rediriger la sortie du flux dans un fichier)

[[ ! -f $1 || « $1 » == «  » && ! -f $2 || « $2 » == «  » ]] && echo « Syntaxe: $0 fichier_noms > fichier_sortie add/rem » 1>&2 && exit 1

Si l’on souhaite ajouter des utilisateurs

if [ « $2 » == « add » ]; then
# Ajout du groupe promaire si il n’existe pas
[ « cat /etc/group | grep ^$prim_grp: » == «  » ] && echo « Adding user group. » 1>&2 && echo « groupadd $prim_grp »

# On crée le répertoire parent des répertoires utilisateurs si il n'existe pas
[ ! -d $home_dir ] && mkdir $home_dir

# On commence à parcourir le fichier contenant les noms
user_file=`cat $1`
lastnames=`echo "$user_file" | awk '{ print $1 }'`
firstnames=( `echo "$user_file" | awk '{ print $2 }'` )

# Caractères possibles dans les mots de passe
matrix="0123456789abcdefghijklmnopqrstuvwxyz"

echo -e "UID\tNom Prénom\t\tLogin\t\tMot de passe"

index=0

for one_user in $lastnames; do
	# Génération du login à partir du Nom Prénom
	account="`echo "$one_user${firstnames[$index]}" | tr '[:upper:]' '[:lower:]' | sed -e 's/[éèêë]/e/g' -e 's/[àâä]/a/g' -e 's/[îï]/i/g' -e 's/[ôö]/o/g' -e 's/ù/u/g' -e 's/ç/c/g'`"

	# On crée l'utilisateur si il n'existe pas
	if [ "`cat /etc/passwd | grep ^$account: /etc/passwd`" == "" ]; then
		# Mot de passe aléatoire
		unset n pass
		while [ "${n:=1}" -le "$passwd_len" ]; do
			pass="$pass${matrix:$(($RANDOM%${#matrix})):1}"
			(( n += 1 ))
		done

		# Ajout de l'utilisateur
		useradd -u $(( $min_uid+$index )) -g $prim_grp -G $sec_grp -m -d $home_dir/$account -p `openssl passwd $pass` $account
		echo -e "$(( $min_uid+$index))\t$one_user\t\t${firstnames[$index]}\t\t$account\t\t$pass"

		# Mise en place des quotas
		edquota -p $quota_prototype $account
	fi

	(( index += 1 ))
done

fi

Si l’on souhaite supprimer des utilisateurs

On supprime tous les utilisateurs qui ont pour groupe primaire prim_grp

if [ « $2 » == « rem » ]; then

# Lecture de la ligne qui contient le groupe prim_grp dans /etc/group
ligne=`grep "$prim_grp:" /etc/group`; status=$?

# Si le groupe existe
if test $status -eq 0; then
	# On extrait le GID (3eme champ de la ligne)
	gid=`echo $ligne | cut -f3 -d:`

	cut -f1,4 -d: /etc/passwd | grep ":$gid" | cut -f1 -d: | sort | while read user; do
		# On vérifie si l'utilisateur n'est pas connecté
		if who | fgrep `expr substr $user 1 8` 1>/dev/null; then
			# Si oui on n'exécute pas userdel car il renvoie une erreur
			echo "User: $user est connecté"
		else
			echo "User: $user n'est pas connecté"
			# Suppression de l'utilisateur
			userdel -r $user
		fi
	done
fi		

fi

exit 0[/code]

Voilà :stuck_out_tongue:

Si il y a des experts du BASH qui se sentent de jeter un oeil, qu’en pensez-vous?
Y a t-il des trucs à améliorer? Des suggestions?
Peut être y a t-il plus simple pour supprimer les utilisateurs d’un groupe, non?

Docs utilisées:
http://www.bsdbooks.net/shells/scripting/f…nipulation.html
http://fr.lang.free.fr/cours/Shell_v1.4.pdf

Carrement oui. Quand plusieurs utilisateurs appartiennent a un meme groupe, y’a un chouette listing directement dans /etc/group, donc ca se fait en une ligne :

On obtient alors une liste d’utilisateurs avec les noms séparés par des espaces… suffit de faire une boucle apres.

Oui mais ce listing est valable uniquement quand on parle de groupes secondaires, dans le cas présent, je supprime des utilisateurs à partir de leur groupe primaire.

Les utilisateurs que le script crée appartiennent au groupe « etudiants ».
Or, si je regarde mon /etc/group, j’ai:[quote][…]
etudiants:x:1001:[/quote] et rien après, car personne n’a le groupe « etudiants » en groupe secondaire.

Dans le 4eme champ de /etc/passwd, j’ai bien le GID du groupe « etudiants » (pour les utilisateurs ajoutes par le script). C’est là qu’est signalé le groupe primaire des utilisateurs.

Par contre effectivement, si l’on regarde pour le groupe « plugdev » (qui permet aux utilisateurs qui lui appartiennent de pouvoir utiliser leurs clés USB, il est souvent (toujours) utilisé en groupe secondaire), on a:[quote]plugdev:x:46:bluelambda,…les_utilisateurs_ajoutés_par_le_script[/quote]

A la limite je pourrais coller « etudiants » en groupe primaire ET secondaire aux utilisateurs, mais ça me semble moche comme solution, non?

Bye, moi je vais… :stuck_out_tongue:

C’est pas tres compliqué alors : suffit d’ajouter l’utilisateur dans “etudiants” comme groupe secondaire aussi :

[code]# useradd -g etudiants -G etudiants,audio,cdrom,floppy,plugdev -m testuser

groups testuser

testuser : etudiants cdrom floppy audio plugdev

cat /etc/group | grep ^etudiants

etudiants:x:1002:testuser

su - testuser

$ touch huhu
$ ls -lh
total 0
-rw-r–r-- 1 testuser etudiants 0 Apr 20 07:15 huhu[/code]

Je préfère laisser la suppression par rapport à l’appartenance à un groupe primaire.

Je modifierai certainement encore le script plus tard pour ajouter des fonctions (par exemple le choix de supprimer des utilisateurs selon leur groupe primaire ou secondaire), j’utiliserai ta solution pour les groupes secondaires.

Je pensais avoir publié la dernière version du script depuis un moment, mais en fait non, je vois que j’ai rêvé.

J’avais corrigé un ou deux petits bugs.
L’ajout du groupe primaire ne se faisait pas si le groupe n’existait pas (il affichait juste le message mais n’exécutait pas groupadd il me semble).

[quote]#!/bin/sh

Configuration

##################################
home_dir=/home/etudiants # Répertoire parent des répertoires utilisateurs
min_uid=1001 # Les UID des utilisateurs à créer sont croissants à partir de cette valeur
prim_grp=etudiants # Groupe primaire
sec_grp=audio,cdrom,floppy,plugdev # Groupes secondaires
passwd_len=8 # Longueur des mots de passe
quota_prototype=skel # Les quotas disque de l’utilisateur ‘quota’ seront
# les mêmes pours les utilisateurs ajoutés
##################################

Vérifie si on est bien le super-utilisateur

[ “whoami” != “root” ] && echo “Vous n’êtes pas super-utilisateur!” 1>&2 && exit 1

On vérifie que la syntaxe des paramètres est correcte

(on doit rediriger la sortie du flux dans un fichier)

[[ ! -f $1 || “$1” == “” && ! -f $2 || “$2” == “” ]] && echo “Syntaxe: $0 fichier_noms > fichier_sortie add/del” 1>&2 && exit 1

Si l’on souhaite ajouter des utilisateurs

if [ “$2” == “add” ]; then
# Ajout du groupe primaire si il n’existe pas
[ “cat /etc/group | grep ^$prim_grp:” == “” ] && echo “Ajout du groupe $prim_grp” 1>&2 && groupadd $prim_grp

# On crée le répertoire parent des répertoires utilisateurs si il n'existe pas
[ ! -d $home_dir ] && mkdir $home_dir

# On commence à parcourir le fichier contenant les noms
user_file=`cat $1`
lastnames=`echo "$user_file" | awk '{ print $1 }'`
firstnames=( `echo "$user_file" | awk '{ print $2 }'` )

# Caractères possibles dans les mots de passe
matrix="0123456789abcdefghijklmnopqrstuvwxyz"

echo -e "UID\tNom Prénom\t\tLogin\t\tMot de passe"

index=0

for one_user in $lastnames; do
	# Génération du login à partir du Nom Prénom
	account="`echo "$one_user${firstnames[$index]}" | tr '[:upper:]' '[:lower:]' | sed -e 's/[éèêë]/e/g' -e 's/[àâä]/a/g' -e 's/[îï]/i/g' -e 's/[ôö]/o/g' -e 's/ù/u/g' -e 's/ç/c/g'`"

	# On crée l'utilisateur si il n'existe pas
	if [ "`cat /etc/passwd | grep ^$account: /etc/passwd`" == "" ]; then
		# Mot de passe aléatoire
		unset n pass
		while [ "${n:=1}" -le "$passwd_len" ]; do
			pass="$pass${matrix:$(($RANDOM%${#matrix})):1}"
			(( n += 1 ))
		done

		# Ajout de l'utilisateur
		useradd -u $(( $min_uid+$index )) -g $prim_grp -G $sec_grp -m -d $home_dir/$account -s /bin/bash -p `openssl passwd "$pass"` $account
		echo -e "$(( $min_uid+$index))\t$one_user\t\t${firstnames[$index]}\t\t$account\t\t$pass"

		# Mise en place des quotas
		edquota -p $quota_prototype $account
	fi

	(( index += 1 ))
done

fi

Si l’on souhaite supprimer des utilisateurs

On supprime tous les utilisateurs qui ont pour groupe primaire prim_grp

if [ “$2” == “del” ]; then

# Lecture de la ligne qui contient le groupe prim_grp dans /etc/group
ligne=`grep "$prim_grp:" /etc/group` ; status=$?

# Si le groupe existe
if test $status -eq 0; then
	# On extrait le GID (3eme champ de la ligne)
	gid=`echo $ligne | cut -f3 -d:`

	cut -f1,4 -d: /etc/passwd | grep ":$gid" | cut -f1 -d: | sort | while read user; do
		# On vérifie si l'utilisateur n'est pas connecté
		if who | fgrep `expr substr $user 1 8` 1>/dev/null; then
			# Si oui, on n'exécute pas userdel, car il renvoie une erreur
			echo "L'utilisateur $user est connecté!" 1>&2
		else
			# Suppression de l'utilisateur
			userdel -r $user
		fi
	done
fi		

fi

exit 0[/quote]

Unreal, je pense continuer à faire évoluer ce script (si le besoin s’en fait ressentir) et à le redistribuer peut être. Etant donné que tu en as écris une très grosse partie, tu as ton mot à dire sur la distribution.
Je pense le distribuer sous GPL, si tu n’est pas d’accord on en discute par MP.