code style reformatting using black

This commit is contained in:
Goffi 2018-06-27 20:14:46 +02:00
commit 744cb0c503

View file

@ -20,6 +20,7 @@
from sat.core.i18n import _
from sat.core.constants import Const as C
from sat.core.log import getLogger
log = getLogger(__name__)
from sat.core import exceptions
from wokkel import disco, iwokkel
@ -40,7 +41,7 @@ from sat.tools.common import regex
import mimetypes
NS_JINGLE_FT = 'urn:xmpp:jingle:apps:file-transfer:5'
NS_JINGLE_FT = "urn:xmpp:jingle:apps:file-transfer:5"
PLUGIN_INFO = {
C.PI_NAME: "Jingle File Transfer",
@ -51,11 +52,11 @@ PLUGIN_INFO = {
C.PI_DEPENDENCIES: ["XEP-0166", "XEP-0300", "FILE"],
C.PI_MAIN: "XEP_0234",
C.PI_HANDLER: "yes",
C.PI_DESCRIPTION: _("""Implementation of Jingle File Transfer""")
C.PI_DESCRIPTION: _("""Implementation of Jingle File Transfer"""),
}
EXTRA_ALLOWED = {u'path', u'namespace', u'file_desc', u'file_hash'}
Range = namedtuple('Range', ('offset', 'length'))
EXTRA_ALLOWED = {u"path", u"namespace", u"file_desc", u"file_hash"}
Range = namedtuple("Range", ("offset", "length"))
class XEP_0234(object):
@ -66,14 +67,30 @@ class XEP_0234(object):
def __init__(self, host):
log.info(_("plugin Jingle File Transfer initialization"))
self.host = host
host.registerNamespace('jingle-ft', NS_JINGLE_FT)
self._j = host.plugins["XEP-0166"] # shortcut to access jingle
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")
self._f.register(
NS_JINGLE_FT, self.fileJingleSend, priority=10000, method_name=u"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)
host.bridge.addMethod("fileJingleRequest", ".plugin", in_sign='sssssa{ss}s', out_sign='s', method=self._fileJingleRequest, async=True)
host.bridge.addMethod(
"fileJingleSend",
".plugin",
in_sign="ssssa{ss}s",
out_sign="",
method=self._fileJingleSend,
async=True,
)
host.bridge.addMethod(
"fileJingleRequest",
".plugin",
in_sign="sssssa{ss}s",
out_sign="s",
method=self._fileJingleRequest,
async=True,
)
def getHandler(self, client):
return XEP_0234_handler()
@ -85,12 +102,25 @@ class XEP_0234(object):
@param content_name(unicode): name of the content
@return (unicode): unique progress id
"""
return u'{}_{}'.format(session['id'], content_name)
return u"{}_{}".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, namespace=None, file_elt=None, **kwargs):
def buildFileElement(
self,
name,
file_hash=None,
hash_algo=None,
size=None,
mime_type=None,
desc=None,
modified=None,
transfer_range=None,
path=None,
namespace=None,
file_elt=None,
**kwargs
):
"""Generate a <file> element with available metadata
@param file_hash(unicode, None): hash of the file
@ -109,26 +139,32 @@ class XEP_0234(object):
@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'))
for name, value in ((u'name', name), (u'size', size), ('media-type', mime_type),
(u'desc', desc), (u'path', path), (u'namespace', namespace)):
file_elt = domish.Element((NS_JINGLE_FT, u"file"))
for name, value in (
(u"name", name),
(u"size", size),
("media-type", mime_type),
(u"desc", desc),
(u"path", path),
(u"namespace", namespace),
):
if value is not None:
file_elt.addElement(name, content=unicode(value))
if modified is not None:
if isinstance(modified, int):
file_elt.addElement(u'date', utils.xmpp_date(modified or None))
file_elt.addElement(u"date", utils.xmpp_date(modified or None))
else:
file_elt.addElement(u'date', modified)
elif 'created' in kwargs:
file_elt.addElement(u'date', utils.xmpp_date(kwargs.pop('created')))
file_elt.addElement(u"date", modified)
elif "created" in kwargs:
file_elt.addElement(u"date", utils.xmpp_date(kwargs.pop("created")))
range_elt = file_elt.addElement(u'range')
range_elt = file_elt.addElement(u"range")
if transfer_range is not None:
if transfer_range.offset is not None:
range_elt[u'offset'] = transfer_range.offset
range_elt[u"offset"] = transfer_range.offset
if transfer_range.length is not None:
range_elt[u'length'] = transfer_range.length
range_elt[u"length"] = transfer_range.length
if file_hash is not None:
if not file_hash:
file_elt.addChild(self._hash.buildHashUsedElt())
@ -136,10 +172,10 @@ class XEP_0234(object):
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(u"XEP-0234_buildFileElement", file_elt, extra_args=kwargs)
if kwargs:
for kw in kwargs:
log.debug('ignored keyword: {}'.format(kw))
log.debug("ignored keyword: {}".format(kw))
return file_elt
def buildFileElementFromDict(self, file_data, **kwargs):
@ -151,10 +187,16 @@ class XEP_0234(object):
if kwargs:
file_data = file_data.copy()
file_data.update(kwargs)
return self. buildFileElement(**file_data)
return self.buildFileElement(**file_data)
def parseFileElement(self, file_elt, file_data=None, given=False, parent_elt=None, keep_empty_range=False):
def parseFileElement(
self,
file_elt,
file_data=None,
given=False,
parent_elt=None,
keep_empty_range=False,
):
"""Parse a <file> element and file dictionary accordingly
@param file_data(dict, None): dict where the data will be set
@ -173,77 +215,105 @@ class XEP_0234(object):
"""
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')
raise exceptions.InternalError(
u"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, u"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()))
raise exceptions.DataError(
u"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 (u"name", u"desc", u"path", u"namespace"):
try:
file_data[name] = unicode(next(file_elt.elements(NS_JINGLE_FT, name)))
except StopIteration:
pass
name = file_data.get(u'name')
if name == u'..':
name = file_data.get(u"name")
if name == u"..":
# we don't want to go to parent dir when joining to a path
name = u'--'
file_data[u'name'] = name
elif name is not None and u'/' in name or u'\\' in name:
file_data[u'name'] = regex.pathEscape(name)
name = u"--"
file_data[u"name"] = name
elif name is not None and u"/" in name or u"\\" in name:
file_data[u"name"] = regex.pathEscape(name)
try:
file_data[u'mime_type'] = unicode(next(file_elt.elements(NS_JINGLE_FT, u'media-type')))
file_data[u"mime_type"] = unicode(
next(file_elt.elements(NS_JINGLE_FT, u"media-type"))
)
except StopIteration:
pass
try:
file_data[u'size'] = int(unicode(next(file_elt.elements(NS_JINGLE_FT, u'size'))))
file_data[u"size"] = int(
unicode(next(file_elt.elements(NS_JINGLE_FT, u"size")))
)
except StopIteration:
pass
try:
file_data[u'modified'] = date_utils.date_parse(next(file_elt.elements(NS_JINGLE_FT, u'date')))
file_data[u"modified"] = date_utils.date_parse(
next(file_elt.elements(NS_JINGLE_FT, u"date"))
)
except StopIteration:
pass
try:
range_elt = file_elt.elements(NS_JINGLE_FT, u'range').next()
range_elt = file_elt.elements(NS_JINGLE_FT, u"range").next()
except StopIteration:
pass
else:
offset = range_elt.getAttribute('offset')
length = range_elt.getAttribute('length')
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[u"transfer_range"] = Range(offset=offset, length=length)
prefix = u'given_' if given else u''
hash_algo_key, hash_key = u'hash_algo', prefix + u'file_hash'
prefix = u"given_" if given else u""
hash_algo_key, hash_key = u"hash_algo", prefix + u"file_hash"
try:
file_data[hash_algo_key], file_data[hash_key] = self._hash.parseHashElt(file_elt)
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(u"XEP-0234_parseFileElement", file_elt, file_data)
return file_data
# bridge methods
def _fileJingleSend(self, peer_jid, filepath, name="", file_desc="", extra=None, profile=C.PROF_KEY_NONE):
def _fileJingleSend(
self,
peer_jid,
filepath,
name="",
file_desc="",
extra=None,
profile=C.PROF_KEY_NONE,
):
client = self.host.getClient(profile)
return self.fileJingleSend(client, jid.JID(peer_jid), filepath, name or None, file_desc or None, extra or None)
return self.fileJingleSend(
client,
jid.JID(peer_jid),
filepath,
name or None,
file_desc or None,
extra or None,
)
@defer.inlineCallbacks
def fileJingleSend(self, client, peer_jid, filepath, name, file_desc=None, extra=None):
def fileJingleSend(
self, client, peer_jid, filepath, name, file_desc=None, extra=None
):
"""Send a file using jingle file transfer
@param peer_jid(jid.JID): destinee jid
@ -256,25 +326,58 @@ class XEP_0234(object):
if extra is None:
extra = {}
if file_desc is not None:
extra['file_desc'] = file_desc
yield self._j.initiate(client,
peer_jid,
[{'app_ns': NS_JINGLE_FT,
'senders': self._j.ROLE_INITIATOR,
'app_kwargs': {'filepath': filepath,
'name': name,
'extra': extra,
'progress_id_d': progress_id_d},
}])
extra["file_desc"] = file_desc
yield self._j.initiate(
client,
peer_jid,
[
{
"app_ns": NS_JINGLE_FT,
"senders": self._j.ROLE_INITIATOR,
"app_kwargs": {
"filepath": filepath,
"name": name,
"extra": extra,
"progress_id_d": progress_id_d,
},
}
],
)
progress_id = yield progress_id_d
defer.returnValue(progress_id)
def _fileJingleRequest(self, peer_jid, filepath, name="", file_hash="", hash_algo="", extra=None, profile=C.PROF_KEY_NONE):
def _fileJingleRequest(
self,
peer_jid,
filepath,
name="",
file_hash="",
hash_algo="",
extra=None,
profile=C.PROF_KEY_NONE,
):
client = self.host.getClient(profile)
return self.fileJingleRequest(client, jid.JID(peer_jid), filepath, name or None, file_hash or None, hash_algo or None, extra or None)
return self.fileJingleRequest(
client,
jid.JID(peer_jid),
filepath,
name or None,
file_hash or None,
hash_algo or None,
extra or None,
)
@defer.inlineCallbacks
def fileJingleRequest(self, client, peer_jid, filepath, name=None, file_hash=None, hash_algo=None, extra=None):
def fileJingleRequest(
self,
client,
peer_jid,
filepath,
name=None,
file_hash=None,
hash_algo=None,
extra=None,
):
"""Request a file using jingle file transfer
@param peer_jid(jid.JID): destinee jid
@ -289,122 +392,152 @@ class XEP_0234(object):
if file_hash is not None:
if hash_algo is None:
raise ValueError(_(u"hash_algo must be set if file_hash is set"))
extra['file_hash'] = file_hash
extra['hash_algo'] = hash_algo
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"))
yield self._j.initiate(client,
peer_jid,
[{'app_ns': NS_JINGLE_FT,
'senders': self._j.ROLE_RESPONDER,
'app_kwargs': {'filepath': filepath,
'name': name,
'extra': extra,
'progress_id_d': progress_id_d},
}])
yield self._j.initiate(
client,
peer_jid,
[
{
"app_ns": NS_JINGLE_FT,
"senders": self._j.ROLE_RESPONDER,
"app_kwargs": {
"filepath": filepath,
"name": name,
"extra": extra,
"progress_id_d": progress_id_d,
},
}
],
)
progress_id = yield progress_id_d
defer.returnValue(progress_id)
# jingle callbacks
def jingleSessionInit(self, client, session, content_name, filepath, name, extra, progress_id_d):
def jingleSessionInit(
self, client, session, content_name, filepath, name, extra, progress_id_d
):
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(
keys=u', '.join(EXTRA_ALLOWED)))
raise ValueError(
_(u"only the following keys are allowed in extra: {keys}").format(
keys=u", ".join(EXTRA_ALLOWED)
)
)
progress_id_d.callback(self.getProgressId(session, content_name))
content_data = session['contents'][content_name]
application_data = content_data['application_data']
assert 'file_path' not in application_data
application_data['file_path'] = filepath
file_data = application_data['file_data'] = {}
desc_elt = domish.Element((NS_JINGLE_FT, 'description'))
content_data = session["contents"][content_name]
application_data = content_data["application_data"]
assert "file_path" not in 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[u"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[u'desc'] = extra.pop(u'file_desc', u'')
file_data[u'name'] = name
file_data[u"date"] = utils.xmpp_date()
file_data[u"desc"] = extra.pop(u"file_desc", u"")
file_data[u"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[u'size'] = os.path.getsize(filepath)
if u'namespace' in extra:
file_data[u'namespace'] = extra[u'namespace']
if u'path' in extra:
file_data[u'path'] = extra[u'path']
self.buildFileElementFromDict(file_data, file_elt=file_elt, file_hash=u'')
file_data[u"mime_type"] = mime_type
file_data[u"size"] = os.path.getsize(filepath)
if u"namespace" in extra:
file_data[u"namespace"] = extra[u"namespace"]
if u"path" in extra:
file_data[u"path"] = extra[u"path"]
self.buildFileElementFromDict(file_data, file_elt=file_elt, file_hash=u"")
else:
# we request a file
file_hash = extra.pop(u'file_hash', u'')
file_hash = extra.pop(u"file_hash", u"")
if not name and not file_hash:
raise ValueError(_(u'you need to provide at least name or file hash'))
raise ValueError(_(u"you need to provide at least name or file hash"))
if name:
file_data[u'name'] = name
file_data[u"name"] = name
if file_hash:
file_data[u'file_hash'] = file_hash
file_data[u'hash_algo'] = extra[u'hash_algo']
file_data[u"file_hash"] = file_hash
file_data[u"hash_algo"] = extra[u"hash_algo"]
else:
file_data[u'hash_algo'] = self._hash.getDefaultAlgo()
if u'namespace' in extra:
file_data[u'namespace'] = extra[u'namespace']
if u'path' in extra:
file_data[u'path'] = extra[u'path']
file_data[u"hash_algo"] = self._hash.getDefaultAlgo()
if u"namespace" in extra:
file_data[u"namespace"] = extra[u"namespace"]
if u"path" in extra:
file_data[u"path"] = extra[u"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']
content_data = session["contents"][content_name]
senders = content_data[u"senders"]
if senders not in (self._j.ROLE_INITIATOR, self._j.ROLE_RESPONDER):
log.warning(u"Bad sender, assuming initiator")
senders = content_data[u'senders'] = self._j.ROLE_INITIATOR
senders = content_data[u"senders"] = self._j.ROLE_INITIATOR
# first we grab file informations
try:
file_elt = desc_elt.elements(NS_JINGLE_FT, 'file').next()
file_elt = desc_elt.elements(NS_JINGLE_FT, "file").next()
except StopIteration:
raise failure.Failure(exceptions.DataError)
file_data = {'progress_id': self.getProgressId(session, content_name)}
file_data = {"progress_id": self.getProgressId(session, content_name)}
if senders == self._j.ROLE_RESPONDER:
# we send the file
return self._fileSendingRequestConf(client, session, content_data, content_name, file_data, file_elt)
return self._fileSendingRequestConf(
client, session, content_data, content_name, file_data, file_elt
)
else:
# we receive the file
return self._fileReceivingRequestConf(client, session, content_data, content_name, file_data, file_elt)
return self._fileReceivingRequestConf(
client, session, content_data, content_name, file_data, file_elt
)
@defer.inlineCallbacks
def _fileSendingRequestConf(self, client, session, content_data, content_name, file_data, file_elt):
def _fileSendingRequestConf(
self, client, session, content_data, content_name, file_data, file_elt
):
"""parse file_elt, and handle file retrieving/permission checking"""
self.parseFileElement(file_elt, file_data)
content_data['application_data']['file_data'] = file_data
finished_d = content_data['finished_d'] = defer.Deferred()
content_data["application_data"]["file_data"] = file_data
finished_d = content_data["finished_d"] = defer.Deferred()
# confirmed_d is a deferred returning confimed value (only used if cont is False)
cont, confirmed_d = self.host.trigger.returnPoint("XEP-0234_fileSendingRequest", client, session, content_data, content_name, file_data, file_elt)
cont, confirmed_d = self.host.trigger.returnPoint(
"XEP-0234_fileSendingRequest",
client,
session,
content_data,
content_name,
file_data,
file_elt,
)
if not cont:
confirmed = yield confirmed_d
if confirmed:
args = [client, session, content_name, content_data]
finished_d.addCallbacks(self._finishedCb, self._finishedEb, args, None, args)
finished_d.addCallbacks(
self._finishedCb, self._finishedEb, args, None, args
)
defer.returnValue(confirmed)
log.warning(_(u'File continue is not implemented yet'))
log.warning(_(u"File continue is not implemented yet"))
defer.returnValue(False)
def _fileReceivingRequestConf(self, client, session, content_data, content_name, file_data, file_elt):
def _fileReceivingRequestConf(
self, client, session, content_data, content_name, file_data, file_elt
):
"""parse file_elt, and handle user permission/file opening"""
self.parseFileElement(file_elt, file_data, given=True)
try:
hash_algo, file_data['given_file_hash'] = self._hash.parseHashElt(file_elt)
hash_algo, file_data["given_file_hash"] = self._hash.parseHashElt(file_elt)
except exceptions.NotFound:
try:
hash_algo = self._hash.parseHashUsedElt(file_elt)
@ -412,88 +545,94 @@ class XEP_0234(object):
raise failure.Failure(exceptions.DataError)
if hash_algo is not None:
file_data['hash_algo'] = hash_algo
file_data['hash_hasher'] = hasher = self._hash.getHasher(hash_algo)
file_data['data_cb'] = lambda data: hasher.update(data)
file_data["hash_algo"] = hash_algo
file_data["hash_hasher"] = hasher = self._hash.getHasher(hash_algo)
file_data["data_cb"] = lambda data: hasher.update(data)
try:
file_data['size'] = int(file_data['size'])
file_data["size"] = int(file_data["size"])
except ValueError:
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_data['name'] = name.replace('/', '_').replace('\\', '_')
name = file_data["name"]
if "/" in name or "\\" in name:
log.warning(
u"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["application_data"]["file_data"] = file_data
# now we actualy request permission to user
def gotConfirmation(confirmed):
if confirmed:
args = [client, session, content_name, content_data]
finished_d.addCallbacks(self._finishedCb, self._finishedEb, args, None, args)
finished_d.addCallbacks(
self._finishedCb, self._finishedEb, args, None, args
)
return confirmed
# deferred to track end of transfer
finished_d = content_data['finished_d'] = defer.Deferred()
d = self._f.getDestDir(client, session['peer_jid'], content_data, file_data, stream_object=True)
finished_d = content_data["finished_d"] = defer.Deferred()
d = self._f.getDestDir(
client, session["peer_jid"], content_data, file_data, stream_object=True
)
d.addCallback(gotConfirmation)
return d
def jingleHandler(self, client, action, session, content_name, desc_elt):
content_data = session['contents'][content_name]
application_data = content_data['application_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 = desc_elt.elements(NS_JINGLE_FT, "file").next()
try:
file_elt.elements(NS_JINGLE_FT, 'range').next()
file_elt.elements(NS_JINGLE_FT, "range").next()
except StopIteration:
# initiator doesn't manage <range>, but we do so we advertise it
# FIXME: to be checked
#  FIXME: to be checked
log.debug("adding <range> element")
file_elt.addElement('range')
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']
if senders != session[u'role']:
assert not "stream_object" in content_data
file_data = application_data["file_data"]
file_path = application_data["file_path"]
senders = content_data[u"senders"]
if senders != session[u"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'))
size_elt = next(file_elt.elements(NS_JINGLE_FT, u'size'))
file_elt = next(desc_elt.elements(NS_JINGLE_FT, u"file"))
size_elt = next(file_elt.elements(NS_JINGLE_FT, u"size"))
size = int(unicode(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(
hasher = file_data["hash_hasher"] = self._hash.getHasher()
content_data["stream_object"] = stream.FileStreamObject(
self.host,
client,
file_path,
mode='wb',
mode="wb",
uid=self.getProgressId(session, content_name),
size=size,
data_cb=lambda data: hasher.update(data),
)
)
else:
# we are sending the file
size = file_data['size']
size = file_data["size"]
# 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(
hasher = file_data["hash_hasher"] = self._hash.getHasher()
content_data["stream_object"] = stream.FileStreamObject(
self.host,
client,
file_path,
uid=self.getProgressId(session, content_name),
size=size,
data_cb=lambda data: hasher.update(data),
)
finished_d = content_data['finished_d'] = defer.Deferred()
)
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:
@ -506,33 +645,42 @@ class XEP_0234(object):
manage checksum, and ignore <received/> element
"""
# TODO: manage <received/> element
content_data = session['contents'][content_name]
content_data = session["contents"][content_name]
elts = [elt for elt in jingle_elt.elements() if elt.uri == NS_JINGLE_FT]
if not elts:
return
for elt in elts:
if elt.name == 'received':
if elt.name == "received":
pass
elif elt.name == 'checksum':
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")
if content_data["senders"] == session["role"]:
log.warning(
u"unexpected checksum received while we are the file sender"
)
raise exceptions.DataError
info_content_name = elt['name']
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']
file_data = content_data["application_data"]["file_data"]
try:
file_elt = elt.elements((NS_JINGLE_FT, 'file')).next()
file_elt = elt.elements((NS_JINGLE_FT, "file")).next()
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(peer_algo=algo, our_algo=file_data.get('hash_algo'), profile=client.profile))
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(
peer_algo=algo,
our_algo=file_data.get("hash_algo"),
profile=client.profile,
)
)
else:
self._receiverTryTerminate(client, session, content_name, content_data)
self._receiverTryTerminate(
client, session, content_name, content_data
)
else:
raise NotImplementedError
@ -540,23 +688,27 @@ class XEP_0234(object):
if jingle_elt.decline:
# progress is the only way to tell to frontends that session has been declined
progress_id = self.getProgressId(session, content_name)
self.host.bridge.progressError(progress_id, C.PROGRESS_ERROR_DECLINED, client.profile)
self.host.bridge.progressError(
progress_id, C.PROGRESS_ERROR_DECLINED, 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']
file_data = content_data["application_data"]["file_data"]
hasher = file_data["hash_hasher"]
hash_ = hasher.hexdigest()
log.debug(u"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')
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_elt.addChild(self._hash.buildHashElt(hash_))
iq_elt.send()
def _receiverTryTerminate(self, client, session, content_name, content_data, last_try=False):
def _receiverTryTerminate(
self, client, session, content_name, content_data, last_try=False
):
"""Try to terminate the session
This method must only be used by the receiver.
@ -565,70 +717,85 @@ class XEP_0234(object):
@param last_try(bool): if True this mean than session must be terminated even given hash is not available
@return (bool): True if session was terminated
"""
if not content_data.get('transfer_finished', False):
if not content_data.get("transfer_finished", False):
return False
file_data = content_data['application_data']['file_data']
given_hash = file_data.get('given_file_hash')
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(profile=client.profile))
log.warning(
u"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()
content_data["stream_object"].close()
return True
return False
hasher = file_data['hash_hasher']
hasher = file_data["hash_hasher"]
hash_ = hasher.hexdigest()
if hash_ == given_hash:
log.info(u"Hash checked, file was successfully transfered: {}".format(hash_))
progress_metadata = {'hash': hash_,
'hash_algo': file_data['hash_algo'],
'hash_verified': C.BOOL_TRUE
}
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")
progress_metadata=None
progress_metadata = None
error = u"Hash mismatch: given={algo}:{given}, calculated={algo}:{our}".format(
algo = file_data['hash_algo'],
given = given_hash,
our = hash_)
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)
content_data["stream_object"].close(progress_metadata, error)
# we may have the last_try timer still active, so we try to cancel it
try:
content_data['last_try_timer'].cancel()
content_data["last_try_timer"].cancel()
except (KeyError, internet_error.AlreadyCalled):
pass
return True
def _finishedCb(self, dummy, client, session, content_name, content_data):
log.info(u"File transfer terminated")
if content_data['senders'] != session['role']:
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(client, session, content_name, content_data):
content_data["transfer_finished"] = True
if not self._receiverTryTerminate(
client, session, content_name, content_data
):
# we have not received the hash yet, we wait 5 more seconds
content_data['last_try_timer'] = reactor.callLater(
5, self._receiverTryTerminate, client, session, content_name, content_data, last_try=True)
content_data["last_try_timer"] = reactor.callLater(
5,
self._receiverTryTerminate,
client,
session,
content_name,
content_data,
last_try=True,
)
else:
# we are the sender, we send the checksum
self._sendCheckSum(client, session, content_name, content_data)
content_data['stream_object'].close()
content_data["stream_object"].close()
def _finishedEb(self, failure, client, session, content_name, content_data):
log.warning(u"Error while streaming file: {}".format(failure))
content_data['stream_object'].close()
self._j.contentTerminate(client, session, content_name, reason=self._j.REASON_FAILED_TRANSPORT)
content_data["stream_object"].close()
self._j.contentTerminate(
client, session, content_name, reason=self._j.REASON_FAILED_TRANSPORT
)
class XEP_0234_handler(XMPPHandler):
implements(iwokkel.IDisco)
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
return [disco.DiscoFeature(NS_JINGLE_FT)]
def getDiscoItems(self, requestor, target, nodeIdentifier=''):
def getDiscoItems(self, requestor, target, nodeIdentifier=""):
return []