L'accès à notre ordinateur (et pas seulement à Internet) doit être limité pour les comptes de mes enfants (7, 8) jusqu'à ce qu'ils soient assez vieux pour gérer cela par eux-mêmes. Jusque-là, nous devons pouvoir définir les éléments suivants:

• les heures de la journée où l'informatique est en bon état (p. ex. 17 h à 21 h)
• les jours de la semaine où l'informatique n'est pas correcte (par exemple, du lundi au vendredi)
• le temps alloué par jour (par exemple 2 heures)

En 11.10, toutes les tâches suivantes qui faisaient le travail ne fonctionnent plus:

• Timekpr : pour> 11.10 pas plus disponible à travers le ppa.
• Timeoutd : alternative à la ligne de commande, mais retirée du référentiel à partir de 11.10 .
• Nounou Gnome : Il a l'air génial mais se bloque à plusieurs reprises pour forcer le redémarrage du serveur X. Nous ne pouvons donc pas utiliser ou recommander ce programme pour le moment.

Y a-t-il d'autres alternatives?

Verrouiller la minuterie de l'écran

Créez votre propre minuterie de verrouillage d'écran au lieu d'applications tierces

Bien qu'il existe des applications tierces pour ce faire, vous pouvez créer les vôtres. Résumé des étapes:

• Utiliser geditpour créer un scriptlock-screen-timer
• Copiez et collez le code à partir de cette fenêtre pour lock-screen-timer
• Marquer lock-screen-timercomme exécutable
• Essaye-le!
• Configurer Nautilus pour exécuter des scripts bash
• Créer un lien de raccourci sur le bureau
• Surveiller le temps restant

Utiliser geditpour créer un scriptlock-screen-timer

Ouvrez l' Terminalaide de Ctrl+ Alt+ Tet tapez:

gedit lock-screen-timer

Copiez et collez le code de la fenêtre ci-dessous pour lock-screen-timer

Revenez à cet écran et copiez le code suivant en le mettant en surbrillance et en appuyant sur Ctrl+ C:

#!/bin/bash

# NAME: lock-screen-timer
# PATH: $HOME/bin
# DESC: Lock screen in x minutes
# CALL: Place on Desktop or call from Terminal with "lock-screen-timer 99"
# DATE: Created Nov 19, 2016. Last revision Mar 22, 2018.
# UPDT: Updated to support WSL (Windows Subsystem for Linux)
#       Remove hotplugtv. Replace ogg with paplay.

# NOTE: Time defaults to 30 minutes.
#       If previous version is sleeping it is killed.
#       Zenity is used to pop up entry box to get number of minutes.
#       If zenity is closed with X or Cancel, no screen lock timer is launched.
#       Pending lock warning displayed on-screen at set intervals.
#       Write time remaining to ~/.lock-screen-timer-remaining

MINUTES="$1" # Optional parameter 1 when invoked from terminal.

