Der Zugriff auf unseren Computer (nicht nur auf das Internet) muss für die Konten meiner Kinder (7, 8) eingeschränkt werden, bis sie alt genug sind, um dies selbst zu verwalten. Bis dahin müssen wir Folgendes definieren können:

• die Stunden des Tages, an denen die Datenverarbeitung in Ordnung ist (z. B. 17 - 21 Uhr)
• die Wochentage, an denen das Rechnen nicht in Ordnung ist (z. B. Montag bis Freitag)
• die pro Tag erlaubte Zeit (zB 2 Stunden)

In 11.10 funktionieren die folgenden Funktionen nicht mehr:

• Timekpr : für> 11.10 nicht mehr über die ppa verfügbar.
• Timeoutd : Kommandozeilenalternative, aber ab 11.10 aus den Repositories entfernt .
• Gnome Nanny : Sieht gut aus, stürzt aber wiederholt ab , um einen Neustart des X-Servers zu erzwingen. Aus diesem Grund können wir dieses Programm derzeit nicht verwenden oder empfehlen.

Gibt es noch andere Alternativen?

Bildschirm-Timer sperren

Erstellen Sie Ihren eigenen Bildschirmsperr-Timer anstelle von Anwendungen von Drittanbietern

Obwohl es hierfür Anwendungen von Drittanbietern gibt, können Sie Ihre eigenen erstellen. Zusammenfassung der Schritte:

• Verwenden Sie geditdiese Option , um ein Skript zu erstellenlock-screen-timer
• Kopieren Sie den Code aus diesem Fenster und fügen Sie ihn in ein lock-screen-timer
• Mark lock-screen-timerals ausführbares
• Probier es aus!
• Konfigurieren Sie Nautilus zum Ausführen von Bash-Skripten
• Erstellen Sie einen Desktop-Verknüpfungslink
• Verbleibende Zeit überwachen

Verwenden Sie geditdiese Option , um ein Skript zu erstellenlock-screen-timer

Öffne das Terminalmit Ctrl+ Alt+ Tund tippe:

gedit lock-screen-timer

Kopieren Sie den Code aus dem folgenden Fenster und fügen Sie ihn in ein lock-screen-timer

Kehren Sie zu diesem Bildschirm zurück und kopieren Sie den folgenden Code, indem Sie ihn markieren und Ctrl+ drücken 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.

Wechseln Sie dann zurück in das leere geditFenster und fügen Sie den Code mit Ctrl+ ein V. Speichern Sie die Datei, und beenden Sie den Editor, und kehren Sie zur Eingabeaufforderung zurück.

Mark lock-screen-timerals ausführbares

Jetzt müssen wir das Skript ausführbar machen, indem wir Folgendes eingeben:

chmod +x lock-screen-timer

Probier es aus!

Bevor wir das Skript von der GUI aufrufen, rufen wir es vom Terminal aus auf, damit wir sehen können, ob Fehlermeldungen angezeigt werden:

~/lock-screen-timer

Sie werden aufgefordert, die Anzahl der Minuten einzugeben:

Stellen Sie die gewünschte Anzahl von Minuten ein und klicken Sie auf OK, um den Timer zu starten. Wenn noch 15, 10, 5, 3, 2 und 1 Minute (n) vergangen sind, ertönt ein Systemton und eine Meldung mit dem Hinweis, wann der Bildschirm gesperrt wird. Nachdem der Bildschirm gesperrt wurde, müssen Sie Ihr Kennwort eingeben, um den Bildschirm zu entsperren.

Konfigurieren Sie Nautilus zum Ausführen von Bash-Skripten

Nautilus definiert, was passiert, wenn wir auf ein ausführbares Skript doppelklicken, wenn es sich um das Dateianzeigefenster oder einen Link auf dem Desktop handelt. Normalerweise bearbeiten Sie das Skript mit gedit. Wir möchten dieses Verhalten so ändern, dass es ausgeführt wird.

Starten Sie Nautilus und navigieren Sie zu dem Verzeichnis, das enthält lock-screen-timer. Klicken Sie einmal mit der linken Maustaste darauf, um den Fokus zu erhalten. Bewegen Sie die Maus über die obere Menüleiste, bis das Menü "Datei bearbeiten ..." angezeigt wird. Verwenden Sie:

