如何限制孩子的计算时间？

60

在我的孩子（7、8）年龄大到可以自己管理之前，必须限制他们只能访问我的计算机（不仅是互联网）。在此之前，我们需要能够定义以下内容：

  • 一天中可以进行计算的时间（例如下午5点至晚上9点）
  • 一周中的哪几天不能进行计算（例如，星期一至星期五）
  • 每天允许的时间量（例如2个小时）

在11.10中，以下用于完成该工作的所有内容不再起作用：

  • Timekpr：对于> 11.10，ppa不再可用。
  • Timeoutd：替代命令行，但已从存储库中从11.10中删除。
  • Gnome Nanny：看起来不错，但反复崩溃以强制重新启动X服务器。因此，我们目前无法使用或推荐此程序。

还有其他选择吗？

software-recommendation  bash  parental-controls 
— 塔卡特
source
嗯...如果没有什么可以做的，将它与shell脚本/ cron作业一起破解可能很容易。
— 内森·奥斯曼
11
EEK。不能让我的父母看到这一件事。但是，我会解决它，因为我拥有很棒的root访问权限。：P
— jrg
兴趣在于“仍在开发中”，但我认为这不值得提出新的问题。
— RobotHumans 2013年
除了timekpr开发人员保证他可能或可能没有时间继续开发之外，没有这样的应用程序。但是根据我自己的经验，我现在知道，如果不做，我们就能做得更好（甚至更好？），那么这就需要聪明的孩子和聪明的父母。
— 塔卡特2013年
@jrg或只是一个实时USB；）
— 威廉·伊拉斯

Answers:

1

锁屏计时器

systray.gif

创建自己的屏幕锁定计时器，而不是第三方应用程序

尽管有第三方应用程序可以执行此操作，但是您可以创建自己的应用程序。步骤摘要：

  • 使用gedit创建脚本lock-screen-timer
  • 将代码从此窗口复制并粘贴到 lock-screen-timer
  • 标记lock-screen-timer为可执行文件
  • 测试一下！
  • 配置Nautilus以执行bash脚本
  • 创建桌面快捷方式链接
  • 监控剩余时间

使用gedit创建脚本lock-screen-timer

打开Terminal使用Ctrl+ Alt+ T并键入：

gedit lock-screen-timer

将代码从下面的窗口复制并粘贴到 lock-screen-timer

切换回此屏幕，并通过突出显示它并按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.

然后切换回空白gedit窗口并使用Ctrl+ 粘贴代码V。保存文件，然后将编辑器退出回到命令提示符。

标记lock-screen-timer为可执行文件

现在，我们需要输入以下内容以使脚本可执行：

chmod +x lock-screen-timer

测试一下！

从GUI调用脚本之前，我们将从终端调用该脚本，以便查看是否显示任何错误消息：

~/lock-screen-timer

系统将提示您输入分钟数：

锁屏计时器

设置所需的分钟数，然后单击“确定”以启动计时器。当还剩下15、10、5、3、2和1分钟时，会听到系统声音，并显示消息气泡，提示何时锁定屏幕。锁定屏幕后，您需要输入密码才能解锁屏幕。

配置Nautilus以执行bash脚本

Nautilus定义当我们在文件显示窗口或桌面上的链接上双击可执行脚本时会发生什么。正常行为是使用来编辑脚本gedit。我们想要更改此行为以使其执行。

启动Nautilus并导航到包含的目录lock-screen-timer。左键单击一次即可使其聚焦。将鼠标悬停在顶部菜单栏上，直到出现“文件编辑...”菜单，请使用：

  1. 点击Edit下拉菜单
  2. 点击Properties选项
  3. 点击Behavior标签
  4. 观察下的单选按钮 Executable Text Files
  5. 检查单选按钮 Run executable text files when they are opened

创建桌面快捷方式链接