# if no parameters set default MINUTES to 30
if [ $# == 0 ]; then
    MINUTES=30
fi

DEFAULT="$MINUTES" # When looping, minutes count down to zero. Save deafult for subsequent timers.

# Check if lock screen timer already running
pID=$(pgrep -f "${0##*/}") # All PIDs matching lock-screen-timer name
PREVIOUS=$(echo "$pID" | grep -v ^"$$") # Strip out this running copy ($$$)
if [ "$PREVIOUS" != "" ]; then
    kill "$PREVIOUS"
    rm ~/.lock-screen-timer-remaining
    zenity --info --title="Lock screen timer already running" --text="Previous lock screen timer has been terminated."
fi

# Running under WSL (Windows Subsystem for Linux)?
if cat /proc/version | grep Microsoft; then
    WSL_running=true
else
    WSL_running=false
fi


while true ; do # loop until cancel

    # Get number of minutes until lock from user
    MINUTES=$(zenity --entry --title="Lock screen timer" --text="Set number of minutes until lock" --entry-text="$DEFAULT")

    RESULT=$? # Zenity return code
    if [ $RESULT != 0 ]; then
        break ; # break out of timer lock screen loop and end this script.
    fi

    DEFAULT="$MINUTES" # Save deafult for subsequent timers.
    if [[ $MINUTES == 0 ]] || [[ $MINUTES == "" ]]; then
        break ; # zero minutes considered cancel.
    fi

    # Loop for X minutes, testing each minute for alert message.
    (( ++MINUTES )) 
    while (( --MINUTES > 0 )); do
        case $MINUTES in 1|2|3|5|10|15|30|45|60|120|480|960|1920)
            notify-send --urgency=critical --icon=/usr/share/icons/gnome/256x256/status/appointment-soon.png "Locking screen in ""$MINUTES"" minute(s)." ;
            if [[ $WSL_running == true ]]; then  
                powershell.exe -c '(New-Object Media.SoundPlayer "C:\Windows\Media\notify.wav").PlaySync();'
            else
               paplay /usr/share/sounds/freedesktop/stereo/complete.oga ;
            fi
           ;;
        esac;

        # Record number of minutes remaining to file other processes can read.
        echo "$MINUTES Minutes" > ~/.lock-screen-timer-remaining

        sleep 60

    done

    rm ~/.lock-screen-timer-remaining # Remove work file others can see our progress with

    if [[ $WSL_running == true ]]; then  
        # Call lock screen for Windows 10
        rundll32.exe user32.dll,LockWorkStation
    else
        # Call screen saver lock for Ubuntu versions > 14.04.
        dbus-send --type=method_call --dest=org.gnome.ScreenSaver /org/gnome/ScreenSaver org.gnome.ScreenSaver.Lock
    fi

done # End of while loop getting minutes to next lock screen

exit 0 # Closed dialog box or "Cancel" selected.

Revenez ensuite à la geditfenêtre vide et collez le code avec Ctrl+ V. Enregistrez le fichier et quittez l'éditeur pour revenir à l'invite de commande.

Marquer lock-screen-timercomme exécutable

Maintenant, nous devons rendre le script exécutable en tapant:

chmod +x lock-screen-timer

Essaye-le!

Avant d'appeler le script depuis l'interface graphique, nous l'appellerons depuis le terminal afin de voir si des messages d'erreur sont affichés:

~/lock-screen-timer

Vous êtes invité à entrer le nombre de minutes:

Définissez le nombre de minutes souhaité et cliquez sur OK pour démarrer le chronomètre. Lorsqu'il reste 15, 10, 5, 3, 2 et 1 minute, un son système est entendu et une bulle apparaît indiquant que l'écran sera verrouillé. Une fois l'écran verrouillé, vous devez entrer votre mot de passe pour le déverrouiller.

Configurer Nautilus pour exécuter des scripts bash

Nautilus définit ce qui se produit lorsque l'on double-clique sur un script exécutable lorsqu'il s'agit de la fenêtre d'affichage des fichiers ou d'un lien sur le bureau. Le comportement normal consiste à éditer le script avec gedit. Nous voulons changer ce comportement pour qu'il soit exécuté.

Démarrez Nautilus et accédez au répertoire contenant lock-screen-timer. Cliquez dessus une fois pour le mettre en évidence. Passez la souris sur la barre de menu supérieure jusqu'à ce que le menu "Fichier Éditer ..." apparaisse, utilisez:

1. Cliquez Editsur le menu déroulant
2. PropertiesOption de clic
3. Cliquez sur l' Behavioronglet
4. Observez les boutons d’option radio sous Executable Text Files
5. Vérifiez le bouton radio Run executable text files when they are opened

Créer un lien de raccourci sur le bureau

De la section précédente a lock-screen-timertoujours le focus. Sinon, naviguez jusqu'au script et cliquez une fois dessus pour le mettre en évidence. Alors utilisez:

• Faites un clic droit sur le fichier et les options du menu contextuel apparaissent.
• Dans le menu, sélectionnez Make Link.
• Une nouvelle icône apparaît appelée Link to lock-screen-timer.
• Faites un clic gauche sur la nouvelle icône et faites-la glisser de Nautilus sur votre bureau.

Maintenant, vous pouvez double-cliquer sur le lien de raccourci sur le bureau et le script est exécuté. Une boîte de dialogue apparaît pour obtenir le nombre de minutes. Deux boutons sont présentés Cancelet OK. Si vous cliquez sur Xpour fermer la fenêtre, le choix est identique Cancel.

Une fois que le chronomètre est en marche et que vous double-cliquez dessus, la première copie en cours est "tuée". Vous pouvez maintenant commencer un nouveau compte à rebours pour le verrouillage du scren ou cliquer Cancelpour ne pas compter.

Temps d'affichage restant dans la zone de notification / système

Pendant le fonctionnement de l’écran de verrouillage, il enregistre le nombre de minutes restantes dans le fichier ~/.lock-screen-timer-remaining. Vous pouvez consulter ce fichier à l'aide de la watchcommande ou l'afficher dans la barre d'état de la barre d'état système / application d'Ubuntu, comme indiqué en haut de cette réponse. Pour afficher le temps restant dans la zone de notification, suivez les instructions de ce Q & A: ( BASH peut-il afficher le tableau de bord en tant qu'indicateur d'application? ).

Ubuntu <= 11.10 L'utilisateur suit ce guide pour l'utilisateur Ubuntu> = 11.10, lisez la notice de la page du bas:

Oui, tous ces programmes sont obsolètes et toutes vos questions sont répondues ici et regardez bien avec votre contrôle parent .....

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

Le module d’authentification enfichable (PAM) est un mécanisme d’authentification des utilisateurs. Plus précisément, nous allons utiliser le pam_timemodule pour contrôler l'accès chronométré des utilisateurs aux services.

À l'aide du pam_timemodule, nous pouvons définir des restrictions d'accès à un système et / ou à des applications spécifiques à différents moments de la journée, ainsi que certains jours ou sur différentes lignes de terminaux. En fonction de la configuration, vous pouvez utiliser ce module pour refuser l'accès à des utilisateurs individuels en fonction de leur nom, de l'heure, du jour de la semaine, du service pour lequel ils demandent et du terminal à partir duquel ils effectuent la demande. .

Lors de l'utilisation pam_time, vous devez mettre fin à la syntaxe de chaque ligne (ou règle) du /etc/security/time.conffichier 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 de règles typique:

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 h et 20 h, ainsi que l'accès à Internet pendant ces heures. Root pourrait se connecter à tout moment et naviguer sur Internet à tout moment.

Remarque: Le système enregistre les erreurs avec ces règles en tant que syslog (3).

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

Configuration manuelle

Comprends ce que tu vas faire

Tout au long de ce didacticiel, nous utiliserons PAM (modules d’authentification enfichables, modules d’authentification enfichables en anglais). Il vous permet de contrôler l'authentification des utilisateurs lorsqu'ils se connectent. Ensuite, nous utiliserons les fichiers de configuration de la 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 n'en nommer que quelques-unes). Activer les heures de restriction via le module PAM

Tout d’abord, allez à /etc/pam.d/, où sont 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 changer le service gdm. Editez le fichier de manière gdm et ajoutez cette ligne de code (à la fin du fichier):

account required pam_time.so

GDM est la distribution d'écran de connexion Ubuntu, Edubuntu et Xubuntu. Pour Kubuntu, qui utilise KDE, le service kdm est appelé, ce sera le fichier qu'il ouvrira. Et vous avez terminé de configurer le PAM! Cela permettra 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 nom de connexion du même fichier et ajouter la même ligne de code que celle précédemment acceptée. Cette action s’applique également aux personnes ayant installé une interface graphique et souhaitant 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 reste plus qu'à configurer les temps d'accès. Ouvrez le /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

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

*;*;user;scheduler