1. Klicken Sie auf das EditDropdown-Menü
2. PropertiesOption anklicken
3. Klicken Sie auf die BehaviorRegisterkarte
4. Beachten Sie die Optionsfelder unter Executable Text Files
5. Aktivieren Sie das Optionsfeld Run executable text files when they are opened

Erstellen Sie einen Desktop-Verknüpfungslink

Aus dem vorherigen Abschnitt hat lock-screen-timerimmer noch den Fokus. Wenn nicht, navigieren Sie zum Skript und klicken Sie einmal mit der linken Maustaste darauf, um es in den Fokus zu setzen. Dann benutze:

• Klicken Sie mit der rechten Maustaste auf die Datei und die Optionen des Kontextmenüs werden angezeigt.
• Wählen Sie im Menü Make Link.
• Ein neues Symbol wird aufgerufen Link to lock-screen-timer.
• Klicken Sie mit der linken Maustaste auf das neue Symbol und ziehen Sie es von Nautilus auf Ihren Desktop.

Jetzt können Sie auf den Desktop-Verknüpfungslink doppelklicken und das Skript wird ausgeführt. In einem Dialogfeld wird die Anzahl der Minuten angezeigt. Es werden zwei Schaltflächen Cancelund angezeigt OK. Wenn Sie auf klicken X, um das Fenster zu schließen, entspricht dies der Auswahl Cancel.

Nachdem der Timer läuft und Sie erneut darauf doppelklicken, wird die erste laufende Kopie "getötet". Sie können jetzt einen neuen Scren-Lock-Countdown starten oder auf klicken, Cancelum keinen Countdown zu starten .

Verbleibende Zeit im Systray / Benachrichtigungsbereich anzeigen

Während der Sperrbildschirm-Timer läuft, wird aufgezeichnet, wie viele Minuten noch in der Datei verbleiben ~/.lock-screen-timer-remaining. Sie können diese Datei mit dem watchBefehl anzeigen oder sie in der Taskleiste / Anwendungsanzeigeleiste von Ubuntu anzeigen, wie oben in dieser Antwort gezeigt. Befolgen Sie die Anweisungen in diesen Fragen und Antworten , um die verbleibende Zeit im Infobereich anzuzeigen : ( Kann BASH im Systray als Anwendungsindikator angezeigt werden? ).

Ubuntu <= 11.10 Benutzer folgen dieser Anleitung für Ubuntu Benutzer> = 11.10 Lesen Sie den Hinweis auf der Unterseite:

Ja, alle diese Programme sind veraltet und alle Ihre Fragen werden hier beantwortet.

Wenn es darum geht, einen Benutzer zum Abmelden zu zwingen, geht es tatsächlich darum, zeitliche Einschränkungen für das Konto für den Systemzugriff oder die Dienste zu implementieren. Die einfachste Möglichkeit, Zeitbeschränkungen zu implementieren, ist die Verwendung eines Plug-In-Moduls namens Linux-PAM .

Pluggable Authentication Module (PAM) ist ein Mechanismus zur Authentifizierung von Benutzern. Insbesondere werden wir das pam_timeModul verwenden, um den zeitgesteuerten Zugriff für Benutzer auf Dienste zu steuern.

Mit dem pam_timeModul können wir zu verschiedenen Tageszeiten sowie an bestimmten Tagen oder über verschiedene Terminalleitungen Zugriffsbeschränkungen für ein System und / oder bestimmte Anwendungen festlegen. Abhängig von der Konfiguration können Sie mit diesem Modul den Zugriff auf einzelne Benutzer anhand ihres Namens, der Uhrzeit, des Wochentags, des Dienstes, für den sie sich bewerben, und des Terminals verweigern, von dem aus sie die Anfrage stellen .

