Dostęp do naszego komputera (nie tylko do Internetu) musi być ograniczony dla kont moich dzieci (7, 8), dopóki nie osiągną wystarczającego wieku, aby same sobie z tym poradzić. Do tego czasu musimy być w stanie zdefiniować:

• godziny dnia, w których przetwarzanie jest w porządku (np. 5-21)
• dni tygodnia, w których korzystanie z komputera jest nieprawidłowe (np. od poniedziałku do piątku)
• dozwolony czas na dzień (np. 2 godziny)

W wersji 11.10 wszystkie poniższe funkcje, które były używane do wykonania tej pracy, już nie działają:

• Timekpr : dla> 11.10 nie jest już dostępny za pośrednictwem ppa.
• Limit czasu : alternatywa dla wiersza poleceń, ale z wersji 11.10 usunięta z repozytoriów .
• Gnome Nanny : Wygląda świetnie, ale ciągle się zawiesza, aby wymusić ponowne uruchomienie X-serwera. Dlatego nie możemy w tej chwili używać ani polecać tego programu.

Czy są jakieś inne alternatywy?

Timer blokady ekranu

Utwórz własny Timer blokady ekranu zamiast aplikacji innych firm

Chociaż istnieją do tego aplikacje innych firm, możesz utworzyć własne. Podsumowanie kroków:

• Służy geditdo tworzenia skryptulock-screen-timer
• Skopiuj i wklej kod z tego okna do lock-screen-timer
• Oznacz lock-screen-timerjako plik wykonywalny
• Sprawdź to!
• Skonfiguruj Nautilus do wykonywania skryptów bash
• Utwórz skrót do pulpitu
• Pozostały czas monitorowania

Służy geditdo tworzenia skryptulock-screen-timer

Otwórz za Terminalpomocą Ctrl+ Alt+ Ti wpisz:

gedit lock-screen-timer

Skopiuj i wklej kod z okna poniżej do lock-screen-timer

Wróć do tego ekranu i skopiuj następujący kod, podświetlając go i naciskając Ctrl+ C:

#!/bin/bash

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

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

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

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

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

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

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


while true ; do # loop until cancel

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

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

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

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

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

        sleep 60

    done

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

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

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

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

Następnie przełącz się z powrotem do pustego geditokna i wklej kod za pomocą Ctrl+ V. Zapisz plik i zamknij edytor z powrotem do wiersza polecenia.

Oznacz lock-screen-timerjako plik wykonywalny

Teraz musimy uczynić skrypt wykonywalnym, wpisując:

chmod +x lock-screen-timer

Sprawdź to!

Przed wywołaniem skryptu z GUI wywołamy go z terminala, abyśmy mogli zobaczyć, czy są wyświetlane komunikaty o błędach:

~/lock-screen-timer

Zostaniesz zapytany o liczbę minut:

Ustaw żądaną liczbę minut i kliknij OK, aby uruchomić stoper. Gdy pozostało 15, 10, 5, 3, 2 i 1 minuta, słychać dźwięk systemu i pojawia się dymek informujący, kiedy ekran zostanie zablokowany. Po zablokowaniu ekranu musisz wprowadzić hasło, aby odblokować ekran.

Skonfiguruj Nautilus do wykonywania skryptów bash

Nautilus określa, co się stanie, gdy klikniemy dwukrotnie skrypt wykonywalny, gdy jest to okno wyświetlania plików lub link na pulpicie. Normalnym zachowaniem jest edycja skryptu za pomocą gedit. Chcemy zmienić to zachowanie, tak aby zostało wykonane.

Uruchom Nautilus i przejdź do katalogu zawierającego lock-screen-timer. Kliknij raz lewym przyciskiem myszy, aby ustawić ostrość. Najedź myszką na górny pasek menu, aż pojawi się menu „Edycja pliku ...”, użyj:

1. Kliknij Editmenu rozwijane
2. Kliknij Propertiesopcję
3. Kliknij Behaviorzakładkę
4. Obserwuj przyciski opcji radiowych pod Executable Text Files
5. Sprawdź przycisk opcji Run executable text files when they are opened

Utwórz skrót do pulpitu

Z poprzedniej sekcji lock-screen-timerwciąż się koncentruję. Jeśli nie, przejdź do skryptu i kliknij go raz lewym przyciskiem myszy, aby ustawić fokus. Następnie użyj:

