pki.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Ade Lee <alee@redhat.com>	2012-02-16 14:38:40 -0500
committer	Ade Lee <alee@redhat.com>	2012-02-23 21:31:24 -0500
commit	1c4c45a87e62a74b68b7d235e94cfe5dc21b8da2 (patch)
tree	ee413dd31d1a9d118c8c1367740ee95460919fae /base/java-tools
parent	0df68f85d453e5fb087a2cf04dc5d3ce4bcdff01 (diff)

Add client auth user to default install

When a subsystem is configured, a user is created to facilitate communication between subsystems. This user is created on the security domain ca, and is has the subsystem certificate in its user record. This user will be reused as a user that can talk to the database using the subsystem certificate for client auth. To do this, this patch does the following: 1. If not the security domain master CA, adds this user to the subsystem, and adds the subsystem cert. 2. Adds the subsystem cert subject dn to the user's record in the seeAlso attribute 3. Adds acis for this user for the $basedn and for cn=config (for VLV searches) By default, this user and acls will be added when the system is configured. To actually use the user and client auth, more config steps are required. They will be doc'ed in https://fedorahosted.org/pki/ticket/5

Diffstat (limited to 'base/java-tools')

0 files changed, 0 insertions, 0 deletions

# # partedUtils.py: helper functions for use with parted objects # # Matt Wilson <msw@redhat.com> # Jeremy Katz <katzj@redhat.com> # Mike Fulbright <msf@redhat.com> # # Copyright 2002 Red Hat, Inc. # # This software may be freely redistributed under the terms of the GNU # library public license. # # You should have received a copy of the GNU Library Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # """Helper functions for use when dealing with parted objects.""" import parted import math import os, sys, string, struct from product import * import fsset import iutil, isys import raid import lvm from flags import flags from partErrors import * from rhpl.log import log from rhpl.translate import _ fsTypes = {} fs_type = parted.file_system_type_get_next () while fs_type: fsTypes[fs_type.name] = fs_type fs_type = parted.file_system_type_get_next (fs_type) def get_flags (part): """Retrieve a list of strings representing the flags on the partition.""" string="" if not part.is_active (): return string first=1 flag = parted.partition_flag_next (0) while flag: if part.get_flag (flag): string = string + parted.partition_flag_get_name (flag) if first: first = 0 else: string = string + ", " flag = parted.partition_flag_next (flag) return string def start_sector_to_cyl(device, sector): """Return the closest cylinder (round down) to sector on device.""" return int(math.floor((float(sector) / (device.heads * device.sectors)) + 1)) def end_sector_to_cyl(device, sector): """Return the closest cylinder (round up) to sector on device.""" return int(math.ceil(float((sector + 1)) / (device.heads * device.sectors))) def start_cyl_to_sector(device, cyl): "Return the sector corresponding to cylinder as a starting cylinder." return long((cyl - 1) * (device.heads * device.sectors)) def end_cyl_to_sector(device, cyl): "Return the sector corresponding to cylinder as a ending cylinder." return long(((cyl) * (device.heads * device.sectors)) - 1) def getPartSize(partition): """Return the size of partition in sectors.""" return partition.geom.length def getPartSizeMB(partition): """Return the size of partition in megabytes.""" return (partition.geom.length * partition.geom.disk.dev.sector_size / 1024.0 / 1024.0) def getDeviceSizeMB(dev): """Return the size of dev in megabytes.""" return (float(dev.heads * dev.cylinders * dev.sectors) / (1024 * 1024) * dev.sector_size) def get_partition_by_name(disks, partname): """Return the parted part object associated with partname. Arguments: disks -- Dictionary of diskname->PedDisk objects partname -- Name of partition to find Return: PedPartition object with name partname. None if no such partition. """ for diskname in disks.keys(): disk = disks[diskname] part = disk.next_partition() while part: if get_partition_name(part) == partname: return part part = disk.next_partition(part) return None def get_partition_name(partition): """Return the device name for the PedPartition partition.""" if (partition.geom.disk.dev.type == parted.DEVICE_DAC960 or partition.geom.disk.dev.type == parted.DEVICE_CPQARRAY): return "%sp%d" % (partition.geom.disk.dev.path[5:], partition.num) return "%s%d" % (partition.geom.disk.dev.path[5:], partition.num) def get_partition_file_system_type(part): """Return the file system type of the PedPartition part. Arguments: part -- PedPartition object Return: Filesystem object (as defined in fsset.py) """ if part.fs_type == None: return None if part.fs_type.name == "linux-swap": ptype = fsset.fileSystemTypeGet("swap") elif part.fs_type.name == "FAT": ptype = fsset.fileSystemTypeGet("vfat") else: try: ptype = fsset.fileSystemTypeGet(part.fs_type.name) except: ptype = fsset.fileSystemTypeGet("foreign") return ptype def set_partition_file_system_type(part, fstype): """Set partition type of part to PedFileSystemType implied by fstype.""" if fstype == None: return try: for flag in fstype.getPartedPartitionFlags(): if not part.is_flag_available(flag): raise PartitioningError, ("requested FileSystemType needs " "a flag that is not available.") part.set_flag(flag, 1) part.set_system(fstype.getPartedFileSystemType()) except: print "Failed to set partition type to ",fstype.getName() pass def get_partition_drive(partition): """Return the device name for disk that PedPartition partition is on.""" return "%s" %(partition.geom.disk.dev.path[5:]) def map_foreign_to_fsname(type): """Return the partition type associated with the numeric type.""" if type in allPartitionTypesDict.keys(): return allPartitionTypesDict[type] else: return _("Foreign") def filter_partitions(disk, func): rc = [] part = disk.next_partition () while part: if func(part): rc.append(part) part = disk.next_partition (part) return rc def get_all_partitions(disk): """Return a list of all PedPartition objects on disk.""" func = lambda part: part.is_active() return filter_partitions(disk, func) def get_logical_partitions(disk): """Return a list of logical PedPartition objects on disk.""" func = lambda part: (part.is_active() and part.type & parted.PARTITION_LOGICAL) return filter_partitions(disk, func) def get_primary_partitions(disk): """Return a list of primary PedPartition objects on disk.""" func = lambda part: part.type == parted.PARTITION_PRIMARY return filter_partitions(disk, func) def get_raid_partitions(disk): """Return a list of RAID-type PedPartition objects on disk.""" func = lambda part: (part.is_active() and part.get_flag(parted.PARTITION_RAID) == 1) return filter_partitions(disk, func) def get_lvm_partitions(disk): """Return a list of physical volume-type PedPartition objects on disk.""" func = lambda part: (part.is_active() and part.get_flag(parted.PARTITION_LVM) == 1) return filter_partitions(disk, func) def getDefaultDiskType(): """Get the default partition table type for this architecture.""" if iutil.getArch() == "i386": return parted.disk_type_get("msdos") elif iutil.getArch() == "ia64": return parted.disk_type_get("GPT") elif iutil.getArch() == "s390": return parted.disk_type_get("dasd") elif iutil.getArch() == "alpha": return parted.disk_type_get("bsd") elif iutil.getArch() == "sparc": return parted.disk_type_get("sun") else: # XXX fix me for alpha at least return parted.disk_type_get("msdos") archLabels = {'i386': ['msdos'], 'alpha': ['bsd'], 's390': ['dasd'], 'alpha': ['bsd', 'msdos'], 'sparc': ['sun'], 'ia64': ['msdos', 'GPT']} def checkDiskLabel(disk, intf): """Check that the disk label on disk is valid for this machine type.""" arch = iutil.getArch() if arch in archLabels.keys(): if disk.type.name in archLabels[arch]: return 0 else: if disk.type.name == "msdos": return 0 if intf: rc = intf.messageWindow(_("Warning"), _("The partition table on device /dev/%s is of an " "unexpected type %s for your architecture. To " "use this disk for installation of %s, " "it must be re-initialized causing the loss of " "ALL DATA on this drive.\n\n" "Would you like to initialize this drive?") % (disk.dev.path[5:], disk.type.name, productName), type = "yesno") if rc == 0: return 1 else: return -1 else: return 1 def isLinuxNativeByNumtype(numtype): """Check if the type is a 'Linux native' filesystem.""" linuxtypes = [0x82, 0x83, 0x8e, 0xfd] for t in linuxtypes: if int(numtype) == t: return 1 return 0 def sniffFilesystemType(device): """Sniff to determine the type of fs on device. device - name of device to sniff. we try to create it if it doesn't exist. """ if os.access(device, os.O_RDONLY): dev = device else: dev = "/tmp/" + device if not os.access(dev, os.O_RDONLY): try: isys.makeDevInode(device, dev) except: pass pagesize = isys.getpagesize() if pagesize > 2048: num = pagesize else: num = 2048 try: fd = os.open(dev, os.O_RDONLY) buf = os.read(fd, num) os.close(fd) except: return None if len(buf) < pagesize: try: log("Tried to read pagesize for %s in sniffFilesystemType and only read %s", dev, len(buf)) except: pass return None # ext2 check if struct.unpack("H", buf[1080:1082]) == (0xef53,): if isys.ext2HasJournal(dev, makeDevNode = 0): return "ext3" else: return "ext2" # physical volumes start with HM (see linux/lvm.h # and LVM/ver/tools/lib/pv_copy.c) if buf.startswith("HM"): return "physical volume (LVM)" # xfs signature if buf.startswith("XFSB"): return "xfs" if (buf[pagesize - 10:] == "SWAP-SPACE" or buf[pagesize - 10:] == "SWAPSPACE2"): return "swap" try: isys.raidsbFromDevice(dev) return "software RAID" except: pass # FIXME: we don't look for reiserfs, jfs, or vfat return None class DiskSet: """The disks in the system.""" skippedDisks = [] mdList = [] def __init__ (self): self.disks = {} def startAllRaid(self): """Start all of the raid devices associated with the DiskSet.""" driveList = [] origDriveList = self.driveList() for drive in origDriveList: if not drive in DiskSet.skippedDisks: driveList.append(drive) DiskSet.mdList.extend(raid.startAllRaid(driveList)) def stopAllRaid(self): """Stop all of the raid devices associated with the DiskSet.""" raid.stopAllRaid(DiskSet.mdList) while DiskSet.mdList: DiskSet.mdList.pop() def getLabels(self): """Return a list of all of the labels used on partitions.""" labels = {} drives = self.disks.keys() drives.sort() for drive in drives: disk = self.disks[drive] func = lambda part: (part.is_active() and not (part.get_flag(parted.PARTITION_RAID) or part.get_flag(parted.PARTITION_LVM)) and part.fs_type and (part.fs_type.name == "ext2" or part.fs_type.name == "ext3")) parts = filter_partitions(disk, func) for part in parts: node = get_partition_name(part) label = isys.readExt2Label(node) if label: labels[node] = label for dev, devices, level, numActive in DiskSet.mdList: label = isys.readExt2Label(dev) if label: labels[dev] = label return labels def findExistingRootPartitions(self, intf, mountpoint):


context:
space:
mode: