# -*- encoding: utf-8 -*- # Software Management Providers # # Copyright (C) 2012-2013 Red Hat, Inc. All rights reserved. # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA # # Authors: Michal Minar # """ Just a common functionality related to SoftwareIdentityFileCheck provider. """ import hashlib import os import pywbem import stat import yum from lmi.providers import cmpi_logging from lmi.software import util from lmi.software.yumdb import errors from lmi.software.yumdb import jobs from lmi.software.yumdb import packagecheck from lmi.software.yumdb import packageinfo from lmi.software.yumdb import YumDB LOG = cmpi_logging.get_logger(__name__) class Values(object): class TargetOperatingSystem(object): Unknown = pywbem.Uint16(0) Other = pywbem.Uint16(1) MACOS = pywbem.Uint16(2) ATTUNIX = pywbem.Uint16(3) DGUX = pywbem.Uint16(4) DECNT = pywbem.Uint16(5) Tru64_UNIX = pywbem.Uint16(6) OpenVMS = pywbem.Uint16(7) HPUX = pywbem.Uint16(8) AIX = pywbem.Uint16(9) MVS = pywbem.Uint16(10) OS400 = pywbem.Uint16(11) OS_2 = pywbem.Uint16(12) JavaVM = pywbem.Uint16(13) MSDOS = pywbem.Uint16(14) WIN3x = pywbem.Uint16(15) WIN95 = pywbem.Uint16(16) WIN98 = pywbem.Uint16(17) WINNT = pywbem.Uint16(18) WINCE = pywbem.Uint16(19) NCR3000 = pywbem.Uint16(20) NetWare = pywbem.Uint16(21) OSF = pywbem.Uint16(22) DC_OS = pywbem.Uint16(23) Reliant_UNIX = pywbem.Uint16(24) SCO_UnixWare = pywbem.Uint16(25) SCO_OpenServer = pywbem.Uint16(26) Sequent = pywbem.Uint16(27) IRIX = pywbem.Uint16(28) Solaris = pywbem.Uint16(29) SunOS = pywbem.Uint16(30) U6000 = pywbem.Uint16(31) ASERIES = pywbem.Uint16(32) HP_NonStop_OS = pywbem.Uint16(33) HP_NonStop_OSS = pywbem.Uint16(34) BS2000 = pywbem.Uint16(35) LINUX = pywbem.Uint16(36) Lynx = pywbem.Uint16(37) XENIX = pywbem.Uint16(38) VM = pywbem.Uint16(39) Interactive_UNIX = pywbem.Uint16(40) BSDUNIX = pywbem.Uint16(41) FreeBSD = pywbem.Uint16(42) NetBSD = pywbem.Uint16(43) GNU_Hurd = pywbem.Uint16(44) OS9 = pywbem.Uint16(45) MACH_Kernel = pywbem.Uint16(46) Inferno = pywbem.Uint16(47) QNX = pywbem.Uint16(48) EPOC = pywbem.Uint16(49) IxWorks = pywbem.Uint16(50) VxWorks = pywbem.Uint16(51) MiNT = pywbem.Uint16(52) BeOS = pywbem.Uint16(53) HP_MPE = pywbem.Uint16(54) NextStep = pywbem.Uint16(55) PalmPilot = pywbem.Uint16(56) Rhapsody = pywbem.Uint16(57) Windows_2000 = pywbem.Uint16(58) Dedicated = pywbem.Uint16(59) OS_390 = pywbem.Uint16(60) VSE = pywbem.Uint16(61) TPF = pywbem.Uint16(62) Windows__R__Me = pywbem.Uint16(63) Caldera_Open_UNIX = pywbem.Uint16(64) OpenBSD = pywbem.Uint16(65) Not_Applicable = pywbem.Uint16(66) Windows_XP = pywbem.Uint16(67) z_OS = pywbem.Uint16(68) Microsoft_Windows_Server_2003 = pywbem.Uint16(69) Microsoft_Windows_Server_2003_64_Bit = pywbem.Uint16(70) Windows_XP_64_Bit = pywbem.Uint16(71) Windows_XP_Embedded = pywbem.Uint16(72) Windows_Vista = pywbem.Uint16(73) Windows_Vista_64_Bit = pywbem.Uint16(74) Windows_Embedded_for_Point_of_Service = pywbem.Uint16(75) Microsoft_Windows_Server_2008 = pywbem.Uint16(76) Microsoft_Windows_Server_2008_64_Bit = pywbem.Uint16(77) FreeBSD_64_Bit = pywbem.Uint16(78) RedHat_Enterprise_Linux = pywbem.Uint16(79) RedHat_Enterprise_Linux_64_Bit = pywbem.Uint16(80) Solaris_64_Bit = pywbem.Uint16(81) SUSE = pywbem.Uint16(82) SUSE_64_Bit = pywbem.Uint16(83) SLES = pywbem.Uint16(84) SLES_64_Bit = pywbem.Uint16(85) Novell_OES = pywbem.Uint16(86) Novell_Linux_Desktop = pywbem.Uint16(87) Sun_Java_Desktop_System = pywbem.Uint16(88) Mandriva = pywbem.Uint16(89) Mandriva_64_Bit = pywbem.Uint16(90) TurboLinux = pywbem.Uint16(91) TurboLinux_64_Bit = pywbem.Uint16(92) Ubuntu = pywbem.Uint16(93) Ubuntu_64_Bit = pywbem.Uint16(94) Debian = pywbem.Uint16(95) Debian_64_Bit = pywbem.Uint16(96) Linux_2_4_x = pywbem.Uint16(97) Linux_2_4_x_64_Bit = pywbem.Uint16(98) Linux_2_6_x = pywbem.Uint16(99) Linux_2_6_x_64_Bit = pywbem.Uint16(100) Linux_64_Bit = pywbem.Uint16(101) Other_64_Bit = pywbem.Uint16(102) Microsoft_Windows_Server_2008_R2 = pywbem.Uint16(103) VMware_ESXi = pywbem.Uint16(104) Microsoft_Windows_7 = pywbem.Uint16(105) CentOS_32_bit = pywbem.Uint16(106) CentOS_64_bit = pywbem.Uint16(107) Oracle_Enterprise_Linux_32_bit = pywbem.Uint16(108) Oracle_Enterprise_Linux_64_bit = pywbem.Uint16(109) eComStation_32_bitx = pywbem.Uint16(110) Microsoft_Windows_Server_2011 = pywbem.Uint16(111) Microsoft_Windows_Server_2012 = pywbem.Uint16(113) Microsoft_Windows_8 = pywbem.Uint16(114) Microsoft_Windows_8_64_bit = pywbem.Uint16(115) _reverse_map = { 0 : 'Unknown', 1 : 'Other', 2 : 'MACOS', 3 : 'ATTUNIX', 4 : 'DGUX', 5 : 'DECNT', 6 : 'Tru64 UNIX', 7 : 'OpenVMS', 8 : 'HPUX', 9 : 'AIX', 10 : 'MVS', 11 : 'OS400', 12 : 'OS/2', 13 : 'JavaVM', 14 : 'MSDOS', 15 : 'WIN3x', 16 : 'WIN95', 17 : 'WIN98', 18 : 'WINNT', 19 : 'WINCE', 20 : 'NCR3000', 21 : 'NetWare', 22 : 'OSF', 23 : 'DC/OS', 24 : 'Reliant UNIX', 25 : 'SCO UnixWare', 26 : 'SCO OpenServer', 27 : 'Sequent', 28 : 'IRIX', 29 : 'Solaris', 30 : 'SunOS', 31 : 'U6000', 32 : 'ASERIES', 33 : 'HP NonStop OS', 34 : 'HP NonStop OSS', 35 : 'BS2000', 36 : 'LINUX', 37 : 'Lynx', 38 : 'XENIX', 39 : 'VM', 40 : 'Interactive UNIX', 41 : 'BSDUNIX', 42 : 'FreeBSD', 43 : 'NetBSD', 44 : 'GNU Hurd', 45 : 'OS9', 46 : 'MACH Kernel', 47 : 'Inferno', 48 : 'QNX', 49 : 'EPOC', 50 : 'IxWorks', 51 : 'VxWorks', 52 : 'MiNT', 53 : 'BeOS', 54 : 'HP MPE', 55 : 'NextStep', 56 : 'PalmPilot', 57 : 'Rhapsody', 58 : 'Windows 2000', 59 : 'Dedicated', 60 : 'OS/390', 61 : 'VSE', 62 : 'TPF', 63 : 'Windows (R) Me', 64 : 'Caldera Open UNIX', 65 : 'OpenBSD', 66 : 'Not Applicable', 67 : 'Windows XP', 68 : 'z/OS', 69 : 'Microsoft Windows Server 2003', 70 : 'Microsoft Windows Server 2003 64-Bit', 71 : 'Windows XP 64-Bit', 72 : 'Windows XP Embedded', 73 : 'Windows Vista', 74 : 'Windows Vista 64-Bit', 75 : 'Windows Embedded for Point of Service', 76 : 'Microsoft Windows Server 2008', 77 : 'Microsoft Windows Server 2008 64-Bit', 78 : 'FreeBSD 64-Bit', 79 : 'RedHat Enterprise Linux', 80 : 'RedHat Enterprise Linux 64-Bit', 81 : 'Solaris 64-Bit', 82 : 'SUSE', 83 : 'SUSE 64-Bit', 84 : 'SLES', 85 : 'SLES 64-Bit', 86 : 'Novell OES', 87 : 'Novell Linux Desktop', 88 : 'Sun Java Desktop System', 89 : 'Mandriva', 90 : 'Mandriva 64-Bit', 91 : 'TurboLinux', 92 : 'TurboLinux 64-Bit', 93 : 'Ubuntu', 94 : 'Ubuntu 64-Bit', 95 : 'Debian', 96 : 'Debian 64-Bit', 97 : 'Linux 2.4.x', 98 : 'Linux 2.4.x 64-Bit', 99 : 'Linux 2.6.x', 100 : 'Linux 2.6.x 64-Bit', 101 : 'Linux 64-Bit', 102 : 'Other 64-Bit', 103 : 'Microsoft Windows Server 2008 R2', 104 : 'VMware ESXi', 105 : 'Microsoft Windows 7', 106 : 'CentOS 32-bit', 107 : 'CentOS 64-bit', 108 : 'Oracle Enterprise Linux 32-bit', 109 : 'Oracle Enterprise Linux 64-bit', 110 : 'eComStation 32-bitx', 111 : 'Microsoft Windows Server 2011', 113 : 'Microsoft Windows Server 2012', 114 : 'Microsoft Windows 8', 115 : 'Microsoft Windows 8 64-bit' } class ChecksumType(object): UNKNOWN = pywbem.Uint16(0) MD5 = pywbem.Uint16(1) SHA_1 = pywbem.Uint16(2) RIPE_MD_160 = pywbem.Uint16(3) SHA256 = pywbem.Uint16(8) SHA384 = pywbem.Uint16(9) SHA512 = pywbem.Uint16(10) SHA224 = pywbem.Uint16(11) _reverse_map = { 0 : 'UNKNOWN', 1 : 'MD5', 2 : 'SHA-1', 3 : 'RIPE-MD/160', 8 : 'SHA256', 9 : 'SHA384', 10 : 'SHA512', 11 : 'SHA224' } class FileType(object): Unknown = pywbem.Uint16(0) File = pywbem.Uint16(1) Directory = pywbem.Uint16(2) Symlink = pywbem.Uint16(3) FIFO = pywbem.Uint16(4) Character_Device = pywbem.Uint16(5) Block_Device = pywbem.Uint16(6) _reverse_map = { 0 : 'Unknown', 1 : 'File', 2 : 'Directory', 3 : 'Symlink', 4 : 'FIFO', 5 : 'Character Device', 6 : 'Block Device' } class FileModeFlags(object): Execute_Other = pywbem.Uint8(0) Write_Other = pywbem.Uint8(1) Read_Other = pywbem.Uint8(2) Execute_Group = pywbem.Uint8(3) Write_Group = pywbem.Uint8(4) Read_Group = pywbem.Uint8(5) Execute_User = pywbem.Uint8(6) Write_User = pywbem.Uint8(7) Read_User = pywbem.Uint8(8) Sticky = pywbem.Uint8(9) SGID = pywbem.Uint8(10) SUID = pywbem.Uint8(11) _reverse_map = { 0 : 'Execute Other', 1 : 'Write Other', 2 : 'Read Other', 3 : 'Execute Group', 4 : 'Write Group', 5 : 'Read Group', 6 : 'Execute User', 7 : 'Write User', 8 : 'Read User', 9 : 'Sticky', 10 : 'SGID', 11 : 'SUID' } class FileModeFlagsOriginal(object): Execute_Other = pywbem.Uint8(0) Write_Other = pywbem.Uint8(1) Read_Other = pywbem.Uint8(2) Execute_Group = pywbem.Uint8(3) Write_Group = pywbem.Uint8(4) Read_Group = pywbem.Uint8(5) Execute_User = pywbem.Uint8(6) Write_User = pywbem.Uint8(7) Read_User = pywbem.Uint8(8) Sticky = pywbem.Uint8(9) SGID = pywbem.Uint8(10) SUID = pywbem.Uint8(11) _reverse_map = { 0 : 'Execute Other', 1 : 'Write Other', 2 : 'Read Other', 3 : 'Execute Group', 4 : 'Write Group', 5 : 'Read Group', 6 : 'Execute User', 7 : 'Write User', 8 : 'Read User', 9 : 'Sticky', 10 : 'SGID', 11 : 'SUID' } class FailedFlags(object): Existence = pywbem.Uint16(0) FileSize = pywbem.Uint16(1) FileMode = pywbem.Uint16(2) Checksum = pywbem.Uint16(3) Device_Number = pywbem.Uint16(4) LinkTarget = pywbem.Uint16(5) UserID = pywbem.Uint16(6) GroupID = pywbem.Uint16(7) Last_Modification_Time = pywbem.Uint16(8) _reverse_map = { 0 : 'Existence', 1 : 'FileSize', 2 : 'FileMode', 3 : 'Checksum', 4 : 'Device Number', 5 : 'LinkTarget', 6 : 'UserID', 7 : 'GroupID', 8 : 'Last Modification Time' } class SoftwareElementState(object): Deployable = pywbem.Uint16(0) Installable = pywbem.Uint16(1) Executable = pywbem.Uint16(2) Running = pywbem.Uint16(3) _reverse_map = { 0 : 'Deployable', 1 : 'Installable', 2 : 'Executable', 3 : 'Running' } class FileTypeOriginal(object): Unknown = pywbem.Uint16(0) File = pywbem.Uint16(1) Directory = pywbem.Uint16(2) Symlink = pywbem.Uint16(3) FIFO = pywbem.Uint16(4) Character_Device = pywbem.Uint16(5) Block_Device = pywbem.Uint16(6) _reverse_map = { 0 : 'Unknown', 1 : 'File', 2 : 'Directory', 3 : 'Symlink', 4 : 'FIFO', 5 : 'Character Device', 6 : 'Block Device' } class Invoke(object): """ This is not an enumeration from mof file, it just gives human names to numeric values. """ Satisfied = pywbem.Uint32(0) Not_Supported = pywbem.Uint32(1) Not_Satisfied = pywbem.Uint32(2) class FileCheck(object): """ File attribute storage keeping both RPM database metadata and info from local filesystem for single file. Most attributes are loaded at the time of first request and cached for later use. Most of properties return tuple: ``(installed, original)`` where ``installed`` is a state of property of installed file, while ``original`` is the value stored in RPM database. If any of those values are None, it means that property could not be retrieved or it's not applicable to file's type. """ def __init__(self, pkg_info, pkg_file, checksum_type): """ :param pkg_file: (``yumdb.packagecheck.PackageFile``) Metadata for file loaded from rpm database. :param checksum_type: (``int``) Indentificator of checksum algorithm corresponding to values in yum.constants.RPM_CHECKSUM_TYPES. """ if not isinstance(pkg_info, packageinfo.PackageInfo): raise TypeError("pkg_info must be an instance of PackageInfo") if not isinstance(pkg_file, packagecheck.PackageFile): raise TypeError("pkg_file must be an instance of PackageFile") self._pkg_info = pkg_info self._pkg_file = pkg_file self._exists = None # (md5 checksum, rpm-type checksum) - this is made on first request self._checksums = None self._checksum_type = checksum_type self._link_target = None # stores result of os.stat() call self._stat = None @property def pkg_info(self): """:rtype: (``PackageInfo``)""" return self._pkg_info @property def pkg_file(self): """:rtype: (``PackageFile``)""" return self._pkg_file @property def path(self): """Return absolute file path.""" return self._pkg_file.path @property def exists(self): """Return true if file exists on local file system.""" if self._exists is None: self._exists = os.path.lexists(self._pkg_file.path) return self._exists @property def stat(self): """ Return cached stat object - result of ``os.lstat()``. None is returned if file does not exist. """ if self._stat is None and self.exists: self._stat = os.lstat(self.path) return self._stat @property def file_type(self): """ Return identifiers of file type for installed and rpm file. If the installed file does not exist, None is returned on its position. :rtype: (``tuple``) Pair of (installed, original). """ fm = self.file_mode[0] if fm is None: ft = None elif stat.S_ISLNK(fm): ft = packagecheck.FILE_TYPE_SYMLINK elif stat.S_ISDIR(fm): ft = packagecheck.FILE_TYPE_DIRECTORY elif stat.S_ISFIFO(fm): ft = packagecheck.FILE_TYPE_FIFO elif stat.S_ISCHR(fm): ft = packagecheck.FILE_TYPE_CHARACTER_DEVICE elif stat.S_ISBLK(fm): ft = packagecheck.FILE_TYPE_BLOCK_DEVICE elif stat.S_ISREG(fm): ft = packagecheck.FILE_TYPE_FILE else: ft = packagecheck.FILE_TYPE_UNKNOWN return (ft, self._pkg_file.file_type) @property def md5_checksum(self): """ Return md5 checksum string of installed file. This is computed on first access either to this or ``file_checksum`` property and cached for later access. :rtype: (``str``) """ if self._checksums is None: self.make_checksums() return self._checksums[0] if self._checksums else None @property def file_checksum_type(self): """ Return identifier of hash algorithm used in rpm package. :rtype: (``int``) """ return self._checksum_type @property def file_checksum(self): """ Return checksum strings for installed and rpm file. This is computed on first access either to this or ``md5_checksum`` property and cached for later access. :rtype: (``tuple``) Pair of (installed, original). """ if self._checksums is None: self.make_checksums() return ( self._checksums[1] if self._checksums else None , self._pkg_file.checksum) @property def file_size(self): """:rtype: (``tuple``) Pair of (installed, original).""" return (self.getstat('size'), self._pkg_file.size) @property def file_mode(self): """:rtype: (``tuple``) Pair of (installed, original).""" return (self.getstat('mode'), self._pkg_file.mode) @property def device(self): """:rtype: (``tuple``) Pair of (installed, original).""" return (self.getstat('dev'), self._pkg_file.device) @property def link_target(self): """:rtype: (``tuple``) Pair of (installed, original).""" if ( self.file_type[0] == packagecheck.FILE_TYPE_SYMLINK and self._link_target is None): self._link_target = os.readlink(self.path) return (self._link_target, self._pkg_file.link_target) @property def user_id(self): """:rtype: (``tuple``) Pair of (installed, original).""" return (self.getstat('uid'), self._pkg_file.uid) @property def group_id(self): """:rtype: (``tuple``) Pair of (installed, original).""" return (self.getstat('gid'), self._pkg_file.gid) @property def last_modification_time(self): """:rtype: (``tuple``) Pair of (installed, original).""" return (self.getstat('mtime'), self._pkg_file.mtime) def getstat(self, attr): """ Get attribute from stat object for given file. :param attr: (``str``) Will be prefixed with "st_". """ if self.stat is not None: return getattr(self.stat, "st_"+attr) def make_checksums(self): """ Compute checksums for installed file and cache them. :rtype: (``tuple``) MD5 and rpm-type checksums for given file as a pair. """ if self.file_type[0] == packagecheck.FILE_TYPE_FILE: self._checksums = compute_checksums( self._checksum_type, self.path) else: self._checksums = None return self._checksums @cmpi_logging.trace_function def hashfile(afile, hashers, blocksize=65536): """ Generic function computing multiple hashes from single file at once. :param hashers: (``list``) A list of hash objects. :rtype: (``list``) List of digest strings (in hex format) for each given hash object in the same order. """ if not isinstance(hashers, (tuple, list, set, frozenset)): hashers = (hashers, ) buf = afile.read(blocksize) while len(buf) > 0: for hashfunc in hashers: hashfunc.update(buf) buf = afile.read(blocksize) return [ hashfunc.hexdigest() for hashfunc in hashers ] @cmpi_logging.trace_function def compute_checksums(checksum_type, file_path): """ Compute file checksums in one go. :param checksum_type: (``int`) Selected hash algorithm to compute second checksum (the one used for rpm package). Correct value can be obtained from ``yum.constants.RPM_CHECKSUM_TYPES``. :param file_path: (``str``) Absolute path of regular file to hash. :rtype (md5sum, checksum) Tuple of strings containing hex represention of computed checksums. Both checksums are computed from file_path's content. First one is always md5, the second one depends on checksum_type. If file does not exists, (None, None) is returned. """ LOG().debug("checksuming file %s", file_path) hashers = [hashlib.md5()] #pylint: disable=E1101 if checksum_type != packagecheck.CHECKSUMTYPE_STR2NUM["md5"]: hashers.append(checksumtype_num2hash(checksum_type)()) try: with open(file_path, 'rb') as fobj: rslts = hashfile(fobj, hashers) except (OSError, IOError) as exc: LOG().error("could not open file \"%s\" for reading: %s", file_path, exc) return None, None return (rslts[0], rslts[1] if len(rslts) > 1 else rslts[0]*2) @cmpi_logging.trace_function def checksumtype_num2hash(csumt): """ Get checksum function for rpm hash identifier. :param csumt: (``int``) Checksum type as a number obtained from package. :rtype: (``function``) Hash function object corresponding to csumt. """ return getattr(hashlib, yum.constants.RPM_CHECKSUM_TYPES[csumt]) @cmpi_logging.trace_function def mode2pywbem_flags(mode): """ Utility for creation of value of ``FileModeFlags`` property out of file's raw mode. :param mode: (``int``) File's mode. Retrieved from os.lstat(). If None, file does not exist. :rtype: (``list``) Of integer flags describing file's access permissions. """ if mode is None: return None flags = [] for i, flag in enumerate(( stat.S_IXOTH, stat.S_IWOTH, stat.S_IROTH, stat.S_IXGRP, stat.S_IWGRP, stat.S_IRGRP, stat.S_IXUSR, stat.S_IWUSR, stat.S_IRUSR, stat.S_ISVTX, stat.S_ISGID, stat.S_ISUID)): if flag & mode: flags.append(pywbem.Uint8(i)) return flags @cmpi_logging.trace_function def get_existing_check_from_job(check_id): """ ``CheckID`` of ``LMI_SoftwareIdentityFileCheck`` refers to asynchronous job that caused creation of this file check. Let's parse it, get the job out of YumWorker and ask it for results so they don't have to be computed again. :param check_id: (``str``) Value of ``CheckID`` property. :rtype: (``tuple``) Pair of (pkg_info, pkg_check). ``None`` if job does not exists anymore. """ try: match = util.RE_INSTANCE_ID.match(check_id) if not match: raise ValueError(check_id) if ( not match.group('clsname').lower() == "LMI_SoftwareVerificationJob".lower()): raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "CheckID does not contain supported job class name: " " %s != %s" % (match.group('clsname'), "LMI_SoftwareVerificationJob".lower())) job_id = int(match.group('id')) job = YumDB.get_instance().get_job(job_id) if not isinstance(job, (jobs.YumCheckPackage, jobs.YumCheckPackageFile)): LOG().error('CheckID="%s" of LMI_SoftwareIdentityFileCheck refers' ' to job %s.', check_id, job) raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "CheckID refers to wrong job.") return job.result_data except errors.JobNotFound: # allow this - job could already be deleted LOG().warn("could not find YumCheckPackage or" " YumCheckPackageFile job with id \"%d\"" % job_id) except ValueError: raise pywbem.CIMError(pywbem.CIM_ERR_INVALID_PARAMETER, "Could not parse \"CheckID\" key property: \"%s\"." % check_id) @cmpi_logging.trace_function def object_path2file_check(objpath): """ @return (package_info, package_check, file_name) """ if not isinstance(objpath, pywbem.CIMInstanceName): raise TypeError("objpath must be instance of CIMInstanceName, " "not \"%s\"" % objpath.__class__.__name__) for key in ('Name', 'SoftwareElementID', 'Version', 'SoftwareElementState', 'TargetOperatingSystem'): if not key in objpath or not objpath[key]: raise pywbem.CIMError(pywbem.CIM_ERR_INVALID_PARAMETER, "Missing key property \"%s\"." % key) version_match = util.RE_EVRA.match(objpath['Version']) if not version_match: raise pywbem.CIMError(pywbem.CIM_ERR_INVALID_PARAMETER, 'Failed to parse \"Version\" property for valid EVRA: "%s".' % objpath['Version']) pkg_fltr = util.nevra2filter(objpath["SoftwareElementID"]) if any( pkg_fltr[attr] != version_match.group(attr) for attr in ('epoch', 'version', 'release', 'arch')): raise pywbem.CIMError(pywbem.CIM_ERR_INVALID_PARAMETER, 'Inconsistent \"Version\" and \"SoftwareElementID\" key' ' properties.') if ( objpath['SoftwareElementState'] != Values.SoftwareElementState.Executable): raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "Only \"Executable\" software element state supported") if not util.check_target_operating_system( objpath['TargetOperatingSystem']): raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "Wrong target operating system.") ydb = YumDB.get_instance() pkg_check = None if ( objpath["CheckID"].lower() != "LMI:LMI_SoftwareIdentityFileCheck".lower()): check = get_existing_check_from_job(objpath["CheckID"]) if check is not None: pkg_info, pkg_check = check # else - job does not exist (could be deleted) if pkg_check is None: # let the YumWorker check the rest try: pkg_info, pkg_check = ydb.check_package_file( objpath["SoftwareElementID"], objpath["Name"]) except errors.PackageNotFound: raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "Could not find package matching SoftwareElementID \"%s\"" % objpath["SoftwareElementID"]) except errors.FileNotFound as exc: raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, exc.message) # last check for file path if objpath["Name"] not in pkg_check: raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, 'File \"%s\" not found in package \"%s\".' % objpath["SoftwareElementID"]) return FileCheck(pkg_info, pkg_check[objpath["Name"]], pkg_check.file_checksum_type) @cmpi_logging.trace_function def test_file(pkg_info, checksum_type, pkg_file): """ :param checksum_type: (``int``) Identifier of checksum algorithm used in rpm package. It's one of keys of ``yum.constants.RPM_CHECKSUM_TYPES`` dictionary. :rtype: (``FileCheck``) """ for var, cls in ( ("pkg_info", packageinfo.PackageInfo), ("pkg_file", packagecheck.PackageFile)): if not isinstance(locals()[var], cls): raise TypeError("%s must be an instance of %s, not %s" % ( var, cls.__name__, pkg_file.__class__.__name__)) return FileCheck(pkg_info, pkg_file, checksum_type) @cmpi_logging.trace_function def _file_check2failed_flags(file_check): """ Makes value of ``FailedFlags`` property from ``FileCheck`` instance. :param file_check: (``FileCheck``) :rtype: (``pywbem.CIMProperty``) Property ``FailedFlags`` value. """ if not isinstance(file_check, FileCheck): raise TypeError("file_check must be an instance of FileCheck") if not file_check.exists: return [Values.FailedFlags.Existence] flags = set() fails_on = lambda attr: ( getattr(file_check, attr)[0] != getattr(file_check, attr)[1]) if fails_on('file_type'): flags.add(Values.FailedFlags.FileMode) # file type specific checks if file_check.file_type[1] == packagecheck.FILE_TYPE_FILE: if fails_on('file_size'): flags.add(Values.FailedFlags.FileSize) if fails_on('last_modification_time'): flags.add(Values.FailedFlags.Last_Modification_Time) if fails_on('file_checksum'): flags.add(Values.FailedFlags.Checksum) elif file_check.file_type[1] in ( packagecheck.FILE_TYPE_CHARACTER_DEVICE, packagecheck.FILE_TYPE_BLOCK_DEVICE): if fails_on('device'): flags.add(Values.FailedFlags.Device_Number) elif file_check.file_type[1] == packagecheck.FILE_TYPE_SYMLINK: if fails_on('link_target'): flags.add(Values.FailedFlags.LinkTarget) # generic checks if ( fails_on('file_mode') # do not check permissions for symlinks and file_check.file_type[1] != packagecheck.FILE_TYPE_SYMLINK): flags.add(Values.FailedFlags.FileMode) if fails_on('user_id'): flags.add(Values.FailedFlags.UserID) if fails_on('group_id'): flags.add(Values.FailedFlags.GroupID) return list(flags) @cmpi_logging.trace_function def file_check_passed(file_check): """ Verify single file and return true if it passes. """ return len(_file_check2failed_flags(file_check)) == 0 @cmpi_logging.trace_function def _fill_non_key_values(model, file_check): """ Fills a non key values into instance of SoftwareIdentityFileCheck. :param model: (``CIMInstance``) Model, that will be filled with all supported non-key properties. """ set_prop = lambda name, kwargs: \ model.__setitem__(name, pywbem.CIMProperty(name, **kwargs)) set_prop("CheckMode", dict(type='boolean', value=True)) model["ChecksumType"] = pywbem.Uint16(file_check.file_checksum_type) set_prop("FailedFlags", dict(type='uint16', is_array=True, value=_file_check2failed_flags(file_check))) for mattr, fattr, kwargs, convert in ( ('LastModificationTime', 'last_modification_time', {'type':'uint64'}, pywbem.Uint64), ('FileType' , 'file_type' ,{'type':'uint16'}, pywbem.Uint16), ('UserID' , 'user_id' ,{'type':'uint32'}, pywbem.Uint32), ('GroupID' , 'group_id' ,{'type':'uint32'}, pywbem.Uint32), ('FileMode' , 'file_mode' ,{'type':'uint32'}, pywbem.Uint32), ('FileSize' , 'file_size' ,{'type':'uint64'}, pywbem.Uint64), ('LinkTarget' , 'link_target' ,{'type':'string'}, str), ('FileChecksum', 'file_checksum',{'type':'string'}, str)): installed, orig = getattr(file_check, fattr) kwargs['value'] = None if orig is None else convert(orig) set_prop(mattr+"Original", kwargs) kwargs['value'] = None if installed is None else convert(installed) set_prop(mattr, kwargs) model['FileName'] = os.path.basename(file_check.path) for suf in ('', 'Original'): set_prop('FileModeFlags'+suf, dict(type='uint8', is_array=True, value=mode2pywbem_flags(file_check.file_mode[1]))) set_prop("FileExists", dict(type='boolean', value=file_check.exists)) set_prop('MD5Checksum', dict(type='string', value=file_check.md5_checksum)) @cmpi_logging.trace_function def file_check2model(file_check, keys_only=True, model=None, job=None): """ :param file_check: (``FileCheck``) File check information to transform to cim instance. :param keys_only: (``bool``) Whether to fill non-key properties. :param model: (``CIMInstance`` | ``CIMInstanceName``) If given, it will be used as a template. Only property values will be set. This instance will be returned on completion. :param job: (``YumAsyncJob``) If this is a consequence of asynchronous job operation, the instance of job should be supplied so that ``CheckID`` property can be filled. :rtype: (``CIMInstance`` | ``CIMInstanceName``) Object of LMI_SoftwareIdentityFileCheck with filled desired values. """ if job is not None and not isinstance(job, jobs.YumCheckPackage): raise TypeError("job must be instance of jobs.YumCheckPackage") if not isinstance(file_check, FileCheck): raise TypeError("file_check must be an instance of FileCheck") if model is None: model = util.new_instance_name("LMI_SoftwareIdentityFileCheck") if not keys_only: model = pywbem.CIMInstance("LMI_SoftwareIdentityFileCheck", path=model) if not keys_only: model.path.update( #pylint: disable=E1103 {k: None for k in ("Name", "SoftwareElementID", "SoftwareElementState", "TargetOperatingSystem", "Version", "CheckID")}) model['Name'] = file_check.path model['SoftwareElementID'] = file_check.pkg_info.nevra model['SoftwareElementState'] = Values.SoftwareElementState.Executable model['TargetOperatingSystem'] = pywbem.Uint16( util.get_target_operating_system()[0]) model['Version'] = file_check.pkg_info.evra model['CheckID'] = ("LMI:LMI_SoftwareVerificationJob:%d" % job.jobid if job is not None else "LMI:%s" % model.classname) if not keys_only: _fill_non_key_values(model, file_check) return model