Comment limiter le temps d'écran de mes enfants ?

Les utilisateurs d'Ubuntu <= 11.10 suivent ce guide pour les utilisateurs d'Ubuntu >= 11.10 lisez la page de bas de page avis :

Oui, tous ces programmes sont obsolètes et toutes vos questions trouvent réponse ici. Bonne chance avec votre contrôle parental......

Lorsque nous parlons de forcer un utilisateur à se déconnecter, il s'agit en fait de mettre en place des restrictions temporelles sur le compte pour l'accès au système ou aux services. Le moyen le plus simple que j'ai trouvé pour mettre en place des restrictions de temps est d'utiliser un module plug-in appelé Linux-PAM .

Module d'authentification enfichable (PAM) est un mécanisme d'authentification des utilisateurs. Plus précisément, nous allons utiliser l'option pam_time pour contrôler les accès temporaires des utilisateurs aux services.

Utilisation de la pam_time nous pouvons définir des restrictions d'accès à un système et/ou à des applications spécifiques à différentes heures de la journée ainsi qu'à des jours spécifiques ou sur différentes lignes terminales. Selon la configuration, vous pouvez utiliser ce module pour refuser l'accès à des utilisateurs individuels en fonction de leur nom, de l'heure de la journée, du jour de la semaine, du service qu'ils demandent et du terminal à partir duquel ils font leur demande.

