Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
pexpect	[ DIR ]	drwxr-xr-x
__pycache__	[ DIR ]	drwxrwxr-x
avahi.py	3.01 KB	-rw-r--r--
codes.py	30.55 KB	-rw-r--r--
device.py	96.04 KB	-rw-r--r--
dime.py	3.3 KB	-rw-r--r--
exif.py	35.08 KB	-rw-r--r--
g.py	14.19 KB	-rw-r--r--
imageprocessing.py	33.14 KB	-rw-r--r--
imagesize.py	5.75 KB	-rw-r--r--
__init__.py	826 B	-rw-r--r--
ldif.py	16.33 KB	-rw-r--r--
LedmWifi.py	30.33 KB	-rw-r--r--
local.py	2.36 KB	-rw-r--r--
logger.py	18.06 KB	-rw-r--r--
magic.py	63.2 KB	-rw-r--r--
maint.py	58.36 KB	-rw-r--r--
mdns.py	10.04 KB	-rw-r--r--
mfpdtf.py	17.34 KB	-rw-r--r--
models.py	19.12 KB	-rw-r--r--
module.py	28.32 KB	-rw-r--r--
os_utils.py	2.28 KB	-rw-r--r--
password.py	13 KB	-rw-r--r--
pkit.py	11.45 KB	-rw-r--r--
pml.py	26.46 KB	-rw-r--r--
queues.py	16.35 KB	-rw-r--r--
services.py	9.74 KB	-rw-r--r--
sixext.py	5.78 KB	-rw-r--r--
six.py	22.32 KB	-rw-r--r--
slp.py	5.8 KB	-rw-r--r--
smart_install.py	11.37 KB	-rw-r--r--
status.py	76.42 KB	-rw-r--r--
strings.py	28.21 KB	-rw-r--r--
tui.py	13.79 KB	-rw-r--r--
utils.py	76.22 KB	-rw-r--r--
validation.py	3.68 KB	-rw-r--r--
vcard.py	43.66 KB	-rw-r--r--
wifi.py	22.25 KB	-rw-r--r--

Code Editor : pkit.py

# -*- coding: utf-8 -*-
#
# (c) Copyright 2003-2015 HP Development Company, L.P.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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 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
#
# Author: Stan Dolson , Goutam Kodu
#

# Std Lib
import os
import os.path
import sys

# Local
from .g import *
from .codes import *
from . import utils, password
from installer import pluginhandler

# DBus
import dbus
import dbus.service

if PY3:
    try:
        from gi._gobject import MainLoop
    except:
        from gi.repository.GLib import MainLoop
else:
    from gobject import MainLoop

import warnings
# Ignore: .../dbus/connection.py:242: DeprecationWarning: object.__init__() takes no parameters
# (occurring on Python 2.6/dBus 0.83/Ubuntu 9.04)
warnings.simplefilter("ignore", DeprecationWarning)

class AccessDeniedException(dbus.DBusException):
    _dbus_error_name = 'com.hp.hplip.AccessDeniedException'

class UnsupportedException(dbus.DBusException):
    _dbus_error_name = 'com.hp.hplip.UnsupportedException'

class UsageError(dbus.DBusException):
    _dbus_error_name = 'com.hp.hplip.UsageError'

POLICY_KIT_ACTION = "com.hp.hplip"
INSTALL_PLUGIN_ACTION = "com.hp.hplip.installplugin"

def get_service_bus():
    return dbus.SystemBus()

def get_service(bus=None):
    if not bus:
        bus = get_service_bus()

service = bus.get_object(BackendService.SERVICE_NAME, '/')
    service = dbus.Interface(service, BackendService.INTERFACE_NAME)
    return service

class PolicyKitAuthentication(object):
    def __init__(self):
        super(PolicyKitAuthentication, self).__init__()
        self.pkit = None
        self.auth = None

def is_authorized(self, action_id, pid=None):
        if pid == None:
            pid = os.getpid()

pid = dbus.UInt32(pid)

authorized = self.policy_kit.IsProcessAuthorized(action_id, pid, False)
        log.debug("is_authorized(%s) = %r" % (action_id, authorized))

return (authorized == 'yes')

def obtain_authorization(self, action_id, widget=None):
        if self.is_authorized(action_id):
            return True

xid = (widget and widget.get_toplevel().window.xid or 0)
        xid, pid = dbus.UInt32(xid), dbus.UInt32(os.getpid())

granted = self.auth_agent.ObtainAuthorization(action_id, xid, pid)
        log.debug("obtain_authorization(%s) = %r" % (action_id, granted))

return bool(granted)

def get_policy_kit(self):
        if self.pkit:
            return self.pkit

service = dbus.SystemBus().get_object('org.freedesktop.PolicyKit', '/')
        self.pkit = dbus.Interface(service, 'org.freedesktop.PolicyKit')
        return self.pkit

policy_kit = property(get_policy_kit)

def get_auth_agent(self):
        if self.auth:
            return self.auth

self.auth = dbus.SessionBus().get_object(
            'org.freedesktop.PolicyKit.AuthenticationAgent', '/')
        return self.auth

auth_agent = property(get_auth_agent)

class PolicyKitService(dbus.service.Object):
    def check_permission_v0(self, sender, action=POLICY_KIT_ACTION):
        if not sender:
            log.error("Session not authorized by PolicyKit")
            raise AccessDeniedException('Session not authorized by PolicyKit')

try:
            policy_auth = PolicyKitAuthentication()
            bus = dbus.SystemBus()

dbus_object = bus.get_object('org.freedesktop.DBus', '/')
            dbus_object = dbus.Interface(dbus_object, 'org.freedesktop.DBus')

pid = dbus.UInt32(dbus_object.GetConnectionUnixProcessID(sender))

granted = policy_auth.is_authorized(action, pid)
            if not granted:
                log.error("Process not authorized by PolicyKit")
                raise AccessDeniedException('Process not authorized by PolicyKit')

granted = policy_auth.policy_kit.IsSystemBusNameAuthorized(action,
                                                                       sender,
                                                                       False)
            if granted != 'yes':
                log.error("Session not authorized by PolicyKit version 0")
                raise AccessDeniedException('Session not authorized by PolicyKit')

except AccessDeniedException:
            log.warning("AccessDeniedException")
            raise

except dbus.DBusException as ex:
            log.warning("AccessDeniedException %r", ex)
            raise AccessDeniedException(ex.message)

def check_permission_v1(self, sender, connection, action=POLICY_KIT_ACTION):
        if not sender or not connection:
            log.error("Session not authorized by PolicyKit")
            raise AccessDeniedException('Session not authorized by PolicyKit')

system_bus = dbus.SystemBus()
        obj = system_bus.get_object("org.freedesktop.PolicyKit1",
                                    "/org/freedesktop/PolicyKit1/Authority",
                                    "org.freedesktop.PolicyKit1.Authority")
        policy_kit = dbus.Interface(obj, "org.freedesktop.PolicyKit1.Authority")

subject = (
           'system-bus-name',
            { 'name' : dbus.String(sender, variant_level = 1) }
        )
        details = { '' : '' }
        flags = dbus.UInt32(1)         # AllowUserInteraction = 0x00000001
        cancel_id = ''

(ok, notused, details) = \
            policy_kit.CheckAuthorization(subject,
                                          action,
                                          details,
                                          flags,
                                          cancel_id)
        if not ok:
            log.error("Session not authorized by PolicyKit version 1")
            raise AccessDeniedException("Session not authorized by PolicyKit")

return ok

if utils.to_bool(sys_conf.get('configure', 'policy-kit')):
    class BackendService(PolicyKitService):
        INTERFACE_NAME = 'com.hp.hplip'
        SERVICE_NAME   = 'com.hp.hplip'

def __init__(self, connection=None, path='/'):
            if connection is None:
                connection = get_service_bus()

super(BackendService, self).__init__(connection, path)

self.name = dbus.service.BusName(self.SERVICE_NAME, connection)
            self.loop = MainLoop()
            self.version = 0
            log.set_level("debug")

def run(self, version=None):
            if version is None:
                version = policykit_version()
                if version is None:
                    log.error("Unable to determine installed PolicyKit version")
                    return

self.version = version
            log.debug("Starting back-end service loop (version %d)" % version)

self.loop.run()

@dbus.service.method(dbus_interface=INTERFACE_NAME,
                                in_signature='s', out_signature='b',
                                sender_keyword='sender',
                                connection_keyword='connection')
        def installPlugin(self, src_dir, sender=None, connection=None):
            if self.version == 0:
                try:
                    self.check_permission_v0(sender, INSTALL_PLUGIN_ACTION)
                except AccessDeniedException as e:
                    log.error("installPlugin:  Failed due to permission error [%s]" %e)
                    return False

elif self.version == 1:
                if not self.check_permission_v1(sender,
                                                connection,
                                                INSTALL_PLUGIN_ACTION):
                    return False

else:
                log.error("installPlugin: invalid PolicyKit version %d" % self.version)
                return False

log.debug("installPlugin: installing from '%s'" % src_dir)
            try:
                from installer import pluginhandler
            except ImportError as e:
                log.error("Failed to Import pluginhandler")
                return False

pluginObj = pluginhandler.PluginHandle()
            if not pluginObj.copyFiles(src_dir):
                log.error("Plugin installation failed")
                return False

return True

@dbus.service.method(dbus_interface=INTERFACE_NAME,
                                in_signature='s', out_signature='b',
                                sender_keyword='sender',
                                connection_keyword='connection')
        def shutdown(self, arg, sender=None, connection=None):
            log.debug("Stopping backend service")
            self.loop.quit()

return True

class PolicyKit(object):
    def __init__(self, version=None):
        if version is None:
            version = policykit_version()
            if version is None:
                log.debug("Unable to determine installed PolicyKit version")
                return

self.bus = dbus.SystemBus()
        self.obj = self.bus.get_object(POLICY_KIT_ACTION, "/")
        self.iface = dbus.Interface(self.obj, dbus_interface=POLICY_KIT_ACTION)
        self.version = version

def installPlugin(self, src_dir):
        if self.version == 0:
            auth = PolicyKitAuthentication()
            if not auth.is_authorized(INSTALL_PLUGIN_ACTION):
                if not auth.obtain_authorization(INSTALL_PLUGIN_ACTION):
                    return None

try:
            ok = self.iface.installPlugin(src_dir)
            return ok
        except dbus.DBusException as e:
            log.debug("installPlugin: %s" % str(e))
            return False

def shutdown(self):
        if self.version == 0:
            auth = PolicyKitAuthentication()
            if not auth.is_authorized(INSTALL_PLUGIN_ACTION):
                if not auth.obtain_authorization(INSTALL_PLUGIN_ACTION):
                    return None

try:
            ok = self.iface.shutdown("")
            return ok
        except dbus.DBusException as e:
            log.debug("shutdown: %s" % str(e))
            return False

def run_plugin_command(required=True, plugin_reason=PLUGIN_REASON_NONE, Mode = GUI_MODE):

if utils.to_bool(sys_conf.get('configure', 'policy-kit')):
        try:
            obj = PolicyKit()
            su_sudo = "%s"
            need_sudo = False
            log.debug("Using PolicyKit for authentication")
        except dbus.DBusException as ex:
            log.error("PolicyKit NOT installed when configured for use. [%s]"%ex)

req = '--required'
    if not required:
        req = '--optional'

if utils.which("hp-plugin"):
        p_path="hp-plugin"
    else:
        p_path="python ./plugin.py"

cmd = "%s -u %s --reason %s" %(p_path, req, plugin_reason)   
    log.debug("%s" % cmd)
    status = os_utils.execute(cmd)

return (status == 0, True)

def policykit_version():
    if os.path.isdir("/usr/share/polkit-1"):
        return 1
    elif os.path.isdir("/usr/share/PolicyKit"):
        return 0
    else:
        return None

${this.title}

Code Editor : pkit.py