Software: Apache/2.2.3 (CentOS). PHP/5.1.6 uname -a: Linux mx-ll-110-164-51-230.static.3bb.co.th 2.6.18-194.el5PAE #1 SMP Fri Apr 2 15:37:44 uid=48(apache) gid=48(apache) groups=48(apache) Safe-mode: OFF (not secure) /usr/sbin/ drwxr-xr-x | |
| Viewing file: Select action/file-type: #!/usr/bin/python -tt
#
# Copyright 2005-2007 Red Hat, Inc.
#
# Jeremy Katz <katzj@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 only
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
import os, sys
# # Python gettext:
# import gettext
import logging
try:
import gtk
import gtk.glade
import gtk.gdk as gdk
import gobject
except Exception, e:
print >> sys.stderr, "Unable to import modules. Maybe you're not running under X?"
sys.exit(1)
from rhpl.exception import installExceptionHandler
from rhpl.translate import _, N_, textdomain
from rpmUtils.miscutils import compareEVR
import rpmUtils.arch
import yum.misc
from yum.packages import parsePackages, YumLocalPackage
from yum import logginglevels
import rpm
from pirut import *
from pirut.constants import *
from pirut.Errors import *
if os.path.exists("data/single.glade"):
gladefn = "data/single.glade"
else:
gladefn = "/usr/share/pirut/ui/single.glade"
# # Python gettext:
# t = gettext.translation(I18N_DOMAIN, "/usr/share/locale", fallback = True)
# _ = t.lgettext
class SinglePackageInstaller(GraphicalYumBase):
def __init__(self):
self.xml = gtk.glade.XML(gladefn, domain=I18N_DOMAIN)
self.mainwin = self.xml.get_widget("InstallerWindow")
self._connectSignals()
self._createPackageStore()
self.mainwin.connect("delete_event", self.quit)
# note that nothing which takes "time" should be called here!
GraphicalYumBase.__init__(self, False)
self.unsignedok = True
self.repos_setup = False
self._enabledRepos = self.repos.listEnabled()
map(lambda x: x.disable(), self._enabledRepos)
def _connectSignals(self):
sigs = { "on_InstallerWindow_destroy": self.quit,
"on_quitButton_clicked": self.quit,
"on_applyButton_clicked": self._apply }
self.xml.signal_autoconnect(sigs)
def _createPackageStore(self):
self.store = gtk.ListStore(gobject.TYPE_PYOBJECT)
tree = self.xml.get_widget("packageList")
tree.set_model(self.store)
column = gtk.TreeViewColumn(None, None)
column.set_clickable(True)
txtr = gtk.CellRendererText()
column.pack_start(txtr, True)
column.set_cell_data_func(txtr, self.get_pkg_info)
tree.append_column(column)
def get_pkg_info(self, col, cell, model, i):
pkg = model.get_value(i, 0)
nevra = "%s" %(pkg,)
desc = pkg.returnSimple('summary')
text = "<span weight=\"bold\">%s</span>\n%s" %(nevra, desc)
text.strip()
cell.set_property("markup", text)
def doRefresh(self, *args):
self._busyCursor()
self.populatePackages()
self._normalCursor()
def logDialog(self, msg):
print msg
d = gtk.MessageDialog(self.mainwin, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO,
gtk.BUTTONS_OK, msg)
d.show_all()
d.run()
d.destroy()
def errorDialog(self, msg):
print msg
d = gtk.MessageDialog(self.mainwin, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK, msg)
d.show_all()
d.run()
d.destroy()
def _populateLocalPackages(self, pkgs):
self.store.clear()
updates = []
installs = []
for pkg in pkgs:
try:
po = YumLocalPackage(ts=self.rpmdb.readOnlyTS(), filename=pkg)
except yum.Errors.MiscError, e:
log = logging.getLogger("yum")
log.warn("Cannot open file: %s. Skipping." %(pkg,))
continue
if po.hdr[rpm.RPMTAG_SOURCEPACKAGE] == 1: # ugh.
self.logDialog(_("Cannot install source packages."))
continue
inst = self.rpmdb.searchNevra(name=po.name)
for instpo in inst:
(n,a,e,v,r) = po.pkgtup
(inn,ia,ie,iv,ir) = instpo.pkgtup
rc = compareEVR((ie,iv,ir), (e,v,r))
if rc < 0: # update
if n not in self.conf.exactarchlist or a == ia:
updates.append((po, instpo))
else:
self.logDialog(_("Can't install a different arch of %s than already installed.") %(pkg,))
continue
elif rc == 0: # same, ignore
self.logDialog("%s is already installed" %(pkg,))
elif rc > 0:
self.logDialog("A newer version than %s is already installed" %(pkg,))
if len(inst) == 0:
installs.append(po)
for po in installs:
self.localPackages.append(po)
self.tsInfo.addInstall(po = po)
self.store.append([po])
for (po, oldpo) in updates:
self.localPackages.append(po)
self.tsInfo.addUpdate(po, oldpo)
self.store.append([po])
def _populateRepoPackages(self, pkgs):
self.store.clear()
self._ensure_repos()
avail = self.pkgSack.returnPackages()
toBeInstalled = {} # keyed on name
updates = []
# FIXME:
# Parsing command line options that aren't local packages gets complex,
# partly because the user has the option of specifying or not specifying
# arch and version. The code below is lifted verbatim from the cli.py
# implementation of 'yum install'. It perhaps should be moved into the
# yum core in some fashion.
#
########################################
# BEGIN CUT-AND-PASTE from cli.py
#
self.verbose_logger.log(logginglevels.INFO_2,
_('Parsing package install arguments'))
for arg in pkgs:
arglist = [arg]
exactmatch, matched, unmatched = parsePackages(avail, arglist,
casematch=1)
if len(unmatched) > 0: # if we get back anything in unmatched, check it for a virtual-provide
arg = unmatched[0] #only one in there
self.verbose_logger.debug('Checking for virtual provide or file-provide for %s',
arg)
try:
mypkg = self.returnPackageByDep(arg)
except yum.Errors.YumBaseError, e:
self.errorDialog(_('No Match for argument: %s') % arg)
# Continuing on and installing only some packages from the requested
# set is probably not useful
self.quit()
else:
arg = '%s:%s-%s-%s.%s' % (mypkg.epoch, mypkg.name,
mypkg.version, mypkg.release,
mypkg.arch)
emtch, mtch, unmtch = parsePackages(avail, [arg])
exactmatch.extend(emtch)
matched.extend(mtch)
installable = yum.misc.unique(exactmatch + matched)
exactarchlist = self.conf.exactarchlist
# we look through each returned possibility and rule out the
# ones that we obviously can't use
for pkg in installable:
if self.rpmdb.installed(po=pkg):
self.verbose_logger.log(logginglevels.DEBUG_3,
'Package %s is already installed, skipping', pkg)
continue
# everything installed that matches the name
installedByKey = self.rpmdb.searchNevra(name=pkg.name)
comparable = []
for instpo in installedByKey:
if rpmUtils.arch.isMultiLibArch(instpo.arch) == rpmUtils.arch.isMultiLibArch(pkg.arch):
comparable.append(instpo)
else:
self.verbose_logger.log(logginglevels.DEBUG_3,
'Discarding non-comparable pkg %s.%s', instpo.name, instpo.arch)
continue
# go through each package
if len(comparable) > 0:
for instpo in comparable:
if pkg.EVR > instpo.EVR: # we're newer - this is an update, pass to them
if instpo.name in exactarchlist:
if pkg.arch == instpo.arch:
updates.append((pkg, instpo))
else:
updates.append((pkg, instpo))
elif pkg.EVR == instpo.EVR: # same, ignore
continue
elif pkg.EVR < instpo.EVR: # lesser, check if the pkgtup is an exactmatch
# if so then add it to be installed
# if it can be multiply installed
# this is where we could handle setting
# it to be an 'oldpackage' revert.
if pkg in exactmatch and self.allowedMultipleInstalls(pkg):
if not toBeInstalled.has_key(pkg.name): toBeInstalled[pkg.name] = []
toBeInstalled[pkg.name].append(pkg)
else: # we've not got any installed that match n or n+a
self.verbose_logger.log(logginglevels.DEBUG_1, 'No other %s installed, adding to list for potential install', pkg.name)
if not toBeInstalled.has_key(pkg.name): toBeInstalled[pkg.name] = []
toBeInstalled[pkg.name].append(pkg)
# this is where I could catch the installs of compat and multilib
# arches on a single yum install command.
pkglist = []
for name in toBeInstalled.keys():
pkglist.extend(self.bestPackagesFromList(toBeInstalled[name]))
#
# END CUT-AND-PASTE from cli.py
#########################################
for po in pkglist:
self.tsInfo.addInstall(po = po)
self.store.append([po])
for (po, oldpo) in updates:
self.tsInfo.addUpdate(po, oldpo)
self.store.append([po])
def populatePackages(self):
locals = []
others = []
# at some point, we should maybe be smarter here
for pkg in sys.argv[1:]:
if os.path.exists(pkg):
locals.append(pkg)
else:
others.append(pkg)
self.doRefreshRepos(progress = False)
if len(locals) > 0:
self._populateLocalPackages(locals)
if len(others) > 0:
self._populateRepoPackages(others)
if not hasattr(self, "tsInfo") or len(self.tsInfo) <= 0:
self.errorDialog(_("No packages were given for installation."))
self.quit()
def _busyCursor(self):
self.mainwin.window.set_cursor(gdk.Cursor(gdk.WATCH))
self.mainwin.set_sensitive(False)
def _normalCursor(self):
self.mainwin.window.set_cursor(None)
self.mainwin.set_sensitive(True)
def _ensure_repos(self):
if self.repos_setup:
return
map(lambda x: x.enable(), self._enabledRepos)
self.doRefreshRepos()
self.repos_setup = True
def _apply(self, *args):
# do a depsolve to see if we need to grab any other stuff... this is
# kind of a hack knowing what resolveDeps does
self.populateTs(test=1)
deps = self.ts.check()
if deps:
self._ensure_repos()
try:
output = self.applyChanges(self.mainwin)
except PirutError:
self.quit()
except OSError:
d = gtk.MessageDialog(self.mainwin, gtk.DIALOG_MODAL,
gtk.BUTTONS_OK,
_("Unable to install software. Error "
"opening files."))
d.show_all()
d.run()
d.destroy()
self.quit()
d = PirutDetailsDialog(self.mainwin, gtk.MESSAGE_INFO,
gtk.BUTTONS_OK,
_("Software installed successfully."))
if output:
d.format_secondary_text("Some warnings were given.")
d.set_details(buffer = outputDictAsTextBuffer(output))
d.run()
d.destroy()
self.quit()
def run(self):
self.mainwin.show_all()
while gtk.events_pending(): gtk.main_iteration()
self.doRefresh()
gtk.main()
def main():
textdomain(I18N_DOMAIN)
gtk.glade.bindtextdomain(I18N_DOMAIN, "/usr/share/locale")
try:
# right now, we have to run privileged...
if os.getuid() != 0:
raise PirutError(_("Must be run as root."))
pkginst = SinglePackageInstaller()
except PirutError, e:
startupError(e)
pkginst.run()
if __name__ == "__main__":
installExceptionHandler("pirut", "")
main()
|
:: Command execute :: | |
:: Shadow's tricks :D :: | |
Useful Commands
|
|
:: Preddy's tricks :D :: | |
Php Safe-Mode Bypass (Read Files)
|
|
--[ c999shell v. 1.0 pre-release build #16 Modded by Shadow & Preddy | RootShell Security Group | r57 c99 shell | Generation time: 0.0053 ]-- |