handlers.py

"""
XMPP-related handlers for the Core class
"""

import logging
log = logging.getLogger(__name__)

from typing import Optional

import asyncio
import curses
import functools
import select
import ssl
import sys
import time
from datetime import datetime
from hashlib import sha1, sha256, sha512
from os import path

import pyasn1.codec.der.decoder
import pyasn1.codec.der.encoder
import pyasn1_modules.rfc2459
from slixmpp import InvalidJID, JID, Message
from slixmpp.xmlstream.stanzabase import StanzaBase, ElementBase
from xml.etree import ElementTree as ET

from poezio import common
from poezio import fixes
from poezio import pep
from poezio import tabs
from poezio import xhtml
from poezio import multiuserchat as muc
from poezio.common import safeJID
from poezio.config import config, get_image_cache
from poezio.core.structs import Status
from poezio.contact import Resource
from poezio.logger import logger
from poezio.roster import roster
from poezio.text_buffer import CorrectionError, AckError
from poezio.theming import dump_tuple, get_theme

from poezio.core.commands import dumb_callback

try:
    from pygments import highlight
    from pygments.lexers import get_lexer_by_name
    from pygments.formatters import HtmlFormatter
    LEXER = get_lexer_by_name('xml')
    FORMATTER = HtmlFormatter(noclasses=True)
    PYGMENTS = True
except ImportError:
    PYGMENTS = False

CERT_WARNING_TEXT = """
WARNING: CERTIFICATE FOR %s CHANGED

This can be part of a normal renewal process, but can also mean that \
an attacker is performing a man-in-the-middle attack on your connection.
When in doubt, check with your administrator using another channel.

SHA-256 of the old certificate (SPKI): %s

SHA-256 of the new certificate (SPKI): %s
"""

HTTP_VERIF_TEXT = """
Someone (maybe you) has requested an identity verification
using method "%s" for the url "%s".

The transaction id is: %s
And the XMPP address of the verification service is %s.

"""


class HandlerCore:
    def __init__(self, core):
        self.core = core

    def on_session_start_features(self, _):
        """
        Enable carbons & blocking on session start if wanted and possible
        """

        def callback(iq):
            if not iq:
                return
            features = iq['disco_info']['features']
            rostertab = self.core.tabs.by_name_and_class(
                'Roster', tabs.RosterInfoTab)
            rostertab.check_blocking(features)
            rostertab.check_saslexternal(features)
            self.core.check_blocking(features)
            if (config.get('enable_carbons')
                    and 'urn:xmpp:carbons:2' in features):
                self.core.xmpp.plugin['xep_0280'].enable()
            self.core.check_bookmark_storage(features)

        self.core.xmpp.plugin['xep_0030'].get_info(
            jid=self.core.xmpp.boundjid.domain, callback=callback)

    def find_identities(self, _):
        asyncio.ensure_future(
            self.core.xmpp['xep_0030'].get_info_from_domain(),
        )

    def is_known_muc_pm(self, message: Message, with_jid: JID) -> Optional[bool]:
        """
        Try to determine whether a given message is a MUC-PM, without a roundtrip. Returns None when it's not clear
        """

        # first, look for the x (XEP-0045 version 1.28)
        if message.xml.find('{http://jabber.org/protocol/muc#user}x') is not None:
            log.debug('MUC-PM from %s with <x>', with_jid)
            return True

        jid_bare = with_jid.bare

        # then, look whether we have a matching tab with barejid
        tab = self.core.tabs.by_jid(JID(jid_bare))
        if tab is not None:
            if isinstance(tab, tabs.MucTab):
                log.debug('MUC-PM from %s in known MucTab', with_jid)
                return True
            one_to_one = isinstance(tab, (
                tabs.ConversationTab,
                tabs.DynamicConversationTab,
            ))
            if one_to_one:
                return False

        # then, look whether we have a matching tab with fulljid
        if with_jid.resource:
            tab = self.core.tabs.by_jid(with_jid)
            if tab is not None:
                if isinstance(tab, tabs.PrivateTab):
                    log.debug('MUC-PM from %s in known PrivateTab', with_jid)
                    return True
                if isinstance(tab, tabs.StaticConversationTab):
                    return False

        # then, look in the roster
        if jid_bare in roster and roster[jid_bare].subscription != 'none':
            return False

        # then, check bookmarks
        for bm in self.core.bookmarks:
            if bm.jid.bare == jid_bare:
                log.debug('MUC-PM from %s in bookmarks', with_jid)
                return True

        return None

    def on_carbon_received(self, message):
        """
        Carbon <received/> received
        """

        def ignore_message(recv):
            log.debug('%s has category conference, ignoring carbon',
                      recv['from'].server)

        def receive_message(recv):
            recv['to'] = self.core.xmpp.boundjid.full
            if recv['receipt']:
                return self.on_receipt(recv)
            self.on_normal_message(recv)

        recv = message['carbon_received']
        is_muc_pm = self.is_known_muc_pm(recv, recv['from'])
        if is_muc_pm:
            log.debug('%s sent a MUC-PM, ignoring carbon', recv['from'])
            return
        if is_muc_pm is None:
            fixes.has_identity(
                self.core.xmpp,
                recv['from'].bare,
                identity='conference',
                on_true=functools.partial(ignore_message, recv),
                on_false=functools.partial(receive_message, recv))
            return
        else:
            receive_message(recv)

    def on_carbon_sent(self, message):
        """
        Carbon <sent/> received
        """

        def groupchat_private_message(sent):
            self.on_groupchat_private_message(sent, sent=True)

        def send_message(sent):
            sent['from'] = self.core.xmpp.boundjid.full
            self.on_normal_message(sent)

        sent = message['carbon_sent']
        is_muc_pm = self.is_known_muc_pm(sent, sent['to'])
        if is_muc_pm:
            groupchat_private_message(sent)
            return
        if is_muc_pm is None:
            fixes.has_identity(
                self.core.xmpp,
                sent['to'].server,
                identity='conference',
                on_true=functools.partial(groupchat_private_message, sent),
                on_false=functools.partial(send_message, sent))
        else:
            send_message(sent)

    ### Invites ###

    def on_groupchat_invitation(self, message):
        """
        Mediated invitation received
        """
        jid = message['from']
        if jid.bare in self.core.pending_invites:
            return
        # there are 2 'x' tags in the messages, making message['x'] useless
        invite = StanzaBase(
            self.core.xmpp,
            xml=message.xml.find(
                '{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}invite'
            ))
        # TODO: find out why pylint thinks "inviter" is a list
        #pylint: disable=no-member
        inviter = invite['from']
        reason = invite['reason']
        password = invite['password']
        msg = "You are invited to the room %s by %s" % (jid.full, inviter.full)
        if reason:
            msg += "because: %s" % reason
        if password:
            msg += ". The password is \"%s\"." % password
        self.core.information(msg, 'Info')
        if 'invite' in config.get('beep_on').split():
            curses.beep()
        logger.log_roster_change(inviter.full, 'invited you to %s' % jid.full)
        self.core.pending_invites[jid.bare] = inviter.full

    def on_groupchat_decline(self, decline):
        "Mediated invitation declined; skip for now"
        pass

    def on_groupchat_direct_invitation(self, message):
        """
        Direct invitation received
        """
        room = safeJID(message['groupchat_invite']['jid'])
        if room.bare in self.core.pending_invites:
            return

        inviter = message['from']
        reason = message['groupchat_invite']['reason']
        password = message['groupchat_invite']['password']
        continue_ = message['groupchat_invite']['continue']
        msg = "You are invited to the room %s by %s" % (room, inviter.full)

        if password:
            msg += ' (password: "%s")' % password
        if continue_:
            msg += '\nto continue the discussion'
        if reason:
            msg += "\nreason: %s" % reason

        self.core.information(msg, 'Info')
        if 'invite' in config.get('beep_on').split():
            curses.beep()

        self.core.pending_invites[room.bare] = inviter.full
        logger.log_roster_change(inviter.full, 'invited you to %s' % room.bare)

    ### "classic" messages ###

    def on_message(self, message):
        """
        When receiving private message from a muc OR a normal message
        (from one of our contacts)
        """
        if message.xml.find(
                '{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}invite'
        ) is not None:
            return
        if message['type'] == 'groupchat':
            return
        # Differentiate both type of messages, and call the appropriate handler.
        if self.is_known_muc_pm(message, message['from']):
            self.on_groupchat_private_message(message, sent=False)
            return
        self.on_normal_message(message)

    def on_encrypted_message(self, message):
        """
        When receiving an encrypted message
        """
        if message["body"]:
            return # Already being handled by on_message.
        self.on_message(message)

    def on_error_message(self, message):
        """
        When receiving any message with type="error"
        """
        jid_from = message['from']
        for tab in self.core.get_tabs(tabs.MucTab):
            if tab.jid.bare == jid_from.bare:
                if jid_from.full == jid_from.bare:
                    self.core.room_error(message, jid_from.bare)
                else:
                    text = self.core.get_error_message(message)
                    p_tab = self.core.tabs.by_name_and_class(
                        jid_from.full, tabs.PrivateTab)
                    if p_tab:
                        p_tab.add_error(text)
                    else:
                        self.core.information(text, 'Error')
                return
        tab = self.core.get_conversation_by_jid(message['from'], create=False)
        error_msg = self.core.get_error_message(message, deprecated=True)
        if not tab:
            self.core.information(error_msg, 'Error')
            return
        error = '\x19%s}%s\x19o' % (dump_tuple(get_theme().COLOR_CHAR_NACK),
                                    error_msg)
        if not tab.nack_message('\n' + error, message['id'], message['to']):
            tab.add_message(error, typ=0)
            self.core.refresh_window()

    def on_normal_message(self, message):
        """
        When receiving "normal" messages (not a private message from a
        muc participant)
        """
        if message['type'] == 'error':
            return
        elif message['type'] == 'headline' and message['body']:
            return self.core.information(
                '%s says: %s' % (message['from'], message['body']), 'Headline')

        use_xhtml = config.get_by_tabname('enable_xhtml_im',
                                          message['from'].bare)
        tmp_dir = get_image_cache()
        body = xhtml.get_body_from_message_stanza(
            message, use_xhtml=use_xhtml, extract_images_to=tmp_dir)
        if not body:
            if not self.core.xmpp.plugin['xep_0380'].has_eme(message):
                return
            self.core.xmpp.plugin['xep_0380'].replace_body_with_eme(message)
            body = message['body']

        remote_nick = ''
        # normal message, we are the recipient
        if message['to'].bare == self.core.xmpp.boundjid.bare:
            conv_jid = message['from']
            jid = conv_jid
            color = get_theme().COLOR_REMOTE_USER
            # check for a name
            if conv_jid.bare in roster:
                remote_nick = roster[conv_jid.bare].name
            # check for a received nick
            if not remote_nick and config.get('enable_user_nick'):
                if message.xml.find(
                        '{http://jabber.org/protocol/nick}nick') is not None:
                    remote_nick = message['nick']['nick']
            if not remote_nick:
                remote_nick = conv_jid.user
                if not remote_nick:
                    remote_nick = conv_jid.full
            own = False
        # we wrote the message (happens with carbons)
        elif message['from'].bare == self.core.xmpp.boundjid.bare:
            conv_jid = message['to']
            jid = self.core.xmpp.boundjid
            color = get_theme().COLOR_OWN_NICK
            remote_nick = self.core.own_nick
            own = True
        # we are not part of that message, drop it
        else:
            return

        conversation = self.core.get_conversation_by_jid(conv_jid, create=True)
        if isinstance(conversation,
                      tabs.DynamicConversationTab) and conv_jid.resource:
            conversation.lock(conv_jid.resource)

        if not own and not conversation.nick:
            conversation.nick = remote_nick
        elif not own:
            remote_nick = conversation.get_nick()

        if not own:
            conversation.last_remote_message = datetime.now()

        self.core.events.trigger('conversation_msg', message, conversation)
        if not message['body']:
            return
        body = xhtml.get_body_from_message_stanza(
            message, use_xhtml=use_xhtml, extract_images_to=tmp_dir)
        delayed, date = common.find_delayed_tag(message)

        def try_modify():
            if message.xml.find('{urn:xmpp:message-correct:0}replace') is None:
                return False
            replaced_id = message['replace']['id']
            if replaced_id and config.get_by_tabname('group_corrections',
                                                     conv_jid.bare):
                try:
                    conversation.modify_message(
                        body,
                        replaced_id,
                        message['id'],
                        jid=jid,
                        nickname=remote_nick)
                    return True
                except CorrectionError:
                    log.debug('Unable to correct a message', exc_info=True)
            return False

        if not try_modify():
            conversation.add_message(
                body,
                date,
                nickname=remote_nick,
                nick_color=color,
                history=delayed,
                identifier=message['id'],
                jid=jid,
                typ=1)

        if not own and 'private' in config.get('beep_on').split():
            if not config.get_by_tabname('disable_beep', conv_jid.bare):
                curses.beep()
        if self.core.tabs.current_tab is not conversation:
            if not own:
                conversation.state = 'private'
                self.core.refresh_tab_win()
            else:
                conversation.set_state('normal')
                self.core.refresh_tab_win()
        else:
            self.core.refresh_window()

    async def on_0084_avatar(self, msg):
        jid = msg['from'].bare
        contact = roster[jid]
        if not contact:
            return
        log.debug('Received 0084 avatar update from %s', jid)
        try:
            metadata = msg['pubsub_event']['items']['item']['avatar_metadata'][
                'items']
        except Exception:
            log.debug('Failed getting metadata from 0084:', exc_info=True)
            return
        for info in metadata:
            avatar_hash = info['id']

            # First check whether we have it in cache.
            cached_avatar = self.core.avatar_cache.retrieve_by_jid(
                jid, avatar_hash)
            if cached_avatar:
                contact.avatar = cached_avatar
                log.debug('Using cached avatar for %s', jid)
                return

            # If we didn’t have any, query the data instead.
            if not info['url']:
                try:
                    result = await self.core.xmpp['xep_0084'].retrieve_avatar(
                        jid, avatar_hash, timeout=60)
                    avatar = result['pubsub']['items']['item']['avatar_data'][
                        'value']
                    if sha1(avatar).hexdigest().lower() != avatar_hash.lower():
                        raise Exception('Avatar sha1 doesn’t match 0084 hash.')
                    contact.avatar = avatar
                except Exception:
                    log.debug(
                        'Failed retrieving 0084 data from %s:',
                        jid,
                        exc_info=True)
                    continue
                log.debug('Received %s avatar: %s', jid, info['type'])

                # Now we save the data on the file system to not have to request it again.
                if not self.core.avatar_cache.store_by_jid(
                        jid, avatar_hash, contact.avatar):
                    log.debug(
                        'Failed writing %s’s avatar to cache:',
                        jid,
                        exc_info=True)
                return

    async def on_vcard_avatar(self, pres):
        jid = pres['from'].bare
        contact = roster[jid]
        if not contact:
            return
        avatar_hash = pres['vcard_temp_update']['photo']
        log.debug('Received vCard avatar update from %s: %s', jid, avatar_hash)

        # First check whether we have it in cache.
        cached_avatar = self.core.avatar_cache.retrieve_by_jid(
            jid, avatar_hash)
        if cached_avatar:
            contact.avatar = cached_avatar
            log.debug('Using cached avatar for %s', jid)
            return

        # If we didn’t have any, query the vCard instead.
        try:
            result = await self.core.xmpp['xep_0054'].get_vcard(
                jid, cached=True, timeout=60)
            avatar = result['vcard_temp']['PHOTO']
            binval = avatar['BINVAL']
            if sha1(binval).hexdigest().lower() != avatar_hash.lower():
                raise Exception('Avatar sha1 doesn’t match 0153 hash.')
            contact.avatar = binval
        except Exception:
            log.debug('Failed retrieving vCard from %s:', jid, exc_info=True)
            return
        log.debug('Received %s avatar: %s', jid, avatar['TYPE'])

        # Now we save the data on the file system to not have to request it again.
        if not self.core.avatar_cache.store_by_jid(jid, avatar_hash,
                                                   contact.avatar):
            log.debug(
                'Failed writing %s’s avatar to cache:', jid, exc_info=True)

    def on_nick_received(self, message):
        """
        Called when a pep notification for a user nickname
        is received
        """
        contact = roster[message['from'].bare]
        if not contact:
            return
        item = message['pubsub_event']['items']['item']
        if item.xml.find('{http://jabber.org/protocol/nick}nick') is not None:
            contact.name = item['nick']['nick']
        else:
            contact.name = ''

    def on_gaming_event(self, message):
        """
        Called when a pep notification for user gaming
        is received
        """
        contact = roster[message['from'].bare]
        if not contact:
            return
        item = message['pubsub_event']['items']['item']
        old_gaming = contact.gaming
        if item.xml.find('{urn:xmpp:gaming:0}gaming') is not None:
            item = item['gaming']
            # only name and server_address are used for now
            contact.gaming = {
                'character_name': item['character_name'],
                'character_profile': item['character_profile'],
                'name': item['name'],
                'level': item['level'],
                'uri': item['uri'],
                'server_name': item['server_name'],
                'server_address': item['server_address'],
            }
        else:
            contact.gaming = {}

        if contact.gaming:
            logger.log_roster_change(
                contact.bare_jid, 'is playing %s' %
                (common.format_gaming_string(contact.gaming)))

        if old_gaming != contact.gaming and config.get_by_tabname(
                'display_gaming_notifications', contact.bare_jid):
            if contact.gaming:
                self.core.information(
                    '%s is playing %s' % (contact.bare_jid,
                                          common.format_gaming_string(
                                              contact.gaming)), 'Gaming')
            else:
                self.core.information(contact.bare_jid + ' stopped playing.',
                                      'Gaming')

    def on_mood_event(self, message):
        """
        Called when a pep notification for a user mood
        is received.
        """
        contact = roster[message['from'].bare]
        if not contact:
            return
        roster.modified()
        item = message['pubsub_event']['items']['item']
        old_mood = contact.mood
        if item.xml.find('{http://jabber.org/protocol/mood}mood') is not None:
            mood = item['mood']['value']
            if mood:
                mood = pep.MOODS.get(mood, mood)
                text = item['mood']['text']
                if text:
                    mood = '%s (%s)' % (mood, text)
                contact.mood = mood
            else:
                contact.mood = ''
        else:
            contact.mood = ''

        if contact.mood:
            logger.log_roster_change(contact.bare_jid,
                                     'has now the mood: %s' % contact.mood)

        if old_mood != contact.mood and config.get_by_tabname(
                'display_mood_notifications', contact.bare_jid):
            if contact.mood:
                self.core.information(
                    'Mood from ' + contact.bare_jid + ': ' + contact.mood,
                    'Mood')
            else:
                self.core.information(
                    contact.bare_jid + ' stopped having their mood.', 'Mood')

    def on_activity_event(self, message):
        """
        Called when a pep notification for a user activity
        is received.
        """
        contact = roster[message['from'].bare]
        if not contact:
            return
        roster.modified()
        item = message['pubsub_event']['items']['item']
        old_activity = contact.activity
        if item.xml.find(
                '{http://jabber.org/protocol/activity}activity') is not None:
            try:
                activity = item['activity']['value']
            except ValueError:
                return
            if activity[0]:
                general = pep.ACTIVITIES.get(activity[0])
                s = general['category']
                if activity[1]:
                    s = s + '/' + general.get(activity[1], 'other')
                text = item['activity']['text']
                if text:
                    s = '%s (%s)' % (s, text)
                contact.activity = s
            else:
                contact.activity = ''
        else:
            contact.activity = ''

        if contact.activity:
            logger.log_roster_change(
                contact.bare_jid, 'has now the activity %s' % contact.activity)

        if old_activity != contact.activity and config.get_by_tabname(
                'display_activity_notifications', contact.bare_jid):
            if contact.activity:
                self.core.information(
                    'Activity from ' + contact.bare_jid + ': ' +
                    contact.activity, 'Activity')
            else:
                self.core.information(
                    contact.bare_jid + ' stopped doing their activity.',
                    'Activity')

    def on_tune_event(self, message):
        """
        Called when a pep notification for a user tune
        is received
        """
        contact = roster[message['from'].bare]
        if not contact:
            return
        roster.modified()
        item = message['pubsub_event']['items']['item']
        old_tune = contact.tune
        if item.xml.find('{http://jabber.org/protocol/tune}tune') is not None:
            item = item['tune']
            contact.tune = {
                'artist': item['artist'],
                'length': item['length'],
                'rating': item['rating'],
                'source': item['source'],
                'title': item['title'],
                'track': item['track'],
                'uri': item['uri']
            }
        else:
            contact.tune = {}

        if contact.tune:
            logger.log_roster_change(
                message['from'].bare, 'is now listening to %s' %
                common.format_tune_string(contact.tune))

        if old_tune != contact.tune and config.get_by_tabname(
                'display_tune_notifications', contact.bare_jid):
            if contact.tune:
                self.core.information(
                    'Tune from ' + message['from'].bare + ': ' +
                    common.format_tune_string(contact.tune), 'Tune')
            else:
                self.core.information(
                    contact.bare_jid + ' stopped listening to music.', 'Tune')

    def on_groupchat_message(self, message):
        """
        Triggered whenever a message is received from a multi-user chat room.
        """
        room_from = message['from'].bare

        if message['type'] == 'error':  # Check if it's an error
            self.core.room_error(message, room_from)
            return

        tab = self.core.tabs.by_name_and_class(room_from, tabs.MucTab)
        if not tab:
            self.core.information(
                "message received for a non-existing room: %s" % (room_from))
            muc.leave_groupchat(
                self.core.xmpp, room_from, self.core.own_nick, msg='')
            return

        nick_from = message['mucnick']
        user = tab.get_user_by_name(nick_from)
        if user and user in tab.ignores:
            return

        self.core.events.trigger('muc_msg', message, tab)
        use_xhtml = config.get_by_tabname('enable_xhtml_im', room_from)
        tmp_dir = get_image_cache()
        body = xhtml.get_body_from_message_stanza(
            message, use_xhtml=use_xhtml, extract_images_to=tmp_dir)
        if not body:
            return

        old_state = tab.state
        delayed, date = common.find_delayed_tag(message)
        replaced = False
        if message.xml.find('{urn:xmpp:message-correct:0}replace') is not None:
            replaced_id = message['replace']['id']
            if replaced_id != '' and config.get_by_tabname(
                    'group_corrections', message['from'].bare):
                try:
                    delayed_date = date or datetime.now()
                    if tab.modify_message(
                            body,
                            replaced_id,
                            message['id'],
                            time=delayed_date,
                            nickname=nick_from,
                            user=user):
                        self.core.events.trigger('highlight', message, tab)
                    replaced = True
                except CorrectionError:
                    log.debug('Unable to correct a message', exc_info=True)
        if not replaced and tab.add_message(
                body,
                date,
                nick_from,
                history=delayed,
                identifier=message['id'],
                jid=message['from'],
                typ=1):
            self.core.events.trigger('highlight', message, tab)

        if message['from'].resource == tab.own_nick:
            tab.last_sent_message = message

        if tab is self.core.tabs.current_tab:
            tab.text_win.refresh()
            tab.info_header.refresh(tab, tab.text_win, user=tab.own_user)
            tab.input.refresh()
            self.core.doupdate()
        elif tab.state != old_state:
            self.core.refresh_tab_win()
            current = self.core.tabs.current_tab
            if hasattr(current, 'input') and current.input:
                current.input.refresh()
            self.core.doupdate()

        if 'message' in config.get('beep_on').split():
            if (not config.get_by_tabname('disable_beep', room_from)
                    and self.core.own_nick != message['from'].resource):
                curses.beep()

    def on_muc_own_nickchange(self, muc):
        "We changed our nick in a MUC"
        for tab in self.core.get_tabs(tabs.PrivateTab):
            if tab.parent_muc == muc:
                tab.own_nick = muc.own_nick

    def on_groupchat_private_message(self, message, sent):
        """
        We received a Private Message (from someone in a Muc)
        """
        jid = message['to'] if sent else message['from']
        with_nick = jid.resource
        if not with_nick:
            self.on_groupchat_message(message)
            return

        room_from = jid.bare
        use_xhtml = config.get_by_tabname('enable_xhtml_im', jid.bare)
        tmp_dir = get_image_cache()
        body = xhtml.get_body_from_message_stanza(
            message, use_xhtml=use_xhtml, extract_images_to=tmp_dir)
        tab = self.core.tabs.by_name_and_class(
            jid.full,
            tabs.PrivateTab)  # get the tab with the private conversation
        ignore = config.get_by_tabname('ignore_private', room_from)
        if not tab:  # It's the first message we receive: create the tab
            if body and not ignore:
                tab = self.core.open_private_window(room_from, with_nick,
                                                    False)
        # Tab can still be None here, when receiving carbons of a MUC-PM for
        # example
        sender_nick = (tab and tab.own_nick
                       or self.core.own_nick) if sent else with_nick
        if ignore and not sent:
            self.core.events.trigger('ignored_private', message, tab)
            msg = config.get_by_tabname('private_auto_response', room_from)
            if msg and body:
                self.core.xmpp.send_message(
                    mto=jid.full, mbody=msg, mtype='chat')
            return
        self.core.events.trigger('private_msg', message, tab)
        body = xhtml.get_body_from_message_stanza(
            message, use_xhtml=use_xhtml, extract_images_to=tmp_dir)
        if not body or not tab:
            return
        replaced = False
        user = tab.parent_muc.get_user_by_name(with_nick)
        if message.xml.find('{urn:xmpp:message-correct:0}replace') is not None:
            replaced_id = message['replace']['id']
            if replaced_id != '' and config.get_by_tabname(
                    'group_corrections', room_from):
                try:
                    tab.modify_message(
                        body,
                        replaced_id,
                        message['id'],
                        user=user,
                        jid=message['from'],
                        nickname=sender_nick)
                    replaced = True
                except CorrectionError:
                    log.debug('Unable to correct a message', exc_info=True)
        if not replaced:
            tab.add_message(
                body,
                time=None,
                nickname=sender_nick,
                nick_color=get_theme().COLOR_OWN_NICK if sent else None,
                forced_user=user,
                identifier=message['id'],
                jid=message['from'],
                typ=1)
        if sent:
            tab.last_sent_message = message
        else:
            tab.last_remote_message = datetime.now()

        if not sent and 'private' in config.get('beep_on').split():
            if not config.get_by_tabname('disable_beep', jid.full):
                curses.beep()
        if tab is self.core.tabs.current_tab:
            self.core.refresh_window()
        else:
            tab.state = 'normal' if sent else 'private'
            self.core.refresh_tab_win()

    ### Chatstates ###

    def on_chatstate_active(self, message):
        self._on_chatstate(message, "active")

    def on_chatstate_inactive(self, message):
        self._on_chatstate(message, "inactive")

    def on_chatstate_composing(self, message):
        self._on_chatstate(message, "composing")

    def on_chatstate_paused(self, message):
        self._on_chatstate(message, "paused")

    def on_chatstate_gone(self, message):
        self._on_chatstate(message, "gone")

    def _on_chatstate(self, message, state):
        if message['type'] == 'chat':
            if not self._on_chatstate_normal_conversation(message, state):
                tab = self.core.tabs.by_name_and_class(message['from'].full,
                                                       tabs.PrivateTab)
                if not tab:
                    return
                self._on_chatstate_private_conversation(message, state)
        elif message['type'] == 'groupchat':
            self.on_chatstate_groupchat_conversation(message, state)

    def _on_chatstate_normal_conversation(self, message, state):
        tab = self.core.get_conversation_by_jid(message['from'], False)
        if not tab:
            return False
        self.core.events.trigger('normal_chatstate', message, tab)
        tab.chatstate = state
        if state == 'gone' and isinstance(tab, tabs.DynamicConversationTab):
            tab.unlock()
        if tab == self.core.tabs.current_tab:
            tab.refresh_info_header()
            self.core.doupdate()
        else:
            _composing_tab_state(tab, state)
            self.core.refresh_tab_win()
        return True

    def _on_chatstate_private_conversation(self, message, state):
        """
        Chatstate received in a private conversation from a MUC
        """
        tab = self.core.tabs.by_name_and_class(message['from'].full,
                                               tabs.PrivateTab)
        if not tab:
            return
        self.core.events.trigger('private_chatstate', message, tab)
        tab.chatstate = state
        if tab == self.core.tabs.current_tab:
            tab.refresh_info_header()
            self.core.doupdate()
        else:
            _composing_tab_state(tab, state)
            self.core.refresh_tab_win()

    def on_chatstate_groupchat_conversation(self, message, state):
        """
        Chatstate received in a MUC
        """
        nick = message['mucnick']