You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3304 lines
136 KiB
3304 lines
136 KiB
#!/usr/bin/python
|
|
# -*- coding: UTF-8 -*-
|
|
###########################################################################
|
|
# mountconfig.py - description #
|
|
# ------------------------------ #
|
|
# begin : Fri Nov 30 2003 #
|
|
# copyright : (C) 2003 by Simon Edwards #
|
|
# email : simon@simonzone.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. #
|
|
# #
|
|
###########################################################################
|
|
|
|
from qt import *
|
|
from tdeui import *
|
|
from tdecore import *
|
|
from kfile import *
|
|
from kio import *
|
|
import sys
|
|
import os
|
|
import os.path
|
|
from types import StringType,UnicodeType
|
|
import pwd
|
|
import grp
|
|
import math
|
|
import locale
|
|
import codecs
|
|
import subprocess
|
|
import MicroHAL
|
|
from SMBShareSelectDialog import *
|
|
from SimpleCommandRunner import *
|
|
from fuser import *
|
|
import sizeview
|
|
|
|
programname = "Disk & Filesystem Configuration"
|
|
version = "0.8.0"
|
|
|
|
# Are we running as a separate standalone application or in KControl?
|
|
standalone = __name__=='__main__'
|
|
|
|
# Running as the root user or not?
|
|
isroot = os.getuid()==0
|
|
allowuuid = True
|
|
allowlabel = True
|
|
|
|
|
|
"""
|
|
Universal Options
|
|
-----------------
|
|
|
|
async/sync
|
|
atime/noatime
|
|
auto/noauto
|
|
dev/nodev
|
|
exec/noexec
|
|
ro/rw
|
|
suid/nosuid
|
|
dirsync
|
|
nouser/user/users
|
|
|
|
defaults =>rw, suid, dev, exec, auto, nouser, and async.
|
|
|
|
Automatically set
|
|
=================
|
|
_netdev
|
|
The filesystem resides on a device that requires network access (used to
|
|
prevent the system from attempting to mount these filesystems until the
|
|
network has been enabled on the system).
|
|
|
|
remount
|
|
Attempt to remount an already-mounted file system. This is commonly used
|
|
to change the mount flags for a file system, especially to make a readonly
|
|
file system writeable. It does not change device or mount point.
|
|
|
|
Supported filesystems
|
|
---------------------
|
|
nfs
|
|
ext2
|
|
ext3
|
|
reiserfs
|
|
vfat
|
|
ntfs
|
|
udf
|
|
iso9660
|
|
supermount
|
|
reiser4
|
|
xfs
|
|
jfs
|
|
hfs
|
|
hfsplus
|
|
|
|
cifs (replacement for smbfs)
|
|
auto
|
|
|
|
swap
|
|
|
|
proc
|
|
sysfs
|
|
usbdevfs
|
|
procbususb
|
|
|
|
TODO
|
|
----
|
|
* SMB finished the connection username nad password fields.
|
|
* SMB entry: finished writing the config.
|
|
* SMBSelector: setting the username and password.
|
|
|
|
"""
|
|
|
|
############################################################################
|
|
class UserComboBox(KComboBox):
|
|
def __init__(self,parent,name=None):
|
|
KComboBox.__init__(self,parent,name)
|
|
tmplist = []
|
|
users = pwd.getpwall()
|
|
for user in users:
|
|
uid = int(user[2])
|
|
username = user[4]
|
|
tmplist.append( (int(uid),"%s (%s)" % (username,uid)) )
|
|
tmplist.sort(lambda a,b: cmp(a[1],b[1]))
|
|
self.userlist = []
|
|
for user in tmplist:
|
|
self.insertItem(user[1])
|
|
self.userlist.append(user[0])
|
|
|
|
########################################################################
|
|
def setUID(self,uid):
|
|
if uid in self.userlist:
|
|
self.setCurrentItem(self.userlist.index(int(uid)))
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
########################################################################
|
|
def UID(self):
|
|
return self.userlist[self.currentItem()]
|
|
|
|
############################################################################
|
|
class GroupComboBox(KComboBox):
|
|
def __init__(self,parent,name=None):
|
|
KComboBox.__init__(self,parent,name)
|
|
self.grouplist = []
|
|
groups = grp.getgrall()
|
|
tmplist = []
|
|
for group in groups:
|
|
gid = group[2]
|
|
groupname = group[0]
|
|
tmplist.append( (int(gid),"%s (%s)" % (groupname,gid)) )
|
|
tmplist.sort(lambda a,b: cmp(a[1],b[1]))
|
|
self.grouplist = []
|
|
for group in tmplist:
|
|
self.insertItem(group[1])
|
|
self.grouplist.append(group[0])
|
|
|
|
########################################################################
|
|
def setGID(self,gid):
|
|
if gid in self.grouplist:
|
|
self.setCurrentItem(self.grouplist.index(int(gid)))
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
########################################################################
|
|
def GID(self):
|
|
return self.grouplist[self.currentItem()]
|
|
|
|
|
|
############################################################################
|
|
class MountEntryExt(object):
|
|
use_as_device = "devicenode" # Can be one of "devicenode", "uuid" or "label"
|
|
showdevice = True
|
|
showlabel = False
|
|
showuuid = False
|
|
|
|
########################################################################
|
|
# Base can be either a fstab format line of text, of another MountEntry
|
|
# object.
|
|
def __init__(self,base=None):
|
|
if base==None:
|
|
self.device = unicode(i18n("<device>"))
|
|
self.mountpoint = unicode(i18n("<mount point>"))
|
|
self.mounttype = 'ext2'
|
|
self.uuid = ""
|
|
self.label = ""
|
|
self.extraoptions = "noauto"
|
|
self.fs_freq = 0
|
|
self.fs_passno = 0
|
|
self.enabled = False
|
|
self.managed = False
|
|
self.device_string = ""
|
|
|
|
elif isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
parts = base.split()
|
|
|
|
device_ref = MountEntry.decodeMountEntryString(parts[0])
|
|
self.uuid = ""
|
|
self.label = ""
|
|
if device_ref.startswith("UUID="):
|
|
self.uuid = device_ref[5:]
|
|
self.setUseAsDevice("uuid")
|
|
mapped_device = microhal.getDeviceByUUID(self.uuid)
|
|
if mapped_device is not None:
|
|
self.device = mapped_device.getDev()
|
|
else:
|
|
self.device = ""
|
|
try:
|
|
self.label = mapped_device.getLabel()
|
|
except AttributeError:
|
|
pass
|
|
elif device_ref.startswith("LABEL="):
|
|
self.label = device_ref[6:]
|
|
self.setUseAsDevice("label")
|
|
mapped_device = microhal.getDeviceByLabel(self.label)
|
|
if mapped_device is not None:
|
|
self.device = mapped_device.getDev()
|
|
else:
|
|
self.device = ""
|
|
else:
|
|
self.device = device_ref
|
|
|
|
self.mountpoint = MountEntry.decodeMountEntryString(parts[1])
|
|
self.mounttype = MountEntry.decodeMountEntryString(parts[2])
|
|
self.extraoptions = MountEntry.decodeMountEntryString(parts[3])
|
|
self.fs_freq = int(parts[4])
|
|
self.fs_passno = int(parts[5])
|
|
self.enabled = False
|
|
|
|
options = self.extraoptions.split(",")
|
|
self.managed = "managed" in options
|
|
try:
|
|
options.remove("managed")
|
|
except ValueError:
|
|
pass
|
|
self.extraoptions = ",".join(options)
|
|
|
|
else:
|
|
# This is a new entry, but it's based on another one.
|
|
self.device = base.device
|
|
self.mountpoint = base.mountpoint
|
|
self.mounttype = base.mounttype
|
|
self.extraoptions = base.extraoptions
|
|
self.fs_freq = base.fs_freq
|
|
self.fs_passno = base.fs_passno
|
|
self.uuid = base.uuid
|
|
self.enabled = base.enabled
|
|
self.managed = False
|
|
self.iconname = self.getIconName()
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExt()
|
|
# FIXME: use "newobject = self.__class__()" and get rid of the newobject parameter.
|
|
newobject.device = self.device
|
|
newobject.mountpoint = self.mountpoint
|
|
newobject.mounttype = self.mounttype
|
|
newobject.use_as_device = self.use_as_device
|
|
newobject.showlabel = self.showlabel
|
|
newobject.showdevice = self.showdevice
|
|
newobject.showuuid = self.showuuid
|
|
newobject.extraoptions = self.extraoptions
|
|
newobject.fs_freq = self.fs_freq
|
|
newobject.fs_passno = self.fs_passno
|
|
newobject.enabled = self.enabled
|
|
newobject.uuid = self.uuid
|
|
newobject.label = self.label
|
|
return newobject
|
|
|
|
########################################################################
|
|
def cleanup(self):
|
|
# This method is called after the entry has been removed from the
|
|
# mounttable.
|
|
pass
|
|
|
|
########################################################################
|
|
def setMountType(self,mounttypename): self.mounttype = mounttypename
|
|
|
|
########################################################################
|
|
def isFileSystemAvailable(self):
|
|
return microhal.isSupportedFileSystem(self.mounttype)
|
|
|
|
def getDevice(self): return self.device
|
|
def setDevice(self,device): self.device = device
|
|
def setUseAsDevice(self,use_as): self.use_as_device = use_as
|
|
def getUseAsDevice(self): return self.use_as_device
|
|
def setUUID(self,uuid): self.uuid = uuid
|
|
def setLabel(self,label): self.label = label
|
|
def getMountPoint(self): return self.mountpoint
|
|
def setMountPoint(self,mountpoint): self.mountpoint = mountpoint
|
|
def getExtraOptions(self): return self.extraoptions
|
|
def setExtraOptions(self,extraoptions): self.extraoptions = extraoptions
|
|
def getFSFreq(self): return self.fs_freq
|
|
def setFSFreq(self,fs_freq): self.fs_freq = fs_freq
|
|
def getFSPassno(self): return self.fs_passno
|
|
def setFSPassno(self,fs_passno): self.fs_passno = fs_passno
|
|
def isManaged(self): return self.managed
|
|
|
|
def getUUID(self):
|
|
if not self.uuid:
|
|
return ""
|
|
return self.uuid
|
|
|
|
def getLabel(self):
|
|
try:
|
|
if not self.label:
|
|
return ""
|
|
return self.label
|
|
except AttributeError:
|
|
return ""
|
|
|
|
def getDeviceString(self):
|
|
if self.getUseAsDevice() == "label":
|
|
if self.label != "":
|
|
return MountEntry.encodeMountEntryString("LABEL="+self.label)
|
|
else:
|
|
print "No Label set, preventing you from shooting yourself in the foot"
|
|
elif self.getUseAsDevice() == "uuid":
|
|
if self.uuid != "":
|
|
return "UUID="+self.uuid
|
|
return MountEntry.encodeMountEntryString("UUID="+self.uuid)
|
|
else:
|
|
print "No UUID set, preventing you from shooting yourself in the foot"
|
|
return MountEntry.encodeMountEntryString(self.device)
|
|
|
|
########################################################################
|
|
def getName(self):
|
|
if os.path.basename(self.device).startswith("fd"):
|
|
return "Floppy"
|
|
else:
|
|
return self.mountpoint
|
|
|
|
########################################################################
|
|
def getIconName(self):
|
|
if self.device is not None and os.path.basename(self.device).startswith("fd"):
|
|
return "hi16-floppy"
|
|
else:
|
|
return "hi16-blockdevice"
|
|
|
|
########################################################################
|
|
def updateStatus(self,mtablist):
|
|
self.enabled = self.mountpoint in mtablist
|
|
|
|
########################################################################
|
|
def getFstabOptions(self):
|
|
if self.extraoptions!="":
|
|
return self.extraoptions.split(",")
|
|
else:
|
|
return []
|
|
|
|
########################################################################
|
|
def getFstabLine(self):
|
|
# Construct the options field.
|
|
_options = self.getFstabOptions()
|
|
options = []
|
|
# Remove whitespace and dupes
|
|
for o in _options:
|
|
if o.strip() not in options:
|
|
options.append(o.strip())
|
|
|
|
return self.getDeviceString() + \
|
|
u" " + MountEntry.encodeMountEntryString(self.mountpoint.replace("%20","\040")) + \
|
|
u" " + MountEntry.encodeMountEntryString(self.mounttype) + \
|
|
u" " + MountEntry.encodeMountEntryString(u",".join(options)) + \
|
|
u" " + unicode(self.fs_freq) + u" " + unicode(self.fs_passno)
|
|
|
|
########################################################################
|
|
def getCategory(self):
|
|
return self.device
|
|
|
|
########################################################################
|
|
def isEnabled(self): return self.enabled
|
|
|
|
########################################################################
|
|
def enable(self,parentdialog):
|
|
self._setBusy(parentdialog,True)
|
|
try:
|
|
(rc,output) = SimpleCommandRunner().run(["/bin/mount",self.mountpoint])
|
|
finally:
|
|
self._setBusy(parentdialog,False)
|
|
if rc!=0:
|
|
self.handleMountFailure(parentdialog,rc,output,True)
|
|
|
|
########################################################################
|
|
def disable(self,parentdialog):
|
|
self._setBusy(parentdialog,True)
|
|
try:
|
|
(rc,output) = SimpleCommandRunner().run(["/bin/umount",self.mountpoint])
|
|
finally:
|
|
self._setBusy(parentdialog,False)
|
|
if rc!=0:
|
|
self.handleMountFailure(parentdialog,rc,output,False)
|
|
|
|
########################################################################
|
|
def handleMountFailure(self,parentdialog,rc,output,mount_action=True):
|
|
"""
|
|
Keyword arguments:
|
|
mount_action - True=enable, False=disable
|
|
"""
|
|
global kapp
|
|
if mount_action:
|
|
msg = i18n("An error occurred while enabling %1.\n\nThe system reported: %2").arg( \
|
|
self.mountpoint).arg(output)
|
|
captionmsg = i18n("Unable to enable %1").arg(self.mountpoint)
|
|
else:
|
|
msg = i18n("An error occurred while disabling %1.\n\nThe system reported: %2").arg(
|
|
self.mountpoint).arg(output)
|
|
captionmsg = i18n("Unable to disable %1").arg(self.mountpoint)
|
|
|
|
extramsg = unicode(i18n("Return code from mount was %1.\n").arg(rc))
|
|
|
|
if (rc & 1)!=0:
|
|
extramsg += unicode(i18n("\"incorrect invocation or permissions\"\n"))
|
|
if (rc & 2)!=0:
|
|
extramsg += unicode(i18n("\"system error (out of memory, cannot fork, no more loop devices)\"\n"))
|
|
if (rc & 4)!=0:
|
|
extramsg += unicode(i18n("\"internal mount bug or missing nfs support in mount\"\n"))
|
|
if (rc & 8)!=0:
|
|
extramsg += unicode(i18n("\"user interrupt\"\n"))
|
|
if (rc & 16)!=0:
|
|
extramsg += unicode(i18n("\"problems writing or locking /etc/mtab\"\n"))
|
|
if (rc & 32)!=0:
|
|
extramsg += unicode(i18n("\"mount failure\"\n"))
|
|
if (rc & 64)!=0:
|
|
extramsg += unicode(i18n("\"some mount succeeded\"\n"))
|
|
|
|
in_use = False
|
|
if not mount_action:
|
|
# Use lsof to find out what is blocking the device.
|
|
lsof_bin = '/usr/bin/lsof'
|
|
rc, output = SimpleCommandRunner().run([lsof_bin,'-FncL',str(self.mountpoint)])
|
|
if rc==0:
|
|
# Check if there is one or more processes using the device.
|
|
in_use = len(output.split())>3
|
|
if in_use:
|
|
# Start fuser.py which lists open filedescriptors on device and offers to get
|
|
# rid of them.
|
|
fuser = FUser(str(self.mountpoint),None,lsof_bin,kapp)
|
|
fuser.exec_loop()
|
|
in_use_message = ""
|
|
if fuser.result() != 0:
|
|
in_use_message = unicode(i18n("Unmounting %1 failed or was cancelled.").arg(self.device))
|
|
extramsg += in_use_message
|
|
else:
|
|
extramsg += unicode(i18n("(none)"))
|
|
|
|
if not in_use:
|
|
KMessageBox.detailedSorry(parentdialog, msg, extramsg, captionmsg)
|
|
|
|
########################################################################
|
|
def _setBusy(self,parentdialog,flag):
|
|
global kapp
|
|
if flag:
|
|
kapp.setOverrideCursor( QCursor(Qt.WaitCursor) )
|
|
parentdialog.setEnabled(False)
|
|
|
|
# It is necessary to process some of the events in the event queue.
|
|
# Otherwise the user won't see that the window is disabled.
|
|
# ( setEnabled() here above doesn't redraw the window immediately.
|
|
# Redrawing is done via the event queue.)
|
|
kapp.processEvents()
|
|
else:
|
|
parentdialog.setEnabled(True)
|
|
kapp.restoreOverrideCursor()
|
|
|
|
############################################################################
|
|
class MountEntryExtCommonUnix(MountEntryExt):
|
|
|
|
USERMOUNT_NO = 0
|
|
USERMOUNT_ONE = 1
|
|
USERMOUNT_ANY = 2
|
|
USERMOUNT_OWNER = 3
|
|
|
|
########################################################################
|
|
# Base can be either a fstab format line of text, or another MountEntry
|
|
# object.
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtCommonUnix,self).__init__(base)
|
|
|
|
if isinstance(base,MountEntryExtCommonUnix):
|
|
# Being initalised from an existing object.
|
|
# Only mess with objects
|
|
self.atime = base.atime
|
|
self.auto = base.auto
|
|
self.writeable = base.writeable
|
|
self.usedevpoints = base.usedevpoints
|
|
self.showlabel = True
|
|
self.showuuid = True
|
|
self.allowexecutables = base.allowexecutables
|
|
self.allowsuid = base.allowsuid
|
|
self.allowusermount = base.allowusermount
|
|
|
|
elif isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
options = self.extraoptions.split(",")
|
|
|
|
self.atime = True
|
|
if "noatime" in options:
|
|
self.atime = False
|
|
self.auto = True
|
|
if "noauto" in options:
|
|
self.auto = False
|
|
self.writeable = True
|
|
if "ro" in options:
|
|
self.writeable = False
|
|
self.usedevpoints = True
|
|
if "nodev" in options:
|
|
self.usedevpoints = False
|
|
self.allowexecutables = True
|
|
if "noexec" in options:
|
|
self.allowexecutables = False
|
|
self.allowsuid = True
|
|
if "nosuid" in options:
|
|
self.allowsuid = False
|
|
self.allowusermount = self.USERMOUNT_NO
|
|
if "user" in options:
|
|
self.allowusermount = self.USERMOUNT_ONE
|
|
if "users" in options:
|
|
self.allowusermount = self.USERMOUNT_ANY
|
|
if "owner" in options:
|
|
self.allowusermount = self.USERMOUNT_OWNER
|
|
|
|
self.showlabel = True
|
|
self.showuuid = True
|
|
|
|
for x in ["noatime","atime","auto","noauto","dev","nodev","nouser", \
|
|
"owner","users","user","suid","nosuid","exec","noexec","rw","ro"]:
|
|
try:
|
|
options.remove(x)
|
|
except ValueError:
|
|
pass
|
|
|
|
self.extraoptions = ",".join(options)
|
|
|
|
else:
|
|
# Set some sane defaults.
|
|
self.showlabel = True
|
|
self.showuuid = True
|
|
self.atime = True
|
|
self.auto = False
|
|
self.writeable = True
|
|
self.usedevpoints = False
|
|
self.allowexecutables = False
|
|
self.allowsuid = False
|
|
self.allowusermount = self.USERMOUNT_NO
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtCommonUnix()
|
|
super(MountEntryExtCommonUnix,self).copy(newobject)
|
|
newobject.atime = self.atime
|
|
newobject.auto = self.auto
|
|
newobject.use_as_device = self.use_as_device
|
|
newobject.showlabel = self.showlabel
|
|
newobject.showdevice = self.showdevice
|
|
newobject.showuuid = self.showuuid
|
|
newobject.uuid = self.uuid
|
|
newobject.label = self.label
|
|
newobject.writeable = self.writeable
|
|
newobject.usedevpoints = self.usedevpoints
|
|
newobject.allowexecutables = self.allowexecutables
|
|
newobject.allowsuid = self.allowsuid
|
|
newobject.allowusermount = self.allowusermount
|
|
return newobject
|
|
|
|
########################################################################
|
|
def getFstabOptions(self):
|
|
options = []
|
|
|
|
# These options must appear before the others. 'user', according to the
|
|
# mount man page implies 'noexec' too, BUT the noexec can be overridden
|
|
# by specifying 'exec' after the 'user' keyword. Therefore 'exec' etc
|
|
# must come after 'user', 'users' and friends.
|
|
options.append(['nouser','user','users','owner'][self.allowusermount])
|
|
|
|
super_options = super(MountEntryExtCommonUnix,self).getFstabOptions()
|
|
options.extend(super_options)
|
|
|
|
options.append(['noatime','atime'][self.atime])
|
|
options.append(['noauto','auto'][self.auto])
|
|
options.append(['ro','rw'][self.writeable])
|
|
options.append(['nodev','dev'][self.usedevpoints])
|
|
options.append(['noexec','exec'][self.allowexecutables])
|
|
options.append(['nosuid','suid'][self.allowsuid])
|
|
return options
|
|
|
|
########################################################################
|
|
# atime/noatime
|
|
def getAtime(self): return self.atime
|
|
def setAtime(self,val): self.atime = val
|
|
# auto/noauto
|
|
def getMountAtBoot(self): return self.auto
|
|
def setMountAtBoot(self,val): self.auto = val
|
|
# ro/rw
|
|
def getWritable(self): return self.writeable
|
|
def setWritable(self,val): self.writeable = val
|
|
# dev, nodev
|
|
def getUseDevPoints(self): return self.usedevpoints
|
|
def setUseDevPoints(self,val): self.usedevpoints = val
|
|
# exec/noexec
|
|
def getAllowExecutables(self): return self.allowexecutables
|
|
def setAllowExecutable(self,val): self.allowexecutables = val
|
|
# suid/nosuid
|
|
def getSUID(self): return self.allowsuid
|
|
def setSUID(self,val): self.allowsuid = val
|
|
# nouser/user/users/owner
|
|
def setAllowUserMount(self,val): self.allowusermount = val
|
|
def getAllowUserMount(self): return self.allowusermount
|
|
|
|
|
|
############################################################################
|
|
# Common unix filesystems, but for local hard disks. i.e. partitions.
|
|
class MountEntryExtCommonUnixLocal(MountEntryExtCommonUnix):
|
|
########################################################################
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtCommonUnixLocal,self).__init__(base)
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtCommonUnixLocal()
|
|
super(MountEntryExtCommonUnixLocal,self).copy(newobject)
|
|
newobject.showlabel = self.showlabel
|
|
newobject.showdevice = self.showdevice
|
|
newobject.showuuid = self.showuuid
|
|
return newobject
|
|
|
|
|
|
############################################################################
|
|
class MountEntryExtAlien(MountEntryExt):
|
|
|
|
USERMOUNT_NO = 0
|
|
USERMOUNT_ONE = 1
|
|
USERMOUNT_ANY = 2
|
|
USERMOUNT_OWNER = 3
|
|
|
|
########################################################################
|
|
# Base can be either a fstab format line of text, of another MountEntry
|
|
# object.
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtAlien,self).__init__(base)
|
|
|
|
if isinstance(base,MountEntryExtAlien):
|
|
self.uid = base.uid
|
|
self.gid = base.gid
|
|
self.label = base.label
|
|
self.writeable = base.writeable
|
|
self.auto = base.auto
|
|
self.allowusermount = base.allowusermount
|
|
|
|
elif isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
self.uid = 0
|
|
self.gid = 0
|
|
options = self.extraoptions.split(",")
|
|
newoptions = []
|
|
for line in options:
|
|
if line.startswith("uid="):
|
|
try:
|
|
self.uid = int(line[4:])
|
|
except ValueError:
|
|
self.uid = 0
|
|
elif line.startswith("gid="):
|
|
try:
|
|
self.gid = int(line[4:])
|
|
except ValueError:
|
|
self.gid = 0
|
|
else:
|
|
# We hang on to unknown options for later.
|
|
newoptions.append(line)
|
|
options = newoptions
|
|
|
|
self.writeable = True
|
|
if "ro" in options:
|
|
self.writeable = False
|
|
self.auto = True
|
|
if "noauto" in options:
|
|
self.auto = False
|
|
self.allowusermount = self.USERMOUNT_NO
|
|
if "user" in options:
|
|
self.allowusermount = self.USERMOUNT_ONE
|
|
if "users" in options:
|
|
self.allowusermount = self.USERMOUNT_ANY
|
|
if "owner" in options:
|
|
self.allowusermount = self.USERMOUNT_OWNER
|
|
|
|
for x in ["noatime","atime","auto","noauto","dev","nodev","nouser", \
|
|
"owner","users","user","suid","nosuid","exec","noexec","rw", \
|
|
"ro"]:
|
|
try:
|
|
options.remove(x)
|
|
except ValueError:
|
|
pass
|
|
self.extraoptions = ",".join(options)
|
|
|
|
else:
|
|
self.uid = 0
|
|
self.gid = 0
|
|
self.writeable = False
|
|
self.auto = False
|
|
self.allowusermount = self.USERMOUNT_NO
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtAlien()
|
|
super(MountEntryExtAlien,self).copy(newobject)
|
|
newobject.uid = self.uid
|
|
newobject.gid = self.gid
|
|
newobject.use_as_device = self.use_as_device
|
|
newobject.showlabel = self.showlabel
|
|
newobject.showdevice = self.showdevice
|
|
newobject.showuuid = self.showuuid
|
|
newobject.writeable = self.writeable
|
|
newobject.auto = self.auto
|
|
newobject.allowusermount = self.allowusermount
|
|
return newobject
|
|
|
|
########################################################################
|
|
def getFstabOptions(self):
|
|
# Construct the options field.
|
|
options = super(MountEntryExtAlien,self).getFstabOptions()
|
|
options.append('uid='+unicode(self.uid))
|
|
options.append('gid='+unicode(self.gid))
|
|
options.append(['noauto','auto'][self.auto])
|
|
options.append(['ro','rw'][self.writeable])
|
|
options.append(['nouser','user','users','owner'][self.allowusermount])
|
|
return options
|
|
|
|
########################################################################
|
|
def getUID(self): return self.uid
|
|
def setUID(self,val): self.uid = val
|
|
def getGID(self): return self.gid
|
|
def setGID(self,val): self.gid = val
|
|
|
|
# ro/rw
|
|
def getWritable(self): return self.writeable
|
|
def setWritable(self,val): self.writeable = val
|
|
# auto/noauto
|
|
def getMountAtBoot(self): return self.auto
|
|
def setMountAtBoot(self,val): self.auto = val
|
|
# nouser/user/users/owner
|
|
def setAllowUserMount(self,val): self.allowusermount = val
|
|
def getAllowUserMount(self): return self.allowusermount
|
|
|
|
############################################################################
|
|
class MountEntryExtVFAT(MountEntryExtAlien):
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtVFAT,self).__init__(base)
|
|
|
|
if isinstance(base,MountEntryExtVFAT):
|
|
self.suppresspermissionerrors = base.suppresspermissionerrors
|
|
elif isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
options = self.extraoptions.split(",")
|
|
self.suppresspermissionerrors = "quiet" in options
|
|
try:
|
|
options.remove("quiet")
|
|
except ValueError:
|
|
pass
|
|
self.extraoptions = ",".join(options)
|
|
|
|
else:
|
|
self.suppresspermissionerrors = False
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtVFAT()
|
|
super(MountEntryExtVFAT,self).copy(newobject)
|
|
newobject.suppresspermissionerrors = self.suppresspermissionerrors
|
|
newobject.showlabel = self.showlabel
|
|
newobject.showdevice = self.showdevice
|
|
newobject.showuuid = self.showuuid
|
|
return newobject
|
|
|
|
########################################################################
|
|
def getFstabOptions(self):
|
|
options = super(MountEntryExtVFAT,self).getFstabOptions()
|
|
if self.suppresspermissionerrors:
|
|
options.append('quiet')
|
|
return options
|
|
|
|
def getSuppressPermissionErrors(self): return self.suppresspermissionerrors
|
|
def setSuppressPermissionErrors(self,val): self.suppresspermissionerrors = val
|
|
|
|
############################################################################
|
|
class MountEntryExtSMB(MountEntryExtAlien):
|
|
CREDENTIALSBASENAME = "/etc/fstab_smb_credentials_"
|
|
########################################################################
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtSMB,self).__init__(base)
|
|
|
|
if isinstance(base,MountEntryExtSMB):
|
|
self.username = base.username
|
|
self.password = base.password
|
|
self.credentialsfile = base.credentialsfile
|
|
|
|
elif isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
self.username = None
|
|
self.password = ""
|
|
self.credentialsfile = None
|
|
|
|
newoptions = []
|
|
options = self.extraoptions.split(",")
|
|
for line in options:
|
|
if line.startswith("username="):
|
|
self.username = line[9:]
|
|
elif line.startswith("password="):
|
|
self.password = line[9:]
|
|
elif line.startswith("credentials="):
|
|
self.credentialsfile = line[12:]
|
|
try:
|
|
fhandle = codecs.open(self.credentialsfile,'r',locale.getpreferredencoding())
|
|
for line in fhandle.readlines():
|
|
if line.startswith("username"):
|
|
self.username = line[8:].strip()[1:].strip()
|
|
elif line.startswith("password"):
|
|
self.password = line[8:].strip()[1:].strip()
|
|
fhandle.close()
|
|
|
|
if not self.credentialsfile.startswith(self.CREDENTIALSBASENAME):
|
|
self.credentialsfile = None
|
|
|
|
except IOError:
|
|
self.credentialsfile = None
|
|
|
|
elif line=="guest":
|
|
pass
|
|
else:
|
|
# We hang on to unknown options for later.
|
|
newoptions.append(line)
|
|
options = newoptions
|
|
|
|
if self.username == "":
|
|
self.username = None
|
|
|
|
self.extraoptions = ",".join(options)
|
|
|
|
else:
|
|
self.username = None
|
|
self.password = ""
|
|
self.credentialsfile = None
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtSMB()
|
|
super(MountEntryExtSMB,self).copy(newobject)
|
|
newobject.username = self.username
|
|
newobject.password = self.password
|
|
newobject.credentialsfile = self.credentialsfile
|
|
newobject.showlabel = self.showlabel
|
|
newobject.showdevice = self.showdevice
|
|
newobject.showuuid = self.showuuid
|
|
return newobject
|
|
|
|
########################################################################
|
|
def cleanup(self):
|
|
if (self.credentialsfile is not None) and os.path.exists(self.credentialsfile) and os.path.isfile(self.credentialsfile):
|
|
os.remove(self.credentialsfile)
|
|
|
|
########################################################################
|
|
def getIconName(self):
|
|
return "hi16-network"
|
|
|
|
########################################################################
|
|
def getFstabOptions(self):
|
|
options = super(MountEntryExtSMB,self).getFstabOptions()
|
|
if self.username is None:
|
|
if (self.credentialsfile is not None) and os.path.exists(self.credentialsfile) and os.path.isfile(self.credentialsfile):
|
|
os.remove(self.credentialsfile)
|
|
options.append("guest") # This option should stop mount(8) from asking for a password.
|
|
else:
|
|
# Write out the credentials file
|
|
if self.credentialsfile is None:
|
|
i = 1
|
|
while os.path.exists(self.CREDENTIALSBASENAME+unicode(i)):
|
|
i += 1
|
|
self.credentialsfile = self.CREDENTIALSBASENAME+unicode(i)
|
|
fd = os.open(self.credentialsfile,os.O_WRONLY|os.O_CREAT,0600)
|
|
fhandle = os.fdopen(fd,'w')
|
|
fhandle.write((u"username = %s\npassword = %s\n" % (self.username,self.password))
|
|
.encode(locale.getpreferredencoding(),'replace') )
|
|
fhandle.close()
|
|
options.append(u"credentials="+self.credentialsfile)
|
|
return options
|
|
|
|
########################################################################
|
|
def getUsername(self): return self.username
|
|
def setUsername(self,username): self.username = username
|
|
def getPassword(self): return self.password
|
|
def setPassword(self,password): self.password = password
|
|
|
|
############################################################################
|
|
class MountEntryExtSystem(MountEntryExt):
|
|
########################################################################
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtSystem,self).__init__(base)
|
|
self.use_as_device = "devicenode"
|
|
self.label = ""
|
|
self.showuuid = False
|
|
self.showlabel = False
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtSystem()
|
|
super(MountEntryExtSystem,self).copy(newobject)
|
|
return newobject
|
|
|
|
########################################################################
|
|
def getCategory(self):
|
|
return "system"
|
|
|
|
def disable(self,parentdialog):
|
|
""" This shouldn't happen since system entries have the disable button disabled """
|
|
msg = i18n("Disabling %1 is not supported.").arg(self.mountpoint)
|
|
extramsg = i18n("""Some system devices cannot be disabled because they are needed for \
|
|
basic functionality of the operating system.""")
|
|
KMessageBox.detailedSorry(parentdialog,msg,extramsg,\
|
|
i18n("Error occurred while disabling %1").arg(self.mountpoint))
|
|
|
|
############################################################################
|
|
class MountEntryExtSwap(MountEntryExt):
|
|
|
|
########################################################################
|
|
# Base can be either a fstab format line of text, of another MountEntry
|
|
# object.
|
|
def __init__(self,base=None):
|
|
super(MountEntryExtSwap,self).__init__(base)
|
|
|
|
if isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
options = self.extraoptions.split(",")
|
|
try:
|
|
options.remove('defaults')
|
|
except ValueError:
|
|
pass
|
|
self.extraoptions = u",".join(options)
|
|
|
|
########################################################################
|
|
def copy(self,newobject=None):
|
|
if newobject is None:
|
|
newobject = MountEntryExtSwap()
|
|
super(MountEntryExtSwap,self).copy(newobject)
|
|
return newobject
|
|
|
|
########################################################################
|
|
def getFstabOptions(self):
|
|
options = super(MountEntryExtSwap,self).getFstabOptions()
|
|
if len(options)==0:
|
|
# Make sure there is at least one option in the list.
|
|
options.append('defaults')
|
|
return options
|
|
|
|
########################################################################
|
|
def updateStatus(self,mtablist):
|
|
|
|
this_device = self.device
|
|
if this_device is None:
|
|
# Find the device name by its UUID.
|
|
if self.uuid:
|
|
hal_device = microhal.getDeviceByUUID(self.uuid)
|
|
if self.label:
|
|
hal_device = microhal.getDeviceByLabel(self.label)
|
|
if hal_device is None:
|
|
self.enabled = False
|
|
return
|
|
this_device = hal_device.getDev()
|
|
|
|
# If the device is a symlink, then grab the complete target.
|
|
if os.path.islink(this_device):
|
|
this_device = os.path.join(os.path.dirname(this_device),os.readlink(this_device))
|
|
|
|
fhandle = open("/proc/swaps")
|
|
lines = fhandle.readlines()
|
|
fhandle.close()
|
|
|
|
try: del lines[0]
|
|
except IndexError: pass
|
|
|
|
self.enabled = False
|
|
for line in lines:
|
|
parts = line.split()
|
|
if parts[0]==this_device:
|
|
self.enabled = True
|
|
return
|
|
|
|
########################################################################
|
|
# Returns a list of command+arguments
|
|
def enable(self,parentdialog):
|
|
self._setBusy(parentdialog,True)
|
|
try:
|
|
(rc,output) = SimpleCommandRunner().run(['/sbin/swapon',self.device])
|
|
if rc!=0:
|
|
msg = i18n("An error occurred while enabling swap partition %1.\n\nThe system reported: %2").arg(self.device).arg(output)
|
|
KMessageBox.sorry(parentdialog,msg,\
|
|
i18n("Error occurred while enabling swap partition %1").arg(self.device))
|
|
finally:
|
|
self._setBusy(parentdialog,False)
|
|
|
|
########################################################################
|
|
# Returns a list of command+arguments or None.
|
|
def disable(self,parentdialog):
|
|
self._setBusy(parentdialog,True)
|
|
try:
|
|
(rc,output) = SimpleCommandRunner().run(['/sbin/swapoff',self.device])
|
|
if rc!=0:
|
|
msg = i18n("An error occurred while disabling swap partition %1.\n\nThe system reported: %2").arg(self.device).arg(output)
|
|
KMessageBox.sorry(parentdialog,msg,\
|
|
i18n("Error occurred while disabling swap partition %1").arg(self.device))
|
|
finally:
|
|
self._setBusy(parentdialog,False)
|
|
|
|
############################################################################
|
|
# This represents a mount entry.
|
|
#
|
|
# It also does a little trick with the MountEntryExt classes. MountEntry
|
|
# objects kind of 'change' class under your nose when they are set to
|
|
# different mount types. The handling of the different kinds of mount types
|
|
# is handled by MountEntryExt objects and subclasses.
|
|
|
|
class MountEntry(object):
|
|
|
|
MountTypes = {
|
|
'proc' : (MountEntryExtSystem,i18n("proc")),
|
|
'sysfs' : (MountEntryExtSystem,i18n("sysfs")),
|
|
'rootfs' : (MountEntryExtSystem,i18n("rootfs")),
|
|
'bdev' : (MountEntryExtSystem,i18n("bdev")),
|
|
'sockfs' : (MountEntryExtSystem,i18n("sockfs")),
|
|
'tmpfs' : (MountEntryExtSystem,i18n("tmpfs")),
|
|
'shm' : (MountEntryExtSystem,i18n("shm")),
|
|
'pipefs' : (MountEntryExtSystem,i18n("pipefs")),
|
|
'devfs' : (MountEntryExtSystem,i18n("devfs - Device File System")),
|
|
'devpts' : (MountEntryExtSystem,i18n("devpts")),
|
|
'ramfs' : (MountEntryExtSystem,i18n("ramfs")),
|
|
'auto' : (MountEntryExtCommonUnix,i18n("Automatic")),
|
|
'usbdevfs' : (MountEntryExtSystem,i18n("usbdevfs")),
|
|
'procbususb' : (MountEntryExtSystem,i18n("procbususb")),
|
|
'usbfs' : (MountEntryExtSystem,i18n("usbfs")),
|
|
'supermount' : (MountEntryExt,i18n("supermount")),
|
|
'swap' : (MountEntryExtSwap,i18n("Swap - Linux Swap Space")),
|
|
|
|
'nfs' : (MountEntryExtCommonUnix,i18n("NFS - Network File System")),
|
|
'cifs' : (MountEntryExtSMB,i18n("Windows File Sharing")),
|
|
|
|
'ext2' : (MountEntryExtCommonUnixLocal,i18n("Ext2 - Second Extended FS")),
|
|
'ext3' : (MountEntryExtCommonUnixLocal,i18n("Ext3 - Third Extended FS")),
|
|
'reiserfs' : (MountEntryExtCommonUnixLocal,i18n("ReiserFS")),
|
|
'reiser4' : (MountEntryExtCommonUnixLocal,i18n("Reiser4")),
|
|
'xfs' : (MountEntryExtCommonUnixLocal,i18n("XFS - SGI's journaling filesystem")),
|
|
'hfs' : (MountEntryExtCommonUnixLocal,i18n("HFS - Apple's Hierarchical File System")),
|
|
'hfsplus' : (MountEntryExtVFAT,i18n("HFS+ - Apple's modernized Hierarchical File System")),
|
|
'jfs' : (MountEntryExtCommonUnixLocal,i18n("JFS - IBM's Journaled File System")),
|
|
'vfat' : (MountEntryExtVFAT,i18n("VFAT - Microsoft FAT File Systems")),
|
|
'ntfs' : (MountEntryExtVFAT,i18n("NTFS - NT File System")),
|
|
'udf' : (MountEntryExtSystem,i18n("udf")),
|
|
'iso9660' : (MountEntryExt,i18n("iso9660 - CD-ROM")),
|
|
}
|
|
|
|
notInFstab = False
|
|
maydisable = True # Some entries, such as /proc can't be disabled.
|
|
|
|
########################################################################
|
|
# Base can be either a fstab format line of text, of another MountEntry
|
|
# object.
|
|
def __init__(self,base=None):
|
|
try:
|
|
self.extensionObjects = {}
|
|
if base==None:
|
|
self.mounttype = 'auto'
|
|
elif isinstance(base,StringType) or isinstance(base,UnicodeType):
|
|
parts = base.split()
|
|
self.mounttype = parts[2]
|
|
# 'udf,iso9660' seems default for some devices in fstab,
|
|
# check if all listed filesystems are available, if yes set to 'auto'.
|
|
if len(self.mounttype.split(',')) > 1:
|
|
"""
|
|
# We could check here, but then we'd need a reference to MicroHAL.
|
|
#for m in self.mounttype.split(','):
|
|
#if m not in supported_fs:
|
|
# print "Filesystem ", m, "not supported by the kernel"
|
|
# break
|
|
"""
|
|
self.mounttype = "auto"
|
|
else:
|
|
# This is a new entry, but it's based on another one.
|
|
self.mounttype = base.mounttype
|
|
self.extension = self.MountTypes[self.mounttype][0](base)
|
|
self.extensionObjects[self.mounttype] = self.extension
|
|
except (KeyError,IndexError):
|
|
raise InvalidMountEntryError, u"Unable to parse mount entry:"+unicode(base)
|
|
|
|
########################################################################
|
|
def getMountType(self):
|
|
return self.mounttype
|
|
|
|
########################################################################
|
|
def setMountType(self,newtypename):
|
|
if newtypename not in self.extensionObjects:
|
|
try:
|
|
self.extensionObjects[newtypename] = self.MountTypes[newtypename][0](self.extension)
|
|
except KeyError:
|
|
raise NotImplementedError, "Unknown mounttype:"+newtypename
|
|
self.mounttype = newtypename
|
|
self.extension = self.extensionObjects[newtypename]
|
|
self.extension.setMountType(newtypename)
|
|
|
|
########################################################################
|
|
def copy(self):
|
|
newentry = MountEntry()
|
|
newentry.mounttype = self.mounttype
|
|
newext = self.extension.copy()
|
|
newentry.use_as_device = self.use_as_device
|
|
newentry.showlabel = self.showlabel
|
|
newentry.showdevice = self.showdevice
|
|
newentry.showuuid = self.showuuid
|
|
newentry.extensionObjects[self.mounttype] = newext
|
|
newentry.extension = newext
|
|
return newentry
|
|
|
|
########################################################################
|
|
def inPlaceCopyFrom(self,sourceentry):
|
|
self.extension.cleanup()
|
|
|
|
tmpcopy = sourceentry.copy()
|
|
self.extensionObjects = tmpcopy.extensionObjects
|
|
self.mounttype = tmpcopy.mounttype
|
|
self.extension = tmpcopy.extension
|
|
|
|
# Override the attribute lookup, set/get, to use the extension object
|
|
########################################################################
|
|
def __getattr__(self,name):
|
|
try:
|
|
return getattr(self.extension,name)
|
|
except AttributeError, a:
|
|
print a
|
|
|
|
########################################################################
|
|
# FIXME
|
|
## def __setattr__(self,name,value):
|
|
## if 'extension' in self.__dict__:
|
|
## if name in self.extension.__dict__:
|
|
## setattr(self.extension,name,value)
|
|
## return
|
|
## self.__dict__[name] = value
|
|
|
|
########################################################################
|
|
def getMountTypes():
|
|
return MountEntry.MountTypes.keys()
|
|
getMountTypes = staticmethod(getMountTypes)
|
|
|
|
########################################################################
|
|
def getMountTypeLongName(typename):
|
|
return MountEntry.MountTypes[typename][1]
|
|
getMountTypeLongName = staticmethod(getMountTypeLongName)
|
|
|
|
########################################################################
|
|
def encodeMountEntryString(string):
|
|
newstring = u""
|
|
for c in string:
|
|
if c==' ':
|
|
newstring += "\\040"
|
|
elif c=="\t":
|
|
newstring += "\\012"
|
|
elif c=='\\':
|
|
newstring += "\\134"
|
|
else:
|
|
newstring += c
|
|
return newstring
|
|
encodeMountEntryString = staticmethod(encodeMountEntryString)
|
|
|
|
########################################################################
|
|
def decodeMountEntryString(string):
|
|
newstring = ""
|
|
while string!="":
|
|
if len(string)>=4 and string[0]=='\\' and isoct(string[1]) \
|
|
and isoct(string[2]) and isoct(string[3]):
|
|
newstring += chr(64*(ord(string[1])-ord('0')) + \
|
|
8*(ord(string[2])-ord('0')) + (ord(string[3])-ord('0')))
|
|
string = string[4:]
|
|
else:
|
|
newstring += string[0]
|
|
string = string[1:]
|
|
return newstring
|
|
decodeMountEntryString = staticmethod(decodeMountEntryString)
|
|
|
|
############################################################################
|
|
class MountEntryComment(MountEntry):
|
|
""" This represents a comment mount entry or generally something that we don't
|
|
understand (might be comment, might be fstab syntax we don't know, might be
|
|
a faulty line in there). We don't want to wipe that stuff out, but we can't
|
|
deal with it in a sensible way, so we keep it in a MountEntryComment,
|
|
exclude it from most operations, but will write it back to fstab afterwards
|
|
|
|
As a result of that we only define the stuff that's necessary, namely saving
|
|
the fstab line and returning it when writing."""
|
|
|
|
########################################################################
|
|
def __init__(self,base=None):
|
|
self.row = base
|
|
|
|
########################################################################
|
|
def getFstabLine(self): return self.row
|
|
|
|
############################################################################
|
|
def isoct(c): return c in '01234567'
|
|
|
|
############################################################################
|
|
class InvalidMountEntryError(Exception):
|
|
|
|
########################################################################
|
|
def __init__(self,arg=None):
|
|
self.arg = arg
|
|
|
|
########################################################################
|
|
def __str__(self):
|
|
return str(self.arg)
|
|
|
|
############################################################################
|
|
class MountTable(object):
|
|
|
|
########################################################################
|
|
def __init__(self,fstab_filename,mtab_filename):
|
|
self.fstab_filename = fstab_filename
|
|
self.mtab_filename = mtab_filename
|
|
|
|
self.entries = []
|
|
self.allentries = []
|
|
|
|
# sysfs does not need an entry in fstab, so we add it even if it's not
|
|
# in there, it's mounted automatically anyway and shows up in mtab
|
|
sysfs_in_fstab = False
|
|
usbdevfs_in_fstab = False
|
|
|
|
fhandle = codecs.open(self.fstab_filename,'r',locale.getpreferredencoding())
|
|
for row in fhandle.readlines():
|
|
row = row.strip('\n') # Carefully remove any trailing newline.
|
|
if row.strip().startswith("#") or row.strip()=="":
|
|
entry = MountEntryComment(row)
|
|
else:
|
|
try:
|
|
entry = MountEntry(row)
|
|
self.append(entry)
|
|
|
|
if entry.getMountType() == "sysfs":
|
|
sysfs_in_fstab = True
|
|
if entry.getMountType() == "usbdevfs" or "procbususb":
|
|
usbdevfs_in_fstab = True
|
|
if entry.getMountType() == "proc":
|
|
entry.maydisable = False
|
|
except InvalidMountEntryError:
|
|
entry = MountEntryComment(row)
|
|
# We keep a list with references to _all_ entries, also the comments,
|
|
# this is the one we'll use to write out our new fstab, only 'real'
|
|
# entries (real == entries we understand) are added to self to let them
|
|
# be handled by iterator.
|
|
# allentries includes comments and invalid lines, self doesn't.
|
|
self.allentries.append(entry)
|
|
fhandle.close()
|
|
|
|
if not sysfs_in_fstab:
|
|
sysfsentry = MountEntry(u"sysfs /sys sysfs defaults 0 0")
|
|
sysfsentry.notInFstab = True
|
|
sysfsentry.maydisable = False
|
|
#self.append(sysfsentry)
|
|
|
|
if not usbdevfs_in_fstab:
|
|
usbdevfsentry = MountEntry(u"procbususb /proc/bus/usb usbdevfs defaults 0 0")
|
|
usbdevfsentry.notInFstab = True
|
|
usbdevfsentry.maydisable = False
|
|
self.append(usbdevfsentry)
|
|
|
|
self.updateStatus()
|
|
|
|
########################################################################
|
|
def append(self,entry):
|
|
self.entries.append(entry)
|
|
|
|
########################################################################
|
|
def remove(self,entry):
|
|
self.allentries.remove(entry)
|
|
entry.cleanup()
|
|
|
|
########################################################################
|
|
def updateStatus(self,entry=None):
|
|
mtablist = self.getMtabList()
|
|
if entry==None:
|
|
for entry in self.entries:
|
|
entry.updateStatus(mtablist)
|
|
else:
|
|
entry.updateStatus(mtablist)
|
|
|
|
########################################################################
|
|
def getMtabList(self):
|
|
fhandle = open(self.mtab_filename)
|
|
mtablist = []
|
|
for row in fhandle.readlines():
|
|
if row.strip()[0]!='#':
|
|
parts = row.split()
|
|
mtablist.append(parts[1])
|
|
fhandle.close()
|
|
return mtablist
|
|
|
|
########################################################################
|
|
def updateFstabOnDisk(self):
|
|
fhandle = None
|
|
try:
|
|
try:
|
|
fhandle = codecs.open(self.fstab_filename+"~","w",locale.getpreferredencoding(),'replace')
|
|
for entry in self.allentries:
|
|
if not entry.notInFstab:
|
|
line = entry.getFstabLine()
|
|
fhandle.write(line+u"\n")
|
|
print line
|
|
fhandle.close()
|
|
fhandle = None
|
|
|
|
# Move it over the original
|
|
os.rename(self.fstab_filename+"~",self.fstab_filename)
|
|
return True
|
|
finally:
|
|
if fhandle:
|
|
fhandle.close()
|
|
except IOError:
|
|
return False
|
|
|
|
########################################################################
|
|
# We make this class look like a container, and just forward everything
|
|
# on to the entries attribute.
|
|
def __contains__(self,item):
|
|
return self.entries.__contains(item)
|
|
########################################################################
|
|
def __delitem__(self,key):
|
|
raise NotImplementedError, "No __delitem__ on MountTable."
|
|
|
|
########################################################################
|
|
def __getitem__(self,key):
|
|
return self.entries.__getitem__(key)
|
|
########################################################################
|
|
|
|
def __iter__(self):
|
|
return self.entries.__iter__()
|
|
########################################################################
|
|
def __len__(self):
|
|
return self.entries.__len__()
|
|
########################################################################
|
|
def __setitem__(self,key,value):
|
|
raise NotImplementedError, "No __setitem__ on MountTable."
|
|
|
|
############################################################################
|
|
class MountEntryDialogOptions(QWidget):
|
|
|
|
deviceexample = i18n("(for example /dev/hdb3)")
|
|
|
|
########################################################################
|
|
def __init__(self,parent,showmountpoint=True,showdevice=True,
|
|
showfs_freq=True,showfs_passno=True,showuuid=True,showlabel=True):
|
|
QWidget.__init__(self,parent)
|
|
self.showmountpoint = showmountpoint
|
|
self.showdevice = showdevice
|
|
self.showfs_freq = showfs_freq
|
|
self.showfs_passno = showfs_passno
|
|
self.showuuid = showuuid
|
|
self.showlabel = showlabel
|
|
self._fillPage()
|
|
# TODO: KDirSelectDialog needs "Create new Folder"
|
|
self.mountpointdialog = KDirSelectDialog("/",True,self,"Select Mount Point",True)
|
|
|
|
########################################################################
|
|
def _fillPage(self):
|
|
row = 0
|
|
grid = QGridLayout(self,1,2)
|
|
grid.setSpacing(KDialog.spacingHint())
|
|
grid.setColStretch(0,0)
|
|
grid.setColStretch(2,0)
|
|
|
|
if self.showmountpoint:
|
|
|
|
label = QLabel(i18n("Mount Point:"),self)
|
|
grid.addWidget(label,row,0)
|
|
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.mountpointlineedit = KLineEdit(hbox)
|
|
hbox.setStretchFactor(self.mountpointlineedit,1)
|
|
#self.connect(self.homediredit, SIGNAL("textChanged(const QString &)"), self.slotHomeDirChanged)
|
|
self.mountpointbutton = KPushButton(i18n("Browse..."),hbox)
|
|
hbox.setStretchFactor(self.mountpointbutton,0)
|
|
self.connect(self.mountpointbutton,SIGNAL("clicked()"),self.slotBrowseMountPointClicked)
|
|
grid.addMultiCellWidget(hbox,row,row,1,3)
|
|
row += 1
|
|
|
|
if self.showdevice:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
|
|
label = QLabel(i18n("Device:"),self)
|
|
grid.addWidget(label,row,0)
|
|
|
|
self.devicecheckbox = QRadioButton(i18n("by name"),hbox)
|
|
self.connect(self.devicecheckbox,SIGNAL("clicked()"), \
|
|
self.slotDeviceCheckboxClicked)
|
|
self.devicelineedit = KLineEdit(hbox)
|
|
grid.addMultiCellWidget(hbox,row,row,1,3)
|
|
row += 1
|
|
example = QLabel(self.deviceexample,self)
|
|
grid.addMultiCellWidget(example,row,row,1,3)
|
|
row += 1
|
|
|
|
if self.showuuid:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.uuidcheckbox = QRadioButton(i18n("by UUID"),hbox)
|
|
self.connect(self.uuidcheckbox,SIGNAL("clicked()"), \
|
|
self.slotUUIDCheckboxClicked)
|
|
self.uuidlineedit = KLineEdit(hbox)
|
|
grid.addMultiCellWidget(hbox,row,row,1,3)
|
|
row += 1
|
|
|
|
if self.showlabel:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.labelcheckbox = QRadioButton(i18n("by label"),hbox)
|
|
self.connect(self.labelcheckbox,SIGNAL("clicked()"), \
|
|
self.slotLabelCheckboxClicked)
|
|
self.labellineedit = KLineEdit(hbox)
|
|
grid.addMultiCellWidget(hbox,row,row,1,3)
|
|
row += 1
|
|
else:
|
|
if self.showdevice:
|
|
label = QLabel(i18n("Device:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.devicelineedit = KLineEdit(self)
|
|
grid.addMultiCellWidget(self.devicelineedit,row,row,1,3)
|
|
row += 1
|
|
example = QLabel(self.deviceexample,self)
|
|
grid.addWidget(example,row,1)
|
|
|
|
if self.showuuid:
|
|
label = QLabel(i18n("Device UUID:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.uuidlineedit = KLineEdit(self)
|
|
grid.addMultiCellWidget(self.uuidlineedit,row,row,1,3)
|
|
row += 1
|
|
|
|
if self.showlabel:
|
|
label = QLabel(i18n("Device Label:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.labellineedit = KLineEdit(self)
|
|
grid.addMultiCellWidget(self.labellineedit,row,row,1,3)
|
|
row += 1
|
|
|
|
label = QLabel(i18n("Options:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.optionslineedit = KLineEdit(self)
|
|
grid.addMultiCellWidget(self.optionslineedit,row,row,1,3)
|
|
row += 1
|
|
|
|
if self.showfs_freq:
|
|
label = QLabel(i18n("fs_freq:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.fsfreqspinbox = KIntSpinBox (0,1000,1,0,10,self)
|
|
grid.addWidget(self.fsfreqspinbox,row,1)
|
|
|
|
if self.showfs_passno:
|
|
label = QLabel(i18n("fs_passno:"),self)
|
|
grid.addWidget(label,row,2)
|
|
self.fspassnospinbox = KIntSpinBox (0,1000,1,0,10,self)
|
|
grid.addWidget(self.fspassnospinbox,row,3)
|
|
row += 1
|
|
|
|
grid.addWidget(QWidget(self),row,0)
|
|
|
|
for x in range(grid.numRows()):
|
|
grid.setRowStretch(x,0)
|
|
grid.setRowStretch(grid.numRows()-1,1)
|
|
|
|
########################################################################
|
|
def displayMountEntry(self,entry):
|
|
global allowuuid, allowlabel
|
|
if self.showmountpoint:
|
|
self.mountpointlineedit.setText(entry.getMountPoint())
|
|
|
|
uuid = entry.getUUID()
|
|
if entry.getDevice() == "" and uuid != "":
|
|
device = microhal.getDeviceByUUID(uuid)
|
|
self.devicelineedit.setText(uuid)
|
|
else:
|
|
if self.showdevice:
|
|
self.devicelineedit.setText(entry.getDevice())
|
|
|
|
if self.showuuid:
|
|
if entry.getUUID()!="":
|
|
self.uuidlineedit.setText(entry.getUUID())
|
|
|
|
if self.showlabel:
|
|
if entry.getLabel()!="":
|
|
self.labellineedit.setText(entry.getLabel())
|
|
|
|
if entry.getUseAsDevice() == "devicenode":
|
|
if self.showdevice:
|
|
self.devicelineedit.setEnabled(True)
|
|
self.devicecheckbox.setChecked(True)
|
|
if self.showuuid:
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.uuidlineedit.setEnabled(False)
|
|
if self.showlabel:
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
elif entry.getUseAsDevice() == "label":
|
|
if self.showlabel:
|
|
self.labellineedit.setEnabled(True)
|
|
self.labelcheckbox.setChecked(True)
|
|
if self.showdevice:
|
|
self.devicelineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(False)
|
|
if self.showuuid:
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.uuidcheckbox.setChecked(False)
|
|
elif entry.getUseAsDevice() == "uuid":
|
|
if self.showdevice:
|
|
self.devicecheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
if self.showlabel:
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
if self.showuuid:
|
|
self.uuidlineedit.setEnabled(True)
|
|
self.uuidcheckbox.setChecked(True)
|
|
|
|
## if allowlabel:
|
|
## self.labellineedit.setText(entry.getLabel())
|
|
## if allowuuid:
|
|
## self.uuidlineedit.setText(entry.getUUID())
|
|
## self.devicelineedit.setText(entry.getDevice())
|
|
|
|
self.optionslineedit.setText(entry.getExtraOptions())
|
|
if self.showfs_freq:
|
|
self.fsfreqspinbox.setValue(entry.getFSFreq())
|
|
if self.showfs_passno:
|
|
self.fspassnospinbox.setValue(entry.getFSPassno())
|
|
|
|
########################################################################
|
|
def undisplayMountEntry(self,entry):
|
|
if self.showmountpoint:
|
|
entry.setMountPoint( unicode(self.mountpointlineedit.text()) )
|
|
if self.showdevice:
|
|
entry.setDevice( unicode(self.devicelineedit.text()) )
|
|
|
|
if self.showuuid and self.showdevice:
|
|
if self.devicecheckbox.isChecked():
|
|
entry.setUUID(None)
|
|
else:
|
|
entry.setUUID( unicode(self.uuidlineedit.text()) )
|
|
if self.showlabel and self.showdevice:
|
|
if self.devicecheckbox.isChecked():
|
|
entry.setLabel(None)
|
|
else:
|
|
entry.setLabel( unicode(self.labellineedit.text()) )
|
|
|
|
if allowuuid and self.showuuid:
|
|
if self.uuidcheckbox.isChecked():
|
|
entry.setUseAsDevice("uuid")
|
|
if allowlabel and self.showlabel:
|
|
if self.labelcheckbox.isChecked():
|
|
entry.setUseAsDevice("label")
|
|
if self.showdevice:
|
|
if self.devicecheckbox.isChecked():
|
|
entry.setUseAsDevice("devicenode")
|
|
|
|
entry.setExtraOptions( unicode(self.optionslineedit.text()) )
|
|
if self.showfs_freq:
|
|
entry.setFSFreq(self.fsfreqspinbox.value())
|
|
if self.showfs_passno:
|
|
entry.setFSPassno(self.fspassnospinbox.value())
|
|
|
|
########################################################################
|
|
def slotBrowseMountPointClicked(self):
|
|
fileurl = KURL()
|
|
fileurl.setPath(self.mountpointlineedit.text())
|
|
self.mountpointdialog.setCurrentURL(fileurl)
|
|
if self.mountpointdialog.exec_loop()==QDialog.Accepted:
|
|
self.mountpointlineedit.setText(self.mountpointdialog.url().path())
|
|
|
|
########################################################################
|
|
def slotDeviceCheckboxClicked(self):
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.labelcheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(True)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.labellineedit.setEnabled(False)
|
|
|
|
########################################################################
|
|
def slotUUIDCheckboxClicked(self):
|
|
if self.uuidlineedit.text() == "":
|
|
label = microhal.getUUIDByDevice(unicode(self.devicelineedit.text()))
|
|
self.uuidlineedit.setText(label)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.uuidlineedit.setEnabled(True)
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
|
|
def slotLabelCheckboxClicked(self):
|
|
if self.labellineedit.text() == "":
|
|
label = microhal.getLabelByDevice(unicode(self.devicelineedit.text()))
|
|
self.labellineedit.setText(label)
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.labelcheckbox.setChecked(True)
|
|
self.labellineedit.setEnabled(True)
|
|
|
|
############################################################################
|
|
class MountEntryDialogOptionsCommonUnix(MountEntryDialogOptions):
|
|
|
|
########################################################################
|
|
def __init__(self,parent):
|
|
MountEntryDialogOptions.__init__(self,parent)
|
|
self.advanceddialog = MountEntryAdvancedCommonUnixDialog(None)
|
|
|
|
########################################################################
|
|
def _fillPage(self):
|
|
|
|
row = 0
|
|
grid = QGridLayout(self,1,2)
|
|
grid.setSpacing(KDialog.spacingHint())
|
|
grid.setColStretch(0,0)
|
|
grid.setRowStretch(6,1)
|
|
|
|
label = QLabel(i18n("Mount Point:"),self)
|
|
grid.addWidget(label,row,0)
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.mountpointlineedit = KLineEdit(hbox)
|
|
hbox.setStretchFactor(self.mountpointlineedit,1)
|
|
#self.connect(self.homediredit, SIGNAL("textChanged(const QString &)"), self.slotHomeDirChanged)
|
|
self.mountpointbutton = KPushButton(i18n("Browse..."),hbox)
|
|
hbox.setStretchFactor(self.mountpointbutton,0)
|
|
self.connect(self.mountpointbutton,SIGNAL("clicked()"), \
|
|
self.slotBrowseMountPointClicked)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
|
|
if self.showuuid or self.showlabel:
|
|
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
|
|
label = QLabel(i18n("Device:"),self)
|
|
grid.addWidget(label,row,0)
|
|
|
|
self.devicecheckbox = QRadioButton(i18n("by name"),hbox)
|
|
self.connect(self.devicecheckbox,SIGNAL("clicked()"), \
|
|
self.slotDeviceCheckboxClicked)
|
|
self.devicelineedit = KLineEdit(hbox)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
example = QLabel(self.deviceexample,self)
|
|
grid.addWidget(example,row,1)
|
|
row += 1
|
|
|
|
if self.showuuid:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.uuidcheckbox = QRadioButton(i18n("by UUID"),hbox)
|
|
self.connect(self.uuidcheckbox,SIGNAL("clicked()"), \
|
|
self.slotUUIDCheckboxClicked)
|
|
self.uuidlineedit = KLineEdit(hbox)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
|
|
if self.showlabel:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.labelcheckbox = QRadioButton(i18n("by label"),hbox)
|
|
self.connect(self.labelcheckbox,SIGNAL("clicked()"), \
|
|
self.slotLabelCheckboxClicked)
|
|
self.labellineedit = KLineEdit(hbox)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
|
|
else:
|
|
label = QLabel(i18n("Device:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.devicelineedit = KLineEdit(self)
|
|
grid.addWidget(self.devicelineedit,row,1)
|
|
row += 1
|
|
example = QLabel(self.deviceexample,self)
|
|
grid.addWidget(example,row,1)
|
|
row += 1
|
|
|
|
self.autocheckbox = QCheckBox(i18n("Enable at start up"),self)
|
|
grid.addWidget(self.autocheckbox,row,1)
|
|
row += 1
|
|
|
|
self.writeablecheckbox = QCheckBox(i18n("Writeable"),self)
|
|
grid.addWidget(self.writeablecheckbox,row,1)
|
|
row += 1
|
|
|
|
label = QLabel(i18n("Mount Permission:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.usermountcombobox = KComboBox(self)
|
|
self.usermountcombobox.insertItem(i18n("Root user only may enable/disable"))
|
|
self.usermountcombobox.insertItem(i18n("One user at a time may enable/disable"))
|
|
self.usermountcombobox.insertItem(i18n("Any user may enable/disable anytime"))
|
|
self.usermountcombobox.insertItem(i18n("Device owner may enable/disable"))
|
|
grid.addWidget(self.usermountcombobox,row,1)
|
|
row += 1
|
|
|
|
#grid.addWidget(,9,0)
|
|
button = KPushButton(i18n("Advanced..."),self)
|
|
button.setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed)
|
|
self.connect(button,SIGNAL("clicked()"),self.slotAdvancedClicked)
|
|
grid.addWidget(button,row,1,Qt.AlignRight)
|
|
row += 1
|
|
|
|
grid.addWidget(QWidget(self),row,0)
|
|
|
|
for x in range(grid.numRows()):
|
|
grid.setRowStretch(x,0)
|
|
grid.setRowStretch(grid.numRows()-1,1)
|
|
|
|
########################################################################
|
|
def displayMountEntry(self,entry):
|
|
self.devicelineedit.setText(entry.getDevice())
|
|
|
|
if self.showuuid:
|
|
if entry.getUUID()!="":
|
|
self.uuidlineedit.setText(entry.getUUID())
|
|
|
|
if self.showlabel:
|
|
if entry.getLabel()!="":
|
|
self.labellineedit.setText(entry.getLabel())
|
|
|
|
if entry.getUseAsDevice() == "devicenode":
|
|
self.devicelineedit.setEnabled(True)
|
|
self.devicecheckbox.setChecked(True)
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
elif entry.getUseAsDevice() == "label":
|
|
self.labellineedit.setEnabled(True)
|
|
self.labelcheckbox.setChecked(True)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.uuidcheckbox.setChecked(False)
|
|
elif entry.getUseAsDevice() == "uuid":
|
|
self.devicecheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
self.uuidlineedit.setEnabled(True)
|
|
self.uuidcheckbox.setChecked(True)
|
|
|
|
self.devicelineedit.setText(entry.getDevice())
|
|
self.mountpointlineedit.setText(entry.getMountPoint())
|
|
self.options = entry.getExtraOptions()
|
|
self.fsfreq = entry.getFSFreq()
|
|
self.fspassno = entry.getFSPassno()
|
|
self.autocheckbox.setChecked(entry.getMountAtBoot())
|
|
self.writeablecheckbox.setChecked(entry.getWritable())
|
|
self.accesstime = entry.getAtime()
|
|
self.allowexecutable = entry.getAllowExecutables()
|
|
self.allowsuid = entry.getSUID()
|
|
self.usedevpoints = entry.getUseDevPoints()
|
|
self.usermountcombobox.setCurrentItem(entry.getAllowUserMount())
|
|
|
|
########################################################################
|
|
def undisplayMountEntry(self,entry):
|
|
|
|
entry.setDevice( unicode(self.devicelineedit.text()) )
|
|
if self.showuuid:
|
|
if self.devicecheckbox.isChecked() or self.labelcheckbox.isChecked():
|
|
entry.setUUID(None)
|
|
else:
|
|
entry.setUUID( unicode(self.uuidlineedit.text()) )
|
|
|
|
if self.showlabel:
|
|
if self.devicecheckbox.isChecked() or self.uuidcheckbox.isChecked():
|
|
entry.setLabel(None)
|
|
else:
|
|
entry.setLabel( unicode(self.labellineedit.text()) )
|
|
|
|
if not self.showlabel and not self.showuuid:
|
|
if self.uuidcheckbox.isChecked() or self.labelcheckbox.isChecked():
|
|
entry.setLabel(None)
|
|
else:
|
|
entry.setLabel( unicode(self.devicelineedit.text()) )
|
|
|
|
if allowuuid:
|
|
if self.uuidcheckbox.isChecked():
|
|
entry.setUseAsDevice("uuid")
|
|
if allowlabel:
|
|
if self.labelcheckbox.isChecked():
|
|
entry.setUseAsDevice("label")
|
|
if self.devicecheckbox.isChecked():
|
|
entry.setUseAsDevice("devicenode")
|
|
|
|
entry.setMountPoint( unicode(self.mountpointlineedit.text()) )
|
|
entry.setExtraOptions(self.options)
|
|
entry.setFSFreq(self.fsfreq)
|
|
entry.setFSPassno(self.fspassno)
|
|
entry.setAtime(self.accesstime)
|
|
entry.setMountAtBoot(self.autocheckbox.isChecked())
|
|
entry.setWritable(self.writeablecheckbox.isChecked())
|
|
entry.setUseDevPoints(self.usedevpoints)
|
|
entry.setAllowExecutable(self.allowexecutable)
|
|
entry.setSUID(self.allowsuid)
|
|
entry.setAllowUserMount(self.usermountcombobox.currentItem())
|
|
|
|
########################################################################
|
|
def slotAdvancedClicked(self):
|
|
(self.accesstime, self.allowexecutable, self.allowsuid, self.usedevpoints, self.options, self.fsfreq,
|
|
self.fspassno)\
|
|
= self.advanceddialog.do(self.accesstime, self.allowexecutable, self.allowsuid, self.usedevpoints,
|
|
self.options, self.fsfreq, self.fspassno)
|
|
|
|
########################################################################
|
|
def slotDeviceCheckboxClicked(self):
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(True)
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
self.uuidlineedit.setEnabled(False)
|
|
|
|
########################################################################
|
|
def slotUUIDCheckboxClicked(self):
|
|
if self.uuidlineedit.text() == "":
|
|
label = microhal.getUUIDByDevice(unicode(self.devicelineedit.text()))
|
|
self.uuidlineedit.setText(label)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.labelcheckbox.setChecked(False)
|
|
self.labellineedit.setEnabled(False)
|
|
self.uuidlineedit.setEnabled(True)
|
|
|
|
def slotLabelCheckboxClicked(self):
|
|
if self.labellineedit.text() == "":
|
|
label = microhal.getLabelByDevice(unicode(self.devicelineedit.text()))
|
|
self.labellineedit.setText(label)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.labellineedit.setEnabled(True)
|
|
|
|
############################################################################
|
|
class MountEntryDialogOptionsSys(MountEntryDialogOptions):
|
|
########################################################################
|
|
def __init__(self,parent):
|
|
MountEntryDialogOptions.__init__(self,parent,True,False,False,False,False,False)
|
|
|
|
############################################################################
|
|
class MountEntryDialogOptionsSwap(MountEntryDialogOptions):
|
|
########################################################################
|
|
def __init__(self,parent):
|
|
MountEntryDialogOptions.__init__(self,parent,False,True,False,False)
|
|
|
|
class MountEntryDialogOptionsNfs(MountEntryDialogOptionsCommonUnix):
|
|
|
|
deviceexample = i18n("(for example 192.168.1.66:/export)")
|
|
|
|
############################################################################
|
|
class MountEntryDialogOptionsVFAT(MountEntryDialogOptions):
|
|
########################################################################
|
|
def __init__(self,parent):
|
|
MountEntryDialogOptions.__init__(self,parent)
|
|
self.advanceddialog = MountEntryAdvancedPlainDialog(None)
|
|
self.updatinggui= False
|
|
|
|
########################################################################
|
|
def _fillPage(self):
|
|
global allowuuid, allowlabel
|
|
|
|
row = 0
|
|
grid = QGridLayout(self,11,2)
|
|
grid.setSpacing(KDialog.spacingHint())
|
|
grid.setColStretch(0,0)
|
|
grid.setColStretch(2,0)
|
|
grid.setRowStretch(10,1)
|
|
|
|
label = QLabel(i18n("Mount Point:"),self)
|
|
grid.addWidget(label,row,0)
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.mountpointlineedit = KLineEdit(hbox)
|
|
hbox.setStretchFactor(self.mountpointlineedit,1)
|
|
#self.connect(self.homediredit, SIGNAL("textChanged(const QString &)"), self.slotHomeDirChanged)
|
|
self.mountpointbutton = KPushButton(i18n("Browse..."),hbox)
|
|
hbox.setStretchFactor(self.mountpointbutton,0)
|
|
self.connect(self.mountpointbutton,SIGNAL("clicked()"),self.slotBrowseMountPointClicked)
|
|
grid.addMultiCellWidget(hbox,row,row,1,3)
|
|
row += 1
|
|
|
|
if allowuuid or allowlabel:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
|
|
label = QLabel(i18n("Device:"),self)
|
|
grid.addWidget(label,row,0)
|
|
|
|
self.devicecheckbox = QRadioButton(i18n("by name"),hbox)
|
|
self.connect(self.devicecheckbox,SIGNAL("clicked()"), \
|
|
self.slotDeviceCheckboxClicked)
|
|
self.devicelineedit = KLineEdit(hbox)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
example = QLabel(self.deviceexample,self)
|
|
grid.addWidget(example,row,1)
|
|
row += 1
|
|
|
|
if allowuuid and self.showuuid:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.uuidcheckbox = QRadioButton(i18n("by UUID"),hbox)
|
|
self.connect(self.uuidcheckbox,SIGNAL("clicked()"), \
|
|
self.slotUUIDCheckboxClicked)
|
|
self.uuidlineedit = KLineEdit(hbox)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
|
|
if allowlabel and self.showlabel:
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.labelcheckbox = QRadioButton(i18n("by label"),hbox)
|
|
self.connect(self.labelcheckbox,SIGNAL("clicked()"), \
|
|
self.slotLabelCheckboxClicked)
|
|
self.labellineedit = KLineEdit(hbox)
|
|
grid.addWidget(hbox,row,1)
|
|
row += 1
|
|
|
|
else:
|
|
|
|
label = QLabel(i18n("Device:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.devicelineedit = KLineEdit(self)
|
|
grid.addMultiCellWidget(self.devicelineedit,row,row,1,3)
|
|
row += 1
|
|
|
|
example = QLabel(self.deviceexample,self)
|
|
grid.addWidget(example,row,1)
|
|
row += 1
|
|
|
|
self.autocheckbox = QCheckBox(i18n("Enable at start up"),self)
|
|
grid.addMultiCellWidget(self.autocheckbox,row,row,1,3)
|
|
row += 1
|
|
|
|
# Security & Safety line.
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
tmplabel = QLabel(hbox)
|
|
tmplabel.setPixmap(UserIcon("hi16-lock"))
|
|
hbox.setStretchFactor(tmplabel,0)
|
|
tmplabel = QLabel(hbox)
|
|
tmplabel.setText(i18n("Security & Safety"))
|
|
hbox.setStretchFactor(tmplabel,0)
|
|
sep = KSeparator(KSeparator.Horizontal,hbox)
|
|
hbox.setStretchFactor(sep,1)
|
|
grid.addMultiCellWidget(hbox,row,row,0,3)
|
|
row += 1
|
|
|
|
self.writeablecheckbox = QCheckBox(i18n("Writeable"),self)
|
|
grid.addMultiCellWidget(self.writeablecheckbox,row,row,1,3)
|
|
row += 1
|
|
|
|
label = QLabel(i18n("Files belong to user:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.uidcombobox = UserComboBox(self)
|
|
grid.addMultiCellWidget(self.uidcombobox,row,row,1,3)
|
|
row += 1
|
|
|
|
label = QLabel(i18n("Files belong to group:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.gidcombobox = GroupComboBox(self)
|
|
grid.addMultiCellWidget(self.gidcombobox,row,row,1,3)
|
|
row += 1
|
|
|
|
label = QLabel(i18n("Mount Permission:"),self)
|
|
grid.addWidget(label,row,0)
|
|
self.usermountcombobox = KComboBox(self)
|
|
self.usermountcombobox.insertItem(i18n("Root user only may enable/disable"))
|
|
self.usermountcombobox.insertItem(i18n("One user at a time may enable/disable"))
|
|
self.usermountcombobox.insertItem(i18n("Any user may enable/disable anytime"))
|
|
self.usermountcombobox.insertItem(i18n("Device owner may enable/disable"))
|
|
grid.addMultiCellWidget(self.usermountcombobox,row,row,1,3)
|
|
row += 1
|
|
|
|
self.suppresspermissionerrorcheckbox = QCheckBox(i18n("Suppress permission errors"),self)
|
|
grid.addMultiCellWidget(self.suppresspermissionerrorcheckbox,row,row,1,3)
|
|
row += 1
|
|
|
|
row += 1
|
|
button = KPushButton(i18n("Advanced..."),self)
|
|
button.setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed)
|
|
self.connect(button,SIGNAL("clicked()"),self.slotAdvancedClicked)
|
|
grid.addMultiCellWidget(button,row,row,1,3,Qt.AlignRight)
|
|
|
|
########################################################################
|
|
def displayMountEntry(self,entry):
|
|
global allowuuid, allowlabel
|
|
|
|
uuid = entry.getUUID()
|
|
if entry.getDevice() == "" and uuid != "":
|
|
device = microhal.getDeviceByUUID(uuid)
|
|
self.devicelineedit.setText(uuid)
|
|
else:
|
|
self.devicelineedit.setText(entry.getDevice())
|
|
|
|
if allowuuid:
|
|
self.uuidlineedit.setText(uuid)
|
|
if entry.getUUID()!="":
|
|
self.uuidlineedit.setEnabled(True)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.uuidcheckbox.setChecked(True)
|
|
else:
|
|
self.devicelineedit.setEnabled(True)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(True)
|
|
self.uuidcheckbox.setChecked(False)
|
|
|
|
if allowlabel: # If the filesystem has a label override the UUID settings
|
|
self.labellineedit.setText(entry.getLabel())
|
|
if entry.getLabel()!="":
|
|
self.labellineedit.setEnabled(True)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.labelcheckbox.setChecked(True)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.uuidcheckbox.setChecked(False)
|
|
else:
|
|
if entry.getUUID()!="":
|
|
self.uuidlineedit.setEnabled(True)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.uuidcheckbox.setChecked(True)
|
|
else:
|
|
self.devicelineedit.setEnabled(True)
|
|
self.uuidlineedit.setEnabled(False)
|
|
self.devicecheckbox.setChecked(True)
|
|
self.uuidcheckbox.setChecked(False)
|
|
|
|
if allowlabel:
|
|
self.labellineedit.setText(entry.getLabel())
|
|
if allowuuid:
|
|
self.uuidlineedit.setText(entry.getUUID())
|
|
self.devicelineedit.setText(entry.getDevice())
|
|
|
|
self.mountpointlineedit.setText(entry.getMountPoint())
|
|
self.options = entry.getExtraOptions()
|
|
self.fsfreq = entry.getFSFreq()
|
|
self.fspassno = entry.getFSPassno()
|
|
self.writeablecheckbox.setChecked(entry.getWritable())
|
|
self.autocheckbox.setChecked(entry.getMountAtBoot())
|
|
self.usermountcombobox.setCurrentItem(entry.getAllowUserMount())
|
|
self.uidcombobox.setUID(entry.getUID())
|
|
self.gidcombobox.setGID(entry.getGID())
|
|
self.suppresspermissionerrorcheckbox.setChecked(entry.getSuppressPermissionErrors())
|
|
|
|
########################################################################
|
|
def undisplayMountEntry(self,entry):
|
|
global allowuuid, allowlabel
|
|
if allowuuid:
|
|
if self.devicecheckbox.isChecked():
|
|
entry.setUUID(None)
|
|
else:
|
|
if allowlabel:
|
|
if self.labelcheckbox.isChecked():
|
|
entry.setLabel( unicode(self.labellineedit.text()) )
|
|
else:
|
|
entry.setUUID( unicode(self.uuidlineedit.text()) )
|
|
else:
|
|
entry.setUUID( unicode(self.uuidlineedit.text()) )
|
|
|
|
if allowlabel:
|
|
if self.devicecheckbox.isChecked():
|
|
entry.setLabel(None)
|
|
else:
|
|
if allowuuid:
|
|
if self.uuidcheckbox.isChecked():
|
|
entry.setUUID( unicode(self.uuidlineedit.text()) )
|
|
else:
|
|
entry.setLabel( unicode(self.labellineedit.text()) )
|
|
else:
|
|
entry.setLabel( unicode(self.labellineedit.text()) )
|
|
|
|
entry.setDevice( unicode(self.devicelineedit.text()) )
|
|
|
|
entry.setMountPoint( unicode(self.mountpointlineedit.text()) )
|
|
entry.setExtraOptions(self.options)
|
|
entry.setFSFreq(self.fsfreq)
|
|
entry.setFSPassno(self.fspassno)
|
|
entry.setMountAtBoot(self.autocheckbox.isChecked())
|
|
entry.setWritable(self.writeablecheckbox.isChecked())
|
|
entry.setAllowUserMount(self.usermountcombobox.currentItem())
|
|
entry.setUID(self.uidcombobox.UID())
|
|
entry.setGID(self.gidcombobox.GID())
|
|
entry.setSuppressPermissionErrors(self.suppresspermissionerrorcheckbox.isChecked())
|
|
|
|
########################################################################
|
|
def slotAdvancedClicked(self):
|
|
(self.options, self.fsfreq, self.fspassno)\
|
|
= self.advanceddialog.do(self.options, self.fsfreq, self.fspassno)
|
|
|
|
########################################################################
|
|
def slotDeviceCheckboxClicked(self):
|
|
self.uuidcheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(True)
|
|
self.uuidlineedit.setEnabled(False)
|
|
|
|
########################################################################
|
|
def slotUUIDCheckboxClicked(self):
|
|
if self.uuidlineedit.text() == "":
|
|
label = microhal.getUUIDByDevice(unicode(self.devicelineedit.text()))
|
|
self.uuidlineedit.setText(label)
|
|
self.devicecheckbox.setChecked(False)
|
|
self.devicelineedit.setEnabled(False)
|
|
self.uuidlineedit.setEnabled(True)
|
|
|
|
############################################################################
|
|
class MountEntryDialogOptionsSMB(MountEntryDialogOptions):
|
|
|
|
########################################################################
|
|
def __init__(self,parent):
|
|
MountEntryDialogOptions.__init__(self,parent)
|
|
self.advanceddialog = MountEntryAdvancedPlainDialog(None)
|
|
self.updatinggui= False
|
|
|
|
########################################################################
|
|
def _fillPage(self):
|
|
grid = QGridLayout(self,14,4)
|
|
grid.setSpacing(KDialog.spacingHint())
|
|
grid.setColStretch(0,0)
|
|
grid.setColStretch(2,0)
|
|
grid.setRowStretch(12,1)
|
|
|
|
label = QLabel(i18n("Mount Point:"),self)
|
|
grid.addWidget(label,0,0)
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.mountpointlineedit = KLineEdit(hbox)
|
|
hbox.setStretchFactor(self.mountpointlineedit,1)
|
|
#self.connect(self.homediredit, SIGNAL("textChanged(const QString &)"), self.slotHomeDirChanged)
|
|
self.mountpointbutton = KPushButton(i18n("Browse..."),hbox)
|
|
hbox.setStretchFactor(self.mountpointbutton,0)
|
|
self.connect(self.mountpointbutton,SIGNAL("clicked()"),self.slotBrowseMountPointClicked)
|
|
grid.addMultiCellWidget(hbox,0,0,1,3)
|
|
|
|
label = QLabel(i18n("Network Share:"),self)
|
|
grid.addWidget(label,1,0)
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
self.devicelineedit = KLineEdit(hbox)
|
|
hbox.setStretchFactor(self.devicelineedit,1)
|
|
self.devicelinebutton = KPushButton(i18n("Scan..."),hbox)
|
|
hbox.setStretchFactor(self.devicelinebutton,0)
|
|
self.connect(self.devicelinebutton,SIGNAL("clicked()"),self.slotBrowseDeviceLineClicked)
|
|
grid.addMultiCellWidget(hbox,1,1,1,3)
|
|
|
|
# Connect as:
|
|
connectaslabel = QLabel(self)
|
|
connectaslabel.setText(i18n("Connect as:"))
|
|
grid.addWidget(connectaslabel,2,0)
|
|
|
|
self.guestradio = QRadioButton(self)
|
|
self.guestradio.setChecked(True)
|
|
grid.addWidget(self.guestradio,2,1)
|
|
tmplabel = QLabel(self)
|
|
tmplabel.setText(i18n("Guest"))
|
|
grid.addMultiCellWidget(tmplabel,2,2,2,3)
|
|
self.connect(self.guestradio,SIGNAL("stateChanged(int)"),self.slotGuestRadioClicked)
|
|
|
|
self.userradio = QRadioButton(self)
|
|
grid.addWidget(self.userradio,3,1)
|
|
tmplabel = QLabel(self)
|
|
tmplabel.setText(i18n("Username:"))
|
|
grid.addWidget(tmplabel,3,2)
|
|
self.connect(self.userradio,SIGNAL("stateChanged(int)"),self.slotUserRadioClicked)
|
|
|
|
self.usernameedit = KLineEdit(self)
|
|
grid.addWidget(self.usernameedit,3,3)
|
|
|
|
tmplabel = QLabel(self)
|
|
tmplabel.setText(i18n("Password:"))
|
|
grid.addWidget(tmplabel,4,2)
|
|
|
|
self.passwordedit = KLineEdit(self)
|
|
grid.addWidget(self.passwordedit,4,3)
|
|
|
|
self.autocheckbox = QCheckBox(i18n("Enable at start up"),self)
|
|
grid.addMultiCellWidget(self.autocheckbox,5,5,1,3)
|
|
|
|
# Security & Safety line.
|
|
hbox = QHBox(self)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
tmplabel = QLabel(hbox)
|
|
tmplabel.setPixmap(UserIcon("hi16-lock"))
|
|
hbox.setStretchFactor(tmplabel,0)
|
|
tmplabel = QLabel(hbox)
|
|
tmplabel.setText(i18n("Security & Safety"))
|
|
hbox.setStretchFactor(tmplabel,0)
|
|
sep = KSeparator(KSeparator.Horizontal,hbox)
|
|
hbox.setStretchFactor(sep,1)
|
|
grid.addMultiCellWidget(hbox,6,6,0,3)
|
|
|
|
self.writeablecheckbox = QCheckBox(i18n("Writeable"),self)
|
|
grid.addMultiCellWidget(self.writeablecheckbox,7,7,1,3)
|
|
|
|
label = QLabel(i18n("Files belong to user:"),self)
|
|
grid.addWidget(label,8,0)
|
|
self.uidcombobox = UserComboBox(self)
|
|
grid.addMultiCellWidget(self.uidcombobox,8,8,1,3)
|
|
|
|
label = QLabel(i18n("Files belong to group:"),self)
|
|
grid.addWidget(label,9,0)
|
|
self.gidcombobox = GroupComboBox(self)
|
|
grid.addMultiCellWidget(self.gidcombobox,9,9,1,3)
|
|
|
|
label = QLabel(i18n("Mount Permission:"),self)
|
|
grid.addWidget(label,10,0)
|
|
self.usermountcombobox = KComboBox(self)
|
|
self.usermountcombobox.insertItem(i18n("Root user only may enable/disable"))
|
|
self.usermountcombobox.insertItem(i18n("One user at a time may enable/disable"))
|
|
self.usermountcombobox.insertItem(i18n("Any user may enable/disable anytime"))
|
|
self.usermountcombobox.insertItem(i18n("Device owner may enable/disable"))
|
|
grid.addMultiCellWidget(self.usermountcombobox,10,10,1,3)
|
|
|
|
button = KPushButton(i18n("Advanced..."),self)
|
|
button.setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed)
|
|
self.connect(button,SIGNAL("clicked()"),self.slotAdvancedClicked)
|
|
grid.addMultiCellWidget(button,13,13,1,3,Qt.AlignRight)
|
|
|
|
self.selectsmbdialog = None
|
|
|
|
########################################################################
|
|
def slotBrowseDeviceLineClicked(self):
|
|
if self.updatinggui:
|
|
return
|
|
self.updatinggui = True
|
|
|
|
if self.selectsmbdialog is None:
|
|
self.selectsmbdialog = SMBShareSelectDialog(None)
|
|
|
|
# This just converts a \\zootv\data\ share name to smb:/zootv/data
|
|
parts = [x.replace("/",'\\') for x in unicode(self.devicelineedit.text()).split('\\') if x!=""]
|
|
oldurl = u"smb:/"+("/".join(parts) )
|
|
|
|
urlobj = KURL(oldurl)
|
|
if self.userradio.isChecked():
|
|
urlobj.setUser(self.usernameedit.text())
|
|
urlobj.setPass(self.passwordedit.text())
|
|
|
|
newurlobj = self.selectsmbdialog.choose(urlobj)
|
|
# This just converts smb:/zootv/data to \\zootv\data.
|
|
plainurl = KURL(newurlobj)
|
|
plainurl.setUser(QString.null)
|
|
plainurl.setPass(QString.null)
|
|
parts = [x.replace('\\',"/") for x in unicode(plainurl.url())[4:].split("/") if x !=""]
|
|
#convert the first part to an IP address
|
|
nmboutput = subprocess.Popen(["nmblookup",parts[0]], stdout=subprocess.PIPE).stdout
|
|
nmboutput.readline()
|
|
ipaddress = nmboutput.readline().split(" ")[0]
|
|
parts[0] = ipaddress
|
|
self.devicelineedit.setText(r'\\'+('\\'.join(parts)))
|
|
|
|
if not newurlobj.hasUser():
|
|
self.guestradio.setChecked(True)
|
|
self.userradio.setChecked(False)
|
|
self.passwordedit.setEnabled(False)
|
|
self.usernameedit.setEnabled(False)
|
|
self.usernameedit.setText("")
|
|
self.passwordedit.setText("")
|
|
else:
|
|
self.guestradio.setChecked(False)
|
|
self.userradio.setChecked(True)
|
|
self.passwordedit.setEnabled(True)
|
|
self.usernameedit.setEnabled(True)
|
|
self.usernameedit.setText(newurlobj.user())
|
|
self.passwordedit.setText(newurlobj.pass_())
|
|
|
|
self.updatinggui = False
|
|
|
|
########################################################################
|
|
def displayMountEntry(self,entry):
|
|
self.devicelineedit.setText(entry.getDevice())
|
|
self.mountpointlineedit.setText(entry.getMountPoint())
|
|
self.options = entry.getExtraOptions()
|
|
self.fsfreq = entry.getFSFreq()
|
|
self.fspassno = entry.getFSPassno()
|
|
self.writeablecheckbox.setChecked(entry.getWritable())
|
|
self.autocheckbox.setChecked(entry.getMountAtBoot())
|
|
self.usermountcombobox.setCurrentItem(entry.getAllowUserMount())
|
|
self.uidcombobox.setUID(entry.getUID())
|
|
self.gidcombobox.setGID(entry.getGID())
|
|
|
|
if entry.getUsername() is None:
|
|
self.guestradio.setChecked(True)
|
|
self.userradio.setChecked(False)
|
|
self.passwordedit.setEnabled(False)
|
|
self.usernameedit.setEnabled(False)
|
|
self.usernameedit.setText("")
|
|
self.passwordedit.setText("")
|
|
else:
|
|
self.guestradio.setChecked(False)
|
|
self.userradio.setChecked(True)
|
|
self.passwordedit.setEnabled(True)
|
|
self.usernameedit.setEnabled(True)
|
|
self.usernameedit.setText(entry.getUsername())
|
|
self.passwordedit.setText(entry.getPassword())
|
|
|
|
########################################################################
|
|
def undisplayMountEntry(self,entry):
|
|
entry.setDevice( unicode(self.devicelineedit.text()) )
|
|
entry.setMountPoint( unicode(self.mountpointlineedit.text()) )
|
|
entry.setExtraOptions(self.options)
|
|
entry.setFSFreq(self.fsfreq)
|
|
entry.setFSPassno(self.fspassno)
|
|
entry.setMountAtBoot(self.autocheckbox.isChecked())
|
|
entry.setWritable(self.writeablecheckbox.isChecked())
|
|
entry.setAllowUserMount(self.usermountcombobox.currentItem())
|
|
entry.setUID(self.uidcombobox.UID())
|
|
entry.setGID(self.gidcombobox.GID())
|
|
|
|
if self.guestradio.isChecked():
|
|
entry.setUsername(None)
|
|
entry.setPassword(None)
|
|
else:
|
|
entry.setUsername( unicode(self.usernameedit.text()) )
|
|
entry.setPassword( unicode(self.passwordedit.text()) )
|
|
|
|
########################################################################
|
|
def slotAdvancedClicked(self):
|
|
(self.options, self.fsfreq, self.fspassno)\
|
|
= self.advanceddialog.do(self.options, self.fsfreq, self.fspassno)
|
|
|
|
########################################################################
|
|
def slotGuestRadioClicked(self,state):
|
|
if self.updatinggui:
|
|
return
|
|
self.updatinggui = True
|
|
|
|
if state==QButton.Off:
|
|
self.guestradio.setChecked(True)
|
|
self.userradio.setChecked(False)
|
|
|
|
self.passwordedit.setEnabled(False)
|
|
self.usernameedit.setEnabled(False)
|
|
|
|
self.updatinggui = False
|
|
|
|
########################################################################
|
|
def slotUserRadioClicked(self,state):
|
|
if self.updatinggui:
|
|
return
|
|
self.updatinggui = True
|
|
if state==QButton.Off:
|
|
self.userradio.setChecked(True)
|
|
self.guestradio.setChecked(False)
|
|
|
|
self.passwordedit.setEnabled(True)
|
|
self.usernameedit.setEnabled(True)
|
|
|
|
self.updatinggui = False
|
|
|
|
############################################################################
|
|
class ROListBoxItem(QListBoxPixmap):
|
|
"""A read-only ListBox item that also uses the 'alternate' background colour
|
|
as background.
|
|
"""
|
|
def __init__(self,listbox,pix,text):
|
|
QListBoxPixmap.__init__(self,listbox,pix,text)
|
|
self.setSelectable(False)
|
|
def paint(self,p):
|
|
boldfont = QFont(p.font())
|
|
boldfont.setWeight(QFont.Bold)
|
|
p.setFont(boldfont)
|
|
p.setBackgroundColor(KGlobalSettings.alternateBackgroundColor())
|
|
p.eraseRect(0,0,self.listBox().width(),self.height(self.listBox()))
|
|
QListBoxPixmap.paint(self,p)
|
|
|
|
############################################################################
|
|
class MountEntryDialog(KDialogBase):
|
|
|
|
MountTypeEditorsDisk = {
|
|
'ext2' : MountEntryDialogOptionsCommonUnix,
|
|
'ext3' : MountEntryDialogOptionsCommonUnix,
|
|
'reiserfs' : MountEntryDialogOptionsCommonUnix,
|
|
'reiser4' : MountEntryDialogOptionsCommonUnix,
|
|
'xfs' : MountEntryDialogOptionsCommonUnix,
|
|
'jfs' : MountEntryDialogOptionsCommonUnix,
|
|
'vfat' : MountEntryDialogOptionsVFAT,
|
|
'ntfs' : MountEntryDialogOptionsVFAT,
|
|
'hfsplus' : MountEntryDialogOptionsVFAT,
|
|
'udf' : MountEntryDialogOptions,
|
|
'iso9660' : MountEntryDialogOptions,
|
|
}
|
|
MountTypeEditorsNetwork = {
|
|
'nfs' : MountEntryDialogOptionsNfs,
|
|
'cifs' : MountEntryDialogOptionsSMB,
|
|
}
|
|
MountTypeEditorsSystem = {
|
|
'proc' : MountEntryDialogOptionsSys,
|
|
'sysfs' : MountEntryDialogOptionsSys,
|
|
'rootfs' : MountEntryDialogOptions,
|
|
'bdev' : MountEntryDialogOptions,
|
|
'sockfs' : MountEntryDialogOptions,
|
|
'tmpfs' : MountEntryDialogOptions,
|
|
'shm' : MountEntryDialogOptions,
|
|
'pipefs' : MountEntryDialogOptions,
|
|
'ramfs' : MountEntryDialogOptionsSys,
|
|
'devfs' : MountEntryDialogOptions,
|
|
'devpts' : MountEntryDialogOptionsSys,
|
|
'auto' : MountEntryDialogOptionsCommonUnix,
|
|
'usbdevfs' : MountEntryDialogOptions,
|
|
'procbususb' : MountEntryDialogOptions,
|
|
'usbfs' : MountEntryDialogOptions,
|
|
'supermount' : MountEntryDialogOptions,
|
|
'swap' : MountEntryDialogOptionsSwap
|
|
}
|
|
|
|
########################################################################
|
|
def __init__(self,parent):
|
|
KDialogBase.__init__(self,parent,None,True,"Configuration",KDialogBase.Ok|KDialogBase.Cancel,
|
|
KDialogBase.Cancel)
|
|
|
|
self.updatingGUI = True
|
|
|
|
# Maps MountEntry classes to MountEntryDialogOptions objects
|
|
self.mountTypeToOptionWidget = {}
|
|
|
|
# Maps indexes in the combobox to mounttypes
|
|
self.comboIndexToMountType = []
|
|
self.currentOptionWidget = None
|
|
|
|
self.topvbox = QVBox(self)
|
|
self.setMainWidget(self.topvbox)
|
|
self.topvbox.setSpacing(self.spacingHint())
|
|
|
|
hb = QHBox(self.topvbox)
|
|
hb.setSpacing(self.spacingHint())
|
|
self.topvbox.setStretchFactor(hb,0)
|
|
|
|
label = QLabel(i18n("Type:"),hb)
|
|
hb.setStretchFactor(label,0)
|
|
self.mounttypecombo = KComboBox(hb)
|
|
|
|
# Disk types
|
|
ROListBoxItem(self.mounttypecombo.listBox(),UserIcon("hi16-hdd"),i18n("Disk Filesystems"))
|
|
self.comboIndexToMountType.append(None)
|
|
items = self.MountTypeEditorsDisk.keys()
|
|
items.sort()
|
|
for mounttype in items:
|
|
self.mounttypecombo.insertItem(MountEntry.getMountTypeLongName(mounttype))
|
|
self.comboIndexToMountType.append(mounttype)
|
|
|
|
# Network types
|
|
ROListBoxItem(self.mounttypecombo.listBox(),UserIcon("hi16-network"),i18n("Network Filesystems"))
|
|
self.comboIndexToMountType.append(None)
|
|
items = self.MountTypeEditorsNetwork.keys()
|
|
items.sort()
|
|
for mounttype in items:
|
|
self.mounttypecombo.insertItem(MountEntry.getMountTypeLongName(mounttype))
|
|
self.comboIndexToMountType.append(mounttype)
|
|
|
|
# System types
|
|
ROListBoxItem(self.mounttypecombo.listBox(),UserIcon("hi16-blockdevice"),i18n("Operating System"))
|
|
self.comboIndexToMountType.append(None)
|
|
items = self.MountTypeEditorsSystem.keys()
|
|
items.sort()
|
|
for mounttype in items:
|
|
self.mounttypecombo.insertItem(MountEntry.getMountTypeLongName(mounttype))
|
|
self.comboIndexToMountType.append(mounttype)
|
|
|
|
self.MountTypeEditors = self.MountTypeEditorsDisk.copy()
|
|
self.MountTypeEditors.update(self.MountTypeEditorsNetwork)
|
|
self.MountTypeEditors.update(self.MountTypeEditorsSystem)
|
|
|
|
#hb.setStretchFactor(self.runlevelcombo,0)
|
|
self.connect(self.mounttypecombo, SIGNAL("activated(int)"), self.slotMountTypeChanged)
|
|
|
|
widget = QWidget(hb)
|
|
hb.setStretchFactor(widget,1)
|
|
|
|
# Create the stack of option edit widgets.
|
|
gb = QVGroupBox(self.topvbox)
|
|
self.topvbox.setStretchFactor(gb,1)
|
|
self.optionsstack = QWidgetStack(gb)
|
|
|
|
for mounttype in self.MountTypeEditors:
|
|
editpage = self.MountTypeEditors[mounttype](self.optionsstack)
|
|
self.mountTypeToOptionWidget[mounttype] = editpage
|
|
self.optionsstack.addWidget(editpage)
|
|
|
|
self.fsunavailablelabel = QHBox(gb)
|
|
self.fsunavailablelabel.setSpacing(KDialog.spacingHint())
|
|
tmplabel = QLabel(self.fsunavailablelabel)
|
|
self.fsunavailablelabel.setStretchFactor(tmplabel,0)
|
|
tmplabel.setPixmap(SmallIcon('info'))
|
|
label = QLabel(i18n("This filesystem type is currently unavailable on the running kernel."),
|
|
self.fsunavailablelabel)
|
|
self.fsunavailablelabel.setStretchFactor(label,1)
|
|
self.fsunavailablelabel.hide()
|
|
|
|
self.updatingGUI = False
|
|
|
|
#######################################################################
|
|
def doEditMount(self,mounttable,mountentry):
|
|
self.newEntry = False
|
|
self.mounttable = mounttable
|
|
self.originalMountEntry = mountentry
|
|
self.currentMountEntry = mountentry.copy()
|
|
|
|
self.updatingGUI = True
|
|
self.selectEntry(self.currentMountEntry.getMountType())
|
|
self.updatingGUI = False
|
|
if self.exec_loop()==QDialog.Accepted:
|
|
# All of the update stuff is in slotOk()
|
|
return True
|
|
return False
|
|
|
|
#######################################################################
|
|
def doNewMount(self,mounttable,defaultdevice):
|
|
self.newEntry = True
|
|
self.mounttable = mounttable
|
|
self.currentMountEntry = MountEntry()
|
|
if defaultdevice is not None:
|
|
self.currentMountEntry.setDevice(defaultdevice)
|
|
self.updatingGUI = True
|
|
self.currentOptionWidget = None
|
|
self.selectEntry(self.currentMountEntry.mounttype)
|
|
self.updatingGUI = False
|
|
if self.exec_loop()==QDialog.Accepted:
|
|
self.mounttable.allentries.append(self.currentMountEntry)
|
|
self.mounttable.updateFstabOnDisk()
|
|
return self.currentMountEntry
|
|
return None
|
|
|
|
#######################################################################
|
|
def selectEntry(self,mounttype):
|
|
#if self.currentOptionWidget!=None:
|
|
# # Update the mount entry from the
|
|
# self.currentOptionWidget.undisplayMountEntry(self.currentMountEntry)
|
|
self.currentMountEntry.setMountType(mounttype)
|
|
# Update GUI
|
|
self.mounttypecombo.setCurrentItem(self.comboIndexToMountType.index(mounttype))
|
|
self.currentOptionWidget = self.mountTypeToOptionWidget[mounttype]
|
|
self.currentOptionWidget.displayMountEntry(self.currentMountEntry)
|
|
self.optionsstack.raiseWidget(self.currentOptionWidget)
|
|
if microhal.isSupportedFileSystem(mounttype):
|
|
self.fsunavailablelabel.hide()
|
|
else:
|
|
self.fsunavailablelabel.show()
|
|
|
|
#######################################################################
|
|
def slotMountTypeChanged(self,index):
|
|
if self.updatingGUI==False:
|
|
self.updatingGUI = True
|
|
self.selectEntry(self.comboIndexToMountType[index])
|
|
self.updatingGUI = False
|
|
|
|
#######################################################################
|
|
def slotOk(self):
|
|
global allowlabel, allowuuid
|
|
self.currentOptionWidget.undisplayMountEntry(self.currentMountEntry)
|
|
if allowuuid:
|
|
if self.currentOptionWidget.uuidcheckbox.isChecked():
|
|
self.currentMountEntry.setUseAsDevice("uuid")
|
|
if allowlabel:
|
|
if self.currentOptionWidget.labelcheckbox.isChecked():
|
|
self.currentMountEntry.setUseAsDevice("label")
|
|
conflictentry = None
|
|
if self.newEntry:
|
|
for entry in self.mounttable:
|
|
if entry.getMountPoint()==self.currentMountEntry.getMountPoint():
|
|
# Conflict found.
|
|
conflictentry = entry
|
|
else:
|
|
# Check if the mountpoint is already in use elsewhere in the mounttable.
|
|
if self.originalMountEntry.getMountPoint()!=self.currentMountEntry.getMountPoint():
|
|
for entry in self.mounttable:
|
|
if (entry.getMountPoint()==self.currentMountEntry.getMountPoint()
|
|
and entry is not self.originalMountEntry):
|
|
# Conflict found.
|
|
conflictentry = entry
|
|
if conflictentry is not None:
|
|
if KMessageBox.warningContinueCancel(self, \
|
|
i18n("The mountpoint '%1' is already in use by another entry?\nContinue?").arg(
|
|
self.currentMountEntry.getMountPoint()), \
|
|
i18n("Mountpoint already in use"))!=KMessageBox.Continue:
|
|
return
|
|
|
|
if self.currentMountEntry.getMountType() in MountEntryDialog.MountTypeEditorsDisk.keys():
|
|
# If device is not in /dev and it's no bind mount, ask if that's meant this way ...
|
|
options = self.currentMountEntry.getFstabOptions()
|
|
if (not self.currentMountEntry.getDevice().startswith("/dev/")
|
|
and not ("loop" in options or "bind" in options)):
|
|
ask = KMessageBox.warningYesNoCancel(self,
|
|
i18n("'%1' does not seem to be a device and the option 'bind' has not been specified in the \
|
|
\"Advanced\" page?\n Should I add the 'loop' option?").arg(self.currentMountEntry.device),
|
|
i18n("Options may be missing"))
|
|
if ask==KMessageBox.Cancel:
|
|
return
|
|
elif ask==KMessageBox.Yes:
|
|
# Add loop option
|
|
extraoptions = self.currentMountEntry.getExtraOptions().split(',')
|
|
extraoptions.append('loop')
|
|
self.currentMountEntry.setExtraOptions(','.join(extraoptions))
|
|
|
|
if (not os.path.isdir(self.currentMountEntry.getMountPoint())
|
|
and not os.path.isfile(self.currentMountEntry.getMountPoint())
|
|
and not self.currentMountEntry.mounttype == 'swap'):
|
|
ask = KMessageBox.warningYesNoCancel(self,
|
|
i18n("""The mountpoint '%1' does not exist. You will not be able to enable it until it is created.\
|
|
\nShould I create the mountpoint?""").arg(self.currentMountEntry.getMountPoint()),
|
|
i18n("Mountpoint does not exist"))
|
|
if ask==KMessageBox.Cancel:
|
|
return
|
|
elif ask==KMessageBox.Yes:
|
|
os.mkdir(self.currentMountEntry.getMountPoint())
|
|
elif os.path.isfile(self.currentMountEntry.getMountPoint()):
|
|
if KMessageBox.warningContinueCancel(self,
|
|
i18n("""The mountpoint '%1' is a file, but it has to be a directory. You will probably not \
|
|
be able to enable it.\nContinue?""").arg(self.currentMountEntry.getMountPoint()),
|
|
i18n("Invalid mountpoint"))!=KMessageBox.Continue:
|
|
return
|
|
|
|
if self.newEntry==False:
|
|
# How to Change a Mount Entry.
|
|
# 1. Disable the exisiting entry (if needed)
|
|
# 2. Update existing entry from the mount table.
|
|
# 3. Enable the updated entry (if needed)
|
|
# 4. Write new fstab file.
|
|
# 5. Enable the new entry (if needed)
|
|
|
|
# 1. Disable the exisiting entry (if needed)
|
|
enabled = self.originalMountEntry.isEnabled()
|
|
if enabled:
|
|
self.disablingold = True
|
|
self.originalMountEntry.disable(self)
|
|
self.originalMountEntry.inPlaceCopyFrom(self.currentMountEntry)
|
|
self.mounttable.updateFstabOnDisk()
|
|
if enabled and self.originalMountEntry.isFileSystemAvailable():
|
|
self.originalMountEntry.enable(self)
|
|
self.accept()
|
|
|
|
############################################################################
|
|
class MountEntryAdvancedCommonUnixDialog(KDialogBase):
|
|
########################################################################
|
|
def __init__(self,parent,name=None):
|
|
KDialogBase.__init__(self,parent,name,1,"",KDialogBase.Ok|KDialogBase.Cancel)
|
|
|
|
grid = self.makeGridMainWidget(2,Qt.Horizontal)
|
|
grid.setSpacing(self.spacingHint())
|
|
|
|
QWidget(grid)
|
|
self.accesstimecheckbox = QCheckBox(i18n("Update file access timestamps"),grid)
|
|
|
|
QWidget(grid)
|
|
self.allowexecutablecheckbox = QCheckBox(i18n("Allow Executables"),grid)
|
|
|
|
QWidget(grid)
|
|
self.allowsuidcheckbox = QCheckBox(i18n("Allow the SUID and SGID attributes"),grid)
|
|
|
|
QWidget(grid)
|
|
self.usedevpointscheckbox = QCheckBox(i18n("Allow device points"),grid)
|
|
|
|
label = QLabel(i18n("Options:"),grid)
|
|
self.optionslineedit = KLineEdit(grid)
|
|
|
|
label = QLabel(i18n("fs_freq:"),grid)
|
|
self.fsfreqspinbox = KIntSpinBox (0,1000,1,0,10,grid)
|
|
|
|
label = QLabel(i18n("fs_passno:"),grid)
|
|
self.fspassnospinbox = KIntSpinBox (0,1000,1,0,10,grid)
|
|
|
|
########################################################################
|
|
def do(self,atime,allowexecutable,allowsuid,usedevpoints,options,fsfreq,fspassno):
|
|
|
|
self.accesstimecheckbox.setChecked(atime)
|
|
self.allowexecutablecheckbox.setChecked(allowexecutable)
|
|
self.allowsuidcheckbox.setChecked(allowsuid)
|
|
self.usedevpointscheckbox.setChecked(usedevpoints)
|
|
self.optionslineedit.setText(options)
|
|
self.fsfreqspinbox.setValue(fsfreq)
|
|
self.fspassnospinbox.setValue(fspassno)
|
|
self.exec_loop()
|
|
return ( self.accesstimecheckbox.isChecked(),
|
|
self.allowexecutablecheckbox.isChecked(),
|
|
self.allowsuidcheckbox.isChecked(),
|
|
self.usedevpointscheckbox.isChecked(),
|
|
unicode(self.optionslineedit.text()),
|
|
self.fsfreqspinbox.value(),
|
|
self.fspassnospinbox.value())
|
|
|
|
############################################################################
|
|
class MountEntryAdvancedPlainDialog(KDialogBase):
|
|
########################################################################
|
|
def __init__(self,parent,name=None):
|
|
KDialogBase.__init__(self,parent,name,1,"",KDialogBase.Ok|KDialogBase.Cancel)
|
|
|
|
grid = self.makeGridMainWidget(2,Qt.Horizontal)
|
|
grid.setSpacing(self.spacingHint())
|
|
|
|
label = QLabel(i18n("Options:"),grid)
|
|
self.optionslineedit = KLineEdit(grid)
|
|
|
|
label = QLabel(i18n("fs_freq:"),grid)
|
|
self.fsfreqspinbox = KIntSpinBox (0,1000,1,0,10,grid)
|
|
|
|
label = QLabel(i18n("fs_passno:"),grid)
|
|
self.fspassnospinbox = KIntSpinBox (0,1000,1,0,10,grid)
|
|
|
|
########################################################################
|
|
def do(self,options,fsfreq,fspassno):
|
|
self.optionslineedit.setText(options)
|
|
self.fsfreqspinbox.setValue(fsfreq)
|
|
self.fspassnospinbox.setValue(fspassno)
|
|
self.exec_loop()
|
|
return (unicode(self.optionslineedit.text()), self.fsfreqspinbox.value(), self.fspassnospinbox.value())
|
|
|
|
############################################################################
|
|
class MountListViewItem(KListViewItem):
|
|
########################################################################
|
|
def __init__(self,parentitem,mountentry,haldevice=None):
|
|
self.haldevice = haldevice
|
|
self.mountentry = mountentry
|
|
if self.mountentry is None:
|
|
# There is no mount entry right now. This acts as a place holder
|
|
# for now.
|
|
KListViewItem.__init__(self,parentitem,self.haldevice.getName(),"","",self.haldevice.getDev(),"")
|
|
else:
|
|
if mountentry.isEnabled():
|
|
enabled = i18n("Enabled")
|
|
else:
|
|
enabled = i18n("Disabled")
|
|
if self.haldevice is not None:
|
|
name = self.haldevice.getName()
|
|
else:
|
|
name = self.mountentry.getName()
|
|
KListViewItem.__init__(self, parentitem, \
|
|
name,
|
|
self.mountentry.getMountPoint(), \
|
|
self.mountentry.mounttype, \
|
|
self.mountentry.getDevice(), \
|
|
enabled)
|
|
|
|
if self.mountentry.isEnabled():
|
|
self.setPixmap(4,UserIcon("greenled"))
|
|
else:
|
|
self.setPixmap(4,UserIcon("greyled"))
|
|
self.__updateIcon()
|
|
|
|
########################################################################
|
|
def hasHAL(self):
|
|
return self.haldevice is not None
|
|
|
|
########################################################################
|
|
def getHAL(self): return self.haldevice
|
|
|
|
########################################################################
|
|
def updateDisplay(self):
|
|
if self.mountentry is not None:
|
|
if self.mountentry.isEnabled():
|
|
enabled = i18n("Enabled")
|
|
self.setPixmap(4,UserIcon("greenled"))
|
|
else:
|
|
enabled = i18n("Disabled")
|
|
self.setPixmap(4,UserIcon("greyled"))
|
|
|
|
if self.haldevice is not None:
|
|
self.setText(0,self.haldevice.getName())
|
|
else:
|
|
self.setText(0,self.mountentry.getMountPoint())
|
|
|
|
self.setText(1,self.mountentry.getMountPoint())
|
|
self.setText(2,self.mountentry.mounttype)
|
|
|
|
if self.mountentry.getDevice() is not None:
|
|
self.setText(3,self.mountentry.getDevice())
|
|
else:
|
|
uuid_device = microhal.getDeviceByUUID(self.mountentry.getUUID())
|
|
label_device = microhal.getDeviceByUUID(self.mountentry.getUUID())
|
|
if label_device is not None:
|
|
self.setText(3,label_device.getDev()+" (Label)")
|
|
elif real_device is not None:
|
|
self.setText(3,real_device.getDev()+" (UUID)")
|
|
else:
|
|
self.setText(3,"UUID="+self.mountentry.getUUID())
|
|
|
|
self.setText(4,enabled)
|
|
else:
|
|
self.setText(0,self.haldevice.getName())
|
|
self.setText(1,"")
|
|
self.setText(2,"")
|
|
self.setText(3,self.haldevice.getDev())
|
|
self.setText(4,"")
|
|
self.setPixmap(4,QPixmap())
|
|
self.__updateIcon()
|
|
|
|
########################################################################
|
|
def setMountEntry(self,entry):
|
|
self.mountentry = entry
|
|
self.updateDisplay()
|
|
|
|
########################################################################
|
|
def getMountEntry(self):
|
|
return self.mountentry
|
|
|
|
########################################################################
|
|
def getDevice(self): return self.haldevice.getDev()
|
|
|
|
########################################################################
|
|
|
|
def __updateIcon(self):
|
|
if self.haldevice is not None:
|
|
self.setPixmap(0,UserIcon(self.haldevice.iconname))
|
|
else:
|
|
self.setPixmap(0,UserIcon(self.mountentry.getIconName()))
|
|
|
|
############################################################################
|
|
class MountGroupListViewItem(KListViewItem):
|
|
########################################################################
|
|
def __init__(self,parentitem,haldevice):
|
|
self.haldevice = haldevice
|
|
KListViewItem.__init__(self,parentitem,self.haldevice.getName(),"","","","")
|
|
|
|
if self.haldevice is not None:
|
|
iconname = self.haldevice.iconname
|
|
else:
|
|
iconname = self.mountentry.getIconName()
|
|
self.setPixmap(0,UserIcon(iconname))
|
|
|
|
########################################################################
|
|
def getMountEntry(self):
|
|
return None
|
|
|
|
########################################################################
|
|
def updateDisplay(self):
|
|
pass
|
|
|
|
def hasHAL(self):
|
|
return False
|
|
|
|
############################################################################
|
|
# Try translating this code to C++. I dare ya!
|
|
if standalone:
|
|
programbase = KDialogBase
|
|
else:
|
|
programbase = KCModule
|
|
|
|
class MountConfigApp(programbase):
|
|
########################################################################
|
|
def __init__(self,parent=None,name=None):
|
|
global standalone,isroot
|
|
KGlobal.locale().insertCatalogue("guidance")
|
|
|
|
if standalone:
|
|
KDialogBase.__init__(self,KJanusWidget.Plain,i18n("Disk & Filesystems"),
|
|
KDialogBase.User1|KDialogBase.Close, KDialogBase.Close)
|
|
self.setButtonText(KDialogBase.User1,i18n("About"))
|
|
topwidget = self.plainPage()
|
|
else:
|
|
KCModule.__init__(self,parent,name)
|
|
self.setButtons(0)
|
|
self.aboutdata = MakeAboutData()
|
|
topwidget = self
|
|
|
|
# Create a configuration object.
|
|
self.config = KConfig("mountconfigrc")
|
|
|
|
KGlobal.iconLoader().addAppDir("guidance")
|
|
self.updatingGUI = False
|
|
self.mounttable = MountTable('/etc/fstab','/etc/mtab')
|
|
self.selectedentry = None
|
|
self.aboutus = KAboutApplication(self)
|
|
self.sizeviewdialogs = {}
|
|
toplayout = QVBoxLayout(topwidget, 0, KDialog.spacingHint())
|
|
#topwidget.setEnabled(isroot)
|
|
|
|
hb = QHBox(topwidget)
|
|
hb.setSpacing(KDialog.spacingHint())
|
|
#if standalone:
|
|
# hb.setMargin(KDialog.marginHint())
|
|
|
|
toplayout.addWidget(hb)
|
|
|
|
label = QLabel(hb)
|
|
label.setPixmap(UserIcon("kcmpartitions"))
|
|
hb.setStretchFactor(label,0)
|
|
|
|
label = QLabel(i18n("Available Disks and Filesystems:"),hb)
|
|
hb.setStretchFactor(label,1)
|
|
|
|
self.mountlist = KListView(topwidget,"Mount list")
|
|
toplayout.addWidget(self.mountlist)
|
|
self.mountlist.addColumn(i18n("Name"))
|
|
self.mountlist.addColumn(i18n("Mount Point"))
|
|
self.mountlist.addColumn(i18n("Type"))
|
|
self.mountlist.addColumn(i18n("Device"))
|
|
self.mountlist.addColumn(i18n("Enabled"))
|
|
self.mountlist.setAllColumnsShowFocus(True)
|
|
self.mountlist.setSelectionMode(QListView.Single)
|
|
self.mountlist.setRootIsDecorated(True)
|
|
self.mountlist.setSorting(-1)
|
|
self.connect(self.mountlist, SIGNAL("selectionChanged(QListViewItem *)"), self.slotListClicked)
|
|
# Doubleclick in item opens modify dialogue.
|
|
self.connect(self.mountlist, SIGNAL("doubleClicked(QListViewItem *)"), self.slotModifyClicked)
|
|
# Rightclick: Open ContextMenu
|
|
self.connect(self.mountlist, SIGNAL("contextMenu(KListView*,QListViewItem*,const QPoint&)"),
|
|
self.slotContextMenu)
|
|
|
|
hbox = QHBox(topwidget)
|
|
toplayout.addWidget(hbox)
|
|
hbox.setSpacing(KDialog.spacingHint())
|
|
|
|
toplayout.setStretchFactor(hbox,0)
|
|
self.newbutton = KPushButton(i18n("New..."),hbox)
|
|
hbox.setStretchFactor(self.newbutton,1)
|
|
self.connect(self.newbutton,SIGNAL("clicked()"),self.slotNewClicked)
|
|
self.newbutton.setEnabled(isroot)
|
|
|
|
self.modifybutton = KPushButton(i18n("Modify..."),hbox)
|
|
hbox.setStretchFactor(self.modifybutton,1)
|
|
self.connect(self.modifybutton,SIGNAL("clicked()"),self.slotModifyClicked)
|
|
|
|
self.deletebutton = KPushButton(i18n("Delete..."),hbox)
|
|
hbox.setStretchFactor(self.deletebutton,1)
|
|
self.connect(self.deletebutton,SIGNAL("clicked()"),self.slotDeleteClicked)
|
|
|
|
self.enablebutton = KPushButton(i18n("Enable"),hbox)
|
|
hbox.setStretchFactor(self.enablebutton,1)
|
|
self.connect(self.enablebutton,SIGNAL("clicked()"),self.slotEnableClicked)
|
|
|
|
self.disablebutton = KPushButton(i18n("Disable"),hbox)
|
|
hbox.setStretchFactor(self.disablebutton,1)
|
|
self.connect(self.disablebutton,SIGNAL("clicked()"),self.slotDisableClicked)
|
|
|
|
self.detailsbutton = KPushButton(i18n("Details..."),hbox)
|
|
hbox.setStretchFactor(self.detailsbutton,1)
|
|
self.connect(self.detailsbutton,SIGNAL("clicked()"),self.slotDetailsClicked)
|
|
|
|
self.devstolistitems = None
|
|
self.uuidstolistitems = None
|
|
self.mountentriestolistitems = None
|
|
self.__updateMountList()
|
|
self.__selectEntry(self.mounttable[0])
|
|
|
|
self.configuredialog = MountEntryDialog(None)
|
|
|
|
########################################################################
|
|
def exec_loop(self):
|
|
global programbase
|
|
self.__loadOptions()
|
|
programbase.exec_loop(self)
|
|
self.__saveOptions()
|
|
|
|
########################################################################
|
|
def slotContextMenu(self,lv,lv_item,p):
|
|
|
|
hal_device = lv_item.haldevice
|
|
if hal_device is not None and not isinstance(hal_device,MicroHAL.FakeSystemDevice):
|
|
|
|
self.cmenu = KPopupMenu(self,"MyActions")
|
|
if isinstance(hal_device,MicroHAL.RemovableDisk) or isinstance(lv_item,MountListViewItem):
|
|
self.cmenu.insertItem(i18n("Modify..."), self.slotModifyClicked, 0, 0)
|
|
self.cmenu.insertItem(i18n("Delete..."), self.slotDeleteClicked, 0, 1)
|
|
if not isroot:
|
|
self.cmenu.setItemEnabled(0,False)
|
|
self.cmenu.setItemEnabled(1,False)
|
|
elif isinstance(hal_device,MicroHAL.Disk) or isinstance(hal_device,MicroHAL.USBDisk):
|
|
self.cmenu.insertItem(i18n("Show details..."), self.slotDetailsClicked, 0, 0)
|
|
self.cmenu.insertItem(i18n("New..."), self.slotNewClicked, 0, 1)
|
|
if not isroot:
|
|
self.cmenu.setItemEnabled(1,False)
|
|
|
|
self.cmenu.exec_loop(p)
|
|
|
|
########################################################################
|
|
def slotUser1(self):
|
|
self.aboutus.show()
|
|
|
|
########################################################################
|
|
def slotEnableClicked(self):
|
|
if self.selectedentry!=None:
|
|
self.selectedentry.enable(self)
|
|
self.mounttable.updateStatus(self.selectedentry)
|
|
self.__updateEntry(self.selectedentry)
|
|
self.enablebutton.setEnabled(not self.selectedentry.isEnabled())
|
|
self.disablebutton.setEnabled(self.selectedentry.isEnabled())
|
|
|
|
########################################################################
|
|
def slotDisableClicked(self):
|
|
if self.selectedentry!=None:
|
|
self.__disableEntry()
|
|
|
|
########################################################################
|
|
def slotModifyClicked(self):
|
|
global isroot
|
|
if not isroot:
|
|
return
|
|
|
|
if self.selectedentry!=None:
|
|
self.configuredialog.doEditMount(self.mounttable,self.selectedentry)
|
|
|
|
lvi = self.mountentriestolistitems[self.selectedentry]
|
|
if lvi.hasHAL():
|
|
if lvi.getHAL().getDev()!=self.selectedentry.getDevice():
|
|
# The (device-)item in the listview no longer matches this mount entry.
|
|
del self.mountentriestolistitems[self.selectedentry]
|
|
lvi.setMountEntry(None)
|
|
lvi.updateDisplay()
|
|
# Reinsert this mount entry into the list view.
|
|
self.__insertMountEntryIntoListView(self.selectedentry)
|
|
|
|
elif self.selectedentry.getDevice() is not None \
|
|
and self.selectedentry.getDevice() in self.devstolistitems:
|
|
# The mount entry can now merged with any existing (HAL-)item.
|
|
# Remove the existing lose item.
|
|
self.mountlist.takeItem(lvi)
|
|
del self.mountentriestolistitems[self.selectedentry]
|
|
del self.devstolistitems[self.selectedentry.getDevice()]
|
|
del lvi
|
|
# Reinsert this mount entry into the list view.
|
|
self.__insertMountEntryIntoListView(self.selectedentry)
|
|
|
|
elif self.selectedentry.getUUID() is not None \
|
|
and self.selectedentry.getUUID() in self.uuidstolistitems:
|
|
# The mount entry can now merged with any existing (HAL-)item.
|
|
# Remove the existing lose item.
|
|
self.mountlist.takeItem(lvi)
|
|
del self.mountentriestolistitems[self.selectedentry]
|
|
del self.uuidstolistitems[self.selectedentry.getUUID()]
|
|
del lvi
|
|
# Reinsert this mount entry into the list view.
|
|
self.__insertMountEntryIntoListView(self.selectedentry)
|
|
|
|
self.__updateEntry(self.selectedentry)
|
|
self.__selectEntry(self.selectedentry)
|
|
else:
|
|
self.slotNewClicked()
|
|
|
|
########################################################################
|
|
def slotNewClicked(self):
|
|
defaultdevice = None
|
|
if self.selectedentry is None:
|
|
lvi = self.mountlist.selectedItem()
|
|
if lvi is not None and lvi.hasHAL() and (lvi.getMountEntry() is None):
|
|
defaultdevice = lvi.getDevice()
|
|
newentry = self.configuredialog.doNewMount(self.mounttable,defaultdevice)
|
|
if newentry!=None:
|
|
self.updatingGUI = True
|
|
self.__insertMountEntryIntoListView(newentry)
|
|
self.__selectEntry(newentry)
|
|
self.updatingGUI = False
|
|
|
|
########################################################################
|
|
def slotDeleteClicked(self):
|
|
if self.selectedentry!=None:
|
|
if self.selectedentry.isEnabled():
|
|
if not self.__disableEntry():
|
|
return # If we couldn't disable it, then we can't continue.
|
|
message = i18n("Are you sure you want to delete mount '%1' of type %2 at '%3'?\n " +
|
|
"(This will only remove the mount, no data will be deleted.)") \
|
|
.arg(self.selectedentry.getMountPoint()).arg(self.selectedentry.mounttype).arg(
|
|
self.selectedentry.getDevice())
|
|
if KMessageBox.warningYesNo(self,message,i18n("Delete Mount?"))==KMessageBox.Yes:
|
|
lvi = self.mountentriestolistitems[self.selectedentry]
|
|
if not lvi.hasHAL():
|
|
self.mountlist.takeItem(lvi)
|
|
del lvi
|
|
del self.mountentriestolistitems[self.selectedentry]
|
|
else:
|
|
lvi.setMountEntry(None)
|
|
self.mounttable.remove(self.selectedentry)
|
|
self.mounttable.updateFstabOnDisk()
|
|
self.__selectEntry(None)
|
|
|
|
########################################################################
|
|
def slotDetailsClicked(self):
|
|
# Popup a dialog showing disklayout and a graphical represenation of 'df'
|
|
hal_device = self.mountlist.selectedItem().haldevice
|
|
if isinstance(hal_device,MicroHAL.Disk):
|
|
blk = hal_device.getDev()
|
|
devicepath, devicename = ('/'.join(blk.split('/')[0:-1])+'/', blk.split('/')[-1])
|
|
# We keep a dict with those widgets, that saves us some time reading out all the values.
|
|
if devicename not in self.sizeviewdialogs.keys():
|
|
self.sizeviewdialogs[devicename] = sizeview.SizeView(self,devicename,devicepath)
|
|
self.sizeviewdialogs[devicename].exec_loop()
|
|
else:
|
|
self.sizeviewdialogs[devicename].exec_loop()
|
|
else:
|
|
print "Sizeview doesn't support",blk.__class__," yet."
|
|
|
|
########################################################################
|
|
def slotListClicked(self,item):
|
|
if self.updatingGUI==False:
|
|
self.__selectEntry(item.getMountEntry())
|
|
|
|
########################################################################
|
|
def __disableEntry(self):
|
|
self.selectedentry.disable(self)
|
|
self.mounttable.updateStatus(self.selectedentry)
|
|
self.__updateEntry(self.selectedentry)
|
|
self.enablebutton.setEnabled(not self.selectedentry.isEnabled() and self.selectedentry.isFileSystemAvailable())
|
|
self.disablebutton.setEnabled(self.selectedentry.isEnabled())
|
|
return not self.selectedentry.isEnabled()
|
|
|
|
########################################################################
|
|
def __updateEntry(self,selectedentry):
|
|
# Update the display.
|
|
lvi = self.mountentriestolistitems[selectedentry]
|
|
lvi.updateDisplay()
|
|
|
|
########################################################################
|
|
def __loadOptions(self):
|
|
self.config.setGroup("General")
|
|
size = self.config.readSizeEntry("Geometry")
|
|
if size.isEmpty()==False:
|
|
self.resize(size)
|
|
|
|
#######################################################################
|
|
def __saveOptions(self):
|
|
global isroot
|
|
if isroot:
|
|
return
|
|
self.config.setGroup("General")
|
|
self.config.writeEntry("Geometry", self.size())
|
|
self.config.sync()
|
|
|
|
########################################################################
|
|
def __updateMountList(self):
|
|
self.mountentriestolistitems = {}
|
|
|
|
self.mountlist.clear()
|
|
|
|
self.listgroups = {}
|
|
self.devstolistitems = {}
|
|
self.uuidstolistitems = {}
|
|
|
|
lasttopitem = None
|
|
|
|
# Find out which disks are installed and should be shown in the
|
|
# listview. For real disks we put a 'group' in the listview and
|
|
# under the group we list the partitions, whether they are
|
|
# mounted or not.
|
|
for blockdevice in microhal.getDevices():
|
|
# We are looking for block devices that represent hard disks or
|
|
# things that have partitions and are not removable
|
|
if (blockdevice.major in microhal.partitionblockdevs and not blockdevice.removable) \
|
|
or isinstance(blockdevice,MicroHAL.USBDisk):
|
|
|
|
# We have a not removable block device.
|
|
# We want to create a listitem for the device and subitems
|
|
# for each partition.
|
|
groupitem = MountGroupListViewItem(self.mountlist,blockdevice)
|
|
groupitem.setOpen(True)
|
|
lasttopitem = groupitem
|
|
lvi = None
|
|
for partition in blockdevice.getPartitions():
|
|
# Try to find a matching mount entry for this partition.
|
|
lastlvi = lvi
|
|
lvi = MountListViewItem(groupitem,None,partition)
|
|
|
|
if partition.getUUID() is not None:
|
|
self.uuidstolistitems[partition.getUUID()] = lvi
|
|
if partition.getDev() is not None:
|
|
self.devstolistitems[partition.getDev()] = lvi
|
|
|
|
if lastlvi is not None:
|
|
lvi.moveItem(lastlvi)
|
|
elif blockdevice.getMajor() in microhal.cdromsdevs or blockdevice.isRemovable():
|
|
# Removable block device, assume CDROM (even if it's a partitionblockdevice)
|
|
lvi = MountListViewItem(self.mountlist,None,blockdevice)
|
|
if blockdevice.getUUID() is not None:
|
|
self.uuidstolistitems[blockdevice.getUUID()] = lvi
|
|
if blockdevice.getDev() is not None:
|
|
self.devstolistitems[blockdevice.getDev()] = lvi
|
|
lasttopitem = lvi
|
|
|
|
|
|
systemdevice = MicroHAL.FakeSystemDevice()
|
|
systemdevice.iconname = systemdevice.getIconName()
|
|
groupitem = MountGroupListViewItem(self.mountlist,systemdevice)
|
|
|
|
if lasttopitem is not None:
|
|
groupitem.moveItem(lasttopitem)
|
|
lasttopitem = groupitem
|
|
|
|
self.listgroups["system"] = groupitem
|
|
|
|
self.mountentriestolistitems = {}
|
|
for entry in self.mounttable:
|
|
self.__insertMountEntryIntoListView(entry)
|
|
|
|
########################################################################
|
|
def __insertMountEntryIntoListView(self,mountentry):
|
|
if mountentry.getDevice() in self.devstolistitems:
|
|
lvi = self.devstolistitems[mountentry.getDevice()]
|
|
lvi.setMountEntry(mountentry)
|
|
elif mountentry.getUUID() in self.uuidstolistitems:
|
|
lvi = self.uuidstolistitems[mountentry.getUUID()]
|
|
lvi.setMountEntry(mountentry)
|
|
else:
|
|
cat = mountentry.getCategory() # Place it under a special node?
|
|
if cat not in self.listgroups:
|
|
lvi = MountListViewItem(self.mountlist,mountentry)
|
|
item = self.mountlist.firstChild()
|
|
else:
|
|
lvi = MountListViewItem(self.listgroups[cat],mountentry)
|
|
item = self.listgroups[cat].firstChild()
|
|
|
|
# Move the item to the end of this (sub-list).
|
|
while item.nextSibling() is not None:
|
|
item = item.nextSibling()
|
|
lvi.moveItem(item)
|
|
|
|
self.mountentriestolistitems[mountentry] = lvi
|
|
|
|
########################################################################
|
|
def __selectEntry(self,mountentry):
|
|
if mountentry is not None and isroot:
|
|
lvi = self.mountentriestolistitems[mountentry]
|
|
self.mountlist.setSelected(lvi,True)
|
|
self.enablebutton.setEnabled(not mountentry.isEnabled() and mountentry.isFileSystemAvailable())
|
|
self.selectedentry = mountentry
|
|
# disable unsupported stuff, such as SystemEntries that canot be disabled and modified
|
|
if not mountentry.maydisable:
|
|
disable = False
|
|
else:
|
|
disable = mountentry.isEnabled()
|
|
if mountentry.notInFstab:
|
|
delete = False
|
|
modify = False
|
|
else:
|
|
delete = True
|
|
modify = True
|
|
|
|
self.disablebutton.setEnabled(disable)
|
|
self.deletebutton.setEnabled(delete)
|
|
self.modifybutton.setEnabled(modify)
|
|
|
|
else:
|
|
self.enablebutton.setEnabled(False)
|
|
self.disablebutton.setEnabled(False)
|
|
self.deletebutton.setEnabled(False)
|
|
self.modifybutton.setEnabled(False)
|
|
self.detailsbutton.setEnabled(False)
|
|
self.selectedentry = None
|
|
selected_item = self.mountlist.selectedItem()
|
|
if selected_item is not None:
|
|
self.detailsbutton.setEnabled(isinstance(selected_item.haldevice,MicroHAL.Disk) \
|
|
and not isinstance(selected_item.haldevice,MicroHAL.RemovableDisk))
|
|
else:
|
|
self.detailsbutton.setEnabled(False)
|
|
|
|
#######################################################################
|
|
# KControl virtual void methods
|
|
def load(self):
|
|
pass
|
|
def save(self):
|
|
pass
|
|
def defaults(self):
|
|
pass
|
|
def sysdefaults(self):
|
|
pass
|
|
|
|
def aboutData(self):
|
|
# Return the KAboutData object which we created during initialisation.
|
|
return self.aboutdata
|
|
def buttons(self):
|
|
# Only supply a Help button. Other choices are Default and Apply.
|
|
return KCModule.Help
|
|
|
|
############################################################################
|
|
# Factory function for KControl
|
|
def create_mountconfig(parent,name):
|
|
global kapp, microhal
|
|
microhal = MicroHAL.MicroHAL()
|
|
kapp = KApplication.kApplication()
|
|
return MountConfigApp(parent, name)
|
|
|
|
############################################################################
|
|
def MakeAboutData():
|
|
aboutdata = KAboutData("mountconfig",programname,version,"Disk & Filesystem Configuration Tool",
|
|
KAboutData.License_GPL, "Copyright (C) 2003-2007 Simon Edwards")
|
|
aboutdata.addAuthor("Simon Edwards","Developer","simon@simonzone.com",
|
|
"http://www.simonzone.com/software/guidance")
|
|
aboutdata.addAuthor("Sebastian Kügler","Developer","sebas@kde.org","http://vizZzion.org");
|
|
return aboutdata
|
|
|
|
if standalone:
|
|
aboutdata = MakeAboutData()
|
|
KCmdLineArgs.init(sys.argv,aboutdata)
|
|
|
|
microhal = MicroHAL.MicroHAL()
|
|
kapp = KApplication()
|
|
sysvapp = MountConfigApp()
|
|
sysvapp.exec_loop()
|