

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: bus.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># Copyright (C) 2007 Collabora Ltd. &lt;http://www.collabora.co.uk/&gt;
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the &quot;Software&quot;), to deal in the Software without
# restriction, including without limitation the rights to use, copy,
# modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

__all__ = (&#039;BusConnection&#039;,)
__docformat__ = &#039;reStructuredText&#039;

import logging
import weakref

from _dbus_bindings import (
    BUS_DAEMON_IFACE, BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_SESSION,
    BUS_STARTER, BUS_SYSTEM, DBUS_START_REPLY_ALREADY_RUNNING,
    DBUS_START_REPLY_SUCCESS, NAME_FLAG_ALLOW_REPLACEMENT,
    NAME_FLAG_DO_NOT_QUEUE, NAME_FLAG_REPLACE_EXISTING,
    RELEASE_NAME_REPLY_NON_EXISTENT, RELEASE_NAME_REPLY_NOT_OWNER,
    RELEASE_NAME_REPLY_RELEASED, REQUEST_NAME_REPLY_ALREADY_OWNER,
    REQUEST_NAME_REPLY_EXISTS, REQUEST_NAME_REPLY_IN_QUEUE,
    REQUEST_NAME_REPLY_PRIMARY_OWNER, validate_bus_name, validate_error_name,
    validate_interface_name, validate_member_name, validate_object_path)
from dbus.connection import Connection
from dbus.exceptions import DBusException
from dbus.lowlevel import HANDLER_RESULT_NOT_YET_HANDLED
from dbus._compat import is_py2


_NAME_OWNER_CHANGE_MATCH = (&quot;type=&#039;signal&#039;,sender=&#039;%s&#039;,&quot;
                            &quot;interface=&#039;%s&#039;,member=&#039;NameOwnerChanged&#039;,&quot;
                            &quot;path=&#039;%s&#039;,arg0=&#039;%%s&#039;&quot;
                            % (BUS_DAEMON_NAME, BUS_DAEMON_IFACE,
                               BUS_DAEMON_PATH))
&quot;&quot;&quot;(_NAME_OWNER_CHANGE_MATCH % sender) matches relevant NameOwnerChange
messages&quot;&quot;&quot;

_NAME_HAS_NO_OWNER = &#039;org.freedesktop.DBus.Error.NameHasNoOwner&#039;

_logger = logging.getLogger(&#039;dbus.bus&#039;)


class NameOwnerWatch(object):
    __slots__ = (&#039;_match&#039;, &#039;_pending_call&#039;)

    def __init__(self, bus_conn, bus_name, callback):
        validate_bus_name(bus_name)

        def signal_cb(owned, old_owner, new_owner):
            callback(new_owner)

        def error_cb(e):
            if e.get_dbus_name() == _NAME_HAS_NO_OWNER:
                callback(&#039;&#039;)
            else:
                logging.basicConfig()
                _logger.debug(&#039;GetNameOwner(%s) failed:&#039;, bus_name,
                              exc_info=(e.__class__, e, None))

        self._match = bus_conn.add_signal_receiver(signal_cb,
                                                   &#039;NameOwnerChanged&#039;,
                                                   BUS_DAEMON_IFACE,
                                                   BUS_DAEMON_NAME,
                                                   BUS_DAEMON_PATH,
                                                   arg0=bus_name)
        keywords = {}
        if is_py2:
            keywords[&#039;utf8_strings&#039;] = True
        self._pending_call = bus_conn.call_async(BUS_DAEMON_NAME,
                                                 BUS_DAEMON_PATH,
                                                 BUS_DAEMON_IFACE,
                                                 &#039;GetNameOwner&#039;,
                                                 &#039;s&#039;, (bus_name,),
                                                 callback, error_cb,
                                                 **keywords)

    def cancel(self):
        if self._match is not None:
            self._match.remove()
        if self._pending_call is not None:
            self._pending_call.cancel()
        self._match = None
        self._pending_call = None


class BusConnection(Connection):
    &quot;&quot;&quot;A connection to a D-Bus daemon that implements the
    ``org.freedesktop.DBus`` pseudo-service.

    :Since: 0.81.0
    &quot;&quot;&quot;

    TYPE_SESSION    = BUS_SESSION
    &quot;&quot;&quot;Represents a session bus (same as the global dbus.BUS_SESSION)&quot;&quot;&quot;

    TYPE_SYSTEM     = BUS_SYSTEM
    &quot;&quot;&quot;Represents the system bus (same as the global dbus.BUS_SYSTEM)&quot;&quot;&quot;

    TYPE_STARTER = BUS_STARTER
    &quot;&quot;&quot;Represents the bus that started this service by activation (same as
    the global dbus.BUS_STARTER)&quot;&quot;&quot;

    START_REPLY_SUCCESS = DBUS_START_REPLY_SUCCESS
    START_REPLY_ALREADY_RUNNING = DBUS_START_REPLY_ALREADY_RUNNING

    def __new__(cls, address_or_type=TYPE_SESSION, mainloop=None):
        bus = cls._new_for_bus(address_or_type, mainloop=mainloop)

        # _bus_names is used by dbus.service.BusName!
        bus._bus_names = weakref.WeakValueDictionary()

        bus._signal_sender_matches = {}
        &quot;&quot;&quot;Map from SignalMatch to NameOwnerWatch.&quot;&quot;&quot;

        return bus

    def add_signal_receiver(self, handler_function, signal_name=None,
                            dbus_interface=None, bus_name=None,
                            path=None, **keywords):
        named_service = keywords.pop(&#039;named_service&#039;, None)
        if named_service is not None:
            if bus_name is not None:
                raise TypeError(&#039;bus_name and named_service cannot both be &#039;
                                &#039;specified&#039;)
            bus_name = named_service
            from warnings import warn
            warn(&#039;Passing the named_service parameter to add_signal_receiver &#039;
                 &#039;by name is deprecated: please use positional parameters&#039;,
                 DeprecationWarning, stacklevel=2)

        match = super(BusConnection, self).add_signal_receiver(
                handler_function, signal_name, dbus_interface, bus_name,
                path, **keywords)

        if (bus_name is not None and bus_name != BUS_DAEMON_NAME):
            if bus_name[:1] == &#039;:&#039;:
                def callback(new_owner):
                    if new_owner == &#039;&#039;:
                        match.remove()
            else:
                callback = match.set_sender_name_owner
            watch = self.watch_name_owner(bus_name, callback)
            self._signal_sender_matches[match] = watch

        self.add_match_string(str(match))

        return match

    def _clean_up_signal_match(self, match):
        # The signals lock is no longer held here (it was in &lt;= 0.81.0)
        self.remove_match_string_non_blocking(str(match))
        watch = self._signal_sender_matches.pop(match, None)
        if watch is not None:
            watch.cancel()

    def activate_name_owner(self, bus_name):
        if (bus_name is not None and bus_name[:1] != &#039;:&#039;
            and bus_name != BUS_DAEMON_NAME):
            try:
                return self.get_name_owner(bus_name)
            except DBusException as e:
                if e.get_dbus_name() != _NAME_HAS_NO_OWNER:
                    raise
                # else it doesn&#039;t exist: try to start it
                self.start_service_by_name(bus_name)
                return self.get_name_owner(bus_name)
        else:
            # already unique
            return bus_name

    def get_object(self, bus_name, object_path, introspect=True,
                   follow_name_owner_changes=False, **kwargs):
        &quot;&quot;&quot;Return a local proxy for the given remote object.

        Method calls on the proxy are translated into method calls on the
        remote object.

        :Parameters:
            `bus_name` : str
                A bus name (either the unique name or a well-known name)
                of the application owning the object. The keyword argument
                named_service is a deprecated alias for this.
            `object_path` : str
                The object path of the desired object
            `introspect` : bool
                If true (default), attempt to introspect the remote
                object to find out supported methods and their signatures
            `follow_name_owner_changes` : bool
                If the object path is a well-known name and this parameter
                is false (default), resolve the well-known name to the unique
                name of its current owner and bind to that instead; if the
                ownership of the well-known name changes in future,
                keep communicating with the original owner.
                This is necessary if the D-Bus API used is stateful.

                If the object path is a well-known name and this parameter
                is true, whenever the well-known name changes ownership in
                future, bind to the new owner, if any.

                If the given object path is a unique name, this parameter
                has no effect.

        :Returns: a `dbus.proxies.ProxyObject`
        :Raises `DBusException`: if resolving the well-known name to a
            unique name fails
        &quot;&quot;&quot;
        if follow_name_owner_changes:
            self._require_main_loop()   # we don&#039;t get the signals otherwise

        named_service = kwargs.pop(&#039;named_service&#039;, None)
        if named_service is not None:
            if bus_name is not None:
                raise TypeError(&#039;bus_name and named_service cannot both &#039;
                                &#039;be specified&#039;)
            from warnings import warn
            warn(&#039;Passing the named_service parameter to get_object by name &#039;
                 &#039;is deprecated: please use positional parameters&#039;,
                 DeprecationWarning, stacklevel=2)
            bus_name = named_service
        if kwargs:
            raise TypeError(&#039;get_object does not take these keyword &#039;
                            &#039;arguments: %s&#039; % &#039;, &#039;.join(kwargs.keys()))

        return self.ProxyObjectClass(self, bus_name, object_path,
                                     introspect=introspect,
                                     follow_name_owner_changes=follow_name_owner_changes)

    def get_unix_user(self, bus_name):
        &quot;&quot;&quot;Get the numeric uid of the process owning the given bus name.

        :Parameters:
            `bus_name` : str
                A bus name, either unique or well-known
        :Returns: a `dbus.UInt32`
        :Since: 0.80.0
        &quot;&quot;&quot;
        validate_bus_name(bus_name)
        return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                  BUS_DAEMON_IFACE, &#039;GetConnectionUnixUser&#039;,
                                  &#039;s&#039;, (bus_name,))

    def start_service_by_name(self, bus_name, flags=0):
        &quot;&quot;&quot;Start a service which will implement the given bus name on this Bus.

        :Parameters:
            `bus_name` : str
                The well-known bus name to be activated.
            `flags` : dbus.UInt32
                Flags to pass to StartServiceByName (currently none are
                defined)

        :Returns: A tuple of 2 elements. The first is always True, the
            second is either START_REPLY_SUCCESS or
            START_REPLY_ALREADY_RUNNING.

        :Raises `DBusException`: if the service could not be started.
        :Since: 0.80.0
        &quot;&quot;&quot;
        validate_bus_name(bus_name)
        return (True, self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                         BUS_DAEMON_IFACE,
                                         &#039;StartServiceByName&#039;,
                                         &#039;su&#039;, (bus_name, flags)))

    # XXX: it might be nice to signal IN_QUEUE, EXISTS by exception,
    # but this would not be backwards-compatible
    def request_name(self, name, flags=0):
        &quot;&quot;&quot;Request a bus name.

        :Parameters:
            `name` : str
                The well-known name to be requested
            `flags` : dbus.UInt32
                A bitwise-OR of 0 or more of the flags
                `NAME_FLAG_ALLOW_REPLACEMENT`,
                `NAME_FLAG_REPLACE_EXISTING`
                and `NAME_FLAG_DO_NOT_QUEUE`
        :Returns: `REQUEST_NAME_REPLY_PRIMARY_OWNER`,
            `REQUEST_NAME_REPLY_IN_QUEUE`,
            `REQUEST_NAME_REPLY_EXISTS` or
            `REQUEST_NAME_REPLY_ALREADY_OWNER`
        :Raises `DBusException`: if the bus daemon cannot be contacted or
            returns an error.
        &quot;&quot;&quot;
        validate_bus_name(name, allow_unique=False)
        return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                  BUS_DAEMON_IFACE, &#039;RequestName&#039;,
                                  &#039;su&#039;, (name, flags))

    def release_name(self, name):
        &quot;&quot;&quot;Release a bus name.

        :Parameters:
            `name` : str
                The well-known name to be released
        :Returns: `RELEASE_NAME_REPLY_RELEASED`,
            `RELEASE_NAME_REPLY_NON_EXISTENT`
            or `RELEASE_NAME_REPLY_NOT_OWNER`
        :Raises `DBusException`: if the bus daemon cannot be contacted or
            returns an error.
        &quot;&quot;&quot;
        validate_bus_name(name, allow_unique=False)
        return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                  BUS_DAEMON_IFACE, &#039;ReleaseName&#039;,
                                  &#039;s&#039;, (name,))

    def list_names(self):
        &quot;&quot;&quot;Return a list of all currently-owned names on the bus.

        :Returns: a dbus.Array of dbus.UTF8String
        :Since: 0.81.0
        &quot;&quot;&quot;
        keywords = {}
        if is_py2:
            keywords[&#039;utf8_strings&#039;] = True
        return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                  BUS_DAEMON_IFACE, &#039;ListNames&#039;,
                                  &#039;&#039;, (), **keywords)

    def list_activatable_names(self):
        &quot;&quot;&quot;Return a list of all names that can be activated on the bus.

        :Returns: a dbus.Array of dbus.UTF8String
        :Since: 0.81.0
        &quot;&quot;&quot;
        keywords = {}
        if is_py2:
            keywords[&#039;utf8_strings&#039;] = True
        return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                  BUS_DAEMON_IFACE, &#039;ListActivatableNames&#039;,
                                  &#039;&#039;, (), **keywords)

    def get_name_owner(self, bus_name):
        &quot;&quot;&quot;Return the unique connection name of the primary owner of the
        given name.

        :Raises `DBusException`: if the `bus_name` has no owner
        :Since: 0.81.0
        &quot;&quot;&quot;
        keywords = {}
        if is_py2:
            keywords[&#039;utf8_strings&#039;] = True
        validate_bus_name(bus_name, allow_unique=False)
        return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                  BUS_DAEMON_IFACE, &#039;GetNameOwner&#039;,
                                  &#039;s&#039;, (bus_name,), **keywords)

    def watch_name_owner(self, bus_name, callback):
        &quot;&quot;&quot;Watch the unique connection name of the primary owner of the
        given name.

        `callback` will be called with one argument, which is either the
        unique connection name, or the empty string (meaning the name is
        not owned).

        :Since: 0.81.0
        &quot;&quot;&quot;
        return NameOwnerWatch(self, bus_name, callback)

    def name_has_owner(self, bus_name):
        &quot;&quot;&quot;Return True iff the given bus name has an owner on this bus.

        :Parameters:
            `bus_name` : str
                The bus name to look up
        :Returns: a `bool`
        &quot;&quot;&quot;
        return bool(self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                                       BUS_DAEMON_IFACE, &#039;NameHasOwner&#039;,
                                       &#039;s&#039;, (bus_name,)))

    def add_match_string(self, rule):
        &quot;&quot;&quot;Arrange for this application to receive messages on the bus that
        match the given rule. This version will block.

        :Parameters:
            `rule` : str
                The match rule
        :Raises `DBusException`: on error.
        :Since: 0.80.0
        &quot;&quot;&quot;
        self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                           BUS_DAEMON_IFACE, &#039;AddMatch&#039;, &#039;s&#039;, (rule,))

    # FIXME: add an async success/error handler capability?
    # (and the same for remove_...)
    def add_match_string_non_blocking(self, rule):
        &quot;&quot;&quot;Arrange for this application to receive messages on the bus that
        match the given rule. This version will not block, but any errors
        will be ignored.


        :Parameters:
            `rule` : str
                The match rule
        :Raises `DBusException`: on error.
        :Since: 0.80.0
        &quot;&quot;&quot;
        self.call_async(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                        BUS_DAEMON_IFACE, &#039;AddMatch&#039;, &#039;s&#039;, (rule,),
                        None, None)

    def remove_match_string(self, rule):
        &quot;&quot;&quot;Arrange for this application to receive messages on the bus that
        match the given rule. This version will block.

        :Parameters:
            `rule` : str
                The match rule
        :Raises `DBusException`: on error.
        :Since: 0.80.0
        &quot;&quot;&quot;
        self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                           BUS_DAEMON_IFACE, &#039;RemoveMatch&#039;, &#039;s&#039;, (rule,))

    def remove_match_string_non_blocking(self, rule):
        &quot;&quot;&quot;Arrange for this application to receive messages on the bus that
        match the given rule. This version will not block, but any errors
        will be ignored.


        :Parameters:
            `rule` : str
                The match rule
        :Raises `DBusException`: on error.
        :Since: 0.80.0
        &quot;&quot;&quot;
        self.call_async(BUS_DAEMON_NAME, BUS_DAEMON_PATH,
                        BUS_DAEMON_IFACE, &#039;RemoveMatch&#039;, &#039;s&#039;, (rule,),
                        None, None)
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python3.6/site-packages/dbus/bus.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython3.6%2Fsite-packages%2Fdbus' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>