Viewing file:  mainWindow.py (35.4 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
## mainWindow.py - main interface window for redhat-config-users
## Copyright (C) 2001-2003 Red Hat, Inc.
## Copyright (C) 2001-2003 Brent Fox <bfox@redhat.com>
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
## Author: Brent Fox
import signal
import gtk
import gobject
import gtk.glade
import string
import sys
import time
import os
import rpm
import libuser
import preferences
import groupWindow
import userWindow
import userProperties
import groupProperties
import messageDialog
import prefWindow
##
## I18N
##
from rhpl.translate import _, N_
import rhpl.translate as translate
import rhpl.executil
domain = "system-config-users"
translate.textdomain (domain)
gtk.glade.bindtextdomain(domain)
def service_pending_events():
while gtk.events_pending():
if gtk.__dict__.has_key ("main_iteration"):
gtk.main_iteration()
else:
gtk.mainiteration()
def admin_prompt_callback(prompts, title):
dialog = gtk.Dialog()
dialog.set_title(title)
dialog.set_position(gtk.WIN_POS_CENTER)
dialog.set_icon(iconPixbuf)
dialog.add_button(gtk.STOCK_OK, 1)
dialog.add_button(gtk.STOCK_CANCEL, 0)
table = gtk.Table(rows = len(prompts), columns = 2)
dialog.vbox.pack_start(table)
table.set_row_spacings(4)
table.set_col_spacings(4)
ret_list = []
for i in range(len(prompts)):
prompt = prompts[i]
label = gtk.Label(prompt.prompt)
label.set_alignment(1.0, 0.5)
table.attach(label, 0, 1, i, i + 1)
entry = gtk.Entry()
entry.set_visibility(prompt.visible)
if prompt.default_value:
entry.set_text(prompt.default_value)
table.attach(entry, 1, 2, i, i + 1)
ret_list.append((prompt, entry))
table.show_all()
i = dialog.run()
if i == 1:
for (prompt, entry) in ret_list:
prompt.value = entry.get_text()
dialog.destroy()
return True
sys.exit(1)
gtk.glade.bindtextdomain(domain)
if os.access("system-config-users.glade", os.F_OK):
xml = gtk.glade.XML ("./system-config-users.glade", domain=domain)
else:
xml = gtk.glade.XML ("/usr/share/system-config-users/system-config-users.glade", domain=domain)
busy_cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
ready_cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR)
##
## Icon for windows
##
iconPixbuf = None
try:
iconPixbuf = gtk.gdk.pixbuf_new_from_file("/usr/share/system-config-users/system-config-users.png")
except:
pass
class mainWindow:
def version():
# substituted to the real version by the Makefile at installation time.
return "1.2.51"
def destroy (self, *args):
try:
self.preferences.save ()
except IOError:
print _("Error saving settings to %s") % preferences.filename
if gtk.__dict__.has_key ("main_quit"):
gtk.main_quit()
else:
gtk.mainquit()
def __init__(self):
self.preferences = preferences.Preferences ()
self.preferences.load ()
self.prefWindow = prefWindow.PrefWindow (xml, iconPixbuf)
nameTag = _("Users and Groups")
commentTag = _("Add or remove users and groups")
self.toplevel = xml.get_widget ('mainWindow')
self.toplevel.resize(775, 550)
self.toplevel.set_icon(iconPixbuf)
self.add_user_button = xml.get_widget("add_user_button")
self.add_group_button = xml.get_widget("add_group_button")
self.properties_button = xml.get_widget("properties_button")
self.properties_menu = xml.get_widget("properties_menu")
self.delete_button = xml.get_widget("delete_button")
self.delete_menu = xml.get_widget("delete_menu")
self.toplevel.connect("destroy", self.destroy)
self.ADMIN = libuser.admin(prompt=admin_prompt_callback, prompt_data=(_('Logon Information Required'),))
self.userStore = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.userStore.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.userTreeView = xml.get_widget('user_view')
self.userTreeView.set_rules_hint(True)
self.userTreeView.set_model(self.userStore)
self.userTreeView.get_selection().connect("changed", self.itemSelected)
self.userTreeView.connect("row_activated", self.rowActivated)
col = gtk.TreeViewColumn(_("User Name"), gtk.CellRendererText(), text=0)
col.set_sort_column_id(0)
col.set_resizable(True)
self.userTreeView.append_column(col)
col = gtk.TreeViewColumn(_("User ID"), gtk.CellRendererText(), text=1)
col.set_sort_column_id(1)
col.set_resizable(True)
self.userTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Primary Group"), gtk.CellRendererText(), text=2)
col.set_sort_column_id(2)
col.set_resizable(True)
self.userTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Full Name"), gtk.CellRendererText(), text=3)
col.set_sort_column_id(3)
col.set_resizable(True)
self.userTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Login Shell"), gtk.CellRendererText(), text=4)
col.set_sort_column_id(4)
col.set_resizable(True)
self.userTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Home Directory"), gtk.CellRendererText(), text=5)
col.set_sort_column_id(5)
col.set_resizable(True)
self.userTreeView.append_column(col)
self.userTreeView.set_property("headers-visible", True)
self.groupStore = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.groupStore.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.groupTreeView = xml.get_widget('group_view')
self.groupTreeView.set_rules_hint(True)
self.groupTreeView.set_model(self.groupStore)
self.groupTreeView.get_selection().connect("changed", self.itemSelected)
self.groupTreeView.connect("row_activated", self.rowActivated)
col = gtk.TreeViewColumn(_("Group Name"), gtk.CellRendererText(), text=0)
col.set_sort_column_id(0)
col.set_resizable(True)
self.groupTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Group ID"), gtk.CellRendererText(), text=1)
col.set_sort_column_id(1)
col.set_resizable(True)
self.groupTreeView.append_column(col)
col = gtk.TreeViewColumn(_("Group Members"), gtk.CellRendererText(), text=2)
col.set_resizable(True)
self.groupTreeView.append_column(col)
self.notebook = xml.get_widget('notebook1')
self.notebook.connect('switch-page', self.changeNotebookPage)
self.filter = xml.get_widget('filterEntry')
self.filterSystemUsersGroupsCheckButton = xml.get_widget ('filterSystemUsersGroupsCheckButton')
self.filterSystemUsersGroupsCheckButton.set_active (self.preferences['FILTER'])
self.assignHighestUidCheckButton = xml.get_widget ('assignHighestUidCheckButton')
self.assignHighestUidCheckButton.set_active (self.preferences['ASSIGN_HIGHEST_UID'])
self.assignHighestGidCheckButton = xml.get_widget ('assignHighestGidCheckButton')
self.assignHighestGidCheckButton.set_active (self.preferences['ASSIGN_HIGHEST_GID'])
self.preferSameUIDGIDCheckButton = xml.get_widget ('preferSameUIDGIDCheckButton')
self.preferSameUIDGIDCheckButton.set_active (self.preferences['PREFER_SAME_UID_GID'])
self.user_dict = {}
self.group_dict = {}
self.gid_dict = {}
self.member_dict = {}
self.service_interval = 10
selinuxEnabled = self.isSELinuxEnabled()
self.userWin = userWindow.userWindow(self, self.userStore, self.groupTreeView, xml, selinuxEnabled)
self.groupWin = groupWindow.groupWindow(self, self.userTreeView, self.groupTreeView, xml)
self.userProperties = userProperties.userProperties(self, self.userTreeView, self.groupTreeView, xml, selinuxEnabled)
self.groupProperties = groupProperties.groupProperties(self, self.userTreeView, self.groupTreeView, xml)
self.userSelectedRow = None
self.groupSelectedRow = None
self.toplevel.show_all ()
xml.signal_connect("on_about_activate", self.on_about_button_clicked)
xml.signal_connect("on_manual_activate", self.on_manual_button_clicked)
xml.signal_connect("on_add_user_activate", self.on_add_user_activate)
xml.signal_connect("on_add_user_button_clicked", self.on_add_user_activate)
xml.signal_connect("on_add_group_activate", self.on_add_group_activate)
xml.signal_connect("on_add_group_button_clicked", self.on_add_group_activate)
xml.signal_connect("on_properties_activate", self.on_properties_activate)
xml.signal_connect("on_properties_button_clicked", self.on_properties_activate)
xml.signal_connect("on_preferences_activate", self.on_preferences_activate)
xml.signal_connect("on_delete_activate", self.on_delete_activate)
xml.signal_connect("on_delete_button_clicked", self.on_delete_activate)
xml.signal_connect("on_help_button_clicked", self.on_help_button_clicked)
xml.signal_connect("on_new_user_activate", self.on_add_user_activate)
xml.signal_connect("on_filterButton_clicked", self.refresh)
xml.signal_connect("on_filterEntry_activate", self.refresh)
xml.signal_connect("on_refreshButton_clicked", self.refresh)
xml.signal_connect("on_exit_activate", self.on_exit_activate)
xml.signal_connect("on_filterSystemUsersGroupsCheckButton_toggled", self.on_filterSystemUsersGroupsCheckButton_toggled)
xml.signal_connect("on_assignHighestUidCheckButton_toggled", self.on_assignHighestUidCheckButton_toggled)
xml.signal_connect("on_assignHighestGidCheckButton_toggled", self.on_assignHighestGidCheckButton_toggled)
xml.signal_connect("on_preferSameUIDGIDCheckButton_toggled", self.on_preferSameUIDGIDCheckButton_toggled)
self.refresh()
self.ready()
if gtk.__dict__.has_key ("main"):
gtk.main ()
else:
gtk.mainloop ()
def on_exit_activate(self, args):
self.destroy()
def busy(self):
self.toplevel.set_sensitive(False)
self.toplevel.window.set_cursor(busy_cursor)
pass
def ready(self):
self.toplevel.window.set_cursor(ready_cursor)
self.toplevel.set_sensitive(True)
pass
def get_user_list (self, filter):
if filter == "":
users = self.ADMIN.enumerateUsersFull()
else:
users = self.ADMIN.enumerateUsersFull(filter)
users.sort()
return users
def get_group_list(self, filter):
if filter == "":
groups = self.ADMIN.enumerateGroupsFull()
else:
groups = self.ADMIN.enumerateGroupsFull(filter)
groups.sort()
return groups
def refresh_users(self):
self.user_dict = {}
self.gid_dict = {}
# pull up information about users and store the objects in
# a dictionary keyed by user name
i = 0
for user in self.get_user_list(self.get_filter_data()):
i = i + 1
if i >= self.service_interval:
service_pending_events()
i = 0
userName = user.get(libuser.USERNAME)[0]
self.user_dict[userName] = user
# try to get a name to associate with the user's primary gid,
# and attempt to minimize lookups by caching answers
try:
gidNumber = user.get(libuser.GIDNUMBER)[0]
except Exception, e:
messageDialog.show_message_dialog (_("The user database cannot be read. This problem is most likely caused by a mismatch between /etc/passwd and /etc/shadow or /etc/group and /etc/gshadow. The program will exit now."))
os._exit(0)
try:
group = self.gid_dict[long (gidNumber)]
except:
try:
group = self.ADMIN.lookupGroupById(long (gidNumber))
self.gid_dict[long (gidNumber)] = group
except:
pass
def refresh_groups(self):
self.group_dict = {}
self.member_dict = {}
i = 0
for group in self.get_group_list(self.get_filter_data()):
i = i + 1
if i >= self.service_interval:
service_pending_events()
i = 0
groupName = group.get(libuser.GROUPNAME)[0]
# /etc/group <-> /etc/gshadow inconsistency canary
try:
gidNumber = group.get (libuser.GIDNUMBER)[0]
except Exception, e:
messageDialog.show_message_dialog (_("The user database cannot be read. This problem is most likely caused by a mismatch between /etc/passwd and /etc/shadow or /etc/group and /etc/gshadow. The program will exit now."))
os._exit(0)
self.group_dict[groupName] = group
members = self.ADMIN.enumerateUsersByGroup(groupName)
if not members:
members = []
members.sort()
self.member_dict[groupName] = members
def refresh_users_and_groups(self, names):
self.busy()
updated_names = {}
for name in names:
# If we've already updated this user/group, skip it.
if updated_names.has_key(name):
continue
updated_names[name] = name
service_pending_events()
userEnt = self.ADMIN.lookupUserByName(name)
if userEnt:
self.user_dict[name] = userEnt
gidNumber = userEnt.get(libuser.GIDNUMBER)[0]
try:
groupEnt = self.gid_dict[long (gidNumber)]
except:
try:
groupEnt = self.ADMIN.lookupGroupById(long (gidNumber))
self.gid_dict[long (gidNumber)] = groupEnt
except:
pass
else:
try:
del(self.user_dict[name])
except:
pass
groupEnt = self.ADMIN.lookupGroupByName(name)
if groupEnt:
self.group_dict[name] = groupEnt
self.member_dict[name] = self.ADMIN.enumerateUsersByGroup(name)
gidNumber = groupEnt.get(libuser.GIDNUMBER)
gidNumber = gidNumber[0]
self.gid_dict[long (gidNumber)] = groupEnt
else:
try:
del(self.group_dict[name])
del(self.member_dict[name])
except:
pass
users = self.get_user_list(self.get_filter_data())
for user in self.user_dict.keys():
if user not in users:
del self.user_dict[user]
groups = self.get_group_list(self.get_filter_data())
for group in self.group_dict.keys():
if group not in groups:
del self.group_dict[group]
self.refresh()
self.ready()
def refresh(self, *args):
self.busy()
self.refresh_users()
self.refresh_groups()
self.populate_lists()
self.toggleWidgets(False)
self.ready()
def populate_user_list(self):
self.userStore.clear()
for user in self.user_dict.keys():
userEnt = self.user_dict[user]
uid = userEnt.get(libuser.USERNAME)[0]
uidNumber = userEnt.get(libuser.UIDNUMBER)[0]
gidNumber = userEnt.get(libuser.GIDNUMBER)[0]
if userEnt.get(libuser.GECOS):
gecos = userEnt.get(libuser.GECOS)[0]
else:
gecos = uid
if userEnt.get(libuser.HOMEDIRECTORY):
homeDir = userEnt.get(libuser.HOMEDIRECTORY)[0]
else:
homeDir = ''
if userEnt.get(libuser.LOGINSHELL):
shell = userEnt.get(libuser.LOGINSHELL)[0]
else:
shell = ''
try:
groupEnt = self.gid_dict[long (gidNumber)]
groupName = groupEnt.get(libuser.GROUPNAME)[0]
except:
groupName = gidNumber
#Convert the user fullName into unicode so pygtk2 doesn't truncate strings
gecos = unicode (gecos, 'utf-8')
if self.preferences['FILTER'] == True:
#display users with UIDs > 499
if long (uidNumber) > 499L and not (uid == "nfsnobody" and (long (uidNumber) == 65534L or long (uidNumber) == 4294967294L)):
iter = self.userStore.append()
self.userStore.set_value(iter, 0, uid)
self.userStore.set_value(iter, 1, uidNumber)
self.userStore.set_value(iter, 2, groupName)
self.userStore.set_value(iter, 3, gecos)
self.userStore.set_value(iter, 4, shell)
self.userStore.set_value(iter, 5, homeDir)
self.userStore.set_value(iter, 6, userEnt)
else:
#display users with UIDs > 499
if long (uidNumber) > -1L:
iter = self.userStore.append()
self.userStore.set_value(iter, 0, uid)
self.userStore.set_value(iter, 1, uidNumber)
self.userStore.set_value(iter, 2, groupName)
self.userStore.set_value(iter, 3, gecos)
self.userStore.set_value(iter, 4, shell)
self.userStore.set_value(iter, 5, homeDir)
self.userStore.set_value(iter, 6, userEnt)
def populate_group_list(self):
self.groupStore.clear()
members = []
for group in self.group_dict.keys():
groupEnt = self.group_dict[group]
if groupEnt.get(libuser.GIDNUMBER) != []:
cn = groupEnt.get(libuser.GROUPNAME)[0]
gid = groupEnt.get(libuser.GIDNUMBER)[0]
members = self.member_dict[group]
if not members:
members = []
#concatenate the list of members in the group into a comma separated list
memberlist = string.join(members, ", ")
if self.preferences['FILTER'] == True:
#display groups with UIDs > 499
if long (gid) > 499 and not (cn == "nfsnobody" and (long (gid) == 65534L or long (gid) == 4294967294L)):
iter = self.groupStore.append()
self.groupStore.set_value(iter, 0, cn)
self.groupStore.set_value(iter, 1, gid)
self.groupStore.set_value(iter, 2, memberlist)
self.groupStore.set_value(iter, 3, groupEnt)
else:
#display groups with UIDs > 499
if long (gid) > -1:
iter = self.groupStore.append()
self.groupStore.set_value(iter, 0, cn)
self.groupStore.set_value(iter, 1, gid)
self.groupStore.set_value(iter, 2, memberlist)
self.groupStore.set_value(iter, 3, groupEnt)
def populate_lists(self):
self.populate_user_list()
self.populate_group_list()
pass
#------------Event handlers-------------#
#---------------------------------------#
#--------Event handlers for toplevel window-----#
def on_about_button_clicked(self, *args):
dlg = xml.get_widget ("aboutWindow")
version = xml.get_widget ("aboutWindowVersion")
version.set_text (_("Version %s") % ("1.2.51"))
copyright = xml.get_widget ("aboutWindowCopyright")
copyright_by = [ [ "2001 - 2006", "Red Hat, Inc." ],
[ "2001 - 2004", "Brent Fox", "bfox@redhat.com" ],
[ "2004 - 2006", "Nils Philippsen", "nphilipp@redhat.com" ] ]
cb_strings = []
for cb in copyright_by:
years = cb[0]
holder = cb[1]
try:
email = cb[2]
cb_strings.append (_("Copyright (c) %s %s <%s>") % (years, holder, email))
except IndexError:
cb_strings.append (_("Copyright (c) %s %s") % (years, holder))
copyright.set_text ('\n'.join (cb_strings))
dlg.run ()
dlg.hide ()
def on_help_button_clicked(self, *args):
help_pages = ["file:///usr/share/doc/system-config-users-1.2.51/user-new.html",
"file:///usr/share/doc/system-config-users-1.2.51/group-new.html",]
page = help_pages [self.notebook.get_current_page ()]
path = "/usr/bin/htmlview"
if path == None:
messageDialog.show_message_dialog(_("Help is not available."))
return
pid = os.fork()
if not pid:
os.execv(path, [path, page])
def on_manual_button_clicked(self, *args):
page = "file:///usr/share/doc/system-config-users-1.2.51/index.html"
path = "/usr/bin/htmlview"
if path == None:
messageDialog.show_message_dialog(_("Help is not available."))
return
pid = os.fork()
if not pid:
os.execv(path, [path, page])
def on_exit1_activate(self, *args):
if gtk.__dict__.has_key ("main_quit"):
gtk.main_quit()
else:
gtk.mainquit()
def on_add_user_activate(self, *args):
filter = self.get_filter_data()
self.userWin.newUserWin(filter)
self.userWin.userWin.set_transient_for(self.toplevel)
def on_add_group_activate(self, *args):
self.groupWin.newGroupWin()
self.groupWin.groupWin.set_transient_for(self.toplevel)
def on_delete_activate(self, *args):
page = self.notebook.get_current_page()
if page == 0:
if self.userTreeView.get_selection().get_selected():
data, iter = self.userTreeView.get_selection().get_selected()
userEnt = self.userStore.get_value(iter, 6)
user = userEnt.get(libuser.USERNAME)[0]
uid = userEnt.get(libuser.UIDNUMBER)[0]
homeDir = userEnt.get(libuser.HOMEDIRECTORY)[0]
mailSpool = "/var/spool/mail/%s" % (user)
errMsgs = []
if uid == 0:
dlg = gtk.MessageDialog (None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, _("Deleting the root user is not allowed."))
dlg.set_position(gtk.WIN_POS_CENTER)
dlg.set_modal (True)
dlg.set_icon (iconPixbuf)
dlg.run ()
dlg.destroy ()
return
ts = rpm.TransactionSet ()
if ts.dbMatch ("basenames", homeDir).count () > 0 or ts.dbMatch ("basenames", os.path.abspath (homeDir)).count () > 0 or ts.dbMatch ("basenames", os.path.realpath (homeDir)).count () > 0:
errMsgs.append (_("- An installed software package contains this directory."))
if uid < 500 or (user == "nfsnobody" and (long (uid) == 65534L or long (uid) == 4294967294L)):
errMsgs.append (_("- A system user owns this directory and removing it may impair the system's integrity."))
if not os.access(homeDir, os.W_OK):
errMsgs.append (_("- This directory doesn't exist or isn't writable."))
elif os.lstat (homeDir).st_uid != uid:
errMsgs.append (_("- The user '%s' doesn't own this directory.") % (user))
pipe = os.popen ("/usr/bin/pgrep -fl -U %d; /usr/bin/pgrep -u %d" % (uid, uid))
processes = pipe.readlines ()
pipe.close ()
processes_running_text = ""
if len (processes) > 0:
processes_running_text = _("<b>There are currently processes running that are owned by '%s'!</b> This user is probably still logged in. ") % (user)
text = _("Do you really want to remove the user '%s'?") % (user)
dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, (processes_running_text + text))
dlg.set_position(gtk.WIN_POS_CENTER)
dlg.set_modal(True)
dlg.set_icon(iconPixbuf)
dlg.label.set_use_markup (True)
filesDeleteCheckButton = None
if len (errMsgs) == 0:
filesDeleteText = _("Delete %s's home directory ('%s') and temporary files.") % (user, homeDir)
if os.access (mailSpool, os.W_OK) and os.lstat (mailSpool).st_uid == uid:
filesDeleteText = _("Delete %s's home directory ('%s'), mail spool ('%s') and temporary files.") % (user, homeDir, mailSpool)
filesDeleteCheckButton = gtk.CheckButton (filesDeleteText)
filesDeleteCheckButton.set_active(True)
filesDeleteCheckButton.set_border_width(5)
filesDeleteCheckButton.get_child().set_line_wrap (True)
dlg.vbox.pack_start(filesDeleteCheckButton)
else:
if len(errMsgs) == 1:
l_txt = _("I won't delete %s's home directory ('%s') due to this reason:\n%s")
else:
l_txt = _("I won't delete %s's home directory ('%s') due to these reasons:\n%s")
errLabel = gtk.Label (l_txt % (user, homeDir, string.join (errMsgs, "\n")))
errLabel.set_line_wrap (True)
dlg.vbox.pack_start (errLabel)
dlg.show_all()
rc = dlg.run()
if rc == gtk.RESPONSE_NO:
#bail out
dlg.destroy()
return
else:
#Ok, we're going to delete the user
if filesDeleteCheckButton and filesDeleteCheckButton.get_active() == 1:
#Let's delete the home directory too
self.rmrf(homeDir)
if os.access (mailSpool, os.W_OK) and os.lstat (mailSpool).st_uid == uid:
self.rmrf(mailSpool)
self.rmtmpfiles (("/tmp", "/var/tmp"), uid)
self.ADMIN.deleteUser(userEnt)
dlg.destroy()
try:
del self.user_dict[user]
except:
pass
need_refresh = [user]
for group in self.group_dict.keys():
groupEnt = self.group_dict[group]
members = groupEnt.get(libuser.MEMBERNAME)
if members:
if user in members:
members.remove(user)
groupEnt.set(libuser.MEMBERNAME, members)
self.ADMIN.modifyGroup(groupEnt)
self.userSelectedRow = None
#Let's check out the user's primary group
groupEnt = self.ADMIN.lookupGroupById(userEnt.get(libuser.GIDNUMBER)[0])
if groupEnt != None and len(groupEnt.get(libuser.MEMBERNAME)) == 0:
#Get the user's primary group. If there's no one besides that user in the group,
#delete it.
if groupEnt.get(libuser.GIDNUMBER)[0] > 500:
#Only delete the group if it is a non-system group
self.ADMIN.deleteGroup(groupEnt)
try:
del self.group_dict[groupName]
except:
pass
self.refresh_users_and_groups(need_refresh)
elif page == 1:
if self.groupTreeView.get_selection().get_selected():
data, iter = self.groupTreeView.get_selection().get_selected()
groupEnt = self.groupStore.get_value(iter, 3)
groupName = groupEnt.get(libuser.GROUPNAME)[0]
#Let's check and see if we are deleting a user's primary group. We don't want that to happen
members = self.ADMIN.enumerateUsersByGroup(groupName)
for userName in members:
userEnt = self.ADMIN.lookupUserByName(userName)
if userEnt.get(libuser.GIDNUMBER)[0] == groupEnt.get(libuser.GIDNUMBER)[0]:
messageDialog.show_message_dialog(_("You cannot remove user '%s' from their primary "
"group.") % userName)
return
rc = messageDialog.show_confirm_dialog(_("Are you sure you want to delete the group '%s'?")
% groupName)
if rc == gtk.RESPONSE_NO:
return
self.ADMIN.deleteGroup(groupEnt)
try:
del self.group_dict[groupName]
except:
pass
self.refresh_users_and_groups(groupName)
def on_properties_activate(self, *args):
page = self.notebook.get_current_page()
if page == 0:
self.user_properties()
elif page == 1:
self.group_properties()
def on_preferences_activate (self, *args):
self.prefWindow.show ()
def user_properties(self):
if self.userTreeView.get_selection().get_selected():
data, iter = self.userTreeView.get_selection().get_selected()
userEnt = self.userStore.get_value(iter, 6)
self.userProperties.showUserProperties(userEnt)
self.userProperties.userWin.set_transient_for(self.toplevel)
def group_properties(self):
if self.groupTreeView.get_selection().get_selected():
data, iter = self.groupTreeView.get_selection().get_selected()
groupEnt = self.groupStore.get_value(iter, 3)
self.groupProperties.showGroupProperties(groupEnt)
self.groupProperties.groupWin.set_transient_for(self.toplevel)
def itemSelected(self, *args):
# When an item is selected, sensitize the properties and the delete buttons.
# When an item is unselected, desensitize the properties and delete buttons.
page = self.notebook.get_current_page()
if page == 0:
object, data = self.userTreeView.get_selection().get_selected()
elif page == 1:
object, data = self.groupTreeView.get_selection().get_selected()
if data == None:
self.toggleWidgets(False)
else:
self.toggleWidgets(True)
def changeNotebookPage(self, *args):
# When the user changes a notebook page, unselect all the choices on both the user and group lists
# This keeps the program from getting confused on which widget is currently selected
page = self.notebook.get_current_page()
if page == 0:
self.groupTreeView.get_selection().unselect_all()
elif page == 1:
self.userTreeView.get_selection().unselect_all()
self.toggleWidgets(False)
def toggleWidgets(self, value):
self.properties_button.set_sensitive(value)
self.properties_menu.set_sensitive(value)
self.delete_button.set_sensitive(value)
self.delete_menu.set_sensitive(value)
def get_filter_data(self):
filter = self.filter.get_text()
filter = string.strip(filter)
if len(filter) == 0:
filter = ''
else:
index = string.find(filter, '*')
length = len(filter) - 1
if index != length:
filter = filter + "*"
return filter
def on_filterSystemUsersGroupsCheckButton_toggled (self, *args):
if self.filterSystemUsersGroupsCheckButton.get_active () == True:
self.preferences['FILTER'] = True
else:
self.preferences['FILTER'] = False
self.populate_lists()
def on_assignHighestUidCheckButton_toggled (self, *args):
if self.assignHighestUidCheckButton.get_active () == True:
self.preferences['ASSIGN_HIGHEST_UID'] = True
else:
self.preferences['ASSIGN_HIGHEST_UID'] = False
def on_assignHighestGidCheckButton_toggled (self, *args):
if self.assignHighestGidCheckButton.get_active () == True:
self.preferences['ASSIGN_HIGHEST_GID'] = True
else:
self.preferences['ASSIGN_HIGHEST_GID'] = False
def on_preferSameUIDGIDCheckButton_toggled (self, *args):
if self.preferSameUIDGIDCheckButton.get_active () == True:
self.preferences['PREFER_SAME_UID_GID'] = True
else:
self.preferences['PREFER_SAME_UID_GID'] = False
def rmrf(self, path):
if path != "/dev/null": #Don't allow /dev/null to be deleted
# just use rm to avoid having to worry about races
args = [ "/bin/rm", "-rf", "%s" %(path,) ]
rhpl.executil.execWithRedirect(args[0], args)
def do_rm_userowned (self, path, uid):
if os.path.isdir (path) and not os.path.islink (path):
for file in os.listdir (path):
self.do_rm_userowned (path + os.sep + file, uid)
if os.lstat (path).st_uid == uid:
try:
os.rmdir (path)
except OSError:
pass
else:
if os.lstat (path).st_uid == uid:
try:
os.unlink (path)
except OSError:
pass
def rmtmpfiles (self, tmppaths, uid):
for path in tmppaths:
self.do_rm_userowned (path, uid)
def rowActivated(self, *args):
self.on_properties_activate()
def isSELinuxInstalled(self):
ts = rpm.TransactionSet()
mi = ts.dbMatch('name', 'policy-sources')
if mi.count() > 0:
return 1
return 0
def isSELinuxEnabled(self):
if self.isSELinuxInstalled():
if os.system("/usr/bin/selinuxenabled") > 0:
#it's enabled, return 1
return 1
else:
#it's installed, but not enabled
return 0
else:
#not installed
return 0
|