Lorsque vous utilisez pam_time vous devez mettre fin à la syntaxe de chaque ligne (ou règle) dans la section /etc/security/time.conf avec une nouvelle ligne. Vous pouvez commenter chaque ligne avec le signe dièse [#], et le système ignorera ce texte jusqu'à la nouvelle ligne.

Voici la syntaxe d'une règle :

services;ttys;utilisateurs;temps

The first field —  services — is a logic list of PAM service names.
The second field — tty — is a logic list of terminal names.
The third field — users — is a logic list of users or a netgroup of users.
The fourth field — times — indicates the applicable times.

Voici un exemple d'un ensemble typique de règles :

login ; * ; !bobby ; MoTuWeThFr0800-2000
login ; * ; !root ; !Al0000-2400
http ; * ; !bobby ; MoTuWeThFr0800-2000
http ; * ; !root; !Al0000-2400

Ces règles empêchent l'utilisateur Bobby de se connecter entre 8 heures et 20 heures, et limitent également l'accès à Internet pendant ces heures. Root pourrait se connecter à tout moment et naviguer sur Internet à tout moment également.

Note : Le système enregistre les erreurs avec ces règles comme syslog(3).

Avec Ubuntu Linux, il est possible d'attribuer à votre ordinateur des restrictions temporelles, afin d'empêcher la connexion d'un ou plusieurs utilisateurs à votre système. Avec les restrictions horaires, vous pouvez, par exemple, limiter l'accès à l'ordinateur pour vos enfants. (une sorte de contrôle parental, en somme) ou même de protéger la connexion à votre serveur pendant certaines heures.

Configuration manuelle

Comprendre ce que vous allez faire

Tout au long de ce tutoriel, nous utiliserons PAM (Pluggable Authentication Modules, en anglais). Il permet de contrôler l'authentification des utilisateurs lors de leur connexion. Ensuite, nous utiliserons les fichiers de configuration de sécurité pour définir les heures de connexion autorisées. Ces manipulations peuvent être effectuées sur n'importe quelle version d'Ubuntu, et ne nécessitent qu'un simple éditeur de texte (vim, emacs, nano, gedit, kate, pour en citer quelques-uns). Activer les heures de restriction via le module PAM

Tout d'abord, allez dans le /etc/pam.d/ où se trouvent tous les services configurables :

$ Ls /etc/pam.d/
atd common-account common-session gdm login ppp sudo
chfn common-auth cron gdm-autologin Other samba
chsh common-cupsys gnome-screensaver password passwd su

Si nous voulons bloquer la connexion à l'ordinateur, nous devrons modifier le service gdm. Editez le fichier so gdm et ajoutez cette ligne de code (à la fin du fichier) :

account required pam_time.so

GDM est l'écran de connexion des distributions Ubuntu, Edubuntu et Xubuntu. Pour Kubuntu, qui utilise KDE, le service kdm est appelé, ce sera le fichier qu'il ouvrira. Et voilà, vous avez terminé pour la configuration de la PAM ! Cela va permettre le contrôle des heures sur ce service.

Si vous avez un serveur, vous n'avez probablement pas d'interface graphique. Dans ce cas, GDM / KDM n'est pas installé et la connexion ne sera pas bloquée. Pour empêcher la connexion à TTY, vous devez modifier le login du même fichier, et ajouter la même ligne de code que celle reconnue précédemment. Cette action s'applique également aux personnes qui ont installé une interface graphique et qui veulent bloquer l'accès à l'écran de connexion et aux terminaux.

Configurer les heures d'accès

Maintenant que le service PAM a été activé, il ne nous reste plus qu'à configurer les temps d'accès. Ouvrez l'application /etc/security . Plusieurs fichiers de configuration sont disponibles :

$ Ls /etc/security/
access.conf namespace.conf pam_env.conf
group.conf namespace.init time.conf
limits.conf opasswd time.conf.bak

Modifier le fichier time.conf . Quelques explications et exemples (anglais) présentant le . Pour définir les horaires d'accès, copiez et collez la ligne de code suivante (à la fin du fichier, comme toujours) :

*;*;user;scheduler

À la place du champ utilisateur, saisissez le compte de connexion que vous souhaitez bloquer.

Si vous voulez bloquer plusieurs utilisateurs, entrez leur login dans une rangée, séparés par l'opérateur |. Par exemple, si je veux bloquer les comptes de Patrick, John et Emily :

*;*;Patrick|jean|emilie;scheduler

Par contre, si vous voulez bloquer l'accès au système pour tous les utilisateurs mais un en particulier, utilisez le ! devant la personne concernée. Par exemple, si je veux que l'accès à l'ordinateur soit refusé à tous les utilisateurs, sauf Nicolas et Xavier :

Nicolas *;*;!|xavier;scheduler

Passons maintenant aux zones de terrain. C'est dans ce champ que la sélection des jours et des heures sera autorisée connexion possible. Vous devez d'abord spécifier le jour de la semaine, en utilisant les abréviations suivantes :

Mo : Monday     Fr : Friday     Wd : Sa/Su
Tu : Tuesday    Sa : Saturday   wk : Mo/Tu/We/Th/Fr
We : Wenesday   Su : Sunday
Th : Thursday   Al : All Days

Attention à ne pas confondre les abréviations Wk et Wd sont trompeuses ! particulièrement mal identifiées sur Internet : on peut facilement trouver des informations contradictoires !

Ensuite, nous précisons les délais. Celles-ci doivent être formatées en 24H, composées de 4 chiffres. Par exemple, pour restreindre de 15 h 17 à 18 h 34, nous écrivons : 1517-1834. Pour permettre à Marie de se connecter uniquement le mardi, de 15h17 à 18h34, nous obtenons le résultat suivant :

*;*;marie;Tu1517-1834

Les connexions en dehors de ces heures seront interdites. Comme pour les utilisateurs, il est possible d'utiliser les opérateurs | et ! pour indiquer plusieurs heures (le ! indique alors que toutes les heures de connexion sont autorisées, sauf celles à afficher).

Les deux étoiles (caractères de remplacement) au début de la ligne de code sont, respectivement, et les champs de services tty. Puisque vous voulez bloquer tout accès au système, il est inutile de préciser quel service ou quel tty vous voulez bloquer. Cependant, si vous voulez empêcher l'utilisation d'un service particulier, il suffit de le spécifier comme dans l'exemple suivant :

login;tty1|tty4|tty5;marie;!Wd0000-2400

Ainsi, l'utilisateur marié ne peut pas se connecter à un ATS, 4 et 5 pendant le week-end.

Quelques exemples de calendrier des restrictions

mathilde est autorisée à se connecter tous les jours de 13 h 20 à 15 h 20 et de 16 h à 20 h 30 :

*;*;mathilde;Al1320-1520|Al1600-2030

Stone, Frank et Florian sont autorisés à se connecter de 14 h à 18 h 45 en semaine, et de 14 h à 22 h 15 le week-end :

*;*;Stone|franck|florian;Wk1400-1845|Wd1400-2215

Olive n'est jamais autorisé à se connecter. Jessica peut se connecter le mercredi de 13h00 à 16h00 :

*;*;olivier;!Al0000-2400
*;*;jessica;We1300-1600

2 lignes différentes, pour deux temps différents pour chaque utilisateur Expiration d'une session

Lorsqu'une session expire (elle dépasse le temps pendant lequel l'utilisateur est déjà connecté), le PAM peut joindre l'utilisateur. Si mathilde se connecte pendant les heures de temps autorisées, elle est parfaitement libre de dépasser ces heures ! Pour cela, nous allons utiliser un nouveau programme : 'cron'. Cette application exécute des commandes à intervalles de temps. Dans notre cas, nous allons utiliser la commande 'skill-KILL-u' pour déconnecter l'utilisateur lorsque la session expire. La manipulation est très simple. Il suffit de modifier le fichier '/etc/crontab'. Puis ajoutez la ligne de code suivante :

Minute Hour Day * * (s) root skill -KILL -u User

Comme précédemment, en remplaçant les horaires du champ Minute et le temps souhaité. Remplissez ensuite le jour (s) par (s) jour (s) interdit (s), ou tapez simplement un astérisque (*) pour indiquer tous les jours de la semaine. Enfin, modifiez le champ utilisé par le compte de connexion à bloquer, et voilà !

Les jours ne remarquent pas la même chose avec les cron des emplois ! Voici la liste des abréviations à utiliser avec ce programme :

mon : monday    fri : friday
tue : tuesday   sat : saturday
wed : wednesady sun : sunday
thu : thursday   *  : all hours

Quelques exemples de cron emplois (avec des exemples de temps dans la section précédente)

jessica peut se connecter le mercredi de 13h00 à 16h00.

-> Déconnexion : Mardi à 16 heures.

00 16 * root * wed skill -KILL -u jessica

mathilde est autorisée à se connecter tous les jours de 13 h 20 à 15 h 20 et de 16 h à 20 h 30.

-> Déconnexion : Tous les jours, de 20 h 30 à 15 h 20, heure de l'Est.

20 15 * * * root skill -KILL -u mathilde
30 20 * * * root skill -KILL -u mathilde

Stone, Frank et Florian sont autorisés à se connecter de 14 h à 18 h 45 en semaine, et de 14 h à 22 h 15 le week-end.

-> Déconnexion (1) : Lundi, mardi, mercredi, jeudi et vendredi, à 18:45. -> Déconnexion (2) : Samedi et dimanche à 22h15.

45 18    * * mon,tue,wed,thu,fri   root    skill -KILL -u stone && skill -KILL -u franck && skill -KILL -u florian
15 22    * * sat,sun               root    skill -KILL -u stone && skill -KILL -u franck && skill -KILL -u florian

La commande skill-KILL-u déconnecte l'utilisateur de l'interface graphique, ainsi que du TTY. Elle est parfaitement utilisable pour les administrateurs de serveurs. Cependant, cette commande est immédiate et la déconnexion se fera sans préavis. Il serait donc préférable d'empêcher l'installation de ce dispositif aux utilisateurs de l'ordinateur ou du réseau en question !

Il est possible d'empêcher les utilisateurs ayant un wall lancée par cron quelques minutes avant la fin de la cadre temporel qui sera affiché dans les terminaux de tous les utilisateurs.

40 18 * * Mon,Tue,wed,thu,fri root echo "end of session in 5 minutes" | wall

Pour empêcher les utilisateurs de l'interface graphique peut être utilisé à la place de la commande murale notify-send est dans le paquet libnotify-bin

40 18 * * Mon,Tue,wed,thu,fri stone DISPLAY=:0 notify-send "end of session in 5 minutes"

Guide de l'utilisateur d'Ubuntu 11.10

J'ai vu des utilisateurs qui avaient des problèmes avec Pam et j'ai vu beaucoup de bogues à ce sujet alors pourquoi ? ?? c'est très simple Ubuntu 11.10 ne supporte plus GDM le nouveau gestionnaire d'affichage est lightGDM le problème est le suivant où stocker cette directive account required pam_time.so Je pense que c'est dans /etc/pam.d/lightdm ou /etc/pam.d/lightdm-autologin mais le bug comment ? ??

Donc, pour faire le tour de la question, vous pouvez vérifier ces 2 fichiers journaux LightGdm :

• /var/log/lightdm/lightdm.log
• /var/log/lightdm/x-0.log

ou exécuter LightGdm en mode débogage :

LightDM --debug

ou signaler un bogue :

ubuntu-bug lightdm

Je rapporte les Bugs aquí alors croisez votre doigt et attendez....

TimeKpr

Je suppose qu'il a tout ce dont vous avez besoin. Limitez le temps d'accès par jour par utilisateur, une interface graphique facile pour la configuration, la possibilité de contourner pour un jour, ajouter un peu de "temps de récompense", notification du temps restant pour les utilisateurs, etc.

La page du projet est ici. Ils ont également un PPA pour ubuntu que vous pouvez ajouter à vos Sources de logiciels : deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. Et installer via le Centre de logiciels ou via CLI : sudo apt-get install timekpr.

L'auto-déconnexion est extrêmement frustrante si vous êtes en train de faire quelque chose. C'est violent, c'est brutal, c'est simplement impoli. Et peu importe votre âge. C'est une chose lorsque vous êtes simplement accro à l'ordinateur et c'est très différent lorsque vous suivez le temps et que vous êtes expulsé 5 secondes avant d'avoir réussi à cliquer sur ce bouton de soumission ou à sauvegarder votre document. Je vous suggère de considérer l'utilisation d'un rappel automatique au lieu d'un expulsion automatique. Cela apprendra à vos enfants à se respecter mutuellement et à se permettre mutuellement d'utiliser l'ordinateur de manière volontaire.

Il existe même une alternative plus légère. Commencez par suivre le temps que chaque enfant passe à utiliser l'ordinateur et rendez les données recueillies disponibles pour tous afin qu'ils puissent les voir. Cette chose incroyablement simple seule (appliquée à la bande passante Internet utilisée) a sauvé ma vie lorsque j'étais l'administrateur réseau dans un bureau rempli d'adultes. Les statistiques publiques sur l'utilisation de la bande passante pour chaque ordinateur (juste la quantité d'octets, pas d'informations de déanonymisation comme des listes de sites visités, etc.) ont changé la situation de "moi - l'admin maléfique et avide contre eux - les utilisateurs de bureau maltraités et pauvres" à "mec, tu as téléchargé 5 fois plus que moi, c'est mal!" "désolé, j'ai en effet téléchargé, j'ai regardé beaucoup de vidéos sur Youtube pendant les pauses déjeuner, je ne le ferai plus à ce rythme" - j'ai simplement été exclu du scénario de confrontation.

Timekpr

peut être utilisé dans 11.10 en cours d'exécution LightDM pour configurer des restrictions pour les utilisateurs en ajoutant la ligne suivante à /etc/pam.d/lightdm

account required pam_time.so

Nous devons peut-être supprimer libpam-smbpass pour activer la commutation d'utilisateur jusqu'à ce que le bug #835310 soit corrigé.

Toutes les restrictions définies dans la fenêtre de l'application fonctionnent comme défini dans l'interface graphique de timekpr.

Pour afficher l'icône timekpr-client dans Unity, nous devons ajouter à la liste blanche 'timekpr' dans les paramètres du panneau Unity, et en plus nous devons ajouter Unity à la ligne suivante dans /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Pour démarrer le compte à rebours du temps accordé, nous devrons peut-être démarrer le démon timekpr avec

/etc/init.d/timekpr start

for 14.04:

Une version / fork plus récente de timekpr a été publiée pour Ubuntu 14.04 par Eduards Bezverhijs dans son ppa:mjasnik/ppa.

J'ai eu ce problème aussi. J'ai donc écrit le kidtimer script, qui vous permet de définir les temps d'utilisation et les totaux. Le projet peut être trouvé sur Github à l'endroit suivant :

• https://github.com/grover66/kidtimer

Voici comment l'installer et l'utiliser :

1. Copiez et collez le code dans un fichier appelé kidtimer.install .

   #!/bin/bash
   # Restrict kids computer access to specific hours and total time.
   # By: Michael Groves - grover66_at_gmail_dot_com
   
   #variables
   basedir="/usr/local/kidtimer"
   configdir="/etc/kidtimer"
   Cdate=`/bin/date | awk '{ print $2" "$3 }'`
   TUI=0
   HOUR=`/bin/date +%H`
   DOW=`/bin/date +%u`
   WEEKEND="no"
   [ "$DOW" == "6" ] && WEEKEND="yes"
   [ "$DOW" == "7" ] && WEEKEND="yes"
   
   #arguments
   [ $# -eq 0 ] && TUI=1
   [ $# -eq 1 ] && COMMAND=$1
   [ $# -eq 2 ] && COMMAND=$1 && KID=$2
   [ $# -eq 3 ] && COMMAND=$1 && KID=$2 && Time=$3
   
   ################# Subroutines ##################
   ################################################
   
   go_check_install () {
   if [ ! -e $basedir ]; then
       go_initialize
   fi
   }
   
   go_initialize () {
   /bin/mkdir -p $basedir/time
   /bin/mkdir -p $basedir/schedule
   /bin/cp $0 /usr/local/bin/kidtimer && chmod +x /usr/local/bin/kidtimer
   echo "0 * * * *     root    /usr/local/bin/kidtimer hourly" > /etc/cron.d/kidtimer
   echo "0 0 * * *     root    /usr/local/bin/kidtimer daily" >> /etc/cron.d/kidtimer
   echo "* * * * *     root    /usr/local/bin/kidtimer check" >> /etc/cron.d/kidtimer
   echo "@reboot       root    /usr/local/bin/kidtimer daily" >> /etc/cron.d/kidtimer
   echo "@reboot       root    /usr/local/bin/kidtimer hourly" >> /etc/cron.d/kidtimer
   /bin/mkdir $configdir
   /usr/bin/touch $configdir/kid.list
   go_create_message_files
   echo "Kidtimer is now installed. Run /usr/local/bin/kidtimer to configure."
   }
   
   go_create_message_files () {
   cat << EOF > $basedir/send5.sh
   #!/bin/bash
   Name=\$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
       /usr/share/pixmaps/gnome-set-time.png "ALERT" \
       "You will be logged out in 5 minutes."' \$Name
   EOF
   chmod +x $basedir/send5.sh
   cat << EOF > $basedir/send4.sh
   #!/bin/bash
   Name=\$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 4 minutes."' \$Name
   EOF
   chmod +x $basedir/send4.sh
   cat << EOF > $basedir/send3.sh
   #!/bin/bash
   Name=\$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 3 minutes."' \$Name
   EOF
   chmod +x $basedir/send3.sh
   cat << EOF > $basedir/send2.sh
   #!/bin/bash
   Name=$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 2 minutes."' \$Name
   EOF
   chmod +x $basedir/send2.sh
   cat << EOF > $basedir/send1.sh
   #!/bin/bash
   Name=\$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 1 minute."' \$Name
   EOF
   chmod +x $basedir/send1.sh
   cat << EOF > $basedir/logout.sh
   #!/bin/bash
   Name=\$1
   /usr/bin/pkill -KILL -u \$Name
   rm -rf /tmp/kidtimer.shutdown.\$Name
   EOF
   chmod +x $basedir/logout.sh
   cat << EOF > $basedir/schedule/blank
   #hour weekday weekend (y/n)
   00 n n
   01 n n
   02 n n
   03 n n
   04 n n
   05 n n
   06 n n
   07 n n
   08 y y
   09 y y
   10 y y
   11 y y
   12 y y
   13 y y
   14 y y
   15 y y
   16 y y
   17 y y
   18 y y
   19 y y
   20 n n
   21 n n
   22 n n
   23 n n
   #minutes weekday weekend
   MAX 120 240
   EOF
   }
   
   go_check () {
   for I in `cat $configdir/kid.list`; do
           /usr/bin/users | grep -q $I
           if [ $? -eq 0 ]; then
                   if [ -e $basedir/time/$I.ttl ]; then
                           C=`cat $basedir/time/$I.ttl`
                           C=$((C + 1))
                           echo $C > $basedir/time/$I.ttl
                   else
                           echo 1 > $basedir/time/$I.ttl
                           C=1
                   fi
           else
           go_clean_jobs $I
           exit 0
       fi
           # check total time.
           W="no"
           [ $DOW -eq 6 ] && W="yes"
           [ $DOW -eq 7 ] && W="yes"
           [ "$W" == "no" ] && TIME_LIMIT=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $2 }'`
           [ "$W" == "yes" ] && TIME_LIMIT=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $3 }'`
           if [ $C -ge $TIME_LIMIT ]; then
                   if [ ! -e /tmp/kidtimer.shutdown.$I ]; then
                           /usr/bin/passwd $I -l
                           go_logout $I
                   fi
           fi
   done
   }
   
   go_clean_jobs () {
   K=$1
   for I in `/usr/bin/atq | awk '{ print $1 }' | sort`; do
       /usr/bin/at -c $I | grep kidtimer | grep -q $K
       [ $? -eq 0 ] && /usr/bin/at -d $I
   done
   [ -e /tmp/kidtimer.shutdown.$K ] && rm -rf /tmp/kidtimer.shutdown.$K
   }
   
   go_daily () {
   for I in `cat $configdir/kid.list`; do
       ls -l $basedir/time/$I.ttl | grep -q "$Cdate"
       if [ ! $? -eq 0 ]; then
           echo "0" > $basedir/time/$I.ttl
       fi
   done
   }
   
   go_hourly () {
   if [ -s $configdir/kid.list ]; then
       for I in `cat $configdir/kid.list`; do
           if [ -e $basedir/schedule/$I ]; then
               [ "$WEEKEND" == "no" ] && TL=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $2 }'`
               [ "$WEEKEND" == "yes" ] && TL=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $3 }'`
               [ -e $basedir/time/$I.ttl ] && C=`cat $basedir/time/$I.ttl`
               [ $C -ge $TL ] && /usr/bin/passwd $I -l && exit 0
               [ "$WEEKEND" == "no" ] && R=`grep ^$HOUR $basedir/schedule/$I | awk '{ print $2 }'`
               [ "$WEEKEND" == "yes" ] && R=`grep ^$HOUR $basedir/schedule/$I | awk '{ print $3 }'`
               if [ "$R" == "y" ]; then
                   /usr/bin/passwd $I -u
               else
                   /usr/bin/passwd $I -l
                   /usr/bin/users | grep -q $I && /usr/local/bin/kidtimer shutdown $I
               fi
           fi
       done
   fi
   }
   
   go_logout () {
   K=$1
   echo "$basedir/send5.sh $K" | at now + 1 minutes
   echo "$basedir/send4.sh $K" | at now + 2 minutes
   echo "$basedir/send3.sh $K" | at now + 3 minutes
   echo "$basedir/send2.sh $K" | at now + 4 minutes
   echo "$basedir/send1.sh $K" | at now + 5 minutes
   echo "$basedir/logout.sh $K" | at now + 6 minutes
   touch /tmp/kidtimer.shutdown.$K
   }
   
   go_addtime () {
   U=$KID
   A=$Time
   if [ "$KID" == "reset" ]; then
       echo "0" > $basedir/time/$U.ttl
       echo "Done."
       exit 0
   elif [ "$KID" == "" ]; then
       echo "Error."
       echo "Syntax: addtime <user> <minutes|reset>"
       exit 1
   else    
       C=`cat $basedir/time/$KID.ttl`
       C=$((C - Time))
       echo $C > $basedir/time/$KID.ttl
       echo "New total minutes is "$C"."
       echo "Done."
   fi
   
   /usr/bin/passwd $KID -u
   }
   
   go_tui () {
   go_command_list
   echo -n "Choose: "; read -e X
   case "$X" in
   1) go_setup_user
           ;;
   2) go_modify_user
           ;;
   3) go_remove_user
           ;;
   4) go_list_users
       ;;
   5) exit 0
           ;;
   esac
   go_tui
   }
   
   go_command_list () {
   echo
   echo "1) Setup user limits."
   echo "2) Modify user limits."
   echo "3) Remove user limits."
   echo "4) List configured users."
   echo "5) Quit."
   echo
   }
   
   go_list_users () {
   echo
   echo "Users configured for kidtimer:"
   if [ -s $configdir/kid.list ]; then
       cat $configdir/kid.list
   else
       echo "No configured users."
   fi
   }
   
   go_setup_user () {
   echo
   echo -n "Username: "; read -e U
   /usr/bin/id $U > /dev/null 2>&1
   if [ $? -eq 0 ]; then
       /bin/cp $basedir/schedule/blank $basedir/schedule/$U
       echo "0" > $basedir/time/$U.ttl
       echo $U >> $configdir/kid.list
       echo "Done."
       echo
       echo -n "Modify limits now ?(y/n): "; read -e M
       if [ "$M" == "y" ]; then
           if [ -e /usr/bin/nano ]; then
                       /usr/bin/nano $basedir/schedule/$U
                       echo "Done."
               else
                       /usr/bin/vi $basedir/schedule/$U
                       echo "Done."
               fi
       fi
   else
       echo "Error. User does not exist. Please create user using the useradd command first."
   fi
   }
   
   go_modify_user () {
   echo
   echo -n "Username: "; read -e U
   grep -q ^$U $configdir/kid.list
   if [ $? -eq 0 ]; then
       if [ -e /usr/bin/nano ]; then
           /usr/bin/nano $basedir/schedule/$U
           echo "Done."
       else
           /usr/bin/vi $basedir/schedule/$U
           echo "Done."
       fi
   else
       echo "Error. User not setup. Please setup user first."
   fi
   }
   
   go_remove_user () {
   echo
   echo -n "Username: "; read -e U
   grep -q ^$U $configdir/kid.list
   if [ $? -eq 0 ]; then
       grep -v ^$U $configdir/kid.list > /tmp/kidtimer.tmp
       cat /tmp/kidtimer.tmp > $configdir/kid.list
       echo "Done."
   else
       echo "Error. User is not setup."
   fi
   }
   
   go_help () {
   echo
   echo "Commands:"
   echo "--------------------------------------------------------------------------------"
   echo "addtime <user> <minutes> ... Increases allowed time for the day."
   echo "logout <user>            ... Starts logout sequence for user."
   echo "hourly                   ... Enables/disables user access based on the schedule."
   echo "daily                    ... Resets time for the new day."
   echo "help                     ... This list."
   echo "--------------------------------------------------------------------------------"
   }
   
   ###################### Code ####################
   ################################################
   
   go_check_install
   [ $TUI -eq 1 ] && go_tui
   
   case "$COMMAND" in
   addtime) go_addtime
       ;;
   logout) go_logout $KID
       ;;
   initialize) go_initialize
       ;;
   hourly) go_hourly
       ;;
   daily) go_daily
       ;;
   check)  go_check
       ;;
   -h) go_help
       ;;
   help) go_help
       ;;
   esac
   exit 0