Au lieu du champ utilisateur, entrez le compte de connexion que vous souhaitez bloquer.

Si vous souhaitez bloquer plusieurs utilisateurs, entrez leurs identifiants dans une rangée, séparés par le symbole | opérateur. Par exemple, si je veux geler les comptes de Patrick, John et Emily:

*;*;Patrick|jean|emilie;scheduler

Par contre, si vous souhaitez bloquer l’accès au système pour tous les utilisateurs sauf 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, à l'exception de Nicolas et Xavier:

Nicolas *;*;!|xavier;scheduler

Passons maintenant aux zones de terrain. 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é sur Internet: vous pouvez facilement trouver des informations contradictoires!

Ensuite, nous spécifions les délais. Ceux-ci devraient être formatés 24H, composé de 4 chiffres. Par exemple, pour limiter 15h17 à 18h34, nous écrivons: 1517-1834. Pour permettre à Marie de ne se connecter que le mardi, de 15h17 à 18h34, on obtient le résultat:

*;*;marie;Tu1517-1834

Les connexions en dehors de ces heures seront interdites. Quant aux utilisateurs, il est possible d'utiliser les opérateurs | et! pour indiquer plusieurs fois (les! indiquent ensuite que toutes les heures de connexion sont autorisées, à l'exception de celles à afficher).

Les deux étoiles (caractères génériques) au début de la ligne de code sont, respectivement, et les champs de services tty. Puisque vous souhaitez bloquer tous les accès au système, il est inutile de spécifier quel service ou quel terminal vous souhaitez bloquer. Toutefois, si vous souhaitez empêcher l'utilisation d'un service particulier, spécifiez-le simplement à l'aide de l'exemple suivant:

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

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

Quelques exemples de calendrier de restrictions

mathilde est autorisée à se connecter tous les jours de 13h20 à 15h20 et de 16h00 à 20h30:

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

Stone, Frank et Florian sont autorisés à se connecter de 14h00 à 18h45 en semaine et de 14h00 à 22h15 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 heures différentes pour chaque utilisateur Expiration d'une session

Lorsqu'une session expire (la durée dépasse le moment où l'utilisateur est déjà connecté), le PAM peut atteindre l'utilisateur. Bien que mathilde se connecte pendant les heures autorisées, il est parfaitement libre de les dépasser! Pour cela, nous allons utiliser un nouveau programme: "cron". Cette application exécute des commandes à intervalles de temps. Dans notre cas, nous utiliserons la commande "Skill-KILL-u" pour déconnecter l'utilisateur à l'expiration de la session. La manipulation est très simple. Éditez simplement le fichier ´ / etc / crontab´. Ajoutez ensuite la ligne de code suivante:

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

