# This file is part of Gajim. # # Gajim is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published # by the Free Software Foundation; version 3 only. # # Gajim is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Gajim. If not, see . import logging import nbxmpp from nbxmpp.client import Client as NBXMPPClient from nbxmpp.const import StreamError from nbxmpp.const import ConnectionType from gi.repository import GLib from gajim.common import passwords from gajim.common.nec import NetworkEvent from gajim.common import app from gajim.common import helpers from gajim.common import modules from gajim.common.const import ClientState from gajim.common.helpers import get_custom_host from gajim.common.helpers import get_user_proxy from gajim.common.helpers import warn_about_plain_connection from gajim.common.helpers import get_resource from gajim.common.helpers import get_idle_status_message from gajim.common.idle import Monitor from gajim.common.i18n import _ from gajim.common.connection_handlers import ConnectionHandlers from gajim.common.connection_handlers_events import MessageSentEvent from gajim.gui.util import open_window log = logging.getLogger('gajim.client') class Client(ConnectionHandlers): def __init__(self, account): self._client = None self._account = account self.name = account self._hostname = app.settings.get_account_setting(self._account, 'hostname') self._user = app.settings.get_account_setting(self._account, 'name') self.password = None self._priority = 0 self._connect_machine_calls = 0 self.addressing_supported = False self.is_zeroconf = False self.pep = {} self.roster_supported = True self._state = ClientState.DISCONNECTED self._status_sync_on_resume = False self._status = 'online' self._status_message = '' self._idle_status = 'online' self._idle_status_enabled = True self._idle_status_message = '' self._reconnect = True self._reconnect_timer_source = None self._destroy_client = False self._remove_account = False self._destroyed = False self.available_transports = {} modules.register_modules(self) self._create_client() if Monitor.is_available(): self._idle_handler_id = Monitor.connect('state-changed', self._idle_state_changed) self._screensaver_handler_id = app.app.connect( 'notify::screensaver-active', self._screensaver_state_changed) ConnectionHandlers.__init__(self) def _set_state(self, state): log.info('State: %s', state) self._state = state @property def state(self): return self._state @property def account(self): return self._account @property def status(self): return self._status @property def status_message(self): if self._idle_status_active(): return self._idle_status_message return self._status_message @property def priority(self): return self._priority @property def certificate(self): return self._client.peer_certificate[0] @property def features(self): return self._client.features @property def local_address(self): address = self._client.local_address if address is not None: return address.to_string().split(':')[0] return None def set_remove_account(self, value): # Used by the RemoveAccount Assistant to make the Client # not react to any stream errors that happen while the # account is removed by the server and the connection is killed self._remove_account = value def _create_client(self): if self._destroyed: # If we disable an account cleanup() is called and all # modules are unregistered. Because disable_account() does not wait # for the client to properly disconnect, handlers of the # nbxmpp.Client() are emitted after we called cleanup(). # After nbxmpp.Client() disconnects and is destroyed we create a # new instance with this method but modules.get_handlers() fails # because modules are already unregistered. # TODO: Make this nicer return log.info('Create new nbxmpp client') self._client = NBXMPPClient(log_context=self._account) self.connection = self._client self._client.set_domain(self._hostname) self._client.set_username(self._user) self._client.set_resource(get_resource(self._account)) pass_saved = app.settings.get_account_setting(self._account, 'savepass') if pass_saved: # Request password from keyring only if the user chose to save # his password self.password = passwords.get_password(self._account) self._client.set_password(self.password) self._client.set_accepted_certificates( app.cert_store.get_certificates()) self._client.subscribe('resume-failed', self._on_resume_failed) self._client.subscribe('resume-successful', self._on_resume_successful) self._client.subscribe('disconnected', self._on_disconnected) self._client.subscribe('connection-failed', self._on_connection_failed) self._client.subscribe('connected', self._on_connected) self._client.subscribe('stanza-sent', self._on_stanza_sent) self._client.subscribe('stanza-received', self._on_stanza_received) for handler in modules.get_handlers(self): self._client.register_handler(handler) def _on_resume_failed(self, _client, _signal_name): log.info('Resume failed') app.nec.push_incoming_event(NetworkEvent( 'our-show', account=self._account, show='offline')) self.get_module('Chatstate').enabled = False def _on_resume_successful(self, _client, _signal_name): self._set_state(ClientState.CONNECTED) self._set_client_available() if self._status_sync_on_resume: self._status_sync_on_resume = False self.update_presence() else: # Normally show is updated when we receive a presence reflection. # On resume, if show has not changed while offline, we don’t send # a new presence so we have to trigger the event here. app.nec.push_incoming_event( NetworkEvent('our-show', account=self._account, show=self._status)) def _set_client_available(self): self._set_state(ClientState.AVAILABLE) app.nec.push_incoming_event(NetworkEvent('account-connected', account=self._account)) def disconnect(self, gracefully, reconnect, destroy_client=False): if self._state.is_disconnecting: log.warning('Disconnect already in progress') return self._set_state(ClientState.DISCONNECTING) self._reconnect = reconnect self._destroy_client = destroy_client log.info('Starting to disconnect %s', self._account) self._client.disconnect(immediate=not gracefully) def _on_disconnected(self, _client, _signal_name): log.info('Disconnect %s', self._account) self._set_state(ClientState.DISCONNECTED) domain, error, text = self._client.get_error() if self._remove_account: # Account was removed via RemoveAccount Assistant. self._reconnect = False elif domain == StreamError.BAD_CERTIFICATE: self._reconnect = False self._destroy_client = True cert, errors = self._client.peer_certificate open_window('SSLErrorDialog', account=self._account, client=self, cert=cert, error=errors.pop()) elif domain in (StreamError.STREAM, StreamError.BIND): if error == 'conflict': # Reset resource app.settings.set_account_setting(self._account, 'resource', 'gajim.$rand') elif domain == StreamError.SASL: self._reconnect = False self._destroy_client = True if error in ('not-authorized', 'no-password'): def _on_password(password): self.password = password self._client.set_password(password) self._prepare_for_connect() app.nec.push_incoming_event(NetworkEvent( 'password-required', conn=self, on_password=_on_password)) app.nec.push_incoming_event( NetworkEvent('simple-notification', account=self._account, type_='connection-failed', title=_('Authentication failed'), text=text or error)) if self._reconnect: self._after_disconnect() self._schedule_reconnect() app.nec.push_incoming_event( NetworkEvent('our-show', account=self._account, show='error')) else: self.get_module('Chatstate').enabled = False app.nec.push_incoming_event(NetworkEvent( 'our-show', account=self._account, show='offline')) self._after_disconnect() def _after_disconnect(self): self._disable_reconnect_timer() self.get_module('VCardAvatars').avatar_advertised = False app.proxy65_manager.disconnect(self._client) self.terminate_sessions() self.get_module('Bytestream').remove_all_transfers() if self._destroy_client: self._client.destroy() self._client = None self._destroy_client = False self._create_client() app.nec.push_incoming_event(NetworkEvent('account-disconnected', account=self._account)) def _on_connection_failed(self, _client, _signal_name): self._schedule_reconnect() def _on_connected(self, _client, _signal_name): self._set_state(ClientState.CONNECTED) self.get_module('MUC').get_manager().reset_state() self.get_module('Discovery').discover_server_info() self.get_module('Discovery').discover_account_info() self.get_module('Discovery').discover_server_items() self.get_module('Chatstate').enabled = True self.get_module('MAM').reset_state() def _on_stanza_sent(self, _client, _signal_name, stanza): app.nec.push_incoming_event(NetworkEvent('stanza-sent', account=self._account, stanza=stanza)) def _on_stanza_received(self, _client, _signal_name, stanza): app.nec.push_incoming_event(NetworkEvent('stanza-received', account=self._account, stanza=stanza)) def get_own_jid(self): """ Return the last full JID we received on a bind event. In case we were never connected it returns the bare JID from config. """ if self._client is not None: jid = self._client.get_bound_jid() if jid is not None: return jid # This returns the bare jid return nbxmpp.JID.from_string(app.get_jid_from_account(self._account)) def change_status(self, show, message): if not message: message = '' self._idle_status_enabled = show == 'online' self._status_message = message if show != 'offline': self._status = show if self._state.is_disconnecting: log.warning('Can\'t change status while ' 'disconnect is in progress') return if self._state.is_disconnected: if show == 'offline': return self._prepare_for_connect() return if self._state.is_connecting: if show == 'offline': self.disconnect(gracefully=False, reconnect=False, destroy_client=True) return if self._state.is_reconnect_scheduled: if show == 'offline': self._destroy_client = True self._abort_reconnect() else: self._prepare_for_connect() return # We are connected if show == 'offline': self.set_user_activity(None) self.set_user_mood(None) self.set_user_tune(None) self.set_user_location(None) presence = self.get_module('Presence').get_presence( typ='unavailable', status=message, caps=False) self.send_stanza(presence) self.disconnect(gracefully=True, reconnect=False, destroy_client=True) return self.update_presence() def update_presence(self, include_muc=True): status, message, idle = self.get_presence_state() self._priority = app.get_priority(self._account, status) self.get_module('Presence').send_presence( priority=self._priority, show=status, status=message, idle_time=idle) if include_muc: self.get_module('MUC').update_presence() def set_user_activity(self, activity): self.get_module('UserActivity').set_activity(activity) def set_user_mood(self, mood): self.get_module('UserMood').set_mood(mood) def set_user_tune(self, tune): self.get_module('UserTune').set_tune(tune) def set_user_location(self, location): self.get_module('UserLocation').set_location(location) def get_module(self, name): return modules.get(self._account, name) @helpers.call_counter def connect_machine(self): log.info('Connect machine state: %s', self._connect_machine_calls) if self._connect_machine_calls == 1: self.get_module('MetaContacts').get_metacontacts() elif self._connect_machine_calls == 2: self.get_module('Delimiter').get_roster_delimiter() elif self._connect_machine_calls == 3: self.get_module('Roster').request_roster() elif self._connect_machine_calls == 4: self._finish_connect() def _finish_connect(self): self._status_sync_on_resume = False self._set_client_available() # We did not resume the stream, so we are not joined any MUCs self.update_presence(include_muc=False) self.get_module('Bookmarks').request_bookmarks() self.get_module('SoftwareVersion').set_enabled(True) self.get_module('Annotations').request_annotations() self.get_module('Blocking').get_blocking_list() # Inform GUI we just signed in app.nec.push_incoming_event(NetworkEvent( 'signed-in', account=self._account, conn=self)) modules.send_stored_publish(self._account) def send_stanza(self, stanza): """ Send a stanza untouched """ return self._client.send_stanza(stanza) def send_message(self, message): if not self._state.is_available: log.warning('Trying to send message while offline') return stanza = self.get_module('Message').build_message_stanza(message) message.stanza = stanza if message.contact is None: # Only Single Message should have no contact self._send_message(message) return method = message.contact.settings.get('encryption') if not method: self._send_message(message) return # TODO: Make extension point return encrypted message extension = 'encrypt' if message.is_groupchat: extension = 'gc_encrypt' app.plugin_manager.extension_point(extension + method, self, message, self._send_message) def _send_message(self, message): message.set_sent_timestamp() message.message_id = self.send_stanza(message.stanza) app.nec.push_incoming_event( MessageSentEvent(None, jid=message.jid, **vars(message))) if message.is_groupchat: return self.get_module('Message').log_message(message) def send_messages(self, jids, message): if not self._state.is_available: log.warning('Trying to send message while offline') return for jid in jids: message = message.copy() message.contact = app.contacts.create_contact(jid, message.account) stanza = self.get_module('Message').build_message_stanza(message) message.stanza = stanza self._send_message(message) def _prepare_for_connect(self): custom_host = get_custom_host(self._account) if custom_host is not None: self._client.set_custom_host(*custom_host) gssapi = app.settings.get_account_setting(self._account, 'enable_gssapi') if gssapi: self._client.set_mechs(['GSSAPI']) anonymous = app.settings.get_account_setting(self._account, 'anonymous_auth') if anonymous: self._client.set_mechs(['ANONYMOUS']) if app.settings.get_account_setting(self._account, 'use_plain_connection'): self._client.set_connection_types([ConnectionType.PLAIN]) proxy = get_user_proxy(self._account) if proxy is not None: self._client.set_proxy(proxy) self.connect() def connect(self, ignored_tls_errors=None): if self._state not in (ClientState.DISCONNECTED, ClientState.RECONNECT_SCHEDULED): # Do not try to reco while we are already trying return log.info('Connect') self._client.set_ignored_tls_errors(ignored_tls_errors) self._reconnect = True self._disable_reconnect_timer() self._set_state(ClientState.CONNECTING) if warn_about_plain_connection(self._account, self._client.connection_types): app.nec.push_incoming_event(NetworkEvent( 'plain-connection', account=self._account, connect=self._client.connect, abort=self._abort_reconnect)) return self._client.connect() def _schedule_reconnect(self): self._set_state(ClientState.RECONNECT_SCHEDULED) log.info("Reconnect to %s in 3s", self._account) self._reconnect_timer_source = GLib.timeout_add_seconds( 3, self._prepare_for_connect) def _abort_reconnect(self): self._set_state(ClientState.DISCONNECTED) self._disable_reconnect_timer() app.nec.push_incoming_event( NetworkEvent('our-show', account=self._account, show='offline')) if self._destroy_client: self._client.destroy() self._client = None self._destroy_client = False self._create_client() def _disable_reconnect_timer(self): if self._reconnect_timer_source is not None: GLib.source_remove(self._reconnect_timer_source) self._reconnect_timer_source = None def _idle_state_changed(self, monitor): state = monitor.state.value if monitor.is_awake(): self._idle_status = state self._idle_status_message = '' self._update_status() return if not app.settings.get(f'auto{state}'): return if (state in ('away', 'xa') and self._status == 'online' or state == 'xa' and self._idle_status == 'away'): self._idle_status = state self._idle_status_message = get_idle_status_message( state, self._status_message) self._update_status() def _update_status(self): if not self._idle_status_enabled: return self._status = self._idle_status if self._state.is_available: self.update_presence() else: self._status_sync_on_resume = True def _idle_status_active(self): if not Monitor.is_available(): return False if not self._idle_status_enabled: return False return self._idle_status != 'online' def get_presence_state(self): if self._idle_status_active(): return self._idle_status, self._idle_status_message, True return self._status, self._status_message, False @staticmethod def _screensaver_state_changed(application, _param): active = application.get_property('screensaver-active') Monitor.set_extended_away(active) def cleanup(self): self._destroyed = True if Monitor.is_available(): Monitor.disconnect(self._idle_handler_id) app.app.disconnect(self._screensaver_handler_id) if self._client is not None: # cleanup() is called before nbmxpp.Client has disconnected, # when we disable the account. So we need to unregister # handlers here. # TODO: cleanup() should not be called before disconnect is finished for handler in modules.get_handlers(self): self._client.unregister_handler(handler) modules.unregister_modules(self) def quit(self, kill_core): if kill_core and self._state in (ClientState.CONNECTING, ClientState.CONNECTED, ClientState.AVAILABLE): self.disconnect(gracefully=True, reconnect=False)