web-dev-qa-db-fra.com

Comment puis-je limiter le temps de calcul de mes enfants?

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 o.k. (par exemple, de 17 h à 21 h)
  • les jours de la semaine où l'informatique n'est pas o.k. (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 plus disponible via ppa.
  • Timeoutd : alternative à la ligne de commande, mais à partir de 11.10 supprimée des référentiels .
  • Gnome Nanny : Belle apparence mais plante à 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?

software-recommendationbashparental-controls
60
Takkat

Verrouiller la minuterie de l'écran

systray.gif

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:

  • Utilisez geditpour créer le script lock-screen-timer
  • Copiez et collez le code depuis cette fenêtre dans lock-screen-timer
  • Marquer lock-screen-timer en tant qu'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

Utilisez geditpour créer le script lock-screen-timer

Ouvrez le Terminalen utilisant Ctrl+Alt+T et type:

gedit lock-screen-timer

Copiez et collez le code de la fenêtre ci-dessous dans 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 Unbuntu 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 fenêtre vide geditet collez le code à l'aide de Ctrl+V. Enregistrez le fichier et quittez l'éditeur pour revenir à l'invite de commande.

Marquer lock-screen-timer en tant qu'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:

Lock Screen Timer

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 à modifier le script à l'aide de geditname__. 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 sur Editdans le menu déroulant.
  2. Cliquez sur l'option Propertiesname__
  3. Cliquez sur l'onglet Behaviorname__
  4. Observez les boutons d'option radio sous Executable Text Files
  5. Cochez 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, lock-screen-timer a toujours 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 appelée Link to lock-screen-timer apparaît.
  • 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 Cancel et OK. Si vous cliquez sur Xpour fermer la fenêtre, la procédure est identique à la sélection. 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 de verrouillage du scren ou cliquer sur Cancel pour pas de compte à rebours.

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

Lorsque le minuteur d’écran de verrouillage est en cours d’exécution, il enregistre le nombre de minutes restantes dans le fichier ~/.lock-screen-timer-remaining. Vous pouvez consulter ce fichier avec la commande watchou 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? ).

1
WinEunuuchs2Unix

Ubuntu <= 11.10 L'utilisateur suit ce guide pour l'utilisateur Ubuntu> = 11.10 lit 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 aux 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 module pam_time pour contrôler l’accès chronométré des utilisateurs aux services.

À l'aide du module 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 que certains jours ou sur plusieurs 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 postulent et du terminal à partir duquel ils effectuent la demande. .

Lorsque vous utilisez pam_time, vous devez mettre fin à la syntaxe de chaque ligne (ou règle) du fichier /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 pour 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) , voire même protéger la connexion à votre serveur. à 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 anglais enfichables). 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 au /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 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, à partir 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 à partir de 13h20. à 15h20 et à partir de 16h00 à 20h30:

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

Stone, Frank et Florian sont autorisés à se connecter à 14h00. à 18h45 en semaine et à 14h00 à 10h15 pour le week-end:

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

Olive n'est jamais autorisé à se connecter. jessica peut se connecter le mercredi à partir 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. Editez 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 jours par 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 manière avec les travaux cron! 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 travaux cron (avec des exemples de fois dans la section précédente)

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

-> Déconnexion: mardi à 16h00.

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

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

-> Déconnexion: tous les jours à 20h30 à 15h20 ET.

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

Stone, Frank et Florian sont autorisés à se connecter à 14h00. à 18h45 en semaine et à 14h00 à 10h15 pour 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 commande wall lancée par cron quelques 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 peuvent être utilisés à la place de la commande murale notify-send est dans le package libnotify-binInstall X

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

Ubuntu 11.10 User

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.so je pense est dans /etc/pam.d/lightdm ou /etc/pam.d/lightdm-autologin mais bug 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 le bogue ici alors croisez votre doigt et attendez ....

38
hhlp

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 é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 installez-le via le centre logiciel ou via la CLI: Sudo apt-get install timekpr.

11
Decio Lira

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 aurons peut-être besoin de supprimer libpam-smbpass pour permettre le changement d'utilisateur jusqu'à ce que bogue n ° 83531 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 liste blanche'timekpr'dans les paramètres du panneau Unity et, en outre, 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 imparti, nous pouvons être amenés à démarrer le démon timekpr avec

/etc/init.d/timekpr start

pour 14.04:

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

8
Takkat

La déconnexion automatique est extrêmement frustrante si vous êtes au milieu de quelque chose. C'est violent, c'est brutal, c'est carrément 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 de leur plein gré.

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", m'a simplement exclu du scénario de la confrontation.

7
vh1

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:

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 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-send pour avertir 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.

6
grover66

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/ppa aux sources logicielles de 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:

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

5
hhlp

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 des privilèges Sudoname__:

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 dans les fichiers éventuellement ouverts, 60 secondes avant le délai de l'utilisateur ciblé expire, un message apparaît sur son DISPLAYname__:

enter image description here

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é: limitname__
  2. Copiez le script dans un fichier vide, enregistrez-le sous le nom 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.local pour que le script l'exécute en tant que 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 marche

  • 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 boot up , à partir de rc.local, seuls les utilisateurs dotés des privilèges Sudo peuvent arrêter le script, 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.

3
Jacob Vlijm

J'ai essayé timekpr mais 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 fichier /var/lib/timelimit/user_to_be_limited.limit avec les droits root uniquement. par exemple. 1800 pour 1800 secondes (30 minutes) limite quotidienne.

  2. Créez /usr/local/bin/timelimit.sh avec les droits racine 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

2
Csaba

Je viens de rendre une réponse disponible facilement. Le code est expliqué sur 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

2
Thomas Baeckeroot

Je viens de publier une version bêta de ma nouvelle application, LittleBrother, capable 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, si nécessaire.
  • L'hôte maître offre une interface Web simple pour afficher l'activité de l'utilisateur sur une longueur d'historique configurée (par exemple, 7 jours) et une page d'administration pour définir de manière dynamique des 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 qui demandent 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 les téléphones intelligents ou les 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 ainsi que sur les règles de temps de pause des hôtes Linux.

Quelques captures d'écran:

Status PageAdministration Page

1
Marcus Rickert