上一节lock-screen-timer仍然有重点。如果不是，请导航至该脚本，然后左键单击一次以使其聚焦。然后使用：

  • 右键单击该文件，然后显示上下文菜单选项。
  • 从菜单中选择Make Link。
  • 出现一个名为的新图标Link to lock-screen-timer。
  • 左键单击新图标，然后将其从Nautilus拖到桌面上。

现在，您可以双击桌面快捷方式链接并运行脚本。出现一个对话框，获取分钟数。出现两个按钮Cancel和OK。如果单击X关闭窗口，则与选择相同Cancel。

计时器运行后，再次双击它，第一个运行的副本被“杀死”。现在，您可以开始新的屏幕锁定倒计时，或者单击Cancel无倒计时。

显示在系统托盘/通知区域中的剩余时间

锁屏计时器运行时，它将记录文件中剩余的分钟数~/.lock-screen-timer-remaining。您可以使用watch命令查看此文件，或将其显示在Ubuntu的系统托盘/应用程序指示栏上，如该答案的顶部所示。要在通知区域中显示剩余时间，请遵循以下问答中的说明：（BASH可以在系统托盘中显示为应用程序指示符吗？）。

— WinEunuuchs2Unix
source
38

Ubuntu <= 11.10用户请遵循本指南，对于Ubuntu用户> = 11.10请阅读底部通知：

是的，所有这些程序都已过时，您的所有问题都已在此处得到答复，并且与您的父控件保持良好的外观.....

当我们谈论强制用户注销时，我们真正在谈论的是对系统访问或服务帐户实施时间限制。我发现实现时间限制的最简单方法是使用名为Linux-PAM的插件模块。

可插拔认证模块（PAM）是一种用于认证用户的机制。具体来说，我们将使用该pam_time模块来控制用户对服务的定时访问。

使用该pam_time模块，我们可以在一天的不同时间，特定日期或通过各种终端线路设置对系统和/或特定应用程序的访问限制。根据配置，您可以使用此模块根据个人用户的姓名，一天中的时间，一周中的一天，所申请的服务以及从其发出请求的终端来拒绝对单个用户的访问。 。

使用时pam_time，必须/etc/security/time.conf用换行符终止文件中每行（或规则）的语法。您可以用井号[＃]注释每行，系统将忽略该文本，直到换行为止。

这是规则的语法：

服务； ttys；用户；时间

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.

这是一组典型规则的示例：

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

这些规则限制了用户bobby在0800到2000之间的时间登录，并且还限制了这些时间的Internet访问。Root可以随时登录，也可以随时浏览Internet。

注意：系统会使用这些规则将错误记录为syslog（3）。

使用Ubuntu Linux，可以为您的计算机分配时间限制，以防止一个或多个用户连接到您的系统。有了时间限制，您就可以例如限制孩子的计算机访问权限（简称为家长控制），甚至可以在某些小时内保护与服务器的连接。

手动配置

了解你会做什么

在本教程中，我们将使用PAM（可插拔身份验证模块，英语可插拔身份验证模块）。当用户连接时，它允许您控制用户身份验证。然后，我们将使用安全性配置文件来定义允许的登录时间。这些操作可以在任何版本的Ubuntu上执行，并且只需要一个简单的文本编辑器（vim，emacs，nano，gedit，kate等）。通过PAM模块启用限制小时数

首先，首先转到/etc/pam.d/，所有可配置服务在哪里：

$ 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

如果我们要阻止与计算机的连接，则必须更改gdm服务。编辑文件，使其为gdm并添加以下代码行（在文件末尾）：

account required pam_time.so

GDM是Ubuntu，Edubuntu和Xubuntu的登录屏幕发行版。对于使用KDE的Kubuntu，将调用kdm服务，它将是它将打开的文件。您已经完成了配置PAM的工作！这样可以控制该服务的小时数。

如果您有服务器，则可能没有GUI。在这种情况下，未安装GDM / KDM，并且不会阻塞连接。为了防止连接到TTY，您必须修改同一文件的登录名，并添加与先前确认的相同的代码行。此操作也适用于已安装GUI并希望阻止访问登录屏幕和终端的人员。

配置访问时间

现在已经激活了PAM服务，我们只需要配置访问时间。打开/etc/security。有几个配置文件可用：

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

编辑文件time.conf。一些解释和例子（英语）介绍。要设置访问时间表，请复制并粘贴以下代码行（与以往一样，在文件末尾）：

*;*;user;scheduler

代替用户字段，输入要阻止的登录帐户。

如果要阻止多个用户，请在一行中输入他们的登录名，并用|分隔。操作员。例如，如果我要冻结Patrick，John和Emily的帐户：

*;*;Patrick|jean|emilie;scheduler

通过利弊，如果您想阻止除一个用户外的所有用户对系统的访问，请使用！在有关人员面前。例如，如果我要拒绝所有用户访问计算机，除了Nicolas和Xavier：

Nicolas *;*;!|xavier;scheduler

现在转到现场区域。在该字段中，将允许选择天数和小时数进行连接。您必须首先使用以下缩写指定星期几：

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

注意不要混淆缩写Wk和Wd误导您！在Internet上特别难以识别：您可以轻松找到有冲突的信息！

然后，我们指定截止日期。这些格式应为24H，由4位数字组成。例如，将下午3:17限制为下午6:34，我们写：1517-1834。为了让Marie仅在星期二下午3:17到6:34进行连接，我们得到以下结果：

*;*;marie;Tu1517-1834

这些时间以外的连接将被禁止。对于用户，可以使用| 和！指示几次（然后！表示允许所有登录时间，但显示的时间除外）。

代码行开头的两个星号（通配符）分别是和tty服务字段。由于要阻止所有对系统的访问，因此无需指定要阻止的服务或tty。但是，如果要阻止使用特定服务，只需将其指定为以下示例：

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

因此，用户结婚不能在周末期间连接到TTY，4和5。

限制时间表的一些示例

每天从1:20 pm到3:20 pm和从4:00 pm到8:30 pm都可以连接mathilde：

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

Stone，Frank和Florian允许在工作日的2:00 pm至6:45 pm以及周末的2:00 pm至10:15 pm进行连接：

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

永远不允许Olive连接。杰西卡可以在星期三1:00 pm至4:00 pm登录：

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

2条不同的线路，每个用户使用两个不同的时间

当会话到期时（超过用户已连接的时间），PAM可以联系用户。虽然mathilde在允许的时间内连接，但完全可以免费超过这些时间！为此，我们将使用一个新程序：“ cron”。该应用程序每隔一段时间执行命令。在本例中，我们将使用“ skill-KILL-u”命令在会话结束时断开与用户的连接。处理非常简单。只需编辑文件“ / etc / crontab”。然后添加以下代码行：

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

和以前一样，替换“分钟”字段的时间表和所需的时间。然后，在禁止的日期之前填写日期，或者只需输入星号（*）来表示一周中的所有日期。最后，将登录帐户使用的字段更改为被阻止，瞧！

天不注意到工作的方式cron！这是此程序使用的缩写列表：

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

一些cron工作示例（在上一节中有时间示例）

杰西卡可以在星期三1:00 pm至4:00 pm登录

->断开连接：星期二下午4:00。

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

每天从1:20 pm到3:20 pm和从4:00 pm到8:30 pm都可以连接mathilde。

->断开连接：美国东部时间每天8:30 pm至3:20 pm。

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

周一至周五，Stone，Frank和Florian的连接时间为2:00 pm至6:45 pm，周末的连接时间为2:00 pm至10:15 pm

->断开连接（1）：星期一，星期二，星期三，星期四和星期五的18:45。->断开连接（2）：周六和周日晚上10: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

命令skill-KILL-u将用户与GUI以及TTY断开。它非常适合服务器管理员使用。但是，此命令是立即执行的，将在不通知的情况下断开连接。因此，最好是防止安装该计算机或网络用户的设备！

可以wall通过cron在时间段结束前几分钟启动的命令来阻止用户，该命令将显示在所有用户的终端中。

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

为了防止用户使用GUI，可以notify-send在软件包libnotify-bin中使用wall命令代替 安装X

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

Ubuntu 11.10用户

我已经看到用户在使用Pam时遇到问题，并且看到了很多关于此的错误，为什么会这样呢？？？如此简单，Ubuntu 11.10不再支持GDM了，新的显示管理器是lightGDM，问题在于存储account required pam_time.so我认为该指令的位置，/etc/pam.d/lightdm或者/etc/pam.d/lightdm-autologin如何出错？

因此，您可以检查以下2个LightGdm日志文件：

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

或以调试模式运行LightGdm：

LightDM-调试

或报告错误：

Ubuntu的bug lightdm

我报告错误在这里，所以请您耐心等待...

— 赫尔普
source
3
这-哇- 太棒了 -我印象深刻！Esp。通知位非常符合我的喜好，因为我们不希望我们的孩子在没有任何警告的情况下就被踢走。即使对于像我这样邪恶的父亲来说，那也太邪恶了；）
— 塔卡特（Takkat
不幸的是，对于lightdm，这似乎不起作用（bugs.launchpad.net/lightdm/+bug/880313）。
— 塔卡特2011年
哇，这是一个很棒而又长久的解释..
— Mahmudin Ashar 2011年
openSUSE 11.4的情况与Ubuntu 11.10完全一样。
— 古普塔
11

TimeKpr

我想它拥有您需要的一切。限制每位用户每天的访问时间，易于配置的gui，可以绕开一天的时间，添加一些“奖励时间”，通知用户剩余时间等。

项目页面在这里。他们也有针对ubuntu的PPA，您可以将其添加到您的软件来源：中deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main。并通过软件中心或CLI进行安装：sudo apt-get install timekpr。

— Decio Lira
source
可以TimeKpr单个应用程序的设置时间限制（比如游戏？）
— 安德森格林
8

Timekpr

可以在运行LightDM的11.10中用于为用户设置限制，方法是将以下行添加到 /etc/pam.d/lightdm

account required pam_time.so

我们可能需要删除libpam-smbpass才能启用用户切换，直到错误＃835310得到修复。

在应用程序窗口中定义的所有限制条件都按照timekpr GUI中的定义工作。

要在Unity中显示timekpr-client图标，我们需要在Unity面板设置中加入白名单 'timekpr'，此外，我们需要Unity在的以下行中添加/etc/xdg/autostart/timekpr-client.desktop：

OnlyShowIn=GNOME;XFCE;KDE;Unity;

要开始倒计时授予的时间，我们可能必须启动timekpr守护进程与

/etc/init.d/timekpr start

对于14.04：

Eduards Bezverhijs在Ubuntu 14.04中发布了timekpr的较新版本/ fork ppa:mjasnik/ppa。

— 塔卡特
source
太好了，但我认为这是一个临时解决方案……因为您正在同时使用timepkr和samba与其他计算机共享有关可能的错误的信息（请参阅ClaudeD（claude-d）编写的内容）……
— hhlp
7

如果您处于某个中间状态，则自动注销非常令人沮丧。这很暴力，很残酷，很无礼。你多大年纪都没关系。当您只是对计算机上瘾时，这是一回事，而在跟踪时间并在设法单击提交按钮或保存文档之前5秒钟被踢出门的情况则大不相同。我建议您考虑使用自动提醒而不是自动踢球。这样可以教会您的孩子互相尊重，并允许彼此自愿使用计算机。

甚至还有更轻巧的选择。首先跟踪每个孩子在计算机上花费的时间，然后将收集到的数据提供给所有人，以便他们可以看到它们。当我是一个成年人办公室里的网络管理员时，仅此一件非常简单的事情（适用于花费的互联网带宽）就挽救了我的性命。有关每台计算机带宽使用情况的公共统计信息（只是字节数，而不是对访问站点列表等信息进行匿名处理）将情况从“我-恶意贪婪的管理员-虐待滥用的办公室用户”变为“人，您下载的次数是我的5倍，这很糟糕！” “对不起，我确实下载了，我在午休时间观看了很多youtube，现在不再以这种速度播放”-我只是被排除在对抗情况之外。

— vh1
source
6

我也有这个问题。因此，我编写了kidtimer脚本，该脚本可让您定义使用时间和总计。该项目可以在Github上的以下位置找到：

这是安装和使用方法：

  1. 将代码复制并粘贴到名为的文件中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. 执行它： 

    sudo ./kidtimer.install

  3. 运行：

    sudo kidtimer

  4. 设置一个现有的用户帐户。

  5. 做完了

求助：

sudo kidtimer help

将时间添加到用户的帐户（仅适用于该天）：

sudo kidtimer addtime user minutes

特征：

  • 在工作日和周末，允许您的孩子在一天中的特定时间访问计算机。
  • 设置工作日和周末的最大时间。

关键文件：

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

Cronjobs：

  • 每分钟检查一次，查看用户是否已登录。如果已登录，请增加总时间。如果达到最大时间，请禁用帐户并开始注销顺序（总共5分钟）。
  • 每小时检查一次，是否允许用户登录。如果是这样，请启用帐户。
  • 在午夜，重置时间。

注意：

该应用程序notify-send用来提醒用户时间即将用尽。当时间用完时，所有用户进程都将终止，因此请准备用户。

— grover66
source
5

timekpr-此程序将跟踪和控制用户帐户的计算机使用率。您可以根据定时访问时间限制他们的日常使用，并配置他们可以登录或不能登录的一天的时间。使用此应用程序，管理员可以限制帐户登录时间或帐户访问时间。该应用程序可作为家长时间控件，对希望限制孩子访问时间的家长很有用。

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

您可以通过从系统不受信任的PPA中添加不受支持的软件包来更新系统，方法是将其添加ppa:timekpr-maintainers/ppa到系统的软件源中。

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

该软件包位于：

问题：

我报告错误在这里，所以请您耐心等待...

— 赫尔普
source
哦，那是个好消息。我们以前在这里使用timekpr。希望它能正常工作-它仍然安装在我的11.10机器上，运行良好，但不会锁定我孩子的帐户。
— 塔卡特2011年
并为14.04工作吗？
— rogerdpack 2014年
3

介绍

我们可以检查用户是否通过以下命令登录：

who -u

这给了我们类似的输出：

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

在输出中，我们获得目标用户的pid，如果时间超出限制，则需要将其暂停。

解决方案

假设您的用户没有sudo特权：

该解决方案是一个小的后台脚本。它将每天的使用量限制为定义的分钟数，以在脚本的开头进行设置。一旦设置（这不太困难），它就非常容易运行，此后无需采取其他任何措施。

为防止可能打开的文件意外丢失数据，在目标用户的时间限制到期前 60秒，他或她将出现一条消息DISPLAY：

在此处输入图片说明

剧本

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

如何使用

  1. 在桌面上（或其他任何地方），创建一个名为： limit
  2. 将脚本复制到一个空文件中，将其另存为limit_use（无扩展名）在文件夹中，并使其可执行

  3. 在脚本的开头编辑要限制的用户名以及允许的最大分钟数。在示例中：

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

  4. 将文件夹复制到目录/opt：

    cp -r /path/to/limit /opt

  5. 现在编辑/etc/rc.local以使脚本root在启动时运行：

    sudo -i gedit /etc/rc.local

    就在行前 

    exit 0

    另一行：

    /opt/limit/limit_use &

说明; 这个怎么运作

  • 脚本每10秒检查一次目标用户是否登录/opt/limit/uselog。如果达到每日限制，该脚本将不再允许用户登录，如果存在则终止其进程。
  • 在更改日期时（日期记录在文件中，因此重新启动将无济于事），删除了日志文件，从而增加了新的使用时间。
  • 由于脚本在启动时运行，因此rc.local只有具有sudo特权的用户才能停止脚本，即使只有在用户知道进程名称的情况下也可以。

停止脚本

如果您想停止脚本，请使用以下命令：

sudo kill "$(pgrep limit_use)"

但是您需要使用sudo密码。

— 雅各布·弗利姆
source
2

我尝试过timekpr但没有成功。然后做了一个变种，可以在我的Ubuntu上使用。这是此变体需要执行的操作：

  1. /var/lib/timelimit/user_to_be_limited.limit仅在具有根权限的文件中添加时间限制。例如1800，每天限制1800秒（30分钟）。

  2. 使用以下内容创建/usr/local/bin/timelimit.sh具有root权限的用户：

    #!/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. 添加到/etc/rc.local：

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

  4. 重新启动Ubuntu

— 沙巴
source
2

我只是简单地提供了一个答案。在线程http://forums.linuxmint.com/viewtopic.php?f=213&t=77687上解释了代码。简而言之：每天（以分钟为单位）配置的限制，每分钟进行一次cron作业，向用户发送消息以使他随时了解情况以及强制注销。

要下载并安装此程序，请打开终端并运行以下命令：

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

在安装过程中（安装cron作业，复制脚本等），将要求管理员密码。从那里您将被引导到所有人。以防万一，在同一位置也有一个./uninstall.sh。它可以与所有基于Ubuntu的发行版（Mint等，也可能还有所有debian）一起使用。如果发生任何问题，请告知我，包括系统版本和图形环境的注释：

uname -a
echo $XDG_CURRENT_DESKTOP

托马斯·贝克克鲁特

— 托马斯·贝克克鲁特
source
1

我刚刚发布了新应用程序的Beta版，该版本LittleBrother可以监视Linux机器上的播放时间。欢迎测试用户试用Debian软件包。有关如何下载和使用它的说明，可以在这里找到：https : //github.com/marcus67/little_brother。但是，安装可能仍然有些粗糙。这些是应用程序的功能：

  • 可以监视任意数量的用户。
  • 每个用户可以具有一组定义允许的播放时间的特定规则。
  • 规则可以适应“上下文”，例如星期几和/或休假时间表（目前仅支持德语时间表）。
  • 播放时间可以限制为一个时间窗口（从，到）。
  • 可以定义每天的最大播放时间。
  • 在一定的最大会话时间之后，可能会迫使用户休息一下。
  • 用户可能被迫在活动后等待最少的休息时间。
  • 可以监视任意数量的Linux客户端主机（当前，这要求用户在所有计算机上具有相同的登录名）。
  • 有一个主主机，其中包含所有用户活动的历史记录。该主控主机检查规则集，并在需要时提示客户端主机终止进程。
  • 主控主机提供了一个简单的Web界面，用于在配置的历史记录长度（例如7天）内查看用户活动，还提供了一个管理页面，用于动态定义规则后的未来几天的例外情况。
  • 该Web应用程序可以在代理后面运行，以便可以从远程访问它，从而可以在接到年轻用户的请求以延长播放时间后进行远程管理。
  • 该应用程序具有国际语言支持。目前提供英语和德语翻译。邀请用户提供其他语言的翻译。
  • 该应用程序使用语音生成功能来通知用户即将进行的强制注销。这些口语信息也被国际化了。
  • 除了在Linux主机上花费的时间外，该应用程序还可以监视其他设备（例如智能手机或桌子）上的活动时间。利用以下事实：大多数现代操作系统在不使用设备时会将其置于某种节能模式。这样，网络响应（通过ping操作）可用于确定这些设备上的活动。与Linux主机相反，该应用程序将无法终止活动。但是，播放时间将添加到总播放时间中，因此会影响允许的时间以及Linux主机上的休息时间规则。

一些截图：

状态页 管理页面

— 马库斯·里克特（Marcus Rickert）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.