libervia-backend: libervia/backend/plugins/plugin_xep

comparison libervia/backend/plugins/plugin_xep_0065.py @ 4270:0d7bb4df2343

Reformatted code base using black.

author	Goffi <goffi@goffi.org>
date	Wed, 19 Jun 2024 18:44:57 +0200
parents	b86912d3fd33
children

comparison

equal deleted inserted replaced

-:64a85ce8be70
+:0d7bb4df2343
 NS_BS = "http://jabber.org/protocol/bytestreams"
 BS_REQUEST = IQ_SET + '/query[@xmlns="' + NS_BS + '"]'
 TIMER_KEY = "timer"
 DEFER_KEY = "finished"  # key of the deferred used to track session end
 SERVER_STARTING_PORT = (
-0
+0  # starting number for server port search (0 to ask automatic attribution)
-)  # starting number for server port search (0 to ask automatic attribution)
+)
 # priorities are candidates local priorities, must be a int between 0 and 65535
 PRIORITY_BEST_DIRECT = 10000
 PRIORITY_DIRECT = 5000
 PRIORITY_ASSISTED = 1000
 ProxyInfos = namedtuple("ProxyInfos", ["host", "jid", "port"])
 class Candidate(object):
-def __init__(self, host, port, type_, priority, jid_, id_=None, priority_local=False,
+def __init__(
-factory=None,):
+self,
+host,
+port,
+type_,
+priority,
+jid_,
+id_=None,
+priority_local=False,
+factory=None,
+):
 """
 @param host(unicode): host IP or domain
 @param port(int): port
 @param type_(unicode): stream type (one of XEP_0065.TYPE_*)
 @param priority(int): priority
 multiplier = 110
 elif self.type == XEP_0065.TYPE_PROXY:
 multiplier = 10
 else:
 raise exceptions.InternalError("Unknown {} type !".format(self.type))
-return 2 ** 16 * multiplier + self._local_priority
+return 2**16 * multiplier + self._local_priority
 def activate(self, client, sid, peer_jid, local_jid):
 """Activate the proxy candidate
 Send activation request as explained in XEP-0065 § 6.3.5
 (sid + requester_jid.full() + target_jid.full()).encode("utf-8")
 ).hexdigest()
 class SOCKSv5(protocol.Protocol):
-CHUNK_SIZE = 2 ** 16
+CHUNK_SIZE = 2**16
 def __init__(self, session_hash=None):
 """
 @param session_hash(str): hash of the session
 must only be used in client mode
 def _parse_user_pass(self):
 try:
 # Parse out data
 ver, ulen = struct.unpack("BB", self.buf[:2])
-uname, = struct.unpack("%ds" % ulen, self.buf[2 : ulen + 2])
+(uname,) = struct.unpack("%ds" % ulen, self.buf[2 : ulen + 2])
-plen, = struct.unpack("B", self.buf[ulen + 2])
+(plen,) = struct.unpack("B", self.buf[ulen + 2])
-password, = struct.unpack("%ds" % plen, self.buf[ulen + 3 : ulen + 3 + plen])
+(password,) = struct.unpack(
+"%ds" % plen, self.buf[ulen + 3 : ulen + 3 + plen]
+)
 # Trim off fron of the buffer
 self.buf = self.buf[3 + ulen + plen :]
 # Fire event to authenticate user
 if self.authenticate_user_pass(uname, password):
 # Signal success
 except struct.error:
 # The buffer is probably not complete, we need to wait more
 return None
 def _make_request(self):
-hash_ = self._session_hash.encode('utf-8')
+hash_ = self._session_hash.encode("utf-8")
 request = struct.pack(
 "!5B%dsH" % len(hash_),
 SOCKS5_VER,
 CMD_CONNECT,
 0,
 if self.state == STATE_CLIENT_INITIAL:
 self._start_negotiation()
 def connect_requested(self, addr, port):
 # Check that this session is expected
-if not self.factory.add_to_session(addr.decode('utf-8'), self):
+if not self.factory.add_to_session(addr.decode("utf-8"), self):
 log.warning(
 "Unexpected connection request received from {host}".format(
 host=self.transport.getPeer().host
 )
 )
 self.send_error_reply(REPLY_CONN_REFUSED)
 return
-self._session_hash = addr.decode('utf-8')
+self._session_hash = addr.decode("utf-8")
 self.connect_completed(addr, 0)
 def start_transfer(self, chunk_size):
 """Callback called when the result iq is received
 def __init__(self, host):
 log.info(_("Plugin XEP_0065 initialization"))
 self.host = host
 # session data
-self.hash_clients_map = {}  # key: hash of the transfer session, value: session data
+self.hash_clients_map = (
+{}
+)  # key: hash of the transfer session, value: session data
 self._cache_proxies = {}  # key: server jid, value: proxy data
 # misc data
 self._server_factory = None
 self._external_port = None
 client.jid if a local part is used (e.g. piotr@file.example.net where
 client.jid would be file.example.net)
 @return (D(list[Candidate])): list of candidates, ordered by priority
 """
 server_factory = self.get_socks_5_server_factory()
-local_port, ext_port, local_ips, external_ip = await self._get_network_data(client)
+local_port, ext_port, local_ips, external_ip = await self._get_network_data(
+client
+)
 try:
 proxy = await self.get_proxy(client, local_jid)
 except exceptions.NotFound:
 proxy = None
 d.addErrback(connection_eb, client, candidate)
 defers_list.append(d)
 return defers_list
-def get_best_candidate(self, client, candidates, session_hash, peer_session_hash=None):
+def get_best_candidate(
+self, client, candidates, session_hash, peer_session_hash=None
+):
 """Get best candidate (according to priority) which can connect
 @param candidates(iterable[Candidate]): candidates to test
 @param session_hash(unicode): hash of the session
 hash is the same as hostname computed in XEP-0065 § 5.3.2 #1
 @param successCb: method to call when stream successfuly finished
 @param failureCb: method to call when something goes wrong
 @return (D): Deferred fired when session is finished
 """
 session_data = self._create_session(
-client, stream_object, local_jid, to_jid, sid, True)
+client, stream_object, local_jid, to_jid, sid, True
+)
 session_data[client] = client
 def got_candidates(candidates):
 session_data["candidates"] = candidates
 streamhost["jid"] = candidate.jid.full()
 log.debug("Candidate proposed: {}".format(candidate))
 d = iq_elt.send()
 args = [client, session_data, local_jid]
-d.addCallbacks(self._iq_negotiation_cb, self._iq_negotiation_eb, args, None, args)
+d.addCallbacks(
+self._iq_negotiation_cb, self._iq_negotiation_eb, args, None, args
-defer.ensureDeferred(self.get_candidates(client, local_jid)).addCallback(got_candidates)
+)
+defer.ensureDeferred(self.get_candidates(client, local_jid)).addCallback(
+got_candidates
+)
 return session_data[DEFER_KEY]
 def _iq_negotiation_cb(self, iq_elt, client, session_data, local_jid):
 """Called when the result of open iq is received
 # FIXME: must clean session
 return
 streamhost_jid = jid.JID(streamhost_used_elt["jid"])
 try:
-candidate = next((
+candidate = next(
-c for c in session_data["candidates"] if c.jid == streamhost_jid
+(c for c in session_data["candidates"] if c.jid == streamhost_jid)
-))
+)
 except StopIteration:
 log.warning(
 "Candidate [{jid}] is unknown !".format(jid=streamhost_jid.full())
 )
 return
 session deferred is fired when transfer is finished
 """
 return self._create_session(*args, **kwargs)[DEFER_KEY]
-def _create_session(self, client, stream_object, local_jid, to_jid, sid,
+def _create_session(
-requester=False):
+self, client, stream_object, local_jid, to_jid, sid, requester=False
+):
 """Called when a bytestream is imminent
 @param stream_object(iface.IStreamProducer): File object where data will be
 written
 @param to_jid(jid.JId): jid of the other peer

Mercurial > libervia-backend

comparison libervia/backend/plugins/plugin_xep_0065.py @ 4270:0d7bb4df2343