Take the 2-minute tour ×
Ask Ubuntu is a question and answer site for Ubuntu users and developers. It's 100% free, no registration required.

Access to our computer (not only to the internet) needs to be restricted for the accounts of my kids (7, 8) until they are old enough to manage this by themselves. Until then we need to be able to define the following:

  • the hours of the day when computing is o.k. (e.g. 5 - 9 pm)
  • the days of the week when computing is not o.k. (e.g. mondays to fridays)
  • the amount of time allowed per day (e.g. 2 hours)

In 11.10 all of the following that used to do the job don't work any more:

  • Timekpr: for > 11.10 no more available through the ppa.
  • Timoutd: command line alternative, but from 11.10 removed from the repositories.
  • Gnome Nanny: Looks great but repeatedly crashes to force restarting X-server. So we can't use or recommed this program at the moment.

Are there any other alternatives?

share|improve this question

We're looking for long answers that provide some explanation and context. Don't just give a one-line answer; explain why your answer is right, ideally with citations. Answers that don't include explanations may be removed.

    
Hmmm... if there isn't anything that does this, it would probably be easy to hack it together with shell scripts / cron jobs. –  Nathan Osman Aug 21 '10 at 2:24
6  
EEK. Can't let my parents see this one. BUT, I'd get around it because I've got awesome root access. :P –  jrg Oct 21 '11 at 19:34
    
The interest is in "still being developed", but I don't think it merits a new question. –  hbdgaf Mar 9 '13 at 19:36
    
Other than the timekpr developer promising he may or may not have time to continue development there is no such application afaik. But from my own experience I know now that we can do well (better even?) without but it then needs smart kids and smart parents. –  Takkat Mar 9 '13 at 20:10

9 Answers 9

up vote 5 down vote accepted

timekpr - This program will track and control the computer usage of your user accounts. You can limit their daily usage based on a timed access duration and configure periods of day when they can or cannot log in. With this application, administrators can limit account login time duration or account access hours. The application works as a parental time control, and will be useful to parents who want to limit child access time.

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

You can update your system with unsupported packages from this untrusted PPA by adding ppa:timekpr-maintainers/ppa to your system's Software Sources.

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

This package is available in :

PROBLEM :

I report the Bug's here so cross your finger and wait....

share|improve this answer
    
Oh that is good news. We used to use timekpr here. Hope it will work - it's still installed on my 11.10 box, runs well but doesn't lock my kid's accounts. –  Takkat Oct 24 '11 at 21:11
    
and for 14.04 does it work? –  rogerdpack Jun 23 at 14:15

Ubuntu <= 11.10 User's follow this guide for Ubuntu User's >= 11.10 read the Bottom page notice :

Yes all of those programs are out of date and all your questions are answered here and good look with your parent control.....

When we talk about forcing a user to log off, what we’re really talking about is implementing time restrictions on the account for system access or services. The easiest way I’ve found to implement time restrictions is using a plug-in module called Linux-PAM.

Pluggable Authentication Module (PAM) is a mechanism for authenticating users. Specifically, we’re going to use the pam_time module to control timed access for users to services.

Using the pam_time module, we can set access restrictions to a system and/or specific applications at various times of the day as well as on specific days or over various terminal lines. Depending on the configuration, you can use this module to deny access to individual users based on their name, the time of day, the day of week, the service they’re applying for, and their terminal from which they’re making the request.

When using pam_time, you must terminate the syntax of each line (or rule) in the /etc/security/time.conf file with a newline. You can comment each line with the pound sign [#], and the system will ignore that text until the newline.

Here’s the syntax for a rule:

services;ttys;users;times

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.

Here’s an example of a typical set of rules:

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

These rules restrict user bobby from logging on between the hours of 0800 and 2000, and they also restrict Internet access during these hours. Root would be able to logon at any time and browse the Internet during all times as well.

Note: The system logs errors with these rules as syslog(3).


With Ubuntu Linux, it is possible to assign to your computer time restrictions, to prevent the connection of one or more users to your system. With the time restrictions, you can, for example, limit access to the computer for your children (a kind of parental control, in short), or even protect the connection to your server during certain hours.

Manual Configuration

Understand what you will do

Throughout this tutorial, we will use PAM (Pluggable Authentication Modules, English Pluggable Authentication Modules). It allows you to control user authentication when they connect. Then, we will use the security configuration files to define logon hours allowed. These manipulations can be performed on any version of Ubuntu, and require only a simple text editor (vim, emacs, nano, gedit, kate, to name a few). Enable Restrictions hours via the PAM Module

First of all, first go to the /etc/pam.d/, where is all configurable services:

$ 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

If we want to block the connection to the computer, we will have to change the gdm service. Edit the file so gdm and add this line of code (at the end of file):

account required pam_time.so

GDM is the login screen distributions Ubuntu, Edubuntu and Xubuntu. For Kubuntu, which uses KDE, kdm service is called, it will be the file it will open. And you're done for configuring the PAM! This will enable the control of hours on this service.

If you have a server, you probably do not have no GUI. In this case, GDM / KDM not installed and the connection will not be blocked. To prevent connection to TTY, you must modify the login of the same file, and add the same line of code than previously acknowledged. This action also applies to people who have installed a GUI and want to block access to the login screen and terminals.

Configure Access Hours

Now that the PAM service has been activated, we only have to configure access times. Open the /etc/security. Several configuration files are available:

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

Edit the file time.conf. Some explanations and examples (English) introducing the. To set access schedules, copy and paste the following line of code (at the end of the file, as always):

*;*;user;scheduler

Instead of the user field, enter the login account you want to block.

If you want to block multiple users, enter their login in a row, separated by the | operator. For example, if I want to freeze the accounts of Patrick, John and Emily:

*;*;Patrick|jean|emilie;scheduler

By cons, if you want to block access to the system for all users but one in particular, use the! before the person concerned. For example, if I want access to the computer is denied to all users, except Nicolas and Xavier:

Nicolas *;*;!|xavier;scheduler

Turning now to the field zones. In this field that the selection of days and hours will be allowed connection possible. You must first specify the day of the week, using the following abbreviations:

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

Be careful not to confuse the abbreviations Wk and Wd are misleading! particularly poorly identified on the Internet: you can easily find conflicting information!

Then, we specify the deadlines. These should be formatted 24H, consisting of 4 digits. For example, to restrict 3:17 p.m. to 6:34 p.m., we write: 1517-1834. To allow Marie to connect only on Tuesday, from 3:17 p.m. to 6:34 p.m., we obtain the result:

*;*;marie;Tu1517-1834

Connections outside of these hours will be banned. As for users, it is possible to use the operators | and! to indicate several times (the! then indicate that all logon hours are allowed, except those to be shown).

The two stars (wildcards) at the beginning of the line of code are, respectively, and tty services fields. Since you want to block all access to the system, it is unnecessary to specify what service or what tty you want to block. However, if you want to prevent the use of a particular service, simply specify it as the following example:

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

Thus, the user marry can not connect to a TTY, 4 and 5 during the weekend.

Some Examples of Restrictions Schedule

mathilde is allowed to connect every day from 1:20 p.m. to 3:20 p.m. and from 4:00 p.m. to 8:30 p.m.:

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

Stone, Frank and Florian are allowed to connect to 2:00 p.m. to 6:45 p.m. during the weekdays, and 2:00 p.m. to 10:15 p.m. for the weekend:

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

Olive is never allowed to connect. jessica can log on Wednesday from 1:00 p.m. to 4:00 p.m.:

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

2 different lines, for two different time for each user Expiration of a Session

When a session expires (it exceeds the time while the user is already connected), the PAM can reach the user. While mathilde connects during the hours of time allowed, it is perfectly free to exceed these hours! For this, we will use a new program: ´cron´. This application executes commands at intervals of time. In our case, we will make use of command ´skill-KILL-u´ to disconnect the user when the session expires. Handling is very simple. Simply edit the file ´/etc/crontab´. Then add the following line of code:

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

As before, replacing the Minute field schedules and time desired. Then fill in the day (s) by (s) day (s) banned (s), or simply type an asterisk (*) to indicate all days of the week. Finally, change the field used by the login account to be blocked, and voila!

Days do not notice the same way with the cron jobs! Here is the list of abbreviations to be used with this program:

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

Some Examples of cron jobs (with examples of times in the previous section)

jessica can log on Wednesday from 1:00 p.m. to 4:00 p.m.

-> Disconnect: Tuesday at 4:00 p.m..

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

mathilde is allowed to connect every day from 1:20 p.m. to 3:20 p.m. and from 4:00 p.m. to 8:30 p.m..

-> Disconnecting: Daily, 8:30 p.m. to 3:20 p.m. ET.

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

Stone, Frank and Florian are allowed to connect to 2:00 p.m. to 6:45 p.m. during the weekdays, and 2:00 p.m. to 10:15 p.m. for the weekend

-> Disconnect (1): Monday, Tuesday, Wednesday, Thursday and Friday, at 18:45. -> Disconnect (2): Saturday and Sunday at 10:15 p.m..

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

The command skill-KILL-u disconnects the user from the GUI, as well as TTY. It is perfectly usable for server administrators. However, this command is immediate and the disconnection will be made without notice. It would therefore be preferable to prevent the installation of this device users of the computer or network in question!

It is possible to prevent users with a wall command launched by cron few minutes before the end of the timeframe, that will be displayed in the terminals of all users.

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

To prevent users from GUI can be used in place of the wall command notify-send is in the package libnotify-bin Install X

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

Ubuntu 11.10 User's

I've seen around user having problems with Pam and i saw alot of bug about that so Why is the reason??? is so simple Ubuntu 11.10 doens't support GDM anymore the new display manager is lightGDM the problem is the follow where store this directive account required pam_time.so i think is in /etc/pam.d/lightdm or /etc/pam.d/lightdm-autologin but bug how ???

so for just around you can check this 2 LightGdm log files :

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

or run LightGdm in debug mode :

LightDM --debug

or report a bug :

ubuntu-bug lightdm

I report the Bug's here so cross your finger and wait....

share|improve this answer
2  
This is - wow - great - I am impressed! Esp. the notify bit is very much to my liking because we don't want our kids to be kicked off without warning. That'd be too evil even for an evil dad like me ;) –  Takkat Oct 21 '11 at 17:50
    
Unfortunately with lightdm this seems not to work (bugs.launchpad.net/lightdm/+bug/880313). –  Takkat Oct 23 '11 at 11:57
    
wow, it's great and long explanation .. –  Mahmudin Ashar Oct 25 '11 at 13:07

TimeKpr


Timekpr Config Screen

I guess it has everything you need. Limit access time per day per user, easy gui for configuration, abitlity to bypass for a day, add some "reward time", notification of remaining time for users, etc.

The project page is here. They also have a PPA for ubuntu which you can add to your Software Sources: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. And install via Software Center or via CLI: sudo apt-get install timekpr.

share|improve this answer
    
Can TimeKpr set time limits for individual applications (such as games?) –  Anderson Green Dec 7 '12 at 16:37

Auto-logoff is extremely frustrating if you are in the middle of something. It's violent, it's brutal, it's plain rude. And it doesn't matter how old you are. It's one thing when you are just computer addicted and it's very different when you are tracking time and get kicked out 5 seconds before you managed to click that submit button or save your document. I suggest you to consider using an auto-reminder instead of an auto-kicker. That will teach your kids to respect each other and allow each other to use the computer willingly.

There's even a lighter alternative. Start by tracking the amount of time that each kid spends using the computer and make the gathered data available for all of them so they can see it. This incredibly simple thing alone (applied to internet bandwidth spent) has saved my life when I was being the network admin in an office full of adults. The public stats about bandwidth usage for each computer (just the amount of bytes, not deanonymizing info like lists of visited sites etc) turned the situation from "me - the evil greedy admin against them - the poor abused office users" to "man, you downloaded 5 times more than me, that's bad!" "sorry, I downloaded indeed, I watched a lot of youtube during lunch breaks, won't do it anymore at this rate" - I was simply excluded from the confrontation scenario.

share|improve this answer

Timekpr

can be used in 11.10 running LightDM to setup restrictions for users by adding the following line to /etc/pam.d/lightdm

account required pam_time.so

We may need to remove libpam-smbpass to enable user switching until bug #835310 is fixed.

All restrictons defined in the application window work as defined in the timekpr GUI.

To display the timekpr-client icon in Unity we need to whitelist 'timekpr'in Unity panel settings, and in addition we need to add Unity to the following line in /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

To start the countdown of the time granted we may have to start the timekpr daemon with

/etc/init.d/timekpr start

Update:

The developer of timekpr announced they plan to continue the development but it is still unclear when we can expect anything further: https://launchpad.net/timekpr/+announcement/9737

share|improve this answer
    
Great but i think is a temporary solution ... because is you are using timepkr and samba at the same time for sharing with other computers (see what ClaudeD (claude-d) wrote) about possible error.... –  hhlp Oct 27 '11 at 19:11
    
Yeah I do hope this bug gets fixed soon. Still, as long as nobody continues developing timekpr we need this line for lighdm. –  Takkat Oct 27 '11 at 19:15
    
According to bug 881098 we may be able to run the existing version. –  Takkat Sep 24 '12 at 19:15

I had this issue too. So I wrote the kidtimer script, which lets you define usage times and totals. The project can be found on Github at the following location:

This is how to install it and use it:

  1. Copy and paste the code into a file called 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. Execute it:

    sudo ./kidtimer.install
    
  3. Run it:

    sudo kidtimer
    
  4. Setup a existing user account.

  5. Done.

For help:

sudo kidtimer help

Add time to a user's account (for that day only):

sudo kidtimer addtime user minutes

Features:

  • Allow your kid specific hours of the day to access the computer, both weekday and weekend.
  • Set maximum amount of time, both weekday and weekend.

Key files:

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

Cronjobs:

  • Check every minute to see if user is logged in. If so, increment total time. If hit max time, disable account and start logoff sequence (5 mins total).
  • Check hourly to see if user is allowed to login. If so, enable account.
  • At midnight, reset time.

Note:

The application uses notify-send to alert user time is running out. When time runs out, all user processes are terminated, so please prepare user.

share|improve this answer

There is "self control" that will block internet access. http://www.omgubuntu.co.uk/2011/02/self-control-ubuntu/

share|improve this answer
2  
Whilst this may theoretically answer the question, it would be preferable to include the essential parts of the answer here, and provide the link for reference. –  RolandiXor Oct 18 '11 at 21:05
1  
Needs to block access to the entire computer, not just the internet. –  zookalicious Oct 18 '11 at 21:06

I tried timekpr but did not got it working. Then made a variant of it which works on my Ubuntu. This is what one needs to do for this variant:

  1. Add time limit in /var/lib/timelimit/user_to_be_limited.limit file with root rights only. e.g. 1800 for 1800 seconds (30 minutes) daily limit.

  2. Create /usr/local/bin/timelimit.sh with root rights with following:

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

    sudo /usr/local/bin/timelimit.sh &
    
  4. Restart Ubuntu

share|improve this answer

Technical answer that I'm not going to bother understanding myself:

This is the thread: http://ubuntuforums.org/showthread.php?t=843510 for this software: https://launchpad.net/webcontentcontrol which has this plan in the works: https://blueprints.launchpad.net/webcontentcontrol/+spec/time-control

Would you be okay with something that allowed you to limit time spent on the internet? Or do they actually like gaming on Ubuntu?

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.