60

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?

software-recommendation bash parental-controls Takkat
quelle

Hmmm ... wenn es nichts gibt, das dies tut, wäre es wahrscheinlich einfach, es zusammen mit Shell-Skripten / Cron-Jobs zu hacken.

Nathan Osman

11

EEK. Ich kann meine Eltern das nicht sehen lassen. ABER, ich würde es umgehen, weil ich einen fantastischen Root-Zugang habe. : P

jrg

Das Interesse ist "noch in der Entwicklung", aber ich denke nicht, dass es eine neue Frage verdient.

RobotHumans

Abgesehen davon, dass der timekpr- Entwickler verspricht, Zeit zu haben oder nicht, um die Entwicklung fortzusetzen, gibt es keine solche Anwendung. Aber aus eigener Erfahrung weiß ich jetzt, dass wir es gut können (sogar besser?), Ohne dass es dann aber kluge Kinder und kluge Eltern braucht .

Takkat

@jrg oder nur ein Live-USB;)

Wilhelm Erasmus

1

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 `gedit`diese Option , um ein Skript zu erstellen`lock-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-timer`als 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:

Klicken Sie auf das EditDropdown-Menü
PropertiesOption anklicken
Klicken Sie auf die BehaviorRegisterkarte
Beachten Sie die Optionsfelder unter Executable Text Files
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? ).

WinEunuuchs2Unix
quelle

38

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 ...

hhlp
quelle

3

Das ist - wow - großartig - ich bin beeindruckt! Esp. Das Benachrichtigungs-Bit gefällt mir sehr gut, weil wir nicht möchten, dass unsere Kinder ohne Vorwarnung abgesetzt werden. Das wäre sogar für einen bösen Vater wie mich zu böse;)

Takkat

Leider scheint dies mit lightdm nicht zu funktionieren ( bugs.launchpad.net/lightdm/+bug/880313 ).

Takkat

Wow, es ist großartig und lange Erklärung ..

Mahmudin Ashar

Der Fall für openSUSE 11.4 ist genau wie bei Ubuntu 11.10.

Gupta

11

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.

Decio Lira
quelle

Kann TimeKpr Zeitlimits für einzelne Anwendungen (wie Spiele?) Festlegen

Anderson Green

8

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.

Takkat
quelle

Großartig, aber ich denke, es ist eine vorübergehende Lösung ... weil Sie timepkr und samba gleichzeitig für den Austausch mit anderen Computern (siehe ClaudeD (claude-d) schrieb) über mögliche Fehler verwenden ...

hhlp

7

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.

vh1
quelle

6

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:

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

Führ es aus:
```
sudo ./kidtimer.install
```
Starte es:
```
sudo kidtimer
```
Richten Sie ein vorhandenes Benutzerkonto ein.
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.

grover66
quelle

5

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 ...

hhlp
quelle

Oh das sind gute Neuigkeiten. Wir haben hier timekpr verwendet . Hoffe, es wird funktionieren - es ist immer noch auf meiner 11.10-Box installiert, läuft gut, sperrt aber nicht die Konten meines Kindes.

Takkat

und für 14.04 funktioniert es?

Rogerdpack

3

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

Erstellen Sie auf Ihrem Desktop (oder anderswo) einen Ordner mit dem Namen: limit
Kopieren Sie das Skript in eine leere Datei, speichern Sie es als limit_use(keine Erweiterung) im Ordner und machen Sie es ausführbar
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"
```
Kopieren Sie den Ordner in das Verzeichnis /opt:
```
cp -r /path/to/limit /opt
```
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.

Jacob Vlijm
quelle

2

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:

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.

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

Hinzufügen zu /etc/rc.local:
```
sudo /usr/local/bin/timelimit.sh &
```
Ubuntu neu starten

Csaba
quelle

2

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

Thomas Bäckeroot
quelle

1

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:

Marcus Rickert
quelle

Wie beschränke ich die Rechenzeit meiner Kinder?

Antworten:

Bildschirm-Timer sperren

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

Verwenden Sie `gedit`diese Option , um ein Skript zu erstellen`lock-screen-timer`

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

Mark `lock-screen-timer`als ausführbares

Probier es aus!

Konfigurieren Sie Nautilus zum Ausführen von Bash-Skripten

Erstellen Sie einen Desktop-Verknüpfungslink

Verbleibende Zeit im Systray / Benachrichtigungsbereich anzeigen

TimeKpr

Timekpr

für 14.04:

Für Hilfe:

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

Eigenschaften:

Schlüsseldateien:

Zeitgesteuerte Aufgaben:

Hinweis:

Einführung

Die Lösung

Das Drehbuch

Wie benutzt man

Erläuterung; wie es funktioniert

Stoppen Sie das Skript

Einige Screenshots:

Wie beschränke ich die Rechenzeit meiner Kinder?

Antworten:

Bildschirm-Timer sperren

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

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

Kopieren Sie den Code aus dem folgenden 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 im Systray / Benachrichtigungsbereich anzeigen

TimeKpr

Timekpr

für 14.04:

Für Hilfe:

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

Eigenschaften:

Schlüsseldateien:

Zeitgesteuerte Aufgaben:

Hinweis:

Einführung

Die Lösung

Das Drehbuch

Wie benutzt man

Erläuterung; wie es funktioniert

Stoppen Sie das Skript

Einige Screenshots:

Verwenden Sie `gedit`diese Option , um ein Skript zu erstellen`lock-screen-timer`

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

Mark `lock-screen-timer`als ausführbares