• Kliknij plik prawym przyciskiem myszy, aby wyświetlić opcje menu kontekstowego.
• Z menu wybierz Make Link.
• Pojawi się nowa ikona o nazwie Link to lock-screen-timer.
• Kliknij lewym przyciskiem myszy nową ikonę i przeciągnij ją z Nautilus na pulpit.

Teraz możesz dwukrotnie kliknąć łącze skrótu na pulpicie, a skrypt zostanie uruchomiony. Pojawi się okno dialogowe z liczbą minut. Przedstawiono dwa przyciski Canceli OK. Kliknięcie przycisku, Xaby zamknąć okno, jest równoznaczne z wybraniem Cancel.

Po uruchomieniu stopera i dwukrotnym kliknięciu go pierwsza uruchomiona kopia zostanie „zabita”. Możesz teraz rozpocząć nowe odliczanie blokady scren lub kliknąć, Cancelaby nie odliczać.

Wyświetl pozostały czas w obszarze paska / obszaru powiadomień

Podczas działania timera blokady ekranu rejestruje, ile minut pozostało do pliku ~/.lock-screen-timer-remaining. Możesz obejrzeć ten plik za pomocą watchpolecenia lub wyświetlić go na pasku zadań / paska narzędzi Ubuntu, jak pokazano na górze tej odpowiedzi. Aby wyświetlić pozostały czas w obszarze powiadomień, postępuj zgodnie z instrukcjami zawartymi w tym pytaniu : ( Czy BASH może wyświetlać się w pasku zadań jako wskaźnik aplikacji? ).

Ubuntu <= 11.10 Użytkownik postępuj zgodnie z tym przewodnikiem dla Ubuntu User> = 11.10 przeczytaj zawiadomienie na dole strony:

Tak, wszystkie te programy są nieaktualne, na wszystkie pytania udzielono odpowiedzi tutaj i dobrze wyglądają one z kontrolą rodzica .....

Kiedy mówimy o zmuszeniu użytkownika do wylogowania, tak naprawdę mówimy o wprowadzeniu ograniczeń czasowych na koncie dostępu do systemu lub usług. Najłatwiejszym sposobem na wdrożenie ograniczeń czasowych jest użycie modułu wtyczki o nazwie Linux-PAM .

Pluggable Authentication Module (PAM) to mechanizm uwierzytelniania użytkowników. W szczególności użyjemy tego pam_timemodułu do kontrolowania dostępu użytkowników do usług w określonym czasie.

Za pomocą pam_timemodułu możemy ustawić ograniczenia dostępu do systemu i / lub określonych aplikacji o różnych porach dnia, a także w określone dni lub przez różne linie terminali. W zależności od konfiguracji możesz użyć tego modułu, aby odmówić dostępu poszczególnym użytkownikom na podstawie ich nazwy, pory dnia, dnia tygodnia, usługi, o którą się ubiegają oraz terminala, z którego wysyłają żądanie .

Podczas używania pam_timenależy zakończyć składnię każdej linii (lub reguły) w /etc/security/time.confpliku za pomocą nowej linii. Możesz skomentować każdą linię znakiem funta [#], a system zignoruje ten tekst do nowej linii.

Oto składnia reguły:

usługi; ttys; użytkownicy; czasy

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.

Oto przykład typowego zestawu reguł:

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

Reguły te ograniczają możliwość logowania się użytkownika bobby między godzinami 0800 i 2000, a także ograniczają dostęp do Internetu w tych godzinach. Root byłby w stanie zalogować się w dowolnym momencie i przeglądać Internet przez cały czas.

Uwaga: System rejestruje błędy według tych reguł jako syslog (3).

W systemie Ubuntu Linux można przypisać do komputera ograniczenia czasowe, aby zapobiec podłączeniu jednego lub więcej użytkowników do systemu. Ograniczenia czasowe pozwalają na przykład ograniczyć dostęp dzieci do komputera (w skrócie kontrolę rodzicielską) , a nawet zabezpieczyć połączenie z serwerem w określonych godzinach.

Konfiguracja ręczna

Zrozum, co będziesz robić

W tym samouczku będziemy używać PAM (Pluggable Authentication Modules, English Pluggable Authentication Modules). Pozwala kontrolować uwierzytelnianie użytkowników podczas ich łączenia. Następnie użyjemy plików konfiguracji zabezpieczeń do zdefiniowania dozwolonych godzin logowania. Te manipulacje mogą być wykonywane na dowolnej wersji Ubuntu i wymagają tylko prostego edytora tekstu (vim, emacs, nano, gedit, kate, aby wymienić tylko kilka). Włącz godziny ograniczeń za pośrednictwem modułu PAM

Przede wszystkim przejdź do /etc/pam.d/, gdzie znajdują się wszystkie konfigurowalne usługi:

$ 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

Jeśli chcemy zablokować połączenie z komputerem, będziemy musieli zmienić usługę gdm. Zmodyfikuj plik, aby gdm i dodaj następujący wiersz kodu (na końcu pliku):

account required pam_time.so

GDM to dystrybucje ekranu logowania Ubuntu, Edubuntu i Xubuntu. W przypadku Kubuntu, który korzysta z KDE, wywoływana jest usługa kdm, będzie to plik, który otworzy. I skończyłeś konfigurować PAM! Umożliwi to kontrolę godzin w tej usłudze.

Jeśli masz serwer, prawdopodobnie nie masz GUI. W takim przypadku GDM / KDM nie jest zainstalowany, a połączenie nie zostanie zablokowane. Aby zapobiec połączeniu z TTY, musisz zmodyfikować login tego samego pliku i dodać ten sam wiersz kodu, co wcześniej potwierdzony. Ta akcja dotyczy także osób, które zainstalowały GUI i chcą zablokować dostęp do ekranu logowania i terminali.

Skonfiguruj godziny dostępu

Teraz, gdy usługa PAM została aktywowana, musimy jedynie skonfigurować czasy dostępu. Otwórz /etc/security. Dostępnych jest kilka plików konfiguracyjnych:

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

Edytuj plik time.conf. Niektóre wyjaśnienia i przykłady (w języku angielskim) wprowadzające. Aby ustawić harmonogramy dostępu, skopiuj i wklej następujący wiersz kodu (jak zawsze na końcu pliku):

*;*;user;scheduler

Zamiast pola użytkownika wprowadź konto logowania, które chcesz zablokować.

Jeśli chcesz zablokować wielu użytkowników, wprowadź ich login z rzędu, oddzielając je znakiem operator. Na przykład, jeśli chcę zamrozić konta Patricka, Johna i Emily:

*;*;Patrick|jean|emilie;scheduler

Z drugiej strony, jeśli chcesz zablokować dostęp do systemu wszystkim użytkownikom, z wyjątkiem jednego, użyj! przed osobą zainteresowaną. Na przykład, jeśli chcę dostęp do komputera jest zabroniony wszystkim użytkownikom, z wyjątkiem Nicolasa i Xaviera:

Nicolas *;*;!|xavier;scheduler

Przechodzę teraz do stref polowych. W tym polu możliwy będzie wybór dni i godzin połączenia. Najpierw musisz określić dzień tygodnia, używając następujących skrótów:

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

Uważaj, aby nie pomylić skrótów Wk i Wd wprowadzają w błąd! szczególnie słabo zidentyfikowane w Internecie: łatwo znajdziesz sprzeczne informacje!

Następnie określamy terminy. Powinny być sformatowane 24 godziny, składające się z 4 cyfr. Na przykład, aby ograniczyć 15:17 do 18:34, piszemy: 1517-1834. Aby umożliwić Marie łączenie się tylko we wtorek, w godzinach od 15:17 do 18:34, otrzymujemy wynik:

*;*;marie;Tu1517-1834

Połączenia poza tymi godzinami zostaną zablokowane. Użytkownicy mogą korzystać z operatorów | i! wskazać kilka razy (!! oznacza, że ​​wszystkie godziny logowania są dozwolone, z wyjątkiem tych, które zostaną pokazane).

Dwie gwiazdki (symbole wieloznaczne) na początku wiersza kodu są odpowiednio polami usług tty. Ponieważ chcesz zablokować cały dostęp do systemu, nie trzeba określać, która usługa lub jakie urządzenie chcesz zablokować. Jeśli jednak chcesz uniemożliwić korzystanie z określonej usługi, po prostu określ ją jako następujący przykład:

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

W związku z tym użytkownik poślubiający nie może połączyć się z TTY, 4 i 5 w weekend.

Niektóre przykłady harmonogramu ograniczeń

mathilde może łączyć się codziennie od 13:20 do 15:20 i od 16:00 do 20:30:

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

Stone, Frank i Florian mogą łączyć się w godzinach od 14.00 do 18:45 w dni powszednie i od 14:00 do 22.15 w weekend:

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

Oliwka nigdy nie może się połączyć. Jessica może zalogować się w środę od 13:00 do 16:00:

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

2 różne linie, na dwa różne czasy dla każdego użytkownika Wygaśnięcie sesji

Gdy sesja wygasa (przekracza czas, gdy użytkownik jest już podłączony), PAM może do niego dotrzeć. Chociaż mathilde łączy się w dozwolonych godzinach, przekraczanie tych godzin jest całkowicie darmowe! W tym celu użyjemy nowego programu: „cron”. Ta aplikacja wykonuje polecenia w odstępach czasu. W naszym przypadku użyjemy polecenia „umiejętność-KILL-u”, aby odłączyć użytkownika po wygaśnięciu sesji. Obsługa jest bardzo prosta. Po prostu edytuj plik ´ / etc / crontab´. Następnie dodaj następujący wiersz kodu:

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

Tak jak poprzednio, zastępując harmonogramy pól Minute i pożądany czas. Następnie wpisz dzień (dni) do dnia (dni) zablokowany (e) lub po prostu wpisz gwiazdkę (*), aby wskazać wszystkie dni tygodnia. Na koniec zmień pole używane przez konto logowania, które ma być blokowane, i voila!

Dni nie zauważają tego samego w cronpracy! Oto lista skrótów używanych w tym programie:

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

Niektóre przykłady cronzadań (z przykładami czasów w poprzedniej sekcji)

Jessica może zalogować się w środę od 13:00 do 16:00

-> Rozłącz: wtorek o 16:00.

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

mathilde może łączyć się codziennie od 13:20 do 15:20 i od 16:00 do 20:30.

-> Rozłączanie: codziennie, od 20:30 do 15:20 ET.

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

Stone, Frank i Florian mogą łączyć się w godzinach od 14.00 do 18:45 w dni powszednie i od 14:00 do 22.15 w weekendy

-> Disconnect (1): poniedziałek, wtorek, środa, czwartek i piątek o 18:45. -> Disconnect (2): sobota i niedziela o 22:15.

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

Polecenie KILL-u odłącza użytkownika od GUI, a także TTY. Jest doskonale użyteczny dla administratorów serwerów. To polecenie jest jednak natychmiastowe i rozłączenie zostanie wykonane bez powiadomienia. Dlatego lepiej byłoby zapobiec instalacji tego urządzenia przez użytkowników danego komputera lub sieci!

Możliwe jest zapobieganie użytkownikom za pomocą wallpolecenia uruchomionego na cronkilka minut przed końcem przedziału czasowego , który będzie wyświetlany na terminalach wszystkich użytkowników.

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

Aby zapobiec użytkownikom z GUI, można użyć zamiast polecenia wall notify-sendznajduje się w pakiecie libnotify-bin

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

Ubuntu 11.10 Użytkownik

Widziałem wokół użytkowników, którzy mają problemy z Pam i widziałem wiele błędów w tym, więc dlaczego jest powód ??? jest tak prosty Ubuntu 11.10 doens't wsparcie GDM już nowy menedżer wyświetlania jest lightGDM problem jest kontynuacją gdzie sklep Niniejsza dyrektywa account required pam_time.somyślę jest /etc/pam.d/lightdmalbo /etc/pam.d/lightdm-autologinale bug jak ???

więc w pobliżu możesz sprawdzić 2 pliki dziennika LightGdm:

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

lub uruchom LightGdm w trybie debugowania:

LightDM - debug

lub zgłoś błąd:

ubuntu-bug lightdm

Zgłaszam, że Bug jest tutaj, więc trzymaj kciuk i czekaj ....

TimeKpr

Myślę, że ma wszystko, czego potrzebujesz. Ogranicz czas dostępu dziennie na użytkownika, łatwe GUI do konfiguracji, możliwość obejścia na jeden dzień, dodaj „czas nagrody”, powiadomienie o pozostałym czasie dla użytkowników itp.

Strona projektu jest tutaj . Mają też PPA dla Ubuntu, które można dodać do swoich źródeł oprogramowania: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. I zainstalować za pomocą Centrum oprogramowania lub poprzez CLI: sudo apt-get install timekpr.

Timekpr

może być używany w 11.10 z uruchomionym LightDM do konfigurowania ograniczeń dla użytkowników poprzez dodanie następującego wiersza do /etc/pam.d/lightdm

account required pam_time.so

^{Może być konieczne usunięcie libpam-smbpass, aby umożliwić przełączanie użytkowników, dopóki błąd # 835310 nie zostanie naprawiony.}

Wszystkie ograniczenia zdefiniowane w oknie aplikacji działają zgodnie z definicją w graficznym interfejsie użytkownika timekpr.

Aby wyświetlić ikonę klienta timekpr w Unity, musimy umieścić na białej liście 'timekpr' w ustawieniach panelu Unity, a ponadto musimy dodać Unitydo następującego wiersza w /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Aby rozpocząć odliczanie przyznanego czasu, może być konieczne uruchomienie demona timekpr

/etc/init.d/timekpr start

dla 14.04:

Nowsza release / widelec z timekpr został opublikowany dla Ubuntu 14.04 przez Eduards Bezverhijs w jego ppa:mjasnik/ppa.

Automatyczne wylogowanie jest wyjątkowo frustrujące, jeśli coś jest w środku. Jest gwałtowny, brutalny, jest po prostu niegrzeczny. I nie ma znaczenia, ile masz lat. To jedna rzecz, gdy jesteś uzależniony od komputera i zupełnie inaczej, gdy śledzisz czas i zostajesz wyrzucony na 5 sekund, zanim zdążysz kliknąć ten przycisk przesyłania lub zapisać dokument. Sugeruję, aby rozważyć użycie automatycznego przypomnienia zamiast auto-kickera. To nauczy twoje dzieci wzajemnego szacunku i pozwoli sobie nawzajem chętnie korzystać z komputera.

Istnieje nawet lżejsza alternatywa. Zacznij od śledzenia czasu, jaki każde dziecko spędza z komputerem, i udostępnij zgromadzone dane wszystkim, aby mogły je zobaczyć. Ta niewiarygodnie prosta rzecz (zastosowana do przepustowości łącza internetowego) uratowała mi życie, kiedy byłem administratorem sieci w biurze pełnym dorosłych. Publiczne statystyki dotyczące wykorzystania przepustowości dla każdego komputera (tylko liczba bajtów, nie deanonimizacji informacji, takich jak listy odwiedzanych witryn itp.) Zmieniły sytuację z „ja - zły chciwy administrator przeciwko nim - biednym nadużywanym użytkownikom biurowym” na „człowieka, pobrałeś 5 razy więcej niż ja, to źle! ” „przepraszam, pobrałem rzeczywiście, oglądałem dużo youtube podczas przerw na lunch, nie zrobię tego już w tym tempie” - po prostu zostałem wykluczony ze scenariusza konfrontacji.

Też miałem ten problem. Napisałem więc skrypt kidtimer, który pozwala zdefiniować czasy użytkowania i sumy. Projekt można znaleźć na Github w następującej lokalizacji:

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

Oto jak go zainstalować i używać:

1. Skopiuj i wklej kod do pliku o nazwie 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. Wykonaj to:

   sudo ./kidtimer.install

3. Uruchom:

   sudo kidtimer

4. Skonfiguruj istniejące konto użytkownika.

5. Gotowy.

O pomoc:

sudo kidtimer help

Dodaj czas do konta użytkownika (tylko na ten dzień):

sudo kidtimer addtime user minutes

Cechy:

• Pozwól dziecku na dostęp do komputera w określonych godzinach w ciągu dnia, zarówno w dni powszednie, jak i weekendy.
• Ustaw maksymalny czas, zarówno w dzień powszedni, jak i weekend.

Kluczowe pliki:

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

Cronjobs:

• Sprawdzaj co minutę, czy użytkownik jest zalogowany. Jeśli tak, zwiększ całkowity czas. Jeśli zostanie osiągnięty maksymalny czas, wyłącz konto i rozpocznij sekwencję wylogowywania (łącznie 5 minut).
• Co godzinę sprawdzaj, czy użytkownik może się zalogować. Jeśli tak, włącz konto.
• O północy zresetuj czas.

Uwaga:

Aplikacja używa, notify-sendaby ostrzec użytkownika, że ​​czas się kończy. Kiedy skończy się czas, wszystkie procesy użytkownika zostaną zakończone, więc przygotuj użytkownika.

timekpr - ten program będzie śledził i kontrolował użycie kont użytkowników przez komputer. Możesz ograniczyć ich codzienne użycie w oparciu o czasowy czas dostępu i skonfigurować przedziały dnia, w których mogą się zalogować lub nie. Dzięki tej aplikacji administratorzy mogą ograniczyć czas logowania się na konto lub godziny dostępu do konta. Aplikacja działa jako kontrola czasu rodzicielskiego i będzie przydatna dla rodziców, którzy chcą ograniczyć czas dostępu dziecka.

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

Możesz zaktualizować swój system o nieobsługiwane pakiety z tego niezaufanego PPA, dodając ppa:timekpr-maintainers/ppado źródeł oprogramowania systemu.

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

Ten pakiet jest dostępny w:

• Problem Oneiric patrz raport o błędzie ....
• zgrabny
• Politycznie niezależny
• przejrzysty
• Karmiczny
• Wesoły
• Nieustraszony

• Wytrzymały

• Co to są umowy PPA i jak z nich korzystać?

PROBLEM:

Zgłaszam, że Bug jest tutaj, więc trzymaj kciuk i czekaj ....

Wprowadzenie

Możemy sprawdzić, czy użytkownik jest zalogowany za pomocą polecenia:

who -u

co daje nam dane wyjściowe takie jak:

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

W wyniku otrzymujemy pid użytkownika docelowego, który należy zatrzymać, jeśli czas przekroczy limit.

Rozwiązanie

Zakładając, że użytkownik nie ma sudouprawnień:

To rozwiązanie jest małym skryptem w tle. Ogranicza dzienne użycie do określonej liczby minut, które można ustawić w skrypcie. Po skonfigurowaniu (co nie jest zbyt trudne) działa bardzo łatwo i nie wymaga żadnych dodatkowych działań.

Aby zapobiec niechcianej utracie danych przez potencjalnie otwarte pliki, 60 sekund przed upływem limitu czasu użytkownika docelowego, pojawi się na nim komunikat DISPLAY:

Scenariusz

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

Jak używać

1. Na pulpicie (lub w dowolnym innym miejscu) utwórz folder o nazwie: limit
2. Skopiuj skrypt do pustego pliku, zapisz go jako limit_use(bez rozszerzenia) w folderze i spraw, aby był wykonywalny

3. Edytuj w nagłówku skryptu nazwę użytkownika, którą chcesz ograniczyć, oraz maksymalną liczbę dozwolonych minut. W przykładzie:

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

4. Skopiuj folder do katalogu /opt:

   cp -r /path/to/limit /opt

5. Teraz edytuj, /etc/rc.localaby skrypt działał tak, jak rootpodczas uruchamiania:

   sudo -i gedit /etc/rc.local

   Tuż przed linią

   exit 0

   inna linia:

   /opt/limit/limit_use &

Wyjaśnienie; jak to działa

• Raz na 10 sekund skrypt sprawdza, czy docelowy użytkownik jest zalogowany. Jeśli tak, „dodaje” jeden „punkt” do całkowitego użycia, aby zapisać go w pliku ( /opt/limit/uselog). Jeśli dzienny limit zostanie osiągnięty, skrypt nie pozwala już na zalogowanie się, zabija proces, jeśli taki istnieje.
• Po zmianie dnia (data jest zapisywana w pliku, więc ponowne uruchomienie nie pomoże), plik dziennika jest usuwany, co pozwala na nagromadzenie nowego czasu użytkowania.
• Ponieważ skrypt jest uruchamiany podczas uruchamiania , rc.localtylko użytkownicy z uprawnieniami sudo mogą zatrzymać skrypt, nawet jeśli użytkownik zna nazwę procesu.

Zatrzymaj skrypt

Jeśli chcesz zatrzymać skrypt, użyj polecenia:

sudo kill "$(pgrep limit_use)"

Aby to zrobić, potrzebujesz hasła sudo.

Próbowałem, timekprale nie udało mi się. Następnie stworzyłem jego wariant, który działa na moim Ubuntu. Oto, co należy zrobić dla tego wariantu:

1. Dodaj limit czasu w /var/lib/timelimit/user_to_be_limited.limitpliku tylko z uprawnieniami administratora. np. 1800 przez 1800 sekund (30 minut) dzienny limit.

2. Twórz /usr/local/bin/timelimit.shz prawami roota za pomocą:

   #!/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. Dodaj do /etc/rc.local:

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

4. Uruchom ponownie Ubuntu

Właśnie udostępniłem odpowiedź łatwo. Kod wyjaśniono w wątku http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 . W skrócie: limit skonfigurowany w minutach dziennie, zadanie cron co minutę, wiadomość dla użytkownika informująca go i wymuszone wylogowanie.

Aby pobrać i zainstalować to, otwórz Terminal i uruchom poniższe polecenia:

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

Hasło administratora będzie wymagane podczas procesu instalacji (w celu zainstalowania zadania cron, skopiowania skryptu,…). Stamtąd zostaniesz poprowadzony dla wszystkich. Na wszelki wypadek w tym samym miejscu jest także plik ./uninstall.sh. Jest budowany do pracy ze wszystkimi dystrybucjami opartymi na Ubuntu (Mint itp. Prawdopodobnie wszystkie również z Debianem). Jeśli wystąpi jakikolwiek problem, proszę o informację, w tym wersję systemu i środowisko graficzne w komentarzach:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

Właśnie wydałem wersję beta mojej nowej aplikacji, LittleBrotherktóra jest w stanie monitorować czas gry na maszynach z systemem Linux. Użytkownicy testowi mogą wypróbować pakiet Debian. Instrukcje dotyczące pobierania i korzystania z niego można znaleźć tutaj: https://github.com/marcus67/little_brother . Jednak instalacja może być trochę trudna. Oto funkcje aplikacji:

• Można monitorować dowolną liczbę użytkowników.
• Każdy użytkownik może mieć określony zestaw reguł określających dozwolony czas odtwarzania.
• Reguły można dostosować do „kontekstów”, takich jak dzień tygodnia i / lub harmonogram wakacji (obecnie obsługiwane są tylko harmonogramy niemieckie).
• Czas odtwarzania można ograniczyć do okna czasowego (od, do).
• Można określić maksymalny czas gry na dzień.
• Użytkownicy mogą zostać zmuszeni do przerwy po określonym maksymalnym czasie sesji.
• Użytkownicy mogą zostać zmuszeni do oczekiwania na minimalny czas przerwy po swojej aktywności.
• Można monitorować dowolną liczbę hostów klienckich systemu Linux (obecnie wymaga to takiego samego logowania na wszystkich komputerach).
• Istnieje główny host z historią działań wszystkich użytkowników. Ten host główny sprawdza zestawy reguł i w razie potrzeby monituje hosty klienta o zakończenie procesów.
• Główny host oferuje prosty interfejs sieciowy do przeglądania aktywności użytkownika na skonfigurowanej długości historii (np. 7 dni) oraz stronę administracyjną do dynamicznego definiowania wyjątków reguł dla skonfigurowanej liczby dni w przyszłości.
• Aplikacja internetowa może być uruchomiona za serwerem proxy, dzięki czemu będzie dostępna z dala, umożliwiając zdalną administrację po odbiorze połączeń od młodych użytkowników błagających o więcej czasu na zabawę.
• Aplikacja obsługuje międzynarodowe języki. Obecnie dostępne są tłumaczenia na angielski i niemiecki. Użytkownicy są proszeni o dostarczenie tłumaczeń na inne języki.
• Aplikacja korzysta z generowania głosu, aby poinformować użytkownika o zbliżającym się wymuszonym wylogowaniu. Również te komunikaty mówione są umiędzynarodowione.
• Oprócz czasu spędzonego na hostach systemu Linux aplikacja może również monitorować czas aktywności na innych urządzeniach, takich jak smartfony lub stoły. Wykorzystuje fakt, że większość nowoczesnych systemów operacyjnych wprowadza urządzenia w pewien rodzaj trybu oszczędzania energii, gdy nie są one używane. W ten sposób odpowiedź sieciowa (przez pingowanie) może być wykorzystana do określenia aktywności na tych urządzeniach. W przeciwieństwie do hostów Linux, aplikacja nie będzie mogła zakończyć działania. Czas gry zostanie jednak dodany do ogólnego czasu gry, a zatem będzie miał wpływ na dozwolony czas, a także na zasady czasu przerwy na hostach Linux.

Niektóre zrzuty ekranu: