मैं अपने बच्चों के कंप्यूटिंग समय को कैसे सीमित करूं?

60

हमारे कंप्यूटर (केवल इंटरनेट तक) की पहुंच मेरे बच्चों (7, 8) के खातों तक सीमित रखने की आवश्यकता है, जब तक कि वे खुद से इसे प्रबंधित करने के लिए पर्याप्त नहीं हैं। तब तक हमें निम्नलिखित को परिभाषित करने में सक्षम होना चाहिए:

  • दिन का समय जब कंप्यूटिंग ठीक है (उदाहरण के लिए 5 - 9 बजे)
  • सप्ताह के दिन, जब कंप्यूटिंग ठीक नहीं है (उदाहरण के लिए शुक्रवार से सोमवार)
  • प्रति दिन अनुमत समय की मात्रा (उदाहरण के लिए 2 घंटे)

11.10 में निम्नलिखित में से सभी जो काम करते थे, किसी भी अधिक काम नहीं करते हैं:

  • Timekpr :> 11.10 ppa के माध्यम से उपलब्ध नहीं है।
  • टाइमआउट : कमांड लाइन वैकल्पिक, लेकिन 11.10 से रिपॉजिटरी से हटा दिया गया ।
  • सूक्ति नानी : एक्स-सर्वर को पुनरारंभ करने के लिए मजबूर करने के लिए बहुत अच्छा लगता है लेकिन बार-बार क्रैश होता है। इसलिए हम इस कार्यक्रम का उपयोग नहीं कर सकते हैं या इस समय इसे पुनः प्राप्त नहीं कर सकते हैं।

क्या कोई अन्य विकल्प हैं?

software-recommendation  bash  parental-controls 
— Takkat
स्रोत
हम्म ... अगर ऐसा कुछ नहीं है, तो शेल स्क्रिप्ट / क्रोन जॉब्स के साथ इसे हैक करना आसान होगा।
— नाथन उस्मान
11
EEK। मेरे माता-पिता को यह देखने नहीं दे सकते। लेकिन, मैं इसके चारों ओर मिल जाएगा क्योंकि मुझे भयानक रूट एक्सेस मिल गया है। : पी
— जेआरजी
रुचि "अभी भी विकसित हो रही है", लेकिन मुझे नहीं लगता कि यह एक नया प्रश्न है।
— रोबॉटहूमंस
के अलावा timekpr डेवलपर का वादा वह या विकास जारी रखने के लिए समय नहीं हो सकता है इस तरह का कोई आवेदन afaik है। लेकिन अपने स्वयं के अनुभव से मुझे पता है कि हम अच्छी तरह से (भले ही?) कर सकते हैं, लेकिन फिर उसे स्मार्ट बच्चों और स्मार्ट माता-पिता की जरूरत है ।
— ताकत
@ जेआरजी या सिर्फ एक लाइव यूएसबी;)
— विल्हेम इरास्मस

जवाबों:

1

लॉक स्क्रीन टाइमर

systray.gif

3rd पार्टी एप्लिकेशन के बजाय अपना स्वयं का स्क्रीन लॉक टाइमर बनाएं

हालाँकि ऐसा करने के लिए 3 पार्टी अनुप्रयोग हैं, आप अपना स्वयं का बना सकते हैं। चरणों का सारांश:

  • geditस्क्रिप्ट बनाने के लिए उपयोग करेंlock-screen-timer
  • इस विंडो से कोड को कॉपी और पेस्ट करें lock-screen-timer
  • lock-screen-timerएक निष्पादन योग्य के रूप में चिह्नित करें
  • झसे आज़माओ!
  • बैश स्क्रिप्ट निष्पादित करने के लिए Nautilus कॉन्फ़िगर करें
  • डेस्कटॉप शॉर्टकट लिंक बनाएं
  • शेष समय की निगरानी करें

geditस्क्रिप्ट बनाने के लिए उपयोग करेंlock-screen-timer

+ + Terminalका उपयोग करके खोलें :CtrlAltT

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। यदि आप Xविंडो को बंद करने के लिए क्लिक करते हैं तो यह चयन के समान है Cancel।

टाइमर के चलने के बाद और आप उस पर फिर से डबल क्लिक करते हैं, पहली बार चलने वाली कॉपी "मार दी जाती है"। अब आप एक नया स्क्रेन लॉक काउंटडाउन शुरू कर सकते हैं या Cancelबिना काउंटडाउन के क्लिक कर सकते हैं ।

प्रदर्शन समय सिस्ट्रे / अधिसूचना क्षेत्र में शेष है

जबकि लॉक स्क्रीन टाइमर यह रिकॉर्ड कर रहा है कि फ़ाइल में कितने मिनट शेष हैं ~/.lock-screen-timer-remaining। आप इस फ़ाइल को watchकमांड के साथ देख सकते हैं या इसे उबंटू के सिस्टम ट्रे / एप्लिकेशन इंडिकेटर बार पर प्रदर्शित कर सकते हैं जैसा कि इस उत्तर के शीर्ष पर दिखाया गया है। अधिसूचना क्षेत्र में शेष समय प्रदर्शित करने के लिए, इस प्रश्नोत्तर में निर्देशों का पालन करें: ( क्या BASH प्रदर्शन संकेतक के रूप में सिस्ट्रे में प्रदर्शित कर सकता है? )।

— WinEunuuchs2Unix
स्रोत
38

उबंटू <= 11.10 उपयोगकर्ता उबंटू के इस गाइड का अनुसरण करते हैं> = 11.10 नीचे पृष्ठ की सूचना पढ़ें:

हाँ, वे सभी कार्यक्रम पुराने हैं और आपके सभी प्रश्नों का उत्तर यहाँ दिया गया है और आपके माता-पिता के नियंत्रण के साथ अच्छे लग रहे हैं ....।

जब हम एक उपयोगकर्ता को लॉग ऑफ करने के लिए मजबूर करने के बारे में बात करते हैं, तो हम वास्तव में जिस चीज के बारे में बात कर रहे हैं, वह सिस्टम एक्सेस या सेवाओं के लिए खाते पर समय प्रतिबंधों को लागू कर रहा है। समय के प्रतिबंधों को लागू करने का सबसे आसान तरीका है कि मैं लिनक्स-पीएएम नामक प्लग-इन मॉड्यूल का उपयोग कर रहा हूं ।

प्लग करने योग्य प्रमाणीकरण मॉड्यूल (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 के घंटों के बीच उपयोगकर्ता की लॉबी को लॉग इन करने से प्रतिबंधित करते हैं, और वे इन घंटों के दौरान इंटरनेट का उपयोग भी प्रतिबंधित करते हैं। रूट किसी भी समय लॉगऑन करने में सक्षम होगा और साथ ही साथ हर समय इंटरनेट ब्राउज़ करेगा।

नोट: प्रणाली इन नियमों के साथ त्रुटियों को लॉग इन करती है (3)।

उबंटू लिनक्स के साथ, आपके कंप्यूटर समय प्रतिबंधों को असाइन करना संभव है, आपके सिस्टम में एक या अधिक उपयोगकर्ताओं के कनेक्शन को रोकने के लिए। समय के प्रतिबंध के साथ, आप, उदाहरण के लिए, अपने बच्चों के लिए कंप्यूटर तक पहुंच सीमित कर सकते हैं (एक प्रकार का अभिभावक नियंत्रण, संक्षेप में) , या यहां तक ​​कि कुछ घंटों के दौरान अपने सर्वर से कनेक्शन की रक्षा करें।

मैनुअल कॉन्फ़िगरेशन

समझें कि आप क्या करेंगे

इस ट्यूटोरियल के दौरान, हम PAM (प्लगगेज ऑथेंटिकेशन मॉड्यूल्स, इंग्लिश प्लगएबल ऑथेंटिकेशन मॉड्यूल्स) का उपयोग करेंगे। यह आपको कनेक्ट होने पर उपयोगकर्ता प्रमाणीकरण को नियंत्रित करने की अनुमति देता है। फिर, हम लॉगऑन घंटे की अनुमति देने के लिए सुरक्षा कॉन्फ़िगरेशन फ़ाइलों का उपयोग करेंगे। इन जोड़तोड़ों को उबंटू के किसी भी संस्करण पर किया जा सकता है, और इसके लिए केवल एक साधारण पाठ संपादक (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 संपादित करें और कोड की इस पंक्ति को जोड़ें (फ़ाइल के अंत में):

account required pam_time.so

GDM लॉगिन स्क्रीन वितरण उबंटू, एडुबंटू और जुबांटु है। कुबंटु के लिए, जो केडीई का उपयोग करता है, केडीएम सेवा को कहा जाता है, यह वह फ़ाइल होगी जो इसे खोलेगी। और आप PAM को कॉन्फ़िगर करने के लिए कर रहे हैं! यह इस सेवा पर घंटों का नियंत्रण सक्षम करेगा।

यदि आपके पास सर्वर है, तो आपके पास कोई GUI नहीं है। इस स्थिति में, जीडीएम / केडीएम स्थापित नहीं है और कनेक्शन अवरुद्ध नहीं होगा। 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|jean|emilie;scheduler

यदि आप सभी उपयोगकर्ताओं के लिए सिस्टम तक पहुँच को रोकना चाहते हैं, तो विशेष रूप से उपयोग करें! संबंधित व्यक्ति से पहले। उदाहरण के लिए, यदि मैं चाहता हूं कि निकोलस और जेवियर को छोड़कर सभी उपयोगकर्ताओं के लिए कंप्यूटर तक पहुंच से इनकार कर दिया जाए:

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 बजे से शाम 6:34 तक प्रतिबंधित करने के लिए, हम लिखते हैं: 1517-1834। मैरी को केवल मंगलवार को शाम 3:17 बजे से शाम 6:34 बजे तक कनेक्ट करने की अनुमति देने के लिए, हम परिणाम प्राप्त करते हैं:

*;*;marie;Tu1517-1834

इन घंटों के बाहर कनेक्शन पर प्रतिबंध लगा दिया जाएगा। उपयोगकर्ताओं के लिए, ऑपरेटरों का उपयोग करना संभव है तथा! कई बार संकेत करने के लिए (तब इंगित करें कि सभी लॉगऑन घंटों की अनुमति है, सिवाय उन लोगों को दिखाए जाने के)।

कोड की लाइन की शुरुआत में दो सितारे (वाइल्डकार्ड) क्रमशः, और टटी सेवा क्षेत्र हैं। चूंकि आप सिस्टम तक सभी पहुंच को अवरुद्ध करना चाहते हैं, इसलिए यह निर्दिष्ट करना अनावश्यक है कि आप किस सेवा या किस tty को ब्लॉक करना चाहते हैं। हालाँकि, यदि आप किसी विशेष सेवा के उपयोग को रोकना चाहते हैं, तो बस इसे निम्न उदाहरण के रूप में निर्दिष्ट करें:

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

इस प्रकार, उपयोगकर्ता विवाह सप्ताहांत के दौरान एक टीटीवाई, 4 और 5 से नहीं जुड़ सकता है।

प्रतिबंध के कुछ उदाहरण अनुसूची

मैथिल्ड को हर दिन दोपहर 1:20 बजे से 3:20 बजे तक और शाम 4:00 बजे से 8:30 बजे तक कनेक्ट करने की अनुमति है:

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

सप्ताह के दिनों में स्टोन, फ्रैंक और फ्लोरियन को 2:00 बजे से शाम 6:45 बजे तक और सप्ताहांत में 2:00 बजे से 10:15 बजे तक कनेक्ट करने की अनुमति है:

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

जैतून को कभी भी कनेक्ट करने की अनुमति नहीं है। जसिका बुधवार को दोपहर 1:00 बजे से शाम 4:00 बजे तक लॉग इन कर सकती है:

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

प्रत्येक उपयोगकर्ता के लिए एक सत्र की समाप्ति के लिए दो अलग-अलग समय के लिए 2 अलग-अलग लाइनें

जब एक सत्र समाप्त हो जाता है (यह समय से अधिक है जब उपयोगकर्ता पहले से जुड़ा हुआ है), पीएएम उपयोगकर्ता तक पहुंच सकता है। जबकि मैथिल्डे अनुमति के समय के दौरान जोड़ता है, यह इन घंटों से अधिक होने के लिए पूरी तरह से स्वतंत्र है! इसके लिए, हम एक नए प्रोग्राम का उपयोग करेंगे: usecron use। यह एप्लिकेशन समय के अंतराल पर कमांड निष्पादित करता है। हमारे मामले में, हम सत्र समाप्त होने पर उपयोगकर्ता को डिस्कनेक्ट करने के लिए कमांड -skill-KILL-u disc का उपयोग करेंगे। हैंडलिंग बहुत सरल है। बस फ़ाइल edit / 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 बजे से शाम 4:00 बजे तक लॉग इन कर सकती है

-> डिस्कनेक्ट: मंगलवार शाम 4:00 बजे।

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

मैथिल्ड को हर दिन दोपहर 1:20 बजे से 3:20 बजे और शाम 4:00 बजे से 8:30 बजे तक कनेक्ट करने की अनुमति है।

-> डिस्कनेक्टिंग: दैनिक, 8:30 बजे से 3:20 बजे ईटी।

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

सप्ताह के दिनों में स्टोन, फ्रैंक और फ्लोरियन को 2:00 अपराह्न से 6:45 बजे और सप्ताहांत में दोपहर 2:00 से 10:15 बजे तक जुड़ने की अनुमति है

-> डिस्कनेक्ट (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

कमांड स्किल-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 में है X स्थापित करें

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

Ubuntu 11.10 उपयोगकर्ता

मैंने पाम के साथ समस्या वाले उपयोगकर्ता के आसपास देखा है और मैंने बग के बारे में देखा है कि ऐसा क्यों है? इतना सरल उबंटू 11.10 है GDM का समर्थन नहीं करता है अब नया डिस्प्ले मैनेजर lightGDM है समस्या यह है कि इस निर्देश को स्टोर करें जहां account required pam_time.soमुझे लगता है कि यह स्टोर है /etc/pam.d/lightdmया /etc/pam.d/lightdm-autologinबग कैसे है ???

तो बस आप अपने आस-पास इस 2 लाइटगैम लॉग फाइलों की जांच कर सकते हैं:

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

या LightGdm को डिबग मोड में चलाएं:

लाइटडीएम - डिडबग

या बग की रिपोर्ट करें:

उबंटु-बग लाइटमाड

मैं रिपोर्ट बग है यहाँ तो अपनी उंगली पार और इंतजार ....

— hhlp
स्रोत
3
यह है - वाह - महान - मैं प्रभावित हूँ! Esp। अधिसूचित बिट मेरी पसंद को बहुत पसंद है क्योंकि हम नहीं चाहते हैं कि हमारे बच्चे बिना चेतावनी के लात मार दें। मेरे जैसे बुरे पिता के लिए भी यह बहुत बुरा होगा;)
— तक्षक
दुर्भाग्य से lightdm के साथ यह काम नहीं करता है ( bugs.launchpad.net/lightdm/+bug/880313 )।
— तक्षक
वाह, यह महान और लंबी व्याख्या है ..
— महमूदीन अशर
OpenSUSE 11.4 का मामला बिल्कुल उबंटू 11.10 जैसा है।
— गुप्त
11

TimeKpr

मुझे लगता है कि इसमें वह सब कुछ है जो आपको चाहिए। प्रति उपयोगकर्ता प्रति दिन पहुंच का समय, कॉन्फ़िगरेशन के लिए आसान गिनी, एक दिन के लिए बायपास करने की योग्यता, कुछ "इनाम समय", उपयोगकर्ताओं के लिए शेष समय की सूचना आदि जोड़ें।

परियोजना पृष्ठ यहाँ है । उनके पास ubuntu के लिए एक PPA भी है जिसे आप अपने सॉफ़्टवेयर स्रोतों में जोड़ सकते हैं deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main:। और सॉफ्टवेयर सेंटर के माध्यम से या सीएलआई के माध्यम से स्थापित करें sudo apt-get install timekpr:।

— दिकियो लिरा
स्रोत
क्या TimeKpr व्यक्तिगत अनुप्रयोगों (जैसे कि खेल?) के लिए समय सीमा निर्धारित कर सकता है
— एंडरसन ग्रीन
8

Timekpr

निम्न पंक्ति में जोड़कर उपयोगकर्ताओं के लिए प्रतिबंध प्रतिबंध के लिए 11.10 रनिंग लाइट डीएमडी में इस्तेमाल किया जा सकता है /etc/pam.d/lightdm

account required pam_time.so

जब तक बग # 835310 तय नहीं हो जाता, तब तक उपयोगकर्ता स्विचिंग को सक्षम करने के लिए हमें libpam-smbpass को निकालना पड़ सकता है।

सभी विंडो विंडो के रूप में परिभाषित के रूप में आवेदन खिड़की के काम में परिभाषित।

यूनिटी में टाइमकप-क्लाइंट आइकन प्रदर्शित करने के लिए हमें एकता पैनल सेटिंग्स में श्वेतसूची की आवश्यकता है 'timekpr', और इसके अलावा हमें Unityनिम्नलिखित पंक्ति में जोड़ने की आवश्यकता है /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

दिए गए समय की उलटी गिनती शुरू करने के लिए हमें समय के साथ डेमॉन शुरू करना पड़ सकता है

/etc/init.d/timekpr start

14.04 के लिए:

एक नयी रिलीज / timekpr का कांटा Ubuntu 14.04 के लिए प्रकाशित किया गया था द्वारा Eduards Bezverhijs अपने में ppa:mjasnik/ppa।

— Takkat
स्रोत
ग्रेट, लेकिन मुझे लगता है कि एक अस्थायी समाधान है ... क्योंकि आप एक ही समय में अन्य कंप्यूटरों के साथ साझा करने के लिए टाइमपक्र और सांबा का उपयोग कर रहे हैं (संभावित त्रुटि के बारे में क्लॉडड (क्लॉड-डी) ने क्या लिखा है ...
— hhlp
7

यदि आप किसी चीज के बीच में हैं तो ऑटो-लॉगऑफ बेहद निराशाजनक है। यह हिंसक है, यह क्रूर है, यह स्पष्ट असभ्य है। और इससे कोई फर्क नहीं पड़ता कि आप कितने साल के हैं। जब आप सिर्फ कंप्यूटर के आदी होते हैं तो यह एक बात है और जब आप उस ट्रैकिंग बटन को क्लिक करने या अपने दस्तावेज़ को सहेजने में कामयाब होते हैं, तो यह बहुत अलग होता है जब आप समय ट्रैक कर रहे होते हैं और 5 सेकंड के लिए बाहर हो जाते हैं। मैं आपको सुझाव देता हूं कि आप ऑटो-किकर के बजाय ऑटो-रिमाइंडर का उपयोग करने पर विचार करें। यह आपके बच्चों को एक दूसरे का सम्मान करना और एक दूसरे को स्वेच्छा से कंप्यूटर का उपयोग करने की अनुमति देगा।

यहां तक ​​कि एक हल्का विकल्प भी है। उस समय की मात्रा पर नज़र रखना शुरू करें जो प्रत्येक बच्चा कंप्यूटर का उपयोग करके खर्च करता है और उन सभी के लिए इकट्ठा किए गए डेटा को उपलब्ध कराता है ताकि वे इसे देख सकें। यह अविश्वसनीय रूप से सरल बात अकेले (खर्च किए गए इंटरनेट बैंडविड्थ पर लागू) ने मेरे जीवन को बचाया है जब मैं वयस्कों से भरे कार्यालय में नेटवर्क व्यवस्थापक बन रहा था। प्रत्येक कंप्यूटर के लिए बैंडविड्थ उपयोग के बारे में सार्वजनिक आँकड़े (बस बाइट्स की मात्रा, विज़िट की गई साइटों की सूचियों जैसी जानकारी का पता लगाना नहीं) "स्थिति - उनके खिलाफ बुरी लालची व्यवस्थापक - दुर्व्यवहार करने वाले कार्यालय उपयोगकर्ताओं" से "आदमी" आपने मुझसे 5 गुना अधिक डाउनलोड किया, यह बुरा है! " "क्षमा करें, मैंने वास्तव में डाउनलोड किया, मैंने लंच ब्रेक के दौरान बहुत सारे यूट्यूब देखे, अब इस दर पर ऐसा नहीं करेगा" - मुझे बस टकराव के परिदृश्य से बाहर रखा गया था।

— VH1
स्रोत
6

मेरा भी यह मुद्दा था। इसलिए मैंने अपहरणकर्ता स्क्रिप्ट लिखी, जो आपको उपयोग के समय और योग को परिभाषित करने की सुविधा देती है। परियोजना को निम्न स्थान पर जीथब पर पाया जा सकता है:

इसे स्थापित करने और इसका उपयोग करने का तरीका है:

  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
स्रोत
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: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

यह पैकेज इसमें उपलब्ध है:

मुसीबत :

मैं रिपोर्ट बग है यहाँ तो अपनी उंगली पार और इंतजार ....

— hhlp
स्रोत
ओह, यह अच्छी खबर है। हम यहां टाइमपास का इस्तेमाल करते थे। आशा है कि यह काम करेगा - यह अभी भी मेरे 11.10 बॉक्स पर स्थापित है, अच्छा चलता है लेकिन मेरे बच्चे के खातों को लॉक नहीं करता है।
— तक्षक
और 14.04 के लिए यह काम करता है?
— रोजरपैक
3

परिचय

यदि उपयोगकर्ता कमांड द्वारा लॉग इन है, तो हम जाँच कर सकते हैं:

who -u

जो हमें एक आउटपुट देता है जैसे:

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

आउटपुट में हमें लक्षित उपयोगकर्ता की पिड मिलती है, जिसे समय सीमा से अधिक होने पर रोकने की आवश्यकता होती है।

समाधान

मान लें कि आपके उपयोगकर्ता के पास 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 kill "$(pgrep limit_use)"

लेकिन ऐसा करने के लिए आपको sudo पासवर्ड की आवश्यकता होगी।

— जैकब व्लिजम
स्रोत
2

मैंने कोशिश की timekprलेकिन काम नहीं मिला। फिर इसका एक वेरिएंट बनाया जो मेरे उबंटू पर काम करता है। इस वैरिएंट के लिए यह करना आवश्यक है:

  1. /var/lib/timelimit/user_to_be_limited.limitकेवल रूट अधिकारों के साथ फाइल में समय सीमा जोड़ें । जैसे 1800 सेकंड (30 मिनट) दैनिक सीमा के लिए 1800।

  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 को पुनरारंभ करें

— कसाबा
स्रोत
2

मैंने बस एक उत्तर आसानी से उपलब्ध कराया। कोड थ्रेड पर समझाया गया है http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 । संक्षेप में: प्रति दिन मिनटों में कॉन्फ़िगर की गई सीमा, हर मिनट एक क्रॉन जॉब, उपयोगकर्ता को उसे सूचित रखने के लिए एक संदेश और एक मजबूर लॉगऑफ़।

इसे डाउनलोड और इंस्टॉल करने के लिए, एक टर्मिनल खोलें और नीचे दिए गए कमांड चलाएं:

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

इंस्टॉलेशन प्रक्रिया के दौरान प्रशासक पासवर्ड का अनुरोध किया जाएगा (स्क्रिप्ट को कॉपी करने के लिए, क्रोन जॉब स्थापित करने के लिए ...)। वहां से आप सभी के लिए मार्गदर्शन किया जाएगा। केवल मामले में एक ही स्थान पर एक ./uninstall.sh भी है। यह सभी उबंटू आधारित डिस्ट्रो (मिंट, आदि ... शायद सभी डेबियन भी) के साथ काम करने के लिए बनाया गया है। यदि कोई समस्या होती है तो कृपया मुझे बताएं, जिसमें सिस्टम संस्करण और टिप्पणियों में चित्रमय वातावरण शामिल हैं:

uname -a
echo $XDG_CURRENT_DESKTOP

थॉमस बेकरूट

— थॉमस बेकरूट
स्रोत
1

मैंने अभी-अभी अपने नए एप्लिकेशन का बीटा संस्करण जारी किया है जो LittleBrotherलिनक्स मशीनों पर खेलने के समय की निगरानी करने में सक्षम है। डेबियन पैकेज को आज़माने के लिए टेस्ट उपयोगकर्ताओं का स्वागत है। इसे डाउनलोड करने और इसका उपयोग करने के निर्देश यहां दिए जा सकते हैं: https://github.com/marcus67/little_brother । स्थापना अभी भी थोड़ा मोटा हो सकता है, हालांकि। ये हैं आवेदन की विशेषताएं:

  • किसी भी उपयोगकर्ता की निगरानी की जा सकती है।
  • प्रत्येक उपयोगकर्ता के पास अनुमत प्लेटाइम को परिभाषित करने वाले नियमों का एक विशिष्ट सेट हो सकता है।
  • नियमों को "संदर्भों" के लिए अनुकूलित किया जा सकता है, जैसे कि सप्ताह का दिन और / या एक छुट्टी अनुसूची (वर्तमान में केवल जर्मन कार्यक्रम समर्थित हैं)।
  • प्ले टाइम को टाइम विंडो (से, तक) तक सीमित रखा जा सकता है।
  • प्रति दिन अधिकतम खेलने का समय परिभाषित किया जा सकता है।
  • उपयोगकर्ताओं को एक निश्चित अधिकतम सत्र समय के बाद ब्रेक लेने के लिए मजबूर किया जा सकता है।
  • उपयोगकर्ताओं को अपनी गतिविधि के बाद मिनीमम ब्रेक के समय का इंतजार करने के लिए मजबूर किया जा सकता है।
  • लिनक्स क्लाइंट होस्ट की किसी भी संख्या की निगरानी की जा सकती है (वर्तमान में इसके लिए उपयोगकर्ताओं को सभी मशीनों पर समान लॉगिन की आवश्यकता होती है)।
  • सभी उपयोगकर्ताओं की गतिविधियों के इतिहास के साथ एक मास्टर होस्ट है। यह मास्टर होस्ट नियम सेट की जाँच करता है और आवश्यकता होने पर प्रक्रियाओं को समाप्त करने के लिए क्लाइंट होस्ट को संकेत देता है।
  • मास्टर होस्ट एक कॉन्फ़िगर इतिहास की लंबाई (जैसे 7 दिन) पर उपयोगकर्ता गतिविधि को देखने के लिए एक सरल वेब इंटरफ़ेस प्रदान करता है और भविष्य में एक कॉन्फ़िगर संख्या के लिए नियम अपवादों को गतिशील रूप से परिभाषित करने के लिए एक प्रशासन पृष्ठ।
  • वेब एप्लिकेशन को एक प्रॉक्सी के पीछे चलाया जा सकता है, ताकि युवा उपयोगकर्ताओं द्वारा कॉल प्ले टाइम के लिए भीख मांगने के बाद दूरस्थ प्रशासन की अनुमति देना दूर से सुलभ हो सके।
  • आवेदन में अंतरराष्ट्रीय भाषा का समर्थन है। वर्तमान में अंग्रेजी और जर्मन अनुवाद प्रदान किए जाते हैं। उपयोगकर्ताओं को अन्य भाषाओं के लिए अनुवाद प्रदान करने के लिए आमंत्रित किया जाता है।
  • अनुप्रयोग उपयोगकर्ता को जबरन लॉगआउट करने से रोकने के लिए वॉइस जेनरेशन का उपयोग करता है। साथ ही इन बोले गए संदेशों का अंतर्राष्ट्रीयकरण किया जाता है।
  • लिनक्स होस्ट पर बिताए गए समय के अलावा एप्लिकेशन स्मार्ट फोन या टेबल जैसे अन्य उपकरणों पर गतिविधि समय की निगरानी भी कर सकता है। यह इस तथ्य का लाभ उठाता है कि अधिकांश आधुनिक ऑपरेटिंग सिस्टम कुछ प्रकार के बिजली बचत मोड में डिवाइस डालते हैं, जबकि उनका उपयोग नहीं किया जा रहा है। इस तरह, नेटवर्क प्रतिक्रिया (पिंगिंग द्वारा) का उपयोग उन उपकरणों पर गतिविधि को निर्धारित करने के लिए किया जा सकता है। लिनक्स होस्ट के विपरीत, एप्लिकेशन गतिविधि को समाप्त नहीं कर पाएगा। हालाँकि, प्ले टाइम को ओवरऑल प्लेटाइम में जोड़ दिया जाएगा और इसलिए अनुमति दी गई समय पर प्रभाव पड़ेगा और लिनक्स होस्ट पर ब्रेक टाइम नियमों पर भी।

कुछ स्क्रीनशॉट:

स्थिति पृष्ठ प्रशासन पृष्ठ

— माक्र्स रिकर्ट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.