/usr/share/sugar-presence-service/linklocal_plugin.py is in sugar-presence-service-0.86 0.86.0-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 | """Link-local plugin for Presence Service"""
# Copyright (C) 2007, Red Hat, Inc.
# Copyright (C) 2007, Collabora Ltd.
#
# 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
# Standard library
import logging
from itertools import izip
# Other libraries
import gobject
from dbus import SystemBus
from telepathy.client import Connection
from telepathy.interfaces import CONN_INTERFACE
from telepathy.constants import HANDLE_TYPE_CONTACT
# Presence Service local modules
import psutils
from telepathy_plugin import TelepathyPlugin
CONN_INTERFACE_BUDDY_INFO = 'org.laptop.Telepathy.BuddyInfo'
_logger = logging.getLogger('s-p-s.linklocal_plugin')
class LinkLocalPlugin(TelepathyPlugin):
"""Telepathy-python-based presence server interface
The ServerPlugin instance translates network events from
Telepathy Python into GObject events. It provides direct
python calls to perform the required network operations
to implement the PresenceService.
"""
_TP_CONN_MANAGER = 'salut'
_PROTOCOL = 'local-xmpp'
_OBJ_PATH_PREFIX = "/org/freedesktop/Telepathy/Connection/salut/"
def __init__(self, registry, owner):
TelepathyPlugin.__init__(self, registry, owner)
self._sys_bus = SystemBus()
self._have_avahi = False
self._watch = self._sys_bus.watch_name_owner('org.freedesktop.Avahi',
self._avahi_owner_cb)
# Glib source ID indicating we have to wait before be allowed to try
# to connect
self._have_to_wait_id = 0
def _avahi_owner_cb(self, unique_name):
had_avahi = self._have_avahi
if unique_name:
self._have_avahi = True
if not had_avahi:
if self._backoff_id > 0:
_logger.info('Avahi appeared on the system bus (%s) - '
'will start when retry time is reached')
else:
_logger.info('Avahi appeared on the system bus (%s) - '
'starting...', unique_name)
self.emit('want-to-connect')
else:
self._have_avahi = False
if had_avahi:
_logger.info('Avahi disappeared from the system bus - '
'stopping...')
self._stop()
def cleanup(self):
TelepathyPlugin.cleanup(self)
if self._watch is not None:
self._watch.cancel()
self._watch = None
def _could_connect(self):
return TelepathyPlugin._could_connect(self) and self._have_avahi and \
self._have_to_wait_id == 0
def _get_account_info(self):
"""Retrieve connection manager parameters for this account
"""
server = self._owner.get_server()
khash = psutils.pubkey_to_keyid(self._owner.props.key)
return {
'nickname': '%s' % self._owner.props.nick,
'first-name': ' ',
'last-name': '%s' % self._owner.props.nick,
'jid': '%s@%s' % (khash, server),
'published-name': '%s' % khash[:8],
}
def _find_existing_connection(self):
"""Try to find an existing Telepathy connection to this server
filters the set of connections from
telepathy.client.Connection.get_connections
to find a connection using our protocol with the
"self handle" of that connection being a handle
which matches our account (see _get_account_info)
returns connection or None
"""
# Search existing connections, if any, that we might be able to use
connections = Connection.get_connections()
for item in connections:
if not item.object_path.startswith(self._OBJ_PATH_PREFIX):
continue
if item[CONN_INTERFACE].GetProtocol() != self._PROTOCOL:
continue
# Any Salut instance will do
return item
return None
def identify_contacts(self, tp_chan, handles, identifiers=None):
"""Work out the "best" unique identifier we can for the given handles,
in the context of the given channel (which may be None), using only
'fast' connection manager API (that does not involve network
round-trips).
For the XMPP server case, we proceed as follows:
* Find the owners of the given handles, if the channel has
channel-specific handles
* If the owner (globally-valid JID) is on a trusted server, return
'keyid/' plus the 'key fingerprint' (the user part of their JID,
currently implemented as the SHA-1 of the Base64 blob in
owner.key.pub)
* If the owner (globally-valid JID) cannot be found or is on an
untrusted server, return 'xmpp/' plus an escaped form of the JID
The idea is that we identify buddies by key-ID (i.e. by key, assuming
no collisions) if we can find it without making network round-trips,
but if that's not possible we just use their JIDs.
:Parameters:
`tp_chan` : telepathy.client.Channel or None
The channel in which the handles were found, or None if they
are known to be channel-specific handles
`handles` : iterable over (int or long)
The contacts' handles in that channel
:Returns:
A dict mapping the provided handles to the best available
unique identifier, which is a string that could be used as a
suffix to an object path
"""
# we need to be able to index into handles, so force them to
# be a sequence
if not isinstance(handles, (tuple, list)):
handles = tuple(handles)
# we happen to know that Salut has no channel-specific handles
if identifiers is None:
identifiers = self._conn[CONN_INTERFACE].InspectHandles(
HANDLE_TYPE_CONTACT, handles)
ret = {}
for handle, ident in izip(handles, identifiers):
# special-case the Owner - we always know who we are
if handle == self.self_handle:
ret[handle] = self._owner.props.objid
continue
# we also happen to know that on Salut, getting properties
# is immediate, and the key is (well, will be) trustworthy
if CONN_INTERFACE_BUDDY_INFO in self._conn:
props = self._conn[CONN_INTERFACE_BUDDY_INFO].GetProperties(
handle, byte_arrays=True, utf8_strings=True)
key = props.get('key')
else:
key = None
if key is not None:
khash = psutils.pubkey_to_keyid(key)
ret[handle] = 'keyid/' + khash
else:
ret[handle] = 'salut/' + psutils.escape_identifier(ident)
return ret
def _have_to_wait_cb(self):
if self._have_to_wait_id > 0:
gobject.source_remove(self._have_to_wait_id)
self._have_to_wait_id = 0
_logger.debug("Timeout elapsed. Salut can connect now")
self.emit('want-to-connect')
def _ip4_address_changed_cb(self, ip4am, address, iface):
TelepathyPlugin._ip4_address_changed_cb(self, ip4am, address, iface)
# FIXME: what about IPv6 ?
if iface == "msh0" and not address.startswith("169.254."):
# msh0 got a not link-local IP so we are connected to a school
# server. Let's disable Salut. See #6299 for details.
_logger.debug("Connected to a school server. Disable Salut")
self._stop()
# Salut can't connect during the next 2 minutes
self._have_to_wait_id = gobject.timeout_add(120000,
self._have_to_wait_cb)
def _handle_is_channel_specific(self, handle):
# Salut doesn't have channel specific handles
return False
|