libervia-backend: sat/plugins/plugin_sec

comparison sat/plugins/plugin_sec_otr.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	967a8e109cda
children	c23cad65ae99

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 @property
 def _p_carbons(self):
 return self.context_manager.parent._p_carbons
-def getPolicy(self, key):
+def get_policy(self, key):
 if key in DEFAULT_POLICY_FLAGS:
 return DEFAULT_POLICY_FLAGS[key]
 else:
 return False
 "subject": {},
 "type": "chat",
 "extra": {},
 "timestamp": time.time(),
 }
-client.generateMessageXML(mess_data)
+client.generate_message_xml(mess_data)
 xml = mess_data['xml']
-self._p_carbons.setPrivate(xml)
+self._p_carbons.set_private(xml)
-self._p_hints.addHintElements(xml, [
+self._p_hints.add_hint_elements(xml, [
 self._p_hints.HINT_NO_COPY,
 self._p_hints.HINT_NO_PERMANENT_STORE])
 client.send(mess_data["xml"])
 else:
 message_elt = appdata["xml"]
 assert message_elt.name == "message"
 message_elt.addElement("body", content=msg)
-def stopCb(self, __, feedback):
+def stop_cb(self, __, feedback):
 client = self.user.client
-self.host.bridge.otrState(
+self.host.bridge.otr_state(
 OTR_STATE_UNENCRYPTED, self.peer.full(), client.profile
 )
 client.feedback(self.peer, feedback)
-def stopEb(self, failure_):
+def stop_eb(self, failure_):
 # encryption may be already stopped in case of manual stop
 if not failure_.check(exceptions.NotFound):
 log.error("Error while stopping OTR encryption: {msg}".format(msg=failure_))
-def isTrusted(self):
+def is_trusted(self):
 # we have to check value because potr code says that a 2-tuples should be
 # returned while in practice it's either None or u"trusted"
 trusted = self.getCurrentTrust()
 if trusted is None:
 return False
 else:
 log.error("Unexpected getCurrentTrust() value: {value}".format(
 value=trusted))
 return False
-def setState(self, state):
+def set_state(self, state):
 client = self.user.client
 old_state = self.state
-super(Context, self).setState(state)
+super(Context, self).set_state(state)
-log.debug("setState: %s (old_state=%s)" % (state, old_state))
+log.debug("set_state: %s (old_state=%s)" % (state, old_state))
 if state == potr.context.STATE_PLAINTEXT:
 feedback = _("/!\\ conversation with %(other_jid)s is now UNENCRYPTED") % {
 "other_jid": self.peer.full()
 }
 d = defer.ensureDeferred(client.encryption.stop(self.peer, NS_OTR))
-d.addCallback(self.stopCb, feedback=feedback)
+d.addCallback(self.stop_cb, feedback=feedback)
-d.addErrback(self.stopEb)
+d.addErrback(self.stop_eb)
 return
 elif state == potr.context.STATE_ENCRYPTED:
 defer.ensureDeferred(client.encryption.start(self.peer, NS_OTR))
 try:
-trusted = self.isTrusted()
+trusted = self.is_trusted()
 except TypeError:
 trusted = False
 trusted_str = _("trusted") if trusted else _("untrusted")
 if old_state == potr.context.STATE_ENCRYPTED:
 ).format(
 trusted=trusted_str,
 other_jid=self.peer.full(),
 extra_info=NO_ADV_FEATURES,
 )
-self.host.bridge.otrState(
+self.host.bridge.otr_state(
 OTR_STATE_ENCRYPTED, self.peer.full(), client.profile
 )
 elif state == potr.context.STATE_FINISHED:
 feedback = D_("OTR conversation with {other_jid} is FINISHED").format(
 other_jid=self.peer.full()
 )
 d = defer.ensureDeferred(client.encryption.stop(self.peer, NS_OTR))
-d.addCallback(self.stopCb, feedback=feedback)
+d.addCallback(self.stop_cb, feedback=feedback)
-d.addErrback(self.stopEb)
+d.addErrback(self.stop_eb)
 return
 else:
 log.error(D_("Unknown OTR state"))
 return
 log.warning("Account created without resource")
 super(Account, self).__init__(str(client.jid), "xmpp", 1024)
 self.host = host
 self.client = client
-def loadPrivkey(self):
+def load_privkey(self):
-log.debug("loadPrivkey")
+log.debug("load_privkey")
 return self.privkey
-def savePrivkey(self):
+def save_privkey(self):
-log.debug("savePrivkey")
+log.debug("save_privkey")
 if self.privkey is None:
 raise exceptions.InternalError(_("Save is called but privkey is None !"))
 priv_key = hexlify(self.privkey.serializePrivateKey())
-encrypted_priv_key = self.host.memory.encryptValue(priv_key, self.client.profile)
+encrypted_priv_key = self.host.memory.encrypt_value(priv_key, self.client.profile)
 self.client._otr_data[PRIVATE_KEY] = encrypted_priv_key
-def loadTrusts(self):
+def load_trusts(self):
 trust_data = self.client._otr_data.get("trust", {})
 for jid_, jid_data in trust_data.items():
 for fingerprint, trust_level in jid_data.items():
 log.debug(
 'setting trust for {jid}: [{fingerprint}] = "{trust_level}"'.format(
 jid=jid_, fingerprint=fingerprint, trust_level=trust_level
 )
 )
 self.trusts.setdefault(jid.JID(jid_), {})[fingerprint] = trust_level
-def saveTrusts(self):
+def save_trusts(self):
 log.debug("saving trusts for {profile}".format(profile=self.client.profile))
 log.debug("trusts = {}".format(self.client._otr_data["trust"]))
 self.client._otr_data.force("trust")
-def setTrust(self, other_jid, fingerprint, trustLevel):
+def set_trust(self, other_jid, fingerprint, trustLevel):
 try:
 trust_data = self.client._otr_data["trust"]
 except KeyError:
 trust_data = {}
 self.client._otr_data["trust"] = trust_data
 jid_data = trust_data.setdefault(other_jid.full(), {})
 jid_data[fingerprint] = trustLevel
-super(Account, self).setTrust(other_jid, fingerprint, trustLevel)
+super(Account, self).set_trust(other_jid, fingerprint, trustLevel)
 class ContextManager(object):
 def __init__(self, parent, client):
 self.parent = parent
 @property
 def host(self):
 return self.parent.host
-def startContext(self, other_jid):
+def start_context(self, other_jid):
 assert isinstance(other_jid, jid.JID)
 context = self.contexts.setdefault(
 other_jid, Context(self, other_jid)
 )
 return context
-def getContextForUser(self, other):
+def get_context_for_user(self, other):
-log.debug("getContextForUser [%s]" % other)
+log.debug("get_context_for_user [%s]" % other)
 if not other.resource:
-log.warning("getContextForUser called with a bare jid: %s" % other.full())
+log.warning("get_context_for_user called with a bare jid: %s" % other.full())
-return self.startContext(other)
+return self.start_context(other)
 class OTR(object):
 def __init__(self, host):
 self.skipped_profiles = (
 set()
 )  #  FIXME: OTR should not be skipped per profile, this need to be refactored
 self._p_hints = host.plugins["XEP-0334"]
 self._p_carbons = host.plugins["XEP-0280"]
-host.trigger.add("messageReceived", self.messageReceivedTrigger, priority=100000)
+host.trigger.add("messageReceived", self.message_received_trigger, priority=100000)
-host.trigger.add("sendMessage", self.sendMessageTrigger, priority=100000)
+host.trigger.add("sendMessage", self.send_message_trigger, priority=100000)
-host.trigger.add("sendMessageData", self._sendMessageDataTrigger)
+host.trigger.add("send_message_data", self._send_message_data_trigger)
-host.bridge.addMethod(
+host.bridge.add_method(
-"skipOTR", ".plugin", in_sign="s", out_sign="", method=self._skipOTR
+"skip_otr", ".plugin", in_sign="s", out_sign="", method=self._skip_otr
 )  # FIXME: must be removed, must be done on per-message basis
-host.bridge.addSignal(
+host.bridge.add_signal(
-"otrState", ".plugin", signature="sss"
+"otr_state", ".plugin", signature="sss"
 )  # args: state, destinee_jid, profile
 # XXX: menus are disabled in favor to the new more generic encryption menu
 #      there are let here commented for a little while as a reference
-# host.importMenu(
+# host.import_menu(
 #     (OTR_MENU, D_(u"Start/Refresh")),
-#     self._otrStartRefresh,
+#     self._otr_start_refresh,
 #     security_limit=0,
 #     help_string=D_(u"Start or refresh an OTR session"),
 #     type_=C.MENU_SINGLE,
 # )
-# host.importMenu(
+# host.import_menu(
 #     (OTR_MENU, D_(u"End session")),
-#     self._otrSessionEnd,
+#     self._otr_session_end,
 #     security_limit=0,
 #     help_string=D_(u"Finish an OTR session"),
 #     type_=C.MENU_SINGLE,
 # )
-# host.importMenu(
+# host.import_menu(
 #     (OTR_MENU, D_(u"Authenticate")),
-#     self._otrAuthenticate,
+#     self._otr_authenticate,
 #     security_limit=0,
 #     help_string=D_(u"Authenticate user/see your fingerprint"),
 #     type_=C.MENU_SINGLE,
 # )
-# host.importMenu(
+# host.import_menu(
 #     (OTR_MENU, D_(u"Drop private key")),
-#     self._dropPrivKey,
+#     self._drop_priv_key,
 #     security_limit=0,
 #     type_=C.MENU_SINGLE,
 # )
-host.trigger.add("presence_received", self._presenceReceivedTrigger)
+host.trigger.add("presence_received", self._presence_received_trigger)
-self.host.registerEncryptionPlugin(self, "OTR", NS_OTR, directed=True)
+self.host.register_encryption_plugin(self, "OTR", NS_OTR, directed=True)
-def _skipOTR(self, profile):
+def _skip_otr(self, profile):
 """Tell the backend to not handle OTR for this profile.
 @param profile (str): %(doc_profile)s
 """
 # FIXME: should not be done per profile but per message, using extra data
 #        for message received, profile wide hook may be need, but client
 #        should be used anyway instead of a class attribute
 self.skipped_profiles.add(profile)
 @defer.inlineCallbacks
-def profileConnecting(self, client):
+def profile_connecting(self, client):
 if client.profile in self.skipped_profiles:
 return
 ctxMng = client._otr_context_manager = ContextManager(self, client)
 client._otr_data = persistent.PersistentBinaryDict(NS_OTR, client.profile)
 yield client._otr_data.load()
 encrypted_priv_key = client._otr_data.get(PRIVATE_KEY, None)
 if encrypted_priv_key is not None:
-priv_key = self.host.memory.decryptValue(
+priv_key = self.host.memory.decrypt_value(
 encrypted_priv_key, client.profile
 )
 ctxMng.account.privkey = potr.crypt.PK.parsePrivateKey(
 unhexlify(priv_key.encode('utf-8'))
 )[0]
 else:
 ctxMng.account.privkey = None
-ctxMng.account.loadTrusts()
+ctxMng.account.load_trusts()
-def profileDisconnected(self, client):
+def profile_disconnected(self, client):
 if client.profile in self.skipped_profiles:
 self.skipped_profiles.remove(client.profile)
 return
 for context in list(client._otr_context_manager.contexts.values()):
 context.disconnect()
 del client._otr_context_manager
 # encryption plugin methods
-def startEncryption(self, client, entity_jid):
+def start_encryption(self, client, entity_jid):
-self.startRefresh(client, entity_jid)
+self.start_refresh(client, entity_jid)
-def stopEncryption(self, client, entity_jid):
+def stop_encryption(self, client, entity_jid):
-self.endSession(client, entity_jid)
+self.end_session(client, entity_jid)
-def getTrustUI(self, client, entity_jid):
+def get_trust_ui(self, client, entity_jid):
 if not entity_jid.resource:
-entity_jid.resource = self.host.memory.getMainResource(
+entity_jid.resource = self.host.memory.main_resource_get(
 client, entity_jid
 )  # FIXME: temporary and unsecure, must be changed when frontends
 #        are refactored
 ctxMng = client._otr_context_manager
-otrctx = ctxMng.getContextForUser(entity_jid)
+otrctx = ctxMng.get_context_for_user(entity_jid)
 priv_key = ctxMng.account.privkey
 if priv_key is None:
 # we have no private key yet
 dialog = xml_tools.XMLUI(
 },
 title=_("Fingerprint"),
 )
 return dialog
-def setTrust(raw_data, profile):
+def set_trust(raw_data, profile):
-if xml_tools.isXMLUICancelled(raw_data):
+if xml_tools.is_xmlui_cancelled(raw_data):
 return {}
 # This method is called when authentication form is submited
-data = xml_tools.XMLUIResult2DataFormResult(raw_data)
+data = xml_tools.xmlui_result_2_data_form_result(raw_data)
 if data["match"] == "yes":
 otrctx.setCurrentTrust(OTR_STATE_TRUSTED)
 note_msg = _("Your correspondent {correspondent} is now TRUSTED")
-self.host.bridge.otrState(
+self.host.bridge.otr_state(
 OTR_STATE_TRUSTED, entity_jid.full(), client.profile
 )
 else:
 otrctx.setCurrentTrust("")
 note_msg = _("Your correspondent {correspondent} is now UNTRUSTED")
-self.host.bridge.otrState(
+self.host.bridge.otr_state(
 OTR_STATE_UNTRUSTED, entity_jid.full(), client.profile
 )
 note = xml_tools.XMLUI(
 C.XMLUI_DIALOG,
 dialog_opt={
 C.XMLUI_DATA_MESS: note_msg.format(correspondent=otrctx.peer),
 },
 )
 return {"xmlui": note.toXml()}
-submit_id = self.host.registerCallback(setTrust, with_data=True, one_shot=True)
+submit_id = self.host.register_callback(set_trust, with_data=True, one_shot=True)
-trusted = otrctx.isTrusted()
+trusted = otrctx.is_trusted()
 xmlui = xml_tools.XMLUI(
 C.XMLUI_FORM,
 title=_("Authentication ({entity_jid})").format(entity_jid=entity_jid.full()),
 submit_id=submit_id,
 D_("Your correspondent fingerprint should be:\n{fingerprint}").format(
 fingerprint=other_fingerprint
 )
 )
 xmlui.addDivider("blank")
-xmlui.changeContainer("pairs")
+xmlui.change_container("pairs")
 xmlui.addLabel(D_("Is your correspondent fingerprint the same as here ?"))
 xmlui.addList(
 "match", [("yes", _("yes")), ("no", _("no"))], ["yes" if trusted else "no"]
 )
 return xmlui
-def _otrStartRefresh(self, menu_data, profile):
+def _otr_start_refresh(self, menu_data, profile):
 """Start or refresh an OTR session
 @param menu_data: %(menu_data)s
 @param profile: %(doc_profile)s
 """
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 try:
 to_jid = jid.JID(menu_data["jid"])
 except KeyError:
 log.error(_("jid key is not present !"))
 return defer.fail(exceptions.DataError)
-self.startRefresh(client, to_jid)
+self.start_refresh(client, to_jid)
 return {}
-def startRefresh(self, client, to_jid):
+def start_refresh(self, client, to_jid):
 """Start or refresh an OTR session
 @param to_jid(jid.JID): jid to start encrypted session with
 """
 encrypted_session = client.encryption.getSession(to_jid.userhostJID())
 if encrypted_session and encrypted_session['plugin'].namespace != NS_OTR:
 raise exceptions.ConflictError(_(
 "Can't start an OTR session, there is already an encrypted session "
 "with {name}").format(name=encrypted_session['plugin'].name))
 if not to_jid.resource:
-to_jid.resource = self.host.memory.getMainResource(
+to_jid.resource = self.host.memory.main_resource_get(
 client, to_jid
 )  # FIXME: temporary and unsecure, must be changed when frontends
 #        are refactored
-otrctx = client._otr_context_manager.getContextForUser(to_jid)
+otrctx = client._otr_context_manager.get_context_for_user(to_jid)
 query = otrctx.sendMessage(0, b"?OTRv?")
 otrctx.inject(query)
-def _otrSessionEnd(self, menu_data, profile):
+def _otr_session_end(self, menu_data, profile):
 """End an OTR session
 @param menu_data: %(menu_data)s
 @param profile: %(doc_profile)s
 """
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 try:
 to_jid = jid.JID(menu_data["jid"])
 except KeyError:
 log.error(_("jid key is not present !"))
 return defer.fail(exceptions.DataError)
-self.endSession(client, to_jid)
+self.end_session(client, to_jid)
 return {}
-def endSession(self, client, to_jid):
+def end_session(self, client, to_jid):
 """End an OTR session"""
 if not to_jid.resource:
-to_jid.resource = self.host.memory.getMainResource(
+to_jid.resource = self.host.memory.main_resource_get(
 client, to_jid
 )  # FIXME: temporary and unsecure, must be changed when frontends
 #        are refactored
-otrctx = client._otr_context_manager.getContextForUser(to_jid)
+otrctx = client._otr_context_manager.get_context_for_user(to_jid)
 otrctx.disconnect()
 return {}
-def _otrAuthenticate(self, menu_data, profile):
+def _otr_authenticate(self, menu_data, profile):
 """End an OTR session
 @param menu_data: %(menu_data)s
 @param profile: %(doc_profile)s
 """
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 try:
 to_jid = jid.JID(menu_data["jid"])
 except KeyError:
 log.error(_("jid key is not present !"))
 return defer.fail(exceptions.DataError)
 return self.authenticate(client, to_jid)
 def authenticate(self, client, to_jid):
 """Authenticate other user and see our own fingerprint"""
-xmlui = self.getTrustUI(client, to_jid)
+xmlui = self.get_trust_ui(client, to_jid)
 return {"xmlui": xmlui.toXml()}
-def _dropPrivKey(self, menu_data, profile):
+def _drop_priv_key(self, menu_data, profile):
 """Drop our private Key
 @param menu_data: %(menu_data)s
 @param profile: %(doc_profile)s
 """
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 try:
 to_jid = jid.JID(menu_data["jid"])
 if not to_jid.resource:
-to_jid.resource = self.host.memory.getMainResource(
+to_jid.resource = self.host.memory.main_resource_get(
 client, to_jid
 )  # FIXME: temporary and unsecure, must be changed when frontends
 #        are refactored
 except KeyError:
 log.error(_("jid key is not present !"))
 if ctxMng.account.privkey is None:
 return {
 "xmlui": xml_tools.note(_("You don't have a private key yet !")).toXml()
 }
-def dropKey(data, profile):
+def drop_key(data, profile):
 if C.bool(data["answer"]):
 # we end all sessions
 for context in list(ctxMng.contexts.values()):
 context.disconnect()
 ctxMng.account.privkey = None
 D_("Your private key has been dropped")
 ).toXml()
 }
 return {}
-submit_id = self.host.registerCallback(dropKey, with_data=True, one_shot=True)
+submit_id = self.host.register_callback(drop_key, with_data=True, one_shot=True)
 confirm = xml_tools.XMLUI(
 C.XMLUI_DIALOG,
 title=_("Confirm private key drop"),
 dialog_opt={"type": C.XMLUI_DIALOG_CONFIRM, "message": _(DROP_TXT)},
 submit_id=submit_id,
 )
 return {"xmlui": confirm.toXml()}
-def _receivedTreatment(self, data, client):
+def _received_treatment(self, data, client):
 from_jid = data["from"]
-log.debug("_receivedTreatment [from_jid = %s]" % from_jid)
+log.debug("_received_treatment [from_jid = %s]" % from_jid)
-otrctx = client._otr_context_manager.getContextForUser(from_jid)
+otrctx = client._otr_context_manager.get_context_for_user(from_jid)
 try:
 message = (
 next(iter(data["message"].values()))
 )  # FIXME: Q&D fix for message refactoring, message is now a dict
 else:
 raise failure.Failure(
 exceptions.CancelError("Cancelled by OTR")
 )  # no message at all (no history, no signal)
-client.encryption.markAsEncrypted(data, namespace=NS_OTR)
+client.encryption.mark_as_encrypted(data, namespace=NS_OTR)
-trusted = otrctx.isTrusted()
+trusted = otrctx.is_trusted()
 if trusted:
-client.encryption.markAsTrusted(data)
+client.encryption.mark_as_trusted(data)
 else:
-client.encryption.markAsUntrusted(data)
+client.encryption.mark_as_untrusted(data)
 return data
-def _receivedTreatmentForSkippedProfiles(self, data):
+def _received_treatment_for_skipped_profiles(self, data):
 """This profile must be skipped because the frontend manages OTR itself,
 but we still need to check if the message must be stored in history or not
 """
 #  XXX: FIXME: this should not be done on a per-profile basis, but  per-message
 #        if they are used at the same time as Libervia.
 #        Hard to avoid with decryption on Libervia though.
 data["history"] = C.HISTORY_SKIP
 return data
-def messageReceivedTrigger(self, client, message_elt, post_treat):
+def message_received_trigger(self, client, message_elt, post_treat):
 if client.is_component:
 return True
 if message_elt.getAttribute("type") == C.MESS_TYPE_GROUPCHAT:
 # OTR is not possible in group chats
 return True
 from_jid = jid.JID(message_elt['from'])
 if not from_jid.resource or from_jid.userhostJID() == client.jid.userhostJID():
 # OTR is only usable when resources are present
 return True
 if client.profile in self.skipped_profiles:
-post_treat.addCallback(self._receivedTreatmentForSkippedProfiles)
+post_treat.addCallback(self._received_treatment_for_skipped_profiles)
 else:
-post_treat.addCallback(self._receivedTreatment, client)
+post_treat.addCallback(self._received_treatment, client)
 return True
-def _sendMessageDataTrigger(self, client, mess_data):
+def _send_message_data_trigger(self, client, mess_data):
 if client.is_component:
 return True
 encryption = mess_data.get(C.MESS_KEY_ENCRYPTION)
 if encryption is None or encryption['plugin'].namespace != NS_OTR:
 return
 to_jid = mess_data['to']
 if not to_jid.resource:
-to_jid.resource = self.host.memory.getMainResource(
+to_jid.resource = self.host.memory.main_resource_get(
 client, to_jid
 )  # FIXME: temporary and unsecure, must be changed when frontends
-otrctx = client._otr_context_manager.getContextForUser(to_jid)
+otrctx = client._otr_context_manager.get_context_for_user(to_jid)
 message_elt = mess_data["xml"]
 if otrctx.state == potr.context.STATE_ENCRYPTED:
 log.debug("encrypting message")
 body = None
 for child in list(message_elt.children):
 # we don't want any XHTML-IM element
 message_elt.children.remove(child)
 if body is None:
 log.warning("No message found")
 else:
-self._p_carbons.setPrivate(message_elt)
+self._p_carbons.set_private(message_elt)
-self._p_hints.addHintElements(message_elt, [
+self._p_hints.add_hint_elements(message_elt, [
 self._p_hints.HINT_NO_COPY,
 self._p_hints.HINT_NO_PERMANENT_STORE])
 otrctx.sendMessage(0, str(body).encode("utf-8"), appdata=mess_data)
 else:
 feedback = D_(
 )
 log.warning(_("Message discarded because closed encryption channel"))
 client.feedback(to_jid, feedback)
 raise failure.Failure(exceptions.CancelError("Cancelled by OTR plugin"))
-def sendMessageTrigger(self, client, mess_data, pre_xml_treatments,
+def send_message_trigger(self, client, mess_data, pre_xml_treatments,
 post_xml_treatments):
 if client.is_component:
 return True
 if mess_data["type"] == "groupchat":
 return True
 if client.encryption.getSession(to_jid.userhostJID()):
 # there is already an encrypted session with this entity
 return True
 if not to_jid.resource:
-to_jid.resource = self.host.memory.getMainResource(
+to_jid.resource = self.host.memory.main_resource_get(
 client, to_jid
 )  # FIXME: full jid may not be known
-otrctx = client._otr_context_manager.getContextForUser(to_jid)
+otrctx = client._otr_context_manager.get_context_for_user(to_jid)
 if otrctx.state != potr.context.STATE_PLAINTEXT:
 defer.ensureDeferred(client.encryption.start(to_jid, NS_OTR))
-client.encryption.setEncryptionFlag(mess_data)
+client.encryption.set_encryption_flag(mess_data)
 if not mess_data["to"].resource:
 # if not resource was given, we force it here
 mess_data["to"] = to_jid
 return True
-def _presenceReceivedTrigger(self, client, entity, show, priority, statuses):
+def _presence_received_trigger(self, client, entity, show, priority, statuses):
 if show != C.PRESENCE_UNAVAILABLE:
 return True
 if not entity.resource:
 try:
-entity.resource = self.host.memory.getMainResource(
+entity.resource = self.host.memory.main_resource_get(
 client, entity
 )  # FIXME: temporary and unsecure, must be changed when frontends
 #        are refactored
 except exceptions.UnknownEntityError:
 return True  #  entity was not connected
 if entity in client._otr_context_manager.contexts:
-otrctx = client._otr_context_manager.getContextForUser(entity)
+otrctx = client._otr_context_manager.get_context_for_user(entity)
 otrctx.disconnect()
 return True

Mercurial > libervia-backend

comparison sat/plugins/plugin_sec_otr.py @ 4037:524856bd7b19