2. Exécutez-le :

   sudo ./kidtimer.install

3. Exécutez-le :

   sudo kidtimer

4. Configurer un compte utilisateur existant.

5. C'est fait.

Pour de l'aide :

sudo kidtimer help

Ajouter du temps au compte d'un utilisateur (pour ce jour seulement) :

sudo kidtimer addtime user minutes

Caractéristiques :

• Autorisez votre enfant à accéder à l'ordinateur à des heures précises de la journée, en semaine comme le week-end.
• Définissez la durée maximale, tant en semaine que le week-end.

Les fichiers clés :

/etc/kidtimer/kid.list
/etc/cron.d/kidtimer
/usr/local/kidtimer/schedule/<user>
/usr/local/kidtimer/time/<user>.ttl
/usr/local/bin/kidtimer

Cronjobs :

• Vérifier toutes les minutes si l'utilisateur est connecté. Si oui, incrémenter le temps total. Si le temps maximum est atteint, le compte est désactivé et la séquence de déconnexion commence (5 minutes au total).
• Vérifier toutes les heures si l'utilisateur est autorisé à se connecter. Si c'est le cas, activez le compte.
• A minuit, remettez l'heure à zéro.

Note :

L'application utilise notify-send pour avertir l'utilisateur que le temps est compté. Lorsque le temps s'écoule, tous les processus de l'utilisateur sont terminés, alors préparez l'utilisateur.