Bei der Verwendung pam_timemüssen Sie die Syntax jeder Zeile (oder Regel) in der /etc/security/time.confDatei mit einer neuen Zeile beenden. Sie können jede Zeile mit dem Nummernzeichen [#] kommentieren, und das System ignoriert diesen Text bis zur neuen Zeile.

Hier ist die Syntax für eine Regel:

Dienstleistungen; ttys; Benutzer; Zeiten

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.

Hier ist ein Beispiel für ein typisches Regelwerk:

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

Diese Regeln verhindern, dass sich Benutzer von Bobby zwischen 08:00 und 2000 anmelden können, und sie beschränken auch den Internetzugang während dieser Zeiten. Root kann sich jederzeit anmelden und jederzeit im Internet surfen.

Hinweis: Das System protokolliert Fehler mit diesen Regeln als syslog (3).

Mit Ubuntu Linux ist es möglich, Ihrem Computer Zeitbeschränkungen zuzuweisen, um die Verbindung eines oder mehrerer Benutzer mit Ihrem System zu verhindern. Mit den zeitlichen Einschränkungen können Sie beispielsweise den Zugriff auf den Computer für Ihre Kinder einschränken (eine Art Kindersicherung , kurz gesagt) oder sogar die Verbindung zu Ihrem Server zu bestimmten Zeiten schützen.

Manuelle Konfiguration

Verstehe, was du tun wirst

In diesem Lernprogramm werden PAM (Pluggable Authentication Modules, Englisch Pluggable Authentication Modules) verwendet. Sie können die Benutzerauthentifizierung steuern, wenn eine Verbindung hergestellt wird. Anschließend definieren wir anhand der Sicherheitskonfigurationsdateien die zulässigen Anmeldestunden. Diese Manipulationen können auf jeder Ubuntu-Version durchgeführt werden und erfordern nur einen einfachen Texteditor (vim, emacs, nano, gedit, kate, um nur einige zu nennen). Aktivieren Sie die Stundenbeschränkungen über das PAM-Modul

Gehen Sie zunächst zu /etc/pam.d/, wo sich alle konfigurierbaren Dienste befinden:

$ 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

Wenn wir die Verbindung zum Computer blockieren möchten, müssen wir den GDM-Dienst ändern. Bearbeiten Sie die Datei so gdm und fügen Sie diese Codezeile (am Ende der Datei) hinzu:

account required pam_time.so

GDM ist die Anmeldebildschirm-Distributionen Ubuntu, Edubuntu und Xubuntu. Für Kubuntu, das KDE verwendet, wird der kdm-Dienst aufgerufen. Dies ist die Datei, die geöffnet wird. Und fertig mit der Konfiguration des PAM! Dies ermöglicht die Kontrolle der Stunden für diesen Dienst.

Wenn Sie einen Server haben, haben Sie wahrscheinlich keine GUI. In diesem Fall ist GDM / KDM nicht installiert und die Verbindung wird nicht blockiert. Um eine Verbindung zu TTY zu verhindern, müssen Sie die Anmeldung derselben Datei ändern und dieselbe Codezeile hinzufügen, die zuvor bestätigt wurde. Diese Aktion gilt auch für Personen, die eine grafische Benutzeroberfläche installiert haben und den Zugriff auf den Anmeldebildschirm und die Terminals blockieren möchten.

Konfigurieren Sie die Zugriffszeiten

Nachdem der PAM-Dienst aktiviert wurde, müssen wir nur noch Zugriffszeiten konfigurieren. Öffnen Sie die /etc/security. Es stehen verschiedene Konfigurationsdateien zur Verfügung:

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

Bearbeiten Sie die Datei time.conf. Einige Erklärungen und Beispiele (englisch) zur Einführung des. Kopieren Sie zum Festlegen von Zugriffszeitplänen die folgende Codezeile und fügen Sie sie ein (wie immer am Ende der Datei):

*;*;user;scheduler

Geben Sie anstelle des Benutzerfelds das Anmeldekonto ein, das Sie sperren möchten.

Wenn Sie mehrere Benutzer sperren möchten, geben Sie ihre Anmeldedaten in einer Reihe ein, die durch | getrennt sind Operator. Wenn ich zum Beispiel die Konten von Patrick, John und Emily einfrieren möchte:

*;*;Patrick|jean|emilie;scheduler

Wenn Sie den Zugriff auf das System für alle Benutzer außer einem bestimmten Benutzer blockieren möchten, verwenden Sie die! vor dem Betroffenen. Wenn ich zum Beispiel möchte, dass allen Benutzern außer Nicolas und Xavier der Zugriff auf den Computer verweigert wird:

Nicolas *;*;!|xavier;scheduler

Wenden wir uns nun den Feldzonen zu. In diesem Feld ist die Auswahl von Tagen und Stunden möglich. Sie müssen zuerst den Wochentag mit den folgenden Abkürzungen angeben:

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

Verwechseln Sie nicht die irreführenden Abkürzungen Wk und Wd! besonders schlecht im Internet identifiziert: Sie können leicht widersprüchliche Informationen finden!

Dann legen wir die Fristen fest. Diese sollten 24h formatiert sein und aus 4 Ziffern bestehen. Um beispielsweise 15:17 Uhr auf 18:34 Uhr zu beschränken, schreiben wir: 1517-1834. Damit Marie nur am Dienstag von 15:17 Uhr bis 18:34 Uhr eine Verbindung herstellen kann, erhalten wir das Ergebnis:

*;*;marie;Tu1517-1834

Verbindungen außerhalb dieser Zeiten werden gesperrt. Für Benutzer ist es möglich, die Operatoren | zu verwenden und! mehrmals angeben (das! zeigt dann an, dass alle Anmeldestunden zulässig sind, mit Ausnahme der angezeigten).

Die zwei Sterne (Wildcards) am Anfang der Codezeile sind die Felder und tty services. Da Sie den gesamten Zugriff auf das System blockieren möchten, müssen Sie nicht angeben, welchen Dienst oder welche Anzahl Sie blockieren möchten. Wenn Sie jedoch die Verwendung eines bestimmten Dienstes verhindern möchten, geben Sie ihn einfach als folgendes Beispiel an:

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

Daher kann der Benutzer heiraten nicht an einem TTY, 4 und 5 am Wochenende verbinden.

Einige Beispiele für Einschränkungen Zeitplan

mathilde darf sich täglich von 13:20 bis 15:20 und von 16:00 bis 20:30 verbinden:

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

Stone, Frank und Florian dürfen sich an Wochentagen von 14.00 bis 18.45 Uhr und am Wochenende von 14.00 bis 22.15 Uhr verbinden:

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

Olive darf sich nie verbinden. jessica kann sich mittwochs von 13 bis 16 uhr anmelden:

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

2 verschiedene Zeilen für zwei verschiedene Zeiten für jeden Benutzer Ablauf einer Sitzung

Wenn eine Sitzung abläuft (sie überschreitet die Zeit, während der der Benutzer bereits verbunden ist), kann der PAM den Benutzer erreichen. Während Mathilde während der zulässigen Zeit eine Verbindung herstellt, ist es vollkommen kostenlos, diese Stunden zu überschreiten! Dafür verwenden wir ein neues Programm: ´cron´. Diese Anwendung führt Befehle in bestimmten Zeitabständen aus. In unserem Fall verwenden wir den Befehl ´skill-KILL-u´, um den Benutzer zu trennen, wenn die Sitzung abläuft. Die Handhabung ist sehr einfach. Bearbeiten Sie einfach die Datei ´ / etc / crontab´. Fügen Sie dann die folgende Codezeile hinzu:

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

Ersetzen Sie nach wie vor die Minutenfelder und die gewünschte Uhrzeit. Füllen Sie dann die Tage nach gesperrten Tagen aus, oder geben Sie einfach ein Sternchen (*) ein, um alle Wochentage anzugeben. Ändern Sie abschließend das Feld, das vom zu sperrenden Anmeldekonto verwendet wird, und voila!

Tage merken das nicht so bei den cronJobs! Hier ist die Liste der mit diesem Programm zu verwendenden Abkürzungen:

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

Einige Beispiele für cronJobs (mit Beispielen für Zeiten im vorherigen Abschnitt)

jessica kann sich mittwochs von 13 bis 16 uhr anmelden

-> Verbindung trennen: Dienstag um 16:00 Uhr.

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

mathilde darf sich täglich von 13:20 bis 15:20 und von 16:00 bis 20:30 verbinden.

-> Trennen: Täglich von 20.30 bis 15.20 Uhr ET.

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

Stone, Frank und Florian dürfen sich an Wochentagen von 14:00 bis 18:45 Uhr und am Wochenende von 14:00 bis 22:15 Uhr verbinden

-> Verbindung trennen (1): Montag, Dienstag, Mittwoch, Donnerstag und Freitag um 18:45 Uhr. -> Verbindung trennen (2): Samstag und Sonntag um 22:15 Uhr.

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

Der Befehl skill-KILL-u trennt den Benutzer von der GUI sowie von TTY. Es ist perfekt für Serveradministratoren geeignet. Dieser Befehl ist jedoch sofort und die Trennung erfolgt ohne Vorankündigung. Es ist daher vorzuziehen, die Installation dieses Gerätes durch Benutzer des betreffenden Rechners oder Netzwerks zu verhindern!

Es ist möglich, Benutzer mit einem wallBefehl zu verhindern, der croneinige Minuten vor Ablauf des Zeitrahmens gestartet wird und auf den Terminals aller Benutzer angezeigt wird.

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

Um zu verhindern, dass Benutzer die GUI verwenden können, befindet sich anstelle des Befehls wall notify-sendim Paket libnotify-bin

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

Ubuntu 11.10 Benutzer

Ich habe gesehen, dass Benutzer Probleme mit Pam haben und ich habe eine Menge Fehler darüber gesehen. Warum ist das der Grund ??? ist so einfach, dass Ubuntu 11.10 GDM nicht mehr unterstützt. Der neue Display Manager ist LightGDM. Das Problem ist, wo diese Direktive gespeichert account required pam_time.sowird, /etc/pam.d/lightdmoder /etc/pam.d/lightdm-autologinaber wie?

Sie können also die folgenden 2 LightGdm-Protokolldateien überprüfen:

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

oder führen Sie LightGdm im Debug-Modus aus:

LightDM - Fehler

oder einen Fehler melden:

Ubuntu-Bug Lightdm

Ich melde den Bug hier also drück die Daumen und warte ...

TimeKpr

Ich denke, es hat alles was Sie brauchen. Beschränken Sie die Zugriffszeit pro Tag und Benutzer, vereinfachen Sie die Konfiguration, lassen Sie sich für einen Tag überbrücken, fügen Sie eine Belohnungszeit hinzu, und teilen Sie Benutzern die verbleibende Zeit mit.

Die Projektseite ist hier . Sie haben auch eine PPA für ubuntu , die Sie Ihre Softwarequellen hinzufügen: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. Und installieren Sie über Software Center oder via CLI: sudo apt-get install timekpr.

Timekpr

kann in 11.10 unter LightDM verwendet werden, um Einschränkungen für Benutzer festzulegen, indem die folgende Zeile hinzugefügt wird /etc/pam.d/lightdm

account required pam_time.so

^{Möglicherweise müssen wir libpam-smbpass entfernen , um den Benutzerwechsel zu ermöglichen, bis der Fehler # 835310 behoben ist.}

Alle im Anwendungsfenster definierten Einschränkungen funktionieren wie in der timekpr-GUI definiert.

Um das timekpr-client-Symbol in Unity anzuzeigen, müssen wir in den Unity-Bedienfeldeinstellungen eine Whitelist erstellen 'timekpr'und außerdem Unitydie folgende Zeile in hinzufügen /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Um den Countdown der gewährten Zeit zu starten, müssen wir möglicherweise den timekpr-Daemon mit starten

/etc/init.d/timekpr start

für 14.04:

Eine neuere Version / Fork von timekpr wurde für Ubuntu 14.04 von Eduards Bezverhijs in seinem veröffentlicht ppa:mjasnik/ppa.

Die automatische Abmeldung ist äußerst frustrierend, wenn Sie sich mitten in etwas befinden. Es ist gewalttätig, es ist brutal, es ist einfach unhöflich. Und es ist egal, wie alt du bist. Dies ist eine Sache, wenn Sie nur computerabhängig sind, und eine andere, wenn Sie die Zeit erfassen und 5 Sekunden vor dem Klicken auf die Senden-Schaltfläche oder dem Speichern Ihres Dokuments aus dem Verkehr gezogen werden. Ich empfehle Ihnen, eine automatische Erinnerung anstelle eines automatischen Kickers zu verwenden. So lernen Ihre Kinder, sich gegenseitig zu respektieren und den Computer bereitwillig zu nutzen.

Es gibt noch eine leichtere Alternative. Verfolgen Sie zunächst die Zeit, die jedes Kind mit dem Computer verbringt, und stellen Sie die gesammelten Daten für alle zur Verfügung, damit sie sie sehen können. Diese unglaublich einfache Sache allein (bezogen auf die ausgegebene Internetbandbreite) hat mir das Leben gerettet, als ich Netzwerkadministrator in einem Büro voller Erwachsener war. Die öffentlichen Statistiken über die Bandbreitennutzung für jeden Computer (nur die Anzahl der Bytes, keine Deanonymisierung von Informationen wie Listen der besuchten Websites usw.) wandelten die Situation von "mir - dem bösen gierigen Administrator gegen sie - den armen, missbrauchten Büronutzern" zu "Mann". du hast 5 mal mehr heruntergeladen als ich, das ist schlimm! " "Tut mir leid, ich habe in der Tat heruntergeladen, ich habe in den Mittagspausen eine Menge Youtube angeschaut, werde es nicht mehr mit dieser Geschwindigkeit tun" - ich wurde einfach aus dem Konfrontationsszenario ausgeschlossen.

Ich hatte auch dieses Problem. Also habe ich das Kidtimer-Skript geschrieben, mit dem Sie Nutzungszeiten und -summen definieren können. Das Projekt ist auf Github an folgendem Ort zu finden:

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

So installieren und verwenden Sie es:

1. Kopieren Sie den Code und fügen Sie ihn in eine Datei mit dem Namen ein 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. Führ es aus:

   sudo ./kidtimer.install

3. Starte es:

   sudo kidtimer

4. Richten Sie ein vorhandenes Benutzerkonto ein.

5. Getan.

Für Hilfe:

sudo kidtimer help

Zeit zum Konto eines Benutzers hinzufügen (nur für diesen Tag):

sudo kidtimer addtime user minutes

Eigenschaften:

• Erlauben Sie Ihrem Kind, zu bestimmten Tageszeiten an Wochentagen und am Wochenende auf den Computer zuzugreifen.
• Stellen Sie die maximale Zeit ein, sowohl an Wochentagen als auch am Wochenende.

Schlüsseldateien:

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

Zeitgesteuerte Aufgaben:

• Überprüfen Sie jede Minute, ob der Benutzer angemeldet ist. Wenn ja, erhöhen Sie die Gesamtzeit. Wenn Sie die maximale Zeit erreicht haben, deaktivieren Sie das Konto und starten Sie die Abmeldesequenz (insgesamt 5 Minuten).
• Überprüfen Sie stündlich, ob der Benutzer sich anmelden darf. Wenn ja, Konto aktivieren.
• Um Mitternacht stellen Sie die Zeit neu ein.

Hinweis:

Die Anwendung zeigt notify-sendan, dass die Benutzerzeit abgelaufen ist. Wenn die Zeit abgelaufen ist, werden alle Benutzerprozesse beendet. Bereiten Sie den Benutzer vor.

timekpr - Dieses Programm überwacht und kontrolliert die Computernutzung Ihrer Benutzerkonten. Sie können die tägliche Nutzung basierend auf einer festgelegten Zugriffszeit einschränken und Zeiträume konfigurieren, in denen sich Benutzer anmelden können oder nicht. Mit dieser Anwendung können Administratoren die Anmeldezeit für das Konto oder die Zugriffszeiten für das Konto einschränken. Die Anwendung fungiert als Kindersicherungsfunktion und ist für Eltern hilfreich, die die Zugriffszeit für Kinder begrenzen möchten.

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

Sie können Ihr System mit nicht unterstützten Paketen aus dieser nicht vertrauenswürdigen PPA aktualisieren, indem ppa:timekpr-maintainers/ppaSie die Softwarequellen Ihres Systems hinzufügen .

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

Dieses Paket ist erhältlich in:

• Oneiric Problem siehe Fehlerbericht ....
• schick
• Einzelgänger
• klar
• Karmisch
• Jaunty
• Unerschrocken

• Winterhart

• Was sind PPAs und wie verwende ich sie?

PROBLEM :

Ich melde den Bug hier also drück die Daumen und warte ...

Einführung

Wir können überprüfen, ob ein Benutzer mit dem folgenden Befehl angemeldet ist:

who -u

Das gibt uns eine Ausgabe wie:

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

In der Ausgabe erhalten wir die pid des Zielbenutzers, die angehalten werden muss, wenn die Zeit das Limit überschreitet.

Die Lösung

Angenommen, Ihr Benutzer hat keine sudoBerechtigungen:

Diese Lösung ist ein kleines Hintergrundskript. Es begrenzt die Nutzung pro Tag auf eine festgelegte Anzahl von Minuten, die im Kopf des Skripts festgelegt werden. Einmal eingerichtet (was nicht allzu schwierig ist), läuft es sehr einfach, und danach sind keine weiteren Maßnahmen erforderlich.

Um einen unerwünschten Datenverlust möglicherweise geöffneter Dateien zu verhindern, wird 60 Sekunden vor Ablauf des Zeitlimits des Zielbenutzers eine Meldung auf seinem Computer angezeigt DISPLAY:

Das Drehbuch

#!/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

Wie benutzt man

1. Erstellen Sie auf Ihrem Desktop (oder anderswo) einen Ordner mit dem Namen: limit
2. Kopieren Sie das Skript in eine leere Datei, speichern Sie es als limit_use(keine Erweiterung) im Ordner und machen Sie es ausführbar

3. Bearbeiten Sie im Kopf des Skripts den zu beschränkenden Benutzernamen und die maximal zulässige Anzahl von Minuten. Im Beispiel:

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

4. Kopieren Sie den Ordner in das Verzeichnis /opt:

   cp -r /path/to/limit /opt

5. Bearbeiten Sie /etc/rc.localnun das Skript, damit es rootbeim Start wie folgt ausgeführt wird:

   sudo -i gedit /etc/rc.local

   Kurz vor der Linie

   exit 0

   eine andere Zeile:

   /opt/limit/limit_use &

Erläuterung; wie es funktioniert

• Das Skript prüft einmal alle 10 Sekunden, ob der Zielbenutzer angemeldet ist. In diesem Fall wird der Gesamtnutzung ein "Punkt" hinzugefügt, der in einer Datei aufgezeichnet werden soll ( /opt/limit/uselog). Wenn das Tageslimit erreicht ist, lässt das Skript nicht mehr zu, dass der Benutzer angemeldet ist, und bricht den Prozess ab, falls vorhanden.
• Bei der Änderung des Tages (das Datum wird in einer Datei aufgezeichnet, sodass ein Neustart nicht hilfreich ist) wird die Protokolldatei gelöscht, sodass eine neue Nutzungsdauer aufgebaut werden kann.
• Da das Skript beim Hochfahren ausgeführt wird , können rc.localnur Benutzer mit sudo-Berechtigungen das Skript stoppen, auch wenn der Benutzer den Prozessnamen kennt.

Stoppen Sie das Skript

Wenn Sie das Skript anhalten möchten, verwenden Sie den folgenden Befehl:

sudo kill "$(pgrep limit_use)"

Dafür benötigen Sie jedoch das sudo-Passwort.

Ich habe es versucht, timekpraber es hat nicht funktioniert. Dann habe ich eine Variante davon gemacht, die auf meinem Ubuntu funktioniert. Das muss man für diese Variante tun:

1. Zeitlimit in /var/lib/timelimit/user_to_be_limited.limitDatei nur mit Root-Rechten hinzufügen. zB 1800 für 1800 Sekunden (30 Minuten) Tageslimit.

2. Erstellen Sie /usr/local/bin/timelimit.shmit Root- Rechten mit folgenden:

   #!/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. Hinzufügen zu /etc/rc.local:

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

4. Ubuntu neu starten

Ich habe einfach eine Antwort zur Verfügung gestellt. Code wird im Thread erklärt http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 erklärt . Kurz gesagt: Ein in Minuten pro Tag konfiguriertes Limit, ein Cron-Job pro Minute, eine Nachricht an den Benutzer, um ihn auf dem Laufenden zu halten, und eine erzwungene Abmeldung.

Um dies herunterzuladen und zu installieren, öffnen Sie ein Terminal und führen Sie die folgenden Befehle aus:

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

Während des Installationsvorgangs wird ein Administratorkennwort abgefragt (zum Installieren des Cron-Jobs, zum Kopieren des Skripts, ...). Von dort werden Sie für alle geführt. Es gibt auch eine ./uninstall.sh am selben Ort für alle Fälle. Es ist so gebaut, dass es mit allen Ubuntu-basierten Distributionen (Mint, etc ... wahrscheinlich auch alle Debian-Versionen) funktioniert. Wenn ein Problem auftritt, lassen Sie es mich bitte wissen, einschließlich der Systemversion und der grafischen Umgebung in den Kommentaren:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Bäckeroot

Ich habe gerade eine Beta-Version meiner neuen Anwendung veröffentlicht LittleBrother, mit der die Spielzeit auf Linux-Computern überwacht werden kann. Testbenutzer können gerne das Debian-Paket ausprobieren. Anweisungen zum Herunterladen und Verwenden finden Sie hier: https://github.com/marcus67/little_brother . Die Installation kann jedoch noch etwas rau sein. Dies sind die Merkmale der Anwendung:

• Es können beliebig viele Benutzer überwacht werden.
• Jeder Benutzer kann einen bestimmten Regelsatz haben, der die zulässige Spielzeit definiert.
• Die Regeln können an "Kontexte" angepasst werden, z. B. an den Wochentag und / oder einen Urlaubsplan (derzeit werden nur die deutschen Zeitpläne unterstützt).
• Die Spielzeit kann auf ein Zeitfenster (von, bis) beschränkt werden.
• Es kann eine maximale Spielzeit pro Tag festgelegt werden.
• Benutzer können gezwungen werden, nach einer bestimmten maximalen Sitzungszeit eine Pause einzulegen.
• Benutzer können gezwungen werden, nach ihrer Aktivität eine kurze Pause einzulegen.
• Es können beliebig viele Linux-Client-Hosts überwacht werden (derzeit müssen sich Benutzer auf allen Rechnern gleich anmelden).
• Es gibt einen Master-Host mit einer Historie der Aktivitäten aller Benutzer. Dieser Master-Host überprüft die Regelsätze und fordert die Client-Hosts auf, Prozesse bei Bedarf zu beenden.
• Der Master-Host bietet eine einfache Weboberfläche zum Anzeigen der Benutzeraktivität über eine konfigurierte Verlaufslänge (z. B. 7 Tage) und eine Administrationsseite zum dynamischen Definieren von Regelausnahmen für eine konfigurierte Anzahl von Tagen in der Zukunft.
• Die Webanwendung kann hinter einem Proxy ausgeführt werden, sodass der Zugriff von außerhalb möglich ist und die Remoteverwaltung nach dem Empfang von Anrufen von jungen Benutzern erfolgt, die um mehr Spielzeit bitten.
• Die Anwendung verfügt über internationale Sprachunterstützung. Derzeit werden englische und deutsche Übersetzungen angeboten. Benutzer werden gebeten, Übersetzungen für andere Sprachen bereitzustellen.
• Die Anwendung verwendet die Sprachgenerierung, um den Benutzer über bevorstehende erzwungene Abmeldungen zu informieren. Auch diese gesprochenen Nachrichten sind internationalisiert.
• Neben der auf Linux-Hosts verbrachten Zeit kann die Anwendung auch die Aktivitätszeit auf anderen Geräten wie Smartphones oder Tabellen überwachen. Es macht sich die Tatsache zunutze, dass die meisten modernen Betriebssysteme Geräte in einen Energiesparmodus versetzen, wenn sie nicht verwendet werden. Auf diese Weise kann die Netzwerkantwort (durch Ping) verwendet werden, um die Aktivität auf diesen Geräten zu bestimmen. Im Gegensatz zu den Linux-Hosts kann die Anwendung die Aktivität nicht beenden. Die Spielzeit wird jedoch zur Gesamtspielzeit addiert und wirkt sich somit auf die zulässige Zeit und auch auf die Pausenzeitregeln auf den Linux-Hosts aus.

Einige Screenshots: