+++ /dev/null
-#!/usr/bin/python
-
-# $Header: $
-# This program is licensed under the GPL, version 2
-
-import os
-import sys
-
-try:
- import portage
-except ImportError:
- from os import path as osp
- sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "pym"))
- import portage
-
-from portage.output import *
-
-from getopt import getopt, GetoptError
-
-__program__ = "glsa-check"
-__author__ = "Marius Mauch <genone@gentoo.org>"
-__version__ = "1.0"
-
-optionmap = [
-["-l", "--list", "list all unapplied GLSA"],
-["-d", "--dump", "--print", "show all information about the given GLSA"],
-["-t", "--test", "test if this system is affected by the given GLSA"],
-["-p", "--pretend", "show the necessary commands to apply this GLSA"],
-["-f", "--fix", "try to auto-apply this GLSA (experimental)"],
-["-i", "--inject", "inject the given GLSA into the checkfile"],
-["-n", "--nocolor", "disable colors (option)"],
-["-e", "--emergelike", "do not use a least-change algorithm (option)"],
-["-h", "--help", "show this help message"],
-["-V", "--version", "some information about this tool"],
-["-v", "--verbose", "print more information (option)"],
-["-c", "--cve", "show CAN ids in listing mode (option)"],
-["-m", "--mail", "send a mail with the given GLSAs to the administrator"]
-]
-
-# option parsing
-args = []
-params = []
-try:
- args, params = getopt(sys.argv[1:], "".join([o[0][1] for o in optionmap]), \
- [x[2:] for x in reduce(lambda x,y: x+y, [z[1:-1] for z in optionmap])])
-# ["dump", "print", "list", "pretend", "fix", "inject", "help", "verbose", "version", "test", "nocolor", "cve", "mail"])
- args = [a for a,b in args]
-
- for option in ["--nocolor", "-n"]:
- if option in args:
- nocolor()
- args.remove(option)
-
- verbose = False
- for option in ["--verbose", "-v"]:
- if option in args:
- verbose = True
- args.remove(option)
-
- list_cve = False
- for option in ["--cve", "-c"]:
- if option in args:
- list_cve = True
- args.remove(option)
-
- least_change = True
- for option in ["--emergelike", "-e"]:
- if option in args:
- least_change = False
- args.remove(option)
-
- # sanity checking
- if len(args) <= 0:
- sys.stderr.write("no option given: what should I do ?\n")
- mode="help"
- elif len(args) > 1:
- sys.stderr.write("please use only one command per call\n")
- mode = "help"
- else:
- # in what mode are we ?
- args = args[0]
- for m in optionmap:
- if args in [o for o in m[:-1]]:
- mode = m[1][2:]
-
-except GetoptError, e:
- sys.stderr.write("unknown option given: ")
- sys.stderr.write(str(e)+"\n")
- mode = "help"
-
-# we need a set of glsa for most operation modes
-if len(params) <= 0 and mode in ["fix", "test", "pretend", "dump", "inject", "mail"]:
- sys.stderr.write("\nno GLSA given, so we'll do nothing for now. \n")
- sys.stderr.write("If you want to run on all GLSA please tell me so \n")
- sys.stderr.write("(specify \"all\" as parameter)\n\n")
- mode = "help"
-elif len(params) <= 0 and mode == "list":
- params.append("new")
-
-# show help message
-if mode == "help":
- sys.stderr.write("\nSyntax: glsa-check <option> [glsa-list]\n\n")
- for m in optionmap:
- sys.stderr.write(m[0] + "\t" + m[1] + " \t: " + m[-1] + "\n")
- for o in m[2:-1]:
- sys.stderr.write("\t" + o + "\n")
- sys.stderr.write("\nglsa-list can contain an arbitrary number of GLSA ids, \n")
- sys.stderr.write("filenames containing GLSAs or the special identifiers \n")
- sys.stderr.write("'all', 'new' and 'affected'\n")
- sys.exit(1)
-
-# we need root priviledges for write access
-if mode in ["fix", "inject"] and os.geteuid() != 0:
- sys.stderr.write("\nThis tool needs root access to "+mode+" this GLSA\n\n")
- sys.exit(2)
-
-# show version and copyright information
-if mode == "version":
- sys.stderr.write("\n"+ __program__ + ", version " + __version__ + "\n")
- sys.stderr.write("Author: " + __author__ + "\n")
- sys.stderr.write("This program is licensed under the GPL, version 2\n\n")
- sys.exit(0)
-
-# delay this for speed increase
-from portage.glsa import *
-
-vardb = portage.db[portage.settings["ROOT"]]["vartree"].dbapi
-portdb = portage.db["/"]["porttree"].dbapi
-
-# build glsa lists
-completelist = get_glsa_list(portage.settings)
-
-checklist = get_applied_glsas(portage.settings)
-todolist = [e for e in completelist if e not in checklist]
-
-glsalist = []
-if "new" in params:
- glsalist = todolist
- params.remove("new")
-
-if "all" in params:
- glsalist = completelist
- params.remove("all")
-if "affected" in params:
- # replaced completelist with todolist on request of wschlich
- for x in todolist:
- try:
- myglsa = Glsa(x, portage.settings, vardb, portdb)
- except (GlsaTypeException, GlsaFormatException), e:
- if verbose:
- sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (x, e)))
- continue
- if myglsa.isVulnerable():
- glsalist.append(x)
- params.remove("affected")
-
-# remove invalid parameters
-for p in params[:]:
- if not (p in completelist or os.path.exists(p)):
- sys.stderr.write(("(removing %s from parameter list as it isn't a valid GLSA specification)\n" % p))
- params.remove(p)
-
-glsalist.extend([g for g in params if g not in glsalist])
-
-def summarylist(myglsalist, fd1=sys.stdout, fd2=sys.stderr):
- fd2.write(white("[A]")+" means this GLSA was already applied,\n")
- fd2.write(green("[U]")+" means the system is not affected and\n")
- fd2.write(red("[N]")+" indicates that the system might be affected.\n\n")
-
- myglsalist.sort()
- for myid in myglsalist:
- try:
- myglsa = Glsa(myid, portage.settings, vardb, portdb)
- except (GlsaTypeException, GlsaFormatException), e:
- if verbose:
- fd2.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
- continue
- if myglsa.isApplied():
- status = "[A]"
- color = white
- elif myglsa.isVulnerable():
- status = "[N]"
- color = red
- else:
- status = "[U]"
- color = green
-
- if verbose:
- access = ("[%-8s] " % myglsa.access)
- else:
- access=""
-
- fd1.write(color(myglsa.nr) + " " + color(status) + " " + color(access) + myglsa.title + " (")
- if not verbose:
- for pkg in myglsa.packages.keys()[:3]:
- fd1.write(" " + pkg + " ")
- if len(myglsa.packages) > 3:
- fd1.write("... ")
- else:
- for pkg in myglsa.packages.keys():
- mylist = vardb.match(portage.dep_getkey(pkg))
- if len(mylist) > 0:
- pkg = color(" ".join(mylist))
- fd1.write(" " + pkg + " ")
-
- fd1.write(")")
- if list_cve:
- fd1.write(" "+(",".join([r[:13] for r in myglsa.references if r[:4] in ["CAN-", "CVE-"]])))
- fd1.write("\n")
- return 0
-
-if mode == "list":
- sys.exit(summarylist(glsalist))
-
-# dump, fix, inject and fix are nearly the same code, only the glsa method call differs
-if mode in ["dump", "fix", "inject", "pretend"]:
- for myid in glsalist:
- try:
- myglsa = Glsa(myid, portage.settings, vardb, portdb)
- except (GlsaTypeException, GlsaFormatException), e:
- if verbose:
- sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
- continue
- if mode == "dump":
- myglsa.dump()
- elif mode == "fix":
- sys.stdout.write("fixing "+myid+"\n")
- mergelist = myglsa.getMergeList(least_change=least_change)
- for pkg in mergelist:
- sys.stdout.write(">>> merging "+pkg+"\n")
- # using emerge for the actual merging as it contains the dependency
- # code and we want to be consistent in behaviour. Also this functionality
- # will be integrated in emerge later, so it shouldn't hurt much.
- emergecmd = "emerge --oneshot " + portage.settings["EMERGE_OPTS"] + " =" + pkg
- if verbose:
- sys.stderr.write(emergecmd+"\n")
- exitcode = os.system(emergecmd)
- # system() returns the exitcode in the high byte of a 16bit integer
- if exitcode >= 1<<8:
- exitcode >>= 8
- if exitcode:
- sys.exit(exitcode)
- myglsa.inject()
- elif mode == "pretend":
- sys.stdout.write("Checking GLSA "+myid+"\n")
- mergelist = myglsa.getMergeList(least_change=least_change)
- if mergelist:
- sys.stdout.write("The following updates will be performed for this GLSA:\n")
- for pkg in mergelist:
- oldver = None
- for x in vardb.match(portage.dep_getkey(pkg)):
- if vardb.aux_get(x, ["SLOT"]) == portdb.aux_get(pkg, ["SLOT"]):
- oldver = x
- if oldver == None:
- raise ValueError("could not find old version for package %s" % pkg)
- oldver = oldver[len(portage.dep_getkey(oldver))+1:]
- sys.stdout.write(" " + pkg + " (" + oldver + ")\n")
- else:
- sys.stdout.write("Nothing to do for this GLSA\n")
- elif mode == "inject":
- sys.stdout.write("injecting " + myid + "\n")
- myglsa.inject()
- sys.stdout.write("\n")
- sys.exit(0)
-
-# test is a bit different as Glsa.test() produces no output
-if mode == "test":
- outputlist = []
- for myid in glsalist:
- try:
- myglsa = Glsa(myid, portage.settings, vardb, portdb)
- except (GlsaTypeException, GlsaFormatException), e:
- if verbose:
- sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
- continue
- if myglsa.isVulnerable():
- outputlist.append(str(myglsa.nr))
- if len(outputlist) > 0:
- sys.stderr.write("This system is affected by the following GLSAs:\n")
- if verbose:
- summarylist(outputlist)
- else:
- sys.stdout.write("\n".join(outputlist)+"\n")
- else:
- sys.stderr.write("This system is not affected by any of the listed GLSAs\n")
- sys.exit(0)
-
-# mail mode as requested by solar
-if mode == "mail":
- import portage.mail, socket
- from StringIO import StringIO
- from email.mime.text import MIMEText
-
- # color doesn't make any sense for mail
- nocolor()
-
- if "PORTAGE_ELOG_MAILURI" in portage.settings:
- myrecipient = portage.settings["PORTAGE_ELOG_MAILURI"].split()[0]
- else:
- myrecipient = "root@localhost"
-
- if "PORTAGE_ELOG_MAILFROM" in portage.settings:
- myfrom = portage.settings["PORTAGE_ELOG_MAILFROM"]
- else:
- myfrom = "glsa-check"
-
- mysubject = "[glsa-check] Summary for %s" % socket.getfqdn()
-
- # need a file object for summarylist()
- myfd = StringIO()
- myfd.write("GLSA Summary report for host %s\n" % socket.getfqdn())
- myfd.write("(Command was: %s)\n\n" % " ".join(sys.argv))
- summarylist(glsalist, fd1=myfd, fd2=myfd)
- summary = str(myfd.getvalue())
- myfd.close()
-
- myattachments = []
- for myid in glsalist:
- try:
- myglsa = Glsa(myid, portage.settings, vardb, portdb)
- except (GlsaTypeException, GlsaFormatException), e:
- if verbose:
- sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
- continue
- myfd = StringIO()
- myglsa.dump(outstream=myfd)
- myattachments.append(MIMEText(str(myfd.getvalue()), _charset="utf8"))
- myfd.close()
-
- mymessage = portage.mail.create_message(myfrom, myrecipient, mysubject, summary, myattachments)
- portage.mail.send_mail(portage.settings, mymessage)
-
- sys.exit(0)
-
-# something wrong here, all valid paths are covered with sys.exit()
-sys.stderr.write("nothing more to do\n")
-sys.exit(2)
+++ /dev/null
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-from portage.versions import catpkgsplit, catsplit, pkgcmp, best
-from portage.dep import Atom
-from portage._sets.base import PackageSet
-from portage._sets import SetConfigError, get_boolean
-
-__all__ = ["CategorySet", "DowngradeSet",
- "EverythingSet", "OwnerSet", "VariableSet"]
-
-class EverythingSet(PackageSet):
- _operations = ["merge"]
- description = "Package set which contains SLOT " + \
- "atoms to match all installed packages"
- _filter = None
-
- def __init__(self, vdbapi):
- super(EverythingSet, self).__init__()
- self._db = vdbapi
-
- def load(self):
- myatoms = []
- db_keys = ["SLOT"]
- aux_get = self._db.aux_get
- cp_list = self._db.cp_list
-
- for cp in self._db.cp_all():
- cpv_list = cp_list(cp)
-
- if len(cpv_list) > 1:
- for cpv in cpv_list:
- slot, = aux_get(cpv, db_keys)
- atom = Atom("%s:%s" % (cp, slot))
- if self._filter:
- if self._filter(atom):
- myatoms.append(atom)
- else:
- myatoms.append(atom)
-
- else:
- atom = Atom(cp)
- if self._filter:
- if self._filter(atom):
- myatoms.append(atom)
- else:
- myatoms.append(atom)
-
- self._setAtoms(myatoms)
-
- def singleBuilder(self, options, settings, trees):
- return EverythingSet(trees["vartree"].dbapi)
- singleBuilder = classmethod(singleBuilder)
-
-class OwnerSet(PackageSet):
-
- _operations = ["merge", "unmerge"]
-
- description = "Package set which contains all packages " + \
- "that own one or more files."
-
- def __init__(self, vardb=None, files=None):
- super(OwnerSet, self).__init__()
- self._db = vardb
- self._files = files
-
- def mapPathsToAtoms(self, paths):
- rValue = set()
- vardb = self._db
- aux_get = vardb.aux_get
- aux_keys = ["SLOT"]
- for link, p in vardb._owners.iter_owners(paths):
- cat, pn = catpkgsplit(link.mycpv)[:2]
- slot, = aux_get(link.mycpv, aux_keys)
- rValue.add("%s/%s:%s" % (cat, pn, slot))
- return rValue
-
- def load(self):
- self._setAtoms(self.mapPathsToAtoms(self._files))
-
- def singleBuilder(cls, options, settings, trees):
- if not "files" in options:
- raise SetConfigError("no files given")
-
- import shlex
- return cls(vardb=trees["vartree"].dbapi,
- files=frozenset(shlex.split(options["files"])))
-
- singleBuilder = classmethod(singleBuilder)
-
-class VariableSet(EverythingSet):
-
- _operations = ["merge", "unmerge"]
-
- description = "Package set which contains all packages " + \
- "that match specified values of a specified variable."
-
- def __init__(self, vardb, metadatadb=None, variable=None, includes=None, excludes=None):
- super(VariableSet, self).__init__(vardb)
- self._metadatadb = metadatadb
- self._variable = variable
- self._includes = includes
- self._excludes = excludes
-
- def _filter(self, atom):
- ebuild = best(self._metadatadb.match(atom))
- if not ebuild:
- return False
- values, = self._metadatadb.aux_get(ebuild, [self._variable])
- values = values.split()
- if self._includes and not self._includes.intersection(values):
- return False
- if self._excludes and self._excludes.intersection(values):
- return False
- return True
-
- def singleBuilder(cls, options, settings, trees):
-
- variable = options.get("variable")
- if variable is None:
- raise SetConfigError("missing required attribute: 'variable'")
-
- includes = options.get("includes", "")
- excludes = options.get("excludes", "")
-
- if not (includes or excludes):
- raise SetConfigError("no includes or excludes given")
-
- metadatadb = options.get("metadata-source", "vartree")
- if not metadatadb in trees.keys():
- raise SetConfigError("invalid value '%s' for option metadata-source" % metadatadb)
-
- return cls(trees["vartree"].dbapi,
- metadatadb=trees[metadatadb].dbapi,
- excludes=frozenset(excludes.split()),
- includes=frozenset(includes.split()),
- variable=variable)
-
- singleBuilder = classmethod(singleBuilder)
-
-class DowngradeSet(PackageSet):
-
- _operations = ["merge", "unmerge"]
-
- description = "Package set which contains all packages " + \
- "for which the highest visible ebuild version is lower than " + \
- "the currently installed version."
-
- def __init__(self, portdb=None, vardb=None):
- super(DowngradeSet, self).__init__()
- self._portdb = portdb
- self._vardb = vardb
-
- def load(self):
- atoms = []
- xmatch = self._portdb.xmatch
- xmatch_level = "bestmatch-visible"
- cp_list = self._vardb.cp_list
- aux_get = self._vardb.aux_get
- aux_keys = ["SLOT"]
- for cp in self._vardb.cp_all():
- for cpv in cp_list(cp):
- slot, = aux_get(cpv, aux_keys)
- slot_atom = "%s:%s" % (cp, slot)
- ebuild = xmatch(xmatch_level, slot_atom)
- if not ebuild:
- continue
- ebuild_split = catpkgsplit(ebuild)[1:]
- installed_split = catpkgsplit(cpv)[1:]
- if pkgcmp(installed_split, ebuild_split) > 0:
- atoms.append(slot_atom)
-
- self._setAtoms(atoms)
-
- def singleBuilder(cls, options, settings, trees):
- return cls(portdb=trees["porttree"].dbapi,
- vardb=trees["vartree"].dbapi)
-
- singleBuilder = classmethod(singleBuilder)
-
-class CategorySet(PackageSet):
- _operations = ["merge", "unmerge"]
-
- def __init__(self, category, dbapi, only_visible=True):
- super(CategorySet, self).__init__()
- self._db = dbapi
- self._category = category
- self._check = only_visible
- if only_visible:
- s="visible"
- else:
- s="all"
- self.description = "Package set containing %s packages of category %s" % (s, self._category)
-
- def load(self):
- myatoms = []
- for cp in self._db.cp_all():
- if catsplit(cp)[0] == self._category:
- if (not self._check) or len(self._db.match(cp)) > 0:
- myatoms.append(cp)
- self._setAtoms(myatoms)
-
- def _builderGetVisible(cls, options):
- return get_boolean(options, "only_visible", True)
- _builderGetVisible = classmethod(_builderGetVisible)
-
- def singleBuilder(cls, options, settings, trees):
- if not "category" in options:
- raise SetConfigError("no category given")
-
- category = options["category"]
- if not category in settings.categories:
- raise SetConfigError("invalid category name '%s'" % category)
-
- visible = cls._builderGetVisible(options)
-
- return CategorySet(category, dbapi=trees["porttree"].dbapi, only_visible=visible)
- singleBuilder = classmethod(singleBuilder)
-
- def multiBuilder(cls, options, settings, trees):
- rValue = {}
-
- if "categories" in options:
- categories = options["categories"].split()
- invalid = set(categories).difference(settings.categories)
- if invalid:
- raise SetConfigError("invalid categories: %s" % ", ".join(list(invalid)))
- else:
- categories = settings.categories
-
- visible = cls._builderGetVisible(options)
- name_pattern = options.get("name_pattern", "$category/*")
-
- if not "$category" in name_pattern and not "${category}" in name_pattern:
- raise SetConfigError("name_pattern doesn't include $category placeholder")
-
- for cat in categories:
- myset = CategorySet(cat, trees["porttree"].dbapi, only_visible=visible)
- myname = name_pattern.replace("$category", cat)
- myname = myname.replace("${category}", cat)
- rValue[myname] = myset
- return rValue
- multiBuilder = classmethod(multiBuilder)
-
-class AgeSet(EverythingSet):
- _operations = ["merge", "unmerge"]
-
- def __init__(self, vardb, mode="older", age=7):
- super(AgeSet, self).__init__(vardb)
- self._mode = mode
- self._age = age
-
- def _filter(self, atom):
- import time, os
-
- cpv = self._db.match(atom)[0]
- path = self._db.getpath(cpv, filename="COUNTER")
- age = (time.time() - os.stat(path).st_mtime) / (3600 * 24)
- if ((self._mode == "older" and age <= self._age) \
- or (self._mode == "newer" and age >= self._age)):
- return False
- else:
- return True
-
- def singleBuilder(cls, options, settings, trees):
- mode = options.get("mode", "older")
- if str(mode).lower() not in ["newer", "older"]:
- raise SetConfigError("invalid 'mode' value %s (use either 'newer' or 'older')" % mode)
- try:
- age = int(options.get("age", "7"))
- except ValueError, e:
- raise SetConfigError("value of option 'age' is not an integer")
- return AgeSet(vardb=trees["vartree"].dbapi, mode=mode, age=age)
-
- singleBuilder = classmethod(singleBuilder)
+++ /dev/null
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-from portage._sets.base import PackageSet
-from portage._sets import get_boolean
-from portage.versions import catpkgsplit
-
-class LibraryConsumerSet(PackageSet):
- _operations = ["merge", "unmerge"]
-
- def __init__(self, vardbapi, debug=False):
- super(LibraryConsumerSet, self).__init__()
- self.dbapi = vardbapi
- self.debug = debug
-
- def mapPathsToAtoms(self, paths):
- rValue = set()
- for link, p in self.dbapi._owners.iter_owners(paths):
- cat, pn = catpkgsplit(link.mycpv)[:2]
- slot = self.dbapi.aux_get(link.mycpv, ["SLOT"])[0]
- rValue.add("%s/%s:%s" % (cat, pn, slot))
- return rValue
+++ /dev/null
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-import os
-import portage.glsa as glsa
-from portage.util import grabfile, write_atomic
-from portage._sets.base import PackageSet
-from portage.versions import catpkgsplit, pkgcmp
-from portage._sets import get_boolean
-
-__all__ = ["SecuritySet", "NewGlsaSet", "NewAffectedSet", "AffectedSet"]
-
-class SecuritySet(PackageSet):
- _operations = ["merge"]
- _skip_applied = False
-
- description = "package set that includes all packages possibly affected by a GLSA"
-
- def __init__(self, settings, vardbapi, portdbapi, least_change=True):
- super(SecuritySet, self).__init__()
- self._settings = settings
- self._vardbapi = vardbapi
- self._portdbapi = portdbapi
- self._least_change = least_change
-
- def getGlsaList(self, skip_applied):
- glsaindexlist = glsa.get_glsa_list(self._settings)
- if skip_applied:
- applied_list = glsa.get_applied_glsas(self._settings)
- glsaindexlist = set(glsaindexlist).difference(applied_list)
- glsaindexlist = list(glsaindexlist)
- glsaindexlist.sort()
- return glsaindexlist
-
- def load(self):
- glsaindexlist = self.getGlsaList(self._skip_applied)
- atomlist = []
- for glsaid in glsaindexlist:
- myglsa = glsa.Glsa(glsaid, self._settings, self._vardbapi, self._portdbapi)
- #print glsaid, myglsa.isVulnerable(), myglsa.isApplied(), myglsa.getMergeList()
- if self.useGlsa(myglsa):
- atomlist += ["="+x for x in myglsa.getMergeList(least_change=self._least_change)]
- self._setAtoms(self._reduce(atomlist))
-
- def _reduce(self, atomlist):
- mydict = {}
- for atom in atomlist[:]:
- cpv = self._portdbapi.xmatch("match-all", atom)[0]
- slot = self._portdbapi.aux_get(cpv, ["SLOT"])[0]
- cps = "/".join(catpkgsplit(cpv)[0:2]) + ":" + slot
- if not cps in mydict:
- mydict[cps] = (atom, cpv)
- else:
- other_cpv = mydict[cps][1]
- if pkgcmp(catpkgsplit(cpv)[1:], catpkgsplit(other_cpv)[1:]) > 0:
- atomlist.remove(mydict[cps][0])
- mydict[cps] = (atom, cpv)
- return atomlist
-
- def useGlsa(self, myglsa):
- return True
-
- def updateAppliedList(self):
- glsaindexlist = self.getGlsaList(True)
- applied_list = glsa.get_applied_glsas(self._settings)
- for glsaid in glsaindexlist:
- myglsa = glsa.Glsa(glsaid, self._settings, self._vardbapi, self._portdbapi)
- if not myglsa.isVulnerable() and not myglsa.nr in applied_list:
- myglsa.inject()
-
- def singleBuilder(cls, options, settings, trees):
- least_change = not get_boolean(options, "use_emerge_resolver", False)
- return cls(settings, trees["vartree"].dbapi, trees["porttree"].dbapi, least_change=least_change)
- singleBuilder = classmethod(singleBuilder)
-
-class NewGlsaSet(SecuritySet):
- _skip_applied = True
- description = "Package set that includes all packages possibly affected by an unapplied GLSA"
-
-class AffectedSet(SecuritySet):
- description = "Package set that includes all packages affected by an unapplied GLSA"
-
- def useGlsa(self, myglsa):
- return myglsa.isVulnerable()
-
-class NewAffectedSet(AffectedSet):
- _skip_applied = True
- description = "Package set that includes all packages affected by an unapplied GLSA"
+++ /dev/null
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-import subprocess
-import os
-
-from portage._sets.base import PackageSet
-from portage._sets import SetConfigError
-
-__all__ = ["CommandOutputSet"]
-
-class CommandOutputSet(PackageSet):
- """This class creates a PackageSet from the output of a shell command.
- The shell command should produce one atom per line, that is:
-
- >>> atom1
- atom2
- ...
- atomN
-
- Args:
- name: A string that identifies the set.
- command: A string or sequence identifying the command to run
- (see the subprocess.Popen documentaion for the format)
- """
- _operations = ["merge", "unmerge"]
-
- def __init__(self, command):
- super(CommandOutputSet, self).__init__()
- self._command = command
- self.description = "Package set generated from output of '%s'" % self._command
-
- def load(self):
- pipe = subprocess.Popen(self._command, stdout=subprocess.PIPE, shell=True)
- if pipe.wait() == os.EX_OK:
- text = pipe.stdout.read()
- self._setAtoms(text.split("\n"))
-
- def singleBuilder(self, options, settings, trees):
- if not "command" in options:
- raise SetConfigError("no command specified")
- return CommandOutputSet(options["command"])
- singleBuilder = classmethod(singleBuilder)
+++ /dev/null
-# Copyright 2003-2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-import os
-import sys
-import urllib
-import re
-import xml.dom.minidom
-
-from portage.versions import pkgsplit, catpkgsplit, pkgcmp, best
-from portage.util import grabfile
-from portage.const import CACHE_PATH
-
-# Note: the space for rgt and rlt is important !!
-# FIXME: use slot deps instead, requires GLSA format versioning
-opMapping = {"le": "<=", "lt": "<", "eq": "=", "gt": ">", "ge": ">=",
- "rge": ">=~", "rle": "<=~", "rgt": " >~", "rlt": " <~"}
-NEWLINE_ESCAPE = "!;\\n" # some random string to mark newlines that should be preserved
-SPACE_ESCAPE = "!;_" # some random string to mark spaces that should be preserved
-
-def get_applied_glsas(settings):
- """
- Return a list of applied or injected GLSA IDs
-
- @type settings: portage.config
- @param settings: portage config instance
- @rtype: list
- @return: list of glsa IDs
- """
- return grabfile(os.path.join(os.sep, settings["ROOT"], CACHE_PATH.lstrip(os.sep), "glsa"))
-
-
-# TODO: use the textwrap module instead
-def wrap(text, width, caption=""):
- """
- Wraps the given text at column I{width}, optionally indenting
- it so that no text is under I{caption}. It's possible to encode
- hard linebreaks in I{text} with L{NEWLINE_ESCAPE}.
-
- @type text: String
- @param text: the text to be wrapped
- @type width: Integer
- @param width: the column at which the text should be wrapped
- @type caption: String
- @param caption: this string is inserted at the beginning of the
- return value and the paragraph is indented up to
- C{len(caption)}.
- @rtype: String
- @return: the wrapped and indented paragraph
- """
- rValue = ""
- line = caption
- text = text.replace(2*NEWLINE_ESCAPE, NEWLINE_ESCAPE+" "+NEWLINE_ESCAPE)
- words = text.split()
- indentLevel = len(caption)+1
-
- for w in words:
- if line != "" and line[-1] == "\n":
- rValue += line
- line = " "*indentLevel
- if len(line)+len(w.replace(NEWLINE_ESCAPE, ""))+1 > width:
- rValue += line+"\n"
- line = " "*indentLevel+w.replace(NEWLINE_ESCAPE, "\n")
- elif w.find(NEWLINE_ESCAPE) >= 0:
- if len(line.strip()) > 0:
- rValue += line+" "+w.replace(NEWLINE_ESCAPE, "\n")
- else:
- rValue += line+w.replace(NEWLINE_ESCAPE, "\n")
- line = " "*indentLevel
- else:
- if len(line.strip()) > 0:
- line += " "+w
- else:
- line += w
- if len(line) > 0:
- rValue += line.replace(NEWLINE_ESCAPE, "\n")
- rValue = rValue.replace(SPACE_ESCAPE, " ")
- return rValue
-
-def get_glsa_list(myconfig):
- """
- Returns a list of all available GLSAs in the given repository
- by comparing the filelist there with the pattern described in
- the config.
-
- @type myconfig: portage.config
- @param myconfig: Portage settings instance
-
- @rtype: List of Strings
- @return: a list of GLSA IDs in this repository
- """
- rValue = []
-
- if "GLSA_DIR" in myconfig:
- repository = myconfig["GLSA_DIR"]
- else:
- repository = os.path.join(myconfig["PORTDIR"], "metadata", "glsa")
-
- if not os.access(repository, os.R_OK):
- return []
- dirlist = os.listdir(repository)
- prefix = "glsa-"
- suffix = ".xml"
-
- for f in dirlist:
- try:
- if f[:len(prefix)] == prefix:
- rValue.append(f[len(prefix):-1*len(suffix)])
- except IndexError:
- pass
- return rValue
-
-def getListElements(listnode):
- """
- Get all <li> elements for a given <ol> or <ul> node.
-
- @type listnode: xml.dom.Node
- @param listnode: <ul> or <ol> list to get the elements for
- @rtype: List of Strings
- @return: a list that contains the value of the <li> elements
- """
- rValue = []
- if not listnode.nodeName in ["ul", "ol"]:
- raise GlsaFormatException("Invalid function call: listnode is not <ul> or <ol>")
- for li in listnode.childNodes:
- if li.nodeType != xml.dom.Node.ELEMENT_NODE:
- continue
- rValue.append(getText(li, format="strip"))
- return rValue
-
-def getText(node, format):
- """
- This is the main parser function. It takes a node and traverses
- recursive over the subnodes, getting the text of each (and the
- I{link} attribute for <uri> and <mail>). Depending on the I{format}
- parameter the text might be formatted by adding/removing newlines,
- tabs and spaces. This function is only useful for the GLSA DTD,
- it's not applicable for other DTDs.
-
- @type node: xml.dom.Node
- @param node: the root node to start with the parsing
- @type format: String
- @param format: this should be either I{strip}, I{keep} or I{xml}
- I{keep} just gets the text and does no formatting.
- I{strip} replaces newlines and tabs with spaces and
- replaces multiple spaces with one space.
- I{xml} does some more formatting, depending on the
- type of the encountered nodes.
- @rtype: String
- @return: the (formatted) content of the node and its subnodes
- """
- rValue = ""
- if format in ["strip", "keep"]:
- if node.nodeName in ["uri", "mail"]:
- rValue += node.childNodes[0].data+": "+node.getAttribute("link")
- else:
- for subnode in node.childNodes:
- if subnode.nodeName == "#text":
- rValue += subnode.data
- else:
- rValue += getText(subnode, format)
- else:
- for subnode in node.childNodes:
- if subnode.nodeName == "p":
- for p_subnode in subnode.childNodes:
- if p_subnode.nodeName == "#text":
- rValue += p_subnode.data.strip()
- elif p_subnode.nodeName in ["uri", "mail"]:
- rValue += p_subnode.childNodes[0].data
- rValue += " ( "+p_subnode.getAttribute("link")+" )"
- rValue += NEWLINE_ESCAPE
- elif subnode.nodeName == "ul":
- for li in getListElements(subnode):
- rValue += "-"+SPACE_ESCAPE+li+NEWLINE_ESCAPE+" "
- elif subnode.nodeName == "ol":
- i = 0
- for li in getListElements(subnode):
- i = i+1
- rValue += str(i)+"."+SPACE_ESCAPE+li+NEWLINE_ESCAPE+" "
- elif subnode.nodeName == "code":
- rValue += getText(subnode, format="keep").replace("\n", NEWLINE_ESCAPE)
- if rValue[-1*len(NEWLINE_ESCAPE):] != NEWLINE_ESCAPE:
- rValue += NEWLINE_ESCAPE
- elif subnode.nodeName == "#text":
- rValue += subnode.data
- else:
- raise GlsaFormatException("Invalid Tag found: ", subnode.nodeName)
- if format == "strip":
- rValue = rValue.strip(" \n\t")
- rValue = re.sub("[\s]{2,}", " ", rValue)
- return rValue.encode("utf_8")
-
-def getMultiTagsText(rootnode, tagname, format):
- """
- Returns a list with the text of all subnodes of type I{tagname}
- under I{rootnode} (which itself is not parsed) using the given I{format}.
-
- @type rootnode: xml.dom.Node
- @param rootnode: the node to search for I{tagname}
- @type tagname: String
- @param tagname: the name of the tags to search for
- @type format: String
- @param format: see L{getText}
- @rtype: List of Strings
- @return: a list containing the text of all I{tagname} childnodes
- """
- rValue = []
- for e in rootnode.getElementsByTagName(tagname):
- rValue.append(getText(e, format))
- return rValue
-
-def makeAtom(pkgname, versionNode):
- """
- creates from the given package name and information in the
- I{versionNode} a (syntactical) valid portage atom.
-
- @type pkgname: String
- @param pkgname: the name of the package for this atom
- @type versionNode: xml.dom.Node
- @param versionNode: a <vulnerable> or <unaffected> Node that
- contains the version information for this atom
- @rtype: String
- @return: the portage atom
- """
- rValue = opMapping[versionNode.getAttribute("range")] \
- + pkgname \
- + "-" + getText(versionNode, format="strip")
- try:
- slot = versionNode.getAttribute("slot").strip()
- except KeyError:
- pass
- else:
- if slot and slot != "*":
- rValue += ":" + slot
- return str(rValue)
-
-def makeVersion(versionNode):
- """
- creates from the information in the I{versionNode} a
- version string (format <op><version>).
-
- @type versionNode: xml.dom.Node
- @param versionNode: a <vulnerable> or <unaffected> Node that
- contains the version information for this atom
- @rtype: String
- @return: the version string
- """
- rValue = opMapping[versionNode.getAttribute("range")] \
- + getText(versionNode, format="strip")
- try:
- slot = versionNode.getAttribute("slot").strip()
- except KeyError:
- pass
- else:
- if slot and slot != "*":
- rValue += ":" + slot
- return rValue
-
-def match(atom, dbapi, match_type="default"):
- """
- wrapper that calls revisionMatch() or portage.dbapi.match() depending on
- the given atom.
-
- @type atom: string
- @param atom: a <~ or >~ atom or a normal portage atom that contains the atom to match against
- @type dbapi: portage.dbapi
- @param dbapi: one of the portage databases to use as information source
- @type match_type: string
- @param match_type: if != "default" passed as first argument to dbapi.xmatch
- to apply the wanted visibility filters
-
- @rtype: list of strings
- @return: a list with the matching versions
- """
- if atom[2] == "~":
- return revisionMatch(atom, dbapi, match_type=match_type)
- elif match_type == "default" or not hasattr(dbapi, "xmatch"):
- return dbapi.match(atom)
- else:
- return dbapi.xmatch(match_type, atom)
-
-def revisionMatch(revisionAtom, dbapi, match_type="default"):
- """
- handler for the special >~, >=~, <=~ and <~ atoms that are supposed to behave
- as > and < except that they are limited to the same version, the range only
- applies to the revision part.
-
- @type revisionAtom: string
- @param revisionAtom: a <~ or >~ atom that contains the atom to match against
- @type dbapi: portage.dbapi
- @param dbapi: one of the portage databases to use as information source
- @type match_type: string
- @param match_type: if != "default" passed as first argument to portdb.xmatch
- to apply the wanted visibility filters
-
- @rtype: list of strings
- @return: a list with the matching versions
- """
- if match_type == "default" or not hasattr(dbapi, "xmatch"):
- if ":" in revisionAtom:
- mylist = dbapi.match(re.sub(r'-r[0-9]+(:[^ ]+)?$', r'\1', revisionAtom[2:]))
- else:
- mylist = dbapi.match(re.sub("-r[0-9]+$", "", revisionAtom[2:]))
- else:
- if ":" in revisionAtom:
- mylist = dbapi.xmatch(match_type, re.sub(r'-r[0-9]+(:[^ ]+)?$', r'\1', revisionAtom[2:]))
- else:
- mylist = dbapi.xmatch(match_type, re.sub("-r[0-9]+$", "", revisionAtom[2:]))
- rValue = []
- for v in mylist:
- r1 = pkgsplit(v)[-1][1:]
- r2 = pkgsplit(revisionAtom[3:])[-1][1:]
- if eval(r1+" "+revisionAtom[0:2]+" "+r2):
- rValue.append(v)
- return rValue
-
-
-def getMinUpgrade(vulnerableList, unaffectedList, portdbapi, vardbapi, minimize=True):
- """
- Checks if the systemstate is matching an atom in
- I{vulnerableList} and returns string describing
- the lowest version for the package that matches an atom in
- I{unaffectedList} and is greater than the currently installed
- version or None if the system is not affected. Both
- I{vulnerableList} and I{unaffectedList} should have the
- same base package.
-
- @type vulnerableList: List of Strings
- @param vulnerableList: atoms matching vulnerable package versions
- @type unaffectedList: List of Strings
- @param unaffectedList: atoms matching unaffected package versions
- @type portdbapi: portage.dbapi.porttree.portdbapi
- @param portdbapi: Ebuild repository
- @type vardbapi: portage.dbapi.vartree.vardbapi
- @param vardbapi: Installed package repository
- @type minimize: Boolean
- @param minimize: True for a least-change upgrade, False for emerge-like algorithm
-
- @rtype: String | None
- @return: the lowest unaffected version that is greater than
- the installed version.
- """
- rValue = None
- v_installed = []
- u_installed = []
- for v in vulnerableList:
- v_installed += match(v, vardbapi)
-
- for u in unaffectedList:
- u_installed += match(u, vardbapi)
-
- install_unaffected = True
- for i in v_installed:
- if i not in u_installed:
- install_unaffected = False
-
- if install_unaffected:
- return rValue
-
- for u in unaffectedList:
- mylist = match(u, portdbapi, match_type="match-all")
- for c in mylist:
- c_pv = catpkgsplit(c)
- i_pv = catpkgsplit(best(v_installed))
- if pkgcmp(c_pv[1:], i_pv[1:]) > 0 \
- and (rValue == None \
- or not match("="+rValue, portdbapi) \
- or (minimize ^ (pkgcmp(c_pv[1:], catpkgsplit(rValue)[1:]) > 0)) \
- and match("="+c, portdbapi)) \
- and portdbapi.aux_get(c, ["SLOT"]) == vardbapi.aux_get(best(v_installed), ["SLOT"]):
- rValue = c_pv[0]+"/"+c_pv[1]+"-"+c_pv[2]
- if c_pv[3] != "r0": # we don't like -r0 for display
- rValue += "-"+c_pv[3]
- return rValue
-
-def format_date(datestr):
- """
- Takes a date (announced, revised) date from a GLSA and formats
- it as readable text (i.e. "January 1, 2008").
-
- @type date: String
- @param date: the date string to reformat
- @rtype: String
- @return: a reformatted string, or the original string
- if it cannot be reformatted.
- """
- splitdate = datestr.split("-", 2)
- if len(splitdate) != 3:
- return datestr
-
- # This cannot raise an error as we use () instead of []
- splitdate = (int(x) for x in splitdate)
-
- from datetime import date
- try:
- d = date(*splitdate)
- except ValueError:
- return datestr
-
- # TODO We could format to local date format '%x' here?
- return d.strftime("%B %d, %Y")
-
-# simple Exception classes to catch specific errors
-class GlsaTypeException(Exception):
- def __init__(self, doctype):
- Exception.__init__(self, "wrong DOCTYPE: %s" % doctype)
-
-class GlsaFormatException(Exception):
- pass
-
-class GlsaArgumentException(Exception):
- pass
-
-# GLSA xml data wrapper class
-class Glsa:
- """
- This class is a wrapper for the XML data and provides methods to access
- and display the contained data.
- """
- def __init__(self, myid, myconfig, vardbapi, portdbapi):
- """
- Simple constructor to set the ID, store the config and gets the
- XML data by calling C{self.read()}.
-
- @type myid: String
- @param myid: String describing the id for the GLSA object (standard
- GLSAs have an ID of the form YYYYMM-nn) or an existing
- filename containing a GLSA.
- @type myconfig: portage.config
- @param myconfig: the config that should be used for this object.
- @type vardbapi: portage.dbapi.vartree.vardbapi
- @param vardbapi: installed package repository
- @type portdbapi: portage.dbapi.porttree.portdbapi
- @param portdbapi: ebuild repository
- """
- if re.match(r'\d{6}-\d{2}', myid):
- self.type = "id"
- elif os.path.exists(myid):
- self.type = "file"
- else:
- raise GlsaArgumentException("Given ID "+myid+" isn't a valid GLSA ID or filename.")
- self.nr = myid
- self.config = myconfig
- self.vardbapi = vardbapi
- self.portdbapi = portdbapi
- self.read()
-
- def read(self):
- """
- Here we build the filename from the config and the ID and pass
- it to urllib to fetch it from the filesystem or a remote server.
-
- @rtype: None
- @return: None
- """
- if "GLSA_DIR" in self.config:
- repository = "file://" + self.config["GLSA_DIR"]+"/"
- else:
- repository = "file://" + self.config["PORTDIR"] + "/metadata/glsa/"
- if self.type == "file":
- myurl = "file://"+self.nr
- else:
- myurl = repository + "glsa-%s.xml" % str(self.nr)
- self.parse(urllib.urlopen(myurl))
- return None
-
- def parse(self, myfile):
- """
- This method parses the XML file and sets up the internal data
- structures by calling the different helper functions in this
- module.
-
- @type myfile: String
- @param myfile: Filename to grab the XML data from
- @rtype: None
- @returns: None
- """
- self.DOM = xml.dom.minidom.parse(myfile)
- if not self.DOM.doctype:
- raise GlsaTypeException(None)
- elif self.DOM.doctype.systemId == "http://www.gentoo.org/dtd/glsa.dtd":
- self.dtdversion = 0
- elif self.DOM.doctype.systemId == "http://www.gentoo.org/dtd/glsa-2.dtd":
- self.dtdversion = 2
- else:
- raise GlsaTypeException(self.DOM.doctype.systemId)
- myroot = self.DOM.getElementsByTagName("glsa")[0]
- if self.type == "id" and myroot.getAttribute("id") != self.nr:
- raise GlsaFormatException("filename and internal id don't match:" + myroot.getAttribute("id") + " != " + self.nr)
-
- # the simple (single, required, top-level, #PCDATA) tags first
- self.title = getText(myroot.getElementsByTagName("title")[0], format="strip")
- self.synopsis = getText(myroot.getElementsByTagName("synopsis")[0], format="strip")
- self.announced = format_date(getText(myroot.getElementsByTagName("announced")[0], format="strip"))
-
- count = 1
- # Support both formats of revised:
- # <revised>December 30, 2007: 02</revised>
- # <revised count="2">2007-12-30</revised>
- revisedEl = myroot.getElementsByTagName("revised")[0]
- self.revised = getText(revisedEl, format="strip")
- if (revisedEl.attributes.has_key("count")):
- count = revisedEl.getAttribute("count")
- elif (self.revised.find(":") >= 0):
- (self.revised, count) = self.revised.split(":")
-
- self.revised = format_date(self.revised)
-
- try:
- self.count = int(count)
- except ValueError:
- # TODO should this rais a GlsaFormatException?
- self.count = 1
-
- # now the optional and 0-n toplevel, #PCDATA tags and references
- try:
- self.access = getText(myroot.getElementsByTagName("access")[0], format="strip")
- except IndexError:
- self.access = ""
- self.bugs = getMultiTagsText(myroot, "bug", format="strip")
- self.references = getMultiTagsText(myroot.getElementsByTagName("references")[0], "uri", format="keep")
-
- # and now the formatted text elements
- self.description = getText(myroot.getElementsByTagName("description")[0], format="xml")
- self.workaround = getText(myroot.getElementsByTagName("workaround")[0], format="xml")
- self.resolution = getText(myroot.getElementsByTagName("resolution")[0], format="xml")
- self.impact_text = getText(myroot.getElementsByTagName("impact")[0], format="xml")
- self.impact_type = myroot.getElementsByTagName("impact")[0].getAttribute("type")
- try:
- self.background = getText(myroot.getElementsByTagName("background")[0], format="xml")
- except IndexError:
- self.background = ""
-
- # finally the interesting tags (product, affected, package)
- self.glsatype = myroot.getElementsByTagName("product")[0].getAttribute("type")
- self.product = getText(myroot.getElementsByTagName("product")[0], format="strip")
- self.affected = myroot.getElementsByTagName("affected")[0]
- self.packages = {}
- for p in self.affected.getElementsByTagName("package"):
- name = p.getAttribute("name")
- if name not in self.packages:
- self.packages[name] = []
- tmp = {}
- tmp["arch"] = p.getAttribute("arch")
- tmp["auto"] = (p.getAttribute("auto") == "yes")
- tmp["vul_vers"] = [makeVersion(v) for v in p.getElementsByTagName("vulnerable")]
- tmp["unaff_vers"] = [makeVersion(v) for v in p.getElementsByTagName("unaffected")]
- tmp["vul_atoms"] = [makeAtom(name, v) for v in p.getElementsByTagName("vulnerable")]
- tmp["unaff_atoms"] = [makeAtom(name, v) for v in p.getElementsByTagName("unaffected")]
- self.packages[name].append(tmp)
- # TODO: services aren't really used yet
- self.services = self.affected.getElementsByTagName("service")
- return None
-
- def dump(self, outstream=sys.stdout):
- """
- Dumps a plaintext representation of this GLSA to I{outfile} or
- B{stdout} if it is ommitted. You can specify an alternate
- I{encoding} if needed (default is latin1).
-
- @type outstream: File
- @param outfile: Stream that should be used for writing
- (defaults to sys.stdout)
- """
- width = 76
- outstream.write(("GLSA %s: \n%s" % (self.nr, self.title)).center(width)+"\n")
- outstream.write((width*"=")+"\n")
- outstream.write(wrap(self.synopsis, width, caption="Synopsis: ")+"\n")
- outstream.write("Announced on: %s\n" % self.announced)
- outstream.write("Last revised on: %s : %02d\n\n" % (self.revised, self.count))
- if self.glsatype == "ebuild":
- for k in self.packages.keys():
- pkg = self.packages[k]
- for path in pkg:
- vul_vers = "".join(path["vul_vers"])
- unaff_vers = "".join(path["unaff_vers"])
- outstream.write("Affected package: %s\n" % k)
- outstream.write("Affected archs: ")
- if path["arch"] == "*":
- outstream.write("All\n")
- else:
- outstream.write("%s\n" % path["arch"])
- outstream.write("Vulnerable: %s\n" % vul_vers)
- outstream.write("Unaffected: %s\n\n" % unaff_vers)
- elif self.glsatype == "infrastructure":
- pass
- if len(self.bugs) > 0:
- outstream.write("\nRelated bugs: ")
- for i in range(0, len(self.bugs)):
- outstream.write(self.bugs[i])
- if i < len(self.bugs)-1:
- outstream.write(", ")
- else:
- outstream.write("\n")
- if self.background:
- outstream.write("\n"+wrap(self.background, width, caption="Background: "))
- outstream.write("\n"+wrap(self.description, width, caption="Description: "))
- outstream.write("\n"+wrap(self.impact_text, width, caption="Impact: "))
- outstream.write("\n"+wrap(self.workaround, width, caption="Workaround: "))
- outstream.write("\n"+wrap(self.resolution, width, caption="Resolution: "))
- myreferences = ""
- for r in self.references:
- myreferences += (r.replace(" ", SPACE_ESCAPE)+NEWLINE_ESCAPE+" ")
- outstream.write("\n"+wrap(myreferences, width, caption="References: "))
- outstream.write("\n")
-
- def isVulnerable(self):
- """
- Tests if the system is affected by this GLSA by checking if any
- vulnerable package versions are installed. Also checks for affected
- architectures.
-
- @rtype: Boolean
- @returns: True if the system is affected, False if not
- """
- rValue = False
- for k in self.packages.keys():
- pkg = self.packages[k]
- for path in pkg:
- if path["arch"] == "*" or self.config["ARCH"] in path["arch"].split():
- for v in path["vul_atoms"]:
- rValue = rValue \
- or (len(match(v, self.vardbapi)) > 0 \
- and getMinUpgrade(path["vul_atoms"], path["unaff_atoms"], \
- self.portdbapi, self.vardbapi))
- return rValue
-
- def isApplied(self):
- """
- Looks if the GLSA IDis in the GLSA checkfile to check if this
- GLSA was already applied.
-
- @rtype: Boolean
- @returns: True if the GLSA was applied, False if not
- """
- return (self.nr in get_applied_glsas(self.config))
-
- def inject(self):
- """
- Puts the ID of this GLSA into the GLSA checkfile, so it won't
- show up on future checks. Should be called after a GLSA is
- applied or on explicit user request.
-
- @rtype: None
- @returns: None
- """
- if not self.isApplied():
- checkfile = open(os.path.join(os.sep, self.config["ROOT"], CACHE_PATH.lstrip(os.sep), "glsa"), "a+")
- checkfile.write(self.nr+"\n")
- checkfile.close()
- return None
-
- def getMergeList(self, least_change=True):
- """
- Returns the list of package-versions that have to be merged to
- apply this GLSA properly. The versions are as low as possible
- while avoiding downgrades (see L{getMinUpgrade}).
-
- @type least_change: Boolean
- @param least_change: True if the smallest possible upgrade should be selected,
- False for an emerge-like algorithm
- @rtype: List of Strings
- @return: list of package-versions that have to be merged
- """
- rValue = []
- for pkg in self.packages.keys():
- for path in self.packages[pkg]:
- update = getMinUpgrade(path["vul_atoms"], path["unaff_atoms"], \
- self.portdbapi, self.vardbapi, minimize=least_change)
- if update:
- rValue.append(update)
- return rValue
+++ /dev/null
-# testConfigFileSet.py -- Portage Unit Testing Functionality
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id: testShell.py 7363 2007-07-22 23:21:14Z zmedico $
-
-import tempfile, os
-
-from portage.tests import TestCase, test_cps
-from portage._sets.files import ConfigFileSet
-
-class ConfigFileSetTestCase(TestCase):
- """Simple Test Case for ConfigFileSet"""
-
- def setUp(self):
- fd, self.testfile = tempfile.mkstemp(suffix=".testdata", prefix=self.__class__.__name__, text=True)
- for i in range(0, len(test_cps)):
- atom = test_cps[i]
- if i % 2 == 0:
- os.write(fd, atom+" abc def"+"\n")
- else:
- os.write(fd, atom+"\n")
- os.close(fd)
-
- def tearDown(self):
- os.unlink(self.testfile)
-
- def testConfigStaticFileSet(self):
- s = ConfigFileSet(self.testfile)
- s.load()
- self.assertEqual(set(test_cps), s.getAtoms())
-
+++ /dev/null
-# testStaticFileSet.py -- Portage Unit Testing Functionality
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id: testShell.py 7363 2007-07-22 23:21:14Z zmedico $
-
-import tempfile, os
-
-from portage.tests import TestCase, test_cps
-from portage._sets.files import StaticFileSet
-from portage.env.loaders import TestTextLoader
-from portage.env.config import ConfigLoaderKlass
-
-class StaticFileSetTestCase(TestCase):
- """Simple Test Case for StaticFileSet"""
-
- def setUp(self):
- fd, self.testfile = tempfile.mkstemp(suffix=".testdata", prefix=self.__class__.__name__, text=True)
- os.write(fd, "\n".join(test_cps))
- os.close(fd)
-
- def tearDown(self):
- os.unlink(self.testfile)
-
- def testSampleStaticFileSet(self):
- s = StaticFileSet(self.testfile)
- s.load()
- self.assertEqual(set(test_cps), s.getAtoms())
-
+++ /dev/null
-# testCommandOututSet.py -- Portage Unit Testing Functionality
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-from portage.process import find_binary
-from portage.tests import TestCase, test_cps
-from portage._sets.shell import CommandOutputSet
-
-class CommandOutputSetTestCase(TestCase):
- """Simple Test Case for CommandOutputSet"""
-
- def setUp(self):
- pass
-
- def tearDown(self):
- pass
-
- def testCommand(self):
-
- input = set(test_cps)
- command = find_binary("bash")
- command += " -c '"
- for a in input:
- command += " echo -e \"%s\" ; " % a
- command += "'"
- s = CommandOutputSet(command)
- atoms = s.getAtoms()
- self.assertEqual(atoms, input)
projects / portage.git / commitdiff