libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0234.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	69e4716d6268
children	fee60f17ebac

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT plugin for Jingle File Transfer (XEP-0234)
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat.core import exceptions
 from wokkel import disco, iwokkel
-from zope.interface import implements
+from zope.interface import implementer
 from sat.tools import utils
 from sat.tools import stream
 from sat.tools.common import date_utils
 import os.path
 from twisted.words.xish import domish
 C.PI_MAIN: "XEP_0234",
 C.PI_HANDLER: "yes",
 C.PI_DESCRIPTION: _("""Implementation of Jingle File Transfer"""),
 }
-EXTRA_ALLOWED = {u"path", u"namespace", u"file_desc", u"file_hash"}
+EXTRA_ALLOWED = {"path", "namespace", "file_desc", "file_hash"}
 Range = namedtuple("Range", ("offset", "length"))
 class XEP_0234(object):
 # TODO: assure everything is closed when file is sent or session terminate is received
 host.registerNamespace("jingle-ft", NS_JINGLE_FT)
 self._j = host.plugins["XEP-0166"]  # shortcut to access jingle
 self._j.registerApplication(NS_JINGLE_FT, self)
 self._f = host.plugins["FILE"]
 self._f.register(
-NS_JINGLE_FT, self.fileJingleSend, priority=10000, method_name=u"Jingle"
+NS_JINGLE_FT, self.fileJingleSend, priority=10000, method_name="Jingle"
 )
 self._hash = self.host.plugins["XEP-0300"]
 host.bridge.addMethod(
 "fileJingleSend",
 ".plugin",
 in_sign="ssssa{ss}s",
 out_sign="",
 method=self._fileJingleSend,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "fileJingleRequest",
 ".plugin",
 in_sign="sssssa{ss}s",
 out_sign="s",
 method=self._fileJingleRequest,
-async=True,
+async_=True,
 )
 def getHandler(self, client):
 return XEP_0234_handler()
 @param session(dict): jingle session
 @param content_name(unicode): name of the content
 @return (unicode): unique progress id
 """
-return u"{}_{}".format(session["id"], content_name)
+return "{}_{}".format(session["id"], content_name)
 # generic methods
 def buildFileElement(self, name, file_hash=None, hash_algo=None, size=None,
 mime_type=None, desc=None, modified=None, transfer_range=None, path=None,
 @param **kwargs: data for plugin extension (ignored by default)
 @return (domish.Element): generated element
 @trigger XEP-0234_buildFileElement(file_elt, extra_args): can be used to extend elements to add
 """
 if file_elt is None:
-file_elt = domish.Element((NS_JINGLE_FT, u"file"))
+file_elt = domish.Element((NS_JINGLE_FT, "file"))
 for name, value in (
-(u"name", name),
+("name", name),
-(u"size", size),
+("size", size),
 ("media-type", mime_type),
-(u"desc", desc),
+("desc", desc),
-(u"path", path),
+("path", path),
-(u"namespace", namespace),
+("namespace", namespace),
 ):
 if value is not None:
-file_elt.addElement(name, content=unicode(value))
+file_elt.addElement(name, content=str(value))
 if modified is not None:
 if isinstance(modified, int):
-file_elt.addElement(u"date", utils.xmpp_date(modified or None))
+file_elt.addElement("date", utils.xmpp_date(modified or None))
 else:
-file_elt.addElement(u"date", modified)
+file_elt.addElement("date", modified)
 elif "created" in kwargs:
-file_elt.addElement(u"date", utils.xmpp_date(kwargs.pop("created")))
+file_elt.addElement("date", utils.xmpp_date(kwargs.pop("created")))
-range_elt = file_elt.addElement(u"range")
+range_elt = file_elt.addElement("range")
 if transfer_range is not None:
 if transfer_range.offset is not None:
-range_elt[u"offset"] = transfer_range.offset
+range_elt["offset"] = transfer_range.offset
 if transfer_range.length is not None:
-range_elt[u"length"] = transfer_range.length
+range_elt["length"] = transfer_range.length
 if file_hash is not None:
 if not file_hash:
 file_elt.addChild(self._hash.buildHashUsedElt())
 else:
 file_elt.addChild(self._hash.buildHashElt(file_hash, hash_algo))
 elif hash_algo is not None:
 file_elt.addChild(self._hash.buildHashUsedElt(hash_algo))
-self.host.trigger.point(u"XEP-0234_buildFileElement", file_elt, extra_args=kwargs)
+self.host.trigger.point("XEP-0234_buildFileElement", file_elt, extra_args=kwargs)
 if kwargs:
 for kw in kwargs:
 log.debug("ignored keyword: {}".format(kw))
 return file_elt
 @raise exceptions.DataError: if file_elt uri is not NS_JINGLE_FT
 """
 if parent_elt is not None:
 if file_elt is not None:
 raise exceptions.InternalError(
-u"file_elt must be None if parent_elt is set"
+"file_elt must be None if parent_elt is set"
 )
 try:
-file_elt = next(parent_elt.elements(NS_JINGLE_FT, u"file"))
+file_elt = next(parent_elt.elements(NS_JINGLE_FT, "file"))
 except StopIteration:
 raise exceptions.NotFound()
 else:
 if not file_elt or file_elt.uri != NS_JINGLE_FT:
 raise exceptions.DataError(
-u"invalid <file> element: {stanza}".format(stanza=file_elt.toXml())
+"invalid <file> element: {stanza}".format(stanza=file_elt.toXml())
 )
 if file_data is None:
 file_data = {}
-for name in (u"name", u"desc", u"path", u"namespace"):
+for name in ("name", "desc", "path", "namespace"):
 try:
-file_data[name] = unicode(next(file_elt.elements(NS_JINGLE_FT, name)))
+file_data[name] = str(next(file_elt.elements(NS_JINGLE_FT, name)))
 except StopIteration:
 pass
-name = file_data.get(u"name")
+name = file_data.get("name")
-if name == u"..":
+if name == "..":
 # we don't want to go to parent dir when joining to a path
-name = u"--"
+name = "--"
-file_data[u"name"] = name
+file_data["name"] = name
-elif name is not None and u"/" in name or u"\\" in name:
+elif name is not None and "/" in name or "\\" in name:
-file_data[u"name"] = regex.pathEscape(name)
+file_data["name"] = regex.pathEscape(name)
 try:
-file_data[u"mime_type"] = unicode(
+file_data["mime_type"] = str(
-next(file_elt.elements(NS_JINGLE_FT, u"media-type"))
+next(file_elt.elements(NS_JINGLE_FT, "media-type"))
 )
 except StopIteration:
 pass
 try:
-file_data[u"size"] = int(
+file_data["size"] = int(
-unicode(next(file_elt.elements(NS_JINGLE_FT, u"size")))
+str(next(file_elt.elements(NS_JINGLE_FT, "size")))
 )
 except StopIteration:
 pass
 try:
-file_data[u"modified"] = date_utils.date_parse(
+file_data["modified"] = date_utils.date_parse(
-next(file_elt.elements(NS_JINGLE_FT, u"date"))
+next(file_elt.elements(NS_JINGLE_FT, "date"))
 )
 except StopIteration:
 pass
 try:
-range_elt = file_elt.elements(NS_JINGLE_FT, u"range").next()
+range_elt = next(file_elt.elements(NS_JINGLE_FT, "range"))
 except StopIteration:
 pass
 else:
 offset = range_elt.getAttribute("offset")
 length = range_elt.getAttribute("length")
 if offset or length or keep_empty_range:
-file_data[u"transfer_range"] = Range(offset=offset, length=length)
+file_data["transfer_range"] = Range(offset=offset, length=length)
-prefix = u"given_" if given else u""
+prefix = "given_" if given else ""
-hash_algo_key, hash_key = u"hash_algo", prefix + u"file_hash"
+hash_algo_key, hash_key = "hash_algo", prefix + "file_hash"
 try:
 file_data[hash_algo_key], file_data[hash_key] = self._hash.parseHashElt(
 file_elt
 )
 except exceptions.NotFound:
 pass
-self.host.trigger.point(u"XEP-0234_parseFileElement", file_elt, file_data)
+self.host.trigger.point("XEP-0234_parseFileElement", file_elt, file_data)
 return file_data
 # bridge methods
 progress_id_d = defer.Deferred()
 if extra is None:
 extra = {}
 if file_hash is not None:
 if hash_algo is None:
-raise ValueError(_(u"hash_algo must be set if file_hash is set"))
+raise ValueError(_("hash_algo must be set if file_hash is set"))
 extra["file_hash"] = file_hash
 extra["hash_algo"] = hash_algo
 else:
 if hash_algo is not None:
-raise ValueError(_(u"file_hash must be set if hash_algo is set"))
+raise ValueError(_("file_hash must be set if hash_algo is set"))
 yield self._j.initiate(
 client,
 peer_jid,
 [
 {
 if extra is None:
 extra = {}
 else:
 if not EXTRA_ALLOWED.issuperset(extra):
 raise ValueError(
-_(u"only the following keys are allowed in extra: {keys}").format(
+_("only the following keys are allowed in extra: {keys}").format(
-keys=u", ".join(EXTRA_ALLOWED)
+keys=", ".join(EXTRA_ALLOWED)
 )
 )
 progress_id_d.callback(self.getProgressId(session, content_name))
 content_data = session["contents"][content_name]
 application_data = content_data["application_data"]
 application_data["file_path"] = filepath
 file_data = application_data["file_data"] = {}
 desc_elt = domish.Element((NS_JINGLE_FT, "description"))
 file_elt = desc_elt.addElement("file")
-if content_data[u"senders"] == self._j.ROLE_INITIATOR:
+if content_data["senders"] == self._j.ROLE_INITIATOR:
 # we send a file
 if name is None:
 name = os.path.basename(filepath)
-file_data[u"date"] = utils.xmpp_date()
+file_data["date"] = utils.xmpp_date()
-file_data[u"desc"] = extra.pop(u"file_desc", u"")
+file_data["desc"] = extra.pop("file_desc", "")
-file_data[u"name"] = name
+file_data["name"] = name
 mime_type = mimetypes.guess_type(name, strict=False)[0]
 if mime_type is not None:
-file_data[u"mime_type"] = mime_type
+file_data["mime_type"] = mime_type
-file_data[u"size"] = os.path.getsize(filepath)
+file_data["size"] = os.path.getsize(filepath)
-if u"namespace" in extra:
+if "namespace" in extra:
-file_data[u"namespace"] = extra[u"namespace"]
+file_data["namespace"] = extra["namespace"]
-if u"path" in extra:
+if "path" in extra:
-file_data[u"path"] = extra[u"path"]
+file_data["path"] = extra["path"]
-self.buildFileElementFromDict(file_data, file_elt=file_elt, file_hash=u"")
+self.buildFileElementFromDict(file_data, file_elt=file_elt, file_hash="")
 else:
 # we request a file
-file_hash = extra.pop(u"file_hash", u"")
+file_hash = extra.pop("file_hash", "")
 if not name and not file_hash:
-raise ValueError(_(u"you need to provide at least name or file hash"))
+raise ValueError(_("you need to provide at least name or file hash"))
 if name:
-file_data[u"name"] = name
+file_data["name"] = name
 if file_hash:
-file_data[u"file_hash"] = file_hash
+file_data["file_hash"] = file_hash
-file_data[u"hash_algo"] = extra[u"hash_algo"]
+file_data["hash_algo"] = extra["hash_algo"]
 else:
-file_data[u"hash_algo"] = self._hash.getDefaultAlgo()
+file_data["hash_algo"] = self._hash.getDefaultAlgo()
-if u"namespace" in extra:
+if "namespace" in extra:
-file_data[u"namespace"] = extra[u"namespace"]
+file_data["namespace"] = extra["namespace"]
-if u"path" in extra:
+if "path" in extra:
-file_data[u"path"] = extra[u"path"]
+file_data["path"] = extra["path"]
 self.buildFileElementFromDict(file_data, file_elt=file_elt)
 return desc_elt
 def jingleRequestConfirmation(self, client, action, session, content_name, desc_elt):
 """This method request confirmation for a jingle session"""
 content_data = session["contents"][content_name]
-senders = content_data[u"senders"]
+senders = content_data["senders"]
 if senders not in (self._j.ROLE_INITIATOR, self._j.ROLE_RESPONDER):
-log.warning(u"Bad sender, assuming initiator")
+log.warning("Bad sender, assuming initiator")
-senders = content_data[u"senders"] = self._j.ROLE_INITIATOR
+senders = content_data["senders"] = self._j.ROLE_INITIATOR
 # first we grab file informations
 try:
-file_elt = desc_elt.elements(NS_JINGLE_FT, "file").next()
+file_elt = next(desc_elt.elements(NS_JINGLE_FT, "file"))
 except StopIteration:
 raise failure.Failure(exceptions.DataError)
 file_data = {"progress_id": self.getProgressId(session, content_name)}
 if senders == self._j.ROLE_RESPONDER:
 finished_d.addCallbacks(
 self._finishedCb, self._finishedEb, args, None, args
 )
 defer.returnValue(confirmed)
-log.warning(_(u"File continue is not implemented yet"))
+log.warning(_("File continue is not implemented yet"))
 defer.returnValue(False)
 def _fileReceivingRequestConf(
 self, client, session, content_data, content_name, file_data, file_elt
 ):
 raise failure.Failure(exceptions.DataError)
 name = file_data["name"]
 if "/" in name or "\\" in name:
 log.warning(
-u"File name contain path characters, we replace them: {}".format(name)
+"File name contain path characters, we replace them: {}".format(name)
 )
 file_data["name"] = name.replace("/", "_").replace("\\", "_")
 content_data["application_data"]["file_data"] = file_data
 content_data = session["contents"][content_name]
 application_data = content_data["application_data"]
 if action in (self._j.A_ACCEPTED_ACK,):
 pass
 elif action == self._j.A_SESSION_INITIATE:
-file_elt = desc_elt.elements(NS_JINGLE_FT, "file").next()
+file_elt = next(desc_elt.elements(NS_JINGLE_FT, "file"))
 try:
-file_elt.elements(NS_JINGLE_FT, "range").next()
+next(file_elt.elements(NS_JINGLE_FT, "range"))
 except StopIteration:
 # initiator doesn't manage <range>, but we do so we advertise it
 #  FIXME: to be checked
 log.debug("adding <range> element")
 file_elt.addElement("range")
 elif action == self._j.A_SESSION_ACCEPT:
 assert not "stream_object" in content_data
 file_data = application_data["file_data"]
 file_path = application_data["file_path"]
-senders = content_data[u"senders"]
+senders = content_data["senders"]
-if senders != session[u"role"]:
+if senders != session["role"]:
 # we are receiving the file
 try:
 # did the responder specified the size of the file?
-file_elt = next(desc_elt.elements(NS_JINGLE_FT, u"file"))
+file_elt = next(desc_elt.elements(NS_JINGLE_FT, "file"))
-size_elt = next(file_elt.elements(NS_JINGLE_FT, u"size"))
+size_elt = next(file_elt.elements(NS_JINGLE_FT, "size"))
-size = int(unicode(size_elt))
+size = int(str(size_elt))
 except (StopIteration, ValueError):
 size = None
 # XXX: hash security is not critical here, so we just take the higher mandatory one
 hasher = file_data["hash_hasher"] = self._hash.getHasher()
 content_data["stream_object"] = stream.FileStreamObject(
 )
 finished_d = content_data["finished_d"] = defer.Deferred()
 args = [client, session, content_name, content_data]
 finished_d.addCallbacks(self._finishedCb, self._finishedEb, args, None, args)
 else:
-log.warning(u"FIXME: unmanaged action {}".format(action))
+log.warning("FIXME: unmanaged action {}".format(action))
 return desc_elt
 def jingleSessionInfo(self, client, action, session, content_name, jingle_elt):
 """Called on session-info action
 pass
 elif elt.name == "checksum":
 # we have received the file hash, we need to parse it
 if content_data["senders"] == session["role"]:
 log.warning(
-u"unexpected checksum received while we are the file sender"
+"unexpected checksum received while we are the file sender"
 )
 raise exceptions.DataError
 info_content_name = elt["name"]
 if info_content_name != content_name:
 # it was for an other content...
 return
 file_data = content_data["application_data"]["file_data"]
 try:
-file_elt = elt.elements((NS_JINGLE_FT, "file")).next()
+file_elt = next(elt.elements((NS_JINGLE_FT, "file")))
 except StopIteration:
 raise exceptions.DataError
 algo, file_data["given_file_hash"] = self._hash.parseHashElt(file_elt)
 if algo != file_data.get("hash_algo"):
 log.warning(
-u"Hash algorithm used in given hash ({peer_algo}) doesn't correspond to the one we have used ({our_algo}) [{profile}]".format(
+"Hash algorithm used in given hash ({peer_algo}) doesn't correspond to the one we have used ({our_algo}) [{profile}]".format(
 peer_algo=algo,
 our_algo=file_data.get("hash_algo"),
 profile=client.profile,
 )
 )
 def _sendCheckSum(self, client, session, content_name, content_data):
 """Send the session-info with the hash checksum"""
 file_data = content_data["application_data"]["file_data"]
 hasher = file_data["hash_hasher"]
 hash_ = hasher.hexdigest()
-log.debug(u"Calculated hash: {}".format(hash_))
+log.debug("Calculated hash: {}".format(hash_))
 iq_elt, jingle_elt = self._j.buildSessionInfo(client, session)
 checksum_elt = jingle_elt.addElement((NS_JINGLE_FT, "checksum"))
 checksum_elt["creator"] = content_data["creator"]
 checksum_elt["name"] = content_name
 file_elt = checksum_elt.addElement("file")
 file_data = content_data["application_data"]["file_data"]
 given_hash = file_data.get("given_file_hash")
 if given_hash is None:
 if last_try:
 log.warning(
-u"sender didn't sent hash checksum, we can't check the file [{profile}]".format(
+"sender didn't sent hash checksum, we can't check the file [{profile}]".format(
 profile=client.profile
 )
 )
 self._j.delayedContentTerminate(client, session, content_name)
 content_data["stream_object"].close()
 return True
 return False
 hasher = file_data["hash_hasher"]
-hash_ = hasher.hexdigest()
+hash_ = hasher.hexdigest().encode('utf-8')
 if hash_ == given_hash:
-log.info(u"Hash checked, file was successfully transfered: {}".format(hash_))
+log.info("Hash checked, file was successfully transfered: {}".format(hash_))
 progress_metadata = {
 "hash": hash_,
 "hash_algo": file_data["hash_algo"],
 "hash_verified": C.BOOL_TRUE,
 }
 error = None
 else:
-log.warning(u"Hash mismatch, the file was not transfered correctly")
+log.warning("Hash mismatch, the file was not transfered correctly")
 progress_metadata = None
-error = u"Hash mismatch: given={algo}:{given}, calculated={algo}:{our}".format(
+error = "Hash mismatch: given={algo}:{given}, calculated={algo}:{our}".format(
 algo=file_data["hash_algo"], given=given_hash, our=hash_
 )
 self._j.delayedContentTerminate(client, session, content_name)
 content_data["stream_object"].close(progress_metadata, error)
 except (KeyError, internet_error.AlreadyCalled):
 pass
 return True
 def _finishedCb(self, __, client, session, content_name, content_data):
-log.info(u"File transfer terminated")
+log.info("File transfer terminated")
 if content_data["senders"] != session["role"]:
 # we terminate the session only if we are the receiver,
 # as recommanded in XEP-0234 §2 (after example 6)
 content_data["transfer_finished"] = True
 if not self._receiverTryTerminate(
 # we are the sender, we send the checksum
 self._sendCheckSum(client, session, content_name, content_data)
 content_data["stream_object"].close()
 def _finishedEb(self, failure, client, session, content_name, content_data):
-log.warning(u"Error while streaming file: {}".format(failure))
+log.warning("Error while streaming file: {}".format(failure))
 content_data["stream_object"].close()
 self._j.contentTerminate(
 client, session, content_name, reason=self._j.REASON_FAILED_TRANSPORT
 )
+@implementer(iwokkel.IDisco)
 class XEP_0234_handler(XMPPHandler):
-implements(iwokkel.IDisco)
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return [disco.DiscoFeature(NS_JINGLE_FT)]
 def getDiscoItems(self, requestor, target, nodeIdentifier=""):

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0234.py @ 3028:ab2696e34d29