Comme auparavant, remplacez les horaires et champs souhaités pour le champ Minute. Indiquez ensuite le ou les jour (s) jour (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 pour le bloquer, et le tour est joué!

Les jours ne se remarquent pas de la même façon avec les cronemplois! 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 d' cronemplois (avec des exemples de fois dans la section précédente)

Jessica peut se connecter le mercredi de 13h à 16h

-> Déconnexion: mardi à 16h00.

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

mathilde est autorisée à se connecter tous les jours de 13h20 à 15h20 et de 16h00 à 20h30.

-> Déconnexion: tous les jours, de 20h30 à 15h20, 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 14h00 à 18h45 en semaine et de 14h00 à 22h15 le week-end.

-> Déconnexion (1): lundi, mardi, mercredi, jeudi et vendredi à 18h45. -> Disconnect (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 le TTY. Il est parfaitement utilisable par les administrateurs de serveur. Cependant, cette commande est immédiate et la déconnexion sera faite sans préavis. Il serait donc préférable d’empêcher l’installation de ce périphérique utilisateurs de l’ordinateur ou du réseau en question!

Il est possible d'empêcher les utilisateurs avec une wallcommande lancée cronquelques minutes avant la fin de la période , qui sera affichée 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 GUI peut être utilisé à la place de la commande wall notify-sendest dans le package libnotify-bin

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

Ubuntu 11.10 Utilisateur

J'ai vu autour de l'utilisateur avoir des problèmes avec Pam et j'ai vu beaucoup de bugs à ce sujet alors pourquoi est la raison ??? est si simple Ubuntu 11.10 ne supporte plus GDM plus le nouveau gestionnaire d’affichage est lightGDM le problème est le suivant où stocker cette directive account required pam_time.soje pense est /etc/pam.d/lightdmou /etc/pam.d/lightdm-autologinbogue comment ???

vous pouvez donc vérifier ces 2 fichiers journaux LightGdm:

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

ou exécutez LightGdm en mode débogage:

LightDM - debug

ou signaler un bug:

ubuntu-bug lightdm

Je signale que le bogue est ici, alors croisez votre doigt et attendez ....

TimeKpr

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

La page du projet est ici . Ils ont aussi un PPA pour ubuntu que vous pouvez ajouter à vos sources Software: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. Et installer via Software Center ou via CLI: sudo apt-get install timekpr.

Timekpr

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

account required pam_time.so

^{Nous devrons peut-être supprimer libpam-smbpass pour permettre le changement d'utilisateur jusqu'à ce que le bogue n ° 835310 soit corrigé.}

Toutes les restrictions définies dans la fenêtre de l'application fonctionnent comme définies 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. Nous devons également ajouter des éléments Unityà la ligne suivante /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Pour démarrer le compte à rebours du temps imparti, il peut être nécessaire de démarrer le démon timekpr avec

/etc/init.d/timekpr start

pour 14.04:

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

La déconnexion automatique est extrêmement frustrante si vous êtes au milieu de quelque chose. C'est violent, c'est brutal, c'est tout simplement grossier. Et peu importe votre âge. C'est une chose lorsque vous êtes simplement accro à l'informatique et c'est très différent lorsque vous faites le suivi du temps et que vous êtes expulsé 5 secondes avant que vous ayez réussi à cliquer sur ce bouton d'envoi ou à enregistrer votre document. Je vous suggère d’envisager d’utiliser un rappel automatique au lieu d’un kicker automatique. Cela apprendra à vos enfants à se respecter et s’autorisera à utiliser l'ordinateur volontairement.

Il y a même une alternative plus légère. Commencez par suivre le temps passé par chaque enfant à utiliser l'ordinateur et rendez les données rassemblées disponibles pour tous afin qu'il puisse les voir. Cette chose incroyablement simple à elle seule (appliquée à la bande passante Internet utilisée) m'a sauvé la vie quand j'étais 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 les informations de désanonymisation telles que les listes de sites visités, etc.) ont transformé la situation de "moi - le mauvais administrateur glouton contre eux - les pauvres utilisateurs de bureau maltraités" en "homme, vous avez téléchargé 5 fois plus que moi, c'est mauvais! " "désolé, j'ai effectivement téléchargé, j'ai regardé beaucoup de youtube pendant les pauses déjeuner, je ne le ferai plus à ce rythme" - j'ai tout simplement été exclu du scénario de la confrontation.

J'ai eu ce problème aussi. J'ai donc écrit le script kidtimer, qui vous permet de définir les temps d'utilisation et les totaux. Le projet peut être trouvé sur Github à l’emplacement 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. L'exécuter:

   sudo ./kidtimer.install

3. Exécuter:

   sudo kidtimer

4. Configurez un compte d'utilisateur existant.

5. Terminé.

Pour aider:

sudo kidtimer help

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

sudo kidtimer addtime user minutes

Fonctionnalités:

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

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érifiez toutes les minutes pour voir si l'utilisateur est connecté. Si c'est le cas, incrémentez la durée totale. Si vous atteignez l'heure maximale, désactivez le compte et démarrez la séquence de déconnexion (5 minutes au total).
• Vérifiez toutes les heures pour voir si l'utilisateur est autorisé à se connecter. Si oui, activez le compte.
• À minuit, réinitialiser l'heure.

Remarque:

L'application utilise notify-sendpour alerter l'utilisateur que le temps est compté. Lorsque le temps imparti est écoulé, tous les processus utilisateur sont terminés. Préparez donc l'utilisateur.

timekpr - Ce programme suivra et contrôlera l'utilisation de vos comptes d'utilisateurs par l'ordinateur. Vous pouvez limiter leur utilisation quotidienne en fonction d'une durée d'accès programmée et configurer des périodes de la journée où ils peuvent ou ne peuvent pas se connecter. Avec cette application, les administrateurs peuvent limiter la durée de connexion au compte ou le nombre d'heures d'accès au compte. L'application fonctionne comme un contrôle du temps parental et sera utile aux parents qui souhaitent limiter le temps d'accès des enfants.

Even Nedberg proposed the following answer:
Just started copying into the 11.10 version for the PPA. Should finish
in a few minutes.

Vous pouvez mettre à jour votre système avec des packages non pris en charge à partir de ce PPA non approuvé en ajoutant ppa:timekpr-maintainers/ppades sources de logiciels à votre système.

deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu oneiric main 
deb-src http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu oneiric main 

Ce forfait est disponible en:

• Problème onirique voir le rapport de bogue ....
• natty
• Maverick
• lucide
• Karmique
• Désinvolte
• Intrépide

• Robuste

• Que sont les PPA et comment les utiliser?

PROBLÈME:

Je signale que le bogue est ici, alors croisez votre doigt et attendez ....

introduction

Nous pouvons vérifier si un utilisateur est connecté avec la commande:

who -u

ce qui nous donne une sortie comme:

$ who -u
jacob    :0           2016-03-17 20:48   ?          2557 (:0)
newuser  :1           2016-03-17 20:50   ?          4466 (:1)

Dans la sortie, nous obtenons le pid de l'utilisateur ciblé, qui doit être interrompu si le temps dépasse la limite.

La solution

En supposant que votre utilisateur ne dispose pas de sudoprivilèges:

Cette solution est un petit script d'arrière-plan. Il limite l'utilisation quotidienne à un nombre défini de minutes, à définir dans l'en-tête du script. Une fois installé (ce qui n’est pas trop difficile), la procédure est très simple et aucune action supplémentaire n’est nécessaire par la suite.

Pour éviter la perte de données non souhaitée de fichiers éventuellement ouverts 60 secondes avant l'expiration du délai imparti à l'utilisateur ciblé, un message apparaîtra sur celui-ci DISPLAY:

Le scénario

#!/usr/bin/python3
import subprocess
import os
import sys
import time


#--- set the time limit below (minutes)
minutes = 120
#--- set the user name to limit below
user = "newuser"

uselog = "/opt/limit/uselog"
datefile = "/opt/limit/currdate"

def read(f):
    try:
        return int(open(f).read().strip())
    except FileNotFoundError:
        pass

def message(disp, user):
    return "DISPLAY="+disp+" su - "+user+" -c "+'"'+\
      "notify-send 'User "+user+\
      " will be logged off in 60 seconds'"+'"'


currday1 = read(datefile)

while True:
    time.sleep(10)
    currday2 = int(time.strftime("%d"))
    # check if the day has changed, to reset the used quantum
    if currday1 != currday2:
        open(datefile, "wt").write(str(currday2))
        try:
            os.remove(uselog)  
        except FileNotFoundError:
            pass
    # if the pid of the targeted process exists, add a "tick" to the used quantum
    check = subprocess.check_output(["who", "-u"]).decode("utf-8")
    pid = [l.split() for l in check.splitlines() if user in l]
    if pid:
        n = read(uselog)
        n = n + 1 if n != None else 0
        open(uselog, "wt").write(str(n))
        # when time exceeds the permitted amount, kill the process
        if n > minutes*6:
            disp = [d for d in [d[1] for d in pid] if all([":" in d, not "." in d])][0]
            subprocess.Popen(["/bin/bash", "-c", message(disp, user)])
            time.sleep(60)
            pids = [p[-2] for p in pid]
            for p in pids:
                subprocess.Popen(["kill", p])  

    currday1 = currday2

Comment utiliser

1. Sur votre bureau (ou ailleurs), créez un dossier nommé: limit
2. Copiez le script dans un fichier vide, enregistrez-le sous limit_use(sans extension) dans le dossier et rendez-le exécutable.

3. Modifiez dans l'en-tête du script le nom d'utilisateur à limiter et le nombre maximal de minutes autorisées. Dans l'exemple:

   #--- set the time limit below (minutes)
   minutes = 1
   #--- set the user name to limit below
   user = "jacob"

4. Copiez le dossier dans le répertoire /opt:

   cp -r /path/to/limit /opt

5. Maintenant, éditez /etc/rc.localpour que le script l'exécute comme rootau démarrage:

   sudo -i gedit /etc/rc.local

   Juste avant la ligne

   exit 0

   une autre ligne:

   /opt/limit/limit_use &

Explication; Comment ça fonctionne

• Une fois toutes les 10 secondes, le script recherche si l'utilisateur ciblé est connecté. Si c'est le cas, il ajoute "un" point à une utilisation totale, à enregistrer dans un fichier ( /opt/limit/uselog). Si la limite quotidienne est atteinte, le script n'autorise plus la connexion de l'utilisateur et tue son processus s'il existe.
• Lors du changement de jour (la date est enregistrée dans un fichier, le redémarrage ne vous aidera pas), le fichier journal est supprimé, ce qui permet une nouvelle durée d'utilisation.
• Étant donné que le script s'exécute au démarrage , rc.localseuls les utilisateurs dotés des privilèges sudo peuvent l'arrêter, même si l'utilisateur connaît le nom du processus.

Arrête le script

Si vous souhaitez arrêter le script, utilisez la commande suivante:

sudo kill "$(pgrep limit_use)"

Mais vous aurez besoin du mot de passe sudo pour le faire.

J'ai essayé timekprmais je ne l'ai pas fait fonctionner. Puis fait une variante de celui-ci qui fonctionne sur mon Ubuntu. Voici ce qu'il faut faire pour cette variante:

1. Ajouter une limite de temps dans le /var/lib/timelimit/user_to_be_limited.limitfichier avec les droits root uniquement. par exemple, 1800 pour une limite quotidienne de 1 800 secondes (30 minutes).

2. Créer /usr/local/bin/timelimit.shavec les droits root avec les éléments suivants:

   #!/bin/bash
   
   pollTime=30
   export DISPLAY=:0
   
   while(true); do
       sleep $pollTime
       usersLogedIn=$( users|sed -e 's/\s\+/\n/g'|sort|uniq )
       for userName in $usersLogedIn; do
           if [[ -e "/var/lib/timelimit/$userName.limit" ]]
           then
               if [[ ! -e "/var/lib/timelimit/$userName.time" || `( stat -c '%z'  /var/lib/timelimit/$userName.time|cut -c9,10 )` != `date +%d` ]]
               then 
                   echo $pollTime > /var/lib/timelimit/$userName.time
               else
                   timeUsed=$(( `cat /var/lib/timelimit/$userName.time` + $pollTime ))
                   echo $timeUsed > /var/lib/timelimit/$userName.time
               fi
               if [[ `cat /var/lib/timelimit/$userName.time` -gt `cat /var/lib/timelimit/$userName.limit` ]]
               then
                   export XAUTHORITY=/home/$userName/.Xauthority
                   notify-send --icon=gtk-dialog-warning --urgency=critical -t 30000 "$userName" "You have 60 seconds left!"
                   sleep 60
                   pkill -u $userName
               fi
           fi
       done
   done

3. Ajouter à /etc/rc.local:

   sudo /usr/local/bin/timelimit.sh &

4. Redémarrer Ubuntu

Je viens de rendre une réponse disponible facilement. Le code est expliqué à la discussion http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 . En bref: une limite configurée en minutes par jour, un travail cron toutes les minutes, un message à l'utilisateur pour le tenir informé et une fermeture de session forcée.

Pour télécharger et installer ceci, ouvrez un terminal et exécutez les commandes ci-dessous:

cd /tmp/
git clone https://github.com/Thomas-Baeckeroot/ParentalControl.git
cd ParentalControl/
./install.sh

Un mot de passe administrateur sera demandé lors de l'installation (installer le travail cron, copier le script,…). De là, vous serez guidé pour tous. Il existe également un fichier ./uninstall.sh au même endroit, juste au cas où. Il est construit pour fonctionner avec toutes les distributions basées sur Ubuntu (Mint, etc… probablement aussi avec debian également). Si un problème survient, merci de me le signaler, y compris la version du système et l'environnement graphique dans les commentaires:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

Je viens de publier une version bêta de ma nouvelle application LittleBrothercapable de surveiller le temps de lecture sur des machines Linux. Les utilisateurs de test sont invités à essayer le paquet Debian. Des instructions sur la façon de le télécharger et de l’utiliser peuvent être trouvées ici: https://github.com/marcus67/little_brother . L'installation peut encore être un peu rude, cependant. Ce sont les fonctionnalités de l'application:

• N'importe quel nombre d'utilisateurs peut être surveillé.
• Chaque utilisateur peut avoir un ensemble spécifique de règles définissant la durée de lecture autorisée.
• Les règles peuvent être adaptées à des "contextes", tels que le jour de la semaine et / ou un programme de vacances (actuellement, seuls les programmes en allemand sont pris en charge).
• La durée de lecture peut être limitée à une fenêtre temporelle (de, à).
• Un temps de jeu maximum par jour peut être défini.
• Les utilisateurs peuvent être obligés de faire une pause après un certain temps maximal de session.
• Les utilisateurs peuvent être obligés d'attendre un temps de pause minimum après leur activité.
• Vous pouvez surveiller n'importe quel nombre d'hôtes clients Linux (pour le moment, les utilisateurs doivent avoir la même connexion sur toutes les machines).
• Il y a un hôte principal avec un historique des activités de tous les utilisateurs. Cet hôte maître vérifie les ensembles de règles et invite les hôtes clients à mettre fin aux processus, le cas échéant.
• L'hôte principal offre une interface Web simple permettant de visualiser l'activité de l'utilisateur sur une longueur d'historique configurée (par exemple, 7 jours) et une page d'administration permettant de définir de manière dynamique les exceptions de règles pour un nombre de jours configuré dans le futur.
• L'application Web peut être exécutée derrière un proxy afin d'être accessible de l'extérieur, ce qui permet une administration à distance après avoir reçu des appels de jeunes utilisateurs demandant plus de temps de lecture.
• L'application prend en charge les langues internationales. Des traductions anglaise et allemande sont actuellement fournies. Les utilisateurs sont invités à fournir des traductions dans d'autres langues.
• L'application utilise la génération de voix pour informer l'utilisateur des déconnexions forcées imminentes. De plus, ces messages parlés sont internationalisés.
• En plus du temps passé sur les hôtes Linux, l'application peut également surveiller le temps d'activité sur d'autres périphériques tels que des téléphones intelligents ou des tables. Il tire parti du fait que la plupart des systèmes d'exploitation modernes mettent les périphériques en mode d'économie d'énergie lorsqu'ils ne sont pas utilisés. De cette façon, la réponse du réseau (par ping) peut être utilisée pour déterminer l'activité sur ces périphériques. Contrairement aux hôtes Linux, l'application ne pourra pas mettre fin à l'activité. Cependant, le temps de jeu sera ajouté au temps de jeu total et aura donc un impact sur le temps imparti et sur les règles de temps de pause des hôtes Linux.

Quelques captures d'écran: