การเข้าถึงคอมพิวเตอร์ของเรา (ไม่เพียง แต่อินเทอร์เน็ต) จะต้องถูก จำกัด สำหรับบัญชีของลูก ๆ ของฉัน (7, 8) จนกว่าพวกเขาจะมีอายุมากพอที่จะจัดการสิ่งนี้ด้วยตนเอง ก่อนหน้านั้นเราจำเป็นต้องสามารถกำหนดสิ่งต่อไปนี้:

• ชั่วโมงของวันที่การคำนวณนั้นใช้ได้ (เช่น 5 - 21.00 น.)
• วันของสัปดาห์เมื่อการคำนวณไม่เป็นที่ตกลง (เช่นวันจันทร์ถึงวันศุกร์)
• ระยะเวลาที่อนุญาตต่อวัน (เช่น 2 ชั่วโมง)

ใน 11.10 ทั้งหมดต่อไปนี้ที่ใช้ในการทำงานไม่ทำงานอีกต่อไป:

• Timekpr : สำหรับ> 11.10 ไม่สามารถดูผ่าน ppa ได้อีก
• timeoutd : คำสั่งทางเลือกบรรทัด แต่จาก 11.10 ลบออกจากคลัง
• Gnome Nanny : ดูดี แต่ล้มเหลวซ้ำ ๆเพื่อบังคับให้รีสตาร์ทเซิร์ฟเวอร์ X ดังนั้นเราจึงไม่สามารถใช้หรือแนะนำโปรแกรมนี้ได้ในขณะนี้

มีทางเลือกอื่นอีกไหม?

ล็อคหน้าจอจับเวลา

สร้าง Screen Lock Timer ของคุณเองแทนแอปพลิเคชันของบุคคลที่สาม

แม้ว่าจะมีแอปพลิเคชันบุคคลที่สามให้ทำเช่นนี้คุณสามารถสร้างของคุณเอง สรุปขั้นตอน:

• ใช้geditเพื่อสร้างสคริปต์lock-screen-timer
• คัดลอกและวางรหัสจากหน้าต่างนี้ไปที่ lock-screen-timer
• ทำเครื่องหมายlock-screen-timerว่าปฏิบัติการได้
• ทดสอบ!
• กำหนดค่า Nautilus เพื่อเรียกใช้งานสคริปต์ทุบตี
• สร้างลิงก์ทางลัดบนเดสก์ท็อป
• เวลาที่เหลือในการตรวจสอบ

ใช้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 เพื่อเรียกใช้งานสคริปต์ทุบตี

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ถ้าคุณคลิกเพื่อปิดหน้าต่างก็เป็นเช่นเดียวกับการเลือกXCancel

หลังจากที่ตัวจับเวลาทำงานและคุณดับเบิลคลิกที่มันอีกครั้งสำเนาที่รันครั้งแรกคือ "ถูกฆ่า" ตอนนี้คุณสามารถเริ่มนับถอยหลัง scren lock ใหม่หรือคลิกCancelเพื่อไม่นับถอยหลัง

แสดงเวลาที่เหลืออยู่ในพื้นที่ systray / การแจ้งเตือน

~/.lock-screen-timer-remainingในขณะที่การจับเวลาการล็อคหน้าจอกำลังทำงานจะบันทึกวิธีการหลายนาทีที่เหลือลงในแฟ้ม คุณสามารถดูไฟล์นี้ด้วยwatchคำสั่งหรือแสดงไว้ในถาดระบบ / แถบตัวบ่งชี้แอปพลิเคชันของ Ubuntu ดังที่แสดงไว้ด้านบนของคำตอบนี้ ในการแสดงเวลาที่เหลืออยู่ในพื้นที่แจ้งเตือนให้ทำตามคำแนะนำในคำถาม & คำตอบนี้: ( BASH สามารถแสดงใน systray เป็นตัวบ่งชี้แอปพลิเคชันได้หรือไม่ )

Ubuntu <= 11.10 ผู้ใช้ทำตามคำแนะนำนี้สำหรับผู้ใช้ Ubuntu> = 11.10 อ่านประกาศด้านล่างของหน้า:

ใช่โปรแกรมเหล่านั้นล้าสมัยและคำถามทั้งหมดของคุณได้รับคำตอบที่นี่และดูดีพร้อมกับการควบคุมของผู้ปกครองของคุณ .....

เมื่อเราพูดถึงการบังคับให้ผู้ใช้ออกจากระบบสิ่งที่เรากำลังพูดถึงคือการใช้การ จำกัด เวลาในบัญชีสำหรับการเข้าถึงระบบหรือบริการ วิธีที่ง่ายที่สุดที่ฉันได้พบในการดำเนินการข้อ จำกัด เวลาใช้ปลั๊กอินโมดูลที่เรียกว่าลินุกซ์ PAM

Pluggable Authentication Module (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

กฎเหล่านี้ จำกัด ผู้ใช้บ็อบบี้จากการเข้าสู่ระบบระหว่างชั่วโมง 0800 และ 2000 และพวกเขายัง จำกัด การเข้าถึงอินเทอร์เน็ตในช่วงเวลาเหล่านี้ รูทจะสามารถเข้าสู่ระบบได้ตลอดเวลาและท่องอินเทอร์เน็ตตลอดเวลาเช่นกัน

หมายเหตุ:ระบบบันทึกข้อผิดพลาดด้วยกฎเหล่านี้เป็น 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 สำหรับ Kubuntu ซึ่งใช้ KDE จะมีการเรียกใช้บริการ 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 ทำให้เข้าใจผิด! โดยเฉพาะอย่างยิ่งการระบุที่ไม่ดีบนอินเทอร์เน็ต: คุณสามารถค้นหาข้อมูลที่ขัดแย้งได้ง่าย!

จากนั้นเราจะระบุกำหนดเวลา สิ่งเหล่านี้ควรอยู่ในรูปแบบ 24H ประกอบด้วยตัวเลข 4 หลัก ตัวอย่างเช่นเพื่อ จำกัด 3:17 น. ถึง 18:34 น. เราเขียน: 1517-1834 เพื่อให้มารีเชื่อมต่อเฉพาะวันอังคารตั้งแต่ 15:17 น. ถึง 18:34 น. เราได้รับผลลัพธ์:

*;*;marie;Tu1517-1834

การเชื่อมต่อนอกเวลาเหล่านี้จะถูกแบน สำหรับผู้ใช้มันเป็นไปได้ที่จะใช้ตัวดำเนินการ | และ! เพื่อระบุหลาย ๆ ครั้ง (! จากนั้นระบุว่าอนุญาตให้ชั่วโมงการเข้าสู่ระบบทั้งหมดยกเว้นที่จะแสดง)

ดาวสองดวง (ไวด์การ์ด) ที่จุดเริ่มต้นของบรรทัดโค้ดคือตามลำดับและฟิลด์เซอร์วิส tty เนื่องจากคุณต้องการบล็อกการเข้าถึงระบบทั้งหมดจึงไม่จำเป็นต้องระบุบริการหรือสิ่งที่คุณต้องการบล็อก อย่างไรก็ตามหากคุณต้องการป้องกันการใช้บริการเฉพาะเพียงระบุเป็นตัวอย่างต่อไปนี้:

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

ดังนั้นผู้ใช้ที่แต่งงานไม่สามารถเชื่อมต่อกับ TTY, 4 และ 5 ในช่วงสุดสัปดาห์

ตัวอย่างบางส่วนของข้อ จำกัด กำหนดการ

mathilde ได้รับอนุญาตให้เชื่อมต่อทุกวันตั้งแต่ 13:20 น. ถึง 15:20 น. และจาก 16:00 น. ถึง 20:30 น.:

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

Stone, Frank และ Florian ได้รับอนุญาตให้เชื่อมต่อกับ 14:00 น. ถึง 18:45 น. ในช่วงวันธรรมดาและ 14:00 น. ถึง 22:15 น. สำหรับวันหยุดสุดสัปดาห์:

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

โอลีฟไม่เคยได้รับอนุญาตให้เชื่อมต่อ เจสสิก้าสามารถเข้าสู่ระบบในวันพุธตั้งแต่ 13.00 น. ถึง 16.00 น.

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

2 บรรทัดที่แตกต่างกันสำหรับสองเวลาที่แตกต่างกันสำหรับการหมดอายุของผู้ใช้แต่ละคนของเซสชัน

เมื่อเซสชันหมดอายุ (เกินเวลาที่ผู้ใช้เชื่อมต่ออยู่) PAM สามารถเข้าถึงผู้ใช้ได้ ในขณะที่ mathilde เชื่อมต่อในช่วงเวลาที่อนุญาตก็เป็นอิสระอย่างสมบูรณ์เกินเวลาเหล่านี้! สำหรับสิ่งนี้เราจะใช้โปรแกรมใหม่:´cron´ แอปพลิเคชั่นนี้รันคำสั่งตามช่วงเวลา ในกรณีของเราเราจะใช้คำสั่ง´skill-KILL-u´เพื่อตัดการเชื่อมต่อผู้ใช้เมื่อเซสชันหมดอายุ การจัดการนั้นง่ายมาก เพียงแก้ไขไฟล์ ´/ etc / crontab´ จากนั้นเพิ่มบรรทัดของรหัสต่อไปนี้:

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

เหมือนก่อนหน้านี้แทนที่ตารางเวลานาทีและเวลาที่ต้องการ จากนั้นกรอกวันตามวันที่ถูกแบนหรือพิมพ์เครื่องหมายดอกจัน (*) เพื่อระบุวันทั้งหมดของสัปดาห์ ในที่สุดเปลี่ยนฟิลด์ที่ใช้โดยบัญชีเข้าสู่ระบบที่จะถูกบล็อกและ voila!

วันไม่ได้สังเกตเช่นเดียวกับcronงาน! นี่คือรายการของตัวย่อที่จะใช้กับโปรแกรมนี้:

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

ตัวอย่างcronงานบางส่วน(พร้อมตัวอย่างของเวลาในส่วนก่อนหน้า)

เจสสิก้าสามารถเข้าสู่ระบบในวันพุธตั้งแต่ 13.00 น. ถึง 16.00 น

-> ตัดการเชื่อมต่อ: วันอังคารเวลา 16:00 น.

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

Mathilde ได้รับอนุญาตให้เชื่อมต่อทุกวันตั้งแต่ 13:20 น. ถึง 15:20 น. และจาก 16:00 น. ถึง 20:30 น.

-> การตัดการเชื่อมต่อ: ทุกวัน 20:30 น. ถึง 15:20 น. ET

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

Stone, Frank และ Florian ได้รับอนุญาตให้เชื่อมต่อกับ 14:00 น. ถึง 18:45 น. ในช่วงวันธรรมดาและ 14:00 น. ถึง 22:15 น. สำหรับวันหยุดสุดสัปดาห์

-> ตัดการเชื่อมต่อ (1): วันจันทร์วันอังคารวันพุธวันพฤหัสบดีและวันศุกร์เวลา 18:45 น. -> ตัดการเชื่อมต่อ (2): วันเสาร์และวันอาทิตย์เวลา 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

คำสั่ง skill-KILL-u ตัดการเชื่อมต่อผู้ใช้จาก GUI รวมถึง TTY มันสามารถใช้งานได้อย่างสมบูรณ์แบบสำหรับผู้ดูแลเซิร์ฟเวอร์ อย่างไรก็ตามคำสั่งนี้เป็นทันทีและจะตัดการเชื่อมต่อโดยไม่ต้องแจ้งให้ทราบล่วงหน้า ดังนั้นจึงเป็นการดีกว่าที่จะป้องกันการติดตั้งผู้ใช้อุปกรณ์นี้ของคอมพิวเตอร์หรือเครือข่ายที่เป็นปัญหา!

มีความเป็นไปได้ที่จะป้องกันผู้ใช้ด้วยwallคำสั่งที่เปิดตัวภายในcronไม่กี่นาทีก่อนสิ้นสุดกรอบเวลาซึ่งจะปรากฏในเทอร์มินัลของผู้ใช้ทั้งหมด

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

เพื่อป้องกันผู้ใช้จาก GUI สามารถใช้แทนคำสั่ง wall notify-sendได้ในแพ็คเกจlibnotify-bin

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

หรือรายงานข้อบกพร่อง:

ubuntu-bug lightdm

ฉันรายงานข้อผิดพลาดที่นี่เพื่อข้ามนิ้วของคุณและรอ

TimeKpr

ฉันคิดว่ามันมีทุกสิ่งที่คุณต้องการ จำกัด เวลาในการเข้าถึงต่อวันต่อผู้ใช้ GUI ง่ายสำหรับการกำหนดค่าความสามารถในการข้ามวันเพิ่มบาง "รางวัลเวลา" การแจ้งเตือนเวลาที่เหลือสำหรับผู้ใช้ ฯลฯ

หน้าโครงการคือที่นี่ พวกเขายังมี PPA สำหรับ Ubuntu ซึ่งคุณสามารถเพิ่มลงใน Software Sources ของคุณdeb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid mainได้ และติดตั้งซอฟแวร์ผ่านทางศูนย์หรือผ่าน sudo apt-get install timekprCLI:

Timekpr

สามารถใช้ใน 11.10 ที่รัน LightDM เพื่อตั้งค่าข้อ จำกัด สำหรับผู้ใช้โดยเพิ่มบรรทัดต่อไปนี้ /etc/pam.d/lightdm

account required pam_time.so

^{เราอาจต้องลบlibpam-smbpassเพื่อเปิดใช้งานการสลับผู้ใช้จนกว่าข้อผิดพลาด # 835310จะได้รับการแก้ไข}

Restrictons ทั้งหมดที่กำหนดในหน้าต่างแอปพลิเคชันทำงานตามที่กำหนดใน timekpr GUI

ในการแสดงไอคอน timekpr-client ใน Unity เราจำเป็นต้องเพิ่ม ไวท์ลิสต์'timekpr'ใน Unity panel settings และนอกจากนี้เราจำเป็นต้องเพิ่มUnityในบรรทัดต่อไปนี้ใน/etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

ในการเริ่มต้นนับถอยหลังของเวลาที่กำหนดเราอาจต้องเริ่ม timekpr daemon ด้วย

/etc/init.d/timekpr start

สำหรับ 14.04:

ข่าวใหม่ / แยกของ timekpr ถูกตีพิมพ์สำหรับ Ubuntu 14.04 โดยEduards Bezverhijsppa:mjasnik/ppaในของเขา

การออกจากระบบอัตโนมัติเป็นเรื่องที่น่าผิดหวังอย่างมากหากคุณอยู่ในกลาง มันรุนแรงโหดร้ายมันหยาบคายธรรมดา และมันไม่สำคัญว่าคุณจะอายุเท่าไหร่ เป็นเรื่องหนึ่งเมื่อคุณเพิ่งจะติดคอมพิวเตอร์และมันแตกต่างกันมากเมื่อคุณกำลังติดตามเวลาและถูกเตะออกไป 5 วินาทีก่อนที่คุณจะคลิกปุ่มส่งหรือบันทึกเอกสารของคุณ ฉันแนะนำให้คุณลองใช้การเตือนความจำอัตโนมัติแทนการใช้ kicker อัตโนมัติ ที่จะสอนให้ลูก ๆ ของคุณเคารพซึ่งกันและกันและอนุญาตให้ใช้คอมพิวเตอร์อย่างเต็มใจ

แม้จะเป็นทางเลือกที่เบากว่า เริ่มต้นด้วยการติดตามระยะเวลาที่เด็กแต่ละคนใช้คอมพิวเตอร์และทำให้ข้อมูลที่รวบรวมได้ทั้งหมดของพวกเขาเพื่อให้พวกเขาเห็น สิ่งที่เรียบง่ายอย่างไม่น่าเชื่อเพียงอย่างเดียว (ใช้กับแบนด์วิดท์อินเทอร์เน็ตที่ใช้) ช่วยชีวิตฉันเมื่อฉันเป็นผู้ดูแลระบบเครือข่ายในสำนักงานที่เต็มไปด้วยผู้ใหญ่ สถิติสาธารณะเกี่ยวกับการใช้แบนด์วิดท์สำหรับคอมพิวเตอร์แต่ละเครื่อง (เพียงจำนวนไบต์ไม่ใช่ข้อมูลไม่ระบุชื่อเช่นรายชื่อของเว็บไซต์ที่เข้าชม ฯลฯ ) ทำให้สถานการณ์เปลี่ยนจาก "ฉัน - ผู้ดูแลระบบโลภชั่วร้ายกับพวกเขา - ผู้ใช้สำนักงานที่ไม่เหมาะสม" คุณดาวน์โหลดมากกว่าฉัน 5 เท่านั่นมันแย่มาก! " "ขออภัยฉันดาวน์โหลดแน่นอนฉันดู youtube จำนวนมากในช่วงพักเที่ยงจะไม่ทำมันอีกต่อไปในอัตรานี้" - ฉันถูกแยกออกจากสถานการณ์การเผชิญหน้า

ฉันมีปัญหานี้เช่นกัน ดังนั้นฉันจึงเขียนสคริปต์ kidtimer ซึ่งให้คุณกำหนดเวลาใช้งานและยอดรวมได้ โครงการสามารถพบได้ใน Github ที่สถานที่ดังต่อไปนี้:

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

นี่คือวิธีการติดตั้งและใช้งาน:

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เพื่อเตือนเวลาผู้ใช้ใกล้หมด เมื่อหมดเวลากระบวนการของผู้ใช้ทั้งหมดจะถูกยกเลิกดังนั้นโปรดเตรียมผู้ใช้

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ลงใน 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 

แพ็คเกจนี้มีให้ใน:

• ปัญหา Oneiric ดูรายงานข้อผิดพลาด ....
• สะอาดสะอ้าน
• นอกรีต
• สุวิมล
• Karmic
• ร่าเริง
• กล้าหาญ

• บึกบึน

• PPA คืออะไรและฉันจะใช้ได้อย่างไร

ปัญหา:

ฉันรายงานข้อผิดพลาดที่นี่เพื่อข้ามนิ้วของคุณและรอ

บทนำ

เราสามารถตรวจสอบว่าผู้ใช้เข้าสู่ระบบโดยคำสั่ง:

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 เพื่อทำเช่นนั้น

ฉันพยายามtimekprแต่ไม่ได้ทำงาน จากนั้นสร้างตัวแปรที่ใช้ได้กับ Ubuntu ของฉัน นี่คือสิ่งที่เราต้องทำสำหรับตัวแปรนี้:

1. เพิ่มการ จำกัด เวลาใน/var/lib/timelimit/user_to_be_limited.limitไฟล์ด้วยสิทธิ์ของรูทเท่านั้น เช่น 1800 เป็นเวลา 1800 วินาที (30 นาที) ขีด จำกัด รายวัน

2. สร้าง/usr/local/bin/timelimit.shด้วยสิทธิ์รูทโดยทำดังนี้:

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

ฉันเพิ่งทำคำตอบได้อย่างง่ายดาย รหัสจะมีการอธิบายในหัวข้อhttp://forums.linuxmint.com/viewtopic.php?f=213&t=77687 ในระยะสั้น: จำกัด การกำหนดค่าในนาทีต่อวันงาน cron ทุกนาทีข้อความถึงผู้ใช้เพื่อแจ้งให้เขาทราบและออกจากระบบบังคับ

ในการดาวน์โหลดและติดตั้งสิ่งนี้ให้เปิด Terminal และเรียกใช้คำสั่งด้านล่าง:

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

รหัสผ่านผู้ดูแลระบบจะถูกร้องขอในระหว่างกระบวนการติดตั้ง (เพื่อติดตั้งงาน cron, เพื่อคัดลอกสคริปต์, ... ) จากนั้นคุณจะได้รับคำแนะนำสำหรับทุกคน นอกจากนี้ยังมี. / uninstall.sh ในสถานที่เดียวกันในกรณี มันสร้างเพื่อทำงานกับ distro ที่ใช้ Ubuntu ทั้งหมด (มิ้นต์และอื่น ๆ ... อาจเป็นเดเบียนทั้งหมด) หากมีปัญหาใด ๆ เกิดขึ้นโปรดแจ้งให้เราทราบรวมถึงรุ่นของระบบและสภาพแวดล้อมแบบกราฟิกในความคิดเห็น:

uname -a
echo $XDG_CURRENT_DESKTOP

โทมัส Baeckeroot

ฉันเพิ่งเปิดตัวแอปพลิเคชั่นรุ่นเบต้าLittleBrotherซึ่งสามารถตรวจสอบเวลาเล่นบนเครื่อง Linux ได้ ผู้ใช้ทดสอบสามารถลองแพ็คเกจ Debian ได้ คำแนะนำเกี่ยวกับวิธีการดาวน์โหลดและใช้งานก็สามารถพบได้ที่นี่: https://github.com/marcus67/little_brother แม้ว่าการติดตั้งอาจยังหยาบเล็กน้อย นี่คือคุณสมบัติของแอปพลิเคชัน:

• จำนวนผู้ใช้สามารถตรวจสอบได้
• ผู้ใช้แต่ละคนสามารถมีกฎเฉพาะที่กำหนดเวลาเล่นที่อนุญาต
• กฎสามารถปรับให้เข้ากับ "บริบท" เช่นวันในสัปดาห์และ / หรือตารางวันหยุด (ปัจจุบันรองรับเฉพาะช่วงเวลาของภาษาเยอรมันเท่านั้น)
• เวลาเล่นสามารถถูก จำกัด ไว้ที่หน้าต่างเวลา (จาก, ถึง)
• สามารถกำหนดเวลาเล่นสูงสุดต่อวันได้
• ผู้ใช้สามารถถูกบังคับให้หยุดพักหลังจากช่วงเวลาสูงสุดที่กำหนด
• ผู้ใช้สามารถถูกบังคับให้รอเวลาพักน้อยลงหลังจากกิจกรรมของพวกเขา
• สามารถตรวจสอบโฮสต์ไคลเอนต์ Linux จำนวนเท่าใดก็ได้ (ในขณะนี้ผู้ใช้ต้องมีชื่อล็อกอินเหมือนกันในทุกเครื่อง)
• มีโฮสต์หลักที่มีประวัติกิจกรรมของผู้ใช้ทั้งหมด โฮสต์ต้นแบบนี้ตรวจสอบชุดของกฎและแจ้งให้โฮสต์ไคลเอ็นต์ยุติกระบวนการหากจำเป็น
• โฮสต์หลักมีเว็บอินเตอร์เฟสที่ใช้งานง่ายสำหรับการดูกิจกรรมของผู้ใช้ในช่วงระยะเวลาประวัติที่กำหนด (เช่น 7 วัน) และหน้าการบริหารเพื่อกำหนดข้อยกเว้นกฎแบบไดนามิกสำหรับจำนวนวันที่กำหนดไว้ในอนาคต
• เว็บแอปพลิเคชั่นสามารถทำงานได้หลังพร็อกซีเพื่อให้สามารถเข้าถึงได้จากระยะไกลช่วยให้สามารถดูแลระบบระยะไกลได้หลังจากรับสายจากผู้ใช้รุ่นใหม่ที่ขอเวลาเล่นเพิ่ม
• แอพพลิเคชั่นนี้รองรับภาษาต่างประเทศ ปัจจุบันมีการแปลภาษาอังกฤษและเยอรมัน ผู้ใช้งานได้รับเชิญให้แปลภาษาอื่น ๆ
• แอปพลิเคชั่นนี้ใช้การสร้างเสียงเพื่อแจ้งผู้ใช้เกี่ยวกับการล็อกเอาต์แบบบังคับ ข้อความที่พูดเหล่านี้ยังเป็นสากล
• นอกเหนือจากเวลาที่ใช้บน Linux โฮสต์แล้วแอปพลิเคชันยังสามารถตรวจสอบเวลากิจกรรมบนอุปกรณ์อื่น ๆ เช่นสมาร์ทโฟนหรือตาราง ใช้ประโยชน์จากความจริงที่ว่าระบบปฏิบัติการที่ทันสมัยส่วนใหญ่วางอุปกรณ์ในโหมดประหยัดพลังงานบางประเภทในขณะที่ไม่ได้ใช้งาน วิธีนี้สามารถใช้การตอบกลับเครือข่าย (โดยการส่ง Ping) เพื่อกำหนดกิจกรรมบนอุปกรณ์เหล่านั้น ตรงกันข้ามกับโฮสต์ Linux แอปพลิเคชันจะไม่สามารถยกเลิกกิจกรรมได้ อย่างไรก็ตามเวลาเล่นจะถูกเพิ่มลงในเวลาเล่นโดยรวมดังนั้นจะมีผลกระทบกับเวลาที่อนุญาตและกฎการแบ่งเวลาในโฮสต์ Linux

ภาพหน้าจอบางส่วน: