Mercurial > libervia-backend
annotate src/plugins/plugin_xep_0260.py @ 1567:268fda4236ca
plugins XE0166, XEP-0234, XEP-0260, XEP-0261: renamed session key managing other peer's jid to "peer_jid" instead of "to_jid"
| author | Goffi <goffi@goffi.org> |
|---|---|
| date | Sun, 08 Nov 2015 14:44:33 +0100 |
| parents | dcce63810733 |
| children | 37d4be4a9fed |
| rev | line source |
|---|---|
| 1560 | 1 #!/usr/bin/python |
| 2 # -*- coding: utf-8 -*- | |
| 3 | |
| 4 # SAT plugin for Jingle (XEP-0260) | |
| 5 # Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Jérôme Poisson (goffi@goffi.org) | |
| 6 | |
| 7 # This program is free software: you can redistribute it and/or modify | |
| 8 # it under the terms of the GNU Affero General Public License as published by | |
| 9 # the Free Software Foundation, either version 3 of the License, or | |
| 10 # (at your option) any later version. | |
| 11 | |
| 12 # This program is distributed in the hope that it will be useful, | |
| 13 # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 15 # GNU Affero General Public License for more details. | |
| 16 | |
| 17 # You should have received a copy of the GNU Affero General Public License | |
| 18 # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 19 | |
| 20 from sat.core.i18n import _ | |
| 21 from sat.core.log import getLogger | |
| 22 log = getLogger(__name__) | |
| 23 from sat.core import exceptions | |
| 24 from wokkel import disco, iwokkel | |
| 25 from zope.interface import implements | |
| 26 from twisted.words.xish import domish | |
| 27 from twisted.words.protocols.jabber import jid | |
| 28 from twisted.internet import defer | |
| 29 import uuid | |
| 30 | |
| 31 try: | |
| 32 from twisted.words.protocols.xmlstream import XMPPHandler | |
| 33 except ImportError: | |
| 34 from wokkel.subprotocols import XMPPHandler | |
| 35 | |
| 36 | |
| 37 NS_JINGLE_S5B = 'urn:xmpp:jingle:transports:s5b:1' | |
| 38 | |
| 39 PLUGIN_INFO = { | |
| 40 "name": "Jingle SOCKS5 Bytestreams", | |
| 41 "import_name": "XEP-0260", | |
| 42 "type": "XEP", | |
| 43 "protocols": ["XEP-0260"], | |
| 44 "dependencies": ["XEP-0166", "XEP-0065"], | |
| 45 "main": "XEP_0260", | |
| 46 "handler": "yes", | |
| 47 "description": _("""Implementation of Jingle SOCKS5 Bytestreams""") | |
| 48 } | |
| 49 | |
| 50 | |
| 51 class XEP_0260(object): | |
| 52 # TODO: udp handling | |
| 53 | |
| 54 def __init__(self, host): | |
| 55 log.info(_("plugin Jingle SOCKS5 Bytestreams")) | |
| 56 self.host = host | |
| 57 self._j = host.plugins["XEP-0166"] # shortcut to access jingle | |
| 58 self._s5b = host.plugins["XEP-0065"] # and socks5 bytestream | |
| 59 self._j.registerTransport(NS_JINGLE_S5B, self._j.TRANSPORT_STREAMING, self, 100) | |
| 60 | |
| 61 def getHandler(self, profile): | |
| 62 return XEP_0260_handler() | |
| 63 | |
| 64 def _parseCandidates(self, transport_elt): | |
| 65 """Parse <candidate> elements | |
| 66 | |
| 67 @param transport_elt(domish.Element): parent <transport> element | |
| 68 @return (list[plugin_xep_0065.Candidate): list of parsed candidates | |
| 69 """ | |
| 70 candidates = [] | |
| 71 for candidate_elt in transport_elt.elements(NS_JINGLE_S5B, 'candidate'): | |
| 72 try: | |
| 73 cid = candidate_elt['cid'] | |
| 74 host = candidate_elt['host'] | |
| 75 jid_= jid.JID(candidate_elt['jid']) | |
| 76 port = int(candidate_elt.getAttribute('port', 1080)) | |
| 77 priority = int(candidate_elt['priority']) | |
| 78 type_ = candidate_elt.getAttribute('type', self._s5b.TYPE_DIRECT) | |
| 79 except (KeyError, ValueError): | |
| 80 raise exceptions.DataError() | |
| 81 candidate = self._s5b.Candidate(host, port, type_, priority, jid_, cid) | |
| 82 candidates.append(candidate) | |
| 83 # self._s5b.registerCandidate(candidate) | |
| 84 return candidates | |
| 85 | |
| 86 def _buildCandidates(self, session, candidates, sid, session_hash, client, mode=None): | |
| 87 """Build <transport> element with candidates | |
| 88 | |
| 89 @param session(dict): jingle session data | |
| 90 @param candidates(iterator[plugin_xep_0065.Candidate]): iterator of candidates to add | |
| 91 @param sid(unicode): transport stream id | |
| 92 @param client: %(doc_client)s | |
| 93 @param mode(str, None): 'tcp' or 'udp', or None to have no attribute | |
| 94 @return (domish.Element): parent <transport> element where <candidate> elements must be added | |
| 95 """ | |
| 96 proxy = next((candidate for candidate in candidates if candidate.type == self._s5b.TYPE_PROXY), None) | |
| 97 transport_elt = domish.Element((NS_JINGLE_S5B, "transport")) | |
| 98 transport_elt['sid'] = sid | |
| 99 if proxy is not None: | |
| 100 transport_elt['dstaddr'] = session_hash | |
| 101 if mode is not None: | |
| 102 transport_elt['mode'] = 'tcp' # XXX: we only manage tcp for now | |
| 103 | |
| 104 for candidate in candidates: | |
| 105 log.debug(u"Adding candidate: {}".format(candidate)) | |
| 106 candidate_elt = transport_elt.addElement('candidate', NS_JINGLE_S5B) | |
| 107 if candidate.id is None: | |
| 108 candidate.id = unicode(uuid.uuid4()) | |
| 109 candidate_elt['cid'] = candidate.id | |
| 110 candidate_elt['host'] = candidate.host | |
| 111 candidate_elt['jid'] = candidate.jid.full() | |
| 112 candidate_elt['port'] = unicode(candidate.port) | |
| 113 candidate_elt['priority'] = unicode(candidate.priority) | |
| 114 candidate_elt['type'] = candidate.type | |
| 115 return transport_elt | |
| 116 | |
| 117 @defer.inlineCallbacks | |
| 118 def jingleSessionInit(self, session, content_name, profile): | |
| 119 client = self.host.getClient(profile) | |
| 120 content_data = session['contents'][content_name] | |
| 121 transport_data = content_data['transport_data'] | |
| 122 sid = transport_data['sid'] = unicode(uuid.uuid4()) | |
|
1567
268fda4236ca
plugins XE0166, XEP-0234, XEP-0260, XEP-0261: renamed session key managing other peer's jid to "peer_jid" instead of "to_jid"
Goffi <goffi@goffi.org>
parents:
1560
diff
changeset
|
123 session_hash = transport_data['session_hash'] = self._s5b.getSessionHash(client.jid, session['peer_jid'], sid) |
| 1560 | 124 candidates = transport_data['candidates'] = yield self._s5b.getCandidates(profile) |
| 125 mode = 'tcp' # XXX: we only manage tcp for now | |
| 126 transport_elt = self._buildCandidates(session, candidates, sid, session_hash, client, mode) | |
| 127 | |
| 128 defer.returnValue(transport_elt) | |
| 129 | |
| 130 def _foundPeerCandidate(self, candidate, session, transport_data, content_name, client): | |
| 131 """Called when the best candidate from other peer is found | |
| 132 | |
| 133 @param candidate(XEP_0065.Candidate, None): selected candidate, | |
| 134 or None if no candidate is accessible | |
| 135 @param session(dict): session data | |
| 136 @param transport_data(dict): transport data | |
| 137 @param content_name(dict): name of the current content | |
| 138 @param client(unicode): %(doc_client)s | |
| 139 """ | |
| 140 | |
| 141 transport_data['best_candidate'] = candidate | |
| 142 # we need to disconnect all non selected candidates before removing them | |
| 143 for c in transport_data['peer_candidates']: | |
| 144 if c is None or c is candidate: | |
| 145 continue | |
| 146 c.discard() | |
| 147 del transport_data['peer_candidates'] | |
| 148 iq_elt, transport_elt = self._j.buildAction(self._j.A_TRANSPORT_INFO, session, content_name, client.profile) | |
| 149 if candidate is None: | |
| 150 log.warning(u"Can't connect to any peer candidate") | |
| 151 candidate_elt = transport_elt.addElement('candidate-error') | |
| 152 else: | |
| 153 log.info(u"Found best peer candidate: {}".format(unicode(candidate))) | |
| 154 candidate_elt = transport_elt.addElement('candidate-used') | |
| 155 candidate_elt['cid'] = candidate.id | |
| 156 iq_elt.send() # TODO: check result stanza | |
| 157 content_data = session['contents'][content_name] | |
| 158 self._checkCandidates(session, content_data, transport_data, client) | |
| 159 | |
| 160 def _checkCandidates(self, session, content_data, transport_data, client): | |
| 161 """Called when a candidate has been choosed | |
| 162 | |
| 163 if we have both candidates, we select one, or fallback to an other transport | |
| 164 @param session(dict): session data | |
| 165 @param content_data(dict): content data | |
| 166 @param transport_data(dict): transport data | |
| 167 @param client(unicode): %(doc_client)s | |
| 168 """ | |
| 169 try: | |
| 170 best_candidate = transport_data['best_candidate'] | |
| 171 except KeyError: | |
| 172 # we have not our best candidate yet | |
| 173 return | |
| 174 try: | |
| 175 peer_best_candidate = transport_data['peer_best_candidate'] | |
| 176 except KeyError: | |
| 177 # we have not peer best candidate yet | |
| 178 return | |
| 179 | |
| 180 # at this point we have both candidates, it's time to choose one | |
| 181 if best_candidate is None or peer_best_candidate is None: | |
| 182 choosed_candidate = best_candidate or peer_best_candidate | |
| 183 else: | |
| 184 if best_candidate.priority == peer_best_candidate.priority: | |
| 185 # same priority, we choose initiator one according to XEP-0260 §2.4 #4 | |
| 186 log.debug(u"Candidates have same priority, we choose the initiator one") | |
| 187 if session['initiator'] == client.jid: | |
| 188 choosed_candidate = best_candidate | |
| 189 else: | |
| 190 choosed_candidate = peer_best_candidate | |
| 191 else: | |
| 192 choosed_candidate = max(best_candidate, peer_best_candidate, key=lambda c:c.priority) | |
| 193 | |
| 194 if choosed_candidate is None: | |
| 195 log.warning(u"Socks5 negociation failed, we need to fallback to IBB") | |
| 196 else: | |
| 197 if choosed_candidate==best_candidate: | |
| 198 who = u'our' | |
| 199 else: | |
| 200 who = u'other peer' | |
| 201 best_candidate.discard() | |
| 202 | |
| 203 log.info(u"Socks5 negociation successful, {who} candidate will be used: {candidate}".format( | |
| 204 who = who, | |
| 205 candidate = choosed_candidate)) | |
| 206 del transport_data['best_candidate'] | |
| 207 del transport_data['peer_best_candidate'] | |
| 208 if content_data['senders'] == session['role']: | |
| 209 # we can now start the file transfer | |
| 210 choosed_candidate.startTransfer(transport_data['session_hash']) | |
| 211 | |
| 212 @defer.inlineCallbacks | |
| 213 def jingleHandler(self, action, session, content_name, transport_elt, profile): | |
| 214 client = self.host.getClient(profile) | |
| 215 content_data = session['contents'][content_name] | |
| 216 transport_data = content_data['transport_data'] | |
| 217 | |
| 218 if action in (self._j.A_ACCEPTED_ACK,): | |
| 219 pass | |
| 220 | |
| 221 elif action == self._j.A_SESSION_ACCEPT: | |
| 222 # initiator side, we select a candidate in the ones sent by responder | |
| 223 assert 'peer_candidates' not in transport_data | |
| 224 transport_data['peer_candidates'] = self._parseCandidates(transport_elt) | |
| 225 | |
| 226 # elif action == self._j.A_START: | |
| 227 elif action == self._j.A_START: | |
| 228 session_hash = transport_data['session_hash'] | |
| 229 peer_candidates = transport_data['peer_candidates'] | |
| 230 file_obj = content_data['file_obj'] | |
| 231 stream_d = self._s5b.registerHash(session_hash, file_obj, profile) | |
| 232 args = [session, content_name, profile] | |
| 233 stream_d.addCallbacks(self._streamCb, self._streamEb, args, None, args) | |
| 234 d = self._s5b.getBestCandidate(peer_candidates, session_hash, profile) | |
| 235 d.addCallback(self._foundPeerCandidate, session, transport_data, content_name, client) | |
| 236 | |
| 237 elif action == self._j.A_SESSION_INITIATE: | |
| 238 # responder side, we select a candidate in the ones sent by initiator | |
| 239 # and we give our candidates | |
| 240 assert 'peer_candidates' not in transport_data | |
| 241 sid = transport_data['sid'] = transport_elt['sid'] | |
|
1567
268fda4236ca
plugins XE0166, XEP-0234, XEP-0260, XEP-0261: renamed session key managing other peer's jid to "peer_jid" instead of "to_jid"
Goffi <goffi@goffi.org>
parents:
1560
diff
changeset
|
242 session_hash = transport_data['session_hash'] = self._s5b.getSessionHash(session['peer_jid'], client.jid, sid) |
| 1560 | 243 peer_candidates = transport_data['peer_candidates'] = self._parseCandidates(transport_elt) |
| 244 file_obj = content_data['file_obj'] | |
| 245 stream_d = self._s5b.registerHash(session_hash, file_obj, profile) | |
| 246 args = [session, content_name, profile] | |
| 247 stream_d.addCallbacks(self._streamCb, self._streamEb, args, None, args) | |
| 248 d = self._s5b.getBestCandidate(peer_candidates, session_hash, profile) | |
| 249 d.addCallback(self._foundPeerCandidate, session, transport_data, content_name, client) | |
| 250 candidates = yield self._s5b.getCandidates(profile) | |
| 251 # we remove duplicate candidates | |
| 252 candidates = [candidate for candidate in candidates if candidate not in peer_candidates] | |
| 253 | |
| 254 transport_data['candidates'] = candidates | |
| 255 # we can now build a new <transport> element with our candidates | |
| 256 transport_elt = self._buildCandidates(session, candidates, sid, session_hash, client) | |
| 257 | |
| 258 elif action == self._j.A_TRANSPORT_INFO: | |
| 259 # other peer gave us its choosed candidate | |
| 260 try: | |
| 261 candidate_elt = transport_elt.elements(NS_JINGLE_S5B, 'candidate-used').next() | |
| 262 except StopIteration: | |
| 263 try: | |
| 264 candidate_elt = transport_elt.elements(NS_JINGLE_S5B, 'candidate-error').next() | |
| 265 except StopIteration: | |
| 266 log.warning(u"Unexpected transport element: {}".format(transport_elt.toXml())) | |
| 267 raise exceptions.DataError | |
| 268 else: | |
| 269 # candidate-error, no candidate worked | |
| 270 transport_data['peer_best_candidate'] = None | |
| 271 else: | |
| 272 # candidate-used, one candidate was choosed | |
| 273 try: | |
| 274 cid = candidate_elt.attributes['cid'] | |
| 275 except KeyError: | |
| 276 log.warning(u"No cid found in <candidate-used>") | |
| 277 raise exceptions.DataError | |
| 278 try: | |
| 279 candidate = (c for c in transport_data['candidates'] if c.id == cid).next() | |
| 280 except StopIteration: | |
| 281 log.warning(u"Given cid doesn't correspond to any known candidate !") | |
| 282 raise exceptions.DataError # TODO: send an error to other peer, and use better exception | |
| 283 except KeyError: | |
| 284 # a transport-info can also be intentionaly sent too early by other peer | |
| 285 # but there is little probability | |
| 286 log.error(u'"candidates" key doesn\'t exists in transport_data, it should at this point') | |
| 287 raise exceptions.InternalError | |
| 288 # at this point we have the candidate choosed by other peer | |
| 289 transport_data['peer_best_candidate'] = candidate | |
| 290 log.info(u"Other peer best candidate: {}".format(candidate)) | |
| 291 | |
| 292 del transport_data['candidates'] | |
| 293 self._checkCandidates(session, content_data, transport_data, client) | |
| 294 | |
| 295 else: | |
| 296 log.warning(u"FIXME: unmanaged action {}".format(action)) | |
| 297 | |
| 298 defer.returnValue(transport_elt) | |
| 299 | |
| 300 def _streamCb(self, dummy, session, content_name, profile): | |
| 301 self._j.contentTerminate(session, content_name, profile=profile) | |
| 302 | |
| 303 def _streamEb(self, failure, session, content_name, profile): | |
| 304 log.warning(u"Error while streaming through s5b: {}".format(failure)) | |
| 305 self._j.contentTerminate(session, content_name, reason=self._j.REASON_FAILED_TRANSPORT, profile=profile) | |
| 306 | |
| 307 | |
| 308 class XEP_0260_handler(XMPPHandler): | |
| 309 implements(iwokkel.IDisco) | |
| 310 | |
| 311 def getDiscoInfo(self, requestor, target, nodeIdentifier=''): | |
| 312 return [disco.DiscoFeature(NS_JINGLE_S5B)] | |
| 313 | |
| 314 def getDiscoItems(self, requestor, target, nodeIdentifier=''): | |
| 315 return [] |